diff --git a/.githooks/pre-push b/.githooks/pre-push
new file mode 100755
index 0000000..1199790
--- /dev/null
+++ b/.githooks/pre-push
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+#
+# Auto-bump the patch version on every push of a branch, so each pushed build
+# is a distinct version. Releases stay manual (they are cut by pushing a v* tag,
+# which this hook deliberately skips).
+#
+# git can't add a commit to a push that is already in flight, so this hook:
+#   1. bumps package.json / Cargo.toml / tauri.conf.json / Cargo.lock,
+#   2. commits the bump onto the current branch,
+#   3. re-runs the push (which carries the bump), and
+#   4. aborts the original push, now superseded by the re-push.
+#
+# Enable once with:  git config core.hooksPath .githooks
+set -euo pipefail
+
+# Guard against the recursion from our own re-push below.
+[ -n "${ELDRUN_BUMPING:-}" ] && exit 0
+
+remote="$1"
+
+repo_root="$(git rev-parse --show-toplevel)"
+
+# stdin: <local-ref> <local-sha> <remote-ref> <remote-sha> per pushed ref.
+# Bump only when pushing a branch whose version still matches what is already on
+# the remote (or a brand-new remote branch). This skips:
+#   - pure tag / deletion pushes (e.g. `git push origin v0.1.8` to cut a release),
+#   - pushes where the version was already advanced manually (minor/major bump),
+# so the version on the remote strictly increases on each push without ever
+# double-bumping.
+pkg_version() { git show "$1:package.json" 2>/dev/null | jq -r '.version // empty' 2>/dev/null; }
+
+bump=0
+while read -r local_ref local_sha _remote_ref remote_sha; do
+  case "$local_ref" in
+    refs/tags/*|"") continue ;;   # tag or deletion — leave version alone
+    refs/*) : ;;
+    *) continue ;;
+  esac
+  if [[ "$remote_sha" =~ ^0+$ ]]; then
+    bump=1                        # new branch on the remote — give it a fresh version
+  elif [ "$(pkg_version "$local_sha")" = "$(pkg_version "$remote_sha")" ]; then
+    bump=1                        # version unchanged since last push — bump it
+  fi
+done
+
+[ "$bump" -eq 0 ] && exit 0
+
+new="$("$repo_root/scripts/bump-version.sh" patch)"
+
+# Cargo.lock carries the workspace's own version too, so it is part of the bump
+# — staged with the rest or the bump commit leaves the tree dirty behind it.
+# `--` and the explicit list keep this to the version files: a push must never
+# sweep up whatever else happens to be in the working tree.
+git -C "$repo_root" add -- \
+  package.json src-tauri/Cargo.toml src-tauri/tauri.conf.json Cargo.lock
+git -C "$repo_root" commit -m "chore: bump version to v${new}" >/dev/null
+
+echo "pre-push: bumped version to v${new}; pushing with the bump included…" >&2
+ELDRUN_BUMPING=1 git push "$remote" HEAD
+echo "pre-push: pushed v${new}. The 'failed to push' line below is the original" >&2
+echo "          pre-bump push being intentionally aborted — the push succeeded." >&2
+
+# The re-push above already sent the bump commit; stop the original (stale) push.
+exit 1
diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
index 509eeec..dd088a9 100644
--- a/.github/workflows/ci-cd.yml
+++ b/.github/workflows/ci-cd.yml
@@ -52,11 +52,9 @@ jobs:
       - name: Run backend tests
         run: cargo test --manifest-path src-tauri/Cargo.toml
 
-  package-windows:
-    name: package-windows
+  test-windows:
+    name: test-windows
     runs-on: windows-latest
-    if: github.event_name == 'push'
-    needs: test
 
     steps:
       - name: Checkout
@@ -79,9 +77,70 @@ jobs:
       - name: Install frontend dependencies
         run: npm ci
 
+      - name: Build frontend
+        run: npm run build
+
+      - name: Run backend tests
+        run: cargo test --manifest-path src-tauri/Cargo.toml
+
+  test-macos:
+    name: test-macos
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          cache: npm
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: ./src-tauri -> target
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Build frontend
+        run: npm run build
+
       - name: Run backend tests
         run: cargo test --manifest-path src-tauri/Cargo.toml
 
+  package-windows:
+    name: package-windows
+    runs-on: windows-latest
+    if: github.event_name == 'push'
+    needs: test-windows
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          cache: npm
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: ./src-tauri -> target
+
+      - name: Install frontend dependencies
+        run: npm ci
+
       - name: Build release bundles
         run: npm run tauri:build -- --bundles nsis
 
@@ -141,51 +200,181 @@ jobs:
         uses: actions/upload-artifact@v4
         with:
           name: eldrun-${{ github.sha }}-appimage
-          path: src-tauri/target/release/bundle/appimage/*.AppImage
+          # Project-root target/ is a fallback for when CARGO_TARGET_DIR is
+          # overridden by swatinem/rust-cache.
+          path: |
+            src-tauri/target/release/bundle/appimage/*.AppImage
+            target/release/bundle/appimage/*.AppImage
 
       - name: Upload DEB
         uses: actions/upload-artifact@v4
         with:
           name: eldrun-${{ github.sha }}-deb
-          path: src-tauri/target/release/bundle/deb/*.deb
+          # Project-root target/ is a fallback for when CARGO_TARGET_DIR is
+          # overridden by swatinem/rust-cache.
+          path: |
+            src-tauri/target/release/bundle/deb/*.deb
+            target/release/bundle/deb/*.deb
+
+  package-macos:
+    name: package-macos
+    runs-on: macos-latest
+    if: github.event_name == 'push'
+    needs: test-macos
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          cache: npm
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: x86_64-apple-darwin,aarch64-apple-darwin
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: ./src-tauri -> target
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Build release bundles
+        # Unsigned alpha .dmg (matches the unsigned Windows NSIS today). macOS
+        # bundle/window overrides come from src-tauri/tauri.macos.conf.json,
+        # which Tauri auto-merges on macOS. To ship a signed + notarized build
+        # later, import an Apple Developer cert into a keychain in a step above
+        # and set APPLE_SIGNING_IDENTITY + APPLE_ID + APPLE_PASSWORD +
+        # APPLE_TEAM_ID (or APPLE_API_KEY_ID/APPLE_API_ISSUER/APPLE_API_KEY_PATH)
+        # from repo secrets here before running the build.
+        run: npm run tauri:build -- --bundles dmg --target universal-apple-darwin
+
+      - name: Rename universal DMG
+        run: |
+          # Only one of these roots exists (rust-cache redirects CARGO_TARGET_DIR
+          # to the project root), and find exits 1 on the missing one — which the
+          # step's `bash -e` would treat as fatal before `test -n` ever runs.
+          dmg="$(find src-tauri/target target -path '*/universal-apple-darwin/release/bundle/dmg/*.dmg' -print -quit 2>/dev/null || true)"
+          test -n "$dmg"
+          # Name the published asset by version, like the AppImage/deb/exe
+          # bundles do — naming it by commit sha made the macOS asset the only
+          # one a user couldn't match to a release at a glance. Guard the move:
+          # Tauri may already emit exactly this name, and `mv x x` fails.
+          version="$(node -p "require('./package.json').version")"
+          target="$(dirname "$dmg")/Eldrun_${version}_universal.dmg"
+          [ "$dmg" = "$target" ] || mv "$dmg" "$target"
+
+      - name: Upload DMG
+        uses: actions/upload-artifact@v4
+        with:
+          name: eldrun-${{ github.sha }}-macos-universal-dmg
+          path: |
+            src-tauri/target/universal-apple-darwin/release/bundle/dmg/*universal.dmg
+            target/universal-apple-darwin/release/bundle/dmg/*universal.dmg
 
   release:
     name: release
     runs-on: ubuntu-22.04
-    if: startsWith(github.ref, 'refs/tags/v0.') && endsWith(github.ref, '.0')
-    needs: [package, package-windows]
+    needs: [package, package-windows, package-macos]
+    if: >-
+      always() &&
+      startsWith(github.ref, 'refs/tags/v') &&
+      (
+        needs.package.result == 'success' ||
+        needs.package-windows.result == 'success' ||
+        needs.package-macos.result == 'success'
+      )
     permissions:
       contents: write
 
     steps:
       - name: Download AppImage artifact
+        if: needs.package.result == 'success'
         uses: actions/download-artifact@v4
         with:
           name: eldrun-${{ github.sha }}-appimage
           path: release-assets
 
       - name: Download DEB artifact
+        if: needs.package.result == 'success'
         uses: actions/download-artifact@v4
         with:
           name: eldrun-${{ github.sha }}-deb
           path: release-assets
 
       - name: Download Windows NSIS artifact
+        if: needs.package-windows.result == 'success'
         uses: actions/download-artifact@v4
         with:
           name: eldrun-${{ github.sha }}-windows-nsis
           path: release-assets
 
+      - name: Download macOS DMG artifact
+        if: needs.package-macos.result == 'success'
+        uses: actions/download-artifact@v4
+        with:
+          name: eldrun-${{ github.sha }}-macos-universal-dmg
+          path: release-assets
+
+      - name: Build release notes
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+          RELEASE_SHA: ${{ github.sha }}
+          LINUX_RESULT: ${{ needs.package.result }}
+          WINDOWS_RESULT: ${{ needs.package-windows.result }}
+          MACOS_RESULT: ${{ needs.package-macos.result }}
+        run: |
+          {
+            printf 'Eldrun %s — alpha / preview build.\n\n' "$RELEASE_TAG"
+            printf 'Built from commit `%s`.\n\n' "$RELEASE_SHA"
+            printf 'Artifacts:\n'
+
+            if [ "$LINUX_RESULT" = success ]; then
+              printf -- '- Linux: `.AppImage` (portable) and `.deb`\n'
+            else
+              printf -- '- Linux: unavailable (package job: `%s`)\n' "$LINUX_RESULT"
+            fi
+
+            if [ "$WINDOWS_RESULT" = success ]; then
+              printf -- '- Windows: NSIS `.exe` installer\n'
+            else
+              printf -- '- Windows: unavailable (package job: `%s`)\n' "$WINDOWS_RESULT"
+            fi
+
+            if [ "$MACOS_RESULT" = success ]; then
+              printf -- '- macOS: universal Intel/Apple Silicon `.dmg` (unsigned — right-click → Open, or run '
+              printf '`xattr -dr com.apple.quarantine /Applications/Eldrun.app`)\n'
+            else
+              printf -- '- macOS: unavailable (package job: `%s`)\n' "$MACOS_RESULT"
+            fi
+
+            printf '\nThis is an early alpha; expect rough edges.\n'
+          } > release-body.md
+
       - name: Publish GitHub Release
         uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ github.ref_name }}
           name: ${{ github.ref_name }}
-          body: |
-            Eldrun release ${{ github.ref_name }}.
-
-            Built from commit ${{ github.sha }}.
+          # Publish as a full release so the newest tag becomes GitHub's
+          # "Latest" — a pre-release never does, which left the releases page
+          # with no latest build and the README's /releases/latest link stale.
+          # The notes still say alpha; this flag is about discoverability.
+          prerelease: false
+          body_path: release-body.md
+          fail_on_unmatched_files: false
+          # Recursive globs: the upload steps list two path patterns, so
+          # upload-artifact roots each artifact at the workspace dir and the
+          # bundle ends up nested (e.g. target/release/bundle/appimage/*.AppImage)
+          # rather than at the artifact root.
           files: |
-            release-assets/*.AppImage
-            release-assets/*.deb
-            release-assets/*.exe
+            release-assets/**/*.AppImage
+            release-assets/**/*.deb
+            release-assets/**/*.exe
+            release-assets/**/*.dmg
diff --git a/.gitignore b/.gitignore
index 28ce37b..5fdac2c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,3 +41,11 @@ src-tauri/WixTools/
 
 # JSON backup files created by storage layer
 *.bak.json
+.env
+.env.local
+*.swp
+*.swo
+.idea/
+
+# Machine-list exports (contain real hostnames)
+eldrun-machines.json
diff --git a/AGENTS.md b/AGENTS.md
index 50a92c2..6a6d967 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,11 +2,29 @@
 
 ## Purpose
 
-ProjectEldrun, or Eldrun, is a Tauri desktop workspace for AI-assisted
+ProjectEldrun, or Eldrun, is a Tauri 2 desktop workspace for AI-assisted
 development. It manages a root control terminal, one terminal per active
-project, a bottom project switcher, a right-side project file browser, global
-app launching, file opening, time tracking, and optional workspace backend
-integration.
+project, a bottom project switcher, a right-side project file viewer, global
+app launching, file opening, time tracking, and optional workspace/backend
+integration in one window.
+
+The product thesis is project-scoped desktop context: opening a project should
+swap the relevant terminals, files, apps, downloads/default-app behavior, and
+time tracking together.
+
+## Load-Bearing Docs
+
+- Root project context: `CLAUDE.md`.
+- Frontend file map: `src/CLAUDE.md`.
+- Backend file map: `src-tauri/CLAUDE.md`.
+- Architecture/user documentation: `DOCUMENTATION.md`.
+- Work plan and grouped TODO conventions: `TODO.md` and `todo/`.
+- Remote/multi-host plan: `docs/multi_host_remote_plan.md`.
+- Remote lockstep case matrix: `docs/git_lockstep_case_matrix.md`.
+- Container plan: `docs/docker_projects_plan.md`.
+
+Read the relevant map before editing unfamiliar code. The maps intentionally
+list only load-bearing files; the tree is still the source of truth.
 
 ## Current Architecture
 
@@ -18,8 +36,10 @@ integration.
 - Terminal UI lives in `src/components/terminal/TerminalView.tsx`; terminal
   backend commands live in `src-tauri/src/commands/terminal.rs` and
   `src-tauri/src/terminal/`.
-- File browsing UI lives in `src/components/files/`; filesystem commands live
-  mostly in `src-tauri/src/commands/projects.rs`.
+- File browsing/viewing UI lives in `src/components/files/` and is shared by
+  the right panel, Files tabs, and per-subwindow file sidebars.
+- Filesystem commands live mostly in `src-tauri/src/commands/projects.rs` and
+  `src-tauri/src/commands/fs.rs`.
 - External app launching and tracked windows live in
   `src-tauri/src/commands/apps.rs`.
 - Settings and persisted schema types live in `src/stores/`, `src/types/`, and
@@ -33,68 +53,198 @@ integration.
 - Managed projects normally live under `~/eldrun/projects/<sanitized-name>/`.
   The root terminal uses `~/eldrun/root/`.
 - Global state lives in `~/.local/share/eldrun/`, especially `projects.json`,
-  `settings.json`, `default_apps.json`, `time_log.json`, and
-  `active_session.json`.
-- Project-local state lives in each project's `project.json`; current open-app
-  metadata is stored in `project.json["open_apps"]`.
+  `settings.json`, `default_apps.json`, `time_log.json`,
+  `active_session.json`, and `usage_stats.json`.
+- Usage stats are local-only rolling hour/day counters behind the daily recap.
+  Do not mix them with time (`time_summary.json`), network bytes
+  (`net_usage.json`), or git stats, which are read from their own sources.
+- Project-local state lives in each project's `project.json`. This includes
+  `open_apps`, `tab_layout`, `tab_groups`, remote specs, runtime/container
+  settings, and per-project file-viewer settings.
 - New/imported projects are scaffolded with `AGENTS.md`, `CLAUDE.md`,
   `GEMINI.md`, `.claude/settings.json`, `.gitignore`, `TODO.md`, `ROADMAP.md`,
-  `STATUS.md`, and `DOCUMENTATION.md`.
+  `STATUS.md`, and `README.md` when missing.
+- Box agent docs contain generated link blocks between
+  `<!-- eldrun:box-links:start -->` and `<!-- eldrun:box-links:end -->`; preserve
+  user edits outside those blocks.
 - `TODO.md` uses grouped IDs such as `G1.1`. When adding a TODO, place it in
   the matching group, create a new group if no current group fits, or merge
   groups if the TODO depends on distinct areas that should be tracked together.
 - Avoid unrelated rewrites in docs, generated state, built assets, project
   metadata, `dist/`, `target/`, and backup files.
 
-## Development Workflow
+## Runtime Safety
 
-- Prefer small, focused changes that match the existing React/TypeScript and
-  Rust/Tauri style.
-- Use `rg` for code search.
 - Do not launch Eldrun from an agent terminal for verification. Opening a
-  second Eldrun instance can corrupt workspace state; ask the user to run or
-  restart the existing instance when runtime validation is needed.
+  second Eldrun instance can corrupt workspace state.
 - Do not run `npm run tauri`, `npm run dev`, `cargo tauri dev`, or
   `./start-eldrun-tauri.sh` unless the user explicitly asks and confirms it is
   safe to launch a new instance.
+- Frontend (`src/`) changes hot-reload in the running instance, so do not ask
+  the user to restart just to see TSX/CSS edits.
+- Backend (`src-tauri/`) changes require the user to rebuild/restart the
+  existing instance for runtime validation. Ask for that only when runtime QA is
+  needed.
+- Runtime launch commands are human-only by default.
+
+## Development Workflow
+
+- Use `rtk` before shell commands, per the included RTK instructions.
+- Prefer small, focused changes that match the existing React/TypeScript and
+  Rust/Tauri style.
+- Use `rg` for code search.
 - When changing frontend behavior, prefer local component state and existing
   Zustand stores over adding new global state.
 - When changing backend commands, keep Tauri command payload names compatible
   with the camelCase keys used by the frontend.
 - Preserve Python-era JSON shapes where the Rust schema already supports them;
   existing user state should round-trip cleanly.
+- Keep service modules `AppHandle`-free and unit-testable where that is the
+  established boundary.
+- Git commit authors for this public-bound repo must use the GitHub noreply
+  email, never the user's real address.
+
+## Remote, Sync, And Runtime Model
+
+- Remote SSH projects are mount-free. Agent/terminal tabs run on the host over
+  SSH, file browsing/I/O goes over SFTP, and git runs on the host over SSH, all
+  using pooled ControlMaster/SFTP sessions in `services::remote`.
+- Remoteness is explicit: use `services::remote::remote_target_for{,_dir}` and
+  host-aware variants. Do not infer it from path conventions.
+- A remote project's `remote` is the primary host. Extra `compute_hosts` are
+  worker machines for experiments; each has its own pool entry, connection lamp,
+  and tab locality (`host:<id>`).
+- Worker sync is one-way code fan-out from the mirror to the worker for tracked
+  files only. It uses git bundle/reset, never `git clean`, and avoids the
+  bidirectional divergence/local-loss path.
+- Shared-filesystem workers are the default in the add-machine UI. They see the
+  primary folder at their own `remote_path`; do not run git init/reset/fan-out on
+  them. Tabs simply `cd` into the shared folder.
+- Git lockstep owns git-tracked files and moves commits/refs semantically via
+  bundles. Byte-sync owns everything else and moves raw bytes. Keep the
+  `drop_tracked` split intact so the two transports never race for one file.
+- With lockstep on, a saved edit to a tracked file reaches the peer only after
+  it is committed. Do not "fix" this back into continuous byte mirroring.
+- Byte-sync is opt-in per path from the explicit manifest. It does not read
+  `.gitignore`; preview and confirm large scopes before pulling big host trees.
+- Local-loss warnings are file-backed, not events. Destructive background git or
+  sync moves must record through `services::local_loss` so losses surface after
+  relaunch.
+- Passwords are never persisted by default. Saved SSH/OpenVPN credentials are
+  keyed by host/config target, not project id; a blank password can mean "use
+  saved credential".
+- Remote auto-connect and VPN auto-connect must never prompt. Check the
+  silent-connect predicates before attempting them.
+- OpenVPN tunnels are machine-wide. The header `VpnIndicator` owns visibility
+  and lifecycle across projects; project UI must not imply the tunnel is
+  project-scoped.
+- Never elevate for a connect that cannot succeed silently. `pkexec` prompts
+  before OpenVPN validates config/credentials.
+- Containerized projects use one session-lived Docker container per local
+  project and bind-mount the project at the identical absolute path. File
+  viewers/git/usage watchers keep reading host bytes. The toggle is local-only
+  and hidden/refused on unsupported platforms.
+
+## Tabs, Agents, And Restore
+
+- Shell/files tabs restore on relaunch. Claude and Codex agent tabs with a
+  `sessionId` are resumable and restored; Gemini and Vibe restore behavior is
+  more limited unless the relevant code explicitly says otherwise.
+- Eldrun installs Claude/Codex session hooks and also has hook-free Codex
+  binding. Codex user hooks may need one-time trust via `/hooks`.
+- Agent authority has three axes: project container sandbox, tab location
+  (local/primary/worker), and optional Plan/Auto agent mode.
+- `components/tabs/agentModes.ts` is a capability table. Add an agent there only
+  if it has an absolute mode flag and a working resume path for the respawn that
+  mode switching causes.
+- Plan/Auto is a launch flag, persisted per tab, and re-applied when args are
+  rebuilt from layout state. Do not persist raw args as the source of truth.
+
+## Frontend Notes
+
+- The right panel and Files (Project) tab share `ProjectFilesView`; keep file
+  viewer features in the shared component so surfaces do not drift.
+- `ProjectFilesPane` owns the tree/sort/source mechanics; panel/tab hosts own
+  only identity, active state, browsed folder, and chrome slots.
+- Remote/SFTP/git probes must be gated when disconnected; synchronous Tauri
+  commands against a dead session can freeze the window.
+- GPU UI reports whole-device memory and optional sensors from `gpustat`, not
+  only Ollama model memory. Omit missing sensor readings; do not render fake
+  zeroes.
+- File viewer parsers such as YAML and table editing are text-preserving views.
+  Keep edits surgical so comments, delimiters, quoting, and line endings survive.
+- Python Run/Debug opens a terminal tab and asks the backend for interpreter
+  precedence. Do not duplicate interpreter-ranking logic in the frontend.
+- Experimental features should use `useExperimental`; unset flags fall back to
+  debug mode.
+
+## Backend Notes
+
+- `commands/` expose Tauri command handlers; `services/` hold reusable runtime
+  logic; `schema/` mirrors persisted JSON.
+- `services::remote` is the source of truth for SSH/SFTP pooling and host-aware
+  remote resolution.
+- `services::worker_sync` is push-only source-to-worker code sync. Shared-FS
+  workers must be skipped defensively even if a command reaches the service.
+- `services::git_peer` owns lockstep and must preserve the tracked/untracked
+  boundary with byte-sync.
+- `services::openvpn` tracks both headless tunnels and interactive terminal
+  tunnels armed with Eldrun-owned pid files.
+- `services::sandbox` owns Docker runtime lifecycle. Tab close must reap
+  in-container processes via the existing wrapper/pidfile mechanism.
+- Terminal `kill`/`kill_all` must reap the child process subtree, not just the
+  shell leader.
+- Remote GPU snapshots are parsed through the same local `gpustat` parsers so
+  host readings match local readings field-for-field.
 
 ## Verification
 
-Before handing off code changes, run the checks that apply to the files you
-changed:
+Run checks that apply to the files changed before handing off:
 
 ```bash
-npm run build
+rtk npm run build
 ```
 
 ```bash
-cd src-tauri && cargo test
+rtk cargo test --manifest-path src-tauri/Cargo.toml
 ```
 
-If `cargo` is unavailable in the environment, state that clearly in the final
-handoff. For whitespace checks, also run:
+For whitespace checks, also run:
 
 ```bash
-git diff --check
+rtk git diff --check
+```
+
+For frontend-only risky changes, also consider targeted Vitest/TypeScript
+checks if faster than a full build. If `cargo` or another tool is unavailable,
+state that clearly in the final handoff.
+
+Before every push, run the privacy/secret scan on staged changes and stop if it
+reports anything real:
+
+```bash
+rtk git add -A
+rtk scripts/privacy-check.sh
 ```
 
 Every push to GitHub should generate a new packaged artifact from
-`.github/workflows/ci-cd.yml`; the local equivalent is `npm run package`,
-which installs the packaged AppImage outside the checkout so branch switches
-do not affect the running app. GitHub Releases are only published for
-`v0.<minor>.0` tags, so patch-only bumps like `0.1.1 -> 0.1.2` do not create
-new releases.
+`.github/workflows/ci-cd.yml`. The local equivalent is `npm run package`, which
+installs the packaged AppImage outside the checkout so branch switches do not
+affect the running app.
+
+Version bumping is automatic on push when `.githooks/` is enabled with
+`git config core.hooksPath .githooks`: the pre-push hook patch-bumps
+`package.json`, `src-tauri/Cargo.toml`, and `src-tauri/tauri.conf.json`, commits
+that bump, and re-pushes. To bump minor/major, run
+`scripts/bump-version.sh minor|major` and commit before pushing.
+
+GitHub Releases are cut manually only when a `v*` tag is pushed; ordinary branch
+pushes do not publish releases.
 
 ## Running Locally
 
-Human-only by default. Agents must not run these commands while an Eldrun
-instance may already be active.
+Human-only by default. Agents must not run these while an Eldrun instance may
+already be active.
 
 Preferred Tauri launcher:
 
@@ -107,3 +257,6 @@ Development run:
 ```bash
 npm run tauri dev
 ```
+
+Useful keys: `F11` toggles fullscreen; `Super` toggles panels while Eldrun is
+focused.
diff --git a/CLAUDE.md b/CLAUDE.md
index cdcbbaf..a34a38c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -5,8 +5,6 @@ development. It keeps a root control terminal, one terminal per active project,
 a bottom project switcher, a right-side file tree overlay, app launching, time
 tracking, and optional KDE/X11 workspace integration in one window.
 
-Stack: Rust (Tauri 2), React 18, TypeScript, Zustand, xterm.js, Tailwind CSS.
-
 ## Running
 
 Do not launch Eldrun from Claude or any other agent terminal for verification.
@@ -21,164 +19,8 @@ Runtime launch commands are intentionally omitted from this Claude context.
 
 ## File Map
 
-### Frontend (`src/`)
-
-Only the load-bearing files are listed; the tree is the source of truth.
-
-**Entry & shell**
-
-| File | Purpose |
-|------|---------|
-| `src/App.tsx` | Root component, theme injection, global key handlers. |
-| `src/main.tsx` | React entry point. |
-| `src/crashReporter.ts` | Captures/forwards WebKitGTK renderer crashes to the backend. |
-| `src/types/index.ts` | Shared TypeScript types. |
-
-**Layout (`src/components/layout/`)**
-
-| File | Purpose |
-|------|---------|
-| `AppShell.tsx` | Top-level layout: header, center, right-panel wiring. |
-| `HeaderBar.tsx` | Window drag handle + hosts the project switcher in the header. |
-| `GlobalAppBar.tsx` | Global toolbar / app launcher (`GLOBAL_APP_ROLES`). |
-| `GlobalAppMenu.tsx` | Context menu for a global-app toolbar button. |
-| `CenterPanel.tsx` | Tab/subwindow tiling host; keeps all panes mounted across scope switches. |
-| `DetachedCenterPanel.tsx` | Center-panel variant rendered inside a detached OS window. |
-| `DetachedApp.tsx` | Root component for a popped-out/detached subwindow (#42). |
-| `ProjectSwitcher.tsx` | Thin composition root: pill strip + search/dialog/settings wiring. Re-exports scaffold helpers. |
-| `ProjectSearch.tsx` *(in `projects/`)* | Inactive-project/box search box + results popover. |
-| `ProjectDialog.tsx` *(in `projects/`)* | New/Import project dialog incl. SSH + OpenVPN + scaffold-fill sub-flows. |
-| `SettingsPanel.tsx` | Settings dialog + sub-panels (theme/git/layout, global apps, file-type apps, Ollama, shortcuts, help). |
-| `RightPanel.tsx` | File-tree overlay panel (git status/history). |
-| `VpnPasswordPrompt.tsx` | Modal prompting for an OpenVPN password on activation. |
-| `LogoIcon.tsx` | Inline SVG logo. |
-
-**Projects, header widgets, tabs, terminal, files, embed, common**
-
-| File | Purpose |
-|------|---------|
-| `projects/ProjectPill.tsx` | Individual project pill (click/close/drag-reorder/group). |
-| `projects/BoxPill.tsx` | Project-box pill (meta-grouping, #13/#41). |
-| `projects/ActivityCalendar.tsx` | Per-project activity calendar heatmap. |
-| `projects/scaffold.ts` | Pure helpers: name sanitize, SSH-address parse, scaffold/description fill prompts. |
-| `header/Clock.tsx` | Header clock. |
-| `header/AppTimerDisplay.tsx` | Active-project time-tracking readout. |
-| `header/AppResourceDisplay.tsx` | Per-project CPU/resource readout. |
-| `header/ConnTypeIcon.tsx` | Local/remote (SSH) connection-type icon. |
-| `header/StatusLamp.tsx` | Status indicator lamp. |
-| `header/WindowControls.tsx` | Minimize/maximize/close window buttons. |
-| `tabs/TabBar.tsx` | Per-subwindow tab strip (add/rename/close, pointer-based DnD). |
-| `tabs/Subwindow.tsx` | A single tiled subwindow (tab group). |
-| `tabs/commitDrop.ts` / `tabs/commitFileDrop.ts` | Apply a tab/file drag-drop into the layout tree. |
-| `tabs/dragGeometry.ts` | Drop-zone/split geometry math for tab drags. |
-| `terminal/TerminalView.tsx` | xterm.js terminal wrapper + PTY I/O. |
-| `files/FileTree.tsx` | Project file tree with git markers, fs-watch refresh. |
-| `files/FileBrowser.tsx` | File browser pane. |
-| `files/GitHistory.tsx` | Commit history / commit / push UI. |
-| `files/SetDefaultAppDialog.tsx` | Pick the default app for a file type. |
-| `embed/EmbedPane.tsx` | Hosts an embedded external app window. |
-| `embed/FileViewerPane.tsx` | In-app viewers (PDF, image, markdown, code, TeX/SyncTeX). |
-| `common/Dropdown.tsx`, `common/OrbitSpinner.tsx` | Shared primitives. |
-
-**Stores (`src/stores/`), hooks, lib**
-
-| File | Purpose |
-|------|---------|
-| `projects.ts` | Project list, active project, CRUD, `setActive`. |
-| `tabs.ts` | Tab/subwindow layout tree per scope; tab persistence policy. |
-| `boxes.ts` | Project boxes (meta-grouping) CRUD + membership. |
-| `settings.ts` | App settings (theme, default agent, git profile, shortcuts, etc.). |
-| `windows.ts` | Embedded app windows. |
-| `detached.ts` | Detached/popped-out subwindow state (#42). |
-| `drag.ts` | Isolated per-frame drag state (reference for fine-grained selectors). |
-| `activity.ts` | PTY-output activity outside React (`lastOutputByPty`). |
-| `timer.ts` | Per-project time-tracking state. |
-| `linkRouting.ts` | Routing of clicked links/URIs to viewers or external apps. |
-| `pdfSync.ts` | Bidirectional PDF/SyncTeX sync state. |
-| `editorJump.ts` | Cross-pane jump-to-location requests. |
-| `vpnPrompt.ts` | State backing `VpnPasswordPrompt`. |
-| `hooks/useKeyboard.ts` | Global keyboard-shortcut hook. |
-| `lib/shortcuts.ts` | Shortcut definitions, chord parsing/resolution. |
-| `lib/viewers/{fileUtils,markdown,highlight,tex}.ts` | Pure viewer logic (XSS-safe markdown/highlight, TeX, file utils). |
-
-### Backend (`src-tauri/src/`)
-
-**Top level**
-
-| File | Purpose |
-|------|---------|
-| `main.rs` | Tauri app entry point, plugin registration. |
-| `lib.rs` | Command registration (`generate_handler!`), app setup, hook/restore install. |
-| `storage.rs` | JSON persistence helpers (read/write state files). |
-| `paths.rs` | Canonical Eldrun directory paths. |
-| `sysstat.rs` | Per-process CPU sampling via `/proc` (`descendant_pids`). |
-
-**Commands (`commands/`)** — Tauri command handlers exposed to the frontend.
-
-| File | Purpose |
-|------|---------|
-| `projects.rs` | Project CRUD, scaffold/import, time-today (god module; #1). |
-| `fs.rs` | File-I/O commands (read/write/mtime, extracted from `projects.rs`; #1 seam). |
-| `fs_watch.rs` | Filesystem watch start/stop + change events. |
-| `git.rs` | Git status/history/commit/push. |
-| `github.rs` | GitHub repo publishing. |
-| `terminal.rs` | Terminal/PTY command surface (delegates to `terminal/mod.rs`). |
-| `apps.rs` | App launching, `run_script_detached`, `open_file`, external window tracking. |
-| `default_apps.rs` | Per-file-type default-app mapping. |
-| `downloads.rs` | Per-project download routing. |
-| `ssh.rs` | SSH commands for remote projects (`ssh_connect`, `ssh_default_dir`, `ssh_list_dir`, `ensure_project_mounted`). |
-| `openvpn.rs` | OpenVPN tunnel connect/store-config commands. |
-| `ollama.rs` | Ollama model list/pull/delete + local autocomplete. |
-| `tex.rs` | TeX compile + SyncTeX (shell-escape defense). |
-| `boxes.rs` | Project-box CRUD. |
-| `subwindow.rs` | Detached/popped-out subwindow lifecycle (#42). |
-| `timer.rs` | Time-tracking commands. |
-| `workspace.rs` | KDE/X11 workspace switch commands. |
-| `settings.rs` | Settings read/update. |
-| `project_runtime.rs` | Project-switch runtime command wrapper (off-UI-thread). |
-| `crash.rs` | Receives frontend renderer crash reports. |
-| `debug.rs` | Debug-mode helpers. |
-
-**Services (`services/`)** — `AppHandle`-free, unit-testable.
-
-| File | Purpose |
-|------|---------|
-| `ssh_mount.rs` | sshfs mount lifecycle (mount/unmount, mountpoint derivation, arg validation). |
-| `ssh_exec.rs` | Remote command execution over SSH (ControlMaster). |
-| `remote_agents.rs` | Remote agent bootstrap/resume for SSH projects. |
-| `openvpn.rs` | OpenVPN process lifecycle (askpass file, teardown). |
-| `agent_session.rs` | SessionStart hook installer + live-session recording for agent resume. |
-| `project_runtime.rs` | Worker-thread project switch + time flush (`flush_project_secs`). |
-| `restore_service.rs` | Tab/session restore on relaunch. |
-| `terminal_service.rs` | Tab layout save/restore for terminals. |
-| `window_service.rs` | Window-state helpers. |
-
-**Platform (`platform/`)** — `WorkspaceBackend` strategy.
-
-| File | Purpose |
-|------|---------|
-| `x11.rs` | X11 workspace / window management via xlib. |
-| `wayland_kde.rs` | KDE Wayland backend via KWin scripting + DBus (show/hide stub, #18). |
-| `windows.rs` | Windows backend (stub). |
-| `null.rs` | No-op platform fallback. |
-
-**Schema (`schema/`)** — Serde structs mirroring the JSON state files.
-
-| File | Purpose |
-|------|---------|
-| `projects.rs` / `project.rs` | `projects.json` entries + per-project `project.json`. |
-| `settings.rs` | `settings.json`. |
-| `default_apps.rs` | `default_apps.json`. |
-| `time_log.rs` | `time_log.json` (unbounded `Vec`; Efficiency #2/#12). |
-| `boxes.rs` | Project boxes. |
-| `session.rs` | Live/restorable session state. |
-| `active_session.rs` | Defined but **not yet wired** (TODO Group F #24). |
-
-**Terminal (`terminal/`)**
-
-| File | Purpose |
-|------|---------|
-| `mod.rs` | PTY lifecycle + agent-session resolvers (`resolve_{claude,codex}_session`). |
+Frontend file map: `src/CLAUDE.md`. Backend file map: `src-tauri/CLAUDE.md`.
+Both list only the load-bearing files; the tree is the source of truth.
 
 ## Persistence
 
@@ -187,28 +29,6 @@ Only the load-bearing files are listed; the tree is the source of truth.
 - Global Eldrun state lives in `~/.local/share/eldrun/`:
   `projects.json`, `settings.json`, `default_apps.json`, `time_log.json`, and
   `active_session.json`.
-- Remote (SSH) projects are sshfs-mounted under
-  `~/.local/share/eldrun/mounts/<project-id>/`; that mountpoint becomes the
-  project's `directory`. Such projects carry a `remote` spec (`user?`, `host`,
-  `port?`, `remote_path`) in their `project.json` and mirrored into the
-  `projects.json` entry's `extra`. Requires `sshfs`/FUSE locally.
-- Project-local state lives in each project's `project.json`. This includes the
-  per-project tab layout (`tab_layout`/`tab_groups`). Shell/files tabs are always
-  restored on relaunch; agent tabs are normally dropped, **except resumable agent
-  tabs** — Claude and Codex tabs that carry a `sessionId` are persisted (with
-  their `sessionId`) and restored, respawning the agent so the prior conversation
-  comes back (see `isRestorableTab`/`RESUMABLE_AGENTS` in `src/stores/tabs.ts`).
-  Mechanism (`services/agent_session.rs`, installed at startup): Eldrun installs a
-  `SessionStart` hook — into `~/.claude/settings.json` (JSON) and
-  `~/.codex/config.toml` (TOML text-append) — that records each tab's live
-  `session_id` under `~/.local/share/eldrun/live_sessions/<key>`, keyed by the
-  `ELDRUN_TAB_UID` env var Eldrun sets on the agent. At spawn,
-  `terminal::resolve_{claude,codex}_session` reads that to resume the *current*
-  session, following a `/clear`. For Claude the key is its launch id
-  (`--session-id`); Codex mints its own id so the key is a separate per-tab uuid
-  and the backend injects `codex resume <live-id>`. **Codex caveat:** user-level
-  Codex hooks need a one-time trust (`/hooks` in Codex) before they run. Gemini
-  and Vibe are still dropped (TODO 39d).
 - New/imported projects receive `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`,
   `.claude/settings.json`, `.gitignore`, `TODO.md`, `ROADMAP.md`, `STATUS.md`,
   and `README.md` when missing.
@@ -216,22 +36,36 @@ Only the load-bearing files are listed; the tree is the source of truth.
   matching group, create a new group if no current group fits, or merge groups
   if the TODO depends on distinct areas that should be tracked together.
 
+### Topic docs (read only when the task touches them)
+
+Each `docs/context/*.md` file below holds the full design rationale for one
+subsystem — load-bearing detail on *why* it works the way it does, not
+discoverable from the code alone. Don't read these speculatively; open the one
+matching the area you're touching.
+
+- **Usage stats** — local-only rolling counters behind the daily recap; what's counted where and why. `docs/context/usage_stats.md`
+- **Remote projects** — SSH/SFTP-native, mount-free: how files/git/terminals work with no sshfs. `docs/context/remote_projects.md`
+- **Git lockstep + byte-sync** — the two transports keeping a remote mirror in step, local-loss warnings, lockstep's safe-default rules, byte-sync's opt-in scope and big-folder census. `docs/context/git_sync.md`
+- **Remote credentials & host security** — locked-keychain handling, password persistence opt-in, SSH_ASKPASS argv hardening, first-contact host-key confirmation. `docs/context/remote_credentials.md`
+- **Remote auto-connect** — when a remote project connects itself on launch/activation, headless vs. non-headless behavior, VPN-needed probing. `docs/context/remote_autoconnect.md`
+- **OpenVPN tunnel** — machine-wide (not project-scoped) lifecycle, connect-on-launch, pre-flight silent-connect check, single-polkit-prompt teardown. `docs/context/openvpn.md`
+- **Agent session persistence** — how resumable Claude/Codex tabs survive relaunch via the SessionStart hook mechanism. `docs/context/agent_sessions.md`
+- **Multi-host remote (compute hosts)** — a remote project's worker machines: push-only code sync, read-only files, pull-outputs, shared-filesystem mode. `docs/context/multi_host_remote.md`
+- **tmux session persistence** — shell/script tabs surviving SSH drops and Eldrun crashes; the Sessions view. `docs/context/tmux_sessions.md`
+- **Docker project containers** — per-project session container, toggle semantics, lifecycle. `docs/context/docker_containers.md`
+- **Agent authority axes** — sandbox / tab location / agentMode (Plan vs Auto) and how they compose. `docs/context/agent_authority.md`
+- **Careful mode on HPC hosts** — what the monitor/usage probes stop collecting on a cluster login node and why (usage rules, login-node load), how a host is classified. `docs/context/hpc_careful_mode.md`
+
 ## Dev Workflow
 
 1. Edit files under `src/` (frontend) or `src-tauri/src/` (backend).
-2. Type-check frontend:
-
-```bash
-npx tsc --noEmit
-```
-
-3. Run Rust tests:
+2. Run Rust tests:
 
 ```bash
 cargo test --manifest-path src-tauri/Cargo.toml
 ```
 
-4. **Privacy check before every push.** This repo is intended to go public, so
+3. **Privacy check before every push.** This repo is intended to go public, so
    before pushing run the privacy/secret scan on the staged changes and stop if
    it reports anything real:
 
@@ -244,15 +78,24 @@ cargo test --manifest-path src-tauri/Cargo.toml
    this doc nor the script hardcodes or self-matches the literals it catches).
    Commits must use the GitHub `noreply` author email, never the real address.
 
-5. Every push to GitHub should produce a fresh packaged artifact from the
+4. Every push to GitHub should produce a fresh packaged artifact from the
    workflow in `.github/workflows/ci-cd.yml`; use `npm run package` locally if
    you need to install the same release build under `~/.local/share/eldrun/`.
-   GitHub Releases are only published for `v0.<minor>.0` tags, so patch-only
-   bumps like `0.1.1 -> 0.1.2` do not create a release.
 
-6. Do not start Eldrun from Claude. Frontend (`src/`) edits hot-reload in the
-   running instance — no restart needed. Only ask the user to rebuild/restart
-   for backend (`src-tauri/`) changes.
+   **Version bumping is automatic on push.** The tracked `pre-push` hook in
+   `.githooks/` auto-bumps the patch version across `package.json`,
+   `src-tauri/Cargo.toml`, and `src-tauri/tauri.conf.json` (via
+   `scripts/bump-version.sh`), commits it, and re-pushes so every push carries a
+   distinct version. Enable it once per clone with
+   `git config core.hooksPath .githooks` (`core.hooksPath` is not itself tracked).
+   To bump minor/major instead, run `scripts/bump-version.sh minor|major` and
+   commit before pushing (the hook only patch-bumps when the version is otherwise
+   unchanged for that push).
+
+   **Releases are cut manually.** A GitHub Release is published only when a `v*`
+   tag is pushed (e.g. `v0.1.5`) — the `release` job is gated on `refs/tags/v*`,
+   so ordinary branch pushes never publish. The hook deliberately skips tag
+   pushes, so to ship a release: `git tag v<version> && git push origin v<version>`.
 
 Useful keys: `F11` toggles fullscreen; `Super` toggles panels while Eldrun is
 focused.
diff --git a/Cargo.lock b/Cargo.lock
index 7db2a48..ea0d79a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8,6 +8,17 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -47,6 +58,15 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+dependencies = [
+ "derive_arbitrary",
+]
+
 [[package]]
 name = "arboard"
 version = "3.6.1"
@@ -64,9 +84,19 @@ dependencies = [
  "parking_lot",
  "percent-encoding",
  "windows-sys 0.60.2",
+ "wl-clipboard-rs",
  "x11rb",
 ]
 
+[[package]]
+name = "arc-swap"
+version = "1.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c049c0be4daef0b145cb3555416b3b8ef5b7888a38aea1a3a155801fe7b0810b"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "async-broadcast"
 version = "0.7.2"
@@ -232,6 +262,15 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "atoi_simd"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ad17c7c205c2c28b527b9845eeb91cf1b4d008b438f98ce0e628227a822758e"
+dependencies = [
+ "debug_unsafe",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -244,6 +283,22 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "awaitable"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70af449c9a763cb655c6a1e5338b42d99c67190824ff90658c1e30be844c0775"
+dependencies = [
+ "awaitable-error",
+ "cfg-if",
+]
+
+[[package]]
+name = "awaitable-error"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5b3469636cdf8543cceab175efca534471f36eee12fb8374aba00eb5e7e7f8a"
+
 [[package]]
 name = "base64"
 version = "0.21.7"
@@ -295,6 +350,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "block2"
 version = "0.6.2"
@@ -416,6 +480,23 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "calamine"
+version = "0.35.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8822fe6253ca47aa5ad9a3be09f6fe7cd20c6a74e41b0aa42e8f4e3d523508df"
+dependencies = [
+ "atoi_simd",
+ "byteorder",
+ "codepage",
+ "encoding_rs",
+ "fast-float2",
+ "log",
+ "quick-xml 0.39.4",
+ "serde",
+ "zip 7.2.0",
+]
+
 [[package]]
 name = "camino"
 version = "1.2.2"
@@ -458,6 +539,15 @@ dependencies = [
  "toml 0.9.12+spec-1.1.0",
 ]
 
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cc"
 version = "1.2.64"
@@ -525,6 +615,16 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
 [[package]]
 name = "clipboard-win"
 version = "5.4.1"
@@ -534,6 +634,15 @@ dependencies = [
  "error-code",
 ]
 
+[[package]]
+name = "codepage"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f68d061bc2828ae826206326e61251aca94c1e4a5305cf52d9138639c918b4"
+dependencies = [
+ "encoding_rs",
+]
+
 [[package]]
 name = "combine"
 version = "4.6.7"
@@ -553,6 +662,17 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "concurrent_arena"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a07f0a549fe58f8477a15f0f1c3aa8ced03a3cdeaa38a661530572f21ea963a0"
+dependencies = [
+ "arc-swap",
+ "parking_lot",
+ "triomphe",
+]
+
 [[package]]
 name = "cookie"
 version = "0.18.1"
@@ -563,6 +683,16 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.10.1"
@@ -579,6 +709,19 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "core-graphics"
+version = "0.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa95a34622365fa5bbf40b20b75dba8dfa8c94c734aea8ac9a5ca38af14316f1"
+dependencies = [
+ "bitflags 2.13.0",
+ "core-foundation 0.10.1",
+ "core-graphics-types",
+ "foreign-types",
+ "libc",
+]
+
 [[package]]
 name = "core-graphics"
 version = "0.25.0"
@@ -586,7 +729,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
 dependencies = [
  "bitflags 2.13.0",
- "core-foundation",
+ "core-foundation 0.10.1",
  "core-graphics-types",
  "foreign-types",
  "libc",
@@ -599,7 +742,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
 dependencies = [
  "bitflags 2.13.0",
- "core-foundation",
+ "core-foundation 0.10.1",
  "libc",
 ]
 
@@ -736,6 +879,30 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "dbus-secret-service"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "708b509edf7889e53d7efb0ffadd994cc6c2345ccb62f55cfd6b0682165e4fa6"
+dependencies = [
+ "aes",
+ "block-padding",
+ "cbc",
+ "dbus",
+ "fastrand",
+ "hkdf",
+ "num",
+ "once_cell",
+ "sha2",
+ "zeroize",
+]
+
+[[package]]
+name = "debug_unsafe"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eed2c4702fa172d1ce21078faa7c5203e69f5394d48cc436d25928394a867a2"
+
 [[package]]
 name = "deranged"
 version = "0.5.8"
@@ -745,6 +912,28 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "derive_destructure2"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64b697ac90ff296f0fc031ee5a61c7ac31fb9fff50e3fb32873b09223613fc0c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "derive_more"
 version = "2.1.1"
@@ -774,6 +963,7 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer",
  "crypto-common",
+ "subtle",
 ]
 
 [[package]]
@@ -851,7 +1041,7 @@ checksum = "521e380c0c8afb8d9a1e83a1822ee03556fc3e3e7dbc1fd30be14e37f9cb3f89"
 dependencies = [
  "bit-set",
  "cssparser",
- "foldhash",
+ "foldhash 0.2.0",
  "html5ever",
  "precomputed-hash",
  "selectors",
@@ -873,6 +1063,28 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "drag"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e90b4a25ace5ce0561534b073943594cbcd21af936e64d09aec444568411f8c"
+dependencies = [
+ "core-graphics 0.24.0",
+ "dunce",
+ "gdk",
+ "gdkx11",
+ "gtk",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "raw-window-handle",
+ "serde",
+ "thiserror 2.0.18",
+ "windows 0.52.0",
+ "windows-core 0.58.0",
+]
+
 [[package]]
 name = "dtoa"
 version = "1.0.11"
@@ -917,27 +1129,42 @@ checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
 name = "eldrun"
-version = "0.1.0"
+version = "0.1.40"
 dependencies = [
  "arboard",
+ "base64 0.22.1",
+ "bytes",
+ "calamine",
+ "dbus-secret-service",
+ "futures-util",
+ "gtk",
  "infer",
+ "keyring",
  "libc",
  "mime_guess",
  "notify",
  "opener",
+ "openssh-sftp-client",
+ "plist",
  "png 0.17.16",
  "portable-pty",
+ "rusqlite",
  "serde",
  "serde_json",
+ "serde_yaml",
+ "starship-battery",
  "tauri",
  "tauri-build",
  "tauri-plugin-dialog",
+ "tauri-plugin-drag",
+ "tauri-plugin-notification",
  "tempfile",
  "tokio",
  "webkit2gtk",
- "windows",
+ "windows 0.61.3",
  "xcb",
- "zbus",
+ "zbus 4.4.0",
+ "zip 2.4.2",
 ]
 
 [[package]]
@@ -960,6 +1187,15 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
 
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "endi"
 version = "1.1.1"
@@ -1041,6 +1277,24 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fast-float2"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8eb564c5c7423d25c886fb561d1e4ee69f72354d16918afa32c08811f6b6a55"
+
 [[package]]
 name = "fastrand"
 version = "2.4.1"
@@ -1089,6 +1343,12 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
 version = "1.1.9"
@@ -1097,6 +1357,7 @@ checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
+ "zlib-rs",
 ]
 
 [[package]]
@@ -1105,6 +1366,12 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
 [[package]]
 name = "foldhash"
 version = "0.2.0"
@@ -1558,11 +1825,41 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "foldhash 0.2.0",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5081f264ed7adee96ea4b4778b6bb9da0a7228b084587aa3bd3ff05da7c5a3b"
+dependencies = [
+ "hashbrown 0.17.1",
+]
 
 [[package]]
 name = "heck"
@@ -1588,6 +1885,24 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
 [[package]]
 name = "html5ever"
 version = "0.38.0"
@@ -1889,6 +2204,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
+
 [[package]]
 name = "ipnet"
 version = "2.12.0"
@@ -2012,6 +2337,23 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "keyring"
+version = "3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c"
+dependencies = [
+ "byteorder",
+ "dbus-secret-service",
+ "linux-keyutils",
+ "log",
+ "secret-service",
+ "security-framework 2.11.1",
+ "security-framework 3.7.0",
+ "windows-sys 0.60.2",
+ "zeroize",
+]
+
 [[package]]
 name = "kqueue"
 version = "1.2.0"
@@ -2038,6 +2380,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
 [[package]]
 name = "libappindicator"
 version = "0.9.0"
@@ -2096,6 +2444,27 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "libsqlite3-sys"
+version = "0.38.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6c19a05435c21ac299d71b6a9c13db3e3f47c520517d58990a462a1397a61db"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-keyutils"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83270a18e9f90d0707c41e9f35efada77b64c0e6f3f1810e71c8368a864d5590"
+dependencies = [
+ "bitflags 2.13.0",
+ "libc",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -2124,21 +2493,44 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "953f07c43838f8e6f9758cab68bf5bed85465e7587ebe0b823f1bcd81978ad3a"
 
 [[package]]
-name = "markup5ever"
-version = "0.38.0"
+name = "mac-notification-sys"
+version = "0.6.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
+checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
 dependencies = [
+ "cc",
  "log",
- "tendril",
- "web_atoms",
+ "objc2",
+ "objc2-foundation",
+ "time",
+ "uuid",
 ]
 
 [[package]]
-name = "memchr"
-version = "2.8.2"
+name = "mach2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
+checksum = "6a1b95cd5421ec55b445b5ae102f5ea0e768de1f82bd3001e11f426c269c3aea"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "markup5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
+dependencies = [
+ "log",
+ "tendril",
+ "web_atoms",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "memoffset"
@@ -2273,6 +2665,27 @@ dependencies = [
  "memoffset",
 ]
 
+[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags 2.13.0",
+ "cfg-if",
+ "cfg_aliases 0.2.1",
+ "libc",
+]
+
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "normpath"
 version = "1.5.1"
@@ -2300,6 +2713,20 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "notify-rust"
+version = "4.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5b4c1b4f2aa9f25f63a7a49d3dd0ed567b3670da15330a66b29434be899b891"
+dependencies = [
+ "futures-lite",
+ "log",
+ "mac-notification-sys",
+ "serde",
+ "tauri-winrt-notification",
+ "zbus 5.17.0",
+]
+
 [[package]]
 name = "notify-types"
 version = "2.1.0"
@@ -2309,12 +2736,87 @@ dependencies = [
  "bitflags 2.13.0",
 ]
 
+[[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
 
+[[package]]
+name = "num-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -2364,10 +2866,17 @@ checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
 dependencies = [
  "bitflags 2.13.0",
  "block2",
+ "libc",
  "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
  "objc2-core-foundation",
  "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-text",
+ "objc2-core-video",
  "objc2-foundation",
+ "objc2-quartz-core",
 ]
 
 [[package]]
@@ -2387,6 +2896,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
 dependencies = [
+ "bitflags 2.13.0",
  "objc2",
  "objc2-foundation",
 ]
@@ -2447,6 +2957,19 @@ dependencies = [
  "objc2-core-graphics",
 ]
 
+[[package]]
+name = "objc2-core-video"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6"
+dependencies = [
+ "bitflags 2.13.0",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-io-surface",
+]
+
 [[package]]
 name = "objc2-encode"
 version = "4.1.0"
@@ -2560,6 +3083,81 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "openssh-sftp-client"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a575af2d0eaa7c8f96368924994a3ae1d484fd2b19750cc1049c1100a42e82"
+dependencies = [
+ "bytes",
+ "derive_destructure2",
+ "futures-core",
+ "once_cell",
+ "openssh-sftp-client-lowlevel",
+ "openssh-sftp-error",
+ "pin-project",
+ "scopeguard",
+ "tokio",
+ "tokio-io-utility",
+ "tokio-util",
+]
+
+[[package]]
+name = "openssh-sftp-client-lowlevel"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6d1a0e0eeb46100745a2c383c842042e1f04aa57a9c18aa41a16b6d4d58aeb0"
+dependencies = [
+ "awaitable",
+ "bytes",
+ "concurrent_arena",
+ "derive_destructure2",
+ "openssh-sftp-error",
+ "openssh-sftp-protocol",
+ "pin-project",
+ "tokio",
+ "tokio-io-utility",
+]
+
+[[package]]
+name = "openssh-sftp-error"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12a702f18f0595b4578b21fd120ae7aa45f4298a8b28ddcb2397ace6f5a8251a"
+dependencies = [
+ "awaitable-error",
+ "openssh-sftp-protocol-error",
+ "ssh_format_error",
+ "thiserror 2.0.18",
+ "tokio",
+]
+
+[[package]]
+name = "openssh-sftp-protocol"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9c862e0c56553146306507f55958c11ff554e02c46de287e6976e50d815b350"
+dependencies = [
+ "bitflags 2.13.0",
+ "num-derive",
+ "num-traits",
+ "openssh-sftp-protocol-error",
+ "serde",
+ "ssh_format",
+ "vec-strings",
+]
+
+[[package]]
+name = "openssh-sftp-protocol-error"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42b54df62ccfd9a7708a83a9d60c46293837e478f9f4c0829360dcfa60ede8d2"
+dependencies = [
+ "serde",
+ "thiserror 2.0.18",
+ "vec-strings",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -2576,6 +3174,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "pango"
 version = "0.18.3"
@@ -2636,6 +3244,17 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+]
+
 [[package]]
 name = "phf"
 version = "0.13.1"
@@ -2689,6 +3308,26 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "pin-project"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
@@ -2714,13 +3353,13 @@ checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
 
 [[package]]
 name = "plist"
-version = "1.9.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
+checksum = "740ebea15c5d1428f910cd1a5f52cebf8d25006245ed8ade92702f4943d91e07"
 dependencies = [
  "base64 0.22.1",
  "indexmap 2.14.0",
- "quick-xml 0.39.4",
+ "quick-xml 0.38.4",
  "serde",
  "time",
 ]
@@ -2899,12 +3538,22 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "quick-xml"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quick-xml"
 version = "0.39.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cdcc8dd4e2f670d309a5f0e83fe36dfdc05af317008fea29144da1a2ac858e5e"
 dependencies = [
+ "encoding_rs",
  "memchr",
 ]
 
@@ -2936,8 +3585,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
 dependencies = [
  "libc",
- "rand_chacha",
- "rand_core",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2947,7 +3606,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2959,6 +3628,15 @@ dependencies = [
  "getrandom 0.2.17",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
 [[package]]
 name = "raw-window-handle"
 version = "0.6.2"
@@ -3092,6 +3770,31 @@ dependencies = [
  "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "rsqlite-vfs"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.40.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11438310b19e3109b6446c33d1ed5e889428cf2e278407bc7896bc4aaea43323"
+dependencies = [
+ "bitflags 2.13.0",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec",
+ "sqlite-wasm-rs",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.2"
@@ -3126,6 +3829,12 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -3193,37 +3902,92 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "selectors"
-version = "0.36.1"
+name = "secret-service"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
+checksum = "e4d35ad99a181be0a60ffcbe85d680d98f87bdc4d7644ade319b87076b9dbfd4"
 dependencies = [
- "bitflags 2.13.0",
- "cssparser",
- "derive_more",
- "log",
- "new_debug_unreachable",
- "phf",
- "phf_codegen",
- "precomputed-hash",
- "rustc-hash",
- "servo_arc",
- "smallvec",
+ "aes",
+ "cbc",
+ "futures-util",
+ "generic-array",
+ "hkdf",
+ "num",
+ "once_cell",
+ "rand 0.8.6",
+ "serde",
+ "sha2",
+ "zbus 4.4.0",
 ]
 
 [[package]]
-name = "semver"
-version = "1.0.28"
+name = "security-framework"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "serde",
- "serde_core",
+ "bitflags 2.13.0",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
 ]
 
 [[package]]
-name = "serde"
-version = "1.0.228"
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.13.0",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "selectors"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
+dependencies = [
+ "bitflags 2.13.0",
+ "cssparser",
+ "derive_more",
+ "log",
+ "new_debug_unreachable",
+ "phf",
+ "phf_codegen",
+ "precomputed-hash",
+ "rustc-hash",
+ "servo_arc",
+ "smallvec",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
@@ -3348,6 +4112,19 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.14.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
 [[package]]
 name = "serial2"
 version = "0.2.37"
@@ -3526,12 +4303,62 @@ dependencies = [
  "system-deps",
 ]
 
+[[package]]
+name = "sqlite-wasm-rs"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc3efc0da82635d7e1ced0053bbbfa8c7ab9645d0bf36ceb4f7127bb85315d75"
+dependencies = [
+ "cc",
+ "js-sys",
+ "rsqlite-vfs",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ssh_format"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24ab31081d1c9097c327ec23550858cb5ffb4af6b866c1ef4d728455f01f3304"
+dependencies = [
+ "bytes",
+ "serde",
+ "ssh_format_error",
+]
+
+[[package]]
+name = "ssh_format_error"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be3c6519de7ca611f71ef7e8a56eb57aa1c818fecb5242d0a0f39c83776c210c"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
+[[package]]
+name = "starship-battery"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd0efc2c44c92705be724265a0c758e3b7c120ea63817d2d684bab86fbeced9a"
+dependencies = [
+ "cfg-if",
+ "core-foundation 0.10.1",
+ "lazycell",
+ "libc",
+ "mach2",
+ "nix 0.30.1",
+ "num-traits",
+ "plist",
+ "uom",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -3568,6 +4395,12 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
 [[package]]
 name = "swift-rs"
 version = "1.0.7"
@@ -3641,8 +4474,8 @@ checksum = "d1c93047acf68669466a34690ac58cca7010bd1b201e1ec86f1fd0a75d3dd4a9"
 dependencies = [
  "bitflags 2.13.0",
  "block2",
- "core-foundation",
- "core-graphics",
+ "core-foundation 0.10.1",
+ "core-graphics 0.25.0",
  "crossbeam-channel",
  "dbus",
  "dispatch2",
@@ -3667,7 +4500,7 @@ dependencies = [
  "tao-macros",
  "unicode-segmentation",
  "url",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
  "windows-version",
  "x11-dl",
@@ -3738,7 +4571,7 @@ dependencies = [
  "webkit2gtk",
  "webview2-com",
  "window-vibrancy",
- "windows",
+ "windows 0.61.3",
 ]
 
 [[package]]
@@ -3837,6 +4670,21 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "tauri-plugin-drag"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "729ca0ce4b1169869d3405216d3c09a524f41ea5e2eec89f917cd6623f8a70ca"
+dependencies = [
+ "base64 0.22.1",
+ "drag",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "tauri-plugin-fs"
 version = "2.5.1"
@@ -3861,6 +4709,25 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "tauri-plugin-notification"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01fc2c5ff41105bd1f7242d8201fdf3efd70749b82fa013a17f2126357d194cc"
+dependencies = [
+ "log",
+ "notify-rust",
+ "rand 0.9.5",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+]
+
 [[package]]
 name = "tauri-runtime"
 version = "2.11.3"
@@ -3883,7 +4750,7 @@ dependencies = [
  "url",
  "webkit2gtk",
  "webview2-com",
- "windows",
+ "windows 0.61.3",
 ]
 
 [[package]]
@@ -3908,7 +4775,7 @@ dependencies = [
  "url",
  "webkit2gtk",
  "webview2-com",
- "windows",
+ "windows 0.61.3",
  "wry",
 ]
 
@@ -3961,6 +4828,17 @@ dependencies = [
  "toml 1.1.2+spec-1.1.0",
 ]
 
+[[package]]
+name = "tauri-winrt-notification"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed071c670382e85fc2f48ae706492d8c338f4f89bf72520d32f8abfe880aade"
+dependencies = [
+ "thiserror 2.0.18",
+ "windows 0.61.3",
+ "windows-version",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.27.0"
@@ -3984,6 +4862,12 @@ dependencies = [
  "utf-8",
 ]
 
+[[package]]
+name = "thin-vec"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0f7e269b48f0a7dd0146680fa24b50cc67fc0373f086a5b2f99bd084639b482"
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -4110,6 +4994,16 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "tokio-io-utility"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d672654d175710e52c7c41f6aec77c62b3c0954e2a7ebce9049d1e94ed7c263"
+dependencies = [
+ "bytes",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-macros"
 version = "2.7.0"
@@ -4352,12 +5246,40 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
+[[package]]
+name = "triomphe"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b40688ea6389c8171614b25491f71d4a27946e0c7ce2da1c6de27e25abf1a0ae"
+dependencies = [
+ "arc-swap",
+ "serde",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "typed-path"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"
+
 [[package]]
 name = "typeid"
 version = "1.0.3"
@@ -4440,6 +5362,22 @@ version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
 
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
+[[package]]
+name = "uom"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd5cfe7d84f6774726717f358a37f5bca8fca273bed4de40604ad129d1107b49"
+dependencies = [
+ "num-traits",
+ "typenum",
+]
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -4489,6 +5427,22 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "vec-strings"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8509489e2a7ee219522238ad45fd370bec6808811ac15ac6b07453804e77659"
+dependencies = [
+ "serde",
+ "thin-vec",
+]
+
 [[package]]
 name = "version-compare"
 version = "0.2.1"
@@ -4623,6 +5577,76 @@ dependencies = [
  "web-sys",
 ]
 
+[[package]]
+name = "wayland-backend"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"
+dependencies = [
+ "bitflags 2.13.0",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6"
+dependencies = [
+ "bitflags 2.13.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"
+dependencies = [
+ "bitflags 2.13.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a"
+dependencies = [
+ "proc-macro2",
+ "quick-xml 0.39.4",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
+dependencies = [
+ "pkg-config",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.102"
@@ -4697,10 +5721,10 @@ checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
 dependencies = [
  "webview2-com-macros",
  "webview2-com-sys",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
 ]
 
 [[package]]
@@ -4721,7 +5745,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
 dependencies = [
  "thiserror 2.0.18",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
 ]
 
@@ -4777,6 +5801,18 @@ dependencies = [
  "windows-version",
 ]
 
+[[package]]
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
+dependencies = [
+ "windows-core 0.52.0",
+ "windows-implement 0.52.0",
+ "windows-interface 0.52.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows"
 version = "0.61.3"
@@ -4799,14 +5835,36 @@ dependencies = [
  "windows-core 0.61.2",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+dependencies = [
+ "windows-implement 0.58.0",
+ "windows-interface 0.58.0",
+ "windows-result 0.2.0",
+ "windows-strings 0.1.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link 0.1.3",
  "windows-result 0.3.4",
  "windows-strings 0.4.2",
@@ -4818,8 +5876,8 @@ version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link 0.2.1",
  "windows-result 0.4.1",
  "windows-strings 0.5.1",
@@ -4836,6 +5894,28 @@ dependencies = [
  "windows-threading",
 ]
 
+[[package]]
+name = "windows-implement"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12168c33176773b86799be25e2a2ba07c7aab9968b37541f1094dbd7a60c8946"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "windows-implement"
 version = "0.60.2"
@@ -4847,6 +5927,28 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "windows-interface"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d8dc32e0095a7eeccebd0e3f09e9509365ecb3fc6ac4d6f5f14a3f6392942d1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
@@ -4880,6 +5982,15 @@ dependencies = [
  "windows-link 0.1.3",
 ]
 
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.3.4"
@@ -4898,6 +6009,16 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result 0.2.0",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-strings"
 version = "0.4.2"
@@ -5214,6 +6335,24 @@ version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix",
+ "thiserror 2.0.18",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.3"
@@ -5258,7 +6397,7 @@ dependencies = [
  "webkit2gtk",
  "webkit2gtk-sys",
  "webview2-com",
- "windows",
+ "windows 0.61.3",
  "windows-core 0.61.2",
  "windows-version",
  "x11-dl",
@@ -5370,7 +6509,7 @@ dependencies = [
  "hex",
  "nix 0.29.0",
  "ordered-stream",
- "rand",
+ "rand 0.8.6",
  "serde",
  "serde_repr",
  "sha1",
@@ -5379,9 +6518,44 @@ dependencies = [
  "uds_windows",
  "windows-sys 0.52.0",
  "xdg-home",
- "zbus_macros",
- "zbus_names",
- "zvariant",
+ "zbus_macros 4.4.0",
+ "zbus_names 3.0.0",
+ "zvariant 4.2.0",
+]
+
+[[package]]
+name = "zbus"
+version = "5.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28b97f866896a4be7aefd2b5a8e01bb6773d19a775d54ab28b4d094b9a4480e"
+dependencies = [
+ "async-broadcast",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "async-process",
+ "async-recursion",
+ "async-task",
+ "async-trait",
+ "blocking",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-lite",
+ "hex",
+ "libc",
+ "ordered-stream",
+ "rustix",
+ "serde",
+ "serde_repr",
+ "tracing",
+ "uds_windows",
+ "uuid",
+ "windows-sys 0.61.2",
+ "winnow 1.0.3",
+ "zbus_macros 5.17.0",
+ "zbus_names 4.3.3",
+ "zvariant 5.13.0",
 ]
 
 [[package]]
@@ -5394,7 +6568,22 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.118",
- "zvariant_utils",
+ "zvariant_utils 2.1.0",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "5.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e05ad887425eecf5e8384dc2406a4a9313eb73468712fc1cdea362eb4fe0469"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "zbus_names 4.3.3",
+ "zvariant 5.13.0",
+ "zvariant_utils 3.5.0",
 ]
 
 [[package]]
@@ -5405,7 +6594,18 @@ checksum = "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c"
 dependencies = [
  "serde",
  "static_assertions",
- "zvariant",
+ "zvariant 4.2.0",
+]
+
+[[package]]
+name = "zbus_names"
+version = "4.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1039ca249fee9559680f3a9f05b55e0761fee51af4f6c1e7d8c1f31e549721d2"
+dependencies = [
+ "serde",
+ "winnow 1.0.3",
+ "zvariant 5.13.0",
 ]
 
 [[package]]
@@ -5449,6 +6649,26 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
 [[package]]
 name = "zerotrie"
 version = "0.2.4"
@@ -5482,12 +6702,61 @@ dependencies = [
  "syn 2.0.118",
 ]
 
+[[package]]
+name = "zip"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "crossbeam-utils",
+ "displaydoc",
+ "flate2",
+ "indexmap 2.14.0",
+ "memchr",
+ "thiserror 2.0.18",
+ "zopfli",
+]
+
+[[package]]
+name = "zip"
+version = "7.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c42e33efc22a0650c311c2ef19115ce232583abbe80850bc8b66509ebef02de0"
+dependencies = [
+ "crc32fast",
+ "flate2",
+ "indexmap 2.14.0",
+ "memchr",
+ "typed-path",
+ "zopfli",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "977347db8caa080403f6b6b7c1cda9479a8e869316f7e13a59b19076a40f94e3"
+
 [[package]]
 name = "zmij"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
 
+[[package]]
+name = "zopfli"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+dependencies = [
+ "bumpalo",
+ "crc32fast",
+ "log",
+ "simd-adler32",
+]
+
 [[package]]
 name = "zune-core"
 version = "0.5.1"
@@ -5513,7 +6782,21 @@ dependencies = [
  "enumflags2",
  "serde",
  "static_assertions",
- "zvariant_derive",
+ "zvariant_derive 4.2.0",
+]
+
+[[package]]
+name = "zvariant"
+version = "5.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cf057bb00bf5c9ad77abb6147b0ca4818236a1858416e9d988e40d6322fefa7"
+dependencies = [
+ "endi",
+ "enumflags2",
+ "serde",
+ "winnow 1.0.3",
+ "zvariant_derive 5.13.0",
+ "zvariant_utils 3.5.0",
 ]
 
 [[package]]
@@ -5526,7 +6809,20 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn 2.0.118",
- "zvariant_utils",
+ "zvariant_utils 2.1.0",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "5.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8118ca6bda77bfc0ab51d660db0c955f2505eef854c9a449435bccb616933b31"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "zvariant_utils 3.5.0",
 ]
 
 [[package]]
@@ -5539,3 +6835,16 @@ dependencies = [
  "quote",
  "syn 2.0.118",
 ]
+
+[[package]]
+name = "zvariant_utils"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90cb9383f9b45290407a1258b202d3f8f01db719eb60b4e4055c6375af4fc7c7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.118",
+ "winnow 1.0.3",
+]
diff --git a/DOCUMENTATION.md b/DOCUMENTATION.md
index c75c56c..c82cb63 100644
--- a/DOCUMENTATION.md
+++ b/DOCUMENTATION.md
@@ -234,7 +234,7 @@ Contents:
   `@dnd-kit/sortable`. Hovering a pill shows a tooltip with the project path,
   status, and today's active time (from `get_time_today`). Clicking switches to
   the project; the × button closes it. The pill's menu also exposes **Publish to
-  GitHub** (see below).
+  GitHub / GitLab** (see below).
 - **Box pills** — `BoxPill.tsx` renders a project box as a single project-style
   pill (`.project-pill.is-box`) with a member-count badge. Dropping a project
   pill onto a box (same `PILL_DRAG_TYPE` as pill reorder) assigns it to the box;
@@ -245,14 +245,20 @@ Contents:
 - **+ button** — opens an add-project menu with "New project" and "Import
   project" sub-options.
 
-**Publish to GitHub.** `publishProject` (`stores/projects.ts`) invokes
-`github_publish` (`commands/github.rs`), which runs `gh repo create <name>
---<visibility> --source=. --remote=origin --push` via the system `gh` CLI. For a
-work-remote (SSH) project the `gh` call runs over `ssh` on the host where the
-repo lives (`BatchMode`, validated argv, single-quoted remote path). On success
-it records the new push target — `git_type` becomes `remote-public` or
-`remote-private` in both `projects.json` and the project's `project.json` — and
-returns `gh`'s stdout (the repo URL). Requires `gh` installed and authenticated
+**Publish to GitHub / GitLab.** `publishProject` (`stores/projects.ts`) invokes
+`publish_project` (`commands/git_publish.rs`) with a `provider` (`github` /
+`gitlab`) and `visibility`. For GitHub it runs `gh repo create <name>
+--<visibility> --source=. --remote=origin --push`; for GitLab it runs `glab repo
+create <name> --<visibility> --remoteName origin` followed by an explicit `git
+push -u origin HEAD` (since `glab` has no `--source/--push`), authenticating the
+push with the effective token via an ephemeral inline git credential helper. For a
+work-remote (SSH) project the CLI call runs over `ssh` on the host where the repo
+lives (`BatchMode`, validated argv, single-quoted remote path), relying on that
+host's own `gh`/`glab` auth. On success it records the new push target —
+`git_type` becomes `remote-public` or `remote-private`, and `git_provider` the
+chosen provider, in both `projects.json` and the project's `project.json` — and
+returns the CLI's stdout (the repo URL). Requires the chosen provider's CLI (`gh`
+or `glab`) installed and authenticated, or a token under Settings → Git hosting
 (locally, or on the remote host for remote projects).
 
 Settings dialog covers: default agent command, theme (Dark/Bright/Fancy
@@ -598,8 +604,19 @@ session and removed.
 
 ### Startup
 
-1. `AppShell` mounts; loads settings and projects from the backend.
-2. `getCurrentWindow().setFullscreen(true)` is called after the window is ready.
+1. The main window is created hidden (`"visible": false` in `tauri.conf.json`).
+   The backend's `restore_main_window` (`lib.rs`) reapplies the geometry saved in
+   `settings.window_state` — monitor, position, size, maximized — then shows it,
+   so the window never visibly jumps between monitors. If nothing is saved, or the
+   saved rect no longer fits any connected monitor (an unplugged external display),
+   it falls back to opening maximized wherever the WM puts it. Which rect is
+   placeable is decided by `services::window_state::resolve_startup_geometry`.
+2. `AppShell` mounts; loads settings and projects from the backend. On macOS only,
+   `getCurrentWindow().setFullscreen(true)` is called after the window is ready
+   (Linux must never enter fullscreen: a `_NET_WM_STATE_FULLSCREEN` window is
+   unmovable under KWin). It then listens for window moves/resizes and writes the
+   geometry back to `settings.window_state` on a 300 ms debounce, plus once more on
+   close.
 3. Projects marked `current` or `active` appear as project-switcher pills.
 4. The project marked `current` is the initial active scope; if none, root.
 5. Workspace management (if enabled) allocates desktops for visible projects.
@@ -739,15 +756,18 @@ test skips itself when no local Ollama server or model is available.
   layout on restart rather than respawning as separate OS windows.
 - Project-box scopes are session-only: a box's tabs are dropped on project switch
   / restart. Renaming a box does not move its already-created folder.
-- `github_publish` requires the `gh` CLI installed and authenticated (on the
-  remote host for work-remote projects); it does not manage GitHub auth itself.
+- `publish_project` requires the chosen provider's CLI — `gh` (GitHub) or `glab`
+  (GitLab) — installed and authenticated (on the remote host for work-remote
+  projects); it does not manage provider auth itself beyond an optional token.
 - Ollama model installation and update depend on network access to the Ollama
   registry and may take minutes for large models.
 - `ensure_ollama_running` can start a system service only when the current user
   has permission to do so; otherwise it falls back to a user `ollama serve`
   process.
-- Open-app restore uses a best-effort relaunch model; window geometry and focus
-  order are not restored.
+- Open-app restore uses a best-effort relaunch model; the geometry and focus
+  order of *externally launched app* windows are not restored. (Eldrun's own main
+  window does restore its monitor, position, size, and maximized state — see
+  Startup below.)
 - Network status depends on reaching Cloudflare DNS; may show offline on
   networks that block direct TCP/53.
 - Download routing browser preference edits assume the browser is not running.
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
new file mode 100644
index 0000000..6f94484
--- /dev/null
+++ b/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Eldrun Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/LICENSE b/LICENSE-MIT
similarity index 100%
rename from LICENSE
rename to LICENSE-MIT
diff --git a/README.md b/README.md
index 1a5ecbd..2ddb891 100644
--- a/README.md
+++ b/README.md
@@ -1,45 +1,112 @@
+![Eldrun logo](src/assets/logo-white.svg)
+
 # Eldrun
 
-**The problem:** when you develop several projects at once, every project's
-windows — browsers, terminals, file managers, docs, agents — pile up on one
-desktop. Switching from project A to project B means hunting through dozens of
-windows for the handful that belong to where you're going, and losing the rest
-in the noise.
-
-**Eldrun's model:** you don't open applications, you open projects. Selecting a
-project swaps the whole desktop to that project's context — its windows come
-forward, the previous project's windows are parked out of the way, the
-downloads folder and default-app mappings re-route, and time tracking switches.
-One project visible at a time, everything else cleanly out of sight.
-
-Inside each project, Eldrun is an operational cockpit: a root control terminal
-for managing the workspace, one or more agent terminals scoped to the project
-(Claude, Codex, Gemini, or a local Ollama model), a persistent project bar, a
-hover-revealed file panel, and cross-project app controls that stay available as
-you move between projects. It is built with Tauri 2 + React + TypeScript, with
-optional KDE/X11 workspace integration.
+**A project-centric desktop layer that swaps your entire working context — windows, files, apps, Git state, layout, and AI agent terminals — as a single unit when you switch projects, and runs any of those projects on a remote machine or HPC cluster as if it were sitting on your laptop.**
+
+[![CI](https://github.com/fseiffarth/ProjectEldrun/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/fseiffarth/ProjectEldrun/actions/workflows/ci-cd.yml)
+[![License: MIT OR Apache-2.0](https://img.shields.io/badge/License-MIT%20OR%20Apache--2.0-yellow.svg)](#license)
+[![Release](https://img.shields.io/github/v/release/fseiffarth/ProjectEldrun)](https://github.com/fseiffarth/ProjectEldrun/releases)
+![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-blue)
+![Tauri](https://img.shields.io/badge/Tauri-2-24C8DB?logo=tauri)
+
+
+> **You don't open applications — you open projects.**
+> **And you don't move to the machine your work runs on — the project takes it
+> with you.**
+
+Eldrun stands on **two pillars**.
+
+**One project = one desktop.** Eldrun is a project-centric desktop layer, not
+just an app that launches or embeds other apps: projects own their windows and
+desktop context, and selecting a project swaps that whole context — windows,
+files, apps, Git state, and layout — as a single unit. The AI agent terminals,
+file viewers, and app launcher ride on top, living *inside* a project once its
+desktop is restored.
+
+**One project = any machine.** A project is not tied to the computer in front of
+you. Point it at an SSH host — or extend an existing local project onto one — and
+its agent tabs, shells, Python runs, and jobs execute *there*, while the file
+tree, viewers, and Git views keep working exactly as they do locally. No sshfs or
+FUSE mount is involved, a project can span several machines at once, long runs
+survive an SSH drop or a laptop lid, and SLURM clusters are driven from the same
+cockpit — submit, watch, cancel, and grab an interactive compute node without
+memorizing the commands. The goal is that *running a project on a cluster costs
+about as much ceremony as running it locally*. See
+[Remote machines & HPC clusters](#remote-machines--hpc-clusters-the-second-differentiator).
+
+Built with **Tauri 2 + React + TypeScript**. Linux (X11 / KDE Wayland) and
+Windows both get native workspace, app-launch, default-app, and download
+integration today; macOS runs as a shell with a no-op workspace backend (on the
+roadmap).
+
+---
+
+## Why Eldrun
+
+When you juggle several projects at once, every project's windows — browsers,
+terminals, file managers, docs, agents — pile onto one desktop. Switching from
+project A to project B means digging through dozens of windows for the handful
+that belong where you're going, and losing the rest in the noise.
+
+Eldrun flips the model. **Select a project, and the desktop becomes that
+project:** its windows come forward, the previous project's windows park out of
+the way, the downloads folder and default-app mappings re-route, and time
+tracking switches. One project visible at a time, everything else cleanly out of
+sight.
+
+Inside a project, Eldrun is an operational cockpit — a root control terminal for
+the workspace, agent terminals scoped to the project (Claude, Codex, Gemini, or
+a local Ollama model), a tiling tab layout, a hover-revealed file panel with
+built-in viewers, and cross-project app controls that follow you between
+projects.
+
+**And the same friction exists one layer down: your work rarely runs where you
+sit.** The heavy half of a project belongs on a server, a GPU box, or an HPC
+cluster, and the usual answer is a second, worse workflow — a bare `ssh` window,
+`scp`/`rsync` by hand, `vim` instead of your editor, tmux discipline you have to
+remember, and SLURM incantations you look up every time. Eldrun makes the remote
+machine a *property of the project* instead of a separate way of working: you
+open the project, and its terminals, agents, and jobs are already on the right
+host, its files are already in the file tree, and its Git history is already in
+sync — with no mount, and no second toolchain to keep in your head.
 
 ## Vision
 
-Eldrun is a project-centric desktop layer, not just an app that launches or
-embeds other apps. The user-facing model is:
-
-> Select a project → Eldrun restores that project's working context.
+> Select a project → Eldrun restores its complete working context.
 
-The core product is the window/workspace layer: projects own their windows and
-desktop context, and switching projects swaps that context as one unit. The
-agent terminals, file panel, and app launcher ride on top of that layer — they
-are what lives inside a project once its desktop is restored. That context
-should eventually include terminals, files, apps, windows, Git state, notes,
-AI/task metadata, layout, and workflow state.
+A project's context already spans terminals, files, apps, windows, Git state,
+layout — **and the machines it runs on**; the direction of travel adds notes,
+AI/task metadata, and workflow state, so a project carries everything it needs to
+be resumed exactly where you left it, whether that is on this laptop or on a
+login node three networks away.
 
-The current implementation is focused on Linux (X11 and KDE Wayland) because
-that provides the fastest path to reliable window control. The longer-term
-direction is a stable Eldrun core with desktop/compositor backends for Cinnamon
-X11, KDE/KWin, Hyprland, GNOME Shell, i3, Sway, and other Wayland environments.
+The implementation runs natively on **Linux (X11 and KDE Wayland)** and
+**Windows** today — both with real per-project window parking — and the design is
+cross-platform by intent. The long-term shape is a stable Eldrun core behind
+pluggable compositor/window backends (X11, KDE/KWin, Hyprland, GNOME Shell, i3,
+Sway, and other Wayland environments; the Win32 backend on Windows), native macOS
+support, and eventually an Eldrun-native compositor for full control of projects,
+windows, and layout.
 
 See [VISION.md](docs/VISION.md) for the full strategy and platform rationale.
 
+## At a glance
+
+![Eldrun functionality map](screenshots/eldrun-functionality.svg)
+
+**①** pick a project and the desktop swaps to it. **②** inside, a tiling tab
+layout hosts agent terminals, shells, and native file viewers. **③** the
+project-desktop layer (window parking, downloads, default apps, time tracking)
+follows the active project automatically, with the right panel (Files · Git ·
+Search) and the global app toolbar alongside. **④** and the project carries the
+machines it runs on: its tabs, jobs, and files can live on an SSH host, a GPU
+box, or an HPC cluster without changing how any of the above works.
+
+And here's how that looks in the running app:
+
+![Current Eldrun screen](screenshots/eldrun-current.png)
+
 ## How Eldrun compares
 
 Agent orchestrators (Vibe Kanban, Conductor, Claude Squad, the Claude Code
@@ -53,33 +120,50 @@ desktop per project handle windows but have no project model and no restore;
 tmux and scripts like `workon` restore terminal layouts but ignore everything
 outside the terminal.
 
+Nor do any of them cross machines. Remote development tooling (VS Code Remote,
+JupyterHub, a hand-rolled `ssh` + `rsync` + tmux setup) attaches *one editor* to
+*one host*; the cluster half — workspaces on the parallel filesystem, `sbatch`
+and `squeue`, an `srun` shell on a compute node, keeping several machines in
+step — stays a terminal exercise you repeat per project.
+
 Eldrun occupies the gap none of them fill: project ownership of *windows and
-desktop context*, with agent terminals built in. It is complementary to the
+desktop context*, and project ownership of *the machines the work runs on*, with
+agent terminals built in on both. It is complementary to the
 task orchestrators rather than a replacement — you can run one inside an Eldrun
 project terminal for parallel task delegation while Eldrun handles switching the
 desktop between projects.
 
-![Current Eldrun screen](screenshots/eldrun-current.png)
-
 ## Stack
 
 - **Frontend:** React 18, TypeScript, Vite, Tailwind CSS, Zustand
 - **Terminal UI:** xterm.js (`@xterm/xterm`, `@xterm/addon-fit`, `@xterm/addon-web-links`)
 - **Backend:** Rust, Tauri v2
 - **PTY:** `portable-pty` crate
-- **Workspace:** `zbus` (DBus) and `xcb` (X11) — Linux only
+- **Workspace:** `zbus` (DBus) and `xcb` (X11) on Linux; the Win32 API
+  (`windows` crate — `SW_HIDE`/`SW_SHOW`, `EnumWindows`, virtual-desktop manager,
+  shell-link/icon resolution) on Windows
+
+## Download
+
+Prebuilt packages are published on the
+[Releases page](https://github.com/fseiffarth/ProjectEldrun/releases). From the
+[latest release](https://github.com/fseiffarth/ProjectEldrun/releases/latest),
+grab the `.AppImage` (portable Linux) or `.deb` (Debian/Ubuntu), or the `.exe`
+installer on Windows. To build from source instead, follow the requirements
+below.
 
 ## Requirements
 
-- Linux desktop (X11 or KDE Wayland)
+- Linux desktop (X11 or KDE Wayland) **or** Windows 10/11
 - Rust toolchain (`rustup`) and Node 18+
-- `sshfs` + FUSE (optional, only for remote/SSH projects)
+- Remote/SSH and HPC projects (optional): nothing to install locally beyond
+  OpenSSH — no `sshfs`, no FUSE. On the host: `tmux` for persistent sessions
+  (optional), plus `openvpn` locally for VPN-gated hosts
 
 ```bash
-# Install Rust
-curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+# Install Rust (all platforms): https://rustup.rs
 
-# Tauri system dependencies (Debian / Ubuntu)
+# Linux: Tauri system dependencies (Debian / Ubuntu)
 sudo apt install libwebkit2gtk-4.1-dev libssl-dev libgtk-3-dev \
     libayatana-appindicator3-dev librsvg2-dev
 
@@ -87,88 +171,41 @@ sudo apt install libwebkit2gtk-4.1-dev libssl-dev libgtk-3-dev \
 npm install
 ```
 
-## Run
+On Windows the Tauri webview uses the system WebView2 runtime (preinstalled on
+Windows 11); no GTK/WebKit packages are needed.
 
-```bash
-./start-eldrun-tauri.sh
-```
+## Run
 
-Or for a development build with hot-reload:
+A development build with hot-reload (all platforms):
 
 ```bash
-npm run tauri dev
+npm run tauri:dev
 ```
 
-The desktop launchers are `Eldrun.desktop` for the normal packaged app and
-`EldrunHotReload.desktop` for hot reload. They already point at this
-checkout's scripts, so you can install them as-is:
+On Linux you can also use the convenience scripts in `docs/`:
+`docs/start-eldrun-tauri.sh` (packaged build) and
+`docs/start-eldrun-tauri-hotreload.sh` (hot reload). The desktop launchers
+`docs/Eldrun.desktop` and `docs/EldrunHotReload.desktop` carry a
+`/path/to/projecteldrun/...` placeholder — point them at your checkout, then
+install them:
 
 ```bash
-cp Eldrun*.desktop ~/.local/share/applications/
+cp docs/Eldrun*.desktop ~/.local/share/applications/
 update-desktop-database ~/.local/share/applications/
 ```
 
-## Agent Support
-
-Eldrun launches agents in xterm.js PTY tabs. The table below describes the
-current integration state.
-
-### CLI agents (xterm.js terminal tabs)
-
-| Agent                                      | Integrated | Tested  | Notes                                                                                                                                               |
-| ------------------------------------------ | ---------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Claude** (`claude`)                      | Yes        | Yes     | Default agent command. Full tab lifecycle, layout persistence, project-scoped sandbox env.                                                          |
-| **Codex** (`codex`)                        | Yes        | Yes     | Selectable as default agent command in Settings. Same tab lifecycle as Claude.                                                                      |
-| **Gemini** (`gemini`)                      | Yes        | Yes     | Selectable as default agent command in Settings. Same tab lifecycle as Claude and Codex.                                                            |
-| **Vibe** (`vibe`)                          | Yes        | No      | Listed as a selectable agent command; same tab lifecycle.                                                                                           |
-| **Ollama via Vibe** (`vibe` + local model) | Yes        | Partial | Installed Ollama models appear under Local Agents. Each local tab gets an isolated per-model `VIBE_HOME` under `~/.local/share/eldrun/vibe_local/`. |
-| **Shell**                                  | Yes        | Yes     | Plain interactive shell tab in the project directory.                                                                                               |
-| Mistral CLI                                | No         | No      | Not integrated. Can be used in a plain shell tab.                                                                                                   |
-| Qwen CLI                                   | No         | No      | Not integrated.                                                                                                                                     |
-| Grok CLI                                   | No         | No      | Not integrated.                                                                                                                                     |
-
-The active agent command (`claude`, `codex`, `gemini`, or `vibe`) is set in
-Settings. If the configured command is not found in `$PATH`, Eldrun falls back
-to the system shell. Project-bound terminals also receive a best-effort project
-sandbox: the child process runs in the project directory with project-local XDG
-config, cache, data, state, and temp locations under
-`<project>/.eldrun/sandbox/`. The root orchestration terminal keeps the normal
-workspace environment.
-
-**Session resume.** Claude and Codex tabs that carry a session id are persisted
-across restarts and respawned with their prior conversation. Eldrun installs a
-`SessionStart` hook (into `~/.claude/settings.json` and `~/.codex/config.toml`)
-that records each tab's live session id keyed by an `ELDRUN_TAB_UID` env var, so
-resume follows the live session even across a `/clear`. (Codex hooks need a
-one-time `/hooks` trust before they fire; Gemini and Vibe tabs are still
-dropped.)
-
-Local Ollama models are available from the tab `+` menu when Ollama is
-installed and reachable. Eldrun can start the Ollama service, list installed
-models, and create a `vibe` tab for a selected model. The per-model `VIBE_HOME`
-config pins `active_model`, registers the Ollama provider, and disables Vibe
-tool calls for local models so local tabs do not mutate global `~/.vibe`
-configuration.
-
-## Platform Support
-
-| Platform                  | Status             | Notes                                                                                        |
-| ------------------------- | ------------------ | -------------------------------------------------------------------------------------------- |
-| **Linux — X11**           | Yes                | Two-desktop workspace parking model (EWMH/xcb). Primary development target.                  |
-| **Linux — KDE Wayland**   | Yes                | Per-project virtual desktop model via KWin DBus scripting. KDE 5 and KDE 6 supported.        |
-| **Linux — other Wayland** | Partial            | Null backend (no workspace switching, no sticky windows). Terminal and file management work. |
-| **Windows**               | Experimental shell | Null workspace backend. No native window/default-app/download integrations.                  |
-| **macOS**                 | Experimental shell | Null workspace backend. No native window/default-app/download integrations.                  |
-
 ## Main Features
 
-### Project desktop (the differentiator)
+### Project desktop (the first differentiator)
 
-- **Workspace management**: X11 two-desktop parking model and KDE Wayland
-  per-project virtual desktop model; global app windows stay visible across
-  all project switches.
-- **External window tracking**: file opens use `xdg-open`; launched windows are
-  tracked by PID and shown in the right panel instead of embedded in the UI.
+- **Workspace management**: X11 two-desktop parking model, KDE Wayland
+  per-project virtual desktop model, and a Windows `SW_HIDE`/`SW_SHOW` parking
+  model (with best-effort virtual-desktop pinning); global app windows stay
+  visible across all project switches.
+- **External window tracking**: file opens use `xdg-open` (Linux) / the shell
+  open verb (Windows); launched windows are tracked by PID — found via
+  `EnumWindows` on Windows — and shown in the right panel instead of embedded in
+  the UI.
 - **Downloads routing**: `~/eldrun/downloads` symlink always points to the active
   project's `tmp/downloads/`; Firefox and Chromium preferences are updated
   automatically.
@@ -177,6 +214,55 @@ configuration.
 - **Time tracking**: Eldrun records active project sessions and shows today's
   elapsed time on project pills.
 
+### Remote machines & HPC clusters (the second differentiator)
+
+Eldrun treats remote hosts as first-class: it **manages a fleet of machines** and
+**runs your projects on them**, from a single SSH box to a full HPC cluster —
+with the same file tree, viewers, Git panel, and agent tabs you use locally, and
+without an sshfs/FUSE mount anywhere.
+
+- **Machine hub**: register SSH hosts once (independent of any project) in the
+  header's machines indicator — see a live CPU/GPU usage bar per machine,
+  connect/disconnect, arm silent auto-connect on launch, and drag a machine onto
+  a project to attach it as a compute host.
+- **Run on the remote host**: a project can point at a host — at creation, or by
+  *extending* an existing local project onto one in place — and run its agent,
+  shell, and Python tabs *on that host* over `ssh -tt`, with the file tree, Git,
+  and in-app viewers all reading the remote tree over SFTP. Everything rides one
+  pooled ControlMaster connection per machine, and VPN-gated hosts bring up an
+  OpenVPN tunnel first.
+- **A local copy that stays in step, on purpose**: the project keeps a local
+  mirror kept current by two transports that split the tree by Git. **Git
+  lockstep** moves *tracked* files semantically — commits and refs via
+  `git bundle`, never `.git` bytes — while an opt-in, per-folder **byte-sync**
+  moves everything else. So your editor, agents, and Git history see the project
+  locally, while gigabytes of host-side experiment output stay on the host until
+  you ask for them; a setup census offers to exclude the giant folders
+  (`node_modules/`, `.venv/`, `data/`, `checkpoints/`) up front.
+- **Many machines per project**: beyond the primary host, add extra *worker*
+  machines — their code is kept in sync from the project (one-way, tracked files
+  only) and their experiment outputs are pulled back on demand. A worker on a
+  **shared filesystem** (e.g. an HPC compute node on a shared home) is used in
+  place, with nothing copied and no Git run on it.
+- **Persistent sessions**: a long run lives in a tmux session per shell tab, so
+  a job survives an SSH drop, a laptop sleep, a VPN drop, or Eldrun quitting, and
+  the tab reattaches on relaunch. A **Sessions view** lists every running session
+  across all connected machines, with per-row attach/rename/kill.
+- **Remote system monitor**: a host's CPU, memory, and GPUs (AMD + NVIDIA,
+  including per-process GPU memory) are sampled over the same SSH connection and
+  shown alongside the local machine's.
+- **HPC / SLURM** *(built, but untested pending real-cluster QA)*: submit a batch
+  script with `sbatch`, watch its live log, list and cancel your queued jobs, and
+  open an interactive compute-node shell via `srun` — without memorizing the
+  commands. A guided **HPC pipeline wizard** walks a cluster newcomer through
+  login → project → data upload → job → watch.
+- **HPC workspaces** *(same QA caveat)*: on clusters that hand out scratch space
+  on the parallel filesystem via `hpc-workspace`, Eldrun allocates, lists,
+  extends, and releases workspaces from the app, and can put the project's remote
+  root *in* one — so the data lands off the quota'd `$HOME` before the first byte
+  is uploaded. Nothing is site-specific: the host is asked which filesystems and
+  limits it offers.
+
 ### Project cockpit
 
 - **Agent-terminal orchestration**: create Claude, Codex, Gemini, or plain shell
@@ -211,80 +297,52 @@ configuration.
   project or imports an existing directory (keep in place, copy, or move).
 - **Remote (SSH) projects**: optionally point a project at a remote host. Enter
   an SSH address (`user@host[:port]`), connect, and browse the remote filesystem
-  in-app to pick the project root. Eldrun `sshfs`-mounts it locally so the file
-  tree, terminal cwd, and git work unchanged. Terminal and agent tabs run **on
-  the remote host** over `ssh -tt` (multiplexed over a ControlMaster socket),
-  with the agent CLI auto-detected/bootstrapped on the remote and authenticated
-  with the remote's own login. VPN-gated hosts bring up an OpenVPN tunnel first.
-  Auth uses your existing SSH setup (keys / agent / `~/.ssh/config`,
-  `BatchMode`); requires `sshfs`/FUSE on the local machine.
-- **Publish to GitHub**: a local (or SSH-remote) git project can be published to
-  a new GitHub repository from the project pill menu. Choose public or private;
-  Eldrun runs `gh repo create … --source=. --push` via the system `gh` CLI (over
-  `ssh` on the host where the bytes live for remote projects), then records the
-  new push target (`git_type` becomes `remote-public`/`remote-private`). Requires
-  the GitHub CLI (`gh`) installed and authenticated.
+  in-app to pick the project root — no mount involved: the file tree and file I/O
+  go over SFTP, terminal and agent tabs run **on the remote host** over `ssh -tt`
+  (multiplexed over a ControlMaster socket), and git runs on the host, with the
+  agent CLI auto-detected/bootstrapped there and authenticated with the remote's
+  own login. Auth uses your existing SSH setup (keys / agent / `~/.ssh/config`)
+  or a password you can optionally save to the OS keychain. See
+  [Remote machines & HPC clusters](#remote-machines--hpc-clusters-the-second-differentiator)
+  for the fleet, sync, session, and cluster features built on top.
+- **Publish to GitHub / GitLab**: a local (or SSH-remote) git project can be
+  published to a new GitHub or GitLab repository from the project pill menu.
+  Choose the provider and public/private; Eldrun runs `gh repo create …
+  --source=. --push` (GitHub) or `glab repo create … --remoteName origin`
+  followed by `git push` (GitLab) via the system CLI (over `ssh` on the host
+  where the bytes live for remote projects), then records the new push target
+  (`git_type` becomes `remote-public`/`remote-private`) and provider. Requires
+  the chosen provider's CLI — `gh` or `glab` — installed and authenticated, or a
+  token set under Settings → Git hosting.
 - **Project switcher**: search, switch, and close projects; a running-task
   indicator spins on pills with live terminal output (even backgrounded
   projects); hover over a pill to see the project path, status, today's active
   time, and live CPU%.
-- **Right file panel**: browse, open, create, rename, delete, and reveal project
-  files, with a breadcrumb trail and per-file git status markers (modified,
-  untracked, staged, committed-but-unpushed, ignored). A "Git" view shows the
-  current branch, clickable branch pills for checkout, and a commit list whose
-  entries open an editable commit-message window (amend HEAD, agent-generated
-  messages, or checkout). The panel can be pinned open instead of hover-revealed.
-  Additional views list tracked external windows.
-- **In-app file viewers**: drag a file from the tree onto a subwindow's tab bar
-  to open it in a tab. The built-in viewers, by type, are:
-  - **Text / code** (`.txt`, `.json`, `.py`, `.rs`, `.ts`, `.svg`, `.bib`, and
-    many more, plus well-known extensionless files like `Dockerfile`): an
-    editable code editor with a line-number gutter, syntax highlighting,
-    Tab/Shift+Tab indent, undo/redo (`Ctrl+Z` / `Ctrl+Shift+Z`), in-editor
-    find (`Ctrl+F`) and find-and-replace (`Ctrl+R`) with match navigation and a
-    case toggle, and a save icon (`Ctrl+S`). Unsaved edits are marked in the
-    gutter so you can see at a glance which lines changed since the last save.
-    It auto-reloads when the file changes on disk (showing a non-destructive
-    Reload / Keep-mine banner if you have unsaved edits), and offers opt-in
-    local autocomplete (see below).
-  - **Markdown** (`.md`, `.markdown`, `.mdx`): rendered preview with an
-    Edit/Preview toggle; links to local files read as clickable.
-  - **LaTeX** (`.tex`): the code editor plus, when a TeX engine is on `PATH`, a
-    compile action with compiler options (output folder, extra engine flags —
-    shell-escape is always stripped). A successful compile opens the PDF in its
-    own tab (reusing/refreshing it on recompile) rather than an inline preview
-    pane, and `Ctrl`/`Cmd`+Click follows `\input{…}` / `\includegraphics{…}`
-    references (shown with a dotted underline). Typing inside `\ref{…}` /
-    `\cite{…}` pops a completion list of the document's `\label` keys and `.bib`
-    entries. A failed compile lists the parsed errors (file, line, message,
-    including errors in `\input`-ed child files) and clicking one jumps the
-    editor to that line. When the engine emits a SyncTeX file, the viewer offers
-    **bidirectional SyncTeX sync**: `Ctrl`/`Cmd`+Click (or a sync action) in the
-    editor highlights the matching box in the PDF tab, and clicking in the PDF
-    jumps the editor back to the source line and word — working even when the
-    editor and PDF live in separate tiled panes or detached OS windows.
-  - **Images** (`.png`, `.jpg`, `.gif`, `.webp`, …): zoom (to the cursor) / pan
-    viewer; the image is also draggable out as an OS drop source.
-  - **PDF** (`.pdf`): rendered with a themed zoom toolbar.
-
-  Office / spreadsheet formats (`.odt`, `.xlsx`, `.docx`, …) and any other type
-  open in their external default app for now. Native-viewer behaviour is
-  configured per file type under **Settings → Native Viewers**: the per-type
-  autocomplete opt-in, plus a global autosave switch. The text/LaTeX/Markdown
-  editors also carry an `A−`/`A+` text-size control (or `Ctrl` +/−, `Ctrl`+0 to
-  reset) — in Markdown it scales the preview too; the chosen size persists per
-  file type. Each viewer also remembers where you left off: the editor/PDF
-  scroll position, PDF/image zoom, and image pan are persisted per tab, so
-  reopening a file — or restarting Eldrun — restores the reader's position
-  instead of jumping back to the top.
+- **Right file panel**: browse, open, create, rename, delete, copy/cut/paste,
+  and reveal project files, with a breadcrumb trail and per-file git status
+  markers (modified, untracked, staged, committed-but-unpushed, ignored). A
+  **Git** view shows the current branch, clickable branch pills for checkout,
+  and a commit list whose entries open an editable commit-message window (amend
+  HEAD, agent-generated messages, or checkout). A **Search** view runs a
+  project-wide literal content search and lists matching lines that jump straight
+  into the in-app viewer. The panel can be pinned open instead of hover-revealed;
+  additional views list tracked external windows.
 - **Local autocomplete (opt-in, private)**: in the editable text/LaTeX/markdown
   viewers, `Ctrl+Space` requests a single completion from a **local Ollama**
-  model (`Tab` accepts, `Esc` dismisses). It is OFF by default and per file
-  type; nothing is sent anywhere unless you enable it, and if Ollama isn't
-  running it fails silently — no remote calls, ever.
+  model (`Tab` accepts, `Esc` dismisses). It is OFF by default; each editor tab
+  has its own **Autocomplete** toggle + length-mode (Sentence/Block/Scope) in the
+  header that overrides the per-type default, so you can enable it just for the
+  tab you're in. Nothing is sent anywhere unless you enable it, and if Ollama
+  isn't running it fails silently — no remote calls, ever.
+- **Local grammar check (opt-in, private)**: the same editable viewers can run a
+  **local Ollama** proofreader after a typing pause, underlining spelling (red),
+  grammar (blue), and style (green) issues; hover a mark for the explanation and a
+  one-click fix. Like autocomplete it is OFF by default with a per-tab **Grammar**
+  toggle in the header, and entirely local — no text leaves the machine.
 - **Global app toolbar**: cross-project roles (Browser, Mail, Calendar, File
   Manager, Password Manager, Notes, Screenshot, etc.) with launch-or-raise and
-  icon resolution.
+  icon resolution. The Screenshot role launches straight into interactive
+  region selection when the configured tool supports it.
 - **Ollama model management**: the Settings Ollama panel shows installed
   models, running CPU/GPU state, parameter and quantization details, plus
   catalog install, update, unload, and delete controls.
@@ -292,6 +350,91 @@ configuration.
   pointer hover and disappear when the pointer leaves, keeping the center
   terminal unobstructed; the right panel can also be pinned permanently open.
 
+### In-app file viewers
+
+Drag a file from the tree onto a subwindow's tab bar to open it in a tab; the
+viewer is chosen by extension. In-progress types open in the external default
+app until they land.
+
+| Viewer | Extensions | Status | Notes |
+| ------ | ---------- | ------ | ----- |
+| **Text / code** | `.txt` `.toml` `.py` `.rs` `.ts` `.bib` + many more, plus extensionless files like `Dockerfile` | ✅ Shipping | Editable editor: line-number gutter, syntax highlighting, Tab/Shift+Tab indent, undo/redo (`Ctrl+Z`/`Ctrl+Shift+Z`), find (`Ctrl+F`) and find-and-replace (`Ctrl+R`) with match nav + case toggle, save (`Ctrl+S`); unsaved lines marked; non-destructive auto-reload banner; opt-in local autocomplete and grammar check. |
+| **Markdown** | `.md` `.markdown` `.mdx` | ✅ Shipping | Rendered preview with an Edit/Preview toggle; links to local files are clickable. |
+| **YAML / JSON** | `.yaml` `.yml` `.json` | ✅ Shipping | Editable structure tree with a Tree/Source toggle: retype a value, rename a key, add a key or list item (with a type picker), reorder, delete. Both of YAML's syntaxes are first-class — block (`key:`) and flow (`{a: 1}`, which is exactly JSON, on one line or spread over many) — and each keeps the style it is written in. The tree edits the file's own text, so comments, quoting and layout survive an edit; it withholds the affordance rather than botch a construct it can't rewrite (anchors, merge keys). Source is the full code editor. |
+| **LaTeX** | `.tex` | ✅ Shipping | Code editor + compile (when a TeX engine is on `PATH`, shell-escape stripped); follows `\input{…}`/`\includegraphics{…}`, `\ref`/`\cite` completion from `\label` keys and `.bib` entries; parsed compile errors jump to the line; bidirectional SyncTeX sync across tiled or detached panes. |
+| **PDF** | `.pdf` | ✅ Shipping | Rendered with a themed zoom toolbar. |
+| **Images** | `.png` `.jpg` `.bmp` `.webp` … | ✅ Shipping | Zoom-to-cursor / pan; draggable out as an OS drop source. |
+| **Animated GIF** | `.gif` | ✅ Shipping | Frame-level transport on top of the image viewer's zoom/pan: play/pause, frame stepping, scrubber, playback speed, loop toggle, frame/delay readout. Decoded in-app (pure LZW decoder), so it works over SFTP too; a GIF the decoder can't handle degrades to the native animated `<img>`. |
+| **Table / CSV** | `.csv` `.tsv` | ✅ Shipping | Read-only grid (RFC 4180-style parse); large files are windowed to keep the webview responsive. |
+| **Jupyter notebook** | `.ipynb` | ✅ Shipping | Read-only render of cells top-to-bottom — markdown cells, Python-highlighted code cells, and their classified outputs. |
+| **Diff / patch** | `.diff` `.patch` | ✅ Shipping | Color-coded add/del rendering that reads in light and dark themes. |
+| **OpenDocument Text** | `.odt` | ✅ Shipping | Read-only: unzips the archive and renders `content.xml` to a safe HTML subset (headings, lists, tables, images). |
+| **Spreadsheet** | `.xlsx` `.xls` `.xlsm` | ✅ Shipping | Backend reader (calamine) into the table grid, with a sheet picker. |
+| **SQLite** | `.db` `.sqlite` `.sqlite3` | ✅ Shipping | Read-only table browser: table list + paged row grid. |
+| **HTML / SVG** | `.html` `.htm` `.svg` | ✅ Shipping | Editable source editor with a sandboxed (no-script) live preview, Preview ⇄ Source toggle. |
+| **Audio / video** | `.mp3` `.mp4` `.webm` `.wav` … | ✅ Shipping | Native in-tab `<audio>`/`<video>` player. |
+
+Other office formats (`.docx`, `.pptx`, `.ods`, …) open in their external
+default app. Viewer behaviour is configured per file type under **Settings →
+Native Viewers**: the per-type autocomplete and grammar-check defaults (each tab
+can override them from its header) plus a global autosave switch. The text/LaTeX/Markdown editors carry an `A−`/`A+` text-size control
+(`Ctrl` +/−, `Ctrl`+0 to reset; scales the Markdown preview too), persisted
+per file type. Every viewer remembers where you left off — editor/PDF scroll
+position, PDF/image zoom, and image pan persist per tab, so reopening a file (or
+restarting Eldrun) restores your position instead of jumping to the top.
+
+### Agent support
+
+Eldrun launches agents in xterm.js PTY tabs. The table below describes the
+current integration state.
+
+#### CLI agents (xterm.js terminal tabs)
+
+| Agent                                      | Integrated | Tested  | Notes                                                                                                                                               |
+| ------------------------------------------ | ---------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Claude** (`claude`)                      | Yes        | Yes     | Default agent command. Full tab lifecycle, layout persistence, project-scoped sandbox env.                                                          |
+| **Codex** (`codex`)                        | Yes        | Yes     | Selectable as default agent command in Settings. Same tab lifecycle as Claude.                                                                      |
+| **Gemini** (`gemini`)                      | Yes        | Yes     | Selectable as default agent command in Settings. Same tab lifecycle as Claude and Codex.                                                            |
+| **Vibe** (`vibe`)                          | Yes        | No      | Listed as a selectable agent command; same tab lifecycle.                                                                                           |
+| **Ollama via Vibe** (`vibe` + local model) | Yes        | Partial | Installed Ollama models appear under Local Agents. Each local tab gets an isolated per-model `VIBE_HOME` under `~/.local/share/eldrun/vibe_local/`. |
+| **Shell**                                  | Yes        | Yes     | Plain interactive shell tab in the project directory.                                                                                               |
+| Mistral CLI                                | No         | No      | Not integrated. Can be used in a plain shell tab.                                                                                                   |
+| Qwen CLI                                   | No         | No      | Not integrated.                                                                                                                                     |
+| Grok CLI                                   | No         | No      | Not integrated.                                                                                                                                     |
+
+The active agent command (`claude`, `codex`, `gemini`, or `vibe`) is set in
+Settings. If the configured command is not found in `$PATH`, Eldrun falls back
+to the system shell. Project-bound terminals also receive a best-effort project
+sandbox: the child process runs in the project directory with project-local XDG
+config, cache, data, state, and temp locations under
+`<project>/.eldrun/sandbox/`. The root orchestration terminal keeps the normal
+workspace environment.
+
+**Session resume.** Claude and Codex tabs that carry a session id are persisted
+across restarts and respawned with their prior conversation. Eldrun installs a
+`SessionStart` hook (into `~/.claude/settings.json` and `~/.codex/config.toml`) —
+a POSIX shell script on Linux, a PowerShell `.ps1` on Windows — that records each
+tab's live session id keyed by an `ELDRUN_TAB_UID` env var, so resume follows the
+live session even across a `/clear`. (Codex hooks need a one-time `/hooks` trust
+before they fire; Gemini and Vibe tabs are still dropped.)
+
+Local Ollama models are available from the tab `+` menu when Ollama is
+installed and reachable. Eldrun can start the Ollama service, list installed
+models, and create a `vibe` tab for a selected model. The per-model `VIBE_HOME`
+config pins `active_model`, registers the Ollama provider, and disables Vibe
+tool calls for local models so local tabs do not mutate global `~/.vibe`
+configuration.
+
+### Platform support
+
+| Platform                  | Status             | Notes                                                                                        |
+| ------------------------- | ------------------ | -------------------------------------------------------------------------------------------- |
+| **Linux — X11**           | Yes                | Two-desktop workspace parking model (EWMH/xcb). Primary development target.                  |
+| **Linux — KDE Wayland**   | Yes                | Per-project virtual desktop model via KWin DBus scripting. KDE 5 and KDE 6 supported.        |
+| **Linux — other Wayland** | Partial            | Null backend (no workspace switching, no sticky windows). Terminal and file management work. |
+| **Windows**               | Yes                | Win32 `SW_HIDE`/`SW_SHOW` parking model (+ best-effort virtual-desktop pinning). Start-Menu app launch with `.lnk`/icon resolution, default-app mapping, downloads routing, external-window tracking, OpenVPN, SSH/SFTP remote projects, and Claude/Codex agent resume. |
+| **macOS**                 | Experimental shell | Null workspace backend (no per-project window parking). Browser downloads config and local Ollama detection work; app launching and file defaults fall back to the OS. |
+
 ### Platform and packaging
 
 - **Network indicator**: probes connectivity and shows online/offline plus wired
@@ -299,20 +442,25 @@ configuration.
 - **Keyboard shortcuts**: Eldrun opens fullscreen by default; `F11` toggles
   fullscreen; `Super` toggles all panels.
 - **Crash logging**: Rust panic hook appends to `~/.local/share/eldrun/crash.log`.
-- **Packaging**: Debian `.deb` and AppImage targets.
+- **Packaging**: Linux `.deb` and AppImage plus a Windows NSIS `.exe` installer,
+  built and published per `v*` tag by `.github/workflows/ci-cd.yml`.
 
 ## Current Limits
 
-- Live X11 window embedding (frameless reparenting of an external app into a
-  tab) is not yet implemented; files render in built-in in-app viewers where
-  available, otherwise open via `xdg-open` and are tracked as external windows.
+- Live window embedding (frameless reparenting of an external app into a tab) is
+  not yet implemented; files render in built-in in-app viewers where available,
+  otherwise open in the OS default app (`xdg-open` / shell open) and are tracked
+  as external windows.
 - KDE Wayland workspace management needs live-session QA.
+- macOS runs on the null workspace backend (no per-project window parking).
 - Terminal/tab layout is persisted per project; shell, file-viewer, and
   resumable Claude/Codex agent tabs are restored on relaunch, but other agent
   tabs (Gemini, Vibe) and live PTY scrollback are not.
 - Detached (popped-out) subwindows and project-box scopes are session-only: the
   former re-docks and the latter's tabs are dropped on project switch / restart.
 - Non-KDE Wayland compositors fall back to the null backend.
+- Remaining office formats (`.docx`, `.pptx`, `.ods`, …) have no native viewer
+  yet and open in the external default app.
 
 ## Project Storage
 
@@ -334,8 +482,24 @@ Global Eldrun state lives in `~/.local/share/eldrun/`:
   each local Ollama model tab.
 
 Project-local state lives in each project's `project.json`, alongside
-scaffolded files such as `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, `TODO.md`,
-`ROADMAP.md`, `STATUS.md`, and `DOCUMENTATION.md`.
+scaffolded files (created when missing): `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`,
+`TODO.md`, `ROADMAP.md`, `STATUS.md`, `README.md`, `DOCUMENTATION.md`, plus
+`.gitignore` and `.claude/settings.json`.
 
 See [DOCUMENTATION.md](DOCUMENTATION.md) for the detailed architecture, data
 schemas, behavior notes, and known limitations.
+
+## License
+
+Eldrun is dual-licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or
+  <http://opensource.org/licenses/MIT>)
+
+at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual-licensed as above, without any additional terms or conditions.
diff --git a/STATUS.md b/STATUS.md
index 3b752cb..8faad4c 100644
--- a/STATUS.md
+++ b/STATUS.md
@@ -65,7 +65,9 @@ Last reviewed: 2026-06-06
   take minutes for large models.
 - Starting the system Ollama service depends on local user permissions; Eldrun
   falls back to a user `ollama serve` process when needed.
-- Open-app restore is best-effort relaunch; window geometry is not restored.
+- Open-app restore is best-effort relaunch; the geometry of *externally launched
+  app* windows is not restored. Eldrun's own main window does reopen on the
+  monitor, at the position/size, and in the maximized state it was last closed in.
 - Download routing browser preference edits assume the browser is not running.
 
 ## Time Log
diff --git a/TODO.md b/TODO.md
index 95c9866..361f440 100644
--- a/TODO.md
+++ b/TODO.md
@@ -2,28 +2,33 @@
 
 ## Context
 
-This is the single home for open implementation plans, organized into coherent
-groups with stable numbers. The raw idea dump lives in `open_ideas.md` (51 loose
-ideas spanning the right file-tree panel, the bottom project switcher, X11/KDE
-workspace switching, project import/publishing, git tooling, drag-and-drop
-reordering, remote/SSH projects, branding, session restore, in-app file/text/tex
-viewers, tab renaming/mapping, per-project security & remote-control toggles, a
-native browser, keyboard-driven navigation, and right-panel polish);
-cross-platform
+This is the index into the plan of open implementation work. Each group lives
+in its own file under [`todo/`](todo/); this file only tracks group letters,
+one-line descriptions, and status, plus the context that applies across all of
+them (status legend, competitive evaluation, sequencing, verification
+approach). The raw idea dump lives in `open_ideas.md` (51 loose ideas spanning
+the right file-tree panel, the bottom project switcher, X11/KDE workspace
+switching, project import/publishing, git tooling, drag-and-drop reordering,
+remote/SSH projects, branding, session restore, in-app file/text/tex viewers,
+tab renaming/mapping, per-project security & remote-control toggles, a native
+browser, keyboard-driven navigation, and right-panel polish); cross-platform
 Windows/macOS follow-ups (#30–#31), backend runtime follow-ups (#32), and the
-global-app URI-routing item (#33) were consolidated here from the former separate
-plan file and the old `TODO.md`. The goal of this plan is
-**not** to implement everything at once, but to organize the ideas into coherent
-groups with stable numbers so you can say "do #14" and I can act on a
-well-scoped unit.
+global-app URI-routing item (#33) were consolidated here from the former
+separate plan file and the old `TODO.md`. The goal of this plan is **not** to
+implement everything at once, but to organize the ideas into coherent groups
+with stable numbers so you can say "do #14" and I can act on a well-scoped
+unit.
 
-Exploration confirmed several ideas are partially built already — those notes are
-called out per item so we don't rebuild existing infrastructure.
+Exploration confirmed several ideas are partially built already — those notes
+are called out per item so we don't rebuild existing infrastructure.
 
 Numbering is **global and stable** (1–65); new ideas are appended with new
 numbers so existing references never shift. Open groups are lettered A, B, C…
-(roughly in suggested sequence); completed groups are renumbered D.1, D.2… and
-collected at the **end** of this file. You can pick any item in any order.
+(roughly in suggested sequence); completed groups are collected in
+[`todo/done.md`](todo/done.md), renumbered D.1, D.2… where that's already
+happened (a couple of done groups — N, U — are still under their original
+letter, not yet renumbered; see that file). You can pick any item in any
+order.
 
 ## Status legend — Done ≠ Tested
 
@@ -40,14 +45,10 @@ Each done feature carries two checkboxes — one per verification axis — with
 example test in words to guide both. A feature is fully **🧪 Tested** only when
 **both** boxes are ticked.
 
-> ✅ **Automated coverage complete; 🖐️ manual QA still pending.** Every done
-> feature below now has a passing automated test (frontend `vitest` +
-> backend `cargo test`), so all 🤖 boxes are ticked — the sole exception is
-> **#25** (logo/icons), which is purely visual and has no meaningful automated
-> test. A few are partial (noted inline): **#11** covers the CPU sampling
-> helpers but not the live % readout, and **#22** covers `shell_quote` argv
-> escaping but not the full `gh`/`ssh` publish flow. **No 🖐️ Manual box is
-> ticked yet** — nothing has been runtime-QA'd in a live Eldrun, so treat each
+> ✅ **Automated coverage complete; 🖐️ manual QA still pending** for every done
+> group (see [`todo/done.md`](todo/done.md) for the current exception list —
+> a couple of items are visual-only or partial-coverage). No 🖐️ Manual box is
+> ticked yet — nothing has been runtime-QA'd in a live Eldrun, so treat each
 > feature as fully 🧪 Tested only once its manual box also flips.
 
 ---
@@ -149,1045 +150,34 @@ toward broad, cloud, team-scale agent automation — and the defensibility
 
 ---
 
-## Group A — Bottom Panel: Meta-Project Grouping (new feature)
-*Files: data model (`schema/project.rs`/`projects.rs`, `types/index.ts`), `ProjectSwitcher.tsx`, `ProjectPill.tsx`. No grouping concept exists today.*
+## Open groups
 
-13. **Project boxes / meta-project management.** Right-click to create a named,
-    renamable box (e.g. PaperBox, CodingBox) that groups projects, with
-    drag-and-drop of pills into boxes. Requires a new grouping field in the
-    project/entry schema plus drag-drop UI and grouped rendering. Largest bottom-
-    panel item.
-    > **Phase 1 (#13) DONE (🤖 covered).** Box model (`schema/boxes.rs`
-    > `ProjectBox`/`BoxRelation`, `boxes.json`) + box CRUD commands
-    > (`commands/boxes.rs`: get/save/create/rename/delete/set_box_members) +
-    > native-DnD pill-into-box + ungrouped-drop-zone + grouped pill rendering with
-    > a distinct `.project-box-chip` (badge + member count) +
-    > `stores/boxes.ts`/`BoxChip.tsx`. `box_id` rides in `ProjectEntry.extra`;
-    > member_ids authoritative, `box_id` derived in-memory on load (no write).
+| Group | File | Description |
+| --- | --- | --- |
+| A | [`todo/group-a.md`](todo/group-a.md) | Bottom Panel: Meta-Project Grouping — "project boxes" to group related pills into one (#13 core UI, #41 multi-project merge). |
+| C | [`todo/group-c.md`](todo/group-c.md) | Workspace Switching / Platform Stability — X11/KDE hidden-workspace hardening, window z-order, i3-style tiling mode, cross-OS verification. |
+| E | [`todo/group-e.md`](todo/group-e.md) | Git Worktree — mostly done (#23); "open worktree as project" stretch goal still deferred. |
+| F | [`todo/group-f.md`](todo/group-f.md) | Session Restore — wire up unused `active_session.json` startup restore on top of existing terminal/tab persistence. |
+| G | [`todo/group-g.md`](todo/group-g.md) | Remote / SSH & Containerized Projects — largest net-new backend surface: work-remote axis, SSH/SFTP-native projects, Docker sandboxing, VPN. |
+| H | [`todo/group-h.md`](todo/group-h.md) | Cross-Platform: Windows & macOS Support — follow-ups on the already-landed platform foundations. |
+| I | [`todo/group-i.md`](todo/group-i.md) | Backend Runtime Follow-Ups — hardening on top of the first `services/` runtime boundary pass. |
+| J | [`todo/group-j.md`](todo/group-j.md) | Web & Mail Surfaces — URI routing to external apps (#33), plus in-app mail (#65) and browser (#61) counterparts. |
+| L | [`todo/group-l.md`](todo/group-l.md) | Center Panel: Tabs, Subwindows & Navigation — detach-to-window, tab UX fixes, keyboard nav, on top of the done tiling split model. |
+| M | [`todo/group-m.md`](todo/group-m.md) | In-App Viewers — text/TeX/image enhancements (Phase 2+) on top of the done file→tab viewer infrastructure. |
+| N | [`todo/group-n.md`](todo/group-n.md) | Internationalization (i18n) — full app-wide translation coverage; in progress, ~40% of components done. Plan: [`docs/i18n_translation_plan.md`](docs/i18n_translation_plan.md). |
+| O | [`todo/group-o.md`](todo/group-o.md) | Project Security & Permissions — per-project policy for downloads, agent spawn, and git-push guardrails. |
+| R | [`todo/group-r.md`](todo/group-r.md) | Right Panel: Polish & App-Window Tracking — follow-on polish + a tracking-display bug on the done pin toggle. |
+| S | [`todo/group-s.md`](todo/group-s.md) | Local Agents via Ollama — generalize the local `vibe` model tab into a family of local Ollama-backed agent tabs. |
+| T | [`todo/group-t.md`](todo/group-t.md) | Smart / Native Shell Terminal — research done, not yet built; shell-completion via a new Ollama command. |
+| P | [`todo/group-p.md`](todo/group-p.md) | Git Hosting: Multi-Host Publishing — generalize the GitHub-only publish flow to GitLab + generic remote URLs. |
 
-41. **Project box containers (merge of two or more projects).** Building on #13,
-    let a box be opened as a single *merged* workspace that spans its member
-    projects rather than just a pill grouping. Specifics:
-    - **Merged file view in the right panel.** Extend the right-panel file tree
-      (`FileTree.tsx`/`RightPanel.tsx`) to render a box as a multi-root view —
-      each member project listed as a top-level node, populated from that
-      project's **stored state** (its `project.json` tree layout / file metadata)
-      rather than re-walking only one root. Reuse the existing per-project file
-      model so each member keeps its own git markers, hidden-file sections, etc.
-    - **A box folder in the eldrun root.** Create a `~/eldrun/boxes/<box-name>/`
-      (or similar under the eldrun root) directory per box to host box-scoped
-      state and serve as the cwd for the box's terminals/agents.
-    - **Agent tabs rooted in the box, hinted to each member.** Start the box's
-      agent tabs rooted in the box folder, seeding each agent with hints/pointers
-      to every member project's local agent files (`CLAUDE.md`/`AGENTS.md`/
-      `GEMINI.md` and paths) so the agent can work across all merged projects
-      from one place.
-    - **Boxes in the project search (merge is opt-in).** Surface boxes as results
-      in the "Search inactive…" box (`ProjectSwitcher.tsx`,
-      `activateSearchResult`/`results`) alongside individual projects; picking a
-      box result opens the merged box workspace. The merge is **opt-in** — a box's
-      member projects stay independently searchable and can each be loaded on
-      their own as a normal single project, without activating the box merge.
-    - **Visual distinction box vs. single project.** Give boxes a distinct look
-      from single projects everywhere they appear — in the search results
-      (`project-search-row`), the pills (`ProjectPill.tsx`/`project-switcher`),
-      and the right-panel multi-root header — e.g. a box icon/badge, member count,
-      and/or a grouped style, so a merged box is never mistaken for a plain
-      project. Add the corresponding styles in `themes.css`.
-    - **Inter-project relations within a box.** Let a box record directed
-      relations between its members — "a change in project A may influence
-      project B" — e.g. project B depends on a Python library developed in project
-      A, so editing A's library can break/affect B. Model as relation edges in the
-      box metadata (source → dependents, with an optional kind/label like
-      "python-lib" and an optional path/package hint). Surface them so the
-      dependency is visible and actionable: show related members in the box view,
-      flag dependents when a source changes (tie into the existing git-status
-      markers so a dirty source highlights its dependents), and seed the box's
-      agent hints with the relation graph so a cross-project agent knows which
-      members a change ripples into. Auto-detection of relations (e.g. scanning
-      `pyproject.toml`/`requirements.txt`/imports for local-path deps between
-      members) is a stretch goal; manual declaration is the baseline.
-    - Schema/model: extends the #13 grouping field with box-as-workspace metadata
-      (member list, box folder path, relation edges); touches
-      `schema/project.rs`/`projects.rs`, `types/index.ts`, `ProjectSwitcher.tsx`,
-      `RightPanel.tsx`/`FileTree.tsx`, and the runtime/spawn path that sets
-      agent-tab cwd + env. Scope to be refined when picked.
-    > **Phase 2 (#41 groundwork) DONE (🤖 covered):** full box schema stored
-    > (`folder`, `relations` via `set_box_relations`), lazy
-    > `~/eldrun/boxes/<name>/` creation (`ensure_box_folder`, idempotent +
-    > name-collision-safe against reserved `folder`s and on-disk dirs), boxes in
-    > the project search (`.project-search-row.is-box`, opt-in — members stay
-    > searchable), and opt-in box activation (`openBox` → `box:<id>` scope rooted
-    > in the box folder). **Box scopes are session-only this pass** —
-    > `switch_project_runtime` does not persist/restore them.
-    > **DEFERRED (explicit follow-on, NOT this pass):** Phase 3 merged multi-root
-    > file tree (`RightPanel.tsx`/`FileTree.tsx`); Phase 4 agent-hint seeding +
-    > relation-graph surfacing (dirty-source→dependent git markers,
-    > auto-detection). Schema groundwork for both is in place.
-    - [x] 🤖 Automated test — `commands/boxes.rs` cargo tests (reconcile drops
-      unknown member_ids / recomputes box_id inverse / drop-on-delete, gap-spaced
-      position, defaults round-trip, folder-collision suffixing); `paths.rs`
-      `boxes_root`; vitest `BoxAssignment` (assign/unassign/move/delete sweep,
-      create/rename, derive-on-load no-write), `BoxRendering` (grouped vs inline,
-      orphan box_id inline, chip drop ≠ reorder, ungrouped drop), `BoxSearch`
-      (is-box row → openBox, members independently searchable). Covers Phase 1 +
-      Phase 2 groundwork; Phase 3/4 deferred.
-    - [ ] 🖐️ Manual test
+Completed groups (code-complete, automated tests green, manual QA pending
+across the board) live in [`todo/done.md`](todo/done.md).
 
----
-
-## Group C — Workspace Switching / Platform Stability
-*Files: `src-tauri/src/platform/x11.rs`, `wayland_kde.rs`, `null.rs`, `services/window_service.rs`, `services/project_runtime.rs`, `commands/workspace.rs`.*
-
-15. **Securely move opened files/windows to the hidden workspace on switch
-    (X11).** Fix the reported issue where files/windows opened in one project
-    aren't reliably parked on the hidden desktop when switching. Investigate the
-    move-retry logic (x11.rs ~retry 5×30ms) and window registry coverage.
-
-16. **Make X11 workspace switching rock-solid.** Broader hardening of the
-    two-desktop parking model — fix all known races/flakiness around
-    show/hide/switch. (#15 is a specific symptom of this.)
-
-17. **Preserve window z-order across switches.** Today `show_window` always
-    raises to `Above` (x11.rs:120), losing stacking order. Track per-window
-    z-order in the window registry/session and restore it on show.
-
-18. **KDE Plasma i3-style workspace mode.** Explore an i3-like tiling/workspace
-    behavior on KDE Plasma. Note: KDE Wayland per-window show/hide is currently a
-    **no-op** (`wayland_kde.rs:74-80`) and needs KWin scripting first — this is
-    research + sizable backend work.
-
-19. **Cross-platform verification: Windows, macOS, KDE Plasma.** Verify the app
-    runs and degrades gracefully where workspace backends are absent (null
-    backend) and KDE works. Mostly QA + targeted fixes. OS-specific build,
-    packaging, and native-window work is tracked separately in Group H (#30/#31).
-
----
-
-## Group E — Git Worktree (new feature)
-*No worktree code exists anywhere today.*
-
-23. **Git worktree support.** Add backend commands to create/list/remove git
-    worktrees and surface them in the UI (likely tied to Group D.3 history view
-    and/or project switching). Net-new feature; scope to be defined when picked.
-
----
-
-## Group F — Session Restore
-*Files: `src-tauri/src/schema/active_session.rs` (defined but unused), `services/project_runtime.rs`, `terminal_service.rs`, `src/stores/tabs.ts`, `CenterPanel.tsx`.*
-
-24. **Restore/resume agent sessions.** Terminal/tab layout persistence already
-    exists (`.eldrun/sessions/terminals.json`), but app-startup restore via
-    `active_session.json` is **unused**. Wire up restoring the full prior session
-    (active project, tabs, windows) on launch. Feasibility note: resuming the
-    actual *agent* process state depends on the agent CLI's own resume support;
-    realistic scope is restoring tabs + relaunching the agent, not live state.
-    Agent-resume approach (migrated from TODO `ISSUE-RESUME`): when restoring a
-    tab, detect that tab's most recent agent session ID from the agent's own
-    session directory — Claude Code `~/.claude/projects/<encoded>/`, Codex
-    `~/.codex/sessions/`, Gemini `~/.gemini/history/`, Vibe
-    `$VIBE_HOME/logs/session/` — and pass `--resume <id>` when respawning. A
-    prior attempt was removed 2026-06-07 because detection was unreliable and
-    **each tab must track its own distinct session ID** (not the project-global
-    latest) to work with multi-agent setups; solve per-tab session tracking
-    before relying on `--resume`.
-
-39. **Per-tab agent session restore — stepwise.** Concrete, incremental path to
-    #24's hard part (per-tab session tracking), built one step at a time so each
-    step is verifiable on its own.
-    - [x] **39a — Surface a tab's launch session id (Claude).** ✅ Done. Eldrun
-      mints a UUID and launches Claude with `claude --session-id <uuid>`, stored
-      on `TabEntry.sessionId` and shown on tab hover. This **launch id** is
-      deterministic, stable, and unique per tab. *Files: `stores/tabs.ts`
-      (`sessionId`), `components/tabs/TabBar.tsx`.* Pure frontend — no rebuild.
-      **Known limitation (drove the design):** the id does **not** follow a
-      `/clear` (which rolls Claude onto a new session id). A first attempt
-      resolved the "live" id from the newest `<uuid>.jsonl` in
-      `~/.claude/projects/<encoded-cwd>/`, but that was **removed** — all Claude
-      sessions in a project (other tabs, *and the dev agent running in the same
-      cwd*) share one folder, so "newest file" cross-contaminates: two tabs
-      showed the same id and it drifted as any session wrote. Following `/clear`
-      reliably needs per-process attribution, not directory guessing → 39c.
-      - *Test (e.g.):* open two Claude tabs in one project → each hover shows a
-        distinct, stable UUID that never changes while the tab is open.
-      - [ ] 🤖 Automated test — none yet (trivial frontend tooltip; covered by
-        manual)
-      - [ ] 🖐️ Manual test
-    - [x] **39b — Persist agent tabs with their session id.** ✅ Done.
-      Resumable agent tabs (Claude with a `sessionId`) are now persisted in
-      `tab_layout` (carrying `sessionId`) and restored on relaunch; other agent
-      tabs are still dropped. *Files: `schema/project.rs` (`TabEntry.session_id`),
-      `stores/tabs.ts` (`isRestorableTab`/`saveLayout`/`loadFromLayout`),
-      `stores/projects.ts`, `components/layout/CenterPanel.tsx`.*
-    - [x] **39c — Track the live session id across `/clear`, then resume.** ✅
-      Done for Claude. The original hard part — following the *live* session id
-      after `/clear` (Claude rolls onto a fresh id with no recorded back-link to
-      the launch id) — is solved with a global Claude **`SessionStart` hook**
-      (fires on startup/resume/clear/compact) that records the live `session_id`
-      keyed by `$ELDRUN_TAB_UID`. Eldrun sets `ELDRUN_TAB_UID` to the tab's
-      stable launch id on spawn, then at (re)spawn resolves the hook-recorded
-      live id and emits `claude --resume <live-id>` (falling back to the launch
-      id, and downgrading to `--session-id` when no log exists yet). The hook is
-      installed once into `~/.claude/settings.json` and no-ops for any Claude not
-      launched by Eldrun. *Files: `services/agent_session.rs` (hook install +
-      live-id store), `terminal/mod.rs` (`resolve_claude_session`), `lib.rs`
-      (install at startup). Hook script: `~/.local/share/eldrun/hooks/`; live ids:
-      `~/.local/share/eldrun/live_sessions/`.*
-    - [~] **39d — Generalize to other agents.** Codex done; Gemini/Vibe open.
-      - [x] **Codex.** ✅ Done. Codex mints its own session id (no launch-time
-        `--session-id`), but it has a Claude-style `SessionStart` hook and resumes
-        by uuid (`codex resume <id>`). Eldrun sets `ELDRUN_TAB_UID` (a per-tab key)
-        on the Codex tab, installs a `SessionStart` hook into `~/.codex/config.toml`
-        (TOML text-append, idempotent) that records the live session id under that
-        key, then at spawn resolves it and launches `codex resume <live-id>` when a
-        rollout log exists (else fresh). Covers `/clear` (Codex `source` includes
-        `clear`). *Files: `services/agent_session.rs` (`register_codex_hook`),
-        `terminal/mod.rs` (`resolve_codex_session`/`codex_session_exists`),
-        `stores/tabs.ts` (`RESUMABLE_AGENTS.codex`), `components/tabs/TabBar.tsx`.*
-        ⚠️ **Manual step:** user-level Codex hooks require a one-time trust
-        approval — run `/hooks` in Codex and trust the Eldrun hook; until then
-        resume is inert (Codex starts fresh, nothing lost). Also unverified at
-        runtime: whether Codex forwards `ELDRUN_TAB_UID` to the hook's env.
-      - [ ] **Gemini.** `--session-id <uuid>` sets the launch id (already passed),
-        but `--resume` takes an index/`latest`, not a uuid; resume-by-uuid likely
-        needs `--session-file ~/.gemini/tmp/<project>/<uuid>`. No `SessionStart`
-        hook → would drift on `/clear` like pre-fix Claude. Needs runtime verification.
-      - [ ] **Vibe.** `--resume <id>` works but Vibe mints its own id with no
-        launch-id control and no hook mechanism found, so per-tab tracking would
-        need the rejected newest-session-file heuristic. Deferred.
-
----
-
-## Group G — Remote / SSH & Containerized Projects (work axes)
-*Files: `src-tauri/src/schema/project.rs` (project model is local-only:
-`directory` is a local path, no host/remote/container fields), `services/project_runtime.rs`,
-`services/ssh_mount.rs` (mount lifecycle — the pattern for container lifecycle),
-`terminal/` (PTY cwd / exec target), `commands/projects.rs` (create/import),
-`commands/ssh.rs`, file-tree commands. These items share a theme: a **work
-axis** — *where the project's process and files live* (host, SSH remote, or
-container) — as opposed to the git **push** axis (#21/#22).*
-
-28. ✅ **SSH-based projects (remote path, remote agent).** Implemented via an
-    **sshfs mount**: a remote project's bytes live on `host:remote_path` and are
-    mounted to `~/.local/share/eldrun/mounts/<project-id>/`; the project's
-    `directory` points at that mountpoint so the file tree, terminal cwd, and git
-    keep working unchanged. New `RemoteSpec` (`user?`, `host`, `port?`,
-    `remote_path`) on the project schema + `projects.json` `extra`. New
-    `commands/ssh.rs` (`ssh_connect`, `ssh_default_dir`, `ssh_list_dir`,
-    `ensure_project_mounted`) shells out to system `ssh` in `BatchMode=yes`
-    (keys/agent/`~/.ssh/config` are the source of truth; no in-app passwords).
-    New `services/ssh_mount.rs` handles mount/unmount lifecycle (idempotent
-    mount, `/proc/mounts` check, `fusermount -u` with `umount` fallback,
-    sshfs-missing guard, unmount-all on app exit). `create_project`/
-    `import_project` accept an optional `remote` and scaffold over the mount
-    (remote import is `keep`-only). `ProjectSwitcher.tsx` add/import dialog gains an
-    SSH-address field + Connect and an in-app remote folder browser. Active
-    remote project is mounted on startup (best-effort, non-blocking) and on
-    switch. Requires `sshfs`/FUSE locally. **Runtime QA pending** (agents can't
-    launch Eldrun); password/interactive auth out of scope for v1;
-    project-removal unmount is a follow-up (no delete command exists yet — stale
-    mounts are cleaned up on next app exit). See `docs/ssh_projects_plan.md`.
-    - *Test (e.g.):* add a project via SSH address against a key-auth host
-      → folder browser lists the remote dir, the project mounts under
-      `mounts/<id>/`, terminal cwd + file tree work on the remote files, and the
-      mount is cleaned up on app exit.
-    - [x] 🤖 Automated test — `services/ssh_mount.rs` unit tests (validate_arg, mountpoint_for, sshfs_args)
-    - [ ] 🖐️ Manual test
-    - **Manual QA checklist (live, step-by-step).** Runtime test plan for
-      #28/#28b — agents can't launch Eldrun, so these are hand-checks. Each box is
-      one check; a phase is done when all its boxes are ticked.
-      - *Phase 0 — prerequisites / baseline.*
-        - [ ] Local tooling on `PATH`: `sshfs`, `fusermount` (or `umount`); for
-          password auth `sshpass`; for VPN-gated hosts `openvpn` + `pkexec`.
-        - [ ] A reachable host with working key/agent auth; ideally a second
-          host/account that requires a **password** (no key) to exercise `sshpass`.
-        - [ ] `cargo test --manifest-path src-tauri/Cargo.toml` green.
-        - [ ] `npx tsc --noEmit` green.
-      - *Phase 1 — connect (`ssh_connect`/`ssh_default_dir`).*
-        - [ ] Tick **Remote (SSH) project** → SSH address + password + Connect
-          section appears.
-        - [ ] `user@host` (key auth, blank password) → Connect succeeds.
-        - [ ] `user@host:port` with a non-default port → Connect succeeds.
-        - [ ] Bare `host` (no user, via `~/.ssh/config`) → Connect succeeds.
-        - [ ] Password-only host + correct password → Connect succeeds (`sshpass`).
-        - [ ] Wrong password → clear ssh-stderr error, no hang.
-        - [ ] Password auth with `sshpass` not installed → actionable error.
-        - [ ] Unreachable host/bad name → fails within ~10s (ConnectTimeout), UI
-          stays responsive.
-        - [ ] Editing the address/password after connect resets to disconnected.
-      - *Phase 2 — browse (`ssh_default_dir`/`ssh_list_dir`).*
-        - [ ] Browser opens at remote `$HOME`.
-        - [ ] Dirs-first, case-insensitive name sort; hidden entries shown;
-          `.`/`..` hidden.
-        - [ ] Click a dir descends; **Up** ascends; can't go above `/`.
-        - [ ] Dir names with spaces/unicode render correctly.
-        - [ ] No-permission directory → error surfaced, dialog stays usable.
-        - [ ] "Use this folder" commits the chosen remote path.
-      - *Phase 3 — create remote project.*
-        - [ ] Connect → browse → Use folder → Create → project created with a
-          generated id.
-        - [ ] Mounted under `~/.local/share/eldrun/mounts/<id>/`; `directory`
-          points at the mountpoint (check `/proc/mounts`).
-        - [ ] Scaffold files written **over the mount** only where missing.
-        - [ ] `project.json` carries `remote`; `projects.json` entry mirrors it
-          under `extra`.
-        - [ ] Create against a password-only host → confirm mount behavior /
-          error (mount path still `BatchMode=yes`; see 28c password half-state).
-      - *Phase 4 — import remote project.*
-        - [ ] Import an existing remote dir (keep-only) → mounts, persists
-          `remote`, does not relocate bytes.
-        - [ ] Scaffold-fill agent tabs are local-disk-only on remote import.
-      - *Phase 5 — mount lifecycle.*
-        - [ ] Switch away and back → mount persists / re-mount is a no-op.
-        - [ ] Restart with a remote project active → startup best-effort mount;
-          an offline host at boot does **not** block app start.
-        - [ ] Quit → `unmount_all` tears down every mount (`/proc/mounts` clean).
-        - [ ] Hard-kill leaving a stale mount → relaunch reuses it without error.
-        - [ ] Host offline mid-session → reconnect/keepalive recovers; no
-          permanent wedge.
-      - *Phase 6 — behaves like local (over the mount).*
-        - [ ] File tree lists remote files.
-        - [ ] Open/edit/save a file → change lands on the remote.
-        - [ ] Git status/history work against the mountpoint.
-        - [ ] Plain shell tab cwd/behavior as expected (see Phase 7).
-      - *Phase 7 — remote agent execution (`ssh_exec.rs`).*
-        - [ ] Claude agent tab runs **on the remote** via `ssh -tt` (verify
-          hostname/env inside the agent).
-        - [ ] Resize resizes the remote PTY; exit/kill ends the remote session.
-        - [ ] Second tab multiplexes over the ControlMaster socket; master
-          persists ~600s after the last session.
-        - [ ] Userspace CLI (`~/.local/bin`/nvm/pyenv) is found (login-shell PATH).
-        - [ ] Auto-bootstrap (probe → install → re-probe; `exit 127` + hint on
-          failure) runs live in the PTY on a remote missing the CLI.
-        - [ ] First-run `claude login` works inside the remote PTY.
-        - [ ] Local `ANTHROPIC_API_KEY`/`OPENAI_API_KEY` is **stripped** from the
-          remote env (remote's own login used).
-        - [ ] `local_only` tabs (local Ollama) are **not** wrapped — run locally.
-        - [ ] Codex/Gemini/Vibe remote tabs — note current behavior (recipes may
-          not be generalized yet).
-      - *Phase 8 — OpenVPN-gated hosts.*
-        - [ ] Project with `remote.openvpn.config` → tunnel comes up first; VPN
-          password prompted and **never persisted**.
-        - [ ] `openvpn_status` detects an already-up tunnel (no double-connect).
-        - [ ] Missing `openvpn`/`pkexec` → actionable error.
-        - [ ] Quit → `disconnect_all` brings tunnels down.
-      - *Phase 9 — security / argument injection (spot-check; mostly auto).*
-        - [ ] UI can't send a host/user/path beginning with `-` to ssh.
-        - [ ] Control chars / newline / NUL in any field rejected.
-        - [ ] Empty host (or empty user when provided) rejected.
-        - [ ] During a password connect, the password is only in the `SSHPASS`
-          env, never in argv (inspect the process list).
-      - *Phase 10 — persistence & restart.*
-        - [ ] Resumable Claude/Codex tabs in a remote project restore and resume
-          on the remote on relaunch.
-        - [ ] `project.json`/`projects.json` round-trip `remote` across restart.
-    - **28b — Remote agent execution (decided 2026-06-19: agents run ON the
-      remote).** A remote project's bytes are sshfs-mounted **only** for
-      Eldrun's own file tree / git / `list_dir`; terminal **and agent** tabs
-      instead run on the remote host via `ssh -tt`. `services/ssh_exec.rs`
-      (`wrap_pty_options`) rewrites any spawn whose cwd is under the mounts root
-      into `ssh -tt [-p port] [user@]host '<remote_command>'`, multiplexed over a
-      ControlMaster socket; `remote_subdir` maps the local mount cwd back to the
-      remote path and `remote_command` builds `cd <dir> && export … && exec
-      <cli> …`. VPN-gated hosts bring an OpenVPN tunnel up first via
-      `services/openvpn.rs` (pkexec + askpass temp file + ready-marker wait,
-      disconnect-all on exit) when `RemoteSpec.openvpn` is set. Rationale and the
-      rejected alternatives (local-CLI-over-sshfs; per-command `ssh host -- …`
-      helper) are in `docs/ssh_projects_plan.md` → *Remote execution model*. This
-      makes a **userspace** agent-CLI install on the remote load-bearing; the
-      items below close the gaps.
-      - [x] **Login-shell PATH for agent tabs.** `remote_command` now runs agent
-        tabs through `exec "${SHELL:-/bin/bash}" -lc '<quoted cli + args>'` (was a
-        bare `exec '<cli>'` under ssh's non-login shell), so a userspace
-        `~/.local/bin`/nvm/pyenv CLI is on PATH and resolves. Shell tabs keep
-        `$SHELL -l`.
-        - [x] 🤖 Automated test — `remote_command_agent_runs_under_login_shell`
-          asserts the `-lc` login-shell wrap with correct single-quoting
-      - [x] **Auto-bootstrap + detect the remote CLI.** Implemented in new
-        `services/remote_agents.rs` (recipe table keyed by agent base name:
-        probe `bin`, userspace `install`, manual hint). Rather than a separate
-        command, `bootstrap_prelude` is **folded into** `remote_command`'s
-        `$SHELL -lc` script for recognised agents: it probes
-        `command -v <bin>`, runs the userspace installer if missing
-        (claude → `npm install -g @anthropic-ai/claude-code`), re-probes, and
-        `exit 127`s with a manual hint on failure — all live in the PTY, so
-        install progress and the first-run `login` show in the terminal. Unknown
-        commands get no prelude. (Chose PTY-folded over a Tauri
-        `ensure_remote_agent` command: no event plumbing, fully unit-testable.)
-        - [x] 🤖 Automated test — `remote_agents` (`recipe_for` base-name match,
-          `bootstrap_prelude` probe/install/abort) + `ssh_exec`
-          `remote_command_agent_bootstraps_known_cli`
-      - [x] **Remote auth = the remote's own login.** Decided: the remote `claude`
-        authenticates with its own `~/.claude` credentials; the first run prompts
-        an interactive `claude login` in the PTY (works because agent tabs get a
-        real `-tt` PTY). `remote_command` now strips agent-auth env vars
-        (`AGENT_AUTH_ENV`: `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`,
-        `CLAUDE_CODE_OAUTH_TOKEN`, `OPENAI_API_KEY`, `GEMINI_API_KEY`,
-        `GOOGLE_API_KEY`) from the exported env so a local key can't clobber the
-        remote session.
-        - [x] 🤖 Automated test — `remote_command_strips_agent_auth_env` asserts
-          auth vars (and their values) are excluded while ordinary env is kept
-      - [ ] **Generalize bootstrap/detect to other agent CLIs** (Codex, Gemini,
-        Vibe): add one `AgentRecipe` row per agent to `remote_agents::RECIPES`
-        (the framework + claude recipe already ship); keep honoring the existing
-        `local_only` flag (local Ollama agents are never wrapped).
-      - [ ] 🖐️ Manual test — connect (VPN if needed) → open a remote agent tab →
-        the CLI is detected/installed, logs in on first run, and runs a pipeline
-        on the remote (remote GPU/env), with edits visible in Eldrun's file tree.
-    - **28c — Hardening & gaps (two-reviewer review, 2026-06-19).** A
-      code-correctness/security pass plus an architecture pass over #28/#28b.
-      Ordered by severity.
-      - [ ] **[Critical] Remote command injection in the browse commands.**
-        `ssh_list_dir`/`ssh_default_dir`/`ssh_connect` (`commands/ssh.rs`) hand
-        remote argv tokens to `ssh`, which space-joins them into one remote
-        `$SHELL -c` string; `validate_arg` only blocks a leading `-`/control
-        chars, so a `path` containing `;`/`$()`/backticks/spaces (e.g. a remote
-        dir name the user clicks while browsing) runs arbitrary remote code.
-        Route these through a shared `shell_quote` (lift from `ssh_exec`) and
-        send a single pre-quoted remote string; add injection tests (`;`, `$()`,
-        backtick, space, quote).
-      - [ ] **[Critical] Remote agent tabs never resume (ordering bug).**
-        `wrap_pty_options` rewrites `opts.cmd` `claude`/`codex`→`ssh`
-        (`commands/terminal.rs`) *before* `spawn_pty`'s `resolve_agent_session`
-        dispatches on `opts.cmd` (`terminal/mod.rs`), so `--resume`/`codex
-        resume` are never injected; the ELDRUN_TAB_UID + SessionStart mechanism
-        is also local-only (it reads the local `~/.claude`/live_sessions while a
-        remote agent logs on the remote). Resolve session args *before* the
-        ssh-exec rewrite and embed them in `remote_command`, and install the
-        SessionStart hook + live-id lookup on the remote — or document remote
-        agents as non-resumable for now.
-      - [ ] **[High] Serialize `mount()` per project id.** The
-        `is_mounted`→`sshfs` sequence in `ssh_mount::mount` is TOCTOU and
-        `ensure_project_mounted` runs from several call sites concurrently, so
-        two activations can stack FUSE mounts (the second shadows the first;
-        `unmount` removes only one → leak). Guard with a per-id global mutex and
-        re-verify `is_mounted` after `sshfs`.
-      - [ ] **[High] Validate exported env in `remote_command`.** Env keys are
-        interpolated raw into `export {k}=…` (`ssh_exec.rs`); a key containing
-        `=`/space/newline injects a second `&&` command. Require keys to match
-        `^[A-Za-z_][A-Za-z0-9_]*$` and reject NUL in any quoted value; test a
-        malicious key.
-      - [ ] **[High] Centralize VPN-gated activation ordering.** The backend
-        mount path (`project_runtime::ensure_remote_mounted`,
-        `ensure_project_mounted`) never calls `openvpn::connect` — only the
-        frontend does — so switching to a VPN-gated project from the backend
-        fails with an opaque ssh timeout. One entry point should do VPN-connect →
-        mount → exec and fail loudly ("VPN not connected — use Connect in the
-        dialog"), since the backend can't prompt for the password.
-      - [ ] **[High] Resolve the password-auth half-state.** `ssh_mount`/
-        `ssh_exec` hardcode `BatchMode=yes`, so a password-only host browses in
-        the dialog but then fails at mount/exec. Either thread the password via
-        `sshpass`/`SSHPASS` (as `commands/ssh.rs` already does for browse) or
-        gate remote create/import on key/agent auth and mark password hosts
-        browse-only — don't ship the silent half-state.
-      - [ ] **[High] Connection-loss / stale-handle recovery + UX.** sshfs
-        `reconnect` doesn't heal a stale FUSE handle (`is_mounted` still returns
-        true → `mount()` no-ops), and exec tabs die silently. Treat a statfs
-        failure on a mounted path as not-mounted so `mount()` remounts; add a
-        reconnect/remount action and a connection-state badge on remote project
-        pills.
-      - [ ] **[Medium] OpenVPN robustness.** (a) `wait_for_ready` only checks the
-        timeout when a new stdout line arrives, so a silent hang (stuck auth /
-        black-hole) blocks `connect` forever — read on a thread with
-        `recv_timeout`. (b) `is_connected` tracks only tunnels this process
-        started, so a tunnel surviving a crash isn't detected and `connect`
-        spawns a duplicate / `pkexec` re-prompts — reconcile via the pidfile/tun
-        device. (c) teardown via `pkexec kill` re-prompts polkit at exit, so the
-        root tunnel can survive app exit — launch once with a teardown trap or a
-        persistent privileged helper.
-      - [ ] **[Medium] Mount-detection edge cases.** Unescape `/proc/mounts`
-        octal sequences (`\040` etc.) and canonicalize before comparing in
-        `is_mounted` (refactor the field parsing into a pure, unit-tested fn) to
-        avoid stacking/leaks when the state-dir path contains spaces; treat
-        `Some(port) == 0` as "no port"; bound/short-hash the ControlPath so it
-        stays under the AF_UNIX 108-byte limit.
-      - [ ] **[Medium] Host-key (TOFU) trust UX.** Browse/mount use
-        `BatchMode=yes`, which *fails* on an unknown host key with no prompt,
-        while the exec path drops BatchMode to prompt in-terminal — but that's
-        only reached after a mount that already failed. Add an explicit
-        `ssh-keyscan`/known_hosts confirmation step in the connect flow.
-      - [ ] **[Medium] Project-delete teardown + startup GC.** When a delete
-        command lands, `unmount` + remove the mountpoint dir + `ssh -O exit` the
-        control master + `openvpn::disconnect` if unused; add startup GC of stale
-        mounts (ties into the stale-handle fix above).
-      - [ ] **[Medium] Generalization auth stories (extends the open item in
-        #28b).** Adding Codex/Gemini recipes is one `AgentRecipe` row each (npm:
-        `@openai/codex`, `@google/gemini-cli`); Vibe likely needs a
-        `manual_hint`-only entry. Each needs a documented remote-auth story, and
-        verify `local_only` is actually set end-to-end for Ollama-backed tabs.
-      - [ ] **[Low] Smaller items.** Replace `which`-based binary detection
-        (`sshfs`/`sshpass`/`openvpn`) with in-process PATH search; lazy-unmount
-        (`-z`) as a last resort at exit; feed the askpass passphrase to OpenVPN
-        via stdin/fd instead of a 0600 temp file (plaintext currently survives a
-        crash); document `parse_ls_output` symlink-vs-dir `-p` semantics.
-      - [ ] 🤖 **Test coverage to add** — injection-safety of the browse `path`;
-        malicious env keys in `remote_command`; a pure `/proc/mounts` field
-        parser (`\040`); `wait_for_ready` timeout with no output; mount
-        double-spawn; `shell_quote` round-trip incl. NUL/newline.
-      - **Refactor / future ideas.**
-        - [ ] **Factor a target-agnostic spawn-rewrite layer before Docker
-          (#38).** `ssh_exec::wrap_pty_options` hardcodes mount-path detection,
-          `AGENT_AUTH_ENV`, `shell_quote`, the `-lc` login wrap, and the
-          `remote_agents` bootstrap; #38 would duplicate all of it. Extract a
-          trait ("PtyOptions + target descriptor → rewritten argv") with SSH and
-          Docker impls so the resume fix, the recipes, and Phase-2 composition
-          (`ssh … docker exec …`) land once.
-        - [ ] **Document the split-model consistency tradeoffs.** git/`list_dir`/
-          file-tree run locally over sshfs while the agent edits on the remote:
-          slow git, weak sshfs inotify (stale tree), line-ending/identity
-          mismatches. Document the model; consider running `git` on the remote
-          via the exec wrapper; add a manual "refresh file tree" affordance.
-        - [ ] **SSH `LocalForward` per project** to reach remote dev-server ports
-          at `localhost:port`.
-        - [ ] **Remote-status panel** (mount state, control-master liveness, VPN
-          state, last error) for debuggability.
-
-38. **Run projects inside Docker containers.** Let a project be started in a
-    Docker container instead of (or in addition to) directly on the host: the
-    project's terminal/agent tabs run via `docker exec` into a container, with the
-    project directory bind-mounted as the working dir so the file tree and git
-    keep working. Mirrors the two-mechanism split the SSH axis (#28) settled on —
-    a lifecycle service `services/docker_runtime.rs` (cf. `ssh_mount.rs`) and a
-    spawn-rewrite service `services/docker_exec.rs` (cf. `ssh_exec.rs`). **Key
-    difference from #28:** the bytes are already local, so the file tree / git /
-    `list_dir` keep running against the **host** `directory` unchanged — only
-    terminal/agent **spawns** are rewritten into the container. Full plan in
-    `docs/docker_projects_plan.md`. Requires Docker/Podman locally.
-
-    **Data model (both phases).** New `DockerSpec` on the project schema +
-    `projects.json` `extra` (same as `RemoteSpec`). The container source must be
-    **exactly one** of `image` / `dockerfile` / `compose_file`+`service` /
-    existing `container` — model it as a **tagged `ContainerSource` enum** (not
-    four parallel `Option`s) so illegal/empty states are unrepresentable, with a
-    `DockerSpec::source()` validator called in `up` and in create/import. Plus
-    `workdir` (default `/workspace`), `run_args`, `engine` (docker|podman), and a
-    Phase-2-only `remote: Option<RemoteSpec>`. A project is containerized iff
-    `docker` is present. `directory` stays the **host** path in Phase 1 (no
-    mountpoint indirection). Mirror in `types/index.ts`.
-
-    **Review notes (2026-06-19, two-reviewer reconciliation).** The two-service
-    split is sound and `ssh_exec.rs` exists as claimed, but three "cf. SSH"
-    shortcuts do **not** carry over and are folded into the bullets below:
-    project-from-cwd resolution (no local analogue — H below), `down_all`
-    enumeration (no on-disk artifact), and the Phase-2 double-quoting. Plus a
-    container-specific security surface SSH never had (`run_args` flags,
-    bind-mount, file ownership).
-
-    - [ ] **38a — Phase 1: local Docker** (container on the same host;
-      independently shippable).
-      - **Project resolution (do NOT mirror `project_id_from_cwd`).**
-        `ssh_exec::project_id_from_cwd` only works by stripping `mounts_root()`;
-        local docker keeps `directory` = host path with no embedded id, and
-        `ProjectEntry` has no `directory`. **Carry the project id (or the resolved
-        `DockerSpec`) on `PtyOptions` from the frontend at spawn time** (the tab
-        already knows its project) — avoids an O(projects) disk scan and nested-dir
-        ambiguity.
-      - `services/docker_runtime.rs` (new) — lifecycle keyed by project id,
-        `eldrun-<id>` container name convention. `engine_available`,
-        `is_running` (`docker ps` exact match), `up` as a **three-state machine**
-        (missing→`docker run -d -v <host_dir>:<workdir> -w <workdir> … sleep
-        infinity`; stopped→`docker start` (a bare `run` collides on the name);
-        running→no-op), reconciling a **stale config** via an
-        `eldrun.spec-hash=<hash>` label (recreate when the spec diverges);
-        dockerfile→`build` then run; compose→`compose up -d`; existing
-        `container`→verify only. `down`/`down_all` must **never** stop/remove the
-        pre-existing-`container` variant, and scope compose teardown to its file.
-        `down_all` **enumerates from the engine** (`docker ps -q --filter
-        name=^/eldrun-`), not from disk (no mountpoint artifact exists). Serialize
-        per-project `up` so rapid switches don't race two `--name eldrun-<id>`.
-        Argv built as `Vec<String>` for unit-testability.
-      - **Arg validation (stricter than SSH's `validate_arg`).** Keep strict
-        `validate_arg` (no leading-`-`/control chars) for `image`/`workdir`/
-        `container`/`service`; **`run_args` is a separate class** (it legitimately
-        holds flags) — denylist host-escape flags (`--privileged`,
-        `--network=host`, `--pid`/`--ipc=host`, `-v`/`--volume`, `--device`,
-        `--cap-add`, `--security-opt`, `--user`, `--entrypoint`) or gate behind an
-        explicit "advanced/unsafe" ack, and insert a `--` separator before the
-        image/command. Validate `workdir` is **absolute** and reject `/` and
-        system dirs; the bind source is the project `directory` by construction.
-      - **File ownership.** Rootful docker writes root-owned files that break the
-        host file tree/git (which run as the user) — the whole point of the
-        feature. Auto-inject `--user $(id -u):$(id -g)` for image/dockerfile on
-        rootful docker (NOT podman-rootless, whose mapping is inverse), don't
-        relegate it to a manual `run_args` escape hatch.
-      - `services/docker_exec.rs` (new) — rewrite a containerized tab's
-        `PtyOptions` to `docker exec -it -w <in_cwd> [-e K=V…] <name> <cmd…>` (or
-        login shell when cmd empty; `compose exec <service>` for compose).
-        `container_workdir` translates host cwd → in-container path (genuine
-        `remote_subdir` mirror). For the `-e` path, **re-implement** the auth-var
-        (`AGENT_AUTH_ENV`) / `TERM`/`COLORTERM` stripping `remote_command` does
-        (the SSH version exports in a shell string, not `-e` flags); decide
-        whether a local container is denied host API keys. Honor the existing
-        **`local_only`** flag verbatim and sit inside the same
-        `if !opts.local_only` guard at `commands/terminal.rs:30`, mutually
-        exclusive with ssh-wrap in Phase 1.
-      - Wiring: `project_runtime::switch` best-effort `up` on switch to a docker
-        project (precedent: `ensure_remote_mounted` at `project_runtime.rs:93`);
-        `CreateProjectRequest`/`ImportProjectRequest` gain optional `docker`;
-        `lib.rs` `RunEvent::Exit` calls `down_all()` alongside `unmount_all()`;
-        new `commands/docker.rs` (`docker_available`, `docker_list_images`,
-        `ensure_project_container`). Engine default: auto-detect docker→podman,
-        frozen per project at create time.
-      - Frontend: `ProjectSwitcher.tsx` "Run in container" dialog section as a
-        **radio** over the four sources (enforces exactly-one) + workdir/run_args/
-        engine; build a `dockerSpec` and add `docker: dockerSpec` to **both**
-        create/import `req` payloads; extend `canSubmit` (refactor the nested
-        ternary to a function) for docker validity; populate via `docker_available`
-        + `docker_list_images` with the existing `project-dialog-error` surfacing.
-        Startup `ensure_project_container` (in `stores/projects.ts::load()`,
-        fire-and-forget like the SSH path) must **only `start` an already-present
-        container — never implicitly pull/build** (minutes-long, no progress behind
-        a `void`); surface "image missing / build needed" as an actionable error
-        with an explicit Build/Pull action.
-      - *Test (e.g.):* create an image-based project → opening a terminal runs
-        inside `eldrun-<id>`, host edits show in the file tree, git works,
-        container stops on app exit.
-      - [ ] 🤖 Automated test — `docker_runtime`/`docker_exec` argv + workdir
-        translation + `run_args` denylist + exactly-one `ContainerSource` +
-        schema round-trip (no daemon needed)
-      - [ ] 🖐️ Manual test
-    - [ ] **38b — Phase 2: remote Docker** (container on an SSH host; composes
-      #28 with 38a, activated when `DockerSpec.remote` is set).
-      - Bytes: as #28 — sshfs-mount the remote dir locally (file tree/git
-        unchanged). Bind-mount source is the **remote** `remote_path` (the remote
-        daemon mounts the remote bytes directly). The in-container workdir is then
-        a **triple** translation (host cwd → sshfs mountpoint → remote_path →
-        container path) — needs its own test, not just argv shape.
-      - Runtime: spawns run `ssh -tt <host> docker exec …`. **Composition caveat:**
-        `ssh_pty_args(remote, remote_command: &str)` takes a single **string**, so
-        the whole `docker exec …` argv must be collapsed and `shell_quote`d a
-        **second** time on top of `docker_exec`'s own pass — two stacked quoting
-        layers the current single-pass tests don't cover. Do NOT also wrap in
-        `remote_command`'s `-lc '<inner>'`; build `docker exec … <name> $SHELL -lc
-        '<inner>'` once, then quote for ssh. `docker_runtime` engine calls gain an
-        `ssh_base_args` prefix when `remote` is set; `down_all` tears down known
-        remote-docker containers by **iterating the project list** (no local
-        inventory of remote containers exists).
-      - Frontend: "Run in container" becomes available after an SSH connection is
-        established (remote-browse flow from #28).
-      - *Test (e.g.):* remote host with docker → terminal execs into the remote
-        container; host file tree (over sshfs) reflects in-container edits.
-      - [ ] 🤖 Automated test — argv builders produce `ssh … docker …` /
-        `ssh -tt … exec docker exec …` when remote (assert the **double-quoting**
-        round-trips, incl. env values with `$`/quotes); triple workdir
-        translation; `DockerSpec.remote` round-trip
-      - [ ] 🖐️ Manual test
-
----
-
-## Group H — Cross-Platform: Windows & macOS Support (new feature)
-*Files: `src-tauri/src/platform/*`, `services/`,
-`terminal/` (PTY), `commands/` (downloads, crash logging), `src-tauri/tauri.conf.json`
-(bundle targets), `.github/workflows/ci-cd.yml` (package jobs). Both OSes already
-have cross-platform foundations — platform-aware state paths, default-shell
-fallback, browser profile paths, network detection — so this is follow-up work,
-not a from-scratch port. Builds on / supersedes the OS half of #19 (Group C).*
-
-30. **Windows support follow-ups.** Windows is past the compile stage (state
-    paths, shell fallback, browser profiles, network detection, app-icon
-    helpers, NSIS packaging, and a Windows CI package job all exist). Remaining:
-    validate a real build/runtime on Win 10 1903+ and Win 11 (incl. ConPTY
-    behavior in xterm.js); decide whether to replace the command-based PID
-    liveness check with a native Windows API; add native window tracking
-    (`EnumWindows` + `GetWindowThreadProcessId`) if project-owned standalone
-    windows need reliable show/hide; decide on a Windows unhandled-exception
-    crash hook (current crash logging is Unix-oriented); document/improve
-    download routing where directory symlinks need Developer Mode or elevation;
-    and QA browser download-preference editing across Firefox/Chrome/Chromium/
-    Chrome Beta profile layouts.
-
-31. **macOS support follow-ups.** macOS has initial cross-platform code (state
-    paths, default shell, browser profiles, network detection, Unix symlinks,
-    null workspace-backend fallback). Remaining: add bundle support when
-    distribution is needed (`dmg`/`app` target, `minimumSystemVersion`, CI
-    artifact handling); add Hardened Runtime entitlements **only** if
-    signing/notarization is pursued — do **not** enable App Sandbox (PTY needs
-    unrestricted POSIX PTY access); validate a real build on Apple Silicon (and
-    Intel if needed); add native app-icon resolution for `.app` bundles if the UI
-    needs resolved macOS icons; add native window tracking (Accessibility APIs or
-    `CGWindowList`) only if project-owned standalone windows need reliable
-    show/hide; and keep the null workspace backend as the default unless a clear
-    need justifies Accessibility permissions or private APIs.
-
----
-
-## Group I — Backend Runtime Follow-Ups
-*Files: `src-tauri/src/services/` (`project_runtime.rs`, `terminal_service.rs`,
-`window_service.rs`), `commands/`, `.eldrun/sessions/` mirrors, `schema/`. The
-first backend runtime boundary pass is implemented: project switching is
-coordinated through `switch_project_runtime`, core services live under
-`services/`, tab/file/layout/window metadata is mirrored into
-`.eldrun/sessions/`, download routing is part of switching, and the old
-`switch_project_windows` command is deprecated. Related to #24 (session restore),
-but backend-owned.*
-
-32. **Backend runtime follow-ups.** Remaining backend-side work on the runtime
-    boundary, each independently pickable:
-    - Backend-owned PTY resurrection after app restart, including dead-session
-      detection and a clear frontend policy (respawn, mark dead, or manual
-      restart).
-    - Terminal/agent transcript storage if restart recovery needs readable
-      historical output rather than metadata-only restoration.
-    - Promote `.eldrun/` runtime files from optional mirrors to the primary
-      source once compatibility reads from `project.json` are validated.
-    - Durable project-window metadata under `.eldrun/sessions/windows.json`
-      beyond registry IDs (window role/origin, restore command, optional file
-      target, future geometry/focus fields).
-    - Move file-navigation runtime state backend-side once switching is stable:
-      center file tabs, right-panel folder, breadcrumbs, history.
-    - Focused tests for backend runtime switching with mocked services
-      (time flushing, old-project save, project-window hide/show, download
-      routing, root runtime handling, no respawn of already-live tabs).
-
----
-
-## Group J — Web & Mail Surfaces: Routing, In-App Mail & Browser
-*Three related surfaces for web/mail content sharing where-it-lives (right-panel
-view vs. center tab vs. global-app surface), security, and auth decisions. #33
-routes links **out** to the user's configured external apps; #65 and #61 are the
-**in-app** counterparts (read mail / browse the web without leaving the
-workspace). Files: `src/components/layout/GlobalAppBar.tsx` (roles +
-launch-or-raise), `src-tauri/src/commands/apps.rs` (`launch_app`, `open_file`),
-terminal/file-tree link handling (the global-apps suite is already implemented —
-#33 is its last remaining item); plus, for the in-app surfaces, a new
-`commands/mail.rs` + `schema/mail.rs` + `src/components/mail/` (mail) and a Tauri
-webview surface + `src/components/browser/` (browser), and `types/index.ts`. No
-mail or browser code exists today.*
-
-33. **URI scheme routing** (migrated from TODO `G6.7`). Intercept `http://`,
-    `https://`, `mailto:`, and `webcal:` links opened from within terminals or
-    the file tree and route them through the global-app launch-or-raise flow
-    (`launch_app`, keyed by the `browser` / `mail` / `calendar` roles) instead of
-    a bare `xdg-open` call, so links open in the user's configured global app.
-
-65. **Include a mail viewer in Eldrun.** Add an in-app email reader so mail can be
-    read without leaving the workspace. Scope to be defined when picked; open
-    questions to settle first: protocol (IMAP vs JMAP vs a provider API like
-    Gmail), auth model (app password vs OAuth, mirroring the SSH "no in-app
-    passwords" stance where possible), read-only vs send/reply, and where it lives
-    (right-panel view like Git/Files, a dedicated center tab, or a global-app
-    surface). Pairs naturally with #33 (`mailto:` routing) once present.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-61. **Include a browser in Eldrun.** Add an in-app web browser so pages can be
-    viewed without leaving the workspace. Weigh the security implications
-    (sandboxing, per-project download routing per #60, credential isolation)
-    before building. Scope and surface (center tab vs. right-panel vs. global-app)
-    to be defined when picked. Pairs with #33 (link routing) and #53 (drag a tab
-    into a browser upload field).
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
----
-
-## Group L — Center Panel: Tabs, Subwindows & Navigation
-*Builds on Group D.11 (tiling split subwindows). All items share the center-panel
-files: `src/stores/tabs.ts` (per-scope layout tree `layoutByScope`,
-`focusedGroupByScope`, active tab), `src/components/layout/CenterPanel.tsx`,
-`src/components/tabs/Subwindow.tsx` / `src/components/tabs/TabBar.tsx`,
-`src/stores/projects.ts`. #42 additionally needs a Tauri multi-window surface
-(`src-tauri/src/lib.rs`, `tauri.conf.json`) + the platform show/hide path
-(`platform/x11.rs`, `platform/wayland_kde.rs`, `services/window_service.rs`,
-`services/project_runtime.rs`); #55–#57 touch `schema/project.rs`; #62 touches
-`src/App.tsx` (global key handlers). #55 (mapping bug) and #62 (keyboard nav) are
-correctness/UX work atop the same layout model #42 detaches.*
-
-42. **Drag a subwindow out of the Eldrun main window.** ✅ Implemented · 🧪 Awaiting
-    live multi-window QA. Let a tiling subwindow
-    (a tab group from Group D.11/#36) be dragged out of the main window and become
-    its own standalone OS window, while keeping it bound to its project. The
-    detached window must follow the **same hide/show logic as on project switch**:
-    when the user switches projects in the main window, a detached subwindow
-    belonging to the now-inactive project is parked/hidden on the hidden workspace
-    (and re-shown on switching back) exactly like other project-owned windows,
-    rather than floating free across all projects.
-    Settled decisions (v1): detach gesture = explicit **pop-out button** (drag-past-
-    edge deferred — WebKitGTK risk); detached window is a **second Tauri
-    `WebviewWindow`** loading the same bundle under `?detached=<scope>:<groupId>`
-    rendering one group (inert to project switches); the group leaves `layoutByScope`
-    and is tracked in `detachedGroupsByScope` while its tab payloads stay in the
-    shared store (PTYs never unmount); detached `TerminalView` is **attach-only**
-    (no `pty_spawn`/no kill-on-unmount — output is broadcast by id; blank until next
-    output, no scrollback restore); restart re-docks (session-only) but a detached
-    group's tabs stay in `project.json` mid-session; parking reuses the existing
-    `project_runtime::switch` path via an `ORIGIN_DETACHED_SUBWINDOW` tracked window
-    + a hardened X11 `set_parkable` override (main window structurally never
-    parkable) **and** a backend-independent Tauri `hide()/show()` fallback so
-    Wayland/KDE/null also hide an inactive project's detached window; re-attach via
-    dock-back button + dock-on-close (`onCloseRequested`) **and Ctrl+drag-to-dock**:
-    Ctrl+dragging the popout's tab bar streams the gesture (screen coords, via the
-    `DETACHED_DRAG_*` events) to the main window, which maps them to client space,
-    shows the normal drop preview, and docks the group on release over a subwindow
-    (`attachGroup` with the resolved edge/center target) — released outside the main
-    window or on Escape, the popout stays floating. A plain (non-Ctrl) tab-bar drag
-    still hands off to the WM for a native window move.
-    Plan/reviews: `docs/group_l_42_detach_plan.md`,
-    `docs/group_l_42_detach_plan_review.md`, `docs/group_l_42_detach_review_code.md`.
-    *Files: `src/stores/detached.ts`, `src/stores/tabs.ts`,
-    `src/components/layout/DetachedApp.tsx` / `DetachedCenterPanel.tsx` /
-    `AppShell.tsx`, `src/components/tabs/TabBar.tsx`,
-    `src/components/terminal/TerminalView.tsx`, `src/App.tsx`;
-    `src-tauri/src/commands/subwindow.rs`, `platform/x11.rs` / `platform/mod.rs`,
-    `services/window_service.rs` / `services/project_runtime.rs`, `lib.rs`,
-    `tauri.conf.json`, `capabilities/default.json`.*
-    - [x] 🤖 Automated test — `SubwindowDetach`, `DetachedSync`, `DetachedHost`,
-      `TerminalAttachOnly` (frontend) + `window_service` detached-labels selector
-      (backend). tsc clean; 30 #42 frontend tests pass; cargo 373 pass.
-    - [ ] 🖐️ Manual test — needs backend rebuild + live run (pop-out spawns &
-      seeds, PTY attaches without respawn, X11 park + Tauri hide on switch,
-      Wayland hide fallback, dock-back & dock-on-close, main window never parked).
-
-55. **[Bug] Fix tab→project mapping leak.** A tab can show up under the wrong
-    project — e.g. the ProjectEldrun main window showing a `TODO.md` tab that
-    belongs to a different project. This must never happen. Audit tab persistence
-    / restore and the per-scope layout keying (`layoutByScope`, `tab_layout`/
-    `tab_groups`, scope ids) so tabs are strictly bound to their owning project.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-56. **Right-click a tab → start renaming.** A right-click on a tab should
-    immediately enter inline rename mode (rather than going through a menu).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-57. **Open `README.md` by default for a project with no tab.** When a project is
-    opened/activated and has no tabs to restore, show its `README.md` in an
-    in-app viewer tab by default (uses the Group D.14 viewer).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-62. **Fast keyboard navigation across projects / subwindows / tabs.** Make the
-    whole app steerable from the keyboard with no mouse required. Needs design
-    choices, but the target set: a fast fullscreen mode for a tab/subwindow,
-    keyboard switching between projects, between subwindows (e.g. `Shift`+arrows
-    to focus subwindows), between tabs in a subwindow (e.g. `Shift`+`Tab`), and
-    between projects (e.g. `Shift`+`Ctrl`+`Tab`), plus closing tabs/subwindows —
-    all keyboard-driven.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
----
-
-## Group M — In-App Viewers: Text / TeX / Image Enhancements (Phase 2+)
-*Builds on Group D.14 (in-app file→tab viewers). Files: `src/components/embed/FileViewerPane.tsx`,
-`src/components/files/markdown.ts`/`tex.ts`/`highlight.ts`, `fileUtils.ts`
-(`internalViewerFor`), `src/stores/tabs.ts` (`"embed"` tab kind, `viewer`),
-`src/components/embed/EmbedPane.tsx`, backend `commands/tex.rs`
-(`tex_capability`/`compile_tex`), `commands/apps.rs` (`embed_capability`,
-default-app resolution), `src/types/index.ts`, `README.md`.*
-
-43. **Auto-reload the native text viewer from disk (diff-aware).** When a file
-    open in the in-app text viewer changes on disk, reload it with a diff check so
-    external edits (agents, git checkout, other tools) surface in the viewer.
-    Don't clobber unsaved in-tab edits — detect divergence and reconcile (reload
-    when clean; warn/merge-prompt when the buffer is dirty). Likely a file-watch
-    or poll on the open file's mtime/hash.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-44. **TeX viewer: preview off by default.** Default the TeX viewer to the source
-    editor rather than auto-rendering a preview; make preview an explicit toggle.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-45. **Auto-complete in native text viewers (pre-defined model).** Add code/text
-    auto-completion across all native text viewers, driven by a pre-defined
-    (ideally local) model. Settle the model source (local Ollama vs. configured
-    global), trigger/UX, and the privacy posture (no remote calls for local-only
-    projects) when picked.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-46. **Undo/redo in native text/TeX viewers.** Add an undo/redo history to the
-    in-app text and TeX editors (keyboard `Ctrl+Z`/`Ctrl+Shift+Z` plus buttons).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-47. **Save icon instead of "save/saved" text (+ optional autosave).** Replace the
-    textual save/saved status in the text/TeX viewer with a save icon that
-    reflects dirty/clean state; consider periodic autosave (with the #43
-    diff-aware reload as the counterpart for external changes).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-48. **Per-file-type native-viewer settings + document supported types.** A single
-    settings surface to configure native-viewer behavior keyed by file type, and
-    document the supported types (and the native text viewer) in `README.md`.
-    Ties into #44 (per-type preview defaults) and #45 (per-type completion).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-49. **Make file links in text/TeX viewers visibly clickable.** Render links that
-    point at files with a clear affordance (underline / dotted underline) so they
-    read as clickable, in both the text and TeX viewers. (Companion to #50, which
-    governs *where* a clicked link opens.)
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-50. **Link-open routing: same subwindow, or drag-to-set-default.** When a file
-    link (#49) is clicked, open the target in the **same** subwindow by default;
-    if the user drags the link to another subwindow, make that the default target
-    **only for that file, from that linking file, for this session** — discard the
-    mapping when the linking file's tab is closed (and optionally close the
-    linked file(s) with it).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-51. **Native `.odt` / `.xlsx` viewer.** Add an in-app viewer for OpenDocument /
-    spreadsheet files. First decide whether it's worth it / already feasible via
-    an existing Tauri-side renderer before building one.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-52. **Image viewer: zoom/scroll to the cursor.** Improve image-viewer scrolling so
-    zoom centers on the mouse cursor rather than the viewport origin.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-53. **Drag images (and their tabs) out as drop sources.** Make images in the image
-    viewer — and image tabs — draggable as drop sources, e.g. drag an image/text
-    tab and drop it into a browser file-upload field.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-54. **TeX compile output → PDF in a new tab + compiler options.** Open the
-    compiled PDF as its own tab (it is a real file), and add compiler options to
-    the TeX viewer (output folder, engine/flags, …). Extends the existing
-    `compile_tex` affordance from Group D.14.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-55. **Adjustable text size in the text/TeX/Markdown editors.** Add an `A−`/`A+`
-    control (and `Ctrl` +/−, `Ctrl`+0 to reset) that scales the editor font. In
-    the code editors (text/TeX) the gutter and syntax/link/ghost overlay layers
-    scale together via the `--code-font-size`/`--code-line-height` CSS variables;
-    in Markdown it sizes the source textarea and, once set, the rendered preview
-    base font. The size persists per file type in `viewer_prefs[type].font_size`
-    (alongside #45's autocomplete).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-66. **SyncTeX PDF↔source navigation + subtex→main compile wiring.** Make the
-    compiled PDF and its `.tex` source navigable both ways, and let a child file
-    build its parent. Compiles now always emit `-synctex=1` (`commands/tex.rs`).
-    *Reverse search:* clicking a point in a PDF (`PdfCanvas`) runs `synctex_edit`
-    and jumps the source tab to that line (via the `editorJump` store +
-    `CodeEditor` `gotoLine`). *Forward search:* after a compile, `synctex_view`
-    maps the source caret to a PDF box that `PdfCanvas` scrolls to and flashes
-    (via the `pdfSync` store). *Subtex wiring:* a successful compile records each
-    `\input`/`\include` child→root in `~/.local/share/eldrun/tex_roots.json`, and
-    `resolve_tex_root` (magic `% !TEX root` comment → stored map → self) redirects
-    a child's Compile to its main document. Adds a compile run animation
-    (`.is-compiling` button sheen + header progress strip, reduced-motion aware).
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-67. **Find in the text/TeX viewers.** Add an in-editor search bar to the shared
-    `CodeEditor` (so it covers both the text and TeX viewers). `Ctrl`/`Cmd`+`F`
-    opens a floating find bar pinned to the editor's top-right — bound on the
-    editor container so it opens whenever focus is anywhere in the tab, not only
-    on the textarea. The bar has a query input (seeded from the selection), a live
-    `n/total` count, `↑`/`↓` (and `Enter`/`Shift`+`Enter`) to cycle, a `Aa` match-
-    case toggle, and `Esc` to close. Matches are painted by a transparent overlay
-    `<pre>` layer (`decorateSearchRanges`) scroll-synced like the highlight/link
-    layers, the current match brighter; navigation moves the textarea selection
-    and scrolls the match into view. Pure helpers `findMatches`/`decorateSearchRanges`.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-68. **Image viewer: auto-reload on disk change.** Give the image viewer the same
-    diff-aware reload as the editors/PDF (#43): `useBlobUrl` polls `file_mtime`
-    and re-reads the bytes when the file changes on disk, swapping the blob URL
-    only once the fresh bytes are ready (no flash) and revoking the old one. An
-    image regenerated by an external tool updates in place; the user's zoom/pan is
-    preserved when the new image has the same dimensions, and only re-fit when the
-    dimensions change.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-69. **Persist viewer scroll/zoom across reopen + restart.** The in-app PDF, text,
-    and image viewers remember the reader's position so reopening a file — or
-    restarting Eldrun — restores it instead of jumping to the top/default zoom.
-    A per-tab `ViewerState` (`scrollTop`/`scrollLeft`/`scale`/`offsetX`/`offsetY`,
-    `src/stores/tabs.ts`) travels with the `embed` tab through
-    `save_tab_layout`/`loadFromLayout` (round-tripped via the Rust `TabEntry`'s
-    flattened `extra`, no backend change). The viewer panes
-    (`FileViewerPane.tsx`, shared `useViewerState` hook) restore once on first
-    load and persist (throttled) as the reader scrolls/zooms/pans; the PDF honours
-    a saved zoom over fit-width on first load, and `CodeEditor` gained
-    `initialScrollTop`/`onScrollPersist`. `setViewerState` merges + dedups so an
-    unchanged write never churns the saveLayout debounce.
-    - [x] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-70. **TeX viewer: `Ctrl`+`S` saves and recompiles.** In the LaTeX viewer (engine
-    available), `Ctrl`+`S` runs `compile()` instead of a plain save — `compile()`
-    persists pending edits first, so the PDF preview tracks the source. The
-    no-engine fallback keeps `Ctrl`+`S` as a plain save.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
----
-
-## Group O — Project Security & Permissions (new feature)
-*Files: `src-tauri/src/commands/projects.rs` (create/import), `schema/project.rs`
-+ `schema/settings.rs` (new security/permission fields), `ProjectSwitcher.tsx`
-(import/add dialog) + a project-settings "Security" area, download-routing in
-`services/project_runtime.rs`/`commands/`. Distinct from the SSH "no in-app
-passwords" stance — this is per-project policy. Ties into Group G (remote/agent
-auth) and the local/remote git push axis (#21).*
-
-58. **Security stages for project import/add.** Offer graded security modes when
-    adding/importing a project, stored in project settings:
-    - **Highest** — only local models allowed; no git push (optionally no git,
-      no scaffolds).
-    - **Restricted** — a checkable allow-list of models; no git push (optionally
-      no git, no scaffolds).
-    - **Lowest** — everything allowed.
-    Surface as a "Security" area in project settings and enforce it where agents
-    are spawned and where pushes happen.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-59. **Per-project remote-control toggle (default off).** A per-project switch to
-    enable/disable agent remote control (Claude, …), defaulting to **off**.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-60. **Reset browser download path to `~/Downloads`.** Stop redirecting browser
-    downloads into the active project for now — keep the standard browser download
-    path at the user's `~/Downloads`. Routing a download into a project is a
-    security risk if the file is then pushed with the project's git.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
+## Suggested sequencing
 
----
-
-## Group R — Right Panel: Polish & App-Window Tracking
-*Files: `src/components/layout/RightPanel.tsx`, `src/styles/themes.css`,
-`src/stores/windows.ts`, backend `commands/apps.rs` + window tracking in
-`services/window_service.rs`/`platform/x11.rs`. The pin toggle itself is done
-(Group D.13 / #37); these are follow-on polish + a tracking-display bug.*
-
-63. **Pin needle black in dark fancy mode.** The right-panel pin (📌) needle isn't
-    legible in the dark "fancy" theme — make it black (or otherwise contrast-fix)
-    in that mode.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
-64. **[Bug] Right-panel Apps list must drop closed app windows.** A project-opened
-    external app appears in the right-panel "Apps" list but doesn't disappear when
-    the app/window is closed. Fix the add/remove lifecycle so the list reflects
-    live windows. Doubles as a window-tracking test surface: on hover, show the
-    entry's window id, monitor id, and z-order.
-    - [ ] 🤖 Automated test
-    - [ ] 🖐️ Manual test
-
----
-
-Sequencing is **group-wise** — tackle whole groups in this order, since items
-within a group share files and context:
+Group-wise — tackle whole groups in this order, since items within a group
+share files and context:
 
 - **Quick wins next:** J (#33 URI routing — last remaining global-apps item; the
   in-app mail #65 / browser #61 in the same group are the larger net-new
@@ -1206,6 +196,12 @@ within a group share files and context:
 - **Project policy:** O (#58–#60) — per-project security/permission model;
   touches the create/import dialog and the agent-spawn + git-push paths.
 - **Right-panel polish:** R (#63 needle contrast, #64 app-window tracking bug).
+- **Local agents:** S (#72–#78) — generalize the vibe local-agent tab to the
+  `ollama launch` family (Claude Code, Hermes, OpenClaw, OpenCode); do the
+  registry + backend argv (#72–#74) first, then the picker (#75) and per-agent
+  verification (#76). Blocked at runtime until the local Ollama runner is fixed.
+- **Git hosting:** P (#79) — multi-host publishing (GitLab + generic remote URL)
+  on top of the done GitHub-only flow (D.10 #22); self-contained, pickable anytime.
 - **Cross-platform (parallel track):** H (Windows #30 / macOS #31 follow-ups) —
   validate builds & packaging per OS; can proceed alongside the above.
 - **Backend runtime (ongoing):** I (#32) — backend-owned runtime hardening
@@ -1222,443 +218,5 @@ within a group share files and context:
 
 ---
 
-# ✅ Done (code-complete) — 🤖 Automated ✅ · 🖐️ Manual pending
-
-Code-complete groups, renumbered D.1, D.2… and kept at the end of the file. Item
-numbers stay global and stable. **All groups below are ✅ Done with passing 🤖
-automated tests** (except #25, visual-only); **🖐️ manual/runtime QA is still
-pending** across the board — see the Status legend at the top. Each group's
-`🧪 Tested:` line and each feature's two checkboxes track the two axes; a feature
-is fully 🧪 Tested only once its 🖐️ Manual box is also ticked after live QA.
-
-## Group D.1 — Right Panel: File Tree & Navigation ✅ Done · 🧪 Untested
-*Files: `src/components/files/FileTree.tsx`, `fileUtils.ts`, `RightPanel.tsx`, `src/styles/themes.css`. Backend create/delete commands already exist in `commands/projects.rs`.*
-🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
-
-1. ✅ **Create file / folder from right-click.** Added "New File" + "New Folder"
-   entries to the entry context menu, plus an empty-area context menu so files
-   can be created in an empty folder. Both reuse the `window.prompt` pattern and
-   call the existing `create_file` / `create_dir` commands, then reload.
-   - *Test (e.g.):* right-click a folder → "New File", type a name → the
-     file appears in the tree **and** on disk; repeat via the empty-area menu
-     inside an empty folder to confirm creation there too.
-   - [x] 🤖 Automated test — `FileTreeNav.test.tsx`
-   - [ ] 🖐️ Manual test
-
-2. ✅ **Show long file/folder names in full.** Added a native `title={e.name}` to
-   the `.file-name` span so the full name shows on hover (CSS ellipsis kept).
-   - *Test (e.g.):* create a file with a very long name → the row shows a
-     truncated name with ellipsis, and hovering it surfaces the full name in a
-     native tooltip.
-   - [x] 🤖 Automated test — `FileTreeNav.test.tsx`
-   - [ ] 🖐️ Manual test
-
-3. ✅ **Show parent folders when inside a subfolder.** Replaced the single
-   "↑ .." button with a breadcrumb trail (up arrow, project-root `⌂` crumb, and
-   each path segment separated by `/`), each segment clickable to jump directly.
-   - *Test (e.g.):* navigate two levels deep → breadcrumb shows
-     `⌂ / sub / subsub`; click the middle `sub` crumb → tree jumps to that folder
-     and the breadcrumb trims accordingly.
-   - [x] 🤖 Automated test — `FileTreeNav.test.tsx`
-   - [ ] 🖐️ Manual test
-
----
-
-## Group D.2 — Right Panel: Git Status Markers ✅ Done · 🧪 Untested
-*Files: `src-tauri/src/commands/git.rs` (`git_file_statuses`), `FileTree.tsx` (`STATUS_COLOR`, `GitMarker`), `fileUtils.ts`.*
-🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
-
-4. ✅ **Fix incorrect git colors.** Rewrote the porcelain parsing so the
-   working-tree column (Y) decides "modified" before the index column (X) decides
-   "staged" — partly-staged files like `MM` now read as modified (red) rather
-   than masquerading as fully-staged. Bubbling priority is now
-   modified > untracked > staged > unpushed > ignored.
-   - *Test (e.g.):* stage a file then edit it again (porcelain `MM`) →
-     its tree marker is red (modified), not orange (staged), and the containing
-     folder bubbles up to red.
-   - [x] 🤖 Automated test — `GitStatusColors.test.tsx` (STATUS_COLOR mapping)
-   - [ ] 🖐️ Manual test
-
-5. ✅ **Richer marker scheme.** `git_file_statuses` now also marks
-   committed-but-unpushed files via `git log @{u}..`. Markers: gitignored → gray
-   ✕ glyph; unstaged/untracked → red bar; staged → orange bar; unpushed → green
-   ↑ glyph; clean/pushed → no marker. (Ignored uses a gray ✕ rather than red to
-   avoid flooding the tree with alarm-colored marks on `target/`, `node_modules/`
-   etc.; trivially switchable in `STATUS_COLOR`.)
-   - *Test (e.g.):* set up one file in each state (ignored, untracked,
-     staged, committed-but-unpushed, clean) → each shows the right glyph/color:
-     gray ✕, red bar, orange bar, green ↑, no marker respectively.
-   - [x] 🤖 Automated test — `GitStatusColors.test.tsx` (STATUS_COLOR mapping)
-   - [ ] 🖐️ Manual test
-
-6. ✅ **Show `.gitignore` in the tree.** `visibleEntries` now keeps `.gitignore`
-   visible by default while still honoring the `panel_hidden_*` filters.
-   - *Test (e.g.):* in a project with a `.gitignore`, confirm it stays
-     visible in the tree even with default hidden-file filtering on, while other
-     `panel_hidden_*` matches remain hidden.
-   - [x] 🤖 Automated test — `GitignoreVisible.test.ts`
-   - [ ] 🖐️ Manual test
-
----
-
-## Group D.3 — Right Panel: Git History & Commit UI ✅ Done · 🧪 Untested
-*Files: `src/components/files/GitHistory.tsx` (new), `RightPanel.tsx` (new "Git"
-view), backend commands `git_log` / `git_branches` / `git_checkout` /
-`git_commit_message` / `git_reword_head` in `commands/git.rs`.*
-🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
-
-7. ✅ **Git history view.** New "Git" tab in the right-panel header shows the
-   current branch, clickable local/remote branch pills (checkout), and a commit
-   list (short hash, subject, ref badges, relative date; HEAD marked). Backend
-   `git_log`, `git_branches`, `git_checkout` added.
-   - *Test (e.g.):* open the Git tab → current branch is shown, the commit
-     list matches `git log`, HEAD is marked, and clicking another branch pill
-     checks it out (tree/branch label update).
-   - [x] 🤖 Automated test — `GitHistory.test.tsx`
-   - [ ] 🖐️ Manual test
-
-8. ✅ **Click a commit → commit-message window.** Clicking a commit opens a modal
-   showing its full message. For HEAD it is editable with a "Generate (agent)"
-   action (reuses `git_generate_commit_message`) and "Save (amend)"
-   (`git_reword_head`); older commits are read-only. A "Checkout" action checks
-   out the commit (detached). Full message fetched via `git_commit_message`.
-   - *Test (e.g.):* click HEAD → modal is editable, edit + "Save (amend)"
-     rewrites the commit message; click an older commit → read-only; "Checkout"
-     puts the repo in detached HEAD at that commit.
-   - [x] 🤖 Automated test — `GitHistory.test.tsx`
-   - [ ] 🖐️ Manual test
-
----
-
-## Group D.4 — Bottom Panel: Project Pill polish ✅ Done · 🧪 Untested
-*Files: `src/components/projects/ProjectPill.tsx`, `src/stores/activity.ts` (new),
-`src/components/layout/AppShell.tsx`, `ProjectSwitcher.tsx`, `src/stores/projects.ts`,
-backend `commands/terminal.rs` (`project_cpu_percent`), `commands/projects.rs`
-(`set_project_description`), `src-tauri/src/sysstat.rs` (new). Test:
-`src/__tests__/PillRunningIndicator.test.ts`.*
-🧪 Tested: 🤖 automated ✅ (suite green; #11 CPU% core helpers only) · 🖐️ manual ❌ (runtime QA pending)
-
-9. ✅ **Running-task indicator on pills.** New `activity` store derives a
-   per-scope "busy" flag from live PTY output: a single global `terminal-output`
-   listener in `AppShell` stamps each PTY's last-output time (covers backgrounded
-   projects too), and a 300 ms tick recomputes `busyByScope`. Busy pills show the
-   three-dot `OrbitSpinner` tinted green (`.pill-running-spinner`).
-   - *Test (e.g.):* start a long-running command in a **backgrounded**
-     project's terminal → that pill shows the green spinner within ~300 ms; when
-     output stops, the spinner clears shortly after.
-   - [x] 🤖 Automated test — `PillRunningIndicator.test.ts`
-   - [ ] 🖐️ Manual test
-
-10. ✅ **Right-click → change description.** Pill context menu gains "Edit
-    description" opening a small textarea dialog. Saving calls the new
-    `set_project_description` command, which writes both `projects.json` (the
-    pill list) and the project's `project.json`, then mirrors the cleaned value
-    into the store.
-    - *Test (e.g.):* right-click a pill → "Edit description", save new
-      text → both `projects.json` and that project's `project.json` are updated
-      on disk and the hover popup shows the new description.
-    - [x] 🤖 Automated test — `projects_commands.rs::set_project_description_writes_both_projects_json_and_project_json`
-    - [ ] 🖐️ Manual test
-
-11. ✅ **Hover → per-project CPU %.** Hover popup now shows live CPU%, polled
-    every 1.5 s while open. New `project_cpu_percent` command (backed by the
-    `sysstat` `/proc` module) resolves the project's PTY ids → child PIDs +
-    descendants and samples jiffies over a 300 ms window. CPU-only by design;
-    per-process GPU isn't reliably attributable on Linux, so the existing Ollama
-    VRAM tracking stays as the GPU signal. No-op (returns 0) off Linux.
-    - *Test (e.g.):* hover a pill whose project runs a CPU-busy process →
-      popup shows a non-zero CPU% refreshing ~every 1.5 s; an idle project reads
-      ~0%; on non-Linux it returns 0 without erroring.
-    - [x] 🤖 Automated test — *partial:* `sysstat.rs` unit tests (clk_tck, descendant_pids self-inclusion/empty, sum_jiffies live+dead pid); live % readout is manual
-    - [ ] 🖐️ Manual test
-
-12. ✅ **Suppress default webview reload/inspect on right-click.** The
-    `.project-switcher` container now `preventDefault`s `contextmenu`, so a right-click
-    anywhere on the bar surfaces only our pill menu, never Reload/Inspect.
-    - *Test (e.g.):* right-click empty space on the project switcher and on a
-      pill → only the custom menu appears; the default webview Reload/Inspect
-      context menu never shows.
-    - [x] 🤖 Automated test — `ProjectSwitcherContextMenu.test.tsx`
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.5 — Branding ✅ Done · 🧪 Untested
-*Files: `src/assets/logo.svg` (new), `src/components/layout/HeaderBar.tsx`, `src-tauri/icons/*`.*
-🧪 Tested: 🤖 automated — N/A (purely visual) · 🖐️ manual ❌ (icons/header not visually verified in a live build)
-
-25. ✅ **Redraw the Eldrun logo in SVG.** Recreated the logo as a clean,
-    symmetric vector (`logo.svg`): green circuit "tree of life" ring, split
-    trunk, mirrored branch traces with node terminals, and the gold spark — left
-    half authored and mirrored across the centre line. Header now imports the SVG
-    (`logo.png` removed). OS app icons (`32x32`, `128x128`, `128x128@2x`,
-    `icon.ico`, `icon.icns`) regenerated from the vector via `tauri icon`, which
-    also fixed the previously mis-sized (all 650×650) raster icons.
-    - *Test (e.g.):* launch a packaged build → the header renders the new
-      SVG logo crisply, and the OS app/taskbar icon shows at correct sizes (not a
-      stretched 650×650 blob).
-    - [ ] 🤖 Automated test — *N/A: purely visual; manual only*
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.6 — Drag & Drop Reordering ✅ Done · 🧪 Untested
-*Files: `src/stores/tabs.ts` (already has a `reorder(from, to)` action),
-`src/components/layout/CenterPanel.tsx` (tab bar — no drag handlers yet);
-`src/stores/projects.ts` (projects carry a `position` field and are sorted by
-it, but there is no reorder/persist action), `ProjectSwitcher.tsx`/`ProjectPill.tsx`,
-backend `save_projects`.*
-🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
-
-26. ✅ **Drag-and-drop tab reordering.** Tabs in `TabBar.tsx` are now `draggable`
-    with HTML5 drag handlers that call `useTabsStore.reorder(from, to)` on drop.
-    Persistence is automatic — `CenterPanel`'s debounced `saveLayout` effect runs
-    whenever `tabs` changes. Drag feedback via `.tab.dragging` / `.tab.drag-over`.
-    - *Test (e.g.):* drag a tab to a new slot → order updates with drag
-      feedback; reopen the app → the new tab order persisted (saveLayout fired).
-    - [x] 🤖 Automated test — `TabReorder.test.ts`
-    - [ ] 🖐️ Manual test
-
-27. ✅ **Drag-and-drop project ordering.** Pills in `ProjectPill.tsx` are now
-    `draggable` (source id carried in `dataTransfer`); dropping on another pill
-    calls the new `reorderProjects(fromId, toId)` action in `projects.ts`, which
-    splices the active-pill order, renumbers every project's `position` with
-    gap-spaced values (active pills first, inactive after), and persists via
-    `save_projects`. Drag feedback via `.project-pill.drag-over`.
-    - *Test (e.g.):* drag one pill onto another → pills reorder, `position`
-      values are renumbered (active first, inactive after) and written via
-      `save_projects`; restart → order survives.
-    - [x] 🤖 Automated test — `ProjectReorder.test.ts`
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.7 — Right Panel: Hidden Files Section ✅ Done · 🧪 Untested
-*Files: `src/components/files/FileTree.tsx` (the `separateScaffold` split at
-~426-480 and the "scaffold" `file-tree-section-divider`), `fileUtils.ts`
-(`visibleEntries`, `STANDARD_PROJECT_FILES`), `src/styles/themes.css`.*
-🧪 Tested: 🤖 automated ✅ (`HiddenFilesSection.test.ts` green) · 🖐️ manual ❌ (runtime QA pending)
-
-29. ✅ **Collapsible hidden-files section under scaffold.** Keep the existing
-    show/hide filtering (`showHidden` toggle + `hiddenEndings`/`hiddenPaths` in
-    `visibleEntries`) exactly as-is. **Additionally**, when a scaffold section is
-    shown, render a third grouped section **below** the scaffold divider that
-    gathers the hidden folders/files, collapsed (minimized) by default with a
-    click-to-expand header. This is an addition to the existing
-    `separateScaffold` rendering (a parallel `hidden` bucket + a collapsed
-    `<details>`-style divider), not a replacement of the binary show/hide
-    toggle — so hidden items stay discoverable without flooding the tree, and
-    the toggle still works for users who want them inline or fully hidden.
-    - *Test (e.g.):* in a project with hidden files, the scaffold view
-      shows a collapsed "hidden" section below the divider; clicking its header
-      expands it; the existing show/hide toggle still works independently.
-    - [x] 🤖 Automated test — `HiddenFilesSection.test.ts`
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.8 — Right Panel: Persist Script-Run Animation ✅ Done · 🧪 Untested
-*Files: `src/components/files/FileTree.tsx` (`runningScripts` state + the
-`script-finished` listener at ~136, `runShellScript`, `.file-run-spinner`),
-`src/components/layout/RightPanel.tsx` (renders `<FileTree>` only `{open && …}`).
-Related to the run-detached backend `run_script_detached` in `commands/apps.rs`.*
-🧪 Tested: 🤖 automated ✅ (`ScriptRunState.test.ts` green) · 🖐️ manual ❌ (runtime QA pending)
-
-34. ✅ **Keep the `.sh` run animation alive when the right panel hides.** Today
-    `FileTree` is mounted only while the panel is open (RightPanel
-    `{open && (<FileTree…>)}`), so hiding the panel unmounts the tree and drops
-    both the local `runningScripts` set and the `script-finished` subscription —
-    when reopened, a still-running script shows no spinner and a completed run is
-    never reflected. Lift the running-scripts state and the `script-finished`
-    listener out of `FileTree` into a persistent owner (a small store like
-    `activity.ts`, or an `AppShell`-level listener) so the run animation/state
-    survives panel hide/show and the button re-renders correctly on reopen.
-    - *Test (e.g.):* run a long `.sh`, hide the right panel, reopen →
-      spinner is still active; let it finish while hidden → on reopen the button
-      shows the finished (non-spinning) state.
-    - [x] 🤖 Automated test — `ScriptRunState.test.ts`
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.9 — Center Panel: Free Tab Arrangement / Grid View ✅ Done · ⛔ Superseded by D.11
-*The per-scope auto-grid (`grid`/`gridByScope`/`toggleGrid`/`setGrid` + ▦ button)
-was **removed** and replaced by the tiling split-subwindow model in Group D.11.
-`TerminalView`'s `visible`/`focused` prop split survives and is reused there.
-`GridView.test.ts` now only asserts the old grid API is gone.*
-🧪 Tested: 🤖 automated ✅ (`GridView.test.ts` green) · 🖐️ manual ❌ (runtime QA pending)
-
-35. ✅ ⛔ **Free arrangement of tabs / grid view — superseded.** The original
-    per-scope auto-grid (columns = `ceil(sqrt(n))`) is gone; tab arrangement is
-    now the directional tiling split model (Group D.11 / #36). The reusable
-    `TerminalView` `visible`/`focused` prop split and the all-scopes-mounted pane
-    approach carried over. `GridView.test.ts` was rewritten to assert the grid
-    store API no longer exists.
-    - [x] 🤖 Automated test — `GridView.test.ts` (asserts removal)
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.11 — Center Panel: Tiling Split Subwindows ✅ Done · 🧪 Untested
-*Files: `src/stores/tabs.ts` (layout-tree model: `SplitNode`/`GroupNode`,
-`splitWithTab`/`moveTab`/`reorderInGroup`/`resizeSplit`/`removeTab` collapse,
-`serializeTree`/`deserializeTree`, per-scope `layoutByScope`/`focusedGroupByScope`),
-`src/components/layout/CenterPanel.tsx` (recursive split render + measured-rect
-pane positioning + panel-wide drop tracking), `src/components/tabs/Subwindow.tsx`
-(per-group frame + L/R/T/B/center drop zones), `src/components/tabs/TabBar.tsx`
-(per-group bar, cross-group drag payload `{key, fromGroup}`),
-`src/components/layout/HeaderBar.tsx` (global tab bar removed), `src/stores/projects.ts`
-(threads `tabGroups` through project switch via shared `serializeTree`),
-`src/styles/themes.css` (`.subwindow`, `.split`/`.split-divider`, `.drop-zone`).
-Backend: `schema/project.rs` `tab_groups`, `commands/projects.rs::save_tab_layout`,
-`services/terminal_service.rs`, `schema/session.rs`, `services/project_runtime.rs`.
-Tests: `src/__tests__/SplitLayout.test.ts`.*
-🧪 Tested: 🤖 automated ✅ (`SplitLayout.test.ts` green, 85 vitest + cargo) · 🖐️ manual ❌ (runtime QA pending)
-
-36. ✅ **Tiling split subwindows (directional drag-drop splits).** Reworked the
-    center panel from one header tab bar + auto-grid into a tiling layout of
-    subwindows. Each subwindow (group) owns its tabs and renders its own tab bar;
-    dragging a tab onto another subwindow's edge (L/R/T/B) splits that direction
-    into a new subwindow, onto its center moves the tab in. Splits resize via
-    draggable dividers (`resizeSplit`, clamped, divider-pair math). The layout is
-    a per-scope tree (`layoutByScope`); flat tab payloads stay per-scope so PTYs
-    never unmount. `removeTab`/`moveTab`/`splitWithTab` collapse emptied groups
-    and lone splits and keep focus + `activeKey` on a surviving group. Persisted
-    as `tab_groups` in `project.json` alongside the flat `tab_layout`, round-trips
-    through project switch (`switch_project_runtime`); absent → single group
-    (legacy projects). **Backend rebuild/restart required** for `tab_groups`
-    persistence (per CLAUDE.md; agents can't launch Eldrun).
-    - *Test (e.g.):* drag a tab onto a subwindow's right edge → a 2-way row split
-      with the dragged tab in a new group sized 50/50; close its only tab → split
-      collapses back to one group with focus on the survivor; reload restores the
-      tree from `tab_groups`.
-    - [x] 🤖 Automated test — `SplitLayout.test.ts` (splits/collapse/move/resize/load)
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.10 — Project Model, Import & Publishing ✅ Done · 🧪 Untested
-*Files: `src-tauri/src/commands/projects.rs` (`normalize_git_type`,
-`ImportProjectRequest.skip_scaffold`, create/import defaults + read-time
-migration), `src-tauri/src/commands/github.rs` (new `github_publish`),
-`lib.rs`/`commands/mod.rs` (registration), `ProjectSwitcher.tsx` (push-target select +
-skip-scaffold checkbox), `ProjectPill.tsx` (Publish window + menu),
-`src/stores/projects.ts` (`publishProject`), `src/types/index.ts`,
-`themes.css` (`.skip-scaffold-row`). Tests: `projects_commands.rs`
-(`import_project_skip_scaffold_…`), unit tests for `normalize_git_type` and
-`shell_quote`.*
-🧪 Tested: 🤖 automated ✅ (suite green; #22 publish = shell_quote only) · 🖐️ manual ❌ (`github_publish` runtime QA pending)
-
-20. ✅ **No-scaffold option for import.** `ImportProjectRequest` gained a
-    `skip_scaffold` flag (default false); `finish_import` now gates the
-    `scaffold_project` call (and its `git init`) on it, still writing
-    `project.json` so the project registers. The import dialog shows a "Skip
-    scaffolding (project already has its own files)" checkbox that also hides the
-    scaffold-fill guidance and suppresses the scaffold-fill agent tabs.
-    - *Test (e.g.):* import an existing repo with "Skip scaffolding"
-      checked → no `AGENTS.md`/`CLAUDE.md`/etc. added and no `git init`, but
-      `project.json` is written so it registers (cf. `import_project_skip_scaffold_…`).
-    - [x] 🤖 Automated test — `projects_commands.rs::import_project_skip_scaffold_does_not_add_missing_scaffold_files`
-    - [ ] 🖐️ Manual test
-
-21. ✅ **Rename public/private → local/remote (push-target axis).** `git_type`
-    now models the git **push** target — distinct from the SSH **work**-remote —
-    with three values: `local`, `remote-private`, `remote-public`. New projects
-    default to `local`. A `normalize_git_type` helper migrates legacy values
-    (private → remote-private, public → remote-public) on read in `get_projects`
-    / `load_project` and canonicalizes writes. The dialog's "Git push target"
-    select offers the three options.
-    - *Test (e.g.):* a legacy project with `git_type: "private"` loads as
-      `remote-private` via `get_projects`; a brand-new project defaults to
-      `local` (cf. the `normalize_git_type` unit test).
-    - [x] 🤖 Automated test — `commands/projects.rs` normalize_git_type unit tests
-    - [ ] 🖐️ Manual test
-
-22. ✅ **"Make repo public" publish flow.** New `github_publish(project_id,
-    visibility)` command shells out to `gh repo create <name> --public|--private
-    --source=. --remote=origin --push`. For SSH work-remote projects it runs over
-    `ssh` on the host where the bytes live (reusing `ssh_base_args`/`validate_arg`
-    + single-quoted remote argv). On success it records `git_type =
-    remote-<visibility>` in both `projects.json` and `project.json`. Surfaced via
-    a "Publish to GitHub…" entry in the project-pill context menu opening a
-    visibility-picker window; the store's `publishProject` mirrors the new push
-    target into state. Requires `gh` installed + authenticated. **Runtime QA
-    pending** (agents can't launch Eldrun).
-    - *Test (e.g.):* on a local project, "Publish to GitHub…" → pick
-      public → `gh repo create` runs and `git_type` flips to `remote-public` in
-      both json files; for an SSH project the command runs over `ssh` on the host.
-    - [x] 🤖 Automated test — *partial:* `commands/github.rs` shell_quote unit tests (argv escaping only; full gh/ssh publish flow is manual)
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.12 — Layout fix: project switcher in the top header ✅ Done · 🧪 Untested
-*Files: `src/components/layout/HeaderBar.tsx` (`header-center`),
-`src/components/layout/ProjectSwitcher.tsx` (renamed from the old `BottomBar`),
-`src/components/layout/AppShell.tsx`, `RightPanel.tsx`, `themes.css`.*
-🧪 Tested: 🤖 automated ✅ (`ProjectSwitcherContextMenu.test.tsx` green) · 🖐️ manual ❌ (runtime QA pending)
-
-14. ✅ **Stop bottom/right panel intersection.** Resolved by moving the project
-    switcher out of the bottom overlay into the top header (`HeaderBar`
-    `header-center`); the old `BottomBar` component became `ProjectSwitcher.tsx`.
-    With no bottom bar there is nothing left to overlap the right panel, and the
-    pill menus now open downward.
-    - *Test (e.g.):* the project pills render in the top header; revealing the
-      right panel no longer collides with a bottom bar.
-    - [x] 🤖 Automated test — `ProjectSwitcherContextMenu.test.tsx`
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.13 — Right Panel: Pin / Dock Option ✅ Done · 🧪 Untested
-*Files: `src/components/layout/AppShell.tsx` (hover-reveal/auto-close timers
-`handleBodyMouseMove`/`scheduleClose`, `rightPinned` state), `RightPanel.tsx`
-(`right-panel-header` pin button), `src/stores/settings.ts`
-(`right_panel_pinned`), `src/styles/themes.css` (`.right-panel`/`.app-body`).*
-🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
-
-37. ✅ **Pin the right panel open.** A 📌 toggle in the `right-panel-header`
-    keeps the panel persistently open instead of auto-hiding on mouse-leave; when
-    pinned the hover-reveal/auto-close timers are suppressed and the panel takes
-    layout space (no overlap of the center terminal). The pinned flag persists in
-    `settings.json` (`right_panel_pinned`) and is restored on launch.
-    - *Test (e.g.):* click the pin → panel stays open after the cursor leaves;
-      center reflows (no overlap); toggle off → reverts to hover-reveal; restart →
-      pinned state restored.
-    - [x] 🤖 Automated test — covered by the right-panel suite
-    - [ ] 🖐️ Manual test
-
----
-
-## Group D.14 — File → Tab: In-App Viewers & Embedded Tabs (Phase 1) ✅ Done · 🧪 Untested
-*Files: drag source `src/components/files/FileTree.tsx`, drop targets
-`src/components/tabs/TabBar.tsx`/`Subwindow.tsx` + `commitFileDrop.ts`,
-`src/stores/tabs.ts` (`"embed"` tab kind, `viewer`/`embedExec`), in-app viewers
-`src/components/embed/FileViewerPane.tsx` + `EmbedPane.tsx`,
-`src/components/files/markdown.ts`, `fileUtils.ts` (`internalViewerFor`),
-backend `commands/apps.rs` (`embed_capability`, default-app resolution),
-`commands/tex.rs` (`tex_capability`/`compile_tex`). Tests:
-`FileDropAddsEmbedTab`/`FileDropEmptyFirstTab`/`FileDropSplitsSubwindow`,
-`EmbedCapabilityGate`, `InternalViewer`, `Markdown`, `embed_capability_tests.rs`.*
-🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
-
-40. ✅ **Drag a file from the right panel into a (sub)window's tab bar to open it
-    in a tab (Phase 1).** Dragging a file row onto a subwindow's tab bar opens a
-    new `"embed"` tab **named after the file**. Two backends: files with a
-    built-in viewer (`internalViewerFor` → PDF, image, markdown, or text) render
-    **in-app** via `FileViewerPane` — a zoom/pan image view, a PDF iframe, a
-    markdown Edit/Preview toggle, and an editable code editor (line-number gutter,
-    Tab/Shift+Tab indent, Ctrl+S save). Other files open in their external default
-    app via `EmbedPane`, gated on an `embed_capability` check. Only in-app
-    `viewer` embeds persist/restore across restart. TeX files additionally get a
-    compile affordance when a LaTeX engine is on `PATH` (`tex_capability` /
-    `compile_tex`). **Phase 2 (live X11-reparented frameless embedding) deferred**
-    — see `docs/group_k_plan.md`.
-    - *Test (e.g.):* drag `notes.md` onto a subwindow's tab bar → a `notes.md`
-      tab opens rendering the markdown in-app; drag a `.png` → zoomable image
-      tab; on an unsupported OS/app a non-viewer file opens externally as before.
-    - [x] 🤖 Automated test — `FileDrop*`/`InternalViewer`/`Markdown`/`EmbedCapabilityGate`
-    - [ ] 🖐️ Manual test
-
-*This is an organizational plan. Pick an item by its number and I'll produce a
+*This is an organizational plan. Pick a group or item number and I'll produce a
 focused implementation plan + changes for just that item.*
diff --git a/docker/agent-sandbox/Dockerfile b/docker/agent-sandbox/Dockerfile
new file mode 100644
index 0000000..35c148e
--- /dev/null
+++ b/docker/agent-sandbox/Dockerfile
@@ -0,0 +1,51 @@
+# Reference image for Eldrun's per-project "Run agents in Docker sandbox" toggle.
+#
+# When the toggle is on for a project, Eldrun launches each agent tab as:
+#   docker run --rm -it --user <uid>:<gid> \
+#     --security-opt no-new-privileges --cap-drop ALL --pids-limit <n> \
+#     -e HOME=<host-home> -w <project> \
+#     -v <project>:<project> \
+#     -v <home>/.claude:<home>/.claude -v <home>/.codex:<home>/.codex \
+#     -v <state_dir>/live_sessions:<state_dir>/live_sessions \
+#     -v <state_dir>/hooks:<state_dir>/hooks:ro \
+#     -v <stage>/..._settings.json:<home>/.claude/settings.json \  # writable copy
+#     -e <agent-auth/env vars> eldrun-agent-sandbox:latest <agent> <args>
+# (see docker/agent-sandbox/README.md and src-tauri/src/services/sandbox.rs).
+#
+# The container therefore needs the agent CLIs on PATH. Auth + session-resume
+# state lives in the bind-mounted host dirs (run as the host uid, with HOME set
+# to the host home), so this image carries no credentials.
+#
+# Build:
+#   docker build -t eldrun-agent-sandbox:latest docker/agent-sandbox
+#
+# The container is started with `--user <host-uid>:<host-gid>` and is NOT root,
+# so install everything to global locations at build time (below). The named
+# user does not need to exist in /etc/passwd; HOME is provided via `-e HOME`.
+
+FROM node:22-bookworm-slim
+
+# Tools agents commonly shell out to. Add your project toolchain (python, go,
+# rustup, etc.) here if your agents need to build/run code inside the sandbox.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git ca-certificates ripgrep less procps curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Agent CLIs. Pin versions in your own fork if you want reproducible builds.
+#   - Claude Code:  @anthropic-ai/claude-code  (provides `claude`)
+#   - Codex:        @openai/codex               (provides `codex`)
+#   - Gemini CLI:   @google/gemini-cli          (provides `gemini`)
+# Vibe and any other agents you use should be added here as well.
+RUN npm install -g \
+        @anthropic-ai/claude-code \
+        @openai/codex \
+        @google/gemini-cli \
+    && npm cache clean --force
+
+# Make global npm bins resolvable regardless of the (host) uid we run as, and
+# give npm a writable cache/prefix under a world-writable dir so a non-root,
+# /etc/passwd-less user can still operate.
+ENV NPM_CONFIG_CACHE=/tmp/.npm
+ENV PATH=/usr/local/bin:$PATH
+
+# No ENTRYPOINT: Eldrun passes the agent command + args as the container command.
diff --git a/docker/agent-sandbox/README.md b/docker/agent-sandbox/README.md
new file mode 100644
index 0000000..81849bf
--- /dev/null
+++ b/docker/agent-sandbox/README.md
@@ -0,0 +1,87 @@
+# Agent sandbox image
+
+Reference Docker image for Eldrun's per-project **"Run agents in Docker sandbox"**
+toggle (right-click a project pill → *Run agents in Docker sandbox*).
+
+When enabled for a (local) project, every **agent** tab (Claude, Codex, Gemini,
+Vibe — anything with `kind: "agent"`) is launched inside an ephemeral
+`docker run --rm` container that bind-mounts **only the project directory** plus a
+minimal set of agent auth/state paths (see *How it runs* below), so the agent
+cannot reach unrelated host files. The agent's own auth dirs (`~/.claude`,
+`~/.codex`, Gemini creds) are shared so login and session-resume keep working;
+everything else under `$HOME` is not. Plain shell/files tabs keep running on the
+host. The toggle is **off by default** and per project.
+
+## Build
+
+```bash
+docker build -t eldrun-agent-sandbox:latest docker/agent-sandbox
+```
+
+`eldrun-agent-sandbox:latest` is the default image name the backend looks for.
+If the image (or `docker` itself) is missing, opening a sandboxed agent tab fails
+loudly in the terminal with a `[spawn error: …]` message rather than silently
+running the agent on the host.
+
+## How it runs
+
+The backend (`src-tauri/src/services/sandbox.rs`) wraps the agent command as:
+
+```
+docker run --rm -it \
+  --user <host-uid>:<host-gid> \
+  --security-opt no-new-privileges --cap-drop ALL --pids-limit <n> \
+  [ --memory <m> --cpus <c> --network <net> --read-only --tmpfs /tmp ] \  # opt-in
+  -e HOME=<host-home> \
+  -w <project-dir> \
+  -v <project-dir>:<project-dir> \
+  -v <home>/.claude:<home>/.claude \                # if present
+  -v <home>/.codex:<home>/.codex \                  # if present
+  -v <state_dir>/live_sessions:<state_dir>/live_sessions \   # hook write target (rw)
+  [ -v <home>/.gemini:… -v <home>/.config/gemini:… ] \       # Gemini creds only, if present
+  -v <state_dir>/hooks:<state_dir>/hooks:ro \                # hook script (read-only)
+  -v <stage>/…_settings.json:<home>/.claude/settings.json \  # writable copy (shadows host)
+  [ -v <stage>/…_settings.local.json:… -v <stage>/…_config.toml:… ] \
+  -e ELDRUN_TAB_UID=… -e TERM=… -e <agent auth vars> \
+  eldrun-agent-sandbox:latest <agent> <args>
+```
+
+`<stage>` is a per-tab dir under `<state_dir>/sandbox-stage/`.
+
+Only these host paths are exposed — **not** the whole `~/.config` or the whole
+`state_dir`, so unrelated secrets (`gh`, `gcloud`, …), `projects.json`, and other
+projects' conversation history stay out of the container.
+
+The `~/.claude` / `~/.codex` / `live_sessions` mounts (at identical paths, as the
+host uid, with `HOME` set to the host home) are what keep **agent auth and session
+resume** working inside the container. Do not remove them.
+
+The SessionStart hook's absolute path is baked into `~/.claude/settings.json` /
+`~/.codex/config.toml`, so those files are an escape vector. Two defences:
+
+- The hook **script dir** (`<state_dir>/hooks`) is shared with host-run agents,
+  so it is mounted **read-only** (`:ro`) — a writable copy would let the sandbox
+  rewrite the script and run code on the host. Do not drop the `:ro`.
+- The **registration files** are mounted as **per-tab writable copies** (staged
+  under `<state_dir>/sandbox-stage/<tab>`) that shadow the host originals. The
+  container gets a real, writable file (so agents that persist config don't
+  error), but its writes land in the throwaway copy — the host's settings can
+  never be repointed at an attacker command. The copy still carries the hook
+  registration, so resume keeps working.
+
+## Customizing
+
+- Add your project toolchain (python, go, rustup, …) to the `Dockerfile` if your
+  agents need to build/run code inside the sandbox.
+- Hardening flags: `--security-opt no-new-privileges`, `--cap-drop ALL`, and a
+  `--pids-limit` are always applied. Per project you can also set `memory`,
+  `cpus`, `network`, and `readonly_rootfs` in the project's `sandbox` config
+  (`project.json`) — e.g. `"network": "none"` for no egress, or a custom
+  allowlist network.
+- Network defaults to the Docker bridge (full egress). Because the mounted auth
+  dirs contain live credentials, consider an egress allowlist: base this image /
+  its run on Anthropic's reference devcontainer `init-firewall.sh`, or set
+  `"network"` to a locked-down network. Rootful Docker runs its daemon as root, so
+  prefer rootless Docker or Podman if a container-escape CVE is a concern.
+- Remote (SSH) projects are out of scope: the sandbox toggle is hidden for them,
+  and the backend ssh-wraps remote agent tabs instead of docker-wrapping them.
diff --git a/CODE_REVIEW.md b/docs/CODE_REVIEW_SECURITY.md
similarity index 100%
rename from CODE_REVIEW.md
rename to docs/CODE_REVIEW_SECURITY.md
diff --git a/Eldrun.desktop b/docs/Eldrun.desktop
similarity index 100%
rename from Eldrun.desktop
rename to docs/Eldrun.desktop
diff --git a/EldrunHotReload.desktop b/docs/EldrunHotReload.desktop
similarity index 100%
rename from EldrunHotReload.desktop
rename to docs/EldrunHotReload.desktop
diff --git a/docs/Features.md b/docs/Features.md
index d9f26ae..0231490 100644
--- a/docs/Features.md
+++ b/docs/Features.md
@@ -61,7 +61,7 @@ only `src-tauri/` changes need a rebuild/restart.
 | Feature | Done | Partial | Issue | Notes |
 |---------|:----:|:-------:|:-----:|-------|
 | SSH hardening (#28c) | | | | two **Critical**: remote cmd injection in `ssh_list_dir`/`ssh_default_dir`; remote `--resume` ordering bug |
-| Agent resume generalization (#39d) | | | | Gemini + Vibe still dropped |
+| Agent resume generalization (#39d) | ✅ | | | Claude/Codex resume-by-id; Gemini (`--resume latest`) + Mistral/vibe (`--continue`) via continue-last |
 | KDE Wayland backend (#18) | | | | show/hide are explicit no-ops (KWin scripting pending) |
 | Windows backend | | | | stub (`platform/windows.rs`) |
 | Boxes phases 3–4 (#41) | | | | merged file tree + relation graph deferred |
diff --git a/README.tex b/docs/README.tex
similarity index 100%
rename from README.tex
rename to docs/README.tex
diff --git a/docs/SSH_CHANGES.md b/docs/SSH_CHANGES.md
new file mode 100644
index 0000000..e0421a6
--- /dev/null
+++ b/docs/SSH_CHANGES.md
@@ -0,0 +1,14 @@
+## SSH remote Project automatically has a local connected project
+- right panel file viewer is remote select folders files that should be synced to local project, snyced get light green background, while sync add animation (use rsync for sync?, something better os independent?)
+- opening file in right file viewer automatically syncs to local
+## Tabs
+There are different types of tabs (different locations (local vs. remote)
+### Agents
+- agent tabs are local by default, but also remote agents (if agents can be installed on remote also remote is possible)
+- thus agents act on the local project
+### Terminals
+- there are local and remote shell tabs, remote e.g., for running remote scripts
+### Local Models
+- same as agents for the moment
+### File Viewer
+- there is a local and remote file viewer, right panel add switch between local and remote (green are synced)
\ No newline at end of file
diff --git a/docs/context/agent_authority.md b/docs/context/agent_authority.md
new file mode 100644
index 0000000..126b072
--- /dev/null
+++ b/docs/context/agent_authority.md
@@ -0,0 +1,20 @@
+# Agent authority axes
+
+Referenced from `CLAUDE.md`.
+
+**Agent authority has three axes**, and they compose: the project container
+`sandbox` (OS containment), the tab's `location` (where the process runs), and — behind the
+experimental `agent_mode_toggle` setting, default off — its `agentMode`: **Plan**
+vs **Auto** (Claude `--permission-mode plan`/`acceptEdits`; Gemini
+`--approval-mode plan`/`auto_edit`). The mode is a *launch flag*, so flipping it
+rewrites the tab's `args`, which respawns the PTY (`TerminalView`'s spawn effect
+keys on them) — non-destructive only because the tab resumes its conversation on
+respawn. That is exactly why `components/tabs/agentModes.ts` is a **capability
+table, not a universal field**: an agent belongs in it only if it has both an
+absolute mode flag *and* a working resume. Claude (resume-by-id) and Gemini
+(continue-last) both qualify; Codex resumes but has no plan mode. Gemini's
+continue-last resume carries one accepted caveat — with two Gemini tabs in a
+project a respawn reattaches to the project's latest session, not necessarily
+this tab's (the same ambiguity their ordinary restore already has). The mode
+is persisted per tab, and re-applied onto the rebuilt args in `loadFromLayout` —
+args are NOT persisted, so without that the split would silently die on restart.
diff --git a/docs/context/agent_sessions.md b/docs/context/agent_sessions.md
new file mode 100644
index 0000000..381cd30
--- /dev/null
+++ b/docs/context/agent_sessions.md
@@ -0,0 +1,21 @@
+# Agent session persistence
+
+Referenced from `CLAUDE.md`.
+
+Project-local state lives in each project's `project.json`. This includes the
+per-project tab layout (`tab_layout`/`tab_groups`). Shell/files tabs are always
+restored on relaunch; agent tabs are normally dropped, **except resumable agent
+tabs** — Claude and Codex tabs that carry a `sessionId` are persisted (with
+their `sessionId`) and restored, respawning the agent so the prior conversation
+comes back (see `isRestorableTab`/`RESUMABLE_AGENTS` in `src/stores/tabs.ts`).
+Mechanism (`services/agent_session.rs`, installed at startup): Eldrun installs a
+`SessionStart` hook — into `~/.claude/settings.json` (JSON) and
+`~/.codex/config.toml` (TOML text-append) — that records each tab's live
+`session_id` under `~/.local/share/eldrun/live_sessions/<key>`, keyed by the
+`ELDRUN_TAB_UID` env var Eldrun sets on the agent. At spawn,
+`terminal::resolve_{claude,codex}_session` reads that to resume the *current*
+session, following a `/clear`. For Claude the key is its launch id
+(`--session-id`); Codex mints its own id so the key is a separate per-tab uuid
+and the backend injects `codex resume <live-id>`. **Codex caveat:** user-level
+Codex hooks need a one-time trust (`/hooks` in Codex) before they run. Gemini
+and Vibe are still dropped (TODO 39d).
diff --git a/docs/context/docker_containers.md b/docs/context/docker_containers.md
new file mode 100644
index 0000000..19c4ad7
--- /dev/null
+++ b/docs/context/docker_containers.md
@@ -0,0 +1,19 @@
+# Docker project containers
+
+Referenced from `CLAUDE.md`.
+
+**A project can run in a container** (#38, `services::sandbox`,
+`docs/docker_projects_plan.md`): with the pill's "Run this project in a
+container" toggle on, every shell/agent tab `docker exec`s into ONE
+session-lived, capability-dropped container (`eldrun-<id>`); `local_agent`
+tabs stay on the host. The project dir stays on the host, bind-mounted at its
+**identical absolute path** — file tree/git/viewers/usage watcher keep reading
+host bytes, and agent resume keeps working — which is what makes it a toggle,
+not a data move. Container lifetime = project session (created on
+activation/first spawn; removed on deactivate *unless tabs are still live in
+it*, at exit, and swept at startup). The toggle is spec-preserving (knobs in
+the pill's "Container settings…" survive off/on), the first enable
+auto-adopts an in-repo `Dockerfile`/devcontainer image, and a missing image
+becomes a one-click build tab. Flipping the toggle respawns every live tab —
+the pill confirms when a non-resumable agent conversation would be lost.
+Local projects only; hidden on Windows.
diff --git a/docs/context/git_sync.md b/docs/context/git_sync.md
new file mode 100644
index 0000000..91a859a
--- /dev/null
+++ b/docs/context/git_sync.md
@@ -0,0 +1,57 @@
+# Git lockstep + byte-sync
+
+Referenced from `CLAUDE.md`.
+
+- **Two transports keep a remote project in step, and they split the tree by
+  git.** *Git lockstep* (`services::git_peer`) owns the **git-tracked** files and
+  moves them **semantically** — commits and refs via `git bundle`, never `.git`
+  bytes. *Byte-sync* (`services::sync_auto`) owns **everything else** and moves raw
+  bytes. `drop_tracked` enforces the split so the two never race for one file. One
+  consequence to internalize: with lockstep on, a saved edit to a **tracked** file
+  no longer reaches the host until it is **committed** (`docs/git_lockstep_case_matrix.md`
+  #5/#7). Live-QA log: `docs/git_lockstep_live_qa.md`.
+- **Anything the sync destroys on the local side says so** (#28q, `services::local_loss`).
+  Byte-sync is non-destructive *by construction* — it pulls only when the local side is
+  unchanged, pushes only when the host is, and skips a both-sides-changed file rather than
+  pick a winner — so every local **deletion** comes from the git side: a fast-forward,
+  `reset --hard` or checkout on the mirror drops the tracked files the incoming commit no
+  longer carries, and the `git clean` that un-blocks a refused fast-forward removes
+  untracked ones outright. Correct, git-recoverable, and *silent* — which is the problem,
+  because it happens during background passes nobody triggered. Each site now files a
+  warning that `LocalLossDialog` raises. The exception that is **not** recoverable, and is
+  labelled as such: `sync_now`/`sync_pull` overwriting a mirror file that held unsynced
+  local edits ("clears amber → green" means the host wins). It is a **log file**, not an
+  event: the services are `AppHandle`-free and a background pass can delete with no window
+  listening, so a loss recorded while the app was closed still surfaces on next launch.
+- **Lockstep is ON by default for a new git-backed remote project** — set at
+  creation by both `create_project` and `extend_project_to_remote` (gated on the
+  mirror actually being a repo). It is safe as a default precisely there: the host
+  root was just created empty, so the first pass can only seed one direction, and a
+  host dir that already holds *differing* files makes pairing **refuse** and ask
+  (`pairing_conflict`) rather than clobber. It is written as explicit per-project
+  state, never as `GitPeerState::default()` — `load_state` falls back to that
+  default for every project with no state file, so flipping it there would silently
+  enable lockstep on existing projects that never opted in.
+- **Byte-sync is opt-in per path and does not read `.gitignore`.** Scope comes from
+  an explicit manifest (`is_auto`: nearest marker wins, root `""` = project-wide);
+  no marker ⇒ nothing crosses. This is what leaves a remote project's *deliberately
+  host-side* data — experiment output, checkpoints, everything gitignored and hence
+  invisible to lockstep — on the host. The corollary is that the two systems have
+  **different notions of scope**, so marking a folder auto-sync is the one click
+  that can haul a multi-GB tree into the mirror; the file tree prices the host
+  subtree first (`sync_auto_preview`) and confirms when it is large.
+  - **The giant folders are asked about once, at setup, on both sides**
+    (`services::big_folders` → `BigFolderExcludeDialog`). Pricing one folder on the
+    click that syncs it is too late for a project whose `node_modules/`, `.venv/`,
+    `data/` or `checkpoints/` was there before Eldrun was: nothing else in the app
+    would ever mention them, since byte-sync doesn't read `.gitignore`. So a
+    project newly created/imported as remote, or **extended** to a host, gets one
+    census — the local mirror walked directly, the host in one `du -ak` round trip
+    (skipped, never attempted, at a cold pool: dispatching at a dead session is
+    what freezes the window) — and one prompt listing each side's numbers, ticked
+    to **exclude** by default. The answer is a manifest `excluded` marker, which is
+    deliberately *stronger* than `auto_off`: it is honoured by the whole-project
+    pull and push too (`is_excluded`, whose `under` waives only the marker on the
+    path the user explicitly asked to transfer), and it makes the rsync fast path
+    stand down, since a whole-subtree rsync cannot honour a carve-out. Byte-side
+    only — a **git-tracked** file in an excluded folder still travels as a commit.
diff --git a/docs/context/hpc_careful_mode.md b/docs/context/hpc_careful_mode.md
new file mode 100644
index 0000000..515de85
--- /dev/null
+++ b/docs/context/hpc_careful_mode.md
@@ -0,0 +1,201 @@
+# Careful mode on remote hosts
+
+Why Eldrun collects *less* from a machine it merely has an account on than from
+the machine it runs on, and what "less" is exactly.
+
+**Careful is the default for every remote machine.** It is not a cluster mode
+that has to be detected — Eldrun cannot tell whose machine a host is, and the two
+wrong guesses do not cost the same: a wrong careful costs a thinner monitor pane
+and a skipped host census, a wrong full reading costs a usage-policy violation on
+somebody else's cluster. So the question is never asked of the host, only of the
+user, and only when they care to answer: the system monitor's per-machine
+**Light / Detailed** switch, stored per SSH target in `settings.careful_hosts`
+(`src/lib/carefulHost.ts`), which is what "this machine is mine" is written down
+as. The rest of this document is what the reduced reading actually is, and the
+rules that shaped it.
+
+## The rules this exists for
+
+A university cluster is not a dev box someone lent you; it runs under usage
+regulations the account holder has agreed to. The ones Eldrun's host probes can
+walk into (wording quoted from one university's usage regulations, but such
+rules are near-identical across sites, and the reasoning is not site-specific):
+
+- **Other people's account names are not yours to enumerate.** *"fremde Uni-IDs
+  und Passwörter weder zu ermitteln noch zu nutzen"* — a plain `getent passwd`
+  on a directory-backed cluster dumps the entire user base. The bulk dump was
+  purely a uid → display-name convenience for the monitor pane's process table.
+- **Information about other users that happens to be readable is not yours to
+  use.** *"keinen unberechtigten Zugriff auf Informationen anderer Nutzer nehmen
+  und bekannt gewordene Informationen anderer Nutzer nicht ohne Genehmigung
+  weiterzugeben, selbst zu nutzen oder zu verändern"* — `/proc/<pid>/cmdline` is
+  world-readable, so reading it is not an intrusion; shipping every user's argv
+  off the cluster and rendering a named per-person breakdown of it is squarely
+  the "selbst zu nutzen" half. Command lines on a cluster carry dataset paths,
+  job parameters, and occasionally something that should never have been on a
+  command line at all.
+- **Personal data is not to be processed on the machine.** *"Die Speicherung und
+  Verarbeitung von personenbezogenen Daten auf der Infrastruktur von
+  Hochleistungsrechnern ist ausdrücklich untersagt"*, and separately, any such
+  processing must be *"mit dem HRZ abzustimmen"*. Account names and per-person
+  command lines are personal data; the `awk`/`getent` pass that assembled them
+  ran on the cluster.
+- **A login node is not to carry sustained load.** The site docs put it plainly:
+  don't run CPU-intensive work on a login node over longer periods, and
+  processes that do may be killed. A monitor pane left open all afternoon at a
+  3-second cadence — each poll a directory query, two file opens per process
+  across a few thousand processes, a `grep` over every `cmdline`, two
+  `nvidia-smi` spawns — is exactly the shape that rule targets.
+
+None of this is criminal-code territory: nothing here defeats an access control
+(§202a StGB is not in play). It is the usage agreement, and the sanction for
+breaking it is the account.
+
+## What careful mode changes
+
+Both host probes have a careful variant. The **monitor snapshot**
+(`sysstat::REMOTE_SNAPSHOT_SCRIPT`):
+
+| Section | Detailed reading | Light (careful) reading |
+|---|---|---|
+| `@PASSWD@` | full `getent passwd` dump | the sampling account's own entry only |
+| `@PASSWD2@` | targeted per-uid lookups for every uid seen | not run |
+| `@CMDLINE@` | `grep` over every `/proc/*/cmdline` | the sampling account's own pids only |
+| `@PROCS@` | `comm` verbatim for every process | foreign `comm` redacted to `(other)`; no `U` (uid) line for a foreign process |
+| `@WHO@` | every login session | the sampling account's own sessions |
+| `@GPU@` | device stats + `--query-compute-apps` | device stats only |
+
+The **connect-time usage probe** (`services::remote_usage`) likewise reports
+only the account's own `who` sessions and its own `ps` rows; the aggregate
+CPU / memory / GPU figures — the whole basis of the `busy` verdict — are
+unchanged, because none of them is about a person.
+
+The load half:
+
+- foreign processes still ship, so the pane can still answer *how loaded is this
+  machine* — they arrive bucketed under one `other users` label
+  (`sysstat::OTHER_USERS`) rather than one row per uid, which would be a
+  per-person breakdown by another name;
+- the pane polls a careful host every **12 s** instead of 3 s, and **not at all**
+  while Eldrun is in the background (`SystemMonitorPane`'s `CAREFUL_POLL_MS`);
+- the connect-time usage probe stops firing automatically at a host once it is
+  known careful (`services::hpc_mode`); the report stays available on demand from
+  the Machines menu.
+
+Both surfaces *say* they are doing this. A silently thinner reading is worse than
+none: a login node full of unnamed rows would otherwise read as a bug.
+
+## Who decides
+
+**The user, per machine.** Every remote host reads careful until an explicit
+answer says otherwise. The answer is keyed by SSH target (`user@host:port`), not
+by host id, because one physical login node is simultaneously a project's primary
+`remote`, another project's `compute_hosts` worker and a project-free global
+machine — three records, one machine, and a per-record flag would be three values
+free to disagree. The switch renders in three places off one component/flag: the
+system monitor's machine row (tab **and** the Machines-menu dialog), and the
+per-host connect dialog's "Go easy on this machine".
+
+The monitor passes that answer on every poll, and it is authoritative in **both**
+directions (`ELDRUN_CAREFUL=1`/`0` via `sysstat::remote_snapshot_script`) — the
+only way a machine the user owns gets a full reading is for their answer to
+outrank anything the host says about itself.
+
+**The host, only when nobody has said anything.** The probe scripts still ask
+whether SLURM is on `PATH` (`sbatch`/`sinfo`/`squeue`) and report the answer on
+their own first line, so the flag rides in the payload (`SystemSnapshot.careful`,
+`RemoteUsageReport.careful`). That still matters for a caller with no stored
+answer to pass — nothing in Eldrun hardcodes an institution's hostnames to guess
+with, so asking the host is the only signal left. `services::hpc_mode` remembers a
+positive verdict per SSH target for the process lifetime, for the caller holding
+no probe result at all (the connect path, deciding whether to fire the usage
+check). That memory only ever *raises* carefulness, and it does not override an
+explicit answer: it exists to stop a flaky probe from talking a cluster down, not
+to overrule a person saying whose machine it is.
+
+## What careful mode does not touch — and the tag that does
+
+Careful mode is about *reading*. It says nothing about how work runs: shells,
+agents, SLURM submission, byte-sync and git lockstep are the same on a careful
+host as on any other. Those are the second half of the problem, and they need a
+different instrument, because they cannot be defaulted safely (switching sync off
+for every remote project would break the feature) and cannot be inferred from the
+host (`sbatch` on `PATH` says a machine *has* a scheduler — a compute node held
+through `srun` has one too, and there you own the machine outright).
+
+So they hang off an explicit per-machine **HPC tag**, ticked wherever a host is
+logged in to — the Machines menu's add-a-machine form, the per-host connect
+dialog (`HpcHostToggle`, beside "Go easy on this machine"), and the new/extend
+project flow — and shown afterwards as an `HPC` badge on that machine's row, with
+a toggle in its expanded detail. Stored per SSH target in `settings.hpc_hosts`
+(`src/lib/hpcHost.ts`, `schema::settings`): the same key as `careful_hosts`, so
+tagging a login node once covers it as a project primary, as another project's
+worker, and as a global machine.
+
+Tagged, a machine gets:
+
+| Behaviour | Untagged | Tagged |
+|---|---|---|
+| monitor reading | careful by default, user may switch to Detailed | careful, **and the Detailed switch is disabled** |
+| connect-time usage probe | fires on every connect | not fired automatically (`commands::remote`) |
+| giant-folder census (`du -ak`) | runs on connect | never runs against the host (`commands::sync`) |
+| disk-usage scan | runs | **refused until confirmed for that scan** (`commands::disk_usage` → `HPC_GUARD` → `lib/hpcGuard.ts`) |
+| auto byte-sync loop (25 s) | starts on connect | never starts (`services::sync_auto`) — manual push/pull still works, and the tag is re-read **per tick**, so tagging a connected host stops the loop mid-session |
+| git lockstep poll (12 s) | starts when lockstep is on | never starts (`services::git_peer`), same per-tick re-read |
+| auto-connect at launch/VPN-up | as armed | never, project or global machine (`stores/projects`, `stores/globalMachines`) |
+| silent reconnect of a dead pool (15 s) | re-dials | never (`stores/projects`' `silentReconnectDeadHost`) — a dropped session ends at a red lamp the user clicks |
+| Machines-menu reachability sweep | probes every machine on open | never swept; the row reads *not checked* until its **◎ Check** is pressed |
+| system-monitor poll | 3 s (12 s careful) | sampled once when the pane opens, then only on **↻ Refresh** |
+| network-traffic host poll (1 s) | polls | 12 s, and only while a session is open |
+| file-tree sync re-stat (15 s) | polls | never on a timer; window focus and an explicit re-list still refresh it |
+| "Remote host usage…" | reads every machine on open | not read automatically; the row offers **Read now** |
+| tmux persistence of a SLURM log tab | persists | not wrapped (`TabEntry.ephemeral`) — a `tail -F` must not outlive Eldrun on a login node. A real run (`srun --pty`) still persists |
+| Python run / debug, script run | runs | **asks first** when it would land on the tagged host |
+
+Three design notes worth keeping:
+
+- **Refuse-and-confirm, not refuse.** A scan of the cluster tree and a run on the
+  login node are things people legitimately want; what the tag buys is that
+  neither happens *by accident*. The backend refuses with a sentinel naming what
+  was refused and which machine (`services::hpc_mode::guard_error`), the frontend
+  wraps the call in `withHpcConfirm`, and confirmation is per act, never
+  remembered — a gate that can be worn down by one click is not a gate.
+- **Opening a plain shell is deliberately not gated.** On a cluster you open
+  shells constantly, to submit and to look around; a prompt on each is the
+  warning everyone learns to click through. The gate sits on the two actions that
+  actually compute.
+- **The gate is the backend's, not the UI's.** Every row above was once enforced
+  only in TypeScript, and the tag's central promise — *Eldrun never logs in here
+  by itself* — was therefore only as good as the last surface anyone remembered
+  to check. It wasn't: a hover over the header, a 15 s reconnect reconciler and a
+  restored terminal tab each dialled a tagged login node. See below.
+
+## The dial policy
+
+The tag's load-bearing promise is enforced in **one** place now:
+`ssh_common::authorize_dial(user, host, port, intent)`, called *inside* the seven
+functions that build an ssh argv (`ssh_base_args`, its password/master/passphrase
+variants, and `ssh_exec::ssh_pty_args`). There is no other way to construct an ssh
+command line in this codebase, so a surface cannot forget the gate — the argv it
+needs simply doesn't come back. `DialIntent::Background` against a tagged target
+returns the same `HPC_GUARD` sentinel the confirm dialog already parses.
+
+`Background` is the **default**, and that asymmetry is the whole design: a
+forgotten intent can only fail closed, into a refusal the user can see and
+override, never into a silent login. The two shapes are:
+
+- **always a gesture** — a command with no poller behind it (`ssh_default_dir`,
+  `ssh_list_dir`, `ssh_mkdir`: the folder browser) takes the authorization
+  unconditionally, so a tagged host stays *addable* and *browsable*;
+- **dual-caller** — a command reachable from both a click and a sweep
+  (`ssh_probe`, `ssh_connect`, `remote_connect`, the usage/monitor/tmux reads)
+  takes `background: Option<bool>`, where absent ≡ `true` ≡ background. A typed,
+  non-empty password is always read as a gesture regardless of the flag.
+
+A **pooled** connection holds a standing authorization from `connect_host` to
+`teardown_pooled`: once the user has connected a tagged project, work riding that
+master — tabs, git, file reads — is not Eldrun connecting by itself, and this is
+also the only signal the backend has for telling a restored tab from a clicked
+one. The frontend gates stay in place on top of it; the redundancy is deliberate,
+because the two answer different questions ("should I offer this?" and "may this
+dial happen?").
diff --git a/docs/context/multi_host_remote.md b/docs/context/multi_host_remote.md
new file mode 100644
index 0000000..5efba0c
--- /dev/null
+++ b/docs/context/multi_host_remote.md
@@ -0,0 +1,34 @@
+# Multi-host remote (compute hosts)
+
+Referenced from `CLAUDE.md`.
+
+- **A remote project can reach N machines, not one** (`docs/multi_host_remote_plan.md`,
+  `services::worker_sync`). The project's `remote` is the **primary** — it still owns
+  files, git, the mirror, and full bidirectional sync, unchanged. Extra **worker**
+  hosts (`Project.compute_hosts`, mirrored into `projects.json`'s
+  `extra["compute_hosts"]`) are experiment machines: their code is kept **one-way** in
+  sync from the mirror (source→worker, tracked files only, `reset --hard`, **never
+  `git clean`**), their files are read-only, and their experiment **outputs** (untracked
+  paths) stay on the worker until a user-initiated, size-confirmed **Pull outputs** — the
+  only worker→local byte path. Because worker sync is push-only it dodges the entire
+  divergence/conflict/local-loss half of lockstep. Each host has its own pool entry
+  (`remote::conn_key`, keyed `(project, host)`), its own pill lamp, and its own tab
+  locality (`host:<id>`); the primary is the implicit `"primary"` id, so every existing
+  file/git/sync caller keeps meaning "the primary" with no change. A tab runs on a host
+  via its `host:<id>` location → `PtyOptions.remote_host_id`. Managed from the pill's
+  "Remote machines…" (`RemoteMachinesWindow`).
+  - **A worker can instead SHARE the primary's folder over a shared filesystem — and
+    this is now the DEFAULT for a newly added machine** (`ComputeHost.shared_fs`,
+    schema default `false` for back-compat but the "Add machine" form ticks it on;
+    untick "Sync a copy" ⇒ shared). A shared-fs worker sees the primary's project
+    folder at its own `remote_path` (an HPC compute node on a shared home), so Eldrun
+    copies **nothing** and **never runs git on it** — a tab just `cd`s into that folder
+    and runs there (`wrap_pty_options` already uses `spec.remote_path`, so tab spawn is
+    unchanged). This is load-bearing for safety: the code path that would `git init` +
+    `reset --hard` a synced worker's tree must **never** fire on a shared-fs host, or it
+    corrupts the primary's real working tree. Three guards enforce it — `remote_connect`
+    skips `on_worker_connect`, `worker_sync::fan_out` skips via `wants_code_fanout`
+    (`!shared_fs && sync_code`), and `sync_worker` itself early-returns a no-op skip for a
+    shared-fs host so even a stray `worker_sync_now` is harmless. "Sync code now" / "Pull
+    outputs" / "Auto-sync code" are hidden for a shared-fs worker (its outputs are already
+    in the primary's folder, moved by the primary's own sync).
diff --git a/docs/context/openvpn.md b/docs/context/openvpn.md
new file mode 100644
index 0000000..7cff675
--- /dev/null
+++ b/docs/context/openvpn.md
@@ -0,0 +1,74 @@
+# OpenVPN tunnel
+
+Referenced from `CLAUDE.md`.
+
+- The **OpenVPN tunnel is machine-wide, not project-scoped.** It runs elevated
+  (`pkexec openvpn`) and Eldrun passes it no routing flags, so a config that pushes
+  `redirect-gateway` reroutes *the whole computer's* traffic — browser included — for
+  as long as it is up, whichever project asked for it. Two consequences are baked in:
+  it is tracked machine-level in `src/stores/vpnStatus.ts` (keyed by config path, with
+  a holder refcount — `releaseVpn` means a project logging out never pulls a tunnel out
+  from under another project) and surfaced in the header by `VpnIndicator`, which is
+  always present, lists every stored `.ovpn`, and can bring a tunnel **up or down with
+  no project behind it**. Every UI that can start a tunnel says so before it does —
+  and none of them offers a *second* one: while a tunnel is up machine-wide, every
+  project-scoped OpenVPN block (the Connect modal, and the SSH section the
+  new-project and extend-to-remote dialogs share) collapses to a one-line
+  "tunnel already up" notice pointing at the header, via the shared
+  `useVpnSectionVisible` gate + `VpnTunnelUpNotice`. The exception the gate keeps:
+  a tunnel *that* dialog itself brought up stays expanded, so its log and its
+  Disconnect remain where the user started it.
+  Interactive (non-headless) tunnels are *armed* at command-build time —
+  `interactive_connect_command` appends a `--writepid` Eldrun owns and registers it —
+  so a tunnel typed into a terminal tab is as visible and as killable as a headless
+  one, and no longer outlives the app still owning the routing. Split-tunnelling is
+  **not** implemented: whatever the `.ovpn` pushes still applies (TODO #82).
+- **A headless login that cannot work is escapable, per tunnel.** Eldrun's own login
+  models exactly two secrets (account password, key passphrase); a config whose server
+  asks anything else — a challenge/OTP, a second prompt — is unanswerable from the
+  modal, and no amount of retyping changes that. The symptom is a loop: the saved
+  credentials fail, the prompt opens, the password typed into it fails too. So every
+  headless VPN surface offers the **non-headless flow for that one connect** —
+  `VpnPasswordPrompt`'s "Log in in terminal" (always present, disabled only while an
+  attempt is in flight, since that attempt's teardown is by *config* and would take the
+  terminal tunnel with it), and, after a failed connect, the same offer in the two
+  connect dialogs, which open their own embedded login terminal instead of a root tab.
+  It is deliberately a **local** switch and never writes `connections_headless`: a mode
+  is how the user wants Eldrun to behave, not something a failed handshake decides for
+  them. `lib/vpnAutoConnect`'s `openVpnLoginInTerminal` is the one implementation of the
+  handoff (arms the tunnel, opens the root tab, polls), shared with the paths that are
+  always non-headless. The prompt rejects its caller with `VPN_TERMINAL_HANDOFF` —
+  checked by every caller of `request`, because it is *not* a failure: the lamp is
+  amber, the poll owns the outcome, and reading it as "no tunnel" would paint a login
+  the user is still typing red.
+- A tunnel can also be armed to **connect on launch** (`settings.vpn_auto_connect`,
+  toggled per config in the `VpnIndicator` menu; `src/lib/vpnAutoConnect.ts`). It is
+  the machine-level twin of a project's `remote.auto_connect` and keeps the same
+  promise — *it never prompts*: the opt-in is only offered when the credentials make
+  the connect silent, and it is re-checked at launch, so a stale opt-in leaves the
+  tunnel down. One config, not a set: two would be two claims on one machine's routing.
+  With `connections_headless` off it instead opens the connect command in the root
+  terminal, since Eldrun handles no passwords in that mode.
+- **Never elevate on a connect that cannot succeed.** `pkexec` authenticates the user
+  *before* OpenVPN reads the config, so a doomed attempt is not a cheap failure — it
+  costs a polkit dialog, and the modal that then collects the missing credential costs
+  a second one. Every silent-connect path therefore asks `vpn_can_connect_silently`
+  first (`src/lib/vpnConnect.ts`) and goes straight to the modal when the answer is no.
+  The missing credential was usually the `auth-user-pass` **username**: it lived only
+  on a project's `OpenVpnSpec`, so a tunnel started from the header had none — the
+  backend now keeps a copy beside the saved password (`openvpn_user_account`), saved
+  and cleared by the same opt-in checkbox as the secrets.
+- **One polkit prompt per tunnel, on connect — and closing Eldrun never traps you.**
+  Elevation is unavoidable to *build* a tunnel (tun device + routing), but stopping
+  one is not: every tunnel Eldrun starts, headless or typed into a terminal tab,
+  carries an owner-only `--management` socket on loopback, and teardown asks the root
+  daemon to `signal SIGTERM` **itself** — nothing to elevate, so no second password.
+  The endpoint sits beside the pidfile so a tunnel from a previous run stays
+  stoppable after a restart. It is deliberately an *optimization*: an unconfirmed
+  shutdown (or a config carrying its own `management` directive, which `--management`
+  twice would turn into an options error) falls back to the old `pkexec kill`, so no
+  path can silently strand a tunnel. And that fallback is asked **at most once** — on
+  the close path, while the window is still on screen. Declining it does **not** block
+  the quit: Eldrun warns that the tunnel stays up and closes anyway, and records the
+  refusal so the exit-time teardown does not raise a second, parentless polkit dialog
+  after the window is gone (which is what used to leave the machine unusable).
diff --git a/docs/context/remote_autoconnect.md b/docs/context/remote_autoconnect.md
new file mode 100644
index 0000000..9b33dc5
--- /dev/null
+++ b/docs/context/remote_autoconnect.md
@@ -0,0 +1,85 @@
+# Remote auto-connect
+
+Referenced from `CLAUDE.md`.
+
+A remote project connects **on demand** (the pill's connection lamp opens the
+`RemoteConnectDialog`) — *unless* it opts into `remote.auto_connect`, which
+connects it on launch and on activation and **never prompts**. The toggle is only
+offered when that promise can be kept: a saved SSH password, or a host the backend
+recorded as `remote.key_auth` (it authenticated with no password at all). Whether
+the OpenVPN tunnel is needed is a property of the *network*, not the project — the
+same host is often reachable directly at one site and only through the tunnel at
+another — so `autoConnectRemote` (`src/stores/projects.ts`) probes (`ssh_probe`)
+and brings the tunnel up only when the host is genuinely *unreachable*, never when
+it merely rejected a credential.
+
+With **`connections_headless` off** the promise is kept differently, because it
+cannot be kept that way at all: Eldrun persists no passwords in that mode, so the
+eligibility gate above can never pass and auto-connect used to reject every project
+and do nothing, silently. There, "auto-connect" means what it means for a tunnel
+armed in the header (`lib/vpnAutoConnect`): the connect command opens in the **root
+terminal** for the user to authenticate, and the pool then rides the ControlMaster
+that login leaves behind (`autoConnectInteractive` → `pollRootLoginReady`, the
+store-side twin of the Connect dialog's `pollSshReady`). No *modal* is raised on
+either path — that is the invariant; a saved credential is only how the headless
+path achieves it. The toggle is correspondingly ungated in that mode, and the probe
+still decides the VPN: reachable-but-rejected is the normal state of a password host
+there and must never be read as "this network needs the tunnel". When the host *is*
+genuinely unreachable and the project carries a `.ovpn`, non-headless auto-connect
+surfaces the **tunnel's** login in the root terminal too — but it must **never** mark
+the machine-wide tunnel `"connecting"` or poll it from this path. A tunnel is
+machine-wide and its lamp is shared, so an *unattended* project poll that resolves
+late (or not at all, on a switch-away) strands the header on a phantom `"connecting"`
+— which `VpnIndicator`'s Disconnect refuses to touch (disabled while connecting) and
+the Connect dialog reads as a live tunnel (`anyVpnLive`), so the tunnel is at once
+un-stoppable and un-reconnectable. The machine-wide lamp therefore has exactly one
+owner that cannot strand it: `VpnIndicator`'s 10 s `refresh` reconcile, driven by the
+backend's real tunnel set. Auto-connect just leaves the SSH lamp **red** and returns;
+when the reconcile flips the tunnel to `connected` it fires `retryAutoConnectAfterVpn`,
+which resets that red lamp and re-runs the connect — now reachable. (For the same
+reason `pollVpnUp`, still used by the *manual* reconnect path, polls to a terminal
+mark regardless of the active project rather than bailing mid-handshake.) Because the
+login tab **is** the connection on that path, closing it is an outcome of its own
+(`"closed"`, distinct from `"timeout"`): the lamp goes back to *disconnected*, not
+red, since the re-attempt guard only fires from `"off"` — a red lamp would read a
+deliberate dismissal as a failure and wedge the project shut. The root-terminal
+dedupe (`lib/remoteConnect`) expires with the tab for the same reason: it now maps
+each key to the tab carrying it, so a closed login stops claiming the key and the
+next activation offers the login again instead of waiting on a master that is never
+coming. A `null` mapping is a connection another surface owns (the Connect dialog's
+embedded terminal), whose lifetime stays that surface's business.
+
+## The three gates, and why "armed" is not one question but three
+
+`auto_connect` is the *user's* opt-in, and for a long time it was the only thing
+checked — which was the bug: a project could be dialled unattended by paths that
+never asked. Every unattended connect now passes the same three, in order:
+
+1. **`mayAutoTouch(settings, target)`** (`src/lib/hpcHost.ts`) — fail-**closed**.
+   `isHpcHost` answers `false` for a null settings object, which is right for
+   painting a badge and wrong for authorising a connect; the launch sweep runs in
+   exactly that window, so it needed a predicate that says *no* while it doesn't
+   yet know. `stores/projects`' `load()` additionally awaits the settings store
+   before auto-connecting at all.
+2. **the host's own `auto_connect`** — primary or worker. This is the one that
+   `silentReconnectDeadHost` was missing: a 15 s reconciler re-dialled any host
+   whose pool had died, so a single manual connect to a host the user had never
+   armed became a permanent reconnect loop, one per `ControlPersist` expiry. Its
+   doc comment claimed it applied "exactly the same eligibility bar" as
+   `autoConnectPrimary`. It did not; it does now, and a dropped session ends at a
+   red lamp rather than a re-dial.
+3. **eligibility** — a saved password or `key_auth`, so the promise never to
+   prompt is kept.
+
+An armed project that fails (3) is no longer *silent*. It used to `return` with no
+lamp, no toast and no console line, which reads exactly like "auto-connect is
+broken" — and, since a locked keyring answers the same as an empty one, that is
+what the user saw when their credential had merely become unreadable. It now says
+which of the two happened (`remote_saved_password_state` returns
+`{ saved, keyring }`, not a boolean), and the keyring case offers the same
+**Unlock keyring** action the VPN side has had all along.
+
+Finally, none of this is the only line of defence: the backend refuses a
+background dial to a tagged host inside the ssh-argv builders themselves
+(`docs/context/hpc_careful_mode.md`, "The dial policy"). The frontend gates decide
+what to *offer*; the backend decides what may *happen*.
diff --git a/docs/context/remote_credentials.md b/docs/context/remote_credentials.md
new file mode 100644
index 0000000..ff84cab
--- /dev/null
+++ b/docs/context/remote_credentials.md
@@ -0,0 +1,207 @@
+# Remote credentials & host security
+
+Referenced from `CLAUDE.md`.
+
+- **A locked keychain is not an empty one, and Eldrun must never confuse the two.**
+  On Linux the Secret Service collection holding every saved SSH/VPN credential can be
+  *locked*, and through the `keyring` crate a locked collection reads exactly like an
+  empty one: every lookup answers "nothing saved". That is not a cosmetic difference —
+  it silently un-saves the credentials the user explicitly asked to keep, so a restart
+  brings back a blank password prompt, no silent connect, and an armed auto-connect
+  that quietly does nothing (reads used to *hang* there instead, which is why
+  `remote_credentials::read_timed` bounds them at 4 s — the bound turned a freeze into
+  this silence). So the lock is a first-class state: `keyring_state`
+  (`unlocked`/`locked`/`unavailable`) and `keyring_unlock` (`commands::credentials`,
+  `src/lib/keyring.ts`), the latter raising the *system's* unlock dialog and therefore
+  only ever reachable from a click — never from a launch path, which promises not to
+  prompt. Because the keychain cannot be asked while locked, the **intent** to remember
+  a tunnel lives outside it, in `settings.vpn_saved_configs` (paths, never secrets);
+  it is what lets the VPN menu's "Save login credentials" toggle show the truth at
+  startup, lets Connect know an unlock is worth raising, and is reconciled back against
+  the keychain whenever that *is* readable. The header's VPN menu is where all of this
+  surfaces: a locked banner with **Unlock keyring**, and the per-config save toggle
+  beside "Connect on launch" — which is also the only place a **non-headless** user can
+  hand Eldrun a VPN secret at all, since that mode otherwise has no password fields.
+  In that mode the header's Connect uses saved credentials when it has them and
+  otherwise opens the connect command in the **root terminal**; it never raises a modal.
+  - **A locked collection is never dispatched to, and mostly does not have to be.**
+    `read_timed` bounds the *caller*, but the abandoned worker stays parked inside the
+    Secret Service call for as long as the unlock prompt goes unanswered — one thread
+    holding one open D-Bus connection, per read, on every connect path. When the process
+    exits they all drop mid-request, which is the state `gnome-keyring-daemon` aborts on;
+    systemd then restarts it *without* the login password PAM gave the original, so the
+    collection comes back locked and the next run parks its reads again. `get`/`set`
+    therefore ask `cached_keyring_state()` (one prompt-free probe per 10 s) **first** and
+    refuse to dispatch while locked — a write says so, a read falls to the cache below.
+    That cache is the other half: on Linux the store is `keyutils_persistent` — the
+    **kernel keyring in front of** the Secret Service, which stays the half that survives
+    a reboot — so only the first read of an account per boot is a D-Bus call at all, and
+    every later one is a syscall that cannot block, cannot prompt, and does not care that
+    the collection is locked. It is built by hand (`KeyutilsPersistentCredential`), not
+    via `keyring::Entry`: keyring 3.6's builder for that store returns a plain
+    secret-service credential, so the feature alone would be a silent no-op. The
+    consequence for callers is that **a lock is no longer proof that the silent path is
+    dead** — ask `canConnectVpnSilently` first and read the lock only to explain a *no*,
+    or a connect that needed nothing raises a system password dialog.
+- **Passwords are never persisted by default**, and the opt-in that persists them is
+  the same in every remote menu — the Connect modal *and* the new-project /
+  extend-to-remote dialogs (`useRemoteSession`, rendered by `RemoteProjectSection`).
+  It can be, because the keychain is keyed by **host target** (`ssh:user@host:port`)
+  and **config path**, never by project id: there is one saved credential per host and
+  per tunnel, whichever menu saved it. Hence the toggle is *pre-ticked* when the target
+  already has one (an untick is an explicit delete, so connecting with it unticked
+  would clear another project's saved password), and a blank password field means "use
+  the saved one", not "authenticate with nothing". The credential a create/extend
+  dialog authenticated with is also handed to that project's **first pooled connect**
+  (`stashRemotePassword`, single-use, never written to disk): connecting it
+  password-less would work — it rides the ControlMaster the dialog left up — but the
+  backend reads "no password given, none saved" as *key* auth and would record
+  `key_auth: true` on a password host, which auto-connect later believes.
+  That inference is now the caller's to disclaim, because handing over the password is
+  only one of several ways a connect ends up credential-less. `remote_connect` takes
+  **`via_login`**: "this may be riding a master somebody else authenticated" — the
+  non-headless login terminal, the session an add-machine/extend dialog left up, a
+  global machine's master. `commands::remote::record_key_auth` then answers `None`
+  ("this proves nothing, write nothing down") instead of `Some(true)`. A *password*
+  is still recorded either way: that is an observation, not an inference.
+- **Headless is a default, not a trap: every login section can be switched to a
+  terminal, for one connect.** Eldrun's own login can only ask what it has fields for —
+  an SSH password, an OpenVPN password and key passphrase. A host or tunnel is free to
+  ask something else (keyboard-interactive challenge, a one-time code, an expired
+  password), and then no number of retries can succeed; the observed symptom is a loop
+  of *credentials rejected → prompt → rejected*. So both connect dialogs carry
+  **"Sign in in a terminal"** (`components/projects/TerminalSignInToggle`) on both
+  channels, **default off**, which swaps the password fields for the same embedded
+  login terminal `connections_headless: false` uses — the server asks its own
+  questions, the user answers them, Eldrun still never sees a secret. The VPN password
+  modal has the same escape hatch as a button (`stores/vpnPrompt`'s
+  `handoffToTerminal`), since it has no fields to swap. Four rules make it safe:
+  it is **per connect** and never writes `connections_headless`; it is **not offered on
+  Windows**, which has no ControlMaster for a terminal login to leave behind (the
+  `winManual` reason); a started terminal **keeps the login section**, so flipping back
+  cannot orphan a live session; and it **never touches a saved credential** — the Save
+  password/passphrase row is rendered from *both* halves of the section (`sshSaveRow` /
+  `vpnSaveRow`), because the secret belongs to the host, not to how you happened to
+  sign in this time, and only an explicit untick ever deletes one. A terminal login
+  leaves nothing to stash, so the dialogs mark that connect `stashRemoteViaLogin` —
+  otherwise its credential-less success is read as key auth by the `via_login` rule above.
+  - The **add-a-machine** form (`RemoteMachinesWindow`) had no terminal login at all —
+    only the password field, in *both* modes — so it now grows the same one, and its
+    switch **defaults to on in non-headless mode**, where a password field was never
+    supposed to be. It cannot reuse the dialogs' plumbing (that lives in
+    `useRemoteSession`/`useRemoteReconnect`, which are per-project), so it drives the
+    shared browse hook directly: open `remote_login_command` in an embedded terminal,
+    poll a credential-less `ssh_connect` until the login's ControlMaster answers, then
+    `useRemoteBrowse.openSession` — freeze the session the user just authenticated,
+    with no second login. Its "Save password" row is *disabled* rather than hidden in
+    that path: the toggle only ever acts through `ssh_connect`'s `remember`, which a
+    terminal login never calls, so the keychain is left exactly as found.
+  - The header's **Machines** add form (`MachinesIndicator`) gets the same switch, but
+    its login goes to the **root terminal** rather than an embedded one: that menu
+    closes 250 ms after the pointer leaves it, which is no place to keep a live PTY —
+    and it is what the VPN indicator beside it already does in that mode. The finisher
+    differs too: there is no folder to browse, so once the poll sees the master it
+    calls the store's `register` (persist without authenticating) instead of `add`
+    (which would `ssh_connect` a second time and re-ask for the password this mode
+    exists to avoid). The label and "Connect on launch" fields are read through refs —
+    a poll re-schedules itself through the closure of the render that started it, and
+    a label typed while the login is still open is exactly the case that would drop.
+- **A terminal login and a saved credential are not a contradiction, so the keychain
+  is reachable from one — by the user's click, and only then.**
+  `connections_headless: false` (and every "Sign in in a terminal" flip above) means
+  Eldrun does not *handle* the secret: the host asks its own questions in a terminal
+  the user is watching. It never meant the keychain was empty — a password saved from
+  a headless connect, or from the header's VPN menu, sat there unreachable while it
+  was retyped into every login. `components/projects/CredentialPasteBar` is the way
+  in: a **"Type it for me"** row above each embedded login terminal, with a button per
+  credential the target actually has (`sshPasteEntries`/`vpnPasteEntries`, one
+  definition for all three surfaces). Four things keep it inside the policy above.
+  The secret **never enters the frontend**: `credential_paste_to_pty`
+  (`commands::credentials`) reads the keychain and writes the bytes into the PTY
+  *inside the backend* — no field, no component state, no event payload; only the
+  non-secrets (an SSH login name, a VPN auth username already shown in a plain field)
+  are pasted from JS via the ordinary `pty_write`. It is **user-initiated, at a
+  terminal the user is looking at** — the distinction that matters against the
+  next bullet: Eldrun still never *answers a prompt* on its own, it types what it was
+  asked to type, where the user put the cursor. It **submits nothing** (no newline), so
+  a paste into the wrong prompt is still correctable on the line — a paste is not a
+  login. And it **stores and deletes nothing**: an unsaved target (or a locked keyring,
+  which reads identically) reports "nothing saved for this login" rather than pasting
+  an empty secret. The SSH target carries the login name **being typed into that
+  terminal**, not the persisted one, because the keychain is keyed per login.
+- **A password Eldrun sends *by itself* is answering exactly one question, at a machine
+  that has already been vetted.** It never goes through a PTY — nothing writes into a
+  terminal but the user, or the paste they just clicked (above) — so a remote shell,
+  MOTD or script that asks for a secret gets nothing. It goes to OpenSSH's own `SSH_ASKPASS`, and what makes that safe is the
+  **argv**, not the shim: `ssh_password_{,master_}base_args` set
+  `PubkeyAuthentication=no` (no passphrase prompt),
+  `PreferredAuthentications=password` (no keyboard-interactive, the one channel where
+  the *server* writes the prompt text), `StrictHostKeyChecking=accept-new` (no yes/no
+  confirmation) and `NumberOfPasswordPrompts=1`, leaving `ssh` exactly one prompt it
+  can raise. Because that invariant is invisible from the shim, it is enforced twice
+  more, in both directions. **Upward**, `make_askpass` takes the ssh argv and
+  *refuses to build* against a command missing any of those four options
+  (`missing_single_prompt_opt`) — so a future caller cannot attach a password to a
+  command nobody vetted, which is a silent failure that would look exactly like a
+  working connect. **Downward**, the Unix shim re-states the same rule at the prompt
+  it is handed: it answers only OpenSSH's `…'s password:` request
+  (`prompt_is_password_request`) and writes anything else to a reject file, answered
+  with nothing, which the caller turns into "the host asked for something else, so
+  nothing was sent" (`unexpected_prompt_error`) instead of a bare `Permission denied`.
+  The **Windows** shim is deliberately prompt-blind: testing the prompt there means
+  forwarding it through `cmd`, which re-parses batch-argument expansions, so the check
+  would trade a narrow disclosure for a command injection. Windows therefore rests on
+  the argv restrictions — which is exactly why `make_askpass`'s refusal is not
+  defence in depth there but *the* defence — plus the gate below.
+  That gate is the other half, and it is the one thing `accept-new` does **not**
+  cover: it silently trusts a *first* key. That is the ordinary TOFU bargain for key
+  auth, but for a password it means the secret goes to whoever answered, with nobody
+  ever shown the fingerprint they were implicitly trusting. So every password path
+  calls `guard_first_contact` **before** the askpass is attached and refuses an
+  unknown host with an `UNKNOWN_HOST_KEY`-marked error;
+  `HostKeyConfirmDialog` (raised via `lib/hostKey.ts`'s `withHostKeyConfirm`, which
+  reads the target out of that error and retries once) shows the fingerprints and, on
+  a yes, writes them to `known_hosts` — which is what clears the gate, so there is no
+  second "confirmed" state to keep in step. Interactive connects opt in; **background
+  and launch paths deliberately do not** (they promise never to prompt), so an unknown
+  host simply leaves auto-connect's lamp red until the user connects by hand — and
+  goes red *at once* rather than after a retry loop, since the refusal is a decision
+  that will repeat identically, not a race worth waiting out. (The one retry loop
+  left that can meet an unknown host, extend-to-remote's, asks **once** and holds the
+  answer for the rest of the loop — `lib/hostKeyOnce.ts`.)
+  The bulk machine **import** loop is exempt for the same reason in reverse: one modal
+  per imported host would be a wall of prompts, so each lands as a red row whose
+  Connect asks once. The gate itself runs two short *local* subprocesses (`ssh -G` to
+  resolve `~/.ssh/config` aliases — checking the alias would call a long-trusted host
+  unknown — and `ssh-keygen -F`), so the async SFTP openers reach it through
+  `guard_first_contact_async` rather than blocking a tokio worker on it.
+
+## A connect must never be able to forget
+
+`ssh_connect` resolves the credential it will use as `typed || saved`,
+authenticates, and *then* applies the `remember` flag. So `remember: false`
+— `Remember::Clear` — deleted the password it had just successfully authenticated
+with. Not a rare path: the flag was seeded by an **async** read of the keychain, so
+pressing Connect before that read landed sent `false`; an unreadable keyring
+answered "nothing saved", which unticked the toggle, which then deleted what was
+actually there; and two surfaces (the Machines add form, the bulk import) never
+queried at all, so adding a host that already had a saved password wiped it. The
+observed symptom was one host's credential missing while fifteen others survived —
+the one host reconnected by hand through the Connect dialog.
+
+Two rules close it, and both are structural rather than careful:
+
+- **`false` is unrepresentable.** `rememberArg(checked)` returns `true | null`, and
+  the connect helpers' parameter types forbid the third value. Clearing a
+  credential is now *only* what the explicit untick / "Forget saved password" does,
+  through `remote_forget_password`. Every surface reaches the keychain through one
+  hook (`useSavedCredential`), so there is no second place to get this wrong.
+- **An unreadable store is never licence to delete.** `remember_secret` skips
+  `Clear` entirely unless the keyring is readable — a locked collection reads
+  identically to an empty one, and treating "I can't tell" as "there's nothing
+  there" is exactly how a password gets thrown away.
+
+Symmetrically, a *failed* write no longer reports success: `set`'s error used to be
+discarded (`let _ = set(...)`) while the UI set its "saved" state from the
+**request**. `ssh_connect` now returns `{ saved, save_error }` and the toggle
+renders what the keychain actually did, with the reason inline when it refused.
diff --git a/docs/context/remote_projects.md b/docs/context/remote_projects.md
new file mode 100644
index 0000000..110a994
--- /dev/null
+++ b/docs/context/remote_projects.md
@@ -0,0 +1,16 @@
+# Remote projects (SSH/SFTP-native, mount-free)
+
+Referenced from `CLAUDE.md`.
+
+Remote (SSH) projects are **mount-free** (no sshfs/FUSE): they are SSH/SFTP-
+native. Agent/terminal tabs run on the host over `ssh -tt`, file browsing and
+file I/O go over SFTP, and git runs on the host over SSH — all riding one
+pooled ControlMaster + `Sftp` session per active remote project (opened via
+`remote_connect`, see `services::remote`). Such projects carry a `remote` spec
+(`user?`, `host`, `port?`, `remote_path`, `openvpn?`) in their `project.json`
+and mirrored into the `projects.json` entry's `extra` (the always-local source
+of truth `remote_target_for` reads). Their `directory` is a **local** per-
+project state dir (`~/.local/share/eldrun/remote-projects/<id>/`) that holds
+`project.json`; the actual tree lives on `host:remote_path`. Remoteness is
+resolved explicitly by `services::remote::remote_target_for{,_dir}`, never by a
+path convention. Plan/history: `docs/mountfree_remote_plan.md`.
diff --git a/docs/context/tmux_sessions.md b/docs/context/tmux_sessions.md
new file mode 100644
index 0000000..690c543
--- /dev/null
+++ b/docs/context/tmux_sessions.md
@@ -0,0 +1,61 @@
+# tmux session persistence
+
+Referenced from `CLAUDE.md`.
+
+**A shell/script tab runs inside a tmux session so a long run survives** (#85,
+`docs/tmux_remote_plan.md`) — decoupled from the disposable channel, the tab
+**reattaches** on relaunch. It covers **two axes**:
+
+- **Remote** (on the SSH host): survives an SSH drop, a laptop sleep, a VPN drop,
+  or Eldrun quitting. **Default ON** per remote project
+  (`RemoteSpec.persist_sessions !== false`; opt out via the pill's "Persistent
+  sessions (tmux)"). `ssh_exec::wrap_pty_options` nests the existing `exec …`
+  inside `tmux new-session -A -D -s <name>`.
+- **Local** (on this machine, Unix only — no tmux on Windows): survives an
+  **Eldrun crash** (the tmux server is a daemon; the PTY only holds a client).
+  **Default ON** via `settings.persist_local_sessions`. `services::tmux_local`
+  rewrites the local spawn's `{cmd,args}` into a `tmux` argv in
+  `commands::terminal::pty_spawn`, *after* the ssh/docker branch so only a
+  genuinely local tab is wrapped.
+
+Scoped to **shell tabs** (Python runs open one; a command runs inside the
+session's login shell, which outlives it → the run reattaches, not re-runs) and
+never the root scope — **agent tabs are excluded** (they resume via their own
+session). The session name is a **`eldrun-<scope>--<uuid>` the frontend mints
+once per shell tab and persists** (`TabEntry.tmuxSession`, `lib/tmuxSession.ts`'s
+`newTmuxSessionName`) — *not* derived from the PTY id, which `loadFromLayout`
+regenerates on restore (a derived name would fork a second session on relaunch
+instead of reattaching); `tmux_attach` overrides it for a Sessions-view attach.
+**Scoping the Sessions view to one project** (`remote_tmux_list` →
+`ssh_exec::filter_sessions_for_project`) matters because the host is usually
+shared — a cluster login node carries several Eldrun projects' runs and other
+people's. It reads **two** signals, and the second is the load-bearing one:
+the **name** settles a session outright when it carries a project id (this
+project's prefix ⇒ shown, `eldrun-<other-project>--` ⇒ hidden), but that only
+ever covers sessions minted *after* the name was scoped. Every session already
+running on a host — the `eldrun-<uuid>` ones — and every hand-started session
+carry no id at all, and on a cluster those outlive the change by weeks, so a
+name-only rule leaves the view looking exactly as unscoped as before. Those are
+attributed by **working directory** instead (`#{pane_current_path}` in
+`tmux_ls_script`, `TmuxSession.current_path`): a session whose active pane sits
+inside this host's `remote_path` is this project's, one running elsewhere is
+not. A row whose host reported no path (older format) is shown rather than
+silently dropped. Nothing is unreachable: the view's **"All host sessions"**
+checkbox passes `include_all`, returning the host listing untouched, so an
+orphaned run outside every project tree can still be attached to or killed.
+**Kill vs. detach**: closing a tab **always detaches** —
+`lib/closeRemoteTab.ts`'s `closeTabWithConfirm` just `removeTab`s, killing only the
+ssh/PTY client, so the session lives on under its tmux daemon; an app-exit,
+crash, or respawn likewise **leave the session alive**. Disconnecting a remote
+machine is deliberately different: `remote_disconnect` and
+`remote_disconnect_all_hosts` end *every* tmux session on each currently
+connected host before tearing down its pool. A session's **×** remains the way to
+terminate just that one session (`remote_tmux_kill`/`local_tmux_kill`). Global
+machines also issue `remote_kill_all_jobs` before closing their master.
+Because a session outlives its tab, a host
+can hold runs no tab points at; the **Sessions view** (`☰` toggle in
+`ProjectFilesView`, mirrors the Orange view) makes them discoverable —
+**multi-host** (aggregated across the primary and every connected worker via
+`remote_tmux_list`, each row host-tagged), click a row to attach, per-row **×**
+(kill) and **Rename** (`remote_tmux_rename`, updates the owning tab's persisted
+name). tmux-absent falls back to today's plain `exec` + a notice.
diff --git a/docs/context/usage_stats.md b/docs/context/usage_stats.md
new file mode 100644
index 0000000..935e3d5
--- /dev/null
+++ b/docs/context/usage_stats.md
@@ -0,0 +1,19 @@
+# Usage stats
+
+Referenced from `CLAUDE.md`.
+
+**Usage stats are local-only** (`usage_stats.json`, `schema::usage_stats`): a
+rolling hour+day counter store behind the daily recap (which agents/models you
+used, prompts asked, shell commands, file churn, tabs). It clones
+`schema::net_usage`'s bucket+prune shape but its payload is an **open
+string-keyed counter map**, so adding a statistic costs one const in `metric`
+(mirrored in `src/lib/usageMetrics.ts`) and one render line — no migration.
+Deliberately NOT counted into it: **time** (`time_summary.json`), **network
+bytes** (`net_usage.json`) and **git** (re-derived from `git log` on demand) —
+the recap reads those at their source so they can never drift. Tab opens are
+counted in the frontend's `addTab`, *not* at `pty_spawn`, because the backend
+spawn fires again for every resumable agent tab respawned on relaunch. File
+churn comes from a recursive `notify` watcher on the **active** project
+(`services::usage_stats`); it cannot see an SFTP tree, so a remote project is
+counted only via its local mirror. The recap (`components/stats/`) opens on the
+first launch of each day (`daily_stats_recap`, default on) and from Settings.
diff --git a/docs/deck_presenter_plan.md b/docs/deck_presenter_plan.md
new file mode 100644
index 0000000..d6c3b4b
--- /dev/null
+++ b/docs/deck_presenter_plan.md
@@ -0,0 +1,614 @@
+# Native Presenter ("Deck") — Plan
+
+Status: **all seven phases implemented, including the dual-window presenter**,
+behind the experimental `deck_presenter` flag (`src/lib/experimental.ts` — off
+for everyone, on in debug mode). Tracked as TODO M#90.
+
+Automated gates green: `npx tsc --noEmit` clean, **147** deck tests, the full
+frontend suite (1985) passing. **Nothing here has been exercised live** — see
+the "Done ≠ Tested" legend in `TODO.md`. The dual-window half in particular is
+the one part of this feature whose failure mode is public (it fails in front of
+a room), so it needs live QA on real hardware with a real second display before
+it is trusted.
+
+**Post-Phase-7 additions (2026-07-24):** the rail shows real per-slide preview
+thumbnails and is user-resizable (drag handle, width persisted per tab via
+`ViewerState.deckRailWidth`); a **Notes** mode gives the editor a place to
+*write* `Slide.notes` (until now only the presenter ever read it); a **TeX**
+mode lists every TeX-figure object across the whole deck. TeX figures are the
+other addition: the toolbar's TeX FAB writes a blank `standalone`-class `.tex`
+beside the deck (`<deck>.tex-figures/<objectId>.{tex,pdf,png}`), compiles it,
+rasterizes page 1 to a PNG, and places it as an ordinary `image` object carrying
+an extra `texSrc` pointer. Double-clicking that object on the stage (or "Edit
+source" in the inspector / TeX list) opens the `.tex` as a real tab — Eldrun's
+full TeX editor, not a bespoke one — and a 1.5s mtime poll on the compiled PDF
+(mirroring the PDF viewer's own external-change poll) notices a recompile from
+that tab and re-rasterizes onto the slide automatically, the same "the PDF tab
+already mtime-polls" trick §7 relies on for the base plate.
+
+The integration anchors in §12 were verified against the tree by three
+read-only investigation passes over the PDF stack, the viewer-registration /
+file-I/O chain, and the TeX + overlay + GIF stack. Where an investigation
+contradicted the first draft of this plan, the plan changed — those points are
+marked **[verified]**.
+
+---
+
+## 1. What it is
+
+A native presentation surface for Eldrun with three separable halves:
+
+1. **Generation** — a base PDF, produced from TeX (Beamer or plain), imported
+   from any existing PDF, or created blank from a generated starter `.tex`.
+2. **Design** — editable object layers on top of each base page: text (with list
+   styles), images, shapes, single-path icons, GIFs. Direct manipulation with
+   snapping/alignment guides.
+3. **Presenting** — a fullscreen presenter with slide transitions (including a
+   GIF played as the bridge between two slides), per-object build steps, speaker
+   notes, a timer, and the existing laser/marker tools.
+
+The three are deliberately decoupled: you can design without ever compiling TeX,
+and you can present a deck whose layers are empty.
+
+---
+
+## 2. The structural decision: the sidecar is the document
+
+```
+talk.tex           source — you own it, Eldrun never writes to it
+talk.pdf           base plate — regenerated on every compile
+talk.eldeck.json   THE DECK — layers, builds, transitions, notes
+talk.export.pdf    flattened output, produced on demand
+```
+
+**The PDF is a background plate, not the document.** This is forced by TeX being
+a first-class generator: `latexmk` rewrites `talk.pdf` on every compile, so any
+layer stored *inside* the PDF is destroyed the next time the author fixes a typo
+in their source. A sidecar survives arbitrarily many recompiles.
+
+Three consequences fall out, all of them wanted:
+
+- **The deck is a tracked text file.** It diffs, it merges, and git lockstep
+  carries it to a remote host like any other source file — no binary blob, no
+  special sync path.
+- **Two authoring models stop fighting.** TeX is declarative source; the layer
+  editor is direct manipulation. The rule that keeps them from contradicting each
+  other is one-way: *TeX owns the base plate, the editor owns the top, and the
+  editor never writes back to `.tex`.*
+- **Export is a build step, not a save.** `talk.export.pdf` is derived,
+  throwaway, and never read back — mirroring the existing rule that
+  `pdfDoc.ts`'s `buildPdf` is the only place a PDF is written.
+
+### 2.1 Anchoring layers across a recompile
+
+Anchoring a layer to a page *index* breaks the moment a slide is inserted in the
+TeX — the single most common edit an author makes. There are two anchors, and
+the better one turns out to be free:
+
+**SyncTeX, when a `.tex` source exists. [verified]** `compile_tex` already passes
+`-synctex=1` unconditionally (`commands/tex.rs:197,221`) and `lib/viewers/tex.ts`
+already exposes `synctexEdit`/`synctexView` returning `SyncRect{page,x,y,w,h}`.
+So a slide generated from TeX anchors to **the source line that produced it** —
+which survives insertion, deletion and reordering of other slides exactly as well
+as the author's own mental model does. Strictly better than any content
+heuristic, and it costs nothing: the mapping is already emitted and thrown away.
+
+**A content fingerprint otherwise** (an imported PDF has no source):
+
+```ts
+fingerprint = hash(pageWidthPt, pageHeightPt, firstNCharsOfExtractedText)
+```
+
+Resolution order on load:
+
+1. Page count unchanged and every anchor resolves → anchor by index. The common
+   case, and free.
+2. Otherwise → resolve by SyncTeX line (or fingerprint), then fill unmatched
+   slides in document order.
+3. Layers with no home go to a **detached bin**, surfaced with a "re-attach to
+   slide…" action.
+
+Never silently drop a layer. A recompile that quietly eats an author's
+annotations is what makes people stop using a tool.
+
+### 2.2 Saving: autosave, because there is nothing to hook
+
+**[verified]** Eldrun has **no unsaved-work prompt anywhere**.
+`closeTabWithConfirm` (`lib/closeRemoteTab.ts:86-88`) is literally
+`removeTab(key)` — its own comment calls itself a seam for a future confirm that
+was never added — there is no `beforeunload` in the viewer stack, and the PDF
+viewer's undo stack and unsaved arrangement are silently dropped on tab close.
+
+So a deck must never *hold* unsaved state. The sidecar is autosaved: it is
+small, it is text, and it is under git, so durable undo already exists at the
+right layer. That deletes the dirty flag, the save button, the close prompt and
+the stale-on-disk conflict banner from the design in one move.
+
+Two constraints govern how: **[verified]** `useEditableFile` autosaves on *every
+keystroke* while dirty (`FileViewerPane.tsx:1038,1104-1106`), and
+`write_file_text` **refuses to create a file that does not exist**
+(`fs.rs:1339-1354`). Therefore:
+
+- The live object model is **local React state during a gesture**; it commits to
+  the draft text only on gesture *end*. Otherwise dragging one object would issue
+  a disk write per `pointermove`.
+- A sidecar that does not exist yet is created with
+  `writeFileBytes(path, new TextEncoder().encode(json), scope)` — or
+  `invoke("create_file", …)` — never `writeFileText`.
+
+Export stays explicit. That one *is* a deliberate act.
+
+### 2.3 Coordinates
+
+Object geometry is stored **normalized to the page box** (0..1) — the same choice
+`PresentationOverlay` makes for marker strokes, so zoom, pane resize, a second
+monitor and export at any DPI all work with no conversion table.
+
+Type size is stored in **PDF points**, not normalized. The split is deliberate:
+geometry is relative (a page-size change should move things sensibly), type size
+is absolute (24 pt should stay 24 pt).
+
+Dropped from the first draft: a per-object `anchor` field (which page edge the
+position is measured from). Normalized coordinates already keep an object where
+it belongs; `anchor` would only matter on a base-plate aspect-ratio change, and a
+field with no reader is not worth encoding speculatively.
+
+**The coordinate chain [verified]** — `scale` in the PDF viewer is
+CSS-px-per-PDF-point, so at `scale === 1` one CSS px is exactly one PDF point
+("big point"). `tex.ts` already provides both halves of the screen mapping,
+**top-left origin**:
+
+```ts
+pdfPointToBigPoints(rect, clientX, clientY, scale)  // tex.ts:249 — CSS px → bp
+bigPointsToCssRect(rect, scale)                     // tex.ts:263 — bp → CSS px box
+```
+
+What does **not** exist anywhere in the repo is the **bottom-left flip pdf-lib
+needs**. The exporter must add it — for an unrotated page,
+`yPdf = pageHeightPt - yTopLeft - h`; a rotated sheet has to go through
+`viewport.convertToPdfPoint`, since `getViewport({rotation})` bakes the turn in
+and the whole viewer already measures in the rotated space.
+
+---
+
+## 3. Object model
+
+```ts
+type DeckObject = {
+  id: string;
+  x: number; y: number; w: number; h: number;  // normalized to the page box
+  rot: number;        // degrees, free (unlike a PDF /Rotate)
+  opacity: number;
+  locked?: boolean;
+  hidden?: boolean;
+  build?: BuildStep;  // animate mode only
+} & (
+  | { kind: "text";  text: string; style: TextStyle; list?: ListStyle; … }
+  | { kind: "image"; src: string; fit: "contain" | "cover" | "stretch" }
+  | { kind: "shape"; shape: ShapeKind; fill?: string; stroke?: string; … }
+  | { kind: "icon";  icon: string; color: string; strokeWidth: number }
+  | { kind: "gif";   src: string; loop: boolean; autoplay: boolean }
+);
+```
+
+Z-order is list order — the same "an arrangement is a list, every op is pure and
+returns a new list" bargain `lib/viewers/pageModel.ts` already strikes, so undo
+is an array of snapshots and rendering is a straight `map`.
+
+**[verified]** Nothing in the repo has draggable/resizable canvas objects with
+selection handles. `ImageAnnotator` is stroke-only and pixel-destructive (its
+undo is a stack of `ImageData` snapshots); the only reusable pieces are its
+`toCanvas` pointer mapping and `drawArrow`. So the object model, hit-testing and
+handle math are genuinely new code — modeled on `pageModel.ts` (pure, tested,
+consumed by two views).
+
+### 3.1 Text, and why "enumeration fields" are a *style*
+
+A text object carries one style (family, size, weight, italic, color, align, line
+height) plus an optional list style:
+
+```ts
+list?: { kind: "bullet" | "number" | "alpha" | "roman"; start: number };
+```
+
+Modeling enumerations as a **list style on a text object** rather than a separate
+object kind buys three things at once: renumbering is automatic, nesting comes
+from per-line indent, and — the important one — **stepped reveal falls straight
+out**: list item *i* becomes build step *i*, in one click. The most-used
+animation in any talk, obtained for free from the data model.
+
+Deliberately **not** in v1: rich text runs *within* one object (bold inside a
+paragraph). One style per object; a second object is cheap. Inline runs need a
+span model, a caret that walks it, and per-run metrics — a rabbit hole with a
+poor payoff for slides.
+
+### 3.2 Text metrics: lay out with PDF metrics on **both** sides
+
+The classic failure of a WYSIWYG-over-PDF editor: the editor breaks lines using
+browser metrics while the exporter uses PDF metrics, so the export silently
+reflows.
+
+Avoid it by measuring with **PDF metrics in the editor too** — create one
+throwaway `PDFDocument` at startup, embed the standard-14 fonts, and make
+`font.widthOfTextAtSize` the single source of truth for wrapping in both the
+canvas and the exporter. Export is then identical to the screen by construction.
+
+Accepted cost: **v1 is standard-14 only** (Helvetica / Times / Courier ×
+regular/bold/italic/bold-italic). Arbitrary TTFs need `@pdf-lib/fontkit` plus a
+font-embedding UI and buy little for a talk. On Linux, Helvetica resolves to
+Nimbus Sans / Liberation Sans, which are metric-compatible, so the on-screen
+paint matches as well as the line breaks do.
+
+### 3.3 Shapes and icons: one mechanism
+
+pdf-lib emits vector art through `drawSvgPath`, which accepts **SVG path data** —
+not gradients, not groups, not a full SVG document. That single constraint
+decides both features:
+
+- **Shapes** are parametric path generators (rect, rounded rect, ellipse, line,
+  arrow, callout) — a function from geometry to a path string.
+- **Icons** must therefore be **single-path monochrome** icons, which is exactly
+  the Lucide/Feather shape. ~150 curated icons ship as inline path strings in one
+  TS module: no dependency, no network fetch (the offline story stays clean),
+  recolorable and resizable because they are paths, and lossless to PDF.
+
+One renderer (`<path d=…>` in SVG) and one exporter (`drawSvgPath`) cover both.
+Arrows get draggable endpoints and a start/end marker set, because an arrow is
+the most-drawn object on a slide and a non-adjustable one is useless.
+
+---
+
+## 4. Snapping
+
+A pure module returning `{ x, y, guides[] }` so the stage only paints what it is
+told. Candidates, in priority order:
+
+- page center X / Y, and the page's safe-area margins
+- every other object's six anchors (left/center/right × top/middle/bottom)
+- **equal spacing** — the gap between two other objects, i.e. distribute-by-drag
+- **same size** — during a resize, another object's width or height
+- text baselines between two text objects
+
+Modifiers: `Shift` locks the axis, `Alt` suspends snapping.
+
+This gets the heaviest unit-test coverage in the feature. A sign error in
+snapping is invisible in code review and infuriating in use.
+
+---
+
+## 5. Animate mode (separate from design)
+
+A distinct mode, as specified — the design canvas ignores animation entirely and
+the animate canvas edits nothing else. Two orthogonal axes:
+
+### 5.1 GIF interstitials — the point of the feature
+
+A GIF is **not** a transition effect and **not** an object on a slide. It is a
+first-class entry in the slide *sequence*: an animation that plays between slide
+*N* and slide *N+1*.
+
+The reason this is the headline feature and not a garnish: a PDF produced by TeX
+**cannot carry animation at all**. An author who wants to show a training curve
+evolving, a simulation running, or a mechanism moving has to either leave the
+deck and alt-tab to a video player, or give up. An interstitial puts the
+animation *inside the presentation sequence* while leaving the deck a pure,
+TeX-generated, version-controllable PDF. Nothing about the base plate changes.
+
+Model — an interstitial hangs off the slide it follows, so the slide↔base-page
+anchoring (§2.1) is untouched:
+
+```ts
+interface Interstitial {
+  id: string;
+  src: string;                 // project-relative path to the .gif
+  fit: "contain" | "cover";    // full-bleed letterboxed, or filled
+  background: string;          // what shows in the letterbox bars
+  /** How it ends. */
+  advance:
+    | { on: "manual" }                    // loop until the presenter advances
+    | { on: "end" }                       // play once, then auto-advance
+    | { on: "end-after"; loops: number }; // play N times, then auto-advance
+  /** Frame shown in the editor rail, and exported as a still (§5.2). */
+  poster: number;
+}
+
+interface Slide { …; after?: Interstitial }   // "after this slide, before the next"
+```
+
+Presenter semantics: `→` from slide *N* enters the interstitial (it does not skip
+to *N+1*); `→` again leaves it for *N+1*; `←` from the interstitial returns to
+*N*. It occupies one step, exactly like a build step does.
+
+**Export.** A GIF cannot be a PDF. `talk.export.pdf` therefore writes the
+interstitial's **poster frame** as its own page by default, so the exported
+handout has a placeholder where the animation was rather than an unexplained jump
+— with a per-deck option to omit interstitial pages entirely.
+
+**[verified]** Playback reuses `lib/viewers/gif.ts`, which is dependency-free and
+already exposes exactly what is needed: `openGif(bytes, {maxPixelBytes})` →
+`GifStream.nextFrame()`, `decodeGif`, and `effectiveDelayMs` (sub-20 ms delays
+play at the 100 ms browser convention). Two facts to design around:
+
+- **Memory.** Every frame is a full-canvas RGBA copy — a 1920×1080 GIF costs
+  ~8.3 MB *per frame*, so ~30 frames reaches the 256 MB default cap. A transition
+  GIF must be opened with a much smaller explicit `maxPixelBytes`, and frames
+  pre-baked to `ImageBitmap` so playback is `drawImage`, not `putImageData`
+  (which ignores transforms and so cannot scale).
+- **Playback.** `GifView`'s rAF accumulator (banked wall-clock × speed, may
+  advance several frames per tick, `MAX_CARRY_MS` clamp so a backgrounded tab
+  doesn't spin on resume) is correct and should be lifted verbatim rather than
+  rewritten.
+
+### 5.2 The other two axes
+
+**Transitions** (slide *N* → *N+1*): `none | fade | push | wipe`. Cheap, purely
+cosmetic, and deliberately separate from interstitials — a transition is *how*
+one page replaces another; an interstitial is *a thing you show*.
+
+**Builds** (within one slide): each object gets an appear step (0 = visible on
+entry) and an effect (`none | fade | rise | scale | wipe | draw`). Space advances
+one build step; when a slide's steps are exhausted, space advances to the
+interstitial if there is one, and otherwise to the next slide.
+
+Two details without which the mode is unusable: build steps render as **numbered
+badges on the objects** in the editor (animation whose structure you cannot see
+cannot be reasoned about), and the presenter steps builds **backwards** — `←`
+must undo the last reveal, not jump slides, or the first audience question costs
+you the whole slide.
+
+---
+
+## 6. The presenter
+
+**[verified]** Two mechanisms already exist and should be used instead of
+`requestFullscreen`:
+
+- `useTabsStore.toggleFullscreen(groupId)` (`stores/tabs.ts:589`) gives an
+  app-internal full-bleed pane with zero new plumbing — panes stay mounted, it is
+  a reposition not a remount, and Escape already clears it. Every viewer already
+  receives `groupId`.
+- The **dual-window** arrangement (`D`, or the ⧉ button) opens a second OS
+  window: audience view on the external display, presenter view on the laptop —
+  current slide, next slide, speaker notes, elapsed + wall-clock time, build
+  indicator.
+
+**Why the audience window is NOT a detached subwindow (#42).** A popout is a tab
+group: a layout, a seed/edit protocol, dock-back, persistence — and *parking*.
+That last one is disqualifying: `project_runtime::switch` hides a project-owned
+window when its project goes inactive, which mid-talk would blank the projector.
+So the audience window is its own thing (`commands/presenter.rs`, ~110 lines):
+built by `open_presenter_window`, registered nowhere, owned only by the presenter
+that opened it, and destroyed with it. What it *does* borrow from #42 is the two
+lessons that path paid for — the command must be `async` (a sync command deadlocks
+`WebviewWindowBuilder::build()` against WebView2 on Windows) and the first paint
+must be kicked (WebKitGTK's second webview is an unpainted black GL surface until
+a genuine OS resize; WebView2's is blank white until shown).
+
+Its label is derived from the deck's **path** (`presenterLabel`), so opening the
+second display twice for one talk targets the window already on the projector
+instead of stacking another on it. `choose_audience_monitor` puts it fullscreen on
+the first monitor the main window is *not* on; with one monitor it opens windowed
+and decorated, to be dragged wherever the speaker wants.
+
+**One owner, two heaps.** Two webviews cannot share a store, so the protocol
+(`lib/viewers/deck/present.ts`, pure and tested) is deliberately lopsided: the
+presenter window owns the stop and the blank screen; the audience window renders
+what it is told and forwards the keys pressed *in it* back as requests. A second
+index in the audience window is precisely how two displays end up a slide apart
+in front of a room. Both windows run the same `keyToAction` map, so a clicker
+means the same thing whichever window has focus.
+
+What crosses: the deck as its **serialized sidecar** (small, and the only shape
+both halves agree on — the presenter may hold edits the 800 ms autosave has not
+written), plus the deck's path and file scope. What does **not** cross: the base
+PDF, images and GIF frames — the audience window loads those itself through the
+ordinary confined file commands (`deckAssets.ts`, shared with the editor), so a
+40 MB plate never becomes an event payload.
+
+Known limit: the laser and marker are drawn on the presenter's window and are
+**not** mirrored to the audience one (TODO M#90).
+
+The laser and marker come from `PresentationOverlay`, whose self-contained pieces
+(`sizeCanvases`, `drawMarker`, `relPoint`, `pushLaser`, the laser rAF effect, the
+palette and width/alpha constants) touch no store, file or tab and lift verbatim.
+Its existing themed CSS classes are reusable by name. One caution: it is mounted
+**once over every viewer** by `FileViewerPane`, so a viewer-level fullscreen
+overlay must not fight it.
+
+Keys: `Space`/`→` next build-or-slide, `←` previous build, `↑`/`↓` slide skip,
+`B` black, `W` white, `G` grid overview, `N` notes, `D` second display, digits +
+`Enter` goto, `Esc` exit. `G`/`N`/`D` are the speaker's alone — they never leave
+the presenter window.
+
+Any portal must target `document.getElementById("root")`, **not**
+`document.body` — a body-level portal can fail to paint in a detached popout
+webview (documented at `ContextFilePicker.tsx:129-143`).
+
+---
+
+## 7. Generation — three ways in, one deck out
+
+- **From TeX** — point at a `.tex`, compile via `compile_tex`, wrap the output.
+- **From a PDF** — any PDF becomes a base plate. The "annotate a paper for
+  journal club" path; needs no TeX at all.
+- **From blank** — generate a minimal starter `.tex` (title / section / content
+  frames) and compile it, so "New presentation" works with zero TeX knowledge
+  while the `.tex` stays there, editable, for anyone who wants it.
+
+**[verified] `compile_tex` constraints that shape this:**
+
+| Constraint | Consequence |
+| --- | --- |
+| Path must end `.tex` and must already exist (`canonicalize`) | write the file before compiling |
+| CWD is always the source file's parent | images/assets live beside the `.tex`, or use paths relative to it |
+| Output is `<stem>.pdf`, or `outDir/<stem>.pdf` | pass `outDir: "build"` to keep `.aux`/`.log`/`.synctex.gz` out of the deck folder |
+| Shell-escape is unconditionally stripped | no `minted`, no TikZ externalization |
+| **No timeout; the command is synchronous** | a hanging `latexmk` blocks a Tauri worker, and the frontend has no abort. `-interaction=nonstopmode` prevents the classic interactive hang, but adding a timeout to `commands/tex.rs` is worth doing as part of this work |
+| **Local only** — no remote dispatch | a remote project compiles on its **local mirror**. Acceptable (the mirror is local by construction) but must be stated in the UI rather than failing obscurely |
+
+Free wins: the PDF tab already mtime-polls at 1.5 s, so a recompile refreshes the
+open base automatically — no invalidation to write. **Beamer appears nowhere in
+the codebase** (zero hits), so frames/overlays/`\pause` are entirely new ground.
+
+Deferred: **from Markdown** (`---`-separated markdown → generated Beamer `.tex`).
+The fastest authoring path, reusing the existing markdown renderer, but additive
+and best landed after the core is real.
+
+---
+
+## 8. Deliberately out of scope
+
+| Not building | Why |
+| --- | --- |
+| Write-back from canvas to `.tex` | Round-tripping direct manipulation into source is what makes such tools untrustworthy. One-way keeps the contract stateable in one sentence. |
+| Rich text runs inside one object | Needs a span model + per-run metrics + a caret that walks runs. A second text object is cheap. |
+| Arbitrary font embedding | `@pdf-lib/fontkit` + a font UI; standard-14 covers slides. |
+| PPTX import/export | An enormous format surface for a workflow this is not aimed at. |
+| Video | Video-in-PDF and video-in-webview are both painful. GIF is already decoded. |
+
+---
+
+## 9. Risks
+
+- **Size.** The largest single feature in the app (~18–20 new files). Phasing is
+  mandatory; each phase must leave the tree type-checking and tested.
+- **WebKitGTK.** HTML5 drag-and-drop does not work (learned twice already — see
+  `stores/pdfDrag.ts` and `YamlTree`); every gesture here is **pointer-based**.
+  Animated blurred box-shadows destroy paint performance under software
+  rendering, so the presenter uses static-shadow pseudo-elements + opacity.
+- **A write per pointermove.** The single easiest way to make this feature feel
+  broken; see §2.2 for the gesture-local-state rule that prevents it.
+- **`compile_tex` has no timeout and no remote support.** See §7.
+- **GIF memory.** See §5.
+- **Undo across two modes.** Design edits and animate edits share one document.
+  One history stack, not two, or "undo" becomes unpredictable.
+- **Fullscreen presenting** is unexercised in this app — a live-QA item.
+
+---
+
+## 10. Phases
+
+Each phase ends with `npx tsc --noEmit` clean and its own tests green.
+
+| Phase | Contents |
+| --- | --- |
+| **0** | Experimental flag `deck_presenter` (TS `Settings` + Rust `Settings` + accessor + both experimental tests), viewer registration for `*.eldeck.json` (§12), empty `DeckView` shell. |
+| **1** | `deck/model.ts` (types + pure ops), `deck/sidecar.ts` (load/save + anchoring + detached bin). Tests. |
+| **2** | `DeckStage`: base page render, object layer, select/move/resize/rotate/z-order, `deck/snap.ts` + painted guides. Tests. |
+| **3** | Objects: text (+ list styles, PDF-metric wrapping via `deck/fonts.ts`), image, shape generators, `deck/icons.ts` + picker. |
+| **4** | Generation: new-from-TeX / from-PDF / from-blank template; compile wiring (+ a `compile_tex` timeout). |
+| **5** | `deck/export.ts` — the single pdf-lib flatten, incl. the bottom-left flip. |
+| **6** | Animate mode: transitions (incl. GIF) + builds, badges in the editor. |
+| **7** | Presenter: fullscreen, dual-window, notes, timer, laser/marker reuse, keys. |
+
+---
+
+## 11. File layout
+
+```
+src/lib/viewers/deck/
+  model.ts      types + pure object ops (the pageModel of this feature)
+  sidecar.ts    load/save, fingerprinting, anchoring, detached bin
+  snap.ts       snapping/alignment/distribution → {x, y, guides}
+  fonts.ts      standard-14 metrics + wrapping (one source of truth)
+  shapes.ts     parametric path generators
+  icons.ts      the single-path icon library + categories + search
+  animate.ts    transitions/builds model + timing
+  export.ts     pdf-lib flatten (the ONLY writer)
+  template.ts   starter .tex generation
+
+  present.ts    the dual-window protocol + shared navigation/key mapping
+
+src/components/embed/deck/
+  DeckView.tsx        editor shell: rail + stage + toolbar + inspector
+  DeckStage.tsx       page + object layer + selection + gestures + guides
+  DeckObjectView.tsx  render one object by kind
+  DeckInspector.tsx   property panel
+  DeckRail.tsx        slide rail (thumbnails, reorder, select)
+  IconPicker.tsx      searchable icon grid
+  DeckAnimate.tsx     the separate animate mode
+  DeckPresenter.tsx   the presenter window (single- or dual-display)
+  DeckAudienceApp.tsx the audience window's root (`?present=<label>`)
+  DeckSlideView.tsx   a presented slide / interstitial — rendered in BOTH windows
+  deckAssets.ts       image + GIF loading hooks, shared by editor and audience
+  deckBase.ts         open the base plate, render a page
+```
+
+---
+
+## 12. Integration map [verified]
+
+### 12.1 Registering the viewer
+
+**The load-bearing gotcha:** `FileEntry.extension` is only the last dotted
+component — the backend builds it with `Path::extension()` (`fs.rs:50-53`) — so
+`talk.eldeck.json` arrives as `".json"`. The branch must test **`entry.name`**,
+and must sit **before** the `.json → "yaml"` line:
+
+```ts
+// fileUtils.ts, in naturalViewerFor, BEFORE line 194
+if (entry.name.toLowerCase().endsWith(".eldeck.json")) return "eldeck";
+```
+
+| # | File | Change |
+| --- | --- | --- |
+| 1 | `lib/viewers/fileUtils.ts:39-62` | add `\| "eldeck"` to the `InternalViewer` union |
+| 2 | `lib/viewers/fileUtils.ts:149-204` | the name-suffix branch above, before `.json` |
+| 3 | `lib/viewers/fileUtils.ts:140-146` | `VIEWER_FALLBACK.eldeck = "yaml"` so an opt-out degrades to the JSON tree, not the external app |
+| 4 | `lib/viewers/fileUtils.ts:254-334` | a `VIEWER_PREF_TYPES` entry — **required**, or the type can never be opted out and never appears in Settings |
+| 5 | `components/embed/FileViewerPane.tsx:440-479` | the dispatch branch, before the final `else` |
+| 6 | `components/tabs/TabHoverCard.tsx:38-56` | `VIEWER_LABEL` is an exhaustive `Record<InternalViewer, string>` — **TS will not compile until this key exists** |
+
+An unknown viewer id persisted on `TabEntry.viewer` falls through to `TextView`,
+so older/newer builds degrade safely.
+
+### 12.2 File I/O
+
+Every wrapper in `components/embed/fileAccess.ts` takes the scope as its last
+argument, and **remote SFTP is transparent** — each backend command routes
+internally on whether the project is remote and the path is outside the mirror.
+
+```ts
+readFileText(path, projectId)                 // read_file_text   — 8 MiB cap
+readFileBytes(path, projectId)                // read_file_bytes  — 64 MiB cap
+writeFileText(path, content, projectId)       // will NOT create a missing file
+writeFileBytes(path, content, projectId)      // may create — use for a new sidecar
+fileMtime(path, projectId)
+```
+
+Scope comes from `useFileScope()` (`fileAccess.ts:19-24`), never a hardcoded
+`null`. Errors go through `describeFileError`. A custom backend command is *not*
+automatically remote-aware — thread `projectId` yourself.
+
+### 12.3 Rendering over a PDF page
+
+`.file-viewer-pdf-page-wrap` is `position: relative` with the page canvas at
+top-left, and already hosts absolutely-positioned overlays (search hits, SyncTeX
+highlight). The object layer is another such child, sized
+`cssSize.w * scale × cssSize.h * scale`.
+
+The canvas contract (`PdfViewer.tsx:251-280`): device px = pt × scale × dpr,
+CSS px = pt × scale.
+
+### 12.4 Per-tab state and new tabs
+
+- Per-tab UI state (current slide) is a new field on `ViewerState`
+  (`stores/tabs.ts:177-235`, a flat interface), read via `useViewerState(tabKey)`
+  and written with `persist({...})`. `tabKey` is `undefined` in popouts that
+  cannot write back — degrade, don't crash.
+- Opening the compiled PDF (or any linked file) as its own tab uses
+  `openLinkedFile(tabKey, dir, { path, viewer, label })`
+  (`FileViewerPane.tsx:633-679`), exactly as TeX's "open the compiled PDF" does
+  at `:5877-5888`. It de-dupes against an already-open tab, and because the PDF
+  pane mtime-polls, a reused tab reloads the fresh bytes by itself.
+
+### 12.5 Styling
+
+Flat, lowercase, hyphenated, component-prefixed class names in
+`src/styles/themes.css` (BEM in `ImageAnnotator.css` is the outlier, not the
+convention), with bare state modifier classes (`.on`, `.active`, `.is-dirty`).
+Reuse `.modal-backdrop` / `.project-dialog` (accent top rail) for dialogs,
+`.context-menu` for popups, `.file-viewer-zoom-btn` + `" active"` for toolbar
+toggles, and the `.presentation-*` classes verbatim for the marker/laser bar.
+Read colors from the theme variables; note `--bg-header` is a *gradient* in some
+themes, so anything needing a color must use `--bg-header-solid`.
diff --git a/docs/docker_projects_plan.md b/docs/docker_projects_plan.md
index e1eb1c5..fca807b 100644
--- a/docs/docker_projects_plan.md
+++ b/docs/docker_projects_plan.md
@@ -1,271 +1,276 @@
-# Docker Projects — Implementation Plan (TODO #38)
+# Project Containers — Implementation Plan (TODO #38, v2)
+
+Status: **implemented** (Phases 0–4, 2026-07-13; Phase 5 remains deferred).
+Code-complete and unit-tested (`cargo test` argv/state suites, tsc); live
+Docker QA is the user's (Done ≠ Tested) — see the runtime checklist under
+Tests. This v2 supersedes the original docker-exec
+plan (see git history of this file): that plan predates the shipped agent
+sandbox (`services/sandbox.rs`) and, followed literally, would have built a
+second containerization feature next to it. **There is exactly one such
+feature.** The project container is an *evolution of the existing sandbox*,
+not a sibling: same toggle, same spec, same storage keys, same spawn seam —
+widened from "ephemeral container per agent tab" to "one session-lived
+container per project that every tab execs into".
+
+## What the toggle means (target behavior)
+
+A project with the toggle on runs **everything** in one closed container:
+
+- All terminal/agent tabs (`shell` and `agent` kinds) exec into a single
+  long-lived container named `eldrun-<project-id>`. `local_only` tabs (e.g.
+  Ollama `local_agent`) stay on the host verbatim, as today.
+- The project directory stays on the **host** and is bind-mounted at its
+  **identical absolute path**. The file tree, git UI, viewers, usage watcher,
+  and privacy scan keep reading host bytes unchanged — which is what makes
+  this a *toggle* (instantly reversible, nothing migrates) rather than a
+  data move.
+- "Closed" means the container's **reach** is closed — capability-dropped,
+  `--init`, pids-limited, optional `--network`/memory/cpu/read-only knobs,
+  only the project dir plus the minimal agent auth/state mounts — not that
+  the bytes are sealed in a volume. (An agent that must not even *see* host
+  bytes is the remote-project shape, out of scope here.)
+- Container lifetime = **project session**: created on activation/first
+  containerized spawn, torn down (stop + rm) on deactivation and app exit.
+  Every session starts from a fresh container, preserving most of the old
+  per-tab ephemerality while giving tabs a shared environment (installed
+  deps, dev servers) within a session. Persistent-across-restarts containers
+  are a later opt-in, not the default.
+
+## Why identical-path mounting (decision, was `/workspace` in v1)
+
+`services/sandbox.rs` already proved the contract: mount `<dir>:<dir>`, run
+`--user <uid>:<gid>`, set `-e HOME=<host home>`. Keeping it:
+
+- deletes v1's entire `container_workdir()` path-translation layer;
+- keeps **agent session resume** working — Claude/Codex transcripts and the
+  SessionStart hook record host-absolute cwds, so the *same* session resumes
+  correctly whether the toggle is on or off (with `/workspace`, flipping the
+  toggle would invalidate every recorded session);
+- keeps `-w <cwd>` per tab trivially correct for subdir tabs.
+
+## Data model — `SandboxSpec` grows, no new struct
+
+`schema/project.rs::SandboxSpec` (and its `types/index.ts` mirror) is the one
+spec. Same serde key (`sandbox`) in `project.json` and the `projects.json`
+entry `extra`, so **already-enabled sandbox projects upgrade in place** — no
+migration. Additions:
 
-Status: **planned** (not started).
-
-Run a project inside a Docker/Podman container instead of (or in addition to)
-directly on the host: the project's terminal/agent tabs run via `docker exec`
-into a container, with the project directory **bind-mounted** as the working dir
-so the file tree and git keep working against the host's bytes.
-
-This plan mirrors the two-mechanism shape that the SSH feature settled on
-(see `docs/ssh_projects_plan.md`):
-
-| SSH concern            | SSH file                       | Docker analogue          |
-|------------------------|--------------------------------|--------------------------|
-| Lifecycle (up/down)    | `services/ssh_mount.rs`        | `services/docker_runtime.rs` |
-| Spawn rewrite          | `services/ssh_exec.rs`         | `services/docker_exec.rs`    |
-| Browse/connect commands| `commands/ssh.rs`              | `commands/docker.rs`         |
-| Spec on the project    | `schema::project::RemoteSpec`  | `schema::project::DockerSpec` |
-
-The key difference from SSH: **the bytes are already local.** We do not need a
-filesystem mount to make the file tree work — the host project directory *is* the
-source of truth and is bind-mounted into the container. So the file tree, git,
-and `list_dir` all keep running unchanged against the **host** `directory`; only
-**terminal/agent spawns** are rewritten to execute inside the container. This is
-the inverse of SSH (where the bytes were remote and we mounted them locally) and
-it makes Phase 1 considerably simpler than the SSH work.
-
-The work is split into **two phases**: **Phase 1 — local Docker** (a container on
-the same host), then **Phase 2 — remote Docker** (a container on an SSH host,
-composing with the existing work-remote axis). Phase 1 is independently
-shippable and useful; Phase 2 builds on it.
+```rust
+pub struct SandboxSpec {
+    pub enabled: bool,
+    pub image: Option<String>,          // existing
+    /// NEW: in-repo Dockerfile (path relative to the project dir); when set,
+    /// `up` builds `eldrun-<id>:latest` from it instead of pulling `image`.
+    pub dockerfile: Option<String>,
+    pub pids_limit: Option<u32>,        // existing
+    pub memory: Option<String>,         // existing
+    pub cpus: Option<String>,           // existing
+    pub network: Option<String>,        // existing
+    pub readonly_rootfs: bool,          // existing
+    // compose / pre-existing-container variants: deferred (Phase 5).
+}
+```
 
----
+Behavior change to document for existing users: with the toggle on, plain
+shell tabs now also run in the container, and the container is shared and
+session-lived rather than per-tab ephemeral.
+
+## Module layout — evolve, don't add
+
+- `services/sandbox.rs` keeps its name and its public seam
+  (`wrap_pty_options_docker`, called from `commands/terminal.rs::pty_spawn`).
+  It gains the lifecycle half; split into `services/sandbox/{mod,lifecycle}.rs`
+  only if it outgrows one file.
+- **No** `docker_runtime.rs` / `docker_exec.rs` / `commands/docker.rs` from
+  the v1 plan. The `pty_spawn` dispatch keeps its current two-way shape
+  (sandbox else ssh, `commands/terminal.rs:116-136`) — no third rewriter, so
+  the "factor a target-agnostic spawn-rewrite layer first" prerequisite
+  (`todo/group-g.md`, #38 preamble) shrinks to a nice-to-have.
+- Lifecycle template is `services/remote.rs` (per-project connection opened on
+  activation, torn down on deactivate/exit), not `ssh_mount.rs`.
+
+## Phase 0 — fixes to the shipped sandbox (independently shippable)
+
+Bugs found in review that the lifecycle rewrite would touch anyway; land them
+first so they're testable in isolation:
+
+- **Preflight misdiagnosis** (`sandbox.rs:384-408`): `docker image inspect`
+  fails identically for "image missing" and "daemon down" (`docker --version`
+  succeeds daemon-less). Distinguish (check stderr or `docker info`) and say
+  "Docker isn't running" when it isn't.
+- **Spec-preserving toggle** (`commands/projects.rs::set_project_sandbox`):
+  re-enabling currently writes `SandboxSpec::default()`, wiping hand-tuned
+  `image`/`memory`/`network`/… . Flip `enabled` only; keep the rest.
+- **`--init` + labels** on every container we start (ephemeral ones too):
+  `--init` so PID 1 reaps zombies; `--label eldrun.owner=eldrun
+  --label eldrun.project=<id>` so anything we started is enumerable.
+- **Windows UI gate**: hide/disable the toggle on Windows (backend already
+  refuses per #86; the pill menu currently still offers it,
+  `ProjectPill.tsx` Runtime group).
+
+## Phase 1 — container lifecycle (the genuinely new code)
+
+`services/sandbox.rs` gains, all argv-building pure and unit-testable:
+
+- `container_name_for(project_id) -> String` — `eldrun-<sanitized-id>`.
+- `spec_fingerprint(spec, image) -> String` — stable hash of everything baked
+  into `create` (image, mounts, hardening). Stored as a label
+  (`eldrun.spec=<hash>`) so `up` can detect a stale container.
+- `up(project_id, spec, project_dir) -> Result<String, String>` — idempotent
+  three-state machine, returns the container name:
+  - **running + fingerprint matches** → no-op;
+  - **exists but stopped or fingerprint mismatch** → `rm -f`, then create
+    (fresh mounts/spec; also covers crash leftovers);
+  - **missing** → create:
+    `docker run -d --name <name> --init <labels> <hardening flags>
+     --user <uid>:<gid> -e HOME=<home> -w <project_dir>
+     -v <project_dir>:<project_dir> <auth/state mounts> <image>
+     sleep infinity`.
+  - `dockerfile` variant: `docker build -t eldrun-<id>:latest -f <df>
+    <project_dir>` first, then run that tag.
+- `down(project_id)` / `down_all()` — `docker rm -f` by name / by
+  `eldrun.owner` label. Idempotent, best-effort.
+- `sweep_orphans()` — at startup, `docker ps -aq --filter
+  label=eldrun.owner=eldrun` and remove everything (previous run's containers
+  are by definition stale). Also clears `<state_dir>/sandbox-stage/` (fixes
+  today's per-tab stage-dir leak; copies are recreated at `up`).
+
+Mount/identity code **reused from today's sandbox**, with two shifts:
+
+- `rw_mounts` / `ro_mounts` / hook shadowing move from per-tab spawn to the
+  `create` step (mounts are fixed at `docker run`). Staged config copies
+  (`staged_config_mounts`) become **per-project** —
+  `<state_dir>/sandbox-stage/<project-id>/` — refreshed from the host
+  originals at each `up`.
+- Agent-auth env (`host_auth_env`) moves to the **exec** step, not create, so
+  rotated tokens are picked up per tab spawn.
+
+## Phase 2 — spawn path: run → exec, and the tab-kill contract
+
+`wrap_pty_options_docker` becomes: resolve spec → `up()` → rewrite to
 
-## Data model (shared by both phases)
+```
+docker exec -i -t -w <opts.cwd> [-e K=V …] <name> <cmd> <args…>
+```
 
-A project is "containerized" iff `docker` is present on `Project`.
+(per-tab env: `opts.env`, `TERM`/`COLORTERM`, auth env, `ELDRUN_TAB_UID`).
+Session resolution still runs first in `pty_spawn`, unchanged — resume args
+ride into the exec argv exactly as they ride into `docker run` today.
 
-`schema/project.rs` — new struct + field on `Project`:
+**Tab-kill contract (required, not optional).** Killing the PTY child kills
+the `docker exec` *client*; Docker does not kill the exec'd process when its
+client dies, so a closed tab would leave the agent running inside the
+container until session end. Wrap the command so Eldrun can kill it:
 
-```rust
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DockerSpec {
-    /// How the container is provided. Exactly one of the variants below is
-    /// "active"; the others are None.
-    /// 1) Existing image to `docker run` from.
-    pub image: Option<String>,
-    /// 2) In-repo Dockerfile (path relative to the project dir) to build.
-    pub dockerfile: Option<String>,
-    /// 3) In-repo compose file (path relative to the project dir); `service`
-    ///    names which compose service the tabs exec into.
-    pub compose_file: Option<String>,
-    pub service: Option<String>,
-    /// 4) Pre-existing container to `docker exec` into (no lifecycle managed).
-    pub container: Option<String>,
-
-    /// Absolute path *inside the container* where the project dir is mounted.
-    /// Defaults to "/workspace" when None.
-    pub workdir: Option<String>,
-    /// Extra `docker run` args (e.g. published ports, --gpus). Validated like
-    /// every other argv item (no leading '-' surprises beyond what we add).
-    #[serde(default)]
-    pub run_args: Vec<String>,
-    /// "docker" (default) or "podman".
-    pub engine: Option<String>,
-
-    /// Phase 2 only: when set, the engine runs on this SSH host. The container
-    /// lives remotely; bind-mount source is the remote project path.
-    pub remote: Option<RemoteSpec>,
-
-    #[serde(flatten)]
-    pub extra: HashMap<String, Value>,
-}
 ```
-
-`Project` gains
-`#[serde(skip_serializing_if = "Option::is_none")] pub docker: Option<DockerSpec>`.
-`ProjectEntry` carries `docker` inside the existing `extra` map (same as
-`remote`), so the pill list / `resolveProjectDirectory` need no structural
-change. `types/index.ts` mirrors `DockerSpec` and adds `docker?` to
-`ProjectEntry`.
-
-**`directory` stays the host project path** in Phase 1 (no mountpoint
-indirection). The container's view of that path is `workdir` (default
-`/workspace`), bind-mounted `-v <directory>:<workdir>`.
-
----
-
-## Phase 1 — Local Docker
-
-A container on the same host as Eldrun. The project's host directory is
-bind-mounted in; terminal/agent tabs exec into the container; file tree and git
-run on the host as today.
-
-### Container lifecycle — `services/docker_runtime.rs` (new)
-
-Mirror `ssh_mount.rs`'s shape: a lifecycle service keyed by project id, with a
-single source of truth for validation/argv helpers, idempotent up/down, and
-best-effort teardown on exit.
-
-- **Container name convention:** `eldrun-<project-id>`. `container_name_for(id)`
-  is the analogue of `mountpoint_for(id)`. (For the "pre-existing container"
-  variant we use `DockerSpec.container` verbatim and manage no lifecycle.)
-- **`engine_available(engine) -> bool`** — `which docker`/`which podman` (cf.
-  `sshfs_available`). Missing engine ⇒ clear, actionable error
-  ("docker not found — install Docker or Podman to use container projects").
-- **`is_running(name) -> bool`** — `docker ps --filter name=^/<name>$ --format '{{.Names}}'`
-  exact match (analogue of `is_mounted`).
-- **`up(spec, project_id, host_dir) -> Result<String, String>`** — ensure the
-  container exists and is running; return its name/id. No-op if already running.
-  Build strategy by variant:
-  - `image`: `docker run -d --name <name> -v <host_dir>:<workdir> -w <workdir>
-    <run_args…> <image> sleep infinity` (long-lived; tabs `exec` into it).
-  - `dockerfile`: `docker build -t eldrun-<id>:latest -f <dockerfile> <host_dir>`
-    then run as above.
-  - `compose_file`: `docker compose -f <file> up -d`; tabs target `<service>`
-    via `docker compose exec` (or resolve the service container id and `exec`).
-  - `container`: assume managed externally; only verify it is running.
-- **`down(spec, project_id)`** — `docker stop`/`docker rm` for managed
-  containers (image/dockerfile), `docker compose down` for compose; **no-op for
-  the pre-existing `container` variant** (we did not create it). Idempotent.
-- **`down_all()`** — analogue of `unmount_all`: enumerate running
-  `eldrun-*` containers (and tracked compose projects) and stop them. Called at
-  app exit.
-
-All argv built as `Vec<String>` (unit-testable without a daemon), every value
-passed as a separate argv item, `validate_arg` reused from the shared helper to
-reject leading-`-` / control chars.
-
-### Spawn rewrite — `services/docker_exec.rs` (new)
-
-Mirror `ssh_exec.rs`. A tab whose project is containerized has its `PtyOptions`
-rewritten to run inside the container:
-
-- **Detection:** the project for `opts.cwd` has a `DockerSpec`. Reuse the same
-  `project_id_from_cwd` style resolution; for local docker the cwd is under the
-  normal host project dir, so resolution is by project-dir prefix rather than
-  the mounts root.
-- **`container_workdir(spec, host_dir, local_cwd)`** — translate the host cwd to
-  the in-container path: strip `host_dir` prefix, join onto `workdir`. Analogue
-  of `remote_subdir`.
-- **`docker_pty_args(spec, name, in_cwd, cmd, args, env)`** — build:
-  `docker exec -it -w <in_cwd> [-e K=V…] <name> <cmd> <args…>`, or
-  `docker exec -it -w <in_cwd> <name> "${SHELL:-/bin/bash}" -l` when `cmd` is
-  empty. Compose variant uses `docker compose -f <file> exec <service> …`.
-- **`wrap_pty_options(opts)`** — if the project is containerized and not
-  `local_only`, rewrite `opts.cmd`/`opts.args` to the `docker exec` invocation
-  and set `opts.cwd` to a stable host dir (the docker client runs on the host).
-  Honor the existing **`local_only`** flag verbatim — locally-bound tabs (e.g.
-  Ollama `local_agent` tabs) must never be pushed into the container.
-- This must compose cleanly with `ssh_exec::wrap_pty_options`: for Phase 1 the
-  two are mutually exclusive (a project is either remote-via-ssh or
-  local-docker). The call site applies docker-wrap for docker projects, ssh-wrap
-  for remote projects.
-
-### Wiring (Phase 1)
-
-- `services/project_runtime.rs::switch` — best-effort `docker_runtime::up(...)`
-  when switching to a docker project (mirrors the best-effort remote mount).
-  Non-panicking; a daemon-down/host-offline does not block the switch.
-- `commands/projects.rs` — `CreateProjectRequest`/`ImportProjectRequest` gain an
-  optional `docker` field; persist it in `project.json` and the `projects.json`
-  entry `extra`. Scaffolding still happens on the **host** dir (unchanged).
-- `lib.rs` — register the new docker commands; in the `RunEvent::Exit` closure
-  call `docker_runtime::down_all()` alongside `unmount_all()`.
-- `commands/docker.rs` (new):
-  - `docker_available(engine) -> Result<(), String>`
-  - `docker_list_images() -> Result<Vec<String>, String>` (for the dialog
-    picker: `docker images --format '{{.Repository}}:{{.Tag}}'`)
-  - `ensure_project_container(project_id) -> Result<String, String>` (up if
-    needed, return name; called before terminal spawn — analogue of
-    `ensure_project_mounted`).
-
-### Frontend (Phase 1)
-
-`ProjectSwitcher.tsx` project dialog: a **"Run in container"** section (collapsed by
-default). When enabled, the user picks the container source:
-
-- **Image** (text field + optional `docker_list_images` dropdown),
-- **Dockerfile** (path within the project),
-- **Compose** (compose file path + service name),
-- **Existing container** (name/id).
-
-Plus optional advanced fields: workdir (default `/workspace`), extra run args,
-engine (docker/podman). Submit passes `docker: {...}` to create/import.
-`stores/projects.ts::load()` best-effort calls `ensure_project_container` for the
-initially-active docker project (startup, non-blocking), mirroring the remote
-case.
-
-### Tests (Phase 1)
-
-`cargo test` (no daemon required — assert on built argv and parsing):
-- `container_name_for` derivation.
-- `docker_pty_args` shape per variant (image/compose), `-w`, `-e`, fallback
-  shell, leading-`-`/control-char rejection.
-- `container_workdir` prefix translation (incl. cwd == project root, cwd outside
-  project → fallback to workdir).
-- `run`/`build` argv construction for each variant.
-- schema round-trip (docker present/absent), request deserialization.
-- `local_only` short-circuits `wrap_pty_options`.
-
-`npx tsc --noEmit` for the dialog. Runtime QA by the user (agents must not launch
-Eldrun): create image-based + compose-based projects, open a terminal, confirm
-it runs inside the container, edits on the host show in the file tree, git works,
-container is cleaned up on exit.
-
----
-
-## Phase 2 — Remote Docker
-
-A container running on an **SSH host** (the work-remote axis), composing Phase 1
-with the existing SSH feature. Activated when `DockerSpec.remote` is set.
-
-### How it composes
-
-The two axes stack: the bytes live remotely (SSH), and the runtime is a
-container on that remote host.
-
-- **Bytes:** as today for remote projects — sshfs-mount the remote project dir
-  locally so the file tree/git/`list_dir` keep working against the mount
-  (`ssh_mount.rs`, unchanged). `directory` = the local mountpoint.
-- **Container bind-mount source:** the **remote** project path
-  (`remote.remote_path`), *not* the local mountpoint — the remote docker daemon
-  bind-mounts the remote bytes directly. So host edits → sshfs → remote file →
-  container all see the same bytes.
-- **Runtime:** terminal/agent spawns run `ssh -tt <host> docker exec …`. This is
-  literally `ssh_exec`'s remote-command wrapping with `docker exec …` as the
-  remote command. Implementation = compose the two existing wrappers rather than
-  duplicate either:
-  1. `docker_exec` builds the `docker exec -w <in_cwd> … <cmd>` argv as a string.
-  2. `ssh_exec::remote_command`/`ssh_pty_args` wrap that to run over `ssh -tt`.
-
-### Work in Phase 2
-
-- `docker_runtime` gains a `remote: Option<&RemoteSpec>` path: each engine call
-  (`run`/`build`/`ps`/`stop`/compose) is prefixed with the SSH base argv
-  (`ssh_base_args`) when remote, so it executes on the remote host. The argv
-  builders stay unit-testable (assert the `ssh … docker …` shape).
-- `docker_exec::wrap_pty_options` detects `remote` and routes through
-  `ssh_exec`'s remote wrapping instead of a bare local `docker exec`.
-- `down_all()` must also tear down remote containers for known remote-docker
-  projects (enumerate from the project list, not just local `docker ps`).
-- Frontend: in the dialog, "Run in container" becomes available **after** an SSH
-  connection is established (the remote-browse flow from Phase 1 of SSH); the
-  container source fields then describe the remote container.
-
-### Tests (Phase 2)
-
-- `docker_runtime` argv builders produce `ssh <base> -- docker …` when remote.
-- `docker_exec` remote path produces `ssh -tt … cd … && exec docker exec …`.
-- Round-trip of a `DockerSpec` with `remote` present.
-- Runtime QA: remote host with docker; create a remote-docker project; terminal
-  execs into the remote container; host file tree (over sshfs) reflects edits.
-
----
-
-## Open questions to resolve when picking this up
-
-- **Compose multi-service:** v1 targets a single named `service`; multi-service
-  topologies (db + app) are started by `compose up` but tabs only exec into the
-  one `service`. Good enough for v1?
-- **Long-lived vs ephemeral:** plan keeps a long-lived container
-  (`sleep infinity` + `exec`) so tab restarts are instant and state persists
-  across switches. Alternative (`docker run` per tab) is simpler but loses
-  in-container state — rejected for v1.
-- **Engine default:** auto-detect docker, fall back to podman, or require the
-  user to choose? Plan: default docker, allow `engine: "podman"` override.
-- **Rootless/permissions:** bind-mounted file ownership (uid mapping) can bite
-  with rootful docker. Document the `--user $(id -u):$(id -g)` escape hatch via
-  `run_args`; do not auto-inject in v1.
+docker exec … <name> sh -c 'echo $$ > /tmp/eldrun-tab-$ELDRUN_TAB_UID.pid; exec "$@"' sh <cmd> <args…>
 ```
+
+and on tab close (PtyRegistry kill path, containerized tabs only) run
+`docker exec <name> sh -c 'kill -TERM -- -$(cat /tmp/eldrun-tab-<uid>.pid)'`
+best-effort. (`/tmp` is in-container, ephemeral with it.) The same signal gap
+exists for today's per-tab sandbox (`--rm` relies on the *container* exiting,
+and TTY-mode docker doesn't proxy signals) — the session-scoped `down()` +
+startup sweep is what finally bounds it.
+
+## Phase 3 — wiring + frontend scope change
+
+- `services/project_runtime.rs::switch` — best-effort `up()` when activating
+  a toggled project, `down()` for the project being left. Runs on the
+  existing worker thread (never the main thread — cf. the remote sync-command
+  freeze lesson). Spawn-path `up()` remains the fallback for tabs opened
+  before activation completes.
+- `lib.rs` `RunEvent::Exit` — `down_all()`; startup — `sweep_orphans()`.
+- `CenterPanel.tsx` — the per-tab flag changes gate from
+  `tab.kind === "agent"` to *any* non-`local_only` tab of a toggled,
+  non-remote project. Prop/field can keep the name `sandbox`.
+- `ProjectPill.tsx` — label becomes "Run this project in a container";
+  keep it hidden for remote projects (and on Windows, Phase 0).
+- **Respawn caveat**: the flag is in `TerminalView`'s spawn-effect deps, so
+  flipping the toggle respawns every live tab. Claude/Codex resume; Gemini/
+  Vibe would lose their conversation — confirm before flipping when such tabs
+  are live (same hazard class `tabs/agentModes.ts` exists for).
+
+## Phase 4 — spec sources & UX
+
+- Auto-detect an in-repo `Dockerfile` / `.devcontainer/devcontainer.json`
+  (image field only) as the container source when the toggle is first
+  enabled; else default image (`eldrun-agent-sandbox:latest` — the existing
+  reference image already fits: agent CLIs, no ENTRYPOINT).
+- Preflight "image missing" failure offers the one-click
+  **open-new-tab-paste-run** build flow (house convention — never a
+  copy-it-yourself message), building from `docker/agent-sandbox` when
+  present in-repo or from an embedded copy of the reference Dockerfile
+  otherwise (an installed app has no repo checkout).
+- Minimal spec UI (project context menu or dialog section): image override,
+  network (`none`/custom), memory/cpus, read-only rootfs — the knobs exist in
+  `SandboxSpec` today but are hand-edit-only, and Phase 0's spec-preserving
+  toggle is what makes exposing them safe.
+
+## Phase 5 — deferred
+
+- **Compose / pre-existing container** variants (exec into a named service /
+  an externally managed container; no lifecycle owned).
+- **Persistent containers** (opt-in: skip `down()` on deactivate; needs a
+  "recreate container" action for spec changes).
+- **Remote Docker** (container on an SSH host): compose the exec argv with
+  `ssh_exec`'s wrapping (`ssh -tt <host> docker exec …`); bind-mount source
+  is the remote path. Only at this point does the target-agnostic
+  spawn-rewrite refactor (`todo/group-g.md` #38 preamble) become load-bearing.
+- **Windows** (#86): path mapping into a Linux container + `--user` story;
+  needs a Docker Desktop box; stays refused until then.
+
+## Security notes (carried + new)
+
+- Keep all of today's hardening at create: `--security-opt
+  no-new-privileges`, `--cap-drop ALL`, `--pids-limit`, socket never mounted,
+  hooks dir ro, settings shadow-copied.
+- Known residual (pre-existing): the rw `~/.claude` mount lets a compromised
+  agent persist host-loaded content (`commands/`, `skills/`, `plugins/`,
+  `CLAUDE.md`) even though hook registration is shadowed. Consider ro-mounting
+  those subpaths at create; decide before, not after, shells share the
+  container.
+- Default bridge network reaches host-bound services via the gateway IP
+  (Ollama, dev servers). Document next to the `network` knob; "closed" users
+  set `network: none` (breaks cloud agents) or a custom allowlist network.
+- Verify live (Done ≠ Tested): container `$HOME` itself is a root-owned
+  auto-created dir — check `~/.claude.json` / `~/.gitconfig` writes from
+  inside; if broken, add them to the staged/ro mounts.
+
+## Tests
+
+`cargo test` (no daemon — pure argv/state assertions):
+
+- `container_name_for` / label / `spec_fingerprint` derivation + stability.
+- `up` decision table (running-match / stopped / mismatch / missing) with
+  injected probe results.
+- Create argv: identical-path mount, `--init`, labels, hardening flags,
+  per-project staged mounts; exec argv: `-w`, per-tab/auth env, kill-wrapper
+  shape, resume args preserved in order.
+- Per-project stage dir: refresh-at-up, single copy per file.
+- `SandboxSpec` round-trip with `dockerfile`; legacy specs (no new fields)
+  parse unchanged.
+- Toggle preserves spec fields (Phase 0).
+- `local_only` and remote projects bypass wrapping (existing tests keep
+  passing).
+
+`npx tsc --noEmit` for the frontend gate change. Runtime QA is the user's
+(agents must not launch Eldrun): toggle on → shell tab runs in-container
+(hostname differs), agent resumes across toggle flips, host edits show in the
+file tree, tab close kills the in-container process, project switch and app
+exit remove the container, `docker ps -a` clean after relaunch.
+
+## Open questions — resolved at implementation
+
+- Confirm-before-respawn UX: a **native confirm dialog** (plugin-dialog
+  `confirm`, warning kind) listing the doomed non-resumable agent tabs by
+  command, shown on both flip directions; cancel aborts the flip.
+- `down()` on deactivate is **immediate, but guarded on liveness**: it is
+  skipped while any PTY of the leaving project is still alive
+  (`PtyRegistry::any_live_for_scope`) — a background agent keeps its container
+  until its tabs end or the app exits. That guard, not a debounce, is what
+  keeps rapid switching from churning a container someone is still inside;
+  an *idle* project's container is torn down at once (cheap to recreate, and
+  `up()` at activation warms it again).
+- Podman: **deferred until someone asks** (no `engine` field; nothing in the
+  implementation would resist adding one).
diff --git a/docs/git_lockstep_case_matrix.md b/docs/git_lockstep_case_matrix.md
new file mode 100644
index 0000000..caf6c07
--- /dev/null
+++ b/docs/git_lockstep_case_matrix.md
@@ -0,0 +1,120 @@
+# Git Lockstep Case Matrix (#28p)
+
+Snapshot of `services::git_peer` + `services::sync_auto` behaviour as of
+2026-07-13 (post D1–D8, `docs/git_lockstep_hardening_plan.md`). Source of truth
+is the code; re-scan before trusting this against a later commit.
+
+> **All 28 cases have now been run against a real SSH host** —
+> `docs/git_lockstep_live_qa.md`, driven by `src-tauri/examples/lockstep_drv.rs`.
+> Four did **not** behave as this document claimed (cases 15, 17, 26, and the
+> error-swallowing behind them) and were fixed; the table below describes the
+> fixed behaviour. Every one of the four had the same shape — a no-op or failure
+> in the transport computing to `Synchronized` — and none was reachable by the
+> unit tests, which cover the pure decision functions the bugs prevented from
+> ever being called.
+
+## Axes
+
+**BS** = byte-sync auto on for the path · **LS** = git lockstep on. Both default
+off. Governing invariant (`src-tauri/CLAUDE.md`,
+`sync_auto::drop_tracked`): **lockstep owns the git-tracked tree, byte-sync owns
+everything else.** "Tracked" = `git ls-files` in the mirror, i.e. the **index** —
+a brand-new file is not tracked until `git add`.
+
+## Creates and edits, before any commit
+
+| # | Scenario | Config | Current behaviour | Status |
+|---|---|---|---|---|
+| 1 | Local create (untracked) | – | nothing; mirror-only | |
+| 2 | Local create (untracked) | BS | pushed to host as an **untracked** file | |
+| 3 | Local create (untracked) | BS+LS | still pushed — not in the index yet, so `drop_tracked` doesn't cover it | |
+| 4 | Local edit of a **tracked** file | BS | pushed; host sees it live | |
+| 5 | Local edit of a **tracked** file | BS+LS | **not pushed** — `drop_tracked` removes it; crosses only on commit | ⚠️ intended, undocumented in CLAUDE.md |
+| 6 | Host create/edit, untracked | BS | pulled into mirror | |
+| 7 | Host edit of a tracked file | BS+LS | not pulled — symmetric to #5 | ⚠️ intended, undocumented |
+| 8 | `git add` (index write) | LS | `.git` watcher → dirty bit flips → signature changes → one full pass, bundle range empty → no transfer | |
+| 9 | `.git` touched, refs+dirty unchanged (e.g. stat-cache write) | LS | `can_early_out` → cached status re-emitted; skips the **bundle/transfer** round trip, not the probe (live: ~280 ms vs ~630 ms for a full pass) | ✅ fixed (D5) |
+
+## Commits
+
+| # | Scenario | Config | Current behaviour | Status |
+|---|---|---|---|---|
+| 10 | Local commit, nothing byte-pushed first | LS | bundle → SFTP → fetch to `refs/eldrun/incoming/*` → `merge --ff-only` writes files on host → restamp → green | |
+| 11 | Local commit, byte-sync already pushed an **identical** copy | BS+LS | ff refused → `retry_ff_clearing_identical` proves identity on the dest (`hash-object` vs `rev-parse <sha>:<path>`), removes it with `git clean -f -x -- :(literal)<path>`, retries → green | ✅ fixed (D1) |
+| 12 | Local commit, byte-pushed copy **differs** from the committed content | BS+LS | `stale_byte_sync_residue` proves the differing peer copy is byte-sync's own untouched prior push (manifest base still matches the peer's current stat) → cleared and the ff retried; a genuine independent edit still blocks | ✅ fixed |
+| 13 | Local commit | BS only | commit stays local; bytes cross, history doesn't | |
+| 14 | Host commit (host CLI, or the Git panel — runs git *on the host*) | LS | 12 s poll → mirror ff → same three sub-cases mirrored | |
+| 15 | Both sides commit on `main` | LS | `Diverged` → never auto-applied → desync bar shows both heads as `sha · subject`, offers Use local / Use remote, parks peer tip at `refs/eldrun/peer/<branch>` for terminal resolution | ✅ fixed (live QA) — **reported green** until then: the thin-bundle excludes name the peer's tip, which in a divergence is a commit the source has never seen, so `bundle create` aborted and both transfer legs no-op'd |
+
+## Checkouts
+
+| # | Scenario | Config | Current behaviour |
+|---|---|---|---|
+| 16 | Checkout a branch locally | LS | pause byte-sync → reconcile → guarded `checkout` on host (never `-f`) → `restamp_after_checkout` → **re-probe** (`refresh_heads`) → resume |
+| 17 | Checkout on the host | LS | same, via 12 s poll. ✅ fixed (live QA) — the mirror **never followed**: a checkout persisted the peer head it observed *before* moving it, and the next pass compares a fresh probe against exactly that stored value, so the stale one masked the peer's next move permanently |
+| 18 | New branch + commit locally | LS | `CreateOnDest` → `update-ref` → host checks it out too |
+| 19 | Peer has dirty **tracked** changes | LS | peer checkout fails → desync carries git's actual stderr (✅ fixed, D2 — was a canned lie) |
+| 20 | FF a branch not checked out on the peer | LS | plain `update-ref`, no worktree write |
+| 21 | Detached HEAD | LS | peer `checkout <sha>` → both detached |
+| 21b | Refs all match but the two HEADs point somewhere different | LS | `Desynchronized: Out of step: the mirror is on 'x', the host is on 'y'` (`head_mismatch`). Reports rather than auto-checking-out — with no observed move there is no principled way to say which side follows. ✅ added (live QA): `reconcile_with` compares only **refs**, so a half-landed checkout (#19, then Retry) was green by construction |
+
+## Initial pairing (exactly one side is a repo)
+
+| # | Scenario | Current behaviour | Status |
+|---|---|---|---|
+| 22 | Dest empty, or holds only **identical** files | `git init` + full bundle + `reset --hard` → seed manifest green → propagate source's `origin` URL | ✅ improved (D7) |
+| 23 | Dest holds files that **differ** from what pairing would write | Refused. `pairing_conflicts` (`ls-tree -r -l -z HEAD` + hashing) names up to 3 files + "(+N more)"; override requires explicit `git_peer_pair_confirm` | ✅ fixed (D3) — was a silent `reset --hard` clobber |
+| 24 | Dest's probe **errored** (either side) | Refused: "…could not be read; refusing to auto-initialize it" | ✅ fixed (D3.4) — guard used to protect only the local side |
+
+## Connectivity, backups, deletions
+
+| # | Scenario | Current behaviour | Status |
+|---|---|---|---|
+| 25 | Pool cold / disconnected | `SyncStatus::Disconnected`, "Not connected to the remote host". No probes, pairing, or writes; early-out signatures cleared | ✅ fixed (D4) — used to report green |
+| 26 | Any resolve or pairing overwrite | Tip saved to `refs/eldrun/backup/<ts>/<branch>` — listable (`git_peer_backups`), restorable (`git_peer_restore_backup`, backs up current tip first), pruned | ✅ fixed (D6) — was write-only |
+| 26b | A resolve/FF where the dest **already has the objects** (they arrived via another branch, or via the peer-tip ref) | The refs still move. ✅ fixed (live QA) — git reports "nothing to bundle" by *refusing to create an empty bundle*, and that was treated as a no-op **transfer** *and* a no-op **apply**: `resolve` transferred nothing, moved nothing, and re-reported the divergence it was asked to end |
+| 27 | Committed deletion | rides the fast-forward; git removes it on the peer | |
+| 28 | Uncommitted deletion | not propagated (deliberate v1 byte-sync policy) | |
+
+## Resolved items
+
+**#12 — stale byte-synced copy blocking a commit.** `retry_ff_clearing_identical`
+was all-or-nothing: one differing file and nothing was deleted. Reachable sequence:
+create `f` (v1) → byte-sync pushes v1 untracked → edit to v2 → `git add` + commit.
+The commit makes `f` tracked, so `drop_tracked` stops byte-sync from ever pushing
+v2 — the host was left with untracked v1, which differs from committed v2, and the
+fast-forward blocked.
+
+Fixed by `stale_byte_sync_residue` (`services/git_peer.rs`): for a colliding path
+that fails the byte-identical check, look up the sync manifest's recorded base for
+it (the size+mtime `divergence`/`push_decision` already trust elsewhere) and compare
+against the peer's *current* stat. An exact match proves the peer's content is fully
+explained by byte-sync's own prior push — nothing has touched it since — so it is
+disposable regardless of differing from the incoming commit; a genuine post-push
+edit on that peer changes the stat and is never treated as safe. Cleared paths have
+their manifest base dropped (`forget_synced_paths`) since lockstep now owns them.
+
+**#5/#7 — tracked-file sync model change was undocumented.** Enabling lockstep
+silently converts tracked files from *continuous byte mirror* to *commit-gated*:
+saving a tracked file no longer reaches the peer until committed. Intended (it's
+what makes #11 and #16–19 safe); now recorded in `src-tauri/CLAUDE.md` next to the
+sync/lockstep invariant.
+
+## Live QA — done
+
+All 28 cases have been run against a real SSH host; see
+**`docs/git_lockstep_live_qa.md`** for the full log, the four bugs it found, and the
+fixes. Re-run it with `src-tauri/examples/lockstep_drv.rs`:
+
+```bash
+ELDRUN_PROJECT=<project-id> cargo run --example lockstep_drv -- <script>
+```
+
+The driver calls the same service entry points the Tauri commands call, so a case
+exercised through it exercises the code that ships. It needs a live host and mutates
+both trees — point it at a scratch project, never at CI.
+
+Still uncovered: the engines' **timing** (the `.git` watcher, the 12 s poll, the 25 s
+byte-sync interval — the driver invokes the passes those timers invoke, but does not
+prove the timers fire), **tags**, and the **UI layer** (desync bar, pairing-conflict
+dialog, the Use local / Use remote / Restore buttons).
diff --git a/docs/git_lockstep_hardening_plan.md b/docs/git_lockstep_hardening_plan.md
new file mode 100644
index 0000000..5818934
--- /dev/null
+++ b/docs/git_lockstep_hardening_plan.md
@@ -0,0 +1,534 @@
+# Git Lockstep Hardening Plan (#28p)
+
+> **Status: implemented 2026-07-13 — all eight defects (D1–D8) fixed**, plus three
+> more (**D9–D11**) found in a follow-up data-loss-focused audit and fixed the same
+> day. The design below is what shipped; deviations are noted inline as **[shipped]**.
+> What is still owed is the **live-host QA** at the end of this document: D1, D3, and
+> now D9/D11 are precisely the cases a unit test cannot fully prove, and the 🖐️ box on
+> #28n was never ticked either. Until that runs, treat this as *code-complete, not
+> verified*.
+
+Follow-up to **#28n Phases 1–3** (`services/git_peer.rs`, `commands/git_peer.rs`).
+Lockstep is code-complete and unit-tested but has never run against a live host.
+Tracing the full local↔remote case matrix surfaced eight defects — two of them
+data-loss or correctness class. This plan fixes all eight, in dependency order.
+D9–D11 were surfaced later, once #28p D1–D8 already shipped, by re-reading the same
+code specifically for remaining data-loss vectors — see each section below.
+
+## Background: the invariant that generates the bugs
+
+A remote project has **two real git repos** (the local mirror,
+`remote_sync::mirror_dir`, and the host tree at `spec.remote_path`) joined by
+**two transports that are blind to each other**:
+
+| Transport | Moves | Sees |
+|---|---|---|
+| **Byte-sync** (`remote_sync` + `sync_auto`) | file *contents* over SFTP | everything except `.git`/`.eldrun` (`remote_sync.rs:388`, `:741`) |
+| **Git lockstep** (`git_peer`) | *commits + refs* via `git bundle` over SFTP | only committed objects — untracked/uncommitted files are invisible |
+
+Neither knows what the other owns. Every genuinely broken case below is these two
+racing for the same file, or a probe failure being read as "the other side is
+empty".
+
+Two git behaviours, **verified experimentally** rather than assumed, decide most
+outcomes:
+
+1. `git merge --ff-only <sha>` **refuses** to overwrite an untracked working-tree
+   file — *even when its content is byte-identical* to the incoming blob.
+2. `git reset --hard <sha>` **silently clobbers** that same colliding untracked
+   file.
+
+That asymmetry is both the bug (1) and the recovery path (2).
+
+---
+
+## D1 — Byte-sync and git race for the same file *(correctness; blocking)*
+
+**Problem.** `sync_auto::reconcile_pass` builds its candidate set from a raw
+host+mirror walk that excludes only `.git`/`.eldrun`. It has no notion of
+"git-tracked". So a file that lockstep is about to deliver as a *commit* may first
+be shipped by byte-sync as *loose bytes*, landing on the peer **untracked** — and
+then blocking the very fast-forward that would have delivered it properly
+(behaviour 1 above). Status goes `Desynchronized` and the commit never crosses.
+
+Which branch you land in is decided by a **debounce race**: auto-sync debounces
+1500 ms (`sync_auto.rs:DEBOUNCE`), lockstep 800 ms (`git_peer.rs:GIT_DEBOUNCE`).
+Commit within ~1.5 s of the last file write → clean fast-forward. Hesitate → wedged.
+Nondeterminism is the worst property this could have.
+
+Symmetric in both directions: local create → auto-push → local commit, and host
+create → auto-pull → host commit.
+
+**Fix (two layers — do both).**
+
+1. *Primary — remove the race by construction.* When lockstep is enabled for a
+   project, subtract the mirror's git-tracked set from the auto-sync candidate
+   list. Lockstep owns the tracked tree; byte-sync owns everything else.
+   - In `sync_auto::reconcile_pass`, after `candidates.retain(is_auto)`, drop any
+     path in the tracked set.
+   - Tracked set = `git ls-files -z` in the mirror (the exact call
+     `git_peer::seed_manifest_after_pairing` already makes, `git_peer.rs:948`) —
+     extract it into a shared `git_peer::tracked_paths(project_id) -> HashSet<String>`.
+   - Gate on `git_peer::load_state(project_id).enabled` so a lockstep-off project
+     keeps today's behaviour exactly.
+   - Cache the set per pass (one local `git` invocation, no SSH).
+
+2. *Safety net — recover the collisions that still happen* (files byte-synced
+   before lockstep was ever enabled; see D-note below). When `merge --ff-only`
+   fails in `transfer_and_apply` (`git_peer.rs:529`), parse the
+   `error: The following untracked working tree files would be overwritten by merge:`
+   list from stderr; for each listed path compare the incoming blob
+   (`git cat-file blob <sha>:<path>`) against the on-disk bytes; if **identical**,
+   delete the file and retry the merge once. If any differ, leave everything alone
+   and fall through to today's `dirty_blocked` path.
+   - Only ever deletes a file whose content is provably already in the incoming
+     commit — nothing recoverable is destroyed.
+
+**D-note.** Case #9 (lockstep *off*, byte-sync *on*) pre-seeds exactly this
+collision: both sides hold the content, only one holds the history. Enabling
+lockstep later walks straight into it. Layer 2 is what makes that first enable
+succeed instead of immediately going red.
+
+**[shipped]** Layer 1 is `git_peer::tracked_paths` + `sync_auto::drop_tracked` (a pure,
+tested filter, gated on `load_state(project_id).enabled`). Layer 2 is
+`git_peer::retry_ff_clearing_identical`: it parses the stderr, proves identity with
+`git hash-object` vs `git rev-parse <sha>:<path>` **on the dest** (so nothing is read
+over the wire), and is **all-or-nothing** — one differing file and nothing is deleted.
+Deletion uses `git clean -f -x -- :(literal)<path>` so a path with glob metacharacters
+can never widen into a pathspec that removes more than it names. Both behaviours are
+pinned against a real repo, not a mocked stderr.
+
+**Files.** `services/sync_auto.rs`, `services/git_peer.rs`.
+
+**Tests.**
+- Rust unit: `parse_untracked_overwrite_paths(stderr) -> Vec<String>` (pure).
+- Rust unit: `tracked_paths` excludes `.git`, splits NUL, normalizes separators.
+- Rust unit: candidate filtering drops tracked paths when lockstep is enabled and
+  keeps them when it is off.
+- Manual: create 10 files under an auto-sync-all root, wait >2 s (so byte-sync
+  pushes), commit → host fast-forwards cleanly, status stays green.
+
+~~**Until this ships:** never enable project-wide auto-sync-all together with
+lockstep.~~ **[shipped]** — the combination is now safe by construction, so the caveat
+is lifted and never needed to reach `CLAUDE.md`.
+
+---
+
+## D2 — The desync message lies *(clarity; trivial)*
+
+**Problem.** A blocked fast-forward always renders as *"A peer has uncommitted
+changes blocking a fast-forward"* (`git_peer.rs:851-855`), but the real cause is
+usually **untracked** collisions (D1). The merge's stderr — which says exactly
+what is wrong and names the files — is discarded at `git_peer.rs:529-533`. Users
+go hunting for uncommitted changes that do not exist.
+
+**Fix.** Widen `TransferResult.dirty_blocked: bool` to
+`blocked: Option<String>` carrying the trimmed stderr of the failed merge (and
+the branch name). Surface it in the `Desynchronized` detail. Keep the message
+short enough for the desync bar's single line; the full text goes in the
+`title=` tooltip, which `GitHistory.tsx:531` already renders.
+
+**[shipped]** As planned, minus the separate tooltip: `detail` carries the composed
+sentence (which *names the files*), so the bar text and the `title=` tooltip agree
+rather than diverging. `TransferResult.dirty_blocked: bool` → `blocked: Option<String>`.
+
+**Files.** `services/git_peer.rs`, `components/files/GitHistory.tsx` (no shape
+change — `detail` is already `Option<String>`).
+
+**Tests.** Rust unit on the detail string composed from a captured stderr sample.
+
+---
+
+## D3 — `init_pairing` can clobber host files *(data loss; blocking)*
+
+**Problem.** The extend-local flow runs `git init` + `reset --hard <source HEAD>`
+on the host (`git_peer.rs:726-751`). The pre-backup at `git_peer.rs:715-722` saves
+**refs** — but a not-yet-a-repo host *has no refs*, which is precisely why we are
+pairing. And `reset --hard` silently overwrites colliding **untracked** files
+(behaviour 2 above). So if `remote_path` points at a directory that already holds
+differing files, they are destroyed with no backup and no prompt.
+
+Note the asymmetry: the *local* side has an explicit `probe_error` guard against
+exactly this class of accident (`git_peer.rs:807-816`, "a transient local-git
+failure must never license a wipe"). The *remote* side — the one reached over a
+flaky network, i.e. the far more likely one to misprobe — has no equivalent.
+
+**Fix.**
+1. Before pairing into a non-repo dest, list the dest's existing files (the
+   `remote_sync` walkers already do this, `.git`-excluded). Compute the set that
+   **collides** with a path in the source's tracked tree **and differs in content**
+   (size first, then hash the small residue over SFTP).
+2. If that set is empty → pair as today (this is the intended
+   "file-sync already mirrored them, adopt them as the tracked tree" path).
+3. If non-empty → **refuse**. Return `Desynchronized` with a detail naming the
+   conflicting files, and require an explicit confirmation (reuse the existing
+   confirm-gated Use-local/Use-remote pattern in the desync bar rather than
+   inventing new UI).
+4. Independently, extend the `probe_error` refusal to be **symmetric**: refuse to
+   auto-initialize *either* side when its probe errored, not just the local one.
+
+**[shipped]** The check runs in `reconcile_with` *before* `init_pairing` (which keeps
+`init_pairing` focused on the happy path), via `pairing_conflicts` → the pure
+`pairing_collisions`. The dest's hashes come from `git hash-object`, which works
+**outside a repo** — that is what lets it run on the not-yet-`init`ed dest without
+reading file bytes over SFTP. Rather than overloading Use-local/Use-remote (meaningless
+when nothing is paired yet), the refusal surfaces a typed `pairingConflict` on the state
+and the bar offers exactly one action: `git_peer_pair_confirm`, behind a confirm that
+lists the files. Symmetric probe-error refusal: `pairing_dest_probe_error`.
+
+**Files.** `services/git_peer.rs` (`init_pairing`, `reconcile`),
+`components/files/GitHistory.tsx` (a third confirm action).
+
+**Tests.**
+- Rust unit: pairing-collision detection (pure, over two path→(size,hash) maps).
+- Rust unit: symmetric `probe_error` refusal truth table.
+- Manual: extend a local project onto a host dir that already contains a differing
+  `README.md` → refused with the filename named, host file untouched.
+
+---
+
+## D4 — Disconnected "Sync now" reports green *(correctness; small)*
+
+**Problem.** A dropped SSH connection surfaces as `Ok(nonzero exit)`, not a spawn
+error, so `probe` leaves `probe_error == false` (`git_peer.rs:341-344`, and its own
+comment says so). The host therefore reads as a *clean, legitimately empty side*.
+`reconcile` then takes the "exactly one side is a repo" branch and attempts
+`init_pairing` **into the host** — every remote git command fails, `init_pairing`
+returns `Err`, and the final status computes to **`Synchronized`** via the
+`!final_remote.is_repo` arm (`git_peer.rs:842-845`). Green pill, nothing done.
+
+Nothing is written (all the SSH commands fail), so this is not destructive — but
+the signal is actively wrong, and it is the same misread that would route a
+*connected-but-misprobing* host into a doomed pairing.
+
+**Fix.** Gate `reconcile` (and `detect_and_sync`) on connectivity up front:
+`crate::services::remote::pooled_sftp(pool, project_id).await.is_none()` →
+return a state carrying today's persisted heads with a new
+`status: Disconnected` (or `Desynchronized` + detail `"Not connected"`, if adding
+a variant is not worth the schema churn — decide at implementation time; the
+frontend pill already handles three states and would need a fourth colour).
+
+This subsumes half of D3's risk: no pool, no pairing.
+
+**[shipped]** Took the `SyncStatus::Disconnected` variant (the fourth pill colour) over
+the `Desynchronized` + detail hack — a disconnected project is not desynchronized, and
+conflating them would have offered destructive resolve actions against a host nobody can
+see. The gate (`connected()`) is applied to **every** entry point that writes or claims:
+`reconcile`, `detect_and_sync`, `checkout_lockstep`, `resolve`, `restore_backup`.
+
+**Files.** `services/git_peer.rs`, `commands/git_peer.rs`,
+`components/files/GitHistory.tsx` (pill state), `src/__tests__/GitLockstep.test.tsx`.
+
+**Tests.** Frontend: pill renders the disconnected state and Sync-now is disabled.
+Rust: `reconcile` early-returns without touching either peer when the pool is cold.
+
+---
+
+## D5 — SSH chattiness *(performance)*
+
+**Problem.** Every reconcile pass costs, over the network:
+- `probe(remote)` = **6** separate `run_git_remote` round trips (`rev-parse
+  --is-inside-work-tree`, `symbolic-ref`, `rev-parse HEAD`, `for-each-ref` ×2,
+  `status --porcelain`), each its own SSH exec;
+- `is_ancestor` = **2 more per branch, per direction** (`git_peer.rs:501-502`),
+  run on the *dest* peer;
+- and `reconcile` runs **both** directions.
+
+A 20-branch repo is ≈80 SSH round trips **every 12 s** (`GIT_POLL_INTERVAL`), plus
+a full pass on **every `git add`** — case #4: the index write trips the `.git`
+watcher, `detect_and_sync` runs, HEAD hasn't moved, and the bundle create errors on
+an empty range for nothing. On a high-latency link this will feel broken.
+
+**Fix.**
+1. **Batch the probe** into a single `run_git_remote` of one `sh -c` script emitting
+   a delimited block (`\x1e`-separated sections), parsed by a new pure
+   `parse_probe_block(stdout) -> PeerSnapshot`. 6 round trips → 1.
+2. **Batch ancestry.** After the bundle fetch the dest holds every object, so all
+   `merge-base --is-ancestor` checks can run in one scripted invocation emitting
+   `<branch> <fwd> <back>` per line → one round trip per direction instead of 2·N.
+3. **Early-out.** Persist the last-seen ref *sets* (not just HEAD) in
+   `GitPeerState`; if neither side's refs moved since the previous pass, skip the
+   bundle/transfer entirely and re-emit the cached status. This alone kills the
+   `git add` storm.
+
+Keep the existing per-command `Peer::run` path as the fallback when the batched
+script fails (a host without a POSIX `sh` — Windows hosts are out of scope for
+remote projects today, but do not hard-depend on it).
+
+**[shipped]** All three parts. The helper was needed: `ssh_exec::run_remote_script`
+(`cd <quoted path> && { <script> }`), documented as embedding its script *verbatim* —
+so callers must pass a constant (`PROBE_SCRIPT`) or interpolate only values proven inert
+(`ancestry_script` takes hex object names only, guarded by `is_hex_sha`). The early-out
+is narrower than "refs didn't move": it fires **only when the last pass was green**, so a
+manual Retry after the user clears a blocker that moved no ref (deleting an untracked
+collision) is never answered from cache; `ReconcileOpts::forced` bypasses it outright.
+The ref signature includes `dirty_tracked`, since a dirty→clean transition can unblock a
+fast-forward and must not be invisible. Both scripts are tested through a real `sh` and
+asserted to agree with the per-command path — a syntax error would otherwise make the
+batching fall back silently, leaving D5 "done" and doing nothing.
+
+**Files.** `services/git_peer.rs`, `services/ssh_exec.rs` (`run_remote_script`).
+
+**Tests.** Rust unit: `parse_probe_block` round-trips a synthesized block, tolerates
+missing sections (unborn HEAD, no tags); early-out predicate truth table.
+
+---
+
+## D6 — Backup refs are write-only *(ops)*
+
+**Problem.** `refs/eldrun/backup/<ts>/*` accrues on every `resolve` and every
+`init_pairing`, pinning objects forever (the repo only grows), and there is **no UI
+to list, restore from, or prune them**. The safety net exists but the user cannot
+reach it — which also weakens D8's "it's recoverable" defence.
+
+**Fix.**
+- `git_peer_backups(project_id) -> Vec<BackupRef { ts, branch, sha, peer, subject }>`
+  (`for-each-ref refs/eldrun/backup` on both peers).
+- Surface in the lockstep bar behind a small "Backups (n)" affordance: list, and a
+  per-entry **Restore** that force-moves the branch back (creating a *fresh* backup
+  of the current tip first — restore must itself be undoable).
+- Prune policy: keep the most recent N (default 20) per peer **and** anything newer
+  than 30 days; drop the rest on each successful reconcile. Never prune the newest.
+
+**[shipped]** As planned. Pruning is driven from where backups are *born* (`resolve`,
+`restore_backup`) rather than from every successful reconcile — same effect on growth,
+zero cost on the hot path (which creates no backups at all).
+
+**Files.** `services/git_peer.rs`, `commands/git_peer.rs`, `GitHistory.tsx`.
+
+**Tests.** Rust unit: backup-ref name parse (round-trips `backup_ref_name`), prune
+selection (keeps newest N + recent, never empties). Frontend: list renders, restore
+routes to the command.
+
+---
+
+## D7 — The paired mirror has no `origin` *(usability)*
+
+**Problem.** `init_pairing` creates the mirror with `git init` + a bundle
+(`git_peer.rs:726`), so **no remote is configured**. A `git push` from a local agent
+tab in the mirror fails. Bundles deliberately never carry `config`/`remotes`
+(correctly — they are machine-specific), so nothing sets it.
+
+This may be intentional: the Git panel pushes *from the host* with the host's
+credentials (`commands/git.rs:15-20`). But the mirror is where local agents work,
+and "push from here" silently not existing is a bad surprise.
+
+**Fix.** After a successful pairing, read the source peer's `remote.origin.url`; if
+it exists and the dest has none, set it on the dest (`git remote add origin <url>`).
+URL only — never credentials, never other config keys. If the host's origin is an
+SSH URL the mirror may not be able to authenticate to, that is the user's existing
+git setup and not ours to paper over; a failing push is then a normal git error with
+a normal git fix.
+
+**[shipped]** As planned (`should_propagate_origin`, URL only, never over an existing
+origin).
+
+**Files.** `services/git_peer.rs` (`init_pairing` tail).
+
+**Tests.** Rust unit: origin propagation is skipped when the dest already has one.
+Manual: pair, then `git push` from a local agent tab in the mirror.
+
+---
+
+## D8 — Divergence offers authority, not merge *(feature gap)*
+
+**Problem.** On a genuine two-sided divergence (case #10) the entire menu is **Use
+local** / **Use remote** — pick a winner, the loser's tip goes to a backup ref you
+cannot browse (D6) and its commits leave the working tree. There is no merge, no
+rebase, and no way to just *look* at the two histories side by side.
+
+**Fix (deliberately minimal — do not build a merge UI).**
+1. Add a third desync action: **Resolve in terminal** — opens a local shell tab in
+   the mirror, on the diverged branch, with the peer's tip already fetched into a
+   local ref (`refs/eldrun/peer/<branch>`, created by the reconcile that detected the
+   divergence — the objects are already there from the bundle, so this is free).
+   The user then merges/rebases with plain git, and the next `.git`-watcher pass
+   picks up the result and fast-forwards the host normally.
+2. Show both heads' short sha + subject in the desync bar so the choice is informed.
+
+This turns an unrecoverable-feeling dead end into "git, as usual" without Eldrun
+having to own conflict resolution.
+
+**[shipped]** The peer ref lives in its own namespace (`refs/eldrun/peer/*`), so
+`cleanup_incoming` — which only ever touched `refs/eldrun/incoming/*` — needed no change;
+instead `peer_ref_op` sets the ref on a diverged branch and **clears** it on any other
+outcome, so it never outlives the divergence it documents. `tabs.ts` needed no change
+either: the existing `addTab({kind: "shell", location: "local"})` already spawns a local
+shell, and `git_peer_mirror_dir` supplies the cwd.
+
+**Files.** `services/git_peer.rs`, `commands/git_peer.rs`, `GitHistory.tsx`.
+
+**Tests.** Rust unit: diverged branches retain `refs/eldrun/peer/*` while in-sync
+ones are still cleaned. Frontend: the action spawns a local tab in the mirror.
+
+---
+
+## D9 — `resolve`/`restore_backup` can clobber untracked files, with no D3-style guard *(data loss; blocking)*
+
+**Problem.** `force_reset_branch` (called by `resolve_inner` for Use-local/Use-remote,
+and by `restore_backup`) runs `git reset --hard <sha>` on the dest's checked-out
+branch. This is *exactly* behaviour 2 from the top of this file — `reset --hard`
+silently clobbers a colliding untracked file — and it is exactly what `init_pairing`
+was hardened against in D3. But `force_reset_branch` has no equivalent check: it
+backs up the branch *ref* to `refs/eldrun/backup/*` and then resets, with nothing
+proving the working tree is safe to overwrite.
+
+The gap is real because a backup ref only saves **committed** history. An untracked
+file was never a git object, so there is nothing to restore it from once `reset
+--hard` overwrites it.
+
+**Concrete scenario.** Lockstep + byte-sync enabled, local and host diverge. The
+user clicks "Use remote." If the local mirror has an untracked file at a path the
+winning remote history tracks (build output, a local-only config, or a file
+byte-synced there before ever being committed), `reset --hard` overwrites it with
+zero backup and zero warning. The confirm dialog (`GitHistory.tsx`) actively
+undersells the risk here: it says the loser's commits are "backed up... first,"
+which reads as "nothing is lost" — true for commits, false for untracked files. The
+pairing-conflict dialog gets this right ("NOT in git — they will be lost"); the
+resolve dialog doesn't carry the equivalent warning because the backend never
+detects the collision in the first place.
+
+**Fix.** Mirror D3: before any `force_reset_branch` call that would move a checked-
+out branch, compute the untracked files on the dest that collide with (and differ
+from) what the target sha's tree holds. If any exist, refuse the whole
+resolve/restore and name them — the same "blocked, user clears it, retries" UX
+`blocked_detail` (D1/D2) already established, rather than a new confirm-override
+flow.
+
+**[shipped]** `reset_collisions(source_peer, dest_peer, target_sha)` — `ls-tree -r -l
+-z` on the source for the target tree, `ls-files --others -z` on the dest for its
+untracked set, `hash_objects` (already used by `pairing_conflicts`) to prove content
+identity. An unprovable hash counts as a difference, the same conservative default as
+`pairing_collisions`. Wired into `resolve_inner` (checked against the *losing* side's
+checked-out branch before `transfer_and_apply(force: true)` runs) and into
+`restore_backup` (checked before `force_reset_branch` whenever the branch being
+restored is the peer's HEAD) — both return `Err` naming the paths instead of
+proceeding, and `restore_backup` resumes auto-sync first so a refusal never leaves it
+paused.
+
+**Files.** `services/git_peer.rs` (`reset_collisions`, `resolve_inner`,
+`restore_backup`).
+
+**Tests.** Rust unit: `reset_collisions` against two real local repos — an
+identical-content collision pairs clean, a differing one is named, an unrelated
+untracked file is ignored. Manual: diverge, drop a colliding untracked file on the
+losing side, click Use-{local,remote} → refused with the filename named, file
+intact.
+
+---
+
+## D10 — Stale-residue deletion trusted a stat heuristic instead of content *(data loss; narrow)*
+
+**Problem.** `retry_ff_clearing_identical`'s two grounds for deleting a colliding
+untracked file before retrying a blocked fast-forward are (a) `blob_matches_worktree`
+— real content equality via `git hash-object` vs the incoming blob — and (b)
+`stale_byte_sync_residue`, which instead relied on `remote_sync::divergence`: a pure
+size+mtime comparison against the sync manifest's recorded base, with **no content
+hash anywhere in `SyncEntry`**. Ground (a) is a proof; ground (b) was a heuristic
+wearing a proof's clothes, and the caller **deletes the file** on either ground with
+the same confidence.
+
+If size and mtime happen to coincide with the manifest's stale base while the actual
+bytes differ (clock skew, a tool that preserves mtimes on copy, or plain bad luck),
+`stale_byte_sync_residue` reports the path safe and `retry_ff_clearing_identical`
+deletes real, never-committed work via `git clean -f -x`, with no backup — untracked
+content has none.
+
+**Fix.** Replace the stat comparison with a content-based proof that needs no schema
+change: the bundle fetch (step 3 of `transfer_and_apply`) has already deposited every
+object the incoming commit needs into the dest's own object store by the time the
+residue check runs. So "the file's current bytes are already a git object the dest's
+store knows about" (`git hash-object` to name it, `git cat-file -e` to check
+existence) proves the content is *some* prior git-known state — either history the
+peer already had, or an object the fetch just brought in — never content nothing has
+ever recorded. That is exactly the distinction that matters: real independent work
+was never a git object anywhere, so it can never pass this check by accident.
+
+**[shipped]** `stale_byte_sync_residue` keeps its manifest gate (only a path
+byte-sync has ever touched is even considered, preserving the D1/case-#12 framing —
+scope, not the safety proof) but the actual verdict is now `object_already_known`
+(`hash-object` + `cat-file -e` on the dest peer, no SFTP, no manifest stat fields
+needed). Dropped the now-unused `pool`/`spec`/`to_remote` params — the check runs
+entirely through `Peer::run`, local or remote alike.
+
+**Files.** `services/git_peer.rs` (`stale_byte_sync_residue`, `object_already_known`).
+
+**Tests.** Rust unit (real repo): content matching a git-known blob (an old commit,
+or an object the incoming fetch deposited) is recognized as safe residue; content
+that has never been part of any commit or fetch is refused even with a matching
+manifest entry; a path outside the manifest is refused regardless of content.
+
+---
+
+## D11 — A genuine bundle-create failure still fell through to ref application *(correctness / potential corruption)*
+
+**Problem.** `transfer_and_apply` creates the bundle, then — regardless of whether
+that succeeded — always runs step 4 (apply safe ref updates per branch). The
+`if out.status.success()` guard only gates steps 2–3 (move + fetch). The reasoning in
+the existing comment is sound for exactly one failure mode: git's "Refusing to
+create empty bundle" refusal, which means the dest already has every object and step
+4 must still run (this is bug #4 from the original #28n live QA). But it does not
+distinguish that from a **genuine** creation failure — disk full, a bad path,
+permission denied — where no objects moved anywhere. In that case step 4 still runs
+using the pre-transfer snapshots and, e.g., blindly `update-ref`s a new branch onto a
+sha the dest never received: a dangling ref pointing at a missing object, reported as
+`applied`, which can compute the whole pass to `Synchronized`. Same "false green"
+shape as the four bugs D1–D8 already fixed, reintroduced by the fix for #4 going one
+conditional too far in the safe direction.
+
+**Fix.** Distinguish the two failure shapes by parsing git's own message: only the
+empty-bundle refusal may still let step 4 proceed. Any other failure aborts the whole
+direction before step 4 ever runs.
+
+**[shipped]** `is_empty_bundle_error(stderr)` (pure — matches git's literal "Refusing
+to create empty bundle" text). On any other bundle-create failure, `transfer_and_apply`
+returns `Err` immediately, before step 4. Every caller already handles `Err` correctly
+(`reconcile_with` surfaces it as `blocked`/`Desynchronized`, per the bug-#2 fix;
+`resolve_inner` propagates it via `?`; `init_pairing` already discarded errors from
+this call and continues to, so its behaviour on a genuine failure only gets safer —
+zero refs applied instead of some applied against missing objects).
+
+**Files.** `services/git_peer.rs` (`transfer_and_apply`, `is_empty_bundle_error`).
+
+**Tests.** Rust unit: `is_empty_bundle_error` recognizes git's exact refusal text and
+rejects an unrelated failure message (e.g. "No space left on device"). Full
+end-to-end proof that a real creation failure aborts the whole direction needs a live
+remote (same caveat as D1/D3's live-only cases) — exercise via `lockstep_drv.rs` when
+next on a live host.
+
+---
+
+## Phasing
+
+**Phase 1 — trust (blocking; nothing else matters until these land).**
+D1 → D3 → D4 → D2. D1 and D3 are the two defects that can lose or wedge real work;
+D4 removes the misread that feeds D3; D2 is a one-liner that makes D1's residual
+failures self-explanatory. Ship together.
+
+**Phase 2 — viability on a real link.**
+D5, then D6. D5 is what determines whether this is usable over a WAN at all; D6
+makes the existing safety net reachable.
+
+**Phase 3 — polish.**
+D7, D8.
+
+## Gates
+
+`cargo test --manifest-path src-tauri/Cargo.toml`, `npx tsc --noEmit`, `vitest`.
+Every item above lands with its unit tests in the same commit.
+
+Phase 1 additionally requires **live-host manual QA** — the 🖐️ box on #28n is still
+unticked, and D1/D3 are precisely the cases a unit test cannot prove. The minimum
+live matrix:
+
+| # | Check |
+|---|---|
+| 1 | auto-sync-all + lockstep, create 10 files, wait 3 s, commit → host fast-forwards, green |
+| 2 | same but commit immediately → still green (no regression on the fast path) |
+| 3 | pre-existing byte-synced tracked files, *then* enable lockstep → first reconcile succeeds |
+| 4 | extend local onto a host dir holding a differing `README.md` → refused, host file intact |
+| 5 | disconnect → Sync now → reports disconnected, not green |
+| 6 | commit on both sides → diverged → Use local → host resets, backup ref present and listable |
+| 7 | diverge, drop a *differing* untracked file at a path the winner tracks on the losing side, Use-{local,remote} → refused, filename named, file untouched (D9) |
+| 8 | same as #7 but the untracked file is byte-identical → resolve proceeds, no refusal |
+| 9 | force a genuine bundle-create failure (e.g. a full disk on the source) → Desynchronized with the real error, no dangling ref on the dest (D11) |
diff --git a/docs/git_lockstep_live_qa.md b/docs/git_lockstep_live_qa.md
new file mode 100644
index 0000000..e3f4d77
--- /dev/null
+++ b/docs/git_lockstep_live_qa.md
@@ -0,0 +1,260 @@
+# Git Lockstep — Live QA against a real SSH host (#28p)
+
+Companion to `docs/git_lockstep_case_matrix.md`, which until now carried the line
+*"Unit tests cover every pure decision function; none of this has run against a real
+SSH host."* This is that run.
+
+## How it was driven
+
+`src-tauri/examples/lockstep_drv.rs` — an example (never CI; it needs a live host and
+mutates both trees). It calls the **same service entry points the Tauri commands call**:
+
+| Driver command | Production entry point | Tauri command it stands in for |
+|---|---|---|
+| `sync` / `sync-soft` | `git_peer::detect_and_sync` (forced / not) | `git_peer_sync_now`, and the poll loop |
+| `pair-confirm` | `detect_and_sync` + `allow_pair_overwrite` | `git_peer_pair_confirm` |
+| `resolve local\|remote` | `git_peer::resolve` | `git_peer_resolve` |
+| `checkout <t> [side]` | `git_peer::checkout_lockstep` | `git_peer_checkout` |
+| `backups` / `restore` | `git_peer::list_backups` / `restore_backup` | `git_peer_backups` / `..._restore_backup` |
+| `bs` | `sync_auto::reconcile_once` | the byte-sync engine's pass |
+| `ls-enable` / `bs-auto` | `git_peer::save_state` / manifest write | the two opt-in toggles |
+
+Not reproduced: the UI event emits, and the engines' *timing* (the `.git` watcher, the
+12 s git poll, the 25 s byte-sync interval). The driver invokes the very passes those
+timers invoke — it supplies the *when*, not the *what*.
+
+One production change was needed to get here: `sync_auto::reconcile_pass` took an
+`AppHandle` it used for nothing but the completion event, so it now takes an
+`Option<&AppHandle>` and `sync_auto::reconcile_once` exposes a single pass. Without it
+the byte-sync half of every BS+LS case would have had to be *reimplemented* in the
+driver — and a reimplementation proves nothing about the code that ships.
+
+**Subject under test:** project `SSH Git Test` —
+mirror `~/eldrun/projects/ssh-git-test` ↔ `<remote-host>:~/projects/ssh-git-test`.
+Baseline for every group: both sides clean on `master` at the same commit.
+
+## Reading the timings
+
+A full reconcile pass costs **~630 ms** (probe + bundle + transfer). The D5 early-out
+costs **~280 ms** — the probe still runs. That gap is how the early-out is *observed*
+below; it is also a correction to the matrix, which calls case 9 "zero network".
+
+---
+
+## Group A — creates and edits before any commit (cases 1–9): 9/9 as documented
+
+| # | Scenario | Config | Observed | |
+|---|---|---|---|---|
+| 1 | create untracked `c1.txt` | – | host never saw it | ✅ |
+| 2 | create untracked `c2.txt` | BS | pushed; host `git status` → `?? c2.txt` | ✅ |
+| 3 | create untracked `c3.txt` | BS+LS | **still pushed** — not in the index, so `drop_tracked` can't see it | ✅ |
+| 4 | edit tracked `README.md` | BS | pushed; host content replaced | ✅ |
+| 5 | edit tracked `TODO.md` | BS+LS | **not pushed**; host still `# TODO` | ✅ |
+| 6 | host creates untracked `host6.txt` | BS+LS | pulled into the mirror | ✅ |
+| 7 | host edits tracked `ROADMAP.md` | BS+LS | **not pulled**; mirror still `# Roadmap` | ✅ |
+| 8 | `git add c3.txt` | LS | dirty bit 0→1 ⇒ signature moved ⇒ **full** pass (636 ms), and it transferred nothing: host head unchanged, `c3.txt` still `??` there | ✅ |
+| 9 | `.git` touched, refs+dirty unchanged | LS | `git status` rewrote `.git/index`'s stat cache; next passes early-outed (281 ms, 272 ms), stayed green | ✅ |
+
+Cases 5 and 7 are the invariant working in both directions: **lockstep owns the tracked
+tree, byte-sync owns everything else.** Case 3 is the documented seam between them — a
+file is "tracked" only once it is in the *index*, so a brand-new file still rides
+byte-sync until the first `git add`.
+
+Case 4 left a real artifact worth naming: with lockstep off, byte-sync pushed
+`README.md`'s new bytes to the host, where they sat **uncommitted**. That is exactly the
+shape case 12 is about, and it arose here by accident — which is the point of that case.
+
+---
+
+## Group B — commits (cases 10–15): 5/6 as documented, **case 15 was broken**
+
+| # | Scenario | Observed | |
+|---|---|---|---|
+| 10 | local commit, nothing byte-pushed | host ff `08cd8ab → 32ff917`, `f10.txt` tracked+clean there | ✅ |
+| 11 | local commit over an **identical** byte-pushed copy | host held `?? f11.txt`; ff refused; `retry_ff_clearing_identical` proved identity, cleared it, retried → green at `97d59d7` | ✅ |
+| 12a | local commit over a **differing** byte-pushed copy | byte-sync pass confirmed it would *not* push v2 (tracked); `stale_byte_sync_residue` proved the host's v1 was its own untouched push → cleared → ff to `9f80525`, v2 on disk | ✅ |
+| 12b | …but the host copy was **independently edited** | **refused**, exactly as it must: `'master' can't fast-forward: untracked file(s) on the peer differ from the incoming commit: f12b.txt`. Host head did not move; the host's edit survived byte-for-byte | ✅ |
+| 13 | local commit, BS only | bytes crossed (`?? f13.txt`), history did **not** (host head unchanged) | ✅ |
+| 14 | commit made **on the host** | mirror fast-forwarded to `f085ef9`, `f14.txt` present and clean | ✅ |
+| 15 | **both sides commit on `master`** | reported **`Synchronized`** — a false green over a real divergence | ❌ → fixed |
+
+Case 12b is the one that matters most: the residue heuristic is doing real proof, not
+blanket clearing. A file byte-sync pushed and nobody touched is disposable; the same file
+after a human edits it on the host is not, and the fast-forward fails closed and names it.
+
+### The bug: every genuine divergence reported green
+
+`transfer_and_apply` builds a thin bundle by delta-excluding the shas the dest already
+has: `git bundle create … --not <dest tips>`. Those excludes are passed to the **source**,
+which in a divergence has *by definition never seen the dest's tip* — so git aborts the
+whole bundle with `unknown revision`. That failure is then swallowed by
+
+```rust
+if !out.status.success() {
+    // Nothing to bundle (e.g. dest already has everything) is reported by git as
+    // an error on an empty rev range — treat as a no-op transfer.
+    return Ok(result);
+}
+```
+
+whose comment assumes the only way bundling fails is the benign empty-range case. Both
+legs abort identically, `diverged` stays empty, and the pass computes to `Synchronized`.
+`decide()` — which the unit tests cover thoroughly — is never reached at all, which is
+exactly why 3 400 lines of well-tested pure logic never caught this.
+
+Consequence: two histories drift apart under a green pill, the desync bar never appears,
+and Use local / Use remote is never offered. Observed live: mirror `945db03`, host
+`3991824`, status `Synchronized`.
+
+**Fix** (`known_shas`): filter the excludes to the shas the source actually has, via one
+`git rev-list --no-walk --ignore-missing` round trip. Excludes are only a bundle-size
+optimization, so dropping an unknowable one costs bytes and never correctness — a
+divergence now simply sends a full bundle, the dest fetches both histories, and `decide`
+reaches `Diverged` as designed. Second, the two transfer legs no longer discard an `Err`
+(`if let Ok(r) = …`), which had the same green-on-failure shape; a failed leg is now
+surfaced as `blocked`.
+
+Re-running the *same* still-diverged repo against the fix:
+
+```
+sync    → status=Desynchronized  local=master@945db032  remote=master@39918242
+          detail: Diverged: master
+mirror  refs/eldrun/peer/master -> 3991824      # host's tip parked locally
+host    refs/eldrun/peer/master -> 945db03      # mirror's tip parked on the host
+        …and neither head moved.
+resolve local → green; host reset to 945db03, its f15-host.txt gone from the worktree,
+                overwritten tip preserved at refs/eldrun/backup/1783938132/master.
+```
+
+---
+
+## Group C — checkouts (cases 16–21): 5/6 as documented, **case 17 was broken**
+
+| # | Scenario | Observed | |
+|---|---|---|---|
+| 16 | checkout a branch locally | host followed onto `feat-x`, `f18.txt` appeared there | ✅ |
+| 17 | checkout **on the host** | mirror did **not** follow, and the pass reported green with the two sides on different branches | ❌ → fixed |
+| 18 | new branch + commit locally | `CreateOnDest` → host checked `feat-x` out too, at the same sha | ✅ |
+| 19 | peer has dirty **tracked** changes | host's guarded checkout refused, carrying git's **actual** stderr: `Your local changes to the following files would be overwritten by checkout: README.md`. Host stayed on `master`; its uncommitted work survived | ✅ |
+| 20 | FF a branch **not checked out** on the peer | host's `feat-x` ref moved to `cde335d` by plain `update-ref`; host HEAD still `master`, and `f20.txt` never appeared in its worktree | ✅ |
+| 21 | detached HEAD | host detached at the same sha; both sides `DETACHED@945db03` | ✅ |
+
+### The bug: a coordinated checkout left a stale peer head, which masked the peer's next one
+
+`checkout_lockstep` reconciles refs (step 2) and only *then* checks the peer out (step 3),
+but it returned the state computed at step 2 — so it persisted a peer head one checkout
+out of date. That is not just a wrong pill. `detect_and_sync` decides *"did the peer's HEAD
+move?"* by comparing a fresh probe against exactly that stored value, so a stale one
+**masks the peer's very next checkout** — and permanently, because the stale state then
+agrees with the probe and no later pass sees a move either.
+
+Underneath it sat a second hole: `reconcile_with` compares only **refs**, never HEAD. Two
+peers sitting on different branches with identical refs is `Synchronized` *by construction*.
+So the mirror stayed on `master`, the host sat on `feat-x`, and nothing ever noticed.
+
+The same hole made case 19 unrecoverable in a subtler way: after the host's checkout was
+refused, every ref still matched, so clearing the dirt and hitting Retry reported **green**
+while leaving the host on the wrong branch.
+
+**Fixes:**
+1. `refresh_heads` — re-probe both peers after a checkout actually moves a HEAD, so the
+   persisted heads (and, when green, the early-out signatures) describe reality.
+2. `head_mismatch` — a new terminal rule in the status chain: refs agree but the HEADs
+   point somewhere different ⇒ `Desynchronized: Out of step: the mirror is on 'x', the host
+   is on 'y'`. It *reports* rather than auto-checking-out: with no observed move there is no
+   principled way to say which side should follow, and lockstep never rewrites a worktree it
+   wasn't asked to. The Checkout action is one click away.
+3. `ReconcileOpts::mid_checkout` — suppresses that rule inside `checkout_lockstep`'s own
+   reconcile, where the two HEADs are *expected* to disagree for the duration. Without it the
+   new rule fired on that normal intermediate state and left its stale red on a checkout that
+   had in fact succeeded.
+
+After the fix: the host's switch to `feat-x` brought the mirror with it; the blocked case-19
+state reports `Out of step: the mirror is on 'feat-y', the host is on 'master'` instead of
+green, and the Checkout action then completes it.
+
+---
+
+## Group D — initial pairing (cases 22–24): 3/3 as documented
+
+The host's repo was destroyed and re-paired from the mirror for each of these (it was
+`tar`'d aside first; the mirror holds the full history, which is the point).
+
+| # | Scenario | Observed | |
+|---|---|---|---|
+| 22a | dest **empty** | `git init` + full bundle + `reset --hard` → all three branches and every file restored at `e71d38b`, clean, no spurious `origin` | ✅ |
+| 22b | dest holds only **identical** files (no `.git`) | paired cleanly, worktree already correct, green | ✅ |
+| 23 | dest holds files that **differ** | **refused**: `Pairing would overwrite 2 file(s) on the host that differ: README.md, TODO.md`. Both files untouched, and it did not even `git init`. `pair-confirm` then overrode it deliberately and the host took the committed content | ✅ |
+| 24 | dest's probe **errored** | **refused**: `Remote host repository could not be read; refusing to auto-initialize it.` Host untouched, still a repo; green again once readable | ✅ |
+
+Case 24's *cause* is simulated — the driver hands `detect_and_sync` a spec whose
+`remote_path` fails `validate_arg`, so `run_remote_script` returns `Err`. That is exactly
+the input which sets `PeerSnapshot::probe_error` on a remote peer, so the guard under test
+and the refusal it produces are the real ones; only the reason the probe couldn't run
+(rather than a flaky link or a missing `git`) is synthetic.
+
+---
+
+## Group E — connectivity, backups, deletions (cases 25–28): 3/4, **case 26 was broken**
+
+| # | Scenario | Observed | |
+|---|---|---|---|
+| 25 | pool cold | `Disconnected` + "Not connected to the remote host", in **0 ms** — it bailed before probing, kept the last-known heads, claimed nothing | ✅ |
+| 26 | backups listable + restorable | listable ✅, restorable ✅ (host went back to the discarded tip, worktree and all), and the restore was itself backed up. But the **`resolve` that follows it silently did nothing** | ❌ → fixed |
+| 27 | committed deletion | rode the fast-forward; `f10.txt` removed on the host, tree clean | ✅ |
+| 28 | uncommitted deletion | not propagated — host kept the file. The engine logged the documented mechanism: `push skip 'del28.txt': No such file or directory` | ✅ |
+
+### The bug: an empty bundle skipped the ref update, not just the transfer
+
+`git` refuses to create an **empty** bundle, which is how it reports *"the dest already has
+every object I would have sent"*. `transfer_and_apply` treated that as a no-op and returned
+— skipping step 4, the ref application. But a no-op *transfer* is not a no-op *apply*: the
+dest's refs still have to move onto those objects.
+
+Hit live by `resolve local`: the host already had the winning commit (via a descendant
+branch and its own backup refs), so the bundle came out empty, so nothing was transferred
+**and nothing was updated** — the resolve reported the very divergence it had just been
+asked to end. It is not specific to resolve: any branch whose commits reached the peer via
+another branch would fail to have its ref moved.
+
+Note this only became reachable *because* the divergence fix worked: parking the peer's tip
+is what gives the host the objects that make the bundle empty. It also explains why the
+first `resolve` (case 15) worked and the second didn't — the `feat-*` branches created in
+Group C were descendants of `master`, so their exclusion covered `master`'s objects.
+
+**Fix:** only the transfer (`move_bundle` + `fetch`) is skipped when there is nothing to
+send; step 4 always runs.
+
+---
+
+## Summary
+
+**28/28 cases now behave as `docs/git_lockstep_case_matrix.md` documents.** Four did not
+when first run live, and all four were the *same shape*: **a no-op or failure in the
+transport computing to `Synchronized`.**
+
+| Bug | Blast radius |
+|---|---|
+| Excludes the source doesn't have abort the bundle ⇒ **every genuine divergence reported green**, desync bar never shown, Use local / Use remote never offered | two histories drift apart silently, forever |
+| Transfer legs discarded their `Err` (`if let Ok(r) = …`) | any failed transfer reported green |
+| Coordinated checkout persisted a stale peer head ⇒ **masked the peer's next checkout**; and `reconcile_with` never compared HEADs at all | the two sides sit on different branches under a green pill, permanently |
+| An empty bundle skipped the **ref application**, not just the transfer | `resolve` (and any ref whose objects arrived via another branch) silently did nothing |
+
+None of these were reachable by the existing unit tests, which are thorough over the *pure
+decision functions* — `decide`, `can_early_out`, `blocked_detail`, the parsers. Every one of
+these bugs lives in the I/O orchestration *around* those functions, and three of the four
+prevented `decide` from ever being called. That is the gap this run existed to close, and it
+is the argument for keeping `lockstep_drv.rs` around.
+
+New regression coverage: `head_mismatch` is pure and unit-tested (3 cases). The other three
+fixes are in async I/O paths; they are covered by this driver, not by `cargo test`.
+
+## Still not covered
+
+- The **engines' timing** — the `.git` watcher, the 12 s git poll, the 25 s byte-sync
+  interval. The driver invokes the passes those timers invoke; it does not prove the timers
+  fire. (Case 8/9's *content* — dirty-bit signature and early-out — is covered.)
+- **Tags.** The matrix never mentions them; `transfer_and_apply` and `resolve` both handle
+  them, and nothing here exercised one.
+- The **UI layer**: the desync bar, the pairing-conflict dialog, and the Use local / Use
+  remote / Restore buttons were never clicked — only the commands behind them were called.
diff --git a/docs/hpc_workspace_plan.md b/docs/hpc_workspace_plan.md
new file mode 100644
index 0000000..dbb59e6
--- /dev/null
+++ b/docs/hpc_workspace_plan.md
@@ -0,0 +1,211 @@
+# HPC workspaces in Eldrun — the layout, and the plan around it
+
+Status: Phases 0, 1 and 2 implemented (untested on a cluster); Phase 3 proposed.
+Companion to `docs/quirky-knitting-umbrella` (the SLURM pipeline) and TODO group
+G #86.
+
+## The problem
+
+On a SLURM cluster the filesystem is split by *purpose*, and getting it wrong is
+expensive in a way nothing in the UI would otherwise mention:
+
+- **home** — small (a per-user quota, commonly ~100 GB), persistent, backed up,
+  identical on every node. Meant for code and job scripts. Filling it locks the
+  user out of everything, including logging in cleanly.
+- **the parallel filesystem** (Lustre/BeeGFS/…) — effectively unlimited space,
+  handed out as a **workspace**: a named directory with a *duration* and an
+  *expiry*, after which it is **deleted** (sites keep the data a few weeks and
+  can restore it, but recovery needs the workspace's **name**). Created with the
+  `hpc-workspace` tooling: `ws_allocate <name> <days>`, `ws_list`, `ws_find`,
+  `ws_extend`, `ws_release`. Bulk input, output and temporary data belong here.
+
+Eldrun's remote projects have exactly **one** host root (`RemoteSpec.remote_path`),
+from which every transport is derived — SFTP upload, byte-sync, git lockstep, the
+file tree, the run tabs. So "where does the project root go" is not a cosmetic
+choice: it decides which of the two filesystems everything Eldrun does lands on.
+Before Phase 0 the pipeline browsed to a folder (i.e. `$HOME`) and made that the
+root, which pointed every one of those transports at the quota.
+
+## The decision: the project root IS the workspace
+
+```
+  the parallel filesystem (expires)              home (persistent, backed up, quota'd)
+  /<fs>/<user>-<ws>/                             ~/eldrun/<project>/
+  └── <project>/        ← PROJECT ROOT           ├── logs/          ← #SBATCH --output
+      ├── code, job.slurm   (git lockstep)       ├── workspace ->  /<fs>/<user>-<ws>
+      └── data/, outputs/   (byte-sync)          └── workspaces.txt  (append-only record)
+```
+
+Three reasons, in order of weight:
+
+1. **Every mechanism already works, unchanged.** One root means the walkers, the
+   manifest, the lockstep pairing, the big-folder census and the run tabs all
+   resolve to the workspace with no new concept. The alternative — project in
+   `$HOME` with the workspace symlinked in as `data/` — is *half* working, and
+   the wrong half: `sftp::list_dir_on` follow-stats symlinks, so the file tree
+   **navigates** into it and opens files, while `remote_sync::walk_host_files` is
+   lstat-typed and **skips** it (guard G3), so the mirror never sees a single
+   file under it. Visible but unsynced is worse than absent: it reads as covered.
+2. **The durable copy of the code is the local mirror + git, not the host tree.**
+   Eldrun already treats the host side as a working copy that lockstep can rebuild.
+   So expiry costs a re-pair, not the work — provided outputs were pulled, which
+   Phase 2 is about.
+3. **Quota safety becomes structural.** Nothing Eldrun does — sync, upload, job
+   output, checkpoints — can fill home, instead of that being a rule the user has
+   to remember at every step.
+
+Accepted costs, stated rather than hidden:
+
+- `.git` lives on the parallel filesystem, which dislikes many small files.
+  Lockstep transfers are single bundle files, so the traffic is fine; it is
+  working-tree checkouts that get slower. Tolerable, and Phase 3 is the escape
+  hatch if it ever isn't.
+- Expiry deletes the host tree wholesale, repo included. That is a **certainty on
+  a ~1 year horizon**, not an edge case — which is precisely why Phase 2 exists.
+
+## The home anchor: what stays behind
+
+A workspace path (`/<fs>/<user>-<ws>`) is unmemorable, and once the workspace is
+gone the only thing that can recover it is its **name**, which by then nobody
+remembers. So each HPC project keeps a *small* folder in home — nothing that can
+grow, and nothing Eldrun syncs:
+
+| Entry | Why it is there |
+|-------|-----------------|
+| `logs/` | `#SBATCH --output` points here, so the record of *what was run* outlives the workspace and is backed up. Small by nature — logs only, never artifacts. |
+| `workspace` → the workspace path | `cd ~/eldrun/<project>/workspace` from any login node, and a job script can reach it without hardcoding a site path. Goes dangling at expiry, which is itself a signal. |
+| `workspaces.txt` | Append-only: date, workspace id, filesystem, path, requested duration, the project name, and the **local mirror path** (which machine holds the durable copy). This is the file that makes `ws_restore` possible, and the one that answers "which workspace held the Q3 runs?" a year later. |
+
+The anchor is *host-side navigation and provenance*. It is deliberately outside
+the project root, so no walker, manifest or census ever touches it.
+
+## Phases
+
+### Phase 0 — the workspace step (implemented)
+
+- `commands::hpc_ws`: `hpc_ws_available` / `_list` / `_allocate` / `_extend` /
+  `_release` / `_link`. Reuses `commands::slurm`'s dispatch for a project target
+  and adds a bare-host target (`run_ssh_auth`) because a workspace is allocated
+  **before** the project exists. Site-agnostic (`ws_list -l` is asked, nothing is
+  preset); every interpolated value validated *and* `shell_quote`d; list/allocate
+  each append a `ws_find` confirmation in the same round trip, because the *path*
+  is what everything downstream depends on and `ws_list` layouts differ by version.
+- `lib/hpcWorkspace.ts` + a **Workspace** step in `HpcPipelineWizard`, between
+  Project and Load data, which is now the step that calls `create_project` —
+  because it is what decides the remote root. The integration is one assignment:
+  `remoteChosenPath = <workspace path>`.
+- The Jobs view lists the project's workspaces with days-left (toned) and Extend.
+
+### Phase 1 — the home anchor (implemented)
+
+1. `hpc_ws_anchor(target, anchor_rel, workspace, project_name, mirror_path)` —
+   one `sh` script: `mkdir -p $HOME/<rel>{,/logs}`, `ln -sfn <ws> …/workspace`
+   (refusing to replace a real file), append the record, print the resolved
+   absolute paths. Everything quoted; `anchor_rel` validated as a path-safe
+   segment list so it cannot escape `$HOME`.
+2. Persist it on the project: an additive optional `hpc` block in `project.json`
+   (`workspace_id`, `workspace_path`, `filesystem`, `anchor_dir`, `logs_dir`),
+   mirrored into the `projects.json` entry's `extra` like `run_host` is. Nothing
+   else can be re-derived after the workspace is gone.
+3. Wizard: a checkbox in the Workspace step (default on when a workspace was
+   chosen), with the anchor path shown and editable (`eldrun/<project>`).
+4. Wire the logs: the starter script's `--output` becomes
+   `<logs_dir>/slurm-%j.out` (a `spliceDirective` call, so it stays an ordinary
+   edit), and `slurm_job_out`'s fallback for a job `scontrol` has forgotten
+   prefers the recorded `logs_dir` over its `<WorkDir>/slurm-<id>.out` guess —
+   otherwise "Watch" on an old job silently tails nothing.
+
+Two details the implementation pinned down that the sketch above did not:
+
+- The anchor is recorded **both** absolutely (`anchor_dir`) and as the
+  `$HOME`-relative path it was created from (`anchor_rel`). Re-anchoring after a
+  move must pass the *rel* back, and deriving it by chopping segments off the
+  absolute path guesses wrong for any folder that isn't two segments deep.
+- `validate_anchor_rel` rejects `.`/`..` segments explicitly: `validate_token`
+  permits `.` inside a name (`my.project`), so traversal had to be its own rule.
+
+### Phase 2 — surviving expiry (implemented)
+
+5. **Re-point the root.** There is no way today to change a primary's
+   `remote_path` after creation (`RemoteMachinesWindow`'s path field only adds
+   worker machines). Add "Move to another workspace…": allocate or pick, set the
+   new root, re-pair the mirror (lockstep seeds it from the local side, which is
+   the durable copy), re-link the anchor and append the record. Without this,
+   expiry means re-creating the project by hand — on a horizon of months, for
+   every HPC project.
+6. **Say the clock out loud.** The persisted `workspace_id` makes a cheap
+   days-left read possible on connect; warn on the pill and in the Jobs view at
+   ≤7 days, urgently at ≤2, with **Extend** and **Pull everything down** right
+   there. The wizard already registers the site's own `-r`/`-m` reminder mail;
+   this is the in-app twin, and it is the only thing standing between a busy
+   month and a deleted campaign.
+7. **Pull the logs down** (small, optional): copy the anchor's `logs/` into the
+   local mirror on demand, so the provenance record exists on the laptop too.
+
+As built: `hpc_ws_move_root` + a **Move here** action on every non-current
+workspace row in the Jobs view; the confirm states plainly that the new root
+starts empty, is re-seeded from the local mirror, and that anything living only
+in the old workspace stays behind. The caller disconnects around the rewrite (the
+pool caches the spec) and **reconnects before re-anchoring**, since the anchor
+script rides the project's own SSH path. The expiry banner (`shouldWarnExpiry`,
+≤7 days / ≤2 urgent) is raised in *every* view of the project, not just Jobs,
+carries Extend + Workspaces, and is dismissible only until the number changes.
+`hpc_ws_pull_logs` is the **Pull logs** button beside the workspaces caption.
+
+### Phase 3 — only if the split layout is ever wanted
+
+8. **Map a prefix instead of following a link.** Register `data` → an absolute
+   host path in the sync manifest and resolve it in `join_remote`, so walk, push,
+   pull, stat and mkdir all address the workspace directly with no symlink in the
+   path. This is the principled version of "project in `$HOME`, data in the
+   workspace" — it needs no relaxation of G3 (nothing is followed; a registered
+   mapping is consulted), but it threads a mapping through `join_remote`'s call
+   sites, so it is a day of careful work in the sync core plus tests. Worth doing
+   only if putting `.git` on the parallel filesystem turns out to hurt.
+
+## Portability: what this assumes about a cluster
+
+Nothing about any *particular* cluster. The only site values that appear anywhere
+in the feature are inside **test fixtures** (captured sample tooling output); no
+filesystem name, path, hostname or day limit exists in the logic. Concretely, the
+whole thing rests on two *families* and degrades cleanly outside both:
+
+| Layer | Assumed | If absent |
+|-------|---------|-----------|
+| Scheduler | SLURM (`sbatch`/`squeue`/`scancel`/`scontrol`/`srun`) | `slurm_available` is false → the SLURM bar and the Jobs view hide themselves. PBS/LSF/SGE would be a separate backend, not a change here. |
+| Storage | `hpc-workspace` (`ws_allocate`/`ws_list`/`ws_find`/`ws_extend`/`ws_release`) | `hpc_ws_available` is false → the Workspace step falls through to **site-filesystem candidates** (below). |
+| Shell | POSIX `sh` + `mkdir`/`ln`/`date`/`df`/`awk` | These are not optional on a cluster login node. |
+
+Everything variable is *asked*, never assumed:
+
+- **Which filesystems exist** → `ws_list -l` (including which is the default).
+- **How long a workspace may live** → the site caps `ws_allocate`'s duration and
+  its refusal is surfaced verbatim; Eldrun only bounds the input to 1–3650 days
+  so a typo cannot ask for a millennium.
+- **Where a workspace actually is** → `ws_find`, never a path pattern.
+- **What `ws_list` output looks like** → parsed by keyword, with the `ws_find`
+  map as the authority for the one field that matters, so version differences
+  (`available` vs `remaining extensions`, `Id:` blocks or not) do not break it.
+- **Whether `ws_extend` exists** → falls back to `ws_allocate -x` (older tooling).
+
+**Clusters with SLURM but no workspace tooling** — the many sites that instead
+export `$SCRATCH`/`$WORK`/`$PROJECT` or follow a `/scratch/$USER` convention —
+are covered by `hpc_scratch_candidates`: the Workspace step asks the host which
+of those the *site's own profile* exports, reports each with its writability and
+free space, and offers them as the project root beside "home". Without it, such a
+project would land in the browsed folder — i.e. `$HOME` — which is the exact
+failure this whole step exists to prevent. The variable *names* probed are the one
+site-shaped list in the module, and they are only names to ask about; the host
+decides which mean anything.
+
+## What is deliberately not done
+
+- **No site presets.** No cluster hostname, filesystem name or day limit is
+  hardcoded anywhere; the host is asked (`ws_list -l`, `ws_list`) and its own
+  output is parsed. A site that caps 90 days at 30 simply answers 30.
+- **No automatic pull of a workspace.** A workspace can hold terabytes; byte-sync
+  stays opt-in per path (the manifest) and the big-folder census still prices a
+  subtree before it is marked. Making the workspace the root does not change that.
+- **No second host root.** The anchor is not a second project tree — it holds
+  logs, a link and a text file, none of which Eldrun syncs, so no walker, manifest
+  or census needs to learn about two roots.
diff --git a/docs/i18n_translation_plan.md b/docs/i18n_translation_plan.md
new file mode 100644
index 0000000..753472a
--- /dev/null
+++ b/docs/i18n_translation_plan.md
@@ -0,0 +1,278 @@
+# Full app-wide i18n — Implementation Plan (Group N, TODO #92)
+
+> **Status: IN PROGRESS.** Settings dialog + all sub-panels, all of
+> `components/layout/`, all of `components/common/`, and now **all 16 of 16**
+> `.tsx` files in `components/projects/` are fully translated across all 5
+> languages (en/de/es/fr/it). `src/lib/i18n.ts` holds **~1284 keys**, all with
+> parity across every language (verified by the key-count script below).
+> `npx tsc --noEmit` and the full vitest suite (2000+ tests) are green
+> throughout — this doc exists so the remaining files can be picked up in a
+> fresh session without re-deriving the approach.
+
+## Background
+
+The user reported: *"language settings are only changing half of the
+descriptions from one language to another"*. Investigation found the cause:
+Eldrun already has a complete, dependency-free i18n system
+(`src/lib/i18n.ts` — flat `lang → key → text` maps, English as source of
+truth with graceful fallback, a zustand store for live switching, no reload
+needed) but it was wired into only the top-level Settings dialog. Every other
+surface in the app — including the Settings dialog's own sub-panels — had
+hardcoded English strings. The user asked for **complete** app-wide coverage,
+including button text, confirmed after seeing the scale ("keep going through
+all batches").
+
+## What's done
+
+| Batch | Files | Keys added (approx) |
+|---|---|---|
+| Settings dialog + sub-panels | `SettingsPanel.tsx`, `SettingsSubPanels.tsx` | ~350 |
+| `components/layout/` (all 19 `.tsx`) | AppShell, HeaderBar, GlobalAppBar, GlobalAppMenu, ProjectSwitcher, RightPanel, VpnPasswordPrompt, DetachedApp, DetachedCenterPanel, CenterPanel, LocalModelMenu, HowToStart, RemoteFeaturesPrompt, LessonsMenu (LogoIcon/HintHost/TourHost needed no keys — SVG-only / no own text) | ~180 |
+| `components/common/` (all 17 `.tsx`) | TourCoachmark, HintBubble, UntestedTag, VpnTunnelUpNotice, ConnectionLog, FolderPickerDialog, ProjectBlobPane, PageStrip, RemoteUsageWarningDialog, HostKeyConfirmDialog, LocalLossDialog (Dropdown/OrbitSpinner/Toggle/PasswordInput/ConnLamp/TourCoachmark's siblings needed none) | ~112 |
+| `components/projects/` — **16 of 16 done** | ProjectSearch, CategoryEditor, BoxPill, ActivityCalendar, RemotePaneHold, ExtendToRemoteDialog, PythonInterpreterWindow, RemoteFolderBrowser, BigFolderExcludeDialog, **ProjectPill.tsx** (the app's single largest component, ~2000 lines, ~10 sub-dialogs + the full right-click context menu), **RemoteConnectDialog.tsx**, **RemoteMachinesWindow.tsx**, **HpcPipelineWizard.tsx**, **ProjectDialog.tsx**, **RemoteProjectSection.tsx**, **CredentialPasteBar.tsx**, **TerminalSignInToggle.tsx**, **ProjectHoverCard.tsx**, **CarefulHostToggle.tsx** (new file, landed mid-plan by a concurrent session) | ~210 + ~430 |
+
+Total so far: **~1284 keys**, all 5 languages at parity (script below confirms
+this after every batch).
+
+### Notes from finishing `components/projects/`
+- `sshPasteEntries`/`vpnPasteEntries` (`CredentialPasteBar.tsx`) and
+  `statusLabel`/`formatTime`/`formatCpu` (`ProjectHoverCard.tsx`) are pure
+  functions outside any component, so they can't call `useT()` — they now take
+  a `t` translator as their **first parameter**, threaded in from the calling
+  component. `vpnStatusHint` in `RemoteProjectSection.tsx` follows the same
+  pattern. Reuse this shape (`t` as first arg) for any other pure
+  string-building helper the remaining files turn up.
+- `src/__tests__/CredentialPaste.test.tsx` needed updating for the new
+  `sshPasteEntries(t, opts)`/`vpnPasteEntries(t, opts)` signature — it now
+  imports `translate` from `lib/i18n` and builds a fixed `en` `t` locally
+  (`translate("en", key, params)`), since a plain unit test has no React
+  context for `useT()`.
+- `PROVIDER_CLI_INSTALL` moved out of `ProjectDialog.tsx` into
+  `lib/installCommand.ts` by a concurrent session mid-edit — another instance
+  of the known concurrent-editing hazard below; `tsc` stayed clean throughout,
+  confirming compatibility.
+- The i18n key-count script's totals in this doc (and the ones you'll compute
+  next) are a moving target under concurrent editing — always re-run it
+  yourself rather than trusting a stale number here.
+
+## What's left
+
+### Remaining directories (not yet started)
+- `components/header/` (8 files) — `MachinesIndicator.tsx` was mid-edit by
+  the concurrent session; re-check before starting.
+- `components/tabs/` (9 files)
+- `components/calendar/` (8 files)
+- `components/files/` (15 files)
+- `components/embed/` + `embed/deck/` + `embed/pdf/` (28 files)
+- `components/monitoring/` + `components/stats/` (6 files)
+- `App.tsx` + final whole-repo verification pass (this was Task #11 in the
+  original session's todo list — a last grep sweep for anything missed, plus
+  updating `src/lib/i18n.ts`'s own doc comment to say coverage is complete
+  rather than "wired through Settings only").
+
+### Content data files (separate, not yet scoped)
+`src/lib/hints.ts` (contextual hint copy), `src/lib/tour.ts` (guided-tour step
+copy), `src/lib/lessons.ts` (lesson picker copy) hold real UI prose but are
+data files, not components — `HintHost`/`TourHost`/`LessonsMenu` render their
+`title`/`body` fields directly as plain strings. These need their own
+`TranslationKey`-based restructuring (mirroring what was done for
+`HELP_SECTIONS` in `SettingsPanel.tsx` — see that file's `HelpItem`/
+`HelpSection` interfaces for the pattern: store `titleKey`/`descKey` instead
+of raw strings, resolve via `t()` at render time). Not started.
+
+## Methodology (proven across ~860 keys — reuse this exactly)
+
+### 1. Scope a file before reading it
+For files under a few hundred lines, just `Read` the whole thing. For larger
+files, grep first to gauge density and avoid reading dead weight:
+```bash
+grep -cE 'title="[A-Za-z]|aria-label="[A-Za-z]|placeholder="[A-Za-z]|>[A-Z][a-zA-Z ,.…'"'"']{3,60}<' path/to/File.tsx
+```
+This regex misses multi-line JSX text (a paragraph split across lines) and
+template-literal titles (`` title={`...`} ``) — for anything that scores 0
+hits but "feels" like it should have text, read it directly rather than
+trusting the grep.
+
+### 2. Add keys in one batch script per file (or small group of files)
+Keys are added via a Python heredoc that inserts new lines just before each
+language block's closing brace. This was run from the repo root every time:
+```bash
+cd "$(git rev-parse --show-toplevel)" && python3 - <<'PYEOF'
+path = "src/lib/i18n.ts"
+with open(path) as f:
+    content = f.read()
+
+K = {}
+def add(key, en, de, es, fr, it):
+    K[key] = (en, de, es, fr, it)
+
+add("someNamespace.someKey", "English text", "Deutscher Text", "Texto en español", "Texte en français", "Testo in italiano")
+# ... more add() calls ...
+
+langs = ["en", "de", "es", "fr", "it"]
+def block_bounds(name):
+    import re
+    re_start = re.compile(r"const " + name + r"(?::\s*Dict)?\s*=\s*\{")
+    m = re_start.search(content)
+    start = m.end()
+    rest = content[start:]
+    end_marker = rest.find("\n} as const;")
+    end2 = rest.find("\n};")
+    end = end_marker if (end_marker != -1 and (end2 == -1 or end_marker < end2)) else end2
+    return start, start + end
+
+inserts = []
+for name in langs:
+    s, e = block_bounds(name)
+    inserts.append((e, name))
+inserts.sort(key=lambda x: -x[0])  # insert from the end backwards so earlier offsets stay valid
+lang_index = {"en":0, "de":1, "es":2, "fr":3, "it":4}
+for pos, name in inserts:
+    i = lang_index[name]
+    lines = []
+    for key, vals in K.items():
+        val = vals[i].replace('"', '\\"')
+        lines.append(f'  "{key}": "{val}",')
+    insertion = "\n" + "\n".join(lines)
+    content = content[:pos] + insertion + content[pos:]
+
+with open(path, "w") as f:
+    f.write(content)
+print("done", len(K), "keys")
+PYEOF
+```
+Only the **`en` block** is the source-of-truth key set (`TranslationKey =
+keyof typeof en`), but all 5 blocks must get every key or `translate()`'s
+fallback-to-English silently masks a missing translation forever — always
+add to all 5 in the same script.
+
+### 2b. Verify key parity + no duplicates after every batch
+```bash
+node -e '
+const fs = require("fs");
+const src = fs.readFileSync("src/lib/i18n.ts", "utf8");
+function block(name){
+  const re = new RegExp("const "+name+"(?::\\s*Dict)?\\s*=\\s*\\{");
+  const m = re.exec(src);
+  const start = m.index + m[0].length;
+  const rest = src.slice(start);
+  const endMarker = rest.indexOf("\n} as const;");
+  const end2 = rest.indexOf("\n};");
+  const end = endMarker !== -1 && (end2 === -1 || endMarker < end2) ? endMarker : end2;
+  return rest.slice(0, end);
+}
+for (const name of ["en","de","es","fr","it"]) {
+  const chunk = block(name);
+  const keys = [...chunk.matchAll(/"([a-zA-Z0-9_.]+)":/g)].map(m=>m[1]);
+  const seen = new Set(); const dupes=[];
+  for (const k of keys) { if (seen.has(k)) dupes.push(k); seen.add(k); }
+  console.log(name, keys.length, "dupes:", dupes);
+}
+'
+```
+All 5 counts must match and `dupes` must be empty every time.
+
+### 3. Wire the component
+- Import `useT` (and `type TranslationKey` if the file needs a lookup table
+  keyed by some union type — see `GIT_ICON_TITLE_KEY` / `MODEL_ROLES` for the
+  pattern of converting a `Record<X, string>` into a `Record<X, TranslationKey>`
+  and resolving with `t()` at render time).
+- Add `const t = useT();` as the **first line** of every component function
+  that needs it (including small nested dialog/window components defined in
+  the same file — each one needs its own call, hooks don't propagate down
+  through props).
+- For prose with inline `<code>`/`<strong>`/`<em>` markup, split the
+  translation into multiple keys around the markup boundary rather than
+  flattening it to one key — this preserves the visual emphasis in every
+  language. Example pattern used throughout:
+  ```tsx
+  {t("foo.helpPre")} <code>literalToken</code> {t("foo.helpPost")}
+  ```
+  Technical literals inside `<code>` (command names, package names, paths)
+  are **not** translated — only the surrounding prose.
+- For simple pluralization (no ICU in this system — it's flat string keys),
+  add two keys per case (`fooCountOne` / `fooCountMany`) and branch on
+  `count === 1` in the component; pass `{ count }` as the `t()` params object.
+- Reuse existing keys aggressively before adding new ones — `common.cancel`,
+  `common.back`, `common.add`, `common.remove`, `common.delete`,
+  `common.rename`, `common.connect`, `common.close`, `common.next`,
+  `common.saving`/`common.save`, `common.loading`, `common.recheck` all exist
+  and are shared across dozens of call sites. Check `i18n.ts`'s `common.*`
+  block before minting a file-specific synonym.
+- Never translate: product/brand names (`Eldrun`), proper nouns (GitHub,
+  GitLab, Ollama, Docker), file extensions/paths, shell commands, CSS/HTML
+  attribute values, technical unit abbreviations (CPU, GPU, MB) — these stay
+  as literal English/technical strings in every language, matching how the
+  existing Settings-panel translations already treat them.
+
+### 4. Verify after every file (or small batch of files)
+```bash
+npx tsc --noEmit -p .
+```
+Expect **zero new errors** in files you touched. Pre-existing errors from
+concurrent editing elsewhere in the repo (see "Known hazard" below) are not
+yours to fix — note them and move on.
+```bash
+npx vitest run 2>&1 | grep -E "^(PASS|FAIL) \("
+```
+Compare the failure count to the baseline before you started this session's
+batch — new failures are yours to investigate; the same pre-existing count
+is fine to proceed past.
+
+Final sweep per file, to catch anything the initial grep missed:
+```bash
+grep -nE 'title="[A-Za-z]|aria-label="[A-Za-z]|placeholder="[A-Za-z]|>[A-Z][a-zA-Z ,.…'"'"']{3,60}<' path/to/File.tsx | grep -v "aria-hidden"
+```
+Should be empty before moving to the next file.
+
+## Known hazard: concurrent editing in this repo
+
+While this plan was being executed, another session was actively working in
+the **same working tree** on an unrelated feature (a `carefulHost`/
+credential-paste/host-key-confirm/HPC-workspace/deck-presenter cluster of
+work — see the untracked files under `src-tauri/src/commands/`,
+`src/components/embed/deck/`, `src/lib/hostKey.ts`, `src/lib/keyring.ts`,
+`src/stores/pillDrag.ts`, `src/components/projects/CredentialPasteBar.tsx`,
+`src/components/projects/TerminalSignInToggle.tsx`). This caused two kinds of
+noise while translating:
+
+1. **Transient compile errors** in files that concurrent session was
+   mid-editing (`ProjectPill.tsx`'s drag logic, `RemoteConnectDialog.tsx`,
+   `RemoteProjectSection.tsx`, `MachinesIndicator.tsx`, `ProjectDialog.tsx`,
+   `BoxPill.tsx` all showed errors like `Cannot find name 'PILL_DRAG_TYPE'` at
+   various points that were **not** caused by this i18n work and resolved on
+   their own once the concurrent session finished that file). Before
+   concluding an error is yours to fix, check whether the error references
+   symbols/imports you never touched.
+2. **A `git reset --hard` ran twice** during the session (visible in
+   `git reflog`) — apparently the other session's own working-tree cleanup.
+   Both times, re-verification via `git diff HEAD --stat` (not the
+   index-relative `git diff --stat`, which can show a stale/misleading empty
+   result — this caused one false alarm mid-session) confirmed this i18n
+   work's edits survived intact both times. **If a future session sees what
+   looks like lost work, re-check with `git diff HEAD --stat -- <path>` before
+   concluding anything is actually gone** — don't trust a single anomalous
+   read in a repo with concurrent editors.
+
+Before resuming this plan: run `npx tsc --noEmit -p .` first. If it's clean,
+the concurrent work has settled and it's safe to proceed through the
+remaining files including `RemoteConnectDialog.tsx`/`MachinesIndicator.tsx`.
+If not, `git status`/`git log` to see what's mid-flight and route around it
+(work on a different directory first, as this session did).
+
+## Batch order suggestion for the next session
+
+1. Finish `components/projects/` (5 files above) once safe to touch.
+2. `components/header/` (check `MachinesIndicator.tsx` compiles cleanly first).
+3. `components/tabs/`, `components/calendar/`, `components/files/` — smaller,
+   likely no concurrent-edit conflicts.
+4. `components/embed/` + `embed/deck/` + `embed/pdf/` — largest remaining
+   batch (28 files); `embed/deck/` is a newer, less-stable feature (the
+   `deck_presenter_plan.md` work) — sanity-check it's not also mid-refactor.
+5. `components/monitoring/` + `components/stats/`.
+6. `App.tsx`, then the content-data-file restructuring (hints/tour/lessons),
+   then a final whole-repo grep sweep + update `i18n.ts`'s own top-of-file
+   doc comment (it still says "Currently wired through the Settings dialog's
+   main panel" — that sentence should be removed/updated once this plan is
+   fully closed out).
+</content>
diff --git a/docs/light_lavender_palette.svg b/docs/light_lavender_palette.svg
new file mode 100644
index 0000000..2e1ca91
--- /dev/null
+++ b/docs/light_lavender_palette.svg
@@ -0,0 +1,35 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="940" height="800" viewBox="0 0 940 800" font-family="system-ui, -apple-system, Segoe UI, sans-serif">
+  <rect x="0" y="0" width="940" height="800" rx="14" fill="#faf9fe"/>
+  <text x="24" y="38" font-size="22" font-weight="700" fill="#2c2348">Light Lavender — terminal palette</text>
+  <text x="24" y="58" font-size="13" fill="#6a6296">Column: swatch · slot · hex · function (Claude Code ANSI usage)</text>
+
+  <!-- ===== CORE ===== -->
+  <text x="24" y="88" font-size="15" font-weight="700" fill="#7c5cdb">Core (non-ANSI)</text>
+
+  <g transform="translate(0,100)"><rect x="24" width="150" height="26" rx="5" fill="#faf9fe" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">background</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#faf9fe</text><text x="470" y="18" font-size="13" fill="#4a4470">Pane background / canvas</text></g>
+  <g transform="translate(0,130)"><rect x="24" width="150" height="26" rx="5" fill="#2c2348" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">foreground</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#2c2348</text><text x="470" y="18" font-size="13" fill="#4a4470">Default text color</text></g>
+  <g transform="translate(0,160)"><rect x="24" width="150" height="26" rx="5" fill="#7c5cdb" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">cursor</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#7c5cdb</text><text x="470" y="18" font-size="13" fill="#4a4470">Text cursor block</text></g>
+  <g transform="translate(0,190)"><rect x="24" width="150" height="26" rx="5" fill="#faf9fe" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">cursorAccent</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#faf9fe</text><text x="470" y="18" font-size="13" fill="#4a4470">Glyph under the cursor</text></g>
+  <g transform="translate(0,220)"><rect x="24" width="150" height="26" rx="5" fill="#dccff2" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">selectionBackground</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#dccff2</text><text x="470" y="18" font-size="13" fill="#4a4470">Mouse-selection highlight</text></g>
+  <g transform="translate(0,250)"><rect x="24" width="150" height="26" rx="5" fill="#241d38" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">selectionForeground</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#241d38</text><text x="470" y="18" font-size="13" fill="#4a4470">Text inside a selection</text></g>
+
+  <!-- ===== ANSI ===== -->
+  <text x="24" y="300" font-size="15" font-weight="700" fill="#7c5cdb">16 ANSI slots</text>
+
+  <g transform="translate(0,312)"><rect x="24" width="150" height="26" rx="5" fill="#2f2358" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">black (0)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#2f2358</text><text x="470" y="18" font-size="13" fill="#4a4470">Sent-msg block / removed-diff bg</text></g>
+  <g transform="translate(0,342)"><rect x="24" width="150" height="26" rx="5" fill="#d1242f" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">red (1)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#d1242f</text><text x="470" y="18" font-size="13" fill="#4a4470">Errors; − removed text</text></g>
+  <g transform="translate(0,372)"><rect x="24" width="150" height="26" rx="5" fill="#0f5a26" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">green (2)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#0f5a26</text><text x="470" y="18" font-size="13" fill="#4a4470">Success; + added text</text></g>
+  <g transform="translate(0,402)"><rect x="24" width="150" height="26" rx="5" fill="#9a6700" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">yellow (3)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#9a6700</text><text x="470" y="18" font-size="13" fill="#4a4470">Warnings, modified markers</text></g>
+  <g transform="translate(0,432)"><rect x="24" width="150" height="26" rx="5" fill="#0969da" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">blue (4)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#0969da</text><text x="470" y="18" font-size="13" fill="#4a4470">Links, info accents</text></g>
+  <g transform="translate(0,462)"><rect x="24" width="150" height="26" rx="5" fill="#7c5cdb" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">magenta (5)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#7c5cdb</text><text x="470" y="18" font-size="13" fill="#4a4470">Accent — pointers / highlights</text></g>
+  <g transform="translate(0,492)"><rect x="24" width="150" height="26" rx="5" fill="#1b7c83" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">cyan (6)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#1b7c83</text><text x="470" y="18" font-size="13" fill="#4a4470">Secondary info, paths</text></g>
+  <g transform="translate(0,522)"><rect x="24" width="150" height="26" rx="5" fill="#cbc0ec" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">white (7)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#cbc0ec</text><text x="470" y="18" font-size="13" fill="#4a4470">Box borders / dim chrome</text></g>
+  <g transform="translate(0,552)"><rect x="24" width="150" height="26" rx="5" fill="#8878c4" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightBlack (8)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#8878c4</text><text x="470" y="18" font-size="13" fill="#4a4470">Dim prev msgs / added-diff bg / hints</text></g>
+  <g transform="translate(0,582)"><rect x="24" width="150" height="26" rx="5" fill="#cf222e" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightRed (9)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#cf222e</text><text x="470" y="18" font-size="13" fill="#4a4470">Bold errors</text></g>
+  <g transform="translate(0,612)"><rect x="24" width="150" height="26" rx="5" fill="#1c7a39" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightGreen (10)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#1c7a39</text><text x="470" y="18" font-size="13" fill="#4a4470">Bold success / bright added</text></g>
+  <g transform="translate(0,642)"><rect x="24" width="150" height="26" rx="5" fill="#bf8700" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightYellow (11)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#bf8700</text><text x="470" y="18" font-size="13" fill="#4a4470">Bold warnings</text></g>
+  <g transform="translate(0,672)"><rect x="24" width="150" height="26" rx="5" fill="#0550ae" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightBlue (12)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#0550ae</text><text x="470" y="18" font-size="13" fill="#4a4470">Bold links / info</text></g>
+  <g transform="translate(0,702)"><rect x="24" width="150" height="26" rx="5" fill="#b48cf0" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightMagenta (13)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#b48cf0</text><text x="470" y="18" font-size="13" fill="#4a4470">Bright accent</text></g>
+  <g transform="translate(0,732)"><rect x="24" width="150" height="26" rx="5" fill="#3192aa" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightCyan (14)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#3192aa</text><text x="470" y="18" font-size="13" fill="#4a4470">Bright secondary</text></g>
+  <g transform="translate(0,762)"><rect x="24" width="150" height="26" rx="5" fill="#2c2348" stroke="#d8d2e6"/><text x="190" y="18" font-size="13" fill="#2c2348">brightWhite (15)</text><text x="360" y="18" font-size="13" font-family="monospace" fill="#2c2348">#2c2348</text><text x="470" y="18" font-size="13" fill="#4a4470">Brightest text = darkest here</text></g>
+</svg>
diff --git a/docs/light_lavender_theme.md b/docs/light_lavender_theme.md
new file mode 100644
index 0000000..c7c8f7b
--- /dev/null
+++ b/docs/light_lavender_theme.md
@@ -0,0 +1,68 @@
+# Light Lavender theme
+
+A light theme with a lavender accent, plus a matching lavender-tinted terminal
+palette so the xterm agent/shell terminals (and Claude Code's **ANSI theme**)
+read as lavender instead of grey/black.
+
+## Where it lives
+
+| Concern | File |
+|---------|------|
+| App CSS variables (window/panels/pills/accent) | `src/styles/themes.css` — `[data-theme="light_lavender"]` block |
+| Registration in the Settings → Theme picker | `src/types/index.ts` — `Theme` union + `THEMES` array |
+| Terminal (xterm) palette | `src/components/terminal/TerminalView.tsx` — `terminalTheme()` `light_lavender` branch + the pane-background ternary |
+
+Adding/adjusting a theme: see the "HOW TO ADD A THEME" comment at the top of the
+theme blocks in `themes.css`.
+
+## Terminal palette
+
+The terminal does **not** read the CSS variables — it has its own hardcoded
+palette per app theme in `terminalTheme()`. Claude Code, when set to its **ANSI
+theme** (`/theme` inside a Claude tab), maps its UI onto these 16 ANSI colors, so
+tuning a slot here recolors Claude's message blocks, diffs and chrome.
+
+![Light Lavender terminal palette](./light_lavender_palette.svg)
+
+### Core (non-ANSI)
+
+| Slot | Hex | Function |
+|------|-----|----------|
+| `background` | `#faf9fe` | Pane background / canvas |
+| `foreground` | `#2c2348` | Default text color |
+| `cursor` | `#7c5cdb` | Text cursor block |
+| `cursorAccent` | `#faf9fe` | Glyph under the cursor block |
+| `selectionBackground` | `#dccff2` | Mouse-selection highlight |
+| `selectionForeground` | `#241d38` | Text inside a selection |
+
+### 16 ANSI slots
+
+| Slot | Hex | Claude Code usage (inferred) |
+|------|-----|------------------------------|
+| `black` (0) | `#2f2358` | Sent-message block / removed-diff line bg (dark lavender) |
+| `red` (1) | `#d1242f` | Errors; `−` removed text |
+| `green` (2) | `#0f5a26` | Success; `+` added text |
+| `yellow` (3) | `#9a6700` | Warnings, modified markers |
+| `blue` (4) | `#0969da` | Links, info accents |
+| `magenta` (5) | `#7c5cdb` | Accent — pointers / highlights |
+| `cyan` (6) | `#1b7c83` | Secondary info, paths |
+| `white` (7) | `#cbc0ec` | Box borders / dim chrome (light lavender) |
+| `brightBlack` (8) | `#8878c4` | Dim previous messages / added-diff bg / hints |
+| `brightRed` (9) | `#cf222e` | Bold errors |
+| `brightGreen` (10) | `#1c7a39` | Bold success / bright added |
+| `brightYellow` (11) | `#bf8700` | Bold warnings |
+| `brightBlue` (12) | `#0550ae` | Bold links / info |
+| `brightMagenta` (13) | `#b48cf0` | Bright accent |
+| `brightCyan` (14) | `#3192aa` | Bright secondary |
+| `brightWhite` (15) | `#2c2348` | Brightest text = darkest / max-contrast here |
+
+### Notes
+
+- Slots are **shared**: e.g. `green` colors both diff-added text *and* every
+  success message; `black` is both the sent-message block *and* actual black
+  output. Tuning a slot for one purpose affects the others.
+- The neutral ramp `black → brightBlack → white` is a deliberately wide lavender
+  gradient (dark → mid → light) so Claude's emphasized vs dimmed message blocks
+  and diff line backgrounds are easy to tell apart.
+- Claude Code's **truecolor** themes ignore this palette entirely; only its ANSI
+  theme honors it.
diff --git a/docs/mountfree_remote_plan.md b/docs/mountfree_remote_plan.md
new file mode 100644
index 0000000..e114981
--- /dev/null
+++ b/docs/mountfree_remote_plan.md
@@ -0,0 +1,221 @@
+# Mount-Free Remote Projects — Implementation Plan
+
+Status: **implemented** (Phases 0–5 / #28e–#28j landed). Supersedes the
+sshfs-based remote model from `docs/ssh_projects_plan.md` (Group G #28). sshfs is
+**removed entirely** — there is no coexistence mode. Remote projects are now
+SSH/SFTP-native: agent tabs over `ssh -tt`, file browse/I-O over SFTP, git on the
+host over SSH, all riding one pooled ControlMaster + `Sftp` session per active
+remote project. See the per-phase notes below; runtime QA against a live key-auth
+host is still hand-checked (agents can't launch Eldrun).
+
+## Goal
+
+Run a remote (SSH) project — agent tabs, file browsing, file create/edit/
+download, and git — **without** a local FUSE mount. Remote projects become
+SSH/SFTP-native:
+
+- **Agent/terminal tabs** run on the host over `ssh -tt` (already the mechanism).
+- **File browsing** lists directories over SFTP.
+- **File I/O** (read/create/edit/delete/download) goes over SFTP.
+- **Git** runs on the host over SSH (`ssh host 'cd <path> && git …'`).
+
+Motivation: drop the FUSE dependency (`sshfs` on Linux, macFUSE on macOS,
+SSHFS-Win on Windows) — install friction, kernel-extension approval (macOS), and
+stale/hung-mount lifecycle bugs all disappear.
+
+Decisions (locked):
+- **Fully replace sshfs** — no mount, no coexistence.
+- **Git runs over SSH** for remote projects (keep the status/history/commit/push
+  UI; re-route its execution to the host).
+
+## The keystone: explicit remoteness
+
+Today "is this project remote?" is inferred from the filesystem: a cwd under
+`ssh_mount::mounts_root()` ⇒ remote (`services/ssh_exec.rs:297` `project_id_from_cwd`,
+`wrap_pty_options:262`). Every remote behavior hangs off that mount path. With no
+mount, that signal is gone, so the **first and load-bearing change** is to make
+remoteness explicit and carry it through every file/git/terminal command.
+
+New backend resolver (single source of truth):
+
+```rust
+// e.g. services/remote.rs
+pub struct RemoteTarget { pub spec: RemoteSpec, pub project_id: String }
+
+/// Some(target) iff the project has a `remote` spec; None for local projects.
+pub fn remote_target_for(project_id: &str) -> Option<RemoteTarget>;
+```
+
+Command surface shift: file/git/terminal commands stop receiving a raw
+`project_dir` *local path* and instead receive a **`project_id` + `rel_path`**
+(path relative to the project root). Each command resolves:
+
+- local project → `directory` + `rel_path` on the local fs (unchanged);
+- remote project → `spec.remote_path` + `rel_path` over SFTP/SSH.
+
+`RemoteSpec` is unchanged structurally (`user?`, `host`, `port?`, `remote_path`,
+`openvpn?`). What changes is the **meaning of `Project.directory`** for remote
+projects: it is no longer a real local mountpoint. It becomes a non-fs display
+value (e.g. `ssh://user@host/remote_path`) that the fs layer never touches.
+Update the doc-comment on `schema/project.rs:71-73` accordingly.
+
+## Connection model (Phase 0 — do this first)
+
+A live file tree and viewers make many small calls; `services/sftp.rs` currently
+spawns a fresh `ssh -s sftp` child **per call** (`open_session`, fine for the
+one-shot dialog, far too slow for interactive use). And without a single shared
+SSH connection the user would re-authenticate for SFTP, agent tabs, and git
+separately.
+
+Design: **one ControlMaster per active remote project, reused by everything.**
+
+- On project activation, open a persistent SSH ControlMaster socket (the
+  `control_dir()` machinery already exists in `ssh_exec.rs`). Auth happens
+  **once** here: key/agent under `BatchMode=yes`, or — per the no-stored-password
+  rule — a one-time password prompt fed to the master via `SSHPASS`
+  (`sshpass -e`), never persisted, never on argv.
+- Hold a **persistent `Sftp` session** per active remote project (one
+  `ssh -s sftp` riding the same ControlMaster), pooled in app state and reused
+  across `list_dir`/read/write calls. Open on activate, close on deactivate.
+- Agent tabs (`ssh -tt`) and git-over-ssh both reuse the same ControlMaster
+  socket → no extra auth, fast channel setup.
+
+This phase is the linchpin for *both* performance and single-sign-on; everything
+else builds on it.
+
+## Phases
+
+Ordered so each is independently shippable and testable. Phase 1 alone delivers
+the stated main goal (remote agent tabs).
+
+### Phase 0 — Explicit remoteness + pooled connection
+- Add `services/remote.rs`: `remote_target_for(project_id)` + a pooled
+  `Sftp`/ControlMaster registry in Tauri-managed state.
+- Define how `project_id` + `rel_path` flow from the frontend into commands
+  (new param shape; keep local path resolution identical for local projects).
+- Auth-once on activation; teardown on deactivation/exit.
+- **No user-visible behavior change yet** beyond the connection being held open.
+
+### Phase 1 — Remote agent tabs *(main goal; smallest lift)*
+- `services/ssh_exec.rs`: replace `project_id_from_cwd`-based detection in
+  `wrap_pty_options` with the explicit `RemoteTarget`. Pass the project id (and
+  resolved remote spec) through `PtyOptions` from `commands/terminal.rs` →
+  `terminal/mod.rs` rather than sniffing the cwd.
+- Remote cwd becomes `spec.remote_path` (+ optional subdir from the tab), not a
+  mountpoint. `remote_command` already `cd`s into the target.
+- Verify agent-resume (`services/remote_agents.rs`, `services/agent_session.rs`)
+  makes no mountpoint assumptions; the `ELDRUN_TAB_UID` keying is unaffected.
+- **Exit criteria:** open a remote project with no mount → Claude/Codex agent
+  tab connects over `ssh -tt`, runs on the host, resizes/exits correctly.
+
+### Phase 2 — Live remote file browsing
+- Make directory listing project-aware: remote → pooled `sftp::list_dir`,
+  local → `fs::read_dir` (today `commands/fs.rs:48 list_dir`).
+- `src/components/files/FileTree.tsx` (`invoke("list_dir", …)` at ~326) and
+  `FileBrowser.tsx`: pass `projectId` + `relPath`; render SFTP entries (which
+  already carry real file-type metadata).
+- fs-watch: inotify can't see the remote tree. Drop live-watch for remote
+  projects; add an explicit refresh control (optional: periodic SFTP re-list as a
+  later enhancement). `commands/fs_watch.rs` no-ops for remote projects.
+- **Exit criteria:** the live file tree of a remote project lists/expands remote
+  dirs with no mount.
+
+### Phase 3 — Remote file I/O (create / edit / download / delete)
+- Extend `services/sftp.rs` with the write half (the `openssh-sftp-client` crate
+  already supports these; only reads are wired today): `read_file`,
+  `write_file`, `create_file`, `mkdir`, `remove_file`, `remove_dir`, `rename`,
+  and `metadata`/mtime. Add `download(rel_path, dest_local)` (SFTP get into the
+  per-project downloads dir) and optionally `upload`.
+- Route `commands/fs.rs` ops to the remote path for remote projects:
+  `create_file` (179), `write_project_file_bytes` (213), `delete_file` (150),
+  reads, and mtime. Either dispatch inside the existing commands via
+  `remote_target_for`, or add remote-specific commands the frontend selects.
+- In-app viewers need bytes: `embed/FileViewerPane.tsx` / `stores/linkRouting.ts`
+  fetch file contents over SFTP for remote projects (PDF/image/markdown/code).
+  Large files over a slow link will be noticeably slower — acceptable.
+- `commands/downloads.rs`: define remote-project download routing (SFTP get →
+  local downloads dir, or write into the remote dir).
+- **Exit criteria:** create, edit+save, view, delete, and download a remote file
+  with no mount.
+
+### Phase 4 — Git over SSH
+- Factor `commands/git.rs` so every invocation goes through one helper:
+  `run_git(target, args)` where `target` is local or remote.
+  - local → `command_no_window("git").current_dir(dir)` (unchanged; keeps the
+    Windows no-console behavior noted at `git.rs:4-9`).
+  - remote → `ssh_exec::remote_command("cd <remote_path> && git <args>")` over the
+    shared ControlMaster. Output parsing is byte-for-byte identical (text is
+    text), so `git_status`, history, diff, commit, push reuse their parsers.
+- Push uses the **remote host's** git credentials/SSH keys, not the local box.
+  Note interaction with `commands/git_publish.rs` (gh/glab) — that's the push
+  axis and may need a remote variant or be deferred.
+- **Exit criteria:** git status/history/commit/push in the right panel work on a
+  remote project, executed on the host.
+
+### Phase 5 — Remove sshfs
+- Delete `services/ssh_mount.rs` and everything mount-specific:
+  `ensure_project_mounted` (`commands/ssh.rs`), `ensure_remote_mounted`
+  (`services/project_runtime.rs`), `mounts_root`/`mountpoint_for`/`unmount_all`,
+  the `mounts/` path in `paths.rs`, and the `RunEvent::Exit` unmount hook in
+  `lib.rs`.
+- Frontend: remove the `ensure_project_mounted` startup/switch calls in
+  `src/stores/projects.ts`.
+- `services/sftp.rs` currently imports `validate_arg`/`ssh_base_args`/
+  `ssh_password_base_args`/`sshpass_available` from `ssh_mount`; relocate those
+  shared helpers (e.g. into `services/ssh_exec.rs` or a small `ssh_common.rs`)
+  before deleting `ssh_mount.rs`.
+- Migration for existing remote projects: their persisted `directory` is a stale
+  mountpoint. On load, ignore it for fs purposes and drive everything from the
+  `remote` spec; best-effort clean up any leftover `mounts/<id>` on first run.
+- Docs/build: strip `sshfs`/FUSE from `CLAUDE.md` (Persistence section), the
+  packaging/runtime notes, and any install hints. Update
+  `docs/ssh_projects_plan.md` to point here.
+
+## Cross-cutting concerns
+
+- **Single authentication.** SFTP + agent tabs + git-over-ssh MUST share one
+  ControlMaster per project or the user is prompted up to 3×. Phase 0 owns this.
+  Password mode prompts once and feeds the master via `SSHPASS`; channels reuse
+  it. No password is ever stored (existing rule).
+- **No page cache.** Every read is a network round-trip. Mitigations: the pooled
+  SFTP session, lazy tree expansion, and only fetching file bytes on open. A
+  small in-memory LRU for recently-read files is a possible later enhancement.
+- **Latency / offline.** An unreachable host must fail fast (ConnectTimeout) and
+  never wedge the UI — same posture as today's startup mount. The file tree
+  should surface a clear "disconnected" state rather than hang.
+- **OpenVPN.** Unchanged: bring the tunnel up before opening the ControlMaster
+  (`RemoteSpec.openvpn`); password prompted at activation, never stored.
+- **Security.** SFTP path components are protocol fields, not shell tokens (the
+  injection-safety property `sftp.rs` already documents). Git-over-ssh embeds the
+  remote path in a remote `$SHELL -c` string, so it MUST go through the existing
+  `shell_quote`/`validate_arg` defenses in `ssh_exec.rs`.
+
+## Testing
+
+- Per-phase `cargo test --manifest-path src-tauri/Cargo.toml` + `npx tsc --noEmit`.
+- New unit tests: SFTP write/path-join helpers (pure parts, no live host);
+  `run_git` local-vs-remote argv construction; `remote_target_for` resolution.
+- Runtime QA is hand-checked against a real key-auth host (agents can't launch
+  Eldrun). Adapt the existing Group G Phase 1–8 manual checklist, dropping all
+  mount/`/proc/mounts` steps and adding: file tree lists over SFTP; create/edit/
+  download a remote file; git status/commit/push runs on the host; single auth
+  prompt across tab+browse+git.
+
+## Proposed TODO tracking
+
+New Group G sub-items under #28 (work-axis theme):
+
+- **#28e — Mount-free remote: explicit remoteness + pooled SSH/SFTP** (Phase 0).
+- **#28f — Mount-free remote agent tabs** (Phase 1).
+- **#28g — Live remote file browsing over SFTP** (Phase 2).
+- **#28h — Remote file I/O (create/edit/download/delete) over SFTP** (Phase 3).
+- **#28i — Git over SSH for remote projects** (Phase 4).
+- **#28j — Remove sshfs** (Phase 5).
+
+## Out of scope (for now)
+
+- Periodic/push-based remote fs change notification (manual refresh only at
+  first).
+- `git_publish` (gh/glab) remote-host variant.
+- Read-cache/LRU for remote file bytes.
+- Windows/macOS-specific remote tuning beyond what the shared SSH path gives.
diff --git a/docs/multi_host_remote_plan.md b/docs/multi_host_remote_plan.md
new file mode 100644
index 0000000..88158e1
--- /dev/null
+++ b/docs/multi_host_remote_plan.md
@@ -0,0 +1,418 @@
+# Multi-Host Remote Projects — Plan (experiment-worker model)
+
+**Goal.** Let one remote project reach **N** remote machines, not just one, so the
+**same code** can be run as experiments across several hosts (e.g. different GPU
+boxes). A tab's `local / remote` toggle becomes a **list**:
+`local | primary | gpu-2 | gpu-3 …`.
+
+**Model (decided).**
+- **One primary host, N extra "worker" hosts.** The primary stays exactly as
+  today: it owns files, git, the local mirror, and full bidirectional sync. Extra
+  hosts are **experiment workers**.
+- **Extra hosts stay in sync with the canonical code — one-way.** Code (git-tracked
+  files) is pushed *source → each extra*; it is never pulled back. So all machines
+  run the same commit.
+- **Files on extra hosts are read-only.** You never *edit* on a worker; the UI
+  offers no write there, and a re-sync overwrites any drift. This is precisely what
+  lets the sync be one-way: with no edits on the workers, there is **no merge
+  conflict, no divergence, and no destructive local-loss** — the entire scary half
+  of the existing lockstep machinery is dodged.
+- **Experiments still write their outputs.** "Read-only" means *code* is read-only,
+  **not** the filesystem. A run writes checkpoints / logs / metrics freely; the sync
+  never touches untracked/gitignored paths (it does `fetch + reset --hard` but
+  **never** `git clean`), so outputs survive every sync.
+- **Outputs stay on each worker, pulled on demand** (recommended default; §4.4).
+  Auto-pulling multi-GB checkpoints from N machines is the byte-sync-scope footgun
+  CLAUDE.md already warns about, so it is opt-in per machine.
+- **Per-host lamps, on-demand connect.** Each host has its own connection lamp in
+  the pill. Auto-connect is an opt-in per host.
+
+**Two load-bearing insights.**
+1. **The bidirectional subsystem is untouched.** Everything that owns the primary's
+   files/git/sync — `services/git_peer.rs` (~200 KB), `remote_sync.rs`,
+   `sync_auto.rs`, all of `commands/fs.rs` + `commands/git.rs` + `commands/sync.rs`
+   — resolves *the* host through `remote_target_for(project_id)` /
+   `remote_target_for_dir(project_dir)`, both reading the single `extra["remote"]`.
+   Store extra hosts under a **separate** key (`extra["compute_hosts"]`) and that
+   whole subsystem keeps meaning "the primary" with zero change.
+2. **Worker sync is push-only, so it inherits none of the hard parts.** The
+   existing lockstep is bidirectional (pull, divergence, conflict, local-loss
+   auditing). The worker fan-out reuses only the *outbound* primitives —
+   bundle-create + apply — and never the inbound half. It is a new, deliberately
+   thin push-only path, not a second full lockstep.
+
+---
+
+## 1. Data model
+
+### 1.1 Backend — `schema/project.rs`
+
+An extra host is a `RemoteSpec` + a stable id + a display label. Reusing
+`RemoteSpec` verbatim means every existing execution helper (`ssh_exec`, `sftp`,
+`remote_usage`, monitor/disk/gpu/python) works unchanged — they already take
+`&RemoteSpec`.
+
+```rust
+/// An additional SSH machine a project runs experiments on. Its code is kept in
+/// one-way sync from the canonical source (the local mirror); its files are
+/// read-only (edits forbidden). It never owns git/sync/mirror state of its own —
+/// the primary `remote` does. `id` is stable (referenced by tab locations + the
+/// pool key + the fan-out state); `label` is the pill/tab display name.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComputeHost {
+    pub id: String,                 // stable, e.g. "h1"; primary is implicit "primary"
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,      // "gpu-2"; falls back to host
+    /// Keep this worker's tracked tree synced to the source HEAD (default true).
+    #[serde(default = "default_true")]
+    pub sync_code: bool,
+    /// Pull this worker's experiment OUTPUTS back on demand only, never
+    /// automatically (default false — outputs stay on the worker).
+    #[serde(default)]
+    pub pull_outputs: bool,
+    #[serde(flatten)]
+    pub spec: RemoteSpec,           // user/host/port/remote_path/openvpn/auto_connect/key_auth
+}
+```
+
+Add to `Project`:
+
+```rust
+#[serde(default, skip_serializing_if = "Vec::is_empty")]
+pub compute_hosts: Vec<ComputeHost>,
+```
+
+**Migration: none.** Existing projects have no `compute_hosts`; `#[serde(default)]`
+yields `[]`. The primary is still `Project.remote`, unchanged.
+
+### 1.2 Mirroring into `projects.json` — `commands/projects.rs`
+
+`project_extra(...)` (~`:2352`) mirrors `remote` + `mirror` into the always-local
+`projects.json` entry so resolvers stay synchronous. Add a mirror of
+`compute_hosts` under `extra["compute_hosts"]` (array). That is the only place
+workers need to reach the local `projects.json`; every resolver below reads it.
+
+New host CRUD commands (mirror the existing `patch_remote_spec` at `:851`):
+- `add_compute_host(project_id, ComputeHost)` — append + write `project.json`
+  **and** `extra["compute_hosts"]`, minting `id` if absent.
+- `remove_compute_host(project_id, host_id)` — disconnect it, stop its fan-out,
+  then drop it.
+- `patch_compute_host(project_id, host_id, patch)` — for `auto_connect` /
+  `key_auth` / `openvpn` / `sync_code` / `pull_outputs`.
+
+### 1.3 Frontend — `types/index.ts`
+
+```ts
+export interface ComputeHost extends RemoteSpec { id: string; label?: string; sync_code?: boolean; pull_outputs?: boolean; }
+export interface ProjectEntry { /* … */ remote?: RemoteSpec; compute_hosts?: ComputeHost[]; }
+```
+
+---
+
+## 2. Worker code sync — one-way, code-only (the heart of this change)
+
+**Canonical source = the local mirror.** It is already lockstep-paired with the
+primary (`git_peer`), so the local mirror always holds the project's current
+committed code. The workers are fed **from the mirror**, one-way. (Feeding from the
+mirror, not primary→worker directly, means Eldrun — which already holds SSH to both
+legs — is the courier; it assumes no primary↔worker network path or shared keys.)
+
+**Direction & grain.**
+- Source → worker only. A worker's tree is **never** read back into the mirror
+  (that is what makes it conflict-free).
+- Tracked files only. The push makes the worker's tracked tree equal the source
+  HEAD; untracked/gitignored paths (experiment outputs, datasets staged on the
+  worker) are left alone.
+
+**Mechanism (reuses `git_peer` outbound primitives; a new push-only mode).**
+Per worker, first sync bootstraps a bare-ish working clone at `worker:remote_path`
+(git init + fetch, or clone from a bundle Eldrun ships over SFTP — same
+`remote_bundle_path` + apply primitives lockstep uses local↔primary). Each
+subsequent sync:
+1. On the mirror, `git bundle` the current HEAD (or an incremental bundle since the
+   worker's last-known head).
+2. Ship the bundle to `worker:remote_path/.git/eldrun-worker.bundle` over SFTP.
+3. On the worker: `git fetch` the bundle, then `git checkout -f <HEAD>` /
+   `reset --hard <HEAD>` — **tracked files only**.
+4. **Never `git clean`.** Untracked outputs survive by construction. (Contrast: the
+   primary's lockstep *does* clean in some refused-FF cases and audits the loss;
+   the worker path deliberately never does, because a worker holds irreplaceable
+   run outputs, not a recoverable mirror.)
+
+**Per-worker state.** A tiny `worker_sync.json` under the worker's slot in the
+project state dir records its `last_head` (the commit last pushed) so an
+incremental bundle is cheap. No manifest, no byte-walk — code is git, and git
+already knows what changed.
+
+**Triggers.**
+- On worker **connect** (bring it up to the current HEAD).
+- On a new **commit** to the mirror/primary (the same signal `git_peer` already
+  watches via the `.git` watcher) → fan out to every connected, `sync_code`
+  worker.
+- Manual **"Push code to machines"** action in the pill.
+
+Because the primary already commits-then-syncs (lockstep is commit-gated), a worker
+receives an edit at the same moment the primary does: **on commit**, not on save.
+This is the identical mental model the primary already has (CLAUDE.md,
+`git_lockstep_case_matrix.md` #5/#7) — extended to N workers.
+
+**Reusing infrastructure vs. new code.** New: a `WorkerSyncRegistry` (per
+`(project, host)`), the push-only fan-out loop, `worker_sync.json`,
+`fetch + reset` (no clean) on the worker. Reused unchanged: bundle create/ship
+primitives in `git_peer`, the `.git` commit watcher, `run_git_remote` /
+`run_remote_script` over the worker's ControlMaster.
+
+---
+
+## 3. Connection layer
+
+### 3.1 Already N-host-safe (no change)
+
+- **ControlMaster sockets** are `cm-%C`, hashed per user/host/port
+  (`ssh_exec.rs:63-70`, `ssh_common.rs:88`). Two hosts → two sockets, free.
+- **Keychain credentials** keyed by host target `ssh:user@host:port`
+  (`remote_credentials.rs:28`) — each worker saves its own password, no collision.
+- **VPN** machine-wide, config-keyed, holder-refcounted (`vpnStatus.ts`,
+  `openvpn.rs`). A worker on a different tunnel just adds a holder/config.
+
+### 3.2 Pool — `services/remote.rs`
+
+Re-key `RemotePool.conns` from `HashMap<project_id, _>` to a composite key:
+
+```rust
+fn conn_key(project_id: &str, host_id: &str) -> String { format!("{project_id}\u{1}{host_id}") }
+```
+
+- `connect(pool, project_id, host_id, password)` — resolve the spec: `"primary"` →
+  `remote_target_for` (unchanged), else the `compute_hosts` entry. **Only the
+  primary touches the mirror** (`mirror_dir` at `:166` stays behind the primary
+  branch).
+- `disconnect` / `is_connected` / `pooled_sftp` thread `host_id`. File/git/sync
+  callers pass the constant `"primary"` (they *are* the primary subsystem).
+- `connected_ids` → `connected_targets -> Vec<(project_id, host_id)>`.
+
+### 3.3 Connect / disconnect commands — `commands/remote.rs`
+
+- `remote_connect(…, project_id, host_id: Option<String>, password)` (default
+  `"primary"`). Primary connect keeps wiring `git_peer` + `sync_auto` (`:73-90`).
+  A **worker** connect instead kicks the **worker code-sync** fan-out (§2) and
+  skips byte-sync/lockstep.
+- `remote_disconnect(…, project_id, host_id)` — primary stops git_peer + sync_auto;
+  a worker stops only its fan-out + pool entry.
+
+### 3.4 Traffic accounting — `services/net_usage.rs` (phase 3, optional)
+
+Sum all of a project's hosts under the project bucket initially (keeps the existing
+per-project shape); per-`(project,host)` buckets can come later.
+
+---
+
+## 4. Frontend
+
+### 4.1 Tab location — `stores/tabs.ts`
+
+```ts
+export type TabLocation = "local" | "remote" | `host:${string}`;  // local | primary | worker id
+```
+
+- `remoteHostIdOf(loc)` → `"primary"` for `"remote"`, the id for `"host:<id>"`,
+  `null` for `"local"`.
+- `defaultLocationForKind` (`:3596`) unchanged; `localTabCwd` (`:3627`) unchanged
+  (only `"local"` uses the mirror; a worker locality returns `fallback`).
+- `SavedTabEntry.location` (`:368`) is already a string → new values round-trip. A
+  location naming a deleted host falls back to `"remote"` on load.
+
+### 4.2 PTY spawn — backend
+
+- `PtyOptions` (`terminal/mod.rs:36`): add
+  `#[serde(default)] pub remote_host_id: Option<String>`.
+- `wrap_pty_options` (`ssh_exec.rs:472`): resolve the spec by host id — primary via
+  `remote_target_for` (unchanged), else the worker spec; `remote_dir =
+  spec.remote_path`; `ssh_pty_args(&spec, cmd)` as today.
+- `commands/terminal.rs:141` passes `opts.remote_host_id`; `TerminalView.tsx:29`
+  passes it from `remoteHostIdOf(tab location)`.
+
+### 4.3 Connection state + pill — `stores/remoteStatus.ts`, `RemoteConnMenu.tsx`
+
+- `byProject: Record<projectId, Record<hostId, { ssh; vpn }>>`; `setSsh/​setVpn`
+  gain `hostId`; add `sshOf(projectId, "primary")` so untouched readers change in
+  one line. `clear(projectId)` wipes all hosts; add `clearHost`.
+- Pill shows **one lamp per host** (primary + each worker). Clicking a lamp opens
+  the connect flow for that host. `connectDialog` opens with `{ projectId, hostId }`
+  (default `"primary"`); `RemoteConnectDialog` / `useRemoteReconnect` parametrize by
+  `hostId` (their `liveTerms`, `pendingRemotePassword`, lamp reads become
+  `(projectId, hostId)`-keyed).
+
+### 4.4 Managing workers + outputs — pill
+
+A "Remote machines…" section lists hosts with **Add machine** (reuses
+`RemoteProjectSection` / `useRemoteSession` to collect user/host/port/remote_path +
+optional VPN → `add_compute_host`) and per-worker controls:
+- **Sync code now** (manual fan-out trigger) and a "last synced: <commit>" line.
+- **Pull outputs…** — a one-shot, on-demand pull of the worker's *untracked* output
+  paths into a local `outputs/<host-label>/` folder (never automatic). This is the
+  one place worker→local bytes ever move, and it is user-initiated. The
+  `sync_auto_preview`-style size-confirm applies (a checkpoint dir can be huge).
+- Toggles: `sync_code` (default on), `pull_outputs`-on-demand-only (default), and
+  auto-connect.
+
+### 4.5 Tab UI
+
+- **TabBar badge** (`TabBar.tsx:1156`): the 2-state `local↔remote` toggle becomes a
+  small menu (`Local`, `Primary (host)`, each worker label) → `setTabLocation`.
+- **Hold gate** (`CenterPanel.tsx:976`): read the lamp of *the tab's* host
+  (`remoteHostIdOf`), not the single project lamp — a pane on gpu-2 holds iff gpu-2
+  is down, independent of the primary. `remoteHost` label = that host's label.
+- **TabHoverCard** / **RemotePaneHold** show the target host's label.
+
+### 4.6 Read-only enforcement on workers
+
+Workers never expose an editing surface:
+- No worker file tree/git/source-switch (the file UI stays `Local | Remote(primary)`
+  — §6). If a *read-only* worker file browser is ever wanted, it is a later,
+  separate SFTP-read view; not in scope here.
+- Any code drift on a worker is silently overwritten by the next `reset --hard`
+  (§2) — which is safe *because* editing is forbidden, so drift can only be
+  accidental, and outputs (untracked) are never in `reset`'s path.
+
+---
+
+## 5. Monitoring per worker
+
+`system_monitor_snapshot` (`monitor.rs:25`), `disk_usage_scan` (`disk_usage.rs:66`),
+the remote GPU snapshot (`sysstat::REMOTE_SNAPSHOT_SCRIPT`), and the python probe
+(`python.rs:389`) each already resolve *a* spec from `project_id`; add an optional
+`host_id` that selects the worker (primary when absent). The monitor / disk panes
+gain a host selector; a run tab on gpu-2 probes gpu-2's interpreter.
+
+---
+
+## 6. Explicitly NOT changing
+
+- `remote_target_for` / `remote_target_for_dir` / `RemoteTarget` stay
+  **primary-only**. All file/git/sync keeps calling them.
+- `git_peer.rs` (bidirectional lockstep), `remote_sync.rs`, `sync_auto.rs`,
+  `local_loss.rs`, the mirror, `commands/fs.rs` / `git.rs` / `sync.rs` — the
+  primary path is **untouched**. The worker fan-out (§2) is *new, additive,
+  push-only* code that reuses their bundle primitives.
+- File tree / file-source switch / `fileSourcePref` stay `Local | Remote(primary)`.
+
+---
+
+## 7. Phasing & tests
+
+**Phase 1 — connect to N workers + run tabs on them.**
+Schema `ComputeHost` + `compute_hosts` + `projects.json` mirror + CRUD (§1); pool
+composite key (§3.2); `TabLocation` `host:<id>` + `PtyOptions.remote_host_id` +
+`wrap_pty_options` resolve + TerminalView (§4.1-4.2); `remoteStatus` re-key +
+per-host lamps + connect-dialog `hostId` + TabBar badge menu (§4.3-4.5).
+Rust tests: two hosts one project — independent connect/disconnect/`is_connected`;
+`conn_key` uniqueness; `wrap_pty_options` builds `ssh` args to a worker; primary
+path unchanged (extend `remote.rs` tests at `:315`).
+
+**Phase 2 — worker code sync (§2).**
+Push-only fan-out (bundle → ship → `fetch`+`reset --hard`, no clean),
+`worker_sync.json`, commit-watch + connect + manual triggers, "last synced" UI.
+Rust tests (drive like `examples/lockstep_drv.rs`): a commit on the mirror reaches
+the worker's tracked tree; an untracked output file on the worker **survives** a
+sync; a worker-side code edit is overwritten; sync is never triggered
+worker→mirror.
+
+**Phase 3 — outputs + monitoring + polish.**
+On-demand **Pull outputs** with size-confirm (§4.4); per-worker monitoring (§5);
+per-worker auto-connect; per-host net_usage; stale-host-id fallback.
+
+**Live QA (hand to user — I can't launch Eldrun):** add gpu-2; connect it while the
+primary stays down; open a shell + a Claude tab on gpu-2, confirm `hostname`;
+commit on the primary and confirm the change appears on gpu-2's tracked tree;
+create an output file on gpu-2, sync again, confirm it survives; try to edit a
+tracked file on gpu-2 and confirm the next sync reverts it; confirm the primary's
+file tree / git / sync are visibly unaffected; disconnect gpu-2 and confirm only
+its panes hold.
+
+## 8. Risks / edge cases
+
+- **"Read-only" ≠ read-only filesystem.** The single most important invariant:
+  the worker sync must **never `git clean`** and never touch untracked paths, or it
+  eats experiment output. Enforced in §2 step 4 and tested in Phase 2.
+- **Output pull-back is the only worker→local byte path** and is user-initiated +
+  size-confirmed (§4.4) — never a background pass.
+- **Uncommitted local edits don't reach workers.** Same commit-gated model as the
+  primary (a worker gets code on commit, not on save). Document, as CLAUDE.md does
+  for the primary.
+- **Tab location naming a deleted worker** → fall back to primary (§4.1).
+- **VPN**: a worker sharing the primary's config is free (refcount); a worker
+  needing a *different* `redirect-gateway` config is a machine-wide routing
+  conflict the existing `VpnIndicator` already surfaces — note it in the add-host
+  UI, no new mechanism.
+- **Agent resume on a worker** works (spec-agnostic `ssh -tt` + `ELDRUN_TAB_UID`),
+  but moving a tab worker→primary respawns it on the primary as a fresh
+  conversation — the same caveat the current local↔remote switch has. Document.
+- **First-worker connectivity assumption**: Eldrun couriers code mirror→worker, so
+  it needs SSH to the worker (it already does, to run tabs) but **no** primary↔worker
+  path — deliberately, since workers are often on isolated cluster networks.
+
+---
+
+## 8b. Shared-filesystem workers (added 2026-07-19, now the default)
+
+Many clusters give the login node (primary) and every compute node a **shared
+filesystem** — the same project folder is visible on all of them at one path. Copying
+the code to each worker and one-way syncing it is then pure waste: the worker already
+*is* looking at the primary's tree. So a worker gains a `shared_fs` flag
+(`schema::project::ComputeHost.shared_fs`), and **a newly added machine defaults to it**
+(the schema default stays `false` for back-compat — existing synced workers are
+untouched on load — but the "Add machine" form ticks it on; "Sync a copy" is the opt-out
+into the §2 synced-copy worker, for hosts that don't share storage).
+
+- **What it does.** Nothing is copied and **git never runs on the host**. A tab on a
+  shared-fs worker just `cd`s into `spec.remote_path` (the project folder as visible on
+  that machine) and runs there — the process executes *on the worker*, reading/writing the
+  shared tree. `wrap_pty_options` already resolves the spec by host id and uses
+  `spec.remote_path`, so tab spawn needed **no** change.
+- **The load-bearing safety invariant.** The §2 push (`git init` + `fetch` +
+  `reset --hard`) must **never** fire on a shared-fs host — that path IS the primary's
+  real working tree, and a `reset --hard` there would clobber the primary's state. Three
+  guards enforce it: (1) `remote_connect` skips `on_worker_connect` for a shared host;
+  (2) `fan_out` filters through the pure `wants_code_fanout(host) = !shared_fs && sync_code`
+  (unit-tested); (3) `sync_worker` itself early-returns a no-op skip for a shared host, so
+  even a stray manual `worker_sync_now` is harmless.
+- **No Sync / Pull outputs.** A shared-fs worker's outputs land in the primary's own
+  folder (moved by the primary's ordinary sync), so "Sync code now" / "Pull outputs" /
+  "Auto-sync code" are hidden for it in `RemoteMachinesWindow`; the row carries a "Shared
+  filesystem" badge instead of a "last synced" line.
+
+## 9. Implementation status (2026-07-19)
+
+**Phases 1 & 2 fully implemented; Phase 3 implemented except per-worker monitoring.**
+All `cargo test` (853) + `vitest` (1703) green; live QA (§7) still owed (I can't launch
+Eldrun).
+
+**Backend.** `schema::project::ComputeHost` + `Project.compute_hosts` (§1.1);
+`projects.rs` mirror into `extra["compute_hosts"]` + CRUD `add_/remove_/patch_compute_host`
+(§1.2). `services::remote` re-keyed to a composite `conn_key(project, host)` with
+`PRIMARY_HOST` wrappers keeping every file/git/sync caller unchanged; `connect_host`/
+`disconnect_host`/`disconnect_project`/`is_connected_host`/`pooled_sftp_host`/
+`connected_targets`/`remote_target_for_host`/`compute_hosts_for` (§3.2). `commands::remote`
+threads `host_id` (default primary) through `remote_connect`/`remote_disconnect`, adds
+`remote_disconnect_all_hosts`, `remote_connected_targets`, `worker_sync_now`,
+`worker_outputs_preview`, `worker_pull_outputs` (§3.3). `PtyOptions.remote_host_id` +
+`wrap_pty_options` resolve-by-host (§4.2). `services::worker_sync` = the whole §2 push-only
+fan-out + §4.4 output pull; wired into `git_peer::start`/`poll_loop` so a mirror commit
+fans out to connected workers.
+
+**Frontend.** `TabLocation` gains `` `host:${string}` `` + `remoteHostIdOf` (§4.1);
+`remoteStatus` split primary(`byProject`)/workers(`byHost`) with `sshOf`/`vpnOf` (§4.3);
+`TerminalView.remoteHostId` from `TabPane` (§4.2); per-host pill lamps (`RemoteConnMenu`) +
+`connectDialog.hostId` + `useRemoteReconnect(project, host?)` + `RemoteConnectDialog`
+host-aware (§4.3); TabBar locality badge → Local/Primary/worker **menu** (§4.5);
+`CenterPanel` hold gate per-host (§4.5); `RemoteMachinesWindow` = the §4.4 pill section
+(add machine, connect, sync-now, pull-outputs w/ size-confirm, toggles); deactivation
+disconnects all hosts; `AppShell` lamp-reconcile uses `remote_connected_targets`.
+
+**Deferred (documented).** Per-worker **monitoring** host selector (§5) — `SystemMonitorPane`
+is mid-refactor by another working copy (pre-existing tsc errors), so not touched; the
+backend monitor commands still take only `project_id`. Per-`(project,host)` **net_usage**
+buckets (§3.4) — `connected_ids` sums a project's hosts under one bucket as the plan
+allows. Per-worker **auto-connect on launch** — the toggle persists via `patch_compute_host`,
+but `autoConnectRemote` (`stores/projects`) still probes the primary only.
diff --git a/docs/ssh_projects_plan.md b/docs/ssh_projects_plan.md
index a6600f5..86d5e7c 100644
--- a/docs/ssh_projects_plan.md
+++ b/docs/ssh_projects_plan.md
@@ -1,7 +1,13 @@
 # SSH / Remote Projects — Implementation Plan (TODO Group M, #28)
 
-Status: **implemented** (code complete; runtime QA pending — agents cannot
-launch Eldrun). Built by a 4-agent sequential team.
+> **Superseded by the mount-free remote model — see
+> [`docs/mountfree_remote_plan.md`](mountfree_remote_plan.md).** The sshfs mount
+> described below was **removed** (#28j): remote projects are now SSH/SFTP-native
+> (no FUSE). Retained for history; the SSH-exec / OpenVPN / SFTP-browse machinery
+> it introduced lives on, but the mount / `ssh_mount.rs` parts no longer exist.
+
+Status: **superseded** (mount removed in #28j; SSH/SFTP machinery retained).
+Originally built by a 4-agent sequential team.
 
 The mount / browse / scaffold v1 below is code-complete. A **remote-execution
 layer** (`services/ssh_exec.rs` + `services/openvpn.rs`) was added on top of it —
diff --git a/docs/ssh_sync_plan.md b/docs/ssh_sync_plan.md
new file mode 100644
index 0000000..9eaacae
--- /dev/null
+++ b/docs/ssh_sync_plan.md
@@ -0,0 +1,297 @@
+# SSH Remote Projects — Local Sync & Tab Locality Plan
+
+Implementation plan for the feature sketched in `docs/SSH_CHANGES.md`: every
+remote (SSH) project automatically has a **local paired version inside Eldrun** —
+a structural twin that starts empty and is populated by **explicit, user-chosen,
+bidirectional sync** (remote→local and local→remote) — plus a **per-tab
+local/remote locality** axis. Stays mount-free (no sshfs/FUSE). Builds on the
+mount-free remote model (`docs/mountfree_remote_plan.md`).
+
+This plan was produced by a two-architect design debate + an independent review
+pass against the real code, then settled by the product owner's decisions
+(recorded below).
+
+## Product decisions (settled)
+
+1. **Agents default LOCAL.** A new agent tab on a remote project runs locally,
+   cwd = the local project root (the mirror root). Remote agents remain possible
+   via the per-tab toggle. (This is the literal reading of `SSH_CHANGES.md`,
+   chosen over the reviewers' "default remote" recommendation.)
+2. **Sync is manual, selective, and bidirectional — the user chooses what syncs,
+   in each direction.** The user marks files/folders to sync remote→local and/or
+   local→remote in the file viewer; nothing syncs automatically and the whole tree
+   is never pulled implicitly. An optional one-click "sync whole project" exists
+   for when the full tree is wanted.
+3. **Transport = hybrid: rsync fast-path over an SFTP floor.** Use `rsync` for
+   bulk/folder/whole-project syncs when it is present on **both** ends (delta
+   transfer, single connection, rides the existing ControlMaster); fall back to
+   SFTP-native recursive everywhere it is missing (Windows by default, minimal
+   hosts). Single-file syncs just use SFTP.
+4. **Every remote project automatically has a local paired version in Eldrun** —
+   a structural twin (the mirror), present by default but **empty until populated**.
+   *No content is duplicated until the user explicitly syncs it*, so the act of
+   selecting what to sync **is** the consent: no separate opt-in toggle, and no
+   bytes land on the local disk unprompted. Deleting the project removes the
+   mirror.
+5. **Up-sync blocks on a stale base** (no silent clobber); **no `filetime` dep**
+   (manifest stores the host base; on-host `sha256sum` only breaks size/mtime
+   ties); **live sync stays out** of the default scope (optional later layer,
+   push-on-open-buffers only).
+
+### Known, accepted trade-off
+
+Decisions 1 + 2 together mean a **local agent may operate on a partial tree** —
+it can miss an unsynced import, config, or dependency, and the mirror is not a
+valid git checkout. **This is accepted as-is** (product decision): the user
+curates the synced set; no warning or gate is added when launching a local agent
+on a partially-synced project. The optional one-click "sync whole project" action
+remains available for when the full tree is wanted. Git operations stay routed to
+the host (see below), never run against the mirror.
+
+## Source-of-truth model
+
+- **Every remote project has a local paired version** — the mirror — present by
+  default but empty until the user syncs content into it. "No content duplicated"
+  means the local twin exists structurally; bytes appear only on explicit sync.
+- **The remote host is the source of truth for conflict resolution.** Sync is
+  user-directed in both directions, but when both ends changed since the last
+  sync, the host wins by default (up-sync blocks on a stale base — see below).
+- **Mirror location:** `<state_dir>/remote-projects/<id>/mirror/`, a sibling of
+  the existing per-project `project.json`. The state dir is minted by
+  `remote_project_state_dir(id)` (`commands/projects.rs:20`); the `mirror/`
+  subdir is net-new (created with the project, populated only by sync).
+- **Manifest:** `<state_dir>/remote-projects/<id>/sync.json`, a map
+  `relPath -> { selected, host_mtime, host_size, local_mtime, local_size,
+  last_pull_ts, last_push_ts }`. All divergence is judged **host-vs-manifest**
+  and **local-vs-manifest** — never host-mtime directly vs local-mtime (clock
+  skew). The manifest is the single source of the green/amber UI state and the
+  3-way (base/host/local) conflict base. It must be a single-writer structure
+  (Tauri-managed `Mutex`, see Phase 1 / gap G7).
+- **Git stays on the host** via the existing `ssh_exec` git path
+  (`remote_git_command`); never run against the (possibly partial) mirror.
+
+## UI state
+
+- **green** — file is in the mirror and its manifest base still matches the host.
+- **amber** — host moved since the last fetch. Only observable *after* an explicit
+  re-stat/refresh (no watcher), so amber is a post-refresh state, not a live
+  divergence indicator.
+- **none** — not synced (default for everything until the user selects it).
+- **spinner row** — a transfer is in flight (`sync-progress` event, mirroring the
+  `fs-change` wiring in `commands/fs_watch.rs`).
+
+The right panel's `files` view gains a **local/remote source toggle** (net-new
+state *inside* the `files` view — NOT a new entry in the `View` union in
+`RightPanel.tsx:44`, which is the left-rail selector). Remote source = today's
+SFTP-on-demand listing; local source = `list_dir` against the mirror dir with the
+overlay above. Both reuse `FileTree`.
+
+## Tab locality
+
+Add an optional field `location: "local" | "remote"` to **both** `TabEntry` and
+`SavedTabEntry` in `src/stores/tabs.ts` (there is no `extra` map — it is an
+explicit field, threaded through `loadFromLayout` and the save mapping). Defaults:
+
+| Kind | Default `location` | Notes |
+|------|--------------------|-------|
+| agent | **local** | cwd = mirror root. Toggle to remote = today's `ssh -tt` path. |
+| shell (terminal) | **remote** | remote for running remote scripts; local option = shell in the mirror dir. |
+| local_agent (Ollama) | local (fixed) | unchanged; already forced local. |
+| files / embed / projects3d | n/a | locality not meaningful. |
+
+**Backend spawn is unchanged.** `commands/terminal.rs:71-75` already gates
+`ssh_exec::wrap_pty_options` behind `!opts.local_only`, and a `local_only` spawn
+runs locally in `opts.cwd`. So:
+
+- `location: "remote"` → today's path (`project_id` set, not local_only → ssh-wrapped).
+- `location: "local"` → `local_only: true` + `cwd` = mirror root.
+
+The real wiring is **frontend**: the `localOnly` computation currently reads
+`tab.kind === "local_agent"` (`CenterPanel.tsx:961`, `DetachedCenterPanel.tsx:939`)
+— change to `isLocalAgentKind(kind) || location === "local"`, and resolve `cwd` to
+the mirror dir for local-on-remote tabs.
+
+## Sync mechanism (hybrid)
+
+- **Single-file pull** (e.g. selecting one file): SFTP `read_file_on` over the
+  pooled `Arc<Sftp>` (`services::remote::pooled_sftp`, `remote.rs:203`).
+- **Bulk pull/push** (folder select, "sync now", "sync whole project"): **rsync
+  when available on both ends**, else **SFTP-native recursive**.
+  - rsync rides the existing pooled master:
+    `rsync -e 'ssh -o ControlPath=<control_dir>/cm-%C -o ControlMaster=no …'`
+    (the socket path is built in `services/ssh_common.rs:84,172`; `control_dir()`
+    in `ssh_exec`). Use `rsync -c` (checksum) as the correctness/conflict basis
+    where available. No rsync exists in the codebase today — net-new shell-out.
+  - SFTP-native recursive walker is net-new, modeled on `remove_dir_on`
+    (`sftp.rs:475`); `list_dir_on` (`sftp.rs:251`) lists a single dir only.
+    `download_on` (`sftp.rs:517`, currently `#[allow(dead_code)]`) is the
+    per-file primitive (prefer `read_file_on` + non-blocking write).
+- **Capability probe:** extend `ssh_tooling_status` (`commands/ssh.rs` /
+  `services/ssh_common.rs`) to report local rsync and probe `command -v rsync` on
+  the host. If rsync is missing locally, offer the one-click install-via-new-tab
+  flow; if missing on the host, **degrade to SFTP** (do not attempt to install on
+  an arbitrary remote host).
+- **Up-sync safety:** re-stat host; if host == manifest base, write to a temp path
+  then `rename_on` (atomic, `sftp.rs:493`); if the base is **stale, block and ask**
+  — never auto-clobber. The conflict prompt offers **keep local / take host / skip**
+  and a **"view diff"** action that opens the local-vs-host diff in the existing
+  in-app diff viewer (`src/components/embed/DiffView.tsx` + `src/lib/viewers/diff.ts`,
+  wired through `FileViewerPane.tsx`), fetching the host copy over SFTP for the
+  right-hand side. Reuse `RightPanel`'s `askConflict` (`:361`) choice mechanism
+  (`replace | rename | skip`; `rename` = keep-both) extended with the diff action.
+  Add a max-sync-size guard — `read_file_on`/`write_file_on` buffer whole files in
+  RAM and hold the single SFTP channel (`sftp.rs:439,450`); large artifacts need a
+  guard/warning.
+
+## Reviewer-verified gaps to design in
+
+- **G1 — Data-at-rest** → resolved by the model itself: the local pairing is
+  always present but empty, and bytes reach the local disk only when the user
+  explicitly syncs them, so selecting what to sync *is* the consent. No separate
+  toggle. (Mirror is removed on project delete — G4.)
+- **G2 — Local reads still route to SFTP.** With `project_id` set, the
+  absolute-path file readers (`read_file_text:920`, `read_file_bytes:1056`,
+  `write_file_text:968` in `commands/fs.rs`) dispatch remote whenever
+  `remote_target_for(project_id)` is `Some`. The local source view / local tabs
+  need a `source: "local"|"remote"` param (or path-prefix routing: a path under
+  the mirror dir ⇒ local read). **Must be resolved in Phase 1** or "local" opens
+  silently round-trip SFTP. (`list_dir` already works against a local mirror dir
+  because it keys on `project_dir`.)
+- **G3 — Symlink escape.** The recursive walker must be lstat-typed and **not
+  follow host symlinks** (a `mirror-me -> /etc` symlink would exfiltrate host
+  files into the mirror / let up-sync write through it). `confine_remote_abs`
+  (`fs.rs:224`) only checks the path string, not symlink targets.
+- **G4 — Mirror cleanup on delete.** Confirm project-delete recursively removes
+  `<state_dir>/remote-projects/<id>/` (incl. `mirror/`); otherwise mirrored bytes
+  leak (contradicts G1).
+- **G7 — Manifest write races.** Push-on-save vs a concurrent "sync now" vs two
+  tabs saving will clobber `sync.json`. Use a Tauri-managed
+  `Mutex<HashMap<projectId, Manifest>>` (same shape as `RemotePoolState`).
+- **G8 — Large/binary files.** Size guard; binary files must not go through the
+  UTF-8 text path.
+- **G9 — "Open auto-syncs" is mostly redundant with the in-app viewers**, which
+  already fetch remote bytes over SFTP. Frame auto-cache-on-open as "make bytes
+  available to local tabs/agents," not as a prerequisite for *viewing*. Given the
+  manual-sync decision, auto-cache-on-open is optional, not the primary path.
+- **G11 — P0 local terminal cwd.** Before the mirror exists, a local terminal on
+  a remote project should cwd to `remote_project_state_dir(id)` (which exists).
+
+## Phased plan
+
+Each phase is independently shippable and gated by `npx tsc --noEmit` +
+`cargo test --manifest-path src-tauri/Cargo.toml`. Live/UI QA is done by the
+human (Eldrun is not launched from an agent).
+
+### Phase 0 — Tab locality axis (frontend-only)
+- `stores/tabs.ts`: `location?` on `TabEntry` + `SavedTabEntry`; thread through
+  `loadFromLayout` + save mapping + `isRestorableTab`; defaults per the table.
+- `CenterPanel.tsx` / `DetachedCenterPanel.tsx`: `localOnly` computation honors
+  `location`; resolve `cwd` (mirror root, or state dir as the pre-mirror fallback).
+- Per-tab local/remote switch + indicator (terminals first).
+- Tests: extend tab-persist / resume round-trip tests for `location`.
+- **QA:** remote project → spawn remote shell (on host) + local shell (local);
+  Windows smoke.
+
+### Phase 1 — Local pairing + selective pull (remote→local) + manifest + green/amber + source toggle
+- Mirror dir is the always-present (empty) local twin; created with the project,
+  populated only by sync. No consent toggle.
+- New `services/remote_sync.rs`: lstat-typed recursive host walker (G3),
+  `pull_file`, manifest type + 3-way base compare. Single-writer manifest state
+  (G7).
+- New `commands/sync.rs`: `sync_mark_selected`, `sync_pull`, `sync_status`,
+  `sync_now` (reconcile selected), `sync_whole_project` (optional full pull);
+  injected with `RemotePoolState`; registered in `lib.rs`. Emit `sync-progress`.
+- Resolve G2: `source` param / path-prefix routing on the file readers so the
+  local view reads the mirror.
+- `FileTree.tsx`: green/amber/spinner overlay beside `GitMarker`; per-entry
+  sync-selection affordance. `RightPanel.tsx`: local/remote source toggle within
+  `files`. New `stores/sync.ts` (manifest cache + `sync-progress` subscription).
+- Mirror cleanup on delete (G4).
+- Tests: walker, symlink-skip, manifest compare.
+- **QA:** select a folder → pulls + turns green; edit on host + refresh → amber;
+  toggle local/remote source.
+
+### Phase 2 — Selective push (local→remote), guarded
+- `sync_push`: user-chosen local→remote sync of selected files — completes the
+  **bidirectional** model. Re-stat host → atomic temp + `rename_on`; block on
+  stale → conflict modal (keep local / take host / skip + **view diff** via the
+  existing `DiffView`); `sha256sum`-over-ssh tie-break; size guard (G8).
+- Optionally route remote-project saves from a local editor/tab through
+  `sync_push` (still user-scoped — only files marked for local→remote).
+- Tests: 3-way base logic incl. stale + tie-break.
+- **QA:** edit locally + edit same file on host → block-on-stale modal, no clobber.
+
+### Phase 3 — rsync fast-path for bulk sync
+- Extend `ssh_tooling_status` to detect rsync both ends.
+- `remote_sync.rs`: rsync transport (ride ControlMaster, `-c`) for bulk
+  pull/push/whole-project; SFTP-native fallback retained as the floor.
+- Tests: argv builder (ControlPath wiring, fallback selection) — pure, unit-testable.
+- **QA:** large folder sync on a Linux host with rsync vs a host without (falls
+  back to SFTP); Windows (SFTP floor).
+
+### Phase 4 (optional, cost-gated) — Live push on open buffers
+- `notify` (already a dep) watching only mirror files with open editors; debounce
+  → `sync_push`. Live **pull** stays out (no cheap SFTP change-notify).
+
+## Implementation status
+
+Phases 0–3 are implemented and gated (`npx tsc --noEmit`, `npx vitest run`,
+`cargo test`); live/UI QA is the human's.
+
+- **Phase 0 (done).** `location?: "local" | "remote"` on `TabEntry`/`SavedTabEntry`
+  (round-trips via the Rust `TabEntry`'s flattened `extra`, so no schema change);
+  `effectiveTabLocation`/`defaultLocationForKind`/`isLocatableKind`/`localTabCwd`
+  helpers; `setTabLocation` store action; `CenterPanel`/`DetachedCenterPanel`
+  `localOnly` honors locality; the backend (`pty_spawn`) authoritatively resolves
+  a local-on-remote tab's cwd to the mirror (and mkdirs it); per-tab badge +
+  toggle in `TabBar`. Tests: `TabLocality.test.ts`.
+- **Phase 1 (done).** `services/remote_sync.rs` (manifest type + IO, lstat host
+  walker G3, `pull_file`, 3-way `compute_state`, single-writer `SyncManifestState`
+  G7); `commands/sync.rs` (`sync_pull`/`sync_whole_project`/`sync_now`/
+  `sync_mark_selected`/`sync_status`, `sync-progress` events); G2 mirror-path
+  routing on the `fs.rs` readers/writers; mirror minted at create + on connect;
+  `FileTree` green/amber overlay + select-to-sync; `RightPanel` local/remote
+  source toggle; `stores/sync.ts`. `sftp::list_dir_raw_on` is the symlink-safe
+  lister. Tests: `remote_sync` unit tests, `SyncStore.test.ts`.
+- **Phase 2 (done).** `sync_push` + `push_decision` (block-on-stale; atomic
+  temp+`rename_on`); `FileTree` "Push to host" / "Push all to host" + the
+  keep-local / take-host / skip conflict modal; `stores/sync.ts` `push`.
+- **Phase 3 (done).** `ssh_tooling_status.rsync` (local probe);
+  `rsync_available_host` (over-ssh probe); pure `rsync_pull_args` /
+  `rsync_ssh_transport` / `should_use_rsync` (ControlMaster-riding `-e`, `-c`);
+  rsync fast-path for **directory pulls** with the SFTP walker as the floor.
+
+### Deferred (safe to add later)
+
+- **rsync for PUSH** stays on the guarded SFTP floor on purpose: a bulk rsync push
+  would bypass the per-file block-on-stale guard (product decision 5 — never
+  clobber). Pulls use rsync (overwriting the user-chosen mirror is intended).
+- **`sha256sum` tie-break** for the host-touched-but-unchanged case: the push
+  staleness check is conservative (size+mtime base; never clobbers, only
+  over-reports a bare `touch` as a conflict the user clears with "keep local"). A
+  real content tie-break needs a base hash captured at pull time — not added.
+- **"View diff"** in the conflict modal (local mirror vs host over SFTP) — needs a
+  new non-git diff source; the keep-local/take-host/skip resolutions ship now.
+- **Phase 4** (live push on open buffers) — optional/cost-gated, not started.
+
+## Critical files
+
+- `src-tauri/src/services/sftp.rs` — SFTP primitives (`read_file_on`,
+  `write_file_on`, `metadata_on`, `rename_on`, `list_dir_on`, `remove_dir_on`,
+  `download_on`).
+- `src-tauri/src/services/remote.rs` — `pooled_sftp`, the connection pool.
+- `src-tauri/src/services/remote_sync.rs` — **new**: walker, manifest, transport.
+- `src-tauri/src/commands/sync.rs` — **new**: sync commands.
+- `src-tauri/src/commands/fs.rs` — local-vs-remote read routing (G2), save hook.
+- `src-tauri/src/commands/terminal.rs` — `local_only` spawn gate (unchanged).
+- `src-tauri/src/commands/projects.rs` — `remote_project_state_dir`, mirror mint
+  + delete cleanup, consent flag.
+- `src-tauri/src/commands/ssh.rs` + `services/ssh_common.rs` — `ssh_tooling_status`
+  rsync probe; ControlMaster socket path.
+- `src-tauri/src/lib.rs` — managed state + command registration.
+- `src/stores/tabs.ts` — `location` field + persistence.
+- `src/stores/sync.ts` — **new**: manifest cache + progress.
+- `src/components/files/FileTree.tsx` — overlay + selection.
+- `src/components/layout/RightPanel.tsx` — local/remote source toggle.
+- `src/components/layout/CenterPanel.tsx` + `DetachedCenterPanel.tsx` —
+  `localOnly`/`cwd` computation.
diff --git a/docs/start-eldrun-tauri-hotreload.sh b/docs/start-eldrun-tauri-hotreload.sh
new file mode 100755
index 0000000..f6fbe87
--- /dev/null
+++ b/docs/start-eldrun-tauri-hotreload.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# Launcher for the hot-reload Tauri dev server.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+LOG_DIR="$HOME/.local/share/eldrun"
+LOG_FILE="$LOG_DIR/hotreload.log"
+
+mkdir -p "$LOG_DIR"
+exec >>"$LOG_FILE" 2>&1
+
+printf '\n=== HOTRELOAD START %s ===\n' "$(date -Is)"
+trap 'status=$?; printf "=== HOTRELOAD EXIT %s status=%s ===\n" "$(date -Is)" "$status"' EXIT
+
+cd "$ROOT"
+
+# Desktop entries don't source ~/.bashrc, so Rust tools may not be in PATH.
+export PATH="$HOME/.cargo/bin:$PATH"
+
+# With GTK overlay scrolling on (the default on Cinnamon/GNOME), WebKitGTK draws
+# a native GTK overlay scrollbar and ignores the app's CSS `scrollbar-color`, so
+# the themed (blue) scrollbars fall back to the system GTK theme (white/grey in
+# Adwaita light). Disabling it forces the legacy scrollbar, which WebKitGTK
+# renders itself and themes from our CSS. Harmless where it's already off.
+export GTK_OVERLAY_SCROLLING=0
+
+printf 'root=%s\n' "$ROOT"
+printf 'PATH=%s\n' "$PATH"
+command -v node
+node --version
+command -v npm
+npm --version
+command -v cargo
+cargo --version
+command -v rustc
+rustc --version
+
+exec npm run tauri:dev
diff --git a/start-eldrun-tauri.sh b/docs/start-eldrun-tauri.sh
similarity index 100%
rename from start-eldrun-tauri.sh
rename to docs/start-eldrun-tauri.sh
diff --git a/docs/tmux_remote_plan.md b/docs/tmux_remote_plan.md
new file mode 100644
index 0000000..164e392
--- /dev/null
+++ b/docs/tmux_remote_plan.md
@@ -0,0 +1,318 @@
+# Persistent Remote Sessions (tmux) — Implementation Plan (TODO #85)
+
+Status: **implemented** (Phases 0–4; live-QA on a real host still pending — Done ≠ Tested).
+
+**What shipped vs. this plan.** Two deliberate changes from the design below:
+
+1. **Default ON**, not opt-in behind the experimental flag (per the user).
+   `RemoteSpec.persist_sessions` means "default on unless explicitly `false`", the
+   pill's "Persistent sessions (tmux)" item is the opt-**out**, and the per-spawn
+   decision is `PtyOptions.tmux_session` (set only for remote `shell` tabs — Python
+   runs open a shell tab — never agents).
+
+2. **The session name is a frontend-minted uuid persisted on the tab**
+   (`TabEntry.tmuxSession`, `newTmuxSessionName`), *not* derived from the tab id
+   (§Data model option 1). The reason: `loadFromLayout` regenerates a tab's key on
+   every restart, so a name derived from the PTY id (`<scope>:<tab-key>`) would
+   change on relaunch and **fork a second session instead of reattaching** — the
+   opposite of the goal. `ELDRUN_TAB_UID` (the plan's suggested source) only exists
+   for agent tabs anyway. Minting once and persisting it makes the name stable
+   across a relaunch, which is what makes restart-reattach work.
+
+Key symbols: backend `ssh_exec::{TmuxWrap, tmux_wrap_exec,
+tmux_kill_session_script, tmux_rename_session_script, tmux_ls_script,
+parse_tmux_ls, TmuxSession, valid_tmux_session_name}` + `services::tmux_local` +
+`PtyOptions.{tmux_session,tmux_attach}`, commands
+`remote_tmux_{list,kill,rename}`/`local_tmux_{list,kill,rename}`/`set_project_persist_sessions`;
+frontend `lib/tmuxSession.ts` (mint + gate), `lib/closeRemoteTab.ts`, the persisted
+`TabEntry.tmuxSession`/`tmuxAttach`, and the Sessions view in `ProjectFilesView.tsx`.
+
+### Post-v1 additions (this pass)
+
+- **Local persistence (Unix)** — the plan below scoped tmux to *remote* tabs, calling
+  local "impossible on Windows and low-value elsewhere." Shipped anyway (per the
+  user): a **local** project's shell/script tab is wrapped in a tmux session on the
+  machine so a run survives an **Eldrun crash** and reattaches on restart. Works
+  because the tmux server is a daemon the PTY-held client is separate from; **Unix
+  only** (no tmux on Windows → `services::tmux_local` no-ops), **default ON** via
+  `settings.persist_local_sessions`. The wrap is an argv rewrite in `pty_spawn`
+  (not a `$SHELL -c` string like the remote path), applied only when ssh/docker
+  wrapping did **not** fire.
+- **Worker-host sessions** — the Sessions view now aggregates across the primary
+  **and every connected worker** (`docs/multi_host_remote_plan.md`), each row
+  host-tagged; attach/kill/rename act on the row's host. The wrap itself was already
+  host-agnostic (it runs per-host via `remote_host_id`), so only the view changed.
+- **Rename** — per-row Rename in the Sessions view (`remote_tmux_rename` /
+  `local_tmux_rename`, gated on `valid_tmux_session_name`) also updates the owning
+  tab's persisted `tmuxSession`/`tmuxAttach` so it reattaches to the new name after a
+  restart (the live client stays attached — tmux rename never drops it).
+- **Resumable command tabs** — largely already satisfied: a script/command runs in a
+  persistent shell tab (the `lib/pythonRun.ts` pattern — a login shell that outlives
+  the command), so it restores and reattaches to the *completed* run rather than
+  re-running. For a directly-`cmd`'d local command tab, `local_tmux_args` keeps a
+  login shell **after** the command for the same guarantee.
+
+## The problem, in one sentence
+
+A remote shell or script is a child of the `ssh -tt` channel, so it dies —
+silently, with `SIGHUP` — the instant that channel breaks: a network blip, a
+laptop sleep, a VPN drop, or Eldrun quitting. For a long Python training run
+that is the worst possible outcome, and it is exactly the case Eldrun cannot
+survive today.
+
+The fix is to run the remote shell/script **inside a tmux server on the host**,
+decoupled from the SSH channel. The SSH client becomes a disposable viewer; the
+work lives on the server. Reconnect — or relaunch Eldrun — and the same command
+reattaches to the still-running session, output and all.
+
+## Why this is server-side, and what that means for Windows/macOS
+
+tmux runs on the **remote host** (a Linux box — essentially always, for a
+compute/experiment host). The local machine only ever runs the `ssh` client. So
+a Windows or macOS Eldrun connecting to that host gets **identical**
+persistence: the feature is entirely server-side and is *not* obsolete on those
+platforms — it is the whole point that the run is decoupled from your laptop's
+OS, network, and Eldrun process. The only local-OS wrinkle is cosmetic and
+already handled elsewhere (Windows skips ControlMaster, `ssh_exec.rs:187`); the
+tmux path is untouched by it.
+
+**Scope is therefore remote projects only.** Local (non-remote) tabs are a
+weaker, harder story — the process is Eldrun's own child, not decoupled by SSH,
+so surviving an Eldrun restart would need tmux/dtach *locally* too, which is
+impossible on Windows and low-value elsewhere. Out of scope for this item.
+
+## The one seam
+
+Every remote tab's command is built by **`remote_command`** (`ssh_exec.rs:117`),
+called from **`wrap_pty_options`** (`ssh_exec.rs:500`). Today it emits:
+
+```
+cd <remote_path> && export K=<v> … && exec "${SHELL:-/bin/bash}" -l          # shell tab
+cd <remote_path> && export K=<v> … && exec "${SHELL:-/bin/bash}" -lc '<cmd>' # command/agent tab
+```
+
+The tmux wrap replaces only the final `exec …` with a tmux launch. Everything
+before it — the `cd`, the sorted env exports, the `remote_agents` bootstrap
+prelude (`ssh_exec.rs:159`) — is preserved verbatim, nested *inside* tmux:
+
+```
+cd <remote_path> && export … && exec tmux new-session -A -D -s eldrun-<name> -- \
+    "${SHELL:-/bin/bash}" -l                          # shell tab
+cd <remote_path> && export … && exec tmux new-session -A -D -s eldrun-<name> -- \
+    "${SHELL:-/bin/bash}" -lc '<cmd>'                 # command/agent tab
+```
+
+Flags, each load-bearing:
+
+- **`-A`** — attach if the session exists, create it if not. This single command
+  is *both* "start" and "resume": on first spawn it creates and runs the target;
+  on a reconnect/relaunch it reattaches and the target arg is ignored (the
+  process is already running). This is what makes restart-resume free.
+- **`-D`** — on attach, detach any *other* client first. Stops a stale ssh
+  client (ControlPersist can outlive a reload) or a second Eldrun window from
+  mirror-sharing the pane and fighting over its size.
+- **`-s eldrun-<name>`** — a **stable per-tab session name**. The one piece of
+  new persisted state (see Data model). If it is not stable across restarts,
+  reattach silently creates a *second* session instead of resuming.
+
+`ssh_pty_args` (`ssh_exec.rs:176`) is unchanged: it still forces `-tt`, and it
+deliberately omits `BatchMode`, so a first-run interactive prompt (host key,
+passphrase) still works through the terminal even with tmux in the middle.
+
+## Data model — one field, no migration
+
+A per-tab boolean plus a derived session name. Two options:
+
+1. **Reuse the existing tab identity.** The frontend already mints
+   `ELDRUN_TAB_UID` (persisted, and already exported to the host). Derive
+   `eldrun-<uid>` in `wrap_pty_options` — no schema change at all, and the name
+   is automatically stable across restarts because the uid is.
+2. **Explicit `tmuxSession` on the tab**, mirrored like `sessionId`
+   (`tabs.ts:372`), if we ever want a human-named session decoupled from the
+   tab. Not needed for v1.
+
+A tab that **attaches** to an arbitrary named session (from the Sessions view,
+below) carries that name explicitly — `tmuxAttach: Option<String>` on the tab —
+so `wrap_pty_options` builds an attach rather than a fresh spawn, and the tab
+restores/reattaches to *that* session across a restart. This is the one case
+where the session name is not derived from the tab uid (the session predates the
+tab), so it must be persisted on the tab.
+
+Go with (1) for tabs Eldrun starts. The opt-in is a per-project toggle
+(`RemoteSpec` gains
+`persist_sessions: Option<bool>`, mirrored into `projects.json` `extra` and the
+`types/index.ts` mirror, defaulting to unset ⇒ off) so it upgrades every
+existing remote project in place with no migration — same pattern as the sandbox
+toggle. Gate the whole thing behind the experimental flag
+(`lib/experimental.ts`) until live-QA'd.
+
+## Restart-resume — most of the machinery already exists
+
+The reattach path is already there; tmux just makes it *mean something* for
+remote work.
+
+- A remote **shell** tab is *already* restorable — `isRestorableKind`
+  (`tabs.ts:3416`) is true for shell/files kinds, so on relaunch Eldrun already
+  respawns its ssh command. Today that respawn gets a *fresh* shell (the prior
+  run is gone). With tmux, the respawned command is
+  `tmux new-session -A -s eldrun-<uid>` → it **reattaches** to the session that
+  kept running. No new restore code for shells — the wrap alone delivers it.
+- **Scripts** run *inside* a shell/command tab (this is already true —
+  `lib/pythonRun.ts` opens a terminal tab and types the command, precisely so it
+  inherits tab locality). So a persistent shell tab carries a running Python
+  process through a restart for free. A dedicated resumable *command* tab (like
+  `RESUMABLE_AGENTS`, `tabs.ts:3452`) is a possible follow-up but not required
+  for v1.
+
+## Kill vs. detach — the one genuinely new decision
+
+Today closing a tab reaps the whole remote subtree (backend `CLAUDE.md`,
+`terminal/mod.rs` `kill`). With tmux, closing the ssh client must **not** kill
+the session — that would defeat the entire feature. Split the intent:
+
+- **Close tab** (an explicit user action) → kill the session:
+  `tmux kill-session -t eldrun-<uid>`, fired as a one-shot over the pooled
+  ControlMaster via **`run_remote_script`** (`ssh_exec.rs:300`) — the transport
+  already exists, no new plumbing. The local ssh child is reaped as today.
+- **Eldrun quit / connection drop** → leave the session alive on the host. An
+  explicit machine disconnect ends that host's tmux sessions before closing SSH.
+
+The seam: the tab-close path (`kill`) needs to know whether the tab was a
+persistent remote tab, and if so run the kill-session one-shot *before* reaping
+the ssh child. App-exit (`kill_all`) and remote-disconnect must **not**.
+
+## tmux presence & fallback
+
+Detect and degrade gracefully, reusing the `remote_agents.rs::bootstrap_prelude`
+pattern (`command -v tmux >/dev/null || …`):
+
+- **Present** → wrap as above.
+- **Absent** → run the plain `exec` (today's behavior) and surface a one-line
+  notice that persistence is off because tmux is missing. Note tmux is *usually*
+  preinstalled on compute/HPC hosts, but userspace-installing it (no sudo) is
+  harder than an npm-installable agent CLI, so the realistic fallback is
+  "run without persistence + tell the user," **not** auto-install.
+
+## UX cost — the honest trade
+
+tmux intercepts scrollback (its own copy-mode) and draws a status bar, which can
+make an xterm.js pane feel less native. Mitigations, shipped as session options:
+
+- `set -g status off` — reclaim the status line; Eldrun already provides tabs and
+  layout, so tmux's status bar is redundant chrome.
+- `set -g mouse on` — wheel scrolls tmux history so scrollback still feels normal.
+
+**Alternative worth weighing: `dtach`/`abduco`.** These give pure detach/attach
+with *no* status bar, no windows, and no scrollback interception — a strictly
+more transparent fit for Eldrun's model, since we already own tabs and layout.
+The trade is availability: tmux is far more likely to be preinstalled on a
+random compute host. Recommendation: **build on tmux** (what the user asked for,
+and the common denominator), but keep the wrap behind a tiny "session backend"
+indirection so a `dtach` backend can be added later without touching the seam.
+
+## Composition with the other axes
+
+- **Docker containers** are mutually exclusive with ssh wrapping
+  (`terminal.rs:116`) — a container project is local. No interaction.
+- **Worker hosts** (multi-host) each get their own pool entry and could each run
+  their own tmux session (`eldrun-<uid>` is already unique per tab, and tab
+  locality is `host:<id>`); the wrap is host-agnostic. v1 can apply it to the
+  primary only and extend to workers trivially later.
+- **Agent tabs** — the `remote_agents` bootstrap prelude nests *inside* the tmux
+  target command untouched. A remote Claude/Codex tab could run inside tmux too,
+  but agent *conversation* resume is already handled by `RESUMABLE_AGENTS`; the
+  tmux value there is narrower (surviving a mid-response disconnect). v1 can
+  scope tmux to shell/command tabs and leave agent tabs as-is.
+
+## Surfacing "your run is still alive" — the Sessions view
+
+Because a persistent session outlives the tab that started it, the host can hold
+sessions no open tab points at: a run from a crashed/relaunched Eldrun, a
+different machine, or one the user started by hand in a plain ssh terminal. Those
+must be **discoverable and reattachable**, or the persistence is a trap. This is
+the primary UI surface for the feature.
+
+**A "Sessions" view in the file viewer**, alongside Files / Git / Search / Apps /
+Orange (`ProjectFilesView.tsx:33,607`). It is the exact analog of the **Orange
+(diverged)** view (`ProjectFilesView.tsx:619-632`): a toolbar toggle gated on
+`project?.remote && projectId`, badged with a live count, that swaps the tree for
+a backend-fed list. Because `ProjectFilesView` renders *twice* (RightPanel and
+the Files (Project) tab), the view — and its click-to-open — appears in **both**
+the right-side files panel and the Files tab with no extra wiring, exactly as the
+Orange view does.
+
+- **Toolbar button:** `☰ N` (session count), remote-only, next to the `±` orange
+  toggle. Toggles `view === "sessions"`.
+- **List rows:** one per host tmux session. Each row shows the session **name**,
+  window/pane count, created/idle time, and an **attached** dot (another client
+  is on it right now). Rows Eldrun created (`eldrun-<uid>` prefix) are labelled
+  with the originating project/tab when known; foreign sessions show their raw
+  name — both are first-class.
+- **Click a row → open the running session.** Opens a shell tab whose remote
+  command is an **attach**, not a fresh shell: `tmux new-session -A -D -s <name>`
+  with no target command (idempotent: attaches the existing session; `-D`
+  detaches any other client so keystrokes aren't mirrored). The tab carries the
+  session name so it restores and reattaches like any persistent tab. This is why
+  attach must accept an **arbitrary** name, not just `eldrun-<uid>` — a
+  hand-started `train` session opens the same way.
+- **Per-row actions:** **Kill** (`tmux kill-session -t <name>`, confirmed) and,
+  for an already-open session, "reveal the tab that owns it". Both ride the same
+  one-shot transport.
+
+**Backend:** one new pure-ish command `remote_tmux_list(project_id, host_id)` →
+`tmux ls -F '#{session_name}\t#{session_windows}\t#{session_created}\t#{session_attached}'`
+over `run_remote_script` (`ssh_exec.rs:300`), parsed into a `Vec<TmuxSession>`
+(empty, not an error, when tmux is absent or no server is running — `tmux ls`
+exits non-zero with "no server running", which the parser treats as zero
+sessions). Polled on the same cadence as the orange/status poll, so the count
+badge stays live. The attach path reuses the existing `wrap_pty_options` seam —
+the tab just declares "attach to session `<name>`" instead of "run `<cmd>`".
+
+**Close confirm.** On **close** of a persistent remote tab, confirm ("This will
+terminate the remote session `eldrun-<uid>` and any process running in it") — the
+mirror of the container toggle's non-resumable-conversation confirm, and in the
+spirit of `LocalLossDialog`: the tab is a window onto a live process, and closing
+it (vs. detaching) is destructive.
+
+## Phases
+
+- **Phase 0 — wrap + flag.** `remote_command` grows a `persist: bool` param;
+  `wrap_pty_options` passes the project's `persist_sessions` (gated on the
+  experimental flag). Pure, unit-testable: assert the exact tmux argv for
+  shell/command tabs, and that env/`cd`/bootstrap-prelude nesting is unchanged
+  when off. **No runtime behavior change until the flag/toggle is on.**
+- **Phase 1 — kill semantics.** Thread "is a persistent remote tab" into the
+  `kill` path; fire `tmux kill-session` via `run_remote_script` on explicit
+  close only. App-exit leaves sessions alive; machine disconnect ends its host's
+  sessions. Unit-test the
+  branch selection (kill-session fired vs. not) without a real host.
+- **Phase 2 — presence + transparency.** tmux-detect fallback prelude; ship the
+  `status off` / `mouse on` options; the missing-tmux notice.
+- **Phase 3 — UI: the toggle + close-confirm.** The per-project persistence
+  toggle in the remote menu; the close-confirm on a persistent tab.
+- **Phase 4 — the Sessions view.** `remote_tmux_list` command + `TmuxSession`
+  type; the `☰ N` toolbar toggle and list view in `ProjectFilesView` (mirrors
+  the Orange view); click-to-attach opening a shell tab via the attach seam;
+  per-row kill/reveal. This is the item's headline surface, not a stretch goal.
+- **Phase 5 (deferred).** `dtach` backend behind the session-backend
+  indirection; worker-host sessions; resumable remote *command* tabs.
+
+## Tests
+
+- **Automated (mine):** argv builders in `ssh_exec.rs` (tmux wrap on/off, both
+  tab kinds, nesting preserved, session name stable from uid; **attach** argv for
+  an arbitrary session name); `tmux ls` output parsing (normal list, "no server
+  running" → zero, tmux-absent → zero); kill-path branch selection; frontend
+  toggle/persistence (tsc + a `tabs` restore test proving both a persistent
+  remote shell tab and an *attach* tab restore to the same session name).
+- **Manual (the user's — Done ≠ Tested; I can't launch Eldrun or reach a host):**
+  1. Remote project, toggle on, start `python -u long_run.py` in a shell tab;
+     kill the network / sleep the laptop → reconnect → same output continues.
+  2. Quit Eldrun mid-run → relaunch → the shell tab reattaches, run still going.
+  3. **Explicitly close** the tab → confirm the session is gone on the host
+     (`tmux ls` shows no `eldrun-<uid>`).
+  4. Host without tmux → tab still works, notice shown, no persistence.
+  5. Two Eldrun windows / a stale client → `-D` detaches the other, no mirror.
+  6. **Sessions view:** start a `tmux` session by hand on the host in a plain
+     terminal → it appears in the `☰` list → click it → a tab attaches and shows
+     the live process → per-row Kill removes it and it drops from the list.
diff --git a/index.html b/index.html
index 2296a86..e3afdc4 100644
--- a/index.html
+++ b/index.html
@@ -4,6 +4,21 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Eldrun</title>
+    <script>
+      // Apply the theme BEFORE first paint. Settings arrive over an async
+      // Tauri invoke, so without this the page renders ~1s with the CSS
+      // :root default (fancy_dark) and then snaps to the real theme.
+      // stores/settings.ts keeps this cache in sync on every theme change;
+      // fancy_dark mirrors the backend default (schema::settings).
+      try {
+        document.documentElement.setAttribute(
+          "data-theme",
+          localStorage.getItem("eldrun-theme") || "fancy_dark",
+        );
+      } catch (_) {
+        document.documentElement.setAttribute("data-theme", "fancy_dark");
+      }
+    </script>
   </head>
   <body>
     <div id="root"></div>
diff --git a/package-lock.json b/package-lock.json
index 2c0c702..cb8bd9f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,20 +1,29 @@
 {
   "name": "eldrun",
-  "version": "0.1.0",
+  "version": "0.1.26",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "eldrun",
-      "version": "0.1.0",
+      "version": "0.1.26",
+      "license": "MIT OR Apache-2.0",
       "dependencies": {
+        "@crabnebula/tauri-plugin-drag": "^2.1.0",
         "@dnd-kit/core": "^6",
         "@dnd-kit/sortable": "^8",
+        "@fontsource-variable/inter": "^5.2.8",
+        "@fontsource-variable/jetbrains-mono": "^5.2.8",
         "@tauri-apps/api": "^2",
         "@tauri-apps/plugin-dialog": "^2.7.1",
+        "@tauri-apps/plugin-notification": "^2.3.3",
         "@xterm/addon-fit": "^0.10.0",
         "@xterm/addon-web-links": "^0.11.0",
         "@xterm/xterm": "^5.5.0",
+        "fflate": "^0.8.3",
+        "katex": "^0.17.0",
+        "mermaid": "^11.16.0",
+        "pdf-lib": "^1.17.1",
         "pdfjs-dist": "^4.10.38",
         "react": "^18",
         "react-dom": "^18",
@@ -24,6 +33,7 @@
         "@tauri-apps/cli": "^2",
         "@testing-library/react": "^16.3.2",
         "@testing-library/user-event": "^14.6.1",
+        "@types/katex": "^0.16.8",
         "@types/react": "^18",
         "@types/react-dom": "^18",
         "@vitejs/plugin-react": "^4",
@@ -48,6 +58,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@antfu/install-pkg": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@antfu/install-pkg/-/install-pkg-1.1.0.tgz",
+      "integrity": "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==",
+      "dependencies": {
+        "package-manager-detector": "^1.3.0",
+        "tinyexec": "^1.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
     "node_modules/@asamuzakjp/css-color": {
       "version": "5.1.11",
       "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
@@ -367,6 +389,11 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@braintree/sanitize-url": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.2.tgz",
+      "integrity": "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA=="
+    },
     "node_modules/@bramus/specificity": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
@@ -379,6 +406,19 @@
         "specificity": "bin/cli.js"
       }
     },
+    "node_modules/@chevrotain/types": {
+      "version": "11.1.2",
+      "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.1.2.tgz",
+      "integrity": "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw=="
+    },
+    "node_modules/@crabnebula/tauri-plugin-drag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@crabnebula/tauri-plugin-drag/-/tauri-plugin-drag-2.1.0.tgz",
+      "integrity": "sha512-LnUXAZwQt1cdMoGDLJ6ogW9wFCYServCZXlGadS7CA+CZ9eXS7L+Q7QyQW6g/zGw9YI2MwKFqf1aSNBGyWw+OA==",
+      "dependencies": {
+        "@tauri-apps/api": "^2.0.0"
+      }
+    },
     "node_modules/@csstools/color-helpers": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.2.tgz",
@@ -866,9 +906,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
       "cpu": [
         "arm64"
       ],
@@ -899,9 +939,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
       "cpu": [
         "arm64"
       ],
@@ -932,9 +972,9 @@
       }
     },
     "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.0.tgz",
-      "integrity": "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
+      "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
       "cpu": [
         "arm64"
       ],
@@ -1029,6 +1069,37 @@
         }
       }
     },
+    "node_modules/@fontsource-variable/inter": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/inter/-/inter-5.2.8.tgz",
+      "integrity": "sha512-kOfP2D+ykbcX/P3IFnokOhVRNoTozo5/JxhAIVYLpea/UBmCQ/YWPBfWIDuBImXX/15KH+eKh4xpEUyS2sQQGQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@fontsource-variable/jetbrains-mono": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource-variable/jetbrains-mono/-/jetbrains-mono-5.2.8.tgz",
+      "integrity": "sha512-WBA9elru6Jdp5df2mES55wuOO0WIrn3kpXnI4+W2ek5u3ZgLS9XS4gmIlcQhiZOWEKl95meYdvK7xI+ETLCq/Q==",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@iconify/types": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz",
+      "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="
+    },
+    "node_modules/@iconify/utils": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-3.1.3.tgz",
+      "integrity": "sha512-LPKOXPn/zV+zis1oOfGWogaXVpqUybF3ZS6SCZIsz8vg0ivVp9+fVqyYB7xq0aiST/VhUQYGO1qo6uoYSiEJqw==",
+      "dependencies": {
+        "@antfu/install-pkg": "^1.1.0",
+        "@iconify/types": "^2.0.0",
+        "import-meta-resolve": "^4.2.0"
+      }
+    },
     "node_modules/@jridgewell/gen-mapping": {
       "version": "0.3.13",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
@@ -1074,6 +1145,14 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@mermaid-js/parser": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-1.2.0.tgz",
+      "integrity": "sha512-oYPyv8A4As1yH5Bx+04iQEQxXuIQDe0GKCNSRgao6z8AM9jixXIfP0vsppRLvGf+nKIOb9/LdpWA4YuJiVvESA==",
+      "dependencies": {
+        "@chevrotain/types": "~11.1.2"
+      }
+    },
     "node_modules/@napi-rs/canvas": {
       "version": "0.1.100",
       "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-0.1.100.tgz",
@@ -1371,6 +1450,22 @@
         "url": "https://github.com/sponsors/Boshen"
       }
     },
+    "node_modules/@pdf-lib/standard-fonts": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/standard-fonts/-/standard-fonts-1.0.0.tgz",
+      "integrity": "sha512-hU30BK9IUN/su0Mn9VdlVKsWBS6GyhVfqjwl1FjZN4TxP6cCw0jP2w7V3Hf5uX7M0AZJ16vey9yE0ny7Sa59ZA==",
+      "dependencies": {
+        "pako": "^1.0.6"
+      }
+    },
+    "node_modules/@pdf-lib/upng": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/upng/-/upng-1.0.1.tgz",
+      "integrity": "sha512-dQK2FUMQtowVP00mtIksrlZhdFXQZPC+taih1q4CvPZ5vqdxR/LKBaFg0oAfzd1GlHZXXSPdQfzQnt+ViGvEIQ==",
+      "dependencies": {
+        "pako": "^1.0.10"
+      }
+    },
     "node_modules/@rolldown/binding-android-arm64": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.3.tgz",
@@ -2172,6 +2267,14 @@
         "@tauri-apps/api": "^2.11.0"
       }
     },
+    "node_modules/@tauri-apps/plugin-notification": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/plugin-notification/-/plugin-notification-2.3.3.tgz",
+      "integrity": "sha512-Zw+ZH18RJb41G4NrfHgIuofJiymusqN+q8fGUIIV7vyCH+5sSn5coqRv/MWB9qETsUs97vmU045q7OyseCV3Qg==",
+      "dependencies": {
+        "@tauri-apps/api": "^2.8.0"
+      }
+    },
     "node_modules/@testing-library/dom": {
       "version": "10.4.1",
       "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
@@ -2300,6 +2403,228 @@
         "assertion-error": "^2.0.1"
       }
     },
+    "node_modules/@types/d3": {
+      "version": "7.4.3",
+      "resolved": "https://registry.npmjs.org/@types/d3/-/d3-7.4.3.tgz",
+      "integrity": "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==",
+      "dependencies": {
+        "@types/d3-array": "*",
+        "@types/d3-axis": "*",
+        "@types/d3-brush": "*",
+        "@types/d3-chord": "*",
+        "@types/d3-color": "*",
+        "@types/d3-contour": "*",
+        "@types/d3-delaunay": "*",
+        "@types/d3-dispatch": "*",
+        "@types/d3-drag": "*",
+        "@types/d3-dsv": "*",
+        "@types/d3-ease": "*",
+        "@types/d3-fetch": "*",
+        "@types/d3-force": "*",
+        "@types/d3-format": "*",
+        "@types/d3-geo": "*",
+        "@types/d3-hierarchy": "*",
+        "@types/d3-interpolate": "*",
+        "@types/d3-path": "*",
+        "@types/d3-polygon": "*",
+        "@types/d3-quadtree": "*",
+        "@types/d3-random": "*",
+        "@types/d3-scale": "*",
+        "@types/d3-scale-chromatic": "*",
+        "@types/d3-selection": "*",
+        "@types/d3-shape": "*",
+        "@types/d3-time": "*",
+        "@types/d3-time-format": "*",
+        "@types/d3-timer": "*",
+        "@types/d3-transition": "*",
+        "@types/d3-zoom": "*"
+      }
+    },
+    "node_modules/@types/d3-array": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz",
+      "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw=="
+    },
+    "node_modules/@types/d3-axis": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-3.0.6.tgz",
+      "integrity": "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-brush": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-3.0.6.tgz",
+      "integrity": "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-chord": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-3.0.6.tgz",
+      "integrity": "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg=="
+    },
+    "node_modules/@types/d3-color": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
+      "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A=="
+    },
+    "node_modules/@types/d3-contour": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-3.0.6.tgz",
+      "integrity": "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==",
+      "dependencies": {
+        "@types/d3-array": "*",
+        "@types/geojson": "*"
+      }
+    },
+    "node_modules/@types/d3-delaunay": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-6.0.4.tgz",
+      "integrity": "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw=="
+    },
+    "node_modules/@types/d3-dispatch": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.7.tgz",
+      "integrity": "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA=="
+    },
+    "node_modules/@types/d3-drag": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz",
+      "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-dsv": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-3.0.7.tgz",
+      "integrity": "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g=="
+    },
+    "node_modules/@types/d3-ease": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz",
+      "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA=="
+    },
+    "node_modules/@types/d3-fetch": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-3.0.7.tgz",
+      "integrity": "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==",
+      "dependencies": {
+        "@types/d3-dsv": "*"
+      }
+    },
+    "node_modules/@types/d3-force": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-3.0.10.tgz",
+      "integrity": "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw=="
+    },
+    "node_modules/@types/d3-format": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-3.0.4.tgz",
+      "integrity": "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g=="
+    },
+    "node_modules/@types/d3-geo": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-3.1.0.tgz",
+      "integrity": "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==",
+      "dependencies": {
+        "@types/geojson": "*"
+      }
+    },
+    "node_modules/@types/d3-hierarchy": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz",
+      "integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg=="
+    },
+    "node_modules/@types/d3-interpolate": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz",
+      "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==",
+      "dependencies": {
+        "@types/d3-color": "*"
+      }
+    },
+    "node_modules/@types/d3-path": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz",
+      "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg=="
+    },
+    "node_modules/@types/d3-polygon": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-3.0.2.tgz",
+      "integrity": "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA=="
+    },
+    "node_modules/@types/d3-quadtree": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-3.0.6.tgz",
+      "integrity": "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg=="
+    },
+    "node_modules/@types/d3-random": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-3.0.3.tgz",
+      "integrity": "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ=="
+    },
+    "node_modules/@types/d3-scale": {
+      "version": "4.0.9",
+      "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz",
+      "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==",
+      "dependencies": {
+        "@types/d3-time": "*"
+      }
+    },
+    "node_modules/@types/d3-scale-chromatic": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz",
+      "integrity": "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ=="
+    },
+    "node_modules/@types/d3-selection": {
+      "version": "3.0.11",
+      "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz",
+      "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w=="
+    },
+    "node_modules/@types/d3-shape": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz",
+      "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==",
+      "dependencies": {
+        "@types/d3-path": "*"
+      }
+    },
+    "node_modules/@types/d3-time": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz",
+      "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g=="
+    },
+    "node_modules/@types/d3-time-format": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-4.0.3.tgz",
+      "integrity": "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg=="
+    },
+    "node_modules/@types/d3-timer": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz",
+      "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw=="
+    },
+    "node_modules/@types/d3-transition": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz",
+      "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==",
+      "dependencies": {
+        "@types/d3-selection": "*"
+      }
+    },
+    "node_modules/@types/d3-zoom": {
+      "version": "3.0.8",
+      "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz",
+      "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==",
+      "dependencies": {
+        "@types/d3-interpolate": "*",
+        "@types/d3-selection": "*"
+      }
+    },
     "node_modules/@types/deep-eql": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
@@ -2312,6 +2637,17 @@
       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
       "dev": true
     },
+    "node_modules/@types/geojson": {
+      "version": "7946.0.16",
+      "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz",
+      "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="
+    },
+    "node_modules/@types/katex": {
+      "version": "0.16.8",
+      "resolved": "https://registry.npmjs.org/@types/katex/-/katex-0.16.8.tgz",
+      "integrity": "sha512-trgaNyfU+Xh2Tc+ABIb44a5AYUpicB3uwirOioeOkNPPbmgRNtcWyDeeFRzjPZENO9Vq8gvVqfhaaXWLlevVwg==",
+      "dev": true
+    },
     "node_modules/@types/prop-types": {
       "version": "15.7.15",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
@@ -2337,6 +2673,21 @@
         "@types/react": "^18.0.0"
       }
     },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "optional": true
+    },
+    "node_modules/@upsetjs/venn.js": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@upsetjs/venn.js/-/venn.js-2.0.0.tgz",
+      "integrity": "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw==",
+      "optionalDependencies": {
+        "d3-selection": "^3.0.0",
+        "d3-transition": "^3.0.1"
+      }
+    },
     "node_modules/@vitejs/plugin-react": {
       "version": "4.7.0",
       "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
@@ -2728,6 +3079,14 @@
       "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
       "dev": true
     },
+    "node_modules/cose-base": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-1.0.3.tgz",
+      "integrity": "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg==",
+      "dependencies": {
+        "layout-base": "^1.0.0"
+      }
+    },
     "node_modules/css-tree": {
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
@@ -2759,6 +3118,471 @@
       "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
       "devOptional": true
     },
+    "node_modules/cytoscape": {
+      "version": "3.34.0",
+      "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.34.0.tgz",
+      "integrity": "sha512-62rNSrioXw93uliKFBwjukeQyeWwH2PqDrTac31r2P6464u3AUvTk0xS4LVvT251g7IgkFunrI48ZEZGjywSOg==",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/cytoscape-cose-bilkent": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/cytoscape-cose-bilkent/-/cytoscape-cose-bilkent-4.1.0.tgz",
+      "integrity": "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==",
+      "dependencies": {
+        "cose-base": "^1.0.0"
+      },
+      "peerDependencies": {
+        "cytoscape": "^3.2.0"
+      }
+    },
+    "node_modules/cytoscape-fcose": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/cytoscape-fcose/-/cytoscape-fcose-2.2.0.tgz",
+      "integrity": "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ==",
+      "dependencies": {
+        "cose-base": "^2.2.0"
+      },
+      "peerDependencies": {
+        "cytoscape": "^3.2.0"
+      }
+    },
+    "node_modules/cytoscape-fcose/node_modules/cose-base": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-2.2.0.tgz",
+      "integrity": "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==",
+      "dependencies": {
+        "layout-base": "^2.0.0"
+      }
+    },
+    "node_modules/cytoscape-fcose/node_modules/layout-base": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-2.0.1.tgz",
+      "integrity": "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg=="
+    },
+    "node_modules/d3": {
+      "version": "7.9.0",
+      "resolved": "https://registry.npmjs.org/d3/-/d3-7.9.0.tgz",
+      "integrity": "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==",
+      "dependencies": {
+        "d3-array": "3",
+        "d3-axis": "3",
+        "d3-brush": "3",
+        "d3-chord": "3",
+        "d3-color": "3",
+        "d3-contour": "4",
+        "d3-delaunay": "6",
+        "d3-dispatch": "3",
+        "d3-drag": "3",
+        "d3-dsv": "3",
+        "d3-ease": "3",
+        "d3-fetch": "3",
+        "d3-force": "3",
+        "d3-format": "3",
+        "d3-geo": "3",
+        "d3-hierarchy": "3",
+        "d3-interpolate": "3",
+        "d3-path": "3",
+        "d3-polygon": "3",
+        "d3-quadtree": "3",
+        "d3-random": "3",
+        "d3-scale": "4",
+        "d3-scale-chromatic": "3",
+        "d3-selection": "3",
+        "d3-shape": "3",
+        "d3-time": "3",
+        "d3-time-format": "4",
+        "d3-timer": "3",
+        "d3-transition": "3",
+        "d3-zoom": "3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-array": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz",
+      "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==",
+      "dependencies": {
+        "internmap": "1 - 2"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-axis": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-3.0.0.tgz",
+      "integrity": "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-brush": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-3.0.0.tgz",
+      "integrity": "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-drag": "2 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-selection": "3",
+        "d3-transition": "3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-chord": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-3.0.1.tgz",
+      "integrity": "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==",
+      "dependencies": {
+        "d3-path": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-color": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+      "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-contour": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-4.0.2.tgz",
+      "integrity": "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==",
+      "dependencies": {
+        "d3-array": "^3.2.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-delaunay": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/d3-delaunay/-/d3-delaunay-6.0.4.tgz",
+      "integrity": "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==",
+      "dependencies": {
+        "delaunator": "5"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-dispatch": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz",
+      "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-drag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz",
+      "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-selection": "3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-dsv": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-3.0.1.tgz",
+      "integrity": "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==",
+      "dependencies": {
+        "commander": "7",
+        "iconv-lite": "0.6",
+        "rw": "1"
+      },
+      "bin": {
+        "csv2json": "bin/dsv2json.js",
+        "csv2tsv": "bin/dsv2dsv.js",
+        "dsv2dsv": "bin/dsv2dsv.js",
+        "dsv2json": "bin/dsv2json.js",
+        "json2csv": "bin/json2dsv.js",
+        "json2dsv": "bin/json2dsv.js",
+        "json2tsv": "bin/json2dsv.js",
+        "tsv2csv": "bin/dsv2dsv.js",
+        "tsv2json": "bin/dsv2json.js"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-dsv/node_modules/commander": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz",
+      "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==",
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/d3-ease": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz",
+      "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-fetch": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-3.0.1.tgz",
+      "integrity": "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==",
+      "dependencies": {
+        "d3-dsv": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-force": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-3.0.0.tgz",
+      "integrity": "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-quadtree": "1 - 3",
+        "d3-timer": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-format": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz",
+      "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-geo": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-3.1.1.tgz",
+      "integrity": "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==",
+      "dependencies": {
+        "d3-array": "2.5.0 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-hierarchy": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz",
+      "integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-interpolate": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+      "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+      "dependencies": {
+        "d3-color": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-path": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz",
+      "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-polygon": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-3.0.1.tgz",
+      "integrity": "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-quadtree": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-3.0.1.tgz",
+      "integrity": "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-random": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-random/-/d3-random-3.0.1.tgz",
+      "integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-sankey": {
+      "version": "0.12.3",
+      "resolved": "https://registry.npmjs.org/d3-sankey/-/d3-sankey-0.12.3.tgz",
+      "integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==",
+      "dependencies": {
+        "d3-array": "1 - 2",
+        "d3-shape": "^1.2.0"
+      }
+    },
+    "node_modules/d3-sankey/node_modules/d3-array": {
+      "version": "2.12.1",
+      "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-2.12.1.tgz",
+      "integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==",
+      "dependencies": {
+        "internmap": "^1.0.0"
+      }
+    },
+    "node_modules/d3-sankey/node_modules/d3-path": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz",
+      "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="
+    },
+    "node_modules/d3-sankey/node_modules/d3-shape": {
+      "version": "1.3.7",
+      "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz",
+      "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==",
+      "dependencies": {
+        "d3-path": "1"
+      }
+    },
+    "node_modules/d3-sankey/node_modules/internmap": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/internmap/-/internmap-1.0.1.tgz",
+      "integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="
+    },
+    "node_modules/d3-scale": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz",
+      "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==",
+      "dependencies": {
+        "d3-array": "2.10.0 - 3",
+        "d3-format": "1 - 3",
+        "d3-interpolate": "1.2.0 - 3",
+        "d3-time": "2.1.1 - 3",
+        "d3-time-format": "2 - 4"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-scale-chromatic": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz",
+      "integrity": "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==",
+      "dependencies": {
+        "d3-color": "1 - 3",
+        "d3-interpolate": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-selection": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
+      "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-shape": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz",
+      "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==",
+      "dependencies": {
+        "d3-path": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz",
+      "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==",
+      "dependencies": {
+        "d3-array": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time-format": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz",
+      "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==",
+      "dependencies": {
+        "d3-time": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-timer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
+      "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-transition": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz",
+      "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==",
+      "dependencies": {
+        "d3-color": "1 - 3",
+        "d3-dispatch": "1 - 3",
+        "d3-ease": "1 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-timer": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "peerDependencies": {
+        "d3-selection": "2 - 3"
+      }
+    },
+    "node_modules/d3-zoom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz",
+      "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==",
+      "dependencies": {
+        "d3-dispatch": "1 - 3",
+        "d3-drag": "2 - 3",
+        "d3-interpolate": "1 - 3",
+        "d3-selection": "2 - 3",
+        "d3-transition": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/dagre-d3-es": {
+      "version": "7.0.14",
+      "resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.14.tgz",
+      "integrity": "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg==",
+      "dependencies": {
+        "d3": "^7.9.0",
+        "lodash-es": "^4.17.21"
+      }
+    },
     "node_modules/data-urls": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
@@ -2772,6 +3596,11 @@
         "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
+    "node_modules/dayjs": {
+      "version": "1.11.21",
+      "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.21.tgz",
+      "integrity": "sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA=="
+    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -2795,6 +3624,14 @@
       "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
       "dev": true
     },
+    "node_modules/delaunator": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/delaunator/-/delaunator-5.1.0.tgz",
+      "integrity": "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ==",
+      "dependencies": {
+        "robust-predicates": "^3.0.2"
+      }
+    },
     "node_modules/dequal": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
@@ -2833,6 +3670,14 @@
       "dev": true,
       "peer": true
     },
+    "node_modules/dompurify": {
+      "version": "3.4.11",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.11.tgz",
+      "integrity": "sha512-zhlUV12GsaRzMsf9q5M254YhA4+VuF0fG+QFqu6aYpoGlKtz+w8//jBcGVYBgQkR5GHjUomejY84AV+/uPbWdw==",
+      "optionalDependencies": {
+        "@types/trusted-types": "^2.0.7"
+      }
+    },
     "node_modules/electron-to-chromium": {
       "version": "1.5.364",
       "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.364.tgz",
@@ -2866,6 +3711,11 @@
       "integrity": "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==",
       "dev": true
     },
+    "node_modules/es-toolkit": {
+      "version": "1.48.1",
+      "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.48.1.tgz",
+      "integrity": "sha512-wfnXlwd5I75eXRtdD2vuEs50xHHESECDsGD7yiQnfFVNoa5522NwXEbmgo98LfiukSQHs+mBM7/YG3qKJB9/mQ=="
+    },
     "node_modules/esbuild": {
       "version": "0.21.5",
       "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
@@ -2968,6 +3818,11 @@
         "reusify": "^1.0.4"
       }
     },
+    "node_modules/fflate": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
+      "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA=="
+    },
     "node_modules/fill-range": {
       "version": "7.1.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
@@ -3037,6 +3892,11 @@
         "node": ">=10.13.0"
       }
     },
+    "node_modules/hachure-fill": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/hachure-fill/-/hachure-fill-0.5.2.tgz",
+      "integrity": "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg=="
+    },
     "node_modules/hasown": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
@@ -3061,6 +3921,34 @@
         "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
       }
     },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/import-meta-resolve": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-4.2.0.tgz",
+      "integrity": "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg==",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/internmap": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
+      "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -3211,6 +4099,39 @@
         "node": ">=6"
       }
     },
+    "node_modules/katex": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/katex/-/katex-0.17.0.tgz",
+      "integrity": "sha512-Vdw0ATsQ9V+LuegM/BTwQqV/6cTl5lbGcIrU+BCgLxyf6bo38ybOr372tuSIxir3CN720flu1meYR6XzNMwQnw==",
+      "funding": [
+        "https://opencollective.com/katex",
+        "https://github.com/sponsors/katex"
+      ],
+      "dependencies": {
+        "commander": "^8.3.0"
+      },
+      "bin": {
+        "katex": "cli.js"
+      }
+    },
+    "node_modules/katex/node_modules/commander": {
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
+      "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/khroma": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz",
+      "integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="
+    },
+    "node_modules/layout-base": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-1.0.2.tgz",
+      "integrity": "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="
+    },
     "node_modules/lightningcss": {
       "version": "1.32.0",
       "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
@@ -3478,6 +4399,11 @@
       "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
       "dev": true
     },
+    "node_modules/lodash-es": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz",
+      "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A=="
+    },
     "node_modules/loose-envify": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
@@ -3517,6 +4443,17 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/marked": {
+      "version": "16.4.2",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-16.4.2.tgz",
+      "integrity": "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA==",
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
     "node_modules/mdn-data": {
       "version": "2.27.1",
       "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
@@ -3532,6 +4469,57 @@
         "node": ">= 8"
       }
     },
+    "node_modules/mermaid": {
+      "version": "11.16.0",
+      "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.16.0.tgz",
+      "integrity": "sha512-Zvm3kbstgdpvIJPPItlL7fppIZ3kibvc1oZIGxdvk9t6UFz6flv+Jw7FtRGKwfcI8OckmH04LqG6LlS6X4B1pA==",
+      "dependencies": {
+        "@braintree/sanitize-url": "^7.1.2",
+        "@iconify/utils": "^3.0.2",
+        "@mermaid-js/parser": "^1.2.0",
+        "@types/d3": "^7.4.3",
+        "@upsetjs/venn.js": "^2.0.0",
+        "cytoscape": "^3.33.3",
+        "cytoscape-cose-bilkent": "^4.1.0",
+        "cytoscape-fcose": "^2.2.0",
+        "d3": "^7.9.0",
+        "d3-sankey": "^0.12.3",
+        "dagre-d3-es": "7.0.14",
+        "dayjs": "^1.11.20",
+        "dompurify": "^3.3.3",
+        "es-toolkit": "^1.45.1",
+        "katex": "^0.16.45",
+        "khroma": "^2.1.0",
+        "marked": "^16.3.0",
+        "roughjs": "^4.6.6",
+        "stylis": "^4.3.6",
+        "ts-dedent": "^2.2.0",
+        "uuid": "^11.1.0 || ^12 || ^13 || ^14.0.0"
+      }
+    },
+    "node_modules/mermaid/node_modules/commander": {
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz",
+      "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/mermaid/node_modules/katex": {
+      "version": "0.16.47",
+      "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.47.tgz",
+      "integrity": "sha512-Eeo8Ys1doU1z+x8AZsPpQu+p/QcZBI5PeOo7QGQdy2x2m0MU/hYagBbGOmXwr5KVbEfVuWv9LpnQWeehogurjg==",
+      "funding": [
+        "https://opencollective.com/katex",
+        "https://github.com/sponsors/katex"
+      ],
+      "dependencies": {
+        "commander": "^8.3.0"
+      },
+      "bin": {
+        "katex": "cli.js"
+      }
+    },
     "node_modules/micromatch": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
@@ -3629,6 +4617,16 @@
         "node": ">=12.20.0"
       }
     },
+    "node_modules/package-manager-detector": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.6.0.tgz",
+      "integrity": "sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA=="
+    },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw=="
+    },
     "node_modules/parse5": {
       "version": "8.0.1",
       "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
@@ -3641,6 +4639,11 @@
         "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
+    "node_modules/path-data-parser": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/path-data-parser/-/path-data-parser-0.1.0.tgz",
+      "integrity": "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w=="
+    },
     "node_modules/path-parse": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
@@ -3653,6 +4656,22 @@
       "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
       "dev": true
     },
+    "node_modules/pdf-lib": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/pdf-lib/-/pdf-lib-1.17.1.tgz",
+      "integrity": "sha512-V/mpyJAoTsN4cnP31vc0wfNA1+p20evqqnap0KLoRUN0Yk/p3wN52DOEsL4oBFcLdb76hlpKPtzJIgo67j/XLw==",
+      "dependencies": {
+        "@pdf-lib/standard-fonts": "^1.0.0",
+        "@pdf-lib/upng": "^1.0.1",
+        "pako": "^1.0.11",
+        "tslib": "^1.11.1"
+      }
+    },
+    "node_modules/pdf-lib/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="
+    },
     "node_modules/pdfjs-dist": {
       "version": "4.10.38",
       "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-4.10.38.tgz",
@@ -3700,6 +4719,20 @@
         "node": ">= 6"
       }
     },
+    "node_modules/points-on-curve": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/points-on-curve/-/points-on-curve-0.2.0.tgz",
+      "integrity": "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="
+    },
+    "node_modules/points-on-path": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/points-on-path/-/points-on-path-0.2.1.tgz",
+      "integrity": "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g==",
+      "dependencies": {
+        "path-data-parser": "0.1.0",
+        "points-on-curve": "0.2.0"
+      }
+    },
     "node_modules/postcss": {
       "version": "8.5.15",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
@@ -4000,6 +5033,11 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/robust-predicates": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.3.tgz",
+      "integrity": "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA=="
+    },
     "node_modules/rolldown": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.3.tgz",
@@ -4083,6 +5121,17 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/roughjs": {
+      "version": "4.6.6",
+      "resolved": "https://registry.npmjs.org/roughjs/-/roughjs-4.6.6.tgz",
+      "integrity": "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ==",
+      "dependencies": {
+        "hachure-fill": "^0.5.2",
+        "path-data-parser": "^0.1.0",
+        "points-on-curve": "^0.2.0",
+        "points-on-path": "^0.2.1"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -4106,6 +5155,16 @@
         "queue-microtask": "^1.2.2"
       }
     },
+    "node_modules/rw": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz",
+      "integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ=="
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
     "node_modules/saxes": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
@@ -4162,6 +5221,11 @@
       "integrity": "sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==",
       "dev": true
     },
+    "node_modules/stylis": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.4.0.tgz",
+      "integrity": "sha512-5Z9ZpRzfuH6l/UAvCPAPUo3665Nk2wLaZU3x+TLHKVzIz33+sbJqbtrYoC3KD4/uVOr2Zp+L0LySezP9OHV9yA=="
+    },
     "node_modules/sucrase": {
       "version": "3.35.1",
       "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
@@ -4270,7 +5334,6 @@
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
       "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
-      "dev": true,
       "engines": {
         "node": ">=18"
       }
@@ -4383,6 +5446,14 @@
         "node": ">=20"
       }
     },
+    "node_modules/ts-dedent": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.3.0.tgz",
+      "integrity": "sha512-JfJeIHke7y2egdGGgRAvpCwYFUsHlM2gPcrVOxFkznt/4uzQ7HFmvE63iFHVLBJNDuyDOQgijDK/tXH/f6Msjg==",
+      "engines": {
+        "node": ">=6.10"
+      }
+    },
     "node_modules/ts-interface-checker": {
       "version": "0.1.13",
       "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
@@ -4452,6 +5523,18 @@
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
       "dev": true
     },
+    "node_modules/uuid": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-14.0.1.tgz",
+      "integrity": "sha512-6ZxzVpzDXDa3bJWaHilVayA+BH/1zmxCJoVgvmqJnid/gPoKHxUrS/aC/T6LGQtNHT+XHG9fXPJB4d+IrU30Ew==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "bin": {
+        "uuid": "dist-node/bin/uuid"
+      }
+    },
     "node_modules/vite": {
       "version": "5.4.21",
       "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
@@ -4601,9 +5684,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/aix-ppc64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.0.tgz",
-      "integrity": "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
+      "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
       "cpu": [
         "ppc64"
       ],
@@ -4618,9 +5701,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/android-arm": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.0.tgz",
-      "integrity": "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
+      "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
       "cpu": [
         "arm"
       ],
@@ -4635,9 +5718,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/android-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.0.tgz",
-      "integrity": "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
+      "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
       "cpu": [
         "arm64"
       ],
@@ -4652,9 +5735,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/android-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.0.tgz",
-      "integrity": "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
+      "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
       "cpu": [
         "x64"
       ],
@@ -4669,9 +5752,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.0.tgz",
-      "integrity": "sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
+      "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
       "cpu": [
         "arm64"
       ],
@@ -4686,9 +5769,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/darwin-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.0.tgz",
-      "integrity": "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
+      "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
       "cpu": [
         "x64"
       ],
@@ -4703,9 +5786,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
       "cpu": [
         "arm64"
       ],
@@ -4720,9 +5803,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.0.tgz",
-      "integrity": "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
       "cpu": [
         "x64"
       ],
@@ -4737,9 +5820,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-arm": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.0.tgz",
-      "integrity": "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
+      "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
       "cpu": [
         "arm"
       ],
@@ -4754,9 +5837,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.0.tgz",
-      "integrity": "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
+      "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
       "cpu": [
         "arm64"
       ],
@@ -4771,9 +5854,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-ia32": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.0.tgz",
-      "integrity": "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
+      "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
       "cpu": [
         "ia32"
       ],
@@ -4788,9 +5871,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-loong64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.0.tgz",
-      "integrity": "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
+      "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
       "cpu": [
         "loong64"
       ],
@@ -4805,9 +5888,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.0.tgz",
-      "integrity": "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
+      "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
       "cpu": [
         "mips64el"
       ],
@@ -4822,9 +5905,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.0.tgz",
-      "integrity": "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
+      "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
       "cpu": [
         "ppc64"
       ],
@@ -4839,9 +5922,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.0.tgz",
-      "integrity": "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
+      "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
       "cpu": [
         "riscv64"
       ],
@@ -4856,9 +5939,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-s390x": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.0.tgz",
-      "integrity": "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
+      "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
       "cpu": [
         "s390x"
       ],
@@ -4873,9 +5956,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/linux-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.0.tgz",
-      "integrity": "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
+      "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
       "cpu": [
         "x64"
       ],
@@ -4890,9 +5973,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.0.tgz",
-      "integrity": "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
       "cpu": [
         "x64"
       ],
@@ -4907,9 +5990,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.0.tgz",
-      "integrity": "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
       "cpu": [
         "x64"
       ],
@@ -4924,9 +6007,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/sunos-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.0.tgz",
-      "integrity": "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
+      "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
       "cpu": [
         "x64"
       ],
@@ -4941,9 +6024,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/win32-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.0.tgz",
-      "integrity": "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
+      "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
       "cpu": [
         "arm64"
       ],
@@ -4958,9 +6041,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/win32-ia32": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.0.tgz",
-      "integrity": "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
+      "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
       "cpu": [
         "ia32"
       ],
@@ -4975,9 +6058,9 @@
       }
     },
     "node_modules/vitest/node_modules/@esbuild/win32-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.0.tgz",
-      "integrity": "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
+      "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
       "cpu": [
         "x64"
       ],
@@ -5018,9 +6101,9 @@
       }
     },
     "node_modules/vitest/node_modules/esbuild": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.0.tgz",
-      "integrity": "sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+      "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
       "dev": true,
       "hasInstallScript": true,
       "optional": true,
@@ -5032,32 +6115,32 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.28.0",
-        "@esbuild/android-arm": "0.28.0",
-        "@esbuild/android-arm64": "0.28.0",
-        "@esbuild/android-x64": "0.28.0",
-        "@esbuild/darwin-arm64": "0.28.0",
-        "@esbuild/darwin-x64": "0.28.0",
-        "@esbuild/freebsd-arm64": "0.28.0",
-        "@esbuild/freebsd-x64": "0.28.0",
-        "@esbuild/linux-arm": "0.28.0",
-        "@esbuild/linux-arm64": "0.28.0",
-        "@esbuild/linux-ia32": "0.28.0",
-        "@esbuild/linux-loong64": "0.28.0",
-        "@esbuild/linux-mips64el": "0.28.0",
-        "@esbuild/linux-ppc64": "0.28.0",
-        "@esbuild/linux-riscv64": "0.28.0",
-        "@esbuild/linux-s390x": "0.28.0",
-        "@esbuild/linux-x64": "0.28.0",
-        "@esbuild/netbsd-arm64": "0.28.0",
-        "@esbuild/netbsd-x64": "0.28.0",
-        "@esbuild/openbsd-arm64": "0.28.0",
-        "@esbuild/openbsd-x64": "0.28.0",
-        "@esbuild/openharmony-arm64": "0.28.0",
-        "@esbuild/sunos-x64": "0.28.0",
-        "@esbuild/win32-arm64": "0.28.0",
-        "@esbuild/win32-ia32": "0.28.0",
-        "@esbuild/win32-x64": "0.28.0"
+        "@esbuild/aix-ppc64": "0.28.1",
+        "@esbuild/android-arm": "0.28.1",
+        "@esbuild/android-arm64": "0.28.1",
+        "@esbuild/android-x64": "0.28.1",
+        "@esbuild/darwin-arm64": "0.28.1",
+        "@esbuild/darwin-x64": "0.28.1",
+        "@esbuild/freebsd-arm64": "0.28.1",
+        "@esbuild/freebsd-x64": "0.28.1",
+        "@esbuild/linux-arm": "0.28.1",
+        "@esbuild/linux-arm64": "0.28.1",
+        "@esbuild/linux-ia32": "0.28.1",
+        "@esbuild/linux-loong64": "0.28.1",
+        "@esbuild/linux-mips64el": "0.28.1",
+        "@esbuild/linux-ppc64": "0.28.1",
+        "@esbuild/linux-riscv64": "0.28.1",
+        "@esbuild/linux-s390x": "0.28.1",
+        "@esbuild/linux-x64": "0.28.1",
+        "@esbuild/netbsd-arm64": "0.28.1",
+        "@esbuild/netbsd-x64": "0.28.1",
+        "@esbuild/openbsd-arm64": "0.28.1",
+        "@esbuild/openbsd-x64": "0.28.1",
+        "@esbuild/openharmony-arm64": "0.28.1",
+        "@esbuild/sunos-x64": "0.28.1",
+        "@esbuild/win32-arm64": "0.28.1",
+        "@esbuild/win32-ia32": "0.28.1",
+        "@esbuild/win32-x64": "0.28.1"
       }
     },
     "node_modules/vitest/node_modules/picomatch": {
diff --git a/package.json b/package.json
index d287d1a..260939c 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,8 @@
 {
   "name": "eldrun",
   "private": true,
-  "version": "0.1.0",
+  "version": "0.1.40",
+  "license": "MIT OR Apache-2.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -11,18 +12,27 @@
     "tauri:dev": "tauri dev",
     "tauri:build": "tauri build",
     "tauri:bundle": "tauri build --bundles appimage,deb",
+    "tauri:bundle:mac": "tauri build --bundles dmg",
     "package": "./scripts/package-local.sh",
     "test": "vitest run",
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@crabnebula/tauri-plugin-drag": "^2.1.0",
     "@dnd-kit/core": "^6",
     "@dnd-kit/sortable": "^8",
+    "@fontsource-variable/inter": "^5.2.8",
+    "@fontsource-variable/jetbrains-mono": "^5.2.8",
     "@tauri-apps/api": "^2",
     "@tauri-apps/plugin-dialog": "^2.7.1",
+    "@tauri-apps/plugin-notification": "^2.3.3",
     "@xterm/addon-fit": "^0.10.0",
     "@xterm/addon-web-links": "^0.11.0",
     "@xterm/xterm": "^5.5.0",
+    "fflate": "^0.8.3",
+    "katex": "^0.17.0",
+    "mermaid": "^11.16.0",
+    "pdf-lib": "^1.17.1",
     "pdfjs-dist": "^4.10.38",
     "react": "^18",
     "react-dom": "^18",
@@ -32,6 +42,7 @@
     "@tauri-apps/cli": "^2",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
+    "@types/katex": "^0.16.8",
     "@types/react": "^18",
     "@types/react-dom": "^18",
     "@vitejs/plugin-react": "^4",
diff --git a/screenshots/eldrun-functionality.svg b/screenshots/eldrun-functionality.svg
new file mode 100644
index 0000000..a3dea4d
--- /dev/null
+++ b/screenshots/eldrun-functionality.svg
@@ -0,0 +1,129 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 960 740" font-family="ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, sans-serif">
+  <!-- card -->
+  <rect x="8" y="8" width="944" height="724" rx="18" fill="#0f1420" stroke="#2f3a4d" stroke-width="1.5"/>
+
+  <!-- header -->
+  <text x="32" y="42" font-size="19" font-weight="700" letter-spacing="2" fill="#e6edf3">ELDRUN</text>
+  <text x="118" y="42" font-size="12.5" fill="#7c8cff">·  you don't open applications, you open projects — and the project brings its machines</text>
+
+  <!-- ===================== Band 1: projects ===================== -->
+  <rect x="32" y="64" width="896" height="74" rx="12" fill="#151b27" stroke="#2c3647"/>
+  <text x="48" y="88" font-size="12" font-weight="700" letter-spacing="0.6" fill="#7c8cff">① PROJECTS · PROJECT SWITCHING</text>
+  <!-- active pill -->
+  <rect x="48" y="100" width="128" height="28" rx="9" fill="#1f6f63" stroke="#36c5b0"/>
+  <text x="62" y="119" font-size="12" font-weight="600" fill="#d7fff6">● Project A</text>
+  <rect x="188" y="100" width="104" height="28" rx="9" fill="#20283a" stroke="#313d52"/>
+  <text x="202" y="119" font-size="12" fill="#c7d2e6">Project B</text>
+  <rect x="304" y="100" width="104" height="28" rx="9" fill="#20283a" stroke="#313d52"/>
+  <text x="318" y="119" font-size="12" fill="#c7d2e6">Project C</text>
+  <rect x="420" y="100" width="86" height="28" rx="9" fill="#2a2438" stroke="#5a4b86"/>
+  <text x="434" y="119" font-size="12" fill="#cbbdf0">▦ Box</text>
+  <rect x="518" y="100" width="34" height="28" rx="9" fill="#20283a" stroke="#313d52"/>
+  <text x="531" y="119" font-size="14" fill="#8aa0c0">+</text>
+  <rect x="576" y="100" width="190" height="28" rx="9" fill="#132635" stroke="#4bb3fd"/>
+  <text x="590" y="119" font-size="11.5" fill="#bfe4ff">◉ runs on: cluster-login</text>
+  <text x="912" y="92" text-anchor="end" font-size="12" fill="#9aa7bd">14:32</text>
+  <text x="912" y="120" text-anchor="end" font-size="11" fill="#7c8898">today · 2h 14m</text>
+
+  <!-- arrow -->
+  <line x1="480" y1="138" x2="480" y2="168" stroke="#41506b" stroke-width="2"/>
+  <path d="M480 174 l-6 -9 h12 z" fill="#41506b"/>
+  <text x="494" y="160" font-size="11" fill="#7c8898">open a project → swap the whole desktop</text>
+
+  <!-- ===================== Band 2: tabs ===================== -->
+  <rect x="32" y="180" width="612" height="262" rx="12" fill="#131a26" stroke="#2c3647"/>
+  <text x="48" y="204" font-size="12" font-weight="700" letter-spacing="0.6" fill="#36c5b0">② TAB MANAGEMENT · TILING SUBWINDOWS</text>
+
+  <!-- tab strip -->
+  <rect x="48" y="214" width="108" height="26" rx="8" fill="#2c2f56" stroke="#7c8cff"/>
+  <text x="62" y="231" font-size="11.5" font-weight="600" fill="#cfd6ff">▤ Claude</text>
+  <rect x="162" y="214" width="78" height="26" rx="8" fill="#1b2233" stroke="#313d52"/>
+  <text x="176" y="231" font-size="11.5" fill="#aab6cc">Codex</text>
+  <rect x="246" y="214" width="78" height="26" rx="8" fill="#1b2233" stroke="#313d52"/>
+  <text x="260" y="231" font-size="11.5" fill="#aab6cc">$ shell</text>
+  <rect x="330" y="214" width="104" height="26" rx="8" fill="#1b2233" stroke="#313d52"/>
+  <text x="344" y="231" font-size="11.5" fill="#aab6cc">◧ notes.md</text>
+  <text x="556" y="231" font-size="11" fill="#5f6f88">⤢ pop-out</text>
+
+  <!-- three cards -->
+  <!-- card A: agent tabs -->
+  <rect x="48" y="252" width="188" height="178" rx="10" fill="#0f1622" stroke="#283246"/>
+  <text x="64" y="276" font-size="12" font-weight="700" fill="#7c8cff">Agent tabs</text>
+  <text x="64" y="300" font-size="11" fill="#aab6cc">• Claude</text>
+  <text x="64" y="320" font-size="11" fill="#aab6cc">• Codex</text>
+  <text x="64" y="340" font-size="11" fill="#aab6cc">• Gemini</text>
+  <text x="64" y="360" font-size="11" fill="#aab6cc">• Ollama (local model)</text>
+  <text x="64" y="392" font-size="10.5" fill="#5f6f88">resumable sessions,</text>
+  <text x="64" y="408" font-size="10.5" fill="#5f6f88">project sandbox env</text>
+
+  <!-- card B: shell tabs -->
+  <rect x="244" y="252" width="188" height="178" rx="10" fill="#0f1622" stroke="#283246"/>
+  <text x="260" y="276" font-size="12" font-weight="700" fill="#57c38a">Shell tabs</text>
+  <text x="260" y="300" font-size="11" fill="#aab6cc">• Root control terminal</text>
+  <text x="260" y="320" font-size="11" fill="#aab6cc">• Per-project shells</text>
+  <text x="260" y="340" font-size="11" fill="#aab6cc">• Remote (SSH) shells</text>
+  <text x="260" y="392" font-size="10.5" fill="#5f6f88">drag-to-tile: split a</text>
+  <text x="260" y="408" font-size="10.5" fill="#5f6f88">pane any direction</text>
+
+  <!-- card C: native viewers -->
+  <rect x="440" y="252" width="188" height="178" rx="10" fill="#0f1622" stroke="#283246"/>
+  <text x="456" y="276" font-size="12" font-weight="700" fill="#e3b341">Native viewers</text>
+  <text x="456" y="300" font-size="11" fill="#aab6cc">• text · markdown · LaTeX</text>
+  <text x="456" y="320" font-size="11" fill="#aab6cc">• PDF · images</text>
+  <text x="456" y="340" font-size="11" fill="#aab6cc">• CSV · notebook · diff</text>
+  <text x="456" y="360" font-size="11" fill="#aab6cc">• ODT</text>
+  <text x="456" y="392" font-size="10.5" fill="#5f6f88">SQLite · HTML · A/V</text>
+  <text x="456" y="408" font-size="10.5" fill="#5f6f88">in progress</text>
+
+  <!-- ===================== Right panel ===================== -->
+  <rect x="656" y="180" width="272" height="262" rx="12" fill="#131a26" stroke="#2c3647"/>
+  <text x="672" y="204" font-size="12" font-weight="700" letter-spacing="0.6" fill="#f0789f">RIGHT PANEL</text>
+  <rect x="672" y="214" width="62" height="26" rx="8" fill="#3a2230" stroke="#f0789f"/>
+  <text x="686" y="231" font-size="11.5" font-weight="600" fill="#ffd0e0">Files</text>
+  <rect x="742" y="214" width="56" height="26" rx="8" fill="#1b2233" stroke="#313d52"/>
+  <text x="756" y="231" font-size="11.5" fill="#aab6cc">Git</text>
+  <rect x="806" y="214" width="78" height="26" rx="8" fill="#1b2233" stroke="#313d52"/>
+  <text x="820" y="231" font-size="11.5" fill="#aab6cc">Search</text>
+  <text x="672" y="266" font-size="11" fill="#aab6cc">• git status markers</text>
+  <text x="672" y="286" font-size="11" fill="#aab6cc">• branch checkout · commit</text>
+  <text x="672" y="306" font-size="11" fill="#aab6cc">• project-wide content search</text>
+  <text x="672" y="326" font-size="11" fill="#aab6cc">• copy / cut / paste files</text>
+
+  <line x1="672" y1="346" x2="912" y2="346" stroke="#283246"/>
+  <text x="672" y="370" font-size="11.5" font-weight="700" letter-spacing="0.4" fill="#f0789f">GLOBAL APP TOOLBAR</text>
+  <text x="672" y="394" font-size="11" fill="#aab6cc">• Browser · Mail · Calendar</text>
+  <text x="672" y="414" font-size="11" fill="#aab6cc">• Screenshot ▸ region · Notes …</text>
+
+  <!-- ===================== Band 3: desktop layer ===================== -->
+  <rect x="32" y="456" width="896" height="104" rx="12" fill="#151b27" stroke="#2c3647"/>
+  <text x="48" y="480" font-size="12" font-weight="700" letter-spacing="0.6" fill="#36c5b0">③ PROJECT DESKTOP LAYER — switches as one unit</text>
+
+  <g font-size="11" fill="#c7d2e6">
+    <rect x="48"  y="490" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="62"  y="507">Window parking</text>
+    <rect x="264" y="490" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="278" y="507">Downloads routing</text>
+    <rect x="480" y="490" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="494" y="507">Default-app mapping</text>
+    <rect x="696" y="490" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="710" y="507">Time tracking</text>
+    <rect x="48"  y="524" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="62"  y="541">Project boxes</text>
+    <rect x="264" y="524" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="278" y="541">External window tracking</text>
+    <rect x="480" y="524" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="494" y="541">Publish to GitHub</text>
+    <rect x="696" y="524" width="200" height="26" rx="8" fill="#1b2233" stroke="#313d52"/><text x="710" y="541">Pop-out windows</text>
+  </g>
+
+  <!-- ===================== Band 4: machines ===================== -->
+  <rect x="32" y="576" width="896" height="104" rx="12" fill="#151b27" stroke="#2c3647"/>
+  <text x="48" y="600" font-size="12" font-weight="700" letter-spacing="0.6" fill="#4bb3fd">④ MACHINE LAYER — the same project, run on SSH hosts, GPU boxes or an HPC cluster</text>
+
+  <g font-size="11" fill="#c7d2e6">
+    <rect x="48"  y="610" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="62"  y="627">Machine hub · live CPU/GPU</text>
+    <rect x="264" y="610" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="278" y="627">Tabs run on the host (ssh -tt)</text>
+    <rect x="480" y="610" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="494" y="627">Files over SFTP · no mount</text>
+    <rect x="696" y="610" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="710" y="627">Git lockstep + byte-sync</text>
+    <rect x="48"  y="644" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="62"  y="661">Many hosts per project</text>
+    <rect x="264" y="644" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="278" y="661">tmux · runs survive drops</text>
+    <rect x="480" y="644" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="494" y="661">SLURM: sbatch · squeue · srun</text>
+    <rect x="696" y="644" width="200" height="26" rx="8" fill="#12202c" stroke="#2b4a63"/><text x="710" y="661">HPC workspaces (parallel FS)</text>
+  </g>
+
+  <!-- footer -->
+  <text x="480" y="706" text-anchor="middle" font-size="11" fill="#5f6f88">Linux-first · X11 + KDE Wayland · Tauri 2 + React + TypeScript · xterm.js · Zustand</text>
+</svg>
diff --git a/scripts/bump-version.sh b/scripts/bump-version.sh
new file mode 100755
index 0000000..24bb03f
--- /dev/null
+++ b/scripts/bump-version.sh
@@ -0,0 +1,79 @@
+#!/usr/bin/env bash
+#
+# Bump the Eldrun version across the four files that must stay in lockstep:
+#   - package.json
+#   - src-tauri/Cargo.toml   (the [package] version)
+#   - src-tauri/tauri.conf.json
+#   - Cargo.lock             (the workspace's own [[package]] entry)
+#
+# The lockfile is in the list because cargo rewrites that entry from Cargo.toml
+# the next time it runs. Left out, every auto-bumped push committed a lockfile
+# one version behind and handed the tree straight back dirty.
+#
+# Usage:
+#   scripts/bump-version.sh [patch|minor|major]   # bump a semver component (default: patch)
+#   scripts/bump-version.sh <x.y.z>               # set an explicit version
+#
+# Prints the new version to stdout. Does not commit or tag.
+set -euo pipefail
+
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+pkg="$repo_root/package.json"
+cargo="$repo_root/src-tauri/Cargo.toml"
+tauri="$repo_root/src-tauri/tauri.conf.json"
+lock="$repo_root/Cargo.lock"
+
+for f in "$pkg" "$cargo" "$tauri"; do
+  [ -f "$f" ] || { echo "bump-version: missing $f" >&2; exit 1; }
+done
+
+current="$(jq -r '.version' "$pkg")"
+[[ "$current" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || {
+  echo "bump-version: current version '$current' is not x.y.z" >&2; exit 1; }
+
+arg="${1:-patch}"
+if [[ "$arg" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+  new="$arg"
+else
+  IFS=. read -r major minor patch <<<"$current"
+  case "$arg" in
+    major) new="$((major + 1)).0.0" ;;
+    minor) new="${major}.$((minor + 1)).0" ;;
+    patch) new="${major}.${minor}.$((patch + 1))" ;;
+    *) echo "bump-version: unknown bump '$arg' (want patch|minor|major|x.y.z)" >&2; exit 1 ;;
+  esac
+fi
+
+# package.json + tauri.conf.json — top-level "version" via jq (preserves formatting/order).
+tmp="$(mktemp)"
+jq --arg v "$new" '.version = $v' "$pkg" >"$tmp" && mv "$tmp" "$pkg"
+tmp="$(mktemp)"
+jq --arg v "$new" '.version = $v' "$tauri" >"$tmp" && mv "$tmp" "$tauri"
+
+# Cargo.toml — only the version line inside [package], nothing else.
+tmp="$(mktemp)"
+awk -v v="$new" '
+  /^\[/ { section = $0 }
+  section == "[package]" && /^version[[:space:]]*=/ && !done {
+    sub(/"[^"]*"/, "\"" v "\""); done = 1
+  }
+  { print }
+' "$cargo" >"$tmp" && mv "$tmp" "$cargo"
+
+# Cargo.lock — only the `eldrun` [[package]] block's version line. Matched on the
+# block's own `name`, never on the version string: a dependency that happens to
+# sit at the same version must not be rewritten along with us. Absent lockfile is
+# not an error (it is generated), so a fresh clone can still bump.
+if [ -f "$lock" ]; then
+  tmp="$(mktemp)"
+  awk -v v="$new" '
+    /^\[\[package\]\]/ { ours = 0 }
+    /^name[[:space:]]*=[[:space:]]*"eldrun"$/ { ours = 1 }
+    ours && /^version[[:space:]]*=/ && !done {
+      sub(/"[^"]*"/, "\"" v "\""); done = 1
+    }
+    { print }
+  ' "$lock" >"$tmp" && mv "$tmp" "$lock"
+fi
+
+echo "$new"
diff --git a/scripts/eldrun-dev.cmd b/scripts/eldrun-dev.cmd
new file mode 100644
index 0000000..0d36ab4
--- /dev/null
+++ b/scripts/eldrun-dev.cmd
@@ -0,0 +1,12 @@
+@echo off
+rem Launch Eldrun in dev mode (Tauri + Vite hot reload).
+rem Generated launcher used by the desktop shortcut.
+cd /d "%~dp0.."
+title Eldrun (dev)
+echo Starting Eldrun in dev mode...
+call npm run tauri:dev
+if errorlevel 1 (
+  echo.
+  echo Eldrun exited with an error. Press any key to close.
+  pause >nul
+)
diff --git a/scripts/privacy-check.sh b/scripts/privacy-check.sh
index 1a27d1c..ed066be 100755
--- a/scripts/privacy-check.sh
+++ b/scripts/privacy-check.sh
@@ -8,20 +8,52 @@
 # self-match. Run with changes staged: `git add -A && scripts/privacy-check.sh`.
 set -uo pipefail
 
+# Resolve a REAL grep binary. An interactive shell may shadow `grep` with a
+# wrapper (e.g. a ugrep function under some tooling) that mishandles these ERE
+# patterns; combined with a swallowed error that used to silently report
+# "clean". Always use a known binary, and FAIL LOUDLY (exit 2) if the scan tool
+# itself errors, rather than passing a scan that never actually ran.
+GREP=""
+for g in /usr/bin/grep /bin/grep "$(command -v grep 2>/dev/null || true)"; do
+  if [ -n "${g:-}" ] && [ -x "$g" ]; then GREP="$g"; break; fi
+done
+if [ -z "$GREP" ]; then
+  echo "privacy-check: no usable grep binary found; refusing to report clean." >&2
+  exit 2
+fi
+
+# Patterns to flag in ADDED lines. $USER/$HOME are added only when non-empty so
+# an empty value can't degrade into a match-everything pattern (a false pass).
+patterns=(
+  '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}'
+  'password[[:space:]]*[:=]' 'secret[[:space:]]*[:=]'
+  'api[_-]?key[[:space:]]*[:=]' 'BEGIN [A-Z ]*PRIVATE KEY'
+  'ssh-rsa AAAA' 'ghp_[A-Za-z0-9]' 'glpat-'
+  '[0-9]{1,3}(\.[0-9]{1,3}){3}'
+)
+[ -n "${USER:-}" ] && patterns+=("$USER")
+[ -n "${HOME:-}" ] && patterns+=("$HOME")
+
+grep_args=()
+for p in "${patterns[@]}"; do grep_args+=(-e "$p"); done
+
 # Only inspect ADDED lines (+), not removed ones — deleting sensitive data must
 # not trip the check. Strip the `+++` file-header lines before matching.
-hits=$(git diff --cached -- . ':!scripts/privacy-check.sh' \
-  | grep -E '^\+' | grep -v '^\+\+\+' \
-  | grep -nEi \
-  -e "$USER" -e "$HOME" \
-  -e '[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}' \
-  -e 'password[[:space:]]*[:=]' -e 'secret[[:space:]]*[:=]' \
-  -e 'api[_-]?key[[:space:]]*[:=]' -e 'BEGIN [A-Z ]*PRIVATE KEY' \
-  -e 'ssh-rsa AAAA' -e 'ghp_[A-Za-z0-9]' -e 'glpat-' \
-  -e '[0-9]{1,3}(\.[0-9]{1,3}){3}' \
-  | grep -vi 'noreply' || true)
+added=$(git diff --cached -- . ':!scripts/privacy-check.sh' \
+  | "$GREP" -E '^\+' | "$GREP" -v '^[+][+][+]') || true
+
+# Run the match grep on its own so we can tell a real grep error (rc >= 2) from
+# "no matches" (rc 1). pipefail makes rc reflect grep, not the leading printf.
+matched=$(printf '%s\n' "$added" | "$GREP" -nEi "${grep_args[@]}")
+rc=$?
+if [ "$rc" -ge 2 ]; then
+  echo "privacy-check: scan tool error (grep rc=$rc); refusing to report clean." >&2
+  exit 2
+fi
 
-if [ -n "$hits" ]; then
+hits=$(printf '%s\n' "$matched" | "$GREP" -vi 'noreply') || true
+# The noreply filter can yield a single empty line; treat whitespace-only as none.
+if [ -n "${hits//[[:space:]]/}" ]; then
   echo "Privacy check: potential sensitive data in staged changes:" >&2
   echo "$hits" >&2
   echo >&2
diff --git a/src-tauri/CLAUDE.md b/src-tauri/CLAUDE.md
new file mode 100644
index 0000000..d31c784
--- /dev/null
+++ b/src-tauri/CLAUDE.md
@@ -0,0 +1,107 @@
+# ProjectEldrun — Backend File Map (`src-tauri/src/`)
+
+See the root `CLAUDE.md` for project-wide context (running, persistence, dev
+workflow); see `src/CLAUDE.md` for the frontend file map.
+
+**Top level**
+
+| File | Purpose |
+|------|---------|
+| `main.rs` | Tauri app entry point, plugin registration. |
+| `lib.rs` | Command registration (`generate_handler!`), app setup, hook/restore install. |
+| `storage.rs` | JSON persistence helpers (read/write state files). |
+| `paths.rs` | Canonical Eldrun directory paths. |
+| `sysstat.rs` | Per-process CPU sampling via `/proc` (`descendant_pids`). |
+| `gpustat.rs` | Whole-**device** GPU memory (the header row, the monitor pane, the model menu's headroom line) — Ollama's `/api/ps` figure is now one line of its breakdown, not the reading. Reports a GPU's **two** pools separately because on an APU only one is real: the dedicated VRAM carve-out (~512 MB — the framebuffer, permanently ~full, so it alone says nothing) and the shared pool mapped out of system RAM (amdgpu's GTT, where a model actually lands); callers sum them, and on a discrete card the shared half is 0 so the sum collapses to plain VRAM. Sources: **DRM sysfs** (`mem_info_*` + `gpu_busy_percent` — no tool, no root) and **`nvidia-smi`** (the only portable NVIDIA read; a process spawn, so its *absence* is remembered rather than re-paid every poll). A card is only reported when it states a `vram_total` — Intel's `i915` exposes none, and a zero is not a measurement. One ~1 s cache serves all three surfaces. Each `GpuSample` also carries the card's **sensors** — temperature, power (draw + cap), core/mem clocks, fan %, PCIe link, driver version — read from the *same* cheap sysfs (a card's `hwmon` subdir + `pp_dpm_*`/`current_link_*`) / `nvidia-smi` pass, so every surface gets them free; each is `None` when the driver won't say (never a fake zero). **Per-process** GPU memory is deliberately separate (`process_snapshot` → `gpu_process_snapshot`, monitor pane only, *not* cached into the shared snapshot): a heavier read (a `/proc` `fdinfo` walk deduped by `drm-client-id` for amdgpu, an `nvidia-smi --query-compute-apps` spawn) the always-visible header must not pay for. A **remote** project samples its host's GPUs too: `sysstat::REMOTE_SNAPSHOT_SCRIPT` ships the host's DRM sysfs files (`AMD\t…` lines) and raw `nvidia-smi` CSV (`NVSMI`/`NVPROC`) over the one SSH round-trip, and `parse_remote_snapshot` runs them through these *same* `parse_drm_card`/`parse_nvidia_smi`/`parse_nvidia_apps` parsers — so a host GPU reads field-for-field like a local one. Remote per-process is NVIDIA-only (the AMD `fdinfo` walk is too heavy to run per remote poll). |
+
+**Commands (`commands/`)** — Tauri command handlers exposed to the frontend.
+
+| File | Purpose |
+|------|---------|
+| `projects.rs` | Project CRUD, scaffold/import, time-today (god module; #1). |
+| `fs.rs` | File-I/O commands (read/write/mtime, extracted from `projects.rs`; #1 seam). |
+| `fs_watch.rs` | Filesystem watch start/stop + change events. |
+| `git.rs` | Git status/history/commit/push. |
+| `git_publish.rs` | Publish a project's repo to GitHub (`gh`) or GitLab (`glab`). Owns the shared `Provider` (which CLI, which token/host env). Also owns **which side runs the CLI** (`PublishSite`), which is the one non-obvious thing here: *where the bytes are is not where the hosting account is*. `gh auth login` and the Settings → Git Hosting tokens are secrets of the local machine, while a work remote is typically a cluster login node with no provider CLI, no GitHub credentials and often no outbound https — so a remote project publishes **from its lockstep mirror by default** (`publish_from = "local"`, the dialog's "Publish from" selector), and the ssh path is the explicit opt-in for a host with its own login. The local default's one hazard is a stale mirror, so `describe_mirror_guard` (pure, tested) refuses unless lockstep is enabled *and* green — otherwise a publish would create the repo from the wrong history. Every follow-up (visibility, unpublish, and `commands::git::git_push` via `mirror_origin_repo`) routes by `origin_site`: wherever `origin` actually got wired, so the create and the pushes never end up on opposite sides. `run_remote_provider_command` additionally translates OpenSSH's own failures (`ssh_transport_error`) — `ssh_base_args` reuses but never creates a master, so a disconnected project fails at ssh auth, and "Permission denied (publickey,password)" reads like a GitHub rejection if passed through raw. |
+| `git_fork.rs` | The import dialog's **fork** source: fork a hosted repo into the user's own account, then clone *that*. A fork is a server-side operation, so it goes through the provider CLI's raw `api` subcommand (`gh api -X POST repos/<owner>/<repo>/forks`, `glab api -X POST projects/<id>/fork`) rather than `repo fork --clone` — the response JSON *names* the fork, and neither CLI's clone can be pointed at a destination directory or have its namespace guessed (a fork can land elsewhere, or already exist: GitHub returns the existing one, GitLab refuses with "already been taken", which is looked up instead of reported). The clone itself is `git::git_clone_blocking`, so the URL whitelist, token credential helper and partial-directory cleanup are the ordinary clone's; it is retried only on the "not there yet" failure, since forking is asynchronous on both services. `git remote add upstream <original>` is best-effort — the tree is on disk by then. `fork_cli_available` backs the dialog's install banner. |
+| `terminal.rs` | Terminal/PTY command surface (delegates to `terminal/mod.rs`). Also the **local** tmux-session commands (TODO #85): `local_tmux_{list,kill,rename}`, and the `pty_spawn` local-tmux wrap (`services::tmux_local`). |
+| `apps.rs` | App launching, `run_script_detached`, `open_file`, external window tracking. |
+| `default_apps.rs` | Per-file-type default-app mapping. |
+| `downloads.rs` | Per-project download routing. |
+| `ssh.rs` | SSH commands for remote projects (`ssh_connect`, `ssh_default_dir`, `ssh_list_dir`, `ssh_tooling_status`). Also the **active-disconnect** pair (explicit-click only, never on relaunch): `remote_kill_all_jobs` (`tmux kill-server` on a host — ends *every* running session/job, best-effort, rides a live master or authenticates ad-hoc like `global_machine_monitor_snapshot`) and `ssh_close_master` (`ssh -O exit` on the shared `cm-%C` socket, for a project-free global machine that pools nothing; a project host tears its pool down via `remote_disconnect` instead). |
+| `remote.rs` | Pooled SSH/SFTP connection lifecycle (`remote_connect`/`remote_disconnect`) for the active remote project. Also `remote_upload_file` (HPC wizard "Load data" step, `docs/quirky-knitting-umbrella`): streams a local file to `<remote_path>/<dest_rel>` over the pooled SFTP (`upload_file_streaming_on`), primary host, dest_rel sanitized to stay inside the root. Also the tmux-session commands (TODO #85): `remote_tmux_list` (Sessions view, `tmux ls` → `Vec<TmuxSession>`; called per-host so the view aggregates every connected worker), `remote_tmux_kill` (explicit-close / per-row kill), and `remote_tmux_rename` (per-row rename), all over the pooled ControlMaster. |
+| `openvpn.rs` | OpenVPN tunnel connect/store-config commands. |
+| `ollama.rs` | Ollama model list/pull/delete + local autocomplete. |
+| `tex.rs` | TeX compile + SyncTeX (shell-escape defense). |
+| `boxes.rs` | Project-box CRUD. |
+| `calendar.rs` | Calendar/event/task CRUD over `calendar.json` + guarded ICS file read/write. |
+| `subwindow.rs` | Detached/popped-out subwindow lifecycle (#42). |
+| `timer.rs` | Time-tracking commands. |
+| `usage_stats.rs` | Usage recap: batched counter writes (`usage_bump`), rollup reads, watcher attach, and git commits/lines derived on demand from `git log`. |
+| `workspace.rs` | KDE/X11 workspace switch commands. |
+| `settings.rs` | Settings read/update. |
+| `project_runtime.rs` | Project-switch runtime command wrapper (off-UI-thread). |
+| `slurm.rs` | **SLURM run/watch core for HPC projects** (`docs/quirky-knitting-umbrella` plan): `slurm_available`/`slurm_submit`/`slurm_queue`/`slurm_job_out`/`slurm_cancel`. Mirrors `python.rs`'s dispatch — resolves `project_dir` (+ optional `host_id`, primary default) to a remote target and runs a POSIX-`sh` script over the pooled ControlMaster (`run_remote_script`), or a local shell for a login node that itself has SLURM. **Security**: the script is embedded verbatim, so every path is `shell_quote`d (the shared `ssh_exec` helper) and a job id is validated numeric before it touches `scontrol`/`scancel`. `slurm_submit` chains `sbatch --parsable` → `scontrol show job` in ONE round trip (the id comes from sbatch, so nothing user-controlled is interpolated) and returns the SLURM-resolved absolute out/err/work paths. Pure parsers (`parse_submit_jobid`, `parse_scontrol_paths`, `parse_squeue`, `split_script_rel` — which preserves absolute paths so the frontend can pass a file's absolute path and skip any remote-vs-local rel computation) are unit-tested. |
+| `hpc_ws.rs` | **HPC workspaces** (`docs/quirky-knitting-umbrella` Phase C): `hpc_ws_available`/`hpc_ws_list`/`hpc_ws_allocate`/`hpc_ws_extend`/`hpc_ws_release`/`hpc_ws_link` over the `hpc-workspace` tooling (`ws_allocate`/`ws_list`/`ws_find`/`ws_extend`/`ws_release`). On a cluster `$HOME` is a small quota'd code filesystem and the bulk data belongs in a **time-limited workspace** on the parallel filesystem — so this is the step that must precede any upload/sync, and its whole integration is that the allocated path becomes the project's **remote root** (every existing transport then lands there unchanged). **Nothing is site-specific**: the host is *asked* what it offers (`ws_list -l`) instead of presets being hardcoded. Reuses `commands::slurm`'s dispatch verbatim (`run_slurm_script`, now `pub(crate)`) for a project target, and — because a workspace is normally allocated **before the project exists** — adds a bare-host target authenticated ad-hoc via `run_ssh_auth`, exactly as `global_machine_usage_check` does. Each list/allocate is ONE round trip that appends a `ws_find` confirmation, because the *path* is the field everything downstream depends on and `ws_list`'s layout differs between versions. **Security**: every interpolated value is validated (id/filesystem/link-name charset, day counts bounded, mail free of metacharacters) *and* `shell_quote`d. Pure parsers (`parse_ws_locations`, `parse_ws_list`, `parse_ws_allocate`) are unit-tested. `hpc_ws_link` symlinks a workspace into a project that stayed in `$HOME`; the link is for the **host's** tools only — byte-sync never follows a symlink (`remote_sync::walk_host_files`, G3). Also the two commands that make the layout survivable (`docs/hpc_workspace_plan.md` Phases 1–2): **`hpc_ws_anchor`** creates the small per-project folder in the cluster `$HOME` (`logs/`, a `workspace` symlink, and an **append-only** `workspaces.txt` record) — append-only because a project passes through several workspaces a year and the *previous* names are what `ws_restore` needs; its `$HOME`-relative path is validated segment-by-segment (with `.`/`..` rejected explicitly, since `validate_token` allows `.` inside a name) so it cannot escape home. **`hpc_ws_move_root`** re-points a primary's `remote_path` — the escape hatch an expiry makes inevitable, and which nothing else could do (a primary's path was fixed at creation) — rewriting `project.json` + the mirrored `extra["remote"]`, resetting lockstep state to a fresh `enabled` and clearing the byte-sync manifest's per-file **bases** while keeping every marker (stale bases would claim the new, empty root holds files, which the safe-direction policy reads as "the host deleted them"). `set_project_hpc` persists the record (both files, like `set_project_run_host`); `hpc_ws_pull_logs` copies the anchor's logs into the mirror. **`hpc_scratch_candidates`** is what keeps the feature true of *any* cluster rather than the `hpc-workspace` ones: at a site with no `ws_allocate` it asks whether the site's own profile exports `$SCRATCH`/`$WORK`/… (plus two conventional paths), reporting each existing directory with writability + `df` free space, so the Workspace step can still offer a big filesystem instead of dropping the project into `$HOME`. The probed variable *names* are the one site-shaped list in the module — names to ask about, nothing assumed about what they mean. |
+| `python.rs` | Which Python the viewer's Run/Debug run (#87), and the **single** source of that precedence — the frontend asks, it never re-derives. A project's pinned `python_interpreter` always wins (and costs no probing); otherwise auto-detect ranks in-tree venv → poetry → active `VIRTUAL_ENV`/`CONDA_PREFIX` → pyenv → system. A **named conda env is offered but never auto-picked**: choosing one of N unrelated envs on the user's behalf is a guess, and a wrong one here is indistinguishable from a bug. Remote projects probe the **host** (one constant `sh` script over `run_remote_script`) — the interpreter that matters is the one on the machine the run tab runs on. |
+| `pdf_clip.rs` | In-memory transfer slot for dragged/copied PDF *pages*. Two Eldrun windows are separate WebViews with separate JS heaps, so the bytes must cross the process boundary; events carry only the token. |
+| `crash.rs` | Receives frontend renderer crash reports. |
+| `debug.rs` | Debug-mode helpers. |
+
+**Services (`services/`)** — `AppHandle`-free, unit-testable.
+
+| File | Purpose |
+|------|---------|
+| `ssh_common.rs` | Shared SSH argv + validation helpers (`validate_arg`, `ssh_*_base_args`, `ssh_target`, `sshpass_available`). |
+| `remote.rs` | Explicit remoteness resolver (`remote_target_for`/`_for_dir`) + pooled `Sftp`/ControlMaster registry (mount-free remote). **Multi-host**: the pool is keyed by a composite `(project, host)` [`conn_key`], so a project's primary and each extra worker connect independently; the primary path is the `PRIMARY_HOST` (`"primary"`) constant and every file/git/sync caller (which *is* the primary subsystem) keeps its old single-arg signature via thin wrappers. `remote_target_for_host` / `compute_hosts_for` resolve a worker's spec from `projects.json`'s `extra["compute_hosts"]`. |
+| `sftp.rs` | Native SFTP session: list + read/write/create/delete/rename/mkdir/download (pooled `*_on` + one-shot). |
+| `ssh_exec.rs` | Remote command execution over SSH (PTY tabs, git-over-ssh, remote `mkdir`; ControlMaster). **Persistent sessions (tmux, TODO #85):** when `PtyOptions.tmux_session`/`tmux_attach` is set, `wrap_pty_options` nests the final `exec …` inside `tmux new-session -A -D -s <name>` (`TmuxWrap::{Session,Attach}` → `tmux_wrap_exec`), preserving the `cd`/env/agent-prelude prefix verbatim — so the run is decoupled from the disposable ssh channel and reattaches on reconnect/relaunch. `-A` = start-or-resume, `-D` = evict a stale client, `-s <name>` = the **frontend-minted, persisted** per-tab session name (a uuid — stable across a relaunch, unlike the regenerated PTY id, which is what makes reattach work). tmux-absent falls back to today's plain `exec` + a notice; `set -g status off`/`mouse on` reclaim the status line. `tmux_kill_session_script` (per-session close), `tmux_kill_server_script` (machine disconnect), and `tmux_ls_script`+`parse_tmux_ls`+`TmuxSession` (Sessions view) ride `run_remote_script`. |
+| `remote_agents.rs` | Remote agent bootstrap/resume for SSH projects. |
+| `remote_sync.rs` | Selective byte-sync core for remote projects: mirror paths, manifest, host/mirror walks, divergence + push/pull primitives. |
+| `big_folders.rs` | The giant-folder census behind the setup prompt (`BigFolderExcludeDialog`): *which folders are too big to sync*, asked for the whole project on **both** sides at the one moment the answer is cheap — before the first pass moved anything. The two sides are measured differently (a local walk; one `du -ak -x` over the pooled ControlMaster via `ssh_exec::remote_du_raw`) and reduced to the SAME shape — a flat `(rel, bytes)` file list — so `tally_dirs` + `pick` are one pure, side-agnostic, unit-tested heuristic rather than two that can disagree. `pick` reports the **shallowest** folder over either threshold (2k files OR 512 MB — count is what makes a pass take minutes, bytes is what fills the disk), except that a folder whose weight is concentrated in one child is skipped in favour of that child, so the prompt says `data/raw` rather than `data`. Results never nest, so no checkbox can shadow another. |
+| `sync_auto.rs` | Auto-sync engine on top of `remote_sync` (watcher + interval trigger, safe-direction policy). Skips the git-tracked set when lockstep owns it. |
+| `git_peer.rs` | Git lockstep: keeps the local mirror and host repo in step **semantically** (commits/refs via `git bundle`, never `.git` bytes). **Lockstep owns the git-tracked tree; byte-sync owns everything else** — the invariant that keeps the two transports from racing for the same file (#28p). One consequence worth knowing: enabling lockstep converts a **tracked** file from a continuous byte mirror to commit-gated — a saved edit no longer reaches the peer until it's committed (`docs/git_lockstep_case_matrix.md` #5/#7). |
+| `worker_sync.rs` | **Multi-host remote** (`docs/multi_host_remote_plan.md`): the push-only, code-only fan-out that keeps each extra "worker" host's tracked tree at the primary's HEAD. Reuses `git_peer`'s bundle primitives (`bundle_create_args`, `Peer`) but only the OUTBOUND half — source(mirror)→worker only, so it inherits none of lockstep's divergence/conflict/local-loss machinery. `git init`→`fetch bundle`→`reset --hard FETCH_HEAD`, **never `git clean`** (untracked experiment outputs survive by construction — the one load-bearing invariant, tested). Triggers: worker connect, a `.git` commit on the mirror (via `git_peer::poll_loop`'s watcher branch, which calls `fan_out`), and the manual `worker_sync_now`. `worker_sync.json` records each worker's `last_head` for incremental bundles. **Output pull-back** (`preview_outputs`/`pull_outputs`) is the ONE worker→local byte path — user-initiated, size-confirmed, `git ls-files --others` → per-file SFTP download into `outputs/<label>/`. **Shared-filesystem workers** (`ComputeHost.shared_fs`, the **default** for a newly added machine) get NONE of this: they see the primary's folder over a shared FS, so no copy/bundle/git ever touches them — the fan-out gate `wants_code_fanout` (`!shared_fs && sync_code`) and a defensive early skip in `sync_worker` keep git off what is the primary's real working tree (a tab just `cd`s into `spec.remote_path`). |
+| `local_loss.rs` | The record of what lockstep/sync **destroyed in the local mirror** (#28q): a per-project append-only log, written by the destructive sites in `git_peer` (`audit_local_head_move`) and `commands::sync`, raised by `LocalLossDialog`. A file, not an event — the services are `AppHandle`-free and a background pass can delete with no window listening. |
+| `openvpn.rs` | OpenVPN process lifecycle (askpass file, teardown). Two registries, both keyed by config path: headless tunnels Eldrun spawned, and *interactive* ones typed into a terminal tab — the latter armed with a `--writepid` Eldrun owns, so they are visible (`is_connected`/`active_configs`) and killable (`disconnect`/`disconnect_all`) rather than outliving the app with the machine's routing changed. Windows adds a third registry: headless connects go through the **OpenVPN Interactive Service** (named-pipe IPC, `\\.\pipe\openvpn\service`) so Eldrun stays unelevated; the direct `openvpn.exe` spawn (needs elevated Eldrun) is only the no-service fallback. **The polkit prompt is paid once, on connect**: teardown no longer costs a second one, because every tunnel Eldrun starts (headless *and* interactive) carries a `--management 127.0.0.1 <port> <pwfile>` socket and `disconnect` asks the daemon to `signal SIGTERM` **itself** — nothing to elevate. The endpoint lives beside the pidfile (`{stem}.mgmt` port + owner-only `{stem}.mgmt.pw`) so a tunnel from a previous run is still stoppable after a restart. It is an **optimization, never a guarantee**: unconfirmed shutdown, or a config that declares its own `management` directive (`config_declares_management` — `--management` twice is an options error, i.e. a tunnel that never comes up), falls straight through to the old `pkexec kill`. If *that* is then declined, the config is recorded in `declined_configs` so the exit-time `disconnect_all` leaves it alone rather than re-prompting with no window left to hold the dialog. |
+| `tmux_local.rs` | Persistent **local** (tmux) sessions (TODO #85): wraps a LOCAL shell/script tab's `PtyOptions.{cmd,args}` into a `tmux new-session -A -D` argv so a run survives an Eldrun **crash** (the tmux server is a daemon the PTY-held client is separate from) and reattaches on restart. **Unix only** — `tmux_available()` is `false` on Windows, making every entry point a no-op. Pure argv builders (`local_tmux_{args,kill_args,rename_args,ls_args}`); the wrap runs in `commands::terminal::pty_spawn` only when ssh/docker wrapping did NOT fire. |
+| `agent_session.rs` | Agent-session resolvers (`resolve_{claude,codex}_session`), SessionStart hook installer, live-session records, Codex hook-trust state. |
+| `codex_bind.rs` | Hook-free Codex session binding: follows `~/.codex/sessions` rollouts so Codex tabs resume even when its hook is untrusted. |
+| `sandbox.rs` | Project containers (#38): ONE session-lived, capability-dropped Docker container per toggled project (`eldrun-<id>`); every shell/agent tab `docker exec`s into it. Identical-path mount of the project dir (+ minimal agent auth/state mounts) keeps resume/git/viewers reading host bytes. Lifecycle: idempotent `up` (spec-fingerprint label detects staleness) / `down` on deactivate (skipped while tabs live) / `down_all` at exit / `sweep_orphans` at startup. Tab close TERMs the in-container process via a pidfile kill-wrapper — docker never kills an exec when its client dies. Local projects only; Windows refused at spawn. Plan: `docs/docker_projects_plan.md`. |
+| `project_runtime.rs` | Worker-thread project switch + time flush (`flush_project_secs`); kicks the sandbox container down(prev)/up(next) thread on switch. |
+| `restore_service.rs` | Tab/session restore on relaunch. |
+| `terminal_service.rs` | Tab layout save/restore for terminals. |
+| `usage_stats.rs` | Recursive file-churn watcher on the active project (pure `classify_fs_event`/`is_ignored`/`Debouncer`) + periodic flush into `usage_stats.json`. Local filesystems only — inotify cannot see an SFTP tree. |
+| `window_service.rs` | Window-state helpers. |
+
+**Platform (`platform/`)** — `WorkspaceBackend` strategy.
+
+| File | Purpose |
+|------|---------|
+| `x11.rs` | X11 workspace / window management via xlib. |
+| `wayland_kde.rs` | KDE Wayland backend via KWin scripting + DBus (show/hide stub, #18). |
+| `windows.rs` | Windows backend: SW_HIDE "parking", position_window, occlusion probe (Win32 FFI). |
+| `windows_park.rs` | Pure Windows parking logic (un-gated; Linux-run safety tests). |
+| `macos.rs` | macOS backend: app-granularity hide/unhide parking (CGWindowList + NSRunningApplication FFI). |
+| `macos_park.rs` | Pure macOS parking + occlusion logic (un-gated; Linux-run safety tests). |
+| `null.rs` | No-op platform fallback. |
+
+**Schema (`schema/`)** — Serde structs mirroring the JSON state files.
+
+| File | Purpose |
+|------|---------|
+| `projects.rs` / `project.rs` | `projects.json` entries + per-project `project.json`. |
+| `settings.rs` | `settings.json`. |
+| `default_apps.rs` | `default_apps.json`. |
+| `time_log.rs` | `time_log.json` (unbounded `Vec`; Efficiency #2/#12). |
+| `usage_stats.rs` | `usage_stats.json`: rolling hour+day usage counters behind the daily recap. Same bucket/prune shape as `net_usage`, but an **open** metric-key → count map (`metric` module) so a new stat needs no migration. |
+| `boxes.rs` | Project boxes. |
+| `calendar.rs` | `calendar.json`: calendars, events (start/end, rrule, alarms), tasks; migrates the legacy v1 array. |
+| `session.rs` | Live/restorable session state. |
+| `active_session.rs` | Defined but **not yet wired** (TODO Group F #24). |
+
+**Terminal (`terminal/`)**
+
+| File | Purpose |
+|------|---------|
+| `mod.rs` | PTY lifecycle. (Agent-session resolution happens in `commands::terminal::pty_spawn`, before ssh/docker wrapping.) **Closing a tab (`kill`) — or the app (`kill_all`, wired into `RunEvent::Exit`) — reaps the child's whole process *subtree*, not just the shell leader**: `portable_pty::Child::kill()` signals only the leader, so a long-running descendant (dev server, build, training run) would otherwise be orphaned. The subtree is walked (`sysstat::descendant_pids`) *before* the leader dies (its children reparent to init once it's gone), then signalled — SIGTERM→SIGKILL-after-grace on tab close, immediate SIGKILL at exit (a delayed escalation thread would die with the process). |
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 9d919d7..2d62f98 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,7 +1,8 @@
 [package]
 name = "eldrun"
-version = "0.1.0"
+version = "0.1.40"
 edition = "2021"
+license = "MIT OR Apache-2.0"
 
 [lib]
 name = "eldrun_lib"
@@ -17,8 +18,21 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 tauri = { version = "2", features = [] }
 tauri-plugin-dialog = "2"
+# Desktop notifications for calendar reminders. The in-app alarm popup
+# (components/calendar/AlarmPopup.tsx) covers the case where Eldrun is focused;
+# this covers the case where it is not — a reminder is worthless if the window
+# has to be open to see it.
+tauri-plugin-notification = "2"
+# Native OS drag-OUT of files (Windows OLE / macOS NSDraggingSession / Linux GTK).
+# WebKitGTK's HTML5 drag-out won't render a drag image or reliably export files
+# to other apps, so the Ctrl-drag file export goes through this plugin instead.
+tauri-plugin-drag = "2"
+# Encode the drag-preview PNG as a base64 data URL for tauri-plugin-drag's icon
+# field (it only accepts `data:image/png;base64,…`, not a file path).
+base64 = "0.22"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+serde_yaml = "0.9"
 portable-pty = "0.9.0"
 tokio = { version = "1.52.3", features = ["full"] }
 mime_guess = "2.0.5"
@@ -26,26 +40,110 @@ infer = "0.19.0"
 opener = "0.8.4"
 notify = "8"
 # Read images (e.g. screenshots) off the system clipboard for paste-into-tree.
-arboard = "3"
+# wayland-data-control: without it arboard speaks only X11, so image copy/paste
+# silently no-ops on a Wayland session with no XWayland. It falls back to X11 at
+# runtime when the compositor lacks the protocol, so this is additive.
+arboard = { version = "3", features = ["wayland-data-control"] }
 # Encode the clipboard's raw RGBA image as PNG before writing it to disk.
 png = "0.17"
+calamine = "0.35.0"
+rusqlite = { version = "0.40.1", features = ["bundled"] }
+# Stage host file bytes on disk so `git diff --no-index` can diff the local mirror
+# against the current host copy (SSH-sync host-vs-mirror diff button).
+tempfile = "3"
+# Extract dropped/double-clicked .zip archives in place (deflate covers the vast
+# majority of real-world zips; "stored" entries need no feature).
+zip = { version = "2", default-features = false, features = ["deflate"] }
+# Store git-hosting access tokens in the OS credential store (Windows Credential
+# Manager / macOS Keychain / Linux Secret Service) instead of plaintext on disk.
+# The backend deps are target-gated inside the crate, so enabling all three
+# native backends is the standard cross-platform recipe.
+#
+# `linux-native-sync-persistent` adds the **kernel keyutils cache in front of** the
+# Secret Service (which stays the store that survives a reboot). It is here because a
+# Secret Service read is the one credential read that can *block*: on a locked
+# collection it waits on an unlock prompt that may never be answered. With the cache,
+# only the first read of an account per boot is a D-Bus call — every later one is a
+# kernel-keyring lookup that cannot block, cannot prompt, and does not care that the
+# collection is locked. `linux-keyutils` is target-gated to Linux inside the crate, so
+# the Windows/macOS backend selection is untouched. NOTE: keyring 3.6's *builder* for
+# this store hands back a plain secret-service credential (upstream bug), so
+# `remote_credentials` constructs `KeyutilsPersistentCredential` itself rather than
+# going through `keyring::Entry` — enabling the feature alone would be a silent no-op.
+keyring = { version = "3", features = ["windows-native", "apple-native", "sync-secret-service", "linux-native-sync-persistent", "crypto-rust"] }
+# Native SFTP client for the remote folder browser (TODO #80): drives the SFTP
+# subsystem over a child `ssh -s sftp` process, so browsing parses no `ls` text
+# and never feeds a remote `$SHELL -c` (replaces the injection-prone `ssh ls`
+# path). The project mount/exec paths are unchanged — still sshfs / `ssh -tt`.
+openssh-sftp-client = "0.15.7"
+# `StreamExt::next` to drive the SFTP `ReadDir` stream (already in the dep tree).
+futures-util = "0.3"
+# `BytesMut` buffer type for chunked SFTP reads (git-lockstep streaming transport,
+# #28n Phase 3); matches the `bytes` version openssh-sftp-client already resolves.
+bytes = "1"
+# AC-vs-battery detection for Energy Saver mode (`commands/power.rs`). The
+# maintained fork of the `battery` crate; one API over Linux
+# (`/sys/class/power_supply`), Windows (`GetSystemPowerStatus`), and macOS
+# (IOKit), so it needs no cfg-gating here.
+starship-battery = "0.10"
 
 # Linux/Unix: workspace backends + crash signal handling
 [target.'cfg(target_os = "linux")'.dependencies]
 zbus = "4"
+# The Secret Service client `keyring`'s `sync-secret-service` backend already uses
+# (same crate, same version — this adds no new dependency, only direct access).
+# `keyring` itself exposes no way to ask whether the collection is *locked*, and a
+# locked collection is indistinguishable there from "nothing saved": every read
+# answers `None`. That silently un-saves every credential the user asked us to
+# remember, so `services::remote_credentials` needs the lock state — and the
+# `Unlock` call that fixes it — directly. See `keyring_state` / `unlock_keyring`.
+dbus-secret-service = { version = "4", features = ["crypto-rust"] }
 xcb = { version = "1", features = ["randr"] }
 # Same crate/version wry uses; needed to hook web-process-terminated on the
 # raw WebKitWebView for the webview crash reporter.
 webkit2gtk = { version = "=2.0.2", features = ["v2_40"] }
+# GTK3 (the toolkit WebKitGTK 4.1 renders with). Used to inject an app-level CSS
+# provider that recolors the native scrollbars WebKit draws inside the web
+# content — the page's `scrollbar-color` is ignored on this WebKitGTK build.
+# Same major version wry/webkit2gtk already pull in, so it adds nothing new.
+gtk = "0.18"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 windows = { version = "0.61", features = [
     "Win32_Foundation",
+    # Native screen capture (BitBlt the virtual screen → PNG) in `screenshot.rs`.
+    "Win32_Graphics_Gdi",
+    # Interface byte counters for the network pane (`GetIfTable2` + the Ndis
+    # types its rows use) in `commands/network.rs`.
+    "Win32_NetworkManagement_IpHelper",
+    "Win32_NetworkManagement_Ndis",
+    "Win32_Storage_FileSystem",
     "Win32_System_Com",
+    # SEH unhandled-exception filter → crash.log line (`install_seh_filter`).
+    # Debug owns the module; Kernel gates EXCEPTION_POINTERS itself and IO gates
+    # the WriteFile the filter logs with.
+    "Win32_System_Diagnostics_Debug",
+    "Win32_System_IO",
+    "Win32_System_Kernel",
+    # Per-process CPU/memory sampling + process-tree walk for the project resource
+    # readout (the Windows analogue of Linux's `/proc` parsing in `sysstat.rs`).
+    "Win32_System_Diagnostics_ToolHelp",
+    "Win32_System_ProcessStatus",
+    # Named-pipe IPC with the OpenVPN Interactive Service (`PeekNamedPipe`,
+    # `SetNamedPipeHandleState`) so headless VPN connects stay unelevated
+    # (`services/openvpn.rs`).
+    "Win32_System_Pipes",
+    # Whole-system monitor sample (`GetSystemTimes`, `GlobalMemoryStatusEx`,
+    # `GetSystemInfo`, `GetTickCount64`) in `sysstat.rs`.
+    "Win32_System_SystemInformation",
+    "Win32_System_Threading",
     "Win32_UI_Shell",
     "Win32_UI_WindowsAndMessaging",
 ] }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+plist = "1"
+
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 
diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
index 9345649..18d61e8 100644
--- a/src-tauri/capabilities/default.json
+++ b/src-tauri/capabilities/default.json
@@ -2,20 +2,29 @@
   "$schema": "../node_modules/@tauri-apps/cli/schema/capability.json",
   "identifier": "default",
   "description": "Eldrun default capabilities — commands and window management",
-  "windows": ["main", "detached-*"],
+  "windows": ["main", "detached-*", "present-*"],
   "permissions": [
     "core:default",
     "core:window:allow-minimize",
+    "core:window:allow-maximize",
+    "core:window:allow-unmaximize",
     "core:window:allow-toggle-maximize",
+    "core:window:allow-is-maximized",
     "core:window:allow-close",
     "core:window:allow-destroy",
     "core:window:allow-start-dragging",
     "core:window:allow-set-position",
+    "core:window:allow-set-size",
+    "core:window:allow-current-monitor",
+    "core:window:allow-set-fullscreen",
     "core:event:allow-emit",
     "core:event:allow-emit-to",
     "core:event:allow-listen",
     "core:event:allow-unlisten",
     "core:webview:allow-create-webview-window",
-    "dialog:default"
+    "core:webview:allow-set-webview-zoom",
+    "dialog:default",
+    "drag:default",
+    "notification:default"
   ]
 }
diff --git a/src-tauri/entitlements.plist b/src-tauri/entitlements.plist
new file mode 100644
index 0000000..2d5b462
--- /dev/null
+++ b/src-tauri/entitlements.plist
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <!-- WKWebView / JavaScriptCore need JIT and writable executable memory. -->
+  <key>com.apple.security.cs.allow-jit</key>
+  <true/>
+  <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+  <true/>
+  <!-- Eldrun spawns child processes (PTYs, git, ssh, sshfs, tex, ollama) and
+       may load third-party dylibs (e.g. macFUSE); relax library validation. -->
+  <key>com.apple.security.cs.disable-library-validation</key>
+  <true/>
+  <!-- Eldrun augments the PATH/env of child processes it launches. -->
+  <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+  <true/>
+  <!-- Network access: SSH, localhost Ollama, the dev server during tauri dev. -->
+  <key>com.apple.security.network.client</key>
+  <true/>
+  <key>com.apple.security.network.server</key>
+  <true/>
+  <!-- AppleScript (osascript) for privileged helpers / future workspace hooks. -->
+  <key>com.apple.security.automation.apple-events</key>
+  <true/>
+</dict>
+</plist>
diff --git a/src-tauri/examples/lockstep_drv.rs b/src-tauri/examples/lockstep_drv.rs
new file mode 100644
index 0000000..d583e8c
--- /dev/null
+++ b/src-tauri/examples/lockstep_drv.rs
@@ -0,0 +1,263 @@
+//! Live-SSH driver for the git-lockstep case matrix (`docs/git_lockstep_case_matrix.md`).
+//!
+//! Every case in that matrix was, until now, backed only by unit tests over the pure
+//! decision functions — nothing had ever run against a real host. This driver closes
+//! that gap: it calls the **same `services::git_peer` / `services::sync_auto` entry
+//! points the Tauri commands call**, against a real remote project, so a case exercised
+//! here exercises the code that ships. The only things it does not reproduce are the UI
+//! event emits and the engines' *timing* (watcher + poll interval); it invokes the very
+//! passes those timers would have invoked.
+//!
+//! It is an example, not a test: it needs a reachable host and it mutates both trees, so
+//! it must never run in CI. Point it at a scratch project.
+//!
+//! ```text
+//! ELDRUN_PROJECT=<project-id> cargo run --example lockstep_drv -- <script>
+//! ```
+//!
+//! Script: one command per line, `#` comments, blank lines ignored.
+//!
+//! | Command | Effect |
+//! |---|---|
+//! | `connect` / `disconnect` | open / drop the pooled SSH+SFTP session |
+//! | `ls-enable` / `ls-disable` | the lockstep opt-in (`git_peer.json`) |
+//! | `bs-auto <rel\|.> on\|off` | per-path byte-sync auto flag (`.` = whole project) |
+//! | `bs` | one **real** byte-sync reconcile pass |
+//! | `sync` | `detect_and_sync` forced (the Retry / "Sync git" action) |
+//! | `sync-soft` | `detect_and_sync` unforced (lets the D5 early-out fire) |
+//! | `pair-confirm` | forced + `allow_pair_overwrite` |
+//! | `resolve local\|remote` | divergence resolution |
+//! | `checkout <target> [local\|remote]` | coordinated checkout |
+//! | `backups` / `restore <peer> <ref>` | safety refs |
+//! | `status` | print persisted state, no network |
+//! | `lsh <sh>` / `hsh <sh>` | shell in the mirror / on the host (in `remote_path`) |
+//! | `lwrite <rel> <text>` | write a mirror file |
+//! | `sleep <secs>` / `echo <text>` | pacing / annotation |
+
+use std::process::Command;
+
+use eldrun_lib::services::git_peer::{self, ReconcileOpts};
+use eldrun_lib::services::{remote, remote_sync, ssh_exec, sync_auto};
+
+/// Print a `GitPeerState` as the one line that matters when reading a case log.
+fn show(state: &git_peer::GitPeerState) {
+    let head = |h: &Option<git_peer::HeadRef>| match h {
+        Some(git_peer::HeadRef::Branch { name, sha }) => {
+            format!("{name}@{}", sha.chars().take(8).collect::<String>())
+        }
+        Some(git_peer::HeadRef::Detached { sha }) => {
+            format!("DETACHED@{}", sha.chars().take(8).collect::<String>())
+        }
+        Some(git_peer::HeadRef::Unborn) => "unborn".into(),
+        None => "-".into(),
+    };
+    println!(
+        "   status={:?} local={} remote={}",
+        state.status,
+        head(&state.local_head),
+        head(&state.remote_head)
+    );
+    if let Some(d) = &state.detail {
+        println!("   detail: {d}");
+    }
+    if let Some(c) = &state.pairing_conflict {
+        println!(
+            "   pairingConflict: source_is_local={} paths={:?}",
+            c.source_is_local, c.paths
+        );
+    }
+}
+
+fn show_result(r: Result<git_peer::GitPeerState, String>) {
+    match r {
+        Ok(s) => show(&s),
+        Err(e) => println!("   ERR: {e}"),
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let script_path = std::env::args().nth(1).expect("usage: lockstep_drv <script>");
+    let project_id = std::env::var("ELDRUN_PROJECT").expect("set ELDRUN_PROJECT=<project-id>");
+    let script = std::fs::read_to_string(&script_path).expect("cannot read script");
+
+    let target = remote::remote_target_for(&project_id).expect("not an SSH remote project");
+    let good_spec = target.spec.clone();
+    let mut spec = good_spec.clone();
+    let mirror = remote_sync::mirror_dir(&project_id);
+
+    // The same three registries `lib.rs` hands to the commands via `manage`.
+    let pool = remote::new_pool();
+    let manifest = remote_sync::new_manifest_state();
+    let auto = sync_auto::new_state();
+
+    println!("project : {project_id}");
+    println!("mirror  : {}", mirror.display());
+    println!("host    : {}:{}", spec.host, spec.remote_path);
+
+    for (n, raw) in script.lines().enumerate() {
+        let line = raw.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let (cmd, rest) = match line.split_once(char::is_whitespace) {
+            Some((c, r)) => (c, r.trim()),
+            None => (line, ""),
+        };
+        println!("\n── [{:>2}] {line}", n + 1);
+        let t0 = std::time::Instant::now();
+
+        match cmd {
+            "connect" => match remote::connect(&pool, &project_id, None).await {
+                Ok(()) => println!("   connected"),
+                Err(e) => println!("   ERR: {e}"),
+            },
+            "disconnect" => {
+                remote::disconnect(&pool, &project_id).await;
+                println!("   disconnected");
+            }
+            "ls-enable" | "ls-disable" => {
+                let mut s = git_peer::load_state(&project_id);
+                s.enabled = cmd == "ls-enable";
+                git_peer::save_state(&project_id, &s).expect("save git_peer.json");
+                println!("   lockstep enabled={}", s.enabled);
+            }
+            // Mirrors `commands::sync::sync_set_auto`.
+            "bs-auto" => {
+                let (rel, on) = rest.split_once(char::is_whitespace).expect("bs-auto <rel> on|off");
+                let rel = if rel == "." { "" } else { rel };
+                let on = on.trim() == "on";
+                let mut g = manifest.lock().await;
+                let m = remote_sync::ensure_loaded(&mut g, &project_id);
+                let e = m.entry(rel.to_string()).or_default();
+                e.auto_sync = on;
+                e.auto_off = !on;
+                if on {
+                    e.selected = true;
+                }
+                e.is_dir = rel.is_empty() || !mirror.join(rel).is_file();
+                remote_sync::save_manifest(&project_id, m).expect("save sync.json");
+                println!("   byte-sync auto[{}] = {on}", if rel.is_empty() { "." } else { rel });
+            }
+            "bs" => {
+                sync_auto::reconcile_once(&pool, &manifest, &target, &project_id).await;
+                println!("   byte-sync pass done");
+            }
+            "sync" | "sync-soft" | "pair-confirm" => {
+                let opts = ReconcileOpts {
+                    forced: cmd != "sync-soft",
+                    allow_pair_overwrite: cmd == "pair-confirm",
+                    ..Default::default()
+                };
+                let s =
+                    git_peer::detect_and_sync(&pool, &manifest, &auto, &project_id, &spec, opts)
+                        .await;
+                show(&s);
+            }
+            "resolve" => show_result(
+                git_peer::resolve(&pool, &manifest, &auto, &project_id, &spec, rest).await,
+            ),
+            "checkout" => {
+                let (tgt, side) = match rest.split_once(char::is_whitespace) {
+                    Some((t, s)) => (t, s.trim()),
+                    None => (rest, "local"),
+                };
+                show_result(
+                    git_peer::checkout_lockstep(
+                        &pool, &manifest, &auto, &project_id, &spec, tgt, side, false,
+                    )
+                    .await,
+                );
+            }
+            "backups" => {
+                let b = git_peer::list_backups(&project_id, &spec);
+                if b.is_empty() {
+                    println!("   (none)");
+                }
+                for r in b {
+                    println!(
+                        "   {:<6} {} → {} {}",
+                        r.peer,
+                        r.refname,
+                        &r.sha[..8.min(r.sha.len())],
+                        r.subject
+                    );
+                }
+            }
+            "restore" => {
+                let (peer, refname) = rest.split_once(char::is_whitespace).expect("restore <peer> <ref>");
+                show_result(
+                    git_peer::restore_backup(
+                        &pool,
+                        &manifest,
+                        &auto,
+                        &project_id,
+                        &spec,
+                        peer,
+                        refname.trim(),
+                    )
+                    .await,
+                );
+            }
+            "status" => show(&git_peer::load_state(&project_id)),
+            // Case 24 (D3.4): make the *host's* probe fail to run, as opposed to running
+            // and answering "not a repo". `validate_arg` rejects a leading '-', so
+            // `run_remote_script` returns Err — which is precisely the input that sets
+            // `PeerSnapshot::probe_error` on a remote peer. The cause is synthetic; the
+            // guard it feeds, and the refusal it must produce, are the real ones.
+            "badspec" => {
+                spec = if rest == "on" {
+                    let mut s = good_spec.clone();
+                    s.remote_path = "-unreadable".to_string();
+                    s
+                } else {
+                    good_spec.clone()
+                };
+                println!("   remote_path = {:?}", spec.remote_path);
+            }
+            "lsh" => {
+                let out = Command::new("bash")
+                    .arg("-lc")
+                    .arg(rest)
+                    .current_dir(&mirror)
+                    .output()
+                    .expect("bash");
+                print!("{}", indent(&String::from_utf8_lossy(&out.stdout)));
+                print!("{}", indent(&String::from_utf8_lossy(&out.stderr)));
+            }
+            "hsh" => match ssh_exec::run_remote_script(&spec, rest) {
+                Ok(out) => {
+                    print!("{}", indent(&String::from_utf8_lossy(&out.stdout)));
+                    print!("{}", indent(&String::from_utf8_lossy(&out.stderr)));
+                }
+                Err(e) => println!("   ERR: {e}"),
+            },
+            "lwrite" => {
+                let (rel, text) = rest.split_once(char::is_whitespace).unwrap_or((rest, ""));
+                let p = mirror.join(rel);
+                if let Some(d) = p.parent() {
+                    std::fs::create_dir_all(d).ok();
+                }
+                std::fs::write(&p, format!("{text}\n")).expect("write mirror file");
+                println!("   wrote {rel}");
+            }
+            "sleep" => {
+                let secs: f64 = rest.parse().unwrap_or(1.0);
+                tokio::time::sleep(std::time::Duration::from_secs_f64(secs)).await;
+                println!("   slept {secs}s");
+            }
+            "echo" => println!("   {rest}"),
+            other => println!("   ?? unknown command '{other}'"),
+        }
+        // Elapsed is the only way to *see* the D5 early-out (case 9): it skips the
+        // bundle+transfer round trip, not the probe, so it shows up as a fast pass.
+        if matches!(cmd, "sync" | "sync-soft" | "pair-confirm" | "bs" | "resolve" | "checkout") {
+            println!("   ({} ms)", t0.elapsed().as_millis());
+        }
+    }
+    println!("\n── done");
+}
+
+fn indent(s: &str) -> String {
+    s.lines().map(|l| format!("   | {l}\n")).collect()
+}
diff --git a/src-tauri/gen/schemas/acl-manifests.json b/src-tauri/gen/schemas/acl-manifests.json
index f2f210a..f0a6a27 100644
--- a/src-tauri/gen/schemas/acl-manifests.json
+++ b/src-tauri/gen/schemas/acl-manifests.json
@@ -1 +1 @@
-{"core":{"default_permission":{"identifier":"default","description":"Default core plugins set.","permissions":["core:path:default","core:event:default","core:window:default","core:webview:default","core:app:default","core:image:default","core:resources:default","core:menu:default","core:tray:default"]},"permissions":{},"permission_sets":{},"global_scope_schema":null},"core:app":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-version","allow-name","allow-tauri-version","allow-identifier","allow-bundle-type","allow-register-listener","allow-remove-listener","allow-supports-multiple-windows"]},"permissions":{"allow-app-hide":{"identifier":"allow-app-hide","description":"Enables the app_hide command without any pre-configured scope.","commands":{"allow":["app_hide"],"deny":[]}},"allow-app-show":{"identifier":"allow-app-show","description":"Enables the app_show command without any pre-configured scope.","commands":{"allow":["app_show"],"deny":[]}},"allow-bundle-type":{"identifier":"allow-bundle-type","description":"Enables the bundle_type command without any pre-configured scope.","commands":{"allow":["bundle_type"],"deny":[]}},"allow-default-window-icon":{"identifier":"allow-default-window-icon","description":"Enables the default_window_icon command without any pre-configured scope.","commands":{"allow":["default_window_icon"],"deny":[]}},"allow-fetch-data-store-identifiers":{"identifier":"allow-fetch-data-store-identifiers","description":"Enables the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":["fetch_data_store_identifiers"],"deny":[]}},"allow-identifier":{"identifier":"allow-identifier","description":"Enables the identifier command without any pre-configured scope.","commands":{"allow":["identifier"],"deny":[]}},"allow-name":{"identifier":"allow-name","description":"Enables the name command without any pre-configured scope.","commands":{"allow":["name"],"deny":[]}},"allow-register-listener":{"identifier":"allow-register-listener","description":"Enables the register_listener command without any pre-configured scope.","commands":{"allow":["register_listener"],"deny":[]}},"allow-remove-data-store":{"identifier":"allow-remove-data-store","description":"Enables the remove_data_store command without any pre-configured scope.","commands":{"allow":["remove_data_store"],"deny":[]}},"allow-remove-listener":{"identifier":"allow-remove-listener","description":"Enables the remove_listener command without any pre-configured scope.","commands":{"allow":["remove_listener"],"deny":[]}},"allow-set-app-theme":{"identifier":"allow-set-app-theme","description":"Enables the set_app_theme command without any pre-configured scope.","commands":{"allow":["set_app_theme"],"deny":[]}},"allow-set-dock-visibility":{"identifier":"allow-set-dock-visibility","description":"Enables the set_dock_visibility command without any pre-configured scope.","commands":{"allow":["set_dock_visibility"],"deny":[]}},"allow-supports-multiple-windows":{"identifier":"allow-supports-multiple-windows","description":"Enables the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":["supports_multiple_windows"],"deny":[]}},"allow-tauri-version":{"identifier":"allow-tauri-version","description":"Enables the tauri_version command without any pre-configured scope.","commands":{"allow":["tauri_version"],"deny":[]}},"allow-version":{"identifier":"allow-version","description":"Enables the version command without any pre-configured scope.","commands":{"allow":["version"],"deny":[]}},"deny-app-hide":{"identifier":"deny-app-hide","description":"Denies the app_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["app_hide"]}},"deny-app-show":{"identifier":"deny-app-show","description":"Denies the app_show command without any pre-configured scope.","commands":{"allow":[],"deny":["app_show"]}},"deny-bundle-type":{"identifier":"deny-bundle-type","description":"Denies the bundle_type command without any pre-configured scope.","commands":{"allow":[],"deny":["bundle_type"]}},"deny-default-window-icon":{"identifier":"deny-default-window-icon","description":"Denies the default_window_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["default_window_icon"]}},"deny-fetch-data-store-identifiers":{"identifier":"deny-fetch-data-store-identifiers","description":"Denies the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":[],"deny":["fetch_data_store_identifiers"]}},"deny-identifier":{"identifier":"deny-identifier","description":"Denies the identifier command without any pre-configured scope.","commands":{"allow":[],"deny":["identifier"]}},"deny-name":{"identifier":"deny-name","description":"Denies the name command without any pre-configured scope.","commands":{"allow":[],"deny":["name"]}},"deny-register-listener":{"identifier":"deny-register-listener","description":"Denies the register_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["register_listener"]}},"deny-remove-data-store":{"identifier":"deny-remove-data-store","description":"Denies the remove_data_store command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_data_store"]}},"deny-remove-listener":{"identifier":"deny-remove-listener","description":"Denies the remove_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_listener"]}},"deny-set-app-theme":{"identifier":"deny-set-app-theme","description":"Denies the set_app_theme command without any pre-configured scope.","commands":{"allow":[],"deny":["set_app_theme"]}},"deny-set-dock-visibility":{"identifier":"deny-set-dock-visibility","description":"Denies the set_dock_visibility command without any pre-configured scope.","commands":{"allow":[],"deny":["set_dock_visibility"]}},"deny-supports-multiple-windows":{"identifier":"deny-supports-multiple-windows","description":"Denies the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":[],"deny":["supports_multiple_windows"]}},"deny-tauri-version":{"identifier":"deny-tauri-version","description":"Denies the tauri_version command without any pre-configured scope.","commands":{"allow":[],"deny":["tauri_version"]}},"deny-version":{"identifier":"deny-version","description":"Denies the version command without any pre-configured scope.","commands":{"allow":[],"deny":["version"]}}},"permission_sets":{},"global_scope_schema":null},"core:event":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-listen","allow-unlisten","allow-emit","allow-emit-to"]},"permissions":{"allow-emit":{"identifier":"allow-emit","description":"Enables the emit command without any pre-configured scope.","commands":{"allow":["emit"],"deny":[]}},"allow-emit-to":{"identifier":"allow-emit-to","description":"Enables the emit_to command without any pre-configured scope.","commands":{"allow":["emit_to"],"deny":[]}},"allow-listen":{"identifier":"allow-listen","description":"Enables the listen command without any pre-configured scope.","commands":{"allow":["listen"],"deny":[]}},"allow-unlisten":{"identifier":"allow-unlisten","description":"Enables the unlisten command without any pre-configured scope.","commands":{"allow":["unlisten"],"deny":[]}},"deny-emit":{"identifier":"deny-emit","description":"Denies the emit command without any pre-configured scope.","commands":{"allow":[],"deny":["emit"]}},"deny-emit-to":{"identifier":"deny-emit-to","description":"Denies the emit_to command without any pre-configured scope.","commands":{"allow":[],"deny":["emit_to"]}},"deny-listen":{"identifier":"deny-listen","description":"Denies the listen command without any pre-configured scope.","commands":{"allow":[],"deny":["listen"]}},"deny-unlisten":{"identifier":"deny-unlisten","description":"Denies the unlisten command without any pre-configured scope.","commands":{"allow":[],"deny":["unlisten"]}}},"permission_sets":{},"global_scope_schema":null},"core:image":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-from-bytes","allow-from-path","allow-rgba","allow-size"]},"permissions":{"allow-from-bytes":{"identifier":"allow-from-bytes","description":"Enables the from_bytes command without any pre-configured scope.","commands":{"allow":["from_bytes"],"deny":[]}},"allow-from-path":{"identifier":"allow-from-path","description":"Enables the from_path command without any pre-configured scope.","commands":{"allow":["from_path"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-rgba":{"identifier":"allow-rgba","description":"Enables the rgba command without any pre-configured scope.","commands":{"allow":["rgba"],"deny":[]}},"allow-size":{"identifier":"allow-size","description":"Enables the size command without any pre-configured scope.","commands":{"allow":["size"],"deny":[]}},"deny-from-bytes":{"identifier":"deny-from-bytes","description":"Denies the from_bytes command without any pre-configured scope.","commands":{"allow":[],"deny":["from_bytes"]}},"deny-from-path":{"identifier":"deny-from-path","description":"Denies the from_path command without any pre-configured scope.","commands":{"allow":[],"deny":["from_path"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-rgba":{"identifier":"deny-rgba","description":"Denies the rgba command without any pre-configured scope.","commands":{"allow":[],"deny":["rgba"]}},"deny-size":{"identifier":"deny-size","description":"Denies the size command without any pre-configured scope.","commands":{"allow":[],"deny":["size"]}}},"permission_sets":{},"global_scope_schema":null},"core:menu":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-append","allow-prepend","allow-insert","allow-remove","allow-remove-at","allow-items","allow-get","allow-popup","allow-create-default","allow-set-as-app-menu","allow-set-as-window-menu","allow-text","allow-set-text","allow-is-enabled","allow-set-enabled","allow-set-accelerator","allow-set-as-windows-menu-for-nsapp","allow-set-as-help-menu-for-nsapp","allow-is-checked","allow-set-checked","allow-set-icon"]},"permissions":{"allow-append":{"identifier":"allow-append","description":"Enables the append command without any pre-configured scope.","commands":{"allow":["append"],"deny":[]}},"allow-create-default":{"identifier":"allow-create-default","description":"Enables the create_default command without any pre-configured scope.","commands":{"allow":["create_default"],"deny":[]}},"allow-get":{"identifier":"allow-get","description":"Enables the get command without any pre-configured scope.","commands":{"allow":["get"],"deny":[]}},"allow-insert":{"identifier":"allow-insert","description":"Enables the insert command without any pre-configured scope.","commands":{"allow":["insert"],"deny":[]}},"allow-is-checked":{"identifier":"allow-is-checked","description":"Enables the is_checked command without any pre-configured scope.","commands":{"allow":["is_checked"],"deny":[]}},"allow-is-enabled":{"identifier":"allow-is-enabled","description":"Enables the is_enabled command without any pre-configured scope.","commands":{"allow":["is_enabled"],"deny":[]}},"allow-items":{"identifier":"allow-items","description":"Enables the items command without any pre-configured scope.","commands":{"allow":["items"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-popup":{"identifier":"allow-popup","description":"Enables the popup command without any pre-configured scope.","commands":{"allow":["popup"],"deny":[]}},"allow-prepend":{"identifier":"allow-prepend","description":"Enables the prepend command without any pre-configured scope.","commands":{"allow":["prepend"],"deny":[]}},"allow-remove":{"identifier":"allow-remove","description":"Enables the remove command without any pre-configured scope.","commands":{"allow":["remove"],"deny":[]}},"allow-remove-at":{"identifier":"allow-remove-at","description":"Enables the remove_at command without any pre-configured scope.","commands":{"allow":["remove_at"],"deny":[]}},"allow-set-accelerator":{"identifier":"allow-set-accelerator","description":"Enables the set_accelerator command without any pre-configured scope.","commands":{"allow":["set_accelerator"],"deny":[]}},"allow-set-as-app-menu":{"identifier":"allow-set-as-app-menu","description":"Enables the set_as_app_menu command without any pre-configured scope.","commands":{"allow":["set_as_app_menu"],"deny":[]}},"allow-set-as-help-menu-for-nsapp":{"identifier":"allow-set-as-help-menu-for-nsapp","description":"Enables the set_as_help_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":["set_as_help_menu_for_nsapp"],"deny":[]}},"allow-set-as-window-menu":{"identifier":"allow-set-as-window-menu","description":"Enables the set_as_window_menu command without any pre-configured scope.","commands":{"allow":["set_as_window_menu"],"deny":[]}},"allow-set-as-windows-menu-for-nsapp":{"identifier":"allow-set-as-windows-menu-for-nsapp","description":"Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":["set_as_windows_menu_for_nsapp"],"deny":[]}},"allow-set-checked":{"identifier":"allow-set-checked","description":"Enables the set_checked command without any pre-configured scope.","commands":{"allow":["set_checked"],"deny":[]}},"allow-set-enabled":{"identifier":"allow-set-enabled","description":"Enables the set_enabled command without any pre-configured scope.","commands":{"allow":["set_enabled"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-text":{"identifier":"allow-set-text","description":"Enables the set_text command without any pre-configured scope.","commands":{"allow":["set_text"],"deny":[]}},"allow-text":{"identifier":"allow-text","description":"Enables the text command without any pre-configured scope.","commands":{"allow":["text"],"deny":[]}},"deny-append":{"identifier":"deny-append","description":"Denies the append command without any pre-configured scope.","commands":{"allow":[],"deny":["append"]}},"deny-create-default":{"identifier":"deny-create-default","description":"Denies the create_default command without any pre-configured scope.","commands":{"allow":[],"deny":["create_default"]}},"deny-get":{"identifier":"deny-get","description":"Denies the get command without any pre-configured scope.","commands":{"allow":[],"deny":["get"]}},"deny-insert":{"identifier":"deny-insert","description":"Denies the insert command without any pre-configured scope.","commands":{"allow":[],"deny":["insert"]}},"deny-is-checked":{"identifier":"deny-is-checked","description":"Denies the is_checked command without any pre-configured scope.","commands":{"allow":[],"deny":["is_checked"]}},"deny-is-enabled":{"identifier":"deny-is-enabled","description":"Denies the is_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["is_enabled"]}},"deny-items":{"identifier":"deny-items","description":"Denies the items command without any pre-configured scope.","commands":{"allow":[],"deny":["items"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-popup":{"identifier":"deny-popup","description":"Denies the popup command without any pre-configured scope.","commands":{"allow":[],"deny":["popup"]}},"deny-prepend":{"identifier":"deny-prepend","description":"Denies the prepend command without any pre-configured scope.","commands":{"allow":[],"deny":["prepend"]}},"deny-remove":{"identifier":"deny-remove","description":"Denies the remove command without any pre-configured scope.","commands":{"allow":[],"deny":["remove"]}},"deny-remove-at":{"identifier":"deny-remove-at","description":"Denies the remove_at command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_at"]}},"deny-set-accelerator":{"identifier":"deny-set-accelerator","description":"Denies the set_accelerator command without any pre-configured scope.","commands":{"allow":[],"deny":["set_accelerator"]}},"deny-set-as-app-menu":{"identifier":"deny-set-as-app-menu","description":"Denies the set_as_app_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_app_menu"]}},"deny-set-as-help-menu-for-nsapp":{"identifier":"deny-set-as-help-menu-for-nsapp","description":"Denies the set_as_help_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_help_menu_for_nsapp"]}},"deny-set-as-window-menu":{"identifier":"deny-set-as-window-menu","description":"Denies the set_as_window_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_window_menu"]}},"deny-set-as-windows-menu-for-nsapp":{"identifier":"deny-set-as-windows-menu-for-nsapp","description":"Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_windows_menu_for_nsapp"]}},"deny-set-checked":{"identifier":"deny-set-checked","description":"Denies the set_checked command without any pre-configured scope.","commands":{"allow":[],"deny":["set_checked"]}},"deny-set-enabled":{"identifier":"deny-set-enabled","description":"Denies the set_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["set_enabled"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-text":{"identifier":"deny-set-text","description":"Denies the set_text command without any pre-configured scope.","commands":{"allow":[],"deny":["set_text"]}},"deny-text":{"identifier":"deny-text","description":"Denies the text command without any pre-configured scope.","commands":{"allow":[],"deny":["text"]}}},"permission_sets":{},"global_scope_schema":null},"core:path":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-resolve-directory","allow-resolve","allow-normalize","allow-join","allow-dirname","allow-extname","allow-basename","allow-is-absolute"]},"permissions":{"allow-basename":{"identifier":"allow-basename","description":"Enables the basename command without any pre-configured scope.","commands":{"allow":["basename"],"deny":[]}},"allow-dirname":{"identifier":"allow-dirname","description":"Enables the dirname command without any pre-configured scope.","commands":{"allow":["dirname"],"deny":[]}},"allow-extname":{"identifier":"allow-extname","description":"Enables the extname command without any pre-configured scope.","commands":{"allow":["extname"],"deny":[]}},"allow-is-absolute":{"identifier":"allow-is-absolute","description":"Enables the is_absolute command without any pre-configured scope.","commands":{"allow":["is_absolute"],"deny":[]}},"allow-join":{"identifier":"allow-join","description":"Enables the join command without any pre-configured scope.","commands":{"allow":["join"],"deny":[]}},"allow-normalize":{"identifier":"allow-normalize","description":"Enables the normalize command without any pre-configured scope.","commands":{"allow":["normalize"],"deny":[]}},"allow-resolve":{"identifier":"allow-resolve","description":"Enables the resolve command without any pre-configured scope.","commands":{"allow":["resolve"],"deny":[]}},"allow-resolve-directory":{"identifier":"allow-resolve-directory","description":"Enables the resolve_directory command without any pre-configured scope.","commands":{"allow":["resolve_directory"],"deny":[]}},"deny-basename":{"identifier":"deny-basename","description":"Denies the basename command without any pre-configured scope.","commands":{"allow":[],"deny":["basename"]}},"deny-dirname":{"identifier":"deny-dirname","description":"Denies the dirname command without any pre-configured scope.","commands":{"allow":[],"deny":["dirname"]}},"deny-extname":{"identifier":"deny-extname","description":"Denies the extname command without any pre-configured scope.","commands":{"allow":[],"deny":["extname"]}},"deny-is-absolute":{"identifier":"deny-is-absolute","description":"Denies the is_absolute command without any pre-configured scope.","commands":{"allow":[],"deny":["is_absolute"]}},"deny-join":{"identifier":"deny-join","description":"Denies the join command without any pre-configured scope.","commands":{"allow":[],"deny":["join"]}},"deny-normalize":{"identifier":"deny-normalize","description":"Denies the normalize command without any pre-configured scope.","commands":{"allow":[],"deny":["normalize"]}},"deny-resolve":{"identifier":"deny-resolve","description":"Denies the resolve command without any pre-configured scope.","commands":{"allow":[],"deny":["resolve"]}},"deny-resolve-directory":{"identifier":"deny-resolve-directory","description":"Denies the resolve_directory command without any pre-configured scope.","commands":{"allow":[],"deny":["resolve_directory"]}}},"permission_sets":{},"global_scope_schema":null},"core:resources":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-close"]},"permissions":{"allow-close":{"identifier":"allow-close","description":"Enables the close command without any pre-configured scope.","commands":{"allow":["close"],"deny":[]}},"deny-close":{"identifier":"deny-close","description":"Denies the close command without any pre-configured scope.","commands":{"allow":[],"deny":["close"]}}},"permission_sets":{},"global_scope_schema":null},"core:tray":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-get-by-id","allow-remove-by-id","allow-set-icon","allow-set-menu","allow-set-tooltip","allow-set-title","allow-set-visible","allow-set-temp-dir-path","allow-set-icon-as-template","allow-set-icon-with-as-template","allow-set-show-menu-on-left-click"]},"permissions":{"allow-get-by-id":{"identifier":"allow-get-by-id","description":"Enables the get_by_id command without any pre-configured scope.","commands":{"allow":["get_by_id"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-remove-by-id":{"identifier":"allow-remove-by-id","description":"Enables the remove_by_id command without any pre-configured scope.","commands":{"allow":["remove_by_id"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-icon-as-template":{"identifier":"allow-set-icon-as-template","description":"Enables the set_icon_as_template command without any pre-configured scope.","commands":{"allow":["set_icon_as_template"],"deny":[]}},"allow-set-icon-with-as-template":{"identifier":"allow-set-icon-with-as-template","description":"Enables the set_icon_with_as_template command without any pre-configured scope.","commands":{"allow":["set_icon_with_as_template"],"deny":[]}},"allow-set-menu":{"identifier":"allow-set-menu","description":"Enables the set_menu command without any pre-configured scope.","commands":{"allow":["set_menu"],"deny":[]}},"allow-set-show-menu-on-left-click":{"identifier":"allow-set-show-menu-on-left-click","description":"Enables the set_show_menu_on_left_click command without any pre-configured scope.","commands":{"allow":["set_show_menu_on_left_click"],"deny":[]}},"allow-set-temp-dir-path":{"identifier":"allow-set-temp-dir-path","description":"Enables the set_temp_dir_path command without any pre-configured scope.","commands":{"allow":["set_temp_dir_path"],"deny":[]}},"allow-set-title":{"identifier":"allow-set-title","description":"Enables the set_title command without any pre-configured scope.","commands":{"allow":["set_title"],"deny":[]}},"allow-set-tooltip":{"identifier":"allow-set-tooltip","description":"Enables the set_tooltip command without any pre-configured scope.","commands":{"allow":["set_tooltip"],"deny":[]}},"allow-set-visible":{"identifier":"allow-set-visible","description":"Enables the set_visible command without any pre-configured scope.","commands":{"allow":["set_visible"],"deny":[]}},"deny-get-by-id":{"identifier":"deny-get-by-id","description":"Denies the get_by_id command without any pre-configured scope.","commands":{"allow":[],"deny":["get_by_id"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-remove-by-id":{"identifier":"deny-remove-by-id","description":"Denies the remove_by_id command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_by_id"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-icon-as-template":{"identifier":"deny-set-icon-as-template","description":"Denies the set_icon_as_template command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon_as_template"]}},"deny-set-icon-with-as-template":{"identifier":"deny-set-icon-with-as-template","description":"Denies the set_icon_with_as_template command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon_with_as_template"]}},"deny-set-menu":{"identifier":"deny-set-menu","description":"Denies the set_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_menu"]}},"deny-set-show-menu-on-left-click":{"identifier":"deny-set-show-menu-on-left-click","description":"Denies the set_show_menu_on_left_click command without any pre-configured scope.","commands":{"allow":[],"deny":["set_show_menu_on_left_click"]}},"deny-set-temp-dir-path":{"identifier":"deny-set-temp-dir-path","description":"Denies the set_temp_dir_path command without any pre-configured scope.","commands":{"allow":[],"deny":["set_temp_dir_path"]}},"deny-set-title":{"identifier":"deny-set-title","description":"Denies the set_title command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title"]}},"deny-set-tooltip":{"identifier":"deny-set-tooltip","description":"Denies the set_tooltip command without any pre-configured scope.","commands":{"allow":[],"deny":["set_tooltip"]}},"deny-set-visible":{"identifier":"deny-set-visible","description":"Denies the set_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["set_visible"]}}},"permission_sets":{},"global_scope_schema":null},"core:webview":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-get-all-webviews","allow-webview-position","allow-webview-size","allow-internal-toggle-devtools"]},"permissions":{"allow-clear-all-browsing-data":{"identifier":"allow-clear-all-browsing-data","description":"Enables the clear_all_browsing_data command without any pre-configured scope.","commands":{"allow":["clear_all_browsing_data"],"deny":[]}},"allow-create-webview":{"identifier":"allow-create-webview","description":"Enables the create_webview command without any pre-configured scope.","commands":{"allow":["create_webview"],"deny":[]}},"allow-create-webview-window":{"identifier":"allow-create-webview-window","description":"Enables the create_webview_window command without any pre-configured scope.","commands":{"allow":["create_webview_window"],"deny":[]}},"allow-get-all-webviews":{"identifier":"allow-get-all-webviews","description":"Enables the get_all_webviews command without any pre-configured scope.","commands":{"allow":["get_all_webviews"],"deny":[]}},"allow-internal-toggle-devtools":{"identifier":"allow-internal-toggle-devtools","description":"Enables the internal_toggle_devtools command without any pre-configured scope.","commands":{"allow":["internal_toggle_devtools"],"deny":[]}},"allow-print":{"identifier":"allow-print","description":"Enables the print command without any pre-configured scope.","commands":{"allow":["print"],"deny":[]}},"allow-reparent":{"identifier":"allow-reparent","description":"Enables the reparent command without any pre-configured scope.","commands":{"allow":["reparent"],"deny":[]}},"allow-set-webview-auto-resize":{"identifier":"allow-set-webview-auto-resize","description":"Enables the set_webview_auto_resize command without any pre-configured scope.","commands":{"allow":["set_webview_auto_resize"],"deny":[]}},"allow-set-webview-background-color":{"identifier":"allow-set-webview-background-color","description":"Enables the set_webview_background_color command without any pre-configured scope.","commands":{"allow":["set_webview_background_color"],"deny":[]}},"allow-set-webview-focus":{"identifier":"allow-set-webview-focus","description":"Enables the set_webview_focus command without any pre-configured scope.","commands":{"allow":["set_webview_focus"],"deny":[]}},"allow-set-webview-position":{"identifier":"allow-set-webview-position","description":"Enables the set_webview_position command without any pre-configured scope.","commands":{"allow":["set_webview_position"],"deny":[]}},"allow-set-webview-size":{"identifier":"allow-set-webview-size","description":"Enables the set_webview_size command without any pre-configured scope.","commands":{"allow":["set_webview_size"],"deny":[]}},"allow-set-webview-zoom":{"identifier":"allow-set-webview-zoom","description":"Enables the set_webview_zoom command without any pre-configured scope.","commands":{"allow":["set_webview_zoom"],"deny":[]}},"allow-webview-close":{"identifier":"allow-webview-close","description":"Enables the webview_close command without any pre-configured scope.","commands":{"allow":["webview_close"],"deny":[]}},"allow-webview-hide":{"identifier":"allow-webview-hide","description":"Enables the webview_hide command without any pre-configured scope.","commands":{"allow":["webview_hide"],"deny":[]}},"allow-webview-position":{"identifier":"allow-webview-position","description":"Enables the webview_position command without any pre-configured scope.","commands":{"allow":["webview_position"],"deny":[]}},"allow-webview-show":{"identifier":"allow-webview-show","description":"Enables the webview_show command without any pre-configured scope.","commands":{"allow":["webview_show"],"deny":[]}},"allow-webview-size":{"identifier":"allow-webview-size","description":"Enables the webview_size command without any pre-configured scope.","commands":{"allow":["webview_size"],"deny":[]}},"deny-clear-all-browsing-data":{"identifier":"deny-clear-all-browsing-data","description":"Denies the clear_all_browsing_data command without any pre-configured scope.","commands":{"allow":[],"deny":["clear_all_browsing_data"]}},"deny-create-webview":{"identifier":"deny-create-webview","description":"Denies the create_webview command without any pre-configured scope.","commands":{"allow":[],"deny":["create_webview"]}},"deny-create-webview-window":{"identifier":"deny-create-webview-window","description":"Denies the create_webview_window command without any pre-configured scope.","commands":{"allow":[],"deny":["create_webview_window"]}},"deny-get-all-webviews":{"identifier":"deny-get-all-webviews","description":"Denies the get_all_webviews command without any pre-configured scope.","commands":{"allow":[],"deny":["get_all_webviews"]}},"deny-internal-toggle-devtools":{"identifier":"deny-internal-toggle-devtools","description":"Denies the internal_toggle_devtools command without any pre-configured scope.","commands":{"allow":[],"deny":["internal_toggle_devtools"]}},"deny-print":{"identifier":"deny-print","description":"Denies the print command without any pre-configured scope.","commands":{"allow":[],"deny":["print"]}},"deny-reparent":{"identifier":"deny-reparent","description":"Denies the reparent command without any pre-configured scope.","commands":{"allow":[],"deny":["reparent"]}},"deny-set-webview-auto-resize":{"identifier":"deny-set-webview-auto-resize","description":"Denies the set_webview_auto_resize command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_auto_resize"]}},"deny-set-webview-background-color":{"identifier":"deny-set-webview-background-color","description":"Denies the set_webview_background_color command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_background_color"]}},"deny-set-webview-focus":{"identifier":"deny-set-webview-focus","description":"Denies the set_webview_focus command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_focus"]}},"deny-set-webview-position":{"identifier":"deny-set-webview-position","description":"Denies the set_webview_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_position"]}},"deny-set-webview-size":{"identifier":"deny-set-webview-size","description":"Denies the set_webview_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_size"]}},"deny-set-webview-zoom":{"identifier":"deny-set-webview-zoom","description":"Denies the set_webview_zoom command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_zoom"]}},"deny-webview-close":{"identifier":"deny-webview-close","description":"Denies the webview_close command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_close"]}},"deny-webview-hide":{"identifier":"deny-webview-hide","description":"Denies the webview_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_hide"]}},"deny-webview-position":{"identifier":"deny-webview-position","description":"Denies the webview_position command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_position"]}},"deny-webview-show":{"identifier":"deny-webview-show","description":"Denies the webview_show command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_show"]}},"deny-webview-size":{"identifier":"deny-webview-size","description":"Denies the webview_size command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_size"]}}},"permission_sets":{},"global_scope_schema":null},"core:window":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-get-all-windows","allow-scale-factor","allow-inner-position","allow-outer-position","allow-inner-size","allow-outer-size","allow-is-fullscreen","allow-is-minimized","allow-is-maximized","allow-is-focused","allow-is-decorated","allow-is-resizable","allow-is-maximizable","allow-is-minimizable","allow-is-closable","allow-is-visible","allow-is-enabled","allow-title","allow-current-monitor","allow-primary-monitor","allow-monitor-from-point","allow-available-monitors","allow-cursor-position","allow-theme","allow-is-always-on-top","allow-activity-name","allow-scene-identifier","allow-internal-toggle-maximize"]},"permissions":{"allow-activity-name":{"identifier":"allow-activity-name","description":"Enables the activity_name command without any pre-configured scope.","commands":{"allow":["activity_name"],"deny":[]}},"allow-available-monitors":{"identifier":"allow-available-monitors","description":"Enables the available_monitors command without any pre-configured scope.","commands":{"allow":["available_monitors"],"deny":[]}},"allow-center":{"identifier":"allow-center","description":"Enables the center command without any pre-configured scope.","commands":{"allow":["center"],"deny":[]}},"allow-close":{"identifier":"allow-close","description":"Enables the close command without any pre-configured scope.","commands":{"allow":["close"],"deny":[]}},"allow-create":{"identifier":"allow-create","description":"Enables the create command without any pre-configured scope.","commands":{"allow":["create"],"deny":[]}},"allow-current-monitor":{"identifier":"allow-current-monitor","description":"Enables the current_monitor command without any pre-configured scope.","commands":{"allow":["current_monitor"],"deny":[]}},"allow-cursor-position":{"identifier":"allow-cursor-position","description":"Enables the cursor_position command without any pre-configured scope.","commands":{"allow":["cursor_position"],"deny":[]}},"allow-destroy":{"identifier":"allow-destroy","description":"Enables the destroy command without any pre-configured scope.","commands":{"allow":["destroy"],"deny":[]}},"allow-get-all-windows":{"identifier":"allow-get-all-windows","description":"Enables the get_all_windows command without any pre-configured scope.","commands":{"allow":["get_all_windows"],"deny":[]}},"allow-hide":{"identifier":"allow-hide","description":"Enables the hide command without any pre-configured scope.","commands":{"allow":["hide"],"deny":[]}},"allow-inner-position":{"identifier":"allow-inner-position","description":"Enables the inner_position command without any pre-configured scope.","commands":{"allow":["inner_position"],"deny":[]}},"allow-inner-size":{"identifier":"allow-inner-size","description":"Enables the inner_size command without any pre-configured scope.","commands":{"allow":["inner_size"],"deny":[]}},"allow-internal-toggle-maximize":{"identifier":"allow-internal-toggle-maximize","description":"Enables the internal_toggle_maximize command without any pre-configured scope.","commands":{"allow":["internal_toggle_maximize"],"deny":[]}},"allow-is-always-on-top":{"identifier":"allow-is-always-on-top","description":"Enables the is_always_on_top command without any pre-configured scope.","commands":{"allow":["is_always_on_top"],"deny":[]}},"allow-is-closable":{"identifier":"allow-is-closable","description":"Enables the is_closable command without any pre-configured scope.","commands":{"allow":["is_closable"],"deny":[]}},"allow-is-decorated":{"identifier":"allow-is-decorated","description":"Enables the is_decorated command without any pre-configured scope.","commands":{"allow":["is_decorated"],"deny":[]}},"allow-is-enabled":{"identifier":"allow-is-enabled","description":"Enables the is_enabled command without any pre-configured scope.","commands":{"allow":["is_enabled"],"deny":[]}},"allow-is-focused":{"identifier":"allow-is-focused","description":"Enables the is_focused command without any pre-configured scope.","commands":{"allow":["is_focused"],"deny":[]}},"allow-is-fullscreen":{"identifier":"allow-is-fullscreen","description":"Enables the is_fullscreen command without any pre-configured scope.","commands":{"allow":["is_fullscreen"],"deny":[]}},"allow-is-maximizable":{"identifier":"allow-is-maximizable","description":"Enables the is_maximizable command without any pre-configured scope.","commands":{"allow":["is_maximizable"],"deny":[]}},"allow-is-maximized":{"identifier":"allow-is-maximized","description":"Enables the is_maximized command without any pre-configured scope.","commands":{"allow":["is_maximized"],"deny":[]}},"allow-is-minimizable":{"identifier":"allow-is-minimizable","description":"Enables the is_minimizable command without any pre-configured scope.","commands":{"allow":["is_minimizable"],"deny":[]}},"allow-is-minimized":{"identifier":"allow-is-minimized","description":"Enables the is_minimized command without any pre-configured scope.","commands":{"allow":["is_minimized"],"deny":[]}},"allow-is-resizable":{"identifier":"allow-is-resizable","description":"Enables the is_resizable command without any pre-configured scope.","commands":{"allow":["is_resizable"],"deny":[]}},"allow-is-visible":{"identifier":"allow-is-visible","description":"Enables the is_visible command without any pre-configured scope.","commands":{"allow":["is_visible"],"deny":[]}},"allow-maximize":{"identifier":"allow-maximize","description":"Enables the maximize command without any pre-configured scope.","commands":{"allow":["maximize"],"deny":[]}},"allow-minimize":{"identifier":"allow-minimize","description":"Enables the minimize command without any pre-configured scope.","commands":{"allow":["minimize"],"deny":[]}},"allow-monitor-from-point":{"identifier":"allow-monitor-from-point","description":"Enables the monitor_from_point command without any pre-configured scope.","commands":{"allow":["monitor_from_point"],"deny":[]}},"allow-outer-position":{"identifier":"allow-outer-position","description":"Enables the outer_position command without any pre-configured scope.","commands":{"allow":["outer_position"],"deny":[]}},"allow-outer-size":{"identifier":"allow-outer-size","description":"Enables the outer_size command without any pre-configured scope.","commands":{"allow":["outer_size"],"deny":[]}},"allow-primary-monitor":{"identifier":"allow-primary-monitor","description":"Enables the primary_monitor command without any pre-configured scope.","commands":{"allow":["primary_monitor"],"deny":[]}},"allow-request-user-attention":{"identifier":"allow-request-user-attention","description":"Enables the request_user_attention command without any pre-configured scope.","commands":{"allow":["request_user_attention"],"deny":[]}},"allow-scale-factor":{"identifier":"allow-scale-factor","description":"Enables the scale_factor command without any pre-configured scope.","commands":{"allow":["scale_factor"],"deny":[]}},"allow-scene-identifier":{"identifier":"allow-scene-identifier","description":"Enables the scene_identifier command without any pre-configured scope.","commands":{"allow":["scene_identifier"],"deny":[]}},"allow-set-always-on-bottom":{"identifier":"allow-set-always-on-bottom","description":"Enables the set_always_on_bottom command without any pre-configured scope.","commands":{"allow":["set_always_on_bottom"],"deny":[]}},"allow-set-always-on-top":{"identifier":"allow-set-always-on-top","description":"Enables the set_always_on_top command without any pre-configured scope.","commands":{"allow":["set_always_on_top"],"deny":[]}},"allow-set-background-color":{"identifier":"allow-set-background-color","description":"Enables the set_background_color command without any pre-configured scope.","commands":{"allow":["set_background_color"],"deny":[]}},"allow-set-badge-count":{"identifier":"allow-set-badge-count","description":"Enables the set_badge_count command without any pre-configured scope.","commands":{"allow":["set_badge_count"],"deny":[]}},"allow-set-badge-label":{"identifier":"allow-set-badge-label","description":"Enables the set_badge_label command without any pre-configured scope.","commands":{"allow":["set_badge_label"],"deny":[]}},"allow-set-closable":{"identifier":"allow-set-closable","description":"Enables the set_closable command without any pre-configured scope.","commands":{"allow":["set_closable"],"deny":[]}},"allow-set-content-protected":{"identifier":"allow-set-content-protected","description":"Enables the set_content_protected command without any pre-configured scope.","commands":{"allow":["set_content_protected"],"deny":[]}},"allow-set-cursor-grab":{"identifier":"allow-set-cursor-grab","description":"Enables the set_cursor_grab command without any pre-configured scope.","commands":{"allow":["set_cursor_grab"],"deny":[]}},"allow-set-cursor-icon":{"identifier":"allow-set-cursor-icon","description":"Enables the set_cursor_icon command without any pre-configured scope.","commands":{"allow":["set_cursor_icon"],"deny":[]}},"allow-set-cursor-position":{"identifier":"allow-set-cursor-position","description":"Enables the set_cursor_position command without any pre-configured scope.","commands":{"allow":["set_cursor_position"],"deny":[]}},"allow-set-cursor-visible":{"identifier":"allow-set-cursor-visible","description":"Enables the set_cursor_visible command without any pre-configured scope.","commands":{"allow":["set_cursor_visible"],"deny":[]}},"allow-set-decorations":{"identifier":"allow-set-decorations","description":"Enables the set_decorations command without any pre-configured scope.","commands":{"allow":["set_decorations"],"deny":[]}},"allow-set-effects":{"identifier":"allow-set-effects","description":"Enables the set_effects command without any pre-configured scope.","commands":{"allow":["set_effects"],"deny":[]}},"allow-set-enabled":{"identifier":"allow-set-enabled","description":"Enables the set_enabled command without any pre-configured scope.","commands":{"allow":["set_enabled"],"deny":[]}},"allow-set-focus":{"identifier":"allow-set-focus","description":"Enables the set_focus command without any pre-configured scope.","commands":{"allow":["set_focus"],"deny":[]}},"allow-set-focusable":{"identifier":"allow-set-focusable","description":"Enables the set_focusable command without any pre-configured scope.","commands":{"allow":["set_focusable"],"deny":[]}},"allow-set-fullscreen":{"identifier":"allow-set-fullscreen","description":"Enables the set_fullscreen command without any pre-configured scope.","commands":{"allow":["set_fullscreen"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-ignore-cursor-events":{"identifier":"allow-set-ignore-cursor-events","description":"Enables the set_ignore_cursor_events command without any pre-configured scope.","commands":{"allow":["set_ignore_cursor_events"],"deny":[]}},"allow-set-max-size":{"identifier":"allow-set-max-size","description":"Enables the set_max_size command without any pre-configured scope.","commands":{"allow":["set_max_size"],"deny":[]}},"allow-set-maximizable":{"identifier":"allow-set-maximizable","description":"Enables the set_maximizable command without any pre-configured scope.","commands":{"allow":["set_maximizable"],"deny":[]}},"allow-set-min-size":{"identifier":"allow-set-min-size","description":"Enables the set_min_size command without any pre-configured scope.","commands":{"allow":["set_min_size"],"deny":[]}},"allow-set-minimizable":{"identifier":"allow-set-minimizable","description":"Enables the set_minimizable command without any pre-configured scope.","commands":{"allow":["set_minimizable"],"deny":[]}},"allow-set-overlay-icon":{"identifier":"allow-set-overlay-icon","description":"Enables the set_overlay_icon command without any pre-configured scope.","commands":{"allow":["set_overlay_icon"],"deny":[]}},"allow-set-position":{"identifier":"allow-set-position","description":"Enables the set_position command without any pre-configured scope.","commands":{"allow":["set_position"],"deny":[]}},"allow-set-progress-bar":{"identifier":"allow-set-progress-bar","description":"Enables the set_progress_bar command without any pre-configured scope.","commands":{"allow":["set_progress_bar"],"deny":[]}},"allow-set-resizable":{"identifier":"allow-set-resizable","description":"Enables the set_resizable command without any pre-configured scope.","commands":{"allow":["set_resizable"],"deny":[]}},"allow-set-shadow":{"identifier":"allow-set-shadow","description":"Enables the set_shadow command without any pre-configured scope.","commands":{"allow":["set_shadow"],"deny":[]}},"allow-set-simple-fullscreen":{"identifier":"allow-set-simple-fullscreen","description":"Enables the set_simple_fullscreen command without any pre-configured scope.","commands":{"allow":["set_simple_fullscreen"],"deny":[]}},"allow-set-size":{"identifier":"allow-set-size","description":"Enables the set_size command without any pre-configured scope.","commands":{"allow":["set_size"],"deny":[]}},"allow-set-size-constraints":{"identifier":"allow-set-size-constraints","description":"Enables the set_size_constraints command without any pre-configured scope.","commands":{"allow":["set_size_constraints"],"deny":[]}},"allow-set-skip-taskbar":{"identifier":"allow-set-skip-taskbar","description":"Enables the set_skip_taskbar command without any pre-configured scope.","commands":{"allow":["set_skip_taskbar"],"deny":[]}},"allow-set-theme":{"identifier":"allow-set-theme","description":"Enables the set_theme command without any pre-configured scope.","commands":{"allow":["set_theme"],"deny":[]}},"allow-set-title":{"identifier":"allow-set-title","description":"Enables the set_title command without any pre-configured scope.","commands":{"allow":["set_title"],"deny":[]}},"allow-set-title-bar-style":{"identifier":"allow-set-title-bar-style","description":"Enables the set_title_bar_style command without any pre-configured scope.","commands":{"allow":["set_title_bar_style"],"deny":[]}},"allow-set-visible-on-all-workspaces":{"identifier":"allow-set-visible-on-all-workspaces","description":"Enables the set_visible_on_all_workspaces command without any pre-configured scope.","commands":{"allow":["set_visible_on_all_workspaces"],"deny":[]}},"allow-show":{"identifier":"allow-show","description":"Enables the show command without any pre-configured scope.","commands":{"allow":["show"],"deny":[]}},"allow-start-dragging":{"identifier":"allow-start-dragging","description":"Enables the start_dragging command without any pre-configured scope.","commands":{"allow":["start_dragging"],"deny":[]}},"allow-start-resize-dragging":{"identifier":"allow-start-resize-dragging","description":"Enables the start_resize_dragging command without any pre-configured scope.","commands":{"allow":["start_resize_dragging"],"deny":[]}},"allow-theme":{"identifier":"allow-theme","description":"Enables the theme command without any pre-configured scope.","commands":{"allow":["theme"],"deny":[]}},"allow-title":{"identifier":"allow-title","description":"Enables the title command without any pre-configured scope.","commands":{"allow":["title"],"deny":[]}},"allow-toggle-maximize":{"identifier":"allow-toggle-maximize","description":"Enables the toggle_maximize command without any pre-configured scope.","commands":{"allow":["toggle_maximize"],"deny":[]}},"allow-unmaximize":{"identifier":"allow-unmaximize","description":"Enables the unmaximize command without any pre-configured scope.","commands":{"allow":["unmaximize"],"deny":[]}},"allow-unminimize":{"identifier":"allow-unminimize","description":"Enables the unminimize command without any pre-configured scope.","commands":{"allow":["unminimize"],"deny":[]}},"deny-activity-name":{"identifier":"deny-activity-name","description":"Denies the activity_name command without any pre-configured scope.","commands":{"allow":[],"deny":["activity_name"]}},"deny-available-monitors":{"identifier":"deny-available-monitors","description":"Denies the available_monitors command without any pre-configured scope.","commands":{"allow":[],"deny":["available_monitors"]}},"deny-center":{"identifier":"deny-center","description":"Denies the center command without any pre-configured scope.","commands":{"allow":[],"deny":["center"]}},"deny-close":{"identifier":"deny-close","description":"Denies the close command without any pre-configured scope.","commands":{"allow":[],"deny":["close"]}},"deny-create":{"identifier":"deny-create","description":"Denies the create command without any pre-configured scope.","commands":{"allow":[],"deny":["create"]}},"deny-current-monitor":{"identifier":"deny-current-monitor","description":"Denies the current_monitor command without any pre-configured scope.","commands":{"allow":[],"deny":["current_monitor"]}},"deny-cursor-position":{"identifier":"deny-cursor-position","description":"Denies the cursor_position command without any pre-configured scope.","commands":{"allow":[],"deny":["cursor_position"]}},"deny-destroy":{"identifier":"deny-destroy","description":"Denies the destroy command without any pre-configured scope.","commands":{"allow":[],"deny":["destroy"]}},"deny-get-all-windows":{"identifier":"deny-get-all-windows","description":"Denies the get_all_windows command without any pre-configured scope.","commands":{"allow":[],"deny":["get_all_windows"]}},"deny-hide":{"identifier":"deny-hide","description":"Denies the hide command without any pre-configured scope.","commands":{"allow":[],"deny":["hide"]}},"deny-inner-position":{"identifier":"deny-inner-position","description":"Denies the inner_position command without any pre-configured scope.","commands":{"allow":[],"deny":["inner_position"]}},"deny-inner-size":{"identifier":"deny-inner-size","description":"Denies the inner_size command without any pre-configured scope.","commands":{"allow":[],"deny":["inner_size"]}},"deny-internal-toggle-maximize":{"identifier":"deny-internal-toggle-maximize","description":"Denies the internal_toggle_maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["internal_toggle_maximize"]}},"deny-is-always-on-top":{"identifier":"deny-is-always-on-top","description":"Denies the is_always_on_top command without any pre-configured scope.","commands":{"allow":[],"deny":["is_always_on_top"]}},"deny-is-closable":{"identifier":"deny-is-closable","description":"Denies the is_closable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_closable"]}},"deny-is-decorated":{"identifier":"deny-is-decorated","description":"Denies the is_decorated command without any pre-configured scope.","commands":{"allow":[],"deny":["is_decorated"]}},"deny-is-enabled":{"identifier":"deny-is-enabled","description":"Denies the is_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["is_enabled"]}},"deny-is-focused":{"identifier":"deny-is-focused","description":"Denies the is_focused command without any pre-configured scope.","commands":{"allow":[],"deny":["is_focused"]}},"deny-is-fullscreen":{"identifier":"deny-is-fullscreen","description":"Denies the is_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["is_fullscreen"]}},"deny-is-maximizable":{"identifier":"deny-is-maximizable","description":"Denies the is_maximizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_maximizable"]}},"deny-is-maximized":{"identifier":"deny-is-maximized","description":"Denies the is_maximized command without any pre-configured scope.","commands":{"allow":[],"deny":["is_maximized"]}},"deny-is-minimizable":{"identifier":"deny-is-minimizable","description":"Denies the is_minimizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_minimizable"]}},"deny-is-minimized":{"identifier":"deny-is-minimized","description":"Denies the is_minimized command without any pre-configured scope.","commands":{"allow":[],"deny":["is_minimized"]}},"deny-is-resizable":{"identifier":"deny-is-resizable","description":"Denies the is_resizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_resizable"]}},"deny-is-visible":{"identifier":"deny-is-visible","description":"Denies the is_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["is_visible"]}},"deny-maximize":{"identifier":"deny-maximize","description":"Denies the maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["maximize"]}},"deny-minimize":{"identifier":"deny-minimize","description":"Denies the minimize command without any pre-configured scope.","commands":{"allow":[],"deny":["minimize"]}},"deny-monitor-from-point":{"identifier":"deny-monitor-from-point","description":"Denies the monitor_from_point command without any pre-configured scope.","commands":{"allow":[],"deny":["monitor_from_point"]}},"deny-outer-position":{"identifier":"deny-outer-position","description":"Denies the outer_position command without any pre-configured scope.","commands":{"allow":[],"deny":["outer_position"]}},"deny-outer-size":{"identifier":"deny-outer-size","description":"Denies the outer_size command without any pre-configured scope.","commands":{"allow":[],"deny":["outer_size"]}},"deny-primary-monitor":{"identifier":"deny-primary-monitor","description":"Denies the primary_monitor command without any pre-configured scope.","commands":{"allow":[],"deny":["primary_monitor"]}},"deny-request-user-attention":{"identifier":"deny-request-user-attention","description":"Denies the request_user_attention command without any pre-configured scope.","commands":{"allow":[],"deny":["request_user_attention"]}},"deny-scale-factor":{"identifier":"deny-scale-factor","description":"Denies the scale_factor command without any pre-configured scope.","commands":{"allow":[],"deny":["scale_factor"]}},"deny-scene-identifier":{"identifier":"deny-scene-identifier","description":"Denies the scene_identifier command without any pre-configured scope.","commands":{"allow":[],"deny":["scene_identifier"]}},"deny-set-always-on-bottom":{"identifier":"deny-set-always-on-bottom","description":"Denies the set_always_on_bottom command without any pre-configured scope.","commands":{"allow":[],"deny":["set_always_on_bottom"]}},"deny-set-always-on-top":{"identifier":"deny-set-always-on-top","description":"Denies the set_always_on_top command without any pre-configured scope.","commands":{"allow":[],"deny":["set_always_on_top"]}},"deny-set-background-color":{"identifier":"deny-set-background-color","description":"Denies the set_background_color command without any pre-configured scope.","commands":{"allow":[],"deny":["set_background_color"]}},"deny-set-badge-count":{"identifier":"deny-set-badge-count","description":"Denies the set_badge_count command without any pre-configured scope.","commands":{"allow":[],"deny":["set_badge_count"]}},"deny-set-badge-label":{"identifier":"deny-set-badge-label","description":"Denies the set_badge_label command without any pre-configured scope.","commands":{"allow":[],"deny":["set_badge_label"]}},"deny-set-closable":{"identifier":"deny-set-closable","description":"Denies the set_closable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_closable"]}},"deny-set-content-protected":{"identifier":"deny-set-content-protected","description":"Denies the set_content_protected command without any pre-configured scope.","commands":{"allow":[],"deny":["set_content_protected"]}},"deny-set-cursor-grab":{"identifier":"deny-set-cursor-grab","description":"Denies the set_cursor_grab command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_grab"]}},"deny-set-cursor-icon":{"identifier":"deny-set-cursor-icon","description":"Denies the set_cursor_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_icon"]}},"deny-set-cursor-position":{"identifier":"deny-set-cursor-position","description":"Denies the set_cursor_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_position"]}},"deny-set-cursor-visible":{"identifier":"deny-set-cursor-visible","description":"Denies the set_cursor_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_visible"]}},"deny-set-decorations":{"identifier":"deny-set-decorations","description":"Denies the set_decorations command without any pre-configured scope.","commands":{"allow":[],"deny":["set_decorations"]}},"deny-set-effects":{"identifier":"deny-set-effects","description":"Denies the set_effects command without any pre-configured scope.","commands":{"allow":[],"deny":["set_effects"]}},"deny-set-enabled":{"identifier":"deny-set-enabled","description":"Denies the set_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["set_enabled"]}},"deny-set-focus":{"identifier":"deny-set-focus","description":"Denies the set_focus command without any pre-configured scope.","commands":{"allow":[],"deny":["set_focus"]}},"deny-set-focusable":{"identifier":"deny-set-focusable","description":"Denies the set_focusable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_focusable"]}},"deny-set-fullscreen":{"identifier":"deny-set-fullscreen","description":"Denies the set_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["set_fullscreen"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-ignore-cursor-events":{"identifier":"deny-set-ignore-cursor-events","description":"Denies the set_ignore_cursor_events command without any pre-configured scope.","commands":{"allow":[],"deny":["set_ignore_cursor_events"]}},"deny-set-max-size":{"identifier":"deny-set-max-size","description":"Denies the set_max_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_max_size"]}},"deny-set-maximizable":{"identifier":"deny-set-maximizable","description":"Denies the set_maximizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_maximizable"]}},"deny-set-min-size":{"identifier":"deny-set-min-size","description":"Denies the set_min_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_min_size"]}},"deny-set-minimizable":{"identifier":"deny-set-minimizable","description":"Denies the set_minimizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_minimizable"]}},"deny-set-overlay-icon":{"identifier":"deny-set-overlay-icon","description":"Denies the set_overlay_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_overlay_icon"]}},"deny-set-position":{"identifier":"deny-set-position","description":"Denies the set_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_position"]}},"deny-set-progress-bar":{"identifier":"deny-set-progress-bar","description":"Denies the set_progress_bar command without any pre-configured scope.","commands":{"allow":[],"deny":["set_progress_bar"]}},"deny-set-resizable":{"identifier":"deny-set-resizable","description":"Denies the set_resizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_resizable"]}},"deny-set-shadow":{"identifier":"deny-set-shadow","description":"Denies the set_shadow command without any pre-configured scope.","commands":{"allow":[],"deny":["set_shadow"]}},"deny-set-simple-fullscreen":{"identifier":"deny-set-simple-fullscreen","description":"Denies the set_simple_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["set_simple_fullscreen"]}},"deny-set-size":{"identifier":"deny-set-size","description":"Denies the set_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_size"]}},"deny-set-size-constraints":{"identifier":"deny-set-size-constraints","description":"Denies the set_size_constraints command without any pre-configured scope.","commands":{"allow":[],"deny":["set_size_constraints"]}},"deny-set-skip-taskbar":{"identifier":"deny-set-skip-taskbar","description":"Denies the set_skip_taskbar command without any pre-configured scope.","commands":{"allow":[],"deny":["set_skip_taskbar"]}},"deny-set-theme":{"identifier":"deny-set-theme","description":"Denies the set_theme command without any pre-configured scope.","commands":{"allow":[],"deny":["set_theme"]}},"deny-set-title":{"identifier":"deny-set-title","description":"Denies the set_title command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title"]}},"deny-set-title-bar-style":{"identifier":"deny-set-title-bar-style","description":"Denies the set_title_bar_style command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title_bar_style"]}},"deny-set-visible-on-all-workspaces":{"identifier":"deny-set-visible-on-all-workspaces","description":"Denies the set_visible_on_all_workspaces command without any pre-configured scope.","commands":{"allow":[],"deny":["set_visible_on_all_workspaces"]}},"deny-show":{"identifier":"deny-show","description":"Denies the show command without any pre-configured scope.","commands":{"allow":[],"deny":["show"]}},"deny-start-dragging":{"identifier":"deny-start-dragging","description":"Denies the start_dragging command without any pre-configured scope.","commands":{"allow":[],"deny":["start_dragging"]}},"deny-start-resize-dragging":{"identifier":"deny-start-resize-dragging","description":"Denies the start_resize_dragging command without any pre-configured scope.","commands":{"allow":[],"deny":["start_resize_dragging"]}},"deny-theme":{"identifier":"deny-theme","description":"Denies the theme command without any pre-configured scope.","commands":{"allow":[],"deny":["theme"]}},"deny-title":{"identifier":"deny-title","description":"Denies the title command without any pre-configured scope.","commands":{"allow":[],"deny":["title"]}},"deny-toggle-maximize":{"identifier":"deny-toggle-maximize","description":"Denies the toggle_maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["toggle_maximize"]}},"deny-unmaximize":{"identifier":"deny-unmaximize","description":"Denies the unmaximize command without any pre-configured scope.","commands":{"allow":[],"deny":["unmaximize"]}},"deny-unminimize":{"identifier":"deny-unminimize","description":"Denies the unminimize command without any pre-configured scope.","commands":{"allow":[],"deny":["unminimize"]}}},"permission_sets":{},"global_scope_schema":null},"dialog":{"default_permission":{"identifier":"default","description":"This permission set configures the types of dialogs\navailable from the dialog plugin.\n\n#### Granted Permissions\n\nAll dialog types are enabled.\n\n\n","permissions":["allow-message","allow-save","allow-open"]},"permissions":{"allow-ask":{"identifier":"allow-ask","description":"Enables the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)","commands":{"allow":["message"],"deny":[]}},"allow-confirm":{"identifier":"allow-confirm","description":"Enables the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)","commands":{"allow":["message"],"deny":[]}},"allow-message":{"identifier":"allow-message","description":"Enables the message command without any pre-configured scope.","commands":{"allow":["message"],"deny":[]}},"allow-open":{"identifier":"allow-open","description":"Enables the open command without any pre-configured scope.","commands":{"allow":["open"],"deny":[]}},"allow-save":{"identifier":"allow-save","description":"Enables the save command without any pre-configured scope.","commands":{"allow":["save"],"deny":[]}},"deny-ask":{"identifier":"deny-ask","description":"Denies the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)","commands":{"allow":[],"deny":["message"]}},"deny-confirm":{"identifier":"deny-confirm","description":"Denies the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)","commands":{"allow":[],"deny":["message"]}},"deny-message":{"identifier":"deny-message","description":"Denies the message command without any pre-configured scope.","commands":{"allow":[],"deny":["message"]}},"deny-open":{"identifier":"deny-open","description":"Denies the open command without any pre-configured scope.","commands":{"allow":[],"deny":["open"]}},"deny-save":{"identifier":"deny-save","description":"Denies the save command without any pre-configured scope.","commands":{"allow":[],"deny":["save"]}}},"permission_sets":{},"global_scope_schema":null}}
\ No newline at end of file
+{"core":{"default_permission":{"identifier":"default","description":"Default core plugins set.","permissions":["core:path:default","core:event:default","core:window:default","core:webview:default","core:app:default","core:image:default","core:resources:default","core:menu:default","core:tray:default"]},"permissions":{},"permission_sets":{},"global_scope_schema":null},"core:app":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-version","allow-name","allow-tauri-version","allow-identifier","allow-bundle-type","allow-register-listener","allow-remove-listener","allow-supports-multiple-windows"]},"permissions":{"allow-app-hide":{"identifier":"allow-app-hide","description":"Enables the app_hide command without any pre-configured scope.","commands":{"allow":["app_hide"],"deny":[]}},"allow-app-show":{"identifier":"allow-app-show","description":"Enables the app_show command without any pre-configured scope.","commands":{"allow":["app_show"],"deny":[]}},"allow-bundle-type":{"identifier":"allow-bundle-type","description":"Enables the bundle_type command without any pre-configured scope.","commands":{"allow":["bundle_type"],"deny":[]}},"allow-default-window-icon":{"identifier":"allow-default-window-icon","description":"Enables the default_window_icon command without any pre-configured scope.","commands":{"allow":["default_window_icon"],"deny":[]}},"allow-fetch-data-store-identifiers":{"identifier":"allow-fetch-data-store-identifiers","description":"Enables the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":["fetch_data_store_identifiers"],"deny":[]}},"allow-identifier":{"identifier":"allow-identifier","description":"Enables the identifier command without any pre-configured scope.","commands":{"allow":["identifier"],"deny":[]}},"allow-name":{"identifier":"allow-name","description":"Enables the name command without any pre-configured scope.","commands":{"allow":["name"],"deny":[]}},"allow-register-listener":{"identifier":"allow-register-listener","description":"Enables the register_listener command without any pre-configured scope.","commands":{"allow":["register_listener"],"deny":[]}},"allow-remove-data-store":{"identifier":"allow-remove-data-store","description":"Enables the remove_data_store command without any pre-configured scope.","commands":{"allow":["remove_data_store"],"deny":[]}},"allow-remove-listener":{"identifier":"allow-remove-listener","description":"Enables the remove_listener command without any pre-configured scope.","commands":{"allow":["remove_listener"],"deny":[]}},"allow-set-app-theme":{"identifier":"allow-set-app-theme","description":"Enables the set_app_theme command without any pre-configured scope.","commands":{"allow":["set_app_theme"],"deny":[]}},"allow-set-dock-visibility":{"identifier":"allow-set-dock-visibility","description":"Enables the set_dock_visibility command without any pre-configured scope.","commands":{"allow":["set_dock_visibility"],"deny":[]}},"allow-supports-multiple-windows":{"identifier":"allow-supports-multiple-windows","description":"Enables the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":["supports_multiple_windows"],"deny":[]}},"allow-tauri-version":{"identifier":"allow-tauri-version","description":"Enables the tauri_version command without any pre-configured scope.","commands":{"allow":["tauri_version"],"deny":[]}},"allow-version":{"identifier":"allow-version","description":"Enables the version command without any pre-configured scope.","commands":{"allow":["version"],"deny":[]}},"deny-app-hide":{"identifier":"deny-app-hide","description":"Denies the app_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["app_hide"]}},"deny-app-show":{"identifier":"deny-app-show","description":"Denies the app_show command without any pre-configured scope.","commands":{"allow":[],"deny":["app_show"]}},"deny-bundle-type":{"identifier":"deny-bundle-type","description":"Denies the bundle_type command without any pre-configured scope.","commands":{"allow":[],"deny":["bundle_type"]}},"deny-default-window-icon":{"identifier":"deny-default-window-icon","description":"Denies the default_window_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["default_window_icon"]}},"deny-fetch-data-store-identifiers":{"identifier":"deny-fetch-data-store-identifiers","description":"Denies the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":[],"deny":["fetch_data_store_identifiers"]}},"deny-identifier":{"identifier":"deny-identifier","description":"Denies the identifier command without any pre-configured scope.","commands":{"allow":[],"deny":["identifier"]}},"deny-name":{"identifier":"deny-name","description":"Denies the name command without any pre-configured scope.","commands":{"allow":[],"deny":["name"]}},"deny-register-listener":{"identifier":"deny-register-listener","description":"Denies the register_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["register_listener"]}},"deny-remove-data-store":{"identifier":"deny-remove-data-store","description":"Denies the remove_data_store command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_data_store"]}},"deny-remove-listener":{"identifier":"deny-remove-listener","description":"Denies the remove_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_listener"]}},"deny-set-app-theme":{"identifier":"deny-set-app-theme","description":"Denies the set_app_theme command without any pre-configured scope.","commands":{"allow":[],"deny":["set_app_theme"]}},"deny-set-dock-visibility":{"identifier":"deny-set-dock-visibility","description":"Denies the set_dock_visibility command without any pre-configured scope.","commands":{"allow":[],"deny":["set_dock_visibility"]}},"deny-supports-multiple-windows":{"identifier":"deny-supports-multiple-windows","description":"Denies the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":[],"deny":["supports_multiple_windows"]}},"deny-tauri-version":{"identifier":"deny-tauri-version","description":"Denies the tauri_version command without any pre-configured scope.","commands":{"allow":[],"deny":["tauri_version"]}},"deny-version":{"identifier":"deny-version","description":"Denies the version command without any pre-configured scope.","commands":{"allow":[],"deny":["version"]}}},"permission_sets":{},"global_scope_schema":null},"core:event":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-listen","allow-unlisten","allow-emit","allow-emit-to"]},"permissions":{"allow-emit":{"identifier":"allow-emit","description":"Enables the emit command without any pre-configured scope.","commands":{"allow":["emit"],"deny":[]}},"allow-emit-to":{"identifier":"allow-emit-to","description":"Enables the emit_to command without any pre-configured scope.","commands":{"allow":["emit_to"],"deny":[]}},"allow-listen":{"identifier":"allow-listen","description":"Enables the listen command without any pre-configured scope.","commands":{"allow":["listen"],"deny":[]}},"allow-unlisten":{"identifier":"allow-unlisten","description":"Enables the unlisten command without any pre-configured scope.","commands":{"allow":["unlisten"],"deny":[]}},"deny-emit":{"identifier":"deny-emit","description":"Denies the emit command without any pre-configured scope.","commands":{"allow":[],"deny":["emit"]}},"deny-emit-to":{"identifier":"deny-emit-to","description":"Denies the emit_to command without any pre-configured scope.","commands":{"allow":[],"deny":["emit_to"]}},"deny-listen":{"identifier":"deny-listen","description":"Denies the listen command without any pre-configured scope.","commands":{"allow":[],"deny":["listen"]}},"deny-unlisten":{"identifier":"deny-unlisten","description":"Denies the unlisten command without any pre-configured scope.","commands":{"allow":[],"deny":["unlisten"]}}},"permission_sets":{},"global_scope_schema":null},"core:image":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-from-bytes","allow-from-path","allow-rgba","allow-size"]},"permissions":{"allow-from-bytes":{"identifier":"allow-from-bytes","description":"Enables the from_bytes command without any pre-configured scope.","commands":{"allow":["from_bytes"],"deny":[]}},"allow-from-path":{"identifier":"allow-from-path","description":"Enables the from_path command without any pre-configured scope.","commands":{"allow":["from_path"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-rgba":{"identifier":"allow-rgba","description":"Enables the rgba command without any pre-configured scope.","commands":{"allow":["rgba"],"deny":[]}},"allow-size":{"identifier":"allow-size","description":"Enables the size command without any pre-configured scope.","commands":{"allow":["size"],"deny":[]}},"deny-from-bytes":{"identifier":"deny-from-bytes","description":"Denies the from_bytes command without any pre-configured scope.","commands":{"allow":[],"deny":["from_bytes"]}},"deny-from-path":{"identifier":"deny-from-path","description":"Denies the from_path command without any pre-configured scope.","commands":{"allow":[],"deny":["from_path"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-rgba":{"identifier":"deny-rgba","description":"Denies the rgba command without any pre-configured scope.","commands":{"allow":[],"deny":["rgba"]}},"deny-size":{"identifier":"deny-size","description":"Denies the size command without any pre-configured scope.","commands":{"allow":[],"deny":["size"]}}},"permission_sets":{},"global_scope_schema":null},"core:menu":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-append","allow-prepend","allow-insert","allow-remove","allow-remove-at","allow-items","allow-get","allow-popup","allow-create-default","allow-set-as-app-menu","allow-set-as-window-menu","allow-text","allow-set-text","allow-is-enabled","allow-set-enabled","allow-set-accelerator","allow-set-as-windows-menu-for-nsapp","allow-set-as-help-menu-for-nsapp","allow-is-checked","allow-set-checked","allow-set-icon"]},"permissions":{"allow-append":{"identifier":"allow-append","description":"Enables the append command without any pre-configured scope.","commands":{"allow":["append"],"deny":[]}},"allow-create-default":{"identifier":"allow-create-default","description":"Enables the create_default command without any pre-configured scope.","commands":{"allow":["create_default"],"deny":[]}},"allow-get":{"identifier":"allow-get","description":"Enables the get command without any pre-configured scope.","commands":{"allow":["get"],"deny":[]}},"allow-insert":{"identifier":"allow-insert","description":"Enables the insert command without any pre-configured scope.","commands":{"allow":["insert"],"deny":[]}},"allow-is-checked":{"identifier":"allow-is-checked","description":"Enables the is_checked command without any pre-configured scope.","commands":{"allow":["is_checked"],"deny":[]}},"allow-is-enabled":{"identifier":"allow-is-enabled","description":"Enables the is_enabled command without any pre-configured scope.","commands":{"allow":["is_enabled"],"deny":[]}},"allow-items":{"identifier":"allow-items","description":"Enables the items command without any pre-configured scope.","commands":{"allow":["items"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-popup":{"identifier":"allow-popup","description":"Enables the popup command without any pre-configured scope.","commands":{"allow":["popup"],"deny":[]}},"allow-prepend":{"identifier":"allow-prepend","description":"Enables the prepend command without any pre-configured scope.","commands":{"allow":["prepend"],"deny":[]}},"allow-remove":{"identifier":"allow-remove","description":"Enables the remove command without any pre-configured scope.","commands":{"allow":["remove"],"deny":[]}},"allow-remove-at":{"identifier":"allow-remove-at","description":"Enables the remove_at command without any pre-configured scope.","commands":{"allow":["remove_at"],"deny":[]}},"allow-set-accelerator":{"identifier":"allow-set-accelerator","description":"Enables the set_accelerator command without any pre-configured scope.","commands":{"allow":["set_accelerator"],"deny":[]}},"allow-set-as-app-menu":{"identifier":"allow-set-as-app-menu","description":"Enables the set_as_app_menu command without any pre-configured scope.","commands":{"allow":["set_as_app_menu"],"deny":[]}},"allow-set-as-help-menu-for-nsapp":{"identifier":"allow-set-as-help-menu-for-nsapp","description":"Enables the set_as_help_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":["set_as_help_menu_for_nsapp"],"deny":[]}},"allow-set-as-window-menu":{"identifier":"allow-set-as-window-menu","description":"Enables the set_as_window_menu command without any pre-configured scope.","commands":{"allow":["set_as_window_menu"],"deny":[]}},"allow-set-as-windows-menu-for-nsapp":{"identifier":"allow-set-as-windows-menu-for-nsapp","description":"Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":["set_as_windows_menu_for_nsapp"],"deny":[]}},"allow-set-checked":{"identifier":"allow-set-checked","description":"Enables the set_checked command without any pre-configured scope.","commands":{"allow":["set_checked"],"deny":[]}},"allow-set-enabled":{"identifier":"allow-set-enabled","description":"Enables the set_enabled command without any pre-configured scope.","commands":{"allow":["set_enabled"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-text":{"identifier":"allow-set-text","description":"Enables the set_text command without any pre-configured scope.","commands":{"allow":["set_text"],"deny":[]}},"allow-text":{"identifier":"allow-text","description":"Enables the text command without any pre-configured scope.","commands":{"allow":["text"],"deny":[]}},"deny-append":{"identifier":"deny-append","description":"Denies the append command without any pre-configured scope.","commands":{"allow":[],"deny":["append"]}},"deny-create-default":{"identifier":"deny-create-default","description":"Denies the create_default command without any pre-configured scope.","commands":{"allow":[],"deny":["create_default"]}},"deny-get":{"identifier":"deny-get","description":"Denies the get command without any pre-configured scope.","commands":{"allow":[],"deny":["get"]}},"deny-insert":{"identifier":"deny-insert","description":"Denies the insert command without any pre-configured scope.","commands":{"allow":[],"deny":["insert"]}},"deny-is-checked":{"identifier":"deny-is-checked","description":"Denies the is_checked command without any pre-configured scope.","commands":{"allow":[],"deny":["is_checked"]}},"deny-is-enabled":{"identifier":"deny-is-enabled","description":"Denies the is_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["is_enabled"]}},"deny-items":{"identifier":"deny-items","description":"Denies the items command without any pre-configured scope.","commands":{"allow":[],"deny":["items"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-popup":{"identifier":"deny-popup","description":"Denies the popup command without any pre-configured scope.","commands":{"allow":[],"deny":["popup"]}},"deny-prepend":{"identifier":"deny-prepend","description":"Denies the prepend command without any pre-configured scope.","commands":{"allow":[],"deny":["prepend"]}},"deny-remove":{"identifier":"deny-remove","description":"Denies the remove command without any pre-configured scope.","commands":{"allow":[],"deny":["remove"]}},"deny-remove-at":{"identifier":"deny-remove-at","description":"Denies the remove_at command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_at"]}},"deny-set-accelerator":{"identifier":"deny-set-accelerator","description":"Denies the set_accelerator command without any pre-configured scope.","commands":{"allow":[],"deny":["set_accelerator"]}},"deny-set-as-app-menu":{"identifier":"deny-set-as-app-menu","description":"Denies the set_as_app_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_app_menu"]}},"deny-set-as-help-menu-for-nsapp":{"identifier":"deny-set-as-help-menu-for-nsapp","description":"Denies the set_as_help_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_help_menu_for_nsapp"]}},"deny-set-as-window-menu":{"identifier":"deny-set-as-window-menu","description":"Denies the set_as_window_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_window_menu"]}},"deny-set-as-windows-menu-for-nsapp":{"identifier":"deny-set-as-windows-menu-for-nsapp","description":"Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope.","commands":{"allow":[],"deny":["set_as_windows_menu_for_nsapp"]}},"deny-set-checked":{"identifier":"deny-set-checked","description":"Denies the set_checked command without any pre-configured scope.","commands":{"allow":[],"deny":["set_checked"]}},"deny-set-enabled":{"identifier":"deny-set-enabled","description":"Denies the set_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["set_enabled"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-text":{"identifier":"deny-set-text","description":"Denies the set_text command without any pre-configured scope.","commands":{"allow":[],"deny":["set_text"]}},"deny-text":{"identifier":"deny-text","description":"Denies the text command without any pre-configured scope.","commands":{"allow":[],"deny":["text"]}}},"permission_sets":{},"global_scope_schema":null},"core:path":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-resolve-directory","allow-resolve","allow-normalize","allow-join","allow-dirname","allow-extname","allow-basename","allow-is-absolute"]},"permissions":{"allow-basename":{"identifier":"allow-basename","description":"Enables the basename command without any pre-configured scope.","commands":{"allow":["basename"],"deny":[]}},"allow-dirname":{"identifier":"allow-dirname","description":"Enables the dirname command without any pre-configured scope.","commands":{"allow":["dirname"],"deny":[]}},"allow-extname":{"identifier":"allow-extname","description":"Enables the extname command without any pre-configured scope.","commands":{"allow":["extname"],"deny":[]}},"allow-is-absolute":{"identifier":"allow-is-absolute","description":"Enables the is_absolute command without any pre-configured scope.","commands":{"allow":["is_absolute"],"deny":[]}},"allow-join":{"identifier":"allow-join","description":"Enables the join command without any pre-configured scope.","commands":{"allow":["join"],"deny":[]}},"allow-normalize":{"identifier":"allow-normalize","description":"Enables the normalize command without any pre-configured scope.","commands":{"allow":["normalize"],"deny":[]}},"allow-resolve":{"identifier":"allow-resolve","description":"Enables the resolve command without any pre-configured scope.","commands":{"allow":["resolve"],"deny":[]}},"allow-resolve-directory":{"identifier":"allow-resolve-directory","description":"Enables the resolve_directory command without any pre-configured scope.","commands":{"allow":["resolve_directory"],"deny":[]}},"deny-basename":{"identifier":"deny-basename","description":"Denies the basename command without any pre-configured scope.","commands":{"allow":[],"deny":["basename"]}},"deny-dirname":{"identifier":"deny-dirname","description":"Denies the dirname command without any pre-configured scope.","commands":{"allow":[],"deny":["dirname"]}},"deny-extname":{"identifier":"deny-extname","description":"Denies the extname command without any pre-configured scope.","commands":{"allow":[],"deny":["extname"]}},"deny-is-absolute":{"identifier":"deny-is-absolute","description":"Denies the is_absolute command without any pre-configured scope.","commands":{"allow":[],"deny":["is_absolute"]}},"deny-join":{"identifier":"deny-join","description":"Denies the join command without any pre-configured scope.","commands":{"allow":[],"deny":["join"]}},"deny-normalize":{"identifier":"deny-normalize","description":"Denies the normalize command without any pre-configured scope.","commands":{"allow":[],"deny":["normalize"]}},"deny-resolve":{"identifier":"deny-resolve","description":"Denies the resolve command without any pre-configured scope.","commands":{"allow":[],"deny":["resolve"]}},"deny-resolve-directory":{"identifier":"deny-resolve-directory","description":"Denies the resolve_directory command without any pre-configured scope.","commands":{"allow":[],"deny":["resolve_directory"]}}},"permission_sets":{},"global_scope_schema":null},"core:resources":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-close"]},"permissions":{"allow-close":{"identifier":"allow-close","description":"Enables the close command without any pre-configured scope.","commands":{"allow":["close"],"deny":[]}},"deny-close":{"identifier":"deny-close","description":"Denies the close command without any pre-configured scope.","commands":{"allow":[],"deny":["close"]}}},"permission_sets":{},"global_scope_schema":null},"core:tray":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin, which enables all commands.","permissions":["allow-new","allow-get-by-id","allow-remove-by-id","allow-set-icon","allow-set-menu","allow-set-tooltip","allow-set-title","allow-set-visible","allow-set-temp-dir-path","allow-set-icon-as-template","allow-set-icon-with-as-template","allow-set-show-menu-on-left-click"]},"permissions":{"allow-get-by-id":{"identifier":"allow-get-by-id","description":"Enables the get_by_id command without any pre-configured scope.","commands":{"allow":["get_by_id"],"deny":[]}},"allow-new":{"identifier":"allow-new","description":"Enables the new command without any pre-configured scope.","commands":{"allow":["new"],"deny":[]}},"allow-remove-by-id":{"identifier":"allow-remove-by-id","description":"Enables the remove_by_id command without any pre-configured scope.","commands":{"allow":["remove_by_id"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-icon-as-template":{"identifier":"allow-set-icon-as-template","description":"Enables the set_icon_as_template command without any pre-configured scope.","commands":{"allow":["set_icon_as_template"],"deny":[]}},"allow-set-icon-with-as-template":{"identifier":"allow-set-icon-with-as-template","description":"Enables the set_icon_with_as_template command without any pre-configured scope.","commands":{"allow":["set_icon_with_as_template"],"deny":[]}},"allow-set-menu":{"identifier":"allow-set-menu","description":"Enables the set_menu command without any pre-configured scope.","commands":{"allow":["set_menu"],"deny":[]}},"allow-set-show-menu-on-left-click":{"identifier":"allow-set-show-menu-on-left-click","description":"Enables the set_show_menu_on_left_click command without any pre-configured scope.","commands":{"allow":["set_show_menu_on_left_click"],"deny":[]}},"allow-set-temp-dir-path":{"identifier":"allow-set-temp-dir-path","description":"Enables the set_temp_dir_path command without any pre-configured scope.","commands":{"allow":["set_temp_dir_path"],"deny":[]}},"allow-set-title":{"identifier":"allow-set-title","description":"Enables the set_title command without any pre-configured scope.","commands":{"allow":["set_title"],"deny":[]}},"allow-set-tooltip":{"identifier":"allow-set-tooltip","description":"Enables the set_tooltip command without any pre-configured scope.","commands":{"allow":["set_tooltip"],"deny":[]}},"allow-set-visible":{"identifier":"allow-set-visible","description":"Enables the set_visible command without any pre-configured scope.","commands":{"allow":["set_visible"],"deny":[]}},"deny-get-by-id":{"identifier":"deny-get-by-id","description":"Denies the get_by_id command without any pre-configured scope.","commands":{"allow":[],"deny":["get_by_id"]}},"deny-new":{"identifier":"deny-new","description":"Denies the new command without any pre-configured scope.","commands":{"allow":[],"deny":["new"]}},"deny-remove-by-id":{"identifier":"deny-remove-by-id","description":"Denies the remove_by_id command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_by_id"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-icon-as-template":{"identifier":"deny-set-icon-as-template","description":"Denies the set_icon_as_template command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon_as_template"]}},"deny-set-icon-with-as-template":{"identifier":"deny-set-icon-with-as-template","description":"Denies the set_icon_with_as_template command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon_with_as_template"]}},"deny-set-menu":{"identifier":"deny-set-menu","description":"Denies the set_menu command without any pre-configured scope.","commands":{"allow":[],"deny":["set_menu"]}},"deny-set-show-menu-on-left-click":{"identifier":"deny-set-show-menu-on-left-click","description":"Denies the set_show_menu_on_left_click command without any pre-configured scope.","commands":{"allow":[],"deny":["set_show_menu_on_left_click"]}},"deny-set-temp-dir-path":{"identifier":"deny-set-temp-dir-path","description":"Denies the set_temp_dir_path command without any pre-configured scope.","commands":{"allow":[],"deny":["set_temp_dir_path"]}},"deny-set-title":{"identifier":"deny-set-title","description":"Denies the set_title command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title"]}},"deny-set-tooltip":{"identifier":"deny-set-tooltip","description":"Denies the set_tooltip command without any pre-configured scope.","commands":{"allow":[],"deny":["set_tooltip"]}},"deny-set-visible":{"identifier":"deny-set-visible","description":"Denies the set_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["set_visible"]}}},"permission_sets":{},"global_scope_schema":null},"core:webview":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-get-all-webviews","allow-webview-position","allow-webview-size","allow-internal-toggle-devtools"]},"permissions":{"allow-clear-all-browsing-data":{"identifier":"allow-clear-all-browsing-data","description":"Enables the clear_all_browsing_data command without any pre-configured scope.","commands":{"allow":["clear_all_browsing_data"],"deny":[]}},"allow-create-webview":{"identifier":"allow-create-webview","description":"Enables the create_webview command without any pre-configured scope.","commands":{"allow":["create_webview"],"deny":[]}},"allow-create-webview-window":{"identifier":"allow-create-webview-window","description":"Enables the create_webview_window command without any pre-configured scope.","commands":{"allow":["create_webview_window"],"deny":[]}},"allow-get-all-webviews":{"identifier":"allow-get-all-webviews","description":"Enables the get_all_webviews command without any pre-configured scope.","commands":{"allow":["get_all_webviews"],"deny":[]}},"allow-internal-toggle-devtools":{"identifier":"allow-internal-toggle-devtools","description":"Enables the internal_toggle_devtools command without any pre-configured scope.","commands":{"allow":["internal_toggle_devtools"],"deny":[]}},"allow-print":{"identifier":"allow-print","description":"Enables the print command without any pre-configured scope.","commands":{"allow":["print"],"deny":[]}},"allow-reparent":{"identifier":"allow-reparent","description":"Enables the reparent command without any pre-configured scope.","commands":{"allow":["reparent"],"deny":[]}},"allow-set-webview-auto-resize":{"identifier":"allow-set-webview-auto-resize","description":"Enables the set_webview_auto_resize command without any pre-configured scope.","commands":{"allow":["set_webview_auto_resize"],"deny":[]}},"allow-set-webview-background-color":{"identifier":"allow-set-webview-background-color","description":"Enables the set_webview_background_color command without any pre-configured scope.","commands":{"allow":["set_webview_background_color"],"deny":[]}},"allow-set-webview-focus":{"identifier":"allow-set-webview-focus","description":"Enables the set_webview_focus command without any pre-configured scope.","commands":{"allow":["set_webview_focus"],"deny":[]}},"allow-set-webview-position":{"identifier":"allow-set-webview-position","description":"Enables the set_webview_position command without any pre-configured scope.","commands":{"allow":["set_webview_position"],"deny":[]}},"allow-set-webview-size":{"identifier":"allow-set-webview-size","description":"Enables the set_webview_size command without any pre-configured scope.","commands":{"allow":["set_webview_size"],"deny":[]}},"allow-set-webview-zoom":{"identifier":"allow-set-webview-zoom","description":"Enables the set_webview_zoom command without any pre-configured scope.","commands":{"allow":["set_webview_zoom"],"deny":[]}},"allow-webview-close":{"identifier":"allow-webview-close","description":"Enables the webview_close command without any pre-configured scope.","commands":{"allow":["webview_close"],"deny":[]}},"allow-webview-hide":{"identifier":"allow-webview-hide","description":"Enables the webview_hide command without any pre-configured scope.","commands":{"allow":["webview_hide"],"deny":[]}},"allow-webview-position":{"identifier":"allow-webview-position","description":"Enables the webview_position command without any pre-configured scope.","commands":{"allow":["webview_position"],"deny":[]}},"allow-webview-show":{"identifier":"allow-webview-show","description":"Enables the webview_show command without any pre-configured scope.","commands":{"allow":["webview_show"],"deny":[]}},"allow-webview-size":{"identifier":"allow-webview-size","description":"Enables the webview_size command without any pre-configured scope.","commands":{"allow":["webview_size"],"deny":[]}},"deny-clear-all-browsing-data":{"identifier":"deny-clear-all-browsing-data","description":"Denies the clear_all_browsing_data command without any pre-configured scope.","commands":{"allow":[],"deny":["clear_all_browsing_data"]}},"deny-create-webview":{"identifier":"deny-create-webview","description":"Denies the create_webview command without any pre-configured scope.","commands":{"allow":[],"deny":["create_webview"]}},"deny-create-webview-window":{"identifier":"deny-create-webview-window","description":"Denies the create_webview_window command without any pre-configured scope.","commands":{"allow":[],"deny":["create_webview_window"]}},"deny-get-all-webviews":{"identifier":"deny-get-all-webviews","description":"Denies the get_all_webviews command without any pre-configured scope.","commands":{"allow":[],"deny":["get_all_webviews"]}},"deny-internal-toggle-devtools":{"identifier":"deny-internal-toggle-devtools","description":"Denies the internal_toggle_devtools command without any pre-configured scope.","commands":{"allow":[],"deny":["internal_toggle_devtools"]}},"deny-print":{"identifier":"deny-print","description":"Denies the print command without any pre-configured scope.","commands":{"allow":[],"deny":["print"]}},"deny-reparent":{"identifier":"deny-reparent","description":"Denies the reparent command without any pre-configured scope.","commands":{"allow":[],"deny":["reparent"]}},"deny-set-webview-auto-resize":{"identifier":"deny-set-webview-auto-resize","description":"Denies the set_webview_auto_resize command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_auto_resize"]}},"deny-set-webview-background-color":{"identifier":"deny-set-webview-background-color","description":"Denies the set_webview_background_color command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_background_color"]}},"deny-set-webview-focus":{"identifier":"deny-set-webview-focus","description":"Denies the set_webview_focus command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_focus"]}},"deny-set-webview-position":{"identifier":"deny-set-webview-position","description":"Denies the set_webview_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_position"]}},"deny-set-webview-size":{"identifier":"deny-set-webview-size","description":"Denies the set_webview_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_size"]}},"deny-set-webview-zoom":{"identifier":"deny-set-webview-zoom","description":"Denies the set_webview_zoom command without any pre-configured scope.","commands":{"allow":[],"deny":["set_webview_zoom"]}},"deny-webview-close":{"identifier":"deny-webview-close","description":"Denies the webview_close command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_close"]}},"deny-webview-hide":{"identifier":"deny-webview-hide","description":"Denies the webview_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_hide"]}},"deny-webview-position":{"identifier":"deny-webview-position","description":"Denies the webview_position command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_position"]}},"deny-webview-show":{"identifier":"deny-webview-show","description":"Denies the webview_show command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_show"]}},"deny-webview-size":{"identifier":"deny-webview-size","description":"Denies the webview_size command without any pre-configured scope.","commands":{"allow":[],"deny":["webview_size"]}}},"permission_sets":{},"global_scope_schema":null},"core:window":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-get-all-windows","allow-scale-factor","allow-inner-position","allow-outer-position","allow-inner-size","allow-outer-size","allow-is-fullscreen","allow-is-minimized","allow-is-maximized","allow-is-focused","allow-is-decorated","allow-is-resizable","allow-is-maximizable","allow-is-minimizable","allow-is-closable","allow-is-visible","allow-is-enabled","allow-title","allow-current-monitor","allow-primary-monitor","allow-monitor-from-point","allow-available-monitors","allow-cursor-position","allow-theme","allow-is-always-on-top","allow-activity-name","allow-scene-identifier","allow-internal-toggle-maximize"]},"permissions":{"allow-activity-name":{"identifier":"allow-activity-name","description":"Enables the activity_name command without any pre-configured scope.","commands":{"allow":["activity_name"],"deny":[]}},"allow-available-monitors":{"identifier":"allow-available-monitors","description":"Enables the available_monitors command without any pre-configured scope.","commands":{"allow":["available_monitors"],"deny":[]}},"allow-center":{"identifier":"allow-center","description":"Enables the center command without any pre-configured scope.","commands":{"allow":["center"],"deny":[]}},"allow-close":{"identifier":"allow-close","description":"Enables the close command without any pre-configured scope.","commands":{"allow":["close"],"deny":[]}},"allow-create":{"identifier":"allow-create","description":"Enables the create command without any pre-configured scope.","commands":{"allow":["create"],"deny":[]}},"allow-current-monitor":{"identifier":"allow-current-monitor","description":"Enables the current_monitor command without any pre-configured scope.","commands":{"allow":["current_monitor"],"deny":[]}},"allow-cursor-position":{"identifier":"allow-cursor-position","description":"Enables the cursor_position command without any pre-configured scope.","commands":{"allow":["cursor_position"],"deny":[]}},"allow-destroy":{"identifier":"allow-destroy","description":"Enables the destroy command without any pre-configured scope.","commands":{"allow":["destroy"],"deny":[]}},"allow-get-all-windows":{"identifier":"allow-get-all-windows","description":"Enables the get_all_windows command without any pre-configured scope.","commands":{"allow":["get_all_windows"],"deny":[]}},"allow-hide":{"identifier":"allow-hide","description":"Enables the hide command without any pre-configured scope.","commands":{"allow":["hide"],"deny":[]}},"allow-inner-position":{"identifier":"allow-inner-position","description":"Enables the inner_position command without any pre-configured scope.","commands":{"allow":["inner_position"],"deny":[]}},"allow-inner-size":{"identifier":"allow-inner-size","description":"Enables the inner_size command without any pre-configured scope.","commands":{"allow":["inner_size"],"deny":[]}},"allow-internal-toggle-maximize":{"identifier":"allow-internal-toggle-maximize","description":"Enables the internal_toggle_maximize command without any pre-configured scope.","commands":{"allow":["internal_toggle_maximize"],"deny":[]}},"allow-is-always-on-top":{"identifier":"allow-is-always-on-top","description":"Enables the is_always_on_top command without any pre-configured scope.","commands":{"allow":["is_always_on_top"],"deny":[]}},"allow-is-closable":{"identifier":"allow-is-closable","description":"Enables the is_closable command without any pre-configured scope.","commands":{"allow":["is_closable"],"deny":[]}},"allow-is-decorated":{"identifier":"allow-is-decorated","description":"Enables the is_decorated command without any pre-configured scope.","commands":{"allow":["is_decorated"],"deny":[]}},"allow-is-enabled":{"identifier":"allow-is-enabled","description":"Enables the is_enabled command without any pre-configured scope.","commands":{"allow":["is_enabled"],"deny":[]}},"allow-is-focused":{"identifier":"allow-is-focused","description":"Enables the is_focused command without any pre-configured scope.","commands":{"allow":["is_focused"],"deny":[]}},"allow-is-fullscreen":{"identifier":"allow-is-fullscreen","description":"Enables the is_fullscreen command without any pre-configured scope.","commands":{"allow":["is_fullscreen"],"deny":[]}},"allow-is-maximizable":{"identifier":"allow-is-maximizable","description":"Enables the is_maximizable command without any pre-configured scope.","commands":{"allow":["is_maximizable"],"deny":[]}},"allow-is-maximized":{"identifier":"allow-is-maximized","description":"Enables the is_maximized command without any pre-configured scope.","commands":{"allow":["is_maximized"],"deny":[]}},"allow-is-minimizable":{"identifier":"allow-is-minimizable","description":"Enables the is_minimizable command without any pre-configured scope.","commands":{"allow":["is_minimizable"],"deny":[]}},"allow-is-minimized":{"identifier":"allow-is-minimized","description":"Enables the is_minimized command without any pre-configured scope.","commands":{"allow":["is_minimized"],"deny":[]}},"allow-is-resizable":{"identifier":"allow-is-resizable","description":"Enables the is_resizable command without any pre-configured scope.","commands":{"allow":["is_resizable"],"deny":[]}},"allow-is-visible":{"identifier":"allow-is-visible","description":"Enables the is_visible command without any pre-configured scope.","commands":{"allow":["is_visible"],"deny":[]}},"allow-maximize":{"identifier":"allow-maximize","description":"Enables the maximize command without any pre-configured scope.","commands":{"allow":["maximize"],"deny":[]}},"allow-minimize":{"identifier":"allow-minimize","description":"Enables the minimize command without any pre-configured scope.","commands":{"allow":["minimize"],"deny":[]}},"allow-monitor-from-point":{"identifier":"allow-monitor-from-point","description":"Enables the monitor_from_point command without any pre-configured scope.","commands":{"allow":["monitor_from_point"],"deny":[]}},"allow-outer-position":{"identifier":"allow-outer-position","description":"Enables the outer_position command without any pre-configured scope.","commands":{"allow":["outer_position"],"deny":[]}},"allow-outer-size":{"identifier":"allow-outer-size","description":"Enables the outer_size command without any pre-configured scope.","commands":{"allow":["outer_size"],"deny":[]}},"allow-primary-monitor":{"identifier":"allow-primary-monitor","description":"Enables the primary_monitor command without any pre-configured scope.","commands":{"allow":["primary_monitor"],"deny":[]}},"allow-request-user-attention":{"identifier":"allow-request-user-attention","description":"Enables the request_user_attention command without any pre-configured scope.","commands":{"allow":["request_user_attention"],"deny":[]}},"allow-scale-factor":{"identifier":"allow-scale-factor","description":"Enables the scale_factor command without any pre-configured scope.","commands":{"allow":["scale_factor"],"deny":[]}},"allow-scene-identifier":{"identifier":"allow-scene-identifier","description":"Enables the scene_identifier command without any pre-configured scope.","commands":{"allow":["scene_identifier"],"deny":[]}},"allow-set-always-on-bottom":{"identifier":"allow-set-always-on-bottom","description":"Enables the set_always_on_bottom command without any pre-configured scope.","commands":{"allow":["set_always_on_bottom"],"deny":[]}},"allow-set-always-on-top":{"identifier":"allow-set-always-on-top","description":"Enables the set_always_on_top command without any pre-configured scope.","commands":{"allow":["set_always_on_top"],"deny":[]}},"allow-set-background-color":{"identifier":"allow-set-background-color","description":"Enables the set_background_color command without any pre-configured scope.","commands":{"allow":["set_background_color"],"deny":[]}},"allow-set-badge-count":{"identifier":"allow-set-badge-count","description":"Enables the set_badge_count command without any pre-configured scope.","commands":{"allow":["set_badge_count"],"deny":[]}},"allow-set-badge-label":{"identifier":"allow-set-badge-label","description":"Enables the set_badge_label command without any pre-configured scope.","commands":{"allow":["set_badge_label"],"deny":[]}},"allow-set-closable":{"identifier":"allow-set-closable","description":"Enables the set_closable command without any pre-configured scope.","commands":{"allow":["set_closable"],"deny":[]}},"allow-set-content-protected":{"identifier":"allow-set-content-protected","description":"Enables the set_content_protected command without any pre-configured scope.","commands":{"allow":["set_content_protected"],"deny":[]}},"allow-set-cursor-grab":{"identifier":"allow-set-cursor-grab","description":"Enables the set_cursor_grab command without any pre-configured scope.","commands":{"allow":["set_cursor_grab"],"deny":[]}},"allow-set-cursor-icon":{"identifier":"allow-set-cursor-icon","description":"Enables the set_cursor_icon command without any pre-configured scope.","commands":{"allow":["set_cursor_icon"],"deny":[]}},"allow-set-cursor-position":{"identifier":"allow-set-cursor-position","description":"Enables the set_cursor_position command without any pre-configured scope.","commands":{"allow":["set_cursor_position"],"deny":[]}},"allow-set-cursor-visible":{"identifier":"allow-set-cursor-visible","description":"Enables the set_cursor_visible command without any pre-configured scope.","commands":{"allow":["set_cursor_visible"],"deny":[]}},"allow-set-decorations":{"identifier":"allow-set-decorations","description":"Enables the set_decorations command without any pre-configured scope.","commands":{"allow":["set_decorations"],"deny":[]}},"allow-set-effects":{"identifier":"allow-set-effects","description":"Enables the set_effects command without any pre-configured scope.","commands":{"allow":["set_effects"],"deny":[]}},"allow-set-enabled":{"identifier":"allow-set-enabled","description":"Enables the set_enabled command without any pre-configured scope.","commands":{"allow":["set_enabled"],"deny":[]}},"allow-set-focus":{"identifier":"allow-set-focus","description":"Enables the set_focus command without any pre-configured scope.","commands":{"allow":["set_focus"],"deny":[]}},"allow-set-focusable":{"identifier":"allow-set-focusable","description":"Enables the set_focusable command without any pre-configured scope.","commands":{"allow":["set_focusable"],"deny":[]}},"allow-set-fullscreen":{"identifier":"allow-set-fullscreen","description":"Enables the set_fullscreen command without any pre-configured scope.","commands":{"allow":["set_fullscreen"],"deny":[]}},"allow-set-icon":{"identifier":"allow-set-icon","description":"Enables the set_icon command without any pre-configured scope.","commands":{"allow":["set_icon"],"deny":[]}},"allow-set-ignore-cursor-events":{"identifier":"allow-set-ignore-cursor-events","description":"Enables the set_ignore_cursor_events command without any pre-configured scope.","commands":{"allow":["set_ignore_cursor_events"],"deny":[]}},"allow-set-max-size":{"identifier":"allow-set-max-size","description":"Enables the set_max_size command without any pre-configured scope.","commands":{"allow":["set_max_size"],"deny":[]}},"allow-set-maximizable":{"identifier":"allow-set-maximizable","description":"Enables the set_maximizable command without any pre-configured scope.","commands":{"allow":["set_maximizable"],"deny":[]}},"allow-set-min-size":{"identifier":"allow-set-min-size","description":"Enables the set_min_size command without any pre-configured scope.","commands":{"allow":["set_min_size"],"deny":[]}},"allow-set-minimizable":{"identifier":"allow-set-minimizable","description":"Enables the set_minimizable command without any pre-configured scope.","commands":{"allow":["set_minimizable"],"deny":[]}},"allow-set-overlay-icon":{"identifier":"allow-set-overlay-icon","description":"Enables the set_overlay_icon command without any pre-configured scope.","commands":{"allow":["set_overlay_icon"],"deny":[]}},"allow-set-position":{"identifier":"allow-set-position","description":"Enables the set_position command without any pre-configured scope.","commands":{"allow":["set_position"],"deny":[]}},"allow-set-progress-bar":{"identifier":"allow-set-progress-bar","description":"Enables the set_progress_bar command without any pre-configured scope.","commands":{"allow":["set_progress_bar"],"deny":[]}},"allow-set-resizable":{"identifier":"allow-set-resizable","description":"Enables the set_resizable command without any pre-configured scope.","commands":{"allow":["set_resizable"],"deny":[]}},"allow-set-shadow":{"identifier":"allow-set-shadow","description":"Enables the set_shadow command without any pre-configured scope.","commands":{"allow":["set_shadow"],"deny":[]}},"allow-set-simple-fullscreen":{"identifier":"allow-set-simple-fullscreen","description":"Enables the set_simple_fullscreen command without any pre-configured scope.","commands":{"allow":["set_simple_fullscreen"],"deny":[]}},"allow-set-size":{"identifier":"allow-set-size","description":"Enables the set_size command without any pre-configured scope.","commands":{"allow":["set_size"],"deny":[]}},"allow-set-size-constraints":{"identifier":"allow-set-size-constraints","description":"Enables the set_size_constraints command without any pre-configured scope.","commands":{"allow":["set_size_constraints"],"deny":[]}},"allow-set-skip-taskbar":{"identifier":"allow-set-skip-taskbar","description":"Enables the set_skip_taskbar command without any pre-configured scope.","commands":{"allow":["set_skip_taskbar"],"deny":[]}},"allow-set-theme":{"identifier":"allow-set-theme","description":"Enables the set_theme command without any pre-configured scope.","commands":{"allow":["set_theme"],"deny":[]}},"allow-set-title":{"identifier":"allow-set-title","description":"Enables the set_title command without any pre-configured scope.","commands":{"allow":["set_title"],"deny":[]}},"allow-set-title-bar-style":{"identifier":"allow-set-title-bar-style","description":"Enables the set_title_bar_style command without any pre-configured scope.","commands":{"allow":["set_title_bar_style"],"deny":[]}},"allow-set-visible-on-all-workspaces":{"identifier":"allow-set-visible-on-all-workspaces","description":"Enables the set_visible_on_all_workspaces command without any pre-configured scope.","commands":{"allow":["set_visible_on_all_workspaces"],"deny":[]}},"allow-show":{"identifier":"allow-show","description":"Enables the show command without any pre-configured scope.","commands":{"allow":["show"],"deny":[]}},"allow-start-dragging":{"identifier":"allow-start-dragging","description":"Enables the start_dragging command without any pre-configured scope.","commands":{"allow":["start_dragging"],"deny":[]}},"allow-start-resize-dragging":{"identifier":"allow-start-resize-dragging","description":"Enables the start_resize_dragging command without any pre-configured scope.","commands":{"allow":["start_resize_dragging"],"deny":[]}},"allow-theme":{"identifier":"allow-theme","description":"Enables the theme command without any pre-configured scope.","commands":{"allow":["theme"],"deny":[]}},"allow-title":{"identifier":"allow-title","description":"Enables the title command without any pre-configured scope.","commands":{"allow":["title"],"deny":[]}},"allow-toggle-maximize":{"identifier":"allow-toggle-maximize","description":"Enables the toggle_maximize command without any pre-configured scope.","commands":{"allow":["toggle_maximize"],"deny":[]}},"allow-unmaximize":{"identifier":"allow-unmaximize","description":"Enables the unmaximize command without any pre-configured scope.","commands":{"allow":["unmaximize"],"deny":[]}},"allow-unminimize":{"identifier":"allow-unminimize","description":"Enables the unminimize command without any pre-configured scope.","commands":{"allow":["unminimize"],"deny":[]}},"deny-activity-name":{"identifier":"deny-activity-name","description":"Denies the activity_name command without any pre-configured scope.","commands":{"allow":[],"deny":["activity_name"]}},"deny-available-monitors":{"identifier":"deny-available-monitors","description":"Denies the available_monitors command without any pre-configured scope.","commands":{"allow":[],"deny":["available_monitors"]}},"deny-center":{"identifier":"deny-center","description":"Denies the center command without any pre-configured scope.","commands":{"allow":[],"deny":["center"]}},"deny-close":{"identifier":"deny-close","description":"Denies the close command without any pre-configured scope.","commands":{"allow":[],"deny":["close"]}},"deny-create":{"identifier":"deny-create","description":"Denies the create command without any pre-configured scope.","commands":{"allow":[],"deny":["create"]}},"deny-current-monitor":{"identifier":"deny-current-monitor","description":"Denies the current_monitor command without any pre-configured scope.","commands":{"allow":[],"deny":["current_monitor"]}},"deny-cursor-position":{"identifier":"deny-cursor-position","description":"Denies the cursor_position command without any pre-configured scope.","commands":{"allow":[],"deny":["cursor_position"]}},"deny-destroy":{"identifier":"deny-destroy","description":"Denies the destroy command without any pre-configured scope.","commands":{"allow":[],"deny":["destroy"]}},"deny-get-all-windows":{"identifier":"deny-get-all-windows","description":"Denies the get_all_windows command without any pre-configured scope.","commands":{"allow":[],"deny":["get_all_windows"]}},"deny-hide":{"identifier":"deny-hide","description":"Denies the hide command without any pre-configured scope.","commands":{"allow":[],"deny":["hide"]}},"deny-inner-position":{"identifier":"deny-inner-position","description":"Denies the inner_position command without any pre-configured scope.","commands":{"allow":[],"deny":["inner_position"]}},"deny-inner-size":{"identifier":"deny-inner-size","description":"Denies the inner_size command without any pre-configured scope.","commands":{"allow":[],"deny":["inner_size"]}},"deny-internal-toggle-maximize":{"identifier":"deny-internal-toggle-maximize","description":"Denies the internal_toggle_maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["internal_toggle_maximize"]}},"deny-is-always-on-top":{"identifier":"deny-is-always-on-top","description":"Denies the is_always_on_top command without any pre-configured scope.","commands":{"allow":[],"deny":["is_always_on_top"]}},"deny-is-closable":{"identifier":"deny-is-closable","description":"Denies the is_closable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_closable"]}},"deny-is-decorated":{"identifier":"deny-is-decorated","description":"Denies the is_decorated command without any pre-configured scope.","commands":{"allow":[],"deny":["is_decorated"]}},"deny-is-enabled":{"identifier":"deny-is-enabled","description":"Denies the is_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["is_enabled"]}},"deny-is-focused":{"identifier":"deny-is-focused","description":"Denies the is_focused command without any pre-configured scope.","commands":{"allow":[],"deny":["is_focused"]}},"deny-is-fullscreen":{"identifier":"deny-is-fullscreen","description":"Denies the is_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["is_fullscreen"]}},"deny-is-maximizable":{"identifier":"deny-is-maximizable","description":"Denies the is_maximizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_maximizable"]}},"deny-is-maximized":{"identifier":"deny-is-maximized","description":"Denies the is_maximized command without any pre-configured scope.","commands":{"allow":[],"deny":["is_maximized"]}},"deny-is-minimizable":{"identifier":"deny-is-minimizable","description":"Denies the is_minimizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_minimizable"]}},"deny-is-minimized":{"identifier":"deny-is-minimized","description":"Denies the is_minimized command without any pre-configured scope.","commands":{"allow":[],"deny":["is_minimized"]}},"deny-is-resizable":{"identifier":"deny-is-resizable","description":"Denies the is_resizable command without any pre-configured scope.","commands":{"allow":[],"deny":["is_resizable"]}},"deny-is-visible":{"identifier":"deny-is-visible","description":"Denies the is_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["is_visible"]}},"deny-maximize":{"identifier":"deny-maximize","description":"Denies the maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["maximize"]}},"deny-minimize":{"identifier":"deny-minimize","description":"Denies the minimize command without any pre-configured scope.","commands":{"allow":[],"deny":["minimize"]}},"deny-monitor-from-point":{"identifier":"deny-monitor-from-point","description":"Denies the monitor_from_point command without any pre-configured scope.","commands":{"allow":[],"deny":["monitor_from_point"]}},"deny-outer-position":{"identifier":"deny-outer-position","description":"Denies the outer_position command without any pre-configured scope.","commands":{"allow":[],"deny":["outer_position"]}},"deny-outer-size":{"identifier":"deny-outer-size","description":"Denies the outer_size command without any pre-configured scope.","commands":{"allow":[],"deny":["outer_size"]}},"deny-primary-monitor":{"identifier":"deny-primary-monitor","description":"Denies the primary_monitor command without any pre-configured scope.","commands":{"allow":[],"deny":["primary_monitor"]}},"deny-request-user-attention":{"identifier":"deny-request-user-attention","description":"Denies the request_user_attention command without any pre-configured scope.","commands":{"allow":[],"deny":["request_user_attention"]}},"deny-scale-factor":{"identifier":"deny-scale-factor","description":"Denies the scale_factor command without any pre-configured scope.","commands":{"allow":[],"deny":["scale_factor"]}},"deny-scene-identifier":{"identifier":"deny-scene-identifier","description":"Denies the scene_identifier command without any pre-configured scope.","commands":{"allow":[],"deny":["scene_identifier"]}},"deny-set-always-on-bottom":{"identifier":"deny-set-always-on-bottom","description":"Denies the set_always_on_bottom command without any pre-configured scope.","commands":{"allow":[],"deny":["set_always_on_bottom"]}},"deny-set-always-on-top":{"identifier":"deny-set-always-on-top","description":"Denies the set_always_on_top command without any pre-configured scope.","commands":{"allow":[],"deny":["set_always_on_top"]}},"deny-set-background-color":{"identifier":"deny-set-background-color","description":"Denies the set_background_color command without any pre-configured scope.","commands":{"allow":[],"deny":["set_background_color"]}},"deny-set-badge-count":{"identifier":"deny-set-badge-count","description":"Denies the set_badge_count command without any pre-configured scope.","commands":{"allow":[],"deny":["set_badge_count"]}},"deny-set-badge-label":{"identifier":"deny-set-badge-label","description":"Denies the set_badge_label command without any pre-configured scope.","commands":{"allow":[],"deny":["set_badge_label"]}},"deny-set-closable":{"identifier":"deny-set-closable","description":"Denies the set_closable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_closable"]}},"deny-set-content-protected":{"identifier":"deny-set-content-protected","description":"Denies the set_content_protected command without any pre-configured scope.","commands":{"allow":[],"deny":["set_content_protected"]}},"deny-set-cursor-grab":{"identifier":"deny-set-cursor-grab","description":"Denies the set_cursor_grab command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_grab"]}},"deny-set-cursor-icon":{"identifier":"deny-set-cursor-icon","description":"Denies the set_cursor_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_icon"]}},"deny-set-cursor-position":{"identifier":"deny-set-cursor-position","description":"Denies the set_cursor_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_position"]}},"deny-set-cursor-visible":{"identifier":"deny-set-cursor-visible","description":"Denies the set_cursor_visible command without any pre-configured scope.","commands":{"allow":[],"deny":["set_cursor_visible"]}},"deny-set-decorations":{"identifier":"deny-set-decorations","description":"Denies the set_decorations command without any pre-configured scope.","commands":{"allow":[],"deny":["set_decorations"]}},"deny-set-effects":{"identifier":"deny-set-effects","description":"Denies the set_effects command without any pre-configured scope.","commands":{"allow":[],"deny":["set_effects"]}},"deny-set-enabled":{"identifier":"deny-set-enabled","description":"Denies the set_enabled command without any pre-configured scope.","commands":{"allow":[],"deny":["set_enabled"]}},"deny-set-focus":{"identifier":"deny-set-focus","description":"Denies the set_focus command without any pre-configured scope.","commands":{"allow":[],"deny":["set_focus"]}},"deny-set-focusable":{"identifier":"deny-set-focusable","description":"Denies the set_focusable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_focusable"]}},"deny-set-fullscreen":{"identifier":"deny-set-fullscreen","description":"Denies the set_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["set_fullscreen"]}},"deny-set-icon":{"identifier":"deny-set-icon","description":"Denies the set_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_icon"]}},"deny-set-ignore-cursor-events":{"identifier":"deny-set-ignore-cursor-events","description":"Denies the set_ignore_cursor_events command without any pre-configured scope.","commands":{"allow":[],"deny":["set_ignore_cursor_events"]}},"deny-set-max-size":{"identifier":"deny-set-max-size","description":"Denies the set_max_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_max_size"]}},"deny-set-maximizable":{"identifier":"deny-set-maximizable","description":"Denies the set_maximizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_maximizable"]}},"deny-set-min-size":{"identifier":"deny-set-min-size","description":"Denies the set_min_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_min_size"]}},"deny-set-minimizable":{"identifier":"deny-set-minimizable","description":"Denies the set_minimizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_minimizable"]}},"deny-set-overlay-icon":{"identifier":"deny-set-overlay-icon","description":"Denies the set_overlay_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["set_overlay_icon"]}},"deny-set-position":{"identifier":"deny-set-position","description":"Denies the set_position command without any pre-configured scope.","commands":{"allow":[],"deny":["set_position"]}},"deny-set-progress-bar":{"identifier":"deny-set-progress-bar","description":"Denies the set_progress_bar command without any pre-configured scope.","commands":{"allow":[],"deny":["set_progress_bar"]}},"deny-set-resizable":{"identifier":"deny-set-resizable","description":"Denies the set_resizable command without any pre-configured scope.","commands":{"allow":[],"deny":["set_resizable"]}},"deny-set-shadow":{"identifier":"deny-set-shadow","description":"Denies the set_shadow command without any pre-configured scope.","commands":{"allow":[],"deny":["set_shadow"]}},"deny-set-simple-fullscreen":{"identifier":"deny-set-simple-fullscreen","description":"Denies the set_simple_fullscreen command without any pre-configured scope.","commands":{"allow":[],"deny":["set_simple_fullscreen"]}},"deny-set-size":{"identifier":"deny-set-size","description":"Denies the set_size command without any pre-configured scope.","commands":{"allow":[],"deny":["set_size"]}},"deny-set-size-constraints":{"identifier":"deny-set-size-constraints","description":"Denies the set_size_constraints command without any pre-configured scope.","commands":{"allow":[],"deny":["set_size_constraints"]}},"deny-set-skip-taskbar":{"identifier":"deny-set-skip-taskbar","description":"Denies the set_skip_taskbar command without any pre-configured scope.","commands":{"allow":[],"deny":["set_skip_taskbar"]}},"deny-set-theme":{"identifier":"deny-set-theme","description":"Denies the set_theme command without any pre-configured scope.","commands":{"allow":[],"deny":["set_theme"]}},"deny-set-title":{"identifier":"deny-set-title","description":"Denies the set_title command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title"]}},"deny-set-title-bar-style":{"identifier":"deny-set-title-bar-style","description":"Denies the set_title_bar_style command without any pre-configured scope.","commands":{"allow":[],"deny":["set_title_bar_style"]}},"deny-set-visible-on-all-workspaces":{"identifier":"deny-set-visible-on-all-workspaces","description":"Denies the set_visible_on_all_workspaces command without any pre-configured scope.","commands":{"allow":[],"deny":["set_visible_on_all_workspaces"]}},"deny-show":{"identifier":"deny-show","description":"Denies the show command without any pre-configured scope.","commands":{"allow":[],"deny":["show"]}},"deny-start-dragging":{"identifier":"deny-start-dragging","description":"Denies the start_dragging command without any pre-configured scope.","commands":{"allow":[],"deny":["start_dragging"]}},"deny-start-resize-dragging":{"identifier":"deny-start-resize-dragging","description":"Denies the start_resize_dragging command without any pre-configured scope.","commands":{"allow":[],"deny":["start_resize_dragging"]}},"deny-theme":{"identifier":"deny-theme","description":"Denies the theme command without any pre-configured scope.","commands":{"allow":[],"deny":["theme"]}},"deny-title":{"identifier":"deny-title","description":"Denies the title command without any pre-configured scope.","commands":{"allow":[],"deny":["title"]}},"deny-toggle-maximize":{"identifier":"deny-toggle-maximize","description":"Denies the toggle_maximize command without any pre-configured scope.","commands":{"allow":[],"deny":["toggle_maximize"]}},"deny-unmaximize":{"identifier":"deny-unmaximize","description":"Denies the unmaximize command without any pre-configured scope.","commands":{"allow":[],"deny":["unmaximize"]}},"deny-unminimize":{"identifier":"deny-unminimize","description":"Denies the unminimize command without any pre-configured scope.","commands":{"allow":[],"deny":["unminimize"]}}},"permission_sets":{},"global_scope_schema":null},"dialog":{"default_permission":{"identifier":"default","description":"This permission set configures the types of dialogs\navailable from the dialog plugin.\n\n#### Granted Permissions\n\nAll dialog types are enabled.\n\n\n","permissions":["allow-message","allow-save","allow-open"]},"permissions":{"allow-ask":{"identifier":"allow-ask","description":"Enables the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)","commands":{"allow":["message"],"deny":[]}},"allow-confirm":{"identifier":"allow-confirm","description":"Enables the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)","commands":{"allow":["message"],"deny":[]}},"allow-message":{"identifier":"allow-message","description":"Enables the message command without any pre-configured scope.","commands":{"allow":["message"],"deny":[]}},"allow-open":{"identifier":"allow-open","description":"Enables the open command without any pre-configured scope.","commands":{"allow":["open"],"deny":[]}},"allow-save":{"identifier":"allow-save","description":"Enables the save command without any pre-configured scope.","commands":{"allow":["save"],"deny":[]}},"deny-ask":{"identifier":"deny-ask","description":"Denies the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)","commands":{"allow":[],"deny":["message"]}},"deny-confirm":{"identifier":"deny-confirm","description":"Denies the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)","commands":{"allow":[],"deny":["message"]}},"deny-message":{"identifier":"deny-message","description":"Denies the message command without any pre-configured scope.","commands":{"allow":[],"deny":["message"]}},"deny-open":{"identifier":"deny-open","description":"Denies the open command without any pre-configured scope.","commands":{"allow":[],"deny":["open"]}},"deny-save":{"identifier":"deny-save","description":"Denies the save command without any pre-configured scope.","commands":{"allow":[],"deny":["save"]}}},"permission_sets":{},"global_scope_schema":null},"drag":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin","permissions":["allow-start-drag"]},"permissions":{"allow-start-drag":{"identifier":"allow-start-drag","description":"Enables the start_drag command without any pre-configured scope.","commands":{"allow":["start_drag"],"deny":[]}},"deny-start-drag":{"identifier":"deny-start-drag","description":"Denies the start_drag command without any pre-configured scope.","commands":{"allow":[],"deny":["start_drag"]}}},"permission_sets":{},"global_scope_schema":null},"notification":{"default_permission":{"identifier":"default","description":"This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n","permissions":["allow-is-permission-granted","allow-request-permission","allow-notify","allow-register-action-types","allow-register-listener","allow-cancel","allow-get-pending","allow-remove-active","allow-get-active","allow-check-permissions","allow-show","allow-batch","allow-list-channels","allow-delete-channel","allow-create-channel","allow-permission-state"]},"permissions":{"allow-batch":{"identifier":"allow-batch","description":"Enables the batch command without any pre-configured scope.","commands":{"allow":["batch"],"deny":[]}},"allow-cancel":{"identifier":"allow-cancel","description":"Enables the cancel command without any pre-configured scope.","commands":{"allow":["cancel"],"deny":[]}},"allow-check-permissions":{"identifier":"allow-check-permissions","description":"Enables the check_permissions command without any pre-configured scope.","commands":{"allow":["check_permissions"],"deny":[]}},"allow-create-channel":{"identifier":"allow-create-channel","description":"Enables the create_channel command without any pre-configured scope.","commands":{"allow":["create_channel"],"deny":[]}},"allow-delete-channel":{"identifier":"allow-delete-channel","description":"Enables the delete_channel command without any pre-configured scope.","commands":{"allow":["delete_channel"],"deny":[]}},"allow-get-active":{"identifier":"allow-get-active","description":"Enables the get_active command without any pre-configured scope.","commands":{"allow":["get_active"],"deny":[]}},"allow-get-pending":{"identifier":"allow-get-pending","description":"Enables the get_pending command without any pre-configured scope.","commands":{"allow":["get_pending"],"deny":[]}},"allow-is-permission-granted":{"identifier":"allow-is-permission-granted","description":"Enables the is_permission_granted command without any pre-configured scope.","commands":{"allow":["is_permission_granted"],"deny":[]}},"allow-list-channels":{"identifier":"allow-list-channels","description":"Enables the list_channels command without any pre-configured scope.","commands":{"allow":["list_channels"],"deny":[]}},"allow-notify":{"identifier":"allow-notify","description":"Enables the notify command without any pre-configured scope.","commands":{"allow":["notify"],"deny":[]}},"allow-permission-state":{"identifier":"allow-permission-state","description":"Enables the permission_state command without any pre-configured scope.","commands":{"allow":["permission_state"],"deny":[]}},"allow-register-action-types":{"identifier":"allow-register-action-types","description":"Enables the register_action_types command without any pre-configured scope.","commands":{"allow":["register_action_types"],"deny":[]}},"allow-register-listener":{"identifier":"allow-register-listener","description":"Enables the register_listener command without any pre-configured scope.","commands":{"allow":["register_listener"],"deny":[]}},"allow-remove-active":{"identifier":"allow-remove-active","description":"Enables the remove_active command without any pre-configured scope.","commands":{"allow":["remove_active"],"deny":[]}},"allow-request-permission":{"identifier":"allow-request-permission","description":"Enables the request_permission command without any pre-configured scope.","commands":{"allow":["request_permission"],"deny":[]}},"allow-show":{"identifier":"allow-show","description":"Enables the show command without any pre-configured scope.","commands":{"allow":["show"],"deny":[]}},"deny-batch":{"identifier":"deny-batch","description":"Denies the batch command without any pre-configured scope.","commands":{"allow":[],"deny":["batch"]}},"deny-cancel":{"identifier":"deny-cancel","description":"Denies the cancel command without any pre-configured scope.","commands":{"allow":[],"deny":["cancel"]}},"deny-check-permissions":{"identifier":"deny-check-permissions","description":"Denies the check_permissions command without any pre-configured scope.","commands":{"allow":[],"deny":["check_permissions"]}},"deny-create-channel":{"identifier":"deny-create-channel","description":"Denies the create_channel command without any pre-configured scope.","commands":{"allow":[],"deny":["create_channel"]}},"deny-delete-channel":{"identifier":"deny-delete-channel","description":"Denies the delete_channel command without any pre-configured scope.","commands":{"allow":[],"deny":["delete_channel"]}},"deny-get-active":{"identifier":"deny-get-active","description":"Denies the get_active command without any pre-configured scope.","commands":{"allow":[],"deny":["get_active"]}},"deny-get-pending":{"identifier":"deny-get-pending","description":"Denies the get_pending command without any pre-configured scope.","commands":{"allow":[],"deny":["get_pending"]}},"deny-is-permission-granted":{"identifier":"deny-is-permission-granted","description":"Denies the is_permission_granted command without any pre-configured scope.","commands":{"allow":[],"deny":["is_permission_granted"]}},"deny-list-channels":{"identifier":"deny-list-channels","description":"Denies the list_channels command without any pre-configured scope.","commands":{"allow":[],"deny":["list_channels"]}},"deny-notify":{"identifier":"deny-notify","description":"Denies the notify command without any pre-configured scope.","commands":{"allow":[],"deny":["notify"]}},"deny-permission-state":{"identifier":"deny-permission-state","description":"Denies the permission_state command without any pre-configured scope.","commands":{"allow":[],"deny":["permission_state"]}},"deny-register-action-types":{"identifier":"deny-register-action-types","description":"Denies the register_action_types command without any pre-configured scope.","commands":{"allow":[],"deny":["register_action_types"]}},"deny-register-listener":{"identifier":"deny-register-listener","description":"Denies the register_listener command without any pre-configured scope.","commands":{"allow":[],"deny":["register_listener"]}},"deny-remove-active":{"identifier":"deny-remove-active","description":"Denies the remove_active command without any pre-configured scope.","commands":{"allow":[],"deny":["remove_active"]}},"deny-request-permission":{"identifier":"deny-request-permission","description":"Denies the request_permission command without any pre-configured scope.","commands":{"allow":[],"deny":["request_permission"]}},"deny-show":{"identifier":"deny-show","description":"Denies the show command without any pre-configured scope.","commands":{"allow":[],"deny":["show"]}}},"permission_sets":{},"global_scope_schema":null}}
\ No newline at end of file
diff --git a/src-tauri/gen/schemas/capabilities.json b/src-tauri/gen/schemas/capabilities.json
index b25b61a..6124d74 100644
--- a/src-tauri/gen/schemas/capabilities.json
+++ b/src-tauri/gen/schemas/capabilities.json
@@ -1 +1 @@
-{"default":{"identifier":"default","description":"Eldrun default capabilities — commands and window management","local":true,"windows":["main","detached-*"],"permissions":["core:default","core:window:allow-minimize","core:window:allow-toggle-maximize","core:window:allow-close","core:window:allow-destroy","core:window:allow-start-dragging","core:window:allow-set-position","core:event:allow-emit","core:event:allow-emit-to","core:event:allow-listen","core:event:allow-unlisten","core:webview:allow-create-webview-window","dialog:default"]}}
\ No newline at end of file
+{"default":{"identifier":"default","description":"Eldrun default capabilities — commands and window management","local":true,"windows":["main","detached-*","present-*"],"permissions":["core:default","core:window:allow-minimize","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-toggle-maximize","core:window:allow-is-maximized","core:window:allow-close","core:window:allow-destroy","core:window:allow-start-dragging","core:window:allow-set-position","core:window:allow-set-size","core:window:allow-current-monitor","core:window:allow-set-fullscreen","core:event:allow-emit","core:event:allow-emit-to","core:event:allow-listen","core:event:allow-unlisten","core:webview:allow-create-webview-window","core:webview:allow-set-webview-zoom","dialog:default","drag:default","notification:default"]}}
\ No newline at end of file
diff --git a/src-tauri/gen/schemas/desktop-schema.json b/src-tauri/gen/schemas/desktop-schema.json
index 24c9001..2a6652b 100644
--- a/src-tauri/gen/schemas/desktop-schema.json
+++ b/src-tauri/gen/schemas/desktop-schema.json
@@ -2257,6 +2257,222 @@
           "type": "string",
           "const": "dialog:deny-save",
           "markdownDescription": "Denies the save command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin\n#### This default permission set includes:\n\n- `allow-start-drag`",
+          "type": "string",
+          "const": "drag:default",
+          "markdownDescription": "Default permissions for the plugin\n#### This default permission set includes:\n\n- `allow-start-drag`"
+        },
+        {
+          "description": "Enables the start_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "drag:allow-start-drag",
+          "markdownDescription": "Enables the start_drag command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the start_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "drag:deny-start-drag",
+          "markdownDescription": "Denies the start_drag command without any pre-configured scope."
+        },
+        {
+          "description": "This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n\n#### This default permission set includes:\n\n- `allow-is-permission-granted`\n- `allow-request-permission`\n- `allow-notify`\n- `allow-register-action-types`\n- `allow-register-listener`\n- `allow-cancel`\n- `allow-get-pending`\n- `allow-remove-active`\n- `allow-get-active`\n- `allow-check-permissions`\n- `allow-show`\n- `allow-batch`\n- `allow-list-channels`\n- `allow-delete-channel`\n- `allow-create-channel`\n- `allow-permission-state`",
+          "type": "string",
+          "const": "notification:default",
+          "markdownDescription": "This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n\n#### This default permission set includes:\n\n- `allow-is-permission-granted`\n- `allow-request-permission`\n- `allow-notify`\n- `allow-register-action-types`\n- `allow-register-listener`\n- `allow-cancel`\n- `allow-get-pending`\n- `allow-remove-active`\n- `allow-get-active`\n- `allow-check-permissions`\n- `allow-show`\n- `allow-batch`\n- `allow-list-channels`\n- `allow-delete-channel`\n- `allow-create-channel`\n- `allow-permission-state`"
+        },
+        {
+          "description": "Enables the batch command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-batch",
+          "markdownDescription": "Enables the batch command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the cancel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-cancel",
+          "markdownDescription": "Enables the cancel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the check_permissions command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-check-permissions",
+          "markdownDescription": "Enables the check_permissions command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-create-channel",
+          "markdownDescription": "Enables the create_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the delete_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-delete-channel",
+          "markdownDescription": "Enables the delete_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-get-active",
+          "markdownDescription": "Enables the get_active command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_pending command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-get-pending",
+          "markdownDescription": "Enables the get_pending command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_permission_granted command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-is-permission-granted",
+          "markdownDescription": "Enables the is_permission_granted command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the list_channels command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-list-channels",
+          "markdownDescription": "Enables the list_channels command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the notify command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-notify",
+          "markdownDescription": "Enables the notify command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the permission_state command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-permission-state",
+          "markdownDescription": "Enables the permission_state command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_action_types command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-register-action-types",
+          "markdownDescription": "Enables the register_action_types command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-remove-active",
+          "markdownDescription": "Enables the remove_active command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the request_permission command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-request-permission",
+          "markdownDescription": "Enables the request_permission command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-show",
+          "markdownDescription": "Enables the show command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the batch command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-batch",
+          "markdownDescription": "Denies the batch command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the cancel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-cancel",
+          "markdownDescription": "Denies the cancel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the check_permissions command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-check-permissions",
+          "markdownDescription": "Denies the check_permissions command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-create-channel",
+          "markdownDescription": "Denies the create_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the delete_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-delete-channel",
+          "markdownDescription": "Denies the delete_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-get-active",
+          "markdownDescription": "Denies the get_active command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_pending command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-get-pending",
+          "markdownDescription": "Denies the get_pending command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_permission_granted command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-is-permission-granted",
+          "markdownDescription": "Denies the is_permission_granted command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the list_channels command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-list-channels",
+          "markdownDescription": "Denies the list_channels command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the notify command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-notify",
+          "markdownDescription": "Denies the notify command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the permission_state command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-permission-state",
+          "markdownDescription": "Denies the permission_state command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_action_types command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-register-action-types",
+          "markdownDescription": "Denies the register_action_types command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-remove-active",
+          "markdownDescription": "Denies the remove_active command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the request_permission command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-request-permission",
+          "markdownDescription": "Denies the request_permission command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-show",
+          "markdownDescription": "Denies the show command without any pre-configured scope."
         }
       ]
     },
diff --git a/src-tauri/gen/schemas/linux-schema.json b/src-tauri/gen/schemas/linux-schema.json
index 24c9001..2a6652b 100644
--- a/src-tauri/gen/schemas/linux-schema.json
+++ b/src-tauri/gen/schemas/linux-schema.json
@@ -2257,6 +2257,222 @@
           "type": "string",
           "const": "dialog:deny-save",
           "markdownDescription": "Denies the save command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin\n#### This default permission set includes:\n\n- `allow-start-drag`",
+          "type": "string",
+          "const": "drag:default",
+          "markdownDescription": "Default permissions for the plugin\n#### This default permission set includes:\n\n- `allow-start-drag`"
+        },
+        {
+          "description": "Enables the start_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "drag:allow-start-drag",
+          "markdownDescription": "Enables the start_drag command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the start_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "drag:deny-start-drag",
+          "markdownDescription": "Denies the start_drag command without any pre-configured scope."
+        },
+        {
+          "description": "This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n\n#### This default permission set includes:\n\n- `allow-is-permission-granted`\n- `allow-request-permission`\n- `allow-notify`\n- `allow-register-action-types`\n- `allow-register-listener`\n- `allow-cancel`\n- `allow-get-pending`\n- `allow-remove-active`\n- `allow-get-active`\n- `allow-check-permissions`\n- `allow-show`\n- `allow-batch`\n- `allow-list-channels`\n- `allow-delete-channel`\n- `allow-create-channel`\n- `allow-permission-state`",
+          "type": "string",
+          "const": "notification:default",
+          "markdownDescription": "This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n\n#### This default permission set includes:\n\n- `allow-is-permission-granted`\n- `allow-request-permission`\n- `allow-notify`\n- `allow-register-action-types`\n- `allow-register-listener`\n- `allow-cancel`\n- `allow-get-pending`\n- `allow-remove-active`\n- `allow-get-active`\n- `allow-check-permissions`\n- `allow-show`\n- `allow-batch`\n- `allow-list-channels`\n- `allow-delete-channel`\n- `allow-create-channel`\n- `allow-permission-state`"
+        },
+        {
+          "description": "Enables the batch command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-batch",
+          "markdownDescription": "Enables the batch command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the cancel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-cancel",
+          "markdownDescription": "Enables the cancel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the check_permissions command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-check-permissions",
+          "markdownDescription": "Enables the check_permissions command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-create-channel",
+          "markdownDescription": "Enables the create_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the delete_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-delete-channel",
+          "markdownDescription": "Enables the delete_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-get-active",
+          "markdownDescription": "Enables the get_active command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_pending command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-get-pending",
+          "markdownDescription": "Enables the get_pending command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_permission_granted command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-is-permission-granted",
+          "markdownDescription": "Enables the is_permission_granted command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the list_channels command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-list-channels",
+          "markdownDescription": "Enables the list_channels command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the notify command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-notify",
+          "markdownDescription": "Enables the notify command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the permission_state command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-permission-state",
+          "markdownDescription": "Enables the permission_state command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_action_types command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-register-action-types",
+          "markdownDescription": "Enables the register_action_types command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-remove-active",
+          "markdownDescription": "Enables the remove_active command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the request_permission command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-request-permission",
+          "markdownDescription": "Enables the request_permission command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-show",
+          "markdownDescription": "Enables the show command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the batch command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-batch",
+          "markdownDescription": "Denies the batch command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the cancel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-cancel",
+          "markdownDescription": "Denies the cancel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the check_permissions command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-check-permissions",
+          "markdownDescription": "Denies the check_permissions command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-create-channel",
+          "markdownDescription": "Denies the create_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the delete_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-delete-channel",
+          "markdownDescription": "Denies the delete_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-get-active",
+          "markdownDescription": "Denies the get_active command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_pending command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-get-pending",
+          "markdownDescription": "Denies the get_pending command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_permission_granted command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-is-permission-granted",
+          "markdownDescription": "Denies the is_permission_granted command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the list_channels command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-list-channels",
+          "markdownDescription": "Denies the list_channels command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the notify command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-notify",
+          "markdownDescription": "Denies the notify command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the permission_state command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-permission-state",
+          "markdownDescription": "Denies the permission_state command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_action_types command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-register-action-types",
+          "markdownDescription": "Denies the register_action_types command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-remove-active",
+          "markdownDescription": "Denies the remove_active command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the request_permission command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-request-permission",
+          "markdownDescription": "Denies the request_permission command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-show",
+          "markdownDescription": "Denies the show command without any pre-configured scope."
         }
       ]
     },
diff --git a/src-tauri/gen/schemas/windows-schema.json b/src-tauri/gen/schemas/windows-schema.json
new file mode 100644
index 0000000..2a6652b
--- /dev/null
+++ b/src-tauri/gen/schemas/windows-schema.json
@@ -0,0 +1,2574 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "CapabilityFile",
+  "description": "Capability formats accepted in a capability file.",
+  "anyOf": [
+    {
+      "description": "A single capability.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/Capability"
+        }
+      ]
+    },
+    {
+      "description": "A list of capabilities.",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Capability"
+      }
+    },
+    {
+      "description": "A list of capabilities.",
+      "type": "object",
+      "required": [
+        "capabilities"
+      ],
+      "properties": {
+        "capabilities": {
+          "description": "The list of capabilities.",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Capability"
+          }
+        }
+      }
+    }
+  ],
+  "definitions": {
+    "Capability": {
+      "description": "A grouping and boundary mechanism developers can use to isolate access to the IPC layer.\n\nIt controls application windows' and webviews' fine grained access to the Tauri core, application, or plugin commands. If a webview or its window is not matching any capability then it has no access to the IPC layer at all.\n\nThis can be done to create groups of windows, based on their required system access, which can reduce impact of frontend vulnerabilities in less privileged windows. Windows can be added to a capability by exact name (e.g. `main-window`) or glob patterns like `*` or `admin-*`. A Window can have none, one, or multiple associated capabilities.\n\n## Example\n\n```json { \"identifier\": \"main-user-files-write\", \"description\": \"This capability allows the `main` window on macOS and Windows access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.\", \"windows\": [ \"main\" ], \"permissions\": [ \"core:default\", \"dialog:open\", { \"identifier\": \"fs:allow-write-text-file\", \"allow\": [{ \"path\": \"$HOME/test.txt\" }] }, ], \"platforms\": [\"macOS\",\"windows\"] } ```",
+      "type": "object",
+      "required": [
+        "identifier",
+        "permissions"
+      ],
+      "properties": {
+        "identifier": {
+          "description": "Identifier of the capability.\n\n## Example\n\n`main-user-files-write`",
+          "type": "string"
+        },
+        "description": {
+          "description": "Description of what the capability is intended to allow on associated windows.\n\nIt should contain a description of what the grouped permissions should allow.\n\n## Example\n\nThis capability allows the `main` window access to `filesystem` write related commands and `dialog` commands to enable programmatic access to files selected by the user.",
+          "default": "",
+          "type": "string"
+        },
+        "remote": {
+          "description": "Configure remote URLs that can use the capability permissions.\n\nThis setting is optional and defaults to not being set, as our default use case is that the content is served from our local application.\n\n:::caution Make sure you understand the security implications of providing remote sources with local system access. :::\n\n## Example\n\n```json { \"urls\": [\"https://*.mydomain.dev\"] } ```",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/CapabilityRemote"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "local": {
+          "description": "Whether this capability is enabled for local app URLs or not. Defaults to `true`.",
+          "default": true,
+          "type": "boolean"
+        },
+        "windows": {
+          "description": "List of windows that are affected by this capability. Can be a glob pattern.\n\nIf a window label matches any of the patterns in this list, the capability will be enabled on all the webviews of that window, regardless of the value of [`Self::webviews`].\n\nOn multiwebview windows, prefer specifying [`Self::webviews`] and omitting [`Self::windows`] for a fine grained access control.\n\n## Example\n\n`[\"main\"]`",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "webviews": {
+          "description": "List of webviews that are affected by this capability. Can be a glob pattern.\n\nThe capability will be enabled on all the webviews whose label matches any of the patterns in this list, regardless of whether the webview's window label matches a pattern in [`Self::windows`].\n\n## Example\n\n`[\"sub-webview-one\", \"sub-webview-two\"]`",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "permissions": {
+          "description": "List of permissions attached to this capability.\n\nMust include the plugin name as prefix in the form of `${plugin-name}:${permission-name}`. For commands directly implemented in the application itself only `${permission-name}` is required.\n\n## Example\n\n```json [ \"core:default\", \"shell:allow-open\", \"dialog:open\", { \"identifier\": \"fs:allow-write-text-file\", \"allow\": [{ \"path\": \"$HOME/test.txt\" }] } ] ```",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/PermissionEntry"
+          },
+          "uniqueItems": true
+        },
+        "platforms": {
+          "description": "Limit which target platforms this capability applies to.\n\nBy default all platforms are targeted.\n\n## Example\n\n`[\"macOS\",\"windows\"]`",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/Target"
+          }
+        }
+      }
+    },
+    "CapabilityRemote": {
+      "description": "Configuration for remote URLs that are associated with the capability.",
+      "type": "object",
+      "required": [
+        "urls"
+      ],
+      "properties": {
+        "urls": {
+          "description": "Remote domains this capability refers to using the [URLPattern standard](https://urlpattern.spec.whatwg.org/).\n\n## Examples\n\n- \"https://*.mydomain.dev\": allows subdomains of mydomain.dev - \"https://mydomain.dev/api/*\": allows any subpath of mydomain.dev/api",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "PermissionEntry": {
+      "description": "An entry for a permission value in a [`Capability`] can be either a raw permission [`Identifier`] or an object that references a permission and extends its scope.",
+      "anyOf": [
+        {
+          "description": "Reference a permission or permission set by identifier.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Identifier"
+            }
+          ]
+        },
+        {
+          "description": "Reference a permission or permission set by identifier and extends its scope.",
+          "type": "object",
+          "allOf": [
+            {
+              "properties": {
+                "identifier": {
+                  "description": "Identifier of the permission or permission set.",
+                  "allOf": [
+                    {
+                      "$ref": "#/definitions/Identifier"
+                    }
+                  ]
+                },
+                "allow": {
+                  "description": "Data that defines what is allowed by the scope.",
+                  "type": [
+                    "array",
+                    "null"
+                  ],
+                  "items": {
+                    "$ref": "#/definitions/Value"
+                  }
+                },
+                "deny": {
+                  "description": "Data that defines what is denied by the scope. This should be prioritized by validation logic.",
+                  "type": [
+                    "array",
+                    "null"
+                  ],
+                  "items": {
+                    "$ref": "#/definitions/Value"
+                  }
+                }
+              }
+            }
+          ],
+          "required": [
+            "identifier"
+          ]
+        }
+      ]
+    },
+    "Identifier": {
+      "description": "Permission identifier",
+      "oneOf": [
+        {
+          "description": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`",
+          "type": "string",
+          "const": "core:default",
+          "markdownDescription": "Default core plugins set.\n#### This default permission set includes:\n\n- `core:path:default`\n- `core:event:default`\n- `core:window:default`\n- `core:webview:default`\n- `core:app:default`\n- `core:image:default`\n- `core:resources:default`\n- `core:menu:default`\n- `core:tray:default`"
+        },
+        {
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`\n- `allow-supports-multiple-windows`",
+          "type": "string",
+          "const": "core:app:default",
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-version`\n- `allow-name`\n- `allow-tauri-version`\n- `allow-identifier`\n- `allow-bundle-type`\n- `allow-register-listener`\n- `allow-remove-listener`\n- `allow-supports-multiple-windows`"
+        },
+        {
+          "description": "Enables the app_hide command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-app-hide",
+          "markdownDescription": "Enables the app_hide command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the app_show command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-app-show",
+          "markdownDescription": "Enables the app_show command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the bundle_type command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-bundle-type",
+          "markdownDescription": "Enables the bundle_type command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the default_window_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-default-window-icon",
+          "markdownDescription": "Enables the default_window_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the fetch_data_store_identifiers command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-fetch-data-store-identifiers",
+          "markdownDescription": "Enables the fetch_data_store_identifiers command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the identifier command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-identifier",
+          "markdownDescription": "Enables the identifier command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the name command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-name",
+          "markdownDescription": "Enables the name command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_data_store command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-remove-data-store",
+          "markdownDescription": "Enables the remove_data_store command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-remove-listener",
+          "markdownDescription": "Enables the remove_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_app_theme command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-set-app-theme",
+          "markdownDescription": "Enables the set_app_theme command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_dock_visibility command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-set-dock-visibility",
+          "markdownDescription": "Enables the set_dock_visibility command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the supports_multiple_windows command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-supports-multiple-windows",
+          "markdownDescription": "Enables the supports_multiple_windows command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the tauri_version command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-tauri-version",
+          "markdownDescription": "Enables the tauri_version command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the version command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:allow-version",
+          "markdownDescription": "Enables the version command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the app_hide command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-app-hide",
+          "markdownDescription": "Denies the app_hide command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the app_show command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-app-show",
+          "markdownDescription": "Denies the app_show command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the bundle_type command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-bundle-type",
+          "markdownDescription": "Denies the bundle_type command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the default_window_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-default-window-icon",
+          "markdownDescription": "Denies the default_window_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the fetch_data_store_identifiers command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-fetch-data-store-identifiers",
+          "markdownDescription": "Denies the fetch_data_store_identifiers command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the identifier command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-identifier",
+          "markdownDescription": "Denies the identifier command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the name command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-name",
+          "markdownDescription": "Denies the name command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_data_store command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-remove-data-store",
+          "markdownDescription": "Denies the remove_data_store command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-remove-listener",
+          "markdownDescription": "Denies the remove_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_app_theme command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-set-app-theme",
+          "markdownDescription": "Denies the set_app_theme command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_dock_visibility command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-set-dock-visibility",
+          "markdownDescription": "Denies the set_dock_visibility command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the supports_multiple_windows command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-supports-multiple-windows",
+          "markdownDescription": "Denies the supports_multiple_windows command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the tauri_version command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-tauri-version",
+          "markdownDescription": "Denies the tauri_version command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the version command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:app:deny-version",
+          "markdownDescription": "Denies the version command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-listen`\n- `allow-unlisten`\n- `allow-emit`\n- `allow-emit-to`",
+          "type": "string",
+          "const": "core:event:default",
+          "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-listen`\n- `allow-unlisten`\n- `allow-emit`\n- `allow-emit-to`"
+        },
+        {
+          "description": "Enables the emit command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:allow-emit",
+          "markdownDescription": "Enables the emit command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the emit_to command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:allow-emit-to",
+          "markdownDescription": "Enables the emit_to command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the listen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:allow-listen",
+          "markdownDescription": "Enables the listen command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the unlisten command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:allow-unlisten",
+          "markdownDescription": "Enables the unlisten command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the emit command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:deny-emit",
+          "markdownDescription": "Denies the emit command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the emit_to command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:deny-emit-to",
+          "markdownDescription": "Denies the emit_to command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the listen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:deny-listen",
+          "markdownDescription": "Denies the listen command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the unlisten command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:event:deny-unlisten",
+          "markdownDescription": "Denies the unlisten command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-from-bytes`\n- `allow-from-path`\n- `allow-rgba`\n- `allow-size`",
+          "type": "string",
+          "const": "core:image:default",
+          "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-from-bytes`\n- `allow-from-path`\n- `allow-rgba`\n- `allow-size`"
+        },
+        {
+          "description": "Enables the from_bytes command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:allow-from-bytes",
+          "markdownDescription": "Enables the from_bytes command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the from_path command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:allow-from-path",
+          "markdownDescription": "Enables the from_path command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the new command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:allow-new",
+          "markdownDescription": "Enables the new command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the rgba command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:allow-rgba",
+          "markdownDescription": "Enables the rgba command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:allow-size",
+          "markdownDescription": "Enables the size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the from_bytes command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:deny-from-bytes",
+          "markdownDescription": "Denies the from_bytes command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the from_path command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:deny-from-path",
+          "markdownDescription": "Denies the from_path command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the new command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:deny-new",
+          "markdownDescription": "Denies the new command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the rgba command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:deny-rgba",
+          "markdownDescription": "Denies the rgba command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:image:deny-size",
+          "markdownDescription": "Denies the size command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-append`\n- `allow-prepend`\n- `allow-insert`\n- `allow-remove`\n- `allow-remove-at`\n- `allow-items`\n- `allow-get`\n- `allow-popup`\n- `allow-create-default`\n- `allow-set-as-app-menu`\n- `allow-set-as-window-menu`\n- `allow-text`\n- `allow-set-text`\n- `allow-is-enabled`\n- `allow-set-enabled`\n- `allow-set-accelerator`\n- `allow-set-as-windows-menu-for-nsapp`\n- `allow-set-as-help-menu-for-nsapp`\n- `allow-is-checked`\n- `allow-set-checked`\n- `allow-set-icon`",
+          "type": "string",
+          "const": "core:menu:default",
+          "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-append`\n- `allow-prepend`\n- `allow-insert`\n- `allow-remove`\n- `allow-remove-at`\n- `allow-items`\n- `allow-get`\n- `allow-popup`\n- `allow-create-default`\n- `allow-set-as-app-menu`\n- `allow-set-as-window-menu`\n- `allow-text`\n- `allow-set-text`\n- `allow-is-enabled`\n- `allow-set-enabled`\n- `allow-set-accelerator`\n- `allow-set-as-windows-menu-for-nsapp`\n- `allow-set-as-help-menu-for-nsapp`\n- `allow-is-checked`\n- `allow-set-checked`\n- `allow-set-icon`"
+        },
+        {
+          "description": "Enables the append command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-append",
+          "markdownDescription": "Enables the append command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create_default command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-create-default",
+          "markdownDescription": "Enables the create_default command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-get",
+          "markdownDescription": "Enables the get command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the insert command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-insert",
+          "markdownDescription": "Enables the insert command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_checked command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-is-checked",
+          "markdownDescription": "Enables the is_checked command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-is-enabled",
+          "markdownDescription": "Enables the is_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the items command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-items",
+          "markdownDescription": "Enables the items command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the new command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-new",
+          "markdownDescription": "Enables the new command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the popup command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-popup",
+          "markdownDescription": "Enables the popup command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the prepend command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-prepend",
+          "markdownDescription": "Enables the prepend command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-remove",
+          "markdownDescription": "Enables the remove command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_at command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-remove-at",
+          "markdownDescription": "Enables the remove_at command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_accelerator command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-accelerator",
+          "markdownDescription": "Enables the set_accelerator command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_as_app_menu command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-as-app-menu",
+          "markdownDescription": "Enables the set_as_app_menu command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_as_help_menu_for_nsapp command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-as-help-menu-for-nsapp",
+          "markdownDescription": "Enables the set_as_help_menu_for_nsapp command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_as_window_menu command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-as-window-menu",
+          "markdownDescription": "Enables the set_as_window_menu command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-as-windows-menu-for-nsapp",
+          "markdownDescription": "Enables the set_as_windows_menu_for_nsapp command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_checked command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-checked",
+          "markdownDescription": "Enables the set_checked command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-enabled",
+          "markdownDescription": "Enables the set_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-icon",
+          "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_text command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-set-text",
+          "markdownDescription": "Enables the set_text command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the text command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:allow-text",
+          "markdownDescription": "Enables the text command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the append command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-append",
+          "markdownDescription": "Denies the append command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create_default command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-create-default",
+          "markdownDescription": "Denies the create_default command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-get",
+          "markdownDescription": "Denies the get command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the insert command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-insert",
+          "markdownDescription": "Denies the insert command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_checked command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-is-checked",
+          "markdownDescription": "Denies the is_checked command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-is-enabled",
+          "markdownDescription": "Denies the is_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the items command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-items",
+          "markdownDescription": "Denies the items command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the new command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-new",
+          "markdownDescription": "Denies the new command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the popup command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-popup",
+          "markdownDescription": "Denies the popup command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the prepend command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-prepend",
+          "markdownDescription": "Denies the prepend command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-remove",
+          "markdownDescription": "Denies the remove command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_at command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-remove-at",
+          "markdownDescription": "Denies the remove_at command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_accelerator command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-accelerator",
+          "markdownDescription": "Denies the set_accelerator command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_as_app_menu command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-as-app-menu",
+          "markdownDescription": "Denies the set_as_app_menu command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_as_help_menu_for_nsapp command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-as-help-menu-for-nsapp",
+          "markdownDescription": "Denies the set_as_help_menu_for_nsapp command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_as_window_menu command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-as-window-menu",
+          "markdownDescription": "Denies the set_as_window_menu command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-as-windows-menu-for-nsapp",
+          "markdownDescription": "Denies the set_as_windows_menu_for_nsapp command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_checked command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-checked",
+          "markdownDescription": "Denies the set_checked command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-enabled",
+          "markdownDescription": "Denies the set_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-icon",
+          "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_text command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-set-text",
+          "markdownDescription": "Denies the set_text command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the text command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:menu:deny-text",
+          "markdownDescription": "Denies the text command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-resolve-directory`\n- `allow-resolve`\n- `allow-normalize`\n- `allow-join`\n- `allow-dirname`\n- `allow-extname`\n- `allow-basename`\n- `allow-is-absolute`",
+          "type": "string",
+          "const": "core:path:default",
+          "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-resolve-directory`\n- `allow-resolve`\n- `allow-normalize`\n- `allow-join`\n- `allow-dirname`\n- `allow-extname`\n- `allow-basename`\n- `allow-is-absolute`"
+        },
+        {
+          "description": "Enables the basename command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-basename",
+          "markdownDescription": "Enables the basename command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the dirname command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-dirname",
+          "markdownDescription": "Enables the dirname command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the extname command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-extname",
+          "markdownDescription": "Enables the extname command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_absolute command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-is-absolute",
+          "markdownDescription": "Enables the is_absolute command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the join command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-join",
+          "markdownDescription": "Enables the join command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the normalize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-normalize",
+          "markdownDescription": "Enables the normalize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the resolve command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-resolve",
+          "markdownDescription": "Enables the resolve command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the resolve_directory command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:allow-resolve-directory",
+          "markdownDescription": "Enables the resolve_directory command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the basename command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-basename",
+          "markdownDescription": "Denies the basename command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the dirname command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-dirname",
+          "markdownDescription": "Denies the dirname command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the extname command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-extname",
+          "markdownDescription": "Denies the extname command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_absolute command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-is-absolute",
+          "markdownDescription": "Denies the is_absolute command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the join command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-join",
+          "markdownDescription": "Denies the join command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the normalize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-normalize",
+          "markdownDescription": "Denies the normalize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the resolve command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-resolve",
+          "markdownDescription": "Denies the resolve command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the resolve_directory command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:path:deny-resolve-directory",
+          "markdownDescription": "Denies the resolve_directory command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-close`",
+          "type": "string",
+          "const": "core:resources:default",
+          "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-close`"
+        },
+        {
+          "description": "Enables the close command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:resources:allow-close",
+          "markdownDescription": "Enables the close command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the close command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:resources:deny-close",
+          "markdownDescription": "Denies the close command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-get-by-id`\n- `allow-remove-by-id`\n- `allow-set-icon`\n- `allow-set-menu`\n- `allow-set-tooltip`\n- `allow-set-title`\n- `allow-set-visible`\n- `allow-set-temp-dir-path`\n- `allow-set-icon-as-template`\n- `allow-set-icon-with-as-template`\n- `allow-set-show-menu-on-left-click`",
+          "type": "string",
+          "const": "core:tray:default",
+          "markdownDescription": "Default permissions for the plugin, which enables all commands.\n#### This default permission set includes:\n\n- `allow-new`\n- `allow-get-by-id`\n- `allow-remove-by-id`\n- `allow-set-icon`\n- `allow-set-menu`\n- `allow-set-tooltip`\n- `allow-set-title`\n- `allow-set-visible`\n- `allow-set-temp-dir-path`\n- `allow-set-icon-as-template`\n- `allow-set-icon-with-as-template`\n- `allow-set-show-menu-on-left-click`"
+        },
+        {
+          "description": "Enables the get_by_id command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-get-by-id",
+          "markdownDescription": "Enables the get_by_id command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the new command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-new",
+          "markdownDescription": "Enables the new command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_by_id command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-remove-by-id",
+          "markdownDescription": "Enables the remove_by_id command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-icon",
+          "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_icon_as_template command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-icon-as-template",
+          "markdownDescription": "Enables the set_icon_as_template command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_icon_with_as_template command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-icon-with-as-template",
+          "markdownDescription": "Enables the set_icon_with_as_template command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_menu command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-menu",
+          "markdownDescription": "Enables the set_menu command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_show_menu_on_left_click command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-show-menu-on-left-click",
+          "markdownDescription": "Enables the set_show_menu_on_left_click command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_temp_dir_path command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-temp-dir-path",
+          "markdownDescription": "Enables the set_temp_dir_path command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_title command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-title",
+          "markdownDescription": "Enables the set_title command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_tooltip command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-tooltip",
+          "markdownDescription": "Enables the set_tooltip command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_visible command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:allow-set-visible",
+          "markdownDescription": "Enables the set_visible command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_by_id command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-get-by-id",
+          "markdownDescription": "Denies the get_by_id command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the new command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-new",
+          "markdownDescription": "Denies the new command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_by_id command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-remove-by-id",
+          "markdownDescription": "Denies the remove_by_id command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-icon",
+          "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_icon_as_template command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-icon-as-template",
+          "markdownDescription": "Denies the set_icon_as_template command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_icon_with_as_template command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-icon-with-as-template",
+          "markdownDescription": "Denies the set_icon_with_as_template command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_menu command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-menu",
+          "markdownDescription": "Denies the set_menu command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_show_menu_on_left_click command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-show-menu-on-left-click",
+          "markdownDescription": "Denies the set_show_menu_on_left_click command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_temp_dir_path command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-temp-dir-path",
+          "markdownDescription": "Denies the set_temp_dir_path command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_title command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-title",
+          "markdownDescription": "Denies the set_title command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_tooltip command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-tooltip",
+          "markdownDescription": "Denies the set_tooltip command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_visible command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:tray:deny-set-visible",
+          "markdownDescription": "Denies the set_visible command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-webviews`\n- `allow-webview-position`\n- `allow-webview-size`\n- `allow-internal-toggle-devtools`",
+          "type": "string",
+          "const": "core:webview:default",
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-webviews`\n- `allow-webview-position`\n- `allow-webview-size`\n- `allow-internal-toggle-devtools`"
+        },
+        {
+          "description": "Enables the clear_all_browsing_data command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-clear-all-browsing-data",
+          "markdownDescription": "Enables the clear_all_browsing_data command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create_webview command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-create-webview",
+          "markdownDescription": "Enables the create_webview command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create_webview_window command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-create-webview-window",
+          "markdownDescription": "Enables the create_webview_window command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_all_webviews command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-get-all-webviews",
+          "markdownDescription": "Enables the get_all_webviews command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the internal_toggle_devtools command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-internal-toggle-devtools",
+          "markdownDescription": "Enables the internal_toggle_devtools command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the print command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-print",
+          "markdownDescription": "Enables the print command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the reparent command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-reparent",
+          "markdownDescription": "Enables the reparent command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_webview_auto_resize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-set-webview-auto-resize",
+          "markdownDescription": "Enables the set_webview_auto_resize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_webview_background_color command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-set-webview-background-color",
+          "markdownDescription": "Enables the set_webview_background_color command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_webview_focus command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-set-webview-focus",
+          "markdownDescription": "Enables the set_webview_focus command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_webview_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-set-webview-position",
+          "markdownDescription": "Enables the set_webview_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_webview_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-set-webview-size",
+          "markdownDescription": "Enables the set_webview_size command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_webview_zoom command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-set-webview-zoom",
+          "markdownDescription": "Enables the set_webview_zoom command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the webview_close command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-webview-close",
+          "markdownDescription": "Enables the webview_close command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the webview_hide command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-webview-hide",
+          "markdownDescription": "Enables the webview_hide command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the webview_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-webview-position",
+          "markdownDescription": "Enables the webview_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the webview_show command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-webview-show",
+          "markdownDescription": "Enables the webview_show command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the webview_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:allow-webview-size",
+          "markdownDescription": "Enables the webview_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the clear_all_browsing_data command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-clear-all-browsing-data",
+          "markdownDescription": "Denies the clear_all_browsing_data command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create_webview command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-create-webview",
+          "markdownDescription": "Denies the create_webview command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create_webview_window command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-create-webview-window",
+          "markdownDescription": "Denies the create_webview_window command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_all_webviews command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-get-all-webviews",
+          "markdownDescription": "Denies the get_all_webviews command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the internal_toggle_devtools command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-internal-toggle-devtools",
+          "markdownDescription": "Denies the internal_toggle_devtools command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the print command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-print",
+          "markdownDescription": "Denies the print command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the reparent command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-reparent",
+          "markdownDescription": "Denies the reparent command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_webview_auto_resize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-set-webview-auto-resize",
+          "markdownDescription": "Denies the set_webview_auto_resize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_webview_background_color command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-set-webview-background-color",
+          "markdownDescription": "Denies the set_webview_background_color command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_webview_focus command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-set-webview-focus",
+          "markdownDescription": "Denies the set_webview_focus command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_webview_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-set-webview-position",
+          "markdownDescription": "Denies the set_webview_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_webview_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-set-webview-size",
+          "markdownDescription": "Denies the set_webview_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_webview_zoom command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-set-webview-zoom",
+          "markdownDescription": "Denies the set_webview_zoom command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the webview_close command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-webview-close",
+          "markdownDescription": "Denies the webview_close command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the webview_hide command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-webview-hide",
+          "markdownDescription": "Denies the webview_hide command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the webview_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-webview-position",
+          "markdownDescription": "Denies the webview_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the webview_show command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-webview-show",
+          "markdownDescription": "Denies the webview_show command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the webview_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:webview:deny-webview-size",
+          "markdownDescription": "Denies the webview_size command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-windows`\n- `allow-scale-factor`\n- `allow-inner-position`\n- `allow-outer-position`\n- `allow-inner-size`\n- `allow-outer-size`\n- `allow-is-fullscreen`\n- `allow-is-minimized`\n- `allow-is-maximized`\n- `allow-is-focused`\n- `allow-is-decorated`\n- `allow-is-resizable`\n- `allow-is-maximizable`\n- `allow-is-minimizable`\n- `allow-is-closable`\n- `allow-is-visible`\n- `allow-is-enabled`\n- `allow-title`\n- `allow-current-monitor`\n- `allow-primary-monitor`\n- `allow-monitor-from-point`\n- `allow-available-monitors`\n- `allow-cursor-position`\n- `allow-theme`\n- `allow-is-always-on-top`\n- `allow-activity-name`\n- `allow-scene-identifier`\n- `allow-internal-toggle-maximize`",
+          "type": "string",
+          "const": "core:window:default",
+          "markdownDescription": "Default permissions for the plugin.\n#### This default permission set includes:\n\n- `allow-get-all-windows`\n- `allow-scale-factor`\n- `allow-inner-position`\n- `allow-outer-position`\n- `allow-inner-size`\n- `allow-outer-size`\n- `allow-is-fullscreen`\n- `allow-is-minimized`\n- `allow-is-maximized`\n- `allow-is-focused`\n- `allow-is-decorated`\n- `allow-is-resizable`\n- `allow-is-maximizable`\n- `allow-is-minimizable`\n- `allow-is-closable`\n- `allow-is-visible`\n- `allow-is-enabled`\n- `allow-title`\n- `allow-current-monitor`\n- `allow-primary-monitor`\n- `allow-monitor-from-point`\n- `allow-available-monitors`\n- `allow-cursor-position`\n- `allow-theme`\n- `allow-is-always-on-top`\n- `allow-activity-name`\n- `allow-scene-identifier`\n- `allow-internal-toggle-maximize`"
+        },
+        {
+          "description": "Enables the activity_name command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-activity-name",
+          "markdownDescription": "Enables the activity_name command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the available_monitors command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-available-monitors",
+          "markdownDescription": "Enables the available_monitors command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the center command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-center",
+          "markdownDescription": "Enables the center command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the close command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-close",
+          "markdownDescription": "Enables the close command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-create",
+          "markdownDescription": "Enables the create command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the current_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-current-monitor",
+          "markdownDescription": "Enables the current_monitor command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the cursor_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-cursor-position",
+          "markdownDescription": "Enables the cursor_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the destroy command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-destroy",
+          "markdownDescription": "Enables the destroy command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_all_windows command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-get-all-windows",
+          "markdownDescription": "Enables the get_all_windows command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the hide command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-hide",
+          "markdownDescription": "Enables the hide command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the inner_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-inner-position",
+          "markdownDescription": "Enables the inner_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the inner_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-inner-size",
+          "markdownDescription": "Enables the inner_size command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the internal_toggle_maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-internal-toggle-maximize",
+          "markdownDescription": "Enables the internal_toggle_maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_always_on_top command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-always-on-top",
+          "markdownDescription": "Enables the is_always_on_top command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_closable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-closable",
+          "markdownDescription": "Enables the is_closable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_decorated command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-decorated",
+          "markdownDescription": "Enables the is_decorated command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-enabled",
+          "markdownDescription": "Enables the is_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_focused command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-focused",
+          "markdownDescription": "Enables the is_focused command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_fullscreen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-fullscreen",
+          "markdownDescription": "Enables the is_fullscreen command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_maximizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-maximizable",
+          "markdownDescription": "Enables the is_maximizable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_maximized command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-maximized",
+          "markdownDescription": "Enables the is_maximized command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_minimizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-minimizable",
+          "markdownDescription": "Enables the is_minimizable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_minimized command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-minimized",
+          "markdownDescription": "Enables the is_minimized command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_resizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-resizable",
+          "markdownDescription": "Enables the is_resizable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_visible command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-is-visible",
+          "markdownDescription": "Enables the is_visible command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-maximize",
+          "markdownDescription": "Enables the maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the minimize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-minimize",
+          "markdownDescription": "Enables the minimize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the monitor_from_point command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-monitor-from-point",
+          "markdownDescription": "Enables the monitor_from_point command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the outer_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-outer-position",
+          "markdownDescription": "Enables the outer_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the outer_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-outer-size",
+          "markdownDescription": "Enables the outer_size command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the primary_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-primary-monitor",
+          "markdownDescription": "Enables the primary_monitor command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the request_user_attention command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-request-user-attention",
+          "markdownDescription": "Enables the request_user_attention command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the scale_factor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-scale-factor",
+          "markdownDescription": "Enables the scale_factor command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the scene_identifier command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-scene-identifier",
+          "markdownDescription": "Enables the scene_identifier command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_always_on_bottom command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-always-on-bottom",
+          "markdownDescription": "Enables the set_always_on_bottom command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_always_on_top command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-always-on-top",
+          "markdownDescription": "Enables the set_always_on_top command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_background_color command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-background-color",
+          "markdownDescription": "Enables the set_background_color command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_badge_count command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-badge-count",
+          "markdownDescription": "Enables the set_badge_count command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_badge_label command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-badge-label",
+          "markdownDescription": "Enables the set_badge_label command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_closable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-closable",
+          "markdownDescription": "Enables the set_closable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_content_protected command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-content-protected",
+          "markdownDescription": "Enables the set_content_protected command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_cursor_grab command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-cursor-grab",
+          "markdownDescription": "Enables the set_cursor_grab command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_cursor_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-cursor-icon",
+          "markdownDescription": "Enables the set_cursor_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_cursor_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-cursor-position",
+          "markdownDescription": "Enables the set_cursor_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_cursor_visible command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-cursor-visible",
+          "markdownDescription": "Enables the set_cursor_visible command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_decorations command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-decorations",
+          "markdownDescription": "Enables the set_decorations command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_effects command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-effects",
+          "markdownDescription": "Enables the set_effects command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-enabled",
+          "markdownDescription": "Enables the set_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_focus command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-focus",
+          "markdownDescription": "Enables the set_focus command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_focusable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-focusable",
+          "markdownDescription": "Enables the set_focusable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_fullscreen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-fullscreen",
+          "markdownDescription": "Enables the set_fullscreen command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-icon",
+          "markdownDescription": "Enables the set_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_ignore_cursor_events command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-ignore-cursor-events",
+          "markdownDescription": "Enables the set_ignore_cursor_events command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_max_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-max-size",
+          "markdownDescription": "Enables the set_max_size command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_maximizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-maximizable",
+          "markdownDescription": "Enables the set_maximizable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_min_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-min-size",
+          "markdownDescription": "Enables the set_min_size command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_minimizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-minimizable",
+          "markdownDescription": "Enables the set_minimizable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_overlay_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-overlay-icon",
+          "markdownDescription": "Enables the set_overlay_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-position",
+          "markdownDescription": "Enables the set_position command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_progress_bar command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-progress-bar",
+          "markdownDescription": "Enables the set_progress_bar command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_resizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-resizable",
+          "markdownDescription": "Enables the set_resizable command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_shadow command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-shadow",
+          "markdownDescription": "Enables the set_shadow command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_simple_fullscreen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-simple-fullscreen",
+          "markdownDescription": "Enables the set_simple_fullscreen command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-size",
+          "markdownDescription": "Enables the set_size command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_size_constraints command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-size-constraints",
+          "markdownDescription": "Enables the set_size_constraints command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_skip_taskbar command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-skip-taskbar",
+          "markdownDescription": "Enables the set_skip_taskbar command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_theme command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-theme",
+          "markdownDescription": "Enables the set_theme command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_title command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-title",
+          "markdownDescription": "Enables the set_title command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_title_bar_style command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-title-bar-style",
+          "markdownDescription": "Enables the set_title_bar_style command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the set_visible_on_all_workspaces command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-set-visible-on-all-workspaces",
+          "markdownDescription": "Enables the set_visible_on_all_workspaces command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-show",
+          "markdownDescription": "Enables the show command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the start_dragging command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-start-dragging",
+          "markdownDescription": "Enables the start_dragging command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the start_resize_dragging command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-start-resize-dragging",
+          "markdownDescription": "Enables the start_resize_dragging command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the theme command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-theme",
+          "markdownDescription": "Enables the theme command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the title command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-title",
+          "markdownDescription": "Enables the title command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the toggle_maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-toggle-maximize",
+          "markdownDescription": "Enables the toggle_maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the unmaximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-unmaximize",
+          "markdownDescription": "Enables the unmaximize command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the unminimize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:allow-unminimize",
+          "markdownDescription": "Enables the unminimize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the activity_name command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-activity-name",
+          "markdownDescription": "Denies the activity_name command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the available_monitors command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-available-monitors",
+          "markdownDescription": "Denies the available_monitors command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the center command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-center",
+          "markdownDescription": "Denies the center command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the close command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-close",
+          "markdownDescription": "Denies the close command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-create",
+          "markdownDescription": "Denies the create command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the current_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-current-monitor",
+          "markdownDescription": "Denies the current_monitor command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the cursor_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-cursor-position",
+          "markdownDescription": "Denies the cursor_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the destroy command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-destroy",
+          "markdownDescription": "Denies the destroy command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_all_windows command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-get-all-windows",
+          "markdownDescription": "Denies the get_all_windows command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the hide command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-hide",
+          "markdownDescription": "Denies the hide command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the inner_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-inner-position",
+          "markdownDescription": "Denies the inner_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the inner_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-inner-size",
+          "markdownDescription": "Denies the inner_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the internal_toggle_maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-internal-toggle-maximize",
+          "markdownDescription": "Denies the internal_toggle_maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_always_on_top command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-always-on-top",
+          "markdownDescription": "Denies the is_always_on_top command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_closable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-closable",
+          "markdownDescription": "Denies the is_closable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_decorated command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-decorated",
+          "markdownDescription": "Denies the is_decorated command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-enabled",
+          "markdownDescription": "Denies the is_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_focused command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-focused",
+          "markdownDescription": "Denies the is_focused command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_fullscreen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-fullscreen",
+          "markdownDescription": "Denies the is_fullscreen command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_maximizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-maximizable",
+          "markdownDescription": "Denies the is_maximizable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_maximized command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-maximized",
+          "markdownDescription": "Denies the is_maximized command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_minimizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-minimizable",
+          "markdownDescription": "Denies the is_minimizable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_minimized command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-minimized",
+          "markdownDescription": "Denies the is_minimized command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_resizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-resizable",
+          "markdownDescription": "Denies the is_resizable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_visible command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-is-visible",
+          "markdownDescription": "Denies the is_visible command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-maximize",
+          "markdownDescription": "Denies the maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the minimize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-minimize",
+          "markdownDescription": "Denies the minimize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the monitor_from_point command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-monitor-from-point",
+          "markdownDescription": "Denies the monitor_from_point command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the outer_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-outer-position",
+          "markdownDescription": "Denies the outer_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the outer_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-outer-size",
+          "markdownDescription": "Denies the outer_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the primary_monitor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-primary-monitor",
+          "markdownDescription": "Denies the primary_monitor command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the request_user_attention command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-request-user-attention",
+          "markdownDescription": "Denies the request_user_attention command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the scale_factor command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-scale-factor",
+          "markdownDescription": "Denies the scale_factor command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the scene_identifier command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-scene-identifier",
+          "markdownDescription": "Denies the scene_identifier command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_always_on_bottom command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-always-on-bottom",
+          "markdownDescription": "Denies the set_always_on_bottom command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_always_on_top command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-always-on-top",
+          "markdownDescription": "Denies the set_always_on_top command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_background_color command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-background-color",
+          "markdownDescription": "Denies the set_background_color command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_badge_count command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-badge-count",
+          "markdownDescription": "Denies the set_badge_count command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_badge_label command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-badge-label",
+          "markdownDescription": "Denies the set_badge_label command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_closable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-closable",
+          "markdownDescription": "Denies the set_closable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_content_protected command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-content-protected",
+          "markdownDescription": "Denies the set_content_protected command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_cursor_grab command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-cursor-grab",
+          "markdownDescription": "Denies the set_cursor_grab command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_cursor_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-cursor-icon",
+          "markdownDescription": "Denies the set_cursor_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_cursor_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-cursor-position",
+          "markdownDescription": "Denies the set_cursor_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_cursor_visible command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-cursor-visible",
+          "markdownDescription": "Denies the set_cursor_visible command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_decorations command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-decorations",
+          "markdownDescription": "Denies the set_decorations command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_effects command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-effects",
+          "markdownDescription": "Denies the set_effects command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_enabled command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-enabled",
+          "markdownDescription": "Denies the set_enabled command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_focus command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-focus",
+          "markdownDescription": "Denies the set_focus command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_focusable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-focusable",
+          "markdownDescription": "Denies the set_focusable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_fullscreen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-fullscreen",
+          "markdownDescription": "Denies the set_fullscreen command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-icon",
+          "markdownDescription": "Denies the set_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_ignore_cursor_events command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-ignore-cursor-events",
+          "markdownDescription": "Denies the set_ignore_cursor_events command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_max_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-max-size",
+          "markdownDescription": "Denies the set_max_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_maximizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-maximizable",
+          "markdownDescription": "Denies the set_maximizable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_min_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-min-size",
+          "markdownDescription": "Denies the set_min_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_minimizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-minimizable",
+          "markdownDescription": "Denies the set_minimizable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_overlay_icon command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-overlay-icon",
+          "markdownDescription": "Denies the set_overlay_icon command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_position command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-position",
+          "markdownDescription": "Denies the set_position command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_progress_bar command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-progress-bar",
+          "markdownDescription": "Denies the set_progress_bar command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_resizable command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-resizable",
+          "markdownDescription": "Denies the set_resizable command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_shadow command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-shadow",
+          "markdownDescription": "Denies the set_shadow command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_simple_fullscreen command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-simple-fullscreen",
+          "markdownDescription": "Denies the set_simple_fullscreen command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_size command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-size",
+          "markdownDescription": "Denies the set_size command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_size_constraints command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-size-constraints",
+          "markdownDescription": "Denies the set_size_constraints command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_skip_taskbar command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-skip-taskbar",
+          "markdownDescription": "Denies the set_skip_taskbar command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_theme command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-theme",
+          "markdownDescription": "Denies the set_theme command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_title command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-title",
+          "markdownDescription": "Denies the set_title command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_title_bar_style command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-title-bar-style",
+          "markdownDescription": "Denies the set_title_bar_style command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the set_visible_on_all_workspaces command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-set-visible-on-all-workspaces",
+          "markdownDescription": "Denies the set_visible_on_all_workspaces command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-show",
+          "markdownDescription": "Denies the show command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the start_dragging command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-start-dragging",
+          "markdownDescription": "Denies the start_dragging command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the start_resize_dragging command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-start-resize-dragging",
+          "markdownDescription": "Denies the start_resize_dragging command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the theme command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-theme",
+          "markdownDescription": "Denies the theme command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the title command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-title",
+          "markdownDescription": "Denies the title command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the toggle_maximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-toggle-maximize",
+          "markdownDescription": "Denies the toggle_maximize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the unmaximize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-unmaximize",
+          "markdownDescription": "Denies the unmaximize command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the unminimize command without any pre-configured scope.",
+          "type": "string",
+          "const": "core:window:deny-unminimize",
+          "markdownDescription": "Denies the unminimize command without any pre-configured scope."
+        },
+        {
+          "description": "This permission set configures the types of dialogs\navailable from the dialog plugin.\n\n#### Granted Permissions\n\nAll dialog types are enabled.\n\n\n\n#### This default permission set includes:\n\n- `allow-message`\n- `allow-save`\n- `allow-open`",
+          "type": "string",
+          "const": "dialog:default",
+          "markdownDescription": "This permission set configures the types of dialogs\navailable from the dialog plugin.\n\n#### Granted Permissions\n\nAll dialog types are enabled.\n\n\n\n#### This default permission set includes:\n\n- `allow-message`\n- `allow-save`\n- `allow-open`"
+        },
+        {
+          "description": "Enables the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)",
+          "type": "string",
+          "const": "dialog:allow-ask",
+          "markdownDescription": "Enables the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)"
+        },
+        {
+          "description": "Enables the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)",
+          "type": "string",
+          "const": "dialog:allow-confirm",
+          "markdownDescription": "Enables the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `allow-message` and will be removed in v3)"
+        },
+        {
+          "description": "Enables the message command without any pre-configured scope.",
+          "type": "string",
+          "const": "dialog:allow-message",
+          "markdownDescription": "Enables the message command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the open command without any pre-configured scope.",
+          "type": "string",
+          "const": "dialog:allow-open",
+          "markdownDescription": "Enables the open command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the save command without any pre-configured scope.",
+          "type": "string",
+          "const": "dialog:allow-save",
+          "markdownDescription": "Enables the save command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)",
+          "type": "string",
+          "const": "dialog:deny-ask",
+          "markdownDescription": "Denies the ask command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)"
+        },
+        {
+          "description": "Denies the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)",
+          "type": "string",
+          "const": "dialog:deny-confirm",
+          "markdownDescription": "Denies the confirm command without any pre-configured scope. (**DEPRECATED**: This is now an alias to `deny-message` and will be removed in v3)"
+        },
+        {
+          "description": "Denies the message command without any pre-configured scope.",
+          "type": "string",
+          "const": "dialog:deny-message",
+          "markdownDescription": "Denies the message command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the open command without any pre-configured scope.",
+          "type": "string",
+          "const": "dialog:deny-open",
+          "markdownDescription": "Denies the open command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the save command without any pre-configured scope.",
+          "type": "string",
+          "const": "dialog:deny-save",
+          "markdownDescription": "Denies the save command without any pre-configured scope."
+        },
+        {
+          "description": "Default permissions for the plugin\n#### This default permission set includes:\n\n- `allow-start-drag`",
+          "type": "string",
+          "const": "drag:default",
+          "markdownDescription": "Default permissions for the plugin\n#### This default permission set includes:\n\n- `allow-start-drag`"
+        },
+        {
+          "description": "Enables the start_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "drag:allow-start-drag",
+          "markdownDescription": "Enables the start_drag command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the start_drag command without any pre-configured scope.",
+          "type": "string",
+          "const": "drag:deny-start-drag",
+          "markdownDescription": "Denies the start_drag command without any pre-configured scope."
+        },
+        {
+          "description": "This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n\n#### This default permission set includes:\n\n- `allow-is-permission-granted`\n- `allow-request-permission`\n- `allow-notify`\n- `allow-register-action-types`\n- `allow-register-listener`\n- `allow-cancel`\n- `allow-get-pending`\n- `allow-remove-active`\n- `allow-get-active`\n- `allow-check-permissions`\n- `allow-show`\n- `allow-batch`\n- `allow-list-channels`\n- `allow-delete-channel`\n- `allow-create-channel`\n- `allow-permission-state`",
+          "type": "string",
+          "const": "notification:default",
+          "markdownDescription": "This permission set configures which\nnotification features are by default exposed.\n\n#### Granted Permissions\n\nIt allows all notification related features.\n\n\n#### This default permission set includes:\n\n- `allow-is-permission-granted`\n- `allow-request-permission`\n- `allow-notify`\n- `allow-register-action-types`\n- `allow-register-listener`\n- `allow-cancel`\n- `allow-get-pending`\n- `allow-remove-active`\n- `allow-get-active`\n- `allow-check-permissions`\n- `allow-show`\n- `allow-batch`\n- `allow-list-channels`\n- `allow-delete-channel`\n- `allow-create-channel`\n- `allow-permission-state`"
+        },
+        {
+          "description": "Enables the batch command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-batch",
+          "markdownDescription": "Enables the batch command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the cancel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-cancel",
+          "markdownDescription": "Enables the cancel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the check_permissions command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-check-permissions",
+          "markdownDescription": "Enables the check_permissions command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the create_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-create-channel",
+          "markdownDescription": "Enables the create_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the delete_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-delete-channel",
+          "markdownDescription": "Enables the delete_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-get-active",
+          "markdownDescription": "Enables the get_active command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the get_pending command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-get-pending",
+          "markdownDescription": "Enables the get_pending command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_permission_granted command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-is-permission-granted",
+          "markdownDescription": "Enables the is_permission_granted command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the list_channels command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-list-channels",
+          "markdownDescription": "Enables the list_channels command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the notify command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-notify",
+          "markdownDescription": "Enables the notify command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the permission_state command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-permission-state",
+          "markdownDescription": "Enables the permission_state command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_action_types command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-register-action-types",
+          "markdownDescription": "Enables the register_action_types command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-register-listener",
+          "markdownDescription": "Enables the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the remove_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-remove-active",
+          "markdownDescription": "Enables the remove_active command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the request_permission command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-request-permission",
+          "markdownDescription": "Enables the request_permission command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:allow-show",
+          "markdownDescription": "Enables the show command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the batch command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-batch",
+          "markdownDescription": "Denies the batch command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the cancel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-cancel",
+          "markdownDescription": "Denies the cancel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the check_permissions command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-check-permissions",
+          "markdownDescription": "Denies the check_permissions command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the create_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-create-channel",
+          "markdownDescription": "Denies the create_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the delete_channel command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-delete-channel",
+          "markdownDescription": "Denies the delete_channel command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-get-active",
+          "markdownDescription": "Denies the get_active command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_pending command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-get-pending",
+          "markdownDescription": "Denies the get_pending command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_permission_granted command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-is-permission-granted",
+          "markdownDescription": "Denies the is_permission_granted command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the list_channels command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-list-channels",
+          "markdownDescription": "Denies the list_channels command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the notify command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-notify",
+          "markdownDescription": "Denies the notify command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the permission_state command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-permission-state",
+          "markdownDescription": "Denies the permission_state command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_action_types command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-register-action-types",
+          "markdownDescription": "Denies the register_action_types command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register_listener command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-register-listener",
+          "markdownDescription": "Denies the register_listener command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the remove_active command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-remove-active",
+          "markdownDescription": "Denies the remove_active command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the request_permission command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-request-permission",
+          "markdownDescription": "Denies the request_permission command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the show command without any pre-configured scope.",
+          "type": "string",
+          "const": "notification:deny-show",
+          "markdownDescription": "Denies the show command without any pre-configured scope."
+        }
+      ]
+    },
+    "Value": {
+      "description": "All supported ACL values.",
+      "anyOf": [
+        {
+          "description": "Represents a null JSON value.",
+          "type": "null"
+        },
+        {
+          "description": "Represents a [`bool`].",
+          "type": "boolean"
+        },
+        {
+          "description": "Represents a valid ACL [`Number`].",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Number"
+            }
+          ]
+        },
+        {
+          "description": "Represents a [`String`].",
+          "type": "string"
+        },
+        {
+          "description": "Represents a list of other [`Value`]s.",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Value"
+          }
+        },
+        {
+          "description": "Represents a map of [`String`] keys to [`Value`]s.",
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/Value"
+          }
+        }
+      ]
+    },
+    "Number": {
+      "description": "A valid ACL number.",
+      "anyOf": [
+        {
+          "description": "Represents an [`i64`].",
+          "type": "integer",
+          "format": "int64"
+        },
+        {
+          "description": "Represents a [`f64`].",
+          "type": "number",
+          "format": "double"
+        }
+      ]
+    },
+    "Target": {
+      "description": "Platform target.",
+      "oneOf": [
+        {
+          "description": "MacOS.",
+          "type": "string",
+          "enum": [
+            "macOS"
+          ]
+        },
+        {
+          "description": "Windows.",
+          "type": "string",
+          "enum": [
+            "windows"
+          ]
+        },
+        {
+          "description": "Linux.",
+          "type": "string",
+          "enum": [
+            "linux"
+          ]
+        },
+        {
+          "description": "Android.",
+          "type": "string",
+          "enum": [
+            "android"
+          ]
+        },
+        {
+          "description": "iOS.",
+          "type": "string",
+          "enum": [
+            "iOS"
+          ]
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/src-tauri/icons/128x128.png b/src-tauri/icons/128x128.png
index 90875d1..ea5213f 100644
Binary files a/src-tauri/icons/128x128.png and b/src-tauri/icons/128x128.png differ
diff --git a/src-tauri/icons/128x128@2x.png b/src-tauri/icons/128x128@2x.png
index 38259e9..b66b44e 100644
Binary files a/src-tauri/icons/128x128@2x.png and b/src-tauri/icons/128x128@2x.png differ
diff --git a/src-tauri/icons/32x32.png b/src-tauri/icons/32x32.png
index a344fef..ba14a62 100644
Binary files a/src-tauri/icons/32x32.png and b/src-tauri/icons/32x32.png differ
diff --git a/src-tauri/icons/icon-source.svg b/src-tauri/icons/icon-source.svg
new file mode 100644
index 0000000..667d884
--- /dev/null
+++ b/src-tauri/icons/icon-source.svg
@@ -0,0 +1,36 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="none" role="img" aria-label="Eldrun">
+  <title>Eldrun</title>
+  <defs>
+    <!-- Brand ramp, same colors as the bg-header ramp in themes.css. -->
+    <linearGradient id="eldrun-coaster" x1="0" y1="0" x2="512" y2="512" gradientUnits="userSpaceOnUse">
+      <stop offset="0" stop-color="#101624" />
+      <stop offset="0.5" stop-color="#16213a" />
+      <stop offset="1" stop-color="#241735" />
+    </linearGradient>
+  </defs>
+  <!-- Opaque coaster so the white glyph reads on any OS taskbar/switcher. -->
+  <rect x="0" y="0" width="512" height="512" rx="96" fill="url(#eldrun-coaster)" />
+  <!-- Glyph inset ~46px inside the coaster (0.82 * 512 = 420, centered). -->
+  <g transform="translate(46,46) scale(0.82)">
+    <g stroke="#FFFFFF" stroke-linecap="round" stroke-linejoin="round" fill="none">
+      <!-- Ring -->
+      <path d="M 214 491 A 239 239 0 1 1 298 491" stroke-width="10" />
+      <!-- Central trunk -->
+      <path d="M 256 161 L 256 499" stroke-width="10" />
+      <!-- Left branches (authored) -->
+      <path d="M 165 176 L 165 238 L 233 306 L 233 440 L 222 483" stroke-width="10" />
+      <path d="M 98 235 L 98 289 L 134.1 325.1 M 155 343.7 L 233 405" stroke-width="10" />
+      <circle cx="165" cy="162" r="14" stroke-width="8" />
+      <circle cx="98"  cy="221" r="14" stroke-width="8" />
+      <circle cx="144" cy="335" r="14" stroke-width="8" />
+      <!-- Right branches (explicit mirror across x=256) -->
+      <path d="M 347 176 L 347 238 L 279 306 L 279 440 L 290 483" stroke-width="10" />
+      <path d="M 414 235 L 414 289 L 377.9 325.1 M 357 343.7 L 279 405" stroke-width="10" />
+      <circle cx="347" cy="162" r="14" stroke-width="8" />
+      <circle cx="414" cy="221" r="14" stroke-width="8" />
+      <circle cx="368" cy="335" r="14" stroke-width="8" />
+    </g>
+    <!-- Gold four-point spark (unchanged) -->
+    <path d="M 256 61 C 261 92 268 96 292 101 C 268 106 261 110 256 142 C 251 110 244 106 220 101 C 244 96 251 92 256 61 Z" fill="#C79A45" />
+  </g>
+</svg>
diff --git a/src-tauri/icons/icon.icns b/src-tauri/icons/icon.icns
index 5a6fa58..82afda9 100644
Binary files a/src-tauri/icons/icon.icns and b/src-tauri/icons/icon.icns differ
diff --git a/src-tauri/icons/icon.ico b/src-tauri/icons/icon.ico
index 9ad5190..a80a71a 100644
Binary files a/src-tauri/icons/icon.ico and b/src-tauri/icons/icon.ico differ
diff --git a/src-tauri/src/commands/agents.rs b/src-tauri/src/commands/agents.rs
new file mode 100644
index 0000000..3dbcc1a
--- /dev/null
+++ b/src-tauri/src/commands/agents.rs
@@ -0,0 +1,739 @@
+//! Agent-CLI management: detect and install the AI coding-agent command-line
+//! tools Eldrun can launch as agent tabs (Claude, Codex, Gemini, Mistral/vibe,
+//! Aider, OpenCode, Cursor, Copilot, Grok, Qwen, OpenClaw).
+//!
+//! This mirrors the local-model install flow in `commands::ollama` (see
+//! `install_vibe`), but is registry-driven so the set of agents lives in one
+//! table (`AGENTS`). Each spec carries the binary name, the official one-line
+//! install command, and any well-known user install locations to also check,
+//! since Eldrun's inherited `PATH` may omit `~/.local/bin` / npm's global bin
+//! even when a login shell would include them.
+
+/// A single installable agent CLI.
+#[derive(Clone, Copy)]
+struct AgentSpec {
+    /// Stable id used by the frontend and `install-progress` events.
+    id: &'static str,
+    /// Human-readable label.
+    label: &'static str,
+    /// Binary name to probe on `PATH` (`where` on Windows, `which` elsewhere).
+    bin: &'static str,
+    /// Official non-interactive install command (Linux/macOS, run in `sh`).
+    install_cmd: &'static str,
+    /// Official non-interactive install command on Windows, when one exists.
+    /// `None` means there is no one-line Windows installer — the UI then points
+    /// at `docs` instead. Commands using `irm`/`iex` are PowerShell-only; plain
+    /// `npm`/`python` commands run in either PowerShell or Command Prompt (see
+    /// `windows_shell`).
+    install_cmd_windows: Option<&'static str>,
+    /// Extra home-relative paths to check when the PATH lookup misses (PATH gaps).
+    extra_paths: &'static [&'static str],
+    /// Docs URL shown when automatic install isn't possible.
+    docs: &'static str,
+}
+
+/// The shell a Windows install command must be run in, derived from the command
+/// itself: `irm … | iex` is PowerShell-only; `npm`/`python` installs work in
+/// either PowerShell or the classic Command Prompt.
+fn windows_shell(cmd: &str) -> &'static str {
+    if cmd.contains("iex") || cmd.trim_start().starts_with("irm") {
+        "PowerShell"
+    } else {
+        "PowerShell or Command Prompt"
+    }
+}
+
+fn windows_shell_kind(cmd: &str) -> &'static str {
+    if cmd.contains("iex") || cmd.trim_start().starts_with("irm") {
+        "powershell"
+    } else {
+        "default"
+    }
+}
+
+/// The install command + the shell it runs in, for the host OS. On Windows the
+/// command is `None` when no one-line installer exists.
+fn platform_install(spec: &AgentSpec) -> (Option<&'static str>, String, &'static str) {
+    if cfg!(target_os = "windows") {
+        let shell = spec
+            .install_cmd_windows
+            .map(windows_shell)
+            .unwrap_or("PowerShell")
+            .to_string();
+        let kind = spec
+            .install_cmd_windows
+            .map(windows_shell_kind)
+            .unwrap_or("powershell");
+        (spec.install_cmd_windows, shell, kind)
+    } else {
+        (Some(spec.install_cmd), "bash".to_string(), "bash")
+    }
+}
+
+/// The built-in agent registry. The order here is the order the UI lists them.
+const AGENTS: &[AgentSpec] = &[
+    AgentSpec {
+        id: "claude",
+        label: "Claude",
+        bin: "claude",
+        install_cmd: "curl -fsSL https://claude.ai/install.sh | bash",
+        install_cmd_windows: Some("irm https://claude.ai/install.ps1 | iex"),
+        extra_paths: &[".local/bin/claude"],
+        docs: "https://docs.anthropic.com/en/docs/claude-code/setup",
+    },
+    AgentSpec {
+        id: "codex",
+        label: "Codex",
+        bin: "codex",
+        install_cmd: "curl -fsSL https://chatgpt.com/codex/install.sh | sh",
+        install_cmd_windows: Some("irm https://chatgpt.com/codex/install.ps1 | iex"),
+        extra_paths: &[".local/bin/codex"],
+        docs: "https://github.com/openai/codex",
+    },
+    AgentSpec {
+        id: "gemini",
+        label: "Gemini",
+        bin: "gemini",
+        install_cmd: "npm install -g @google/gemini-cli",
+        install_cmd_windows: Some("npm install -g @google/gemini-cli"),
+        extra_paths: &[".local/bin/gemini"],
+        docs: "https://github.com/google-gemini/gemini-cli",
+    },
+    AgentSpec {
+        id: "vibe",
+        label: "Mistral",
+        bin: "vibe",
+        install_cmd: "curl -LsSf https://mistral.ai/vibe/install.sh | bash",
+        // No one-line Windows installer; the UI points at `docs`.
+        install_cmd_windows: None,
+        extra_paths: &[".local/bin/vibe", ".cargo/bin/vibe"],
+        docs: "https://docs.mistral.ai/getting-started/quickstarts/vibe-code/install-cli",
+    },
+    AgentSpec {
+        id: "aider",
+        label: "Aider",
+        bin: "aider",
+        install_cmd: "python -m pip install aider-install && aider-install",
+        install_cmd_windows: Some("python -m pip install aider-install && aider-install"),
+        extra_paths: &[".local/bin/aider"],
+        docs: "https://aider.chat/docs/install.html",
+    },
+    AgentSpec {
+        id: "opencode",
+        label: "OpenCode",
+        bin: "opencode",
+        install_cmd: "curl -fsSL https://opencode.ai/install | bash",
+        install_cmd_windows: Some("npm install -g opencode-ai"),
+        extra_paths: &[".opencode/bin/opencode", ".local/bin/opencode"],
+        docs: "https://opencode.ai/docs/",
+    },
+    AgentSpec {
+        id: "cursor-agent",
+        label: "Cursor",
+        bin: "cursor-agent",
+        install_cmd: "curl https://cursor.com/install -fsS | bash",
+        // No one-line Windows installer; the UI points at `docs`.
+        install_cmd_windows: None,
+        extra_paths: &[".local/bin/cursor-agent"],
+        docs: "https://cursor.com/docs/cli/installation",
+    },
+    AgentSpec {
+        id: "copilot",
+        label: "Copilot",
+        bin: "copilot",
+        install_cmd: "npm install -g @github/copilot",
+        install_cmd_windows: Some("npm install -g @github/copilot"),
+        extra_paths: &[".local/bin/copilot"],
+        docs: "https://docs.github.com/en/copilot/how-tos/copilot-cli/set-up-copilot-cli/install-copilot-cli",
+    },
+    AgentSpec {
+        id: "grok",
+        label: "Grok",
+        bin: "grok",
+        install_cmd: "npm install -g @vibe-kit/grok-cli",
+        install_cmd_windows: Some("npm install -g @vibe-kit/grok-cli"),
+        extra_paths: &[".local/bin/grok"],
+        docs: "https://github.com/superagent-ai/grok-cli",
+    },
+    AgentSpec {
+        id: "qwen",
+        label: "Qwen",
+        bin: "qwen",
+        install_cmd: "npm install -g @qwen-code/qwen-code",
+        install_cmd_windows: Some("npm install -g @qwen-code/qwen-code"),
+        extra_paths: &[".local/bin/qwen"],
+        docs: "https://github.com/QwenLM/qwen-code",
+    },
+    AgentSpec {
+        id: "openclaw",
+        label: "OpenClaw",
+        bin: "openclaw",
+        install_cmd: "npm install -g openclaw",
+        install_cmd_windows: Some("npm install -g openclaw"),
+        extra_paths: &[".local/bin/openclaw"],
+        docs: "https://docs.openclaw.ai",
+    },
+];
+
+/// Public view of one agent + whether it is currently installed.
+#[derive(serde::Serialize)]
+pub struct AgentInfo {
+    pub id: String,
+    pub label: String,
+    pub bin: String,
+    /// The install command for the host OS, or empty when there is no one-line
+    /// installer on this platform (Windows-only case — fall back to `docs`).
+    pub install_cmd: String,
+    /// The shell `install_cmd` is meant to run in: `bash` on Linux/macOS,
+    /// `PowerShell` or `PowerShell or Command Prompt` on Windows.
+    pub shell: String,
+    /// Machine-readable terminal shell policy for the frontend.
+    pub shell_kind: String,
+    /// `npm uninstall -g <pkg>` for an npm-installed agent, empty otherwise —
+    /// the terminal fallback the frontend offers next to "Remove" when the
+    /// one-click uninstall hits a permission error (a system-wide npm global
+    /// directory owned by root, common on non-nvm Linux Node installs, needs a
+    /// sudo prompt Eldrun cannot answer itself).
+    pub uninstall_cmd: String,
+    pub docs: String,
+    pub installed: bool,
+}
+
+fn find_spec(id: &str) -> Option<&'static AgentSpec> {
+    AGENTS.iter().find(|a| a.id == id)
+}
+
+/// Where `spec`'s binary actually lives — on `PATH` (including Eldrun's
+/// supplemental Windows/macOS fallback dirs) or in one of its well-known
+/// per-user install locations — or `None` when it isn't installed. The single
+/// resolver behind both `spec_is_installed` and `uninstall_agent` (removal
+/// deletes exactly the file detection found, never a guess).
+///
+/// PATH lookup goes through the shared cross-platform helper (`where` on Windows,
+/// `which` elsewhere): `which` does not exist on Windows, so probing it directly
+/// reported every Windows install — Claude included — as missing.
+fn resolve_spec_path(spec: &AgentSpec) -> Option<std::path::PathBuf> {
+    if let Some(path) = crate::paths::resolve_executable(spec.bin) {
+        return Some(path);
+    }
+    let home = crate::paths::home_dir();
+    spec.extra_paths.iter().find_map(|rel| {
+        let base = home.join(rel);
+        if base.exists() {
+            return Some(base);
+        }
+        // On Windows the extra paths omit the executable extension that the
+        // installer actually writes (e.g. `.local/bin/claude` → `claude.exe`).
+        if cfg!(target_os = "windows") {
+            for ext in ["exe", "cmd", "bat", "ps1"] {
+                let cand = base.with_extension(ext);
+                if cand.exists() {
+                    return Some(cand);
+                }
+            }
+        }
+        None
+    })
+}
+
+/// True when an agent's binary is reachable on `PATH` or in one of its
+/// well-known user install locations.
+fn spec_is_installed(spec: &AgentSpec) -> bool {
+    resolve_spec_path(spec).is_some()
+}
+
+/// True when the given agent (by id) is installed. Unknown ids return false.
+#[tauri::command]
+pub async fn agent_is_installed(id: String) -> bool {
+    find_spec(&id).map(spec_is_installed).unwrap_or(false)
+}
+
+/// True when Node.js' `npm` is reachable on `PATH`. Most agent CLIs install via
+/// `npm install -g …`, so the Manage Agents panel uses this to decide whether to
+/// surface its "install Node/npm first" helper.
+#[tauri::command]
+pub async fn npm_is_installed() -> bool {
+    crate::paths::binary_on_path("npm")
+}
+
+/// Probe arbitrary commands (user-defined custom agents, which aren't in the
+/// built-in `AGENTS` registry) for install status, returning the subset present.
+/// A bare name is looked up on `PATH`; a value containing a path separator is
+/// checked as a file path so a custom agent pointed at a full path resolves too.
+#[tauri::command]
+pub async fn probe_binaries(bins: Vec<String>) -> Vec<String> {
+    bins.into_iter()
+        .filter(|b| {
+            if b.contains('/') || b.contains('\\') {
+                std::path::Path::new(b).exists()
+            } else {
+                crate::paths::binary_on_path(b)
+            }
+        })
+        .collect()
+}
+
+/// Sync install probe for callers outside the agent registry (e.g. the local-
+/// model drivers in `commands::ollama`). Looks `bin` up in the registry first so
+/// it reuses the known user install locations; falls back to a bare PATH lookup
+/// for binaries the registry doesn't track (e.g. Droid).
+pub fn binary_is_installed(bin: &str) -> bool {
+    AGENTS
+        .iter()
+        .find(|a| a.bin == bin)
+        .map(spec_is_installed)
+        .unwrap_or_else(|| crate::paths::binary_on_path(bin))
+}
+
+/// Whether Codex is actually running Eldrun's `SessionStart` hook — the precise
+/// path for resuming a tab's *current* conversation. Codex gates user-level hooks
+/// behind a one-time trust approval (`/hooks`), and an untrusted one never fires,
+/// silently; Eldrun then falls back to guessing the session from Codex's rollout
+/// logs (`services::codex_bind`). The UI reads this to offer the one-click fix.
+#[tauri::command]
+pub async fn codex_hook_status() -> crate::services::agent_session::CodexHookState {
+    crate::services::agent_session::codex_hook_state()
+}
+
+/// List every known agent CLI with its current installed status.
+#[tauri::command]
+pub async fn list_agents() -> Vec<AgentInfo> {
+    AGENTS
+        .iter()
+        .map(|spec| {
+            let (cmd, shell, shell_kind) = platform_install(spec);
+            let uninstall_cmd = cmd
+                .and_then(npm_package_from_cmd)
+                .map(|pkg| format!("npm uninstall -g {pkg}"))
+                .unwrap_or_default();
+            AgentInfo {
+                id: spec.id.to_string(),
+                label: spec.label.to_string(),
+                bin: spec.bin.to_string(),
+                install_cmd: cmd.unwrap_or("").to_string(),
+                shell,
+                shell_kind: shell_kind.to_string(),
+                uninstall_cmd,
+                docs: spec.docs.to_string(),
+                installed: spec_is_installed(spec),
+            }
+        })
+        .collect()
+}
+
+/// Build the process that runs `spec`'s installer for the host OS, with stdout
+/// and stderr merged in-shell (the read loop only drains stdout — merging in the
+/// shell keeps interleaving right and avoids a stderr-fill deadlock).
+///
+/// Linux/macOS run `install_cmd` via `sh`. Windows runs `install_cmd_windows`
+/// via PowerShell when the command is PowerShell-only (`irm … | iex`), else via
+/// `cmd /C` — plain `npm`/`python` installs may chain with `&&`, which Windows
+/// PowerShell 5.1 does not parse but cmd does.
+fn installer_command(spec: &AgentSpec) -> Result<std::process::Command, String> {
+    #[cfg(windows)]
+    {
+        let cmd_str = spec.install_cmd_windows.ok_or_else(|| {
+            format!(
+                "{} has no one-line Windows installer. See {}.",
+                spec.label, spec.docs
+            )
+        })?;
+        let mut c;
+        if windows_shell_kind(cmd_str) == "powershell" {
+            c = crate::paths::command_no_window("powershell");
+            c.args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command"])
+                // Scriptblock-wrap so `2>&1` merges the whole pipeline's error
+                // stream, not just the last command's.
+                .arg(format!("& {{ {cmd_str} }} 2>&1"));
+        } else {
+            c = crate::paths::command_no_window("cmd");
+            // cmd doesn't take an argv — hand it the raw line un-requoted.
+            use std::os::windows::process::CommandExt;
+            c.raw_arg(format!("/C {cmd_str} 2>&1"));
+        }
+        Ok(c)
+    }
+    #[cfg(not(windows))]
+    {
+        if !cfg!(any(target_os = "linux", target_os = "macos")) {
+            return Err(format!(
+                "Automatic install is not supported on this OS. See {}.",
+                spec.docs
+            ));
+        }
+        let mut c = crate::paths::command_no_window("sh");
+        c.arg("-c").arg(format!("{} 2>&1", spec.install_cmd));
+        Ok(c)
+    }
+}
+
+/// The command string to suggest re-running manually when the installer fails,
+/// for the host OS.
+fn manual_install_cmd(spec: &AgentSpec) -> &'static str {
+    if cfg!(windows) {
+        spec.install_cmd_windows.unwrap_or(spec.install_cmd)
+    } else {
+        spec.install_cmd
+    }
+}
+
+/// Install an agent CLI via its official install command.
+///
+/// Streams the installer's combined stdout+stderr to the frontend line-by-line
+/// via `agent-install-progress` events (`{ id, line }`) so the UI can show live
+/// progress. Returns the install log on success, or the tail of the output on
+/// failure. The post-install probe is the real source of truth.
+#[tauri::command]
+pub async fn install_agent(app: tauri::AppHandle, id: String) -> Result<String, String> {
+    use std::io::{BufRead, BufReader};
+    use tauri::Emitter;
+
+    let spec = find_spec(&id).ok_or_else(|| format!("unknown agent: {id}"))?;
+
+    if spec_is_installed(spec) {
+        return Ok(format!("{} is already installed.", spec.label));
+    }
+
+    let id_owned = id.clone();
+    let emit = move |line: &str| {
+        let _ = app.emit(
+            "agent-install-progress",
+            serde_json::json!({ "id": id_owned, "line": line }),
+        );
+    };
+    emit(&format!("Starting {} installer…", spec.label));
+
+    let mut child = installer_command(spec)?
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("failed to launch installer: {e}"))?;
+
+    let mut lines: Vec<String> = Vec::new();
+    if let Some(stdout) = child.stdout.take() {
+        for line in BufReader::new(stdout).lines() {
+            let line = match line {
+                Ok(l) => l,
+                Err(_) => break,
+            };
+            emit(&line);
+            lines.push(line);
+        }
+    }
+
+    let status = child
+        .wait()
+        .map_err(|e| format!("installer did not finish: {e}"))?;
+    let combined = lines.join("\n").trim().to_string();
+
+    if !status.success() {
+        let tail: Vec<&str> = combined.lines().rev().take(20).collect();
+        let tail = tail.into_iter().rev().collect::<Vec<_>>().join("\n");
+        return Err(if tail.is_empty() {
+            format!(
+                "installer exited unsuccessfully ({status}). Run `{}` in a terminal.",
+                manual_install_cmd(spec)
+            )
+        } else {
+            tail
+        });
+    }
+
+    // The post-install check is the real source of truth.
+    if !spec_is_installed(spec) {
+        return Err(format!(
+            "installer ran but `{}` is still not detected. It may need a new shell so \
+            the install dir is on PATH — run `{}` in a terminal.\n\n{combined}",
+            spec.bin,
+            manual_install_cmd(spec)
+        ));
+    }
+
+    emit("Done.");
+    Ok(if combined.is_empty() {
+        format!("{} installed.", spec.label)
+    } else {
+        combined
+    })
+}
+
+/// The npm package spec an `npm install -g <pkg>` command installs, or `None`
+/// for a curl/irm script installer (which has no npm package to remove — its
+/// binary is deleted directly instead). Used so uninstall targets the exact
+/// package the installer added rather than guessing from the agent id.
+fn npm_package_from_cmd(cmd: &str) -> Option<&str> {
+    cmd.trim()
+        .strip_prefix("npm install -g ")?
+        .split_whitespace()
+        .next()
+}
+
+/// Run `cmd` to completion and return its combined stdout+stderr, trimmed.
+/// `Err` carries that same output (or a status-only message when the command
+/// produced none) on a non-zero exit.
+fn run_capture(mut cmd: std::process::Command) -> Result<String, String> {
+    let output = cmd
+        .output()
+        .map_err(|e| format!("failed to run command: {e}"))?;
+    let mut combined = String::from_utf8_lossy(&output.stdout).into_owned();
+    combined.push_str(&String::from_utf8_lossy(&output.stderr));
+    let combined = combined.trim().to_string();
+    if !output.status.success() {
+        return Err(if combined.is_empty() {
+            format!("command exited unsuccessfully ({})", output.status)
+        } else {
+            combined
+        });
+    }
+    Ok(combined)
+}
+
+/// True when an error message reads as a permission/lock failure rather than
+/// a genuine "nothing to remove" — `EACCES`/"permission denied" (a system-wide
+/// npm global directory owned by root, the default on a non-nvm Linux Node
+/// install) and `EPERM`/`EBUSY` (a file locked by a running process, common on
+/// Windows). Used to swap in guidance pointing at a terminal Eldrun can't
+/// elevate on the user's behalf, instead of a bare stack of npm's own output.
+fn is_permission_error(msg: &str) -> bool {
+    let lower = msg.to_lowercase();
+    ["eacces", "eperm", "ebusy", "permission denied"]
+        .iter()
+        .any(|needle| lower.contains(needle))
+}
+
+/// Build the `npm uninstall -g <pkg>` process for the host OS (same shell
+/// choice as the npm branch of `installer_command`: `cmd /C` on Windows, `sh -c`
+/// elsewhere).
+fn npm_uninstall_command(pkg: &str) -> std::process::Command {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        let mut c = crate::paths::command_no_window("cmd");
+        c.raw_arg(format!("/C npm uninstall -g {pkg} 2>&1"));
+        c
+    }
+    #[cfg(not(windows))]
+    {
+        let mut c = crate::paths::command_no_window("sh");
+        c.arg("-c").arg(format!("npm uninstall -g {pkg} 2>&1"));
+        c
+    }
+}
+
+/// Remove an installed agent CLI so it can be cleanly reinstalled — the
+/// "Remove" action in Manage Agents, and the first half of "Reinstall".
+///
+/// An agent installed via `npm install -g <pkg>` is removed with the matching
+/// `npm uninstall -g` — deleting just the PATH shim would leave the package
+/// registered, so a subsequent install becomes a no-op re-link instead of a
+/// fresh fetch. Every other agent (curl/irm script installers) drops exactly
+/// the binary/shim `resolve_spec_path` found — enough to flip
+/// `spec_is_installed` back to false and let the official installer run again
+/// from scratch; any support files the installer left behind (an updater, a
+/// packages cache) are none of Eldrun's business to guess at and clean up.
+#[tauri::command]
+pub async fn uninstall_agent(id: String) -> Result<String, String> {
+    let spec = find_spec(&id).ok_or_else(|| format!("unknown agent: {id}"))?;
+
+    let cmd_for_platform = if cfg!(windows) {
+        spec.install_cmd_windows.unwrap_or(spec.install_cmd)
+    } else {
+        spec.install_cmd
+    };
+
+    if let Some(pkg) = npm_package_from_cmd(cmd_for_platform) {
+        if !spec_is_installed(spec) {
+            return Ok(format!("{} is not installed.", spec.label));
+        }
+        let out = run_capture(npm_uninstall_command(pkg)).map_err(|e| {
+            if is_permission_error(&e) {
+                format!(
+                    "Permission denied — this machine's npm global directory needs \
+                    elevated rights (common when Node was installed system-wide rather \
+                    than per-user). Eldrun never prompts for a password itself: run \
+                    `npm uninstall -g {pkg}` yourself in an elevated terminal (or via \
+                    the terminal button below).\n\n{e}"
+                )
+            } else {
+                e
+            }
+        })?;
+        if spec_is_installed(spec) {
+            return Err(format!(
+                "npm uninstall ran but `{}` is still detected on PATH.\n\n{out}",
+                spec.bin
+            ));
+        }
+        return Ok(if out.is_empty() {
+            format!("{} removed.", spec.label)
+        } else {
+            out
+        });
+    }
+
+    let path = resolve_spec_path(spec).ok_or_else(|| format!("{} is not installed.", spec.label))?;
+    std::fs::remove_file(&path).map_err(|e| {
+        let shown = path.display();
+        if e.kind() == std::io::ErrorKind::PermissionDenied {
+            format!(
+                "Permission denied removing {shown} — it's owned by another user \
+                (likely installed as root/admin). Remove it yourself in an elevated \
+                terminal (`rm {shown}`, or the OS equivalent)."
+            )
+        } else {
+            format!("failed to remove {shown}: {e}")
+        }
+    })?;
+    Ok(format!("{} removed ({}).", spec.label, path.display()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn windows_shell_flags_powershell_only_commands() {
+        // `irm … | iex` is PowerShell syntax.
+        assert_eq!(
+            windows_shell("irm https://claude.ai/install.ps1 | iex"),
+            "PowerShell"
+        );
+        // npm/python installs run in either shell.
+        assert_eq!(
+            windows_shell("npm install -g @google/gemini-cli"),
+            "PowerShell or Command Prompt"
+        );
+    }
+
+    #[test]
+    fn claude_has_a_powershell_windows_installer() {
+        let claude = find_spec("claude").expect("claude in registry");
+        let win = claude
+            .install_cmd_windows
+            .expect("claude has a Windows installer");
+        assert!(
+            win.contains("irm"),
+            "expected the PowerShell `irm` installer"
+        );
+        assert!(
+            !win.contains("curl"),
+            "Windows installer must not use curl/bash"
+        );
+    }
+
+    #[test]
+    fn npm_package_from_cmd_extracts_the_package_spec() {
+        assert_eq!(
+            npm_package_from_cmd("npm install -g @google/gemini-cli"),
+            Some("@google/gemini-cli")
+        );
+        assert_eq!(
+            npm_package_from_cmd("npm install -g opencode-ai"),
+            Some("opencode-ai")
+        );
+        // curl/irm script installers have no npm package to uninstall.
+        assert_eq!(
+            npm_package_from_cmd("curl -fsSL https://claude.ai/install.sh | bash"),
+            None
+        );
+        assert_eq!(
+            npm_package_from_cmd("irm https://chatgpt.com/codex/install.ps1 | iex"),
+            None
+        );
+    }
+
+    #[test]
+    fn is_permission_error_matches_npm_and_windows_lock_failures() {
+        // Real npm output, old and new formats, both cases.
+        assert!(is_permission_error("npm ERR! code EACCES\nnpm ERR! syscall rename"));
+        assert!(is_permission_error("npm error code EACCES"));
+        assert!(is_permission_error("Access is denied. (os error 5) EPERM"));
+        assert!(is_permission_error("resource busy or locked, rename 'x' EBUSY"));
+        assert!(is_permission_error("Permission denied (os error 13)"));
+        assert!(!is_permission_error("npm ERR! 404 Not Found"));
+        assert!(!is_permission_error("command exited unsuccessfully (exit status: 1)"));
+    }
+
+    #[test]
+    fn uninstall_cmd_is_populated_only_for_npm_installed_agents() {
+        // Gemini installs via npm on every platform, so its uninstall command
+        // must be derivable regardless of host OS this test runs on.
+        let gemini = find_spec("gemini").expect("gemini in registry");
+        let (cmd, _, _) = platform_install(gemini);
+        let uninstall = cmd
+            .and_then(npm_package_from_cmd)
+            .map(|pkg| format!("npm uninstall -g {pkg}"));
+        assert_eq!(uninstall.as_deref(), Some("npm uninstall -g @google/gemini-cli"));
+
+        // Claude's curl/irm script installer has no npm package, so no
+        // uninstall command should be synthesized for it.
+        let claude = find_spec("claude").expect("claude in registry");
+        let (cmd, _, _) = platform_install(claude);
+        assert!(cmd.and_then(npm_package_from_cmd).is_none());
+    }
+
+    #[test]
+    fn every_npm_installed_agent_resolves_to_its_package() {
+        // Every agent whose install command is npm-based must round-trip
+        // through `npm_package_from_cmd`, since `uninstall_agent` relies on it
+        // to target `npm uninstall -g` rather than deleting a shim.
+        for spec in AGENTS {
+            for cmd in [Some(spec.install_cmd), spec.install_cmd_windows].into_iter().flatten() {
+                if cmd.trim_start().starts_with("npm install -g") {
+                    assert!(
+                        npm_package_from_cmd(cmd).is_some(),
+                        "{}'s npm install command did not parse: {cmd}",
+                        spec.id
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn every_agent_serves_a_shell_label() {
+        for spec in AGENTS {
+            let (_cmd, shell, shell_kind) = platform_install(spec);
+            assert!(!shell.is_empty(), "{} has no shell label", spec.id);
+            assert!(
+                matches!(shell_kind, "bash" | "powershell" | "default"),
+                "{} has an invalid shell kind",
+                spec.id
+            );
+        }
+    }
+
+    /// Windows one-click install picks its interpreter per command: PowerShell
+    /// for `irm … | iex`, `cmd /C` for plain npm/python lines (which may chain
+    /// with `&&` — cmd parses that, Windows PowerShell 5.1 does not), and a
+    /// clear error when there is no one-line Windows installer at all.
+    #[cfg(windows)]
+    #[test]
+    fn windows_installer_command_picks_interpreter_per_command() {
+        use std::ffi::OsStr;
+        let claude = find_spec("claude").unwrap(); // irm | iex
+        assert_eq!(
+            installer_command(claude).unwrap().get_program(),
+            OsStr::new("powershell")
+        );
+        let gemini = find_spec("gemini").unwrap(); // npm install -g …
+        assert_eq!(
+            installer_command(gemini).unwrap().get_program(),
+            OsStr::new("cmd")
+        );
+        let vibe = find_spec("vibe").unwrap(); // no Windows installer
+        assert!(installer_command(vibe).is_err());
+    }
+
+    #[test]
+    fn windows_shell_kind_is_not_derived_from_display_text() {
+        assert_eq!(
+            windows_shell_kind("irm https://claude.ai/install.ps1 | iex"),
+            "powershell"
+        );
+        assert_eq!(
+            windows_shell_kind("npm install -g @google/gemini-cli"),
+            "default"
+        );
+    }
+}
diff --git a/src-tauri/src/commands/apps.rs b/src-tauri/src/commands/apps.rs
index 041bff2..d87c0ec 100644
--- a/src-tauri/src/commands/apps.rs
+++ b/src-tauri/src/commands/apps.rs
@@ -5,6 +5,32 @@
 //! apps are tracked by PID and launched/raised as separate windows.
 //! `project.json["open_apps"]` is preserved for backward compatibility but
 //! treated as best-effort restore metadata.
+//!
+//! ## Per-OS backends (TODO 30d)
+//!
+//! App discovery, icon resolution and launching are inherently OS-specific, so
+//! the platform-divergent pieces are gated behind `cfg`:
+//! - **Linux** uses the freedesktop/XDG model: it scans `.desktop` entries under
+//!   `$XDG_DATA_HOME/applications` and every `$XDG_DATA_DIRS` entry's
+//!   `applications` dir (see [`xdg_application_dirs`]) — which, since desktop
+//!   sessions add Flatpak/Snap export paths to `XDG_DATA_DIRS`, is what makes
+//!   apps installed that way discoverable too — resolves icons through the
+//!   icon-theme directories, and launches the `Exec=` line. Multi-word `Exec=`
+//!   values (Flatpak's `flatpak run --branch=... app.id`) are preserved in full
+//!   by [`parse_exec_command`] and shell-split back into program+args at launch
+//!   time by [`split_exec_command`], rather than truncated to their first token.
+//! - **Windows** has no XDG layer, so [`list_installed_apps`] instead enumerates
+//!   Start-Menu `.lnk` shortcuts under `%ProgramData%`/`%APPDATA%`, reading each
+//!   shortcut's display name and resolving its target executable via
+//!   `IShellLinkW` (see [`windows_shortcuts`]). Launching resolves a bare app
+//!   name or `.lnk` back to that target exe ([`resolve_windows_launch_exec`]) and
+//!   spawns it; [`run_script_detached`] runs scripts through `cmd`/PowerShell
+//!   rather than `bash`. Icons are best-effort: a `.png`/`.ico` referenced by the
+//!   shortcut is inlined as a data URL, otherwise the target path is returned for
+//!   the frontend to resolve lazily (no native HICON rasterization — that would
+//!   need GDI, which is out of scope here).
+//! - **Other OSes** fall back to empty/no-op results so the commands never fail
+//!   to build or error at runtime.
 
 use std::collections::HashMap;
 use std::fs;
@@ -32,9 +58,38 @@ pub struct TrackedWindow {
     pub origin: String,
 }
 
+/// A detached popout's last on-screen geometry in PHYSICAL desktop px (#42).
+///
+/// Captured by the project-switch path just BEFORE it hides an inactive
+/// project's popout, and re-applied right after it re-shows it on switch-back —
+/// `hide()`/`show()` lets the WM re-place the window (typically onto the primary
+/// monitor), so switch-back must put it back explicitly or a multi-monitor
+/// popout jumps to the wrong screen. Physical px are scale-invariant for
+/// placement, so no per-monitor scale conversion is needed on re-apply.
+/// Transient (not persisted): the *restart* path restores popouts from the
+/// frontend's saved bounds instead.
+#[derive(Debug, Clone, Copy)]
+pub struct DetachedBounds {
+    pub x: i32,
+    pub y: i32,
+    pub w: u32,
+    pub h: u32,
+}
+
 #[derive(Default)]
 pub struct WindowRegistry {
     pub windows: HashMap<String, TrackedWindow>,
+    /// Detached-subwindow display numbers, keyed by the window's stable label.
+    /// Assigned in `detach_subwindow` (lowest free positive int) so each popout's
+    /// OS title reads "Eldrun win-N", and freed on dock-back/close
+    /// (`attach_subwindow`) and on any other window destruction (the
+    /// `WindowEvent::Destroyed` hook in `lib.rs`) so numbers stay small and
+    /// reuse freed slots — a lone popout is always "win-1".
+    pub detached_seqs: HashMap<String, u32>,
+    /// Last on-screen geometry of each detached popout, keyed by its stable label
+    /// (see [`DetachedBounds`]). Written just before a switch-away hides the
+    /// popout; read just after switch-back re-shows it, to restore its monitor.
+    pub detached_bounds: HashMap<String, DetachedBounds>,
 }
 
 pub type WindowRegistryState = Arc<Mutex<WindowRegistry>>;
@@ -83,19 +138,12 @@ pub fn do_launch(
     origin: &str,
 ) -> Result<TrackedWindow, String> {
     let launch_exec = resolve_launch_exec(exec);
-    let mut cmd = Command::new(&launch_exec);
-    cmd.args(args);
-    if let Some(f) = file {
-        cmd.arg(f);
-    }
+    let mut cmd = launch_command(&launch_exec, args, file);
     cmd.stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::null());
 
-    let child = cmd
-        .spawn()
-        .map_err(|e| format!("launch {launch_exec}: {e}"))?;
-    let pid = child.id();
+    let pid = crate::paths::spawn_reaped(cmd).map_err(|e| format!("launch {launch_exec}: {e}"))?;
     let window_id = find_window_for_pid(pid, 20);
 
     let opened_at = SystemTime::now()
@@ -120,6 +168,57 @@ pub fn do_launch(
     Ok(win)
 }
 
+/// Split an exec string into the literal program to spawn and any leading
+/// arguments already baked into it (e.g. Flatpak's
+/// `flatpak run --branch=stable --command=... app.id`, from
+/// [`parse_exec_command`]).
+///
+/// An exec with no whitespace is always a single program. One that does
+/// contain whitespace is still treated as a single program when the whole
+/// string exists as a literal path on disk — this covers Windows targets like
+/// `C:\Program Files\App\app.exe` and any manually typed Linux path with a
+/// space, both of which must be spawned whole, not split. Only when the whole
+/// string is *not* a real path do we fall back to splitting on whitespace,
+/// which is exactly the multi-word-launcher case: the single-program
+/// interpretation could never have spawned it anyway (no file is literally
+/// named `flatpak run --branch=stable ...`).
+fn split_exec_command(exec: &str) -> (&str, Vec<&str>) {
+    if !exec.contains(' ') || Path::new(exec).exists() {
+        return (exec, Vec::new());
+    }
+    let mut parts = exec.split_whitespace();
+    let program = parts.next().unwrap_or(exec);
+    (program, parts.collect())
+}
+
+fn launch_command(exec: &str, args: &[String], file: Option<&str>) -> Command {
+    #[cfg(target_os = "macos")]
+    if Path::new(exec)
+        .extension()
+        .and_then(|ext| ext.to_str())
+        .is_some_and(|ext| ext.eq_ignore_ascii_case("app"))
+    {
+        let mut cmd = crate::paths::command_no_window("/usr/bin/open");
+        cmd.arg("-a").arg(exec);
+        if let Some(file) = file {
+            cmd.arg(file);
+        }
+        if !args.is_empty() {
+            cmd.arg("--args").args(args);
+        }
+        return cmd;
+    }
+
+    let (program, leading_args) = split_exec_command(exec);
+    let mut cmd = crate::paths::command_for_program(Path::new(program));
+    cmd.args(leading_args);
+    cmd.args(args);
+    if let Some(file) = file {
+        cmd.arg(file);
+    }
+    cmd
+}
+
 // ── Commands ───────────────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -181,13 +280,15 @@ fn resolve_app_icon_uncached(exec: &str) -> Option<String> {
         }
     }
 
-    let exec_base = Path::new(&exec)
+    let (exec_program, _) = split_exec_command(exec);
+    let exec_base = Path::new(exec_program)
         .file_name()?
         .to_string_lossy()
         .to_lowercase();
     for desktop_file in desktop_files() {
         if let Some(entry) = parse_desktop_entry(&desktop_file) {
-            let Some(entry_base) = Path::new(&entry.exec)
+            let (entry_program, _) = split_exec_command(&entry.exec);
+            let Some(entry_base) = Path::new(entry_program)
                 .file_name()
                 .map(|name| name.to_string_lossy().to_lowercase())
             else {
@@ -241,12 +342,28 @@ pub(crate) fn base64_encode(bytes: &[u8]) -> String {
 #[tauri::command]
 pub fn open_file(
     registry: State<'_, WindowRegistryState>,
+    workspace: State<'_, crate::commands::workspace::WorkspaceStateArc>,
     path: String,
     handler: Option<String>,
     project_id: Option<String>,
     origin: Option<String>,
+    // Physical desktop coordinates to place the launched window at (the point a
+    // file was dropped, on the target monitor). Both must be present to apply;
+    // absent on double-click / manual launch, leaving WM placement untouched.
+    x: Option<i32>,
+    y: Option<i32>,
 ) -> Result<TrackedWindow, String> {
     let origin = origin.unwrap_or_else(|| ORIGIN_MANUAL_LAUNCH.to_string());
+    // Best-effort: move a resolved window to the drop point so an externally
+    // launched app lands on the screen the file was dropped onto. Placement
+    // failure never fails the open (X11-only; a no-op elsewhere).
+    let place = |window_id: Option<u64>| {
+        if let (Some(wid), Some(px), Some(py)) = (window_id, x, y) {
+            if let Err(e) = workspace.lock().unwrap().backend.position_window(wid, px, py) {
+                eprintln!("position_window failed: {e}");
+            }
+        }
+    };
     let before = list_window_ids();
     // Resolve the executable to launch: an explicit handler always wins;
     // otherwise consult the project-then-global default-app map (keyed by
@@ -273,15 +390,14 @@ pub fn open_file(
     };
     if let Some(exec) = effective {
         let launch_exec = resolve_launch_exec(&exec);
-        let child = Command::new(&launch_exec)
-            .arg(&path)
-            .stdin(Stdio::null())
+        let mut cmd = launch_command(&launch_exec, &[], Some(&path));
+        cmd.stdin(Stdio::null())
             .stdout(Stdio::null())
-            .stderr(Stdio::null())
-            .spawn()
-            .map_err(|e| format!("open with {launch_exec}: {e}"))?;
-        let pid = child.id();
+            .stderr(Stdio::null());
+        let pid =
+            crate::paths::spawn_reaped(cmd).map_err(|e| format!("open with {launch_exec}: {e}"))?;
         let window_id = find_window_for_pid(pid, 20).or_else(|| find_new_window(&before, 20));
+        place(window_id);
         return track_opened_file(
             registry.inner(),
             launch_exec,
@@ -294,6 +410,7 @@ pub fn open_file(
     }
     opener::open(&path).map_err(|e| e.to_string())?;
     let window_id = find_new_window(&before, 20);
+    place(window_id);
     track_opened_file(
         registry.inner(),
         "open-file".to_string(),
@@ -308,11 +425,16 @@ pub fn open_file(
 /// Run a shell script as a fire-and-forget detached process.
 ///
 /// Used by the right-panel "run in background" mode: the script is spawned with
-/// `bash <path>`, stdio fully detached, and is not tracked as a window or tab.
-/// No output is surfaced — callers that want to watch a script should open a
-/// terminal tab instead. When a `run_id` is supplied, a background thread waits
-/// for the process and emits a `script-finished` event (`{ runId, success }`)
-/// so the UI can show a running animation that clears on completion.
+/// stdio fully detached, and is not tracked as a window or tab. No output is
+/// surfaced — callers that want to watch a script should open a terminal tab
+/// instead. When a `run_id` is supplied, a background thread waits for the
+/// process and emits a `script-finished` event (`{ runId, success }`) so the UI
+/// can show a running animation that clears on completion.
+///
+/// On Linux/Unix the script is run with `bash <path>`. Windows has no `bash`, so
+/// [`windows_script_command`] picks an interpreter by extension (`.ps1` →
+/// PowerShell, everything else → `cmd /C`, which honours `.bat`/`.cmd` and the
+/// file's shell association) while still yielding a waitable child process.
 #[tauri::command]
 pub fn run_script_detached(
     app: tauri::AppHandle,
@@ -320,16 +442,24 @@ pub fn run_script_detached(
     cwd: Option<String>,
     run_id: Option<String>,
 ) -> Result<(), String> {
-    let mut cmd = Command::new("bash");
-    cmd.arg(&script_path);
+    #[cfg(target_os = "windows")]
+    let mut cmd = windows_script_command(&script_path);
+    #[cfg(not(target_os = "windows"))]
+    let mut cmd = {
+        let mut cmd = Command::new("bash");
+        cmd.arg(&script_path);
+        cmd
+    };
     if let Some(dir) = cwd.as_deref().filter(|d| !d.is_empty()) {
         cmd.current_dir(dir);
     }
     cmd.stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::null());
-    let mut child = cmd.spawn().map_err(|e| format!("run {script_path}: {e}"))?;
+    crate::paths::augment_command_path(&mut cmd);
+    let child = cmd.spawn().map_err(|e| format!("run {script_path}: {e}"))?;
     if let Some(run_id) = run_id {
+        let mut child = child;
         std::thread::spawn(move || {
             let success = child.wait().map(|s| s.success()).unwrap_or(false);
             let _ = app.emit(
@@ -337,6 +467,11 @@ pub fn run_script_detached(
                 serde_json::json!({ "runId": run_id, "success": success }),
             );
         });
+    } else {
+        std::thread::spawn(move || {
+            let mut child = child;
+            let _ = child.wait();
+        });
     }
     Ok(())
 }
@@ -365,13 +500,15 @@ pub const EMBEDDABLE_EXECS: &[&str] = &[
     "code", "blender",
 ];
 
-/// Whether `exec` (a path or bare command) names an embeddable app, matched by
-/// its basename against `EMBEDDABLE_EXECS`.
+/// Whether `exec` (a path, bare command, or multi-word launcher line) names an
+/// embeddable app, matched by the basename of its program (see
+/// [`split_exec_command`]) against `EMBEDDABLE_EXECS`.
 pub fn is_embeddable_exec(exec: &str) -> bool {
-    let base = Path::new(exec)
+    let (program, _) = split_exec_command(exec);
+    let base = Path::new(program)
         .file_name()
         .map(|n| n.to_string_lossy().to_lowercase())
-        .unwrap_or_else(|| exec.to_lowercase());
+        .unwrap_or_else(|| program.to_lowercase());
     EMBEDDABLE_EXECS.iter().any(|&e| e == base)
 }
 
@@ -413,48 +550,262 @@ pub fn resolve_default_handler(
 }
 
 /// System-default handler via `xdg-mime` → `.desktop` `Exec` first token.
+///
+/// Linux-only: `xdg-mime` and `.desktop` entries are a freedesktop concept. On
+/// other platforms this is a no-op (`None`) so the caller falls back to
+/// `opener::open` / the OS default.
 fn resolve_handler_via_mime(path: &str) -> Option<String> {
-    let mime = Command::new("xdg-mime")
-        .args(["query", "filetype", path])
-        .stdin(Stdio::null())
-        .stderr(Stdio::null())
-        .output()
-        .ok()
-        .filter(|o| o.status.success())
-        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
-        .filter(|s| !s.is_empty())?;
-    let desktop = Command::new("xdg-mime")
-        .args(["query", "default", &mime])
-        .stdin(Stdio::null())
-        .stderr(Stdio::null())
-        .output()
-        .ok()
-        .filter(|o| o.status.success())
-        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
-        .filter(|s| !s.is_empty())?;
-    // Locate the named .desktop file and pull its Exec first token.
-    for dir in desktop_app_dirs() {
-        let candidate = dir.join(&desktop);
-        if candidate.exists() {
-            if let Some(entry) = parse_desktop_entry(&candidate) {
-                return Some(entry.exec);
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = path;
+        None
+    }
+    #[cfg(target_os = "linux")]
+    {
+        let mime = Command::new("xdg-mime")
+            .args(["query", "filetype", path])
+            .stdin(Stdio::null())
+            .stderr(Stdio::null())
+            .output()
+            .ok()
+            .filter(|o| o.status.success())
+            .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+            .filter(|s| !s.is_empty())?;
+        let desktop = Command::new("xdg-mime")
+            .args(["query", "default", &mime])
+            .stdin(Stdio::null())
+            .stderr(Stdio::null())
+            .output()
+            .ok()
+            .filter(|o| o.status.success())
+            .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+            .filter(|s| !s.is_empty())?;
+        // Locate the named .desktop file and pull its Exec first token.
+        for dir in desktop_app_dirs() {
+            let candidate = dir.join(&desktop);
+            if candidate.exists() {
+                if let Some(entry) = parse_desktop_entry(&candidate) {
+                    return Some(entry.exec);
+                }
             }
         }
+        None
     }
-    None
 }
 
-fn desktop_app_dirs() -> Vec<PathBuf> {
-    let mut dirs = vec![
-        PathBuf::from("/usr/share/applications"),
-        PathBuf::from("/usr/local/share/applications"),
-    ];
-    if let Some(home) = std::env::var_os("HOME") {
-        dirs.insert(0, PathBuf::from(home).join(".local/share/applications"));
+/// XDG application directories, in precedence order: `$XDG_DATA_HOME/applications`
+/// (falling back to `~/.local/share/applications`), then each dir in
+/// `$XDG_DATA_DIRS` (falling back to `/usr/local/share:/usr/share`) joined with
+/// `applications`. Respecting `XDG_DATA_DIRS` (rather than hardcoding just
+/// `/usr/share` + `/usr/local/share`) is what picks up Flatpak/Snap exports
+/// (e.g. `/var/lib/flatpak/exports/share`), which the desktop session already
+/// adds to that variable.
+fn xdg_application_dirs() -> Vec<PathBuf> {
+    let mut dirs = Vec::new();
+    let data_home = std::env::var_os("XDG_DATA_HOME")
+        .map(PathBuf::from)
+        .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".local/share")));
+    if let Some(home) = data_home {
+        dirs.push(home.join("applications"));
+    }
+    let data_dirs = std::env::var("XDG_DATA_DIRS")
+        .ok()
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| "/usr/local/share:/usr/share".to_string());
+    for dir in data_dirs.split(':').filter(|s| !s.is_empty()) {
+        dirs.push(PathBuf::from(dir).join("applications"));
     }
+    let mut seen = std::collections::HashSet::new();
+    dirs.retain(|d| seen.insert(d.clone()));
     dirs
 }
 
+/// Linux-only after the mime-resolver was platform-gated; the icon resolver still
+/// uses the separate `desktop_files`, so keep this compiled but quiet elsewhere.
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+fn desktop_app_dirs() -> Vec<PathBuf> {
+    xdg_application_dirs()
+}
+
+/// Return the native file-drag preview icon as a PNG `data:` URL.
+///
+/// `tauri-plugin-drag`'s `startDrag` icon field is deserialized through an
+/// untagged enum whose only string form is a base64 PNG **data URL**
+/// (`data:image/png;base64,…`) — a bare file path fails to deserialize and the
+/// whole drag command rejects before it starts. So embed the app icon at compile
+/// time and hand back a data URL the frontend can pass straight to `startDrag`.
+#[tauri::command]
+pub fn drag_preview_icon() -> String {
+    use base64::Engine;
+    const ICON_PNG: &[u8] = include_bytes!("../../icons/128x128.png");
+    let b64 = base64::engine::general_purpose::STANDARD.encode(ICON_PNG);
+    format!("data:image/png;base64,{b64}")
+}
+
+#[cfg(target_os = "linux")]
+thread_local! {
+    /// The in-flight GTK drag, so `cancel_file_drag` can abort it when the
+    /// cursor comes back into the window. GTK/GDK objects are not `Send`, and
+    /// every access is on the GTK main thread (sync Tauri commands and GTK
+    /// signal handlers both run there), so a thread-local is the right home.
+    static ACTIVE_DRAG: std::cell::RefCell<Option<gtk::gdk::DragContext>> =
+        const { std::cell::RefCell::new(None) };
+    /// Set by `cancel_file_drag` so the `cancel` signal it provokes is
+    /// recognised as OURS: the gesture is being handed back to the in-app drag
+    /// and is NOT over, so it must not emit `FILE_DRAG_ENDED`.
+    static CANCEL_REQUESTED: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+/// Emitted when a native drag reaches its true end (dropped, failed, or
+/// cancelled by the user/WM). The frontend keeps a gesture alive across the
+/// handoff, so it needs to hear the end from the OS: once GTK owns the pointer,
+/// the webview never sees the `pointerup` that would otherwise end it.
+#[cfg(target_os = "linux")]
+pub const FILE_DRAG_ENDED: &str = "eldrun:file-drag-ended";
+
+/// Start a native OS drag-out of `paths` from the calling window (Linux/GTK).
+///
+/// Replaces `tauri-plugin-drag`'s GTK path for the Ctrl-drag file export. That
+/// path LOOKS right (OS drag icon, drop animation) but delivers an empty
+/// payload to external targets: it disconnects its `drag-data-get` handler on
+/// `drop-performed` — emitted at the instant of the drop, BEFORE the target
+/// asynchronously requests the `text/uri-list` selection — so a browser's or
+/// file manager's data request finds no provider and the drop silently does
+/// nothing. It also builds `file://{path}` with no percent-encoding (a space
+/// in the name yields an invalid URI strict consumers discard) and passes
+/// `GDK_BUTTON1_MASK` (256) where GTK expects the button NUMBER (1).
+///
+/// Here URIs are encoded canonically (`glib::filename_to_uri`) and teardown is
+/// deferred to `dnd-finished` (the target has read the data), with `cancel` /
+/// `drag-failed` covering the abort paths. Windows/macOS keep the plugin
+/// (their OLE/NSDragging backends are sound).
+///
+/// Deliberately a SYNC command: Tauri dispatches those on the main (GTK)
+/// thread, which is exactly where every call below must run.
+#[cfg(target_os = "linux")]
+#[tauri::command]
+pub fn start_file_drag(window: tauri::Window, paths: Vec<String>) -> Result<(), String> {
+    use gtk::{gdk, glib, prelude::*};
+    use std::cell::RefCell;
+    use std::rc::Rc;
+
+    if paths.is_empty() {
+        return Err("start_file_drag: no paths".into());
+    }
+    let uris: Vec<String> = paths
+        .iter()
+        .map(|p| {
+            glib::filename_to_uri(p, None)
+                .map(|u| u.to_string())
+                .map_err(|e| format!("start_file_drag: invalid path {p:?}: {e}"))
+        })
+        .collect::<Result<_, _>>()?;
+
+    let win = window.gtk_window().map_err(|e| e.to_string())?;
+    win.drag_source_set(gdk::ModifierType::BUTTON1_MASK, &[], gdk::DragAction::COPY);
+    win.drag_source_add_uri_targets();
+
+    // Window-level signal handlers live until an end-of-drag signal fires;
+    // the drag-data-get one MUST survive past the drop itself (see above).
+    let handler_ids: Rc<RefCell<Vec<glib::SignalHandlerId>>> = Rc::new(RefCell::new(Vec::new()));
+    {
+        let uris = uris.clone();
+        handler_ids
+            .borrow_mut()
+            .push(win.connect_drag_data_get(move |_, _, data, _, _| {
+                let refs: Vec<&str> = uris.iter().map(String::as_str).collect();
+                data.set_uris(&refs);
+            }));
+    }
+
+    let target_list = win
+        .drag_source_get_target_list()
+        .ok_or("start_file_drag: empty target list")?;
+    let context = win
+        .drag_begin_with_coordinates(&target_list, gdk::DragAction::COPY, 1, None, -1, -1)
+        .ok_or("start_file_drag: drag_begin refused (no pointer grab?)")?;
+    ACTIVE_DRAG.with(|c| *c.borrow_mut() = Some(context.clone()));
+
+    // Idempotent teardown shared by every end-of-drag signal — a cancelled drag
+    // can raise more than one of them for the same gesture. `ours` marks the
+    // cancel WE asked for (handing the gesture back to the in-app drag): the
+    // GTK drag is over, but the user's gesture is not, so no end event.
+    let cleanup = {
+        let win = win.clone();
+        let window = window.clone();
+        let handler_ids = handler_ids.clone();
+        move || {
+            for id in handler_ids.borrow_mut().drain(..) {
+                win.disconnect(id);
+            }
+            win.drag_source_unset();
+            ACTIVE_DRAG.with(|c| *c.borrow_mut() = None);
+            let ours = CANCEL_REQUESTED.with(|f| f.replace(false));
+            if !ours {
+                use tauri::Emitter;
+                let _ = window.emit(FILE_DRAG_ENDED, ());
+            }
+        }
+    };
+    {
+        let cleanup = cleanup.clone();
+        context.connect_dnd_finished(move |_| cleanup());
+    }
+    {
+        let cleanup = cleanup.clone();
+        context.connect_cancel(move |_, _| cleanup());
+    }
+    {
+        let cleanup = cleanup.clone();
+        let id = win.connect_drag_failed(move |_, _, _| {
+            cleanup();
+            // Proceed keeps GTK's snap-back animation for the failed drop.
+            glib::Propagation::Proceed
+        });
+        handler_ids.borrow_mut().push(id);
+    }
+
+    // Same OS drag icon the plugin path used (the app icon).
+    const ICON_PNG: &[u8] = include_bytes!("../../icons/128x128.png");
+    let loader = gtk::gdk_pixbuf::PixbufLoader::new();
+    if loader.write(ICON_PNG).and_then(|_| loader.close()).is_ok() {
+        if let Some(pixbuf) = loader.pixbuf() {
+            context.drag_set_icon_pixbuf(&pixbuf, 0, 0);
+        }
+    }
+    Ok(())
+}
+
+/// Abort the in-flight native drag, handing the still-held button back to the
+/// in-app pointer drag (the cursor re-entered the Eldrun window, so the ghost
+/// and hover take over again from the OS drag icon). A no-op when no native
+/// drag is running, so the frontend can call it unconditionally.
+#[cfg(target_os = "linux")]
+#[tauri::command]
+pub fn cancel_file_drag() {
+    use gtk::prelude::DragContextExtManual;
+    let Some(context) = ACTIVE_DRAG.with(|c| c.borrow().clone()) else {
+        return;
+    };
+    // Read back in `cleanup` (via the `cancel` signal this raises) to tell our
+    // own abort apart from a real one.
+    CANCEL_REQUESTED.with(|f| f.set(true));
+    context.drag_cancel();
+}
+
+#[cfg(not(target_os = "linux"))]
+#[tauri::command]
+pub fn cancel_file_drag() {}
+
+/// Non-Linux stub so the command registers everywhere; the frontend only
+/// routes to it on Linux (Windows/macOS stay on `tauri-plugin-drag`).
+#[cfg(not(target_os = "linux"))]
+#[tauri::command]
+pub fn start_file_drag(paths: Vec<String>) -> Result<(), String> {
+    let _ = paths;
+    Err("start_file_drag is Linux-only; use tauri-plugin-drag".into())
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EmbedCapability {
     /// OS can host an embedded frameless window (X11 backend, not XWayland).
@@ -530,47 +881,164 @@ fn project_apps_for_id(project_id: Option<&str>) -> HashMap<String, String> {
 pub struct InstalledApp {
     /// Display name (`Name=` from the `.desktop` entry).
     pub name: String,
-    /// Launch executable (first non-`%` token of `Exec=`).
+    /// Launch command line, parsed from `Exec=` with desktop field codes
+    /// (`%f`/`%U`/...) and Flatpak's `@@` quoting markers stripped. Kept as the
+    /// full command line (not just the first token) so multi-word launchers like
+    /// `flatpak run --branch=stable --command=... app.id` still work — see
+    /// [`parse_exec_command`].
     pub exec: String,
     /// Raw `Icon=` value (theme name or path); the frontend resolves it lazily.
     pub icon: Option<String>,
 }
 
-/// List installed applications by scanning `.desktop` entries in the standard
-/// application directories. Powers the search box in the "set default app"
-/// dialog. Skips hidden entries (`NoDisplay=true`) and non-`Application` types,
-/// dedupes by executable basename (user dirs take precedence), sorted by name.
+/// List installed applications, powering the search box in the "set default app"
+/// dialog. On Linux this scans `.desktop` entries in the standard application
+/// directories (skipping hidden entries and non-`Application` types, deduped by
+/// executable basename with user dirs taking precedence); on Windows it
+/// enumerates Start-Menu shortcuts. Sorted by name.
 #[tauri::command]
 pub fn list_installed_apps() -> Vec<InstalledApp> {
+    #[cfg(target_os = "windows")]
+    {
+        return windows_installed_apps();
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos_installed_apps();
+    }
+    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+    {
+        let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
+        let mut apps: Vec<InstalledApp> = Vec::new();
+        for dir in desktop_app_dirs() {
+            let Ok(entries) = fs::read_dir(&dir) else {
+                continue;
+            };
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.extension().and_then(|e| e.to_str()) != Some("desktop") {
+                    continue;
+                }
+                if let Some(app) = parse_installed_app(&path) {
+                    let key = Path::new(&app.exec)
+                        .file_name()
+                        .map(|n| n.to_string_lossy().to_lowercase())
+                        .unwrap_or_else(|| app.exec.to_lowercase());
+                    if seen.insert(key) {
+                        apps.push(app);
+                    }
+                }
+            }
+        }
+        apps.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+        apps
+    }
+}
+
+/// Windows installed-app list: every Start-Menu `.lnk` shortcut, mapped to its
+/// display name and resolved target executable (which is what the picker stores
+/// and later launches). Deduped by target-exe path (case-insensitive), sorted by
+/// name. The icon is left to lazy resolution via [`resolve_app_icon`].
+#[cfg(target_os = "windows")]
+fn windows_installed_apps() -> Vec<InstalledApp> {
     let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
     let mut apps: Vec<InstalledApp> = Vec::new();
-    for dir in desktop_app_dirs() {
-        let Ok(entries) = fs::read_dir(&dir) else {
+    for shortcut in windows_shortcuts() {
+        let exec = shortcut.target_path.to_string_lossy().into_owned();
+        if exec.trim().is_empty() {
+            continue;
+        }
+        if seen.insert(exec.to_lowercase()) {
+            apps.push(InstalledApp {
+                name: shortcut.display_name,
+                exec,
+                icon: None,
+            });
+        }
+    }
+    apps.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+    apps
+}
+
+/// macOS installed-app list from each bundle's Info.plist. The picker persists
+/// the bundle path so launch goes through LaunchServices.
+#[cfg(target_os = "macos")]
+fn macos_installed_apps() -> Vec<InstalledApp> {
+    let mut roots = vec![
+        PathBuf::from("/Applications"),
+        PathBuf::from("/System/Applications"),
+        PathBuf::from("/System/Applications/Utilities"),
+    ];
+    if let Some(home) = std::env::var_os("HOME") {
+        roots.insert(0, PathBuf::from(home).join("Applications"));
+    }
+
+    macos_installed_apps_in(&roots)
+}
+
+#[cfg(target_os = "macos")]
+fn macos_installed_apps_in(roots: &[PathBuf]) -> Vec<InstalledApp> {
+    let mut seen = std::collections::HashSet::new();
+    let mut apps: Vec<InstalledApp> = Vec::new();
+    for root in roots {
+        let Ok(entries) = fs::read_dir(&root) else {
             continue;
         };
         for entry in entries.flatten() {
             let path = entry.path();
-            if path.extension().and_then(|e| e.to_str()) != Some("desktop") {
+            if path.extension().and_then(|e| e.to_str()) != Some("app") {
                 continue;
             }
-            if let Some(app) = parse_installed_app(&path) {
-                let key = Path::new(&app.exec)
-                    .file_name()
-                    .map(|n| n.to_string_lossy().to_lowercase())
-                    .unwrap_or_else(|| app.exec.to_lowercase());
-                if seen.insert(key) {
-                    apps.push(app);
-                }
+            let Some(app) = parse_macos_app_bundle(&path) else {
+                continue;
+            };
+            if !seen.insert(app.exec.to_lowercase()) {
+                continue;
             }
+            apps.push(app);
         }
     }
     apps.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
     apps
 }
 
+#[cfg(target_os = "macos")]
+fn parse_macos_app_bundle(app: &Path) -> Option<InstalledApp> {
+    let plist = plist::Value::from_file(app.join("Contents").join("Info.plist")).ok()?;
+    let dict = plist.as_dictionary()?;
+    let executable = dict.get("CFBundleExecutable")?.as_string()?.trim();
+    if executable.is_empty()
+        || !app
+            .join("Contents")
+            .join("MacOS")
+            .join(executable)
+            .is_file()
+    {
+        return None;
+    }
+    let name = ["CFBundleDisplayName", "CFBundleName"]
+        .iter()
+        .find_map(|key| dict.get(*key).and_then(plist::Value::as_string))
+        .map(str::trim)
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
+        .or_else(|| {
+            app.file_stem()
+                .map(|name| name.to_string_lossy().into_owned())
+        })?;
+    Some(InstalledApp {
+        name,
+        exec: app.to_string_lossy().into_owned(),
+        icon: None,
+    })
+}
+
 /// Parse a single `.desktop` file into an `InstalledApp`, or `None` when it is
 /// hidden, not an application, or has no `Exec`. First value of each key wins so
 /// the unlocalized `Name=`/`Exec=` take precedence over later `[Action]` groups.
+/// Linux-only (Windows lists Start-Menu shortcuts instead); kept compiled for the
+/// shared unit tests.
+#[cfg_attr(not(any(test, target_os = "linux")), allow(dead_code))]
 fn parse_installed_app(path: &Path) -> Option<InstalledApp> {
     let content = fs::read_to_string(path).ok()?;
     let mut in_entry = false;
@@ -594,7 +1062,7 @@ fn parse_installed_app(path: &Path) -> Option<InstalledApp> {
             }
         } else if let Some(v) = line.strip_prefix("Exec=") {
             if exec.is_none() {
-                exec = first_exec_token(v);
+                exec = parse_exec_command(v);
             }
         } else if let Some(v) = line.strip_prefix("Icon=") {
             if icon.is_none() {
@@ -704,6 +1172,33 @@ fn resolve_windows_launch_exec(exec: &str) -> Option<String> {
         .map(|shortcut| shortcut.target_path.to_string_lossy().into_owned())
 }
 
+/// Build the [`Command`] that runs `script_path` on Windows, choosing an
+/// interpreter by extension: `.ps1` is run through PowerShell with an execution
+/// policy bypass; anything else is handed to `cmd /C`, which executes `.bat`/
+/// `.cmd` directly and otherwise opens the file via its shell association. Either
+/// way the returned command spawns a child whose exit status the caller can wait
+/// on for the `script-finished` event.
+#[cfg(target_os = "windows")]
+fn windows_script_command(script_path: &str) -> Command {
+    let is_ps1 = Path::new(script_path)
+        .extension()
+        .and_then(|ext| ext.to_str())
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("ps1"));
+    // `command_no_window` sets CREATE_NO_WINDOW so a background "run script"
+    // action doesn't pop a transient console window — its output is intentionally
+    // not surfaced (callers wanting output open a terminal tab instead).
+    if is_ps1 {
+        let mut cmd = crate::paths::command_no_window("powershell");
+        cmd.args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-File"]);
+        cmd.arg(script_path);
+        cmd
+    } else {
+        let mut cmd = crate::paths::command_no_window("cmd");
+        cmd.args(["/C", script_path]);
+        cmd
+    }
+}
+
 #[cfg(target_os = "windows")]
 fn resolve_windows_app_icon(exec: &str) -> Option<String> {
     let direct = PathBuf::from(exec.trim_matches('"'));
@@ -782,10 +1277,10 @@ fn collect_windows_shortcuts(dir: &Path, depth: usize, out: &mut Vec<ShortcutEnt
 
 #[cfg(target_os = "windows")]
 fn resolve_windows_shortcut(path: &Path) -> Option<ShortcutEntry> {
-    use windows::core::{Interface, PCWSTR, PWSTR};
+    use windows::core::{Interface, PCWSTR};
     use windows::Win32::System::Com::{
         CoCreateInstance, CoInitializeEx, IPersistFile, CLSCTX_INPROC_SERVER,
-        COINIT_APARTMENTTHREADED,
+        COINIT_APARTMENTTHREADED, STGM_READ,
     };
     use windows::Win32::UI::Shell::{IShellLinkW, ShellLink};
 
@@ -794,26 +1289,17 @@ fn resolve_windows_shortcut(path: &Path) -> Option<ShortcutEntry> {
         let link: IShellLinkW = CoCreateInstance(&ShellLink, None, CLSCTX_INPROC_SERVER).ok()?;
         let persist: IPersistFile = link.cast().ok()?;
         let wide = wide_null(path.as_os_str());
-        persist.Load(PCWSTR(wide.as_ptr()), 0).ok()?;
+        persist.Load(PCWSTR(wide.as_ptr()), STGM_READ).ok()?;
 
         let mut target_buf = [0u16; 32768];
-        link.GetPath(
-            PWSTR(target_buf.as_mut_ptr()),
-            target_buf.len() as i32,
-            None,
-            0,
-        )
-        .ok()?;
+        link.GetPath(&mut target_buf, std::ptr::null_mut(), 0)
+            .ok()?;
         let target = utf16_buf_to_path(&target_buf)?;
 
         let mut icon_buf = [0u16; 32768];
         let mut icon_index = 0i32;
         let icon_path = link
-            .GetIconLocation(
-                PWSTR(icon_buf.as_mut_ptr()),
-                icon_buf.len() as i32,
-                &mut icon_index,
-            )
+            .GetIconLocation(&mut icon_buf, &mut icon_index)
             .ok()
             .and_then(|_| utf16_buf_to_path(&icon_buf));
 
@@ -828,16 +1314,179 @@ fn resolve_windows_shortcut(path: &Path) -> Option<ShortcutEntry> {
 
 #[cfg(target_os = "windows")]
 fn windows_icon_to_data_url(path: &Path) -> Option<String> {
+    // A raster `.png` is already a valid `<img>` source, so inline it directly
+    // with the correct MIME. Everything else — `.exe`/`.dll` (no embedded raster),
+    // `.ico` (whose `image/png` mislabel did not render reliably), or an extension-
+    // less target — is rasterized through the shell to a real PNG data URL below.
+    // Returning a bare filesystem path here (the prior behaviour) produced an
+    // `<img src="C:\...\app.exe">` the WebView cannot load, hence blank icons.
     if path
         .extension()
         .and_then(|ext| ext.to_str())
-        .map_or(false, |ext| {
-            ext.eq_ignore_ascii_case("png") || ext.eq_ignore_ascii_case("ico")
-        })
+        .map_or(false, |ext| ext.eq_ignore_ascii_case("png"))
     {
         return icon_to_data_url(path);
     }
-    Some(path.to_string_lossy().into_owned())
+    extract_windows_icon_png(path)
+}
+
+/// Rasterize the shell icon for `path` (an `.exe`/`.ico`/`.dll`/associated file)
+/// to a base64 PNG data URL via GDI. Returns `None` on any failure so the
+/// frontend falls back to its glyph rather than rendering a broken image. Every
+/// GDI/shell handle acquired here is released on all paths.
+#[cfg(target_os = "windows")]
+fn extract_windows_icon_png(path: &Path) -> Option<String> {
+    use windows::core::PCWSTR;
+    use windows::Win32::Storage::FileSystem::FILE_FLAGS_AND_ATTRIBUTES;
+    use windows::Win32::UI::Shell::{SHGetFileInfoW, SHFILEINFOW, SHGFI_ICON, SHGFI_LARGEICON};
+    use windows::Win32::UI::WindowsAndMessaging::DestroyIcon;
+
+    // SAFETY: the HICON returned in `info.hIcon` is destroyed before returning on
+    // both the success and failure paths.
+    unsafe {
+        let wide = wide_null(path.as_os_str());
+        let mut info = SHFILEINFOW::default();
+        let res = SHGetFileInfoW(
+            PCWSTR(wide.as_ptr()),
+            FILE_FLAGS_AND_ATTRIBUTES(0),
+            Some(&mut info),
+            std::mem::size_of::<SHFILEINFOW>() as u32,
+            SHGFI_ICON | SHGFI_LARGEICON,
+        );
+        if res == 0 || info.hIcon.is_invalid() {
+            return None;
+        }
+        let rgba = hicon_to_rgba(info.hIcon);
+        let _ = DestroyIcon(info.hIcon);
+        let (width, height, pixels) = rgba?;
+        encode_png_data_url(width, height, &pixels)
+    }
+}
+
+/// Convert an `HICON` to a top-down RGBA buffer `(width, height, pixels)`. The
+/// icon's color bitmap supplies BGR (and per-pixel alpha for modern 32-bit
+/// icons); when that alpha channel is entirely zero — legacy icons — opacity is
+/// reconstructed from the 1-bpp AND mask instead. The color/mask GDI bitmaps from
+/// `GetIconInfo` are deleted on every path.
+#[cfg(target_os = "windows")]
+unsafe fn hicon_to_rgba(
+    hicon: windows::Win32::UI::WindowsAndMessaging::HICON,
+) -> Option<(u32, u32, Vec<u8>)> {
+    use std::ffi::c_void;
+    use windows::Win32::Graphics::Gdi::{
+        DeleteObject, GetDC, GetDIBits, GetObjectW, ReleaseDC, BITMAP, BITMAPINFO,
+        BITMAPINFOHEADER, BI_RGB, DIB_RGB_COLORS, HGDIOBJ,
+    };
+    use windows::Win32::UI::WindowsAndMessaging::{GetIconInfo, ICONINFO};
+
+    let mut icon_info = ICONINFO::default();
+    if GetIconInfo(hicon, &mut icon_info).is_err() {
+        return None;
+    }
+    let color = icon_info.hbmColor;
+    let mask = icon_info.hbmMask;
+
+    let result = (|| {
+        if color.is_invalid() {
+            return None;
+        }
+        let mut bmp = BITMAP::default();
+        let got = GetObjectW(
+            HGDIOBJ(color.0),
+            std::mem::size_of::<BITMAP>() as i32,
+            Some(&mut bmp as *mut BITMAP as *mut c_void),
+        );
+        if got == 0 || bmp.bmWidth <= 0 || bmp.bmHeight <= 0 {
+            return None;
+        }
+        let width = bmp.bmWidth;
+        let height = bmp.bmHeight;
+        let pixel_count = (width as usize) * (height as usize);
+
+        // Negative biHeight requests top-down rows (the order the PNG encoder
+        // wants); 32-bit BI_RGB unpacks any source depth to BGRA scanlines.
+        let header = BITMAPINFOHEADER {
+            biSize: std::mem::size_of::<BITMAPINFOHEADER>() as u32,
+            biWidth: width,
+            biHeight: -height,
+            biPlanes: 1,
+            biBitCount: 32,
+            biCompression: BI_RGB.0 as u32,
+            ..Default::default()
+        };
+
+        let dc = GetDC(None);
+        if dc.is_invalid() {
+            return None;
+        }
+
+        let read_dib = |hbm: windows::Win32::Graphics::Gdi::HBITMAP, buf: &mut [u8]| -> bool {
+            let mut info = BITMAPINFO {
+                bmiHeader: header,
+                ..Default::default()
+            };
+            GetDIBits(
+                dc,
+                hbm,
+                0,
+                height as u32,
+                Some(buf.as_mut_ptr() as *mut c_void),
+                &mut info,
+                DIB_RGB_COLORS,
+            ) != 0
+        };
+
+        let mut pixels = vec![0u8; pixel_count * 4];
+        let outcome = (|| {
+            if !read_dib(color, &mut pixels) {
+                return None;
+            }
+            // Reconstruct alpha from the AND mask when the color bitmap carries
+            // none (mask: 0 = opaque, white = transparent).
+            if !pixels.chunks_exact(4).any(|px| px[3] != 0) && !mask.is_invalid() {
+                let mut mask_px = vec![0u8; pixel_count * 4];
+                if read_dib(mask, &mut mask_px) {
+                    for (px, m) in pixels.chunks_exact_mut(4).zip(mask_px.chunks_exact(4)) {
+                        px[3] = if m[0] == 0 { 0xFF } else { 0x00 };
+                    }
+                } else {
+                    for px in pixels.chunks_exact_mut(4) {
+                        px[3] = 0xFF;
+                    }
+                }
+            }
+            // GDI delivers BGRA; the PNG encoder wants RGBA.
+            for px in pixels.chunks_exact_mut(4) {
+                px.swap(0, 2);
+            }
+            Some((width as u32, height as u32, pixels))
+        })();
+
+        ReleaseDC(None, dc);
+        outcome
+    })();
+
+    if !color.is_invalid() {
+        let _ = DeleteObject(HGDIOBJ(color.0));
+    }
+    if !mask.is_invalid() {
+        let _ = DeleteObject(HGDIOBJ(mask.0));
+    }
+    result
+}
+
+/// Encode a top-down RGBA buffer to a base64 `data:image/png` URL in memory.
+#[cfg(target_os = "windows")]
+fn encode_png_data_url(width: u32, height: u32, rgba: &[u8]) -> Option<String> {
+    let mut buf = Vec::new();
+    {
+        let mut encoder = png::Encoder::new(&mut buf, width, height);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        let mut writer = encoder.write_header().ok()?;
+        writer.write_image_data(rgba).ok()?;
+    }
+    Some(format!("data:image/png;base64,{}", base64_encode(&buf)))
 }
 
 #[cfg(target_os = "windows")]
@@ -857,17 +1506,9 @@ fn utf16_buf_to_path(buf: &[u16]) -> Option<PathBuf> {
 }
 
 fn desktop_files() -> Vec<PathBuf> {
-    let mut dirs = vec![
-        PathBuf::from("/usr/share/applications"),
-        PathBuf::from("/usr/local/share/applications"),
-    ];
-    if let Some(home) = std::env::var_os("HOME") {
-        dirs.insert(0, PathBuf::from(home).join(".local/share/applications"));
-    }
-
     let mut files = Vec::new();
-    for dir in dirs {
-        let Ok(entries) = fs::read_dir(dir) else {
+    for dir in xdg_application_dirs() {
+        let Ok(entries) = fs::read_dir(&dir) else {
             continue;
         };
         for entry in entries.flatten() {
@@ -895,7 +1536,7 @@ fn parse_desktop_entry(path: &Path) -> Option<DesktopEntry> {
             continue;
         }
         if let Some(value) = line.strip_prefix("Exec=") {
-            exec = first_exec_token(value);
+            exec = parse_exec_command(value);
         } else if let Some(value) = line.strip_prefix("Icon=") {
             icon = Some(value.to_string());
         }
@@ -906,16 +1547,27 @@ fn parse_desktop_entry(path: &Path) -> Option<DesktopEntry> {
     })
 }
 
-pub(crate) fn first_exec_token(value: &str) -> Option<String> {
-    let first = value
+/// Parse a desktop-entry `Exec=` value into the literal command line to launch.
+///
+/// Desktop field codes (`%f`, `%U`, `%i`, ...) are placeholders the file/URL
+/// argument fills in separately (see `file` in [`launch_command`]), and
+/// Flatpak's `@@...@@` quoting markers wrap those placeholders, so both are
+/// dropped. Every remaining token is kept and rejoined with single spaces —
+/// unlike a first-token-only parse, this preserves multi-word launchers such as
+/// Flatpak's `flatpak run --branch=stable --command=entrypoint app.id`, which
+/// would otherwise be truncated to a bare `flatpak` with no way to know which
+/// app to run.
+pub(crate) fn parse_exec_command(value: &str) -> Option<String> {
+    let tokens: Vec<&str> = value
         .split_whitespace()
-        .find(|part| !part.starts_with('%'))?
-        .trim_matches('"')
-        .to_string();
-    if first.is_empty() {
+        .filter(|part| !part.starts_with('%') && !part.starts_with("@@"))
+        .map(|part| part.trim_matches('"'))
+        .filter(|part| !part.is_empty())
+        .collect();
+    if tokens.is_empty() {
         None
     } else {
-        Some(first)
+        Some(tokens.join(" "))
     }
 }
 
@@ -1002,19 +1654,44 @@ pub fn untrack_window(registry: State<'_, WindowRegistryState>, id: String) -> b
 
 #[tauri::command]
 pub fn check_pid_alive(pid: u32) -> bool {
+    if pid == 0 {
+        return false;
+    }
     if cfg!(target_os = "linux") {
         std::path::Path::new(&format!("/proc/{pid}")).exists()
     } else if cfg!(target_os = "windows") {
-        // tasklist /FI "PID eq <pid>" exits 0 even if the PID is not found;
-        // check that the PID number appears in the output instead.
-        std::process::Command::new("tasklist")
-            .args(["/FI", &format!("PID eq {}", pid), "/NH", "/FO", "CSV"])
-            .output()
-            .map(|o| {
-                let out = String::from_utf8_lossy(&o.stdout);
-                out.contains(&format!(",\"{}\",", pid))
-            })
-            .unwrap_or(false)
+        // Native liveness check: open the process and read its exit code.
+        // STILL_ACTIVE (259) means the process is still running. A handle to an
+        // already-exited process still opens successfully but GetExitCodeProcess
+        // then reports the real exit code, so OpenProcess succeeding alone is not
+        // enough — we must inspect the code. A failed OpenProcess (e.g. the PID
+        // no longer exists) is treated as dead.
+        #[cfg(target_os = "windows")]
+        {
+            use windows::Win32::Foundation::CloseHandle;
+            use windows::Win32::System::Threading::{
+                GetExitCodeProcess, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
+            };
+            const STILL_ACTIVE: u32 = 259;
+            unsafe {
+                match OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid) {
+                    Ok(handle) => {
+                        let mut code: u32 = 0;
+                        let alive =
+                            GetExitCodeProcess(handle, &mut code).is_ok() && code == STILL_ACTIVE;
+                        let _ = CloseHandle(handle);
+                        alive
+                    }
+                    Err(_) => false,
+                }
+            }
+        }
+        // On non-Windows targets this branch is never taken at runtime; the
+        // `false` keeps the expression well-typed when the cfg above is absent.
+        #[cfg(not(target_os = "windows"))]
+        {
+            false
+        }
     } else {
         // macOS / non-Linux Unix: kill(pid, 0) returns 0 if process exists.
         // On non-Unix platforms this branch is never reached (Windows is
@@ -1109,7 +1786,12 @@ fn list_window_ids() -> Vec<u64> {
     crate::platform::windows::list_window_ids()
 }
 
-#[cfg(not(any(target_os = "linux", target_os = "windows")))]
+#[cfg(target_os = "macos")]
+fn list_window_ids() -> Vec<u64> {
+    crate::platform::macos::list_window_ids()
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
 fn list_window_ids() -> Vec<u64> {
     Vec::new()
 }
@@ -1135,7 +1817,31 @@ fn find_window_for_pid(pid: u32, attempts: usize) -> Option<u64> {
     crate::platform::windows::find_window_for_pid(pid, attempts)
 }
 
-#[cfg(not(any(target_os = "linux", target_os = "windows")))]
+#[cfg(target_os = "macos")]
+fn find_window_for_pid(pid: u32, attempts: usize) -> Option<u64> {
+    crate::platform::macos::find_window_for_pid(pid, attempts)
+}
+
+/// Single-pass, non-blocking window-id resolver injected into `window_service`
+/// at project-switch (hide) time. A launch-time miss (race, or the visible
+/// top-level belonging to a child of the spawned pid) leaves `window_id` None;
+/// re-resolving here just before hiding lets such a window still be parked, and
+/// the back-populated id keeps the later switch-back SHOW symmetric. `attempts:
+/// 1` does one enumeration with no `thread::sleep`, so it never stalls the
+/// switch worker.
+#[cfg(target_os = "windows")]
+pub fn resolve_window_id_for_pid(pid: u32) -> Option<u64> {
+    crate::platform::windows::find_window_for_pid(pid, 1)
+}
+
+/// macOS twin of the Windows resolver above — the launcher-stub → child-pid
+/// hand-off happens with `open`-style launches too.
+#[cfg(target_os = "macos")]
+pub fn resolve_window_id_for_pid(pid: u32) -> Option<u64> {
+    crate::platform::macos::find_window_for_pid(pid, 1)
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
 fn find_window_for_pid(_pid: u32, _attempts: usize) -> Option<u64> {
     None
 }
@@ -1161,7 +1867,12 @@ fn find_new_window(before: &[u64], attempts: usize) -> Option<u64> {
     crate::platform::windows::find_new_window(before, attempts)
 }
 
-#[cfg(not(any(target_os = "linux", target_os = "windows")))]
+#[cfg(target_os = "macos")]
+fn find_new_window(before: &[u64], attempts: usize) -> Option<u64> {
+    crate::platform::macos::find_new_window(before, attempts)
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
 fn find_new_window(_before: &[u64], _attempts: usize) -> Option<u64> {
     None
 }
@@ -1354,22 +2065,16 @@ mod tests {
     }
 
     #[test]
-    fn base64_roundtrip_via_stdlib() {
-        use std::process::Command;
-        // Cross-check against system base64 on Linux.
+    fn base64_roundtrip_via_reference_crate() {
+        use base64::Engine;
+
         let input = b"Eldrun workspace manager";
         let encoded = base64_encode(input);
+        let decoded = base64::engine::general_purpose::STANDARD
+            .decode(encoded)
+            .expect("custom encoder should produce valid base64");
 
-        // Use base64 --decode via shell to verify correctness.
-        if let Ok(out) = Command::new("sh")
-            .arg("-c")
-            .arg(format!("echo -n '{encoded}' | base64 -d"))
-            .output()
-        {
-            if out.status.success() {
-                assert_eq!(out.stdout, input.as_ref());
-            }
-        }
+        assert_eq!(decoded, input.as_ref());
     }
 
     #[test]
@@ -1416,52 +2121,101 @@ mod tests {
         );
     }
 
-    // ── first_exec_token ───────────────────────────────────────────────────
+    // ── parse_exec_command ──────────────────────────────────────────────────
 
     #[test]
-    fn first_exec_token_plain_path() {
+    fn parse_exec_command_plain_path() {
         assert_eq!(
-            first_exec_token("/usr/bin/firefox"),
+            parse_exec_command("/usr/bin/firefox"),
             Some("/usr/bin/firefox".into())
         );
     }
 
     #[test]
-    fn first_exec_token_strips_desktop_field_codes() {
+    fn parse_exec_command_strips_desktop_field_codes() {
         // %U, %F etc. must be skipped.
         assert_eq!(
-            first_exec_token("/usr/bin/code %F"),
+            parse_exec_command("/usr/bin/code %F"),
             Some("/usr/bin/code".into())
         );
     }
 
     #[test]
-    fn first_exec_token_strips_leading_percent_args() {
+    fn parse_exec_command_strips_leading_percent_args() {
         assert_eq!(
-            first_exec_token("%u /usr/bin/app"),
+            parse_exec_command("%u /usr/bin/app"),
             Some("/usr/bin/app".into())
         );
     }
 
     #[test]
-    fn first_exec_token_empty_string() {
-        assert_eq!(first_exec_token(""), None);
+    fn parse_exec_command_empty_string() {
+        assert_eq!(parse_exec_command(""), None);
     }
 
     #[test]
-    fn first_exec_token_only_field_codes() {
-        assert_eq!(first_exec_token("%U %F %i"), None);
+    fn parse_exec_command_only_field_codes() {
+        assert_eq!(parse_exec_command("%U %F %i"), None);
     }
 
     #[test]
-    fn first_exec_token_quoted_token_outer_quotes_stripped() {
+    fn parse_exec_command_quoted_token_outer_quotes_stripped() {
         // The function strips outer quotes from the final string but splits on
         // whitespace first, so a quoted path with spaces is split at the space.
         // This documents the actual behavior.
-        let result = first_exec_token("\"/usr/bin/myapp\"");
+        let result = parse_exec_command("\"/usr/bin/myapp\"");
         assert_eq!(result, Some("/usr/bin/myapp".into()));
     }
 
+    #[test]
+    fn parse_exec_command_preserves_multi_token_flatpak_launcher() {
+        // A first-token-only parse would truncate this to a bare `flatpak`
+        // with no way to know which app to run — the full command line
+        // (minus field codes/@@ markers) must survive.
+        let result = parse_exec_command(
+            "/usr/bin/flatpak run --branch=stable --arch=x86_64 \
+             --command=entrypoint --file-forwarding com.prusa3d.PrusaSlicer \
+             --single-instance-on-url @@u %u @@",
+        );
+        assert_eq!(
+            result,
+            Some(
+                "/usr/bin/flatpak run --branch=stable --arch=x86_64 \
+                 --command=entrypoint --file-forwarding com.prusa3d.PrusaSlicer \
+                 --single-instance-on-url"
+                    .into()
+            )
+        );
+    }
+
+    // ── split_exec_command ──────────────────────────────────────────────────
+
+    #[test]
+    fn split_exec_command_no_whitespace_is_single_program() {
+        assert_eq!(split_exec_command("/usr/bin/firefox"), ("/usr/bin/firefox", vec![]));
+    }
+
+    #[test]
+    fn split_exec_command_splits_nonexistent_multi_word_launcher() {
+        let (program, args) =
+            split_exec_command("/usr/bin/flatpak run --branch=stable com.prusa3d.PrusaSlicer");
+        assert_eq!(program, "/usr/bin/flatpak");
+        assert_eq!(args, vec!["run", "--branch=stable", "com.prusa3d.PrusaSlicer"]);
+    }
+
+    #[test]
+    fn split_exec_command_keeps_existing_path_with_spaces_whole() {
+        let dir = std::env::temp_dir();
+        let path = dir.join(format!(
+            "eldrun test app {}.txt",
+            std::process::id()
+        ));
+        fs::write(&path, b"").unwrap();
+        let exec = path.to_string_lossy().into_owned();
+        assert_eq!(split_exec_command(&exec), (exec.as_str(), vec![]));
+        let _ = fs::remove_file(&path);
+    }
+
     // ── installed-app parsing / embeddable allowlist ───────────────────────
 
     fn write_desktop(body: &str) -> PathBuf {
@@ -1517,6 +2271,44 @@ mod tests {
         assert!(project_apps_for_id(None).is_empty());
     }
 
+    #[test]
+    fn pid_zero_is_never_alive() {
+        assert!(!check_pid_alive(0));
+    }
+
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_bundle_discovery_uses_info_plist_and_bundle_path() {
+        let temp = tempfile::tempdir().unwrap();
+        let app = temp.path().join("Filename.app");
+        let contents = app.join("Contents");
+        let executable = contents.join("MacOS").join("real-bin");
+        fs::create_dir_all(executable.parent().unwrap()).unwrap();
+        fs::write(&executable, b"binary").unwrap();
+
+        let mut info = plist::Dictionary::new();
+        info.insert(
+            "CFBundleDisplayName".into(),
+            plist::Value::String("Preferred Name".into()),
+        );
+        info.insert(
+            "CFBundleName".into(),
+            plist::Value::String("Fallback Name".into()),
+        );
+        info.insert(
+            "CFBundleExecutable".into(),
+            plist::Value::String("real-bin".into()),
+        );
+        plist::Value::Dictionary(info)
+            .to_file_xml(contents.join("Info.plist"))
+            .unwrap();
+
+        let apps = macos_installed_apps_in(&[temp.path().to_path_buf()]);
+        assert_eq!(apps.len(), 1);
+        assert_eq!(apps[0].name, "Preferred Name");
+        assert_eq!(apps[0].exec, app.to_string_lossy().into_owned());
+    }
+
     // ── Windows Start Menu matching ────────────────────────────────────────
 
     fn shortcut() -> ShortcutEntry {
@@ -1556,4 +2348,17 @@ mod tests {
     fn shortcut_does_not_match_unrelated_name() {
         assert!(!shortcut_matches("notepad", &shortcut()));
     }
+
+    #[cfg(target_os = "windows")]
+    #[test]
+    fn windows_script_command_picks_interpreter_by_extension() {
+        // .ps1 → PowerShell; .bat / .cmd / everything else → cmd /C.
+        let ps1 = windows_script_command(r"C:\tmp\build.ps1");
+        assert_eq!(ps1.get_program().to_string_lossy(), "powershell");
+
+        for script in [r"C:\tmp\build.bat", r"C:\tmp\run.cmd", r"C:\tmp\go.sh"] {
+            let cmd = windows_script_command(script);
+            assert_eq!(cmd.get_program().to_string_lossy(), "cmd");
+        }
+    }
 }
diff --git a/src-tauri/src/commands/boxes.rs b/src-tauri/src/commands/boxes.rs
index 75726cd..85fa311 100644
--- a/src-tauri/src/commands/boxes.rs
+++ b/src-tauri/src/commands/boxes.rs
@@ -129,8 +129,10 @@ links to the project root and its `{agent_file}`:\n\n"
     } else {
         for (name, dir) in members {
             let root = dir.to_string_lossy();
-            let doc = dir.join(agent_file);
-            let doc = doc.to_string_lossy();
+            // Build the doc link with a literal `/` rather than `Path::join`, so the
+            // generated markdown is identical on every host OS (on Windows `join`
+            // would splice in a `\`, producing a malformed link URL).
+            let doc = format!("{}/{agent_file}", root.trim_end_matches(['/', '\\']));
             out.push_str(&format!(
                 "- **{name}** — root: `{root}` · [`{agent_file}`]({doc})\n"
             ));
diff --git a/src-tauri/src/commands/calendar.rs b/src-tauri/src/commands/calendar.rs
new file mode 100644
index 0000000..ce5b4a0
--- /dev/null
+++ b/src-tauri/src/commands/calendar.rs
@@ -0,0 +1,608 @@
+//! Native calendar — a single global, local store of calendars, events and tasks.
+//!
+//! Everything lives in `~/.local/share/eldrun/calendar.json` (like `boxes.json`),
+//! read/written through the shared `storage` helpers. Reads go through
+//! `schema::calendar::CalendarFile`, so a version-1 file (a bare array of
+//! start-time-only events) still loads and is migrated on the way in; writes are
+//! always the current shape.
+//!
+//! The CRUD logic is factored onto a `&Path` so the `#[tauri::command]` wrappers
+//! stay thin (they just pass `calendar_path()`) and the tests can drive a tempdir.
+//!
+//! The backend deliberately stays dumb about calendar *semantics*: it does not
+//! expand recurrences, evaluate alarms, or parse ICS. Those are pure functions in
+//! the frontend (`src/lib/{recurrence,ics,calendarTime}.ts`) where they are cheap
+//! to unit-test. This module is storage plus identity.
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+
+use crate::commands::projects::uuid_v4;
+use crate::schema::calendar::{
+    Calendar, CalendarData, CalendarEvent, CalendarFile, CalendarTask, DEFAULT_CALENDAR_ID,
+};
+use crate::storage;
+
+fn calendar_path() -> PathBuf {
+    storage::state_dir().join("calendar.json")
+}
+
+/// Read the store, migrating a legacy file in the process. A missing file is an
+/// empty calendar, not an error.
+fn read_data(path: &Path) -> Result<CalendarData, String> {
+    if !path.exists() {
+        return Ok(CalendarData::default());
+    }
+    let file: CalendarFile = storage::read_json(path).map_err(|e| e.to_string())?;
+    Ok(file.into_data())
+}
+
+fn write_data(path: &Path, data: &CalendarData) -> Result<(), String> {
+    storage::write_json(path, data).map_err(|e| e.to_string())
+}
+
+/// Mint an id not already present among `existing` (guards against back-to-back
+/// time-based `uuid_v4` collisions, mirroring `create_box`).
+fn fresh_id(existing: &HashSet<&str>) -> String {
+    let mut id = uuid_v4();
+    while existing.contains(id.as_str()) {
+        id = uuid_v4();
+    }
+    id
+}
+
+fn event_ids(data: &CalendarData) -> HashSet<&str> {
+    data.events.iter().map(|e| e.id.as_str()).collect()
+}
+
+fn task_ids(data: &CalendarData) -> HashSet<&str> {
+    data.tasks.iter().map(|t| t.id.as_str()).collect()
+}
+
+fn calendar_ids(data: &CalendarData) -> HashSet<&str> {
+    data.calendars.iter().map(|c| c.id.as_str()).collect()
+}
+
+// ── Events ──────────────────────────────────────────────────────────────────
+
+/// Insert `event`, minting an id and defaulting its calendar. The caller's `id`
+/// is ignored — the store owns identity.
+fn create_event_at(path: &Path, mut event: CalendarEvent) -> Result<CalendarEvent, String> {
+    let mut data = read_data(path)?;
+    event.id = fresh_id(&event_ids(&data));
+    if event.calendar_id.is_empty() {
+        event.calendar_id = DEFAULT_CALENDAR_ID.to_string();
+    }
+    data.events.push(event.clone());
+    data.normalize();
+    write_data(path, &data)?;
+    Ok(event)
+}
+
+/// Replace the event with `event.id` wholesale.
+fn update_event_at(path: &Path, event: CalendarEvent) -> Result<CalendarEvent, String> {
+    let mut data = read_data(path)?;
+    let slot = data
+        .events
+        .iter_mut()
+        .find(|e| e.id == event.id)
+        .ok_or_else(|| format!("event '{}' not found", event.id))?;
+    *slot = event.clone();
+    data.normalize();
+    write_data(path, &data)?;
+    Ok(event)
+}
+
+fn delete_event_at(path: &Path, id: &str) -> Result<(), String> {
+    let mut data = read_data(path)?;
+    let before = data.events.len();
+    data.events.retain(|e| e.id != id);
+    if data.events.len() == before {
+        return Err(format!("event '{id}' not found"));
+    }
+    write_data(path, &data)
+}
+
+// ── Tasks ───────────────────────────────────────────────────────────────────
+
+fn create_task_at(path: &Path, mut task: CalendarTask) -> Result<CalendarTask, String> {
+    let mut data = read_data(path)?;
+    task.id = fresh_id(&task_ids(&data));
+    if task.calendar_id.is_empty() {
+        task.calendar_id = DEFAULT_CALENDAR_ID.to_string();
+    }
+    data.tasks.push(task.clone());
+    data.normalize();
+    write_data(path, &data)?;
+    Ok(task)
+}
+
+fn update_task_at(path: &Path, task: CalendarTask) -> Result<CalendarTask, String> {
+    let mut data = read_data(path)?;
+    let slot = data
+        .tasks
+        .iter_mut()
+        .find(|t| t.id == task.id)
+        .ok_or_else(|| format!("task '{}' not found", task.id))?;
+    *slot = task.clone();
+    data.normalize();
+    write_data(path, &data)?;
+    Ok(task)
+}
+
+fn delete_task_at(path: &Path, id: &str) -> Result<(), String> {
+    let mut data = read_data(path)?;
+    let before = data.tasks.len();
+    data.tasks.retain(|t| t.id != id);
+    if data.tasks.len() == before {
+        return Err(format!("task '{id}' not found"));
+    }
+    write_data(path, &data)
+}
+
+// ── Calendars ───────────────────────────────────────────────────────────────
+
+fn create_calendar_at(path: &Path, mut calendar: Calendar) -> Result<Calendar, String> {
+    let mut data = read_data(path)?;
+    calendar.id = fresh_id(&calendar_ids(&data));
+    data.calendars.push(calendar.clone());
+    write_data(path, &data)?;
+    Ok(calendar)
+}
+
+fn update_calendar_at(path: &Path, calendar: Calendar) -> Result<Calendar, String> {
+    let mut data = read_data(path)?;
+    let slot = data
+        .calendars
+        .iter_mut()
+        .find(|c| c.id == calendar.id)
+        .ok_or_else(|| format!("calendar '{}' not found", calendar.id))?;
+    *slot = calendar.clone();
+    write_data(path, &data)?;
+    Ok(calendar)
+}
+
+/// Delete a calendar **and everything filed under it** — the destructive choice,
+/// matching what Thunderbird's "Remove calendar" does. Refusing to delete the last
+/// calendar keeps `normalize()`'s "at least one calendar" invariant meaningful
+/// (otherwise the next read would silently resurrect a default).
+fn delete_calendar_at(path: &Path, id: &str) -> Result<(), String> {
+    let mut data = read_data(path)?;
+    if data.calendars.len() <= 1 {
+        return Err("cannot delete the last calendar".to_string());
+    }
+    let before = data.calendars.len();
+    data.calendars.retain(|c| c.id != id);
+    if data.calendars.len() == before {
+        return Err(format!("calendar '{id}' not found"));
+    }
+    data.events.retain(|e| e.calendar_id != id);
+    data.tasks.retain(|t| t.calendar_id != id);
+    write_data(path, &data)
+}
+
+// ── ICS file I/O ────────────────────────────────────────────────────────────
+//
+// Import/export need to touch a path *outside* any project — wherever the user
+// pointed the file dialog. The general-purpose `fs::read_file_text` /
+// `write_file_text` commands deliberately refuse that: they confine every path to
+// the current project's roots, precisely so a compromised renderer cannot read
+// `~/.ssh/id_rsa` or overwrite arbitrary files (Security #1). That confinement is
+// worth keeping, so instead of widening it these two commands open a much narrower
+// door: an iCalendar file, and nothing else.
+//
+// The guards are the door's width — an extension allowlist (so the path cannot
+// name a key, a config, or a document) and a size cap (so a "calendar" cannot be
+// used to slurp a huge file into the renderer). Parsing itself stays in the
+// frontend (`src/lib/ics.ts`), where it is unit-tested; these only move bytes.
+
+/// Extensions an ICS path may carry. Anything else is refused outright.
+const ICS_EXTENSIONS: [&str; 3] = ["ics", "ical", "ifb"];
+
+/// Size cap for an imported/exported calendar (8 MiB — a decade of events is a
+/// few hundred KiB, so this is generous while still bounding the read).
+const MAX_ICS_BYTES: u64 = 8 * 1024 * 1024;
+
+fn check_ics_path(path: &Path) -> Result<(), String> {
+    let ext = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.to_ascii_lowercase())
+        .unwrap_or_default();
+    if !ICS_EXTENSIONS.contains(&ext.as_str()) {
+        return Err(format!(
+            "not a calendar file: expected one of {}, got '{}'",
+            ICS_EXTENSIONS.join(", "),
+            if ext.is_empty() { "no extension" } else { &ext }
+        ));
+    }
+    Ok(())
+}
+
+/// Read an `.ics` file the user picked, for the frontend parser.
+#[tauri::command]
+pub fn calendar_read_ics(path: String) -> Result<String, String> {
+    let p = PathBuf::from(&path);
+    check_ics_path(&p)?;
+
+    let meta = std::fs::metadata(&p).map_err(|e| e.to_string())?;
+    if !meta.is_file() {
+        return Err("not a file".to_string());
+    }
+    if meta.len() > MAX_ICS_BYTES {
+        return Err(format!(
+            "calendar file too large ({} bytes; limit {MAX_ICS_BYTES})",
+            meta.len()
+        ));
+    }
+    std::fs::read_to_string(&p).map_err(|e| e.to_string())
+}
+
+/// Write an `.ics` file to the path the user picked.
+#[tauri::command]
+pub fn calendar_write_ics(path: String, content: String) -> Result<(), String> {
+    let p = PathBuf::from(&path);
+    check_ics_path(&p)?;
+    if content.len() as u64 > MAX_ICS_BYTES {
+        return Err("calendar export too large".to_string());
+    }
+    std::fs::write(&p, content).map_err(|e| e.to_string())
+}
+
+// ── Commands ────────────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn calendar_load() -> Result<CalendarData, String> {
+    read_data(&calendar_path())
+}
+
+/// Replace the whole store. Used by ICS import, which rewrites in bulk.
+#[tauri::command]
+pub fn calendar_save(data: CalendarData) -> Result<(), String> {
+    let mut data = data;
+    data.normalize();
+    write_data(&calendar_path(), &data)
+}
+
+#[tauri::command]
+pub fn create_event(event: CalendarEvent) -> Result<CalendarEvent, String> {
+    create_event_at(&calendar_path(), event)
+}
+
+#[tauri::command]
+pub fn update_event(event: CalendarEvent) -> Result<CalendarEvent, String> {
+    update_event_at(&calendar_path(), event)
+}
+
+#[tauri::command]
+pub fn delete_event(id: String) -> Result<(), String> {
+    delete_event_at(&calendar_path(), &id)
+}
+
+#[tauri::command]
+pub fn create_task(task: CalendarTask) -> Result<CalendarTask, String> {
+    create_task_at(&calendar_path(), task)
+}
+
+#[tauri::command]
+pub fn update_task(task: CalendarTask) -> Result<CalendarTask, String> {
+    update_task_at(&calendar_path(), task)
+}
+
+#[tauri::command]
+pub fn delete_task(id: String) -> Result<(), String> {
+    delete_task_at(&calendar_path(), &id)
+}
+
+#[tauri::command]
+pub fn create_calendar(calendar: Calendar) -> Result<Calendar, String> {
+    create_calendar_at(&calendar_path(), calendar)
+}
+
+#[tauri::command]
+pub fn update_calendar(calendar: Calendar) -> Result<Calendar, String> {
+    update_calendar_at(&calendar_path(), calendar)
+}
+
+#[tauri::command]
+pub fn delete_calendar(id: String) -> Result<(), String> {
+    delete_calendar_at(&calendar_path(), &id)
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tmp_path() -> (tempfile::TempDir, PathBuf) {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("calendar.json");
+        (dir, path)
+    }
+
+    fn event(title: &str, start: &str, end: &str) -> CalendarEvent {
+        CalendarEvent {
+            title: title.into(),
+            start: start.into(),
+            end: end.into(),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn read_missing_file_is_an_empty_default_calendar() {
+        let (_dir, path) = tmp_path();
+        let data = read_data(&path).unwrap();
+        assert!(data.events.is_empty());
+        assert!(data.tasks.is_empty());
+        assert_eq!(data.calendars.len(), 1, "a default calendar always exists");
+    }
+
+    #[test]
+    fn create_then_read_roundtrips() {
+        let (_dir, path) = tmp_path();
+        let ev = create_event_at(
+            &path,
+            event("standup", "2026-07-08T09:00", "2026-07-08T09:15"),
+        )
+        .unwrap();
+        assert!(!ev.id.is_empty());
+
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.events.len(), 1);
+        assert_eq!(data.events[0].title, "standup");
+        assert_eq!(data.events[0].start, "2026-07-08T09:00");
+        assert_eq!(data.events[0].end, "2026-07-08T09:15");
+        assert_eq!(data.events[0].calendar_id, DEFAULT_CALENDAR_ID);
+    }
+
+    #[test]
+    fn create_mints_unique_ids_and_ignores_caller_id() {
+        let (_dir, path) = tmp_path();
+        let mut forged = event("a", "2026-07-08T09:00", "2026-07-08T10:00");
+        forged.id = "forged".into();
+        let a = create_event_at(&path, forged).unwrap();
+        let b = create_event_at(&path, event("b", "2026-07-08T11:00", "2026-07-08T12:00")).unwrap();
+        assert_ne!(a.id, "forged", "the store owns identity");
+        assert_ne!(a.id, b.id);
+        assert_eq!(read_data(&path).unwrap().events.len(), 2);
+    }
+
+    #[test]
+    fn update_replaces_the_event() {
+        let (_dir, path) = tmp_path();
+        let ev = create_event_at(&path, event("old", "2026-07-08T09:00", "2026-07-08T10:00")).unwrap();
+
+        let mut edited = ev.clone();
+        edited.title = "new".into();
+        edited.start = "2026-07-09T10:30".into();
+        edited.end = "2026-07-09T11:30".into();
+        edited.location = "room 2".into();
+        let out = update_event_at(&path, edited).unwrap();
+
+        assert_eq!(out.title, "new");
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.events.len(), 1);
+        assert_eq!(data.events[0].title, "new");
+        assert_eq!(data.events[0].start, "2026-07-09T10:30");
+        assert_eq!(data.events[0].location, "room 2");
+    }
+
+    #[test]
+    fn update_missing_id_errors() {
+        let (_dir, path) = tmp_path();
+        let mut ghost = event("x", "2026-07-08T09:00", "2026-07-08T10:00");
+        ghost.id = "nope".into();
+        assert!(update_event_at(&path, ghost).is_err());
+    }
+
+    #[test]
+    fn delete_removes_the_event() {
+        let (_dir, path) = tmp_path();
+        let ev = create_event_at(&path, event("x", "2026-07-08T09:00", "2026-07-08T10:00")).unwrap();
+        delete_event_at(&path, &ev.id).unwrap();
+        assert!(read_data(&path).unwrap().events.is_empty());
+    }
+
+    #[test]
+    fn delete_missing_id_errors() {
+        let (_dir, path) = tmp_path();
+        assert!(delete_event_at(&path, "nope").is_err());
+    }
+
+    #[test]
+    fn task_crud_roundtrips() {
+        let (_dir, path) = tmp_path();
+        let t = create_task_at(
+            &path,
+            CalendarTask {
+                title: "write plan".into(),
+                due: Some("2026-07-10".into()),
+                priority: 1,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        assert!(!t.id.is_empty());
+
+        let mut done = t.clone();
+        done.percent = 100;
+        done.completed = Some("2026-07-09T12:00".into());
+        update_task_at(&path, done).unwrap();
+
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.tasks.len(), 1);
+        assert_eq!(data.tasks[0].percent, 100);
+        assert_eq!(data.tasks[0].completed.as_deref(), Some("2026-07-09T12:00"));
+
+        delete_task_at(&path, &t.id).unwrap();
+        assert!(read_data(&path).unwrap().tasks.is_empty());
+    }
+
+    #[test]
+    fn calendar_crud_roundtrips() {
+        let (_dir, path) = tmp_path();
+        let cal = create_calendar_at(
+            &path,
+            Calendar {
+                id: String::new(),
+                name: "Work".into(),
+                color: "#ff0000".into(),
+                visible: true,
+                readonly: false,
+                extra: Default::default(),
+            },
+        )
+        .unwrap();
+
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.calendars.len(), 2, "default + Work");
+
+        let mut hidden = cal.clone();
+        hidden.visible = false;
+        update_calendar_at(&path, hidden).unwrap();
+        let data = read_data(&path).unwrap();
+        assert!(!data.calendars.iter().find(|c| c.id == cal.id).unwrap().visible);
+    }
+
+    #[test]
+    fn deleting_a_calendar_takes_its_events_and_tasks_with_it() {
+        let (_dir, path) = tmp_path();
+        let cal = create_calendar_at(
+            &path,
+            Calendar {
+                id: String::new(),
+                name: "Work".into(),
+                color: "#ff0000".into(),
+                visible: true,
+                readonly: false,
+                extra: Default::default(),
+            },
+        )
+        .unwrap();
+
+        let mut in_work = event("meeting", "2026-07-08T09:00", "2026-07-08T10:00");
+        in_work.calendar_id = cal.id.clone();
+        create_event_at(&path, in_work).unwrap();
+        create_event_at(&path, event("personal", "2026-07-08T18:00", "2026-07-08T19:00")).unwrap();
+
+        delete_calendar_at(&path, &cal.id).unwrap();
+
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.calendars.len(), 1);
+        assert_eq!(data.events.len(), 1, "only the Work event is gone");
+        assert_eq!(data.events[0].title, "personal");
+    }
+
+    #[test]
+    fn cannot_delete_the_last_calendar() {
+        let (_dir, path) = tmp_path();
+        let data = read_data(&path).unwrap();
+        let only = data.calendars[0].id.clone();
+        // Writing first, so the file exists with exactly one calendar.
+        write_data(&path, &data).unwrap();
+        assert!(delete_calendar_at(&path, &only).is_err());
+    }
+
+    #[test]
+    fn legacy_file_migrates_on_read() {
+        let (_dir, path) = tmp_path();
+        std::fs::write(
+            &path,
+            r#"[
+                {"id":"a","date":"2026-07-08","time":"09:00","title":"standup","notes":"daily"},
+                {"id":"b","date":"2026-07-09","time":"","title":"holiday"}
+            ]"#,
+        )
+        .unwrap();
+
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.events.len(), 2);
+
+        let standup = data.events.iter().find(|e| e.title == "standup").unwrap();
+        assert_eq!(standup.start, "2026-07-08T09:00");
+        assert_eq!(standup.end, "2026-07-08T10:00");
+        assert!(!standup.all_day);
+        assert_eq!(standup.notes, "daily");
+
+        let holiday = data.events.iter().find(|e| e.title == "holiday").unwrap();
+        assert!(holiday.all_day);
+        assert_eq!(holiday.start, "2026-07-09");
+        assert_eq!(holiday.end, "2026-07-10");
+    }
+
+    #[test]
+    fn legacy_file_is_rewritten_in_the_current_shape() {
+        let (_dir, path) = tmp_path();
+        std::fs::write(
+            &path,
+            r#"[{"id":"a","date":"2026-07-08","time":"09:00","title":"standup"}]"#,
+        )
+        .unwrap();
+
+        // Any write path (here: adding an event) upgrades the file on disk.
+        create_event_at(&path, event("new", "2026-07-10T09:00", "2026-07-10T10:00")).unwrap();
+
+        let raw = std::fs::read_to_string(&path).unwrap();
+        assert!(raw.contains("\"version\""), "upgraded file carries a version: {raw}");
+        let data = read_data(&path).unwrap();
+        assert_eq!(data.events.len(), 2, "the migrated event survives the write");
+    }
+
+    #[test]
+    fn ics_path_guard_accepts_calendar_extensions() {
+        for ok in ["a.ics", "a.ical", "a.ifb", "A.ICS"] {
+            assert!(check_ics_path(Path::new(ok)).is_ok(), "{ok} should be accepted");
+        }
+    }
+
+    #[test]
+    fn ics_path_guard_refuses_anything_else() {
+        // The whole point of the guard: an ICS command must not become a
+        // read-any-file primitive.
+        for bad in ["id_rsa", "/home/u/.ssh/id_rsa", "notes.txt", "a.ics.txt", "config.toml"] {
+            assert!(check_ics_path(Path::new(bad)).is_err(), "{bad} should be refused");
+        }
+    }
+
+    #[test]
+    fn read_ics_refuses_a_non_ics_path() {
+        let (dir, _) = tmp_path();
+        let secret = dir.path().join("id_rsa");
+        std::fs::write(&secret, "PRIVATE KEY").unwrap();
+        let err = calendar_read_ics(secret.to_string_lossy().into_owned());
+        assert!(err.is_err(), "a non-.ics path must be refused");
+    }
+
+    #[test]
+    fn read_ics_roundtrips_a_calendar_file() {
+        let (dir, _) = tmp_path();
+        let ics = dir.path().join("cal.ics");
+        std::fs::write(&ics, "BEGIN:VCALENDAR\r\nEND:VCALENDAR\r\n").unwrap();
+        let text = calendar_read_ics(ics.to_string_lossy().into_owned()).unwrap();
+        assert!(text.contains("VCALENDAR"));
+    }
+
+    #[test]
+    fn write_ics_refuses_a_non_ics_path() {
+        let (dir, _) = tmp_path();
+        let target = dir.path().join("important.conf");
+        assert!(calendar_write_ics(
+            target.to_string_lossy().into_owned(),
+            "x".into()
+        )
+        .is_err());
+        assert!(!target.exists(), "the refused write must not have happened");
+    }
+
+    #[test]
+    fn empty_optional_fields_are_omitted_from_the_file() {
+        let (_dir, path) = tmp_path();
+        create_event_at(&path, event("x", "2026-07-08T09:00", "2026-07-08T10:00")).unwrap();
+        let raw = std::fs::read_to_string(&path).unwrap();
+        assert!(!raw.contains("\"notes\""), "empty notes must be skipped: {raw}");
+        assert!(!raw.contains("\"location\""), "empty location must be skipped: {raw}");
+        assert!(!raw.contains("\"rrule\""), "absent rrule must be skipped: {raw}");
+    }
+}
diff --git a/src-tauri/src/commands/clipboard.rs b/src-tauri/src/commands/clipboard.rs
index 101b9d9..4872786 100644
--- a/src-tauri/src/commands/clipboard.rs
+++ b/src-tauri/src/commands/clipboard.rs
@@ -1,9 +1,15 @@
-//! System-clipboard image paste: lets the file tree turn a screenshot (or any
-//! image on the OS clipboard) into a PNG file inside the project. The path side
-//! reuses `fs`'s relative-path confinement so a paste can only ever land inside
-//! the project root.
+//! System-clipboard image bridge, in both directions:
+//!
+//! - **In:** the file tree turns an image already on the OS clipboard into a PNG
+//!   file inside the project ([`clipboard_has_image`] / [`save_clipboard_image`]).
+//!   The path side reuses `fs`'s relative-path confinement so a paste can only
+//!   ever land inside the project root.
+//! - **Out:** [`copy_image_to_clipboard`] / [`copy_png_file_to_clipboard`] put an
+//!   image *on* the clipboard, so a screenshot Eldrun files into the project is
+//!   also pasteable straight into a chat, an editor, or an agent tab.
 
-use std::path::PathBuf;
+use std::borrow::Cow;
+use std::path::{Path, PathBuf};
 
 use crate::commands::fs::enforce_confinement;
 
@@ -11,12 +17,23 @@ use crate::commands::fs::enforce_confinement;
 /// file tree's context menu should offer "Paste screenshot". Any failure
 /// (no clipboard, no image, unsupported platform) reports `false` rather than
 /// erroring so the menu simply omits the option.
+///
+/// Runs on a blocking worker rather than the main thread: on X11 the `arboard`
+/// probe stalls while negotiating the clipboard selection (notably when there is
+/// *no* image, where it waits out a transfer timeout). A synchronous Tauri
+/// command executes on the main thread and would freeze the webview for that
+/// whole stall — which made the file-tree context menu take a long time to
+/// appear, since it fires this probe as it opens. Keeping the work off-thread
+/// lets the menu paint immediately and the "Paste screenshot" item appear once
+/// the probe resolves.
 #[tauri::command]
-pub fn clipboard_has_image() -> bool {
-    match arboard::Clipboard::new() {
+pub async fn clipboard_has_image() -> bool {
+    tauri::async_runtime::spawn_blocking(|| match arboard::Clipboard::new() {
         Ok(mut cb) => cb.get_image().is_ok(),
         Err(_) => false,
-    }
+    })
+    .await
+    .unwrap_or(false)
 }
 
 /// Read the clipboard image and write it as a PNG at `project_dir`/`rel_path`.
@@ -43,6 +60,80 @@ pub fn save_clipboard_image(project_dir: String, rel_path: String) -> Result<(),
     std::fs::write(&dest, png).map_err(|e| e.to_string())
 }
 
+/// Put raw RGBA8 pixels on the system clipboard as an image.
+///
+/// On X11/Wayland the clipboard has no OS-owned store: the *owning process*
+/// serves the data on request, and arboard tears its serving window down as soon
+/// as the last `Clipboard` handle drops — so a set-then-drop would leave nothing
+/// to paste. Hence the Linux path hands the image to a thread that calls
+/// `.wait()`, which keeps serving until another app takes the selection over
+/// (including the next Eldrun screenshot). It therefore returns before the image
+/// is necessarily on the clipboard, and a failure there is silent. Windows and
+/// macOS copy the bytes into an OS-owned clipboard, so there they are set inline.
+pub fn copy_image_to_clipboard(width: usize, height: usize, rgba: Vec<u8>) -> Result<(), String> {
+    let expected = width.checked_mul(height).and_then(|p| p.checked_mul(4));
+    if expected != Some(rgba.len()) {
+        return Err("image has an unexpected size".to_string());
+    }
+    let image = arboard::ImageData {
+        width,
+        height,
+        bytes: Cow::Owned(rgba),
+    };
+
+    #[cfg(target_os = "linux")]
+    {
+        use arboard::SetExtLinux;
+        std::thread::spawn(move || {
+            if let Ok(mut cb) = arboard::Clipboard::new() {
+                let _ = cb.set().wait().image(image);
+            }
+        });
+        Ok(())
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    {
+        let mut cb = arboard::Clipboard::new().map_err(|e| e.to_string())?;
+        cb.set_image(image).map_err(|e| e.to_string())
+    }
+}
+
+/// Read a PNG file and put it on the system clipboard as an image.
+pub fn copy_png_file_to_clipboard(path: &Path) -> Result<(), String> {
+    let (width, height, rgba) = decode_png_rgba(path)?;
+    copy_image_to_clipboard(width, height, rgba)
+}
+
+/// Decode a PNG file to RGBA8. Capture tools emit whatever color type they like
+/// (grayscale, palette, RGB, 16-bit), while the clipboard wants plain RGBA8:
+/// `normalize_to_color8` folds palette/16-bit/sub-byte-gray down to 8-bit
+/// channels, leaving only the four channel layouts expanded below.
+fn decode_png_rgba(path: &Path) -> Result<(usize, usize, Vec<u8>), String> {
+    let file = std::fs::File::open(path).map_err(|e| e.to_string())?;
+    let mut decoder = png::Decoder::new(std::io::BufReader::new(file));
+    decoder.set_transformations(png::Transformations::normalize_to_color8());
+    let mut reader = decoder.read_info().map_err(|e| e.to_string())?;
+    let mut buf = vec![0u8; reader.output_buffer_size()];
+    let info = reader.next_frame(&mut buf).map_err(|e| e.to_string())?;
+    let px = &buf[..info.buffer_size()];
+
+    let rgba = match info.color_type {
+        png::ColorType::Rgba => px.to_vec(),
+        png::ColorType::Rgb => px
+            .chunks_exact(3)
+            .flat_map(|c| [c[0], c[1], c[2], 0xFF])
+            .collect(),
+        png::ColorType::GrayscaleAlpha => px
+            .chunks_exact(2)
+            .flat_map(|c| [c[0], c[0], c[0], c[1]])
+            .collect(),
+        png::ColorType::Grayscale => px.iter().flat_map(|&g| [g, g, g, 0xFF]).collect(),
+        png::ColorType::Indexed => return Err("indexed PNG was not expanded".to_string()),
+    };
+    Ok((info.width as usize, info.height as usize, rgba))
+}
+
 /// Encode raw RGBA8 pixels as a PNG byte buffer.
 fn encode_png(width: usize, height: usize, rgba: &[u8]) -> Result<Vec<u8>, String> {
     let expected = width.checked_mul(height).and_then(|p| p.checked_mul(4));
@@ -94,4 +185,39 @@ mod tests {
         // 3 bytes can't be a 2x1 RGBA image (needs 8).
         assert!(encode_png(2, 1, &[0, 0, 0]).is_err());
     }
+
+    /// Capture tools emit plain RGB PNGs (no alpha); the clipboard needs RGBA, so
+    /// the decoder has to widen them rather than reject them.
+    #[test]
+    fn decode_png_rgba_widens_an_rgb_png() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("rgb.png");
+        let file = std::fs::File::create(&path).unwrap();
+        let mut encoder = png::Encoder::new(file, 2, 1);
+        encoder.set_color(png::ColorType::Rgb);
+        encoder.set_depth(png::BitDepth::Eight);
+        let mut writer = encoder.write_header().unwrap();
+        writer.write_image_data(&[255, 0, 0, 0, 255, 0]).unwrap();
+        drop(writer);
+
+        let (width, height, rgba) = decode_png_rgba(&path).unwrap();
+        assert_eq!((width, height), (2, 1));
+        assert_eq!(rgba, vec![255, 0, 0, 255, 0, 255, 0, 255]);
+    }
+
+    /// An RGBA PNG (what Eldrun itself writes) round-trips unchanged.
+    #[test]
+    fn decode_png_rgba_round_trips_rgba() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("rgba.png");
+        let rgba = vec![1u8, 2, 3, 4, 5, 6, 7, 8];
+        std::fs::write(&path, encode_png(2, 1, &rgba).unwrap()).unwrap();
+
+        assert_eq!(decode_png_rgba(&path).unwrap(), (2, 1, rgba));
+    }
+
+    #[test]
+    fn copy_image_rejects_size_mismatch() {
+        assert!(copy_image_to_clipboard(2, 1, vec![0, 0, 0]).is_err());
+    }
 }
diff --git a/src-tauri/src/commands/credentials.rs b/src-tauri/src/commands/credentials.rs
new file mode 100644
index 0000000..47b70ac
--- /dev/null
+++ b/src-tauri/src/commands/credentials.rs
@@ -0,0 +1,124 @@
+//! Commands about the **OS credential store itself**, rather than any one
+//! credential in it.
+//!
+//! Every "is this password saved?" answer in Eldrun — the SSH `remote_has_password`,
+//! the VPN `vpn_has_saved_password`, both silent-connect probes — reduces to a
+//! keychain read, and on Linux a read against a *locked* Secret Service collection
+//! answers exactly like an empty one: nothing saved. That is how a user who ticked
+//! "Save password" ends up staring at a blank prompt after a restart, with the
+//! credential sitting in the keyring the whole time.
+//!
+//! So the lock state is its own question, asked once by the UI, with one action
+//! behind it. Both commands are `async` + `spawn_blocking` for the reason every
+//! keychain command here is: a synchronous Tauri command runs on the **main thread**,
+//! and a Secret Service round trip against a locked collection blocks — which would
+//! freeze the window in the very state it is trying to explain.
+
+use crate::commands::terminal::RegistryState;
+use crate::services::remote_credentials::{self as creds, KeyringState};
+use tauri::State;
+
+/// Whether the OS credential store is readable right now (see [`KeyringState`]).
+#[tauri::command]
+pub async fn keyring_state() -> KeyringState {
+    tokio::task::spawn_blocking(creds::keyring_state)
+        .await
+        // A worker that died tells us nothing about the store; "locked" is the answer
+        // with a remedy attached, and a wrong "unlocked" would send the caller back
+        // into the silent path that is already failing.
+        .unwrap_or(KeyringState::Locked)
+}
+
+/// Unlock the OS credential store, raising the system's own unlock dialog.
+///
+/// Only ever called from an explicit user action (the header's VPN menu, a Connect
+/// dialog) — never from a launch path, which promises not to prompt.
+#[tauri::command]
+pub async fn keyring_unlock() -> Result<(), String> {
+    tokio::task::spawn_blocking(creds::unlock_keyring)
+        .await
+        .map_err(|e| format!("keyring unlock task failed: {e}"))?
+}
+
+/// Which saved credential a paste targets. Tagged by `kind` so the frontend names
+/// the *credential*, never the keychain account string — the account spelling
+/// (`ssh:{user}@{host}:{port}`, `openvpn-key:{config}`, …) stays the backend's, as
+/// it is everywhere else, so a UI that mints one by hand can't drift from the one
+/// [`creds`] writes.
+#[derive(serde::Deserialize)]
+#[serde(tag = "kind", rename_all = "kebab-case")]
+pub enum PasteCredential {
+    /// The SSH login password for a host target.
+    SshPassword {
+        user: Option<String>,
+        host: String,
+        port: Option<u16>,
+    },
+    /// An OpenVPN tunnel's primary secret (the `auth-user-pass` password, or the
+    /// key passphrase for a config with no account).
+    VpnPassword { config: String },
+    /// An OpenVPN tunnel's separately-stored private-key passphrase.
+    VpnKeyPassphrase { config: String },
+    /// An OpenVPN tunnel's saved auth **username** — the one non-secret of the set,
+    /// stored in the keychain because a header-started tunnel has no project spec to
+    /// carry it (see [`creds::openvpn_user_account`]).
+    VpnUsername { config: String },
+}
+
+impl PasteCredential {
+    fn account(&self) -> String {
+        match self {
+            Self::SshPassword { user, host, port } => creds::ssh_account(user, host, *port),
+            Self::VpnPassword { config } => creds::openvpn_account(config),
+            Self::VpnKeyPassphrase { config } => creds::openvpn_key_account(config),
+            Self::VpnUsername { config } => creds::openvpn_user_account(config),
+        }
+    }
+}
+
+/// Type a saved credential into a **login terminal**, at its cursor, without it ever
+/// reaching the frontend.
+///
+/// This is the non-headless login's missing half. In that mode Eldrun deliberately
+/// handles no passwords — the host asks its own questions in an embedded terminal and
+/// the user answers them — but a user who *did* save a credential (from a headless
+/// connect, or the header's VPN menu) then has it sitting in the keychain, unreachable,
+/// while retyping it by hand into every login. The same is true one flip of "Sign in in
+/// a terminal" away: the escape hatch for a host that asks a challenge code still asks
+/// for the ordinary password first.
+///
+/// So the secret goes keychain → PTY **inside the backend**. It is never returned to
+/// JS, never rendered into a field, never in a component's state — the same bargain
+/// `ssh_connect`'s saved-password fallback makes, applied to a terminal the user is
+/// looking at rather than a headless connect. `submit` appends a newline for a prompt
+/// the user wants answered outright; by default nothing is sent but the credential, so
+/// the line can still be corrected before it is committed.
+///
+/// Returns `false` when nothing is stored for the target (including a locked keyring,
+/// which reads as empty — [`keyring_state`] is what distinguishes the two), so the
+/// caller can say "nothing saved" instead of appearing to paste an empty secret.
+#[tauri::command]
+pub async fn credential_paste_to_pty(
+    registry: State<'_, RegistryState>,
+    pty: String,
+    target: PasteCredential,
+    submit: Option<bool>,
+) -> Result<bool, String> {
+    let account = target.account();
+    let Some(secret) = tokio::task::spawn_blocking(move || creds::get(&account))
+        .await
+        .map_err(|e| format!("credential read task failed: {e}"))?
+    else {
+        return Ok(false);
+    };
+    let mut bytes = secret.into_bytes();
+    if submit.unwrap_or(false) {
+        bytes.push(b'\r');
+    }
+    registry
+        .lock()
+        .unwrap()
+        .write(&pty, &bytes)
+        .map_err(|e| e.to_string())?;
+    Ok(true)
+}
diff --git a/src-tauri/src/commands/debug.rs b/src-tauri/src/commands/debug.rs
index 71cd833..10b3926 100644
--- a/src-tauri/src/commands/debug.rs
+++ b/src-tauri/src/commands/debug.rs
@@ -1,3 +1,4 @@
+use crate::gpustat::GpuSample;
 use serde::Serialize;
 
 #[derive(Debug, Clone, Serialize)]
@@ -5,6 +6,15 @@ pub struct AppResourceUsage {
     pub cpu_percent: f64,
     pub rss_bytes: u64,
     pub process_count: usize,
+    /// VRAM (bytes) in use by local models loaded in Ollama's memory. `0` when
+    /// the Ollama server is down or no model is resident on the GPU. This is
+    /// Ollama's *share* of the GPU — one line of the readout's breakdown, and
+    /// the whole readout only on a machine whose GPU we cannot read (`gpus`
+    /// empty). It is not part of Eldrun's own process tree.
+    pub vram_bytes: u64,
+    /// Every GPU in the machine and its memory, Ollama's models or not. Empty
+    /// when no GPU can be read; see [`crate::gpustat`].
+    pub gpus: Vec<GpuSample>,
 }
 
 /// Debug-only live resource usage for Eldrun's own process tree.
@@ -14,38 +24,33 @@ pub struct AppResourceUsage {
 /// process and any descendants.
 #[tauri::command]
 pub async fn debug_app_resource_usage() -> Result<AppResourceUsage, String> {
-    #[cfg(target_os = "linux")]
-    {
-        use crate::sysstat;
+    use crate::sysstat;
 
-        let root = eldrun_process_root(std::process::id());
-        let pids = sysstat::descendant_pids(&[root]);
-        let interval = std::time::Duration::from_millis(300);
-        let t0 = sysstat::sum_jiffies(&pids);
-        tokio::time::sleep(interval).await;
-        let t1 = sysstat::sum_jiffies(&pids);
+    let root = eldrun_process_root(std::process::id());
+    let pids = sysstat::descendant_pids(&[root]);
+    let interval = std::time::Duration::from_millis(300);
+    let t0 = sysstat::sum_jiffies(&pids);
+    tokio::time::sleep(interval).await;
+    let t1 = sysstat::sum_jiffies(&pids);
 
-        let busy_secs = t1.saturating_sub(t0) as f64 / sysstat::clk_tck() as f64;
-        let cpu_percent = busy_secs / interval.as_secs_f64() * 100.0;
-        let rss_bytes = sysstat::sum_rss_kib(&pids) * 1024;
+    let busy_secs = t1.saturating_sub(t0) as f64 / sysstat::clk_tck() as f64;
+    let cpu_percent = busy_secs / interval.as_secs_f64() * 100.0;
+    let rss_bytes = sysstat::sum_rss_kib(&pids) * 1024;
 
-        Ok(AppResourceUsage {
-            cpu_percent: (cpu_percent * 10.0).round() / 10.0,
-            rss_bytes,
-            process_count: pids.len(),
-        })
-    }
-    #[cfg(not(target_os = "linux"))]
-    {
-        Ok(AppResourceUsage {
-            cpu_percent: 0.0,
-            rss_bytes: 0,
-            process_count: 0,
-        })
-    }
+    Ok(AppResourceUsage {
+        cpu_percent: (cpu_percent * 10.0).round() / 10.0,
+        rss_bytes,
+        process_count: pids.len(),
+        vram_bytes: crate::commands::ollama::total_vram_in_use(),
+        gpus: crate::gpustat::snapshot(),
+    })
 }
 
-#[cfg(target_os = "linux")]
+/// Walk up to the process that owns the running app. In `tauri dev` the useful
+/// total is the npm/tauri/vite tree, so we climb to the highest ancestor whose
+/// command line names the dev runner. Where the backend can't read command lines
+/// (Windows, and packaged builds), no ancestor matches and this returns `pid`
+/// itself — which is exactly the app process in a packaged build.
 fn eldrun_process_root(pid: u32) -> u32 {
     let mut current = pid;
     let mut best = pid;
@@ -68,7 +73,7 @@ fn eldrun_process_root(pid: u32) -> u32 {
     best
 }
 
-#[cfg(all(test, target_os = "linux"))]
+#[cfg(test)]
 mod tests {
     use super::*;
 
diff --git a/src-tauri/src/commands/disk_usage.rs b/src-tauri/src/commands/disk_usage.rs
new file mode 100644
index 0000000..73b0e9c
--- /dev/null
+++ b/src-tauri/src/commands/disk_usage.rs
@@ -0,0 +1,160 @@
+//! Tauri surface for the Disk Usage Analyzer pane.
+//!
+//! Thin, like `commands::monitor`: the scanning itself lives in [`crate::duscan`]
+//! (pure, unit-tested, `AppHandle`-free); this module only dispatches local vs
+//! remote, streams progress, and owns the cancel registry.
+//!
+//! A scan can take minutes (`/`, a big `$HOME`), so every branch runs inside
+//! `spawn_blocking` — a blocking body on a sync command runs on the UI thread and
+//! freezes the whole window, which is exactly the failure the remote git commands
+//! hit before. The caller mints a `scan_id`, listens for `disk-scan-progress`, and
+//! can abort mid-walk with [`disk_usage_cancel`].
+
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+use serde::Serialize;
+use tauri::{AppHandle, Emitter, State};
+
+use crate::duscan::{self, DuDevice, DuScan, Tally};
+
+/// Cancel flags for the scans currently in flight, keyed by the frontend's
+/// `scan_id`. An entry lives only for the duration of its scan.
+pub type DuScanState = Arc<Mutex<HashMap<String, Arc<AtomicBool>>>>;
+
+pub fn new_state() -> DuScanState {
+    Arc::new(Mutex::new(HashMap::new()))
+}
+
+/// Progress payload for the `disk-scan-progress` event, keyed by `scan_id` so a
+/// pane ignores other panes' scans. Bookended `start` / `dir` / `done` phases,
+/// mirroring `commands::sync`'s `sync-progress`. snake_case on the wire.
+#[derive(Debug, Clone, Serialize)]
+struct DuProgress {
+    scan_id: String,
+    /// `start` | `dir` | `done`.
+    phase: String,
+    /// The directory being read (`phase == "dir"`), else the scan root.
+    path: String,
+    files: u64,
+    dirs: u64,
+    bytes: u64,
+}
+
+fn emit(app: &AppHandle, scan_id: &str, phase: &str, path: &str, t: &Tally) {
+    let _ = app.emit(
+        "disk-scan-progress",
+        DuProgress {
+            scan_id: scan_id.to_string(),
+            phase: phase.to_string(),
+            path: path.to_string(),
+            files: t.files,
+            dirs: t.dirs,
+            bytes: t.bytes,
+        },
+    );
+}
+
+/// Scan `root` and return its size tree.
+///
+/// `project_id` selects the machine: a project with a `remote` spec scans on the
+/// **host** (and `root` is a path over there), anything else scans locally. As in
+/// `fs::dir_size`, remoteness is resolved *before* any local-fs access — a remote
+/// project's stored directory is a local state dir, not the tree being measured.
+#[tauri::command]
+pub async fn disk_usage_scan(
+    app: AppHandle,
+    scan_id: String,
+    root: String,
+    project_id: Option<String>,
+    confirmed: Option<bool>,
+    state: State<'_, DuScanState>,
+) -> Result<DuScan, String> {
+    let remote = project_id
+        .as_deref()
+        .and_then(crate::services::remote::remote_target_for);
+
+    // A scan of a host tagged HPC is refused until the user confirms this run.
+    // `remote_du_tree` stats every file under `root`, and on a cluster that root
+    // is normally on the parallel filesystem — the one recursive walk a site's
+    // filesystem guide names outright. Refusing rather than silently skipping,
+    // and per-run rather than once, because the pane's whole purpose is that walk:
+    // a scan the user asked for by name is theirs to have, a scan a pane opened
+    // for them is not (`services::hpc_mode::HPC_GUARD`).
+    if let Some(target) = remote.as_ref() {
+        if confirmed != Some(true) && crate::services::hpc_mode::is_hpc_spec(&target.spec) {
+            return Err(crate::services::hpc_mode::guard_error("du-scan", &target.spec));
+        }
+    }
+
+    // A confirmed scan is the user asking for this machine by name, so it also
+    // clears the dial policy (`ssh_common::authorize_dial`) that would otherwise
+    // refuse the walk's own ssh — one confirmation covers the whole act, not the
+    // scan only to be stopped again one layer down.
+    let _dial = remote
+        .as_ref()
+        .filter(|_| confirmed == Some(true))
+        .map(|t| {
+            crate::services::ssh_common::user_dial(&t.spec.user, &t.spec.host, t.spec.port)
+        });
+
+    let cancel = Arc::new(AtomicBool::new(false));
+    if let Ok(mut map) = state.lock() {
+        map.insert(scan_id.clone(), cancel.clone());
+    }
+
+    let result = if let Some(target) = remote {
+        let spec = target.spec.clone();
+        let root = root.clone();
+        tokio::task::spawn_blocking(move || {
+            crate::services::ssh_exec::remote_du_tree(&spec, &root)
+        })
+        .await
+        .map_err(|e| e.to_string())?
+    } else {
+        let app2 = app.clone();
+        let id = scan_id.clone();
+        let root = root.clone();
+        emit(&app, &scan_id, "start", &root, &Tally::default());
+        tokio::task::spawn_blocking(move || {
+            let mut on_progress = |t: &Tally, at: &std::path::Path| {
+                emit(&app2, &id, "dir", &at.to_string_lossy(), t);
+            };
+            duscan::scan_local(&root, &cancel, &mut on_progress)
+        })
+        .await
+        .map_err(|e| e.to_string())?
+    };
+
+    if let Ok(mut map) = state.lock() {
+        map.remove(&scan_id);
+    }
+    let done = result
+        .as_ref()
+        .map(|s| Tally { files: s.files, dirs: s.dirs, bytes: s.root.size, errors: s.errors })
+        .unwrap_or_default();
+    emit(&app, &scan_id, "done", &root, &done);
+
+    result
+}
+
+/// Ask an in-flight **local** scan to stop. It returns the partial tree it had
+/// built, with `cancelled` set. A no-op for an unknown or already-finished
+/// `scan_id` — and for a remote scan, which is a single `du` round-trip on the host
+/// with no walk of ours to interrupt.
+#[tauri::command]
+pub fn disk_usage_cancel(scan_id: String, state: State<'_, DuScanState>) {
+    if let Ok(map) = state.lock() {
+        if let Some(flag) = map.get(&scan_id) {
+            flag.store(true, Ordering::Relaxed);
+        }
+    }
+}
+
+/// Scan targets offered on the pane's home screen (home dir + its filesystem),
+/// each with its capacity where the platform can tell us.
+#[tauri::command]
+pub async fn disk_usage_devices() -> Result<Vec<DuDevice>, String> {
+    Ok(duscan::devices())
+}
diff --git a/src-tauri/src/commands/downloads.rs b/src-tauri/src/commands/downloads.rs
deleted file mode 100644
index b31ca91..0000000
--- a/src-tauri/src/commands/downloads.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-//! Browser download preference reset — restores the default ~/Downloads folder.
-
-use std::fs;
-use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use serde::{Deserialize, Serialize};
-
-use crate::paths;
-
-fn home_dir() -> String {
-    paths::home_dir_string()
-}
-
-// ── Browser preference editing ─────────────────────────────────────────────
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DownloadsStatus {
-    pub firefox_updated: bool,
-    pub chromium_updated: bool,
-    pub notes: Vec<String>,
-}
-
-/// Reset browser download preferences to the default ~/Downloads folder.
-/// Creates backups and skips locked files.
-#[tauri::command]
-pub fn configure_browser_downloads() -> Result<DownloadsStatus, String> {
-    let home = home_dir();
-    let sep = if cfg!(target_os = "windows") {
-        '\\'
-    } else {
-        '/'
-    };
-    let target = format!("{home}{sep}Downloads");
-    let mut status = DownloadsStatus {
-        firefox_updated: false,
-        chromium_updated: false,
-        notes: Vec::new(),
-    };
-
-    let ff_base = firefox_profile_base();
-    if ff_base.exists() {
-        match update_firefox_prefs(&ff_base, &target) {
-            Ok(updated) => {
-                status.firefox_updated = updated;
-                if !updated {
-                    status
-                        .notes
-                        .push("Firefox prefs.js was locked; skipped".to_string());
-                }
-            }
-            Err(e) => status.notes.push(format!("Firefox error: {e}")),
-        }
-    }
-
-    for base in chromium_profile_bases() {
-        if base.exists() {
-            let label = base.to_string_lossy().to_string();
-            match update_chromium_prefs(&base, &target) {
-                Ok(updated) => {
-                    if updated {
-                        status.chromium_updated = true;
-                    } else {
-                        status
-                            .notes
-                            .push(format!("{label}: Preferences was locked; skipped"));
-                    }
-                }
-                Err(e) => status.notes.push(format!("{label} error: {e}")),
-            }
-        }
-    }
-
-    Ok(status)
-}
-
-fn firefox_profile_base() -> PathBuf {
-    let home = home_dir();
-    if cfg!(target_os = "windows") {
-        let appdata = std::env::var("APPDATA").unwrap_or_else(|_| home);
-        PathBuf::from(appdata).join("Mozilla").join("Firefox")
-    } else if cfg!(target_os = "macos") {
-        PathBuf::from(&home)
-            .join("Library")
-            .join("Application Support")
-            .join("Firefox")
-    } else {
-        PathBuf::from(&home).join(".mozilla").join("firefox")
-    }
-}
-
-fn chromium_profile_bases() -> Vec<PathBuf> {
-    let home = home_dir();
-    if cfg!(target_os = "windows") {
-        let local = std::env::var("LOCALAPPDATA").unwrap_or_else(|_| home);
-        vec![
-            PathBuf::from(&local)
-                .join("Google")
-                .join("Chrome")
-                .join("User Data"),
-            PathBuf::from(&local).join("Chromium").join("User Data"),
-            PathBuf::from(&local)
-                .join("Google")
-                .join("Chrome Beta")
-                .join("User Data"),
-        ]
-    } else if cfg!(target_os = "macos") {
-        let base = PathBuf::from(&home)
-            .join("Library")
-            .join("Application Support");
-        vec![
-            base.join("Google").join("Chrome"),
-            base.join("Chromium"),
-            base.join("Google").join("Chrome Beta"),
-        ]
-    } else {
-        vec![
-            PathBuf::from(&home).join(".config").join("chromium"),
-            PathBuf::from(&home).join(".config").join("google-chrome"),
-            PathBuf::from(&home)
-                .join(".config")
-                .join("google-chrome-beta"),
-        ]
-    }
-}
-
-// ── Firefox prefs.js editor ───────────────────────────────────────────────
-
-fn update_firefox_prefs(ff_base: &Path, download_path: &str) -> Result<bool, String> {
-    let profiles = find_firefox_profiles(ff_base);
-    let mut any_updated = false;
-
-    for profile_dir in profiles {
-        let prefs = profile_dir.join("prefs.js");
-        if !prefs.exists() {
-            continue;
-        }
-        if is_locked(&profile_dir.join(".parentlock")) {
-            continue;
-        }
-        let _backup = backup_file(&prefs)?;
-        let content = fs::read_to_string(&prefs).map_err(|e| e.to_string())?;
-
-        let new_content = set_pref(
-            &content,
-            "browser.download.dir",
-            &format!("\"{download_path}\""),
-        );
-        let new_content = set_pref(&new_content, "browser.download.folderList", "2");
-        let new_content = set_pref(&new_content, "browser.download.useDownloadDir", "true");
-
-        fs::write(&prefs, &new_content).map_err(|e| e.to_string())?;
-        any_updated = true;
-    }
-    Ok(any_updated)
-}
-
-fn find_firefox_profiles(ff_base: &Path) -> Vec<PathBuf> {
-    let mut profiles = Vec::new();
-    if let Ok(entries) = fs::read_dir(ff_base) {
-        for entry in entries.flatten() {
-            let path = entry.path();
-            if path.is_dir() {
-                let name = entry.file_name().to_string_lossy().to_string();
-                if name.contains('.') || name == "Crash Reports" || name == "Pending Pings" {
-                    continue;
-                }
-                profiles.push(path);
-            }
-        }
-    }
-    let ini = ff_base.join("profiles.ini");
-    if let Ok(content) = fs::read_to_string(&ini) {
-        for line in content.lines() {
-            if let Some(path_str) = line.strip_prefix("Path=") {
-                let p = if Path::new(path_str).is_absolute() {
-                    PathBuf::from(path_str)
-                } else {
-                    ff_base.join(path_str)
-                };
-                if p.exists() && !profiles.contains(&p) {
-                    profiles.push(p);
-                }
-            }
-        }
-    }
-    profiles
-}
-
-fn set_pref(content: &str, key: &str, value: &str) -> String {
-    let pattern = format!("user_pref(\"{key}\"");
-    let new_line = format!("user_pref(\"{key}\", {value});");
-    if let Some(pos) = content.find(&pattern) {
-        let end = content[pos..]
-            .find('\n')
-            .map(|i| pos + i + 1)
-            .unwrap_or(content.len());
-        format!("{}{new_line}\n{}", &content[..pos], &content[end..])
-    } else {
-        format!("{content}{new_line}\n")
-    }
-}
-
-// ── Chromium/Chrome Preferences editor ────────────────────────────────────
-
-fn update_chromium_prefs(base: &Path, download_path: &str) -> Result<bool, String> {
-    let default_dir = base.join("Default");
-    let prefs_file = default_dir.join("Preferences");
-
-    if !prefs_file.exists() {
-        return Ok(false);
-    }
-    if is_locked(&base.join("SingletonLock")) {
-        return Ok(false);
-    }
-
-    let content = fs::read_to_string(&prefs_file).map_err(|e| e.to_string())?;
-    let mut prefs: serde_json::Value =
-        serde_json::from_str(&content).map_err(|e| format!("JSON parse: {e}"))?;
-
-    backup_file(&prefs_file)?;
-
-    if let Some(obj) = prefs.as_object_mut() {
-        let download = obj
-            .entry("download")
-            .or_insert_with(|| serde_json::Value::Object(Default::default()))
-            .as_object_mut()
-            .ok_or("download is not an object")?;
-        download.insert(
-            "default_directory".to_string(),
-            serde_json::Value::String(download_path.to_string()),
-        );
-        download.insert(
-            "prompt_for_download".to_string(),
-            serde_json::Value::Bool(false),
-        );
-    }
-
-    let new_content = serde_json::to_string_pretty(&prefs).map_err(|e| e.to_string())?;
-    fs::write(&prefs_file, new_content).map_err(|e| e.to_string())?;
-    Ok(true)
-}
-
-// ── Shared helpers ────────────────────────────────────────────────────────
-
-fn is_locked(lock_file: &Path) -> bool {
-    lock_file.exists()
-}
-
-fn backup_file(path: &Path) -> Result<PathBuf, String> {
-    let ts = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs();
-    let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("file");
-    let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
-    let backup_name = if ext.is_empty() {
-        format!("{stem}.{ts}.bak")
-    } else {
-        format!("{stem}.{ts}.bak.{ext}")
-    };
-    let backup = path.with_file_name(backup_name);
-    fs::copy(path, &backup).map_err(|e| format!("backup: {e}"))?;
-    Ok(backup)
-}
diff --git a/src-tauri/src/commands/format.rs b/src-tauri/src/commands/format.rs
new file mode 100644
index 0000000..8110369
--- /dev/null
+++ b/src-tauri/src/commands/format.rs
@@ -0,0 +1,279 @@
+//! Source-formatting and syntax-checking command handlers backing the in-app
+//! text viewer's "Format" button and inline validation banner.
+//!
+//! Formatting shells out to whatever external formatter is available for the
+//! language — `prettier` (web/markup/JSON family), `black` (Python), `rustfmt`
+//! (Rust), `gofmt` (Go) — each invoked over stdin→stdout so nothing touches
+//! disk. Prettier is resolved from a project-local `node_modules/.bin` first
+//! (walking up from the edited file) and only then from `PATH`, so a repo's
+//! pinned formatter wins. When no tool is found the command returns a typed
+//! `formatter-unavailable:<lang>` error and the frontend disables the button.
+//!
+//! Syntax checking is done in-process via `serde_json`/`serde_yaml`, which give
+//! an exact line/column for the first parse error — more reliable than the
+//! webview's `JSON.parse`, whose JavaScriptCore messages carry no position.
+
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+
+use serde::Serialize;
+
+/// A resolved external formatter: the executable plus the args to invoke it with
+/// (it always reads the source on stdin and writes the result to stdout).
+struct Tool {
+    program: PathBuf,
+    args: Vec<String>,
+    /// Directory to run the tool in (so prettier finds the repo's config), if
+    /// the edited file's directory is known.
+    cwd: Option<PathBuf>,
+}
+
+/// Find the first executable named `name` on `PATH`, if any.
+fn on_path(name: &str) -> Option<PathBuf> {
+    crate::paths::resolve_executable(name)
+}
+
+/// Walk up from `start` looking for a `node_modules/.bin/<name>` executable, so a
+/// project's pinned prettier is preferred over a global one.
+fn node_bin(start: &Path, name: &str) -> Option<PathBuf> {
+    let mut dir = Some(start);
+    while let Some(d) = dir {
+        let bin_dir = d.join("node_modules").join(".bin");
+        if let Some(cand) = crate::paths::resolve_executable_in_dir(&bin_dir, name) {
+            return Some(cand);
+        }
+        dir = d.parent();
+    }
+    None
+}
+
+/// The extension a synthetic stdin filename should carry for `lang`, so prettier
+/// can infer its parser when the real path is unknown.
+fn synth_ext(lang: &str) -> &str {
+    match lang {
+        "css" => "css",
+        "scss" => "scss",
+        "less" => "less",
+        "html" => "html",
+        "json" => "json",
+        "js" => "js",
+        "jsx" => "jsx",
+        "ts" => "ts",
+        "tsx" => "tsx",
+        "yaml" => "yaml",
+        "vue" => "vue",
+        "graphql" => "graphql",
+        "markdown" => "md",
+        "python" => "py",
+        "rust" => "rs",
+        "go" => "go",
+        _ => "txt",
+    }
+}
+
+/// Languages prettier handles in this app.
+fn is_prettier_lang(lang: &str) -> bool {
+    matches!(
+        lang,
+        "css" | "scss"
+            | "less"
+            | "html"
+            | "json"
+            | "js"
+            | "jsx"
+            | "ts"
+            | "tsx"
+            | "yaml"
+            | "vue"
+            | "graphql"
+            | "markdown"
+    )
+}
+
+/// Resolve the formatter for `lang`, using `path` (when known) to find a
+/// project-local prettier and to label prettier's stdin parser. Returns `None`
+/// when no suitable tool is installed.
+fn resolve_tool(lang: &str, path: Option<&str>) -> Option<Tool> {
+    let file_dir = path
+        .and_then(|p| Path::new(p).parent())
+        .map(Path::to_path_buf);
+    let file_name = path
+        .and_then(|p| Path::new(p).file_name())
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_else(|| format!("stdin.{}", synth_ext(lang)));
+
+    if is_prettier_lang(lang) {
+        let program = file_dir
+            .as_deref()
+            .and_then(|d| node_bin(d, "prettier"))
+            .or_else(|| on_path("prettier"))?;
+        return Some(Tool {
+            program,
+            args: vec!["--stdin-filepath".into(), file_name],
+            cwd: file_dir,
+        });
+    }
+
+    let (bin, args): (&str, Vec<String>) = match lang {
+        // `black -q -` formats stdin → stdout quietly.
+        "python" => ("black", vec!["-q".into(), "-".into()]),
+        // rustfmt and gofmt both read stdin and write stdout with no args.
+        "rust" => ("rustfmt", vec![]),
+        "go" => ("gofmt", vec![]),
+        _ => return None,
+    };
+    let program = on_path(bin)?;
+    Some(Tool {
+        program,
+        args,
+        cwd: file_dir,
+    })
+}
+
+/// Whether a formatter for `lang` is available (drives the button's enabled
+/// state). `path` lets a project-local prettier count.
+#[tauri::command]
+pub fn formatter_available(lang: String, path: Option<String>) -> bool {
+    resolve_tool(&lang, path.as_deref()).is_some()
+}
+
+/// Format `text` as `lang` via the resolved external tool, returning the
+/// formatted source. Errors:
+///  - `formatter-unavailable:<lang>` when no tool is installed (frontend disables
+///    the button and shows a hint),
+///  - the tool's stderr (trimmed) when it exits non-zero (e.g. a syntax error).
+#[tauri::command]
+pub fn format_source(text: String, lang: String, path: Option<String>) -> Result<String, String> {
+    let tool = resolve_tool(&lang, path.as_deref())
+        .ok_or_else(|| format!("formatter-unavailable:{lang}"))?;
+
+    let mut cmd = crate::paths::command_for_program(&tool.program);
+    cmd.args(&tool.args)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+    if let Some(cwd) = &tool.cwd {
+        cmd.current_dir(cwd);
+    }
+
+    let mut child = cmd
+        .spawn()
+        .map_err(|e| format!("formatter-unavailable:{lang}: {e}"))?;
+
+    // Write the source and drop the handle so the tool sees EOF, then collect
+    // output. Dropping before `wait_with_output` avoids a stdin/stdout deadlock.
+    {
+        let mut stdin = child
+            .stdin
+            .take()
+            .ok_or_else(|| "could not open formatter stdin".to_string())?;
+        stdin
+            .write_all(text.as_bytes())
+            .map_err(|e| e.to_string())?;
+    }
+
+    let output = child.wait_with_output().map_err(|e| e.to_string())?;
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
+    } else {
+        let err = String::from_utf8_lossy(&output.stderr);
+        let trimmed = err.trim();
+        Err(if trimmed.is_empty() {
+            format!("{} exited with a non-zero status", tool.program.display())
+        } else {
+            trimmed.to_string()
+        })
+    }
+}
+
+/// The first parse error in a checked document: 1-based `line`/`column` and the
+/// parser's message. Columns/lines of 0 mean "position unknown".
+#[derive(Debug, Serialize)]
+pub struct SyntaxIssue {
+    pub line: usize,
+    pub column: usize,
+    pub message: String,
+}
+
+/// Validate `text` as `lang` (`"json"` or `"yaml"`), returning the first parse
+/// error or `None` when it is well-formed. Whitespace-only input is treated as
+/// valid (an empty buffer isn't an error to surface while typing). Any other
+/// `lang` is unchecked and returns `None`.
+#[tauri::command]
+pub fn check_syntax(text: String, lang: String) -> Option<SyntaxIssue> {
+    if text.trim().is_empty() {
+        return None;
+    }
+    match lang.as_str() {
+        "json" => match serde_json::from_str::<serde::de::IgnoredAny>(&text) {
+            Ok(_) => None,
+            Err(e) => Some(SyntaxIssue {
+                line: e.line(),
+                column: e.column(),
+                message: e.to_string(),
+            }),
+        },
+        "yaml" => match serde_yaml::from_str::<serde_yaml::Value>(&text) {
+            Ok(_) => None,
+            Err(e) => {
+                let (line, column) = e
+                    .location()
+                    .map(|loc| (loc.line(), loc.column()))
+                    .unwrap_or((0, 0));
+                Some(SyntaxIssue {
+                    line,
+                    column,
+                    message: e.to_string(),
+                })
+            }
+        },
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn json_ok_is_none() {
+        assert!(check_syntax("{\"a\": 1}".into(), "json".into()).is_none());
+    }
+
+    #[test]
+    fn json_error_reports_position() {
+        let issue = check_syntax("{\"a\": }".into(), "json".into()).expect("should error");
+        assert_eq!(issue.line, 1);
+        assert!(issue.column > 0);
+    }
+
+    #[test]
+    fn blank_input_is_valid() {
+        assert!(check_syntax("   \n  ".into(), "json".into()).is_none());
+        assert!(check_syntax("".into(), "yaml".into()).is_none());
+    }
+
+    #[test]
+    fn yaml_ok_and_error() {
+        assert!(check_syntax("a: 1\nb: 2\n".into(), "yaml".into()).is_none());
+        // A tab in indentation is invalid YAML.
+        assert!(check_syntax("a:\n\t- 1\n".into(), "yaml".into()).is_some());
+    }
+
+    #[test]
+    fn unknown_lang_is_unchecked() {
+        assert!(check_syntax("@@@ not checked".into(), "python".into()).is_none());
+    }
+
+    #[test]
+    fn unavailable_formatter_is_typed_error() {
+        // A language with no installed tool yields the typed sentinel; we can't
+        // assume any formatter is installed in CI, so only assert the prefix when
+        // it is in fact unavailable.
+        if !formatter_available("rust".into(), None) {
+            let err = format_source("fn  main(){}".into(), "rust".into(), None).unwrap_err();
+            assert!(err.starts_with("formatter-unavailable:"));
+        }
+    }
+}
diff --git a/src-tauri/src/commands/fs.rs b/src-tauri/src/commands/fs.rs
index bc84c25..6302cf4 100644
--- a/src-tauri/src/commands/fs.rs
+++ b/src-tauri/src/commands/fs.rs
@@ -43,14 +43,70 @@ fn mime_for_ext(ext: &str) -> String {
         .to_string()
 }
 
-/// List directory contents — validates the path stays inside the project root.
+/// Build a [`FileEntry`] from a directory entry's path + metadata. Shared by the
+/// project-confined lister ([`list_dir_local`]) and the unconfined downloads
+/// scanner ([`list_recent_downloads`]) so both produce byte-identical shapes.
+fn file_entry_from(path: &Path, meta: &fs::Metadata, name: String) -> FileEntry {
+    let ext = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|s| format!(".{s}"));
+    // Efficiency #15: compute the MIME lazily from the extension only when there
+    // is one, instead of always producing octet-stream fallbacks.
+    let mime = ext.as_deref().map(mime_for_ext);
+    FileEntry {
+        name,
+        path: display_path(path),
+        is_dir: meta.is_dir(),
+        size: if meta.is_file() { meta.len() } else { 0 },
+        modified_secs: meta
+            .modified()
+            .ok()
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs()),
+        created_secs: meta
+            .created()
+            .ok()
+            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+            .map(|d| d.as_secs()),
+        extension: ext,
+        mime,
+    }
+}
+
+/// List directory contents — project-aware (mount-free remote, Phase 2):
+///
+/// - **Remote project** → list the directory over SFTP, riding the pooled
+///   session opened on activation (`services::remote`), or a one-shot session if
+///   the pool is cold. Detected FIRST, before any local-fs touch, via
+///   [`remote_target_for_dir`] (the `project_dir` the frontend passes is the
+///   project's stored `directory`).
+/// - **Local project** → `fs::read_dir`, validating the path stays inside the
+///   project root. Byte-identical to the pre-Phase-2 behavior.
+///
+/// `pool` is Tauri-injected managed state; the frontend does not pass it.
 #[tauri::command]
-pub fn list_dir(project_dir: String, rel_path: String) -> Result<Vec<FileEntry>, String> {
-    let root = canonical(&project_dir)?;
+pub async fn list_dir(
+    project_dir: String,
+    rel_path: String,
+    pool: tauri::State<'_, crate::services::remote::RemotePoolState>,
+) -> Result<Vec<FileEntry>, String> {
+    // Detect remote BEFORE any local-fs access (`canonical` would touch the fs).
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        return list_dir_remote(&target, &rel_path, pool.inner()).await;
+    }
+    list_dir_local(&project_dir, &rel_path)
+}
+
+/// Local-fs directory listing — the pre-Phase-2 behavior, byte-identical.
+/// Split out of the `list_dir` command so it stays sync (no Tauri `State`) and
+/// is directly unit/integration-testable.
+pub fn list_dir_local(project_dir: &str, rel_path: &str) -> Result<Vec<FileEntry>, String> {
+    let root = canonical(project_dir)?;
     let target = if rel_path.is_empty() {
         root.clone()
     } else {
-        canonical(&root.join(&rel_path).to_string_lossy().to_string())?
+        canonical(&root.join(rel_path).to_string_lossy().to_string())?
     };
 
     enforce_confinement(&root, &target)?;
@@ -69,37 +125,498 @@ pub fn list_dir(project_dir: String, rel_path: String) -> Result<Vec<FileEntry>,
         if name == ".eldrun" {
             continue;
         }
-        let ext = path
-            .extension()
-            .and_then(|e| e.to_str())
-            .map(|s| format!(".{s}"));
-        // Efficiency #15: compute the MIME lazily from the extension only when
-        // there is one, instead of always producing octet-stream fallbacks.
-        let mime = ext.as_deref().map(mime_for_ext);
-
-        result.push(FileEntry {
-            name,
-            path: path.to_string_lossy().to_string(),
-            is_dir: meta.is_dir(),
-            size: if meta.is_file() { meta.len() } else { 0 },
-            modified_secs: meta
-                .modified()
-                .ok()
-                .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
-                .map(|d| d.as_secs()),
-            created_secs: meta
-                .created()
-                .ok()
-                .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
-                .map(|d| d.as_secs()),
-            extension: ext,
-            mime,
-        });
+        result.push(file_entry_from(&path, &meta, name));
     }
     result.sort_by_key(|entry| (!entry.is_dir, entry.name.to_lowercase()));
     Ok(result)
 }
 
+/// Scan one or more download *source* folders and return their recently-modified
+/// entries, merged and sorted newest-first. Backs the right-panel Downloads
+/// section (fast-copy of freshly downloaded files into a project).
+///
+/// Unlike [`list_dir`], the `paths` are user-chosen source folders that live
+/// OUTSIDE any project root, so path-confinement deliberately does not apply here
+/// — this is a read-only scan the user explicitly configured. Missing/unreadable
+/// folders are skipped rather than failing the whole call (a stale configured
+/// path must not break the section). Dot-hidden entries are skipped; top-level
+/// files and folders are included (a browser can drop a folder), no recursion.
+///
+/// `since_secs` (Unix seconds) keeps only entries modified at or after it; `None`
+/// returns everything. Results are sorted by `modified_secs` descending, then by
+/// name, so the most recent download is first.
+#[tauri::command]
+pub fn list_recent_downloads(
+    paths: Vec<String>,
+    since_secs: Option<u64>,
+) -> Result<Vec<FileEntry>, String> {
+    let mut result: Vec<FileEntry> = Vec::new();
+    let mut seen: HashSet<String> = HashSet::new();
+    for dir in &paths {
+        let entries = match fs::read_dir(dir) {
+            Ok(e) => e,
+            // Missing/unreadable source dir — skip it, don't fail the whole scan.
+            Err(_) => continue,
+        };
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let meta = match entry.metadata() {
+                Ok(m) => m,
+                Err(_) => continue,
+            };
+            let name = entry.file_name().to_string_lossy().to_string();
+            // Skip dot-hidden entries (partial-download temp files, etc.).
+            if name.starts_with('.') {
+                continue;
+            }
+            let fe = file_entry_from(&path, &meta, name);
+            if let Some(since) = since_secs {
+                if !matches!(fe.modified_secs, Some(m) if m >= since) {
+                    continue;
+                }
+            }
+            // De-dupe when the same absolute path is reachable via two configured
+            // source folders (e.g. a folder plus a symlink pointing into it).
+            if seen.insert(fe.path.clone()) {
+                result.push(fe);
+            }
+        }
+    }
+    result.sort_by(|a, b| {
+        b.modified_secs
+            .cmp(&a.modified_secs)
+            .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+    });
+    Ok(result)
+}
+
+// ── Remote (SFTP) directory listing (mount-free remote, Phase 2) ────────────
+
+/// List a remote project's directory over SFTP and map the entries into the same
+/// `FileEntry` shape the local lister returns. Prefers the pooled session opened
+/// on activation; if the project is not connected (cold pool / dropped link) it
+/// falls back to a one-shot session so browsing still works. An unreachable host
+/// surfaces as the `Err` from the SFTP layer (ConnectTimeout) rather than hanging.
+async fn list_dir_remote(
+    target: &crate::services::remote::RemoteTarget,
+    rel_path: &str,
+    pool: &crate::services::remote::RemotePoolState,
+) -> Result<Vec<FileEntry>, String> {
+    let spec = &target.spec;
+    let remote_dir = join_remote_dir(&spec.remote_path, rel_path);
+
+    let entries = match crate::services::remote::pooled_sftp(pool, &target.project_id).await {
+        Some(sftp) => crate::services::sftp::list_dir_on(&sftp, &remote_dir).await?,
+        // Cold pool: one-shot session (key/agent auth — no stored password). The
+        // one-shot path uses ConnectTimeout so an unreachable host fails fast.
+        None => {
+            crate::services::sftp::list_dir(&spec.user, &spec.host, spec.port, None, &remote_dir)
+                .await?
+        }
+    };
+
+    Ok(entries
+        .into_iter()
+        // Always hide .eldrun/ — mirrors the local lister (internal runtime dir).
+        .filter(|e| e.name != ".eldrun")
+        .map(|e| remote_file_entry(&remote_dir, e))
+        .collect())
+}
+
+/// Recursive byte size of a single directory — project-aware, mirroring
+/// [`list_dir`]. Computed lazily by the file tree (one call per folder shown), so
+/// it is kept off the listing hot path: the tree renders immediately and folder
+/// sizes fill in as they resolve.
+///
+/// - **Remote project** → `du` on the host over SSH (`remote_dir_size`).
+/// - **Local project** → walk the subtree on a blocking thread so a large folder
+///   (e.g. `node_modules`) never stalls the async runtime.
+///
+/// A folder that can't be fully read yields the partial total rather than an
+/// error, since this is a best-effort display aid.
+#[tauri::command]
+pub async fn dir_size(
+    project_dir: String,
+    rel_path: String,
+    excluded: Option<Vec<String>>,
+    pool: tauri::State<'_, crate::services::remote::RemotePoolState>,
+) -> Result<u64, String> {
+    let _ = &pool; // remote path uses SSH exec, not the SFTP pool; keep the arg for symmetry
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let remote_dir = join_remote_dir(&target.spec.remote_path, &rel_path);
+        let spec = target.spec.clone();
+        return tokio::task::spawn_blocking(move || {
+            crate::services::ssh_exec::remote_dir_size(&spec, &remote_dir)
+        })
+        .await
+        .map_err(|e| e.to_string())?;
+    }
+    let excluded = excluded.unwrap_or_default();
+    tokio::task::spawn_blocking(move || dir_size_local(&project_dir, &rel_path, &excluded))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+/// Local-fs recursive directory size (bytes). Confinement-checked like the local
+/// lister, then a symlink-skipping walk (so a symlink cycle can't loop forever).
+pub fn dir_size_local(project_dir: &str, rel_path: &str, excluded: &[String]) -> Result<u64, String> {
+    let root = canonical(project_dir)?;
+    let target = if rel_path.is_empty() {
+        root.clone()
+    } else {
+        canonical(&root.join(rel_path).to_string_lossy().to_string())?
+    };
+    enforce_confinement(&root, &target)?;
+    // The walk builds rel paths from `rel_path` down, so the exclusion list —
+    // which is project-root-relative — matches at any depth under the folder.
+    Ok(walk_dir_size(&target, rel_path.trim_matches('/'), &excluded_rel_set(excluded)))
+}
+
+/// Normalise the caller's scan-exclusion list into the same project-relative,
+/// forward-slash spelling the walks build as they descend.
+///
+/// The list is the user's own (`scan_excluded_paths` in `project.json`, set from
+/// the file tree's "Exclude from scans"), so it is whatever they clicked plus
+/// whatever survived a hand edit: tolerate `./x`, `/x`, `x/`, and Windows
+/// separators rather than silently failing to match one of them.
+pub fn excluded_rel_set(excluded: &[String]) -> HashSet<String> {
+    excluded
+        .iter()
+        .map(|raw| raw.replace('\\', "/"))
+        .map(|rel| rel.trim().trim_matches('/').trim_start_matches("./").to_string())
+        .filter(|rel| !rel.is_empty())
+        .collect()
+}
+
+/// Sum file sizes under `dir`, recursing into subdirectories. Symlinks are never
+/// followed (avoids cycles and double-counting); unreadable dirs/entries are
+/// skipped, so the result is a best-effort total.
+///
+/// `excluded` prunes whole subtrees the user has excluded from scans. It is a
+/// *prune*, not a filter: the point is not to leave those bytes out of the total
+/// but to never descend into them at all — this walk is what made opening a
+/// project with a 50 GB virtualenv peg a core for minutes.
+fn walk_dir_size(dir: &Path, rel_prefix: &str, excluded: &HashSet<String>) -> u64 {
+    let mut total = 0u64;
+    let Ok(rd) = fs::read_dir(dir) else {
+        return 0;
+    };
+    for entry in rd.flatten() {
+        let Ok(ft) = entry.file_type() else { continue };
+        if ft.is_symlink() {
+            continue;
+        }
+        let name = entry.file_name().to_string_lossy().into_owned();
+        let child_rel = if rel_prefix.is_empty() { name } else { format!("{rel_prefix}/{name}") };
+        if excluded.contains(&child_rel) {
+            continue;
+        }
+        if ft.is_dir() {
+            total = total.saturating_add(walk_dir_size(&entry.path(), &child_rel, excluded));
+        } else if ft.is_file() {
+            if let Ok(m) = entry.metadata() {
+                total = total.saturating_add(m.len());
+            }
+        }
+    }
+    total
+}
+
+#[derive(Debug, Serialize)]
+pub struct DirSizeBreakdown {
+    pub total: u64,
+    pub ignored: u64,
+}
+
+/// Recursive byte size of a folder split into git-ignored vs
+/// tracked/untracked content, so a mixed folder (e.g. source alongside a
+/// build output dir) can show how much of its weight is ignored content.
+/// Local projects only: splitting by ignore status needs a `git status`
+/// process, and there is no cheap way to run one against a remote host's
+/// index without a dedicated round trip per lazily-shown folder — a remote
+/// folder (or one with no `.git`) just gets `ignored: 0`, same best-effort
+/// fallback as [`dir_size`] on failure.
+#[tauri::command]
+pub async fn dir_size_breakdown(
+    project_dir: String,
+    rel_path: String,
+    excluded: Option<Vec<String>>,
+) -> Result<DirSizeBreakdown, String> {
+    let excluded = excluded.unwrap_or_default();
+    tokio::task::spawn_blocking(move || dir_size_breakdown_local(&project_dir, &rel_path, &excluded))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn dir_size_breakdown_local(
+    project_dir: &str,
+    rel_path: &str,
+    excluded: &[String],
+) -> Result<DirSizeBreakdown, String> {
+    // A remote project's `project_dir` is a local per-project STATE dir (holds
+    // project.json/sync.json/git_peer.json, never the tree itself) — canonicalizing
+    // it and walking `<state_dir>/<rel_path>` as done below always found nothing and
+    // silently reported 0 bytes for every folder, the "shows 0B" bug. Fixed the same
+    // way `dir_size` already handles it: `du` the real path on the host over SSH.
+    // Deliberately does NOT fall back to a local mirror even when one exists — a
+    // "Remote" view must reflect the host's actual tree (e.g. a folder covered
+    // entirely by `.gitignore`, which lockstep never pushes, must show as absent
+    // there, not silently stand in with the mirror's copy). That substitution
+    // already belongs to the frontend's own Local/Remote toggle: selecting "Local"
+    // routes `list_dir`/`dir_size`/`dir_size_breakdown` straight at the mirror path
+    // before this command is ever called with a remote `project_dir`.
+    if let Some(target) = crate::services::remote::remote_target_for_dir(project_dir) {
+        let remote_dir = join_remote_dir(&target.spec.remote_path, rel_path);
+        let total = crate::services::ssh_exec::remote_dir_size(&target.spec, &remote_dir)?;
+        return Ok(DirSizeBreakdown { total, ignored: 0 });
+    }
+
+    let root = canonical(project_dir)?;
+    let target = if rel_path.is_empty() {
+        root.clone()
+    } else {
+        canonical(&root.join(rel_path).to_string_lossy().to_string())?
+    };
+    enforce_confinement(&root, &target)?;
+
+    let prefix = rel_path.trim_matches('/');
+    let excluded = excluded_rel_set(excluded);
+    if !root.join(".git").exists() {
+        return Ok(DirSizeBreakdown { total: walk_dir_size(&target, prefix, &excluded), ignored: 0 });
+    }
+
+    let ignored = ignored_paths_under(&root, rel_path);
+    let (total, ignored_bytes) = walk_dir_size_breakdown(&target, prefix, &ignored, &excluded);
+    Ok(DirSizeBreakdown { total, ignored: ignored_bytes })
+}
+
+/// The set of repo-root-relative paths (matching git's own porcelain output)
+/// that `git status` reports as ignored (`!!`) anywhere under `rel_path`.
+/// `--untracked-files=all` is what makes this useful: without it, git
+/// collapses a wholly-ignored directory to one line for the directory itself
+/// rather than recursing into it (see `commands::git::git_file_statuses`'s
+/// `wholly_ignored` handling for the same quirk) — here we want every
+/// individual ignored file, at any depth, so [`walk_dir_size_breakdown`] can
+/// classify each file it visits by simple set membership. A failed/absent
+/// `git` yields an empty set, so the breakdown degrades to "0 ignored"
+/// rather than erroring.
+fn ignored_paths_under(root: &Path, rel_path: &str) -> HashSet<String> {
+    let mut args = vec!["status", "--porcelain", "--ignored", "--untracked-files=all"];
+    if !rel_path.is_empty() {
+        args.push("--");
+        args.push(rel_path);
+    }
+    let Ok(out) = crate::paths::command_no_window("git").args(&args).current_dir(root).output() else {
+        return HashSet::new();
+    };
+    let text = String::from_utf8_lossy(&out.stdout);
+    text.lines()
+        .filter_map(|line| {
+            if line.len() < 4 || &line[..2] != "!!" {
+                return None;
+            }
+            Some(line[3..].trim_matches('"').to_string())
+        })
+        .collect()
+}
+
+/// Like [`walk_dir_size`], but also sums the subset of bytes whose
+/// repo-root-relative path (`rel_prefix` + entry name, built up as recursion
+/// descends) is in `ignored`. Directories themselves never appear in
+/// `ignored` (git only reports leaf files under `--untracked-files=all`), so
+/// this always recurses rather than short-circuiting on a directory match —
+/// the leaf files inside eventually match individually regardless of depth.
+fn walk_dir_size_breakdown(
+    dir: &Path,
+    rel_prefix: &str,
+    ignored: &HashSet<String>,
+    excluded: &HashSet<String>,
+) -> (u64, u64) {
+    let mut total = 0u64;
+    let mut ignored_total = 0u64;
+    let Ok(rd) = fs::read_dir(dir) else {
+        return (0, 0);
+    };
+    for entry in rd.flatten() {
+        let Ok(ft) = entry.file_type() else { continue };
+        if ft.is_symlink() {
+            continue;
+        }
+        let name = entry.file_name().to_string_lossy().into_owned();
+        let child_rel = if rel_prefix.is_empty() { name } else { format!("{rel_prefix}/{name}") };
+        if excluded.contains(&child_rel) {
+            continue;
+        }
+        if ft.is_dir() {
+            let (t, i) = walk_dir_size_breakdown(&entry.path(), &child_rel, ignored, excluded);
+            total = total.saturating_add(t);
+            ignored_total = ignored_total.saturating_add(i);
+        } else if ft.is_file() {
+            if let Ok(m) = entry.metadata() {
+                let bytes = m.len();
+                total = total.saturating_add(bytes);
+                if ignored.contains(&child_rel) {
+                    ignored_total = ignored_total.saturating_add(bytes);
+                }
+            }
+        }
+    }
+    (total, ignored_total)
+}
+
+/// Join a remote project root (`remote_path`) with a project-relative path,
+/// mirroring `ssh_exec::remote_subdir`-style joining: trim a trailing '/', then
+/// append the non-empty rel. Pure, so it is unit-tested without a live host.
+fn join_remote_dir(remote_path: &str, rel: &str) -> String {
+    let base = remote_path.trim_end_matches('/');
+    let rel = rel.trim_start_matches('/');
+    if rel.is_empty() {
+        if base.is_empty() { "/".to_string() } else { base.to_string() }
+    } else if base.is_empty() {
+        format!("/{rel}")
+    } else {
+        format!("{base}/{rel}")
+    }
+}
+
+/// Map one SFTP [`Entry`](crate::services::sftp::Entry) into a `FileEntry`. The
+/// `path` is the **absolute remote path** (`remote_dir`/name) so the frontend's
+/// existing absolute-path model keeps working during the sshfs→SFTP transition.
+/// `extension`/`mime` come from the file name (as the local lister does);
+/// `created_secs` is unavailable over SFTP.
+fn remote_file_entry(remote_dir: &str, e: crate::services::sftp::Entry) -> FileEntry {
+    let path = format!("{}/{}", remote_dir.trim_end_matches('/'), e.name);
+    let ext = Path::new(&e.name)
+        .extension()
+        .and_then(|s| s.to_str())
+        .map(|s| format!(".{s}"));
+    let mime = ext.as_deref().map(mime_for_ext);
+    FileEntry {
+        name: e.name,
+        path,
+        is_dir: e.is_dir,
+        size: e.size,
+        modified_secs: e.modified_secs,
+        created_secs: None,
+        extension: ext,
+        mime,
+    }
+}
+
+// ── Remote (SFTP) file I/O dispatch (mount-free remote, Phase 3) ────────────
+//
+// Each remote operation is pooled-session-first with a one-shot fallback — the
+// I/O analogue of `list_dir_remote`. Confinement is the remote counterpart of
+// the local `confine_abs`/`enforce_confinement`: a project-relative path is
+// validated to stay under the project root (no `..`/absolute escape), and an
+// absolute remote path must resolve at or under `spec.remote_path`.
+
+type RemoteTarget = crate::services::remote::RemoteTarget;
+type RemotePoolState = crate::services::remote::RemotePoolState;
+
+/// Resolve a project-relative path under a remote project root, rejecting
+/// `..`/absolute traversal — the remote analogue of `canonical` + relative
+/// `enforce_confinement`. Reuses `normalize_project_rel_path` (which rejects
+/// `..`/root components and strips a leading `/`), then joins onto the root.
+pub(crate) fn remote_join_confined(remote_root: &str, rel_path: &str) -> Result<String, String> {
+    let clean = normalize_project_rel_path(rel_path)?;
+    Ok(join_remote_dir(remote_root, &clean))
+}
+
+/// Confine an **absolute** remote path to the project's remote root: reject any
+/// parent-directory component and require the path to sit at or under
+/// `remote_root` on a path boundary (so `/srv/proj-evil` is NOT inside
+/// `/srv/proj`). The remote analogue of `confine_abs_within`. Pure, unit-tested.
+fn confine_remote_abs(remote_root: &str, path: &str) -> Result<(), String> {
+    if Path::new(path)
+        .components()
+        .any(|c| matches!(c, std::path::Component::ParentDir))
+    {
+        return Err(format!("remote path '{path}' contains a parent-directory component"));
+    }
+    let root = remote_root.trim_end_matches('/');
+    let p = path.trim_end_matches('/');
+    let inside = root.is_empty() // remote_path "/" → the whole remote fs is the root
+        || p == root
+        || p.strip_prefix(root).is_some_and(|rest| rest.starts_with('/'));
+    if inside {
+        Ok(())
+    } else {
+        Err(format!(
+            "remote path '{path}' is outside the project root '{remote_root}'"
+        ))
+    }
+}
+
+/// Clone the pooled SFTP session for the target's project, or `None` (cold pool).
+async fn pooled(pool: &RemotePoolState, target: &RemoteTarget) -> Option<std::sync::Arc<openssh_sftp_client::Sftp>> {
+    crate::services::remote::pooled_sftp(pool, &target.project_id).await
+}
+
+pub(crate) async fn remote_read(pool: &RemotePoolState, target: &RemoteTarget, path: &str) -> Result<Vec<u8>, String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::read_file_on(&sftp, path).await,
+        None => crate::services::sftp::read_file(&s.user, &s.host, s.port, None, path).await,
+    }
+}
+
+async fn remote_write(pool: &RemotePoolState, target: &RemoteTarget, path: &str, bytes: &[u8]) -> Result<(), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::write_file_on(&sftp, path, bytes).await,
+        None => crate::services::sftp::write_file(&s.user, &s.host, s.port, None, path, bytes).await,
+    }
+}
+
+async fn remote_create_file(pool: &RemotePoolState, target: &RemoteTarget, path: &str) -> Result<(), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::create_file_on(&sftp, path).await,
+        None => crate::services::sftp::create_file(&s.user, &s.host, s.port, None, path).await,
+    }
+}
+
+async fn remote_mkdir(pool: &RemotePoolState, target: &RemoteTarget, path: &str) -> Result<(), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::mkdir_on(&sftp, path).await,
+        None => crate::services::sftp::mkdir(&s.user, &s.host, s.port, None, path).await,
+    }
+}
+
+async fn remote_remove_file(pool: &RemotePoolState, target: &RemoteTarget, path: &str) -> Result<(), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::remove_file_on(&sftp, path).await,
+        None => crate::services::sftp::remove_file(&s.user, &s.host, s.port, None, path).await,
+    }
+}
+
+async fn remote_remove_dir(pool: &RemotePoolState, target: &RemoteTarget, path: &str) -> Result<(), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::remove_dir_on(&sftp, path).await,
+        None => crate::services::sftp::remove_dir(&s.user, &s.host, s.port, None, path).await,
+    }
+}
+
+async fn remote_rename(pool: &RemotePoolState, target: &RemoteTarget, from: &str, to: &str) -> Result<(), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::rename_on(&sftp, from, to).await,
+        None => crate::services::sftp::rename(&s.user, &s.host, s.port, None, from, to).await,
+    }
+}
+
+async fn remote_metadata(pool: &RemotePoolState, target: &RemoteTarget, path: &str) -> Result<(u64, Option<u64>), String> {
+    let s = &target.spec;
+    match pooled(pool, target).await {
+        Some(sftp) => crate::services::sftp::metadata_on(&sftp, path).await,
+        None => crate::services::sftp::metadata(&s.user, &s.host, s.port, None, path).await,
+    }
+}
+
 #[tauri::command]
 pub fn list_project_endings(project_dir: String) -> Result<Vec<String>, String> {
     let root = canonical(&project_dir)?;
@@ -117,27 +634,56 @@ pub fn list_project_paths(project_dir: String) -> Result<Vec<ProjectPathEntry>,
     Ok(paths)
 }
 
+/// Validate that `new_name` is a bare file name (no separators, not `.`/`..`),
+/// returning the trimmed name. Shared by the local and remote rename paths.
+fn validate_bare_name(new_name: &str) -> Result<String, String> {
+    let trimmed = new_name.trim();
+    if trimmed.is_empty()
+        || trimmed == "."
+        || trimmed == ".."
+        || trimmed.contains('/')
+        || trimmed.contains('\\')
+        || trimmed.contains('\0')
+    {
+        return Err(format!("invalid file name '{trimmed}'"));
+    }
+    Ok(trimmed.to_string())
+}
+
 /// Rename a file or directory — path must stay inside the project root.
 /// `new_name` must be a bare file name; renames never move entries between
-/// directories.
+/// directories. Remote projects (mount-free, Phase 3) rename over SFTP; local
+/// projects keep the byte-identical local behavior.
 #[tauri::command]
-pub fn rename_path(project_dir: String, old_rel: String, new_name: String) -> Result<(), String> {
-    let new_name = new_name.trim();
-    if new_name.is_empty()
-        || new_name == "."
-        || new_name == ".."
-        || new_name.contains('/')
-        || new_name.contains('\\')
-        || new_name.contains('\0')
-    {
-        return Err(format!("invalid file name '{new_name}'"));
+pub async fn rename_path(
+    project_dir: String,
+    old_rel: String,
+    new_name: String,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    let name = validate_bare_name(&new_name)?;
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let from = remote_join_confined(&target.spec.remote_path, &old_rel)?;
+        // Rename in place: keep `from`'s directory, swap the final component.
+        let to = match from.rfind('/') {
+            Some(i) => format!("{}/{}", &from[..i], name),
+            None => name.clone(),
+        };
+        return remote_rename(pool.inner(), &target, &from, &to).await;
     }
+    rename_path_local(&project_dir, &old_rel, &new_name)
+}
 
-    let root = canonical(&project_dir)?;
-    let old = canonical(&root.join(&old_rel).to_string_lossy().to_string())?;
+/// Local-fs rename — the pre-Phase-3 body, byte-identical. Re-validates so it is
+/// directly callable in tests.
+pub fn rename_path_local(project_dir: &str, old_rel: &str, new_name: &str) -> Result<(), String> {
+    let new_name = validate_bare_name(new_name)?;
+
+    let root = canonical(project_dir)?;
+    let old = canonical(&root.join(old_rel).to_string_lossy().to_string())?;
     enforce_confinement(&root, &old)?;
 
-    let new = old.parent().ok_or("no parent")?.join(new_name);
+    let new = old.parent().ok_or("no parent")?.join(&new_name);
     // New path must also stay inside root.
     let new_c = canonical_or_new(&new);
     enforce_confinement(&root, &new_c)?;
@@ -147,9 +693,22 @@ pub fn rename_path(project_dir: String, old_rel: String, new_name: String) -> Re
 
 /// Delete a file — never a directory (safety: use trash or explicit confirm for dirs).
 #[tauri::command]
-pub fn delete_file(project_dir: String, rel_path: String) -> Result<(), String> {
-    let root = canonical(&project_dir)?;
-    let target = canonical(&root.join(&rel_path).to_string_lossy().to_string())?;
+pub async fn delete_file(
+    project_dir: String,
+    rel_path: String,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let full = remote_join_confined(&target.spec.remote_path, &rel_path)?;
+        return remote_remove_file(pool.inner(), &target, &full).await;
+    }
+    delete_file_local(&project_dir, &rel_path)
+}
+
+/// Local-fs file delete — byte-identical pre-Phase-3 body.
+pub fn delete_file_local(project_dir: &str, rel_path: &str) -> Result<(), String> {
+    let root = canonical(project_dir)?;
+    let target = canonical(&root.join(rel_path).to_string_lossy().to_string())?;
     enforce_confinement(&root, &target)?;
 
     if target.is_dir() {
@@ -160,9 +719,26 @@ pub fn delete_file(project_dir: String, rel_path: String) -> Result<(), String>
 
 /// Delete a directory tree inside the project root.
 #[tauri::command]
-pub fn delete_dir(project_dir: String, rel_path: String) -> Result<(), String> {
-    let root = canonical(&project_dir)?;
-    let target = canonical(&root.join(&rel_path).to_string_lossy().to_string())?;
+pub async fn delete_dir(
+    project_dir: String,
+    rel_path: String,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let clean = normalize_project_rel_path(&rel_path)?;
+        if clean.is_empty() {
+            return Err("refusing to delete project root".to_string());
+        }
+        let full = join_remote_dir(&target.spec.remote_path, &clean);
+        return remote_remove_dir(pool.inner(), &target, &full).await;
+    }
+    delete_dir_local(&project_dir, &rel_path)
+}
+
+/// Local-fs directory-tree delete — byte-identical pre-Phase-3 body.
+pub fn delete_dir_local(project_dir: &str, rel_path: &str) -> Result<(), String> {
+    let root = canonical(project_dir)?;
+    let target = canonical(&root.join(rel_path).to_string_lossy().to_string())?;
     enforce_confinement(&root, &target)?;
 
     if target == root {
@@ -176,9 +752,22 @@ pub fn delete_dir(project_dir: String, rel_path: String) -> Result<(), String> {
 
 /// Create a new empty file inside the project.
 #[tauri::command]
-pub fn create_file(project_dir: String, rel_path: String) -> Result<(), String> {
-    let root = canonical(&project_dir)?;
-    let target = root.join(&rel_path);
+pub async fn create_file(
+    project_dir: String,
+    rel_path: String,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let full = remote_join_confined(&target.spec.remote_path, &rel_path)?;
+        return remote_create_file(pool.inner(), &target, &full).await;
+    }
+    create_file_local(&project_dir, &rel_path)
+}
+
+/// Local-fs empty-file create — byte-identical pre-Phase-3 body.
+pub fn create_file_local(project_dir: &str, rel_path: &str) -> Result<(), String> {
+    let root = canonical(project_dir)?;
+    let target = root.join(rel_path);
     let target_c = canonical_or_new(&target);
     enforce_confinement(&root, &target_c)?;
 
@@ -192,13 +781,23 @@ pub fn create_file(project_dir: String, rel_path: String) -> Result<(), String>
 
 /// Write a text file inside the project.
 #[tauri::command]
-pub fn write_project_file(
+pub async fn write_project_file(
     project_dir: String,
     rel_path: String,
     content: String,
+    pool: tauri::State<'_, RemotePoolState>,
 ) -> Result<(), String> {
-    let root = canonical(&project_dir)?;
-    let target = root.join(&rel_path);
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let full = remote_join_confined(&target.spec.remote_path, &rel_path)?;
+        return remote_write(pool.inner(), &target, &full, content.as_bytes()).await;
+    }
+    write_project_file_local(&project_dir, &rel_path, &content)
+}
+
+/// Local-fs text write — byte-identical pre-Phase-3 body.
+pub fn write_project_file_local(project_dir: &str, rel_path: &str, content: &str) -> Result<(), String> {
+    let root = canonical(project_dir)?;
+    let target = root.join(rel_path);
     let target_c = canonical_or_new(&target);
     enforce_confinement(&root, &target_c)?;
 
@@ -210,20 +809,30 @@ pub fn write_project_file(
 
 /// Write raw bytes to a file inside the project (used for drag-and-drop uploads).
 #[tauri::command]
-pub fn write_project_file_bytes(
+pub async fn write_project_file_bytes(
     project_dir: String,
     rel_path: String,
     content: Vec<u8>,
+    pool: tauri::State<'_, RemotePoolState>,
 ) -> Result<(), String> {
-    let root = canonical(&project_dir)?;
-    let target = root.join(&rel_path);
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let full = remote_join_confined(&target.spec.remote_path, &rel_path)?;
+        return remote_write(pool.inner(), &target, &full, &content).await;
+    }
+    write_project_file_bytes_local(&project_dir, &rel_path, &content)
+}
+
+/// Local-fs byte write — byte-identical pre-Phase-3 body.
+pub fn write_project_file_bytes_local(project_dir: &str, rel_path: &str, content: &[u8]) -> Result<(), String> {
+    let root = canonical(project_dir)?;
+    let target = root.join(rel_path);
     let target_c = canonical_or_new(&target);
     enforce_confinement(&root, &target_c)?;
 
     if let Some(parent) = target.parent() {
         fs::create_dir_all(parent).map_err(|e| e.to_string())?;
     }
-    fs::write(&target, &content).map_err(|e| e.to_string())
+    fs::write(&target, content).map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -270,9 +879,22 @@ pub fn update_gitignore_rule(
 
 /// Create a new directory inside the project.
 #[tauri::command]
-pub fn create_dir(project_dir: String, rel_path: String) -> Result<(), String> {
-    let root = canonical(&project_dir)?;
-    let target = root.join(&rel_path);
+pub async fn create_dir(
+    project_dir: String,
+    rel_path: String,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    if let Some(target) = crate::services::remote::remote_target_for_dir(&project_dir) {
+        let full = remote_join_confined(&target.spec.remote_path, &rel_path)?;
+        return remote_mkdir(pool.inner(), &target, &full).await;
+    }
+    create_dir_local(&project_dir, &rel_path)
+}
+
+/// Local-fs directory create — byte-identical pre-Phase-3 body.
+pub fn create_dir_local(project_dir: &str, rel_path: &str) -> Result<(), String> {
+    let root = canonical(project_dir)?;
+    let target = root.join(rel_path);
     let target_c = canonical_or_new(&target);
     enforce_confinement(&root, &target_c)?;
     fs::create_dir_all(&target).map_err(|e| e.to_string())
@@ -323,6 +945,171 @@ pub fn move_path(
     remove.map_err(|e| e.to_string())
 }
 
+/// Import an external file or directory (dropped onto the right panel from the
+/// OS file manager) into the project. Unlike [`copy_path`], the SOURCE is an
+/// arbitrary absolute path outside the project, so it is not confined; only the
+/// DESTINATION is confined to the project root. `dest_rel` is the project-
+/// relative folder to drop into (empty = project root). On a name collision,
+/// `replace=false` appends " (n)" before the extension (keep both); `replace=
+/// true` overwrites the existing entry. Returns the final project-relative path
+/// of the imported copy. Callers prompt the user (see `project_path_exists`)
+/// before passing `replace=true`.
+#[tauri::command]
+pub fn import_external_file(
+    project_dir: String,
+    source_path: String,
+    dest_rel: String,
+    replace: bool,
+) -> Result<String, String> {
+    let src = canonical(&source_path)?;
+    let root = canonical(&project_dir)?;
+
+    let rel_dir = normalize_project_rel_path(&dest_rel)?;
+    let dest_dir = if rel_dir.is_empty() {
+        root.clone()
+    } else {
+        root.join(&rel_dir)
+    };
+    let dest_dir_c = canonical_or_new(&dest_dir);
+    enforce_confinement(&root, &dest_dir_c)?;
+    // Block copying a directory into its own subtree (would recurse forever).
+    if dest_dir_c.starts_with(&src) {
+        return Err("cannot copy a folder into itself".to_string());
+    }
+
+    let file_name = src
+        .file_name()
+        .map(|n| n.to_string_lossy().to_string())
+        .ok_or_else(|| "source has no file name".to_string())?;
+    let dest = if replace {
+        dest_dir_c.join(&file_name)
+    } else {
+        unique_dest(&dest_dir_c, &file_name)
+    };
+    enforce_confinement(&root, &canonical_or_new(&dest))?;
+
+    fs::create_dir_all(&dest_dir_c).map_err(|e| e.to_string())?;
+    if replace && dest.exists() {
+        // Clear the existing entry first so a file→dir (or dir→file) replace is
+        // clean rather than merging into a stale tree.
+        if dest.is_dir() {
+            fs::remove_dir_all(&dest).map_err(|e| e.to_string())?;
+        } else {
+            fs::remove_file(&dest).map_err(|e| e.to_string())?;
+        }
+    }
+    copy_recursive(&src, &dest).map_err(|e| e.to_string())?;
+
+    Ok(dest
+        .strip_prefix(&root)
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+        .unwrap_or(file_name))
+}
+
+/// Whether a project-relative path currently exists. The drag-drop importer
+/// calls this before copying so it can prompt rename-vs-replace on a collision.
+#[tauri::command]
+pub fn project_path_exists(project_dir: String, rel_path: String) -> Result<bool, String> {
+    let root = canonical(&project_dir)?;
+    let rel = normalize_project_rel_path(&rel_path)?;
+    let target = if rel.is_empty() { root.clone() } else { root.join(&rel) };
+    let target_c = canonical_or_new(&target);
+    enforce_confinement(&root, &target_c)?;
+    Ok(target_c.exists())
+}
+
+/// Extract a `.zip` archive in place. Contents land in a new sibling folder
+/// named after the archive (without its extension, deduped with " (n)"), inside
+/// the same directory as the archive — so a double-click in the file tree never
+/// dumps loose files over the current folder. Returns the project-relative path
+/// of the created folder.
+///
+/// Security: guards against Zip-Slip. Every entry's path goes through
+/// `enclosed_name` (which rejects `..`/absolute components), and the resolved
+/// output is additionally confined to the destination folder before any write.
+#[tauri::command]
+pub fn extract_archive(project_dir: String, rel_path: String) -> Result<String, String> {
+    let root = canonical(&project_dir)?;
+    let archive = canonical(&root.join(&rel_path).to_string_lossy().to_string())?;
+    enforce_confinement(&root, &archive)?;
+    if !archive.is_file() {
+        return Err("not a file".to_string());
+    }
+
+    let parent = archive
+        .parent()
+        .ok_or("archive has no parent directory")?
+        .to_path_buf();
+    let stem = archive
+        .file_stem()
+        .map(|s| s.to_string_lossy().to_string())
+        .filter(|s| !s.is_empty())
+        .ok_or_else(|| "archive has no name".to_string())?;
+    // Reuse the " (n)" collision suffixing — `stem` has no extension, so the
+    // suffix simply lands at the end of the folder name.
+    let dest_dir = unique_dest(&parent, &stem);
+    enforce_confinement(&root, &canonical_or_new(&dest_dir))?;
+
+    let file = fs::File::open(&archive).map_err(|e| e.to_string())?;
+    let mut zip = zip::ZipArchive::new(file).map_err(|e| format!("read zip: {e}"))?;
+    fs::create_dir_all(&dest_dir).map_err(|e| e.to_string())?;
+
+    for i in 0..zip.len() {
+        let mut entry = zip.by_index(i).map_err(|e| e.to_string())?;
+        // `enclosed_name` returns None for any path that would escape the
+        // destination (`..`, absolute, drive prefix) — skip those rather than
+        // trusting the archive.
+        let rel = match entry.enclosed_name() {
+            Some(p) => p,
+            None => continue,
+        };
+        let out = dest_dir.join(&rel);
+        // Defense in depth: confine the resolved output to the dest folder.
+        enforce_confinement(&dest_dir, &canonical_or_new(&out))?;
+        if entry.is_dir() {
+            fs::create_dir_all(&out).map_err(|e| e.to_string())?;
+        } else {
+            if let Some(p) = out.parent() {
+                fs::create_dir_all(p).map_err(|e| e.to_string())?;
+            }
+            let mut outfile = fs::File::create(&out).map_err(|e| e.to_string())?;
+            std::io::copy(&mut entry, &mut outfile).map_err(|e| e.to_string())?;
+        }
+    }
+
+    Ok(dest_dir
+        .strip_prefix(&root)
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+        .unwrap_or(stem))
+}
+
+/// Pick a non-colliding destination path in `dir` for `file_name`, appending
+/// " (1)", " (2)", … before the extension until a free name is found.
+fn unique_dest(dir: &Path, file_name: &str) -> PathBuf {
+    let direct = dir.join(file_name);
+    if !direct.exists() {
+        return direct;
+    }
+    // A leading-dot name with no other dot (".gitignore") has no extension, so
+    // `stem` keeps the whole name and the suffix lands at the end.
+    let ext = Path::new(file_name).extension().and_then(|e| e.to_str());
+    let stem = match ext {
+        Some(e) => &file_name[..file_name.len() - e.len() - 1],
+        None => file_name,
+    };
+    for n in 1..10_000 {
+        let candidate = match ext {
+            Some(e) => format!("{stem} ({n}).{e}"),
+            None => format!("{stem} ({n})"),
+        };
+        let p = dir.join(candidate);
+        if !p.exists() {
+            return p;
+        }
+    }
+    direct
+}
+
 /// Validate and resolve a copy/move: confine both ends, refuse an existing
 /// destination, a no-op, and copying a directory into its own subtree.
 fn resolve_transfer(
@@ -374,10 +1161,42 @@ fn copy_recursive(src: &Path, dest: &Path) -> std::io::Result<()> {
 
 // ── MIME detection (magic bytes) ──────────────────────────────────────────
 
+/// Detect a file's MIME type. Local projects sniff magic bytes (then fall back to
+/// the extension); remote projects (mount-free, Phase 3) use the **extension**
+/// only — avoiding a network fetch just to classify — after confining the path to
+/// the remote project root.
 #[tauri::command]
-pub fn detect_mime(path: String) -> Result<String, String> {
-    let p = PathBuf::from(&path);
-    confine_abs_read(&p)?;
+pub async fn detect_mime(
+    path: String,
+    project_id: Option<String>,
+    _pool: tauri::State<'_, RemotePoolState>,
+) -> Result<String, String> {
+    if let Some(pid) = project_id.as_deref() {
+        if let Some(target) = crate::services::remote::remote_target_for(pid) {
+            // SSH-sync G2: a mirror-local path is classified on the LOCAL fs
+            // (magic bytes); a host path uses the extension only (no fetch).
+            if !crate::services::remote_sync::is_under_mirror(pid, &path) {
+                confine_remote_abs(&target.spec.remote_path, &path)?;
+                return Ok(ext_mime_or_octet(&path));
+            }
+        }
+    }
+    detect_mime_local(&path, project_id.as_deref())
+}
+
+/// Extension-based MIME for `path`, defaulting to `application/octet-stream`.
+fn ext_mime_or_octet(path: &str) -> String {
+    Path::new(path)
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(mime_for_ext)
+        .unwrap_or_else(|| "application/octet-stream".to_string())
+}
+
+/// Local-fs MIME detection — byte-identical pre-Phase-3 body.
+pub fn detect_mime_local(path: &str, scope_id: Option<&str>) -> Result<String, String> {
+    let p = PathBuf::from(path);
+    confine_abs_read(&p, scope_id)?;
     // 1. Try magic bytes via infer.
     if let Ok(mut f) = fs::File::open(&p) {
         let mut buf = [0u8; 8192];
@@ -389,10 +1208,34 @@ pub fn detect_mime(path: String) -> Result<String, String> {
         }
     }
     // 2. Fall back to extension.
-    Ok(p.extension()
-        .and_then(|e| e.to_str())
-        .map(mime_for_ext)
-        .unwrap_or_else(|| "application/octet-stream".to_string()))
+    Ok(ext_mime_or_octet(path))
+}
+
+// ── Viewer source classification (remote-native vs local mirror) ──────────
+
+/// Classify where an in-app viewer's bytes come from, for the viewer's source
+/// notice. Returns exactly one of:
+///   - `"remote"` — a remote (SSH) project path served straight from the host
+///                  over SFTP (remote-native, no local copy).
+///   - `"local"`  — a remote project path under the local **mirror**, read on the
+///                  LOCAL fs (the paired working copy synced from the host).
+///   - `"none"`   — a local project (or root scope): there is no remote/local
+///                  distinction, so the frontend shows no badge.
+/// This mirrors the *exact* routing `read_file_text`/`read_file_bytes` apply
+/// (`remote_target_for` gates remoteness, `is_under_mirror` picks the side), so
+/// the badge can never disagree with where the bytes were actually read from.
+#[tauri::command]
+pub fn file_source(path: String, project_id: Option<String>) -> String {
+    match project_id.as_deref() {
+        Some(pid) if crate::services::remote::remote_target_for(pid).is_some() => {
+            if crate::services::remote_sync::is_under_mirror(pid, &path) {
+                "local".to_string()
+            } else {
+                "remote".to_string()
+            }
+        }
+        _ => "none".to_string(),
+    }
 }
 
 // ── Read file contents for in-app viewers (Group K #40) ───────────────────
@@ -412,9 +1255,37 @@ const MAX_BINARY_VIEW_BYTES: u64 = 64 * 1024 * 1024;
 /// `~/.ssh/id_rsa`. Refuses files over `MAX_TEXT_VIEW_BYTES` and non-UTF-8
 /// (binary) files.
 #[tauri::command]
-pub fn read_file_text(path: String) -> Result<String, String> {
-    let p = PathBuf::from(&path);
-    confine_abs_read(&p)?;
+pub async fn read_file_text(
+    path: String,
+    project_id: Option<String>,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<String, String> {
+    if let Some(pid) = project_id.as_deref() {
+        if let Some(target) = crate::services::remote::remote_target_for(pid) {
+            // SSH-sync G2: a path under the local mirror is read on the LOCAL fs
+            // even for a remote project, so the local source view / local-on-remote
+            // tabs see mirrored bytes instead of round-tripping SFTP.
+            if !crate::services::remote_sync::is_under_mirror(pid, &path) {
+                confine_remote_abs(&target.spec.remote_path, &path)?;
+                let (size, _) = remote_metadata(pool.inner(), &target, &path).await?;
+                if size > MAX_TEXT_VIEW_BYTES {
+                    return Err(format!(
+                        "file too large to view ({size} bytes; limit {MAX_TEXT_VIEW_BYTES})"
+                    ));
+                }
+                let bytes = remote_read(pool.inner(), &target, &path).await?;
+                return String::from_utf8(bytes)
+                    .map_err(|_| "file is not valid UTF-8 text".to_string());
+            }
+        }
+    }
+    read_file_text_local(&path, project_id.as_deref())
+}
+
+/// Local-fs text read — byte-identical pre-Phase-3 body.
+pub fn read_file_text_local(path: &str, scope_id: Option<&str>) -> Result<String, String> {
+    let p = PathBuf::from(path);
+    confine_abs_read(&p, scope_id)?;
     let meta = fs::metadata(&p).map_err(|e| e.to_string())?;
     if !meta.is_file() {
         return Err("not a file".to_string());
@@ -438,9 +1309,36 @@ pub fn read_file_text(path: String) -> Result<String, String> {
 /// `MAX_TEXT_VIEW_BYTES`, and only writes to an existing regular file (the
 /// editor edits files opened from the tree; it never creates new paths).
 #[tauri::command]
-pub fn write_file_text(path: String, content: String) -> Result<(), String> {
-    let p = PathBuf::from(&path);
-    confine_abs_write(&p)?;
+pub async fn write_file_text(
+    path: String,
+    content: String,
+    project_id: Option<String>,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    if let Some(pid) = project_id.as_deref() {
+        if let Some(target) = crate::services::remote::remote_target_for(pid) {
+            // SSH-sync G2: a mirror-local path saves to the LOCAL mirror (Phase 2
+            // optionally pushes it on to the host through sync_push).
+            if !crate::services::remote_sync::is_under_mirror(pid, &path) {
+                confine_remote_abs(&target.spec.remote_path, &path)?;
+                if content.len() as u64 > MAX_TEXT_VIEW_BYTES {
+                    return Err(format!(
+                        "content too large to save ({} bytes; limit {})",
+                        content.len(),
+                        MAX_TEXT_VIEW_BYTES
+                    ));
+                }
+                return remote_write(pool.inner(), &target, &path, content.as_bytes()).await;
+            }
+        }
+    }
+    write_file_text_local(&path, &content, project_id.as_deref())
+}
+
+/// Local-fs text write (existing regular file only) — byte-identical pre-Phase-3 body.
+pub fn write_file_text_local(path: &str, content: &str, scope_id: Option<&str>) -> Result<(), String> {
+    let p = PathBuf::from(path);
+    confine_abs_write(&p, scope_id)?;
     let meta = fs::metadata(&p).map_err(|e| e.to_string())?;
     if !meta.is_file() {
         return Err("not a file".to_string());
@@ -455,15 +1353,83 @@ pub fn write_file_text(path: String, content: String) -> Result<(), String> {
     fs::write(&p, content).map_err(|e| e.to_string())
 }
 
+/// Write raw bytes to an absolute path, confined to Eldrun's known roots
+/// (Security #1). Unlike `write_file_text` this may create a new file (so the
+/// image annotator can "Save as…" a sibling PNG), but still refuses paths
+/// outside the allowed roots and oversized payloads.
+#[tauri::command]
+pub async fn write_file_bytes(
+    path: String,
+    content: Vec<u8>,
+    project_id: Option<String>,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<(), String> {
+    if let Some(pid) = project_id.as_deref() {
+        if let Some(target) = crate::services::remote::remote_target_for(pid) {
+            // SSH-sync G2: a mirror-local path writes to the LOCAL mirror.
+            if !crate::services::remote_sync::is_under_mirror(pid, &path) {
+                confine_remote_abs(&target.spec.remote_path, &path)?;
+                if content.len() as u64 > MAX_BINARY_VIEW_BYTES {
+                    return Err(format!(
+                        "content too large to save ({} bytes; limit {})",
+                        content.len(),
+                        MAX_BINARY_VIEW_BYTES
+                    ));
+                }
+                return remote_write(pool.inner(), &target, &path, &content).await;
+            }
+        }
+    }
+    write_file_bytes_local(&path, &content, project_id.as_deref())
+}
+
+/// Local-fs byte write (may create a new file) — byte-identical pre-Phase-3 body.
+pub fn write_file_bytes_local(path: &str, content: &[u8], scope_id: Option<&str>) -> Result<(), String> {
+    let p = PathBuf::from(path);
+    confine_abs_write(&p, scope_id)?;
+    if content.len() as u64 > MAX_BINARY_VIEW_BYTES {
+        return Err(format!(
+            "content too large to save ({} bytes; limit {})",
+            content.len(),
+            MAX_BINARY_VIEW_BYTES
+        ));
+    }
+    fs::write(&p, content).map_err(|e| e.to_string())
+}
+
 /// Read an absolute file path as raw bytes for the in-app PDF viewer.
 ///
 /// Confined to Eldrun's known roots (Security #1). Refuses files over
 /// `MAX_BINARY_VIEW_BYTES`. The frontend wraps the returned bytes in a Blob URL
 /// so the PDF renders in-tab without an external viewer.
 #[tauri::command]
-pub fn read_file_bytes(path: String) -> Result<Vec<u8>, String> {
-    let p = PathBuf::from(&path);
-    confine_abs_read(&p)?;
+pub async fn read_file_bytes(
+    path: String,
+    project_id: Option<String>,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<Vec<u8>, String> {
+    if let Some(pid) = project_id.as_deref() {
+        if let Some(target) = crate::services::remote::remote_target_for(pid) {
+            // SSH-sync G2: a mirror-local path reads from the LOCAL mirror.
+            if !crate::services::remote_sync::is_under_mirror(pid, &path) {
+                confine_remote_abs(&target.spec.remote_path, &path)?;
+                let (size, _) = remote_metadata(pool.inner(), &target, &path).await?;
+                if size > MAX_BINARY_VIEW_BYTES {
+                    return Err(format!(
+                        "file too large to view ({size} bytes; limit {MAX_BINARY_VIEW_BYTES})"
+                    ));
+                }
+                return remote_read(pool.inner(), &target, &path).await;
+            }
+        }
+    }
+    read_file_bytes_local(&path, project_id.as_deref())
+}
+
+/// Local-fs byte read — byte-identical pre-Phase-3 body.
+pub fn read_file_bytes_local(path: &str, scope_id: Option<&str>) -> Result<Vec<u8>, String> {
+    let p = PathBuf::from(path);
+    confine_abs_read(&p, scope_id)?;
     let meta = fs::metadata(&p).map_err(|e| e.to_string())?;
     if !meta.is_file() {
         return Err("not a file".to_string());
@@ -484,9 +1450,28 @@ pub fn read_file_bytes(path: String) -> Result<Vec<u8>, String> {
 /// (#43 diff-aware auto-reload). Confined to Eldrun's known roots (Security #1).
 /// Mirrors the `FileEntry.modified_secs` machinery in `list_dir`.
 #[tauri::command]
-pub fn file_mtime(path: String) -> Result<u64, String> {
-    let p = PathBuf::from(&path);
-    confine_abs_read(&p)?;
+pub async fn file_mtime(
+    path: String,
+    project_id: Option<String>,
+    pool: tauri::State<'_, RemotePoolState>,
+) -> Result<u64, String> {
+    if let Some(pid) = project_id.as_deref() {
+        if let Some(target) = crate::services::remote::remote_target_for(pid) {
+            // SSH-sync G2: a mirror-local path is stat'd on the LOCAL fs.
+            if !crate::services::remote_sync::is_under_mirror(pid, &path) {
+                confine_remote_abs(&target.spec.remote_path, &path)?;
+                let (_, modified) = remote_metadata(pool.inner(), &target, &path).await?;
+                return Ok(modified.unwrap_or(0));
+            }
+        }
+    }
+    file_mtime_local(&path, project_id.as_deref())
+}
+
+/// Local-fs mtime — byte-identical pre-Phase-3 body.
+pub fn file_mtime_local(path: &str, scope_id: Option<&str>) -> Result<u64, String> {
+    let p = PathBuf::from(path);
+    confine_abs_read(&p, scope_id)?;
     let meta = fs::metadata(&p).map_err(|e| e.to_string())?;
     let secs = meta
         .modified()
@@ -499,48 +1484,72 @@ pub fn file_mtime(path: String) -> Result<u64, String> {
 
 // ── Absolute-path confinement (Security #1) ────────────────────────────────
 
-/// The set of directories the absolute-path file commands may touch: the
-/// **current** project's own directory, plus the directories of any projects
-/// that share a box with it. Switching to project X makes X's tree reachable and
-/// a sibling project Y's tree *un*reachable — unless X and Y are members of the
-/// same box, in which case box members are deliberately co-accessible (the whole
-/// point of grouping them). This is stricter and more intuitive than the earlier
-/// root-based confinement: imported "keep"-mode projects living anywhere on disk
-/// are reachable while they (or a box sibling) are current, and nothing else is.
+/// The set of directories the absolute-path file commands may touch for a given
+/// **scope**: the scope project's own directory, plus the directories of any
+/// projects that share a box with it. Projects are filesystem-isolated from one
+/// another — a file command made on behalf of project X can reach X's tree (and
+/// any box sibling's tree, since box members are deliberately co-accessible), and
+/// nothing else.
 ///
-/// Returns an empty set when no project is current (e.g. at startup), which makes
-/// every absolute-path command fail closed. See REVIEW.md Security #1.
-fn allowed_roots() -> Vec<PathBuf> {
+/// Crucially the scope is the project that *owns the calling viewer* (passed by
+/// the frontend), NOT whichever project is globally "current". In-app viewers
+/// stay mounted across project switches, are restored on relaunch, and can live
+/// in detached windows; binding confinement to the current project made those
+/// fail with a spurious "path is not in the current project" error the moment you
+/// switched away (e.g. a `file_mtime` poll or `read_file_text` reload). Binding
+/// it to the viewer's own project keeps strict per-project isolation while
+/// letting a viewer keep working regardless of which project is current.
+///
+/// `scope_id` of `None` (root scope, or a caller that supplied no project) falls
+/// back to the current project + its box siblings. Returns an empty set when the
+/// scope resolves to no project (e.g. first run), which makes every absolute-path
+/// command fail closed. See REVIEW.md Security #1.
+fn allowed_roots(scope_id: Option<&str>) -> Vec<PathBuf> {
     let projects: ProjectsList = read_state_json("projects.json");
     let boxes: BoxesList = read_state_json("boxes.json");
-    compute_allowed_roots(&projects, &boxes)
+    compute_allowed_roots(&projects, &boxes, scope_id)
 }
 
 /// Pure core of [`allowed_roots`], split out so the project/box scoping logic is
 /// testable without touching the real state dir.
-fn compute_allowed_roots(projects: &ProjectsList, boxes: &BoxesList) -> Vec<PathBuf> {
-    let Some(current) = projects.iter().find(|e| e.status == "current") else {
+fn compute_allowed_roots(
+    projects: &ProjectsList,
+    boxes: &BoxesList,
+    scope_id: Option<&str>,
+) -> Vec<PathBuf> {
+    // Anchor on the scope project when one is named, else the current project.
+    let anchor = match scope_id {
+        Some(id) => projects.iter().find(|e| e.id == id),
+        None => projects.iter().find(|e| e.status == "current"),
+    };
+    let Some(anchor) = anchor else {
         return Vec::new();
     };
 
-    // Start with the current project, then fold in every member of any box the
-    // current project belongs to (`member_ids` is the authoritative membership —
+    // Start with the anchor project, then fold in every member of any box the
+    // anchor belongs to (`member_ids` is the authoritative membership —
     // see schema::boxes::ProjectBox).
     let mut ids: HashSet<&str> = HashSet::new();
-    ids.insert(current.id.as_str());
+    ids.insert(anchor.id.as_str());
     for b in boxes {
-        if b.member_ids.iter().any(|m| m == &current.id) {
+        if b.member_ids.iter().any(|m| m == &anchor.id) {
             for m in &b.member_ids {
                 ids.insert(m.as_str());
             }
         }
     }
 
-    let mut roots: Vec<PathBuf> = projects
-        .iter()
-        .filter(|e| ids.contains(e.id.as_str()))
-        .filter_map(project_dir)
-        .collect();
+    let in_scope = || projects.iter().filter(|e| ids.contains(e.id.as_str()));
+    let mut roots: Vec<PathBuf> = in_scope().filter_map(project_dir).collect();
+    // For a remote (SSH) project the tree the user actually browses is the local
+    // *mirror*, not the state dir that `project_dir` returns. The default mirror
+    // lives under the state dir (already covered above), but an explicit
+    // `extra["mirror"]` relocation — including the top-level default minted at
+    // import — sits outside it, so add each in-scope project's mirror override as
+    // its own root. Otherwise opening a mirrored local file fails confinement
+    // with a spurious "not in the current project" error. Pure: read straight
+    // from the entry, no state-dir touch.
+    roots.extend(in_scope().filter_map(mirror_override_dir));
     // Canonicalize where possible so symlinked roots compare correctly; fall
     // back to the literal path when the dir does not exist (yet).
     roots
@@ -562,6 +1571,15 @@ fn project_dir(entry: &ProjectEntry) -> Option<PathBuf> {
         .map(|p| p.to_path_buf())
 }
 
+/// A remote project's explicit local-mirror override (`extra["mirror"]`), or
+/// `None` when unset/empty or for a local project. Mirrors the resolution in
+/// `services::remote_sync::mirror_override` but stays pure (reads the passed
+/// entry, not the state dir) so `compute_allowed_roots` remains testable.
+fn mirror_override_dir(entry: &ProjectEntry) -> Option<PathBuf> {
+    let raw = entry.extra.get("mirror").and_then(Value::as_str)?.trim();
+    (!raw.is_empty()).then(|| PathBuf::from(raw))
+}
+
 /// Read a JSON state file under `state_dir()`, defaulting to `T::default()` when
 /// the file is absent or unparseable (so confinement degrades to fail-closed).
 fn read_state_json<T>(name: &str) -> T
@@ -590,8 +1608,8 @@ fn resolve_for_confinement(p: &Path) -> PathBuf {
     }
 }
 
-fn confine_abs(p: &Path) -> Result<(), String> {
-    confine_abs_within(p, &allowed_roots())
+fn confine_abs(p: &Path, scope_id: Option<&str>) -> Result<(), String> {
+    confine_abs_within(p, &allowed_roots(scope_id))
 }
 
 /// Pure confinement check against an explicit root set. Empty `roots` (no current
@@ -608,14 +1626,14 @@ fn confine_abs_within(p: &Path, roots: &[PathBuf]) -> Result<(), String> {
     }
 }
 
-/// Confine a read of an absolute path to the known roots.
-fn confine_abs_read(p: &Path) -> Result<(), String> {
-    confine_abs(p)
+/// Confine a read of an absolute path to the scope's known roots.
+fn confine_abs_read(p: &Path, scope_id: Option<&str>) -> Result<(), String> {
+    confine_abs(p, scope_id)
 }
 
-/// Confine a write of an absolute path to the known roots.
-fn confine_abs_write(p: &Path) -> Result<(), String> {
-    confine_abs(p)
+/// Confine a write of an absolute path to the scope's known roots.
+fn confine_abs_write(p: &Path, scope_id: Option<&str>) -> Result<(), String> {
+    confine_abs(p, scope_id)
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────────
@@ -624,6 +1642,29 @@ fn canonical(path: &str) -> Result<PathBuf, String> {
     fs::canonicalize(path).map_err(|e| format!("canonicalize {path}: {e}"))
 }
 
+/// Render a (typically canonicalized) path as the string handed to the frontend.
+///
+/// `fs::canonicalize` returns *verbatim* paths on Windows — `\\?\C:\proj\file`
+/// for a drive path, `\\?\UNC\server\share\...` for a network path. The frontend
+/// (`src/lib/paths.ts`) expects NATIVE paths (`C:\proj\file`, `\\server\share`)
+/// and prefix-matches `entry.path` against the project directory (stored without
+/// the verbatim prefix); the `\\?\` prefix would break that match and `file://`
+/// URI building. This strips it. No-op on Unix and for paths lacking the prefix.
+pub(crate) fn display_path(p: &Path) -> String {
+    let s = p.to_string_lossy();
+    #[cfg(target_os = "windows")]
+    {
+        if let Some(rest) = s.strip_prefix(r"\\?\UNC\") {
+            // `\\?\UNC\server\share` → `\\server\share`
+            return format!(r"\\{rest}");
+        }
+        if let Some(rest) = s.strip_prefix(r"\\?\") {
+            return rest.to_string();
+        }
+    }
+    s.into_owned()
+}
+
 fn collect_project_endings(
     root: &Path,
     dir: &Path,
@@ -764,6 +1805,60 @@ pub(crate) fn enforce_confinement(root: &Path, target: &Path) -> Result<(), Stri
     Ok(())
 }
 
+/// One subdirectory in a [`DirListing`]: its display name and absolute path.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DirEntry {
+    pub name: String,
+    pub path: String,
+}
+
+/// The directory listing backing the in-app folder-browser popup: the current
+/// absolute directory, its parent (for up-navigation; `None` at a filesystem
+/// root), and the immediate subdirectories.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DirListing {
+    pub path: String,
+    pub parent: Option<String>,
+    pub entries: Vec<DirEntry>,
+}
+
+/// List the immediate subdirectories of a LOCAL directory for the in-app folder
+/// picker. Unlike [`list_dir`], this is deliberately NOT project-confined — the
+/// picker browses the whole local filesystem to choose a destination folder.
+/// Empty `path` starts at the user's home directory. Files are omitted (only
+/// folders); unreadable entries are skipped rather than failing the whole call.
+#[tauri::command]
+pub fn list_dirs(path: String) -> Result<DirListing, String> {
+    let trimmed = path.trim();
+    let base = if trimmed.is_empty() {
+        crate::paths::home_dir()
+    } else {
+        PathBuf::from(trimmed)
+    };
+    // Best-effort canonicalize so `..`/symlinks resolve to a stable absolute
+    // path; fall back to the raw path if it can't be canonicalized.
+    let base = fs::canonicalize(&base).unwrap_or(base);
+
+    let read = fs::read_dir(&base).map_err(|e| format!("cannot read '{}': {e}", base.display()))?;
+    let mut entries: Vec<DirEntry> = read
+        .flatten()
+        .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
+        .map(|e| DirEntry {
+            name: e.file_name().to_string_lossy().into_owned(),
+            path: display_path(&e.path()),
+        })
+        .collect();
+    entries.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+
+    Ok(DirListing {
+        path: display_path(&base),
+        parent: base.parent().map(display_path),
+        entries,
+    })
+}
+
 // ── Tests ─────────────────────────────────────────────────────────────────
 
 #[cfg(test)]
@@ -771,6 +1866,63 @@ mod tests {
     use super::*;
     use std::path::PathBuf;
 
+    // ── join_remote_dir / remote_file_entry ────────────────────────────────
+
+    #[test]
+    fn join_remote_dir_root_is_remote_path() {
+        assert_eq!(join_remote_dir("/srv/project", ""), "/srv/project");
+        // Trailing slash on the root is trimmed.
+        assert_eq!(join_remote_dir("/srv/project/", ""), "/srv/project");
+    }
+
+    #[test]
+    fn join_remote_dir_appends_relative() {
+        assert_eq!(join_remote_dir("/srv/project", "sub/dir"), "/srv/project/sub/dir");
+        // A leading slash on the rel is normalized away (no doubled slash).
+        assert_eq!(join_remote_dir("/srv/project", "/sub"), "/srv/project/sub");
+        assert_eq!(join_remote_dir("/srv/project/", "sub"), "/srv/project/sub");
+    }
+
+    #[test]
+    fn join_remote_dir_handles_filesystem_root() {
+        // remote_path "/" trims to empty; results stay single-leading-slash.
+        assert_eq!(join_remote_dir("/", ""), "/");
+        assert_eq!(join_remote_dir("/", "etc"), "/etc");
+    }
+
+    #[test]
+    fn remote_file_entry_maps_path_and_mime() {
+        let entry = crate::services::sftp::Entry {
+            name: "notes.txt".to_string(),
+            is_dir: false,
+            size: 42,
+            modified_secs: Some(1000),
+        };
+        let fe = remote_file_entry("/srv/project/src", entry);
+        assert_eq!(fe.path, "/srv/project/src/notes.txt");
+        assert_eq!(fe.extension.as_deref(), Some(".txt"));
+        assert_eq!(fe.mime.as_deref(), Some("text/plain"));
+        assert_eq!(fe.size, 42);
+        assert_eq!(fe.modified_secs, Some(1000));
+        assert_eq!(fe.created_secs, None);
+        assert!(!fe.is_dir);
+    }
+
+    #[test]
+    fn remote_file_entry_dir_has_no_extension() {
+        let entry = crate::services::sftp::Entry {
+            name: "src".to_string(),
+            is_dir: true,
+            size: 0,
+            modified_secs: None,
+        };
+        let fe = remote_file_entry("/srv/project", entry);
+        assert_eq!(fe.path, "/srv/project/src");
+        assert_eq!(fe.extension, None);
+        assert_eq!(fe.mime, None);
+        assert!(fe.is_dir);
+    }
+
     // ── enforce_confinement ────────────────────────────────────────────────
 
     #[test]
@@ -818,6 +1970,67 @@ mod tests {
         );
     }
 
+    // ── dir_size_breakdown ──────────────────────────────────────────────────
+
+    fn git_available() -> bool {
+        crate::paths::command_no_window("git")
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+    }
+
+    fn init_repo(dir: &Path) {
+        let run = |args: &[&str]| {
+            assert!(
+                crate::paths::command_no_window("git")
+                    .args(args)
+                    .current_dir(dir)
+                    .output()
+                    .expect("git command should run")
+                    .status
+                    .success(),
+                "git {args:?} failed"
+            );
+        };
+        run(&["init"]);
+        run(&["config", "user.email", "test@example.com"]);
+        run(&["config", "user.name", "Test User"]);
+    }
+
+    #[test]
+    fn dir_size_breakdown_splits_ignored_from_tracked() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping dir_size_breakdown_splits_ignored_from_tracked");
+            return;
+        }
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path();
+        init_repo(dir);
+
+        std::fs::write(dir.join(".gitignore"), "whole/\n").unwrap();
+        std::fs::create_dir(dir.join("src")).unwrap();
+        std::fs::write(dir.join("src/main.rs"), "12345").unwrap(); // 5 bytes, tracked/untracked
+        std::fs::create_dir_all(dir.join("src/whole/sub")).unwrap();
+        std::fs::write(dir.join("src/whole/a.txt"), "1234567890").unwrap(); // 10 bytes, ignored
+        std::fs::write(dir.join("src/whole/sub/b.txt"), "12345678901234567890").unwrap(); // 20 bytes, ignored
+
+        let breakdown = dir_size_breakdown_local(&dir.to_string_lossy(), "src", &[]).expect("breakdown");
+        assert_eq!(breakdown.total, 35);
+        assert_eq!(breakdown.ignored, 30);
+    }
+
+    #[test]
+    fn dir_size_breakdown_no_git_yields_zero_ignored() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path();
+        std::fs::write(dir.join("a.txt"), "hello").unwrap();
+
+        let breakdown = dir_size_breakdown_local(&dir.to_string_lossy(), "", &[]).expect("breakdown");
+        assert_eq!(breakdown.total, 5);
+        assert_eq!(breakdown.ignored, 0);
+    }
+
     // ── copy_path / move_path ──────────────────────────────────────────────
 
     #[test]
@@ -861,6 +2074,79 @@ mod tests {
         assert_eq!(std::fs::read_to_string(tmp.path().join("b.txt")).unwrap(), "2");
     }
 
+    // ── extract_archive ────────────────────────────────────────────────────
+
+    /// Write a minimal .zip (stored, no compression) at `path` from
+    /// (entry-name, contents) pairs. An entry name ending in `/` is a directory.
+    fn write_test_zip(path: &Path, entries: &[(&str, &[u8])]) {
+        let file = std::fs::File::create(path).unwrap();
+        let mut zip = zip::ZipWriter::new(file);
+        let opts: zip::write::FileOptions<()> =
+            zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);
+        for (name, data) in entries {
+            if name.ends_with('/') {
+                zip.add_directory(*name, opts).unwrap();
+            } else {
+                use std::io::Write;
+                zip.start_file(*name, opts).unwrap();
+                zip.write_all(data).unwrap();
+            }
+        }
+        zip.finish().unwrap();
+    }
+
+    #[test]
+    fn extract_archive_unpacks_into_named_folder() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path().to_string_lossy().to_string();
+        write_test_zip(
+            &tmp.path().join("bundle.zip"),
+            &[("a.txt", b"hello"), ("sub/", b""), ("sub/b.txt", b"world")],
+        );
+
+        let folder = extract_archive(dir.clone(), "bundle.zip".into()).unwrap();
+
+        assert_eq!(folder, "bundle");
+        assert_eq!(
+            std::fs::read_to_string(tmp.path().join("bundle/a.txt")).unwrap(),
+            "hello"
+        );
+        assert_eq!(
+            std::fs::read_to_string(tmp.path().join("bundle/sub/b.txt")).unwrap(),
+            "world"
+        );
+    }
+
+    #[test]
+    fn extract_archive_dedupes_existing_folder() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path().to_string_lossy().to_string();
+        std::fs::create_dir(tmp.path().join("bundle")).unwrap();
+        write_test_zip(&tmp.path().join("bundle.zip"), &[("a.txt", b"x")]);
+
+        let folder = extract_archive(dir.clone(), "bundle.zip".into()).unwrap();
+
+        assert_eq!(folder, "bundle (1)");
+        assert!(tmp.path().join("bundle (1)/a.txt").exists());
+    }
+
+    #[test]
+    fn extract_archive_ignores_zip_slip_entries() {
+        let tmp = tempfile::tempdir().unwrap();
+        let dir = tmp.path().to_string_lossy().to_string();
+        // A crafted entry trying to escape the destination via `..`.
+        write_test_zip(
+            &tmp.path().join("evil.zip"),
+            &[("../escaped.txt", b"pwned"), ("safe.txt", b"ok")],
+        );
+
+        extract_archive(dir.clone(), "evil.zip".into()).unwrap();
+
+        // The traversal entry is dropped; the sibling escape file never appears.
+        assert!(!tmp.path().join("escaped.txt").exists());
+        assert!(tmp.path().join("evil/safe.txt").exists());
+    }
+
     #[test]
     fn copy_path_refuses_directory_into_itself() {
         let tmp = tempfile::tempdir().unwrap();
@@ -883,6 +2169,121 @@ mod tests {
         assert_eq!(std::fs::read_to_string(tmp.path().join("sub/b.txt")).unwrap(), "hello");
     }
 
+    // ── import_external_file ───────────────────────────────────────────────
+
+    #[test]
+    fn import_external_file_copies_into_subfolder() {
+        let ext = tempfile::tempdir().unwrap();
+        std::fs::write(ext.path().join("photo.png"), "img").unwrap();
+        let proj = tempfile::tempdir().unwrap();
+        std::fs::create_dir(proj.path().join("assets")).unwrap();
+
+        let rel = import_external_file(
+            proj.path().to_string_lossy().to_string(),
+            ext.path().join("photo.png").to_string_lossy().to_string(),
+            "assets".into(),
+            false,
+        )
+        .unwrap();
+
+        assert_eq!(rel, "assets/photo.png");
+        assert_eq!(
+            std::fs::read_to_string(proj.path().join("assets/photo.png")).unwrap(),
+            "img"
+        );
+        // Source is left in place (copy, not move).
+        assert!(ext.path().join("photo.png").exists());
+    }
+
+    #[test]
+    fn import_external_file_renames_on_collision() {
+        let ext = tempfile::tempdir().unwrap();
+        std::fs::write(ext.path().join("a.txt"), "new").unwrap();
+        let proj = tempfile::tempdir().unwrap();
+        std::fs::write(proj.path().join("a.txt"), "old").unwrap();
+
+        let rel = import_external_file(
+            proj.path().to_string_lossy().to_string(),
+            ext.path().join("a.txt").to_string_lossy().to_string(),
+            "".into(),
+            false,
+        )
+        .unwrap();
+
+        assert_eq!(rel, "a (1).txt");
+        // The pre-existing file is untouched; the import lands beside it.
+        assert_eq!(std::fs::read_to_string(proj.path().join("a.txt")).unwrap(), "old");
+        assert_eq!(std::fs::read_to_string(proj.path().join("a (1).txt")).unwrap(), "new");
+    }
+
+    #[test]
+    fn import_external_file_replace_overwrites() {
+        let ext = tempfile::tempdir().unwrap();
+        std::fs::write(ext.path().join("a.txt"), "new").unwrap();
+        let proj = tempfile::tempdir().unwrap();
+        std::fs::write(proj.path().join("a.txt"), "old").unwrap();
+
+        let rel = import_external_file(
+            proj.path().to_string_lossy().to_string(),
+            ext.path().join("a.txt").to_string_lossy().to_string(),
+            "".into(),
+            true,
+        )
+        .unwrap();
+
+        // Same name, content overwritten — no " (1)" copy created.
+        assert_eq!(rel, "a.txt");
+        assert_eq!(std::fs::read_to_string(proj.path().join("a.txt")).unwrap(), "new");
+        assert!(!proj.path().join("a (1).txt").exists());
+    }
+
+    #[test]
+    fn project_path_exists_reports_presence() {
+        let proj = tempfile::tempdir().unwrap();
+        std::fs::write(proj.path().join("here.txt"), "x").unwrap();
+        let dir = proj.path().to_string_lossy().to_string();
+        assert!(project_path_exists(dir.clone(), "here.txt".into()).unwrap());
+        assert!(!project_path_exists(dir, "missing.txt".into()).unwrap());
+    }
+
+    #[test]
+    fn import_external_file_recurses_into_directories() {
+        let ext = tempfile::tempdir().unwrap();
+        std::fs::create_dir(ext.path().join("pkg")).unwrap();
+        std::fs::write(ext.path().join("pkg/mod.rs"), "fn x() {}").unwrap();
+        let proj = tempfile::tempdir().unwrap();
+
+        let rel = import_external_file(
+            proj.path().to_string_lossy().to_string(),
+            ext.path().join("pkg").to_string_lossy().to_string(),
+            "".into(),
+            false,
+        )
+        .unwrap();
+
+        assert_eq!(rel, "pkg");
+        assert_eq!(
+            std::fs::read_to_string(proj.path().join("pkg/mod.rs")).unwrap(),
+            "fn x() {}"
+        );
+    }
+
+    #[test]
+    fn import_external_file_rejects_escaping_dest() {
+        let ext = tempfile::tempdir().unwrap();
+        std::fs::write(ext.path().join("a.txt"), "x").unwrap();
+        let proj = tempfile::tempdir().unwrap();
+
+        let err = import_external_file(
+            proj.path().to_string_lossy().to_string(),
+            ext.path().join("a.txt").to_string_lossy().to_string(),
+            "../escape".into(),
+            false,
+        )
+        .unwrap_err();
+        assert!(err.contains("invalid path component"), "{err}");
+    }
+
     // ── list_project_endings ───────────────────────────────────────────────
 
     #[test]
@@ -910,10 +2311,10 @@ mod tests {
     #[test]
     fn write_project_file_creates_nested_file_inside_project() {
         let tmp = tempfile::tempdir().unwrap();
-        write_project_file(
-            tmp.path().to_string_lossy().to_string(),
-            ".eldrun/scaffold-fill-claude.md".to_string(),
-            "fill AGENTS.md".to_string(),
+        write_project_file_local(
+            &tmp.path().to_string_lossy(),
+            ".eldrun/scaffold-fill-claude.md",
+            "fill AGENTS.md",
         )
         .unwrap();
 
@@ -927,12 +2328,7 @@ mod tests {
         let tmp = tempfile::tempdir().unwrap();
         std::fs::write(tmp.path().join("old.txt"), "content").unwrap();
 
-        rename_path(
-            tmp.path().to_string_lossy().to_string(),
-            "old.txt".to_string(),
-            "new.txt".to_string(),
-        )
-        .unwrap();
+        rename_path_local(&tmp.path().to_string_lossy(), "old.txt", "new.txt").unwrap();
 
         assert!(!tmp.path().join("old.txt").exists());
         assert_eq!(
@@ -948,7 +2344,7 @@ mod tests {
         let dir = tmp.path().to_string_lossy().to_string();
 
         for bad in ["", " ", ".", "..", "sub/name", "..\\name", "a\0b"] {
-            let err = rename_path(dir.clone(), "a.txt".to_string(), bad.to_string());
+            let err = rename_path_local(&dir, "a.txt", bad);
             assert!(err.is_err(), "name {bad:?} must be rejected");
         }
         assert!(tmp.path().join("a.txt").exists(), "file must be untouched");
@@ -957,16 +2353,55 @@ mod tests {
     #[test]
     fn write_project_file_blocks_parent_escape() {
         let tmp = tempfile::tempdir().unwrap();
-        let err = write_project_file(
-            tmp.path().to_string_lossy().to_string(),
-            "../outside.md".to_string(),
-            "escape".to_string(),
+        let err = write_project_file_local(
+            &tmp.path().to_string_lossy(),
+            "../outside.md",
+            "escape",
         )
         .unwrap_err();
 
         assert!(err.contains("escapes project root"), "unexpected error: {err}");
     }
 
+    // ── Remote path join / confinement (mount-free remote, Phase 3) ─────────
+
+    #[test]
+    fn remote_join_confined_joins_clean_rel() {
+        assert_eq!(
+            remote_join_confined("/srv/project", "src/main.rs").unwrap(),
+            "/srv/project/src/main.rs"
+        );
+        // Empty rel resolves to the project root itself.
+        assert_eq!(remote_join_confined("/srv/project", "").unwrap(), "/srv/project");
+    }
+
+    #[test]
+    fn remote_join_confined_rejects_traversal() {
+        assert!(remote_join_confined("/srv/project", "../escape").is_err());
+        assert!(remote_join_confined("/srv/project", "a/../../b").is_err());
+        // A leading slash (absolute rel) is a RootDir component → rejected, so a
+        // caller can never pivot the join off the project root.
+        assert!(remote_join_confined("/srv/project", "/etc/passwd").is_err());
+    }
+
+    #[test]
+    fn confine_remote_abs_allows_paths_under_root() {
+        assert!(confine_remote_abs("/srv/project", "/srv/project").is_ok());
+        assert!(confine_remote_abs("/srv/project", "/srv/project/src/main.rs").is_ok());
+        // Trailing slash on the root is tolerated.
+        assert!(confine_remote_abs("/srv/project/", "/srv/project/a").is_ok());
+    }
+
+    #[test]
+    fn confine_remote_abs_blocks_outside_and_prefix_sibling() {
+        // A sibling that merely shares a string prefix must NOT be inside.
+        assert!(confine_remote_abs("/srv/project", "/srv/project-evil/loot").is_err());
+        // Unrelated absolute path.
+        assert!(confine_remote_abs("/srv/project", "/etc/passwd").is_err());
+        // Parent-dir traversal is refused even if it would resolve back inside.
+        assert!(confine_remote_abs("/srv/project", "/srv/project/../secret").is_err());
+    }
+
     // ── Absolute-path confinement (Security #1) ─────────────────────────────
 
     fn entry(id: &str, status: &str, dir: &str) -> ProjectEntry {
@@ -983,24 +2418,39 @@ mod tests {
     }
 
     #[test]
-    fn allowed_roots_scoped_to_current_project_only() {
+    fn allowed_roots_scoped_to_named_project_not_current() {
+        // The scope is the *viewer's own* project, not whichever is current. A
+        // viewer owned by Y stays able to reach Y even while X is current — and
+        // X's tree is NOT reachable through Y's scope (per-project isolation).
         let projects = vec![
             entry("x", "current", "/home/u/code/projectx"),
             entry("y", "inactive", "/home/u/code/projecty"),
         ];
-        let roots = compute_allowed_roots(&projects, &Vec::new());
-        // Only X (the current project) is reachable; sibling Y is not.
-        assert!(roots
-            .iter()
-            .any(|r| r.ends_with("projectx")));
+        let roots = compute_allowed_roots(&projects, &Vec::new(), Some("y"));
+        assert!(
+            roots.iter().any(|r| r.ends_with("projecty")),
+            "the scope project must be reachable even when it is not current"
+        );
         assert!(
-            !roots.iter().any(|r| r.ends_with("projecty")),
-            "a non-current sibling project must not be reachable"
+            !roots.iter().any(|r| r.ends_with("projectx")),
+            "a project outside the scope must not be reachable"
         );
     }
 
     #[test]
-    fn allowed_roots_includes_box_siblings() {
+    fn allowed_roots_falls_back_to_current_when_no_scope() {
+        // No scope id (root scope / legacy caller) → the current project.
+        let projects = vec![
+            entry("x", "current", "/home/u/code/projectx"),
+            entry("y", "inactive", "/home/u/code/projecty"),
+        ];
+        let roots = compute_allowed_roots(&projects, &Vec::new(), None);
+        assert!(roots.iter().any(|r| r.ends_with("projectx")));
+        assert!(!roots.iter().any(|r| r.ends_with("projecty")));
+    }
+
+    #[test]
+    fn allowed_roots_includes_box_siblings_of_scope() {
         let projects = vec![
             entry("x", "current", "/home/u/code/projectx"),
             entry("y", "inactive", "/home/u/code/projecty"),
@@ -1009,23 +2459,47 @@ mod tests {
         let boxes = vec![crate::schema::boxes::ProjectBox {
             id: "b1".to_string(),
             name: "grp".to_string(),
-            member_ids: vec!["x".to_string(), "y".to_string()],
+            member_ids: vec!["y".to_string(), "z".to_string()],
             ..Default::default()
         }];
-        let roots = compute_allowed_roots(&projects, &boxes);
-        // X (current) and Y (box sibling) are reachable; Z (unrelated) is not.
-        assert!(roots.iter().any(|r| r.ends_with("projectx")));
+        // Scope is Y; its box sibling Z is co-accessible, X (current) is not.
+        let roots = compute_allowed_roots(&projects, &boxes, Some("y"));
         assert!(roots.iter().any(|r| r.ends_with("projecty")));
+        assert!(roots.iter().any(|r| r.ends_with("projectz")));
+        assert!(
+            !roots.iter().any(|r| r.ends_with("projectx")),
+            "a project outside the scope's box must not be reachable"
+        );
+    }
+
+    #[test]
+    fn allowed_roots_includes_remote_mirror_override() {
+        // A remote (SSH) project's browsable tree is its local mirror, relocated
+        // outside the state dir via extra["mirror"]. That mirror must be reachable
+        // or opening a mirrored local file fails confinement (#28k regression).
+        let mut r = entry("r", "current", "/home/u/.local/share/eldrun/remote-projects/r");
+        r.extra.insert(
+            "mirror".to_string(),
+            Value::String("/home/u/eldrun/projects-ssh/myproj".to_string()),
+        );
+        let roots = compute_allowed_roots(&vec![r], &Vec::new(), Some("r"));
         assert!(
-            !roots.iter().any(|r| r.ends_with("projectz")),
-            "a project outside the current box must not be reachable"
+            roots.iter().any(|p| p.ends_with("projects-ssh/myproj")),
+            "the relocated local mirror must be an allowed root"
         );
     }
 
     #[test]
-    fn allowed_roots_empty_when_no_current_project() {
+    fn allowed_roots_empty_when_scope_unknown() {
+        let projects = vec![entry("x", "current", "/home/u/code/projectx")];
+        // An unknown scope id resolves to no project → fail closed.
+        assert!(compute_allowed_roots(&projects, &Vec::new(), Some("nope")).is_empty());
+    }
+
+    #[test]
+    fn allowed_roots_empty_when_no_current_and_no_scope() {
         let projects = vec![entry("x", "inactive", "/home/u/code/projectx")];
-        assert!(compute_allowed_roots(&projects, &Vec::new()).is_empty());
+        assert!(compute_allowed_roots(&projects, &Vec::new(), None).is_empty());
     }
 
     #[test]
@@ -1067,4 +2541,77 @@ mod tests {
     fn confine_abs_within_empty_roots_refuses_everything() {
         assert!(confine_abs_within(Path::new("/home/u/code/projectx/a"), &[]).is_err());
     }
+
+    // ── display_path ───────────────────────────────────────────────────────
+
+    #[test]
+    fn display_path_is_noop_without_verbatim_prefix() {
+        // A plain path is returned unchanged on every platform.
+        let p = if cfg!(target_os = "windows") {
+            r"C:\Users\u\proj\file.txt"
+        } else {
+            "/home/u/proj/file.txt"
+        };
+        assert_eq!(display_path(Path::new(p)), p);
+    }
+
+    #[test]
+    fn excluded_rel_set_normalises_every_spelling_to_one() {
+        let set = excluded_rel_set(&[
+            "venv".into(),
+            "./data/raw".into(),
+            "/results/".into(),
+            "a\\b".into(),
+            "  spaced  ".into(),
+            String::new(),
+            "/".into(),
+        ]);
+        assert!(set.contains("venv"));
+        assert!(set.contains("data/raw"));
+        assert!(set.contains("results"));
+        assert!(set.contains("a/b"));
+        assert!(set.contains("spaced"));
+        // Empty and separator-only entries are dropped rather than becoming an
+        // empty-string key, which would match the project root and prune the lot.
+        assert_eq!(set.len(), 5);
+    }
+
+    #[test]
+    fn dir_size_skips_an_excluded_subtree() {
+        let tmp = std::env::temp_dir().join(format!("eldrun-excl-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&tmp);
+        fs::create_dir_all(tmp.join("keep")).unwrap();
+        fs::create_dir_all(tmp.join("venv/lib")).unwrap();
+        fs::write(tmp.join("keep/a.txt"), vec![b'x'; 100]).unwrap();
+        fs::write(tmp.join("venv/lib/big.bin"), vec![b'x'; 5000]).unwrap();
+        let root = tmp.to_string_lossy().to_string();
+
+        let all = dir_size_local(&root, "", &[]).unwrap();
+        assert_eq!(all, 5100, "baseline walks everything");
+
+        let pruned = dir_size_local(&root, "", &["venv".into()]).unwrap();
+        assert_eq!(pruned, 100, "the excluded subtree contributes nothing");
+
+        // Exclusions are project-root-relative, so they still bite when the walk
+        // starts deeper — here the walk root IS the excluded folder's parent.
+        let nested = dir_size_local(&root, "venv", &["venv/lib".into()]).unwrap();
+        assert_eq!(nested, 0);
+
+        let _ = fs::remove_dir_all(&tmp);
+    }
+
+    #[test]
+    #[cfg(target_os = "windows")]
+    fn display_path_strips_windows_verbatim_prefixes() {
+        // Drive verbatim prefix is removed so the frontend sees a native path.
+        assert_eq!(
+            display_path(Path::new(r"\\?\C:\proj\file.txt")),
+            r"C:\proj\file.txt"
+        );
+        // UNC verbatim prefix collapses back to a `\\server\share` path.
+        assert_eq!(
+            display_path(Path::new(r"\\?\UNC\server\share\file.txt")),
+            r"\\server\share\file.txt"
+        );
+    }
 }
diff --git a/src-tauri/src/commands/fs_watch.rs b/src-tauri/src/commands/fs_watch.rs
index 8bf7554..6a12414 100644
--- a/src-tauri/src/commands/fs_watch.rs
+++ b/src-tauri/src/commands/fs_watch.rs
@@ -10,11 +10,19 @@
 //! unwatches it.
 
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
+use std::time::Duration;
 
 use notify::{recommended_watcher, RecursiveMode, Watcher};
 use tauri::{AppHandle, Emitter, State};
 
+/// How long to coalesce a burst of raw `notify` events into a single
+/// `fs-change` emit. A single write (or a `git status` touching `.git/*` while
+/// the repo root is watched) fires many raw events back-to-back; without this
+/// the frontend would receive a storm of `fs-change` events.
+const DEBOUNCE: Duration = Duration::from_millis(200);
+
 /// Currently-watched canonical directory and its live watcher. `None` when
 /// nothing is being watched (panel closed / unmounted).
 pub type FsWatchState = Arc<Mutex<Option<(PathBuf, notify::RecommendedWatcher)>>>;
@@ -29,6 +37,13 @@ pub fn watch_dir(
     state: State<'_, FsWatchState>,
     path: String,
 ) -> Result<(), String> {
+    // Mount-free remote (Phase 2): inotify cannot see a remote (SFTP) tree, and a
+    // remote project's watched dir is its non-fs mountpoint root. No-op so the
+    // remote file tree just relies on manual refresh; the frontend already skips
+    // watching for remote projects, this is belt-and-suspenders.
+    if crate::services::remote::remote_target_for_dir(&path).is_some() {
+        return Ok(());
+    }
     let canonical = std::fs::canonicalize(&path).map_err(|e| e.to_string())?;
 
     let mut guard = state.lock().unwrap();
@@ -39,10 +54,39 @@ pub fn watch_dir(
     }
 
     let emit_path = canonical.to_string_lossy().to_string();
+    // Trailing-edge debounce: each raw event bumps a shared generation, and ONE
+    // long-lived thread waits out `DEBOUNCE` and emits only if no newer event
+    // arrived meanwhile. A burst of raw events thus collapses into a single
+    // `fs-change`.
+    //
+    // The generation counter used to be paired with a `std::thread::spawn` *per
+    // raw event*. That is fine at a handful of events and pathological at a burst:
+    // an unpacking install or a recursive size walk in the watched directory turns
+    // into thousands of thread spawns a second, each one only to sleep 200ms and
+    // find itself outdated. One parked thread does the same job at a fixed cost.
+    let generation = Arc::new(AtomicU64::new(0));
+    let (tx, rx) = std::sync::mpsc::channel::<u64>();
+    {
+        let generation = Arc::clone(&generation);
+        std::thread::spawn(move || {
+            // Ends when the watcher (and with it the sender) is dropped.
+            while let Ok(seen) = rx.recv() {
+                std::thread::sleep(DEBOUNCE);
+                // Only the last event of a burst still matches — the rest have been
+                // superseded, and their queued messages are drained by this same
+                // check on the next iterations.
+                if generation.load(Ordering::SeqCst) == seen {
+                    let _ = app.emit("fs-change", &emit_path);
+                }
+            }
+        });
+    }
     let mut watcher = recommended_watcher(move |res: notify::Result<notify::Event>| {
-        if res.is_ok() {
-            let _ = app.emit("fs-change", &emit_path);
+        if res.is_err() {
+            return;
         }
+        let my_gen = generation.fetch_add(1, Ordering::SeqCst) + 1;
+        let _ = tx.send(my_gen);
     })
     .map_err(|e| e.to_string())?;
 
diff --git a/src-tauri/src/commands/git.rs b/src-tauri/src/commands/git.rs
index 198386c..b0b646f 100644
--- a/src-tauri/src/commands/git.rs
+++ b/src-tauri/src/commands/git.rs
@@ -1,6 +1,91 @@
 use std::collections::HashMap;
-use std::path::Path;
-use std::process::Command;
+use std::path::{Path, PathBuf};
+
+use crate::services::remote::{remote_target_for_dir, RemoteTarget};
+
+// Every git invocation goes through the single `run_git` helper, which dispatches
+// on whether the project is local or remote:
+//
+//   * **local** → `crate::paths::command_no_window("git")` in `project_dir`
+//     rather than a bare `Command::new`: Eldrun is a windowed app with no
+//     console, so on Windows every `git` subprocess would otherwise flash a
+//     transient console window — and `git_status`/`git_file_statuses` are polled
+//     continuously for the file tree. `command_no_window` sets CREATE_NO_WINDOW
+//     on Windows and is a no-op elsewhere.
+//   * **remote** (project carries a `RemoteSpec`) → the same `git <args>` run on
+//     the host over SSH, riding the shared ControlMaster (`ssh_exec::
+//     run_git_remote`). git's output is plain text, so the captured stdout/
+//     stderr/exit are parsed byte-for-byte identically to the local case and
+//     every parser below is reused unchanged. `push` then authenticates with the
+//     *host's* own git credentials/SSH keys, since git runs there.
+//
+// Each command resolves remoteness once via `remote_target_for_dir(&project_dir)`
+// (a reverse-lookup from the absolute `project_dir` the frontend passes to the
+// owning project's `RemoteSpec`) and threads the resulting `Option<&RemoteTarget>`
+// into `run_git` and the `local_non_repo` guard.
+
+/// Run `git <args>` for a project, dispatching local-vs-remote on `target`.
+/// Returns the captured `Output` (stdout/stderr/exit) for both, so callers parse
+/// it identically. `target` is the resolved remoteness for `project_dir`.
+fn run_git(
+    target: Option<&RemoteTarget>,
+    project_dir: &str,
+    args: &[&str],
+) -> Result<std::process::Output, String> {
+    match target {
+        Some(t) => {
+            let owned: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+            crate::services::ssh_exec::run_git_remote(&t.spec, &owned)
+        }
+        None => crate::paths::command_no_window("git")
+            .args(args)
+            .current_dir(project_dir)
+            .output()
+            .map_err(|e| e.to_string()),
+    }
+}
+
+/// Cheap "not a git repo" short-circuit for the read commands. Applies only to
+/// **local** projects, where a missing `.git` means "no repo" without spawning
+/// git. A remote project's `.git` lives on the host, so it is never short-
+/// circuited here — its command runs over SSH and the usual lenient
+/// empty-on-failure handling covers a non-repo host dir.
+fn local_non_repo(target: Option<&RemoteTarget>, project_dir: &str) -> bool {
+    target.is_none() && !Path::new(project_dir).join(".git").exists()
+}
+
+/// Run a blocking git command body on a worker thread.
+///
+/// Every git command here is genuinely blocking — `run_git` either spawns a local
+/// `git` subprocess (`.output()`) or runs `git` over SSH (`run_git_remote`, which
+/// can stall up to the SSH `ConnectTimeout`/`ServerAlive` window on an unreachable
+/// or unauthenticated host). Tauri runs a synchronous `#[command]` on the MAIN
+/// thread, so doing that work inline froze the whole window whenever a remote
+/// project's host was down (the remote-disconnect freeze). Each command is an
+/// `async` wrapper that offloads its sync body here via `spawn_blocking`, so the
+/// blocking work runs on tokio's blocking pool and the UI thread stays free. The
+/// bodies live in sibling `*_blocking` fns (kept sync, so they remain directly
+/// unit-testable without a tokio runtime).
+pub(crate) async fn run_off_thread<T: Send + 'static>(
+    f: impl FnOnce() -> Result<T, String> + Send + 'static,
+) -> Result<T, String> {
+    tokio::task::spawn_blocking(f)
+        .await
+        .map_err(|e| format!("git task failed: {e}"))?
+}
+
+/// Whether the `git` binary is on `PATH`. The new/import-project dialog calls
+/// this before offering a git-backed project, so a missing `git` surfaces as an
+/// install prompt instead of `scaffold_project` silently no-oping `git init`
+/// (see its `let _ =` discard) and registering a git-typed project with no repo.
+#[tauri::command]
+pub fn git_available() -> bool {
+    crate::paths::command_no_window("git")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
 
 #[derive(serde::Serialize)]
 pub struct GitStatus {
@@ -12,17 +97,17 @@ pub struct GitStatus {
 }
 
 #[tauri::command]
-pub fn git_status(project_dir: String) -> Result<GitStatus, String> {
-    let dir = Path::new(&project_dir);
-    if !dir.join(".git").exists() {
+pub async fn git_status(project_dir: String) -> Result<GitStatus, String> {
+    run_off_thread(move || git_status_blocking(project_dir)).await
+}
+
+fn git_status_blocking(project_dir: String) -> Result<GitStatus, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
         return Ok(GitStatus { staged: 0, unstaged: 0, untracked: 0, has_remote: false, is_repo: false });
     }
 
-    let out = Command::new("git")
-        .args(["status", "--porcelain"])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+    let out = run_git(target.as_ref(), &project_dir, &["status", "--porcelain"])?;
 
     let text = String::from_utf8_lossy(&out.stdout);
     let mut staged = 0usize;
@@ -40,23 +125,62 @@ pub fn git_status(project_dir: String) -> Result<GitStatus, String> {
         }
     }
 
-    let has_remote = Command::new("git")
-        .args(["remote"])
-        .current_dir(&project_dir)
-        .output()
+    let has_remote = run_git(target.as_ref(), &project_dir, &["remote"])
         .map(|o| !o.stdout.is_empty())
         .unwrap_or(false);
 
     Ok(GitStatus { staged, unstaged, untracked, has_remote, is_repo: true })
 }
 
+/// Resolve the git top-level enclosing `project_dir`/`rel_path` (the folder the
+/// user is currently browsing in the file tree). Returns the absolute repo root
+/// path, or `None` when the folder isn't inside any git repo. The right panel
+/// uses this to detect a **nested** repo — a subfolder that is its own git repo
+/// distinct from the project's repo — and re-root its git section at it.
+///
+/// Local only for now: a remote project's tree lives on the host, and a nested
+/// host toplevel can't be reverse-mapped back to the project's `RemoteSpec` by
+/// `remote_target_for_dir`, so remote projects short-circuit to `None` and keep
+/// their existing project-scoped behavior.
 #[tauri::command]
-pub fn git_add_all(project_dir: String) -> Result<(), String> {
-    let out = Command::new("git")
-        .args(["add", "-A"])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_repo_root(project_dir: String, rel_path: String) -> Result<Option<String>, String> {
+    run_off_thread(move || git_repo_root_blocking(project_dir, rel_path)).await
+}
+
+fn git_repo_root_blocking(project_dir: String, rel_path: String) -> Result<Option<String>, String> {
+    // Remote projects keep project-scoped git (see doc comment).
+    if remote_target_for_dir(&project_dir).is_some() {
+        return Ok(None);
+    }
+    let dir: PathBuf = if rel_path.is_empty() {
+        PathBuf::from(&project_dir)
+    } else {
+        Path::new(&project_dir).join(&rel_path)
+    };
+    // `--show-toplevel` prints the absolute root of the innermost repo enclosing
+    // `dir`. Any failure (not a repo, missing dir) maps to `None`, not an error,
+    // so the UI treats it as "no repo here" rather than flashing a banner.
+    let out = crate::paths::command_no_window("git")
+        .args(["rev-parse", "--show-toplevel"])
+        .current_dir(&dir)
+        .output();
+    match out {
+        Ok(o) if o.status.success() => {
+            let top = String::from_utf8_lossy(&o.stdout).trim().to_string();
+            Ok(if top.is_empty() { None } else { Some(top) })
+        }
+        _ => Ok(None),
+    }
+}
+
+#[tauri::command]
+pub async fn git_add_all(project_dir: String) -> Result<(), String> {
+    run_off_thread(move || git_add_all_blocking(project_dir)).await
+}
+
+fn git_add_all_blocking(project_dir: String) -> Result<(), String> {
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["add", "-A"])?;
     if !out.status.success() {
         return Err(String::from_utf8_lossy(&out.stderr).to_string());
     }
@@ -64,21 +188,19 @@ pub fn git_add_all(project_dir: String) -> Result<(), String> {
 }
 
 #[tauri::command]
-pub fn git_generate_commit_message(project_dir: String) -> Result<String, String> {
-    let files_out = Command::new("git")
-        .args(["diff", "--staged", "--name-only"])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_generate_commit_message(project_dir: String) -> Result<String, String> {
+    run_off_thread(move || git_generate_commit_message_blocking(project_dir)).await
+}
+
+fn git_generate_commit_message_blocking(project_dir: String) -> Result<String, String> {
+    let target = remote_target_for_dir(&project_dir);
+    let files_out = run_git(target.as_ref(), &project_dir, &["diff", "--staged", "--name-only"])?;
     let staged_text = String::from_utf8_lossy(&files_out.stdout).to_string();
     let staged: Vec<&str> = staged_text.lines().collect();
 
     // Also check untracked / unstaged if nothing staged
     let files: Vec<String> = if staged.is_empty() {
-        let all = Command::new("git")
-            .args(["diff", "--name-only"])
-            .current_dir(&project_dir)
-            .output()
+        let all = run_git(target.as_ref(), &project_dir, &["diff", "--name-only"])
             .map(|o| String::from_utf8_lossy(&o.stdout).lines().map(str::to_owned).collect())
             .unwrap_or_default();
         all
@@ -130,12 +252,13 @@ fn format_commit_message(kind: &str, files: &[String]) -> String {
 }
 
 #[tauri::command]
-pub fn git_commit(project_dir: String, message: String) -> Result<(), String> {
-    let out = Command::new("git")
-        .args(["commit", "-m", &message])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_commit(project_dir: String, message: String) -> Result<(), String> {
+    run_off_thread(move || git_commit_blocking(project_dir, message)).await
+}
+
+fn git_commit_blocking(project_dir: String, message: String) -> Result<(), String> {
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["commit", "-m", &message])?;
     if !out.status.success() {
         return Err(String::from_utf8_lossy(&out.stderr).to_string());
     }
@@ -151,20 +274,59 @@ pub fn git_commit(project_dir: String, message: String) -> Result<(), String> {
 ///   "ignored"   – ignored by git (gray ✕)
 /// For directories the highest-priority child status bubbles up.
 #[tauri::command]
-pub fn git_file_statuses(
+pub async fn git_file_statuses(
     project_dir: String,
     rel_path: String,
 ) -> Result<HashMap<String, String>, String> {
-    let dir = Path::new(&project_dir);
-    if !dir.join(".git").exists() {
+    run_off_thread(move || git_file_statuses_blocking(project_dir, rel_path)).await
+}
+
+fn git_file_statuses_blocking(
+    project_dir: String,
+    rel_path: String,
+) -> Result<HashMap<String, String>, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
         return Ok(HashMap::new());
     }
 
-    let out = Command::new("git")
-        .args(["status", "--porcelain", "--ignored"])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+    // A directory that is itself wholly ignored is collapsed by git into a
+    // single `!! rel_path/` line at every ancestor listing under the default
+    // `--untracked-files=normal` — so listing `rel_path` itself would come
+    // back with zero lines under its prefix, and its children would silently
+    // lose their "ignored" marker (rather than the folder just being empty of
+    // git-reportable changes, which is the far more common reason this map
+    // comes back empty). Detect that case up front via `check-ignore` and add
+    // `--untracked-files=all`, which makes git recurse into an ignored
+    // directory and report every file underneath individually instead of
+    // collapsing it, scoped to `rel_path` so this stays cheap even inside a
+    // huge folder like `node_modules`. Left off for the common case: it's a
+    // more expensive walk, and combined with the anti-bubble rule below it
+    // would actually stop a normal (non-wholly-ignored-ancestor) ignored
+    // subfolder from being recognized, since a deep file line like
+    // `sub/leaf.js` never equals its containing folder's own name.
+    let wholly_ignored = !rel_path.is_empty()
+        && run_git(target.as_ref(), &project_dir, &["check-ignore", "-q", "--", &rel_path])
+            .map(|out| out.status.success())
+            .unwrap_or(false);
+
+    // Scope the status to the browsed folder. Without a pathspec git walks the
+    // WHOLE repo — and with `--ignored` that means stat-ing every ignored path in
+    // it — only for `record` below to throw away every line outside `rel_path`
+    // anyway. On a REMOTE project that walk runs on the host over SSH, on every
+    // folder navigation and on every Local→Remote switch, which is what made
+    // both feel like a hang on a repo carrying big gitignored trees (data,
+    // checkpoints, venvs). The wholly-ignored branch already scoped itself for
+    // exactly this reason; the common branch just never did. An empty
+    // `rel_path` IS the repo root, so there is nothing to scope it to.
+    let status_args: Vec<&str> = if wholly_ignored {
+        vec!["status", "--porcelain", "--ignored", "--untracked-files=all", "--", &rel_path]
+    } else if rel_path.is_empty() {
+        vec!["status", "--porcelain", "--ignored", "--untracked-files=normal"]
+    } else {
+        vec!["status", "--porcelain", "--ignored", "--untracked-files=normal", "--", &rel_path]
+    };
+    let out = run_git(target.as_ref(), &project_dir, &status_args)?;
     let porcelain = String::from_utf8_lossy(&out.stdout).into_owned();
 
     // prefix used to filter entries under rel_path
@@ -202,6 +364,21 @@ pub fn git_file_statuses(
         let top = rel.split('/').next().unwrap_or(rel);
         if top.is_empty() { return; }
 
+        // "ignored" must not bubble up from a descendant: git reports a wholly
+        // ignored path as `foo` (file) or `foo/` (whole dir), but an ignored
+        // file inside an otherwise-tracked dir as `foo/bar`. Only mark the
+        // top-level entry ignored when the ignored path IS that entry — else a
+        // single ignored child would drag the whole folder into the gitignored
+        // section. Other statuses still bubble up so a dir reflects its changes.
+        // Skipped when `rel_path` itself is already known to be wholly
+        // ignored: every line here is one of its descendants, so there is no
+        // "is this ONE child ignored or is the whole folder" ambiguity to
+        // guard against, and a deep file's top-level parent must still be
+        // marked ignored even though the two paths never match exactly.
+        if status == "ignored" && !wholly_ignored && rel.trim_end_matches('/') != top {
+            return;
+        }
+
         let cur = map.get(top).map(|s| priority(s.as_str())).unwrap_or(0);
         if priority(status) > cur {
             map.insert(top.to_string(), status.to_string());
@@ -230,10 +407,7 @@ pub fn git_file_statuses(
     }
 
     // Files in commits that exist locally but are not on the upstream branch.
-    if let Ok(out) = Command::new("git")
-        .args(["log", "@{u}..", "--name-only", "--pretty=format:"])
-        .current_dir(&project_dir)
-        .output()
+    if let Ok(out) = run_git(target.as_ref(), &project_dir, &["log", "@{u}..", "--name-only", "--pretty=format:"])
     {
         if out.status.success() {
             let committed = String::from_utf8_lossy(&out.stdout).into_owned();
@@ -246,36 +420,193 @@ pub fn git_file_statuses(
         }
     }
 
+    // When `rel_path` is itself wholly ignored, EVERY entry under it is ignored —
+    // but git's porcelain only ever emits *file* lines, so a child that is an
+    // empty directory (or a tree of only empty directories, e.g. freshly scaffolded
+    // experiment-output folders) produces no line at all and would silently drop
+    // its "ignored" marker, landing in the regular section. git also can't be
+    // coaxed into listing such dirs: it collapses a wholly-ignored subtree to its
+    // topmost ignored ancestor and never enumerates empty descendants. Emit a
+    // sentinel under the reserved key "." (never a real listing entry) so the
+    // frontend can default every child of this directory to ignored, letting any
+    // explicit per-child status above (a force-added tracked file) still win.
+    if wholly_ignored {
+        map.insert(".".to_string(), "ignored".to_string());
+    }
+
     Ok(map)
 }
 
 /// Stages a specific path (file or directory) via `git add`.
 #[tauri::command]
-pub fn git_add_path(project_dir: String, rel_path: String) -> Result<(), String> {
-    let out = Command::new("git")
-        .args(["add", "--", &rel_path])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_add_path(project_dir: String, rel_path: String) -> Result<(), String> {
+    run_off_thread(move || git_add_path_blocking(project_dir, rel_path)).await
+}
+
+fn git_add_path_blocking(project_dir: String, rel_path: String) -> Result<(), String> {
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["add", "--", &rel_path])?;
     if !out.status.success() {
         return Err(String::from_utf8_lossy(&out.stderr).to_string());
     }
     Ok(())
 }
 
+/// A single changed file with its line delta, used by the action-button change
+/// tree (Add/Commit/Push). `binary` files report 0/0 — git emits "-" for them.
+#[derive(serde::Serialize)]
+pub struct FileChange {
+    pub path: String,
+    pub added: i64,
+    pub deleted: i64,
+    pub binary: bool,
+}
+
+/// Per-file line stats (`git diff --numstat`) for one of three scopes:
+///   "unstaged" – working-tree changes + untracked files (the Add list)
+///   "staged"   – index vs HEAD (the Commit list)
+///   "unpushed" – local commits ahead of upstream (the Push list)
+/// The frontend folds these flat paths into a navigable folder tree.
+#[tauri::command]
+pub async fn git_change_stats(
+    project_dir: String,
+    scope: String,
+    pool: tauri::State<'_, crate::services::remote::RemotePoolState>,
+) -> Result<Vec<FileChange>, String> {
+    let dir = Path::new(&project_dir);
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
+        return Ok(vec![]);
+    }
+
+    let numstat_args: &[&str] = match scope.as_str() {
+        "staged" => &["diff", "--cached", "--numstat", "--"],
+        "unpushed" => &["diff", "@{u}..", "--numstat", "--"],
+        _ => &["diff", "--numstat", "--"],
+    };
+
+    let mut changes: Vec<FileChange> = Vec::new();
+    if let Ok(out) = run_git(target.as_ref(), &project_dir, numstat_args)
+    {
+        if out.status.success() {
+            let text = String::from_utf8_lossy(&out.stdout);
+            for line in text.lines() {
+                let mut parts = line.splitn(3, '\t');
+                let a = parts.next().unwrap_or("");
+                let d = parts.next().unwrap_or("");
+                let p = parts.next().unwrap_or("");
+                if p.is_empty() {
+                    continue;
+                }
+                changes.push(FileChange {
+                    path: normalize_numstat_path(p),
+                    added: a.parse().unwrap_or(0),
+                    deleted: d.parse().unwrap_or(0),
+                    binary: a == "-" || d == "-",
+                });
+            }
+        }
+    }
+
+    // Untracked files never appear in `git diff`; list them separately and count
+    // their lines as additions (the Add list shows them alongside modified files).
+    if scope == "unstaged" {
+        if let Ok(out) = run_git(target.as_ref(), &project_dir, &["ls-files", "--others", "--exclude-standard", "-z"])
+        {
+            if out.status.success() {
+                for chunk in out.stdout.split(|&b| b == 0) {
+                    if chunk.is_empty() {
+                        continue;
+                    }
+                    let rel = String::from_utf8_lossy(chunk).into_owned();
+                    // Untracked line counts read the file's bytes and apply the
+                    // same NUL/newline logic for both project kinds:
+                    //   * local  → `std::fs::read` under the project directory;
+                    //   * remote → the bytes over the pooled SFTP session, with
+                    //     the rel path confined under `spec.remote_path` (a path
+                    //     that escapes the root is treated as unreadable).
+                    // Any read/confinement error degrades to (0, false) rather
+                    // than failing the whole listing.
+                    let (added, binary) = match &target {
+                        None => count_added_lines(&dir.join(&rel)),
+                        Some(t) => count_added_lines_remote(&pool, t, &rel).await,
+                    };
+                    changes.push(FileChange { path: rel, added, deleted: 0, binary });
+                }
+            }
+        }
+    }
+
+    Ok(changes)
+}
+
+/// `git --numstat` renders renames as `old => new`, optionally with a braced
+/// common segment (`src/{a => b}/f.rs`). Reduce either form to the new path.
+fn normalize_numstat_path(p: &str) -> String {
+    let Some(arrow) = p.find(" => ") else {
+        return p.to_string();
+    };
+    if let (Some(lb), Some(rb)) = (p.find('{'), p.find('}')) {
+        if lb < arrow && arrow < rb {
+            return format!("{}{}{}", &p[..lb], &p[arrow + 4..rb], &p[rb + 1..]);
+        }
+    }
+    p[arrow + 4..].to_string()
+}
+
+/// Classify an untracked file's bytes into `(added_lines, binary)`, treating
+/// NUL-containing files as binary (0 lines). A final line without a trailing
+/// newline still counts. Shared by the local and remote readers below.
+fn count_lines_in_bytes(bytes: &[u8]) -> (i64, bool) {
+    if bytes.contains(&0) {
+        return (0, true);
+    }
+    let newlines = bytes.iter().filter(|&&b| b == b'\n').count() as i64;
+    let trailing = matches!(bytes.last(), Some(&b) if b != b'\n') as i64;
+    (newlines + trailing, false)
+}
+
+/// Line count of an untracked **local** file. An unreadable path degrades to
+/// `(0, false)` rather than failing the listing.
+fn count_added_lines(path: &Path) -> (i64, bool) {
+    match std::fs::read(path) {
+        Ok(bytes) => count_lines_in_bytes(&bytes),
+        Err(_) => (0, false),
+    }
+}
+
+/// Line count of an untracked **remote** file, read over the project's pooled
+/// SFTP session (mount-free remote). `rel` is the project-relative path from
+/// `git ls-files --others`; it is confined under `spec.remote_path` so a hostile
+/// path cannot escape the root. A confinement or read error degrades to
+/// `(0, false)`, mirroring the local reader.
+async fn count_added_lines_remote(
+    pool: &crate::services::remote::RemotePoolState,
+    target: &RemoteTarget,
+    rel: &str,
+) -> (i64, bool) {
+    let Ok(path) = crate::commands::fs::remote_join_confined(&target.spec.remote_path, rel) else {
+        return (0, false);
+    };
+    match crate::commands::fs::remote_read(pool, target, &path).await {
+        Ok(bytes) => count_lines_in_bytes(&bytes),
+        Err(_) => (0, false),
+    }
+}
+
 /// Returns one-line summaries of commits ahead of the upstream (not yet pushed).
 /// Returns an empty vec when there is no upstream or the repo is not git.
 #[tauri::command]
-pub fn git_unpushed_commits(project_dir: String) -> Result<Vec<String>, String> {
-    let dir = Path::new(&project_dir);
-    if !dir.join(".git").exists() {
+pub async fn git_unpushed_commits(project_dir: String) -> Result<Vec<String>, String> {
+    run_off_thread(move || git_unpushed_commits_blocking(project_dir)).await
+}
+
+fn git_unpushed_commits_blocking(project_dir: String) -> Result<Vec<String>, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
         return Ok(vec![]);
     }
-    let out = Command::new("git")
-        .args(["log", "@{u}..", "--oneline"])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+    let out = run_git(target.as_ref(), &project_dir, &["log", "@{u}..", "--oneline"])?;
     if !out.status.success() {
         return Ok(vec![]);
     }
@@ -283,13 +614,60 @@ pub fn git_unpushed_commits(project_dir: String) -> Result<Vec<String>, String>
     Ok(text.lines().filter(|l| !l.is_empty()).map(|l| l.to_string()).collect())
 }
 
+/// Ephemeral inline credential helper that answers an https challenge with the
+/// effective token. The token is read from the child's env INSIDE the snippet, so
+/// it never lands in argv or on disk. Always passed after a leading empty
+/// `credential.helper=`, which clears any system helper (e.g. GCM) so only ours
+/// runs. Harmless for SSH remotes — git won't call an http helper. Shared by
+/// `git_push` and `git_clone`.
+const TOKEN_CREDENTIAL_HELPER: &str =
+    "credential.helper=!f() { test \"$1\" = get && echo username=x-access-token && echo \"password=$ELDRUN_GIT_TOKEN\"; }; f";
+
 #[tauri::command]
-pub fn git_push(project_dir: String) -> Result<String, String> {
-    let out = Command::new("git")
-        .args(["push"])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_push(project_dir: String, project_id: Option<String>) -> Result<String, String> {
+    run_off_thread(move || git_push_blocking(project_dir, project_id)).await
+}
+
+/// `git push` in a local directory, authenticating an https remote with `token`
+/// when one is set (see `TOKEN_CREDENTIAL_HELPER`). Shared by the local-project
+/// push and the mirror-side push below, so both sides get identical auth.
+fn push_local(dir: &std::path::Path, token: Option<&str>) -> Result<std::process::Output, String> {
+    let mut cmd = crate::paths::command_no_window("git");
+    cmd.current_dir(dir);
+    if let Some(tok) = token {
+        cmd.args(["-c", "credential.helper=", "-c", TOKEN_CREDENTIAL_HELPER, "push"]);
+        cmd.env("ELDRUN_GIT_TOKEN", tok);
+        cmd.env("GIT_TERMINAL_PROMPT", "0");
+    } else {
+        cmd.args(["push"]);
+    }
+    cmd.output().map_err(|e| e.to_string())
+}
+
+fn git_push_blocking(project_dir: String, project_id: Option<String>) -> Result<String, String> {
+    let out = if let Some(target) = remote_target_for_dir(&project_dir) {
+        // A remote project published from THIS machine has its `origin` on the
+        // lockstep mirror, not on the host (see `commands::git_publish`) — so the
+        // push has to run there, where the remote exists and the effective token
+        // is the right machine's secret.
+        match crate::commands::git_publish::mirror_origin_repo(&target.project_id) {
+            Some(mirror) => {
+                let token = crate::commands::git_hosting::effective_git_creds(&target.project_id).1;
+                push_local(&mirror, token.as_deref())?
+            }
+            // No mirror-side origin: the repo was published (or wired by hand) on
+            // the host, so the push runs there and authenticates with the host's
+            // own git credentials/SSH keys. The local effective token does not
+            // apply (it would be the wrong machine's secret) and is not forwarded.
+            None => crate::services::ssh_exec::run_git_remote(&target.spec, &["push".to_string()])?,
+        }
+    } else {
+        // Local project: effective per-project → global token (if any).
+        let token = project_id
+            .as_deref()
+            .and_then(|id| crate::commands::git_hosting::effective_git_creds(id).1);
+        push_local(std::path::Path::new(&project_dir), token.as_deref())?
+    };
     let stderr = String::from_utf8_lossy(&out.stderr).to_string();
     let stdout = String::from_utf8_lossy(&out.stdout).to_string();
     if !out.status.success() {
@@ -298,6 +676,142 @@ pub fn git_push(project_dir: String) -> Result<String, String> {
     Ok(if stdout.is_empty() { stderr } else { stdout })
 }
 
+// ── Clone (import from GitHub/GitLab) ───────────────────────────────────────
+
+/// Accept only the clone URL forms we actually mean to support: https/http,
+/// `ssh://`, `git://`, and the scp-like `[user@]host:path`. This is a whitelist
+/// on purpose — git also understands `ext::<command>` (which *runs* the command)
+/// and local paths, and neither belongs behind a "paste a repo URL" field.
+pub(crate) fn validate_clone_url(url: &str) -> Result<(), String> {
+    let url = url.trim();
+    let reject = || {
+        Err(format!(
+            "'{url}' is not a supported repository URL (expected https://…, ssh://… or git@host:owner/repo.git)"
+        ))
+    };
+    if url.is_empty() {
+        return Err("Repository URL is empty".to_string());
+    }
+
+    let lower = url.to_ascii_lowercase();
+    if let Some(scheme_end) = lower.find("://") {
+        // An explicit scheme must be one we support. `file://` is not a remote,
+        // and anything else is a transport we did not mean to expose.
+        return if ["https", "http", "ssh", "git"].contains(&&lower[..scheme_end]) {
+            Ok(())
+        } else {
+            reject()
+        };
+    }
+
+    // scp-like: `[user@]host:path`. The host part carries no slash (that would be
+    // a local path) and no colon of its own — `transport::address` is git's
+    // transport-helper form, and `ext::<command>` *runs* the command.
+    let Some(colon) = url.find(':') else {
+        return reject();
+    };
+    let (host, path) = (&url[..colon], &url[colon + 1..]);
+    if host.is_empty()
+        || host.contains('/')
+        || host.starts_with('-')
+        || path.is_empty()
+        || path.starts_with(':')
+    {
+        return reject();
+    }
+    Ok(())
+}
+
+/// Turn git's own auth failure into the one sentence that tells the user what to
+/// do about it. A private https repo with no token stored reads as "could not
+/// read Username" / "Authentication failed", which explains nothing on its own.
+fn clone_error(stderr: &str, had_token: bool, https: bool) -> String {
+    let lower = stderr.to_ascii_lowercase();
+    let auth_failed = lower.contains("could not read username")
+        || lower.contains("authentication failed")
+        || lower.contains("terminal prompts disabled")
+        || lower.contains("repository not found");
+    if auth_failed && https {
+        let hint = if had_token {
+            "The stored access token was rejected (or has no access to this repository) — check it in Settings → Git Hosting."
+        } else {
+            "For a private repository, add an access token in Settings → Git Hosting, or use an SSH URL."
+        };
+        return format!("{}\n\n{hint}", stderr.trim());
+    }
+    if auth_failed {
+        return format!(
+            "{}\n\nSSH authentication failed — make sure your key is loaded (ssh-agent) and the host is known.",
+            stderr.trim()
+        );
+    }
+    stderr.trim().to_string()
+}
+
+/// Clone `url` into `dest` and return `dest`. Used by the import dialog's
+/// "Clone from GitHub/GitLab" source: the clone lands first, then the regular
+/// `import_project` registers the resulting directory in place ("keep" mode).
+///
+/// Auth: an https URL rides the global access token from Settings → Git Hosting
+/// (via the same inline credential helper as `git_push`) when one is stored; an
+/// SSH URL uses the user's own keys. Every interactive prompt git could raise is
+/// disabled (`GIT_TERMINAL_PROMPT=0`, ssh `BatchMode=yes`) — Eldrun has no console
+/// attached, so a prompt would be an invisible hang rather than a question.
+#[tauri::command]
+pub async fn git_clone(url: String, dest: String) -> Result<String, String> {
+    run_off_thread(move || git_clone_blocking(url, dest)).await
+}
+
+pub(crate) fn git_clone_blocking(url: String, dest: String) -> Result<String, String> {
+    let url = url.trim().to_string();
+    validate_clone_url(&url)?;
+
+    let dest_path = PathBuf::from(&dest);
+    if dest_path.exists() {
+        let empty = std::fs::read_dir(&dest_path)
+            .map(|mut entries| entries.next().is_none())
+            .unwrap_or(false);
+        if !empty {
+            return Err(format!("Destination '{dest}' already exists and is not empty"));
+        }
+    }
+    if let Some(parent) = dest_path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+
+    let token = crate::commands::git_hosting::global_git_token();
+    let https = {
+        let lower = url.to_ascii_lowercase();
+        lower.starts_with("https://") || lower.starts_with("http://")
+    };
+
+    let mut cmd = crate::paths::command_no_window("git");
+    cmd.env("GIT_TERMINAL_PROMPT", "0");
+    cmd.env("GIT_SSH_COMMAND", "ssh -o BatchMode=yes");
+    if https {
+        if let Some(tok) = token.as_deref() {
+            cmd.args(["-c", "credential.helper=", "-c", TOKEN_CREDENTIAL_HELPER]);
+            cmd.env("ELDRUN_GIT_TOKEN", tok);
+        }
+    }
+    // `--` so a URL can never be read as an option.
+    cmd.args(["clone", "--", &url, &dest]);
+
+    let out = cmd.output().map_err(|e| e.to_string())?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr).to_string();
+        let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+        let raw = if stderr.trim().is_empty() { stdout } else { stderr };
+        // A failed clone can still leave a partial directory behind; drop it so a
+        // retry isn't blocked by its own debris.
+        if dest_path.exists() {
+            let _ = std::fs::remove_dir_all(&dest_path);
+        }
+        return Err(clone_error(&raw, token.is_some(), https));
+    }
+    Ok(dest)
+}
+
 // ── Git history & branches ──────────────────────────────────────────────────
 
 #[derive(serde::Serialize)]
@@ -314,11 +828,8 @@ pub struct GitCommit {
     pub parents: Vec<String>,
 }
 
-fn git_head_hash(project_dir: &str) -> Option<String> {
-    Command::new("git")
-        .args(["rev-parse", "HEAD"])
-        .current_dir(project_dir)
-        .output()
+fn git_head_hash(target: Option<&RemoteTarget>, project_dir: &str) -> Option<String> {
+    run_git(target, project_dir, &["rev-parse", "HEAD"])
         .ok()
         .filter(|o| o.status.success())
         .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
@@ -327,25 +838,33 @@ fn git_head_hash(project_dir: &str) -> Option<String> {
 /// Returns the most recent commits (default 100) as one-line summaries.
 /// Returns an empty vec for a non-git directory or a repo with no commits yet.
 #[tauri::command]
-pub fn git_log(project_dir: String, limit: Option<u32>) -> Result<Vec<GitCommit>, String> {
-    let dir = Path::new(&project_dir);
-    if !dir.join(".git").exists() {
+pub async fn git_log(project_dir: String, limit: Option<u32>) -> Result<Vec<GitCommit>, String> {
+    run_off_thread(move || git_log_blocking(project_dir, limit)).await
+}
+
+fn git_log_blocking(project_dir: String, limit: Option<u32>) -> Result<Vec<GitCommit>, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
         return Ok(vec![]);
     }
     let max = limit.unwrap_or(100);
-    // Fields separated by US (0x1f) so subjects can contain anything but a newline.
-    let fmt = "--pretty=format:%H\u{1f}%h\u{1f}%s\u{1f}%an\u{1f}%ar\u{1f}%D\u{1f}%P";
-    let out = Command::new("git")
-        .args(["log", &format!("--max-count={max}"), fmt])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+    let max_count = format!("--max-count={max}");
+    let out = run_git(target.as_ref(), &project_dir, &["log", &max_count, GIT_LOG_FMT])?;
     if !out.status.success() {
         // Empty repository (no commits) — not an error for our purposes.
         return Ok(vec![]);
     }
-    let text = String::from_utf8_lossy(&out.stdout);
-    let head = git_head_hash(&project_dir);
+    let head = git_head_hash(target.as_ref(), &project_dir);
+    Ok(parse_git_log(&String::from_utf8_lossy(&out.stdout), head.as_deref()))
+}
+
+/// The `--pretty` format shared by `git_log` and `git_file_log`: fields separated
+/// by US (0x1f) so subjects can contain anything but a newline.
+const GIT_LOG_FMT: &str = "--pretty=format:%H\u{1f}%h\u{1f}%s\u{1f}%an\u{1f}%ar\u{1f}%D\u{1f}%P";
+
+/// Parse `git log` output emitted with `GIT_LOG_FMT` into `GitCommit`s. `head` is
+/// the current HEAD sha (used only to flag `is_head`).
+fn parse_git_log(text: &str, head: Option<&str>) -> Vec<GitCommit> {
     let mut commits = Vec::new();
     for line in text.lines() {
         let parts: Vec<&str> = line.split('\u{1f}').collect();
@@ -353,7 +872,7 @@ pub fn git_log(project_dir: String, limit: Option<u32>) -> Result<Vec<GitCommit>
             continue;
         }
         let hash = parts[0].to_string();
-        let is_head = head.as_deref() == Some(hash.as_str());
+        let is_head = head == Some(hash.as_str());
         let parents = parts[6]
             .split_whitespace()
             .map(|p| p.to_string())
@@ -369,7 +888,75 @@ pub fn git_log(project_dir: String, limit: Option<u32>) -> Result<Vec<GitCommit>
             parents,
         });
     }
-    Ok(commits)
+    commits
+}
+
+/// The commit history for a single file (`git log --follow -- <rel_path>`), most
+/// recent first. `--follow` keeps history across renames. Returns an empty vec for
+/// a non-git dir, an untracked path, or a repo with no commits. Local and remote
+/// (SSH) projects both work via the shared `run_git` dispatch.
+#[tauri::command]
+pub async fn git_file_log(
+    project_dir: String,
+    rel_path: String,
+    limit: Option<u32>,
+) -> Result<Vec<GitCommit>, String> {
+    run_off_thread(move || git_file_log_blocking(project_dir, rel_path, limit)).await
+}
+
+fn git_file_log_blocking(
+    project_dir: String,
+    rel_path: String,
+    limit: Option<u32>,
+) -> Result<Vec<GitCommit>, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
+        return Ok(vec![]);
+    }
+    let max = limit.unwrap_or(100);
+    let max_count = format!("--max-count={max}");
+    let out = run_git(
+        target.as_ref(),
+        &project_dir,
+        &["log", &max_count, "--follow", GIT_LOG_FMT, "--", &rel_path],
+    )?;
+    if !out.status.success() {
+        // Untracked path or empty repo — not an error for our purposes.
+        return Ok(vec![]);
+    }
+    let head = git_head_hash(target.as_ref(), &project_dir);
+    Ok(parse_git_log(&String::from_utf8_lossy(&out.stdout), head.as_deref()))
+}
+
+/// Returns a file's contents at a specific revision (`git show <rev>:<rel_path>`).
+/// Used by the in-app compare/merge view for the "old version" pane. Errors (bad
+/// rev, path absent at that rev) surface as `Err(stderr)`. Local and remote (SSH)
+/// projects both work via the shared `run_git` dispatch.
+#[tauri::command]
+pub async fn git_file_at_rev(
+    project_dir: String,
+    rel_path: String,
+    rev: String,
+) -> Result<String, String> {
+    run_off_thread(move || git_file_at_rev_blocking(project_dir, rel_path, rev)).await
+}
+
+fn git_file_at_rev_blocking(
+    project_dir: String,
+    rel_path: String,
+    rev: String,
+) -> Result<String, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
+        return Ok(String::new());
+    }
+    // `git show <rev>:<path>` wants a repo-relative, forward-slash path.
+    let spec = format!("{rev}:{}", rel_path.replace('\\', "/"));
+    let out = run_git(target.as_ref(), &project_dir, &["show", &spec])?;
+    if !out.status.success() {
+        return Err(String::from_utf8_lossy(&out.stderr).to_string());
+    }
+    Ok(String::from_utf8_lossy(&out.stdout).to_string())
 }
 
 #[derive(serde::Serialize)]
@@ -381,17 +968,17 @@ pub struct GitBranch {
 
 /// Lists local and remote-tracking branches.
 #[tauri::command]
-pub fn git_branches(project_dir: String) -> Result<Vec<GitBranch>, String> {
-    let dir = Path::new(&project_dir);
-    if !dir.join(".git").exists() {
+pub async fn git_branches(project_dir: String) -> Result<Vec<GitBranch>, String> {
+    run_off_thread(move || git_branches_blocking(project_dir)).await
+}
+
+fn git_branches_blocking(project_dir: String) -> Result<Vec<GitBranch>, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
         return Ok(vec![]);
     }
     let fmt = "--format=%(if)%(HEAD)%(then)*%(else) %(end)\u{1f}%(refname:short)\u{1f}%(refname)";
-    let out = Command::new("git")
-        .args(["branch", "-a", fmt])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+    let out = run_git(target.as_ref(), &project_dir, &["branch", "-a", fmt])?;
     let text = String::from_utf8_lossy(&out.stdout);
     let mut branches = Vec::new();
     for line in text.lines() {
@@ -416,12 +1003,13 @@ pub fn git_branches(project_dir: String) -> Result<Vec<GitBranch>, String> {
 /// Checks out a branch name or commit hash. Surfaces git's stderr on failure
 /// (e.g. when the working tree has conflicting uncommitted changes).
 #[tauri::command]
-pub fn git_checkout(project_dir: String, target: String) -> Result<String, String> {
-    let out = Command::new("git")
-        .args(["checkout", &target])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_checkout(project_dir: String, target: String) -> Result<String, String> {
+    run_off_thread(move || git_checkout_blocking(project_dir, target)).await
+}
+
+fn git_checkout_blocking(project_dir: String, target: String) -> Result<String, String> {
+    let rt = remote_target_for_dir(&project_dir);
+    let out = run_git(rt.as_ref(), &project_dir, &["checkout", &target])?;
     let stderr = String::from_utf8_lossy(&out.stderr).to_string();
     let stdout = String::from_utf8_lossy(&out.stdout).to_string();
     if !out.status.success() {
@@ -432,12 +1020,13 @@ pub fn git_checkout(project_dir: String, target: String) -> Result<String, Strin
 
 /// Returns the full commit message (subject + body) for a single commit.
 #[tauri::command]
-pub fn git_commit_message(project_dir: String, hash: String) -> Result<String, String> {
-    let out = Command::new("git")
-        .args(["log", "-1", "--pretty=format:%B", &hash])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+pub async fn git_commit_message(project_dir: String, hash: String) -> Result<String, String> {
+    run_off_thread(move || git_commit_message_blocking(project_dir, hash)).await
+}
+
+fn git_commit_message_blocking(project_dir: String, hash: String) -> Result<String, String> {
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["log", "-1", "--pretty=format:%B", &hash])?;
     if !out.status.success() {
         return Err(String::from_utf8_lossy(&out.stderr).to_string());
     }
@@ -447,17 +1036,924 @@ pub fn git_commit_message(project_dir: String, hash: String) -> Result<String, S
 /// Rewords the most recent commit (HEAD) via `git commit --amend`. Only valid
 /// for the latest commit; rewording older commits would require a rebase.
 #[tauri::command]
-pub fn git_reword_head(project_dir: String, message: String) -> Result<(), String> {
+pub async fn git_reword_head(project_dir: String, message: String) -> Result<(), String> {
+    run_off_thread(move || git_reword_head_blocking(project_dir, message)).await
+}
+
+fn git_reword_head_blocking(project_dir: String, message: String) -> Result<(), String> {
     if message.trim().is_empty() {
         return Err("Commit message cannot be empty".to_string());
     }
-    let out = Command::new("git")
-        .args(["commit", "--amend", "-m", &message])
-        .current_dir(&project_dir)
-        .output()
-        .map_err(|e| e.to_string())?;
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["commit", "--amend", "-m", &message])?;
     if !out.status.success() {
         return Err(String::from_utf8_lossy(&out.stderr).to_string());
     }
     Ok(())
 }
+
+/// Returns the unified diff for a single file relative to `project_dir`.
+///
+/// Runs `git diff -- <rel_path>` (working-tree changes against the index/HEAD).
+/// When that yields no output — typically because the file is untracked, so it
+/// has no tracked diff — it falls back to `git diff --no-index -- /dev/null
+/// <rel_path>`, which renders the whole file as added. `--no-index` exits
+/// non-zero whenever there are differences, so for the fallback we treat any
+/// non-empty stdout as success regardless of exit status.
+#[tauri::command]
+pub async fn git_diff_file(project_dir: String, rel_path: String) -> Result<String, String> {
+    run_off_thread(move || git_diff_file_blocking(project_dir, rel_path)).await
+}
+
+fn git_diff_file_blocking(project_dir: String, rel_path: String) -> Result<String, String> {
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["diff", "--", &rel_path])?;
+    if !out.status.success() {
+        return Err(String::from_utf8_lossy(&out.stderr).to_string());
+    }
+    let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+    if !stdout.is_empty() {
+        return Ok(stdout);
+    }
+
+    // Tracked diff is empty (e.g. untracked file). Show the whole file as added.
+    // `--no-index` exits non-zero when differences exist, which is the normal
+    // case here, so treat any non-empty stdout as success.
+    let fallback = run_git(target.as_ref(), &project_dir, &["diff", "--no-index", "--", "/dev/null", &rel_path])?;
+    let fb_stdout = String::from_utf8_lossy(&fallback.stdout).to_string();
+    if !fb_stdout.is_empty() {
+        return Ok(fb_stdout);
+    }
+    if !fallback.status.success() {
+        return Err(String::from_utf8_lossy(&fallback.stderr).to_string());
+    }
+    // No tracked changes and the fallback produced nothing — return empty diff.
+    Ok(stdout)
+}
+
+// ── Git blame ────────────────────────────────────────────────────────────────
+
+/// One source line's blame attribution. Mirrored field-for-field by the
+/// frontend `BlameLine` interface (snake_case, no serde renames).
+#[derive(serde::Serialize)]
+pub struct GitBlameLine {
+    /// 1-based final line number in the current file.
+    pub line_no: u32,
+    /// Full commit sha. All-zeros ⇒ the line is uncommitted (working tree).
+    pub hash: String,
+    /// First 8 chars of `hash`.
+    pub short: String,
+    pub author: String,
+    /// Author time as unix epoch seconds; the frontend renders the relative date.
+    pub author_time: i64,
+    /// Commit subject (first line of the message).
+    pub summary: String,
+}
+
+#[derive(Clone, Default)]
+struct BlameMeta {
+    author: String,
+    author_time: i64,
+    summary: String,
+}
+
+/// Parses `git blame --porcelain` output into one `GitBlameLine` per source
+/// line. In porcelain form each line begins with a header
+/// `<40-hex-sha> <orig-lineno> <final-lineno>[ <group-size>]`, followed — only
+/// the **first** time a given commit appears — by its metadata (`author`,
+/// `author-time`, `summary`, …), and always ends with a `\t`-prefixed content
+/// line. Later lines of an already-seen commit carry only the header + content,
+/// so commit metadata is cached by sha and reused.
+fn parse_blame_porcelain(text: &str) -> Vec<GitBlameLine> {
+    let mut cache: HashMap<String, BlameMeta> = HashMap::new();
+    let mut lines: Vec<GitBlameLine> = Vec::new();
+
+    let mut cur_hash: Option<String> = None;
+    let mut cur_line_no: u32 = 0;
+    let mut building = BlameMeta::default();
+
+    let is_header = |l: &str| -> Option<(String, u32)> {
+        let mut it = l.split(' ');
+        let sha = it.next()?;
+        if sha.len() != 40 || !sha.bytes().all(|b| b.is_ascii_hexdigit()) {
+            return None;
+        }
+        let _orig = it.next()?; // original line number (unused)
+        let final_no: u32 = it.next()?.parse().ok()?;
+        Some((sha.to_string(), final_no))
+    };
+
+    for line in text.lines() {
+        if let Some((sha, final_no)) = is_header(line) {
+            // Start a new line record; seed metadata from cache if this commit
+            // was already described earlier in the stream.
+            building = cache.get(&sha).cloned().unwrap_or_default();
+            cur_hash = Some(sha);
+            cur_line_no = final_no;
+        } else if let Some(rest) = line.strip_prefix("author-time ") {
+            building.author_time = rest.trim().parse().unwrap_or(0);
+        } else if let Some(rest) = line.strip_prefix("author ") {
+            building.author = rest.to_string();
+        } else if let Some(rest) = line.strip_prefix("summary ") {
+            building.summary = rest.to_string();
+        } else if line.starts_with('\t') {
+            // Content line — finalizes the current record.
+            if let Some(hash) = cur_hash.take() {
+                cache.entry(hash.clone()).or_insert_with(|| building.clone());
+                let short = hash.chars().take(8).collect();
+                lines.push(GitBlameLine {
+                    line_no: cur_line_no,
+                    short,
+                    author: building.author.clone(),
+                    author_time: building.author_time,
+                    summary: building.summary.clone(),
+                    hash,
+                });
+            }
+        }
+    }
+
+    lines
+}
+
+/// Per-line git blame for a file, ordered by line number. Returns an empty vec
+/// for a non-git dir or a path with no blame (e.g. never committed and no
+/// working-tree content). Local and remote (SSH) projects both work via the
+/// shared `run_git` dispatch.
+#[tauri::command]
+pub async fn git_blame(project_dir: String, rel_path: String) -> Result<Vec<GitBlameLine>, String> {
+    run_off_thread(move || git_blame_blocking(project_dir, rel_path)).await
+}
+
+fn git_blame_blocking(project_dir: String, rel_path: String) -> Result<Vec<GitBlameLine>, String> {
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
+        return Ok(vec![]);
+    }
+    // `--porcelain` emits commit metadata once per commit; `-w` ignores
+    // whitespace-only changes so reformatting doesn't reassign blame.
+    let out = run_git(
+        target.as_ref(),
+        &project_dir,
+        &["blame", "--porcelain", "-w", "--", &rel_path],
+    )?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+        // An unmodified/untracked-but-blamable file blames fine; genuinely
+        // un-blamable paths (never committed, no HEAD) just yield nothing.
+        if stderr.is_empty() {
+            return Ok(vec![]);
+        }
+        return Err(stderr);
+    }
+    Ok(parse_blame_porcelain(&String::from_utf8_lossy(&out.stdout)))
+}
+
+// ── Git worktrees (#23) ──────────────────────────────────────────────────────
+
+#[derive(serde::Serialize)]
+pub struct Worktree {
+    pub path: String,
+    /// Short branch name, or "" when detached/bare.
+    pub branch: String,
+    /// Full HEAD sha, or "" for a bare worktree.
+    pub head: String,
+    pub is_main: bool,
+    pub is_locked: bool,
+    pub is_bare: bool,
+}
+
+/// Parses `git worktree list --porcelain` output. Records are blank-line
+/// separated; each starts with `worktree <abs-path>` followed by optional
+/// attribute lines (`HEAD <sha>`, `branch refs/heads/<name>`, `bare`,
+/// `detached`, `locked [<reason>]`, `prunable [<reason>]`). git always lists
+/// the main worktree first, so the first record is flagged `is_main`.
+fn parse_worktree_porcelain(text: &str) -> Vec<Worktree> {
+    let mut out: Vec<Worktree> = Vec::new();
+    let mut cur: Option<Worktree> = None;
+    let mut first = true;
+
+    fn flush(cur: &mut Option<Worktree>, out: &mut Vec<Worktree>) {
+        if let Some(wt) = cur.take() {
+            if !wt.path.is_empty() {
+                out.push(wt);
+            }
+        }
+    }
+
+    for line in text.lines() {
+        if line.is_empty() {
+            flush(&mut cur, &mut out);
+            continue;
+        }
+        if let Some(path) = line.strip_prefix("worktree ") {
+            // Starting a new record; close any in progress.
+            flush(&mut cur, &mut out);
+            cur = Some(Worktree {
+                path: path.to_string(),
+                branch: String::new(),
+                head: String::new(),
+                is_main: first,
+                is_locked: false,
+                is_bare: false,
+            });
+            first = false;
+        } else if let Some(wt) = cur.as_mut() {
+            if let Some(sha) = line.strip_prefix("HEAD ") {
+                wt.head = sha.to_string();
+            } else if let Some(refname) = line.strip_prefix("branch ") {
+                wt.branch = refname
+                    .strip_prefix("refs/heads/")
+                    .unwrap_or(refname)
+                    .to_string();
+            } else if line == "bare" {
+                wt.is_bare = true;
+            } else if line == "detached" {
+                // branch stays empty
+            } else if line == "locked" || line.starts_with("locked ") {
+                wt.is_locked = true;
+            }
+            // ignore prunable / unknown lines
+        }
+    }
+    flush(&mut cur, &mut out);
+    out
+}
+
+/// Lists worktrees attached to the repository at `project_dir`.
+#[tauri::command]
+pub async fn git_worktree_list(project_dir: String) -> Result<Vec<Worktree>, String> {
+    run_off_thread(move || git_worktree_list_blocking(project_dir)).await
+}
+
+fn git_worktree_list_blocking(project_dir: String) -> Result<Vec<Worktree>, String> {
+    // `.git` exists as a dir for the main repo and as a file in linked worktrees.
+    let target = remote_target_for_dir(&project_dir);
+    if local_non_repo(target.as_ref(), &project_dir) {
+        return Ok(vec![]);
+    }
+    let out = run_git(target.as_ref(), &project_dir, &["worktree", "list", "--porcelain"])?;
+    if !out.status.success() {
+        // Lenient, like git_log (e.g. empty repo).
+        return Ok(vec![]);
+    }
+    Ok(parse_worktree_porcelain(&String::from_utf8_lossy(&out.stdout)))
+}
+
+/// Adds a worktree at `path`. When `new_branch` is true, creates a new branch
+/// `branch` at `path` (`git worktree add -b <branch> <path>`); otherwise checks
+/// out the existing `branch` (`git worktree add <path> <branch>`).
+#[tauri::command]
+pub async fn git_worktree_add(
+    project_dir: String,
+    path: String,
+    branch: String,
+    new_branch: bool,
+) -> Result<(), String> {
+    run_off_thread(move || git_worktree_add_blocking(project_dir, path, branch, new_branch)).await
+}
+
+fn git_worktree_add_blocking(
+    project_dir: String,
+    path: String,
+    branch: String,
+    new_branch: bool,
+) -> Result<(), String> {
+    if path.trim().is_empty() {
+        return Err("Worktree path cannot be empty".to_string());
+    }
+    if branch.trim().is_empty() {
+        return Err("Branch cannot be empty".to_string());
+    }
+    let mut args: Vec<&str> = vec!["worktree", "add"];
+    if new_branch {
+        args.push("-b");
+        args.push(&branch);
+        args.push(&path);
+    } else {
+        args.push(&path);
+        args.push(&branch);
+    }
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &args)?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr).to_string();
+        let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+        return Err(if stderr.is_empty() { stdout } else { stderr });
+    }
+    Ok(())
+}
+
+/// Removes the worktree at `path`. Pass `force` to remove a dirty worktree;
+/// git refuses to remove the main worktree or a dirty one without it, and that
+/// error is surfaced to the caller as-is.
+#[tauri::command]
+pub async fn git_worktree_remove(project_dir: String, path: String, force: bool) -> Result<(), String> {
+    run_off_thread(move || git_worktree_remove_blocking(project_dir, path, force)).await
+}
+
+fn git_worktree_remove_blocking(project_dir: String, path: String, force: bool) -> Result<(), String> {
+    let mut args: Vec<&str> = vec!["worktree", "remove"];
+    if force {
+        args.push("--force");
+    }
+    args.push(&path);
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &args)?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr).to_string();
+        let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+        return Err(if stderr.is_empty() { stdout } else { stderr });
+    }
+    Ok(())
+}
+
+/// Prunes administrative entries for worktrees whose directories were removed
+/// out-of-band (`git worktree prune`).
+#[tauri::command]
+pub async fn git_worktree_prune(project_dir: String) -> Result<(), String> {
+    run_off_thread(move || git_worktree_prune_blocking(project_dir)).await
+}
+
+fn git_worktree_prune_blocking(project_dir: String) -> Result<(), String> {
+    let target = remote_target_for_dir(&project_dir);
+    let out = run_git(target.as_ref(), &project_dir, &["worktree", "prune"])?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr).to_string();
+        let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+        return Err(if stderr.is_empty() { stdout } else { stderr });
+    }
+    Ok(())
+}
+
+/// Map an `origin` remote URL to a hosting provider by its **host only**.
+/// Handles both SSH (`git@github.com:owner/repo.git`) and HTTPS
+/// (`https://github.com/owner/repo.git`) forms. Read-only string work — no
+/// network. Returns `None` for unrecognized/self-hosted vanity hosts so we
+/// never render a wrong badge.
+fn provider_from_origin_url(url: &str) -> Option<&'static str> {
+    let lower = url.to_ascii_lowercase();
+    if lower.contains("gitlab") {
+        Some("gitlab")
+    } else if lower.contains("github") {
+        Some("github")
+    } else {
+        None
+    }
+}
+
+/// A recognized `origin` for a local project: the hosting provider plus the raw
+/// remote URL, so the frontend can both badge the provider and display the git
+/// address in the project hover.
+#[derive(serde::Serialize)]
+pub struct DetectedOrigin {
+    pub provider: String,
+    pub url: String,
+}
+
+/// Sniff the `origin` host for each **local** git project and map it to a
+/// hosting provider (`"github"`/`"gitlab"`) plus its raw URL. Read-only: runs
+/// `git remote get-url origin`, makes no network calls and writes nothing.
+/// Returns `{ project_id -> { provider, url } }` only for projects whose origin
+/// resolves to a recognized provider. Published (`remote-*`) local projects are
+/// included too, so their git address shows in the hover even though their badge
+/// already rides on `git_type`. Used to decorate pill/right-panel hovers for
+/// repos pushed to a host — including ones published outside Eldrun's own
+/// Publish flow (the sole writer of the `remote-*` `git_type`).
+#[tauri::command]
+pub fn detect_git_providers() -> Result<HashMap<String, DetectedOrigin>, String> {
+    use serde_json::Value;
+
+    let path = crate::storage::state_dir().join("projects.json");
+    if !path.exists() {
+        return Ok(HashMap::new());
+    }
+    let list: crate::schema::projects::ProjectsList =
+        crate::storage::read_json(&path).map_err(|e| e.to_string())?;
+
+    let mut out = HashMap::new();
+    for entry in &list {
+        // Local projects only: a remote project's `origin` lives on the host,
+        // and sniffing it would be a network call.
+        if entry.extra.contains_key("remote") {
+            continue;
+        }
+        // Skip repo-less projects; `local` and `remote-*` are both eligible.
+        if let Some(Value::String(gt)) = entry.extra.get("git_type") {
+            if gt == "none" {
+                continue;
+            }
+        }
+        // The project's working directory. Legacy entries (created before
+        // `directory` was persisted — e.g. the self-hosting ProjectEldrun
+        // entry) omit the key; fall back to `local_file`'s parent, which is
+        // always `<directory>/project.json`, so they still get sniffed/badged.
+        let dir: String = match entry.extra.get("directory") {
+            Some(Value::String(d)) => d.clone(),
+            _ => match Path::new(&entry.local_file).parent() {
+                Some(p) => p.to_string_lossy().into_owned(),
+                None => continue,
+            },
+        };
+        if !Path::new(&dir).join(".git").exists() {
+            continue;
+        }
+        let output = crate::paths::command_no_window("git")
+            .args(["-C", &dir, "remote", "get-url", "origin"])
+            .output();
+        let Ok(output) = output else { continue };
+        if !output.status.success() {
+            continue;
+        }
+        let url = String::from_utf8_lossy(&output.stdout);
+        let url = url.trim();
+        if let Some(provider) = provider_from_origin_url(url) {
+            out.insert(
+                entry.id.clone(),
+                DetectedOrigin {
+                    provider: provider.to_string(),
+                    url: url.to_string(),
+                },
+            );
+        }
+    }
+    Ok(out)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    /// Tests skip gracefully when `git` isn't on PATH.
+    fn git_available() -> bool {
+        super::git_available()
+    }
+
+    fn init_repo(dir: &std::path::Path) {
+        let run = |args: &[&str]| {
+            let ok = crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git command should run")
+                .status
+                .success();
+            assert!(ok, "git {args:?} failed");
+        };
+        run(&["init"]);
+        run(&["config", "user.email", "test@example.com"]);
+        run(&["config", "user.name", "Test User"]);
+    }
+
+    #[test]
+    fn git_diff_file_shows_modified_hunk() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping git_diff_file_shows_modified_hunk");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        init_repo(dir);
+
+        let file = dir.join("note.txt");
+        fs::write(&file, "first line\nsecond line\n").expect("write");
+        let add_ok = crate::paths::command_no_window("git")
+            .args(["add", "note.txt"])
+            .current_dir(dir)
+            .output()
+            .expect("add runs")
+            .status
+            .success();
+        assert!(add_ok, "git add failed");
+        let real_commit = crate::paths::command_no_window("git")
+            .args(["commit", "-m", "init"])
+            .current_dir(dir)
+            .output()
+            .expect("commit runs")
+            .status
+            .success();
+        assert!(real_commit, "git commit failed");
+
+        // Modify the file so a tracked diff exists.
+        fs::write(&file, "first line\nCHANGED line\n").expect("rewrite");
+
+        let diff = git_diff_file_blocking(
+            dir.to_string_lossy().to_string(),
+            "note.txt".to_string(),
+        )
+        .expect("git_diff_file should succeed");
+        assert!(diff.contains("@@"), "expected a hunk marker, got: {diff}");
+        assert!(diff.contains("CHANGED line"), "expected changed line, got: {diff}");
+    }
+
+    #[test]
+    fn git_diff_file_untracked_uses_no_index_fallback() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping git_diff_file_untracked_uses_no_index_fallback");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        init_repo(dir);
+
+        // Brand-new untracked file: the tracked `git diff` is empty, so the
+        // command must fall back to `--no-index` and show it as added.
+        let file = dir.join("fresh.txt");
+        fs::write(&file, "brand new content\nanother line\n").expect("write");
+
+        let diff = git_diff_file_blocking(
+            dir.to_string_lossy().to_string(),
+            "fresh.txt".to_string(),
+        )
+        .expect("git_diff_file should succeed via fallback");
+        assert!(!diff.is_empty(), "fallback diff should be non-empty");
+        assert!(
+            diff.contains("brand new content"),
+            "expected file content in fallback diff, got: {diff}"
+        );
+    }
+
+    #[test]
+    fn parse_blame_porcelain_maps_lines_and_caches_metadata() {
+        // Two commits: `aaa…` owns lines 1 & 3 (its metadata appears once, on
+        // line 1, and is reused for line 3), `bbb…` owns line 2, and line 4 is
+        // uncommitted (all-zeros sha, "Not Committed Yet").
+        let sample = "\
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1 1 1
+author Alice
+author-mail <alice@example.com>
+author-time 1000000000
+author-tz +0000
+summary first commit
+filename note.txt
+\tline one
+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb 2 2 1
+author Bob
+author-mail <bob@example.com>
+author-time 1600000000
+author-tz +0000
+summary second commit
+filename note.txt
+\tline two
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 3 3 1
+filename note.txt
+\tline three
+0000000000000000000000000000000000000000 4 4 1
+author Not Committed Yet
+author-mail <not.committed.yet>
+author-time 1700000000
+author-tz +0000
+summary Version of note.txt from note.txt
+filename note.txt
+\tline four
+";
+        let blame = parse_blame_porcelain(sample);
+        assert_eq!(blame.len(), 4, "one entry per source line");
+
+        assert_eq!(blame[0].line_no, 1);
+        assert_eq!(blame[0].short, "aaaaaaaa");
+        assert_eq!(blame[0].author, "Alice");
+        assert_eq!(blame[0].author_time, 1_000_000_000);
+        assert_eq!(blame[0].summary, "first commit");
+
+        assert_eq!(blame[1].line_no, 2);
+        assert_eq!(blame[1].author, "Bob");
+        assert_eq!(blame[1].author_time, 1_600_000_000);
+
+        // Line 3 reuses `aaa…`'s cached metadata even though it wasn't repeated.
+        assert_eq!(blame[2].line_no, 3);
+        assert_eq!(blame[2].hash, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+        assert_eq!(blame[2].author, "Alice");
+        assert_eq!(blame[2].summary, "first commit");
+
+        // Line 4 is uncommitted.
+        assert_eq!(blame[3].line_no, 4);
+        assert_eq!(blame[3].hash, "0000000000000000000000000000000000000000");
+        assert_eq!(blame[3].author, "Not Committed Yet");
+    }
+
+    #[test]
+    fn git_blame_blocking_attributes_lines() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping git_blame_blocking_attributes_lines");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        init_repo(dir);
+
+        let file = dir.join("note.txt");
+        fs::write(&file, "first line\nsecond line\n").expect("write");
+        for args in [&["add", "note.txt"][..], &["commit", "-m", "init"][..]] {
+            let ok = crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git runs")
+                .status
+                .success();
+            assert!(ok, "git {args:?} failed");
+        }
+
+        let blame = git_blame_blocking(
+            dir.to_string_lossy().to_string(),
+            "note.txt".to_string(),
+        )
+        .expect("git_blame should succeed");
+        assert_eq!(blame.len(), 2, "two committed lines");
+        assert_eq!(blame[0].line_no, 1);
+        assert_eq!(blame[0].author, "Test User");
+        assert_ne!(blame[0].hash, "0000000000000000000000000000000000000000");
+    }
+
+    #[test]
+    fn git_blame_blocking_empty_for_non_repo() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        // No `git init` → local_non_repo short-circuits to an empty vec.
+        let blame = git_blame_blocking(
+            dir.to_string_lossy().to_string(),
+            "whatever.txt".to_string(),
+        )
+        .expect("non-repo blame is empty, not an error");
+        assert!(blame.is_empty());
+    }
+
+    #[test]
+    fn ignored_child_does_not_mark_whole_folder_ignored() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping ignored_child_does_not_mark_whole_folder_ignored");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        init_repo(dir);
+
+        // `partial/` has one ignored file and one tracked file → the folder
+        // itself is NOT ignored. `whole/` is ignored in its entirety.
+        fs::write(dir.join(".gitignore"), "partial/ignored.log\nwhole/\n").expect("write .gitignore");
+        fs::create_dir(dir.join("partial")).expect("mkdir partial");
+        fs::write(dir.join("partial/ignored.log"), "log\n").expect("write log");
+        fs::write(dir.join("partial/keep.txt"), "keep\n").expect("write keep");
+        fs::create_dir(dir.join("whole")).expect("mkdir whole");
+        fs::write(dir.join("whole/a.txt"), "a\n").expect("write a");
+
+        let statuses = git_file_statuses_blocking(
+            dir.to_string_lossy().to_string(),
+            String::new(),
+        )
+        .expect("git_file_statuses should succeed");
+
+        // A folder with only some ignored content stays out of the ignored bucket.
+        assert_ne!(
+            statuses.get("partial").map(String::as_str),
+            Some("ignored"),
+            "partial/ must not be marked ignored (got {:?})",
+            statuses.get("partial")
+        );
+        // A wholly-ignored folder is still reported as ignored.
+        assert_eq!(
+            statuses.get("whole").map(String::as_str),
+            Some("ignored"),
+            "whole/ should be ignored (got {:?})",
+            statuses.get("whole")
+        );
+
+        // Navigating INTO the wholly-ignored folder must still report its own
+        // children as ignored, not silently come back empty (the bug this
+        // test guards: plain `--ignored` collapses `whole/` to one line and
+        // never descends into it).
+        let inner = git_file_statuses_blocking(dir.to_string_lossy().to_string(), "whole".to_string())
+            .expect("git_file_statuses on whole/ should succeed");
+        assert_eq!(
+            inner.get("a.txt").map(String::as_str),
+            Some("ignored"),
+            "whole/a.txt should be reported as ignored when listing whole/ (got {:?})",
+            inner.get("a.txt")
+        );
+    }
+
+    #[test]
+    fn ignored_entries_are_reported_when_git_config_hides_untracked_files() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping ignored_entries_are_reported_when_git_config_hides_untracked_files");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        init_repo(dir);
+
+        fs::write(dir.join(".gitignore"), "cache/\n").expect("write .gitignore");
+        fs::create_dir(dir.join("cache")).expect("mkdir cache");
+        fs::write(dir.join("cache/data.bin"), "ignored\n").expect("write ignored file");
+        let configured = crate::paths::command_no_window("git")
+            .args(["config", "status.showUntrackedFiles", "no"])
+            .current_dir(dir)
+            .output()
+            .expect("git config should run")
+            .status
+            .success();
+        assert!(configured, "git config failed");
+
+        let statuses = git_file_statuses_blocking(
+            dir.to_string_lossy().to_string(),
+            String::new(),
+        )
+        .expect("git_file_statuses should override the user's untracked-files setting");
+
+        assert_eq!(statuses.get("cache").map(String::as_str), Some("ignored"));
+    }
+
+    #[test]
+    fn parses_main_and_linked_with_branches() {
+        let text = "worktree /home/u/proj\nHEAD abc123def456\nbranch refs/heads/main\n\nworktree /home/u/proj-feature\nHEAD 999888777666\nbranch refs/heads/feature\n";
+        let wts = parse_worktree_porcelain(text);
+        assert_eq!(wts.len(), 2);
+        assert_eq!(wts[0].path, "/home/u/proj");
+        assert_eq!(wts[0].branch, "main");
+        assert_eq!(wts[0].head, "abc123def456");
+        assert!(wts[0].is_main);
+        assert!(!wts[0].is_bare);
+        assert!(!wts[0].is_locked);
+        assert_eq!(wts[1].path, "/home/u/proj-feature");
+        assert_eq!(wts[1].branch, "feature");
+        assert!(!wts[1].is_main);
+    }
+
+    #[test]
+    fn parses_detached_head() {
+        let text = "worktree /home/u/proj\nHEAD abc123\nbranch refs/heads/main\n\nworktree /home/u/detached\nHEAD deadbeef\ndetached\n";
+        let wts = parse_worktree_porcelain(text);
+        assert_eq!(wts.len(), 2);
+        assert_eq!(wts[1].branch, "");
+        assert_eq!(wts[1].head, "deadbeef");
+        assert!(!wts[1].is_main);
+    }
+
+    #[test]
+    fn parses_bare_main() {
+        let text = "worktree /home/u/bare.git\nbare\n\nworktree /home/u/linked\nHEAD abc123\nbranch refs/heads/work\n";
+        let wts = parse_worktree_porcelain(text);
+        assert_eq!(wts.len(), 2);
+        assert!(wts[0].is_bare);
+        assert!(wts[0].is_main);
+        assert_eq!(wts[0].branch, "");
+        assert_eq!(wts[0].head, "");
+        assert_eq!(wts[1].branch, "work");
+    }
+
+    #[test]
+    fn parses_locked_with_reason() {
+        let text = "worktree /home/u/proj\nHEAD abc\nbranch refs/heads/main\n\nworktree /home/u/locked\nHEAD def\nbranch refs/heads/wip\nlocked on a removable drive\n";
+        let wts = parse_worktree_porcelain(text);
+        assert_eq!(wts.len(), 2);
+        assert!(wts[1].is_locked);
+        assert_eq!(wts[1].branch, "wip");
+    }
+
+    #[test]
+    fn skips_empty_path_records() {
+        // Leading/trailing blank lines must not produce phantom worktrees.
+        let text = "\n\nworktree /home/u/proj\nHEAD abc\nbranch refs/heads/main\n\n\n";
+        let wts = parse_worktree_porcelain(text);
+        assert_eq!(wts.len(), 1);
+        assert_eq!(wts[0].path, "/home/u/proj");
+        assert!(wts[0].is_main);
+    }
+
+    #[test]
+    fn add_list_remove_roundtrip() {
+        if !git_available() {
+            eprintln!("skipping: git binary not available");
+            return;
+        }
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path().join("repo");
+        std::fs::create_dir(&root).unwrap();
+        let root_str = root.to_string_lossy().to_string();
+
+        let run = |args: &[&str]| {
+            crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(&root)
+                .output()
+                .expect("git run")
+        };
+        assert!(run(&["init"]).status.success());
+        run(&["config", "user.email", "test@example.com"]);
+        run(&["config", "user.name", "Test"]);
+        // Ensure a known starting branch name regardless of git defaults.
+        run(&["checkout", "-b", "main"]);
+        std::fs::write(root.join("file.txt"), "hello").unwrap();
+        run(&["add", "-A"]);
+        assert!(run(&["commit", "-m", "init"]).status.success());
+
+        // Initially a single (main) worktree.
+        let listed = git_worktree_list_blocking(root_str.clone()).unwrap();
+        assert_eq!(listed.len(), 1);
+        assert!(listed[0].is_main);
+
+        // Add a new worktree on a new branch.
+        let wt_path = tmp.path().join("wt-feature").to_string_lossy().to_string();
+        git_worktree_add_blocking(root_str.clone(), wt_path.clone(), "feature".to_string(), true).unwrap();
+
+        let listed = git_worktree_list_blocking(root_str.clone()).unwrap();
+        assert_eq!(listed.len(), 2);
+        assert_eq!(listed.iter().filter(|w| w.is_main).count(), 1);
+        assert!(listed.iter().any(|w| w.branch == "feature"));
+
+        // Remove it and confirm we are back to one.
+        git_worktree_remove_blocking(root_str.clone(), wt_path, true).unwrap();
+        let listed = git_worktree_list_blocking(root_str).unwrap();
+        assert_eq!(listed.len(), 1);
+    }
+
+    #[test]
+    fn provider_from_origin_url_recognizes_hosts() {
+        // SSH form.
+        assert_eq!(
+            provider_from_origin_url("git@github.com:owner/repo.git"),
+            Some("github")
+        );
+        assert_eq!(
+            provider_from_origin_url("git@gitlab.com:owner/repo.git"),
+            Some("gitlab")
+        );
+        // HTTPS form.
+        assert_eq!(
+            provider_from_origin_url("https://github.com/owner/repo.git"),
+            Some("github")
+        );
+        assert_eq!(
+            provider_from_origin_url("https://gitlab.example.com/owner/repo.git"),
+            Some("gitlab")
+        );
+        // Enterprise/vanity host containing the provider name still matches.
+        assert_eq!(
+            provider_from_origin_url("git@github.corp.internal:owner/repo.git"),
+            Some("github")
+        );
+        // Unrecognized / self-hosted vanity host → no badge.
+        assert_eq!(
+            provider_from_origin_url("git@git.mycorp.com:owner/repo.git"),
+            None
+        );
+    }
+
+    // ── validate_clone_url ─────────────────────────────────────────────────
+
+    #[test]
+    fn validate_clone_url_accepts_supported_forms() {
+        for url in &[
+            "https://github.com/owner/repo.git",
+            "https://gitlab.com/group/sub/repo",
+            "http://git.internal/owner/repo.git",
+            "ssh://git@github.com:22/owner/repo.git",
+            "git://git.internal/repo.git",
+            "git@github.com:owner/repo.git",
+            "gitlab.com:group/repo.git",
+        ] {
+            assert!(validate_clone_url(url).is_ok(), "should accept: {url}");
+        }
+        // Surrounding whitespace (a pasted URL) is tolerated.
+        assert!(validate_clone_url("  https://github.com/o/r.git  ").is_ok());
+    }
+
+    #[test]
+    fn validate_clone_url_rejects_unsupported_forms() {
+        for url in &[
+            "",
+            "   ",
+            // `ext::` runs a command — never behind a URL field.
+            "ext::sh -c 'touch /tmp/pwned'",
+            "file:///etc",
+            "/etc/passwd",
+            "../repo",
+            "just-a-name",
+            // Option injection, with and without the scp-like colon.
+            "--upload-pack=touch /tmp/pwned",
+            "--upload-pack=x:y",
+        ] {
+            assert!(validate_clone_url(url).is_err(), "should reject: {url}");
+        }
+    }
+
+    #[test]
+    fn clone_error_explains_missing_token_for_https() {
+        let msg = clone_error("fatal: could not read Username for 'https://github.com'", false, true);
+        assert!(msg.contains("Settings → Git Hosting"), "{msg}");
+
+        // A token IS stored but was rejected → point at the token, not at adding one.
+        let msg = clone_error("remote: Repository not found.", true, true);
+        assert!(msg.contains("was rejected"), "{msg}");
+
+        // SSH auth failure gets the key/agent hint instead.
+        let msg = clone_error("git@github.com: Permission denied (publickey).\nfatal: Authentication failed", false, false);
+        assert!(msg.contains("ssh-agent"), "{msg}");
+
+        // A non-auth failure is passed through unchanged (no misleading hint).
+        let msg = clone_error("fatal: destination path exists", false, true);
+        assert_eq!(msg, "fatal: destination path exists");
+    }
+}
diff --git a/src-tauri/src/commands/git_fork.rs b/src-tauri/src/commands/git_fork.rs
new file mode 100644
index 0000000..12fbdab
--- /dev/null
+++ b/src-tauri/src/commands/git_fork.rs
@@ -0,0 +1,493 @@
+//! Forking a hosted repository into the user's own account, then cloning the
+//! fork — the import dialog's "Fork a GitHub/GitLab repository" source.
+//!
+//! This is deliberately *not* a clone with a different name. A clone of someone
+//! else's repository has an `origin` nobody can push to; a fork gives the user a
+//! repository of their own to push to, with the original kept as `upstream` so
+//! the history can still be followed (and a pull request opened). So the flow is
+//! three steps, in this order:
+//!
+//!   1. **fork** — `gh api -X POST repos/<owner>/<repo>/forks` / `glab api -X
+//!      POST projects/<path>/fork`. The provider CLIs are used the way
+//!      `git_publish` uses them (same `Provider`, same token env, same "the CLI
+//!      owns the auth" bargain) — but through their raw `api` subcommand rather
+//!      than `repo fork`, because the response JSON *names the fork*: neither
+//!      CLI's `repo fork --clone` can be pointed at a destination directory, and
+//!      guessing the fork's URL from the user's login is wrong the moment a fork
+//!      lands in a different namespace or under a different name.
+//!   2. **clone** — the fork's URL through `git::git_clone_blocking`, so a fork
+//!      import inherits the ordinary clone's URL whitelist, token credential
+//!      helper, prompt-disabling and partial-directory cleanup unchanged.
+//!   3. **upstream** — `git remote add upstream <original url>`, best-effort:
+//!      the tree is already on disk by then, and failing the whole import over a
+//!      second remote would leave a cloned directory with no project behind it.
+//!
+//! Forking is asynchronous on both services (GitHub answers 202 before the fork
+//! exists; GitLab reports an `import_status`), which is why the clone is retried
+//! on the "no such repository yet" class of failure instead of once.
+
+use std::time::Duration;
+
+use serde_json::Value;
+
+use crate::commands::git::validate_clone_url;
+use crate::commands::git_publish::Provider;
+
+/// How many times the clone of a freshly created fork is attempted, and how long
+/// to wait between attempts. A fork is created asynchronously, so the first
+/// clone can legitimately hit a repository that does not exist yet; only that
+/// class of failure is retried (an auth failure fails on the first attempt).
+const CLONE_ATTEMPTS: usize = 5;
+const CLONE_RETRY_DELAY: Duration = Duration::from_secs(3);
+
+/// A hosted repository, as read out of a clone/browser URL.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct RepoRef {
+    /// Host only — no userinfo, no port.
+    pub host: String,
+    /// Namespace + repository, `.git` stripped: `owner/repo`, or a nested
+    /// GitLab group path like `group/sub/repo`.
+    pub path: String,
+    /// The URL asked for SSH transport (`git@host:…`, `ssh://…`), so the fork is
+    /// cloned over SSH too rather than silently switching the user to https.
+    pub ssh: bool,
+}
+
+impl RepoRef {
+    /// The repository's own name (last path segment).
+    fn name(&self) -> &str {
+        self.path.rsplit('/').next().unwrap_or(&self.path)
+    }
+}
+
+/// Read `host` + `owner/repo` out of any clone URL form we accept. The URL has
+/// already passed `validate_clone_url`; this only has to understand it.
+pub(crate) fn parse_repo_url(raw: &str) -> Result<RepoRef, String> {
+    let url = raw.trim();
+    let reject = || format!("Could not read an owner/repository out of '{url}'");
+
+    let (authority, path, ssh) = if let Some(scheme_end) = url.find("://") {
+        let scheme = url[..scheme_end].to_ascii_lowercase();
+        let rest = &url[scheme_end + 3..];
+        let slash = rest.find('/').ok_or_else(reject)?;
+        (
+            &rest[..slash],
+            &rest[slash + 1..],
+            scheme == "ssh" || scheme == "git",
+        )
+    } else {
+        // scp-like `[user@]host:path`.
+        let colon = url.find(':').ok_or_else(reject)?;
+        (&url[..colon], &url[colon + 1..], true)
+    };
+
+    // Strip userinfo and port off the authority; strip a leading slash, a
+    // trailing slash and a trailing `.git` off the path.
+    let host = authority.rsplit('@').next().unwrap_or(authority);
+    let host = host.split(':').next().unwrap_or(host).to_ascii_lowercase();
+    let path = path.trim_matches('/');
+    let path = path.strip_suffix(".git").unwrap_or(path);
+
+    if host.is_empty() || path.is_empty() || !path.contains('/') {
+        return Err(reject());
+    }
+    Ok(RepoRef {
+        host,
+        path: path.to_string(),
+        ssh,
+    })
+}
+
+/// Which provider a host is, when the hostname says so. A self-hosted instance
+/// usually doesn't, which is why the dialog also offers an explicit choice.
+pub(crate) fn provider_from_host(host: &str) -> Option<Provider> {
+    let host = host.to_ascii_lowercase();
+    if host == "github.com" || host.contains("github") {
+        Some(Provider::GitHub)
+    } else if host == "gitlab.com" || host.contains("gitlab") {
+        Some(Provider::GitLab)
+    } else {
+        None
+    }
+}
+
+/// Percent-encode a GitLab project path for use as the `:id` path segment
+/// (`group/sub/repo` → `group%2Fsub%2Frepo`). Only the separator needs encoding;
+/// everything else a GitLab path may contain (`a-z0-9_.-`) is already safe.
+fn encode_project_id(path: &str) -> String {
+    path.replace('/', "%2F")
+}
+
+/// Whether the provider's CLI (`gh` / `glab`) is on `PATH`. The import dialog
+/// asks before offering the fork source, so a missing CLI surfaces as an install
+/// prompt rather than as a failed fork after the user filled the form in. Also
+/// used by the publish flow (`commands::git_publish`) for the same reason —
+/// publishing to a fresh GitHub/GitLab repo shells out to this same CLI.
+#[tauri::command]
+pub fn provider_cli_available(provider: String) -> Result<bool, String> {
+    let provider = Provider::parse(&provider)?;
+    Ok(crate::paths::command_no_window(provider.cli())
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false))
+}
+
+/// What a completed fork import reports back: where the tree landed, and the
+/// fork it was cloned from (so the caller can name it).
+#[derive(serde::Serialize)]
+pub struct ForkResult {
+    /// The directory the fork was cloned into (= `dest`).
+    pub dir: String,
+    /// The fork's full path on the host, e.g. `me/repo`.
+    pub fork: String,
+    /// The URL the fork was cloned from.
+    pub url: String,
+}
+
+/// Fork `url` into the user's own account, clone the fork into `dest`, and wire
+/// the original repository as the `upstream` remote.
+///
+/// `provider` is "github"/"gitlab", or empty to infer it from the URL's host
+/// (which only works for a host that names itself — a self-hosted instance must
+/// be told). Auth is the provider CLI's own (`gh auth login` / `glab auth
+/// login`), with the global access token from Settings → Git Hosting passed
+/// through its env var when one is stored.
+#[tauri::command]
+pub async fn git_fork_clone(
+    url: String,
+    dest: String,
+    provider: Option<String>,
+) -> Result<ForkResult, String> {
+    crate::commands::git::run_off_thread(move || fork_clone_blocking(url, dest, provider)).await
+}
+
+fn fork_clone_blocking(
+    url: String,
+    dest: String,
+    provider: Option<String>,
+) -> Result<ForkResult, String> {
+    let url = url.trim().to_string();
+    validate_clone_url(&url)?;
+    let repo = parse_repo_url(&url)?;
+
+    let requested = provider.unwrap_or_default();
+    let provider = if requested.trim().is_empty() {
+        provider_from_host(&repo.host).ok_or_else(|| {
+            format!(
+                "Could not tell whether '{}' is GitHub or GitLab — choose the host type.",
+                repo.host
+            )
+        })?
+    } else {
+        Provider::parse(&requested)?
+    };
+
+    let fork = create_fork(provider, &repo)?;
+
+    // Prefer the transport the user asked for: an ssh URL in, an ssh URL out.
+    let clone_url = if repo.ssh && !fork.ssh_url.is_empty() {
+        fork.ssh_url.clone()
+    } else if !fork.http_url.is_empty() {
+        fork.http_url.clone()
+    } else {
+        fork.ssh_url.clone()
+    };
+    if clone_url.is_empty() {
+        return Err(format!(
+            "{} created the fork but reported no clone URL for it",
+            provider.cli()
+        ));
+    }
+
+    clone_with_retry(&clone_url, &dest)?;
+
+    // Best-effort: the tree is on disk already, so a missing `upstream` is worth
+    // less than the import it would otherwise abort.
+    let _ = crate::paths::command_no_window("git")
+        .current_dir(&dest)
+        .args(["remote", "add", "upstream", &url])
+        .output();
+
+    Ok(ForkResult {
+        dir: dest,
+        fork: fork.full_path,
+        url: clone_url,
+    })
+}
+
+/// The fork, as the provider reported it.
+struct Fork {
+    full_path: String,
+    http_url: String,
+    ssh_url: String,
+}
+
+fn create_fork(provider: Provider, repo: &RepoRef) -> Result<Fork, String> {
+    match provider {
+        Provider::GitHub => {
+            // GitHub answers an already-existing fork with the existing one, so
+            // there is no conflict case to handle here.
+            let json = provider_api(
+                provider,
+                repo,
+                &["-X", "POST", &format!("repos/{}/forks", repo.path)],
+            )?;
+            Ok(github_fork(&json))
+        }
+        Provider::GitLab => {
+            let id = encode_project_id(&repo.path);
+            match provider_api(provider, repo, &["-X", "POST", &format!("projects/{id}/fork")]) {
+                Ok(json) => Ok(gitlab_fork(&json)),
+                // GitLab refuses a second fork into the same namespace ("has
+                // already been taken"). That is the *success* state for an
+                // import — the user's fork exists — so look it up instead of
+                // reporting a name clash they cannot act on.
+                Err(e) if is_already_forked(&e) => existing_gitlab_fork(repo).map_err(|_| e),
+                Err(e) => Err(e),
+            }
+        }
+    }
+}
+
+fn github_fork(json: &Value) -> Fork {
+    Fork {
+        full_path: string_field(json, "full_name"),
+        http_url: string_field(json, "clone_url"),
+        ssh_url: string_field(json, "ssh_url"),
+    }
+}
+
+fn gitlab_fork(json: &Value) -> Fork {
+    Fork {
+        full_path: string_field(json, "path_with_namespace"),
+        http_url: string_field(json, "http_url_to_repo"),
+        ssh_url: string_field(json, "ssh_url_to_repo"),
+    }
+}
+
+/// GitLab's "you already forked this" refusal, in the wordings it comes in.
+fn is_already_forked(err: &str) -> bool {
+    let lower = err.to_ascii_lowercase();
+    lower.contains("already been taken")
+        || lower.contains("already exists")
+        || lower.contains("name has already")
+}
+
+/// Resolve the fork the user already has: their own namespace + the repository's
+/// name, which is where `POST /fork` would have put it.
+fn existing_gitlab_fork(repo: &RepoRef) -> Result<Fork, String> {
+    let user = provider_api(Provider::GitLab, repo, &["user"])?;
+    let login = string_field(&user, "username");
+    if login.is_empty() {
+        return Err("glab did not report the logged-in user".to_string());
+    }
+    let id = encode_project_id(&format!("{login}/{}", repo.name()));
+    let json = provider_api(Provider::GitLab, repo, &[&format!("projects/{id}")])?;
+    Ok(gitlab_fork(&json))
+}
+
+/// Run the provider CLI's `api` subcommand and parse its JSON response.
+///
+/// The CLI authenticates itself; the stored global token is passed through its
+/// env var (never argv) when set, and a non-default host is pointed at through
+/// the CLI's own host env var so a self-hosted instance works.
+fn provider_api(provider: Provider, repo: &RepoRef, args: &[&str]) -> Result<Value, String> {
+    let mut cmd = crate::paths::command_no_window(provider.cli());
+    cmd.arg("api").args(args);
+    if let Some(tok) = crate::commands::git_hosting::global_git_token() {
+        cmd.env(provider.token_env(), tok);
+    }
+    if !provider.is_default_host(&repo.host) {
+        cmd.env(provider.host_env(), &repo.host);
+    }
+
+    let out = cmd
+        .output()
+        .map_err(|e| format!("failed to run {}: {e}", provider.cli()))?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+        let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
+        let raw = if stderr.is_empty() { stdout } else { stderr };
+        return Err(api_error(provider, &raw));
+    }
+    let stdout = String::from_utf8_lossy(&out.stdout).to_string();
+    serde_json::from_str(&stdout)
+        .map_err(|e| format!("could not read {}'s response: {e}", provider.cli()))
+}
+
+/// Turn the CLI's own failure into the sentence that says what to do about it.
+/// "not logged in" is by far the most common one, and the CLI's own wording for
+/// it doesn't mention the fork the user was trying to make.
+fn api_error(provider: Provider, raw: &str) -> String {
+    let lower = raw.to_ascii_lowercase();
+    let cli = provider.cli();
+    if lower.contains("not logged") || lower.contains("authentication") || lower.contains("401") {
+        return format!(
+            "{}\n\nForking uses the {cli} CLI's own login — run `{cli} auth login` (or store an access token in Settings → Git Hosting).",
+            raw.trim()
+        );
+    }
+    if lower.contains("404") || lower.contains("not found") {
+        return format!(
+            "{}\n\nThe repository was not found — check the URL, and that your {cli} login can see it if it is private.",
+            raw.trim()
+        );
+    }
+    raw.trim().to_string()
+}
+
+/// Clone the fork, retrying only the "it isn't there yet" failure: a fork is
+/// created asynchronously, so the repository can legitimately 404 for a few
+/// seconds after the API call returned. Any other failure (auth, disk) is final
+/// on the first attempt — retrying it would only make the dialog hang.
+fn clone_with_retry(clone_url: &str, dest: &str) -> Result<(), String> {
+    let mut last = String::new();
+    for attempt in 0..CLONE_ATTEMPTS {
+        match crate::commands::git::git_clone_blocking(clone_url.to_string(), dest.to_string()) {
+            Ok(_) => return Ok(()),
+            Err(e) => {
+                if !fork_not_ready(&e) {
+                    return Err(e);
+                }
+                last = e;
+                if attempt + 1 < CLONE_ATTEMPTS {
+                    std::thread::sleep(CLONE_RETRY_DELAY);
+                }
+            }
+        }
+    }
+    Err(format!(
+        "{last}\n\nThe fork was created but is not clonable yet — try importing it again in a moment."
+    ))
+}
+
+/// Whether a clone failure reads as "the fork has not materialized yet".
+fn fork_not_ready(err: &str) -> bool {
+    let lower = err.to_ascii_lowercase();
+    lower.contains("repository not found")
+        || lower.contains("not found")
+        || lower.contains("does not appear to be a git repository")
+        || lower.contains("could not read from remote repository")
+}
+
+fn string_field(json: &Value, key: &str) -> String {
+    json.get(key)
+        .and_then(Value::as_str)
+        .unwrap_or_default()
+        .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_https_urls() {
+        let r = parse_repo_url("https://github.com/owner/repo.git").unwrap();
+        assert_eq!(r.host, "github.com");
+        assert_eq!(r.path, "owner/repo");
+        assert!(!r.ssh);
+        assert_eq!(r.name(), "repo");
+    }
+
+    #[test]
+    fn parses_browser_url_with_trailing_slash_and_nested_groups() {
+        let r = parse_repo_url("https://gitlab.com/group/sub/repo/").unwrap();
+        assert_eq!(r.host, "gitlab.com");
+        assert_eq!(r.path, "group/sub/repo");
+        assert_eq!(r.name(), "repo");
+    }
+
+    #[test]
+    fn parses_scp_like_and_ssh_urls_as_ssh() {
+        let scp = parse_repo_url("git@github.com:owner/repo.git").unwrap();
+        assert_eq!(scp.host, "github.com");
+        assert_eq!(scp.path, "owner/repo");
+        assert!(scp.ssh);
+
+        let ssh = parse_repo_url("ssh://git@gitlab.example.org:2222/owner/repo.git").unwrap();
+        assert_eq!(ssh.host, "gitlab.example.org");
+        assert_eq!(ssh.path, "owner/repo");
+        assert!(ssh.ssh);
+    }
+
+    #[test]
+    fn rejects_urls_with_no_owner() {
+        // A fork needs a namespace + repository; a bare repo path is not one.
+        assert!(parse_repo_url("https://github.com/repo.git").is_err());
+        assert!(parse_repo_url("git@host:repo.git").is_err());
+    }
+
+    #[test]
+    fn detects_provider_from_host_only_when_it_says_so() {
+        assert!(matches!(
+            provider_from_host("github.com"),
+            Some(Provider::GitHub)
+        ));
+        assert!(matches!(
+            provider_from_host("gitlab.example.org"),
+            Some(Provider::GitLab)
+        ));
+        // A self-hosted instance that doesn't name itself must be told.
+        assert!(provider_from_host("git.internal").is_none());
+    }
+
+    #[test]
+    fn encodes_nested_gitlab_paths() {
+        assert_eq!(encode_project_id("group/sub/repo"), "group%2Fsub%2Frepo");
+        assert_eq!(encode_project_id("owner/repo"), "owner%2Frepo");
+    }
+
+    #[test]
+    fn reads_provider_fork_payloads() {
+        let gh = serde_json::json!({
+            "full_name": "me/repo",
+            "clone_url": "https://github.com/me/repo.git",
+            "ssh_url": "git@github.com:me/repo.git",
+        });
+        let f = github_fork(&gh);
+        assert_eq!(f.full_path, "me/repo");
+        assert_eq!(f.http_url, "https://github.com/me/repo.git");
+        assert_eq!(f.ssh_url, "git@github.com:me/repo.git");
+
+        let gl = serde_json::json!({
+            "path_with_namespace": "me/repo",
+            "http_url_to_repo": "https://gitlab.com/me/repo.git",
+            "ssh_url_to_repo": "git@gitlab.com:me/repo.git",
+        });
+        let f = gitlab_fork(&gl);
+        assert_eq!(f.full_path, "me/repo");
+        assert_eq!(f.http_url, "https://gitlab.com/me/repo.git");
+    }
+
+    #[test]
+    fn already_forked_is_recognized_not_reported() {
+        assert!(is_already_forked("Path has already been taken"));
+        assert!(is_already_forked("name has already been taken"));
+        assert!(!is_already_forked("404 Project Not Found"));
+    }
+
+    #[test]
+    fn only_the_not_yet_there_clone_failure_is_retried() {
+        assert!(fork_not_ready("remote: Repository not found."));
+        assert!(fork_not_ready(
+            "fatal: 'x' does not appear to be a git repository"
+        ));
+        // An auth failure must fail on the first attempt, not after 5 waits.
+        assert!(!fork_not_ready("fatal: Authentication failed for 'https://…'"));
+        assert!(!fork_not_ready(
+            "Destination '/tmp/x' already exists and is not empty"
+        ));
+    }
+
+    #[test]
+    fn api_error_names_the_cli_login() {
+        let msg = api_error(Provider::GitHub, "gh: not logged into any GitHub hosts");
+        assert!(msg.contains("gh auth login"));
+        let msg = api_error(Provider::GitLab, "404 Project Not Found");
+        assert!(msg.contains("not found"));
+        // An unrecognized failure is passed through as-is.
+        assert_eq!(api_error(Provider::GitHub, "disk full"), "disk full");
+    }
+}
diff --git a/src-tauri/src/commands/git_hosting.rs b/src-tauri/src/commands/git_hosting.rs
new file mode 100644
index 0000000..d1389b9
--- /dev/null
+++ b/src-tauri/src/commands/git_hosting.rs
@@ -0,0 +1,178 @@
+//! Per-project git-hosting overrides (profile URL + access token) that take
+//! precedence over the global `settings.json` values when set.
+//!
+//! The non-secret profile URL is persisted in the project's `project.json`
+//! (mirrored into `projects.json` so the pill can read it without loading the
+//! per-project file). The secret token lives only in the OS keyring
+//! (`services::git_credentials`), keyed by project id — never on disk in our JSON
+//! state. `git_push` / `publish_project` resolve the *effective* credentials via
+//! [`effective_git_creds`]: the per-project value if present, else the global one.
+
+use std::path::PathBuf;
+
+use serde_json::Value;
+
+use crate::schema::project::Project;
+use crate::schema::projects::ProjectsList;
+use crate::schema::settings::Settings;
+use crate::services::git_credentials;
+use crate::storage;
+
+/// What the frontend gets back about a project's git hosting. The token itself is
+/// never returned — only whether one is stored — so the secret stays out of the
+/// renderer.
+#[derive(serde::Serialize)]
+pub struct GitHostingInfo {
+    /// Per-project profile URL override, if any.
+    pub profile_url: Option<String>,
+    /// Whether a per-project token is stored in the keyring.
+    pub has_token: bool,
+    /// The global fallback profile URL (from settings.json), shown as the
+    /// placeholder/inherited value in the editor.
+    pub global_profile_url: Option<String>,
+    /// Whether a global token exists to fall back on.
+    pub has_global_token: bool,
+}
+
+/// Read effective hosting config for the project-settings editor.
+#[tauri::command]
+pub fn get_project_git_hosting(project_id: String) -> Result<GitHostingInfo, String> {
+    let project = project_for(&project_id)?;
+    let settings = read_settings();
+    Ok(GitHostingInfo {
+        profile_url: project.git_profile_url.filter(|s| !s.is_empty()),
+        has_token: git_credentials::has_token(&project_id),
+        global_profile_url: settings
+            .as_ref()
+            .and_then(|s| s.git_profile_url.clone())
+            .filter(|s| !s.is_empty()),
+        has_global_token: settings
+            .as_ref()
+            .and_then(|s| s.git_token.clone())
+            .map(|t| !t.is_empty())
+            .unwrap_or(false),
+    })
+}
+
+/// Write the per-project hosting override. `profile_url` is stored in
+/// project.json + projects.json (cleared when blank). The token is stored in the
+/// keyring when `token` is `Some`; when `clear_token` is true the stored token is
+/// removed. A `token` of `None` with `clear_token` false leaves the token as-is
+/// (so saving just the URL doesn't wipe an existing secret).
+#[tauri::command]
+pub fn set_project_git_hosting(
+    project_id: String,
+    profile_url: Option<String>,
+    token: Option<String>,
+    clear_token: bool,
+) -> Result<GitHostingInfo, String> {
+    let cleaned_url = profile_url
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty());
+
+    // project.json — authoritative per-project store for the URL.
+    let (idx, mut list) = find_entry(&project_id)?;
+    let local_file = list[idx].local_file.clone();
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.git_profile_url = cleaned_url.clone();
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+
+    // projects.json — mirror into the pill list entry's flattened `extra` so the
+    // frontend sees it without reading project.json (kept consistent with how
+    // `git_type`/`description` are mirrored).
+    match &cleaned_url {
+        Some(url) => {
+            list[idx]
+                .extra
+                .insert("git_profile_url".to_string(), Value::String(url.clone()));
+        }
+        None => {
+            list[idx].extra.remove("git_profile_url");
+        }
+    }
+    storage::write_json(&storage::state_dir().join("projects.json"), &list)
+        .map_err(|e| e.to_string())?;
+
+    // Token → keyring. Only touch it when explicitly provided/cleared.
+    if clear_token {
+        git_credentials::set_token(&project_id, None)?;
+    } else if token.is_some() {
+        git_credentials::set_token(&project_id, token.as_deref())?;
+    }
+
+    get_project_git_hosting(project_id)
+}
+
+/// The credentials to actually use for a project's push/publish: the per-project
+/// override if present, otherwise the global `settings.json` value. Returns
+/// `(profile_url, token)`. Used by `git::git_push` and `git_publish::publish_project`.
+pub fn effective_git_creds(project_id: &str) -> (Option<String>, Option<String>) {
+    let settings = read_settings();
+    let project = project_for(project_id).ok();
+
+    let profile_url = project
+        .as_ref()
+        .and_then(|p| p.git_profile_url.clone())
+        .filter(|s| !s.is_empty())
+        .or_else(|| {
+            settings
+                .as_ref()
+                .and_then(|s| s.git_profile_url.clone())
+                .filter(|s| !s.is_empty())
+        });
+
+    // Per-project token (keyring) wins; else the global token from settings.json.
+    let token = git_credentials::get_token(project_id).or_else(|| {
+        settings
+            .as_ref()
+            .and_then(|s| s.git_token.clone())
+            .filter(|s| !s.is_empty())
+    });
+
+    (profile_url, token)
+}
+
+/// The global access token from Settings → Git Hosting, if one is stored. For
+/// work that has no project to key a per-project override off yet — `git_clone`
+/// runs *before* the project exists — so only the global connection applies.
+pub fn global_git_token() -> Option<String> {
+    read_settings()
+        .and_then(|s| s.git_token)
+        .filter(|t| !t.trim().is_empty())
+}
+
+fn read_settings() -> Option<Settings> {
+    let path = storage::state_dir().join("settings.json");
+    if path.exists() {
+        storage::read_json::<Settings>(&path).ok()
+    } else {
+        None
+    }
+}
+
+/// Read a project's `project.json` by id (via its `local_file` in projects.json).
+fn project_for(project_id: &str) -> Result<Project, String> {
+    let (idx, list) = find_entry(project_id)?;
+    let local_file = list[idx].local_file.clone();
+    storage::read_json::<Project>(&PathBuf::from(&local_file)).map_err(|e| e.to_string())
+}
+
+/// Find a project entry by id, returning its index and the owned list so the
+/// caller can mutate + persist it. (Mirrors the helper in `commands::git_publish`.)
+fn find_entry(project_id: &str) -> Result<(usize, ProjectsList), String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let idx = list
+        .iter()
+        .position(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    Ok((idx, list))
+}
diff --git a/src-tauri/src/commands/git_peer.rs b/src-tauri/src/commands/git_peer.rs
new file mode 100644
index 0000000..b4d6e6d
--- /dev/null
+++ b/src-tauri/src/commands/git_peer.rs
@@ -0,0 +1,225 @@
+//! Tauri commands for git-aware local↔remote lockstep sync (TODO #28n, Phase 1).
+//!
+//! Thin wrappers over `services::git_peer`: toggle the per-project opt-in, read the
+//! observed status, run a manual reconcile (Retry), and perform a coordinated
+//! checkout. The heavy lifting (probe, bundle transport, fast-forward apply, checkout
+//! lockstep, base re-stamping) lives in the service so it stays `AppHandle`-free and
+//! unit-testable.
+
+use tauri::{AppHandle, State};
+
+use crate::services::git_peer::{
+    self, BackupRef, GitPeerRegistry, GitPeerState, ReconcileOpts,
+};
+use crate::services::remote::{remote_target_for, RemotePoolState};
+use crate::services::remote_sync::SyncManifestState;
+use crate::services::sync_auto::AutoSyncState;
+
+/// Read a project's persisted lockstep state (disabled/synchronized default).
+#[tauri::command]
+pub async fn git_peer_status(project_id: String) -> Result<GitPeerState, String> {
+    Ok(git_peer::load_state(&project_id))
+}
+
+/// Toggle the per-project opt-in. Enabling persists the flag, launches the detection
+/// task (`.git` watcher + host poll), and reconciles once; disabling stops the task.
+/// Returns the resulting state.
+#[tauri::command]
+pub async fn git_peer_set_enabled(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    reg: State<'_, GitPeerRegistry>,
+    worker_sync: State<'_, crate::services::worker_sync::WorkerSyncState>,
+    project_id: String,
+    enabled: bool,
+) -> Result<GitPeerState, String> {
+    if remote_target_for(&project_id).is_none() {
+        return Err("Git lockstep is only available for SSH remote projects".to_string());
+    }
+    let mut state = git_peer::load_state(&project_id);
+    state.enabled = enabled;
+    git_peer::save_state(&project_id, &state)?;
+
+    if enabled {
+        // start() reads the freshly-persisted `enabled`, attaches the watcher, and
+        // runs an initial detect+emit in its loop.
+        git_peer::start(
+            app,
+            pool.inner().clone(),
+            manifest.inner().clone(),
+            auto.inner().clone(),
+            reg.inner(),
+            worker_sync.inner().clone(),
+            &project_id,
+        )
+        .await;
+    } else {
+        git_peer::stop(reg.inner(), &project_id).await;
+    }
+    Ok(git_peer::load_state(&project_id))
+}
+
+/// Manually reconcile now (the Retry / "Sync git" action). Runs a detection pass and
+/// emits the new status.
+#[tauri::command]
+pub async fn git_peer_sync_now(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    project_id: String,
+) -> Result<GitPeerState, String> {
+    let target = remote_target_for(&project_id)
+        .ok_or("Git lockstep is only available for SSH remote projects")?;
+    let state = git_peer::detect_and_sync(
+        pool.inner(),
+        manifest.inner(),
+        auto.inner(),
+        &project_id,
+        &target.spec,
+        // A manual Retry means "actually look": bypass the D5 ref-signature early-out,
+        // which would otherwise answer from cache after the user cleared a blocker that
+        // moved no ref (deleting an untracked collision, say).
+        ReconcileOpts { forced: true, ..Default::default() },
+    )
+    .await;
+    git_peer::emit_status(&app, &project_id, &state);
+    Ok(state)
+}
+
+/// Confirm an initial pairing that would overwrite differing files on the empty side
+/// (#28p D3). Only reachable from the state's `pairingConflict`, whose paths the UI has
+/// already named — this is the explicit consent that the refusal demands, and the only
+/// caller that may set `allow_pair_overwrite`.
+#[tauri::command]
+pub async fn git_peer_pair_confirm(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    project_id: String,
+) -> Result<GitPeerState, String> {
+    let rt = remote_target_for(&project_id)
+        .ok_or("Git lockstep is only available for SSH remote projects")?;
+    let state = git_peer::detect_and_sync(
+        pool.inner(),
+        manifest.inner(),
+        auto.inner(),
+        &project_id,
+        &rt.spec,
+        ReconcileOpts { forced: true, allow_pair_overwrite: true, ..Default::default() },
+    )
+    .await;
+    git_peer::emit_status(&app, &project_id, &state);
+    Ok(state)
+}
+
+/// List both peers' `refs/eldrun/backup/*` safety refs, newest first (#28p D6).
+#[tauri::command]
+pub async fn git_peer_backups(project_id: String) -> Result<Vec<BackupRef>, String> {
+    let rt = remote_target_for(&project_id)
+        .ok_or("Git lockstep is only available for SSH remote projects")?;
+    Ok(git_peer::list_backups(&project_id, &rt.spec))
+}
+
+/// Move a branch back onto a backup ref, on the peer that holds it (#28p D6). The
+/// branch's current tip is backed up first, so a restore is itself undoable.
+#[tauri::command]
+pub async fn git_peer_restore_backup(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    project_id: String,
+    peer: String,
+    refname: String,
+) -> Result<GitPeerState, String> {
+    let rt = remote_target_for(&project_id)
+        .ok_or("Git lockstep is only available for SSH remote projects")?;
+    let state = git_peer::restore_backup(
+        pool.inner(),
+        manifest.inner(),
+        auto.inner(),
+        &project_id,
+        &rt.spec,
+        &peer,
+        &refname,
+    )
+    .await?;
+    git_peer::emit_status(&app, &project_id, &state);
+    Ok(state)
+}
+
+/// The local mirror's absolute path — where "Resolve in terminal" (#28p D8) opens its
+/// shell, since that is the working copy the user merges/rebases in.
+#[tauri::command]
+pub async fn git_peer_mirror_dir(project_id: String) -> Result<String, String> {
+    if remote_target_for(&project_id).is_none() {
+        return Err("Git lockstep is only available for SSH remote projects".to_string());
+    }
+    Ok(crate::services::remote_sync::mirror_dir(&project_id)
+        .to_string_lossy()
+        .to_string())
+}
+
+/// Coordinated checkout: check `target` out on the initiating side, bring the peer in
+/// step, and check the same target out there (guarded — never `-f`). `initiating_side`
+/// is `"local"` or `"remote"` (default `"local"`; the frontend passes `initiatingSide`).
+#[tauri::command]
+pub async fn git_peer_checkout(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    project_id: String,
+    target: String,
+    initiating_side: Option<String>,
+) -> Result<GitPeerState, String> {
+    let rt = remote_target_for(&project_id)
+        .ok_or("Git lockstep is only available for SSH remote projects")?;
+    let side = initiating_side.unwrap_or_else(|| "local".to_string());
+    let state = git_peer::checkout_lockstep(
+        pool.inner(),
+        manifest.inner(),
+        auto.inner(),
+        &project_id,
+        &rt.spec,
+        &target,
+        &side,
+        false,
+    )
+    .await?;
+    git_peer::emit_status(&app, &project_id, &state);
+    Ok(state)
+}
+
+/// Resolve a divergence by choosing an authority: `authority` is `"local"` or
+/// `"remote"`. The winner's history is force-applied to the loser (its overwritten
+/// tips backed up to `refs/eldrun/backup/*` first), file-sync bases are re-stamped,
+/// and the recomputed status is emitted. The Use-local / Use-remote action (#28n
+/// Phase 2), only offered when the state is `Desynchronized`.
+#[tauri::command]
+pub async fn git_peer_resolve(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    project_id: String,
+    authority: String,
+) -> Result<GitPeerState, String> {
+    let rt = remote_target_for(&project_id)
+        .ok_or("Git lockstep is only available for SSH remote projects")?;
+    let state = git_peer::resolve(
+        pool.inner(),
+        manifest.inner(),
+        auto.inner(),
+        &project_id,
+        &rt.spec,
+        &authority,
+    )
+    .await?;
+    git_peer::emit_status(&app, &project_id, &state);
+    Ok(state)
+}
diff --git a/src-tauri/src/commands/git_publish.rs b/src-tauri/src/commands/git_publish.rs
new file mode 100644
index 0000000..2e615f2
--- /dev/null
+++ b/src-tauri/src/commands/git_publish.rs
@@ -0,0 +1,1087 @@
+//! Publishing a project's git repository to a hosting provider (GitHub or
+//! GitLab), via the provider's official CLI (`gh` / `glab`).
+//!
+//! Publishing creates a remote repo from the project's git working tree and
+//! pushes to it. The project's push target (`git_type`) is then updated to
+//! `remote-<visibility>` and its `git_provider` recorded.
+//!
+//! Provider parity:
+//! - GitHub uses `gh repo create … --source=. --remote=origin --push`, which
+//!   creates the repo, wires `origin`, and pushes the existing history in one go.
+//! - GitLab's `glab repo create` has no `--source/--push`: it creates the
+//!   project and adds the `origin` remote, so we follow it with an explicit
+//!   `git push -u origin HEAD` to upload the existing commits.
+//!
+//! A project's bytes may live locally or on an SSH work-remote host. **Where the
+//! bytes are is not where the hosting account is**: `gh auth login`, and the
+//! tokens in Settings → Git Hosting, are secrets of *this* machine, and a work
+//! remote is typically a cluster login node with no provider CLI, no GitHub
+//! credentials, and often no outbound https at all. A remote project also
+//! already has a full local repo — the lockstep mirror
+//! ([`remote_sync::mirror_dir`]) — holding the same history.
+//!
+//! So a remote project publishes **from its local mirror by default**
+//! ([`PublishSite::Local`]), and the ssh path is retained as an explicit choice
+//! (`publish_from = "remote"`) for a host that really does have its own
+//! `gh`/`glab` login. Publishing from the mirror is refused unless lockstep is
+//! on and reports the two sides in step — otherwise the mirror's history is not
+//! the host's, and publishing would ship the wrong commits
+//! ([`ensure_mirror_in_step`]).
+//!
+//! Every *follow-up* operation (visibility, unpublish, and `git_push` over in
+//! `commands::git`) then routes to wherever `origin` actually got wired
+//! ([`origin_site`]), so the create and the pushes never end up on opposite
+//! sides.
+//!
+//! The ssh invocation mirrors `commands::ssh`: `BatchMode`, validated argv, no
+//! shell string built from untrusted input — the remote path/name are
+//! single-quoted for the remote shell. It relies on the work-remote host's own
+//! `gh`/`glab` auth (we don't forward the token over ssh).
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use serde_json::Value;
+
+use crate::commands::projects::{normalize_git_type, sanitize_name};
+use crate::schema::project::Project;
+use crate::schema::projects::ProjectsList;
+use crate::services::git_peer::SyncStatus;
+use crate::services::ssh_common::{ssh_base_args, validate_arg};
+use crate::storage;
+
+/// A supported git-hosting provider. Also used by `commands::git_fork`, which
+/// drives the same two CLIs — one definition of "which CLI, which token env,
+/// which host" rather than a second copy that can drift.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Provider {
+    GitHub,
+    GitLab,
+}
+
+impl Provider {
+    /// Parse the frontend's provider string. Defaults to GitHub when omitted so
+    /// older callers (and the historical single-provider behavior) keep working.
+    pub(crate) fn parse(s: &str) -> Result<Self, String> {
+        match s.trim().to_ascii_lowercase().as_str() {
+            "" | "github" => Ok(Provider::GitHub),
+            "gitlab" => Ok(Provider::GitLab),
+            other => Err(format!("provider must be 'github' or 'gitlab', got '{other}'")),
+        }
+    }
+
+    /// The canonical string persisted in `git_provider`.
+    fn as_str(self) -> &'static str {
+        match self {
+            Provider::GitHub => "github",
+            Provider::GitLab => "gitlab",
+        }
+    }
+
+    /// The env var that lets the CLI authenticate non-interactively from a token
+    /// (used for local publishing; the absent case falls back to the CLI's own
+    /// `… auth login`).
+    pub(crate) fn token_env(self) -> &'static str {
+        match self {
+            Provider::GitHub => "GH_TOKEN",
+            Provider::GitLab => "GITLAB_TOKEN",
+        }
+    }
+
+    /// The env var that points the CLI at a *self-hosted* instance (both CLIs
+    /// default to their public service otherwise).
+    pub(crate) fn host_env(self) -> &'static str {
+        match self {
+            Provider::GitHub => "GH_HOST",
+            Provider::GitLab => "GITLAB_HOST",
+        }
+    }
+
+    /// Whether `host` is the provider's public service, i.e. the host the CLI
+    /// already assumes and must not be re-pointed at.
+    pub(crate) fn is_default_host(self, host: &str) -> bool {
+        let host = host.trim().to_ascii_lowercase();
+        match self {
+            Provider::GitHub => host == "github.com" || host == "www.github.com",
+            Provider::GitLab => host == "gitlab.com" || host == "www.gitlab.com",
+        }
+    }
+
+    /// The username an https credential helper presents alongside a PAT. Both
+    /// providers ignore the username for PAT auth, but we use each one's
+    /// convention.
+    fn cred_username(self) -> &'static str {
+        match self {
+            Provider::GitHub => "x-access-token",
+            Provider::GitLab => "oauth2",
+        }
+    }
+
+    /// The provider's official CLI binary.
+    pub(crate) fn cli(self) -> &'static str {
+        match self {
+            Provider::GitHub => "gh",
+            Provider::GitLab => "glab",
+        }
+    }
+
+    /// Display name for error text ("GitHub"/"GitLab"), distinct from
+    /// `as_str()`'s lowercase persisted form.
+    fn display_name(self) -> &'static str {
+        match self {
+            Provider::GitHub => "GitHub",
+            Provider::GitLab => "GitLab",
+        }
+    }
+
+    /// The `repo edit` argv that flips the current repo's visibility in place
+    /// (no re-create). GitHub requires an explicit consent flag for the change.
+    fn visibility_edit_args(self, visibility: &str) -> Vec<String> {
+        match self {
+            Provider::GitHub => vec![
+                "repo".into(),
+                "edit".into(),
+                "--visibility".into(),
+                visibility.into(),
+                "--accept-visibility-change-consequences".into(),
+            ],
+            Provider::GitLab => vec![
+                "repo".into(),
+                "edit".into(),
+                "--visibility".into(),
+                visibility.into(),
+            ],
+        }
+    }
+}
+
+/// Where a hosting operation runs. A *local* project has only one answer; a
+/// work-remote project has two, because its history exists on both sides (the
+/// lockstep mirror and the host), which is precisely why the choice has to be
+/// named rather than inferred from "where the bytes are".
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum PublishSite {
+    /// Run the CLI in a local directory: a local project's tree, or a remote
+    /// project's lockstep mirror. Uses *this* machine's `gh`/`glab` login and the
+    /// effective per-project → global token.
+    Local(PathBuf),
+    /// Run the CLI over ssh on the work-remote host, using that host's own login.
+    Host,
+}
+
+/// Parse the dialog's "Publish from" choice. Defaults to the local mirror: the
+/// hosting account is this machine's, so that is the side that can actually
+/// authenticate. `"remote"` opts into the host's own `gh`/`glab` login.
+fn parse_publish_from(s: Option<&str>) -> Result<PublishSite, String> {
+    match s.unwrap_or("local").trim().to_ascii_lowercase().as_str() {
+        "" | "local" | "mirror" => Ok(PublishSite::Local(PathBuf::new())),
+        "remote" | "host" => Ok(PublishSite::Host),
+        other => Err(format!(
+            "publish_from must be 'local' or 'remote', got '{other}'"
+        )),
+    }
+}
+
+/// A remote project's lockstep mirror, when it actually holds a git repo.
+fn mirror_repo(project_id: &str) -> Option<PathBuf> {
+    let dir = crate::services::remote_sync::mirror_dir(project_id);
+    dir.join(".git").exists().then_some(dir)
+}
+
+/// Whether a local repo has an `origin` remote — i.e. whether a publish wired
+/// one here.
+fn has_origin(dir: &Path) -> bool {
+    crate::paths::command_no_window("git")
+        .current_dir(dir)
+        .args(["remote", "get-url", "origin"])
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// The mirror of a remote project **when `origin` was wired there**, i.e. when
+/// the project published from this machine. `commands::git::git_push` routes
+/// through this so the pushes land on the same side the repo was created on —
+/// otherwise a mirror-side publish would be followed by host-side pushes into an
+/// `origin` that does not exist there.
+pub(crate) fn mirror_origin_repo(project_id: &str) -> Option<PathBuf> {
+    mirror_repo(project_id).filter(|dir| has_origin(dir))
+}
+
+/// A local project's tree, checked to exist.
+fn local_dir(project: &Project) -> Result<PathBuf, String> {
+    let dir = PathBuf::from(&project.directory);
+    if !dir.is_dir() {
+        return Err(format!(
+            "Project directory does not exist: {}",
+            project.directory
+        ));
+    }
+    Ok(dir)
+}
+
+/// Refuse a mirror-side publish unless lockstep can vouch that the mirror holds
+/// the host's commits.
+///
+/// This is the one hazard the local default introduces: the mirror is a *real*
+/// repo whether or not it is current, so an unguarded publish would happily
+/// create the repository and push a stale — possibly scaffold-only — history
+/// under the project's name. Only a green lockstep means "these are the same
+/// commits"; every other state is reported with what to do about it.
+fn ensure_mirror_in_step(project_id: &str) -> Result<(), String> {
+    let state = crate::services::git_peer::load_state(project_id);
+    match describe_mirror_guard(state.enabled, state.status, state.detail) {
+        Some(msg) => Err(msg),
+        None => Ok(()),
+    }
+}
+
+/// The refusal text for a lockstep state, or `None` when the mirror may publish.
+/// Pure, so the policy — which is the whole safety of the local default — is
+/// unit-tested without a state dir.
+fn describe_mirror_guard(
+    enabled: bool,
+    status: SyncStatus,
+    detail: Option<String>,
+) -> Option<String> {
+    if !enabled {
+        return Some(
+            "Git lockstep is off for this project, so the local mirror is not kept in step \
+             with the host and may not hold the host's commits. Turn lockstep on and let it \
+             sync, or publish from the work-remote host instead."
+                .to_string(),
+        );
+    }
+    match status {
+        SyncStatus::Synchronized => None,
+        SyncStatus::Syncing => {
+            Some("Lockstep is still syncing — wait for it to finish, then publish.".to_string())
+        }
+        SyncStatus::Disconnected => Some(
+            "Lockstep cannot see the host, so it cannot confirm the local mirror holds the \
+             host's commits. Connect the project and let it sync, then publish."
+                .to_string(),
+        ),
+        SyncStatus::Desynchronized => {
+            let detail = detail.map(|d| format!(" ({d})")).unwrap_or_default();
+            Some(format!(
+                "The local mirror and the host are out of step{detail} — publishing now would \
+                 create the repository from the mirror's history. Reconcile lockstep first, or \
+                 publish from the work-remote host instead."
+            ))
+        }
+    }
+}
+
+/// Where a **create** runs: the project's own tree for a local project, and for
+/// a remote one the caller's choice (mirror by default, guarded by lockstep).
+fn publish_site(
+    project: &Project,
+    project_id: &str,
+    publish_from: Option<&str>,
+) -> Result<PublishSite, String> {
+    // A local project has no second side to choose between; the flag is ignored
+    // rather than rejected, so a dialog may always send it.
+    if project.remote.is_none() {
+        return Ok(PublishSite::Local(local_dir(project)?));
+    }
+    match parse_publish_from(publish_from)? {
+        PublishSite::Host => Ok(PublishSite::Host),
+        PublishSite::Local(_) => {
+            let mirror = mirror_repo(project_id).ok_or_else(|| {
+                "This remote project has no local mirror repository to publish from. Turn git \
+                 lockstep on to create one, or publish from the work-remote host instead."
+                    .to_string()
+            })?;
+            ensure_mirror_in_step(project_id)?;
+            Ok(PublishSite::Local(mirror))
+        }
+    }
+}
+
+/// Where a **follow-up** operation runs (visibility, unpublish, push): wherever
+/// `origin` actually got wired. No choice to make — the answer is a fact about
+/// the repos, and guessing it wrong means editing/removing a remote on the side
+/// that doesn't have one.
+fn origin_site(project: &Project, project_id: &str) -> Result<PublishSite, String> {
+    if project.remote.is_none() {
+        return Ok(PublishSite::Local(local_dir(project)?));
+    }
+    Ok(mirror_origin_repo(project_id)
+        .map(PublishSite::Local)
+        .unwrap_or(PublishSite::Host))
+}
+
+/// Publish a project's git repository to a hosting provider and record the new
+/// push target.
+///
+/// `provider` is "github" or "gitlab" (defaulting to GitHub when empty).
+/// `visibility` must be "public" or "private". `publish_from` selects the side
+/// for a work-remote project — `"local"` (default: the lockstep mirror, using
+/// this machine's provider login) or `"remote"` (the host's own login). Returns
+/// the CLI's stdout (typically the new repository URL) on success, or the
+/// trimmed stderr on failure.
+#[tauri::command]
+pub fn publish_project(
+    project_id: String,
+    provider: Option<String>,
+    visibility: String,
+    publish_from: Option<String>,
+) -> Result<String, String> {
+    let provider = Provider::parse(provider.as_deref().unwrap_or("github"))?;
+    let visibility = match visibility.trim() {
+        "public" => "public",
+        "private" => "private",
+        other => {
+            return Err(format!(
+                "visibility must be 'public' or 'private', got '{other}'"
+            ))
+        }
+    };
+
+    let (entry_index, mut list) = find_entry(&project_id)?;
+    let local_file = list[entry_index].local_file.clone();
+    let project: Project =
+        storage::read_json(&PathBuf::from(&local_file)).map_err(|e| e.to_string())?;
+
+    // Repo names can't contain spaces/special chars; reuse the project name
+    // sanitizer that already produces a safe slug for local directories.
+    let repo_name = sanitize_name(&project.name);
+    if repo_name.is_empty() {
+        return Err("Project name does not yield a valid repository name".to_string());
+    }
+
+    // Effective per-project → global token. When set, run the CLI as that token's
+    // account via the provider's token env var instead of relying on the ambient
+    // `… auth login`.
+    let (_profile, token) = crate::commands::git_hosting::effective_git_creds(&project_id);
+
+    let stdout = match publish_site(&project, &project_id, publish_from.as_deref())? {
+        // Local project's tree, or a remote project's lockstep mirror: run the CLI
+        // here, with this machine's provider login / effective token.
+        PublishSite::Local(dir) => {
+            local_publish(provider, &dir, &repo_name, visibility, token.as_deref())?
+        }
+        // Explicit opt-in: run the CLI on the work-remote host, relying on that
+        // host's own provider auth (the local token is never forwarded over ssh).
+        PublishSite::Host => {
+            let remote = project
+                .remote
+                .as_ref()
+                .ok_or_else(|| "Project is not a work-remote project".to_string())?;
+            let base = ssh_base_args(&remote.user, &remote.host, remote.port)?;
+            validate_arg("remote_path", &remote.remote_path)?;
+            let script =
+                remote_publish_script(provider, &remote.remote_path, &repo_name, visibility);
+            // `command_no_window` avoids a console-window flash on Windows.
+            run_remote_provider_command(
+                crate::paths::command_no_window("ssh").args(&base).arg(script),
+                provider,
+            )?
+        }
+    };
+
+    // Reflect the new push target + provider in both projects.json and project.json.
+    let new_git_type = normalize_git_type(&format!("remote-{visibility}"));
+    list[entry_index]
+        .extra
+        .insert("git_type".to_string(), Value::String(new_git_type.clone()));
+    list[entry_index].extra.insert(
+        "git_provider".to_string(),
+        Value::String(provider.as_str().to_string()),
+    );
+    storage::write_json(&storage::state_dir().join("projects.json"), &list)
+        .map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut p) = storage::read_json::<Project>(&proj_path) {
+            p.git_type = Some(new_git_type);
+            p.git_provider = Some(provider.as_str().to_string());
+            let _ = storage::write_json(&proj_path, &p);
+        }
+    }
+
+    Ok(stdout.trim().to_string())
+}
+
+/// Unpublish a project: forget its hosting push target **without** deleting
+/// either its local history or the hosted repository. Removes the `origin`
+/// remote (locally, or over ssh on the work-remote host where the repo lives),
+/// resets `git_type` to `"local"`, and clears `git_provider`.
+///
+/// This is the safe inverse of `publish_project`: commits are never touched and
+/// the GitHub/GitLab repo is left intact — only the local tree is detached from
+/// it. Re-publishing later re-creates or re-attaches a remote.
+#[tauri::command]
+pub fn unpublish_project(project_id: String) -> Result<(), String> {
+    let (idx, mut list) = find_entry(&project_id)?;
+    let local_file = list[idx].local_file.clone();
+    let project: Project =
+        storage::read_json(&PathBuf::from(&local_file)).map_err(|e| e.to_string())?;
+
+    let gt = project
+        .git_type
+        .as_deref()
+        .map(normalize_git_type)
+        .unwrap_or_default();
+    if !gt.starts_with("remote") {
+        return Err("Project is not published to a remote".to_string());
+    }
+
+    // Drop `origin` where it actually is — the mirror for a project published
+    // from this machine, the host for one published over ssh. Removing it from
+    // the wrong side would leave the real one wired and silently destroy a remote
+    // the user configured themselves.
+    match origin_site(&project, &project_id)? {
+        PublishSite::Local(dir) => {
+            // Ignore failure (e.g. origin already absent) — desired end state is "no origin".
+            let _ = crate::paths::command_no_window("git")
+                .current_dir(&dir)
+                .args(["remote", "remove", "origin"])
+                .output();
+        }
+        PublishSite::Host => {
+            let remote = project
+                .remote
+                .as_ref()
+                .ok_or_else(|| "Project is not a work-remote project".to_string())?;
+            let base = ssh_base_args(&remote.user, &remote.host, remote.port)?;
+            validate_arg("remote_path", &remote.remote_path)?;
+            let path = shell_quote(&remote.remote_path);
+            // A missing origin is fine — the goal state is simply "no origin".
+            let script = format!("cd {path} && git remote remove origin 2>/dev/null || true");
+            run_command(crate::paths::command_no_window("ssh").args(&base).arg(script))?;
+        }
+    }
+
+    list[idx]
+        .extra
+        .insert("git_type".to_string(), Value::String("local".to_string()));
+    list[idx].extra.remove("git_provider");
+    storage::write_json(&storage::state_dir().join("projects.json"), &list)
+        .map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut p) = storage::read_json::<Project>(&proj_path) {
+            p.git_type = Some("local".to_string());
+            p.git_provider = None;
+            let _ = storage::write_json(&proj_path, &p);
+        }
+    }
+    Ok(())
+}
+
+/// Flip a published project's repository visibility (public ↔ private) in place
+/// via the provider's `repo edit` verb — no re-create, so the repo, its URL, and
+/// its history are preserved. Updates `git_type` to `remote-<visibility>`.
+///
+/// Runs locally, or over ssh on the work-remote host for a remote project
+/// (relying on that host's provider auth, exactly like `publish_project`).
+#[tauri::command]
+pub fn set_project_visibility(project_id: String, visibility: String) -> Result<String, String> {
+    let visibility = match visibility.trim() {
+        "public" => "public",
+        "private" => "private",
+        other => {
+            return Err(format!(
+                "visibility must be 'public' or 'private', got '{other}'"
+            ))
+        }
+    };
+
+    let (idx, mut list) = find_entry(&project_id)?;
+    let local_file = list[idx].local_file.clone();
+    let project: Project =
+        storage::read_json(&PathBuf::from(&local_file)).map_err(|e| e.to_string())?;
+
+    let gt = project
+        .git_type
+        .as_deref()
+        .map(normalize_git_type)
+        .unwrap_or_default();
+    if !gt.starts_with("remote") {
+        return Err("Project is not published to a remote".to_string());
+    }
+    let provider = Provider::parse(project.git_provider.as_deref().unwrap_or("github"))?;
+
+    // `repo edit` acts on the repo `origin` points at, so it has to run on the
+    // side that has one.
+    let stdout = match origin_site(&project, &project_id)? {
+        PublishSite::Local(dir) => {
+            let (_profile, token) = crate::commands::git_hosting::effective_git_creds(&project_id);
+            local_set_visibility(provider, &dir, visibility, token.as_deref())?
+        }
+        PublishSite::Host => {
+            let remote = project
+                .remote
+                .as_ref()
+                .ok_or_else(|| "Project is not a work-remote project".to_string())?;
+            let base = ssh_base_args(&remote.user, &remote.host, remote.port)?;
+            validate_arg("remote_path", &remote.remote_path)?;
+            let script = remote_visibility_script(provider, &remote.remote_path, visibility);
+            run_remote_provider_command(
+                crate::paths::command_no_window("ssh").args(&base).arg(script),
+                provider,
+            )?
+        }
+    };
+
+    let new_git_type = normalize_git_type(&format!("remote-{visibility}"));
+    list[idx]
+        .extra
+        .insert("git_type".to_string(), Value::String(new_git_type.clone()));
+    storage::write_json(&storage::state_dir().join("projects.json"), &list)
+        .map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut p) = storage::read_json::<Project>(&proj_path) {
+            p.git_type = Some(new_git_type);
+            let _ = storage::write_json(&proj_path, &p);
+        }
+    }
+    Ok(stdout.trim().to_string())
+}
+
+/// Migrate a published project to the **other** hosting provider. Because this
+/// is a true migration (not a rename), the existing `origin` is moved aside to
+/// `origin-old` — the old provider's repository is intentionally **left intact**
+/// (we never delete someone's hosted repo) and stays reachable as `origin-old` —
+/// then a fresh publish creates the repo on the new provider, wires `origin`,
+/// and pushes. Records the new `git_provider` + `git_type` (via the reused
+/// `publish_project`). Returns the create CLI's stdout (new repo URL).
+#[tauri::command]
+pub fn switch_project_provider(
+    project_id: String,
+    provider: Option<String>,
+    visibility: String,
+    publish_from: Option<String>,
+) -> Result<String, String> {
+    let new_provider = Provider::parse(provider.as_deref().unwrap_or("github"))?;
+    let visibility = match visibility.trim() {
+        "public" | "private" => visibility.trim().to_string(),
+        other => {
+            return Err(format!(
+                "visibility must be 'public' or 'private', got '{other}'"
+            ))
+        }
+    };
+
+    let (idx, list) = find_entry(&project_id)?;
+    let local_file = list[idx].local_file.clone();
+    let project: Project =
+        storage::read_json(&PathBuf::from(&local_file)).map_err(|e| e.to_string())?;
+
+    let gt = project
+        .git_type
+        .as_deref()
+        .map(normalize_git_type)
+        .unwrap_or_default();
+    if !gt.starts_with("remote") {
+        return Err("Project is not published — use Publish instead".to_string());
+    }
+    if project.git_provider.as_deref() == Some(new_provider.as_str()) {
+        return Err(format!("Project is already on {}", new_provider.as_str()));
+    }
+
+    // Move the existing origin aside so a fresh publish can wire a new one. The
+    // old hosted repo is intentionally left intact (reachable as origin-old).
+    // This targets the side that *has* the origin, which need not be the side the
+    // new publish will use.
+    rename_origin_aside(origin_site(&project, &project_id)?, &project)?;
+
+    // Delegate the create+wire+push+persist to the normal publish path, now
+    // targeting the new provider.
+    publish_project(
+        project_id,
+        Some(new_provider.as_str().to_string()),
+        visibility,
+        publish_from,
+    )
+}
+
+/// Run the provider's `repo edit --visibility` for a *local* project.
+fn local_set_visibility(
+    provider: Provider,
+    dir: &PathBuf,
+    visibility: &str,
+    token: Option<&str>,
+) -> Result<String, String> {
+    let mut cmd = crate::paths::command_no_window(provider.cli());
+    cmd.current_dir(dir).args(provider.visibility_edit_args(visibility));
+    if let Some(tok) = token {
+        cmd.env(provider.token_env(), tok);
+    }
+    run_provider_command(&mut cmd, provider)
+}
+
+/// Build the remote-host shell script that flips visibility over ssh. `visibility`
+/// is a fixed `public`/`private` literal (validated by the caller); `remote_path`
+/// is single-quoted for the remote shell.
+fn remote_visibility_script(provider: Provider, remote_path: &str, visibility: &str) -> String {
+    let path = shell_quote(remote_path);
+    let args = provider.visibility_edit_args(visibility).join(" ");
+    format!("cd {path} && {} {args}", provider.cli())
+}
+
+/// Rename a project's existing `origin` remote to `origin-old` (best effort),
+/// dropping any stale prior `origin-old` first. Runs at `site` — the side that
+/// actually holds the origin. Used by `switch_project_provider` so a fresh
+/// publish can wire a new `origin` without clobbering the reference to the old
+/// repo.
+fn rename_origin_aside(site: PublishSite, project: &Project) -> Result<(), String> {
+    match site {
+        PublishSite::Local(dir) => {
+            let _ = crate::paths::command_no_window("git")
+                .current_dir(&dir)
+                .args(["remote", "remove", "origin-old"])
+                .output();
+            let _ = crate::paths::command_no_window("git")
+                .current_dir(&dir)
+                .args(["remote", "rename", "origin", "origin-old"])
+                .output();
+        }
+        PublishSite::Host => {
+            let remote = project
+                .remote
+                .as_ref()
+                .ok_or_else(|| "Project is not a work-remote project".to_string())?;
+            let base = ssh_base_args(&remote.user, &remote.host, remote.port)?;
+            validate_arg("remote_path", &remote.remote_path)?;
+            let path = shell_quote(&remote.remote_path);
+            let script = format!(
+                "cd {path} && git remote remove origin-old 2>/dev/null; \
+                 git remote rename origin origin-old 2>/dev/null || true"
+            );
+            run_command(crate::paths::command_no_window("ssh").args(&base).arg(script))?;
+        }
+    }
+    Ok(())
+}
+
+/// Run the provider's create (and, for GitLab, an explicit push) for a *local*
+/// project, returning the combined CLI stdout.
+fn local_publish(
+    provider: Provider,
+    dir: &PathBuf,
+    repo_name: &str,
+    visibility: &str,
+    token: Option<&str>,
+) -> Result<String, String> {
+    match provider {
+        // `gh repo create` creates, wires origin, and pushes in one command.
+        Provider::GitHub => {
+            let mut cmd = crate::paths::command_no_window("gh");
+            cmd.current_dir(dir).args([
+                "repo",
+                "create",
+                repo_name,
+                &format!("--{visibility}"),
+                "--source=.",
+                "--remote=origin",
+                "--push",
+            ]);
+            if let Some(tok) = token {
+                cmd.env(provider.token_env(), tok);
+            }
+            run_provider_command(&mut cmd, provider)
+        }
+        // `glab repo create` creates the project and adds `origin`, but does not
+        // push existing history — so do that as a second, token-authenticated step.
+        Provider::GitLab => {
+            let mut create = crate::paths::command_no_window("glab");
+            create.current_dir(dir).args([
+                "repo",
+                "create",
+                repo_name,
+                &format!("--{visibility}"),
+                "--remoteName",
+                "origin",
+            ]);
+            if let Some(tok) = token {
+                create.env(provider.token_env(), tok);
+            }
+            let mut out = run_provider_command(&mut create, provider)?;
+
+            let mut push = crate::paths::command_no_window("git");
+            push.current_dir(dir);
+            push_with_token(&mut push, provider, token);
+            push.args(["push", "-u", "origin", "HEAD"]);
+            out.push('\n');
+            out.push_str(&run_command(&mut push)?);
+            Ok(out)
+        }
+    }
+}
+
+/// Build the remote-host shell script that performs the publish over ssh.
+fn remote_publish_script(
+    provider: Provider,
+    remote_path: &str,
+    repo_name: &str,
+    visibility: &str,
+) -> String {
+    let path = shell_quote(remote_path);
+    let name = shell_quote(repo_name);
+    match provider {
+        Provider::GitHub => format!(
+            "cd {path} && gh repo create {name} --{visibility} --source=. --remote=origin --push"
+        ),
+        // Mirror the local two-step flow on the remote; the remote host's git
+        // credentials/ssh auth carry the push.
+        Provider::GitLab => format!(
+            "cd {path} && glab repo create {name} --{visibility} --remoteName origin \
+             && git push -u origin HEAD"
+        ),
+    }
+}
+
+/// Attach an ephemeral inline https credential helper that injects the effective
+/// token (read from the child env, never argv/disk) so a `git push` to a freshly
+/// created https remote authenticates. Harmless for ssh remotes — git won't call
+/// an http helper. Mirrors the helper in `commands::git::git_push`.
+fn push_with_token(cmd: &mut Command, provider: Provider, token: Option<&str>) {
+    let Some(tok) = token else { return };
+    let helper = format!(
+        "!f() {{ test \"$1\" = get && echo username={} && echo \"password=$ELDRUN_GIT_TOKEN\"; }}; f",
+        provider.cred_username()
+    );
+    cmd.args(["-c", "credential.helper=", "-c", &helper]);
+    cmd.env("ELDRUN_GIT_TOKEN", tok);
+    cmd.env("GIT_TERMINAL_PROMPT", "0");
+}
+
+/// Find a project entry by id, returning its index and the full (owned) list so
+/// the caller can mutate + persist it.
+fn find_entry(project_id: &str) -> Result<(usize, ProjectsList), String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let idx = list
+        .iter()
+        .position(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    Ok((idx, list))
+}
+
+/// Run a command, returning trimmed stdout on success or a useful error
+/// (stderr, else stdout, else a generic message) on failure.
+fn run_command(cmd: &mut Command) -> Result<String, String> {
+    let output = cmd
+        .output()
+        .map_err(|e| format!("failed to run command: {e}"))?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        if !stderr.is_empty() {
+            return Err(stderr);
+        }
+        let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        if !stdout.is_empty() {
+            return Err(stdout);
+        }
+        return Err("command failed".to_string());
+    }
+    Ok(String::from_utf8_lossy(&output.stdout).to_string())
+}
+
+/// Run a provider CLI (`gh`/`glab`) invocation, turning its two most common
+/// failures — not installed, not signed in — into an actionable message
+/// instead of the CLI's own terse (or, for a local "not installed", raw OS)
+/// wording. The dialog pre-empts both cases for anything running on this machine
+/// (`provider_cli_available`, `effective_git_creds`) — which since the local
+/// default includes a remote project's mirror publish. Only the explicit
+/// **work-remote host** choice is never probed ahead of time, so this is the one
+/// place that failure surfaces for it: the CLI runs inside a shell script over
+/// ssh, so "not installed" there is just stderr text (`… command not found`),
+/// never a local `io::Error`.
+fn run_provider_command(cmd: &mut Command, provider: Provider) -> Result<String, String> {
+    match cmd.output() {
+        Ok(output) => {
+            if output.status.success() {
+                return Ok(String::from_utf8_lossy(&output.stdout).to_string());
+            }
+            let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+            let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+            let raw = if !stderr.is_empty() {
+                stderr
+            } else if !stdout.is_empty() {
+                stdout
+            } else {
+                "command failed".to_string()
+            };
+            Err(friendly_publish_error(provider, &raw))
+        }
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Err(not_installed_error(provider)),
+        Err(e) => Err(format!("failed to run command: {e}")),
+    }
+}
+
+/// Run a provider CLI invocation that is wrapped in `ssh`, where a failure may
+/// come from the *transport* rather than the CLI. `ssh_base_args` is
+/// `BatchMode=yes` + `ControlMaster=no`: it rides an existing master but never
+/// creates one, so a project that isn't currently connected fails at ssh auth
+/// before `gh`/`glab` ever runs — and OpenSSH's wording ("Permission denied
+/// (publickey,password)") reads like a *GitHub* rejection if passed through as-is.
+fn run_remote_provider_command(cmd: &mut Command, provider: Provider) -> Result<String, String> {
+    run_provider_command(cmd, provider).map_err(|e| match ssh_transport_error(&e) {
+        Some(msg) => msg,
+        None => e,
+    })
+}
+
+/// Recognize OpenSSH's own failure wording and say what it actually means. Each
+/// pattern is one OpenSSH emits verbatim — deliberately narrow, so a provider
+/// message that merely contains "denied" is not mistaken for a transport failure.
+fn ssh_transport_error(raw: &str) -> Option<String> {
+    let lower = raw.to_ascii_lowercase();
+    let transport = lower.contains("permission denied (public")
+        || lower.contains("ssh: connect to host")
+        || lower.contains("could not resolve hostname")
+        || lower.contains("host key verification failed")
+        || lower.contains("kex_exchange_identification")
+        || lower.contains("connection closed by remote host")
+        || lower.contains("connection timed out during banner exchange")
+        || lower.contains("operation timed out");
+    transport.then(|| {
+        format!(
+            "Could not reach the work-remote host over SSH, so the publish never started. \
+             Connect the project first (the pill's connection lamp must be green), or publish \
+             from this computer's local mirror instead.\n\n{}",
+            raw.trim()
+        )
+    })
+}
+
+/// The message for "the provider CLI isn't on this machine (or the remote
+/// host)" — the most common wall a first publish hits.
+fn not_installed_error(provider: Provider) -> String {
+    let cli = provider.cli();
+    format!(
+        "{cli} is not installed — publishing to {} creates the repository through \
+         the provider's own CLI, which plain git cannot do. Install {cli}, then run \
+         `{cli} auth login` (or store an access token in Settings → Git Hosting) \
+         before publishing.",
+        provider.display_name()
+    )
+}
+
+/// Turn a provider CLI's own failure text into the sentence that says what to
+/// do about it. Mirrors `commands::git_fork::api_error`'s two cases (not
+/// installed, not signed in) for the create/publish path.
+fn friendly_publish_error(provider: Provider, raw: &str) -> String {
+    let lower = raw.to_ascii_lowercase();
+    let cli = provider.cli();
+    // Shell "binary not found" wording, GitHub/GitLab's install docs cover
+    // bash/sh/PowerShell: "command not found", "gh: not found", "is not
+    // recognized as an internal or external command" (Windows cmd/PowerShell).
+    if lower.contains("command not found")
+        || lower.contains(&format!("{cli}: not found"))
+        || lower.contains("is not recognized as")
+    {
+        return not_installed_error(provider);
+    }
+    if lower.contains("not logged")
+        || lower.contains("authentication")
+        || lower.contains("401")
+        || lower.contains("unauthorized")
+    {
+        return format!(
+            "{}\n\nPublishing uses the {cli} CLI's own login — run `{cli} auth login` \
+             (or store an access token in Settings → Git Hosting).",
+            raw.trim()
+        );
+    }
+    raw.trim().to_string()
+}
+
+/// Single-quote a string for safe embedding in a remote `/bin/sh` command,
+/// escaping any embedded single quotes.
+fn shell_quote(s: &str) -> String {
+    format!("'{}'", s.replace('\'', "'\\''"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shell_quote_wraps_plain_value() {
+        assert_eq!(shell_quote("/home/user/proj"), "'/home/user/proj'");
+    }
+
+    #[test]
+    fn shell_quote_escapes_embedded_single_quotes() {
+        assert_eq!(shell_quote("a'b"), r"'a'\''b'");
+        // The result is a safe single-quoted shell token (no unescaped quote
+        // breaks out of the quoting).
+        assert!(shell_quote("; rm -rf /").starts_with('\''));
+    }
+
+    #[test]
+    fn provider_parse_defaults_and_validates() {
+        assert!(matches!(Provider::parse(""), Ok(Provider::GitHub)));
+        assert!(matches!(Provider::parse("GitHub"), Ok(Provider::GitHub)));
+        assert!(matches!(Provider::parse("gitlab"), Ok(Provider::GitLab)));
+        assert!(Provider::parse("bitbucket").is_err());
+    }
+
+    #[test]
+    fn github_remote_script_is_single_command_push() {
+        let s = remote_publish_script(Provider::GitHub, "/srv/proj", "my-proj", "public");
+        assert_eq!(
+            s,
+            "cd '/srv/proj' && gh repo create 'my-proj' --public --source=. --remote=origin --push"
+        );
+    }
+
+    #[test]
+    fn gitlab_remote_script_creates_then_pushes() {
+        let s = remote_publish_script(Provider::GitLab, "/srv/proj", "my-proj", "private");
+        assert!(s.contains("glab repo create 'my-proj' --private --remoteName origin"));
+        assert!(s.contains("&& git push -u origin HEAD"));
+    }
+
+    #[test]
+    fn github_visibility_edit_requires_consent_flag() {
+        let args = Provider::GitHub.visibility_edit_args("private");
+        assert_eq!(
+            args,
+            vec![
+                "repo",
+                "edit",
+                "--visibility",
+                "private",
+                "--accept-visibility-change-consequences"
+            ]
+        );
+    }
+
+    #[test]
+    fn gitlab_visibility_edit_has_no_consent_flag() {
+        let args = Provider::GitLab.visibility_edit_args("public");
+        assert_eq!(args, vec!["repo", "edit", "--visibility", "public"]);
+    }
+
+    #[test]
+    fn remote_visibility_script_quotes_path_and_uses_cli() {
+        let s = remote_visibility_script(Provider::GitLab, "/srv/proj", "public");
+        assert_eq!(
+            s,
+            "cd '/srv/proj' && glab repo edit --visibility public"
+        );
+    }
+
+    #[test]
+    fn friendly_error_flags_missing_cli_across_shells() {
+        assert!(friendly_publish_error(Provider::GitHub, "bash: gh: command not found")
+            .contains("is not installed"));
+        assert!(friendly_publish_error(Provider::GitLab, "sh: 1: glab: not found")
+            .contains("is not installed"));
+        assert!(friendly_publish_error(
+            Provider::GitHub,
+            "'gh' is not recognized as an internal or external command"
+        )
+        .contains("is not installed"));
+    }
+
+    #[test]
+    fn friendly_error_flags_missing_auth() {
+        let msg = friendly_publish_error(Provider::GitHub, "gh: not logged into any GitHub hosts");
+        assert!(msg.contains("gh auth login"));
+        assert!(msg.contains("not logged into any GitHub hosts"));
+    }
+
+    #[test]
+    fn friendly_error_passes_through_unrecognized_failures() {
+        let msg = friendly_publish_error(Provider::GitLab, "GraphQL: Name has already been taken");
+        assert_eq!(msg, "GraphQL: Name has already been taken");
+    }
+
+    // ── Publish site (local mirror by default) ─────────────────────────────
+
+    #[test]
+    fn publish_from_defaults_to_the_local_mirror() {
+        // Absent and empty both mean "this machine" — the hosting login is local.
+        assert!(matches!(
+            parse_publish_from(None),
+            Ok(PublishSite::Local(_))
+        ));
+        assert!(matches!(
+            parse_publish_from(Some("")),
+            Ok(PublishSite::Local(_))
+        ));
+        assert!(matches!(
+            parse_publish_from(Some("mirror")),
+            Ok(PublishSite::Local(_))
+        ));
+    }
+
+    #[test]
+    fn publish_from_remote_opts_into_the_host() {
+        assert_eq!(parse_publish_from(Some("remote")), Ok(PublishSite::Host));
+        assert_eq!(parse_publish_from(Some("Host")), Ok(PublishSite::Host));
+        assert!(parse_publish_from(Some("elsewhere")).is_err());
+    }
+
+    #[test]
+    fn ssh_transport_failures_are_named_as_such() {
+        for raw in [
+            "Permission denied (publickey,password).",
+            "ssh: connect to host h port 22: Connection refused",
+            "ssh: Could not resolve hostname h: Name or service not known",
+            "Host key verification failed.",
+            "kex_exchange_identification: Connection closed by remote host",
+        ] {
+            let msg = ssh_transport_error(raw).expect("recognized as a transport failure");
+            assert!(msg.contains("Could not reach the work-remote host"));
+            // The original wording is kept — it is what a user greps for.
+            assert!(msg.contains(raw.trim()));
+        }
+    }
+
+    #[test]
+    fn provider_failures_are_not_mistaken_for_transport_ones() {
+        // "denied"/"not found" from the provider must fall through to the CLI
+        // messages, or a real GitHub error would be reported as an SSH problem.
+        assert!(ssh_transport_error("gh: Permission denied to fseiffarth.").is_none());
+        assert!(ssh_transport_error("bash: gh: command not found").is_none());
+        assert!(ssh_transport_error("GraphQL: Name has already been taken").is_none());
+    }
+
+    #[test]
+    fn mirror_publish_is_refused_unless_lockstep_vouches_for_it() {
+        // Lockstep off: the mirror is a real repo but nothing keeps it current, so
+        // publishing it could ship a scaffold-only history under the project name.
+        let msg = describe_mirror_guard(false, SyncStatus::Synchronized, None);
+        assert!(msg.as_deref().unwrap().contains("lockstep is off"));
+
+        // Out of step: name the reason, since the user can act on it.
+        let msg = describe_mirror_guard(
+            true,
+            SyncStatus::Desynchronized,
+            Some("the mirror is on 'main', the host is on 'claude'".to_string()),
+        );
+        let msg = msg.expect("desynchronized is refused");
+        assert!(msg.contains("the host is on 'claude'"));
+
+        // Cold pool: we cannot claim anything about the host, so we don't.
+        assert!(describe_mirror_guard(true, SyncStatus::Disconnected, None).is_some());
+        assert!(describe_mirror_guard(true, SyncStatus::Syncing, None).is_some());
+
+        // Green is the one state that publishes.
+        assert!(describe_mirror_guard(true, SyncStatus::Synchronized, None).is_none());
+    }
+
+    #[test]
+    fn not_installed_error_names_cli_and_next_step() {
+        let msg = not_installed_error(Provider::GitLab);
+        assert!(msg.contains("glab"));
+        assert!(msg.contains("glab auth login"));
+        assert!(msg.contains("GitLab"));
+    }
+}
diff --git a/src-tauri/src/commands/github.rs b/src-tauri/src/commands/github.rs
deleted file mode 100644
index c8035d8..0000000
--- a/src-tauri/src/commands/github.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-//! GitHub publishing for projects, via the system `gh` CLI.
-//!
-//! Publishing creates a GitHub repo from the project's git working tree and
-//! pushes to it (`gh repo create … --source=. --push`). The project's push
-//! target (`git_type`) is then updated to `remote-<visibility>`.
-//!
-//! A project's bytes may live locally or on an SSH work-remote host. For a
-//! remote project the push must originate where the repo actually is, so the
-//! `gh` invocation runs over `ssh` on the remote host (mirroring `commands::ssh`:
-//! `BatchMode`, validated argv, no shell string built from untrusted input — the
-//! remote path/name are single-quoted for the remote shell).
-
-use std::path::PathBuf;
-use std::process::Command;
-
-use serde_json::Value;
-
-use crate::commands::projects::{normalize_git_type, sanitize_name};
-use crate::schema::project::Project;
-use crate::schema::projects::ProjectsList;
-use crate::services::ssh_mount::{ssh_base_args, validate_arg};
-use crate::storage;
-
-/// Publish a project's git repository to GitHub and record the new push target.
-///
-/// `visibility` must be "public" or "private". Returns `gh`'s stdout (typically
-/// the new repository URL) on success, or the trimmed stderr on failure.
-#[tauri::command]
-pub fn github_publish(project_id: String, visibility: String) -> Result<String, String> {
-    let visibility = match visibility.trim() {
-        "public" => "public",
-        "private" => "private",
-        other => {
-            return Err(format!(
-                "visibility must be 'public' or 'private', got '{other}'"
-            ))
-        }
-    };
-
-    let (entry_index, mut list) = find_entry(&project_id)?;
-    let local_file = list[entry_index].local_file.clone();
-    let project: Project =
-        storage::read_json(&PathBuf::from(&local_file)).map_err(|e| e.to_string())?;
-
-    // GitHub repo names can't contain spaces/special chars; reuse the project
-    // name sanitizer that already produces a safe slug for local directories.
-    let repo_name = sanitize_name(&project.name);
-    if repo_name.is_empty() {
-        return Err("Project name does not yield a valid GitHub repo name".to_string());
-    }
-
-    let stdout = match project.remote.as_ref() {
-        // Remote project: run gh on the host where the bytes live.
-        Some(remote) => {
-            let base = ssh_base_args(&remote.user, &remote.host, remote.port)?;
-            validate_arg("remote_path", &remote.remote_path)?;
-            let script = format!(
-                "cd {} && gh repo create {} --{} --source=. --remote=origin --push",
-                shell_quote(&remote.remote_path),
-                shell_quote(&repo_name),
-                visibility,
-            );
-            run_command(Command::new("ssh").args(&base).arg(script))?
-        }
-        // Local project: run gh in the project directory.
-        None => {
-            let dir = PathBuf::from(&project.directory);
-            if !dir.is_dir() {
-                return Err(format!(
-                    "Project directory does not exist: {}",
-                    project.directory
-                ));
-            }
-            let mut cmd = Command::new("gh");
-            cmd.current_dir(&dir).args([
-                "repo",
-                "create",
-                &repo_name,
-                &format!("--{visibility}"),
-                "--source=.",
-                "--remote=origin",
-                "--push",
-            ]);
-            run_command(&mut cmd)?
-        }
-    };
-
-    // Reflect the new push target in both projects.json and project.json.
-    let new_git_type = normalize_git_type(&format!("remote-{visibility}"));
-    list[entry_index]
-        .extra
-        .insert("git_type".to_string(), Value::String(new_git_type.clone()));
-    storage::write_json(&storage::state_dir().join("projects.json"), &list)
-        .map_err(|e| e.to_string())?;
-
-    let proj_path = PathBuf::from(&local_file);
-    if proj_path.exists() {
-        if let Ok(mut p) = storage::read_json::<Project>(&proj_path) {
-            p.git_type = Some(new_git_type);
-            let _ = storage::write_json(&proj_path, &p);
-        }
-    }
-
-    Ok(stdout.trim().to_string())
-}
-
-/// Find a project entry by id, returning its index and the full (owned) list so
-/// the caller can mutate + persist it.
-fn find_entry(project_id: &str) -> Result<(usize, ProjectsList), String> {
-    let list_path = storage::state_dir().join("projects.json");
-    let list: ProjectsList = if list_path.exists() {
-        storage::read_json(&list_path).map_err(|e| e.to_string())?
-    } else {
-        Vec::new()
-    };
-    let idx = list
-        .iter()
-        .position(|p| p.id == project_id)
-        .ok_or_else(|| format!("project '{project_id}' not found"))?;
-    Ok((idx, list))
-}
-
-/// Run a command, returning trimmed stdout on success or a useful error
-/// (stderr, else stdout, else a generic message) on failure.
-fn run_command(cmd: &mut Command) -> Result<String, String> {
-    let output = cmd
-        .output()
-        .map_err(|e| format!("failed to run command: {e}"))?;
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-        if !stderr.is_empty() {
-            return Err(stderr);
-        }
-        let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
-        if !stdout.is_empty() {
-            return Err(stdout);
-        }
-        return Err("command failed".to_string());
-    }
-    Ok(String::from_utf8_lossy(&output.stdout).to_string())
-}
-
-/// Single-quote a string for safe embedding in a remote `/bin/sh` command,
-/// escaping any embedded single quotes.
-fn shell_quote(s: &str) -> String {
-    format!("'{}'", s.replace('\'', "'\\''"))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn shell_quote_wraps_plain_value() {
-        assert_eq!(shell_quote("/home/user/proj"), "'/home/user/proj'");
-    }
-
-    #[test]
-    fn shell_quote_escapes_embedded_single_quotes() {
-        assert_eq!(shell_quote("a'b"), r"'a'\''b'");
-        // The result is a safe single-quoted shell token (no unescaped quote
-        // breaks out of the quoting).
-        assert!(shell_quote("; rm -rf /").starts_with('\''));
-    }
-}
diff --git a/src-tauri/src/commands/global_machines.rs b/src-tauri/src/commands/global_machines.rs
new file mode 100644
index 0000000..c691e86
--- /dev/null
+++ b/src-tauri/src/commands/global_machines.rs
@@ -0,0 +1,451 @@
+//! Global worker-machine registry (project-free, mirrors the VPN tunnel
+//! registry's "machine-wide, not project-scoped" pattern).
+//!
+//! A [`GlobalMachine`] is authenticated once via the ordinary login mechanism
+//! (`commands::ssh::ssh_connect`) with no `remote_path` — the caller does that
+//! *before* calling [`global_machine_add`], which only persists the identity.
+//! No connect/disconnect commands live here: `ssh_connect`/`ssh_probe` are
+//! already project-free and host-identity keyed, so the frontend calls them
+//! directly with a machine's `user`/`host`/`port`.
+
+use crate::schema::GlobalMachine;
+use crate::storage;
+use serde::{Deserialize, Serialize};
+
+fn global_machines_path() -> std::path::PathBuf {
+    storage::state_dir().join("global_machines.json")
+}
+
+/// One machine as it crosses the import/export boundary. Deliberately a **subset**
+/// of [`GlobalMachine`]: it carries the connection *address* (host/port) and the
+/// display `label`, but **no `id`, no `auto_connect`, and — on export — no
+/// `user`**. The export omits the username on purpose so the resulting file is
+/// shareable between people who each log in as themselves (import supplies one
+/// common username + password). `user` is still an *accepted* field on import so
+/// a hand-authored file can pin a per-machine login; a file Eldrun wrote never
+/// has it. Passwords are never written to or read from this file — the whole
+/// point of the "one common password at import" flow.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MachineIo {
+    pub host: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<u16>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+}
+
+/// The on-disk shape of an exported machines file: a versioned wrapper around the
+/// list, so a future format change can be detected rather than mis-parsed. Import
+/// also tolerates a bare `[MachineIo]` array (a hand-written file), so the wrapper
+/// is a convenience, not a requirement.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct MachineExportFile {
+    pub version: u32,
+    pub machines: Vec<MachineIo>,
+}
+
+fn load_all() -> Vec<GlobalMachine> {
+    storage::read_json(&global_machines_path()).unwrap_or_default()
+}
+
+fn save_all(list: &[GlobalMachine]) -> Result<(), String> {
+    storage::write_json(&global_machines_path(), &list.to_vec()).map_err(|e| e.to_string())
+}
+
+/// Every globally connected machine, for the header's Machines indicator.
+#[tauri::command]
+pub fn global_machines_list() -> Vec<GlobalMachine> {
+    load_all()
+}
+
+/// Register a machine in the global list. The CALLER has already authenticated
+/// it via `ssh_connect` — this command does no auth of its own, it only
+/// persists the identity (mirrors how `RemoteMachinesWindow` already separates
+/// "log in" from "add" for a project worker).
+#[tauri::command]
+pub fn global_machine_add(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    label: Option<String>,
+) -> Result<GlobalMachine, String> {
+    let host = host.trim().to_string();
+    if host.is_empty() {
+        return Err("host must not be empty".to_string());
+    }
+    crate::services::ssh_common::validate_arg("host", &host)?;
+    let user = user
+        .map(|u| u.trim().to_string())
+        .filter(|u| !u.is_empty());
+    if let Some(u) = &user {
+        crate::services::ssh_common::validate_arg("user", u)?;
+    }
+    let label = label
+        .map(|l| l.trim().to_string())
+        .filter(|l| !l.is_empty());
+    let mut list = load_all();
+    // Idempotent by target: a machine *is* its `(user, host, port)` identity, so a
+    // second registration of the same host — the HPC-wizard login surfacing a
+    // cluster the user may already have added by hand, or a repeat wizard run —
+    // returns the existing row rather than stacking a duplicate. The caller has
+    // just authenticated the same target, so nothing new needs persisting.
+    if let Some(existing) = list
+        .iter()
+        .find(|m| m.user == user && m.host == host && m.port == port)
+    {
+        return Ok(existing.clone());
+    }
+    let machine = GlobalMachine {
+        id: crate::commands::projects::uuid_v4(),
+        user,
+        host,
+        port,
+        label,
+        auto_connect: None,
+    };
+    list.push(machine.clone());
+    save_all(&list)?;
+    Ok(machine)
+}
+
+/// Edit an existing machine's connection identity — `user`/`host`/`port`/`label`.
+/// **Only the identity**: the SSH password is never held here (it lives in the OS
+/// keychain, keyed by host target), so a password change is applied by the caller
+/// re-running `ssh_connect` with the new target, not by this command. Validates
+/// host/user exactly as [`global_machine_add`], and refuses a change that would
+/// collide the machine onto another row's `(user, host, port)` target (which
+/// `global_machine_add`'s idempotency would otherwise silently merge). Returns the
+/// full updated list, like [`global_machine_remove`]/[`global_machine_reorder`].
+///
+/// Note the keychain consequence of changing the target: the saved password (if
+/// any) was stored under the *old* `ssh_account` key and does not follow the
+/// machine to a new user/host/port. The caller re-authenticates the new target.
+#[tauri::command]
+pub fn global_machine_update(
+    id: String,
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    label: Option<String>,
+) -> Result<Vec<GlobalMachine>, String> {
+    let host = host.trim().to_string();
+    if host.is_empty() {
+        return Err("host must not be empty".to_string());
+    }
+    crate::services::ssh_common::validate_arg("host", &host)?;
+    let user = user.map(|u| u.trim().to_string()).filter(|u| !u.is_empty());
+    if let Some(u) = &user {
+        crate::services::ssh_common::validate_arg("user", u)?;
+    }
+    let label = label.map(|l| l.trim().to_string()).filter(|l| !l.is_empty());
+    let mut list = load_all();
+    if !list.iter().any(|m| m.id == id) {
+        return Err("machine not found".to_string());
+    }
+    // A machine *is* its `(user, host, port)` identity — refuse to point two rows
+    // at the same target (rather than silently fold them, which `global_machine_add`
+    // would do on a re-add but is surprising as the result of an edit).
+    if list
+        .iter()
+        .any(|m| m.id != id && m.user == user && m.host == host && m.port == port)
+    {
+        return Err("another machine already uses that address".to_string());
+    }
+    for m in list.iter_mut() {
+        if m.id == id {
+            m.user = user.clone();
+            m.host = host.clone();
+            m.port = port;
+            m.label = label.clone();
+        }
+    }
+    save_all(&list)?;
+    Ok(list)
+}
+
+/// Arm (or disarm) a machine for silent auto-connect on launch / VPN-up. Stores
+/// `Some(true)` when enabled and drops the field entirely when disabled, so a
+/// disarmed machine looks exactly like one from before the field existed. The
+/// promise is kept on the *frontend* auto path (it probes before it connects, so
+/// it never prompts); this only persists the opt-in.
+#[tauri::command]
+pub fn global_machine_set_auto_connect(
+    id: String,
+    enabled: bool,
+) -> Result<Vec<GlobalMachine>, String> {
+    let mut list = load_all();
+    for m in list.iter_mut() {
+        if m.id == id {
+            m.auto_connect = if enabled { Some(true) } else { None };
+        }
+    }
+    save_all(&list)?;
+    Ok(list)
+}
+
+/// Drop a machine from the global list. Never touches the OS keychain — the
+/// saved SSH credential (if any) is keyed by host identity
+/// (`remote_credentials::ssh_account`), shared with any project that reaches
+/// the same target, not by this registry. Never touches any project's
+/// `compute_hosts` either: a `ComputeHost` is a value copy of the connection
+/// info made at drop time, not a reference back here.
+#[tauri::command]
+pub fn global_machine_remove(id: String) -> Result<Vec<GlobalMachine>, String> {
+    let mut list = load_all();
+    list.retain(|m| m.id != id);
+    save_all(&list)?;
+    Ok(list)
+}
+
+/// Persist a new display order for the global machines list — the frontend
+/// (drag-and-drop in `MachinesIndicator`) computes the reordered id sequence
+/// client-side (splice, mirrors `stores::projects`' `reorderProjects`) and this
+/// only rewrites the file to match it. There's no separate position field:
+/// array order in `global_machines.json` **is** the order. Any id missing from
+/// `ids` (a stale snapshot racing a concurrent add/remove) keeps its original
+/// relative place, appended after the given ones, so a reorder can never
+/// silently drop a machine.
+#[tauri::command]
+pub fn global_machine_reorder(ids: Vec<String>) -> Result<Vec<GlobalMachine>, String> {
+    let list = load_all();
+    let mut reordered: Vec<GlobalMachine> = ids
+        .iter()
+        .filter_map(|id| list.iter().find(|m| &m.id == id).cloned())
+        .collect();
+    for m in &list {
+        if !reordered.iter().any(|r| r.id == m.id) {
+            reordered.push(m.clone());
+        }
+    }
+    save_all(&reordered)?;
+    Ok(reordered)
+}
+
+/// Write the selected machines to a shareable JSON file at `path`. `ids` is the
+/// caller's selection **in display order**; the file preserves that order. Only
+/// host/port/label cross — never the username (so the file works for whoever
+/// imports it) and never a password (secrets live in the OS keychain, keyed by
+/// host, and are never serialized). The path comes from a native save dialog on
+/// the frontend, so it can be anywhere the user chose.
+#[tauri::command]
+pub fn global_machines_export(ids: Vec<String>, path: String) -> Result<(), String> {
+    let list = load_all();
+    let by_id: std::collections::HashMap<&str, &GlobalMachine> =
+        list.iter().map(|m| (m.id.as_str(), m)).collect();
+    let machines: Vec<MachineIo> = ids
+        .iter()
+        .filter_map(|id| by_id.get(id.as_str()).copied())
+        .map(|m| MachineIo {
+            host: m.host.clone(),
+            port: m.port,
+            label: m.label.clone(),
+            user: None, // deliberately dropped — see `MachineIo`.
+        })
+        .collect();
+    if machines.is_empty() {
+        return Err("no machines selected to export".to_string());
+    }
+    let file = MachineExportFile { version: 1, machines };
+    let json = serde_json::to_string_pretty(&file).map_err(|e| e.to_string())?;
+    std::fs::write(&path, json).map_err(|e| format!("failed to write {path}: {e}"))?;
+    Ok(())
+}
+
+/// Read and validate a machines file at `path`, returning the importable entries
+/// **without** connecting or persisting anything — the frontend previews them,
+/// collects one shared username + password, then connects+adds each via the
+/// ordinary `ssh_connect` + `global_machine_add` pair (so status lamps and the
+/// idempotent-by-target de-dup both apply). Accepts either the
+/// [`MachineExportFile`] wrapper Eldrun writes or a bare `[MachineIo]` array.
+/// Entries are trimmed; those with an empty or shell-unsafe host/user are dropped
+/// (the same `validate_arg` gate `global_machine_add` applies), so a malformed
+/// file yields fewer rows rather than an unsafe add later.
+#[tauri::command]
+pub fn global_machines_import_read(path: String) -> Result<Vec<MachineIo>, String> {
+    let content =
+        std::fs::read_to_string(&path).map_err(|e| format!("failed to read {path}: {e}"))?;
+    let raw = match serde_json::from_str::<MachineExportFile>(&content) {
+        Ok(f) => f.machines,
+        // Fall back to a bare array (a hand-written file) before giving up.
+        Err(_) => serde_json::from_str::<Vec<MachineIo>>(&content)
+            .map_err(|_| "not a machines export file (expected {version, machines} or a JSON array)".to_string())?,
+    };
+    let mut out = Vec::new();
+    for m in raw {
+        let host = m.host.trim().to_string();
+        if host.is_empty() || crate::services::ssh_common::validate_arg("host", &host).is_err() {
+            continue;
+        }
+        let user = m
+            .user
+            .map(|u| u.trim().to_string())
+            .filter(|u| !u.is_empty());
+        if let Some(u) = &user {
+            if crate::services::ssh_common::validate_arg("user", u).is_err() {
+                continue;
+            }
+        }
+        let label = m
+            .label
+            .map(|l| l.trim().to_string())
+            .filter(|l| !l.is_empty());
+        out.push(MachineIo {
+            host,
+            port: m.port,
+            label,
+            user,
+        });
+    }
+    if out.is_empty() {
+        return Err("no valid machines found in file".to_string());
+    }
+    Ok(out)
+}
+
+/// Full system-monitor snapshot for one global machine — the header's Machines
+/// menu opens `GlobalMachineMonitorDialog` (`components/monitoring/
+/// SystemMonitorPane` in its ad-hoc `globalMachine` mode) on this, in place of
+/// the old small per-row usage bar. The direct analog of
+/// `commands::monitor::system_monitor_snapshot` for a project-free host: a
+/// global machine has no `project_id` to resolve through
+/// `remote_target_for_host`, so this authenticates **ad-hoc** instead —
+/// `run_ssh_auth`'s saved-password/key-agent branching (the same one
+/// `ssh_connect`/`ssh_probe` use), no pooled ControlMaster — then runs the same
+/// whole-`/proc` `REMOTE_SNAPSHOT_SCRIPT` / `parse_remote_snapshot` pair
+/// `system_monitor_snapshot` uses for a project's remote host, so the two
+/// surfaces read identically field-for-field. One SSH round trip, heavier than
+/// a pooled poll, so the frontend should only sample this while the dialog is
+/// open.
+#[tauri::command]
+pub async fn global_machine_monitor_snapshot(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    careful: Option<bool>,
+    background: Option<bool>,
+) -> Result<crate::sysstat::SystemSnapshot, String> {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        // `background` per `ssh_common`'s second shape: opening the monitor is a
+        // gesture, its repeat poll is not, and both land here.
+        let _dial = crate::services::ssh_common::declared_dial(background, &user, &host, port);
+        let account = creds::ssh_account(&user, &host, port);
+        let password = creds::get(&account);
+        // `careful` is the machine's stored mode (careful by default for every
+        // remote machine, normal where the user said this one is theirs), keyed
+        // by the same SSH target this command already is — see
+        // `commands::monitor::system_monitor_snapshot`. With no answer to pass,
+        // fall back to what earlier probes of this target found; the host's own
+        // SLURM check covers a first sample either way.
+        let key = crate::services::ssh_common::target_key(user.as_deref(), &host, port);
+        let mode = careful.or_else(|| crate::services::hpc_mode::is_known_careful(&key).then_some(true));
+        let script = crate::sysstat::remote_snapshot_script(mode);
+        let stdout =
+            crate::commands::ssh::run_ssh_auth(&user, &host, port, password.as_deref(), &[&script])?;
+        if stdout.trim().is_empty() {
+            return Err("system monitor probe returned no output".to_string());
+        }
+        let snap = crate::sysstat::parse_remote_snapshot(&stdout);
+        crate::services::hpc_mode::remember(&key, snap.careful);
+        Ok(snap)
+    })
+    .await
+    .map_err(|e| format!("system monitor probe task failed: {e}"))?
+}
+
+/// The tmux sessions running on one global machine — the "is someone actually
+/// working here?" probe behind the **busy** (pulsing green) lamp in the header
+/// Machines menu, the project pill and the Remote-machines hub. A connected lamp
+/// only says the host authenticates; this says a run is alive on it.
+///
+/// The project-scoped twin is `commands::remote::remote_tmux_list`, which
+/// resolves a `project_id`/`host_id` and rides that project's pooled
+/// ControlMaster. A global machine has no project to resolve through, so this
+/// authenticates **ad-hoc** via `run_ssh_auth` — exactly as
+/// `global_machine_monitor_snapshot` and `global_machine_usage_check` do — and
+/// then runs the *same* `tmux_ls_script` through the *same* `parse_tmux_ls`, so
+/// a global machine's busy state and a project host's are the same reading.
+///
+/// An absent tmux, or a host with no server running, yields an **empty** list
+/// rather than an error (`tmux_ls_script` ends in `|| true`): "no sessions" and
+/// "no tmux" both mean *not busy*, and neither should redden a lamp.
+///
+/// One SSH round trip per call, so the frontend fires it only while the menu or
+/// hub that shows the lamp is open — never on a background poll.
+#[tauri::command]
+pub async fn global_machine_tmux_list(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    background: Option<bool>,
+) -> Result<Vec<crate::services::ssh_exec::TmuxSession>, String> {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        // `background` per `ssh_common`'s second shape. The doc above already
+        // says this fires "only while the menu is open" — but a menu that opens
+        // on hover is not a decision, so the sweep behind it is background and
+        // only a row the user acted on passes `Some(false)`.
+        let _dial = crate::services::ssh_common::declared_dial(background, &user, &host, port);
+        let account = creds::ssh_account(&user, &host, port);
+        let password = creds::get(&account);
+        let stdout = crate::commands::ssh::run_ssh_auth(
+            &user,
+            &host,
+            port,
+            password.as_deref(),
+            &[crate::services::ssh_exec::tmux_ls_script()],
+        )?;
+        Ok(crate::services::ssh_exec::parse_tmux_ls(&stdout))
+    })
+    .await
+    .map_err(|e| format!("tmux probe task failed: {e}"))?
+}
+
+/// Usage report (who's logged in, CPU/load/memory/GPU, top processes) for one
+/// global machine — what the header Machines menu's on-demand "Remote host
+/// usage…" dialog shows for every machine in the list, in list order.
+///
+/// The project-scoped twin is `commands::remote::remote_usage_check`, which
+/// resolves a `project_id`/`host_id` to a spec and rides that project's pooled
+/// ControlMaster. A global machine has no project to resolve through and pools
+/// nothing, so this authenticates **ad-hoc** via `run_ssh_auth`'s saved-password
+/// /key-agent branching — exactly as `global_machine_monitor_snapshot` does —
+/// and then runs the *same* `remote_usage::probe_script` through the *same*
+/// `parse_report`, so a global machine's section and a project host's section of
+/// that dialog read identically field-for-field.
+///
+/// One SSH round trip per call, so the frontend only fires it when the dialog is
+/// opened or its "Recheck" is pressed — never on a poll.
+#[tauri::command]
+pub async fn global_machine_usage_check(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    background: Option<bool>,
+) -> Result<crate::services::remote_usage::RemoteUsageReport, String> {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        // `background` per `ssh_common`'s second shape — the project-scoped twin
+        // `remote::remote_usage_check` takes the same parameter with the same
+        // polarity, since the one dialog drives both.
+        let _dial = crate::services::ssh_common::declared_dial(background, &user, &host, port);
+        let account = creds::ssh_account(&user, &host, port);
+        let password = creds::get(&account);
+        let script = crate::services::remote_usage::probe_script();
+        let stdout = crate::commands::ssh::run_ssh_auth(
+            &user,
+            &host,
+            port,
+            password.as_deref(),
+            &[script.as_str()],
+        )?;
+        if stdout.trim().is_empty() {
+            return Err("usage probe returned no output".to_string());
+        }
+        Ok(crate::services::remote_usage::parse_report(&stdout))
+    })
+    .await
+    .map_err(|e| format!("usage probe task failed: {e}"))?
+}
diff --git a/src-tauri/src/commands/hpc_ws.rs b/src-tauri/src/commands/hpc_ws.rs
new file mode 100644
index 0000000..ea05158
--- /dev/null
+++ b/src-tauri/src/commands/hpc_ws.rs
@@ -0,0 +1,1238 @@
+//! HPC **workspaces** — the missing first step of the SLURM pipeline
+//! (`docs/quirky-knitting-umbrella` plan, Phase C).
+//!
+//! On a cluster, `$HOME` is a small, quota'd, backed-up filesystem for *code*;
+//! the bulk data of a computation belongs on the big parallel filesystem, which
+//! is handed out as a **workspace** — a directory with a *name*, a *duration* and
+//! an *expiry*, created through the `hpc-workspace` tooling (`ws_allocate`,
+//! `ws_list`, `ws_find`, `ws_extend`, `ws_release`). Sites differ in filesystems
+//! and limits (a typical one: up to 90 days, three extensions, a general-purpose
+//! default location plus a faster SSD one, data deleted some weeks after expiry),
+//! so nothing here is site-specific: the host is *asked* what it offers
+//! (`ws_list -l`) and the tooling's own output is parsed.
+//!
+//! This module is what lets Eldrun put a remote project's tree **in a workspace
+//! instead of `$HOME`** before a single byte is uploaded or synced — the wizard's
+//! Workspace step simply makes the allocated path the project's remote root, so
+//! every existing transport (SFTP upload, byte-sync, git lockstep) lands on the
+//! parallel filesystem with no change of its own.
+//!
+//! Structure mirrors `commands::slurm` (whose dispatch it reuses verbatim), with
+//! one addition: a workspace is usually allocated **before the project exists**,
+//! so every command takes an [`HpcWsTarget`] that is *either* a project (pooled
+//! ControlMaster, like SLURM) *or* a bare host (ad-hoc `run_ssh_auth`, exactly as
+//! `global_machine_usage_check` does for a project-free machine).
+//!
+//! **Security.** The scripts are embedded verbatim in `sh`, so every interpolated
+//! value is both **validated** (id/filesystem/link name charsets, day counts
+//! numeric and bounded, mail free of shell metacharacters) *and* `shell_quote`d.
+//! The pure parsers are unit-tested against captured tooling output.
+
+use serde::{Deserialize, Serialize};
+
+use crate::services::remote::{remote_target_for_dir, PRIMARY_HOST};
+use crate::services::ssh_exec::shell_quote;
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+/// One workspace filesystem the site offers (`ws_list -l`). `default` marks the
+/// one used when `ws_allocate` is given no `-F`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HpcWsFilesystem {
+    pub name: String,
+    pub default: bool,
+}
+
+/// Whether the host has the workspace tooling at all, and which filesystems it
+/// offers. `available: false` is the ordinary answer on a cluster without
+/// `hpc-workspace` (and on a plain SSH host) — the UI hides the step, it is not
+/// an error.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HpcWsInfo {
+    pub available: bool,
+    pub filesystems: Vec<HpcWsFilesystem>,
+}
+
+/// One workspace, as reported by `ws_list` (and by `ws_allocate` for a fresh one).
+/// Only `id` and `path` are guaranteed; every other field is whatever the site's
+/// tooling printed, because the detail lines differ between versions.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HpcWorkspace {
+    pub id: String,
+    pub path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub filesystem: Option<String>,
+    /// The tooling's own remaining-time phrasing, e.g. `"89 days 23 hours"`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub remaining: Option<String>,
+    /// Whole days left, lifted out of `remaining` when it starts with a day count.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub remaining_days: Option<i64>,
+    /// Extensions still available (each buys another duration).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extensions: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub expiration: Option<String>,
+}
+
+/// Where to run a workspace command. **Either** a project (`project_dir` +
+/// optional `host_id`, riding its pooled ControlMaster exactly as SLURM does)
+/// **or** a bare host (`host` + credentials, authenticated ad-hoc) — because the
+/// wizard allocates a workspace *before* the project it will hold exists.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HpcWsTarget {
+    pub project_dir: Option<String>,
+    pub host_id: Option<String>,
+    pub user: Option<String>,
+    pub host: Option<String>,
+    pub port: Option<u16>,
+    /// Single-use, never persisted here: the credential the wizard's login just
+    /// authenticated with. Omitted, a saved password (then key/agent auth) is used
+    /// — the same fallback `ssh_connect` applies.
+    pub password: Option<String>,
+}
+
+/// The `ws_allocate` request. `days` is mandatory on purpose: the tooling's own
+/// default when it is omitted is **one day**, which is the classic way to lose a
+/// workspace full of results overnight.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HpcWsAllocate {
+    pub id: String,
+    pub days: i64,
+    /// `-F`: the workspace filesystem. Omitted ⇒ the site default.
+    pub filesystem: Option<String>,
+    /// `-r`: send a reminder this many days before expiry (needs `mail`).
+    pub reminder_days: Option<i64>,
+    /// `-m`: the reminder address. Sites commonly only deliver to their own
+    /// domain, so a rejected address is the site's answer, not ours.
+    pub mail: Option<String>,
+    /// `-G`: make the workspace group-writable for this group.
+    pub group: Option<String>,
+    /// `-g`: make the workspace group-readable.
+    pub group_readable: Option<bool>,
+}
+
+// ── Dispatch ─────────────────────────────────────────────────────────────────
+
+/// Run `script` at the target and return its stdout. A project target reuses
+/// `commands::slurm`'s dispatch verbatim (pooled ControlMaster for a remote
+/// project, a local shell for a login node Eldrun runs on); a bare-host target
+/// authenticates ad-hoc like `global_machine_usage_check`.
+fn run_ws_script(target: &HpcWsTarget, script: &str) -> Result<String, String> {
+    if let Some(dir) = target
+        .project_dir
+        .as_deref()
+        .map(str::trim)
+        .filter(|d| !d.is_empty())
+    {
+        let host = target.host_id.as_deref().unwrap_or(PRIMARY_HOST);
+        return crate::commands::slurm::run_slurm_script(dir, host, script);
+    }
+    let host = target
+        .host
+        .as_deref()
+        .map(str::trim)
+        .filter(|h| !h.is_empty())
+        .ok_or_else(|| "no project or host given for the workspace command".to_string())?;
+    let user = target
+        .user
+        .clone()
+        .map(|u| u.trim().to_string())
+        .filter(|u| !u.is_empty());
+    use crate::services::remote_credentials as creds;
+    // The bare-host branch runs *before any project exists* — the Workspace step
+    // of the create flow, where the user has just typed this machine's address —
+    // so, like the project branch above (`run_slurm_script`), it is user-initiated
+    // and clears the dial policy for the argv `run_ssh_auth` builds.
+    let _dial = crate::services::ssh_common::user_dial(&user, host, target.port);
+    let account = creds::ssh_account(&user, host, target.port);
+    let password = target
+        .password
+        .clone()
+        .filter(|p| !p.is_empty())
+        .or_else(|| creds::get(&account));
+    crate::commands::ssh::run_ssh_auth(&user, host, target.port, password.as_deref(), &[script])
+}
+
+// ── Validation (defense in depth — every value is ALSO shell-quoted) ──────────
+
+/// A workspace id / filesystem / link name: printable, path-free, and made only
+/// of characters the tooling itself accepts. Rejecting here buys a readable error
+/// instead of a remote `ws_allocate` usage dump.
+fn validate_token(what: &str, value: &str) -> Result<String, String> {
+    let v = value.trim();
+    if v.is_empty() {
+        return Err(format!("no {what} given"));
+    }
+    if v.len() > 64 {
+        return Err(format!("{what} is too long (max 64 characters)"));
+    }
+    if v.starts_with('-') {
+        return Err(format!("{what} may not start with '-'"));
+    }
+    if !v
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-'))
+    {
+        return Err(format!(
+            "invalid {what} '{v}' — use letters, digits, '.', '_' or '-'"
+        ));
+    }
+    Ok(v.to_string())
+}
+
+/// A day count for an allocation/extension/reminder. Bounded so a typo can't ask
+/// for a decade; the site caps it further anyway.
+fn validate_days(what: &str, days: i64) -> Result<i64, String> {
+    if days < 1 || days > 3650 {
+        return Err(format!("{what} must be between 1 and 3650 days"));
+    }
+    Ok(days)
+}
+
+/// A reminder address: one token, an `@`, no shell metacharacters. (It is quoted
+/// too; this only turns a hostile-looking value into a clear error.)
+fn validate_mail(mail: &str) -> Result<String, String> {
+    let m = mail.trim();
+    if m.is_empty() {
+        return Err("no reminder address given".to_string());
+    }
+    if m.len() > 254
+        || m.chars().any(|c| c.is_whitespace())
+        || !m.contains('@')
+        || m.chars()
+            .any(|c| matches!(c, '\'' | '"' | '`' | '$' | ';' | '|' | '&' | '<' | '>'))
+    {
+        return Err(format!("invalid reminder address '{m}'"));
+    }
+    Ok(m.to_string())
+}
+
+/// An absolute host path (a workspace path we are about to link to). Quoted at
+/// use; validated so a relative or empty value fails locally.
+fn validate_abs_path(what: &str, path: &str) -> Result<String, String> {
+    let p = path.trim().trim_end_matches('/');
+    if p.is_empty() || !p.starts_with('/') {
+        return Err(format!("{what} must be an absolute path"));
+    }
+    if p.contains('\n') || p.contains('\0') {
+        return Err(format!("invalid {what} '{path}'"));
+    }
+    Ok(p.to_string())
+}
+
+// ── Scripts ──────────────────────────────────────────────────────────────────
+
+/// Separates the `ws_list` detail blocks from the `id\tpath` map appended after
+/// them, so one round trip yields both the human detail and an authoritative path
+/// per workspace (`ws_find`), whatever the site's `ws_list` layout is.
+const PATHS_MARKER: &str = "---ELDRUN-WS-PATHS---";
+/// Separates `ws_allocate`'s own output from the `ws_find` confirmation after it.
+const PATH_MARKER: &str = "---ELDRUN-WS-PATH---";
+
+/// `-F <fs>` when a filesystem was chosen, else nothing. Pre-validated + quoted.
+fn fs_flag(filesystem: Option<&str>) -> Result<String, String> {
+    match filesystem.map(str::trim).filter(|f| !f.is_empty()) {
+        None => Ok(String::new()),
+        Some(f) => {
+            let f = validate_token("filesystem", f)?;
+            Ok(format!(" -F {}", shell_quote(&f)))
+        }
+    }
+}
+
+// ── Pure parsers ─────────────────────────────────────────────────────────────
+
+/// Parse `ws_list -l` — the available workspace filesystems. Output is a header
+/// line plus one location per line, one of which may carry a `(default)` marker.
+/// Anything that isn't a bare location token (headers, `Info:`/`Error:` chatter)
+/// is skipped, so a site whose banner differs still yields a clean list.
+pub fn parse_ws_locations(stdout: &str) -> Vec<HpcWsFilesystem> {
+    let mut out: Vec<HpcWsFilesystem> = Vec::new();
+    for line in stdout.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.ends_with(':') || line.contains("://") {
+            continue;
+        }
+        let lower = line.to_ascii_lowercase();
+        if lower.starts_with("info")
+            || lower.starts_with("error")
+            || lower.starts_with("warning")
+            || lower.starts_with("available")
+        {
+            continue;
+        }
+        let Some(name) = line.split_whitespace().next() else {
+            continue;
+        };
+        if name.len() > 64
+            || !name
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-'))
+        {
+            continue;
+        }
+        if out.iter().any(|f| f.name == name) {
+            continue;
+        }
+        out.push(HpcWsFilesystem {
+            name: name.to_string(),
+            default: lower.contains("(default)"),
+        });
+    }
+    out
+}
+
+/// Lift the leading whole-day count out of a remaining-time phrase
+/// (`"89 days 23 hours"` → 89). `None` when it doesn't start with a number.
+fn leading_days(remaining: &str) -> Option<i64> {
+    let first = remaining.trim().split_whitespace().next()?;
+    first.parse::<i64>().ok()
+}
+
+/// Assign one `key : value` detail line onto a workspace. Keys are matched by
+/// *keyword*, not exact spelling, because they differ between tooling versions
+/// (`available extensions` vs `remaining extensions`, `remaining time` vs
+/// `remaining time in days`).
+fn apply_detail(ws: &mut HpcWorkspace, key: &str, value: &str) {
+    let k = key.trim().to_ascii_lowercase();
+    let v = value.trim();
+    if v.is_empty() {
+        return;
+    }
+    if k.contains("directory") || k.contains("workspace path") {
+        if ws.path.is_empty() {
+            ws.path = v.to_string();
+        }
+    } else if k.contains("filesystem") || k.contains("location") {
+        ws.filesystem = Some(v.to_string());
+    } else if k.contains("extension") {
+        ws.extensions = v.parse::<i64>().ok().or(ws.extensions);
+    } else if k.contains("expiration") || k.contains("expires") {
+        ws.expiration = Some(v.to_string());
+    } else if k.contains("remaining") {
+        if k.contains("in days") {
+            ws.remaining_days = v.parse::<i64>().ok().or(ws.remaining_days);
+            ws.remaining.get_or_insert_with(|| format!("{v} days"));
+        } else {
+            ws.remaining_days = leading_days(v).or(ws.remaining_days);
+            ws.remaining = Some(v.to_string());
+        }
+    }
+}
+
+/// Parse the two-part `ws_list` script output: the tooling's detail blocks
+/// (`Id: <name>` followed by indented `key : value` lines), then a
+/// [`PATHS_MARKER`]-separated `id\tpath` map from `ws_find`.
+///
+/// The map is what makes this robust: the *path* is the one field everything
+/// downstream depends on, and `ws_find` states it unambiguously whatever the
+/// listing looks like. A workspace present only in the map still appears (with no
+/// detail); a block whose path the map confirms is corrected.
+pub fn parse_ws_list(stdout: &str) -> Vec<HpcWorkspace> {
+    let (blocks, paths) = match stdout.split_once(PATHS_MARKER) {
+        Some((a, b)) => (a, b),
+        None => (stdout, ""),
+    };
+
+    let mut out: Vec<HpcWorkspace> = Vec::new();
+    for line in blocks.lines() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        // `Id: name` starts a new workspace block.
+        if let Some(rest) = trimmed
+            .strip_prefix("Id:")
+            .or_else(|| trimmed.strip_prefix("id:"))
+            .or_else(|| trimmed.strip_prefix("ID:"))
+        {
+            let id = rest.trim();
+            if !id.is_empty() {
+                out.push(HpcWorkspace {
+                    id: id.to_string(),
+                    ..Default::default()
+                });
+            }
+            continue;
+        }
+        // An indented `key : value` detail line belongs to the open block.
+        if line.starts_with(char::is_whitespace) {
+            if let Some((k, v)) = trimmed.split_once(':') {
+                if let Some(ws) = out.last_mut() {
+                    apply_detail(ws, k, v);
+                }
+            }
+        }
+    }
+
+    // `id<TAB>path` from `ws_find` — authoritative for the path, and the source
+    // of any workspace the block parse missed entirely.
+    for line in paths.lines() {
+        let Some((id, path)) = line.trim_end().split_once('\t') else {
+            continue;
+        };
+        let (id, path) = (id.trim(), path.trim());
+        if id.is_empty() || !path.starts_with('/') {
+            continue;
+        }
+        match out.iter_mut().find(|w| w.id == id) {
+            Some(ws) => ws.path = path.to_string(),
+            None => out.push(HpcWorkspace {
+                id: id.to_string(),
+                path: path.to_string(),
+                ..Default::default()
+            }),
+        }
+    }
+    out.retain(|w| !w.path.is_empty());
+    out
+}
+
+/// Parse the allocate script's output into the fresh workspace. The path is taken
+/// from the `ws_find` confirmation after [`PATH_MARKER`] when present (the
+/// tooling prints its path to stdout but its chatter to stderr, and a site could
+/// mix them), else from the first absolute-looking line of `ws_allocate`'s own
+/// output. `None` means no path was stated — the caller reports the raw output,
+/// which is where the site's refusal will be.
+pub fn parse_ws_allocate(id: &str, stdout: &str) -> Option<HpcWorkspace> {
+    let (head, tail) = match stdout.split_once(PATH_MARKER) {
+        Some((a, b)) => (a, b),
+        None => (stdout, ""),
+    };
+    let path = tail
+        .lines()
+        .map(str::trim)
+        .find(|l| l.starts_with('/'))
+        .or_else(|| {
+            head.lines()
+                .map(str::trim)
+                .find(|l| l.starts_with('/') && !l.contains(char::is_whitespace))
+        })?;
+    let mut ws = HpcWorkspace {
+        id: id.to_string(),
+        path: path.to_string(),
+        ..Default::default()
+    };
+    // `ws_allocate` prints its own `remaining …` lines; reuse the list parser's
+    // keyword matching so both surfaces read the same fields.
+    for line in head.lines() {
+        if let Some((k, v)) = line.split_once(':') {
+            if k.trim().to_ascii_lowercase().contains("remaining") {
+                apply_detail(&mut ws, k, v);
+            }
+        }
+    }
+    Some(ws)
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+//
+// Every command shells out (locally, over the pooled ControlMaster, or through an
+// ad-hoc ssh), which can block for as long as the host takes to answer. A
+// synchronous Tauri command runs on the MAIN thread and would freeze the window
+// (the bug `commands::git`/`commands::slurm` already fixed), so each is an async
+// wrapper around a blocking body.
+
+async fn run_off_thread<T: Send + 'static>(
+    f: impl FnOnce() -> Result<T, String> + Send + 'static,
+) -> Result<T, String> {
+    tokio::task::spawn_blocking(f)
+        .await
+        .map_err(|e| format!("workspace task failed: {e}"))?
+}
+
+/// Does this host hand out workspaces, and on which filesystems? Constant script.
+/// A host without the tooling answers `available: false` — never an error, since
+/// most hosts are not clusters.
+#[tauri::command]
+pub async fn hpc_ws_available(target: HpcWsTarget) -> Result<HpcWsInfo, String> {
+    run_off_thread(move || {
+        let script = "command -v ws_allocate >/dev/null 2>&1 || exit 0\n\
+                      printf 'ELDRUN-WS-OK\\n'\n\
+                      ws_list -l 2>/dev/null || true";
+        let stdout = run_ws_script(&target, script).unwrap_or_default();
+        if !stdout.contains("ELDRUN-WS-OK") {
+            return Ok(HpcWsInfo::default());
+        }
+        let rest = stdout.split_once("ELDRUN-WS-OK").map(|(_, b)| b).unwrap_or("");
+        Ok(HpcWsInfo {
+            available: true,
+            filesystems: parse_ws_locations(rest),
+        })
+    })
+    .await
+}
+
+/// The caller's existing workspaces. Constant script: `ws_list` for the detail,
+/// then `ws_find` per id for an authoritative path — one round trip.
+#[tauri::command]
+pub async fn hpc_ws_list(target: HpcWsTarget) -> Result<Vec<HpcWorkspace>, String> {
+    run_off_thread(move || {
+        let script = format!(
+            "command -v ws_list >/dev/null 2>&1 || exit 0\n\
+             ws_list 2>/dev/null || true\n\
+             printf '%s\\n' '{PATHS_MARKER}'\n\
+             ws_list -s 2>/dev/null | while IFS= read -r wsid; do\n\
+             \x20 [ -n \"$wsid\" ] || continue\n\
+             \x20 case \"$wsid\" in *:*|*' '*) continue;; esac\n\
+             \x20 wspath=$(ws_find \"$wsid\" 2>/dev/null | tail -n 1)\n\
+             \x20 case \"$wspath\" in /*) printf '%s\\t%s\\n' \"$wsid\" \"$wspath\";; esac\n\
+             done"
+        );
+        let stdout = run_ws_script(&target, &script)?;
+        Ok(parse_ws_list(&stdout))
+    })
+    .await
+}
+
+/// Allocate a workspace (`ws_allocate <id> <days>`), then confirm its path with
+/// `ws_find` in the same round trip. Every interpolated value is validated above
+/// and `shell_quote`d here.
+#[tauri::command]
+pub async fn hpc_ws_allocate(
+    target: HpcWsTarget,
+    req: HpcWsAllocate,
+) -> Result<HpcWorkspace, String> {
+    run_off_thread(move || {
+        let id = validate_token("workspace name", &req.id)?;
+        let days = validate_days("duration", req.days)?;
+        let fs = fs_flag(req.filesystem.as_deref())?;
+
+        let mut opts = String::new();
+        if let Some(mail) = req.mail.as_deref().map(str::trim).filter(|m| !m.is_empty()) {
+            let mail = validate_mail(mail)?;
+            opts.push_str(&format!(" -m {}", shell_quote(&mail)));
+            let reminder = validate_days("reminder", req.reminder_days.unwrap_or(7))?;
+            opts.push_str(&format!(" -r {reminder}"));
+        } else if let Some(r) = req.reminder_days {
+            // A reminder with no address still works when the site's
+            // `~/.ws_user.conf` carries one.
+            opts.push_str(&format!(" -r {}", validate_days("reminder", r)?));
+        }
+        if let Some(group) = req.group.as_deref().map(str::trim).filter(|g| !g.is_empty()) {
+            let group = validate_token("group", group)?;
+            opts.push_str(&format!(" -G {}", shell_quote(&group)));
+        } else if req.group_readable.unwrap_or(false) {
+            opts.push_str(" -g");
+        }
+
+        let q_id = shell_quote(&id);
+        let script = format!(
+            "command -v ws_allocate >/dev/null 2>&1 || {{ printf '%s\\n' \
+             'this host has no ws_allocate (no workspace tooling)' >&2; exit 1; }}\n\
+             out=$(ws_allocate{fs}{opts} {q_id} {days} 2>&1) || {{ printf '%s\\n' \"$out\" >&2; exit 1; }}\n\
+             printf '%s\\n' \"$out\"\n\
+             printf '%s\\n' '{PATH_MARKER}'\n\
+             ws_find{fs} {q_id} 2>/dev/null | tail -n 1"
+        );
+        let stdout = run_ws_script(&target, &script)?;
+        parse_ws_allocate(&id, &stdout).ok_or_else(|| {
+            format!(
+                "ws_allocate did not report a workspace path:\n{}",
+                stdout.trim()
+            )
+        })
+    })
+    .await
+}
+
+/// Extend a workspace by `days`, spending one of its extensions. Prefers
+/// `ws_extend`, falling back to `ws_allocate -x` (older tooling has only the
+/// latter). The same `-F` used at allocation must be repeated, so the caller
+/// passes the workspace's own filesystem.
+#[tauri::command]
+pub async fn hpc_ws_extend(
+    target: HpcWsTarget,
+    id: String,
+    days: i64,
+    filesystem: Option<String>,
+) -> Result<HpcWorkspace, String> {
+    run_off_thread(move || {
+        let id = validate_token("workspace name", &id)?;
+        let days = validate_days("duration", days)?;
+        let fs = fs_flag(filesystem.as_deref())?;
+        let q_id = shell_quote(&id);
+        let script = format!(
+            "if command -v ws_extend >/dev/null 2>&1; then\n\
+             \x20 out=$(ws_extend{fs} {q_id} {days} 2>&1) || {{ printf '%s\\n' \"$out\" >&2; exit 1; }}\n\
+             elif command -v ws_allocate >/dev/null 2>&1; then\n\
+             \x20 out=$(ws_allocate -x{fs} {q_id} {days} 2>&1) || {{ printf '%s\\n' \"$out\" >&2; exit 1; }}\n\
+             else\n\
+             \x20 printf '%s\\n' 'this host has no workspace tooling' >&2; exit 1\n\
+             fi\n\
+             printf '%s\\n' \"$out\"\n\
+             printf '%s\\n' '{PATH_MARKER}'\n\
+             ws_find{fs} {q_id} 2>/dev/null | tail -n 1"
+        );
+        let stdout = run_ws_script(&target, &script)?;
+        parse_ws_allocate(&id, &stdout)
+            .ok_or_else(|| format!("could not extend '{id}':\n{}", stdout.trim()))
+    })
+    .await
+}
+
+/// Release a workspace. The data is not deleted immediately (sites keep it for a
+/// grace period and `ws_restore` can recover it), but the directory goes away —
+/// so the UI must confirm before calling this.
+#[tauri::command]
+pub async fn hpc_ws_release(
+    target: HpcWsTarget,
+    id: String,
+    filesystem: Option<String>,
+) -> Result<(), String> {
+    run_off_thread(move || {
+        let id = validate_token("workspace name", &id)?;
+        let fs = fs_flag(filesystem.as_deref())?;
+        let script = format!(
+            "command -v ws_release >/dev/null 2>&1 || {{ printf '%s\\n' \
+             'this host has no ws_release' >&2; exit 1; }}\n\
+             out=$(ws_release{fs} {} 2>&1) || {{ printf '%s\\n' \"$out\" >&2; exit 1; }}\n\
+             printf '%s\\n' \"$out\"",
+            shell_quote(&id)
+        );
+        run_ws_script(&target, &script)?;
+        Ok(())
+    })
+    .await
+}
+
+/// Symlink a workspace into a project's remote root (`<remote_path>/<link_name>
+/// -> <workspace_path>`) — for the layout where the project itself stays in
+/// `$HOME` (code, git) and only the bulk data lives in the workspace, so a job
+/// script can write to `./<link_name>` without knowing the site's path.
+///
+/// **The link is for the host's own tools, not for Eldrun's byte-sync**, which
+/// never follows a symlink (`remote_sync::walk_host_files`, guard G3): files the
+/// job writes under it are not mirrored. That is exactly why the wizard's default
+/// is instead to put the project *in* the workspace, where every transport
+/// already works unchanged.
+#[tauri::command]
+pub async fn hpc_ws_link(
+    project_dir: String,
+    workspace_path: String,
+    link_name: String,
+) -> Result<String, String> {
+    run_off_thread(move || {
+        let ws = validate_abs_path("workspace path", &workspace_path)?;
+        let name = validate_token("link name", &link_name)?;
+        let root = remote_target_for_dir(&project_dir)
+            .map(|t| t.spec.remote_path.trim_end_matches('/').to_string())
+            .ok_or_else(|| "not a remote project".to_string())?;
+        let dest = format!("{root}/{name}");
+        let script = format!(
+            "[ -d {ws} ] || {{ printf '%s\\n' 'workspace path does not exist' >&2; exit 1; }}\n\
+             if [ -e {dest} ] && [ ! -L {dest} ]; then\n\
+             \x20 printf '%s\\n' 'a real file or folder of that name already exists' >&2; exit 1\n\
+             fi\n\
+             ln -sfn {ws} {dest}",
+            ws = shell_quote(&ws),
+            dest = shell_quote(&dest),
+        );
+        run_ws_script(
+            &HpcWsTarget {
+                project_dir: Some(project_dir.clone()),
+                ..Default::default()
+            },
+            &script,
+        )?;
+        Ok(dest)
+    })
+    .await
+}
+
+// ── Big-filesystem candidates for a cluster WITHOUT workspace tooling ────────
+
+/// A directory the site itself nominates as the place for bulk data — the
+/// `hpc-workspace`-less cluster's answer to "where does this project go".
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ScratchCandidate {
+    /// `env` (an environment variable the site's profile exports) or `path` (a
+    /// conventional location that turned out to exist).
+    pub source: String,
+    /// `$SCRATCH`, `$WORK`, … or the convention's own name.
+    pub label: String,
+    pub path: String,
+    pub writable: bool,
+    /// Free space in KiB from `df -Pk`, when it answered.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub free_kb: Option<u64>,
+}
+
+/// The environment variables clusters use to point at their big filesystem. This
+/// list is the ONE site-shaped thing in this module, and it is deliberately just
+/// a list of *names to ask about* — the site's own profile decides which exist
+/// and what they mean, exactly as `ws_list -l` does at a workspace site. Ordered
+/// by how specifically each usually means "bulk working data".
+const SCRATCH_VARS: &[&str] = &[
+    "SCRATCH",
+    "WORK",
+    "WORKDIR",
+    "WRKDIR",
+    "BIGWORK",
+    "PROJECT",
+    "FASTDATA",
+    "DATA",
+];
+
+/// Parse the candidate probe's `source\tlabel\tpath\twritable\tfree` lines,
+/// dropping duplicates by path (a site commonly points two variables at one
+/// directory) and anything malformed.
+pub fn parse_scratch_candidates(stdout: &str) -> Vec<ScratchCandidate> {
+    let mut out: Vec<ScratchCandidate> = Vec::new();
+    for line in stdout.lines() {
+        let f: Vec<&str> = line.trim_end().split('\t').collect();
+        if f.len() < 4 {
+            continue;
+        }
+        let path = f[2].trim().trim_end_matches('/');
+        if !path.starts_with('/') || f[1].trim().is_empty() {
+            continue;
+        }
+        if out.iter().any(|c| c.path == path) {
+            continue;
+        }
+        out.push(ScratchCandidate {
+            source: f[0].trim().to_string(),
+            label: f[1].trim().to_string(),
+            path: path.to_string(),
+            writable: f[3].trim() == "yes",
+            free_kb: f.get(4).and_then(|v| v.trim().parse::<u64>().ok()),
+        });
+    }
+    out
+}
+
+/// Ask a cluster **without** workspace tooling where its bulk data belongs.
+///
+/// This is what keeps the pipeline honest at a site that has SLURM but no
+/// `ws_allocate`: without it the project would land in the browsed folder — i.e.
+/// `$HOME` — which is the exact failure the whole workspace step exists to
+/// prevent. Nothing about a site is assumed: the probe asks whether the *site's
+/// own profile* exports one of the usual variables, then falls back to the two
+/// conventional locations, and reports only directories that actually exist.
+/// Writability is stated rather than filtered on, because a read-only hit is
+/// still information (it is usually the group's shared tree, not yours).
+#[tauri::command]
+pub async fn hpc_scratch_candidates(
+    target: HpcWsTarget,
+) -> Result<Vec<ScratchCandidate>, String> {
+    run_off_thread(move || {
+        // `eval` only ever expands a name from SCRATCH_VARS, and every value is
+        // handled as data (quoted `"$p"`), never re-evaluated.
+        let vars = SCRATCH_VARS.join(" ");
+        let script = format!(
+            "probe() {{\n\
+             \x20 [ -d \"$3\" ] || return 0\n\
+             \x20 w=no; [ -w \"$3\" ] && w=yes\n\
+             \x20 free=$(df -Pk \"$3\" 2>/dev/null | awk 'NR==2 {{print $4}}')\n\
+             \x20 printf '%s\\t%s\\t%s\\t%s\\t%s\\n' \"$1\" \"$2\" \"$3\" \"$w\" \"${{free:-}}\"\n\
+             }}\n\
+             for v in {vars}; do\n\
+             \x20 eval p=\\$$v\n\
+             \x20 case \"$p\" in /*) probe env \"\\$$v\" \"$p\";; esac\n\
+             done\n\
+             for p in \"/scratch/$USER\" \"/work/$USER\" \"/lustre/$USER\"; do\n\
+             \x20 probe path \"$p\" \"$p\"\n\
+             done"
+        );
+        let stdout = run_ws_script(&target, &script).unwrap_or_default();
+        Ok(parse_scratch_candidates(&stdout))
+    })
+    .await
+}
+
+// ── The home anchor (Phase 1) ────────────────────────────────────────────────
+
+/// The small per-project folder kept in the user's cluster **home**, holding what
+/// must outlive the workspace: the job logs, a `cd`-able link to the workspace,
+/// and an append-only record naming it. Returned with every path resolved
+/// absolutely, because `$HOME` is only known on the host.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HpcAnchor {
+    pub dir: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logs_dir: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub link: Option<String>,
+}
+
+/// A `$HOME`-relative anchor location (`eldrun/my-project`): plain path segments,
+/// no absolute path, no `..`, no metacharacters. Validated rather than merely
+/// quoted so a slip can't write outside the user's home.
+fn validate_anchor_rel(rel: &str) -> Result<String, String> {
+    let r = rel.trim().trim_matches('/');
+    if r.is_empty() {
+        return Err("no anchor folder given".to_string());
+    }
+    if r.len() > 128 {
+        return Err("anchor folder path is too long".to_string());
+    }
+    for seg in r.split('/') {
+        // `validate_token` permits '.' inside a name (`my.project`), so the
+        // traversal segments have to be rejected on their own.
+        if seg == "." || seg == ".." {
+            return Err("anchor folder path may not contain '.' or '..'".to_string());
+        }
+        validate_token("anchor folder", seg)?;
+    }
+    Ok(r.to_string())
+}
+
+/// Create (idempotently) the project's home anchor: `$HOME/<anchor_rel>` with a
+/// `logs/` subfolder, a `workspace` symlink to the workspace path, and a line
+/// appended to `workspaces.txt`.
+///
+/// The record is **append-only and deliberately plain text**: a project moves
+/// through several workspaces over a year, and the previous names are what
+/// `ws_restore` needs after an expiry — a file that got overwritten each time
+/// would answer "which workspace held the runs from March?" with the wrong one.
+/// It notes the local mirror path too, so the cluster side says which machine
+/// holds the durable copy.
+///
+/// Refuses to replace a real file/directory named `workspace` (only its own
+/// symlink is re-pointed), so an anchor folder someone put real data in is never
+/// clobbered.
+#[tauri::command]
+pub async fn hpc_ws_anchor(
+    target: HpcWsTarget,
+    anchor_rel: String,
+    workspace_path: Option<String>,
+    workspace_id: Option<String>,
+    project_name: String,
+    mirror_path: Option<String>,
+    make_logs: Option<bool>,
+) -> Result<HpcAnchor, String> {
+    run_off_thread(move || {
+        let rel = validate_anchor_rel(&anchor_rel)?;
+        let logs = make_logs.unwrap_or(true);
+        let ws_path = match workspace_path.as_deref().map(str::trim).filter(|p| !p.is_empty()) {
+            Some(p) => Some(validate_abs_path("workspace path", p)?),
+            None => None,
+        };
+        // Free text only ever reaches the host inside single quotes; newlines are
+        // stripped so a name cannot forge a second record line.
+        let clean = |s: &str| s.replace(['\n', '\r'], " ").trim().to_string();
+        let name = clean(&project_name);
+        let ws_id = workspace_id.as_deref().map(clean).unwrap_or_default();
+        let mirror = mirror_path.as_deref().map(clean).unwrap_or_default();
+
+        let mut script = format!(
+            "dir=\"$HOME\"/{rel}\n\
+             mkdir -p \"$dir\" || exit 1\n",
+            rel = shell_quote(&rel),
+        );
+        if logs {
+            script.push_str("mkdir -p \"$dir/logs\" || exit 1\n");
+        }
+        if let Some(p) = &ws_path {
+            script.push_str(&format!(
+                "if [ -e \"$dir/workspace\" ] && [ ! -L \"$dir/workspace\" ]; then\n\
+                 \x20 printf '%s\\n' 'a real file named workspace is already there' >&2; exit 1\n\
+                 fi\n\
+                 ln -sfn {ws} \"$dir/workspace\" || exit 1\n",
+                ws = shell_quote(p),
+            ));
+        }
+        script.push_str(&format!(
+            "{{ printf '%s  project=%s  workspace=%s  path=%s  mirror=%s\\n' \
+             \"$(date -u '+%Y-%m-%dT%H:%M:%SZ')\" {name} {id} {path} {mirror}; }} \
+             >> \"$dir/workspaces.txt\" || exit 1\n\
+             printf '%s\\n' \"$dir\"",
+            name = shell_quote(&name),
+            id = shell_quote(&ws_id),
+            path = shell_quote(ws_path.as_deref().unwrap_or("")),
+            mirror = shell_quote(&mirror),
+        ));
+
+        let stdout = run_ws_script(&target, &script)?;
+        let dir = stdout
+            .lines()
+            .map(str::trim)
+            .rev()
+            .find(|l| l.starts_with('/'))
+            .ok_or_else(|| format!("could not create the home folder:\n{}", stdout.trim()))?
+            .to_string();
+        Ok(HpcAnchor {
+            logs_dir: logs.then(|| format!("{dir}/logs")),
+            link: ws_path.map(|_| format!("{dir}/workspace")),
+            dir,
+        })
+    })
+    .await
+}
+
+/// Persist a project's workspace/anchor record. Writes BOTH the `projects.json`
+/// entry's `extra["hpc"]` (what the frontend reads on load) and the `project.json`
+/// `hpc` field, exactly as `set_project_run_host` does for its own value.
+#[tauri::command]
+pub fn set_project_hpc(
+    project_id: String,
+    hpc: Option<crate::schema::project::HpcInfo>,
+) -> Result<(), String> {
+    use crate::schema::projects::ProjectsList;
+    use crate::storage;
+
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    match &hpc {
+        Some(info) => {
+            let value = serde_json::to_value(info).map_err(|e| e.to_string())?;
+            entry.extra.insert("hpc".into(), value);
+        }
+        None => {
+            entry.extra.remove("hpc");
+        }
+    }
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    let proj_path = std::path::PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<crate::schema::project::Project>(&proj_path) {
+            project.hpc = hpc.clone();
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+/// Copy the anchor's `logs/` into the local mirror's `logs/` — the provenance
+/// record on the machine the user actually reads logs on. Small by construction
+/// (SLURM out/err only), so it is a plain per-file SFTP read, not a sync pass;
+/// nothing is deleted locally and an unreadable file is skipped rather than
+/// failing the batch. Returns how many files were copied.
+#[tauri::command]
+pub async fn hpc_ws_pull_logs(
+    pool: tauri::State<'_, crate::services::remote::RemotePoolState>,
+    project_id: String,
+    logs_dir: String,
+) -> Result<u32, String> {
+    let dir = validate_abs_path("logs folder", &logs_dir)?;
+    let sftp = crate::services::remote::pooled_sftp(pool.inner(), &project_id)
+        .await
+        .ok_or_else(|| "remote project is not connected".to_string())?;
+    let entries = crate::services::sftp::list_dir_on(&sftp, &dir).await?;
+    let local_root = crate::services::remote_sync::mirror_dir(&project_id).join("logs");
+    std::fs::create_dir_all(&local_root).map_err(|e| e.to_string())?;
+    let mut copied = 0u32;
+    for entry in entries {
+        if entry.is_dir {
+            continue;
+        }
+        let remote = format!("{dir}/{}", entry.name);
+        let Ok(bytes) = crate::services::sftp::read_file_on(&sftp, &remote).await else {
+            continue;
+        };
+        if std::fs::write(local_root.join(&entry.name), &bytes).is_ok() {
+            copied += 1;
+        }
+    }
+    Ok(copied)
+}
+
+// ── Moving the project to another workspace (Phase 2) ────────────────────────
+
+/// Re-point a remote project's **primary** root at `new_root` — the action a
+/// workspace expiry makes inevitable, and which nothing else in Eldrun could do
+/// (a primary's `remote_path` is fixed at creation; the remote-machines hub's
+/// path field only adds worker hosts).
+///
+/// It rewrites the pointers and **resets the pairing bases**, nothing more:
+///  - `project.json`'s `remote.remote_path` and the `projects.json` entry's
+///    mirrored `extra["remote"]`, which is the source of truth every caller reads;
+///  - git lockstep's state back to a fresh `enabled` (the next pass re-seeds the
+///    new, empty host repo from the mirror — the same one-directional seed
+///    `extend_project_to_remote` relies on, and safe for the same reason);
+///  - the byte-sync manifest's per-file **bases** (host size/mtime + transfer
+///    timestamps), keeping every marker (`selected`/`auto`/`excluded`). Left in
+///    place they would claim the new root already holds files it does not, and
+///    the safe-direction policy would read that as "host deleted them".
+///
+/// The local mirror — the durable copy — is never touched, which is exactly why
+/// losing a workspace costs a re-pair rather than the work. The caller must
+/// disconnect and reconnect the project around this: the pool caches the spec.
+#[tauri::command]
+pub async fn hpc_ws_move_root(
+    project_id: String,
+    new_root: String,
+) -> Result<crate::schema::projects::ProjectEntry, String> {
+    run_off_thread(move || {
+        use crate::schema::projects::ProjectsList;
+        use crate::storage;
+
+        let root = validate_abs_path("project root", &new_root)?;
+        let target = crate::services::remote::remote_target_for(&project_id)
+            .ok_or_else(|| "not a remote project".to_string())?;
+        if target.spec.remote_path.trim_end_matches('/') == root {
+            return Err("the project is already there".to_string());
+        }
+
+        // Create the destination before anything is rewritten: a failure here must
+        // leave the project pointing at a root that still exists.
+        crate::services::ssh_exec::run_remote_shell(
+            &target.spec,
+            &format!("mkdir -p {}", shell_quote(&root)),
+        )
+        .and_then(|out| {
+            if out.status.success() {
+                Ok(())
+            } else {
+                Err(String::from_utf8_lossy(&out.stderr).trim().to_string())
+            }
+        })
+        .map_err(|e| format!("could not create '{root}' on the host: {e}"))?;
+
+        let list_path = storage::state_dir().join("projects.json");
+        let mut list: ProjectsList = if list_path.exists() {
+            storage::read_json(&list_path).map_err(|e| e.to_string())?
+        } else {
+            return Err("project not found".to_string());
+        };
+        let entry = list
+            .iter_mut()
+            .find(|p| p.id == project_id)
+            .ok_or_else(|| format!("project '{project_id}' not found"))?;
+
+        let mut spec = target.spec.clone();
+        spec.remote_path = root.clone();
+        let value = serde_json::to_value(&spec).map_err(|e| e.to_string())?;
+        entry.extra.insert("remote".to_string(), value);
+        let local_file = entry.local_file.clone();
+        let updated = entry.clone();
+        storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+        let proj_path = std::path::PathBuf::from(&local_file);
+        if proj_path.exists() {
+            if let Ok(mut project) = storage::read_json::<crate::schema::project::Project>(&proj_path)
+            {
+                project.remote = Some(spec.clone());
+                storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+            }
+        }
+
+        // Lockstep: keep the opt-in, drop every cached head/signature so the next
+        // pass pairs the empty new root instead of trusting the old one's refs.
+        let prev = crate::services::git_peer::load_state(&project_id);
+        let reset = crate::services::git_peer::GitPeerState {
+            enabled: prev.enabled,
+            ..Default::default()
+        };
+        if let Err(e) = crate::services::git_peer::save_state(&project_id, &reset) {
+            eprintln!("hpc_ws_move_root: could not reset lockstep state: {e}");
+        }
+
+        // Byte-sync: markers stay (they are the user's consent), bases clear.
+        let mut manifest = crate::services::remote_sync::load_manifest(&project_id);
+        for entry in manifest.values_mut() {
+            entry.host_size = 0;
+            entry.host_mtime = None;
+            entry.local_size = 0;
+            entry.local_mtime = None;
+            entry.last_pull_ts = None;
+            entry.last_push_ts = None;
+        }
+        if let Err(e) = crate::services::remote_sync::save_manifest(&project_id, &manifest) {
+            eprintln!("hpc_ws_move_root: could not reset sync bases: {e}");
+        }
+
+        Ok(updated)
+    })
+    .await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scratch_candidates_are_parsed_and_deduped_by_path() {
+        // Two variables pointing at one directory is normal at a site that keeps
+        // an alias; the picker must not offer the same place twice.
+        let out = "env\t$SCRATCH\t/scratch/alice\tyes\t123456\n\
+                   env\t$WORK\t/scratch/alice/\tyes\t123456\n\
+                   env\t$PROJECT\t/project/grp\tno\t\n\
+                   path\t/work/alice\t/work/alice\tyes\t9\n\
+                   garbage\n\
+                   env\t$X\trelative/path\tyes\t1\n";
+        let c = parse_scratch_candidates(out);
+        assert_eq!(c.len(), 3);
+        assert_eq!(c[0].label, "$SCRATCH");
+        assert_eq!(c[0].path, "/scratch/alice");
+        assert_eq!(c[0].free_kb, Some(123456));
+        assert!(c[0].writable);
+        // Reported, not filtered: a read-only hit is still information.
+        assert_eq!(c[1].path, "/project/grp");
+        assert!(!c[1].writable);
+        assert_eq!(c[1].free_kb, None);
+        assert_eq!(c[2].source, "path");
+    }
+
+    #[test]
+    fn anchor_rel_is_home_relative_and_path_safe() {
+        assert_eq!(validate_anchor_rel("eldrun/my-project").unwrap(), "eldrun/my-project");
+        assert_eq!(validate_anchor_rel("/eldrun/p/").unwrap(), "eldrun/p");
+        assert!(validate_anchor_rel("../../etc").is_err());
+        assert!(validate_anchor_rel("a/../b").is_err());
+        assert!(validate_anchor_rel("a b").is_err());
+        assert!(validate_anchor_rel("").is_err());
+    }
+
+    #[test]
+    fn locations_are_lifted_and_default_marked() {
+        let out = "available filesystems:\nscratch (default)\nmlnvme\nproject\n";
+        let fs = parse_ws_locations(out);
+        assert_eq!(fs.len(), 3);
+        assert_eq!(fs[0].name, "scratch");
+        assert!(fs[0].default);
+        assert_eq!(fs[1].name, "mlnvme");
+        assert!(!fs[1].default);
+    }
+
+    #[test]
+    fn locations_skip_chatter_and_duplicates() {
+        let out = "Info: something\nError: nope\nscratch\nscratch\n\n";
+        let fs = parse_ws_locations(out);
+        assert_eq!(fs.len(), 1);
+        assert_eq!(fs[0].name, "scratch");
+    }
+
+    #[test]
+    fn ws_list_blocks_and_path_map_merge() {
+        let out = "Id: demo\n    \
+                   workspace directory  : /lustre/scratch/data/alice-demo\n    \
+                   remaining time       : 89 days 23 hours\n    \
+                   creation time        : Mon Jul 21 10:00:00 2026\n    \
+                   expiration date      : Sun Oct 19 10:00:00 2026\n    \
+                   filesystem name      : scratch\n    \
+                   available extensions : 3\n\
+                   Id: fast\n    \
+                   workspace directory  : /lustre/mlnvme/data/alice-fast\n    \
+                   remaining time       : 5 days 1 hours\n    \
+                   filesystem name      : mlnvme\n\
+                   ---ELDRUN-WS-PATHS---\n\
+                   demo\t/lustre/scratch/data/alice-demo\n\
+                   fast\t/lustre/mlnvme/data/alice-fast\n";
+        let ws = parse_ws_list(out);
+        assert_eq!(ws.len(), 2);
+        assert_eq!(ws[0].id, "demo");
+        assert_eq!(ws[0].path, "/lustre/scratch/data/alice-demo");
+        assert_eq!(ws[0].filesystem.as_deref(), Some("scratch"));
+        assert_eq!(ws[0].remaining_days, Some(89));
+        assert_eq!(ws[0].extensions, Some(3));
+        assert_eq!(ws[0].expiration.as_deref(), Some("Sun Oct 19 10:00:00 2026"));
+        assert_eq!(ws[1].id, "fast");
+        assert_eq!(ws[1].remaining_days, Some(5));
+    }
+
+    #[test]
+    fn ws_find_map_is_authoritative_and_adds_missed_workspaces() {
+        // The listing's own path is stale/absent; the map states the truth, and a
+        // workspace only in the map still shows up.
+        let out = "Id: demo\n    remaining time : 3 days\n\
+                   ---ELDRUN-WS-PATHS---\n\
+                   demo\t/lustre/scratch/data/alice-demo\n\
+                   extra\t/lustre/scratch/data/alice-extra\n";
+        let ws = parse_ws_list(out);
+        assert_eq!(ws.len(), 2);
+        assert_eq!(ws[0].path, "/lustre/scratch/data/alice-demo");
+        assert_eq!(ws[0].remaining_days, Some(3));
+        assert_eq!(ws[1].id, "extra");
+        assert_eq!(ws[1].path, "/lustre/scratch/data/alice-extra");
+    }
+
+    #[test]
+    fn ws_list_drops_pathless_entries() {
+        // Without a path there is nothing the UI could do with the row.
+        assert!(parse_ws_list("Id: demo\n    remaining time : 3 days\n").is_empty());
+        assert!(parse_ws_list("").is_empty());
+    }
+
+    #[test]
+    fn allocate_takes_the_ws_find_path_and_details() {
+        let out = "Info: creating workspace.\n\
+                   /lustre/scratch/data/alice-demo\n\
+                   remaining extensions  : 3\n\
+                   remaining time in days: 90\n\
+                   ---ELDRUN-WS-PATH---\n\
+                   /lustre/scratch/data/alice-demo\n";
+        let ws = parse_ws_allocate("demo", out).expect("path");
+        assert_eq!(ws.id, "demo");
+        assert_eq!(ws.path, "/lustre/scratch/data/alice-demo");
+        assert_eq!(ws.extensions, Some(3));
+        assert_eq!(ws.remaining_days, Some(90));
+    }
+
+    #[test]
+    fn allocate_falls_back_to_the_tools_own_path_line() {
+        let out = "Info: creating workspace.\n/lustre/scratch/data/alice-demo\n";
+        let ws = parse_ws_allocate("demo", out).expect("path");
+        assert_eq!(ws.path, "/lustre/scratch/data/alice-demo");
+    }
+
+    #[test]
+    fn allocate_without_a_path_is_none() {
+        assert!(parse_ws_allocate("demo", "Error: quota exceeded\n").is_none());
+        assert!(parse_ws_allocate("demo", "").is_none());
+    }
+
+    #[test]
+    fn tokens_reject_injection_and_flags() {
+        assert!(validate_token("workspace name", "my-ws_1.2").is_ok());
+        assert!(validate_token("workspace name", "a b").is_err());
+        assert!(validate_token("workspace name", "x;rm -rf /").is_err());
+        assert!(validate_token("workspace name", "../escape").is_err());
+        assert!(validate_token("workspace name", "-F").is_err());
+        assert!(validate_token("workspace name", "  ").is_err());
+    }
+
+    #[test]
+    fn days_are_bounded() {
+        assert!(validate_days("duration", 1).is_ok());
+        assert!(validate_days("duration", 0).is_err());
+        assert!(validate_days("duration", 4000).is_err());
+    }
+
+    #[test]
+    fn mail_rejects_metacharacters() {
+        assert!(validate_mail("a.user@example.org").is_ok());
+        assert!(validate_mail("a user@example.org").is_err());
+        assert!(validate_mail("a@b$(id)").is_err());
+        assert!(validate_mail("nodomain").is_err());
+    }
+
+    #[test]
+    fn abs_paths_only() {
+        assert_eq!(
+            validate_abs_path("workspace path", "/lustre/x/").unwrap(),
+            "/lustre/x"
+        );
+        assert!(validate_abs_path("workspace path", "relative/x").is_err());
+        assert!(validate_abs_path("workspace path", "").is_err());
+    }
+
+    #[test]
+    fn fs_flag_is_quoted_or_empty() {
+        assert_eq!(fs_flag(None).unwrap(), "");
+        assert_eq!(fs_flag(Some("  ")).unwrap(), "");
+        assert_eq!(fs_flag(Some("mlnvme")).unwrap(), " -F 'mlnvme'");
+        assert!(fs_flag(Some("a;b")).is_err());
+    }
+
+    #[test]
+    fn leading_days_parsing() {
+        assert_eq!(leading_days("89 days 23 hours"), Some(89));
+        assert_eq!(leading_days("0 days"), Some(0));
+        assert_eq!(leading_days("expired"), None);
+    }
+}
diff --git a/src-tauri/src/commands/local_loss.rs b/src-tauri/src/commands/local_loss.rs
new file mode 100644
index 0000000..0111deb
--- /dev/null
+++ b/src-tauri/src/commands/local_loss.rs
@@ -0,0 +1,26 @@
+//! Tauri commands for the local-loss warning log (#28q).
+//!
+//! Thin wrappers over `services::local_loss`, which is where the doc comment explaining
+//! *why* this is a file rather than an event lives. The frontend re-reads the log
+//! whenever a lockstep or sync pass reports in, so a deletion that happened during a
+//! background pass — or while the app was closed — still surfaces.
+
+use crate::services::local_loss::{self, LocalLoss};
+
+/// Every recorded local loss for a project, newest first. Empty for a local project (it
+/// has no mirror to lose anything from) and for the overwhelming majority of remote ones.
+#[tauri::command]
+pub async fn local_loss_list(project_id: String) -> Result<Vec<LocalLoss>, String> {
+    Ok(local_loss::load(&project_id))
+}
+
+/// Mark every entry seen (the dialog's "Got it"). The entries stay on disk — acking is
+/// permanent, and a user who dismissed a 3am deletion can still read
+/// `remote-projects/<id>/local_loss.json` to find out which files it took. (A UI to
+/// browse the history would live next to the backup-ref list in `GitHistory`; there
+/// isn't one yet, which is why there is no "clear" command either.)
+#[tauri::command]
+pub async fn local_loss_ack(project_id: String) -> Result<(), String> {
+    local_loss::ack_all(&project_id);
+    Ok(())
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index f7a0492..76a2905 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -1,23 +1,47 @@
+pub mod agents;
 pub mod apps;
 pub mod boxes;
+pub mod calendar;
 pub mod clipboard;
 pub mod crash;
+pub mod credentials;
 pub mod debug;
 pub mod default_apps;
-pub mod downloads;
+pub mod disk_usage;
+pub mod format;
 pub mod fs;
 pub mod fs_watch;
 pub mod git;
-pub mod github;
+pub mod git_fork;
+pub mod git_hosting;
+pub mod git_peer;
+pub mod git_publish;
+pub mod global_machines;
+pub mod hpc_ws;
+pub mod local_loss;
+pub mod monitor;
+pub mod net_usage;
+pub mod network;
 pub mod ollama;
+pub mod pdf_clip;
+pub mod power;
+pub mod presenter;
 pub mod openvpn;
 pub mod project_runtime;
+pub mod python;
 pub mod projects;
+pub mod remote;
 pub mod screenshot;
+pub mod search;
 pub mod settings;
+pub mod sheets;
+pub mod slurm;
+pub mod sqlite;
 pub mod ssh;
 pub mod subwindow;
+pub mod sync;
 pub mod terminal;
 pub mod tex;
 pub mod timer;
+pub mod usage_stats;
 pub mod workspace;
diff --git a/src-tauri/src/commands/monitor.rs b/src-tauri/src/commands/monitor.rs
new file mode 100644
index 0000000..565c96a
--- /dev/null
+++ b/src-tauri/src/commands/monitor.rs
@@ -0,0 +1,89 @@
+//! Whole-system resource snapshot for the htop-like monitor pane.
+//!
+//! A single read-only command: it returns one cumulative [`SystemSnapshot`]
+//! (every process + per-core CPU + memory/swap/load). Live CPU/MEM percentages
+//! are derived on the frontend by diffing two successive snapshots, so — unlike
+//! the per-project readout in `commands::debug` — there is no in-command sleep or
+//! shared sampler state to race between panes. Sampling itself lives in
+//! [`crate::sysstat`]; this is just the Tauri surface.
+
+use crate::gpustat::{self, GpuProc, GpuSample};
+use crate::sysstat::{self, SystemSnapshot};
+
+/// One whole-system sample. `supported` is `false` on non-Linux targets, where
+/// the pane shows a "Linux only" placeholder instead of an empty table.
+///
+/// `project_id` selects the machine, mirroring `disk_usage_scan`: when it names a
+/// project with a `remote` spec, the sample is taken on the **host** — its `/proc`
+/// read over the shared ControlMaster (`REMOTE_SNAPSHOT_SCRIPT`) and assembled by
+/// the same pure parsers — inside `spawn_blocking` so the SSH round-trip never
+/// runs on the UI thread. Any other value (a local project, `None`, or a project
+/// with no remote) samples this machine. `host_id` picks which of the project's
+/// hosts to sample (primary or a `compute_hosts` worker); defaults to the primary
+/// (`remote::PRIMARY_HOST`), mirroring every other multi-host command. The pane
+/// passes `project_id` only while its source toggle points at a host; a
+/// disconnected host is gated out on the frontend, so a dead pool is never dialed
+/// here.
+///
+/// `careful` selects the collection mode, and is authoritative in **both**
+/// directions: `true` = the reduced careful collection (no foreign account
+/// names, argv, GPU processes or sessions leave the host), `false` = the full
+/// reading a local sample gets. It is the machine's stored mode — careful for
+/// every remote machine until the user says that one is theirs, keyed by SSH
+/// target in `settings.careful_hosts` (`src/lib/carefulHost.ts`) — so the pane
+/// passes it on every poll and the answer holds from the first sample.
+///
+/// `None` means the caller has no answer to pass, and only then does anything
+/// guess: the host's own SLURM probe, plus this process's memory of what earlier
+/// probes of the same target found ([`crate::services::hpc_mode`]). That memory
+/// deliberately does **not** override an explicit `false` — it exists to stop a
+/// flaky *probe* from talking a cluster down, not to overrule the user.
+#[tauri::command]
+pub async fn system_monitor_snapshot(
+    project_id: Option<String>,
+    host_id: Option<String>,
+    careful: Option<bool>,
+) -> Result<SystemSnapshot, String> {
+    let host_id = host_id.unwrap_or_else(|| crate::services::remote::PRIMARY_HOST.to_string());
+    if let Some(target) = project_id
+        .as_deref()
+        .and_then(|pid| crate::services::remote::remote_target_for_host(pid, &host_id))
+    {
+        let spec = target.spec.clone();
+        let key = crate::services::hpc_mode::key_for(&spec);
+        let mode = careful.or_else(|| {
+            crate::services::hpc_mode::is_known_careful(&key).then_some(true)
+        });
+        return tokio::task::spawn_blocking(move || {
+            let out = crate::services::ssh_exec::run_remote_script(
+                &spec,
+                &sysstat::remote_snapshot_script(mode),
+            )?;
+            let snap = sysstat::parse_remote_snapshot(&String::from_utf8_lossy(&out.stdout));
+            crate::services::hpc_mode::remember(&key, snap.careful);
+            Ok::<_, String>(snap)
+        })
+        .await
+        .map_err(|e| e.to_string())?;
+    }
+    Ok(sysstat::system_snapshot())
+}
+
+/// GPU memory alone, for callers that want the device's memory without paying
+/// for a whole process table (the local-model menu, which asks "what headroom is
+/// left before I load this?"). Reads the same [`gpustat`] cache the snapshot
+/// does. An empty list means no GPU could be read, not that there is no GPU.
+#[tauri::command]
+pub async fn gpu_memory_snapshot() -> Result<Vec<GpuSample>, String> {
+    Ok(gpustat::snapshot())
+}
+
+/// Per-process GPU memory for the monitor pane's process breakdown. A separate,
+/// heavier read (a `/proc` `fdinfo` walk for amdgpu, a `nvidia-smi` spawn for
+/// compute clients) than the whole-device snapshot, so only the pane calls it —
+/// the always-visible header readout never pays for it. Local-only and best-effort:
+/// an empty list means "no per-process data available", not "no GPU processes".
+#[tauri::command]
+pub async fn gpu_process_snapshot() -> Result<Vec<GpuProc>, String> {
+    Ok(gpustat::process_snapshot())
+}
diff --git a/src-tauri/src/commands/net_usage.rs b/src-tauri/src/commands/net_usage.rs
new file mode 100644
index 0000000..dd82ae7
--- /dev/null
+++ b/src-tauri/src/commands/net_usage.rs
@@ -0,0 +1,40 @@
+use std::collections::HashMap;
+
+use serde::Serialize;
+
+use crate::schema::net_usage::{self, ByteCounts, FileCounts};
+
+/// Persisted SSH-link byte and FILE-count totals for one project, at both
+/// stored granularities. The frontend derives every window from these:
+/// this-hour from `hours`/`fileHours`; today, this week, this month and
+/// overall from `days`/`fileDays`.
+#[derive(Debug, Clone, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NetUsageReport {
+    /// "YYYY-MM-DDTHH" (UTC) → { rx, tx }, over the retained hour window.
+    pub hours: HashMap<String, ByteCounts>,
+    /// "YYYY-MM-DD" (UTC) → { rx, tx }, full history.
+    pub days: HashMap<String, ByteCounts>,
+    /// "YYYY-MM-DDTHH" (UTC) → { down, up } files transferred, over the
+    /// retained hour window.
+    pub file_hours: HashMap<String, FileCounts>,
+    /// "YYYY-MM-DD" (UTC) → { down, up } files transferred, full history.
+    pub file_days: HashMap<String, FileCounts>,
+}
+
+/// Per-hour and per-date SSH-link byte and file-count totals for `project_id`
+/// (or every project when empty). All four maps come from one load, so a flush
+/// between them can never leave the views disagreeing. Recording is internal
+/// (bytes from the `services::net_usage` sampler, file counts from the sync
+/// engine), so there is no companion write command — mirrors
+/// `commands::timer::get_project_activity`.
+#[tauri::command]
+pub fn get_net_usage(project_id: String) -> NetUsageReport {
+    let summary = net_usage::load();
+    NetUsageReport {
+        hours: summary.hourly_for(&project_id),
+        days: summary.activity_for(&project_id),
+        file_hours: summary.hourly_files_for(&project_id),
+        file_days: summary.activity_files_for(&project_id),
+    }
+}
diff --git a/src-tauri/src/commands/network.rs b/src-tauri/src/commands/network.rs
new file mode 100644
index 0000000..a80df50
--- /dev/null
+++ b/src-tauri/src/commands/network.rs
@@ -0,0 +1,797 @@
+//! Read-only network monitoring for project tabs.
+//!
+//! A local project observes the local Linux host. A remote project observes its
+//! SSH host by riding the already-authenticated ControlMaster; it never opens a
+//! connection on its own. The separate SSH-link snapshot is collected locally
+//! from the ControlMaster's TCP socket so it includes every multiplexed channel
+//! (terminal, SFTP, sync, git).
+
+#[cfg(target_os = "linux")]
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::Serialize;
+use tauri::State;
+
+use crate::services::remote::{self, RemotePoolState};
+
+const REMOTE_IFACES: &str = "test -r /proc/net/dev || exit 42; \
+printf '__ELDRUN_IFACES__\\n'; cat /proc/net/dev; \
+printf '__ELDRUN_STATES__\\n'; \
+for p in /sys/class/net/*; do test -e \"$p\" || continue; \
+printf '%s ' \"${p##*/}\"; cat \"$p/operstate\" 2>/dev/null || printf 'unknown\\n'; done";
+const REMOTE_WITH_CONNECTIONS: &str = "test -r /proc/net/dev || exit 42; \
+printf '__ELDRUN_IFACES__\\n'; cat /proc/net/dev; \
+printf '__ELDRUN_STATES__\\n'; \
+for p in /sys/class/net/*; do test -e \"$p\" || continue; \
+printf '%s ' \"${p##*/}\"; cat \"$p/operstate\" 2>/dev/null || printf 'unknown\\n'; done; \
+printf '__ELDRUN_CONNECTIONS__\\n'; \
+if command -v ss >/dev/null 2>&1; then LC_ALL=C ss -H -tuna -p 2>/dev/null || true; \
+else printf '__ELDRUN_NO_SS__\\n'; fi";
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NetworkInterface {
+    pub name: String,
+    pub rx_bytes: u64,
+    pub tx_bytes: u64,
+    pub up: bool,
+    pub loopback: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NetworkConnection {
+    pub protocol: String,
+    pub state: String,
+    pub local_address: String,
+    pub local_port: String,
+    pub remote_address: String,
+    pub remote_port: String,
+    pub pid: Option<u32>,
+    pub process: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NetworkHostSnapshot {
+    pub supported: bool,
+    pub remote: bool,
+    pub connected: bool,
+    pub sampled_at_ms: u64,
+    pub host_label: String,
+    pub interfaces: Vec<NetworkInterface>,
+    pub connections: Option<Vec<NetworkConnection>>,
+    pub warning: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SshLinkSnapshot {
+    pub supported: bool,
+    pub connected: bool,
+    pub sampled_at_ms: u64,
+    pub connection_id: Option<String>,
+    pub rx_bytes: u64,
+    pub tx_bytes: u64,
+    pub local_endpoint: Option<String>,
+    pub remote_endpoint: Option<String>,
+    pub warning: Option<String>,
+}
+
+fn now_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as u64
+}
+
+fn unsupported_host(
+    remote: bool,
+    connected: bool,
+    host_label: String,
+    warning: &str,
+) -> NetworkHostSnapshot {
+    NetworkHostSnapshot {
+        supported: false,
+        remote,
+        connected,
+        sampled_at_ms: now_ms(),
+        host_label,
+        interfaces: Vec::new(),
+        connections: None,
+        warning: Some(warning.to_string()),
+    }
+}
+
+fn split_endpoint(value: &str) -> (String, String) {
+    let value = value.trim();
+    if let Some(rest) = value.strip_prefix('[') {
+        if let Some((address, port)) = rest.rsplit_once("]:") {
+            return (address.to_string(), port.to_string());
+        }
+    }
+    value
+        .rsplit_once(':')
+        .map(|(address, port)| (address.to_string(), port.to_string()))
+        .unwrap_or_else(|| (value.to_string(), String::new()))
+}
+
+fn process_meta(text: &str) -> (Option<u32>, Option<String>) {
+    let pid = text
+        .find("pid=")
+        .and_then(|start| {
+            text[start + 4..]
+                .split(|c: char| !c.is_ascii_digit())
+                .next()
+        })
+        .and_then(|v| v.parse().ok());
+    let process = text
+        .find("((\"")
+        .and_then(|start| {
+            let tail = &text[start + 3..];
+            tail.find('"').map(|end| tail[..end].to_string())
+        })
+        .filter(|v| !v.is_empty());
+    (pid, process)
+}
+
+fn parse_interfaces(text: &str) -> Vec<NetworkInterface> {
+    text.lines()
+        .filter_map(|line| {
+            let (name, counters) = line.rsplit_once(':')?;
+            let name = name.trim();
+            if name.is_empty() || name == "Inter-| Receive" {
+                return None;
+            }
+            let fields: Vec<&str> = counters.split_whitespace().collect();
+            let rx_bytes = fields.first()?.parse().ok()?;
+            let tx_bytes = fields.get(8)?.parse().ok()?;
+            Some(NetworkInterface {
+                name: name.to_string(),
+                rx_bytes,
+                tx_bytes,
+                // Remote snapshots do not make an extra round trip for operstate.
+                // An interface present in /proc is selectable; the local path
+                // replaces this with the kernel's current state below.
+                up: true,
+                loopback: name == "lo",
+            })
+        })
+        .collect()
+}
+
+fn parse_connections(text: &str) -> Vec<NetworkConnection> {
+    text.lines()
+        .filter_map(|line| {
+            let fields: Vec<&str> = line.split_whitespace().collect();
+            if fields.len() < 6 {
+                return None;
+            }
+            let protocol = fields[0].to_ascii_uppercase();
+            if protocol != "TCP" && protocol != "UDP" {
+                return None;
+            }
+            let (local_address, local_port) = split_endpoint(fields[4]);
+            let (remote_address, remote_port) = split_endpoint(fields[5]);
+            let meta = fields.get(6..).unwrap_or_default().join(" ");
+            let (pid, process) = process_meta(&meta);
+            Some(NetworkConnection {
+                protocol,
+                state: fields[1].to_string(),
+                local_address,
+                local_port,
+                remote_address,
+                remote_port,
+                pid,
+                process,
+            })
+        })
+        .collect()
+}
+
+fn parse_remote_snapshot(
+    output: &str,
+    host_label: String,
+    include_connections: bool,
+) -> NetworkHostSnapshot {
+    let Some(after_ifaces) = output.split_once("__ELDRUN_IFACES__\n").map(|(_, v)| v) else {
+        return unsupported_host(
+            true,
+            true,
+            host_label,
+            "The SSH host does not expose Linux /proc network counters.",
+        );
+    };
+    let (iface_text, after_states) = after_ifaces
+        .split_once("__ELDRUN_STATES__\n")
+        .unwrap_or((after_ifaces, ""));
+    let (state_text, connection_text) = after_states
+        .split_once("__ELDRUN_CONNECTIONS__\n")
+        .map(|(a, b)| (a, Some(b)))
+        .unwrap_or((after_states, None));
+    let states: std::collections::HashMap<&str, &str> = state_text
+        .lines()
+        .filter_map(|line| line.split_once(' '))
+        .map(|(name, state)| (name.trim(), state.trim()))
+        .collect();
+    let mut interfaces = parse_interfaces(iface_text);
+    for iface in &mut interfaces {
+        iface.up = states
+            .get(iface.name.as_str())
+            .map(|state| matches!(*state, "up" | "unknown"))
+            .unwrap_or(true);
+    }
+    if interfaces.is_empty() {
+        return unsupported_host(
+            true,
+            true,
+            host_label,
+            "No Linux network interfaces were available on the SSH host.",
+        );
+    }
+    let no_ss = connection_text.is_some_and(|v| v.contains("__ELDRUN_NO_SS__"));
+    NetworkHostSnapshot {
+        supported: true,
+        remote: true,
+        connected: true,
+        sampled_at_ms: now_ms(),
+        host_label,
+        interfaces,
+        connections: if include_connections && !no_ss {
+            Some(parse_connections(connection_text.unwrap_or_default()))
+        } else {
+            None
+        },
+        warning: no_ss.then(|| {
+            "`ss` is unavailable on the SSH host; connection details are hidden.".to_string()
+        }),
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn local_snapshot(include_connections: bool) -> NetworkHostSnapshot {
+    let proc_net = match std::fs::read_to_string("/proc/net/dev") {
+        Ok(v) => v,
+        Err(e) => {
+            return unsupported_host(
+                false,
+                true,
+                "Local host".to_string(),
+                &format!("Cannot read /proc/net/dev: {e}"),
+            );
+        }
+    };
+    let mut interfaces = parse_interfaces(&proc_net);
+    for iface in &mut interfaces {
+        iface.up = std::fs::read_to_string(format!("/sys/class/net/{}/operstate", iface.name))
+            .map(|v| matches!(v.trim(), "up" | "unknown"))
+            .unwrap_or(true);
+    }
+
+    let (connections, warning) = if include_connections {
+        match crate::paths::command_no_window("ss")
+            .args(["-H", "-tuna", "-p"])
+            .env("LC_ALL", "C")
+            .output()
+        {
+            Ok(out) if out.status.success() => (
+                Some(parse_connections(&String::from_utf8_lossy(&out.stdout))),
+                None,
+            ),
+            Ok(out) => {
+                let message = String::from_utf8_lossy(&out.stderr).trim().to_string();
+                (
+                    None,
+                    Some(if message.is_empty() {
+                        "`ss` could not list connections.".to_string()
+                    } else {
+                        message
+                    }),
+                )
+            }
+            Err(_) => (
+                None,
+                Some("`ss` is unavailable; connection details are hidden.".to_string()),
+            ),
+        }
+    } else {
+        (None, None)
+    };
+
+    NetworkHostSnapshot {
+        supported: true,
+        remote: false,
+        connected: true,
+        sampled_at_ms: now_ms(),
+        host_label: "Local host".to_string(),
+        interfaces,
+        connections,
+        warning,
+    }
+}
+
+/// Decode a NUL-terminated UTF-16 buffer (a `MIB_IF_ROW2.Alias`) to a String.
+#[cfg(any(target_os = "windows", test))]
+fn utf16_nul_to_string(units: &[u16]) -> String {
+    let len = units.iter().position(|&u| u == 0).unwrap_or(units.len());
+    String::from_utf16_lossy(&units[..len])
+}
+
+/// Local interface counters via `GetIfTable2`. Per-connection details need a
+/// `GetExtendedTcpTable`/`GetExtendedUdpTable` port that is not written yet, so
+/// `connections` stays `None` with an explanatory warning (the pane renders
+/// interfaces and hides the connection table).
+#[cfg(target_os = "windows")]
+fn local_snapshot(_include_connections: bool) -> NetworkHostSnapshot {
+    use windows::Win32::NetworkManagement::IpHelper::{FreeMibTable, GetIfTable2, MIB_IF_TABLE2};
+    use windows::Win32::NetworkManagement::Ndis::IfOperStatusUp;
+
+    /// IANA ifType 24 = softwareLoopback (`IF_TYPE_SOFTWARE_LOOPBACK`).
+    const IF_TYPE_SOFTWARE_LOOPBACK: u32 = 24;
+
+    let mut table: *mut MIB_IF_TABLE2 = std::ptr::null_mut();
+    // SAFETY: GetIfTable2 allocates the table it points `table` at; it is read
+    // within NumEntries bounds and released with FreeMibTable on every path
+    // where it was set.
+    let interfaces = unsafe {
+        if GetIfTable2(&mut table).is_err() || table.is_null() {
+            Vec::new()
+        } else {
+            let rows =
+                std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize);
+            let interfaces = rows
+                .iter()
+                .filter_map(|row| {
+                    let name = utf16_nul_to_string(&row.Alias);
+                    // Skip alias-less rows (filter/lightweight interfaces); a
+                    // user-visible adapter always carries an alias.
+                    if name.is_empty() {
+                        return None;
+                    }
+                    Some(NetworkInterface {
+                        name,
+                        rx_bytes: row.InOctets,
+                        tx_bytes: row.OutOctets,
+                        up: row.OperStatus == IfOperStatusUp,
+                        loopback: row.Type == IF_TYPE_SOFTWARE_LOOPBACK,
+                    })
+                })
+                .collect();
+            FreeMibTable(table as *const core::ffi::c_void);
+            interfaces
+        }
+    };
+    if interfaces.is_empty() {
+        return unsupported_host(
+            false,
+            true,
+            "Local host".to_string(),
+            "No network interfaces could be enumerated.",
+        );
+    }
+    NetworkHostSnapshot {
+        supported: true,
+        remote: false,
+        connected: true,
+        sampled_at_ms: now_ms(),
+        host_label: "Local host".to_string(),
+        interfaces,
+        connections: None,
+        warning: Some("Connection details are not yet collected on Windows.".to_string()),
+    }
+}
+
+/// Parse `netstat -ibn` output into per-interface byte counters. Only the
+/// `<Link#N>` rows are interface totals (per-address rows repeat the counters
+/// per bound address and carry no `<Link#…>` cell). The Address column is
+/// EMPTY for some link rows (`lo0`, `gif0`, …), so columns are indexed from
+/// the END of the row: … Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll — Ibytes
+/// is `len-5` and Obytes `len-2`. Loopback = name starts with "lo"; operstate
+/// isn't in this output, so `up` stays true (an interface present in the
+/// table is selectable — same convention as the remote /proc path).
+#[cfg(any(target_os = "macos", test))]
+fn parse_netstat_ibn(text: &str) -> Vec<NetworkInterface> {
+    text.lines()
+        .filter_map(|line| {
+            if !line.contains("<Link#") {
+                return None;
+            }
+            let fields: Vec<&str> = line.split_whitespace().collect();
+            if fields.len() < 8 {
+                return None;
+            }
+            let name = *fields.first()?;
+            let rx_bytes = fields.get(fields.len() - 5)?.parse().ok()?;
+            let tx_bytes = fields.get(fields.len() - 2)?.parse().ok()?;
+            Some(NetworkInterface {
+                name: name.to_string(),
+                rx_bytes,
+                tx_bytes,
+                up: true,
+                loopback: name.starts_with("lo"),
+            })
+        })
+        .collect()
+}
+
+/// Local interface counters via `netstat -ibn` (spawned, not the raw
+/// `NET_RT_IFLIST2` sysctl — hand-declared route-message layouts are silent-
+/// garbage risk on a compile-blind port; the netstat text format is stable and
+/// fixture-tested). Connection details are not collected yet, mirroring the
+/// Windows arm.
+#[cfg(target_os = "macos")]
+fn local_snapshot(_include_connections: bool) -> NetworkHostSnapshot {
+    let output = match crate::paths::command_no_window("netstat")
+        .args(["-ibn"])
+        .env("LC_ALL", "C")
+        .output()
+    {
+        Ok(out) if out.status.success() => out,
+        _ => {
+            return unsupported_host(
+                false,
+                true,
+                "Local host".to_string(),
+                "`netstat -ibn` could not enumerate network interfaces.",
+            );
+        }
+    };
+    let interfaces = parse_netstat_ibn(&String::from_utf8_lossy(&output.stdout));
+    if interfaces.is_empty() {
+        return unsupported_host(
+            false,
+            true,
+            "Local host".to_string(),
+            "No network interfaces could be enumerated.",
+        );
+    }
+    NetworkHostSnapshot {
+        supported: true,
+        remote: false,
+        connected: true,
+        sampled_at_ms: now_ms(),
+        host_label: "Local host".to_string(),
+        interfaces,
+        connections: None,
+        warning: Some("Connection details are not yet collected on macOS.".to_string()),
+    }
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
+fn local_snapshot(_include_connections: bool) -> NetworkHostSnapshot {
+    unsupported_host(
+        false,
+        true,
+        "Local host".to_string(),
+        "Network monitoring is not supported on this platform yet.",
+    )
+}
+
+#[tauri::command]
+pub async fn network_host_snapshot(
+    pool: State<'_, RemotePoolState>,
+    project_id: String,
+    include_connections: bool,
+) -> Result<NetworkHostSnapshot, String> {
+    let Some(target) = remote::remote_target_for(&project_id) else {
+        return Ok(local_snapshot(include_connections));
+    };
+    let host_label = target.spec.host.clone();
+    if !remote::is_connected(pool.inner(), &project_id).await {
+        return Ok(unsupported_host(
+            true,
+            false,
+            host_label,
+            "Connect the SSH project to observe its remote host.",
+        ));
+    }
+    let spec = target.spec;
+    let command = if include_connections {
+        REMOTE_WITH_CONNECTIONS
+    } else {
+        REMOTE_IFACES
+    };
+    let output = tokio::task::spawn_blocking(move || {
+        crate::services::ssh_exec::run_remote_shell(&spec, command)
+    })
+    .await
+    .map_err(|e| format!("network snapshot task failed: {e}"))??;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Ok(unsupported_host(
+            true,
+            true,
+            host_label,
+            if stderr.is_empty() {
+                "The SSH host does not support the Linux network collector."
+            } else {
+                &stderr
+            },
+        ));
+    }
+    Ok(parse_remote_snapshot(
+        &String::from_utf8_lossy(&output.stdout),
+        host_label,
+        include_connections,
+    ))
+}
+
+fn parse_master_pid(text: &str) -> Option<u32> {
+    let start = text.find("pid=")?;
+    text[start + 4..]
+        .split(|c: char| !c.is_ascii_digit())
+        .next()?
+        .parse()
+        .ok()
+}
+
+#[cfg(target_os = "linux")]
+pub(crate) fn linux_ssh_link(project_id: &str) -> SshLinkSnapshot {
+    let Some(target) = remote::remote_target_for(project_id) else {
+        return SshLinkSnapshot {
+            supported: false,
+            connected: false,
+            sampled_at_ms: now_ms(),
+            connection_id: None,
+            rx_bytes: 0,
+            tx_bytes: 0,
+            local_endpoint: None,
+            remote_endpoint: None,
+            warning: Some("SSH-link traffic is only available for remote projects.".to_string()),
+        };
+    };
+    let check =
+        match crate::services::ssh_exec::ssh_control_check_args(&target.spec).and_then(|args| {
+            crate::paths::command_no_window("ssh")
+                .args(args)
+                .output()
+                .map_err(|e| format!("failed to inspect SSH ControlMaster: {e}"))
+        }) {
+            Ok(v) => v,
+            Err(e) => {
+                return SshLinkSnapshot {
+                    supported: true,
+                    connected: false,
+                    sampled_at_ms: now_ms(),
+                    connection_id: None,
+                    rx_bytes: 0,
+                    tx_bytes: 0,
+                    local_endpoint: None,
+                    remote_endpoint: None,
+                    warning: Some(e),
+                };
+            }
+        };
+    let check_text = format!(
+        "{}\n{}",
+        String::from_utf8_lossy(&check.stdout),
+        String::from_utf8_lossy(&check.stderr)
+    );
+    let Some(master_pid) = parse_master_pid(&check_text) else {
+        return SshLinkSnapshot {
+            supported: true,
+            connected: false,
+            sampled_at_ms: now_ms(),
+            connection_id: None,
+            rx_bytes: 0,
+            tx_bytes: 0,
+            local_endpoint: None,
+            remote_endpoint: None,
+            warning: Some("The shared SSH transport is not connected.".to_string()),
+        };
+    };
+
+    let output = Command::new("ss")
+        .args(["-H", "-t", "-i", "-n", "-p"])
+        .env("LC_ALL", "C")
+        .output();
+    let Ok(output) = output else {
+        return SshLinkSnapshot {
+            supported: false,
+            connected: true,
+            sampled_at_ms: now_ms(),
+            connection_id: Some(master_pid.to_string()),
+            rx_bytes: 0,
+            tx_bytes: 0,
+            local_endpoint: None,
+            remote_endpoint: None,
+            warning: Some(
+                "`ss` is unavailable; SSH-link byte counters cannot be read.".to_string(),
+            ),
+        };
+    };
+    let parsed = parse_ssh_link_ss(&String::from_utf8_lossy(&output.stdout), master_pid);
+    parsed.unwrap_or_else(|| SshLinkSnapshot {
+        supported: true,
+        connected: true,
+        sampled_at_ms: now_ms(),
+        connection_id: Some(master_pid.to_string()),
+        rx_bytes: 0,
+        tx_bytes: 0,
+        local_endpoint: None,
+        remote_endpoint: None,
+        warning: Some(
+            "The SSH socket is connected, but its byte counters are not visible.".to_string(),
+        ),
+    })
+}
+
+#[cfg(not(target_os = "linux"))]
+fn linux_ssh_link(_project_id: &str) -> SshLinkSnapshot {
+    SshLinkSnapshot {
+        supported: false,
+        connected: false,
+        sampled_at_ms: now_ms(),
+        connection_id: None,
+        rx_bytes: 0,
+        tx_bytes: 0,
+        local_endpoint: None,
+        remote_endpoint: None,
+        warning: Some("SSH-link monitoring is currently supported on Linux.".to_string()),
+    }
+}
+
+fn counter(text: &str, key: &str) -> Option<u64> {
+    let start = text.find(key)?;
+    text[start + key.len()..]
+        .split(|c: char| !c.is_ascii_digit())
+        .next()?
+        .parse()
+        .ok()
+}
+
+fn parse_ssh_link_ss(text: &str, master_pid: u32) -> Option<SshLinkSnapshot> {
+    let needle = format!("pid={master_pid},");
+    let lines: Vec<&str> = text.lines().collect();
+    for (index, line) in lines.iter().enumerate() {
+        if !line.contains(&needle) {
+            continue;
+        }
+        let fields: Vec<&str> = line.split_whitespace().collect();
+        if fields.len() < 5 {
+            continue;
+        }
+        let info = lines.get(index + 1).copied().unwrap_or_default();
+        let tx_bytes = counter(info, "bytes_sent:")?;
+        let rx_bytes = counter(info, "bytes_received:")?;
+        return Some(SshLinkSnapshot {
+            supported: true,
+            connected: true,
+            sampled_at_ms: now_ms(),
+            connection_id: Some(format!("{master_pid}:{}:{}", fields[3], fields[4])),
+            rx_bytes,
+            tx_bytes,
+            local_endpoint: Some(fields[3].to_string()),
+            remote_endpoint: Some(fields[4].to_string()),
+            warning: None,
+        });
+    }
+    None
+}
+
+#[tauri::command]
+pub async fn network_ssh_link_snapshot(
+    pool: State<'_, RemotePoolState>,
+    project_id: String,
+) -> Result<SshLinkSnapshot, String> {
+    if remote::remote_target_for(&project_id).is_none() {
+        return Ok(linux_ssh_link(&project_id));
+    }
+    if !remote::is_connected(pool.inner(), &project_id).await {
+        return Ok(SshLinkSnapshot {
+            supported: cfg!(target_os = "linux"),
+            connected: false,
+            sampled_at_ms: now_ms(),
+            connection_id: None,
+            rx_bytes: 0,
+            tx_bytes: 0,
+            local_endpoint: None,
+            remote_endpoint: None,
+            warning: Some("Connect the SSH project to observe its link.".to_string()),
+        });
+    }
+    tokio::task::spawn_blocking(move || linux_ssh_link(&project_id))
+        .await
+        .map_err(|e| format!("SSH-link snapshot task failed: {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_proc_interfaces() {
+        let input = "Inter-| Receive | Transmit\n face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed\n  lo: 100 1 0 0 0 0 0 0 200 2 0 0 0 0 0 0\neth0: 1234 2 0 0 0 0 0 0 5678 4 0 0 0 0 0 0\n";
+        let parsed = parse_interfaces(input);
+        assert_eq!(parsed.len(), 2);
+        assert!(parsed[0].loopback);
+        assert_eq!(parsed[1].name, "eth0");
+        assert_eq!(parsed[1].rx_bytes, 1234);
+        assert_eq!(parsed[1].tx_bytes, 5678);
+    }
+
+    #[test]
+    fn parses_ipv4_ipv6_and_optional_processes() {
+        let input = "tcp ESTAB 0 0 127.0.0.1:51000 10.0.0.2:22 users:((\"ssh\",pid=42,fd=3))\nudp UNCONN 0 0 [::]:5353 [::]:*\n";
+        let parsed = parse_connections(input);
+        assert_eq!(parsed.len(), 2);
+        assert_eq!(parsed[0].process.as_deref(), Some("ssh"));
+        assert_eq!(parsed[0].pid, Some(42));
+        assert_eq!(parsed[1].local_address, "::");
+        assert_eq!(parsed[1].remote_port, "*");
+    }
+
+    #[test]
+    fn parses_netstat_ibn_link_rows() {
+        // Real `netstat -ibn` shape: header, a Link row WITHOUT an Address
+        // cell (lo0), per-address rows that repeat counters (must be skipped),
+        // and a Link row WITH a MAC address (en0).
+        let input = "\
+Name  Mtu   Network       Address            Ipkts Ierrs     Ibytes    Opkts Oerrs     Obytes  Coll
+lo0   16384 <Link#1>                         354628     0   82789666   354628     0   82789666     0
+lo0   16384 127           127.0.0.1          354628     -   82789666   354628     -   82789666     -
+lo0   16384 ::1/128     ::1                  354628     -   82789666   354628     -   82789666     -
+en0   1500  <Link#4>    a4:83:e7:00:11:22  1755892     0 1863340029  1084887     0  212930751     0
+en0   1500  192.168.1     192.168.1.23       1755892     - 1863340029  1084887     -  212930751     -
+utun0 1380  <Link#16>                            123     0      45678      321     0      98765     0
+";
+        let parsed = parse_netstat_ibn(input);
+        assert_eq!(parsed.len(), 3, "only <Link#N> rows are interface totals");
+        assert_eq!(parsed[0].name, "lo0");
+        assert!(parsed[0].loopback);
+        assert_eq!(parsed[0].rx_bytes, 82_789_666);
+        assert_eq!(parsed[0].tx_bytes, 82_789_666);
+        assert_eq!(parsed[1].name, "en0");
+        assert!(!parsed[1].loopback);
+        assert_eq!(parsed[1].rx_bytes, 1_863_340_029);
+        assert_eq!(parsed[1].tx_bytes, 212_930_751);
+        assert_eq!(parsed[2].name, "utun0");
+        assert_eq!(parsed[2].rx_bytes, 45_678);
+        assert_eq!(parsed[2].tx_bytes, 98_765);
+        assert!(parsed.iter().all(|i| i.up));
+        // Garbage/empty input degrades to no interfaces, not a panic.
+        assert!(parse_netstat_ibn("").is_empty());
+        assert!(parse_netstat_ibn("Name Mtu\nen0 1500 broken").is_empty());
+    }
+
+    #[test]
+    fn utf16_alias_decoding_stops_at_nul() {
+        let mut alias = [0u16; 8];
+        for (i, u) in "Ethernet".encode_utf16().take(6).enumerate() {
+            alias[i] = u;
+        }
+        alias[6] = 0;
+        alias[7] = b'x' as u16; // garbage after the NUL must be ignored
+        assert_eq!(utf16_nul_to_string(&alias), "Ethern");
+        // No NUL at all → whole buffer.
+        let full: Vec<u16> = "lo".encode_utf16().collect();
+        assert_eq!(utf16_nul_to_string(&full), "lo");
+        assert_eq!(utf16_nul_to_string(&[]), "");
+    }
+
+    #[test]
+    fn parses_control_master_pid() {
+        assert_eq!(parse_master_pid("Master running (pid=8123)"), Some(8123));
+        assert_eq!(parse_master_pid("Control socket connect failed"), None);
+    }
+
+    #[test]
+    fn parses_ssh_transport_counters() {
+        let input = "ESTAB 0 0 192.0.2.2:40000 198.51.100.4:22 users:((\"ssh\",pid=8123,fd=3))\n\t cubic wscale:7,7 bytes_sent:4567 bytes_received:8910 segs_out:2\n";
+        let parsed = parse_ssh_link_ss(input, 8123).unwrap();
+        assert_eq!(parsed.tx_bytes, 4567);
+        assert_eq!(parsed.rx_bytes, 8910);
+        assert_eq!(parsed.remote_endpoint.as_deref(), Some("198.51.100.4:22"));
+    }
+
+    #[test]
+    fn remote_snapshot_without_ss_keeps_interface_data() {
+        let output = "__ELDRUN_IFACES__\neth0: 12 0 0 0 0 0 0 0 34 0 0 0 0 0 0 0\n__ELDRUN_STATES__\neth0 up\n__ELDRUN_CONNECTIONS__\n__ELDRUN_NO_SS__\n";
+        let parsed = parse_remote_snapshot(output, "host".to_string(), true);
+        assert!(parsed.supported);
+        assert!(parsed.interfaces[0].up);
+        assert!(parsed.connections.is_none());
+        assert!(parsed.warning.is_some());
+    }
+}
diff --git a/src-tauri/src/commands/ollama.rs b/src-tauri/src/commands/ollama.rs
index a4aed7a..392f57d 100644
--- a/src-tauri/src/commands/ollama.rs
+++ b/src-tauri/src/commands/ollama.rs
@@ -76,24 +76,419 @@ fn ollama_http(method: &str, path: &str, json_body: Option<&str>) -> Result<Stri
             .ok()
             .and_then(|v| v["error"].as_str().map(String::from))
             .unwrap_or_else(|| format!("HTTP {status}"));
-        return Err(msg);
+        return Err(friendly_ollama_error(&msg));
     }
 
     Ok(body)
 }
 
+/// Rewrite a raw Ollama error into a clearer, actionable message for the failure
+/// modes that otherwise surface as an opaque HTTP 500 / "internal server error"
+/// (e.g. when driven through vibe). Currently detects a broken install whose
+/// inference runner (`llama-server`) is missing: Ollama answers API requests but
+/// cannot load any model, so every generate/chat call 500s. Unrecognised errors
+/// pass through unchanged. Pure + tested.
+fn friendly_ollama_error(raw: &str) -> String {
+    let lower = raw.to_ascii_lowercase();
+    if lower.contains("llama-server") && lower.contains("not found") {
+        let cmd = ollama_install_cmd();
+        return format!(
+            "Ollama's inference runner (llama-server) is missing, so Ollama can \
+            serve its API but cannot load any model — the install is incomplete. \
+            Reinstall Ollama with `{cmd}`."
+        );
+    }
+    raw.to_string()
+}
+
 // ── New management commands ───────────────────────────────────────────────
 
-/// True when the `ollama` binary is available in PATH.
+// PATH lookups go through the shared, cross-platform `crate::paths::binary_on_path`
+// (`where` on Windows, `which` elsewhere); see that module for the rationale.
+use crate::paths::binary_on_path;
+
+/// True when the `ollama` binary is available. Checks PATH first, then (on
+/// Windows) the well-known per-user install location, since winget/the GUI
+/// installer drop `ollama.exe` under `%LOCALAPPDATA%\Programs\Ollama` and a
+/// running Eldrun's inherited PATH won't pick it up until a new session.
 #[tauri::command]
 pub async fn ollama_is_installed() -> bool {
-    std::process::Command::new("which")
-        .arg("ollama")
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
+    if binary_on_path("ollama") {
+        return true;
+    }
+    if cfg!(target_os = "windows") {
+        if let Ok(local) = std::env::var("LOCALAPPDATA") {
+            if std::path::Path::new(&local)
+                .join("Programs")
+                .join("Ollama")
+                .join("ollama.exe")
+                .exists()
+            {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// The manual download page, offered as a last-resort fallback on every OS.
+pub const OLLAMA_DOWNLOAD_URL: &str = "https://ollama.com/download";
+
+/// The recommended Ollama install command for the host OS. Kept here so the
+/// backend installer, the error messages, and the UI's copy-to-clipboard
+/// fallback all stay in sync with whatever the installer actually runs.
+///
+/// - Windows: winget (present on all supported Windows 10/11 builds).
+/// - Linux/macOS: the official distro-agnostic install script.
+pub fn ollama_install_cmd() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "winget install --id Ollama.Ollama -e --silent --accept-source-agreements --accept-package-agreements"
+    } else {
+        "curl -fsSL https://ollama.com/install.sh | sh"
+    }
+}
+
+/// Install Ollama using the host OS's native package mechanism, streaming its
+/// combined stdout+stderr to the frontend line-by-line via
+/// `ollama-install-progress` events (`{ line }`) so the UI can show live progress.
+///
+/// Per-OS strategy (see [`ollama_install_cmd`]):
+/// - **Windows**: `winget install --id Ollama.Ollama …` (silent, per-user). winget
+///   ships with all supported Windows 10/11 builds; if it is absent or fails, the
+///   UI falls back to the manual command + the ollama.com download link.
+/// - **Linux/macOS**: the official `curl … install.sh | sh` script. It needs root
+///   to drop the binary and register the systemd service; it invokes `sudo` itself,
+///   so a non-interactive run only succeeds with passwordless sudo or as root.
+///
+/// Returns the install log on success, or the tail of the output on failure.
+#[tauri::command]
+pub async fn install_ollama(app: tauri::AppHandle) -> Result<String, String> {
+    use std::io::{BufRead, BufReader};
+    use tauri::Emitter;
+
+    if ollama_is_installed().await {
+        return Ok("Ollama is already installed.".to_string());
+    }
+
+    let cmd = ollama_install_cmd();
+
+    // Build the OS-native invocation. We merge stderr into stdout (`2>&1`) at the
+    // shell level so a single reader sees every line in order. On unsupported
+    // platforms there is no automated path — point at the manual download.
+    let (program, args): (&str, Vec<String>) = if cfg!(target_os = "windows") {
+        ("cmd", vec!["/C".into(), format!("{cmd} 2>&1")])
+    } else if cfg!(any(target_os = "linux", target_os = "macos")) {
+        ("sh", vec!["-c".into(), format!("{cmd} 2>&1")])
+    } else {
+        return Err(format!(
+            "Automatic install isn't supported on this OS. Download Ollama from {OLLAMA_DOWNLOAD_URL}."
+        ));
+    };
+
+    // Per-OS hint appended to failure messages (the likely reason it didn't take).
+    let fail_hint: &str = if cfg!(target_os = "windows") {
+        "It may need winget (App Installer) or administrator rights"
+    } else {
+        "It likely needs sudo"
+    };
+
+    let emit = |line: &str| {
+        let _ = app.emit(
+            "ollama-install-progress",
+            serde_json::json!({ "line": line }),
+        );
+    };
+    emit("Starting Ollama installer…");
+
+    // `command_no_window` suppresses the transient console window the `cmd`/`sh`
+    // wrapper would otherwise pop on Windows; progress is surfaced in-app via the
+    // piped stdout below.
+    let mut child = crate::paths::command_no_window(program)
+        .args(&args)
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("failed to launch installer: {e}"))?;
+
+    let mut lines: Vec<String> = Vec::new();
+    if let Some(stdout) = child.stdout.take() {
+        for line in BufReader::new(stdout).lines() {
+            let line = match line {
+                Ok(l) => l,
+                Err(_) => break,
+            };
+            emit(&line);
+            lines.push(line);
+        }
+    }
+
+    let status = child
+        .wait()
+        .map_err(|e| format!("installer did not finish: {e}"))?;
+    let combined = lines.join("\n");
+    let combined = combined.trim().to_string();
+
+    if !status.success() {
+        let tail: Vec<&str> = combined.lines().rev().take(20).collect();
+        let tail = tail.into_iter().rev().collect::<Vec<_>>().join("\n");
+        return Err(if tail.is_empty() {
+            format!(
+                "installer exited unsuccessfully ({status}). {fail_hint} — \
+                run `{cmd}` in a terminal."
+            )
+        } else {
+            tail
+        });
+    }
+
+    // The post-install check is the real source of truth: an installer can print a
+    // warning to stderr yet still have placed the binary, or vice versa.
+    if !ollama_is_installed().await {
+        return Err(format!(
+            "installer ran but `ollama` is still not detected. {fail_hint}, or it \
+            may need a fresh session so the install dir is on PATH — run `{cmd}` in \
+            a terminal.\n\n{combined}"
+        ));
+    }
+
+    emit("Done.");
+    Ok(if combined.is_empty() {
+        "Ollama installed.".to_string()
+    } else {
+        combined
+    })
+}
+
+/// OS-appropriate install guidance for the frontend, so the UI can render the
+/// right command and wording without hardcoding a platform. `auto` is true when
+/// [`install_ollama`] can drive the install itself on this OS.
+#[derive(serde::Serialize, Clone)]
+pub struct OllamaInstallStrategy {
+    /// "windows" | "macos" | "linux" | "unknown".
+    pub os: String,
+    /// The exact command Eldrun runs / the user can copy-paste.
+    pub command: String,
+    /// Whether one-click `install_ollama` is supported on this OS.
+    pub auto: bool,
+    /// Manual download page, always provided as a last resort.
+    pub download_url: String,
+}
+
+/// Report the OS-dependent Ollama install strategy (detect OS + suggest command).
+#[tauri::command]
+pub async fn ollama_install_strategy() -> OllamaInstallStrategy {
+    let os = if cfg!(target_os = "windows") {
+        "windows"
+    } else if cfg!(target_os = "macos") {
+        "macos"
+    } else if cfg!(target_os = "linux") {
+        "linux"
+    } else {
+        "unknown"
+    };
+    OllamaInstallStrategy {
+        os: os.to_string(),
+        command: ollama_install_cmd().to_string(),
+        auto: cfg!(any(
+            target_os = "windows",
+            target_os = "linux",
+            target_os = "macos"
+        )),
+        download_url: OLLAMA_DOWNLOAD_URL.to_string(),
+    }
+}
+
+// ── Vibe (local-model agent runtime) ──────────────────────────────────────
+//
+// Local Ollama models are driven through Mistral's `vibe` CLI (the Local Model
+// tab spawns `vibe` with a per-model VIBE_HOME). Vibe is a separate install
+// from Ollama itself, so without it the tab fails with "unable to spawn vibe".
+// We surface install/detection here, alongside the Ollama installer, so the
+// Ollama settings window can guide the user through the full prerequisite.
+
+/// The official Vibe install command for the host OS. Kept here so the backend
+/// installer, the error messages, and the UI's copy-to-clipboard fallback all
+/// stay in sync with whatever the installer actually runs. Both paths install
+/// per-user (no administrator rights / `sudo`).
+///
+/// - **Windows**: install Astral's `uv` (per-user, into `%USERPROFILE%\.local\bin`)
+///   via its PowerShell installer, then `uv tool install mistral-vibe`, which drops
+///   `vibe.exe` alongside it. uv isn't on `PATH` in the same session that just
+///   installed it, so the command invokes `uv.exe` by full path to work in one shot.
+/// - **Linux/macOS**: the official `curl … install.sh | bash` script (installs via
+///   `uv` into `~/.local/bin`).
+pub fn vibe_install_cmd() -> &'static str {
+    if cfg!(target_os = "windows") {
+        // PowerShell. The second statement calls uv by full path because the
+        // freshly-installed uv is not yet on this session's PATH.
+        "irm https://astral.sh/uv/install.ps1 | iex; & \"$env:USERPROFILE\\.local\\bin\\uv.exe\" tool install mistral-vibe"
+    } else {
+        "curl -LsSf https://mistral.ai/vibe/install.sh | bash"
+    }
+}
+
+/// True when the `vibe` binary is reachable. Checks `PATH` (cross-platform, via
+/// `where`/`which`) and the well-known user install locations the installer uses,
+/// since Eldrun's inherited `PATH` may omit `~/.local/bin` even when a login shell
+/// would include it.
+#[tauri::command]
+pub async fn vibe_is_installed() -> bool {
+    if binary_on_path("vibe") {
+        return true;
+    }
+    let home = crate::paths::home_dir();
+    [".local/bin/vibe", ".cargo/bin/vibe"].iter().any(|rel| {
+        let base = home.join(rel);
+        if base.exists() {
+            return true;
+        }
+        // On Windows the install dir holds `vibe.exe` (the uv tool shim), which
+        // the bare extensionless relative path misses.
+        cfg!(target_os = "windows")
+            && ["exe", "cmd", "bat", "ps1"]
+                .iter()
+                .any(|ext| base.with_extension(ext).exists())
+    })
+}
+
+/// Install the Vibe CLI via its official per-user install command (see
+/// [`vibe_install_cmd`]).
+///
+/// Streams the installer's combined stdout+stderr to the frontend line-by-line via
+/// `vibe-install-progress` events (`{ line }`) so the UI can show live progress. The
+/// install is per-user (no `sudo` / administrator rights), so this runs
+/// non-interactively. Returns the install log on success, or the tail of the output
+/// on failure.
+///
+/// Per-OS the command is driven through the native shell: PowerShell on Windows
+/// (uv → `uv tool install mistral-vibe`), the POSIX shell on Linux/macOS.
+#[tauri::command]
+pub async fn install_vibe(app: tauri::AppHandle) -> Result<String, String> {
+    use std::io::{BufRead, BufReader};
+    use tauri::Emitter;
+
+    if vibe_is_installed().await {
+        return Ok("Vibe is already installed.".to_string());
+    }
+
+    let cmd = vibe_install_cmd();
+
+    // Build the OS-native invocation, merging stderr into stdout (`2>&1`) so a
+    // single reader sees every line in order.
+    let (program, args): (&str, Vec<String>) = if cfg!(target_os = "windows") {
+        (
+            "powershell",
+            vec![
+                "-NoProfile".into(),
+                "-ExecutionPolicy".into(),
+                "Bypass".into(),
+                "-Command".into(),
+                format!("{cmd} 2>&1"),
+            ],
+        )
+    } else if cfg!(any(target_os = "linux", target_os = "macos")) {
+        ("sh", vec!["-c".into(), format!("{cmd} 2>&1")])
+    } else {
+        return Err("Automatic install isn't supported on this OS. \
+            See https://docs.mistral.ai/getting-started/quickstarts/vibe-code/install-cli."
+            .to_string());
+    };
+
+    let emit = |line: &str| {
+        let _ = app.emit("vibe-install-progress", serde_json::json!({ "line": line }));
+    };
+    emit("Starting Vibe installer…");
+
+    // `command_no_window` suppresses the transient console window the PowerShell/
+    // `sh` wrapper would otherwise pop on Windows; progress is surfaced in-app.
+    let mut child = crate::paths::command_no_window(program)
+        .args(&args)
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .map_err(|e| format!("failed to launch installer: {e}"))?;
+
+    let mut lines: Vec<String> = Vec::new();
+    if let Some(stdout) = child.stdout.take() {
+        for line in BufReader::new(stdout).lines() {
+            let line = match line {
+                Ok(l) => l,
+                Err(_) => break,
+            };
+            emit(&line);
+            lines.push(line);
+        }
+    }
+
+    let status = child
+        .wait()
+        .map_err(|e| format!("installer did not finish: {e}"))?;
+    let combined = lines.join("\n").trim().to_string();
+
+    if !status.success() {
+        let tail: Vec<&str> = combined.lines().rev().take(20).collect();
+        let tail = tail.into_iter().rev().collect::<Vec<_>>().join("\n");
+        return Err(if tail.is_empty() {
+            format!("installer exited unsuccessfully ({status}). Run `{cmd}` in a terminal.")
+        } else {
+            tail
+        });
+    }
+
+    // The post-install check is the real source of truth.
+    if !vibe_is_installed().await {
+        return Err(format!(
+            "installer ran but `vibe` is still not detected. It may need a new shell so \
+            the install dir (`~/.local/bin`) is on PATH — run `{cmd}` in a terminal.\n\n{combined}"
+        ));
+    }
+
+    emit("Done.");
+    Ok(if combined.is_empty() {
+        "Vibe installed.".to_string()
+    } else {
+        combined
+    })
+}
+
+/// OS-appropriate Vibe install guidance for the frontend, so the UI renders the
+/// right command and wording without hardcoding a platform. `auto` is true when
+/// [`install_vibe`] can drive the install itself on this OS.
+#[derive(serde::Serialize, Clone)]
+pub struct VibeInstallStrategy {
+    /// "windows" | "macos" | "linux" | "unknown".
+    pub os: String,
+    /// The exact command Eldrun runs / the user can copy-paste.
+    pub command: String,
+    /// Whether one-click `install_vibe` is supported on this OS.
+    pub auto: bool,
+    /// Docs URL, always provided as a last resort.
+    pub docs: String,
+}
+
+/// Report the OS-dependent Vibe install strategy (detect OS + suggest command).
+#[tauri::command]
+pub async fn vibe_install_strategy() -> VibeInstallStrategy {
+    let os = if cfg!(target_os = "windows") {
+        "windows"
+    } else if cfg!(target_os = "macos") {
+        "macos"
+    } else if cfg!(target_os = "linux") {
+        "linux"
+    } else {
+        "unknown"
+    };
+    VibeInstallStrategy {
+        os: os.to_string(),
+        command: vibe_install_cmd().to_string(),
+        auto: cfg!(any(
+            target_os = "windows",
+            target_os = "linux",
+            target_os = "macos"
+        )),
+        docs: "https://docs.mistral.ai/getting-started/quickstarts/vibe-code/install-cli"
+            .to_string(),
+    }
 }
 
 /// Return detailed info for every locally installed model, cross-referenced
@@ -150,26 +545,412 @@ pub async fn stop_ollama_model(model: String) -> Result<(), String> {
     Ok(())
 }
 
-/// Pull (download or update) a model from the Ollama registry.
-/// Blocks until complete — may take minutes for large models.
+// ── Interrupted-pull tracking ─────────────────────────────────────────────
+// A pull that is in flight is recorded in a small JSON file so that if Eldrun
+// exits or crashes mid-download the model can be resumed on the next launch
+// (Ollama's /api/pull continues a partially-fetched model). The entry is added
+// when a pull starts and removed only on success; a caught error or a crash
+// leaves it behind so the UI can offer "Continue".
+
+fn pending_pulls_path() -> std::path::PathBuf {
+    crate::storage::state_dir().join("ollama_pending_pulls.json")
+}
+
+fn read_pending_pulls() -> Vec<String> {
+    crate::storage::read_json::<Vec<String>>(&pending_pulls_path()).unwrap_or_default()
+}
+
+fn mark_pending_pull(model: &str, active: bool) {
+    let mut list = read_pending_pulls();
+    let existed = list.iter().any(|m| m == model);
+    if active {
+        if existed {
+            return;
+        }
+        list.push(model.to_string());
+    } else {
+        if !existed {
+            return;
+        }
+        list.retain(|m| m != model);
+    }
+    let _ = crate::storage::write_json(&pending_pulls_path(), &list);
+}
+
+/// Model refs whose download was interrupted (Eldrun closed/crashed mid-pull).
+/// The UI reconciles these against the installed list and offers to resume them.
 #[tauri::command]
-pub async fn pull_ollama_model(model: String) -> Result<(), String> {
-    let body = serde_json::json!({"model": model, "stream": false}).to_string();
-    let response = ollama_http("POST", "/api/pull", Some(&body))?;
+pub async fn list_pending_ollama_pulls() -> Vec<String> {
+    read_pending_pulls()
+}
+
+/// An orphaned partial layer left in Ollama's blob cache by an interrupted pull.
+/// Ollama keys blobs by content digest with no on-disk name link, so a partial
+/// whose manifest was never written can't be mapped back to a model — we can
+/// only surface it (size) and offer to delete it to reclaim space.
+#[derive(serde::Serialize)]
+pub struct PartialBlob {
+    /// Short content digest, e.g. "6e9f90f02bb3".
+    pub digest: String,
+    /// Bytes on disk for the resumable partial layer.
+    pub size: u64,
+    /// Absolute path of the main `-partial` file (passed back to delete it).
+    pub path: String,
+}
+
+/// Ollama blob directories to scan (env override, user home, system service),
+/// de-duplicated and filtered to those that exist.
+fn ollama_blob_dirs() -> Vec<std::path::PathBuf> {
+    let override_dir = std::env::var_os("OLLAMA_MODELS").map(std::path::PathBuf::from);
+    let mut dirs = ollama_model_dir_candidates(
+        crate::paths::OsKind::current(),
+        &crate::paths::home_dir(),
+        override_dir.as_deref(),
+    )
+    .into_iter()
+    .map(|dir| dir.join("blobs"))
+    .collect::<Vec<_>>();
+    if let Some(system) = system_ollama_models_dir() {
+        dirs.push(system.join("blobs"));
+    }
+    let mut seen = std::collections::HashSet::new();
+    dirs.into_iter()
+        .filter(|d| d.is_dir() && seen.insert(d.clone()))
+        .collect()
+}
+
+fn ollama_model_dir_candidates(
+    os: crate::paths::OsKind,
+    home: &std::path::Path,
+    override_dir: Option<&std::path::Path>,
+) -> Vec<std::path::PathBuf> {
+    let mut dirs = Vec::new();
+    if let Some(path) = override_dir.filter(|path| !path.as_os_str().is_empty()) {
+        dirs.push(path.to_path_buf());
+    }
+    dirs.push(home.join(".ollama").join("models"));
+    if os == crate::paths::OsKind::Unix {
+        dirs.extend([
+            std::path::PathBuf::from("/usr/share/ollama/.ollama/models"),
+            std::path::PathBuf::from("/var/lib/ollama/.ollama/models"),
+            std::path::PathBuf::from("/var/lib/ollama/models"),
+        ]);
+    }
+    dirs
+}
+
+/// Orphaned partial download layers sitting in Ollama's blob cache, largest
+/// first. Each is an interrupted download with no recoverable model name.
+#[tauri::command]
+pub async fn list_orphan_partial_blobs() -> Vec<PartialBlob> {
+    let mut out: Vec<PartialBlob> = Vec::new();
+    for dir in ollama_blob_dirs() {
+        let rd = match std::fs::read_dir(&dir) {
+            Ok(r) => r,
+            Err(_) => continue,
+        };
+        for entry in rd.flatten() {
+            let name = entry.file_name().to_string_lossy().to_string();
+            // The main data file ends exactly in "-partial"; per-chunk metadata
+            // files are "-partial-<N>", so counting only the former lists each
+            // interrupted layer once.
+            if !name.ends_with("-partial") {
+                continue;
+            }
+            let size = entry.metadata().map(|m| m.len()).unwrap_or(0);
+            let digest = name
+                .strip_suffix("-partial")
+                .unwrap_or(&name)
+                .strip_prefix("sha256-")
+                .unwrap_or(&name)
+                .chars()
+                .take(12)
+                .collect::<String>();
+            out.push(PartialBlob {
+                digest,
+                size,
+                path: entry.path().to_string_lossy().to_string(),
+            });
+        }
+    }
+    out.sort_by(|a, b| b.size.cmp(&a.size));
+    out
+}
+
+/// Delete an orphaned partial layer (the main `-partial` file plus its per-chunk
+/// `-partial-<N>` siblings) to reclaim disk. Validated to a file named `*-partial`
+/// inside a `blobs` directory so it can't be used to remove anything else.
+#[tauri::command]
+pub async fn delete_partial_blob(path: String) -> Result<(), String> {
+    let p = std::path::Path::new(&path);
+    let name = p
+        .file_name()
+        .and_then(|n| n.to_str())
+        .ok_or("invalid path")?
+        .to_string();
+    if !name.ends_with("-partial") {
+        return Err("not a partial blob".into());
+    }
+    let dir = p.parent().ok_or("no parent directory")?;
+    if dir.file_name().and_then(|n| n.to_str()) != Some("blobs") {
+        return Err("not inside a blobs directory".into());
+    }
+    let mut removed = false;
+    let mut last_err: Option<String> = None;
+    if let Ok(rd) = std::fs::read_dir(dir) {
+        for entry in rd.flatten() {
+            let fname = entry.file_name().to_string_lossy().to_string();
+            if fname == name || fname.starts_with(&format!("{name}-")) {
+                match std::fs::remove_file(entry.path()) {
+                    Ok(()) => removed = true,
+                    Err(e) => last_err = Some(e.to_string()),
+                }
+            }
+        }
+    }
+    if removed {
+        Ok(())
+    } else {
+        Err(last_err.unwrap_or_else(|| "nothing to remove".into()))
+    }
+}
+
+/// Forget an interrupted pull (e.g. the user dismisses it, or it finished).
+#[tauri::command]
+pub async fn clear_pending_ollama_pull(model: String) {
+    mark_pending_pull(&model, false);
+}
+
+// ── Pausable pulls ────────────────────────────────────────────────────────
+// Ollama's /api/pull has no native pause, but dropping the connection mid-stream
+// leaves the partial blobs on disk, and a later /api/pull continues from them. We
+// implement "pause" as a cooperative cancel: `pause_ollama_pull` records a model
+// ref, and the streaming loop in `pull_ollama_model` notices it on its next chunk,
+// stops reading, and returns — keeping the pending-pull record so the UI can offer
+// Resume (re-pull) or Delete (drop the partials).
+
+fn paused_pulls() -> &'static std::sync::Mutex<std::collections::HashSet<String>> {
+    static S: std::sync::OnceLock<std::sync::Mutex<std::collections::HashSet<String>>> =
+        std::sync::OnceLock::new();
+    S.get_or_init(|| std::sync::Mutex::new(std::collections::HashSet::new()))
+}
+
+/// Request that an in-flight pull of `model` pause at the next streamed chunk.
+/// The partial download is preserved so it can be resumed later.
+#[tauri::command]
+pub async fn pause_ollama_pull(model: String) {
+    if let Ok(mut set) = paused_pulls().lock() {
+        set.insert(model);
+    }
+}
+
+/// True (consuming the flag) if a pause was requested for `model`.
+fn take_pause_request(model: &str) -> bool {
+    paused_pulls()
+        .lock()
+        .map(|mut set| set.remove(model))
+        .unwrap_or(false)
+}
+
+/// Delete a paused/interrupted download: clear its pending record, remove the
+/// partial blobs it left in Ollama's cache, and delete any committed model of the
+/// same ref. Best-effort — the partial blobs are resolved from the registry
+/// manifest's layer digests, so a missing network leaves them for the orphan-blob
+/// cleanup to reclaim instead. Always clears the pending record so the UI settles.
+#[tauri::command]
+pub async fn delete_ollama_pull(model: String) -> Result<(), String> {
+    mark_pending_pull(&model, false);
+    // Drop any committed manifest/blobs (no-op 404 if the pull never got that far).
+    let body = serde_json::json!({ "model": model }).to_string();
+    let _ = ollama_http("DELETE", "/api/delete", Some(&body));
+    // Remove the partial layers this model's pull was fetching.
+    if let Ok(digests) = registry_layer_digests(&model) {
+        delete_partials_for_digests(&digests);
+    }
+    Ok(())
+}
+
+/// The set of blob digests (`sha256:<hex>`) a model ref is composed of — its
+/// config plus every layer — read from the Ollama registry manifest. Used to map
+/// a paused download back to the specific `-partial` files it created.
+fn registry_layer_digests(model: &str) -> Result<Vec<String>, String> {
+    let v = fetch_registry_manifest(model)?;
+    let mut out: Vec<String> = Vec::new();
+    if let Some(d) = v["config"]["digest"].as_str() {
+        out.push(d.to_string());
+    }
+    if let Some(arr) = v["layers"].as_array() {
+        for l in arr {
+            if let Some(d) = l["digest"].as_str() {
+                out.push(d.to_string());
+            }
+        }
+    }
+    Ok(out)
+}
 
-    // Response may be multiple newline-delimited JSON objects; check last line.
-    for line in response.lines().rev() {
+/// Delete the `*-partial` (and per-chunk `*-partial-<N>`) files matching any of
+/// the given `sha256:<hex>` digests, across all known blob directories.
+fn delete_partials_for_digests(digests: &[String]) {
+    // Blob files are named `sha256-<hex>`; the manifest gives `sha256:<hex>`.
+    let stems: std::collections::HashSet<String> =
+        digests.iter().map(|d| d.replace(':', "-")).collect();
+    for dir in ollama_blob_dirs() {
+        let Ok(rd) = std::fs::read_dir(&dir) else {
+            continue;
+        };
+        for entry in rd.flatten() {
+            let name = entry.file_name().to_string_lossy().to_string();
+            let Some(rest) = name.strip_suffix("-partial").or_else(|| {
+                // per-chunk metadata file: `<stem>-partial-<N>`
+                name.rsplit_once("-partial-").map(|(head, _)| head)
+            }) else {
+                continue;
+            };
+            if stems.contains(rest) {
+                let _ = std::fs::remove_file(entry.path());
+            }
+        }
+    }
+}
+
+/// Load a model into memory now (an empty `/api/generate` warms it) and keep it
+/// resident until explicitly unloaded (`keep_alive: -1`), so the user controls
+/// residency by button rather than relying on first use to trigger the load.
+///
+/// Ollama's warm-up call returns only once the model is fully resident and streams
+/// no load percentage, so progress here is coarse: an `ollama-load-progress` event
+/// (`{ model, status }`, status `loading`→`success`/`error`) is emitted around the
+/// blocking call so any surface (the brain menu, the settings panel) can show a
+/// live "Loading into memory…" indicator for a load started anywhere.
+#[tauri::command]
+pub async fn load_ollama_model(app: tauri::AppHandle, model: String) -> Result<(), String> {
+    use tauri::Emitter;
+
+    let _ = app.emit(
+        "ollama-load-progress",
+        serde_json::json!({ "model": model, "status": "loading" }),
+    );
+    let body = serde_json::json!({"model": model, "keep_alive": -1}).to_string();
+    let result = ollama_http("POST", "/api/generate", Some(&body));
+    let _ = app.emit(
+        "ollama-load-progress",
+        match &result {
+            Ok(_) => serde_json::json!({ "model": model, "status": "success" }),
+            Err(e) => serde_json::json!({ "model": model, "status": "error", "error": e }),
+        },
+    );
+    result?;
+    Ok(())
+}
+
+/// Pull (download or update) a model from the Ollama registry, streaming
+/// download progress to the frontend. Emits `ollama-pull-progress` events
+/// (`{ model, status, completed, total }`) line-by-line as Ollama reports
+/// them so the UI can show a live percentage. Blocks until complete — may
+/// take minutes for large models.
+#[tauri::command]
+pub async fn pull_ollama_model(app: tauri::AppHandle, model: String) -> Result<(), String> {
+    use std::io::{BufRead, BufReader};
+    use tauri::Emitter;
+
+    let body = serde_json::json!({"model": model, "stream": true}).to_string();
+
+    let stream = TcpStream::connect("127.0.0.1:11434").map_err(|_| "not_running".to_string())?;
+    // 10-minute read timeout accommodates large model pulls between chunks.
+    stream
+        .set_read_timeout(Some(Duration::from_secs(600)))
+        .map_err(|e| format!("set timeout: {e}"))?;
+
+    let req = format!(
+        "POST /api/pull HTTP/1.0\r\nHost: localhost\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}",
+        body.as_bytes().len()
+    );
+    let mut writer = stream.try_clone().map_err(|e| format!("clone: {e}"))?;
+    writer
+        .write_all(req.as_bytes())
+        .map_err(|e| format!("write: {e}"))?;
+
+    // Record this as an in-flight pull; a crash/exit now leaves the entry behind
+    // so the next launch can offer to resume it. Removed only on success below.
+    mark_pending_pull(&model, true);
+    // Consume any stale pause flag from a previous run so this fresh pull (e.g. a
+    // resume) isn't cancelled before it starts.
+    take_pause_request(&model);
+
+    let mut reader = BufReader::new(stream);
+
+    // Consume the HTTP status line + headers up to the blank separator,
+    // capturing the status code so a 4xx/5xx can surface as an error.
+    let mut status_code = 200u16;
+    let mut header = String::new();
+    reader
+        .read_line(&mut header)
+        .map_err(|e| format!("read: {e}"))?;
+    if let Some(code) = header
+        .split_whitespace()
+        .nth(1)
+        .and_then(|s| s.parse().ok())
+    {
+        status_code = code;
+    }
+    loop {
+        let mut h = String::new();
+        let n = reader.read_line(&mut h).map_err(|e| format!("read: {e}"))?;
+        if n == 0 || h == "\r\n" || h == "\n" {
+            break;
+        }
+    }
+
+    // Stream the newline-delimited JSON body, forwarding each progress line.
+    let mut last_err: Option<String> = None;
+    loop {
+        // Cooperative pause: if the user asked to pause this pull, stop reading and
+        // drop the connection. Ollama keeps the partial blobs, and the pending-pull
+        // record is left in place so the UI can offer Resume or Delete.
+        if take_pause_request(&model) {
+            let _ = app.emit(
+                "ollama-pull-progress",
+                serde_json::json!({ "model": model, "status": "paused" }),
+            );
+            return Ok(());
+        }
+        let mut line = String::new();
+        let n = reader
+            .read_line(&mut line)
+            .map_err(|e| format!("read: {e}"))?;
+        if n == 0 {
+            break;
+        }
         let line = line.trim();
         if line.is_empty() {
             continue;
         }
         if let Ok(v) = serde_json::from_str::<serde_json::Value>(line) {
             if let Some(err) = v["error"].as_str() {
-                return Err(err.to_string());
+                last_err = Some(err.to_string());
+                continue;
             }
+            let _ = app.emit(
+                "ollama-pull-progress",
+                serde_json::json!({
+                    "model": model,
+                    "status": v["status"].as_str().unwrap_or_default(),
+                    "completed": v["completed"].as_u64().unwrap_or(0),
+                    "total": v["total"].as_u64().unwrap_or(0),
+                }),
+            );
         }
-        break;
     }
+
+    if let Some(err) = last_err {
+        return Err(friendly_ollama_error(&err));
+    }
+    if status_code >= 400 {
+        return Err(format!("HTTP {status_code}"));
+    }
+    // Completed cleanly — drop it from the interrupted-pull record.
+    mark_pending_pull(&model, false);
     Ok(())
 }
 
@@ -181,6 +962,217 @@ pub async fn delete_ollama_model(model: String) -> Result<(), String> {
     Ok(())
 }
 
+/// Fetch the Ollama registry manifest (config + layers) for a model ref. Shells
+/// out to `curl` (no Rust TLS dep); `model` may be `name`, `name:tag`, or
+/// `namespace/name:tag`, with an absent tag defaulting to `latest`. Shared by the
+/// size hint and the paused-download partial-blob resolver.
+fn fetch_registry_manifest(model: &str) -> Result<serde_json::Value, String> {
+    validate_model_name(model)?;
+
+    let (name, tag) = match model.split_once(':') {
+        Some((n, t)) => (n, t),
+        None => (model, "latest"),
+    };
+    // Bare names live under the implicit `library/` namespace on the registry.
+    let repo = if name.contains('/') {
+        name.to_string()
+    } else {
+        format!("library/{name}")
+    };
+    let url = format!("https://registry.ollama.ai/v2/{repo}/manifests/{tag}");
+
+    // No shell — args are passed directly, and `validate_model_name` already
+    // restricts the characters that reach the URL. `command_no_window` keeps
+    // `curl` from flashing a console window on Windows (Win10/11 ship curl.exe).
+    let output = crate::paths::command_no_window("curl")
+        .args([
+            "-fsSL",
+            "-H",
+            "Accept: application/vnd.docker.distribution.manifest.v2+json",
+            &url,
+        ])
+        .output()
+        .map_err(|e| format!("failed to query registry: {e}"))?;
+
+    if !output.status.success() {
+        return Err(format!("registry returned no manifest for {model}"));
+    }
+
+    serde_json::from_slice(&output.stdout).map_err(|e| format!("manifest json: {e}"))
+}
+
+/// Total download size in bytes for an installable model tag, read from the
+/// Ollama registry manifest. Used to show a model's size on hover before the
+/// user commits to a pull. Sums the manifest's config + layer sizes.
+#[tauri::command]
+pub async fn ollama_registry_size(model: String) -> Result<u64, String> {
+    let v = fetch_registry_manifest(&model)?;
+
+    let layers_total: u64 = v["layers"]
+        .as_array()
+        .map(|arr| arr.iter().filter_map(|l| l["size"].as_u64()).sum())
+        .unwrap_or(0);
+    let config_size = v["config"]["size"].as_u64().unwrap_or(0);
+    let total = layers_total + config_size;
+
+    if total == 0 {
+        return Err(format!("no size info in manifest for {model}"));
+    }
+    Ok(total)
+}
+
+// ── Live registry browse (ollama.com/search) ─────────────────────────────────
+//
+// Ollama exposes no JSON catalog API, but its search page is server-rendered
+// HTML carrying stable `x-test-*` hooks. We fetch it with `curl` (no TLS dep,
+// same as `ollama_registry_size`) and parse those hooks. This surfaces *every*
+// model in the registry — far beyond the curated `list_installable_models` — and
+// supports Ollama's own filters: free-text query, capability filter, sort, and
+// pagination for lazy loading. NB: Ollama provides no country/year metadata, so
+// "recency" comes only from its relative `updated` label and the `newest` sort.
+
+/// One model row parsed from an ollama.com/search results page.
+#[derive(serde::Serialize, Clone, PartialEq, Debug)]
+pub struct RegistryModel {
+    pub name: String,
+    pub description: String,
+    /// Capability badges: e.g. "tools", "vision", "thinking", "embedding", "audio".
+    pub capabilities: Vec<String>,
+    /// Parameter-size tags e.g. ["8b", "70b"] (also "e2b" for Gemma-3n variants).
+    pub sizes: Vec<String>,
+    /// Human pull count as shown, e.g. "65.8K".
+    pub pulls: String,
+    /// Relative update label as shown, e.g. "1 week ago".
+    pub updated: String,
+}
+
+/// Percent-encode a search query for safe inclusion in the URL's query string.
+/// Keeps RFC-3986 unreserved characters; everything else becomes %XX.
+fn percent_encode_query(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for b in s.bytes() {
+        if b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_' | b'.' | b'~') {
+            out.push(b as char);
+        } else {
+            out.push('%');
+            out.push_str(&format!("{b:02X}"));
+        }
+    }
+    out
+}
+
+/// Minimal HTML-entity unescape for the text fragments we extract (names,
+/// descriptions). Covers the entities Ollama's templates actually emit.
+fn html_unescape(s: &str) -> String {
+    s.replace("&amp;", "&")
+        .replace("&lt;", "<")
+        .replace("&gt;", ">")
+        .replace("&quot;", "\"")
+        .replace("&#39;", "'")
+        .replace("&#x27;", "'")
+        .replace("&nbsp;", " ")
+}
+
+/// Text content right after an attribute marker: find `marker`, then the next
+/// '>', then return text up to the following '<' (unescaped, trimmed).
+fn tag_text_after(card: &str, marker: &str) -> Option<String> {
+    let i = card.find(marker)?;
+    let rest = &card[i + marker.len()..];
+    let gt = rest.find('>')?;
+    let after = &rest[gt + 1..];
+    let lt = after.find('<')?;
+    Some(html_unescape(after[..lt].trim()))
+}
+
+/// All text contents for a marker that repeats within a single card (e.g. the
+/// capability and size badges).
+fn all_tag_texts(card: &str, marker: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut pos = 0;
+    while let Some(i) = card[pos..].find(marker) {
+        let start = pos + i + marker.len();
+        let Some(gt) = card[start..].find('>') else {
+            break;
+        };
+        let after = start + gt + 1;
+        if let Some(lt) = card[after..].find('<') {
+            let text = html_unescape(card[after..after + lt].trim());
+            if !text.is_empty() {
+                out.push(text);
+            }
+        }
+        pos = after;
+    }
+    out
+}
+
+/// Parse the ollama.com/search HTML into model rows. Pure + tested: each
+/// `<li x-test-model …>` becomes one `RegistryModel`.
+fn parse_search_html(html: &str) -> Vec<RegistryModel> {
+    // Each result card starts at an `x-test-model` marker; the first split chunk
+    // is the page header before any card, so skip it.
+    html.split("x-test-model")
+        .skip(1)
+        .filter_map(|card| {
+            let name = tag_text_after(card, "x-test-search-response-title")?;
+            if name.is_empty() {
+                return None;
+            }
+            // Description is the first <p> with the max-w-lg class.
+            let description = tag_text_after(card, "class=\"max-w-lg").unwrap_or_default();
+            Some(RegistryModel {
+                name,
+                description,
+                capabilities: all_tag_texts(card, "x-test-capability"),
+                sizes: all_tag_texts(card, "x-test-size"),
+                pulls: tag_text_after(card, "x-test-pull-count").unwrap_or_default(),
+                updated: tag_text_after(card, "x-test-updated").unwrap_or_default(),
+            })
+        })
+        .collect()
+}
+
+/// Browse the full Ollama registry via its search page. Returns one page
+/// (~20 rows) of results so the frontend can lazy-load; an empty vec means no
+/// more pages. `capability` filters by a single capability ("" = any);
+/// `sort` is "newest" or anything else (popular, the default). `page` is 1-based.
+#[tauri::command]
+pub async fn search_ollama_registry(
+    query: String,
+    capability: String,
+    sort: String,
+    page: u32,
+) -> Result<Vec<RegistryModel>, String> {
+    let page = page.max(1);
+    let mut url = format!(
+        "https://ollama.com/search?q={}&page={page}",
+        percent_encode_query(query.trim())
+    );
+    // Only forward a capability we recognise, so we never inject arbitrary params.
+    const CAPS: [&str; 6] = ["tools", "vision", "thinking", "embedding", "audio", "cloud"];
+    if CAPS.contains(&capability.as_str()) {
+        url.push_str(&format!("&c={capability}"));
+    }
+    if sort == "newest" {
+        url.push_str("&o=newest");
+    }
+
+    // No shell — args passed directly; the URL is built only from a validated
+    // capability/sort and a percent-encoded query. `command_no_window` avoids a
+    // console-window flash on Windows.
+    let output = crate::paths::command_no_window("curl")
+        .args(["-fsSL", &url])
+        .output()
+        .map_err(|e| format!("failed to query registry: {e}"))?;
+
+    if !output.status.success() {
+        return Err("ollama.com search request failed".to_string());
+    }
+
+    let html = String::from_utf8_lossy(&output.stdout);
+    Ok(parse_search_html(&html))
+}
+
 /// Return the built-in catalog of popular installable models.
 #[tauri::command]
 pub async fn list_installable_models() -> Vec<CatalogEntry> {
@@ -366,6 +1358,54 @@ pub async fn list_installable_models() -> Vec<CatalogEntry> {
     ]
 }
 
+/// True when the Ollama server is reachable on its default port. Cheap enough
+/// (200 ms TCP connect) to poll from the UI for a live status indicator.
+#[tauri::command]
+pub async fn ollama_is_running() -> bool {
+    ollama_listening()
+}
+
+/// Three-state health of the local Ollama server for the header status lamp:
+/// - `"stopped"` — server unreachable (lamp red),
+/// - `"idle"` — server up but no model loaded in memory (lamp yellow),
+/// - `"loaded"` — at least one model currently loaded in memory (lamp green).
+///
+/// One round trip: `/api/ps` lists the models resident in memory, and a
+/// successful response also proves the server is reachable, so it doubles as
+/// the running check.
+#[tauri::command]
+pub async fn ollama_status() -> &'static str {
+    match ollama_http("GET", "/api/ps", None) {
+        Err(_) => "stopped",
+        Ok(body) => {
+            let loaded = serde_json::from_str::<serde_json::Value>(&body)
+                .ok()
+                .and_then(|v| v["models"].as_array().map(|a| !a.is_empty()))
+                .unwrap_or(false);
+            if loaded {
+                "loaded"
+            } else {
+                "idle"
+            }
+        }
+    }
+}
+
+/// Total VRAM (bytes) currently in use across all models resident in Ollama's
+/// memory, summed from `/api/ps`'s `size_vram`. Returns `0` when the server is
+/// unreachable or no model is loaded on the GPU, so callers can treat it as a
+/// plain "GPU bytes in use" gauge that degrades to zero rather than erroring.
+pub fn total_vram_in_use() -> u64 {
+    ollama_http("GET", "/api/ps", None)
+        .ok()
+        .and_then(|b| serde_json::from_str::<serde_json::Value>(&b).ok())
+        .and_then(|v| v["models"].as_array().cloned())
+        .unwrap_or_default()
+        .iter()
+        .map(|m| m["size_vram"].as_u64().unwrap_or(0))
+        .sum()
+}
+
 fn ollama_listening() -> bool {
     TcpStream::connect_timeout(
         &"127.0.0.1:11434".parse().unwrap(),
@@ -386,26 +1426,35 @@ pub async fn ensure_ollama_running() -> Result<(), String> {
         return Ok(());
     }
 
-    // Try the system service first — it runs as the ollama user and sees all
-    // system-wide models (e.g. /usr/share/ollama/.ollama/models).
-    let service_started = std::process::Command::new("systemctl")
-        .args(["start", "ollama"])
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false);
-
-    if service_started {
-        let deadline = Instant::now() + Duration::from_secs(8);
-        if wait_for_ollama(deadline) {
-            return Ok(());
+    // Try the system service first (Linux only) — it runs as the ollama user and
+    // sees all system-wide models (e.g. /usr/share/ollama/.ollama/models).
+    #[cfg(target_os = "linux")]
+    {
+        let service_started = std::process::Command::new("systemctl")
+            .args(["start", "ollama"])
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .status()
+            .map(|s| s.success())
+            .unwrap_or(false);
+
+        if service_started {
+            let deadline = Instant::now() + Duration::from_secs(8);
+            if wait_for_ollama(deadline) {
+                return Ok(());
+            }
         }
     }
 
     // Fall back to spawning a user process, but point it at the system models
-    // directory if it exists so models installed via the system service are visible.
-    let mut cmd = std::process::Command::new("ollama");
+    // directory if it exists so models installed via the system service are
+    // visible. Resolve `ollama` to an absolute path: on Windows the winget/GUI
+    // installer drops `ollama.exe` under %LOCALAPPDATA%\Programs\Ollama, which is
+    // detected by `ollama_is_installed` but is not on this process's PATH.
+    let ollama_bin = crate::paths::resolve_offpath_binary("ollama")
+        .map(std::ffi::OsString::from)
+        .unwrap_or_else(|| "ollama".into());
+    let mut cmd = crate::paths::command_no_window(&ollama_bin);
     cmd.arg("serve")
         .stdout(std::process::Stdio::null())
         .stderr(std::process::Stdio::null());
@@ -414,8 +1463,7 @@ pub async fn ensure_ollama_running() -> Result<(), String> {
         cmd.env("OLLAMA_MODELS", sys_models);
     }
 
-    cmd.spawn()
-        .map_err(|e| format!("failed to start ollama serve: {e}"))?;
+    crate::paths::spawn_reaped(cmd).map_err(|e| format!("failed to start ollama serve: {e}"))?;
 
     let deadline = Instant::now() + Duration::from_secs(8);
     if wait_for_ollama(deadline) {
@@ -438,15 +1486,17 @@ fn wait_for_ollama(deadline: Instant) -> bool {
 /// Returns the path to the system-wide Ollama models directory if it exists
 /// and contains at least one model manifest.
 fn system_ollama_models_dir() -> Option<std::path::PathBuf> {
-    let candidates = [
-        "/usr/share/ollama/.ollama/models",
-        "/var/lib/ollama/.ollama/models",
-        "/var/lib/ollama/models",
-    ];
-    for path in &candidates {
-        let p = std::path::Path::new(path);
-        if p.join("manifests").exists() {
-            return Some(p.to_owned());
+    #[cfg(target_os = "linux")]
+    {
+        for path in [
+            "/usr/share/ollama/.ollama/models",
+            "/var/lib/ollama/.ollama/models",
+            "/var/lib/ollama/models",
+        ] {
+            let p = std::path::Path::new(path);
+            if p.join("manifests").exists() {
+                return Some(p.to_owned());
+            }
         }
     }
     None
@@ -460,42 +1510,344 @@ pub async fn list_ollama_models() -> Result<Vec<String>, String> {
     let v: serde_json::Value =
         serde_json::from_str(&body).map_err(|e| format!("ollama json: {e}"))?;
 
-    let models = v["models"]
-        .as_array()
-        .ok_or("no models field in ollama response")?;
+    let models = v["models"]
+        .as_array()
+        .ok_or("no models field in ollama response")?;
+
+    Ok(models
+        .iter()
+        .filter_map(|m| Some(m["name"].as_str()?.to_owned()))
+        .collect())
+}
+
+// ── Local code/text autocomplete (TODO Group M #45) ──────────────────────────
+//
+// DECISION A: completion is LOCAL OLLAMA ONLY and OPT-IN. We reuse `ollama_http`
+// against the local `/api/chat` endpoint — no remote endpoint is ever contacted.
+// The frontend gates the call behind a per-type `autocomplete` setting (default
+// OFF) and runs it against whichever model is currently loaded in memory; if none
+// is loaded / Ollama isn't reachable this returns `not_running` and the UI shows a
+// "load a local model" hint.
+//
+// We use /api/chat (not /api/generate) with a dedicated system role: a general
+// instruct/chat model like llama3.2 otherwise reads the surrounding text as a
+// *task* and replies "Here is the reformatted version…" instead of continuing it.
+
+/// System message that turns a general instruct/chat model into a fill-in-the-
+/// middle completion engine: it must INSERT between BEFORE and AFTER (not author a
+/// fresh reply). How *much* to insert is left to the per-request TASK hint (see
+/// [`CompletionMode`]) so the same engine serves sentence, block, and whole-scope
+/// completions. Verified against llama3.2:3b. Pure + sent as the chat `system` role.
+const COMPLETION_SYSTEM: &str = "You are a fill-in-the-middle autocomplete engine inside a code/text \
+editor. You receive the text BEFORE the cursor and the text AFTER the cursor. Output ONLY the raw text \
+to INSERT at the cursor so that BEFORE + your insertion + AFTER reads as one correct, natural, continuous \
+piece of text. Continue directly from the end of BEFORE and join smoothly into the start of AFTER. Insert \
+exactly what the TASK asks for and no more. Never repeat, rewrite, or quote any text from BEFORE or AFTER. \
+No preamble, no quotes, no code fences, no explanations, no labels.";
+
+/// How much of a completion to generate (#45 modes). Chosen per file type in
+/// settings and cycled live with Shift+Tab while a suggestion is showing. Drives
+/// both the TASK hint in [`completion_prompt`] and the `num_predict` output cap.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum CompletionMode {
+    /// Finish the current word/sentence/line only (default; least intrusive).
+    Sentence,
+    /// Finish the current code block / paragraph (may span several lines).
+    Block,
+    /// Complete the whole enclosing function or scope.
+    Scope,
+}
+
+impl CompletionMode {
+    /// Parse the frontend's mode string; anything unknown/absent falls back to the
+    /// conservative `Sentence` mode.
+    fn parse(s: &str) -> Self {
+        match s {
+            "block" => Self::Block,
+            "scope" => Self::Scope,
+            _ => Self::Sentence,
+        }
+    }
+
+    /// Output cap (tokens). Larger modes need more room, but each stays bounded so
+    /// a local model can't run away generating the rest of the file.
+    fn num_predict(self) -> u32 {
+        match self {
+            Self::Sentence => 128,
+            Self::Block => 256,
+            Self::Scope => 512,
+        }
+    }
+}
+
+/// True when the cursor sits in the middle of a sentence — i.e. the last
+/// non-space/tab character of `prefix` is a word/comma rather than a sentence
+/// terminator, a newline, or the start of the document. Used to bias the model
+/// toward finishing the current sentence first. Pure + tested.
+fn is_mid_sentence(prefix: &str) -> bool {
+    match prefix.trim_end_matches([' ', '\t']).chars().last() {
+        None => false,
+        Some(c) => !matches!(c, '.' | '!' | '?' | ':' | ';' | '\n'),
+    }
+}
+
+/// Line-comment token(s) for `language`, used to recognise an "intent comment" the
+/// user wrote to describe the code they want next (e.g. `// new for loop to compute
+/// the sum`). Known code languages map to their comment syntax; prose-ish languages
+/// (markdown / plain text / unknown-empty) return an empty slice so headings like
+/// `# Title` are never mistaken for a code-intent comment; any other named (but
+/// unrecognised) language falls back to the two most common tokens. Pure + tested.
+fn line_comment_tokens(language: &str) -> &'static [&'static str] {
+    match language.to_ascii_lowercase().as_str() {
+        "rust" | "c" | "cpp" | "c++" | "h" | "hpp" | "java" | "javascript" | "js" | "jsx"
+        | "typescript" | "ts" | "tsx" | "go" | "swift" | "kotlin" | "kt" | "scala" | "dart"
+        | "php" | "csharp" | "cs" | "c#" | "objc" | "objectivec" | "groovy" | "rust-objc" => {
+            &["//"]
+        }
+        "python" | "py" | "ruby" | "rb" | "bash" | "sh" | "shell" | "zsh" | "perl" | "pl" | "r"
+        | "yaml" | "yml" | "toml" | "makefile" | "make" | "dockerfile" | "elixir" | "ex"
+        | "nix" => &["#"],
+        "sql" | "lua" | "haskell" | "hs" | "ada" | "elm" => &["--"],
+        "lisp" | "clojure" | "clj" | "scheme" | "racket" | "asm" => &[";"],
+        "tex" | "latex" | "matlab" | "erlang" | "erl" => &["%"],
+        // Prose / unknown-empty: do not treat any line as a code-intent comment.
+        "" | "markdown" | "md" | "mdx" | "text" | "plain" | "txt" | "rst" | "html" | "xml"
+        | "css" => &[],
+        // Some other named code-ish language we don't have a table entry for.
+        _ => &["//", "#"],
+    }
+}
+
+/// If `line` is a single comment line, return its human-readable body (comment
+/// token, any repeated token chars like `///`/`##`, surrounding `/* */`, and
+/// whitespace stripped); otherwise `None`. Pure + tested.
+fn strip_comment_line(line: &str, tokens: &[&str]) -> Option<String> {
+    let t = line.trim();
+    // Single-line block comment `/* … */` (C-family only).
+    if tokens.contains(&"//") && t.starts_with("/*") {
+        let body = t.trim_start_matches("/*").trim_end_matches("*/").trim();
+        return Some(body.to_string());
+    }
+    for tok in tokens {
+        if let Some(rest) = t.strip_prefix(tok) {
+            // Drop extra repeats of the token's first char (`///`, `##`, `--!`).
+            let lead = tok.chars().next().unwrap_or(' ');
+            return Some(rest.trim_start_matches(lead).trim().to_string());
+        }
+    }
+    None
+}
+
+/// Detect an "intent comment" sitting immediately before the caret and return its
+/// combined text, so [`completion_prompt`] can switch from continuing prose to
+/// *implementing the comment as code*. Fires when the caret is on a fresh (blank or
+/// indent-only) line directly below a run of comment lines, or at the end of a
+/// comment line itself; consecutive comment lines above are merged into one
+/// instruction. Returns `None` for non-code languages, when there is no comment, or
+/// when the text doesn't read like an instruction (needs ≥2 words and ≥3 letters,
+/// so a lone `//` or a `// ----` divider never triggers). Pure + tested.
+fn trailing_comment_intent(prefix: &str, language: &str) -> Option<String> {
+    let tokens = line_comment_tokens(language);
+    if tokens.is_empty() {
+        return None;
+    }
+    let lines: Vec<&str> = prefix.split('\n').collect();
+    let n = lines.len();
+    if n == 0 {
+        return None;
+    }
+    // Index of the last comment line of the block to read.
+    let last = if lines[n - 1].trim().is_empty() {
+        // Caret on its own fresh line: the comment block is just above it.
+        if n < 2 {
+            return None;
+        }
+        n - 2
+    } else if strip_comment_line(lines[n - 1], tokens).is_some() {
+        // Caret at the end of a comment line itself.
+        n - 1
+    } else {
+        return None;
+    };
+    // Walk up the consecutive run of comment lines ending at `last`.
+    let mut texts = Vec::new();
+    let mut i = last as isize;
+    while i >= 0 {
+        match strip_comment_line(lines[i as usize], tokens) {
+            Some(t) => texts.push(t),
+            None => break,
+        }
+        i -= 1;
+    }
+    texts.reverse();
+    let intent = texts
+        .iter()
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>()
+        .join(" ");
+    let letters = intent.chars().filter(|c| c.is_alphabetic()).count();
+    if letters >= 3 && intent.split_whitespace().count() >= 2 {
+        Some(intent)
+    } else {
+        None
+    }
+}
+
+/// A reference file the user attached to inform a completion (#45 context files).
+/// Its `content` is included (size-capped) as read-only CONTEXT in the prompt so
+/// the local model can draw on sibling project files when completing the current
+/// one. Deserialized from the frontend's `context` array.
+#[derive(serde::Deserialize)]
+pub struct ContextFile {
+    pub name: String,
+    pub content: String,
+}
+
+/// Per-file and total caps (bytes) on attached context, so a few large files can't
+/// blow past a small local model's context window. Each file is truncated to the
+/// per-file cap; files are included in order until the total cap is reached.
+const MAX_CONTEXT_PER_FILE: usize = 6000;
+const MAX_CONTEXT_TOTAL: usize = 24000;
+
+/// Truncate `s` to at most `max` bytes, backing off to the nearest char boundary
+/// so the result is always valid UTF-8. Pure.
+fn truncate_chars(s: &str, max: usize) -> String {
+    if s.len() <= max {
+        return s.to_string();
+    }
+    let mut end = max;
+    while end > 0 && !s.is_char_boundary(end) {
+        end -= 1;
+    }
+    s[..end].to_string()
+}
 
-    Ok(models
-        .iter()
-        .filter_map(|m| Some(m["name"].as_str()?.to_owned()))
-        .collect())
+/// Build the read-only CONTEXT preamble from attached reference files, size-capped
+/// (see [`MAX_CONTEXT_PER_FILE`]/[`MAX_CONTEXT_TOTAL`]). Each file becomes a labelled
+/// `--- <name> ---` block; empty/whitespace-only files are skipped. Returns an empty
+/// string when there is nothing to include, so [`completion_prompt`] can omit the
+/// section entirely. Pure + tested.
+fn build_context_block(files: &[ContextFile]) -> String {
+    let mut out = String::new();
+    let mut total = 0usize;
+    for f in files {
+        if total >= MAX_CONTEXT_TOTAL {
+            break;
+        }
+        let cap = MAX_CONTEXT_PER_FILE.min(MAX_CONTEXT_TOTAL - total);
+        let body = truncate_chars(f.content.trim(), cap);
+        if body.is_empty() {
+            continue;
+        }
+        total += body.len();
+        out.push_str("--- ");
+        out.push_str(f.name.trim());
+        out.push_str(" ---\n");
+        out.push_str(&body);
+        out.push_str("\n\n");
+    }
+    out
 }
 
-// ── Local code/text autocomplete (TODO Group M #45) ──────────────────────────
-//
-// DECISION A: completion is LOCAL OLLAMA ONLY and OPT-IN. We reuse `ollama_http`
-// against the same `/api/generate` endpoint as the rest of this module — no
-// remote endpoint is ever contacted. The frontend gates the call behind a
-// per-type `autocomplete` setting (default OFF) and an explicit Ctrl+Space, and
-// only fires after `ensure_ollama_running` succeeds; if Ollama isn't reachable
-// this returns the standard `not_running` error so the UI can fail silently.
-
-/// Build the fill-in-the-middle prompt sent to the model: the text before the
-/// caret (`prefix`) and after it (`suffix`), with a short instruction so a
-/// general instruct model returns only the continuation. Pure + tested.
-fn completion_prompt(prefix: &str, suffix: &str, language: &str) -> String {
-    let lang = if language.is_empty() { "text" } else { language };
-    format!(
-        "You are an autocomplete engine for a code/text editor. Continue the {lang} \
-document at the cursor. Reply with ONLY the text that should be inserted at the \
-cursor — no explanation, no code fences, no repetition of the surrounding text.\n\n\
-<before>\n{prefix}\n</before>\n<after>\n{suffix}\n</after>\n\nInsertion:"
-    )
+/// Build the user message paired with [`COMPLETION_SYSTEM`]: a per-caret TASK hint
+/// plus the text before the caret (`prefix`) and after it (`suffix`) as labelled
+/// sections, so the model inserts at the cursor rather than rewriting the document.
+/// The TASK is selected by `mode`: `Sentence` keeps the insertion to the current
+/// word/sentence/line (and, when mid-sentence, biases toward finishing it first),
+/// `Block` completes the current block/paragraph, and `Scope` the whole enclosing
+/// function or scope. When `context` is non-empty it is inserted as a read-only
+/// REFERENCE FILES section before BEFORE/AFTER. Pure + tested.
+fn completion_prompt(
+    prefix: &str,
+    suffix: &str,
+    language: &str,
+    mode: CompletionMode,
+    context: &str,
+) -> String {
+    let lang = if language.is_empty() {
+        "text"
+    } else {
+        language
+    };
+    // When the caret sits just after a natural-language comment, switch from
+    // continuing text to *implementing that comment as code* (#45 intent comments).
+    let task: String = if let Some(desc) = trailing_comment_intent(prefix, language) {
+        format!(
+            "TASK: The comment line(s) immediately above the cursor describe the code to write \
+next: \"{desc}\". Output the {lang} code that implements that description, starting on a new line \
+below the comment, matching the surrounding indentation and style, and joining smoothly into AFTER. \
+Write only that code — do not repeat, rewrite, or extend the comment, and add no explanations."
+        )
+    } else {
+        match mode {
+            CompletionMode::Sentence => {
+                if is_mid_sentence(prefix) {
+                    "TASK: The cursor is in the middle of a sentence. Output only what completes the \
+current word and sentence so it joins smoothly into AFTER. Keep it to a single sentence or line; do \
+not begin a new paragraph."
+                } else {
+                    "TASK: Continue from the end of BEFORE with a brief, on-topic insertion that leads \
+into AFTER. Keep it to one sentence or line; do not begin a new paragraph or topic."
+                }
+            }
+            CompletionMode::Block => {
+                "TASK: Continue from the end of BEFORE, completing the current line and the rest of the \
+current code block, statement, or paragraph. You may span several lines, but stop at the end of that \
+block — do not write the remainder of the document."
+            }
+            CompletionMode::Scope => {
+                "TASK: Continue from the end of BEFORE, completing the entire enclosing function, block, \
+or scope — its full body, with balanced brackets and indentation — so it joins into AFTER. Stop at \
+the end of that function or scope; do not continue past it."
+            }
+        }
+        .to_string()
+    };
+    let reference = if context.is_empty() {
+        String::new()
+    } else {
+        format!(
+            "REFERENCE FILES (read-only context from the project — use only to inform the \
+insertion; never output, quote, or repeat them):\n{context}\n"
+        )
+    };
+    format!("Language: {lang}\n{task}\n\n{reference}BEFORE:\n{prefix}\n\nAFTER:\n{suffix}")
 }
 
-/// Strip wrapping artefacts a chat model sometimes adds around a raw completion
-/// (leading/trailing code fences). Pure + tested.
+/// Strip wrapping artefacts a chat model sometimes adds around a raw completion:
+/// a leading conversational preamble line ("Here is the continuation:") and
+/// leading/trailing code fences. Conservative — a preamble line is dropped only
+/// when it clearly reads as a preface AND ends with ':', so real first lines are
+/// never eaten. Pure + tested.
 fn clean_completion(raw: &str) -> String {
-    let mut s = raw.trim_end_matches('\n').to_string();
+    let mut s = raw.trim_matches('\n').to_string();
+
+    // Defense in depth (the system prompt already forbids it): drop a leading
+    // preamble line if the model added one anyway.
+    if let Some(nl) = s.find('\n') {
+        let first = s[..nl].trim();
+        let lower = first.to_ascii_lowercase();
+        let is_preamble = first.ends_with(':')
+            && [
+                "here is",
+                "here's",
+                "here are",
+                "sure",
+                "certainly",
+                "of course",
+                "the continuation",
+                "continuation",
+                "the reformatted",
+                "the completed",
+            ]
+            .iter()
+            .any(|p| lower.starts_with(p));
+        if is_preamble {
+            s = s[nl + 1..].trim_start_matches('\n').to_string();
+        }
+    }
+
     // Drop a leading ```lang fence and a trailing ``` if the model wrapped it.
     if s.starts_with("```") {
         if let Some(nl) = s.find('\n') {
@@ -508,6 +1860,48 @@ fn clean_completion(raw: &str) -> String {
     s
 }
 
+/// Smallest overlap we bother trimming, in chars — short enough to catch a
+/// repeated word/operator ("fox", "a +") but above incidental 1–2 char matches.
+const MIN_SEAM_OVERLAP: usize = 3;
+
+/// Largest number of leading chars of `b` that are also a suffix of `a` (aligned
+/// on char boundaries); 0 when there is no overlap. Completions are short, so the
+/// quadratic scan is cheap. Pure + tested.
+fn overlap_len(a: &str, b: &str) -> usize {
+    let max = a.len().min(b.len());
+    for k in (1..=max).rev() {
+        if b.is_char_boundary(k) && a.is_char_boundary(a.len() - k) && a[a.len() - k..] == b[..k] {
+            return k;
+        }
+    }
+    0
+}
+
+/// Remove text the model echoed from the surrounding context, so only the genuinely
+/// new insertion remains. Small models often repeat the word/line just before the
+/// cursor (BEFORE "…return " → completion "return a + b") or pre-echo the text just
+/// after it. Trims a leading run of `completion` that repeats the tail of `prefix`
+/// and a trailing run that repeats the head of `suffix`, ignoring whitespace at the
+/// seam. Pure + tested.
+fn trim_context_overlap(prefix: &str, suffix: &str, completion: &str) -> String {
+    // Leading overlap with the end of BEFORE.
+    let head = completion.trim_start();
+    let p = prefix.trim_end();
+    let mut c = match overlap_len(p, head) {
+        n if n >= MIN_SEAM_OVERLAP => head[n..].trim_start(),
+        _ => completion,
+    };
+
+    // Trailing overlap with the start of AFTER.
+    let tail = c.trim_end();
+    let s = suffix.trim_start();
+    if overlap_len(tail, s) >= MIN_SEAM_OVERLAP {
+        let m = overlap_len(tail, s);
+        c = tail[..tail.len() - m].trim_end();
+    }
+    c.to_string()
+}
+
 /// Single-shot local completion: given the text around the caret, ask the local
 /// Ollama `model` for the insertion. Local-only (`ollama_http` talks to
 /// 127.0.0.1:11434); returns `not_running` when Ollama isn't reachable.
@@ -517,22 +1911,194 @@ pub async fn complete_text(
     suffix: String,
     model: String,
     language: String,
+    mode: Option<String>,
+    context: Option<Vec<ContextFile>>,
 ) -> Result<String, String> {
-    let prompt = completion_prompt(&prefix, &suffix, &language);
-    // `stream: false` returns one JSON object with the full `response`. Cap the
-    // output and use a low temperature so completions are short and deterministic.
+    let mode = CompletionMode::parse(mode.as_deref().unwrap_or("sentence"));
+    let context_block = context
+        .as_deref()
+        .map(build_context_block)
+        .unwrap_or_default();
+    let user = completion_prompt(&prefix, &suffix, &language, mode, &context_block);
+    // Implementing a comment needs room for a whole statement/block even in the
+    // conservative Sentence mode, so give intent completions at least the Block cap.
+    let num_predict = if trailing_comment_intent(&prefix, &language).is_some() {
+        mode.num_predict().max(CompletionMode::Block.num_predict())
+    } else {
+        mode.num_predict()
+    };
+    // `/api/chat` with a system role keeps a chat model from treating the text as
+    // a task to rewrite. `stream: false` returns one JSON object; low temperature
+    // + a mode-scaled output cap keep completions tight and deterministic.
+    let body = serde_json::json!({
+        "model": model,
+        "stream": false,
+        "messages": [
+            { "role": "system", "content": COMPLETION_SYSTEM },
+            { "role": "user", "content": user }
+        ],
+        "options": { "temperature": 0.1, "num_predict": num_predict }
+    })
+    .to_string();
+    let response = ollama_http("POST", "/api/chat", Some(&body))?;
+    let v: serde_json::Value =
+        serde_json::from_str(&response).map_err(|e| format!("ollama json: {e}"))?;
+    let text = v["message"]["content"].as_str().unwrap_or("");
+    let text = clean_completion(text);
+    Ok(trim_context_overlap(&prefix, &suffix, &text))
+}
+
+// ── Local grammar / spelling check (TODO Group M #45 follow-up) ───────────────
+//
+// Like the autocomplete above, this is LOCAL OLLAMA ONLY and OPT-IN: it reuses
+// `ollama_http` against 127.0.0.1's `/api/chat`, never a remote endpoint. The
+// editor sends the document text; the model returns a JSON list of issues, each
+// with the offending substring, a category (spelling/grammar/style), a one-line
+// message, and a suggested fix. The frontend resolves each issue to a character
+// range and underlines it (colour by category). Offsets are NOT asked of the
+// model — LLMs count characters unreliably — so we send the text with 1-based
+// line-number prefixes and the model reports WHICH line each issue is on, which
+// the frontend resolver uses to disambiguate duplicates.
+
+/// One proofreading issue the local model found. `bad` is the exact offending
+/// substring as it appears in the source (so the frontend can locate it); `line`
+/// is its 1-based line in the submitted text, used as a resolution hint.
+#[derive(serde::Serialize, Clone, PartialEq, Debug)]
+pub struct GrammarIssue {
+    /// 1-based line number in the submitted text.
+    pub line: u32,
+    /// The exact offending text as it appears in the source.
+    pub bad: String,
+    /// Suggested replacement ("" when the fix is simply to delete `bad`).
+    pub suggestion: String,
+    /// "spelling" | "grammar" | "style" (anything else is normalised to "grammar").
+    pub category: String,
+    /// Short human-readable explanation of the problem.
+    pub message: String,
+}
+
+/// Largest document (chars) we submit for a grammar check, so a huge file can't
+/// blow past a small local model's context window. Lines beyond the cap are not
+/// checked; because the cap only drops a trailing slice, the 1-based line numbers
+/// of everything before it stay valid for the frontend resolver.
+const MAX_GRAMMAR_CHARS: usize = 12000;
+
+/// System message turning a chat model into a strict proofreader that emits only
+/// machine-readable JSON. Pure + sent as the chat `system` role.
+const GRAMMAR_SYSTEM: &str = "You are a meticulous proofreader inside a text editor. You receive a \
+document whose lines are each prefixed with \"<n>: \" (a 1-based line number then a colon and a space). \
+Find ONLY genuine spelling, grammar, and punctuation mistakes — do not rewrite for style preference, do \
+not flag correct text, and do not invent issues. Respond with ONLY a JSON array (no prose, no code \
+fences) of objects, each exactly: {\"line\": <number>, \"bad\": \"<exact text from the document WITHOUT \
+the line-number prefix>\", \"suggestion\": \"<corrected replacement for bad>\", \"category\": one of \
+\"spelling\", \"grammar\", \"style\", \"message\": \"<short reason>\"}. The \"bad\" string must be copied \
+verbatim from the document so it can be located, and kept as short as possible (the smallest span that \
+contains the error). If there are no mistakes, respond with exactly [].";
+
+/// Per-language preamble appended to the user message so the model ignores markup
+/// it shouldn't proofread (LaTeX commands, Markdown syntax). Pure + tested.
+fn grammar_language_hint(language: &str) -> &'static str {
+    match language {
+        "latex" | "tex" => {
+            "This is a LaTeX document: ignore commands (\\command), math (between $...$ or \\[...\\]), \
+labels, citations, and environment markers — proofread only the human-readable prose.\n"
+        }
+        "markdown" => {
+            "This is Markdown: ignore code spans/blocks, link/image syntax, and formatting markers — \
+proofread only the human-readable prose.\n"
+        }
+        _ => "",
+    }
+}
+
+/// Prefix each line of `text` with its 1-based number and a colon, so the model
+/// can report which line an issue is on. The numbering matches the frontend's
+/// notion of a line (split on '\n'), so the resolver's line hint lines up. Pure +
+/// tested.
+fn number_lines(text: &str) -> String {
+    let mut out = String::with_capacity(text.len() + text.len() / 8 + 8);
+    for (i, line) in text.split('\n').enumerate() {
+        out.push_str(&format!("{}: {}\n", i + 1, line));
+    }
+    out
+}
+
+/// Extract the JSON array from a model reply that may carry stray prose or code
+/// fences, then build issues from it. Tolerant: a reply with no array, or a
+/// single malformed object, yields the issues that DID parse (a failed check
+/// shows fewer/no marks rather than erroring). The category is normalised to one
+/// of the three known kinds and entries with an empty `bad` are dropped. Pure +
+/// tested.
+fn parse_grammar_issues(raw: &str) -> Vec<GrammarIssue> {
+    let start = match raw.find('[') {
+        Some(i) => i,
+        None => return Vec::new(),
+    };
+    let end = match raw.rfind(']') {
+        Some(i) => i,
+        None => return Vec::new(),
+    };
+    if end <= start {
+        return Vec::new();
+    }
+    let arr: Vec<serde_json::Value> = serde_json::from_str(&raw[start..=end]).unwrap_or_default();
+    arr.into_iter()
+        .filter_map(|v| {
+            let bad = v["bad"].as_str().unwrap_or("").to_string();
+            if bad.trim().is_empty() {
+                return None;
+            }
+            let line = v["line"].as_u64().unwrap_or(1).max(1) as u32;
+            let category = match v["category"].as_str().unwrap_or("grammar") {
+                "spelling" => "spelling",
+                "style" => "style",
+                _ => "grammar",
+            }
+            .to_string();
+            Some(GrammarIssue {
+                line,
+                bad,
+                suggestion: v["suggestion"].as_str().unwrap_or("").to_string(),
+                category,
+                message: v["message"].as_str().unwrap_or("").to_string(),
+            })
+        })
+        .collect()
+}
+
+/// Single-shot local grammar/spelling check: send the document `text` to the
+/// local Ollama `model` and return the issues it found. Local-only (`ollama_http`
+/// talks to 127.0.0.1:11434); returns `not_running` when Ollama isn't reachable.
+/// `language` (the file's syntax language, e.g. "latex"/"markdown") tailors the
+/// prompt so markup isn't proofread as prose.
+#[tauri::command]
+pub async fn check_grammar(
+    text: String,
+    model: String,
+    language: String,
+) -> Result<Vec<GrammarIssue>, String> {
+    let truncated = truncate_chars(&text, MAX_GRAMMAR_CHARS);
+    let numbered = number_lines(&truncated);
+    let hint = grammar_language_hint(&language);
+    let user = format!("{hint}Proofread this document:\n\n{numbered}");
+    // `/api/chat` with a system role keeps a chat model from treating the text as
+    // a task; `stream: false` returns one JSON object; temperature 0 + a generous
+    // output cap let it list every issue deterministically.
     let body = serde_json::json!({
         "model": model,
-        "prompt": prompt,
         "stream": false,
-        "options": { "temperature": 0.1, "num_predict": 128 }
+        "messages": [
+            { "role": "system", "content": GRAMMAR_SYSTEM },
+            { "role": "user", "content": user }
+        ],
+        "options": { "temperature": 0.0, "num_predict": 1024 }
     })
     .to_string();
-    let response = ollama_http("POST", "/api/generate", Some(&body))?;
+    let response = ollama_http("POST", "/api/chat", Some(&body))?;
     let v: serde_json::Value =
         serde_json::from_str(&response).map_err(|e| format!("ollama json: {e}"))?;
-    let text = v["response"].as_str().unwrap_or("");
-    Ok(clean_completion(text))
+    let content = v["message"]["content"].as_str().unwrap_or("");
+    Ok(parse_grammar_issues(content))
 }
 
 /// Result of preparing a local Ollama agent for vibe.
@@ -611,6 +2177,180 @@ pub async fn ensure_vibe_ollama_model(model: String) -> Result<String, String> {
     Ok(alias)
 }
 
+// ── Local-model coding agents (ollama launch + fallbacks) ─────────────────────
+//
+// Beyond Mistral's `vibe` (see `prepare_local_agent`), the single active local
+// Ollama model can drive other coding agents. The preferred path is Ollama's own
+// `ollama launch <agent> --model <model>` (shipped v0.15): it wires Claude Code,
+// Codex, OpenCode and Droid to the local server — including Claude Code's
+// Anthropic-compatible endpoint, which we can't hand-roll the way vibe gets an
+// OpenAI one. When `ollama launch` is unavailable we fall back to a direct
+// invocation for the agents that natively accept a local Ollama endpoint.
+
+/// A coding agent that can drive the local Ollama model.
+#[derive(Clone, Copy)]
+struct LocalDriver {
+    /// Stable id used by the frontend picker and `prepare_local_launch`.
+    id: &'static str,
+    /// Human-readable label.
+    label: &'static str,
+    /// The agent's own binary name. The driver is only offered when this is
+    /// actually installed — `ollama launch <sub>` still drives the agent's CLI,
+    /// so a missing binary means the tab can't run regardless of `launch`.
+    bin: &'static str,
+    /// `ollama launch <sub> --model <model>` subcommand, when supported.
+    launch_sub: Option<&'static str>,
+    /// Direct fallback when `ollama launch` is unavailable: the binary to spawn
+    /// and its args (with the `{model}` placeholder substituted). `None` means
+    /// the agent can only be wired up by `ollama launch` itself.
+    fallback: Option<(&'static str, &'static [&'static str])>,
+}
+
+/// Registry of local-model coding agents, in picker order. `vibe` is intentionally
+/// absent — it keeps its bespoke per-model VIBE_HOME path in `prepare_local_agent`.
+const LOCAL_DRIVERS: &[LocalDriver] = &[
+    LocalDriver {
+        id: "claude",
+        label: "Claude Code",
+        bin: "claude",
+        launch_sub: Some("claude"),
+        // Claude Code needs an Anthropic-compatible endpoint, which only
+        // `ollama launch` stands up — no reliable hand-rolled fallback.
+        fallback: None,
+    },
+    LocalDriver {
+        id: "codex",
+        label: "Codex",
+        bin: "codex",
+        launch_sub: Some("codex"),
+        // `codex --oss -m <model>` talks to the local Ollama server directly.
+        fallback: Some(("codex", &["--oss", "-m", "{model}"])),
+    },
+    LocalDriver {
+        id: "opencode",
+        label: "OpenCode",
+        bin: "opencode",
+        launch_sub: Some("opencode"),
+        // OpenCode's built-in `ollama` provider; `--model ollama/<model>` selects it.
+        fallback: Some(("opencode", &["--model", "ollama/{model}"])),
+    },
+    LocalDriver {
+        id: "droid",
+        label: "Droid",
+        bin: "droid",
+        launch_sub: Some("droid"),
+        // Droid is configured via ~/.factory/config.json; only `ollama launch`
+        // writes that wiring for us.
+        fallback: None,
+    },
+    LocalDriver {
+        id: "openclaw",
+        label: "OpenClaw",
+        bin: "openclaw",
+        launch_sub: Some("openclaw"),
+        // Launch-only: `ollama launch openclaw` installs OpenClaw if missing and
+        // stands up its gateway against the local Ollama endpoint. There's no
+        // documented standalone flag to point `openclaw` at a local server, so
+        // no hand-rolled fallback.
+        fallback: None,
+    },
+];
+
+/// True when the installed Ollama exposes the `launch` subcommand (v0.15+).
+/// Cheap probe: `ollama launch --help` exits 0 only when the subcommand exists.
+fn ollama_has_launch() -> bool {
+    crate::paths::command_no_window("ollama")
+        .args(["launch", "--help"])
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
+
+/// Build the fallback launch spec for a driver, substituting `{model}`. Pure +
+/// tested; `prepare_local_launch` uses it only when `ollama launch` is missing.
+fn fallback_spec(driver: &LocalDriver, model: &str) -> Option<LocalLaunchSpec> {
+    driver.fallback.map(|(bin, args)| LocalLaunchSpec {
+        cmd: bin.to_string(),
+        args: args.iter().map(|a| a.replace("{model}", model)).collect(),
+    })
+}
+
+/// One local-model driver plus whether Eldrun currently has a way to launch it.
+#[derive(serde::Serialize)]
+pub struct LocalDriverInfo {
+    pub id: String,
+    pub label: String,
+    /// True when the agent's binary is installed *and* Eldrun has a way to wire
+    /// it to the local model (`ollama launch` supports it, or a direct fallback
+    /// exists). The menu hides drivers that aren't installed or are unreachable.
+    pub available: bool,
+}
+
+/// List the local-model coding agents (Claude Code, Codex, OpenCode, Droid) with
+/// their availability, so the Local Model menu can offer them alongside
+/// Mistral/vibe. Probes `ollama launch` once.
+#[tauri::command]
+pub async fn list_local_drivers() -> Vec<LocalDriverInfo> {
+    let has_launch = ollama_has_launch();
+    LOCAL_DRIVERS
+        .iter()
+        .map(|d| LocalDriverInfo {
+            id: d.id.to_string(),
+            label: d.label.to_string(),
+            // Both must hold: the agent itself is installed, and we have a wiring
+            // path (ollama launch or a direct fallback). A driver whose binary is
+            // missing (e.g. Droid) is no longer offered.
+            available: crate::commands::agents::binary_is_installed(d.bin)
+                && ((d.launch_sub.is_some() && has_launch) || d.fallback.is_some()),
+        })
+        .collect()
+}
+
+/// The command + args to spawn for a local-model agent tab.
+#[derive(serde::Serialize)]
+pub struct LocalLaunchSpec {
+    pub cmd: String,
+    pub args: Vec<String>,
+}
+
+/// Resolve how to drive the local Ollama `model` through `agent` (one of the
+/// [`LOCAL_DRIVERS`] ids). Prefers `ollama launch <agent> --model <model>`; falls
+/// back to a direct invocation when launch is unavailable. Errors when the agent
+/// is unknown, or it is launch-only and `ollama launch` is missing. The model is
+/// validated and passed as a discrete arg (no shell), so it can't inject.
+#[tauri::command]
+pub async fn prepare_local_launch(agent: String, model: String) -> Result<LocalLaunchSpec, String> {
+    validate_model_name(&model)?;
+    let driver = LOCAL_DRIVERS
+        .iter()
+        .find(|d| d.id == agent)
+        .ok_or_else(|| format!("unknown local driver: {agent}"))?;
+
+    if let Some(sub) = driver.launch_sub {
+        if ollama_has_launch() {
+            return Ok(LocalLaunchSpec {
+                cmd: "ollama".to_string(),
+                args: vec![
+                    "launch".to_string(),
+                    sub.to_string(),
+                    "--model".to_string(),
+                    model,
+                ],
+            });
+        }
+    }
+
+    fallback_spec(driver, &model).ok_or_else(|| {
+        format!(
+            "{} can only drive a local model through `ollama launch`, which isn't \
+             available. Update Ollama (v0.15+) to enable it.",
+            driver.label
+        )
+    })
+}
+
 fn sanitize_alias(model: &str) -> String {
     model.replace(':', "-")
 }
@@ -631,9 +2371,7 @@ fn validate_model_name(model: &str) -> Result<(), String> {
         .chars()
         .find(|c| !(c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-' | ':' | '/' | '@')))
     {
-        return Err(format!(
-            "invalid character {bad:?} in model name '{model}'"
-        ));
+        return Err(format!("invalid character {bad:?} in model name '{model}'"));
     }
     Ok(())
 }
@@ -724,6 +2462,37 @@ mod tests {
         }
     }
 
+    // ── local-driver registry (ollama launch + fallbacks) ────────────────────
+
+    #[test]
+    fn codex_fallback_substitutes_model_for_oss_mode() {
+        let d = LOCAL_DRIVERS.iter().find(|d| d.id == "codex").unwrap();
+        let spec = fallback_spec(d, "qwen2.5-coder:7b").expect("codex has a fallback");
+        assert_eq!(spec.cmd, "codex");
+        assert_eq!(spec.args, vec!["--oss", "-m", "qwen2.5-coder:7b"]);
+    }
+
+    #[test]
+    fn opencode_fallback_prefixes_the_ollama_provider() {
+        let d = LOCAL_DRIVERS.iter().find(|d| d.id == "opencode").unwrap();
+        let spec = fallback_spec(d, "llama3.2").expect("opencode has a fallback");
+        assert_eq!(spec.cmd, "opencode");
+        assert_eq!(spec.args, vec!["--model", "ollama/llama3.2"]);
+    }
+
+    #[test]
+    fn launch_only_drivers_have_no_fallback() {
+        // Claude Code / Droid need `ollama launch`; there is no hand-rolled spec.
+        for id in ["claude", "droid"] {
+            let d = LOCAL_DRIVERS.iter().find(|d| d.id == id).unwrap();
+            assert!(
+                fallback_spec(d, "any:model").is_none(),
+                "{id} must be launch-only"
+            );
+            assert!(d.launch_sub.is_some(), "{id} must support ollama launch");
+        }
+    }
+
     #[test]
     fn model_block_with_validated_name_has_no_stray_quotes_or_newlines_in_value() {
         // Defense in depth: once validated, the interpolated name can never break
@@ -800,11 +2569,111 @@ mod tests {
         );
     }
 
+    // ── friendly error mapping: broken Ollama runner (#vibe 500) ─────────────
+
+    #[test]
+    fn friendly_ollama_error_detects_missing_runner() {
+        // The exact shape Ollama returns when its llama-server binary is absent —
+        // this is what surfaces through vibe as an "internal server error".
+        let raw = "error starting llama-server: llama-server binary not found \
+            (checked: /usr/local/lib/ollama/llama-server, ...). Run 'cmake -S \
+            llama/server --preset cpu && cmake --build --preset cpu' first";
+        let msg = friendly_ollama_error(raw);
+        assert!(
+            msg.contains("inference runner") && msg.contains("incomplete"),
+            "missing-runner error should be rewritten to an actionable message, got: {msg}"
+        );
+        // It points the user at the reinstall command.
+        assert!(msg.contains(ollama_install_cmd()));
+        // And it no longer leaks the raw cmake/build hint.
+        assert!(!msg.contains("cmake"));
+    }
+
+    #[test]
+    fn friendly_ollama_error_is_case_insensitive() {
+        let msg = friendly_ollama_error("LLAMA-SERVER binary NOT FOUND");
+        assert!(msg.contains("inference runner"));
+    }
+
+    #[test]
+    fn friendly_ollama_error_passes_through_unrelated() {
+        // Errors we don't special-case must be returned verbatim, not swallowed.
+        for raw in [
+            "model 'foo' not found, try pulling it first",
+            "out of memory",
+            "HTTP 500",
+        ] {
+            assert_eq!(friendly_ollama_error(raw), raw);
+        }
+    }
+
+    // ── registry search HTML parsing ─────────────────────────────────────────
+
+    // Trimmed-down but structurally faithful fixture of two ollama.com/search
+    // result cards (same `x-test-*` hooks the live page emits).
+    const SEARCH_FIXTURE: &str = r#"
+      <ul role="list">
+      <li x-test-model class="flex">
+        <a href="/library/glm-5.2">
+          <h2><span x-test-search-response-title>glm-5.2</span></h2>
+          <p class="max-w-lg break-words text-md">GLM-5.2 is Z.ai&#39;s flagship model &amp; more.</p>
+          <span x-test-capability class="...">tools</span>
+          <span x-test-capability class="...">thinking</span>
+          <span x-test-size class="...">8b</span>
+          <span x-test-size class="...">355b</span>
+          <span x-test-pull-count>65.8K</span>
+          <span x-test-updated>1 week ago</span>
+        </a>
+      </li>
+      <li x-test-model class="flex">
+        <a href="/library/nomic-embed-text">
+          <h2><span x-test-search-response-title>nomic-embed-text</span></h2>
+          <p class="max-w-lg break-words text-md">High-quality text embeddings.</p>
+          <span x-test-capability class="...">embedding</span>
+          <span x-test-size class="...">latest</span>
+          <span x-test-pull-count>30M</span>
+          <span x-test-updated>1 year ago</span>
+        </a>
+      </li>
+      </ul>"#;
+
+    #[test]
+    fn parse_search_html_extracts_all_fields() {
+        let models = parse_search_html(SEARCH_FIXTURE);
+        assert_eq!(models.len(), 2);
+
+        let glm = &models[0];
+        assert_eq!(glm.name, "glm-5.2");
+        // HTML entities are unescaped.
+        assert_eq!(glm.description, "GLM-5.2 is Z.ai's flagship model & more.");
+        assert_eq!(glm.capabilities, vec!["tools", "thinking"]);
+        assert_eq!(glm.sizes, vec!["8b", "355b"]);
+        assert_eq!(glm.pulls, "65.8K");
+        assert_eq!(glm.updated, "1 week ago");
+
+        let nomic = &models[1];
+        assert_eq!(nomic.name, "nomic-embed-text");
+        assert_eq!(nomic.capabilities, vec!["embedding"]);
+        assert_eq!(nomic.sizes, vec!["latest"]);
+    }
+
+    #[test]
+    fn parse_search_html_empty_when_no_cards() {
+        assert!(parse_search_html("<html><body>no results</body></html>").is_empty());
+    }
+
+    #[test]
+    fn percent_encode_query_escapes_unsafe_chars() {
+        assert_eq!(percent_encode_query("llama 3.2"), "llama%203.2");
+        assert_eq!(percent_encode_query("a&b=c"), "a%26b%3Dc");
+        assert_eq!(percent_encode_query("qwen2.5-coder"), "qwen2.5-coder");
+    }
+
     // ── completion prompt construction (#45) ──────────────────────────────────
 
     #[test]
     fn completion_prompt_includes_prefix_suffix_and_language() {
-        let p = completion_prompt("let x =", " + 1;", "rust");
+        let p = completion_prompt("let x =", " + 1;", "rust", CompletionMode::Sentence, "");
         assert!(p.contains("let x ="), "prefix must be embedded");
         assert!(p.contains(" + 1;"), "suffix must be embedded");
         assert!(p.contains("rust"), "language must be named");
@@ -814,8 +2683,216 @@ mod tests {
 
     #[test]
     fn completion_prompt_defaults_empty_language_to_text() {
-        let p = completion_prompt("a", "b", "");
-        assert!(p.contains("text document") || p.contains("the text document"));
+        let p = completion_prompt("a", "b", "", CompletionMode::Sentence, "");
+        assert!(
+            p.contains("Language: text"),
+            "empty language defaults to text"
+        );
+    }
+
+    #[test]
+    fn completion_prompt_labels_before_and_after_sections() {
+        // The BEFORE/AFTER framing is what stops a chat model rewriting the doc.
+        let p = completion_prompt("pre", "post", "rust", CompletionMode::Sentence, "");
+        assert!(p.contains("BEFORE:\npre"));
+        assert!(p.contains("AFTER:\npost"));
+        assert!(p.find("BEFORE:").unwrap() < p.find("AFTER:").unwrap());
+    }
+
+    #[test]
+    fn build_context_block_labels_files_and_skips_empty() {
+        let files = vec![
+            ContextFile {
+                name: "util.rs".into(),
+                content: "fn helper() {}".into(),
+            },
+            ContextFile {
+                name: "blank.rs".into(),
+                content: "   \n  ".into(),
+            },
+            ContextFile {
+                name: "types.rs".into(),
+                content: "struct Foo;".into(),
+            },
+        ];
+        let block = build_context_block(&files);
+        assert!(block.contains("--- util.rs ---\nfn helper() {}"));
+        assert!(block.contains("--- types.rs ---\nstruct Foo;"));
+        // Whitespace-only files contribute nothing.
+        assert!(!block.contains("blank.rs"));
+        // No files → empty string, so the prompt omits the section.
+        assert_eq!(build_context_block(&[]), "");
+    }
+
+    #[test]
+    fn build_context_block_caps_total_size() {
+        let big = "x".repeat(20_000);
+        let files = vec![
+            ContextFile {
+                name: "a".into(),
+                content: big.clone(),
+            },
+            ContextFile {
+                name: "b".into(),
+                content: big.clone(),
+            },
+            ContextFile {
+                name: "c".into(),
+                content: big,
+            },
+        ];
+        let block = build_context_block(&files);
+        // Each file is per-file capped and the total is bounded; allow for the
+        // labels/separators on top of the included bytes.
+        assert!(
+            block.len() <= MAX_CONTEXT_TOTAL + 256,
+            "total context stays bounded"
+        );
+        // The first file always makes it in.
+        assert!(block.contains("--- a ---"));
+    }
+
+    #[test]
+    fn truncate_chars_respects_utf8_boundaries() {
+        // Cutting mid-multibyte must back off to a valid boundary, never panic.
+        let s = "a\u{00e9}b"; // 'é' is 2 bytes → byte index 2 splits it
+        assert_eq!(truncate_chars(s, 2), "a");
+        assert_eq!(truncate_chars(s, 100), s);
+    }
+
+    #[test]
+    fn completion_prompt_embeds_reference_files_before_the_cursor_sections() {
+        let ctx = build_context_block(&[ContextFile {
+            name: "lib.rs".into(),
+            content: "pub fn answer() -> i32 { 42 }".into(),
+        }]);
+        let p = completion_prompt("let x = ", "", "rust", CompletionMode::Sentence, &ctx);
+        assert!(p.contains("REFERENCE FILES"));
+        assert!(p.contains("pub fn answer"));
+        // Reference context precedes the BEFORE/AFTER framing.
+        assert!(p.find("REFERENCE FILES").unwrap() < p.find("BEFORE:").unwrap());
+        // With no context the section is omitted entirely.
+        let plain = completion_prompt("let x = ", "", "rust", CompletionMode::Sentence, "");
+        assert!(!plain.contains("REFERENCE FILES"));
+    }
+
+    #[test]
+    fn completion_mode_parse_and_caps_scale_by_mode() {
+        assert_eq!(CompletionMode::parse("block"), CompletionMode::Block);
+        assert_eq!(CompletionMode::parse("scope"), CompletionMode::Scope);
+        // Unknown / absent → the conservative default.
+        assert_eq!(CompletionMode::parse("sentence"), CompletionMode::Sentence);
+        assert_eq!(CompletionMode::parse("bogus"), CompletionMode::Sentence);
+        // Caps grow with scope so bigger modes have room to finish.
+        assert!(
+            CompletionMode::Sentence.num_predict() < CompletionMode::Block.num_predict()
+                && CompletionMode::Block.num_predict() < CompletionMode::Scope.num_predict()
+        );
+    }
+
+    #[test]
+    fn completion_prompt_block_and_scope_drop_the_single_sentence_bias() {
+        // Block/scope allow multi-line output; they must NOT carry the sentence
+        // mode's "do not begin a new paragraph" restriction.
+        let mid = "fn add(a: i32, b: i32) {\n    ";
+        let block = completion_prompt(mid, "\n}", "rust", CompletionMode::Block, "");
+        assert!(block.contains("block"));
+        assert!(!block.contains("middle of a sentence"));
+
+        let scope = completion_prompt(mid, "\n}", "rust", CompletionMode::Scope, "");
+        assert!(scope.contains("function") && scope.contains("scope"));
+        assert!(!scope.contains("middle of a sentence"));
+    }
+
+    #[test]
+    fn trailing_comment_intent_detects_comment_above_a_fresh_line() {
+        // Caret on a fresh indented line directly below a `//` comment.
+        let p = "fn main() {\n    // new for loop to compute the sum\n    ";
+        assert_eq!(
+            trailing_comment_intent(p, "rust").as_deref(),
+            Some("new for loop to compute the sum")
+        );
+        // Caret at the end of the comment line itself (no newline yet).
+        let p2 = "# compute the average of the list";
+        assert_eq!(
+            trailing_comment_intent(p2, "python").as_deref(),
+            Some("compute the average of the list")
+        );
+    }
+
+    #[test]
+    fn trailing_comment_intent_merges_consecutive_comment_lines() {
+        let p = "    // compute the sum of all even numbers\n    /// and return the result\n    ";
+        assert_eq!(
+            trailing_comment_intent(p, "rust").as_deref(),
+            Some("compute the sum of all even numbers and return the result")
+        );
+        // Single-line block comment is recognised in C-family languages.
+        let blk = "/* build the lookup table */\n";
+        assert_eq!(
+            trailing_comment_intent(blk, "typescript").as_deref(),
+            Some("build the lookup table")
+        );
+    }
+
+    #[test]
+    fn trailing_comment_intent_ignores_non_instructions_and_prose() {
+        // Real code on the caret line → not an intent comment.
+        assert_eq!(trailing_comment_intent("let x = 1;\n", "rust"), None);
+        // Dividers / lone tokens don't read as instructions.
+        assert_eq!(trailing_comment_intent("// ----\n", "rust"), None);
+        assert_eq!(trailing_comment_intent("//\n", "rust"), None);
+        // Comment is no longer adjacent to the caret (intervening code line).
+        let gap = "// describe the loop\nlet y = 2;\n";
+        assert_eq!(trailing_comment_intent(gap, "rust"), None);
+        // Markdown headings must never be treated as code-intent comments.
+        assert_eq!(trailing_comment_intent("# My Heading\n", "markdown"), None);
+        // Shebang line is not a natural-language instruction.
+        assert_eq!(trailing_comment_intent("#!/bin/bash\n", "bash"), None);
+    }
+
+    #[test]
+    fn completion_prompt_switches_to_implement_mode_for_intent_comments() {
+        let p = "fn main() {\n    // new for loop to compute the sum\n    ";
+        let prompt = completion_prompt(p, "\n}", "rust", CompletionMode::Sentence, "");
+        // Implements the comment as code rather than continuing prose.
+        assert!(prompt.contains("implements that description"));
+        assert!(prompt.contains("new for loop to compute the sum"));
+        assert!(!prompt.contains("middle of a sentence"));
+        // Without a trailing comment it keeps the ordinary sentence behaviour.
+        let plain = completion_prompt("let x = ", "", "rust", CompletionMode::Sentence, "");
+        assert!(!plain.contains("implements that description"));
+    }
+
+    #[test]
+    fn is_mid_sentence_detects_unfinished_sentences() {
+        // Mid-sentence: ends on a word, comma, or trailing space after a word.
+        assert!(is_mid_sentence("The main advantages are"));
+        assert!(is_mid_sentence("I am writing to "));
+        assert!(is_mid_sentence("a, b,"));
+        // Not mid-sentence: terminator, newline, or empty (start of document).
+        assert!(!is_mid_sentence("Done."));
+        assert!(!is_mid_sentence("Why?"));
+        assert!(!is_mid_sentence("Header:"));
+        assert!(!is_mid_sentence("paragraph end.\n"));
+        assert!(!is_mid_sentence(""));
+    }
+
+    #[test]
+    fn completion_prompt_biases_to_finishing_the_sentence_when_mid_sentence() {
+        let mid = completion_prompt(
+            "I am writing to ",
+            " Best regards",
+            "text",
+            CompletionMode::Sentence,
+            "",
+        );
+        assert!(mid.contains("middle of a sentence"));
+        assert!(mid.contains("complete") || mid.contains("completes"));
+        // At a sentence boundary it switches to the plain-continuation hint.
+        let cont = completion_prompt("First line.\n", "", "text", CompletionMode::Sentence, "");
+        assert!(!cont.contains("middle of a sentence"));
+        assert!(cont.contains("Continue"));
     }
 
     #[test]
@@ -826,6 +2903,138 @@ mod tests {
         assert_eq!(clean_completion("plain"), "plain");
     }
 
+    #[test]
+    fn clean_completion_strips_conversational_preamble() {
+        // The exact failure the user hit: a chat model prefacing the answer.
+        assert_eq!(
+            clean_completion("Here is the reformatted version of the text:\nreturn a + b"),
+            "return a + b",
+        );
+        assert_eq!(clean_completion("Sure, here you go:\nx = 1"), "x = 1");
+        // A real first line that merely ends in ':' is NOT a preamble — keep it.
+        assert_eq!(
+            clean_completion("def foo():\n    return 1"),
+            "def foo():\n    return 1",
+        );
+        // A normal multi-line completion is untouched.
+        assert_eq!(clean_completion("a + b\nc + d"), "a + b\nc + d");
+    }
+
+    #[test]
+    fn trim_context_overlap_drops_echoed_prefix_tail() {
+        // The exact case from llama3.2:3b: BEFORE ends with "return ", model echoes it.
+        assert_eq!(
+            trim_context_overlap("    return ", "\n\nprint(x)", "return a + b"),
+            "a + b",
+        );
+        // Repeated trailing word.
+        assert_eq!(
+            trim_context_overlap("The quick brown fox", " over the dog", "fox jumps"),
+            "jumps",
+        );
+    }
+
+    #[test]
+    fn trim_context_overlap_drops_echoed_suffix_head() {
+        // Model pre-echoes the start of AFTER at the end of its insertion.
+        assert_eq!(
+            trim_context_overlap("a = ", " + 1", "compute() + 1"),
+            "compute()",
+        );
+    }
+
+    #[test]
+    fn trim_context_overlap_keeps_unrelated_completion() {
+        // No overlap → returned unchanged.
+        assert_eq!(
+            trim_context_overlap("I am writing to ", " Best regards", "express my thanks"),
+            "express my thanks",
+        );
+        // A 1–2 char incidental match is below the threshold, so it is NOT trimmed.
+        assert_eq!(
+            trim_context_overlap("foo a", "", "a list of items"),
+            "a list of items"
+        );
+    }
+
+    #[test]
+    fn overlap_len_finds_seam() {
+        assert_eq!(overlap_len("    return", "return a"), 6);
+        assert_eq!(overlap_len("brown fox", "fox jumps"), 3);
+        assert_eq!(overlap_len("hello", "world"), 0);
+    }
+
+    // ── grammar check: line numbering + JSON parsing ──────────────────────────
+
+    #[test]
+    fn number_lines_prefixes_each_line_one_based() {
+        assert_eq!(number_lines("a\nb"), "1: a\n2: b\n");
+        // A trailing newline produces a final (empty) numbered line; harmless.
+        assert_eq!(number_lines("only"), "1: only\n");
+    }
+
+    #[test]
+    fn parse_grammar_issues_reads_a_clean_array() {
+        let raw =
+            r#"[{"line":2,"bad":"teh","suggestion":"the","category":"spelling","message":"typo"}]"#;
+        let issues = parse_grammar_issues(raw);
+        assert_eq!(issues.len(), 1);
+        assert_eq!(
+            issues[0],
+            GrammarIssue {
+                line: 2,
+                bad: "teh".into(),
+                suggestion: "the".into(),
+                category: "spelling".into(),
+                message: "typo".into(),
+            }
+        );
+    }
+
+    #[test]
+    fn parse_grammar_issues_strips_prose_and_fences() {
+        // Models sometimes wrap the array in prose or a ```json fence; we extract
+        // the outermost [...] regardless.
+        let raw = "Sure! Here are the issues:\n```json\n[{\"line\":1,\"bad\":\"alot\",\"suggestion\":\"a lot\",\"category\":\"grammar\",\"message\":\"two words\"}]\n```";
+        let issues = parse_grammar_issues(raw);
+        assert_eq!(issues.len(), 1);
+        assert_eq!(issues[0].bad, "alot");
+        assert_eq!(issues[0].category, "grammar");
+    }
+
+    #[test]
+    fn parse_grammar_issues_normalises_category_and_drops_empty_bad() {
+        let raw = r#"[
+            {"line":1,"bad":"x","category":"weird","message":"m"},
+            {"line":1,"bad":"   ","category":"spelling","message":"blank"},
+            {"line":3,"bad":"y","category":"style"}
+        ]"#;
+        let issues = parse_grammar_issues(raw);
+        assert_eq!(issues.len(), 2, "blank-bad entry is dropped");
+        // Unknown category → grammar; missing suggestion/message default to "".
+        assert_eq!(issues[0].category, "grammar");
+        assert_eq!(issues[0].suggestion, "");
+        // Known categories pass through.
+        assert_eq!(issues[1].category, "style");
+    }
+
+    #[test]
+    fn parse_grammar_issues_empty_or_no_array() {
+        assert!(parse_grammar_issues("[]").is_empty());
+        assert!(parse_grammar_issues("no issues found").is_empty());
+        assert!(parse_grammar_issues("").is_empty());
+    }
+
+    #[test]
+    fn grammar_language_hint_targets_markup_languages() {
+        assert!(grammar_language_hint("latex").contains("LaTeX"));
+        assert!(grammar_language_hint("tex").contains("LaTeX"));
+        assert!(grammar_language_hint("markdown").contains("Markdown"));
+        // Plain text / code → no special markup hint.
+        assert_eq!(grammar_language_hint("text"), "");
+        assert_eq!(grammar_language_hint("rust"), "");
+    }
+
     // ── sanitize_alias turns ':' into '-' ─────────────────────────────────────
 
     #[test]
@@ -856,6 +3065,20 @@ mod tests {
         assert_eq!(active_model_count, 1);
     }
 
+    #[test]
+    fn model_directory_candidates_are_os_specific() {
+        let home = std::path::Path::new("/home/alice");
+        for os in [crate::paths::OsKind::Windows, crate::paths::OsKind::Macos] {
+            let dirs = ollama_model_dir_candidates(os, home, None);
+            assert_eq!(dirs, vec![home.join(".ollama/models")]);
+        }
+        let linux = ollama_model_dir_candidates(crate::paths::OsKind::Unix, home, None);
+        assert!(linux.contains(&home.join(".ollama/models")));
+        assert!(linux.contains(&std::path::PathBuf::from(
+            "/usr/share/ollama/.ollama/models"
+        )));
+    }
+
     /// Integration test: only runs when Ollama is reachable and has models.
     #[test]
     fn prepare_local_agent_integration_if_ollama_running() {
diff --git a/src-tauri/src/commands/openvpn.rs b/src-tauri/src/commands/openvpn.rs
index fda2e5e..e9184eb 100644
--- a/src-tauri/src/commands/openvpn.rs
+++ b/src-tauri/src/commands/openvpn.rs
@@ -2,15 +2,235 @@
 //!
 //! Tunnels are keyed by the local `.ovpn` config path so the same config is
 //! shared between project setup (browsing the remote) and later activation. The
-//! password is taken per call and never persisted (see `services::openvpn`).
+//! secrets are taken per call and never persisted unless the caller opts in (see
+//! `services::openvpn` and `services::remote_credentials`).
+//!
+//! A config can demand up to **two** secrets from us — an `auth-user-pass`
+//! account password and an encrypted key's passphrase — which OpenVPN prompts for
+//! separately. `openvpn_auth_needs` tells the UI which fields to show; the local
+//! root password is a third secret, but that one belongs to polkit/`pkexec`, not
+//! to Eldrun.
 
 use crate::services::openvpn;
+use serde::Serialize;
+use tauri::{AppHandle, Emitter};
+
+/// Which secrets `config` needs the user to supply, so the UI can show exactly
+/// those fields. The two are independent — a config can need both.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VpnAuthNeeds {
+    /// A bare `auth-user-pass` directive: server-side account auth, so we must
+    /// supply a username alongside the password (else OpenVPN prompts on stdin
+    /// and, with stdin closed, hangs).
+    pub username: bool,
+    /// An encrypted private key: OpenVPN asks `Enter Private Key Password:` for
+    /// it separately from the account password.
+    pub key_passphrase: bool,
+}
+
+/// Bring up (or reuse) the OpenVPN tunnel for `config`. Blocks until the tunnel
+/// is up or the attempt fails. While the handshake runs, each line OpenVPN emits
+/// is forwarded to the frontend as an `openvpn-progress` event (`{ config, line }`)
+/// so a VPN-gated activation / dialog can show the live handshake in a read-only
+/// log instead of an opaque spinner.
+///
+/// Two secrets, resolved independently. For each: a typed value wins; a
+/// `None`/empty one falls back to the saved credential for this config (the
+/// silent auto-connect path) and errors if none exists, so the caller can show
+/// the prompt.
+///  - `password` — the `auth-user-pass` account password, or for a config with no
+///    account, the key passphrase (the long-standing single-secret path).
+///  - `key_passphrase` — only for a config that has an encrypted key *and* an
+///    account; required in that case, since OpenVPN prompts for it separately.
+///
+/// `username` is the (non-secret) auth username for `auth-user-pass` configs.
+///
+/// `remember` is the "Save passphrase" checkbox, and **only** the checkbox:
+/// `Some(true)` saves the working secrets in the OS keychain (keyed by config path,
+/// written only *after* the tunnel is up), `Some(false)` — an explicit untick —
+/// clears any previously-saved ones, and `None` leaves the keychain untouched. It
+/// governs both secrets together: the UI offers one "save" toggle for the
+/// connection, not one per field.
+///
+/// The `None` case is load-bearing. A silent connect (`password: None`, no
+/// checkbox) authenticates *from* the saved passphrase — folding that into
+/// "unticked" deleted the passphrase it had just used, so the tunnel came up once
+/// and prompted ever after.
+#[tauri::command]
+pub async fn openvpn_connect(
+    app: AppHandle,
+    config: String,
+    username: Option<String>,
+    password: Option<String>,
+    key_passphrase: Option<String>,
+    remember: Option<bool>,
+) -> Result<(), String> {
+    use crate::services::remote_credentials as creds;
+    let account = creds::openvpn_account(&config);
+    let key_account = creds::openvpn_key_account(&config);
+    let user_account = creds::openvpn_user_account(&config);
+    let Some(pw) = password
+        .filter(|p| !p.is_empty())
+        .or_else(|| creds::get(&account))
+    else {
+        return Err("no VPN password provided and none saved".to_string());
+    };
+    // The key passphrase is a *second* prompt OpenVPN raises, so it is only needed
+    // when the config both has an encrypted key and takes its password for an
+    // account (otherwise `password` already is the key passphrase — see
+    // `services::openvpn::write_credfiles`). Erroring here rather than letting the
+    // handshake stall on an unanswered prompt is what makes the UI able to ask.
+    let needs_key = openvpn::config_requires_key_passphrase(&config)
+        && openvpn::config_requires_userpass(&config);
+    let key_passphrase = key_passphrase
+        .filter(|p| !p.is_empty())
+        .or_else(|| creds::get(&key_account));
+    if needs_key && key_passphrase.is_none() {
+        return Err("no VPN private-key passphrase provided and none saved".to_string());
+    }
+    // The username is the one non-secret of the three, and the only one that used to
+    // have no home when no project owned the tunnel — so a header-started connect
+    // supplied none, and `pkexec` had already raised its polkit prompt by the time the
+    // server rejected the login. Fall back to the saved one for exactly that case.
+    let username = username
+        .filter(|u| !u.is_empty())
+        .or_else(|| creds::get(&user_account));
+    // Offload to a blocking worker. `connect_streaming` is fully synchronous and
+    // blocks for the whole handshake — up to `CONNECT_TIMEOUT` (45s), and longer
+    // still while `pkexec` waits on the polkit prompt. Awaiting it directly on the
+    // async runtime starves a worker and froze the headless VPN connect; mirror
+    // `ssh_connect`, which spawn_blocks its ssh probe for exactly this reason.
+    tokio::task::spawn_blocking(move || {
+        openvpn::connect_streaming(
+            &config,
+            username.as_deref(),
+            &pw,
+            key_passphrase.as_deref(),
+            |line| {
+                let _ = app.emit(
+                    "openvpn-progress",
+                    serde_json::json!({ "config": config, "line": line }),
+                );
+            },
+        )?;
+        // Tunnel is up — honour the checkbox (save / clear / leave alone). The
+        // username rides the same checkbox as the secrets: it is useless on its own,
+        // and saving it while clearing them would leave a half-set that still prompts.
+        creds::remember_secret(&account, remember, Some(pw.as_str()));
+        creds::remember_secret(&key_account, remember, key_passphrase.as_deref());
+        creds::remember_secret(&user_account, remember, username.as_deref());
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("openvpn connect task failed: {e}"))?
+}
+
+/// Which secrets `config` needs from the user (see [`VpnAuthNeeds`]). The UI calls
+/// this when a config is chosen, to decide which fields to show and require.
+#[tauri::command]
+pub async fn openvpn_auth_needs(config: String) -> VpnAuthNeeds {
+    VpnAuthNeeds {
+        username: openvpn::config_requires_userpass(&config),
+        key_passphrase: openvpn::config_requires_key_passphrase(&config),
+    }
+}
+
+/// Whether this config can connect with **no prompt** — i.e. every secret it needs
+/// is already in the keychain. Lets the UI pre-check the "Save password" box and
+/// offer "Forget", without ever receiving a secret. A config needing two secrets
+/// with only one saved reports `false`: a silent connect would fail on the other.
+///
+/// The keychain reads below are why this (and its two siblings) are `async` +
+/// `spawn_blocking` rather than plain commands: a synchronous Tauri command runs
+/// on the **main thread**, and a Secret Service lookup is an unbounded D-Bus
+/// round-trip that blocks outright while the keyring is locked — waiting on an
+/// unlock prompt the user cannot reach, because the window is frozen mid-frame
+/// waiting for it. The auto-connect-on-launch path asks these questions before it
+/// does anything else, so on the main thread they are a startup freeze.
+#[tauri::command]
+pub async fn vpn_has_saved_password(config: String) -> bool {
+    tokio::task::spawn_blocking(move || has_saved_password_blocking(&config))
+        .await
+        // Unreadable keychain ⇒ "nothing saved" ⇒ the caller prompts. Never the
+        // other way round: claiming a secret exists would license a silent
+        // connect that then stalls on a prompt nobody sees.
+        .unwrap_or(false)
+}
+
+/// The blocking body of [`vpn_has_saved_password`], callable from the other
+/// keychain helpers without going through the command layer (and without each
+/// one spawning its own blocking task).
+fn has_saved_password_blocking(config: &str) -> bool {
+    use crate::services::remote_credentials as creds;
+    if !creds::has(&creds::openvpn_account(config)) {
+        return false;
+    }
+    let needs_key = openvpn::config_requires_key_passphrase(config)
+        && openvpn::config_requires_userpass(config);
+    !needs_key || creds::has(&creds::openvpn_key_account(config))
+}
+
+/// Whether `config` can be brought up with **no prompt of any kind** — the question
+/// a silent/auto connect must ask *before* it runs, because running it is what
+/// raises the polkit dialog: `pkexec` authenticates the user long before OpenVPN
+/// gets far enough to reject a login. An attempt made without everything it needs
+/// therefore doesn't fail cheaply — it costs the user a system password prompt, and
+/// then the modal costs them a second one. This is what stops that.
+///
+/// True when every secret the config needs is saved, *and* — for an `auth-user-pass`
+/// config — a username is available: either one the caller can supply (a project's
+/// spec) or one saved alongside the password. `vpn_has_saved_password` deliberately
+/// still answers the narrower keychain-state question the "Save password" checkbox
+/// and "Forget" button are asking; this one answers "would connecting now be silent?".
+#[tauri::command]
+pub async fn vpn_can_connect_silently(config: String, username: Option<String>) -> bool {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        if !has_saved_password_blocking(&config) {
+            return false;
+        }
+        if !openvpn::config_requires_userpass(&config) {
+            return true;
+        }
+        username.is_some_and(|u| !u.trim().is_empty())
+            || creds::get(&creds::openvpn_user_account(&config)).is_some()
+    })
+    .await
+    // "Can't tell" must mean "don't connect silently" — the whole point of this
+    // question is to avoid an elevation prompt for a connect that cannot succeed.
+    .unwrap_or(false)
+}
 
-/// Bring up (or reuse) the OpenVPN tunnel for `config`, authenticating with
-/// `password`. Blocks until the tunnel is up or the attempt fails.
+/// Forget every saved credential for `config` (explicit "log out" action) — the
+/// password, any separately-stored key passphrase, and the saved auth username, so a
+/// partial forget can't leave a stale half behind. The SSH-side twin is
+/// `remote_forget_password`.
 #[tauri::command]
-pub async fn openvpn_connect(config: String, password: String) -> Result<(), String> {
-    openvpn::connect(&config, &password)
+pub async fn vpn_forget_password(config: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || forget_password_blocking(&config))
+        .await
+        .map_err(|e| format!("forget credentials task failed: {e}"))?
+}
+
+/// The blocking body of [`vpn_forget_password`], so `openvpn_remove_config` can
+/// forget a config's credentials inside its own blocking task rather than nesting
+/// one command inside another.
+fn forget_password_blocking(config: &str) -> Result<(), String> {
+    use crate::services::remote_credentials as creds;
+    let pw = creds::set(&creds::openvpn_account(config), None);
+    let key = creds::set(&creds::openvpn_key_account(config), None);
+    let user = creds::set(&creds::openvpn_user_account(config), None);
+    pw.and(key).and(user)
+}
+
+/// Build the shell command that brings the tunnel up **interactively** (the
+/// passphrase is typed into a visible terminal, no askpass file). Returned for
+/// the frontend to type into a root-scope shell tab when headless connections are
+/// off (see `services::openvpn::interactive_connect_command`).
+#[tauri::command]
+pub async fn openvpn_login_command(config: String) -> Result<String, String> {
+    openvpn::interactive_connect_command(&config)
 }
 
 /// Tear down the OpenVPN tunnel for `config` if it is up. Idempotent.
@@ -19,15 +239,76 @@ pub async fn openvpn_disconnect(config: String) -> Result<(), String> {
     openvpn::disconnect(&config)
 }
 
+/// Tear down **every** registered tunnel on the **app-close path**, reporting whether
+/// they all went down. This is the checked twin of the exit-time `disconnect_all`: it
+/// touches the same set of tunnels, so that once it succeeds nothing is left for
+/// `RunEvent::Exit` to kill — which is what used to raise the polkit prompt *after* the
+/// window had already vanished. A refused prompt is an error here and leaves the tunnel
+/// registered *and* marks it declined, so the frontend can warn the user it is staying
+/// up — but the quit itself proceeds either way, and `RunEvent::Exit` will not re-ask
+/// for a declined config, so this is a one-shot: the user is asked once, not once per
+/// close attempt.
+///
+/// It enumerates the backend registries directly rather than taking a config from the
+/// frontend's `openvpn_active`: `active_configs` filters by a liveness probe, so a
+/// tunnel whose probe reads false would be skipped here yet still killed (and prompted
+/// for) by the exit-time `disconnect_all`. On Linux this raises the `pkexec` password
+/// prompt while the window is still on screen (the whole point); elsewhere it is the
+/// ordinary best-effort teardown.
+#[tauri::command]
+pub async fn openvpn_disconnect_all_on_quit() -> Result<(), String> {
+    // Offload for the same reason `openvpn_connect` does: the teardown is fully
+    // synchronous and blocks for as long as `pkexec` sits on the polkit prompt —
+    // i.e. until the user types a password. Awaiting that directly on the async
+    // runtime starves a worker while the window is still on screen and waiting.
+    tokio::task::spawn_blocking(openvpn::disconnect_all_checked)
+        .await
+        .map_err(|e| format!("openvpn teardown task failed: {e}"))?
+}
+
 /// Whether the OpenVPN tunnel for `config` is currently up.
 #[tauri::command]
 pub async fn openvpn_status(config: String) -> Result<bool, String> {
     Ok(openvpn::is_connected(&config))
 }
 
+/// Every config whose tunnel is up right now, regardless of which project asked
+/// for it. A tunnel reroutes the whole machine, so the frontend tracks it as a
+/// machine-level object (`stores/vpnStatus.ts`) rather than a per-project one; this
+/// is how that store seats itself on launch and re-seats after a renderer reload,
+/// where the tunnel outlives the window that started it.
+#[tauri::command]
+pub async fn openvpn_active() -> Result<Vec<String>, String> {
+    Ok(openvpn::active_configs())
+}
+
 /// Copy a selected `.ovpn` config into Eldrun's storage and return the stored
 /// path, so the project no longer depends on the original file's location.
 #[tauri::command]
 pub async fn openvpn_store_config(config: String) -> Result<String, String> {
     openvpn::store_config(&config)
 }
+
+/// List the `.ovpn` configs Eldrun has previously stored (newest first), so the
+/// project dialog can offer a previously-used config for reuse instead of
+/// browsing for the file again.
+#[tauri::command]
+pub async fn openvpn_list_configs() -> Result<Vec<openvpn::StoredConfig>, String> {
+    Ok(openvpn::list_configs())
+}
+
+/// Remove a stored `.ovpn` config from Eldrun's store, and with it every
+/// credential saved for it — a keychain entry keyed by a config that no longer
+/// exists is exactly the stale half `vpn_forget_password` exists to prevent.
+/// Order matters: the removal is the guarded step (must be a stored path, tunnel
+/// must be down), so it goes first — a refused removal leaves the credentials
+/// alone. Deletes Eldrun's copy only, never the user's original file.
+#[tauri::command]
+pub async fn openvpn_remove_config(config: String) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        openvpn::remove_config(&config)?;
+        forget_password_blocking(&config)
+    })
+    .await
+    .map_err(|e| format!("remove config task failed: {e}"))?
+}
diff --git a/src-tauri/src/commands/pdf_clip.rs b/src-tauri/src/commands/pdf_clip.rs
new file mode 100644
index 0000000..82c3b6f
--- /dev/null
+++ b/src-tauri/src/commands/pdf_clip.rs
@@ -0,0 +1,152 @@
+//! A small in-memory clipboard for PDF *pages*, so pages can move between two
+//! Eldrun windows.
+//!
+//! A detached subwindow (#42) is a separate WebView with its own JS heap, so a drag
+//! payload cannot simply be a JavaScript object — the bytes have to cross the
+//! process boundary. Tauri events *could* carry them, but an event payload is JSON,
+//! and a few MB of page bytes would become a multi-million-element number array on
+//! the way out and back. So the events carry only identity and coordinates, and the
+//! bytes ride here: the source window extracts the dragged pages into a small PDF and
+//! `pdf_clip_set`s it, and whichever window the drop lands in `pdf_clip_get`s it.
+//!
+//! The same slot backs copy/paste of pages between windows, which is the same
+//! problem without the pointer.
+//!
+//! This is a *transfer* buffer, not the OS clipboard: it holds only what Eldrun put
+//! there, it is not readable by other apps, and it dies with the process. Entries are
+//! kept only until `MAX_ENTRIES` newer ones push them out, which bounds the memory a
+//! long session can accumulate.
+
+use std::collections::VecDeque;
+use std::sync::Mutex;
+
+/// Mirrors `fs::MAX_BINARY_VIEW_BYTES`: the ceiling on a PDF Eldrun will read or
+/// write, applied here too so a drag cannot become an unbounded allocation.
+const MAX_CLIP_BYTES: usize = 64 * 1024 * 1024;
+
+/// How many transfers to keep. More than one so a drop can still find its bytes if
+/// another drag started meanwhile, but small enough to bound memory.
+const MAX_ENTRIES: usize = 4;
+
+/// The page-transfer buffer. Registered as Tauri managed state in `lib.rs`.
+#[derive(Default)]
+pub struct PdfClipboard {
+    inner: Mutex<PdfClipState>,
+}
+
+#[derive(Default)]
+struct PdfClipState {
+    next_token: u64,
+    entries: VecDeque<(String, Vec<u8>)>,
+}
+
+impl PdfClipboard {
+    fn set(&self, bytes: Vec<u8>) -> Result<String, String> {
+        if bytes.is_empty() {
+            return Err("no pages to transfer".to_string());
+        }
+        if bytes.len() > MAX_CLIP_BYTES {
+            return Err(format!(
+                "those pages are too large to transfer ({} MiB; the limit is {} MiB)",
+                bytes.len() / (1024 * 1024),
+                MAX_CLIP_BYTES / (1024 * 1024)
+            ));
+        }
+        let mut st = self.inner.lock().map_err(|_| "clipboard poisoned")?;
+        st.next_token += 1;
+        let token = format!("clip{}", st.next_token);
+        st.entries.push_back((token.clone(), bytes));
+        while st.entries.len() > MAX_ENTRIES {
+            st.entries.pop_front();
+        }
+        Ok(token)
+    }
+
+    fn get(&self, token: &str) -> Result<Vec<u8>, String> {
+        let st = self.inner.lock().map_err(|_| "clipboard poisoned")?;
+        st.entries
+            .iter()
+            .find(|(t, _)| t == token)
+            .map(|(_, b)| b.clone())
+            .ok_or_else(|| "those pages are no longer available".to_string())
+    }
+}
+
+/// Park a one-off PDF (the dragged/copied pages) and return the token naming it.
+#[tauri::command]
+pub fn pdf_clip_set(
+    clipboard: tauri::State<'_, PdfClipboard>,
+    bytes: Vec<u8>,
+) -> Result<String, String> {
+    clipboard.set(bytes)
+}
+
+/// Fetch a parked PDF by token. The entry is left in place, so the same transfer can
+/// be dropped or pasted more than once (a copy is not consumed by its first use).
+#[tauri::command]
+pub fn pdf_clip_get(
+    clipboard: tauri::State<'_, PdfClipboard>,
+    token: String,
+) -> Result<Vec<u8>, String> {
+    clipboard.get(&token)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trips_bytes_under_the_token_it_returns() {
+        let cb = PdfClipboard::default();
+        let token = cb.set(vec![1, 2, 3]).unwrap();
+        assert_eq!(cb.get(&token).unwrap(), vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn a_transfer_can_be_fetched_more_than_once() {
+        // A copied page may be pasted repeatedly, so a get must not consume the entry.
+        let cb = PdfClipboard::default();
+        let token = cb.set(vec![7]).unwrap();
+        assert_eq!(cb.get(&token).unwrap(), vec![7]);
+        assert_eq!(cb.get(&token).unwrap(), vec![7]);
+    }
+
+    #[test]
+    fn each_transfer_gets_its_own_token() {
+        let cb = PdfClipboard::default();
+        let a = cb.set(vec![1]).unwrap();
+        let b = cb.set(vec![2]).unwrap();
+        assert_ne!(a, b);
+        assert_eq!(cb.get(&a).unwrap(), vec![1]);
+        assert_eq!(cb.get(&b).unwrap(), vec![2]);
+    }
+
+    #[test]
+    fn an_unknown_token_errors_rather_than_returning_nothing() {
+        let cb = PdfClipboard::default();
+        assert!(cb.get("clip404").is_err());
+    }
+
+    #[test]
+    fn old_transfers_are_evicted_so_memory_stays_bounded() {
+        let cb = PdfClipboard::default();
+        let first = cb.set(vec![0]).unwrap();
+        for i in 1..=MAX_ENTRIES {
+            cb.set(vec![i as u8]).unwrap();
+        }
+        // The oldest has been pushed out; the most recent are still there.
+        assert!(cb.get(&first).is_err());
+    }
+
+    #[test]
+    fn rejects_an_empty_transfer() {
+        assert!(PdfClipboard::default().set(vec![]).is_err());
+    }
+
+    #[test]
+    fn rejects_a_transfer_over_the_size_ceiling() {
+        let cb = PdfClipboard::default();
+        let err = cb.set(vec![0u8; MAX_CLIP_BYTES + 1]).unwrap_err();
+        assert!(err.contains("too large"), "unexpected error: {err}");
+    }
+}
diff --git a/src-tauri/src/commands/power.rs b/src-tauri/src/commands/power.rs
new file mode 100644
index 0000000..626093b
--- /dev/null
+++ b/src-tauri/src/commands/power.rs
@@ -0,0 +1,83 @@
+//! AC-vs-battery power state for Energy Saver mode.
+//!
+//! A single read-only command backing the frontend `stores/power.ts` poller.
+//! The classification is pulled out into a pure [`classify`] so it can be
+//! unit-tested without a real `Manager` (which needs OS battery devices). We
+//! follow the `commands::monitor` shape: a `supported` flag lets the frontend
+//! degrade gracefully — when detection fails we report `supported: false` and
+//! `on_battery: false` (fail open to AC) so a machine where the query breaks is
+//! never left feeling sluggish.
+
+use starship_battery::State;
+
+#[derive(serde::Serialize)]
+pub struct PowerState {
+    /// True only when every present battery is discharging (i.e. unplugged).
+    pub on_battery: bool,
+    /// False when the battery manager could not be queried at all.
+    pub supported: bool,
+}
+
+/// Decide whether we are running on battery from the states of all present
+/// batteries. Pure so it can be tested without OS battery devices.
+///
+/// - No batteries (a desktop) → `false` (treated as AC).
+/// - Any battery charging or full → `false` (a charger is attached).
+/// - Otherwise (all discharging/empty/unknown) → `true`.
+fn classify(states: &[State]) -> bool {
+    if states.is_empty() {
+        return false;
+    }
+    !states
+        .iter()
+        .any(|s| matches!(s, State::Charging | State::Full))
+}
+
+/// Read the states of every present battery, or `None` if the manager or its
+/// enumeration fails. Split from the command so the command stays trivial.
+fn read_states() -> Option<Vec<State>> {
+    let manager = starship_battery::Manager::new().ok()?;
+    let batteries = manager.batteries().ok()?;
+    // A single battery that fails to read shouldn't sink the whole query; skip it.
+    Some(batteries.flatten().map(|b| b.state()).collect())
+}
+
+#[tauri::command]
+pub async fn get_power_state() -> PowerState {
+    match read_states() {
+        Some(states) => PowerState {
+            on_battery: classify(&states),
+            supported: true,
+        },
+        None => PowerState {
+            on_battery: false,
+            supported: false,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn no_batteries_is_ac() {
+        assert!(!classify(&[]));
+    }
+
+    #[test]
+    fn any_charging_is_ac() {
+        assert!(!classify(&[State::Discharging, State::Charging]));
+    }
+
+    #[test]
+    fn full_is_ac() {
+        assert!(!classify(&[State::Full]));
+    }
+
+    #[test]
+    fn all_discharging_is_on_battery() {
+        assert!(classify(&[State::Discharging]));
+        assert!(classify(&[State::Discharging, State::Discharging]));
+    }
+}
diff --git a/src-tauri/src/commands/presenter.rs b/src-tauri/src/commands/presenter.rs
new file mode 100644
index 0000000..39c6f70
--- /dev/null
+++ b/src-tauri/src/commands/presenter.rs
@@ -0,0 +1,268 @@
+//! The deck presenter's **audience window** (TODO M#90, `docs/deck_presenter_plan.md`).
+//!
+//! A talk wants two surfaces: the slide the room sees, and the notes/timer the
+//! speaker sees. The second one is an OS window rendering the same React bundle
+//! under `?present=<label>`, which the frontend drives entirely over Tauri events
+//! (`src/lib/viewers/deck/present.ts`) — this module only opens it, puts it on
+//! the right monitor, and closes it.
+//!
+//! Deliberately NOT a detached subwindow (#42): a popout is a tab group with a
+//! layout, a seed protocol, dock-back, parking and persistence. None of that
+//! applies here — an audience window has no tabs, must survive nothing, and above
+//! all must **not be parked**: `project_runtime::switch` hides a project-owned
+//! window when its project goes inactive, which mid-talk would blank the
+//! projector. So it is registered nowhere and owned only by the presenter that
+//! opened it.
+
+use tauri::{
+    AppHandle, Manager, PhysicalPosition, PhysicalSize, WebviewUrl, WebviewWindowBuilder,
+};
+
+/// A monitor's placement, in physical desktop px — the shape both the real
+/// `tauri::Monitor` and the unit tests reduce to.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct MonitorRect {
+    pub x: i32,
+    pub y: i32,
+    pub w: u32,
+    pub h: u32,
+}
+
+/// Whether `label` is one this command may open.
+///
+/// The label comes from the frontend and becomes both a window label and a URL
+/// query value, so it is validated rather than trusted. The `present-` prefix is
+/// also what `capabilities/default.json` grants window permissions by, so a
+/// label outside this shape would open a window that cannot call anything.
+pub fn valid_presenter_label(label: &str) -> bool {
+    label.len() <= 64
+        && label.starts_with("present-")
+        && label.len() > "present-".len()
+        && label
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
+}
+
+/// The query the audience renderer reads.
+pub fn presenter_query(label: &str) -> String {
+    format!("index.html?present={label}")
+}
+
+/// Which monitor the audience window should take over, if any.
+///
+/// The whole point of the feature is "audience there, notes here", so a single
+/// monitor yields `None` — the window then opens ordinary and windowed, which the
+/// speaker can drag wherever they like. With two or more, take the first monitor
+/// that is not the one the main window is on. `main` unknown falls back to the
+/// *second* monitor rather than the first: the first is nearly always the
+/// built-in panel the presenter is sitting at.
+pub fn choose_audience_monitor(
+    monitors: &[MonitorRect],
+    main: Option<MonitorRect>,
+) -> Option<MonitorRect> {
+    if monitors.len() < 2 {
+        return None;
+    }
+    match main {
+        Some(m) => monitors
+            .iter()
+            .find(|c| (c.x, c.y) != (m.x, m.y))
+            .copied()
+            .or_else(|| monitors.get(1).copied()),
+        None => monitors.get(1).copied(),
+    }
+}
+
+/// Open (or focus) the audience window for a deck.
+///
+/// MUST be `async`, for the same reason `detach_subwindow` is: a synchronous
+/// Tauri command runs on the main thread, and `WebviewWindowBuilder::build()` on
+/// Windows blocks on the main-thread event loop pumping WebView2's controller
+/// callback — which the in-flight sync command is itself blocking (wry#583 /
+/// tauri#4121), surfacing as a blank window that never renders.
+#[tauri::command]
+pub async fn open_presenter_window(app: AppHandle, label: String) -> Result<String, String> {
+    if !valid_presenter_label(&label) {
+        return Err("invalid presenter window label".into());
+    }
+
+    // Idempotent: presenting the same deck twice re-uses (and re-focuses) the
+    // window already on the projector rather than stacking a second one on it.
+    if let Some(win) = app.get_webview_window(&label) {
+        let _ = win.set_focus();
+        return Ok(label);
+    }
+
+    let target = audience_monitor(&app);
+
+    let mut builder = WebviewWindowBuilder::new(
+        &app,
+        &label,
+        WebviewUrl::App(presenter_query(&label).into()),
+    )
+    .title("Eldrun — Presentation")
+    // Decorated on purpose, unlike a popout: with one monitor this window is
+    // dragged to a projector by hand, and a borderless window is awkward to move
+    // and impossible to close if the renderer never seeds.
+    .decorations(true);
+    // LOGICAL default size only; any monitor geometry below is PHYSICAL and is
+    // applied through the physical setters after the build.
+    builder = builder.inner_size(960.0, 600.0);
+    #[cfg(target_os = "windows")]
+    {
+        // Same first-paint story as the detached window: a fresh WebView2 surface
+        // shows blank white until it is shown/focused, so build hidden and reveal
+        // it in the deferred kick below.
+        builder = builder.visible(false);
+    }
+
+    let win = builder
+        .build()
+        .map_err(|e| format!("build presenter window: {e}"))?;
+
+    // Physical setters, never the builder's logical ones: a monitor's origin/size
+    // are PHYSICAL px, and feeding those to a logical setter multiplies them by
+    // the display scale — the bug that put a detached window off-screen on every
+    // scaled display (#42).
+    if let Some(m) = target {
+        let _ = win.set_position(PhysicalPosition::new(m.x, m.y));
+        let _ = win.set_size(PhysicalSize::new(m.w, m.h));
+        // Fullscreen AFTER placing it, so the WM makes *that* monitor fullscreen
+        // and not the one the window was born on.
+        let _ = win.set_fullscreen(true);
+    }
+
+    // Force the first paint, deferred so the webview has mounted. Same two
+    // platform quirks the detached path documents: WebKitGTK presents an
+    // unpainted BLACK GL surface until a genuine OS-level resize, WebView2 a
+    // blank WHITE one until it is shown/focused.
+    let nudge_app = app.clone();
+    let nudge_label = label.clone();
+    std::thread::spawn(move || {
+        let kick = |app: AppHandle, label: String, reveal: bool| {
+            let app_main = app.clone();
+            let _ = app.run_on_main_thread(move || {
+                if let Some(w) = app_main.get_webview_window(&label) {
+                    #[cfg(target_os = "windows")]
+                    if reveal {
+                        let _ = w.show();
+                        let _ = w.set_focus();
+                    }
+                    // A fullscreen window must not be resized — that would drop it
+                    // out of fullscreen. Showing/focusing is enough there, and on
+                    // Linux the fullscreen transition is itself the resize that
+                    // paints the surface.
+                    if let Ok(false) = w.is_fullscreen() {
+                        if let Ok(sz) = w.inner_size() {
+                            let delta: i32 = if reveal { 1 } else { -1 };
+                            let next = (sz.width as i32 + delta).max(1) as u32;
+                            let _ = w.set_size(PhysicalSize::new(next, sz.height));
+                        }
+                    }
+                }
+            });
+        };
+        std::thread::sleep(std::time::Duration::from_millis(250));
+        kick(nudge_app.clone(), nudge_label.clone(), true);
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        kick(nudge_app, nudge_label, false);
+    });
+
+    Ok(label)
+}
+
+/// Close the audience window. Idempotent — a window already gone is the state the
+/// caller wanted, so it is not an error (the presenter closes on unmount too,
+/// which races the user closing it from the WM).
+#[tauri::command]
+pub fn close_presenter_window(app: AppHandle, label: String) -> Result<(), String> {
+    if !valid_presenter_label(&label) {
+        return Err("invalid presenter window label".into());
+    }
+    if let Some(win) = app.get_webview_window(&label) {
+        // `destroy()`, not `close()`: `close()` fires the audience window's
+        // `onCloseRequested`, which reports back that it went away — a message the
+        // presenter that just asked for this does not need.
+        let _ = win.destroy();
+    }
+    Ok(())
+}
+
+/// Resolve the monitor to hand the audience window, from the live app.
+fn audience_monitor(app: &AppHandle) -> Option<MonitorRect> {
+    let to_rect = |m: &tauri::Monitor| MonitorRect {
+        x: m.position().x,
+        y: m.position().y,
+        w: m.size().width,
+        h: m.size().height,
+    };
+    let monitors: Vec<MonitorRect> = app
+        .available_monitors()
+        .ok()?
+        .iter()
+        .map(to_rect)
+        .collect();
+    let main = app
+        .get_webview_window("main")
+        .and_then(|w| w.current_monitor().ok().flatten())
+        .map(|m| to_rect(&m));
+    choose_audience_monitor(&monitors, main)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn rect(x: i32, y: i32) -> MonitorRect {
+        MonitorRect { x, y, w: 1920, h: 1080 }
+    }
+
+    #[test]
+    fn labels_are_validated() {
+        assert!(valid_presenter_label("present-1a2b3c"));
+        assert!(valid_presenter_label("present-A_b-9"));
+        // Not a presenter window at all.
+        assert!(!valid_presenter_label("main"));
+        assert!(!valid_presenter_label("detached-p-g1"));
+        // The prefix alone is not a label.
+        assert!(!valid_presenter_label("present-"));
+        // Path/query injection into the window URL.
+        assert!(!valid_presenter_label("present-../../etc"));
+        assert!(!valid_presenter_label("present-x?y=1"));
+        assert!(!valid_presenter_label(&format!("present-{}", "x".repeat(80))));
+    }
+
+    #[test]
+    fn query_carries_the_label() {
+        assert_eq!(presenter_query("present-zz"), "index.html?present=present-zz");
+    }
+
+    #[test]
+    fn one_monitor_means_no_takeover() {
+        assert_eq!(choose_audience_monitor(&[rect(0, 0)], Some(rect(0, 0))), None);
+        assert_eq!(choose_audience_monitor(&[], None), None);
+    }
+
+    #[test]
+    fn picks_the_monitor_the_main_window_is_not_on() {
+        let ms = [rect(0, 0), rect(1920, 0)];
+        assert_eq!(choose_audience_monitor(&ms, Some(rect(0, 0))), Some(rect(1920, 0)));
+        assert_eq!(choose_audience_monitor(&ms, Some(rect(1920, 0))), Some(rect(0, 0)));
+    }
+
+    #[test]
+    fn unknown_main_monitor_falls_back_to_the_second() {
+        // Not the first: that is nearly always the built-in panel the speaker is
+        // sitting at, i.e. the one surface the audience must NOT get.
+        let ms = [rect(0, 0), rect(1920, 0), rect(3840, 0)];
+        assert_eq!(choose_audience_monitor(&ms, None), Some(rect(1920, 0)));
+    }
+
+    #[test]
+    fn main_on_an_unknown_monitor_still_yields_one() {
+        // The main window reported a monitor that is not in the list (a hot-plug
+        // between the two reads). Any second screen beats refusing to open.
+        let ms = [rect(0, 0), rect(1920, 0)];
+        assert_eq!(choose_audience_monitor(&ms, Some(rect(-1080, 0))), Some(rect(0, 0)));
+    }
+}
diff --git a/src-tauri/src/commands/projects.rs b/src-tauri/src/commands/projects.rs
index cb29542..0a839bc 100644
--- a/src-tauri/src/commands/projects.rs
+++ b/src-tauri/src/commands/projects.rs
@@ -1,17 +1,94 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::process::Command;
 
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
+use tauri::State;
+
 use crate::paths;
-use crate::schema::project::{Project, RemoteSpec};
+use crate::schema::project::{ComputeHost, OpenVpnSpec, Project, RemoteSpec, SandboxSpec};
 use crate::schema::projects::{ProjectEntry, ProjectsList};
-use crate::services::ssh_mount;
+use crate::services::remote_sync::SyncManifestState;
 use crate::storage;
 
+/// Local per-project state directory for a **remote** project:
+/// `<state_dir>/remote-projects/<id>`. Mount-free remote projects keep their
+/// `project.json` (tabs/time/etc.) here — a real local dir, unlike the old sshfs
+/// mountpoint — while the project's tree lives on the host and is reached over
+/// SFTP/SSH. This path becomes the project's `directory` (a stable local key the
+/// fs/git/terminal commands resolve to a `RemoteTarget`).
+fn remote_project_state_dir(id: &str) -> std::path::PathBuf {
+    storage::state_dir().join("remote-projects").join(id)
+}
+
+/// Drop the per-project state that is bound to **one specific host**: the byte-sync
+/// manifest (`sync.json`) and the lockstep state (`git_peer.json`). Both are meaningless
+/// — worse, actively wrong — once a project is pointed at a *different* host, or at none.
+///
+/// The manifest is the dangerous one, and it is why detach→re-extend needs this at all.
+/// Its entries carry `last_pull_ts`/`last_push_ts`, so against a fresh, empty host
+/// `push_decision` sees `ever_synced = true` plus a missing file and returns `Stale` — it
+/// **refuses to push**. Meanwhile `divergence` maps the failed host stat to "couldn't
+/// check → don't flag", so the file tree paints the very same file **green**. Net: a
+/// re-extended project whose auto-synced data silently never crosses, reported as fully
+/// in sync. The classic false green.
+///
+/// The state dir is keyed by project **id**, which a detach preserves — so a re-extend
+/// lands back on the same directory and inherits whatever the detach left behind.
+/// `remove_dir` (as detach used to call) only removes an *empty* dir, and this one never
+/// is, so every one of these files survived.
+///
+/// Evicting the in-memory cache is not optional: `ensure_loaded` is `or_insert_with`, so
+/// a manifest already loaded this session is never re-read from disk — deleting the file
+/// alone would just get the stale copy re-saved on the next pass.
+///
+/// `local_loss.json` deliberately **survives**: it records what was destroyed in the
+/// *local mirror*, the user may not have acknowledged it yet, and it is a fact about this
+/// machine rather than about any host.
+async fn clear_host_bound_state(project_id: &str, manifest: &SyncManifestState) {
+    let _ = fs::remove_file(crate::services::remote_sync::manifest_path(project_id));
+    let _ = fs::remove_file(crate::services::git_peer::state_path(project_id));
+    manifest.lock().await.remove(project_id);
+}
+
+/// Compute a `<name>` leaf under `parent` for a remote (SSH) project's local
+/// mirror. `sanitize_name` keeps the folder readable; the `id` disambiguates a
+/// name-based path already taken by another remote project, so two hosts' `~/work`
+/// never collide on the same local mirror. Shared by the default location and the
+/// user-chosen `mirror_parent`.
+fn remote_mirror_in(parent: &Path, name: &str, id: &str) -> PathBuf {
+    let safe = sanitize_name(name);
+    let leaf = if safe.is_empty() { id.to_string() } else { safe };
+    let candidate = parent.join(&leaf);
+    if candidate.exists() {
+        parent.join(format!("{leaf}-{}", &id[..id.len().min(8)]))
+    } else {
+        candidate
+    }
+}
+
+/// The default local mirror location for a new remote (SSH) project: a readable
+/// `<name>` subfolder of the top-level `eldrun/projects-ssh/` root (rather than a
+/// hidden state dir or the managed-local `projects/` tree).
+fn default_remote_mirror(name: &str, id: &str) -> PathBuf {
+    remote_mirror_in(&paths::projects_ssh_root(), name, id)
+}
+
+/// Resolve a remote project's local mirror path: under the user-chosen
+/// `mirror_parent` (the dialog's "Local location") when provided and non-empty,
+/// otherwise the default `projects-ssh` root. Returns the full `<parent>/<name>`
+/// path as a string, ready to store in `project.json`/`projects.json`.
+fn resolve_remote_mirror(mirror_parent: Option<&str>, name: &str, id: &str) -> String {
+    match mirror_parent.map(str::trim).filter(|p| !p.is_empty()) {
+        Some(parent) => remote_mirror_in(Path::new(parent), name, id),
+        None => default_remote_mirror(name, id),
+    }
+    .to_string_lossy()
+    .to_string()
+}
+
 // ── Project list ──────────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -21,20 +98,59 @@ pub fn get_projects() -> Result<ProjectsList, String> {
         return Ok(vec![]);
     }
     let mut list: ProjectsList = storage::read_json(&path).map_err(|e| e.to_string())?;
-    // Migrate legacy git_type values (private/public) to the local/remote model
-    // in-memory so the frontend always sees canonical values. Persisted on the
-    // next natural save (no surprise write from a read command).
+    // Bring legacy entries up to the current shape in-memory so the frontend and
+    // every command see canonical, fully-populated entries regardless of which
+    // Eldrun version first wrote them. Persisted on the next natural save (no
+    // surprise write from a read command).
     for entry in list.iter_mut() {
-        if let Some(Value::String(gt)) = entry.extra.get("git_type") {
-            let norm = normalize_git_type(gt);
-            if &norm != gt {
-                entry
-                    .extra
-                    .insert("git_type".to_string(), Value::String(norm));
+        normalize_entry(entry);
+    }
+    Ok(list)
+}
+
+/// Bring one `projects.json` entry up to the current on-disk shape, in place.
+///
+/// Old Eldrun versions (pre-Group-D) wrote entries that omit fields the current
+/// code and pill/hover UI expect. This backfills those from information the
+/// entry already carries, so a legacy project (e.g. the self-hosting
+/// ProjectEldrun entry, which predates persisted `directory`) becomes
+/// indistinguishable from a freshly-created one. Purely additive/canonicalizing:
+/// it never overwrites a value the entry already sets.
+///
+/// - `directory`: derived from `local_file`'s parent (always `<dir>/project.json`)
+///   when absent. Load-bearing — provider sniffing, archive, and remoteness
+///   checks all key off it.
+/// - `git_type`: legacy `private`/`public` mapped to the `remote-*` model.
+///
+/// Returns `true` when it actually changed something — i.e. the entry was
+/// legacy. Startup uses that as the trigger to also refresh the project's
+/// on-disk scaffold (see `migrate_legacy_projects`).
+pub(crate) fn normalize_entry(entry: &mut ProjectEntry) -> bool {
+    let mut changed = false;
+    // Backfill a missing working directory from `local_file`'s parent.
+    let has_dir = matches!(entry.extra.get("directory"), Some(Value::String(d)) if !d.is_empty());
+    if !has_dir {
+        if let Some(parent) = std::path::Path::new(&entry.local_file).parent() {
+            if !parent.as_os_str().is_empty() {
+                entry.extra.insert(
+                    "directory".to_string(),
+                    Value::String(parent.to_string_lossy().into_owned()),
+                );
+                changed = true;
             }
         }
     }
-    Ok(list)
+    // Canonicalize a legacy git_type value (private/public → remote-*).
+    if let Some(Value::String(gt)) = entry.extra.get("git_type") {
+        let norm = normalize_git_type(gt);
+        if &norm != gt {
+            entry
+                .extra
+                .insert("git_type".to_string(), Value::String(norm));
+            changed = true;
+        }
+    }
+    changed
 }
 
 /// Normalize a `git_type` value to the local/remote model used since Group D.
@@ -45,6 +161,7 @@ pub(crate) fn normalize_git_type(value: &str) -> String {
         "private" => "remote-private",
         "public" => "remote-public",
         "local" => "local",
+        "none" => "none",
         "remote-private" => "remote-private",
         "remote-public" => "remote-public",
         _ => "local",
@@ -58,6 +175,431 @@ pub fn save_projects(projects: ProjectsList) -> Result<(), String> {
     storage::write_json(&path, &projects).map_err(|e| e.to_string())
 }
 
+// ── Archive (delete → restorable holding area) ─────────────────────────────
+//
+// Deleting a project moves its LOCAL folders into `~/eldrun/archive/<id>/` and
+// drops it from `projects.json`. A remote project's tree on its host is never
+// touched — only its local state dir + mirror move. The archive is only cleared
+// manually from Settings; restore moves the folders back and re-registers the
+// project as `inactive`.
+
+/// Restore manifest written into `archive/<id>/entry.json`. Holds the full
+/// original `projects.json` entry (the source of truth for restore) plus the
+/// archive stamp and a remote flag.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct ArchiveManifest {
+    entry: ProjectEntry,
+    archived_at: String,
+    remote: bool,
+}
+
+/// A summary row for the Settings "Archived projects" list.
+#[derive(Debug, Clone, Serialize)]
+pub struct ArchivedProject {
+    pub id: String,
+    pub name: String,
+    pub archived_at: String,
+    pub remote: bool,
+}
+
+/// Reject ids that could escape the archive root (path traversal). Project ids
+/// are UUIDs in practice, so anything with a separator or `..` is invalid.
+fn validate_project_id(id: &str) -> Result<(), String> {
+    if id.is_empty() || id.contains('/') || id.contains('\\') || id.contains("..") {
+        return Err(format!("invalid project id '{id}'"));
+    }
+    Ok(())
+}
+
+fn entry_directory(entry: &ProjectEntry) -> Option<String> {
+    entry
+        .extra
+        .get("directory")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+}
+
+fn entry_mirror(entry: &ProjectEntry) -> Option<String> {
+    entry
+        .extra
+        .get("mirror")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+}
+
+fn entry_is_remote(entry: &ProjectEntry) -> bool {
+    entry
+        .extra
+        .get("remote")
+        .map(|v| !v.is_null())
+        .unwrap_or(false)
+}
+
+/// Move a directory tree from `src` to `dst`, creating `dst`'s parent. Tries a
+/// fast `rename` first and falls back to recursive copy + remove when that fails
+/// (e.g. a cross-filesystem move). No-op when `src` does not exist.
+fn move_tree(src: &Path, dst: &Path) -> Result<(), String> {
+    if !src.exists() {
+        return Ok(());
+    }
+    if let Some(parent) = dst.parent() {
+        fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+    if fs::rename(src, dst).is_ok() {
+        return Ok(());
+    }
+    copy_tree(src, dst).map_err(|e| e.to_string())?;
+    fs::remove_dir_all(src).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+fn copy_tree(src: &Path, dst: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(dst)?;
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let from = entry.path();
+        let to = dst.join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_tree(&from, &to)?;
+        } else {
+            fs::copy(&from, &to)?;
+        }
+    }
+    Ok(())
+}
+
+/// The original path if free, else a collision-safe sibling, so restoring never
+/// clobbers a folder re-created since the project was archived.
+fn free_target(orig: &Path) -> PathBuf {
+    if !orig.exists() {
+        return orig.to_path_buf();
+    }
+    let parent = orig.parent().unwrap_or_else(|| Path::new("."));
+    let stem = orig.file_name().and_then(|n| n.to_str()).unwrap_or("restored");
+    for n in 1..1000 {
+        let cand = parent.join(format!("{stem}-restored-{n}"));
+        if !cand.exists() {
+            return cand;
+        }
+    }
+    parent.join(format!("{stem}-restored"))
+}
+
+/// Purge a project's time-tracking history: drop it from every day bucket of the
+/// rolling summary and filter it out of the legacy append-only log if present.
+/// Called only on PERMANENT deletion (archiving keeps the history).
+fn purge_project_time(project_id: &str) {
+    use crate::schema::time_log;
+    let mut summary = time_log::load_summary_migrating();
+    let mut changed = false;
+    for by_project in summary.days.values_mut() {
+        if by_project.remove(project_id).is_some() {
+            changed = true;
+        }
+    }
+    if changed {
+        let _ = time_log::save_summary(&summary);
+    }
+    let legacy = storage::state_dir().join(time_log::LEGACY_LOG_FILE);
+    if legacy.exists() {
+        if let Ok(entries) = storage::read_json::<time_log::TimeLog>(&legacy) {
+            let kept: time_log::TimeLog = entries
+                .into_iter()
+                .filter(|e| e.project_id != project_id)
+                .collect();
+            let _ = storage::write_json(&legacy, &kept);
+        }
+    }
+}
+
+/// Move a project into the archive and drop it from `projects.json`. `archived_at`
+/// is a caller-supplied ISO timestamp (the frontend stamps it). The remote host
+/// tree is never touched — only local folders move.
+#[tauri::command]
+pub fn archive_project(project_id: String, archived_at: String) -> Result<(), String> {
+    validate_project_id(&project_id)?;
+
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let idx = list
+        .iter()
+        .position(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    let entry = list[idx].clone();
+    let remote = entry_is_remote(&entry);
+
+    let dest = paths::archive_root().join(&project_id);
+    if dest.exists() {
+        return Err(format!(
+            "an archived project with id '{project_id}' already exists"
+        ));
+    }
+    fs::create_dir_all(&dest).map_err(|e| e.to_string())?;
+
+    // Move the LOCAL folders. Remote host tree is intentionally left in place.
+    if remote {
+        move_tree(&remote_project_state_dir(&project_id), &dest.join("state"))?;
+        if let Some(mirror) = entry_mirror(&entry) {
+            move_tree(Path::new(&mirror), &dest.join("mirror"))?;
+        }
+    } else if let Some(dir) = entry_directory(&entry) {
+        move_tree(Path::new(&dir), &dest.join("dir"))?;
+    }
+
+    let manifest = ArchiveManifest {
+        entry,
+        archived_at,
+        remote,
+    };
+    storage::write_json(&dest.join("entry.json"), &manifest).map_err(|e| e.to_string())?;
+
+    list.remove(idx);
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+/// List archived projects (newest first) for the Settings panel.
+#[tauri::command]
+pub fn list_archived_projects() -> Result<Vec<ArchivedProject>, String> {
+    let root = paths::archive_root();
+    if !root.exists() {
+        return Ok(vec![]);
+    }
+    let mut out = Vec::new();
+    for entry in fs::read_dir(&root).map_err(|e| e.to_string())? {
+        let entry = entry.map_err(|e| e.to_string())?;
+        if !entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
+            continue;
+        }
+        if let Ok(m) = storage::read_json::<ArchiveManifest>(&entry.path().join("entry.json")) {
+            out.push(ArchivedProject {
+                id: m.entry.id.clone(),
+                name: m.entry.name.clone(),
+                archived_at: m.archived_at,
+                remote: m.remote,
+            });
+        }
+    }
+    // Newest first; the stamp is an ISO string so a lexical sort is chronological.
+    out.sort_by(|a, b| b.archived_at.cmp(&a.archived_at));
+    Ok(out)
+}
+
+/// Restore an archived project: move its folders back (collision-safe) and
+/// re-register it in `projects.json` as `inactive`. Returns the restored entry.
+#[tauri::command]
+pub fn restore_archived_project(project_id: String) -> Result<ProjectEntry, String> {
+    validate_project_id(&project_id)?;
+
+    let dest = paths::archive_root().join(&project_id);
+    let manifest: ArchiveManifest =
+        storage::read_json(&dest.join("entry.json")).map_err(|e| e.to_string())?;
+    let mut entry = manifest.entry;
+
+    if manifest.remote {
+        // The state dir is keyed by id and was moved out on archive, so its
+        // original path is free again.
+        let state_dst = remote_project_state_dir(&project_id);
+        move_tree(&dest.join("state"), &state_dst)?;
+        entry.local_file = state_dst
+            .join("project.json")
+            .to_string_lossy()
+            .to_string();
+        entry.extra.insert(
+            "directory".to_string(),
+            Value::String(state_dst.to_string_lossy().to_string()),
+        );
+        let mirror_src = dest.join("mirror");
+        if mirror_src.exists() {
+            if let Some(orig) = entry_mirror(&entry) {
+                let target = free_target(Path::new(&orig));
+                move_tree(&mirror_src, &target)?;
+                entry.extra.insert(
+                    "mirror".to_string(),
+                    Value::String(target.to_string_lossy().to_string()),
+                );
+            }
+        }
+    } else if let Some(dir) = entry_directory(&entry) {
+        let target = free_target(Path::new(&dir));
+        move_tree(&dest.join("dir"), &target)?;
+        entry.extra.insert(
+            "directory".to_string(),
+            Value::String(target.to_string_lossy().to_string()),
+        );
+        entry.local_file = target.join("project.json").to_string_lossy().to_string();
+    }
+
+    entry.status = "inactive".to_string();
+
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+    entry.position = next_position(&list);
+    list.retain(|p| p.id != entry.id); // guard against a stale duplicate
+    list.push(entry.clone());
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    fs::remove_dir_all(&dest).map_err(|e| e.to_string())?;
+    Ok(entry)
+}
+
+/// One local branch of an archived mirror carrying commits the host baseline
+/// does not contain.
+#[derive(Debug, Clone, Serialize)]
+pub struct UnsyncedBranch {
+    pub name: String,
+    pub count: usize,
+}
+
+/// Whether permanently deleting an archived remote project's mirror would discard
+/// local-only history. Computed purely from the archived files — no host contact,
+/// so it works while the host is offline.
+#[derive(Debug, Clone, Serialize)]
+pub struct UnsyncedReport {
+    /// Total commits reachable from the mirror's local branches but not from the
+    /// host baseline (last-synced tips). 0 means nothing would be lost.
+    pub total: usize,
+    /// Per-branch breakdown (only branches with a non-zero count).
+    pub branches: Vec<UnsyncedBranch>,
+    /// True when a host baseline existed to compare against (a recorded
+    /// `remote_head` or any `refs/eldrun/{incoming,backup}` ref). When false the
+    /// count is every local commit and should be framed as "could not verify".
+    pub verified: bool,
+}
+
+/// Run `git <args>` in `dir`, returning trimmed stdout (empty string on failure).
+fn git_in(dir: &Path, args: &[&str]) -> String {
+    crate::paths::command_no_window("git")
+        .args(args)
+        .current_dir(dir)
+        .output()
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .unwrap_or_default()
+}
+
+/// Inspect an archived remote project's mirror for commits that were never synced
+/// to its host, so the UI can warn before an irreversible permanent delete.
+/// Non-remote projects (and those without a mirror repo) report nothing to lose.
+#[tauri::command]
+pub fn archived_mirror_unsynced(project_id: String) -> Result<UnsyncedReport, String> {
+    validate_project_id(&project_id)?;
+    let none = UnsyncedReport {
+        total: 0,
+        branches: vec![],
+        verified: true,
+    };
+
+    let dest = paths::archive_root().join(&project_id);
+    let manifest: ArchiveManifest = match storage::read_json(&dest.join("entry.json")) {
+        Ok(m) => m,
+        Err(_) => return Ok(none),
+    };
+    // Only remote projects keep a paired mirror; local projects hold no host-only
+    // relationship, so there is nothing that "wasn't synced".
+    if !manifest.remote {
+        return Ok(none);
+    }
+    let mirror = dest.join("mirror");
+    if !mirror.join(".git").exists() {
+        return Ok(none);
+    }
+
+    // Build the host baseline: refs whose history we know reached (or came from)
+    // the host. `refs/eldrun/incoming/*` are the host's tips at the last fetch,
+    // `refs/eldrun/backup/*` are safety snapshots, and the recorded `remote_head`
+    // is the last-observed host HEAD.
+    let mut negatives: Vec<String> = vec![
+        "--glob=refs/eldrun/incoming".to_string(),
+        "--glob=refs/eldrun/backup".to_string(),
+    ];
+    let mut have_baseline = !git_in(
+        &mirror,
+        &["for-each-ref", "refs/eldrun/incoming", "refs/eldrun/backup"],
+    )
+    .is_empty();
+    if let Ok(state) = storage::read_json::<crate::services::git_peer::GitPeerState>(
+        &dest.join("state").join("git_peer.json"),
+    ) {
+        if let Some(sha) = remote_head_sha(&state) {
+            // Only include a sha the mirror actually has, else rev-list errors out.
+            if !git_in(&mirror, &["rev-parse", "--verify", "--quiet", &format!("{sha}^{{commit}}")])
+                .is_empty()
+            {
+                negatives.push(sha);
+                have_baseline = true;
+            }
+        }
+    }
+
+    // Per-branch: commits on this branch not reachable from the baseline.
+    let mut branches = Vec::new();
+    let mut total = 0usize;
+    let heads = git_in(
+        &mirror,
+        &["for-each-ref", "--format=%(refname:short)", "refs/heads"],
+    );
+    for branch in heads.lines().map(str::trim).filter(|b| !b.is_empty()) {
+        let mut args: Vec<&str> = vec!["rev-list", "--count", branch, "--not"];
+        let neg_refs: Vec<&str> = negatives.iter().map(String::as_str).collect();
+        args.extend_from_slice(&neg_refs);
+        let count: usize = git_in(&mirror, &args).parse().unwrap_or(0);
+        if count > 0 {
+            total += count;
+            branches.push(UnsyncedBranch {
+                name: branch.to_string(),
+                count,
+            });
+        }
+    }
+
+    Ok(UnsyncedReport {
+        total,
+        branches,
+        verified: have_baseline,
+    })
+}
+
+/// The sha of a persisted `remote_head`, if it names a concrete commit.
+fn remote_head_sha(state: &crate::services::git_peer::GitPeerState) -> Option<String> {
+    use crate::services::git_peer::HeadRef;
+    match state.remote_head.as_ref()? {
+        HeadRef::Branch { sha, .. } | HeadRef::Detached { sha } => Some(sha.clone()),
+        HeadRef::Unborn => None,
+    }
+}
+
+/// Permanently delete an archived project: remove its archive folder and purge
+/// its time-tracking history. Irreversible.
+#[tauri::command]
+pub fn delete_archived_project(project_id: String) -> Result<(), String> {
+    validate_project_id(&project_id)?;
+    let dest = paths::archive_root().join(&project_id);
+    if dest.exists() {
+        fs::remove_dir_all(&dest).map_err(|e| e.to_string())?;
+    }
+    purge_project_time(&project_id);
+    Ok(())
+}
+
+/// Permanently delete every archived project (Settings "Clear archive").
+#[tauri::command]
+pub fn clear_archive() -> Result<(), String> {
+    for archived in list_archived_projects()? {
+        delete_archived_project(archived.id)?;
+    }
+    Ok(())
+}
+
 /// Update a project's description in both `projects.json` (the pill list) and
 /// the project's own `project.json`, keeping the two in sync. An empty/blank
 /// description clears the field. Returns the cleaned description (or null).
@@ -105,6 +647,757 @@ pub fn set_project_description(
     Ok(cleaned)
 }
 
+/// Rename a project: update its display `name` in both `projects.json` (the
+/// pill list) and the project's own `project.json`, keeping the two in sync.
+/// The on-disk `directory` is left untouched — only the human-facing name
+/// changes. A blank name is rejected. Returns the cleaned (trimmed) name.
+#[tauri::command]
+pub fn set_project_name(project_id: String, name: String) -> Result<String, String> {
+    let cleaned = name.trim().to_string();
+    if cleaned.is_empty() {
+        return Err("project name cannot be empty".to_string());
+    }
+
+    // projects.json — find the entry and update its `name`.
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    entry.name = cleaned.clone();
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    // project.json — keep the per-project file consistent (best effort: a
+    // missing file is not fatal since the list is the source of truth for pills).
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.name = cleaned.clone();
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+
+    Ok(cleaned)
+}
+
+/// Toggle the project container for a project in both `projects.json` (so the
+/// pill list / frontend can flag it without reading project.json) and the
+/// project's own `project.json`. **Spec-preserving**: only `enabled` is
+/// flipped — hand-tuned `image`/`memory`/`network`/… survive a disable/enable
+/// round-trip (the spec stays stored with `enabled:false` rather than being
+/// cleared). On the *first* enable (no prior spec), in-repo container sources
+/// are auto-detected (`Dockerfile`, else a devcontainer `image`). Returns the
+/// resulting spec so the frontend can mirror it verbatim.
+#[tauri::command]
+pub fn set_project_sandbox(project_id: String, enabled: bool) -> Result<SandboxSpec, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+
+    // Existing spec: the projects.json mirror is authoritative; fall back to
+    // project.json for entries predating the mirror.
+    let local_file = entry.local_file.clone();
+    let existing: Option<SandboxSpec> = entry
+        .extra
+        .get("sandbox")
+        .and_then(|v| serde_json::from_value(v.clone()).ok())
+        .or_else(|| {
+            storage::read_json::<Project>(&PathBuf::from(&local_file))
+                .ok()
+                .and_then(|p| p.sandbox)
+        });
+    let first_enable = enabled && existing.is_none();
+    let mut spec = existing.unwrap_or_default();
+    spec.enabled = enabled;
+    if first_enable {
+        // First enable ever: prefer what the repo itself declares as its
+        // container over the built-in default image.
+        if let Some(dir) = entry
+            .extra
+            .get("directory")
+            .and_then(|v| v.as_str())
+            .filter(|s| !s.is_empty())
+        {
+            crate::services::sandbox::detect_spec_sources(Path::new(dir), &mut spec);
+        }
+    }
+
+    write_project_sandbox_spec(&mut list, &list_path, &project_id, &spec)?;
+    Ok(spec)
+}
+
+/// Replace a project's container spec (the knobs dialog's save). `enabled` is
+/// taken from the incoming spec verbatim; blank strings are normalized away so
+/// "cleared field" and "never set" serialize identically. Returns the stored
+/// spec.
+#[tauri::command]
+pub fn set_project_sandbox_spec(
+    project_id: String,
+    mut spec: SandboxSpec,
+) -> Result<SandboxSpec, String> {
+    let clean = |v: &mut Option<String>| {
+        if v.as_deref().map(str::trim).is_none_or(str::is_empty) {
+            *v = None;
+        } else if let Some(s) = v.as_mut() {
+            *s = s.trim().to_string();
+        }
+    };
+    clean(&mut spec.image);
+    clean(&mut spec.dockerfile);
+    clean(&mut spec.memory);
+    clean(&mut spec.cpus);
+    clean(&mut spec.network);
+
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    write_project_sandbox_spec(&mut list, &list_path, &project_id, &spec)?;
+    Ok(spec)
+}
+
+/// Persist a container spec into both stores: the `projects.json` entry's
+/// flattened `sandbox` (the always-local mirror the spawn path reads) and the
+/// project's own `project.json` (best effort — the list is the source of truth).
+fn write_project_sandbox_spec(
+    list: &mut ProjectsList,
+    list_path: &Path,
+    project_id: &str,
+    spec: &SandboxSpec,
+) -> Result<(), String> {
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    let value = serde_json::to_value(spec).map_err(|e| e.to_string())?;
+    entry.extra.insert("sandbox".to_string(), value);
+    let local_file = entry.local_file.clone();
+    storage::write_json(list_path, list).map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.sandbox = Some(spec.clone());
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+/// Toggle-time container preflight: is docker installed, is the daemon up, does
+/// the image exist? For a missing image the report carries the shell command
+/// that provides it, so the frontend can run it in a fresh terminal tab
+/// (one-click, per house convention) instead of telling the user to do it.
+#[tauri::command]
+pub fn sandbox_preflight(project_id: String) -> crate::services::sandbox::PreflightReport {
+    crate::services::sandbox::preflight_report(&project_id)
+}
+
+/// Set (or clear) the OpenVPN client config on a **remote** project's SSH spec,
+/// mirrored into both `projects.json` (the flattened `remote` extra the frontend
+/// reads) and the project's own `project.json`. This exists because a remote
+/// project may be created/extended on a network that needs no VPN (so no config
+/// is stored), then later reconnected from a VPN-gated network — the Connect
+/// dialog attaches the config here so it's remembered for next time.
+///
+/// `config = Some(path)` attaches the tunnel; `None`/blank removes it. `username`
+/// is stored alongside for `auth-user-pass` configs (it is not a secret); blank
+/// clears it. Errors if the project isn't remote. Returns the stored config path
+/// ("" when cleared).
+#[tauri::command]
+pub fn set_project_openvpn(
+    project_id: String,
+    config: Option<String>,
+    username: Option<String>,
+) -> Result<String, String> {
+    let username = username
+        .map(|u| u.trim().to_string())
+        .filter(|u| !u.is_empty());
+    let spec = config
+        .as_deref()
+        .map(str::trim)
+        .filter(|c| !c.is_empty())
+        .map(|c| OpenVpnSpec {
+            config: c.to_string(),
+            username: username.clone(),
+            extra: HashMap::new(),
+        });
+
+    patch_remote_spec(&project_id, |remote| remote.openvpn = spec.clone())?;
+
+    Ok(spec.map(|s| s.config).unwrap_or_default())
+}
+
+/// Apply `patch` to a **remote** project's SSH spec in both places it is stored:
+/// `projects.json` (the flattened `remote` extra, which is the always-local source
+/// of truth `services::remote::remote_target_for` reads) and the project's own
+/// `project.json` (best effort — a remote project's copy may be unreachable).
+/// Errors if the project is unknown or not remote.
+fn patch_remote_spec(project_id: &str, patch: impl Fn(&mut RemoteSpec)) -> Result<(), String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    let remote_val = entry
+        .extra
+        .get_mut("remote")
+        .ok_or_else(|| "project is not remote".to_string())?;
+    let mut remote: RemoteSpec =
+        serde_json::from_value(remote_val.clone()).map_err(|e| e.to_string())?;
+    patch(&mut remote);
+    *remote_val = serde_json::to_value(&remote).map_err(|e| e.to_string())?;
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            if let Some(r) = project.remote.as_mut() {
+                patch(r);
+                storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Opt a **remote** project in/out of auto-connect (launch + activation bring the
+/// SSH — and, only if the host isn't directly reachable, the VPN — up with no
+/// prompt). The frontend only offers this once the connection can complete
+/// silently (saved SSH password, or a host recorded as `key_auth`); the connect
+/// path re-checks that itself, so a stale opt-in can never produce a prompt.
+/// Returns the resulting state.
+#[tauri::command]
+pub fn set_project_auto_connect(project_id: String, enabled: bool) -> Result<bool, String> {
+    patch_remote_spec(&project_id, |remote| {
+        remote.auto_connect = enabled.then_some(true);
+    })?;
+    Ok(enabled)
+}
+
+/// Opt a **remote** project in/out of persistent (tmux) sessions (TODO #85). The
+/// feature is **default ON** for a remote project, so the field is only written
+/// when the user opts *out* (`Some(false)`); turning it back on clears the field
+/// (`None`) to restore the default. Returns the resulting enabled state. Applies
+/// to shell/script tabs spawned after the change (each spawn reads it via the
+/// frontend's per-tab `tmux_session` name).
+#[tauri::command]
+pub fn set_project_persist_sessions(project_id: String, enabled: bool) -> Result<bool, String> {
+    patch_remote_spec(&project_id, |remote| {
+        remote.persist_sessions = if enabled { None } else { Some(false) };
+    })?;
+    Ok(enabled)
+}
+
+/// Set (or clear) the display name for a **remote** project's primary machine —
+/// the counterpart of `patch_compute_host`'s `label` for a worker. Distinct from
+/// the project name: this labels the host `Project.remote.host` reaches, shown
+/// wherever a project's hosts are listed side by side (System Monitor's source
+/// picker, the pill's connection lamps). A blank/whitespace-only string clears it,
+/// falling back to the bare host. Returns the resulting label (`None` when cleared).
+#[tauri::command]
+pub fn set_project_remote_label(
+    project_id: String,
+    label: Option<String>,
+) -> Result<Option<String>, String> {
+    let normalized = label
+        .as_deref()
+        .map(str::trim)
+        .filter(|t| !t.is_empty())
+        .map(str::to_string);
+    patch_remote_spec(&project_id, |remote| remote.label = normalized.clone())?;
+    Ok(normalized)
+}
+
+/// Set (or clear) the **SSH login name** a remote project's primary host is
+/// reached as. The half of the credential the Connect dialog never let you enter:
+/// the address is fixed at creation (`user@host`), so a project created without a
+/// user — or with the wrong one — authenticated as the *local* account name with
+/// no way to correct it short of recreating the project. Every login surface needs
+/// it, not just the headless one: it is what `ssh_connect`/`remote_connect` send
+/// **and** what `remote_login_command` types into the interactive login terminal.
+///
+/// A blank/whitespace-only string clears it (ssh then falls back to the local
+/// account name / `~/.ssh/config`). Returns the resulting user (`None` = cleared).
+///
+/// Changing it **clears `key_auth`**, which is not bookkeeping: that flag records
+/// that *the previous login* authenticated with no password at all, and it is what
+/// makes the pill offer a promptless auto-connect. Carried over to a different
+/// account it would advertise a silent connect nothing has ever proved — exactly
+/// the failure `record_key_auth`'s `via_login` case exists to prevent.
+///
+/// The saved password moves **with** the login. The keychain is keyed
+/// `ssh:{user}@{host}:{port}`, so a new login name addresses a different (empty)
+/// account — which used to be described here as needing no handling, and is in
+/// fact the bug: the old entry is orphaned, still on the ring, unreachable from
+/// any surface, and the connect that was silent starts prompting with no
+/// explanation. [`move_saved_password`] re-keys it, and only when the store is
+/// actually readable (a locked ring is not evidence there was nothing to move,
+/// and certainly not licence to delete). If nothing came across, the target now
+/// has neither a saved password nor a proven key login, so `auto_connect` is
+/// cleared too — an armed auto-connect it cannot deliver is worse than none.
+#[tauri::command]
+pub fn set_project_remote_user(
+    project_id: String,
+    user: Option<String>,
+) -> Result<Option<String>, String> {
+    let normalized = user
+        .as_deref()
+        .map(str::trim)
+        .filter(|t| !t.is_empty())
+        .map(str::to_string);
+    let target = crate::services::remote::remote_target_for(&project_id);
+    let current = target.as_ref().and_then(|t| t.spec.user.clone());
+    if current == normalized {
+        return Ok(normalized);
+    }
+    let has_password = target
+        .as_ref()
+        .map(|t| move_saved_password(&current, &normalized, &t.spec.host, t.spec.port))
+        .unwrap_or(false);
+    patch_remote_spec(&project_id, |remote| {
+        remote.user = normalized.clone();
+        remote.key_auth = None;
+        if !has_password {
+            remote.auto_connect = None;
+        }
+    })?;
+    Ok(normalized)
+}
+
+/// Re-key a host's saved SSH password from one login name to another, returning
+/// whether the new login has one afterwards.
+///
+/// Read under the old account, written under the new, then the old deleted — in
+/// that order, so a failed write never costs the secret. Refuses outright while
+/// the credential store is unreadable: there, `get` answers `None` for every
+/// account, so "there was nothing saved" and "we could not look" are the same
+/// answer, and acting on it would silently drop the password (and, since the entry
+/// is keyed by host, possibly another project's).
+fn move_saved_password(
+    old_user: &Option<String>,
+    new_user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> bool {
+    use crate::services::remote_credentials as creds;
+    if !creds::store_readable() {
+        return false;
+    }
+    let old = creds::ssh_account(old_user, host, port);
+    let new = creds::ssh_account(new_user, host, port);
+    if old == new {
+        return creds::has(&new);
+    }
+    let Some(secret) = creds::get(&old) else {
+        return creds::has(&new);
+    };
+    if creds::set(&new, Some(&secret)).is_err() {
+        return false;
+    }
+    let _ = creds::set(&old, None);
+    true
+}
+
+/// Record how a remote project's host authenticated on its last successful connect
+/// (`key_auth` = no password was used at all — key/agent auth). Called by
+/// `remote_connect`; this is the only way the UI can know a passwordless host is
+/// auto-connect-eligible, since such a host has nothing in the keychain to check.
+/// A no-op when the value is unchanged, so an ordinary connect costs no write.
+pub fn record_remote_key_auth(project_id: &str, key_auth: bool) -> Result<(), String> {
+    let current = crate::services::remote::remote_target_for(project_id)
+        .and_then(|t| t.spec.key_auth);
+    if current == Some(key_auth) {
+        return Ok(());
+    }
+    patch_remote_spec(project_id, |remote| remote.key_auth = Some(key_auth))
+}
+
+/// The worker twin of `record_remote_key_auth`: record how an extra "worker" host
+/// authenticated on its last successful connect (`key_auth` = no password at all —
+/// key/agent auth). Called by `remote_connect` on a worker connect. Without it a
+/// passwordless worker could never be marked auto-connect-eligible — it has nothing
+/// in the keychain to check — so the Connect dialog's Auto-connect toggle would
+/// stay permanently disabled for it. A no-op when unchanged, so an ordinary connect
+/// costs no write.
+pub fn record_worker_key_auth(
+    project_id: &str,
+    host_id: &str,
+    key_auth: bool,
+) -> Result<(), String> {
+    let current = crate::services::remote::compute_hosts_for(project_id)
+        .into_iter()
+        .find(|h| h.id == host_id)
+        .and_then(|h| h.spec.key_auth);
+    if current == Some(key_auth) {
+        return Ok(());
+    }
+    patch_compute_hosts(project_id, |hosts| {
+        if let Some(h) = hosts.iter_mut().find(|h| h.id == host_id) {
+            h.spec.key_auth = Some(key_auth);
+        }
+    })?;
+    Ok(())
+}
+
+/// Apply `patch` to a **remote** project's extra worker hosts (`compute_hosts`,
+/// `docs/multi_host_remote_plan.md`) in both places they are stored: the
+/// `projects.json` entry's flattened `extra["compute_hosts"]` (the always-local
+/// source of truth `services::remote::compute_hosts_for` reads) and the project's
+/// own `project.json` (best effort — a remote project's copy may be unreachable).
+/// Errors if the project is unknown. The list is created when absent, so this works
+/// on a project that has no workers yet.
+fn patch_compute_hosts(
+    project_id: &str,
+    patch: impl Fn(&mut Vec<ComputeHost>),
+) -> Result<Vec<ComputeHost>, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    let mut hosts: Vec<ComputeHost> = entry
+        .extra
+        .get("compute_hosts")
+        .and_then(|v| serde_json::from_value(v.clone()).ok())
+        .unwrap_or_default();
+    patch(&mut hosts);
+    let value = serde_json::to_value(&hosts).map_err(|e| e.to_string())?;
+    if hosts.is_empty() {
+        entry.extra.remove("compute_hosts");
+    } else {
+        entry.extra.insert("compute_hosts".to_string(), value);
+    }
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            patch(&mut project.compute_hosts);
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(hosts)
+}
+
+/// Persist which machine shells launched from this project run on — the choice
+/// made in the `RunHostPicker`. Mirrors `set_project_python`: it writes BOTH the
+/// `projects.json` entry's `extra["run_host"]` (what the frontend seeds its live
+/// preference store from on load) and the `project.json` `run_host` field (keeps
+/// it with the project). `location` is a `TabLocation` string (`"local"` /
+/// `"remote"` / `"host:<id>"`); `None` or empty clears it (back to the primary
+/// default). Returns the stored value.
+#[tauri::command]
+pub fn set_project_run_host(
+    project_id: String,
+    location: Option<String>,
+) -> Result<Option<String>, String> {
+    let value = location
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty());
+
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+
+    match &value {
+        Some(v) => {
+            entry
+                .extra
+                .insert("run_host".into(), serde_json::Value::String(v.clone()));
+        }
+        None => {
+            entry.extra.remove("run_host");
+        }
+    }
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.run_host = value.clone();
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(value)
+}
+
+/// Add an extra "worker" host to a remote project (the pill's "Add machine").
+/// Mints a stable `id` when the incoming spec has none, then appends it. Returns
+/// the full updated host list. The primary (`Project.remote`) is untouched.
+#[tauri::command]
+pub fn add_compute_host(
+    project_id: String,
+    mut host: ComputeHost,
+) -> Result<Vec<ComputeHost>, String> {
+    if host.id.trim().is_empty() {
+        host.id = uuid_v4();
+    }
+    patch_compute_hosts(&project_id, |hosts| {
+        // Replace in place when the id already exists (idempotent re-add), else push.
+        if let Some(existing) = hosts.iter_mut().find(|h| h.id == host.id) {
+            *existing = host.clone();
+        } else {
+            hosts.push(host.clone());
+        }
+    })
+}
+
+/// Remove a worker host from a remote project. The caller disconnects it and stops
+/// its fan-out first (frontend); this only drops the persisted entry. Returns the
+/// remaining host list.
+#[tauri::command]
+pub fn remove_compute_host(
+    project_id: String,
+    host_id: String,
+) -> Result<Vec<ComputeHost>, String> {
+    patch_compute_hosts(&project_id, |hosts| hosts.retain(|h| h.id != host_id))
+}
+
+/// Patch a worker host's toggles (`sync_code` / `pull_outputs` / `auto_connect` /
+/// `shared_fs` / `label` / `user`). Each argument is applied only when `Some`, so a
+/// caller can flip one flag without restating the others. Unknown `host_id` is a
+/// silent no-op (returns the unchanged list).
+///
+/// `user` is the worker twin of [`set_project_remote_user`] — the SSH login name,
+/// editable from the same Connect dialog — and clears `key_auth` for the same
+/// reason: it was recorded for the account being replaced.
+#[tauri::command]
+pub fn patch_compute_host(
+    project_id: String,
+    host_id: String,
+    sync_code: Option<bool>,
+    pull_outputs: Option<bool>,
+    auto_connect: Option<bool>,
+    shared_fs: Option<bool>,
+    label: Option<String>,
+    user: Option<String>,
+) -> Result<Vec<ComputeHost>, String> {
+    patch_compute_hosts(&project_id, |hosts| {
+        if let Some(h) = hosts.iter_mut().find(|h| h.id == host_id) {
+            if let Some(v) = &user {
+                let t = v.trim();
+                let next = if t.is_empty() { None } else { Some(t.to_string()) };
+                if h.spec.user != next {
+                    h.spec.user = next;
+                    h.spec.key_auth = None;
+                }
+            }
+            if let Some(v) = shared_fs {
+                h.shared_fs = v;
+            }
+            if let Some(v) = sync_code {
+                h.sync_code = v;
+            }
+            if let Some(v) = pull_outputs {
+                h.pull_outputs = v;
+            }
+            if let Some(v) = auto_connect {
+                h.spec.auto_connect = v.then_some(true);
+            }
+            if let Some(v) = &label {
+                let t = v.trim();
+                h.spec.label = if t.is_empty() { None } else { Some(t.to_string()) };
+            }
+        }
+    })
+}
+
+/// Normalize a list of category tags: trim each, drop blanks, and de-duplicate
+/// case-insensitively (first spelling wins), preserving order. Mirrors the
+/// frontend `cleanCategories` so storage stays canonical regardless of caller.
+fn clean_categories(raw: Vec<String>) -> Vec<String> {
+    let mut out: Vec<String> = Vec::new();
+    let mut seen: HashSet<String> = HashSet::new();
+    for r in raw {
+        let c = r.split_whitespace().collect::<Vec<_>>().join(" ");
+        if c.is_empty() {
+            continue;
+        }
+        if seen.insert(c.to_lowercase()) {
+            out.push(c);
+        }
+    }
+    out
+}
+
+/// Set a project's category tags in both `projects.json` (the pill list) and the
+/// project's own `project.json`, keeping the two in sync. Categories color/group
+/// the project in the cloud and the pill bar. An empty list clears the field
+/// entirely. Returns the cleaned, de-duplicated list that was stored.
+#[tauri::command]
+pub fn set_project_categories(
+    project_id: String,
+    categories: Vec<String>,
+) -> Result<Vec<String>, String> {
+    let cleaned = clean_categories(categories);
+
+    // projects.json — mirror into the entry's flattened `categories`.
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    if cleaned.is_empty() {
+        entry.extra.remove("categories");
+    } else {
+        let value = serde_json::to_value(&cleaned).map_err(|e| e.to_string())?;
+        entry.extra.insert("categories".to_string(), value);
+    }
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    // project.json — keep the per-project file consistent (best effort).
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            if cleaned.is_empty() {
+                project.extra.remove("categories");
+            } else {
+                let value = serde_json::to_value(&cleaned).map_err(|e| e.to_string())?;
+                project.extra.insert("categories".to_string(), value);
+            }
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+
+    Ok(cleaned)
+}
+
+/// Enable or disable git version control for an existing project.
+///
+/// **Destructive when disabling.** Disabling deletes the project's `.git`
+/// directory and `.gitignore` file outright — every commit, branch, stash,
+/// and remote is gone and cannot be recovered — and moves the project to
+/// `git_type` `"none"`, the same state a "No git (local files only)" project
+/// starts in. Enabling runs
+/// `git init` (a no-op if a repo already exists), writes the default
+/// `.gitignore` if missing (same as `scaffold_project`), and moves the
+/// project to `git_type` `"local"`.
+///
+/// Returns the resulting `git_type`. Mirrors the change into both
+/// `projects.json` and `project.json`, like `set_project_sandbox`.
+#[tauri::command]
+pub fn set_project_git_disabled(project_id: String, disabled: bool) -> Result<String, String> {
+    // projects.json — locate the entry and resolve its on-disk directory.
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    let local_file = entry.local_file.clone();
+    let directory = entry
+        .extra
+        .get("directory")
+        .and_then(Value::as_str)
+        .map(PathBuf::from)
+        .ok_or_else(|| "project has no directory".to_string())?;
+    if !directory.is_dir() {
+        return Err(format!(
+            "project directory does not exist: {}",
+            directory.display()
+        ));
+    }
+
+    let git_dir = directory.join(".git");
+    let new_git_type = if disabled {
+        // Destroy version-control history. `.git` is the single source of truth
+        // for it, so removing the directory is the whole operation.
+        if git_dir.exists() {
+            fs::remove_dir_all(&git_dir)
+                .map_err(|e| format!("failed to remove .git: {e}"))?;
+        }
+        let gitignore = directory.join(".gitignore");
+        if gitignore.exists() {
+            fs::remove_file(&gitignore)
+                .map_err(|e| format!("failed to remove .gitignore: {e}"))?;
+        }
+        "none".to_string()
+    } else {
+        if !git_dir.exists() {
+            let output = crate::paths::command_no_window("git")
+                .args(["init"])
+                .current_dir(&directory)
+                .output()
+                .map_err(|e| format!("failed to run git init: {e}"))?;
+            if !output.status.success() {
+                return Err(format!(
+                    "git init failed: {}",
+                    String::from_utf8_lossy(&output.stderr).trim()
+                ));
+            }
+        }
+        let gitignore = directory.join(".gitignore");
+        if !gitignore.exists() {
+            fs::write(&gitignore, GITIGNORE_DEFAULT)
+                .map_err(|e| format!("failed to write .gitignore: {e}"))?;
+        }
+        "local".to_string()
+    };
+
+    // projects.json — mirror the new push-axis type into the flattened entry.
+    entry
+        .extra
+        .insert("git_type".to_string(), Value::String(new_git_type.clone()));
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    // project.json — keep the per-project file consistent (best effort).
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.git_type = Some(new_git_type.clone());
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+
+    Ok(new_git_type)
+}
+
 // ── Per-project project.json ───────────────────────────────────────────────
 
 #[tauri::command]
@@ -124,14 +1417,25 @@ pub fn save_project(local_file: String, project: Project) -> Result<(), String>
 }
 
 /// Save only the tab layout — writes to both project.json and the session file.
+///
+/// `allow_clear` licenses an EMPTY `tabs` to erase the saved layout. The frontend
+/// sets it only for a scope it has actually hydrated and that genuinely holds no
+/// tabs; every other empty save is a no-op. See `terminal_service`.
 #[tauri::command]
 pub fn save_tab_layout(
     local_file: String,
     tabs: Vec<crate::schema::project::TabEntry>,
     groups: Option<Value>,
     sessions: Option<Value>,
+    allow_clear: bool,
 ) -> Result<(), String> {
-    crate::services::terminal_service::save_tab_layout(&local_file, &tabs, groups, sessions)
+    crate::services::terminal_service::save_tab_layout(
+        &local_file,
+        &tabs,
+        groups,
+        sessions,
+        allow_clear,
+    )
 }
 
 #[tauri::command]
@@ -144,6 +1448,14 @@ pub fn projects_root_dir() -> String {
     projects_root().to_string_lossy().to_string()
 }
 
+/// The default parent directory for a remote (SSH) project's local mirror — the
+/// top-level `eldrun/projects-ssh/` root. The New/Import dialog seeds its "Local
+/// location" picker from this so its default matches `default_remote_mirror`.
+#[tauri::command]
+pub fn remote_mirror_root_dir() -> String {
+    paths::projects_ssh_root().to_string_lossy().to_string()
+}
+
 /// Open a directory in the OS file manager (Files/Finder/Explorer).
 #[tauri::command]
 pub fn open_in_file_manager(path: String) -> Result<(), String> {
@@ -151,7 +1463,137 @@ pub fn open_in_file_manager(path: String) -> Result<(), String> {
     if !dir.is_dir() {
         return Err(format!("Not a directory: {path}"));
     }
-    opener::open(&dir).map_err(|e| e.to_string())
+    opener::open(&dir).map_err(|e| e.to_string())
+}
+
+/// The local mirror status for a remote (SSH) project — backs the pill's "Show on
+/// disk". Returns the current mirror root (its stored override or the default),
+/// whether that directory still exists on disk (a user may have deleted it), and
+/// a suggested fresh location (`ssh/<name>` under the projects root) to default a
+/// relocation picker to. Errors for a local project.
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MirrorStatus {
+    pub path: String,
+    pub exists: bool,
+    pub suggested: String,
+}
+
+#[tauri::command]
+pub fn remote_mirror_status(project_id: String, name: String) -> Result<MirrorStatus, String> {
+    if crate::services::remote::remote_target_for(&project_id).is_none() {
+        return Err("not a remote project".to_string());
+    }
+    let dir = crate::services::remote_sync::mirror_dir(&project_id);
+    let suggested = default_remote_mirror(&name, &project_id);
+    Ok(MirrorStatus {
+        exists: dir.is_dir(),
+        path: dir.to_string_lossy().to_string(),
+        suggested: suggested.to_string_lossy().to_string(),
+    })
+}
+
+/// Point a remote (SSH) project's local mirror at `path`, creating the directory,
+/// and persist the choice in both `projects.json` (`extra["mirror"]`, the source
+/// of truth `remote_sync::mirror_dir` reads) and the project's `project.json`.
+/// Used when the user relocates a mirror whose folder was deleted. Returns the
+/// resolved absolute path.
+#[tauri::command]
+pub fn set_remote_mirror_dir(project_id: String, path: String) -> Result<String, String> {
+    if crate::services::remote::remote_target_for(&project_id).is_none() {
+        return Err("not a remote project".to_string());
+    }
+    let dir = PathBuf::from(path.trim());
+    if dir.as_os_str().is_empty() {
+        return Err("Mirror path is empty".to_string());
+    }
+    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+    let resolved = dir.to_string_lossy().to_string();
+    persist_mirror_dir(&project_id, &resolved)?;
+    Ok(resolved)
+}
+
+/// Persist a remote project's chosen mirror root into both `projects.json`
+/// (`extra["mirror"]`, the always-local source of truth `remote_sync::mirror_dir`
+/// reads) and the project's `project.json` (best effort). Shared by
+/// `set_remote_mirror_dir` and `move_remote_mirror`.
+fn persist_mirror_dir(project_id: &str, resolved: &str) -> Result<(), String> {
+    // projects.json — the always-local source of truth.
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+    entry
+        .extra
+        .insert("mirror".to_string(), Value::String(resolved.to_string()));
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    // project.json — keep the per-project file consistent (best effort).
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.mirror = Some(resolved.to_string());
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Move a remote (SSH) project's local mirror folder to a new location: the user
+/// picks a **parent** directory, and the mirror is relocated to
+/// `<parent_dir>/<sanitized-name>` (disambiguated with a short id suffix if that
+/// leaf is taken). The existing mirror bytes are moved (rename, with a
+/// copy-then-remove fallback across filesystems); a never-synced mirror simply
+/// has the new folder created. Persists the new pointer and returns its absolute
+/// path. Errors for a local project. Backs the pill's "Move project…" option.
+#[tauri::command]
+pub fn move_remote_mirror(
+    project_id: String,
+    name: String,
+    parent_dir: String,
+) -> Result<String, String> {
+    if crate::services::remote::remote_target_for(&project_id).is_none() {
+        return Err("not a remote project".to_string());
+    }
+    let parent = PathBuf::from(parent_dir.trim());
+    if parent.as_os_str().is_empty() {
+        return Err("Destination folder is empty".to_string());
+    }
+    fs::create_dir_all(&parent).map_err(|e| e.to_string())?;
+
+    // Compute the new leaf under the chosen parent, mirroring `default_remote_mirror`.
+    let safe = sanitize_name(&name);
+    let leaf = if safe.is_empty() { project_id.clone() } else { safe };
+    let candidate = parent.join(&leaf);
+    let new_root = if candidate.exists() {
+        parent.join(format!("{leaf}-{}", &project_id[..project_id.len().min(8)]))
+    } else {
+        candidate
+    };
+
+    let old = crate::services::remote_sync::mirror_dir(&project_id);
+    if old.exists() && old != new_root {
+        // A plain rename fails across drives/filesystems (EXDEV on Unix). Fall
+        // back to copy-then-remove so a cross-volume move still works.
+        if fs::rename(&old, &new_root).is_err() {
+            copy_dir_all(&old, &new_root)?;
+            fs::remove_dir_all(&old).map_err(|e| e.to_string())?;
+        }
+    } else {
+        fs::create_dir_all(&new_root).map_err(|e| e.to_string())?;
+    }
+
+    let resolved = new_root.to_string_lossy().to_string();
+    persist_mirror_dir(&project_id, &resolved)?;
+    Ok(resolved)
 }
 
 // ── Scaffold new project ───────────────────────────────────────────────────
@@ -167,7 +1609,7 @@ const SCAFFOLD_FILES: &[(&str, &str)] = &[
     ("DOCUMENTATION.md", "# Documentation\n"),
 ];
 
-const GITIGNORE_DEFAULT: &str = "__pycache__/\n*.pyc\n.venv/\nnode_modules/\ntarget/\ndist/\nbuild/\n.env\n.env.local\n.DS_Store\n*.log\n*.swp\n*.swo\n.idea/\n.eldrun/\n";
+const GITIGNORE_DEFAULT: &str = "__pycache__/\n*.pyc\n.venv/\nnode_modules/\ntarget/\ndist/\nbuild/\n.env\n.env.local\n.DS_Store\n*.log\n*.swp\n*.swo\n.idea/\n.eldrun/\nproject.json\n";
 
 const CLAUDE_SETTINGS: &str = r#"{"permissions":{"allow":[],"deny":[]}}"#;
 
@@ -180,7 +1622,11 @@ pub struct ScaffoldPreviewItem {
 }
 
 /// Write the standard Eldrun project scaffold into a directory.
-pub fn scaffold_project(dir: &Path) -> std::io::Result<()> {
+///
+/// When `with_git` is false the scaffold files are still written but no git
+/// repository is initialized — used for "local, no git" projects (git_type
+/// `"none"`).
+pub fn scaffold_project(dir: &Path, with_git: bool) -> std::io::Result<()> {
     fs::create_dir_all(dir)?;
     let dot_claude = dir.join(".claude");
     fs::create_dir_all(&dot_claude)?;
@@ -192,19 +1638,316 @@ pub fn scaffold_project(dir: &Path) -> std::io::Result<()> {
         }
     }
     let gi = dir.join(".gitignore");
-    if !gi.exists() {
+    if with_git && !gi.exists() {
         fs::write(gi, GITIGNORE_DEFAULT)?;
     }
     let cs = dot_claude.join("settings.json");
     if !cs.exists() {
         fs::write(cs, CLAUDE_SETTINGS)?;
     }
-    if !dir.join(".git").exists() {
-        let _ = Command::new("git").args(["init"]).current_dir(dir).output();
+    if with_git && !dir.join(".git").exists() {
+        let _ = crate::paths::command_no_window("git")
+            .args(["init"])
+            .current_dir(dir)
+            .output();
+        // Give the fresh repo an initial commit so the scaffold (`.claude`, docs,
+        // `.gitignore`) is TRACKED, not merely present. This is what makes a later
+        // remote `extend` seed the host: git lockstep pairs by transferring
+        // *committed* state (`init_pairing` → `reset --hard`), so an unborn HEAD
+        // would leave the freshly-paired remote empty and untracked files (like
+        // `.claude/settings.json`) never ride the bundle. Only runs for a repo we
+        // just created — an imported repo already has `.git`, so its history is
+        // never touched.
+        git_scaffold_commit(dir);
     }
     Ok(())
 }
 
+/// Stage everything the `.gitignore` permits and create a single scaffold commit.
+/// Best-effort: staging or the commit failing just leaves HEAD as it was. Respects
+/// the user's configured git identity, falling back to an Eldrun identity only when
+/// git can't resolve one (fresh machine, no global `user.name`/`user.email`) so the
+/// commit never silently fails for lack of a committer and leaves HEAD unborn.
+fn git_scaffold_commit(dir: &Path) {
+    let _ = crate::paths::command_no_window("git")
+        .args(["add", "-A"])
+        .current_dir(dir)
+        .output();
+    const MSG: &str = "Initial Eldrun scaffold";
+    let committed = crate::paths::command_no_window("git")
+        .args(["commit", "-m", MSG])
+        .current_dir(dir)
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if !committed {
+        let _ = crate::paths::command_no_window("git")
+            .args([
+                "-c",
+                "user.name=Eldrun",
+                "-c",
+                "user.email=eldrun@localhost",
+                "commit",
+                "-m",
+                MSG,
+            ])
+            .current_dir(dir)
+            .output();
+    }
+}
+
+/// True when `dir` is a git repo whose current branch is **unborn** (no commits
+/// yet — `rev-parse HEAD` fails). Used to decide whether `extend` must seed an
+/// initial commit before lockstep pairing. A missing/erroring git returns `false`
+/// (don't force a commit when we can't tell), never a wipe.
+fn git_head_unborn(dir: &Path) -> bool {
+    crate::paths::command_no_window("git")
+        .args(["rev-parse", "--verify", "--quiet", "HEAD"])
+        .current_dir(dir)
+        .output()
+        .map(|o| !o.status.success())
+        .unwrap_or(false)
+}
+
+/// Append any `GITIGNORE_DEFAULT` pattern missing from `dir/.gitignore` to the
+/// end of the file, creating it fresh if absent. Existing lines are never
+/// reordered or removed — this only ever adds patterns Eldrun scaffolds by
+/// default (e.g. a new one like `project.json` added after the project's
+/// `.gitignore` was first written). Returns the patterns that were added.
+fn ensure_gitignore_defaults(dir: &Path) -> std::io::Result<Vec<String>> {
+    let path = dir.join(".gitignore");
+    let defaults: Vec<&str> = GITIGNORE_DEFAULT.lines().filter(|l| !l.is_empty()).collect();
+    if !path.exists() {
+        fs::write(&path, GITIGNORE_DEFAULT)?;
+        return Ok(defaults.into_iter().map(str::to_string).collect());
+    }
+    let existing = fs::read_to_string(&path)?;
+    let existing_lines: HashSet<&str> = existing.lines().collect();
+    let missing: Vec<&str> = defaults
+        .into_iter()
+        .filter(|l| !existing_lines.contains(l))
+        .collect();
+    if missing.is_empty() {
+        return Ok(vec![]);
+    }
+    let mut updated = existing;
+    if !updated.is_empty() && !updated.ends_with('\n') {
+        updated.push('\n');
+    }
+    for line in &missing {
+        updated.push_str(line);
+        updated.push('\n');
+    }
+    fs::write(&path, updated)?;
+    Ok(missing.into_iter().map(str::to_string).collect())
+}
+
+/// Result of repairing one project's scaffold — which pieces were actually
+/// missing and got filled in, so the caller can report something meaningful
+/// instead of a silent no-op.
+#[derive(Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScaffoldRepairReport {
+    pub created_files: Vec<String>,
+    pub gitignore_lines_added: Vec<String>,
+    pub git_initialized: bool,
+}
+
+impl ScaffoldRepairReport {
+    fn is_empty(&self) -> bool {
+        self.created_files.is_empty() && self.gitignore_lines_added.is_empty() && !self.git_initialized
+    }
+}
+
+/// Like `scaffold_project`, but for an **already-scaffolded** project whose
+/// scaffold has drifted behind current defaults (e.g. it predates a scaffold
+/// file or a `.gitignore` pattern being added). Fills in whatever is missing —
+/// same never-overwrite rule for existing files — and additionally merges any
+/// missing `GITIGNORE_DEFAULT` pattern into an already-present `.gitignore`
+/// (plain `scaffold_project` leaves a pre-existing `.gitignore` untouched).
+fn repair_project_scaffold_at(dir: &Path, with_git: bool) -> std::io::Result<ScaffoldRepairReport> {
+    fs::create_dir_all(dir)?;
+    let dot_claude = dir.join(".claude");
+    fs::create_dir_all(&dot_claude)?;
+
+    let mut report = ScaffoldRepairReport::default();
+    for (name, content) in SCAFFOLD_FILES {
+        let p = dir.join(name);
+        if !p.exists() {
+            fs::write(&p, content)?;
+            report.created_files.push((*name).to_string());
+        }
+    }
+    if with_git {
+        report.gitignore_lines_added = ensure_gitignore_defaults(dir)?;
+    }
+
+    let cs = dot_claude.join("settings.json");
+    if !cs.exists() {
+        fs::write(&cs, CLAUDE_SETTINGS)?;
+        report.created_files.push(".claude/settings.json".to_string());
+    }
+    if with_git && !dir.join(".git").exists() {
+        let _ = crate::paths::command_no_window("git")
+            .args(["init"])
+            .current_dir(dir)
+            .output();
+        report.git_initialized = dir.join(".git").is_dir();
+    }
+    Ok(report)
+}
+
+/// Resolve the local, on-disk directory a project's scaffold lives in: the
+/// project's own `directory` for a local project, or its local `mirror`
+/// working copy for a mount-free remote project (the remote host tree is
+/// never touched here — see `finish_import`/`create_project`). `None` when
+/// there is no local target to repair (e.g. a remote project with no mirror
+/// recorded yet).
+fn scaffold_target_for_entry(entry: &ProjectEntry) -> Option<(PathBuf, bool)> {
+    let git_type = entry
+        .extra
+        .get("git_type")
+        .and_then(Value::as_str)
+        .unwrap_or("local");
+    let with_git = git_type != "none";
+    let target = if entry_is_remote(entry) {
+        entry_mirror(entry)?
+    } else {
+        entry_directory(entry)?
+    };
+    Some((PathBuf::from(target), with_git))
+}
+
+/// A single project's scaffold-repair outcome, for the "Repair scaffold
+/// files" UI action (per-project or bulk across all managed projects).
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectScaffoldRepair {
+    pub project_id: String,
+    pub name: String,
+    pub target_dir: String,
+    pub report: ScaffoldRepairReport,
+}
+
+/// Repair one project's scaffold: fill in any scaffold doc, `.gitignore`
+/// pattern, or `.claude/settings.json` that is missing relative to current
+/// defaults. Safe to run repeatedly — every step is additive/idempotent.
+#[tauri::command]
+pub fn repair_project_scaffold(project_id: String) -> Result<ProjectScaffoldRepair, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let list: ProjectsList = storage::read_json(&list_path).map_err(|e| e.to_string())?;
+    let entry = list
+        .into_iter()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| "Project not found".to_string())?;
+    let (target, with_git) = scaffold_target_for_entry(&entry)
+        .ok_or_else(|| "Project has no local scaffold target".to_string())?;
+    let report = repair_project_scaffold_at(&target, with_git).map_err(|e| e.to_string())?;
+    Ok(ProjectScaffoldRepair {
+        project_id: entry.id,
+        name: entry.name,
+        target_dir: target.to_string_lossy().to_string(),
+        report,
+    })
+}
+
+/// Repair scaffold files across every managed project in one pass — the bulk
+/// counterpart to `repair_project_scaffold`. Projects whose local target
+/// directory doesn't exist yet (e.g. a remote project whose mirror hasn't
+/// materialized) are silently skipped rather than erroring the whole batch.
+/// Returns only the projects that actually needed a repair.
+#[tauri::command]
+pub fn repair_all_project_scaffolds() -> Result<Vec<ProjectScaffoldRepair>, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    if !list_path.exists() {
+        return Ok(vec![]);
+    }
+    let list: ProjectsList = storage::read_json(&list_path).map_err(|e| e.to_string())?;
+    let mut results = Vec::new();
+    for entry in &list {
+        let Some((target, with_git)) = scaffold_target_for_entry(entry) else {
+            continue;
+        };
+        if !target.is_dir() {
+            continue;
+        }
+        match repair_project_scaffold_at(&target, with_git) {
+            Ok(report) if !report.is_empty() => results.push(ProjectScaffoldRepair {
+                project_id: entry.id.clone(),
+                name: entry.name.clone(),
+                target_dir: target.to_string_lossy().to_string(),
+                report,
+            }),
+            Ok(_) => {}
+            Err(e) => eprintln!(
+                "repair_all_project_scaffolds: '{}' ({}) failed: {e}",
+                entry.name, entry.id
+            ),
+        }
+    }
+    Ok(results)
+}
+
+/// One-time-per-entry startup migration that brings legacy `projects.json`
+/// entries fully in line with the current Eldrun version. For each entry:
+///
+/// 1. `normalize_entry` canonicalizes its shape (backfill `directory`, map
+///    legacy `git_type`). Entries it touches are *legacy* — written by an older
+///    Eldrun that predates those fields.
+/// 2. Every legacy entry additionally gets its on-disk scaffold refreshed (the
+///    same additive, never-overwrite repair as the manual "Repair scaffold
+///    files" action), since a legacy project also predates current scaffold
+///    defaults (`.claude/settings.json`, newer docs, `.gitignore` patterns).
+///
+/// The normalized list is persisted once if anything changed, so the migration
+/// is durable rather than re-derived on every load. Runs best-effort at startup
+/// off the UI thread; every failure is logged and non-fatal.
+pub fn migrate_legacy_projects() {
+    let path = storage::state_dir().join("projects.json");
+    if !path.exists() {
+        return;
+    }
+    let mut list: ProjectsList = match storage::read_json(&path) {
+        Ok(l) => l,
+        Err(e) => {
+            eprintln!("migrate_legacy_projects: read projects.json: {e}");
+            return;
+        }
+    };
+    let mut dirty = false;
+    for entry in list.iter_mut() {
+        if !normalize_entry(entry) {
+            continue; // already current — nothing to migrate or repair.
+        }
+        dirty = true;
+        // Legacy entry: also fill in any scaffold piece it predates. Skipped
+        // when there's no materialized local target yet (e.g. a remote project
+        // whose mirror hasn't been created).
+        let Some((target, with_git)) = scaffold_target_for_entry(entry) else {
+            continue;
+        };
+        if !target.is_dir() {
+            continue;
+        }
+        match repair_project_scaffold_at(&target, with_git) {
+            Ok(report) if !report.is_empty() => eprintln!(
+                "migrate_legacy_projects: '{}' ({}) scaffold repaired: {:?}",
+                entry.name, entry.id, report.created_files
+            ),
+            Ok(_) => {}
+            Err(e) => eprintln!(
+                "migrate_legacy_projects: '{}' ({}) scaffold repair failed: {e}",
+                entry.name, entry.id
+            ),
+        }
+    }
+    if dirty {
+        if let Err(e) = storage::write_json(&path, &list) {
+            eprintln!("migrate_legacy_projects: persist projects.json: {e}");
+        }
+    }
+}
+
 fn scaffold_preview(dir: &Path) -> Vec<ScaffoldPreviewItem> {
     let mut items = SCAFFOLD_FILES
         .iter()
@@ -242,6 +1985,37 @@ pub fn preview_project_scaffold(source_dir: String) -> Result<Vec<ScaffoldPrevie
     Ok(scaffold_preview(&source))
 }
 
+/// True when a project is missing one or more scaffold pieces (any scaffold
+/// doc, `.claude/settings.json`, or — for git-backed projects only —
+/// `.gitignore`) — drives the "no scaffold" tag in the pill hover overlay.
+/// `.gitignore` is a git-axis artifact, so it is not required of `git_type:
+/// "none"` projects (which never get one written, see `scaffold_project`).
+/// `.git` is likewise excluded: git presence is the separate `git_type` axis. A
+/// project with no materialized local scaffold target yet (e.g. a remote project
+/// whose mirror hasn't been created) reports `false` rather than a spurious
+/// "missing".
+#[tauri::command]
+pub fn project_scaffold_missing(project_id: String) -> Result<bool, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    if !list_path.exists() {
+        return Ok(false);
+    }
+    let list: ProjectsList = storage::read_json(&list_path).map_err(|e| e.to_string())?;
+    let Some(entry) = list.into_iter().find(|p| p.id == project_id) else {
+        return Ok(false);
+    };
+    let Some((target, with_git)) = scaffold_target_for_entry(&entry) else {
+        return Ok(false);
+    };
+    if !target.is_dir() {
+        return Ok(false);
+    }
+    let missing = SCAFFOLD_FILES.iter().any(|(name, _)| !target.join(name).exists())
+        || (with_git && !target.join(".gitignore").exists())
+        || !target.join(".claude/settings.json").exists();
+    Ok(missing)
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateProjectRequest {
@@ -249,29 +2023,81 @@ pub struct CreateProjectRequest {
     pub directory: String,
     pub description: Option<String>,
     pub git_type: Option<String>,
+    /// Skip writing the Eldrun scaffold (and `git init`) — for new projects
+    /// that should start empty. `project.json` is still created so the project
+    /// registers normally.
+    #[serde(default)]
+    pub skip_scaffold: bool,
     /// When present the project is remote: `directory` is ignored and the
     /// project root becomes the local sshfs mountpoint for `remote`.
     #[serde(default)]
     pub remote: Option<RemoteSpec>,
+    /// Remote projects only: the user-chosen parent directory for the local
+    /// mirror (the dialog's "Local location"). The mirror lands at
+    /// `<mirror_parent>/<name>`. Absent → the default `projects-ssh` root.
+    #[serde(default)]
+    pub mirror_parent: Option<String>,
 }
 
 #[tauri::command]
 pub fn create_project(req: CreateProjectRequest) -> Result<ProjectEntry, String> {
     let id = uuid_v4();
 
-    // For remote projects the working directory is the sshfs mountpoint; for
-    // local projects it is the chosen directory. Establish the mount first so
-    // scaffolding writes onto the remote filesystem.
+    // Mount-free remote: a remote project's `directory` is a LOCAL per-project
+    // state dir that holds its `project.json` (tabs/time/etc.); the project's
+    // actual tree lives on the host at `remote.remote_path` and is reached over
+    // SFTP/SSH. Best-effort create that remote root so agent tabs / git can `cd`
+    // into it (key/agent auth — a password-auth host may need it to pre-exist).
+    // Local projects use the chosen directory unchanged.
     let dir = match req.remote.as_ref() {
-        Some(remote) => ssh_mount::mount(remote, &id)?,
+        Some(remote) => {
+            if let Err(e) = crate::services::ssh_exec::remote_mkdir_p(remote) {
+                eprintln!(
+                    "create_project: remote mkdir '{}' failed (create it on the host if needed): {e}",
+                    remote.remote_path
+                );
+            }
+            remote_project_state_dir(&id)
+        }
         None => PathBuf::from(&req.directory),
     };
     let directory = dir.to_string_lossy().to_string();
 
-    scaffold_project(&dir).map_err(|e| e.to_string())?;
+    let git_type = normalize_git_type(req.git_type.as_deref().unwrap_or("local"));
+
+    // Remote projects mirror into `<name>` under the chosen "Local location"
+    // (`mirror_parent`), defaulting to the top-level `eldrun/projects-ssh/` root;
+    // relocatable later. None for local projects.
+    let mirror = req
+        .remote
+        .as_ref()
+        .map(|_| resolve_remote_mirror(req.mirror_parent.as_deref(), &req.name, &id));
+
+    // A remote project's local `directory` only holds project.json (created
+    // below); its scaffold belongs in the local **mirror** twin — the working
+    // copy the user edits and local-on-remote tabs cwd into. Bytes reach the
+    // host only on an explicit manual push (SSH-sync is PULL-only / no-clobber),
+    // so scaffolding the mirror is safe and never touches the host tree here.
+    if req.remote.is_some() {
+        std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+        // Every remote project has an always-present local mirror twin, created
+        // up front so a local-on-remote tab can cwd into it immediately. Scaffold
+        // it like a local project (honoring skip_scaffold); manual sync pushes it.
+        if let Some(mirror) = &mirror {
+            let mirror_dir = Path::new(mirror);
+            if req.skip_scaffold {
+                let _ = std::fs::create_dir_all(mirror_dir);
+            } else {
+                scaffold_project(mirror_dir, git_type != "none").map_err(|e| e.to_string())?;
+            }
+        }
+    } else if !req.skip_scaffold {
+        scaffold_project(&dir, git_type != "none").map_err(|e| e.to_string())?;
+    } else {
+        std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+    }
 
     let now = chrono_now();
-    let git_type = normalize_git_type(req.git_type.as_deref().unwrap_or("local"));
     let description = clean_description(req.description);
 
     let project = Project {
@@ -282,6 +2108,7 @@ pub fn create_project(req: CreateProjectRequest) -> Result<ProjectEntry, String>
         git_type: Some(git_type.clone()),
         created_at: Some(now),
         remote: req.remote.clone(),
+        mirror: mirror.clone(),
         ..Default::default()
     };
 
@@ -296,7 +2123,7 @@ pub fn create_project(req: CreateProjectRequest) -> Result<ProjectEntry, String>
         vec![]
     };
     let position = next_position(&list);
-    let extra = project_extra(directory, git_type, description, req.remote.as_ref());
+    let extra = project_extra(directory, git_type, description, req.remote.as_ref(), mirror.as_deref());
 
     let entry = ProjectEntry {
         id: id.clone(),
@@ -309,6 +2136,32 @@ pub fn create_project(req: CreateProjectRequest) -> Result<ProjectEntry, String>
     list.push(entry.clone());
     storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
 
+    // Lockstep on by default for a git-backed remote project — the same call
+    // `extend_project_to_remote` makes, for the same reason: the host root was
+    // just created (empty), and the mirror was scaffolded with an initial commit,
+    // so the first pass can only be a one-directional seed, never a divergence.
+    // If the user instead pointed at a host dir that already holds differing
+    // files, pairing refuses and asks (`pairing_conflict`) rather than clobbering.
+    //
+    // Gated on the mirror *actually* being a repo rather than on `git_type` alone:
+    // `skip_scaffold` creates the mirror without `git init`, and lockstep on a
+    // repo-less mirror has no history to seed from. Best-effort — a write failure
+    // just leaves lockstep off (its default), never fails project creation.
+    if let Some(mirror) = mirror.as_deref() {
+        if Path::new(mirror).join(".git").is_dir() {
+            let state = crate::services::git_peer::GitPeerState {
+                enabled: true,
+                ..Default::default()
+            };
+            if let Err(e) = crate::services::git_peer::save_state(&id, &state) {
+                eprintln!(
+                    "create_project: could not enable lockstep for '{id}' \
+                     (leaving it off; user can toggle it on): {e}"
+                );
+            }
+        }
+    }
+
     Ok(entry)
 }
 
@@ -331,6 +2184,11 @@ pub struct ImportProjectRequest {
     /// remote directory and the only supported `mode` is "keep".
     #[serde(default)]
     pub remote: Option<RemoteSpec>,
+    /// Remote imports only: the user-chosen parent directory for the local
+    /// mirror (the dialog's "Local location"). The mirror lands at
+    /// `<mirror_parent>/<name>`. Absent → the default `projects-ssh` root.
+    #[serde(default)]
+    pub mirror_parent: Option<String>,
 }
 
 #[tauri::command]
@@ -339,17 +2197,19 @@ pub fn import_project(req: ImportProjectRequest) -> Result<ProjectEntry, String>
         return Err("Project name is invalid".to_string());
     }
 
-    // Generate the id up front: remote imports mount under it before we touch
-    // the filesystem.
     let id = uuid_v4();
 
     if let Some(remote) = req.remote.clone() {
         if req.mode != "keep" {
             return Err("Remote imports must use 'keep' mode (copy/move are not supported)".to_string());
         }
-        // Establish (or reuse) the sshfs mount; the mountpoint is the project root.
-        let mountpoint = ssh_mount::mount(&remote, &id)?;
-        return finish_import(req, id, mountpoint, Some(remote));
+        // Mount-free: the user browsed to an existing remote directory, so there
+        // is nothing to create on the host. The project's `directory` is a LOCAL
+        // per-project state dir that holds its project.json; the tree stays on the
+        // host (`remote.remote_path`) and is reached over SFTP/SSH.
+        let local = remote_project_state_dir(&id);
+        std::fs::create_dir_all(&local).map_err(|e| e.to_string())?;
+        return finish_import(req, id, local, Some(remote));
     }
 
     let source = PathBuf::from(&req.source_dir);
@@ -377,7 +2237,13 @@ pub fn import_project(req: ImportProjectRequest) -> Result<ProjectEntry, String>
                 copy_dir_all(&source, &dest)?;
             } else {
                 fs::create_dir_all(projects_root()).map_err(|e| e.to_string())?;
-                fs::rename(&source, &dest).map_err(|e| e.to_string())?;
+                // A plain rename fails across drives/filesystems (EXDEV on Unix,
+                // ERROR_NOT_SAME_DEVICE / os error 17 on Windows). Fall back to
+                // copy-then-remove so a cross-volume import still moves.
+                if fs::rename(&source, &dest).is_err() {
+                    copy_dir_all(&source, &dest)?;
+                    fs::remove_dir_all(&source).map_err(|e| e.to_string())?;
+                }
             }
             dest
         }
@@ -415,14 +2281,55 @@ fn finish_import(
         return Err("Project is already registered".to_string());
     }
 
-    if !req.skip_scaffold {
-        scaffold_project(&target).map_err(|e| e.to_string())?;
+    let mut git_type = normalize_git_type(req.git_type.as_deref().unwrap_or("local"));
+
+    // Scaffold only LOCAL imports onto their (local) tree. A remote import's
+    // `target` is the local per-project state dir (project.json only); its tree
+    // already exists on the host, so no local scaffold is written there.
+    if remote.is_none() && !req.skip_scaffold {
+        scaffold_project(&target, git_type != "none").map_err(|e| e.to_string())?;
+    }
+
+    // A remote import keeps the host tree as the git authority (it pre-exists on
+    // the host, so we never scaffold or `git init` the local mirror — pairing
+    // pulls the host's history down). But when the user imports **with git
+    // support** onto a host dir that is not yet a repo, there is no history for
+    // lockstep to pair from; initialize a repo on the host so the mirror can be
+    // paired from it. Idempotent (a dir that is already a repo is left as-is).
+    //
+    // The git label must reflect reality: a remote project's repo lives on the
+    // host, so if we cannot establish one there, the project must NOT be tagged
+    // git (else the pill shows a git badge for a project with no repo anywhere —
+    // the mirror deliberately carries no `.git`). Import always runs with a live
+    // connection (the user just browsed the host to pick the dir), so a failure
+    // here means git genuinely could not be set up, not a transient offline —
+    // downgrade to `none` so the label is honest.
+    if let Some(remote) = &remote {
+        if git_type != "none" {
+            if let Err(e) = crate::services::ssh_exec::remote_git_init(remote) {
+                eprintln!(
+                    "finish_import: remote git init '{}' failed; recording git_type=none so the \
+                     project is not labeled git without a repo on the host: {e}",
+                    remote.remote_path
+                );
+                git_type = "none".to_string();
+            }
+        }
     }
 
     let now = chrono_now();
-    let git_type = normalize_git_type(req.git_type.as_deref().unwrap_or("local"));
     let requested_description = clean_description(req.description);
 
+    // Remote imports mirror into `<name>` under the chosen "Local location"
+    // (`mirror_parent`), defaulting to the `eldrun/projects-ssh/` root; created up
+    // front so a local-on-remote tab can cwd into it immediately. None for local.
+    let mirror = remote
+        .as_ref()
+        .map(|_| resolve_remote_mirror(req.mirror_parent.as_deref(), &req.name, &id));
+    if let Some(mirror) = &mirror {
+        let _ = std::fs::create_dir_all(mirror);
+    }
+
     let project = if project_file.exists() {
         let mut existing: Project = storage::read_json(&project_file).unwrap_or_default();
         existing.id = id.clone();
@@ -433,6 +2340,7 @@ fn finish_import(
         }
         existing.git_type = Some(git_type.clone());
         existing.remote = remote.clone();
+        existing.mirror = mirror.clone();
         existing
     } else {
         Project {
@@ -443,6 +2351,7 @@ fn finish_import(
             git_type: Some(git_type.clone()),
             created_at: Some(now),
             remote: remote.clone(),
+            mirror: mirror.clone(),
             ..Default::default()
         }
     };
@@ -450,7 +2359,7 @@ fn finish_import(
 
     let position = next_position(&list);
     let description = project.description.clone();
-    let extra = project_extra(directory, git_type, description, remote.as_ref());
+    let extra = project_extra(directory, git_type, description, remote.as_ref(), mirror.as_deref());
     let entry = ProjectEntry {
         id,
         name: req.name,
@@ -464,6 +2373,302 @@ fn finish_import(
     Ok(entry)
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtendProjectRemoteRequest {
+    pub project_id: String,
+    /// The remote spec to attach. `remote_path` already includes the project
+    /// name leaf (the frontend appends it, matching direct remote creation).
+    pub remote: RemoteSpec,
+}
+
+/// Extend an existing **local** project to remote: attach a `RemoteSpec`, create
+/// the empty remote root on the host (best-effort, exactly like `create_project`),
+/// and re-point the project into the mount-free remote layout **without uploading
+/// any data**. The project keeps its id; its current local directory becomes the
+/// local `mirror` (working copy) in place — files never move — and its `directory`
+/// becomes a local state dir holding `project.json`. The user pushes files to the
+/// (empty) host later via the existing manual sync UI.
+#[tauri::command]
+pub async fn extend_project_to_remote(
+    req: ExtendProjectRemoteRequest,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<ProjectEntry, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        return Err("Project not found".to_string());
+    };
+
+    let idx = list
+        .iter()
+        .position(|p| p.id == req.project_id)
+        .ok_or_else(|| "Project not found".to_string())?;
+
+    // Guard: only local projects can be extended.
+    if list[idx].extra.contains_key("remote") {
+        return Err("Project is already remote".to_string());
+    }
+
+    // The current local tree becomes the mirror (working copy), unchanged.
+    let old_dir = list[idx]
+        .extra
+        .get("directory")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+        .ok_or_else(|| "Project has no local directory".to_string())?;
+
+    // Whether this project carries git — only then is lockstep meaningful. `none`
+    // (or a missing tag) means no repo to keep in step, so we leave lockstep off.
+    let git_backed = list[idx]
+        .extra
+        .get("git_type")
+        .and_then(Value::as_str)
+        .map(|t| t != "none")
+        .unwrap_or(false);
+    let old_path = PathBuf::from(&old_dir);
+    if !old_path.is_dir() {
+        return Err(format!("Local directory '{old_dir}' does not exist"));
+    }
+
+    // Best-effort create the empty remote root — same as create_project. Failure
+    // is non-fatal (key/agent-auth hosts may need it to pre-exist; a password-auth
+    // host connects and creates it at activation).
+    if let Err(e) = crate::services::ssh_exec::remote_mkdir_p(&req.remote) {
+        eprintln!(
+            "extend_project_to_remote: remote mkdir '{}' failed (create it on the host if needed): {e}",
+            req.remote.remote_path
+        );
+    }
+
+    // The remote project's `directory` is a local state dir holding project.json.
+    let state_dir = remote_project_state_dir(&req.project_id);
+    std::fs::create_dir_all(&state_dir).map_err(|e| e.to_string())?;
+    let new_directory = state_dir.to_string_lossy().to_string();
+
+    // This project may have been remote before (detached, and now pointed at a different
+    // host — the ordinary way to correct a wrong path). The state dir is keyed by id, so
+    // any host-bound state from that earlier life is sitting right here. Clear it before
+    // we write the new pairing: a manifest describing the OLD host makes byte-sync refuse
+    // to push to the new one while the file tree reports green. Detach clears it too; this
+    // is the belt-and-braces that also rescues a project detached by an older build, which
+    // could not clear it (`remove_dir` cannot empty a non-empty directory).
+    clear_host_bound_state(&req.project_id, manifest.inner()).await;
+
+    // Move project.json from the old (now mirror) tree into the state dir, tagging
+    // it remote. Read the existing one so tabs/time/created_at/etc. survive.
+    let old_project_file = old_path.join("project.json");
+    let mut project: Project = if old_project_file.exists() {
+        storage::read_json(&old_project_file).unwrap_or_default()
+    } else {
+        Project::default()
+    };
+    project.id = req.project_id.clone();
+    project.name = list[idx].name.clone();
+    project.directory = new_directory.clone();
+    project.remote = Some(req.remote.clone());
+    project.mirror = Some(old_dir.clone());
+    let new_project_file = state_dir.join("project.json");
+    storage::write_json(&new_project_file, &project).map_err(|e| e.to_string())?;
+
+    // Update the same projects.json entry in place, preserving every other extra
+    // key (categories, git_provider, git_type, description, sandbox, …).
+    let entry = &mut list[idx];
+    entry.local_file = new_project_file.to_string_lossy().to_string();
+    entry
+        .extra
+        .insert("directory".to_string(), Value::String(new_directory));
+    if let Ok(value) = serde_json::to_value(&req.remote) {
+        entry.extra.insert("remote".to_string(), value);
+    }
+    entry
+        .extra
+        .insert("mirror".to_string(), Value::String(old_dir));
+    let updated = entry.clone();
+    // Persist the `mirror` pointer to projects.json BEFORE removing the old
+    // project.json. If this crashes mid-way, the worst case is a harmless leftover
+    // project.json in the mirror — never a lost `mirror` pointer (which would make
+    // `mirror_dir` fall back to an empty state dir and desync the lockstep view).
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    // Extend is an explicit "keep these two in step" action, and at this instant the
+    // remote root was just created empty — so the first lockstep sync can only be a
+    // one-directional seed (never a divergence). Enable lockstep by default for a
+    // git-backed project so the pairing stays live without the user hunting for the
+    // toggle; a non-git project has nothing to sync, so it stays off. Best-effort:
+    // a write failure just leaves lockstep off (its default), never blocks extend.
+    if git_backed {
+        // A project scaffolded before initial-commit support (`git init` only) has
+        // an unborn HEAD: nothing is committed, so lockstep's `init_pairing` would
+        // find no tree to check out and leave the remote empty. Seed a commit of the
+        // current mirror tree now (identity-safe, gitignore-honouring) so pairing has
+        // committed state to transfer. Repos that already have history are untouched.
+        if git_head_unborn(&old_path) {
+            git_scaffold_commit(&old_path);
+        }
+        let state = crate::services::git_peer::GitPeerState {
+            enabled: true,
+            ..Default::default()
+        };
+        if let Err(e) = crate::services::git_peer::save_state(&req.project_id, &state) {
+            eprintln!(
+                "extend_project_to_remote: could not enable lockstep for '{}' \
+                 (leaving it off; user can toggle it on): {e}",
+                req.project_id
+            );
+        }
+    }
+
+    // Now that the remote wiring is durably recorded, drop the stale project.json
+    // from the working copy so the mirror is clean. Best-effort (a leftover is
+    // harmless — the state-dir copy is the source of truth).
+    let _ = std::fs::remove_file(&old_project_file);
+    Ok(updated)
+}
+
+/// Detach a **remote** (SSH) project back to a plain local project — the inverse
+/// of `extend_project_to_remote`. The project's local mirror (working copy)
+/// becomes its `directory` in place; `project.json` moves from the state dir back
+/// into that tree; the `remote`/`mirror` extras are dropped. **The remote host's
+/// files are never touched** — only the local pointers change. The project keeps
+/// its id, tabs, time, categories, git metadata, etc.
+///
+/// Errors if the project isn't remote, or has no local mirror to fall back to.
+#[tauri::command]
+pub async fn detach_project_from_remote(
+    project_id: String,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<ProjectEntry, String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        return Err("Project not found".to_string());
+    };
+
+    let idx = list
+        .iter()
+        .position(|p| p.id == project_id)
+        .ok_or_else(|| "Project not found".to_string())?;
+
+    // Guard: only remote projects can be detached.
+    if !list[idx].extra.contains_key("remote") {
+        return Err("Project is not remote".to_string());
+    }
+
+    // The local mirror (working copy) becomes the project directory again.
+    let mirror = list[idx]
+        .extra
+        .get("mirror")
+        .and_then(Value::as_str)
+        .map(str::to_string)
+        .ok_or_else(|| "Remote project has no local mirror to detach to".to_string())?;
+    let mirror_path = PathBuf::from(&mirror);
+    if !mirror_path.is_dir() {
+        return Err(format!("Local mirror '{mirror}' does not exist"));
+    }
+
+    // Move project.json from the state dir back into the (now local) tree,
+    // dropping the remote/mirror fields. Read the existing one so tabs/time/
+    // created_at/etc. survive.
+    let state_local_file = list[idx].local_file.clone();
+    let mut project: Project = if PathBuf::from(&state_local_file).exists() {
+        storage::read_json(&PathBuf::from(&state_local_file)).unwrap_or_default()
+    } else {
+        Project::default()
+    };
+    project.id = project_id.clone();
+    project.name = list[idx].name.clone();
+    project.directory = mirror.clone();
+    project.remote = None;
+    project.mirror = None;
+
+    // Re-point the carried tabs at the mirror. While the project was remote its
+    // `directory` WAS the state dir, so that is what every tab holds as its cwd —
+    // harmless then (the frontend rewrote it at render time, gated on the project
+    // being remote), a dangling path the moment it isn't. Left alone, a restored
+    // agent relaunches inside the state dir this detach is about to delete, and
+    // Claude — which keys its session history by cwd — finds no conversation to
+    // `--resume`. The frontend fixes the LIVE tabs (`detachScopeFromRemote`); this
+    // fixes the ones on disk, which is what a restart restores from.
+    let state_dir = remote_project_state_dir(&project_id);
+    let state_dir_s = state_dir.to_string_lossy().to_string();
+    if let Some(tabs) = project.tab_layout.as_mut() {
+        for tab in tabs.iter_mut() {
+            if tab.cwd == state_dir_s {
+                tab.cwd = mirror.clone();
+            } else if let Some(rest) = tab.cwd.strip_prefix(&format!("{state_dir_s}/")) {
+                tab.cwd = format!("{mirror}/{rest}");
+            }
+        }
+    }
+
+    let new_project_file = mirror_path.join("project.json");
+    storage::write_json(&new_project_file, &project).map_err(|e| e.to_string())?;
+
+    // The tabs are in project.json now — but that is not where they are READ from.
+    // `load_terminal_session` prefers `.eldrun/sessions/terminals.json` and only falls
+    // back to project.json, and the mirror has its OWN session file, left over from
+    // before this project was ever extended to a host. Preserving `tab_layout` while
+    // that stale file still sits there restores the pre-extend tabs and silently drops
+    // everything the project gained while it was remote. Rewrite it from what we carried
+    // (or drop it, when the project genuinely ended up with no tabs — project.json is the
+    // record, and a leftover session file must not resurrect tabs from before the extend).
+    let new_local_file = new_project_file.to_string_lossy().to_string();
+    match project.tab_layout.as_deref() {
+        Some(tabs) if !tabs.is_empty() => {
+            let _ = crate::services::terminal_service::save_tab_layout(
+                &new_local_file,
+                tabs,
+                project.tab_groups.clone(),
+                None,
+                false,
+            );
+        }
+        _ => {
+            if let Some(dir) = crate::services::terminal_service::eldrun_sessions_dir(&new_local_file)
+            {
+                let _ = std::fs::remove_file(dir.join("terminals.json"));
+            }
+        }
+    }
+
+    // Drop everything that was bound to the host we are detaching from. Not merely
+    // hygiene: the project keeps its id, so a later "extend to remote" — the whole point
+    // of detaching, when the old path was wrong — lands on this same state dir and would
+    // otherwise inherit a byte-sync manifest whose bases describe the OLD host. See
+    // `clear_host_bound_state` for what that silently does to the new one.
+    clear_host_bound_state(&project_id, manifest.inner()).await;
+
+    // Remove the old state-dir project.json, its session mirror, and then the state dir.
+    // `.eldrun/` is why the dir used to survive every detach: `remove_dir` is
+    // non-recursive, so it failed on a dir that still held the session mirror, and the
+    // project's id was left lying around under `remote-projects/` forever.
+    //
+    // The final `remove_dir` stays non-recursive ON PURPOSE — `local_loss.json`
+    // deliberately outlives a detach (it records what was destroyed in the *local*
+    // mirror, and the user may not have seen it yet). A dir that still holds it must
+    // survive; `remove_dir` succeeds only once the dir is genuinely empty, which is
+    // exactly that distinction.
+    let _ = std::fs::remove_file(&state_local_file);
+    let _ = std::fs::remove_dir_all(state_dir.join(".eldrun"));
+    let _ = std::fs::remove_dir(&state_dir);
+
+    // Update the projects.json entry in place, preserving every other extra key
+    // (categories, git_provider, git_type, description, sandbox, …).
+    let entry = &mut list[idx];
+    entry.local_file = new_project_file.to_string_lossy().to_string();
+    entry
+        .extra
+        .insert("directory".to_string(), Value::String(mirror));
+    entry.extra.remove("remote");
+    entry.extra.remove("mirror");
+    let updated = entry.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+    Ok(updated)
+}
+
 // ── Time tracking ─────────────────────────────────────────────────────────
 
 #[tauri::command]
@@ -484,6 +2689,7 @@ fn project_extra(
     git_type: String,
     description: Option<String>,
     remote: Option<&RemoteSpec>,
+    mirror: Option<&str>,
 ) -> HashMap<String, Value> {
     let mut extra = HashMap::from([
         ("directory".to_string(), Value::String(directory)),
@@ -500,6 +2706,11 @@ fn project_extra(
             extra.insert("remote".to_string(), value);
         }
     }
+    // The chosen local mirror root (remote projects only) — the always-local
+    // source of truth `remote_sync::mirror_dir` reads.
+    if let Some(mirror) = mirror {
+        extra.insert("mirror".to_string(), Value::String(mirror.to_string()));
+    }
     extra
 }
 
@@ -643,6 +2854,7 @@ mod tests {
     #[test]
     fn normalize_git_type_passes_through_canonical_values() {
         assert_eq!(normalize_git_type("local"), "local");
+        assert_eq!(normalize_git_type("none"), "none");
         assert_eq!(normalize_git_type("remote-private"), "remote-private");
         assert_eq!(normalize_git_type("remote-public"), "remote-public");
     }
@@ -654,12 +2866,64 @@ mod tests {
         assert_eq!(normalize_git_type("  public  "), "remote-public");
     }
 
+    // ── normalize_entry ────────────────────────────────────────────────────
+
+    fn legacy_entry() -> ProjectEntry {
+        // A pre-Group-D stub like the real ProjectEldrun entry: core fields only,
+        // no `directory`, no `git_type`.
+        ProjectEntry {
+            id: "legacy-id".to_string(),
+            name: "ProjectEldrun".to_string(),
+            status: "active".to_string(),
+            position: 10,
+            local_file: "/home/u/eldrun/projects/projecteldrun/project.json".to_string(),
+            extra: HashMap::new(),
+        }
+    }
+
+    #[test]
+    fn normalize_entry_backfills_directory_from_local_file() {
+        let mut entry = legacy_entry();
+        normalize_entry(&mut entry);
+        assert_eq!(
+            entry.extra.get("directory").and_then(Value::as_str),
+            Some("/home/u/eldrun/projects/projecteldrun"),
+        );
+    }
+
+    #[test]
+    fn normalize_entry_keeps_existing_directory() {
+        let mut entry = legacy_entry();
+        entry.extra.insert(
+            "directory".to_string(),
+            Value::String("/custom/dir".to_string()),
+        );
+        normalize_entry(&mut entry);
+        assert_eq!(
+            entry.extra.get("directory").and_then(Value::as_str),
+            Some("/custom/dir"),
+        );
+    }
+
+    #[test]
+    fn normalize_entry_canonicalizes_legacy_git_type() {
+        let mut entry = legacy_entry();
+        entry
+            .extra
+            .insert("git_type".to_string(), Value::String("public".to_string()));
+        normalize_entry(&mut entry);
+        assert_eq!(
+            entry.extra.get("git_type").and_then(Value::as_str),
+            Some("remote-public"),
+        );
+    }
+
     // ── scaffold_project ───────────────────────────────────────────────────
 
     #[test]
     fn scaffold_project_creates_all_files() {
         let tmp = tempfile::tempdir().unwrap();
-        scaffold_project(tmp.path()).unwrap();
+        scaffold_project(tmp.path(), true).unwrap();
 
         for name in &[
             "AGENTS.md",
@@ -676,13 +2940,25 @@ mod tests {
         assert!(tmp.path().join(".claude/settings.json").exists());
     }
 
+    #[test]
+    fn scaffold_project_gitignores_project_json() {
+        let tmp = tempfile::tempdir().unwrap();
+        scaffold_project(tmp.path(), true).unwrap();
+
+        let content = std::fs::read_to_string(tmp.path().join(".gitignore")).unwrap();
+        assert!(
+            content.lines().any(|l| l == "project.json"),
+            "default .gitignore must exclude project.json"
+        );
+    }
+
     #[test]
     fn scaffold_project_does_not_overwrite_existing_files() {
         let tmp = tempfile::tempdir().unwrap();
         let todo_path = tmp.path().join("TODO.md");
         std::fs::write(&todo_path, "original content").unwrap();
 
-        scaffold_project(tmp.path()).unwrap();
+        scaffold_project(tmp.path(), true).unwrap();
 
         let content = std::fs::read_to_string(&todo_path).unwrap();
         assert_eq!(
@@ -698,7 +2974,7 @@ mod tests {
         let cs = tmp.path().join(".claude/settings.json");
         std::fs::write(&cs, r#"{"custom": true}"#).unwrap();
 
-        scaffold_project(tmp.path()).unwrap();
+        scaffold_project(tmp.path(), true).unwrap();
 
         let content = std::fs::read_to_string(&cs).unwrap();
         assert!(
@@ -710,9 +2986,62 @@ mod tests {
     #[test]
     fn scaffold_project_idempotent() {
         let tmp = tempfile::tempdir().unwrap();
-        scaffold_project(tmp.path()).unwrap();
-        scaffold_project(tmp.path()).unwrap(); // second call must not error
+        scaffold_project(tmp.path(), true).unwrap();
+        scaffold_project(tmp.path(), true).unwrap(); // second call must not error
+        assert!(tmp.path().join("TODO.md").exists());
+    }
+
+    #[test]
+    fn scaffold_project_commits_scaffold_files() {
+        let tmp = tempfile::tempdir().unwrap();
+        scaffold_project(tmp.path(), true).unwrap();
+
+        // A commit exists (HEAD is born) so lockstep pairing has a tree to check out.
+        let head = crate::paths::command_no_window("git")
+            .args(["rev-parse", "--verify", "HEAD"])
+            .current_dir(tmp.path())
+            .output()
+            .unwrap();
+        assert!(head.status.success(), "scaffold must create an initial commit");
+
+        // The .claude settings and docs are TRACKED, not just present on disk — that
+        // is what lets `extend` seed them onto the remote via the lockstep bundle.
+        for path in &[".claude/settings.json", "CLAUDE.md", ".gitignore"] {
+            let tracked = crate::paths::command_no_window("git")
+                .args(["ls-files", "--error-unmatch", path])
+                .current_dir(tmp.path())
+                .output()
+                .unwrap();
+            assert!(tracked.status.success(), "{path} must be tracked by git");
+        }
+        assert!(!git_head_unborn(tmp.path()), "HEAD must be born after scaffold");
+    }
+
+    #[test]
+    fn scaffold_project_without_git_skips_init() {
+        let tmp = tempfile::tempdir().unwrap();
+        scaffold_project(tmp.path(), false).unwrap();
+        // Scaffold files are still written, but no git repo is initialized.
+        assert!(tmp.path().join("TODO.md").exists());
+        assert!(tmp.path().join(".claude/settings.json").exists());
+        assert!(
+            !tmp.path().join(".git").exists(),
+            "git must not be initialized when with_git is false"
+        );
+    }
+
+    #[test]
+    fn scaffold_project_without_git_skips_gitignore() {
+        let tmp = tempfile::tempdir().unwrap();
+        scaffold_project(tmp.path(), false).unwrap();
+        // No git → no `.gitignore` (it's a git-axis artifact), but the docs and
+        // .claude settings are still written.
+        assert!(
+            !tmp.path().join(".gitignore").exists(),
+            ".gitignore must not be written for a no-git project"
+        );
         assert!(tmp.path().join("TODO.md").exists());
+        assert!(tmp.path().join(".claude/settings.json").exists());
     }
 
     #[test]
@@ -735,4 +3064,74 @@ mod tests {
         assert_eq!(present.kind, "directory");
     }
 
+    // ── repair_project_scaffold_at ─────────────────────────────────────────
+
+    #[test]
+    fn repair_fills_missing_scaffold_docs_and_settings() {
+        let tmp = tempfile::tempdir().unwrap();
+        // Simulate a project scaffolded before DOCUMENTATION.md / .claude
+        // settings existed: only a couple of the current scaffold files.
+        std::fs::write(tmp.path().join("TODO.md"), "# TODO\n").unwrap();
+        std::fs::write(tmp.path().join(".gitignore"), "node_modules/\n").unwrap();
+
+        let report = repair_project_scaffold_at(tmp.path(), false).unwrap();
+
+        assert!(report.created_files.contains(&"AGENTS.md".to_string()));
+        assert!(report.created_files.contains(&".claude/settings.json".to_string()));
+        assert!(!report.created_files.contains(&"TODO.md".to_string()));
+        assert!(tmp.path().join("DOCUMENTATION.md").exists());
+        assert!(tmp.path().join(".claude/settings.json").exists());
+    }
+
+    #[test]
+    fn repair_merges_missing_gitignore_lines_without_clobbering() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::write(tmp.path().join(".gitignore"), "# my custom rule\nfoo/\n").unwrap();
+
+        // `.gitignore` is a git-axis artifact, so the merge only runs for
+        // git-backed projects.
+        let report = repair_project_scaffold_at(tmp.path(), true).unwrap();
+
+        assert!(report.gitignore_lines_added.contains(&"project.json".to_string()));
+        let content = std::fs::read_to_string(tmp.path().join(".gitignore")).unwrap();
+        assert!(content.contains("# my custom rule"));
+        assert!(content.contains("foo/"));
+        assert!(content.lines().any(|l| l == "project.json"));
+    }
+
+    #[test]
+    fn repair_without_git_does_not_touch_gitignore() {
+        let tmp = tempfile::tempdir().unwrap();
+        // A no-git project missing `.gitignore` entirely.
+        let report = repair_project_scaffold_at(tmp.path(), false).unwrap();
+
+        assert!(
+            !tmp.path().join(".gitignore").exists(),
+            "no-git repair must not create a .gitignore"
+        );
+        assert!(report.gitignore_lines_added.is_empty());
+        // Docs/settings are still filled in as usual.
+        assert!(tmp.path().join("DOCUMENTATION.md").exists());
+        assert!(tmp.path().join(".claude/settings.json").exists());
+    }
+
+    #[test]
+    fn repair_is_a_noop_when_scaffold_is_already_current() {
+        let tmp = tempfile::tempdir().unwrap();
+        scaffold_project(tmp.path(), false).unwrap();
+
+        let report = repair_project_scaffold_at(tmp.path(), false).unwrap();
+
+        assert!(report.is_empty());
+    }
+
+    #[test]
+    fn repair_initializes_git_when_missing_and_requested() {
+        let tmp = tempfile::tempdir().unwrap();
+
+        let report = repair_project_scaffold_at(tmp.path(), true).unwrap();
+
+        assert!(report.git_initialized);
+        assert!(tmp.path().join(".git").is_dir());
+    }
 }
diff --git a/src-tauri/src/commands/python.rs b/src-tauri/src/commands/python.rs
new file mode 100644
index 0000000..d750913
--- /dev/null
+++ b/src-tauri/src/commands/python.rs
@@ -0,0 +1,668 @@
+//! Which Python runs the code viewer's Run/Debug buttons (#87).
+//!
+//! Naming the interpreter is the whole problem. Running a project's script with a
+//! bare `python3` when its dependencies live in a venv fails with
+//! `ModuleNotFoundError`, and that reads to the user as "Eldrun's Run button is
+//! broken" rather than "wrong interpreter" — so getting this right is what makes
+//! Run trustworthy at all.
+//!
+//! Two layers, in this order:
+//!
+//! 1. **The project's explicit choice** (`Project::python_interpreter`), set in the
+//!    pill's "Python interpreter…" dialog. Always wins, and once set costs nothing
+//!    to honour — no probing at all.
+//! 2. **Auto-detect**, which is what an unconfigured project gets. It probes the
+//!    environment managers people actually use, because a `.venv/` scan alone
+//!    silently mis-fires on every conda/Poetry project.
+//!
+//! Auto-detect deliberately only *auto-selects* an environment that is
+//! unambiguously this project's: an in-tree venv, this project's Poetry env, the
+//! shell's active `VIRTUAL_ENV`/`CONDA_PREFIX`, a pyenv version pinned by
+//! `.python-version`. Named conda envs are **listed** for the dialog but never
+//! auto-picked — choosing one of the user's N unrelated envs on their behalf would
+//! be a guess, and a wrong guess here is indistinguishable from a bug.
+//!
+//! A project can hold **more than one** venv (a top-level `.venv` plus a
+//! per-subproject one), so the in-tree scan walks the tree for `pyvenv.cfg`
+//! markers rather than checking only the root — the dialog lists them all, and the
+//! shallowest (a root `.venv`) is the one auto-detect prefers.
+//!
+//! Remote projects probe **the host**, over the pooled ControlMaster, with a single
+//! constant `sh` script (`run_remote_script`) — the interpreter that matters is the
+//! one on the machine the run tab will actually run on.
+
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+use crate::schema::project::Project;
+use crate::schema::projects::ProjectsList;
+use crate::storage;
+
+/// One interpreter the user could pick, as offered by the dialog.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct PyInterpreter {
+    /// Where it came from: `venv` | `poetry` | `conda` | `pyenv` | `active` | `system`.
+    /// Drives the dialog's grouping and the auto-select precedence below.
+    pub kind: String,
+    /// The command Run/Debug executes. Relative (`.venv/bin/python`) for an in-tree
+    /// venv — the run tab's cwd is the project root — absolute otherwise.
+    pub path: String,
+    /// Human label for the dropdown, e.g. `conda: ml-env`.
+    pub label: String,
+}
+
+/// Precedence for auto-detect. Lower sorts first, and the first entry wins.
+/// A `conda` (named, not active) env never auto-wins — see the module note.
+fn auto_rank(kind: &str) -> u8 {
+    match kind {
+        "venv" => 0,    // in the project tree: unambiguous
+        "poetry" => 1,  // this project's env, per poetry itself
+        "active" => 2,  // the shell Eldrun was launched from
+        "pyenv" => 3,   // usually pinned by an in-tree .python-version
+        "system" => 5,
+        _ => 4, // "conda" (named): offered, never auto-selected
+    }
+}
+
+/// True when auto-detect may select this kind on its own.
+fn auto_selectable(kind: &str) -> bool {
+    matches!(kind, "venv" | "poetry" | "active" | "pyenv" | "system")
+}
+
+const WINDOWS: bool = cfg!(windows);
+
+fn default_interpreter() -> String {
+    if WINDOWS { "python".into() } else { "python3".into() }
+}
+
+/// The venv directory names we look for in the project root, in preference order.
+const VENV_DIRS: [&str; 3] = [".venv", "venv", "env"];
+
+/// How deep the tree scan hunts for venvs below the project root. A project may
+/// carry more than one (a top-level `.venv` plus a per-subproject one), so a
+/// root-only scan misses the rest; the cap keeps a deep tree from being walked in
+/// full for one dialog.
+const VENV_SCAN_MAX_DEPTH: usize = 4;
+
+/// Directory names never descended into while hunting for venvs: heavy or
+/// irrelevant subtrees (a venv's own `pyvenv.cfg` sits at its root, so we never
+/// need to walk *into* one, and `node_modules`/`.git` never hold a project venv).
+fn prunes_venv_scan(name: &str) -> bool {
+    matches!(
+        name,
+        ".git"
+            | "node_modules"
+            | "__pycache__"
+            | ".mypy_cache"
+            | ".pytest_cache"
+            | ".ruff_cache"
+            | ".tox"
+            | ".idea"
+            | ".vscode"
+            | "site-packages"
+    )
+}
+
+/// The interpreter inside a venv root, relative to it.
+fn venv_python_rel() -> &'static str {
+    if WINDOWS { "Scripts\\python.exe" } else { "bin/python" }
+}
+
+/// True when `dir` is a venv root: it carries a `pyvenv.cfg` (PEP 405, the
+/// canonical marker every `python -m venv`/`virtualenv` writes) *and* the
+/// interpreter. Requiring the marker is what keeps the recursive scan from
+/// mistaking a stray `env/bin/python` for an environment.
+fn is_venv_root(dir: &Path) -> bool {
+    dir.join("pyvenv.cfg").is_file() && dir.join(venv_python_rel()).is_file()
+}
+
+/// The label for a discovered in-tree venv: leads with its path relative to the
+/// project root, so two venvs in one project are told apart (`.venv` vs
+/// `services/api/.venv`).
+fn venv_label(rel: &Path) -> String {
+    format!("{} (in this project)", rel.to_string_lossy())
+}
+
+/// Every venv *anywhere* under the project root (bounded by `VENV_SCAN_MAX_DEPTH`),
+/// each as a project-relative interpreter path — the run tab's cwd is the project
+/// root, so a relative path keeps working when the project moves. A venv is never
+/// descended into (its `pyvenv.cfg` is at its root), and heavy dirs are pruned.
+/// Sorted shallowest-first so a top-level `.venv` sorts ahead of a nested one and
+/// wins auto-select.
+fn find_venvs(root: &Path) -> Vec<PyInterpreter> {
+    let mut roots: Vec<PathBuf> = Vec::new();
+    let mut stack: Vec<(PathBuf, usize)> = vec![(root.to_path_buf(), 0)];
+    while let Some((dir, depth)) = stack.pop() {
+        let Ok(entries) = std::fs::read_dir(&dir) else {
+            continue;
+        };
+        for child in entries.flatten().map(|e| e.path()).filter(|p| p.is_dir()) {
+            if is_venv_root(&child) {
+                roots.push(child); // a venv root — record it, don't walk into it
+                continue;
+            }
+            let name = child.file_name().and_then(|s| s.to_str()).unwrap_or("");
+            if depth < VENV_SCAN_MAX_DEPTH && !prunes_venv_scan(name) {
+                stack.push((child, depth + 1));
+            }
+        }
+    }
+    // Shallowest first, then lexicographic — a stable, sensible dropdown order that
+    // also puts the top-level venv (the auto-detect winner) ahead of nested ones.
+    roots.sort_by(|a, b| {
+        a.components()
+            .count()
+            .cmp(&b.components().count())
+            .then_with(|| a.cmp(b))
+    });
+    roots
+        .into_iter()
+        .filter_map(|d| {
+            let rel = d.strip_prefix(root).ok()?.to_path_buf();
+            Some(PyInterpreter {
+                kind: "venv".into(),
+                path: rel.join(venv_python_rel()).to_string_lossy().into_owned(),
+                label: venv_label(&rel),
+            })
+        })
+        .collect()
+}
+
+// ── Local discovery ──────────────────────────────────────────────────────────
+
+/// Run a helper program and return its trimmed stdout, or None if it isn't
+/// installed / failed. Every probe here is *optional* by design: a machine with no
+/// conda must not make interpreter discovery fail, it must simply offer no conda.
+fn probe(dir: &Path, program: &str, args: &[&str]) -> Option<String> {
+    let out = crate::paths::command_no_window(program)
+        .args(args)
+        .current_dir(dir)
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    let s = String::from_utf8_lossy(&out.stdout).trim().to_string();
+    if s.is_empty() { None } else { Some(s) }
+}
+
+/// Interpreters visible from a LOCAL project directory.
+///
+/// Done natively rather than by shelling out a script because it must also work on
+/// Windows, where there is no `sh` and the interpreter sits at `Scripts\python.exe`.
+pub fn discover_local(dir: &Path) -> Vec<PyInterpreter> {
+    let mut out: Vec<PyInterpreter> = Vec::new();
+
+    // 1. venvs in the project tree — ALL of them, not just the root's, since a
+    //    project can carry several. `find_venvs` walks the tree for `pyvenv.cfg`
+    //    markers; the classic root names catch a venv that predates the marker.
+    out.extend(find_venvs(dir));
+    for name in VENV_DIRS {
+        let py = dir.join(name).join(venv_python_rel());
+        if py.is_file() {
+            out.push(PyInterpreter {
+                kind: "venv".into(),
+                // Relative: the run tab's cwd IS the project root, and a relative
+                // path keeps working if the project is moved. Native separators —
+                // `cmd.exe` will not exec `.venv/Scripts/python.exe`.
+                path: PathBuf::from(name)
+                    .join(venv_python_rel())
+                    .to_string_lossy()
+                    .into_owned(),
+                label: format!("{name} (in this project)"),
+            });
+        }
+    }
+
+    // 2. Poetry — the env lives outside the tree, so nothing else can find it.
+    if let Some(p) = probe(dir, "poetry", &["env", "info", "-p"]) {
+        let py = PathBuf::from(&p).join(venv_python_rel());
+        if py.is_file() {
+            out.push(PyInterpreter {
+                kind: "poetry".into(),
+                path: py.to_string_lossy().into_owned(),
+                label: format!("poetry ({})", basename_of(&p)),
+            });
+        }
+    }
+
+    // 3. The environment Eldrun itself was launched inside.
+    for (var, kind) in [("VIRTUAL_ENV", "active"), ("CONDA_PREFIX", "active")] {
+        if let Ok(root) = std::env::var(var) {
+            if root.is_empty() {
+                continue;
+            }
+            let py = PathBuf::from(&root).join(venv_python_rel());
+            if py.is_file() {
+                out.push(PyInterpreter {
+                    kind: kind.into(),
+                    path: py.to_string_lossy().into_owned(),
+                    label: format!("active ${var} ({})", basename_of(&root)),
+                });
+            }
+        }
+    }
+
+    // 4. Named conda envs — offered, never auto-picked.
+    if let Some(list) = probe(dir, "conda", &["env", "list"]) {
+        for env in parse_conda_envs(&list) {
+            let py = PathBuf::from(&env.1).join(venv_python_rel());
+            if py.is_file() {
+                out.push(PyInterpreter {
+                    kind: "conda".into(),
+                    path: py.to_string_lossy().into_owned(),
+                    label: format!("conda: {}", env.0),
+                });
+            }
+        }
+    }
+
+    // 5. pyenv — honours an in-tree `.python-version`, since we probe from `dir`.
+    if let Some(p) = probe(dir, "pyenv", &["which", "python"]) {
+        if Path::new(&p).is_file() {
+            out.push(PyInterpreter {
+                kind: "pyenv".into(),
+                path: p.clone(),
+                label: format!("pyenv ({})", basename_of(&p)),
+            });
+        }
+    }
+
+    // 6. The system interpreter — always last, always present as a fallback.
+    out.push(PyInterpreter {
+        kind: "system".into(),
+        path: default_interpreter(),
+        label: format!("system ({})", default_interpreter()),
+    });
+
+    dedupe_and_rank(out)
+}
+
+/// `conda env list` → `(name, prefix)` pairs. Its output is columns with a `*`
+/// marking the active env:
+/// ```text
+/// # conda environments:
+/// #
+/// base                  *  /home/u/miniconda3
+/// ml-env                   /home/u/miniconda3/envs/ml-env
+/// ```
+pub fn parse_conda_envs(stdout: &str) -> Vec<(String, String)> {
+    let mut out = Vec::new();
+    for line in stdout.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let fields: Vec<&str> = line.split_whitespace().collect();
+        // Name first, prefix last; the optional `*` sits between them.
+        if fields.len() < 2 {
+            continue;
+        }
+        let name = fields[0];
+        let prefix = fields[fields.len() - 1];
+        if name == "*" || !prefix.starts_with('/') && !prefix.contains(":\\") {
+            continue;
+        }
+        out.push((name.to_string(), prefix.to_string()));
+    }
+    out
+}
+
+fn basename_of(p: &str) -> String {
+    p.rsplit(['/', '\\']).next().unwrap_or(p).to_string()
+}
+
+/// Drop duplicate interpreter paths (a poetry env can also be the active one) and
+/// order by auto-detect precedence, so `first()` IS the auto-detected choice.
+fn dedupe_and_rank(mut list: Vec<PyInterpreter>) -> Vec<PyInterpreter> {
+    list.sort_by_key(|i| auto_rank(&i.kind));
+    let mut seen = std::collections::HashSet::new();
+    list.retain(|i| seen.insert(i.path.clone()));
+    list
+}
+
+// ── Remote discovery ─────────────────────────────────────────────────────────
+
+/// The host-side probe. A **constant** POSIX-`sh` script (the `run_remote_script`
+/// contract: nothing may be interpolated into it), run with the project's remote
+/// dir as cwd so `poetry`/`pyenv` resolve *this* project's environment. Emits one
+/// `kind\tpath\tlabel` line per interpreter — collapsing what would otherwise be
+/// six SSH round trips into one.
+const REMOTE_PROBE: &str = r#"
+emit() { printf '%s\t%s\t%s\n' "$1" "$2" "$3"; }
+for d in .venv venv env; do
+  [ -x "$d/bin/python" ] && emit venv "$d/bin/python" "$d (in this project)"
+done
+find . -maxdepth 4 \( -name node_modules -o -name .git -o -name site-packages \) -prune \
+  -o -name pyvenv.cfg -type f -print 2>/dev/null | while read -r cfg; do
+  d=${cfg%/pyvenv.cfg}; d=${d#./}
+  [ -x "$d/bin/python" ] && emit venv "$d/bin/python" "$d (in this project)"
+done
+if command -v poetry >/dev/null 2>&1; then
+  p=$(poetry env info -p 2>/dev/null)
+  [ -n "$p" ] && [ -x "$p/bin/python" ] && emit poetry "$p/bin/python" "poetry ($(basename "$p"))"
+fi
+[ -n "$VIRTUAL_ENV" ] && [ -x "$VIRTUAL_ENV/bin/python" ] && \
+  emit active "$VIRTUAL_ENV/bin/python" "active \$VIRTUAL_ENV ($(basename "$VIRTUAL_ENV"))"
+[ -n "$CONDA_PREFIX" ] && [ -x "$CONDA_PREFIX/bin/python" ] && \
+  emit active "$CONDA_PREFIX/bin/python" "active \$CONDA_PREFIX ($(basename "$CONDA_PREFIX"))"
+if command -v conda >/dev/null 2>&1; then
+  conda env list 2>/dev/null | awk '!/^#/ && NF >= 2 { print $1, $NF }' | while read -r n p; do
+    [ -x "$p/bin/python" ] && emit conda "$p/bin/python" "conda: $n"
+  done
+fi
+if command -v pyenv >/dev/null 2>&1; then
+  p=$(pyenv which python 2>/dev/null)
+  [ -n "$p" ] && [ -x "$p" ] && emit pyenv "$p" "pyenv ($(basename "$p"))"
+fi
+p=$(command -v python3 || command -v python)
+[ -n "$p" ] && emit system "$p" "system ($p)"
+exit 0
+"#;
+
+/// Parse the `kind\tpath\tlabel` lines the remote probe emits.
+pub fn parse_remote_probe(stdout: &str) -> Vec<PyInterpreter> {
+    let mut out = Vec::new();
+    for line in stdout.lines() {
+        let mut f = line.splitn(3, '\t');
+        let (Some(kind), Some(path), Some(label)) = (f.next(), f.next(), f.next()) else {
+            continue;
+        };
+        if kind.is_empty() || path.is_empty() {
+            continue;
+        }
+        out.push(PyInterpreter {
+            kind: kind.to_string(),
+            path: path.to_string(),
+            label: label.to_string(),
+        });
+    }
+    dedupe_and_rank(out)
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+//
+// A remote probe shells out over the pooled SSH ControlMaster, which can stall up
+// to its ConnectTimeout/ServerAlive window on a dead/degraded host. Tauri runs a
+// synchronous `#[command]` on the MAIN thread, so doing that inline froze the
+// whole window — the same bug `commands::git` already fixed (see its
+// `run_off_thread` doc comment) but that fix never reached this file. The two
+// remote-capable commands are now `async` wrappers that offload their blocking
+// body via `spawn_blocking`; the local-only `discover_local`/`project_python`
+// paths stay plain sync fns underneath, so they remain directly unit-testable.
+
+async fn run_off_thread<T: Send + 'static>(
+    f: impl FnOnce() -> Result<T, String> + Send + 'static,
+) -> Result<T, String> {
+    tokio::task::spawn_blocking(f)
+        .await
+        .map_err(|e| format!("python task failed: {e}"))?
+}
+
+/// Every interpreter offered for `project_dir` — the dialog's dropdown. Probes the
+/// **host** for a remote project (that is where its run tab will run).
+fn python_interpreters_blocking(project_dir: &str) -> Result<Vec<PyInterpreter>, String> {
+    if let Some(target) = crate::services::remote::remote_target_for_dir(project_dir) {
+        let out = crate::services::ssh_exec::run_remote_script(&target.spec, REMOTE_PROBE)?;
+        return Ok(parse_remote_probe(&String::from_utf8_lossy(&out.stdout)));
+    }
+    Ok(discover_local(Path::new(project_dir)))
+}
+
+#[tauri::command]
+pub async fn python_interpreters(project_dir: String) -> Result<Vec<PyInterpreter>, String> {
+    run_off_thread(move || python_interpreters_blocking(&project_dir)).await
+}
+
+/// The interpreter Run/Debug should use *right now*: the project's explicit choice
+/// if it has one (no probing), else the best auto-detected candidate, else the
+/// system default. This is the only thing `lib/pythonRun.ts` needs to ask.
+#[tauri::command]
+pub async fn python_interpreter_for(
+    project_id: Option<String>,
+    project_dir: String,
+) -> Result<String, String> {
+    if let Some(pinned) = project_id.as_deref().and_then(project_python) {
+        return Ok(pinned);
+    }
+    run_off_thread(move || {
+        let found = python_interpreters_blocking(&project_dir).unwrap_or_default();
+        Ok(found
+            .into_iter()
+            .find(|i| auto_selectable(&i.kind))
+            .map(|i| i.path)
+            .unwrap_or_else(default_interpreter))
+    })
+    .await
+}
+
+/// A project's pinned interpreter, read from the always-local `projects.json`
+/// mirror (falling back to `project.json` for entries predating the mirror) — the
+/// same two-store read as the sandbox spec.
+fn project_python(project_id: &str) -> Option<String> {
+    let list_path = storage::state_dir().join("projects.json");
+    let list: ProjectsList = storage::read_json(&list_path).ok()?;
+    let entry = list.iter().find(|p| p.id == project_id)?;
+    entry
+        .extra
+        .get("python_interpreter")
+        .and_then(|v| v.as_str())
+        .map(str::to_string)
+        .or_else(|| {
+            storage::read_json::<Project>(&PathBuf::from(&entry.local_file))
+                .ok()?
+                .python_interpreter
+        })
+        .filter(|s| !s.trim().is_empty())
+}
+
+/// Pin (or clear, with `None`/blank) the project's interpreter. Written to both
+/// stores, like the sandbox spec: the `projects.json` mirror is what the run path
+/// reads, `project.json` keeps it with the project.
+#[tauri::command]
+pub fn set_project_python(
+    project_id: String,
+    interpreter: Option<String>,
+) -> Result<Option<String>, String> {
+    let value = interpreter
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty());
+
+    let list_path = storage::state_dir().join("projects.json");
+    let mut list: ProjectsList = if list_path.exists() {
+        storage::read_json(&list_path).map_err(|e| e.to_string())?
+    } else {
+        Vec::new()
+    };
+    let entry = list
+        .iter_mut()
+        .find(|p| p.id == project_id)
+        .ok_or_else(|| format!("project '{project_id}' not found"))?;
+
+    match &value {
+        Some(v) => {
+            entry
+                .extra
+                .insert("python_interpreter".into(), serde_json::Value::String(v.clone()));
+        }
+        None => {
+            entry.extra.remove("python_interpreter");
+        }
+    }
+    let local_file = entry.local_file.clone();
+    storage::write_json(&list_path, &list).map_err(|e| e.to_string())?;
+
+    let proj_path = PathBuf::from(&local_file);
+    if proj_path.exists() {
+        if let Ok(mut project) = storage::read_json::<Project>(&proj_path) {
+            project.python_interpreter = value.clone();
+            storage::write_json(&proj_path, &project).map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(value)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn conda_env_list_is_parsed_name_and_prefix() {
+        let out = "# conda environments:\n#\nbase                  *  /home/u/miniconda3\nml-env                   /home/u/miniconda3/envs/ml-env\n";
+        assert_eq!(
+            parse_conda_envs(out),
+            vec![
+                ("base".to_string(), "/home/u/miniconda3".to_string()),
+                (
+                    "ml-env".to_string(),
+                    "/home/u/miniconda3/envs/ml-env".to_string()
+                ),
+            ]
+        );
+    }
+
+    #[test]
+    fn conda_comments_and_short_lines_are_skipped() {
+        assert!(parse_conda_envs("# nothing\n\ngarbage\n").is_empty());
+    }
+
+    #[test]
+    fn remote_probe_lines_are_parsed() {
+        let out = "venv\t.venv/bin/python\t.venv (in this project)\nsystem\t/usr/bin/python3\tsystem (/usr/bin/python3)\n";
+        let got = parse_remote_probe(out);
+        assert_eq!(got.len(), 2);
+        assert_eq!(got[0].kind, "venv");
+        assert_eq!(got[0].path, ".venv/bin/python");
+        assert_eq!(got[1].kind, "system");
+    }
+
+    #[test]
+    fn malformed_probe_lines_are_dropped_not_fatal() {
+        assert!(parse_remote_probe("garbage\nalso\tgarbage\n").is_empty());
+    }
+
+    #[test]
+    fn ranking_puts_an_in_tree_venv_first_and_system_last() {
+        let list = parse_remote_probe(
+            "system\t/usr/bin/python3\tsystem\nconda\t/c/envs/x/bin/python\tconda: x\nvenv\t.venv/bin/python\t.venv\n",
+        );
+        assert_eq!(list[0].kind, "venv");
+        assert_eq!(list.last().unwrap().kind, "system");
+    }
+
+    #[test]
+    fn a_named_conda_env_is_offered_but_never_auto_selected() {
+        // The dialog lists it; auto-detect must not pick one of N unrelated envs.
+        assert!(!auto_selectable("conda"));
+        assert!(auto_selectable("venv"));
+        assert!(auto_selectable("poetry"));
+        assert!(auto_selectable("system"));
+    }
+
+    #[test]
+    fn duplicate_paths_collapse_to_the_higher_ranked_kind() {
+        // A poetry env that is ALSO the active VIRTUAL_ENV must appear once.
+        let list = parse_remote_probe(
+            "active\t/e/x/bin/python\tactive\npoetry\t/e/x/bin/python\tpoetry (x)\n",
+        );
+        assert_eq!(list.len(), 1);
+        assert_eq!(list[0].kind, "poetry"); // ranked above "active"
+    }
+
+    #[test]
+    fn local_discovery_finds_an_in_tree_venv_as_a_relative_path() {
+        let tmp = std::env::temp_dir().join(format!("eldrun-py-{}", std::process::id()));
+        let bin = tmp.join(".venv").join(if WINDOWS { "Scripts" } else { "bin" });
+        std::fs::create_dir_all(&bin).unwrap();
+        let py = bin.join(if WINDOWS { "python.exe" } else { "python" });
+        std::fs::write(&py, b"#!/bin/sh\n").unwrap();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            std::fs::set_permissions(&py, std::fs::Permissions::from_mode(0o755)).unwrap();
+        }
+
+        let found = discover_local(&tmp);
+        // Relative, because the run tab's cwd is the project root.
+        assert_eq!(found[0].kind, "venv");
+        let expected = PathBuf::from(".venv")
+            .join(venv_python_rel())
+            .to_string_lossy()
+            .into_owned();
+        assert_eq!(found[0].path, expected);
+        // The system interpreter is always offered as the last resort.
+        assert!(found.iter().any(|i| i.kind == "system"));
+
+        std::fs::remove_dir_all(&tmp).ok();
+    }
+
+    /// Build a fake venv (interpreter + `pyvenv.cfg`) at `root/rel`.
+    #[cfg(test)]
+    fn make_fake_venv(root: &Path, rel: &str) {
+        let venv = root.join(rel);
+        let bin = venv.join(if WINDOWS { "Scripts" } else { "bin" });
+        std::fs::create_dir_all(&bin).unwrap();
+        let py = bin.join(if WINDOWS { "python.exe" } else { "python" });
+        std::fs::write(&py, b"#!/bin/sh\n").unwrap();
+        std::fs::write(venv.join("pyvenv.cfg"), b"home = /usr\n").unwrap();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            std::fs::set_permissions(&py, std::fs::Permissions::from_mode(0o755)).unwrap();
+        }
+    }
+
+    #[test]
+    fn local_discovery_finds_every_venv_in_the_tree_not_only_the_root() {
+        let tmp = std::env::temp_dir().join(format!("eldrun-py-multi-{}", std::process::id()));
+        std::fs::create_dir_all(&tmp).unwrap();
+        make_fake_venv(&tmp, ".venv");
+        make_fake_venv(&tmp, "services/api/.venv");
+
+        let found = discover_local(&tmp);
+        let venvs: Vec<&str> = found
+            .iter()
+            .filter(|i| i.kind == "venv")
+            .map(|i| i.path.as_str())
+            .collect();
+        let root_py = PathBuf::from(".venv").join(venv_python_rel());
+        // Build from components, not a "services/api/.venv" literal: discovery emits
+        // the relative path with the OS separator (backslash on Windows), so a
+        // forward-slash literal would fail the string compare there.
+        let nested_py = PathBuf::from("services")
+            .join("api")
+            .join(".venv")
+            .join(venv_python_rel());
+        assert!(venvs.contains(&root_py.to_string_lossy().as_ref()), "root venv missing: {venvs:?}");
+        assert!(
+            venvs.contains(&nested_py.to_string_lossy().as_ref()),
+            "nested venv missing: {venvs:?}"
+        );
+        // The top-level venv sorts first, so it stays the auto-detect winner.
+        assert_eq!(found[0].path, root_py.to_string_lossy());
+
+        std::fs::remove_dir_all(&tmp).ok();
+    }
+
+    #[test]
+    fn venv_scan_prunes_heavy_dirs() {
+        // A venv buried inside node_modules is not the project's — don't offer it,
+        // and don't pay to walk that subtree.
+        let tmp = std::env::temp_dir().join(format!("eldrun-py-prune-{}", std::process::id()));
+        std::fs::create_dir_all(&tmp).unwrap();
+        make_fake_venv(&tmp, "node_modules/pkg/.venv");
+        let found = find_venvs(&tmp);
+        assert!(found.is_empty(), "should not descend into node_modules: {found:?}");
+        std::fs::remove_dir_all(&tmp).ok();
+    }
+
+    #[test]
+    fn local_discovery_with_no_venv_still_offers_the_system_interpreter() {
+        let tmp = std::env::temp_dir().join(format!("eldrun-py-none-{}", std::process::id()));
+        std::fs::create_dir_all(&tmp).unwrap();
+        let found = discover_local(&tmp);
+        assert!(found.iter().any(|i| i.kind == "system"));
+        assert!(!found.iter().any(|i| i.kind == "venv"));
+        std::fs::remove_dir_all(&tmp).ok();
+    }
+}
diff --git a/src-tauri/src/commands/remote.rs b/src-tauri/src/commands/remote.rs
new file mode 100644
index 0000000..5064780
--- /dev/null
+++ b/src-tauri/src/commands/remote.rs
@@ -0,0 +1,582 @@
+//! Pooled remote-connection commands (Phase 0 of mount-free remote).
+//!
+//! The frontend calls these fire-and-forget on project activation/deactivation
+//! to open and close the single persistent SSH/SFTP connection per active remote
+//! project (see `services::remote`). Opening it once is what gives single
+//! sign-on: the master authenticates here and every later channel (file browse /
+//! I-O, agent tabs, git over ssh) rides it.
+
+use tauri::{AppHandle, State};
+
+use crate::services::git_peer::{self, GitPeerRegistry};
+use crate::services::hpc_mode;
+use crate::services::remote::{self, RemotePoolState};
+use crate::services::remote_sync::SyncManifestState;
+use crate::services::sync_auto::{self, AutoSyncState};
+
+// NOTE: `kill_tmux_on_disconnect` used to run here, from both disconnect
+// commands. It ran `tmux kill-server` on the host for a **plain project
+// deactivation** (`stores/projects` calls `remote_disconnect_all_hosts` on every
+// switch away), which destroyed exactly the sessions TODO #85 exists to
+// preserve — a training run left in a tmux session died because the user clicked
+// another project. `commands::ssh::remote_kill_all_jobs` remains the one
+// deliberate path that ends remote work, and it says so in its own doc comment.
+
+/// What this connect proves about **how the host authenticates**, if anything.
+///
+/// `Some(true)` = key/agent auth (no password given, none in the keychain — the only
+/// way a passwordless host can announce itself, since it has nothing saved to look
+/// for). `Some(false)` = a password was used. `None` = **it proves nothing, so don't
+/// write anything down**.
+///
+/// That last case is the whole reason this is a function. A credential-less connect
+/// that rode a ControlMaster somebody else authenticated (`via_login`) looks *exactly*
+/// like key auth from in here, and recording it as such is not a cosmetic error: the
+/// stored `key_auth: true` is what makes the pill offer auto-connect, and auto-connect
+/// then believes it — so a password host silently advertises a promptless connect it
+/// cannot deliver, and fails on every launch. Only the caller knows which it was.
+fn record_key_auth(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    via_login: Option<bool>,
+) -> Option<bool> {
+    if password.is_some() {
+        // A password was used: that is a fact about the host either way, and no
+        // borrowed master can make it wrong.
+        return Some(false);
+    }
+    if via_login == Some(true) {
+        return None;
+    }
+    // The inference below is "nothing in the keychain, so the host wanted nothing"
+    // — which is only sound if the keychain could be *read*. A locked collection
+    // answers every lookup "nothing saved" (`docs/context/remote_credentials.md`),
+    // so on a password host with a locked ring this used to stamp `key_auth: true`
+    // and the pill then advertised a promptless auto-connect it cannot deliver, on
+    // every launch. An unreadable store proves nothing, so write nothing.
+    if !crate::services::remote_credentials::store_readable() {
+        return None;
+    }
+    let saved = crate::services::remote_credentials::has(
+        &crate::services::remote_credentials::ssh_account(user, host, port),
+    );
+    Some(!saved)
+}
+
+/// Open (idempotently) the pooled SSH/SFTP connection for a remote project,
+/// authenticating once. A no-op for a local project or one already connected.
+/// `password` is used only for password-auth hosts (never stored); `None` →
+/// key/agent auth. Returned errors are logged by the caller, never blocking
+/// activation.
+///
+/// On a successful connect the per-project auto-sync task is launched (idempotent;
+/// itself a no-op for a local project), so any paths the user marked auto-sync
+/// start reconciling in the background.
+///
+/// `via_login` marks a connect that may be riding a ControlMaster **somebody else
+/// authenticated** — an interactive login terminal (`connections_headless` off), the
+/// session an add-machine/extend dialog left up, a global machine's master. Such a
+/// connect succeeds with no password and nothing in the keychain, which is
+/// indistinguishable from key/agent auth from here — so it must NOT be allowed to
+/// record `key_auth: true` (see [`record_key_auth`]). It is a *caller* fact, not
+/// something this command can observe.
+#[tauri::command]
+pub async fn remote_connect(
+    app: AppHandle,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+    auto: State<'_, AutoSyncState>,
+    git_peer_reg: State<'_, GitPeerRegistry>,
+    worker_sync: State<'_, crate::services::worker_sync::WorkerSyncState>,
+    project_id: String,
+    host_id: Option<String>,
+    password: Option<String>,
+    via_login: Option<bool>,
+    background: Option<bool>,
+) -> Result<(), String> {
+    let host_id = host_id.unwrap_or_else(|| remote::PRIMARY_HOST.to_string());
+    // `background` per `ssh_common`'s second shape, same polarity and same
+    // default as every other dual-caller command: a Connect click passes
+    // `Some(false)` and may reach a machine tagged HPC; the armed auto-connect at
+    // launch/VPN-up passes nothing (or `true`) and may not. The dial policy sees
+    // this guard several layers down, where the argv is actually built.
+    //
+    // The default is background even though it makes an un-updated caller's
+    // Connect *fail* on a tagged host, because the alternative is the bug this
+    // whole change exists to close: a launch path that inherits "user-initiated"
+    // by saying nothing is exactly how the cluster kept being dialled. Failing
+    // closed here costs one `ELDRUN_HPC_GUARD connect …` naming the machine.
+    let _dial = remote::remote_target_for_host(&project_id, &host_id).and_then(|t| {
+        crate::services::ssh_common::declared_dial(
+            background,
+            &t.spec.user,
+            &t.spec.host,
+            t.spec.port,
+        )
+    });
+    remote::connect_host(pool.inner(), &project_id, &host_id, password.as_deref()).await?;
+
+    // Best-effort "is this host already busy?" check, off the connect critical
+    // path: it runs one extra SSH round trip (riding the same ControlMaster this
+    // connect just opened), so it is spawned rather than awaited — a slow or
+    // failing probe must never delay activation. Fires for ANY host (primary or a
+    // multi-host `compute_hosts` worker) that just connected — the frontend's
+    // warning dialog groups every connected host's report by `host_id` into one
+    // combined view instead of only ever showing the primary's.
+    // …except on a host the user called shared, or one already known to be a
+    // cluster login node: there the probe is not just unhelpful (a login node is
+    // *always* busy and always has other people on it) but unasked-for, and its
+    // careful variant still costs the node a `ps`/`who` on every connect. The
+    // report stays available on demand from the Machines menu
+    // (`remote_usage_check`). Nothing is skipped on a host with no answer and no
+    // probe behind it — that first probe is what teaches us what the host is, and
+    // it censors itself host-side either way.
+    if let Some(target) = remote::remote_target_for_host(&project_id, &host_id)
+        .filter(|t| !hpc_mode::is_careful_host(&t.spec))
+    {
+        let app_for_usage = app.clone();
+        let usage_spec = target.spec.clone();
+        let usage_project_id = project_id.clone();
+        let usage_host_id = host_id.clone();
+        tauri::async_runtime::spawn(async move {
+            let result = tauri::async_runtime::spawn_blocking(move || {
+                crate::services::remote_usage::check_usage(&usage_spec)
+            })
+            .await;
+            if let Ok(Ok(report)) = result {
+                crate::services::remote_usage::emit_usage_report(
+                    &app_for_usage,
+                    &usage_project_id,
+                    &usage_host_id,
+                    &report,
+                );
+            }
+        });
+    }
+
+    // A WORKER connect skips the bidirectional primary machinery (git lockstep +
+    // byte-sync own the primary only) and instead kicks the push-only code fan-out
+    // that brings the worker's tracked tree up to the source HEAD (plan §2/§3.3).
+    // Exception: a SHARED-FILESYSTEM worker has no copy of its own — its tabs `cd`
+    // straight into the primary's shared folder — so there is nothing to sync and
+    // git must never run against that tree. Just leave the pool open.
+    if host_id != remote::PRIMARY_HOST {
+        let hosts = remote::compute_hosts_for(&project_id);
+        let worker = hosts.iter().find(|h| h.id == host_id);
+        let shared = worker.map(|h| h.shared_fs).unwrap_or(false);
+        // Record whether this worker authenticated with no password at all
+        // (key/agent auth) — the worker twin of the primary's key_auth recording
+        // below. It is the only way the Connect dialog can mark a passwordless
+        // worker auto-connect-eligible (it has nothing in the keychain to check),
+        // so without it a shared-fs HPC worker's Auto-connect toggle never enables.
+        if let Some(w) = worker {
+            if let Some(key_auth) = record_key_auth(
+                &w.spec.user,
+                &w.spec.host,
+                w.spec.port,
+                password.as_deref(),
+                via_login,
+            ) {
+                if let Err(e) = crate::commands::projects::record_worker_key_auth(
+                    &project_id,
+                    &host_id,
+                    key_auth,
+                ) {
+                    eprintln!("record worker auth mode for '{project_id}/{host_id}' failed: {e}");
+                }
+            }
+        }
+        if !shared {
+            crate::services::worker_sync::on_worker_connect(
+                app.clone(),
+                pool.inner().clone(),
+                worker_sync.inner().clone(),
+                &project_id,
+                &host_id,
+            )
+            .await;
+        }
+        return Ok(());
+    }
+
+    // The connect succeeded; record whether it needed a password at all. No password
+    // passed *and* none in the keychain means the host authenticated via key/agent —
+    // the only way the UI can tell a passwordless host is auto-connect-eligible,
+    // since such a host has no keychain entry to look for. Best effort.
+    if let Some(target) = remote::remote_target_for(&project_id) {
+        let spec = &target.spec;
+        if let Some(key_auth) = record_key_auth(
+            &spec.user,
+            &spec.host,
+            spec.port,
+            password.as_deref(),
+            via_login,
+        ) {
+            if let Err(e) = crate::commands::projects::record_remote_key_auth(&project_id, key_auth)
+            {
+                eprintln!("record auth mode for '{project_id}' failed: {e}");
+            }
+        }
+    }
+    sync_auto::start(
+        app.clone(),
+        pool.inner().clone(),
+        manifest.inner().clone(),
+        auto.inner(),
+        &project_id,
+    )
+    .await;
+    // Launch git lockstep only when the project has opted in (start() itself no-ops
+    // otherwise); it attaches the .git watcher + host poll and reconciles once.
+    git_peer::start(
+        app,
+        pool.inner().clone(),
+        manifest.inner().clone(),
+        auto.inner().clone(),
+        git_peer_reg.inner(),
+        worker_sync.inner().clone(),
+        &project_id,
+    )
+    .await;
+    Ok(())
+}
+
+/// The ids of every project whose pooled SSH connection is currently live —
+/// the authoritative backend truth `remote::is_connected` already computes for
+/// `network_ssh_link_snapshot`. Lets the frontend periodically reconcile
+/// `useRemoteStatusStore` (which only ever moves on an explicit connect/
+/// disconnect result) against reality: a pooled ssh child that exits on its own
+/// — a network drop, a keepalive eviction, a VPN tunnel getting replaced out
+/// from under it — is only ever noticed lazily, the next time some other
+/// command happens to touch that project's pool entry. Until then the lamp and
+/// the Connect dialog both keep reporting "connected" from stale frontend
+/// state while every read that actually asks the pool (like the network-
+/// traffic pane) correctly reports disconnected.
+#[tauri::command]
+pub async fn remote_connected_ids(pool: State<'_, RemotePoolState>) -> Result<Vec<String>, ()> {
+    Ok(remote::connected_ids(pool.inner()).await)
+}
+
+/// Close the pooled connection for a remote project host (on deactivation, or a
+/// per-host lamp toggle). `host_id` defaults to the primary.
+/// For the **primary**, stops the auto-sync + git-lockstep tasks first (cancel +
+/// unwatch), then tears down the pool; a **worker** disconnect only drops its pool
+/// entry (it owns no lockstep/sync). No-op if nothing is pooled for it.
+///
+/// Deliberately leaves the host's tmux sessions running: closing a connection is
+/// not ending the work it was carrying (TODO #85). See the note at the top of
+/// this module.
+#[tauri::command]
+pub async fn remote_disconnect(
+    pool: State<'_, RemotePoolState>,
+    auto: State<'_, AutoSyncState>,
+    git_peer_reg: State<'_, GitPeerRegistry>,
+    project_id: String,
+    host_id: Option<String>,
+) -> Result<(), String> {
+    let host_id = host_id.unwrap_or_else(|| remote::PRIMARY_HOST.to_string());
+    if host_id == remote::PRIMARY_HOST {
+        git_peer::stop(git_peer_reg.inner(), &project_id).await;
+        sync_auto::stop(auto.inner(), &project_id).await;
+    }
+    remote::disconnect_host(pool.inner(), &project_id, &host_id).await;
+    Ok(())
+}
+
+/// Disconnect **every connected** host of a remote project — primary and workers
+/// — on project deactivation. Stops the primary's lockstep/auto-sync, then tears
+/// down all pooled entries for the project. Like [`remote_disconnect`], it leaves
+/// the hosts' tmux sessions alone: this fires on an ordinary project switch.
+#[tauri::command]
+pub async fn remote_disconnect_all_hosts(
+    pool: State<'_, RemotePoolState>,
+    auto: State<'_, AutoSyncState>,
+    git_peer_reg: State<'_, GitPeerRegistry>,
+    project_id: String,
+) -> Result<(), String> {
+    git_peer::stop(git_peer_reg.inner(), &project_id).await;
+    sync_auto::stop(auto.inner(), &project_id).await;
+    remote::disconnect_project(pool.inner(), &project_id).await;
+    Ok(())
+}
+
+/// The `(project_id, host_id)` pairs whose pooled SSH connection is currently live
+/// — the per-host granular form of [`remote_connected_ids`], for the frontend to
+/// reconcile each host lamp against reality (see that command's rationale).
+#[tauri::command]
+pub async fn remote_connected_targets(
+    pool: State<'_, RemotePoolState>,
+) -> Result<Vec<(String, String)>, ()> {
+    Ok(remote::connected_targets(pool.inner()).await)
+}
+
+/// Manually push the mirror's current HEAD to a remote project's worker host (the
+/// pill's "Sync code now"). `force` re-pushes even when the worker is recorded as
+/// already at HEAD. Emits a `worker-sync-report` and returns the same report.
+#[tauri::command]
+pub async fn worker_sync_now(
+    pool: State<'_, RemotePoolState>,
+    project_id: String,
+    host_id: String,
+) -> Result<crate::services::worker_sync::WorkerSyncReport, String> {
+    let _dial = user_dial_for_host(&project_id, &host_id);
+    let report =
+        crate::services::worker_sync::sync_worker(pool.inner(), &project_id, &host_id, true).await;
+    Ok(report)
+}
+
+/// Hold this target user-initiated for the rest of the enclosing command — the
+/// project-host spelling of `ssh_common::user_dial`, for the handful of commands
+/// that only ever run off a click ("Sync code now", "Pull outputs", a Sessions
+/// row's Kill). `None` for a local project or an unknown host, where there is
+/// nothing to authorize.
+fn user_dial_for_host(
+    project_id: &str,
+    host_id: &str,
+) -> Option<crate::services::ssh_common::UserDial> {
+    let target = remote::remote_target_for_host(project_id, host_id)?;
+    Some(crate::services::ssh_common::user_dial(
+        &target.spec.user,
+        &target.spec.host,
+        target.spec.port,
+    ))
+}
+
+/// Preview the size of a worker's pullable experiment outputs (its untracked
+/// files) so the frontend can confirm before a large transfer (plan §4.4).
+#[tauri::command]
+pub async fn worker_outputs_preview(
+    project_id: String,
+    host_id: String,
+) -> Result<crate::services::worker_sync::WorkerOutputsPreview, String> {
+    crate::services::worker_sync::preview_outputs(&project_id, &host_id).await
+}
+
+/// Pull a worker's untracked outputs into a local `outputs/<label>/` folder — the
+/// one, user-initiated worker→local byte path (plan §4.4/§8).
+#[tauri::command]
+pub async fn worker_pull_outputs(
+    pool: State<'_, RemotePoolState>,
+    project_id: String,
+    host_id: String,
+) -> Result<crate::services::worker_sync::WorkerPullReport, String> {
+    let _dial = user_dial_for_host(&project_id, &host_id);
+    crate::services::worker_sync::pull_outputs(pool.inner(), &project_id, &host_id).await
+}
+
+/// Upload a LOCAL file to a remote project's tree over the pooled SFTP, streaming
+/// it in bounded chunks (so a large dataset never buffers whole). `dest_rel` is a
+/// project-relative destination path (its parent dirs are created); the file lands
+/// at `<remote_path>/<dest_rel>`. Used by the HPC pipeline wizard's "Load data"
+/// step (`docs/quirky-knitting-umbrella` plan). Primary host only; the project must
+/// already be connected (a cold pool errors rather than opening a second master).
+///
+/// `dest_rel` is sanitized to stay inside the project root: a leading `/` is
+/// dropped and a `..` component is refused, so an upload can never escape the tree.
+#[tauri::command]
+pub async fn remote_upload_file(
+    pool: State<'_, RemotePoolState>,
+    project_id: String,
+    local_path: String,
+    dest_rel: String,
+) -> Result<String, String> {
+    let target = remote::remote_target_for(&project_id)
+        .ok_or_else(|| "not a remote project".to_string())?;
+    let rel = dest_rel.trim().trim_start_matches('/');
+    if rel.is_empty() {
+        return Err("no destination given".to_string());
+    }
+    if rel.split('/').any(|c| c == ".." || c == ".") {
+        return Err(format!("invalid destination path '{dest_rel}'"));
+    }
+    let root = target.spec.remote_path.trim_end_matches('/');
+    let dest = format!("{root}/{rel}");
+    let sftp = remote::pooled_sftp(pool.inner(), &project_id)
+        .await
+        .ok_or_else(|| "remote project is not connected".to_string())?;
+    crate::services::sftp::upload_file_streaming_on(&sftp, std::path::Path::new(&local_path), &dest)
+        .await?;
+    Ok(dest)
+}
+
+/// List the tmux sessions running on a remote project host (TODO #85), for the
+/// Sessions view. Runs `tmux ls` over the pooled ControlMaster; an absent tmux or
+/// a not-running server yields an **empty** list, never an error (see
+/// `ssh_exec::parse_tmux_ls`). `host_id` defaults to the primary.
+///
+/// The raw host listing is scoped to THIS project
+/// (`ssh_exec::filter_sessions_for_project`) — by session name where it carries a
+/// project id, otherwise by the session's working directory — so a host that
+/// several projects share (a cluster login node) never shows one project's runs
+/// in another's view. `include_all` is the view's escape hatch: it returns the
+/// host listing unfiltered, which is how an orphaned or unattributable session
+/// stays reachable to kill. The **path** used is this host's own
+/// `remote_path`, so a synced worker with its own copy scopes to its own tree.
+#[tauri::command]
+pub async fn remote_tmux_list(
+    project_id: String,
+    host_id: Option<String>,
+    include_all: Option<bool>,
+) -> Result<Vec<crate::services::ssh_exec::TmuxSession>, String> {
+    let host_id = host_id.unwrap_or_else(|| remote::PRIMARY_HOST.to_string());
+    let target = remote::remote_target_for_host(&project_id, &host_id)
+        .ok_or_else(|| "not a remote project host".to_string())?;
+    let filter_project_id = project_id.clone();
+    let project_root = target.spec.remote_path.clone();
+    let include_all = include_all.unwrap_or(false);
+    tauri::async_runtime::spawn_blocking(move || {
+        let out = crate::services::ssh_exec::run_remote_script(
+            &target.spec,
+            crate::services::ssh_exec::tmux_ls_script(),
+        )?;
+        let sessions = crate::services::ssh_exec::parse_tmux_ls(
+            &String::from_utf8_lossy(&out.stdout),
+        );
+        Ok(crate::services::ssh_exec::filter_sessions_for_project(
+            sessions,
+            &filter_project_id,
+            &project_root,
+            include_all,
+        ))
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+/// Kill a tmux session on a remote project host (TODO #85) — the destructive
+/// intent behind an **explicit** tab close of a persistent remote tab, and the
+/// Sessions view's per-row Kill. `host_id`
+/// defaults to the primary; `session` is `shell_quote`d inside the script.
+#[tauri::command]
+pub async fn remote_tmux_kill(
+    project_id: String,
+    host_id: Option<String>,
+    session: String,
+) -> Result<(), String> {
+    let host_id = host_id.unwrap_or_else(|| remote::PRIMARY_HOST.to_string());
+    let target = remote::remote_target_for_host(&project_id, &host_id)
+        .ok_or_else(|| "not a remote project host".to_string())?;
+    let _dial = user_dial_for_host(&project_id, &host_id);
+    tauri::async_runtime::spawn_blocking(move || {
+        crate::services::ssh_exec::run_remote_script(
+            &target.spec,
+            &crate::services::ssh_exec::tmux_kill_session_script(&session),
+        )
+        .map(|_| ())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+/// Rename a tmux session on a remote project host (TODO #85) — the Sessions
+/// view's per-row Rename. `new_name` must be a safe tmux name
+/// (`ssh_exec::valid_tmux_session_name`); the (possibly foreign) `session` source
+/// name is only quoted. `host_id` defaults to the primary.
+#[tauri::command]
+pub async fn remote_tmux_rename(
+    project_id: String,
+    host_id: Option<String>,
+    session: String,
+    new_name: String,
+) -> Result<(), String> {
+    if !crate::services::ssh_exec::valid_tmux_session_name(&new_name) {
+        return Err(
+            "a session name may only contain letters, digits, '-' and '_'".to_string(),
+        );
+    }
+    let host_id = host_id.unwrap_or_else(|| remote::PRIMARY_HOST.to_string());
+    let target = remote::remote_target_for_host(&project_id, &host_id)
+        .ok_or_else(|| "not a remote project host".to_string())?;
+    tauri::async_runtime::spawn_blocking(move || {
+        crate::services::ssh_exec::run_remote_script(
+            &target.spec,
+            &crate::services::ssh_exec::tmux_rename_session_script(&session, &new_name),
+        )
+        .map(|_| ())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+/// On-demand resource check for an already-connected remote project (the
+/// warning dialog's "Recheck" action). Unlike the fire-and-forget check
+/// `remote_connect` runs on connect, this one is awaited and its result
+/// returned directly rather than pushed as an event. `host_id` defaults to the
+/// primary; the combined usage dialog rechecks each host it currently shows.
+///
+/// Takes `background` (`ssh_common`'s second shape): a per-row "Read now" is a
+/// gesture, while the dialog's open-the-menu sweep across every host is not, and
+/// the two reach this same command. Only `Some(false)` counts as the former.
+#[tauri::command]
+pub async fn remote_usage_check(
+    project_id: String,
+    host_id: Option<String>,
+    background: Option<bool>,
+) -> Result<crate::services::remote_usage::RemoteUsageReport, String> {
+    let host_id = host_id.unwrap_or_else(|| remote::PRIMARY_HOST.to_string());
+    let target = remote::remote_target_for_host(&project_id, &host_id)
+        .ok_or_else(|| "not a remote project host".to_string())?;
+    let _dial = crate::services::ssh_common::declared_dial(
+        background,
+        &target.spec.user,
+        &target.spec.host,
+        target.spec.port,
+    );
+    tauri::async_runtime::spawn_blocking(move || {
+        crate::services::remote_usage::check_usage(&target.spec)
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+#[cfg(test)]
+mod tests {
+    use super::record_key_auth;
+
+    /// The bug this guards: with `connections_headless` off, every pooled connect is
+    /// credential-less and succeeds only because an interactive login left a master
+    /// behind. Reading that as key auth wrote `key_auth: true` onto a password host,
+    /// which made the pill offer auto-connect and auto-connect fail on every launch.
+    #[test]
+    fn a_borrowed_master_proves_nothing_about_key_auth() {
+        assert_eq!(
+            record_key_auth(&Some("alice".into()), "host.example", None, None, Some(true)),
+            None,
+        );
+    }
+
+    /// A password is a fact about the host however the session was established, so it
+    /// is still recorded — `via_login` only suppresses the *inference*, never a
+    /// direct observation.
+    #[test]
+    fn a_password_is_recorded_even_on_a_borrowed_master() {
+        assert_eq!(
+            record_key_auth(
+                &Some("alice".into()),
+                "host.example",
+                None,
+                Some("hunter2"),
+                Some(true),
+            ),
+            Some(false),
+        );
+    }
+
+    /// A locked keychain reads exactly like an empty one, so the "nothing saved,
+    /// therefore key auth" inference is only sound when the store could be read.
+    /// Against a locked one it used to stamp `key_auth: true` on a password host,
+    /// and the pill then offered a promptless auto-connect that fails every launch.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn an_unreadable_keychain_proves_nothing() {
+        crate::services::remote_credentials::remember_keyring_state(
+            crate::services::remote_credentials::KeyringState::Locked,
+        );
+        assert_eq!(
+            record_key_auth(&Some("alice".into()), "locked.example", None, None, None),
+            None,
+        );
+    }
+}
diff --git a/src-tauri/src/commands/screenshot.rs b/src-tauri/src/commands/screenshot.rs
index d8daaba..9adb85c 100644
--- a/src-tauri/src/commands/screenshot.rs
+++ b/src-tauri/src/commands/screenshot.rs
@@ -1,68 +1,50 @@
-//! Project-scoped screenshots: capture an interactive screen region and write
-//! the PNG into the active project's `screenshots/` folder.
+//! Project-scoped screenshots: capture the screen and write the PNG into the
+//! active project's `screenshots/` folder.
 //!
 //! Eldrun's global "Screenshot" app already launches a region-capture tool, but
 //! each tool otherwise saves to its own default location (`~/Pictures`, a prompt,
-//! …). This command instead drives the tool's *output path* into the project so
-//! the capture lands beside the code it documents. It prefers the tool the user
-//! configured for the Screenshot global app; if that tool isn't one we know how
-//! to direct (or none is configured), it falls back to the first available
-//! native region-capture tool. The destination is confined to the project root,
-//! mirroring `clipboard`/`fs`.
-
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+//! …). This command instead drives the capture's *output path* into the project
+//! so the shot lands beside the code it documents. The destination is confined
+//! to the project root, mirroring `clipboard`/`fs`.
+//!
+//! The shot is *also* put on the system clipboard, so it can be pasted straight
+//! into a chat or an agent tab without going hunting for the file (see
+//! [`clipboard::copy_image_to_clipboard`]). Copying is best-effort and off the
+//! critical path: the file is the product, the clipboard is a convenience.
+//!
+//! The platform-neutral layer (destination dir + timestamped filename) is shared;
+//! the actual capture is delegated to a per-OS [`platform`] backend:
+//! - **Linux** spawns an interactive native region tool (`spectacle`/`grim`/…),
+//!   directed to write its PNG into the project's `screenshots/` folder.
+//! - **Windows** grabs the whole virtual screen natively via GDI and encodes it
+//!   to PNG with the `png` crate — no external tool required.
+//! - **macOS** drives the built-in `screencapture` CLI in interactive region
+//!   mode, writing the PNG into the project's `screenshots/` folder.
+//! - **Any other OS** returns an error rather than failing to build.
+
+use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use crate::commands::fs::enforce_confinement;
 
-/// Native region-capture tools we know how to drive, in preference order. The
-/// first one present on `PATH` is used when the global Screenshot app has no
-/// usable command. `grim` additionally needs `slurp` for region selection.
-const NATIVE_TOOLS: &[&str] = &[
-    "spectacle",
-    "gnome-screenshot",
-    "flameshot",
-    "grim",
-    "scrot",
-    "maim",
-    "xfce4-screenshooter",
-    "ksnip",
-    "shutter",
-    "import",
-];
-
-/// Capture an interactive screen region into `<project_dir>/screenshots/`.
+/// How long, after the capture tool exits, we keep looking for the PNG it was
+/// supposed to write before giving up on the clipboard copy.
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+const SHOT_WAIT: std::time::Duration = std::time::Duration::from_secs(2);
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+const SHOT_POLL: std::time::Duration = std::time::Duration::from_millis(100);
+
+/// Capture a screenshot into `<project_dir>/screenshots/`.
 ///
 /// `exec` is the command configured for the global Screenshot app (a full path
-/// or bare name); when it names a tool we can direct, it is used, otherwise a
-/// native tool is chosen. The capture tool is spawned detached — region
-/// selection blocks the *tool*, not Eldrun — and the project's filesystem watch
-/// surfaces the new PNG in the file tree. Returns the directory the shot will
-/// land in (the exact filename is the tool's for dir-mode tools like flameshot).
+/// or bare name); the Linux backend uses it to pick a tool it can direct, while
+/// the Windows backend ignores it (it always does a native grab). Returns the
+/// directory the shot lands in; the project's filesystem watch surfaces the new
+/// PNG in the file tree.
 #[tauri::command]
 pub fn capture_project_screenshot(project_dir: String, exec: Option<String>) -> Result<String, String> {
     let dir = ensure_screenshots_dir(&project_dir)?;
-
-    let configured = exec
-        .as_deref()
-        .map(str::trim)
-        .filter(|e| !e.is_empty())
-        .filter(|e| is_directable(&basename(e)));
-    let program = match configured {
-        Some(e) => e.to_string(),
-        None => pick_native_tool()
-            .ok_or_else(|| "no usable screenshot tool found; set one for the Screenshot global app".to_string())?,
-    };
-
-    let mut cmd = capture_command(&program, &dir)
-        .ok_or_else(|| format!("don't know how to capture with '{}'", basename(&program)))?;
-    cmd.stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null());
-    cmd.spawn()
-        .map_err(|e| format!("launch {program}: {e}"))?;
-
+    platform::capture(&dir, exec.as_deref())?;
     Ok(dir.to_string_lossy().to_string())
 }
 
@@ -76,68 +58,6 @@ fn ensure_screenshots_dir(project_dir: &str) -> Result<PathBuf, String> {
     Ok(dir_c)
 }
 
-/// Build the capture `Command` for a tool, routing its output into `dir`. Tools
-/// that take an explicit output file get a timestamped path; tools that only
-/// take a directory (flameshot) or self-name (`import`) write into `dir` too.
-/// Returns `None` for tools we don't know how to direct.
-fn capture_command(program: &str, dir: &Path) -> Option<Command> {
-    let base = basename(program);
-    let file = dir.join(screenshot_filename());
-    let f = file.to_string_lossy().to_string();
-    let d = dir.to_string_lossy().to_string();
-
-    let mut cmd = Command::new(program);
-    match base.as_str() {
-        // region + headless save, no desktop notification, -o output
-        "spectacle" => cmd.args(["-r", "-b", "-n", "-o", &f]),
-        "gnome-screenshot" => cmd.args(["--area", "--file", &f]),
-        // flameshot names the file itself; -p sets the directory it saves into
-        "flameshot" => cmd.args(["gui", "--path", &d]),
-        "scrot" => cmd.args(["--select", &f]),
-        "maim" => cmd.args(["--select", &f]),
-        "xfce4-screenshooter" => cmd.args(["--region", "--save", &f]),
-        "ksnip" => cmd.args(["--rectarea", "-s", &f]),
-        "shutter" => cmd.args(["--select", "--exit_after_capture", "-o", &f]),
-        // ImageMagick: bare `import <file>` lets the user click/drag a region
-        "import" => cmd.arg(&f),
-        // Wayland: slurp selects the region, grim captures it — needs a shell
-        "grim" => {
-            let mut sh = Command::new("sh");
-            sh.arg("-c").arg(format!("grim -g \"$(slurp)\" {}", shell_quote(&f)));
-            return Some(sh);
-        }
-        _ => return None,
-    };
-    Some(cmd)
-}
-
-/// Whether `capture_command` knows how to direct a tool's output, by basename.
-fn is_directable(base: &str) -> bool {
-    NATIVE_TOOLS.contains(&base)
-}
-
-/// First native tool present on `PATH` (grim additionally requires `slurp`).
-fn pick_native_tool() -> Option<String> {
-    NATIVE_TOOLS.iter().copied().find(|&tool| {
-        on_path(tool) && (tool != "grim" || on_path("slurp"))
-    }).map(String::from)
-}
-
-/// Whether an executable named `name` exists on `PATH`.
-fn on_path(name: &str) -> bool {
-    match std::env::var_os("PATH") {
-        Some(path) => std::env::split_paths(&path).any(|dir| dir.join(name).is_file()),
-        None => false,
-    }
-}
-
-fn basename(exec: &str) -> String {
-    Path::new(exec)
-        .file_name()
-        .map(|n| n.to_string_lossy().to_lowercase())
-        .unwrap_or_default()
-}
-
 /// `Screenshot-YYYYMMDD-HHMMSS.png` in UTC — sortable and collision-resistant.
 fn screenshot_filename() -> String {
     let secs = SystemTime::now()
@@ -150,6 +70,77 @@ fn screenshot_filename() -> String {
     format!("Screenshot-{y:04}{mo:02}{d:02}-{h:02}{mi:02}{s:02}.png")
 }
 
+/// Spawn a capture tool detached and, once it exits, copy the PNG it produced
+/// onto the clipboard.
+///
+/// Region selection blocks the *tool*, not Eldrun, so the shot does not exist
+/// until the child is gone — the wait therefore happens on a background thread,
+/// which also reaps the child (as `spawn_reaped` otherwise would). `expected` is
+/// the path the tool was directed at, or `None` for tools that name the file
+/// themselves (flameshot), where the newest PNG to appear is taken instead. A
+/// cancelled capture writes no file at all, so finding nothing is a normal
+/// outcome and stays silent.
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+fn spawn_and_copy(
+    mut cmd: std::process::Command,
+    dir: &std::path::Path,
+    expected: Option<PathBuf>,
+) -> std::io::Result<()> {
+    // Filesystem mtimes can be coarser than `SystemTime::now()`, so leave slack
+    // rather than let a just-written file look older than the spawn.
+    let since = SystemTime::now()
+        .checked_sub(SHOT_WAIT)
+        .unwrap_or_else(SystemTime::now);
+    let mut child = cmd.spawn()?;
+    let dir = dir.to_path_buf();
+    std::thread::spawn(move || {
+        if child.wait().is_err() {
+            return;
+        }
+        // The PNG lands as the tool exits; poll briefly for it to appear (and to
+        // be readable — a decode can lose a race with the tool's final flush).
+        let polls = SHOT_WAIT.as_millis() / SHOT_POLL.as_millis();
+        for _ in 0..polls {
+            if let Some(shot) = locate_shot(&dir, expected.as_deref(), since) {
+                if crate::commands::clipboard::copy_png_file_to_clipboard(&shot).is_ok() {
+                    return;
+                }
+            }
+            std::thread::sleep(SHOT_POLL);
+        }
+    });
+    Ok(())
+}
+
+/// The PNG a capture just produced: the path the tool was directed at, or — for
+/// tools that choose their own filename — the newest PNG in `dir` written since
+/// the tool was spawned. `None` when the capture was cancelled and wrote nothing.
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+fn locate_shot(
+    dir: &std::path::Path,
+    expected: Option<&std::path::Path>,
+    since: SystemTime,
+) -> Option<PathBuf> {
+    if let Some(path) = expected {
+        return path.is_file().then(|| path.to_path_buf());
+    }
+    std::fs::read_dir(dir)
+        .ok()?
+        .flatten()
+        .filter(|entry| {
+            entry
+                .path()
+                .extension()
+                .is_some_and(|ext| ext.eq_ignore_ascii_case("png"))
+        })
+        .filter_map(|entry| {
+            let mtime = entry.metadata().ok()?.modified().ok()?;
+            (mtime >= since).then_some((mtime, entry.path()))
+        })
+        .max_by_key(|(mtime, _)| *mtime)
+        .map(|(_, path)| path)
+}
+
 /// Civil date from days since the Unix epoch (Howard Hinnant's algorithm).
 fn civil_from_days(z: i64) -> (i64, i64, i64) {
     let z = z + 719_468;
@@ -164,14 +155,320 @@ fn civil_from_days(z: i64) -> (i64, i64, i64) {
     (if m <= 2 { y + 1 } else { y }, m, d)
 }
 
-/// Minimal single-quote shell escaping for a path embedded in `sh -c`.
-fn shell_quote(s: &str) -> String {
-    format!("'{}'", s.replace('\'', r"'\''"))
+// ── Linux backend (drive an interactive native region tool) ──────────────────
+#[cfg(target_os = "linux")]
+mod platform {
+    //! Spawns the user-configured (or first available) native region-capture
+    //! tool, routing its output into the project's `screenshots/` folder. The
+    //! tool is spawned detached — region selection blocks the *tool*, not Eldrun
+    //! — and the project's filesystem watch surfaces the new PNG.
+
+    use std::path::{Path, PathBuf};
+    use std::process::{Command, Stdio};
+
+    /// Native region-capture tools we know how to drive, in preference order. The
+    /// first one present on `PATH` is used when the global Screenshot app has no
+    /// usable command. `grim` additionally needs `slurp` for region selection.
+    const NATIVE_TOOLS: &[&str] = &[
+        "spectacle",
+        "gnome-screenshot",
+        "flameshot",
+        "grim",
+        "scrot",
+        "maim",
+        "xfce4-screenshooter",
+        "ksnip",
+        "shutter",
+        "import",
+    ];
+
+    /// Pick a tool (configured `exec` if directable, else the first native one on
+    /// `PATH`) and spawn it detached, writing into `dir`.
+    pub fn capture(dir: &Path, exec: Option<&str>) -> Result<(), String> {
+        let configured = exec
+            .map(str::trim)
+            .filter(|e| !e.is_empty())
+            .filter(|e| is_directable(&basename(e)));
+        let program = match configured {
+            Some(e) => e.to_string(),
+            None => pick_native_tool().ok_or_else(|| {
+                "no usable screenshot tool found; set one for the Screenshot global app".to_string()
+            })?,
+        };
+
+        let (mut cmd, expected) = capture_command(&program, dir)
+            .ok_or_else(|| format!("don't know how to capture with '{}'", basename(&program)))?;
+        cmd.stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        crate::paths::augment_command_path(&mut cmd);
+        super::spawn_and_copy(cmd, dir, expected).map_err(|e| format!("launch {program}: {e}"))?;
+        Ok(())
+    }
+
+    /// Build the capture `Command` for a tool, routing its output into `dir`, plus
+    /// the file it will write. Tools that take an explicit output file get a
+    /// timestamped path; flameshot only takes a directory and names the file
+    /// itself, so it reports no expected path. Returns `None` for tools we don't
+    /// know how to direct.
+    pub fn capture_command(program: &str, dir: &Path) -> Option<(Command, Option<PathBuf>)> {
+        let base = basename(program);
+        let file = dir.join(super::screenshot_filename());
+        let f = file.to_string_lossy().to_string();
+        let d = dir.to_string_lossy().to_string();
+
+        let mut cmd = Command::new(program);
+        match base.as_str() {
+            // region + headless save, no desktop notification, -o output
+            "spectacle" => cmd.args(["-r", "-b", "-n", "-o", &f]),
+            "gnome-screenshot" => cmd.args(["--area", "--file", &f]),
+            // flameshot names the file itself; -p sets the directory it saves into
+            "flameshot" => {
+                cmd.args(["gui", "--path", &d]);
+                return Some((cmd, None));
+            }
+            "scrot" => cmd.args(["--select", &f]),
+            "maim" => cmd.args(["--select", &f]),
+            "xfce4-screenshooter" => cmd.args(["--region", "--save", &f]),
+            "ksnip" => cmd.args(["--rectarea", "-s", &f]),
+            "shutter" => cmd.args(["--select", "--exit_after_capture", "-o", &f]),
+            // ImageMagick: bare `import <file>` lets the user click/drag a region
+            "import" => cmd.arg(&f),
+            // Wayland: slurp selects the region, grim captures it — needs a shell
+            "grim" => {
+                let mut sh = Command::new("sh");
+                sh.arg("-c").arg(format!("grim -g \"$(slurp)\" {}", shell_quote(&f)));
+                return Some((sh, Some(file)));
+            }
+            _ => return None,
+        };
+        Some((cmd, Some(file)))
+    }
+
+    /// Whether `capture_command` knows how to direct a tool's output, by basename.
+    pub fn is_directable(base: &str) -> bool {
+        NATIVE_TOOLS.contains(&base)
+    }
+
+    /// First native tool present on `PATH` (grim additionally requires `slurp`).
+    fn pick_native_tool() -> Option<String> {
+        NATIVE_TOOLS
+            .iter()
+            .copied()
+            .find(|&tool| on_path(tool) && (tool != "grim" || on_path("slurp")))
+            .map(String::from)
+    }
+
+    /// Whether an executable named `name` exists on `PATH`.
+    fn on_path(name: &str) -> bool {
+        match std::env::var_os("PATH") {
+            Some(path) => std::env::split_paths(&path).any(|dir| dir.join(name).is_file()),
+            None => false,
+        }
+    }
+
+    pub fn basename(exec: &str) -> String {
+        Path::new(exec)
+            .file_name()
+            .map(|n| n.to_string_lossy().to_lowercase())
+            .unwrap_or_default()
+    }
+
+    /// Minimal single-quote shell escaping for a path embedded in `sh -c`.
+    pub fn shell_quote(s: &str) -> String {
+        format!("'{}'", s.replace('\'', r"'\''"))
+    }
+}
+
+// ── Windows backend (Win32 GDI virtual-screen grab) ──────────────────────────
+#[cfg(target_os = "windows")]
+mod platform {
+    //! Native full virtual-screen capture via GDI. Windows has no equally
+    //! ubiquitous interactive region CLI, so rather than shelling out we grab the
+    //! entire virtual screen (every monitor) with `BitBlt` + `GetDIBits` and
+    //! encode it to PNG with the `png` crate, writing the file directly into the
+    //! project's `screenshots/` folder. This is deterministic — it always
+    //! produces image data — and needs no external tool. The configured `exec`
+    //! (which names a Linux tool) is ignored. Every GDI object acquired here is
+    //! released on both the success and error paths.
+
+    use std::ffi::c_void;
+    use std::path::Path;
+
+    use windows::Win32::Graphics::Gdi::{
+        BitBlt, CreateCompatibleBitmap, CreateCompatibleDC, DeleteDC, DeleteObject, GetDC,
+        GetDIBits, ReleaseDC, SelectObject, BITMAPINFO, BITMAPINFOHEADER, BI_RGB, DIB_RGB_COLORS,
+        HDC, HGDIOBJ, SRCCOPY,
+    };
+    use windows::Win32::UI::WindowsAndMessaging::{
+        GetSystemMetrics, SM_CXVIRTUALSCREEN, SM_CYVIRTUALSCREEN, SM_XVIRTUALSCREEN,
+        SM_YVIRTUALSCREEN,
+    };
+
+    /// Grab the virtual screen, write the PNG into `dir`, and put the same pixels
+    /// on the clipboard. Unlike the spawn-a-tool backends, the buffer is already
+    /// in hand here, so the copy needs no wait — and a clipboard failure must not
+    /// fail a capture whose file landed fine. `_exec` is unused on Windows (the
+    /// native grab is always preferred).
+    pub fn capture(dir: &Path, _exec: Option<&str>) -> Result<(), String> {
+        let (width, height, rgba) = grab_virtual_screen()?;
+        let file = dir.join(super::screenshot_filename());
+        encode_png_file(&file, width, height, &rgba)?;
+        let _ = crate::commands::clipboard::copy_image_to_clipboard(
+            width as usize,
+            height as usize,
+            rgba,
+        );
+        Ok(())
+    }
+
+    /// Capture all monitors as a single top-down RGBA buffer `(width, height, px)`.
+    fn grab_virtual_screen() -> Result<(u32, u32, Vec<u8>), String> {
+        // SAFETY: every GDI handle acquired below is released before this function
+        // returns, on both the success and error paths.
+        unsafe {
+            let x = GetSystemMetrics(SM_XVIRTUALSCREEN);
+            let y = GetSystemMetrics(SM_YVIRTUALSCREEN);
+            let width = GetSystemMetrics(SM_CXVIRTUALSCREEN);
+            let height = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+            if width <= 0 || height <= 0 {
+                return Err("virtual screen has no area".to_string());
+            }
+
+            let screen_dc = GetDC(None);
+            if screen_dc.is_invalid() {
+                return Err("GetDC failed for the screen".to_string());
+            }
+            let result = capture_to_buffer(screen_dc, x, y, width, height);
+            ReleaseDC(None, screen_dc);
+            result
+        }
+    }
+
+    /// BitBlt the screen region into a memory bitmap, then read it back as RGBA.
+    /// Caller owns `screen_dc`; the memory DC and bitmap are created and freed here.
+    unsafe fn capture_to_buffer(
+        screen_dc: HDC,
+        x: i32,
+        y: i32,
+        width: i32,
+        height: i32,
+    ) -> Result<(u32, u32, Vec<u8>), String> {
+        let mem_dc = CreateCompatibleDC(Some(screen_dc));
+        if mem_dc.is_invalid() {
+            return Err("CreateCompatibleDC failed".to_string());
+        }
+        let bitmap = CreateCompatibleBitmap(screen_dc, width, height);
+        if bitmap.is_invalid() {
+            let _ = DeleteDC(mem_dc);
+            return Err("CreateCompatibleBitmap failed".to_string());
+        }
+        let prev = SelectObject(mem_dc, HGDIOBJ(bitmap.0));
+
+        let result = (|| {
+            BitBlt(mem_dc, 0, 0, width, height, Some(screen_dc), x, y, SRCCOPY)
+                .map_err(|e| format!("BitBlt failed: {e}"))?;
+
+            // Negative biHeight requests top-down rows, so the buffer is already in
+            // the row order the PNG encoder expects.
+            let header = BITMAPINFOHEADER {
+                biSize: std::mem::size_of::<BITMAPINFOHEADER>() as u32,
+                biWidth: width,
+                biHeight: -height,
+                biPlanes: 1,
+                biBitCount: 32,
+                biCompression: BI_RGB.0 as u32,
+                ..Default::default()
+            };
+            let mut info = BITMAPINFO {
+                bmiHeader: header,
+                ..Default::default()
+            };
+
+            let mut buffer = vec![0u8; (width as usize) * (height as usize) * 4];
+            let scanlines = GetDIBits(
+                mem_dc,
+                bitmap,
+                0,
+                height as u32,
+                Some(buffer.as_mut_ptr() as *mut c_void),
+                &mut info,
+                DIB_RGB_COLORS,
+            );
+            if scanlines == 0 {
+                return Err("GetDIBits failed".to_string());
+            }
+            // GDI delivers BGRA with an unused alpha byte; convert to opaque RGBA.
+            for px in buffer.chunks_exact_mut(4) {
+                px.swap(0, 2);
+                px[3] = 0xFF;
+            }
+            Ok((width as u32, height as u32, buffer))
+        })();
+
+        let _ = SelectObject(mem_dc, prev);
+        let _ = DeleteObject(HGDIOBJ(bitmap.0));
+        let _ = DeleteDC(mem_dc);
+        result
+    }
+
+    /// Encode an RGBA buffer to a PNG file (matching `clipboard`'s encoder setup).
+    fn encode_png_file(path: &Path, width: u32, height: u32, rgba: &[u8]) -> Result<(), String> {
+        let file = std::fs::File::create(path).map_err(|e| e.to_string())?;
+        let writer = std::io::BufWriter::new(file);
+        let mut encoder = png::Encoder::new(writer, width, height);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        let mut writer = encoder.write_header().map_err(|e| e.to_string())?;
+        writer.write_image_data(rgba).map_err(|e| e.to_string())?;
+        Ok(())
+    }
+}
+
+// ── macOS backend (built-in `screencapture` CLI) ─────────────────────────────
+#[cfg(target_os = "macos")]
+mod platform {
+    //! Drives macOS's built-in `screencapture` in interactive region mode,
+    //! routing its output into the project's `screenshots/` folder. Like the Linux
+    //! backend, the tool is spawned detached — region selection blocks the *tool*,
+    //! not Eldrun — and the project's filesystem watch surfaces the new PNG. The
+    //! configured `exec` is ignored (the OS tool is always used).
+
+    use std::path::Path;
+    use std::process::{Command, Stdio};
+
+    /// Spawn `screencapture -i <file>` (interactive region capture) writing into
+    /// `dir`. `_exec` is unused on macOS.
+    pub fn capture(dir: &Path, _exec: Option<&str>) -> Result<(), String> {
+        let file = dir.join(super::screenshot_filename());
+        let mut cmd = crate::paths::command_no_window("screencapture");
+        cmd.arg("-i")
+            .arg(&file)
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        super::spawn_and_copy(cmd, dir, Some(file))
+            .map_err(|e| format!("launch screencapture: {e}"))?;
+        Ok(())
+    }
+}
+
+// ── Fallback backend (other OSes) ────────────────────────────────────────────
+// Any remaining target has no native path wired yet; capture fails with a clear
+// error rather than the crate failing to build.
+#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
+mod platform {
+    use std::path::Path;
+
+    pub fn capture(_dir: &Path, _exec: Option<&str>) -> Result<(), String> {
+        Err("screenshot capture is not supported on this platform".to_string())
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::time::Duration;
 
     #[test]
     fn filename_has_expected_shape() {
@@ -188,22 +485,85 @@ mod tests {
         assert_eq!(civil_from_days(18_993), (2022, 1, 1));
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn basename_lowercases_and_strips_dir() {
-        assert_eq!(basename("/usr/bin/Spectacle"), "spectacle");
-        assert_eq!(basename("flameshot"), "flameshot");
+        assert_eq!(platform::basename("/usr/bin/Spectacle"), "spectacle");
+        assert_eq!(platform::basename("flameshot"), "flameshot");
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn directable_matches_known_tools() {
-        assert!(is_directable("scrot"));
-        assert!(is_directable("grim"));
-        assert!(!is_directable("totally-unknown-tool"));
+        assert!(platform::is_directable("scrot"));
+        assert!(platform::is_directable("grim"));
+        assert!(!platform::is_directable("totally-unknown-tool"));
+    }
+
+    /// The directed-output case: the tool's file is taken when it exists, and a
+    /// cancelled capture (no file) yields nothing rather than an older shot.
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    #[test]
+    fn locate_shot_uses_the_expected_path_when_written() {
+        let dir = tempfile::tempdir().unwrap();
+        let stale = dir.path().join("Screenshot-20200101-000000.png");
+        std::fs::write(&stale, b"old").unwrap();
+        let expected = dir.path().join("Screenshot-20260101-000000.png");
+        let since = SystemTime::now() - SHOT_WAIT;
+
+        assert_eq!(locate_shot(dir.path(), Some(&expected), since), None);
+        std::fs::write(&expected, b"new").unwrap();
+        assert_eq!(
+            locate_shot(dir.path(), Some(&expected), since),
+            Some(expected)
+        );
+    }
+
+    /// The self-naming case (flameshot): the newest PNG written since the spawn
+    /// wins, and PNGs predating it — or non-PNGs — are ignored.
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    #[test]
+    fn locate_shot_picks_the_newest_png_since_spawn() {
+        let dir = tempfile::tempdir().unwrap();
+        let old = dir.path().join("old.png");
+        std::fs::write(&old, b"old").unwrap();
+
+        // mtimes come from a coarse kernel clock that only advances on a timer
+        // tick (~1-4ms), so a file written right after a fine-grained `now()` can
+        // land *before* it and be filtered out by the `mtime >= since` cutoff. A
+        // real capture writes seconds later, so straddle the cutoff with sleeps
+        // past one tick instead of racing it.
+        std::thread::sleep(Duration::from_millis(20));
+
+        // Spawned now: anything already on disk is older than the cutoff.
+        let since = SystemTime::now();
+        assert_eq!(locate_shot(dir.path(), None, since), None);
+        std::thread::sleep(Duration::from_millis(20));
+
+        std::fs::write(dir.path().join("notes.txt"), b"txt").unwrap();
+        let shot = dir.path().join("shot.png");
+        std::fs::write(&shot, b"new").unwrap();
+        assert_eq!(locate_shot(dir.path(), None, since), Some(shot));
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn capture_command_reports_the_file_it_directs() {
+        let dir = std::path::Path::new("/tmp/eldrun-shots");
+        let (_, expected) = platform::capture_command("scrot", dir).unwrap();
+        let expected = expected.expect("scrot is directed at an explicit file");
+        assert_eq!(expected.parent(), Some(dir));
+        assert!(expected.extension().is_some_and(|e| e == "png"));
+
+        // flameshot names the file itself, so there is no path to expect.
+        let (_, expected) = platform::capture_command("flameshot", dir).unwrap();
+        assert_eq!(expected, None);
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn shell_quote_escapes_single_quotes() {
-        assert_eq!(shell_quote("/a/b.png"), "'/a/b.png'");
-        assert_eq!(shell_quote("/o'dir/x.png"), r"'/o'\''dir/x.png'");
+        assert_eq!(platform::shell_quote("/a/b.png"), "'/a/b.png'");
+        assert_eq!(platform::shell_quote("/o'dir/x.png"), r"'/o'\''dir/x.png'");
     }
 }
diff --git a/src-tauri/src/commands/search.rs b/src-tauri/src/commands/search.rs
new file mode 100644
index 0000000..f4ab062
--- /dev/null
+++ b/src-tauri/src/commands/search.rs
@@ -0,0 +1,322 @@
+//! Project-wide literal content search (Group: new viewers / project search).
+//!
+//! `project_search` walks a project tree (reusing the safe-walk idiom from
+//! `commands::fs::collect_project_paths`: recursive `read_dir`, skipped vendor
+//! dirs, no symlink-following, a hard depth cap) and reports every line that
+//! contains the query as a literal substring. There is no regex in v1.
+//!
+//! The walk is pure Rust — `rg` is intentionally NOT depended upon (it is not on
+//! PATH in the build sandbox), so the literal walker below is the only
+//! implementation and is exactly what the tests exercise.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// One matching line. `line`/`col` are 1-based; `col` is the char column of the
+/// first occurrence of the query in `text`.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct SearchMatch {
+    /// Absolute path to the file containing the match.
+    pub path: String,
+    /// Project-relative path (forward-slash separated) for display.
+    pub rel: String,
+    pub line: u32,
+    pub col: u32,
+    /// The full text of the matching line (trailing newline stripped).
+    pub text: String,
+}
+
+/// Hard cap on recursive scan depth — mirrors `fs::MAX_SCAN_DEPTH`. Guards
+/// against pathological trees even though symlinks are not followed.
+const MAX_SCAN_DEPTH: usize = 64;
+
+/// Largest file we will read into memory for scanning.
+const MAX_FILE_BYTES: u64 = 8 * 1024 * 1024; // 8 MiB
+
+/// How many leading bytes to sniff for a NUL byte (binary detection).
+const BINARY_SNIFF_BYTES: usize = 8 * 1024; // 8 KiB
+
+/// Default result cap when the caller does not supply one.
+const DEFAULT_MAX_RESULTS: usize = 500;
+
+/// Vendor/build directories never worth searching. Mirrors
+/// `fs::should_skip_ending_scan_dir`.
+fn should_skip_dir(name: &str) -> bool {
+    matches!(
+        name,
+        ".git" | ".eldrun" | "node_modules" | "target" | "dist" | "build" | ".next" | ".cache"
+    )
+}
+
+/// True when `bytes` looks like binary content (contains a NUL byte).
+fn looks_binary(bytes: &[u8]) -> bool {
+    bytes.iter().take(BINARY_SNIFF_BYTES).any(|&b| b == 0)
+}
+
+/// Find the 1-based char column of the first occurrence of `needle` in `hay`,
+/// honouring case sensitivity. Returns `None` when absent.
+fn first_match_col(hay: &str, needle: &str, case_sensitive: bool) -> Option<u32> {
+    let byte_idx = if case_sensitive {
+        hay.find(needle)
+    } else {
+        // Case-insensitive: lower-case both sides. The byte index into the
+        // lower-cased haystack maps back to a char column because lower-casing
+        // is done per the original char order; we recompute the column by
+        // counting chars of the original string up to the matched char count.
+        let hay_l = hay.to_lowercase();
+        let needle_l = needle.to_lowercase();
+        hay_l.find(&needle_l).map(|lower_idx| {
+            // Count chars in the lower-cased prefix; that char count is also the
+            // char count of the original prefix (lower-casing preserves char
+            // order, though not necessarily byte length per char).
+            let char_count = hay_l[..lower_idx].chars().count();
+            // Convert that char count back to a byte index into the ORIGINAL
+            // string so the shared mapping below works uniformly.
+            hay.char_indices()
+                .nth(char_count)
+                .map(|(b, _)| b)
+                .unwrap_or(hay.len())
+        })
+    }?;
+    // Convert a byte index in `hay` to a 1-based char column.
+    let col = hay[..byte_idx].chars().count() as u32 + 1;
+    Some(col)
+}
+
+/// Scan a single file's contents, appending matches. `out` is bounded by
+/// `max_results`; returns once the cap is hit.
+fn scan_file(
+    path: &Path,
+    rel: &str,
+    query: &str,
+    case_sensitive: bool,
+    max_results: usize,
+    out: &mut Vec<SearchMatch>,
+) {
+    let meta = match fs::metadata(path) {
+        Ok(m) => m,
+        Err(_) => return,
+    };
+    if meta.len() > MAX_FILE_BYTES {
+        return;
+    }
+    let bytes = match fs::read(path) {
+        Ok(b) => b,
+        Err(_) => return,
+    };
+    if looks_binary(&bytes) {
+        return;
+    }
+    let content = String::from_utf8_lossy(&bytes);
+    let path_str = path.to_string_lossy().to_string();
+    for (i, raw_line) in content.lines().enumerate() {
+        if out.len() >= max_results {
+            return;
+        }
+        if let Some(col) = first_match_col(raw_line, query, case_sensitive) {
+            out.push(SearchMatch {
+                path: path_str.clone(),
+                rel: rel.to_string(),
+                line: i as u32 + 1,
+                col,
+                text: raw_line.to_string(),
+            });
+        }
+    }
+}
+
+/// Recursively walk `dir`, scanning files for `query`. Confined to `root`.
+fn walk(
+    root: &Path,
+    dir: &Path,
+    rel_dir: &str,
+    depth: usize,
+    query: &str,
+    case_sensitive: bool,
+    max_results: usize,
+    out: &mut Vec<SearchMatch>,
+) {
+    if out.len() >= max_results || depth >= MAX_SCAN_DEPTH {
+        return;
+    }
+    // Confinement: never escape the canonicalized root.
+    if !dir.starts_with(root) {
+        return;
+    }
+    let entries = match fs::read_dir(dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+    for entry in entries.flatten() {
+        if out.len() >= max_results {
+            return;
+        }
+        let name = entry.file_name().to_string_lossy().to_string();
+        let path = entry.path();
+        let rel = if rel_dir.is_empty() {
+            name.clone()
+        } else {
+            format!("{rel_dir}/{name}")
+        };
+        // `entry.file_type()` does NOT follow symlinks; a symlinked directory is
+        // reported as a non-directory, so a symlinked dir never recurses (and a
+        // self-referential symlink cannot loop).
+        let is_dir = entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false);
+        if is_dir {
+            if should_skip_dir(&name) {
+                continue;
+            }
+            walk(
+                root,
+                &path,
+                &rel,
+                depth + 1,
+                query,
+                case_sensitive,
+                max_results,
+                out,
+            );
+        } else {
+            // Skip symlinks to files too (file_type reports symlink, not file).
+            if entry.file_type().map(|ft| ft.is_file()).unwrap_or(false) {
+                scan_file(&path, &rel, query, case_sensitive, max_results, out);
+            }
+        }
+    }
+}
+
+/// Literal, project-confined content search. Returns up to `max_results`
+/// matching lines (default 500). Vendor/build dirs, binary files, and oversized
+/// files are skipped; symlinks are not followed.
+#[tauri::command]
+pub fn project_search(
+    project_dir: String,
+    query: String,
+    case_sensitive: bool,
+    max_results: Option<usize>,
+) -> Result<Vec<SearchMatch>, String> {
+    if query.is_empty() {
+        return Ok(Vec::new());
+    }
+    let cap = max_results.unwrap_or(DEFAULT_MAX_RESULTS).max(1);
+    let root_raw = PathBuf::from(&project_dir);
+    let root = root_raw
+        .canonicalize()
+        .map_err(|e| format!("invalid project_dir '{project_dir}': {e}"))?;
+    if !root.is_dir() {
+        return Err(format!("project_dir '{project_dir}' is not a directory"));
+    }
+    let mut out = Vec::new();
+    walk(&root, &root, "", 0, &query, case_sensitive, cap, &mut out);
+    Ok(out)
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::tempdir;
+
+    fn rels(matches: &[SearchMatch]) -> Vec<&str> {
+        matches.iter().map(|m| m.rel.as_str()).collect()
+    }
+
+    #[test]
+    fn finds_matches_with_line_and_col() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("a.txt"), "hello world\nsecond NEEDLE here\nplain\n").unwrap();
+        fs::write(root.join("b.rs"), "fn main() { let needle = 1; }\n").unwrap();
+
+        let matches =
+            project_search(root.to_string_lossy().to_string(), "NEEDLE".into(), true, None)
+                .unwrap();
+
+        assert_eq!(matches.len(), 1, "only the case-sensitive line matches");
+        let m = &matches[0];
+        assert_eq!(m.rel, "a.txt");
+        assert_eq!(m.line, 2);
+        // "second " is 7 chars, so NEEDLE starts at char column 8.
+        assert_eq!(m.col, 8);
+        assert!(m.text.contains("NEEDLE"));
+        assert!(m.path.ends_with("a.txt"));
+    }
+
+    #[test]
+    fn case_insensitive_matches_both() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("a.txt"), "second NEEDLE here\n").unwrap();
+        fs::write(root.join("b.rs"), "let needle = 1;\n").unwrap();
+
+        let matches = project_search(
+            root.to_string_lossy().to_string(),
+            "needle".into(),
+            false,
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(matches.len(), 2, "both files match case-insensitively");
+        // b.rs: "let " = 4 chars, needle at column 5.
+        let b = matches.iter().find(|m| m.rel == "b.rs").unwrap();
+        assert_eq!(b.col, 5);
+        assert_eq!(b.line, 1);
+    }
+
+    #[test]
+    fn skips_node_modules_and_binary_files() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("keep.txt"), "find QUERYME here\n").unwrap();
+
+        let nm = root.join("node_modules").join("pkg");
+        fs::create_dir_all(&nm).unwrap();
+        fs::write(nm.join("dep.js"), "QUERYME in vendored code\n").unwrap();
+
+        // Binary file with a NUL byte that also contains the literal text.
+        fs::write(root.join("blob.bin"), b"QUERYME\x00binary\n").unwrap();
+
+        let matches = project_search(
+            root.to_string_lossy().to_string(),
+            "QUERYME".into(),
+            true,
+            None,
+        )
+        .unwrap();
+
+        let found = rels(&matches);
+        assert_eq!(found, vec!["keep.txt"], "node_modules + binary excluded");
+    }
+
+    #[test]
+    fn honours_max_results() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        // 10 lines, each containing the query.
+        let body: String = (0..10).map(|i| format!("line {i} HIT\n")).collect();
+        fs::write(root.join("many.txt"), body).unwrap();
+
+        let matches = project_search(
+            root.to_string_lossy().to_string(),
+            "HIT".into(),
+            true,
+            Some(3),
+        )
+        .unwrap();
+
+        assert_eq!(matches.len(), 3, "result cap honoured");
+    }
+
+    #[test]
+    fn empty_query_returns_empty() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(root.join("a.txt"), "anything\n").unwrap();
+        let matches =
+            project_search(root.to_string_lossy().to_string(), "".into(), true, None).unwrap();
+        assert!(matches.is_empty());
+    }
+}
diff --git a/src-tauri/src/commands/settings.rs b/src-tauri/src/commands/settings.rs
index 702504f..2b7905a 100644
--- a/src-tauri/src/commands/settings.rs
+++ b/src-tauri/src/commands/settings.rs
@@ -1,13 +1,32 @@
+use crate::schema::settings::WindowState;
 use crate::schema::Settings;
 use crate::storage;
 
 #[tauri::command]
 pub fn get_settings() -> Result<Settings, String> {
     let path = storage::state_dir().join("settings.json");
-    if !path.exists() {
-        return Ok(Settings::default());
+    let mut settings = if path.exists() {
+        storage::read_json(&path).map_err(|e| e.to_string())?
+    } else {
+        Settings::default()
+    };
+    // Seed platform-appropriate global apps when none are configured. The
+    // global-app toolbar only renders roles that have an entry, so a fresh
+    // install (no `global_apps` in settings.json) shows an empty bar. On Linux
+    // these were historically seeded by the legacy app; on Windows nothing
+    // populated them, leaving the toolbar blank. Detection runs at read time and
+    // is not persisted, so the bar appears immediately; the first edit in the
+    // Global Apps settings panel writes the merged set back to disk.
+    if settings
+        .global_apps
+        .as_ref()
+        .map_or(true, |apps| apps.is_empty())
+    {
+        if let Some(defaults) = default_global_apps() {
+            settings.global_apps = Some(defaults);
+        }
     }
-    storage::read_json(&path).map_err(|e| e.to_string())
+    Ok(settings)
 }
 
 #[tauri::command]
@@ -15,3 +34,231 @@ pub fn save_settings(settings: Settings) -> Result<(), String> {
     let path = storage::state_dir().join("settings.json");
     storage::write_json(&path, &settings).map_err(|e| e.to_string())
 }
+
+/// Persist only the main window's geometry, leaving every other setting on disk
+/// untouched.
+///
+/// Deliberately NOT routed through `save_settings`: the frontend's
+/// `updateSettings` writes the *whole* settings object back from its in-memory
+/// cache, and this is called on a debounce every time the user drags or resizes
+/// the window. Going through the full object would rewrite the entire
+/// user-facing settings file on every window nudge, and would clobber any setting
+/// changed elsewhere since the cache was filled. Read-modify-write of the single
+/// field here keeps a window drag from ever touching an unrelated setting.
+#[tauri::command]
+pub fn save_window_state(state: WindowState) -> Result<(), String> {
+    let path = storage::state_dir().join("settings.json");
+    let mut settings: Settings = if path.exists() {
+        storage::read_json(&path).map_err(|e| e.to_string())?
+    } else {
+        Settings::default()
+    };
+    settings.window_state = Some(state);
+    storage::write_json(&path, &settings).map_err(|e| e.to_string())
+}
+
+/// Detect installed apps for the global-app toolbar roles on the current
+/// platform. Only roles whose executable actually resolves are returned, so the
+/// seeded buttons always launch something. Returns `None` when nothing is
+/// detected (e.g. unsupported platform), leaving the toolbar empty as before.
+fn default_global_apps()
+-> Option<std::collections::HashMap<String, crate::schema::settings::GlobalAppEntry>> {
+    #[cfg(target_os = "windows")]
+    {
+        detect_windows_global_apps()
+    }
+    #[cfg(target_os = "macos")]
+    {
+        detect_macos_global_apps()
+    }
+    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+    {
+        None
+    }
+}
+
+/// First existing path among `candidates`, or `None`. Used to pick the
+/// best-available executable for a role across install locations.
+#[cfg(any(target_os = "windows", target_os = "macos"))]
+fn first_existing(candidates: &[String]) -> Option<String> {
+    candidates
+        .iter()
+        .find(|p| !p.is_empty() && std::path::Path::new(p).exists())
+        .cloned()
+}
+
+/// Build a `\\`-joined path under an environment-variable-rooted directory,
+/// returning an empty string when the variable is unset so the candidate is
+/// skipped by [`first_existing`].
+#[cfg(target_os = "windows")]
+fn env_join(var: &str, tail: &str) -> String {
+    match std::env::var(var) {
+        Ok(root) if !root.is_empty() => format!("{root}\\{tail}"),
+        _ => String::new(),
+    }
+}
+
+/// Probe well-known install locations for the common global-app roles on
+/// Windows. Always-present system tools (Explorer, Notepad, Task Manager) are
+/// effectively guaranteed, so the toolbar is never empty; browser/mail/etc. are
+/// included only when found.
+#[cfg(target_os = "windows")]
+fn detect_windows_global_apps()
+-> Option<std::collections::HashMap<String, crate::schema::settings::GlobalAppEntry>> {
+    use crate::schema::settings::GlobalAppEntry;
+    use std::collections::HashMap;
+
+    // role -> ordered candidate executable paths (first existing wins).
+    let candidates: [(&str, Vec<String>); 8] = [
+        (
+            "browser",
+            vec![
+                env_join("ProgramFiles", "Google\\Chrome\\Application\\chrome.exe"),
+                env_join(
+                    "ProgramFiles(x86)",
+                    "Google\\Chrome\\Application\\chrome.exe",
+                ),
+                env_join("ProgramFiles", "Mozilla Firefox\\firefox.exe"),
+                env_join("ProgramFiles(x86)", "Mozilla Firefox\\firefox.exe"),
+                env_join("ProgramFiles(x86)", "Microsoft\\Edge\\Application\\msedge.exe"),
+                env_join("ProgramFiles", "Microsoft\\Edge\\Application\\msedge.exe"),
+            ],
+        ),
+        ("file_manager", vec![env_join("WINDIR", "explorer.exe")]),
+        ("notes", vec![env_join("WINDIR", "System32\\notepad.exe")]),
+        (
+            "system_monitor",
+            vec![env_join("WINDIR", "System32\\Taskmgr.exe")],
+        ),
+        (
+            "screenshot",
+            vec![env_join("WINDIR", "System32\\SnippingTool.exe")],
+        ),
+        (
+            "media_player",
+            vec![
+                env_join("ProgramFiles(x86)", "Windows Media Player\\wmplayer.exe"),
+                env_join("ProgramFiles", "Windows Media Player\\wmplayer.exe"),
+            ],
+        ),
+        (
+            "mail",
+            vec![
+                env_join("ProgramFiles", "Microsoft Office\\root\\Office16\\OUTLOOK.EXE"),
+                env_join(
+                    "ProgramFiles(x86)",
+                    "Microsoft Office\\root\\Office16\\OUTLOOK.EXE",
+                ),
+            ],
+        ),
+        (
+            "password_manager",
+            vec![
+                env_join("ProgramFiles", "KeePassXC\\KeePassXC.exe"),
+                env_join("ProgramFiles(x86)", "KeePass Password Safe 2\\KeePass.exe"),
+            ],
+        ),
+    ];
+
+    let detected: HashMap<String, GlobalAppEntry> = candidates
+        .into_iter()
+        .filter_map(|(role, paths)| {
+            first_existing(&paths).map(|exec| {
+                (
+                    role.to_string(),
+                    GlobalAppEntry {
+                        exec,
+                        visible: true,
+                        extra: HashMap::new(),
+                    },
+                )
+            })
+        })
+        .collect();
+
+    if detected.is_empty() {
+        None
+    } else {
+        Some(detected)
+    }
+}
+
+/// Seed the global-app toolbar with stock macOS apps for the common roles. Each
+/// `exec` points at the launchable binary inside the bundle's `Contents/MacOS/`
+/// (not the `.app` path) so the existing `Command::new(exec)` launch path works.
+/// Roles whose app is absent (e.g. iTerm) are skipped; the toolbar is never empty
+/// on a stock install since Safari/Finder/Mail are always present.
+#[cfg(target_os = "macos")]
+fn detect_macos_global_apps()
+-> Option<std::collections::HashMap<String, crate::schema::settings::GlobalAppEntry>> {
+    use crate::schema::settings::GlobalAppEntry;
+    use std::collections::HashMap;
+
+    // role -> ordered candidate executable paths (first existing wins).
+    let candidates: [(&str, Vec<String>); 7] = [
+        (
+            "browser",
+            vec![
+                "/Applications/Safari.app/Contents/MacOS/Safari".to_string(),
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome".to_string(),
+                "/Applications/Firefox.app/Contents/MacOS/firefox".to_string(),
+            ],
+        ),
+        (
+            "mail",
+            vec!["/System/Applications/Mail.app/Contents/MacOS/Mail".to_string()],
+        ),
+        (
+            "file_manager",
+            vec!["/System/Library/CoreServices/Finder.app/Contents/MacOS/Finder".to_string()],
+        ),
+        (
+            "system_monitor",
+            vec![
+                "/System/Applications/Utilities/Activity Monitor.app/Contents/MacOS/Activity Monitor"
+                    .to_string(),
+            ],
+        ),
+        (
+            "notes",
+            vec!["/System/Applications/Notes.app/Contents/MacOS/Notes".to_string()],
+        ),
+        (
+            "media_player",
+            vec![
+                "/System/Applications/QuickTime Player.app/Contents/MacOS/QuickTime Player"
+                    .to_string(),
+                "/System/Applications/Music.app/Contents/MacOS/Music".to_string(),
+            ],
+        ),
+        (
+            "screenshot",
+            vec![
+                "/System/Applications/Utilities/Screenshot.app/Contents/MacOS/Screenshot"
+                    .to_string(),
+            ],
+        ),
+    ];
+
+    let detected: HashMap<String, GlobalAppEntry> = candidates
+        .into_iter()
+        .filter_map(|(role, paths)| {
+            first_existing(&paths).map(|exec| {
+                (
+                    role.to_string(),
+                    GlobalAppEntry {
+                        exec,
+                        visible: true,
+                        extra: HashMap::new(),
+                    },
+                )
+            })
+        })
+        .collect();
+
+    if detected.is_empty() {
+        None
+    } else {
+        Some(detected)
+    }
+}
diff --git a/src-tauri/src/commands/sheets.rs b/src-tauri/src/commands/sheets.rs
new file mode 100644
index 0000000..1b71312
--- /dev/null
+++ b/src-tauri/src/commands/sheets.rs
@@ -0,0 +1,116 @@
+//! Spreadsheet reader backend (Dev G).
+//!
+//! Reads `.xlsx`/`.xls`/`.xlsm` workbooks via `calamine` and returns a single
+//! sheet as a rectangular grid of stringified cells, so the existing CSV/TSV
+//! `TableView` can render spreadsheets too (retires part of the deferred #51
+//! office-format gap). Bounds the row count so a huge workbook can't exhaust
+//! memory.
+
+use calamine::{open_workbook_auto, Data, Reader};
+use serde::Serialize;
+
+/// Hard cap on the number of rows returned so a huge workbook can't exhaust
+/// memory. Rows beyond this are silently dropped for v1 (the UI already has its
+/// own render window on top of this).
+const MAX_ROWS: usize = 20_000;
+
+/// A workbook read result: the names of all sheets (so the UI can offer a sheet
+/// picker) plus the rows of the selected (or first) sheet.
+#[derive(Debug, Clone, Serialize)]
+pub struct SheetData {
+    pub sheet_names: Vec<String>,
+    /// The sheet actually returned in `rows`.
+    pub active_sheet: String,
+    /// Row-major grid of stringified cells (header row included, if any).
+    pub rows: Vec<Vec<String>>,
+}
+
+/// Stringify a single spreadsheet cell. Pure so it can be unit-tested without a
+/// workbook file. Empty cells become `""`; everything else renders to a plain,
+/// CSV-like string the table viewer can display.
+fn cell_to_string(cell: &Data) -> String {
+    match cell {
+        Data::Empty => String::new(),
+        Data::String(s) => s.clone(),
+        Data::Int(i) => i.to_string(),
+        Data::Float(f) => {
+            // Render whole floats without a trailing `.0` so a column of integers
+            // stored as floats (the common xlsx case) reads cleanly.
+            if f.fract() == 0.0 && f.is_finite() {
+                (*f as i64).to_string()
+            } else {
+                f.to_string()
+            }
+        }
+        Data::Bool(b) => {
+            if *b {
+                "TRUE".to_string()
+            } else {
+                "FALSE".to_string()
+            }
+        }
+        // DateTime / DateTimeIso / DurationIso / Error all have a sensible Display.
+        other => other.to_string(),
+    }
+}
+
+/// Read one sheet of a spreadsheet workbook. When `sheet` is `None`, returns the
+/// first sheet.
+#[tauri::command]
+pub fn read_spreadsheet(path: String, sheet: Option<String>) -> Result<SheetData, String> {
+    let mut workbook =
+        open_workbook_auto(&path).map_err(|e| format!("Failed to open workbook: {e}"))?;
+
+    let sheet_names = workbook.sheet_names().to_vec();
+    if sheet_names.is_empty() {
+        return Err("Workbook has no sheets".to_string());
+    }
+
+    // Pick the requested sheet if present, otherwise fall back to the first.
+    let active_sheet = match sheet {
+        Some(name) if sheet_names.iter().any(|n| n == &name) => name,
+        _ => sheet_names[0].clone(),
+    };
+
+    let range = workbook
+        .worksheet_range(&active_sheet)
+        .map_err(|e| format!("Failed to read sheet '{active_sheet}': {e}"))?;
+
+    let mut rows: Vec<Vec<String>> = Vec::new();
+    for row in range.rows() {
+        if rows.len() >= MAX_ROWS {
+            break; // Truncate huge workbooks (v1); the rest is dropped.
+        }
+        rows.push(row.iter().map(cell_to_string).collect());
+    }
+
+    Ok(SheetData {
+        sheet_names,
+        active_sheet,
+        rows,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn nonexistent_path_is_err() {
+        let res = read_spreadsheet("/no/such/file/definitely-missing.xlsx".into(), None);
+        assert!(res.is_err());
+    }
+
+    #[test]
+    fn cell_to_string_maps_variants() {
+        assert_eq!(cell_to_string(&Data::Empty), "");
+        assert_eq!(cell_to_string(&Data::String("hi".into())), "hi");
+        assert_eq!(cell_to_string(&Data::Int(42)), "42");
+        // Whole floats lose the trailing `.0`.
+        assert_eq!(cell_to_string(&Data::Float(7.0)), "7");
+        // Fractional floats keep their decimals.
+        assert_eq!(cell_to_string(&Data::Float(3.5)), "3.5");
+        assert_eq!(cell_to_string(&Data::Bool(true)), "TRUE");
+        assert_eq!(cell_to_string(&Data::Bool(false)), "FALSE");
+    }
+}
diff --git a/src-tauri/src/commands/slurm.rs b/src-tauri/src/commands/slurm.rs
new file mode 100644
index 0000000..24eed0d
--- /dev/null
+++ b/src-tauri/src/commands/slurm.rs
@@ -0,0 +1,470 @@
+//! SLURM run/watch core for HPC projects (`docs/quirky-knitting-umbrella` plan).
+//!
+//! A SLURM cluster forbids real computation on the login node — everything heavy
+//! goes through the scheduler (`sbatch`/`srun`). Eldrun already connects to such a
+//! host as a remote project;
+//! this module lets the user submit/query/cancel jobs without memorizing the
+//! commands, and the frontend turns the resulting log files and interactive shells
+//! into ordinary terminal tabs (`lib/slurm.ts`).
+//!
+//! Structure mirrors `commands::python`: each command resolves `project_dir` to a
+//! remote target with `remote_target_for_dir` (threading a specific worker host via
+//! `remote_target_for_host`) and runs a POSIX-`sh` script over the pooled
+//! ControlMaster (`run_remote_script`), or the same script through a local shell for
+//! a local project (a login node that itself has SLURM).
+//!
+//! **Security.** `run_remote_script` embeds its script *verbatim* — nothing may be
+//! interpolated into it that a user controls without quoting. So every path is
+//! `shell_quote`d (the same helper `git_peer`/`ssh_exec` use) and a job id is
+//! validated numeric (`^\d+$`) before it can touch `scontrol`/`scancel`. The pure
+//! parsers (`parse_submit_jobid`, `parse_scontrol_paths`, `parse_squeue`) are
+//! unit-tested against captured sample output.
+
+use serde::{Deserialize, Serialize};
+
+use crate::services::remote::{remote_target_for_dir, remote_target_for_host, PRIMARY_HOST};
+use crate::services::ssh_exec::{run_remote_script, shell_quote};
+
+/// Whether SLURM is usable for a project's host, and its version banner.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SlurmInfo {
+    pub available: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+
+/// The result of a submit: the parsed job id plus the real output paths SLURM
+/// resolved (absolute, `%j`/`%x`-expanded), so the frontend can tail the right file.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SlurmSubmit {
+    pub job_id: String,
+    pub out_file: String,
+    pub err_file: String,
+    pub work_dir: String,
+}
+
+/// One row of `squeue`, for the Jobs view.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SlurmJob {
+    pub id: String,
+    pub name: String,
+    pub state: String,
+    pub time: String,
+    pub nodes: String,
+    pub reason: String,
+}
+
+/// Paths lifted out of `scontrol show job` output.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct ScontrolPaths {
+    pub out_file: String,
+    pub err_file: String,
+    pub work_dir: String,
+}
+
+// ── Dispatch ─────────────────────────────────────────────────────────────────
+
+/// Run `script` for `project_dir` on `host_id` and return its stdout. Remote
+/// projects run it over the pooled ControlMaster (the primary, or a named worker);
+/// a local project (a login node with SLURM) runs it through the local shell with
+/// the project dir as cwd. `host_id` defaults to the primary.
+///
+/// `pub(crate)` because `commands::hpc_ws` (workspaces) runs *its* tooling at the
+/// exact same place a job is submitted — one dispatch, so the two can never
+/// disagree about which machine "the project's host" is.
+pub(crate) fn run_slurm_script(
+    project_dir: &str,
+    host_id: &str,
+    script: &str,
+) -> Result<String, String> {
+    if let Some(primary) = remote_target_for_dir(project_dir) {
+        let target = if host_id == PRIMARY_HOST {
+            primary
+        } else {
+            remote_target_for_host(&primary.project_id, host_id)
+                .ok_or_else(|| format!("unknown remote host '{host_id}'"))?
+        };
+        // Every caller of this dispatch — `slurm_*` and `hpc_ws_*` — is a button:
+        // submit, cancel, refresh the queue, allocate a workspace. Reaching the
+        // cluster is the whole point of the click, so the dial policy is told so
+        // here, once, rather than at each of the dozen commands above it.
+        let _dial = crate::services::ssh_common::user_dial(
+            &target.spec.user,
+            &target.spec.host,
+            target.spec.port,
+        );
+        let out = run_remote_script(&target.spec, script)?;
+        if !out.status.success() && out.stdout.is_empty() {
+            return Err(String::from_utf8_lossy(&out.stderr).trim().to_string());
+        }
+        return Ok(String::from_utf8_lossy(&out.stdout).into_owned());
+    }
+    // Local project: run the same POSIX-sh script with the project dir as cwd.
+    let out = crate::paths::command_no_window("sh")
+        .arg("-c")
+        .arg(script)
+        .current_dir(project_dir)
+        .output()
+        .map_err(|e| format!("failed to run slurm command locally: {e}"))?;
+    if !out.status.success() && out.stdout.is_empty() {
+        return Err(String::from_utf8_lossy(&out.stderr).trim().to_string());
+    }
+    Ok(String::from_utf8_lossy(&out.stdout).into_owned())
+}
+
+// ── Pure parsers ─────────────────────────────────────────────────────────────
+
+/// `sbatch --parsable` prints `<jobid>` or `<jobid>;<cluster>` on its first line.
+/// Returns the numeric id, or `None` if the first non-empty line isn't one (an
+/// error message, an empty submit). Validating numeric here is also the injection
+/// guard: only a `^\d+$` id is ever spliced into `scontrol`/`scancel`.
+pub fn parse_submit_jobid(stdout: &str) -> Option<String> {
+    let line = stdout.lines().map(str::trim).find(|l| !l.is_empty())?;
+    let id = line.split(';').next().unwrap_or(line).trim();
+    if !id.is_empty() && id.bytes().all(|b| b.is_ascii_digit()) {
+        Some(id.to_string())
+    } else {
+        None
+    }
+}
+
+/// `scontrol show job <id>` emits whitespace-separated `Key=Value` tokens across
+/// several lines; we want `StdOut=`, `StdErr=`, `WorkDir=` (absolute, already
+/// `%j`/`%x`-expanded by SLURM). A value can itself contain no whitespace in
+/// practice for these path keys, so a plain token split is correct.
+pub fn parse_scontrol_paths(stdout: &str) -> ScontrolPaths {
+    let mut paths = ScontrolPaths::default();
+    for tok in stdout.split_whitespace() {
+        if let Some(v) = tok.strip_prefix("StdOut=") {
+            paths.out_file = v.to_string();
+        } else if let Some(v) = tok.strip_prefix("StdErr=") {
+            paths.err_file = v.to_string();
+        } else if let Some(v) = tok.strip_prefix("WorkDir=") {
+            paths.work_dir = v.to_string();
+        }
+    }
+    paths
+}
+
+/// Parse `squeue … -o '%i|%j|%T|%M|%D|%R'` output — one job per line, six
+/// pipe-separated fields (`%R`, the reason, may itself contain spaces but never a
+/// pipe, so `splitn(6, '|')` is safe). Blank lines are skipped.
+pub fn parse_squeue(stdout: &str) -> Vec<SlurmJob> {
+    let mut out = Vec::new();
+    for line in stdout.lines() {
+        let line = line.trim_end();
+        if line.trim().is_empty() {
+            continue;
+        }
+        let f: Vec<&str> = line.splitn(6, '|').collect();
+        if f.len() < 6 {
+            continue;
+        }
+        out.push(SlurmJob {
+            id: f[0].trim().to_string(),
+            name: f[1].trim().to_string(),
+            state: f[2].trim().to_string(),
+            time: f[3].trim().to_string(),
+            nodes: f[4].trim().to_string(),
+            reason: f[5].trim().to_string(),
+        });
+    }
+    out
+}
+
+/// Split a script path into `(dir, base)`, both empty-safe. `dir` is the parent
+/// (empty when the path is a bare file name); `base` the file name. **Absolute
+/// paths are preserved** — the frontend passes the file's absolute host/local path
+/// so the same command works for a remote project (where the viewer path is the
+/// host-absolute path) and a local one, without either side computing a rel path.
+/// Uses forward slashes (the host is POSIX). A leading `/` therefore makes `dir`
+/// absolute (`/home/a/p`), so the `cd` lands correctly regardless of cwd.
+fn split_script_rel(script_rel: &str) -> (String, String) {
+    let s = script_rel.trim().trim_end_matches('/');
+    match s.rfind('/') {
+        // Keep a lone leading slash (root file `/x`): dir = "/".
+        Some(0) => ("/".to_string(), s[1..].to_string()),
+        Some(i) => (s[..i].to_string(), s[i + 1..].to_string()),
+        None => (String::new(), s.to_string()),
+    }
+}
+
+/// The default `sbatch` output file when `scontrol` couldn't be consulted:
+/// `<work_dir>/slurm-<jobid>.out`, SLURM's own default pattern.
+fn default_out_file(work_dir: &str, job_id: &str) -> String {
+    if work_dir.is_empty() {
+        format!("slurm-{job_id}.out")
+    } else {
+        format!("{}/slurm-{job_id}.out", work_dir.trim_end_matches('/'))
+    }
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+//
+// Every command here shells out (locally or over the pooled SSH ControlMaster,
+// which can stall up to its ConnectTimeout/ServerAlive window on a dead/degraded
+// host). Tauri runs a synchronous `#[command]` on the MAIN thread, so doing that
+// work inline froze the whole window — the same bug `commands::git` already fixed
+// (see its `run_off_thread` doc comment) but that fix never reached this file.
+// Each command is now an `async` wrapper that offloads its blocking body via
+// `spawn_blocking`, so the UI thread stays free; the bodies are ordinary sync fns
+// so they stay directly callable from the unit tests below.
+
+async fn run_off_thread<T: Send + 'static>(
+    f: impl FnOnce() -> Result<T, String> + Send + 'static,
+) -> Result<T, String> {
+    tokio::task::spawn_blocking(f)
+        .await
+        .map_err(|e| format!("slurm task failed: {e}"))?
+}
+
+/// Is SLURM available on the project's host? Lets the UI hide itself off-HPC.
+#[tauri::command]
+pub async fn slurm_available(
+    project_dir: String,
+    host_id: Option<String>,
+) -> Result<SlurmInfo, String> {
+    run_off_thread(move || {
+        let host = host_id.as_deref().unwrap_or(PRIMARY_HOST);
+        // Constant script — nothing interpolated.
+        let script = "command -v sbatch >/dev/null 2>&1 || exit 0\n\
+                      sbatch --version 2>/dev/null | head -n1";
+        let out = run_slurm_script(&project_dir, host, script).unwrap_or_default();
+        let version = out.lines().next().map(str::trim).filter(|s| !s.is_empty());
+        Ok(SlurmInfo {
+            available: version.is_some(),
+            version: version.map(str::to_string),
+        })
+    })
+    .await
+}
+
+/// Submit `script_rel` (project-relative) with `sbatch`, then resolve its real
+/// output paths via `scontrol` — in one round trip: the numeric job id comes from
+/// `sbatch`'s own output, so chaining `scontrol` on it injects nothing.
+#[tauri::command]
+pub async fn slurm_submit(
+    project_dir: String,
+    script_rel: String,
+    host_id: Option<String>,
+) -> Result<SlurmSubmit, String> {
+    run_off_thread(move || {
+        let host = host_id.as_deref().unwrap_or(PRIMARY_HOST);
+        let (dir, base) = split_script_rel(&script_rel);
+        if base.is_empty() {
+            return Err("no script file given".into());
+        }
+        // cd into the script's own directory so the job's default WorkDir is where
+        // the script lives; sbatch --parsable prints the job id; scontrol (fed
+        // sbatch's own id) resolves the absolute out/err/work paths. `${jid%%;*}`
+        // strips a `;<cluster>` suffix for the scontrol lookup.
+        let cd = if dir.is_empty() {
+            String::new()
+        } else {
+            format!("cd {} && ", shell_quote(&dir))
+        };
+        let script = format!(
+            "{cd}jid=$(sbatch --parsable {base}) || exit 1\n\
+             printf '%s\\n' \"$jid\"\n\
+             scontrol show job \"${{jid%%;*}}\" 2>/dev/null",
+            base = shell_quote(&base),
+        );
+        let stdout = run_slurm_script(&project_dir, host, &script)?;
+
+        let mut lines = stdout.lines();
+        let first = lines.next().unwrap_or("").trim();
+        let job_id = parse_submit_jobid(first)
+            .ok_or_else(|| format!("sbatch did not return a job id:\n{}", stdout.trim()))?;
+        let rest: String = lines.collect::<Vec<_>>().join("\n");
+        let paths = parse_scontrol_paths(&rest);
+
+        let out_file = if paths.out_file.is_empty() {
+            default_out_file(&paths.work_dir, &job_id)
+        } else {
+            paths.out_file
+        };
+        Ok(SlurmSubmit {
+            job_id,
+            out_file,
+            err_file: paths.err_file,
+            work_dir: paths.work_dir,
+        })
+    })
+    .await
+}
+
+/// The current user's jobs on the host. `--me` (newer SLURM) with a `-u "$USER"`
+/// fallback for sites where it isn't supported. Constant script.
+#[tauri::command]
+pub async fn slurm_queue(
+    project_dir: String,
+    host_id: Option<String>,
+) -> Result<Vec<SlurmJob>, String> {
+    run_off_thread(move || {
+        let host = host_id.as_deref().unwrap_or(PRIMARY_HOST);
+        let fmt = "%i|%j|%T|%M|%D|%R";
+        let script = format!(
+            "squeue --me --noheader -o '{fmt}' 2>/dev/null || \
+             squeue -u \"$USER\" --noheader -o '{fmt}'"
+        );
+        let stdout = run_slurm_script(&project_dir, host, &script)?;
+        Ok(parse_squeue(&stdout))
+    })
+    .await
+}
+
+/// Resolve a job's stdout path via `scontrol` — for **Watch** on a job Eldrun did
+/// not submit this session (so the session store has no path for it). Returns the
+/// absolute `StdOut`, or a `slurm-<id>.out` fallback when scontrol is silent (a
+/// job that already finished). The id is validated numeric.
+///
+/// `log_dir` is the project's recorded HPC log folder
+/// (`Project.hpc.logs_dir`, `docs/hpc_workspace_plan.md`): when the pipeline
+/// routes `--output` into the home anchor, `<WorkDir>/slurm-<id>.out` is simply
+/// the wrong guess, and Watch on an older job would tail a file that never
+/// existed. Given one, it wins over `WorkDir` — but only for the *fallback*;
+/// whatever `scontrol` states still beats both, since that is what SLURM
+/// actually used.
+#[tauri::command]
+pub async fn slurm_job_out(
+    project_dir: String,
+    job_id: String,
+    host_id: Option<String>,
+    log_dir: Option<String>,
+) -> Result<String, String> {
+    run_off_thread(move || {
+        let host = host_id.as_deref().unwrap_or(PRIMARY_HOST);
+        if job_id.is_empty() || !job_id.bytes().all(|b| b.is_ascii_digit()) {
+            return Err(format!("invalid job id '{job_id}'"));
+        }
+        let stdout =
+            run_slurm_script(&project_dir, host, &format!("scontrol show job {job_id}"))?;
+        let paths = parse_scontrol_paths(&stdout);
+        if !paths.out_file.is_empty() {
+            return Ok(paths.out_file);
+        }
+        let dir = log_dir
+            .as_deref()
+            .map(str::trim)
+            .filter(|d| !d.is_empty())
+            .unwrap_or(&paths.work_dir);
+        Ok(default_out_file(dir, &job_id))
+    })
+    .await
+}
+
+/// Cancel a job. The id is validated numeric before it touches the command.
+#[tauri::command]
+pub async fn slurm_cancel(
+    project_dir: String,
+    job_id: String,
+    host_id: Option<String>,
+) -> Result<(), String> {
+    run_off_thread(move || {
+        let host = host_id.as_deref().unwrap_or(PRIMARY_HOST);
+        if job_id.is_empty() || !job_id.bytes().all(|b| b.is_ascii_digit()) {
+            return Err(format!("invalid job id '{job_id}'"));
+        }
+        run_slurm_script(&project_dir, host, &format!("scancel {job_id}"))?;
+        Ok(())
+    })
+    .await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn submit_jobid_plain_and_with_cluster_suffix() {
+        assert_eq!(parse_submit_jobid("1234567\n").as_deref(), Some("1234567"));
+        assert_eq!(
+            parse_submit_jobid("1234567;cluster\n").as_deref(),
+            Some("1234567")
+        );
+    }
+
+    #[test]
+    fn submit_jobid_rejects_error_text() {
+        assert!(parse_submit_jobid("sbatch: error: Batch job submission failed").is_none());
+        assert!(parse_submit_jobid("").is_none());
+        assert!(parse_submit_jobid("\n\n").is_none());
+    }
+
+    #[test]
+    fn scontrol_paths_are_lifted_from_tokens() {
+        let out = "JobId=1234567 JobName=train\n   \
+                   UserId=alice(1000) GroupId=alice(1000)\n   \
+                   WorkDir=/home/alice/proj StdOut=/home/alice/proj/slurm-1234567.out \
+                   StdErr=/home/alice/proj/slurm-1234567.err\n";
+        let p = parse_scontrol_paths(out);
+        assert_eq!(p.work_dir, "/home/alice/proj");
+        assert_eq!(p.out_file, "/home/alice/proj/slurm-1234567.out");
+        assert_eq!(p.err_file, "/home/alice/proj/slurm-1234567.err");
+    }
+
+    #[test]
+    fn scontrol_paths_empty_when_absent() {
+        assert_eq!(parse_scontrol_paths("JobId=1 JobName=x"), ScontrolPaths::default());
+    }
+
+    #[test]
+    fn squeue_rows_are_parsed() {
+        let out = "42|train.slurm|RUNNING|1:23|2|(None)\n\
+                   43|prep|PENDING|0:00|1|(Priority)\n\n";
+        let jobs = parse_squeue(out);
+        assert_eq!(jobs.len(), 2);
+        assert_eq!(jobs[0].id, "42");
+        assert_eq!(jobs[0].name, "train.slurm");
+        assert_eq!(jobs[0].state, "RUNNING");
+        assert_eq!(jobs[0].nodes, "2");
+        assert_eq!(jobs[0].reason, "(None)");
+        assert_eq!(jobs[1].state, "PENDING");
+        assert_eq!(jobs[1].reason, "(Priority)");
+    }
+
+    #[test]
+    fn squeue_reason_with_spaces_survives() {
+        // %R can be a multi-word reason; splitn(6) keeps it whole.
+        let jobs = parse_squeue("7|j|PENDING|0:00|1|(Resources not available)\n");
+        assert_eq!(jobs[0].reason, "(Resources not available)");
+    }
+
+    #[test]
+    fn squeue_short_lines_skipped() {
+        assert!(parse_squeue("garbage\n1|2|3\n").is_empty());
+    }
+
+    #[test]
+    fn split_script_rel_variants() {
+        assert_eq!(split_script_rel("train.slurm"), ("".into(), "train.slurm".into()));
+        assert_eq!(
+            split_script_rel("jobs/train.slurm"),
+            ("jobs".into(), "train.slurm".into())
+        );
+        assert_eq!(
+            split_script_rel("a/b/c.slurm"),
+            ("a/b".into(), "c.slurm".into())
+        );
+    }
+
+    #[test]
+    fn split_script_rel_keeps_absolute_paths() {
+        // The frontend passes the file's absolute path; the leading slash must
+        // survive so the `cd` is absolute (host-agnostic between remote/local).
+        assert_eq!(
+            split_script_rel("/home/alice/proj/train.slurm"),
+            ("/home/alice/proj".into(), "train.slurm".into())
+        );
+        assert_eq!(split_script_rel("/train.slurm"), ("/".into(), "train.slurm".into()));
+    }
+
+    #[test]
+    fn default_out_file_follows_slurm_pattern() {
+        assert_eq!(
+            default_out_file("/home/alice/proj", "42"),
+            "/home/alice/proj/slurm-42.out"
+        );
+        assert_eq!(default_out_file("", "42"), "slurm-42.out");
+    }
+}
diff --git a/src-tauri/src/commands/sqlite.rs b/src-tauri/src/commands/sqlite.rs
new file mode 100644
index 0000000..063ab13
--- /dev/null
+++ b/src-tauri/src/commands/sqlite.rs
@@ -0,0 +1,181 @@
+//! SQLite database browser backend (Dev C).
+//!
+//! Read-only inspection of a `.db`/`.sqlite`/`.sqlite3` file: list its user
+//! tables and page through a single table's rows. Opens the database in
+//! read-only mode (never mutates the file) and bounds every result so a huge
+//! table can't exhaust memory. All values are stringified for transport to the
+//! webview table grid.
+
+use rusqlite::types::ValueRef;
+use rusqlite::{Connection, OpenFlags};
+use serde::Serialize;
+
+/// One page of rows from a table, plus its column names.
+#[derive(Debug, Clone, Serialize)]
+pub struct SqlitePage {
+    pub columns: Vec<String>,
+    /// Each row is a vector of stringified cell values, column-aligned.
+    pub rows: Vec<Vec<String>>,
+    /// Total row count of the table (so the UI can show "showing N of M").
+    pub total: i64,
+}
+
+/// The query that enumerates the user tables/views we're willing to expose.
+/// Reused by `sqlite_tables` and by `sqlite_page` to validate the table name.
+const LIST_TABLES_SQL: &str = "SELECT name FROM sqlite_master \
+     WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' ORDER BY name";
+
+/// Open the database file strictly read-only — never create or modify it.
+fn open_readonly(path: &str) -> Result<Connection, String> {
+    Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY)
+        .map_err(|e| e.to_string())
+}
+
+/// Run `LIST_TABLES_SQL` against an open connection, returning the names.
+fn list_tables(conn: &Connection) -> Result<Vec<String>, String> {
+    let mut stmt = conn.prepare(LIST_TABLES_SQL).map_err(|e| e.to_string())?;
+    let names = stmt
+        .query_map([], |row| row.get::<_, String>(0))
+        .map_err(|e| e.to_string())?
+        .collect::<Result<Vec<String>, _>>()
+        .map_err(|e| e.to_string())?;
+    Ok(names)
+}
+
+/// Quote an identifier for safe interpolation: wrap in double quotes and double
+/// any embedded double quote. Only ever applied to a name already validated
+/// against the allow-list, but quoting defensively keeps the SQL well-formed.
+fn quote_ident(name: &str) -> String {
+    format!("\"{}\"", name.replace('"', "\"\""))
+}
+
+/// Stringify one cell value for transport to the webview grid.
+fn stringify(value: ValueRef<'_>) -> String {
+    match value {
+        ValueRef::Null => String::new(),
+        ValueRef::Integer(i) => i.to_string(),
+        ValueRef::Real(f) => f.to_string(),
+        ValueRef::Text(bytes) => String::from_utf8_lossy(bytes).into_owned(),
+        ValueRef::Blob(bytes) => format!("<blob {} bytes>", bytes.len()),
+    }
+}
+
+/// List the user tables (and views) in a SQLite database file, sorted by name.
+#[tauri::command]
+pub fn sqlite_tables(path: String) -> Result<Vec<String>, String> {
+    let conn = open_readonly(&path)?;
+    list_tables(&conn)
+}
+
+/// Read up to `limit` rows from `table`, starting at `offset`.
+#[tauri::command]
+pub fn sqlite_page(
+    path: String,
+    table: String,
+    limit: u32,
+    offset: u32,
+) -> Result<SqlitePage, String> {
+    let conn = open_readonly(&path)?;
+
+    // SECURITY: a table identifier cannot be a bound parameter, so validate it
+    // against the allow-list of real tables/views before interpolating. This
+    // blocks SQL injection through the `table` argument.
+    let allowed = list_tables(&conn)?;
+    if !allowed.iter().any(|t| t == &table) {
+        return Err(format!("unknown table: {table}"));
+    }
+    let quoted = quote_ident(&table);
+
+    // Total row count of the table (drives the UI's "rows X–Y of N").
+    let total: i64 = conn
+        .query_row(&format!("SELECT COUNT(*) FROM {quoted}"), [], |row| {
+            row.get(0)
+        })
+        .map_err(|e| e.to_string())?;
+
+    let sql = format!("SELECT * FROM {quoted} LIMIT ?1 OFFSET ?2");
+    let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
+    // Column names must be cloned before stepping (they borrow the statement).
+    let columns: Vec<String> = stmt.column_names().iter().map(|c| c.to_string()).collect();
+    let col_count = columns.len();
+
+    let mut query_rows = stmt
+        .query(rusqlite::params![limit, offset])
+        .map_err(|e| e.to_string())?;
+    let mut rows: Vec<Vec<String>> = Vec::new();
+    while let Some(row) = query_rows.next().map_err(|e| e.to_string())? {
+        let mut cells = Vec::with_capacity(col_count);
+        for i in 0..col_count {
+            let value = row.get_ref(i).map_err(|e| e.to_string())?;
+            cells.push(stringify(value));
+        }
+        rows.push(cells);
+    }
+
+    Ok(SqlitePage {
+        columns,
+        rows,
+        total,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rusqlite::Connection;
+
+    /// Build a small on-disk SQLite fixture and return its path (kept alive by
+    /// the returned `TempDir`).
+    fn fixture() -> (tempfile::TempDir, String) {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("test.db");
+        let path_str = path.to_string_lossy().into_owned();
+        let conn = Connection::open(&path).unwrap();
+        conn.execute_batch(
+            "CREATE TABLE people (id INTEGER PRIMARY KEY, name TEXT, score REAL);
+             INSERT INTO people (id, name, score) VALUES (1, 'Ada', 9.5);
+             INSERT INTO people (id, name, score) VALUES (2, 'Linus', NULL);
+             CREATE VIEW high AS SELECT * FROM people WHERE score >= 9.0;",
+        )
+        .unwrap();
+        drop(conn);
+        (dir, path_str)
+    }
+
+    #[test]
+    fn lists_tables_and_views() {
+        let (_dir, path) = fixture();
+        let tables = sqlite_tables(path).unwrap();
+        // Sorted by name; view + table, no sqlite_* internals.
+        assert_eq!(tables, vec!["high".to_string(), "people".to_string()]);
+    }
+
+    #[test]
+    fn pages_rows_with_columns_and_total() {
+        let (_dir, path) = fixture();
+        let page = sqlite_page(path, "people".to_string(), 100, 0).unwrap();
+        assert_eq!(page.columns, vec!["id", "name", "score"]);
+        assert_eq!(page.total, 2);
+        assert_eq!(page.rows.len(), 2);
+        assert_eq!(page.rows[0], vec!["1", "Ada", "9.5"]);
+        // NULL stringifies to empty; integer/real to their decimal forms.
+        assert_eq!(page.rows[1], vec!["2", "Linus", ""]);
+    }
+
+    #[test]
+    fn paginates_with_limit_and_offset() {
+        let (_dir, path) = fixture();
+        let page = sqlite_page(path, "people".to_string(), 1, 1).unwrap();
+        assert_eq!(page.total, 2);
+        assert_eq!(page.rows.len(), 1);
+        assert_eq!(page.rows[0][0], "2");
+    }
+
+    #[test]
+    fn rejects_unknown_table() {
+        let (_dir, path) = fixture();
+        let err = sqlite_page(path, "people; DROP TABLE people".to_string(), 10, 0)
+            .unwrap_err();
+        assert!(err.contains("unknown table"), "got: {err}");
+    }
+}
diff --git a/src-tauri/src/commands/ssh.rs b/src-tauri/src/commands/ssh.rs
index 91c1f8b..75d95b9 100644
--- a/src-tauri/src/commands/ssh.rs
+++ b/src-tauri/src/commands/ssh.rs
@@ -6,17 +6,14 @@
 //! passed as separate argv items, and we reject values that could be mistaken
 //! for `ssh`/`ls` options (a leading `-`) or that contain control characters.
 
-use std::path::PathBuf;
 use std::process::Command;
 
 use serde::Serialize;
 
-use crate::schema::project::Project;
-use crate::schema::projects::ProjectsList;
-use crate::storage;
-// The validation + base-argv helpers live in `services::ssh_mount` so the
-// `ssh` and `sshfs` commands share a single validated implementation.
-use crate::services::ssh_mount::{self, ssh_base_args, ssh_target, sshpass_available, validate_arg};
+// The validation + base-argv helpers live in `services::ssh_common` so every
+// remote path shares a single validated implementation.
+use crate::services::sftp;
+use crate::services::ssh_common::{ssh_base_args, ssh_password_base_args};
 
 /// One entry in a remote directory listing.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
@@ -27,15 +24,19 @@ pub struct RemoteEntry {
 
 /// Availability of the external binaries remote projects rely on, so the UI can
 /// warn the moment the "Remote (SSH) project" checkbox is enabled instead of
-/// only surfacing a failure after the user tries to connect/mount.
+/// only surfacing a failure after the user tries to connect. Remote projects are
+/// SSH/SFTP-native (no FUSE mount), so only `sshpass`/`openvpn` are relevant.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 pub struct SshTooling {
-    /// `sshfs` — required to mount a remote project locally.
-    pub sshfs: bool,
-    /// `sshpass` — required only for password auth (key/agent auth needs none).
-    pub sshpass: bool,
+    /// Whether non-interactive password auth works without the user installing
+    /// anything. Always true on Unix (OpenSSH's own `SSH_ASKPASS` carries it);
+    /// on Windows it still depends on `sshpass` being present.
+    pub password_auth: bool,
     /// `openvpn` + `pkexec` — required only for VPN-gated hosts.
     pub openvpn: bool,
+    /// `rsync` on the LOCAL machine — enables the SSH-sync bulk fast-path (the
+    /// SFTP-native floor is always used when it (or the host's rsync) is missing).
+    pub rsync: bool,
 }
 
 /// Report which remote-project tools are present on `PATH`. Called when the
@@ -43,337 +44,867 @@ pub struct SshTooling {
 #[tauri::command]
 pub fn ssh_tooling_status() -> SshTooling {
     SshTooling {
-        sshfs: ssh_mount::sshfs_available(),
-        sshpass: sshpass_available(),
+        password_auth: crate::services::ssh_common::password_auth_available(),
         openvpn: crate::services::openvpn::openvpn_available(),
+        rsync: crate::services::remote_sync::rsync_available_local(),
     }
 }
 
+/// What the fingerprint-confirmation dialog shows for a host Eldrun has never
+/// connected to. `scan` is the raw known_hosts text behind `keys` and is handed
+/// straight back to [`ssh_trust_host_key`], so what gets stored is exactly what
+/// was shown — a re-scan at accept time would leave a window for a different key.
+#[derive(Debug, Clone, Serialize)]
+pub struct HostKeyPreview {
+    /// Resolved `host:port` (after `~/.ssh/config`), so the dialog names the
+    /// machine the key actually belongs to rather than the alias typed.
+    pub target: String,
+    /// True when the key is already in known_hosts — the dialog then has nothing
+    /// to ask and the caller can proceed straight to connecting.
+    pub known: bool,
+    pub keys: Vec<crate::services::ssh_common::HostKeyFingerprint>,
+    /// Opaque known_hosts lines to pass back to `ssh_trust_host_key`.
+    pub scan: String,
+}
+
+/// Fetch the SSH host keys a host currently offers, so the user can verify the
+/// fingerprint before a password is sent to it (see
+/// `ssh_common::guard_first_contact`). Async + `spawn_blocking`: `ssh-keyscan`
+/// talks to the network and would otherwise freeze the window.
+#[tauri::command]
+pub async fn ssh_host_key_preview(
+    host: String,
+    port: Option<u16>,
+) -> Result<HostKeyPreview, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        use crate::services::ssh_common as sc;
+        let (resolved, resolved_port) = sc::resolve_host_port(&host, port);
+        let known = sc::host_key_known(&resolved, resolved_port);
+        let (scan, keys) = sc::scan_host_keys(&host, port)?;
+        Ok(HostKeyPreview {
+            target: format!("{resolved}:{resolved_port}"),
+            known,
+            keys,
+            scan,
+        })
+    })
+    .await
+    .map_err(|e| format!("host key preview failed: {e}"))?
+}
+
+/// Record the user's acceptance of the keys `ssh_host_key_preview` showed, by
+/// appending them to `~/.ssh/known_hosts`. This is the *only* thing that clears
+/// the first-contact gate, and it exists solely to be reachable from a click — no
+/// launch or background path may call it.
+#[tauri::command]
+pub fn ssh_trust_host_key(scan: String) -> Result<(), String> {
+    crate::services::ssh_common::trust_host_key(&scan)
+}
+
+/// Most-recently-used SSH addresses to keep. Old entries past this fall off.
+const SSH_ADDRESS_CAP: usize = 20;
+
+/// File backing the recently-used SSH address list (a plain `Vec<String>`).
+fn ssh_addresses_path() -> std::path::PathBuf {
+    crate::storage::state_dir().join("ssh_addresses.json")
+}
+
+/// Merge `addr` into `existing` as a most-recently-used list: drop any prior
+/// case-insensitive duplicate, prepend the new value, and cap the length. Pure
+/// so the dedupe/cap policy is unit-tested without touching disk.
+fn merge_recent_address(existing: Vec<String>, addr: &str) -> Vec<String> {
+    let mut out: Vec<String> = Vec::with_capacity(existing.len() + 1);
+    out.push(addr.to_string());
+    for e in existing {
+        if !e.eq_ignore_ascii_case(addr) {
+            out.push(e);
+        }
+    }
+    out.truncate(SSH_ADDRESS_CAP);
+    out
+}
+
+/// Previously-used SSH addresses (most-recent first) so the project dialog can
+/// offer them for reuse instead of retyping. Best-effort: a missing or corrupt
+/// store yields an empty list.
+#[tauri::command]
+pub fn ssh_list_addresses() -> Vec<String> {
+    crate::storage::read_json(&ssh_addresses_path()).unwrap_or_default()
+}
+
+/// Remember `address` as the most-recently-used SSH address. Trims and validates
+/// it (rejecting blanks, option-looking values, and control chars) so we never
+/// persist something the connect path couldn't use, then moves it to the front
+/// of the recents list.
+#[tauri::command]
+pub fn ssh_remember_address(address: String) -> Result<(), String> {
+    let trimmed = address.trim();
+    if trimmed.is_empty() {
+        return Err("empty SSH address".to_string());
+    }
+    crate::services::ssh_common::validate_arg("SSH address", trimmed)?;
+    let existing: Vec<String> = crate::storage::read_json(&ssh_addresses_path()).unwrap_or_default();
+    let merged = merge_recent_address(existing, trimmed);
+    crate::storage::write_json(&ssh_addresses_path(), &merged).map_err(|e| e.to_string())
+}
+
+/// Most-recently-used remote paths to keep, per host. Old entries past this
+/// fall off.
+const REMOTE_PATH_CAP: usize = 20;
+
+/// File backing the recently-used remote-path lists, keyed by host
+/// (case-insensitive) so a path picked on one host isn't suggested for another.
+fn remote_paths_path() -> std::path::PathBuf {
+    crate::storage::state_dir().join("remote_paths.json")
+}
+
+/// Merge `path` into `existing` as a most-recently-used list: drop any prior
+/// exact-match duplicate (paths are case-sensitive, unlike hostnames), prepend
+/// the new value, and cap the length. Pure so the dedupe/cap policy is
+/// unit-tested without touching disk.
+fn merge_recent_path(existing: Vec<String>, path: &str) -> Vec<String> {
+    let mut out: Vec<String> = Vec::with_capacity(existing.len() + 1);
+    out.push(path.to_string());
+    for e in existing {
+        if e != path {
+            out.push(e);
+        }
+    }
+    out.truncate(REMOTE_PATH_CAP);
+    out
+}
+
+/// Previously-used remote paths for `host` (most-recent first), so the project
+/// dialog can offer them for reuse instead of re-browsing. Best-effort: a
+/// missing or corrupt store, or a host with no history, yields an empty list.
+#[tauri::command]
+pub fn remote_list_paths(host: String) -> Vec<String> {
+    let store: std::collections::HashMap<String, Vec<String>> =
+        crate::storage::read_json(&remote_paths_path()).unwrap_or_default();
+    store.get(&host.to_lowercase()).cloned().unwrap_or_default()
+}
+
+/// Remember `path` as the most-recently-used remote path for `host`. Trims and
+/// validates it (rejecting blanks, option-looking values, and control chars) so
+/// we never persist something the browse/connect path couldn't use, then moves
+/// it to the front of that host's recents list.
+#[tauri::command]
+pub fn remote_remember_path(host: String, path: String) -> Result<(), String> {
+    let trimmed = path.trim();
+    if trimmed.is_empty() {
+        return Err("empty remote path".to_string());
+    }
+    crate::services::ssh_common::validate_arg("remote path", trimmed)?;
+    let key = host.to_lowercase();
+    let mut store: std::collections::HashMap<String, Vec<String>> =
+        crate::storage::read_json(&remote_paths_path()).unwrap_or_default();
+    let existing = store.remove(&key).unwrap_or_default();
+    store.insert(key, merge_recent_path(existing, trimmed));
+    crate::storage::write_json(&remote_paths_path(), &store).map_err(|e| e.to_string())
+}
+
+/// File backing the per-host **standard** remote paths set from Settings'
+/// "Remote Connections" panel — a `HashMap<host, path>`, keyed case-
+/// insensitively like `remote_paths.json`. Distinct from that file: this one
+/// holds one explicit, user-chosen default per host, not an auto-remembered
+/// recents list.
+fn remote_host_defaults_path() -> std::path::PathBuf {
+    crate::storage::state_dir().join("remote_host_defaults.json")
+}
+
+/// All per-host standard paths configured from Settings, for the "Remote
+/// Connections" panel to list and edit.
+#[tauri::command]
+pub fn remote_list_default_paths() -> std::collections::HashMap<String, String> {
+    crate::storage::read_json(&remote_host_defaults_path()).unwrap_or_default()
+}
+
+/// The configured standard remote path for `host`, if any. Consulted when a
+/// connect/browse flow would otherwise fall back to `ssh_default_dir`'s SSH
+/// home-directory guess, so a host with a preferred working directory starts
+/// there instead every time.
+#[tauri::command]
+pub fn remote_get_default_path(host: String) -> Option<String> {
+    let store: std::collections::HashMap<String, String> =
+        crate::storage::read_json(&remote_host_defaults_path()).unwrap_or_default();
+    store.get(&host.to_lowercase()).cloned()
+}
+
+/// Set (or, with a blank `path`, clear) the standard remote path for `host`.
+/// Trims and validates a non-empty path the same way `remote_remember_path`
+/// does, so it can't smuggle in an `ssh`/`sftp`-option-looking value or
+/// control characters.
+#[tauri::command]
+pub fn remote_set_default_path(host: String, path: String) -> Result<(), String> {
+    let key = host.trim().to_lowercase();
+    if key.is_empty() {
+        return Err("empty host".to_string());
+    }
+    let mut store: std::collections::HashMap<String, String> =
+        crate::storage::read_json(&remote_host_defaults_path()).unwrap_or_default();
+    let trimmed = path.trim();
+    if trimmed.is_empty() {
+        store.remove(&key);
+    } else {
+        crate::services::ssh_common::validate_arg("remote path", trimmed)?;
+        store.insert(key, trimmed.to_string());
+    }
+    crate::storage::write_json(&remote_host_defaults_path(), &store).map_err(|e| e.to_string())
+}
+
+/// Open a web URL in the user's default browser. Refuses anything that is not an
+/// `http(s)` URL so it cannot be turned into a launcher for arbitrary local files
+/// or schemes.
+#[tauri::command]
+pub fn open_external_url(url: String) -> Result<(), String> {
+    if !(url.starts_with("https://") || url.starts_with("http://")) {
+        return Err("refusing to open a non-web URL".to_string());
+    }
+    opener::open(&url).map_err(|e| format!("failed to open {url}: {e}"))
+}
+
 /// Run a built command, returning stdout on success or the trimmed stderr (or a
 /// generic message) on failure. `what` names the binary for error messages.
-fn capture(mut cmd: Command, what: &str) -> Result<String, String> {
+fn capture(cmd: Command, what: &str) -> Result<String, String> {
+    capture_raw(cmd, what).map_err(|(explained, _)| explained)
+}
+
+/// [`capture`] keeping ssh's raw stderr alongside the explained message, for the
+/// one caller that must tell a *local* failure (a wrong key passphrase) from a
+/// server-side one before deciding whether to try another auth method — see
+/// [`run_ssh_auth`]. The explained form is deliberately lossy, so the choice
+/// cannot be made from it.
+fn capture_raw(mut cmd: Command, what: &str) -> Result<String, (String, String)> {
     let output = cmd
         .output()
-        .map_err(|e| format!("failed to run {what}: {e}"))?;
+        .map_err(|e| (format!("failed to run {what}: {e}"), String::new()))?;
 
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
         if stderr.is_empty() {
-            return Err(format!("{what} command failed"));
+            return Err((format!("{what} command failed"), stderr));
         }
-        return Err(stderr);
+        // Headless has no terminal for the user to read, so translate what OpenSSH
+        // said into what they got wrong. Unrecognized stderr passes through
+        // verbatim rather than being flattened into a vague guess.
+        let explained = crate::services::ssh_common::explain_ssh_error(&stderr)
+            .unwrap_or_else(|| stderr.clone());
+        return Err((explained, stderr));
     }
 
     Ok(String::from_utf8_lossy(&output.stdout).to_string())
 }
 
-/// Build the password-auth ssh argv: BatchMode off and only the password method
-/// enabled, so ssh never falls back to (or hangs on) keys/keyboard-interactive.
-/// The target `[user@]host` is validated and rendered as a single argv item.
-fn ssh_password_base_args(
-    user: &Option<String>,
-    host: &str,
-    port: Option<u16>,
-) -> Result<Vec<String>, String> {
-    let mut args: Vec<String> = vec![
-        "-o".to_string(),
-        "BatchMode=no".to_string(),
-        "-o".to_string(),
-        "ConnectTimeout=10".to_string(),
-        "-o".to_string(),
-        "PreferredAuthentications=password".to_string(),
-        "-o".to_string(),
-        "PubkeyAuthentication=no".to_string(),
-        "-o".to_string(),
-        "NumberOfPasswordPrompts=1".to_string(),
-    ];
-    if let Some(port) = port {
-        args.push("-p".to_string());
-        args.push(port.to_string());
+/// Replace a failed ssh result with the prompt the askpass shim refused to answer,
+/// when there was one. Without this a refusal surfaces as OpenSSH's generic
+/// `Permission denied` — which is exactly the dead end the shape check exists to
+/// avoid: the user needs to be told the host asked for something else, and what.
+///
+/// Must be called while the [`Askpass`](crate::services::ssh_common::Askpass) guard
+/// is still alive; dropping it deletes the record.
+#[cfg(any(unix, windows))]
+fn askpass_refusal_raw(
+    kind: crate::services::ssh_common::SecretKind,
+    askpass: &crate::services::ssh_common::Askpass,
+    result: Result<String, (String, String)>,
+) -> Result<String, (String, bool)> {
+    let Err((explained, raw)) = result else {
+        return result.map_err(|(e, _)| (e, false));
+    };
+    // Both reads must happen before the guard drops (it deletes its files).
+    if crate::services::ssh_common::secret_rejected_locally(kind, Some(askpass), &raw) {
+        return Err((crate::services::ssh_common::wrong_passphrase_error(), true));
+    }
+    match askpass.refused_prompt() {
+        Some(prompt) => Err((
+            crate::services::ssh_common::unexpected_prompt_error(&prompt),
+            false,
+        )),
+        None => Err((explained, false)),
     }
-    args.push(ssh_target(user, host)?);
-    Ok(args)
 }
 
 /// Run an ssh command against `[user@]host[:port]`, choosing the auth method by
 /// whether a non-empty `password` was supplied:
-///   - password present → `sshpass -e ssh …` (password read from the `SSHPASS`
-///     env var so it never appears in the process's argv), password-only auth;
+///   - password present → password-only auth via OpenSSH's own `SSH_ASKPASS` shim
+///     (`services::ssh_common::make_askpass`) — on Windows only when OpenSSH ≥ 8.4
+///     supports `SSH_ASKPASS_REQUIRE`, with `sshpass -e` as the legacy fallback.
 ///   - otherwise → key/agent auth in `BatchMode=yes` (the original v1 flow).
 /// Returns ssh stdout on success or the trimmed stderr on failure.
-fn run_ssh_auth(
+///
+/// `pub(crate)`: also called by
+/// `commands::global_machines::global_machine_monitor_snapshot`, which needs
+/// this exact password-vs-key branching for a project-free host (no pooled
+/// ControlMaster to ride, unlike `remote_usage::check_usage`).
+pub(crate) fn run_ssh_auth(
     user: &Option<String>,
     host: &str,
     port: Option<u16>,
     password: Option<&str>,
     remote: &[&str],
 ) -> Result<String, String> {
-    match password.filter(|p| !p.is_empty()) {
-        Some(pw) => {
-            if !sshpass_available() {
-                return Err(
-                    "sshpass not found — install sshpass to use password auth, or set up SSH keys"
-                        .to_string(),
-                );
+    use crate::services::ssh_common::SecretKind;
+
+    let Some(pw) = password.filter(|p| !p.is_empty()) else {
+        let base = ssh_base_args(user, host, port)?;
+        let mut cmd = crate::paths::command_no_window("ssh");
+        cmd.args(&base);
+        cmd.args(remote);
+        return capture(cmd, "ssh").map_err(|err| {
+            // `BatchMode=yes` never asks for an encrypted key's passphrase, so a
+            // locked key surfaces as a bare "Permission denied (publickey)" with
+            // nothing pointing at the actual cause. Name it.
+            match crate::services::ssh_common::locked_key_hint(user, host, port) {
+                Some(hint) => format!("{err}\n\n{hint}"),
+                None => err,
             }
-            let base = ssh_password_base_args(user, host, port)?;
-            let mut cmd = Command::new("sshpass");
-            cmd.arg("-e"); // read the password from the SSHPASS env var
-            cmd.env("SSHPASS", pw);
-            cmd.arg("ssh");
-            cmd.args(&base);
-            cmd.args(remote);
-            capture(cmd, "sshpass")
+        });
+    };
+
+    let kinds = crate::services::ssh_common::secret_attempt_order(user, host, port);
+    let last = kinds.len() - 1;
+    let mut error = String::new();
+    for (i, kind) in kinds.iter().copied().enumerate() {
+        if kind == SecretKind::Password {
+            // Never hand a password to a host whose key has not been vetted — the
+            // one thing `accept-new` does not cover (see `guard_first_contact`).
+            // A passphrase needs no such gate: it never leaves this machine.
+            crate::services::ssh_common::guard_first_contact(host, port)?;
         }
-        None => {
-            let base = ssh_base_args(user, host, port)?;
-            let mut cmd = Command::new("ssh");
-            cmd.args(&base);
-            cmd.args(remote);
-            capture(cmd, "ssh")
+        let base = match kind {
+            SecretKind::Password => ssh_password_base_args(user, host, port)?,
+            SecretKind::KeyPassphrase => {
+                crate::services::ssh_common::ssh_passphrase_base_args(user, host, port)?
+            }
+        };
+        match run_one_secret_attempt(kind, pw, &base, remote) {
+            Ok(out) => return Ok(out),
+            Err((explained, rejected_locally)) => {
+                error = explained;
+                // Definitively a wrong passphrase: retrying it as a login password
+                // would disclose a local secret to the host.
+                if rejected_locally || i == last {
+                    return Err(error);
+                }
+            }
         }
     }
+    Err(error)
 }
 
-/// Single-quote `s` for a POSIX shell, escaping embedded single quotes as
-/// `'\''`. The result parses back to exactly `s` regardless of spaces, `;`,
-/// `$()`, quotes, or other metacharacters.
+/// One authentication attempt for [`run_ssh_auth`]: build `ssh` (or `sshpass`)
+/// with the askpass shim for `kind` attached, run it, and return stdout or
+/// `(explained, raw stderr)`.
 ///
-/// This is required because `ssh` concatenates its trailing argv with spaces and
-/// hands the result to the *remote* `$SHELL -c`. Passing the path after `--`
-/// only stops `ls`'s own option parsing; it does **not** stop the remote shell
-/// from interpreting metacharacters. So each remote path argument must be quoted
-/// before it reaches ssh, or a directory named e.g. `foo; rm -rf ~` would run as
-/// a command on the remote host.
-fn shell_quote(s: &str) -> String {
-    let mut out = String::with_capacity(s.len() + 2);
-    out.push('\'');
-    for ch in s.chars() {
-        if ch == '\'' {
-            out.push_str("'\\''");
-        } else {
-            out.push(ch);
+/// The askpass guard must outlive the ssh run — the shim is invoked *during*
+/// authentication — so it stays in scope until `capture_raw` returns, and its
+/// refusal record is read before it drops (dropping deletes it).
+fn run_one_secret_attempt(
+    kind: crate::services::ssh_common::SecretKind,
+    secret: &str,
+    base: &[String],
+    remote: &[&str],
+) -> Result<String, (String, bool)> {
+    let build_err = |e: String| (e, false);
+
+    #[cfg(unix)]
+    {
+        let mut cmd = crate::paths::command_no_window("ssh");
+        cmd.args(base);
+        cmd.args(remote);
+        let askpass = crate::services::ssh_common::make_askpass_for(kind, secret, base)
+            .map_err(build_err)?;
+        for (k, v) in askpass.env_vars() {
+            cmd.env(k, v);
         }
+        let out = capture_raw(cmd, "ssh");
+        askpass_refusal_raw(kind, &askpass, out)
     }
-    out.push('\'');
-    out
-}
+    #[cfg(not(unix))]
+    {
+        use crate::services::ssh_common::SecretKind;
 
-/// Parse `ls -1Ap` output into entries. A trailing `/` marks a directory; we
-/// strip it and set `is_dir`. `.`/`..` are filtered out, blank lines skipped.
-/// Result is sorted dirs-first, then case-insensitively by name.
-fn parse_ls_output(stdout: &str) -> Vec<RemoteEntry> {
-    let mut entries: Vec<RemoteEntry> = Vec::new();
-    for line in stdout.lines() {
-        let line = line.trim_end_matches(['\r', '\n']);
-        if line.is_empty() {
-            continue;
-        }
-        let (name, is_dir) = match line.strip_suffix('/') {
-            Some(stripped) => (stripped, true),
-            None => (line, false),
-        };
-        if name.is_empty() || name == "." || name == ".." {
-            continue;
+        // Windows: same SSH_ASKPASS path when OpenSSH is >= 8.4; older installs
+        // (Win10-inbox 8.1) fall back to sshpass, which can only answer a
+        // *password* prompt. All commands use `command_no_window`, so no console
+        // flashes either way.
+        if crate::services::ssh_common::ssh_supports_askpass() {
+            let mut cmd = crate::paths::command_no_window("ssh");
+            cmd.args(base);
+            cmd.args(remote);
+            let askpass = crate::services::ssh_common::make_askpass_for(kind, secret, base)
+                .map_err(build_err)?;
+            for (k, v) in askpass.env_vars() {
+                cmd.env(k, v);
+            }
+            let out = capture_raw(cmd, "ssh");
+            askpass_refusal_raw(kind, &askpass, out)
+        } else if kind == SecretKind::KeyPassphrase {
+            Err(build_err(
+                "unlocking a passphrase-protected SSH key needs OpenSSH 8.4+ — update \
+                 OpenSSH, or run `ssh-add` to load the key before connecting"
+                    .to_string(),
+            ))
+        } else if crate::services::ssh_common::sshpass_available() {
+            let mut cmd = crate::paths::command_no_window("sshpass");
+            cmd.arg("-e"); // read the password from the SSHPASS env var
+            cmd.env("SSHPASS", secret);
+            cmd.arg("ssh");
+            cmd.args(base);
+            cmd.args(remote);
+            capture_raw(cmd, "sshpass").map_err(|(e, _)| (e, false))
+        } else {
+            Err(build_err(
+                "password auth needs OpenSSH 8.4+ or sshpass — update OpenSSH, \
+                 install sshpass, or set up SSH keys"
+                    .to_string(),
+            ))
         }
-        entries.push(RemoteEntry {
-            name: name.to_string(),
-            is_dir,
-        });
     }
-    entries.sort_by(|a, b| {
-        b.is_dir
-            .cmp(&a.is_dir)
-            .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
-    });
-    entries
 }
 
-/// Verify the remote host is reachable over SSH (non-interactive). With a
-/// non-empty `password`, authenticates via `sshpass`; otherwise uses key/agent
-/// auth. Returns the trimmed ssh stderr as the error on failure.
+/// Build the shell command that opens an **interactive** ssh login to
+/// `[user@]host[:port]`, sharing the multiplexing master the mount/check paths
+/// reuse. Returned for the frontend to type into a root-scope shell tab when
+/// headless connections are off, so the password is entered in the visible
+/// terminal and never handled by Eldrun (see `ssh_exec::interactive_login_command`).
 #[tauri::command]
-pub fn ssh_connect(
+pub fn remote_login_command(
     user: Option<String>,
     host: String,
     port: Option<u16>,
-    password: Option<String>,
-) -> Result<(), String> {
-    run_ssh_auth(&user, &host, port, password.as_deref(), &["true"]).map(|_| ())
+) -> Result<String, String> {
+    crate::services::ssh_exec::interactive_login_command(&user, &host, port)
 }
 
-/// Return the remote `$HOME` (via `pwd`) as the browser's start location.
+/// Verify the remote host is reachable over SSH (non-interactive). With a
+/// non-empty `password`, authenticates by feeding it to ssh (via `SSH_ASKPASS` on
+/// Unix, `sshpass` on Windows); otherwise uses key/agent auth. Returns the trimmed
+/// ssh stderr as the error on failure.
+///
+/// Async + `spawn_blocking`: the ssh probe spawns a subprocess that can block for
+/// up to `ConnectTimeout=10s` (BatchMode key/agent auth against an unreachable or
+/// not-yet-tunnelled host, or while a password login's master comes up). As a
+/// *synchronous* Tauri command this ran on the main/UI thread and froze the whole
+/// window — most visibly during reconnect, where `pollSshReady` polls it every
+/// few seconds against a still-authenticating master. Running it on a blocking
+/// worker keeps the UI responsive (e.g. the SSH-login button stays clickable while
+/// the OpenVPN tunnel is coming up).
+///
+/// `remember` is the "Save password" checkbox, and **only** the checkbox:
+/// `Some(true)` persists the working password in the OS keychain (keyed by the host
+/// target, written only *after* auth succeeds) for no-prompt reconnects,
+/// `Some(false)` — an explicit untick — clears any previously-saved one, and `None`
+/// leaves the keychain untouched. That last case is not a nicety: a caller with no
+/// checkbox behind it (a readiness poll riding the ControlMaster, a silent
+/// reconnect) must not delete the credential it just authenticated with — which is
+/// exactly what folding `None` into "unticked" used to do.
+///
+/// A `None`/empty `password` first falls back to any saved credential (silent
+/// reconnect) before dropping to key/agent auth.
+///
+/// The outcome is [`SshConnectOutcome`], not `()`, because the keychain half can
+/// fail on its own: a locked keyring refuses the write, and reporting only "the
+/// connect worked" left the user with a ticked Save box, no saved password, and a
+/// blank prompt at the next launch as the sole evidence.
 #[tauri::command]
-pub fn ssh_default_dir(
+pub async fn ssh_connect(
     user: Option<String>,
     host: String,
     port: Option<u16>,
     password: Option<String>,
-) -> Result<String, String> {
-    let stdout = run_ssh_auth(&user, &host, port, password.as_deref(), &["pwd"])?;
-    let path = stdout.trim().to_string();
-    if path.is_empty() {
-        return Err("remote pwd returned no path".to_string());
-    }
-    Ok(path)
+    remember: Option<bool>,
+    background: Option<bool>,
+) -> Result<SshConnectOutcome, String> {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        // Both shapes at once, because this command is both. A **typed password**
+        // is a person at a login form, so it is unconditionally their connect to
+        // make. Credential-less, it is ambiguous: the same call is the readiness
+        // poll that waits for a terminal login's ControlMaster (a gesture, so the
+        // add-a-machine and reconnect flows pass `background: false`) and the
+        // silent reconnect behind auto-connect (which passes nothing). The guard
+        // must outlive `run_ssh_auth`, which is where the argv is built.
+        let typed = password.as_deref().is_some_and(|p| !p.is_empty());
+        let _dial = typed
+            .then(|| crate::services::ssh_common::user_dial(&user, &host, port))
+            .or_else(|| {
+                crate::services::ssh_common::declared_dial(background, &user, &host, port)
+            });
+        let account = creds::ssh_account(&user, &host, port);
+        // A typed password wins; otherwise fall back to a saved one so an
+        // activation-time reconnect authenticates without a prompt.
+        let effective = password
+            .filter(|p| !p.is_empty())
+            .or_else(|| creds::get(&account));
+        run_ssh_auth(&user, &host, port, effective.as_deref(), &["true"])?;
+        let outcome = creds::remember_secret(&account, remember, effective.as_deref());
+        Ok(SshConnectOutcome {
+            saved: outcome.saved,
+            save_error: outcome.error,
+        })
+    })
+    .await
+    .map_err(|e| format!("ssh probe task failed: {e}"))?
+}
+
+/// What [`ssh_connect`] did *besides* connecting: whether the "Save password"
+/// checkbox was honoured, and — when it was not — the reason, verbatim from the
+/// keychain layer ("the OS keyring is locked, so nothing was saved…").
+///
+/// A failed keychain write never fails the connect: authentication already
+/// succeeded, and refusing the session over a storage problem helps nobody. But
+/// it must not be silent either, which is what discarding it amounted to.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct SshConnectOutcome {
+    /// A password is now saved for this target as a result of this connect.
+    pub saved: bool,
+    /// Why it is not, when the user asked for it (or asked to remove one and the
+    /// keyring could not be read). `None` on success and when nothing was asked.
+    pub save_error: Option<String>,
+}
+
+/// Both halves of "is a password saved for this host?" in one answer: whether one
+/// reads back, and whether the store could be read at all.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct SavedPasswordState {
+    pub saved: bool,
+    pub keyring: crate::services::remote_credentials::KeyringState,
 }
 
-/// List one remote directory. Empty `path` lists the remote home directory.
+/// The saved-password state of a host target — [`remote_has_saved_password`] plus
+/// the fact that makes its answer readable.
+///
+/// A locked collection answers every lookup with "nothing saved", so `saved:
+/// false` alone is ambiguous in exactly the case the user cares about: they *did*
+/// tick Save, the password *is* on the ring, and the UI reports it gone. Both
+/// facts come from **one** `spawn_blocking` hop because they are one question —
+/// asking them separately costs two unbounded keychain trips per host, on a path
+/// auto-connect already takes once per host per launch.
 #[tauri::command]
-pub fn ssh_list_dir(
+pub async fn remote_saved_password_state(
     user: Option<String>,
     host: String,
     port: Option<u16>,
-    password: Option<String>,
-    path: String,
-) -> Result<Vec<RemoteEntry>, String> {
-    let pw = password.as_deref();
-    let path = path.trim();
-    let stdout = if path.is_empty() {
-        // No path → list the remote home directory.
-        run_ssh_auth(&user, &host, port, pw, &["ls", "-1Ap", "--"])?
-    } else {
-        validate_arg("path", path)?;
-        // `ssh` joins its trailing argv with spaces and feeds it to the remote
-        // `$SHELL -c`, so the path must be single-quoted for that shell (the
-        // `--` only stops `ls`'s own flag parsing). Without this a directory name
-        // containing `;`/`$()`/spaces would be re-interpreted on the remote host.
-        let quoted = shell_quote(path);
-        run_ssh_auth(&user, &host, port, pw, &["ls", "-1Ap", "--", quoted.as_str()])?
-    };
-
-    Ok(parse_ls_output(&stdout))
+) -> SavedPasswordState {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        // Lock state first: it refreshes the cache `has()`'s gate then reads, so
+        // the two facts describe the same moment rather than straddling a probe.
+        let keyring = creds::keyring_state();
+        let saved = creds::has(&creds::ssh_account(&user, &host, port));
+        SavedPasswordState { saved, keyring }
+    })
+    .await
+    .unwrap_or(SavedPasswordState {
+        saved: false,
+        // A panicked lookup told us nothing about the store, and "unavailable" is
+        // the state with no action behind it — the honest answer to "we don't
+        // know", and the one that routes the caller to a prompt.
+        keyring: crate::services::remote_credentials::KeyringState::Unavailable,
+    })
 }
 
-/// Ensure a project's bytes are reachable locally and return the directory to
-/// use. For a remote project this sshfs-mounts it (no-op if already mounted)
-/// and returns the local mountpoint; for a local project it returns the stored
-/// `directory` unchanged.
+/// Whether a saved SSH password exists for this host target, so the UI can
+/// pre-check the "Save password" box and show "saved" without ever receiving the
+/// secret itself.
+///
+/// `async` + `spawn_blocking` is load-bearing, not stylistic. A **synchronous**
+/// Tauri command runs on the **main thread**, and the keychain behind this is the
+/// platform secret store — on Linux a D-Bus round-trip to the Secret Service,
+/// which is unbounded: it is slow while the daemon starts, and it blocks
+/// *indefinitely* while the keyring is locked, because the unlock prompt has to be
+/// answered first. Answering it needs the compositor, and Eldrun's window is
+/// frozen mid-frame at that point. Auto-connect is what makes this a launch
+/// problem rather than a rare one: it asks this question once per host, for the
+/// primary and every opted-in worker, on every launch and every activation — so a
+/// multi-host remote project serialised several unbounded main-thread D-Bus calls
+/// into startup. Off the main thread it is just a slow promise.
+///
+/// Now a thin wrapper over [`remote_saved_password_state`], which answers the same
+/// question *and* says whether the store was readable. Kept because callers still
+/// ask it this way; a `false` here remains the safe direction (the caller prompts,
+/// never a silent connect on a credential we cannot read).
 #[tauri::command]
-pub fn ensure_project_mounted(project_id: String) -> Result<String, String> {
-    let project = load_project_by_id(&project_id)?;
+pub async fn remote_has_saved_password(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+) -> bool {
+    remote_saved_password_state(user, host, port).await.saved
+}
 
-    match project.remote.as_ref() {
-        Some(remote) => {
-            let mountpoint = ssh_mount::mount(remote, &project_id)?;
-            Ok(mountpoint.to_string_lossy().into_owned())
-        }
-        None => Ok(project.directory),
-    }
+/// Outcome of a silent reachability probe (`ssh_probe`).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct SshProbe {
+    /// The host answered and authentication succeeded.
+    pub ok: bool,
+    /// The failure was the *network* not reaching the host — not a rejected
+    /// credential. Only this warrants bringing an OpenVPN tunnel up and retrying.
+    pub unreachable: bool,
+    /// Trimmed ssh stderr (empty when `ok`).
+    pub error: String,
 }
 
-/// Load a project's `project.json` by its id, resolving `local_file` from the
-/// global `projects.json` list.
-pub(crate) fn load_project_by_id(project_id: &str) -> Result<Project, String> {
-    let list_path = storage::state_dir().join("projects.json");
-    let list: ProjectsList = if list_path.exists() {
-        storage::read_json(&list_path).map_err(|e| e.to_string())?
-    } else {
-        Vec::new()
-    };
-    let entry = list
+/// Whether an ssh failure means "the host was not reachable from this network"
+/// rather than "the host said no". Auto-connect escalates to the project's VPN
+/// tunnel *only* on the former: a wrong or expired credential must never cause a
+/// tunnel to be brought up, and no tunnel would fix it anyway.
+fn ssh_unreachable(err: &str) -> bool {
+    const MARKERS: [&str; 6] = [
+        "Connection timed out",
+        "Operation timed out",
+        "No route to host",
+        "Network is unreachable",
+        "Connection refused",
+        "Could not resolve hostname",
+    ];
+    let err = err.to_ascii_lowercase();
+    MARKERS
         .iter()
-        .find(|p| p.id == project_id)
-        .ok_or_else(|| format!("project '{project_id}' not found"))?;
-    let path = PathBuf::from(&entry.local_file);
-    storage::read_json::<Project>(&path).map_err(|e| e.to_string())
+        .any(|m| err.contains(&m.to_ascii_lowercase()))
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+/// Silently probe whether this host is reachable *and* authenticates right now,
+/// classifying a failure as unreachable-vs-rejected. Backs the auto-connect path
+/// (`autoConnectRemote`), which uses the verdict to decide whether the project's
+/// OpenVPN tunnel is needed on the current network.
+///
+/// Deliberately **not** `ssh_connect`: that command rewrites the keychain entry on
+/// every success (clearing it whenever `remember` is falsy), so probing through it
+/// would delete the very saved password auto-connect depends on. This one is
+/// read-only — it reuses the saved credential but never writes one.
+///
+/// Read-only of the *keychain*, that is: it is a full authenticated login at the
+/// host, which is precisely how a tagged cluster kept being dialled unattended.
+/// So it takes `background` (`ssh_common`'s second shape) — the armed
+/// auto-connect and the machines-menu reachability sweep are its background
+/// callers, a Connect dialog's pre-flight its gesture one — and only an explicit
+/// `Some(false)` counts as a person waiting.
+#[tauri::command]
+pub async fn ssh_probe(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    background: Option<bool>,
+) -> SshProbe {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        let _dial = crate::services::ssh_common::declared_dial(background, &user, &host, port);
+        let saved = creds::get(&creds::ssh_account(&user, &host, port));
+        match run_ssh_auth(&user, &host, port, saved.as_deref(), &["true"]) {
+            Ok(_) => SshProbe {
+                ok: true,
+                unreachable: false,
+                error: String::new(),
+            },
+            Err(e) => SshProbe {
+                ok: false,
+                unreachable: ssh_unreachable(&e),
+                error: e,
+            },
+        }
+    })
+    .await
+    .unwrap_or_else(|e| SshProbe {
+        ok: false,
+        unreachable: false,
+        error: format!("ssh probe task failed: {e}"),
+    })
+}
 
-    // ── parse_ls_output ────────────────────────────────────────────────────
+/// Forget any saved SSH password for this host target (explicit "clear" action).
+/// Off the main thread for the same reason as `remote_has_saved_password`.
+#[tauri::command]
+pub async fn remote_forget_password(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        let account = crate::services::remote_credentials::ssh_account(&user, &host, port);
+        crate::services::remote_credentials::set(&account, None)
+    })
+    .await
+    .map_err(|e| format!("forget password task failed: {e}"))?
+}
 
-    #[test]
-    fn parse_ls_distinguishes_dirs_and_files() {
-        let out = "src/\nmain.rs\nCargo.toml\ntarget/\n";
-        let entries = parse_ls_output(out);
-        let dirs: Vec<_> = entries
-            .iter()
-            .filter(|e| e.is_dir)
-            .map(|e| e.name.as_str())
-            .collect();
-        let files: Vec<_> = entries
-            .iter()
-            .filter(|e| !e.is_dir)
-            .map(|e| e.name.as_str())
-            .collect();
-        assert_eq!(dirs, vec!["src", "target"]);
-        assert_eq!(files, vec!["Cargo.toml", "main.rs"]);
-    }
+/// Kill every tmux session on a remote host — the "end all my running jobs" half
+/// of an **active** disconnect. Rides a live multiplexing master if one exists (a
+/// project/HPC host with a pooled connection), otherwise authenticates ad-hoc
+/// with the saved credential (a global machine, which pools nothing) — the same
+/// `run_ssh_auth` branching `global_machine_monitor_snapshot` uses.
+///
+/// EXPLICIT-ACTION ONLY. Persistent tmux sessions are meant to outlive a tab
+/// close, an app quit and a relaunch (the whole point of #85); this is the one
+/// deliberate path that ends them, and it must never fire on deactivation or
+/// restart. `tmux kill-server` reporting "no server running" is success (there
+/// was nothing to kill), so the whole command is best-effort past reachability.
+#[tauri::command]
+pub async fn remote_kill_all_jobs(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        use crate::services::remote_credentials as creds;
+        // Explicit-action-only, so it is user-initiated by definition — this is
+        // the one path allowed to reach a tagged HPC host to end work on it.
+        let _dial = crate::services::ssh_common::user_dial(&user, &host, port);
+        let password = creds::get(&creds::ssh_account(&user, &host, port));
+        run_ssh_auth(
+            &user,
+            &host,
+            port,
+            password.as_deref(),
+            &[crate::services::ssh_exec::tmux_kill_server_script()],
+        )
+        .map(|_| ())
+    })
+    .await
+    .map_err(|e| format!("kill-jobs task failed: {e}"))?
+}
 
-    #[test]
-    fn parse_ls_sorts_dirs_first_then_name_ci() {
-        let out = "zebra.txt\nApple/\nbanana.txt\nCherry/\n";
-        let entries = parse_ls_output(out);
-        let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
-        // Dirs first (Apple, Cherry), then files (banana, zebra), each ci-sorted.
-        assert_eq!(names, vec!["Apple", "Cherry", "banana.txt", "zebra.txt"]);
-    }
+/// Close the shared multiplexing master for a host (`ssh -O exit`) so an active
+/// disconnect really severs the SSH connection, not just the lamp. Best-effort:
+/// a host with no live master — a pure global machine never opens one
+/// (`ControlMaster=no`, see `ssh_common::control_reuse_opts`) — yields a harmless
+/// no-op. A **project** host tears its pool down through `remote_disconnect`
+/// instead (which also stops its lockstep/auto-sync); this is for the project-
+/// free **global machines**, which pool nothing of their own.
+#[tauri::command]
+pub async fn ssh_close_master(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        close_control_master(&user, &host, port);
+        Ok(())
+    })
+    .await
+    .map_err(|e| format!("close-master task failed: {e}"))?
+}
 
-    #[test]
-    fn parse_ls_includes_hidden_entries() {
-        let out = ".config/\n.bashrc\nvisible.txt\n";
-        let entries = parse_ls_output(out);
-        assert!(entries
-            .iter()
-            .any(|e| e.name == ".config" && e.is_dir));
-        assert!(entries
-            .iter()
-            .any(|e| e.name == ".bashrc" && !e.is_dir));
+/// Ask a live ControlMaster for this host to exit, over the shared `cm-%C`
+/// socket. Unix-only — Windows OpenSSH has no control socket (see `ssh_pty_args`).
+#[cfg(not(target_os = "windows"))]
+fn close_control_master(user: &Option<String>, host: &str, port: Option<u16>) {
+    let Ok(target) = crate::services::ssh_common::ssh_target(user, host) else {
+        return;
+    };
+    let control_path = crate::services::ssh_exec::control_dir().join("cm-%C");
+    let mut cmd = crate::paths::command_no_window("ssh");
+    cmd.arg("-o")
+        .arg(format!("ControlPath={}", control_path.to_string_lossy()));
+    if let Some(port) = port {
+        cmd.arg("-p").arg(port.to_string());
     }
+    cmd.arg("-O").arg("exit").arg(&target);
+    let _ = cmd.output();
+}
 
-    #[test]
-    fn parse_ls_filters_dot_and_dotdot_and_blanks() {
-        // -Ap omits . and .., but be defensive: ./ and ../ and blank lines drop.
-        let out = "./\n../\n\nreal/\n";
-        let entries = parse_ls_output(out);
-        let names: Vec<_> = entries.iter().map(|e| e.name.as_str()).collect();
-        assert_eq!(names, vec!["real"]);
-    }
+#[cfg(target_os = "windows")]
+fn close_control_master(_user: &Option<String>, _host: &str, _port: Option<u16>) {}
 
-    #[test]
-    fn parse_ls_handles_crlf_line_endings() {
-        let out = "dir/\r\nfile.txt\r\n";
-        let entries = parse_ls_output(out);
-        assert_eq!(entries.len(), 2);
-        assert!(entries[0].is_dir && entries[0].name == "dir");
-        assert!(!entries[1].is_dir && entries[1].name == "file.txt");
-    }
+/// Return the remote default (home) directory as the browser's start location.
+/// Resolved over SFTP (REALPATH of `.`), so no remote shell runs.
+///
+/// Unconditionally user-initiated (`ssh_common`'s first shape): the remote folder
+/// browser has no caller but a dialog somebody is typing into — the new/import
+/// project flow, extend-to-remote, the add-worker form, the HPC pipeline wizard.
+/// Leaving it background made a tagged machine impossible to *add*, which turns
+/// the tag from a protection into a trap: the point is that Eldrun never reaches
+/// a cluster on its own, not that the user cannot.
+#[tauri::command]
+pub async fn ssh_default_dir(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    password: Option<String>,
+) -> Result<String, String> {
+    let _dial = crate::services::ssh_common::user_dial(&user, &host, port);
+    sftp::default_dir(&user, &host, port, password.as_deref()).await
+}
 
-    #[test]
-    fn parse_ls_empty_output_yields_no_entries() {
-        assert!(parse_ls_output("").is_empty());
-        assert!(parse_ls_output("\n\n").is_empty());
-    }
+/// List one remote directory over SFTP. Empty `path` lists the remote home
+/// directory. Because SFTP is a binary protocol, a directory name containing
+/// `;`/`$()`/spaces is just a listing entry — it is never re-interpreted by a
+/// remote shell (the injection surface the old `ssh ls` path had to guard).
+/// User-initiated for the same reason as [`ssh_default_dir`] — one browser, one
+/// rule.
+#[tauri::command]
+pub async fn ssh_list_dir(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    password: Option<String>,
+    path: String,
+) -> Result<Vec<RemoteEntry>, String> {
+    let _dial = crate::services::ssh_common::user_dial(&user, &host, port);
+    let entries = sftp::list_dir(&user, &host, port, password.as_deref(), &path).await?;
+    Ok(entries
+        .into_iter()
+        .map(|e| RemoteEntry {
+            name: e.name,
+            is_dir: e.is_dir,
+        })
+        .collect())
+}
 
-    // ── shell_quote (remote path injection defense) ────────────────────────
+/// Create a remote directory (mkdir -p) over SFTP. Like `ssh_list_dir`, `path`
+/// is a binary SFTP field, never re-interpreted by a remote shell — so a folder
+/// name with shell metacharacters is created verbatim, not executed. Used by the
+/// new/import dialog's remote browser to add a target folder while browsing.
+/// User-initiated for the same reason as [`ssh_default_dir`]; creating a folder
+/// is a gesture by construction — nothing polls a mkdir.
+#[tauri::command]
+pub async fn ssh_mkdir(
+    user: Option<String>,
+    host: String,
+    port: Option<u16>,
+    password: Option<String>,
+    path: String,
+) -> Result<(), String> {
+    let _dial = crate::services::ssh_common::user_dial(&user, &host, port);
+    sftp::mkdir(&user, &host, port, password.as_deref(), &path).await
+}
 
-    #[test]
-    fn shell_quote_wraps_plain_and_metachars() {
-        assert_eq!(shell_quote("projects"), "'projects'");
-        assert_eq!(shell_quote("a b"), "'a b'");
-        assert_eq!(shell_quote("$HOME"), "'$HOME'");
-    }
+#[cfg(test)]
+mod tests {
+    use super::*;
 
+    /// The keychain-touching commands must stay `async`. A **synchronous**
+    /// `#[tauri::command]` runs on the **main thread**, and the platform secret
+    /// store behind these is an unbounded D-Bus round-trip that blocks outright
+    /// while the keyring is locked — freezing the window against an unlock prompt
+    /// the user then cannot reach. Auto-connect asks `remote_has_saved_password`
+    /// once per host on every launch and activation, so on the main thread a
+    /// multi-host remote project serialises several of those into startup.
+    ///
+    /// This is a COMPILE-TIME guard: making one of them `fn` again stops it being
+    /// a `Future` and fails the build here. The futures are constructed and
+    /// dropped, never awaited, so no keychain is touched by running this test.
     #[test]
-    fn shell_quote_neutralizes_command_injection() {
-        // A directory named so as to inject a command must come back fully
-        // single-quoted, so the remote shell treats it as one literal argument.
-        let evil = "foo; rm -rf ~";
-        assert_eq!(shell_quote(evil), "'foo; rm -rf ~'");
-        let subst = "$(touch /tmp/pwned)";
-        assert_eq!(shell_quote(subst), "'$(touch /tmp/pwned)'");
+    fn credential_commands_are_async_so_they_never_block_the_main_thread() {
+        fn assert_future<F: std::future::Future>(_f: F) {}
+        assert_future(remote_has_saved_password(None, "host".into(), None));
+        assert_future(remote_forget_password(None, "host".into(), None));
+        assert_future(crate::commands::openvpn::vpn_has_saved_password(String::new()));
+        assert_future(crate::commands::openvpn::vpn_can_connect_silently(
+            String::new(),
+            None,
+        ));
+        assert_future(crate::commands::openvpn::vpn_forget_password(String::new()));
+        assert_future(crate::commands::openvpn::openvpn_remove_config(String::new()));
     }
 
-    #[test]
-    fn shell_quote_escapes_embedded_single_quotes() {
-        // The classic break-out attempt: close the quote, inject, reopen.
-        assert_eq!(shell_quote("a'b"), "'a'\\''b'");
-        // A name trying to escape its own quoting stays inert.
-        assert_eq!(shell_quote("'; rm -rf ~ #"), "''\\''; rm -rf ~ #'");
-    }
+    // NOTE: the old `ls`-text browse path (`parse_ls_output`) and its
+    // `shell_quote` remote-path injection defense were removed when browsing
+    // moved to native SFTP (TODO #80). The dirs-first/ci sort + dot-filter and
+    // the injection-is-inert property now live in `services::sftp` tests
+    // (`finalize_entries`, `finalize_injection_named_dir_is_one_inert_entry`),
+    // since SFTP paths are protocol fields and never reach a remote shell.
 
     // ── ssh_base_args / validation ─────────────────────────────────────────
 
@@ -386,6 +917,34 @@ mod tests {
         assert!(args.iter().any(|a| a == "ConnectTimeout=10"));
     }
 
+    // ── ssh_unreachable (auto-connect's VPN-escalation gate) ───────────────
+
+    #[test]
+    fn unreachable_recognizes_network_failures() {
+        for err in [
+            "ssh: connect to host build.example port 22: Connection timed out",
+            "ssh: connect to host build.example port 22: No route to host",
+            "ssh: connect to host build.example port 22: Network is unreachable",
+            "ssh: connect to host build.example port 22: Connection refused",
+            "ssh: Could not resolve hostname build.example: Name or service not known",
+        ] {
+            assert!(ssh_unreachable(err), "should be unreachable: {err}");
+        }
+    }
+
+    /// A rejected credential must never escalate to bringing the VPN up: no tunnel
+    /// fixes a wrong password, and the tunnel is not wanted on this network.
+    #[test]
+    fn unreachable_does_not_claim_auth_failures() {
+        for err in [
+            "alice@build.example: Permission denied (publickey,password).",
+            "Received disconnect from 10.0.0.2 port 22:2: Too many authentication failures",
+            "Host key verification failed.",
+        ] {
+            assert!(!ssh_unreachable(err), "should not be unreachable: {err}");
+        }
+    }
+
     #[test]
     fn base_args_no_user_uses_bare_host() {
         let args = ssh_base_args(&None, "host.example", None).unwrap();
@@ -428,9 +987,9 @@ mod tests {
 
     #[test]
     fn validate_arg_rejects_dash_and_control_allows_normal_path() {
-        assert!(validate_arg("path", "/home/user/projects").is_ok());
-        assert!(validate_arg("path", "-rf").is_err());
-        assert!(validate_arg("path", "a\nb").is_err());
+        assert!(crate::services::ssh_common::validate_arg("path", "/home/user/projects").is_ok());
+        assert!(crate::services::ssh_common::validate_arg("path", "-rf").is_err());
+        assert!(crate::services::ssh_common::validate_arg("path", "a\nb").is_err());
     }
 
     // ── ssh_password_base_args ─────────────────────────────────────────────
@@ -454,4 +1013,65 @@ mod tests {
         assert!(ssh_password_base_args(&None, "-evil", None).is_err());
         assert!(ssh_password_base_args(&Some("-evil".to_string()), "host", None).is_err());
     }
+
+    // ── merge_recent_address (recently-used SSH addresses) ─────────────────
+
+    #[test]
+    fn merge_recent_prepends_new_address() {
+        let out = merge_recent_address(vec!["a@h".to_string(), "b@h".to_string()], "c@h");
+        assert_eq!(out, vec!["c@h", "a@h", "b@h"]);
+    }
+
+    #[test]
+    fn merge_recent_moves_existing_to_front_without_duplicating() {
+        let out = merge_recent_address(vec!["a@h".to_string(), "b@h".to_string()], "b@h");
+        assert_eq!(out, vec!["b@h", "a@h"]);
+    }
+
+    #[test]
+    fn merge_recent_dedup_is_case_insensitive() {
+        let out = merge_recent_address(vec!["User@Host".to_string()], "user@host");
+        assert_eq!(out, vec!["user@host"]);
+    }
+
+    #[test]
+    fn merge_recent_caps_length_keeping_newest() {
+        let existing: Vec<String> = (0..SSH_ADDRESS_CAP).map(|i| format!("h{i}")).collect();
+        let out = merge_recent_address(existing, "newest");
+        assert_eq!(out.len(), SSH_ADDRESS_CAP);
+        assert_eq!(out[0], "newest");
+        // The oldest entry ("h19") is dropped to make room.
+        assert!(!out.iter().any(|a| a == &format!("h{}", SSH_ADDRESS_CAP - 1)));
+    }
+
+    // ── merge_recent_path (recently-used remote paths, per host) ───────────
+
+    #[test]
+    fn merge_recent_path_prepends_new_path() {
+        let out = merge_recent_path(vec!["/a".to_string(), "/b".to_string()], "/c");
+        assert_eq!(out, vec!["/c", "/a", "/b"]);
+    }
+
+    #[test]
+    fn merge_recent_path_moves_existing_to_front_without_duplicating() {
+        let out = merge_recent_path(vec!["/a".to_string(), "/b".to_string()], "/b");
+        assert_eq!(out, vec!["/b", "/a"]);
+    }
+
+    #[test]
+    fn merge_recent_path_dedup_is_case_sensitive() {
+        // Unlike hostnames, remote filesystem paths are case-sensitive — "/Foo"
+        // and "/foo" are different directories on Linux, so both must survive.
+        let out = merge_recent_path(vec!["/Foo".to_string()], "/foo");
+        assert_eq!(out, vec!["/foo", "/Foo"]);
+    }
+
+    #[test]
+    fn merge_recent_path_caps_length_keeping_newest() {
+        let existing: Vec<String> = (0..REMOTE_PATH_CAP).map(|i| format!("/p{i}")).collect();
+        let out = merge_recent_path(existing, "/newest");
+        assert_eq!(out.len(), REMOTE_PATH_CAP);
+        assert_eq!(out[0], "/newest");
+        assert!(!out.iter().any(|a| a == &format!("/p{}", REMOTE_PATH_CAP - 1)));
+    }
 }
diff --git a/src-tauri/src/commands/subwindow.rs b/src-tauri/src/commands/subwindow.rs
index 57da1dd..dd4bce5 100644
--- a/src-tauri/src/commands/subwindow.rs
+++ b/src-tauri/src/commands/subwindow.rs
@@ -4,9 +4,10 @@
 //! Tauri `WebviewWindow` rendering the same React bundle under a
 //! `?detached=<project>:<group>` query. The detached window is registered as a
 //! project-owned `TrackedWindow` (origin `detached_subwindow`) and its resolved
-//! X11 id is opted into the workspace backend's parkable override, so the
-//! existing `project_runtime::switch` hide/show path parks it when its project
-//! goes inactive and re-shows it on switch-back — no parallel parking path.
+//! native id (X11 window on Linux, HWND on Windows) is opted into the workspace
+//! backend's parkable override, so the existing `project_runtime::switch`
+//! hide/show path parks it when its project goes inactive and re-shows it on
+//! switch-back — no parallel parking path.
 //!
 //! Persistence is session-only: a detached group re-docks into the main layout
 //! on restart (no OS-window respawn). The MAIN window owns project.json writes;
@@ -14,9 +15,14 @@
 
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use tauri::{AppHandle, Manager, PhysicalSize, State, WebviewWindowBuilder, WebviewUrl};
+use tauri::{
+    AppHandle, Manager, PhysicalPosition, PhysicalSize, Position, Size, State,
+    WebviewWindowBuilder, WebviewUrl,
+};
 
-use crate::commands::apps::{TrackedWindow, WindowRegistryState, ORIGIN_DETACHED_SUBWINDOW};
+use crate::commands::apps::{
+    TrackedWindow, WindowRegistry, WindowRegistryState, ORIGIN_DETACHED_SUBWINDOW,
+};
 use crate::commands::workspace::WorkspaceStateArc;
 
 /// Stable Tauri window label for a detached group. One window per (project,
@@ -25,11 +31,14 @@ pub fn detached_label(scope: &str, group_id: &str) -> String {
     format!("detached-{scope}-{group_id}")
 }
 
-/// Unique `_NET_WM_NAME` title for a detached window — the resolver in
-/// `platform::x11::find_window_for_title` matches on this exact string. The
-/// embedded `scope:group` avoids title collisions across detached windows.
-pub fn detached_title(scope: &str, group_id: &str) -> String {
-    format!("Eldrun — {scope} — {group_id}")
+/// Human-friendly, per-session-unique OS window title for a detached group,
+/// e.g. "Eldrun win-1". This string is load-bearing on X11: the resolver in
+/// `platform::x11::find_window_for_title` matches on it exactly to recover the
+/// native window id, so it must stay unique among live detached windows.
+/// Uniqueness comes from the caller assigning a distinct sequence number per
+/// live window (lowest free positive int); see `detach_subwindow`.
+pub fn detached_title(seq: u32) -> String {
+    format!("Eldrun win-{seq}")
 }
 
 /// The query string the DetachedApp renderer reads to mount a single group.
@@ -37,14 +46,82 @@ pub fn detached_query(scope: &str, group_id: &str) -> String {
     format!("index.html?detached={scope}:{group_id}")
 }
 
+pub fn detached_decorations(os: crate::paths::OsKind) -> bool {
+    os == crate::paths::OsKind::Macos
+}
+
+/// Reserve the lowest free display number for `label` (the N in "Eldrun
+/// win-N"). Must run under the registry lock so a concurrent detach (or a
+/// restart batch respawning several popouts) can't pick the same one.
+pub fn reserve_detached_seq(reg: &mut WindowRegistry, label: &str) -> u32 {
+    let used: std::collections::HashSet<u32> = reg.detached_seqs.values().copied().collect();
+    let n = (1u32..).find(|n| !used.contains(n)).expect("a free u32 always exists");
+    reg.detached_seqs.insert(label.to_string(), n);
+    n
+}
+
+/// Drop a detached window's registry footprint: its display number (so the
+/// next detach can reuse it — "the second window is always win-1") and its
+/// `TrackedWindow`. Returns the native window id (if one was resolved) so the
+/// caller can unset the parkable override. Idempotent: a label with no
+/// footprint is a no-op returning `None`, which is what makes it safe to call
+/// from BOTH `attach_subwindow` and the `WindowEvent::Destroyed` hook — the
+/// dock-back path fires it twice.
+pub fn release_detached_entry(reg: &mut WindowRegistry, label: &str) -> Option<u64> {
+    reg.detached_seqs.remove(label);
+    // Drop any captured switch-back geometry too, so a docked/closed label never
+    // leaves a stale bounds entry a reused label could later pick up (#42).
+    reg.detached_bounds.remove(label);
+    reg.windows.remove(label).and_then(|w| w.window_id)
+}
+
+/// PHYSICAL-pixel position to apply to a freshly-built detached window from the
+/// optional restore-geometry args, or `None` to let the WM place it.
+///
+/// The frontend's bounds are PHYSICAL desktop px (the canonical cross-window
+/// space — `src/lib/coords.ts`), so they MUST be applied via the `Physical`
+/// dpi variant. The builder's `.position()` takes LOGICAL px; feeding physical
+/// numbers to it multiplied them by the display scale, placing the window
+/// off-screen on every scale != 1.0 display — invisible on a scaled Windows
+/// display, while harmless on the scale-1.0 Linux dev box (#42).
+pub fn detached_position(x: Option<f64>, y: Option<f64>) -> Option<Position> {
+    match (x, y) {
+        (Some(x), Some(y)) => Some(Position::Physical(PhysicalPosition::new(x as i32, y as i32))),
+        _ => None,
+    }
+}
+
+/// PHYSICAL-pixel size to apply to a freshly-built detached window, or `None`
+/// to keep the default size. Same physical-vs-logical rationale as
+/// [`detached_position`] (the builder's `.inner_size()` is LOGICAL). Non-positive
+/// dimensions are rejected so a stale/zero payload can never yield a 0×0 window.
+pub fn detached_size(width: Option<f64>, height: Option<f64>) -> Option<Size> {
+    match (width, height) {
+        (Some(w), Some(h)) if w > 0.0 && h > 0.0 => {
+            Some(Size::Physical(PhysicalSize::new(w as u32, h as u32)))
+        }
+        _ => None,
+    }
+}
+
 /// Pop a tab group out into its own borderless OS window bound to `project_id`.
 ///
-/// Resolves the window's X11 id *before returning* (bounded retry) so the
+/// Resolves the window's native id *before returning* so the
 /// registry always carries a `window_id` before the window is usable — an
 /// unresolved id would float across projects until resolved (reviewer Finding 7).
 /// Returns the registry id the frontend uses to later dock it back.
+///
+/// MUST be `async`. A synchronous Tauri command runs on the main (UI) thread, and
+/// `WebviewWindowBuilder::build()` on Windows blocks waiting for the main-thread
+/// event loop to pump WebView2's `create_controller` callback — which the in-flight
+/// sync command is itself blocking → deadlock (wry#583 / tauri#4121), surfacing as
+/// a blank white popout that never renders. An `async` command is driven off the
+/// main thread, so `.build()` can dispatch to and await the (now free) event loop.
+/// This body holds no lock guard across an `.await` (it has none), so the future
+/// stays `Send`. On Linux/macOS the loop isn't blocked the same way, which is why a
+/// sync command worked on the dev box but not on Windows (#42).
 #[tauri::command]
-pub fn detach_subwindow(
+pub async fn detach_subwindow(
     app: AppHandle,
     workspace: State<'_, WorkspaceStateArc>,
     win_registry: State<'_, WindowRegistryState>,
@@ -59,37 +136,73 @@ pub fn detach_subwindow(
     height: Option<f64>,
 ) -> Result<String, String> {
     let label = detached_label(&project_id, &group_id);
-    let title = detached_title(&project_id, &group_id);
 
     // If a window with this label already exists, treat the call as idempotent.
+    // (Before reserving a number, so re-detaching a live label never burns one.)
     if app.get_webview_window(&label).is_some() {
         return Ok(label);
     }
 
+    // Reserve the lowest free display number. It becomes the OS title
+    // "Eldrun win-N" and, on X11, the resolver key — hence it must be unique per
+    // live window. It's freed on dock-back/close (`attach_subwindow`) AND on any
+    // other destruction via the `WindowEvent::Destroyed` hook in `lib.rs` (the
+    // popout self-destroys on seed timeout, last-tab close and the WM-close
+    // safety net without ever calling attach), so freed numbers get reused and a
+    // lone popout is always "win-1".
+    let seq = reserve_detached_seq(&mut win_registry.lock().unwrap(), &label);
+    let title = detached_title(seq);
+
     let mut builder = WebviewWindowBuilder::new(
         &app,
         &label,
         WebviewUrl::App(detached_query(&project_id, &group_id).into()),
     )
     .title(&title)
-    .decorations(false);
-    match (width, height) {
-        (Some(w), Some(h)) if w > 0.0 && h > 0.0 => {
-            builder = builder.inner_size(w, h);
-        }
-        _ => {
-            builder = builder.inner_size(900.0, 640.0);
+    .decorations(detached_decorations(crate::paths::OsKind::current()));
+    // Windows: a freshly runtime-created WebView2 window commonly presents a blank
+    // WHITE surface until it is shown/focused or genuinely resized — and the rapid
+    // +1/-1px resize nudge that fixes the analogous BLACK WebKitGTK surface tends
+    // to coalesce without a repaint here. Build it HIDDEN and reveal it once the
+    // webview has initialized (the deferred thread below): toggling visibility
+    // forces WebView2's first composite. Linux keeps building visible so the X11
+    // title-based id resolver can find the mapped window.
+    #[cfg(target_os = "windows")]
+    {
+        builder = builder.visible(false);
+    }
+    // Default LOGICAL size only. Any caller-supplied geometry is PHYSICAL px
+    // (frontend canonical space, `src/lib/coords.ts`) and is applied AFTER build
+    // via the physical setters below — routing it through the builder's LOGICAL
+    // `.position()`/`.inner_size()` placed/sized the window wrong on every
+    // scale != 1.0 display, which is why detach worked on the scale-1.0 Linux dev
+    // box but spawned an invisible, off-screen window on scaled Windows (#42).
+    builder = builder.inner_size(900.0, 640.0);
+    let win = match builder.build() {
+        Ok(win) => win,
+        Err(e) => {
+            // Release the reserved number so a rare failed build doesn't
+            // permanently skip a slot.
+            release_detached_entry(&mut win_registry.lock().unwrap(), &label);
+            return Err(format!("build detached window: {e}"));
         }
+    };
+
+    // Apply restore geometry in PHYSICAL px. Missing/zero bounds keep the logical
+    // default size and let the WM place the window. Size before position so a
+    // resize can't shift the placement. Best-effort: a failed setter still leaves
+    // a usable (default-placed) window rather than aborting the detach.
+    if let Some(size) = detached_size(width, height) {
+        let _ = win.set_size(size);
     }
-    if let (Some(x), Some(y)) = (x, y) {
-        builder = builder.position(x, y);
+    if let Some(pos) = detached_position(x, y) {
+        let _ = win.set_position(pos);
     }
-    builder
-        .build()
-        .map_err(|e| format!("build detached window: {e}"))?;
 
-    // Resolve the X11 id by the unique title (bypasses the protected filter).
-    let window_id = resolve_detached_window_id(&title);
+    // Resolve the native window id so the switch path can park this popout. On
+    // X11 we match the unique title (bypasses the protected filter); on Windows
+    // we read the HWND straight off the Tauri window by its label.
+    let window_id = resolve_detached_window_id(&app, &label, &title);
 
     if let Some(wid) = window_id {
         // Opt the detached window into the parkable override so the switch path
@@ -119,25 +232,57 @@ pub fn detach_subwindow(
         .windows
         .insert(label.clone(), win);
 
-    // A freshly-created second WebKitGTK webview commonly presents an unpainted
-    // (black) GL surface until a real OS-level size change forces the compositor
-    // to allocate and paint it — the main window only avoids this because its
-    // startup fullscreen transition is itself such a resize. The borderless
-    // detached window gets no such resize, so nudge its size by 1px and back
-    // shortly after creation to force the first paint. Deferred on a thread so
-    // the webview has mounted; the window stays mapped throughout, so the X11 id
-    // resolved above remains valid.
+    // Force the detached webview's first paint shortly after creation, deferred on
+    // a thread so the webview has mounted. The window stays mapped throughout, so
+    // the X11 id resolved above remains valid.
+    //
+    // - Linux/WebKitGTK: a freshly-created second webview presents an unpainted
+    //   (BLACK) GL surface until a real OS-level size change forces the compositor
+    //   to allocate and paint it — the main window only avoids this because its
+    //   startup fullscreen transition is itself such a resize. The borderless
+    //   detached window gets no such resize, so nudge its size by 1px and back.
+    // - Windows/WebView2: the same window instead presents a blank WHITE surface
+    //   and the resize nudge is unreliable (rapid +1/-1 resizes coalesce without a
+    //   repaint). The window was built HIDDEN above; show()+set_focus() here
+    //   toggles WebView2's visibility, which forces the first composite. The resize
+    //   nudge is kept as a belt-and-suspenders kick.
     let nudge_app = app.clone();
     let nudge_label = label.clone();
     std::thread::spawn(move || {
+        // Marshal every window op onto the main (UI) thread. Tauri window methods
+        // are `Send` so they compile from a worker thread, but on Windows calling
+        // show()/set_focus()/set_size() off the thread that owns the HWND is
+        // unreliable — it can no-op the repaint or deadlock against the event loop
+        // — so dispatch through `run_on_main_thread`.
+        let kick = |app: AppHandle, label: String, reveal: bool| {
+            let app_main = app.clone();
+            let _ = app.run_on_main_thread(move || {
+                if let Some(w) = app_main.get_webview_window(&label) {
+                    #[cfg(target_os = "windows")]
+                    if reveal {
+                        // Built hidden on Windows; toggling visibility forces
+                        // WebView2's first composite (a fresh runtime-created
+                        // window otherwise shows a blank white surface until it is
+                        // shown/focused).
+                        let _ = w.show();
+                        let _ = w.set_focus();
+                    }
+                    if let Ok(sz) = w.inner_size() {
+                        // A real ±1px size change forces the compositor to allocate
+                        // and paint the surface (WebKitGTK's second webview is an
+                        // unpainted BLACK GL surface until a genuine OS resize).
+                        let delta: i32 = if reveal { 1 } else { -1 };
+                        let next = (sz.width as i32 + delta).max(1) as u32;
+                        let _ = w.set_size(PhysicalSize::new(next, sz.height));
+                    }
+                }
+            });
+        };
         std::thread::sleep(std::time::Duration::from_millis(250));
-        if let Some(w) = nudge_app.get_webview_window(&nudge_label) {
-            if let Ok(sz) = w.inner_size() {
-                let _ = w.set_size(PhysicalSize::new(sz.width + 1, sz.height));
-                std::thread::sleep(std::time::Duration::from_millis(50));
-                let _ = w.set_size(sz);
-            }
-        }
+        kick(nudge_app.clone(), nudge_label.clone(), true);
+        // A short gap so the grow then restore aren't coalesced into a no-op.
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        kick(nudge_app, nudge_label, false);
     });
 
     Ok(label)
@@ -154,11 +299,10 @@ pub fn attach_subwindow(
     registry_id: String,
 ) -> Result<(), String> {
     // Drop the parkable override first so a stray park can't target a closing id.
-    let removed = win_registry.lock().unwrap().windows.remove(&registry_id);
-    if let Some(win) = removed {
-        if let Some(wid) = win.window_id {
-            workspace.lock().unwrap().backend.unset_parkable(wid);
-        }
+    // Free the display number in the same critical section so it can be reused.
+    let wid = release_detached_entry(&mut win_registry.lock().unwrap(), &registry_id);
+    if let Some(wid) = wid {
+        workspace.lock().unwrap().backend.unset_parkable(wid);
     }
     if let Some(window) = app.get_webview_window(&registry_id) {
         // `destroy()` (not `close()`) so the removal is immediate: `close()` fires
@@ -170,13 +314,77 @@ pub fn attach_subwindow(
     Ok(())
 }
 
+/// Whether the detached window registered under `registry_id` is the front-most
+/// window at the current pointer location. The frontend calls this on a file
+/// drop that lands over a popout's bounds: if the popout is occluded (behind the
+/// main window or another app) it is NOT at front, so the drop must open a new
+/// window instead of merging into a window the user can't see (#42).
+///
+/// Defaults to `true` (allow the merge) when the popout has no resolved native
+/// window id or on platforms without an occlusion probe (currently everything
+/// but Linux/X11 and Windows), so a missing occlusion signal never suppresses a
+/// legit dock.
+#[tauri::command]
+pub fn detached_window_frontmost(
+    win_registry: State<'_, WindowRegistryState>,
+    registry_id: String,
+) -> bool {
+    let wid = win_registry
+        .lock()
+        .unwrap()
+        .windows
+        .get(&registry_id)
+        .and_then(|w| w.window_id);
+    match wid {
+        None => true,
+        Some(wid) => {
+            #[cfg(target_os = "linux")]
+            {
+                crate::platform::x11::frontmost_window_under_pointer()
+                    .map(|top| top == wid)
+                    .unwrap_or(false)
+            }
+            #[cfg(target_os = "windows")]
+            {
+                crate::platform::windows::frontmost_window_under_cursor()
+                    .map(|top| top == wid)
+                    .unwrap_or(false)
+            }
+            // macOS: future-proofing — `resolve_detached_window_id` stays None
+            // on macOS v1, so this arm is only reached once popouts learn their
+            // CGWindowID.
+            #[cfg(target_os = "macos")]
+            {
+                crate::platform::macos::frontmost_window_under_pointer()
+                    .map(|top| top == wid)
+                    .unwrap_or(false)
+            }
+            #[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
+            {
+                let _ = wid;
+                true
+            }
+        }
+    }
+}
+
 #[cfg(target_os = "linux")]
-fn resolve_detached_window_id(title: &str) -> Option<u64> {
+fn resolve_detached_window_id(_app: &AppHandle, _label: &str, title: &str) -> Option<u64> {
     crate::platform::x11::find_window_for_title(title, 20)
 }
 
-#[cfg(not(target_os = "linux"))]
-fn resolve_detached_window_id(_title: &str) -> Option<u64> {
+/// Windows: read the popout's HWND directly from the Tauri window by its stable
+/// label (more robust than title enumeration, and the window is already built),
+/// so the parkable override (#42) is reachable on Windows too — not X11-only.
+#[cfg(target_os = "windows")]
+fn resolve_detached_window_id(app: &AppHandle, label: &str, _title: &str) -> Option<u64> {
+    let win = app.get_webview_window(label)?;
+    let hwnd = win.hwnd().ok()?;
+    Some(hwnd.0 as usize as u64)
+}
+
+#[cfg(not(any(target_os = "linux", target_os = "windows")))]
+fn resolve_detached_window_id(_app: &AppHandle, _label: &str, _title: &str) -> Option<u64> {
     None
 }
 
@@ -185,12 +393,17 @@ mod tests {
     use super::*;
 
     #[test]
-    fn label_and_title_embed_scope_and_group() {
+    fn label_embeds_scope_and_group() {
         assert_eq!(detached_label("p1", "g-3"), "detached-p1-g-3");
-        assert_eq!(detached_title("p1", "g-3"), "Eldrun — p1 — g-3");
-        // Different groups produce different titles (no collision).
-        assert_ne!(detached_title("p1", "g-3"), detached_title("p1", "g-4"));
-        assert_ne!(detached_title("p1", "g-3"), detached_title("p2", "g-3"));
+    }
+
+    #[test]
+    fn title_is_a_human_friendly_sequence_name() {
+        assert_eq!(detached_title(1), "Eldrun win-1");
+        assert_eq!(detached_title(2), "Eldrun win-2");
+        // Distinct numbers produce distinct titles (the X11 resolver key must be
+        // unique per live window).
+        assert_ne!(detached_title(1), detached_title(2));
     }
 
     #[test]
@@ -198,4 +411,107 @@ mod tests {
         assert_eq!(detached_query("p1", "g-3"), "index.html?detached=p1:g-3");
         assert_eq!(detached_query("root", "g-1"), "index.html?detached=root:g-1");
     }
+
+    #[test]
+    fn only_macos_detached_windows_use_native_decorations() {
+        assert!(detached_decorations(crate::paths::OsKind::Macos));
+        assert!(!detached_decorations(crate::paths::OsKind::Windows));
+        assert!(!detached_decorations(crate::paths::OsKind::Unix));
+    }
+
+    #[test]
+    fn restore_geometry_is_applied_as_physical_pixels() {
+        // The frontend ships PHYSICAL desktop px (`src/lib/coords.ts`); a detached
+        // window MUST apply them via the `Physical` dpi variant, NOT the builder's
+        // LOGICAL setters — otherwise it lands off-screen on any scale != 1.0
+        // display (the #42 Windows regression). Pin both the variant and value so a
+        // revert to logical (or to LogicalPosition/LogicalSize) fails the build.
+        match detached_position(Some(1500.0), Some(820.0)) {
+            Some(Position::Physical(p)) => {
+                assert_eq!(p.x, 1500);
+                assert_eq!(p.y, 820);
+            }
+            other => panic!("expected a physical position, got {other:?}"),
+        }
+        match detached_size(Some(900.0), Some(640.0)) {
+            Some(Size::Physical(s)) => {
+                assert_eq!(s.width, 900);
+                assert_eq!(s.height, 640);
+            }
+            other => panic!("expected a physical size, got {other:?}"),
+        }
+    }
+
+    fn tracked(label: &str, window_id: Option<u64>) -> TrackedWindow {
+        TrackedWindow {
+            id: label.to_string(),
+            exec: "eldrun-detached".to_string(),
+            file: None,
+            pid: 1,
+            project_id: Some("p1".to_string()),
+            role: Some("g-1".to_string()),
+            opened_at: 0.0,
+            window_id,
+            origin: ORIGIN_DETACHED_SUBWINDOW.to_string(),
+        }
+    }
+
+    #[test]
+    fn released_numbers_are_reused_lowest_first() {
+        // The user-visible guarantee: a lone popout is always "win-1". Reserve
+        // three, release the first two (whichever way their windows died), and
+        // the next detach must take 1 — not climb to 4.
+        let mut reg = WindowRegistry::default();
+        assert_eq!(reserve_detached_seq(&mut reg, "detached-p1-g-1"), 1);
+        assert_eq!(reserve_detached_seq(&mut reg, "detached-p1-g-2"), 2);
+        assert_eq!(reserve_detached_seq(&mut reg, "detached-p1-g-3"), 3);
+        release_detached_entry(&mut reg, "detached-p1-g-1");
+        release_detached_entry(&mut reg, "detached-p1-g-2");
+        assert_eq!(reserve_detached_seq(&mut reg, "detached-p1-g-4"), 1);
+        // 3 is still live, so the one after takes 2, never a duplicate 3.
+        assert_eq!(reserve_detached_seq(&mut reg, "detached-p1-g-5"), 2);
+    }
+
+    #[test]
+    fn release_is_idempotent_and_returns_the_native_id() {
+        // The Destroyed hook fires after `attach_subwindow` already freed the
+        // entry, so a second release of the same label must be a clean no-op.
+        let mut reg = WindowRegistry::default();
+        let label = "detached-p1-g-1";
+        reserve_detached_seq(&mut reg, label);
+        reg.windows.insert(label.to_string(), tracked(label, Some(42)));
+        assert_eq!(release_detached_entry(&mut reg, label), Some(42));
+        assert!(reg.detached_seqs.is_empty());
+        assert!(reg.windows.is_empty());
+        // Second release (and a never-registered label): no-op, no id.
+        assert_eq!(release_detached_entry(&mut reg, label), None);
+        assert_eq!(release_detached_entry(&mut reg, "detached-p1-g-9"), None);
+    }
+
+    #[test]
+    fn release_without_native_id_still_frees_the_number() {
+        // A popout whose native id never resolved (e.g. macOS) must still give
+        // its display number back.
+        let mut reg = WindowRegistry::default();
+        let label = "detached-p1-g-1";
+        reserve_detached_seq(&mut reg, label);
+        reg.windows.insert(label.to_string(), tracked(label, None));
+        assert_eq!(release_detached_entry(&mut reg, label), None);
+        assert_eq!(reserve_detached_seq(&mut reg, "detached-p1-g-2"), 1);
+    }
+
+    #[test]
+    fn missing_or_invalid_geometry_keeps_the_default() {
+        // A partial position is ignored (WM places the window).
+        assert!(detached_position(Some(10.0), None).is_none());
+        assert!(detached_position(None, Some(10.0)).is_none());
+        assert!(detached_position(None, None).is_none());
+        // Non-positive or partial size keeps the logical default — never a 0×0 or
+        // negative window from a stale/garbage payload.
+        assert!(detached_size(Some(0.0), Some(640.0)).is_none());
+        assert!(detached_size(Some(900.0), Some(0.0)).is_none());
+        assert!(detached_size(Some(900.0), Some(-1.0)).is_none());
+        assert!(detached_size(None, Some(640.0)).is_none());
+        assert!(detached_size(Some(900.0), None).is_none());
+    }
 }
diff --git a/src-tauri/src/commands/sync.rs b/src-tauri/src/commands/sync.rs
new file mode 100644
index 0000000..4651154
--- /dev/null
+++ b/src-tauri/src/commands/sync.rs
@@ -0,0 +1,1164 @@
+//! Selective local↔remote sync commands for remote (SSH) projects.
+//!
+//! SSH-sync Phase 1 (`docs/ssh_sync_plan.md`). The user marks files/folders in
+//! the remote file view to mirror locally; nothing syncs automatically. These
+//! commands orchestrate the `services::remote_sync` core: they resolve the pooled
+//! SFTP session, walk + pull the chosen subtree into the mirror, and update the
+//! single-writer manifest. Pull progress is streamed as `sync-progress` events so
+//! the file tree can show a spinner row (mirroring `fs_watch`'s `fs-change`).
+//!
+//! Every command requires the project's pooled connection to be live (the whole
+//! remote surface is gated on `ssh == connected`); a cold pool errors cleanly
+//! rather than opening a one-shot session, since bulk transfers must ride the
+//! shared ControlMaster.
+
+use std::sync::Arc;
+
+use futures_util::{stream, StreamExt};
+use openssh_sftp_client::Sftp;
+use serde::Serialize;
+use tauri::{AppHandle, Emitter, State};
+
+use crate::schema::net_usage;
+use crate::services::big_folders;
+use crate::services::local_loss;
+use crate::services::remote::{remote_target_for, pooled_sftp, RemotePoolState, RemoteTarget};
+use crate::services::remote_sync::{
+    self, ensure_loaded, join_remote, local_meta, local_size_mtime, mirror_local_path, Manifest,
+    PushDecision, SyncManifestState, SyncState,
+};
+use crate::services::sftp;
+
+/// Max concurrent host re-stats during a `sync_status` refresh. The SFTP client
+/// pipelines these over the one pooled channel; this bounds the in-flight count
+/// so a large selection can't flood it.
+const STAT_CONCURRENCY: usize = 16;
+
+/// Size cutoff for content-verifying an amber verdict during a `sync_status`
+/// refresh. Size+mtime is only a *heuristic* for divergence — a re-save with the
+/// same bytes, or a bare `touch`, moves the mtime while the content is unchanged,
+/// so the file paints amber with nothing actually to resolve. For files at or
+/// below this size we confirm the amber against the actual bytes and downgrade a
+/// byte-identical pair to green (re-recording the base so it *stays* green). Files
+/// ABOVE this keep the pure metadata heuristic — reading them over SFTP on every
+/// refresh is exactly the cost the heuristic exists to avoid.
+const CONTENT_VERIFY_MAX_BYTES: u64 = 1024 * 1024; // 1 MiB
+
+/// A rebase captured when an amber file proves byte-identical: the host + local
+/// `(size, mtime)` to stamp as the new sync base so the file goes (and stays)
+/// green instead of re-reading its bytes on every refresh.
+struct ContentRebase {
+    rel: String,
+    host_size: u64,
+    host_mtime: Option<u64>,
+    local_size: u64,
+    local_mtime: Option<u64>,
+}
+
+/// Confirm an amber verdict against the actual bytes, for a file small enough to
+/// be worth reading. Returns `Some(rebase)` only when both sides exist, are the
+/// same size, sit within [`CONTENT_VERIFY_MAX_BYTES`], and hold identical bytes —
+/// i.e. the divergence was metadata-only. Returns `None` (stay amber) otherwise,
+/// including on any read error: an unreadable side keeps the conservative amber.
+async fn verify_amber_identical(
+    sftp: &Sftp,
+    host_abs: &str,
+    mirror_path: &std::path::Path,
+    rel: &str,
+    host: (u64, Option<u64>),
+    local: (u64, Option<u64>),
+) -> Option<ContentRebase> {
+    let (host_size, host_mtime) = host;
+    let (local_size, local_mtime) = local;
+    // Gate the read on the pure heuristic-vs-content policy (both sides present,
+    // same size, within the cutoff — large files keep the metadata heuristic).
+    if !remote_sync::content_verify_worth_it(host, local, CONTENT_VERIFY_MAX_BYTES) {
+        return None;
+    }
+    let host_bytes = sftp::read_file_on(sftp, host_abs).await.ok()?;
+    let local_bytes = std::fs::read(mirror_path).ok()?;
+    (host_bytes == local_bytes).then_some(ContentRebase {
+        rel: rel.to_string(),
+        host_size,
+        host_mtime,
+        local_size,
+        local_mtime,
+    })
+}
+
+/// One row of sync status for the file-tree overlay.
+#[derive(Debug, Clone, Serialize)]
+pub struct SyncStatusEntry {
+    /// Project-relative path (forward slashes).
+    pub rel_path: String,
+    pub is_dir: bool,
+    pub selected: bool,
+    /// `green` | `amber` | `none`.
+    pub state: SyncState,
+    /// Effective auto-sync: this path's own entry or an ancestor auto folder
+    /// marker (`remote_sync::is_auto`). Drives the file-tree/viewer auto glyph.
+    pub auto_sync: bool,
+    /// This path's OWN byte-sync exclusion marker (not an inherited one): what
+    /// the file tree flips "Exclude from sync" to "Include in sync" on, and what
+    /// the giant-folder prompt shows as the standing answer. Inheritance is the
+    /// transfer paths' business (`remote_sync::is_excluded`), not a row's label.
+    pub excluded: bool,
+    /// Current host modification time when known. This is display metadata for
+    /// the diverged-files list; sync decisions still compare each side to its
+    /// recorded base so host/local clock skew cannot choose an authority.
+    pub host_mtime: Option<u64>,
+    /// Current local-mirror modification time when known.
+    pub local_mtime: Option<u64>,
+}
+
+/// Progress payload for the `sync-progress` event (one per transferred file plus
+/// start/done bookends), keyed by project so the frontend can ignore other
+/// projects' transfers.
+#[derive(Debug, Clone, Serialize)]
+struct SyncProgress {
+    project_id: String,
+    /// `start` | `file` | `done`.
+    phase: String,
+    /// The file just transferred (`phase == "file"`), else the synced root.
+    rel_path: String,
+    done: usize,
+    total: usize,
+}
+
+/// Resolve the remote target + live pooled SFTP session for `project_id`, erroring
+/// if the project is local or its connection is cold (reconnect first).
+async fn resolve(
+    project_id: &str,
+    pool: &RemotePoolState,
+) -> Result<(RemoteTarget, Arc<Sftp>), String> {
+    let target = remote_target_for(project_id)
+        .ok_or_else(|| "not a remote project".to_string())?;
+    let sftp = pooled_sftp(pool, project_id)
+        .await
+        .ok_or_else(|| "remote project not connected — reconnect first".to_string())?;
+    Ok((target, sftp))
+}
+
+/// Pull a single file or a whole folder subtree from the host into the local
+/// mirror, marking each pulled file selected and recording its base. `rel_path`
+/// is project-relative (`""` = the whole project root). Returns the number of
+/// files transferred. Streams `sync-progress` as it goes.
+#[tauri::command]
+pub async fn sync_pull(
+    app: AppHandle,
+    project_id: String,
+    rel_path: String,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<usize, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    pull_subtree(&app, &project_id, &target, &sftp, &rel_path, manifest.inner()).await
+}
+
+/// Pull the entire project tree into the mirror (the one-click "sync whole
+/// project"). Equivalent to `sync_pull` with an empty `rel_path`.
+#[tauri::command]
+pub async fn sync_whole_project(
+    app: AppHandle,
+    project_id: String,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<usize, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    pull_subtree(&app, &project_id, &target, &sftp, "", manifest.inner()).await
+}
+
+/// Re-pull every currently-selected file (the "sync now" reconcile): brings the
+/// mirror back in step with the host and clears amber → green. Returns the number
+/// of files re-pulled.
+#[tauri::command]
+pub async fn sync_now(
+    app: AppHandle,
+    project_id: String,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<usize, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    // Snapshot the selected file paths under the lock, then transfer outside it.
+    let selected: Vec<String> = {
+        let mut guard = manifest.lock().await;
+        let m = ensure_loaded(&mut guard, &project_id);
+        m.iter()
+            .filter(|(_, e)| e.selected && !e.is_dir)
+            .map(|(k, _)| k.clone())
+            .collect()
+    };
+    // #28q: "clears amber → green" means the host wins every file that moved on both
+    // sides. Name the local edits that costs before overwriting them.
+    let doomed = unsynced_local_edits(&project_id, manifest.inner(), &selected).await;
+    warn_overwritten(&project_id, "Sync now (re-pulled every selected file)", doomed);
+
+    let total = selected.len();
+    emit(&app, &project_id, "start", "", 0, total);
+    let mut done = 0usize;
+    for rel in selected {
+        let host_abs = join_remote(&target.spec.remote_path, &rel);
+        let (size, mtime) = remote_sync::stat_or_zero(&sftp, &host_abs).await;
+        let local = mirror_local_path(&project_id, &rel);
+        if remote_sync::pull_file(&sftp, &host_abs, size, &local).await.is_ok() {
+            let local_meta = std::fs::metadata(&local).ok();
+            let (ls, lm) = local_size_mtime(local_meta);
+            let mut guard = manifest.lock().await;
+            let m = ensure_loaded(&mut guard, &project_id);
+            remote_sync::record_pull(m, &rel, size, mtime, ls, lm);
+            let _ = remote_sync::save_manifest(&project_id, m);
+            net_usage::record_files(&project_id, 1, 0);
+        }
+        done += 1;
+        emit(&app, &project_id, "file", &rel, done, total);
+    }
+    emit(&app, &project_id, "done", "", done, total);
+    Ok(done)
+}
+
+/// Toggle the `selected` flag for one or more project-relative paths WITHOUT
+/// transferring anything (e.g. deselecting to stop tracking). Selecting a path
+/// the user then wants mirrored is followed by `sync_pull`; selecting alone just
+/// records intent. Mirror bytes are left in place on deselect.
+#[tauri::command]
+pub async fn sync_mark_selected(
+    project_id: String,
+    rel_paths: Vec<String>,
+    selected: bool,
+    is_dir: bool,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<(), String> {
+    let mut guard = manifest.lock().await;
+    let m = ensure_loaded(&mut guard, &project_id);
+    for rel in &rel_paths {
+        let entry = m.entry(rel.clone()).or_default();
+        entry.selected = selected;
+        if is_dir {
+            entry.is_dir = true;
+        }
+    }
+    remote_sync::save_manifest(&project_id, m)
+}
+
+/// Toggle auto-sync for one or more project-relative paths. Turning it ON sets
+/// `auto_sync` (and implies `selected = true`, clearing any exclusion). On a
+/// directory the marker covers the whole subtree (resolved by
+/// `remote_sync::is_auto`); the empty path `""` is the project-wide "auto-sync
+/// all" root marker. Turning it OFF records an explicit `auto_off` EXCLUSION
+/// (clearing `auto_sync`) so a path can be carved out of an ancestor's — or the
+/// project-wide — auto-sync; `selected` is left as-is (manual tracking continues),
+/// matching the deselect-leaves-bytes convention. No bytes transfer here — the
+/// background reconcile engine (`services::sync_auto`) acts on its next pass.
+#[tauri::command]
+pub async fn sync_set_auto(
+    project_id: String,
+    rel_paths: Vec<String>,
+    auto: bool,
+    is_dir: bool,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<(), String> {
+    let mut guard = manifest.lock().await;
+    let m = ensure_loaded(&mut guard, &project_id);
+    for rel in &rel_paths {
+        let entry = m.entry(rel.clone()).or_default();
+        entry.auto_sync = auto;
+        // OFF writes an explicit exclusion (overrides an ancestor/project-wide
+        // auto); ON clears any prior exclusion and marks the path tracked.
+        entry.auto_off = !auto;
+        if auto {
+            entry.selected = true;
+        }
+        if is_dir {
+            entry.is_dir = true;
+        }
+    }
+    remote_sync::save_manifest(&project_id, m)
+}
+
+/// What turning auto-sync ON over a host subtree would start pulling.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AutoSyncPreview {
+    pub files: usize,
+    pub bytes: u64,
+}
+
+/// Cost preview for `sync_set_auto(auto = true)` on a directory. Read-only.
+///
+/// Byte-sync's scope is an explicit opt-in manifest and it does **not** read
+/// `.gitignore` — the two systems have different notions of what is in scope. So
+/// marking a host folder auto is the one click that can start hauling a tree the
+/// user deliberately keeps host-side (experiment output, checkpoints: gitignored,
+/// therefore also invisible to lockstep) into the local mirror. The frontend calls
+/// this first and confirms when the answer is large, so the pull is a decision
+/// rather than a surprise.
+///
+/// Walks the **host** because that is the side that holds the bytes in the case
+/// worth warning about; a `rel` that is a file (not a directory) fails the walk
+/// and reports a single entry, which is never large enough to warn on anyway.
+#[tauri::command]
+pub async fn sync_auto_preview(
+    project_id: String,
+    rel_path: String,
+    pool: State<'_, RemotePoolState>,
+) -> Result<AutoSyncPreview, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    let files = remote_sync::walk_host_files(&sftp, &target.spec.remote_path, &rel_path).await?;
+    Ok(AutoSyncPreview {
+        files: files.len(),
+        bytes: files.iter().map(|f| f.size).sum(),
+    })
+}
+
+/// One folder big enough to be worth a question before the first sync pass, with
+/// what each side holds. A folder that exists on only one side reports zeros for
+/// the other — which is itself the answer to "is this the host's data or mine?".
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BigFolderRow {
+    pub rel: String,
+    pub local_files: u64,
+    pub local_bytes: u64,
+    pub host_files: u64,
+    pub host_bytes: u64,
+    /// Already carrying an explicit exclusion marker (so re-opening the prompt
+    /// shows the standing answer rather than asking again from scratch).
+    pub excluded: bool,
+}
+
+/// The whole giant-folder answer, plus which sides it could actually measure.
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BigFolderScan {
+    pub folders: Vec<BigFolderRow>,
+    /// The host tree was walked (i.e. the pool was live). When false the rows
+    /// carry local numbers only — the caller re-runs once the project connects.
+    pub host_scanned: bool,
+    /// Why the host side is missing, when it is and the reason isn't "cold pool".
+    pub host_error: Option<String>,
+}
+
+/// Find the folders too big to sync silently — on **both** sides.
+///
+/// This is the question `sync_auto_preview` asks one folder at a time, asked for
+/// the whole project at the moment it matters: a project just created, imported,
+/// or extended to a host, before anything has been hauled anywhere. Byte-sync
+/// does not read `.gitignore`, so nothing else in the system would ever mention
+/// that `node_modules/`, `data/` or `checkpoints/` is about to cross.
+///
+/// Read-only. The local mirror is walked directly; the host side is one `du -ak`
+/// round trip over the pooled ControlMaster, and is **skipped** (not attempted)
+/// when the pool is cold — dispatching at a dead session is what freezes the
+/// window, and a disconnected project's answer is simply "local only, ask again
+/// once connected".
+///
+/// `scan_host` (default **true**, so an ordinary host behaves exactly as before)
+/// is what a **careful** host turns off. `du -ak -x` stats every file under the
+/// project root, and on a cluster that root is very often on the *parallel*
+/// filesystem — because that is precisely where the HPC workspace feature puts
+/// it. A recursive stat of a whole tree is a metadata storm against a shared
+/// Lustre/GPFS metadata server, which is the kind of thing a site's usage policy
+/// actually names. That it is also *cheap for us* and *automatic on connect* is
+/// what makes it worth gating: the caller decides, and a careful host's census
+/// runs local-only until the user asks for the host half by name.
+///
+/// The host half is skipped, never faked: `hostScanned` stays false, which the
+/// dialog already renders as "—" per row rather than as a zero.
+#[tauri::command]
+pub async fn sync_big_folders(
+    project_id: String,
+    scan_host: Option<bool>,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<BigFolderScan, String> {
+    let target = remote_target_for(&project_id)
+        .ok_or_else(|| "not a remote project".to_string())?;
+
+    // Local mirror walk (blocking fs work — off the UI thread).
+    let mirror = remote_sync::mirror_dir(&project_id);
+    let local = tokio::task::spawn_blocking(move || big_folders::scan_local(&mirror))
+        .await
+        .map_err(|e| e.to_string())?;
+
+    // Host walk, only when asked for AND with a live pool behind it. The pool
+    // check is skipped entirely when the caller doesn't want the host half, so a
+    // careful host is never even dialled for it.
+    // A tagged HPC host never gets the `du` half, whatever the caller asked for:
+    // the frontend already withholds it for a careful host, and this is the same
+    // refusal made unconditional where the tag is known — a census is automatic
+    // (it fires on connect), so there is no moment at which the user asked for
+    // this particular walk of a parallel filesystem.
+    let scan_host = scan_host.unwrap_or(true)
+        && !crate::services::hpc_mode::is_hpc_spec(&target.spec);
+    let connected = scan_host && pooled_sftp(pool.inner(), &project_id).await.is_some();
+    let mut host_error = None;
+    let host = if connected {
+        let spec = target.spec.clone();
+        let root = spec.remote_path.clone();
+        match tokio::task::spawn_blocking(move || crate::services::ssh_exec::remote_du_raw(&spec, &root))
+            .await
+            .map_err(|e| e.to_string())?
+        {
+            Ok(out) => big_folders::scan_host(&target.spec.remote_path, &out),
+            Err(e) => {
+                host_error = Some(e);
+                Vec::new()
+            }
+        }
+    } else {
+        Vec::new()
+    };
+
+    // Merge by path: one row per folder, whichever side(s) reported it.
+    let mut rows: std::collections::BTreeMap<String, BigFolderRow> = Default::default();
+    for f in local {
+        let row = rows.entry(f.rel.clone()).or_insert(BigFolderRow {
+            rel: f.rel.clone(),
+            local_files: 0,
+            local_bytes: 0,
+            host_files: 0,
+            host_bytes: 0,
+            excluded: false,
+        });
+        row.local_files = f.files;
+        row.local_bytes = f.bytes;
+    }
+    for f in host {
+        let row = rows.entry(f.rel.clone()).or_insert(BigFolderRow {
+            rel: f.rel.clone(),
+            local_files: 0,
+            local_bytes: 0,
+            host_files: 0,
+            host_bytes: 0,
+            excluded: false,
+        });
+        row.host_files = f.files;
+        row.host_bytes = f.bytes;
+    }
+
+    let mut folders: Vec<BigFolderRow> = {
+        let mut guard = manifest.lock().await;
+        let m = ensure_loaded(&mut guard, &project_id);
+        rows.into_values()
+            .map(|mut r| {
+                r.excluded = m.get(&r.rel).map(|e| e.excluded).unwrap_or(false);
+                r
+            })
+            .collect()
+    };
+    folders.sort_by(|a, b| {
+        (b.host_bytes.max(b.local_bytes)).cmp(&a.host_bytes.max(a.local_bytes))
+    });
+
+    Ok(BigFolderScan { folders, host_scanned: connected, host_error })
+}
+
+/// Record (or lift) an explicit byte-sync **exclusion** for one or more folders —
+/// the answer the giant-folder prompt collects.
+///
+/// Stronger than `sync_set_auto(false)`, which only carves a path out of the
+/// background engine: an exclusion is also honoured by the one-click whole-project
+/// pull and push (`pull_subtree` / `sync_push`), which is the transfer the prompt
+/// exists to keep off a multi-GB tree. Nothing is deleted either way — mirror bytes
+/// already present stay exactly where they are.
+#[tauri::command]
+pub async fn sync_set_excluded(
+    project_id: String,
+    rel_paths: Vec<String>,
+    excluded: bool,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<(), String> {
+    let mut guard = manifest.lock().await;
+    let m = ensure_loaded(&mut guard, &project_id);
+    for rel in &rel_paths {
+        let entry = m.entry(rel.clone()).or_default();
+        entry.excluded = excluded;
+        entry.is_dir = true;
+        if excluded {
+            // An excluded folder is not auto-synced, whatever an ancestor (or the
+            // project-wide root marker) says — otherwise the background engine
+            // would keep hauling what the pull path now skips.
+            entry.auto_sync = false;
+            entry.auto_off = true;
+        }
+    }
+    remote_sync::save_manifest(&project_id, m)
+}
+
+/// Return the sync status of every tracked path, re-stat'ing each selected FILE
+/// on the host so the green/amber state is fresh (amber = host moved since the
+/// last fetch). Directories report their stored selection (no re-stat). This is
+/// the explicit "refresh" the plan calls out — there is no live watcher.
+#[tauri::command]
+pub async fn sync_status(
+    project_id: String,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<Vec<SyncStatusEntry>, String> {
+    // A local project has no sync; return empty rather than erroring (callers may
+    // probe indiscriminately).
+    let Some(target) = remote_target_for(&project_id) else {
+        return Ok(Vec::new());
+    };
+    // Snapshot the whole manifest under the lock; re-stat outside it. The full
+    // snapshot (not just the (k,v) list) lets `is_auto` walk ancestor folder
+    // markers to resolve each row's effective auto-sync flag.
+    let snapshot: Manifest = {
+        let mut guard = manifest.lock().await;
+        ensure_loaded(&mut guard, &project_id).clone()
+    };
+    let entries: Vec<(String, crate::services::remote_sync::SyncEntry)> =
+        snapshot.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
+    // Re-stat selected files when the pool is live; if cold, fall back to the
+    // stored base (green for selected) rather than erroring out the whole panel.
+    let sftp = pooled_sftp(pool.inner(), &project_id).await;
+    let mut out = Vec::with_capacity(entries.len());
+    // Partition without any network first: only selected FILES against a live
+    // pool need a host re-stat. Everything else (unselected → none, directories →
+    // green, cold pool → last-known-good green) resolves immediately.
+    let mut to_stat: Vec<(String, crate::services::remote_sync::SyncEntry, bool, bool)> = Vec::new();
+    for (rel, entry) in entries {
+        // Effective auto-sync and exclusion both resolve against the whole manifest
+        // (ancestor folder markers), so compute them before `rel` is moved into the
+        // row. A file excluded only via an ancestor folder marker (no marker of its
+        // own) must still drop out of the diverged (amber) view — `entry.excluded`
+        // alone (the row's OWN marker, see `SyncStatusEntry::excluded`) would miss
+        // that case.
+        let auto = remote_sync::is_auto(&snapshot, &rel);
+        let excluded_eff = remote_sync::is_excluded(&snapshot, &rel, "");
+        if !entry.selected {
+            out.push(SyncStatusEntry {
+                rel_path: rel,
+                is_dir: entry.is_dir,
+                selected: false,
+                state: SyncState::None,
+                auto_sync: false, // auto implies selected, so unselected is never auto
+                excluded: entry.excluded,
+                host_mtime: None,
+                local_mtime: None,
+            });
+        } else if entry.is_dir {
+            out.push(SyncStatusEntry {
+                rel_path: rel,
+                is_dir: true,
+                selected: true,
+                state: SyncState::Green,
+                auto_sync: auto,
+                excluded: entry.excluded,
+                host_mtime: None,
+                local_mtime: None,
+            });
+        } else if sftp.is_some() {
+            to_stat.push((rel, entry, auto, excluded_eff));
+        } else {
+            // Cold pool: the host can't be re-stat'd, but the local mirror still
+            // can (no network) — so a local-only edit made while disconnected
+            // still surfaces as amber instead of a stale green.
+            let local = std::fs::metadata(mirror_local_path(&project_id, &rel))
+                .ok()
+                .map(|m| local_meta(&m));
+            let state = remote_sync::compute_state(&entry, None, local, excluded_eff);
+            out.push(SyncStatusEntry {
+                rel_path: rel,
+                is_dir: false,
+                selected: true,
+                state,
+                auto_sync: auto,
+                excluded: entry.excluded,
+                host_mtime: None,
+                local_mtime: local.and_then(|(_, mtime)| mtime),
+            });
+        }
+    }
+    // Re-stat the selected files concurrently over the pooled SFTP session. The
+    // client multiplexes many in-flight requests over the one channel, so a large
+    // selection is latency-bound (~one round-trip worth) instead of N sequential
+    // round-trips. `buffer_unordered` caps the in-flight count so a huge selection
+    // can't flood the channel; order is irrelevant (the frontend keys status by
+    // `rel_path`). The stat/compare rule itself is unchanged.
+    if let Some(sftp) = &sftp {
+        let statted = stream::iter(to_stat.into_iter().map(|(rel, entry, auto, excluded_eff)| {
+            let sftp = Arc::clone(sftp);
+            let root = target.spec.remote_path.clone();
+            let project_id = project_id.clone();
+            async move {
+                let host_abs = join_remote(&root, &rel);
+                let (size, mtime) = remote_sync::stat_or_zero(&sftp, &host_abs).await;
+                // Also re-stat the local mirror so a local-only edit flips to amber
+                // (symmetric divergence — the host may be unchanged).
+                let mirror_path = mirror_local_path(&project_id, &rel);
+                let local = std::fs::metadata(&mirror_path).ok().map(|m| local_meta(&m));
+                let mut state =
+                    remote_sync::compute_state(&entry, Some((size, mtime)), local, excluded_eff);
+                // A metadata-only amber (same bytes, drifted mtime/size-vs-base) is a
+                // false positive: for a small file, confirm against the actual bytes
+                // and downgrade an identical pair to green, capturing the rebase so it
+                // is re-recorded and stays green. Large files keep the heuristic.
+                let mut rebase = None;
+                if state == SyncState::Amber {
+                    if let Some(local_vals) = local {
+                        if let Some(rb) = verify_amber_identical(
+                            &sftp, &host_abs, &mirror_path, &rel, (size, mtime), local_vals,
+                        )
+                        .await
+                        {
+                            state = SyncState::Green;
+                            rebase = Some(rb);
+                        }
+                    }
+                }
+                (
+                    SyncStatusEntry {
+                        rel_path: rel,
+                        is_dir: false,
+                        selected: true,
+                        state,
+                        auto_sync: auto,
+                        excluded: entry.excluded,
+                        host_mtime: mtime,
+                        local_mtime: local.and_then(|(_, mtime)| mtime),
+                    },
+                    rebase,
+                )
+            }
+        }))
+        .buffer_unordered(STAT_CONCURRENCY)
+        .collect::<Vec<_>>()
+        .await;
+        // Split the rows from the content-verified rebases: the rows go straight to
+        // the response, the rebases are stamped into the manifest under the single-
+        // writer lock and persisted once (only when at least one file self-healed).
+        let mut rebases = Vec::new();
+        for (row, rb) in statted {
+            if let Some(rb) = rb {
+                rebases.push(rb);
+            }
+            out.push(row);
+        }
+        if !rebases.is_empty() {
+            let mut guard = manifest.lock().await;
+            let m = ensure_loaded(&mut guard, &project_id);
+            for rb in &rebases {
+                remote_sync::record_pull(
+                    m, &rb.rel, rb.host_size, rb.host_mtime, rb.local_size, rb.local_mtime,
+                );
+            }
+            let _ = remote_sync::save_manifest(&project_id, m);
+        }
+    }
+    Ok(out)
+}
+
+/// One side (local mirror OR host) of a tracked file, for the amber "resolve"
+/// popup. `exists` is false when that side has no such file (deleted/never
+/// created); `size`/`mtime` are then zero/None.
+#[derive(Debug, Clone, Serialize)]
+pub struct SideMeta {
+    pub exists: bool,
+    pub size: u64,
+    /// Unix seconds, when the side reports one.
+    pub mtime: Option<u64>,
+}
+
+/// Local + host metadata for one tracked file, plus the recorded base — backs
+/// the amber divergence popup (size/mtime on each side so the user can see what
+/// changed before choosing "take local" or "take remote").
+#[derive(Debug, Clone, Serialize)]
+pub struct SyncFileMeta {
+    pub rel_path: String,
+    pub local: SideMeta,
+    pub host: SideMeta,
+    /// Host base (size + mtime) captured at the last pull/push — what the
+    /// green/amber state is judged against.
+    pub base_size: u64,
+    pub base_mtime: Option<u64>,
+}
+
+/// Return the local-mirror and current-host metadata for one file so the amber
+/// popup can show the concrete divergence (size + mtime, per side) alongside the
+/// recorded base. Requires a live pooled connection to stat the host; a cold
+/// pool errors via `resolve` (the popup only opens for a connected project).
+#[tauri::command]
+pub async fn sync_file_meta(
+    project_id: String,
+    rel_path: String,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<SyncFileMeta, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    let host_abs = join_remote(&target.spec.remote_path, &rel_path);
+    let host = match sftp::metadata_on(&sftp, &host_abs).await {
+        Ok((size, mtime)) => SideMeta { exists: true, size, mtime },
+        Err(_) => SideMeta { exists: false, size: 0, mtime: None },
+    };
+    let local_path = mirror_local_path(&project_id, &rel_path);
+    let local = match std::fs::metadata(&local_path) {
+        Ok(m) => {
+            let (size, mtime) = local_size_mtime(Some(m));
+            SideMeta { exists: true, size, mtime }
+        }
+        Err(_) => SideMeta { exists: false, size: 0, mtime: None },
+    };
+    let (base_size, base_mtime) = {
+        let mut guard = manifest.lock().await;
+        let m = ensure_loaded(&mut guard, &project_id);
+        m.get(&rel_path).map(|e| (e.host_size, e.host_mtime)).unwrap_or((0, None))
+    };
+    Ok(SyncFileMeta { rel_path, local, host, base_size, base_mtime })
+}
+
+/// Byte-for-byte check for one diverged (amber) file, run when the three-way
+/// merge viewer opens it. If the local mirror and the current host copy hold
+/// **identical bytes**, the divergence was metadata-only (a re-save with the same
+/// content, a bare `touch`, or a stale base): re-record the sync base from both
+/// sides' fresh `(size, mtime)` so the file clears amber → green — no transfer,
+/// since the bytes already match — and return `true`. Returns `false` when the
+/// sides genuinely differ, or when either side is missing/unreadable (a real
+/// divergence the viewer must resolve). Requires a live pooled connection to read
+/// the host over SFTP; a cold pool errors via `resolve`.
+///
+/// This is the same "amber is size+mtime, not content" self-heal that
+/// [`verify_amber_identical`] applies during a `sync_status` refresh, but WITHOUT
+/// that path's size cutoff: the user explicitly opened the viewer for this one
+/// file, so reading it once — however large — is a decision, not the per-refresh
+/// cost the heuristic exists to avoid.
+#[tauri::command]
+pub async fn sync_resolve_if_identical(
+    project_id: String,
+    rel_path: String,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<bool, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    let host_abs = join_remote(&target.spec.remote_path, &rel_path);
+    // Read both sides fully. A side that can't be read (deleted on the host, never
+    // pulled locally) is not "identical" — leave it amber for the merge viewer.
+    let Ok(host_bytes) = sftp::read_file_on(&sftp, &host_abs).await else {
+        return Ok(false);
+    };
+    let mirror_path = mirror_local_path(&project_id, &rel_path);
+    let Ok(local_bytes) = std::fs::read(&mirror_path) else {
+        return Ok(false);
+    };
+    if host_bytes != local_bytes {
+        return Ok(false);
+    }
+    // Identical: stamp a fresh base from each side's current metadata so the file
+    // goes (and stays) green without any byte transfer.
+    let (host_size, host_mtime) = sftp::metadata_on(&sftp, &host_abs)
+        .await
+        .unwrap_or((host_bytes.len() as u64, None));
+    let (ls, lm) = local_size_mtime(std::fs::metadata(&mirror_path).ok());
+    let mut guard = manifest.lock().await;
+    let m = ensure_loaded(&mut guard, &project_id);
+    remote_sync::record_pull(m, &rel_path, host_size, host_mtime, ls, lm);
+    remote_sync::save_manifest(&project_id, m)?;
+    Ok(true)
+}
+
+/// Result of a local→remote push: how many files were written, and which
+/// project-relative paths were blocked by a stale host base (only populated when
+/// `force` is false — the frontend prompts per conflict and re-calls with the
+/// user's choice).
+#[derive(Debug, Clone, Serialize)]
+pub struct SyncPushResult {
+    pub pushed: usize,
+    pub conflicts: Vec<String>,
+}
+
+/// Push a local mirror file or folder subtree to the host (the bidirectional
+/// other half of `sync_pull`). For each file: re-stat the host and compare to the
+/// manifest base. A file whose host base is unchanged (or that the host doesn't
+/// have yet) is written atomically (temp + rename). A file whose host moved since
+/// the last sync is BLOCKED and returned in `conflicts` — unless `force` is set
+/// (the user chose "keep local"), which overwrites it. Never silently clobbers.
+#[tauri::command]
+pub async fn sync_push(
+    app: AppHandle,
+    project_id: String,
+    rel_path: String,
+    force: bool,
+    pool: State<'_, RemotePoolState>,
+    manifest: State<'_, SyncManifestState>,
+) -> Result<SyncPushResult, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    let files = remote_sync::walk_mirror_files(&project_id, &rel_path)?;
+    // Excluded folders are excluded in BOTH directions: a mirror-side copy of an
+    // excluded tree (an earlier pull, a local build) must not be pushed up either.
+    let files: Vec<String> = {
+        let mut guard = manifest.lock().await;
+        let m = ensure_loaded(&mut guard, &project_id);
+        files
+            .into_iter()
+            .filter(|rel| !remote_sync::is_excluded(m, rel, &rel_path))
+            .collect()
+    };
+    let total = files.len();
+    emit(&app, &project_id, "start", &rel_path, 0, total);
+    let mut pushed = 0usize;
+    let mut conflicts = Vec::new();
+    let mut done = 0usize;
+    for rel in files {
+        let host_abs = join_remote(&target.spec.remote_path, &rel);
+        let host = sftp::metadata_on(&sftp, &host_abs).await.ok();
+        // Snapshot the base under the lock (released before the transfer).
+        let base = {
+            let mut guard = manifest.lock().await;
+            let m = ensure_loaded(&mut guard, &project_id);
+            m.get(&rel).cloned().unwrap_or_default()
+        };
+        if remote_sync::push_decision(&base, host) == PushDecision::Stale && !force {
+            conflicts.push(rel.clone());
+            done += 1;
+            emit(&app, &project_id, "file", &rel, done, total);
+            continue;
+        }
+        let local = mirror_local_path(&project_id, &rel);
+        match remote_sync::push_file_atomic(&sftp, &local, &host_abs).await {
+            Ok((hs, hm)) => {
+                let (ls, lm) = local_size_mtime(std::fs::metadata(&local).ok());
+                let mut guard = manifest.lock().await;
+                let m = ensure_loaded(&mut guard, &project_id);
+                remote_sync::record_push(m, &rel, hs, hm, ls, lm);
+                let _ = remote_sync::save_manifest(&project_id, m);
+                net_usage::record_files(&project_id, 0, 1);
+                pushed += 1;
+            }
+            Err(e) => eprintln!("sync_push: skip '{rel}': {e}"),
+        }
+        done += 1;
+        emit(&app, &project_id, "file", &rel, done, total);
+    }
+    emit(&app, &project_id, "done", &rel_path, done, total);
+    Ok(SyncPushResult { pushed, conflicts })
+}
+
+/// Unified diff of the local mirror copy (old / "local") against the current host
+/// copy (new / "host") for one file. Backs the file-tree's diverged (amber) diff
+/// button: the host moved past our mirrored base, so this shows exactly what
+/// changed on the host before the user re-syncs. Requires a live pooled
+/// connection (reads the host over SFTP); a cold pool errors via `resolve`.
+#[tauri::command]
+pub async fn sync_diff(
+    project_id: String,
+    rel_path: String,
+    pool: State<'_, RemotePoolState>,
+) -> Result<String, String> {
+    let (target, sftp) = resolve(&project_id, pool.inner()).await?;
+    let host_abs = join_remote(&target.spec.remote_path, &rel_path);
+    // Host bytes now (empty if the host no longer has the file → shown as a full
+    // deletion by the diff).
+    let host_bytes = sftp::read_file_on(&sftp, &host_abs).await.unwrap_or_default();
+    let mirror_path = mirror_local_path(&project_id, &rel_path);
+    // Compute the diff LOCALLY (never over SSH — the mirror is on disk and the
+    // host bytes are already in memory). Off the async thread: git spawns a
+    // subprocess.
+    let rel = rel_path.clone();
+    tokio::task::spawn_blocking(move || diff_mirror_vs_host(&mirror_path, &host_bytes, &rel))
+        .await
+        .map_err(|e| format!("sync_diff task failed: {e}"))?
+}
+
+// ── Internals ──────────────────────────────────────────────────────────────
+
+/// The paths, among `rels`, whose mirror copy holds edits that exist **nowhere else**,
+/// and which the pull about to run will therefore overwrite and lose (#28q).
+///
+/// A pull is the one byte-sync operation that destroys something: it writes the host's
+/// bytes over the mirror's, and `sync_now`'s whole job — "clears amber → green" — is to
+/// do exactly that to files that moved on *both* sides. Which reads as bringing things
+/// in step, and is also, silently, choosing the host and discarding the local edit. The
+/// auto-sync engine never does this (it skips an amber file rather than pick a winner);
+/// only the manual commands do, and only because the user asked. So: not blocked, but
+/// no longer silent.
+///
+/// A path qualifies only when we can be sure there was something to lose: it has a
+/// recorded base (byte-sync has synced it before — so the base is a real "as of" mark,
+/// not a zeroed default), its mirror file is still there (a pull that *creates* a file
+/// destroys nothing), and its current size/mtime differ from that base. That is the same
+/// local-divergence rule the file tree already paints amber, so the warning names
+/// exactly the files the user was already being shown as locally changed.
+async fn unsynced_local_edits(
+    project_id: &str,
+    manifest: &SyncManifestState,
+    rels: &[String],
+) -> Vec<String> {
+    let mut guard = manifest.lock().await;
+    let m = ensure_loaded(&mut guard, project_id);
+    rels.iter()
+        .filter(|rel| {
+            let Some(entry) = m.get(rel.as_str()) else {
+                return false; // never synced → no base to have diverged from
+            };
+            if entry.last_pull_ts.is_none() && entry.last_push_ts.is_none() {
+                return false;
+            }
+            let Some(meta) = std::fs::metadata(mirror_local_path(project_id, rel)).ok() else {
+                return false; // no mirror file → the pull only creates
+            };
+            let (_, local_changed) = remote_sync::divergence(entry, None, Some(local_meta(&meta)));
+            local_changed
+        })
+        .cloned()
+        .collect()
+}
+
+/// File the warning for the local edits a pull just overwrote. Called with the list
+/// captured *before* the transfer — afterwards the evidence is, by definition, gone.
+fn warn_overwritten(project_id: &str, op: &str, paths: Vec<String>) {
+    local_loss::record_paths(
+        project_id,
+        local_loss::LossSource::Sync,
+        local_loss::LossKind::Overwritten,
+        op,
+        paths,
+        None, // the edits were only ever in the mirror — there is nowhere to get them back from
+    );
+}
+
+/// Pull `rel` (a single file OR a whole folder subtree) from the host into the
+/// mirror, recording each file's base in the manifest. Shared by `sync_pull` and
+/// `sync_whole_project`.
+///
+/// For a directory, the bulk transfer prefers the rsync fast-path (delta +
+/// single connection, riding the ControlMaster) when rsync is present on BOTH
+/// ends, falling back to the SFTP-native per-file walker (the floor) when it is
+/// missing or rsync fails. Either way the manifest bases come from the host walk
+/// (metadata only — no extra byte transfer) plus a local stat.
+async fn pull_subtree(
+    app: &AppHandle,
+    project_id: &str,
+    target: &RemoteTarget,
+    sftp: &Sftp,
+    rel: &str,
+    manifest: &SyncManifestState,
+) -> Result<usize, String> {
+    // Determine whether `rel` is a directory (walkable) or a single file.
+    let (files, is_dir) = match remote_sync::walk_host_files(sftp, &target.spec.remote_path, rel).await
+    {
+        Ok(f) => (f, true),
+        Err(_) => {
+            // Not a directory — treat `rel` as a single file (stat it).
+            let host_abs = join_remote(&target.spec.remote_path, rel);
+            let (size, mtime) = crate::services::sftp::metadata_on(sftp, &host_abs).await?;
+            (
+                vec![remote_sync::HostFile { rel: rel.to_string(), size, mtime }],
+                false,
+            )
+        }
+    };
+    // Drop everything the user excluded from byte-sync (the giant-folder prompt,
+    // `services::big_folders`). A whole-project pull is exactly the click that
+    // answer exists to make safe; an explicit pull *of* the excluded folder still
+    // goes through, which is why its own marker is ignored (`is_excluded`'s `under`).
+    let (files, skipped_excluded) = {
+        let mut guard = manifest.lock().await;
+        let m = ensure_loaded(&mut guard, project_id);
+        let before = files.len();
+        let kept: Vec<_> = files
+            .into_iter()
+            .filter(|f| !remote_sync::is_excluded(m, &f.rel, rel))
+            .collect();
+        let skipped = before - kept.len();
+        (kept, skipped)
+    };
+
+    let total = files.len();
+    emit(app, project_id, "start", rel, 0, total);
+
+    // #28q: whichever transport wins below, a pull writes the host's bytes over the
+    // mirror's. Name the local edits that destroys before either of them runs — after the
+    // transfer the evidence is gone (rsync's fast path in particular leaves nothing to
+    // compare a base against).
+    let rels: Vec<String> = files.iter().map(|f| f.rel.clone()).collect();
+    let doomed = unsynced_local_edits(project_id, manifest, &rels).await;
+    warn_overwritten(project_id, "Pull from the host", doomed);
+
+    // rsync fast-path for a directory pull: transfer the bytes in one shot, then
+    // fall through to the manifest-recording loop (which only re-stats locally —
+    // the bytes are already on disk, so `pull_file` would be a wasteful re-read).
+    // It transfers the *whole* subtree, so it is given up entirely as soon as one
+    // file inside was excluded — a fast path that ignores the exclusion would haul
+    // the very folder the user just said to leave on the host.
+    let rsynced = is_dir && skipped_excluded == 0 && try_rsync_pull(target, rel).await;
+
+    let mut done = 0usize;
+    for file in files {
+        let host_abs = join_remote(&target.spec.remote_path, &file.rel);
+        let local = mirror_local_path(project_id, &file.rel);
+        // rsync already wrote the bytes; only stat locally to capture the base.
+        // Otherwise pull the file over SFTP.
+        let local_base = if rsynced {
+            std::fs::metadata(&local).ok().map(|m| local_meta(&m))
+        } else {
+            remote_sync::pull_file(sftp, &host_abs, file.size, &local).await.ok()
+        };
+        match local_base {
+            Some((ls, lm)) => {
+                let mut guard = manifest.lock().await;
+                let m = ensure_loaded(&mut guard, project_id);
+                remote_sync::record_pull(m, &file.rel, file.size, file.mtime, ls, lm);
+                let _ = remote_sync::save_manifest(project_id, m);
+                net_usage::record_files(project_id, 1, 0);
+            }
+            None => {
+                // A single oversized/unreadable file shouldn't abort the whole
+                // folder sync; report it and carry on.
+                eprintln!("sync_pull: skip '{}'", file.rel);
+            }
+        }
+        done += 1;
+        emit(app, project_id, "file", &file.rel, done, total);
+    }
+    emit(app, project_id, "done", rel, done, total);
+    Ok(done)
+}
+
+/// Attempt the rsync fast-path for a directory pull of `rel`: probe rsync on both
+/// ends, and if present run `rsync_pull_dir` on a blocking thread. Returns `true`
+/// when rsync actually transferred (the caller then just stats locally); `false`
+/// to fall back to the SFTP walker. Best-effort — any probe/transfer failure
+/// returns `false`.
+async fn try_rsync_pull(target: &RemoteTarget, rel: &str) -> bool {
+    if !remote_sync::rsync_available_local() {
+        return false;
+    }
+    let spec = target.spec.clone();
+    let project_id = target.project_id.clone();
+    let host_src = join_remote(&spec.remote_path, rel);
+    let local_dest = mirror_local_path(&project_id, rel);
+    tokio::task::spawn_blocking(move || {
+        if !remote_sync::rsync_available_host(&spec) {
+            return false;
+        }
+        remote_sync::rsync_pull_dir(&spec.user, &spec.host, spec.port, &host_src, &local_dest).is_ok()
+    })
+    .await
+    .unwrap_or(false)
+}
+
+/// Produce a unified diff of `mirror_path` (old / "local") vs `host_bytes`
+/// (new / "host") using local `git diff --no-index`. `git` is a hard dependency
+/// and `--no-index` works outside any repo, exiting non-zero when the files
+/// differ (the normal case) — so non-empty stdout is treated as success,
+/// mirroring `git_diff_file_blocking`. The host bytes are staged in a temp file;
+/// an absent mirror (never pulled) diffs against an empty temp file so it shows
+/// as all-additions. The temp/abs paths in the header lines are rewritten to
+/// friendly `local/<rel>` / `host/<rel>` labels. Returns "" when identical.
+fn diff_mirror_vs_host(
+    mirror_path: &std::path::Path,
+    host_bytes: &[u8],
+    rel: &str,
+) -> Result<String, String> {
+    use std::io::Write;
+    let mut host_tmp = tempfile::NamedTempFile::new().map_err(|e| e.to_string())?;
+    host_tmp.write_all(host_bytes).map_err(|e| e.to_string())?;
+    host_tmp.flush().map_err(|e| e.to_string())?;
+    let host_tmp_path = host_tmp.path().to_string_lossy().into_owned();
+
+    // Old side: the mirror file if present, else an empty temp stand-in for
+    // /dev/null (portable across platforms). Both temps stay alive until the git
+    // call returns below.
+    let empty_tmp = if mirror_path.exists() {
+        None
+    } else {
+        Some(tempfile::NamedTempFile::new().map_err(|e| e.to_string())?)
+    };
+    let mirror_arg = match &empty_tmp {
+        Some(t) => t.path().to_string_lossy().into_owned(),
+        None => mirror_path.to_string_lossy().into_owned(),
+    };
+
+    let out = crate::paths::command_no_window("git")
+        .args(["diff", "--no-index", "--", &mirror_arg, &host_tmp_path])
+        .output()
+        .map_err(|e| e.to_string())?;
+    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+    if stdout.is_empty() {
+        // Zero exit + no output = identical. Non-zero + no output = a real error.
+        if !out.status.success() {
+            return Err(String::from_utf8_lossy(&out.stderr).to_string());
+        }
+        return Ok(String::new());
+    }
+    Ok(rewrite_diff_labels(&stdout, rel))
+}
+
+/// Rewrite the temp/abs paths in a `git diff --no-index` output to friendly
+/// `a/local/<rel>` and `b/host/<rel>` header labels. Operates on the header LINES
+/// (not raw substrings): git formats an absolute path as `a/tmp/…` — the leading
+/// `/` folds into the `a/` prefix, so a naive path replacement would eat the
+/// prefix. The frontend's diff parser strips the `a/`/`b/` prefixes, leaving a
+/// clean `local/<rel>` / `host/<rel>` shown in the diff header.
+fn rewrite_diff_labels(diff: &str, rel: &str) -> String {
+    let local = format!("local/{rel}");
+    let host = format!("host/{rel}");
+    let mut out = String::with_capacity(diff.len());
+    for line in diff.split_inclusive('\n') {
+        let trimmed = line.strip_suffix('\n').unwrap_or(line);
+        let nl = if line.ends_with('\n') { "\n" } else { "" };
+        if trimmed.starts_with("diff --git ") {
+            out.push_str(&format!("diff --git a/{local} b/{host}{nl}"));
+        } else if trimmed.starts_with("--- ") {
+            out.push_str(&format!("--- a/{local}{nl}"));
+        } else if trimmed.starts_with("+++ ") {
+            out.push_str(&format!("+++ b/{host}{nl}"));
+        } else if trimmed.starts_with("Binary files ") {
+            out.push_str(&format!("Binary files a/{local} and b/{host} differ{nl}"));
+        } else {
+            out.push_str(line);
+        }
+    }
+    out
+}
+
+/// Emit one `sync-progress` event (best-effort).
+fn emit(app: &AppHandle, project_id: &str, phase: &str, rel_path: &str, done: usize, total: usize) {
+    let _ = app.emit(
+        "sync-progress",
+        SyncProgress {
+            project_id: project_id.to_string(),
+            phase: phase.to_string(),
+            rel_path: rel_path.to_string(),
+            done,
+            total,
+        },
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::rewrite_diff_labels;
+
+    #[test]
+    fn rewrite_diff_labels_relabels_both_sides() {
+        // Real `git diff --no-index` output for two absolute temp paths: git folds
+        // the leading `/` into the `a/`/`b/` prefix (`a/tmp/.mirrorAAA`).
+        let raw = "\
+diff --git a/tmp/.mirrorAAA b/tmp/.hostBBB
+index 3367afd..3e75765 100644
+--- a/tmp/.mirrorAAA
++++ b/tmp/.hostBBB
+@@ -1 +1 @@
+-old
++new
+";
+        let out = rewrite_diff_labels(raw, "src/main.rs");
+        // Header lines carry friendly labels; the parser strips git's a/ b/
+        // prefixes, leaving `local/…` / `host/…`. Body/hunk lines are untouched.
+        assert!(out.contains("diff --git a/local/src/main.rs b/host/src/main.rs"), "got: {out}");
+        assert!(out.contains("--- a/local/src/main.rs"), "got: {out}");
+        assert!(out.contains("+++ b/host/src/main.rs"), "got: {out}");
+        assert!(out.contains("-old"), "got: {out}");
+        assert!(out.contains("+new"), "got: {out}");
+        assert!(!out.contains(".mirrorAAA"));
+        assert!(!out.contains(".hostBBB"));
+    }
+
+    #[test]
+    fn rewrite_diff_labels_handles_binary() {
+        let raw = "diff --git a/tmp/x b/tmp/y\nBinary files a/tmp/x and b/tmp/y differ\n";
+        let out = rewrite_diff_labels(raw, "data/img.png");
+        assert!(out.contains("Binary files a/local/data/img.png and b/host/data/img.png differ"), "got: {out}");
+    }
+}
diff --git a/src-tauri/src/commands/terminal.rs b/src-tauri/src/commands/terminal.rs
index c23977b..2f2352a 100644
--- a/src-tauri/src/commands/terminal.rs
+++ b/src-tauri/src/commands/terminal.rs
@@ -7,10 +7,24 @@ use crate::terminal::{PtyOptions, PtyRegistry};
 
 pub type RegistryState = Arc<Mutex<PtyRegistry>>;
 
+/// Read the global `agent_remote_control` setting, defaulting ON when the
+/// settings file or key is absent. A cheap per-spawn JSON read (spawns are
+/// infrequent), kept here so the spawn path has no `AppHandle` dependency.
+fn settings_agent_remote_control() -> bool {
+    let path = storage::state_dir().join("settings.json");
+    if !path.exists() {
+        return crate::schema::Settings::default().agent_remote_control();
+    }
+    storage::read_json::<crate::schema::Settings>(&path)
+        .map(|s| s.agent_remote_control())
+        .unwrap_or(true)
+}
+
 #[tauri::command]
 pub async fn pty_spawn(
     app: AppHandle,
     registry: State<'_, RegistryState>,
+    pool: State<'_, crate::services::remote::RemotePoolState>,
     mut opts: PtyOptions,
 ) -> Result<(), String> {
     // Resolve empty cwd to Eldrun's root workspace directory.
@@ -25,6 +39,20 @@ pub async fn pty_spawn(
         opts.cwd = root_dir.to_string_lossy().into_owned();
     }
 
+    // SSH-sync Phase 1: a LOCAL-running tab on a REMOTE project runs in the
+    // project's local mirror — it can't reach the remote tree. Resolve the cwd to
+    // the mirror here (authoritative, OS-correct path) and ensure it exists, so a
+    // local agent/shell tab spawns in the synced twin rather than a stale cwd.
+    if opts.local_only {
+        if let Some(pid) = opts.project_id.clone() {
+            if crate::services::remote::remote_target_for(&pid).is_some() {
+                let mirror = crate::services::remote_sync::mirror_dir(&pid);
+                let _ = std::fs::create_dir_all(&mirror);
+                opts.cwd = mirror.to_string_lossy().into_owned();
+            }
+        }
+    }
+
     // Resolve agent-session resume args (Claude `--resume`, Codex `resume …`)
     // BEFORE any ssh wrapping. `wrap_pty_options` rewrites `opts.cmd` to "ssh",
     // after which the resolver (which dispatches on `cmd == "claude"|"codex"`)
@@ -36,12 +64,135 @@ pub async fn pty_spawn(
     // twice.)
     opts = crate::services::agent_session::resolve_agent_session(opts);
 
-    // For remote (SSH) projects, rewrite the spawn to run on the remote host
-    // via `ssh -tt`. No-op for local projects or `local_only` tabs.
-    if !opts.local_only {
+    // Codex resume, without the hook. Codex will not run Eldrun's SessionStart
+    // hook until the user trusts it (`/hooks`), and an untrusted hook fails
+    // silently — so nothing recorded a tab's live session id and every restored
+    // Codex tab came back blank. Follow Codex's own rollout logs instead and
+    // record the id in the same place the hook would have; `resolve_codex_session`
+    // above then picks it up on the next spawn, unchanged. Tracked here, while
+    // `cmd`/`cwd`/`env` still describe the tab itself — after the wrapping below
+    // they describe `docker`/`ssh`.
+    if opts.cmd == "codex" && crate::services::agent_session::codex_binder_enabled() {
+        // A remote tab's Codex runs on the far host, so its rollouts (and its
+        // cwd) are over there; the local sessions tree would only mis-attribute
+        // someone else's. `local_only` tabs of a remote project are the exception
+        // — they run here, in the local mirror cwd resolved above.
+        let is_remote = !opts.local_only
+            && opts
+                .project_id
+                .as_deref()
+                .is_some_and(|id| crate::services::remote::remote_target_for(id).is_some());
+        if let Some(uid) = opts.env.get("ELDRUN_TAB_UID").filter(|_| !is_remote).cloned() {
+            // Args at this point are `["resume", <id>]` iff we just resumed a
+            // recorded session — hand that id over so the binder claims it for
+            // this tab rather than offering it to a sibling.
+            let resumed = opts
+                .args
+                .iter()
+                .position(|a| a == "resume")
+                .and_then(|i| opts.args.get(i + 1))
+                .cloned();
+            crate::services::codex_bind::track(
+                &opts.id,
+                &uid,
+                std::path::Path::new(&opts.cwd),
+                resumed,
+            );
+        }
+    }
+
+    // Claude remote control (global setting `agent_remote_control`, default ON):
+    // spawn `claude` agent tabs with `--remote-control` so the running session can
+    // be monitored/steered from the Claude app/web. Only Claude has this flag.
+    // Applied here — after session resolution but before ssh/docker wrapping — so
+    // it rides into the wrapped command for remote/sandboxed tabs too. Guarded
+    // against duplicates so a re-spawn never stacks the flag.
+    if opts.cmd == "claude"
+        && settings_agent_remote_control()
+        && !opts.args.iter().any(|a| a == "--remote-control")
+    {
+        opts.args.push("--remote-control".to_string());
+    }
+
+    // Container (Docker) and ssh-remote wrapping are mutually exclusive: the
+    // project container is local-only. When `opts.sandbox` is set (frontend
+    // marks shell+agent tabs of a container-toggled local project), rewrite the
+    // resolved command into a `docker exec` into the project's session-lived
+    // container (created on demand); otherwise fall back to ssh wrapping for
+    // remote projects. Both run after agent-session resolution so resume
+    // args/env ride into whichever wrapper applies. `local_only` tabs (e.g.
+    // Ollama `local_agent`) must run on the host verbatim, so they take neither
+    // path — the `local_only` guard on the container branch preserves that
+    // invariant even if a tab were ever marked both `sandbox` and `local_only`.
+    if !opts.sandbox {
+        // A respawn of a tab that was containerized before the toggle flipped
+        // off: its old in-container process outlives the docker-exec client the
+        // respawn replaces — reap it (cheap no-op for never-containerized tabs).
+        crate::services::sandbox::kill_tab_process(&opts.id);
+    }
+    if opts.sandbox && !opts.local_only {
+        #[cfg(unix)]
+        crate::services::sandbox::wrap_pty_options_docker(&mut opts)?;
+        // The container maps host paths into a Linux container, so on Windows
+        // the container-side mount destinations would be host paths (`C:\…`)
+        // that mean nothing inside it. Refuse rather than silently spawning a
+        // tab the user asked to contain with no container at all.
+        #[cfg(windows)]
+        return Err("Project containers are not supported on Windows yet. Turn the container toggle off for this project to run this tab.".to_string());
+    } else if !opts.local_only {
+        // `wrap_pty_options` below spawns a bare `ssh` with no BatchMode and no
+        // askpass — it only ever rides an already-authenticated ControlMaster.
+        // The pool is normally primed at project activation, but that master can
+        // die quietly (keepalive kill on a dropped VPN/laptop sleep, or an HPC
+        // job's long queue wait past `ControlPersist`) long before this tab opens.
+        // Re-run the same silent connect used at activation here, best-effort:
+        // on a healthy headless host this re-authenticates via the saved
+        // password/askpass with no prompt, so the tab's own ssh always has a live
+        // master to ride; on a genuinely unreachable host it fails harmlessly and
+        // today's raw-ssh fallback (with its native prompt) still applies.
+        if let Some(project_id) = opts.project_id.clone() {
+            let host_id = opts
+                .remote_host_id
+                .clone()
+                .unwrap_or_else(|| crate::services::remote::PRIMARY_HOST.to_string());
+            // …but that convenience is also an unattended dial. This same call
+            // runs for a tab *restored at relaunch*, where nobody has asked for
+            // anything: it would open a ControlMaster on the host and, for a
+            // tmux-wrapped tab, a tmux server with it. On a machine tagged HPC
+            // that is precisely what the tag forbids, so refuse with the
+            // `HPC_GUARD` sentinel and let the frontend offer "connect and open".
+            // Once the user *has* connected the project the pool holds a standing
+            // authorization (`services::remote::connect_host`), so a tab opened
+            // by hand after that is allowed — which is the only distinction this
+            // seam can make: `pty_spawn` receives identical options for a restore
+            // and for a click.
+            if let Some(target) =
+                crate::services::remote::remote_target_for_host(&project_id, &host_id)
+            {
+                let spec = &target.spec;
+                crate::services::ssh_common::authorize_dial(
+                    &spec.user,
+                    &spec.host,
+                    spec.port,
+                    crate::services::ssh_common::ambient_intent(&spec.user, &spec.host, spec.port),
+                )?;
+            }
+            let _ = crate::services::remote::connect_host(&pool, &project_id, &host_id, None).await;
+        }
         crate::services::ssh_exec::wrap_pty_options(&mut opts)?;
     }
 
+    // Persistent LOCAL (tmux) sessions (TODO #85): a tab that resolved to a LOCAL
+    // spawn — i.e. ssh/docker wrapping did NOT rewrite it — and carries a
+    // `tmux_session` name is wrapped in a tmux session on this machine, so the run
+    // survives an Eldrun crash and the tab reattaches on restart. A remote tab is
+    // now `cmd == "ssh"` (its tmux is inside the remote command) and a container tab
+    // is `cmd == "docker"`, so both are skipped. No-op on Windows / without tmux.
+    #[cfg(unix)]
+    if opts.tmux_session.is_some() && opts.cmd != "ssh" && opts.cmd != "docker" {
+        crate::services::tmux_local::wrap_pty_options_local(&mut opts);
+    }
+
     // Crash-loop guard.
     {
         let mut reg = registry.lock().unwrap();
@@ -56,6 +207,60 @@ pub async fn pty_spawn(
     crate::terminal::spawn_pty(app, registry.inner().clone(), opts)
 }
 
+/// List the tmux sessions running on the **local** machine (TODO #85), for a local
+/// project's Sessions view. Empty on Windows / without tmux / no server.
+#[tauri::command]
+pub async fn local_tmux_list() -> Result<Vec<crate::services::ssh_exec::TmuxSession>, String> {
+    if !crate::services::tmux_local::tmux_available() {
+        return Ok(Vec::new());
+    }
+    tauri::async_runtime::spawn_blocking(|| {
+        let out = crate::paths::command_no_window("tmux")
+            .args(crate::services::tmux_local::local_tmux_ls_args())
+            .output();
+        match out {
+            Ok(o) => crate::services::ssh_exec::parse_tmux_ls(&String::from_utf8_lossy(&o.stdout)),
+            Err(_) => Vec::new(),
+        }
+    })
+    .await
+    .map_err(|e| e.to_string())
+}
+
+/// Kill a **local** tmux session (TODO #85) — the explicit-close / Sessions-view
+/// kill of a local persistent tab. No-op on Windows / without tmux.
+#[tauri::command]
+pub async fn local_tmux_kill(session: String) -> Result<(), String> {
+    if !crate::services::tmux_local::tmux_available() {
+        return Ok(());
+    }
+    tauri::async_runtime::spawn_blocking(move || {
+        let _ = crate::paths::command_no_window("tmux")
+            .args(crate::services::tmux_local::local_tmux_kill_args(&session))
+            .output();
+    })
+    .await
+    .map_err(|e| e.to_string())
+}
+
+/// Rename a **local** tmux session (TODO #85). `new_name` must be a safe tmux name.
+#[tauri::command]
+pub async fn local_tmux_rename(session: String, new_name: String) -> Result<(), String> {
+    if !crate::services::ssh_exec::valid_tmux_session_name(&new_name) {
+        return Err("a session name may only contain letters, digits, '-' and '_'".to_string());
+    }
+    if !crate::services::tmux_local::tmux_available() {
+        return Ok(());
+    }
+    tauri::async_runtime::spawn_blocking(move || {
+        let _ = crate::paths::command_no_window("tmux")
+            .args(crate::services::tmux_local::local_tmux_rename_args(&session, &new_name))
+            .output();
+    })
+    .await
+    .map_err(|e| e.to_string())
+}
+
 #[tauri::command]
 pub async fn pty_write(
     registry: State<'_, RegistryState>,
@@ -88,41 +293,34 @@ pub async fn pty_kill(registry: State<'_, RegistryState>, id: String) -> Result<
 /// Live CPU usage (percent of a single core; may exceed 100 on multi-core work)
 /// for the processes rooted at the given PTYs and all their descendants.
 ///
-/// Samples `/proc` jiffies twice over a short interval. Linux-only; other
-/// platforms return 0.0 so the UI can simply hide the figure.
+/// Samples busy CPU ticks twice over a short interval via `sysstat` (Linux
+/// `/proc`, Windows `GetProcessTimes`). On backends that don't sample (other
+/// OSes) the ticks are always 0, so this returns 0.0 and the UI hides the figure.
 #[tauri::command]
 pub async fn project_cpu_percent(
     registry: State<'_, RegistryState>,
     pty_ids: Vec<String>,
 ) -> Result<f64, String> {
-    #[cfg(target_os = "linux")]
-    {
-        use crate::sysstat;
-
-        let roots: Vec<u32> = {
-            let reg = registry.lock().unwrap();
-            pty_ids.iter().filter_map(|id| reg.pid(id)).collect()
-        };
-        if roots.is_empty() {
-            return Ok(0.0);
-        }
+    use crate::sysstat;
 
-        // Resolve the process tree once, then sample its busy time across a
-        // fixed window. Newly spawned children mid-window simply contribute
-        // less; that is acceptable for a coarse live readout.
-        let pids = sysstat::descendant_pids(&roots);
-        let interval = std::time::Duration::from_millis(300);
-        let t0 = sysstat::sum_jiffies(&pids);
-        tokio::time::sleep(interval).await;
-        let t1 = sysstat::sum_jiffies(&pids);
-
-        let busy_secs = t1.saturating_sub(t0) as f64 / sysstat::clk_tck() as f64;
-        let pct = busy_secs / interval.as_secs_f64() * 100.0;
-        Ok((pct * 10.0).round() / 10.0)
-    }
-    #[cfg(not(target_os = "linux"))]
-    {
-        let _ = (registry, pty_ids);
-        Ok(0.0)
+    let roots: Vec<u32> = {
+        let reg = registry.lock().unwrap();
+        pty_ids.iter().filter_map(|id| reg.pid(id)).collect()
+    };
+    if roots.is_empty() {
+        return Ok(0.0);
     }
+
+    // Resolve the process tree once, then sample its busy time across a fixed
+    // window. Newly spawned children mid-window simply contribute less; that is
+    // acceptable for a coarse live readout.
+    let pids = sysstat::descendant_pids(&roots);
+    let interval = std::time::Duration::from_millis(300);
+    let t0 = sysstat::sum_jiffies(&pids);
+    tokio::time::sleep(interval).await;
+    let t1 = sysstat::sum_jiffies(&pids);
+
+    let busy_secs = t1.saturating_sub(t0) as f64 / sysstat::clk_tck() as f64;
+    let pct = busy_secs / interval.as_secs_f64() * 100.0;
+    Ok((pct * 10.0).round() / 10.0)
 }
diff --git a/src-tauri/src/commands/tex.rs b/src-tauri/src/commands/tex.rs
index 1e8a756..9718a2d 100644
--- a/src-tauri/src/commands/tex.rs
+++ b/src-tauri/src/commands/tex.rs
@@ -10,7 +10,7 @@
 
 use std::fs;
 use std::path::Path;
-use std::process::{Command, Stdio};
+use std::process::Stdio;
 
 use serde::Serialize;
 
@@ -79,16 +79,10 @@ pub struct SyncRect {
     pub h: f64,
 }
 
-/// True if `bin` resolves on `PATH`.
+/// True if `bin` resolves on `PATH`. Uses the shared cross-platform probe so the
+/// TeX toolchain is detected on Windows too (where `which` does not exist).
 fn on_path(bin: &str) -> bool {
-    Command::new("which")
-        .arg(bin)
-        .stdin(Stdio::null())
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
+    crate::paths::binary_on_path(bin)
 }
 
 /// Probe `PATH` for the TeX toolchain. Cheap enough to call on demand.
@@ -117,20 +111,84 @@ struct RunOut {
     text: String,
 }
 
+/// How long a single TeX/bibtex invocation may run before it is killed.
+///
+/// `compile_tex` is a **synchronous** command, so a run that never returns holds
+/// a Tauri worker thread for the rest of the session and the frontend has no way
+/// to abort it — the deck editor and the TeX viewer both just sit on a spinner.
+/// `-interaction=nonstopmode` already rules out the classic prompt-for-input
+/// hang; what is left is a genuinely pathological document (a runaway macro, a
+/// `\loop` with no exit), and for that a ceiling is the only defence. Ten minutes
+/// is far beyond any healthy build, including a first run that is downloading
+/// packages on MiKTeX.
+const RUN_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(600);
+
 /// Run `bin args…` with `dir` as the working directory, capturing stdout+stderr.
+/// Spawned via `command_no_window` so MiKTeX's console tools (engine, `bibtex`,
+/// `synctex`) don't flash a console window per invocation on Windows.
+///
+/// Killed after {@link RUN_TIMEOUT}. The output is read on a worker thread rather
+/// than with `output()` so the wait can time out at all: `output()` blocks until
+/// the pipes close, which a wedged child never does.
 fn run_in<S: AsRef<std::ffi::OsStr>>(dir: &Path, bin: &str, args: &[S]) -> Result<RunOut, String> {
-    let out = Command::new(bin)
+    let mut child = crate::paths::command_no_window(bin)
         .args(args)
         .current_dir(dir)
         .stdin(Stdio::null())
-        .output()
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
         .map_err(|e| format!("run {bin}: {e}"))?;
-    let mut text = String::from_utf8_lossy(&out.stdout).into_owned();
-    text.push_str(&String::from_utf8_lossy(&out.stderr));
-    Ok(RunOut {
-        ok: out.status.success(),
-        text,
-    })
+
+    // Drain both pipes on their own threads. A child that fills a pipe buffer
+    // deadlocks if nobody is reading, which would make the timeout fire on
+    // perfectly healthy builds with a lot of log output.
+    let mut out_pipe = child.stdout.take();
+    let mut err_pipe = child.stderr.take();
+    let out_reader = std::thread::spawn(move || {
+        let mut buf = Vec::new();
+        if let Some(p) = out_pipe.as_mut() {
+            let _ = std::io::Read::read_to_end(p, &mut buf);
+        }
+        buf
+    });
+    let err_reader = std::thread::spawn(move || {
+        let mut buf = Vec::new();
+        if let Some(p) = err_pipe.as_mut() {
+            let _ = std::io::Read::read_to_end(p, &mut buf);
+        }
+        buf
+    });
+
+    let deadline = std::time::Instant::now() + RUN_TIMEOUT;
+    let status = loop {
+        match child.try_wait().map_err(|e| format!("wait {bin}: {e}"))? {
+            Some(s) => break Some(s),
+            None if std::time::Instant::now() >= deadline => {
+                let _ = child.kill();
+                let _ = child.wait();
+                break None;
+            }
+            None => std::thread::sleep(std::time::Duration::from_millis(50)),
+        }
+    };
+
+    let mut text = String::from_utf8_lossy(&out_reader.join().unwrap_or_default()).into_owned();
+    text.push_str(&String::from_utf8_lossy(&err_reader.join().unwrap_or_default()));
+
+    match status {
+        Some(s) => Ok(RunOut {
+            ok: s.success(),
+            text,
+        }),
+        None => {
+            text.push_str(&format!(
+                "\n! Eldrun stopped {bin} after {} seconds — the build appears to be stuck.\n",
+                RUN_TIMEOUT.as_secs()
+            ));
+            Ok(RunOut { ok: false, text })
+        }
+    }
 }
 
 /// True when the `.aux` references a bibliography (so a `bibtex` pass is wanted).
diff --git a/src-tauri/src/commands/timer.rs b/src-tauri/src/commands/timer.rs
index 297ca1f..be63790 100644
--- a/src-tauri/src/commands/timer.rs
+++ b/src-tauri/src/commands/timer.rs
@@ -1,7 +1,6 @@
 use std::collections::HashMap;
 
-use crate::schema::time_log::TimeLogEntry;
-use crate::storage;
+use crate::schema::time_log;
 
 pub const APP_TIMER_ID: &str = "__eldrun__";
 
@@ -11,7 +10,7 @@ pub fn timer_flush_app(secs: f64) {
     if secs <= 0.0 {
         return;
     }
-    flush_secs(APP_TIMER_ID, secs);
+    time_log::record_secs(APP_TIMER_ID, secs);
 }
 
 /// Flush elapsed project session seconds into the time log.
@@ -20,41 +19,23 @@ pub fn timer_flush_project(project_id: String, secs: f64) {
     if secs <= 0.0 || project_id.is_empty() {
         return;
     }
-    flush_secs(&project_id, secs);
+    time_log::record_secs(&project_id, secs);
 }
 
 /// Returns total seconds per date for the given project_id (or global if empty).
 /// Result: { "YYYY-MM-DD" -> total_seconds }
 #[tauri::command]
 pub fn get_project_activity(project_id: String) -> HashMap<String, f64> {
-    let path = storage::state_dir().join("time_log.json");
-    if !path.exists() {
-        return HashMap::new();
-    }
-    let log: crate::schema::time_log::TimeLog =
-        storage::read_json(&path).unwrap_or_default();
-    let mut result: HashMap<String, f64> = HashMap::new();
-    for entry in log {
-        if project_id.is_empty() || entry.project_id == project_id {
-            *result.entry(entry.date).or_insert(0.0) += entry.duration_s;
-        }
-    }
-    result
+    time_log::load_summary_migrating().activity_for(&project_id)
 }
 
-fn flush_secs(project_id: &str, secs: f64) {
-    let path = storage::state_dir().join("time_log.json");
-    let mut log: crate::schema::time_log::TimeLog = if path.exists() {
-        storage::read_json(&path).unwrap_or_default()
-    } else {
-        vec![]
-    };
-    log.push(TimeLogEntry {
-        project_id: project_id.to_string(),
-        date: storage::today_utc(),
-        start_iso: storage::iso_now(),
-        duration_s: secs,
-        extra: HashMap::new(),
-    });
-    let _ = storage::write_json(&path, &log);
+/// The whole time summary, unfolded: `{ "YYYY-MM-DD" -> { project_id -> secs } }`.
+///
+/// The usage recap needs *every* project's time for a period ("work spent per
+/// project"), which through [`get_project_activity`] would mean one call — and one
+/// full read of the summary file — per project. This hands back the map the store
+/// already holds, in a single read.
+#[tauri::command]
+pub fn get_time_activity_all() -> HashMap<String, HashMap<String, f64>> {
+    time_log::load_summary_migrating().days
 }
diff --git a/src-tauri/src/commands/usage_stats.rs b/src-tauri/src/commands/usage_stats.rs
new file mode 100644
index 0000000..fa22703
--- /dev/null
+++ b/src-tauri/src/commands/usage_stats.rs
@@ -0,0 +1,257 @@
+//! Commands behind the daily usage recap.
+//!
+//! Three surfaces:
+//!
+//! - [`usage_bump`] — the one write path the frontend uses. It is *batched*: the
+//!   frontend accumulates counters in memory and flushes them on an interval, so
+//!   a burst of keystrokes costs one whole-file rewrite per flush, not per event.
+//! - [`usage_summary`] — read-only rollup, mirroring `commands::net_usage::get_net_usage`.
+//! - [`usage_git_stats`] — commits/lines, **derived on demand** from `git log`
+//!   rather than counted into the store, so they can never drift or double-count.
+
+use std::collections::HashMap;
+
+use crate::schema::usage_stats::{self, Counters};
+use crate::services::remote::remote_target_for_dir;
+
+/// The rollup handed to the frontend: the same two bucket maps the store holds,
+/// already folded to one project (or summed across all of them).
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct UsageReport {
+    /// hour ("YYYY-MM-DDTHH") → metric → count.
+    pub hours: HashMap<String, Counters>,
+    /// date ("YYYY-MM-DD") → metric → count.
+    pub days: HashMap<String, Counters>,
+}
+
+/// Fold a batch of counters into `project_id`'s current UTC hour.
+///
+/// `project_id` is the scope the counters belong to — a project id, or the root
+/// scope's pseudo-id. An empty batch or an empty id is a no-op that never touches
+/// disk.
+///
+/// Offloaded to the blocking pool: it is a read-modify-write of a JSON file, and
+/// a Tauri sync command would do that on the UI thread.
+#[tauri::command]
+pub async fn usage_bump(project_id: String, metrics: Counters) -> Result<(), String> {
+    tokio::task::spawn_blocking(move || {
+        usage_stats::record(&project_id, &metrics);
+    })
+    .await
+    .map_err(|e| format!("usage_bump task failed: {e}"))
+}
+
+/// Every recorded counter for `project_id`, or summed across all projects when it
+/// is empty. Read-only — recording is internal to [`usage_bump`] and the watcher.
+#[tauri::command]
+pub async fn usage_summary(project_id: String) -> Result<UsageReport, String> {
+    tokio::task::spawn_blocking(move || {
+        let stats = usage_stats::load();
+        UsageReport {
+            hours: stats.hourly_for(&project_id),
+            days: stats.daily_for(&project_id),
+        }
+    })
+    .await
+    .map_err(|e| format!("usage_summary task failed: {e}"))
+}
+
+/// Point the file-churn watcher at a project's tree, replacing any previous
+/// watch. Called by the frontend when the active project changes; an empty
+/// `project_id` (no project active) just stops watching.
+///
+/// Which directory that actually is — the project's own, or a remote project's
+/// local mirror — is resolved backend-side (`services::usage_stats::watch_root_for`).
+/// Watching is best-effort: a project with nothing watchable simply records no
+/// file stats.
+#[tauri::command]
+pub fn usage_watch_project(
+    state: tauri::State<'_, crate::services::usage_stats::UsageWatchState>,
+    project_id: String,
+) -> Result<(), String> {
+    crate::services::usage_stats::watch_project(&state, &project_id)
+}
+
+/// Commits and line churn attributable to *you*, in a time window.
+#[derive(Debug, Clone, Default, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GitStats {
+    pub commits: u64,
+    pub files_changed: u64,
+    pub lines_added: u64,
+    pub lines_removed: u64,
+}
+
+/// Commits/lines for `project_dir` since `since` (any string git's `--since`
+/// accepts — the recap passes an ISO date).
+///
+/// **Derived, not stored.** Re-reading the log is idempotent, so a recap that is
+/// opened twice cannot double-count, and the week/month windows come free by
+/// moving `since`.
+///
+/// Scoped to commits authored by the repo's configured `user.email`, so a `git
+/// pull` that lands fifty of a colleague's commits does not read as fifty of
+/// yours. With no `user.email` configured we fall back to counting every commit
+/// (better than reporting zero).
+///
+/// **Local repos only.** A remote project's git lives on the host and would run
+/// over SSH, which can stall for the whole `ConnectTimeout` when the host is
+/// down — and this command runs while the recap is opening. A remote project
+/// reports no git stats rather than hanging the dialog; its local mirror, being
+/// an ordinary local path, works normally.
+#[tauri::command]
+pub async fn usage_git_stats(project_dir: String, since: String) -> Result<GitStats, String> {
+    tokio::task::spawn_blocking(move || git_stats_blocking(&project_dir, &since))
+        .await
+        .map_err(|e| format!("usage_git_stats task failed: {e}"))?
+}
+
+fn git_stats_blocking(project_dir: &str, since: &str) -> Result<GitStats, String> {
+    // Remote (see the doc comment) and non-repos short-circuit to zero.
+    if remote_target_for_dir(project_dir).is_some() {
+        return Ok(GitStats::default());
+    }
+    if !std::path::Path::new(project_dir).join(".git").exists() {
+        return Ok(GitStats::default());
+    }
+
+    let author = git_user_email(project_dir);
+    let mut args: Vec<String> = vec![
+        "log".into(),
+        format!("--since={since}"),
+        "--numstat".into(),
+        "--pretty=format:%H".into(),
+        // A merge shows no numstat by default; excluding merges also keeps the
+        // commit count to work you actually authored.
+        "--no-merges".into(),
+    ];
+    if let Some(email) = &author {
+        args.push(format!("--author={email}"));
+    }
+
+    let out = crate::paths::command_no_window("git")
+        .args(&args)
+        .current_dir(project_dir)
+        .output()
+        .map_err(|e| e.to_string())?;
+
+    // A repo with no commits yet exits non-zero; that is "nothing today", not an
+    // error worth failing the whole recap over.
+    if !out.status.success() {
+        return Ok(GitStats::default());
+    }
+    Ok(parse_numstat_log(&String::from_utf8_lossy(&out.stdout)))
+}
+
+/// The repo's configured author email, or `None` when unset.
+fn git_user_email(project_dir: &str) -> Option<String> {
+    let out = crate::paths::command_no_window("git")
+        .args(["config", "user.email"])
+        .current_dir(project_dir)
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    let email = String::from_utf8_lossy(&out.stdout).trim().to_string();
+    (!email.is_empty()).then_some(email)
+}
+
+/// Parse `git log --numstat --pretty=format:%H` output.
+///
+/// The shape is a commit hash on its own line, then one `added\tremoved\tpath`
+/// line per file, then a blank line. A binary file reports `-` for both counts —
+/// it changed, so it counts as a file, but contributes no lines.
+///
+/// Pure, so the parsing is unit-tested without a repo.
+fn parse_numstat_log(stdout: &str) -> GitStats {
+    let mut stats = GitStats::default();
+    for line in stdout.lines() {
+        let line = line.trim_end();
+        if line.is_empty() {
+            continue;
+        }
+        match line.split('\t').collect::<Vec<_>>()[..] {
+            [added, removed, _path] => {
+                stats.files_changed += 1;
+                // "-" means binary: a real change, but no line counts.
+                stats.lines_added += added.parse::<u64>().unwrap_or(0);
+                stats.lines_removed += removed.parse::<u64>().unwrap_or(0);
+            }
+            // Anything else on its own line is the `%H` commit hash.
+            _ => stats.commits += 1,
+        }
+    }
+    stats
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_a_single_commit_with_two_files() {
+        let out = "abc123\n\
+                   3\t1\tsrc/lib.rs\n\
+                   10\t0\tREADME.md\n";
+        let stats = parse_numstat_log(out);
+        assert_eq!(
+            stats,
+            GitStats {
+                commits: 1,
+                files_changed: 2,
+                lines_added: 13,
+                lines_removed: 1,
+            }
+        );
+    }
+
+    #[test]
+    fn parses_several_commits_separated_by_blank_lines() {
+        let out = "aaa\n\
+                   1\t1\ta.rs\n\
+                   \n\
+                   bbb\n\
+                   2\t3\tb.rs\n";
+        let stats = parse_numstat_log(out);
+        assert_eq!(stats.commits, 2);
+        assert_eq!(stats.files_changed, 2);
+        assert_eq!(stats.lines_added, 3);
+        assert_eq!(stats.lines_removed, 4);
+    }
+
+    #[test]
+    fn binary_files_count_as_changed_but_add_no_lines() {
+        // git reports "-\t-\tpath" for a binary blob.
+        let out = "abc\n-\t-\tlogo.png\n";
+        let stats = parse_numstat_log(out);
+        assert_eq!(stats.commits, 1);
+        assert_eq!(stats.files_changed, 1);
+        assert_eq!(stats.lines_added, 0);
+        assert_eq!(stats.lines_removed, 0);
+    }
+
+    #[test]
+    fn a_commit_touching_nothing_still_counts_as_a_commit() {
+        let stats = parse_numstat_log("abc123\n");
+        assert_eq!(stats.commits, 1);
+        assert_eq!(stats.files_changed, 0);
+    }
+
+    #[test]
+    fn empty_log_is_all_zeroes() {
+        assert_eq!(parse_numstat_log(""), GitStats::default());
+        assert_eq!(parse_numstat_log("\n\n"), GitStats::default());
+    }
+
+    #[test]
+    fn paths_containing_spaces_are_not_split() {
+        // numstat is TAB-separated precisely so paths may contain spaces; a
+        // whitespace split here would misread the path as extra columns.
+        let out = "abc\n5\t2\tsrc/my folder/a file.rs\n";
+        let stats = parse_numstat_log(out);
+        assert_eq!(stats.files_changed, 1);
+        assert_eq!(stats.lines_added, 5);
+        assert_eq!(stats.lines_removed, 2);
+    }
+}
diff --git a/src-tauri/src/commands/workspace.rs b/src-tauri/src/commands/workspace.rs
index 7e201a2..9cb732d 100644
--- a/src-tauri/src/commands/workspace.rs
+++ b/src-tauri/src/commands/workspace.rs
@@ -162,7 +162,9 @@ pub(crate) fn detect_conn_type_linux(net_dir: &Path) -> String {
 
 fn detect_conn_type_windows() -> String {
     // Check for an active Wi-Fi connection via `netsh wlan show interfaces`.
-    if let Ok(out) = std::process::Command::new("netsh")
+    // `command_no_window` keeps these probes from flashing a console window on
+    // every poll (Eldrun is a windowed app with no console).
+    if let Ok(out) = crate::paths::command_no_window("netsh")
         .args(["wlan", "show", "interfaces"])
         .output()
     {
@@ -172,7 +174,7 @@ fn detect_conn_type_windows() -> String {
         }
     }
     // Check for any active Ethernet via `netsh interface show interface`.
-    if let Ok(out) = std::process::Command::new("netsh")
+    if let Ok(out) = crate::paths::command_no_window("netsh")
         .args(["interface", "show", "interface"])
         .output()
     {
diff --git a/src-tauri/src/duscan.rs b/src-tauri/src/duscan.rs
new file mode 100644
index 0000000..2b040e9
--- /dev/null
+++ b/src-tauri/src/duscan.rs
@@ -0,0 +1,740 @@
+//! Recursive disk-usage scanning for the Disk Usage Analyzer pane (baobab-like).
+//!
+//! Two scanners, one output shape ([`DuScan`]):
+//!
+//!  - [`scan_local`] walks a local directory with plain `std::fs::read_dir`
+//!    recursion — the same idiom as `commands::fs::walk_dir_size` and
+//!    `commands::search::walk`. No `walkdir`/`rayon`: the repo deliberately keeps
+//!    its walks in pure std (see `commands::search`).
+//!  - [`parse_du_output`] rebuilds the same tree from a remote `du -ak` dump, so a
+//!    host scan costs one SSH round-trip instead of an N-call SFTP walk.
+//!
+//! Units contract: every `size` is **bytes**. Local sizes are *apparent* sizes
+//! (`metadata.len()`), matching `commands::fs::dir_size` and the FileTree size
+//! column; remote sizes come from `du`'s 1024-byte blocks (so they are *allocated*
+//! sizes, and a dir's total includes its own directory inode). The two therefore
+//! differ slightly for the same tree — that is inherent to `du`, and matches what
+//! `ssh_exec::remote_dir_size` already reports elsewhere in the app.
+//!
+//! Safety properties of the local walk:
+//!
+//!  - **Symlinks are never followed** (`entry.file_type()` reports the link, not
+//!    its target), so a symlink cycle cannot loop and a symlinked tree cannot be
+//!    double-counted.
+//!  - **Hard links are counted once**, by `(dev, ino)`, like `du`.
+//!  - Unreadable dirs/entries are skipped and tallied in `errors`; the result is a
+//!    best-effort partial total rather than a hard failure.
+//!  - Unlike `fs::should_skip_ending_scan_dir`, vendor/build dirs (`node_modules`,
+//!    `target`, `.git`, …) are **not** skipped — for a disk analyzer those are
+//!    precisely the answer the user came for.
+
+use std::collections::{HashMap, HashSet};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::{Duration, Instant};
+
+use serde::Serialize;
+
+use crate::commands::fs::display_path;
+
+/// Hard cap on recursion depth. Mirrors `fs::MAX_SCAN_DEPTH` — a backstop even
+/// though symlinks are not followed.
+const MAX_SCAN_DEPTH: usize = 64;
+
+/// Deepest level whose children are shipped to the frontend. Nodes below this keep
+/// their aggregate `size` but carry no `children` — the chart never draws that deep
+/// anyway, and this is what keeps a whole-home scan from blowing up the IPC bridge.
+const MAX_EMIT_DEPTH: usize = 12;
+
+/// Most children shipped per directory, biggest first. The rest are folded into
+/// `hidden_children` / `hidden_bytes` (the chart's "…others" slice).
+const MAX_CHILDREN: usize = 64;
+
+/// Most `du` lines parsed from a remote scan before giving up on completeness.
+const MAX_REMOTE_LINES: usize = 400_000;
+
+/// How often the walk reports progress. Fine enough to look live, coarse enough
+/// that the event stream never becomes the bottleneck.
+const PROGRESS_INTERVAL: Duration = Duration::from_millis(100);
+
+/// One node of the size tree. `size` is always cumulative (the node itself plus
+/// every descendant), so a parent's `size` is authoritative even when its children
+/// were pruned by the emit caps.
+#[derive(Debug, Clone, Serialize)]
+pub struct DuNode {
+    pub name: String,
+    /// Absolute path, rendered for the frontend (see `fs::display_path`).
+    pub path: String,
+    pub size: u64,
+    pub is_dir: bool,
+    /// Sorted descending by `size`. Empty for files and for pruned directories.
+    pub children: Vec<DuNode>,
+    /// Children omitted from `children` by the emit caps.
+    pub hidden_children: u32,
+    /// Their summed size. `children` + `hidden_bytes` always accounts for `size`.
+    pub hidden_bytes: u64,
+}
+
+impl DuNode {
+    fn dir(name: String, path: String) -> Self {
+        Self { name, path, size: 0, is_dir: true, children: Vec::new(), hidden_children: 0, hidden_bytes: 0 }
+    }
+    fn file(name: String, path: String, size: u64) -> Self {
+        Self { name, path, size, is_dir: false, children: Vec::new(), hidden_children: 0, hidden_bytes: 0 }
+    }
+}
+
+/// A completed (or cancelled) scan.
+#[derive(Debug, Clone, Serialize)]
+pub struct DuScan {
+    pub root: DuNode,
+    pub files: u64,
+    pub dirs: u64,
+    /// Entries skipped because they could not be read (permissions, races).
+    pub errors: u64,
+    /// An emit cap or the line cap was hit — the tree is complete in `size` but
+    /// abridged in `children`.
+    pub truncated: bool,
+    /// The walk stopped early because the caller cancelled it.
+    pub cancelled: bool,
+    /// Capacity of the filesystem holding the root, when knowable.
+    pub total_bytes: Option<u64>,
+    pub free_bytes: Option<u64>,
+}
+
+/// Running counters handed to the progress callback.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Tally {
+    pub files: u64,
+    pub dirs: u64,
+    pub bytes: u64,
+    pub errors: u64,
+}
+
+/// A scan target offered on the pane's home screen.
+#[derive(Debug, Clone, Serialize)]
+pub struct DuDevice {
+    pub label: String,
+    pub path: String,
+    pub total_bytes: Option<u64>,
+    pub free_bytes: Option<u64>,
+}
+
+// ── Local walk ────────────────────────────────────────────────────────────────
+
+struct Walker<'a> {
+    cancel: &'a AtomicBool,
+    progress: &'a mut dyn FnMut(&Tally, &Path),
+    tally: Tally,
+    /// `(dev, ino)` of every multiply-linked file already counted, so a hard link
+    /// is billed once. Unused off Unix, which exposes no portable inode identity.
+    #[cfg_attr(not(unix), allow(dead_code))]
+    seen: HashSet<(u64, u64)>,
+    truncated: bool,
+    cancelled: bool,
+    last_emit: Instant,
+}
+
+impl Walker<'_> {
+    /// True when this file's bytes should be counted — i.e. it is not another link
+    /// to an inode we have already billed.
+    #[cfg(unix)]
+    fn count_once(&mut self, meta: &fs::Metadata) -> bool {
+        use std::os::unix::fs::MetadataExt;
+        if meta.nlink() <= 1 {
+            return true;
+        }
+        self.seen.insert((meta.dev(), meta.ino()))
+    }
+
+    /// Off Unix there is no portable inode identity, so every file counts.
+    #[cfg(not(unix))]
+    fn count_once(&mut self, _meta: &fs::Metadata) -> bool {
+        true
+    }
+
+    fn tick(&mut self, at: &Path) {
+        if self.last_emit.elapsed() >= PROGRESS_INTERVAL {
+            self.last_emit = Instant::now();
+            (self.progress)(&self.tally, at);
+        }
+    }
+
+    fn walk(&mut self, dir: &Path, name: String, depth: usize) -> DuNode {
+        let mut node = DuNode::dir(name, display_path(dir));
+        if depth >= MAX_SCAN_DEPTH {
+            self.truncated = true;
+            return node;
+        }
+        if self.cancel.load(Ordering::Relaxed) {
+            self.cancelled = true;
+            return node;
+        }
+
+        self.tally.dirs = self.tally.dirs.saturating_add(1);
+        self.tick(dir);
+
+        let entries = match fs::read_dir(dir) {
+            Ok(e) => e,
+            Err(_) => {
+                self.tally.errors = self.tally.errors.saturating_add(1);
+                return node;
+            }
+        };
+
+        // Children are only materialised while we are shallow enough to emit them;
+        // deeper levels contribute their `size` and nothing else, so a very deep
+        // tree never accumulates in memory.
+        let emit = depth < MAX_EMIT_DEPTH;
+        let mut kids: Vec<DuNode> = Vec::new();
+        let mut hidden_children = 0u32;
+        let mut hidden_bytes = 0u64;
+
+        for entry in entries.flatten() {
+            if self.cancelled || self.cancel.load(Ordering::Relaxed) {
+                self.cancelled = true;
+                break;
+            }
+            let Ok(ft) = entry.file_type() else {
+                self.tally.errors = self.tally.errors.saturating_add(1);
+                continue;
+            };
+            // A symlink — to a dir or a file — is reported as a symlink here, never
+            // as its target, so this single check is the whole cycle defence.
+            if ft.is_symlink() {
+                continue;
+            }
+            let path = entry.path();
+            let child_name = entry.file_name().to_string_lossy().into_owned();
+
+            let child = if ft.is_dir() {
+                self.walk(&path, child_name, depth + 1)
+            } else if ft.is_file() {
+                let Ok(meta) = entry.metadata() else {
+                    self.tally.errors = self.tally.errors.saturating_add(1);
+                    continue;
+                };
+                if !self.count_once(&meta) {
+                    continue; // another link to an inode we already billed
+                }
+                let size = meta.len();
+                self.tally.files = self.tally.files.saturating_add(1);
+                self.tally.bytes = self.tally.bytes.saturating_add(size);
+                DuNode::file(child_name, display_path(&path), size)
+            } else {
+                continue; // sockets, fifos, devices — no meaningful size
+            };
+
+            node.size = node.size.saturating_add(child.size);
+            if emit {
+                kids.push(child);
+            } else {
+                hidden_children += 1;
+                hidden_bytes = hidden_bytes.saturating_add(child.size);
+                self.truncated = true;
+            }
+        }
+
+        kids.sort_by(|a, b| b.size.cmp(&a.size));
+        if kids.len() > MAX_CHILDREN {
+            let rest = kids.split_off(MAX_CHILDREN);
+            hidden_children += rest.len() as u32;
+            hidden_bytes = hidden_bytes.saturating_add(rest.iter().map(|k| k.size).sum());
+            self.truncated = true;
+        }
+        node.children = kids;
+        node.hidden_children = hidden_children;
+        node.hidden_bytes = hidden_bytes;
+        node
+    }
+}
+
+/// Walk `root` and return its size tree.
+///
+/// `cancel` is polled per directory and per entry, so a `/` scan aborts promptly;
+/// a cancelled scan still returns the partial tree it built (with `cancelled` set)
+/// rather than an error. `progress` is invoked at most every
+/// [`PROGRESS_INTERVAL`] with the running tally and the directory being read.
+pub fn scan_local(
+    root: &str,
+    cancel: &AtomicBool,
+    progress: &mut dyn FnMut(&Tally, &Path),
+) -> Result<DuScan, String> {
+    let root_path = fs::canonicalize(root).map_err(|e| format!("cannot scan {root}: {e}"))?;
+    if !root_path.is_dir() {
+        return Err(format!("not a directory: {root}"));
+    }
+    let name = root_name(&root_path);
+
+    let mut walker = Walker {
+        cancel,
+        progress,
+        tally: Tally::default(),
+        seen: HashSet::new(),
+        truncated: false,
+        cancelled: false,
+        last_emit: Instant::now(),
+    };
+    let node = walker.walk(&root_path, name, 0);
+    let (total_bytes, free_bytes) = capacity_of(&root_path).unzip();
+
+    Ok(DuScan {
+        root: node,
+        files: walker.tally.files,
+        dirs: walker.tally.dirs,
+        errors: walker.tally.errors,
+        truncated: walker.truncated,
+        cancelled: walker.cancelled,
+        total_bytes,
+        free_bytes,
+    })
+}
+
+/// Display name for a scan root: its final component, or the path itself for a
+/// filesystem root (`/`, `C:\`) which has none.
+fn root_name(p: &Path) -> String {
+    p.file_name()
+        .map(|n| n.to_string_lossy().into_owned())
+        .unwrap_or_else(|| display_path(p))
+}
+
+// ── Remote `du` parsing ───────────────────────────────────────────────────────
+
+/// Parent of an absolute POSIX path: `/a/b` → `/a`, `/a` → `/`, `/` → `None`.
+fn parent_of(p: &str) -> Option<&str> {
+    if p == "/" {
+        return None;
+    }
+    let i = p.rfind('/')?;
+    Some(if i == 0 { "/" } else { &p[..i] })
+}
+
+fn base_name(p: &str) -> String {
+    match p.rsplit_once('/') {
+        Some((_, name)) if !name.is_empty() => name.to_string(),
+        _ => p.to_string(),
+    }
+}
+
+/// Rebuild a [`DuScan`] from the stdout of `du -ak <root>` on the host.
+///
+/// `du` emits `"<kbytes>\t<path>"` per line, children before parents, with each
+/// directory's figure already cumulative — so sizes are taken verbatim rather than
+/// re-summed. It also dedups hard links itself. A path is treated as a directory
+/// iff some other line names it as a parent; a genuinely *empty* remote directory
+/// is therefore reported as a zero-byte file. That is cosmetic and the only way to
+/// tell without a second round-trip.
+pub fn parse_du_output(root: &str, stdout: &str) -> Result<DuScan, String> {
+    let mut sizes: HashMap<&str, u64> = HashMap::new();
+    let mut order: Vec<&str> = Vec::new();
+    let mut truncated = false;
+
+    for line in stdout.lines() {
+        if order.len() >= MAX_REMOTE_LINES {
+            truncated = true;
+            break;
+        }
+        let Some((kb, path)) = line.split_once('\t') else {
+            continue;
+        };
+        let path = path.trim_end_matches('/');
+        let path = if path.is_empty() { "/" } else { path };
+        let Ok(kb) = kb.trim().parse::<u64>() else {
+            continue;
+        };
+        if sizes.insert(path, kb.saturating_mul(1024)).is_none() {
+            order.push(path);
+        }
+    }
+
+    let root = root.trim_end_matches('/');
+    let root = if root.is_empty() { "/" } else { root };
+    if !sizes.contains_key(root) {
+        return Err(format!("du reported nothing for {root}"));
+    }
+
+    let mut kids: HashMap<&str, Vec<&str>> = HashMap::new();
+    for &p in &order {
+        if p == root {
+            continue;
+        }
+        let Some(parent) = parent_of(p) else { continue };
+        if sizes.contains_key(parent) {
+            kids.entry(parent).or_default().push(p);
+        }
+    }
+
+    let mut tally = Tally::default();
+    let node = build_remote(root, 0, &sizes, &kids, &mut tally, &mut truncated);
+
+    Ok(DuScan {
+        root: node,
+        files: tally.files,
+        dirs: tally.dirs,
+        errors: 0,
+        truncated,
+        cancelled: false,
+        total_bytes: None,
+        free_bytes: None,
+    })
+}
+
+fn build_remote(
+    path: &str,
+    depth: usize,
+    sizes: &HashMap<&str, u64>,
+    kids: &HashMap<&str, Vec<&str>>,
+    tally: &mut Tally,
+    truncated: &mut bool,
+) -> DuNode {
+    let size = sizes.get(path).copied().unwrap_or(0);
+    let name = base_name(path);
+    let Some(children) = kids.get(path) else {
+        tally.files = tally.files.saturating_add(1);
+        tally.bytes = tally.bytes.saturating_add(size);
+        return DuNode::file(name, path.to_string(), size);
+    };
+
+    tally.dirs = tally.dirs.saturating_add(1);
+    let mut node = DuNode::dir(name, path.to_string());
+    node.size = size;
+
+    if depth >= MAX_EMIT_DEPTH || depth >= MAX_SCAN_DEPTH {
+        // Still descend, so the file/dir counters stay honest, but emit nothing.
+        for &c in children {
+            let sub = build_remote(c, depth + 1, sizes, kids, tally, truncated);
+            node.hidden_children += 1;
+            node.hidden_bytes = node.hidden_bytes.saturating_add(sub.size);
+        }
+        *truncated = true;
+        return node;
+    }
+
+    let mut built: Vec<DuNode> =
+        children.iter().map(|&c| build_remote(c, depth + 1, sizes, kids, tally, truncated)).collect();
+    built.sort_by(|a, b| b.size.cmp(&a.size));
+    if built.len() > MAX_CHILDREN {
+        let rest = built.split_off(MAX_CHILDREN);
+        node.hidden_children = rest.len() as u32;
+        node.hidden_bytes = rest.iter().map(|k| k.size).sum();
+        *truncated = true;
+    }
+    node.children = built;
+    node
+}
+
+// ── Capacity ──────────────────────────────────────────────────────────────────
+
+/// `(total, available)` bytes of the filesystem holding `path`. `None` where the
+/// platform gives us no answer, in which case the pane simply omits its
+/// capacity bar.
+#[cfg(unix)]
+pub fn capacity_of(path: &Path) -> Option<(u64, u64)> {
+    use std::ffi::CString;
+    use std::os::unix::ffi::OsStrExt;
+
+    let c_path = CString::new(path.as_os_str().as_bytes()).ok()?;
+    // SAFETY: `stat` is zeroed and outlives the call; `c_path` is a valid NUL-
+    // terminated string for its duration.
+    let mut stat: libc::statvfs = unsafe { std::mem::zeroed() };
+    if unsafe { libc::statvfs(c_path.as_ptr(), &mut stat) } != 0 {
+        return None;
+    }
+    // `f_frsize` is the fragment size the block counts are expressed in; it is 0 on
+    // some filesystems, where `f_bsize` is the right unit.
+    let unit = if stat.f_frsize > 0 { stat.f_frsize as u64 } else { stat.f_bsize as u64 };
+    let total = (stat.f_blocks as u64).saturating_mul(unit);
+    let free = (stat.f_bavail as u64).saturating_mul(unit);
+    Some((total, free))
+}
+
+/// Windows: `GetDiskFreeSpaceExW` on the volume holding `path`. Total-bytes and
+/// caller-available bytes (quota-aware), matching the Unix arm's
+/// `f_blocks`/`f_bavail` semantics.
+#[cfg(windows)]
+pub fn capacity_of(path: &Path) -> Option<(u64, u64)> {
+    use std::os::windows::ffi::OsStrExt;
+    use windows::core::PCWSTR;
+    use windows::Win32::Storage::FileSystem::GetDiskFreeSpaceExW;
+
+    let wide: Vec<u16> = path.as_os_str().encode_wide().chain(std::iter::once(0)).collect();
+    let mut avail: u64 = 0;
+    let mut total: u64 = 0;
+    // SAFETY: `wide` is a valid NUL-terminated UTF-16 string for the duration of
+    // the call; the out-params are plain u64s the API fills on success.
+    unsafe {
+        GetDiskFreeSpaceExW(
+            PCWSTR(wide.as_ptr()),
+            Some(&mut avail as *mut u64),
+            Some(&mut total as *mut u64),
+            None,
+        )
+        .ok()?;
+    }
+    Some((total, avail))
+}
+
+#[cfg(not(any(unix, windows)))]
+pub fn capacity_of(_path: &Path) -> Option<(u64, u64)> {
+    None
+}
+
+/// Scan targets for the pane's home screen: the user's home directory, plus the
+/// filesystem root it lives on.
+pub fn devices() -> Vec<DuDevice> {
+    let home = crate::paths::home_dir();
+    let mut out = vec![device("Home", &home)];
+
+    let fs_root: PathBuf = home.ancestors().last().unwrap_or(&home).to_path_buf();
+    if fs_root != home {
+        out.push(device("Filesystem", &fs_root));
+    }
+    out
+}
+
+fn device(label: &str, path: &Path) -> DuDevice {
+    let (total_bytes, free_bytes) = capacity_of(path).unzip();
+    DuDevice { label: label.to_string(), path: display_path(path), total_bytes, free_bytes }
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    fn no_cancel() -> AtomicBool {
+        AtomicBool::new(false)
+    }
+
+    /// The capacity probe answers for the volume holding the home dir on every
+    /// OS we ship (statvfs on Unix, GetDiskFreeSpaceExW on Windows) — this used
+    /// to be `None` on Windows, silently dropping the pane's capacity bar.
+    #[test]
+    fn capacity_of_home_reports_a_plausible_volume() {
+        let (total, free) = capacity_of(&crate::paths::home_dir()).expect("capacity");
+        assert!(total > 0, "volume total should be non-zero");
+        assert!(free <= total, "free bytes cannot exceed the volume size");
+    }
+
+    fn scan(root: &Path) -> DuScan {
+        let cancel = no_cancel();
+        let mut noop = |_: &Tally, _: &Path| {};
+        scan_local(&root.to_string_lossy(), &cancel, &mut noop).expect("scan")
+    }
+
+    fn write(path: &Path, bytes: usize) {
+        let mut f = fs::File::create(path).unwrap();
+        f.write_all(&vec![b'x'; bytes]).unwrap();
+    }
+
+    fn child<'a>(node: &'a DuNode, name: &str) -> &'a DuNode {
+        node.children.iter().find(|c| c.name == name).expect("child")
+    }
+
+    #[test]
+    fn sums_nested_sizes_and_sorts_children_biggest_first() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        fs::create_dir(root.join("small")).unwrap();
+        fs::create_dir(root.join("big")).unwrap();
+        write(&root.join("small/a.txt"), 100);
+        write(&root.join("big/b.txt"), 5_000);
+        write(&root.join("big/c.txt"), 1_000);
+
+        let scan = scan(root);
+        assert_eq!(scan.root.size, 6_100);
+        assert_eq!(scan.files, 3);
+        assert_eq!(scan.dirs, 3); // root + small + big
+        assert!(!scan.truncated);
+        assert!(!scan.cancelled);
+
+        let names: Vec<&str> = scan.root.children.iter().map(|c| c.name.as_str()).collect();
+        assert_eq!(names, vec!["big", "small"], "children sort descending by size");
+        assert_eq!(child(&scan.root, "big").size, 6_000);
+        // ...and grandchildren sort too.
+        let big = child(&scan.root, "big");
+        assert_eq!(big.children[0].name, "b.txt");
+    }
+
+    #[test]
+    fn vendor_dirs_are_scanned_not_skipped() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        fs::create_dir(root.join("node_modules")).unwrap();
+        write(&root.join("node_modules/dep.js"), 2_048);
+
+        let scan = scan(root);
+        assert_eq!(scan.root.size, 2_048, "node_modules is the answer, not noise");
+        assert_eq!(child(&scan.root, "node_modules").size, 2_048);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn symlink_loop_terminates_and_is_not_counted() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        fs::create_dir(root.join("real")).unwrap();
+        write(&root.join("real/f.bin"), 512);
+        // A directory symlink pointing back at the root: following it would loop.
+        std::os::unix::fs::symlink(root, root.join("real/loop")).unwrap();
+        // ...and a file symlink, which must not double-count f.bin.
+        std::os::unix::fs::symlink(root.join("real/f.bin"), root.join("alias.bin")).unwrap();
+
+        let scan = scan(root);
+        assert_eq!(scan.root.size, 512, "symlinks contribute nothing");
+        assert_eq!(scan.files, 1);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn hard_links_are_counted_once() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        write(&root.join("original.bin"), 4_096);
+        fs::hard_link(root.join("original.bin"), root.join("link.bin")).unwrap();
+
+        let scan = scan(root);
+        assert_eq!(scan.root.size, 4_096, "the second link is the same bytes on disk");
+        assert_eq!(scan.files, 1);
+    }
+
+    #[test]
+    fn wide_directory_is_capped_and_the_remainder_is_accounted_for() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let n = MAX_CHILDREN + 10;
+        for i in 0..n {
+            // Descending sizes, so the pruned tail is the smallest files.
+            write(&root.join(format!("f{i:03}.bin")), n - i);
+        }
+        let total: usize = (1..=n).sum();
+
+        let scan = scan(root);
+        assert!(scan.truncated);
+        assert_eq!(scan.files, n as u64);
+        assert_eq!(scan.root.children.len(), MAX_CHILDREN);
+        assert_eq!(scan.root.hidden_children, 10);
+        assert_eq!(scan.root.size, total as u64, "the total stays exact");
+        let emitted: u64 = scan.root.children.iter().map(|c| c.size).sum();
+        assert_eq!(
+            emitted + scan.root.hidden_bytes,
+            scan.root.size,
+            "emitted children plus hidden bytes account for the whole node",
+        );
+    }
+
+    #[test]
+    fn deep_tree_keeps_its_total_but_stops_emitting_children() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let mut p = root.to_path_buf();
+        for i in 0..(MAX_EMIT_DEPTH + 3) {
+            p = p.join(format!("d{i}"));
+            fs::create_dir(&p).unwrap();
+        }
+        write(&p.join("deep.bin"), 777);
+
+        let scan = scan(root);
+        assert!(scan.truncated);
+        assert_eq!(scan.root.size, 777, "the deep file still counts toward the root");
+
+        // Walk down the emitted spine: it must stop handing out children at the cap.
+        let mut node = &scan.root;
+        let mut depth = 0;
+        while let Some(next) = node.children.first() {
+            node = next;
+            depth += 1;
+        }
+        assert_eq!(depth, MAX_EMIT_DEPTH);
+        assert_eq!(node.hidden_children, 1, "the level below the cap is folded away");
+        assert_eq!(node.size, 777);
+    }
+
+    #[test]
+    fn cancellation_stops_the_walk_and_returns_a_partial_tree() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        for i in 0..20 {
+            write(&root.join(format!("f{i}.bin")), 100);
+        }
+        let cancel = AtomicBool::new(true); // already cancelled
+        let mut noop = |_: &Tally, _: &Path| {};
+        let scan = scan_local(&root.to_string_lossy(), &cancel, &mut noop).unwrap();
+        assert!(scan.cancelled);
+        assert!(scan.root.children.is_empty());
+    }
+
+    #[test]
+    fn missing_root_is_an_error() {
+        let tmp = tempfile::tempdir().unwrap();
+        let cancel = no_cancel();
+        let mut noop = |_: &Tally, _: &Path| {};
+        let missing = tmp.path().join("nope");
+        assert!(scan_local(&missing.to_string_lossy(), &cancel, &mut noop).is_err());
+    }
+
+    #[test]
+    fn progress_reports_the_running_tally() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        fs::create_dir(root.join("sub")).unwrap();
+        write(&root.join("sub/a.bin"), 10);
+
+        let cancel = no_cancel();
+        let mut seen: Vec<u64> = Vec::new();
+        // The first tick always fires (last_emit starts one interval in the past is
+        // not guaranteed), so assert only that the callback is *callable* and that
+        // the tally it sees is monotonic — the timing itself is not under test.
+        let mut cb = |t: &Tally, _: &Path| seen.push(t.dirs);
+        let scan = scan_local(&root.to_string_lossy(), &cancel, &mut cb).unwrap();
+        assert_eq!(scan.dirs, 2);
+        assert!(seen.windows(2).all(|w| w[0] <= w[1]), "dir count only grows");
+    }
+
+    // ── Remote `du` parsing ───────────────────────────────────────────────────
+
+    #[test]
+    fn parses_du_output_into_the_same_tree_shape() {
+        // Real `du -ak` shape: children first, dirs cumulative, sizes in KiB.
+        let out = "\
+4\t/srv/app/src/main.rs
+8\t/srv/app/src
+16\t/srv/app/data.bin
+28\t/srv/app
+";
+        let scan = parse_du_output("/srv/app", out).unwrap();
+        assert_eq!(scan.root.name, "app");
+        assert_eq!(scan.root.size, 28 * 1024, "the root total is du's, not a re-sum");
+        assert_eq!(scan.dirs, 2); // /srv/app and /srv/app/src
+        assert_eq!(scan.files, 2);
+
+        let names: Vec<&str> = scan.root.children.iter().map(|c| c.name.as_str()).collect();
+        assert_eq!(names, vec!["data.bin", "src"], "biggest first");
+        assert_eq!(child(&scan.root, "src").children[0].name, "main.rs");
+    }
+
+    #[test]
+    fn parses_a_du_scan_rooted_at_the_filesystem_root() {
+        let out = "4\t/etc/hosts\n8\t/etc\n12\t/\n";
+        let scan = parse_du_output("/", out).unwrap();
+        assert_eq!(scan.root.name, "/");
+        assert_eq!(scan.root.size, 12 * 1024);
+        assert_eq!(child(&scan.root, "etc").children[0].name, "hosts");
+    }
+
+    #[test]
+    fn du_output_without_the_root_is_an_error() {
+        assert!(parse_du_output("/srv/app", "4\t/other/thing\n").is_err());
+    }
+
+    #[test]
+    fn du_output_tolerates_junk_lines_and_a_trailing_slash_root() {
+        let out = "not a du line\n\n4\t/srv/app/f\n8\t/srv/app/\n";
+        let scan = parse_du_output("/srv/app", out).unwrap();
+        assert_eq!(scan.root.size, 8 * 1024);
+        assert_eq!(scan.root.children.len(), 1);
+    }
+}
diff --git a/src-tauri/src/gpustat.rs b/src-tauri/src/gpustat.rs
new file mode 100644
index 0000000..7e4e434
--- /dev/null
+++ b/src-tauri/src/gpustat.rs
@@ -0,0 +1,1007 @@
+//! Whole-system GPU memory sampling for the GPU readouts (header, system
+//! monitor, local-model menu).
+//!
+//! This is the *device's* memory, not one process's share of it: the number that
+//! answers "how much GPU memory is left before I load a model?". Ollama's own
+//! `/api/ps` figure (`commands::ollama::total_vram_in_use`) remains a line in the
+//! breakdown, no longer the whole reading.
+//!
+//! A GPU's memory comes in **two pools** and both are reported, because on an
+//! integrated GPU only one of them is real: the dedicated **VRAM** carve-out
+//! (typically 512 MB on an APU — the framebuffer, and permanently ~full, so
+//! reading it alone says nothing) and the **shared** pool the driver maps out of
+//! system RAM (`GTT` on amdgpu — where a model actually lands). On a discrete
+//! card the shared pool is ~0 and the combined figure collapses to plain device
+//! VRAM. Callers sum the two; this module keeps them apart so the UI can show the
+//! split.
+//!
+//! Sources, in the order they are tried:
+//! - **DRM sysfs** (Linux): `/sys/class/drm/card*/device/mem_info_*` +
+//!   `gpu_busy_percent`. Plain file reads — no tool, no root, cheap enough to
+//!   poll. Exposed by `amdgpu`; Intel's `i915` does not expose it (its memory
+//!   accounting lives behind root-only debugfs), so an Intel-only box reports no
+//!   GPU memory rather than a wrong one.
+//! - **`nvidia-smi`** (Linux + Windows): the only portable read of NVIDIA memory.
+//!   A process spawn, so its absence is remembered ([`NVIDIA_RETRY`]) instead of
+//!   being paid for on every poll.
+//! - Anything else (macOS, unknown drivers) samples nothing and the UI falls back
+//!   to the Ollama figure.
+
+use serde::Serialize;
+use std::collections::HashMap;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+/// One GPU's memory (and utilization, when the driver reports it).
+///
+/// `vram_*` is dedicated device memory; `shared_*` is system memory mapped for
+/// the GPU (amdgpu's GTT), which is `0` on a discrete card. `busy_percent` is
+/// `None` when the driver won't say — distinct from `Some(0.0)`, an idle GPU.
+///
+/// The trailing scalars are the *sensor* readings — temperature, power, clocks,
+/// fan, PCIe link and driver version — each `None` when the driver or platform
+/// won't report it (an APU exposes no `power1_cap`, a laptop's `nvidia-smi`
+/// answers `[N/A]` in power-saving). They come from the *same* cheap sysfs /
+/// `nvidia-smi` read as the memory figures, so every surface that already samples
+/// a GPU gets them for free. Per-**process** GPU usage is deliberately *not* here:
+/// it is a separate, heavier walk ([`process_snapshot`]) only the monitor pane pays
+/// for, so the always-visible header readout stays cheap.
+#[derive(Serialize, Clone, Debug, Default, PartialEq)]
+pub struct GpuSample {
+    pub name: String,
+    pub driver: String,
+    pub vram_used: u64,
+    pub vram_total: u64,
+    pub shared_used: u64,
+    pub shared_total: u64,
+    pub busy_percent: Option<f64>,
+    /// Edge/core temperature, °C.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub temp_c: Option<f64>,
+    /// Instantaneous board power draw, watts.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub power_w: Option<f64>,
+    /// Board power limit/cap, watts — the ceiling `power_w` is measured against.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub power_cap_w: Option<f64>,
+    /// Core (shader) clock, MHz.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sclk_mhz: Option<u64>,
+    /// Memory clock, MHz.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mclk_mhz: Option<u64>,
+    /// Fan speed as 0–100% of its range (not RPM).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fan_percent: Option<f64>,
+    /// Kernel/driver version string (`nvidia-smi` only; amdgpu exposes none per-card).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub driver_version: Option<String>,
+    /// Current PCIe link generation (1–5) and lane width (e.g. 16).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pcie_gen: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pcie_width: Option<u32>,
+}
+
+/// One process's share of GPU memory, for the monitor pane's per-process list.
+///
+/// A *gauge* (bytes resident on the GPU right now), not a cumulative counter, so
+/// it needs no delta between samples — unlike engine-time utilization, which is
+/// why this carries memory only. `name` is the process's `comm` (Linux) or the
+/// `process_name` `nvidia-smi` reports.
+#[derive(Serialize, Clone, Debug, Default, PartialEq)]
+pub struct GpuProc {
+    pub pid: u32,
+    pub name: String,
+    pub mem_bytes: u64,
+}
+
+/// Upper bound on cache reuse. Three surfaces poll this independently (header,
+/// monitor pane, model menu); without the cache a `nvidia-smi` spawn would be
+/// paid three times over per tick.
+const CACHE_TTL: Duration = Duration::from_millis(1000);
+
+/// How long a missing `nvidia-smi` is believed. Long enough that the common case
+/// (no NVIDIA GPU) costs one failed spawn rather than one per poll, short enough
+/// that installing the driver doesn't require an app restart to be noticed.
+const NVIDIA_RETRY: Duration = Duration::from_secs(60);
+
+static CACHE: Mutex<Option<(Instant, Vec<GpuSample>)>> = Mutex::new(None);
+static NVIDIA_MISSING_UNTIL: Mutex<Option<Instant>> = Mutex::new(None);
+
+/// Every GPU this machine will talk about, memoized for [`CACHE_TTL`]. Returns an
+/// empty vec (never an error) on a platform or driver we can't read, so callers
+/// treat "no GPU information" as a display fallback rather than a failure.
+pub fn snapshot() -> Vec<GpuSample> {
+    if let Some((at, gpus)) = CACHE.lock().ok().and_then(|c| c.clone()) {
+        if at.elapsed() < CACHE_TTL {
+            return gpus;
+        }
+    }
+
+    let gpus = sample();
+    if let Ok(mut cache) = CACHE.lock() {
+        *cache = Some((Instant::now(), gpus.clone()));
+    }
+    gpus
+}
+
+/// The two sources are disjoint by construction, so there is nothing to
+/// de-duplicate: [`drm_sample`] only keeps cards that expose `mem_info_*` (i.e.
+/// `amdgpu`), and the proprietary NVIDIA driver exposes none — its cards come
+/// from `nvidia-smi` alone.
+fn sample() -> Vec<GpuSample> {
+    let mut gpus = drm_sample();
+    gpus.extend(nvidia_sample());
+    gpus
+}
+
+// ── DRM sysfs (Linux) ────────────────────────────────────────────────────────
+
+/// The sysfs files backing one DRM card, read as strings. Split out from the
+/// filesystem walk so [`parse_drm_card`] stays pure and testable on a machine
+/// with no such GPU (i.e. CI).
+/// The sysfs files backing one DRM card, read as strings. `pub(crate)` — the
+/// remote-snapshot parser in [`crate::sysstat`] rebuilds one of these from the
+/// host's files (shipped over SSH) and runs it through the same [`parse_drm_card`],
+/// so the local and host AMD readings share one code path.
+#[derive(Default)]
+pub(crate) struct DrmFiles {
+    driver: String,
+    vendor: String,
+    device: String,
+    vram_used: Option<String>,
+    vram_total: Option<String>,
+    gtt_used: Option<String>,
+    gtt_total: Option<String>,
+    busy: Option<String>,
+    // Sensor reads. `temp`/`power`/`power_cap` come from the card's hwmon subdir
+    // (millidegrees / microwatts); `pwm`/`pwm_max` give a fan percent; `sclk`/`mclk`
+    // are the `pp_dpm_*` clock tables (the active state is flagged `*`); the two
+    // `link_*` files describe the current PCIe link.
+    temp: Option<String>,
+    power: Option<String>,
+    power_cap: Option<String>,
+    pwm: Option<String>,
+    pwm_max: Option<String>,
+    sclk: Option<String>,
+    mclk: Option<String>,
+    link_speed: Option<String>,
+    link_width: Option<String>,
+}
+
+fn parse_u64(s: Option<&String>) -> u64 {
+    s.and_then(|v| v.trim().parse::<u64>().ok()).unwrap_or(0)
+}
+
+/// A hwmon millidegree/milliunit reading (`temp1_input` is °C×1000) as its base unit.
+fn parse_milli(s: Option<&String>) -> Option<f64> {
+    s.and_then(|v| v.trim().parse::<f64>().ok())
+        .map(|m| m / 1000.0)
+}
+
+/// A hwmon micro-unit reading (`power1_average` is watts×1e6) as its base unit.
+fn parse_micro(s: Option<&String>) -> Option<f64> {
+    s.and_then(|v| v.trim().parse::<f64>().ok())
+        .map(|m| m / 1_000_000.0)
+}
+
+/// Fan speed as 0–100% from a raw `pwm1` (0–`pwm1_max`, default 255) reading.
+fn parse_pwm_percent(pwm: Option<&String>, max: Option<&String>) -> Option<f64> {
+    let pwm = pwm.and_then(|v| v.trim().parse::<f64>().ok())?;
+    let max = max
+        .and_then(|m| m.trim().parse::<f64>().ok())
+        .filter(|m| *m > 0.0)
+        .unwrap_or(255.0);
+    Some((pwm / max * 100.0).clamp(0.0, 100.0))
+}
+
+/// amdgpu's `pp_dpm_sclk`/`pp_dpm_mclk` list every DPM state, one per line
+/// (`1: 1000Mhz *`), with the **active** one flagged `*`. Returns its MHz.
+fn parse_active_clock_mhz(s: Option<&String>) -> Option<u64> {
+    let line = s?.lines().find(|l| l.contains('*'))?;
+    line.split_whitespace().find_map(|tok| {
+        tok.to_ascii_lowercase()
+            .strip_suffix("mhz")
+            .and_then(|n| n.parse::<u64>().ok())
+    })
+}
+
+/// PCIe generation from a `current_link_speed` string (`"16.0 GT/s PCIe"`),
+/// mapping the transfer rate to the gen that introduced it.
+fn pcie_gen_from_speed(s: Option<&String>) -> Option<u32> {
+    let gts = s?.split_whitespace().next()?.parse::<f64>().ok()?;
+    Some(if gts >= 32.0 {
+        5
+    } else if gts >= 16.0 {
+        4
+    } else if gts >= 8.0 {
+        3
+    } else if gts >= 5.0 {
+        2
+    } else {
+        1
+    })
+}
+
+/// A card is only reported when it states a **VRAM total**: that is the marker
+/// that this driver does memory accounting at all. Without it (Intel `i915`, the
+/// NVIDIA blob) every byte figure would be a zero pretending to be a measurement.
+/// Set one [`DrmFiles`] field by its sysfs basename, for the remote parser that
+/// receives the host's files as `key`/`value` pairs. An empty `value` (a file the
+/// host didn't have) is the caller's cue to skip, so this is only handed real ones.
+pub(crate) fn set_drm_field(files: &mut DrmFiles, key: &str, value: &str) {
+    let owned = || Some(value.to_string());
+    match key {
+        "driver" => files.driver = value.to_string(),
+        "vendor" => files.vendor = value.to_string(),
+        "device" => files.device = value.to_string(),
+        "vram_used" => files.vram_used = owned(),
+        "vram_total" => files.vram_total = owned(),
+        "gtt_used" => files.gtt_used = owned(),
+        "gtt_total" => files.gtt_total = owned(),
+        "busy" => files.busy = owned(),
+        "temp" => files.temp = owned(),
+        "power" => files.power = owned(),
+        "power_cap" => files.power_cap = owned(),
+        "pwm" => files.pwm = owned(),
+        "pwm_max" => files.pwm_max = owned(),
+        "sclk" => files.sclk = owned(),
+        "mclk" => files.mclk = owned(),
+        "link_speed" => files.link_speed = owned(),
+        "link_width" => files.link_width = owned(),
+        _ => {}
+    }
+}
+
+pub(crate) fn parse_drm_card(index: u32, files: &DrmFiles) -> Option<GpuSample> {
+    let vram_total = parse_u64(files.vram_total.as_ref());
+    if vram_total == 0 {
+        return None;
+    }
+
+    Some(GpuSample {
+        name: gpu_name(&files.vendor, &files.device, index),
+        driver: files.driver.clone(),
+        vram_used: parse_u64(files.vram_used.as_ref()),
+        vram_total,
+        shared_used: parse_u64(files.gtt_used.as_ref()),
+        shared_total: parse_u64(files.gtt_total.as_ref()),
+        busy_percent: files
+            .busy
+            .as_ref()
+            .and_then(|b| b.trim().parse::<f64>().ok()),
+        temp_c: parse_milli(files.temp.as_ref()),
+        power_w: parse_micro(files.power.as_ref()),
+        power_cap_w: parse_micro(files.power_cap.as_ref()),
+        sclk_mhz: parse_active_clock_mhz(files.sclk.as_ref()),
+        mclk_mhz: parse_active_clock_mhz(files.mclk.as_ref()),
+        fan_percent: parse_pwm_percent(files.pwm.as_ref(), files.pwm_max.as_ref()),
+        // amdgpu exposes no clean per-card driver version in sysfs; leave it unset
+        // rather than surface the kernel release, which isn't the GPU driver.
+        driver_version: None,
+        pcie_gen: pcie_gen_from_speed(files.link_speed.as_ref()),
+        pcie_width: files
+            .link_width
+            .as_ref()
+            .and_then(|w| w.trim().parse::<u32>().ok()),
+    })
+}
+
+#[cfg(target_os = "linux")]
+fn drm_sample() -> Vec<GpuSample> {
+    use std::fs;
+
+    let Ok(entries) = fs::read_dir("/sys/class/drm") else {
+        return Vec::new();
+    };
+
+    let mut cards: Vec<(u32, GpuSample)> = Vec::new();
+    for entry in entries.flatten() {
+        // Only whole cards ("card1"), not their connectors ("card1-DP-1").
+        let name = entry.file_name();
+        let Some(index) = name
+            .to_str()
+            .and_then(|n| n.strip_prefix("card"))
+            .and_then(|n| n.parse::<u32>().ok())
+        else {
+            continue;
+        };
+
+        let dev = entry.path().join("device");
+        let read = |file: &str| fs::read_to_string(dev.join(file)).ok();
+        // Temperature/power/fan live under the card's hwmon instance, whose index
+        // isn't stable (`hwmon/hwmonN`), so take the first one the card exposes.
+        let hwmon = fs::read_dir(dev.join("hwmon")).ok().and_then(|it| {
+            it.flatten()
+                .map(|e| e.path())
+                .find(|p| {
+                    p.file_name()
+                        .and_then(|n| n.to_str())
+                        .is_some_and(|n| n.starts_with("hwmon"))
+                })
+        });
+        let hread = |file: &str| {
+            hwmon
+                .as_ref()
+                .and_then(|h| fs::read_to_string(h.join(file)).ok())
+        };
+        let files = DrmFiles {
+            driver: read("uevent")
+                .and_then(|u| {
+                    u.lines()
+                        .find_map(|l| l.strip_prefix("DRIVER=").map(str::to_string))
+                })
+                .unwrap_or_default(),
+            vendor: read("vendor").unwrap_or_default().trim().to_string(),
+            device: read("device").unwrap_or_default().trim().to_string(),
+            vram_used: read("mem_info_vram_used"),
+            vram_total: read("mem_info_vram_total"),
+            gtt_used: read("mem_info_gtt_used"),
+            gtt_total: read("mem_info_gtt_total"),
+            busy: read("gpu_busy_percent"),
+            // `power1_average` is the smoothed draw; some cards only expose the
+            // instantaneous `power1_input`, so fall back to it.
+            temp: hread("temp1_input"),
+            power: hread("power1_average").or_else(|| hread("power1_input")),
+            power_cap: hread("power1_cap"),
+            pwm: hread("pwm1"),
+            pwm_max: hread("pwm1_max"),
+            sclk: read("pp_dpm_sclk"),
+            mclk: read("pp_dpm_mclk"),
+            link_speed: read("current_link_speed"),
+            link_width: read("current_link_width"),
+        };
+
+        if let Some(sample) = parse_drm_card(index, &files) {
+            cards.push((index, sample));
+        }
+    }
+
+    cards.sort_by_key(|(index, _)| *index);
+    cards.into_iter().map(|(_, sample)| sample).collect()
+}
+
+#[cfg(not(target_os = "linux"))]
+fn drm_sample() -> Vec<GpuSample> {
+    Vec::new()
+}
+
+// ── Card naming ──────────────────────────────────────────────────────────────
+
+/// Memo for [`gpu_name`], keyed `"vendor:device"`. `pci.ids` is ~1.5 MB; without
+/// this it would be re-scanned on every cache miss, i.e. once a second.
+static NAME_CACHE: Mutex<Option<HashMap<String, String>>> = Mutex::new(None);
+
+/// Where a Linux system keeps the PCI vendor/device name database. Sysfs carries
+/// only the numeric ids, so this is the only way to say "Radeon 890M" rather than
+/// "AMD GPU 1" — and it is a nicety, so its absence is not an error.
+const PCI_IDS_PATHS: [&str; 3] = [
+    "/usr/share/hwdata/pci.ids",
+    "/usr/share/misc/pci.ids",
+    "/usr/share/pci.ids",
+];
+
+/// A human name for a card: its marketing name from `pci.ids` when that database
+/// is installed, otherwise the vendor plus the DRM card index.
+fn gpu_name(vendor: &str, device: &str, index: u32) -> String {
+    let vendor_id = strip_hex(vendor);
+    let device_id = strip_hex(device);
+    let fallback = || match vendor_label(&vendor_id) {
+        Some(vendor) => format!("{vendor} GPU {index}"),
+        None => format!("GPU {index}"),
+    };
+
+    if vendor_id.is_empty() || device_id.is_empty() {
+        return fallback();
+    }
+
+    let key = format!("{vendor_id}:{device_id}");
+    let Ok(mut cache) = NAME_CACHE.lock() else {
+        return fallback();
+    };
+    let names = cache.get_or_insert_with(HashMap::new);
+    if let Some(hit) = names.get(&key) {
+        return hit.clone();
+    }
+
+    let name = PCI_IDS_PATHS
+        .iter()
+        .find_map(|path| std::fs::read_to_string(path).ok())
+        .and_then(|db| pci_ids_lookup(&db, &vendor_id, &device_id))
+        .unwrap_or_else(fallback);
+    names.insert(key, name.clone());
+    name
+}
+
+/// Sysfs writes ids as `0x1002`; `pci.ids` indexes them as `1002`.
+fn strip_hex(id: &str) -> String {
+    id.trim()
+        .trim_start_matches("0x")
+        .to_ascii_lowercase()
+        .to_string()
+}
+
+fn vendor_label(vendor_id: &str) -> Option<&'static str> {
+    match vendor_id {
+        "1002" => Some("AMD"),
+        "10de" => Some("NVIDIA"),
+        "8086" => Some("Intel"),
+        _ => None,
+    }
+}
+
+/// Find a device's name in a `pci.ids` database. The format is indentation-scoped:
+/// a vendor at column 0, its devices one tab in, their subsystems two tabs in —
+/// so a device line only means anything *under* the right vendor, and the
+/// two-tab lines must be skipped rather than matched.
+fn pci_ids_lookup(db: &str, vendor_id: &str, device_id: &str) -> Option<String> {
+    let mut in_vendor = false;
+    for line in db.lines() {
+        if line.starts_with('#') || line.trim().is_empty() {
+            continue;
+        }
+        if !line.starts_with('\t') {
+            if in_vendor {
+                return None; // Left our vendor's block without a match.
+            }
+            in_vendor = line
+                .split_whitespace()
+                .next()
+                .is_some_and(|id| id.eq_ignore_ascii_case(vendor_id));
+            continue;
+        }
+        if !in_vendor || line.starts_with("\t\t") {
+            continue; // Another vendor's device, or a subsystem line.
+        }
+        let mut parts = line.trim_start().splitn(2, char::is_whitespace);
+        if parts
+            .next()
+            .is_some_and(|id| id.eq_ignore_ascii_case(device_id))
+        {
+            let name = parts.next().unwrap_or_default().trim();
+            if !name.is_empty() {
+                return Some(name.to_string());
+            }
+        }
+    }
+    None
+}
+
+// ── nvidia-smi (Linux + Windows) ─────────────────────────────────────────────
+
+fn nvidia_sample() -> Vec<GpuSample> {
+    if let Ok(missing_until) = NVIDIA_MISSING_UNTIL.lock() {
+        if missing_until.is_some_and(|until| Instant::now() < until) {
+            return Vec::new();
+        }
+    }
+
+    let output = crate::paths::command_no_window("nvidia-smi")
+        .args([
+            "--query-gpu=name,memory.used,memory.total,utilization.gpu,\
+temperature.gpu,power.draw,power.limit,clocks.sm,clocks.mem,fan.speed,\
+driver_version,pcie.link.gen.current,pcie.link.width.current",
+            "--format=csv,noheader,nounits",
+        ])
+        .output();
+
+    match output {
+        Ok(out) if out.status.success() => {
+            parse_nvidia_smi(&String::from_utf8_lossy(&out.stdout))
+        }
+        _ => {
+            if let Ok(mut missing_until) = NVIDIA_MISSING_UNTIL.lock() {
+                *missing_until = Some(Instant::now() + NVIDIA_RETRY);
+            }
+            Vec::new()
+        }
+    }
+}
+
+/// A `nvidia-smi` CSV field, or `None` when it is absent/blank or the `[N/A]` the
+/// tool prints for a value the driver won't answer (a laptop GPU in power-saving,
+/// a passthrough VM) — so an unreadable sensor is *unknown*, never a zero.
+fn nv_field<'a>(fields: &[&'a str], i: usize) -> Option<&'a str> {
+    fields
+        .get(i)
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty() && !s.starts_with("[N/A") && *s != "N/A")
+}
+
+/// Parse the `nvidia-smi --query-gpu=…` line (see the query in [`nvidia_sample`]):
+/// one comma-separated record per GPU, memory in **MiB**, clocks in MHz, power in
+/// W, temperature in °C, fan and utilization in %. Column order is fixed by the
+/// query; a driver too old for a trailing column simply omits it, so every field
+/// past the memory triple is read defensively by index.
+pub(crate) fn parse_nvidia_smi(stdout: &str) -> Vec<GpuSample> {
+    const MIB: u64 = 1024 * 1024;
+
+    stdout
+        .lines()
+        .filter_map(|line| {
+            let fields: Vec<&str> = line.split(',').map(str::trim).collect();
+            if fields.len() < 3 {
+                return None;
+            }
+            let vram_total = fields[2].parse::<u64>().ok()? * MIB;
+            let f64_at = |i| nv_field(&fields, i).and_then(|s| s.parse::<f64>().ok());
+            let u64_at = |i| nv_field(&fields, i).and_then(|s| s.parse::<u64>().ok());
+            let u32_at = |i| nv_field(&fields, i).and_then(|s| s.parse::<u32>().ok());
+            Some(GpuSample {
+                name: fields[0].to_string(),
+                driver: "nvidia".to_string(),
+                vram_used: fields[1].parse::<u64>().unwrap_or(0) * MIB,
+                vram_total,
+                shared_used: 0,
+                shared_total: 0,
+                busy_percent: f64_at(3),
+                temp_c: f64_at(4),
+                power_w: f64_at(5),
+                power_cap_w: f64_at(6),
+                sclk_mhz: u64_at(7),
+                mclk_mhz: u64_at(8),
+                fan_percent: f64_at(9),
+                driver_version: nv_field(&fields, 10).map(str::to_string),
+                pcie_gen: u32_at(11),
+                pcie_width: u32_at(12),
+            })
+        })
+        .collect()
+}
+
+// ── Per-process GPU memory (monitor pane only) ───────────────────────────────
+
+/// Per-process GPU memory, cached for [`CACHE_TTL`] so the pane's poll and any
+/// repeat caller share one walk. Deliberately *not* folded into [`snapshot`]: the
+/// work here (all of `/proc`'s `fdinfo`, or a `nvidia-smi` spawn) is heavier than
+/// the whole-device read, and only the monitor pane asks for it.
+static PROC_CACHE: Mutex<Option<(Instant, Vec<GpuProc>)>> = Mutex::new(None);
+
+/// Every process currently holding GPU memory, biggest first. Empty (never an
+/// error) when nothing can be read — a driver that reports no per-process data,
+/// or a non-Linux/no-`nvidia-smi` box — so the UI treats it as "not available".
+pub fn process_snapshot() -> Vec<GpuProc> {
+    if let Some((at, procs)) = PROC_CACHE.lock().ok().and_then(|c| c.clone()) {
+        if at.elapsed() < CACHE_TTL {
+            return procs;
+        }
+    }
+
+    let mut procs = amd_fdinfo_procs();
+    procs.extend(nvidia_proc_sample());
+    procs.sort_by(|a, b| b.mem_bytes.cmp(&a.mem_bytes));
+
+    if let Ok(mut cache) = PROC_CACHE.lock() {
+        *cache = Some((Instant::now(), procs.clone()));
+    }
+    procs
+}
+
+/// NVIDIA's compute clients (`--query-compute-apps`), memory in **MiB**. Only the
+/// compute context is listed — a pure-graphics process won't appear — which is the
+/// portable, driver-agnostic read; the fuller `pmon` needs elevated access.
+fn nvidia_proc_sample() -> Vec<GpuProc> {
+    if let Ok(missing_until) = NVIDIA_MISSING_UNTIL.lock() {
+        if missing_until.is_some_and(|until| Instant::now() < until) {
+            return Vec::new();
+        }
+    }
+
+    let output = crate::paths::command_no_window("nvidia-smi")
+        .args([
+            "--query-compute-apps=pid,process_name,used_memory",
+            "--format=csv,noheader,nounits",
+        ])
+        .output();
+
+    match output {
+        Ok(out) if out.status.success() => parse_nvidia_apps(&String::from_utf8_lossy(&out.stdout)),
+        _ => Vec::new(),
+    }
+}
+
+/// Parse `nvidia-smi --query-compute-apps=pid,process_name,used_memory
+/// --format=csv,noheader,nounits`: one `pid, name, MiB` line per client.
+pub(crate) fn parse_nvidia_apps(stdout: &str) -> Vec<GpuProc> {
+    const MIB: u64 = 1024 * 1024;
+
+    stdout
+        .lines()
+        .filter_map(|line| {
+            let f: Vec<&str> = line.split(',').map(str::trim).collect();
+            if f.len() < 3 {
+                return None;
+            }
+            let pid = f[0].parse::<u32>().ok()?;
+            let mem = nv_field(&f, 2)
+                .and_then(|s| s.parse::<u64>().ok())
+                .unwrap_or(0)
+                * MIB;
+            Some(GpuProc {
+                pid,
+                name: f[1].to_string(),
+                mem_bytes: mem,
+            })
+        })
+        .collect()
+}
+
+/// One amdgpu `fdinfo` file's relevant fields. A process opens the card through
+/// many fds, but the fds of one rendering context share a `drm-client-id`, so the
+/// caller dedups on it to avoid counting the same memory once per fd.
+#[derive(Default)]
+struct FdInfo {
+    driver: String,
+    client_id: Option<u64>,
+    vram_kib: u64,
+    gtt_kib: u64,
+}
+
+/// Parse a `/proc/<pid>/fdinfo/<fd>` file. Returns `None` for a non-DRM fd (a
+/// socket, a plain file) — one with no `drm-driver` line.
+fn parse_fdinfo(text: &str) -> Option<FdInfo> {
+    let mut info = FdInfo::default();
+    for line in text.lines() {
+        if let Some(v) = line.strip_prefix("drm-driver:") {
+            info.driver = v.trim().to_string();
+        } else if let Some(v) = line.strip_prefix("drm-client-id:") {
+            info.client_id = v.trim().parse::<u64>().ok();
+        } else if let Some(v) = line.strip_prefix("drm-memory-vram:") {
+            info.vram_kib = parse_kib(v);
+        } else if let Some(v) = line.strip_prefix("drm-memory-gtt:") {
+            info.gtt_kib = parse_kib(v);
+        }
+    }
+    if info.driver.is_empty() {
+        return None;
+    }
+    Some(info)
+}
+
+/// A `drm-memory-*` value, e.g. `"\t12345 KiB"`, as KiB.
+fn parse_kib(v: &str) -> u64 {
+    v.split_whitespace()
+        .next()
+        .and_then(|n| n.parse::<u64>().ok())
+        .unwrap_or(0)
+}
+
+#[cfg(target_os = "linux")]
+fn amd_fdinfo_procs() -> Vec<GpuProc> {
+    use std::collections::HashSet;
+    use std::fs;
+
+    let Ok(entries) = fs::read_dir("/proc") else {
+        return Vec::new();
+    };
+
+    let mut by_pid: HashMap<u32, u64> = HashMap::new();
+    let mut names: HashMap<u32, String> = HashMap::new();
+    // Dedup a context's memory across its many fds, machine-wide.
+    let mut seen: HashSet<(u32, u64)> = HashSet::new();
+
+    for entry in entries.flatten() {
+        let Some(pid) = entry
+            .file_name()
+            .to_str()
+            .and_then(|n| n.parse::<u32>().ok())
+        else {
+            continue;
+        };
+        let Ok(fds) = fs::read_dir(entry.path().join("fdinfo")) else {
+            continue;
+        };
+
+        let mut pid_bytes: u64 = 0;
+        let mut matched = false;
+        for fd in fds.flatten() {
+            let Ok(text) = fs::read_to_string(fd.path()) else {
+                continue;
+            };
+            let Some(info) = parse_fdinfo(&text) else {
+                continue;
+            };
+            if info.driver != "amdgpu" {
+                continue;
+            }
+            matched = true;
+            // A fd with no client-id (rare on modern amdgpu) dedups per-pid, i.e.
+            // is counted once — undercounting is the safer error than double.
+            if !seen.insert((pid, info.client_id.unwrap_or(u64::MAX))) {
+                continue;
+            }
+            pid_bytes += (info.vram_kib + info.gtt_kib) * 1024;
+        }
+
+        if matched && pid_bytes > 0 {
+            by_pid.insert(pid, pid_bytes);
+            names.insert(pid, proc_comm(pid));
+        }
+    }
+
+    by_pid
+        .into_iter()
+        .map(|(pid, mem_bytes)| GpuProc {
+            pid,
+            name: names.remove(&pid).unwrap_or_default(),
+            mem_bytes,
+        })
+        .collect()
+}
+
+#[cfg(not(target_os = "linux"))]
+fn amd_fdinfo_procs() -> Vec<GpuProc> {
+    Vec::new()
+}
+
+#[cfg(target_os = "linux")]
+fn proc_comm(pid: u32) -> String {
+    std::fs::read_to_string(format!("/proc/{pid}/comm"))
+        .map(|s| s.trim().to_string())
+        .unwrap_or_default()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn files(pairs: &[(&str, &str)]) -> DrmFiles {
+        let get = |key: &str| {
+            pairs
+                .iter()
+                .find(|(k, _)| *k == key)
+                .map(|(_, v)| v.to_string())
+        };
+        DrmFiles {
+            driver: get("driver").unwrap_or_default(),
+            vendor: get("vendor").unwrap_or_default(),
+            device: get("device").unwrap_or_default(),
+            vram_used: get("vram_used"),
+            vram_total: get("vram_total"),
+            gtt_used: get("gtt_used"),
+            gtt_total: get("gtt_total"),
+            busy: get("busy"),
+            temp: get("temp"),
+            power: get("power"),
+            power_cap: get("power_cap"),
+            pwm: get("pwm"),
+            pwm_max: get("pwm_max"),
+            sclk: get("sclk"),
+            mclk: get("mclk"),
+            link_speed: get("link_speed"),
+            link_width: get("link_width"),
+        }
+    }
+
+    #[test]
+    fn amdgpu_apu_reports_both_pools() {
+        let sample = parse_drm_card(
+            1,
+            &files(&[
+                ("driver", "amdgpu"),
+                ("vendor", "0x1002"),
+                ("device", "0x150e"),
+                ("vram_used", "440770560\n"),
+                ("vram_total", "536870912\n"),
+                ("gtt_used", "18052190208\n"),
+                ("gtt_total", "65855619072\n"),
+                ("busy", "95\n"),
+            ]),
+        )
+        .expect("a card exposing mem_info_vram_total is reported");
+
+        assert_eq!(sample.driver, "amdgpu");
+        assert_eq!(sample.vram_used, 440_770_560);
+        assert_eq!(sample.vram_total, 536_870_912);
+        assert_eq!(sample.shared_used, 18_052_190_208);
+        assert_eq!(sample.shared_total, 65_855_619_072);
+        assert_eq!(sample.busy_percent, Some(95.0));
+    }
+
+    #[test]
+    fn card_without_memory_accounting_is_skipped() {
+        // Intel i915 / the NVIDIA blob: a DRM card with no `mem_info_*` at all.
+        // Reporting it would mean showing 0 B of 0 B as if it were a measurement.
+        assert!(parse_drm_card(0, &files(&[("driver", "i915"), ("vendor", "0x8086")])).is_none());
+    }
+
+    #[test]
+    fn drm_busy_absent_is_none_not_zero() {
+        let sample = parse_drm_card(
+            0,
+            &files(&[
+                ("driver", "amdgpu"),
+                ("vram_used", "1024"),
+                ("vram_total", "2048"),
+            ]),
+        )
+        .expect("memory alone is enough to report a card");
+        assert_eq!(sample.busy_percent, None, "unknown utilization is not idle");
+        assert_eq!(sample.shared_total, 0, "a card with no GTT files has none");
+    }
+
+    #[test]
+    fn nvidia_dgpu_has_no_shared_pool() {
+        let gpus = parse_nvidia_smi("NVIDIA GeForce RTX 4090, 1234, 24564, 37\n");
+        assert_eq!(gpus.len(), 1);
+        assert_eq!(gpus[0].name, "NVIDIA GeForce RTX 4090");
+        assert_eq!(gpus[0].driver, "nvidia");
+        assert_eq!(gpus[0].vram_used, 1234 * 1024 * 1024);
+        assert_eq!(gpus[0].vram_total, 24564 * 1024 * 1024);
+        assert_eq!(gpus[0].shared_used, 0);
+        assert_eq!(gpus[0].shared_total, 0);
+        assert_eq!(gpus[0].busy_percent, Some(37.0));
+    }
+
+    #[test]
+    fn nvidia_multi_gpu_and_unavailable_fields() {
+        let gpus = parse_nvidia_smi(
+            "NVIDIA A100, 0, 40960, [N/A]\nNVIDIA A100, 8192, 40960, 100\n\n",
+        );
+        assert_eq!(gpus.len(), 2, "blank lines are not GPUs");
+        assert_eq!(gpus[0].busy_percent, None, "[N/A] utilization is unknown");
+        assert_eq!(gpus[1].busy_percent, Some(100.0));
+    }
+
+    #[test]
+    fn nvidia_garbage_is_ignored() {
+        assert!(parse_nvidia_smi("Failed to initialize NVML: Driver/library version mismatch\n")
+            .is_empty());
+    }
+
+    #[test]
+    fn pci_ids_finds_device_under_its_own_vendor() {
+        let db = "\
+# Comment
+1002  Advanced Micro Devices, Inc. [AMD/ATI]
+\t150e  Strix [Radeon 880M / 890M]
+\t\t1d05 5006  Some Laptop
+\t164e  Raphael
+10de  NVIDIA Corporation
+\t150e  Not our card
+";
+        assert_eq!(
+            pci_ids_lookup(db, "1002", "150e").as_deref(),
+            Some("Strix [Radeon 880M / 890M]")
+        );
+        assert_eq!(
+            pci_ids_lookup(db, "10de", "150e").as_deref(),
+            Some("Not our card"),
+            "a device id is only meaningful under its vendor"
+        );
+        assert_eq!(pci_ids_lookup(db, "1002", "9999"), None);
+        assert_eq!(pci_ids_lookup(db, "8086", "150e"), None);
+    }
+
+    #[test]
+    fn gpu_name_falls_back_to_vendor_and_index() {
+        // No ids at all → cannot consult pci.ids, so the label must still be
+        // recognizable rather than empty.
+        assert_eq!(gpu_name("", "", 1), "GPU 1");
+        assert_eq!(gpu_name("0x10de", "", 0), "NVIDIA GPU 0");
+        assert_eq!(gpu_name("0x8086", "", 2), "Intel GPU 2");
+    }
+
+    #[test]
+    fn amd_sensors_are_converted_to_base_units() {
+        let sample = parse_drm_card(
+            1,
+            &files(&[
+                ("driver", "amdgpu"),
+                ("vram_used", "1024"),
+                ("vram_total", "2048"),
+                ("temp", "58000\n"),        // 58.000 °C
+                ("power", "34560000\n"),    // 34.56 W
+                ("power_cap", "65000000\n"),
+                ("pwm", "128"),             // ~50% of 255
+                ("sclk", "0: 200Mhz\n1: 1000Mhz\n2: 2900Mhz *\n"),
+                ("mclk", "0: 96Mhz *\n1: 1200Mhz\n"),
+                ("link_speed", "16.0 GT/s PCIe"),
+                ("link_width", "16"),
+            ]),
+        )
+        .expect("a card exposing vram_total is reported");
+
+        assert_eq!(sample.temp_c, Some(58.0));
+        assert_eq!(sample.power_w, Some(34.56));
+        assert_eq!(sample.power_cap_w, Some(65.0));
+        assert_eq!(sample.sclk_mhz, Some(2900), "the DPM state flagged * is active");
+        assert_eq!(sample.mclk_mhz, Some(96));
+        assert_eq!(sample.pcie_gen, Some(4), "16 GT/s is PCIe 4.0");
+        assert_eq!(sample.pcie_width, Some(16));
+        assert_eq!(sample.driver_version, None);
+        let fan = sample.fan_percent.expect("pwm1 gives a fan percent");
+        assert!((fan - 50.2).abs() < 0.2, "128/255 ≈ 50%, got {fan}");
+    }
+
+    #[test]
+    fn amd_missing_sensors_stay_unknown_not_zero() {
+        // A card with memory but no hwmon/clock/pcie files: every sensor is None,
+        // never a fabricated 0 that would read as "0 °C / idle fan".
+        let sample = parse_drm_card(
+            0,
+            &files(&[("driver", "amdgpu"), ("vram_used", "1"), ("vram_total", "2")]),
+        )
+        .unwrap();
+        assert_eq!(sample.temp_c, None);
+        assert_eq!(sample.power_w, None);
+        assert_eq!(sample.sclk_mhz, None);
+        assert_eq!(sample.fan_percent, None);
+        assert_eq!(sample.pcie_gen, None);
+    }
+
+    #[test]
+    fn pcie_gen_maps_transfer_rate_to_generation() {
+        let g = |s: &str| pcie_gen_from_speed(Some(&s.to_string()));
+        assert_eq!(g("2.5 GT/s PCIe"), Some(1));
+        assert_eq!(g("5.0 GT/s PCIe"), Some(2));
+        assert_eq!(g("8.0 GT/s PCIe"), Some(3));
+        assert_eq!(g("16.0 GT/s PCIe"), Some(4));
+        assert_eq!(g("32.0 GT/s PCIe"), Some(5));
+        assert_eq!(pcie_gen_from_speed(None), None);
+    }
+
+    #[test]
+    fn nvidia_smi_reads_the_full_sensor_row() {
+        let gpus = parse_nvidia_smi(
+            "NVIDIA GeForce RTX 4090, 1234, 24564, 37, 61, 210.5, 450, 2520, 10501, 41, 550.107.02, 4, 16\n",
+        );
+        assert_eq!(gpus.len(), 1);
+        let g = &gpus[0];
+        assert_eq!(g.busy_percent, Some(37.0));
+        assert_eq!(g.temp_c, Some(61.0));
+        assert_eq!(g.power_w, Some(210.5));
+        assert_eq!(g.power_cap_w, Some(450.0));
+        assert_eq!(g.sclk_mhz, Some(2520));
+        assert_eq!(g.mclk_mhz, Some(10501));
+        assert_eq!(g.fan_percent, Some(41.0));
+        assert_eq!(g.driver_version.as_deref(), Some("550.107.02"));
+        assert_eq!(g.pcie_gen, Some(4));
+        assert_eq!(g.pcie_width, Some(16));
+    }
+
+    #[test]
+    fn nvidia_smi_na_sensors_are_unknown_and_short_rows_still_parse() {
+        // A laptop dGPU in power-saving answers [N/A] for power/clocks; an older
+        // driver simply omits the trailing pcie columns.
+        let gpus = parse_nvidia_smi("NVIDIA A2000, 512, 8192, [N/A], 45, [N/A], [N/A]\n");
+        assert_eq!(gpus.len(), 1);
+        let g = &gpus[0];
+        assert_eq!(g.vram_total, 8192 * 1024 * 1024);
+        assert_eq!(g.busy_percent, None);
+        assert_eq!(g.temp_c, Some(45.0));
+        assert_eq!(g.power_w, None);
+        assert_eq!(g.sclk_mhz, None, "an absent column is unknown, not zero");
+        assert_eq!(g.pcie_gen, None);
+    }
+
+    #[test]
+    fn nvidia_compute_apps_parse_to_bytes() {
+        let procs = parse_nvidia_apps("1234, python, 512\n9, ollama, 4096\n\n");
+        assert_eq!(procs.len(), 2, "blank lines are not processes");
+        assert_eq!(procs[0].pid, 1234);
+        assert_eq!(procs[0].name, "python");
+        assert_eq!(procs[0].mem_bytes, 512 * 1024 * 1024);
+        assert_eq!(procs[1].mem_bytes, 4096 * 1024 * 1024);
+    }
+
+    #[test]
+    fn fdinfo_reads_amdgpu_memory_and_client_id() {
+        let info = parse_fdinfo(
+            "pos:\t0\ndrm-driver:\tamdgpu\ndrm-client-id:\t42\n\
+drm-memory-vram:\t131072 KiB\ndrm-memory-gtt:\t8192 KiB\n",
+        )
+        .expect("a DRM fd is recognized");
+        assert_eq!(info.driver, "amdgpu");
+        assert_eq!(info.client_id, Some(42));
+        assert_eq!(info.vram_kib, 131072);
+        assert_eq!(info.gtt_kib, 8192);
+    }
+
+    #[test]
+    fn fdinfo_ignores_non_drm_fds() {
+        // A socket / regular file has no drm-driver line and must not be counted.
+        assert!(parse_fdinfo("pos:\t0\nflags:\t02\nmnt_id:\t9\n").is_none());
+    }
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 75c2672..a0809ff 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1,10 +1,11 @@
 pub mod commands;
+pub mod duscan;
+pub mod gpustat;
 pub mod paths;
 pub mod platform;
 pub mod schema;
 pub mod services;
 pub mod storage;
-#[cfg(target_os = "linux")]
 pub mod sysstat;
 pub mod terminal;
 
@@ -18,6 +19,12 @@ use terminal::PtyRegistry;
 #[cfg(unix)]
 static CRASH_LOG_FD: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(-1);
 
+/// Raw file HANDLE kept open so the SEH crash filter can write to it — the
+/// Windows analog of `CRASH_LOG_FD`. `0` (null, never a valid file handle)
+/// means "not installed".
+#[cfg(windows)]
+static CRASH_LOG_HANDLE: std::sync::atomic::AtomicIsize = std::sync::atomic::AtomicIsize::new(0);
+
 /// Install a panic hook + OS signal handlers that append to crash.log.
 fn install_crash_logger() {
     let state_dir = storage::state_dir();
@@ -37,6 +44,10 @@ fn install_crash_logger() {
     #[cfg(unix)]
     // SAFETY: called once at startup before any threads that touch signals.
     unsafe { install_signal_handlers(&path) };
+
+    #[cfg(windows)]
+    // SAFETY: called once at startup before any thread can crash.
+    unsafe { install_seh_filter(&path) };
 }
 
 /// Append one entry to crash.log in the state dir.
@@ -120,6 +131,110 @@ fn sig_write(fd: i32, buf: &[u8]) {
     unsafe { libc::write(fd, buf.as_ptr() as *const libc::c_void, buf.len()) };
 }
 
+/// Register a Windows SEH unhandled-exception filter that appends a
+/// `=== CRASH: … ===` line to crash.log — the native-fault analog of the Unix
+/// signal handlers above (a Rust panic is already covered by the panic hook;
+/// this catches access violations and friends that never unwind).
+#[cfg(windows)]
+unsafe fn install_seh_filter(path: &std::path::Path) {
+    use std::os::windows::io::IntoRawHandle;
+    use windows::Win32::System::Diagnostics::Debug::SetUnhandledExceptionFilter;
+    if let Ok(file) = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)
+    {
+        CRASH_LOG_HANDLE.store(
+            file.into_raw_handle() as isize,
+            std::sync::atomic::Ordering::Relaxed,
+        );
+    }
+    // SAFETY: `crash_filter` matches the required `extern "system"` signature
+    // and only performs handle writes on pre-opened state.
+    unsafe {
+        SetUnhandledExceptionFilter(Some(crash_filter));
+    }
+}
+
+/// SEH top-level filter: write one crash line to the pre-opened handle, then
+/// return `EXCEPTION_CONTINUE_SEARCH` (0) so default termination (WER, exit
+/// code) proceeds — the moral equivalent of `SA_RESETHAND` on Unix. Runs on
+/// the crashing thread with a possibly corrupt heap, so it formats into a
+/// stack buffer via the allocation-free `format_crash_line`.
+#[cfg(windows)]
+unsafe extern "system" fn crash_filter(
+    info: *const windows::Win32::System::Diagnostics::Debug::EXCEPTION_POINTERS,
+) -> i32 {
+    use windows::Win32::Foundation::HANDLE;
+    use windows::Win32::Storage::FileSystem::WriteFile;
+
+    // SAFETY: the OS hands us a valid EXCEPTION_POINTERS for the duration of
+    // the filter call; both pointers are null-checked before dereference.
+    let (code, addr) = unsafe {
+        if info.is_null() || (*info).ExceptionRecord.is_null() {
+            (0u32, 0usize)
+        } else {
+            let rec = &*(*info).ExceptionRecord;
+            (rec.ExceptionCode.0 as u32, rec.ExceptionAddress as usize)
+        }
+    };
+    let handle = CRASH_LOG_HANDLE.load(std::sync::atomic::Ordering::Relaxed);
+    if handle != 0 {
+        let mut buf = [0u8; 64];
+        let len = format_crash_line(code, addr, &mut buf);
+        // SAFETY: the handle was opened at install time and is kept open for
+        // the process lifetime; WriteFile on a file handle is safe here.
+        unsafe {
+            let _ = WriteFile(
+                HANDLE(handle as *mut core::ffi::c_void),
+                Some(&buf[..len]),
+                None,
+                None,
+            );
+        }
+    }
+    0 // EXCEPTION_CONTINUE_SEARCH
+}
+
+/// Format `=== CRASH: code=0x… addr=0x… ===\n` into `buf` without allocating
+/// (an SEH filter runs on a crashing thread whose heap may be corrupt) and
+/// return the byte length. Truncates silently if `buf` is too small. Compiled
+/// on every OS so its unit tests run on Linux; only the Windows crash filter
+/// consumes it at runtime.
+pub fn format_crash_line(code: u32, addr: usize, buf: &mut [u8]) -> usize {
+    fn push(buf: &mut [u8], pos: usize, bytes: &[u8]) -> usize {
+        let n = bytes.len().min(buf.len().saturating_sub(pos));
+        buf[pos..pos + n].copy_from_slice(&bytes[..n]);
+        pos + n
+    }
+    fn push_hex(buf: &mut [u8], pos: usize, mut v: u64, min_digits: usize) -> usize {
+        let mut digits = [0u8; 16];
+        let mut i = 0;
+        loop {
+            let d = (v & 0xF) as u8;
+            digits[i] = if d < 10 { b'0' + d } else { b'A' + (d - 10) };
+            i += 1;
+            v >>= 4;
+            if (v == 0 && i >= min_digits) || i == digits.len() {
+                break;
+            }
+        }
+        let mut pos = pos;
+        while i > 0 {
+            i -= 1;
+            pos = push(buf, pos, &digits[i..i + 1]);
+        }
+        pos
+    }
+    let mut pos = 0;
+    pos = push(buf, pos, b"=== CRASH: code=0x");
+    pos = push_hex(buf, pos, code as u64, 8);
+    pos = push(buf, pos, b" addr=0x");
+    pos = push_hex(buf, pos, addr as u64, 1);
+    pos = push(buf, pos, b" ===\n");
+    pos
+}
+
 /// Webview renderer crashes (e.g. WebKitWebProcess SIGBUS) happen in a child
 /// process, so the signal handlers above never fire and the window keeps
 /// showing its last frame — an apparent freeze. Hook WebKit's
@@ -157,6 +272,144 @@ fn install_webview_crash_reporter(app: &tauri::App) {
     }
 }
 
+/// WebKitGTK draws the scrollbars INSIDE the web content with the native GTK
+/// theme, not the page's CSS — the standard `scrollbar-color` property is ignored
+/// on this WebKitGTK build (confirmed on 2.50.x). On a light GTK system theme
+/// that leaves a white trough + grey slider regardless of Eldrun's in-app theme.
+///
+/// WebKit's scrollbar renderer queries the default screen's GTK style providers,
+/// so an APPLICATION-priority `GtkCssProvider` that recolors the `scrollbar`
+/// nodes is picked up for the in-content bars. We apply a theme-agnostic look —
+/// a translucent-grey trough (subtle on both light and dark surfaces) with a
+/// solid accent-blue slider — so it reads as "Eldrun blue" without having to
+/// follow the live in-app theme. Best-effort and behind an env opt-out: any
+/// failure simply leaves the native scrollbar untouched.
+#[cfg(target_os = "linux")]
+fn install_scrollbar_theme() {
+    use gtk::prelude::*;
+
+    if std::env::var_os("ELDRUN_NO_SCROLLBAR_THEME").is_some() {
+        return;
+    }
+
+    // GTK3 scrollbar node structure: `scrollbar > contents > trough > slider`.
+    // Recolor the trough + slider; `min-width/height` keep the thin overlay bar
+    // wide enough to see. Colors mirror the frontend's fancy_dark accent so the
+    // native bar matches the webview's themed bars on every surface.
+    const CSS: &str = "
+        scrollbar trough {
+            background-color: rgba(127, 127, 127, 0.14);
+            border-radius: 8px;
+            border: none;
+        }
+        scrollbar slider {
+            background-color: #36c5f0;
+            border: 2px solid transparent;
+            border-radius: 8px;
+            min-width: 8px;
+            min-height: 8px;
+        }
+        scrollbar slider:hover { background-color: #5edcff; }
+        scrollbar slider:active { background-color: #1ca7d8; }
+    ";
+
+    let provider = gtk::CssProvider::new();
+    if let Err(e) = provider.load_from_data(CSS.as_bytes()) {
+        eprintln!("scrollbar theme: load css: {e}");
+        return;
+    }
+    match gtk::gdk::Screen::default() {
+        Some(screen) => gtk::StyleContext::add_provider_for_screen(
+            &screen,
+            &provider,
+            gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+        ),
+        None => eprintln!("scrollbar theme: no default GDK screen"),
+    }
+}
+
+/// Reopen the main window on the monitor and at the geometry it was last closed
+/// at, then show it. The counterpart of the debounced save in `AppShell.tsx`.
+///
+/// The window is declared `"visible": false` in `tauri.conf.json` purely so this
+/// can run before the first frame: it opens `maximized`, so on a multi-monitor
+/// desk the WM maps it on the primary monitor and a restore onto the *other*
+/// monitor would be a visible jump. Hidden → placed → shown, and the user only
+/// ever sees the final position. The cost is that `win.show()` below is now
+/// load-bearing; every call in here is best-effort (`let _ =`) so no failure can
+/// skip it.
+///
+/// Geometry rules (which monitor, what if it was unplugged) live in
+/// `services::window_state::resolve_startup_geometry`, which is pure and tested.
+fn restore_main_window(app: &tauri::App) {
+    use tauri::Manager;
+
+    let Some(win) = app.get_webview_window("main") else {
+        return; // No main window: nothing to place and nothing to show.
+    };
+
+    // Guard against a stray fullscreen state surviving into this launch. On Linux
+    // this is not cosmetic: a window the WM has put into fullscreen keeps
+    // `_NET_WM_STATE_FULLSCREEN`, which under KWin wins over MAXIMIZED and makes
+    // the window UNMOVABLE — KWin refuses the `_NET_WM_MOVERESIZE` that
+    // `startDragging` sends, so the header title-bar drag silently no-ops. A
+    // maximized window fills the monitor identically yet stays draggable and
+    // edge-snappable, so that is what Eldrun uses instead. macOS is excluded: real
+    // fullscreen (its own Space) is the platform-expected behaviour there, and
+    // `AppShell.tsx` opts into it explicitly after load.
+    #[cfg(not(target_os = "macos"))]
+    let _ = win.set_fullscreen(false);
+
+    let saved = storage::read_json::<schema::Settings>(&storage::state_dir().join("settings.json"))
+        .ok()
+        .and_then(|s| s.window_state);
+    let monitors: Vec<services::window_state::MonitorRect> = win
+        .available_monitors()
+        .unwrap_or_default()
+        .iter()
+        .map(|m| services::window_state::MonitorRect {
+            x: m.position().x,
+            y: m.position().y,
+            w: m.size().width,
+            h: m.size().height,
+        })
+        .collect();
+    if saved.is_some() && monitors.is_empty() {
+        // We have a rect to restore but nothing to validate it against, so it is
+        // dropped and the window opens at the configured default. Not fatal, but
+        // it silently defeats the whole feature — say so rather than leave the
+        // user wondering why their window never comes back where they left it.
+        eprintln!("window_state: no monitors reported at startup; ignoring the saved geometry");
+    }
+
+    match services::window_state::resolve_startup_geometry(saved, &monitors) {
+        Some(g) => {
+            // Unmaximize FIRST, even when we are about to re-maximize immediately:
+            // the window is mapped maximized, and assigning a size/position while
+            // it is in that state is what gives the WM a genuine restore geometry
+            // to fall back to. Without it the WM's only record of a "normal" size
+            // is the full monitor, so the maximize button appears to do nothing —
+            // the exact bug `WindowControls.tsx` has to work around today.
+            let _ = win.unmaximize();
+            let _ = win.set_size(tauri::PhysicalSize::new(g.w, g.h));
+            let _ = win.set_position(tauri::PhysicalPosition::new(g.x, g.y));
+            if g.maximized {
+                let _ = win.maximize();
+            }
+        }
+        None => {
+            // Fresh install, or a saved rect no connected monitor can host (the
+            // undocked-external-display case). Fall back to the configured default
+            // and re-assert it, in case the WM dropped the `maximized` hint at map
+            // time.
+            #[cfg(not(target_os = "macos"))]
+            let _ = win.maximize();
+        }
+    }
+
+    let _ = win.show();
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     // WebKit's DMA-BUF renderer SIGBUSes inside Mesa on some driver stacks
@@ -173,15 +426,53 @@ pub fn run() {
     let win_registry: WindowRegistryState = Arc::new(Mutex::new(WindowRegistry::default()));
     let workspace: WorkspaceStateArc = Arc::new(Mutex::new(WorkspaceState::new()));
     let fs_watch = commands::fs_watch::new_state();
+    // Pooled SSH/SFTP connections, one per active remote project (Phase 0 of the
+    // mount-free remote model). Opened on activation, torn down at exit below.
+    let remote_pool = services::remote::new_pool();
+    // Single-writer cache of per-project sync manifests (SSH-sync Phase 1). Guards
+    // every `sync.json` mutation so concurrent syncs/saves can't clobber it (G7).
+    let sync_manifest = services::remote_sync::new_manifest_state();
+    // Registry of per-project auto-sync tasks (started on remote_connect, stopped
+    // on remote_disconnect / app exit). See `services::sync_auto`.
+    let auto_sync = services::sync_auto::new_state();
+    // Registry of per-project git lockstep tasks (.git watcher + host poll; started
+    // on remote_connect when enabled, stopped on disconnect / exit). See
+    // `services::git_peer` (TODO #28n).
+    let git_peer = services::git_peer::new_registry();
+    // Registry of per-(project,worker) code-sync fan-outs (multi-host remote,
+    // `docs/multi_host_remote_plan.md`). Kicked on a worker connect / commit /
+    // manual "Push code to machines". See `services::worker_sync`.
+    let worker_sync = services::worker_sync::new_state();
+    // Cancel flags for in-flight disk-usage scans, one per scanning pane. See
+    // `commands::disk_usage`.
+    let disk_scans = commands::disk_usage::new_state();
+    // Recursive file-churn watcher on the active project + the counters it has
+    // seen since the last flush (see `services::usage_stats`).
+    let usage_watch = services::usage_stats::new_state();
 
     tauri::Builder::default()
         .manage(pty_registry)
         .manage(win_registry)
         .manage(workspace)
         .manage(fs_watch)
+        .manage(remote_pool)
+        // Carries PDF pages between two Eldrun windows: they are separate WebViews
+        // with separate JS heaps, so the bytes must cross the process boundary.
+        .manage(commands::pdf_clip::PdfClipboard::default())
+        .manage(sync_manifest)
+        .manage(auto_sync)
+        .manage(git_peer)
+        .manage(worker_sync)
+        .manage(disk_scans)
+        .manage(usage_watch.clone())
         .setup(|_app| {
             #[cfg(target_os = "linux")]
             install_webview_crash_reporter(_app);
+            // Recolor WebKitGTK's native in-content scrollbars (page CSS can't —
+            // `scrollbar-color` is ignored on this build). Runs on the GTK main
+            // thread, which `setup` is, after GTK is initialized.
+            #[cfg(target_os = "linux")]
+            install_scrollbar_theme();
             // Record the MAIN window's X11 id so the workspace backend can
             // STRUCTURALLY refuse to ever park it (#42 detached-subwindow
             // parkable override). Resolved off-thread so a slow compositor never
@@ -197,17 +488,98 @@ pub fn run() {
                     }
                 });
             }
+            // Windows: the HWND is known synchronously from Tauri, so no off-thread
+            // title scan is needed. Binding the main-window id arms the structural
+            // guard so the override can never park the main window (defense-in-depth
+            // on top of the self_pid protection that already shields it).
+            #[cfg(target_os = "windows")]
+            {
+                use tauri::Manager;
+                let workspace = _app.state::<WorkspaceStateArc>().inner().clone();
+                if let Some(hwnd) = _app
+                    .get_webview_window("main")
+                    .and_then(|w| w.hwnd().ok())
+                {
+                    let id = hwnd.0 as usize as u64;
+                    workspace.lock().unwrap().backend.set_main_window_id(id);
+                    // Add the WS_MAXIMIZEBOX/WS_THICKFRAME styles a borderless wry
+                    // window lacks, so dragging the header against a screen edge
+                    // triggers the native Aero Snap (top → maximize, sides → half).
+                    platform::windows::enable_aero_snap(id);
+                }
+            }
+            // macOS: bind the MAIN window's CGWindowID (== NSWindow.windowNumber)
+            // for the structural parkable guard, like the Windows arm above.
+            // `ns_window()` must be used on the main thread, which setup is.
+            #[cfg(target_os = "macos")]
+            {
+                use tauri::Manager;
+                let workspace = _app.state::<WorkspaceStateArc>().inner().clone();
+                if let Some(id) = _app
+                    .get_webview_window("main")
+                    .and_then(|w| w.ns_window().ok())
+                    .and_then(|ns| platform::macos::ns_window_id(ns as *mut std::ffi::c_void))
+                {
+                    workspace.lock().unwrap().backend.set_main_window_id(id);
+                }
+            }
             // Install the global Claude SessionStart hook so Eldrun can follow a
             // tab's live session id across `/clear` (see services::agent_session).
             if let Err(e) = services::agent_session::install_session_start_hook() {
                 eprintln!("agent_session: install SessionStart hook: {e}");
             }
+            // Bring legacy `projects.json` entries (written by older Eldrun
+            // versions) up to the current shape and refresh their scaffold, then
+            // persist. Off-thread so file I/O never blocks startup; additive and
+            // idempotent, so a race with the frontend's first load is benign.
+            std::thread::spawn(commands::projects::migrate_legacy_projects);
+            // Remove project containers a previous run left behind (a crash
+            // skips the exit teardown) and the staged config copies. Off-thread:
+            // docker may be slow or absent, and neither may block startup.
+            std::thread::spawn(services::sandbox::sweep_orphans);
+            // Unlink ssh ControlMaster sockets a previous run left behind. The
+            // master is killed by signal rather than `ssh -O exit`, so the socket
+            // outlives it — and a stale one makes OpenSSH disable multiplexing for
+            // that target, quietly turning every later channel into its own login.
+            // Off-thread: one cheap local `ssh -O check` per file.
+            std::thread::spawn(services::ssh_exec::sweep_stale_control_sockets);
+            // Re-adopt OpenVPN tunnels a previous run left running (a crash, an OOM
+            // kill, a refused quit-time prompt): the daemon runs as root and outlives
+            // the app, still rerouting the machine, but the live-tunnel registries are
+            // in-memory and start empty — so without this the VPN lamp reads grey while
+            // the machines are in fact reachable through the still-up tunnel. Off-thread
+            // (a few pidfile stats); additive and idempotent, so racing the frontend's
+            // first `openvpn_active` refresh is benign.
+            #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+            std::thread::spawn(services::openvpn::adopt_orphans);
+            // Start the background per-project SSH-link traffic sampler so each
+            // remote project's daily/monthly/overall usage accrues even when its
+            // Network Traffic tab is closed (see services::net_usage). No-op on
+            // non-Linux.
+            {
+                use tauri::Manager;
+                let pool = _app
+                    .state::<services::remote::RemotePoolState>()
+                    .inner()
+                    .clone();
+                services::net_usage::start(pool);
+            }
+            // Periodically fold the file-churn the watcher has seen into
+            // `usage_stats.json` (see services::usage_stats). The watcher itself is
+            // attached on project activation, via `usage_watch_project`.
+            services::usage_stats::start(usage_watch);
+            // Place the main window where it was last closed and MAKE IT VISIBLE.
+            // Must stay last in `setup`: the window is created hidden (see
+            // `restore_main_window`), so anything that returns early before this
+            // leaves Eldrun running with no window on screen.
+            restore_main_window(_app);
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
             // Settings
             commands::settings::get_settings,
             commands::settings::save_settings,
+            commands::settings::save_window_state,
             commands::default_apps::get_default_apps,
             commands::default_apps::save_default_apps,
             // Projects
@@ -216,14 +588,63 @@ pub fn run() {
             commands::projects::load_project,
             commands::projects::save_project,
             commands::projects::set_project_description,
+            commands::projects::set_project_name,
+            commands::projects::set_project_sandbox,
+            commands::projects::set_project_sandbox_spec,
+            commands::projects::sandbox_preflight,
+            commands::python::python_interpreters,
+            commands::python::python_interpreter_for,
+            commands::python::set_project_python,
+            commands::slurm::slurm_available,
+            commands::slurm::slurm_submit,
+            commands::slurm::slurm_queue,
+            commands::slurm::slurm_job_out,
+            commands::slurm::slurm_cancel,
+            commands::hpc_ws::hpc_ws_available,
+            commands::hpc_ws::hpc_ws_list,
+            commands::hpc_ws::hpc_ws_allocate,
+            commands::hpc_ws::hpc_ws_extend,
+            commands::hpc_ws::hpc_ws_release,
+            commands::hpc_ws::hpc_ws_link,
+            commands::hpc_ws::hpc_ws_anchor,
+            commands::hpc_ws::hpc_scratch_candidates,
+            commands::hpc_ws::hpc_ws_pull_logs,
+            commands::hpc_ws::hpc_ws_move_root,
+            commands::hpc_ws::set_project_hpc,
+            commands::projects::set_project_openvpn,
+            commands::projects::set_project_auto_connect,
+            commands::projects::set_project_persist_sessions,
+            commands::projects::set_project_remote_label,
+            commands::projects::set_project_remote_user,
+            commands::projects::add_compute_host,
+            commands::projects::remove_compute_host,
+            commands::projects::patch_compute_host,
+            commands::projects::set_project_run_host,
+            commands::projects::set_project_categories,
+            commands::projects::set_project_git_disabled,
             commands::projects::save_tab_layout,
             commands::projects::root_work_dir,
             commands::projects::projects_root_dir,
+            commands::projects::remote_mirror_root_dir,
             commands::projects::open_in_file_manager,
+            commands::projects::remote_mirror_status,
+            commands::projects::set_remote_mirror_dir,
+            commands::projects::move_remote_mirror,
             commands::projects::create_project,
             commands::projects::preview_project_scaffold,
+            commands::projects::project_scaffold_missing,
+            commands::projects::repair_project_scaffold,
+            commands::projects::repair_all_project_scaffolds,
             commands::projects::import_project,
+            commands::projects::extend_project_to_remote,
+            commands::projects::detach_project_from_remote,
             commands::projects::get_time_today,
+            commands::projects::archive_project,
+            commands::projects::list_archived_projects,
+            commands::projects::restore_archived_project,
+            commands::projects::delete_archived_project,
+            commands::projects::archived_mirror_unsynced,
+            commands::projects::clear_archive,
             // Project boxes (meta-project grouping)
             commands::boxes::get_boxes,
             commands::boxes::save_boxes,
@@ -234,30 +655,144 @@ pub fn run() {
             commands::boxes::ensure_box_folder,
             commands::boxes::refresh_box_agent_docs,
             commands::boxes::set_box_relations,
+            // Native calendar (local event store)
+            commands::calendar::calendar_load,
+            commands::calendar::calendar_save,
+            commands::calendar::create_event,
+            commands::calendar::update_event,
+            commands::calendar::delete_event,
+            commands::calendar::create_task,
+            commands::calendar::update_task,
+            commands::calendar::delete_task,
+            commands::calendar::create_calendar,
+            commands::calendar::update_calendar,
+            commands::calendar::delete_calendar,
+            commands::calendar::calendar_read_ics,
+            commands::calendar::calendar_write_ics,
             // SSH / remote projects
             commands::ssh::ssh_connect,
+            commands::ssh::ssh_probe,
+            commands::ssh::remote_has_saved_password,
+            commands::ssh::remote_saved_password_state,
+            commands::ssh::remote_forget_password,
+            commands::ssh::remote_kill_all_jobs,
+            commands::ssh::ssh_close_master,
+            commands::ssh::remote_login_command,
             commands::ssh::ssh_default_dir,
             commands::ssh::ssh_list_dir,
-            commands::ssh::ensure_project_mounted,
+            commands::ssh::ssh_mkdir,
+            // Pooled SSH/SFTP connection lifecycle (mount-free remote, Phase 0)
+            commands::remote::remote_connect,
+            commands::remote::remote_disconnect,
+            commands::remote::remote_disconnect_all_hosts,
+            commands::remote::remote_connected_ids,
+            commands::remote::remote_connected_targets,
+            commands::remote::worker_sync_now,
+            commands::remote::worker_outputs_preview,
+            commands::remote::worker_pull_outputs,
+            commands::remote::remote_upload_file,
+            commands::remote::remote_usage_check,
+            // Global machines (cross-project compute host registry)
+            commands::global_machines::global_machines_list,
+            commands::global_machines::global_machine_add,
+            commands::global_machines::global_machine_update,
+            commands::global_machines::global_machine_set_auto_connect,
+            commands::global_machines::global_machine_remove,
+            commands::global_machines::global_machine_reorder,
+            commands::global_machines::global_machine_monitor_snapshot,
+            commands::global_machines::global_machine_usage_check,
+            commands::global_machines::global_machine_tmux_list,
+            commands::global_machines::global_machines_export,
+            commands::global_machines::global_machines_import_read,
+            commands::remote::remote_tmux_list,
+            commands::remote::remote_tmux_kill,
+            commands::remote::remote_tmux_rename,
+            // Read-only local/remote host + SSH transport monitoring.
+            commands::network::network_host_snapshot,
+            commands::network::network_ssh_link_snapshot,
+            commands::net_usage::get_net_usage,
+            // Usage counters + daily recap.
+            commands::usage_stats::usage_bump,
+            commands::usage_stats::usage_summary,
+            commands::usage_stats::usage_watch_project,
+            commands::usage_stats::usage_git_stats,
+            commands::monitor::system_monitor_snapshot,
+            commands::monitor::gpu_memory_snapshot,
+            commands::monitor::gpu_process_snapshot,
+            // AC-vs-battery detection for Energy Saver mode.
+            commands::power::get_power_state,
+            // SSH-sync (Phase 1): selective local↔remote mirror sync.
+            commands::sync::sync_pull,
+            commands::sync::sync_whole_project,
+            commands::sync::sync_now,
+            commands::sync::sync_push,
+            commands::sync::sync_mark_selected,
+            commands::sync::sync_set_auto,
+            commands::sync::sync_auto_preview,
+            commands::sync::sync_big_folders,
+            commands::sync::sync_set_excluded,
+            commands::sync::sync_status,
+            commands::sync::sync_file_meta,
+            commands::sync::sync_resolve_if_identical,
+            commands::sync::sync_diff,
             commands::ssh::ssh_tooling_status,
+            commands::ssh::ssh_host_key_preview,
+            commands::ssh::ssh_trust_host_key,
+            commands::ssh::ssh_list_addresses,
+            commands::ssh::ssh_remember_address,
+            commands::ssh::remote_list_paths,
+            commands::ssh::remote_remember_path,
+            commands::ssh::remote_list_default_paths,
+            commands::ssh::remote_get_default_path,
+            commands::ssh::remote_set_default_path,
+            commands::ssh::open_external_url,
             // OpenVPN tunnels for VPN-gated remote projects
             commands::openvpn::openvpn_connect,
+            commands::openvpn::openvpn_auth_needs,
+            commands::openvpn::vpn_has_saved_password,
+            commands::openvpn::vpn_can_connect_silently,
+            commands::openvpn::vpn_forget_password,
+            commands::openvpn::openvpn_login_command,
             commands::openvpn::openvpn_disconnect,
+            commands::openvpn::openvpn_disconnect_all_on_quit,
             commands::openvpn::openvpn_status,
+            commands::openvpn::openvpn_active,
             commands::openvpn::openvpn_store_config,
-            // GitHub publishing
-            commands::github::github_publish,
+            commands::openvpn::openvpn_list_configs,
+            commands::openvpn::openvpn_remove_config,
+            // The credential store itself (locked vs readable), shared by SSH + VPN
+            commands::credentials::keyring_state,
+            commands::credentials::keyring_unlock,
+            commands::credentials::credential_paste_to_pty,
+            // Git hosting (GitHub / GitLab) publishing
+            commands::git_publish::publish_project,
+            commands::git_publish::unpublish_project,
+            commands::git_publish::set_project_visibility,
+            commands::git_publish::switch_project_provider,
+            // Fork + clone (the import dialog's "fork a repository" source)
+            commands::git_fork::git_fork_clone,
+            commands::git_fork::provider_cli_available,
+            commands::git_hosting::get_project_git_hosting,
+            commands::git_hosting::set_project_git_hosting,
             // Timer flush + activity
             commands::timer::timer_flush_app,
             commands::timer::timer_flush_project,
             commands::timer::get_project_activity,
+            commands::timer::get_time_activity_all,
             // File tree + file I/O (commands::fs)
             commands::fs::list_dir,
+            commands::fs::list_recent_downloads,
+            commands::fs::dir_size,
+            commands::fs::dir_size_breakdown,
+            commands::fs::list_dirs,
             commands::fs::list_project_endings,
             commands::fs::list_project_paths,
             commands::fs::rename_path,
             commands::fs::copy_path,
             commands::fs::move_path,
+            commands::fs::import_external_file,
+            commands::fs::project_path_exists,
+            commands::fs::extract_archive,
             commands::clipboard::clipboard_has_image,
             commands::clipboard::save_clipboard_image,
             commands::screenshot::capture_project_screenshot,
@@ -269,12 +804,23 @@ pub fn run() {
             commands::fs::update_gitignore_rule,
             commands::fs::create_dir,
             commands::fs::detect_mime,
+            commands::fs::file_source,
             commands::fs::read_file_text,
             commands::fs::write_file_text,
             commands::fs::read_file_bytes,
+            commands::fs::write_file_bytes,
+            commands::pdf_clip::pdf_clip_set,
+            commands::pdf_clip::pdf_clip_get,
             commands::fs::file_mtime,
+            commands::format::format_source,
+            commands::format::formatter_available,
+            commands::format::check_syntax,
             commands::fs_watch::watch_dir,
             commands::fs_watch::unwatch_dir,
+            // Disk usage analyzer (commands::disk_usage)
+            commands::disk_usage::disk_usage_scan,
+            commands::disk_usage::disk_usage_cancel,
+            commands::disk_usage::disk_usage_devices,
             // LaTeX view / compile (gated on a TeX engine being on PATH)
             commands::tex::tex_capability,
             commands::tex::compile_tex,
@@ -286,6 +832,9 @@ pub fn run() {
             commands::terminal::pty_write,
             commands::terminal::pty_resize,
             commands::terminal::pty_kill,
+            commands::terminal::local_tmux_list,
+            commands::terminal::local_tmux_kill,
+            commands::terminal::local_tmux_rename,
             commands::terminal::project_cpu_percent,
             // External apps / window tracking
             commands::apps::launch_app,
@@ -296,6 +845,9 @@ pub fn run() {
             commands::apps::check_pid_alive,
             commands::apps::restore_open_apps,
             commands::apps::run_script_detached,
+            commands::apps::drag_preview_icon,
+            commands::apps::start_file_drag,
+            commands::apps::cancel_file_drag,
             commands::apps::embed_capability,
             commands::apps::list_installed_apps,
             // Workspace / network
@@ -308,6 +860,10 @@ pub fn run() {
             // Detached subwindows (#42)
             commands::subwindow::detach_subwindow,
             commands::subwindow::attach_subwindow,
+            commands::subwindow::detached_window_frontmost,
+            // The deck presenter's audience window (M#90)
+            commands::presenter::open_presenter_window,
+            commands::presenter::close_presenter_window,
             commands::workspace::workspace_name,
             commands::workspace::network_conn_type,
             // Project-runtime switching (replaces switch_project_windows)
@@ -315,51 +871,175 @@ pub fn run() {
             commands::project_runtime::load_right_panel_folder,
             commands::project_runtime::save_right_panel_folder,
             // Git
+            commands::git::git_available,
             commands::git::git_status,
+            commands::git::git_repo_root,
+            commands::git::detect_git_providers,
             commands::git::git_add_all,
             commands::git::git_generate_commit_message,
             commands::git::git_commit,
             commands::git::git_push,
+            commands::git::git_clone,
             commands::git::git_file_statuses,
             commands::git::git_unpushed_commits,
+            commands::git::git_change_stats,
             commands::git::git_add_path,
             commands::git::git_log,
             commands::git::git_branches,
             commands::git::git_checkout,
             commands::git::git_commit_message,
             commands::git::git_reword_head,
+            commands::git_peer::git_peer_status,
+            commands::git_peer::git_peer_set_enabled,
+            commands::git_peer::git_peer_sync_now,
+            commands::git_peer::git_peer_checkout,
+            commands::git_peer::git_peer_resolve,
+            commands::git_peer::git_peer_pair_confirm,
+            commands::git_peer::git_peer_backups,
+            commands::git_peer::git_peer_restore_backup,
+            commands::git_peer::git_peer_mirror_dir,
+            // Local-loss warnings (#28q): what lockstep/sync destroyed in the mirror.
+            commands::local_loss::local_loss_list,
+            commands::local_loss::local_loss_ack,
+            commands::git::git_diff_file,
+            commands::git::git_blame,
+            commands::git::git_file_log,
+            commands::git::git_file_at_rev,
+            // Project-wide content search
+            commands::search::project_search,
+            // SQLite database browser (Dev C)
+            commands::sqlite::sqlite_tables,
+            commands::sqlite::sqlite_page,
+            // Spreadsheet (.xlsx/.xls) reader (Dev G)
+            commands::sheets::read_spreadsheet,
+            // Git worktrees (TODO Group E #23)
+            commands::git::git_worktree_list,
+            commands::git::git_worktree_add,
+            commands::git::git_worktree_remove,
+            commands::git::git_worktree_prune,
             // Crash reporting
             commands::crash::report_frontend_error,
             // Debug diagnostics
             commands::debug::debug_app_resource_usage,
-            // Downloads
-            commands::downloads::configure_browser_downloads,
             // Ollama local models
             commands::ollama::list_ollama_models,
             commands::ollama::ensure_vibe_ollama_model,
             commands::ollama::prepare_local_agent,
+            commands::ollama::list_local_drivers,
+            commands::ollama::prepare_local_launch,
             commands::ollama::ensure_ollama_running,
             // Ollama model management
             commands::ollama::ollama_is_installed,
+            commands::ollama::install_ollama,
+            commands::ollama::ollama_install_strategy,
+            commands::ollama::vibe_is_installed,
+            commands::ollama::install_vibe,
+            commands::ollama::vibe_install_strategy,
+            commands::agents::agent_is_installed,
+            commands::agents::npm_is_installed,
+            commands::agents::probe_binaries,
+            commands::agents::list_agents,
+            commands::agents::codex_hook_status,
+            commands::agents::install_agent,
+            commands::agents::uninstall_agent,
+            commands::ollama::ollama_is_running,
+            commands::ollama::ollama_status,
+            commands::ollama::ollama_registry_size,
             commands::ollama::list_ollama_models_detailed,
             commands::ollama::stop_ollama_model,
+            commands::ollama::load_ollama_model,
+            commands::ollama::list_pending_ollama_pulls,
+            commands::ollama::clear_pending_ollama_pull,
+            commands::ollama::list_orphan_partial_blobs,
+            commands::ollama::delete_partial_blob,
             commands::ollama::pull_ollama_model,
+            commands::ollama::pause_ollama_pull,
+            commands::ollama::delete_ollama_pull,
             commands::ollama::delete_ollama_model,
             commands::ollama::list_installable_models,
+            commands::ollama::search_ollama_registry,
             // Local code/text autocomplete (opt-in, local-only)
             commands::ollama::complete_text,
+            // Local grammar/spelling check (opt-in, local-only)
+            commands::ollama::check_grammar,
         ])
         .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_drag::init())
+        .plugin(tauri_plugin_notification::init())
         .build(tauri::generate_context!())
         .expect("error while building tauri application")
         .run(|_app, event| {
-            // Tear down any sshfs mounts for remote projects when the app exits
-            // so the user isn't left with stale FUSE mounts after shutdown.
+            // A detached popout can die WITHOUT going through `attach_subwindow`
+            // (seed-timeout self-destroy, last-tab close, the WM-close safety
+            // net in DetachedApp). Free its registry footprint — display number
+            // ("Eldrun win-N"), TrackedWindow, parkable override — here, the one
+            // choke point every destruction passes, so freed numbers get reused
+            // and a lone popout is always "win-1". The dock-back path fires this
+            // after `attach_subwindow` already freed; the release is idempotent.
+            if let tauri::RunEvent::WindowEvent {
+                label,
+                event: tauri::WindowEvent::Destroyed,
+                ..
+            } = &event
+            {
+                if label.starts_with("detached-") {
+                    use tauri::Manager;
+                    // Guard against a same-label window already re-created
+                    // (rapid destroy → re-detach): only clean up when no live
+                    // window holds the label, else we'd free the NEW window's
+                    // number while it is still on screen.
+                    if _app.get_webview_window(label).is_none() {
+                        let reg = _app.state::<WindowRegistryState>();
+                        let wid = commands::subwindow::release_detached_entry(
+                            &mut reg.lock().unwrap(),
+                            label,
+                        );
+                        if let Some(wid) = wid {
+                            let ws = _app.state::<commands::workspace::WorkspaceStateArc>();
+                            ws.lock().unwrap().backend.unset_parkable(wid);
+                        }
+                    }
+                }
+            }
             if let tauri::RunEvent::Exit = event {
-                services::ssh_mount::unmount_all();
+                use tauri::Manager;
+                // Abort every terminal's process subtree so no inner process (a
+                // dev server, a build, a training run) outlives Eldrun. Runs
+                // before the container teardown below, since a containerized
+                // tab's in-container process is TERMed via its still-live
+                // container. Dropping the registry alone would kill only the
+                // shell leaders and orphan everything they spawned.
+                _app.state::<RegistryState>().lock().unwrap().kill_all();
                 // Tear down any OpenVPN tunnels brought up for VPN-gated
                 // remote projects so no privileged tunnel outlives the app.
+                // Best-effort: a tunnel the close-path already asked about and was
+                // told to leave up (`declined_configs`) is skipped here rather than
+                // re-prompted with no window left to hold the dialog.
                 services::openvpn::disconnect_all();
+                // Remove every project container this run created — container
+                // lifetime is the project session, never longer than the app.
+                services::sandbox::down_all();
+                // Tear down pooled SSH/SFTP connections so no ssh ControlMaster
+                // child (and the master socket it owns) outlives Eldrun.
+                // Stop every auto-sync task first (cancel loops + drop watchers)
+                // so none races the pool teardown below.
+                let auto = _app
+                    .state::<services::sync_auto::AutoSyncState>()
+                    .inner()
+                    .clone();
+                tauri::async_runtime::block_on(services::sync_auto::stop_all(&auto));
+                // Stop every git-peer lockstep task (cancel poll loops + drop .git
+                // watchers) before the pool teardown.
+                let git_peer = _app
+                    .state::<services::git_peer::GitPeerRegistry>()
+                    .inner()
+                    .clone();
+                tauri::async_runtime::block_on(services::git_peer::stop_all(&git_peer));
+                let pool = _app
+                    .state::<services::remote::RemotePoolState>()
+                    .inner()
+                    .clone();
+                tauri::async_runtime::block_on(services::remote::disconnect_all(&pool));
             }
         });
 }
@@ -376,4 +1056,39 @@ mod tests {
         assert!(s.ends_with('Z'), "crash-log timestamps end with Z: {s}");
         assert!(s.contains('T'));
     }
+
+    fn crash_line(code: u32, addr: usize, cap: usize) -> (String, usize) {
+        let mut buf = vec![0u8; cap];
+        let len = format_crash_line(code, addr, &mut buf);
+        (String::from_utf8(buf[..len].to_vec()).unwrap(), len)
+    }
+
+    #[test]
+    fn format_crash_line_access_violation() {
+        // 0xC0000005 = STATUS_ACCESS_VIOLATION, the canonical native crash.
+        let (s, _) = crash_line(0xC000_0005, 0x7FF6_1234_ABCD, 64);
+        assert_eq!(s, "=== CRASH: code=0xC0000005 addr=0x7FF61234ABCD ===\n");
+    }
+
+    #[test]
+    fn format_crash_line_pads_code_to_8_digits_and_addr_to_1() {
+        let (s, _) = crash_line(0x5, 0x0, 64);
+        assert_eq!(s, "=== CRASH: code=0x00000005 addr=0x0 ===\n");
+    }
+
+    #[test]
+    fn format_crash_line_truncates_without_panicking() {
+        for cap in 0..48 {
+            let (s, len) = crash_line(0xC000_0005, usize::MAX, cap);
+            assert!(len <= cap, "len {len} must fit cap {cap}");
+            assert!("=== CRASH: code=0xC0000005 addr=0xFFFFFFFFFFFFFFFF ===\n".starts_with(&s));
+        }
+    }
+
+    #[test]
+    fn format_crash_line_max_values_fit_a_64_byte_buffer() {
+        let (s, len) = crash_line(u32::MAX, usize::MAX, 64);
+        assert!(len < 64, "worst case must fit the filter's stack buffer");
+        assert_eq!(s, "=== CRASH: code=0xFFFFFFFF addr=0xFFFFFFFFFFFFFFFF ===\n");
+    }
 }
diff --git a/src-tauri/src/paths.rs b/src-tauri/src/paths.rs
index f42a232..dfada1d 100644
--- a/src-tauri/src/paths.rs
+++ b/src-tauri/src/paths.rs
@@ -1,4 +1,6 @@
-use std::path::PathBuf;
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum OsKind {
@@ -19,6 +21,308 @@ impl OsKind {
     }
 }
 
+/// The PATH-lookup executable for `os`: `where` on Windows, `which` elsewhere.
+/// `which` does not exist on Windows, so any detection that hardcodes it reports
+/// every Windows install as missing.
+pub fn path_finder(os: OsKind) -> &'static str {
+    match os {
+        OsKind::Windows => "where",
+        OsKind::Macos | OsKind::Unix => "which",
+    }
+}
+
+/// Build a [`std::process::Command`] for `bin` that never flashes a console
+/// window on Windows. Console tools (TeX engines, `bibtex`, `synctex`, `where`)
+/// are GUI-less subprocesses we only read output from; without `CREATE_NO_WINDOW`
+/// each invocation pops a transient console window, and a single TeX compile
+/// spawns several. No-op on non-Windows targets.
+pub fn command_no_window(bin: impl AsRef<OsStr>) -> Command {
+    let mut cmd = Command::new(bin);
+    augment_command_path(&mut cmd);
+    hide_command_window(&mut cmd);
+    cmd
+}
+
+fn hide_command_window(_cmd: &mut Command) {
+    #[cfg(target_os = "windows")]
+    {
+        use std::os::windows::process::CommandExt;
+        // CREATE_NO_WINDOW (winbase.h): don't allocate a console for the child.
+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+        _cmd.creation_flags(CREATE_NO_WINDOW);
+    }
+}
+
+/// True when `bin` resolves on Eldrun's effective PATH on the current OS.
+/// Windows lookup expands PATHEXT and all platforms include supplemental
+/// per-user/package-manager directories.
+pub fn binary_on_path(bin: &str) -> bool {
+    resolve_executable(bin).is_some()
+}
+
+/// Standard directories macOS package managers (Homebrew, MacTeX) install CLI
+/// tools into but which a Finder/Dock-launched GUI app's inherited PATH omits —
+/// so a tool can be installed yet unreachable by bare name. The macOS analogue of
+/// the per-user dirs in [`launch_search_dirs`].
+const MACOS_EXTRA_DIRS: &[&str] = &[
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/opt/local/bin",
+    "/opt/local/sbin",
+    "/Library/TeX/texbin",
+];
+
+fn supplemental_path_dirs_for(
+    os: OsKind,
+    home: &Path,
+    local_app_data: Option<&OsStr>,
+    app_data: Option<&OsStr>,
+    program_files: Option<&OsStr>,
+) -> Vec<PathBuf> {
+    let mut dirs = vec![
+        home.join(".local").join("bin"),
+        home.join(".cargo").join("bin"),
+        home.join(".opencode").join("bin"),
+    ];
+    match os {
+        OsKind::Macos => dirs.extend(MACOS_EXTRA_DIRS.iter().map(PathBuf::from)),
+        OsKind::Windows => {
+            if let Some(local) = local_app_data {
+                let local = PathBuf::from(local);
+                dirs.push(local.join("Microsoft").join("WindowsApps"));
+                dirs.push(local.join("Programs").join("Ollama"));
+                // Per-user winget install of MiKTeX (`winget install --id
+                // MiKTeX.MiKTeX -e`, the command the "Install MiKTeX" button runs) —
+                // without this, a fresh install stays invisible to Eldrun's own
+                // process until it's relaunched, since a Windows PATH change made by
+                // an installer never reaches an already-running process's env.
+                dirs.push(
+                    local
+                        .join("Programs")
+                        .join("MiKTeX")
+                        .join("miktex")
+                        .join("bin")
+                        .join("x64"),
+                );
+                // Codex's standalone Windows installer (releases.openai.com/codex/
+                // install.ps1) writes here and updates the User PATH registry for
+                // *future* sessions only — the same "invisible until relaunch" gap.
+                dirs.push(
+                    local
+                        .join("Programs")
+                        .join("OpenAI")
+                        .join("Codex")
+                        .join("bin"),
+                );
+                dirs.push(local.join("bin"));
+            }
+            if let Some(roaming) = app_data {
+                dirs.push(PathBuf::from(roaming).join("npm"));
+            }
+            // Machine-wide MiKTeX install (`winget install --scope machine`, or the
+            // classic non-winget installer, which defaults here).
+            if let Some(pf) = program_files {
+                dirs.push(
+                    PathBuf::from(pf)
+                        .join("MiKTeX")
+                        .join("miktex")
+                        .join("bin")
+                        .join("x64"),
+                );
+            }
+        }
+        OsKind::Unix => {}
+    }
+    dirs
+}
+
+/// Directories prepended to every child process PATH. GUI-launched applications
+/// commonly miss per-user package directories on every supported OS.
+pub fn extra_path_dirs() -> Vec<PathBuf> {
+    supplemental_path_dirs_for(
+        OsKind::current(),
+        &home_dir(),
+        std::env::var_os("LOCALAPPDATA").as_deref(),
+        std::env::var_os("APPDATA").as_deref(),
+        std::env::var_os("ProgramFiles").as_deref(),
+    )
+}
+
+/// Prepend [`extra_path_dirs`] to `cmd`'s PATH env.
+pub fn augment_command_path(cmd: &mut std::process::Command) {
+    if let Some(path) = effective_path() {
+        cmd.env("PATH", path);
+    }
+}
+
+pub fn effective_path() -> Option<std::ffi::OsString> {
+    let current = std::env::var_os("PATH").unwrap_or_default();
+    let mut paths = extra_path_dirs();
+    paths.extend(std::env::split_paths(&current));
+    std::env::join_paths(&paths).ok()
+}
+
+fn launch_search_dirs() -> Vec<PathBuf> {
+    extra_path_dirs()
+}
+
+/// Pure resolver: the first existing `bin` across `dirs`, trying each of `exts`
+/// (an empty `exts` / `""` entry means no extension expansion). `exists` is
+/// injected so this is unit-testable without touching the filesystem.
+fn resolve_in_dirs(
+    dirs: &[PathBuf],
+    bin: &str,
+    exts: &[&str],
+    exists: &impl Fn(&Path) -> bool,
+) -> Option<PathBuf> {
+    for dir in dirs {
+        let base = dir.join(bin);
+        if exists(&base) {
+            return Some(base);
+        }
+        for ext in exts {
+            if ext.is_empty() {
+                continue;
+            }
+            let cand = dir.join(format!("{bin}.{ext}"));
+            if exists(&cand) {
+                return Some(cand);
+            }
+        }
+    }
+    None
+}
+
+fn windows_extensions(pathext: Option<&OsStr>) -> Vec<String> {
+    let value = pathext
+        .and_then(OsStr::to_str)
+        .filter(|value| !value.trim().is_empty())
+        .unwrap_or(".COM;.EXE;.BAT;.CMD;.PS1");
+    let mut extensions = value
+        .split(';')
+        .map(|ext| ext.trim().trim_start_matches('.').to_ascii_lowercase())
+        .filter(|ext| !ext.is_empty())
+        .collect::<Vec<_>>();
+    // PowerShell scripts are launchable through our explicit dispatcher even
+    // though Windows' default PATHEXT usually omits .PS1.
+    if !extensions.iter().any(|ext| ext == "ps1") {
+        extensions.push("ps1".to_string());
+    }
+    extensions
+}
+
+fn resolve_executable_in_dirs(
+    os: OsKind,
+    dirs: &[PathBuf],
+    bin: &str,
+    pathext: Option<&OsStr>,
+    exists: &impl Fn(&Path) -> bool,
+) -> Option<PathBuf> {
+    if bin.is_empty() {
+        return None;
+    }
+    if bin.contains('/') || bin.contains('\\') {
+        let path = PathBuf::from(bin);
+        return exists(&path).then_some(path);
+    }
+    let exts = if os == OsKind::Windows {
+        windows_extensions(pathext)
+    } else {
+        Vec::new()
+    };
+    let refs = exts.iter().map(String::as_str).collect::<Vec<_>>();
+    resolve_in_dirs(dirs, bin, &refs, exists)
+}
+
+/// Resolve a command using the same effective PATH Eldrun applies at execution.
+/// Windows resolution follows PATHEXT, including script shims.
+pub fn resolve_executable(bin: &str) -> Option<PathBuf> {
+    let current = std::env::var_os("PATH").unwrap_or_default();
+    let mut dirs = extra_path_dirs();
+    dirs.extend(std::env::split_paths(&current));
+    resolve_executable_in_dirs(
+        OsKind::current(),
+        &dirs,
+        bin,
+        std::env::var_os("PATHEXT").as_deref(),
+        &|path| path.is_file(),
+    )
+}
+
+pub fn resolve_executable_in_dir(dir: &Path, bin: &str) -> Option<PathBuf> {
+    resolve_executable_in_dirs(
+        OsKind::current(),
+        std::slice::from_ref(&dir.to_path_buf()),
+        bin,
+        std::env::var_os("PATHEXT").as_deref(),
+        &|path| path.is_file(),
+    )
+}
+
+fn command_for_program_for(os: OsKind, program: &Path) -> Command {
+    let ext = program
+        .extension()
+        .and_then(OsStr::to_str)
+        .unwrap_or("")
+        .to_ascii_lowercase();
+    let mut cmd = if os == OsKind::Windows && matches!(ext.as_str(), "cmd" | "bat") {
+        let mut cmd = Command::new("cmd.exe");
+        cmd.args(["/D", "/C"]).arg(program);
+        cmd
+    } else if os == OsKind::Windows && ext == "ps1" {
+        let mut cmd = Command::new("powershell.exe");
+        cmd.args(["-NoProfile", "-ExecutionPolicy", "Bypass", "-File"])
+            .arg(program);
+        cmd
+    } else {
+        Command::new(program)
+    };
+    augment_command_path(&mut cmd);
+    hide_command_window(&mut cmd);
+    cmd
+}
+
+/// Build a command for a resolved executable. Windows command/batch shims run
+/// through cmd.exe and PowerShell scripts through powershell.exe.
+pub fn command_for_program(program: &Path) -> Command {
+    command_for_program_for(OsKind::current(), program)
+}
+
+/// Spawn a process whose result is intentionally ignored, retaining the Child
+/// in a background waiter so it cannot become a zombie or leak process handles.
+pub fn spawn_reaped(mut cmd: Command) -> std::io::Result<u32> {
+    let mut child: Child = cmd.spawn()?;
+    let pid = child.id();
+    std::thread::spawn(move || {
+        let _ = child.wait();
+    });
+    Ok(pid)
+}
+
+/// Resolve a bare tool name to an absolute executable path when it is installed
+/// in a well-known per-user location but is NOT on the inherited PATH. Returns
+/// `None` when the name already carries a path, already resolves on PATH (so the
+/// caller should keep using the bare name), or matches nowhere. This closes the
+/// gap where Eldrun *detects* a tool (ollama/vibe/agent CLIs) yet fails to
+/// *launch* it on Windows because winget/uv/npm install dirs aren't on PATH.
+pub fn resolve_offpath_binary(bin: &str) -> Option<PathBuf> {
+    if bin.is_empty() || bin.contains('/') || bin.contains('\\') {
+        return None;
+    }
+    if binary_on_path(bin) {
+        return None;
+    }
+    resolve_executable_in_dirs(
+        OsKind::current(),
+        &launch_search_dirs(),
+        bin,
+        std::env::var_os("PATHEXT").as_deref(),
+        &|p| p.is_file(),
+    )
+}
+
 pub fn home_dir() -> PathBuf {
     home_dir_for(OsKind::current(), |key| std::env::var(key).ok())
 }
@@ -58,6 +362,14 @@ pub fn projects_root() -> PathBuf {
     home_dir().join("eldrun").join("projects")
 }
 
+/// The default parent for remote (SSH) projects' local mirrors: a top-level
+/// `eldrun/projects-ssh/` sibling of [`projects_root`], rather than a nested
+/// `projects/ssh/` subfolder. Keeps synced remote working copies out of the
+/// managed-local-projects tree.
+pub fn projects_ssh_root() -> PathBuf {
+    home_dir().join("eldrun").join("projects-ssh")
+}
+
 pub fn root_work_dir() -> PathBuf {
     home_dir().join("eldrun").join("root")
 }
@@ -66,6 +378,14 @@ pub fn boxes_root() -> PathBuf {
     home_dir().join("eldrun").join("boxes")
 }
 
+/// Holding area for deleted projects: `~/eldrun/archive/<id>/`. A deleted
+/// project's local folders (and a restore manifest) move here rather than being
+/// erased, so it can be restored or permanently cleared from Settings. Only ever
+/// emptied manually from the Settings "Archived projects" panel.
+pub fn archive_root() -> PathBuf {
+    home_dir().join("eldrun").join("archive")
+}
+
 fn non_empty(value: Option<String>) -> Option<String> {
     value.filter(|value| !value.is_empty())
 }
@@ -120,6 +440,154 @@ mod tests {
         assert_eq!(home, PathBuf::from("/root"));
     }
 
+    #[test]
+    fn path_finder_is_where_on_windows_which_elsewhere() {
+        assert_eq!(path_finder(OsKind::Windows), "where");
+        assert_eq!(path_finder(OsKind::Macos), "which");
+        assert_eq!(path_finder(OsKind::Unix), "which");
+    }
+
+    #[test]
+    fn resolve_in_dirs_finds_extensionless_match() {
+        let dirs = vec![
+            PathBuf::from("/opt/bin"),
+            PathBuf::from("/home/a/.local/bin"),
+        ];
+        let present = PathBuf::from("/home/a/.local/bin/vibe");
+        let found = resolve_in_dirs(&dirs, "vibe", &[], &|p| p == present);
+        assert_eq!(found, Some(present));
+    }
+
+    #[test]
+    fn resolve_in_dirs_expands_windows_extensions_in_order() {
+        let dirs = vec![PathBuf::from(r"C:\Users\a\.local\bin")];
+        // Build the expected path via `join` (as `resolve_in_dirs` does) so the
+        // separator is correct on every OS: a hardcoded backslash literal only
+        // equals `dir.join(..)` on Windows, so it failed on the Linux CI runner.
+        let present = dirs[0].join("vibe.exe");
+        let found = resolve_in_dirs(&dirs, "vibe", &["exe", "cmd", "bat"], &|p| p == present);
+        assert_eq!(found, Some(present));
+    }
+
+    #[test]
+    fn resolve_in_dirs_returns_none_when_absent() {
+        let dirs = vec![PathBuf::from("/opt/bin")];
+        let found = resolve_in_dirs(&dirs, "nope", &["exe"], &|_| false);
+        assert_eq!(found, None);
+    }
+
+    #[test]
+    fn supplemental_paths_cover_all_supported_os_families() {
+        let home = Path::new("/home/alice");
+        let unix = supplemental_path_dirs_for(OsKind::Unix, home, None, None, None);
+        assert!(unix.contains(&home.join(".local/bin")));
+        assert!(unix.contains(&home.join(".cargo/bin")));
+        assert!(unix.contains(&home.join(".opencode/bin")));
+
+        let mac = supplemental_path_dirs_for(OsKind::Macos, home, None, None, None);
+        assert!(mac.contains(&PathBuf::from("/opt/homebrew/bin")));
+        assert!(mac.contains(&PathBuf::from("/Library/TeX/texbin")));
+
+        let windows = supplemental_path_dirs_for(
+            OsKind::Windows,
+            Path::new(r"C:\Users\alice"),
+            Some(OsStr::new(r"C:\Users\alice\AppData\Local")),
+            Some(OsStr::new(r"C:\Users\alice\AppData\Roaming")),
+            Some(OsStr::new(r"C:\Program Files")),
+        );
+        assert!(windows
+            .iter()
+            .any(|path| path.ends_with(Path::new("Microsoft/WindowsApps"))));
+        assert!(windows.iter().any(|path| path.ends_with(Path::new("npm"))));
+        assert!(windows
+            .iter()
+            .any(|path| path.ends_with(Path::new("Programs/Ollama"))));
+        assert!(windows
+            .iter()
+            .any(|path| path.ends_with(Path::new("Programs/MiKTeX/miktex/bin/x64"))));
+        assert!(windows
+            .iter()
+            .any(|path| path.ends_with(Path::new("Programs/OpenAI/Codex/bin"))));
+        assert!(windows.iter().any(|path| {
+            path.starts_with(r"C:\Program Files") && path.ends_with(Path::new("MiKTeX/miktex/bin/x64"))
+        }));
+    }
+
+    #[test]
+    fn windows_resolution_honors_pathext() {
+        let dir = PathBuf::from("tools");
+        for (ext, expected) in [
+            ("EXE", "fmt.exe"),
+            ("CMD", "fmt.cmd"),
+            ("BAT", "fmt.bat"),
+            ("PS1", "fmt.ps1"),
+        ] {
+            let present = dir.join(expected);
+            let pathext = format!(".{ext}");
+            let found = resolve_executable_in_dirs(
+                OsKind::Windows,
+                std::slice::from_ref(&dir),
+                "fmt",
+                Some(OsStr::new(&pathext)),
+                &|path| path == present,
+            );
+            assert_eq!(found, Some(present));
+        }
+        let script = dir.join("fmt.ps1");
+        let found = resolve_executable_in_dirs(
+            OsKind::Windows,
+            std::slice::from_ref(&dir),
+            "fmt",
+            Some(OsStr::new(".EXE;.CMD")),
+            &|path| path == script,
+        );
+        assert_eq!(found, Some(script));
+    }
+
+    #[test]
+    fn windows_scripts_dispatch_through_their_interpreters() {
+        let cmd = command_for_program_for(OsKind::Windows, Path::new(r"C:\tools\fmt.cmd"));
+        assert_eq!(cmd.get_program(), "cmd.exe");
+        assert!(cmd
+            .get_args()
+            .any(|arg| arg == OsStr::new(r"C:\tools\fmt.cmd")));
+
+        let ps = command_for_program_for(OsKind::Windows, Path::new(r"C:\tools\fmt.ps1"));
+        assert_eq!(ps.get_program(), "powershell.exe");
+        assert!(ps
+            .get_args()
+            .any(|arg| arg == OsStr::new(r"C:\tools\fmt.ps1")));
+
+        let exe = command_for_program_for(OsKind::Windows, Path::new(r"C:\tools\fmt.exe"));
+        assert_eq!(exe.get_program(), OsStr::new(r"C:\tools\fmt.exe"));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn fire_and_forget_children_are_reaped() {
+        let mut cmd = command_no_window("sh");
+        cmd.args(["-c", "exit 0"]);
+        let pid = spawn_reaped(cmd).expect("spawn");
+        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
+        while std::time::Instant::now() < deadline {
+            let result =
+                unsafe { libc::waitpid(pid as libc::pid_t, std::ptr::null_mut(), libc::WNOHANG) };
+            if result == -1 {
+                return;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(10));
+        }
+        panic!("background waiter did not reap pid {pid}");
+    }
+
+    #[test]
+    fn resolve_offpath_binary_ignores_qualified_names() {
+        // A name carrying a path separator is already explicit — leave it alone.
+        assert_eq!(resolve_offpath_binary("/usr/bin/vibe"), None);
+        assert_eq!(resolve_offpath_binary(r"C:\tools\vibe.exe"), None);
+        assert_eq!(resolve_offpath_binary(""), None);
+    }
+
     #[test]
     fn boxes_root_ends_with_boxes_under_eldrun() {
         let dir = boxes_root();
@@ -132,4 +600,20 @@ mod tests {
             .unwrap_or("");
         assert_eq!(parent, "eldrun", "boxes_root parent must be 'eldrun'");
     }
+
+    #[test]
+    fn archive_root_ends_with_archive_under_eldrun() {
+        let dir = archive_root();
+        let last = dir.file_name().and_then(|n| n.to_str()).unwrap_or("");
+        assert_eq!(
+            last, "archive",
+            "archive_root must end in 'archive': {dir:?}"
+        );
+        let parent = dir
+            .parent()
+            .and_then(|p| p.file_name())
+            .and_then(|n| n.to_str())
+            .unwrap_or("");
+        assert_eq!(parent, "eldrun", "archive_root parent must be 'eldrun'");
+    }
 }
diff --git a/src-tauri/src/platform/macos.rs b/src-tauri/src/platform/macos.rs
new file mode 100644
index 0000000..05de298
--- /dev/null
+++ b/src-tauri/src/platform/macos.rs
@@ -0,0 +1,524 @@
+//! macOS project-window backend — NSRunningApplication hide/unhide "parking".
+//!
+//! macOS offers no public per-window control over other applications (that
+//! would need the private CGS/SkyLight API — rejected as build-fragile), so
+//! Eldrun parks at APP granularity: hiding a tracked window `hide`s its owning
+//! application, showing it `unhide`s + best-effort activates it. Window
+//! enumeration/geometry ride `CGWindowListCopyWindowInfo`, which needs NO
+//! Screen Recording permission for the keys used here (window id, owner pid,
+//! owner name, layer, bounds), and `NSRunningApplication hide/unhide` needs NO
+//! Accessibility permission.
+//!
+//! Every X11/Windows safety invariant holds: Eldrun's own windows are never
+//! hidden (owning-process identity — hiding our own app would hide the MAIN
+//! window, since hide is app-wide — plus the structural main-window guard),
+//! protected shell surfaces (Dock/Finder/…) are never hidden, and cleanup
+//! unhides everything Eldrun hid. Because a hidden app's windows leave the
+//! on-screen CGWindowList, the owner pid is recorded at hide time
+//! (`MacParkState::mark_parked`) and show/cleanup key on that pid.
+//!
+//! The pure decision logic lives FFI-free in `super::macos_park` so it is unit
+//! tested on any OS; this file is the thin FFI shell (raw `extern "C"` — the
+//! same pattern as `sysstat.rs`'s libproc backend; no new crates).
+
+use std::ffi::c_void;
+use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
+
+use super::macos_park::{is_protected_owner_name, MacParkState, WinRect};
+use super::{WorkspaceBackend, WorkspaceInfo};
+
+// ── Raw CoreFoundation / CoreGraphics / objc FFI ────────────────────────────
+
+type CFTypeRef = *const c_void;
+type CFArrayRef = *const c_void;
+type CFDictionaryRef = *const c_void;
+type CFStringRef = *const c_void;
+type CFIndex = isize;
+
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+struct CGPoint {
+    x: f64,
+    y: f64,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+struct CGSize {
+    width: f64,
+    height: f64,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Default)]
+struct CGRect {
+    origin: CGPoint,
+    size: CGSize,
+}
+
+/// `kCGWindowListOptionOnScreenOnly`: only windows currently on screen, in
+/// front-to-back order — exactly what the occlusion walk needs.
+const ON_SCREEN_ONLY: u32 = 1 << 0;
+/// `kCGNullWindowID`.
+const NULL_WINDOW_ID: u32 = 0;
+/// `kCFStringEncodingUTF8`.
+const UTF8: u32 = 0x0800_0100;
+/// `kCFNumberSInt64Type`.
+const SINT64: CFIndex = 4;
+
+#[link(name = "CoreGraphics", kind = "framework")]
+extern "C" {
+    fn CGWindowListCopyWindowInfo(option: u32, relative_to_window: u32) -> CFArrayRef;
+    fn CGRectMakeWithDictionaryRepresentation(dict: CFDictionaryRef, rect: *mut CGRect) -> bool;
+    fn CGEventCreate(source: *const c_void) -> CFTypeRef;
+    fn CGEventGetLocation(event: CFTypeRef) -> CGPoint;
+}
+
+#[link(name = "CoreFoundation", kind = "framework")]
+extern "C" {
+    fn CFArrayGetCount(array: CFArrayRef) -> CFIndex;
+    fn CFArrayGetValueAtIndex(array: CFArrayRef, index: CFIndex) -> *const c_void;
+    fn CFDictionaryGetValue(dict: CFDictionaryRef, key: *const c_void) -> *const c_void;
+    fn CFStringCreateWithCString(
+        alloc: *const c_void,
+        c_str: *const std::ffi::c_char,
+        encoding: u32,
+    ) -> CFStringRef;
+    fn CFStringGetCString(
+        string: CFStringRef,
+        buffer: *mut std::ffi::c_char,
+        buffer_size: CFIndex,
+        encoding: u32,
+    ) -> bool;
+    fn CFNumberGetValue(number: *const c_void, number_type: CFIndex, out: *mut c_void) -> bool;
+    fn CFRelease(cf: CFTypeRef);
+}
+
+#[link(name = "objc")]
+extern "C" {
+    fn objc_getClass(name: *const std::ffi::c_char) -> *mut c_void;
+    fn sel_registerName(name: *const std::ffi::c_char) -> *mut c_void;
+    fn objc_msgSend();
+}
+
+/// `objc_msgSend` cast to `(receiver, selector) -> id/isize`. macOS ships a
+/// single untyped `objc_msgSend`; casting it per call signature is the
+/// standard raw-FFI pattern (what the `objc` crate does under the hood).
+fn msg_send0(receiver: *mut c_void, selector: *mut c_void) -> *mut c_void {
+    // SAFETY: transmuting objc_msgSend to the concrete calling signature is
+    // the documented way to invoke it; receiver/selector are checked non-null
+    // by callers where required (messaging nil is well-defined and returns 0).
+    unsafe {
+        let f: extern "C" fn(*mut c_void, *mut c_void) -> *mut c_void =
+            std::mem::transmute(objc_msgSend as *const ());
+        f(receiver, selector)
+    }
+}
+
+/// `objc_msgSend` cast to `(receiver, selector, i32) -> id`.
+fn msg_send_i32(receiver: *mut c_void, selector: *mut c_void, arg: i32) -> *mut c_void {
+    // SAFETY: see `msg_send0`.
+    unsafe {
+        let f: extern "C" fn(*mut c_void, *mut c_void, i32) -> *mut c_void =
+            std::mem::transmute(objc_msgSend as *const ());
+        f(receiver, selector, arg)
+    }
+}
+
+/// `objc_msgSend` cast to `(receiver, selector, usize) -> id` (NSUInteger arg).
+fn msg_send_usize(receiver: *mut c_void, selector: *mut c_void, arg: usize) -> *mut c_void {
+    // SAFETY: see `msg_send0`.
+    unsafe {
+        let f: extern "C" fn(*mut c_void, *mut c_void, usize) -> *mut c_void =
+            std::mem::transmute(objc_msgSend as *const ());
+        f(receiver, selector, arg)
+    }
+}
+
+fn sel(name: &std::ffi::CStr) -> *mut c_void {
+    // SAFETY: sel_registerName copies the NUL-terminated name; always valid.
+    unsafe { sel_registerName(name.as_ptr()) }
+}
+
+/// The `NSRunningApplication` instance for `pid`, or null if the process is
+/// not a running application (a daemon, or already gone).
+fn running_application(pid: u32) -> *mut c_void {
+    // SAFETY: objc_getClass on a static NUL-terminated name; messaging the
+    // class object with a pid is the documented constructor. AppKit is loaded
+    // (Tauri's window layer is AppKit), so the class resolves.
+    let cls = unsafe { objc_getClass(c"NSRunningApplication".as_ptr()) };
+    if cls.is_null() {
+        return std::ptr::null_mut();
+    }
+    msg_send_i32(
+        cls,
+        sel(c"runningApplicationWithProcessIdentifier:"),
+        pid as i32,
+    )
+}
+
+// ── CGWindowList enumeration ────────────────────────────────────────────────
+
+/// One on-screen window as reported by `CGWindowListCopyWindowInfo`, in
+/// front-to-back order.
+struct WindowInfo {
+    id: u64,
+    pid: u32,
+    layer: i32,
+    owner_name: String,
+    bounds: CGRect,
+}
+
+/// Read an i64 out of a CFNumber dictionary value; 0 when absent/mistyped.
+fn dict_i64(dict: CFDictionaryRef, key: CFStringRef) -> i64 {
+    // SAFETY: CFDictionaryGetValue returns a borrowed reference (may be null);
+    // CFNumberGetValue only writes `out` when it returns true.
+    unsafe {
+        let value = CFDictionaryGetValue(dict, key);
+        if value.is_null() {
+            return 0;
+        }
+        let mut out: i64 = 0;
+        if CFNumberGetValue(value, SINT64, &mut out as *mut i64 as *mut c_void) {
+            out
+        } else {
+            0
+        }
+    }
+}
+
+/// Read a String out of a CFString dictionary value; empty when absent.
+fn dict_string(dict: CFDictionaryRef, key: CFStringRef) -> String {
+    // SAFETY: the value is borrowed; CFStringGetCString NUL-terminates into
+    // the provided buffer and returns false on truncation/absence.
+    unsafe {
+        let value = CFDictionaryGetValue(dict, key);
+        if value.is_null() {
+            return String::new();
+        }
+        let mut buf = [0i8; 256];
+        if CFStringGetCString(value, buf.as_mut_ptr(), buf.len() as CFIndex, UTF8) {
+            std::ffi::CStr::from_ptr(buf.as_ptr())
+                .to_string_lossy()
+                .into_owned()
+        } else {
+            String::new()
+        }
+    }
+}
+
+/// Snapshot every on-screen window (front-to-back). Needs no Screen Recording
+/// permission for these keys (id/pid/owner-name/layer/bounds); without that
+/// permission only `kCGWindowName` would be withheld, which is not read.
+fn window_list() -> Vec<WindowInfo> {
+    let mut out = Vec::new();
+    // SAFETY: every Create/Copy ref made here (the key strings, the array) is
+    // CFReleased before returning; dictionary values are borrowed and read
+    // only while the array is alive.
+    unsafe {
+        let key_number = CFStringCreateWithCString(std::ptr::null(), c"kCGWindowNumber".as_ptr(), UTF8);
+        let key_pid = CFStringCreateWithCString(std::ptr::null(), c"kCGWindowOwnerPID".as_ptr(), UTF8);
+        let key_owner = CFStringCreateWithCString(std::ptr::null(), c"kCGWindowOwnerName".as_ptr(), UTF8);
+        let key_layer = CFStringCreateWithCString(std::ptr::null(), c"kCGWindowLayer".as_ptr(), UTF8);
+        let key_bounds = CFStringCreateWithCString(std::ptr::null(), c"kCGWindowBounds".as_ptr(), UTF8);
+
+        let array = CGWindowListCopyWindowInfo(ON_SCREEN_ONLY, NULL_WINDOW_ID);
+        if !array.is_null() {
+            for i in 0..CFArrayGetCount(array) {
+                let dict = CFArrayGetValueAtIndex(array, i);
+                if dict.is_null() {
+                    continue;
+                }
+                let id = dict_i64(dict, key_number);
+                if id <= 0 {
+                    continue;
+                }
+                let mut bounds = CGRect::default();
+                let bounds_dict = CFDictionaryGetValue(dict, key_bounds);
+                if !bounds_dict.is_null() {
+                    // Writes `bounds` only on success; the default (zero rect)
+                    // is harmless for the occlusion walk otherwise.
+                    let _ = CGRectMakeWithDictionaryRepresentation(bounds_dict, &mut bounds);
+                }
+                out.push(WindowInfo {
+                    id: id as u64,
+                    pid: dict_i64(dict, key_pid).max(0) as u32,
+                    layer: dict_i64(dict, key_layer) as i32,
+                    owner_name: dict_string(dict, key_owner),
+                    bounds,
+                });
+            }
+            CFRelease(array);
+        }
+        for key in [key_number, key_pid, key_owner, key_layer, key_bounds] {
+            if !key.is_null() {
+                CFRelease(key);
+            }
+        }
+    }
+    out
+}
+
+/// The current pointer location in the CG global coordinate space — the SAME
+/// top-left-origin space `kCGWindowBounds` uses, so the two compare directly.
+fn pointer_location() -> Option<(f64, f64)> {
+    // SAFETY: CGEventCreate(null) returns a new event snapshotting the current
+    // pointer state; it is CFReleased after the location is read.
+    unsafe {
+        let event = CGEventCreate(std::ptr::null());
+        if event.is_null() {
+            return None;
+        }
+        let point = CGEventGetLocation(event);
+        CFRelease(event);
+        Some((point.x, point.y))
+    }
+}
+
+// ── Backend ─────────────────────────────────────────────────────────────────
+
+pub struct MacBackend {
+    /// Pure parking state: parkable override, main-window guard, parked map.
+    state: Mutex<MacParkState>,
+    /// Eldrun's own pid — the structural backbone of "never hide Eldrun":
+    /// hide is app-granular, so hiding our own app would hide the MAIN window.
+    self_pid: u32,
+    /// Idempotency latch for `cleanup` (mirrors x11.rs/windows.rs).
+    cleaned_up: Mutex<bool>,
+}
+
+impl MacBackend {
+    pub fn new() -> Self {
+        Self {
+            state: Mutex::new(MacParkState::default()),
+            self_pid: std::process::id(),
+            cleaned_up: Mutex::new(false),
+        }
+    }
+
+    /// Resolve the owning pid + owner name for a window id from the on-screen
+    /// list. `None` when the window is gone (or its app already hidden).
+    fn owner_of(&self, window_id: u64) -> Option<(u32, String)> {
+        window_list()
+            .into_iter()
+            .find(|w| w.id == window_id)
+            .map(|w| (w.pid, w.owner_name))
+    }
+
+    /// `unhide` + best-effort activate the app owning `pid`.
+    fn unhide_pid(&self, pid: u32) {
+        let app = running_application(pid);
+        if app.is_null() {
+            return; // app quit while parked — nothing to restore
+        }
+        let _ = msg_send0(app, sel(c"unhide"));
+        // NSApplicationActivateIgnoringOtherApps (1 << 1): best-effort raise;
+        // failure just leaves the app unhidden behind the current window.
+        let _ = msg_send_usize(app, sel(c"activateWithOptions:"), 1 << 1);
+    }
+}
+
+impl Default for MacBackend {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl WorkspaceBackend for MacBackend {
+    fn name(&self) -> &'static str {
+        "macos"
+    }
+
+    fn info(&self) -> WorkspaceInfo {
+        WorkspaceInfo {
+            label: "mac".to_string(),
+            current_desktop: None,
+            desktop_count: None,
+        }
+    }
+
+    fn show_window(&self, window_id: u64) -> Result<(), String> {
+        // A parked window's app has left the on-screen list, so the pid comes
+        // from the parked map; fall back to a live scan for a window that was
+        // never actually hidden.
+        let pid = self
+            .state
+            .lock()
+            .unwrap()
+            .parked_pid(window_id)
+            .or_else(|| self.owner_of(window_id).map(|(pid, _)| pid));
+        if let Some(pid) = pid {
+            if pid != self.self_pid {
+                self.unhide_pid(pid);
+            }
+        }
+        self.state.lock().unwrap().unmark_parked(window_id);
+        Ok(())
+    }
+
+    fn hide_window(&self, window_id: u64) -> Result<(), String> {
+        let Some((pid, owner_name)) = self.owner_of(window_id) else {
+            return Ok(()); // window already gone/hidden — nothing to do
+        };
+        // NEVER hide Eldrun itself — hide is app-granular, so this would take
+        // down the MAIN window. Unlike X11/Windows, the parkable override can
+        // NOT bypass this: popout self-parking is deferred on macOS for
+        // exactly this reason (see the intentional-gaps register).
+        if pid == self.self_pid {
+            return Ok(());
+        }
+        if !self.state.lock().unwrap().is_parkable(window_id)
+            && is_protected_owner_name(&owner_name)
+        {
+            return Ok(());
+        }
+        let app = running_application(pid);
+        if app.is_null() {
+            return Ok(()); // not an application (daemon) or already gone
+        }
+        let _ = msg_send0(app, sel(c"hide"));
+        self.state.lock().unwrap().mark_parked(window_id, pid);
+        Ok(())
+    }
+
+    fn make_sticky(&self, _eldrun_pid: u32) -> Result<(), String> {
+        // No public Spaces API to pin an app to every Space. Leave Eldrun on
+        // the user-selected Space.
+        Ok(())
+    }
+
+    fn set_parkable(&self, window_id: u64) {
+        self.state.lock().unwrap().add_parkable(window_id);
+    }
+
+    fn unset_parkable(&self, window_id: u64) {
+        self.state.lock().unwrap().remove_parkable(window_id);
+    }
+
+    fn set_main_window_id(&self, window_id: u64) {
+        self.state.lock().unwrap().set_main(window_id);
+    }
+
+    fn cleanup(&self) -> Result<(), String> {
+        let mut cleaned_up = self.cleaned_up.lock().unwrap();
+        if *cleaned_up {
+            return Ok(());
+        }
+        *cleaned_up = true;
+        drop(cleaned_up);
+
+        // Unhide exactly the apps Eldrun hid (dedup by pid — several tracked
+        // windows can share one app, and unhide is app-granular anyway).
+        let parked = self.state.lock().unwrap().drain_parked();
+        let mut seen = std::collections::HashSet::new();
+        for (_window_id, pid) in parked {
+            if pid != self.self_pid && seen.insert(pid) {
+                self.unhide_pid(pid);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Drop for MacBackend {
+    fn drop(&mut self) {
+        // Mirrors x11.rs/windows.rs: normal teardown always unhides project
+        // apps even if the explicit cleanup command is missed.
+        let _ = self.cleanup();
+    }
+}
+
+// ── Free helpers (command-layer window resolution) ──────────────────────────
+
+/// All on-screen layer-0 window ids, front-to-back. Non-zero layers (menu bar,
+/// Dock, overlays) are not app windows and never enter tracked sets.
+pub fn list_window_ids() -> Vec<u64> {
+    window_list()
+        .into_iter()
+        .filter(|w| w.layer == 0)
+        .map(|w| w.id)
+        .collect()
+}
+
+/// Resolve a window owned by `pid` OR any of its descendants — a launcher stub
+/// commonly spawns the real GUI process as a child, so the visible window's
+/// owning pid is a descendant of (not equal to) the spawned pid. Mirrors
+/// `windows::find_window_for_pid`; `attempts == 1` does a single no-sleep scan
+/// (the hide-time resolver must not block the switch worker).
+pub fn find_window_for_pid(pid: u32, attempts: usize) -> Option<u64> {
+    for attempt in 0..attempts {
+        let pids = crate::sysstat::descendant_pids(&[pid]);
+        if let Some(win) = window_list()
+            .into_iter()
+            .find(|w| w.layer == 0 && pids.contains(&w.pid))
+        {
+            return Some(win.id);
+        }
+        if attempt + 1 < attempts {
+            thread::sleep(Duration::from_millis(100));
+        }
+    }
+    None
+}
+
+/// First window id not present in `before`, polling up to `attempts` times.
+/// Mirrors x11's `!w.protected` filter: never latch onto Eldrun's own or a
+/// protected shell window that happens to appear during the poll.
+pub fn find_new_window(before: &[u64], attempts: usize) -> Option<u64> {
+    let self_pid = std::process::id();
+    for attempt in 0..attempts {
+        if let Some(win) = window_list()
+            .into_iter()
+            .filter(|w| {
+                w.layer == 0 && w.pid != self_pid && !is_protected_owner_name(&w.owner_name)
+            })
+            .find(|w| !before.contains(&w.id))
+        {
+            return Some(win.id);
+        }
+        if attempt + 1 < attempts {
+            thread::sleep(Duration::from_millis(100));
+        }
+    }
+    None
+}
+
+/// The layer-0 window currently under the pointer, for the popout occlusion
+/// check (#42). Pointer location and window bounds share the CG global
+/// top-left coordinate space; the front-to-back walk itself is the pure,
+/// unit-tested `macos_park::frontmost_at_point`.
+pub fn frontmost_window_under_pointer() -> Option<u64> {
+    let (x, y) = pointer_location()?;
+    let rects: Vec<WinRect> = window_list()
+        .into_iter()
+        .map(|w| WinRect {
+            id: w.id,
+            layer: w.layer,
+            x: w.bounds.origin.x,
+            y: w.bounds.origin.y,
+            w: w.bounds.size.width,
+            h: w.bounds.size.height,
+        })
+        .collect();
+    super::macos_park::frontmost_at_point(&rects, x, y)
+}
+
+/// The `CGWindowID` of an `NSWindow*`, via its `windowNumber` property (the
+/// two are the same numbering). Used at startup to bind the MAIN window id for
+/// the structural parkable guard. Must be called on the main thread (AppKit
+/// rule for NSWindow access), which Tauri's `setup` is.
+pub fn ns_window_id(ns_window: *mut c_void) -> Option<u64> {
+    if ns_window.is_null() {
+        return None;
+    }
+    // SAFETY: messaging a live NSWindow with the argless `windowNumber`
+    // selector returns its NSInteger window number.
+    let number = unsafe {
+        let f: extern "C" fn(*mut c_void, *mut c_void) -> isize =
+            std::mem::transmute(objc_msgSend as *const ());
+        f(ns_window, sel(c"windowNumber"))
+    };
+    (number > 0).then_some(number as u64)
+}
diff --git a/src-tauri/src/platform/macos_park.rs b/src-tauri/src/platform/macos_park.rs
new file mode 100644
index 0000000..c23fbff
--- /dev/null
+++ b/src-tauri/src/platform/macos_park.rs
@@ -0,0 +1,336 @@
+//! Pure parking logic for the macOS backend — OS-agnostic, FFI-free.
+//!
+//! macOS has no public API to hide a single *window* of another application:
+//! per-window manipulation of foreign apps needs the private CGS (SkyLight)
+//! calls, which are rejected here for the same build-fragility reason the
+//! undocumented `IVirtualDesktopManagerInternal` is rejected on Windows. The
+//! macOS backend therefore parks at **app granularity**: hiding a tracked
+//! window means `NSRunningApplication hide` on its owning app, and showing it
+//! means `unhide`. A hidden app's windows leave the on-screen `CGWindowList`,
+//! so show cannot re-resolve the owner from a live enumeration — the pid is
+//! recorded at hide time in the parked map keyed by window id.
+//!
+//! This module holds only the pure decision logic so the safety-critical
+//! invariants can be unit tested on any OS (it is NOT `#[cfg]`-gated):
+//!   - `MacParkState` — the parkable override + the structural main-window
+//!     guard (mirroring `windows_park::WindowsParkState`) + the parked
+//!     window-id → owner-pid map that stands in for X11's PARKED_DESKTOP
+//!     membership.
+//!   - `is_protected_owner_name` — the macOS analog of
+//!     `is_protected_process_name`, keyed on `kCGWindowOwnerName`.
+//!   - `frontmost_at_point` — the occlusion geometry for the popout drop-merge
+//!     check, over `CGWindowList` bounds snapshots.
+
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+/// Owner names (per `kCGWindowOwnerName`, lowercased) whose windows must NEVER
+/// be parked: Eldrun itself plus the macOS shell surfaces. Mirrors
+/// `windows_park::PROTECTED_PROCESSES`. Eldrun's own windows are additionally
+/// shielded by owning-process identity (self pid) in the FFI layer, so
+/// `eldrun` here only guards same-named helper processes.
+pub const PROTECTED_OWNERS: &[&str] = &[
+    "eldrun",
+    "dock",
+    "finder",
+    "windowserver",
+    "systemuiserver",
+    "controlcenter",
+    "notificationcenter",
+];
+
+/// Pure owner-name check — the macOS analog of `is_protected_process_name`.
+///
+/// Lowercases, drops a trailing `.app`, and matches whole segments (split on
+/// the usual name separators) against [`PROTECTED_OWNERS`]. Segment matching
+/// rather than raw substring matching keeps an owner merely *containing* a
+/// protected token (e.g. "Docker" contains "dock"? no — segments — or
+/// "eldrunner") parkable, directly mirroring the X11 `kwinter`/`eldrunner`
+/// regression tests.
+pub fn is_protected_owner_name(owner: &str) -> bool {
+    let lowered = owner.to_lowercase();
+    let stem = lowered.strip_suffix(".app").unwrap_or(&lowered);
+    stem.split(['.', '-', '_', ' '])
+        .any(|segment| PROTECTED_OWNERS.contains(&segment))
+}
+
+/// The parkable override + the structurally-protected main window id + the
+/// map of currently-hidden ("parked") window ids to the owner pid recorded at
+/// hide time. Pure over its own state — unit-testable without CoreGraphics.
+/// Mirrors `windows_park::WindowsParkState`; the map (not a set) exists
+/// because a hidden app's windows vanish from the on-screen `CGWindowList`,
+/// so `show_window`/`cleanup` must key the `unhide` on the remembered pid.
+#[derive(Default)]
+pub struct MacParkState {
+    override_ids: HashSet<u64>,
+    /// The main Eldrun window's `CGWindowID`, once known. `add_parkable`
+    /// refuses to add this id, keeping "the main window is never parked"
+    /// structural.
+    main_window_id: Option<u64>,
+    /// window id → owner pid recorded when the app was hidden.
+    parked: HashMap<u64, u32>,
+}
+
+impl MacParkState {
+    /// Add `id` to the parkable override unless it is the main window id.
+    /// Returns whether it was added. Mirrors `WindowsParkState::add_parkable`.
+    pub fn add_parkable(&mut self, id: u64) -> bool {
+        if self.main_window_id == Some(id) {
+            // STRUCTURAL GUARD: the main window must never be parkable, even if
+            // a caller mistakenly asks. Refuse silently (debug-assert in tests).
+            debug_assert!(false, "attempted to mark the MAIN Eldrun window parkable");
+            return false;
+        }
+        self.override_ids.insert(id)
+    }
+
+    /// Remove `id` from the parkable override (on dock-back / close).
+    pub fn remove_parkable(&mut self, id: u64) {
+        self.override_ids.remove(&id);
+    }
+
+    pub fn is_parkable(&self, id: u64) -> bool {
+        self.override_ids.contains(&id)
+    }
+
+    /// Record the MAIN Eldrun window's id so `add_parkable` can structurally
+    /// refuse to ever add it to the override.
+    pub fn set_main(&mut self, id: u64) {
+        self.main_window_id = Some(id);
+    }
+
+    /// Record window `id` as parked, remembering the owning `pid` the hide was
+    /// issued against (the app has left the on-screen list by the time show
+    /// runs, so this pid is the only way back).
+    pub fn mark_parked(&mut self, id: u64, pid: u32) {
+        self.parked.insert(id, pid);
+    }
+
+    /// The pid recorded for a parked window id, if any.
+    pub fn parked_pid(&self, id: u64) -> Option<u32> {
+        self.parked.get(&id).copied()
+    }
+
+    /// Forget `id` from the parked map (its app was unhidden again).
+    pub fn unmark_parked(&mut self, id: u64) {
+        self.parked.remove(&id);
+    }
+
+    /// Take the whole parked map, clearing it. Used by `cleanup` to unhide
+    /// exactly the apps Eldrun hid.
+    pub fn drain_parked(&mut self) -> Vec<(u64, u32)> {
+        self.parked.drain().collect()
+    }
+}
+
+/// One on-screen window's geometry as snapshotted from `CGWindowList`, in the
+/// CG global coordinate space (origin top-left, y growing downward — the same
+/// space `CGEventGetLocation` reports the pointer in).
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct WinRect {
+    pub id: u64,
+    /// `kCGWindowLayer`. Layer 0 is the normal app-window layer; anything else
+    /// (menu bar, Dock, overlays) is not a candidate for the drop-merge check.
+    pub layer: i32,
+    pub x: f64,
+    pub y: f64,
+    pub w: f64,
+    pub h: f64,
+}
+
+/// The id of the front-most **layer-0** window containing point `(x, y)`,
+/// given `windows` in front-to-back order (the order `CGWindowListCopyWindowInfo`
+/// returns on-screen windows in). Containment is half-open, `[x, x+w)` /
+/// `[y, y+h)`, matching pixel ownership. `None` when no normal window is under
+/// the point. The macOS analog of x11.rs `frontmost_window_under_pointer`'s
+/// stacking walk, used by the popout occlusion check (#42).
+pub fn frontmost_at_point(windows: &[WinRect], x: f64, y: f64) -> Option<u64> {
+    windows
+        .iter()
+        .find(|w| {
+            w.layer == 0 && x >= w.x && x < w.x + w.w && y >= w.y && y < w.y + w.h
+        })
+        .map(|w| w.id)
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+//
+// These exercise only the pure structs/fns (no CoreGraphics calls), so they
+// compile and run on any OS, even though the FFI backend in `macos.rs` is
+// `#[cfg(target_os = "macos")]` and cannot even be compile-checked on Linux.
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ── is_protected_owner_name ─────────────────────────────────────────────
+
+    #[test]
+    fn eldrun_owner_is_always_protected() {
+        // The most critical invariant: Eldrun-named apps must NEVER be hidden.
+        // (The main window is doubly protected via the self-pid check.)
+        assert!(is_protected_owner_name("Eldrun"));
+        assert!(is_protected_owner_name("eldrun"));
+        assert!(is_protected_owner_name("ELDRUN"));
+        assert!(is_protected_owner_name("Eldrun.app"));
+    }
+
+    #[test]
+    fn protected_owners_constant_includes_eldrun() {
+        assert!(
+            PROTECTED_OWNERS.contains(&"eldrun"),
+            "PROTECTED_OWNERS must contain \"eldrun\" or Eldrun helpers could be hidden"
+        );
+    }
+
+    #[test]
+    fn macos_shell_owners_are_protected() {
+        assert!(is_protected_owner_name("Dock"));
+        assert!(is_protected_owner_name("Finder"));
+        assert!(is_protected_owner_name("WindowServer"));
+        assert!(is_protected_owner_name("SystemUIServer"));
+        assert!(is_protected_owner_name("ControlCenter"));
+        assert!(is_protected_owner_name("NotificationCenter"));
+    }
+
+    #[test]
+    fn ordinary_app_owner_is_not_protected() {
+        assert!(!is_protected_owner_name("Safari"));
+        assert!(!is_protected_owner_name("Visual Studio Code"));
+        assert!(!is_protected_owner_name("kitty"));
+        assert!(!is_protected_owner_name("")); // empty → not protected
+    }
+
+    #[test]
+    fn owner_merely_containing_protected_token_is_parkable() {
+        // Segment matching, not substring matching — the macOS analog of the
+        // x11 `kwinter`/`eldrunner` regression tests.
+        assert!(!is_protected_owner_name("eldrunner"));
+        assert!(!is_protected_owner_name("Docker")); // contains "dock" as substring only
+        assert!(!is_protected_owner_name("Pathfinder")); // contains "finder" as substring only
+    }
+
+    // ── parkable override (#42) ─────────────────────────────────────────────
+
+    #[test]
+    fn overridden_id_is_parkable() {
+        let mut state = MacParkState::default();
+        assert!(state.add_parkable(42));
+        assert!(state.is_parkable(42));
+    }
+
+    #[test]
+    fn non_overridden_id_is_not_parkable() {
+        let state = MacParkState::default();
+        assert!(!state.is_parkable(99));
+    }
+
+    #[test]
+    fn main_window_id_can_never_become_parkable() {
+        // The single most safety-critical invariant, structural like on the
+        // other backends: the MAIN window id is refused by add_parkable.
+        let mut state = MacParkState::default();
+        state.set_main(7);
+        let added =
+            std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| state.add_parkable(7)));
+        let _ = added; // debug builds panic on the debug_assert; either way:
+        assert!(
+            !state.is_parkable(7),
+            "the main window id must never enter the parkable override"
+        );
+    }
+
+    #[test]
+    fn other_ids_still_parkable_after_main_window_set() {
+        let mut state = MacParkState::default();
+        state.set_main(7);
+        assert!(state.add_parkable(8));
+        assert!(state.is_parkable(8));
+        assert!(!state.is_parkable(7));
+    }
+
+    #[test]
+    fn remove_parkable_clears_override() {
+        let mut state = MacParkState::default();
+        state.add_parkable(8);
+        state.remove_parkable(8);
+        assert!(!state.is_parkable(8));
+    }
+
+    // ── parked map (hide-time pid round-trip) ───────────────────────────────
+
+    #[test]
+    fn park_records_pid_for_show() {
+        // Hidden apps leave the on-screen CGWindowList, so show must key on
+        // the pid recorded at hide time — the map is the only way back.
+        let mut state = MacParkState::default();
+        state.mark_parked(10, 501);
+        assert_eq!(state.parked_pid(10), Some(501));
+        assert_eq!(state.parked_pid(11), None);
+    }
+
+    #[test]
+    fn unmark_and_drain_parked_round_trip() {
+        let mut state = MacParkState::default();
+        state.mark_parked(10, 501);
+        state.mark_parked(11, 502);
+        state.unmark_parked(10);
+        let drained = state.drain_parked();
+        assert_eq!(drained, vec![(11, 502)]);
+        assert!(state.drain_parked().is_empty(), "drain clears the map");
+    }
+
+    #[test]
+    fn repark_overwrites_recorded_pid() {
+        // A window id re-hidden after its app restarted must track the NEW pid.
+        let mut state = MacParkState::default();
+        state.mark_parked(10, 501);
+        state.mark_parked(10, 601);
+        assert_eq!(state.parked_pid(10), Some(601));
+    }
+
+    // ── occlusion geometry (popout drop-merge check, #42) ───────────────────
+
+    fn rect(id: u64, layer: i32, x: f64, y: f64, w: f64, h: f64) -> WinRect {
+        WinRect { id, layer, x, y, w, h }
+    }
+
+    #[test]
+    fn topmost_containing_window_wins() {
+        // Front-to-back order: window 1 overlaps window 2; the point is inside
+        // both, so the front one (listed first) must win.
+        let wins = [rect(1, 0, 0.0, 0.0, 100.0, 100.0), rect(2, 0, 50.0, 50.0, 100.0, 100.0)];
+        assert_eq!(frontmost_at_point(&wins, 60.0, 60.0), Some(1));
+        // A point only inside the back window resolves to it.
+        assert_eq!(frontmost_at_point(&wins, 120.0, 120.0), Some(2));
+    }
+
+    #[test]
+    fn non_zero_layer_windows_are_skipped() {
+        // The menu bar / Dock / overlay layers must never win the check — a
+        // popout under the menu bar is still the frontmost *app* window.
+        let wins = [
+            rect(9, 25, 0.0, 0.0, 100.0, 100.0), // overlay layer in front
+            rect(1, 0, 0.0, 0.0, 100.0, 100.0),
+        ];
+        assert_eq!(frontmost_at_point(&wins, 10.0, 10.0), Some(1));
+    }
+
+    #[test]
+    fn point_outside_every_window_is_none() {
+        let wins = [rect(1, 0, 0.0, 0.0, 100.0, 100.0)];
+        assert_eq!(frontmost_at_point(&wins, 500.0, 500.0), None);
+        assert_eq!(frontmost_at_point(&[], 0.0, 0.0), None);
+    }
+
+    #[test]
+    fn containment_is_half_open() {
+        // [x, x+w): the left/top edge belongs to the window, the right/bottom
+        // edge does not — matching pixel ownership.
+        let wins = [rect(1, 0, 10.0, 10.0, 100.0, 100.0)];
+        assert_eq!(frontmost_at_point(&wins, 10.0, 10.0), Some(1));
+        assert_eq!(frontmost_at_point(&wins, 110.0, 50.0), None);
+        assert_eq!(frontmost_at_point(&wins, 50.0, 110.0), None);
+        assert_eq!(frontmost_at_point(&wins, 109.999, 109.999), Some(1));
+    }
+}
diff --git a/src-tauri/src/platform/mod.rs b/src-tauri/src/platform/mod.rs
index 7317e3a..b464b4b 100644
--- a/src-tauri/src/platform/mod.rs
+++ b/src-tauri/src/platform/mod.rs
@@ -11,10 +11,20 @@ use serde::{Deserialize, Serialize};
 
 pub mod null;
 
+#[cfg(target_os = "macos")]
+pub mod macos;
+/// Pure parking logic for the macOS backend. Compiled on every OS (not
+/// `#[cfg]`-gated) so its safety-critical unit tests run on any platform; the
+/// CoreGraphics/objc FFI that consumes it lives in `macos.rs`.
+pub mod macos_park;
 #[cfg(target_os = "linux")]
 pub mod wayland_kde;
 #[cfg(target_os = "windows")]
 pub mod windows;
+/// Pure parking logic for the Windows backend. Compiled on every OS (not
+/// `#[cfg]`-gated) so its safety-critical unit tests run on any platform; the
+/// Win32 FFI that consumes it lives in `windows.rs`.
+pub mod windows_park;
 #[cfg(target_os = "linux")]
 pub mod x11;
 
@@ -85,6 +95,18 @@ pub trait WorkspaceBackend: Send + Sync {
     /// refuse to ever add it to the override. Called once at startup when the
     /// main window's X11 id is resolved. Default no-op.
     fn set_main_window_id(&self, _window_id: u64) {}
+
+    /// Move an already-mapped window to absolute physical root coordinates so it
+    /// lands on the monitor containing (x, y). Used to place an externally
+    /// launched app on the screen where a file was dropped. Best-effort;
+    /// implemented on X11 (ConfigureWindow) and Windows (SetWindowPos). The
+    /// default is a no-op for backends that cannot position foreign windows
+    /// (KDE-Wayland forbids a client positioning another app's window; macOS
+    /// has no public API for it; null has no windowing), which degrades
+    /// gracefully to "the WM places it wherever it likes".
+    fn position_window(&self, _window_id: u64, _x: i32, _y: i32) -> Result<(), String> {
+        Ok(())
+    }
 }
 
 // ── Factory ────────────────────────────────────────────────────────────────
@@ -92,7 +114,7 @@ pub trait WorkspaceBackend: Send + Sync {
 pub fn detect_backend() -> Box<dyn WorkspaceBackend> {
     #[cfg(target_os = "windows")]
     {
-        return Box::new(windows::WindowsBackend);
+        return Box::new(windows::WindowsBackend::new());
     }
 
     #[cfg(target_os = "linux")]
@@ -124,7 +146,18 @@ pub fn detect_backend() -> Box<dyn WorkspaceBackend> {
         }
     }
 
-    Box::new(null::NullBackend)
+    #[cfg(target_os = "macos")]
+    {
+        return Box::new(macos::MacBackend::new());
+    }
+
+    // Fallback for Linux desktops that matched no backend above, plus other
+    // platforms. On Windows/macOS the early returns above are the only paths,
+    // so gating this keeps it from being flagged as unreachable.
+    #[cfg(not(any(target_os = "windows", target_os = "macos")))]
+    {
+        return Box::new(null::NullBackend);
+    }
 }
 
 // ── Tests ─────────────────────────────────────────────────────────────────
@@ -138,7 +171,7 @@ mod tests {
         let b = detect_backend();
         let name = b.name();
         assert!(
-            ["null", "x11", "kde-wayland", "windows"].contains(&name),
+            ["null", "x11", "kde-wayland", "windows", "macos"].contains(&name),
             "unknown backend name: {name}"
         );
     }
diff --git a/src-tauri/src/platform/windows.rs b/src-tauri/src/platform/windows.rs
index 87e91d2..280f5c7 100644
--- a/src-tauri/src/platform/windows.rs
+++ b/src-tauri/src/platform/windows.rs
@@ -1,29 +1,108 @@
-//! Windows project-window backend.
+//! Windows project-window backend — SW_HIDE "parking" model.
 //!
 //! Windows exposes a documented virtual desktop affinity API for top-level
-//! windows, but not a supported API for creating or switching arbitrary virtual
-//! desktops. Eldrun therefore hides the previous project's tracked windows and
-//! moves the current project's tracked windows onto the desktop where Eldrun is
-//! currently running, then restores/raises them.
+//! windows (`IVirtualDesktopManager`), but no supported API for creating or
+//! switching arbitrary virtual desktops (that needs the undocumented, build-
+//! fragile `IVirtualDesktopManagerInternal`). Eldrun therefore mirrors the X11
+//! two-desktop "parking" model (see x11.rs) without a real second desktop: the
+//! previous project's tracked windows are HIDDEN with `SW_HIDE` (the logical
+//! "parked desktop"), and the current project's tracked windows are restored and
+//! raised. The documented `MoveWindowToDesktop` is kept as a best-effort defense
+//! (pull a window the user dragged onto another real desktop back onto Eldrun's),
+//! but parking never depends on it.
+//!
+//! Every X11 safety invariant holds: Eldrun's own window is never hidden
+//! (protected by owning-process identity AND the structural main-window guard),
+//! protected shell/system windows are never hidden, the parkable override lets a
+//! detached subwindow (#42) opt in, and cleanup restores everything Eldrun hid.
+//! The pure decision logic lives FFI-free in `super::windows_park` so it is unit
+//! tested on any OS.
 
+use std::sync::Mutex;
 use std::thread;
 use std::time::Duration;
 
+use super::windows_park::{is_protected_process_name, WindowsParkState};
 use super::{WorkspaceBackend, WorkspaceInfo};
 
+use windows::core::BOOL;
 use windows::core::GUID;
-use windows::Win32::Foundation::{BOOL, HWND, LPARAM};
+use windows::core::PWSTR;
+use windows::Win32::Foundation::{CloseHandle, HWND, LPARAM, POINT};
 use windows::Win32::System::Com::{
     CoCreateInstance, CoInitializeEx, CLSCTX_INPROC_SERVER, COINIT_APARTMENTTHREADED,
 };
+use windows::Win32::System::Threading::{
+    GetCurrentProcessId, OpenProcess, QueryFullProcessImageNameW, PROCESS_NAME_WIN32,
+    PROCESS_QUERY_LIMITED_INFORMATION,
+};
 use windows::Win32::UI::Shell::{IVirtualDesktopManager, VirtualDesktopManager};
 use windows::Win32::UI::WindowsAndMessaging::{
-    BringWindowToTop, EnumWindows, GetForegroundWindow, GetParent, GetWindow,
-    GetWindowThreadProcessId, IsWindow, IsWindowVisible, SetForegroundWindow, ShowWindow, GW_OWNER,
-    SW_HIDE, SW_RESTORE,
+    BringWindowToTop, EnumWindows, GetAncestor, GetCursorPos, GetForegroundWindow, GetParent,
+    GetWindow, GetWindowLongPtrW, GetWindowThreadProcessId, IsWindow, IsWindowVisible,
+    SetForegroundWindow, SetWindowLongPtrW, SetWindowPos, ShowWindow, WindowFromPoint, GA_ROOT,
+    GW_OWNER, GWL_STYLE, SWP_FRAMECHANGED, SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER,
+    SW_HIDE, SW_SHOW, WS_MAXIMIZEBOX, WS_THICKFRAME,
 };
 
-pub struct WindowsBackend;
+pub struct WindowsBackend {
+    /// Pure parking state: parkable override, main-window guard, parked set.
+    state: Mutex<WindowsParkState>,
+    /// Eldrun's own process id, captured at construction. The structural backbone
+    /// of the "never hide Eldrun" invariant: every Eldrun-owned top-level (the
+    /// main window AND detached subwindows) shares this pid, exactly as they share
+    /// the `eldrun` WM_CLASS on X11.
+    self_pid: u32,
+    /// Idempotency latch for `cleanup` (mirrors x11.rs `cleaned_up`).
+    cleaned_up: Mutex<bool>,
+}
+
+impl WindowsBackend {
+    pub fn new() -> Self {
+        Self {
+            state: Mutex::new(WindowsParkState::default()),
+            self_pid: unsafe { GetCurrentProcessId() },
+            cleaned_up: Mutex::new(false),
+        }
+    }
+
+    fn is_parkable(&self, window_id: u64) -> bool {
+        self.state.lock().unwrap().is_parkable(window_id)
+    }
+
+    /// Whether `hwnd` must NEVER be hidden. Combines owning-process identity (any
+    /// Eldrun-owned window) with the protected-process-name list (desktop shell +
+    /// Eldrun-named helpers). The Windows analog of x11.rs `is_protected`. The
+    /// parkable override is consulted by callers BEFORE this gate (see
+    /// show/hide_window), identical to X11's ordering.
+    fn is_protected(&self, hwnd: HWND) -> bool {
+        let Some(pid) = window_pid(hwnd) else {
+            // No owning pid — be conservative and treat it as protected.
+            return true;
+        };
+        // (a) Eldrun's own window (main or detached): the `eldrun` WM_CLASS analog.
+        if pid == self.self_pid {
+            return true;
+        }
+        // (b) Otherwise key on the owning process's executable basename. This
+        // name backstop only reliably covers same-session user processes; a
+        // failed lookup (cross-session/secured/PPL processes such as dwm.exe or
+        // elevated apps) is treated as NOT protected. That is safe because the
+        // real guarantee is the tracked-set invariant — `hide_window` is only
+        // ever called with ids from the active project's tracked window set, and
+        // such system windows never enter it (they cannot pass
+        // `is_candidate_window`). Eldrun's own windows are independently shielded
+        // by `self_pid`, so the name list is a defense-in-depth backstop for
+        // user-session shell windows, not the primary safety mechanism.
+        match process_exe_basename(pid) {
+            Some(basename) => is_protected_process_name(&basename),
+            None => {
+                eprintln!("windows backend: could not resolve exe basename for pid {pid}; treating as parkable");
+                false
+            }
+        }
+    }
+}
 
 impl WorkspaceBackend for WindowsBackend {
     fn name(&self) -> &'static str {
@@ -43,20 +122,41 @@ impl WorkspaceBackend for WindowsBackend {
         if !is_window(hwnd) {
             return Ok(());
         }
+        // Override-before-protected, exactly like x11.rs: a detached Eldrun
+        // subwindow (same self_pid, normally protected) is still restored when it
+        // has been opted in. The main window can never be in the override
+        // (structural guard in `add_parkable`).
+        if !self.is_parkable(window_id) && self.is_protected(hwnd) {
+            return Ok(());
+        }
+        // Best-effort defense: pull a window the user dragged onto another real
+        // desktop back onto Eldrun's. Focus-stealing semantics differ from X11's
+        // StackMode::Above raise (SetForegroundWindow frequently no-ops unless
+        // Eldrun is already foreground), but the restore is what matters.
         if let Ok(desktop_id) = current_desktop_id() {
             let _ = move_window_to_desktop(hwnd, desktop_id);
         }
         restore_and_raise(hwnd);
+        self.state.lock().unwrap().unmark_parked(window_id);
         Ok(())
     }
 
     fn hide_window(&self, window_id: u64) -> Result<(), String> {
         let hwnd = hwnd_from_u64(window_id)?;
-        if is_window(hwnd) {
-            unsafe {
-                let _ = ShowWindow(hwnd, SW_HIDE);
-            }
+        if !is_window(hwnd) {
+            return Ok(());
+        }
+        // See show_window: the override lets a detached subwindow park; the main
+        // window can never be in the override (structural guard). Because Eldrun
+        // windows are protected by self_pid and the main window id can never enter
+        // the override, the main Eldrun window can NEVER be SW_HIDE'd here.
+        if !self.is_parkable(window_id) && self.is_protected(hwnd) {
+            return Ok(());
+        }
+        unsafe {
+            let _ = ShowWindow(hwnd, SW_HIDE);
         }
+        self.state.lock().unwrap().mark_parked(window_id);
         Ok(())
     }
 
@@ -66,56 +166,219 @@ impl WorkspaceBackend for WindowsBackend {
         Ok(())
     }
 
+    fn set_parkable(&self, window_id: u64) {
+        self.state.lock().unwrap().add_parkable(window_id);
+    }
+
+    fn unset_parkable(&self, window_id: u64) {
+        self.state.lock().unwrap().remove_parkable(window_id);
+    }
+
+    fn set_main_window_id(&self, window_id: u64) {
+        self.state.lock().unwrap().set_main(window_id);
+    }
+
+    fn position_window(&self, window_id: u64, x: i32, y: i32) -> Result<(), String> {
+        let hwnd = hwnd_from_u64(window_id)?;
+        if !is_window(hwnd) {
+            return Ok(());
+        }
+        // Move only — virtual-screen pixels map to whichever monitor contains
+        // (x, y), so no monitor enumeration is needed (the Windows analog of
+        // x11.rs positioning in root coordinates). Size, z-order and activation
+        // are left untouched.
+        // SAFETY: hwnd was validated by `is_window` above; SetWindowPos with
+        // SWP_NOSIZE ignores the zero width/height arguments.
+        unsafe {
+            SetWindowPos(hwnd, None, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE)
+                .map_err(|e| format!("SetWindowPos: {e}"))
+        }
+    }
+
     fn cleanup(&self) -> Result<(), String> {
-        // No virtual desktops are created or switched by this backend, so there
-        // is no desktop topology to restore.
+        let mut cleaned_up = self.cleaned_up.lock().unwrap();
+        if *cleaned_up {
+            return Ok(());
+        }
+        *cleaned_up = true;
+        drop(cleaned_up);
+
+        // Restore exactly the windows Eldrun hid (the SW_HIDE analog of x11.rs
+        // cleanup moving PARKED_DESKTOP windows back to ACTIVE_DESKTOP).
+        let parked = self.state.lock().unwrap().drain_parked();
+        for window_id in parked {
+            let Ok(hwnd) = hwnd_from_u64(window_id) else {
+                continue;
+            };
+            if !is_window(hwnd) {
+                continue;
+            }
+            // Re-check protection: HWND numeric values are recycled by the OS, so
+            // a parked window that closed mid-session may have had its HWND reused
+            // by an unrelated (possibly protected) window. Never un-hide/raise a
+            // recycled-into-protected window. Mirrors x11.rs cleanup's is_protected
+            // skip (x11.rs:211).
+            if self.is_protected(hwnd) {
+                continue;
+            }
+            restore_and_raise(hwnd);
+        }
+        // No virtual desktops were created or switched by this backend, so there
+        // is no desktop topology to restore (unlike x11.rs).
         Ok(())
     }
 }
 
+impl Drop for WindowsBackend {
+    fn drop(&mut self) {
+        // Mirrors x11.rs: normal teardown always un-hides project windows even if
+        // the explicit cleanup command is missed.
+        let _ = self.cleanup();
+    }
+}
+
 pub fn list_window_ids() -> Vec<u64> {
     enumerate_windows().into_iter().map(hwnd_to_u64).collect()
 }
 
+/// Ensure the main window participates in Aero Snap (drag to the top edge →
+/// maximize; drag to a side edge → half-tile) and is OS-resizable.
+///
+/// A borderless wry window (`decorations: false`) is created WITHOUT the
+/// `WS_MAXIMIZEBOX` / `WS_THICKFRAME` styles, and Windows only offers snap during
+/// the native move loop (`startDragging`) for windows that carry them — so without
+/// this the header drag never snaps to the screen edges. We OR the two styles in
+/// (idempotent) and force a frame recalculation so the change takes effect. wry's
+/// own `WM_NCCALCSIZE` handling keeps the added sizing border visually frameless,
+/// so the custom title bar / borderless look is unaffected. Called once at startup
+/// with the Tauri-provided HWND.
+pub fn enable_aero_snap(window_id: u64) {
+    let Ok(hwnd) = hwnd_from_u64(window_id) else {
+        return;
+    };
+    if !is_window(hwnd) {
+        return;
+    }
+    unsafe {
+        let style = GetWindowLongPtrW(hwnd, GWL_STYLE);
+        if style == 0 {
+            return; // couldn't read the style; leave the window untouched
+        }
+        let wanted = style | (WS_THICKFRAME.0 as isize) | (WS_MAXIMIZEBOX.0 as isize);
+        if wanted == style {
+            return; // already snappable — nothing to do
+        }
+        SetWindowLongPtrW(hwnd, GWL_STYLE, wanted);
+        // Apply the style change immediately; the SWP_NO* flags mean only the frame
+        // recalculation happens (no move/resize/restack/activation).
+        let _ = SetWindowPos(
+            hwnd,
+            None,
+            0,
+            0,
+            0,
+            0,
+            SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED,
+        );
+    }
+}
+
+/// Resolve a top-level window owned by `pid` OR any of its descendants. A
+/// launcher stub commonly spawns the real GUI exe as a CHILD, so the visible
+/// top-level's owning pid is a descendant of — not equal to — the spawned pid.
+/// `descendant_pids(&[pid])` always includes the root pid, so the exact-pid case
+/// is still covered. The X11 analog resolves via `_NET_WM_PID`; this is the
+/// Windows equivalent that also tolerates the child-process hand-off. With
+/// `attempts == 1` this does a single no-sleep enumeration (used by the
+/// hide-time resolver, which must not block the switch worker).
 pub fn find_window_for_pid(pid: u32, attempts: usize) -> Option<u64> {
-    for _ in 0..attempts {
+    for attempt in 0..attempts {
+        let pids = crate::sysstat::descendant_pids(&[pid]);
         if let Some(hwnd) = enumerate_windows()
             .into_iter()
-            .find(|&hwnd| window_pid(hwnd) == Some(pid))
+            .find(|&hwnd| window_pid(hwnd).map_or(false, |p| pids.contains(&p)))
         {
             return Some(hwnd_to_u64(hwnd));
         }
-        thread::sleep(Duration::from_millis(100));
+        if attempt + 1 < attempts {
+            thread::sleep(Duration::from_millis(100));
+        }
     }
     None
 }
 
 pub fn find_new_window(before: &[u64], attempts: usize) -> Option<u64> {
-    for _ in 0..attempts {
+    for attempt in 0..attempts {
         if let Some(hwnd) = enumerate_windows()
             .into_iter()
+            // Mirror x11.rs's `!w.protected` filter: never latch onto Eldrun's
+            // own or a protected shell window (explorer/dwm/…) that happens to
+            // appear during the poll — only a genuinely new app window.
+            .filter(|&hwnd| !is_protected_owner(hwnd))
             .map(hwnd_to_u64)
             .find(|id| !before.contains(id))
         {
             return Some(hwnd);
         }
-        thread::sleep(Duration::from_millis(100));
+        if attempt + 1 < attempts {
+            thread::sleep(Duration::from_millis(100));
+        }
     }
     None
 }
 
+/// The ROOT top-level window currently under the mouse cursor, as a u64 id.
+/// The Windows analog of x11.rs `frontmost_window_under_pointer`, used by the
+/// popout occlusion check (#42): a file drop over a popout's bounds must not
+/// merge into a popout that is actually behind another window. `WindowFromPoint`
+/// returns the deepest child at the point (a drop usually lands on the webview
+/// child HWND), so it is resolved to its `GA_ROOT` ancestor to compare against
+/// the popout's registered top-level HWND.
+pub fn frontmost_window_under_cursor() -> Option<u64> {
+    // SAFETY: plain Win32 calls on stack-owned data; WindowFromPoint/GetAncestor
+    // return null HWNDs on failure, which are checked before use.
+    unsafe {
+        let mut pt = POINT::default();
+        GetCursorPos(&mut pt).ok()?;
+        let hwnd = WindowFromPoint(pt);
+        if hwnd.0.is_null() {
+            return None;
+        }
+        let root = GetAncestor(hwnd, GA_ROOT);
+        let top = if root.0.is_null() { hwnd } else { root };
+        Some(hwnd_to_u64(top))
+    }
+}
+
+/// Whether `hwnd`'s owning process is Eldrun itself or a protected shell/system
+/// process. Free helper (no `&self`) so `find_new_window` can drop such windows
+/// before they ever enter a tracked set — the FFI-side analog of x11.rs's
+/// `w.protected` flag. Owning-process identity (self) is checked directly here;
+/// the name list reuses the pure `is_protected_process_name`.
+fn is_protected_owner(hwnd: HWND) -> bool {
+    let Some(pid) = window_pid(hwnd) else {
+        return true; // no owner → conservatively protected
+    };
+    if pid == unsafe { GetCurrentProcessId() } {
+        return true; // Eldrun's own window
+    }
+    match process_exe_basename(pid) {
+        Some(basename) => is_protected_process_name(&basename),
+        None => false,
+    }
+}
+
 fn current_desktop_id() -> Result<GUID, String> {
     let manager = virtual_desktop_manager()?;
     let hwnd = unsafe { GetForegroundWindow() };
-    if hwnd.0 == 0 {
+    if hwnd.0.is_null() {
         return Err("no foreground window for virtual desktop detection".to_string());
     }
-    let mut desktop = GUID::zeroed();
-    unsafe {
+    let desktop = unsafe {
         manager
-            .GetWindowDesktopId(hwnd, &mut desktop)
-            .map_err(|e| format!("GetWindowDesktopId: {e}"))?;
-    }
+            .GetWindowDesktopId(hwnd)
+            .map_err(|e| format!("GetWindowDesktopId: {e}"))?
+    };
     Ok(desktop)
 }
 
@@ -130,13 +393,40 @@ fn move_window_to_desktop(hwnd: HWND, desktop: GUID) -> Result<(), String> {
 }
 
 fn virtual_desktop_manager() -> Result<IVirtualDesktopManager, String> {
+    ensure_com_initialized();
     unsafe {
-        let _ = CoInitializeEx(None, COINIT_APARTMENTTHREADED);
         CoCreateInstance(&VirtualDesktopManager, None, CLSCTX_INPROC_SERVER)
             .map_err(|e| format!("VirtualDesktopManager: {e}"))
     }
 }
 
+/// Initialize COM for the calling thread exactly once per thread, for the
+/// thread's lifetime. This is the only COM init Eldrun's Windows backend needs
+/// (the best-effort `MoveWindowToDesktop` defense); parking never touches COM.
+///
+/// We deliberately do NOT pair this with `CoUninitialize`: the apartment is
+/// reused by every later `MoveWindowToDesktop` on this thread, so it is
+/// intentionally process/thread-lifetime state. The `Cell` latch means each
+/// thread issues at most ONE `CoInitializeEx`, so there is no per-call refcount
+/// leak (the old code re-init'd on every call). `S_FALSE` (already initialized)
+/// and `RPC_E_CHANGED_MODE` (thread already MTA — common on Tauri worker
+/// threads) are both fine: `CoCreateInstance` works in either apartment, so any
+/// outcome counts as "ready" and the latch is set regardless.
+fn ensure_com_initialized() {
+    thread_local! {
+        static COM_READY: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+    }
+    COM_READY.with(|ready| {
+        if ready.get() {
+            return;
+        }
+        unsafe {
+            let _hr = CoInitializeEx(None, COINIT_APARTMENTTHREADED);
+        }
+        ready.set(true);
+    });
+}
+
 fn enumerate_windows() -> Vec<HWND> {
     let mut windows = Vec::<HWND>::new();
     unsafe {
@@ -160,10 +450,10 @@ unsafe extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
 
 fn is_candidate_window(hwnd: HWND) -> bool {
     unsafe {
-        IsWindow(hwnd).as_bool()
+        IsWindow(Some(hwnd)).as_bool()
             && IsWindowVisible(hwnd).as_bool()
-            && GetParent(hwnd).0 == 0
-            && GetWindow(hwnd, GW_OWNER).0 == 0
+            && GetParent(hwnd).map_or(true, |h| h.0.is_null())
+            && GetWindow(hwnd, GW_OWNER).map_or(true, |h| h.0.is_null())
     }
 }
 
@@ -172,14 +462,19 @@ fn restore_and_raise(hwnd: HWND) {
         return;
     }
     unsafe {
-        let _ = ShowWindow(hwnd, SW_RESTORE);
+        // `SW_SHOW` (not `SW_RESTORE`) is the faithful inverse of the `SW_HIDE`
+        // used to park: it un-hides the window while preserving its prior
+        // maximized/normal placement. `SW_RESTORE` would also un-maximize, so a
+        // maximized project app would lose that state on every switch-back. The
+        // explicit raise below handles bringing it to front.
+        let _ = ShowWindow(hwnd, SW_SHOW);
         let _ = BringWindowToTop(hwnd);
         let _ = SetForegroundWindow(hwnd);
     }
 }
 
 fn is_window(hwnd: HWND) -> bool {
-    unsafe { IsWindow(hwnd).as_bool() }
+    unsafe { IsWindow(Some(hwnd)).as_bool() }
 }
 
 fn window_pid(hwnd: HWND) -> Option<u32> {
@@ -190,12 +485,35 @@ fn window_pid(hwnd: HWND) -> Option<u32> {
     (pid != 0).then_some(pid)
 }
 
+/// The owning process's executable basename for `pid` (file name only, e.g.
+/// "explorer.exe"). Returns `None` if the process can't be queried — this
+/// reliably succeeds only for same-session user processes; cross-session or
+/// secured processes (e.g. `dwm.exe`, elevated apps) are access-denied. Callers
+/// treat `None` as NOT protected, which is safe because such windows are never
+/// in the tracked set passed to `hide_window`, and Eldrun's own windows are
+/// independently shielded by `self_pid`.
+fn process_exe_basename(pid: u32) -> Option<String> {
+    // SAFETY: the handle is closed before returning regardless of the query
+    // result; the buffer is sized to MAX_PATH and `len` bounds the read.
+    unsafe {
+        let handle = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid).ok()?;
+        let mut buf = [0u16; 260];
+        let mut len = buf.len() as u32;
+        let result =
+            QueryFullProcessImageNameW(handle, PROCESS_NAME_WIN32, PWSTR(buf.as_mut_ptr()), &mut len);
+        let _ = CloseHandle(handle);
+        result.ok()?;
+        let full = String::from_utf16_lossy(&buf[..len as usize]);
+        full.rsplit(['\\', '/']).next().map(|s| s.to_string())
+    }
+}
+
 fn hwnd_to_u64(hwnd: HWND) -> u64 {
     hwnd.0 as usize as u64
 }
 
 fn hwnd_from_u64(window_id: u64) -> Result<HWND, String> {
     isize::try_from(window_id)
-        .map(HWND)
+        .map(|v| HWND(v as *mut core::ffi::c_void))
         .map_err(|_| format!("invalid windows window id {window_id}"))
 }
diff --git a/src-tauri/src/platform/windows_park.rs b/src-tauri/src/platform/windows_park.rs
new file mode 100644
index 0000000..ad67ced
--- /dev/null
+++ b/src-tauri/src/platform/windows_park.rs
@@ -0,0 +1,247 @@
+//! Pure parking logic for the Windows backend — OS-agnostic, FFI-free.
+//!
+//! Windows ships only the documented `IVirtualDesktopManager` (which can query a
+//! window's desktop GUID and move a window to an *existing* desktop, but cannot
+//! create or switch desktops); creating a dedicated "parked" desktop needs the
+//! undocumented `IVirtualDesktopManagerInternal`, whose IID/vtable churn across
+//! Windows 10/11 builds makes it unsafe to rely on. The Windows backend therefore
+//! "parks" a project's windows by `SW_HIDE`-ing them, tracking the hidden set as
+//! a logical "parked desktop" here.
+//!
+//! This module holds only the pure decision logic so the safety-critical
+//! invariants can be unit tested on any OS (it is NOT `#[cfg]`-gated):
+//!   - `WindowsParkState` — the parkable override + the structural main-window
+//!     guard (mirroring x11.rs `ParkableState`) + the SW_HIDE "parked set" that
+//!     stands in for X11's PARKED_DESKTOP membership.
+//!   - `is_protected_process_name` — the Windows analog of x11.rs
+//!     `is_protected_class` (there is no WM_CLASS on Windows, so protection keys
+//!     on the owning process executable basename; owning-process *identity* is
+//!     handled in the FFI layer via Eldrun's own pid).
+
+use std::collections::HashSet;
+
+/// Executable basenames whose top-level windows must NEVER be parked: the
+/// desktop shell and Eldrun-named helpers. Mirrors x11.rs `PROTECTED_CLASSES`.
+/// Eldrun's own windows are additionally shielded by owning-process identity in
+/// the FFI layer, so `eldrun` here only guards same-named helper processes.
+pub const PROTECTED_PROCESSES: &[&str] = &[
+    "eldrun",
+    "explorer",
+    "dwm",
+    "shellexperiencehost",
+    "startmenuexperiencehost",
+    "searchhost",
+    "textinputhost",
+    "applicationframehost",
+];
+
+/// Pure process-name check — the Windows analog of `is_protected_class`.
+///
+/// Lowercases, drops a trailing `.exe`, and matches whole segments (split on the
+/// usual name separators) against `PROTECTED_PROCESSES`. Matching whole segments
+/// rather than raw substrings keeps a process merely *containing* a protected
+/// token (e.g. `eldrunner.exe`) parkable — directly mirroring the X11 segment
+/// logic and its `kwinter`/`eldrunner` regression tests.
+pub fn is_protected_process_name(exe_basename: &str) -> bool {
+    let lowered = exe_basename.to_lowercase();
+    let stem = lowered.strip_suffix(".exe").unwrap_or(&lowered);
+    stem.split(['.', '-', '_', ' '])
+        .any(|segment| PROTECTED_PROCESSES.contains(&segment))
+}
+
+/// The parkable override + the structurally-protected main window id + the set
+/// of currently-hidden ("parked") window ids. Pure over its own state —
+/// unit-testable without Win32. Mirrors x11.rs `ParkableState`, with the added
+/// `parked` set as the SW_HIDE analog of X11's PARKED_DESKTOP membership: it
+/// records exactly which HWNDs Eldrun hid so cleanup restores precisely those.
+#[derive(Default)]
+pub struct WindowsParkState {
+    override_ids: HashSet<u64>,
+    /// The main Eldrun window's HWND id, once known. `add_parkable` refuses to
+    /// add this id, keeping "the main window is never parked" structural.
+    main_window_id: Option<u64>,
+    /// Window ids currently `SW_HIDE`-parked by Eldrun.
+    parked: HashSet<u64>,
+}
+
+impl WindowsParkState {
+    /// Add `id` to the parkable override unless it is the main window id. Returns
+    /// whether it was added. Pure over its own state — unit-testable without
+    /// Win32. Mirrors x11.rs `ParkableState::add_parkable`.
+    pub fn add_parkable(&mut self, id: u64) -> bool {
+        if self.main_window_id == Some(id) {
+            // STRUCTURAL GUARD: the main window must never be parkable, even if a
+            // caller mistakenly asks. Refuse silently (debug-assert in tests).
+            debug_assert!(false, "attempted to mark the MAIN Eldrun window parkable");
+            return false;
+        }
+        self.override_ids.insert(id)
+    }
+
+    /// Remove `id` from the parkable override (on dock-back / close).
+    pub fn remove_parkable(&mut self, id: u64) {
+        self.override_ids.remove(&id);
+    }
+
+    pub fn is_parkable(&self, id: u64) -> bool {
+        self.override_ids.contains(&id)
+    }
+
+    /// Record the MAIN Eldrun window's id so `add_parkable` can structurally
+    /// refuse to ever add it to the override.
+    pub fn set_main(&mut self, id: u64) {
+        self.main_window_id = Some(id);
+    }
+
+    /// Record `id` as `SW_HIDE`-parked.
+    pub fn mark_parked(&mut self, id: u64) {
+        self.parked.insert(id);
+    }
+
+    /// Forget `id` from the parked set (it was shown again).
+    pub fn unmark_parked(&mut self, id: u64) {
+        self.parked.remove(&id);
+    }
+
+    /// Take the whole parked set, clearing it. Used by `cleanup` to restore
+    /// exactly the windows Eldrun hid (the SW_HIDE analog of X11 moving
+    /// PARKED_DESKTOP windows back to ACTIVE_DESKTOP).
+    pub fn drain_parked(&mut self) -> Vec<u64> {
+        self.parked.drain().collect()
+    }
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+//
+// These exercise only the pure structs/fns (no Win32 calls), so they compile and
+// run on any OS (Linux/macOS CI included), even though the FFI backend in
+// `windows.rs` is `#[cfg(target_os = "windows")]`.
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ── is_protected_process_name ──────────────────────────────────────────
+
+    #[test]
+    fn eldrun_process_is_always_protected() {
+        // The most critical invariant: Eldrun's own helper processes must NEVER
+        // be SW_HIDE-parked. (The main window is doubly protected via self_pid.)
+        assert!(is_protected_process_name("eldrun.exe"));
+        assert!(is_protected_process_name("eldrun"));
+        assert!(is_protected_process_name("ELDRUN")); // case-insensitive
+        assert!(is_protected_process_name("Eldrun.EXE"));
+    }
+
+    #[test]
+    fn protected_processes_constant_includes_eldrun() {
+        // Regression guard: if someone removes "eldrun" from PROTECTED_PROCESSES
+        // by accident, this test fails immediately.
+        assert!(
+            PROTECTED_PROCESSES.contains(&"eldrun"),
+            "PROTECTED_PROCESSES must contain \"eldrun\" or Eldrun helpers could be hidden"
+        );
+    }
+
+    #[test]
+    fn desktop_shell_processes_are_protected() {
+        assert!(is_protected_process_name("explorer.exe"));
+        assert!(is_protected_process_name("dwm.exe"));
+        assert!(is_protected_process_name("ShellExperienceHost.exe"));
+        assert!(is_protected_process_name("ApplicationFrameHost.exe"));
+    }
+
+    #[test]
+    fn ordinary_app_process_is_not_protected() {
+        // Ordinary app windows must be parkable.
+        assert!(!is_protected_process_name("code.exe"));
+        assert!(!is_protected_process_name("firefox.exe"));
+        assert!(!is_protected_process_name("konsole"));
+        assert!(!is_protected_process_name("")); // empty → not protected
+    }
+
+    #[test]
+    fn process_merely_containing_protected_token_is_parkable() {
+        // Segment matching, not substring matching: an unrelated process whose
+        // name happens to contain "eldrun"/"explorer" must remain parkable — the
+        // direct analog of x11's `kwinter`/`eldrunner` test.
+        assert!(!is_protected_process_name("eldrunner.exe"));
+        assert!(!is_protected_process_name("explorerplus.exe"));
+    }
+
+    #[test]
+    fn find_new_window_protection_rejects_shell_accepts_ordinary() {
+        // The FFI-free name half of `windows.rs::is_protected_owner`, which
+        // `find_new_window` uses to skip Eldrun-self/shell windows that appear
+        // during the launch poll. A protected basename is rejected; an ordinary
+        // app basename is accepted (and would thus be a candidate new window).
+        assert!(is_protected_process_name("explorer.exe"));
+        assert!(is_protected_process_name("ApplicationFrameHost.exe"));
+        assert!(!is_protected_process_name("code.exe"));
+    }
+
+    // ── parkable override (#42) ─────────────────────────────────────────────
+
+    #[test]
+    fn overridden_id_is_parkable() {
+        // A detached subwindow's id, opted in, must be parkable despite its
+        // owning process being Eldrun (protected) — that is the #42 parking link.
+        let mut state = WindowsParkState::default();
+        assert!(state.add_parkable(42));
+        assert!(state.is_parkable(42));
+    }
+
+    #[test]
+    fn non_overridden_id_is_not_parkable() {
+        let state = WindowsParkState::default();
+        assert!(!state.is_parkable(99), "ids not opted in stay non-parkable");
+    }
+
+    #[test]
+    fn main_window_id_can_never_become_parkable() {
+        // The single most safety-critical invariant: the MAIN window must never
+        // be parked. `add_parkable` refuses its id structurally.
+        let mut state = WindowsParkState::default();
+        state.set_main(7);
+        // In debug builds add_parkable debug_asserts; in release it returns false.
+        // Either way the id must NOT be in the override set afterwards.
+        let added = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| state.add_parkable(7)));
+        let _ = added; // result intentionally ignored
+        assert!(
+            !state.is_parkable(7),
+            "the main window id must never enter the parkable override"
+        );
+    }
+
+    #[test]
+    fn other_ids_still_parkable_after_main_window_set() {
+        let mut state = WindowsParkState::default();
+        state.set_main(7);
+        assert!(state.add_parkable(8));
+        assert!(state.is_parkable(8));
+        assert!(!state.is_parkable(7));
+    }
+
+    #[test]
+    fn remove_parkable_clears_override() {
+        let mut state = WindowsParkState::default();
+        state.add_parkable(8);
+        assert!(state.is_parkable(8));
+        state.remove_parkable(8);
+        assert!(!state.is_parkable(8));
+    }
+
+    // ── parked-set bookkeeping (SW_HIDE analog of PARKED_DESKTOP) ───────────
+
+    #[test]
+    fn mark_unmark_drain_parked_round_trips() {
+        let mut state = WindowsParkState::default();
+        state.mark_parked(10);
+        state.mark_parked(11);
+        state.unmark_parked(10);
+        let drained = state.drain_parked();
+        assert_eq!(drained, vec![11]);
+        // drain_parked clears the set, so a second drain is empty.
+        assert!(state.drain_parked().is_empty());
+    }
+}
diff --git a/src-tauri/src/platform/x11.rs b/src-tauri/src/platform/x11.rs
index d4ede19..18296f6 100644
--- a/src-tauri/src/platform/x11.rs
+++ b/src-tauri/src/platform/x11.rs
@@ -195,6 +195,36 @@ impl WorkspaceBackend for X11Backend {
         self.parkable.lock().unwrap().main_window_id = Some(window_id);
     }
 
+    fn position_window(&self, window_id: u64, x: i32, y: i32) -> Result<(), String> {
+        let wid =
+            window_from_u64(window_id).ok_or_else(|| format!("invalid x11 window id {window_id}"))?;
+        // Geometry only — root-window pixels map to whichever monitor contains
+        // (x, y), so no monitor enumeration is needed. Do NOT touch
+        // _NET_WM_DESKTOP here: this is placement, not workspace parking.
+        // Best-effort re-apply: an app can force its own geometry right after
+        // mapping, so re-issue a few times. Never a hard error — positioning a
+        // foreign app is inherently best-effort.
+        let mut last_err = None;
+        for attempt in 0..3 {
+            if attempt > 0 {
+                thread::sleep(Duration::from_millis(40));
+            }
+            last_err = self
+                .conn
+                .send_and_check_request(&x::ConfigureWindow {
+                    window: wid,
+                    value_list: &[x::ConfigWindow::X(x), x::ConfigWindow::Y(y)],
+                })
+                .map_err(|e| e.to_string())
+                .and_then(|()| self.conn.flush().map_err(|e| e.to_string()))
+                .err();
+        }
+        match last_err {
+            Some(e) => Err(e),
+            None => Ok(()),
+        }
+    }
+
     fn cleanup(&self) -> Result<(), String> {
         let mut cleaned_up = self.cleaned_up.lock().unwrap();
         if *cleaned_up {
@@ -558,6 +588,98 @@ pub fn find_window_for_title(target: &str, attempts: usize) -> Option<u64> {
     None
 }
 
+/// The topmost (front-most) mapped client window under the X11 pointer, by its
+/// X11 id, or `None` if the pointer is over no client (bare root) or the query
+/// fails. Used to decide whether a detached subwindow is actually at the front
+/// at a drop point: an occluded popout (covered by the main window or another
+/// app) must NOT capture a file drop dragged "onto" it (#42).
+///
+/// Walks `_NET_CLIENT_LIST_STACKING` top-to-bottom (it is stored bottom-to-top),
+/// skipping non-viewable windows and windows on another desktop, and returns the
+/// first whose root-space geometry contains the pointer. Uses the pointer's
+/// *current* position (the release point), so no logical/physical px conversion
+/// is needed — everything stays in X11 physical coords.
+pub fn frontmost_window_under_pointer() -> Option<u64> {
+    let (conn, screen_num) = xcb::Connection::connect(None).ok()?;
+    let root = root_window(&conn, screen_num);
+
+    let ptr = conn
+        .wait_for_reply(conn.send_request(&x::QueryPointer { window: root }))
+        .ok()?;
+    let (px, py) = (ptr.root_x() as i32, ptr.root_y() as i32);
+
+    let stacking_atom = intern_atom(&conn, b"_NET_CLIENT_LIST_STACKING").ok()?;
+    let net_current_desktop = intern_atom(&conn, b"_NET_CURRENT_DESKTOP").ok()?;
+    let net_wm_desktop = intern_atom(&conn, b"_NET_WM_DESKTOP").ok()?;
+    let cur_desktop = get_cardinal(&conn, screen_num, net_current_desktop);
+
+    let cookie = conn.send_request(&x::GetProperty {
+        delete: false,
+        window: root,
+        property: stacking_atom,
+        r#type: x::ATOM_WINDOW,
+        long_offset: 0,
+        long_length: 1024,
+    });
+    let reply = conn.wait_for_reply(cookie).ok()?;
+    let windows = reply.value::<Window>();
+
+    for &wid in windows.iter().rev() {
+        // Skip windows that aren't actually on screen.
+        let viewable = conn
+            .wait_for_reply(conn.send_request(&x::GetWindowAttributes { window: wid }))
+            .map(|a| a.map_state() == x::MapState::Viewable)
+            .unwrap_or(false);
+        if !viewable {
+            continue;
+        }
+        // Skip windows on a different desktop (a parked popout, another ws).
+        // `0xFFFF_FFFF` means "all desktops" (sticky) and always qualifies.
+        if let Some(cur) = cur_desktop {
+            let desktop = conn
+                .wait_for_reply(conn.send_request(&x::GetProperty {
+                    delete: false,
+                    window: wid,
+                    property: net_wm_desktop,
+                    r#type: x::ATOM_CARDINAL,
+                    long_offset: 0,
+                    long_length: 1,
+                }))
+                .ok()
+                .and_then(|r| r.value::<u32>().first().copied());
+            if let Some(d) = desktop {
+                if d != cur && d != 0xFFFF_FFFF {
+                    continue;
+                }
+            }
+        }
+        // Root-space geometry: TranslateCoordinates handles WM reparenting, so the
+        // origin is correct even though the window sits inside a frame.
+        let geo = match conn
+            .wait_for_reply(conn.send_request(&x::GetGeometry {
+                drawable: x::Drawable::Window(wid),
+            })) {
+            Ok(g) => g,
+            Err(_) => continue,
+        };
+        let trans = match conn.wait_for_reply(conn.send_request(&x::TranslateCoordinates {
+            src_window: wid,
+            dst_window: root,
+            src_x: 0,
+            src_y: 0,
+        })) {
+            Ok(t) => t,
+            Err(_) => continue,
+        };
+        let (ox, oy) = (trans.dst_x() as i32, trans.dst_y() as i32);
+        let (w, h) = (geo.width() as i32, geo.height() as i32);
+        if px >= ox && px < ox + w && py >= oy && py < oy + h {
+            return Some(wid.resource_id() as u64);
+        }
+    }
+    None
+}
+
 fn is_cinnamon_desktop() -> bool {
     std::env::var("XDG_CURRENT_DESKTOP")
         .unwrap_or_default()
diff --git a/src-tauri/src/schema/calendar.rs b/src-tauri/src/schema/calendar.rs
new file mode 100644
index 0000000..3255a12
--- /dev/null
+++ b/src-tauri/src/schema/calendar.rs
@@ -0,0 +1,585 @@
+//! `~/.local/share/eldrun/calendar.json` — the native calendar's on-disk model.
+//!
+//! The file is an object (`CalendarData`): a list of named calendars, the events
+//! filed under them, and the tasks (VTODO-style to-dos). Version 1 of this file
+//! was a bare JSON array of start-time-only events; `CalendarFile` still reads
+//! that shape and `migrate_legacy` lifts it into the current model, so an
+//! existing calendar survives the upgrade untouched. Eldrun always *writes* the
+//! current shape.
+//!
+//! Times are **local wall-clock**, never UTC: `"YYYY-MM-DDTHH:MM"` for a timed
+//! event and `"YYYY-MM-DD"` for an all-day one. This keeps "09:00 standup"
+//! at 09:00 regardless of the machine's timezone, which is what a personal
+//! calendar wants; it is also why no timezone crate is pulled in.
+//!
+//! Every non-required field defaults and each record keeps an `extra` flatten,
+//! so a newer or hand-edited file round-trips without losing keys.
+
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+/// Current `version` written into `calendar.json`.
+pub const CALENDAR_VERSION: u32 = 2;
+
+/// Id of the calendar that legacy events (and events with no calendar) land in.
+pub const DEFAULT_CALENDAR_ID: &str = "default";
+
+/// Fallback duration for a timed event whose end is missing/invalid — also what a
+/// migrated legacy event (which only had a start) gets.
+pub const DEFAULT_EVENT_MINUTES: i64 = 60;
+
+// ── Calendars ───────────────────────────────────────────────────────────────
+
+/// One named, colored calendar in the sidebar list.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Calendar {
+    pub id: String,
+    pub name: String,
+    /// CSS color the calendar's events render in (e.g. `"#4aa3df"`).
+    pub color: String,
+    /// Unchecked in the sidebar → its events drop out of every view.
+    #[serde(default = "default_true")]
+    pub visible: bool,
+    /// Read-only calendars (e.g. an imported feed) reject edits in the UI.
+    #[serde(default)]
+    pub readonly: bool,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+impl Calendar {
+    /// The calendar every migrated/unfiled event belongs to.
+    pub fn default_calendar() -> Self {
+        Self {
+            id: DEFAULT_CALENDAR_ID.to_string(),
+            name: "Personal".to_string(),
+            color: "#4aa3df".to_string(),
+            visible: true,
+            readonly: false,
+            extra: HashMap::new(),
+        }
+    }
+}
+
+// ── Recurrence ──────────────────────────────────────────────────────────────
+
+/// How often a recurring event repeats. Mirrors the iCalendar `RRULE` subset
+/// Eldrun supports.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum Freq {
+    #[default]
+    Daily,
+    Weekly,
+    Monthly,
+    Yearly,
+}
+
+/// A recurrence rule. `until` and `count` are mutually exclusive ends; with
+/// neither set the event repeats forever (expansion is always window-bounded, so
+/// "forever" is safe).
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct Rrule {
+    pub freq: Freq,
+    /// Repeat every N periods. `0` is treated as `1` by the expander.
+    #[serde(default = "default_interval")]
+    pub interval: u32,
+    /// Weekly only: weekdays to fire on, `0`=Sunday … `6`=Saturday. Empty → the
+    /// weekday of the event's own start.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub byweekday: Vec<u8>,
+    /// Monthly only: day of month (1–31). `None` → the event's own day of month.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bymonthday: Option<u8>,
+    /// Inclusive last date (`"YYYY-MM-DD"`) the rule may fire on.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub until: Option<String>,
+    /// Total number of occurrences, counting the first.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<u32>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+fn default_interval() -> u32 {
+    1
+}
+
+/// A single occurrence edited away from its master ("this event only"). Keyed by
+/// the occurrence's *original* start, so it survives edits to its own start.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct EventOverride {
+    /// The occurrence's start as the rule generated it — the key.
+    pub occurrence_start: String,
+    /// Fields that differ from the master; anything absent is inherited.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub end: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub notes: Option<String>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+// ── Alarms ──────────────────────────────────────────────────────────────────
+
+/// A reminder, fired `minutes_before` the occurrence starts. Negative values fire
+/// *after* the start (iCalendar allows a positive trigger offset).
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct Alarm {
+    pub minutes_before: i64,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+// ── Events ──────────────────────────────────────────────────────────────────
+
+/// A calendar event.
+///
+/// `start`/`end` are local wall-clock: `"YYYY-MM-DDTHH:MM"` when timed, or
+/// `"YYYY-MM-DD"` when `all_day`. `end` is **exclusive** — following the iCal
+/// convention, an all-day event on the 8th has `start: "2026-07-08"` and
+/// `end: "2026-07-09"`. A multi-day event is simply one whose `end` lands on a
+/// later day than its `start`.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct CalendarEvent {
+    pub id: String,
+    #[serde(default = "default_calendar_id")]
+    pub calendar_id: String,
+    pub start: String,
+    pub end: String,
+    #[serde(default)]
+    pub all_day: bool,
+    pub title: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub location: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub notes: String,
+    /// Category key; maps to a color in the frontend's category palette.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub category: String,
+    /// `"confirmed"` (default) | `"tentative"` | `"cancelled"`.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub status: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub rrule: Option<Rrule>,
+    /// Occurrence starts deleted from the series ("this event only" → delete).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub exdates: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub overrides: Vec<EventOverride>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub alarms: Vec<Alarm>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+fn default_calendar_id() -> String {
+    DEFAULT_CALENDAR_ID.to_string()
+}
+
+// ── Tasks ───────────────────────────────────────────────────────────────────
+
+/// A to-do (VTODO). `due`/`start` use the same local encoding as events; a task
+/// with no `due` simply never appears in the calendar views, only in the task list.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct CalendarTask {
+    pub id: String,
+    #[serde(default = "default_calendar_id")]
+    pub calendar_id: String,
+    pub title: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub notes: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub due: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<String>,
+    /// iCalendar priority: `0` = unset, `1` = highest … `9` = lowest.
+    #[serde(default)]
+    pub priority: u8,
+    /// Completion percentage, 0–100. `100` implies done.
+    #[serde(default)]
+    pub percent: u8,
+    /// Local timestamp the task was completed at; `None` while open.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub completed: Option<String>,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub category: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub alarms: Vec<Alarm>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+// ── The file ────────────────────────────────────────────────────────────────
+
+/// The whole of `calendar.json` in its current shape.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct CalendarData {
+    pub version: u32,
+    #[serde(default)]
+    pub calendars: Vec<Calendar>,
+    #[serde(default)]
+    pub events: Vec<CalendarEvent>,
+    #[serde(default)]
+    pub tasks: Vec<CalendarTask>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+impl Default for CalendarData {
+    fn default() -> Self {
+        Self {
+            version: CALENDAR_VERSION,
+            calendars: vec![Calendar::default_calendar()],
+            events: Vec::new(),
+            tasks: Vec::new(),
+            extra: HashMap::new(),
+        }
+    }
+}
+
+impl CalendarData {
+    /// Guarantee the invariants every reader relies on: at least one calendar
+    /// exists, and every event/task points at a calendar that is actually in the
+    /// list (a dangling `calendar_id` — from a hand-edit or a deleted calendar —
+    /// is refiled into the default rather than rendering invisibly).
+    pub fn normalize(&mut self) {
+        self.version = CALENDAR_VERSION;
+        if self.calendars.is_empty() {
+            self.calendars.push(Calendar::default_calendar());
+        }
+        let known: Vec<&str> = self.calendars.iter().map(|c| c.id.as_str()).collect();
+        let fallback = self.calendars[0].id.clone();
+        let orphan = |id: &String| !known.contains(&id.as_str());
+
+        let refile: Vec<usize> = self
+            .events
+            .iter()
+            .enumerate()
+            .filter(|(_, e)| orphan(&e.calendar_id))
+            .map(|(i, _)| i)
+            .collect();
+        for i in refile {
+            self.events[i].calendar_id = fallback.clone();
+        }
+        let refile: Vec<usize> = self
+            .tasks
+            .iter()
+            .enumerate()
+            .filter(|(_, t)| orphan(&t.calendar_id))
+            .map(|(i, _)| i)
+            .collect();
+        for i in refile {
+            self.tasks[i].calendar_id = fallback.clone();
+        }
+    }
+}
+
+/// A version-1 event: a start moment, and nothing else.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct LegacyEvent {
+    pub id: String,
+    /// `"YYYY-MM-DD"`.
+    pub date: String,
+    /// `"HH:MM"`, or `""` for an all-day event.
+    #[serde(default)]
+    pub time: String,
+    pub title: String,
+    #[serde(default)]
+    pub notes: String,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// What `calendar.json` may deserialize as. Untagged, so serde tries the current
+/// object shape first and falls back to the version-1 array.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum CalendarFile {
+    Current(CalendarData),
+    Legacy(Vec<LegacyEvent>),
+}
+
+impl CalendarFile {
+    /// Collapse either on-disk shape into the current model.
+    pub fn into_data(self) -> CalendarData {
+        let mut data = match self {
+            CalendarFile::Current(data) => data,
+            CalendarFile::Legacy(events) => migrate_legacy(events),
+        };
+        data.normalize();
+        data
+    }
+}
+
+/// Lift version-1 events into the current model.
+///
+/// An all-day legacy event (`time == ""`) becomes a true all-day event spanning
+/// its one day (exclusive end = the next day). A timed one gets a
+/// `DEFAULT_EVENT_MINUTES` duration, since v1 stored no end. Unknown keys ride
+/// along in `extra`.
+pub fn migrate_legacy(events: Vec<LegacyEvent>) -> CalendarData {
+    let events = events
+        .into_iter()
+        .map(|old| {
+            let all_day = old.time.is_empty();
+            let (start, end) = if all_day {
+                (old.date.clone(), add_days(&old.date, 1))
+            } else {
+                let start = format!("{}T{}", old.date, old.time);
+                let end = add_minutes(&start, DEFAULT_EVENT_MINUTES);
+                (start, end)
+            };
+            CalendarEvent {
+                id: old.id,
+                calendar_id: DEFAULT_CALENDAR_ID.to_string(),
+                start,
+                end,
+                all_day,
+                title: old.title,
+                notes: old.notes,
+                extra: old.extra,
+                ..Default::default()
+            }
+        })
+        .collect();
+
+    CalendarData {
+        version: CALENDAR_VERSION,
+        calendars: vec![Calendar::default_calendar()],
+        events,
+        tasks: Vec::new(),
+        extra: HashMap::new(),
+    }
+}
+
+// ── Date math ───────────────────────────────────────────────────────────────
+//
+// Just enough civil-date arithmetic to migrate and validate. The frontend owns
+// the real calendar math (`src/lib/calendarTime.ts`); this exists so the backend
+// never has to parse a date to serve a request.
+
+fn is_leap(y: i32) -> bool {
+    (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
+}
+
+fn days_in_month(y: i32, m: u32) -> u32 {
+    match m {
+        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+        4 | 6 | 9 | 11 => 30,
+        2 if is_leap(y) => 29,
+        2 => 28,
+        _ => 30,
+    }
+}
+
+/// Parse `"YYYY-MM-DD"` (ignoring any `T…` suffix) into `(y, m, d)`.
+fn parse_date(s: &str) -> Option<(i32, u32, u32)> {
+    let date = s.split('T').next()?;
+    let mut parts = date.split('-');
+    let y: i32 = parts.next()?.parse().ok()?;
+    let m: u32 = parts.next()?.parse().ok()?;
+    let d: u32 = parts.next()?.parse().ok()?;
+    if !(1..=12).contains(&m) || d == 0 || d > days_in_month(y, m) {
+        return None;
+    }
+    Some((y, m, d))
+}
+
+/// Add `n` days to a `"YYYY-MM-DD"` date, returning the same format. An
+/// unparseable input is returned unchanged rather than panicking — a corrupt
+/// record should render oddly, not take the app down.
+pub fn add_days(date: &str, n: i64) -> String {
+    let Some((mut y, mut m, mut d)) = parse_date(date) else {
+        return date.to_string();
+    };
+    let mut left = n;
+    while left > 0 {
+        let dim = days_in_month(y, m);
+        if d < dim {
+            d += 1;
+        } else {
+            d = 1;
+            if m == 12 {
+                m = 1;
+                y += 1;
+            } else {
+                m += 1;
+            }
+        }
+        left -= 1;
+    }
+    while left < 0 {
+        if d > 1 {
+            d -= 1;
+        } else {
+            if m == 1 {
+                m = 12;
+                y -= 1;
+            } else {
+                m -= 1;
+            }
+            d = days_in_month(y, m);
+        }
+        left += 1;
+    }
+    format!("{y:04}-{m:02}-{d:02}")
+}
+
+/// Add `n` minutes to a `"YYYY-MM-DDTHH:MM"` timestamp, rolling the date over as
+/// needed. An unparseable input is returned unchanged.
+pub fn add_minutes(stamp: &str, n: i64) -> String {
+    let Some((date, time)) = stamp.split_once('T') else {
+        return stamp.to_string();
+    };
+    let Some((h, mi)) = time.split_once(':') else {
+        return stamp.to_string();
+    };
+    let (Ok(h), Ok(mi)) = (h.parse::<i64>(), mi.parse::<i64>()) else {
+        return stamp.to_string();
+    };
+
+    let total = h * 60 + mi + n;
+    // Euclidean division, so a negative offset rolls back into the previous day.
+    let day_shift = total.div_euclid(24 * 60);
+    let within = total.rem_euclid(24 * 60);
+    let new_date = add_days(date, day_shift);
+    format!("{}T{:02}:{:02}", new_date, within / 60, within % 60)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn add_days_rolls_month_and_year() {
+        assert_eq!(add_days("2026-07-08", 1), "2026-07-09");
+        assert_eq!(add_days("2026-07-31", 1), "2026-08-01");
+        assert_eq!(add_days("2026-12-31", 1), "2027-01-01");
+        assert_eq!(add_days("2026-01-01", -1), "2025-12-31");
+        assert_eq!(add_days("2026-03-01", -1), "2026-02-28");
+    }
+
+    #[test]
+    fn add_days_handles_leap_february() {
+        assert_eq!(add_days("2024-02-28", 1), "2024-02-29");
+        assert_eq!(add_days("2024-03-01", -1), "2024-02-29");
+        assert_eq!(add_days("2026-02-28", 1), "2026-03-01");
+    }
+
+    #[test]
+    fn add_days_leaves_garbage_alone() {
+        assert_eq!(add_days("not-a-date", 1), "not-a-date");
+    }
+
+    #[test]
+    fn add_minutes_rolls_across_midnight() {
+        assert_eq!(add_minutes("2026-07-08T09:00", 60), "2026-07-08T10:00");
+        assert_eq!(add_minutes("2026-07-08T23:30", 60), "2026-07-09T00:30");
+        assert_eq!(add_minutes("2026-07-08T00:15", -30), "2026-07-07T23:45");
+        assert_eq!(add_minutes("2026-12-31T23:00", 120), "2027-01-01T01:00");
+    }
+
+    #[test]
+    fn migrate_timed_legacy_event() {
+        let data = migrate_legacy(vec![LegacyEvent {
+            id: "a".into(),
+            date: "2026-07-08".into(),
+            time: "09:00".into(),
+            title: "standup".into(),
+            notes: "daily".into(),
+            extra: HashMap::new(),
+        }]);
+        assert_eq!(data.version, CALENDAR_VERSION);
+        assert_eq!(data.calendars.len(), 1);
+        let ev = &data.events[0];
+        assert_eq!(ev.start, "2026-07-08T09:00");
+        assert_eq!(ev.end, "2026-07-08T10:00");
+        assert!(!ev.all_day);
+        assert_eq!(ev.title, "standup");
+        assert_eq!(ev.notes, "daily");
+        assert_eq!(ev.calendar_id, DEFAULT_CALENDAR_ID);
+    }
+
+    #[test]
+    fn migrate_all_day_legacy_event() {
+        let data = migrate_legacy(vec![LegacyEvent {
+            id: "a".into(),
+            date: "2026-07-08".into(),
+            time: String::new(),
+            title: "holiday".into(),
+            ..Default::default()
+        }]);
+        let ev = &data.events[0];
+        assert!(ev.all_day);
+        assert_eq!(ev.start, "2026-07-08");
+        // Exclusive end: a one-day all-day event ends on the NEXT day.
+        assert_eq!(ev.end, "2026-07-09");
+    }
+
+    #[test]
+    fn legacy_array_deserializes_through_untagged() {
+        let raw = r#"[{"id":"a","date":"2026-07-08","time":"09:00","title":"standup"}]"#;
+        let file: CalendarFile = serde_json::from_str(raw).unwrap();
+        let data = file.into_data();
+        assert_eq!(data.events.len(), 1);
+        assert_eq!(data.events[0].start, "2026-07-08T09:00");
+    }
+
+    #[test]
+    fn current_object_deserializes_through_untagged() {
+        let raw = r#"{"version":2,"calendars":[],"events":[],"tasks":[]}"#;
+        let file: CalendarFile = serde_json::from_str(raw).unwrap();
+        let data = file.into_data();
+        // normalize() backfills the default calendar.
+        assert_eq!(data.calendars.len(), 1);
+        assert_eq!(data.calendars[0].id, DEFAULT_CALENDAR_ID);
+    }
+
+    #[test]
+    fn normalize_refiles_orphaned_events() {
+        let mut data = CalendarData {
+            version: CALENDAR_VERSION,
+            calendars: vec![Calendar::default_calendar()],
+            events: vec![CalendarEvent {
+                id: "a".into(),
+                calendar_id: "deleted-cal".into(),
+                ..Default::default()
+            }],
+            tasks: vec![CalendarTask {
+                id: "t".into(),
+                calendar_id: "deleted-cal".into(),
+                ..Default::default()
+            }],
+            extra: HashMap::new(),
+        };
+        data.normalize();
+        assert_eq!(data.events[0].calendar_id, DEFAULT_CALENDAR_ID);
+        assert_eq!(data.tasks[0].calendar_id, DEFAULT_CALENDAR_ID);
+    }
+
+    #[test]
+    fn unknown_keys_round_trip() {
+        let raw = r#"{"version":2,"calendars":[],"events":[
+            {"id":"a","calendar_id":"default","start":"2026-07-08T09:00",
+             "end":"2026-07-08T10:00","title":"x","future_field":"keep me"}
+        ],"tasks":[],"top_level_future":"also keep"}"#;
+        let data: CalendarFile = serde_json::from_str(raw).unwrap();
+        let data = data.into_data();
+        let out = serde_json::to_string(&data).unwrap();
+        assert!(out.contains("keep me"), "event extra must survive: {out}");
+        assert!(out.contains("also keep"), "file extra must survive: {out}");
+    }
+}
diff --git a/src-tauri/src/schema/global_machine.rs b/src-tauri/src/schema/global_machine.rs
new file mode 100644
index 0000000..24e6229
--- /dev/null
+++ b/src-tauri/src/schema/global_machine.rs
@@ -0,0 +1,35 @@
+use serde::{Deserialize, Serialize};
+
+/// A globally connected worker machine: authenticated once via the ordinary
+/// login mechanism (`commands::ssh::ssh_connect`) with **no** `remote_path` set —
+/// project-free by construction, unlike [`super::project::RemoteSpec`]. Later
+/// drag-and-dropped onto an SSH project to become a `shared_fs`
+/// [`super::project::ComputeHost`] there (a value COPY of this identity, not a
+/// reference — removing it from a project never touches this registry).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GlobalMachine {
+    /// Stable id, minted on add.
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+    pub host: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub port: Option<u16>,
+    /// Display name; falls back to `host` wherever shown.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    /// Opt-in to a *silent* connect on launch and whenever a VPN tunnel comes up
+    /// (the machine-wide twin of a project's `RemoteSpec::auto_connect`). Like it,
+    /// the auto path never prompts: it probes first and connects only when the host
+    /// is reachable with no user input, so a stale opt-in degrades to "stay off".
+    /// `#[serde(default)]` so a `global_machines.json` written before this field
+    /// existed still loads.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub auto_connect: Option<bool>,
+}
+
+impl GlobalMachine {
+    pub fn display_label(&self) -> &str {
+        self.label.as_deref().unwrap_or(&self.host)
+    }
+}
diff --git a/src-tauri/src/schema/mod.rs b/src-tauri/src/schema/mod.rs
index c33dc3c..9f91f8b 100644
--- a/src-tauri/src/schema/mod.rs
+++ b/src-tauri/src/schema/mod.rs
@@ -1,17 +1,24 @@
 pub mod active_session;
 pub mod boxes;
+pub mod calendar;
 pub mod default_apps;
+pub mod global_machine;
+pub mod net_usage;
 pub mod project;
 pub mod projects;
 pub mod session;
 pub mod settings;
 pub mod time_log;
+pub mod usage_stats;
 
 pub use active_session::ActiveSession;
 pub use boxes::{BoxRelation, BoxesList, ProjectBox};
+pub use calendar::{Calendar, CalendarData, CalendarEvent, CalendarFile, CalendarTask};
 pub use default_apps::DefaultApps;
+pub use global_machine::GlobalMachine;
 pub use project::Project;
 pub use projects::ProjectEntry;
 pub use session::{FileTabSession, LayoutSession, ProjectState, TerminalSession, WindowSession};
 pub use settings::Settings;
 pub use time_log::TimeLogEntry;
+pub use usage_stats::{Counters, UsageStats};
diff --git a/src-tauri/src/schema/net_usage.rs b/src-tauri/src/schema/net_usage.rs
new file mode 100644
index 0000000..0099e77
--- /dev/null
+++ b/src-tauri/src/schema/net_usage.rs
@@ -0,0 +1,605 @@
+//! Persisted per-project network usage (SSH-link bytes), bucketed by UTC hour
+//! and UTC day.
+//!
+//! Companion to the live Network Traffic tab (`commands::network`), which is
+//! in-memory only. The background sampler (`services::net_usage`) diffs each
+//! connected remote project's ControlMaster byte counters and folds the deltas
+//! in here, so a project's cumulative usage survives across tab opens/closes and
+//! restarts. The frontend derives "this hour / today / this week / this month /
+//! overall" from the two maps, exactly as the time-tracking tab derives its
+//! totals from `time_log::activity_for`.
+//!
+//! Two granularities, because they have different lifetimes. Days are cheap
+//! (one key per day) and kept forever, and every multi-day window — week, month,
+//! overall — is a sum over them, so no separate week or month bucket is stored.
+//! Hours are 24× denser, so they are pruned to [`HOUR_RETENTION`] keys; the day
+//! totals they contributed to survive that pruning untouched.
+//!
+//! Only **SSH-link bytes per remote project** are stored: Eldrun pools one
+//! ControlMaster per active remote project, so those counters are genuinely
+//! per-project. Host-wide interface counters are not attributable to a project
+//! and are never recorded here, so local projects have no entry.
+
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::storage;
+
+/// File name of the usage store inside `state_dir()`.
+pub const USAGE_FILE: &str = "net_usage.json";
+
+/// How many hour buckets to retain — 14 days. Keys are shared across projects
+/// (one key per wall-clock hour, holding every project's counts for it), so this
+/// is a calendar window, not a per-project quota, and the file stays bounded no
+/// matter how many remote projects exist.
+pub const HOUR_RETENTION: usize = 24 * 14;
+
+/// Received/transmitted byte totals for one (bucket, project) pair.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ByteCounts {
+    #[serde(default)]
+    pub rx: u64,
+    #[serde(default)]
+    pub tx: u64,
+}
+
+/// Downloaded/uploaded FILE-COUNT totals for one (bucket, project) pair — how
+/// many discrete files were transferred, as opposed to [`ByteCounts`]' bytes.
+/// Recorded once per file at the sync call sites (`services::remote_sync` /
+/// `services::sync_auto`), whether the transfer rode the SFTP-native walker or
+/// the rsync fast-path — unlike bytes, which are sampled continuously off the
+/// ControlMaster link and so cover every channel (terminal, SFTP, sync, git),
+/// this counts only files actually copied by the sync engine.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FileCounts {
+    #[serde(default)]
+    pub down: u64,
+    #[serde(default)]
+    pub up: u64,
+}
+
+/// Rolling per-project network-usage summary at two granularities: hour
+/// ("YYYY-MM-DDTHH") and day ("YYYY-MM-DD"), each mapping to project_id →
+/// cumulative {rx, tx} for that bucket. Bounded maps (like `TimeSummary`), so
+/// folding a delta is an O(map) read-modify-write and reading one bucket is O(1).
+///
+/// Serialized shape:
+/// ```json
+/// {
+///   "version": 3,
+///   "hours": { "2026-07-03T14": { "<project-id>": { "rx": 12, "tx": 34 } } },
+///   "days":  { "2026-07-03":    { "<project-id>": { "rx": 1234, "tx": 5678 } } },
+///   "fileHours": { "2026-07-03T14": { "<project-id>": { "down": 3, "up": 1 } } },
+///   "fileDays":  { "2026-07-03":    { "<project-id>": { "down": 9, "up": 4 } } }
+/// }
+/// ```
+///
+/// A version-1 file has no `hours` and loads with an empty one: history stays,
+/// hourly resolution simply starts accruing from the upgrade. A version-2 file
+/// has no `fileHours`/`fileDays`; those likewise start empty and accrue from
+/// there — bytes history is never touched by the file-count upgrade.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NetUsageSummary {
+    /// Schema version. 1 = days only; 2 adds `hours`; 3 adds `fileHours`/`fileDays`.
+    #[serde(default = "default_version")]
+    pub version: u32,
+    /// hour ("YYYY-MM-DDTHH") → project_id → cumulative {rx, tx} for that hour.
+    /// Pruned to the newest [`HOUR_RETENTION`] keys on every save.
+    #[serde(default)]
+    pub hours: HashMap<String, HashMap<String, ByteCounts>>,
+    /// date ("YYYY-MM-DD") → project_id → cumulative {rx, tx} for that day.
+    #[serde(default)]
+    pub days: HashMap<String, HashMap<String, ByteCounts>>,
+    /// hour ("YYYY-MM-DDTHH") → project_id → cumulative {down, up} FILE counts
+    /// for that hour. Same retention/pruning as `hours`.
+    #[serde(default)]
+    pub file_hours: HashMap<String, HashMap<String, FileCounts>>,
+    /// date ("YYYY-MM-DD") → project_id → cumulative {down, up} FILE counts for
+    /// that day.
+    #[serde(default)]
+    pub file_days: HashMap<String, HashMap<String, FileCounts>>,
+}
+
+/// A file written before `hours` existed is implicitly version 1.
+fn default_version() -> u32 {
+    1
+}
+
+impl Default for NetUsageSummary {
+    fn default() -> Self {
+        NetUsageSummary {
+            version: 3,
+            hours: HashMap::new(),
+            days: HashMap::new(),
+            file_hours: HashMap::new(),
+            file_days: HashMap::new(),
+        }
+    }
+}
+
+impl NetUsageSummary {
+    /// Cumulative {rx, tx} recorded for `project_id` on `date` ("YYYY-MM-DD").
+    pub fn usage_on(&self, project_id: &str, date: &str) -> ByteCounts {
+        lookup(&self.days, project_id, date)
+    }
+
+    /// Cumulative {rx, tx} recorded for `project_id` in `hour`
+    /// ("YYYY-MM-DDTHH").
+    pub fn usage_in_hour(&self, project_id: &str, hour: &str) -> ByteCounts {
+        lookup(&self.hours, project_id, hour)
+    }
+
+    /// Add `rx`/`tx` bytes to `project_id`'s totals for the UTC hour `hour`
+    /// ("YYYY-MM-DDTHH"), and to the day that hour falls in. Both buckets come
+    /// from the one stamp — the day is its `YYYY-MM-DD` prefix — so they can
+    /// never disagree about when the bytes moved.
+    ///
+    /// A zero delta is a no-op so idle projects never create empty buckets. A
+    /// malformed stamp is ignored rather than panicking. Saturating so a
+    /// pathological counter can never overflow.
+    pub fn add(&mut self, project_id: &str, hour: &str, rx: u64, tx: u64) {
+        if rx == 0 && tx == 0 {
+            return;
+        }
+        let Some(date) = hour.get(..10) else { return };
+        accrue(&mut self.hours, project_id, hour, rx, tx);
+        accrue(&mut self.days, project_id, date, rx, tx);
+    }
+
+    /// Per-date totals for `project_id` (or every project when empty), matching
+    /// the shape `commands::net_usage::get_net_usage` returns.
+    pub fn activity_for(&self, project_id: &str) -> HashMap<String, ByteCounts> {
+        fold(&self.days, project_id)
+    }
+
+    /// Per-hour totals for `project_id` (or every project when empty), over the
+    /// retained window.
+    pub fn hourly_for(&self, project_id: &str) -> HashMap<String, ByteCounts> {
+        fold(&self.hours, project_id)
+    }
+
+    /// Cumulative {down, up} FILE counts recorded for `project_id` on `date`
+    /// ("YYYY-MM-DD").
+    pub fn files_on(&self, project_id: &str, date: &str) -> FileCounts {
+        lookup(&self.file_days, project_id, date)
+    }
+
+    /// Cumulative {down, up} FILE counts recorded for `project_id` in `hour`
+    /// ("YYYY-MM-DDTHH").
+    pub fn files_in_hour(&self, project_id: &str, hour: &str) -> FileCounts {
+        lookup(&self.file_hours, project_id, hour)
+    }
+
+    /// Add `down`/`up` FILE counts to `project_id`'s totals for the UTC hour
+    /// `hour`, and to the day it falls in — same shape as [`Self::add`], one
+    /// call per file transferred rather than per byte delta.
+    pub fn add_files(&mut self, project_id: &str, hour: &str, down: u64, up: u64) {
+        if down == 0 && up == 0 {
+            return;
+        }
+        let Some(date) = hour.get(..10) else { return };
+        accrue(&mut self.file_hours, project_id, hour, down, up);
+        accrue(&mut self.file_days, project_id, date, down, up);
+    }
+
+    /// Per-date FILE-count totals for `project_id` (or every project when
+    /// empty), matching the shape `commands::net_usage::get_net_usage` returns.
+    pub fn activity_files_for(&self, project_id: &str) -> HashMap<String, FileCounts> {
+        fold(&self.file_days, project_id)
+    }
+
+    /// Per-hour FILE-count totals for `project_id` (or every project when
+    /// empty), over the retained window.
+    pub fn hourly_files_for(&self, project_id: &str) -> HashMap<String, FileCounts> {
+        fold(&self.file_hours, project_id)
+    }
+
+    /// Drop all but the newest [`HOUR_RETENTION`] hour buckets, for both the
+    /// byte and file-count hour maps independently. Keys sort lexicographically
+    /// in chronological order (fixed-width, zero-padded), so this needs no date
+    /// arithmetic and no clock read — which also means a backdated or
+    /// clock-skewed key can never evict live ones out of order. Day buckets are
+    /// untouched: the pruned hours' totals already live there.
+    pub fn prune_hours(&mut self) {
+        prune_hour_map(&mut self.hours);
+        prune_hour_map(&mut self.file_hours);
+    }
+}
+
+/// Shared pruning body for an hour-keyed bucket map, generic over the payload
+/// type so it serves both `hours` (bytes) and `file_hours` (file counts).
+fn prune_hour_map<T>(hours: &mut HashMap<String, HashMap<String, T>>) {
+    if hours.len() <= HOUR_RETENTION {
+        return;
+    }
+    let mut keys: Vec<&str> = hours.keys().map(String::as_str).collect();
+    keys.sort_unstable();
+    let cutoff = keys[keys.len() - HOUR_RETENTION].to_string();
+    hours.retain(|hour, _| *hour >= cutoff);
+}
+
+/// A per-bucket payload holding two independent `u64` counters (`ByteCounts`'
+/// rx/tx, `FileCounts`' down/up), so `lookup`/`accrue`/`fold` below serve both
+/// maps in `NetUsageSummary` instead of being duplicated per payload type.
+trait PairCounts: Copy + Default {
+    fn from_pair(a: u64, b: u64) -> Self;
+    fn merge(&mut self, other: Self);
+}
+
+impl PairCounts for ByteCounts {
+    fn from_pair(rx: u64, tx: u64) -> Self {
+        ByteCounts { rx, tx }
+    }
+    fn merge(&mut self, other: Self) {
+        self.rx = self.rx.saturating_add(other.rx);
+        self.tx = self.tx.saturating_add(other.tx);
+    }
+}
+
+impl PairCounts for FileCounts {
+    fn from_pair(down: u64, up: u64) -> Self {
+        FileCounts { down, up }
+    }
+    fn merge(&mut self, other: Self) {
+        self.down = self.down.saturating_add(other.down);
+        self.up = self.up.saturating_add(other.up);
+    }
+}
+
+/// `bucket → project → counts` lookup, defaulting to zero.
+fn lookup<T: Copy + Default>(
+    buckets: &HashMap<String, HashMap<String, T>>,
+    project_id: &str,
+    key: &str,
+) -> T {
+    buckets
+        .get(key)
+        .and_then(|by_project| by_project.get(project_id))
+        .copied()
+        .unwrap_or_default()
+}
+
+/// Fold `a`/`b` into `buckets[key][project_id]`, creating buckets as needed.
+fn accrue<T: PairCounts>(
+    buckets: &mut HashMap<String, HashMap<String, T>>,
+    project_id: &str,
+    key: &str,
+    a: u64,
+    b: u64,
+) {
+    let entry = buckets
+        .entry(key.to_string())
+        .or_default()
+        .entry(project_id.to_string())
+        .or_default();
+    entry.merge(T::from_pair(a, b));
+}
+
+/// Collapse `bucket → project → counts` to `bucket → counts` for one project
+/// (or summed across all projects when `project_id` is empty).
+fn fold<T: PairCounts>(
+    buckets: &HashMap<String, HashMap<String, T>>,
+    project_id: &str,
+) -> HashMap<String, T> {
+    let mut out: HashMap<String, T> = HashMap::new();
+    for (key, by_project) in buckets {
+        for (pid, counts) in by_project {
+            if project_id.is_empty() || pid == project_id {
+                out.entry(key.clone()).or_default().merge(*counts);
+            }
+        }
+    }
+    out
+}
+
+// ── On-disk helpers ────────────────────────────────────────────────────────
+
+fn usage_path() -> std::path::PathBuf {
+    storage::state_dir().join(USAGE_FILE)
+}
+
+/// Load the usage summary, defaulting to empty when the file is absent or
+/// unparseable (a brand-new install, or a partial write) rather than erroring.
+pub fn load() -> NetUsageSummary {
+    let path = usage_path();
+    if path.exists() {
+        storage::read_json(&path).unwrap_or_default()
+    } else {
+        NetUsageSummary::default()
+    }
+}
+
+/// Persist the usage summary, pruning stale hour buckets first. Pruning lives
+/// here rather than in `add` so it is impossible for a writer to skip it, and so
+/// it costs one sort per flush rather than one per project.
+pub fn save(summary: &mut NetUsageSummary) -> Result<(), String> {
+    summary.version = 3;
+    summary.prune_hours();
+    storage::write_json(&usage_path(), summary).map_err(|e| e.to_string())
+}
+
+/// Fold `rx`/`tx` bytes for `project_id` into the current UTC hour (and thereby
+/// the current UTC day). O(map) read-modify-write of a bounded file. A zero
+/// delta is skipped without touching disk.
+pub fn record(project_id: &str, rx: u64, tx: u64) {
+    if project_id.is_empty() || (rx == 0 && tx == 0) {
+        return;
+    }
+    let mut summary = load();
+    summary.add(project_id, &storage::hour_utc(), rx, tx);
+    let _ = save(&mut summary);
+}
+
+/// Fold a downloaded/uploaded FILE count for `project_id` into the current UTC
+/// hour (and thereby the current UTC day). Called once per file actually
+/// transferred by the sync engine (`services::remote_sync::pull_file` /
+/// `push_file_atomic`, and the rsync fast-path's per-file manifest loop) — unlike
+/// [`record`] above, which is driven by the continuous link-byte sampler. A zero
+/// delta is skipped without touching disk.
+pub fn record_files(project_id: &str, down: u64, up: u64) {
+    if project_id.is_empty() || (down == 0 && up == 0) {
+        return;
+    }
+    let mut summary = load();
+    summary.add_files(project_id, &storage::hour_utc(), down, up);
+    let _ = save(&mut summary);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn add_and_lookup_accumulates() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 100, 40);
+        s.add("p1", "2026-07-03T14", 50, 10);
+        s.add("p2", "2026-07-03T09", 7, 3);
+        s.add("p1", "2026-07-02T23", 9, 1);
+        assert_eq!(s.usage_on("p1", "2026-07-03"), ByteCounts { rx: 150, tx: 50 });
+        assert_eq!(s.usage_on("p2", "2026-07-03"), ByteCounts { rx: 7, tx: 3 });
+        assert_eq!(s.usage_on("p1", "2026-07-02"), ByteCounts { rx: 9, tx: 1 });
+        assert_eq!(s.usage_on("missing", "2026-07-03"), ByteCounts::default());
+        assert_eq!(s.usage_on("p1", "1999-01-01"), ByteCounts::default());
+    }
+
+    #[test]
+    fn add_splits_the_day_into_hours() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 100, 40);
+        s.add("p1", "2026-07-03T09", 5, 2);
+        s.add("p1", "2026-07-03T14", 50, 10);
+        assert_eq!(
+            s.usage_in_hour("p1", "2026-07-03T09"),
+            ByteCounts { rx: 105, tx: 42 }
+        );
+        assert_eq!(
+            s.usage_in_hour("p1", "2026-07-03T14"),
+            ByteCounts { rx: 50, tx: 10 }
+        );
+        assert_eq!(s.usage_in_hour("p1", "2026-07-03T10"), ByteCounts::default());
+        // The day is the sum of its hours, from the same stamps.
+        assert_eq!(s.usage_on("p1", "2026-07-03"), ByteCounts { rx: 155, tx: 52 });
+    }
+
+    #[test]
+    fn add_ignores_zero_delta() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 0, 0);
+        assert!(s.days.is_empty());
+        assert!(s.hours.is_empty());
+        // A one-sided delta still records.
+        s.add("p1", "2026-07-03T09", 0, 5);
+        assert_eq!(s.usage_on("p1", "2026-07-03"), ByteCounts { rx: 0, tx: 5 });
+        assert_eq!(
+            s.usage_in_hour("p1", "2026-07-03T09"),
+            ByteCounts { rx: 0, tx: 5 }
+        );
+    }
+
+    #[test]
+    fn add_ignores_malformed_stamp() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07", 100, 40);
+        s.add("p1", "", 100, 40);
+        assert!(s.days.is_empty());
+        assert!(s.hours.is_empty());
+    }
+
+    #[test]
+    fn add_saturates_instead_of_overflowing() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", u64::MAX, u64::MAX);
+        s.add("p1", "2026-07-03T10", 10, 10);
+        assert_eq!(
+            s.usage_on("p1", "2026-07-03"),
+            ByteCounts { rx: u64::MAX, tx: u64::MAX }
+        );
+    }
+
+    #[test]
+    fn activity_for_aggregates_per_date() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 100, 20);
+        s.add("p2", "2026-07-03T09", 5, 1);
+        s.add("p1", "2026-07-02T09", 9, 3);
+
+        let p1 = s.activity_for("p1");
+        assert_eq!(p1.get("2026-07-03"), Some(&ByteCounts { rx: 100, tx: 20 }));
+        assert_eq!(p1.get("2026-07-02"), Some(&ByteCounts { rx: 9, tx: 3 }));
+        assert_eq!(p1.get("2026-07-01"), None);
+
+        let all = s.activity_for("");
+        assert_eq!(all.get("2026-07-03"), Some(&ByteCounts { rx: 105, tx: 21 }));
+        assert_eq!(all.get("2026-07-02"), Some(&ByteCounts { rx: 9, tx: 3 }));
+    }
+
+    #[test]
+    fn hourly_for_aggregates_per_hour() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 100, 20);
+        s.add("p2", "2026-07-03T09", 5, 1);
+        s.add("p1", "2026-07-03T10", 9, 3);
+
+        let p1 = s.hourly_for("p1");
+        assert_eq!(p1.get("2026-07-03T09"), Some(&ByteCounts { rx: 100, tx: 20 }));
+        assert_eq!(p1.get("2026-07-03T10"), Some(&ByteCounts { rx: 9, tx: 3 }));
+        assert_eq!(p1.get("2026-07-03T11"), None);
+
+        let all = s.hourly_for("");
+        assert_eq!(all.get("2026-07-03T09"), Some(&ByteCounts { rx: 105, tx: 21 }));
+    }
+
+    #[test]
+    fn day_rollover_keys_separately() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T23", 100, 0);
+        s.add("p1", "2026-07-04T00", 200, 0);
+        assert_eq!(s.usage_on("p1", "2026-07-03").rx, 100);
+        assert_eq!(s.usage_on("p1", "2026-07-04").rx, 200);
+        assert_eq!(s.days.len(), 2);
+        assert_eq!(s.hours.len(), 2);
+    }
+
+    #[test]
+    fn prune_hours_keeps_the_newest_window_and_all_days() {
+        let mut s = NetUsageSummary::default();
+        // 20 days × 24 h, oldest first.
+        for day in 1..=20u32 {
+            for hour in 0..24u32 {
+                s.add("p1", &format!("2026-06-{day:02}T{hour:02}"), 10, 1);
+            }
+        }
+        assert_eq!(s.hours.len(), 20 * 24);
+        s.prune_hours();
+
+        assert_eq!(s.hours.len(), HOUR_RETENTION);
+        // Days 7..=20 are the newest 14; day 6 and earlier are gone.
+        assert_eq!(
+            s.usage_in_hour("p1", "2026-06-20T23"),
+            ByteCounts { rx: 10, tx: 1 }
+        );
+        assert_eq!(s.usage_in_hour("p1", "2026-06-07T00"), ByteCounts { rx: 10, tx: 1 });
+        assert_eq!(s.usage_in_hour("p1", "2026-06-06T23"), ByteCounts::default());
+        assert_eq!(s.usage_in_hour("p1", "2026-06-01T00"), ByteCounts::default());
+        // Pruning hours never touches the day totals they fed.
+        assert_eq!(s.days.len(), 20);
+        assert_eq!(s.usage_on("p1", "2026-06-01"), ByteCounts { rx: 240, tx: 24 });
+    }
+
+    #[test]
+    fn prune_hours_is_a_noop_under_the_cap() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 1, 1);
+        s.prune_hours();
+        assert_eq!(s.hours.len(), 1);
+    }
+
+    #[test]
+    fn summary_roundtrips_through_json() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 42, 7);
+        let json = serde_json::to_string(&s).unwrap();
+        let back: NetUsageSummary = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.usage_on("p1", "2026-07-03"), ByteCounts { rx: 42, tx: 7 });
+        assert_eq!(
+            back.usage_in_hour("p1", "2026-07-03T09"),
+            ByteCounts { rx: 42, tx: 7 }
+        );
+        assert_eq!(back.version, 3);
+    }
+
+    #[test]
+    fn deserializes_empty_object_with_defaults() {
+        let back: NetUsageSummary = serde_json::from_str("{}").unwrap();
+        assert_eq!(back.version, 1);
+        assert!(back.days.is_empty());
+        assert!(back.hours.is_empty());
+        assert!(back.file_days.is_empty());
+        assert!(back.file_hours.is_empty());
+    }
+
+    #[test]
+    fn version_1_file_loads_with_days_intact_and_empty_hours() {
+        let json = r#"{
+            "version": 1,
+            "days": { "2026-07-03": { "p1": { "rx": 500, "tx": 100 } } }
+        }"#;
+        let mut back: NetUsageSummary = serde_json::from_str(json).unwrap();
+        assert_eq!(back.usage_on("p1", "2026-07-03"), ByteCounts { rx: 500, tx: 100 });
+        assert!(back.hours.is_empty());
+        // Hourly resolution starts accruing from here; the old day total stands.
+        back.add("p1", "2026-07-03T09", 1, 1);
+        assert_eq!(back.usage_on("p1", "2026-07-03"), ByteCounts { rx: 501, tx: 101 });
+        assert_eq!(back.usage_in_hour("p1", "2026-07-03T09"), ByteCounts { rx: 1, tx: 1 });
+    }
+
+    #[test]
+    fn add_files_accumulates_independently_of_bytes() {
+        let mut s = NetUsageSummary::default();
+        s.add("p1", "2026-07-03T09", 100, 40); // bytes
+        s.add_files("p1", "2026-07-03T09", 3, 0); // 3 files downloaded
+        s.add_files("p1", "2026-07-03T09", 0, 1); // 1 file uploaded
+        s.add_files("p1", "2026-07-02T23", 5, 2);
+
+        assert_eq!(s.files_on("p1", "2026-07-03"), FileCounts { down: 3, up: 1 });
+        assert_eq!(s.files_in_hour("p1", "2026-07-03T09"), FileCounts { down: 3, up: 1 });
+        assert_eq!(s.files_on("p1", "2026-07-02"), FileCounts { down: 5, up: 2 });
+        // Byte totals are untouched by file-count recording.
+        assert_eq!(s.usage_on("p1", "2026-07-03"), ByteCounts { rx: 100, tx: 40 });
+    }
+
+    #[test]
+    fn add_files_ignores_zero_delta_and_malformed_stamp() {
+        let mut s = NetUsageSummary::default();
+        s.add_files("p1", "2026-07-03T09", 0, 0);
+        s.add_files("p1", "2026-07", 1, 0);
+        assert!(s.file_days.is_empty());
+        assert!(s.file_hours.is_empty());
+    }
+
+    #[test]
+    fn activity_files_for_and_hourly_files_for_aggregate_across_projects() {
+        let mut s = NetUsageSummary::default();
+        s.add_files("p1", "2026-07-03T09", 2, 0);
+        s.add_files("p2", "2026-07-03T09", 1, 1);
+        s.add_files("p1", "2026-07-03T10", 0, 4);
+
+        let p1_days = s.activity_files_for("p1");
+        assert_eq!(p1_days.get("2026-07-03"), Some(&FileCounts { down: 2, up: 4 }));
+
+        let all_hours = s.hourly_files_for("");
+        assert_eq!(all_hours.get("2026-07-03T09"), Some(&FileCounts { down: 3, up: 1 }));
+    }
+
+    #[test]
+    fn prune_hours_prunes_file_hours_independently_of_byte_hours() {
+        let mut s = NetUsageSummary::default();
+        for day in 1..=20u32 {
+            for hour in 0..24u32 {
+                s.add_files("p1", &format!("2026-06-{day:02}T{hour:02}"), 1, 0);
+            }
+        }
+        assert_eq!(s.file_hours.len(), 20 * 24);
+        s.prune_hours();
+        assert_eq!(s.file_hours.len(), HOUR_RETENTION);
+        assert_eq!(s.file_days.len(), 20); // day totals survive hour pruning
+        assert_eq!(s.files_on("p1", "2026-06-01"), FileCounts { down: 24, up: 0 });
+    }
+
+    #[test]
+    fn file_counts_roundtrip_through_json() {
+        let mut s = NetUsageSummary::default();
+        s.add_files("p1", "2026-07-03T09", 6, 2);
+        let json = serde_json::to_string(&s).unwrap();
+        let back: NetUsageSummary = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.files_on("p1", "2026-07-03"), FileCounts { down: 6, up: 2 });
+        assert_eq!(
+            back.files_in_hour("p1", "2026-07-03T09"),
+            FileCounts { down: 6, up: 2 }
+        );
+    }
+}
diff --git a/src-tauri/src/schema/project.rs b/src-tauri/src/schema/project.rs
index 8438249..a175bae 100644
--- a/src-tauri/src/schema/project.rs
+++ b/src-tauri/src/schema/project.rs
@@ -68,9 +68,16 @@ pub struct TabEntry {
     pub extra: HashMap<String, Value>,
 }
 
-/// Remote (SSH) location metadata. A project is "remote" iff this is present.
-/// The project's `directory` then points at the local sshfs mountpoint while
-/// the bytes live on `host:remote_path`.
+/// Remote (SSH) location metadata. A project is "remote" iff this is present;
+/// the explicit "is this project remote?" resolver is
+/// `services::remote::remote_target_for` (replacing the old infer-from-mountpoint
+/// signal). The bytes live on `host:remote_path`.
+///
+/// In the mount-free remote model (`docs/mountfree_remote_plan.md`) the project's
+/// `directory` is **not** a real local path for a remote project — file, git, and
+/// terminal commands resolve `host:remote_path` directly over SSH/SFTP, never the
+/// local fs. (During the sshfs→SFTP transition `directory` may still hold a legacy
+/// mountpoint; it is ignored for fs purposes once a phase routes that op remote.)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct RemoteSpec {
     /// SSH user, e.g. "alice"
@@ -88,17 +95,153 @@ pub struct RemoteSpec {
     /// before the sshfs mount / ssh sessions.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub openvpn: Option<OpenVpnSpec>,
+    /// Opt-in: connect this project automatically (launch + activation) instead of
+    /// waiting for the user to bring it up from the pill's connection lamp. Only
+    /// offered when the connection can complete with no prompt — a saved SSH
+    /// password, or `key_auth` below. The auto-connect never prompts: if it can't
+    /// authenticate silently it stops with a red lamp.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auto_connect: Option<bool>,
+    /// Recorded (not user-set): the last successful connect to `host` used no
+    /// password at all, so it authenticated via key/agent. This is the only way to
+    /// know a host is passwordless without connecting, and it is what makes
+    /// auto-connect available to key-auth projects (which have nothing in the
+    /// keychain to check). Written by `remote_connect`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub key_auth: Option<bool>,
+    /// Run this project's remote shell/script tabs inside a **tmux** session on
+    /// the host (TODO #85), so a long run survives an SSH drop, a laptop sleep, or
+    /// Eldrun quitting — the session keeps running and the tab reattaches on
+    /// reconnect/relaunch. **Default ON** for a remote project: `None` and
+    /// `Some(true)` both mean enabled; only an explicit `Some(false)` opts out (the
+    /// pill's toggle). Agent tabs are excluded regardless — they resume via their
+    /// own session. The frontend reads this to set each spawn's `tmux_session`
+    /// name; the backend wraps in `ssh_exec::wrap_pty_options`. Mirrored into the
+    /// `projects.json` entry's `extra["remote"]`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub persist_sessions: Option<bool>,
+    /// Display name for this machine, e.g. "gpu-2"; falls back to `host`. Shown
+    /// wherever a project's hosts are listed side by side (the System Monitor's
+    /// source picker, the pill's connection lamps, `hostsForProject`) so a host is
+    /// identifiable by more than its raw address. Distinct from the *project*
+    /// name: this labels the machine `host` reaches, not the project itself — the
+    /// primary (`Project.remote.label`) and every `ComputeHost` (flattened into
+    /// its `spec`, so the JSON key stays the same one worker labels already used)
+    /// share this one field.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
     #[serde(flatten)]
     pub extra: HashMap<String, Value>,
 }
 
-/// Optional OpenVPN tunnel for reaching a remote project's host. Only the
-/// client config path is persisted; the password is prompted each time the
-/// tunnel is brought up and is never written to disk.
+fn default_true() -> bool {
+    true
+}
+
+/// An additional SSH machine a project runs experiments on (`docs/multi_host_remote_plan.md`).
+/// Its code is kept in one-way sync from the canonical source (the local mirror);
+/// its files are read-only (edits forbidden). It never owns git/sync/mirror state
+/// of its own — the primary [`RemoteSpec`] (`Project.remote`) does. `id` is stable
+/// (referenced by tab locations + the pool key + the fan-out state); `label` is the
+/// pill/tab display name. Reusing `RemoteSpec` verbatim (flattened) means every
+/// existing execution helper (`ssh_exec`, `sftp`, monitor/disk/gpu/python) works
+/// unchanged — they already take `&RemoteSpec`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComputeHost {
+    /// Stable id, e.g. "h1"; the primary is the implicit "primary".
+    pub id: String,
+    /// Keep this worker's tracked tree synced to the source HEAD (default true).
+    /// Ignored when [`shared_fs`](Self::shared_fs) is set (there is no copy to sync).
+    #[serde(default = "default_true")]
+    pub sync_code: bool,
+    /// Pull this worker's experiment OUTPUTS back on demand only, never
+    /// automatically (default false — outputs stay on the worker).
+    #[serde(default)]
+    pub pull_outputs: bool,
+    /// This machine reaches the project over a **shared filesystem**: it already
+    /// sees the primary's project folder at `spec.remote_path`, so Eldrun copies
+    /// **no** code to it and **never runs git on it** — shells just `cd` into the
+    /// shared tree and run there (`docs/multi_host_remote_plan.md`, shared-fs mode).
+    /// Mutually exclusive with the whole one-way sync path: when set, connect does
+    /// no bootstrap, commits do no fan-out, and "Sync code"/"Pull outputs" are
+    /// meaningless (the folder *is* the primary's, kept in step by the primary's
+    /// own sync). Default false — a machine is a synced-copy worker unless it opts
+    /// into sharing.
+    #[serde(default)]
+    pub shared_fs: bool,
+    /// user/host/port/remote_path/openvpn/auto_connect/key_auth.
+    #[serde(flatten)]
+    pub spec: RemoteSpec,
+}
+
+impl ComputeHost {
+    /// The display label for this worker (its `spec.label`, or the bare host).
+    pub fn display_label(&self) -> &str {
+        self.spec.label.as_deref().unwrap_or(&self.spec.host)
+    }
+}
+
+/// Optional OpenVPN tunnel for reaching a remote project's host. The client
+/// config path and (for `auth-user-pass` configs) the auth username are
+/// persisted; the password/passphrase is prompted each time the tunnel is
+/// brought up and is never written to disk (unless the user opts into the OS
+/// keychain via "Save password").
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct OpenVpnSpec {
     /// Absolute path to the local `.ovpn` client config file.
     pub config: String,
+    /// Auth username for configs that use `auth-user-pass` (server-side
+    /// username+password auth). Persisted (it is not a secret, like the SSH
+    /// `user`); the matching password is still prompted/keychained separately and
+    /// never written here. `None` for configs that don't need a username (e.g.
+    /// certificate-only or encrypted-key-passphrase configs).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(flatten)]
+    pub extra: HashMap<String, Value>,
+}
+
+/// Per-project container config (TODO #38). When present and `enabled`, every
+/// terminal/agent tab of this project execs into ONE session-lived,
+/// capability-dropped Docker container (`eldrun-<id>`) that mounts only the
+/// project directory plus the minimal agent auth/state paths (see
+/// `services::sandbox`), so a process inside cannot reach unrelated host files.
+/// Absent (the default) = tabs run on the host exactly as before. Local
+/// projects only. (Serde key stays `sandbox` so projects that enabled the old
+/// per-tab agent sandbox upgrade in place — no migration.)
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct SandboxSpec {
+    /// Whether this project's tabs run inside the container.
+    pub enabled: bool,
+    /// Optional image override; falls back to the built-in default image when
+    /// absent (and is ignored while `dockerfile` is set).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub image: Option<String>,
+    /// In-repo Dockerfile (path relative to the project dir); when set, `up`
+    /// builds `eldrun-<id>:latest` from it instead of pulling/expecting `image`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub dockerfile: Option<String>,
+    /// Max number of processes inside the container (`--pids-limit`). Guards
+    /// against a fork-bombing agent. Falls back to a generous built-in default
+    /// when absent (see `services::sandbox`).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pids_limit: Option<u32>,
+    /// Optional hard memory cap (`--memory`, e.g. "4g"). Absent = unlimited, so
+    /// heavy in-container builds are not OOM-killed unless the user opts in.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub memory: Option<String>,
+    /// Optional CPU cap (`--cpus`, e.g. "2"). Absent = unlimited.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cpus: Option<String>,
+    /// Optional docker network (`--network`, e.g. "none" for no egress, or a
+    /// custom allowlist network). Absent = the default bridge (full egress).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub network: Option<String>,
+    /// Run the container with a read-only root filesystem (`--read-only` +
+    /// `--tmpfs /tmp`). Off by default because it breaks agents that write
+    /// outside the mounted dirs (e.g. `~/.cache`); opt-in hardening.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub readonly_rootfs: bool,
     #[serde(flatten)]
     pub extra: HashMap<String, Value>,
 }
@@ -117,6 +260,18 @@ pub struct Project {
     pub description: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub git_type: Option<String>,
+    /// Per-project git-hosting profile URL (e.g. `https://github.com/me`) that
+    /// overrides the global `settings.git_profile_url` for this project's push /
+    /// publish. Non-secret, so it lives here; the matching token is kept in the
+    /// OS keyring (see `services::git_credentials`), never in this file (which is
+    /// inside the project's committed git tree).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub git_profile_url: Option<String>,
+    /// Hosting provider this project was published to (`"github"` / `"gitlab"`),
+    /// recorded at publish time so the UI can label the pill and pick the right
+    /// CLI. Absent until the project is published to a remote.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub git_provider: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub created_at: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -156,6 +311,85 @@ pub struct Project {
     pub open_tab_sessions: Option<serde_json::Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub remote: Option<RemoteSpec>,
+    /// Extra SSH machines this project runs experiments on (`docs/multi_host_remote_plan.md`).
+    /// The primary is still `remote`; these are one-way, read-only "workers". Mirrored
+    /// into the `projects.json` entry's `extra["compute_hosts"]`. Migration-free
+    /// (`#[serde(default)]` → `[]` for existing projects).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub compute_hosts: Vec<ComputeHost>,
+    /// For a remote (SSH) project, the local mirror root — the paired local
+    /// working copy synced from the host. Chosen at import (defaults to a
+    /// `<name>` subfolder of the top-level `eldrun/projects-ssh/` root) and relocatable via the
+    /// pill's "Show on disk" when the mirror has been deleted. Absent for local
+    /// projects and for remote projects predating configurable mirrors, which
+    /// fall back to the default under the state dir. Mirrored into the
+    /// `projects.json` entry's `extra["mirror"]`, which `remote_sync::mirror_dir`
+    /// reads as the always-local source of truth.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mirror: Option<String>,
+    /// Docker sandbox config for agent tabs. Absent = run agents on the host.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sandbox: Option<SandboxSpec>,
+    /// The interpreter the code viewer's Run/Debug buttons use for this project
+    /// (#87). Absent = **auto-detect** (see `commands::python`), which is what the
+    /// overwhelming majority of projects want; this pins it for the ones auto-detect
+    /// cannot see — a conda env, a Poetry venv outside the tree, a second venv.
+    /// Stored as the command/path verbatim (relative paths resolve against the
+    /// project root, which is the run tab's cwd). Mirrored into the `projects.json`
+    /// entry's `extra["python_interpreter"]`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub python_interpreter: Option<String>,
+    /// Which machine shells launched from this project run on — the choice made in
+    /// the `RunHostPicker`, persisted so it survives a relaunch (a Run/Debug or a
+    /// new shell tab lands on it instead of the primary). A `TabLocation` string:
+    /// `"local"` (the mirror), `"remote"` (the primary host), or `"host:<id>"` (a
+    /// worker). Absent = the shell default (the primary). Mirrored into the
+    /// `projects.json` entry's `extra["run_host"]`, which is what the frontend
+    /// seeds its live preference store from on load.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub run_host: Option<String>,
+    /// The HPC **workspace** this project's tree lives in, plus the small anchor
+    /// folder kept in the user's cluster home (`docs/hpc_workspace_plan.md`).
+    /// Recorded because **none of it can be re-derived once the workspace
+    /// expires**: the tooling's recovery path (`ws_restore`) is keyed by the
+    /// workspace *name*, and the host tree that would have told you which one it
+    /// was is exactly what got deleted. Mirrored into the `projects.json` entry's
+    /// `extra["hpc"]`. Absent for every project that isn't in a workspace.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hpc: Option<HpcInfo>,
     #[serde(flatten)]
     pub extra: HashMap<String, Value>,
 }
+
+/// What a project remembers about its HPC workspace and home anchor. Every field
+/// is optional: a project may have a workspace but no anchor (or the reverse,
+/// after a workspace expired and was released), and a site's tooling may not
+/// report a filesystem name.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HpcInfo {
+    /// The workspace id (`ws_allocate <id>`) — the handle `ws_extend`/`ws_release`
+    /// /`ws_restore` take, and the only one that survives the directory.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_id: Option<String>,
+    /// Its absolute path on the host at the time it was recorded.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub workspace_path: Option<String>,
+    /// The workspace filesystem (`-F`), which `ws_extend` must be given again.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub filesystem: Option<String>,
+    /// The per-project folder in the user's cluster home (logs + workspace link +
+    /// the append-only record). Outside the project root, so nothing syncs it.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub anchor_dir: Option<String>,
+    /// The same folder as the `$HOME`-relative path it was created from. Kept
+    /// beside the absolute one because re-anchoring (a move to another workspace)
+    /// must pass the *rel* back — deriving it by chopping segments off
+    /// `anchor_dir` guesses wrong the moment the user picks a path that isn't two
+    /// segments deep.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub anchor_rel: Option<String>,
+    /// `<anchor_dir>/logs` — where `#SBATCH --output` points, and the fallback
+    /// `slurm_job_out` uses for a job `scontrol` has already forgotten.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logs_dir: Option<String>,
+}
diff --git a/src-tauri/src/schema/settings.rs b/src-tauri/src/schema/settings.rs
index 3344959..4620f77 100644
--- a/src-tauri/src/schema/settings.rs
+++ b/src-tauri/src/schema/settings.rs
@@ -19,10 +19,6 @@ pub struct GlobalAppEntry {
 /// still roll back. They are not used in Tauri app logic.
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct Settings {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub terminal_command: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub workspace_management: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub debug: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -31,12 +27,47 @@ pub struct Settings {
     pub git_token: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub color_scheme: Option<String>,
+    /// UI language for Eldrun's interface (`en`/`de`/`es`/`fr`/`it`). Frontend
+    /// logic only (`lib/i18n`); the backend just round-trips the value.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    /// Global UI zoom factor for the whole interface (helps on high-DPI/4K
+    /// monitors). `1.0` (or unset) is 100% — the current default look. Applied
+    /// frontend-side as a CSS `zoom`; the backend only round-trips the value.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ui_zoom: Option<f32>,
+    /// Calendar: first column of the week — `0` = Sunday (default), `1` = Monday.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calendar_week_start: Option<u8>,
+    /// Calendar: the view a fresh calendar tab opens on
+    /// (`day`/`week`/`multiweek`/`month`/`agenda`/`tasks`). Frontend logic only —
+    /// the backend just round-trips the value.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calendar_default_view: Option<String>,
+    /// Calendar: 24-hour clock instead of AM/PM.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calendar_time_format_24h: Option<bool>,
+    /// Calendar: first/last hour the day and week grids scroll to.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calendar_day_start_hour: Option<u8>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calendar_day_end_hour: Option<u8>,
+    /// Calendar: minutes-before reminder pre-filled on a new event. `0` = none.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub calendar_default_reminder_minutes: Option<i64>,
     /// Preserved for Python rollback; not used by the Tauri app.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ollama_host: Option<String>,
     /// Preserved for Python rollback; not used by the Tauri app.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ollama_model: Option<String>,
+    /// Per-task local-model assignments set from the 🧠 menu's role chips. Maps a
+    /// task key (`"autocomplete"`, `"grammar"`, `"tabs"`) to the model name that
+    /// serves it, so several loaded models can run different jobs in parallel.
+    /// Optional + flat so older settings files round-trip cleanly; a task absent
+    /// here falls back to `ollama_model`. Frontend logic only — persisted here.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ollama_roles: Option<HashMap<String, String>>,
     /// Preserved for Python rollback; not used by the Tauri app.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ollama_autostart: Option<bool>,
@@ -46,6 +77,150 @@ pub struct Settings {
     /// as a detached background process instead of opening a terminal tab.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub run_scripts_in_background: Option<bool>,
+    /// When true (the default), `claude` agent tabs are spawned with
+    /// `--remote-control` so the session can be monitored/steered from the Claude
+    /// app/web. Only Claude supports the flag; other agents ignore it. Default ON.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub agent_remote_control: Option<bool>,
+    /// When true (the default), the usage recap opens by itself on the first
+    /// launch of each day. Turning it off leaves the recap reachable from
+    /// Settings — it stops the popup, it does not stop the counting.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub daily_stats_recap: Option<bool>,
+    /// UTC date ("YYYY-MM-DD") the recap was last auto-shown, so it opens once a
+    /// day rather than on every window. Written by the recap host itself.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub daily_stats_last_shown: Option<String>,
+    /// EXPERIMENTAL, default OFF. When true, agent tabs whose agent supports it
+    /// (currently only Claude) show a Plan/Auto badge that switches the tab's
+    /// authority mode — `--permission-mode plan` vs `acceptEdits`. Switching
+    /// respawns the agent (the mode is a launch flag), which is only safe because
+    /// the backend resumes the conversation; see `services::agent_session`. Purely
+    /// a frontend gate: the flag reaches the backend inside `opts.args` like any
+    /// other launch arg, so nothing in the spawn path reads this.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub agent_mode_toggle: Option<bool>,
+    /// EXPERIMENTAL, default OFF. When true, a Python file in the native code
+    /// viewer gets the Run/Debug buttons and the breakpoint gutter (#87). Purely a
+    /// frontend gate, and off by default because Run *executes the file*: the
+    /// button is one click from an editor, so it is opt-in rather than something a
+    /// user discovers by mis-clicking. Go-to-definition is not gated — it reads,
+    /// it never runs anything. Nothing in the backend reads this: Run/Debug open an
+    /// ordinary terminal tab, which reaches `pty_spawn` like any other.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub python_run_debug: Option<bool>,
+    /// EXPERIMENTAL, default OFF. The native presenter ("deck",
+    /// `docs/deck_presenter_plan.md`): editable object layers over a base PDF, kept in
+    /// a `*.eldeck.json` sidecar, plus the animate mode and the fullscreen presenter.
+    /// Purely a frontend gate — a deck is an ordinary text file the existing fs
+    /// commands read and write, and its PDF export is built in the webview by pdf-lib,
+    /// so nothing in the backend reads this.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub deck_presenter: Option<bool>,
+    /// Persistent LOCAL (tmux) sessions (TODO #85): when true (the default on Unix),
+    /// a local project's shell/script tabs run inside a tmux session on the machine,
+    /// so a long run survives an Eldrun crash and the tab reattaches on restart.
+    /// `None`/`Some(true)` = on; `Some(false)` = off. No effect on Windows (no tmux):
+    /// `services::tmux_local` no-ops there. Read via `persist_local_sessions()`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub persist_local_sessions: Option<bool>,
+    /// When true (the default), remote SSH/OpenVPN connections are made headlessly
+    /// in the background, with Eldrun handling the password transiently (sshpass /
+    /// askpass). When false, those connections are launched as interactive
+    /// terminal tabs in the Eldrun **root** scope so the password is typed directly
+    /// into the live terminal and Eldrun never handles it at all. Default ON
+    /// (headless) so existing behaviour is preserved.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub connections_headless: Option<bool>,
+    /// Hosts marked **careful**: "this machine is shared and policed, so keep
+    /// Eldrun's background load off it." An HPC login node is the case it exists
+    /// for — CPU there is watched, its `$HOME` usually sits on a parallel
+    /// filesystem whose metadata server a recursive `du` hammers, and its account
+    /// database is a shared directory service.
+    ///
+    /// Keyed by canonical SSH target ([`crate::services::ssh_common::target_key`],
+    /// i.e. `user@host:port`) rather than by any host id, because **one physical
+    /// login node is simultaneously several records**: a project's primary
+    /// `remote`, a `compute_hosts` worker on another project, and a project-free
+    /// global machine — three tables, three ids, one machine. A per-record `bool`
+    /// would be three values free to disagree about the same host; the SSH target
+    /// is the identity `lib/machineSync`'s `sameTarget` already treats as the
+    /// bridge between them, so it is the identity used here too.
+    ///
+    /// The stored value is the user's **explicit** answer. A target *absent* from
+    /// the map has not been answered and is treated as **careful** — the default
+    /// for every remote machine, since Eldrun cannot tell whose machine a host is
+    /// and the two wrong guesses do not cost the same. Which is why this is a map
+    /// to `bool` and not a set of careful hosts: an explicit `false` ("this one is
+    /// mine") has to be distinguishable from an unanswered host, or the careful
+    /// default would keep turning itself back on.
+    ///
+    /// Deliberately **not** named for HPC. A departmental shared box wants the
+    /// same treatment, and a compute node held through SLURM — HPC by any
+    /// definition — does not: you own it outright for the length of the job, and
+    /// there monitoring is useful rather than rude.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub careful_hosts: Option<HashMap<String, bool>>,
+    /// The machines the user has tagged **HPC** — a shared cluster login node,
+    /// ticked on the login form and shown on the machine's row in the Machines
+    /// menu (`src/lib/hpcHost.ts`). Same SSH-target key as [`Self::careful_hosts`],
+    /// for the same reason.
+    ///
+    /// Where `careful_hosts` says how much Eldrun may *look at*, this says what
+    /// Eldrun may *do*, and it is a strictly stronger statement: a tagged host is
+    /// careful whatever `careful_hosts` says (the monitor's Detailed switch cannot
+    /// override it), and four further behaviours turn off — the disk-usage scan
+    /// and giant-folder census (a recursive `du` over a parallel filesystem's
+    /// metadata server), the auto byte-sync and git-lockstep poll loops, silent
+    /// auto-connect at launch, and unannounced compute in a login-node shell.
+    /// Each of those is something a site's usage rules name, and none of them can
+    /// be inferred from the host — `sbatch` on `PATH` says a machine *has* a
+    /// scheduler, not that its operators mind. Only the user knows that, so only
+    /// the user sets this.
+    ///
+    /// A set, not a map: unlike careful mode there is no default to distinguish an
+    /// answer from, so an absent target simply isn't tagged. Stored as a map to
+    /// `bool` anyway so an untagging writes `false` rather than having to delete a
+    /// key from a settings blob the frontend saves whole.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub hpc_hosts: Option<HashMap<String, bool>>,
+    /// Path of the stored `.ovpn` config Eldrun brings up **on launch**, with no
+    /// project behind it. Unset (the default) = no tunnel is started by itself.
+    ///
+    /// One config, not a list: a tunnel reroutes the whole machine, so arming two
+    /// would be arming them to fight over the routing. The frontend re-checks at
+    /// launch that the connect can still be made without a prompt and stays down if
+    /// it can't (see `lib/vpnAutoConnect.ts`); the backend only round-trips this.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vpn_auto_connect: Option<String>,
+    /// The `.ovpn` configs the user asked Eldrun to **remember the credentials of**
+    /// (the VPN menu's "Save login credentials"). No secret lives here — the secrets
+    /// are in the OS keychain; this is only the *intent*, and it exists because the
+    /// keychain cannot always be asked.
+    ///
+    /// A locked Secret Service collection answers every read like an empty one, so
+    /// "is a credential saved for this config?" is unanswerable exactly when it
+    /// matters most: at launch, before anything has unlocked the keyring. Without
+    /// this list the toggle would show *off* over a saved credential and a connect
+    /// would drop to the password prompt rather than offering to unlock. Reconciled
+    /// against the keychain whenever it *is* readable, so it cannot drift for long.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vpn_saved_configs: Option<Vec<String>>,
+    /// Energy-saver mode: "off" | "battery" (default) | "always". When active
+    /// (mode "always", or "battery" while discharging) Eldrun pauses the blob
+    /// auto-spin, collapses idle animations, and widens always-on UI timers.
+    /// Read entirely on the frontend; kept here only so it round-trips.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub energy_saver: Option<String>,
+    /// Header resource-monitor row toggles. Each defaults ON when unset so the
+    /// pill shows CPU/RAM/GPU by default; flip one off to hide that row. Shown in
+    /// every build (independent of `debug`).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub show_cpu_usage: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub show_ram_usage: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub show_gpu_usage: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub global_apps: Option<HashMap<String, GlobalAppEntry>>,
     /// Minimum subwindow (split pane) width in px a divider drag may shrink a
@@ -61,6 +236,11 @@ pub struct Settings {
     /// counterpart for external changes.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub autosave: Option<bool>,
+    /// When true (the default), the in-app text/TeX editors tint recently typed
+    /// runs with a sequential new→old colour trail that fades as typing
+    /// continues. Defaults ON; only an explicit `false` disables it.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub change_tint: Option<bool>,
     /// Per-file-type native-viewer preferences (#48), keyed by a type id derived
     /// from `fileUtils` (e.g. "tex", "text", "markdown"). Holds the opt-in
     /// autocomplete toggle (#45). Optional + flat so older settings files
@@ -73,10 +253,48 @@ pub struct Settings {
     /// fall back to the built-in defaults in the frontend.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub keyboard_shortcuts: Option<HashMap<String, ChordDescriptor>>,
+    /// Download *source* folders scanned by the right-panel Downloads section
+    /// (fast-copy of freshly downloaded files into a project). A machine-wide
+    /// list, read-only — Eldrun never changes any browser's download path.
+    /// Unset/empty → the frontend falls back to the user's `~/Downloads`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub download_sources: Option<Vec<String>>,
+    /// Where the MAIN window was when Eldrun last ran, so it reopens on the same
+    /// monitor in the same place. Unset (fresh install, or a saved rect no live
+    /// monitor can host) → the window opens as `tauri.conf.json` configures it:
+    /// maximized, wherever the WM puts it.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub window_state: Option<WindowState>,
     #[serde(flatten)]
     pub extra: HashMap<String, Value>,
 }
 
+/// Last-known geometry of the MAIN window, in PHYSICAL desktop pixels — the
+/// canonical cross-window coordinate space (see `src/lib/coords.ts`). Tauri's
+/// `outerPosition`/`outerSize`/`set_position`/`set_size` are all physical; only a
+/// *builder*'s `.position()`/`.inner_size()` are logical, which is the trap
+/// `commands::subwindow::detached_position` exists to document.
+///
+/// `x`/`y`/`w`/`h` is the *restore* (non-maximized) rect: it is refreshed only
+/// while the window is floating. Storing the maximized rect here instead would
+/// recreate the bug `WindowControls.tsx` works around — a window whose only known
+/// "normal" size is the whole monitor, so un-maximizing appears to do nothing and
+/// KWin's edge-snap stays suppressed.
+///
+/// There is deliberately no `fullscreen` field. Linux must never enter fullscreen
+/// (a `_NET_WM_STATE_FULLSCREEN` window is unmovable under KWin — see the note in
+/// `lib.rs`'s setup), and macOS is unconditionally fullscreen. Persisting the flag
+/// could only ever strand the window.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
+pub struct WindowState {
+    pub x: i32,
+    pub y: i32,
+    pub w: u32,
+    pub h: u32,
+    #[serde(default)]
+    pub maximized: bool,
+}
+
 /// One entry in `settings["keyboard_shortcuts"]` (Group L / #62). A serializable
 /// key chord mirroring the frontend `ChordDescriptor`. The modifier flags default
 /// to false when absent so the JSON stays compact.
@@ -101,10 +319,24 @@ fn is_false(b: &bool) -> bool {
 /// One per-type entry in `settings["viewer_prefs"]` (#48).
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct ViewerPref {
+    /// Whether this native viewer is used at all. Absent/true renders the type
+    /// in-app; false opts it out so its files open in the external default app.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
     /// Whether Ctrl+Space local autocomplete is enabled for this type (#45).
     /// Defaults OFF (privacy: no model call unless explicitly turned on).
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub autocomplete: Option<bool>,
+    /// Default completion-length mode for this type (#45 modes): `"sentence"`
+    /// (default), `"block"`, or `"scope"`. Cycled live in-editor with Shift+Tab
+    /// while a suggestion is showing; this is just the starting mode. Absent →
+    /// `"sentence"`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub autocomplete_mode: Option<String>,
+    /// Whether the local-model grammar/spelling check is enabled for this type.
+    /// Like `autocomplete`, defaults OFF (no model call unless explicitly on).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub grammar_check: Option<bool>,
     /// Editor font size in px for this type's in-app code editor. Adjusted from
     /// the viewer's A−/A+ controls (or Ctrl +/−/0). Unset falls back to the
     /// frontend default (12px).
@@ -117,7 +349,97 @@ impl Settings {
         self.color_scheme.as_deref().unwrap_or("fancy_dark")
     }
 
-    pub fn workspace_management(&self) -> bool {
-        self.workspace_management.unwrap_or(false)
+    /// Whether Claude agent tabs should be spawned with `--remote-control`.
+    /// Defaults ON when unset so existing settings files opt in automatically.
+    pub fn agent_remote_control(&self) -> bool {
+        self.agent_remote_control.unwrap_or(true)
+    }
+
+    /// Whether the usage recap auto-opens once a day. Defaults ON when unset, so
+    /// an existing install gets the recap without having to find the toggle.
+    pub fn daily_stats_recap(&self) -> bool {
+        self.daily_stats_recap.unwrap_or(true)
+    }
+
+    /// The rule every experimental flag follows (mirrors `src/lib/experimental.ts`):
+    /// unset means **debug mode decides**, so someone building Eldrun gets each new
+    /// experiment without re-ticking a list, and everyone else gets none of them. An
+    /// explicit value always wins, in both directions — otherwise "turn this off"
+    /// would silently fail for exactly the people most likely to hit a broken one.
+    fn experimental(&self, flag: Option<bool>) -> bool {
+        flag.unwrap_or_else(|| self.debug.unwrap_or(false))
+    }
+
+    /// Whether the experimental per-tab Plan/Auto agent-mode badge is offered.
+    /// Switching a mode restarts the agent, so nobody outside debug mode gets that
+    /// behaviour without asking for it.
+    pub fn agent_mode_toggle(&self) -> bool {
+        self.experimental(self.agent_mode_toggle)
+    }
+
+    /// Whether the experimental Python Run/Debug buttons and breakpoint gutter are
+    /// offered in the code viewer. Run *executes the file*, so outside debug mode it
+    /// is opt-in.
+    pub fn python_run_debug(&self) -> bool {
+        self.experimental(self.python_run_debug)
+    }
+
+    /// Whether the experimental native presenter ("deck") is offered — the
+    /// `*.eldeck.json` viewer and its fullscreen presenter. Off outside debug mode
+    /// while the surface is still moving.
+    pub fn deck_presenter(&self) -> bool {
+        self.experimental(self.deck_presenter)
+    }
+
+    /// Whether LOCAL shell/script tabs are wrapped in a persistent tmux session
+    /// (TODO #85). Default ON when unset; only an explicit `Some(false)` opts out.
+    /// The caller still gates on `tmux_local::tmux_available()` (no tmux / Windows →
+    /// no wrap regardless), so this is a preference, not a guarantee.
+    pub fn persist_local_sessions(&self) -> bool {
+        self.persist_local_sessions.unwrap_or(true)
+    }
+
+    /// Whether remote SSH/OpenVPN connections are made headlessly (Eldrun handles
+    /// the password) rather than as interactive root-terminal tabs. Defaults ON
+    /// (headless) when unset so existing behaviour is preserved.
+    pub fn connections_headless(&self) -> bool {
+        self.connections_headless.unwrap_or(true)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Settings;
+
+    /// The experimental rule, backend side (the frontend twin lives in
+    /// `src/__tests__/Experimental.test.ts`): unset defers to debug mode, and an
+    /// explicit value wins in BOTH directions.
+    #[test]
+    fn experimental_flags_default_to_debug_mode() {
+        let off = Settings::default();
+        assert!(!off.python_run_debug());
+        assert!(!off.agent_mode_toggle());
+        assert!(!off.deck_presenter());
+
+        let debug = Settings {
+            debug: Some(true),
+            ..Default::default()
+        };
+        assert!(debug.python_run_debug());
+        assert!(debug.agent_mode_toggle());
+        assert!(debug.deck_presenter());
+
+        let debug_but_off = Settings {
+            debug: Some(true),
+            python_run_debug: Some(false),
+            ..Default::default()
+        };
+        assert!(!debug_but_off.python_run_debug());
+
+        let opted_in = Settings {
+            python_run_debug: Some(true),
+            ..Default::default()
+        };
+        assert!(opted_in.python_run_debug());
     }
 }
diff --git a/src-tauri/src/schema/usage_stats.rs b/src-tauri/src/schema/usage_stats.rs
new file mode 100644
index 0000000..3ec8f78
--- /dev/null
+++ b/src-tauri/src/schema/usage_stats.rs
@@ -0,0 +1,545 @@
+//! `usage_stats.json` — the rolling counter store behind the daily recap.
+//!
+//! Structurally this is [`crate::schema::net_usage`] with a wider payload: the
+//! same hour + day bucket maps keyed by project, the same saturating folds, the
+//! same prune-on-save. Where net_usage stores a fixed `{rx, tx}`, this stores an
+//! open **metric key → count** map, so a new statistic costs one constant in
+//! [`metric`] and one render line in the recap — no schema version, no migration.
+//!
+//! What is deliberately NOT here:
+//!
+//! - **Time** (`time_summary.json`) and **network bytes** (`net_usage.json`)
+//!   already exist as per-project daily rollups; the recap reads them through
+//!   their own commands.
+//! - **Git** commits/lines are re-derived from `git log` on demand
+//!   (`commands::usage_stats::usage_git_stats`).
+//!
+//! Both stay at their source so a counter here can never drift from the truth.
+//!
+//! Counts are `u64`. Durations are counts of **seconds** (`agent.worked_s`) —
+//! the one unit convention in this file.
+
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+use crate::storage;
+
+/// File name of the counter store inside `state_dir()`.
+pub const STATS_FILE: &str = "usage_stats.json";
+
+/// How many hour buckets to retain — 14 days, matching `net_usage`. Keys are
+/// shared across projects (one per wall-clock hour), so this is a calendar
+/// window, not a per-project quota.
+pub const HOUR_RETENTION: usize = 24 * 14;
+
+/// How many day buckets to retain — ~13 months, so a "this month" view always
+/// has a full month behind it and a year-over-year glance still works.
+///
+/// `net_usage` keeps its days forever, which is affordable for two `u64`s per
+/// project per day. A counter map is far wider (one entry per distinct metric,
+/// and the agent/model keys are open-ended), so days are pruned here too.
+pub const DAY_RETENTION: usize = 400;
+
+/// Metric key → count for one (bucket, project) pair.
+pub type Counters = HashMap<String, u64>;
+
+/// The metric keys. Namespaced with `.`; the `<…>` segments are interpolated
+/// (agent command, local model name) and so are open-ended by design.
+///
+/// Mirrored in `src/lib/usageMetrics.ts` — keep the two in step.
+pub mod metric {
+    /// `agent.tab.<cmd>` — an agent tab was opened (not counting restore-respawns).
+    pub const AGENT_TAB: &str = "agent.tab";
+    /// `agent.tab.local.<model>` — a local (Ollama-backed) agent tab was opened.
+    pub const AGENT_TAB_LOCAL: &str = "agent.tab.local";
+    /// `agent.active.<cmd>` — distinct agent tabs that received ≥1 prompt that day.
+    pub const AGENT_ACTIVE: &str = "agent.active";
+    /// `agent.prompt.<cmd>` — prompts submitted to an agent.
+    pub const AGENT_PROMPT: &str = "agent.prompt";
+    /// Seconds agent tabs spent actually working.
+    pub const AGENT_WORKED_S: &str = "agent.worked_s";
+    /// Times an agent stopped to ask the user a decision.
+    pub const AGENT_DECISION: &str = "agent.decision";
+    /// Times an agent finished a turn.
+    pub const AGENT_DONE: &str = "agent.done";
+    /// Commands run in a shell tab.
+    pub const SHELL_COMMAND: &str = "shell.command";
+    /// Files created / modified / deleted, as seen by the watcher.
+    pub const FILE_CREATED: &str = "file.created";
+    pub const FILE_MODIFIED: &str = "file.modified";
+    pub const FILE_DELETED: &str = "file.deleted";
+    /// Tabs opened / closed (every kind, not just agents).
+    pub const TAB_OPENED: &str = "tab.opened";
+    pub const TAB_CLOSED: &str = "tab.closed";
+    /// External apps launched.
+    pub const APP_LAUNCHED: &str = "app.launched";
+
+    /// Compose a dotted key from a prefix and an open-ended segment, e.g.
+    /// `sub(AGENT_PROMPT, "claude")` → `"agent.prompt.claude"`.
+    pub fn sub(prefix: &str, leaf: &str) -> String {
+        format!("{prefix}.{leaf}")
+    }
+}
+
+/// Rolling per-project usage counters at two granularities: hour
+/// ("YYYY-MM-DDTHH") and day ("YYYY-MM-DD"), each mapping project_id → counters.
+///
+/// Serialized shape:
+/// ```json
+/// {
+///   "version": 1,
+///   "hours": { "2026-07-13T14": { "<project-id>": { "agent.prompt.claude": 3 } } },
+///   "days":  { "2026-07-13":    { "<project-id>": { "agent.prompt.claude": 37 } } }
+/// }
+/// ```
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UsageStats {
+    /// Schema version, for forward compatibility.
+    #[serde(default = "default_version")]
+    pub version: u32,
+    /// hour ("YYYY-MM-DDTHH") → project_id → counters. Pruned to the newest
+    /// [`HOUR_RETENTION`] keys on every save.
+    #[serde(default)]
+    pub hours: HashMap<String, HashMap<String, Counters>>,
+    /// date ("YYYY-MM-DD") → project_id → counters. Pruned to the newest
+    /// [`DAY_RETENTION`] keys on every save.
+    #[serde(default)]
+    pub days: HashMap<String, HashMap<String, Counters>>,
+}
+
+fn default_version() -> u32 {
+    1
+}
+
+impl Default for UsageStats {
+    fn default() -> Self {
+        UsageStats {
+            version: 1,
+            hours: HashMap::new(),
+            days: HashMap::new(),
+        }
+    }
+}
+
+impl UsageStats {
+    /// Counters recorded for `project_id` on `date` ("YYYY-MM-DD").
+    pub fn counters_on(&self, project_id: &str, date: &str) -> Counters {
+        lookup(&self.days, project_id, date)
+    }
+
+    /// Counters recorded for `project_id` in `hour` ("YYYY-MM-DDTHH").
+    pub fn counters_in_hour(&self, project_id: &str, hour: &str) -> Counters {
+        lookup(&self.hours, project_id, hour)
+    }
+
+    /// Add `n` to `project_id`'s `key` counter for the UTC hour `hour`
+    /// ("YYYY-MM-DDTHH"), and to the day that hour falls in. Both buckets come
+    /// from the one stamp — the day is its `YYYY-MM-DD` prefix — so they can
+    /// never disagree about when something happened.
+    ///
+    /// A zero delta is a no-op so an idle project never creates empty buckets. A
+    /// malformed stamp is ignored rather than panicking. Saturating, so a
+    /// pathological counter can never overflow.
+    pub fn add(&mut self, project_id: &str, hour: &str, key: &str, n: u64) {
+        if n == 0 || key.is_empty() {
+            return;
+        }
+        let Some(date) = hour.get(..10) else { return };
+        accrue(&mut self.hours, project_id, hour, key, n);
+        accrue(&mut self.days, project_id, date, key, n);
+    }
+
+    /// Fold a whole batch of counters in one pass — what the frontend's periodic
+    /// flush sends.
+    pub fn add_many(&mut self, project_id: &str, hour: &str, counters: &Counters) {
+        for (key, n) in counters {
+            self.add(project_id, hour, key, *n);
+        }
+    }
+
+    /// Per-date counters for `project_id` (or summed across every project when
+    /// empty) — the shape `commands::usage_stats::usage_summary` returns.
+    pub fn daily_for(&self, project_id: &str) -> HashMap<String, Counters> {
+        fold(&self.days, project_id)
+    }
+
+    /// Per-hour counters for `project_id` (or every project when empty), over the
+    /// retained window.
+    pub fn hourly_for(&self, project_id: &str) -> HashMap<String, Counters> {
+        fold(&self.hours, project_id)
+    }
+
+    /// Drop all but the newest [`HOUR_RETENTION`] hour buckets and
+    /// [`DAY_RETENTION`] day buckets. Keys sort lexicographically in
+    /// chronological order (fixed-width, zero-padded), so this needs no date
+    /// arithmetic and no clock read — which also means a backdated or
+    /// clock-skewed key can never evict live ones out of order.
+    pub fn prune(&mut self) {
+        prune_to(&mut self.hours, HOUR_RETENTION);
+        prune_to(&mut self.days, DAY_RETENTION);
+    }
+}
+
+/// `bucket → project → counters` lookup, defaulting to empty.
+fn lookup(
+    buckets: &HashMap<String, HashMap<String, Counters>>,
+    project_id: &str,
+    key: &str,
+) -> Counters {
+    buckets
+        .get(key)
+        .and_then(|by_project| by_project.get(project_id))
+        .cloned()
+        .unwrap_or_default()
+}
+
+/// Fold `n` into `buckets[bucket][project_id][key]`, creating buckets as needed.
+fn accrue(
+    buckets: &mut HashMap<String, HashMap<String, Counters>>,
+    project_id: &str,
+    bucket: &str,
+    key: &str,
+    n: u64,
+) {
+    let entry = buckets
+        .entry(bucket.to_string())
+        .or_default()
+        .entry(project_id.to_string())
+        .or_default()
+        .entry(key.to_string())
+        .or_insert(0);
+    *entry = entry.saturating_add(n);
+}
+
+/// Collapse `bucket → project → counters` to `bucket → counters` for one project
+/// (or summed across all projects when `project_id` is empty).
+fn fold(
+    buckets: &HashMap<String, HashMap<String, Counters>>,
+    project_id: &str,
+) -> HashMap<String, Counters> {
+    let mut out: HashMap<String, Counters> = HashMap::new();
+    for (bucket, by_project) in buckets {
+        for (pid, counters) in by_project {
+            if project_id.is_empty() || pid == project_id {
+                let acc = out.entry(bucket.clone()).or_default();
+                for (key, n) in counters {
+                    let slot = acc.entry(key.clone()).or_insert(0);
+                    *slot = slot.saturating_add(*n);
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Retain only the newest `keep` keys of a bucket map.
+fn prune_to(buckets: &mut HashMap<String, HashMap<String, Counters>>, keep: usize) {
+    if buckets.len() <= keep {
+        return;
+    }
+    let mut keys: Vec<&str> = buckets.keys().map(String::as_str).collect();
+    keys.sort_unstable();
+    let cutoff = keys[keys.len() - keep].to_string();
+    buckets.retain(|bucket, _| *bucket >= cutoff);
+}
+
+// ── On-disk helpers ────────────────────────────────────────────────────────
+
+fn stats_path() -> std::path::PathBuf {
+    storage::state_dir().join(STATS_FILE)
+}
+
+/// Load the counter store, defaulting to empty when the file is absent or
+/// unparseable (a brand-new install, or a partial write) rather than erroring.
+pub fn load() -> UsageStats {
+    let path = stats_path();
+    if path.exists() {
+        storage::read_json(&path).unwrap_or_default()
+    } else {
+        UsageStats::default()
+    }
+}
+
+/// Persist the counter store, pruning stale buckets first. Pruning lives here
+/// rather than in `add` so it is impossible for a writer to skip it, and so it
+/// costs one sort per flush rather than one per counter.
+///
+/// Written atomically: unlike the other stores this one has two writers (the
+/// frontend's batched flush and the file watcher), so a torn read is a real
+/// possibility rather than a theoretical one.
+pub fn save(stats: &mut UsageStats) -> Result<(), String> {
+    stats.version = 1;
+    stats.prune();
+    storage::write_json_atomic(&stats_path(), stats).map_err(|e| e.to_string())
+}
+
+/// Fold a batch of counters for `project_id` into the current UTC hour (and
+/// thereby the current UTC day). O(map) read-modify-write of a bounded file. An
+/// empty batch is skipped without touching disk.
+pub fn record(project_id: &str, counters: &Counters) {
+    if project_id.is_empty() || counters.is_empty() {
+        return;
+    }
+    let mut stats = load();
+    stats.add_many(project_id, &storage::hour_utc(), counters);
+    let _ = save(&mut stats);
+}
+
+/// Fold a single counter — the convenience path for backend-side one-shot events
+/// (a tab spawn).
+pub fn record_one(project_id: &str, key: &str, n: u64) {
+    let mut counters = Counters::new();
+    counters.insert(key.to_string(), n);
+    record(project_id, &counters);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn counters(pairs: &[(&str, u64)]) -> Counters {
+        pairs.iter().map(|(k, n)| (k.to_string(), *n)).collect()
+    }
+
+    // ── add / lookup ───────────────────────────────────────────────────────
+
+    #[test]
+    fn add_lands_in_both_hour_and_day() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::SHELL_COMMAND, 3);
+        assert_eq!(
+            s.counters_in_hour("p1", "2026-07-13T14")[metric::SHELL_COMMAND],
+            3
+        );
+        // The day bucket is the hour stamp's first ten chars — the two can never
+        // disagree about when something happened.
+        assert_eq!(s.counters_on("p1", "2026-07-13")[metric::SHELL_COMMAND], 3);
+    }
+
+    #[test]
+    fn add_accumulates_across_calls() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::AGENT_DECISION, 2);
+        s.add("p1", "2026-07-13T15", metric::AGENT_DECISION, 5);
+        // Different hours, same day.
+        assert_eq!(s.counters_on("p1", "2026-07-13")[metric::AGENT_DECISION], 7);
+        assert_eq!(
+            s.counters_in_hour("p1", "2026-07-13T14")[metric::AGENT_DECISION],
+            2
+        );
+    }
+
+    #[test]
+    fn add_keeps_projects_separate() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::TAB_OPENED, 1);
+        s.add("p2", "2026-07-13T14", metric::TAB_OPENED, 9);
+        assert_eq!(s.counters_on("p1", "2026-07-13")[metric::TAB_OPENED], 1);
+        assert_eq!(s.counters_on("p2", "2026-07-13")[metric::TAB_OPENED], 9);
+    }
+
+    #[test]
+    fn add_zero_is_a_no_op() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::TAB_OPENED, 0);
+        // An idle project must not create empty buckets.
+        assert!(s.days.is_empty());
+        assert!(s.hours.is_empty());
+    }
+
+    #[test]
+    fn add_empty_key_is_a_no_op() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", "", 5);
+        assert!(s.days.is_empty());
+    }
+
+    #[test]
+    fn add_with_malformed_stamp_is_ignored_not_panicking() {
+        let mut s = UsageStats::default();
+        s.add("p1", "short", metric::TAB_OPENED, 1);
+        assert!(s.days.is_empty());
+        assert!(s.hours.is_empty());
+    }
+
+    #[test]
+    fn add_saturates_rather_than_overflowing() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::AGENT_WORKED_S, u64::MAX);
+        s.add("p1", "2026-07-13T14", metric::AGENT_WORKED_S, 10);
+        assert_eq!(
+            s.counters_on("p1", "2026-07-13")[metric::AGENT_WORKED_S],
+            u64::MAX
+        );
+    }
+
+    #[test]
+    fn lookup_of_absent_bucket_is_empty_not_panicking() {
+        let s = UsageStats::default();
+        assert!(s.counters_on("nobody", "1999-01-01").is_empty());
+        assert!(s.counters_in_hour("nobody", "1999-01-01T00").is_empty());
+    }
+
+    // ── add_many ───────────────────────────────────────────────────────────
+
+    #[test]
+    fn add_many_folds_a_whole_batch() {
+        let mut s = UsageStats::default();
+        s.add_many(
+            "p1",
+            "2026-07-13T14",
+            &counters(&[("agent.prompt.claude", 4), ("shell.command", 2)]),
+        );
+        let day = s.counters_on("p1", "2026-07-13");
+        assert_eq!(day["agent.prompt.claude"], 4);
+        assert_eq!(day["shell.command"], 2);
+    }
+
+    // ── open-ended metric keys ─────────────────────────────────────────────
+
+    #[test]
+    fn sub_composes_a_dotted_key() {
+        assert_eq!(metric::sub(metric::AGENT_PROMPT, "claude"), "agent.prompt.claude");
+        assert_eq!(
+            metric::sub(metric::AGENT_TAB_LOCAL, "qwen3:8b"),
+            "agent.tab.local.qwen3:8b"
+        );
+    }
+
+    #[test]
+    fn per_agent_keys_do_not_collide() {
+        let mut s = UsageStats::default();
+        s.add(
+            "p1",
+            "2026-07-13T14",
+            &metric::sub(metric::AGENT_PROMPT, "claude"),
+            10,
+        );
+        s.add(
+            "p1",
+            "2026-07-13T14",
+            &metric::sub(metric::AGENT_PROMPT, "codex"),
+            3,
+        );
+        let day = s.counters_on("p1", "2026-07-13");
+        assert_eq!(day["agent.prompt.claude"], 10);
+        assert_eq!(day["agent.prompt.codex"], 3);
+    }
+
+    // ── fold (daily_for / hourly_for) ──────────────────────────────────────
+
+    #[test]
+    fn daily_for_one_project_excludes_the_others() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::TAB_OPENED, 1);
+        s.add("p2", "2026-07-13T14", metric::TAB_OPENED, 9);
+        let folded = s.daily_for("p1");
+        assert_eq!(folded["2026-07-13"][metric::TAB_OPENED], 1);
+    }
+
+    #[test]
+    fn daily_for_empty_project_sums_across_all_projects() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::TAB_OPENED, 1);
+        s.add("p2", "2026-07-13T14", metric::TAB_OPENED, 9);
+        let folded = s.daily_for("");
+        assert_eq!(folded["2026-07-13"][metric::TAB_OPENED], 10);
+    }
+
+    #[test]
+    fn hourly_for_folds_per_hour_not_per_day() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::SHELL_COMMAND, 2);
+        s.add("p1", "2026-07-13T15", metric::SHELL_COMMAND, 5);
+        let folded = s.hourly_for("p1");
+        assert_eq!(folded["2026-07-13T14"][metric::SHELL_COMMAND], 2);
+        assert_eq!(folded["2026-07-13T15"][metric::SHELL_COMMAND], 5);
+    }
+
+    // ── prune ──────────────────────────────────────────────────────────────
+
+    #[test]
+    fn prune_keeps_the_newest_hours_and_drops_the_oldest() {
+        let mut s = UsageStats::default();
+        // One more hour than the retention window, all on distinct days so the
+        // day map is not what is being tested here.
+        for i in 0..(HOUR_RETENTION + 1) {
+            let hour = format!("2020-01-01T00-{i:05}"); // sortable, ascending
+            s.hours
+                .entry(hour)
+                .or_default()
+                .entry("p1".into())
+                .or_default()
+                .insert(metric::TAB_OPENED.into(), 1);
+        }
+        s.prune();
+        assert_eq!(s.hours.len(), HOUR_RETENTION);
+        assert!(!s.hours.contains_key("2020-01-01T00-00000"), "oldest dropped");
+        assert!(
+            s.hours.contains_key(&format!("2020-01-01T00-{:05}", HOUR_RETENTION)),
+            "newest kept"
+        );
+    }
+
+    #[test]
+    fn prune_keeps_the_newest_days_and_drops_the_oldest() {
+        let mut s = UsageStats::default();
+        for i in 0..(DAY_RETENTION + 1) {
+            let day = format!("2020-{i:05}"); // sortable, ascending
+            s.days
+                .entry(day)
+                .or_default()
+                .entry("p1".into())
+                .or_default()
+                .insert(metric::TAB_OPENED.into(), 1);
+        }
+        s.prune();
+        assert_eq!(s.days.len(), DAY_RETENTION);
+        assert!(!s.days.contains_key("2020-00000"), "oldest dropped");
+        assert!(
+            s.days.contains_key(&format!("2020-{:05}", DAY_RETENTION)),
+            "newest kept"
+        );
+    }
+
+    #[test]
+    fn prune_under_the_limit_changes_nothing() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", metric::TAB_OPENED, 1);
+        s.prune();
+        assert_eq!(s.days.len(), 1);
+        assert_eq!(s.hours.len(), 1);
+    }
+
+    // ── serde ──────────────────────────────────────────────────────────────
+
+    #[test]
+    fn roundtrips_through_json() {
+        let mut s = UsageStats::default();
+        s.add("p1", "2026-07-13T14", "agent.prompt.claude", 37);
+        let json = serde_json::to_string(&s).unwrap();
+        let back: UsageStats = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.counters_on("p1", "2026-07-13")["agent.prompt.claude"], 37);
+        assert_eq!(back.version, 1);
+    }
+
+    #[test]
+    fn empty_json_object_loads_as_default() {
+        // Every field is #[serde(default)], so a truncated or future-written file
+        // degrades to "no history" instead of failing the whole load.
+        let back: UsageStats = serde_json::from_str("{}").unwrap();
+        assert_eq!(back.version, 1);
+        assert!(back.days.is_empty());
+        assert!(back.hours.is_empty());
+    }
+
+    #[test]
+    fn unknown_metric_keys_survive_a_roundtrip() {
+        // The key space is open by design: a file written by a NEWER Eldrun that
+        // knows metrics this build does not must not lose them on rewrite.
+        let json = r#"{"version":1,"days":{"2026-07-13":{"p1":{"future.metric":5}}}}"#;
+        let back: UsageStats = serde_json::from_str(json).unwrap();
+        assert_eq!(back.counters_on("p1", "2026-07-13")["future.metric"], 5);
+    }
+}
diff --git a/src-tauri/src/services/agent_session.rs b/src-tauri/src/services/agent_session.rs
index 45b444f..a999d4c 100644
--- a/src-tauri/src/services/agent_session.rs
+++ b/src-tauri/src/services/agent_session.rs
@@ -17,7 +17,13 @@ use crate::paths;
 use crate::storage;
 use crate::terminal::PtyOptions;
 
+// The hook body is platform-specific: a POSIX `#!/bin/sh` script that the agents'
+// shell (`/bin/sh`) runs directly on unix, and a PowerShell script on Windows
+// (there is no `/bin/sh`; the agents run the hook `command` through `cmd.exe`).
+#[cfg(not(windows))]
 const HOOK_SCRIPT_NAME: &str = "eldrun_session_start.sh";
+#[cfg(windows)]
+const HOOK_SCRIPT_NAME: &str = "eldrun_session_start.ps1";
 
 // ── Agent session resolution ────────────────────────────────────────────────
 //
@@ -195,9 +201,30 @@ fn hook_script_path() -> PathBuf {
     storage::state_dir().join("hooks").join(HOOK_SCRIPT_NAME)
 }
 
+/// The `command` string Eldrun registers in the agents' SessionStart hook config
+/// (Claude `settings.json` / Codex `config.toml`). The agents run this through the
+/// OS shell, so it must be runnable there: on unix the bare `#!/bin/sh` script path
+/// suffices, but on Windows `cmd.exe` cannot execute that script, so we invoke the
+/// PowerShell hook explicitly. `-File` makes PowerShell read the script while still
+/// forwarding the hook's stdin JSON payload to it.
+fn hook_command() -> String {
+    let path = hook_script_path();
+    #[cfg(windows)]
+    {
+        format!(
+            "powershell -NoProfile -ExecutionPolicy Bypass -File \"{}\"",
+            path.to_string_lossy()
+        )
+    }
+    #[cfg(not(windows))]
+    {
+        path.to_string_lossy().into_owned()
+    }
+}
+
 /// uuid-ish guard: hex digits + dashes only, non-empty. Doubles as path-traversal
 /// protection for the file key.
-fn is_uuidish(s: &str) -> bool {
+pub fn is_uuidish(s: &str) -> bool {
     !s.is_empty() && s.chars().all(|c| c.is_ascii_hexdigit() || c == '-')
 }
 
@@ -221,6 +248,173 @@ pub fn read_live_session_in(dir: &std::path::Path, uid: &str) -> Option<String>
     }
 }
 
+/// Record `id` as the live session for `uid` — the same file, in the same
+/// format, that the SessionStart hook writes. This is what lets
+/// [`crate::services::codex_bind`] act as a drop-in stand-in for an untrusted
+/// Codex hook without touching the resolve path.
+pub fn write_live_session(uid: &str, id: &str) -> std::io::Result<()> {
+    write_live_session_in(&live_sessions_dir(), uid, id)
+}
+
+/// Testable core of [`write_live_session`]. The uuid-ish guard on both keys is
+/// path-traversal defense (`uid` becomes a filename). Writes via a temp file +
+/// rename so a hook writing the same key concurrently can never observe a torn
+/// value.
+pub fn write_live_session_in(dir: &std::path::Path, uid: &str, id: &str) -> std::io::Result<()> {
+    if !is_uuidish(uid) || !is_uuidish(id) {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            "live-session keys must be uuid-ish",
+        ));
+    }
+    std::fs::create_dir_all(dir)?;
+    let tmp = dir.join(format!(".{uid}.tmp"));
+    std::fs::write(&tmp, id)?;
+    std::fs::rename(&tmp, dir.join(uid))?;
+    Ok(())
+}
+
+// ── Codex hook trust state ──────────────────────────────────────────────────
+
+/// What Eldrun's Codex `SessionStart` hook is actually doing right now.
+///
+/// Codex gates *user-level* hooks behind a one-time trust approval (`/hooks`
+/// inside Codex), recording the verdict in a `[hooks.state."…"]` table. An
+/// untrusted or disabled hook simply never runs — silently — which is why Codex
+/// tabs used to restore into a blank conversation: no live id was ever recorded,
+/// so [`resolve_codex_session`] had nothing to resume.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CodexHookState {
+    /// No `~/.codex` — Codex isn't in use, so there is nothing to report.
+    NoCodex,
+    /// Codex is in use but our hook isn't in its config (registration failed).
+    NotRegistered,
+    /// Registered, but Codex has no trust verdict for it yet → it never runs.
+    Untrusted,
+    /// Registered and known to Codex, but explicitly `enabled = false`.
+    Disabled,
+    /// Registered and trusted → the precise resume path is live.
+    Enabled,
+}
+
+/// Classify Eldrun's hook in the user's Codex config.
+pub fn codex_hook_state() -> CodexHookState {
+    let codex_dir = paths::home_dir().join(".codex");
+    if !codex_dir.is_dir() {
+        return CodexHookState::NoCodex;
+    }
+    let config = codex_dir.join("config.toml");
+    let src = std::fs::read_to_string(&config).unwrap_or_default();
+    codex_hook_state_in(&src, &config.to_string_lossy(), &hook_command())
+}
+
+/// Testable core of [`codex_hook_state`].
+///
+/// A line scanner, not a TOML parse — deliberately, for the same reason
+/// [`register_codex_hook_in`] text-appends: taking a `toml` dependency just to
+/// read two keys isn't worth it, and the shapes involved are fixed.
+///
+/// Codex keys its trust verdicts by *position*: `<config path>:session_start:
+/// <group>:<hook>`, where the indices count `[[hooks.SessionStart]]` tables and
+/// the `[[hooks.SessionStart.hooks]]` tables within each. So we find our hook by
+/// its `command`, note where it sits, and look the verdict up under that key.
+pub fn codex_hook_state_in(src: &str, config_path: &str, cmd: &str) -> CodexHookState {
+    let mut group: i64 = -1;
+    let mut hook: i64 = -1;
+    let mut in_hook_table = false;
+    let mut ours: Option<(i64, i64)> = None;
+    let mut state_key: Option<String> = None;
+    let mut verdicts: std::collections::HashMap<String, bool> = std::collections::HashMap::new();
+
+    for raw in src.lines() {
+        let line = raw.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        if line.starts_with('[') {
+            in_hook_table = false;
+            state_key = None;
+            if line.starts_with("[[hooks.SessionStart]]") {
+                group += 1;
+                hook = -1;
+            } else if line.starts_with("[[hooks.SessionStart.hooks]]") {
+                hook += 1;
+                in_hook_table = true;
+            } else if let Some(key) = toml_state_table_key(line) {
+                state_key = Some(key);
+            }
+            continue;
+        }
+        if in_hook_table {
+            if toml_value(line, "command").as_deref() == Some(cmd) {
+                ours = Some((group.max(0), hook.max(0)));
+            }
+        } else if let Some(key) = state_key.as_ref() {
+            if let Some(v) = toml_value(line, "enabled") {
+                verdicts.insert(key.clone(), v == "true");
+            }
+        }
+    }
+
+    let Some((g, h)) = ours else {
+        return CodexHookState::NotRegistered;
+    };
+    let suffix = format!(":session_start:{g}:{h}");
+    let verdict = verdicts
+        .get(&format!("{config_path}{suffix}"))
+        // Fall back to any entry at our position: Codex builds the key from the
+        // config path *it* resolved, which can differ from ours in spelling (a
+        // symlinked `$CODEX_HOME`, a `/private` prefix on macOS).
+        .or_else(|| {
+            verdicts
+                .iter()
+                .find(|(k, _)| k.ends_with(&suffix))
+                .map(|(_, v)| v)
+        });
+    match verdict {
+        Some(true) => CodexHookState::Enabled,
+        Some(false) => CodexHookState::Disabled,
+        None => CodexHookState::Untrusted,
+    }
+}
+
+/// `[hooks.state."<key>"]` → `<key>`. Any other table header → `None`.
+fn toml_state_table_key(header: &str) -> Option<String> {
+    let inner = header
+        .strip_prefix("[hooks.state.")?
+        .strip_suffix(']')?
+        .trim();
+    let unquoted = inner
+        .strip_prefix('"')
+        .and_then(|s| s.strip_suffix('"'))
+        .unwrap_or(inner);
+    Some(unquoted.to_string())
+}
+
+/// `key = <value>` → the value, unquoted. `None` when the line isn't `key`'s.
+fn toml_value(line: &str, key: &str) -> Option<String> {
+    let (lhs, rhs) = line.split_once('=')?;
+    if lhs.trim() != key {
+        return None;
+    }
+    let v = rhs.trim();
+    let unquoted = v
+        .strip_prefix('\'')
+        .and_then(|s| s.strip_suffix('\''))
+        .or_else(|| v.strip_prefix('"').and_then(|s| s.strip_suffix('"')))
+        .unwrap_or(v);
+    Some(unquoted.to_string())
+}
+
+/// Whether the hook-free rollout binder ([`crate::services::codex_bind`]) should
+/// run for a Codex tab. It is the *fallback*: when the hook is trusted it is
+/// strictly more precise (it fires on `/clear` immediately and can't confuse two
+/// tabs sharing a cwd), so we stay out of its way.
+pub fn codex_binder_enabled() -> bool {
+    !matches!(codex_hook_state(), CodexHookState::Enabled)
+}
+
 /// Install (idempotently) the `SessionStart` hook and its script for every agent
 /// Eldrun can track (Claude + Codex), so it learns each tab's live session id.
 /// Safe to call on every startup. The shared script keys by `$ELDRUN_TAB_UID`
@@ -257,6 +451,7 @@ fn write_hook_script() -> std::io::Result<()> {
 /// POSIX-sh hook body. Reads the SessionStart JSON on stdin, extracts
 /// `session_id`, and records it under `<live_dir>/<ELDRUN_TAB_UID>`. No jq
 /// dependency: a single `sed` pulls the uuid out of the one-line JSON.
+#[cfg(not(windows))]
 fn hook_script_body(live_dir: &str) -> String {
     format!(
         "#!/bin/sh\n\
@@ -276,6 +471,38 @@ fn hook_script_body(live_dir: &str) -> String {
     )
 }
 
+/// PowerShell hook body (Windows). Mirrors the POSIX script: reads the SessionStart
+/// JSON on stdin, extracts `session_id` with a regex (no jq/`Get-Content` JSON
+/// dependency), and writes it to `<live_dir>/<ELDRUN_TAB_UID>` using the same key
+/// scheme `read_live_session` reads back. No-op unless launched by Eldrun
+/// (`ELDRUN_TAB_UID` set); the uuid-ish guard doubles as path-traversal defense.
+/// `[IO.File]::WriteAllText` writes UTF-8 *without* a BOM, so the stored id round-
+/// trips cleanly through `read_live_session`'s `trim()`/`is_uuidish` checks.
+#[cfg(windows)]
+fn hook_script_body(live_dir: &str) -> String {
+    // `live_dir` is a Windows path (backslashes); embed it in a single-quoted
+    // PowerShell literal so backslashes are not treated as escapes.
+    let live_dir = live_dir.replace('\'', "''");
+    format!(
+        "# Eldrun SessionStart hook - records the agent's live session id per tab so\r\n\
+         # Eldrun can resume the current session (incl. after /clear). No-op unless\r\n\
+         # launched by Eldrun (ELDRUN_TAB_UID set). Managed by Eldrun; do not edit.\r\n\
+         $ErrorActionPreference = 'SilentlyContinue'\r\n\
+         $uid = $env:ELDRUN_TAB_UID\r\n\
+         if ([string]::IsNullOrEmpty($uid)) {{ exit 0 }}\r\n\
+         if ($uid -notmatch '^[A-Za-z0-9-]+$') {{ exit 0 }}\r\n\
+         $payload = [Console]::In.ReadToEnd()\r\n\
+         $m = [regex]::Match($payload, '\"session_id\"\\s*:\\s*\"([0-9A-Fa-f-]+)\"')\r\n\
+         if (-not $m.Success) {{ exit 0 }}\r\n\
+         $sid = $m.Groups[1].Value\r\n\
+         $dir = '{live_dir}'\r\n\
+         [void](New-Item -ItemType Directory -Force -Path $dir -ErrorAction SilentlyContinue)\r\n\
+         [IO.File]::WriteAllText((Join-Path $dir $uid), $sid)\r\n\
+         exit 0\r\n",
+        live_dir = live_dir,
+    )
+}
+
 /// Merge our `SessionStart` handler into a Claude `settings.json`, preserving all
 /// other content and other hooks. Idempotent: a handler already pointing at our
 /// script is left untouched. The matcher is omitted so the hook fires for every
@@ -291,7 +518,7 @@ fn register_hook_in_settings(settings_path: &std::path::Path) -> std::io::Result
     if !root.is_object() {
         root = serde_json::json!({});
     }
-    let cmd = hook_script_path().to_string_lossy().into_owned();
+    let cmd = hook_command();
 
     let obj = root.as_object_mut().unwrap();
     let hooks = obj.entry("hooks").or_insert_with(|| serde_json::json!({}));
@@ -339,7 +566,10 @@ fn register_hook_in_settings(settings_path: &std::path::Path) -> std::io::Result
 /// content. Idempotent: skipped once our script path is present.
 ///
 /// NOTE: user-level Codex hooks require a one-time trust approval (`/hooks` in
-/// Codex) before they run, so resume tracking is inert until the user trusts it.
+/// Codex) before they run, so resume tracking through *this* path is inert until
+/// the user trusts it — see [`codex_hook_state`], which detects that, and
+/// [`crate::services::codex_bind`], the hook-free fallback that keeps Codex tabs
+/// resumable meanwhile.
 fn register_codex_hook() -> std::io::Result<()> {
     let codex_dir = paths::home_dir().join(".codex");
     if !codex_dir.is_dir() {
@@ -350,7 +580,7 @@ fn register_codex_hook() -> std::io::Result<()> {
 
 /// Testable core of [`register_codex_hook`] against an explicit config path.
 fn register_codex_hook_in(config_path: &std::path::Path) -> std::io::Result<()> {
-    let cmd = hook_script_path().to_string_lossy().into_owned();
+    let cmd = hook_command();
     let mut content = std::fs::read_to_string(config_path).unwrap_or_default();
     if content.contains(&cmd) {
         return Ok(());
@@ -399,6 +629,11 @@ mod tests {
             cols: 80,
             rows: 24,
             local_only: false,
+            sandbox: false,
+            project_id: None,
+            remote_host_id: None,
+            tmux_session: None,
+            tmux_attach: None,
         }
     }
 
@@ -617,6 +852,7 @@ mod tests {
         let _ = std::fs::remove_dir_all(&tmp);
     }
 
+    #[cfg(not(windows))]
     #[test]
     fn hook_body_is_no_op_without_env_and_bakes_dir() {
         let body = hook_script_body("/home/x/.local/share/eldrun/live_sessions");
@@ -626,6 +862,16 @@ mod tests {
         assert!(body.contains("\"session_id\""));
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn hook_body_is_no_op_without_env_and_bakes_dir() {
+        let body = hook_script_body(r"C:\Users\x\AppData\Roaming\eldrun\live_sessions");
+        assert!(body.contains("$uid = $env:ELDRUN_TAB_UID"));
+        assert!(body.contains("if ([string]::IsNullOrEmpty($uid)) { exit 0 }"));
+        assert!(body.contains(r"C:\Users\x\AppData\Roaming\eldrun\live_sessions"));
+        assert!(body.contains("\"session_id\""));
+    }
+
     #[test]
     fn register_hook_is_idempotent_and_preserves_other_keys() {
         let tmp = std::env::temp_dir().join(format!("eldrun-settings-{}", std::process::id()));
@@ -645,7 +891,9 @@ mod tests {
         let ss = v["hooks"]["SessionStart"].as_array().unwrap();
         assert_eq!(ss.len(), 1);
         let cmd = ss[0]["hooks"][0]["command"].as_str().unwrap();
-        assert!(cmd.ends_with(HOOK_SCRIPT_NAME));
+        // unix registers the bare script path (ends with the name); Windows wraps it
+        // in a `powershell ... -File "<path>"` invocation, so assert containment.
+        assert!(cmd.contains(HOOK_SCRIPT_NAME));
 
         let _ = std::fs::remove_dir_all(&tmp);
     }
@@ -676,4 +924,129 @@ mod tests {
 
         let _ = std::fs::remove_dir_all(&tmp);
     }
+
+    // ── Codex hook trust state ──────────────────────────────────────────────
+
+    const CFG: &str = "/home/x/.codex/config.toml";
+    const CMD: &str = "/home/x/.local/share/eldrun/hooks/eldrun_session_start.sh";
+
+    /// Our hook block as `register_codex_hook_in` writes it.
+    fn our_hook() -> String {
+        format!(
+            "[[hooks.SessionStart]]\n\
+             matcher = \"startup|resume|clear|compact\"\n\n\
+             [[hooks.SessionStart.hooks]]\n\
+             type = \"command\"\n\
+             command = '{CMD}'\n\
+             timeout = 10\n"
+        )
+    }
+
+    #[test]
+    fn codex_hook_state_reports_disabled_when_the_trust_gate_is_off() {
+        // Regression test for the bug this whole path exists to fix: Codex had
+        // hashed our hook and recorded `enabled = false`, so it never ran and
+        // Codex tabs silently restored blank.
+        let src = format!(
+            "model = \"o3\"\n\n{}\n[hooks.state]\n\n[hooks.state.\"{CFG}:session_start:0:0\"]\n\
+             trusted_hash = \"sha256:93f0\"\nenabled = false\n",
+            our_hook()
+        );
+        assert_eq!(codex_hook_state_in(&src, CFG, CMD), CodexHookState::Disabled);
+    }
+
+    #[test]
+    fn codex_hook_state_reports_untrusted_without_a_verdict() {
+        let src = our_hook();
+        assert_eq!(codex_hook_state_in(&src, CFG, CMD), CodexHookState::Untrusted);
+    }
+
+    #[test]
+    fn codex_hook_state_reports_enabled_when_trusted() {
+        let src = format!(
+            "{}\n[hooks.state.\"{CFG}:session_start:0:0\"]\nenabled = true\n",
+            our_hook()
+        );
+        assert_eq!(codex_hook_state_in(&src, CFG, CMD), CodexHookState::Enabled);
+    }
+
+    #[test]
+    fn codex_hook_state_indexes_our_hook_past_the_users_own() {
+        // A user hook group precedes ours, so our verdict key is `:0:0` → no,
+        // `:1:0`. Their `enabled = true` at `:0:0` must not be read as ours.
+        let src = format!(
+            "[[hooks.SessionStart]]\n\n[[hooks.SessionStart.hooks]]\n\
+             type = \"command\"\ncommand = '/usr/bin/their-hook.sh'\n\n\
+             {}\n[hooks.state.\"{CFG}:session_start:0:0\"]\nenabled = true\n",
+            our_hook()
+        );
+        assert_eq!(codex_hook_state_in(&src, CFG, CMD), CodexHookState::Untrusted);
+
+        // And with the verdict at *our* index, we read it.
+        let trusted = format!("{src}\n[hooks.state.\"{CFG}:session_start:1:0\"]\nenabled = true\n");
+        assert_eq!(
+            codex_hook_state_in(&trusted, CFG, CMD),
+            CodexHookState::Enabled
+        );
+    }
+
+    #[test]
+    fn codex_hook_state_is_not_registered_without_our_command() {
+        let src = "model = \"o3\"\n\n[projects.\"/home/x\"]\ntrust_level = \"trusted\"\n";
+        assert_eq!(
+            codex_hook_state_in(src, CFG, CMD),
+            CodexHookState::NotRegistered
+        );
+    }
+
+    #[test]
+    fn codex_hook_state_tolerates_a_config_path_spelled_differently() {
+        // Codex builds the key from the path *it* resolved (symlinked CODEX_HOME,
+        // macOS `/private` prefix …), so we fall back to matching our position.
+        let src = format!(
+            "{}\n[hooks.state.\"/private{CFG}:session_start:0:0\"]\nenabled = false\n",
+            our_hook()
+        );
+        assert_eq!(codex_hook_state_in(&src, CFG, CMD), CodexHookState::Disabled);
+    }
+
+    #[test]
+    fn write_live_session_round_trips_and_refuses_junk_keys() {
+        let tmp = unique_tmp("eldrun-live-write");
+        let uid = "11111111-2222-3333-4444-555555555555";
+        let id = "019ea7c8-b7d5-7a13-80e2-1ad6608db5e6";
+
+        write_live_session_in(&tmp, uid, id).unwrap();
+        assert_eq!(read_live_session_in(&tmp, uid).as_deref(), Some(id));
+
+        // The uid becomes a filename, so a traversal key must never be written.
+        assert!(write_live_session_in(&tmp, "../../etc/passwd", id).is_err());
+        assert!(write_live_session_in(&tmp, uid, "not a uuid!").is_err());
+        // …and the good value survives the refused writes.
+        assert_eq!(read_live_session_in(&tmp, uid).as_deref(), Some(id));
+
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+
+    #[test]
+    fn resolve_codex_session_reads_a_binder_written_record() {
+        // The seam the hook-free fallback relies on: whatever `codex_bind` writes
+        // with `write_live_session_in` must come back out of the *unchanged*
+        // resolve path as `codex resume <id>`.
+        let live = "019ea7c8-b7d5-7a13-80e2-1ad6608db5e6";
+        let uid = "11111111-2222-3333-4444-555555555555";
+        let root = codex_sessions_with(live);
+        let live_dir = unique_tmp("eldrun-live-seam");
+
+        write_live_session_in(&live_dir, uid, live).unwrap();
+
+        let mut opts = codex_opts();
+        opts.env.insert("ELDRUN_TAB_UID".to_string(), uid.to_string());
+        let out =
+            resolve_codex_session_impl(opts, &root, |u| read_live_session_in(&live_dir, u));
+        assert_eq!(out.args, vec!["resume".to_string(), live.to_string()]);
+
+        let _ = std::fs::remove_dir_all(&root);
+        let _ = std::fs::remove_dir_all(&live_dir);
+    }
 }
diff --git a/src-tauri/src/services/big_folders.rs b/src-tauri/src/services/big_folders.rs
new file mode 100644
index 0000000..803d5b6
--- /dev/null
+++ b/src-tauri/src/services/big_folders.rs
@@ -0,0 +1,341 @@
+//! Finding the folders that are too big to sync, on **both** sides of a remote
+//! project — and doing it *before* the first sync pass rather than after it.
+//!
+//! Byte-sync's scope is an explicit opt-in manifest and it does **not** read
+//! `.gitignore` (`commands::sync::sync_auto_preview` says the same thing one
+//! folder at a time). The moment that costs the most is the one where the user
+//! has the least information: a project just created, imported, or extended to a
+//! host, where a single `node_modules/`, `data/`, `checkpoints/` or `.venv/`
+//! decides whether the first pass moves a few MB or a few hundred thousand
+//! files. So this module answers one question — *which folders are giant?* — for
+//! the local mirror and the host tree alike, and the caller turns the answer into
+//! one prompt with one checkbox per folder.
+//!
+//! The two sides are measured differently but reduced to the SAME shape: a flat
+//! list of `(project-relative path, bytes)` per regular file. Everything after
+//! that ([`tally_dirs`] + [`pick`]) is pure, side-agnostic and unit-tested, which
+//! is what keeps "local says 12 GB, host says 40" from being two heuristics that
+//! disagree for reasons nobody can reconstruct.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+/// A folder is worth asking about at this many files, whatever its size: file
+/// *count* — not bytes — is what makes a sync pass take minutes and what makes
+/// the manifest enormous (`node_modules` is the canonical case: small, endless).
+pub const MIN_FILES: u64 = 2_000;
+
+/// …or at this many bytes, however few files (a checkpoint dir is the mirror
+/// image: a handful of files, tens of GB).
+pub const MIN_BYTES: u64 = 512 * 1024 * 1024;
+
+/// How deep the prompt is willing to point. Past this we name the ancestor and
+/// let the user carve inside it from the file tree's own auto-sync menu.
+pub const MAX_DEPTH: usize = 4;
+
+/// Descend into a single heavy child instead of reporting its parent when the
+/// child accounts for at least this share of it — the difference between saying
+/// "exclude `data/`" (which also drops the two scripts beside it) and "exclude
+/// `data/raw/`", which is what the user actually meant.
+const DOMINANT_SHARE: f64 = 0.8;
+
+/// Stop walking a tree after this many files. A cap, not a sample: the counts
+/// stay honest up to it, and a tree that hits it is *by definition* one worth
+/// warning about — the numbers only get bigger.
+pub const MAX_ENTRIES: usize = 400_000;
+
+/// Cumulative (subtree) totals for one directory.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct FolderTally {
+    pub files: u64,
+    pub bytes: u64,
+}
+
+/// One folder the user should be asked about, with the totals behind the ask.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BigFolder {
+    /// Project-relative path, forward slashes, no leading/trailing slash.
+    pub rel: String,
+    pub files: u64,
+    pub bytes: u64,
+}
+
+/// Fold a flat file list into cumulative per-directory totals: every ancestor of
+/// a file is credited with it, so a parent's totals always contain its children's
+/// (which is what lets [`pick`] prune whole subtrees by testing the parent alone).
+pub fn tally_dirs(files: &[(String, u64)]) -> HashMap<String, FolderTally> {
+    let mut out: HashMap<String, FolderTally> = HashMap::new();
+    for (rel, size) in files {
+        let mut cur = rel.as_str();
+        while let Some(idx) = cur.rfind('/') {
+            cur = &cur[..idx];
+            let e = out.entry(cur.to_string()).or_default();
+            e.files += 1;
+            e.bytes += size;
+        }
+    }
+    out
+}
+
+fn depth_of(rel: &str) -> usize {
+    if rel.is_empty() { 0 } else { rel.matches('/').count() + 1 }
+}
+
+fn children_of<'a>(tallies: &'a HashMap<String, FolderTally>, parent: &str) -> Vec<&'a str> {
+    let want = depth_of(parent) + 1;
+    tallies
+        .keys()
+        .filter(|k| depth_of(k) == want && parent_of(k) == parent)
+        .map(|k| k.as_str())
+        .collect()
+}
+
+fn parent_of(rel: &str) -> &str {
+    match rel.rfind('/') {
+        Some(idx) => &rel[..idx],
+        None => "",
+    }
+}
+
+/// Pick the folders worth prompting about: the **shallowest** directories that
+/// cross either threshold, except that a directory whose weight is concentrated
+/// in one child is skipped in favour of that child (recursively, to `max_depth`).
+/// Sorted heaviest-first so the prompt leads with the decision that matters.
+///
+/// Never returns nested pairs — excluding a reported folder always excludes
+/// everything it reports, so no checkbox in the prompt can shadow another.
+pub fn pick(
+    tallies: &HashMap<String, FolderTally>,
+    min_files: u64,
+    min_bytes: u64,
+    max_depth: usize,
+) -> Vec<BigFolder> {
+    let mut out = Vec::new();
+    let mut queue: Vec<String> = children_of(tallies, "").iter().map(|s| s.to_string()).collect();
+    while let Some(rel) = queue.pop() {
+        let Some(t) = tallies.get(&rel).copied() else { continue };
+        if t.files < min_files && t.bytes < min_bytes {
+            // Totals are cumulative, so a folder under both thresholds cannot
+            // contain one over them — the whole subtree is done.
+            continue;
+        }
+        let kids = children_of(tallies, &rel);
+        // Descend only into a child that *explains* the parent: it must still cross
+        // a threshold on its own, and carry the bulk of whichever metric put the
+        // parent over one. (A parent flagged for its 40 GB isn't made more precise
+        // by a child holding 90% of its *file count* but none of the bytes.)
+        let by_files = t.files >= min_files;
+        let by_bytes = t.bytes >= min_bytes;
+        let dominant = (depth_of(&rel) < max_depth)
+            .then(|| {
+                kids.iter().find(|k| {
+                    let kt = tallies.get(**k).copied().unwrap_or_default();
+                    (kt.files >= min_files || kt.bytes >= min_bytes)
+                        && (!by_files || kt.files as f64 >= t.files as f64 * DOMINANT_SHARE)
+                        && (!by_bytes || kt.bytes as f64 >= t.bytes as f64 * DOMINANT_SHARE)
+                })
+            })
+            .flatten();
+        match dominant {
+            Some(child) => queue.push(child.to_string()),
+            None => out.push(BigFolder { rel, files: t.files, bytes: t.bytes }),
+        }
+    }
+    out.sort_by(|a, b| b.bytes.cmp(&a.bytes).then_with(|| b.files.cmp(&a.files)));
+    out
+}
+
+// ── Local side ──────────────────────────────────────────────────────────────
+
+/// Walk `root` and return every regular file as `(project-relative path, bytes)`.
+///
+/// Symlinks are never followed (the host walk in `remote_sync` makes the same
+/// promise, for the same reason: a `link -> /` must not be measured as project
+/// data), and `.git`/`.eldrun` are skipped — git's bytes are lockstep's business
+/// and Eldrun's runtime dir is nobody's. Stops at [`MAX_ENTRIES`].
+pub fn walk_local_files(root: &Path) -> Vec<(String, u64)> {
+    let mut out = Vec::new();
+    let mut stack: Vec<(PathBuf, String)> = vec![(root.to_path_buf(), String::new())];
+    while let Some((dir, rel)) = stack.pop() {
+        if out.len() >= MAX_ENTRIES {
+            break;
+        }
+        let Ok(entries) = std::fs::read_dir(&dir) else { continue };
+        for entry in entries.flatten() {
+            let name = entry.file_name().to_string_lossy().to_string();
+            if name == ".git" || name == ".eldrun" {
+                continue;
+            }
+            let child_rel = if rel.is_empty() { name.clone() } else { format!("{rel}/{name}") };
+            // `symlink_metadata`: a symlink is neither walked nor billed.
+            let Ok(meta) = entry.metadata() else { continue };
+            if meta.is_symlink() {
+                continue;
+            }
+            if meta.is_dir() {
+                stack.push((entry.path(), child_rel));
+            } else if meta.is_file() {
+                out.push((child_rel, meta.len()));
+                if out.len() >= MAX_ENTRIES {
+                    break;
+                }
+            }
+        }
+    }
+    out
+}
+
+// ── Host side ───────────────────────────────────────────────────────────────
+
+/// Parse `du -ak <root>` output into the same `(project-relative path, bytes)`
+/// list the local walk produces.
+///
+/// `du -a` prints every file *and* every directory, so directory-ness is derived
+/// from the listing itself — a path is a directory exactly when another path is
+/// beneath it — rather than from a second round trip. Sizes are `du`'s 1 KiB
+/// blocks (allocated, not apparent): a rounding we accept, because a threshold
+/// prompt asks "is this folder huge", not "how huge to the byte".
+pub fn parse_du_files(root: &str, out: &str) -> Vec<(String, u64)> {
+    let root = root.trim_end_matches('/');
+    let mut rows: Vec<(String, u64)> = Vec::new();
+    for line in out.lines().take(MAX_ENTRIES) {
+        let mut parts = line.splitn(2, '\t');
+        let (Some(kb), Some(path)) = (parts.next(), parts.next()) else { continue };
+        let Ok(kb) = kb.trim().parse::<u64>() else { continue };
+        let path = path.trim_end_matches('/');
+        let rel = if path == root {
+            String::new()
+        } else if let Some(stripped) = path.strip_prefix(root).and_then(|p| p.strip_prefix('/')) {
+            stripped.to_string()
+        } else {
+            continue;
+        };
+        if rel.is_empty()
+            || rel == ".git"
+            || rel.starts_with(".git/")
+            || rel == ".eldrun"
+            || rel.starts_with(".eldrun/")
+        {
+            continue;
+        }
+        rows.push((rel, kb.saturating_mul(1024)));
+    }
+    // A path with anything beneath it is a directory; only the leaves are files.
+    let dirs: std::collections::HashSet<String> =
+        rows.iter().map(|(rel, _)| parent_of(rel).to_string()).collect();
+    rows.into_iter().filter(|(rel, _)| !dirs.contains(rel)).collect()
+}
+
+/// The whole local-side answer: walk the mirror, tally, pick.
+pub fn scan_local(root: &Path) -> Vec<BigFolder> {
+    let files = walk_local_files(root);
+    pick(&tally_dirs(&files), MIN_FILES, MIN_BYTES, MAX_DEPTH)
+}
+
+/// The whole host-side answer, given a `du -ak` capture from the host.
+pub fn scan_host(remote_root: &str, du_output: &str) -> Vec<BigFolder> {
+    let files = parse_du_files(remote_root, du_output);
+    pick(&tally_dirs(&files), MIN_FILES, MIN_BYTES, MAX_DEPTH)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn files(specs: &[(&str, u64)]) -> Vec<(String, u64)> {
+        specs.iter().map(|(p, s)| (p.to_string(), *s)).collect()
+    }
+
+    #[test]
+    fn tallies_are_cumulative_over_every_ancestor() {
+        let t = tally_dirs(&files(&[("a/b/c.txt", 10), ("a/d.txt", 5)]));
+        assert_eq!(t["a"], FolderTally { files: 2, bytes: 15 });
+        assert_eq!(t["a/b"], FolderTally { files: 1, bytes: 10 });
+        assert!(!t.contains_key(""), "the project root is never a candidate");
+    }
+
+    #[test]
+    fn small_folders_are_never_offered() {
+        let t = tally_dirs(&files(&[("src/a.rs", 100), ("src/b.rs", 100)]));
+        assert!(pick(&t, MIN_FILES, MIN_BYTES, MAX_DEPTH).is_empty());
+    }
+
+    #[test]
+    fn many_small_files_qualify_on_count_alone() {
+        let specs: Vec<(String, u64)> = (0..MIN_FILES)
+            .map(|i| (format!("node_modules/p{i}/index.js"), 10))
+            .collect();
+        let got = pick(&tally_dirs(&specs), MIN_FILES, MIN_BYTES, MAX_DEPTH);
+        assert_eq!(got.len(), 1);
+        assert_eq!(got[0].rel, "node_modules");
+        assert_eq!(got[0].files, MIN_FILES);
+    }
+
+    #[test]
+    fn a_few_huge_files_qualify_on_bytes_alone() {
+        let got = pick(
+            &tally_dirs(&files(&[("ckpt/a.bin", MIN_BYTES), ("ckpt/b.bin", 1)])),
+            MIN_FILES,
+            MIN_BYTES,
+            MAX_DEPTH,
+        );
+        assert_eq!(got.len(), 1);
+        assert_eq!(got[0].rel, "ckpt");
+    }
+
+    #[test]
+    fn descends_into_a_dominant_child_but_not_a_split_parent() {
+        // `data` is heavy only because `data/raw` is: point at `data/raw`.
+        let dominant = tally_dirs(&files(&[
+            ("data/raw/big.bin", MIN_BYTES),
+            ("data/notes.md", 10),
+        ]));
+        assert_eq!(pick(&dominant, MIN_FILES, MIN_BYTES, MAX_DEPTH)[0].rel, "data/raw");
+
+        // Two comparable children: naming either would understate the ask.
+        let split = tally_dirs(&files(&[
+            ("data/a/big.bin", MIN_BYTES),
+            ("data/b/big.bin", MIN_BYTES),
+        ]));
+        assert_eq!(pick(&split, MIN_FILES, MIN_BYTES, MAX_DEPTH)[0].rel, "data");
+    }
+
+    #[test]
+    fn results_never_nest() {
+        let t = tally_dirs(&files(&[
+            ("data/a/big.bin", MIN_BYTES),
+            ("data/b/big.bin", MIN_BYTES),
+        ]));
+        let got = pick(&t, MIN_FILES, MIN_BYTES, MAX_DEPTH);
+        for a in &got {
+            for b in &got {
+                assert!(
+                    a.rel == b.rel || !b.rel.starts_with(&format!("{}/", a.rel)),
+                    "{} shadows {}",
+                    a.rel,
+                    b.rel
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn du_output_becomes_leaf_files_only() {
+        let out = "4\t/srv/proj/data\n2048\t/srv/proj/data/big.bin\n8\t/srv/proj/data/small\n\
+                   4\t/srv/proj/data/small/x.txt\n12\t/srv/proj\n";
+        let got = parse_du_files("/srv/proj", out);
+        assert_eq!(
+            got,
+            vec![
+                ("data/big.bin".to_string(), 2048 * 1024),
+                ("data/small/x.txt".to_string(), 4 * 1024),
+            ]
+        );
+    }
+
+    #[test]
+    fn du_output_skips_git_and_foreign_paths() {
+        let out = "4\t/srv/proj/.git/objects/aa\n4\t/elsewhere/x\n4\t/srv/proj/keep.txt\n";
+        assert_eq!(parse_du_files("/srv/proj", out), vec![("keep.txt".to_string(), 4096)]);
+    }
+}
diff --git a/src-tauri/src/services/codex_bind.rs b/src-tauri/src/services/codex_bind.rs
new file mode 100644
index 0000000..6a8029b
--- /dev/null
+++ b/src-tauri/src/services/codex_bind.rs
@@ -0,0 +1,533 @@
+//! Hook-free Codex session binding — the fallback that keeps Codex tabs
+//! resumable when Codex won't run Eldrun's `SessionStart` hook.
+//!
+//! Codex gates user-level hooks behind a one-time trust approval (`/hooks`), and
+//! an untrusted hook never fires — silently. Until the user trusts it, nothing
+//! records a tab's live session id, so [`agent_session::resolve_codex_session`]
+//! has nothing to resume and every restored Codex tab comes back blank.
+//!
+//! So we learn the id from Codex's own logs instead. Every session writes
+//! `~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ts>-<uuid>.jsonl`, whose first
+//! line is a `session_meta` record carrying both `session_id` and `cwd`. We
+//! follow that tree for a *new* rollout in a tracked tab's cwd and write its id
+//! into the very same `live_sessions/<uid>` file the hook would have written —
+//! so the resolve path, and Claude's, stay untouched.
+//!
+//! Attribution is by cwd and time, which is a heuristic, and it has two known
+//! soft spots (the trusted hook has neither, which is why we still install it
+//! and still nag):
+//!
+//! - Two Codex tabs started fresh in the *same* cwd within one tick can end up
+//!   with each other's sessions. Both conversations stay resumable — possibly in
+//!   the wrong tabs.
+//! - A Codex started *outside* Eldrun in a tracked tab's cwd can be mis-claimed
+//!   when that tab's `/clear` is being rebound.
+//!
+//! Remote (ssh) Codex tabs are out of scope: their rollouts live on the far
+//! host, so `commands::terminal::pty_spawn` never tracks them. Sandboxed tabs
+//! *are* in scope and need no special handling — `services::sandbox` bind-mounts
+//! both `~/.codex` and the project cwd at identical paths inside the container,
+//! so a sandboxed Codex writes host-shaped rollouts to the host's sessions tree.
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::sync::{Mutex, OnceLock};
+use std::time::{Duration, SystemTime};
+
+use crate::paths;
+use crate::services::agent_session;
+
+/// Rollout first lines inline the full base instructions, so they run ~20 KB.
+/// Cap the read well above that but far below "a whole transcript".
+const MAX_HEAD_BYTES: usize = 1 << 20;
+
+/// mtime granularity + clock skew: a rollout created moments *before* we record
+/// the spawn time is still plausibly ours.
+const SLACK: Duration = Duration::from_secs(2);
+
+/// A fresh Codex writes its rollout within a second or so of spawning; poll
+/// briskly while any tracked tab is young, then settle into a slow watch that
+/// only exists to catch a `/clear`.
+const FAST_TICK: Duration = Duration::from_millis(400);
+const SLOW_TICK: Duration = Duration::from_secs(2);
+const FAST_PHASE: Duration = Duration::from_secs(20);
+
+/// A rollout's identifying header: the first JSONL line, when it is a
+/// `session_meta` record.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RolloutMeta {
+    pub id: String,
+    pub cwd: PathBuf,
+    pub mtime: SystemTime,
+}
+
+/// One Codex tab the binder is following.
+struct Tracked {
+    /// `ELDRUN_TAB_UID` — the key `live_sessions/<uid>` is stored under.
+    uid: String,
+    /// The tab's cwd, canonicalized where possible (matched against `meta.cwd`).
+    cwd: PathBuf,
+    /// Spawn time, less `SLACK`. Rollouts older than this were not made by us.
+    since: SystemTime,
+    /// Rollout ids that already existed when this tab spawned, plus every id
+    /// we have since inspected and rejected — never opened twice.
+    known: HashSet<String>,
+    /// The id currently recorded for this tab, if any.
+    bound: Option<String>,
+    /// Bumped on every `track` of the same pty id, so a dying old PTY's teardown
+    /// can't untrack the tab that just replaced it.
+    seq: u64,
+}
+
+#[derive(Default)]
+struct Binder {
+    tabs: HashMap<String, Tracked>,
+    next_seq: u64,
+}
+
+fn binder() -> &'static Mutex<Binder> {
+    static BINDER: OnceLock<Mutex<Binder>> = OnceLock::new();
+    BINDER.get_or_init(|| Mutex::new(Binder::default()))
+}
+
+fn sessions_root() -> PathBuf {
+    paths::home_dir().join(".codex").join("sessions")
+}
+
+// ── Pure core ───────────────────────────────────────────────────────────────
+
+/// `rollout-2026-07-11T11-26-43-019f5080-….jsonl` → the trailing uuid.
+///
+/// The id is right there in the filename, which is what lets `snapshot_ids`
+/// enumerate every existing session without opening a single file.
+pub fn rollout_id_from_filename(name: &str) -> Option<String> {
+    let rest = name.strip_prefix("rollout-")?.strip_suffix(".jsonl")?;
+    // `<ISO date>T<HH-MM-SS>-<uuid>`: the uuid is the last 5 dash-separated
+    // groups, so drop everything before them.
+    let parts: Vec<&str> = rest.split('-').collect();
+    if parts.len() < 5 {
+        return None;
+    }
+    let id = parts[parts.len() - 5..].join("-");
+    agent_session::is_uuidish(&id).then_some(id)
+}
+
+/// Every rollout under `root`, as `(path, id, mtime)`. Bounded depth (the tree is
+/// `YYYY/MM/DD/file`); stats only, no file contents.
+fn walk_rollouts(root: &Path, out: &mut Vec<(PathBuf, String, SystemTime)>) {
+    fn walk(dir: &Path, depth: u8, out: &mut Vec<(PathBuf, String, SystemTime)>) {
+        if depth > 4 {
+            return;
+        }
+        let Ok(entries) = std::fs::read_dir(dir) else {
+            return;
+        };
+        for entry in entries.flatten() {
+            let path = entry.path();
+            let Ok(meta) = entry.metadata() else { continue };
+            if meta.is_dir() {
+                walk(&path, depth + 1, out);
+            } else if let Some(id) = path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .and_then(rollout_id_from_filename)
+            {
+                let mtime = meta.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+                out.push((path, id, mtime));
+            }
+        }
+    }
+    walk(root, 0, out);
+}
+
+/// Ids of every rollout that exists right now. No file is opened.
+pub fn snapshot_ids(root: &Path) -> HashSet<String> {
+    let mut found = Vec::new();
+    walk_rollouts(root, &mut found);
+    found.into_iter().map(|(_, id, _)| id).collect()
+}
+
+/// Parse a rollout's `session_meta` header. `None` unless the first line really
+/// is one and carries both fields — a half-written line (we may be reading while
+/// Codex is still writing) simply fails to parse and is retried next tick.
+pub fn read_rollout_meta(path: &Path, mtime: SystemTime) -> Option<RolloutMeta> {
+    use std::io::Read;
+
+    let mut file = std::fs::File::open(path).ok()?;
+    let mut buf = vec![0u8; MAX_HEAD_BYTES];
+    let n = file.read(&mut buf).ok()?;
+    buf.truncate(n);
+    let text = String::from_utf8_lossy(&buf);
+    let line = text.split('\n').next()?;
+
+    #[derive(serde::Deserialize)]
+    struct Head {
+        #[serde(rename = "type")]
+        kind: String,
+        payload: Payload,
+    }
+    #[derive(serde::Deserialize)]
+    struct Payload {
+        session_id: String,
+        cwd: PathBuf,
+    }
+
+    let head: Head = serde_json::from_str(line).ok()?;
+    if head.kind != "session_meta" || !agent_session::is_uuidish(&head.payload.session_id) {
+        return None;
+    }
+    Some(RolloutMeta {
+        id: head.payload.session_id,
+        cwd: head.payload.cwd,
+        mtime,
+    })
+}
+
+/// Pick the rollout that belongs to a tab whose cwd is `cwd`.
+///
+/// The whole attribution decision, kept pure. A candidate qualifies when it is
+/// in the tab's cwd, is not one this tab has already seen or rejected (`known`),
+/// and is not already bound to a live sibling tab (`claimed`). Among those we
+/// take the **oldest** — a tab's own rollout is the *first* to appear after it
+/// spawned, so picking the newest would let a later-spawned sibling in the same
+/// cwd steal it.
+pub fn pick_binding(
+    candidates: &[RolloutMeta],
+    cwd: &Path,
+    known: &HashSet<String>,
+    claimed: &HashSet<String>,
+) -> Option<String> {
+    candidates
+        .iter()
+        .filter(|m| !known.contains(&m.id) && !claimed.contains(&m.id) && same_dir(&m.cwd, cwd))
+        .min_by_key(|m| m.mtime)
+        .map(|m| m.id.clone())
+}
+
+/// Compare two directories for identity. Both sides are canonicalized when they
+/// still exist (a project can be moved), falling back to a literal compare —
+/// which also keeps this honest on Windows, where `payload.cwd` comes back as a
+/// `C:\…` path that may or may not carry a `\\?\` prefix.
+fn same_dir(a: &Path, b: &Path) -> bool {
+    let ca = a.canonicalize().unwrap_or_else(|_| a.to_path_buf());
+    let cb = b.canonicalize().unwrap_or_else(|_| b.to_path_buf());
+    ca == cb
+}
+
+// ── Registry ────────────────────────────────────────────────────────────────
+
+/// Start following a Codex tab. `initial` is the session id we just resumed it
+/// into (if any) — registered as this tab's claim straight away so a sibling
+/// can't take it, and so its bumped mtime (resume *appends* to the existing
+/// rollout) isn't mistaken for a new session.
+///
+/// Idempotent per `pty_id`: a re-spawn replaces the entry and bumps its seq.
+/// Returns that seq, for `untrack`.
+pub fn track(pty_id: &str, uid: &str, cwd: &Path, initial: Option<String>) -> u64 {
+    let root = sessions_root();
+    let mut known = snapshot_ids(&root);
+    if let Some(id) = &initial {
+        known.insert(id.clone());
+    }
+    let since = SystemTime::now() - SLACK;
+    let cwd = cwd.canonicalize().unwrap_or_else(|_| cwd.to_path_buf());
+
+    {
+        let mut b = binder().lock().unwrap();
+        b.next_seq += 1;
+        let seq = b.next_seq;
+        b.tabs.insert(
+            pty_id.to_string(),
+            Tracked {
+                uid: uid.to_string(),
+                cwd,
+                since,
+                known,
+                bound: initial,
+                seq,
+            },
+        );
+        ensure_poller();
+        seq
+    }
+}
+
+/// Stop following the tab a *specific* spawn of `pty_id` created. The seq guard
+/// matters because a PTY's death is observed asynchronously: without it, the
+/// dying old process of a re-spawned tab would untrack the live new one.
+pub fn untrack(pty_id: &str, seq: u64) {
+    let mut b = binder().lock().unwrap();
+    if b.tabs.get(pty_id).is_some_and(|t| t.seq == seq) {
+        b.tabs.remove(pty_id);
+    }
+}
+
+/// Stop following `pty_id` outright — the tab itself is gone (explicit kill), so
+/// there is no successor spawn to protect.
+pub fn untrack_now(pty_id: &str) {
+    binder().lock().unwrap().tabs.remove(pty_id);
+}
+
+/// The seq currently tracking `pty_id`, if any. Lets `spawn_pty` hand its
+/// teardown a token without plumbing `track`'s return value through the wrapper
+/// layers between them.
+pub fn current_seq(pty_id: &str) -> Option<u64> {
+    binder().lock().unwrap().tabs.get(pty_id).map(|t| t.seq)
+}
+
+// ── Poll loop ───────────────────────────────────────────────────────────────
+
+/// Start the single global poll task, once. It owns every tracked tab: one walk
+/// of the sessions tree per tick serves all of them.
+fn ensure_poller() {
+    static STARTED: OnceLock<()> = OnceLock::new();
+    if STARTED.set(()).is_err() {
+        return;
+    }
+    tokio::spawn(async move {
+        loop {
+            let tick = poll_once(&sessions_root());
+            tokio::time::sleep(tick).await;
+        }
+    });
+}
+
+/// A tracked tab, copied out from under the lock so the tick's filesystem work
+/// never holds it.
+struct Snapshot {
+    pty: String,
+    uid: String,
+    cwd: PathBuf,
+    since: SystemTime,
+    known: HashSet<String>,
+    bound: Option<String>,
+}
+
+/// One pass: bind every tracked tab that can be bound. Returns how long to wait
+/// before the next pass.
+fn poll_once(root: &Path) -> Duration {
+    let tabs: Vec<Snapshot> = {
+        let b = binder().lock().unwrap();
+        b.tabs
+            .iter()
+            .map(|(pty, t)| Snapshot {
+                pty: pty.clone(),
+                uid: t.uid.clone(),
+                cwd: t.cwd.clone(),
+                since: t.since,
+                known: t.known.clone(),
+                bound: t.bound.clone(),
+            })
+            .collect()
+    };
+    if tabs.is_empty() {
+        return SLOW_TICK;
+    }
+
+    let earliest = tabs.iter().map(|t| t.since).min().unwrap();
+    let now = SystemTime::now();
+    let young = tabs
+        .iter()
+        .any(|t| now.duration_since(t.since).unwrap_or_default() < FAST_PHASE);
+
+    // Stat-only filter first: the vast majority of rollouts predate every tracked
+    // tab, and those we never open.
+    let mut found = Vec::new();
+    walk_rollouts(root, &mut found);
+    let fresh: Vec<(PathBuf, String, SystemTime)> = found
+        .into_iter()
+        .filter(|(_, _, mtime)| *mtime >= earliest)
+        .collect();
+
+    // Ids bound to *some* live tab — off-limits to every other tab.
+    let claimed: HashSet<String> = tabs.iter().filter_map(|t| t.bound.clone()).collect();
+
+    // Parse each fresh rollout at most once per tick, and only when at least one
+    // tab hasn't already written it off.
+    let metas: Vec<RolloutMeta> = fresh
+        .iter()
+        .filter(|(_, id, _)| tabs.iter().any(|t| !t.known.contains(id)))
+        .filter_map(|(path, _, mtime)| read_rollout_meta(path, *mtime))
+        .collect();
+
+    let live_dir = agent_session::live_sessions_dir();
+    for Snapshot {
+        pty,
+        uid,
+        cwd,
+        since: _,
+        known,
+        bound,
+    } in tabs
+    {
+        // The trusted hook, if it is running, is strictly more precise than we
+        // are — so if it has recorded an id we didn't put there, it wins.
+        if let Some(hook_id) = agent_session::read_live_session_in(&live_dir, &uid) {
+            if Some(&hook_id) != bound.as_ref() && !known.contains(&hook_id) {
+                adopt(&pty, hook_id);
+                continue;
+            }
+        }
+
+        let mut mine = claimed.clone();
+        if let Some(b) = &bound {
+            mine.remove(b); // our own claim doesn't block us
+        }
+        let inspected: Vec<String> = metas.iter().map(|m| m.id.clone()).collect();
+
+        match pick_binding(&metas, &cwd, &known, &mine) {
+            Some(id) => {
+                if let Err(e) = agent_session::write_live_session_in(&live_dir, &uid, &id) {
+                    eprintln!("codex_bind: record session for {uid}: {e}");
+                    continue;
+                }
+                adopt(&pty, id);
+            }
+            None => remember(&pty, inspected),
+        }
+    }
+
+    if young {
+        FAST_TICK
+    } else {
+        SLOW_TICK
+    }
+}
+
+/// Record `id` as a tab's bound session (and never reconsider it).
+fn adopt(pty_id: &str, id: String) {
+    let mut b = binder().lock().unwrap();
+    if let Some(t) = b.tabs.get_mut(pty_id) {
+        t.known.insert(id.clone());
+        t.bound = Some(id);
+    }
+}
+
+/// Write off rollouts this tab has now looked at and does not want, so a later
+/// tick never opens them again.
+fn remember(pty_id: &str, ids: Vec<String>) {
+    let mut b = binder().lock().unwrap();
+    if let Some(t) = b.tabs.get_mut(pty_id) {
+        t.known.extend(ids);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn unique_tmp(prefix: &str) -> PathBuf {
+        use std::sync::atomic::{AtomicU64, Ordering};
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let n = COUNTER.fetch_add(1, Ordering::Relaxed);
+        std::env::temp_dir().join(format!("{prefix}-{}-{n}", std::process::id()))
+    }
+
+    fn meta(id: &str, cwd: &str, secs: u64) -> RolloutMeta {
+        RolloutMeta {
+            id: id.to_string(),
+            cwd: PathBuf::from(cwd),
+            mtime: SystemTime::UNIX_EPOCH + Duration::from_secs(secs),
+        }
+    }
+
+    const A: &str = "019f5080-245c-7813-8a7c-0e3c988ff891";
+    const B: &str = "019f5081-1111-7813-8a7c-0e3c988ff892";
+    const C: &str = "019f5082-2222-7813-8a7c-0e3c988ff893";
+
+    #[test]
+    fn rollout_id_parses_out_of_the_filename() {
+        assert_eq!(
+            rollout_id_from_filename(&format!("rollout-2026-07-11T11-26-43-{A}.jsonl")).as_deref(),
+            Some(A)
+        );
+        assert_eq!(rollout_id_from_filename("notes.txt"), None);
+        assert_eq!(rollout_id_from_filename("rollout-short.jsonl"), None);
+        // A `.jsonl` that isn't a rollout at all.
+        assert_eq!(rollout_id_from_filename("session-2026.jsonl"), None);
+    }
+
+    #[test]
+    fn snapshot_ids_opens_no_files() {
+        let root = unique_tmp("eldrun-bind-snap");
+        let day = root.join("2026").join("07").join("11");
+        std::fs::create_dir_all(&day).unwrap();
+        for id in [A, B] {
+            // Deliberately unparseable content: ids must come from the names.
+            std::fs::write(day.join(format!("rollout-2026-07-11T11-26-43-{id}.jsonl")), b"").unwrap();
+        }
+        std::fs::write(day.join("stray.txt"), b"x").unwrap();
+
+        let ids = snapshot_ids(&root);
+        assert_eq!(ids.len(), 2);
+        assert!(ids.contains(A) && ids.contains(B));
+
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn read_rollout_meta_handles_a_fat_header_and_rejects_non_meta() {
+        let root = unique_tmp("eldrun-bind-head");
+        std::fs::create_dir_all(&root).unwrap();
+
+        // Real headers inline ~20 KB of base instructions ahead of nothing in
+        // particular — the fields must still come out.
+        let filler = "x".repeat(30_000);
+        let good = root.join("good.jsonl");
+        std::fs::write(
+            &good,
+            format!(
+                "{{\"timestamp\":\"t\",\"type\":\"session_meta\",\"payload\":{{\"session_id\":\"{A}\",\"cwd\":\"/home/u/proj\",\"base_instructions\":{{\"text\":\"{filler}\"}}}}}}\n{{\"type\":\"turn\"}}\n"
+            ),
+        )
+        .unwrap();
+        let m = read_rollout_meta(&good, SystemTime::UNIX_EPOCH).unwrap();
+        assert_eq!(m.id, A);
+        assert_eq!(m.cwd, PathBuf::from("/home/u/proj"));
+
+        // Not a session_meta first line.
+        let other = root.join("other.jsonl");
+        std::fs::write(&other, "{\"type\":\"turn_context\",\"payload\":{}}\n").unwrap();
+        assert_eq!(read_rollout_meta(&other, SystemTime::UNIX_EPOCH), None);
+
+        // Torn line (we may read while Codex is still writing) → no panic, no id.
+        let torn = root.join("torn.jsonl");
+        std::fs::write(&torn, "{\"type\":\"session_meta\",\"payl").unwrap();
+        assert_eq!(read_rollout_meta(&torn, SystemTime::UNIX_EPOCH), None);
+
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn pick_binding_takes_the_oldest_unclaimed_rollout_in_the_tab_cwd() {
+        let cwd = PathBuf::from("/home/u/proj");
+        let candidates = vec![
+            meta(A, "/home/u/other", 10), // wrong cwd
+            meta(B, "/home/u/proj", 30),  // right cwd, but younger than C
+            meta(C, "/home/u/proj", 20),  // ← the tab's own: first to appear
+        ];
+        assert_eq!(
+            pick_binding(&candidates, &cwd, &HashSet::new(), &HashSet::new()).as_deref(),
+            Some(C)
+        );
+    }
+
+    #[test]
+    fn pick_binding_ignores_rollouts_that_predate_the_tab() {
+        // Ids present at spawn live in `known` and are never ours.
+        let cwd = PathBuf::from("/home/u/proj");
+        let candidates = vec![meta(A, "/home/u/proj", 10)];
+        let known: HashSet<String> = [A.to_string()].into_iter().collect();
+        assert_eq!(pick_binding(&candidates, &cwd, &known, &HashSet::new()), None);
+    }
+
+    #[test]
+    fn pick_binding_never_steals_a_sibling_tabs_session() {
+        // Two tabs, one cwd: the only new rollout is already bound to tab A, so
+        // tab B must come away with nothing rather than hijack it.
+        let cwd = PathBuf::from("/home/u/proj");
+        let candidates = vec![meta(A, "/home/u/proj", 10)];
+        let claimed: HashSet<String> = [A.to_string()].into_iter().collect();
+        assert_eq!(pick_binding(&candidates, &cwd, &HashSet::new(), &claimed), None);
+    }
+}
diff --git a/src-tauri/src/services/git_credentials.rs b/src-tauri/src/services/git_credentials.rs
new file mode 100644
index 0000000..dc2d8f4
--- /dev/null
+++ b/src-tauri/src/services/git_credentials.rs
@@ -0,0 +1,60 @@
+//! Secure storage for git-hosting access tokens, backed by the OS credential
+//! store (Windows Credential Manager / macOS Keychain / Linux Secret Service)
+//! via the `keyring` crate.
+//!
+//! Why not `settings.json` / `project.json`? A project's `project.json` lives in
+//! the project's git working tree and is NOT covered by the scaffolded
+//! `.gitignore`, so a token written there would be committed and pushed. And the
+//! security review (§4.2) flags the existing plaintext global `git_token`. Tokens
+//! therefore never touch our JSON state — only the keyring holds them, keyed by a
+//! caller-supplied scope (`"global"` or a project id).
+//!
+//! All operations degrade gracefully: a keyring that is unavailable (e.g. a
+//! headless Linux box with no Secret Service) yields `None` on read and an
+//! `Err(String)` on write, so callers can fall back to the global token or
+//! surface a friendly message rather than panicking.
+
+const SERVICE: &str = "eldrun-git-hosting";
+
+/// The keyring "username" under which a scope's token is stored. Kept distinct
+/// from any real account name so the entry is unambiguous in the OS store.
+fn account(scope: &str) -> String {
+    format!("token:{scope}")
+}
+
+fn entry(scope: &str) -> Result<keyring::Entry, String> {
+    keyring::Entry::new(SERVICE, &account(scope)).map_err(|e| e.to_string())
+}
+
+/// Read the token for `scope` (`"global"` or a project id). Returns `None` when
+/// no token is stored or the keyring is unavailable — never an error, so a
+/// missing per-project token cleanly falls through to the global one.
+pub fn get_token(scope: &str) -> Option<String> {
+    match entry(scope).and_then(|e| match e.get_password() {
+        Ok(secret) => Ok(Some(secret)),
+        Err(keyring::Error::NoEntry) => Ok(None),
+        Err(e) => Err(e.to_string()),
+    }) {
+        Ok(token) => token.filter(|t| !t.is_empty()),
+        Err(_) => None,
+    }
+}
+
+/// Store (non-empty) or clear (`None`/empty) the token for `scope`. Returns an
+/// error string if the keyring write fails so the UI can report it.
+pub fn set_token(scope: &str, token: Option<&str>) -> Result<(), String> {
+    let e = entry(scope)?;
+    match token.map(str::trim).filter(|t| !t.is_empty()) {
+        Some(secret) => e.set_password(secret).map_err(|err| err.to_string()),
+        None => match e.delete_credential() {
+            Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),
+            Err(err) => Err(err.to_string()),
+        },
+    }
+}
+
+/// Whether a non-empty token is stored for `scope`. Used to tell the frontend
+/// "token set" without ever handing the secret back to the renderer.
+pub fn has_token(scope: &str) -> bool {
+    get_token(scope).is_some()
+}
diff --git a/src-tauri/src/services/git_peer.rs b/src-tauri/src/services/git_peer.rs
new file mode 100644
index 0000000..6828d34
--- /dev/null
+++ b/src-tauri/src/services/git_peer.rs
@@ -0,0 +1,4589 @@
+//! Git-aware local↔remote lockstep sync for SSH remote projects (TODO #28n, Phase 1).
+//!
+//! A remote project has **two real git working trees**: the local mirror
+//! ([`remote_sync::mirror_dir`]) and the host tree at `spec.remote_path` (git run
+//! over the shared ControlMaster via [`ssh_exec::run_git_remote`]). The selective/
+//! auto file-sync (`services::sync_auto`) mirrors *bytes* and has no concept of git
+//! branches, so a branch switch on either side rewrites many tracked files and would
+//! be misread as edits and pushed. This module keeps the two repos in step
+//! **semantically**: it transfers commits/refs with `git bundle` (which carries only
+//! objects + the named refs — never `config`/hooks/reflogs/index/remotes/stashes/
+//! worktree metadata) moved over the pooled SFTP session, then runs `git checkout`
+//! on each side so each git materializes its own working tree.
+//!
+//! Phase 1 scope (this file): opt-in per project; bidirectional **fast-forward-only**
+//! ref/commit transfer + missing-ref creation; coordinated checkout that pauses file
+//! auto-sync and re-stamps its bases so checkout writes don't become false conflicts;
+//! and **detection + display** of a desynchronized state (diverged history / dirty
+//! peer). Full Use-local/Use-remote resolution with `refs/eldrun/backup/*` and messy
+//! initial-pairing authority are deferred to Phase 2/3.
+//!
+//! **Hardening (#28p).** Byte-sync (`sync_auto`) and this module are two transports
+//! over the same two trees, and they used to be blind to each other. The invariant
+//! that removes the whole bug class: **lockstep owns the git-tracked tree, byte-sync
+//! owns everything else** ([`tracked_paths`], subtracted from the auto-sync candidate
+//! set in `sync_auto::reconcile_pass`). Everything else here follows from two git
+//! behaviours worth stating, because they are load-bearing and non-obvious:
+//!
+//! 1. `git merge --ff-only <sha>` **refuses** to overwrite an untracked working-tree
+//!    file — *even when its bytes are identical* to the incoming blob (D1/D2).
+//! 2. `git reset --hard <sha>` **silently clobbers** that same file (D3).
+//!
+//! (1) is why a file byte-synced ahead of its commit wedges the fast-forward that
+//! would have delivered it — recovered by [`retry_ff_clearing_identical`], which only
+//! ever deletes a file whose content is provably already in the incoming commit. (2)
+//! is why initial pairing pre-checks for colliding, *differing* files
+//! ([`pairing_collisions`]) instead of trusting `reset --hard` to be safe.
+//!
+//! **Every one of those writes can still make a local file disappear** — legitimately:
+//! a fast-forward, a `reset --hard` and a checkout all delete the tracked files their
+//! target commit doesn't carry, and the ff retry deletes untracked ones outright. That
+//! is ordinary git, and (bar a failed retry) recoverable from git — but it happens in
+//! the mirror, during background passes nobody asked for, and it used to happen in
+//! silence. [`audit_local_head_move`] and its call sites file each one as a warning the
+//! UI raises (`services::local_loss`, #28q).
+
+/// Section separator for the batched probe script (ASCII RS — never in git output).
+const RS: char = '\x1e';
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::process::Output;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use notify::{RecursiveMode, Watcher};
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Emitter};
+use tokio::sync::{mpsc, Mutex, Notify};
+use tokio::time::MissedTickBehavior;
+
+use crate::schema::net_usage;
+use crate::schema::project::RemoteSpec;
+use crate::services::local_loss;
+use crate::services::remote::{remote_target_for, RemotePoolState};
+use crate::services::remote_sync::{self, mirror_dir, mirror_local_path, SyncManifestState};
+use crate::services::sftp;
+use crate::services::ssh_exec;
+use crate::services::sync_auto::AutoSyncState;
+
+/// Host re-probe cadence while connected (the local side is caught near-instantly by
+/// the `.git` watcher). A remote CLI checkout is picked up within this window.
+const GIT_POLL_INTERVAL: Duration = Duration::from_secs(12);
+/// Coalesce a burst of `.git` writes (a checkout touches HEAD + refs) into one pass.
+const GIT_DEBOUNCE: Duration = Duration::from_millis(800);
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+/// A peer's HEAD: on a named branch, on a detached commit, or unborn (fresh repo).
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+pub enum HeadRef {
+    Branch { name: String, sha: String },
+    Detached { sha: String },
+    Unborn,
+}
+
+/// A `refs/heads/*` or `refs/tags/*` entry: short name + object sha.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RefEntry {
+    pub name: String,
+    pub sha: String,
+}
+
+/// A snapshot of one peer's git state (the inputs to `plan`/`decide`).
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeerSnapshot {
+    pub is_repo: bool,
+    pub head: Option<HeadRef>,
+    pub branches: Vec<RefEntry>,
+    pub tags: Vec<RefEntry>,
+    /// True only for staged/unstaged **tracked** changes (blocks a clean checkout);
+    /// untracked/ignored files never count (they remain file-sync's domain).
+    pub dirty_tracked: bool,
+    /// True when the repo check could not be *executed* over an existing tree
+    /// (git missing / spawn failure), as opposed to a clean "not a repo" answer.
+    /// A side with `probe_error` must never be treated as an empty pairing dest —
+    /// a transient failure must not license a `reset --hard` that wipes a real repo.
+    pub probe_error: bool,
+    /// Subject line of the commit at HEAD (#28p D8: shown in the desync bar so a
+    /// Use-local/Use-remote choice is informed rather than blind).
+    pub head_subject: Option<String>,
+}
+
+/// Overall lockstep status for a project.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum SyncStatus {
+    Synchronized,
+    Syncing,
+    Desynchronized,
+    /// The SSH pool is cold: nothing is known about the host, so nothing is claimed.
+    /// #28p D4 — a dropped connection used to surface as `Ok(nonzero)` from every
+    /// remote git command, which read as a *clean, legitimately empty host* and
+    /// computed to `Synchronized`. Green pill, nothing done, and the same misread
+    /// would route a misprobing host into a doomed pairing.
+    Disconnected,
+}
+
+/// The files initial pairing refused to overwrite (#28p D3): paths that exist on the
+/// would-be-`git init`ed dest and **differ** from the source's tracked content. Held
+/// in the state so the UI can name them and offer an explicit confirmation, rather
+/// than `reset --hard` destroying them with no backup and no prompt.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PairingConflict {
+    /// True when the repo side (the authority) is the local mirror, i.e. the files at
+    /// risk are the **host's**.
+    pub source_is_local: bool,
+    pub paths: Vec<String>,
+}
+
+/// Persisted per-project lockstep state (`git_peer.json`).
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GitPeerState {
+    /// Opt-in toggle; when false the watcher/poll tasks never run.
+    pub enabled: bool,
+    pub status: SyncStatus,
+    /// Human-readable reason when `status == Desynchronized`.
+    pub detail: Option<String>,
+    pub local_head: Option<HeadRef>,
+    pub remote_head: Option<HeadRef>,
+    pub last_sync_ts: Option<u64>,
+    /// Subject lines of the two HEADs (#28p D8).
+    #[serde(default)]
+    pub local_subject: Option<String>,
+    #[serde(default)]
+    pub remote_subject: Option<String>,
+    /// Set when pairing was refused because the empty side holds differing files
+    /// (#28p D3). Cleared by any pass that pairs or finds no conflict.
+    #[serde(default)]
+    pub pairing_conflict: Option<PairingConflict>,
+    /// Ref-set signatures of the last *completed* pass, per side (#28p D5 early-out):
+    /// when neither side's refs (nor its tracked-dirty bit) moved and we were green,
+    /// the whole bundle/transfer round trip is skipped and the cached status re-emitted.
+    /// This is what stops a `git add` — which trips the `.git` watcher without moving
+    /// HEAD — from costing a full network pass.
+    #[serde(default)]
+    pub local_sig: Option<String>,
+    #[serde(default)]
+    pub remote_sig: Option<String>,
+}
+
+impl Default for GitPeerState {
+    fn default() -> Self {
+        GitPeerState {
+            enabled: false,
+            status: SyncStatus::Synchronized,
+            detail: None,
+            local_head: None,
+            remote_head: None,
+            last_sync_ts: None,
+            local_subject: None,
+            remote_subject: None,
+            pairing_conflict: None,
+            local_sig: None,
+            remote_sig: None,
+        }
+    }
+}
+
+/// The fast-forward classification for one branch that both peers know.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RefAction {
+    /// Same sha on both sides.
+    InSync,
+    /// Dest lacks the branch entirely → create it (a trivial fast-forward).
+    CreateOnDest,
+    /// Dest's sha is an ancestor of the source's → dest can fast-forward.
+    FastForwardDest,
+    /// Source's sha is an ancestor of dest's → dest is ahead (the other direction handles it).
+    DestAhead,
+    /// Neither is an ancestor of the other → real divergence; never auto-applied.
+    Diverged,
+}
+
+/// A tracked file changed by a checkout (`git diff --name-status <old> <new>`),
+/// used to re-stamp the file-sync bases so the rewrite isn't seen as a conflict.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TrackedChange {
+    pub path: String,
+    pub deleted: bool,
+}
+
+/// Which peer a git command runs against.
+pub enum Peer {
+    Local(PathBuf),
+    Remote(RemoteSpec),
+}
+
+impl Peer {
+    /// Run `git <args>` against this peer, returning the captured output (parsed
+    /// byte-identically for both, exactly like `commands::git::run_git`).
+    pub fn run(&self, args: &[&str]) -> Result<Output, String> {
+        match self {
+            Peer::Local(dir) => crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .map_err(|e| e.to_string()),
+            Peer::Remote(spec) => {
+                let owned: Vec<String> = args.iter().map(|s| s.to_string()).collect();
+                ssh_exec::run_git_remote(spec, &owned)
+            }
+        }
+    }
+}
+
+/// The subset of `shas` that `peer` actually has, in one round trip: `git rev-list
+/// --no-walk --ignore-missing` echoes back every sha it can resolve and quietly drops
+/// the rest. Any failure yields none of them — a full bundle is always correct, merely
+/// larger, so this fails toward "exclude nothing".
+///
+/// An annotated tag's object sha resolves to the commit it points at rather than being
+/// echoed verbatim, so it drops out of the result. That only forfeits a delta hint (a
+/// bigger bundle), never correctness — which is the safe direction for the caller.
+fn known_shas(peer: &Peer, shas: &[String]) -> Vec<String> {
+    if shas.is_empty() {
+        return Vec::new();
+    }
+    let mut args = vec!["rev-list", "--no-walk", "--ignore-missing"];
+    args.extend(shas.iter().map(String::as_str));
+    let Ok(out) = peer.run(&args) else {
+        return Vec::new();
+    };
+    if !out.status.success() {
+        return Vec::new();
+    }
+    let have: HashSet<String> = String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .map(|l| l.trim().to_string())
+        .filter(|l| !l.is_empty())
+        .collect();
+    shas.iter().filter(|s| have.contains(*s)).cloned().collect()
+}
+
+// ── Pure parsers (unit-tested; zero I/O) ────────────────────────────────────
+
+/// Parse `git for-each-ref --format='%(objectname) %(refname:short)'` output into
+/// `(short-name, sha)` entries. Blank/short lines are skipped.
+pub fn parse_refs(stdout: &str) -> Vec<RefEntry> {
+    stdout
+        .lines()
+        .filter_map(|line| {
+            let (sha, name) = line.split_once(' ')?;
+            let name = name.trim();
+            if sha.is_empty() || name.is_empty() {
+                return None;
+            }
+            Some(RefEntry {
+                name: name.to_string(),
+                sha: sha.to_string(),
+            })
+        })
+        .collect()
+}
+
+/// Combine `git symbolic-ref --quiet --short HEAD` (branch, empty when detached)
+/// and `git rev-parse --verify --quiet HEAD` (sha, empty on an unborn HEAD) into a
+/// [`HeadRef`].
+///
+/// The sha must be a real object name or the head is [`HeadRef::Unborn`] — "not
+/// empty" is NOT enough. A plain `git rev-parse HEAD` on an unborn repo prints the
+/// literal string `HEAD` to **stdout** (and fails only via its exit status), so a
+/// caller that forgets to check that status hands us `("master", "HEAD")`. Trusting
+/// it built `Branch { name: "master", sha: "HEAD" }` — a branch that exists nowhere,
+/// at a sha that is not a sha — which read as a legitimately-checked-out peer and so
+/// masked the one state that actually needed repairing: a `git init`ed host that was
+/// never checked out. Whatever the probe does, an unborn HEAD parses as unborn.
+pub fn parse_head(symbolic: &str, rev: &str) -> HeadRef {
+    let branch = symbolic.trim();
+    let sha = rev.trim();
+    if !is_hex_sha(sha) {
+        HeadRef::Unborn
+    } else if branch.is_empty() {
+        HeadRef::Detached {
+            sha: sha.to_string(),
+        }
+    } else {
+        HeadRef::Branch {
+            name: branch.to_string(),
+            sha: sha.to_string(),
+        }
+    }
+}
+
+/// Whether `git status --porcelain` reports any **tracked** change. Untracked
+/// entries (`??`) are ignored — they never block a checkout and belong to the
+/// selective/auto file-sync engine.
+pub fn is_dirty_tracked(porcelain: &str) -> bool {
+    porcelain.lines().any(|line| {
+        let line = line.trim_end_matches(['\r', '\n']);
+        if line.len() < 2 {
+            return false;
+        }
+        &line[..2] != "??"
+    })
+}
+
+/// Classify how `dest` should move toward `source` for one branch, given the two
+/// `merge-base --is-ancestor` bits computed on the side that has both commits.
+/// `dest_sha == None` means the dest lacks the branch entirely.
+pub fn decide(
+    dest_sha: Option<&str>,
+    source_sha: &str,
+    dest_is_ancestor_of_source: bool,
+    source_is_ancestor_of_dest: bool,
+) -> RefAction {
+    match dest_sha {
+        None => RefAction::CreateOnDest,
+        Some(d) if d == source_sha => RefAction::InSync,
+        Some(_) => {
+            if dest_is_ancestor_of_source {
+                RefAction::FastForwardDest
+            } else if source_is_ancestor_of_dest {
+                RefAction::DestAhead
+            } else {
+                RefAction::Diverged
+            }
+        }
+    }
+}
+
+/// Build `git bundle create <path> <positives...> [--not <excludes...>]`.
+///
+/// `positives` are the refs/shas to include (`--branches`/`--tags`/an explicit sha).
+/// `excludes` are shas the receiver already has, making a thin delta bundle. We
+/// **never** pass `--all` (which could rope in odd refs); the shape is asserted in
+/// tests, and a bundle inherently carries only objects + the named refs — so
+/// `config`/hooks/reflogs/remotes/stashes never travel.
+pub fn bundle_create_args(path: &str, positives: &[&str], excludes: &[String]) -> Vec<String> {
+    let mut v = vec!["bundle".to_string(), "create".to_string(), path.to_string()];
+    v.extend(positives.iter().map(|s| s.to_string()));
+    if !excludes.is_empty() {
+        v.push("--not".to_string());
+        v.extend(excludes.iter().cloned());
+    }
+    v
+}
+
+/// Whether a failed `git bundle create` failed only because there was nothing to
+/// send — git's own "Refusing to create empty bundle" refusal — as opposed to a
+/// genuine I/O failure (disk full, bad path, permission denied, ...). Load-bearing
+/// for #28p D11: only the empty-bundle case may still let ref application proceed,
+/// since only then does the dest already hold every object being pointed at. Pure.
+fn is_empty_bundle_error(stderr: &str) -> bool {
+    stderr.contains("Refusing to create empty bundle")
+}
+
+/// The two refspecs that import a bundle's refs into the receiver's isolated
+/// `refs/eldrun/incoming/*` namespace — never touching real `refs/heads`/`refs/tags`.
+pub fn incoming_fetch_refspecs() -> [String; 2] {
+    [
+        "refs/heads/*:refs/eldrun/incoming/heads/*".to_string(),
+        "refs/tags/*:refs/eldrun/incoming/tags/*".to_string(),
+    ]
+}
+
+/// Parse `git diff --name-status <old> <new>` into per-file [`TrackedChange`]s.
+/// Handles rename lines (`R100\told\tnew`) by taking the new path.
+pub fn changed_tracked_paths(name_status: &str) -> Vec<TrackedChange> {
+    name_status
+        .lines()
+        .filter_map(|line| {
+            let mut cols = line.split('\t');
+            let status = cols.next()?.trim();
+            if status.is_empty() {
+                return None;
+            }
+            let code = status.chars().next().unwrap_or(' ');
+            // Renames/copies carry two paths; the last column is the current path.
+            let path = cols.last()?.trim();
+            if path.is_empty() {
+                return None;
+            }
+            Some(TrackedChange {
+                path: path.to_string(),
+                deleted: code == 'D',
+            })
+        })
+        .collect()
+}
+
+/// The distinct tracked files a set of applied branch moves changed on `dest`,
+/// unioned across moves. Each move is `(old_tip, new_tip)`; a `None` old tip is
+/// a fresh branch create, whose *whole* tree (`ls-tree -r`) is new. This feeds
+/// the "files synced" metric (`net_usage`) so a lockstep transfer is counted
+/// like a byte-sync one — without it the metric only ever reflected byte-sync
+/// and read 0 after a lockstep seed (e.g. extend-to-remote). Tags are excluded
+/// by the caller: their file content is already counted via the branch that
+/// carries the commit. Best-effort — a git failure for one move contributes
+/// nothing rather than aborting the count.
+fn files_changed_by_moves(dest: &Peer, moves: &[(Option<String>, String)]) -> usize {
+    let mut paths: HashSet<String> = HashSet::new();
+    for (old, new) in moves {
+        let out = match old {
+            Some(old) => dest.run(&["diff", "--name-only", old, new]),
+            None => dest.run(&["ls-tree", "-r", "--name-only", new]),
+        };
+        if let Ok(o) = out {
+            if o.status.success() {
+                for line in String::from_utf8_lossy(&o.stdout).lines() {
+                    let p = line.trim();
+                    if !p.is_empty() {
+                        paths.insert(p.to_string());
+                    }
+                }
+            }
+        }
+    }
+    paths.len()
+}
+
+/// A timestamped safety-ref name for a to-be-overwritten branch (Phase 2 uses it to
+/// back up the losing side before a reset; Phase 1 only names it).
+pub fn backup_ref_name(branch_short: &str, now_secs: u64) -> String {
+    format!("refs/eldrun/backup/{now_secs}/{branch_short}")
+}
+
+/// The ref a diverged branch's *peer* tip is parked at on this side (#28p D8), so the
+/// user can `git merge`/`rebase` it by hand in a terminal instead of being limited to
+/// pick-a-winner. The objects are already local (the bundle brought them), so keeping
+/// the ref is free.
+pub fn peer_ref_name(branch_short: &str) -> String {
+    format!("refs/eldrun/peer/{branch_short}")
+}
+
+/// What to do with a branch's `refs/eldrun/peer/*` ref after classifying it (#28p D8):
+/// park the peer tip only while the branch is genuinely diverged and unresolved;
+/// otherwise clear a stale one so the ref never outlives the divergence it documents.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PeerRefOp {
+    Set,
+    Delete,
+}
+
+/// See [`PeerRefOp`]. A forced pass (Use-local/Use-remote) *resolves* the divergence,
+/// so it clears the peer ref rather than parking one.
+pub fn peer_ref_op(action: RefAction, force: bool) -> PeerRefOp {
+    match action {
+        RefAction::Diverged if !force => PeerRefOp::Set,
+        _ => PeerRefOp::Delete,
+    }
+}
+
+/// Undo git's C-style path quoting (`core.quotePath`): a path containing non-ASCII,
+/// a quote, or a control char is printed wrapped in `"` with `\`-escapes. Plain paths
+/// (including ones with spaces) are printed bare and pass through unchanged.
+pub fn unquote_git_path(raw: &str) -> String {
+    let inner = match raw.strip_prefix('"').and_then(|s| s.strip_suffix('"')) {
+        Some(i) => i,
+        None => return raw.to_string(),
+    };
+    let mut out: Vec<u8> = Vec::with_capacity(inner.len());
+    let bytes = inner.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] != b'\\' || i + 1 >= bytes.len() {
+            out.push(bytes[i]);
+            i += 1;
+            continue;
+        }
+        let c = bytes[i + 1];
+        match c {
+            b'n' => {
+                out.push(b'\n');
+                i += 2;
+            }
+            b't' => {
+                out.push(b'\t');
+                i += 2;
+            }
+            b'r' => {
+                out.push(b'\r');
+                i += 2;
+            }
+            b'0'..=b'7' => {
+                // Octal escape (\303\251 → the two UTF-8 bytes of "é").
+                let end = (i + 4).min(bytes.len());
+                match u8::from_str_radix(&inner[i + 1..end], 8) {
+                    Ok(b) => {
+                        out.push(b);
+                        i = end;
+                    }
+                    Err(_) => {
+                        out.push(bytes[i]);
+                        i += 1;
+                    }
+                }
+            }
+            // `\"`, `\\`, and anything else: the escaped byte stands for itself.
+            _ => {
+                out.push(c);
+                i += 2;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).to_string()
+}
+
+/// The paths git names in
+/// `error: The following untracked working tree files would be overwritten by merge:`
+/// — the real cause of most blocked fast-forwards (#28p D1/D2), and the input to the
+/// identical-content retry. The list is TAB-indented and terminated by git's
+/// "Please move or remove them…" line. Pure.
+pub fn parse_untracked_overwrite_paths(stderr: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut in_list = false;
+    for line in stderr.lines() {
+        if line.contains("untracked working tree files would be overwritten") {
+            in_list = true;
+            continue;
+        }
+        if !in_list {
+            continue;
+        }
+        // The list is the run of indented lines; anything else ends it.
+        let trimmed = line.trim_start_matches(['\t', ' ']);
+        if trimmed.len() == line.len() || trimmed.is_empty() {
+            break;
+        }
+        out.push(unquote_git_path(trimmed.trim_end()));
+    }
+    out
+}
+
+/// The `Desynchronized` detail for a fast-forward git refused to perform (#28p D2).
+/// The old message always read "A peer has uncommitted changes" — but the cause is
+/// usually *untracked* collisions, and the stderr naming the files was thrown away,
+/// sending users hunting for uncommitted changes that do not exist. Pure.
+pub fn blocked_detail(branch: &str, stderr: &str) -> String {
+    let untracked = parse_untracked_overwrite_paths(stderr);
+    if !untracked.is_empty() {
+        let shown: Vec<&str> = untracked.iter().take(3).map(String::as_str).collect();
+        let more = untracked.len() - shown.len();
+        let extra = if more > 0 {
+            format!(" (+{more} more)")
+        } else {
+            String::new()
+        };
+        return format!(
+            "'{branch}' can't fast-forward: untracked file(s) on the peer differ from the incoming commit: {}{extra}",
+            shown.join(", ")
+        );
+    }
+    let first = stderr
+        .lines()
+        .map(str::trim)
+        .find(|l| !l.is_empty())
+        .unwrap_or("the peer has uncommitted changes");
+    format!("'{branch}' can't fast-forward: {first}")
+}
+
+// ── Batched probe (#28p D5) ─────────────────────────────────────────────────
+
+/// One `sh` script emitting every field [`probe`] needs, as `\x1e`-separated sections
+/// — replacing **6 SSH round trips with 1**. Sections, in order: the literal `repo`
+/// marker, `symbolic-ref HEAD`, `rev-parse HEAD`, branches, tags, `status --porcelain`,
+/// HEAD's subject. A non-repo emits the single token `norepo`.
+///
+/// Contains no interpolation: it is a constant, so there is nothing here to inject
+/// into (the only variable — the project's remote path — is `shell_quote`d by
+/// [`ssh_exec::run_remote_script`], which `cd`s to it).
+/// The batched host probe. Its **output** is its answer; its **exit status** means only
+/// "the probe ran" — hence the trailing `|| true`. An unborn repo makes the final
+/// `git log HEAD` exit 128, and letting that escape would make a legitimately-empty side
+/// indistinguishable from a probe that could not run at all — the one confusion that must
+/// never happen here, since "could not run" is what withholds a `reset --hard`.
+///
+/// Every `rev-parse` inside must likewise report an unborn HEAD by *printing nothing*
+/// (`--verify --quiet`), not by exiting non-zero: a bare `git rev-parse HEAD` prints the
+/// literal `HEAD` to stdout and fails only in its status, which this script discards.
+const PROBE_SCRIPT: &str = "\
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then \
+printf 'repo\\036'; \
+git symbolic-ref --quiet --short HEAD 2>/dev/null; printf '\\036'; \
+git rev-parse --verify --quiet HEAD 2>/dev/null; printf '\\036'; \
+git for-each-ref --format='%(objectname) %(refname:short)' refs/heads 2>/dev/null; printf '\\036'; \
+git for-each-ref --format='%(objectname) %(refname:short)' refs/tags 2>/dev/null; printf '\\036'; \
+git status --porcelain 2>/dev/null; printf '\\036'; \
+git log -1 --format=%s HEAD 2>/dev/null || true; \
+else printf 'norepo'; fi";
+
+/// Parse [`PROBE_SCRIPT`]'s output into a snapshot. `None` means the output was not
+/// recognizable (a host with no POSIX `sh`, or a link that died mid-script), which
+/// makes the caller fall back to the per-command probe. Pure.
+pub fn parse_probe_block(stdout: &str) -> Option<PeerSnapshot> {
+    if stdout.trim_start().starts_with("norepo") {
+        return Some(PeerSnapshot::default());
+    }
+    let rest = stdout.trim_start().strip_prefix("repo")?.strip_prefix(RS)?;
+    let parts: Vec<&str> = rest.split(RS).collect();
+    // Tolerate a truncated tail (an older git printing nothing for a section still
+    // emits its separator; a missing trailing section is not fatal).
+    if parts.len() < 5 {
+        return None;
+    }
+    Some(PeerSnapshot {
+        is_repo: true,
+        head: Some(parse_head(parts[0], parts[1])),
+        branches: parse_refs(parts[2]),
+        tags: parse_refs(parts[3]),
+        dirty_tracked: is_dirty_tracked(parts[4]),
+        probe_error: false,
+        head_subject: parts
+            .get(5)
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty()),
+    })
+}
+
+/// Whether a string is a plain hex object name — the guard that lets [`ancestry_script`]
+/// interpolate shas into a shell script at all.
+fn is_hex_sha(s: &str) -> bool {
+    !s.is_empty() && s.len() <= 64 && s.chars().all(|c| c.is_ascii_hexdigit())
+}
+
+/// One script running every branch's two `merge-base --is-ancestor` checks (#28p D5),
+/// collapsing `2·N` round trips into 1. Emits one `01`/`10`/`00`/`11` line per pair, in
+/// order: `<dest is ancestor of source><source is ancestor of dest>`. Callers must pass
+/// hex shas only ([`is_hex_sha`]); nothing else is ever interpolated. Pure.
+pub fn ancestry_script(pairs: &[(String, String)]) -> String {
+    let mut s = String::new();
+    for (dst, src) in pairs {
+        s.push_str(&format!(
+            "if git merge-base --is-ancestor {dst} {src} 2>/dev/null; then printf 1; else printf 0; fi; \
+             if git merge-base --is-ancestor {src} {dst} 2>/dev/null; then printf '1\\n'; else printf '0\\n'; fi; "
+        ));
+    }
+    s
+}
+
+/// Parse [`ancestry_script`]'s output into `(dest_is_ancestor_of_source,
+/// source_is_ancestor_of_dest)` per pair. `None` when the line count doesn't match the
+/// pairs asked about — the caller then falls back to per-branch checks rather than
+/// trusting a misaligned answer (a wrong bit here would misclassify a divergence). Pure.
+pub fn parse_ancestry_block(stdout: &str, expected: usize) -> Option<Vec<(bool, bool)>> {
+    let v: Vec<(bool, bool)> = stdout
+        .lines()
+        .map(str::trim)
+        .filter(|l| l.len() == 2 && l.chars().all(|c| c == '0' || c == '1'))
+        .map(|l| (l.starts_with('1'), l.ends_with('1')))
+        .collect();
+    (v.len() == expected).then_some(v)
+}
+
+/// A compact signature of everything about a peer that can make a pass necessary: its
+/// refs, its HEAD, and whether its tracked tree is dirty (a dirty→clean transition can
+/// unblock a fast-forward, so it must not be invisible). Pure.
+pub fn refs_signature(snap: &PeerSnapshot) -> String {
+    if !snap.is_repo {
+        return String::new();
+    }
+    let mut refs: Vec<String> = snap
+        .branches
+        .iter()
+        .map(|r| format!("h{}={}", r.name, r.sha))
+        .chain(snap.tags.iter().map(|r| format!("t{}={}", r.name, r.sha)))
+        .collect();
+    refs.sort();
+    format!(
+        "{}|{}|{}",
+        refs.join(";"),
+        match &snap.head {
+            Some(HeadRef::Branch { name, sha }) => format!("b:{name}:{sha}"),
+            Some(HeadRef::Detached { sha }) => format!("d:{sha}"),
+            _ => "u".to_string(),
+        },
+        snap.dirty_tracked as u8
+    )
+}
+
+/// The two peers' refs all match, but their HEADs point somewhere different — same
+/// history, different working state. Lockstep's promise is that both sides sit on the
+/// *same* commit, so this is not green. Pure; `None` means "in step".
+///
+/// `reconcile_with` otherwise compares only **refs**, and refs are identical in exactly
+/// the situations this catches:
+///   * a coordinated checkout that only half-landed — the peer's guarded checkout was
+///     refused because its tree was dirty (case 19) — and the user then clears the dirt
+///     and hits Retry. No ref moved, so nothing looked wrong, and the peer was left on
+///     the old branch under a green pill.
+///   * any peer HEAD move the event-driven detection missed.
+///
+/// Deliberately *reports* rather than auto-checking-out: with no observed move there is
+/// no principled way to say which side should follow the other, and lockstep never
+/// rewrites a worktree it wasn't asked to. The Checkout action is one click away.
+pub fn head_mismatch(local: &PeerSnapshot, remote: &PeerSnapshot) -> Option<String> {
+    let describe = |h: &HeadRef| match h {
+        HeadRef::Branch { name, .. } => format!("'{name}'"),
+        HeadRef::Detached { sha } => {
+            format!("detached at {}", sha.chars().take(8).collect::<String>())
+        }
+        HeadRef::Unborn => "an unborn branch".to_string(),
+    };
+    match (&local.head, &remote.head) {
+        (Some(l), Some(r)) if l != r => Some(format!(
+            "Out of step: the mirror is on {}, the host is on {}",
+            describe(l),
+            describe(r)
+        )),
+        _ => None,
+    }
+}
+
+/// Whether a side is **seeded**: a repo whose HEAD is *born* — some commit is actually
+/// checked out. A bare `git init` is a repo but is NOT seeded: nothing has ever been
+/// written to its working tree.
+///
+/// This, not [`PeerSnapshot::is_repo`], is what initial pairing keys on, because
+/// `git init` is pairing's own *first step*. A seed that dies after it (a link that
+/// drops mid-bundle) leaves a dest that is a repo, holds no commit, and has an empty
+/// working tree. Under an `is_repo` gate that state is unrepairable: "exactly one side
+/// is a repo" never fires again, and the steady-state path only ever moves refs
+/// (`update-ref`) — it never positions HEAD or checks anything out, since that is
+/// [`init_pairing`]'s exclusive job. Refs and objects land, the tree stays empty, and
+/// the pill reports an eternal head mismatch against a branch nobody has. Keying on
+/// "has a commit checked out" makes a half-seeded side simply *unpaired*, so the next
+/// pass finishes what the dropped one started. Pure.
+pub fn is_seeded(snap: &PeerSnapshot) -> bool {
+    snap.is_repo
+        && matches!(
+            snap.head,
+            Some(HeadRef::Branch { .. }) | Some(HeadRef::Detached { .. })
+        )
+}
+
+/// What a pass should do with the two sides — the gate `reconcile` runs on. Pure.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PairPlan {
+    /// Both sides seeded → the ordinary bidirectional transfer.
+    Sync,
+    /// Exactly one side seeded → initialize the other from it. `source_is_local` names
+    /// the authority; the *other* side is the one `git init` + `reset --hard` touches.
+    Pair { source_is_local: bool },
+    /// Neither side holds a commit → there is nothing to move in either direction.
+    Nothing,
+}
+
+/// Decide the pass from the two snapshots. Pure.
+pub fn pair_plan(local: &PeerSnapshot, remote: &PeerSnapshot) -> PairPlan {
+    match (is_seeded(local), is_seeded(remote)) {
+        (true, true) => PairPlan::Sync,
+        (true, false) => PairPlan::Pair { source_is_local: true },
+        (false, true) => PairPlan::Pair { source_is_local: false },
+        (false, false) => PairPlan::Nothing,
+    }
+}
+
+/// Whether a pass may be skipped entirely (#28p D5). Deliberately narrow: only a
+/// **green** project whose two ref signatures are both unchanged early-outs. Any
+/// non-green state re-runs in full, so a manual Retry after the user clears a blocker
+/// (deleting an untracked collision moves no ref) is never answered from cache. Pure.
+///
+/// `both_seeded` — not "both are repos": a half-seeded side must never be able to
+/// early-out of the pass that would repair it.
+pub fn can_early_out(
+    prior: &GitPeerState,
+    local_sig: &str,
+    remote_sig: &str,
+    both_seeded: bool,
+    forced: bool,
+) -> bool {
+    !forced
+        && both_seeded
+        && prior.status == SyncStatus::Synchronized
+        && prior.local_sig.as_deref() == Some(local_sig)
+        && prior.remote_sig.as_deref() == Some(remote_sig)
+}
+
+// ── Pairing-collision detection (#28p D3) ───────────────────────────────────
+
+/// A file's identity on one side: its size, plus a git blob sha when one could be
+/// computed. `hash: None` means "not proven equal to anything" — treated as a
+/// difference, because pairing's `reset --hard` is destructive and unproven-equal is
+/// not a safe basis for it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Fingerprint {
+    pub size: u64,
+    pub hash: Option<String>,
+}
+
+/// Parse `git ls-tree -r -l -z HEAD`: NUL-terminated records of
+/// `<mode> SP blob SP <sha> SP<pad> <size> TAB <path>`. `-z` is what makes this
+/// unambiguous — an unquoted path may contain anything but NUL. Pure.
+pub fn parse_ls_tree_long(stdout: &[u8]) -> HashMap<String, Fingerprint> {
+    let mut out = HashMap::new();
+    for rec in stdout.split(|&b| b == 0) {
+        if rec.is_empty() {
+            continue;
+        }
+        let rec = String::from_utf8_lossy(rec);
+        let Some((meta, path)) = rec.split_once('\t') else {
+            continue;
+        };
+        let cols: Vec<&str> = meta.split_whitespace().collect();
+        // <mode> <type> <sha> <size>; skip submodules/trees (only blobs have bytes).
+        if cols.len() != 4 || cols[1] != "blob" {
+            continue;
+        }
+        let Ok(size) = cols[3].parse::<u64>() else {
+            continue;
+        };
+        out.insert(
+            path.replace('\\', "/"),
+            Fingerprint {
+                size,
+                hash: Some(cols[2].to_string()),
+            },
+        );
+    }
+    out
+}
+
+/// The paths that make an initial pairing unsafe: present on **both** sides and not
+/// provably identical (#28p D3). Only these are at risk — `reset --hard` would destroy
+/// them with no backup — so a non-empty result must refuse the pairing rather than
+/// proceed. Everything else (dest-only files, and byte-identical collisions, which is
+/// the *expected* case when file-sync already mirrored the tree) pairs cleanly.
+///
+/// Conservative by construction: an equal size with an unknown hash counts as a
+/// difference. Refusing a pairing costs a click; guessing wrong costs the user's files.
+/// Pure.
+pub fn pairing_collisions(
+    source: &HashMap<String, Fingerprint>,
+    dest: &HashMap<String, Fingerprint>,
+) -> Vec<String> {
+    let mut out: Vec<String> = source
+        .iter()
+        .filter_map(|(path, s)| {
+            let d = dest.get(path)?;
+            if s.size != d.size {
+                return Some(path.clone());
+            }
+            match (&s.hash, &d.hash) {
+                (Some(a), Some(b)) if a == b => None,
+                _ => Some(path.clone()),
+            }
+        })
+        .collect();
+    out.sort();
+    out
+}
+
+// ── Backup refs (#28p D6) ───────────────────────────────────────────────────
+
+/// One `refs/eldrun/backup/<ts>/<branch>` safety ref, as listed for the Backups UI.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BackupRef {
+    /// `"local"` or `"remote"` — which peer holds it.
+    pub peer: String,
+    pub refname: String,
+    pub ts: u64,
+    pub branch: String,
+    pub sha: String,
+    pub subject: String,
+}
+
+/// Inverse of [`backup_ref_name`]. Pure.
+pub fn parse_backup_ref_name(refname: &str) -> Option<(u64, String)> {
+    let rest = refname.strip_prefix("refs/eldrun/backup/")?;
+    let (ts, branch) = rest.split_once('/')?;
+    if branch.is_empty() {
+        return None;
+    }
+    Some((ts.parse().ok()?, branch.to_string()))
+}
+
+/// Parse `for-each-ref --format='%(objectname)%09%(refname)%09%(contents:subject)'`
+/// over `refs/eldrun/backup`. Pure.
+pub fn parse_backup_refs(peer: &str, stdout: &str) -> Vec<BackupRef> {
+    let mut out: Vec<BackupRef> = stdout
+        .lines()
+        .filter_map(|line| {
+            let mut cols = line.split('\t');
+            let sha = cols.next()?.trim();
+            let refname = cols.next()?.trim();
+            let subject = cols.next().unwrap_or("").trim();
+            let (ts, branch) = parse_backup_ref_name(refname)?;
+            (!sha.is_empty()).then(|| BackupRef {
+                peer: peer.to_string(),
+                refname: refname.to_string(),
+                ts,
+                branch,
+                sha: sha.to_string(),
+                subject: subject.to_string(),
+            })
+        })
+        .collect();
+    out.sort_by(|a, b| b.ts.cmp(&a.ts).then_with(|| a.branch.cmp(&b.branch)));
+    out
+}
+
+/// Which backup refs to drop: everything that is neither among the newest `keep_n` nor
+/// younger than `max_age_secs` (#28p D6 — they pin objects forever otherwise). The
+/// newest ref is **never** pruned, whatever the policy says: the most recent safety net
+/// is the one a user is most likely to still need. Pure.
+pub fn select_prunable(
+    refs: &[BackupRef],
+    now: u64,
+    keep_n: usize,
+    max_age_secs: u64,
+) -> Vec<String> {
+    let mut sorted: Vec<&BackupRef> = refs.iter().collect();
+    sorted.sort_by_key(|r| std::cmp::Reverse(r.ts));
+    sorted
+        .iter()
+        .enumerate()
+        .filter(|(i, r)| {
+            *i > 0 && *i >= keep_n && now.saturating_sub(r.ts) > max_age_secs
+        })
+        .map(|(_, r)| r.refname.clone())
+        .collect()
+}
+
+/// The `origin` URL a freshly-paired dest should inherit from the source (#28p D7):
+/// the mirror is `git init`ed from a bundle, and bundles carry no `config`/remotes, so
+/// `git push` from a local agent tab used to just fail. Only the **URL** propagates —
+/// never credentials, never other config keys — and never over a dest that already has
+/// its own origin. Pure.
+pub fn should_propagate_origin(source: Option<&str>, dest: Option<&str>) -> Option<String> {
+    let src = source.map(str::trim).filter(|s| !s.is_empty())?;
+    match dest.map(str::trim).filter(|s| !s.is_empty()) {
+        Some(_) => None,
+        None => Some(src.to_string()),
+    }
+}
+
+fn now_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0)
+}
+
+// ── State persistence ───────────────────────────────────────────────────────
+
+/// `<state_dir>/remote-projects/<id>/git_peer.json` (sibling of `sync.json`).
+pub fn state_path(project_id: &str) -> PathBuf {
+    crate::storage::state_dir()
+        .join("remote-projects")
+        .join(project_id)
+        .join("git_peer.json")
+}
+
+/// Load a project's persisted lockstep state (default/disabled if absent).
+pub fn load_state(project_id: &str) -> GitPeerState {
+    crate::storage::read_json(&state_path(project_id)).unwrap_or_default()
+}
+
+/// Persist a project's lockstep state.
+pub fn save_state(project_id: &str, state: &GitPeerState) -> Result<(), String> {
+    crate::storage::write_json(&state_path(project_id), state).map_err(|e| e.to_string())
+}
+
+// ── Probing ─────────────────────────────────────────────────────────────────
+
+/// Read a peer's git state (HEAD, branches, tags, tracked-dirty). A non-repo or any
+/// probe failure yields `is_repo == false` so the caller degrades gracefully.
+///
+/// A **remote** peer is probed with one batched script ([`PROBE_SCRIPT`]) instead of
+/// six SSH round trips (#28p D5); anything the script's output can't answer for falls
+/// back to the per-command path below, so a host without a POSIX `sh` still works.
+pub fn probe(peer: &Peer) -> PeerSnapshot {
+    if let Peer::Remote(spec) = peer {
+        match ssh_exec::run_remote_script(spec, PROBE_SCRIPT) {
+            Ok(out) => {
+                if let Some(snap) = parse_probe_block(&String::from_utf8_lossy(&out.stdout)) {
+                    return snap;
+                }
+                // Unrecognizable output → fall through to the per-command probe, which
+                // classifies `probe_error` itself.
+            }
+            Err(_) => {
+                return PeerSnapshot {
+                    probe_error: true,
+                    ..Default::default()
+                }
+            }
+        }
+    }
+    probe_per_command(peer)
+}
+
+/// The original one-command-per-field probe. Still the path for the local mirror (six
+/// local `git` spawns cost nothing) and the fallback for a remote host whose shell
+/// couldn't run the batched script.
+fn probe_per_command(peer: &Peer) -> PeerSnapshot {
+    let res = peer.run(&["rev-parse", "--is-inside-work-tree"]);
+    let is_repo = res.as_ref().map(|o| o.status.success()).unwrap_or(false);
+    if !is_repo {
+        // Distinguish a clean "not a repo" (git ran, said no — a legitimately empty
+        // side we may safely initialize) from a probe that could not run at all. A
+        // missing local dir is *not* an error: there is no repo there to destroy, so
+        // pairing may create the mirror. But an execution failure over an existing
+        // tree must NOT read as "empty" — that would let a `reset --hard` wipe a real
+        // repo on a transient git hiccup. `remote_target_for`-side connection drops
+        // surface as a non-zero ssh exit (Ok), so only a true spawn error flags here.
+        let probe_error = match peer {
+            Peer::Local(dir) => dir.exists() && res.is_err(),
+            Peer::Remote(_) => res.is_err(),
+        };
+        return PeerSnapshot {
+            probe_error,
+            ..Default::default()
+        };
+    }
+
+    let symbolic = peer
+        .run(&["symbolic-ref", "--quiet", "--short", "HEAD"])
+        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+        .unwrap_or_default();
+    // `--verify --quiet` so an unborn HEAD yields *empty stdout* rather than the
+    // literal `HEAD` that a bare `rev-parse HEAD` prints — the two probes must agree
+    // on what unborn looks like, whichever one a peer happens to take.
+    let rev = peer
+        .run(&["rev-parse", "--verify", "--quiet", "HEAD"])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).to_string())
+        .unwrap_or_default();
+    let head = Some(parse_head(&symbolic, &rev));
+
+    let branches = peer
+        .run(&[
+            "for-each-ref",
+            "--format=%(objectname) %(refname:short)",
+            "refs/heads",
+        ])
+        .map(|o| parse_refs(&String::from_utf8_lossy(&o.stdout)))
+        .unwrap_or_default();
+    let tags = peer
+        .run(&[
+            "for-each-ref",
+            "--format=%(objectname) %(refname:short)",
+            "refs/tags",
+        ])
+        .map(|o| parse_refs(&String::from_utf8_lossy(&o.stdout)))
+        .unwrap_or_default();
+    let dirty_tracked = peer
+        .run(&["status", "--porcelain"])
+        .map(|o| is_dirty_tracked(&String::from_utf8_lossy(&o.stdout)))
+        .unwrap_or(false);
+    let head_subject = peer
+        .run(&["log", "-1", "--format=%s", "HEAD"])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .filter(|s| !s.is_empty());
+
+    PeerSnapshot {
+        is_repo: true,
+        head,
+        branches,
+        tags,
+        dirty_tracked,
+        probe_error: false,
+        head_subject,
+    }
+}
+
+/// The mirror's git-tracked path set (`git ls-files -z`), normalized to `/` separators.
+///
+/// **The load-bearing boundary of #28p D1.** `sync_auto` subtracts this from its
+/// candidate set whenever lockstep is on, which is what makes the two transports stop
+/// racing: lockstep owns every tracked file (it delivers them as commits), byte-sync
+/// owns everything else. Without it, a file lockstep was about to deliver as a commit
+/// could first be shipped as loose bytes, land on the peer *untracked*, and then block
+/// the very fast-forward that would have delivered it properly.
+///
+/// NUL-delimited so paths with spaces/quotes survive verbatim (no `core.quotePath`
+/// escaping). `.git` is never listed by `ls-files`; a gitignored `.eldrun` won't be
+/// either — both stay out of byte-sync, as elsewhere. Empty set on any failure, which
+/// degrades to today's (racy but working) behaviour rather than silently syncing nothing.
+pub fn tracked_paths(project_id: &str) -> HashSet<String> {
+    let local = Peer::Local(mirror_dir(project_id));
+    let out = match local.run(&["ls-files", "-z"]) {
+        Ok(o) if o.status.success() => o.stdout,
+        _ => return HashSet::new(),
+    };
+    out.split(|&b| b == 0)
+        .filter(|s| !s.is_empty())
+        .map(|s| String::from_utf8_lossy(s).replace('\\', "/"))
+        .collect()
+}
+
+// ── Transport + apply ───────────────────────────────────────────────────────
+
+/// Transient bundle file paths (inside `.git`, so file-sync/status never see them).
+fn local_bundle_path(project_id: &str) -> PathBuf {
+    mirror_dir(project_id).join(".git").join("eldrun-lockstep.bundle")
+}
+fn remote_bundle_path(spec: &RemoteSpec) -> String {
+    remote_sync::join_remote(&spec.remote_path, ".git/eldrun-lockstep.bundle")
+}
+
+fn sha_of<'a>(snap: &'a PeerSnapshot, kind: RefKind, name: &str) -> Option<&'a str> {
+    let list = match kind {
+        RefKind::Head => &snap.branches,
+        RefKind::Tag => &snap.tags,
+    };
+    list.iter().find(|r| r.name == name).map(|r| r.sha.as_str())
+}
+
+#[derive(Clone, Copy)]
+enum RefKind {
+    Head,
+    Tag,
+}
+
+/// One direction of a reconcile: bundle `source`'s heads+tags (delta-excluding what
+/// `dest` already has), move the bundle to the dest's fs, `git fetch` it, then apply
+/// the safe (create / fast-forward) updates on `dest`. Returns branch names that
+/// diverged (never auto-applied) and whether a needed fast-forward was blocked by a
+/// dirty dest. Objects only — `.git` internals never cross (see [`bundle_create_args`]).
+///
+/// When `force` is set (the Use-local/Use-remote resolution, #28n Phase 2), `source`
+/// is the user-chosen authority: a diverged branch or one where `dest` is *ahead* is
+/// reset to `source`'s sha after saving the overwritten tip to a timestamped
+/// `refs/eldrun/backup/*` safety ref (a checked-out loser branch is `reset --hard`,
+/// moving ref + working tree). Tags conflicting on sha are likewise force-moved with
+/// a backup. `force` never widens what history *transfers*, only how `dest` applies it.
+async fn transfer_and_apply(
+    pool: &RemotePoolState,
+    manifest: &SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    to_remote: bool,
+    source: &PeerSnapshot,
+    dest: &PeerSnapshot,
+    force: bool,
+) -> Result<TransferResult, String> {
+    let mut result = TransferResult::default();
+    if !source.is_repo {
+        return Ok(result);
+    }
+
+    // Delta-exclude every sha the dest already has (thin bundle). A brand-new dest
+    // has no shas → full bundle.
+    let mut excludes: Vec<String> = dest
+        .branches
+        .iter()
+        .chain(dest.tags.iter())
+        .map(|r| r.sha.clone())
+        .collect();
+    excludes.sort();
+    excludes.dedup();
+
+    let (src_peer, dst_peer) = if to_remote {
+        (Peer::Local(mirror_dir(project_id)), Peer::Remote(spec.clone()))
+    } else {
+        (Peer::Remote(spec.clone()), Peer::Local(mirror_dir(project_id)))
+    };
+
+    // #28q: when the dest is the LOCAL mirror, the apply below can move its checked-out
+    // branch — by fast-forward, or by `reset --hard` under `force` — and either one
+    // deletes the tracked files the incoming commit dropped. Snapshot the tip now so the
+    // audit at the end can name them. `None` for a remote dest (nothing local at risk) or
+    // an unborn local one (nothing there to lose).
+    let local_head_before = if to_remote { None } else { local_head_sha(project_id) };
+
+    // …but only the ones the source actually has. An exclude the source has never seen
+    // is not a delta hint to git, it is a fatal argument: `bundle create --not <unknown>`
+    // aborts the entire bundle. And "the dest's tip is a commit this side has never seen"
+    // is *precisely* what a divergence looks like from the source — so leaving them in
+    // aborted BOTH transfer legs on every genuine divergence, and the empty-bundle no-op
+    // below then reported it as Synchronized. A green pill over two histories silently
+    // drifting apart, with the desync bar (and Use local / Use remote) never offered.
+    // Excludes are only a bundle-size optimization, so dropping one costs bytes, never
+    // correctness.
+    let excludes = known_shas(&src_peer, &excludes);
+
+    // 1. Create the bundle on the source's own fs.
+    let (src_bundle, dst_bundle) = if to_remote {
+        (
+            local_bundle_path(project_id).to_string_lossy().to_string(),
+            remote_bundle_path(spec),
+        )
+    } else {
+        (
+            remote_bundle_path(spec),
+            local_bundle_path(project_id).to_string_lossy().to_string(),
+        )
+    };
+    let create = bundle_create_args(&src_bundle, &["--branches", "--tags"], &excludes);
+    let create_ref: Vec<&str> = create.iter().map(|s| s.as_str()).collect();
+    let out = src_peer.run(&create_ref)?;
+    // git refuses to create an *empty* bundle, which is how it reports "the dest already
+    // has every object I would have sent". That is a no-op **transfer** — it is emphatically
+    // not a no-op **apply**: the dest's refs still have to move onto those objects. Returning
+    // here (as this used to) silently skipped step 4 whenever the objects happened to be
+    // there already, which is the normal case for a Use-local/Use-remote resolve, and for any
+    // branch whose commits reached the peer via a descendant branch. Observed live: a resolve
+    // that transferred nothing, moved nothing, and reported the divergence it had just been
+    // asked to end.
+    if out.status.success() {
+        // 2. Move the bundle across via the pooled SFTP session.
+        move_bundle(pool, project_id, to_remote, &src_bundle, &dst_bundle).await?;
+
+        // 3. Import objects into the dest's isolated incoming namespace.
+        let specs = incoming_fetch_refspecs();
+        let fetch: Vec<&str> = vec!["fetch", &dst_bundle, &specs[0], &specs[1]];
+        let _ = dst_peer.run(&fetch); // fetch failure → apply below simply finds nothing
+    } else {
+        let stderr = String::from_utf8_lossy(&out.stderr);
+        if !is_empty_bundle_error(&stderr) {
+            // #28p D11: a GENUINE creation failure (disk full, bad path, permission
+            // denied, ...) — as opposed to the empty-bundle refusal handled above —
+            // means no objects moved anywhere. Step 4 must not run: applying a ref
+            // update now would move dest's refs onto shas it was never actually given,
+            // a dangling pointer no object backs, reported as `applied` and computed
+            // to Synchronized — the same false-green shape the empty-bundle fix above
+            // exists to avoid, in the one case that fix must not paper over.
+            return Err(format!("bundle create failed: {}", stderr.trim()));
+        }
+    }
+
+    // 4. Apply safe updates per branch. One shared timestamp so every safety ref this
+    //    forced pass creates sorts under the same `refs/eldrun/backup/<ts>/` batch.
+    let head_branch = match &dest.head {
+        Some(HeadRef::Branch { name, .. }) => Some(name.clone()),
+        _ => None,
+    };
+    let ts = now_secs();
+
+    // Every branch's two ancestry bits in ONE round trip on the dest (#28p D5); the
+    // bundle already put every object there, so all the checks can run together.
+    let known: Vec<(String, String, String)> = source
+        .branches
+        .iter()
+        .filter_map(|r| {
+            sha_of(dest, RefKind::Head, &r.name)
+                .map(|d| (r.name.clone(), d.to_string(), r.sha.clone()))
+        })
+        .collect();
+    let flags = ancestry_map(
+        &dst_peer,
+        &known
+            .iter()
+            .map(|(_, d, s)| (d.clone(), s.clone()))
+            .collect::<Vec<_>>(),
+    );
+    let ancestry: HashMap<&str, (bool, bool)> = known
+        .iter()
+        .map(|(b, _, _)| b.as_str())
+        .zip(flags)
+        .collect();
+
+    // Every branch tip that actually moved on the dest this pass, as
+    // `(old_tip, new_tip)` — unioned into a "files synced" count at the end so a
+    // lockstep transfer registers in `net_usage` like a byte-sync one.
+    let mut applied_moves: Vec<(Option<String>, String)> = Vec::new();
+    for src_ref in &source.branches {
+        let dst_sha = sha_of(dest, RefKind::Head, &src_ref.name);
+        let applied_before = result.applied;
+        let (fwd, back) = ancestry
+            .get(src_ref.name.as_str())
+            .copied()
+            .unwrap_or((false, false));
+        let is_head = head_branch.as_deref() == Some(src_ref.name.as_str());
+        let action = decide(dst_sha, &src_ref.sha, fwd, back);
+        match action {
+            RefAction::InSync => {}
+            RefAction::DestAhead => {
+                // Under a resolution the authority wins even where the dest is ahead:
+                // discard the dest's extra commits (backed up) and reset to source.
+                if force {
+                    force_reset_branch(&dst_peer, &src_ref.name, &src_ref.sha, dst_sha.unwrap(), is_head, ts);
+                    result.applied += 1;
+                }
+            }
+            RefAction::CreateOnDest => {
+                let _ = dst_peer.run(&[
+                    "update-ref",
+                    &format!("refs/heads/{}", src_ref.name),
+                    &src_ref.sha,
+                ]);
+                result.applied += 1;
+            }
+            RefAction::FastForwardDest => {
+                if is_head {
+                    // Checked-out branch: move ref + working tree, refusing on a dirty tree.
+                    match dst_peer.run(&["merge", "--ff-only", &src_ref.sha]) {
+                        Ok(o) if o.status.success() => result.applied += 1,
+                        Ok(o) => {
+                            // Usually NOT "uncommitted changes": git also refuses when an
+                            // untracked file would be overwritten — even a byte-identical
+                            // one, which is exactly what a byte-sync that outran the commit
+                            // leaves behind. Clear those (only when provably identical, or
+                            // provably our own stale byte-sync residue — case #12) and
+                            // retry; otherwise report what git actually said (#28p D1/D2).
+                            let stderr = String::from_utf8_lossy(&o.stderr).to_string();
+                            let colliding = parse_untracked_overwrite_paths(&stderr);
+                            let residue =
+                                stale_byte_sync_residue(manifest, project_id, &dst_peer, &colliding)
+                                    .await;
+                            match retry_ff_clearing_identical(
+                                &dst_peer,
+                                &src_ref.sha,
+                                &stderr,
+                                &residue,
+                            ) {
+                                FfRetry::Cleared(cleared) => {
+                                    // #28q: the identical files came back byte-for-byte (the ff
+                                    // wrote the same blob), so only the residue ones lost
+                                    // anything — their older byte-synced copy, replaced by the
+                                    // committed content. Report those, and only when the mirror
+                                    // is the side that was cleaned.
+                                    if !to_remote {
+                                        let replaced: Vec<String> = cleared
+                                            .iter()
+                                            .filter(|p| residue.contains(*p))
+                                            .cloned()
+                                            .collect();
+                                        local_loss::record_paths(
+                                            project_id,
+                                            local_loss::LossSource::Git,
+                                            local_loss::LossKind::Overwritten,
+                                            "fast-forward from the host (replaced a stale \
+                                             byte-synced copy)",
+                                            replaced,
+                                            Some(
+                                                "The file now holds the host's committed content. \
+                                                 The copy that was replaced was an older \
+                                                 byte-synced version of the same file and was \
+                                                 never committed anywhere."
+                                                    .to_string(),
+                                            ),
+                                        );
+                                    }
+                                    forget_synced_paths(manifest, project_id, &colliding).await;
+                                    result.applied += 1;
+                                }
+                                FfRetry::ClearedButFailed(cleared) => {
+                                    // The files were removed to clear the way and the ff then
+                                    // failed anyway: the mirror is now short every one of them,
+                                    // with nothing having rewritten them. Loudest case we have.
+                                    if !to_remote {
+                                        local_loss::record_paths(
+                                            project_id,
+                                            local_loss::LossSource::Git,
+                                            local_loss::LossKind::Deleted,
+                                            "fast-forward from the host (cleared blocking \
+                                             untracked files, then failed)",
+                                            cleared,
+                                            Some(format!(
+                                                "The content is in git on the mirror — restore a \
+                                                 file with:  git -C {} show {}:<path> > <path>",
+                                                mirror_dir(project_id).display(),
+                                                &src_ref.sha[..src_ref.sha.len().min(12)]
+                                            )),
+                                        );
+                                    }
+                                    result.blocked = Some(blocked_detail(&src_ref.name, &stderr));
+                                }
+                                FfRetry::Refused => {
+                                    result.blocked = Some(blocked_detail(&src_ref.name, &stderr));
+                                }
+                            }
+                        }
+                        Err(e) => {
+                            result.blocked = Some(format!("'{}' merge failed: {e}", src_ref.name))
+                        }
+                    }
+                } else {
+                    let _ = dst_peer.run(&[
+                        "update-ref",
+                        &format!("refs/heads/{}", src_ref.name),
+                        &src_ref.sha,
+                        dst_sha.unwrap(),
+                    ]);
+                    result.applied += 1;
+                }
+            }
+            RefAction::Diverged => {
+                if force {
+                    force_reset_branch(&dst_peer, &src_ref.name, &src_ref.sha, dst_sha.unwrap(), is_head, ts);
+                    result.applied += 1;
+                } else {
+                    result.diverged.push(src_ref.name.clone());
+                }
+            }
+        }
+        // If any arm above moved this branch's tip on the dest (`result.applied`
+        // rose), record the move so its file delta is counted below. `dst_sha`
+        // is `None` for a fresh create — its whole tree is the delta.
+        if result.applied > applied_before {
+            applied_moves.push((dst_sha.map(str::to_string), src_ref.sha.clone()));
+        }
+
+        // Park (or clear) the peer's tip so a divergence can be resolved with plain git
+        // in a terminal rather than only by picking a winner (#28p D8).
+        let peer_ref = peer_ref_name(&src_ref.name);
+        match peer_ref_op(action, force) {
+            PeerRefOp::Set => {
+                let _ = dst_peer.run(&["update-ref", &peer_ref, &src_ref.sha]);
+            }
+            PeerRefOp::Delete => {
+                let _ = dst_peer.run(&["update-ref", "-d", &peer_ref]);
+            }
+        }
+    }
+
+    // Tags: create missing ones; a same-name/different-sha tag is a conflict we
+    // surface (and, under a resolution, force-move after a backup — never otherwise).
+    for src_tag in &source.tags {
+        match sha_of(dest, RefKind::Tag, &src_tag.name) {
+            None => {
+                let _ = dst_peer.run(&[
+                    "update-ref",
+                    &format!("refs/tags/{}", src_tag.name),
+                    &src_tag.sha,
+                ]);
+                result.applied += 1;
+            }
+            Some(d) if d != src_tag.sha => {
+                if force {
+                    let backup = backup_ref_name(&format!("tags/{}", src_tag.name), ts);
+                    let _ = dst_peer.run(&["update-ref", &backup, d]);
+                    let _ = dst_peer.run(&[
+                        "update-ref",
+                        &format!("refs/tags/{}", src_tag.name),
+                        &src_tag.sha,
+                    ]);
+                    result.applied += 1;
+                } else {
+                    result.diverged.push(format!("tag:{}", src_tag.name));
+                }
+            }
+            Some(_) => {}
+        }
+    }
+
+    // 5. #28q: if the mirror's HEAD moved above, say what that cost the working tree.
+    //    Scoped to this apply, so a caller that runs a checkout of its own around it
+    //    (`checkout_lockstep`) audits that separately and neither reports the other's.
+    if let Some(before) = &local_head_before {
+        audit_local_head_move(
+            project_id,
+            before,
+            if force {
+                "Use-remote resolve (reset --hard on the mirror)"
+            } else {
+                "fast-forward from the host"
+            },
+        );
+    }
+
+    // 6. Cleanup: drop the incoming namespace + bundle files on both ends.
+    cleanup_incoming(&dst_peer);
+    cleanup_bundles(pool, project_id, spec, &src_peer, &dst_peer, to_remote).await;
+
+    // 7. Count the tracked files these applied moves carried into the "files
+    //    synced" metric. Lockstep moves the whole tracked tree as one bundle, so
+    //    without this the metric only reflected byte-sync and read 0 after a
+    //    lockstep seed (e.g. extend-to-remote). Direction follows the transfer:
+    //    `to_remote` is an upload, a pull is a download. Runs on the dest (the
+    //    side whose refs just moved), after apply, so the diffs resolve.
+    if !applied_moves.is_empty() {
+        let files = files_changed_by_moves(&dst_peer, &applied_moves) as u64;
+        if files > 0 {
+            if to_remote {
+                net_usage::record_files(project_id, 0, files);
+            } else {
+                net_usage::record_files(project_id, files, 0);
+            }
+        }
+    }
+
+    Ok(result)
+}
+
+#[derive(Default)]
+struct TransferResult {
+    applied: usize,
+    diverged: Vec<String>,
+    /// What git said when it refused a needed fast-forward, already composed into a
+    /// user-facing sentence (#28p D2 — this used to be a bare `bool` that always
+    /// rendered as "a peer has uncommitted changes", which was usually a lie).
+    blocked: Option<String>,
+}
+
+/// `git merge-base --is-ancestor <a> <b>` → true iff exit 0 (a is an ancestor of b).
+fn is_ancestor(peer: &Peer, a: &str, b: &str) -> bool {
+    peer.run(&["merge-base", "--is-ancestor", a, b])
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// The `(dest_is_ancestor_of_source, source_is_ancestor_of_dest)` bits for every
+/// `(dest_sha, source_sha)` pair, in one SSH round trip when the dest is remote
+/// (#28p D5 — this was `2·N` round trips, per direction, every 12 s). Falls back to
+/// per-pair `merge-base` calls for a local dest, for non-hex input, or whenever the
+/// batched output doesn't line up with what we asked — a misaligned bit would
+/// misclassify a divergence, so an unverifiable answer is never used.
+fn ancestry_map(peer: &Peer, pairs: &[(String, String)]) -> Vec<(bool, bool)> {
+    if pairs.is_empty() {
+        return Vec::new();
+    }
+    if let Peer::Remote(spec) = peer {
+        let all_hex = pairs
+            .iter()
+            .all(|(a, b)| is_hex_sha(a) && is_hex_sha(b));
+        if all_hex {
+            if let Ok(out) = ssh_exec::run_remote_script(spec, &ancestry_script(pairs)) {
+                if let Some(v) =
+                    parse_ancestry_block(&String::from_utf8_lossy(&out.stdout), pairs.len())
+                {
+                    return v;
+                }
+            }
+        }
+    }
+    pairs
+        .iter()
+        .map(|(d, s)| (is_ancestor(peer, d, s), is_ancestor(peer, s, d)))
+        .collect()
+}
+
+/// Recover the fast-forward git just refused, when — and only when — every untracked
+/// file in its way is either **byte-identical to the blob the incoming commit would
+/// write**, or provably disposable **stale byte-sync residue** (#28p D1 layer 2, and
+/// case #12 in `docs/git_lockstep_case_matrix.md`).
+///
+/// The identical case is a byte-sync that outran its commit: the content is already on
+/// the peer, just untracked, so `merge --ff-only` balks (it refuses even for identical
+/// content) while the commit that owns those bytes never crosses. It is also what a
+/// project that byte-synced *before* lockstep was ever enabled looks like on its first
+/// reconcile.
+///
+/// The residue case is #12: a file byte-synced while still untracked, then edited and
+/// committed — `drop_tracked` (D1) stops byte-sync from ever delivering the newer
+/// content once the path becomes tracked, so the peer is stuck holding the *older*
+/// byte-synced copy, which now differs from the incoming commit. `stale_residue` names
+/// exactly the paths proven (by the caller, against the sync manifest) to be that old
+/// copy and nothing else.
+///
+/// Identity is established with git itself, on the dest: `hash-object` of the working
+/// file vs `rev-parse <sha>:<path>` of the incoming blob. All-or-nothing — one file that
+/// is neither provably identical nor provably stale residue, and nothing is touched,
+/// because it is real unsynced work.
+fn retry_ff_clearing_identical(
+    dst_peer: &Peer,
+    src_sha: &str,
+    stderr: &str,
+    stale_residue: &HashSet<String>,
+) -> FfRetry {
+    let paths = parse_untracked_overwrite_paths(stderr);
+    if paths.is_empty() {
+        return FfRetry::Refused;
+    }
+    if !paths
+        .iter()
+        .all(|p| blob_matches_worktree(dst_peer, src_sha, p) || stale_residue.contains(p))
+    {
+        return FfRetry::Refused;
+    }
+    for p in &paths {
+        // `:(literal)` so a path with glob metacharacters (`*`, `[`, `?`) is matched as
+        // itself and can never widen into a pathspec that removes more than it names.
+        let _ = dst_peer.run(&["clean", "-f", "-x", "--", &format!(":(literal){p}")]);
+    }
+    let landed = dst_peer
+        .run(&["merge", "--ff-only", src_sha])
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if landed {
+        FfRetry::Cleared(paths)
+    } else {
+        FfRetry::ClearedButFailed(paths)
+    }
+}
+
+/// What a cleared-fast-forward retry actually did. The two cleared variants used to be
+/// one `false`/`true` bool, which is precisely the distinction #28q needs: the retry
+/// *deletes untracked files* to get the fast-forward through, and whether those files
+/// come back depends on whether the fast-forward then landed.
+enum FfRetry {
+    /// A colliding file was neither provably identical nor provably stale residue, so
+    /// nothing was touched — it is real unsynced work and the ff stays blocked.
+    Refused,
+    /// The named paths were cleaned and the fast-forward landed, so git rewrote each one
+    /// with the incoming commit's blob. For an identical file that is byte-for-byte what
+    /// was there; for stale byte-sync residue it is the newer, committed content — the
+    /// older copy is gone.
+    Cleared(Vec<String>),
+    /// The named paths were cleaned and the fast-forward *still* failed: they are gone
+    /// and nothing rewrote them. The one path here that leaves the mirror short a file.
+    ClearedButFailed(Vec<String>),
+}
+
+/// Whether the dest's on-disk `path` already holds exactly the bytes `<sha>:<path>`
+/// would write. Compared as git object names so nothing has to be read over the wire:
+/// `hash-object` applies the same filters (CRLF/clean) git would, so this is the blob
+/// the file *would* become — an equal name means checkout is a no-op for that file.
+fn blob_matches_worktree(peer: &Peer, sha: &str, path: &str) -> bool {
+    let incoming = peer
+        .run(&["rev-parse", "--verify", "--quiet", &format!("{sha}:{path}")])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .unwrap_or_default();
+    if incoming.is_empty() {
+        return false;
+    }
+    let on_disk = peer
+        .run(&["hash-object", "--", path])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .unwrap_or_default();
+    !on_disk.is_empty() && on_disk == incoming
+}
+
+/// Which of a blocked ff's colliding untracked paths are provably disposable
+/// **stale byte-sync residue** rather than real, independent work on the dest (case
+/// #12: `docs/git_lockstep_case_matrix.md`). A path qualifies when the sync manifest
+/// holds a base for it (byte-sync touched it before it became tracked — the scope
+/// this is meant to cover, kept as a cheap pre-filter) AND its current content is
+/// already a git object `dst_peer`'s own store knows about (#28p D10:
+/// [`object_already_known`]) — proof by content, not by a stat heuristic.
+///
+/// The previous check instead compared the dest's current size+mtime against the
+/// manifest's recorded base, on the theory that an unchanged stat means nothing has
+/// written to the path since byte-sync last put its content there. But a same-size,
+/// same-mtime *different* file (clock skew, a tool that preserves mtimes on copy)
+/// satisfies that heuristic despite differing content — and the caller **deletes**
+/// the file on this verdict, with no backup possible for something that was never a
+/// git object. Proving the content is already a git-known blob removes that gap:
+/// real independent work was never committed or fetched anywhere, so it can never
+/// pass this check by accident.
+async fn stale_byte_sync_residue(
+    manifest: &SyncManifestState,
+    project_id: &str,
+    dst_peer: &Peer,
+    paths: &[String],
+) -> HashSet<String> {
+    let mut out = HashSet::new();
+    if paths.is_empty() {
+        return out;
+    }
+    let candidates: Vec<String> = {
+        let mut g = manifest.lock().await;
+        let m = remote_sync::ensure_loaded(&mut g, project_id);
+        paths.iter().filter(|p| m.contains_key(p.as_str())).cloned().collect()
+    };
+    for p in candidates {
+        if object_already_known(dst_peer, &p) {
+            out.insert(p);
+        }
+    }
+    out
+}
+
+/// Whether the on-disk bytes at `path` (as `git hash-object` would name them) are
+/// already an object `peer`'s own store has — i.e. some commit it has ever held, or
+/// the incoming fetch just deposited, wrote exactly this content at some point
+/// (#28p D10). `git cat-file -e` checks object *existence*, not reachability from any
+/// ref, so this is true for an object the bundle fetch just brought into
+/// `refs/eldrun/incoming/*` even before any ref points at it.
+fn object_already_known(peer: &Peer, path: &str) -> bool {
+    let Some(hash) = peer
+        .run(&["hash-object", "--", path])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .filter(|s| !s.is_empty())
+    else {
+        return false;
+    };
+    peer.run(&["cat-file", "-e", &hash])
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// Drop the sync-manifest bases for paths a cleared ff retry just handed to lockstep
+/// (they are now git-tracked, `drop_tracked` excludes them from byte-sync going
+/// forward, so a lingering base would otherwise sit inert until the path were ever
+/// untracked again). Best-effort, mirrors the removal `restamp_after_checkout` does
+/// for a checkout-deleted tracked file.
+async fn forget_synced_paths(manifest: &SyncManifestState, project_id: &str, paths: &[String]) {
+    if paths.is_empty() {
+        return;
+    }
+    let mut g = manifest.lock().await;
+    let m = remote_sync::ensure_loaded(&mut g, project_id);
+    for p in paths {
+        m.remove(p);
+    }
+    let _ = remote_sync::save_manifest(project_id, m);
+}
+
+// ── Local-loss audit (#28q) ─────────────────────────────────────────────────
+//
+// Every lockstep write that moves the LOCAL mirror's HEAD materializes in its working
+// tree, and a tracked file the incoming commit no longer carries is *deleted* there —
+// by a fast-forward, by a `reset --hard`, by a checkout. That is ordinary git, it is
+// recoverable from git, and it is also exactly how a file the user was looking at
+// vanishes from the mirror during a background pass they never triggered. The audit
+// below is what makes it say so (`services::local_loss`).
+//
+// Each auditor is scoped to ONE mutation and reads the mirror's HEAD itself, before and
+// after. Two consequences worth stating, because they are what keep the audit honest:
+// an op that failed never moved HEAD, so it records nothing (the audit observes, it
+// does not predict); and a nested call that has already moved HEAD sees `from == to`,
+// so an outer op and the reconcile it runs can never both report the same deletion.
+
+/// The mirror's current HEAD sha, or `None` when it is unborn / not a repo.
+fn local_head_sha(project_id: &str) -> Option<String> {
+    Peer::Local(mirror_dir(project_id))
+        .run(&["rev-parse", "--verify", "--quiet", "HEAD"])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .filter(|s| !s.is_empty())
+}
+
+/// The tracked paths present at `from` and gone at `to` — i.e. what checking `to` out
+/// over `from` deletes from the working tree.
+fn deleted_between(peer: &Peer, from: &str, to: &str) -> Vec<String> {
+    peer.run(&["diff", "--name-only", "--diff-filter=D", from, to])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| {
+            String::from_utf8_lossy(&o.stdout)
+                .lines()
+                .map(|l| l.trim().to_string())
+                .filter(|l| !l.is_empty())
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+/// Record the tracked files that a lockstep op — which has just moved the mirror's HEAD
+/// away from `from_sha` — deleted from the local working tree. A no-op when HEAD did not
+/// actually move (the op failed, or was a ref-only update on a branch that isn't checked
+/// out) or when it dropped no file.
+fn audit_local_head_move(project_id: &str, from_sha: &str, op: &str) {
+    if from_sha.is_empty() {
+        return;
+    }
+    let Some(to_sha) = local_head_sha(project_id) else {
+        return;
+    };
+    if to_sha == from_sha {
+        return;
+    }
+    let local = Peer::Local(mirror_dir(project_id));
+    let gone = deleted_between(&local, from_sha, &to_sha);
+    let mirror = mirror_dir(project_id);
+    local_loss::record_paths(
+        project_id,
+        local_loss::LossSource::Git,
+        local_loss::LossKind::Deleted,
+        op,
+        gone,
+        Some(format!(
+            "Still in git — restore a file with:  git -C {} checkout {} -- <path>",
+            mirror.display(),
+            &from_sha[..from_sha.len().min(12)]
+        )),
+    );
+}
+
+/// Force-move `dest`'s `branch` from `dst_sha` to the authority's `src_sha` during a
+/// resolution, after saving the overwritten tip to a timestamped `refs/eldrun/backup/*`
+/// safety ref so nothing is lost. When the branch is the dest's checked-out HEAD, a
+/// `reset --hard` moves the ref *and* the working tree; otherwise the ref is force-set
+/// with `update-ref`'s old-value guard. Best-effort (each step ignores its own error;
+/// a stale backup is harmless).
+fn force_reset_branch(
+    dst_peer: &Peer,
+    branch: &str,
+    src_sha: &str,
+    dst_sha: &str,
+    is_head: bool,
+    ts: u64,
+) {
+    let backup = backup_ref_name(branch, ts);
+    let _ = dst_peer.run(&["update-ref", &backup, dst_sha]);
+    if is_head {
+        let _ = dst_peer.run(&["reset", "--hard", src_sha]);
+    } else {
+        let _ = dst_peer.run(&[
+            "update-ref",
+            &format!("refs/heads/{branch}"),
+            src_sha,
+            dst_sha,
+        ]);
+    }
+}
+
+/// Copy the bundle file between the two machines over the pooled SFTP session.
+/// Streamed in bounded chunks (#28n Phase 3) so an initial-pairing bundle carrying
+/// a project's whole history never has to fit in memory on either end.
+async fn move_bundle(
+    pool: &RemotePoolState,
+    project_id: &str,
+    to_remote: bool,
+    src_bundle: &str,
+    dst_bundle: &str,
+) -> Result<(), String> {
+    let sftp = crate::services::remote::pooled_sftp(pool, project_id)
+        .await
+        .ok_or("remote not connected")?;
+    if to_remote {
+        sftp::upload_file_streaming_on(&sftp, Path::new(src_bundle), dst_bundle).await
+    } else {
+        sftp::download_file_streaming_on(&sftp, src_bundle, Path::new(dst_bundle)).await
+    }
+}
+
+/// Delete the `refs/eldrun/incoming/*` tracking refs on a peer after applying.
+fn cleanup_incoming(peer: &Peer) {
+    // `for-each-ref` then delete each; best-effort.
+    if let Ok(out) = peer.run(&[
+        "for-each-ref",
+        "--format=%(refname)",
+        "refs/eldrun/incoming",
+    ]) {
+        for line in String::from_utf8_lossy(&out.stdout).lines() {
+            let r = line.trim();
+            if !r.is_empty() {
+                let _ = peer.run(&["update-ref", "-d", r]);
+            }
+        }
+    }
+}
+
+async fn cleanup_bundles(
+    pool: &RemotePoolState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    _src_peer: &Peer,
+    _dst_peer: &Peer,
+    _to_remote: bool,
+) {
+    let _ = std::fs::remove_file(local_bundle_path(project_id));
+    if let Some(sftp) = crate::services::remote::pooled_sftp(pool, project_id).await {
+        let _ = sftp::remove_file_on(&sftp, &remote_bundle_path(spec)).await;
+    }
+}
+
+// ── Initial pairing ─────────────────────────────────────────────────────────
+
+/// Bring an unpaired side up: `git init` the empty peer, transfer every ref from the
+/// `source` (authority) peer, then position the new HEAD + working tree to match the
+/// source (#28n Phase 3). `source_is_local` picks the direction — the empty side is
+/// always the peer that is *not* the source. Files already physically present on the
+/// empty side (selective/auto file-sync mirrored them) become the tracked tree; a
+/// `reset --hard`/detached checkout materializes any that git manages but are missing,
+/// and untracked files are left untouched (they stay file-sync's domain).
+async fn init_pairing(
+    pool: &RemotePoolState,
+    manifest: &SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    source_is_local: bool,
+    source: &PeerSnapshot,
+) -> Result<(), String> {
+    let (dest_peer, to_remote) = if source_is_local {
+        (Peer::Remote(spec.clone()), true)
+    } else {
+        (Peer::Local(mirror_dir(project_id)), false)
+    };
+    let dest_label = if source_is_local { "remote host" } else { "local mirror" };
+    if let Peer::Local(dir) = &dest_peer {
+        let _ = std::fs::create_dir_all(dir);
+    }
+
+    // Defense-in-depth: init_pairing's contract is that `dest` is the *empty* side.
+    // If a misprobe/race routed us here with a dest that actually already holds
+    // commits, back every existing branch tip up to `refs/eldrun/backup/*` BEFORE the
+    // `reset --hard` below can move them — so an unexpected non-empty dest is always
+    // recoverable rather than silently wiped. Truly-empty dests probe clean and skip.
+    let pre = probe(&dest_peer);
+    if !pre.branches.is_empty() {
+        let ts = now_secs();
+        for b in &pre.branches {
+            let backup = backup_ref_name(&b.name, ts);
+            let _ = dest_peer.run(&["update-ref", &backup, &b.sha]);
+        }
+    }
+
+    // The host root must exist before any remote git can run: every remote command is
+    // `cd '<remote_path>' && git …`, so a missing directory fails ALL of them — including
+    // the `git init` below. Eldrun only `mkdir -p`s the root at create/extend time, which
+    // leaves a host whose directory is later removed (or whose creation was refused back
+    // then — it is best-effort there) permanently unpairable. Idempotent, so re-pairing an
+    // existing host costs one cheap round trip.
+    if source_is_local {
+        crate::services::ssh_exec::remote_mkdir_p(spec)
+            .map_err(|e| format!("could not create '{}' on the host: {e}", spec.remote_path))?;
+    }
+
+    // `git init` the empty side. Idempotent, and deliberately so: the dest may already be
+    // a repo here — a bare, never-checked-out one left behind by an earlier seed that died
+    // after this very step. Re-running init on it is a no-op and the pairing carries on.
+    let out = dest_peer.run(&["init"])?;
+    if !out.status.success() {
+        return Err(format!(
+            "git init on {dest_label} failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        ));
+    }
+
+    // Transfer every ref from the authority into the freshly-init'd (empty) dest;
+    // with no dest shas this is a full bundle and every branch/tag is a create.
+    //
+    // A failure here is fatal to the pairing and must NOT fall through to the checkout
+    // below: `reset --hard` would be aimed at a sha whose objects never arrived, and the
+    // `git init` above has *already run* — so swallowing this (as `let _ =` used to) left
+    // a dest that is a repo, holds no commit, and has an empty working tree, while
+    // reporting `Ok`. That is precisely the half-seeded state `is_seeded` now exists to
+    // recognize; reporting it means the user sees why, and the next pass retries the seed
+    // instead of settling into a permanent head mismatch.
+    let dest = probe(&dest_peer);
+    transfer_and_apply(pool, manifest, project_id, spec, to_remote, source, &dest, false).await?;
+
+    // Position HEAD + populate the working tree to match the source's HEAD. The
+    // `reset --hard` here is only reached once `pairing_conflicts` has confirmed that
+    // nothing it would clobber differs from what it is about to write (#28p D3).
+    //
+    // This is the ONLY place lockstep writes a dest's working tree at pairing time, so a
+    // silent failure here is the difference between a seeded peer and an empty directory
+    // with a `.git` in it. Checked, not swallowed.
+    let checked = |what: &str, out: Output| -> Result<(), String> {
+        if out.status.success() {
+            return Ok(());
+        }
+        Err(format!(
+            "{what} on the {dest_label} failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        ))
+    };
+    match &source.head {
+        Some(HeadRef::Branch { name, sha }) => {
+            checked(
+                &format!("pointing HEAD at '{name}'"),
+                dest_peer.run(&["symbolic-ref", "HEAD", &format!("refs/heads/{name}")])?,
+            )?;
+            checked(
+                &format!("checking out '{name}'"),
+                dest_peer.run(&["reset", "--hard", sha])?,
+            )?;
+        }
+        Some(HeadRef::Detached { sha }) => {
+            checked("checking out the detached HEAD", dest_peer.run(&["checkout", sha])?)?;
+        }
+        // Unborn/None source → nothing committed yet; leave the empty repo unborn too.
+        // Unreachable via `pair_plan` (an unseeded side is never the source), kept as a
+        // total match rather than a panic.
+        _ => {}
+    }
+
+    // Give the fresh dest the source's `origin` URL (#28p D7). A bundle carries no
+    // remotes, so without this a `git push` from a local agent tab in the mirror fails
+    // with "no configured push destination" — a bad surprise in the one place agents
+    // actually work.
+    let source_peer = if source_is_local {
+        Peer::Local(mirror_dir(project_id))
+    } else {
+        Peer::Remote(spec.clone())
+    };
+    let origin_url = |p: &Peer| -> Option<String> {
+        p.run(&["config", "--get", "remote.origin.url"])
+            .ok()
+            .filter(|o| o.status.success())
+            .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+            .filter(|s| !s.is_empty())
+    };
+    let src_url = origin_url(&source_peer);
+    let dst_url = origin_url(&dest_peer);
+    if let Some(url) = should_propagate_origin(src_url.as_deref(), dst_url.as_deref()) {
+        let _ = dest_peer.run(&["remote", "add", "origin", &url]);
+    }
+    Ok(())
+}
+
+/// The files an initial pairing would destroy (#28p D3): paths that exist on the
+/// not-yet-a-repo dest **and differ** from the source's tracked content at HEAD.
+///
+/// Why this exists: extend-local runs `git init` + `reset --hard` on the host, and
+/// `reset --hard` silently clobbers colliding untracked files. The pre-backup in
+/// `init_pairing` saves *refs* — but a host that isn't a repo yet has none, which is
+/// precisely the situation. So the check has to happen on *files*, before any of it.
+///
+/// The common case is deliberately allowed: when file-sync already mirrored the tree,
+/// every collision is byte-identical and this returns empty — that is the intended
+/// "adopt the mirrored files as the tracked tree" path.
+async fn pairing_conflicts(
+    pool: &RemotePoolState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    source_is_local: bool,
+) -> Vec<String> {
+    let (source_peer, dest_peer) = if source_is_local {
+        (Peer::Local(mirror_dir(project_id)), Peer::Remote(spec.clone()))
+    } else {
+        (Peer::Remote(spec.clone()), Peer::Local(mirror_dir(project_id)))
+    };
+
+    // What the source would write: every tracked blob at HEAD, with its size + sha.
+    let source: HashMap<String, Fingerprint> = source_peer
+        .run(&["ls-tree", "-r", "-l", "-z", "HEAD"])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| parse_ls_tree_long(&o.stdout))
+        .unwrap_or_default();
+    if source.is_empty() {
+        return Vec::new(); // unborn source → nothing to overwrite with
+    }
+
+    // What is already on the dest, restricted to paths the source would touch.
+    let mut dest: HashMap<String, Fingerprint> = HashMap::new();
+    if source_is_local {
+        let Some(sftp) = crate::services::remote::pooled_sftp(pool, project_id).await else {
+            return Vec::new(); // no pool → reconcile's connectivity gate handles it
+        };
+        match remote_sync::walk_host_files(&sftp, &spec.remote_path, "").await {
+            Ok(files) => {
+                for f in files {
+                    if source.contains_key(&f.rel) {
+                        dest.insert(f.rel, Fingerprint { size: f.size, hash: None });
+                    }
+                }
+            }
+            Err(_) => return Vec::new(),
+        }
+    } else {
+        let Ok(files) = remote_sync::walk_mirror_files(project_id, "") else {
+            return Vec::new();
+        };
+        for rel in files {
+            if !source.contains_key(&rel) {
+                continue;
+            }
+            let (size, _) =
+                remote_sync::local_size_mtime(std::fs::metadata(mirror_local_path(project_id, &rel)).ok());
+            dest.insert(rel, Fingerprint { size, hash: None });
+        }
+    }
+
+    // Only same-size collisions can possibly be identical, so only those are hashed.
+    let to_hash: Vec<String> = dest
+        .iter()
+        .filter(|(p, d)| source.get(*p).map(|s| s.size == d.size).unwrap_or(false))
+        .map(|(p, _)| p.clone())
+        .collect();
+    for (path, hash) in hash_objects(&dest_peer, &to_hash) {
+        if let Some(e) = dest.get_mut(&path) {
+            e.hash = Some(hash);
+        }
+    }
+
+    pairing_collisions(&source, &dest)
+}
+
+/// Git blob names of files on a peer, batched (`git hash-object` works outside a repo,
+/// which is what lets this run on the not-yet-`init`ed pairing dest). A chunk whose
+/// output doesn't line up one-to-one with its input is dropped rather than
+/// mis-assigned: the missing hashes then read as "not provably identical", which
+/// [`pairing_collisions`] treats as a conflict — the safe direction.
+fn hash_objects(peer: &Peer, paths: &[String]) -> HashMap<String, String> {
+    let mut out = HashMap::new();
+    for chunk in paths.chunks(100) {
+        let mut args: Vec<String> = vec!["hash-object".to_string(), "--".to_string()];
+        args.extend(chunk.iter().cloned());
+        let argv: Vec<&str> = args.iter().map(String::as_str).collect();
+        let Ok(o) = peer.run(&argv) else { continue };
+        if !o.status.success() {
+            continue;
+        }
+        let text = String::from_utf8_lossy(&o.stdout);
+        let lines: Vec<&str> = text.lines().map(str::trim).filter(|l| !l.is_empty()).collect();
+        if lines.len() != chunk.len() {
+            continue;
+        }
+        for (p, h) in chunk.iter().zip(lines) {
+            out.insert(p.clone(), h.to_string());
+        }
+    }
+    out
+}
+
+// ── Force-reset collisions (#28p D9) ────────────────────────────────────────
+
+/// The untracked files on `dest_peer` a force-reset of its checked-out branch to
+/// `target_sha` would silently clobber: paths `target_sha`'s tree holds that also
+/// exist, untracked, on `dest_peer` and differ in content.
+///
+/// This is the same `reset --hard` clobber behaviour (see the module doc comment)
+/// `init_pairing` was hardened against for a not-yet-a-repo dest (D3) — but
+/// `resolve`'s and `restore_backup`'s force-reset of an *existing* repo's checked-out
+/// branch had no equivalent guard. A path git never tracked is invisible to the
+/// `refs/eldrun/backup/*` safety net (that only saves refs), so without this check it
+/// is destroyed with no way back. Conservative like `pairing_collisions`: an
+/// unprovable hash counts as a difference. Reuses `hash_objects`, so it costs no new
+/// primitive.
+fn reset_collisions(source_peer: &Peer, dest_peer: &Peer, target_sha: &str) -> Vec<String> {
+    let target: HashMap<String, Fingerprint> = source_peer
+        .run(&["ls-tree", "-r", "-l", "-z", target_sha])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| parse_ls_tree_long(&o.stdout))
+        .unwrap_or_default();
+    if target.is_empty() {
+        return Vec::new();
+    }
+
+    let listed = match dest_peer.run(&["ls-files", "--others", "-z"]) {
+        Ok(o) if o.status.success() => o.stdout,
+        _ => return Vec::new(),
+    };
+    let candidates: Vec<String> = listed
+        .split(|&b| b == 0)
+        .filter(|s| !s.is_empty())
+        .map(|s| String::from_utf8_lossy(s).replace('\\', "/"))
+        .filter(|p| target.contains_key(p))
+        .collect();
+    if candidates.is_empty() {
+        return Vec::new();
+    }
+
+    let hashes = hash_objects(dest_peer, &candidates);
+    let mut out: Vec<String> = candidates
+        .into_iter()
+        .filter(|p| match (target[p].hash.as_deref(), hashes.get(p).map(String::as_str)) {
+            (Some(a), Some(b)) => a != b,
+            _ => true, // unprovable → treat as a difference, the safe direction
+        })
+        .collect();
+    out.sort();
+    out
+}
+
+// ── Reconcile + status ──────────────────────────────────────────────────────
+
+/// Probe both peers, transfer + fast-forward in both directions, and compute the new
+/// [`GitPeerState`]. Diverged branches / a dirty peer blocking a needed fast-forward
+/// → `Desynchronized` (surfaced for Use-local/Use-remote resolution). Persists +
+/// returns the state. `enabled` is preserved from the prior persisted state.
+///
+/// When exactly one side is a git repo, this performs **initial pairing** (#28n
+/// Phase 3): the repo side is the authority and the empty side is `git init`-ed and
+/// populated from it (remote import → mirror from remote; extend-local → remote from
+/// local). If *both* already exist and diverge, no side is guessed — that is the
+/// normal diverged→`Desynchronized` path, resolved by the explicit authority choice.
+pub async fn reconcile(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+) -> GitPeerState {
+    reconcile_with(pool, manifest, project_id, spec, ReconcileOpts::default()).await
+}
+
+/// Knobs the two user-driven entry points need; a background pass uses the defaults.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct ReconcileOpts {
+    /// Skip the D5 early-out. A manual "Sync now"/Retry means "actually look", and a
+    /// user usually clicks it *after* clearing a blocker — which moves no ref, so a
+    /// signature-based cache would answer from a stale red state.
+    pub forced: bool,
+    /// The user has seen the conflicting files named and confirmed the overwrite
+    /// (#28p D3). Only ever set by `git_peer_pair_confirm`.
+    pub allow_pair_overwrite: bool,
+    /// A coordinated checkout is *in flight*: it reconciles refs first and only then
+    /// checks the peer out, so the two HEADs are expected to disagree for the duration.
+    /// Suppresses the [`head_mismatch`] rule, which otherwise fires on that entirely
+    /// normal intermediate state and leaves its stale red behind on the finished
+    /// checkout. Only `checkout_lockstep`'s own reconcile sets it.
+    pub mid_checkout: bool,
+}
+
+async fn reconcile_with(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    opts: ReconcileOpts,
+) -> GitPeerState {
+    let prior = load_state(project_id);
+
+    // #28p D4: with no pooled SSH session, every remote git command would exit non-zero
+    // — which `probe` reads as "the host is a clean, empty side", which pairs into it,
+    // which fails, which computes to Synchronized. A green pill for a host we cannot
+    // see. So: no connection, no claim, no writes.
+    if !connected(pool, project_id).await {
+        return persist(project_id, disconnected_state(&prior));
+    }
+
+    let local = probe(&Peer::Local(mirror_dir(project_id)));
+    let remote = probe(&Peer::Remote(spec.clone()));
+    let (local_sig, remote_sig) = (refs_signature(&local), refs_signature(&remote));
+    let plan = pair_plan(&local, &remote);
+
+    // #28p D5: nothing moved on either side and we were green → re-emit, skipping the
+    // bundle round trip entirely. This is what stops a bare `git add` (which trips the
+    // `.git` watcher without moving a ref) from costing a full network pass.
+    if can_early_out(
+        &prior,
+        &local_sig,
+        &remote_sig,
+        matches!(plan, PairPlan::Sync),
+        opts.forced,
+    ) {
+        return persist(
+            project_id,
+            GitPeerState {
+                last_sync_ts: Some(now_secs()),
+                ..prior
+            },
+        );
+    }
+
+    let mut diverged: Vec<String> = Vec::new();
+    let mut blocked: Option<String> = None;
+    // Set when we deliberately refuse to auto-pair because the side that would be
+    // `git init`+`reset --hard`ed couldn't be read — forces a Desynchronized state
+    // instead of a wipe (checked first in the status decision).
+    let mut pairing_blocked: Option<String> = None;
+    let mut pairing_conflict: Option<PairingConflict> = None;
+
+    if matches!(plan, PairPlan::Sync) {
+        // Local → remote, then remote → local (each catches the side that is ahead).
+        // A leg that *errors* (bundle unreadable, SFTP transfer died) must not be
+        // discarded: dropping it leaves `diverged`/`blocked` empty, which computes to
+        // Synchronized — claiming green about work we never managed to do, the same
+        // misreport D4 fixed for a cold pool.
+        match transfer_and_apply(pool, manifest, project_id, spec, true, &local, &remote, false)
+            .await
+        {
+            Ok(r) => {
+                diverged.extend(r.diverged);
+                blocked = blocked.or(r.blocked);
+            }
+            Err(e) => blocked = blocked.or(Some(format!("Sync to the host failed: {e}"))),
+        }
+        // Re-probe the remote so the reverse pass sees any ref we just moved.
+        let remote2 = probe(&Peer::Remote(spec.clone()));
+        match transfer_and_apply(pool, manifest, project_id, spec, false, &remote2, &local, false)
+            .await
+        {
+            Ok(r) => {
+                for d in r.diverged {
+                    if !diverged.contains(&d) {
+                        diverged.push(d);
+                    }
+                }
+                blocked = blocked.or(r.blocked);
+            }
+            Err(e) => blocked = blocked.or(Some(format!("Sync from the host failed: {e}"))),
+        }
+    } else if let PairPlan::Pair { source_is_local } = plan {
+        // Exactly one side holds a commit → initialize the other from it (initial
+        // pairing). NB "holds a commit", not "is a repo": a host left as a bare
+        // `git init` by a seed that died mid-way is an unpaired dest, not a peer, and
+        // this is the branch that finishes it (see `is_seeded`).
+        // The dest is the side we would `git init` + `reset --hard`. If *its* probe
+        // errored (the tree is there, but git couldn't confirm what it is), refuse: a
+        // transient git/network failure must never license a wipe of a real repo. This
+        // guard used to protect only the local side — while the remote one, reached
+        // over a flaky link, is by far the likelier to misprobe (#28p D3.4).
+        let dest_probe_error = if source_is_local {
+            remote.probe_error
+        } else {
+            local.probe_error
+        };
+        if dest_probe_error {
+            let side = if source_is_local { "Remote host" } else { "Local mirror" };
+            pairing_blocked = Some(format!(
+                "{side} repository could not be read; refusing to auto-initialize it. \
+                 Retry once git is reachable there."
+            ));
+        } else {
+            let conflicts = if opts.allow_pair_overwrite {
+                // The user confirmed the overwrite (`pair_confirm`), so this no longer
+                // blocks — but it is still the exact list of files pairing is about to
+                // destroy, and when the dest is the mirror they are the user's LOCAL
+                // files. Compute it anyway, purely to record what went (#28q), then
+                // proceed. Only runs on the explicit confirm, never on the hot path.
+                if !source_is_local {
+                    local_loss::record_paths(
+                        project_id,
+                        local_loss::LossSource::Git,
+                        local_loss::LossKind::Overwritten,
+                        "initial pairing with the host (you confirmed the overwrite)",
+                        pairing_conflicts(pool, project_id, spec, source_is_local).await,
+                        None, // never a git object on this side — nothing to restore from
+                    );
+                }
+                Vec::new()
+            } else {
+                pairing_conflicts(pool, project_id, spec, source_is_local).await
+            };
+            if !conflicts.is_empty() {
+                // #28p D3: the empty side holds files that differ from what pairing
+                // would write over them. Name them and stop — `reset --hard` would
+                // destroy them with no backup and no prompt.
+                pairing_conflict = Some(PairingConflict {
+                    source_is_local,
+                    paths: conflicts,
+                });
+            } else {
+                let source = if source_is_local { &local } else { &remote };
+                match init_pairing(pool, manifest, project_id, spec, source_is_local, source).await
+                {
+                    Ok(()) => {
+                        // Pairing just materialized both sides to the same HEAD, so every
+                        // tracked file is byte-identical across host and mirror. Seed the
+                        // selective-sync manifest for them so the file tree shows them green
+                        // (in sync) rather than red (untracked by SFTP sync) — there is
+                        // nothing to transfer. This branch only fires at the pairing moment
+                        // (exactly one side seeded), so it runs once and never re-selects a
+                        // file the user later deselects.
+                        seed_manifest_after_pairing(pool, manifest, project_id, spec).await;
+                    }
+                    // A seed that failed part-way leaves the dest a bare, unseeded repo.
+                    // Say so: it used to report `Ok` and settle into a permanent, baffling
+                    // head mismatch. The dest stays unseeded, so the next pass retries.
+                    Err(e) => pairing_blocked = Some(format!("Initial pairing failed: {e}")),
+                }
+            }
+        }
+    }
+
+    let final_local = probe(&Peer::Local(mirror_dir(project_id)));
+    let final_remote = probe(&Peer::Remote(spec.clone()));
+
+    let (status, detail) = if let Some(msg) = pairing_blocked {
+        // We refused to auto-initialize an unreadable side — report it (must be checked
+        // before the "one side has no repo" branch, which would mask it).
+        (SyncStatus::Desynchronized, Some(msg))
+    } else if let Some(c) = &pairing_conflict {
+        let where_ = if c.source_is_local { "host" } else { "mirror" };
+        let shown: Vec<&str> = c.paths.iter().take(3).map(String::as_str).collect();
+        let more = c.paths.len() - shown.len();
+        let extra = if more > 0 { format!(" (+{more} more)") } else { String::new() };
+        (
+            SyncStatus::Desynchronized,
+            Some(format!(
+                "Pairing would overwrite {} file(s) on the {where_} that differ: {}{extra}",
+                c.paths.len(),
+                shown.join(", ")
+            )),
+        )
+    } else if !final_local.is_repo || !final_remote.is_repo {
+        // Still one side without a repo (source was unborn, or init failed) — nothing
+        // to lock-step yet.
+        (SyncStatus::Synchronized, None)
+    } else if !diverged.is_empty() {
+        (
+            SyncStatus::Desynchronized,
+            Some(format!("Diverged: {}", diverged.join(", "))),
+        )
+    } else if let Some(msg) = blocked {
+        (SyncStatus::Desynchronized, Some(msg))
+    } else if let Some(msg) = (!opts.mid_checkout)
+        .then(|| head_mismatch(&final_local, &final_remote))
+        .flatten()
+    {
+        // Refs agree but the two sides sit on different commits — a half-landed
+        // checkout. Checked last: a real divergence or block is the better story.
+        (SyncStatus::Desynchronized, Some(msg))
+    } else {
+        (SyncStatus::Synchronized, None)
+    };
+
+    // Only a completed, green pass may seed the early-out signatures — otherwise the
+    // next pass could skip the work this one failed to do.
+    let green = status == SyncStatus::Synchronized;
+    let local_sig = green.then(|| refs_signature(&final_local));
+    let remote_sig = green.then(|| refs_signature(&final_remote));
+    persist(
+        project_id,
+        GitPeerState {
+            enabled: prior.enabled,
+            status,
+            detail,
+            local_subject: final_local.head_subject,
+            remote_subject: final_remote.head_subject,
+            local_head: final_local.head,
+            remote_head: final_remote.head,
+            last_sync_ts: Some(now_secs()),
+            pairing_conflict,
+            local_sig,
+            remote_sig,
+        },
+    )
+}
+
+/// Whether the project's pooled SSH/SFTP session is up. The single gate every writing
+/// path checks before it believes anything about the host (#28p D4).
+pub async fn connected(pool: &RemotePoolState, project_id: &str) -> bool {
+    crate::services::remote::pooled_sftp(pool, project_id)
+        .await
+        .is_some()
+}
+
+/// The state to report when the pool is cold (#28p D4). Keeps the last-known heads —
+/// they are the last thing we actually observed — and drops the early-out signatures so
+/// the first pass after reconnecting is a real one. Pure.
+pub fn disconnected_state(prior: &GitPeerState) -> GitPeerState {
+    GitPeerState {
+        status: SyncStatus::Disconnected,
+        detail: Some("Not connected to the remote host".to_string()),
+        local_sig: None,
+        remote_sig: None,
+        ..prior.clone()
+    }
+}
+
+/// Which side an initial pairing would `git init` + `reset --hard`, and whether *its*
+/// probe failed. A dest we could not read is never treated as empty: a transient git or
+/// network failure must not license a wipe (#28p D3.4). This used to guard only the
+/// local mirror — while the remote host, reached over a flaky link, is the far likelier
+/// side to misprobe. Pure.
+pub fn pairing_dest_probe_error(
+    source_is_local: bool,
+    local: &PeerSnapshot,
+    remote: &PeerSnapshot,
+) -> bool {
+    if source_is_local {
+        remote.probe_error
+    } else {
+        local.probe_error
+    }
+}
+
+/// Persist and return a state (every reconcile path ends here).
+fn persist(project_id: &str, state: GitPeerState) -> GitPeerState {
+    let _ = save_state(project_id, &state);
+    state
+}
+
+/// The head sha of a peer, if any (branch or detached).
+fn head_sha(snap: &PeerSnapshot) -> Option<String> {
+    match &snap.head {
+        Some(HeadRef::Branch { sha, .. }) | Some(HeadRef::Detached { sha }) => Some(sha.clone()),
+        _ => None,
+    }
+}
+
+/// Re-stamp the file-sync manifest bases for the tracked files a checkout rewrote
+/// (between `old_sha` and the current HEAD on the local mirror), so the resumed auto
+/// file-sync reads them green instead of as false local edits. Deleted tracked files
+/// drop their manifest entry. Best-effort; needs the pooled SFTP for host stats.
+async fn restamp_after_checkout(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    old_sha: &str,
+) {
+    let local = Peer::Local(mirror_dir(project_id));
+    let new_sha = match head_sha(&probe(&local)) {
+        Some(s) => s,
+        None => return,
+    };
+    if old_sha == new_sha {
+        return;
+    }
+    let changes = local
+        .run(&["diff", "--name-status", old_sha, &new_sha])
+        .map(|o| changed_tracked_paths(&String::from_utf8_lossy(&o.stdout)))
+        .unwrap_or_default();
+    if changes.is_empty() {
+        return;
+    }
+    let sftp = crate::services::remote::pooled_sftp(pool, project_id).await;
+
+    let mut g = manifest.lock().await;
+    let m = remote_sync::ensure_loaded(&mut g, project_id);
+    for ch in changes {
+        if ch.deleted {
+            m.remove(&ch.path);
+            continue;
+        }
+        let local_path = mirror_local_path(project_id, &ch.path);
+        let (ls, lm) = remote_sync::local_size_mtime(std::fs::metadata(&local_path).ok());
+        let (hs, hm) = match &sftp {
+            Some(s) => {
+                let host_abs = remote_sync::join_remote(&spec.remote_path, &ch.path);
+                sftp::metadata_on(s, &host_abs).await.unwrap_or((ls, lm))
+            }
+            None => (ls, lm),
+        };
+        remote_sync::record_pull(m, &ch.path, hs, hm, ls, lm);
+    }
+    let _ = remote_sync::save_manifest(project_id, m);
+}
+
+/// Seed the file-sync manifest for every git-tracked file right after an INITIAL
+/// PAIRING materialized both peers to the same HEAD (so each tracked path is now
+/// byte-identical across host and mirror). Marks each path selected and stamps its
+/// host + local bases, so `compute_state` reads them green (in sync) instead of the
+/// red "not tracked by selective sync" a freshly-extended/imported project would
+/// otherwise show — there is nothing to transfer. This mirrors what
+/// `restamp_after_checkout` does for a checkout, applied to the pairing moment.
+/// Best-effort; needs the pooled SFTP for host stats (falls back to the local base
+/// when the host can't be stat'd, matching `restamp_after_checkout`).
+async fn seed_manifest_after_pairing(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+) {
+    let paths = tracked_paths(project_id);
+    if paths.is_empty() {
+        return;
+    }
+    let sftp = crate::services::remote::pooled_sftp(pool, project_id).await;
+
+    let mut g = manifest.lock().await;
+    let m = remote_sync::ensure_loaded(&mut g, project_id);
+    for rel in paths {
+        let local_path = mirror_local_path(project_id, &rel);
+        let (ls, lm) = remote_sync::local_size_mtime(std::fs::metadata(&local_path).ok());
+        let (hs, hm) = match &sftp {
+            Some(s) => {
+                let host_abs = remote_sync::join_remote(&spec.remote_path, &rel);
+                sftp::metadata_on(s, &host_abs).await.unwrap_or((ls, lm))
+            }
+            None => (ls, lm),
+        };
+        remote_sync::record_pull(m, &rel, hs, hm, ls, lm);
+    }
+    let _ = remote_sync::save_manifest(project_id, m);
+}
+
+/// Coordinated checkout: pause file auto-sync, check the target out on the initiating
+/// side (unless already done), reconcile so the peer has the commits, check the same
+/// target out on the peer (a **guarded** checkout — never `-f`), re-stamp file-sync
+/// bases, and resume. `initiating_side` is `"local"` or `"remote"`.
+pub async fn checkout_lockstep(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    auto: &crate::services::sync_auto::AutoSyncState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    target: &str,
+    initiating_side: &str,
+    already_checked_out: bool,
+) -> Result<GitPeerState, String> {
+    // #28p D4: a checkout writes to both trees; never start one against a host we
+    // cannot reach (the remote half would fail command by command).
+    if !connected(pool, project_id).await {
+        return Err("Not connected to the remote host".to_string());
+    }
+    crate::services::sync_auto::pause(auto, project_id).await;
+    // Guarantee resume even on an early error.
+    let result =
+        checkout_lockstep_inner(pool, manifest, project_id, spec, target, initiating_side, already_checked_out)
+            .await;
+    crate::services::sync_auto::resume(auto, project_id).await;
+    result
+}
+
+async fn checkout_lockstep_inner(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    target: &str,
+    initiating_side: &str,
+    already_checked_out: bool,
+) -> Result<GitPeerState, String> {
+    let local = Peer::Local(mirror_dir(project_id));
+    let remote = Peer::Remote(spec.clone());
+
+    // Old local HEAD (for the post-checkout restamp diff).
+    let old_local_sha = head_sha(&probe(&local)).unwrap_or_default();
+
+    // 1. Check out on the initiating side if the caller hasn't already.
+    if !already_checked_out {
+        let initiating_local = initiating_side != "remote";
+        let init_peer = if initiating_local { &local } else { &remote };
+        let out = init_peer.run(&["checkout", target])?;
+        if !out.status.success() {
+            return Ok(desync_state(
+                project_id,
+                spec,
+                &format!(
+                    "Checkout on {initiating_side} failed: {}",
+                    String::from_utf8_lossy(&out.stderr).trim()
+                ),
+            ));
+        }
+        // #28q: a checkout deletes the tracked files the target commit doesn't carry.
+        // Audited only when Eldrun ran it — `already_checked_out` means the user ran
+        // `git checkout` themselves in a terminal, where git already said so.
+        if initiating_local {
+            audit_local_head_move(project_id, &old_local_sha, &format!("checkout '{target}'"));
+        }
+    }
+
+    // 2. Bring commits/refs into step so the peer has the target commit. The peer's HEAD
+    //    is still on the old target until step 3, so the head-mismatch rule must not fire
+    //    on this deliberately-transient state.
+    let mut state = reconcile_with(
+        pool,
+        manifest,
+        project_id,
+        spec,
+        ReconcileOpts { mid_checkout: true, ..Default::default() },
+    )
+    .await;
+
+    // 3. Guarded checkout on the peer (the side that did NOT initiate). When the peer is
+    //    the mirror, this is the checkout that follows a branch switch made on the host —
+    //    the one the user is least expecting to rewrite their local tree, so #28q audits
+    //    it from the tip as it stands *now* (step 2's fast-forward, if any, already
+    //    reported its own deletions).
+    let peer_is_local = initiating_side == "remote";
+    let peer = if peer_is_local { &local } else { &remote };
+    let peer_name = if peer_is_local { "local" } else { "remote" };
+    let pre_peer_checkout = peer_is_local.then(|| local_head_sha(project_id)).flatten();
+    let out = peer.run(&["checkout", target])?;
+    if let Some(before) = &pre_peer_checkout {
+        audit_local_head_move(
+            project_id,
+            before,
+            &format!("checkout '{target}' (following the host)"),
+        );
+    }
+    if !out.status.success() {
+        state = desync_state(
+            project_id,
+            spec,
+            &format!(
+                "Peer ({peer_name}) checkout blocked (uncommitted changes?): {}",
+                String::from_utf8_lossy(&out.stderr).trim()
+            ),
+        );
+    }
+
+    // 4. Re-stamp file-sync bases for what the checkout rewrote in the mirror
+    //    (both directions ultimately rewrite the local mirror tree).
+    restamp_after_checkout(pool, manifest, project_id, spec, &old_local_sha).await;
+
+    // 5. Re-observe both sides. `state` was computed at step 2 — *before* step 3 moved
+    //    the peer's HEAD — so returning it as-is persisted a peer head one checkout out
+    //    of date. That is not merely a wrong pill: `detect_and_sync` decides "did the
+    //    peer's HEAD move?" by comparing a fresh probe against this stored value, so a
+    //    stale one **masks the peer's very next checkout**, and permanently — the stale
+    //    state matches the probe, so no later pass sees a move either. Observed live: a
+    //    local checkout, then a checkout on the host, and the mirror never followed while
+    //    the pass reported green with the two sides on different branches.
+    Ok(refresh_heads(project_id, spec, state))
+}
+
+/// Re-probe both peers and refresh a state's observed heads (and, when it is green, its
+/// early-out signatures) before persisting it. Used by any path that *changes* a HEAD
+/// after its status was computed.
+fn refresh_heads(project_id: &str, spec: &RemoteSpec, mut state: GitPeerState) -> GitPeerState {
+    let local = probe(&Peer::Local(mirror_dir(project_id)));
+    let remote = probe(&Peer::Remote(spec.clone()));
+    let green = state.status == SyncStatus::Synchronized;
+    // Only a green pass may seed the early-out, exactly as in `reconcile_with`.
+    state.local_sig = green.then(|| refs_signature(&local));
+    state.remote_sig = green.then(|| refs_signature(&remote));
+    state.local_subject = local.head_subject;
+    state.remote_subject = remote.head_subject;
+    state.local_head = local.head;
+    state.remote_head = remote.head;
+    persist(project_id, state)
+}
+
+/// Normalize a resolution authority string to whether the **local** side wins
+/// (anything but `"remote"` is treated as local — the safer default of "keep my
+/// working copy" for an unexpected value).
+pub fn winner_is_local(authority: &str) -> bool {
+    authority != "remote"
+}
+
+/// Explicit **Use local / Use remote** divergence resolution (#28n Phase 2). The
+/// chosen `authority` (`"local"` or `"remote"`) becomes the source of truth: every
+/// diverged branch — and every branch where the *losing* side is ahead — is reset to
+/// the winner's commit, after the overwritten tip is saved to a timestamped
+/// `refs/eldrun/backup/*` safety ref so nothing is discarded irrecoverably. Conflicting
+/// tags are force-moved the same way. File auto-sync is paused for the duration and its
+/// tracked-file bases are re-stamped afterward (a losing local branch is `reset --hard`,
+/// rewriting the mirror tree), then a normal reconcile recomputes the (now
+/// `Synchronized`) status. A no-op reconcile is returned if either side lacks a repo.
+pub async fn resolve(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    auto: &crate::services::sync_auto::AutoSyncState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    authority: &str,
+) -> Result<GitPeerState, String> {
+    if !connected(pool, project_id).await {
+        return Err("Not connected to the remote host".to_string());
+    }
+    crate::services::sync_auto::pause(auto, project_id).await;
+    let result = resolve_inner(pool, manifest, project_id, spec, authority).await;
+    crate::services::sync_auto::resume(auto, project_id).await;
+    result
+}
+
+async fn resolve_inner(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    authority: &str,
+) -> Result<GitPeerState, String> {
+    let local = probe(&Peer::Local(mirror_dir(project_id)));
+    let remote = probe(&Peer::Remote(spec.clone()));
+    if !local.is_repo || !remote.is_repo {
+        // Nothing paired to resolve; a plain reconcile may still initial-pair.
+        return Ok(reconcile(pool, manifest, project_id, spec).await);
+    }
+
+    let old_local_sha = head_sha(&local).unwrap_or_default();
+    let winner_local = winner_is_local(authority);
+    // Force in the winner→loser direction: winner local ⇒ push to the remote loser.
+    let to_remote = winner_local;
+    let (source, dest) = if winner_local {
+        (&local, &remote)
+    } else {
+        (&remote, &local)
+    };
+
+    // #28p D9: a force-reset of dest's checked-out branch runs `reset --hard`, which
+    // silently clobbers a colliding untracked file. Refuse and name it rather than
+    // guess — the same "blocked, user clears it, retries" UX a blocked fast-forward
+    // already gets (D1/D2) — instead of trusting the backup-ref safety net to cover
+    // something it structurally cannot (an untracked file was never a git object).
+    if let Some(HeadRef::Branch { name, sha: dest_sha }) = &dest.head {
+        if let Some(target) = source.branches.iter().find(|r| &r.name == name) {
+            if &target.sha != dest_sha {
+                let (source_peer, dest_peer) = if to_remote {
+                    (Peer::Local(mirror_dir(project_id)), Peer::Remote(spec.clone()))
+                } else {
+                    (Peer::Remote(spec.clone()), Peer::Local(mirror_dir(project_id)))
+                };
+                let collisions = reset_collisions(&source_peer, &dest_peer, &target.sha);
+                if !collisions.is_empty() {
+                    let where_ = if to_remote { "host" } else { "mirror" };
+                    let shown: Vec<&str> = collisions.iter().take(5).map(String::as_str).collect();
+                    let more = collisions.len() - shown.len();
+                    let extra = if more > 0 { format!(" (+{more} more)") } else { String::new() };
+                    return Err(format!(
+                        "Refusing: {} untracked file(s) on the {where_} differ from '{name}' \
+                         and are not in git: {}{extra}. Move or remove them, then retry.",
+                        collisions.len(),
+                        shown.join(", "),
+                    ));
+                }
+            }
+        }
+    }
+
+    transfer_and_apply(pool, manifest, project_id, spec, to_remote, source, dest, true).await?;
+
+    // A losing local branch was `reset --hard`, rewriting mirror tracked files — refresh
+    // the file-sync bases so the resumed auto-sync reads them green (no-op when the
+    // remote was the loser, since the mirror tree is unchanged).
+    restamp_after_checkout(pool, manifest, project_id, spec, &old_local_sha).await;
+
+    // A resolution is where backup refs are born, so it is also where they are pruned
+    // (#28p D6) — keeping the cost off the hot reconcile path, which creates none.
+    prune_backups(project_id, spec);
+
+    // Recompute status; the forced side is now in sync, so this should read Synchronized.
+    Ok(reconcile(pool, manifest, project_id, spec).await)
+}
+
+// ── Backup refs: list / restore / prune (#28p D6) ────────────────────────────
+
+/// Keep at least this many backups per peer, whatever their age…
+const BACKUP_KEEP_N: usize = 20;
+/// …and keep anything younger than this regardless of the count.
+const BACKUP_MAX_AGE: u64 = 30 * 24 * 60 * 60;
+
+/// Every `refs/eldrun/backup/*` safety ref on one peer, newest first.
+fn backups_on(peer: &Peer, label: &str) -> Vec<BackupRef> {
+    peer.run(&[
+        "for-each-ref",
+        "--format=%(objectname)%09%(refname)%09%(contents:subject)",
+        "refs/eldrun/backup",
+    ])
+    .ok()
+    .filter(|o| o.status.success())
+    .map(|o| parse_backup_refs(label, &String::from_utf8_lossy(&o.stdout)))
+    .unwrap_or_default()
+}
+
+/// Both peers' safety refs, newest first (#28p D6). Until this existed the backups
+/// `resolve`/`init_pairing` create were write-only: they pinned objects forever and no
+/// UI could list, restore from, or prune them — which also hollowed out the "it's
+/// recoverable" defence of Use-local/Use-remote.
+pub fn list_backups(project_id: &str, spec: &RemoteSpec) -> Vec<BackupRef> {
+    let mut all = backups_on(&Peer::Local(mirror_dir(project_id)), "local");
+    all.extend(backups_on(&Peer::Remote(spec.clone()), "remote"));
+    all.sort_by(|a, b| b.ts.cmp(&a.ts).then_with(|| a.branch.cmp(&b.branch)));
+    all
+}
+
+/// Move a branch back onto a backed-up tip. The branch's *current* tip is itself backed
+/// up first — a restore must be as undoable as the thing it undoes.
+///
+/// This deliberately leaves the peers diverged (one side moved, the other didn't); the
+/// next reconcile reports that, and the user resolves it with the authority they meant.
+pub async fn restore_backup(
+    pool: &RemotePoolState,
+    manifest: &remote_sync::SyncManifestState,
+    auto: &crate::services::sync_auto::AutoSyncState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    peer_label: &str,
+    refname: &str,
+) -> Result<GitPeerState, String> {
+    if !connected(pool, project_id).await {
+        return Err("Not connected to the remote host".to_string());
+    }
+    let (_, branch) = parse_backup_ref_name(refname).ok_or("Not an Eldrun backup ref")?;
+    let peer = if peer_label == "remote" {
+        Peer::Remote(spec.clone())
+    } else {
+        Peer::Local(mirror_dir(project_id))
+    };
+
+    let sha = peer
+        .run(&["rev-parse", "--verify", "--quiet", refname])
+        .ok()
+        .filter(|o| o.status.success())
+        .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+        .filter(|s| !s.is_empty())
+        .ok_or_else(|| format!("Backup ref {refname} no longer resolves"))?;
+
+    crate::services::sync_auto::pause(auto, project_id).await;
+    let old_local_sha = head_sha(&probe(&Peer::Local(mirror_dir(project_id)))).unwrap_or_default();
+
+    let snap = probe(&peer);
+    let is_head = matches!(&snap.head, Some(HeadRef::Branch { name, .. }) if *name == branch);
+
+    // #28p D9: same clobber risk as `resolve` — check before `force_reset_branch`'s
+    // `reset --hard` on the checked-out branch. Resume auto-sync before returning so a
+    // refusal never leaves it paused.
+    if is_head {
+        let collisions = reset_collisions(&peer, &peer, &sha);
+        if !collisions.is_empty() {
+            crate::services::sync_auto::resume(auto, project_id).await;
+            let shown: Vec<&str> = collisions.iter().take(5).map(String::as_str).collect();
+            let more = collisions.len() - shown.len();
+            let extra = if more > 0 { format!(" (+{more} more)") } else { String::new() };
+            return Err(format!(
+                "Refusing to restore: {} untracked file(s) on the {peer_label} differ from \
+                 the backup and are not in git: {}{extra}. Move or remove them, then retry.",
+                collisions.len(),
+                shown.join(", "),
+            ));
+        }
+    }
+
+    match sha_of(&snap, RefKind::Head, &branch) {
+        // force_reset_branch backs the current tip up before moving it, so the state we
+        // are restoring *away from* stays reachable too.
+        Some(cur) => force_reset_branch(&peer, &branch, &sha, cur, is_head, now_secs()),
+        // The branch is gone entirely (a resolve deleted it) — recreate it.
+        None => {
+            let _ = peer.run(&["update-ref", &format!("refs/heads/{branch}"), &sha]);
+        }
+    }
+
+    // #28q: restoring a backup onto the mirror's checked-out branch is a `reset --hard`
+    // like any other — it deletes the tracked files the older tip didn't have. (A no-op
+    // when the restore was on the host: the mirror's HEAD never moved.)
+    audit_local_head_move(
+        project_id,
+        &old_local_sha,
+        &format!("restore backup '{branch}' (reset --hard on the mirror)"),
+    );
+
+    restamp_after_checkout(pool, manifest, project_id, spec, &old_local_sha).await;
+    crate::services::sync_auto::resume(auto, project_id).await;
+
+    prune_backups(project_id, spec);
+    Ok(reconcile(pool, manifest, project_id, spec).await)
+}
+
+/// Drop the backup refs that are neither recent nor among the newest N, per peer, so the
+/// namespace stops pinning objects forever. Never drops a peer's newest. Best-effort.
+fn prune_backups(project_id: &str, spec: &RemoteSpec) {
+    let now = now_secs();
+    for (peer, label) in [
+        (Peer::Local(mirror_dir(project_id)), "local"),
+        (Peer::Remote(spec.clone()), "remote"),
+    ] {
+        let refs = backups_on(&peer, label);
+        for refname in select_prunable(&refs, now, BACKUP_KEEP_N, BACKUP_MAX_AGE) {
+            let _ = peer.run(&["update-ref", "-d", &refname]);
+        }
+    }
+}
+
+/// Build + persist a `Desynchronized` state with a message (probes current heads).
+fn desync_state(project_id: &str, spec: &RemoteSpec, detail: &str) -> GitPeerState {
+    let prior = load_state(project_id);
+    let local = probe(&Peer::Local(mirror_dir(project_id)));
+    let remote = probe(&Peer::Remote(spec.clone()));
+    persist(
+        project_id,
+        GitPeerState {
+            enabled: prior.enabled,
+            status: SyncStatus::Desynchronized,
+            detail: Some(detail.to_string()),
+            local_subject: local.head_subject,
+            remote_subject: remote.head_subject,
+            local_head: local.head,
+            remote_head: remote.head,
+            last_sync_ts: Some(now_secs()),
+            pairing_conflict: None,
+            // Not green → never seed the early-out (it must not skip the retry).
+            local_sig: None,
+            remote_sig: None,
+        },
+    )
+}
+
+// ── Detection loop + registry ───────────────────────────────────────────────
+
+/// One running git-peer lockstep task: its cancel signal, join handle, and the
+/// `.git` watcher whose lifetime is tied to the task (dropping it unwatches).
+pub struct GitPeerTask {
+    cancel: Arc<Notify>,
+    join: tokio::task::JoinHandle<()>,
+    _watcher: Option<notify::RecommendedWatcher>,
+}
+
+/// Tauri-managed registry of per-project lockstep tasks, keyed by project id.
+pub type GitPeerRegistry = Arc<Mutex<HashMap<String, GitPeerTask>>>;
+
+/// Build a fresh, empty registry for `tauri::Builder::manage`.
+pub fn new_registry() -> GitPeerRegistry {
+    Arc::new(Mutex::new(HashMap::new()))
+}
+
+/// The `git-peer-status` event payload (camelCase).
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StatusEvent {
+    project_id: String,
+    state: GitPeerState,
+}
+
+/// Emit the current lockstep state to the frontend.
+pub fn emit_status(app: &AppHandle, project_id: &str, state: &GitPeerState) {
+    let _ = app.emit(
+        "git-peer-status",
+        StatusEvent {
+            project_id: project_id.to_string(),
+            state: state.clone(),
+        },
+    );
+}
+
+/// Start the per-project lockstep task (idempotent; no-op for a local project or a
+/// project whose lockstep toggle is off). Attaches a narrowly-scoped `.git` watcher
+/// on the local mirror and spawns the host-poll loop. Runs one reconcile immediately.
+pub async fn start(
+    app: AppHandle,
+    pool: RemotePoolState,
+    manifest: SyncManifestState,
+    auto: AutoSyncState,
+    reg: &GitPeerRegistry,
+    worker_sync: crate::services::worker_sync::WorkerSyncState,
+    project_id: &str,
+) {
+    let Some(target) = remote_target_for(project_id) else {
+        return;
+    };
+    if !load_state(project_id).enabled {
+        return;
+    }
+    // A host tagged HPC gets no background poll loop: every tick runs `git` in the
+    // host tree, which on a cluster sits on the parallel filesystem, and a repo
+    // probe every 12 s for as long as the project is open is exactly the standing
+    // load a login node's rules ask you not to put there. Lockstep's manual
+    // reconcile (and the local `.git` watcher's push) still work — what stops is
+    // Eldrun asking the cluster, unprompted, forever.
+    if crate::services::hpc_mode::is_hpc_spec(&target.spec) {
+        return;
+    }
+    let mut guard = reg.lock().await;
+    if guard.contains_key(project_id) {
+        return;
+    }
+
+    let (tx, rx) = mpsc::unbounded_channel::<()>();
+    // Watch only `.git` (HEAD/refs/packed-refs live here) so we don't double-fire
+    // with the mirror-wide auto-sync watcher on ordinary file edits.
+    let gitdir = mirror_dir(project_id).join(".git");
+    let watcher = if gitdir.exists() {
+        match notify::recommended_watcher(move |res: notify::Result<notify::Event>| {
+            if res.is_ok() {
+                let _ = tx.send(());
+            }
+        }) {
+            Ok(mut w) => {
+                let _ = w.watch(&gitdir, RecursiveMode::Recursive);
+                Some(w)
+            }
+            Err(_) => None,
+        }
+    } else {
+        None
+    };
+
+    let cancel = Arc::new(Notify::new());
+    let join = tokio::spawn(poll_loop(
+        app,
+        pool,
+        manifest,
+        auto,
+        worker_sync,
+        target.spec,
+        project_id.to_string(),
+        rx,
+        cancel.clone(),
+    ));
+    guard.insert(
+        project_id.to_string(),
+        GitPeerTask {
+            cancel,
+            join,
+            _watcher: watcher,
+        },
+    );
+}
+
+/// Stop the project's lockstep task (no-op if none).
+pub async fn stop(reg: &GitPeerRegistry, project_id: &str) {
+    let task = reg.lock().await.remove(project_id);
+    if let Some(t) = task {
+        t.cancel.notify_one();
+        let _ = tokio::time::timeout(Duration::from_secs(5), t.join).await;
+    }
+}
+
+/// Stop every lockstep task (app exit).
+pub async fn stop_all(reg: &GitPeerRegistry) {
+    let tasks: Vec<GitPeerTask> = reg.lock().await.drain().map(|(_, t)| t).collect();
+    for t in tasks {
+        t.cancel.notify_one();
+        let _ = tokio::time::timeout(Duration::from_secs(5), t.join).await;
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn poll_loop(
+    app: AppHandle,
+    pool: RemotePoolState,
+    manifest: SyncManifestState,
+    auto: AutoSyncState,
+    worker_sync: crate::services::worker_sync::WorkerSyncState,
+    spec: RemoteSpec,
+    project_id: String,
+    mut rx: mpsc::UnboundedReceiver<()>,
+    cancel: Arc<Notify>,
+) {
+    // Initial reconcile so both sides start in step. Forced: there is no prior pass in
+    // this session to early-out against, and a stale green signature from the last run
+    // must not skip it.
+    let s = detect_and_sync(
+        &pool,
+        &manifest,
+        &auto,
+        &project_id,
+        &spec,
+        ReconcileOpts { forced: true, ..Default::default() },
+    )
+    .await;
+    emit_status(&app, &project_id, &s);
+    // The primary now holds the current committed code; push it to any already-
+    // connected workers (multi-host, `docs/multi_host_remote_plan.md` §2). Cheap
+    // when they are already at HEAD (a mirror-head read, no network).
+    crate::services::worker_sync::fan_out(&app, &pool, &worker_sync, &project_id, false).await;
+
+    let mut interval = tokio::time::interval(GIT_POLL_INTERVAL);
+    interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
+    loop {
+        tokio::select! {
+            _ = cancel.notified() => break,
+            _ = interval.tick() => {
+                // Re-read the HPC tag rather than trusting the one `start()` saw.
+                // Tagging a login node is normally a reaction to noticing this very
+                // poll; a gate evaluated only at start would leave it running until
+                // the project is closed. Breaking ends the task — `stop()` then
+                // finds it already finished, which is what a cancel leaves too.
+                if crate::services::hpc_mode::is_hpc_spec(&spec) { break; }
+                let s = detect_and_sync(
+                    &pool, &manifest, &auto, &project_id, &spec, ReconcileOpts::default(),
+                )
+                .await;
+                emit_status(&app, &project_id, &s);
+            }
+            res = rx.recv() => {
+                if res.is_none() { break; }
+                // A `.git` change reconciles against the host exactly as a tick
+                // does, so it takes the same re-check.
+                if crate::services::hpc_mode::is_hpc_spec(&spec) { break; }
+                loop {
+                    tokio::select! {
+                        _ = cancel.notified() => return,
+                        _ = tokio::time::sleep(GIT_DEBOUNCE) => break,
+                        res = rx.recv() => { if res.is_none() { return; } }
+                    }
+                }
+                let s = detect_and_sync(
+                    &pool, &manifest, &auto, &project_id, &spec, ReconcileOpts::default(),
+                )
+                .await;
+                emit_status(&app, &project_id, &s);
+                // A `.git` change on the mirror = a new commit/ref move; fan the
+                // committed code out to every connected worker (plan §2 trigger).
+                crate::services::worker_sync::fan_out(
+                    &app, &pool, &worker_sync, &project_id, false,
+                )
+                .await;
+            }
+        }
+    }
+}
+
+/// The target (branch name or detached sha) a HEAD points at, if any.
+fn target_of(head: &Option<HeadRef>) -> Option<String> {
+    match head {
+        Some(HeadRef::Branch { name, .. }) => Some(name.clone()),
+        Some(HeadRef::Detached { sha }) => Some(sha.clone()),
+        _ => None,
+    }
+}
+
+/// One detection pass: if either side's HEAD moved since the last observed state,
+/// treat it as a checkout on that side and lock the peer to the same target;
+/// otherwise just fast-forward-reconcile refs. Persists + returns the new state.
+pub async fn detect_and_sync(
+    pool: &RemotePoolState,
+    manifest: &SyncManifestState,
+    auto: &AutoSyncState,
+    project_id: &str,
+    spec: &RemoteSpec,
+    opts: ReconcileOpts,
+) -> GitPeerState {
+    // #28p D4: probing a disconnected host is six dead round trips whose failures read
+    // as "the host is empty" — bail before any of that.
+    if !connected(pool, project_id).await {
+        return persist(project_id, disconnected_state(&load_state(project_id)));
+    }
+    let prior = load_state(project_id);
+    let local = probe(&Peer::Local(mirror_dir(project_id)));
+    let remote = probe(&Peer::Remote(spec.clone()));
+
+    // A HEAD move is only actionable once we have a prior observation to compare to
+    // (the first pass just records heads via reconcile).
+    let local_moved = prior.local_head.is_some() && prior.local_head != local.head;
+    let remote_moved = prior.remote_head.is_some() && prior.remote_head != remote.head;
+
+    if local_moved {
+        if let Some(t) = target_of(&local.head) {
+            if let Ok(s) = checkout_lockstep(
+                pool, manifest, auto, project_id, spec, &t, "local", true,
+            )
+            .await
+            {
+                return s;
+            }
+        }
+    } else if remote_moved {
+        if let Some(t) = target_of(&remote.head) {
+            if let Ok(s) = checkout_lockstep(
+                pool, manifest, auto, project_id, spec, &t, "remote", true,
+            )
+            .await
+            {
+                return s;
+            }
+        }
+    }
+    reconcile_with(pool, manifest, project_id, spec, opts).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Returns true when `git` is on PATH; probe tests skip gracefully otherwise.
+    fn git_available() -> bool {
+        crate::paths::command_no_window("git")
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+    }
+
+    #[test]
+    fn probe_missing_local_dir_is_clean_empty_not_error() {
+        // A local dir that does not exist is a legitimately-empty side (nothing to
+        // destroy) — it must NOT flag `probe_error`, so pairing can still create it.
+        let missing = std::path::PathBuf::from("/definitely/not/a/real/eldrun/dir/xyz");
+        let snap = probe(&Peer::Local(missing));
+        assert!(!snap.is_repo);
+        assert!(!snap.probe_error, "missing dir must read as clean-empty");
+    }
+
+    #[test]
+    fn probe_existing_non_repo_dir_is_clean_empty() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping probe_existing_non_repo_dir_is_clean_empty");
+            return;
+        }
+        // An existing directory that is not a git repo: git runs and cleanly says
+        // "no" → is_repo=false, but probe_error=false (safe to initialize).
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let snap = probe(&Peer::Local(tmp.path().to_path_buf()));
+        assert!(!snap.is_repo);
+        assert!(
+            !snap.probe_error,
+            "an existing non-repo dir must be a clean-empty, not a probe error"
+        );
+    }
+
+    #[test]
+    fn parse_refs_reads_sha_and_short_name() {
+        let out = "abc123 main\ndef456 feature/x\n\n  \n";
+        let refs = parse_refs(out);
+        assert_eq!(refs.len(), 2);
+        assert_eq!(refs[0], RefEntry { name: "main".into(), sha: "abc123".into() });
+        assert_eq!(refs[1].name, "feature/x");
+    }
+
+    #[test]
+    fn parse_head_branch_detached_unborn() {
+        assert_eq!(
+            parse_head("main\n", "abc\n"),
+            HeadRef::Branch { name: "main".into(), sha: "abc".into() }
+        );
+        assert_eq!(parse_head("", "abc\n"), HeadRef::Detached { sha: "abc".into() });
+        assert_eq!(parse_head("", ""), HeadRef::Unborn);
+    }
+
+    #[test]
+    fn is_dirty_tracked_ignores_untracked() {
+        assert!(!is_dirty_tracked("?? newfile.txt\n?? other\n"));
+        assert!(is_dirty_tracked(" M tracked.rs\n"));
+        assert!(is_dirty_tracked("M  staged.rs\n"));
+        assert!(is_dirty_tracked("?? a\n M b\n")); // any tracked line
+        assert!(!is_dirty_tracked(""));
+    }
+
+    #[test]
+    fn decide_truth_table() {
+        assert_eq!(decide(None, "a", false, false), RefAction::CreateOnDest);
+        assert_eq!(decide(Some("a"), "a", false, false), RefAction::InSync);
+        assert_eq!(decide(Some("old"), "new", true, false), RefAction::FastForwardDest);
+        assert_eq!(decide(Some("new"), "old", false, true), RefAction::DestAhead);
+        assert_eq!(decide(Some("x"), "y", false, false), RefAction::Diverged);
+    }
+
+    #[test]
+    fn bundle_create_args_shape_never_all() {
+        let excl = vec!["r1".to_string(), "r2".to_string()];
+        let args = bundle_create_args("/tmp/b.bundle", &["--branches", "--tags"], &excl);
+        assert_eq!(&args[..3], &["bundle", "create", "/tmp/b.bundle"]);
+        assert!(args.iter().any(|a| a == "--branches"));
+        assert!(args.iter().any(|a| a == "--tags"));
+        assert!(args.iter().any(|a| a == "--not"));
+        assert!(args.iter().position(|a| a == "--not").unwrap() < args.iter().position(|a| a == "r1").unwrap());
+        // Guardrail: never `--all` (could pull odd refs), and no config/hook words.
+        assert!(!args.iter().any(|a| a == "--all"));
+        assert!(!args.iter().any(|a| a.contains("config") || a.contains("hooks") || a.contains("remotes")));
+    }
+
+    #[test]
+    fn bundle_create_args_full_when_no_excludes() {
+        let args = bundle_create_args("/tmp/b", &["--branches", "--tags"], &[]);
+        assert!(!args.iter().any(|a| a == "--not"));
+    }
+
+    // ── #28p D11: distinguish an empty-bundle no-op from a real failure ──────
+
+    #[test]
+    fn empty_bundle_error_is_recognized_precisely() {
+        // Git's own literal refusal text (verified against a real `git bundle create`).
+        assert!(is_empty_bundle_error("fatal: Refusing to create empty bundle.\n"));
+        // A genuine I/O failure must NOT be mistaken for the no-op case — that is
+        // exactly the false-green D11 exists to close.
+        assert!(!is_empty_bundle_error(
+            "fatal: could not write bundle: No space left on device\n"
+        ));
+        assert!(!is_empty_bundle_error("fatal: bad revision 'HEAD'\n"));
+        assert!(!is_empty_bundle_error(""));
+    }
+
+    #[test]
+    fn bundle_create_fails_empty_with_gits_exact_message() {
+        // Pins the literal string `is_empty_bundle_error` matches against a real git,
+        // so a future git release changing this wording fails loudly here rather than
+        // silently making every genuine failure look like the safe no-op case.
+        if !git_available() {
+            eprintln!("git not on PATH — skipping bundle_create_fails_empty_with_gits_exact_message");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let peer = Peer::Local(dir.to_path_buf());
+        peer.run(&["init", "-q", "."]).expect("git init");
+        peer.run(&["config", "user.email", "t@e"]).expect("git config");
+        peer.run(&["config", "user.name", "t"]).expect("git config");
+        std::fs::write(dir.join("a.txt"), b"x").unwrap();
+        peer.run(&["add", "a.txt"]).expect("git add");
+        peer.run(&["commit", "-qm", "init"]).expect("git commit");
+        let head = String::from_utf8_lossy(
+            &peer.run(&["rev-parse", "HEAD"]).expect("rev-parse").stdout,
+        )
+        .trim()
+        .to_string();
+
+        let bundle_path = dir.join("out.bundle").to_string_lossy().to_string();
+        let args = bundle_create_args(&bundle_path, &["--branches"], &[head]);
+        let argv: Vec<&str> = args.iter().map(String::as_str).collect();
+        let out = peer.run(&argv).expect("bundle create");
+        assert!(!out.status.success());
+        assert!(is_empty_bundle_error(&String::from_utf8_lossy(&out.stderr)));
+    }
+
+    #[test]
+    fn incoming_refspecs_are_namespaced() {
+        let specs = incoming_fetch_refspecs();
+        assert!(specs[0].ends_with(":refs/eldrun/incoming/heads/*"));
+        assert!(specs[1].ends_with(":refs/eldrun/incoming/tags/*"));
+        // Never target real refs/heads or refs/remotes on the receiver.
+        assert!(specs.iter().all(|s| {
+            let dst = s.split(':').nth(1).unwrap();
+            dst.starts_with("refs/eldrun/incoming/") && !dst.contains("refs/remotes")
+        }));
+    }
+
+    #[test]
+    fn changed_tracked_paths_handles_deletions_and_renames() {
+        let ns = "M\tsrc/a.rs\nD\tsrc/gone.rs\nR100\told/name.rs\tnew/name.rs\nA\tadded.rs\n";
+        let ch = changed_tracked_paths(ns);
+        assert_eq!(ch.len(), 4);
+        assert_eq!(ch[0], TrackedChange { path: "src/a.rs".into(), deleted: false });
+        assert_eq!(ch[1], TrackedChange { path: "src/gone.rs".into(), deleted: true });
+        assert_eq!(ch[2], TrackedChange { path: "new/name.rs".into(), deleted: false });
+        assert!(!ch[3].deleted);
+    }
+
+    #[test]
+    fn backup_ref_name_format() {
+        assert_eq!(
+            backup_ref_name("feature/x", 1735689600),
+            "refs/eldrun/backup/1735689600/feature/x"
+        );
+        // Tag conflicts back up under a `tags/` prefix so a branch and a same-named tag
+        // never collide in the safety-ref namespace.
+        assert_eq!(
+            backup_ref_name("tags/v1", 1735689600),
+            "refs/eldrun/backup/1735689600/tags/v1"
+        );
+    }
+
+    #[test]
+    fn winner_is_local_defaults_to_local() {
+        assert!(winner_is_local("local"));
+        assert!(!winner_is_local("remote"));
+        // Anything unexpected keeps the safer "my working copy wins" default.
+        assert!(winner_is_local(""));
+        assert!(winner_is_local("garbage"));
+    }
+
+    #[test]
+    fn decide_under_force_targets_diverged_and_dest_ahead() {
+        // The resolution force path acts exactly on the two actions that a normal
+        // reconcile leaves for the user: a real divergence, and the loser being ahead.
+        // (`force_reset_branch` is IO; this pins which classifications route into it.)
+        assert_eq!(decide(Some("x"), "y", false, false), RefAction::Diverged);
+        assert_eq!(decide(Some("new"), "old", false, true), RefAction::DestAhead);
+        // Fast-forwardable / create / in-sync never need forcing (no data loss).
+        assert_eq!(decide(Some("old"), "new", true, false), RefAction::FastForwardDest);
+        assert_eq!(decide(None, "a", false, false), RefAction::CreateOnDest);
+        assert_eq!(decide(Some("a"), "a", false, false), RefAction::InSync);
+    }
+
+    // ── #28p D1/D2: the blocked-fast-forward stderr ──────────────────────────
+
+    #[test]
+    fn parse_untracked_overwrite_paths_reads_gits_list() {
+        // Verbatim shape of a real `git merge --ff-only` refusal (captured from git).
+        let stderr = "error: The following untracked working tree files would be overwritten by merge:\n\
+                      \tnew.txt\n\
+                      \tsp ace.txt\n\
+                      \tsrc/deep/file.rs\n\
+                      Please move or remove them before you merge.\n\
+                      Aborting\n";
+        assert_eq!(
+            parse_untracked_overwrite_paths(stderr),
+            vec!["new.txt", "sp ace.txt", "src/deep/file.rs"]
+        );
+    }
+
+    #[test]
+    fn parse_untracked_overwrite_paths_unquotes_and_ignores_other_errors() {
+        // core.quotePath wraps non-ASCII paths in C-escapes; \303\251 is "é".
+        let stderr = "error: The following untracked working tree files would be overwritten by merge:\n\
+                      \t\"caf\\303\\251.txt\"\n\
+                      Please move or remove them before you merge.\n";
+        assert_eq!(parse_untracked_overwrite_paths(stderr), vec!["café.txt"]);
+        // A genuinely-dirty tree is a different message and yields no paths, so the
+        // identical-content retry never fires for it.
+        assert!(parse_untracked_overwrite_paths(
+            "error: Your local changes to the following files would be overwritten by merge:\n\tsrc/a.rs\n"
+        )
+        .is_empty());
+        assert!(parse_untracked_overwrite_paths("").is_empty());
+    }
+
+    #[test]
+    fn blocked_detail_names_the_untracked_files_not_uncommitted_changes() {
+        let stderr = "error: The following untracked working tree files would be overwritten by merge:\n\
+                      \ta.txt\n\tb.txt\n\tc.txt\n\td.txt\n\
+                      Please move or remove them before you merge.\n";
+        let d = blocked_detail("main", stderr);
+        assert!(d.contains("untracked"), "{d}");
+        assert!(d.contains("a.txt") && d.contains("c.txt"), "{d}");
+        assert!(d.contains("+1 more"), "{d}");
+        // The old message claimed uncommitted changes for every blocked ff — the lie D2
+        // exists to kill.
+        assert!(!d.contains("uncommitted"), "{d}");
+
+        // A blocked ff with no untracked list still says what git said.
+        let dirty = blocked_detail("main", "error: Your local changes would be overwritten\n");
+        assert!(dirty.contains("local changes"), "{dirty}");
+    }
+
+    #[test]
+    fn unquote_git_path_passes_plain_paths_through() {
+        assert_eq!(unquote_git_path("a/b c.txt"), "a/b c.txt");
+        assert_eq!(unquote_git_path("\"a\\tb\""), "a\tb");
+        assert_eq!(unquote_git_path("\"q\\\"uote\""), "q\"uote");
+    }
+
+    // ── #28p D1: lockstep owns the tracked tree ──────────────────────────────
+
+    #[test]
+    fn tracked_paths_lists_the_mirrors_tracked_files_only() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping tracked_paths_lists_the_mirrors_tracked_files_only");
+            return;
+        }
+        // `tracked_paths` reads the mirror of a project id, so drive it through a repo
+        // built at that exact path via the real `mirror_dir` mapping.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let git = |args: &[&str]| {
+            crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git")
+        };
+        git(&["init", "-q", "."]);
+        git(&["config", "user.email", "t@e"]);
+        git(&["config", "user.name", "t"]);
+        std::fs::write(dir.join("tracked.txt"), b"x").unwrap();
+        std::fs::write(dir.join("untracked.txt"), b"y").unwrap();
+        git(&["add", "tracked.txt"]);
+        git(&["commit", "-qm", "x"]);
+
+        let peer = Peer::Local(dir.to_path_buf());
+        let out = peer.run(&["ls-files", "-z"]).expect("ls-files");
+        let set: HashSet<String> = out
+            .stdout
+            .split(|&b| b == 0)
+            .filter(|s| !s.is_empty())
+            .map(|s| String::from_utf8_lossy(s).replace('\\', "/"))
+            .collect();
+        assert!(set.contains("tracked.txt"));
+        assert!(!set.contains("untracked.txt"), "byte-sync keeps the untracked files");
+        assert!(!set.iter().any(|p| p.starts_with(".git/")));
+    }
+
+    /// Build a repo where `main` is one commit behind `feat`, `feat` adds `new.txt` +
+    /// `keep.txt`, and `main` is checked out. Returns the repo dir and `feat`'s sha —
+    /// the exact shape a byte-sync-outran-the-commit collision arrives in.
+    fn repo_behind_by_one(dir: &Path) -> String {
+        let git = |args: &[&str]| {
+            crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git")
+        };
+        git(&["init", "-q", "-b", "main", "."]);
+        git(&["config", "user.email", "t@e"]);
+        git(&["config", "user.name", "t"]);
+        std::fs::write(dir.join("base.txt"), b"base\n").unwrap();
+        git(&["add", "-A"]);
+        git(&["commit", "-qm", "base"]);
+        git(&["checkout", "-q", "-b", "feat"]);
+        std::fs::write(dir.join("new.txt"), b"incoming content\n").unwrap();
+        std::fs::write(dir.join("keep.txt"), b"also incoming\n").unwrap();
+        git(&["add", "-A"]);
+        git(&["commit", "-qm", "feat"]);
+        let sha = String::from_utf8_lossy(&git(&["rev-parse", "HEAD"]).stdout)
+            .trim()
+            .to_string();
+        git(&["checkout", "-q", "main"]);
+        sha
+    }
+
+    /// A worktree file as git *checked it out*, with the line endings its filters
+    /// applied normalized back out. Git for Windows defaults to `core.autocrlf=true`,
+    /// so a blob committed with LF lands on disk with CRLF — the assertions below are
+    /// about *which content* a fast-forward wrote, never about its line endings. The
+    /// lockstep code itself never compares raw worktree bytes for this reason: it asks
+    /// git (`hash-object`, which runs the same filters) whether the file already is the
+    /// blob — see `blob_matches_worktree`.
+    fn checked_out(path: &Path) -> Vec<u8> {
+        let bytes = std::fs::read(path).unwrap();
+        let mut out = Vec::with_capacity(bytes.len());
+        for (i, &b) in bytes.iter().enumerate() {
+            if b == b'\r' && bytes.get(i + 1) == Some(&b'\n') {
+                continue;
+            }
+            out.push(b);
+        }
+        out
+    }
+
+    #[test]
+    fn deleted_between_names_only_what_a_move_removes() {
+        // #28q: the audit's whole job is to name the files a HEAD move deletes from the
+        // working tree. `feat` ADDS new.txt/keep.txt on top of `main`, so moving forward
+        // deletes nothing — and moving BACK (a checkout of the older commit, a
+        // `reset --hard` onto it, a restored backup) deletes both. A warning that fired
+        // on the forward move would be crying wolf on every ordinary fast-forward.
+        if !git_available() {
+            eprintln!("git not on PATH — skipping deleted_between_names_only_what_a_move_removes");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let feat = repo_behind_by_one(dir);
+        let peer = Peer::Local(dir.to_path_buf());
+        let main = String::from_utf8_lossy(
+            &peer.run(&["rev-parse", "HEAD"]).expect("rev-parse").stdout,
+        )
+        .trim()
+        .to_string();
+
+        assert!(
+            deleted_between(&peer, &main, &feat).is_empty(),
+            "a fast-forward that only adds files must warn about nothing"
+        );
+
+        let mut back = deleted_between(&peer, &feat, &main);
+        back.sort();
+        assert_eq!(back, vec!["keep.txt".to_string(), "new.txt".to_string()]);
+
+        // An unmoved HEAD (the op failed, or was a ref-only update on a branch that is
+        // not checked out) is not a deletion of anything.
+        assert!(deleted_between(&peer, &feat, &feat).is_empty());
+    }
+
+    /// The blocked `merge --ff-only` and its stderr, against a real git.
+    fn try_ff(peer: &Peer, sha: &str) -> (bool, String) {
+        let o = peer.run(&["merge", "--ff-only", sha]).expect("merge");
+        (o.status.success(), String::from_utf8_lossy(&o.stderr).to_string())
+    }
+
+    #[test]
+    fn ff_retry_clears_byte_identical_untracked_files_and_succeeds() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping ff_retry_clears_byte_identical_untracked_files");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let sha = repo_behind_by_one(dir);
+        let peer = Peer::Local(dir.to_path_buf());
+
+        // The D1 collision: byte-sync already delivered the files the incoming commit
+        // carries, so they sit here untracked and byte-identical.
+        std::fs::write(dir.join("new.txt"), b"incoming content\n").unwrap();
+        std::fs::write(dir.join("keep.txt"), b"also incoming\n").unwrap();
+
+        // Git refuses even though the bytes match — the behaviour the whole fix exists
+        // for. (If this ever stops being true, the retry is dead code and should go.)
+        let (ok, stderr) = try_ff(&peer, &sha);
+        assert!(!ok, "git is expected to refuse over identical untracked files");
+        assert!(!parse_untracked_overwrite_paths(&stderr).is_empty());
+
+        // #28q: the retry reports WHICH files it deleted to get here, so the caller can
+        // warn about them — a `git diff` never could, they were never tracked.
+        let retry = retry_ff_clearing_identical(&peer, &sha, &stderr, &HashSet::new());
+        let FfRetry::Cleared(cleared) = &retry else {
+            panic!("identical untracked files must be cleared and the ff retried");
+        };
+        // Both collisions are named — the warning the caller files must not under-report
+        // what it deleted just because the ff put identical bytes straight back.
+        let mut named = cleared.clone();
+        named.sort();
+        assert_eq!(named, vec!["keep.txt".to_string(), "new.txt".to_string()]);
+        // The fast-forward landed, and the files are now TRACKED at the incoming content.
+        let head = probe(&peer);
+        assert_eq!(
+            head.head,
+            Some(HeadRef::Branch { name: "main".into(), sha: sha.clone() })
+        );
+        assert_eq!(checked_out(&dir.join("new.txt")), b"incoming content\n");
+        assert!(!head.dirty_tracked);
+    }
+
+    #[test]
+    fn ff_retry_refuses_when_any_colliding_file_differs() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping ff_retry_refuses_when_any_colliding_file_differs");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let sha = repo_behind_by_one(dir);
+        let peer = Peer::Local(dir.to_path_buf());
+
+        // One collision is identical; the other holds REAL unsynced work.
+        std::fs::write(dir.join("new.txt"), b"incoming content\n").unwrap();
+        std::fs::write(dir.join("keep.txt"), b"MY UNSAVED WORK\n").unwrap();
+
+        let (ok, stderr) = try_ff(&peer, &sha);
+        assert!(!ok);
+        assert!(
+            matches!(
+                retry_ff_clearing_identical(&peer, &sha, &stderr, &HashSet::new()),
+                FfRetry::Refused
+            ),
+            "one differing file must abort the whole retry"
+        );
+        // All-or-nothing: nothing was deleted — not even the identical one — and the
+        // branch did not move. The user's work is still there to be seen and merged.
+        assert_eq!(
+            std::fs::read(dir.join("keep.txt")).unwrap(),
+            b"MY UNSAVED WORK\n"
+        );
+        assert_eq!(
+            std::fs::read(dir.join("new.txt")).unwrap(),
+            b"incoming content\n"
+        );
+        assert!(matches!(
+            probe(&peer).head,
+            Some(HeadRef::Branch { ref name, .. }) if name == "main"
+        ));
+        // And the message the user gets names the real culprit rather than inventing
+        // uncommitted changes (D2).
+        let detail = blocked_detail("main", &stderr);
+        assert!(detail.contains("keep.txt"), "{detail}");
+    }
+
+    #[test]
+    fn ff_retry_clears_a_differing_file_when_named_as_stale_residue() {
+        // Case #12: `keep.txt` differs from the incoming commit, but the caller has
+        // already proven (via the sync manifest) that it is byte-sync's own old copy —
+        // this is what makes the retry succeed where the plain identical-only check
+        // above refuses.
+        if !git_available() {
+            eprintln!("git not on PATH — skipping ff_retry_clears_a_differing_file_when_named_as_stale_residue");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let sha = repo_behind_by_one(dir);
+        let peer = Peer::Local(dir.to_path_buf());
+
+        std::fs::write(dir.join("new.txt"), b"incoming content\n").unwrap();
+        std::fs::write(dir.join("keep.txt"), b"stale pre-commit copy\n").unwrap();
+
+        let (ok, stderr) = try_ff(&peer, &sha);
+        assert!(!ok);
+        let residue: HashSet<String> = ["keep.txt".to_string()].into_iter().collect();
+        // Cleared *and named*: `keep.txt`'s old copy is the one thing this retry destroys
+        // that the ff does not put back byte-for-byte, which is what the caller warns
+        // about (#28q).
+        assert!(
+            matches!(
+                retry_ff_clearing_identical(&peer, &sha, &stderr, &residue),
+                FfRetry::Cleared(ref cleared) if cleared.contains(&"keep.txt".to_string())
+            ),
+            "a file named as proven stale residue must be cleared even though it differs"
+        );
+        assert_eq!(checked_out(&dir.join("keep.txt")), b"also incoming\n");
+        assert!(matches!(
+            probe(&peer).head,
+            Some(HeadRef::Branch { sha: ref s, .. }) if s == &sha
+        ));
+    }
+
+    #[tokio::test]
+    async fn stale_residue_recognizes_content_already_known_to_git() {
+        // #28p D10: `f.txt` sits on the dest, untracked, holding content that WAS once
+        // committed there (a prior commit, later untracked — the shape a byte-synced
+        // leftover takes once lockstep starts owning the path). `g.txt` holds content
+        // that has never been part of any commit — real, never-synced work — and must
+        // never be treated as safe even though the manifest also has an entry for it.
+        // `h.txt` holds git-known content too, but carries NO manifest entry, so the
+        // scope gate must exclude it regardless of what its content proves.
+        if !git_available() {
+            eprintln!("git not on PATH — skipping stale_residue_recognizes_content_already_known_to_git");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let git = |args: &[&str]| {
+            crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git")
+        };
+        git(&["init", "-q", "."]);
+        git(&["config", "user.email", "t@e"]);
+        git(&["config", "user.name", "t"]);
+        std::fs::write(dir.join("f.txt"), b"old committed content\n").unwrap();
+        std::fs::write(dir.join("h.txt"), b"old committed content\n").unwrap();
+        git(&["add", "f.txt", "h.txt"]);
+        git(&["commit", "-qm", "add"]);
+        // Untrack both, then leave f.txt/h.txt holding that SAME (git-known) content,
+        // and g.txt holding content nothing has ever recorded.
+        git(&["rm", "-q", "--cached", "f.txt", "h.txt"]);
+        git(&["commit", "-qm", "untrack"]);
+        std::fs::write(dir.join("g.txt"), b"totally new, never committed\n").unwrap();
+
+        let project_id = format!("d10-test-{}-{}", std::process::id(), line!());
+        let manifest = remote_sync::new_manifest_state();
+        {
+            let mut g = manifest.lock().await;
+            let m = remote_sync::ensure_loaded(&mut g, &project_id);
+            m.insert("f.txt".to_string(), remote_sync::SyncEntry::default());
+            m.insert("g.txt".to_string(), remote_sync::SyncEntry::default());
+            // h.txt deliberately has no manifest entry.
+        }
+
+        let peer = Peer::Local(dir.to_path_buf());
+        let paths = vec!["f.txt".to_string(), "g.txt".to_string(), "h.txt".to_string()];
+        let residue = stale_byte_sync_residue(&manifest, &project_id, &peer, &paths).await;
+        assert!(
+            residue.contains("f.txt"),
+            "content matching a git-known blob must be recognized as safe residue"
+        );
+        assert!(
+            !residue.contains("g.txt"),
+            "content nothing has ever recorded must never be treated as safe to delete, \
+             manifest entry or not"
+        );
+        assert!(
+            !residue.contains("h.txt"),
+            "a path outside the manifest's scope must be excluded regardless of content"
+        );
+
+        forget_synced_paths(&manifest, &project_id, &paths).await;
+        {
+            let mut g = manifest.lock().await;
+            let m = remote_sync::ensure_loaded(&mut g, &project_id);
+            assert!(m.is_empty(), "the bases must be dropped once lockstep owns the paths");
+        }
+
+        if let Some(parent) = remote_sync::manifest_path(&project_id).parent() {
+            let _ = std::fs::remove_dir_all(parent);
+        }
+    }
+
+    // ── #28p D3: pairing collisions + symmetric probe-error refusal ──────────
+
+    fn fp(size: u64, hash: Option<&str>) -> Fingerprint {
+        Fingerprint { size, hash: hash.map(str::to_string) }
+    }
+
+    #[test]
+    fn pairing_collisions_only_flags_files_that_actually_differ() {
+        let source: HashMap<String, Fingerprint> = [
+            ("same.txt".to_string(), fp(3, Some("aaa"))),
+            ("differs.txt".to_string(), fp(3, Some("bbb"))),
+            ("bigger.txt".to_string(), fp(9, Some("ccc"))),
+            ("source-only.txt".to_string(), fp(1, Some("ddd"))),
+        ]
+        .into_iter()
+        .collect();
+        let dest: HashMap<String, Fingerprint> = [
+            // Byte-identical: the EXPECTED case when file-sync already mirrored the
+            // tree — pairing must adopt these, not refuse over them.
+            ("same.txt".to_string(), fp(3, Some("aaa"))),
+            // Same size, different content → a real difference.
+            ("differs.txt".to_string(), fp(3, Some("zzz"))),
+            // Different size → differs without needing a hash at all.
+            ("bigger.txt".to_string(), fp(4, None)),
+            // Only on the dest → pairing doesn't touch it.
+            ("dest-only.txt".to_string(), fp(2, Some("eee"))),
+        ]
+        .into_iter()
+        .collect();
+        assert_eq!(
+            pairing_collisions(&source, &dest),
+            vec!["bigger.txt", "differs.txt"]
+        );
+        // Nothing in common → nothing at risk.
+        assert!(pairing_collisions(&source, &HashMap::new()).is_empty());
+    }
+
+    #[test]
+    fn pairing_collisions_treat_an_unprovable_match_as_a_difference() {
+        // Same size but the dest's hash couldn't be computed: `reset --hard` is
+        // destructive, so "probably fine" is not good enough.
+        let source: HashMap<String, Fingerprint> =
+            [("f".to_string(), fp(3, Some("aaa")))].into_iter().collect();
+        let dest: HashMap<String, Fingerprint> =
+            [("f".to_string(), fp(3, None))].into_iter().collect();
+        assert_eq!(pairing_collisions(&source, &dest), vec!["f"]);
+    }
+
+    #[test]
+    fn parse_ls_tree_long_reads_blobs_with_sizes() {
+        let out = b"100644 blob aaa111    6\tsrc/a.rs\x00100755 blob bbb222   12\tb in.sh\x00160000 commit ccc333       -\tsub\x00";
+        let m = parse_ls_tree_long(out);
+        assert_eq!(m.len(), 2, "submodules/commits carry no bytes and are skipped");
+        assert_eq!(m["src/a.rs"], fp(6, Some("aaa111")));
+        assert_eq!(m["b in.sh"], fp(12, Some("bbb222")));
+    }
+
+    #[test]
+    fn pairing_dest_probe_error_is_symmetric() {
+        let clean = PeerSnapshot::default();
+        let errored = PeerSnapshot { probe_error: true, ..Default::default() };
+        // Source local ⇒ the host is the side we'd init+reset: its probe error blocks.
+        assert!(pairing_dest_probe_error(true, &clean, &errored));
+        assert!(!pairing_dest_probe_error(true, &errored, &clean));
+        // Source remote ⇒ the mirror is the dest (the case that was already guarded).
+        assert!(pairing_dest_probe_error(false, &errored, &clean));
+        assert!(!pairing_dest_probe_error(false, &clean, &errored));
+        assert!(!pairing_dest_probe_error(true, &clean, &clean));
+    }
+
+    // ── #28p D4: disconnected ────────────────────────────────────────────────
+
+    #[tokio::test]
+    async fn cold_pool_reads_as_disconnected_not_connected() {
+        // The gate every writing path checks: an empty pool is not a connection, so no
+        // probe ever runs and no host state is believed (a dropped SSH exits non-zero,
+        // which `probe` would otherwise read as "the host is a clean, empty side").
+        let pool = crate::services::remote::new_pool();
+        assert!(!connected(&pool, "no-such-project").await);
+    }
+
+    #[test]
+    fn disconnected_state_keeps_heads_and_drops_the_early_out() {
+        let prior = GitPeerState {
+            enabled: true,
+            status: SyncStatus::Synchronized,
+            local_head: Some(HeadRef::Branch { name: "main".into(), sha: "a".into() }),
+            remote_head: Some(HeadRef::Branch { name: "main".into(), sha: "a".into() }),
+            local_sig: Some("sig".into()),
+            remote_sig: Some("sig".into()),
+            ..Default::default()
+        };
+        let s = disconnected_state(&prior);
+        assert_eq!(s.status, SyncStatus::Disconnected);
+        assert!(s.enabled, "the opt-in survives a dropped link");
+        assert_eq!(s.local_head, prior.local_head, "last-known heads are still shown");
+        // Signatures must not persist across a disconnect, else the first pass after
+        // reconnecting could early-out on a stale green.
+        assert!(s.local_sig.is_none() && s.remote_sig.is_none());
+    }
+
+    // ── #28p D5: batched probe + ancestry + early-out ────────────────────────
+
+    #[test]
+    fn parse_probe_block_round_trips_a_synthesized_block() {
+        let block = format!(
+            "repo{RS}main\n{RS}abc123\n{RS}abc123 main\ndef456 feat\n{RS}t1t1 v1.0\n{RS} M src/a.rs\n?? new\n{RS}Fix the thing\n"
+        );
+        let s = parse_probe_block(&block).expect("parses");
+        assert!(s.is_repo && !s.probe_error);
+        assert_eq!(s.head, Some(HeadRef::Branch { name: "main".into(), sha: "abc123".into() }));
+        assert_eq!(s.branches.len(), 2);
+        assert_eq!(s.branches[1].name, "feat");
+        assert_eq!(s.tags, vec![RefEntry { name: "v1.0".into(), sha: "t1t1".into() }]);
+        assert!(s.dirty_tracked, "a tracked modification, despite the ?? line");
+        assert_eq!(s.head_subject.as_deref(), Some("Fix the thing"));
+    }
+
+    #[test]
+    fn parse_probe_block_tolerates_empty_sections_and_a_non_repo() {
+        // Unborn HEAD, no branches, no tags, clean tree, no subject.
+        let s = parse_probe_block(&format!("repo{RS}{RS}{RS}{RS}{RS}{RS}")).expect("parses");
+        assert!(s.is_repo);
+        assert_eq!(s.head, Some(HeadRef::Unborn));
+        assert!(s.branches.is_empty() && s.tags.is_empty() && !s.dirty_tracked);
+        assert!(s.head_subject.is_none());
+
+        let none = parse_probe_block("norepo").expect("parses");
+        assert!(!none.is_repo && !none.probe_error);
+
+        // Garbage (no POSIX sh, or a link that died mid-script) → the caller must fall
+        // back to the per-command probe rather than believe a half-read snapshot.
+        assert!(parse_probe_block("").is_none());
+        assert!(parse_probe_block("sh: 1: git: not found\n").is_none());
+    }
+
+    #[test]
+    fn ancestry_script_and_block_round_trip() {
+        let pairs = vec![
+            ("aaa".to_string(), "bbb".to_string()),
+            ("ccc".to_string(), "ddd".to_string()),
+        ];
+        let script = ancestry_script(&pairs);
+        assert!(script.contains("merge-base --is-ancestor aaa bbb"));
+        assert!(script.contains("merge-base --is-ancestor bbb aaa"));
+
+        assert_eq!(
+            parse_ancestry_block("10\n01\n", 2),
+            Some(vec![(true, false), (false, true)])
+        );
+        assert_eq!(parse_ancestry_block("00\n11\n", 2), Some(vec![(false, false), (true, true)]));
+        // A misaligned answer is never used: a wrong bit here would misclassify a
+        // divergence, so the caller falls back to per-branch checks instead.
+        assert_eq!(parse_ancestry_block("10\n", 2), None);
+        assert_eq!(parse_ancestry_block("", 1), None);
+    }
+
+    /// Run a script through a real POSIX `sh` in `dir`, exactly as
+    /// `ssh_exec::run_remote_script` has the remote shell run it. A syntax error here
+    /// would make every remote probe fall back to the six-round-trip path *silently* —
+    /// D5 would look implemented and do nothing.
+    #[cfg(unix)]
+    fn run_sh(dir: &Path, script: &str) -> String {
+        let out = std::process::Command::new("sh")
+            .arg("-c")
+            .arg(format!("cd {} && {{ {script}\n}}", dir.display()))
+            .output()
+            .expect("sh");
+        assert!(
+            out.status.success(),
+            "script failed: {}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        String::from_utf8_lossy(&out.stdout).to_string()
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn probe_script_runs_in_a_real_shell_and_parses() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping probe_script_runs_in_a_real_shell_and_parses");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let sha = repo_behind_by_one(dir); // leaves `main` checked out, `feat` ahead
+        std::fs::write(dir.join("base.txt"), b"edited\n").unwrap(); // tracked, dirty
+
+        let snap = parse_probe_block(&run_sh(dir, PROBE_SCRIPT))
+            .expect("the batched probe must parse its own script's output");
+        assert!(snap.is_repo && !snap.probe_error);
+        assert!(matches!(&snap.head, Some(HeadRef::Branch { name, .. }) if name == "main"));
+        assert_eq!(snap.branches.len(), 2, "main + feat");
+        assert!(snap.branches.iter().any(|b| b.name == "feat" && b.sha == sha));
+        assert!(snap.dirty_tracked);
+        assert_eq!(snap.head_subject.as_deref(), Some("base"));
+
+        // The one-round-trip answer must match the six-round-trip one it replaces.
+        let per_cmd = probe_per_command(&Peer::Local(dir.to_path_buf()));
+        assert_eq!(snap.head, per_cmd.head);
+        assert_eq!(snap.dirty_tracked, per_cmd.dirty_tracked);
+        assert_eq!(snap.branches.len(), per_cmd.branches.len());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn probe_script_reports_a_non_repo_dir() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let snap = parse_probe_block(&run_sh(tmp.path(), PROBE_SCRIPT)).expect("parses");
+        assert!(!snap.is_repo);
+        // A clean "not a repo" is a legitimately-empty side we may pair into — it must
+        // never be confused with a probe that could not run (which would license a wipe).
+        assert!(!snap.probe_error);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn ancestry_script_runs_in_a_real_shell_and_agrees_with_merge_base() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping ancestry_script_runs_in_a_real_shell");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let feat = repo_behind_by_one(dir);
+        let peer = Peer::Local(dir.to_path_buf());
+        let main = String::from_utf8_lossy(&peer.run(&["rev-parse", "main"]).unwrap().stdout)
+            .trim()
+            .to_string();
+
+        // main is strictly behind feat → (dest=main is ancestor of source=feat) = true,
+        // and the reverse false. Plus a self-pair, which is an ancestor of itself.
+        let pairs = vec![(main.clone(), feat.clone()), (feat.clone(), feat.clone())];
+        let out = run_sh(dir, &ancestry_script(&pairs));
+        let got = parse_ancestry_block(&out, 2).expect("batched ancestry must parse");
+        assert_eq!(got, vec![(true, false), (true, true)]);
+
+        // And it agrees with the per-pair `merge-base` calls it replaces.
+        let fallback: Vec<(bool, bool)> = pairs
+            .iter()
+            .map(|(d, s)| (is_ancestor(&peer, d, s), is_ancestor(&peer, s, d)))
+            .collect();
+        assert_eq!(got, fallback);
+    }
+
+    #[test]
+    fn is_hex_sha_gates_what_reaches_the_shell() {
+        assert!(is_hex_sha("abc123"));
+        assert!(!is_hex_sha(""));
+        assert!(!is_hex_sha("abc; rm -rf /"));
+        assert!(!is_hex_sha("$(whoami)"));
+    }
+
+    #[test]
+    fn early_out_only_when_green_and_nothing_moved() {
+        let snap = PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Branch { name: "main".into(), sha: "a".into() }),
+            branches: vec![RefEntry { name: "main".into(), sha: "a".into() }],
+            ..Default::default()
+        };
+        let sig = refs_signature(&snap);
+        let green = GitPeerState {
+            status: SyncStatus::Synchronized,
+            local_sig: Some(sig.clone()),
+            remote_sig: Some(sig.clone()),
+            ..Default::default()
+        };
+        assert!(can_early_out(&green, &sig, &sig, true, false));
+        // A moved ref on either side.
+        assert!(!can_early_out(&green, "other", &sig, true, false));
+        assert!(!can_early_out(&green, &sig, "other", true, false));
+        // A manual Retry always looks (the user may have cleared a blocker that moved
+        // no ref at all — deleting an untracked collision, say).
+        assert!(!can_early_out(&green, &sig, &sig, true, true));
+        // Never skip a pass that has real work: a red state, or an unpaired side.
+        let red = GitPeerState { status: SyncStatus::Desynchronized, ..green.clone() };
+        assert!(!can_early_out(&red, &sig, &sig, true, false));
+        assert!(!can_early_out(&green, &sig, &sig, false, false));
+        // A first-ever pass has no signatures to compare against.
+        assert!(!can_early_out(&GitPeerState::default(), &sig, &sig, true, false));
+    }
+
+    #[test]
+    fn refs_signature_moves_when_dirty_flips() {
+        // A dirty→clean transition can unblock a fast-forward, so it must not be
+        // invisible to the early-out.
+        let clean = PeerSnapshot { is_repo: true, ..Default::default() };
+        let dirty = PeerSnapshot { is_repo: true, dirty_tracked: true, ..Default::default() };
+        assert_ne!(refs_signature(&clean), refs_signature(&dirty));
+    }
+
+    // ── Out-of-step HEADs (live-QA case 17/19) ───────────────────────────────
+
+    fn on_branch(name: &str, sha: &str) -> PeerSnapshot {
+        PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Branch { name: name.into(), sha: sha.into() }),
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn peers_on_the_same_head_are_in_step() {
+        assert_eq!(head_mismatch(&on_branch("main", "aaa"), &on_branch("main", "aaa")), None);
+        // Nothing observed on a side → nothing to claim.
+        assert_eq!(head_mismatch(&on_branch("main", "aaa"), &PeerSnapshot::default()), None);
+    }
+
+    #[test]
+    fn peers_on_different_branches_are_not_green() {
+        // The live failure: every ref matched on both sides, so `reconcile_with` — which
+        // compares only refs — called it Synchronized while the mirror sat on `master`
+        // and the host on `feat-x`. A half-landed checkout is not "in step".
+        let msg = head_mismatch(&on_branch("master", "aaa"), &on_branch("feat-x", "bbb"))
+            .expect("different branches must not be green");
+        assert!(msg.contains("master") && msg.contains("feat-x"), "{msg}");
+    }
+
+    #[test]
+    fn detached_peer_is_reported_against_a_branch() {
+        let detached = PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Detached { sha: "cafebabe1234".into() }),
+            ..Default::default()
+        };
+        let msg = head_mismatch(&on_branch("main", "aaa"), &detached).expect("out of step");
+        assert!(msg.contains("detached at cafebabe"), "{msg}");
+    }
+
+    // ── #28p D6: backup refs ─────────────────────────────────────────────────
+
+    #[test]
+    fn backup_ref_name_round_trips_through_the_parser() {
+        for branch in ["main", "feature/x", "tags/v1"] {
+            let name = backup_ref_name(branch, 1735689600);
+            assert_eq!(
+                parse_backup_ref_name(&name),
+                Some((1735689600, branch.to_string()))
+            );
+        }
+        assert_eq!(parse_backup_ref_name("refs/heads/main"), None);
+        assert_eq!(parse_backup_ref_name("refs/eldrun/backup/notanumber/x"), None);
+    }
+
+    #[test]
+    fn parse_backup_refs_reads_for_each_ref_output() {
+        let out = "aaa\trefs/eldrun/backup/100/main\tOld tip\n\
+                   bbb\trefs/eldrun/backup/200/feature/x\tNewer tip\n\
+                   ccc\trefs/heads/main\tnot a backup\n";
+        let refs = parse_backup_refs("local", out);
+        assert_eq!(refs.len(), 2);
+        assert_eq!(refs[0].ts, 200, "newest first");
+        assert_eq!(refs[0].branch, "feature/x");
+        assert_eq!(refs[0].peer, "local");
+        assert_eq!(refs[1].subject, "Old tip");
+    }
+
+    #[test]
+    fn select_prunable_keeps_the_newest_n_and_anything_recent() {
+        let now = 1_800_000_000u64; // a plausible epoch; must exceed the ages below
+        let day = 24 * 60 * 60;
+        let mk = |ts: u64| BackupRef {
+            peer: "local".into(),
+            refname: format!("refs/eldrun/backup/{ts}/main"),
+            ts,
+            branch: "main".into(),
+            sha: "a".into(),
+            subject: String::new(),
+        };
+        // Three ancient, two recent.
+        let refs = vec![
+            mk(now - 100 * day),
+            mk(now - 90 * day),
+            mk(now - 80 * day),
+            mk(now - 2 * day),
+            mk(now - day),
+        ];
+        // keep_n=2 → the two newest survive on count; the recent ones survive on age
+        // anyway; the three ancient ones beyond the count go.
+        let pruned = select_prunable(&refs, now, 2, 30 * day);
+        assert_eq!(pruned.len(), 3);
+        assert!(pruned.iter().all(|r| r.contains(&format!("{}", now - 100 * day))
+            || r.contains(&format!("{}", now - 90 * day))
+            || r.contains(&format!("{}", now - 80 * day))));
+
+        // Age alone protects a ref even past the count.
+        assert!(select_prunable(&refs, now, 0, 30 * day).len() == 3);
+        // The newest is NEVER pruned, however aggressive the policy.
+        let all_ancient = vec![mk(now - 100 * day), mk(now - 99 * day)];
+        let pruned = select_prunable(&all_ancient, now, 0, 0);
+        assert_eq!(pruned.len(), 1);
+        assert!(pruned[0].contains(&format!("{}", now - 100 * day)));
+        assert!(select_prunable(&[], now, 0, 0).is_empty());
+    }
+
+    // ── #28p D7: origin propagation ──────────────────────────────────────────
+
+    #[test]
+    fn origin_propagates_only_into_a_dest_that_has_none() {
+        assert_eq!(
+            should_propagate_origin(Some("git@github.com:me/p.git"), None),
+            Some("git@github.com:me/p.git".to_string())
+        );
+        // The dest already has its own origin → never overwritten.
+        assert_eq!(
+            should_propagate_origin(Some("git@github.com:me/p.git"), Some("git@other:x.git")),
+            None
+        );
+        // Nothing to propagate.
+        assert_eq!(should_propagate_origin(None, None), None);
+        assert_eq!(should_propagate_origin(Some("  "), None), None);
+    }
+
+    // ── #28p D8: peer refs for a hand-resolved divergence ────────────────────
+
+    #[test]
+    fn only_diverged_branches_park_a_peer_ref() {
+        assert_eq!(peer_ref_op(RefAction::Diverged, false), PeerRefOp::Set);
+        // Everything in step (or already resolved) clears the ref, so it never outlives
+        // the divergence it documents.
+        assert_eq!(peer_ref_op(RefAction::InSync, false), PeerRefOp::Delete);
+        assert_eq!(peer_ref_op(RefAction::FastForwardDest, false), PeerRefOp::Delete);
+        assert_eq!(peer_ref_op(RefAction::CreateOnDest, false), PeerRefOp::Delete);
+        assert_eq!(peer_ref_op(RefAction::DestAhead, false), PeerRefOp::Delete);
+        // A forced pass RESOLVES the divergence, so it clears rather than parks.
+        assert_eq!(peer_ref_op(RefAction::Diverged, true), PeerRefOp::Delete);
+        assert_eq!(peer_ref_name("feature/x"), "refs/eldrun/peer/feature/x");
+    }
+
+    // ── #28p D9: force-reset collisions ──────────────────────────────────────
+
+    /// A fresh repo at `dir` with one commit tracking `path` = `content`. Returns the
+    /// commit sha.
+    fn init_repo_with_file(dir: &Path, path: &str, content: &[u8]) -> String {
+        let git = |args: &[&str]| {
+            crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git")
+        };
+        git(&["init", "-q", "."]);
+        git(&["config", "user.email", "t@e"]);
+        git(&["config", "user.name", "t"]);
+        std::fs::write(dir.join(path), content).unwrap();
+        git(&["add", path]);
+        git(&["commit", "-qm", "add"]);
+        String::from_utf8_lossy(&git(&["rev-parse", "HEAD"]).stdout)
+            .trim()
+            .to_string()
+    }
+
+    #[test]
+    fn reset_collisions_flags_only_the_differing_source_tracked_path() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping reset_collisions_flags_only_the_differing_source_tracked_path");
+            return;
+        }
+        let src_tmp = tempfile::tempdir().expect("tempdir");
+        let sha = init_repo_with_file(src_tmp.path(), "keep.txt", b"committed content\n");
+        let source = Peer::Local(src_tmp.path().to_path_buf());
+
+        let dst_tmp = tempfile::tempdir().expect("tempdir");
+        let dst = dst_tmp.path();
+        crate::paths::command_no_window("git")
+            .args(["init", "-q", "."])
+            .current_dir(dst)
+            .output()
+            .expect("git init");
+        // Differs from what the target sha tracks → at risk.
+        std::fs::write(dst.join("keep.txt"), b"MY UNSAVED WORK\n").unwrap();
+        // Untracked but not something the source's tree even mentions → never at risk.
+        std::fs::write(dst.join("other.txt"), b"unrelated\n").unwrap();
+        let dest = Peer::Local(dst.to_path_buf());
+
+        assert_eq!(reset_collisions(&source, &dest, &sha), vec!["keep.txt"]);
+    }
+
+    #[test]
+    fn reset_collisions_allows_byte_identical_untracked_files() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping reset_collisions_allows_byte_identical_untracked_files");
+            return;
+        }
+        let src_tmp = tempfile::tempdir().expect("tempdir");
+        let sha = init_repo_with_file(src_tmp.path(), "keep.txt", b"committed content\n");
+        let source = Peer::Local(src_tmp.path().to_path_buf());
+
+        let dst_tmp = tempfile::tempdir().expect("tempdir");
+        let dst = dst_tmp.path();
+        crate::paths::command_no_window("git")
+            .args(["init", "-q", "."])
+            .current_dir(dst)
+            .output()
+            .expect("git init");
+        std::fs::write(dst.join("keep.txt"), b"committed content\n").unwrap();
+        let dest = Peer::Local(dst.to_path_buf());
+
+        assert!(
+            reset_collisions(&source, &dest, &sha).is_empty(),
+            "byte-identical untracked content is a no-op for reset --hard, not a collision"
+        );
+    }
+
+    #[test]
+    fn reset_collisions_within_a_single_peer_detects_the_restore_backup_case() {
+        // `restore_backup` calls this with source_peer == dest_peer: the backup ref
+        // and the untracked collision live on the same repo.
+        if !git_available() {
+            eprintln!("git not on PATH — skipping reset_collisions_within_a_single_peer_detects_the_restore_backup_case");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let backup_sha = init_repo_with_file(dir, "secret.env", b"old committed secret\n");
+        let git = |args: &[&str]| {
+            crate::paths::command_no_window("git")
+                .args(args)
+                .current_dir(dir)
+                .output()
+                .expect("git")
+        };
+        // A later commit untracks the path (the shape restoring an OLDER backup onto
+        // a repo that has since moved on produces), then the now-untracked file is
+        // edited — real, never-committed work sitting where the backup would land it.
+        git(&["rm", "-q", "--cached", "secret.env"]);
+        git(&["commit", "-qm", "untrack secret"]);
+        std::fs::write(dir.join("secret.env"), b"NEW LOCAL WORK\n").unwrap();
+
+        let peer = Peer::Local(dir.to_path_buf());
+        assert_eq!(reset_collisions(&peer, &peer, &backup_sha), vec!["secret.env"]);
+    }
+
+    #[test]
+    fn state_default_is_disabled_and_synchronized() {
+        let s = GitPeerState::default();
+        assert!(!s.enabled);
+        assert_eq!(s.status, SyncStatus::Synchronized);
+    }
+
+    #[test]
+    fn state_roundtrips_camelcase() {
+        let s = GitPeerState {
+            enabled: true,
+            status: SyncStatus::Desynchronized,
+            detail: Some("Diverged: main".into()),
+            local_head: Some(HeadRef::Branch { name: "main".into(), sha: "a".into() }),
+            remote_head: Some(HeadRef::Detached { sha: "b".into() }),
+            last_sync_ts: Some(42),
+            local_subject: Some("Fix it".into()),
+            remote_subject: None,
+            pairing_conflict: Some(PairingConflict {
+                source_is_local: true,
+                paths: vec!["README.md".into()],
+            }),
+            local_sig: None,
+            remote_sig: None,
+        };
+        let json = serde_json::to_string(&s).unwrap();
+        assert!(json.contains("\"lastSyncTs\":42"));
+        assert!(json.contains("\"localHead\""));
+        assert!(json.contains("\"kind\":\"branch\""));
+        assert!(json.contains("\"desynchronized\""));
+        assert!(json.contains("\"pairingConflict\""));
+        assert!(json.contains("\"sourceIsLocal\":true"));
+        let back: GitPeerState = serde_json::from_str(&json).unwrap();
+        assert_eq!(back.status, SyncStatus::Desynchronized);
+        assert_eq!(back.remote_head, Some(HeadRef::Detached { sha: "b".into() }));
+        assert_eq!(back.pairing_conflict.unwrap().paths, vec!["README.md"]);
+    }
+
+    #[test]
+    fn state_from_before_28p_still_loads() {
+        // Every field #28p added is `#[serde(default)]`, so a `git_peer.json` written by
+        // the shipped #28n build keeps working instead of resetting the opt-in.
+        let old = r#"{"enabled":true,"status":"synchronized","detail":null,
+                      "localHead":{"kind":"unborn"},"remoteHead":null,"lastSyncTs":7}"#;
+        let s: GitPeerState = serde_json::from_str(old).unwrap();
+        assert!(s.enabled);
+        assert_eq!(s.status, SyncStatus::Synchronized);
+        assert!(s.pairing_conflict.is_none() && s.local_sig.is_none());
+    }
+
+    // ── The half-seeded host: `git init` ran, the checkout never did ─────────
+    //
+    // Live failure (DemoProj, extend-local-to-remote): the host ended up holding a
+    // `.git` and an empty working tree, permanently, and the pill blamed a branch that
+    // existed on neither side ("the mirror is on 'transfer-learning', the host is on
+    // 'master'"). Three bugs in series; one test each, plus the gate that repairs it.
+
+    /// Bug 1. `git rev-parse HEAD` on an unborn repo prints the literal `HEAD` to
+    /// **stdout** and reports the failure only in its exit status. `PROBE_SCRIPT`
+    /// discarded that status, so `parse_head` was handed `("master", "HEAD")` and built
+    /// `Branch { name: "master", sha: "HEAD" }` — a branch nobody has, at a sha that is
+    /// not a sha. `parse_head` now demands a real object name, so no probe, however
+    /// broken, can fabricate a checked-out branch again.
+    #[test]
+    fn parse_head_never_invents_a_branch_from_a_non_sha() {
+        assert_eq!(parse_head("master", "HEAD"), HeadRef::Unborn);
+        assert_eq!(parse_head("", "HEAD"), HeadRef::Unborn);
+        assert_eq!(parse_head("main", ""), HeadRef::Unborn);
+        assert_eq!(parse_head("main", "not-a-sha"), HeadRef::Unborn);
+        // …while a real head still parses exactly as before.
+        assert_eq!(
+            parse_head("main", "abc123"),
+            HeadRef::Branch { name: "main".into(), sha: "abc123".into() }
+        );
+        assert_eq!(parse_head("", "abc123"), HeadRef::Detached { sha: "abc123".into() });
+    }
+
+    /// Bug 1, at the level that actually shipped. `parse_probe_block_tolerates_empty_
+    /// sections_and_a_non_repo` already asserted "unborn → `HeadRef::Unborn`", and passed
+    /// throughout — because it *synthesized* the block by hand with an empty sha section,
+    /// encoding the very assumption that was false. So: drive the real `PROBE_SCRIPT`
+    /// through a real `sh` against a real `git init`ed repo, and read what git actually
+    /// prints. This is the test that would have caught it.
+    #[cfg(unix)]
+    #[test]
+    fn probe_script_reports_a_real_unborn_repo_as_unborn() {
+        if !git_available() {
+            eprintln!("git not on PATH — skipping probe_script_reports_a_real_unborn_repo");
+            return;
+        }
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        crate::paths::command_no_window("git")
+            .args(["init", "-q", "-b", "master", "."])
+            .current_dir(dir)
+            .output()
+            .expect("git init");
+
+        let snap = parse_probe_block(&run_sh(dir, PROBE_SCRIPT)).expect("parses");
+        assert!(snap.is_repo, "a bare `git init` IS a repo…");
+        assert_eq!(
+            snap.head,
+            Some(HeadRef::Unborn),
+            "…but its HEAD is unborn — NOT `Branch {{ name: \"master\", sha: \"HEAD\" }}`"
+        );
+        assert!(snap.branches.is_empty() && snap.head_subject.is_none());
+        // The batched remote probe and the per-command local one must agree about what
+        // unborn looks like, or the bug simply moves to whichever path a peer takes.
+        assert_eq!(snap.head, probe_per_command(&Peer::Local(dir.to_path_buf())).head);
+        // And the whole point: this side is not seeded, so it is still pairable.
+        assert!(!is_seeded(&snap));
+    }
+
+    /// Bug 2. The pairing gate keyed on `is_repo`, but `git init` is pairing's own first
+    /// step — so a seed that died after it flipped the gate shut behind itself. The dest
+    /// was a repo forever after, "exactly one side is a repo" never fired again, and the
+    /// steady-state path only ever moves refs (`update-ref`); it never positions HEAD or
+    /// checks out. Hence: objects and refs on the host, empty tree, forever.
+    #[test]
+    fn a_bare_git_init_is_not_seeded_and_stays_pairable() {
+        let unborn = PeerSnapshot { is_repo: true, head: Some(HeadRef::Unborn), ..Default::default() };
+        let seeded = PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Branch { name: "transfer-learning".into(), sha: "a5b535d".into() }),
+            branches: vec![RefEntry { name: "transfer-learning".into(), sha: "a5b535d".into() }],
+            ..Default::default()
+        };
+        let absent = PeerSnapshot::default();
+
+        assert!(!is_seeded(&absent), "not a repo");
+        assert!(!is_seeded(&unborn), "a repo, but nothing is checked out");
+        assert!(is_seeded(&seeded));
+        assert!(is_seeded(&PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Detached { sha: "abc123".into() }),
+            ..Default::default()
+        }));
+
+        // The live case: mirror seeded, host `git init`ed and never checked out.
+        assert_eq!(
+            pair_plan(&seeded, &unborn),
+            PairPlan::Pair { source_is_local: true },
+            "the half-seeded host must be re-paired, not treated as a peer"
+        );
+        // Under the old `is_repo` gate this was `Sync` — which moved refs and never a
+        // single file, which is exactly how it wedged.
+        assert!(seeded.is_repo && unborn.is_repo, "…and both ARE repos, which is the trap");
+
+        assert_eq!(pair_plan(&seeded, &absent), PairPlan::Pair { source_is_local: true });
+        assert_eq!(pair_plan(&absent, &seeded), PairPlan::Pair { source_is_local: false });
+        assert_eq!(pair_plan(&seeded, &seeded), PairPlan::Sync);
+        assert_eq!(pair_plan(&absent, &absent), PairPlan::Nothing);
+        assert_eq!(pair_plan(&unborn, &unborn), PairPlan::Nothing, "nothing to move either way");
+    }
+
+    /// The nastiest shape of bug 2: the refs DID land (the steady-state pass creates them
+    /// with `update-ref`), so the host looks populated by every measure except the only
+    /// one that matters — whether anything is checked out. A gate that looked at branches
+    /// rather than HEAD would call this seeded and wedge exactly as before.
+    #[test]
+    fn a_host_with_refs_but_no_checkout_is_still_unseeded() {
+        let mirror = PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Branch { name: "transfer-learning".into(), sha: "a5b535d".into() }),
+            branches: vec![RefEntry { name: "transfer-learning".into(), sha: "a5b535d".into() }],
+            ..Default::default()
+        };
+        // Every ref arrived; HEAD is still unborn. Empty working tree.
+        let host = PeerSnapshot {
+            is_repo: true,
+            head: Some(HeadRef::Unborn),
+            branches: vec![
+                RefEntry { name: "transfer-learning".into(), sha: "a5b535d".into() },
+                RefEntry { name: "main".into(), sha: "64bd1c3".into() },
+            ],
+            ..Default::default()
+        };
+        assert!(!is_seeded(&host), "refs are not a checkout");
+        assert_eq!(pair_plan(&mirror, &host), PairPlan::Pair { source_is_local: true });
+    }
+
+    /// Bug 3's other half: a half-seeded side must never be able to *early-out* of the
+    /// very pass that would repair it. `can_early_out` now gates on both sides being
+    /// seeded, not on both being repos.
+    #[test]
+    fn early_out_never_skips_a_half_seeded_side() {
+        let prior = GitPeerState {
+            status: SyncStatus::Synchronized,
+            local_sig: Some("sig".into()),
+            remote_sig: Some("sig".into()),
+            ..Default::default()
+        };
+        assert!(
+            can_early_out(&prior, "sig", "sig", true, false),
+            "both seeded + green + unmoved → skip, as before"
+        );
+        assert!(
+            !can_early_out(&prior, "sig", "sig", false, false),
+            "a side that was never checked out must always be re-examined"
+        );
+    }
+
+    /// The constraint on the repair: it must never cost the user a local file. When the
+    /// mirror is the unseeded side, pairing writes *it* — so the D3 collision guard is
+    /// what stands between `reset --hard` and the user's untracked work, and it must fail
+    /// CLOSED. A dest file that cannot be proven byte-identical to what the source would
+    /// write over it (`hash: None` — the hash could not be computed) is a conflict, which
+    /// blocks the pairing and raises the prompt instead of clobbering.
+    #[test]
+    fn pairing_into_the_mirror_refuses_to_clobber_unproven_local_files() {
+        let source: HashMap<String, Fingerprint> = [
+            ("README.md".to_string(), Fingerprint { size: 10, hash: Some("aaa".into()) }),
+            ("src/a.rs".to_string(), Fingerprint { size: 20, hash: Some("bbb".into()) }),
+        ]
+        .into_iter()
+        .collect();
+
+        // Same path, same size, but the hash could not be established → NOT provably
+        // identical → refused rather than overwritten.
+        let unproven: HashMap<String, Fingerprint> =
+            [("README.md".to_string(), Fingerprint { size: 10, hash: None })].into_iter().collect();
+        assert_eq!(pairing_collisions(&source, &unproven), vec!["README.md".to_string()]);
+
+        // Differing content → refused.
+        let differs: HashMap<String, Fingerprint> =
+            [("src/a.rs".to_string(), Fingerprint { size: 20, hash: Some("zzz".into()) })]
+                .into_iter()
+                .collect();
+        assert_eq!(pairing_collisions(&source, &differs), vec!["src/a.rs".to_string()]);
+
+        // Byte-identical → adopting it is a no-op, so pairing proceeds (the intended
+        // "the mirror already holds these files" path).
+        let identical: HashMap<String, Fingerprint> =
+            [("README.md".to_string(), Fingerprint { size: 10, hash: Some("aaa".into()) })]
+                .into_iter()
+                .collect();
+        assert!(pairing_collisions(&source, &identical).is_empty());
+
+        // A local file the source does not track is not a collision at all — and
+        // `reset --hard` never removes untracked paths, so it survives the pairing.
+        let untracked: HashMap<String, Fingerprint> =
+            [("data/big.npz".to_string(), Fingerprint { size: 999, hash: None })]
+                .into_iter()
+                .collect();
+        assert!(pairing_collisions(&source, &untracked).is_empty());
+    }
+}
diff --git a/src-tauri/src/services/hpc_mode.rs b/src-tauri/src/services/hpc_mode.rs
new file mode 100644
index 0000000..15577c5
--- /dev/null
+++ b/src-tauri/src/services/hpc_mode.rs
@@ -0,0 +1,255 @@
+//! Which remote hosts Eldrun treats as **HPC hosts**, and therefore samples
+//! carefully.
+//!
+//! A shared cluster login node runs under usage rules an ordinary dev box does
+//! not (`docs/context/hpc_careful_mode.md`): other users' account names may not
+//! be determined, information about them that happens to be readable may not be
+//! used, and a login node is not to carry a sustained background load. Eldrun's
+//! two host probes — the monitor snapshot (`sysstat::REMOTE_SNAPSHOT_SCRIPT`)
+//! and the connect-time usage check (`services::remote_usage`) — therefore have
+//! a *careful* variant that collects strictly less.
+//!
+//! **Detection lives on the host**: each probe script asks whether SLURM is on
+//! `PATH` and reports the answer back in its own output, so nothing here has to
+//! guess from a hostname (which would be both unreliable and, for a hostname of
+//! someone's institution, not ours to hardcode). This module is only the
+//! *memory* of that answer, keyed by SSH target, so a caller that has no probe
+//! result in hand — the connect path, deciding whether to fire the usage check
+//! at all — can still act on what the last probe learned.
+//!
+//! The memory is process-lifetime only and deliberately one-way: a host may be
+//! marked careful, and nothing un-marks it while Eldrun runs. A false "careful"
+//! costs a slightly thinner monitor pane; a false "ordinary" costs a rule
+//! violation, so the asymmetry is the point.
+
+use std::collections::HashSet;
+use std::sync::Mutex;
+
+use crate::schema::project::RemoteSpec;
+
+static CAREFUL_HOSTS: Mutex<Option<HashSet<String>>> = Mutex::new(None);
+
+/// Identity of an SSH target for this registry: `user@host:port`, from
+/// `ssh_common::target_key` — the single implementation, shared with the
+/// frontend's `targetKey`.
+///
+/// This module used to spell the same format out a second time. Two copies of a
+/// key that must stay byte-identical do not fail loudly when they drift: the
+/// lookup simply finds nothing, and "nothing" reads as *not careful, not
+/// tagged* — failing open, in exactly the case both flags exist to close.
+pub fn key_for(spec: &RemoteSpec) -> String {
+    crate::services::ssh_common::target_key(spec.user.as_deref(), &spec.host, spec.port)
+}
+
+/// Record what a probe found. Only `true` is remembered (see the module note on
+/// the one-way asymmetry).
+pub fn remember(key: &str, careful: bool) {
+    if !careful {
+        return;
+    }
+    let mut guard = CAREFUL_HOSTS.lock().unwrap();
+    guard.get_or_insert_with(HashSet::new).insert(key.to_string());
+}
+
+/// Whether a previous probe reported this target as an HPC host. `false` for a
+/// target never probed — the probes themselves detect on the host, so an unknown
+/// target is never sampled wrongly, it just isn't gated yet.
+pub fn is_known_careful(key: &str) -> bool {
+    CAREFUL_HOSTS
+        .lock()
+        .unwrap()
+        .as_ref()
+        .is_some_and(|s| s.contains(key))
+}
+
+/// The user's **explicit** per-machine answer from `settings.careful_hosts`
+/// (the system monitor's Light/Detailed switch, and the connect dialog's "Go
+/// easy on this machine"), or `None` where they have not answered for this
+/// target. Keyed by [`key_for`], which is byte-identical to the frontend's
+/// `targetKey` — a divergence would silently look up a host nobody wrote.
+pub fn stored_answer(key: &str) -> Option<bool> {
+    load_settings()?.careful_hosts?.get(key).copied()
+}
+
+/// How long a `settings.json` reading is reused.
+///
+/// This used to be a fresh read and parse per call, which was fine while the
+/// only callers were one SSH round trip deep. [`is_tagged_hpc`] now also backs
+/// `ssh_common::authorize_dial`, i.e. it runs on **every** ssh argv built, so an
+/// uncached read would put a file open + parse in front of every remote command.
+/// Two seconds is short enough that flipping the tag takes effect while the user
+/// is still looking at the switch — the auto-sync and lockstep loops re-check it
+/// on their own ticks and must see the change — and long enough that a burst of
+/// argv builds costs one read.
+const SETTINGS_TTL: std::time::Duration = std::time::Duration::from_secs(2);
+
+/// `(read at, what it said)`. The value is `Option` because "no settings file"
+/// is itself an answer worth caching, not a reason to retry every call.
+static SETTINGS_CACHE: Mutex<Option<(std::time::Instant, Option<crate::schema::Settings>)>> =
+    Mutex::new(None);
+
+fn load_settings() -> Option<crate::schema::Settings> {
+    if let Ok(cache) = SETTINGS_CACHE.lock() {
+        if let Some((at, settings)) = cache.as_ref() {
+            if at.elapsed() < SETTINGS_TTL {
+                return settings.clone();
+            }
+        }
+    }
+    let path = crate::storage::state_dir().join("settings.json");
+    match crate::storage::read_json::<crate::schema::Settings>(&path) {
+        Ok(fresh) => {
+            if let Ok(mut cache) = SETTINGS_CACHE.lock() {
+                *cache = Some((std::time::Instant::now(), Some(fresh.clone())));
+            }
+            Some(fresh)
+        }
+        // A failed read must NOT be cached. This gate's whole job is to refuse, so
+        // "I could not find out" has to fall back on the last thing we did know —
+        // caching the failure would answer "not tagged" for the whole TTL, which is
+        // the one direction that costs the promise (a mid-write settings.json, an
+        // EMFILE, a momentary permission blip would each open a 2 s window in which
+        // a cluster login node is dialled as if untagged). The stale value is kept
+        // and the next call retries.
+        Err(_) => {
+            if let Ok(cache) = SETTINGS_CACHE.lock() {
+                if let Some((_, prev)) = cache.as_ref() {
+                    return prev.clone();
+                }
+            }
+            None
+        }
+    }
+}
+
+/// Whether the user has tagged this target **HPC** (`settings.hpc_hosts`, the
+/// tick on the login form and the badge on the machine's row).
+///
+/// This is the gate every *behaviour* hangs off — the disk-usage scan, the
+/// giant-folder census, the auto byte-sync and lockstep loops, silent
+/// auto-connect. Unlike careful mode there is no default and no probe: nothing
+/// tags a host but the user, because nothing else can know whether a machine's
+/// operators mind (`sbatch` on `PATH` says a scheduler exists, not that the node
+/// is shared). An untagged host therefore behaves exactly as it always has.
+pub fn is_tagged_hpc(key: &str) -> bool {
+    load_settings()
+        .and_then(|s| s.hpc_hosts)
+        .and_then(|m| m.get(key).copied())
+        .unwrap_or(false)
+}
+
+/// [`is_tagged_hpc`] for a host spec.
+pub fn is_hpc_spec(spec: &RemoteSpec) -> bool {
+    is_tagged_hpc(&key_for(spec))
+}
+
+/// Sentinel carried by a command that refused because its target is tagged HPC
+/// and the user has not confirmed *this* run. Must match `src/lib/hpcGuard.ts`.
+///
+/// The shape is deliberately the one `UNKNOWN_HOST_KEY` already established
+/// (`services::ssh_common::guard_first_contact`): everything the frontend needs
+/// to raise a dialog and retry rides in the error string, so no call site has to
+/// know in advance that its target might be a cluster. The alternative — asking
+/// before every scan — would put the question in front of the 99% of users who
+/// have no cluster at all.
+pub const HPC_GUARD: &str = "ELDRUN_HPC_GUARD";
+
+/// Build the refusal a gated command returns: `ELDRUN_HPC_GUARD <what> <target>`.
+/// `what` is a stable slug the dialog switches its wording on (`du-scan`,
+/// `census`, `login-node-run`, `connect`), `target` the `user@host:port` being
+/// protected.
+pub fn guard_error(what: &str, spec: &RemoteSpec) -> String {
+    guard_error_for(what, &key_for(spec))
+}
+
+/// [`guard_error`] for a caller holding only the target key — the dial policy
+/// (`ssh_common::authorize_dial`), which gates argv builders that never see a
+/// `RemoteSpec`.
+pub fn guard_error_for(what: &str, key: &str) -> String {
+    format!("{HPC_GUARD} {what} {key}")
+}
+
+/// [`is_tagged_hpc`] for a project's host (primary or a `compute_hosts` worker),
+/// resolving the spec itself. `false` for a local project or an unknown host, so
+/// a caller with only ids in hand can gate without plumbing a spec through.
+pub fn project_host_is_hpc(project_id: &str, host_id: &str) -> bool {
+    crate::services::remote::remote_target_for_host(project_id, host_id)
+        .is_some_and(|t| is_hpc_spec(&t.spec))
+}
+
+/// Whether this host should be treated carefully **outside the monitor** — the
+/// connect-time usage probe, which has no frontend answer passed down to it.
+///
+/// The user's explicit answer wins in both directions; with no answer it falls
+/// back to what earlier probes learned, which is what the gate has always done.
+/// Note this is deliberately *not* the frontend's careful-by-default rule: the
+/// probe censors itself host-side either way, and defaulting it off here would
+/// silently retire the busy-host warning for every remote project rather than
+/// only for the machines the user called shared.
+pub fn is_careful_host(spec: &RemoteSpec) -> bool {
+    let key = key_for(spec);
+    // The HPC tag outranks the Light/Detailed answer in one direction only: a
+    // tagged machine is careful even if its careful answer says "this one is
+    // mine". Those two say different things — "how much may Eldrun look at" and
+    // "is this a shared cluster" — and there is no coherent reading of the second
+    // that permits the first's full collection.
+    is_tagged_hpc(&key) || stored_answer(&key).unwrap_or_else(|| is_known_careful(&key))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::services::ssh_common::target_key;
+
+    /// The shape of the key itself is pinned once, in
+    /// `ssh_common::target_key_matches_frontend`; what belongs here is only that
+    /// this registry indexes by *that* key. Spelling the format out again is the
+    /// duplication the second implementation was deleted for.
+    fn key(user: &Option<String>, host: &str, port: Option<u16>) -> String {
+        target_key(user.as_deref(), host, port)
+    }
+
+    /// The asymmetry that keeps a flaky probe from *downgrading* a cluster: once
+    /// a host has said "I am an HPC host", a later probe that fails to detect it
+    /// (SLURM missing from a login shell's `PATH`, say) must not turn the
+    /// reduced collection back off.
+    #[test]
+    fn careful_is_sticky_and_never_cleared() {
+        let k = key(&Some("carol".into()), "sticky.example", None);
+        remember(&k, true);
+        remember(&k, false);
+        assert!(is_known_careful(&k));
+    }
+
+    /// The wire contract with `src/lib/hpcGuard.ts`: sentinel, then the slug the
+    /// dialog switches its wording on, then the target it names. Parsed by
+    /// splitting on whitespace, so neither field may gain a space.
+    #[test]
+    fn guard_error_carries_the_slug_and_the_target() {
+        // Built field-by-field: `RemoteSpec` has no `Default`, and the point of
+        // the assertion is the exact three-token shape the frontend splits.
+        let spec = RemoteSpec {
+            user: Some("alice".into()),
+            host: "login.example".into(),
+            port: None,
+            remote_path: "/home/alice/p".into(),
+            openvpn: None,
+            auto_connect: None,
+            key_auth: None,
+            persist_sessions: None,
+            label: None,
+            extra: Default::default(),
+        };
+        assert_eq!(
+            guard_error("du-scan", &spec),
+            "ELDRUN_HPC_GUARD du-scan alice@login.example:22"
+        );
+        assert_eq!(guard_error("du-scan", &spec).split_whitespace().count(), 3);
+    }
+
+    #[test]
+    fn an_unprobed_target_is_not_known_careful() {
+        assert!(!is_known_careful(&key(&None, "never-probed.example", None)));
+    }
+}
diff --git a/src-tauri/src/services/local_loss.rs b/src-tauri/src/services/local_loss.rs
new file mode 100644
index 0000000..230fbcb
--- /dev/null
+++ b/src-tauri/src/services/local_loss.rs
@@ -0,0 +1,187 @@
+//! Warnings for the local side of a remote project losing something (#28q).
+//!
+//! Two transports write into the local mirror of a remote (SSH) project, and a handful
+//! of those writes *destroy* what is already there: a lockstep fast-forward or
+//! `reset --hard` deletes the tracked files the incoming commit dropped; the `git clean`
+//! that un-blocks a refused fast-forward removes untracked files outright; a confirmed
+//! initial pairing overwrites the colliding mirror files it warned about; and a manual
+//! byte-sync pull overwrites a mirror file that had unsynced local edits.
+//!
+//! Each of those is deliberate, and all but the last are recoverable — but none of them
+//! *said* anything, so from the user's chair a local file simply vanished, usually
+//! during a background pass they never asked for. This module is the record: every
+//! destructive local write appends an entry here, and the UI raises the unacknowledged
+//! ones (`components/common/LocalLossDialog`).
+//!
+//! It is a **file**, not an event, for two reasons that both come from where the writes
+//! happen: `services::{git_peer,sync_auto}` are deliberately `AppHandle`-free, and a
+//! background reconcile can delete a file with no window listening — a warning that
+//! existed only as an event would be dropped exactly when it mattered. The frontend
+//! re-reads this log whenever a lockstep/sync pass reports in, so a loss recorded while
+//! the app was closed still surfaces on the next launch.
+//!
+//! What is deliberately NOT recorded: byte-sync's own reconcile
+//! (`services::sync_auto`), which is non-destructive by construction — it pulls only
+//! when the local side is unchanged, pushes only when the host is, and skips a file
+//! that moved on both sides rather than picking a winner.
+
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+
+/// Keep the log bounded: the newest N entries survive a `record`.
+const MAX_ENTRIES: usize = 50;
+/// Per entry, name at most this many paths (`total` still carries the real count, so a
+/// 900-file `reset --hard` reports honestly without writing 900 strings into the log).
+const MAX_PATHS: usize = 25;
+
+/// What happened to the local file.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum LossKind {
+    /// The file is gone from the mirror.
+    Deleted,
+    /// The file is still there, but content that was only on the local side was
+    /// overwritten by the host's.
+    Overwritten,
+}
+
+/// Which transport did it — the two have very different recovery stories, so the UI
+/// says which one is talking.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum LossSource {
+    /// Git lockstep (`services::git_peer`).
+    Git,
+    /// Byte-sync (`services::remote_sync` / `commands::sync`).
+    Sync,
+}
+
+/// One destructive local write, as the UI shows it.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LocalLoss {
+    /// Unix seconds — also the entry's identity for acknowledgement.
+    pub ts: u64,
+    pub source: LossSource,
+    pub kind: LossKind,
+    /// The operation that did it, as a user-facing phrase ("fast-forward from the
+    /// host"), not a function name.
+    pub op: String,
+    /// Project-relative paths, truncated to [`MAX_PATHS`].
+    pub paths: Vec<String>,
+    /// How many paths there really were (`> paths.len()` when truncated).
+    pub total: usize,
+    /// How to get the content back, when it can be got back. `None` means it cannot —
+    /// which the dialog says in as many words rather than leaving blank.
+    pub recovery: Option<String>,
+    /// Cleared until the user has seen it.
+    #[serde(default)]
+    pub acked: bool,
+}
+
+fn now_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0)
+}
+
+/// `~/.local/share/eldrun/remote-projects/<id>/local_loss.json`. Sits beside
+/// `git_peer.json` in the project's local state dir — the log is about the *local*
+/// mirror, so it belongs on the machine that lost the file, not on the host.
+pub fn log_path(project_id: &str) -> PathBuf {
+    crate::storage::state_dir()
+        .join("remote-projects")
+        .join(project_id)
+        .join("local_loss.json")
+}
+
+/// Every recorded loss for a project, newest first. Empty for a project that has never
+/// lost anything (the overwhelmingly common case, and the reason this never errors).
+pub fn load(project_id: &str) -> Vec<LocalLoss> {
+    crate::storage::read_json(&log_path(project_id)).unwrap_or_default()
+}
+
+fn save(project_id: &str, entries: &[LocalLoss]) {
+    let _ = crate::storage::write_json(&log_path(project_id), &entries);
+}
+
+/// Append a loss and persist. Best-effort throughout: this is the *warning* about a
+/// destructive write, and failing to file it must never turn into a second failure on
+/// top of the first — the callers are all `let _ =`-style recovery paths themselves.
+pub fn record(project_id: &str, loss: LocalLoss) {
+    let mut entries = load(project_id);
+    entries.insert(0, loss);
+    entries.truncate(MAX_ENTRIES);
+    save(project_id, &entries);
+}
+
+/// Record the loss of `paths`, or do nothing at all when it is empty — which is what
+/// makes this safe to call unconditionally from every destructive site, including the
+/// ones that usually destroy nothing. Truncates the path list to [`MAX_PATHS`], keeping
+/// the true count in `total`.
+pub fn record_paths(
+    project_id: &str,
+    source: LossSource,
+    kind: LossKind,
+    op: &str,
+    mut paths: Vec<String>,
+    recovery: Option<String>,
+) {
+    if paths.is_empty() {
+        return;
+    }
+    let total = paths.len();
+    paths.sort();
+    paths.truncate(MAX_PATHS);
+    record(
+        project_id,
+        LocalLoss {
+            ts: now_secs(),
+            source,
+            kind,
+            op: op.to_string(),
+            paths,
+            total,
+            recovery,
+            acked: false,
+        },
+    );
+}
+
+/// Mark every entry seen (the dialog's "Got it"). The entries stay on disk — the point
+/// of the log is that it outlives the warning, so a user who dismissed a deletion at 3am
+/// can still read it to find out which files it took.
+pub fn ack_all(project_id: &str) {
+    let mut entries = load(project_id);
+    if entries.iter().all(|e| e.acked) {
+        return;
+    }
+    for e in &mut entries {
+        e.acked = true;
+    }
+    save(project_id, &entries);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_paths_record_nothing() {
+        // Every destructive site calls this unconditionally — the usual case is that it
+        // destroyed nothing, and that must not file a warning about zero files.
+        let before = load("no-such-project");
+        record_paths(
+            "no-such-project",
+            LossSource::Git,
+            LossKind::Deleted,
+            "fast-forward from the host",
+            Vec::new(),
+            None,
+        );
+        assert_eq!(load("no-such-project"), before);
+    }
+}
diff --git a/src-tauri/src/services/mod.rs b/src-tauri/src/services/mod.rs
index 9bbaa15..3bd0d2a 100644
--- a/src-tauri/src/services/mod.rs
+++ b/src-tauri/src/services/mod.rs
@@ -1,9 +1,33 @@
 pub mod agent_session;
+pub mod big_folders;
+pub mod codex_bind;
+pub mod git_credentials;
+pub mod git_peer;
+pub mod hpc_mode;
+pub mod local_loss;
+pub mod net_usage;
 pub mod openvpn;
 pub mod project_runtime;
+pub mod remote;
 pub mod remote_agents;
+pub mod remote_credentials;
+pub mod remote_sync;
+pub mod remote_usage;
 pub mod restore_service;
+// The project container bind-mounts host paths straight into a Linux container
+// and maps the host uid/gid, so it is Unix-only today *at runtime*: Windows
+// refuses at the `pty_spawn` call site (and `up_for_project` no-ops) rather
+// than running a tab unwrapped. The module itself compiles everywhere — the
+// kill/lifecycle seams (PtyRegistry, project switch, app exit) call into it
+// unconditionally.
+pub mod sandbox;
+pub mod sftp;
+pub mod ssh_common;
 pub mod ssh_exec;
-pub mod ssh_mount;
+pub mod sync_auto;
 pub mod terminal_service;
+pub mod tmux_local;
+pub mod usage_stats;
 pub mod window_service;
+pub mod worker_sync;
+pub mod window_state;
diff --git a/src-tauri/src/services/net_usage.rs b/src-tauri/src/services/net_usage.rs
new file mode 100644
index 0000000..84dad58
--- /dev/null
+++ b/src-tauri/src/services/net_usage.rs
@@ -0,0 +1,279 @@
+//! Background sampler that accrues per-project SSH-link traffic into the
+//! persisted store (`schema::net_usage`).
+//!
+//! Every active remote project rides its own pooled ControlMaster, whose TCP
+//! socket carries all of that project's multiplexed channels (terminal, SFTP,
+//! sync, git). This loop reads that socket's cumulative `bytes_sent` /
+//! `bytes_received` counters for each connected project on a timer — regardless
+//! of whether the Network Traffic tab is open — diffs them against the previous
+//! sample, and folds the deltas into the current UTC hour bucket (and thereby
+//! the current UTC day). That is what makes the tab's "this hour / today / this
+//! week / this month / overall" totals reflect real usage rather than only what
+//! was observed while watching.
+//!
+//! Reset handling mirrors the pane's client-side `rateFromSamples`: when a
+//! project's ControlMaster restarts (its `connection_id` changes) or its
+//! counters run backwards, we re-baseline for the diff.
+//!
+//! First-sight booking: a ControlMaster's `bytes_*` counters start at ~0 when it
+//! comes up, so the *first* time we see a given `connection_id` its whole
+//! cumulative value is real traffic for this project that nothing has booked yet
+//! — we book it, then diff from there. This is what captures a burst that
+//! completes *before* the sampler's first tick, most visibly the seed transfer a
+//! fresh remote project pushes right after connecting (extend-to-remote). We must
+//! not do this on *every* re-baseline, though: a transient `ss` failure drops our
+//! baseline for a master we already track, and re-booking its cumulative would
+//! double-count everything since it came up. So the booking is gated on the
+//! `connection_id` being one we have *never* tracked this process — the PID in it
+//! makes a genuinely new master distinguishable from one we simply lost sight of.
+//! (A master that survives a crash and is re-attached within `ControlPersist` is
+//! the one residual case where its pre-crash bytes book once; a rare, bounded
+//! over-count, versus silently losing every seed.)
+//!
+//! Linux-only: the counters come from `ss`, matching `commands::network`. On
+//! other platforms [`start`] is a no-op.
+
+use crate::services::remote::RemotePoolState;
+
+/// How often to sample each connected project's link counters.
+#[cfg(target_os = "linux")]
+const SAMPLE_INTERVAL_SECS: u64 = 5;
+/// Flush the in-memory accumulator to disk every this-many ticks (~30 s). The
+/// bytes for a project persist in memory between flushes, so a slower cadence
+/// only widens the tail lost on a hard kill — not steady-state accuracy.
+#[cfg(target_os = "linux")]
+const FLUSH_EVERY_TICKS: u64 = 6;
+
+/// Start the background traffic sampler. Spawns a single detached task that runs
+/// for the life of the process. A no-op on non-Linux platforms.
+pub fn start(pool: RemotePoolState) {
+    #[cfg(target_os = "linux")]
+    {
+        tauri::async_runtime::spawn(run(pool));
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        let _ = pool;
+    }
+}
+
+#[cfg(target_os = "linux")]
+mod linux {
+    use std::collections::HashMap;
+    use std::time::Duration;
+
+    use super::{FLUSH_EVERY_TICKS, SAMPLE_INTERVAL_SECS};
+    use crate::commands::network::linux_ssh_link;
+    use crate::schema::net_usage::{self, ByteCounts};
+    use crate::services::remote::{self, RemotePoolState};
+    use crate::storage;
+
+    /// The last observed cumulative counters for one project's ControlMaster.
+    /// `connection_id` identifies the specific master+socket so a restart is
+    /// detected and does not book the new master's lifetime total as a delta.
+    struct Baseline {
+        connection_id: Option<String>,
+        rx: u64,
+        tx: u64,
+    }
+
+    /// What one sample contributes, given the previous baseline and whether this
+    /// master's `connection_id` has been tracked before this process.
+    #[derive(Debug, PartialEq)]
+    enum Booking {
+        /// Same master, counters advanced → the per-interval delta.
+        Delta(u64, u64),
+        /// A master never tracked before → book its cumulative counter from zero
+        /// (its counters started at ~0 when it came up; captures a pre-first-sample
+        /// burst such as the extend-to-remote seed). Caller marks it tracked.
+        Fresh(u64, u64),
+        /// A master we *have* tracked but whose baseline we lost (a transient `ss`
+        /// failure) → book nothing; re-booking the cumulative would double-count.
+        Rebaseline,
+    }
+
+    /// Pure booking decision (see the module doc). `cid_known` is whether this
+    /// master's `connection_id` is already in the process's tracked set.
+    fn decide_booking(prev: Option<&Baseline>, cur: &Baseline, cid_known: bool) -> Booking {
+        match prev {
+            Some(p)
+                if p.connection_id == cur.connection_id && cur.rx >= p.rx && cur.tx >= p.tx =>
+            {
+                Booking::Delta(cur.rx - p.rx, cur.tx - p.tx)
+            }
+            // First sight, a restarted master (new connection_id), or a backwards
+            // counter. Book from zero only when the connection_id is genuinely new.
+            _ if cid_known => Booking::Rebaseline,
+            _ => Booking::Fresh(cur.rx, cur.tx),
+        }
+    }
+
+    pub(super) async fn run(pool: RemotePoolState) {
+        let mut baselines: HashMap<String, Baseline> = HashMap::new();
+        // Every `connection_id` we have ever booked a baseline for this process.
+        // A `connection_id` absent here is a master we have never tracked, so its
+        // cumulative counter is bookable-from-zero (see the module doc); one we
+        // have tracked but lost (an `ss` hiccup) must re-baseline silently.
+        let mut known_conns: std::collections::HashSet<String> = std::collections::HashSet::new();
+        let mut pending: HashMap<String, ByteCounts> = HashMap::new();
+        let mut tick: u64 = 0;
+
+        loop {
+            tokio::time::sleep(Duration::from_secs(SAMPLE_INTERVAL_SECS)).await;
+            tick += 1;
+
+            let ids = remote::connected_ids(&pool).await;
+
+            // A project that dropped out of the pool since last tick has
+            // disconnected: forget its baseline (so a reconnect re-baselines
+            // rather than counting the new master's lifetime counter) and flush
+            // soon to capture its tail before the pending bytes can be lost.
+            let mut disconnected = false;
+            let live: std::collections::HashSet<&String> = ids.iter().collect();
+            let gone: Vec<String> = baselines
+                .keys()
+                .filter(|id| !live.contains(id))
+                .cloned()
+                .collect();
+            for id in gone {
+                // Forget the master's connection_id too: a reconnect brings up a
+                // fresh master (counter from ~0), which should book-from-zero, and
+                // this keeps `known_conns` bounded by the *live* master count.
+                if let Some(prev) = baselines.remove(&id) {
+                    if let Some(cid) = prev.connection_id {
+                        known_conns.remove(&cid);
+                    }
+                }
+                disconnected = true;
+            }
+
+            for id in &ids {
+                let pid = id.clone();
+                let snap = tauri::async_runtime::spawn_blocking(move || linux_ssh_link(&pid))
+                    .await
+                    .ok();
+                let Some(snap) = snap else { continue };
+
+                // Not actually carrying counters (master not found / `ss`
+                // unavailable): drop the baseline so the next good sample
+                // re-baselines instead of diffing against stale numbers.
+                if !snap.connected || snap.connection_id.is_none() {
+                    baselines.remove(id);
+                    continue;
+                }
+
+                let cur = Baseline {
+                    connection_id: snap.connection_id.clone(),
+                    rx: snap.rx_bytes,
+                    tx: snap.tx_bytes,
+                };
+                // Guaranteed `Some` — the `is_none()` guard above `continue`d.
+                let cid = snap.connection_id.clone().unwrap_or_default();
+
+                let booked = match decide_booking(baselines.get(id), &cur, known_conns.contains(&cid))
+                {
+                    Booking::Delta(d_rx, d_tx) => Some((d_rx, d_tx)),
+                    Booking::Fresh(d_rx, d_tx) => {
+                        known_conns.insert(cid);
+                        Some((d_rx, d_tx))
+                    }
+                    Booking::Rebaseline => None,
+                };
+                if let Some((d_rx, d_tx)) = booked {
+                    if d_rx != 0 || d_tx != 0 {
+                        let acc = pending.entry(id.clone()).or_default();
+                        acc.rx = acc.rx.saturating_add(d_rx);
+                        acc.tx = acc.tx.saturating_add(d_tx);
+                    }
+                }
+                baselines.insert(id.clone(), cur);
+            }
+
+            if disconnected || tick % FLUSH_EVERY_TICKS == 0 {
+                flush(&mut pending).await;
+            }
+        }
+    }
+
+    /// Persist and clear the accumulated deltas in one read-modify-write, off the
+    /// async runtime thread. Nonzero-only, so an idle interval never rewrites the
+    /// file.
+    ///
+    /// Bytes are booked to the hour (and day) the *flush* falls in, not the hour
+    /// each sample fell in. With a ~30 s flush cadence, an hour boundary can
+    /// therefore misattribute at most the last flush interval's bytes to the new
+    /// hour — invisible in a per-hour total, and the day is unaffected except in
+    /// the one flush that straddles midnight.
+    async fn flush(pending: &mut HashMap<String, ByteCounts>) {
+        let drained: Vec<(String, ByteCounts)> = pending
+            .drain()
+            .filter(|(_, c)| c.rx != 0 || c.tx != 0)
+            .collect();
+        if drained.is_empty() {
+            return;
+        }
+        let _ = tauri::async_runtime::spawn_blocking(move || {
+            let mut summary = net_usage::load();
+            let hour = storage::hour_utc();
+            for (id, c) in &drained {
+                summary.add(id, &hour, c.rx, c.tx);
+            }
+            let _ = net_usage::save(&mut summary);
+        })
+        .await;
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::{decide_booking, Baseline, Booking};
+
+        fn base(cid: &str, rx: u64, tx: u64) -> Baseline {
+            Baseline { connection_id: Some(cid.to_string()), rx, tx }
+        }
+
+        #[test]
+        fn same_master_advancing_books_the_delta() {
+            let prev = base("pid1:a:b", 100, 40);
+            let cur = base("pid1:a:b", 175, 55);
+            assert_eq!(decide_booking(Some(&prev), &cur, true), Booking::Delta(75, 15));
+        }
+
+        #[test]
+        fn first_sight_of_a_new_master_books_from_zero() {
+            // No baseline yet and a connection_id never tracked → the whole
+            // cumulative counter is the seed that landed before the first sample.
+            let cur = base("pid1:a:b", 9000, 4000);
+            assert_eq!(decide_booking(None, &cur, false), Booking::Fresh(9000, 4000));
+        }
+
+        #[test]
+        fn restart_to_a_new_master_books_its_cumulative() {
+            // Master restarted (new pid → new connection_id, counter reset). The new
+            // id is unknown, so its from-zero counter is booked, not discarded.
+            let prev = base("pid1:a:b", 9000, 4000);
+            let cur = base("pid2:a:b", 120, 30);
+            assert_eq!(decide_booking(Some(&prev), &cur, false), Booking::Fresh(120, 30));
+        }
+
+        #[test]
+        fn lost_baseline_for_a_known_master_rebaselines_silently() {
+            // A transient `ss` failure dropped our baseline (prev is None) but the
+            // connection_id is still one we tracked → booking the cumulative again
+            // would double-count, so book nothing.
+            let cur = base("pid1:a:b", 9000, 4000);
+            assert_eq!(decide_booking(None, &cur, true), Booking::Rebaseline);
+        }
+
+        #[test]
+        fn backwards_counter_on_known_id_rebaselines() {
+            // Same id but the counter regressed (should not happen for a cumulative
+            // counter, but never book a negative) → re-baseline, no booking.
+            let prev = base("pid1:a:b", 9000, 4000);
+            let cur = base("pid1:a:b", 100, 30);
+            assert_eq!(decide_booking(Some(&prev), &cur, true), Booking::Rebaseline);
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+use linux::run;
diff --git a/src-tauri/src/services/openvpn.rs b/src-tauri/src/services/openvpn.rs
index 9453400..2e32276 100644
--- a/src-tauri/src/services/openvpn.rs
+++ b/src-tauri/src/services/openvpn.rs
@@ -6,9 +6,26 @@
 //!
 //! OpenVPN needs root to create the tun device and adjust routing, so it is
 //! launched via `pkexec` (the user authenticates through the system polkit
-//! agent). The password for the VPN itself (encrypted-key passphrase) is never
-//! persisted: callers pass it in, we write it to an owner-only temp file that
-//! OpenVPN reads via `--askpass`, then delete it once the tunnel is up.
+//! agent) — that local password is the system's to collect, never Eldrun's.
+//!
+//! **That prompt is paid once, on connect.** Stopping the tunnel used to cost a
+//! second one — the daemon is root-owned, so `kill` had to be `pkexec kill` — which
+//! is one password too many and landed worst on the app-close path. Every tunnel
+//! Eldrun starts now carries a `--management` socket instead, and teardown asks the
+//! daemon to signal *itself* over it. See the "management interface" section below
+//! for the endpoint, its access control, and why every caller still falls back to
+//! the elevated kill.
+//!
+//! The VPN's own secrets are two *independent* channels, and a config can need
+//! either or **both** — OpenVPN prompts for them separately, so answering only
+//! one leaves the other prompt hanging (stdin is closed) until the connect times
+//! out:
+//!   - an `auth-user-pass` account (username + password) → `--auth-user-pass`, and
+//!   - an encrypted private key's passphrase → `--askpass`.
+//! Which ones a config needs is read off the config itself
+//! ([`config_requires_userpass`] / [`config_requires_key_passphrase`]). Neither
+//! secret is persisted here: callers pass them in, we write them to owner-only
+//! temp files OpenVPN reads, and delete those once the tunnel is up.
 //!
 //! Tunnels are tracked in a process-global registry keyed by the **config path**
 //! so the same config is never connected twice and a connect made during project
@@ -17,14 +34,24 @@
 //! argv item.
 
 use std::collections::HashMap;
-use std::io::{BufRead, BufReader, Write};
-use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+use std::io::{BufRead, BufReader};
+use std::io::Write;
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+#[cfg(unix)]
+use std::os::unix::fs::OpenOptionsExt;
 use std::path::{Path, PathBuf};
-use std::process::{Child, Command, Stdio};
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+use std::process::{Child, Stdio};
+#[cfg(target_os = "linux")]
+use std::process::Command;
 use std::sync::{Mutex, OnceLock};
 use std::time::{Duration, Instant};
 
-use crate::services::ssh_mount::validate_arg;
+use serde::Serialize;
+
+use crate::services::ssh_common::validate_arg;
 use crate::storage;
 
 /// OpenVPN prints this once the tunnel is fully up.
@@ -32,19 +59,238 @@ const READY_MARKER: &str = "Initialization Sequence Completed";
 /// Give the tunnel this long to come up before we give up and kill it.
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(45);
 
-/// A running tunnel: the `pkexec openvpn` child plus the pidfile OpenVPN wrote
-/// (so we can `pkexec kill` the root process on teardown).
+/// A running tunnel: the OpenVPN child plus the pidfile OpenVPN wrote. On Linux
+/// the child is `pkexec openvpn` and the pidfile lets us `pkexec kill` the root
+/// process; on Windows the child *is* `openvpn.exe`, torn down via its handle /
+/// `taskkill` (the pidfile is still written but unused for teardown).
+#[cfg(any(target_os = "linux", target_os = "windows"))]
 struct VpnProc {
     child: Child,
     pidfile: PathBuf,
 }
 
 /// Process-global registry of live tunnels, keyed by config path.
+#[cfg(any(target_os = "linux", target_os = "windows"))]
 fn registry() -> &'static Mutex<HashMap<String, VpnProc>> {
     static REG: OnceLock<Mutex<HashMap<String, VpnProc>>> = OnceLock::new();
     REG.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
+/// Registry of **interactive** tunnels (`connections_headless: false`), keyed by
+/// config path → the pidfile OpenVPN writes. Value is a pidfile rather than a
+/// `Child` because Eldrun does not spawn these: they run as `pkexec openvpn` (or
+/// `sudo openvpn`) inside a *terminal tab*, typed into by the user, so there is no
+/// child handle to hold — only the pid the daemon records.
+///
+/// Without this, an interactive tunnel was invisible and unkillable: absent from
+/// [`registry`], it could not be seen by [`is_connected`] / [`active_configs`], nor
+/// killed by [`disconnect`] / [`disconnect_all`] — so it **outlived Eldrun with the
+/// machine's routing still changed**. [`interactive_connect_command`] now appends a
+/// `--writepid` we own and registers it here, which closes all four gaps at once.
+///
+/// Not cfg-gated (unlike [`registry`]) so the bookkeeping unit-tests run anywhere.
+fn interactive_registry() -> &'static Mutex<HashMap<String, PathBuf>> {
+    static REG: OnceLock<Mutex<HashMap<String, PathBuf>>> = OnceLock::new();
+    REG.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// Where an interactive tunnel for `config` records its pid. Deliberately a
+/// different file from the headless `{stem}.pid`, so a stale file from one flavour
+/// can never be mistaken for a live tunnel of the other.
+fn interactive_pidfile(config: &str) -> PathBuf {
+    runtime_dir().join(format!("{}.interactive.pid", safe_stem(config)))
+}
+
+/// Whether `pid` is alive. **EPERM counts as ALIVE**: the OpenVPN daemon runs as
+/// root, so an unprivileged probe gets EPERM for a perfectly healthy tunnel —
+/// treating that as dead is what keeps a VPN lamp dark while the tunnel is up
+/// (the 28l bug).
+#[cfg(unix)]
+fn pid_alive(pid: i32) -> bool {
+    // SAFETY: kill with signal 0 only probes for existence/permission.
+    if unsafe { libc::kill(pid, 0) } == 0 {
+        return true;
+    }
+    std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM)
+}
+
+/// Windows analog: no `kill(0)`, so ask the task list. An elevated `openvpn.exe`
+/// is still enumerated for an unelevated query, so there is no EPERM-style trap
+/// here — but a failed probe is treated as *not* alive rather than guessed at.
+#[cfg(target_os = "windows")]
+fn pid_alive(pid: i32) -> bool {
+    let out = crate::paths::command_no_window("tasklist")
+        .args(["/FI", &format!("PID eq {pid}"), "/NH"])
+        .output();
+    match out {
+        Ok(o) => String::from_utf8_lossy(&o.stdout).contains(&pid.to_string()),
+        Err(_) => false,
+    }
+}
+
+/// State of the interactive tunnel registered for `config`.
+#[derive(PartialEq, Eq, Debug)]
+enum Interactive {
+    /// No interactive tunnel registered for this config.
+    None,
+    /// Registered, but OpenVPN has not written its pid yet — the user is still at
+    /// the polkit/sudo prompt or typing the passphrase. **Not dead**: the entry is
+    /// kept, or a tunnel would be forgotten in the seconds before it comes up.
+    Pending,
+    /// Registered and its recorded pid is alive: the tunnel is up.
+    Alive(i32),
+}
+
+/// Classify (and reap) the interactive entry for `config`.
+fn interactive_state(config: &str) -> Interactive {
+    let pidfile = match interactive_registry().lock().unwrap().get(config) {
+        Some(p) => p.clone(),
+        None => return Interactive::None,
+    };
+    match pidfile_pid(&pidfile) {
+        Some(pid) if pid_alive(pid) => Interactive::Alive(pid),
+        Some(_) => {
+            // The pid was written and is now gone: the tunnel died (or the user
+            // closed its terminal). Reap the entry and its stale pidfile.
+            interactive_registry().lock().unwrap().remove(config);
+            let _ = std::fs::remove_file(&pidfile);
+            Interactive::None
+        }
+        None => Interactive::Pending,
+    }
+}
+
+/// Whether an interactive tunnel for `config` is *up* (not merely registered).
+fn interactive_connected(config: &str) -> bool {
+    matches!(interactive_state(config), Interactive::Alive(_))
+}
+
+/// Tear down the interactive tunnel for `config`, if any. The daemon is root, so
+/// the kill is elevated the same way the connect was.
+fn disconnect_interactive(config: &str) {
+    let alive = match interactive_state(config) {
+        Interactive::Alive(pid) => Some(pid),
+        // Pending: nothing to kill yet, but drop the claim so a never-authenticated
+        // connect doesn't linger in the registry forever.
+        Interactive::Pending => None,
+        Interactive::None => return,
+    };
+    let pidfile = interactive_registry().lock().unwrap().remove(config);
+    if let Some(pid) = alive {
+        kill_root_pid(pid);
+    }
+    if let Some(pidfile) = pidfile {
+        let _ = std::fs::remove_file(&pidfile);
+    }
+}
+
+/// Root pids we have already delivered a TERM to. **This is what keeps the app-close
+/// path to a single password prompt.** Killing an OpenVPN daemon is elevated
+/// (`pkexec kill`), and polkit authenticates *per invocation* — so a second elevated
+/// kill aimed at the same daemon costs the user a second password, even though the
+/// first one already did the job. Two things make that second kill happen: the quit
+/// path tears tunnels down twice by design (the checked teardown while the window is
+/// still on screen, then `RunEvent::Exit`'s best-effort `disconnect_all`), and TERM is
+/// asynchronous — the daemon is still alive for a moment after the first kill returns,
+/// so a liveness probe alone cannot tell "already handled" from "still needs killing".
+///
+/// Remembering the pid does. A pid in here has been asked to die and needs no second
+/// elevated ask; anything *not* in here is still killed exactly as before, so no tunnel
+/// can be silently left up. Pids are unique for the app's lifetime in practice (the set
+/// only ever holds the handful of tunnels one run brought up).
+#[cfg(any(unix, target_os = "windows"))]
+fn signalled_pids() -> &'static Mutex<std::collections::HashSet<i32>> {
+    static PIDS: OnceLock<Mutex<std::collections::HashSet<i32>>> = OnceLock::new();
+    PIDS.get_or_init(|| Mutex::new(std::collections::HashSet::new()))
+}
+
+/// Whether an elevated kill of `pid` can be skipped as already-done: we have signalled
+/// it before, or it is simply gone. Skipping reports *success* to the caller — the
+/// tunnel is down or on its way down either way, and the whole point is to not spend a
+/// password prompt re-confirming it.
+#[cfg(any(unix, target_os = "windows"))]
+fn kill_already_handled(pid: i32) -> bool {
+    if signalled_pids().lock().unwrap().contains(&pid) {
+        return true;
+    }
+    !pid_alive(pid)
+}
+
+/// Record that `pid` has been sent a TERM, so no later teardown pass re-elevates for it.
+#[cfg(any(unix, target_os = "windows"))]
+fn mark_signalled(pid: i32) {
+    signalled_pids().lock().unwrap().insert(pid);
+}
+
+/// Configs whose elevated teardown was explicitly **refused** (a dismissed polkit
+/// prompt) once already during this run. [`disconnect_checked`] is the one caller
+/// that asks — on the app-close path, while the window is still on screen — and it
+/// is meant to ask exactly once: a "no" there means the user has already decided,
+/// not that Eldrun should try again the moment the window is gone. Every later
+/// best-effort pass ([`disconnect_all`], run from `RunEvent::Exit` with no window
+/// left to hold a polkit dialog) checks this set and leaves a declined tunnel
+/// running rather than re-prompting — which is what used to raise a parentless
+/// pkexec dialog after Eldrun had already vanished.
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+fn declined_configs() -> &'static Mutex<std::collections::HashSet<String>> {
+    static SET: OnceLock<Mutex<std::collections::HashSet<String>>> = OnceLock::new();
+    SET.get_or_init(|| Mutex::new(std::collections::HashSet::new()))
+}
+
+#[cfg(target_os = "linux")]
+fn mark_declined(config: &str) {
+    declined_configs().lock().unwrap().insert(config.to_string());
+}
+
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+fn is_declined(config: &str) -> bool {
+    declined_configs().lock().unwrap().contains(config)
+}
+
+/// `kill -TERM` a **root-owned** pid, escalating the same way the platform's
+/// connect does (a plain kill would get EPERM).
+#[cfg(target_os = "linux")]
+fn kill_root_pid(pid: i32) {
+    if kill_already_handled(pid) {
+        return;
+    }
+    let status = Command::new("pkexec")
+        .arg("kill")
+        .arg("-TERM")
+        .arg(pid.to_string())
+        .status();
+    if matches!(status, Ok(s) if s.success()) {
+        mark_signalled(pid);
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn kill_root_pid(pid: i32) {
+    let script = macos_admin_shell_command(
+        &format!("kill -TERM {pid}"),
+        "Eldrun needs to stop the OpenVPN tunnel.",
+    );
+    let _ = crate::paths::command_no_window("osascript")
+        .arg("-e")
+        .arg(&script)
+        .output();
+}
+
+/// Windows analog: `taskkill /F`. A service-started tunnel's `openvpn.exe` runs
+/// with this user's token (the privilege lives in the interactive service), so
+/// an unelevated kill reaches it; a direct-spawn tunnel was started from an
+/// already-elevated context, whose `taskkill` is equally elevated.
+#[cfg(target_os = "windows")]
+fn kill_root_pid(pid: i32) {
+    let _ = crate::paths::command_no_window("taskkill")
+        .args(["/PID", &pid.to_string(), "/F"])
+        .output();
+}
+
+/// No supported escalation path on other platforms; nothing spawns tunnels there.
+#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+fn kill_root_pid(_pid: i32) {}
+
 /// Directory holding OpenVPN runtime files (askpass + pidfiles), created 0700.
 fn runtime_dir() -> PathBuf {
     storage::state_dir().join("openvpn")
@@ -79,47 +325,553 @@ pub fn store_config(src: &str) -> Result<String, String> {
         .unwrap_or("config.ovpn");
     let dest = dir.join(format!("{}__{file_name}", safe_stem(src)));
     std::fs::copy(src_path, &dest).map_err(|e| format!("copy config: {e}"))?;
+    #[cfg(unix)]
     let _ = std::fs::set_permissions(&dest, std::fs::Permissions::from_mode(0o600));
     Ok(dest.to_string_lossy().into_owned())
 }
 
-/// True if `openvpn` and `pkexec` are both available on `PATH`.
+/// A previously-used `.ovpn` config copied into Eldrun's store, offered for
+/// reuse so a config need only be browsed for once.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct StoredConfig {
+    /// Absolute path to the stored copy (what callers pass to `connect`).
+    pub path: String,
+    /// Friendly display name (the original `.ovpn` file name).
+    pub name: String,
+}
+
+/// List the `.ovpn` configs Eldrun has previously stored, newest first (by file
+/// mtime). Every config passed through [`store_config`] lands here, so the dir
+/// doubles as the "recently used" history. Returns empty if nothing is stored.
+pub fn list_configs() -> Vec<StoredConfig> {
+    let dir = configs_dir();
+    let Ok(entries) = std::fs::read_dir(&dir) else {
+        return Vec::new();
+    };
+    let mut items: Vec<(std::time::SystemTime, StoredConfig)> = Vec::new();
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if !path.is_file() {
+            continue;
+        }
+        let Some(file_name) = path.file_name().and_then(|n| n.to_str()) else {
+            continue;
+        };
+        let name = display_name(file_name);
+        let mtime = entry
+            .metadata()
+            .and_then(|m| m.modified())
+            .unwrap_or(std::time::UNIX_EPOCH);
+        items.push((
+            mtime,
+            StoredConfig {
+                path: path.to_string_lossy().into_owned(),
+                name,
+            },
+        ));
+    }
+    items.sort_by(|a, b| b.0.cmp(&a.0));
+    items.into_iter().map(|(_, c)| c).collect()
+}
+
+/// Remove a stored `.ovpn` config from Eldrun's store. Deletes only Eldrun's
+/// copy — the path must be inside [`configs_dir`], so the user's original file
+/// is never touched. Refused while the config's tunnel is up: the row offering
+/// removal should be a dead tunnel's, and a live one must be disconnected
+/// first, not have its config pulled out from under it. Removing an
+/// already-gone file succeeds — the goal state is "not stored".
+pub fn remove_config(config: &str) -> Result<(), String> {
+    let config = config.trim();
+    validate_arg("OpenVPN config", config)?;
+    let path = Path::new(config);
+    if !path.starts_with(configs_dir()) {
+        return Err("not a stored OpenVPN config".to_string());
+    }
+    if is_connected(config) {
+        return Err("this tunnel is up — disconnect it before removing its config".to_string());
+    }
+    match std::fs::remove_file(path) {
+        Ok(()) => Ok(()),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),
+        Err(e) => Err(format!("remove config: {e}")),
+    }
+}
+
+/// Recover an `.ovpn` config's display name from its stored file name. Stored
+/// as `{stem}__{original_name}`; `rsplit_once` keeps the last segment as the
+/// name (the stem can itself contain `__` since non-alnums collapse to `_`,
+/// while the original file name rarely does). Falls back to the whole name.
+fn display_name(file_name: &str) -> String {
+    file_name
+        .rsplit_once("__")
+        .map(|(_, n)| n.to_string())
+        .unwrap_or_else(|| file_name.to_string())
+}
+
+/// Single-quote `s` for a POSIX shell so a config path with spaces or
+/// metacharacters stays a single inert argument when the built command is typed
+/// into a terminal. Embedded single quotes become `'\''`.
+fn shell_quote(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() + 2);
+    out.push('\'');
+    for ch in s.chars() {
+        if ch == '\'' {
+            out.push_str("'\\''");
+        } else {
+            out.push(ch);
+        }
+    }
+    out.push('\'');
+    out
+}
+
+/// Build a ready-to-run shell command string that brings up the OpenVPN tunnel
+/// for `config` **interactively**, so the encrypted-key passphrase is typed
+/// directly into a visible terminal (no `--askpass` temp file, nothing for Eldrun
+/// to handle). Typed into a root-scope shell tab (see the frontend
+/// `openConnectionInRoot`) when headless connections are turned off.
+///
+/// Linux launches it elevated via `pkexec` (the tun device / routing need root);
+/// the polkit prompt comes first, then OpenVPN prompts for the passphrase on the
+/// same tty. `--auth-nocache` keeps the passphrase out of OpenVPN's memory across
+/// re-keys. Windows runs `openvpn.exe` directly (it must be started elevated).
+/// The config path is validated and shell-quoted as a single argument.
+///
+/// **Side effect (deliberate):** every variant appends `--writepid <pidfile>` and
+/// registers that pidfile in [`interactive_registry`] via [`arm_interactive`]. The
+/// tunnel this command starts is not Eldrun's child, so the pid it records is the
+/// *only* handle on a root process that is rerouting the whole machine. Without it,
+/// the tunnel is invisible to [`is_connected`] / [`active_configs`] and unkillable
+/// by [`disconnect`] / [`disconnect_all`] — it outlives the app with the routing
+/// still changed. Building the command is therefore also *claiming* it.
+#[cfg(target_os = "linux")]
+pub fn interactive_connect_command(config: &str) -> Result<String, String> {
+    let arm = arm_interactive(config)?;
+    Ok(format!(
+        "pkexec openvpn --config {} --auth-nocache --writepid {}{}",
+        shell_quote(&arm.config),
+        shell_quote(&arm.pidfile.to_string_lossy()),
+        arm.management
+    ))
+}
+
+/// Windows variant: no `pkexec`; `openvpn.exe` must already be running elevated.
+#[cfg(target_os = "windows")]
+pub fn interactive_connect_command(config: &str) -> Result<String, String> {
+    let arm = arm_interactive(config)?;
+    Ok(format!(
+        "openvpn --config {} --auth-nocache --writepid {}{}",
+        shell_quote(&arm.config),
+        shell_quote(&arm.pidfile.to_string_lossy()),
+        arm.management
+    ))
+}
+
+/// macOS variant: `sudo` on the visible tty (no `pkexec`/polkit on macOS; the
+/// interactive root-tab path types the password straight into the terminal).
+#[cfg(target_os = "macos")]
+pub fn interactive_connect_command(config: &str) -> Result<String, String> {
+    let arm = arm_interactive(config)?;
+    Ok(format!(
+        "sudo openvpn --config {} --auth-nocache --writepid {}{}",
+        shell_quote(&arm.config),
+        shell_quote(&arm.pidfile.to_string_lossy()),
+        arm.management
+    ))
+}
+
+/// Validate `config` and claim an interactive tunnel for it: pick the pidfile,
+/// delete any stale one (a leftover from a previous run would otherwise read as a
+/// live tunnel), ensure the runtime dir exists for root to write into, and register
+/// the claim. Returns the trimmed config and the pidfile the command must use.
+///
+/// Shared by all three [`interactive_connect_command`] variants so a platform
+/// cannot forget the `--writepid` bookkeeping. Compiled cfg-free so the claim logic
+/// is unit-testable on any host.
+fn arm_interactive(config: &str) -> Result<InteractiveArm, String> {
+    let config = config.trim();
+    validate_arg("OpenVPN config", config)?;
+    if config.is_empty() {
+        return Err("OpenVPN config path must not be empty".to_string());
+    }
+    let pidfile = interactive_pidfile(config);
+    let _ = std::fs::create_dir_all(runtime_dir());
+    let _ = std::fs::remove_file(&pidfile);
+    interactive_registry()
+        .lock()
+        .unwrap()
+        .insert(config.to_string(), pidfile.clone());
+    // A terminal-started tunnel gets the same management socket a headless one does,
+    // so stopping it costs no second elevation either. Best-effort: if no endpoint
+    // can be armed the fragment is empty and the command is exactly what it was.
+    #[cfg(unix)]
+    let management = arm_management(config)
+        .map(|a| match a.as_slice() {
+            // Shape is fixed by `management_args`: flag, ip, port, pwfile. Only the
+            // last can contain shell metacharacters, and leaving the first three bare
+            // keeps the command legible in the terminal tab the user actually reads.
+            [flag, ip, port, pwfile] => format!(" {flag} {ip} {port} {}", shell_quote(pwfile)),
+            _ => String::new(),
+        })
+        .unwrap_or_default();
+    #[cfg(not(unix))]
+    let management = String::new();
+    Ok(InteractiveArm {
+        config: config.to_string(),
+        pidfile,
+        management,
+    })
+}
+
+/// What [`arm_interactive`] hands each platform's [`interactive_connect_command`]:
+/// the validated config, the pidfile the command must `--writepid` to, and the
+/// pre-quoted `--management …` fragment (leading space included, empty when none
+/// could be armed) to append verbatim.
+struct InteractiveArm {
+    config: String,
+    pidfile: PathBuf,
+    management: String,
+}
+
+/// True if `openvpn` and `pkexec` are both available on `PATH` (both are needed:
+/// OpenVPN to build the tunnel, polkit's `pkexec` to launch it elevated).
+#[cfg(target_os = "linux")]
 pub fn openvpn_available() -> bool {
-    which_exists("openvpn") && which_exists("pkexec")
+    crate::paths::binary_on_path("openvpn") && crate::paths::binary_on_path("pkexec")
 }
 
-fn which_exists(bin: &str) -> bool {
-    Command::new("which")
-        .arg(bin)
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false)
+/// True if `openvpn.exe` can be located (PATH, a per-user dir, or the standard
+/// `Program Files\OpenVPN\bin` location). Windows has no `pkexec`/polkit, so
+/// only the OpenVPN binary itself is probed (see [`connect`] for how elevation
+/// is handled).
+#[cfg(target_os = "windows")]
+pub fn openvpn_available() -> bool {
+    resolve_openvpn().is_some()
+}
+
+/// True if an `openvpn` binary can be located (PATH or the usual Homebrew /
+/// local prefixes). Elevation rides `osascript … with administrator privileges`
+/// (see [`connect_streaming`]), which is always present, so only the binary is
+/// probed.
+#[cfg(target_os = "macos")]
+pub fn openvpn_available() -> bool {
+    resolve_openvpn().is_some()
 }
 
 /// Build the `openvpn` argv (without the leading `pkexec`/`openvpn`) for a
 /// connect. Returned as `Vec<String>` so it is unit-testable without launching.
 ///
-/// Shape: `--config <cfg> --askpass <credfile> --auth-nocache
-///         --writepid <pidfile> --connect-timeout 20 --connect-retry-max 3`.
-pub fn openvpn_args(config: &str, askpass: &Path, pidfile: &Path) -> Result<Vec<String>, String> {
+/// The two credential files are **independent channels**, and a config can need
+/// one, the other, or *both* — OpenVPN prompts for them separately, so feeding
+/// only one leaves the other prompt unanswered and (stdin closed) hangs the
+/// handshake until it times out:
+/// - `userpass_file` → `--auth-user-pass <f>` (a two-line `username\npassword`
+///   file), for configs with a bare `auth-user-pass` directive (server-side
+///   username+password auth).
+/// - `askpass_file` → `--askpass <f>` (a one-line passphrase file), for an
+///   encrypted private key.
+///
+/// Shape: `--config <cfg> [--auth-user-pass <f>] [--askpass <f>] --auth-nocache
+///         --writepid <pidfile> --connect-timeout 20 --persist-tun
+///         --verb 3 --mute 0`.
+pub fn openvpn_args(
+    config: &str,
+    userpass_file: Option<&Path>,
+    askpass_file: Option<&Path>,
+    pidfile: &Path,
+) -> Result<Vec<String>, String> {
     let config = config.trim();
     if config.is_empty() {
         return Err("OpenVPN config path must not be empty".to_string());
     }
     validate_arg("OpenVPN config", config)?;
-    Ok(vec![
-        "--config".to_string(),
-        config.to_string(),
-        "--askpass".to_string(),
-        askpass.to_string_lossy().into_owned(),
+    let mut args = vec!["--config".to_string(), config.to_string()];
+    if let Some(f) = userpass_file {
+        args.push("--auth-user-pass".to_string());
+        args.push(f.to_string_lossy().into_owned());
+    }
+    if let Some(f) = askpass_file {
+        args.push("--askpass".to_string());
+        args.push(f.to_string_lossy().into_owned());
+    }
+    args.extend([
         "--auth-nocache".to_string(),
         "--writepid".to_string(),
         pidfile.to_string_lossy().into_owned(),
         "--connect-timeout".to_string(),
         "20".to_string(),
-        "--connect-retry-max".to_string(),
+        // NO `--connect-retry-max`. That option is *not* an initial-connect
+        // guard — it caps reconnect attempts for the tunnel's whole lifetime, so
+        // the `3` this used to pass meant any mid-session blip (a rekey failure,
+        // a suspended laptop, a server restart) burned the three retries and
+        // OpenVPN **exited for good**, leaving the machine's routing changed and
+        // every SSH/SFTP session on top of it stalled against a peer that would
+        // never answer. Unlimited (the OpenVPN default) is what makes a tunnel
+        // survive a blip. The *initial* connect is still bounded — from the
+        // outside, by `CONNECT_TIMEOUT` + the `child.kill()` on its Err — so a
+        // doomed connect cannot retry forever behind the user's back.
+        //
+        // `--persist-tun` keeps the tun device and its routes across those
+        // reconnects, which is what lets a connection on top of the tunnel ride
+        // one out instead of breaking. It also makes the failure mode
+        // fail-*closed*: while OpenVPN is re-handshaking, traffic is black-holed
+        // rather than leaking out the physical default route. That is the right
+        // trade for a VPN, and it is only safe now that the tunnel no longer
+        // gives up permanently (above) and that a tunnel dying is *detected*
+        // rather than left showing a green lamp (`stores/vpnStatus`'s drop
+        // reconcile).
+        "--persist-tun".to_string(),
+        // Readiness is detected by watching OpenVPN's output for READY_MARKER,
+        // so logging must be deterministic no matter what the config says: a
+        // config's `mute N` suppresses consecutive same-category lines — the
+        // marker follows a burst of route additions, so it was exactly the line
+        // a `mute 16` swallowed, and Eldrun then "timed out" on (and killed) a
+        // tunnel that was up. `verb 0` would hide the marker the same way.
+        // Command-line options are applied after `--config`, so these override.
+        "--verb".to_string(),
         "3".to_string(),
-    ])
+        "--mute".to_string(),
+        "0".to_string(),
+    ]);
+    Ok(args)
+}
+
+/// Whether `config` uses server-side username+password auth that OpenVPN would
+/// otherwise prompt for interactively — i.e. it contains a bare `auth-user-pass`
+/// directive with **no** inline credentials file argument. Such configs need a
+/// username (collected in the UI, stored in [`OpenVpnSpec`]) fed via
+/// `--auth-user-pass`; a directive that already names a file (`auth-user-pass
+/// creds.txt`) supplies its own and is treated as not needing one.
+///
+/// Best-effort: an unreadable config returns `false` (the connect then falls back
+/// to the `--askpass` path, matching the pre-username behaviour). Comment lines
+/// (`#`/`;`) and inline trailing comments are ignored.
+pub fn config_requires_userpass(config: &str) -> bool {
+    let Ok(text) = std::fs::read_to_string(config.trim()) else {
+        return false;
+    };
+    text.lines().any(|line| {
+        // Strip trailing `# ...` / `; ...` comments, then tokenize on whitespace.
+        let body = line
+            .split(['#', ';'])
+            .next()
+            .unwrap_or("")
+            .trim();
+        let mut tok = body.split_whitespace();
+        tok.next() == Some("auth-user-pass") && tok.next().is_none()
+    })
+}
+
+/// Whether `config` declares its own `management` socket. Such a config is left
+/// **alone**: OpenVPN rejects `--management` given twice, and even where it did not,
+/// the socket would be on terms Eldrun does not know (its own port, and a password
+/// file it cannot read). Those tunnels simply keep the elevated teardown — the one
+/// place the second password prompt survives, and the reason every management caller
+/// treats the endpoint as optional.
+///
+/// Same best-effort parse as [`config_requires_userpass`]: unreadable ⇒ `false`,
+/// `#`/`;` comments stripped.
+pub fn config_declares_management(config: &str) -> bool {
+    let Ok(text) = std::fs::read_to_string(config.trim()) else {
+        return false;
+    };
+    text.lines().any(|line| {
+        let body = line.split(['#', ';']).next().unwrap_or("").trim();
+        body.split_whitespace().next() == Some("management")
+    })
+}
+
+/// Whether a PEM blob holds an *encrypted* private key — the two markers OpenSSL
+/// writes: `Proc-Type: 4,ENCRYPTED` (traditional/PKCS#1) and the PKCS#8
+/// `BEGIN ENCRYPTED PRIVATE KEY` header. An unencrypted key has neither.
+fn pem_is_encrypted(text: &str) -> bool {
+    text.contains("Proc-Type: 4,ENCRYPTED") || text.contains("BEGIN ENCRYPTED PRIVATE KEY")
+}
+
+/// Whether `config` uses a private key whose passphrase OpenVPN would prompt for
+/// (`Enter Private Key Password:`). This is an **independent** channel from
+/// [`config_requires_userpass`]: a config can need both, and OpenVPN asks for
+/// them as two separate prompts, so a connect that supplies only one hangs on the
+/// other. Callers feed this one via `--askpass` (see [`openvpn_args`]).
+///
+/// True when the key is encrypted, whether inlined in a `<key>` block or named by
+/// a `key <file>` directive (resolved relative to the config), and for a `pkcs12`
+/// bundle — PKCS#12 is DER, so its encryption can't be sniffed the way PEM's can,
+/// and the bundles OpenVPN ships are effectively always passphrase-protected.
+/// False when the config carries its own `askpass <file>` (it supplies the
+/// passphrase itself), and false for an unreadable config — best-effort, matching
+/// [`config_requires_userpass`].
+///
+/// Erring toward `true` is the safe bias: a false positive shows one extra field
+/// that, left blank, writes no askpass file and changes nothing; a false negative
+/// hangs the handshake on an unanswered prompt.
+pub fn config_requires_key_passphrase(config: &str) -> bool {
+    let config = config.trim();
+    let Ok(text) = std::fs::read_to_string(config) else {
+        return false;
+    };
+    let config_dir = Path::new(config).parent();
+
+    let mut in_key_block = false;
+    let mut key_file: Option<String> = None;
+    let mut pkcs12 = false;
+    for line in text.lines() {
+        let raw = line.trim();
+        if raw.eq_ignore_ascii_case("<key>") {
+            in_key_block = true;
+            continue;
+        }
+        if raw.eq_ignore_ascii_case("</key>") {
+            in_key_block = false;
+            continue;
+        }
+        // Inside the inline key: the PEM body itself is the evidence. Base64 never
+        // contains `#`/`;`, so no comment-stripping is needed (or wanted) here.
+        if in_key_block {
+            if pem_is_encrypted(raw) {
+                return true;
+            }
+            continue;
+        }
+        let body = line.split(['#', ';']).next().unwrap_or("").trim();
+        let mut tok = body.split_whitespace();
+        match tok.next() {
+            // `askpass <file>` supplies the passphrase itself; a bare `askpass`
+            // means "prompt on the console" and still needs one from us.
+            Some("askpass") if tok.next().is_some() => return false,
+            Some("key") => key_file = tok.next().map(str::to_string),
+            Some("pkcs12") => pkcs12 = true,
+            _ => {}
+        }
+    }
+
+    if pkcs12 {
+        return true;
+    }
+    // An out-of-line key: resolve it against the config's directory when relative,
+    // then sniff the same PEM markers. Unreadable → false (best-effort).
+    let Some(key_file) = key_file else {
+        return false;
+    };
+    let key_path = Path::new(&key_file);
+    let key_path = match (key_path.is_absolute(), config_dir) {
+        (false, Some(dir)) => dir.join(key_path),
+        _ => key_path.to_path_buf(),
+    };
+    std::fs::read_to_string(key_path)
+        .map(|k| pem_is_encrypted(&k))
+        .unwrap_or(false)
+}
+
+/// The credential files a connect must hand OpenVPN, resolved from what the
+/// config actually asks for. Shared by the Linux/Windows/macOS `connect_streaming`
+/// implementations so all three feed the same channels.
+///
+/// `password` is the primary secret and `key_passphrase` the (optional) second
+/// one. Which channel `password` lands in depends on the config:
+/// - bare `auth-user-pass` → `password` is the *account* password, written with
+///   `username` into the two-line userpass file, and `key_passphrase` (when the
+///   config also has an encrypted key) becomes the askpass file.
+/// - otherwise → there is no account to log into, so `password` *is* the key
+///   passphrase and goes to askpass. This is the long-standing single-secret path.
+///
+/// Returns `(userpass_file, askpass_file)`; the caller passes them to
+/// [`openvpn_args`] and deletes both once OpenVPN has read them.
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+fn write_credfiles(
+    config: &str,
+    stem: &str,
+    username: Option<&str>,
+    password: &str,
+    key_passphrase: Option<&str>,
+) -> Result<(Option<PathBuf>, Option<PathBuf>), String> {
+    let userpass = config_requires_userpass(config);
+    let userpass_file = if userpass {
+        Some(write_userpass(stem, username.unwrap_or(""), password)?)
+    } else {
+        None
+    };
+    let key_passphrase = key_passphrase.filter(|p| !p.is_empty());
+    let askpass_file = match key_passphrase {
+        Some(kp) => Some(write_askpass(stem, kp)?),
+        None if !userpass => Some(write_askpass(stem, password)?),
+        None => None,
+    };
+    Ok((userpass_file, askpass_file))
+}
+
+/// Turn OpenVPN's output into a message that names which secret was wrong.
+///
+/// This is the payoff of feeding the two credential channels separately: OpenVPN
+/// reports an `auth-user-pass` rejection (`AUTH_FAILED`) and a bad private-key
+/// passphrase (a decrypt error) with completely different lines, so a headless
+/// connect can tell the user *which* of the fields to retype instead of dumping
+/// the handshake log at them.
+///
+/// `log` is the failure tail (or the whole handshake). Returns `None` when nothing
+/// is recognized, so the caller falls back to the raw tail rather than replacing a
+/// specific error with a vague guess. Most-specific checks run first.
+pub fn explain_openvpn_error(log: &str) -> Option<String> {
+    let s = log.to_ascii_lowercase();
+
+    // Wrong private-key passphrase. OpenVPN/OpenSSL word this several ways
+    // depending on version and key format; all of them mean the same thing.
+    if s.contains("private key password verification failed")
+        || s.contains("error parsing private key")
+        || s.contains("bad decrypt")
+        || s.contains("decryption error")
+        || s.contains("could not load private key")
+    {
+        return Some("Wrong private-key passphrase for this VPN config.".to_string());
+    }
+
+    // Wrong account username/password. AUTH_FAILED is the server explicitly
+    // rejecting the `auth-user-pass` credentials.
+    if s.contains("auth_failed") || s.contains("authenticate/decrypt packet error") {
+        return Some(
+            "VPN authentication failed — check the username and password.".to_string(),
+        );
+    }
+
+    // Elevation: the polkit / macOS admin prompt was dismissed or unavailable. No
+    // credential the user types into Eldrun can fix this one.
+    if s.contains("authorization was declined")
+        || s.contains("request dismissed")
+        || s.contains("not authorized")
+    {
+        return Some(
+            "Elevation was declined — OpenVPN needs root to create the tunnel device."
+                .to_string(),
+        );
+    }
+
+    // Reachability / config problems, which a user easily mistakes for bad creds.
+    if s.contains("cannot resolve host address") || s.contains("resolve: cannot resolve") {
+        return Some(
+            "Cannot resolve the VPN server's address — check the config, and that you're online."
+                .to_string(),
+        );
+    }
+    if s.contains("tls key negotiation failed") || s.contains("tls handshake failed") {
+        return Some(
+            "VPN TLS handshake failed — the server never completed the key exchange. Check \
+             that this config is current and the server is reachable."
+                .to_string(),
+        );
+    }
+    if s.contains("cannot open tun/tap") || s.contains("cannot allocate tun/tap") {
+        return Some(
+            "Could not create the VPN tunnel device — OpenVPN needs root, and the tun module \
+             must be available."
+                .to_string(),
+        );
+    }
+    if s.contains("connection refused") {
+        return Some("The VPN server refused the connection — check the config's port/protocol."
+            .to_string());
+    }
+
+    None
 }
 
 /// Derive a filesystem-safe stem from a config path for naming its runtime
@@ -148,43 +900,488 @@ fn safe_stem(config: &str) -> String {
 }
 
 /// Write `password` to an owner-only (0600) askpass file and return its path.
+/// On Windows the 0600 mode is skipped (no `mode()`); the file lives under the
+/// per-user `%APPDATA%\eldrun\openvpn` dir, which is already user-scoped, and is
+/// deleted as soon as OpenVPN has read it.
 fn write_askpass(stem: &str, password: &str) -> Result<PathBuf, String> {
     let dir = runtime_dir();
     std::fs::create_dir_all(&dir).map_err(|e| format!("create openvpn dir: {e}"))?;
     let path = dir.join(format!("{stem}.pass"));
-    let mut f = std::fs::OpenOptions::new()
-        .write(true)
-        .create(true)
-        .truncate(true)
-        .mode(0o600)
+    let mut opts = std::fs::OpenOptions::new();
+    opts.write(true).create(true).truncate(true);
+    #[cfg(unix)]
+    opts.mode(0o600);
+    let mut f = opts
         .open(&path)
         .map_err(|e| format!("create askpass file: {e}"))?;
     writeln!(f, "{password}").map_err(|e| format!("write askpass file: {e}"))?;
     Ok(path)
 }
 
+/// Write a two-line `username\npassword` credentials file (owner-only, 0600) for
+/// `--auth-user-pass` and return its path. Same lifetime/permissions story as
+/// [`write_askpass`]: it lives under the per-user runtime dir and is deleted as
+/// soon as OpenVPN has read it. A newline in either field would forge extra lines
+/// OpenVPN misreads, so both are rejected (they can't occur in a real credential
+/// anyway).
+fn write_userpass(stem: &str, username: &str, password: &str) -> Result<PathBuf, String> {
+    if username.contains(['\n', '\r']) || password.contains(['\n', '\r']) {
+        return Err("VPN username/password must not contain newlines".to_string());
+    }
+    let dir = runtime_dir();
+    std::fs::create_dir_all(&dir).map_err(|e| format!("create openvpn dir: {e}"))?;
+    let path = dir.join(format!("{stem}.auth"));
+    let mut opts = std::fs::OpenOptions::new();
+    opts.write(true).create(true).truncate(true);
+    #[cfg(unix)]
+    opts.mode(0o600);
+    let mut f = opts
+        .open(&path)
+        .map_err(|e| format!("create auth-user-pass file: {e}"))?;
+    writeln!(f, "{username}\n{password}").map_err(|e| format!("write auth-user-pass file: {e}"))?;
+    Ok(path)
+}
+
+// --- OpenVPN management interface: teardown without a second password --------
+//
+// Bringing a tunnel UP costs one polkit prompt (`pkexec openvpn`) and always will:
+// the tun device and the routing table genuinely need root. Taking it DOWN used to
+// cost a *second* one, because the daemon is root-owned and a plain `kill` gets
+// EPERM — so teardown had to be `pkexec kill`, and polkit authenticates per
+// invocation. That is one password too many. The user already authorized this exact
+// tunnel; re-authorizing to stop the process Eldrun itself started is pure friction,
+// and it is worst on the app-close path, where it lands as a prompt in front of
+// someone who has already decided to quit.
+//
+// OpenVPN's own management interface removes it. Eldrun controls the argv for every
+// tunnel it starts — the headless one AND the one typed into a terminal tab — so
+// each connect now appends `--management 127.0.0.1 <port> <pwfile>`, and teardown
+// simply opens that loopback socket and sends `signal SIGTERM`. **The daemon signals
+// itself**, so there is nothing to elevate and no prompt to raise.
+//
+// The endpoint is recorded on disk beside the pidfile (`{stem}.mgmt` = port,
+// `{stem}.mgmt.pw` = password) rather than only in memory, for the same reason the
+// pidfile is: a tunnel started by a previous Eldrun run must still be stoppable
+// after a restart.
+//
+// Access control: the socket is loopback-only and gated by a 32-byte CSPRNG password
+// in an owner-only (0600) file. Another process running as this user could read it
+// and stop the tunnel — but that process could equally kill Eldrun outright or read
+// its state dir, so this grants it nothing it did not already have.
+//
+// Every caller treats management as an **optimization, never a guarantee**: a
+// failed, unanswered, or unconfirmed shutdown falls straight through to the elevated
+// kill exactly as before, so no path can silently leave a tunnel up. That is what
+// makes it safe to attach to the interactive command too, where OpenVPN may be an
+// older build or the user may have edited the command before running it.
+
+/// How long to wait for the daemon to actually exit after it acknowledges the
+/// management `signal SIGTERM` (it still has routes to unwind), and how often to
+/// look. Only a pid that has *gone* lets a caller skip the elevated kill.
+#[cfg(unix)]
+const MANAGEMENT_EXIT_POLL: Duration = Duration::from_millis(100);
+#[cfg(unix)]
+const MANAGEMENT_EXIT_POLLS: usize = 50; // ≤5s
+
+/// Where the management port for `config` is recorded.
+fn management_portfile(config: &str) -> PathBuf {
+    runtime_dir().join(format!("{}.mgmt", safe_stem(config)))
+}
+
+/// The password file OpenVPN reads to guard its management socket — and that
+/// Eldrun reads back to authenticate against it.
+fn management_pwfile(config: &str) -> PathBuf {
+    runtime_dir().join(format!("{}.mgmt.pw", safe_stem(config)))
+}
+
+/// The `--management <ip> <port> <pwfile>` argv fragment. Pure and cfg-free so its
+/// shape is unit-testable without opening a socket.
+pub fn management_args(port: u16, pwfile: &Path) -> Vec<String> {
+    vec![
+        "--management".to_string(),
+        "127.0.0.1".to_string(),
+        port.to_string(),
+        pwfile.to_string_lossy().into_owned(),
+    ]
+}
+
+/// Random lowercase-hex string of `bytes` random bytes, straight from the OS
+/// CSPRNG. `None` if it cannot be read, which simply means no management endpoint
+/// is armed and teardown keeps the elevated kill.
+#[cfg(unix)]
+fn random_hex(bytes: usize) -> Option<String> {
+    use std::io::Read;
+    let mut buf = vec![0u8; bytes];
+    std::fs::File::open("/dev/urandom")
+        .ok()?
+        .read_exact(&mut buf)
+        .ok()?;
+    Some(buf.iter().map(|b| format!("{b:02x}")).collect())
+}
+
+/// Forget any endpoint recorded for `config`. Called before arming a new one (a
+/// stale port from a previous run would send teardown at a dead socket) and after
+/// a confirmed shutdown.
+#[cfg(unix)]
+fn clear_management(config: &str) {
+    let _ = std::fs::remove_file(management_portfile(config));
+    let _ = std::fs::remove_file(management_pwfile(config));
+}
+
+/// Claim a management endpoint for `config` and return the `--management` argv the
+/// connect must carry. `None` when none could be armed (no free port, no CSPRNG, an
+/// unwritable runtime dir) — the tunnel then simply keeps the old elevated-kill
+/// teardown, which is why every caller ignores the failure.
+/// A/B kill switch for the `--management` socket (added 2026-07-23, restored
+/// 2026-07-24). It was briefly suspected of the amber-forever connect and gated off to
+/// prove it; the real cause was a locked keyring blocking keychain reads
+/// (`remote_credentials::read_timed`), so the socket is back on — it is the
+/// single-elevation teardown (no second polkit prompt to stop a tunnel). Left as a
+/// const so it can be flipped again without disturbing the two paths that arm it.
+#[cfg(unix)]
+const MANAGEMENT_SOCKET_DISABLED: bool = false;
+
+#[cfg(unix)]
+fn arm_management(config: &str) -> Option<Vec<String>> {
+    if MANAGEMENT_SOCKET_DISABLED {
+        return None;
+    }
+    // A config that already opens its own management socket keeps it — passing
+    // `--management` on top would be the option twice, which OpenVPN refuses, and a
+    // refused option means the tunnel does not come up at all.
+    if config_declares_management(config) {
+        return None;
+    }
+    std::fs::create_dir_all(runtime_dir()).ok()?;
+    clear_management(config);
+    // Bind :0, read the port the kernel picked, release it. A racing bind in that
+    // gap only makes OpenVPN fail to open its socket, which costs the tunnel
+    // nothing — teardown falls back to the elevated kill.
+    let port = std::net::TcpListener::bind(("127.0.0.1", 0))
+        .ok()?
+        .local_addr()
+        .ok()?
+        .port();
+    let password = random_hex(32)?;
+    let pwfile = management_pwfile(config);
+    let mut opts = std::fs::OpenOptions::new();
+    opts.write(true).create(true).truncate(true);
+    opts.mode(0o600);
+    let mut f = opts.open(&pwfile).ok()?;
+    writeln!(f, "{password}").ok()?;
+    drop(f);
+    std::fs::write(management_portfile(config), format!("{port}\n")).ok()?;
+    Some(management_args(port, &pwfile))
+}
+
+/// Read back the endpoint recorded for `config`, if any.
+#[cfg(unix)]
+fn management_endpoint(config: &str) -> Option<(u16, String)> {
+    let port: u16 = std::fs::read_to_string(management_portfile(config))
+        .ok()?
+        .trim()
+        .parse()
+        .ok()?;
+    let password = std::fs::read_to_string(management_pwfile(config))
+        .ok()?
+        .lines()
+        .next()?
+        .to_string();
+    Some((port, password))
+}
+
+/// The pid of whichever flavour of tunnel `config` has recorded on disk — headless
+/// first, then interactive. Used only to CONFIRM that a management shutdown took.
+#[cfg(unix)]
+fn tunnel_pid(config: &str) -> Option<i32> {
+    pidfile_pid(&runtime_dir().join(format!("{}.pid", safe_stem(config))))
+        .or_else(|| pidfile_pid(&interactive_pidfile(config)))
+}
+
+/// Authenticate against the management socket on `port` and send `signal SIGTERM`.
+/// Reports only whether the command was *delivered*; whether the daemon actually
+/// died is [`management_shutdown`]'s job to confirm.
+///
+/// The greeting has to be read as bytes rather than lines: with a password file set,
+/// OpenVPN's first write is the bare prompt `ENTER PASSWORD:` with **no newline**, so
+/// a line-oriented read would block on it forever.
+#[cfg(unix)]
+fn management_send_sigterm(port: u16, password: &str) -> bool {
+    use std::io::Read;
+    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));
+    let Ok(mut sock) = std::net::TcpStream::connect_timeout(&addr, Duration::from_secs(2)) else {
+        return false;
+    };
+    let _ = sock.set_read_timeout(Some(Duration::from_millis(250)));
+    let _ = sock.set_write_timeout(Some(Duration::from_secs(2)));
+
+    let deadline = Instant::now() + Duration::from_secs(3);
+    let mut seen = String::new();
+    let mut buf = [0u8; 512];
+    // An empty password means the socket was armed without one; nothing to answer.
+    let mut authed = password.is_empty();
+    while Instant::now() < deadline {
+        match sock.read(&mut buf) {
+            Ok(0) => return false, // peer closed before we got anywhere
+            Ok(n) => seen.push_str(&String::from_utf8_lossy(&buf[..n])),
+            // A read timeout is just "nothing yet" — keep waiting out the deadline.
+            Err(_) => {}
+        }
+        if !authed && seen.contains("ENTER PASSWORD:") {
+            if writeln!(sock, "{password}").is_err() {
+                return false;
+            }
+            let _ = sock.flush();
+            authed = true;
+            seen.clear();
+            continue;
+        }
+        // A rejected password is `ERROR: bad password` (OpenVPN then closes, which
+        // the `Ok(0)` above also catches). Neither token appears in a success flow.
+        if seen.contains("FAILED") || seen.contains("ERROR:") {
+            return false;
+        }
+        // `SUCCESS: password is correct` (password set) or the unsolicited
+        // `>INFO:OpenVPN Management Interface Version …` banner (no password).
+        if authed && (seen.contains("SUCCESS") || seen.contains(">INFO")) {
+            break;
+        }
+    }
+    if !authed {
+        return false;
+    }
+    writeln!(sock, "signal SIGTERM").is_ok() && sock.flush().is_ok()
+}
+
+/// Ask the tunnel for `config` to stop over its own management socket, and report
+/// whether it is **confirmed down**. Only a `true` lets a caller skip the elevated
+/// kill; every other outcome falls through to it.
+#[cfg(unix)]
+fn management_shutdown(config: &str) -> bool {
+    let Some((port, password)) = management_endpoint(config) else {
+        return false;
+    };
+    if !management_send_sigterm(port, &password) {
+        return false;
+    }
+    // `signal SIGTERM` is asynchronous — OpenVPN acknowledges it, then unwinds its
+    // routes and exits. Only a pid that has actually gone proves the tunnel is down;
+    // anything less and we would skip the elevated kill on a still-live tunnel.
+    let Some(pid) = tunnel_pid(config) else {
+        // Nothing recorded to confirm against. Harmless either way: with no pidfile
+        // the elevated kill this gates has nothing to signal either.
+        clear_management(config);
+        return true;
+    };
+    for _ in 0..MANAGEMENT_EXIT_POLLS {
+        if !pid_alive(pid) {
+            clear_management(config);
+            return true;
+        }
+        std::thread::sleep(MANAGEMENT_EXIT_POLL);
+    }
+    false
+}
+
 /// True if a tunnel for `config` is currently up (registered and its process is
-/// still alive).
+/// still alive). Shared by Linux and Windows since both track the spawned child
+/// in [`registry`].
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+pub fn is_connected(config: &str) -> bool {
+    {
+        let mut reg = registry().lock().unwrap();
+        let headless = match reg.get_mut(config) {
+            Some(proc) => match proc.child.try_wait() {
+                Ok(Some(_)) => {
+                    // Exited — drop the dead entry.
+                    reg.remove(config);
+                    false
+                }
+                Ok(None) => true,
+                Err(_) => true,
+            },
+            None => false,
+        };
+        if headless {
+            return true;
+        }
+    }
+    // A service-started tunnel (Windows): the control pipe is the liveness
+    // signal — the service closes it when the openvpn.exe it spawned exits.
+    #[cfg(target_os = "windows")]
+    {
+        if svc_connected(config) {
+            return true;
+        }
+    }
+    // Not one of ours — but an *interactive* tunnel (started in a terminal tab) is
+    // just as up, and just as much in charge of the machine's routing.
+    interactive_connected(config)
+}
+
+/// True if a tunnel for `config` is currently up: registered and its recorded
+/// daemon pid probes alive via `kill(pid, 0)` — where **EPERM counts as
+/// alive** (the daemon is root; see [`pid_alive`]). This feeds `openvpn_status`,
+/// so getting EPERM wrong keeps the VPN lamp dark (the 28l bug). A registered
+/// tunnel whose pid is gone is dropped from the registry.
+#[cfg(target_os = "macos")]
 pub fn is_connected(config: &str) -> bool {
-    let mut reg = registry().lock().unwrap();
-    match reg.get_mut(config) {
-        Some(proc) => match proc.child.try_wait() {
-            Ok(Some(_)) => {
-                // Exited — drop the dead entry.
-                reg.remove(config);
-                false
+    {
+        let mut reg = mac_registry().lock().unwrap();
+        let headless = match reg.get(config) {
+            Some(proc) => match pidfile_pid(&proc.pidfile) {
+                Some(pid) if pid_alive(pid) => true,
+                _ => {
+                    let dead = reg.remove(config);
+                    if let Some(dead) = dead {
+                        let _ = std::fs::remove_file(&dead.pidfile);
+                        let _ = std::fs::remove_file(&dead.logfile);
+                    }
+                    false
+                }
+            },
+            None => false,
+        };
+        if headless {
+            return true;
+        }
+    }
+    // ...or an interactive tunnel from a terminal tab (see `interactive_registry`).
+    interactive_connected(config)
+}
+
+/// Every config whose tunnel is currently up.
+///
+/// A tunnel is a **machine-level** object — it owns the box's routing (and often
+/// its DNS) for as long as it lives, no matter which project asked for it — so the
+/// UI needs to be able to ask "what is up right now?" without going project by
+/// project. This is that question. It also re-seats the frontend after a reload or
+/// a renderer crash, where the tunnel outlives the window that started it.
+///
+/// Keys are snapshotted before probing: [`is_connected`] takes the registry lock
+/// itself (and reaps dead entries under it), so holding it across the filter would
+/// deadlock.
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+pub fn active_configs() -> Vec<String> {
+    let mut keys: Vec<String> = registry().lock().unwrap().keys().cloned().collect();
+    keys.extend(interactive_registry().lock().unwrap().keys().cloned());
+    #[cfg(target_os = "windows")]
+    keys.extend(svc_registry().lock().unwrap().keys().cloned());
+    keys.sort();
+    keys.dedup();
+    keys.into_iter().filter(|c| is_connected(c)).collect()
+}
+
+/// macOS analog of the above (its tunnels live in [`mac_registry`], keyed the same
+/// way — by config path).
+#[cfg(target_os = "macos")]
+pub fn active_configs() -> Vec<String> {
+    let mut keys: Vec<String> = mac_registry().lock().unwrap().keys().cloned().collect();
+    keys.extend(interactive_registry().lock().unwrap().keys().cloned());
+    keys.sort();
+    keys.dedup();
+    keys.into_iter().filter(|c| is_connected(c)).collect()
+}
+
+/// Re-adopt tunnels a **previous run of Eldrun** (or a crash) left running, so the
+/// VPN lamp reflects the machine's *actual* routing at launch instead of a blank
+/// slate.
+///
+/// Every live-tunnel registry — [`registry`] (headless), [`interactive_registry`],
+/// and macOS's `mac_registry` — is **in-memory only**. Nothing rebuilds them from
+/// disk. So after a full restart Eldrun has no record of a tunnel it started before,
+/// yet the OpenVPN daemon runs as **root** and survives the app dying (a renderer
+/// SIGBUS that takes the process down, an OOM kill, a refused polkit prompt at quit,
+/// a plain crash): it is reparented to init and keeps rerouting the whole machine.
+/// The machines then still connect over SSH — exactly the "lamp is grey but the
+/// machines are up" symptom — because the routing the tunnel installed is genuinely
+/// still there; only Eldrun's memory of it is gone.
+///
+/// This closes that gap. For every **stored** config it looks for the pidfiles
+/// Eldrun writes to [`runtime_dir`] — `{stem}.pid` (headless) and
+/// `{stem}.interactive.pid` (interactive) — and, when the recorded pid is still
+/// alive, re-registers the tunnel; a pidfile whose pid is dead is a stale leftover
+/// and is removed. Recovered tunnels are seated in [`interactive_registry`]
+/// regardless of which flavour wrote the pidfile: after a restart there is no
+/// [`Child`] handle to reconstruct, so a bare pid + [`pid_alive`] + [`kill_root_pid`]
+/// is the only liveness/teardown model available — which is precisely the interactive
+/// one, and it makes the recovered tunnel visible ([`is_connected`]/[`active_configs`])
+/// and killable ([`disconnect`]/[`disconnect_all`]) just like any other.
+///
+/// Only tunnels for configs Eldrun *stored* are recoverable: a tunnel brought up
+/// entirely outside Eldrun (NetworkManager, systemd, a manual `sudo openvpn`) has no
+/// Eldrun-owned pidfile to map back to a config, so it is out of scope here.
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+pub fn adopt_orphans() {
+    for cfg in list_configs() {
+        adopt_config(&cfg.path);
+    }
+}
+
+/// Re-adopt one config's orphaned tunnel if its pidfile records a live root daemon.
+/// Returns `true` when a tunnel was (re-)seated. The per-config core of
+/// [`adopt_orphans`], split out so the recovery logic is unit-testable against a
+/// throwaway config path without touching the real config store.
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+fn adopt_config(config: &str) -> bool {
+    // Already tracked by a live registry entry (this can run after another path
+    // seated the tunnel) — leave it be.
+    if is_connected(config) {
+        return false;
+    }
+    let stem = safe_stem(config);
+    // Prefer the headless pidfile, then the interactive one; either records the
+    // root daemon's pid, which is all a post-restart adopt can act on.
+    let candidates = [
+        runtime_dir().join(format!("{stem}.pid")),
+        interactive_pidfile(config),
+    ];
+    for pidfile in candidates {
+        match pidfile_pid(&pidfile) {
+            Some(pid) if pid_alive(pid) => {
+                interactive_registry()
+                    .lock()
+                    .unwrap()
+                    .insert(config.to_string(), pidfile);
+                return true;
             }
-            Ok(None) => true,
-            Err(_) => true,
-        },
-        None => false,
+            // Pid recorded but gone: a stale file from a tunnel that has since
+            // died. Drop it so a later connect can't mistake it for a live one.
+            Some(_) => {
+                let _ = std::fs::remove_file(&pidfile);
+            }
+            None => {}
+        }
     }
+    false
+}
+
+/// Bring up the OpenVPN tunnel for `config`, authenticating with `password` (and
+/// `key_passphrase` for a config that *also* has an encrypted private key — see
+/// [`write_credfiles`]). No-op (returns `Ok`) if already connected. Blocks until
+/// OpenVPN reports the tunnel up, the process exits, or `CONNECT_TIMEOUT` elapses.
+#[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+pub fn connect(
+    config: &str,
+    username: Option<&str>,
+    password: &str,
+    key_passphrase: Option<&str>,
+) -> Result<(), String> {
+    connect_streaming(config, username, password, key_passphrase, |_| {})
 }
 
-/// Bring up the OpenVPN tunnel for `config`, authenticating with `password`.
-/// No-op (returns `Ok`) if already connected. Blocks until OpenVPN reports the
-/// tunnel up, the process exits, or `CONNECT_TIMEOUT` elapses.
-pub fn connect(config: &str, password: &str) -> Result<(), String> {
+/// Like [`connect`], but invokes `on_line` for every line OpenVPN emits while the
+/// tunnel comes up (stdout + stderr), so the caller can stream the live handshake
+/// into a read-only log. The callback runs on the calling thread, before the
+/// ready-marker check, so the marker line is reported too.
+#[cfg(target_os = "linux")]
+pub fn connect_streaming(
+    config: &str,
+    username: Option<&str>,
+    password: &str,
+    key_passphrase: Option<&str>,
+    on_line: impl Fn(&str),
+) -> Result<(), String> {
     let config = config.trim();
     validate_arg("OpenVPN config", config)?;
     if !Path::new(config).is_file() {
@@ -201,9 +1398,30 @@ pub fn connect(config: &str, password: &str) -> Result<(), String> {
     }
 
     let stem = safe_stem(config);
-    let askpass = write_askpass(&stem, password)?;
+    // Feed the secrets through whichever channels the config actually reads —
+    // both, when it has an `auth-user-pass` account *and* an encrypted key.
+    let (userpass_file, askpass_file) =
+        write_credfiles(config, &stem, username, password, key_passphrase)?;
     let pidfile = runtime_dir().join(format!("{stem}.pid"));
-    let args = openvpn_args(config, &askpass, &pidfile)?;
+    let mut args = openvpn_args(
+        config,
+        userpass_file.as_deref(),
+        askpass_file.as_deref(),
+        &pidfile,
+    )?;
+    // Give the daemon a management socket so `disconnect` can ask it to stop rather
+    // than spend a second polkit prompt on `pkexec kill`. Optional by design — a
+    // tunnel with no endpoint armed simply keeps the elevated teardown.
+    if let Some(mgmt) = arm_management(config) {
+        args.extend(mgmt);
+    }
+    // The credentials have been read once OpenVPN is up (or has failed); remove
+    // whichever files we wrote, on every exit path.
+    let remove_credfiles = || {
+        for f in [userpass_file.as_deref(), askpass_file.as_deref()].into_iter().flatten() {
+            let _ = std::fs::remove_file(f);
+        }
+    };
 
     let spawn_result = Command::new("pkexec")
         .arg("openvpn")
@@ -216,15 +1434,14 @@ pub fn connect(config: &str, password: &str) -> Result<(), String> {
     let mut child = match spawn_result {
         Ok(c) => c,
         Err(e) => {
-            let _ = std::fs::remove_file(&askpass);
+            remove_credfiles();
             return Err(format!("failed to launch pkexec openvpn: {e}"));
         }
     };
 
-    // Stream stdout until the ready marker, EOF, or timeout.
-    let ready = wait_for_ready(&mut child);
-    // The passphrase has been read by now; remove it regardless of outcome.
-    let _ = std::fs::remove_file(&askpass);
+    // Stream stdout/stderr until the ready marker, EOF, or timeout.
+    let ready = wait_for_ready(&mut child, &on_line);
+    remove_credfiles();
 
     match ready {
         Ok(()) => {
@@ -237,87 +1454,1189 @@ pub fn connect(config: &str, password: &str) -> Result<(), String> {
         Err(msg) => {
             let _ = child.kill();
             let _ = child.wait();
-            Err(msg)
+            // Say which secret was wrong; fall back to the raw handshake tail.
+            Err(explain_openvpn_error(&msg).unwrap_or(msg))
         }
     }
 }
 
-/// Read the child's stdout until the ready marker appears (Ok), the stream ends
-/// (Err with the tail), or the timeout elapses (Err).
-fn wait_for_ready(child: &mut Child) -> Result<(), String> {
+/// Wait until OpenVPN reports the tunnel up (Ok), the process ends without the
+/// marker (Err with the tail), or [`CONNECT_TIMEOUT`] elapses (Err). Shared by
+/// Linux/Windows.
+///
+/// Both stdout *and* stderr are drained on background threads feeding a channel,
+/// and the wait loop blocks on `recv_timeout` rather than directly on a read.
+/// This is deliberate: a plain `for line in reader.lines()` only re-checks the
+/// deadline once a line arrives, so a child that emits *nothing* — e.g. `pkexec`
+/// blocked on a polkit prompt that is never answered (or has no agent), or a
+/// stalled handshake — would hang indefinitely instead of timing out. Reading
+/// stderr too means `pkexec`/driver errors (which never touch stdout) surface in
+/// the failure message instead of being lost.
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+fn wait_for_ready(child: &mut Child, on_line: &dyn Fn(&str)) -> Result<(), String> {
+    use std::sync::mpsc::{self, RecvTimeoutError};
+
     let stdout = child
         .stdout
         .take()
         .ok_or_else(|| "openvpn produced no stdout".to_string())?;
-    let start = Instant::now();
-    let mut tail: Vec<String> = Vec::new();
-    let reader = BufReader::new(stdout);
-    for line in reader.lines() {
-        if start.elapsed() > CONNECT_TIMEOUT {
-            return Err("OpenVPN connection timed out".to_string());
+    let stderr = child.stderr.take();
+
+    let (tx, rx) = mpsc::channel::<String>();
+    let tx_err = tx.clone();
+    std::thread::spawn(move || {
+        for line in BufReader::new(stdout).lines() {
+            match line {
+                Ok(l) => {
+                    if tx.send(l).is_err() {
+                        break; // receiver gone (timed out / found marker)
+                    }
+                }
+                Err(_) => break,
+            }
+        }
+    });
+    match stderr {
+        Some(stderr) => {
+            std::thread::spawn(move || {
+                for line in BufReader::new(stderr).lines() {
+                    match line {
+                        Ok(l) => {
+                            if tx_err.send(l).is_err() {
+                                break;
+                            }
+                        }
+                        Err(_) => break,
+                    }
+                }
+            });
         }
-        let line = match line {
-            Ok(l) => l,
-            Err(_) => break,
+        // No stderr pipe: drop the spare sender so the channel can disconnect
+        // once the stdout reader finishes (otherwise `Disconnected` never fires).
+        None => drop(tx_err),
+    }
+
+    let start = Instant::now();
+    let mut tail: Vec<String> = Vec::new();
+    loop {
+        let remaining = match CONNECT_TIMEOUT.checked_sub(start.elapsed()) {
+            Some(r) if !r.is_zero() => r,
+            _ => return Err("OpenVPN connection timed out".to_string()),
         };
-        if line.contains(READY_MARKER) {
-            return Ok(());
+        match rx.recv_timeout(remaining) {
+            Ok(line) => {
+                // Surface every line (stdout + stderr) to the caller so the UI can
+                // render the live handshake, then keep the marker/tail bookkeeping.
+                on_line(&line);
+                if line.contains(READY_MARKER) {
+                    return Ok(());
+                }
+                tail.push(line);
+                if tail.len() > 8 {
+                    tail.remove(0);
+                }
+            }
+            Err(RecvTimeoutError::Timeout) => {
+                return Err("OpenVPN connection timed out".to_string());
+            }
+            // Both readers ended → the process exited without the marker.
+            Err(RecvTimeoutError::Disconnected) => {
+                let detail = tail.join("; ");
+                return if detail.is_empty() {
+                    Err("OpenVPN exited before the tunnel came up".to_string())
+                } else {
+                    Err(format!("OpenVPN failed: {detail}"))
+                };
+            }
+        }
+    }
+}
+
+/// Tear down the tunnel for `config` if it is up. Best-effort: signals the root
+/// OpenVPN process via `pkexec kill` (reading the pid OpenVPN wrote), then reaps
+/// our child. A missing/already-dead tunnel is treated as success.
+#[cfg(target_os = "linux")]
+pub fn disconnect(config: &str) -> Result<(), String> {
+    // First ask the daemon to stop over its own management socket — no elevation,
+    // hence no second password. When it works the pid below is already gone, so
+    // `kill_already_handled` short-circuits every elevated kill that follows; when
+    // it doesn't, those kills run exactly as they always did.
+    management_shutdown(config);
+    // An interactive tunnel has no child of ours — kill it by the pid it wrote.
+    disconnect_interactive(config);
+    let proc = registry().lock().unwrap().remove(config);
+    let Some(mut proc) = proc else {
+        return Ok(());
+    };
+    let _ = kill_pidfile(&proc.pidfile);
+    let _ = proc.child.kill();
+    let _ = proc.child.wait();
+    let _ = std::fs::remove_file(&proc.pidfile);
+    Ok(())
+}
+
+/// Interactive-tunnel teardown that reports whether the tunnel is down afterwards.
+/// Mirrors [`disconnect_interactive`] but keeps the registry claim when the elevated
+/// kill is refused, so a cancelled polkit prompt leaves the tunnel visible and
+/// killable rather than forgotten-but-alive.
+#[cfg(target_os = "linux")]
+fn disconnect_interactive_checked(config: &str) -> bool {
+    match interactive_state(config) {
+        Interactive::Alive(pid) => {
+            if !kill_root_pid_checked(pid) {
+                return false;
+            }
+            if let Some(pidfile) = interactive_registry().lock().unwrap().remove(config) {
+                let _ = std::fs::remove_file(&pidfile);
+            }
+            true
+        }
+        // Never authenticated — nothing root-owned to kill; drop the stale claim.
+        Interactive::Pending => {
+            interactive_registry().lock().unwrap().remove(config);
+            true
+        }
+        Interactive::None => true,
+    }
+}
+
+/// `pkexec kill -TERM` a root-owned pid, reporting whether it was delivered (vs. a
+/// refused polkit prompt). The checked twin of [`kill_root_pid`].
+#[cfg(target_os = "linux")]
+fn kill_root_pid_checked(pid: i32) -> bool {
+    // Already TERMed (or already gone) — the tunnel is down or going down, and a
+    // second `pkexec` would only cost the user a second password. See `signalled_pids`.
+    if kill_already_handled(pid) {
+        return true;
+    }
+    let ok = Command::new("pkexec")
+        .arg("kill")
+        .arg("-TERM")
+        .arg(pid.to_string())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false);
+    if ok {
+        mark_signalled(pid);
+    }
+    ok
+}
+
+/// Like [`disconnect`], but reports whether the tunnel actually went down.
+///
+/// The app-close path needs this. `disconnect` is best-effort — it drops the
+/// registry entry and ignores whether the elevated `pkexec kill` succeeded — which
+/// is right for exit-time cleanup but wrong for the one interactive ask on the
+/// close path: the frontend needs to know a "no" happened so it can warn the user
+/// that the tunnel (and the machine-wide routing it installed) is staying up,
+/// rather than silently forgetting it. On failure the registry entry is preserved
+/// so the tunnel stays visible (`active_configs`) and killable, and the config is
+/// [`mark_declined`]ed so no later pass re-prompts for it (the quit itself is no
+/// longer blocked on this — see `AppShell`'s close handler).
+#[cfg(target_os = "linux")]
+pub fn disconnect_checked(config: &str) -> Result<(), String> {
+    // Management socket first: it stops the daemon with no elevation at all, which
+    // is what keeps the app-close path to ZERO password prompts. Both checked kills
+    // below then find a dead pid and skip their `pkexec`. Only if this fails does the
+    // user see a prompt — and then exactly one, which they may still decline.
+    management_shutdown(config);
+    // Interactive tunnel (terminal-started) first — its own elevated kill.
+    if !disconnect_interactive_checked(config) {
+        mark_declined(config);
+        return Err("openvpn teardown was not authorized".into());
+    }
+    // Headless tunnel: peek the pidfile without removing, so a refused kill leaves
+    // the entry in place.
+    let pidfile = registry()
+        .lock()
+        .unwrap()
+        .get(config)
+        .map(|p| p.pidfile.clone());
+    let Some(pidfile) = pidfile else {
+        return Ok(());
+    };
+    if !kill_pidfile(&pidfile) {
+        mark_declined(config);
+        return Err("openvpn teardown was not authorized".into());
+    }
+    // TERM delivered — now reap our child and forget it.
+    if let Some(mut proc) = registry().lock().unwrap().remove(config) {
+        let _ = proc.child.kill();
+        let _ = proc.child.wait();
+        let _ = std::fs::remove_file(&proc.pidfile);
+    }
+    Ok(())
+}
+
+/// Non-Linux: no polkit prompt to cancel (Windows brings tunnels up through the
+/// unelevated interactive service; macOS raises an `osascript` admin prompt whose
+/// cancellation is a smaller, separate gap), so the app-close path falls back to the
+/// best-effort teardown.
+#[cfg(not(target_os = "linux"))]
+pub fn disconnect_checked(config: &str) -> Result<(), String> {
+    disconnect(config)
+}
+
+/// `pkexec kill` the pid recorded in `pidfile` (the root OpenVPN process). Returns
+/// whether the tunnel can be considered down afterwards: `true` if the TERM was
+/// delivered (or there was no pid to kill), `false` if the elevated kill was refused
+/// — a cancelled polkit prompt, which leaves the tunnel (and the machine's routing)
+/// up. Best-effort callers ignore the bool; the app-close path (`disconnect_checked`)
+/// reads it to decide whether the quit can proceed.
+#[cfg(target_os = "linux")]
+fn kill_pidfile(pidfile: &Path) -> bool {
+    // No pid on disk (or an unusable one) — nothing to kill, and nothing that may
+    // reach `kill` unvalidated. `pidfile_pid` is the one place that parse lives.
+    let Some(pid) = pidfile_pid(pidfile) else {
+        return true;
+    };
+    // Already TERMed (or already gone): report success without re-elevating, so the
+    // exit-time `disconnect_all` never re-prompts for a tunnel the on-quit teardown
+    // already took down. See `signalled_pids`.
+    if kill_already_handled(pid) {
+        return true;
+    }
+    let ok = Command::new("pkexec")
+        .arg("kill")
+        .arg("-TERM")
+        .arg(pid.to_string())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false);
+    if ok {
+        mark_signalled(pid);
+    }
+    ok
+}
+
+/// Tear down every live tunnel. Used at app exit; errors are swallowed so
+/// shutdown never blocks. Shared by Linux/Windows (each dispatches to its own
+/// platform [`disconnect`]).
+///
+/// Skips any config already [`mark_declined`]ed: the app-close path
+/// (`disconnect_checked`) already asked once, with the window still on screen, and
+/// was told no. Re-asking here would raise a `pkexec` prompt with no window left to
+/// hold it — parentless, easy to miss, and able to sit there stalling shutdown —
+/// which is worse than just leaving a tunnel the user already chose to keep up.
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+pub fn disconnect_all() {
+    // Interactive tunnels included: they are the ones that used to survive the app
+    // and leave the machine's routing rewritten with nothing left to undo it.
+    let keys: Vec<String> = {
+        let reg = registry().lock().unwrap();
+        let interactive = interactive_registry().lock().unwrap();
+        #[cfg(target_os = "windows")]
+        let svc = svc_registry().lock().unwrap();
+        let keys = reg.keys().chain(interactive.keys());
+        #[cfg(target_os = "windows")]
+        let keys = keys.chain(svc.keys());
+        keys.cloned().collect()
+    };
+    for k in keys {
+        if is_declined(&k) {
+            continue;
+        }
+        let _ = disconnect(&k);
+    }
+}
+
+/// The **checked twin of [`disconnect_all`]** used on the app-close path. It tears
+/// down the *same* set of registered tunnels — every key `disconnect_all` would touch,
+/// unfiltered by liveness — while the window is still on screen, which is where a
+/// `pkexec` prompt belongs. It stops at the first refused teardown and reports it, so
+/// the frontend can warn the user their tunnel is staying up — but it does **not**
+/// retry: a refusal is [`mark_declined`]ed, so the exit-time `disconnect_all` leaves it
+/// alone instead of raising a second, parentless prompt after the window is gone.
+/// Enumerating the registries directly — rather than the frontend filtering
+/// `active_configs` — is the point: `active_configs` hides a tunnel whose liveness
+/// probe reads false, which is exactly a tunnel `disconnect_all` would still prompt to
+/// kill.
+#[cfg(any(target_os = "linux", target_os = "windows"))]
+pub fn disconnect_all_checked() -> Result<(), String> {
+    let keys: Vec<String> = {
+        let reg = registry().lock().unwrap();
+        let interactive = interactive_registry().lock().unwrap();
+        #[cfg(target_os = "windows")]
+        let svc = svc_registry().lock().unwrap();
+        let keys = reg.keys().chain(interactive.keys());
+        #[cfg(target_os = "windows")]
+        let keys = keys.chain(svc.keys());
+        keys.cloned().collect()
+    };
+    for k in keys {
+        disconnect_checked(&k)?;
+    }
+    Ok(())
+}
+
+// --- Windows: interactive-service-first tunnel management --------------------
+//
+// Windows has no `pkexec`/polkit, but it has something better suited: the
+// **OpenVPN Interactive Service** (`OpenVPNServiceInteractive`, installed and
+// auto-started by the community installer), which exists precisely so an
+// UNELEVATED client can bring a tunnel up. The client sends one startup
+// message over `\\.\pipe\openvpn\service` — three NUL-terminated UTF-16LE
+// strings: working directory, openvpn command line, stdin data — and the
+// SYSTEM service spawns `openvpn.exe` with the *client's* token, appending a
+// `--msg-channel` through which the privileged work (TUN adapter open, routes,
+// DNS) is done by the service itself. It replies `0x%08x\n%ls\n%ls`: code 0 +
+// the spawned pid on success, an error code + text otherwise. The service also
+// ties the tunnel to the client: when the pipe drops or the process exits, it
+// reverts the routes/DNS it applied (its undo lists) — a service-started
+// tunnel can never outlive Eldrun with the machine's routing still changed.
+//
+// `connect_streaming` therefore tries the service FIRST. The service owns the
+// spawned process's stdio, so the handshake is followed by tailing a `--log`
+// file (`wait_for_ready_logfile`, shared with macOS). Authorization caveat: a
+// user who is neither elevated nor a member of the "OpenVPN Administrators"
+// local group may only use configs inside the machine config directory —
+// Eldrun's stored configs live under %APPDATA%, so [`explain_service_refusal`]
+// turns that refusal into the one-time `net localgroup` fix.
+//
+// Only when the service pipe does not exist (service not installed / not
+// running) does the old path run: spawn `openvpn.exe` directly with the same
+// `--askpass`-file credential flow as Linux, parsing stdout for the ready
+// marker — which only works when Eldrun itself is elevated (creating the
+// TAP/Wintun adapter needs Administrator rights), and the error messages say so.
+
+/// Quote one argument for a Windows command line so `CommandLineToArgvW` —
+/// which the interactive service uses to parse the options string — reads it
+/// back as a single argv item. MSVCRT rules: backslashes are literal except in
+/// front of a `"`, where each doubles and the quote itself is escaped; trailing
+/// backslashes double so they can't eat the closing quote. Compiled cfg-free
+/// for Linux-run unit tests.
+pub fn win_cmdline_quote(arg: &str) -> String {
+    if !arg.is_empty() && !arg.chars().any(|c| matches!(c, ' ' | '\t' | '"')) {
+        return arg.to_string();
+    }
+    let mut out = String::with_capacity(arg.len() + 2);
+    out.push('"');
+    let mut backslashes = 0usize;
+    for ch in arg.chars() {
+        match ch {
+            '\\' => backslashes += 1,
+            '"' => {
+                out.extend(std::iter::repeat('\\').take(backslashes * 2 + 1));
+                out.push('"');
+                backslashes = 0;
+            }
+            _ => {
+                out.extend(std::iter::repeat('\\').take(backslashes));
+                out.push(ch);
+                backslashes = 0;
+            }
+        }
+    }
+    out.extend(std::iter::repeat('\\').take(backslashes * 2));
+    out.push('"');
+    out
+}
+
+/// Join an argv into the single options string the service startup message
+/// carries (the service re-parses it with `CommandLineToArgvW`).
+pub fn svc_options_string(args: &[String]) -> String {
+    args.iter()
+        .map(|a| win_cmdline_quote(a))
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+/// Encode the interactive service's startup message: three NUL-terminated
+/// UTF-16LE strings back to back — working directory, openvpn command line
+/// (WITHOUT the program name; the service prepends its registered exe), and
+/// stdin data (empty here: credentials travel in files, as on every other
+/// platform). Compiled cfg-free for Linux-run unit tests.
+pub fn svc_startup_message(workdir: &str, options: &str, stdin_data: &str) -> Vec<u8> {
+    let mut msg = Vec::with_capacity((workdir.len() + options.len() + stdin_data.len() + 3) * 2);
+    for s in [workdir, options, stdin_data] {
+        for unit in s.encode_utf16().chain(std::iter::once(0)) {
+            msg.extend_from_slice(&unit.to_le_bytes());
+        }
+    }
+    msg
+}
+
+/// A decoded reply from the interactive service: `0x%08x\n%ls\n%ls` in
+/// UTF-16LE. `code` 0 is success, with `detail` carrying the spawned
+/// `openvpn.exe` pid (also `0x%08x`); otherwise `detail`/`message` are the
+/// failing function and its error text.
+pub struct SvcResponse {
+    pub code: u32,
+    pub detail: String,
+    pub message: String,
+}
+
+/// Parse a service reply. `None` when the bytes aren't the expected shape —
+/// the caller reports an unrecognized reply rather than inventing a verdict.
+pub fn svc_parse_response(bytes: &[u8]) -> Option<SvcResponse> {
+    let units: Vec<u16> = bytes
+        .chunks_exact(2)
+        .map(|c| u16::from_le_bytes([c[0], c[1]]))
+        .collect();
+    let text = String::from_utf16_lossy(&units);
+    let text = text.trim_end_matches('\0');
+    let mut lines = text.splitn(3, '\n');
+    let code = lines.next()?.trim();
+    let code = u32::from_str_radix(code.trim_start_matches("0x"), 16).ok()?;
+    Some(SvcResponse {
+        code,
+        detail: lines.next().unwrap_or("").trim().to_string(),
+        message: lines.next().unwrap_or("").trim().to_string(),
+    })
+}
+
+/// The pid the service reports on success (`code` 0, pid in `detail`).
+pub fn svc_response_pid(resp: &SvcResponse) -> Option<u32> {
+    if resp.code != 0 {
+        return None;
+    }
+    u32::from_str_radix(resp.detail.trim_start_matches("0x"), 16).ok()
+}
+
+/// Turn a service refusal into an actionable message. The refusal a non-admin
+/// actually hits is the authorization check (Eldrun's stored configs are not
+/// inside the machine config directory), and the fix is the one-time group
+/// membership the official OpenVPN GUI also sets up — so say exactly that,
+/// keeping the raw service text for everything else. The group's member list
+/// is re-read per connect, so no re-logon is needed after adding.
+pub fn explain_service_refusal(resp: &SvcResponse) -> String {
+    let raw = match (resp.message.is_empty(), resp.detail.is_empty()) {
+        (false, false) => format!("{} ({})", resp.message, resp.detail),
+        (false, true) => resp.message.clone(),
+        (true, false) => resp.detail.clone(),
+        (true, true) => format!("error 0x{:08x}", resp.code),
+    };
+    format!(
+        "the OpenVPN Interactive Service refused to start the tunnel: {raw} — if this is \
+         an authorization error, add your account to the \"OpenVPN Administrators\" group \
+         once (from an elevated prompt: net localgroup \"OpenVPN Administrators\" \
+         \"%USERNAME%\" /add) and reconnect"
+    )
+}
+
+/// The interactive service's control pipe (default instance name).
+#[cfg(target_os = "windows")]
+const SVC_PIPE: &str = r"\\.\pipe\openvpn\service";
+
+/// How long the service gets to answer the startup message. It only has to
+/// validate and `CreateProcess` — the handshake itself is tailed separately.
+#[cfg(target_os = "windows")]
+const SVC_RESPONSE_TIMEOUT: Duration = Duration::from_secs(15);
+
+/// A tunnel brought up through the interactive service: the control pipe
+/// (dropping it is the teardown signal — see [`disconnect`]), the spawned
+/// `openvpn.exe` pid, and the runtime files to reap.
+#[cfg(target_os = "windows")]
+struct SvcVpn {
+    pipe: std::fs::File,
+    pid: u32,
+    pidfile: PathBuf,
+    logfile: PathBuf,
+}
+
+/// Registry of service-started tunnels, keyed by config path (the Windows
+/// third registry, alongside [`registry`] and [`interactive_registry`]).
+#[cfg(target_os = "windows")]
+fn svc_registry() -> &'static Mutex<HashMap<String, SvcVpn>> {
+    static REG: OnceLock<Mutex<HashMap<String, SvcVpn>>> = OnceLock::new();
+    REG.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// Open the service control pipe. `None` = no interactive service on this
+/// machine (pipe absent) — the caller falls back to the direct spawn. A busy
+/// pipe (another client connecting this instant) is retried briefly: the
+/// service re-creates its listening instance right after each accept.
+#[cfg(target_os = "windows")]
+fn svc_open_pipe() -> Option<std::fs::File> {
+    const ERROR_PIPE_BUSY: i32 = 231;
+    for _ in 0..5 {
+        match std::fs::OpenOptions::new().read(true).write(true).open(SVC_PIPE) {
+            Ok(pipe) => return Some(pipe),
+            Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY) => {
+                std::thread::sleep(Duration::from_millis(200));
+            }
+            Err(_) => return None,
+        }
+    }
+    None
+}
+
+/// Bytes waiting on `pipe`, or `None` when the service end is closed. The
+/// service closes the pipe when the `openvpn.exe` it spawned for us exits, so
+/// `None` doubles as "tunnel over".
+#[cfg(target_os = "windows")]
+fn pipe_avail(pipe: &std::fs::File) -> Option<usize> {
+    use std::os::windows::io::AsRawHandle;
+    use windows::Win32::Foundation::HANDLE;
+    use windows::Win32::System::Pipes::PeekNamedPipe;
+    let mut avail = 0u32;
+    unsafe {
+        PeekNamedPipe(
+            HANDLE(pipe.as_raw_handle()),
+            None,
+            0,
+            None,
+            Some(&mut avail),
+            None,
+        )
+    }
+    .ok()
+    .map(|()| avail as usize)
+}
+
+/// Liveness probe for a service tunnel, draining (and discarding) any pending
+/// service chatter so the pipe buffer can never fill up and stall the service.
+#[cfg(target_os = "windows")]
+fn pipe_alive(pipe: &std::fs::File) -> bool {
+    use std::io::Read;
+    match pipe_avail(pipe) {
+        None => false,
+        Some(0) => true,
+        Some(n) => {
+            let mut scratch = vec![0u8; n];
+            let mut reader: &std::fs::File = pipe;
+            let _ = reader.read(&mut scratch);
+            true
+        }
+    }
+}
+
+/// Read the service's reply to the startup message: poll for bytes (a named
+/// pipe read would block indefinitely), then take everything available —
+/// message-read mode was set at connect, so that is exactly one reply. `None`
+/// on timeout or a broken pipe.
+#[cfg(target_os = "windows")]
+fn svc_read_response(pipe: &mut std::fs::File, timeout: Duration) -> Option<Vec<u8>> {
+    use std::io::Read;
+    let start = Instant::now();
+    loop {
+        let avail = pipe_avail(pipe)?;
+        if avail > 0 {
+            let mut buf = vec![0u8; avail];
+            let n = pipe.read(&mut buf).ok()?;
+            buf.truncate(n);
+            return Some(buf);
+        }
+        if start.elapsed() >= timeout {
+            return None;
+        }
+        std::thread::sleep(Duration::from_millis(100));
+    }
+}
+
+/// Outcome of a service-first connect: `Done` is authoritative — the service
+/// was there, and its verdict (up, or why not) is the connect's. Only
+/// `Unavailable` (no pipe: service not installed / not running) falls back to
+/// the direct spawn.
+#[cfg(target_os = "windows")]
+enum SvcAttempt {
+    Done(Result<(), String>),
+    Unavailable,
+}
+
+/// Ask the interactive service to bring the tunnel up (see the section comment
+/// for the protocol). `args` is the argv [`openvpn_args`] built; the caller
+/// still owns the credential files' lifetime.
+#[cfg(target_os = "windows")]
+fn svc_connect_streaming(
+    config: &str,
+    stem: &str,
+    args: &[String],
+    pidfile: &Path,
+    on_line: &impl Fn(&str),
+) -> SvcAttempt {
+    let Some(mut pipe) = svc_open_pipe() else {
+        return SvcAttempt::Unavailable;
+    };
+    // Message-read mode, so each service reply comes out of `read` whole.
+    {
+        use std::os::windows::io::AsRawHandle;
+        use windows::Win32::Foundation::HANDLE;
+        use windows::Win32::System::Pipes::{SetNamedPipeHandleState, PIPE_READMODE_MESSAGE};
+        let mode = PIPE_READMODE_MESSAGE;
+        let _ = unsafe {
+            SetNamedPipeHandleState(HANDLE(pipe.as_raw_handle()), Some(&mode), None, None)
+        };
+    }
+
+    // The service owns the spawned process's stdio, so the handshake is tailed
+    // from a logfile instead (the macOS pattern). Start clean: a stale logfile
+    // would satisfy the tail spuriously.
+    let logfile = runtime_dir().join(format!("{stem}.svc.log"));
+    let _ = std::fs::remove_file(&logfile);
+    let mut svc_args = args.to_vec();
+    svc_args.push("--log".to_string());
+    svc_args.push(logfile.to_string_lossy().into_owned());
+
+    // Working dir = the config's directory, so relative paths inside the config
+    // (ca/cert/key) resolve the same as for a direct spawn.
+    let workdir = Path::new(config)
+        .parent()
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
+    let msg = svc_startup_message(&workdir, &svc_options_string(&svc_args), "");
+    if pipe.write_all(&msg).is_err() {
+        return SvcAttempt::Done(Err(
+            "could not send the connect request to the OpenVPN Interactive Service".to_string(),
+        ));
+    }
+
+    let resp = match svc_read_response(&mut pipe, SVC_RESPONSE_TIMEOUT) {
+        Some(bytes) => match svc_parse_response(&bytes) {
+            Some(resp) => resp,
+            None => {
+                return SvcAttempt::Done(Err(
+                    "unrecognized reply from the OpenVPN Interactive Service".to_string(),
+                ));
+            }
+        },
+        None => {
+            return SvcAttempt::Done(Err(
+                "the OpenVPN Interactive Service did not answer the connect request".to_string(),
+            ));
         }
-        tail.push(line);
-        if tail.len() > 8 {
-            tail.remove(0);
+    };
+    let Some(pid) = svc_response_pid(&resp) else {
+        return SvcAttempt::Done(Err(explain_service_refusal(&resp)));
+    };
+    on_line(&format!(
+        "OpenVPN Interactive Service started openvpn.exe (pid {pid})"
+    ));
+
+    let ready = wait_for_ready_logfile(
+        &logfile,
+        CONNECT_TIMEOUT,
+        Duration::from_millis(300),
+        || pipe_alive(&pipe),
+        |line| on_line(line),
+    );
+    match ready {
+        Ok(()) => {
+            svc_registry().lock().unwrap().insert(
+                config.to_string(),
+                SvcVpn {
+                    pipe,
+                    pid,
+                    pidfile: pidfile.to_path_buf(),
+                    logfile,
+                },
+            );
+            SvcAttempt::Done(Ok(()))
+        }
+        Err(msg) => {
+            // Kill the half-up tunnel; the service sees the exit, reverts any
+            // routes/DNS it applied (its undo lists), and closes the pipe.
+            kill_root_pid(pid as i32);
+            let _ = std::fs::remove_file(&logfile);
+            SvcAttempt::Done(Err(explain_openvpn_error(&msg).unwrap_or(msg)))
+        }
+    }
+}
+
+/// Whether the service-started tunnel for `config` is still up; a dead entry
+/// (service closed the pipe: its openvpn exited) is reaped with its files.
+#[cfg(target_os = "windows")]
+fn svc_connected(config: &str) -> bool {
+    let mut reg = svc_registry().lock().unwrap();
+    match reg.get(config) {
+        Some(svc) if pipe_alive(&svc.pipe) => true,
+        Some(_) => {
+            if let Some(dead) = reg.remove(config) {
+                let _ = std::fs::remove_file(&dead.pidfile);
+                let _ = std::fs::remove_file(&dead.logfile);
+            }
+            false
+        }
+        None => false,
+    }
+}
+
+/// Actionable "openvpn not found" message for Windows.
+#[cfg(target_os = "windows")]
+const OPENVPN_MISSING: &str = "openvpn.exe not found — install OpenVPN (the community build, \
+     https://openvpn.net/community-downloads/) to use VPN-gated projects on Windows";
+
+/// Locate `openvpn.exe`: on `PATH`, in a per-user install dir, or under the
+/// standard `Program Files\OpenVPN\bin` location a GUI app's PATH usually omits.
+#[cfg(target_os = "windows")]
+fn resolve_openvpn() -> Option<PathBuf> {
+    if crate::paths::binary_on_path("openvpn") {
+        return Some(PathBuf::from("openvpn"));
+    }
+    if let Some(p) = crate::paths::resolve_offpath_binary("openvpn") {
+        return Some(p);
+    }
+    for key in ["ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"] {
+        if let Some(pf) = std::env::var_os(key) {
+            let cand = PathBuf::from(pf)
+                .join("OpenVPN")
+                .join("bin")
+                .join("openvpn.exe");
+            if cand.is_file() {
+                return Some(cand);
+            }
+        }
+    }
+    None
+}
+
+/// Like [`connect`], but invokes `on_line` for every line OpenVPN emits while the
+/// tunnel comes up, so the caller can stream the live handshake into a read-only
+/// log. Interactive-service-first (see the section comment); the direct spawn
+/// below is only the fallback for a machine without the service.
+#[cfg(target_os = "windows")]
+pub fn connect_streaming(
+    config: &str,
+    username: Option<&str>,
+    password: &str,
+    key_passphrase: Option<&str>,
+    on_line: impl Fn(&str),
+) -> Result<(), String> {
+    let config = config.trim();
+    validate_arg("OpenVPN config", config)?;
+    if !Path::new(config).is_file() {
+        return Err(format!("OpenVPN config not found: {config}"));
+    }
+    if is_connected(config) {
+        return Ok(());
+    }
+
+    let stem = safe_stem(config);
+    // Feed the secrets through whichever channels the config actually reads —
+    // both, when it has an `auth-user-pass` account *and* an encrypted key.
+    let (userpass_file, askpass_file) =
+        write_credfiles(config, &stem, username, password, key_passphrase)?;
+    let pidfile = runtime_dir().join(format!("{stem}.pid"));
+    let args = openvpn_args(
+        config,
+        userpass_file.as_deref(),
+        askpass_file.as_deref(),
+        &pidfile,
+    )?;
+    let remove_credfiles = || {
+        for f in [userpass_file.as_deref(), askpass_file.as_deref()].into_iter().flatten() {
+            let _ = std::fs::remove_file(f);
+        }
+    };
+
+    // Service first: its verdict is final. Only a missing service (no pipe)
+    // falls through to the direct spawn, which needs an elevated Eldrun.
+    match svc_connect_streaming(config, &stem, &args, &pidfile, &on_line) {
+        SvcAttempt::Done(result) => {
+            remove_credfiles();
+            return result;
+        }
+        SvcAttempt::Unavailable => {}
+    }
+
+    let Some(exe) = resolve_openvpn() else {
+        remove_credfiles();
+        return Err(OPENVPN_MISSING.to_string());
+    };
+
+    // `command_no_window` adds CREATE_NO_WINDOW so the long-lived openvpn.exe
+    // does not own a flashing console window.
+    let spawn_result = crate::paths::command_no_window(&exe)
+        .args(&args)
+        .stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn();
+
+    let mut child = match spawn_result {
+        Ok(c) => c,
+        Err(e) => {
+            remove_credfiles();
+            return Err(format!(
+                "failed to launch openvpn.exe: {e} — the OpenVPN Interactive Service is not \
+                 running, and a direct spawn needs Eldrun itself to run as Administrator"
+            ));
+        }
+    };
+
+    // Stream stdout/stderr until the ready marker, EOF, or timeout.
+    let ready = wait_for_ready(&mut child, &on_line);
+    remove_credfiles();
+
+    match ready {
+        Ok(()) => {
+            registry()
+                .lock()
+                .unwrap()
+                .insert(config.to_string(), VpnProc { child, pidfile });
+            Ok(())
+        }
+        Err(msg) => {
+            let _ = child.kill();
+            let _ = child.wait();
+            // A recognized credential error stands on its own — appending the
+            // adapter/Administrator hint to "wrong password" would just mislead.
+            Err(explain_openvpn_error(&msg).unwrap_or_else(|| {
+                format!(
+                    "{msg} — if this is a permissions/adapter error, start the OpenVPN \
+                     Interactive Service (OpenVPNServiceInteractive) so Eldrun can connect \
+                     unelevated, run Eldrun as Administrator, or (re)install the OpenVPN \
+                     TAP/Wintun driver"
+                )
+            }))
+        }
+    }
+}
+
+/// Tear down the tunnel for `config` if it is up. Best-effort, three flavours:
+/// an interactive tunnel (typed into a terminal tab) by the pid it wrote; a
+/// service-started tunnel by user-level `taskkill` (its `openvpn.exe` runs with
+/// THIS user's token) plus dropping the control pipe — the service sees the
+/// exit, reverts the routes/DNS it applied, and closes its end; a direct-spawn
+/// child via `taskkill /T` on its handle. A missing/already-dead tunnel is
+/// treated as success.
+#[cfg(target_os = "windows")]
+pub fn disconnect(config: &str) -> Result<(), String> {
+    // An interactive tunnel has no child of ours — kill it by the pid it wrote
+    // (this was missing on Windows; Linux/macOS have always done it).
+    disconnect_interactive(config);
+    let svc = svc_registry().lock().unwrap().remove(config);
+    if let Some(svc) = svc {
+        kill_root_pid(svc.pid as i32);
+        drop(svc.pipe);
+        let _ = std::fs::remove_file(&svc.pidfile);
+        let _ = std::fs::remove_file(&svc.logfile);
+    }
+    let proc = registry().lock().unwrap().remove(config);
+    let Some(mut proc) = proc else {
+        return Ok(());
+    };
+    let pid = proc.child.id();
+    let _ = crate::paths::command_no_window("taskkill")
+        .args(["/F", "/T", "/PID", &pid.to_string()])
+        .output();
+    let _ = proc.child.kill();
+    let _ = proc.child.wait();
+    let _ = std::fs::remove_file(&proc.pidfile);
+    Ok(())
+}
+
+// --- macOS: osascript-elevated daemon + logfile tail -------------------------
+//
+// macOS has no `pkexec`/polkit analogue; privileged one-shots go through
+// `osascript -e 'do shell script … with administrator privileges'` (the system
+// admin-auth dialog). That call BLOCKS until the launched command exits, so
+// OpenVPN must not run in the foreground — it is started with `--daemon --log
+// <file>`: the parent exits as soon as the daemon forks (osascript returns),
+// and the handshake is followed by tailing the logfile for the ready marker.
+// There is consequently no `Child` to track: the macOS registry keys the
+// config to its pidfile/logfile, liveness is `kill(pid, 0)` (EPERM = alive —
+// the daemon is root; treating EPERM as dead is the exact 28l lamp bug), and
+// teardown is a second admin-prompted `kill -TERM <pid>` (accepted for v1;
+// management-interface teardown would avoid the prompt but needs the config
+// to opt in — follow-up note in TODO 31e).
+
+/// Escape `s` for embedding inside an AppleScript double-quoted string
+/// literal: backslashes and double quotes are the only metacharacters.
+/// Compiled cfg-free so it is unit-tested on Linux.
+pub fn applescript_escape(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    for ch in s.chars() {
+        if ch == '\\' || ch == '"' {
+            out.push('\\');
+        }
+        out.push(ch);
+    }
+    out
+}
+
+/// Build the AppleScript source that runs `shell_cmd` elevated with the given
+/// dialog `prompt` — the macOS analog of prefixing `pkexec`. `shell_cmd` must
+/// already be shell-quoted (see [`shell_quote`]); this wraps it for the
+/// AppleScript string context. Compiled cfg-free for Linux-run unit tests.
+pub fn macos_admin_shell_command(shell_cmd: &str, prompt: &str) -> String {
+    format!(
+        "do shell script \"{}\" with administrator privileges with prompt \"{}\"",
+        applescript_escape(shell_cmd),
+        applescript_escape(prompt)
+    )
+}
+
+/// Read and validate the pid recorded in `pidfile`: digits only (same
+/// validation as `kill_pidfile` — the file is root-written, but never feed a
+/// non-numeric string to `kill`). `None` when missing/empty/invalid. Compiled
+/// cfg-free for Linux-run unit tests.
+pub fn pidfile_pid(pidfile: &Path) -> Option<i32> {
+    let contents = std::fs::read_to_string(pidfile).ok()?;
+    let pid = contents.trim();
+    if pid.is_empty() || !pid.chars().all(|c| c.is_ascii_digit()) {
+        return None;
+    }
+    pid.parse().ok()
+}
+
+/// Follow `logfile` until the OpenVPN ready marker appears (`Ok`), the daemon
+/// dies without it (`Err` with the log tail), or `timeout` elapses (`Err`).
+/// The logfile analog of `wait_for_ready`'s pipe loop, for a daemonized
+/// OpenVPN whose parent already exited. Emits every COMPLETE line to
+/// `on_line` (a trailing partial line is held until its newline arrives).
+/// `still_alive` is consulted after each drain so a death right after writing
+/// the failure reason still surfaces that reason. std-only and cfg-free so it
+/// is unit-tested on Linux with a temp file.
+pub fn wait_for_ready_logfile(
+    logfile: &Path,
+    timeout: Duration,
+    poll: Duration,
+    still_alive: impl Fn() -> bool,
+    on_line: impl Fn(&str),
+) -> Result<(), String> {
+    let start = Instant::now();
+    let mut seen = 0usize; // byte offset of consumed (complete) lines
+    let mut tail: Vec<String> = Vec::new();
+    loop {
+        // Raw bytes + lossy per-line decode: a log with a stray non-UTF-8 byte
+        // must not stall the whole tail.
+        let bytes = std::fs::read(logfile).unwrap_or_default();
+        while let Some(nl) = bytes[seen.min(bytes.len())..].iter().position(|&b| b == b'\n') {
+            let line = String::from_utf8_lossy(&bytes[seen..seen + nl]);
+            let line = line.trim_end_matches('\r');
+            on_line(line);
+            if line.contains(READY_MARKER) {
+                return Ok(());
+            }
+            tail.push(line.to_string());
+            if tail.len() > 8 {
+                tail.remove(0);
+            }
+            seen += nl + 1;
+        }
+        if !still_alive() {
+            let detail = tail.join("; ");
+            return if detail.is_empty() {
+                Err("OpenVPN exited before the tunnel came up".to_string())
+            } else {
+                Err(format!("OpenVPN failed: {detail}"))
+            };
+        }
+        if start.elapsed() >= timeout {
+            return Err("OpenVPN connection timed out".to_string());
+        }
+        std::thread::sleep(poll);
+    }
+}
+
+/// A live macOS tunnel: the root daemon's pidfile + its logfile. No `Child` —
+/// osascript exits once OpenVPN daemonizes.
+#[cfg(target_os = "macos")]
+struct MacVpn {
+    pidfile: PathBuf,
+    logfile: PathBuf,
+}
+
+/// macOS-own registry of live tunnels, keyed by config path (the pid-tracked
+/// analog of [`registry`]).
+#[cfg(target_os = "macos")]
+fn mac_registry() -> &'static Mutex<HashMap<String, MacVpn>> {
+    static REG: OnceLock<Mutex<HashMap<String, MacVpn>>> = OnceLock::new();
+    REG.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// Locate `openvpn` as an ABSOLUTE path: PATH first, then the Homebrew /
+/// usr-local prefixes a GUI app's environment usually lacks. Absolute because
+/// the command runs under `do shell script`, whose /bin/sh gets a minimal
+/// PATH without any of those prefixes.
+#[cfg(target_os = "macos")]
+fn resolve_openvpn() -> Option<PathBuf> {
+    let path_var = std::env::var("PATH").unwrap_or_default();
+    let extra = [
+        "/opt/homebrew/bin",
+        "/opt/homebrew/sbin",
+        "/usr/local/bin",
+        "/usr/local/sbin",
+    ];
+    for dir in path_var
+        .split(':')
+        .filter(|d| !d.is_empty())
+        .chain(extra.iter().copied())
+    {
+        let cand = Path::new(dir).join("openvpn");
+        if cand.is_file() {
+            return Some(cand);
+        }
+    }
+    None
+}
+
+/// Like [`connect`], but invokes `on_line` for every line OpenVPN writes to
+/// its logfile while the tunnel comes up, so the caller can stream the live
+/// handshake into a read-only log. See the section comment above for the
+/// osascript + `--daemon` + logfile-tail design.
+#[cfg(target_os = "macos")]
+pub fn connect_streaming(
+    config: &str,
+    username: Option<&str>,
+    password: &str,
+    key_passphrase: Option<&str>,
+    on_line: impl Fn(&str),
+) -> Result<(), String> {
+    let config = config.trim();
+    validate_arg("OpenVPN config", config)?;
+    if !Path::new(config).is_file() {
+        return Err(format!("OpenVPN config not found: {config}"));
+    }
+    if is_connected(config) {
+        return Ok(());
+    }
+    let exe = resolve_openvpn().ok_or_else(|| {
+        "openvpn not found — install it (e.g. `brew install openvpn`) to use VPN-gated projects"
+            .to_string()
+    })?;
+
+    let stem = safe_stem(config);
+    // Feed the secrets through whichever channels the config actually reads —
+    // both, when it has an `auth-user-pass` account *and* an encrypted key.
+    let (userpass_file, askpass_file) =
+        write_credfiles(config, &stem, username, password, key_passphrase)?;
+    let remove_credfiles = || {
+        for f in [userpass_file.as_deref(), askpass_file.as_deref()].into_iter().flatten() {
+            let _ = std::fs::remove_file(f);
+        }
+    };
+    let pidfile = runtime_dir().join(format!("{stem}.pid"));
+    let logfile = runtime_dir().join(format!("{stem}.log"));
+    // Stale files from a previous run would satisfy the tail/liveness checks
+    // spuriously — start clean.
+    let _ = std::fs::remove_file(&pidfile);
+    let _ = std::fs::remove_file(&logfile);
+
+    let mut args = openvpn_args(
+        config,
+        userpass_file.as_deref(),
+        askpass_file.as_deref(),
+        &pidfile,
+    )?;
+    // Management socket, so `disconnect` asks the daemon to stop instead of raising
+    // a second `osascript` admin prompt to `kill` it (the macOS twin of the polkit
+    // double-prompt). Optional: no endpoint just keeps the elevated teardown.
+    if let Some(mgmt) = arm_management(config) {
+        args.extend(mgmt);
+    }
+    args.push("--daemon".to_string());
+    args.push("--log".to_string());
+    args.push(logfile.to_string_lossy().into_owned());
+
+    let shell_cmd = std::iter::once(exe.to_string_lossy().into_owned())
+        .chain(args)
+        .map(|a| shell_quote(&a))
+        .collect::<Vec<_>>()
+        .join(" ");
+    let script = macos_admin_shell_command(
+        &shell_cmd,
+        "Eldrun needs to start the OpenVPN tunnel.",
+    );
+
+    // Blocks until the admin dialog is answered AND openvpn daemonizes (its
+    // parent exits) — or fails. "User canceled." on stderr = dialog declined.
+    let output = crate::paths::command_no_window("osascript")
+        .arg("-e")
+        .arg(&script)
+        .output();
+    let output = match output {
+        Ok(out) => out,
+        Err(e) => {
+            remove_credfiles();
+            return Err(format!("failed to run osascript: {e}"));
+        }
+    };
+    if !output.status.success() {
+        remove_credfiles();
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(if stderr.contains("User canceled") {
+            "administrator authorization was declined".to_string()
+        } else {
+            let msg = stderr.trim();
+            if msg.is_empty() {
+                "osascript failed to start OpenVPN".to_string()
+            } else {
+                format!("failed to start OpenVPN: {msg}")
+            }
+        });
+    }
+
+    // Tail the logfile until the marker / dead daemon / timeout. A missing
+    // pidfile means the daemon is still writing it — only a RECORDED pid that
+    // fails the probe counts as dead.
+    let ready = wait_for_ready_logfile(
+        &logfile,
+        CONNECT_TIMEOUT,
+        Duration::from_millis(200),
+        || pidfile_pid(&pidfile).map(pid_alive).unwrap_or(true),
+        &on_line,
+    );
+    // The credentials have been read by now; remove them regardless of outcome.
+    remove_credfiles();
+
+    match ready {
+        Ok(()) => {
+            mac_registry()
+                .lock()
+                .unwrap()
+                .insert(config.to_string(), MacVpn { pidfile, logfile });
+            Ok(())
         }
-    }
-    // Stream ended without the marker → connection failed.
-    let detail = tail.join("; ");
-    if detail.is_empty() {
-        Err("OpenVPN exited before the tunnel came up".to_string())
-    } else {
-        Err(format!("OpenVPN failed: {detail}"))
+        // Say which secret was wrong; fall back to the raw log tail.
+        Err(msg) => Err(explain_openvpn_error(&msg).unwrap_or(msg)),
     }
 }
 
-/// Tear down the tunnel for `config` if it is up. Best-effort: signals the root
-/// OpenVPN process via `pkexec kill` (reading the pid OpenVPN wrote), then reaps
-/// our child. A missing/already-dead tunnel is treated as success.
+/// Tear down the tunnel for `config` if it is up: an admin-prompted
+/// `kill -TERM <pid>` (the daemon is root — a plain kill gets EPERM). The
+/// second prompt per disconnect is accepted for v1. A missing/already-dead
+/// tunnel is treated as success.
+#[cfg(target_os = "macos")]
 pub fn disconnect(config: &str) -> Result<(), String> {
-    let proc = registry().lock().unwrap().remove(config);
-    let Some(mut proc) = proc else {
+    // Management socket first — stops the daemon with no admin prompt at all, so the
+    // "second prompt per disconnect" the section comment above accepts for v1 is now
+    // only paid when the socket is unavailable.
+    management_shutdown(config);
+    // An interactive tunnel has no entry in `mac_registry` — kill it by its pid.
+    disconnect_interactive(config);
+    let proc = mac_registry().lock().unwrap().remove(config);
+    let Some(proc) = proc else {
         return Ok(());
     };
-    kill_pidfile(&proc.pidfile);
-    let _ = proc.child.kill();
-    let _ = proc.child.wait();
+    if let Some(pid) = pidfile_pid(&proc.pidfile) {
+        if pid_alive(pid) {
+            kill_root_pid(pid);
+        }
+    }
     let _ = std::fs::remove_file(&proc.pidfile);
+    let _ = std::fs::remove_file(&proc.logfile);
     Ok(())
 }
 
-/// `pkexec kill` the pid recorded in `pidfile` (the root OpenVPN process).
-fn kill_pidfile(pidfile: &Path) {
-    let Ok(contents) = std::fs::read_to_string(pidfile) else {
-        return;
+/// Tear down every live tunnel at app exit; errors are swallowed so shutdown
+/// never blocks (mirrors the Linux/Windows `disconnect_all`).
+#[cfg(target_os = "macos")]
+pub fn disconnect_all() {
+    // Interactive tunnels included — see the Linux/Windows twin.
+    let keys: Vec<String> = {
+        let reg = mac_registry().lock().unwrap();
+        let interactive = interactive_registry().lock().unwrap();
+        reg.keys().chain(interactive.keys()).cloned().collect()
     };
-    let pid = contents.trim();
-    if pid.is_empty() || !pid.chars().all(|c| c.is_ascii_digit()) {
-        return;
+    for k in keys {
+        let _ = disconnect(&k);
     }
-    let _ = Command::new("pkexec")
-        .arg("kill")
-        .arg("-TERM")
-        .arg(pid)
-        .status();
 }
 
-/// Tear down every live tunnel. Used at app exit; errors are swallowed so
-/// shutdown never blocks.
-pub fn disconnect_all() {
+/// macOS twin of [`disconnect_all_checked`] (its tunnels live in [`mac_registry`]).
+#[cfg(target_os = "macos")]
+pub fn disconnect_all_checked() -> Result<(), String> {
     let keys: Vec<String> = {
-        let reg = registry().lock().unwrap();
-        reg.keys().cloned().collect()
+        let reg = mac_registry().lock().unwrap();
+        let interactive = interactive_registry().lock().unwrap();
+        reg.keys().chain(interactive.keys()).cloned().collect()
     };
     for k in keys {
-        let _ = disconnect(&k);
+        disconnect_checked(&k)?;
     }
+    Ok(())
 }
 
 #[cfg(test)]
@@ -325,18 +2644,545 @@ mod tests {
     use super::*;
 
     #[test]
-    fn openvpn_args_basic_shape() {
+    fn shell_quote_wraps_and_escapes() {
+        assert_eq!(shell_quote("/home/u/a.ovpn"), "'/home/u/a.ovpn'");
+        assert_eq!(shell_quote("a b"), "'a b'");
+        assert_eq!(shell_quote("a'b"), "'a'\\''b'");
+    }
+
+    /// A config nobody connected is not reported as up. The header's VPN indicator
+    /// is driven by this, and a false positive parks a "your machine is being
+    /// rerouted" badge over a machine that isn't.
+    ///
+    /// Asserts about *this* config rather than global emptiness: the registries are
+    /// process-global and the tests below register live entries in parallel.
+    #[cfg(any(target_os = "linux", target_os = "windows", target_os = "macos"))]
+    #[test]
+    fn unconnected_config_is_never_reported_up() {
+        let cfg = "/store/never-connected.ovpn";
+        assert!(!is_connected(cfg));
+        assert!(!active_configs().contains(&cfg.to_string()));
+    }
+
+    /// Drop a config from both the interactive registry and the disk, without going
+    /// through `disconnect_interactive` — which would try to `kill` the pid, and in
+    /// these tests that pid is *our own process*.
+    ///
+    /// Also clears the management endpoint `arm_interactive` now writes, so the suite
+    /// leaves nothing behind in the user's real runtime dir (these tests run against
+    /// it, not a temp dir).
+    fn forget_interactive(config: &str) {
+        if let Some(pidfile) = interactive_registry().lock().unwrap().remove(config) {
+            let _ = std::fs::remove_file(pidfile);
+        }
+        #[cfg(unix)]
+        clear_management(config);
+    }
+
+    /// The interactive command must carry a `--writepid` Eldrun chose, and claim it.
+    /// This is the whole fix for #83: without the pid, a root tunnel started in a
+    /// terminal tab is invisible to `is_connected`/`active_configs` and unkillable by
+    /// `disconnect`/`disconnect_all` — it outlives the app still owning the routing.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn interactive_command_claims_a_pidfile() {
+        let cfg = "/store/test-claims.ovpn";
+        forget_interactive(cfg);
+
+        let cmd = interactive_connect_command(cfg).unwrap();
+        let pidfile = interactive_pidfile(cfg);
+
+        assert!(cmd.contains("--writepid"));
+        assert!(cmd.contains(&shell_quote(&pidfile.to_string_lossy())));
+        // Claimed, but OpenVPN hasn't written a pid yet — the user is still at the
+        // polkit prompt. Pending is NOT dead: reaping here would forget a tunnel in
+        // the seconds before it comes up.
+        assert_eq!(interactive_state(cfg), Interactive::Pending);
+        assert!(!is_connected(cfg));
+
+        forget_interactive(cfg);
+    }
+
+    /// Once the pid is on disk and alive, the tunnel is up — visible to everything
+    /// the frontend asks (`openvpn_status`, `openvpn_active`).
+    #[cfg(unix)]
+    #[test]
+    fn interactive_tunnel_with_a_live_pid_is_up() {
+        let cfg = "/store/test-live.ovpn";
+        forget_interactive(cfg);
+        let _ = interactive_connect_command(cfg).unwrap();
+
+        // Our own pid is, definitionally, alive.
+        let me = std::process::id();
+        std::fs::write(interactive_pidfile(cfg), format!("{me}\n")).unwrap();
+
+        assert_eq!(interactive_state(cfg), Interactive::Alive(me as i32));
+        assert!(is_connected(cfg));
+        assert!(active_configs().contains(&cfg.to_string()));
+
+        forget_interactive(cfg);
+    }
+
+    /// A tunnel whose process is gone (the user closed its terminal) is reaped, not
+    /// reported as up — and its stale pidfile is cleaned up so the next connect
+    /// can't mistake it for a live one.
+    #[cfg(unix)]
+    #[test]
+    fn interactive_tunnel_with_a_dead_pid_is_reaped() {
+        let cfg = "/store/test-dead.ovpn";
+        forget_interactive(cfg);
+        let _ = interactive_connect_command(cfg).unwrap();
+
+        // A pid that is *certainly* dead: spawn a process and reap it.
+        let mut child = std::process::Command::new("true").spawn().unwrap();
+        let dead = child.id();
+        child.wait().unwrap();
+        let pidfile = interactive_pidfile(cfg);
+        std::fs::write(&pidfile, format!("{dead}\n")).unwrap();
+
+        assert_eq!(interactive_state(cfg), Interactive::None);
+        assert!(!is_connected(cfg));
+        // Reaped from both the registry and the disk.
+        assert!(!interactive_registry().lock().unwrap().contains_key(cfg));
+        assert!(!pidfile.exists());
+
+        forget_interactive(cfg);
+    }
+
+    /// Arming twice must not resurrect a stale pidfile: a leftover from a previous
+    /// run would otherwise read as a live tunnel the moment the config is armed.
+    #[cfg(unix)]
+    #[test]
+    fn arming_clears_a_stale_pidfile() {
+        let cfg = "/store/test-stale.ovpn";
+        forget_interactive(cfg);
+        let pidfile = interactive_pidfile(cfg);
+        let _ = std::fs::create_dir_all(runtime_dir());
+        std::fs::write(&pidfile, format!("{}\n", std::process::id())).unwrap();
+
+        let _ = interactive_connect_command(cfg).unwrap();
+
+        assert!(!pidfile.exists());
+        assert_eq!(interactive_state(cfg), Interactive::Pending);
+
+        forget_interactive(cfg);
+    }
+
+    /// The bug this fixes: a tunnel a *previous* run started is up (its root daemon
+    /// survived, pidfile on disk) but every registry is empty at launch, so the lamp
+    /// reads grey while the machine is still routed through it. `adopt_config` recovers
+    /// it from the headless `{stem}.pid`, making it visible again.
+    #[cfg(unix)]
+    #[test]
+    fn adopt_recovers_a_surviving_headless_tunnel() {
+        let cfg = "/store/test-adopt-headless.ovpn";
+        forget_interactive(cfg);
+        let pidfile = runtime_dir().join(format!("{}.pid", safe_stem(cfg)));
+        let _ = std::fs::create_dir_all(runtime_dir());
+        // Our own pid stands in for the still-alive root daemon.
+        std::fs::write(&pidfile, format!("{}\n", std::process::id())).unwrap();
+        assert!(!is_connected(cfg)); // nothing tracks it yet
+
+        assert!(adopt_config(cfg));
+        assert!(is_connected(cfg));
+        assert!(active_configs().contains(&cfg.to_string()));
+
+        forget_interactive(cfg);
+        let _ = std::fs::remove_file(&pidfile);
+    }
+
+    /// The interactive flavour's pidfile is recovered too.
+    #[cfg(unix)]
+    #[test]
+    fn adopt_recovers_a_surviving_interactive_tunnel() {
+        let cfg = "/store/test-adopt-interactive.ovpn";
+        forget_interactive(cfg);
+        let pidfile = interactive_pidfile(cfg);
+        let _ = std::fs::create_dir_all(runtime_dir());
+        std::fs::write(&pidfile, format!("{}\n", std::process::id())).unwrap();
+
+        assert!(adopt_config(cfg));
+        assert!(is_connected(cfg));
+
+        forget_interactive(cfg);
+        let _ = std::fs::remove_file(&pidfile);
+    }
+
+    /// A pidfile whose recorded process is gone is not a live tunnel: adopt reports
+    /// nothing recovered and cleans the stale file, so a later connect can't mistake
+    /// it for one that is up.
+    #[cfg(unix)]
+    #[test]
+    fn adopt_reaps_a_stale_pidfile_and_recovers_nothing() {
+        let cfg = "/store/test-adopt-stale.ovpn";
+        forget_interactive(cfg);
+        let pidfile = runtime_dir().join(format!("{}.pid", safe_stem(cfg)));
+        let _ = std::fs::create_dir_all(runtime_dir());
+        // A pid that is certainly dead: spawn a process and reap it.
+        let mut child = std::process::Command::new("true").spawn().unwrap();
+        let dead = child.id();
+        child.wait().unwrap();
+        std::fs::write(&pidfile, format!("{dead}\n")).unwrap();
+
+        assert!(!adopt_config(cfg));
+        assert!(!is_connected(cfg));
+        assert!(!pidfile.exists()); // stale file cleaned up
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn interactive_connect_command_linux_shape() {
+        let cmd = interactive_connect_command("/home/u/work.ovpn").unwrap();
+        // Elevated via pkexec; passphrase typed interactively (no --askpass file).
+        assert!(cmd.starts_with("pkexec openvpn --config "));
+        assert!(cmd.contains("'/home/u/work.ovpn'"));
+        assert!(cmd.contains("--auth-nocache"));
+        assert!(!cmd.contains("--askpass"));
+
+        forget_interactive("/home/u/work.ovpn");
+    }
+
+    /// The whole point of the management socket: a terminal-started tunnel carries
+    /// one too, so stopping it costs no second polkit prompt either. Without this the
+    /// interactive flavour would silently keep the old double-password teardown.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn interactive_connect_command_arms_a_management_socket() {
+        // Skipped while the A/B kill switch is on (no `--management` is appended).
+        if MANAGEMENT_SOCKET_DISABLED {
+            return;
+        }
+        let cfg = "/home/u/mgmt-interactive.ovpn";
+        forget_interactive(cfg);
+        let cmd = interactive_connect_command(cfg).unwrap();
+        assert!(
+            cmd.contains("--management 127.0.0.1 "),
+            "interactive tunnels need a management socket too: {cmd}"
+        );
+        // The endpoint it armed is the one teardown will read back.
+        let (port, password) = management_endpoint(cfg).expect("endpoint recorded");
+        assert!(port > 0);
+        assert!(!password.is_empty());
+        assert!(cmd.contains(&port.to_string()));
+
+        forget_interactive(cfg);
+    }
+
+    /// A config that runs its own management socket must be left alone: `--management`
+    /// twice is an options error, i.e. a tunnel that never comes up at all. Worth a
+    /// test because the failure is total and only shows on the user's own config.
+    #[cfg(unix)]
+    #[test]
+    fn config_declaring_management_is_detected() {
+        let dir = std::env::temp_dir().join("eldrun-mgmt-detect");
+        std::fs::create_dir_all(&dir).unwrap();
+
+        let own = dir.join("own.ovpn");
+        std::fs::write(&own, "client\nmanagement 127.0.0.1 7505\nremote vpn.example 1194\n")
+            .unwrap();
+        assert!(config_declares_management(own.to_str().unwrap()));
+        assert!(arm_management(own.to_str().unwrap()).is_none());
+
+        let plain = dir.join("plain.ovpn");
+        std::fs::write(
+            &plain,
+            "client\n# management 127.0.0.1 7505\n; management foo\nremote vpn.example 1194\n",
+        )
+        .unwrap();
+        assert!(
+            !config_declares_management(plain.to_str().unwrap()),
+            "a commented-out directive is not a declaration"
+        );
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// `--management <ip> <port> <pwfile>`, in that order — OpenVPN is positional
+    /// here, so a reordering would be silently accepted and mean something else.
+    #[test]
+    fn management_args_shape() {
+        let args = management_args(7505, Path::new("/run/eldrun/openvpn/x.mgmt.pw"));
+        assert_eq!(
+            args,
+            vec![
+                "--management".to_string(),
+                "127.0.0.1".to_string(),
+                "7505".to_string(),
+                "/run/eldrun/openvpn/x.mgmt.pw".to_string(),
+            ]
+        );
+    }
+
+    /// An armed endpoint round-trips, and its password file is owner-only — it is the
+    /// only thing standing between a local process and control of the tunnel.
+    #[cfg(unix)]
+    #[test]
+    fn arm_management_records_an_owner_only_endpoint() {
+        // Skipped while the A/B kill switch is on (no endpoint is armed by design).
+        if MANAGEMENT_SOCKET_DISABLED {
+            return;
+        }
+        let cfg = "/home/u/mgmt-roundtrip.ovpn";
+        let args = arm_management(cfg).expect("endpoint armed");
+        assert_eq!(args[0], "--management");
+        let (port, password) = management_endpoint(cfg).expect("endpoint readable");
+        assert_eq!(args[2], port.to_string());
+        assert_eq!(password.len(), 64, "32 random bytes, hex-encoded");
+
+        let mode = std::fs::metadata(management_pwfile(cfg))
+            .unwrap()
+            .permissions()
+            .mode()
+            & 0o777;
+        assert_eq!(mode, 0o600, "management password must not be group/world readable");
+
+        clear_management(cfg);
+        assert!(management_endpoint(cfg).is_none(), "cleared endpoint is forgotten");
+    }
+
+    /// The teardown handshake, against a stand-in for OpenVPN. Two things are pinned:
+    /// the client answers the password prompt (which arrives with **no newline**, so a
+    /// line-oriented read would hang on it forever), and what it then sends is exactly
+    /// `signal SIGTERM` — the command that makes the root daemon stop *itself*, which
+    /// is the entire reason no second password is needed.
+    #[cfg(unix)]
+    #[test]
+    fn management_sigterm_authenticates_then_signals() {
+        use std::io::{BufRead, BufReader};
+        let listener = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let port = listener.local_addr().unwrap().port();
+        let (tx, rx) = std::sync::mpsc::channel::<String>();
+        std::thread::spawn(move || {
+            let (mut sock, _) = listener.accept().unwrap();
+            write!(sock, "ENTER PASSWORD:").unwrap();
+            sock.flush().unwrap();
+            let mut reader = BufReader::new(sock.try_clone().unwrap());
+            let mut pw = String::new();
+            reader.read_line(&mut pw).unwrap();
+            let _ = tx.send(format!("pw:{}", pw.trim()));
+            writeln!(sock, "SUCCESS: password is correct").unwrap();
+            sock.flush().unwrap();
+            let mut cmd = String::new();
+            reader.read_line(&mut cmd).unwrap();
+            let _ = tx.send(format!("cmd:{}", cmd.trim()));
+        });
+
+        assert!(management_send_sigterm(port, "s3cret"));
+        let got: Vec<String> = rx.iter().take(2).collect();
+        assert_eq!(got, vec!["pw:s3cret", "cmd:signal SIGTERM"]);
+    }
+
+    /// A refused password must report failure, never a false "tunnel is down" — that
+    /// is what makes the caller fall back to the elevated kill instead of walking away
+    /// from a tunnel still rerouting the machine.
+    #[cfg(unix)]
+    #[test]
+    fn management_sigterm_reports_failure_when_auth_is_refused() {
+        use std::io::{BufRead, BufReader};
+        let listener = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let port = listener.local_addr().unwrap().port();
+        std::thread::spawn(move || {
+            let (mut sock, _) = listener.accept().unwrap();
+            write!(sock, "ENTER PASSWORD:").unwrap();
+            sock.flush().unwrap();
+            let mut line = String::new();
+            let _ = BufReader::new(sock.try_clone().unwrap()).read_line(&mut line);
+            let _ = writeln!(sock, "ERROR: bad password");
+            let _ = sock.flush();
+        });
+
+        assert!(!management_send_sigterm(port, "wrong"));
+    }
+
+    /// Nothing listening (a tunnel from a previous run whose port is long gone) is an
+    /// ordinary failure, not a hang or a panic.
+    #[cfg(unix)]
+    #[test]
+    fn management_sigterm_fails_on_a_dead_port() {
+        let listener = std::net::TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let port = listener.local_addr().unwrap().port();
+        drop(listener); // nothing is listening now
+        assert!(!management_send_sigterm(port, "whatever"));
+    }
+
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn interactive_connect_command_rejects_bad_config() {
+        assert!(interactive_connect_command("-evil").is_err());
+        assert!(interactive_connect_command("/a\nb.ovpn").is_err());
+        assert!(interactive_connect_command("   ").is_err());
+    }
+
+    #[test]
+    fn win_cmdline_quote_shapes() {
+        // No metacharacters → unquoted, byte for byte (backslashes are literal).
+        assert_eq!(win_cmdline_quote("plain"), "plain");
+        assert_eq!(win_cmdline_quote(r"C:\dir\file.ovpn"), r"C:\dir\file.ovpn");
+        assert_eq!(win_cmdline_quote(r"end\"), r"end\");
+        // Spaces / emptiness force quotes.
+        assert_eq!(win_cmdline_quote("has space"), "\"has space\"");
+        assert_eq!(win_cmdline_quote(""), "\"\"");
+        // A quote inside: preceding backslashes double and the quote is escaped.
+        assert_eq!(win_cmdline_quote(r#"a"b"#), r#""a\"b""#);
+        assert_eq!(win_cmdline_quote(r#"a\"b"#), r#""a\\\"b""#);
+        // Trailing backslashes double so they can't eat the closing quote.
+        assert_eq!(win_cmdline_quote(r"e nd\"), "\"e nd\\\\\"");
+        // The options string is the quoted args joined by single spaces.
+        assert_eq!(
+            svc_options_string(&["--config".to_string(), r"C:\a b\c.ovpn".to_string()]),
+            r#"--config "C:\a b\c.ovpn""#
+        );
+    }
+
+    #[test]
+    fn svc_startup_message_is_three_nul_terminated_utf16_strings() {
+        // Non-ASCII on purpose: the message is UTF-16LE, not the ANSI codepage.
+        let msg = svc_startup_message("C:\\wä", "--config a.ovpn", "");
+        assert_eq!(msg.len() % 2, 0);
+        let units: Vec<u16> = msg
+            .chunks_exact(2)
+            .map(|c| u16::from_le_bytes([c[0], c[1]]))
+            .collect();
+        // Exactly three NULs, one terminating each string (the last is empty).
+        assert_eq!(units.iter().filter(|&&u| u == 0).count(), 3);
+        assert_eq!(units.last(), Some(&0));
+        let parts: Vec<String> = units
+            .split(|&u| u == 0)
+            .map(|p| String::from_utf16(p).unwrap())
+            .collect();
+        assert_eq!(parts, ["C:\\wä", "--config a.ovpn", "", ""]);
+    }
+
+    #[test]
+    fn svc_parse_response_reads_pid_and_refusals() {
+        let enc = |s: &str| -> Vec<u8> {
+            s.encode_utf16().flat_map(|u| u.to_le_bytes()).collect()
+        };
+        // Success: code 0, pid on line 2 (both `0x%08x`), description on line 3.
+        let ok = svc_parse_response(&enc("0x00000000\n0x00001a2b\nProcess ID")).unwrap();
+        assert_eq!(ok.code, 0);
+        assert_eq!(svc_response_pid(&ok), Some(0x1a2b));
+        // Refusal: nonzero code — never a pid, and the explanation must carry
+        // both the service's own text and the actionable one-time fix.
+        let err = svc_parse_response(&enc(
+            "0x20000001\nValidateOptions\nconfig is not in the allowed location",
+        ))
+        .unwrap();
+        assert_eq!(err.code, 0x2000_0001);
+        assert_eq!(svc_response_pid(&err), None);
+        let msg = explain_service_refusal(&err);
+        assert!(msg.contains("config is not in the allowed location"), "{msg}");
+        assert!(msg.contains("OpenVPN Administrators"), "{msg}");
+        assert!(msg.contains("net localgroup"), "{msg}");
+        // Garbage is None, not a fabricated verdict.
+        assert!(svc_parse_response(&enc("not-a-code\nx\ny")).is_none());
+        assert!(svc_parse_response(&[]).is_none());
+    }
+
+    #[test]
+    fn openvpn_args_askpass_shape() {
         let args = openvpn_args(
             "/home/u/work.ovpn",
-            Path::new("/run/eldrun/openvpn/x.pass"),
+            None,
+            Some(Path::new("/run/eldrun/openvpn/x.pass")),
             Path::new("/run/eldrun/openvpn/x.pid"),
         )
         .unwrap();
         // --config then the path as a single item.
         let ci = args.iter().position(|a| a == "--config").unwrap();
         assert_eq!(args[ci + 1], "/home/u/work.ovpn");
+        // Passphrase-only configs feed the secret via --askpass.
+        let ai = args.iter().position(|a| a == "--askpass").unwrap();
+        assert_eq!(args[ai + 1], "/run/eldrun/openvpn/x.pass");
+        assert!(!args.iter().any(|a| a == "--auth-user-pass"));
+        let pi = args.iter().position(|a| a == "--writepid").unwrap();
+        assert_eq!(args[pi + 1], "/run/eldrun/openvpn/x.pid");
+        assert!(args.iter().any(|a| a == "--auth-nocache"));
+    }
+
+    /// A tunnel must survive a blip. `--connect-retry-max` caps reconnects for
+    /// the tunnel's whole *lifetime*, not just the first connect, so passing it
+    /// meant a momentary drop exhausted the retries and OpenVPN exited for good
+    /// — leaving the machine's routing changed and every SSH/SFTP session on top
+    /// stalled against a peer that would never answer. It must stay absent, with
+    /// `--persist-tun` holding the device and routes across a reconnect.
+    #[test]
+    fn openvpn_args_let_a_dropped_tunnel_reconnect_forever() {
+        let args = openvpn_args(
+            "/home/u/work.ovpn",
+            None,
+            Some(Path::new("/run/eldrun/openvpn/x.pass")),
+            Path::new("/run/eldrun/openvpn/x.pid"),
+        )
+        .unwrap();
+        assert!(
+            !args.iter().any(|a| a == "--connect-retry-max"),
+            "a retry cap makes a blip kill the tunnel permanently: {args:?}"
+        );
+        assert!(args.iter().any(|a| a == "--persist-tun"));
+        // The initial connect stays bounded by CONNECT_TIMEOUT, not by openvpn.
+        let ti = args.iter().position(|a| a == "--connect-timeout").unwrap();
+        assert_eq!(args[ti + 1], "20");
+    }
+
+    /// Readiness is detected by scanning OpenVPN's output for the
+    /// "Initialization Sequence Completed" marker, so the argv must pin the
+    /// logging knobs a config could otherwise sabotage it with: a `mute 16`
+    /// (as shipped in real configs) suppresses the marker — it follows a burst
+    /// of same-category route-addition lines — and Eldrun then reported
+    /// "timed out" on, and killed, a tunnel that was actually up. `verb 0`
+    /// hides the marker outright. Both are overridden because command-line
+    /// options are applied after `--config`.
+    #[test]
+    fn openvpn_args_pin_logging_so_the_ready_marker_survives() {
+        let args = openvpn_args(
+            "/home/u/work.ovpn",
+            None,
+            Some(Path::new("/run/eldrun/openvpn/x.pass")),
+            Path::new("/run/eldrun/openvpn/x.pid"),
+        )
+        .unwrap();
+        let vi = args.iter().position(|a| a == "--verb").unwrap();
+        assert_eq!(args[vi + 1], "3");
+        let mi = args.iter().position(|a| a == "--mute").unwrap();
+        assert_eq!(args[mi + 1], "0");
+        // Overrides only win from *after* the config file's own directives.
+        let ci = args.iter().position(|a| a == "--config").unwrap();
+        assert!(vi > ci && mi > ci);
+    }
+
+    #[test]
+    fn openvpn_args_userpass_uses_auth_user_pass() {
+        let args = openvpn_args(
+            "/home/u/work.ovpn",
+            Some(Path::new("/run/eldrun/openvpn/x.auth")),
+            None,
+            Path::new("/run/eldrun/openvpn/x.pid"),
+        )
+        .unwrap();
+        let ai = args.iter().position(|a| a == "--auth-user-pass").unwrap();
+        assert_eq!(args[ai + 1], "/run/eldrun/openvpn/x.auth");
+        assert!(!args.iter().any(|a| a == "--askpass"));
+    }
+
+    #[test]
+    fn openvpn_args_carries_both_channels_at_once() {
+        // The regression this whole change exists for: a config with an
+        // `auth-user-pass` account AND an encrypted key needs BOTH flags. Feeding
+        // only one leaves OpenVPN's other prompt unanswered and the handshake
+        // hangs until it times out.
+        let args = openvpn_args(
+            "/home/u/work.ovpn",
+            Some(Path::new("/run/eldrun/openvpn/x.auth")),
+            Some(Path::new("/run/eldrun/openvpn/x.pass")),
+            Path::new("/run/eldrun/openvpn/x.pid"),
+        )
+        .unwrap();
+        let ui = args.iter().position(|a| a == "--auth-user-pass").unwrap();
+        assert_eq!(args[ui + 1], "/run/eldrun/openvpn/x.auth");
         let ai = args.iter().position(|a| a == "--askpass").unwrap();
         assert_eq!(args[ai + 1], "/run/eldrun/openvpn/x.pass");
+        // …and the tail options survive both being present.
         let pi = args.iter().position(|a| a == "--writepid").unwrap();
         assert_eq!(args[pi + 1], "/run/eldrun/openvpn/x.pid");
         assert!(args.iter().any(|a| a == "--auth-nocache"));
@@ -344,17 +3190,209 @@ mod tests {
 
     #[test]
     fn openvpn_args_rejects_leading_dash_config() {
-        assert!(openvpn_args("-evil", Path::new("/a"), Path::new("/b")).is_err());
+        assert!(openvpn_args("-evil", None, Some(Path::new("/a")), Path::new("/b")).is_err());
     }
 
     #[test]
     fn openvpn_args_rejects_control_chars() {
-        assert!(openvpn_args("/a\nb.ovpn", Path::new("/a"), Path::new("/b")).is_err());
+        assert!(openvpn_args("/a\nb.ovpn", None, Some(Path::new("/a")), Path::new("/b")).is_err());
     }
 
     #[test]
     fn openvpn_args_rejects_empty_config() {
-        assert!(openvpn_args("   ", Path::new("/a"), Path::new("/b")).is_err());
+        assert!(openvpn_args("   ", None, Some(Path::new("/a")), Path::new("/b")).is_err());
+    }
+
+    #[test]
+    fn config_requires_userpass_detects_bare_directive() {
+        use std::io::Write;
+        let dir = std::env::temp_dir().join(format!("eldrun-ovpn-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+
+        // Bare `auth-user-pass` → needs a username.
+        let bare = dir.join("bare.ovpn");
+        let mut f = std::fs::File::create(&bare).unwrap();
+        writeln!(f, "client\nremote vpn.example.com 1194\nauth-user-pass\nauth-nocache").unwrap();
+        assert!(config_requires_userpass(bare.to_str().unwrap()));
+
+        // `auth-user-pass creds.txt` supplies its own file → does not.
+        let withfile = dir.join("withfile.ovpn");
+        let mut f = std::fs::File::create(&withfile).unwrap();
+        writeln!(f, "client\nauth-user-pass /etc/creds.txt").unwrap();
+        assert!(!config_requires_userpass(withfile.to_str().unwrap()));
+
+        // Commented-out directive → does not.
+        let commented = dir.join("commented.ovpn");
+        let mut f = std::fs::File::create(&commented).unwrap();
+        writeln!(f, "client\n# auth-user-pass\n;auth-user-pass").unwrap();
+        assert!(!config_requires_userpass(commented.to_str().unwrap()));
+
+        // Cert-only config → does not.
+        let cert = dir.join("cert.ovpn");
+        let mut f = std::fs::File::create(&cert).unwrap();
+        writeln!(f, "client\nremote vpn.example.com 1194\ncert a.crt\nkey a.key").unwrap();
+        assert!(!config_requires_userpass(cert.to_str().unwrap()));
+
+        // Missing file → false (best-effort fallback).
+        assert!(!config_requires_userpass(
+            dir.join("nope.ovpn").to_str().unwrap()
+        ));
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn explain_openvpn_error_names_which_secret_was_wrong() {
+        // The whole point: a rejected account and a bad key passphrase are two
+        // different fields, and OpenVPN reports them with two different lines.
+        let auth = explain_openvpn_error(
+            "AUTH: Received control message: AUTH_FAILED; SIGTERM[soft,auth-failure] received",
+        )
+        .unwrap();
+        assert!(auth.contains("username and password"), "{auth}");
+
+        let key = explain_openvpn_error(
+            "Cryptographic API error; OpenSSL: error:0308010C:digital envelope routines; \
+             Private Key Password verification failed",
+        )
+        .unwrap();
+        assert!(key.contains("private-key passphrase"), "{key}");
+        // …and they must never be confused for each other.
+        assert!(!key.contains("username"), "{key}");
+        assert!(!auth.contains("private-key"), "{auth}");
+
+        // OpenSSL words a bad decrypt several ways; all mean the same field.
+        for line in ["OpenSSL: error:0700006C:bad decrypt", "Decryption error"] {
+            assert!(
+                explain_openvpn_error(line).unwrap().contains("private-key passphrase"),
+                "{line}"
+            );
+        }
+    }
+
+    #[test]
+    fn explain_openvpn_error_separates_non_credential_failures() {
+        // Things no retyped password can fix must not be reported as bad creds.
+        let declined = explain_openvpn_error("administrator authorization was declined").unwrap();
+        assert!(declined.contains("Elevation"), "{declined}");
+
+        let dns = explain_openvpn_error("RESOLVE: Cannot resolve host address: vpn.x").unwrap();
+        assert!(dns.contains("resolve"), "{dns}");
+
+        let tls = explain_openvpn_error("TLS Error: TLS key negotiation failed to occur").unwrap();
+        assert!(tls.contains("TLS handshake"), "{tls}");
+
+        let tun = explain_openvpn_error("ERROR: Cannot open TUN/TAP dev /dev/net/tun").unwrap();
+        assert!(tun.contains("tunnel device"), "{tun}");
+    }
+
+    #[test]
+    fn explain_openvpn_error_passes_unknown_output_through() {
+        // Unrecognized output must fall back to the raw tail — replacing a specific
+        // error with a vague guess is worse than showing the real thing.
+        assert_eq!(explain_openvpn_error("Initialization Sequence In Progress"), None);
+        assert_eq!(explain_openvpn_error(""), None);
+    }
+
+    #[test]
+    fn config_requires_key_passphrase_detects_encrypted_keys() {
+        use std::io::Write;
+        let dir = std::env::temp_dir().join(format!("eldrun-ovpn-key-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let write = |name: &str, body: &str| {
+            let p = dir.join(name);
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(body.as_bytes()).unwrap();
+            p
+        };
+
+        // Inline encrypted key (traditional PEM) → needs a passphrase.
+        let inline = write(
+            "inline.ovpn",
+            "client\nauth-user-pass\n<key>\n-----BEGIN RSA PRIVATE KEY-----\n\
+             Proc-Type: 4,ENCRYPTED\nDEK-Info: AES-256-CBC,ABC\n\nbase64==\n\
+             -----END RSA PRIVATE KEY-----\n</key>\n",
+        );
+        assert!(config_requires_key_passphrase(inline.to_str().unwrap()));
+        // …and it is orthogonal to the account channel: this config needs both.
+        assert!(config_requires_userpass(inline.to_str().unwrap()));
+
+        // Inline PKCS#8 encrypted key → needs a passphrase.
+        let pkcs8 = write(
+            "pkcs8.ovpn",
+            "client\n<key>\n-----BEGIN ENCRYPTED PRIVATE KEY-----\nb64==\n\
+             -----END ENCRYPTED PRIVATE KEY-----\n</key>\n",
+        );
+        assert!(config_requires_key_passphrase(pkcs8.to_str().unwrap()));
+
+        // Inline *unencrypted* key → does not.
+        let plain = write(
+            "plain.ovpn",
+            "client\n<key>\n-----BEGIN PRIVATE KEY-----\nb64==\n-----END PRIVATE KEY-----\n</key>\n",
+        );
+        assert!(!config_requires_key_passphrase(plain.to_str().unwrap()));
+
+        // Out-of-line key, resolved relative to the config's own directory.
+        write("enc.key", "-----BEGIN RSA PRIVATE KEY-----\nProc-Type: 4,ENCRYPTED\nb64==\n");
+        let extenc = write("extenc.ovpn", "client\ncert a.crt\nkey enc.key\n");
+        assert!(config_requires_key_passphrase(extenc.to_str().unwrap()));
+
+        write("plain.key", "-----BEGIN PRIVATE KEY-----\nb64==\n");
+        let extplain = write("extplain.ovpn", "client\ncert a.crt\nkey plain.key\n");
+        assert!(!config_requires_key_passphrase(extplain.to_str().unwrap()));
+
+        // A key file we can't read → false (best-effort, like the userpass twin).
+        let missingkey = write("missingkey.ovpn", "client\nkey nope.key\n");
+        assert!(!config_requires_key_passphrase(missingkey.to_str().unwrap()));
+
+        // `pkcs12` bundles are treated as passphrase-protected (DER — can't sniff).
+        let p12 = write("p12.ovpn", "client\npkcs12 bundle.p12\n");
+        assert!(config_requires_key_passphrase(p12.to_str().unwrap()));
+
+        // A config that supplies its own `askpass <file>` needs nothing from us…
+        let ownaskpass = write(
+            "ownaskpass.ovpn",
+            "client\naskpass /etc/openvpn/pass.txt\n<key>\n\
+             -----BEGIN RSA PRIVATE KEY-----\nProc-Type: 4,ENCRYPTED\n</key>\n",
+        );
+        assert!(!config_requires_key_passphrase(ownaskpass.to_str().unwrap()));
+        // …but a *bare* `askpass` means "prompt on the console" — we must answer it.
+        let bareaskpass = write(
+            "bareaskpass.ovpn",
+            "client\naskpass\n<key>\n-----BEGIN RSA PRIVATE KEY-----\n\
+             Proc-Type: 4,ENCRYPTED\n</key>\n",
+        );
+        assert!(config_requires_key_passphrase(bareaskpass.to_str().unwrap()));
+
+        // Commented-out key directive / cert-only config → does not.
+        let certonly = write("certonly.ovpn", "client\n# key enc.key\nauth-user-pass\n");
+        assert!(!config_requires_key_passphrase(certonly.to_str().unwrap()));
+
+        // Missing config → false.
+        assert!(!config_requires_key_passphrase(
+            dir.join("nope.ovpn").to_str().unwrap()
+        ));
+
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn remove_config_refuses_paths_outside_the_store() {
+        // It deletes Eldrun's copy only — pointed at anything else (the user's
+        // original .ovpn, or worse), it must refuse before touching the fs.
+        let err = remove_config("/home/u/office.ovpn").unwrap_err();
+        assert!(err.contains("not a stored"), "{err}");
+        let err = remove_config("/etc/passwd").unwrap_err();
+        assert!(err.contains("not a stored"), "{err}");
+    }
+
+    #[test]
+    fn remove_config_of_missing_stored_file_is_ok() {
+        // The goal state is "not stored": a file already gone is success, not an
+        // error the UI has to explain.
+        let path = configs_dir().join("nope__gone.ovpn");
+        assert!(!path.exists());
+        assert_eq!(remove_config(path.to_str().unwrap()), Ok(()));
     }
 
     #[test]
@@ -377,8 +3415,154 @@ mod tests {
         assert!(stem.len() <= 40 + 1 + 16);
     }
 
+    #[test]
+    fn display_name_recovers_original_from_stored() {
+        // `{stem}__{original}` → original; stem may contain `__`.
+        assert_eq!(display_name("_home_u_work_ovpn_abcd1234__work.ovpn"), "work.ovpn");
+        assert_eq!(display_name("a__b__client.conf"), "client.conf");
+        // No separator → whole name (defensive; shouldn't happen for stored copies).
+        assert_eq!(display_name("loose.ovpn"), "loose.ovpn");
+    }
+
     #[test]
     fn is_connected_false_for_unknown_config() {
         assert!(!is_connected("/no/such/config-unit-test.ovpn"));
     }
+
+    // ── macOS pure helpers (run on any OS) ──────────────────────────────────
+
+    #[test]
+    fn applescript_escape_handles_quotes_and_backslashes() {
+        assert_eq!(applescript_escape("plain"), "plain");
+        assert_eq!(applescript_escape(r#"a"b"#), r#"a\"b"#);
+        assert_eq!(applescript_escape(r"a\b"), r"a\\b");
+        assert_eq!(applescript_escape(r#"\""#), r#"\\\""#);
+    }
+
+    #[test]
+    fn macos_admin_shell_command_wraps_and_escapes() {
+        let cmd = macos_admin_shell_command("'/opt/x/openvpn' --config 'a\"b.ovpn'", "Prompt.");
+        assert!(cmd.starts_with("do shell script \""));
+        assert!(cmd.ends_with("with prompt \"Prompt.\""));
+        assert!(cmd.contains("with administrator privileges"));
+        // The embedded double quote survived AppleScript-escaped.
+        assert!(cmd.contains(r#"a\"b.ovpn"#));
+    }
+
+    /// The app-close path tears tunnels down twice by design (the checked teardown
+    /// while the window is up, then `RunEvent::Exit`). The second pass must not
+    /// re-elevate for a daemon the first one already TERMed, or the user pays a
+    /// second polkit password prompt for one tunnel.
+    #[test]
+    #[cfg(any(unix, target_os = "windows"))]
+    fn a_signalled_pid_is_never_killed_a_second_time() {
+        // A pid this run has never signalled and that is alive (our own process)
+        // still needs its elevated kill.
+        let live = std::process::id() as i32;
+        assert!(!kill_already_handled(live));
+        // Once TERMed, a second teardown pass skips it — no second prompt.
+        mark_signalled(live);
+        assert!(kill_already_handled(live));
+        // A pid that is simply gone needs no kill either. Spawn-and-reap gives a pid
+        // that is definitively dead (pid 0 would NOT: `kill(0, 0)` signals the
+        // caller's own process group and so reads as alive).
+        let mut child = std::process::Command::new(if cfg!(windows) { "cmd" } else { "true" })
+            .args(if cfg!(windows) { vec!["/C", "exit"] } else { vec![] })
+            .spawn()
+            .expect("spawn a trivial child");
+        let dead = child.id() as i32;
+        child.wait().expect("reap it");
+        assert!(kill_already_handled(dead));
+    }
+
+    #[test]
+    fn pidfile_pid_accepts_digits_only() {
+        let dir = std::env::temp_dir().join(format!("eldrun-pidfile-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let write = |name: &str, body: &str| {
+            let p = dir.join(name);
+            std::fs::write(&p, body).unwrap();
+            p
+        };
+        assert_eq!(pidfile_pid(&write("ok.pid", "1234\n")), Some(1234));
+        assert_eq!(pidfile_pid(&write("ws.pid", "  567  ")), Some(567));
+        // Anything non-numeric must never reach `kill`.
+        assert_eq!(pidfile_pid(&write("evil.pid", "123; rm -rf /")), None);
+        assert_eq!(pidfile_pid(&write("neg.pid", "-1")), None);
+        assert_eq!(pidfile_pid(&write("empty.pid", "")), None);
+        assert_eq!(pidfile_pid(&dir.join("missing.pid")), None);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn wait_for_ready_logfile_finds_marker() {
+        let dir = std::env::temp_dir().join(format!("eldrun-ovpnlog-a-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let log = dir.join("t.log");
+        std::fs::write(&log, "line one\nInitialization Sequence Completed\nafter\n").unwrap();
+        let seen = std::sync::Mutex::new(Vec::<String>::new());
+        let result = wait_for_ready_logfile(
+            &log,
+            Duration::from_secs(5),
+            Duration::from_millis(10),
+            || true,
+            |l| seen.lock().unwrap().push(l.to_string()),
+        );
+        assert!(result.is_ok());
+        let seen = seen.lock().unwrap();
+        // Every line up to AND INCLUDING the marker is streamed; nothing after.
+        assert_eq!(seen.len(), 2);
+        assert_eq!(seen[0], "line one");
+        assert!(seen[1].contains("Initialization Sequence Completed"));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn wait_for_ready_logfile_reports_death_with_tail() {
+        let dir = std::env::temp_dir().join(format!("eldrun-ovpnlog-b-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let log = dir.join("t.log");
+        std::fs::write(&log, "AUTH: Received control message: AUTH_FAILED\n").unwrap();
+        let result = wait_for_ready_logfile(
+            &log,
+            Duration::from_secs(5),
+            Duration::from_millis(10),
+            || false, // daemon died
+            |_| {},
+        );
+        let err = result.unwrap_err();
+        // The failure reason from the log is surfaced, not swallowed.
+        assert!(err.contains("AUTH_FAILED"), "{err}");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn wait_for_ready_logfile_times_out_and_holds_partial_lines() {
+        let dir = std::env::temp_dir().join(format!("eldrun-ovpnlog-c-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let log = dir.join("t.log");
+        // No trailing newline: the partial line must NOT be emitted.
+        std::fs::write(&log, "partial without newline").unwrap();
+        let seen = std::sync::Mutex::new(Vec::<String>::new());
+        let result = wait_for_ready_logfile(
+            &log,
+            Duration::from_millis(50),
+            Duration::from_millis(10),
+            || true, // alive but silent → timeout path
+            |l| seen.lock().unwrap().push(l.to_string()),
+        );
+        assert_eq!(result.unwrap_err(), "OpenVPN connection timed out");
+        assert!(seen.lock().unwrap().is_empty(), "partial line must be held back");
+        // A missing logfile behaves like an empty one (daemon hasn't created it
+        // yet) rather than erroring out of the wait.
+        let result = wait_for_ready_logfile(
+            &dir.join("never-created.log"),
+            Duration::from_millis(30),
+            Duration::from_millis(10),
+            || true,
+            |_| {},
+        );
+        assert!(result.is_err());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
 }
diff --git a/src-tauri/src/services/project_runtime.rs b/src-tauri/src/services/project_runtime.rs
index 15eb9f0..e41d791 100644
--- a/src-tauri/src/services/project_runtime.rs
+++ b/src-tauri/src/services/project_runtime.rs
@@ -84,13 +84,9 @@ pub fn switch(
         save_previous_sessions(local_file, previous_project_id, snapshot);
     }
 
-    // 2b. If the next project is remote, ensure its sshfs mount is up before we
-    //     read any of its files. Best-effort + non-panicking: a mount failure is
-    //     logged and the switch proceeds (the file tree / PTY will simply see an
-    //     empty mountpoint rather than crashing the switch).
-    if let (Some(next_id), Some(local_file)) = (project_id, next_local_file) {
-        ensure_remote_mounted(next_id, local_file);
-    }
+    // 2b. Remote projects are SSH/SFTP-native (no mount): the pooled connection
+    //     is opened by the frontend on activation (`remote_connect`), and file
+    //     browse / I-O / git dispatch over SFTP/SSH. Nothing to mount here.
 
     // 3. Load the next project's session data (terminal, apps, file tabs).
     //    This is the only part the frontend waits on, so it runs before the
@@ -124,7 +120,26 @@ pub fn switch(
     //    Acquire WindowRegistry before WorkspaceState (lock order).
     {
         let prev_wids = {
-            let wins = win_registry.lock().unwrap();
+            // `mut` is only exercised on Windows/macOS (the cfg'd re-resolve
+            // below); other targets bind it immutably.
+            #[cfg_attr(
+                not(any(target_os = "windows", target_os = "macos")),
+                allow(unused_mut)
+            )]
+            let mut wins = win_registry.lock().unwrap();
+            // Windows/macOS: re-resolve any project-owned window whose id was never
+            // captured at launch time (the visible top-level often belongs to a
+            // CHILD of the spawned pid). Runs while holding ONLY the registry lock,
+            // before the WorkspaceState lock below — lock order preserved. The
+            // back-populated ids make this hide AND the switch-back show (step 8)
+            // work through the existing id-based primitives. No-op on Linux,
+            // where launch-time `_NET_WM_PID` resolution already fills the id.
+            #[cfg(any(target_os = "windows", target_os = "macos"))]
+            window_service::resolve_missing_window_ids(
+                &mut wins.windows,
+                previous_project_id,
+                |pid| crate::commands::apps::resolve_window_id_for_pid(pid),
+            );
             window_service::project_window_ids(&wins.windows, previous_project_id)
         };
         let ws = workspace.lock().unwrap();
@@ -143,6 +158,23 @@ pub fn switch(
         };
         for label in &prev_labels {
             if let Some(win) = app.get_webview_window(label) {
+                // Capture the popout's real on-screen geometry (PHYSICAL px, so
+                // it is scale-invariant and re-applies onto the SAME monitor)
+                // BEFORE hiding it. hide()/show() lets the WM re-place the window
+                // — typically onto the primary monitor — so switch-back must put
+                // it back explicitly (step 8b), or a multi-monitor popout lands on
+                // the wrong screen (#42).
+                if let (Ok(pos), Ok(size)) = (win.outer_position(), win.inner_size()) {
+                    win_registry.lock().unwrap().detached_bounds.insert(
+                        label.clone(),
+                        crate::commands::apps::DetachedBounds {
+                            x: pos.x,
+                            y: pos.y,
+                            w: size.width,
+                            h: size.height,
+                        },
+                    );
+                }
                 let _ = win.hide();
             }
         }
@@ -185,6 +217,31 @@ pub fn switch(
             if let Some(win) = app.get_webview_window(label) {
                 let _ = win.unminimize();
                 let _ = win.show();
+                // Put the popout back where it was before it was parked: the
+                // show() above lets the WM move it (often onto the wrong
+                // monitor), so re-apply the geometry captured at hide-time (step
+                // 5b), validated against the currently-connected monitors so an
+                // unplugged display can't strand it off-screen. Size before
+                // position so a resize can't shift the placement. PHYSICAL px →
+                // correct monitor regardless of per-monitor scaling (#42).
+                let saved = win_registry.lock().unwrap().detached_bounds.get(label).copied();
+                if let Some(b) = saved {
+                    let monitors = window_service::monitor_rects(&win);
+                    let fitted = crate::services::window_state::resolve_detached_geometry(
+                        crate::schema::settings::WindowState {
+                            x: b.x,
+                            y: b.y,
+                            w: b.w,
+                            h: b.h,
+                            maximized: false,
+                        },
+                        &monitors,
+                    );
+                    if let Some(g) = fitted {
+                        let _ = win.set_size(tauri::PhysicalSize::new(g.w, g.h));
+                        let _ = win.set_position(tauri::PhysicalPosition::new(g.x, g.y));
+                    }
+                }
             }
         }
     }
@@ -195,6 +252,37 @@ pub fn switch(
         window_service::project_tracked_ids(&wins.windows, project_id)
     };
 
+    // 10. Project containers (#38): tear down the container of the project
+    //     being left — unless tabs are still live inside it (a background
+    //     agent keeps its container until they finish or the app exits) — and
+    //     warm up the next project's. On its own thread, not merely off the
+    //     UI thread: `up()` can build an image (minutes) and must never delay
+    //     the switch; the spawn-path `up()` stays the fallback for tabs
+    //     opened before the warm-up completes, and sandbox's lifecycle lock
+    //     serializes rapid switches. Best-effort by design.
+    {
+        use tauri::Manager;
+        let registry = app
+            .state::<crate::commands::terminal::RegistryState>()
+            .inner()
+            .clone();
+        let prev = previous_project_id.map(String::from);
+        let next = project_id.map(String::from);
+        std::thread::spawn(move || {
+            if let Some(prev) = prev {
+                let live = registry.lock().unwrap().any_live_for_scope(&prev);
+                if !live {
+                    crate::services::sandbox::down_for_project(&prev);
+                }
+            }
+            if let Some(next) = next {
+                if let Err(e) = crate::services::sandbox::up_for_project(&next) {
+                    eprintln!("sandbox: container for '{next}': {e}");
+                }
+            }
+        });
+    }
+
     Ok(ProjectRuntimeSwitchedPayload {
         opened_window_ids,
         ..payload
@@ -203,24 +291,6 @@ pub fn switch(
 
 // ── Helpers ───────────────────────────────────────────────────────────────
 
-/// Best-effort sshfs mount for a remote project on switch. Loads the project's
-/// `project.json` from `local_file`; if it carries a `remote` spec, mount it (a
-/// no-op when already mounted). Local projects and load/mount failures are
-/// silently tolerated — this must never panic or abort the switch.
-fn ensure_remote_mounted(project_id: &str, local_file: &str) {
-    let project: crate::schema::project::Project =
-        match storage::read_json(std::path::Path::new(local_file)) {
-            Ok(p) => p,
-            Err(_) => return, // unreadable project.json → nothing to mount
-        };
-    let Some(remote) = project.remote.as_ref() else {
-        return; // local project
-    };
-    if let Err(e) = crate::services::ssh_mount::mount(remote, project_id) {
-        eprintln!("ProjectRuntime: mount remote project '{project_id}': {e}");
-    }
-}
-
 /// Persist file-tab, layout, and state snapshots for the project being left.
 fn save_previous_sessions(
     local_file: &str,
diff --git a/src-tauri/src/services/remote.rs b/src-tauri/src/services/remote.rs
new file mode 100644
index 0000000..5b11eb0
--- /dev/null
+++ b/src-tauri/src/services/remote.rs
@@ -0,0 +1,710 @@
+//! Explicit remoteness + pooled SSH/SFTP connection for remote (SSH) projects.
+//!
+//! Phase 0 of the mount-free remote model (`docs/mountfree_remote_plan.md`).
+//! Two responsibilities:
+//!
+//! 1. **Explicit remoteness.** [`remote_target_for`] is the single source of
+//!    truth for "is this project remote, and where does it live?" — replacing
+//!    the old infer-from-mountpoint-path signal (`ssh_exec::project_id_from_cwd`,
+//!    which sniffed a cwd under `ssh_mount::mounts_root()`). It returns `Some`
+//!    iff the project carries a [`RemoteSpec`]. Later phases (terminal, file
+//!    browse, file I/O, git) dispatch on this rather than on a path convention.
+//!
+//! 2. **Pooled connection.** A single persistent SSH ControlMaster + SFTP session
+//!    per active remote project, opened once on activation ([`connect`]) and
+//!    reused by file browsing / I-O (and ridden by agent tabs / git over the
+//!    shared master). This is the single-sign-on + performance linchpin:
+//!    authentication happens once here, and every later channel rides the master
+//!    with no re-auth and fast channel setup. Held in Tauri-managed state
+//!    ([`RemotePoolState`]); torn down by [`disconnect`] / [`disconnect_all`].
+//!
+//! Password-auth hosts feed the password to the master via `SSHPASS`
+//! (`sshpass -e`), never on argv. By default it is never stored; when the user
+//! opts into "Save password", it is kept in the OS keychain (never our JSON) and
+//! reused here for silent reconnect (see `services::remote_credentials`).
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use openssh_sftp_client::Sftp;
+use tokio::process::Child;
+use tokio::sync::Mutex;
+
+use crate::schema::project::{ComputeHost, RemoteSpec};
+use crate::schema::projects::{ProjectEntry, ProjectsList};
+
+/// The implicit host id of a project's **primary** remote (`Project.remote`).
+/// Extra "worker" hosts (`docs/multi_host_remote_plan.md`) carry their own stable
+/// ids; the primary's is this constant so file/git/sync callers — which *are* the
+/// primary subsystem — resolve it without threading an id.
+pub const PRIMARY_HOST: &str = "primary";
+
+/// Pool key for a `(project, host)` pair. Two hosts of one project → two entries,
+/// so a worker connects/disconnects independently of the primary. The `\u{1}`
+/// separator can't appear in a project or host id.
+fn conn_key(project_id: &str, host_id: &str) -> String {
+    format!("{project_id}\u{1}{host_id}")
+}
+
+/// The project id embedded in a [`conn_key`] (everything before the separator).
+fn project_of_key(key: &str) -> &str {
+    key.split('\u{1}').next().unwrap_or(key)
+}
+
+/// A resolved remote project: its [`RemoteSpec`] plus the owning project id.
+/// The explicit replacement for inferring remoteness from a mountpoint path.
+#[derive(Debug, Clone)]
+pub struct RemoteTarget {
+    pub spec: RemoteSpec,
+    pub project_id: String,
+}
+
+/// `Some(target)` iff the project identified by `project_id` is remote; `None`
+/// for a local project or any read failure (degrades to local-fs behavior).
+///
+/// The remote spec is read from the **always-local** `projects.json` entry's
+/// flattened `extra["remote"]` (mirrored there at create/import time), NOT from
+/// the per-project `project.json`: for a mount-free remote project that file
+/// lives on the host and is not locally readable, whereas this global list is
+/// always on the local disk. This keeps the resolver synchronous and fast.
+pub fn remote_target_for(project_id: &str) -> Option<RemoteTarget> {
+    let list = read_projects_list()?;
+    let entry = list.iter().find(|e| e.id == project_id)?;
+    spec_from_entry(entry).map(|spec| RemoteTarget {
+        spec,
+        project_id: project_id.to_string(),
+    })
+}
+
+/// `Some(target)` iff the project whose stored `directory` equals `project_dir`
+/// is remote; `None` for a local project, an unknown directory, or a read
+/// failure.
+///
+/// The git/file commands receive a `project_dir` (not a `project_id`), so to
+/// dispatch remote-vs-local without threading a `project_id` through every
+/// frontend call site we reverse-look-up the owning project: the value the
+/// frontend passes as `project_dir` is the project's stored `directory`, kept in
+/// the `projects.json` entry's flattened `extra["directory"]`. For a remote
+/// project `directory` is a local per-project state dir (no longer a mountpoint)
+/// that simply keys the entry and holds its `project.json`; the actual tree lives
+/// on `spec.remote_path` and is reached over SFTP/SSH.
+pub fn remote_target_for_dir(project_dir: &str) -> Option<RemoteTarget> {
+    let list = read_projects_list()?;
+    let entry = list
+        .iter()
+        .find(|e| entry_directory(e) == Some(project_dir))?;
+    spec_from_entry(entry).map(|spec| RemoteTarget {
+        spec,
+        project_id: entry.id.clone(),
+    })
+}
+
+/// Parsed `projects.json` plus the `(mtime, len)` it was parsed from — the cache
+/// behind [`read_projects_list`].
+static PROJECTS_CACHE: std::sync::Mutex<Option<(std::time::SystemTime, u64, Arc<ProjectsList>)>> =
+    std::sync::Mutex::new(None);
+
+/// Read the global `projects.json` list, or `None` if absent/unparseable.
+///
+/// CACHED on the file's `(mtime, len)`, because this is one of the hottest paths
+/// in the backend and it was re-reading and re-parsing the same file every time.
+/// [`remote_target_for`] and [`remote_target_for_dir`] are *the* remoteness
+/// oracle — every file, git, sync and SFTP call resolves through one of them, at
+/// ~110 call sites — and each call did a full disk read plus a serde parse of a
+/// document whose entries carry `#[serde(flatten)]` extras. Flattened
+/// deserialization is buffered and quadratic-ish in field count, so it is
+/// expensive out of proportion to the file's size. A `perf` profile of the
+/// backend under ordinary use was dominated by exactly that: `parse_whitespace`,
+/// `FlatMapAccess::next_value_seed`, `skip_to_escape`, spread across every tokio
+/// worker, at ~175% of a core.
+///
+/// A `stat` replaces the read whenever nothing has changed. Eldrun is the only
+/// writer of this file, and every write goes through `storage::write_json`, so a
+/// changed list always moves `mtime` (nanosecond precision on Linux) or `len`.
+/// The value is an `Arc`, so a hit costs one clone of a pointer rather than of
+/// the whole list.
+fn read_projects_list() -> Option<Arc<ProjectsList>> {
+    let list_path = crate::storage::state_dir().join("projects.json");
+    let meta = std::fs::metadata(&list_path).ok()?;
+    let stamp = (meta.modified().ok()?, meta.len());
+
+    if let Ok(guard) = PROJECTS_CACHE.lock() {
+        if let Some((mtime, len, list)) = guard.as_ref() {
+            if *mtime == stamp.0 && *len == stamp.1 {
+                return Some(Arc::clone(list));
+            }
+        }
+    }
+
+    let list: Arc<ProjectsList> = Arc::new(crate::storage::read_json(&list_path).ok()?);
+    if let Ok(mut guard) = PROJECTS_CACHE.lock() {
+        *guard = Some((stamp.0, stamp.1, Arc::clone(&list)));
+    }
+    Some(list)
+}
+
+/// A `projects.json` entry's stored `directory` (its flattened `extra` field).
+fn entry_directory(entry: &ProjectEntry) -> Option<&str> {
+    entry.extra.get("directory").and_then(|v| v.as_str())
+}
+
+/// The `directory` recorded for `project_id` in the always-local `projects.json`.
+///
+/// The forward lookup to [`remote_target_for_dir`]'s reverse one. For a LOCAL
+/// project this is where its files are; for a REMOTE project it is the local
+/// per-project state dir, not the tree (which lives on the host).
+pub fn project_directory(project_id: &str) -> Option<String> {
+    let list = read_projects_list()?;
+    let entry = list.iter().find(|e| e.id == project_id)?;
+    entry_directory(entry).map(str::to_string)
+}
+
+/// The `RemoteSpec` mirrored into a `projects.json` entry's flattened
+/// `extra["remote"]`, or `None` for a local project. Pure, so the "remote iff a
+/// spec is present" mapping is testable without the real state dir.
+fn spec_from_entry(entry: &ProjectEntry) -> Option<RemoteSpec> {
+    let value = entry.extra.get("remote")?;
+    serde_json::from_value(value.clone()).ok()
+}
+
+/// The extra "worker" hosts mirrored into a `projects.json` entry's flattened
+/// `extra["compute_hosts"]`, or `[]` when absent/unparseable. Pure, so the
+/// resolver is testable without the real state dir.
+fn compute_hosts_from_entry(entry: &ProjectEntry) -> Vec<ComputeHost> {
+    entry
+        .extra
+        .get("compute_hosts")
+        .and_then(|v| serde_json::from_value(v.clone()).ok())
+        .unwrap_or_default()
+}
+
+/// The extra worker hosts declared for `project_id`, read from the always-local
+/// `projects.json` (mirrored there by `commands::projects`). `[]` for a local or
+/// single-host project.
+pub fn compute_hosts_for(project_id: &str) -> Vec<ComputeHost> {
+    read_projects_list()
+        .and_then(|list| {
+            list.iter()
+                .find(|e| e.id == project_id)
+                .map(compute_hosts_from_entry)
+        })
+        .unwrap_or_default()
+}
+
+/// Resolve `(project_id, host_id)` to a [`RemoteTarget`]: the primary spec
+/// ([`remote_target_for`]) for [`PRIMARY_HOST`], else the matching worker's spec.
+/// `None` for a local project, an unknown host id, or a read failure.
+pub fn remote_target_for_host(project_id: &str, host_id: &str) -> Option<RemoteTarget> {
+    if host_id == PRIMARY_HOST {
+        return remote_target_for(project_id);
+    }
+    compute_hosts_for(project_id)
+        .into_iter()
+        .find(|h| h.id == host_id)
+        .map(|h| RemoteTarget {
+            spec: h.spec,
+            project_id: project_id.to_string(),
+        })
+}
+
+// ── Pooled connection ──────────────────────────────────────────────────────
+
+/// One pooled remote connection: the live SFTP session (shared via `Arc` so file
+/// commands can clone it and run operations without holding the pool lock — see
+/// [`pooled_sftp`]) and the `ssh` child whose lifetime keeps the session, and the
+/// ControlMaster it established, alive. Dropping `child` would collapse the
+/// connection, so it is owned here and killed explicitly on teardown.
+struct PooledRemote {
+    sftp: Arc<Sftp>,
+    child: Child,
+    /// The `cm-<hash>` socket this connection's ControlMaster owns, resolved at
+    /// connect time (`ssh -G` expands `%C`, which nothing here can compute) so
+    /// teardown can unlink it. See [`teardown_pooled`].
+    control_path: Option<std::path::PathBuf>,
+    /// The standing dial authorization this connection holds, as an RAII guard
+    /// rather than a matching `forget_…` call at teardown. That distinction is
+    /// load-bearing: `teardown_pooled` is **not** the only way a pool entry goes
+    /// away — five sites (`connect_host`'s own dead-entry eviction,
+    /// `pooled_sftp_host`, `connected_ids`, `is_connected_host`,
+    /// `connected_targets`) reap a dead connection by simply removing it from the
+    /// map. Each of those used to leak a refcount, and one leak permanently
+    /// authorizes *every background* dial to that target for the rest of the
+    /// process — disarming the HPC gate on precisely the hosts whose master dies
+    /// most often. Held as a field, `Drop` covers every one of those paths.
+    _dial: crate::services::ssh_common::UserDial,
+}
+
+/// Tauri-managed pool of live remote connections, keyed by [`conn_key`]
+/// (`project\u{1}host`) so a project's primary and its extra worker hosts each
+/// hold an independent connection.
+#[derive(Default)]
+pub struct RemotePool {
+    conns: HashMap<String, PooledRemote>,
+}
+
+/// Managed-state handle to the pool. `tokio::sync::Mutex` because every access is
+/// inside an async command and teardown awaits the child.
+pub type RemotePoolState = Arc<Mutex<RemotePool>>;
+
+/// Build a fresh, empty pool for `tauri::Builder::manage`.
+pub fn new_pool() -> RemotePoolState {
+    Arc::new(Mutex::new(RemotePool::default()))
+}
+
+/// Open (idempotently) the pooled SSH/SFTP connection for `project_id`. A no-op
+/// for a local project or one already connected. `password` is used only for
+/// password-auth hosts (fed to `sshpass` over `SSHPASS`, never stored / on argv);
+/// `None` uses key/agent auth. The connection is opened OUTSIDE the pool lock so
+/// a slow handshake never blocks other pool access.
+///
+/// By contract of the caller (the UI invokes this fire-and-forget on activation)
+/// a failure must never block activation: it is returned as `Err` for the caller
+/// to log, and the project simply has no pooled connection (later access falls
+/// back to a one-shot session, exactly as before).
+pub async fn connect(
+    pool: &RemotePoolState,
+    project_id: &str,
+    password: Option<&str>,
+) -> Result<(), String> {
+    connect_host(pool, project_id, PRIMARY_HOST, password).await
+}
+
+/// Open (idempotently) the pooled connection for a specific `(project, host)`.
+/// [`PRIMARY_HOST`] is the project's primary remote (and mints the local mirror);
+/// any other id is an extra worker host resolved from `compute_hosts`. A no-op for
+/// a local project, an unknown host id, or one already connected. See [`connect`]
+/// for the password/auth contract.
+pub async fn connect_host(
+    pool: &RemotePoolState,
+    project_id: &str,
+    host_id: &str,
+    password: Option<&str>,
+) -> Result<(), String> {
+    let Some(target) = remote_target_for_host(project_id, host_id) else {
+        return Ok(()); // local project or unknown host — nothing to pool
+    };
+    // SSH-sync Phase 1: ensure the local mirror twin exists for a connected
+    // remote project (covers projects created before the mirror was minted at
+    // create time). Only the PRIMARY owns the mirror — a worker never does.
+    if host_id == PRIMARY_HOST {
+        let _ = std::fs::create_dir_all(crate::services::remote_sync::mirror_dir(project_id));
+    }
+    let key = conn_key(project_id, host_id);
+    {
+        // Liveness-checked, not mere presence: a pooled ssh child can have exited
+        // long after connect (keepalive kill on a dropped VPN/network, laptop
+        // sleep, an HPC job's long queue wait past `ControlPersist`) while the
+        // pool entry lingers. Every other reader here (`is_connected_host`,
+        // `pooled_sftp_host`, etc.) reaps a corpse before answering; this one
+        // must too, or a dead entry blocks reconnection forever and every later
+        // tab on that host falls through to its own unauthenticated raw `ssh`.
+        let mut guard = pool.lock().await;
+        let dead = guard
+            .conns
+            .get_mut(&key)
+            .map(|conn| matches!(conn.child.try_wait(), Ok(Some(_))));
+        match dead {
+            Some(true) => {
+                guard.conns.remove(&key);
+            }
+            Some(false) => return Ok(()), // already connected and alive
+            None => {}
+        }
+    }
+
+    let spec = &target.spec;
+    // Silent reconnect: the activation path calls this with `None`. Before falling
+    // back to key/agent auth, use a saved password for this host target if the user
+    // opted to remember one (see `services::remote_credentials`).
+    //
+    // An *empty* password counts as "none given", not as "authenticate with the
+    // empty string": the Connect modal sends a blank field when the user is relying
+    // on the saved credential, and taking that literally made the pooled connect
+    // fail with a saved password sitting right there in the keychain (`ssh_connect`
+    // filters it, so the probe passed and only this leg failed).
+    let saved_pw;
+    let password = password.filter(|p| !p.is_empty());
+    let password = if password.is_some() {
+        password
+    } else {
+        saved_pw = crate::services::remote_credentials::get(
+            &crate::services::remote_credentials::ssh_account(&spec.user, &spec.host, spec.port),
+        );
+        saved_pw.as_deref()
+    };
+    let (sftp, child) =
+        crate::services::sftp::open_pooled_session(&spec.user, &spec.host, spec.port, password)
+            .await?;
+
+    // Resolve the master's socket path now, while nothing is held: it spawns a
+    // local `ssh -G` (see `ssh_exec::resolve_control_path`), which must not run
+    // on a tokio worker under the pool lock. Recorded so teardown can unlink it.
+    let control_path = {
+        let spec = spec.clone();
+        tokio::task::spawn_blocking(move || crate::services::ssh_exec::resolve_control_path(&spec))
+            .await
+            .unwrap_or(None)
+    };
+
+    let mut guard = pool.lock().await;
+    // A concurrent connect may have won the race while we were handshaking. If so
+    // keep theirs and tear ours down rather than leaking a second ssh child.
+    if guard.conns.contains_key(&key) {
+        drop(guard);
+        teardown_session(sftp, child).await;
+        return Ok(());
+    }
+    // The connection is live and the user's: hold a standing dial authorization
+    // for as long as it is pooled. Work that rides a master a person opened — a
+    // shell tab, a `git status`, a Sessions listing — is not Eldrun reaching out
+    // by itself, so it must not be refused on a host tagged HPC. The guard lives
+    // *in* the pool entry, so it is released however that entry dies.
+    let dial = crate::services::ssh_common::user_dial(&spec.user, &spec.host, spec.port);
+    guard.conns.insert(
+        key,
+        PooledRemote {
+            sftp: Arc::new(sftp),
+            child,
+            control_path,
+            _dial: dial,
+        },
+    );
+    Ok(())
+}
+
+/// Close and remove the pooled PRIMARY connection for `project_id` (no-op if none).
+pub async fn disconnect(pool: &RemotePoolState, project_id: &str) {
+    disconnect_host(pool, project_id, PRIMARY_HOST).await;
+}
+
+/// Close and remove the pooled connection for a specific `(project, host)`.
+pub async fn disconnect_host(pool: &RemotePoolState, project_id: &str, host_id: &str) {
+    let removed = pool.lock().await.conns.remove(&conn_key(project_id, host_id));
+    if let Some(conn) = removed {
+        teardown_pooled(conn).await;
+    }
+}
+
+/// Close and remove **every** pooled connection for `project_id` — its primary and
+/// all worker hosts. Used on project deactivation so no host outlives the view.
+pub async fn disconnect_project(pool: &RemotePoolState, project_id: &str) {
+    let removed: Vec<PooledRemote> = {
+        let mut guard = pool.lock().await;
+        let keys: Vec<String> = guard
+            .conns
+            .keys()
+            .filter(|k| project_of_key(k) == project_id)
+            .cloned()
+            .collect();
+        keys.into_iter().filter_map(|k| guard.conns.remove(&k)).collect()
+    };
+    for conn in removed {
+        teardown_pooled(conn).await;
+    }
+}
+
+/// Tear down every pooled connection. Used at app exit so no ssh ControlMaster
+/// child outlives Eldrun.
+pub async fn disconnect_all(pool: &RemotePoolState) {
+    let conns: Vec<PooledRemote> = {
+        let mut guard = pool.lock().await;
+        guard.conns.drain().map(|(_, c)| c).collect()
+    };
+    for conn in conns {
+        teardown_pooled(conn).await;
+    }
+}
+
+/// Clone the pooled SFTP session for `project_id`, if one is connected. Later
+/// phases (file browse / I-O) call this and run operations on the returned
+/// `Arc<Sftp>` without holding the pool lock. `None` when the project is not
+/// connected — the caller then opens a one-shot session or surfaces a
+/// "disconnected" state rather than hanging.
+#[allow(dead_code)] // consumed by Phase 2/3 (remote file browse + I/O)
+pub async fn pooled_sftp(pool: &RemotePoolState, project_id: &str) -> Option<Arc<Sftp>> {
+    pooled_sftp_host(pool, project_id, PRIMARY_HOST).await
+}
+
+/// Clone the pooled SFTP session for a specific `(project, host)`, if connected.
+pub async fn pooled_sftp_host(
+    pool: &RemotePoolState,
+    project_id: &str,
+    host_id: &str,
+) -> Option<Arc<Sftp>> {
+    let key = conn_key(project_id, host_id);
+    let mut guard = pool.lock().await;
+    let conn = guard.conns.get_mut(&key)?;
+    // If the ssh child has already exited — the keepalive killed it after a
+    // network drop (ServerAliveInterval/CountMax), or the remote closed the
+    // connection — the pooled session is dead and every SFTP op on it would fail
+    // against a closed pipe. Evict the corpse so the caller falls back to a
+    // one-shot session (which can ride a still-live master, or surface a clean
+    // disconnected state) instead of looping on the dead entry forever.
+    if matches!(conn.child.try_wait(), Ok(Some(_))) {
+        guard.conns.remove(&key);
+        return None;
+    }
+    Some(Arc::clone(&conn.sftp))
+}
+
+/// The **distinct project ids** with any pooled SSH connection currently live
+/// (primary or any worker host). Evicts any whose ssh child has already exited
+/// (same corpse-reaping as [`is_connected`]) so the background traffic sampler
+/// never samples a dead ControlMaster. Order is unspecified. Traffic accounting
+/// sums a project's hosts under one project bucket (plan §3.4), so this collapses
+/// the composite keys back to project ids.
+pub async fn connected_ids(pool: &RemotePoolState) -> Vec<String> {
+    let mut guard = pool.lock().await;
+    let dead: Vec<String> = guard
+        .conns
+        .iter_mut()
+        .filter_map(|(key, conn)| match conn.child.try_wait() {
+            Ok(Some(_)) => Some(key.clone()),
+            _ => None,
+        })
+        .collect();
+    for key in &dead {
+        guard.conns.remove(key);
+    }
+    let mut ids: Vec<String> = guard
+        .conns
+        .keys()
+        .map(|k| project_of_key(k).to_string())
+        .collect();
+    ids.sort();
+    ids.dedup();
+    ids
+}
+
+/// Whether a project's PRIMARY pooled SSH connection is live.
+pub async fn is_connected(pool: &RemotePoolState, project_id: &str) -> bool {
+    is_connected_host(pool, project_id, PRIMARY_HOST).await
+}
+
+/// Whether a specific `(project, host)` pooled SSH connection is live. Like
+/// [`pooled_sftp`], this evicts a child that has already exited so read-only
+/// observers never launch a fallback connection merely to discover it is offline.
+pub async fn is_connected_host(pool: &RemotePoolState, project_id: &str, host_id: &str) -> bool {
+    let key = conn_key(project_id, host_id);
+    let mut guard = pool.lock().await;
+    let Some(conn) = guard.conns.get_mut(&key) else {
+        return false;
+    };
+    if matches!(conn.child.try_wait(), Ok(Some(_))) {
+        guard.conns.remove(&key);
+        return false;
+    }
+    true
+}
+
+/// The `(project_id, host_id)` pairs whose pooled SSH connection is currently live.
+/// The per-host granular form of [`connected_ids`], for the frontend to reconcile
+/// each lamp against reality. Evicts dead children like the others.
+pub async fn connected_targets(pool: &RemotePoolState) -> Vec<(String, String)> {
+    let mut guard = pool.lock().await;
+    let dead: Vec<String> = guard
+        .conns
+        .iter_mut()
+        .filter_map(|(key, conn)| match conn.child.try_wait() {
+            Ok(Some(_)) => Some(key.clone()),
+            _ => None,
+        })
+        .collect();
+    for key in &dead {
+        guard.conns.remove(key);
+    }
+    guard
+        .conns
+        .keys()
+        .filter_map(|k| {
+            let mut parts = k.split('\u{1}');
+            let pid = parts.next()?;
+            let hid = parts.next().unwrap_or(PRIMARY_HOST);
+            Some((pid.to_string(), hid.to_string()))
+        })
+        .collect()
+}
+
+/// Tear down a pooled connection: gracefully close the SFTP session (sends
+/// `SSH_FXP_CLOSE`, matching [`teardown_session`]) when we hold its only
+/// reference, then kill the `ssh` child, which collapses the channel and the
+/// ControlMaster it owned. If a file op is still borrowing the `Arc<Sftp>`, we
+/// can't take ownership to `close()` it, so we drop our reference and let its own
+/// `Drop` close the local side once that borrow finishes.
+/// Also unlinks the control socket, and releases the standing dial authorization
+/// [`connect_host`] took out — both paired one-for-one with the pool entry, so
+/// they cannot outlive the connection they describe.
+///
+/// The socket matters because `child.kill()` is not `ssh -O exit`: the master dies
+/// but leaves its `cm-<hash>` behind, and OpenSSH answers the *next* connection to
+/// a stale socket with "ControlSocket … already exists, disabling multiplexing" —
+/// after which every command that was supposed to ride one authenticated master
+/// opens its own login instead. On a host with a saved password that is silent; on
+/// a cluster login node it is a login per file read.
+async fn teardown_pooled(conn: PooledRemote) {
+    // `_dial` is dropped with the rest of the struct at the end of this function,
+    // releasing the standing authorization — the same thing that happens when a
+    // dead entry is reaped without ever reaching here.
+    let PooledRemote {
+        sftp,
+        mut child,
+        control_path,
+        _dial,
+    } = conn;
+    match Arc::try_unwrap(sftp) {
+        Ok(sftp) => {
+            let _ = sftp.close().await;
+        }
+        Err(arc) => drop(arc),
+    }
+    let _ = child.kill().await;
+    if let Some(path) = control_path {
+        let _ = std::fs::remove_file(path);
+    }
+}
+
+/// Gracefully close a freshly-opened, not-yet-pooled session (the lost-race path
+/// in [`connect`]). Here we still own the `Sftp` outright, so the consuming
+/// `Sftp::close` can run before the child is killed.
+async fn teardown_session(sftp: Sftp, mut child: Child) {
+    let _ = sftp.close().await;
+    let _ = child.kill().await;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    fn spec() -> RemoteSpec {
+        RemoteSpec {
+            user: Some("alice".to_string()),
+            host: "host.example".to_string(),
+            port: None,
+            remote_path: "/srv/project".to_string(),
+            openvpn: None,
+            auto_connect: None,
+            key_auth: None,
+            persist_sessions: None,
+            label: None,
+            extra: HashMap::new(),
+        }
+    }
+
+    /// A `projects.json` entry, optionally remote (its spec mirrored into
+    /// `extra["remote"]` exactly as `commands::projects::project_extra` does).
+    fn entry(id: &str, directory: Option<&str>, remote: Option<RemoteSpec>) -> ProjectEntry {
+        let mut extra = HashMap::new();
+        if let Some(d) = directory {
+            extra.insert(
+                "directory".to_string(),
+                serde_json::Value::String(d.to_string()),
+            );
+        }
+        if let Some(r) = remote {
+            extra.insert("remote".to_string(), serde_json::to_value(&r).unwrap());
+        }
+        ProjectEntry {
+            id: id.to_string(),
+            name: id.to_string(),
+            status: "active".to_string(),
+            position: 0,
+            local_file: format!("/state/{id}.json"),
+            extra,
+        }
+    }
+
+    #[test]
+    fn spec_from_entry_some_for_remote_project() {
+        let e = entry("p1", Some("/state/remote-projects/p1"), Some(spec()));
+        let resolved = spec_from_entry(&e).expect("remote entry resolves a spec");
+        assert_eq!(resolved.host, "host.example");
+        assert_eq!(resolved.remote_path, "/srv/project");
+    }
+
+    #[test]
+    fn spec_from_entry_none_for_local_project() {
+        let e = entry("p1", Some("/home/u/eldrun/projects/alpha"), None);
+        assert!(spec_from_entry(&e).is_none());
+    }
+
+    #[test]
+    fn entry_directory_reads_extra() {
+        let e = entry("p1", Some("/some/dir"), None);
+        assert_eq!(entry_directory(&e), Some("/some/dir"));
+        let e2 = entry("p2", None, None);
+        assert_eq!(entry_directory(&e2), None);
+    }
+
+    fn compute_host(id: &str, host: &str) -> ComputeHost {
+        ComputeHost {
+            id: id.to_string(),
+            sync_code: true,
+            pull_outputs: false,
+            shared_fs: false,
+            spec: RemoteSpec {
+                user: Some("alice".to_string()),
+                host: host.to_string(),
+                port: None,
+                remote_path: "/srv/worker".to_string(),
+                openvpn: None,
+                auto_connect: None,
+                key_auth: None,
+                persist_sessions: None,
+                label: None,
+                extra: HashMap::new(),
+            },
+        }
+    }
+
+    #[test]
+    fn conn_key_is_unique_per_host() {
+        let a = conn_key("p1", PRIMARY_HOST);
+        let b = conn_key("p1", "h1");
+        let c = conn_key("p2", "h1");
+        assert_ne!(a, b);
+        assert_ne!(b, c);
+        assert_ne!(a, c);
+        // The project id is recoverable from the composite key.
+        assert_eq!(project_of_key(&a), "p1");
+        assert_eq!(project_of_key(&b), "p1");
+        assert_eq!(project_of_key(&c), "p2");
+    }
+
+    #[test]
+    fn compute_hosts_from_entry_parses_mirror() {
+        let mut e = entry("p1", Some("/state/p1"), Some(spec()));
+        e.extra.insert(
+            "compute_hosts".to_string(),
+            serde_json::to_value(vec![compute_host("h1", "gpu-2.example")]).unwrap(),
+        );
+        let hosts = compute_hosts_from_entry(&e);
+        assert_eq!(hosts.len(), 1);
+        assert_eq!(hosts[0].id, "h1");
+        assert_eq!(hosts[0].spec.host, "gpu-2.example");
+        assert!(hosts[0].sync_code); // serde default_true survives a round trip
+    }
+
+    #[test]
+    fn compute_hosts_from_entry_empty_when_absent() {
+        let e = entry("p1", Some("/state/p1"), Some(spec()));
+        assert!(compute_hosts_from_entry(&e).is_empty());
+    }
+
+    #[test]
+    fn display_label_falls_back_to_host() {
+        let mut h = compute_host("h1", "gpu-2.example");
+        assert_eq!(h.display_label(), "gpu-2.example");
+        h.spec.label = Some("trainer".to_string());
+        assert_eq!(h.display_label(), "trainer");
+    }
+
+    #[test]
+    fn new_pool_starts_empty() {
+        let pool = new_pool();
+        // The pool is async-locked; a blocking check here is fine in a sync test
+        // since nothing else holds the lock.
+        let guard = pool.try_lock().expect("uncontended");
+        assert!(guard.conns.is_empty());
+    }
+}
diff --git a/src-tauri/src/services/remote_credentials.rs b/src-tauri/src/services/remote_credentials.rs
new file mode 100644
index 0000000..57e4584
--- /dev/null
+++ b/src-tauri/src/services/remote_credentials.rs
@@ -0,0 +1,658 @@
+//! Optional, opt-in secure storage for **remote-connection passwords** (SSH
+//! login + OpenVPN passphrase), backed by the OS credential store (Windows
+//! Credential Manager / macOS Keychain / Linux Secret Service) via the `keyring`
+//! crate — the same mechanism `git_credentials` uses for hosting tokens.
+//!
+//! The default remains "never persist a password": a password is only written
+//! here when the user ticks the per-connection **Save password** checkbox, and it
+//! is written **only after authentication has succeeded**. Unticking the box (and
+//! reconnecting) clears any previously-saved entry, so the checkbox is the single
+//! source of truth for "remember this".
+//!
+//! Why the OS keychain and not our JSON state? A password in `settings.json` or a
+//! project's `project.json` would sit in plaintext on disk (and `project.json`
+//! lives in the git working tree). Secrets therefore never touch our JSON — only
+//! the keychain holds them, keyed by the **host target** so two projects sharing a
+//! host/VPN share one saved credential.
+//!
+//! All operations degrade gracefully: a keychain that is unavailable (e.g. a
+//! headless Linux box with no Secret Service) yields `None` on read and an
+//! `Err(String)` on write, so callers fall back to prompting rather than failing.
+
+const SERVICE: &str = "eldrun-remote";
+
+/// The Linux credential handles are trait objects, not `keyring::Entry`, so their
+/// `get_password`/`set_password`/`delete_credential` come from this trait. Imported
+/// anonymously: only the methods are wanted, never the name.
+#[cfg(target_os = "linux")]
+use keyring::credential::CredentialApi as _;
+
+/// The keychain account for an SSH host target: `"ssh:{user}@{host}:{port}"`.
+/// `user` defaults to empty and `port` to 22 so the key is stable whether the
+/// caller passes `None`/`Some(22)` or an omitted user — the same live target
+/// always maps to the same entry.
+///
+/// The **host is lower-cased** for the same reason `ssh_common::target_key`
+/// does it: DNS is case-insensitive, so a host typed `Login.Example` in one
+/// dialog and `login.example` in another is one machine — but two keychain
+/// entries, which reads as "no password saved" on whichever spelling the user
+/// did not save under. The login name is *not* folded: a different login is a
+/// different account with its own password. Trimming matches: a trailing space
+/// pasted into the address field must not mint a second entry.
+pub fn ssh_account(user: &Option<String>, host: &str, port: Option<u16>) -> String {
+    let user = user.as_deref().unwrap_or("").trim();
+    let host = host.trim().to_lowercase();
+    let port = port.unwrap_or(22);
+    format!("ssh:{user}@{host}:{port}")
+}
+
+/// The keychain account for an OpenVPN tunnel's primary secret, keyed by its
+/// stored config path — the `auth-user-pass` account password, or (for a config
+/// with no account) the private-key passphrase.
+pub fn openvpn_account(config: &str) -> String {
+    format!("openvpn:{config}")
+}
+
+/// The keychain account for an OpenVPN tunnel's **private-key passphrase**, for
+/// configs that need it *alongside* an `auth-user-pass` account password. Two
+/// independent secrets need two entries; a config that only has a key passphrase
+/// keeps storing it under [`openvpn_account`] (there is no account password to
+/// collide with).
+pub fn openvpn_key_account(config: &str) -> String {
+    format!("openvpn-key:{config}")
+}
+
+/// The keychain account for an OpenVPN tunnel's **auth username** — the one
+/// non-secret in the set, stored here anyway because it is the missing half of a
+/// promptless connect and there is nowhere else to put it.
+///
+/// A username on a *project's* `OpenVpnSpec` only exists for a tunnel a project
+/// owns. A tunnel brought up from the header has no project, so without this the
+/// username was simply unknown on every reconnect: the silent connect ran without
+/// it, `pkexec` raised a polkit prompt, OpenVPN was rejected by the server, and the
+/// modal then asked for it — a second polkit prompt for one tunnel. Saved and
+/// cleared together with the secrets, under the same opt-in checkbox.
+pub fn openvpn_user_account(config: &str) -> String {
+    format!("openvpn-user:{config}")
+}
+
+/// The platform credential handle for `account`.
+///
+/// Everywhere but Linux this is `keyring::Entry`, the crate's own dispatch to the
+/// Windows Credential Manager / macOS Keychain.
+///
+/// On **Linux** it is deliberately *not* `Entry`: it is the keyutils-persistent
+/// credential built by hand. That store — a kernel-keyring cache in front of the
+/// Secret Service, which stays the half that survives a reboot — is what keeps a
+/// blocking D-Bus read off every connect path but the first of each boot. It cannot be
+/// reached through `Entry`, because keyring 3.6's builder for it
+/// (`KeyutilsPersistentCredentialBuilder::build`) returns a plain `SsCredential`:
+/// enabling the feature and going on using `Entry` would silently keep today's
+/// secret-service-only behaviour. Constructing the credential directly is the whole
+/// point of the feature, so it is done here, once.
+#[cfg(target_os = "linux")]
+fn entry(account: &str) -> Result<keyring::keyutils_persistent::KeyutilsPersistentCredential, String>
+{
+    keyring::keyutils_persistent::KeyutilsPersistentCredential::new_with_target(
+        None, SERVICE, account,
+    )
+    .map_err(|e| e.to_string())
+}
+
+#[cfg(not(target_os = "linux"))]
+fn entry(account: &str) -> Result<keyring::Entry, String> {
+    keyring::Entry::new(SERVICE, account).map_err(|e| e.to_string())
+}
+
+/// Read `account` from the **kernel keyring only**, never touching the Secret Service.
+///
+/// This is the locked-collection path. The cache half of the store is a plain syscall:
+/// it cannot block, cannot raise a prompt, and is readable while the `login` collection
+/// is locked — so a credential already read once this boot keeps working through a lock
+/// instead of reading as "nothing saved". A miss is simply `None`; there is deliberately
+/// no fallback, because the fallback is the call this exists to avoid.
+///
+/// The key must match the one the combo store's cache half writes, so it is derived the
+/// same way: `new_with_target(None, SERVICE, account)`.
+#[cfg(target_os = "linux")]
+fn get_cached_only(account: &str) -> Option<String> {
+    use keyring::credential::CredentialApi;
+    let cred = keyring::keyutils::KeyutilsCredential::new_with_target(None, SERVICE, account).ok()?;
+    cred.get_password().ok().filter(|p| !p.is_empty())
+}
+
+/// How long a single keychain **read** may block before we give up on it and answer
+/// "nothing readable". Comfortably longer than an unlocked read (milliseconds), short
+/// enough that a connect never appears wedged.
+const READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(4);
+
+/// Run a keychain read on a throwaway thread and abandon it after [`READ_TIMEOUT`].
+///
+/// The Linux Secret Service blocks **indefinitely** while the keyring collection is
+/// *locked*: the read triggers an unlock that has to be answered first, and on a
+/// session where that prompt never surfaces (a locked `login` collection with no
+/// running prompter, a headless run) the call simply never returns. Every credential
+/// read here sits on a connect path — `ssh_connect`'s saved-password fallback, the
+/// silent-connect probes, auto-connect — so an unbounded one wedges the connect and
+/// parks the lamp on "connecting" forever (the amber-that-never-resolves). Bounding it
+/// degrades a locked keyring to "nothing saved", which routes the caller to a prompt —
+/// the safe direction. The abandoned worker unblocks if the keyring ever does; that
+/// costs at most one parked thread per hung read, and only ever happens locked.
+fn read_timed<T: Send + 'static>(f: impl FnOnce() -> T + Send + 'static, on_timeout: T) -> T {
+    let (tx, rx) = std::sync::mpsc::channel();
+    std::thread::spawn(move || {
+        let _ = tx.send(f());
+    });
+    rx.recv_timeout(READ_TIMEOUT).unwrap_or(on_timeout)
+}
+
+/// Read the saved password for `account`. Returns `None` when nothing is stored,
+/// the keychain is unavailable, or the read timed out against a locked keyring —
+/// never an error, and never a hang, so a missing/unreachable credential cleanly
+/// falls through to prompting.
+///
+/// **A locked collection is never dispatched to.** [`read_timed`] bounds the *caller*,
+/// but the abandoned worker stays parked inside the Secret Service call for as long as
+/// the unlock prompt goes unanswered — one thread, holding one open D-Bus connection,
+/// per read, and every connect path takes one. When the process then exits, all of them
+/// drop mid-request, which is a client vanishing between dispatch and reply: the state
+/// `gnome-keyring-daemon` aborts on (`assertion 'client' failed` in `OpenSession`). A
+/// crashed daemon is restarted by systemd *without* the login password PAM handed the
+/// original, so the collection comes back locked — and the next run parks its reads
+/// again. Asking [`cached_keyring_state`] first breaks that loop: while locked, the read
+/// goes to the kernel-keyring cache, which answers immediately and off the bus.
+pub fn get(account: &str) -> Option<String> {
+    #[cfg(target_os = "linux")]
+    if cached_keyring_state() != KeyringState::Unlocked {
+        return get_cached_only(account);
+    }
+    let account = account.to_string();
+    read_timed(move || get_uncapped(&account), None)
+}
+
+/// The unbounded keychain read, run on the worker thread by [`get`].
+fn get_uncapped(account: &str) -> Option<String> {
+    match entry(account).and_then(|e| match e.get_password() {
+        Ok(secret) => Ok(Some(secret)),
+        Err(keyring::Error::NoEntry) => Ok(None),
+        Err(e) => Err(e.to_string()),
+    }) {
+        Ok(pw) => pw.filter(|p| !p.is_empty()),
+        Err(_) => None,
+    }
+}
+
+/// Store (non-empty) or clear (`None`/empty) the password for `account`. Returns
+/// an error string if the keychain write fails so the UI can report it.
+///
+/// A write to a **locked** collection is refused rather than attempted, for the reason
+/// [`get`] gives: it would block on an unlock prompt, and a blocked write is a wedged
+/// connect and one more parked D-Bus client. Refusing says the true thing ("locked, so
+/// nothing was saved") instead of appearing to save and never returning. Writing only
+/// the kernel-keyring half would be worse than either — a credential that reads back
+/// fine until the next reboot silently loses it.
+pub fn set(account: &str, password: Option<&str>) -> Result<(), String> {
+    #[cfg(target_os = "linux")]
+    if cached_keyring_state() != KeyringState::Unlocked {
+        return Err("the OS keyring is locked, so nothing was saved — unlock it and try again".into());
+    }
+    let e = entry(account)?;
+    let wrote = match password.filter(|p| !p.is_empty()) {
+        Some(secret) => e.set_password(secret).map_err(|err| err.to_string()),
+        None => match e.delete_credential() {
+            Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),
+            Err(err) => Err(err.to_string()),
+        },
+    };
+    // A completed write is a first-hand observation that the collection was open —
+    // fresher than anything the cache holds, and the cheapest place to notice a lock
+    // that was lifted (or dropped) since the last probe.
+    forget_keyring_state();
+    wrote
+}
+
+/// Whether a non-empty password is stored for `account`. Used to tell the
+/// frontend "saved" (so it can pre-check the box) without handing back the secret.
+pub fn has(account: &str) -> bool {
+    get(account).is_some()
+}
+
+/// Whether the credential store can be read **right now**, as [`get`]'s own gate
+/// sees it (cached on Linux, always true elsewhere — see [`keyring_state`]).
+///
+/// This is the question every `has(..) == false` silently depends on, and the one
+/// no caller used to ask. A locked collection answers every lookup with "nothing
+/// saved", so anything that reads absence as a *fact* — "this host authenticates
+/// by key", "there is no password to delete" — draws a conclusion from a store it
+/// could not read. Callers that would act destructively, or write something down,
+/// ask this first and do nothing when it says no.
+pub fn store_readable() -> bool {
+    #[cfg(target_os = "linux")]
+    {
+        cached_keyring_state() == KeyringState::Unlocked
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        true
+    }
+}
+
+/// Whether the OS credential store can be read **right now** — the question every
+/// "is this credential saved?" answer silently depends on.
+///
+/// On Linux the Secret Service collection holding our entries can be *locked*, and a
+/// locked collection is indistinguishable from an empty one through the `keyring`
+/// crate: every read answers `None`. So a user who ticked "Save password", connected,
+/// and restarted finds the box blank and the silent connect gone — the credential is
+/// still there, it just cannot be read. Reporting the lock is what lets the UI say
+/// that, and offer [`unlock_keyring`], instead of quietly pretending nothing was saved.
+///
+/// Windows and macOS have no equivalent state (their stores unlock with the login
+/// session), so they always report [`KeyringState::Unlocked`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum KeyringState {
+    /// Readable: a `None` from [`get`] really does mean "nothing saved".
+    Unlocked,
+    /// Present but locked — saved credentials exist but read as absent until unlocked.
+    Locked,
+    /// No credential store at all (no Secret Service on the bus). Saving is impossible
+    /// here, so the UI should stop offering it rather than fail every write silently.
+    Unavailable,
+}
+
+/// The lock state of the collection our entries live in. Bounded like every other
+/// keychain read, and *never* prompts: the probe connects with a zero-second prompt
+/// timeout, so asking the question can never put a dialog on screen.
+///
+/// A timeout answers `Locked` rather than `Unavailable` on purpose — a hung Secret
+/// Service call is overwhelmingly a locked collection waiting on an unlock nobody
+/// answered, and `Locked` is the state with an action behind it.
+pub fn keyring_state() -> KeyringState {
+    let state = read_timed(keyring_state_uncapped, KeyringState::Locked);
+    remember_keyring_state(state);
+    state
+}
+
+/// How long [`cached_keyring_state`] trusts a reading. Short enough that unlocking the
+/// collection from *outside* Eldrun (Seahorse, another app's prompt) is picked up
+/// without a restart; long enough that a burst of connects costs one probe, not one per
+/// credential. The transition that actually matters — our own [`unlock_keyring`] — does
+/// not wait for it: it invalidates the cache outright.
+#[cfg(target_os = "linux")]
+const STATE_TTL: std::time::Duration = std::time::Duration::from_secs(10);
+
+#[cfg(target_os = "linux")]
+static STATE_CACHE: std::sync::Mutex<Option<(std::time::Instant, KeyringState)>> =
+    std::sync::Mutex::new(None);
+
+/// The lock state as [`get`]'s gate sees it: cached, so that asking "may I dispatch a
+/// Secret Service read?" before *every* read costs a D-Bus round trip only once per
+/// [`STATE_TTL`]. The probe behind it never prompts, so a miss is cheap and safe.
+#[cfg(target_os = "linux")]
+fn cached_keyring_state() -> KeyringState {
+    if let Ok(cache) = STATE_CACHE.lock() {
+        if let Some((at, state)) = *cache {
+            if at.elapsed() < STATE_TTL {
+                return state;
+            }
+        }
+    }
+    keyring_state()
+}
+
+/// Record a freshly-observed lock state. A no-op off Linux, where there is no lock to
+/// observe and [`get`] never consults the cache.
+/// `pub(crate)` only so a test elsewhere can put the gate into a known state
+/// without a live probe (see `commands::remote`'s locked-keychain test) — nothing
+/// in production code outside this module should be *asserting* a lock state.
+pub(crate) fn remember_keyring_state(_state: KeyringState) {
+    #[cfg(target_os = "linux")]
+    {
+        if let Ok(mut cache) = STATE_CACHE.lock() {
+            *cache = Some((std::time::Instant::now(), _state));
+        }
+    }
+}
+
+/// Drop the cached lock state, so the next [`get`] re-asks. Called wherever the state
+/// is known to have just changed under us — an unlock we raised, a write that proved
+/// the collection was writable.
+pub fn forget_keyring_state() {
+    #[cfg(target_os = "linux")]
+    {
+        if let Ok(mut cache) = STATE_CACHE.lock() {
+            *cache = None;
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn keyring_state_uncapped() -> KeyringState {
+    use dbus_secret_service::{EncryptionType, SecretService};
+    // 0 = never raise a prompt; this is a probe, and a probe that can pop a system
+    // dialog is not a probe. `Plain` because no secret crosses this session — we ask
+    // for a boolean, so there is nothing to encrypt.
+    let Ok(service) = SecretService::connect_with_max_prompt_timeout(EncryptionType::Plain, 0)
+    else {
+        return KeyringState::Unavailable;
+    };
+    let Ok(collection) = service.get_default_collection() else {
+        return KeyringState::Unavailable;
+    };
+    match collection.is_locked() {
+        Ok(true) => KeyringState::Locked,
+        Ok(false) => KeyringState::Unlocked,
+        Err(_) => KeyringState::Unavailable,
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+fn keyring_state_uncapped() -> KeyringState {
+    KeyringState::Unlocked
+}
+
+/// Ask the OS to unlock the credential store, raising *its own* unlock dialog.
+///
+/// Deliberately blocking and unbounded-ish (a generous prompt timeout): the user is
+/// typing a password into a system dialog, and abandoning that after four seconds
+/// would be worse than not asking. Call it only from an explicit user action — never
+/// from a launch path that promises not to prompt.
+///
+/// Returns `Ok(())` once the collection is unlocked (including when it already was);
+/// an `Err` if the dialog was dismissed, timed out, or there is no store to unlock.
+pub fn unlock_keyring() -> Result<(), String> {
+    let out = unlock_keyring_impl();
+    // Whichever way the dialog went, the cached reading is now the stale one — and this
+    // is precisely the transition [`get`]'s gate must see immediately, since the click
+    // exists to make the next connect find its saved credential.
+    forget_keyring_state();
+    out
+}
+
+#[cfg(target_os = "linux")]
+fn unlock_keyring_impl() -> Result<(), String> {
+    use dbus_secret_service::{EncryptionType, SecretService};
+    // Two minutes: long enough to find and answer the dialog, short enough that a
+    // prompt nobody ever sees does not park this thread for the session.
+    let service = SecretService::connect_with_max_prompt_timeout(EncryptionType::Plain, 120)
+        .map_err(|e| format!("no OS credential store available: {e}"))?;
+    let collection = service
+        .get_default_collection()
+        .map_err(|e| format!("no default keyring collection: {e}"))?;
+    match collection.is_locked() {
+        Ok(false) => return Ok(()),
+        Ok(true) => {}
+        Err(e) => return Err(format!("could not read the keyring's lock state: {e}")),
+    }
+    collection
+        .unlock()
+        .map_err(|e| format!("keyring unlock failed or was dismissed: {e}"))?;
+    // `unlock` returns as soon as the prompt is dismissed, whichever way — so confirm
+    // rather than report success on a cancelled dialog.
+    match collection.is_locked() {
+        Ok(false) => Ok(()),
+        _ => Err("the keyring is still locked".to_string()),
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+fn unlock_keyring_impl() -> Result<(), String> {
+    Ok(())
+}
+
+/// What a successful connect should do to the stored credential, decided by the
+/// caller's `remember` argument.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Remember {
+    /// The user ticked "Save password" — persist the working secret.
+    Save,
+    /// The user *unticked* it — drop any previously-saved secret.
+    Clear,
+    /// The caller has no checkbox behind it — do not touch the keychain.
+    Leave,
+}
+
+/// Map a connect command's `remember` argument to a keychain action.
+///
+/// The case that matters is `None → Leave`. Not every connect comes from a form:
+/// a reachability probe, a ControlMaster readiness poll, and a silent auto-connect
+/// all authenticate *using* the saved credential while having no opinion about
+/// storing it. Folding `None` into "unticked" (the old `unwrap_or(false)`) made
+/// each of them delete the very password it had just used — the credential worked
+/// exactly once, then the next connect prompted again.
+pub fn remember_action(remember: Option<bool>) -> Remember {
+    match remember {
+        Some(true) => Remember::Save,
+        Some(false) => Remember::Clear,
+        None => Remember::Leave,
+    }
+}
+
+/// What the post-auth keychain write actually did, so the connect that triggered
+/// it can say so instead of swallowing it.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub struct RememberOutcome {
+    /// A secret is stored for this account as a result of this call — either the
+    /// save landed, or a clear was **declined** because the store could not be
+    /// read (so whatever was there is still there).
+    pub saved: bool,
+    /// Why the keychain did not do what the checkbox asked. Never a reason to
+    /// fail the connect: authentication already succeeded.
+    pub error: Option<String>,
+}
+
+/// Apply the post-auth keychain write for `account`: save `secret`, clear the
+/// entry, or leave it alone, per [`remember_action`]. Call only *after*
+/// authentication succeeded, so a rejected credential is never stored.
+///
+/// Two things this deliberately does **not** do any more. It does not discard
+/// [`set`]'s result: a write refused by a locked keyring produced a connect that
+/// looked as if it had saved the password, and a next launch with a blank prompt
+/// as the only evidence. And it does not clear an entry it could not first read:
+/// an unreadable store is not licence to delete — [`get`]/[`has`] answer "nothing
+/// saved" while locked, so an untick evaluated against that answer would destroy a
+/// password the user still wants (and, keyed by host, possibly another project's).
+/// The destructive branch is the one branch that needs the store to be *known*
+/// open, so it asks [`store_readable`] first.
+pub fn remember_secret(
+    account: &str,
+    remember: Option<bool>,
+    secret: Option<&str>,
+) -> RememberOutcome {
+    match remember_action(remember) {
+        Remember::Save => match set(account, secret) {
+            Ok(()) => RememberOutcome {
+                saved: secret.is_some_and(|s| !s.is_empty()),
+                error: None,
+            },
+            Err(e) => RememberOutcome {
+                saved: false,
+                error: Some(e),
+            },
+        },
+        Remember::Clear => {
+            if !store_readable() {
+                return RememberOutcome {
+                    saved: true,
+                    error: Some(
+                        "the OS keyring is locked, so the saved password was left alone — \
+                         unlock it and untick again to remove it"
+                            .to_string(),
+                    ),
+                };
+            }
+            match set(account, None) {
+                Ok(()) => RememberOutcome {
+                    saved: false,
+                    error: None,
+                },
+                Err(e) => RememberOutcome {
+                    saved: true,
+                    error: Some(e),
+                },
+            }
+        }
+        // No checkbox behind this call, so nothing was asked and nothing done —
+        // `saved` reports this call's doing, not the state of the keychain.
+        Remember::Leave => RememberOutcome {
+            saved: false,
+            error: None,
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The whole point of the tri-state: "no checkbox behind this call" must not be
+    /// read as "the user unticked the box". A probe or a silent reconnect that
+    /// cleared the keychain would delete the password it had just used.
+    #[test]
+    fn remember_none_leaves_the_keychain_alone() {
+        assert_eq!(remember_action(None), Remember::Leave);
+        assert_eq!(remember_action(Some(true)), Remember::Save);
+        assert_eq!(remember_action(Some(false)), Remember::Clear);
+    }
+
+    #[test]
+    fn ssh_account_normalizes_default_port() {
+        // None and Some(22) must map to the same entry as the live target.
+        assert_eq!(
+            ssh_account(&Some("alice".into()), "host.example", None),
+            "ssh:alice@host.example:22"
+        );
+        assert_eq!(
+            ssh_account(&Some("alice".into()), "host.example", Some(22)),
+            "ssh:alice@host.example:22"
+        );
+    }
+
+    #[test]
+    fn ssh_account_omitted_user_is_empty() {
+        assert_eq!(ssh_account(&None, "host.example", Some(2222)), "ssh:@host.example:2222");
+        // A blank/whitespace user normalizes to the same empty-user key.
+        assert_eq!(ssh_account(&Some("  ".into()), "host.example", Some(2222)), "ssh:@host.example:2222");
+    }
+
+    /// One machine, one entry. DNS is case-insensitive, so the same host typed
+    /// `MLAI21…` in one dialog and `mlai21…` in another used to mint two keychain
+    /// accounts — and the spelling the user did not save under read back as "no
+    /// password saved", i.e. a prompt where a silent reconnect was promised.
+    #[test]
+    fn ssh_account_folds_host_case_and_trims() {
+        assert_eq!(
+            ssh_account(&Some("alice".into()), " Login.Example ", None),
+            ssh_account(&Some("alice".into()), "login.example", Some(22)),
+        );
+        // The login name is deliberately NOT folded: a different login is a
+        // different account on that host, with its own password.
+        assert_ne!(
+            ssh_account(&Some("Alice".into()), "login.example", None),
+            ssh_account(&Some("alice".into()), "login.example", None),
+        );
+    }
+
+    /// An unreadable store is not licence to delete. While the collection is
+    /// locked every lookup answers "nothing saved", so an untick evaluated against
+    /// that answer destroys a password the user still wants — and the entry is
+    /// keyed by host, so possibly another project's. Proven by the outcome alone:
+    /// reaching `set` would mean the guard let the delete through.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn a_locked_keyring_never_clears_a_saved_password() {
+        remember_keyring_state(KeyringState::Locked);
+        let out = remember_secret("test:clear-guard", Some(false), None);
+        assert!(out.saved, "the entry must be reported as still present");
+        assert!(out.error.unwrap_or_default().contains("locked"));
+    }
+
+    /// The other half: a save the keychain refused must reach the caller as a
+    /// reason, not vanish. Swallowing it produced a connect that looked as though
+    /// it had saved the password, with the next launch's blank prompt as the only
+    /// evidence it had not.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn a_refused_save_is_reported_rather_than_swallowed() {
+        remember_keyring_state(KeyringState::Locked);
+        let out = remember_secret("test:save-report", Some(true), Some("secret"));
+        assert!(!out.saved);
+        assert!(out.error.is_some(), "the reason must reach the caller");
+    }
+
+    /// `Leave` touches nothing, so it reports nothing — `saved` is what *this
+    /// call* did, not a reading of the keychain (which it deliberately never takes).
+    #[test]
+    fn nothing_asked_means_nothing_done() {
+        assert_eq!(
+            remember_secret("test:leave", None, Some("secret")),
+            RememberOutcome {
+                saved: false,
+                error: None
+            }
+        );
+    }
+
+    #[test]
+    fn ssh_account_distinct_ports_are_distinct_keys() {
+        assert_ne!(
+            ssh_account(&Some("a".into()), "h", Some(22)),
+            ssh_account(&Some("a".into()), "h", Some(2222))
+        );
+    }
+
+    #[test]
+    fn openvpn_account_keys_by_config_path() {
+        assert_eq!(openvpn_account("/store/x.ovpn"), "openvpn:/store/x.ovpn");
+    }
+
+    #[test]
+    fn openvpn_user_account_is_distinct_from_both_secret_accounts() {
+        // The username shares the config key but must never share an *entry* with a
+        // secret: writing it into either would overwrite the password/passphrase.
+        let c = "/store/x.ovpn";
+        assert_eq!(openvpn_user_account(c), "openvpn-user:/store/x.ovpn");
+        assert_ne!(openvpn_user_account(c), openvpn_account(c));
+        assert_ne!(openvpn_user_account(c), openvpn_key_account(c));
+    }
+
+    /// The gate's cheap half: a reading taken once is reused, so asking "may I dispatch
+    /// a Secret Service read?" before every credential read costs one probe, not one per
+    /// account. Deterministic — it asserts only what was just remembered, never a live
+    /// probe's answer.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn a_remembered_lock_state_is_served_from_the_cache() {
+        remember_keyring_state(KeyringState::Locked);
+        assert_eq!(cached_keyring_state(), KeyringState::Locked);
+        // Deliberately not cleared: another test clearing it mid-run would send the next
+        // one to a *live* probe, which on an unlocked dev machine would let a test write
+        // reach the real keychain. The reading expires on its own.
+    }
+
+    /// A locked collection must make the write fail *fast*, not wait on an unlock prompt
+    /// nobody may answer. Proven by the error alone: reaching the keychain at all would
+    /// mean the gate let the call through.
+    #[cfg(target_os = "linux")]
+    #[test]
+    fn a_locked_keyring_refuses_the_write_instead_of_blocking_on_it() {
+        remember_keyring_state(KeyringState::Locked);
+        let err = set("test:locked-gate", Some("secret")).unwrap_err();
+        assert!(err.contains("locked"), "unexpected error: {err}");
+    }
+
+    #[test]
+    fn openvpn_key_account_is_distinct_from_the_password_account() {
+        // Same config, two secrets — they must never share an entry, or saving one
+        // would overwrite the other.
+        assert_eq!(
+            openvpn_key_account("/store/x.ovpn"),
+            "openvpn-key:/store/x.ovpn"
+        );
+        assert_ne!(
+            openvpn_key_account("/store/x.ovpn"),
+            openvpn_account("/store/x.ovpn")
+        );
+    }
+}
diff --git a/src-tauri/src/services/remote_sync.rs b/src-tauri/src/services/remote_sync.rs
new file mode 100644
index 0000000..b6c6393
--- /dev/null
+++ b/src-tauri/src/services/remote_sync.rs
@@ -0,0 +1,1276 @@
+//! Local mirror + selective bidirectional sync for remote (SSH) projects.
+//!
+//! SSH-sync Phase 1 (`docs/ssh_sync_plan.md`). Every remote project has a local
+//! paired **mirror** — by default a `<name>` subfolder of the top-level
+//! `eldrun/projects-ssh/` root
+//! (legacy/fallback: `<state_dir>/remote-projects/<id>/mirror/`), relocatable per
+//! project via `extra["mirror"]` (see [`mirror_dir`]) — that starts empty and is
+//! populated only by **explicit, user-chosen** sync. This module is
+//! the `AppHandle`-free core: the manifest type + its on-disk IO, the lstat-typed
+//! recursive host walker (G3 — never follows host symlinks), the per-file pull
+//! primitive, and the pure 3-way (base/host/local) state compare. The Tauri
+//! commands that orchestrate these (`commands::sync`) own the SFTP session and the
+//! progress events.
+//!
+//! ## Source of truth
+//! - The **manifest** (`<state_dir>/remote-projects/<id>/sync.json`) records, per
+//!   project-relative path, the host base (size+mtime) captured at the last pull
+//!   and the local base after writing it. All divergence is judged base-vs-host
+//!   and base-vs-local (never host-mtime directly vs local-mtime — clock skew).
+//! - The manifest is a single-writer structure: a Tauri-managed
+//!   [`SyncManifestState`] serializes every mutation (G7), and SFTP transfers run
+//!   with the lock released.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+use crate::services::sftp::{self, SyncKind};
+
+/// Largest single file the sync will transfer (64 MiB). `read_file_on` buffers a
+/// whole file in RAM and holds the SFTP channel (G8), so a giant artifact is
+/// skipped with an error rather than stalling the connection / OOMing.
+pub const MAX_SYNC_FILE_BYTES: u64 = 64 * 1024 * 1024;
+
+/// One manifest record for a project-relative path. The host/local size+mtime are
+/// the **bases** captured at the last successful pull/push — the reference the
+/// green/amber UI state and the (Phase 2) stale-base conflict check compare a
+/// fresh re-stat against.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SyncEntry {
+    /// Whether the user has marked this path to track. Selecting a path is the
+    /// consent to mirror it; deselecting stops tracking (the mirror bytes stay).
+    pub selected: bool,
+    /// `true` when this path is a directory (selection marker, no bytes mirrored
+    /// for the dir itself).
+    #[serde(default)]
+    pub is_dir: bool,
+    /// Host size (bytes) at the last pull. `0` for a dir / absent.
+    #[serde(default)]
+    pub host_size: u64,
+    /// Host mtime (unix secs) at the last pull, when reported.
+    #[serde(default)]
+    pub host_mtime: Option<u64>,
+    /// Local mirror size (bytes) after the last pull/push.
+    #[serde(default)]
+    pub local_size: u64,
+    /// Local mirror mtime (unix secs) after the last pull/push.
+    #[serde(default)]
+    pub local_mtime: Option<u64>,
+    /// When this path was last pulled host→local (unix secs).
+    #[serde(default)]
+    pub last_pull_ts: Option<u64>,
+    /// When this path was last pushed local→host (unix secs; Phase 2).
+    #[serde(default)]
+    pub last_push_ts: Option<u64>,
+    /// Whether this path auto-syncs (bidirectional, safe-direction-only — the
+    /// background reconcile engine keeps it in sync without a click). Implies
+    /// `selected`. On a **directory** marker it applies to the whole subtree; the
+    /// per-file entries the engine creates on transfer are NOT stamped (auto-ness
+    /// is derived from the nearest marker by `is_auto`), so a file synced under a
+    /// manually-selected folder stays non-auto. The project root (`""`) carries
+    /// this flag as the project-wide "auto-sync all" toggle.
+    #[serde(default)]
+    pub auto_sync: bool,
+    /// Explicit auto-sync EXCLUSION. Set when the user turns auto **off** for a
+    /// path that would otherwise inherit it from an ancestor marker (a folder or
+    /// the project-wide root). It overrides an ancestor's `auto_sync` for this
+    /// path and its subtree — the "local toggles win" override — so a project-wide
+    /// auto-sync can carve out individual files/folders. Nearest marker wins
+    /// (`is_auto`); a plain off with no ancestor auto is a harmless no-op marker.
+    #[serde(default)]
+    pub auto_off: bool,
+    /// **Excluded from byte-sync entirely** — a stronger statement than `auto_off`,
+    /// which only carves a path out of the *background* engine. A folder the user
+    /// answered "don't sync this" about (the giant-folder prompt raised when a
+    /// project is first paired with a host, `services::big_folders`) must also be
+    /// skipped by the one-click whole-project pull/push, or the very click the
+    /// prompt exists to make safe would haul it over anyway. Applies to the whole
+    /// subtree on a directory marker; an explicit auto-on *inside* it still wins
+    /// (nearest marker, as everywhere else here).
+    ///
+    /// Byte-sync only: a **git-tracked** file in an excluded folder still travels
+    /// via lockstep (commits, not bytes) — the two transports split the tree by
+    /// git, and this flag lives on the byte side of that line.
+    #[serde(default)]
+    pub excluded: bool,
+}
+
+/// A project's manifest: project-relative path → record.
+pub type Manifest = HashMap<String, SyncEntry>;
+
+/// The green/amber/none UI state for a path (see the plan's "UI state").
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SyncState {
+    /// In the mirror and the manifest base still matches the host.
+    Green,
+    /// Host moved since the last fetch (detected on an explicit re-stat).
+    Amber,
+    /// Not synced (no mirror copy / not selected).
+    None,
+}
+
+/// Tauri-managed, single-writer cache of per-project manifests (G7). Every mutate
+/// path locks this, so a push-on-save / a "sync now" / two tabs saving can never
+/// clobber `sync.json`. `tokio::sync::Mutex` because the commands are async.
+pub type SyncManifestState = Arc<Mutex<HashMap<String, Manifest>>>;
+
+/// Build a fresh, empty manifest cache for `tauri::Builder::manage`.
+pub fn new_manifest_state() -> SyncManifestState {
+    Arc::new(Mutex::new(HashMap::new()))
+}
+
+// ── Paths ───────────────────────────────────────────────────────────────────
+
+/// The local per-project state dir for a remote project (mirrors
+/// `commands::projects::remote_project_state_dir`, kept here to stay
+/// command-layer-free).
+fn state_dir(project_id: &str) -> PathBuf {
+    crate::storage::state_dir()
+        .join("remote-projects")
+        .join(project_id)
+}
+
+/// The DEFAULT local mirror root for a remote project when it carries no explicit
+/// override: `<state_dir>/.../<id>/mirror`. This remains the fallback so remote
+/// projects created before configurable mirrors keep their existing location.
+fn default_mirror_dir(project_id: &str) -> PathBuf {
+    state_dir(project_id).join("mirror")
+}
+
+/// A remote project's explicitly-chosen mirror root, read from the always-local
+/// `projects.json` entry's flattened `extra["mirror"]` (written at import — where
+/// it defaults to a `<name>` subfolder of the top-level `eldrun/projects-ssh/` root — and rewritten
+/// when the user relocates a deleted mirror). `None` when unset. Read from the
+/// global list rather than the per-project `project.json` for the same reason as
+/// `remote::remote_target_for`: the global list is always on the local disk.
+fn mirror_override(project_id: &str) -> Option<PathBuf> {
+    let list_path = crate::storage::state_dir().join("projects.json");
+    let list: crate::schema::projects::ProjectsList = crate::storage::read_json(&list_path).ok()?;
+    let entry = list.iter().find(|e| e.id == project_id)?;
+    let raw = entry.extra.get("mirror")?.as_str()?.trim();
+    (!raw.is_empty()).then(|| PathBuf::from(raw))
+}
+
+/// The local mirror root for a remote project. An explicit per-project override
+/// (`extra["mirror"]`) wins; otherwise the default under the state dir. Every
+/// path-prefix routing helper below (`is_under_mirror`, `mirror_local_path`)
+/// resolves through here, so relocating the mirror moves all of them together.
+pub fn mirror_dir(project_id: &str) -> PathBuf {
+    mirror_override(project_id).unwrap_or_else(|| default_mirror_dir(project_id))
+}
+
+/// The manifest file path: `<state_dir>/.../<id>/sync.json`.
+pub fn manifest_path(project_id: &str) -> PathBuf {
+    state_dir(project_id).join("sync.json")
+}
+
+/// Whether `abs_path` lies inside the project's local mirror. Used by the file
+/// readers (G2 path-prefix routing): a path under the mirror is read/written on
+/// the LOCAL fs even though the project is remote, so the local source view and
+/// local-on-remote tabs see mirrored bytes instead of round-tripping SFTP.
+pub fn is_under_mirror(project_id: &str, abs_path: &str) -> bool {
+    let mirror = mirror_dir(project_id);
+    // Compare on canonicalized prefixes where possible so a symlinked state dir
+    // still matches; fall back to the literal path when it doesn't exist yet.
+    let candidate = Path::new(abs_path);
+    let mirror_norm = mirror.canonicalize().unwrap_or(mirror);
+    let cand_norm = candidate.canonicalize().unwrap_or_else(|_| candidate.to_path_buf());
+    cand_norm.starts_with(&mirror_norm)
+}
+
+/// Map a project-relative path to its absolute path inside the local mirror.
+pub fn mirror_local_path(project_id: &str, rel: &str) -> PathBuf {
+    let clean = rel.trim_start_matches('/');
+    mirror_dir(project_id).join(clean)
+}
+
+// ── Manifest IO ───────────────────────────────────────────────────────────
+
+/// Load a project's manifest from disk, or an empty one if absent/unparseable.
+pub fn load_manifest(project_id: &str) -> Manifest {
+    let path = manifest_path(project_id);
+    if !path.exists() {
+        return Manifest::new();
+    }
+    crate::storage::read_json(&path).unwrap_or_default()
+}
+
+/// Persist a project's manifest to disk (creates the state dir if needed).
+pub fn save_manifest(project_id: &str, manifest: &Manifest) -> Result<(), String> {
+    let path = manifest_path(project_id);
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+    crate::storage::write_json(&path, manifest).map_err(|e| e.to_string())
+}
+
+// ── Pure helpers ──────────────────────────────────────────────────────────
+
+/// Current wall-clock time as whole seconds since the Unix epoch.
+fn now_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0)
+}
+
+/// The green/amber state for a SELECTED file, judged SYMMETRICALLY against both
+/// bases: amber when the host moved from its recorded base (`host` re-stat differs
+/// from `entry.host_*`) OR the local mirror moved from its recorded base (`local`
+/// re-stat differs from `entry.local_*`); green only when neither side diverged.
+/// `host` is `None` when the host wasn't stat'd (cold pool) — then only the local
+/// side is judged (no network needed). `local` is `None` when the mirror file is
+/// gone; a missing mirror we had previously synced counts as diverged (deleted
+/// locally). `excluded` is the path's EFFECTIVE (own-or-inherited, see
+/// `is_excluded`) byte-sync exclusion: a path excluded from sync is also
+/// excluded from the diverged view — flagging amber on a file sync will never
+/// touch again is a dead end, not a warning. Pure, unit-tested.
+pub fn compute_state(
+    entry: &SyncEntry,
+    host: Option<(u64, Option<u64>)>,
+    local: Option<(u64, Option<u64>)>,
+    excluded: bool,
+) -> SyncState {
+    if !entry.selected || excluded {
+        return SyncState::None;
+    }
+    let (host_diverged, local_diverged) = divergence(entry, host, local);
+    if host_diverged || local_diverged {
+        SyncState::Amber
+    } else {
+        SyncState::Green
+    }
+}
+
+/// `(host_diverged, local_diverged)` vs the recorded bases — the same rule
+/// `compute_state` collapses into green/amber, but kept as two distinct booleans
+/// so the auto-sync engine can pick the SAFE direction (pull when only the host
+/// moved, push when only the local moved, skip when both = amber/conflict).
+/// `host` is `None` when the host wasn't stat'd (cold pool) → host side not
+/// flagged. `local` is `None` when the mirror file is gone; a missing mirror we
+/// had previously synced counts as diverged (deleted locally). Pure, unit-tested.
+pub fn divergence(
+    entry: &SyncEntry,
+    host: Option<(u64, Option<u64>)>,
+    local: Option<(u64, Option<u64>)>,
+) -> (bool, bool) {
+    let host_diverged = match host {
+        Some((size, mtime)) => entry.host_size != size || entry.host_mtime != mtime,
+        None => false, // couldn't check the host → don't flag host divergence
+    };
+    let local_diverged = match local {
+        Some((size, mtime)) => entry.local_size != size || entry.local_mtime != mtime,
+        // Mirror gone but we had synced it before → deleted locally = diverged.
+        None => entry.last_pull_ts.is_some() || entry.last_push_ts.is_some(),
+    };
+    (host_diverged, local_diverged)
+}
+
+/// Whether an amber verdict is worth confirming against the actual bytes rather
+/// than trusting the size+mtime heuristic. Size+mtime only *approximates*
+/// divergence: a re-save with identical bytes (or a bare `touch`) moves the mtime
+/// while the content is unchanged, so the file paints amber with nothing to
+/// resolve. We read to disprove that only when it could pay off: both sides exist
+/// (a present mtime), they are the SAME size (different sizes can't be identical —
+/// don't read), and they sit at or below `cutoff`. Large files keep the heuristic —
+/// reading them over SFTP on every status refresh is exactly its reason to exist.
+/// Pure, unit-tested; the byte read + compare itself lives in `commands::sync`.
+pub fn content_verify_worth_it(
+    host: (u64, Option<u64>),
+    local: (u64, Option<u64>),
+    cutoff: u64,
+) -> bool {
+    let (host_size, host_mtime) = host;
+    let (local_size, local_mtime) = local;
+    host_mtime.is_some()
+        && local_mtime.is_some()
+        && host_size == local_size
+        && host_size <= cutoff
+}
+
+/// Whether `rel` auto-syncs, by **nearest explicit marker wins**. A marker is an
+/// entry carrying `auto_sync` (on) or `auto_off` (excluded). We consult, closest
+/// first: the path's own entry, then each ancestor **directory** marker, ending at
+/// the project root (`""`) — whose marker is the project-wide "auto-sync all"
+/// toggle. The first explicit decision found wins, so a per-file/folder toggle
+/// overrides an ancestor (including project-wide) in either direction. A folder
+/// marker only applies to descendants when it is `is_dir`. Pure.
+pub fn is_auto(manifest: &Manifest, rel: &str) -> bool {
+    // The path's own entry decides for itself regardless of is_dir.
+    if let Some(e) = manifest.get(rel) {
+        if e.auto_off || e.excluded {
+            return false;
+        }
+        if e.auto_sync {
+            return true;
+        }
+    }
+    // Ancestor directory markers, nearest first, finally the root "" marker (which
+    // `rfind('/')` never reaches on its own).
+    let mut cur = rel;
+    loop {
+        cur = match cur.rfind('/') {
+            Some(idx) => &cur[..idx],
+            None if !cur.is_empty() => "", // consult the project root last
+            None => return false,          // consumed the root: no decision
+        };
+        if let Some(e) = manifest.get(cur) {
+            if e.is_dir {
+                if e.auto_off || e.excluded {
+                    return false;
+                }
+                if e.auto_sync {
+                    return true;
+                }
+            }
+        }
+    }
+}
+
+/// Whether `rel` is **excluded from byte-sync**, by the same nearest-marker walk
+/// as [`is_auto`]: the path's own entry, then each ancestor directory marker up
+/// to the project root. An explicit `auto_sync` marker nearer than the exclusion
+/// re-includes the path, so a user can keep one folder inside an excluded tree.
+///
+/// `under` is the path the caller was *asked* to transfer, and its own marker is
+/// deliberately ignored: right-clicking an excluded folder and syncing it is an
+/// explicit override of the very answer stored there, whereas a whole-project
+/// pull is not. Pass `""` for a project-root pull to honour every exclusion.
+pub fn is_excluded(manifest: &Manifest, rel: &str, under: &str) -> bool {
+    let mut cur = rel;
+    loop {
+        if cur != under {
+            if let Some(e) = manifest.get(cur) {
+                // A directory marker rules its subtree; a file's own entry rules
+                // only itself (`cur == rel` on the first pass).
+                if e.is_dir || cur == rel {
+                    if e.excluded {
+                        return true;
+                    }
+                    if e.auto_sync {
+                        return false;
+                    }
+                }
+            }
+        }
+        cur = match cur.rfind('/') {
+            Some(idx) => &cur[..idx],
+            None if !cur.is_empty() => "",
+            None => return false,
+        };
+    }
+}
+
+/// Borrow (loading from disk on first touch) the project's manifest from the
+/// single-writer cache. Shared by the command layer and the auto-sync engine.
+pub fn ensure_loaded<'a>(
+    cache: &'a mut HashMap<String, Manifest>,
+    project_id: &str,
+) -> &'a mut Manifest {
+    cache
+        .entry(project_id.to_string())
+        .or_insert_with(|| load_manifest(project_id))
+}
+
+/// `(size, mtime)` from a local file's metadata (mtime as unix secs).
+pub fn local_meta(m: &std::fs::Metadata) -> (u64, Option<u64>) {
+    let mtime = m
+        .modified()
+        .ok()
+        .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
+        .map(|d| d.as_secs());
+    (m.len(), mtime)
+}
+
+/// `(size, mtime)` of a local file's metadata, defaulting to `(0, None)`.
+pub fn local_size_mtime(meta: Option<std::fs::Metadata>) -> (u64, Option<u64>) {
+    match meta {
+        Some(m) => local_meta(&m),
+        None => (0, None),
+    }
+}
+
+/// Join a remote project root with a project-relative path (mirrors
+/// `commands::fs::join_remote_dir`). Pure.
+pub fn join_remote(remote_root: &str, rel: &str) -> String {
+    let base = remote_root.trim_end_matches('/');
+    let rel = rel.trim_start_matches('/');
+    if rel.is_empty() {
+        if base.is_empty() { "/".to_string() } else { base.to_string() }
+    } else if base.is_empty() {
+        format!("/{rel}")
+    } else {
+        format!("{base}/{rel}")
+    }
+}
+
+/// Append a child segment to a project-relative path (`""`+`a` → `a`, `a`+`b` →
+/// `a/b`). Pure.
+fn join_rel(parent: &str, child: &str) -> String {
+    if parent.is_empty() {
+        child.to_string()
+    } else {
+        format!("{}/{}", parent.trim_end_matches('/'), child)
+    }
+}
+
+// ── Host walk + pull (async; SFTP) ─────────────────────────────────────────
+
+/// One regular file discovered by the host walk: its project-relative path and
+/// the host base (size + mtime) captured at walk time.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HostFile {
+    pub rel: String,
+    pub size: u64,
+    pub mtime: Option<u64>,
+}
+
+/// Recursively collect the regular FILES under `rel` on the host, lstat-typed so
+/// symlinks and special files are SKIPPED, never followed (G3). `remote_root` is
+/// the project's `remote_path`; `rel` is project-relative (`""` walks the root).
+/// Directories recurse; symlinks/sockets/etc. are ignored. Bounded by the host
+/// tree; a hostile `link -> /etc` is skipped rather than mirrored.
+pub async fn walk_host_files(
+    sftp: &openssh_sftp_client::Sftp,
+    remote_root: &str,
+    rel: &str,
+) -> Result<Vec<HostFile>, String> {
+    let mut out = Vec::new();
+    walk_inner(sftp, remote_root, rel, &mut out).await?;
+    Ok(out)
+}
+
+async fn walk_inner(
+    sftp: &openssh_sftp_client::Sftp,
+    remote_root: &str,
+    rel: &str,
+    out: &mut Vec<HostFile>,
+) -> Result<(), String> {
+    let abs = join_remote(remote_root, rel);
+    let entries = sftp::list_dir_raw_on(sftp, &abs).await?;
+    for entry in entries {
+        // Skip Eldrun's internal runtime dir, mirroring the local/remote listers.
+        // `.git` is likewise never byte-mirrored: git state is kept in step
+        // *semantically* by `services::git_peer` (lockstep), so copying its bytes
+        // would fight that layer and risk corrupting a repo mid-write.
+        if entry.name == ".eldrun" || entry.name == ".git" {
+            continue;
+        }
+        let child_rel = join_rel(rel, &entry.name);
+        match entry.kind {
+            SyncKind::Dir => {
+                Box::pin(walk_inner(sftp, remote_root, &child_rel, out)).await?;
+            }
+            SyncKind::File => out.push(HostFile {
+                rel: child_rel,
+                size: entry.size,
+                mtime: entry.modified_secs,
+            }),
+            // G3: symlinks and special files are never mirrored.
+            SyncKind::Symlink | SyncKind::Other => {}
+        }
+    }
+    Ok(())
+}
+
+/// Pull one host file into the mirror: read it over SFTP (size-guarded, G8) and
+/// write it locally, creating parent dirs. Returns the local (size, mtime) base
+/// captured after the write. The host `abs` path must already be confined by the
+/// caller; `local` is the mirror destination.
+pub async fn pull_file(
+    sftp: &openssh_sftp_client::Sftp,
+    host_abs: &str,
+    host_size: u64,
+    local: &Path,
+) -> Result<(u64, Option<u64>), String> {
+    if host_size > MAX_SYNC_FILE_BYTES {
+        return Err(format!(
+            "'{host_abs}' is too large to sync ({host_size} bytes; limit {MAX_SYNC_FILE_BYTES})"
+        ));
+    }
+    let bytes = sftp::read_file_on(sftp, host_abs).await?;
+    if bytes.len() as u64 > MAX_SYNC_FILE_BYTES {
+        return Err(format!(
+            "'{host_abs}' is too large to sync ({} bytes; limit {MAX_SYNC_FILE_BYTES})",
+            bytes.len()
+        ));
+    }
+    if let Some(parent) = local.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+    std::fs::write(local, &bytes).map_err(|e| e.to_string())?;
+    let meta = std::fs::metadata(local).map_err(|e| e.to_string())?;
+    let local_size = meta.len();
+    let local_mtime = meta
+        .modified()
+        .ok()
+        .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
+        .map(|d| d.as_secs());
+    Ok((local_size, local_mtime))
+}
+
+/// Re-stat a host path over SFTP, returning `(size, mtime)` or `(0, None)` when
+/// the path is gone/unreadable — the input to [`compute_state`] for the amber
+/// refresh.
+pub async fn stat_or_zero(
+    sftp: &openssh_sftp_client::Sftp,
+    host_abs: &str,
+) -> (u64, Option<u64>) {
+    sftp::metadata_on(sftp, host_abs).await.unwrap_or((0, None))
+}
+
+/// Record a freshly-pulled file in the manifest: mark it selected and stamp the
+/// host + local bases and the pull timestamp. Mutates `manifest` in place; the
+/// caller persists under the single-writer lock.
+pub fn record_pull(
+    manifest: &mut Manifest,
+    rel: &str,
+    host_size: u64,
+    host_mtime: Option<u64>,
+    local_size: u64,
+    local_mtime: Option<u64>,
+) {
+    let entry = manifest.entry(rel.to_string()).or_default();
+    entry.selected = true;
+    entry.is_dir = false;
+    entry.host_size = host_size;
+    entry.host_mtime = host_mtime;
+    entry.local_size = local_size;
+    entry.local_mtime = local_mtime;
+    entry.last_pull_ts = Some(now_secs());
+}
+
+// ── rsync fast-path (Phase 3) ──────────────────────────────────────────────
+//
+// rsync gives delta transfer + a single connection for BULK (folder / whole-
+// project) PULLS, riding the existing ControlMaster so it never re-authenticates.
+// It is a pure-optimisation fast-path over the SFTP-native walker, which remains
+// the floor (used whenever rsync is missing on either end, and on any rsync
+// failure). Only PULLS use rsync: a push must honour the per-file block-on-stale
+// guard (product decision 5 — never clobber), which a bulk rsync would bypass, so
+// pushes stay on the guarded SFTP path.
+
+/// SSH keepalive options threaded into rsync's `-e` ssh transport (matches the
+/// pooled-session keepalive so a dropped link fails fast rather than hanging).
+const RSYNC_SSH_KEEPALIVE: &[&str] = &[
+    "-o", "ServerAliveInterval=15",
+    "-o", "ServerAliveCountMax=3",
+    "-o", "BatchMode=yes",
+];
+
+/// Whether the bulk rsync fast-path applies: rsync present on BOTH ends and the
+/// transfer is a directory (single files just use SFTP). Pure, unit-tested.
+pub fn should_use_rsync(rsync_local: bool, rsync_host: bool, is_dir: bool) -> bool {
+    rsync_local && rsync_host && is_dir
+}
+
+/// Build the `ssh …` string for rsync's `-e` so the transfer rides the shared
+/// `cm-%C` ControlMaster (no second auth) with `ControlMaster=no` (use, don't
+/// create). Includes the port and keepalive. Pure (the control dir is a stable
+/// per-user path), unit-tested for the ControlPath wiring.
+pub fn rsync_ssh_transport(port: Option<u16>) -> String {
+    let control_path = crate::services::ssh_exec::control_dir().join("cm-%C");
+    let mut parts: Vec<String> = vec![
+        "ssh".to_string(),
+        "-o".to_string(),
+        "ControlMaster=no".to_string(),
+        "-o".to_string(),
+        format!("ControlPath={}", control_path.to_string_lossy()),
+    ];
+    for a in RSYNC_SSH_KEEPALIVE {
+        parts.push((*a).to_string());
+    }
+    if let Some(p) = port {
+        parts.push("-p".to_string());
+        parts.push(p.to_string());
+    }
+    parts.join(" ")
+}
+
+/// Build the full rsync argv for a host→local PULL: archive mode (`-a`), checksum
+/// basis (`-c`, the correctness/conflict basis where available), the
+/// ControlMaster-riding `-e` transport, then `[user@]host:host_src` → `local_dest`.
+/// The caller adds trailing slashes to copy a directory's CONTENTS. Pure,
+/// unit-tested (it never touches the network).
+pub fn rsync_pull_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    host_src: &str,
+    local_dest: &str,
+) -> Vec<String> {
+    let target = match user {
+        Some(u) => format!("{u}@{host}:{host_src}"),
+        None => format!("{host}:{host_src}"),
+    };
+    vec![
+        "-a".to_string(),
+        "-c".to_string(),
+        "-e".to_string(),
+        rsync_ssh_transport(port),
+        target,
+        local_dest.to_string(),
+    ]
+}
+
+/// Whether `rsync` is on the LOCAL `PATH`.
+pub fn rsync_available_local() -> bool {
+    which_on_path("rsync")
+}
+
+/// Whether `rsync` is present on the HOST (`command -v rsync` over SSH, riding the
+/// master). Best-effort: any ssh/probe failure → `false` (fall back to SFTP).
+/// Blocking; call from `spawn_blocking`.
+pub fn rsync_available_host(spec: &crate::schema::project::RemoteSpec) -> bool {
+    match crate::services::ssh_exec::run_remote_shell(
+        spec,
+        "command -v rsync >/dev/null 2>&1 && echo eldrun-rsync-yes",
+    ) {
+        Ok(out) => String::from_utf8_lossy(&out.stdout).contains("eldrun-rsync-yes"),
+        Err(_) => false,
+    }
+}
+
+/// Cross-platform `command -v` check for a binary on `PATH`.
+fn which_on_path(bin: &str) -> bool {
+    let probe = if cfg!(windows) { "where" } else { "which" };
+    crate::paths::command_no_window(probe)
+        .arg(bin)
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
+
+/// Run a bulk rsync host→local PULL of `host_src_dir` (absolute host dir) into
+/// `local_dest_dir`. Both get a trailing slash so the source's CONTENTS land in
+/// dest. Best-effort fast-path: returns `Err` on any failure so the caller falls
+/// back to the SFTP walker. Blocking shell-out, so call from `spawn_blocking`.
+pub fn rsync_pull_dir(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    host_src_dir: &str,
+    local_dest_dir: &std::path::Path,
+) -> Result<(), String> {
+    std::fs::create_dir_all(local_dest_dir).map_err(|e| e.to_string())?;
+    let src = format!("{}/", host_src_dir.trim_end_matches('/'));
+    let dest = format!("{}/", local_dest_dir.to_string_lossy().trim_end_matches(['/', '\\']));
+    let args = rsync_pull_args(user, host, port, &src, &dest);
+    let out = crate::paths::command_no_window("rsync")
+        .args(&args)
+        .output()
+        .map_err(|e| format!("failed to launch rsync: {e}"))?;
+    if out.status.success() {
+        Ok(())
+    } else {
+        Err(String::from_utf8_lossy(&out.stderr).trim().to_string())
+    }
+}
+
+// ── Push (local→remote), block-on-stale (Phase 2) ──────────────────────────
+
+/// The decision for pushing one local file to the host, judged by re-stat'ing the
+/// host and comparing to the manifest base (NEVER host-mtime vs local-mtime).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PushDecision {
+    /// The host still matches the base we recorded (or this path was created
+    /// locally and never existed on the host) — safe to write.
+    Safe,
+    /// The host moved since the last sync, or a never-synced host file already
+    /// exists — block and let the user resolve (keep local / take host / skip).
+    Stale,
+}
+
+/// Decide whether pushing `entry`'s local file is safe given a fresh host re-stat
+/// (`None` = the host path is gone). Conservative: anything that isn't provably
+/// unchanged-since-base is `Stale`, so a push never silently clobbers a host
+/// change. Pure, unit-tested.
+///
+/// (A content-hash tie-break to distinguish a real host edit from a bare `touch`
+/// — the plan's optional `sha256sum` refinement — would need a base hash captured
+/// at pull time; it is deferred. The conservative rule here never clobbers, it
+/// only over-reports the touch case as a conflict the user clears with "keep
+/// local".)
+pub fn push_decision(entry: &SyncEntry, host: Option<(u64, Option<u64>)>) -> PushDecision {
+    let ever_synced = entry.last_pull_ts.is_some() || entry.last_push_ts.is_some();
+    match host {
+        // Host gone: a change (deletion) if we'd synced it before; a plain create
+        // otherwise.
+        None => {
+            if ever_synced {
+                PushDecision::Stale
+            } else {
+                PushDecision::Safe
+            }
+        }
+        Some((size, mtime)) => {
+            if !ever_synced {
+                // Never synced, yet the host already has this path → don't clobber.
+                PushDecision::Stale
+            } else if size == entry.host_size && mtime == entry.host_mtime {
+                PushDecision::Safe
+            } else {
+                PushDecision::Stale
+            }
+        }
+    }
+}
+
+/// Push one local mirror file to the host atomically: write the bytes to a temp
+/// path beside the target, then `rename_on` over it (so a reader never sees a
+/// half-written file). The caller has already decided this is `Safe`. Returns the
+/// host (size, mtime) base captured after the write. Size-guarded (G8).
+pub async fn push_file_atomic(
+    sftp: &openssh_sftp_client::Sftp,
+    local: &Path,
+    host_abs: &str,
+) -> Result<(u64, Option<u64>), String> {
+    let meta = std::fs::metadata(local).map_err(|e| e.to_string())?;
+    if meta.len() > MAX_SYNC_FILE_BYTES {
+        return Err(format!(
+            "'{}' is too large to sync ({} bytes; limit {MAX_SYNC_FILE_BYTES})",
+            local.display(),
+            meta.len()
+        ));
+    }
+    let bytes = std::fs::read(local).map_err(|e| e.to_string())?;
+    // Temp path beside the target (same dir → same filesystem → atomic rename).
+    // The single-writer manifest lock serializes pushes per project, so a fixed
+    // suffix can't collide with a concurrent push of the same file.
+    let tmp = format!("{host_abs}.eldrun-sync-tmp");
+    sftp::write_file_on(sftp, &tmp, &bytes).await?;
+    sftp::rename_on(sftp, &tmp, host_abs).await?;
+    // Re-stat the host to capture the new base (mtime is the host's, post-write).
+    let (h_size, h_mtime) = sftp::metadata_on(sftp, host_abs).await.unwrap_or((bytes.len() as u64, None));
+    Ok((h_size, h_mtime))
+}
+
+/// Record a freshly-pushed file in the manifest: keep it selected and stamp the
+/// new host + local bases and the push timestamp.
+pub fn record_push(
+    manifest: &mut Manifest,
+    rel: &str,
+    host_size: u64,
+    host_mtime: Option<u64>,
+    local_size: u64,
+    local_mtime: Option<u64>,
+) {
+    let entry = manifest.entry(rel.to_string()).or_default();
+    entry.selected = true;
+    entry.is_dir = false;
+    entry.host_size = host_size;
+    entry.host_mtime = host_mtime;
+    entry.local_size = local_size;
+    entry.local_mtime = local_mtime;
+    entry.last_push_ts = Some(now_secs());
+}
+
+/// Recursively collect the project-relative paths of regular FILES in the local
+/// mirror under `rel` (lstat-typed; symlinks skipped, mirroring the host walker's
+/// G3 stance). `rel` "" walks the whole mirror. Returns paths relative to the
+/// mirror root with forward slashes.
+pub fn walk_mirror_files(project_id: &str, rel: &str) -> Result<Vec<String>, String> {
+    let root = mirror_dir(project_id);
+    let start = mirror_local_path(project_id, rel);
+    let mut out = Vec::new();
+    // A single file selected directly.
+    let lmeta = std::fs::symlink_metadata(&start);
+    match lmeta {
+        Ok(m) if m.file_type().is_file() => {
+            if let Some(r) = rel_under(&root, &start) {
+                out.push(r);
+            }
+            return Ok(out);
+        }
+        Ok(m) if m.file_type().is_dir() => {
+            walk_mirror_inner(&root, &start, &mut out)?;
+            Ok(out)
+        }
+        // Missing / symlink / special → nothing to push.
+        _ => Ok(out),
+    }
+}
+
+fn walk_mirror_inner(root: &Path, dir: &Path, out: &mut Vec<String>) -> Result<(), String> {
+    let entries = std::fs::read_dir(dir).map_err(|e| e.to_string())?;
+    for entry in entries.flatten() {
+        let path = entry.path();
+        let ft = match entry.file_type() {
+            Ok(t) => t,
+            Err(_) => continue,
+        };
+        if ft.is_symlink() {
+            continue; // G3: never follow symlinks out of the mirror
+        }
+        // `.git`/`.eldrun` are never byte-mirrored (git is kept in step semantically
+        // by `services::git_peer`; `.eldrun` is Eldrun's own runtime dir).
+        if entry.file_name() == *".git" || entry.file_name() == *".eldrun" {
+            continue;
+        }
+        if ft.is_dir() {
+            walk_mirror_inner(root, &path, out)?;
+        } else if ft.is_file() {
+            if let Some(r) = rel_under(root, &path) {
+                out.push(r);
+            }
+        }
+    }
+    Ok(())
+}
+
+/// The forward-slash path of `path` relative to `root`, or `None` if not inside.
+fn rel_under(root: &Path, path: &Path) -> Option<String> {
+    path.strip_prefix(root)
+        .ok()
+        .map(|p| p.to_string_lossy().replace('\\', "/"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn excluded_dir() -> SyncEntry {
+        SyncEntry { is_dir: true, excluded: true, auto_off: true, ..Default::default() }
+    }
+
+    #[test]
+    fn exclusion_covers_the_subtree_of_a_whole_project_transfer() {
+        let mut m = Manifest::new();
+        m.insert("".into(), SyncEntry { is_dir: true, auto_sync: true, ..Default::default() });
+        m.insert("data".into(), excluded_dir());
+        assert!(is_excluded(&m, "data/raw/big.bin", ""));
+        assert!(!is_excluded(&m, "src/main.rs", ""));
+        // …and the background engine agrees, so the two transports can't disagree.
+        assert!(!is_auto(&m, "data/raw/big.bin"));
+        assert!(is_auto(&m, "src/main.rs"));
+    }
+
+    #[test]
+    fn explicitly_transferring_the_excluded_folder_overrides_its_own_marker() {
+        let mut m = Manifest::new();
+        m.insert("data".into(), excluded_dir());
+        // Whole-project pull: skipped. Right-clicking `data` itself: honoured.
+        assert!(is_excluded(&m, "data/big.bin", ""));
+        assert!(!is_excluded(&m, "data/big.bin", "data"));
+        // A nested exclusion inside it is still honoured — only the requested
+        // path's own marker is waived.
+        m.insert("data/raw".into(), excluded_dir());
+        assert!(is_excluded(&m, "data/raw/big.bin", "data"));
+    }
+
+    #[test]
+    fn a_nearer_auto_marker_re_includes_a_folder_inside_an_excluded_tree() {
+        let mut m = Manifest::new();
+        m.insert("data".into(), excluded_dir());
+        m.insert(
+            "data/small".into(),
+            SyncEntry { is_dir: true, auto_sync: true, selected: true, ..Default::default() },
+        );
+        assert!(!is_excluded(&m, "data/small/notes.md", ""));
+        assert!(is_excluded(&m, "data/raw/big.bin", ""));
+    }
+
+    #[test]
+    fn push_decision_safe_when_host_matches_base() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            last_pull_ts: Some(1),
+            ..Default::default()
+        };
+        assert_eq!(push_decision(&e, Some((10, Some(100)))), PushDecision::Safe);
+    }
+
+    #[test]
+    fn push_decision_stale_when_host_moved() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            last_pull_ts: Some(1),
+            ..Default::default()
+        };
+        assert_eq!(push_decision(&e, Some((11, Some(100)))), PushDecision::Stale);
+        assert_eq!(push_decision(&e, Some((10, Some(200)))), PushDecision::Stale);
+    }
+
+    #[test]
+    fn push_decision_create_safe_when_never_synced_and_host_absent() {
+        let e = SyncEntry { selected: true, ..Default::default() };
+        assert_eq!(push_decision(&e, None), PushDecision::Safe);
+    }
+
+    #[test]
+    fn push_decision_stale_when_never_synced_but_host_exists() {
+        // A local file the user wants to push, but the host already has an
+        // unsynced file there — don't clobber blindly.
+        let e = SyncEntry { selected: true, ..Default::default() };
+        assert_eq!(push_decision(&e, Some((5, Some(3)))), PushDecision::Stale);
+    }
+
+    #[test]
+    fn push_decision_stale_when_host_deleted_after_sync() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            last_pull_ts: Some(1),
+            ..Default::default()
+        };
+        assert_eq!(push_decision(&e, None), PushDecision::Stale);
+    }
+
+    #[test]
+    fn should_use_rsync_requires_both_ends_and_a_dir() {
+        assert!(should_use_rsync(true, true, true));
+        assert!(!should_use_rsync(true, true, false)); // single file → SFTP
+        assert!(!should_use_rsync(false, true, true)); // missing locally
+        assert!(!should_use_rsync(true, false, true)); // missing on host
+    }
+
+    #[test]
+    fn rsync_transport_rides_controlmaster() {
+        let e = rsync_ssh_transport(None);
+        assert!(e.starts_with("ssh "));
+        assert!(e.contains("ControlMaster=no"));
+        assert!(e.contains("ControlPath="));
+        assert!(e.contains("cm-%C"));
+        // Port absent → no -p.
+        assert!(!e.contains(" -p "));
+    }
+
+    #[test]
+    fn rsync_transport_includes_port() {
+        let e = rsync_ssh_transport(Some(2222));
+        assert!(e.contains(" -p 2222"));
+    }
+
+    #[test]
+    fn rsync_pull_args_build_target_and_flags() {
+        let args = rsync_pull_args(
+            &Some("alice".to_string()),
+            "host.example",
+            None,
+            "/srv/p/",
+            "/local/mirror/",
+        );
+        assert_eq!(args[0], "-a");
+        assert_eq!(args[1], "-c");
+        assert_eq!(args[2], "-e");
+        assert!(args[3].contains("ControlPath="));
+        assert_eq!(args[4], "alice@host.example:/srv/p/");
+        assert_eq!(args[5], "/local/mirror/");
+    }
+
+    #[test]
+    fn rsync_pull_args_omit_user_when_absent() {
+        let args = rsync_pull_args(&None, "host.example", None, "/srv/p/", "/m/");
+        assert_eq!(args[4], "host.example:/srv/p/");
+    }
+
+    #[test]
+    fn join_remote_handles_root_and_rel() {
+        assert_eq!(join_remote("/srv/p", ""), "/srv/p");
+        assert_eq!(join_remote("/srv/p/", "a/b"), "/srv/p/a/b");
+        assert_eq!(join_remote("/srv/p", "/a"), "/srv/p/a");
+        assert_eq!(join_remote("", "a"), "/a");
+        assert_eq!(join_remote("", ""), "/");
+    }
+
+    #[test]
+    fn join_rel_appends_segments() {
+        assert_eq!(join_rel("", "a"), "a");
+        assert_eq!(join_rel("a", "b"), "a/b");
+        assert_eq!(join_rel("a/b/", "c"), "a/b/c");
+    }
+
+    #[test]
+    fn compute_state_green_when_base_matches() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            local_size: 10,
+            local_mtime: Some(50),
+            ..Default::default()
+        };
+        // Both host and local match their recorded bases → green.
+        assert_eq!(
+            compute_state(&e, Some((10, Some(100))), Some((10, Some(50))), false),
+            SyncState::Green,
+        );
+    }
+
+    #[test]
+    fn compute_state_amber_when_host_moved() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            local_size: 10,
+            local_mtime: Some(50),
+            ..Default::default()
+        };
+        // Host size changed (local unchanged).
+        assert_eq!(
+            compute_state(&e, Some((12, Some(100))), Some((10, Some(50))), false),
+            SyncState::Amber,
+        );
+        // Host mtime changed (local unchanged).
+        assert_eq!(
+            compute_state(&e, Some((10, Some(200))), Some((10, Some(50))), false),
+            SyncState::Amber,
+        );
+        // Same divergence, but the path is excluded from sync → None, not Amber.
+        assert_eq!(
+            compute_state(&e, Some((12, Some(100))), Some((10, Some(50))), true),
+            SyncState::None,
+        );
+    }
+
+    #[test]
+    fn compute_state_amber_when_local_moved() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            local_size: 10,
+            local_mtime: Some(50),
+            last_pull_ts: Some(1),
+            ..Default::default()
+        };
+        // Host still matches its base, but the local mirror mtime moved → amber.
+        assert_eq!(
+            compute_state(&e, Some((10, Some(100))), Some((10, Some(80))), false),
+            SyncState::Amber,
+        );
+        // Also amber offline (host not stat'd) when the local size moved.
+        assert_eq!(compute_state(&e, None, Some((12, Some(50))), false), SyncState::Amber);
+        // Mirror deleted after a prior sync → diverged.
+        assert_eq!(compute_state(&e, Some((10, Some(100))), None, false), SyncState::Amber);
+    }
+
+    #[test]
+    fn compute_state_none_when_unselected() {
+        let e = SyncEntry { selected: false, ..Default::default() };
+        assert_eq!(compute_state(&e, Some((0, None)), None, false), SyncState::None);
+    }
+
+    #[test]
+    fn record_pull_marks_selected_and_stamps_bases() {
+        let mut m = Manifest::new();
+        record_pull(&mut m, "src/main.rs", 42, Some(7), 42, Some(9));
+        let e = m.get("src/main.rs").unwrap();
+        assert!(e.selected);
+        assert_eq!(e.host_size, 42);
+        assert_eq!(e.host_mtime, Some(7));
+        assert_eq!(e.local_size, 42);
+        assert_eq!(e.local_mtime, Some(9));
+        assert!(e.last_pull_ts.is_some());
+    }
+
+    #[test]
+    fn mirror_path_joins_under_mirror() {
+        let p = mirror_local_path("pid", "a/b.txt");
+        assert!(p.ends_with("remote-projects/pid/mirror/a/b.txt"));
+    }
+
+    #[test]
+    fn divergence_splits_the_two_sides() {
+        let e = SyncEntry {
+            selected: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            local_size: 10,
+            local_mtime: Some(50),
+            last_pull_ts: Some(1),
+            ..Default::default()
+        };
+        // Neither side moved → (false, false).
+        assert_eq!(
+            divergence(&e, Some((10, Some(100))), Some((10, Some(50)))),
+            (false, false)
+        );
+        // Host moved only → (true, false): the auto engine pulls.
+        assert_eq!(
+            divergence(&e, Some((12, Some(100))), Some((10, Some(50)))),
+            (true, false)
+        );
+        // Local moved only → (false, true): the auto engine pushes.
+        assert_eq!(
+            divergence(&e, Some((10, Some(100))), Some((10, Some(80)))),
+            (false, true)
+        );
+        // Both moved → (true, true): amber, skipped by the auto engine.
+        assert_eq!(
+            divergence(&e, Some((12, Some(100))), Some((10, Some(80)))),
+            (true, true)
+        );
+        // Host not stat'd (cold) → host side never flagged.
+        assert_eq!(divergence(&e, None, Some((10, Some(50)))), (false, false));
+    }
+
+    #[test]
+    fn content_verify_gate() {
+        let cutoff = 1024;
+        // Same size, both present, within cutoff → worth reading to disprove amber.
+        assert!(content_verify_worth_it((10, Some(100)), (10, Some(50)), cutoff));
+        // Different sizes can't be byte-identical → never read.
+        assert!(!content_verify_worth_it((10, Some(100)), (12, Some(50)), cutoff));
+        // A missing side (no mtime) is a real divergence → don't downgrade, don't read.
+        assert!(!content_verify_worth_it((10, None), (10, Some(50)), cutoff));
+        assert!(!content_verify_worth_it((10, Some(100)), (10, None), cutoff));
+        // Above the cutoff → large files keep the pure metadata heuristic.
+        assert!(!content_verify_worth_it((2048, Some(100)), (2048, Some(50)), cutoff));
+        // Exactly at the cutoff is still verified (boundary is inclusive).
+        assert!(content_verify_worth_it((1024, Some(100)), (1024, Some(50)), cutoff));
+        // Two empty files (size 0, both present) → trivially worth it (and equal).
+        assert!(content_verify_worth_it((0, Some(100)), (0, Some(50)), cutoff));
+    }
+
+    #[test]
+    fn is_auto_follows_own_entry_and_ancestor_folder_markers() {
+        let mut m = Manifest::new();
+        // A file with its own auto flag.
+        m.insert(
+            "solo.txt".to_string(),
+            SyncEntry { selected: true, auto_sync: true, ..Default::default() },
+        );
+        // An auto folder marker; its descendants inherit auto even with no entry.
+        m.insert(
+            "src".to_string(),
+            SyncEntry { selected: true, is_dir: true, auto_sync: true, ..Default::default() },
+        );
+        // A NON-auto folder marker; its descendants are not auto.
+        m.insert(
+            "vendor".to_string(),
+            SyncEntry { selected: true, is_dir: true, ..Default::default() },
+        );
+
+        assert!(is_auto(&m, "solo.txt"));
+        assert!(is_auto(&m, "src/main.rs")); // inherits from src/
+        assert!(is_auto(&m, "src/a/b/deep.rs")); // any depth under an auto folder
+        assert!(!is_auto(&m, "vendor/lib.rs")); // ancestor folder not auto
+        assert!(!is_auto(&m, "other.txt")); // no entry, no auto ancestor
+
+        // A plain FILE entry named like a dir must not act as a folder marker.
+        m.insert(
+            "notadir".to_string(),
+            SyncEntry { selected: true, auto_sync: true, is_dir: false, ..Default::default() },
+        );
+        assert!(!is_auto(&m, "notadir/child.rs"));
+    }
+
+    #[test]
+    fn is_auto_project_wide_root_marker_and_exclusions() {
+        let mut m = Manifest::new();
+        // Project-wide "auto-sync all": the root "" directory marker.
+        m.insert(
+            "".to_string(),
+            SyncEntry { selected: true, is_dir: true, auto_sync: true, ..Default::default() },
+        );
+        // Everything is auto under the project-wide marker, at any depth and for
+        // top-level files (which `rfind('/')` never resolves to the root).
+        assert!(is_auto(&m, "README.md"));
+        assert!(is_auto(&m, "src/main.rs"));
+        assert!(is_auto(&m, "a/b/c/deep.rs"));
+
+        // A local OFF override carves a subtree out of the project-wide auto.
+        m.insert(
+            "vendor".to_string(),
+            SyncEntry { selected: true, is_dir: true, auto_off: true, ..Default::default() },
+        );
+        assert!(!is_auto(&m, "vendor/lib.rs"));
+        assert!(!is_auto(&m, "vendor")); // the folder itself
+        assert!(is_auto(&m, "src/main.rs")); // siblings unaffected
+
+        // A single excluded file under an otherwise-auto tree.
+        m.insert(
+            "src/secret.rs".to_string(),
+            SyncEntry { selected: true, auto_off: true, ..Default::default() },
+        );
+        assert!(!is_auto(&m, "src/secret.rs"));
+        assert!(is_auto(&m, "src/other.rs"));
+
+        // A local ON override wins over an ancestor exclusion (nearest marker).
+        m.insert(
+            "vendor/keep".to_string(),
+            SyncEntry { selected: true, is_dir: true, auto_sync: true, ..Default::default() },
+        );
+        assert!(is_auto(&m, "vendor/keep/x.rs"));
+        assert!(!is_auto(&m, "vendor/other/y.rs")); // still excluded
+
+        // Project-wide OFF (root auto_off): nothing auto except explicit ON paths.
+        m.insert(
+            "".to_string(),
+            SyncEntry { selected: true, is_dir: true, auto_off: true, ..Default::default() },
+        );
+        assert!(!is_auto(&m, "README.md"));
+        assert!(is_auto(&m, "vendor/keep/x.rs")); // explicit ON still wins
+    }
+
+    /// Why `commands::projects::clear_host_bound_state` must exist.
+    ///
+    /// A manifest entry is a claim about **one specific host**. Point the project at a
+    /// different one — detach, then extend to a corrected path, which is the normal way to
+    /// fix a wrong `remote_path` — and every base in it becomes a lie. The state dir is
+    /// keyed by project *id*, which detach preserves, so without an explicit purge the new
+    /// pairing inherits the old host's manifest wholesale.
+    ///
+    /// The two pure functions below then disagree about the same file in the worst
+    /// possible way, and this test pins both halves so the purge can never be quietly
+    /// dropped:
+    ///   * `push_decision` sees `ever_synced` + a missing host file and calls it `Stale` —
+    ///     a deletion to be resolved, not a file to send. So it **refuses to push**.
+    ///   * `divergence` maps the same failed host stat to "couldn't check → don't flag",
+    ///     so with the mirror untouched the file reads `(false, false)` — **green**.
+    ///
+    /// A file the tree reports as fully in sync, on a host that has never had it, which
+    /// byte-sync will never send. It would look like the sync simply worked.
+    #[test]
+    fn a_stale_manifest_against_a_fresh_host_is_a_false_green() {
+        // Synced against the OLD host, and untouched locally since.
+        let stale = SyncEntry {
+            selected: true,
+            auto_sync: true,
+            host_size: 10,
+            host_mtime: Some(100),
+            local_size: 10,
+            local_mtime: Some(100),
+            last_pull_ts: Some(1),
+            ..Default::default()
+        };
+        let local_unchanged = Some((10u64, Some(100u64)));
+
+        // The new host has never heard of this file.
+        assert_eq!(
+            push_decision(&stale, None),
+            PushDecision::Stale,
+            "refuses to push: it reads the absence as a host-side DELETION, not a new host"
+        );
+        assert_eq!(
+            divergence(&stale, None, local_unchanged),
+            (false, false),
+            "…and paints it green while doing so"
+        );
+
+        // Cleared (as a fresh pairing must be), the very same file behaves correctly: it
+        // is simply a local file the host lacks, so it gets created there.
+        let fresh = SyncEntry { selected: true, auto_sync: true, ..Default::default() };
+        assert_eq!(push_decision(&fresh, None), PushDecision::Safe);
+        assert_eq!(
+            divergence(&fresh, None, local_unchanged),
+            (false, true),
+            "local-only change → push, which is exactly the seed a new host needs"
+        );
+    }
+}
diff --git a/src-tauri/src/services/remote_usage.rs b/src-tauri/src/services/remote_usage.rs
new file mode 100644
index 0000000..af8c508
--- /dev/null
+++ b/src-tauri/src/services/remote_usage.rs
@@ -0,0 +1,697 @@
+//! Remote-host resource check, run right after a project's pooled SSH
+//! connection comes up.
+//!
+//! `check_usage` runs one constant, non-interactive probe script over the
+//! shared ControlMaster (`ssh_exec::run_remote_shell`) and parses `who`,
+//! `uptime`, `nproc`, `free -m`, a two-sample `/proc/stat` CPU reading, a
+//! top-CPU `ps` snapshot, and (when `nvidia-smi` exists on the host) GPU
+//! utilization + memory into a [`RemoteUsageReport`]. [`emit_usage_report`]
+//! hands that to the frontend as a `remote-usage-report` event so
+//! `remote_connect` (`commands::remote`) can fire it fire-and-forget after
+//! every connect — manual or silent auto-connect alike — without delaying
+//! activation on a failed probe.
+//!
+//! **CPU is measured, not estimated from load average.** `/proc/stat` is
+//! read twice ~300ms apart (all inside the one remote script, so it costs no
+//! extra SSH round trip) and the busy/total tick delta over that window gives
+//! an instantaneous percentage — a load average conflates *this instant*
+//! with the last 1/5/15 minutes, which is exactly wrong for "is someone using
+//! it *right now*". A host without `/proc/stat` (non-Linux) falls back to
+//! `load1 / cpu_count`.
+//!
+//! **GPU is opportunistic, NVIDIA-only.** `nvidia-smi` is the only portable
+//! read across vendors/drivers without shelling into sysfs paths that differ
+//! per card (see `gpustat.rs`'s doc comment for why the *local* reader needs
+//! both DRM sysfs and `nvidia-smi` to cover AMD/Intel/NVIDIA) — replicating
+//! that over SSH for an arbitrary unknown host isn't worth it here, so a host
+//! with no `nvidia-smi` on `PATH` (or no GPU at all) simply reports an empty
+//! GPU list rather than a guess.
+//!
+//! The report flags `busy` when the host looks like someone (or something)
+//! else is already using it: high CPU, high memory, a busy GPU, or any other
+//! logged-in session. That last signal is best-effort, not exact — an Eldrun
+//! terminal tab connected to the same host allocates a remote PTY (`ssh -tt`)
+//! and shows up in `who` exactly like a human login, so a project with its
+//! own open terminal to that host will also read as "in use". There's no
+//! reliable way to tell the two apart from `who`'s output alone, so this is
+//! accepted rather than chased.
+//!
+//! **Careful mode (HPC hosts).** When the host reports SLURM on its `PATH` the
+//! probe collects only this account's own sessions and processes — a cluster's
+//! usage rules do not permit gathering other users' names or commands
+//! (`docs/context/hpc_careful_mode.md`) — and the verdict is remembered in
+//! [`crate::services::hpc_mode`] so `remote_connect` stops firing this probe
+//! automatically at that host from the next connect on. The aggregate figures
+//! (CPU, memory, GPU) are unchanged, which is what the `busy` gate actually
+//! reads; only the personal detail is dropped.
+
+use std::collections::HashMap;
+
+use serde::Serialize;
+use tauri::{AppHandle, Emitter};
+
+use crate::schema::project::RemoteSpec;
+use crate::services::ssh_exec::run_remote_shell;
+
+/// A single line of `who` output.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UserSession {
+    pub user: String,
+    pub tty: String,
+    /// Everything after the tty column, verbatim (login time, `(from-host)`).
+    pub detail: String,
+}
+
+/// A single row of the top-CPU `ps` snapshot.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProcInfo {
+    pub user: String,
+    pub pid: String,
+    pub cpu_pct: f64,
+    pub mem_pct: f64,
+    pub command: String,
+}
+
+/// One NVIDIA GPU's utilization + memory, from `nvidia-smi`.
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GpuUsage {
+    pub name: String,
+    pub util_pct: f64,
+    pub mem_used_mb: u64,
+    pub mem_total_mb: u64,
+}
+
+/// A CPU / memory / GPU / login-session snapshot of a remote host, plus a
+/// `busy` verdict a frontend warning dialog can gate on.
+#[derive(Debug, Clone, PartialEq, Serialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct RemoteUsageReport {
+    pub users: Vec<UserSession>,
+    /// Instantaneous CPU usage (0-100), from a two-sample `/proc/stat` delta;
+    /// falls back to a load-average estimate when `/proc/stat` is unreadable.
+    pub cpu_pct: f64,
+    pub load1: f64,
+    pub load5: f64,
+    pub load15: f64,
+    pub cpu_count: u32,
+    pub mem_total_mb: u64,
+    pub mem_used_mb: u64,
+    /// NVIDIA GPUs only (see module doc) — empty on a GPU-less host, an
+    /// AMD/Intel-only host, or one with no `nvidia-smi` on `PATH`.
+    pub gpus: Vec<GpuUsage>,
+    pub top_procs: Vec<ProcInfo>,
+    /// Whether the host looks already in use — see the module doc for the
+    /// heuristic and its one known false-positive.
+    pub busy: bool,
+    /// Human-readable reasons `busy` was set, for the warning dialog to list.
+    pub reasons: Vec<String>,
+    /// Whether the host reported itself an **HPC host** (SLURM on `PATH`), in
+    /// which case this report was taken in careful mode: `users` holds only the
+    /// connecting account's own sessions and `top_procs` only its own processes,
+    /// because a cluster's usage rules don't allow collecting other people's
+    /// (`docs/context/hpc_careful_mode.md`). The dialog says so rather than
+    /// letting a short list read as a quiet machine.
+    #[serde(default)]
+    pub careful: bool,
+}
+
+/// CPU is "busy" once usage exceeds this percentage.
+const CPU_BUSY_PCT: f64 = 80.0;
+/// Memory is "busy" once used/total exceeds this percentage.
+const MEM_BUSY_PCT: f64 = 85.0;
+/// A GPU is "busy" once its utilization exceeds this percentage.
+const GPU_BUSY_PCT: f64 = 50.0;
+/// Gap between the two `/proc/stat` samples the CPU-percentage reading is
+/// computed from. Long enough that tick-counter rounding doesn't dominate the
+/// delta, short enough that one extra SSH round trip's latency budget covers
+/// it comfortably.
+const CPU_SAMPLE_GAP: &str = "0.3";
+
+const MARK_CAREFUL: &str = "CAREFUL";
+const MARK_WHO: &str = "WHO";
+const MARK_UPTIME: &str = "UPTIME";
+const MARK_NPROC: &str = "NPROC";
+const MARK_FREE: &str = "FREE";
+const MARK_CPU1: &str = "CPU1";
+const MARK_CPU2: &str = "CPU2";
+const MARK_PROCS: &str = "PROCS";
+const MARK_GPU: &str = "GPU";
+
+/// Constant probe script — no interpolation, so it needs no quoting (see
+/// `ssh_exec::run_remote_shell`'s contract). Each section is bounded by a
+/// `##NAME##` marker line so the output can be split back apart without
+/// depending on any tool's exact formatting beyond what's parsed below.
+///
+/// `pub(crate)`: also used by `services::remote_usage::check_usage` for a
+/// project's connect-time usage warning, the only other caller of
+/// [`parse_report`] below.
+pub(crate) fn probe_script() -> String {
+    format!(
+        "_careful=0\n\
+         if command -v sbatch >/dev/null 2>&1 || command -v sinfo >/dev/null 2>&1 \
+         || command -v squeue >/dev/null 2>&1; then _careful=1; fi\n\
+         _myname=$(id -un 2>/dev/null || echo '')\n\
+         echo '##{MARK_CAREFUL}##'\n\
+         echo \"$_careful\"\n\
+         echo '##{MARK_WHO}##'\n\
+         if [ \"$_careful\" = 1 ]; then \
+         who 2>/dev/null | awk -v me=\"$_myname\" '$1 == me'; \
+         else who 2>/dev/null; fi\n\
+         echo '##{MARK_UPTIME}##'\n\
+         uptime 2>/dev/null\n\
+         echo '##{MARK_NPROC}##'\n\
+         nproc 2>/dev/null || getconf _NPROCESSORS_ONLN 2>/dev/null || echo 1\n\
+         echo '##{MARK_FREE}##'\n\
+         free -m 2>/dev/null\n\
+         echo '##{MARK_CPU1}##'\n\
+         head -n1 /proc/stat 2>/dev/null\n\
+         sleep {CPU_SAMPLE_GAP} 2>/dev/null\n\
+         echo '##{MARK_CPU2}##'\n\
+         head -n1 /proc/stat 2>/dev/null\n\
+         echo '##{MARK_PROCS}##'\n\
+         if [ \"$_careful\" = 1 ]; then \
+         ps -u \"$_myname\" -o user,pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null | head -n 9; \
+         else ps -eo user,pid,pcpu,pmem,comm --sort=-pcpu 2>/dev/null | head -n 9; fi\n\
+         echo '##{MARK_GPU}##'\n\
+         command -v nvidia-smi >/dev/null 2>&1 && \
+         nvidia-smi --query-gpu=name,utilization.gpu,memory.used,memory.total \
+         --format=csv,noheader,nounits 2>/dev/null\n"
+    )
+}
+
+/// Run the probe script on `spec`'s host (riding the shared ControlMaster)
+/// and parse it into a [`RemoteUsageReport`]. Synchronous (shells out via
+/// `std::process`), so callers on an async runtime should run it inside
+/// `spawn_blocking`.
+pub fn check_usage(spec: &RemoteSpec) -> Result<RemoteUsageReport, String> {
+    let out = run_remote_shell(spec, &probe_script())?;
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    if stdout.trim().is_empty() {
+        return Err(format!(
+            "remote usage probe returned no output: {}",
+            String::from_utf8_lossy(&out.stderr)
+        ));
+    }
+    let report = parse_report(&stdout);
+    // Remember an HPC verdict so the *automatic* connect-time probe can stop
+    // firing at this host altogether (`commands::remote::remote_connect`) — the
+    // probe is cheap, but on a cluster it is also unasked-for, and once we know
+    // what the host is there is no reason to keep asking it who is logged in.
+    crate::services::hpc_mode::remember(&crate::services::hpc_mode::key_for(spec), report.careful);
+    Ok(report)
+}
+
+/// Emit `report` as a `remote-usage-report` event (`{ projectId, hostId, report }`,
+/// camelCase) for the frontend's warning dialog. `host_id` names which of the
+/// project's hosts (primary or a `compute_hosts` worker) this report is for, so
+/// the dialog can show a section per connected host rather than only the
+/// primary's. Best-effort — a closed window / no listener is not an error.
+pub fn emit_usage_report(
+    app: &AppHandle,
+    project_id: &str,
+    host_id: &str,
+    report: &RemoteUsageReport,
+) {
+    #[derive(Serialize, Clone)]
+    #[serde(rename_all = "camelCase")]
+    struct Event<'a> {
+        project_id: &'a str,
+        host_id: &'a str,
+        report: &'a RemoteUsageReport,
+    }
+    let _ = app.emit(
+        "remote-usage-report",
+        Event {
+            project_id,
+            host_id,
+            report,
+        },
+    );
+}
+
+/// Split `output` into its `##MARK##`-delimited sections, keyed by marker
+/// name with the `##` stripped. Lines before the first marker are dropped.
+fn split_sections(output: &str) -> HashMap<&str, Vec<&str>> {
+    let mut sections: HashMap<&str, Vec<&str>> = HashMap::new();
+    let mut current: Option<&str> = None;
+    for line in output.lines() {
+        let trimmed = line.trim();
+        if let Some(name) = trimmed
+            .strip_prefix("##")
+            .and_then(|s| s.strip_suffix("##"))
+            .filter(|s| !s.is_empty())
+        {
+            current = Some(name);
+            sections.entry(name).or_default();
+            continue;
+        }
+        if let Some(name) = current {
+            sections.get_mut(name).unwrap().push(line);
+        }
+    }
+    sections
+}
+
+fn parse_who(lines: &[&str]) -> Vec<UserSession> {
+    lines
+        .iter()
+        .filter(|l| !l.trim().is_empty())
+        .filter_map(|l| {
+            let mut parts = l.split_whitespace();
+            let user = parts.next()?.to_string();
+            let tty = parts.next().unwrap_or("").to_string();
+            let detail = parts.collect::<Vec<_>>().join(" ");
+            Some(UserSession { user, tty, detail })
+        })
+        .collect()
+}
+
+/// Parses the three comma-separated floats after `load average:` in
+/// `uptime`'s output. `(0.0, 0.0, 0.0)` if the line is missing or malformed
+/// (a host whose `uptime` doesn't support `-p`-less BSD-style output, say) —
+/// the caller can't distinguish "idle" from "unreadable" here, and idle is
+/// the safe default for a warning gate.
+fn parse_load_average(lines: &[&str]) -> (f64, f64, f64) {
+    let line = lines.iter().find(|l| l.contains("load average"));
+    let Some(line) = line else {
+        return (0.0, 0.0, 0.0);
+    };
+    let Some(tail) = line.split("load average").nth(1) else {
+        return (0.0, 0.0, 0.0);
+    };
+    let tail = tail.trim_start_matches(':').trim_start_matches(',');
+    let nums: Vec<f64> = tail
+        .split(',')
+        .filter_map(|s| s.trim().parse::<f64>().ok())
+        .collect();
+    (
+        nums.first().copied().unwrap_or(0.0),
+        nums.get(1).copied().unwrap_or(0.0),
+        nums.get(2).copied().unwrap_or(0.0),
+    )
+}
+
+fn parse_cpu_count(lines: &[&str]) -> u32 {
+    lines
+        .iter()
+        .find_map(|l| l.trim().parse::<u32>().ok())
+        .unwrap_or(1)
+        .max(1)
+}
+
+/// Reads the `Mem:` row of `free -m` (`total`, `used` are its 2nd/3rd
+/// whitespace-separated fields). `(0, 0)` if the row is missing.
+fn parse_mem(lines: &[&str]) -> (u64, u64) {
+    let Some(line) = lines.iter().find(|l| l.trim_start().starts_with("Mem:")) else {
+        return (0, 0);
+    };
+    let fields: Vec<&str> = line.split_whitespace().collect();
+    let total = fields.get(1).and_then(|s| s.parse::<u64>().ok()).unwrap_or(0);
+    let used = fields.get(2).and_then(|s| s.parse::<u64>().ok()).unwrap_or(0);
+    (total, used)
+}
+
+/// Reads `/proc/stat`'s `cpu ` summary line (the aggregate over all cores,
+/// distinct from the per-core `cpu0`/`cpu1`/... lines) into `(idle, total)`
+/// tick counts — `idle` = idle + iowait, `total` = the sum of every field.
+/// `None` if the line is missing (a non-Linux host) or too short to trust.
+fn parse_proc_stat(lines: &[&str]) -> Option<(u64, u64)> {
+    let line = lines
+        .iter()
+        .find(|l| l.split_whitespace().next() == Some("cpu"))?;
+    let nums: Vec<u64> = line
+        .split_whitespace()
+        .skip(1)
+        .filter_map(|s| s.parse::<u64>().ok())
+        .collect();
+    if nums.len() < 4 {
+        return None;
+    }
+    let idle = nums[3] + nums.get(4).copied().unwrap_or(0);
+    let total = nums.iter().sum();
+    Some((idle, total))
+}
+
+/// Instantaneous CPU usage (0-100) from two `/proc/stat` samples taken
+/// `CPU_SAMPLE_GAP` seconds apart. Falls back to `load1 / cpu_count` (still
+/// clamped to 0-100) when either sample is missing, e.g. a non-Linux host.
+fn compute_cpu_pct(
+    sample1: Option<(u64, u64)>,
+    sample2: Option<(u64, u64)>,
+    load1: f64,
+    cpu_count: u32,
+) -> f64 {
+    if let (Some((idle1, total1)), Some((idle2, total2))) = (sample1, sample2) {
+        let dt = total2.saturating_sub(total1);
+        if dt > 0 {
+            let d_idle = idle2.saturating_sub(idle1);
+            return ((1.0 - d_idle as f64 / dt as f64) * 100.0).clamp(0.0, 100.0);
+        }
+    }
+    (load1 / cpu_count.max(1) as f64 * 100.0).clamp(0.0, 100.0)
+}
+
+/// Parses `nvidia-smi --query-gpu=name,utilization.gpu,memory.used,memory.total
+/// --format=csv,noheader,nounits` rows (plain CSV, no header since
+/// `noheader`). Empty when `nvidia-smi` isn't on the host's `PATH` at all —
+/// the probe script's `command -v` guard then produces no output here rather
+/// than an error.
+fn parse_gpus(lines: &[&str]) -> Vec<GpuUsage> {
+    lines
+        .iter()
+        .filter(|l| !l.trim().is_empty())
+        .filter_map(|l| {
+            let fields: Vec<&str> = l.split(',').map(str::trim).collect();
+            if fields.len() < 4 {
+                return None;
+            }
+            Some(GpuUsage {
+                name: fields[0].to_string(),
+                util_pct: fields[1].parse().unwrap_or(0.0),
+                mem_used_mb: fields[2].parse().unwrap_or(0),
+                mem_total_mb: fields[3].parse().unwrap_or(0),
+            })
+        })
+        .collect()
+}
+
+/// Parses `ps -eo user,pid,pcpu,pmem,comm` rows, skipping the header line.
+/// `comm` is a single token (unlike `args`), so five whitespace fields is
+/// always right even for a command containing spaces in its full path.
+fn parse_procs(lines: &[&str]) -> Vec<ProcInfo> {
+    lines
+        .iter()
+        .filter(|l| !l.trim().is_empty())
+        .skip(1) // header: "USER PID %CPU %MEM COMMAND"
+        .filter_map(|l| {
+            let fields: Vec<&str> = l.split_whitespace().collect();
+            if fields.len() < 5 {
+                return None;
+            }
+            Some(ProcInfo {
+                user: fields[0].to_string(),
+                pid: fields[1].to_string(),
+                cpu_pct: fields[2].parse().unwrap_or(0.0),
+                mem_pct: fields[3].parse().unwrap_or(0.0),
+                command: fields[4..].join(" "),
+            })
+        })
+        .collect()
+}
+
+pub(crate) fn parse_report(output: &str) -> RemoteUsageReport {
+    let sections = split_sections(output);
+    let empty: Vec<&str> = Vec::new();
+    let careful = sections
+        .get(MARK_CAREFUL)
+        .and_then(|lines| lines.iter().find(|l| !l.trim().is_empty()))
+        .is_some_and(|l| l.trim() == "1");
+    let users = parse_who(sections.get(MARK_WHO).unwrap_or(&empty));
+    let (load1, load5, load15) = parse_load_average(sections.get(MARK_UPTIME).unwrap_or(&empty));
+    let cpu_count = parse_cpu_count(sections.get(MARK_NPROC).unwrap_or(&empty));
+    let (mem_total_mb, mem_used_mb) = parse_mem(sections.get(MARK_FREE).unwrap_or(&empty));
+    let cpu1 = parse_proc_stat(sections.get(MARK_CPU1).unwrap_or(&empty));
+    let cpu2 = parse_proc_stat(sections.get(MARK_CPU2).unwrap_or(&empty));
+    let cpu_pct = compute_cpu_pct(cpu1, cpu2, load1, cpu_count);
+    let top_procs = parse_procs(sections.get(MARK_PROCS).unwrap_or(&empty));
+    let gpus = parse_gpus(sections.get(MARK_GPU).unwrap_or(&empty));
+
+    let mut reasons = Vec::new();
+    if cpu_pct > CPU_BUSY_PCT {
+        reasons.push(format!(
+            "CPU usage is high ({cpu_pct:.0}% across {cpu_count} core(s))"
+        ));
+    }
+    let mem_pct = if mem_total_mb > 0 {
+        mem_used_mb as f64 / mem_total_mb as f64 * 100.0
+    } else {
+        0.0
+    };
+    if mem_pct > MEM_BUSY_PCT {
+        reasons.push(format!(
+            "Memory usage is high ({mem_pct:.0}% of {mem_total_mb} MB used)"
+        ));
+    }
+    for gpu in &gpus {
+        if gpu.util_pct > GPU_BUSY_PCT {
+            reasons.push(format!("GPU \"{}\" is busy ({:.0}%)", gpu.name, gpu.util_pct));
+        }
+    }
+    if !users.is_empty() {
+        // On a careful (HPC) host the session list is only ever this account's
+        // own, so the old wording would claim something the probe cannot see. A
+        // login node always has other people on it; that is not the warning.
+        reasons.push(if careful {
+            format!(
+                "{} session{} of your own already logged in",
+                users.len(),
+                if users.len() == 1 { "" } else { "s" }
+            )
+        } else {
+            format!(
+                "{} other session{} logged in",
+                users.len(),
+                if users.len() == 1 { "" } else { "s" }
+            )
+        });
+    }
+    let busy = !reasons.is_empty();
+
+    RemoteUsageReport {
+        users,
+        cpu_pct,
+        load1,
+        load5,
+        load15,
+        cpu_count,
+        mem_total_mb,
+        mem_used_mb,
+        gpus,
+        top_procs,
+        busy,
+        reasons,
+        careful,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &str = "\
+##WHO##
+alice    pts/0        2026-07-18 09:12 (203.0.113.5)
+bob      tty1         2026-07-17 22:03
+##UPTIME##
+ 14:32:01 up 10 days,  3:22,  2 users,  load average: 3.21, 2.98, 2.50
+##NPROC##
+4
+##FREE##
+              total        used        free      shared  buff/cache   available
+Mem:          15974       14200         500         100        1274         900
+Swap:          2047           0        2047
+##CPU1##
+cpu  1000 0 500 8000 0 0 0 0 0 0
+##CPU2##
+cpu  1085 0 500 8015 0 0 0 0 0 0
+##PROCS##
+USER       PID  %CPU %MEM COMMAND
+bob      12345  88.0 40.1 python3
+alice     6789  10.5  2.0 node
+##GPU##
+NVIDIA GeForce RTX 3090, 92, 20000, 24576
+";
+
+    #[test]
+    fn parses_who_sessions() {
+        let sections = split_sections(SAMPLE);
+        let users = parse_who(sections.get(MARK_WHO).unwrap());
+        assert_eq!(users.len(), 2);
+        assert_eq!(users[0].user, "alice");
+        assert_eq!(users[0].tty, "pts/0");
+        assert!(users[0].detail.contains("203.0.113.5"));
+        assert_eq!(users[1].user, "bob");
+        assert_eq!(users[1].tty, "tty1");
+    }
+
+    #[test]
+    fn parses_load_average() {
+        let sections = split_sections(SAMPLE);
+        let (l1, l5, l15) = parse_load_average(sections.get(MARK_UPTIME).unwrap());
+        assert_eq!(l1, 3.21);
+        assert_eq!(l5, 2.98);
+        assert_eq!(l15, 2.50);
+    }
+
+    #[test]
+    fn load_average_missing_defaults_to_zero() {
+        let (l1, l5, l15) = parse_load_average(&["no load info here"]);
+        assert_eq!((l1, l5, l15), (0.0, 0.0, 0.0));
+    }
+
+    #[test]
+    fn parses_cpu_count() {
+        let sections = split_sections(SAMPLE);
+        assert_eq!(parse_cpu_count(sections.get(MARK_NPROC).unwrap()), 4);
+    }
+
+    #[test]
+    fn parses_mem() {
+        let sections = split_sections(SAMPLE);
+        let (total, used) = parse_mem(sections.get(MARK_FREE).unwrap());
+        assert_eq!(total, 15974);
+        assert_eq!(used, 14200);
+    }
+
+    #[test]
+    fn parses_top_procs_skipping_header() {
+        let sections = split_sections(SAMPLE);
+        let procs = parse_procs(sections.get(MARK_PROCS).unwrap());
+        assert_eq!(procs.len(), 2);
+        assert_eq!(procs[0].user, "bob");
+        assert_eq!(procs[0].command, "python3");
+        assert_eq!(procs[0].cpu_pct, 88.0);
+    }
+
+    #[test]
+    fn busy_host_flags_all_reasons() {
+        let report = parse_report(SAMPLE);
+        assert!(report.busy);
+        // (100-15)/100... i.e. 1 - 15/100 = 85% > 80%
+        assert_eq!(report.cpu_pct, 85.0);
+        assert!(report.reasons.iter().any(|r| r.contains("CPU usage")));
+        // 14200/15974 = 88.9% > 85%
+        assert!(report.reasons.iter().any(|r| r.contains("Memory usage")));
+        assert!(report.reasons.iter().any(|r| r.contains("GPU") && r.contains("92")));
+        assert!(report.reasons.iter().any(|r| r.contains("other session")));
+        assert_eq!(report.gpus.len(), 1);
+        assert_eq!(report.gpus[0].name, "NVIDIA GeForce RTX 3090");
+        assert_eq!(report.gpus[0].mem_used_mb, 20000);
+    }
+
+    #[test]
+    fn cpu_pct_falls_back_to_load_average_without_proc_stat() {
+        // No CPU1/CPU2 sections at all — a non-Linux host.
+        let no_proc_stat = "\
+##UPTIME##
+load average: 4.0, 4.0, 4.0
+##NPROC##
+8
+";
+        let report = parse_report(no_proc_stat);
+        // 4.0 / 8 * 100 = 50%
+        assert_eq!(report.cpu_pct, 50.0);
+    }
+
+    #[test]
+    fn no_gpu_tool_reports_empty_gpu_list() {
+        let no_gpu = "\
+##WHO##
+##UPTIME##
+load average: 0.1, 0.1, 0.1
+##NPROC##
+4
+##FREE##
+Mem: 8000 1000 7000
+##GPU##
+";
+        let report = parse_report(no_gpu);
+        assert!(report.gpus.is_empty());
+        assert!(!report.reasons.iter().any(|r| r.contains("GPU")));
+    }
+
+    #[test]
+    fn idle_host_is_not_busy() {
+        let idle = "\
+##WHO##
+##UPTIME##
+ 14:32:01 up 10 days,  3:22,  0 users,  load average: 0.05, 0.10, 0.08
+##NPROC##
+8
+##FREE##
+              total        used        free      shared  buff/cache   available
+Mem:          32000        2000       28000         100        2000       29000
+##PROCS##
+USER       PID  %CPU %MEM COMMAND
+root         1   0.0  0.1 systemd
+";
+        let report = parse_report(idle);
+        assert!(!report.busy);
+        assert!(report.reasons.is_empty());
+        assert!(report.users.is_empty());
+        // No `##CAREFUL##` section at all is an ordinary host (an older probe
+        // script, or a plain dev box): full collection, as before.
+        assert!(!report.careful);
+    }
+
+    #[test]
+    fn a_careful_host_reports_itself_and_rewords_the_session_reason() {
+        // On an HPC host the script ships only this account's own sessions and
+        // processes, so "N other sessions logged in" would be a claim the probe
+        // can no longer make — a login node always has other people on it, and
+        // that is not what the warning is for.
+        let careful = "\
+##CAREFUL##
+1
+##WHO##
+alice    pts/0        2026-07-18 09:12
+##UPTIME##
+ 14:32:01 up 10 days,  3:22,  9 users,  load average: 0.10, 0.10, 0.10
+##NPROC##
+64
+##FREE##
+              total        used        free      shared  buff/cache   available
+Mem:         256000       20000      200000         100       36000      230000
+##PROCS##
+USER       PID  %CPU %MEM COMMAND
+alice     6789   1.5  0.2 python3
+";
+        let report = parse_report(careful);
+        assert!(report.careful);
+        assert_eq!(report.users.len(), 1);
+        assert!(report
+            .reasons
+            .iter()
+            .any(|r| r.contains("of your own already logged in")));
+        assert!(!report.reasons.iter().any(|r| r.contains("other session")));
+        // The aggregate figures — what `busy` actually gates on — are untouched.
+        assert_eq!(report.cpu_count, 64);
+        assert_eq!(report.mem_total_mb, 256_000);
+    }
+
+    #[test]
+    fn the_probe_script_detects_and_censors_on_an_hpc_host() {
+        let s = probe_script();
+        assert!(s.contains("command -v sbatch"));
+        assert!(s.contains("##CAREFUL##"));
+        // Both branches present: own-sessions/own-processes when careful, the
+        // whole-host reads otherwise.
+        assert!(s.contains("ps -u \"$_myname\""));
+        assert!(s.contains("ps -eo user,pid,pcpu,pmem,comm"));
+    }
+
+    #[test]
+    fn singular_session_wording() {
+        let one_user = "\
+##WHO##
+alice    pts/0        2026-07-18 09:12
+##UPTIME##
+load average: 0.1, 0.1, 0.1
+##NPROC##
+4
+##FREE##
+Mem: 8000 1000 7000
+##PROCS##
+USER PID %CPU %MEM COMMAND
+";
+        let report = parse_report(one_user);
+        assert!(report.busy);
+        assert!(report
+            .reasons
+            .iter()
+            .any(|r| r == "1 other session logged in"));
+    }
+}
diff --git a/src-tauri/src/services/sandbox.rs b/src-tauri/src/services/sandbox.rs
new file mode 100644
index 0000000..62adb1d
--- /dev/null
+++ b/src-tauri/src/services/sandbox.rs
@@ -0,0 +1,1421 @@
+//! Project containers (TODO #38): one closed Docker container per project.
+//!
+//! When a project's container toggle is on, every terminal/agent tab of the
+//! project (`shell` and `agent` kinds) execs into a single long-lived container
+//! named `eldrun-<project-id>`. `local_only` tabs (e.g. Ollama `local_agent`)
+//! stay on the host verbatim. The container mounts **only the project
+//! directory** plus the minimal agent auth/state paths, so a process inside it
+//! physically cannot reach unrelated host files.
+//!
+//! Lifecycle: container lifetime = **project session**. It is created on
+//! activation (`project_runtime::switch`) or on the first containerized spawn,
+//! and torn down on deactivation (unless tabs are still live inside it), at app
+//! exit (`down_all`), and at startup (`sweep_orphans` — a previous run's
+//! containers are by definition stale). Every session starts from a fresh
+//! container; installed deps and dev servers are shared between tabs *within*
+//! a session.
+//!
+//! ## Identical-path mounting (correctness-critical)
+//!
+//! The project directory stays on the host and is bind-mounted at its
+//! **identical absolute path**; the container runs `--user <uid>:<gid>` with
+//! `-e HOME=<host home>`. This is what keeps the file tree, git UI, viewers and
+//! usage watcher reading host bytes unchanged, keeps `-w <cwd>` trivially
+//! correct for subdir tabs, and — most importantly — keeps **agent session
+//! resume** working: Claude/Codex transcripts and the SessionStart hook record
+//! host-absolute cwds, so the *same* session resumes correctly whether the
+//! toggle is on or off.
+//!
+//! ## What the container can reach (blast radius)
+//!
+//! Only these host paths are bind-mounted, each at its identical absolute path:
+//! - the **project directory** (rw) — the sole project bytes exposed;
+//! - `~/.claude`, `~/.codex` (rw, when present) — agent auth + session transcripts;
+//! - `<state_dir>/live_sessions` (rw) — where the in-container SessionStart hook
+//!   records a tab's live session id for resume;
+//! - Gemini creds (`~/.gemini`, `~/.config/gemini`, rw, when present) — narrowed
+//!   from the whole `~/.config` so `gh`/`gcloud`/etc. secrets are *not* exposed;
+//! - `<state_dir>/hooks` mounted **read-only** (see the RCE note below);
+//! - the agents' hook-registration files (`~/.claude/settings.json[.local]`,
+//!   `~/.codex/config.toml`) as **per-project writable copies** shadowing the
+//!   host originals (see the RCE note below), staged under
+//!   `<state_dir>/sandbox-stage/<project-id>/` and refreshed from the host
+//!   originals at each `up`.
+//!
+//! Nothing else under `$HOME` or `state_dir` (notably `projects.json`, other
+//! projects' conversation history, `time_log.json`) is mounted.
+//!
+//! ## Hook mounts (host-RCE defence)
+//!
+//! The SessionStart hook *script* lives at `<state_dir>/hooks/…` and its absolute
+//! path is baked into `~/.claude/settings.json` / `~/.codex/config.toml`. Two
+//! distinct escape paths, each closed differently:
+//! - **The script** is shared with host-run agents, so it is mounted
+//!   **read-only**: a writable copy would let a compromised agent rewrite it and
+//!   have arbitrary code run on the host next time an agent starts there.
+//! - **The registration files** point *at* that script. They are mounted as
+//!   **per-project writable copies** rather than the host originals: the
+//!   container gets a real, writable file it can freely rewrite (so agents that
+//!   persist config don't error), but its writes land in the throwaway copy —
+//!   the host's real settings can never be repointed at an attacker command.
+//!   The copy still carries the hook registration, so resume recording works.
+//!
+//! ## The exec step and the tab-kill contract
+//!
+//! Tabs are spawned as `docker exec -i -t -w <cwd> … <name> sh -c '…' sh <cmd>
+//! <args…>`. Per-tab env (`opts.env`, `TERM`/`COLORTERM`) and **agent-auth env**
+//! (`ssh_exec::AGENT_AUTH_ENV`, read off the host process at exec time so
+//! rotated tokens are picked up per spawn) ride as `-e` flags. The `sh -c`
+//! wrapper records the process's pid into an in-container pidfile before
+//! exec'ing the real command: Docker does **not** kill an exec'd process when
+//! its client dies, so closing a tab would otherwise leave the agent running
+//! inside the container until session end. `PtyRegistry::kill` calls
+//! [`kill_tab_process`], which TERMs that recorded pid (group) best-effort.
+//!
+//! ## Hardening
+//!
+//! Every container is created with `--init` (PID 1 reaps zombies),
+//! `--security-opt no-new-privileges`, `--cap-drop ALL`, a `--pids-limit`
+//! (fork-bomb guard), and `--label eldrun.owner=eldrun` so anything we started
+//! is enumerable (and sweepable). Optional per-project knobs (`SandboxSpec`):
+//! `--memory`, `--cpus`, `--network` (e.g. `none` for no egress), and
+//! `--read-only` rootfs (+ `--tmpfs /tmp`). Docker's own socket is never
+//! mounted. Note the default bridge network still reaches host-bound services
+//! via the gateway IP (Ollama, dev servers); "closed" users set `network: none`
+//! (breaks cloud agents) or a custom allowlist network.
+//!
+//! All paths are built from Rust path helpers as absolute strings — never
+//! relying on `$HOME` shell-expansion, because `docker` is exec'd directly.
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Mutex, OnceLock};
+
+use serde::Serialize;
+
+use crate::paths;
+use crate::schema::project::SandboxSpec;
+use crate::storage;
+use crate::terminal::PtyOptions;
+
+/// Default image used when a project does not override it. Building/providing
+/// this image is the user's responsibility; the toggle-time preflight offers a
+/// one-click build (see `preflight_report` / `docker/agent-sandbox/`).
+pub const DEFAULT_IMAGE: &str = "eldrun-agent-sandbox:latest";
+
+/// Default `--pids-limit` when a project does not override it. Generous enough
+/// for node + git + ripgrep + child processes, tight enough to blunt a fork bomb.
+pub const DEFAULT_PIDS_LIMIT: u32 = 1024;
+
+/// `--label` marking every container Eldrun starts, so anything we own is
+/// enumerable (`docker ps --filter label=…`) and sweepable at startup/exit.
+pub const OWNER_LABEL: &str = "eldrun.owner=eldrun";
+
+/// The reference sandbox image's Dockerfile, embedded so an installed app (no
+/// repo checkout) can still materialize it for the one-click build flow.
+const REFERENCE_DOCKERFILE: &str = include_str!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/../docker/agent-sandbox/Dockerfile"
+));
+
+/// Runtime hardening flags for a project container. Built from a project's
+/// `SandboxSpec`; owns its strings so it has no lifetime ties to the spec.
+#[derive(Debug, Clone)]
+pub struct HardenOpts {
+    pub pids_limit: u32,
+    pub memory: Option<String>,
+    pub cpus: Option<String>,
+    pub network: Option<String>,
+    pub readonly_rootfs: bool,
+}
+
+impl Default for HardenOpts {
+    fn default() -> Self {
+        HardenOpts {
+            pids_limit: DEFAULT_PIDS_LIMIT,
+            memory: None,
+            cpus: None,
+            network: None,
+            readonly_rootfs: false,
+        }
+    }
+}
+
+// ── Naming ────────────────────────────────────────────────────────────────
+
+/// Reduce an id to a docker-name/shell/path-safe key (`[A-Za-z0-9_-]`, never
+/// empty). Shared by the container name, the per-project stage dir, and the
+/// per-tab pidfile so all three stay derivable from the same id.
+fn sanitize_key(id: &str) -> String {
+    let safe: String = id
+        .chars()
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '-' || c == '_' {
+                c
+            } else {
+                '_'
+            }
+        })
+        .collect();
+    if safe.is_empty() {
+        "x".to_string()
+    } else {
+        safe
+    }
+}
+
+/// Name of the session container for a project: `eldrun-<sanitized-id>`.
+pub fn container_name_for(project_id: &str) -> String {
+    format!("eldrun-{}", sanitize_key(project_id))
+}
+
+/// Image tag to run for a project: a `dockerfile` spec builds a per-project tag,
+/// otherwise the spec's `image` override, otherwise the built-in default.
+pub fn image_for(project_id: &str, spec: Option<&SandboxSpec>) -> String {
+    if spec.is_some_and(|s| s.dockerfile.is_some()) {
+        return format!("eldrun-{}:latest", sanitize_key(project_id));
+    }
+    spec.and_then(|s| s.image.clone())
+        .unwrap_or_else(|| DEFAULT_IMAGE.to_string())
+}
+
+// ── Fingerprint + up decision (pure) ──────────────────────────────────────
+
+/// Stable FNV-1a hash of everything baked into `docker run` at create time
+/// (image, mounts, hardening — i.e. the create argv built with no fingerprint
+/// label). Stored on the container as `--label eldrun.spec=<hash>` so `up` can
+/// detect a stale container whose spec/mounts no longer match and recreate it.
+/// Deliberately not `DefaultHasher` (unstable across Rust releases — a false
+/// mismatch would needlessly recreate on every app upgrade… of the hasher).
+pub fn spec_fingerprint(create_args: &[String]) -> String {
+    let mut h: u64 = 0xcbf2_9ce4_8422_2325;
+    for a in create_args {
+        for b in a.as_bytes() {
+            h ^= u64::from(*b);
+            h = h.wrapping_mul(0x0000_0100_0000_01b3);
+        }
+        // Separator step so ["ab","c"] and ["a","bc"] hash differently.
+        h ^= 0x1f;
+        h = h.wrapping_mul(0x0000_0100_0000_01b3);
+    }
+    format!("{h:016x}")
+}
+
+/// What `up` observed about the named container.
+#[derive(Debug, Clone, Default)]
+pub struct ContainerProbe {
+    pub exists: bool,
+    pub running: bool,
+    /// The `eldrun.spec` label recorded at create, when present.
+    pub fingerprint: Option<String>,
+}
+
+/// What `up` should do, given a probe and the wanted fingerprint.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UpAction {
+    /// Running and the spec still matches — no-op.
+    UseExisting,
+    /// Exists but stopped, or the spec/mounts changed — `rm -f`, then create.
+    /// (Also covers crash leftovers.)
+    Recreate,
+    /// No such container — create.
+    Create,
+}
+
+/// The idempotent three-state decision at the heart of `up`.
+pub fn up_decision(probe: &ContainerProbe, want_fingerprint: &str) -> UpAction {
+    if !probe.exists {
+        return UpAction::Create;
+    }
+    if probe.running && probe.fingerprint.as_deref() == Some(want_fingerprint) {
+        return UpAction::UseExisting;
+    }
+    UpAction::Recreate
+}
+
+// ── Argv builders (pure, unit-testable) ───────────────────────────────────
+
+/// Build the `docker run -d … <image> sleep infinity` argv that creates a
+/// project's session container. Pure: all host-derived inputs are passed in.
+/// `rw_mounts`/`ro_mounts` are `src:dst` pairs (the project dir is always
+/// mounted rw regardless); each `ro_mounts` entry gets a `:ro` suffix appended.
+/// `fingerprint` is `None` while computing the fingerprint itself (the argv is
+/// its own hash input), then `Some` for the real create.
+#[allow(clippy::too_many_arguments)]
+pub fn docker_create_args(
+    name: &str,
+    project_id: &str,
+    image: &str,
+    home: &str,
+    uid: u32,
+    gid: u32,
+    project_dir: &str,
+    rw_mounts: &[String],
+    ro_mounts: &[String],
+    harden: &HardenOpts,
+    fingerprint: Option<&str>,
+) -> Vec<String> {
+    let mut a = vec![
+        "run".to_string(),
+        "-d".to_string(),
+        "--name".to_string(),
+        name.to_string(),
+        // PID 1 reaps zombies — tabs come and go for the container's whole life.
+        "--init".to_string(),
+        "--label".to_string(),
+        OWNER_LABEL.to_string(),
+        "--label".to_string(),
+        format!("eldrun.project={project_id}"),
+    ];
+    if let Some(fp) = fingerprint {
+        // Keep the label out of its own hash input: it is appended only on the
+        // second, real build of this argv.
+        a.push("--label".to_string());
+        a.push(format!("eldrun.spec={fp}"));
+    }
+    a.extend([
+        "--user".to_string(),
+        format!("{uid}:{gid}"),
+        // Hardening: no privilege escalation, no Linux capabilities, bounded
+        // process count. Docker's socket is deliberately never mounted.
+        "--security-opt".to_string(),
+        "no-new-privileges".to_string(),
+        "--cap-drop".to_string(),
+        "ALL".to_string(),
+        "--pids-limit".to_string(),
+        harden.pids_limit.to_string(),
+        "-e".to_string(),
+        format!("HOME={home}"),
+        "-w".to_string(),
+        project_dir.to_string(),
+    ]);
+    if let Some(mem) = &harden.memory {
+        a.push("--memory".to_string());
+        a.push(mem.clone());
+    }
+    if let Some(cpus) = &harden.cpus {
+        a.push("--cpus".to_string());
+        a.push(cpus.clone());
+    }
+    if let Some(net) = &harden.network {
+        a.push("--network".to_string());
+        a.push(net.clone());
+    }
+    if harden.readonly_rootfs {
+        a.push("--read-only".to_string());
+        // Writable scratch so tools that need /tmp (npm cache, the per-tab
+        // pidfiles below) still work under a read-only rootfs.
+        a.push("--tmpfs".to_string());
+        a.push("/tmp".to_string());
+    }
+    // The project dir (the only project bytes exposed), always mounted rw at
+    // its identical path.
+    a.push("-v".to_string());
+    a.push(format!("{project_dir}:{project_dir}"));
+    for m in rw_mounts {
+        a.push("-v".to_string());
+        a.push(m.clone());
+    }
+    // Read-only mounts (the hook script dir). A nested `:ro` file mount over an
+    // rw parent dir works regardless of argv order: docker applies bind mounts
+    // parent-first by destination depth.
+    for m in ro_mounts {
+        a.push("-v".to_string());
+        a.push(format!("{m}:ro"));
+    }
+    a.push(image.to_string());
+    // The container's sole job is to exist; tabs are `docker exec`s into it.
+    a.push("sleep".to_string());
+    a.push("infinity".to_string());
+    a
+}
+
+/// Build the `docker exec …` argv that runs a tab's command inside the session
+/// container. Per-tab env rides as `-e` flags (the exec inherits the container
+/// env, notably `HOME`, from create). The `sh -c` wrapper writes the process's
+/// pid to `pidfile` before exec'ing the real command — the tab-kill contract
+/// (see the module doc and [`kill_tab_process`]).
+pub fn docker_exec_args(
+    name: &str,
+    cwd: &str,
+    env: &BTreeMap<String, String>,
+    auth_env: &BTreeMap<String, String>,
+    pidfile: &str,
+    cmd: &str,
+    cmd_args: &[String],
+) -> Vec<String> {
+    let mut a = vec![
+        "exec".to_string(),
+        "-i".to_string(),
+        "-t".to_string(),
+        "-w".to_string(),
+        cwd.to_string(),
+        "-e".to_string(),
+        "TERM=xterm-256color".to_string(),
+        "-e".to_string(),
+        "COLORTERM=truecolor".to_string(),
+    ];
+    for (k, v) in env {
+        a.push("-e".to_string());
+        a.push(format!("{k}={v}"));
+    }
+    for (k, v) in auth_env {
+        a.push("-e".to_string());
+        a.push(format!("{k}={v}"));
+    }
+    a.push(name.to_string());
+    a.push("sh".to_string());
+    a.push("-c".to_string());
+    // `pidfile` is built from sanitize_key output — shell-safe by construction.
+    a.push(format!("echo $$ > {pidfile}; exec \"$@\""));
+    a.push("sh".to_string());
+    a.push(cmd.to_string());
+    a.extend(cmd_args.iter().cloned());
+    a
+}
+
+// ── Spawn-path entry point ────────────────────────────────────────────────
+
+/// Rewrite `opts` to run its command inside the project's session container:
+/// resolve the spec → `up()` (idempotent) → `docker exec`. No-op when
+/// `opts.sandbox` is false. Errors (so `pty_spawn` surfaces the message in the
+/// terminal) when docker, the daemon, or the image is unavailable, rather than
+/// silently running the command on the host.
+pub fn wrap_pty_options_docker(opts: &mut PtyOptions) -> Result<(), String> {
+    if !opts.sandbox {
+        return Ok(());
+    }
+    // Defence-in-depth: containers are local-only. Never docker-wrap a remote
+    // project (resolved explicitly from the tab's owning project id).
+    if opts
+        .project_id
+        .as_deref()
+        .is_some_and(|id| crate::services::remote::remote_target_for(id).is_some())
+    {
+        return Ok(());
+    }
+    let project_id = opts
+        .project_id
+        .clone()
+        .ok_or_else(|| "Project container: this tab has no owning project.".to_string())?;
+
+    let spec = sandbox_spec_for(&project_id);
+    // The container mounts the project ROOT; a subdir tab keeps its cwd via -w.
+    let project_dir = project_dir_for(&project_id).unwrap_or_else(|| opts.cwd.clone());
+    let name = up(&project_id, spec.as_ref(), &project_dir)?;
+
+    // A shell tab spawns with an empty cmd (host default shell) — resolve the
+    // *in-container* shell instead: bash when the image has it, else sh.
+    let (cmd, cmd_args) = if opts.cmd.is_empty() {
+        (
+            "sh".to_string(),
+            vec![
+                "-c".to_string(),
+                "command -v bash >/dev/null 2>&1 && exec bash; exec sh".to_string(),
+            ],
+        )
+    } else {
+        (opts.cmd.clone(), opts.args.clone())
+    };
+
+    // opts.env is already resolved (ELDRUN_TAB_UID, resume args' env, etc.).
+    let env: BTreeMap<String, String> = opts.env.clone().into_iter().collect();
+    // Auth env is read at exec (not create) so rotated tokens are picked up
+    // per tab spawn.
+    let auth_env = host_auth_env();
+    let pidfile = register_exec_tab(&opts.id, &name);
+
+    opts.args = docker_exec_args(&name, &opts.cwd, &env, &auth_env, &pidfile, &cmd, &cmd_args);
+    opts.cmd = "docker".to_string();
+    // Env now rides inside the docker argv as `-e` flags; the docker client
+    // itself needs nothing from opts.env.
+    opts.env.clear();
+    Ok(())
+}
+
+// ── Container lifecycle ───────────────────────────────────────────────────
+
+/// Serializes every create/remove so racing project switches (or a switch
+/// racing a tab spawn) never interleave an `rm -f` with a `run` for the same
+/// container.
+fn lifecycle_lock() -> &'static Mutex<()> {
+    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| Mutex::new(()))
+}
+
+/// Container names created by THIS app run — bounds who `down_for_project`
+/// spawns docker for (a project that never went up needs no teardown attempt),
+/// and whether exit needs a `down_all` at all.
+fn created_set() -> &'static Mutex<HashSet<String>> {
+    static SET: OnceLock<Mutex<HashSet<String>>> = OnceLock::new();
+    SET.get_or_init(|| Mutex::new(HashSet::new()))
+}
+
+/// Idempotent "make the project's session container exist and match the spec".
+/// Returns the container name. Three-state: running+fingerprint-match → no-op;
+/// exists-but-stopped or fingerprint-mismatch → `rm -f` + create; missing →
+/// create. Called from the activation warm-up and from every containerized
+/// spawn (the fallback for tabs opened before activation completes).
+pub fn up(project_id: &str, spec: Option<&SandboxSpec>, project_dir: &str) -> Result<String, String> {
+    let _guard = lifecycle_lock().lock().unwrap();
+    preflight_docker()?;
+    preflight_daemon()?;
+
+    let name = container_name_for(project_id);
+    let home = paths::home_dir_string();
+    let (uid, gid) = host_uid_gid();
+    let state_dir = storage::state_dir();
+    let live_sessions = state_dir.join("live_sessions");
+    let hooks_dir = state_dir.join("hooks");
+    // Ensure the hook's write target and the staging dir exist so their bind
+    // mounts map real host paths rather than docker-auto-created (root-owned)
+    // ones. Best effort.
+    let _ = std::fs::create_dir_all(&live_sessions);
+    let stage = stage_dir(project_id);
+    let _ = std::fs::create_dir_all(&stage);
+
+    // Refresh the staged config copies from the host originals at every up.
+    // `fs::copy` overwrites in place (same inode), so a running container's
+    // bind mounts see the refreshed content too.
+    let mut rw_mounts = rw_mounts(&home, &live_sessions.to_string_lossy());
+    rw_mounts.extend(
+        staged_config_mounts(&home, &stage).into_iter().map(|(src, dst)| format!("{src}:{dst}")),
+    );
+    let ro_mounts = ro_mounts(&hooks_dir);
+    let harden = harden_opts(spec);
+    let image = image_for(project_id, spec);
+
+    // The create argv (sans fingerprint label) is its own fingerprint input.
+    let base = docker_create_args(
+        &name, project_id, &image, &home, uid, gid, project_dir, &rw_mounts, &ro_mounts, &harden,
+        None,
+    );
+    let fingerprint = spec_fingerprint(&base);
+
+    match up_decision(&probe_container(&name), &fingerprint) {
+        UpAction::UseExisting => {
+            created_set().lock().unwrap().insert(name.clone());
+            return Ok(name);
+        }
+        UpAction::Recreate => {
+            let _ = docker(&["rm", "-f", &name]);
+        }
+        UpAction::Create => {}
+    }
+
+    ensure_image(spec, project_dir, &image)?;
+
+    let args = docker_create_args(
+        &name,
+        project_id,
+        &image,
+        &home,
+        uid,
+        gid,
+        project_dir,
+        &rw_mounts,
+        &ro_mounts,
+        &harden,
+        Some(&fingerprint),
+    );
+    let argv: Vec<&str> = args.iter().map(String::as_str).collect();
+    let out = docker(&argv)?;
+    if !out.status.success() {
+        return Err(format!(
+            "Project container: docker run failed: {}",
+            stderr_tail(&out)
+        ));
+    }
+    created_set().lock().unwrap().insert(name.clone());
+    Ok(name)
+}
+
+/// Activation warm-up: `up()` for a project *iff* it is a container-toggled,
+/// local project. `Ok(None)` when the toggle is off / the project is remote /
+/// not on Unix — callers treat that as "nothing to do".
+pub fn up_for_project(project_id: &str) -> Result<Option<String>, String> {
+    #[cfg(not(unix))]
+    {
+        let _ = project_id;
+        Ok(None)
+    }
+    #[cfg(unix)]
+    {
+        if crate::services::remote::remote_target_for(project_id).is_some() {
+            return Ok(None);
+        }
+        let Some(spec) = sandbox_spec_for(project_id) else {
+            return Ok(None);
+        };
+        if !spec.enabled {
+            return Ok(None);
+        }
+        let dir = project_dir_for(project_id)
+            .ok_or_else(|| format!("project '{project_id}' has no directory"))?;
+        up(project_id, Some(&spec), &dir).map(Some)
+    }
+}
+
+/// Tear down a project's session container (`rm -f` by name). Idempotent,
+/// best-effort. Only spawns docker when this run actually created the container
+/// or the toggle is currently on — a never-containerized project costs nothing.
+pub fn down_for_project(project_id: &str) {
+    let name = container_name_for(project_id);
+    let created = created_set().lock().unwrap().contains(&name);
+    if !created && !sandbox_spec_for(project_id).is_some_and(|s| s.enabled) {
+        return;
+    }
+    let _guard = lifecycle_lock().lock().unwrap();
+    let _ = docker(&["rm", "-f", &name]);
+    created_set().lock().unwrap().remove(&name);
+    exec_tabs()
+        .lock()
+        .unwrap()
+        .retain(|_, t| t.container != name);
+}
+
+/// App-exit teardown: remove every eldrun-owned container. Skipped entirely
+/// when this run never created one (a crash's leftovers are `sweep_orphans`'s
+/// job next startup).
+pub fn down_all() {
+    if created_set().lock().unwrap().is_empty() {
+        return;
+    }
+    remove_all_owned();
+    created_set().lock().unwrap().clear();
+    exec_tabs().lock().unwrap().clear();
+}
+
+/// Startup sweep: remove every container labelled `eldrun.owner=eldrun` (a
+/// previous run's containers are by definition stale) and clear the staged
+/// config copies (recreated at each `up`). Best-effort; cheap no-op when
+/// docker is absent.
+pub fn sweep_orphans() {
+    let stage_root = storage::state_dir().join("sandbox-stage");
+    let _ = std::fs::remove_dir_all(&stage_root);
+    // Containers are Unix-only (`up_for_project` is a no-op and spawn refuses on
+    // Windows), so a previous run can't have left one behind — don't spawn
+    // `docker --version`/`docker ps` at every Windows startup for nothing.
+    if !cfg!(unix) || preflight_docker().is_err() {
+        return;
+    }
+    remove_all_owned();
+}
+
+/// `docker rm -f` every container carrying our owner label. Best-effort.
+fn remove_all_owned() {
+    let _guard = lifecycle_lock().lock().unwrap();
+    let Ok(out) = docker(&[
+        "ps",
+        "-aq",
+        "--filter",
+        &format!("label={OWNER_LABEL}"),
+    ]) else {
+        return;
+    };
+    let ids: Vec<&str> = std::str::from_utf8(&out.stdout)
+        .unwrap_or("")
+        .split_whitespace()
+        .collect();
+    if ids.is_empty() {
+        return;
+    }
+    let mut args = vec!["rm", "-f"];
+    args.extend(ids);
+    let _ = docker(&args);
+}
+
+/// Inspect the named container: does it exist, is it running, and which spec
+/// fingerprint was it created with?
+fn probe_container(name: &str) -> ContainerProbe {
+    let out = match docker(&[
+        "inspect",
+        "--format",
+        "{{.State.Running}}\t{{index .Config.Labels \"eldrun.spec\"}}",
+        name,
+    ]) {
+        Ok(o) if o.status.success() => o,
+        _ => return ContainerProbe::default(),
+    };
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let line = stdout.trim();
+    let (running, fp) = line.split_once('\t').unwrap_or((line, ""));
+    ContainerProbe {
+        exists: true,
+        running: running == "true",
+        fingerprint: (!fp.is_empty()).then(|| fp.to_string()),
+    }
+}
+
+/// Make the image runnable: build it from the project's in-repo Dockerfile when
+/// the spec says so, otherwise require it to already exist locally.
+fn ensure_image(spec: Option<&SandboxSpec>, project_dir: &str, image: &str) -> Result<(), String> {
+    if let Some(df) = spec.and_then(|s| s.dockerfile.as_deref()) {
+        let df_path = Path::new(project_dir).join(df);
+        let out = docker(&[
+            "build",
+            "-t",
+            image,
+            "-f",
+            &df_path.to_string_lossy(),
+            project_dir,
+        ])?;
+        if !out.status.success() {
+            return Err(format!(
+                "Project container: building '{df}' failed: {}",
+                stderr_tail(&out)
+            ));
+        }
+        return Ok(());
+    }
+    if image_exists(image) {
+        return Ok(());
+    }
+    Err(format!(
+        "Project container: image '{image}' not found. Toggle the container off and on again \
+         to get a one-click build, or provide the image yourself (`docker build -t {image} \
+         docker/agent-sandbox` from the Eldrun repo, or `docker pull` for a registry image)."
+    ))
+}
+
+// ── Preflight ─────────────────────────────────────────────────────────────
+
+/// `docker` binary present and runnable?
+fn preflight_docker() -> Result<(), String> {
+    match crate::paths::command_no_window("docker").arg("--version").output() {
+        Ok(o) if o.status.success() => Ok(()),
+        _ => Err(
+            "Project container: 'docker' not found. Install Docker, or turn the container \
+             toggle off for this project."
+                .to_string(),
+        ),
+    }
+}
+
+/// Daemon actually up? `docker --version` succeeds daemon-less, so a dead
+/// daemon must be diagnosed separately — "image missing" and "Docker isn't
+/// running" are different user actions.
+fn preflight_daemon() -> Result<(), String> {
+    match docker(&["info", "--format", "{{.ServerVersion}}"]) {
+        Ok(o) if o.status.success() => Ok(()),
+        _ => Err(
+            "Project container: Docker isn't running. Start the Docker service (e.g. \
+             `systemctl start docker`), or turn the container toggle off for this project."
+                .to_string(),
+        ),
+    }
+}
+
+fn image_exists(image: &str) -> bool {
+    docker(&["image", "inspect", image])
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// Toggle-time preflight verdict, surfaced to the frontend so a missing image
+/// becomes a one-click open-new-tab-paste-run build (house convention — never a
+/// copy-it-yourself message) instead of an error at the next tab spawn.
+#[derive(Debug, Clone, Serialize)]
+pub struct PreflightReport {
+    /// "ok" | "no_docker" | "daemon_down" | "image_missing"
+    pub status: String,
+    pub image: String,
+    /// For "image_missing": the shell command that provides the image — a
+    /// `docker build` of the in-repo/embedded reference Dockerfile for eldrun
+    /// images, a `docker pull` for registry images.
+    pub build_command: Option<String>,
+}
+
+/// Run the preflight for a project and describe the outcome (never errors —
+/// the caller renders the status).
+pub fn preflight_report(project_id: &str) -> PreflightReport {
+    let spec = sandbox_spec_for(project_id);
+    let image = image_for(project_id, spec.as_ref());
+    let report = |status: &str, build: Option<String>| PreflightReport {
+        status: status.to_string(),
+        image: image.clone(),
+        build_command: build,
+    };
+    if preflight_docker().is_err() {
+        return report("no_docker", None);
+    }
+    if preflight_daemon().is_err() {
+        return report("daemon_down", None);
+    }
+    // A dockerfile spec builds at `up`; nothing to pre-provide.
+    if spec.as_ref().is_some_and(|s| s.dockerfile.is_some()) {
+        return report("ok", None);
+    }
+    if image_exists(&image) {
+        return report("ok", None);
+    }
+    let build = build_command(project_id, &image);
+    report("image_missing", build)
+}
+
+/// The command that provides a missing image. Eldrun's own images build from
+/// `docker/agent-sandbox` when the project carries a checkout, else from an
+/// embedded copy of the reference Dockerfile materialized under the state dir
+/// (an installed app has no repo checkout). Anything else is a registry pull.
+fn build_command(project_id: &str, image: &str) -> Option<String> {
+    if image != DEFAULT_IMAGE && !image.starts_with("eldrun-") {
+        return Some(format!("docker pull {image}"));
+    }
+    if let Some(dir) = project_dir_for(project_id) {
+        let in_repo = Path::new(&dir).join("docker").join("agent-sandbox");
+        if in_repo.join("Dockerfile").is_file() {
+            return Some(format!("docker build -t {image} '{}'", in_repo.display()));
+        }
+    }
+    let stage = storage::state_dir().join("agent-sandbox");
+    std::fs::create_dir_all(&stage).ok()?;
+    std::fs::write(stage.join("Dockerfile"), REFERENCE_DOCKERFILE).ok()?;
+    Some(format!("docker build -t {image} '{}'", stage.display()))
+}
+
+// ── Tab-kill contract ─────────────────────────────────────────────────────
+
+/// A containerized tab's kill handle: which container it execs into and the
+/// in-container pidfile its kill-wrapper wrote.
+#[derive(Debug, Clone)]
+struct ExecTab {
+    container: String,
+    pidfile: String,
+}
+
+fn exec_tabs() -> &'static Mutex<HashMap<String, ExecTab>> {
+    static MAP: OnceLock<Mutex<HashMap<String, ExecTab>>> = OnceLock::new();
+    MAP.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// Register a containerized tab at spawn and mint its per-spawn pidfile path.
+/// The nonce keeps a respawn's pidfile distinct from its predecessor's, so
+/// killing the OLD process (below) can never race the NEW spawn's pidfile
+/// write. A previous registration for the same tab id (this is a respawn) is
+/// killed here — Docker does not kill an exec'd process when its client dies.
+fn register_exec_tab(tab_id: &str, container: &str) -> String {
+    static NONCE: AtomicU64 = AtomicU64::new(0);
+    let n = NONCE.fetch_add(1, Ordering::Relaxed);
+    let pidfile = format!("/tmp/eldrun-tab-{}-{n}.pid", sanitize_key(tab_id));
+    let tab = ExecTab {
+        container: container.to_string(),
+        pidfile: pidfile.clone(),
+    };
+    if let Some(old) = exec_tabs().lock().unwrap().insert(tab_id.to_string(), tab) {
+        spawn_kill(old);
+    }
+    pidfile
+}
+
+/// Kill the in-container process of a (possibly former) containerized tab.
+/// Called from `PtyRegistry::kill` on tab close — killing the PTY child only
+/// kills the `docker exec` *client*; the agent inside would otherwise keep
+/// running until session end. Cheap no-op for tabs that never containerized.
+pub fn kill_tab_process(tab_id: &str) {
+    if let Some(tab) = exec_tabs().lock().unwrap().remove(tab_id) {
+        spawn_kill(tab);
+    }
+}
+
+/// TERM the recorded pid (preferring its process group) inside the container,
+/// then drop the pidfile. Own thread + best-effort: the container may already
+/// be gone, which is fine — teardown is what bounds stragglers.
+fn spawn_kill(tab: ExecTab) {
+    std::thread::spawn(move || {
+        let script = format!(
+            "p=$(cat {pf} 2>/dev/null); [ -n \"$p\" ] && \
+             (kill -TERM -- \"-$p\" 2>/dev/null || kill -TERM \"$p\" 2>/dev/null); rm -f {pf}",
+            pf = tab.pidfile
+        );
+        let _ = docker(&["exec", &tab.container, "sh", "-c", &script]);
+    });
+}
+
+// ── Spec / project resolution ─────────────────────────────────────────────
+
+/// Read the sandbox spec for `project_id` from the always-local `projects.json`
+/// entry's flattened `extra["sandbox"]`. `None` when unknown/unparseable — the
+/// caller then falls back to defaults. Mirrors `remote::remote_target_for`.
+pub fn sandbox_spec_for(project_id: &str) -> Option<SandboxSpec> {
+    let entry_value = project_entry_value(project_id, "sandbox")?;
+    serde_json::from_value(entry_value).ok()
+}
+
+/// The project's directory (the bind-mount root), from the `projects.json`
+/// entry's flattened `extra["directory"]`, falling back to `project.json`.
+pub fn project_dir_for(project_id: &str) -> Option<String> {
+    if let Some(v) = project_entry_value(project_id, "directory") {
+        if let Some(s) = v.as_str() {
+            if !s.is_empty() {
+                return Some(s.to_string());
+            }
+        }
+    }
+    let list_path = storage::state_dir().join("projects.json");
+    let list: crate::schema::projects::ProjectsList = storage::read_json(&list_path).ok()?;
+    let entry = list.iter().find(|e| e.id == project_id)?;
+    let project: crate::schema::project::Project =
+        storage::read_json(Path::new(&entry.local_file)).ok()?;
+    (!project.directory.is_empty()).then_some(project.directory)
+}
+
+fn project_entry_value(project_id: &str, key: &str) -> Option<serde_json::Value> {
+    let list_path = storage::state_dir().join("projects.json");
+    let list: crate::schema::projects::ProjectsList = storage::read_json(&list_path).ok()?;
+    let entry = list.iter().find(|e| e.id == project_id)?;
+    entry.extra.get(key).cloned()
+}
+
+/// Detect in-repo container sources for a project whose toggle is being enabled
+/// for the first time: a root `Dockerfile` wins, else a
+/// `.devcontainer/devcontainer.json` `image` field. Leaves `spec` untouched
+/// when neither is present (the default image applies).
+pub fn detect_spec_sources(project_dir: &Path, spec: &mut SandboxSpec) {
+    if project_dir.join("Dockerfile").is_file() {
+        spec.dockerfile = Some("Dockerfile".to_string());
+        return;
+    }
+    let devcontainer = project_dir.join(".devcontainer").join("devcontainer.json");
+    if let Ok(text) = std::fs::read_to_string(&devcontainer) {
+        // devcontainer.json is JSONC; strip line comments so serde can parse
+        // the common case. (A devcontainer that only names a Dockerfile/compose
+        // setup has no `image` and is simply not auto-detected.)
+        let stripped: String = text
+            .lines()
+            .filter(|l| !l.trim_start().starts_with("//"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(&stripped) {
+            if let Some(image) = v.get("image").and_then(|i| i.as_str()) {
+                if !image.is_empty() {
+                    spec.image = Some(image.to_string());
+                }
+            }
+        }
+    }
+}
+
+// ── Mounts / identity (shared helpers) ────────────────────────────────────
+
+/// Read-write identical-path mounts: the agent auth/state dirs the resume
+/// machinery depends on. `~/.claude`/`~/.codex` and Gemini creds are mounted only
+/// when they exist so we never auto-create empty root-owned dirs in `$HOME`.
+fn rw_mounts(home: &str, live_sessions: &str) -> Vec<String> {
+    let mut m = Vec::new();
+    for cand in [format!("{home}/.claude"), format!("{home}/.codex")] {
+        if Path::new(&cand).is_dir() {
+            m.push(format!("{cand}:{cand}"));
+        }
+    }
+    // The in-container SessionStart hook writes a tab's live id here.
+    m.push(format!("{live_sessions}:{live_sessions}"));
+    // Gemini credentials only — narrowed from the whole `~/.config` so unrelated
+    // secrets (`gh`, `gcloud`, …) are never exposed to the container.
+    for cand in [format!("{home}/.gemini"), format!("{home}/.config/gemini")] {
+        if Path::new(&cand).is_dir() {
+            m.push(format!("{cand}:{cand}"));
+        }
+    }
+    m
+}
+
+/// Read-only identical-path mounts: just the hook *script* dir, which is shared
+/// with host-run agents and so must be immutable from inside the container (see
+/// the module doc). Mounted only when it exists on the host.
+fn ro_mounts(hooks_dir: &Path) -> Vec<String> {
+    let mut m = Vec::new();
+    if hooks_dir.is_dir() {
+        let h = hooks_dir.to_string_lossy();
+        m.push(format!("{h}:{h}"));
+    }
+    m
+}
+
+/// Per-project staging dir for the writable hook-config copies:
+/// `<state_dir>/sandbox-stage/<sanitized project id>`. One dir per project
+/// (mounts are fixed at create), refreshed at each `up` — no per-tab leak.
+fn stage_dir(project_id: &str) -> PathBuf {
+    storage::state_dir()
+        .join("sandbox-stage")
+        .join(sanitize_key(project_id))
+}
+
+/// Copy the agents' hook-registration files into the per-project `stage` dir
+/// and return rw mounts of the *copies* at the files' identical container
+/// paths. The container thus gets writable settings it can freely rewrite (so
+/// agents that persist config don't error) while the host originals are
+/// shadowed and never touched — a compromised agent cannot repoint the host's
+/// SessionStart hook. Best effort: a file that is absent or fails to copy is
+/// simply not mounted.
+///
+/// Returned as `(copy on host, original path)` **pairs**, not pre-joined
+/// `src:dst` strings: a host path is not colon-free on every platform (a
+/// Windows drive letter carries one), so joining here would hand the caller a
+/// string it cannot split back apart unambiguously.
+fn staged_config_mounts(home: &str, stage: &Path) -> Vec<(String, String)> {
+    let home = Path::new(home);
+    let mut mounts = Vec::new();
+    for rel in [".claude/settings.json", ".claude/settings.local.json", ".codex/config.toml"] {
+        // Native separators: the container path is the host original's own path.
+        let src_path = rel.split('/').fold(home.to_path_buf(), |p, seg| p.join(seg));
+        if !src_path.is_file() {
+            continue;
+        }
+        // Flatten the host path to a unique leaf so the three files never collide.
+        let src = src_path.to_string_lossy().into_owned();
+        let leaf = src.trim_start_matches(['/', '\\']).replace(['/', '\\', ':'], "_");
+        let dst = stage.join(&leaf);
+        if std::fs::copy(&src_path, &dst).is_ok() {
+            mounts.push((dst.to_string_lossy().into_owned(), src));
+        }
+    }
+    mounts
+}
+
+/// Build the runtime hardening flags from a project's spec, applying built-in
+/// defaults (always-on `--pids-limit`; other caps opt-in).
+fn harden_opts(spec: Option<&SandboxSpec>) -> HardenOpts {
+    HardenOpts {
+        pids_limit: spec.and_then(|s| s.pids_limit).unwrap_or(DEFAULT_PIDS_LIMIT),
+        memory: spec.and_then(|s| s.memory.clone()),
+        cpus: spec.and_then(|s| s.cpus.clone()),
+        network: spec.and_then(|s| s.network.clone()),
+        readonly_rootfs: spec.map(|s| s.readonly_rootfs).unwrap_or(false),
+    }
+}
+
+/// Agent-auth env vars present on the host process, forwarded into the
+/// container at exec time (which inherits none of the host env). Sorted for
+/// determinism.
+fn host_auth_env() -> BTreeMap<String, String> {
+    let mut out = BTreeMap::new();
+    for &k in crate::services::ssh_exec::AGENT_AUTH_ENV {
+        if let Ok(v) = std::env::var(k) {
+            if !v.is_empty() {
+                out.insert(k.to_string(), v);
+            }
+        }
+    }
+    out
+}
+
+fn docker(args: &[&str]) -> Result<std::process::Output, String> {
+    crate::paths::command_no_window("docker")
+        .args(args)
+        .output()
+        .map_err(|e| format!("run docker: {e}"))
+}
+
+/// Last non-empty stderr line — docker's errors are one-liners at the tail.
+fn stderr_tail(out: &std::process::Output) -> String {
+    String::from_utf8_lossy(&out.stderr)
+        .lines()
+        .rev()
+        .find(|l| !l.trim().is_empty())
+        .unwrap_or("(no error output)")
+        .to_string()
+}
+
+#[cfg(unix)]
+fn host_uid_gid() -> (u32, u32) {
+    // Safe: geteuid/getegid have no preconditions and cannot fail.
+    unsafe { (libc::geteuid(), libc::getegid()) }
+}
+
+#[cfg(not(unix))]
+fn host_uid_gid() -> (u32, u32) {
+    (0, 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn env(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
+        pairs
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect()
+    }
+
+    fn args(strs: &[&str]) -> Vec<String> {
+        strs.iter().map(|s| s.to_string()).collect()
+    }
+
+    /// Index of `needle` in `v`, or None.
+    fn pos(v: &[String], needle: &str) -> Option<usize> {
+        v.iter().position(|s| s == needle)
+    }
+
+    /// True if `v` contains the consecutive pair `flag value`.
+    fn has_flag_value(v: &[String], flag: &str, value: &str) -> bool {
+        v.windows(2).any(|w| w[0] == flag && w[1] == value)
+    }
+
+    /// Standard rw/ro mount sets used by the argv tests. `rw` includes a staged
+    /// (writable copy) settings.json mount whose dst is the container path.
+    fn rw(home: &str) -> Vec<String> {
+        vec![
+            format!("{home}/.claude:{home}/.claude"),
+            format!("{home}/.codex:{home}/.codex"),
+            "/state/live_sessions:/state/live_sessions".to_string(),
+            format!("/state/sandbox-stage/p1/_home_alice_.claude_settings.json:{home}/.claude/settings.json"),
+        ]
+    }
+    fn ro() -> Vec<String> {
+        // Only the hook script dir is read-only; registration files are
+        // writable per-project copies (see `staged_config_mounts`).
+        vec!["/state/hooks:/state/hooks".to_string()]
+    }
+
+    fn create(fingerprint: Option<&str>) -> Vec<String> {
+        docker_create_args(
+            "eldrun-p1",
+            "p1",
+            "img:latest",
+            "/home/alice",
+            1000,
+            1000,
+            "/home/alice/eldrun/projects/p1",
+            &rw("/home/alice"),
+            &ro(),
+            &HardenOpts::default(),
+            fingerprint,
+        )
+    }
+
+    // ── Naming / fingerprint ──────────────────────────────────────────────
+
+    #[test]
+    fn container_name_is_sanitized_and_prefixed() {
+        assert_eq!(container_name_for("p1"), "eldrun-p1");
+        assert_eq!(container_name_for("my proj/α"), "eldrun-my_proj__");
+        assert_eq!(container_name_for(""), "eldrun-x");
+    }
+
+    #[test]
+    fn fingerprint_is_stable_and_input_sensitive() {
+        let a = spec_fingerprint(&create(None));
+        let b = spec_fingerprint(&create(None));
+        assert_eq!(a, b, "same argv must hash identically");
+        assert_eq!(a.len(), 16);
+
+        let mut other = create(None);
+        let img = pos(&other, "img:latest").unwrap();
+        other[img] = "img:v2".to_string();
+        assert_ne!(a, spec_fingerprint(&other), "image change must change the hash");
+
+        // Boundary sensitivity: ["ab","c"] vs ["a","bc"].
+        assert_ne!(
+            spec_fingerprint(&args(&["ab", "c"])),
+            spec_fingerprint(&args(&["a", "bc"]))
+        );
+    }
+
+    // ── up decision table ─────────────────────────────────────────────────
+
+    #[test]
+    fn up_decision_table() {
+        let fp = "abc123";
+        let missing = ContainerProbe::default();
+        assert_eq!(up_decision(&missing, fp), UpAction::Create);
+
+        let running_match = ContainerProbe {
+            exists: true,
+            running: true,
+            fingerprint: Some(fp.to_string()),
+        };
+        assert_eq!(up_decision(&running_match, fp), UpAction::UseExisting);
+
+        let stopped = ContainerProbe {
+            exists: true,
+            running: false,
+            fingerprint: Some(fp.to_string()),
+        };
+        assert_eq!(up_decision(&stopped, fp), UpAction::Recreate);
+
+        let mismatch = ContainerProbe {
+            exists: true,
+            running: true,
+            fingerprint: Some("other".to_string()),
+        };
+        assert_eq!(up_decision(&mismatch, fp), UpAction::Recreate);
+
+        let unlabeled = ContainerProbe {
+            exists: true,
+            running: true,
+            fingerprint: None,
+        };
+        assert_eq!(up_decision(&unlabeled, fp), UpAction::Recreate);
+    }
+
+    // ── create argv ───────────────────────────────────────────────────────
+
+    #[test]
+    fn create_argv_has_mounts_identity_hardening_labels_and_sleeps() {
+        let out = create(Some("deadbeef00000000"));
+
+        assert_eq!(out[0], "run");
+        assert!(out.contains(&"-d".to_string()));
+        assert!(out.contains(&"--init".to_string()));
+        assert!(has_flag_value(&out, "--name", "eldrun-p1"));
+        assert!(has_flag_value(&out, "--label", OWNER_LABEL));
+        assert!(has_flag_value(&out, "--label", "eldrun.project=p1"));
+        assert!(has_flag_value(&out, "--label", "eldrun.spec=deadbeef00000000"));
+        assert!(has_flag_value(&out, "--user", "1000:1000"));
+        assert!(has_flag_value(&out, "-e", "HOME=/home/alice"));
+        assert!(has_flag_value(&out, "-w", "/home/alice/eldrun/projects/p1"));
+        // Hardening always on.
+        assert!(has_flag_value(&out, "--security-opt", "no-new-privileges"));
+        assert!(has_flag_value(&out, "--cap-drop", "ALL"));
+        assert!(has_flag_value(&out, "--pids-limit", &DEFAULT_PIDS_LIMIT.to_string()));
+        // Project dir always mounted rw at its identical path.
+        assert!(has_flag_value(
+            &out,
+            "-v",
+            "/home/alice/eldrun/projects/p1:/home/alice/eldrun/projects/p1"
+        ));
+        // rw auth mounts.
+        assert!(has_flag_value(&out, "-v", "/home/alice/.claude:/home/alice/.claude"));
+        assert!(has_flag_value(&out, "-v", "/state/live_sessions:/state/live_sessions"));
+        // The hook script dir is read-only (:ro suffix)...
+        assert!(has_flag_value(&out, "-v", "/state/hooks:/state/hooks:ro"));
+        // ...but settings.json is a writable per-PROJECT copy shadowing the
+        // host path: mounted rw (no :ro), source is the staged copy.
+        assert!(has_flag_value(
+            &out,
+            "-v",
+            "/state/sandbox-stage/p1/_home_alice_.claude_settings.json:/home/alice/.claude/settings.json"
+        ));
+        assert!(
+            !out.iter().any(|s| s.ends_with(
+                "/home/alice/.claude/settings.json:/home/alice/.claude/settings.json:ro"
+            )),
+            "host settings.json must not be mounted read-only in place"
+        );
+        // The container's sole job is to exist: image, then `sleep infinity`.
+        let img = pos(&out, "img:latest").expect("image present");
+        assert_eq!(&out[img + 1..], &["sleep", "infinity"]);
+        // No `--rm`: lifetime is owned by up/down, not by process exit.
+        assert!(pos(&out, "--rm").is_none());
+    }
+
+    #[test]
+    fn create_argv_without_fingerprint_omits_spec_label_only() {
+        let bare = create(None);
+        let labeled = create(Some("feedface00000000"));
+        assert!(!bare.iter().any(|s| s.starts_with("eldrun.spec=")));
+        assert_eq!(labeled.len(), bare.len() + 2, "fingerprint adds exactly --label + value");
+        assert!(has_flag_value(&labeled, "--label", "eldrun.spec=feedface00000000"));
+    }
+
+    #[test]
+    fn optional_resource_and_network_caps_appear_only_when_set() {
+        let none = create(None);
+        assert!(pos(&none, "--memory").is_none());
+        assert!(pos(&none, "--cpus").is_none());
+        assert!(pos(&none, "--network").is_none());
+        assert!(pos(&none, "--read-only").is_none());
+
+        let harden = HardenOpts {
+            pids_limit: 256,
+            memory: Some("4g".to_string()),
+            cpus: Some("2".to_string()),
+            network: Some("none".to_string()),
+            readonly_rootfs: true,
+        };
+        let out = docker_create_args(
+            "eldrun-p1", "p1", "img", "/h", 1, 1, "/p", &[], &[], &harden, None,
+        );
+        assert!(has_flag_value(&out, "--pids-limit", "256"));
+        assert!(has_flag_value(&out, "--memory", "4g"));
+        assert!(has_flag_value(&out, "--cpus", "2"));
+        assert!(has_flag_value(&out, "--network", "none"));
+        assert!(has_flag_value(&out, "--tmpfs", "/tmp"));
+        assert!(out.contains(&"--read-only".to_string()));
+    }
+
+    // ── exec argv ─────────────────────────────────────────────────────────
+
+    #[test]
+    fn exec_argv_has_cwd_env_killwrapper_and_preserves_resume_args() {
+        let envs = env(&[("ELDRUN_TAB_UID", "tab-1")]);
+        let auth = env(&[("ANTHROPIC_API_KEY", "sk-test")]);
+        let out = docker_exec_args(
+            "eldrun-p1",
+            "/home/alice/eldrun/projects/p1/sub",
+            &envs,
+            &auth,
+            "/tmp/eldrun-tab-t1-0.pid",
+            "claude",
+            &args(&["--resume", "uuid-1"]),
+        );
+
+        assert_eq!(out[0], "exec");
+        assert!(out.contains(&"-i".to_string()));
+        assert!(out.contains(&"-t".to_string()));
+        // Per-tab cwd (subdir tabs stay correct under identical-path mounting).
+        assert!(has_flag_value(&out, "-w", "/home/alice/eldrun/projects/p1/sub"));
+        assert!(has_flag_value(&out, "-e", "TERM=xterm-256color"));
+        assert!(has_flag_value(&out, "-e", "ELDRUN_TAB_UID=tab-1"));
+        // Auth env rides at exec (rotated tokens per spawn), before the name.
+        assert!(has_flag_value(&out, "-e", "ANTHROPIC_API_KEY=sk-test"));
+        let key = out.iter().position(|s| s == "ANTHROPIC_API_KEY=sk-test").unwrap();
+        let name = pos(&out, "eldrun-p1").unwrap();
+        assert!(key < name, "env must precede the container name");
+        // Kill-wrapper shape: name, sh -c '<pidfile script>' sh <cmd> <args…>.
+        assert_eq!(out[name + 1], "sh");
+        assert_eq!(out[name + 2], "-c");
+        assert_eq!(out[name + 3], "echo $$ > /tmp/eldrun-tab-t1-0.pid; exec \"$@\"");
+        assert_eq!(out[name + 4], "sh");
+        // Original command + resume args preserved in order after the wrapper.
+        assert_eq!(&out[name + 5..], &["claude", "--resume", "uuid-1"]);
+    }
+
+    #[test]
+    fn exec_argv_codex_resume_order_preserved() {
+        let out = docker_exec_args(
+            "eldrun-p1",
+            "/p",
+            &BTreeMap::new(),
+            &BTreeMap::new(),
+            "/tmp/eldrun-tab-t2-1.pid",
+            "codex",
+            &args(&["resume", "live-id"]),
+        );
+        // `-c <script> sh` precede the real command ($0 is the literal "sh").
+        let sh = pos(&out, "-c").unwrap();
+        assert_eq!(out[sh + 2], "sh");
+        assert_eq!(&out[sh + 3..], &["codex", "resume", "live-id"]);
+    }
+
+    // ── stage dir ─────────────────────────────────────────────────────────
+
+    #[test]
+    fn staged_config_mounts_copies_and_shadows_host_originals() {
+        // Fake home with a settings.json; a distinct stage dir. Both under the
+        // OS temp dir, keyed by pid so parallel test runs don't collide.
+        let base = std::env::temp_dir().join(format!("eldrun-sbx-{}", std::process::id()));
+        let home = base.join("home");
+        let stage = base.join("stage");
+        let claude = home.join(".claude");
+        std::fs::create_dir_all(&claude).unwrap();
+        std::fs::create_dir_all(&stage).unwrap();
+        let settings = claude.join("settings.json");
+        std::fs::write(&settings, b"{\"hooks\":{}}").unwrap();
+
+        let home_str = home.to_string_lossy().into_owned();
+        let mounts = staged_config_mounts(&home_str, &stage);
+
+        // Exactly one mount (only settings.json exists), dst == the host path.
+        assert_eq!(mounts.len(), 1, "got: {mounts:?}");
+        let (src, dst) = (mounts[0].0.clone(), mounts[0].1.clone());
+        assert_eq!(dst, settings.to_string_lossy());
+        // Source is a real copy living under the stage dir, not the host file.
+        assert!(Path::new(&src).starts_with(&stage));
+        assert_ne!(Path::new(&src), settings.as_path());
+        assert_eq!(std::fs::read(&src).unwrap(), b"{\"hooks\":{}}");
+
+        // Refresh-at-up: a second pass overwrites the same single copy in
+        // place (same path, new content) — never a second file.
+        std::fs::write(&settings, b"{\"hooks\":{\"v\":2}}").unwrap();
+        let again = staged_config_mounts(&home_str, &stage);
+        assert_eq!(again, mounts, "mount list must be stable across refreshes");
+        assert_eq!(std::fs::read(src).unwrap(), b"{\"hooks\":{\"v\":2}}");
+        assert_eq!(
+            std::fs::read_dir(&stage).unwrap().count(),
+            1,
+            "one staged copy per file, refreshed in place"
+        );
+
+        std::fs::remove_dir_all(&base).ok();
+    }
+
+    // ── spec sources ──────────────────────────────────────────────────────
+
+    #[test]
+    fn detect_spec_sources_prefers_dockerfile_then_devcontainer_image() {
+        let base = std::env::temp_dir().join(format!("eldrun-det-{}", std::process::id()));
+        std::fs::create_dir_all(&base).unwrap();
+
+        // Nothing present → spec untouched.
+        let mut spec = SandboxSpec::default();
+        detect_spec_sources(&base, &mut spec);
+        assert_eq!(spec.dockerfile, None);
+        assert_eq!(spec.image, None);
+
+        // devcontainer image (JSONC comments tolerated).
+        let dc = base.join(".devcontainer");
+        std::fs::create_dir_all(&dc).unwrap();
+        std::fs::write(
+            dc.join("devcontainer.json"),
+            b"{\n  // dev image\n  \"image\": \"mcr.example/devbox:1\"\n}",
+        )
+        .unwrap();
+        let mut spec = SandboxSpec::default();
+        detect_spec_sources(&base, &mut spec);
+        assert_eq!(spec.image.as_deref(), Some("mcr.example/devbox:1"));
+        assert_eq!(spec.dockerfile, None);
+
+        // A root Dockerfile wins over the devcontainer.
+        std::fs::write(base.join("Dockerfile"), b"FROM debian:stable").unwrap();
+        let mut spec = SandboxSpec::default();
+        detect_spec_sources(&base, &mut spec);
+        assert_eq!(spec.dockerfile.as_deref(), Some("Dockerfile"));
+        assert_eq!(spec.image, None);
+
+        std::fs::remove_dir_all(&base).ok();
+    }
+
+    #[test]
+    fn image_for_prefers_dockerfile_tag_then_override_then_default() {
+        assert_eq!(image_for("p1", None), DEFAULT_IMAGE);
+        let with_image = SandboxSpec {
+            image: Some("python:3.12".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(image_for("p1", Some(&with_image)), "python:3.12");
+        let with_df = SandboxSpec {
+            image: Some("python:3.12".to_string()),
+            dockerfile: Some("Dockerfile".to_string()),
+            ..Default::default()
+        };
+        assert_eq!(image_for("p1", Some(&with_df)), "eldrun-p1:latest");
+    }
+
+    // ── wrap ──────────────────────────────────────────────────────────────
+
+    #[test]
+    fn wrap_is_noop_when_sandbox_disabled() {
+        let mut opts = PtyOptions {
+            id: "t".to_string(),
+            cmd: "claude".to_string(),
+            args: args(&["--session-id", "x"]),
+            env: Default::default(),
+            cwd: "/proj".to_string(),
+            cols: 80,
+            rows: 24,
+            local_only: false,
+            sandbox: false,
+            project_id: None,
+            remote_host_id: None,
+            tmux_session: None,
+            tmux_attach: None,
+        };
+        wrap_pty_options_docker(&mut opts).unwrap();
+        assert_eq!(opts.cmd, "claude");
+        assert_eq!(opts.args, args(&["--session-id", "x"]));
+    }
+
+    #[test]
+    fn register_exec_tab_mints_unique_pidfiles_per_respawn() {
+        let a = register_exec_tab("tab/α:1", "eldrun-p1");
+        let b = register_exec_tab("tab/α:1", "eldrun-p1");
+        assert_ne!(a, b, "a respawn must never reuse its predecessor's pidfile");
+        assert!(a.starts_with("/tmp/eldrun-tab-tab___1-"));
+        assert!(a.ends_with(".pid"));
+        // Cleanup so other tests never see this entry.
+        exec_tabs().lock().unwrap().remove("tab/α:1");
+    }
+}
diff --git a/src-tauri/src/services/sftp.rs b/src-tauri/src/services/sftp.rs
new file mode 100644
index 0000000..8bcc222
--- /dev/null
+++ b/src-tauri/src/services/sftp.rs
@@ -0,0 +1,1139 @@
+//! Native SFTP session for the remote folder browser (TODO #80).
+//!
+//! This replaces the `ssh … ls -1Ap` shell-out the browse commands used to do.
+//! We open the **SFTP subsystem** over a child `ssh -s sftp` process and speak
+//! the binary SFTP protocol to it, so:
+//!   - directory listings carry real file-type metadata (no `ls -p` trailing-`/`
+//!     guessing), and
+//!   - remote path components are protocol fields, never concatenated into a
+//!     remote `$SHELL -c` string — the command-injection class that
+//!     `shell_quote`/`validate_arg` exist to defend against simply cannot occur
+//!     here (a directory named `foo; rm -rf ~` is one inert listing entry).
+//!
+//! Only the *browse* path moves to SFTP. Remote **agent/terminal** tabs run over
+//! `ssh -tt` (see #28b). Auth is shared with those paths: key/agent in
+//! `BatchMode=yes`, or — when a password is supplied — fed to ssh via OpenSSH's
+//! own `SSH_ASKPASS` (`services::ssh_common::make_askpass`; on Windows only with
+//! OpenSSH ≥ 8.4, else the legacy `sshpass` fallback).
+
+use std::process::Stdio;
+
+use futures_util::StreamExt;
+use openssh_sftp_client::{Sftp, SftpOptions};
+use tokio::process::{Child, ChildStderr, Command};
+
+use crate::services::ssh_common::{
+    explain_ssh_error, ssh_base_args, ssh_master_base_args, ssh_passphrase_base_args,
+    ssh_passphrase_master_base_args, ssh_password_base_args, ssh_password_master_base_args,
+    validate_arg,
+};
+
+/// How much of ssh's stderr to keep. Auth failures are a line or two; the cap only
+/// exists so a long-lived master that chatters for hours can't grow unbounded.
+const STDERR_KEEP: usize = 4096;
+
+/// Drain the child ssh's stderr to EOF on a background task, keeping the last
+/// [`STDERR_KEEP`] bytes, and hand back a handle that yields them.
+///
+/// Draining is not optional once stderr is piped: the pooled master lives for the
+/// whole session, and an unread pipe that fills would block ssh forever. So the
+/// task runs to EOF (i.e. until ssh exits) either way — on the happy path it just
+/// throws the bytes away.
+///
+/// This is what makes a headless failure legible at all. Both openers used to set
+/// `Stdio::null()`, so when a wrong password made ssh exit, the SFTP handshake saw
+/// only a closed pipe and the user got `pooled sftp connection failed: <EOF>` —
+/// the actual reason ("Permission denied") had been thrown away.
+fn drain_stderr(mut stderr: ChildStderr) -> tokio::task::JoinHandle<String> {
+    use tokio::io::AsyncReadExt;
+    tokio::spawn(async move {
+        let mut kept: Vec<u8> = Vec::new();
+        let mut chunk = [0u8; 1024];
+        loop {
+            match stderr.read(&mut chunk).await {
+                Ok(0) | Err(_) => break, // EOF, or the pipe broke — either way, done
+                Ok(n) => {
+                    kept.extend_from_slice(&chunk[..n]);
+                    if kept.len() > STDERR_KEEP {
+                        kept.drain(..kept.len() - STDERR_KEEP);
+                    }
+                }
+            }
+        }
+        String::from_utf8_lossy(&kept).trim().to_string()
+    })
+}
+
+/// Turn a failed SFTP handshake into the reason ssh actually gave. The handshake
+/// error itself is just "the pipe closed"; the *why* is on ssh's stderr, so wait
+/// briefly for the drain (ssh has already exited, so this returns at once) and
+/// prefer its explanation. Falls back to the raw stderr, then to the handshake
+/// error, so no information is ever lost — only re-ranked by usefulness.
+/// Returns `(explained, raw stderr)`. The raw text is kept, not just folded into
+/// the message, because the auth-method loop in [`open_any`] has to distinguish a
+/// *local* failure (a wrong key passphrase) from a server-side one, and the
+/// explained form is deliberately lossy.
+async fn handshake_error(
+    drain: Option<tokio::task::JoinHandle<String>>,
+    err: String,
+) -> (String, String) {
+    let stderr = match drain {
+        Some(handle) => {
+            tokio::time::timeout(std::time::Duration::from_secs(3), handle)
+                .await
+                .ok()
+                .and_then(Result::ok)
+                .unwrap_or_default()
+        }
+        None => String::new(),
+    };
+    if stderr.is_empty() {
+        return (err, stderr);
+    }
+    let explained = explain_ssh_error(&stderr).unwrap_or_else(|| stderr.clone());
+    (explained, stderr)
+}
+
+/// Prefer the prompt the askpass shim refused over whatever ssh said afterwards.
+/// A refusal ends the handshake as a plain auth failure, so without this the user
+/// is told "Permission denied" for a host that actually asked them for a
+/// verification code — see `ssh_common::Askpass`. Must run before the guard drops.
+#[cfg(any(unix, windows))]
+fn refusal_override(
+    askpass: &Option<crate::services::ssh_common::Askpass>,
+    err: String,
+) -> String {
+    match askpass.as_ref().and_then(|a| a.refused_prompt()) {
+        Some(prompt) => crate::services::ssh_common::unexpected_prompt_error(&prompt),
+        None => err,
+    }
+}
+
+/// One entry in a remote directory listing. Structurally identical to the
+/// frontend-facing `commands::ssh::RemoteEntry`; kept separate so this service
+/// stays free of the command layer (the command maps one to the other).
+///
+/// `size`/`modified_secs` come from the `readdir`-supplied attributes (no extra
+/// round-trip), so the file browser can show the same metadata columns local
+/// listings do. They are best-effort: a server that omits an attribute yields
+/// `0`/`None`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Entry {
+    pub name: String,
+    pub is_dir: bool,
+    /// File size in bytes from the listing attrs (`0` when absent or a dir).
+    pub size: u64,
+    /// Last-modified time as whole seconds since the Unix epoch, when reported.
+    pub modified_secs: Option<u64>,
+}
+
+/// Build the argv for invoking the remote SFTP subsystem. `base` is the validated
+/// option+target list (`ssh_base_args`/`ssh_password_base_args`), whose **last**
+/// element is the `[user@]host` target. OpenSSH requires options before the
+/// destination, so we splice `-s` in front of the target and append the
+/// subsystem name `sftp` as the remote command: `ssh <opts> -s <target> sftp`.
+fn sftp_subsystem_args(mut base: Vec<String>) -> Result<Vec<String>, String> {
+    let target = base
+        .pop()
+        .ok_or_else(|| "internal: empty ssh base args".to_string())?;
+    base.push("-s".to_string());
+    base.push(target);
+    base.push("sftp".to_string());
+    Ok(base)
+}
+
+/// Spawn `ssh -s sftp` with piped stdin/stdout and hand the pipes to an `Sftp`
+/// client. Returns the live client plus the child so the caller can await its exit
+/// after dropping the client (dropping closes stdin, which makes ssh exit).
+///
+/// For password auth the secret is fed via OpenSSH's `SSH_ASKPASS` (on Windows
+/// only when OpenSSH ≥ 8.4 honors `SSH_ASKPASS_REQUIRE`; older installs fall back
+/// to `sshpass -e`). The askpass guard is kept in scope until the function
+/// returns so the shim exists throughout the ssh handshake (auth happens during
+/// `Sftp::new`, not merely at spawn).
+async fn open_session(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+) -> Result<(Sftp, Child), String> {
+    open_any(user, host, port, password, false).await
+}
+
+/// The auth-method loop both openers share: key/agent when no secret was typed,
+/// otherwise each kind in [`secret_attempt_order`](crate::services::ssh_common::secret_attempt_order)
+/// until one authenticates. `master` selects the master-owning argv builders.
+///
+/// Attempting more than once is what lets a single credential field serve a host
+/// whose key is locked *and* a host that wants a login password, without the user
+/// having to know which they are giving us — see `secret_attempt_order` for why
+/// the order is a security property rather than a preference. The loop stops early
+/// on a wrong *passphrase*, since retrying that secret as a password would send it
+/// to the server.
+async fn open_any(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    master: bool,
+) -> Result<(Sftp, Child), String> {
+    use crate::services::ssh_common::SecretKind;
+
+    let what = if master {
+        "pooled sftp connection failed"
+    } else {
+        "sftp connection failed"
+    };
+
+    let Some(pw) = password.filter(|p| !p.is_empty()) else {
+        let base = if master {
+            ssh_master_base_args(user, host, port)?
+        } else {
+            ssh_base_args(user, host, port)?
+        };
+        let args = sftp_subsystem_args(base)?;
+        let mut cmd = Command::new("ssh");
+        cmd.args(&args);
+        return match spawn_sftp(cmd, None, None, what).await {
+            // A key-auth denial against a host whose key is encrypted on disk is
+            // the one failure OpenSSH cannot explain itself: `BatchMode=yes` means
+            // it never asked for the passphrase, so all the user sees is
+            // "Permission denied (publickey)". Say what actually happened.
+            Err((err, _)) => Err(match crate::services::ssh_common::locked_key_hint_async(
+                user, host, port,
+            )
+            .await
+            {
+                Some(hint) => format!("{err}\n\n{hint}"),
+                None => err,
+            }),
+            Ok(session) => Ok(session),
+        };
+    };
+
+    let kinds = crate::services::ssh_common::secret_attempt_order_async(user, host, port).await;
+    let last = kinds.len() - 1;
+    let mut error = String::new();
+    for (i, kind) in kinds.iter().copied().enumerate() {
+        if kind == SecretKind::Password {
+            // Never release a password to a host key nobody has vetted. (A
+            // passphrase needs no such gate — it never leaves this machine.)
+            crate::services::ssh_common::guard_first_contact_async(host, port).await?;
+        }
+        let base = match (kind, master) {
+            (SecretKind::Password, false) => ssh_password_base_args(user, host, port)?,
+            (SecretKind::Password, true) => ssh_password_master_base_args(user, host, port)?,
+            (SecretKind::KeyPassphrase, false) => ssh_passphrase_base_args(user, host, port)?,
+            (SecretKind::KeyPassphrase, true) => {
+                ssh_passphrase_master_base_args(user, host, port)?
+            }
+        };
+        let args = sftp_subsystem_args(base)?;
+        let (cmd, askpass) = secret_cmd(kind, pw, &args)?;
+        match spawn_sftp(cmd, askpass, Some(kind), what).await {
+            Ok(session) => return Ok(session),
+            Err((explained, rejected_locally)) => {
+                error = explained;
+                // The secret is definitively a wrong passphrase — trying it
+                // against the server would disclose it for nothing.
+                if rejected_locally || i == last {
+                    return Err(error);
+                }
+            }
+        }
+    }
+    Err(error)
+}
+
+/// Build the `ssh` command for one secret-auth attempt, with the askpass shim for
+/// `kind` attached. Returns the guard alongside, which the caller must keep alive
+/// until the handshake completes (see [`spawn_sftp`], which owns it).
+fn secret_cmd(
+    kind: crate::services::ssh_common::SecretKind,
+    secret: &str,
+    args: &[String],
+) -> Result<(Command, Option<crate::services::ssh_common::Askpass>), String> {
+    #[cfg(unix)]
+    {
+        let mut cmd = Command::new("ssh");
+        cmd.args(args);
+        let ap = crate::services::ssh_common::make_askpass_for(kind, secret, args)?;
+        for (k, v) in ap.env_vars() {
+            cmd.env(k, v);
+        }
+        Ok((cmd, Some(ap)))
+    }
+    #[cfg(not(unix))]
+    {
+        // Windows: askpass when OpenSSH ≥ 8.4, else the sshpass fallback.
+        if crate::services::ssh_common::ssh_supports_askpass() {
+            let mut cmd = Command::new("ssh");
+            cmd.args(args);
+            let ap = crate::services::ssh_common::make_askpass_for(kind, secret, args)?;
+            for (k, v) in ap.env_vars() {
+                cmd.env(k, v);
+            }
+            Ok((cmd, Some(ap)))
+        } else if kind == crate::services::ssh_common::SecretKind::KeyPassphrase {
+            // `sshpass` answers the *password* prompt only; it has no way to feed a
+            // key passphrase. Say so rather than silently sending it to the server.
+            Err(
+                "unlocking a passphrase-protected SSH key needs OpenSSH 8.4+ — update \
+                 OpenSSH, or run `ssh-add` to load the key before connecting"
+                    .to_string(),
+            )
+        } else if crate::services::ssh_common::sshpass_available() {
+            let mut cmd = Command::new("sshpass");
+            cmd.arg("-e"); // read the password from $SSHPASS, never argv
+            cmd.env("SSHPASS", secret);
+            cmd.arg("ssh");
+            cmd.args(args);
+            Ok((cmd, None))
+        } else {
+            Err(
+                "password auth needs OpenSSH 8.4+ or sshpass — update OpenSSH, \
+                 install sshpass, or set up SSH keys"
+                    .to_string(),
+            )
+        }
+    }
+}
+
+/// Spawn `cmd` (an `ssh -s sftp`) and complete the SFTP handshake over its pipes.
+/// Takes ownership of the askpass guard so the shim outlives authentication —
+/// which happens during `Sftp::new`, not at spawn.
+///
+/// On failure returns `(explained, raw stderr)`: the explained form is what the
+/// user reads, while the raw text is what [`open_any`] inspects to decide whether
+/// another auth method is worth trying.
+async fn spawn_sftp(
+    mut cmd: Command,
+    askpass: Option<crate::services::ssh_common::Askpass>,
+    kind: Option<crate::services::ssh_common::SecretKind>,
+    what: &str,
+) -> Result<(Sftp, Child), (String, bool)> {
+    let launch = |e: std::io::Error| (format!("failed to launch ssh for sftp: {e}"), false);
+    let missing = |s: &str| (s.to_string(), false);
+
+    cmd.stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        // Piped, not null: this is where ssh says *why* it failed (see drain_stderr).
+        // This is the connect the headless Connect modal drives, so its error text
+        // is what the user reads — it must carry the reason, not an EOF.
+        .stderr(Stdio::piped());
+    if let Some(path) = crate::paths::effective_path() {
+        cmd.env("PATH", path);
+    }
+    // Don't pop a console window for the child ssh on Windows.
+    #[cfg(windows)]
+    cmd.creation_flags(0x0800_0000); // CREATE_NO_WINDOW
+
+    let mut child = cmd.spawn().map_err(launch)?;
+    let stdin = child
+        .stdin
+        .take()
+        .ok_or_else(|| missing("ssh stdin unavailable"))?;
+    let stdout = child
+        .stdout
+        .take()
+        .ok_or_else(|| missing("ssh stdout unavailable"))?;
+    let drain = child.stderr.take().map(drain_stderr);
+
+    match Sftp::new(stdin, stdout, SftpOptions::default()).await {
+        Ok(sftp) => Ok((sftp, child)),
+        Err(e) => {
+            let (err, raw) = handshake_error(drain, format!("{what}: {e}")).await;
+            // Both reads must happen before the guard drops (it deletes its files).
+            #[cfg(any(unix, windows))]
+            let rejected = kind.is_some_and(|k| {
+                crate::services::ssh_common::secret_rejected_locally(k, askpass.as_ref(), &raw)
+            });
+            #[cfg(not(any(unix, windows)))]
+            let rejected = kind.is_some_and(|k| {
+                k == crate::services::ssh_common::SecretKind::KeyPassphrase
+                    && crate::services::ssh_common::is_wrong_passphrase(&raw)
+            });
+            #[cfg(any(unix, windows))]
+            let err = refusal_override(&askpass, err);
+            let err = if rejected {
+                crate::services::ssh_common::wrong_passphrase_error()
+            } else {
+                err
+            };
+            Err((err, rejected))
+        }
+    }
+}
+
+/// Open a **master-owning, persistent** SFTP session for the pooled remote
+/// connection (Phase 0; `services::remote`). Unlike [`open_session`] — a one-shot
+/// per-call session for the project dialog — this rides `ControlMaster=auto`
+/// (Unix), so it *creates and persists* the shared multiplexing master that
+/// agent tabs, git-over-ssh, and later SFTP channels reuse without
+/// re-authenticating. Returns the live client plus the `ssh` child, whose
+/// lifetime keeps the master alive; the caller pools both and tears them down on
+/// deactivation/exit.
+pub async fn open_pooled_session(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+) -> Result<(Sftp, Child), String> {
+    // Ensure the control-socket directory exists before ssh binds the master.
+    #[cfg(not(target_os = "windows"))]
+    let _ = std::fs::create_dir_all(crate::services::ssh_exec::control_dir());
+
+    open_any(user, host, port, password, true).await
+}
+
+/// Wait for the ssh child to exit after the `Sftp` client has been dropped, so we
+/// don't leave a zombie. Best-effort — a stuck child is not worth failing on.
+async fn reap(mut child: Child) {
+    let _ = child.wait().await;
+}
+
+/// Resolve the remote default directory (the SFTP server's notion of `.`, i.e.
+/// the login/home directory) via REALPATH — no remote `pwd` shell-out.
+pub async fn default_dir(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+) -> Result<String, String> {
+    let (sftp, child) = open_session(user, host, port, password).await?;
+    let mut fs = sftp.fs();
+    let result = fs
+        .canonicalize(".")
+        .await
+        .map_err(|e| format!("sftp realpath failed: {e}"))
+        .map(|p| p.to_string_lossy().into_owned());
+    drop(fs);
+    let _ = sftp.close().await;
+    reap(child).await;
+    let path = result?;
+    if path.trim().is_empty() {
+        return Err("remote realpath returned no path".to_string());
+    }
+    Ok(path)
+}
+
+/// List one remote directory over SFTP. An empty `path` lists the remote default
+/// (home) directory. Entries carry real SFTP file-type metadata.
+pub async fn list_dir(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<Vec<Entry>, String> {
+    let path = path.trim();
+    // Leading-`-`/control-char guard is no longer load-bearing (SFTP paths are
+    // protocol fields, not shell tokens) but kept as cheap defense in depth.
+    if !path.is_empty() {
+        validate_arg("path", path)?;
+    }
+    let target = if path.is_empty() { "." } else { path };
+
+    let (sftp, child) = open_session(user, host, port, password).await?;
+    let result = list_dir_on(&sftp, target).await;
+    let _ = sftp.close().await;
+    reap(child).await;
+
+    result
+}
+
+/// List one remote directory on an **already-open** `Sftp` session — the shared
+/// core used by both the one-shot [`list_dir`] (which owns its session) and the
+/// pooled file-browse path (Phase 2: `commands::fs::list_dir` rides the
+/// persistent session from `services::remote`). An empty `path` lists the SFTP
+/// default (home) directory. Entries carry real SFTP file-type metadata plus the
+/// `readdir`-supplied size/mtime.
+pub async fn list_dir_on(sftp: &Sftp, path: &str) -> Result<Vec<Entry>, String> {
+    let path = path.trim();
+    // Leading-`-`/control-char guard is no longer load-bearing (SFTP paths are
+    // protocol fields, not shell tokens) but kept as cheap defense in depth.
+    if !path.is_empty() {
+        validate_arg("path", path)?;
+    }
+    let target = if path.is_empty() { "." } else { path };
+
+    let mut fs = sftp.fs();
+    let listing = read_entries(&mut fs, target).await;
+    drop(fs);
+    Ok(finalize_entries(listing?))
+}
+
+/// Directory / symlink / other, as reported by a `readdir` entry's lstat-style
+/// `file_type()`. Symlinks need a follow-up stat to learn what they point at.
+enum RawKind {
+    Dir,
+    Symlink,
+    Other,
+}
+
+/// Lstat-typed kind of a directory entry for the sync walker — the entry's OWN
+/// type, never a symlink's target (G3: the recursive sync must NOT follow host
+/// symlinks, or a `link -> /etc` would exfiltrate host files into the mirror).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SyncKind {
+    Dir,
+    File,
+    Symlink,
+    Other,
+}
+
+/// One raw (lstat-typed) directory entry for the sync walker.
+#[derive(Debug, Clone)]
+pub struct RawEntry {
+    pub name: String,
+    pub kind: SyncKind,
+    /// Size in bytes from the listing attrs (`0` when absent).
+    pub size: u64,
+    /// Last-modified time as whole seconds since the Unix epoch, when reported.
+    pub modified_secs: Option<u64>,
+}
+
+/// List one remote directory on an open session WITHOUT following symlinks — the
+/// listing the recursive sync walker uses. Unlike [`list_dir_on`] (which follows
+/// symlinks so a symlink-to-dir is navigable in the picker), every entry reports
+/// its own lstat-style type, so the walker can skip symlinks/special files (G3)
+/// and recurse only into real directories. `.`/`..`/blank names are dropped; no
+/// sorting (the walker doesn't need it).
+pub async fn list_dir_raw_on(sftp: &Sftp, path: &str) -> Result<Vec<RawEntry>, String> {
+    let path = path.trim();
+    if !path.is_empty() {
+        validate_arg("path", path)?;
+    }
+    let target = if path.is_empty() { "." } else { path };
+
+    let mut fs = sftp.fs();
+    let dir = fs
+        .open_dir(target)
+        .await
+        .map_err(|e| format!("sftp open_dir failed: {e}"))?;
+    let mut rd = Box::pin(dir.read_dir());
+    let mut out: Vec<RawEntry> = Vec::new();
+    while let Some(item) = rd.next().await {
+        let entry = item.map_err(|e| format!("sftp read_dir failed: {e}"))?;
+        let name = entry.filename().to_string_lossy().into_owned();
+        if name.is_empty() || name == "." || name == ".." {
+            continue;
+        }
+        let meta = entry.metadata();
+        let size = meta.len().unwrap_or(0);
+        let modified_secs = meta.modified().map(|t| t.as_duration().as_secs());
+        let kind = match entry.file_type() {
+            Some(t) if t.is_dir() => SyncKind::Dir,
+            Some(t) if t.is_symlink() => SyncKind::Symlink,
+            Some(t) if t.is_file() => SyncKind::File,
+            _ => SyncKind::Other,
+        };
+        out.push(RawEntry {
+            name,
+            kind,
+            size,
+            modified_secs,
+        });
+    }
+    Ok(out)
+}
+
+/// Build the path to a directory child for a follow-up stat. `target` is the
+/// listed directory (`"."` for the SFTP home, otherwise an absolute path); the
+/// child is resolved relative to it. Pure, so it is unit-tested.
+fn resolve_child_path(target: &str, name: &str) -> String {
+    if target == "." || target.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}/{}", target.trim_end_matches('/'), name)
+    }
+}
+
+/// Open `target` and drain its `ReadDir` stream into raw `Entry`s (unsorted,
+/// unfiltered). Split out so `list_dir`'s session teardown always runs.
+///
+/// Two passes: pass 1 drains the listing (the `readdir` `file_type()` is
+/// lstat-style, so a symlink reports as a symlink, not its target); pass 2
+/// follow-stats each **symlink** so a symlink-to-directory is flagged `is_dir`
+/// and is navigable in the picker. Only symlinks cost an extra round-trip; a
+/// broken/inaccessible link resolves to non-dir.
+async fn read_entries(
+    fs: &mut openssh_sftp_client::fs::Fs,
+    target: &str,
+) -> Result<Vec<Entry>, String> {
+    let dir = fs
+        .open_dir(target)
+        .await
+        .map_err(|e| format!("sftp open_dir failed: {e}"))?;
+    // `ReadDir` is `!Unpin`; `Pin<Box<_>>` is `Unpin` so `StreamExt::next` applies.
+    let mut rd = Box::pin(dir.read_dir());
+    let mut raw: Vec<(String, RawKind, u64, Option<u64>)> = Vec::new();
+    while let Some(item) = rd.next().await {
+        let entry = item.map_err(|e| format!("sftp read_dir failed: {e}"))?;
+        let name = entry.filename().to_string_lossy().into_owned();
+        // `metadata()` here is the `readdir`-supplied attrs — no extra round-trip.
+        let meta = entry.metadata();
+        let size = meta.len().unwrap_or(0);
+        let modified_secs = meta.modified().map(|t| t.as_duration().as_secs());
+        let kind = match entry.file_type() {
+            Some(t) if t.is_dir() => RawKind::Dir,
+            Some(t) if t.is_symlink() => RawKind::Symlink,
+            _ => RawKind::Other,
+        };
+        raw.push((name, kind, size, modified_secs));
+    }
+    drop(rd); // release the directory handle before the follow-up stats
+
+    let mut out: Vec<Entry> = Vec::with_capacity(raw.len());
+    for (name, kind, size, modified_secs) in raw {
+        let is_dir = match kind {
+            RawKind::Dir => true,
+            RawKind::Other => false,
+            // `metadata` follows the link (vs `symlink_metadata`), so this is the
+            // *target's* type. Errors (broken/denied link) fall back to non-dir.
+            RawKind::Symlink => {
+                let child = resolve_child_path(target, &name);
+                fs.metadata(&child)
+                    .await
+                    .ok()
+                    .and_then(|m| m.file_type())
+                    .map(|t| t.is_dir())
+                    .unwrap_or(false)
+            }
+        };
+        out.push(Entry {
+            name,
+            is_dir,
+            // Mirror the local lister: directories report size 0.
+            size: if is_dir { 0 } else { size },
+            modified_secs,
+        });
+    }
+    Ok(out)
+}
+
+/// Drop `.`/`..`/blank names, then sort dirs-first and case-insensitively by
+/// name — the exact ordering the old `parse_ls_output` produced, so the browser
+/// UI is unchanged. Pure, so it is unit-tested without a live host.
+pub(crate) fn finalize_entries(entries: Vec<Entry>) -> Vec<Entry> {
+    let mut entries: Vec<Entry> = entries
+        .into_iter()
+        .filter(|e| !e.name.is_empty() && e.name != "." && e.name != "..")
+        .collect();
+    entries.sort_by(|a, b| {
+        b.is_dir
+            .cmp(&a.is_dir)
+            .then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
+    });
+    entries
+}
+
+// ── Write/read half (mount-free remote, Phase 3) ────────────────────────────
+//
+// The counterpart to the read/list half above: file I/O (read / write / create /
+// delete / mkdir / rename / metadata) over SFTP, used by `commands::fs` to route
+// remote-project file operations. Mirrors the `list_dir` / `list_dir_on` shape —
+// a `*_on(&Sftp, …)` core that runs on an already-open (pooled) session, plus a
+// one-shot wrapper that opens its own session and tears it down (teardown runs
+// even on error). SFTP paths are protocol fields, never shell tokens, so no
+// quoting/validation against injection is needed here (see the module header).
+
+/// The parent directory of a remote (POSIX) path, or `None` for a bare leaf
+/// name. `"/a/b"` → `"/a"`, `"/a"` → `"/"`, `"a"` → `None`. Pure, unit-tested.
+fn remote_parent(path: &str) -> Option<String> {
+    let trimmed = path.trim_end_matches('/');
+    match trimmed.rfind('/') {
+        Some(0) => Some("/".to_string()),
+        Some(i) => Some(trimmed[..i].to_string()),
+        None => None,
+    }
+}
+
+/// Every directory prefix of `path`, shallowest-first up to `path` itself:
+/// `"/a/b/c"` → `["/a", "/a/b", "/a/b/c"]`. Used to emulate `mkdir -p` (SFTP
+/// MKDIR is single-level). Pure, unit-tested.
+fn ancestor_dirs(path: &str) -> Vec<String> {
+    let trimmed = path.trim_end_matches('/');
+    let absolute = trimmed.starts_with('/');
+    let mut out = Vec::new();
+    let mut acc = String::new();
+    for comp in trimmed.split('/').filter(|c| !c.is_empty()) {
+        if acc.is_empty() && !absolute {
+            acc.push_str(comp);
+        } else {
+            acc.push('/');
+            acc.push_str(comp);
+        }
+        out.push(acc.clone());
+    }
+    out
+}
+
+/// Create `path` and any missing parents on an open session — the remote
+/// analogue of `std::fs::create_dir_all`. A no-op when `path` already exists
+/// (any kind). SFTP has no atomic `mkdir -p`, so each missing ancestor is created
+/// in turn; a level that already exists (or a create race) is tolerated.
+pub async fn mkdir_on(sftp: &Sftp, path: &str) -> Result<(), String> {
+    let mut fs = sftp.fs();
+    if fs.metadata(path).await.is_ok() {
+        return Ok(()); // already present — nothing to create
+    }
+    for prefix in ancestor_dirs(path) {
+        if fs.metadata(&prefix).await.is_ok() {
+            continue;
+        }
+        if let Err(e) = fs.create_dir(&prefix).await {
+            // A concurrent create / pre-existing dir is fine; only a still-missing
+            // level after the attempt is a real failure.
+            if fs.metadata(&prefix).await.is_err() {
+                return Err(format!("sftp mkdir failed for '{prefix}': {e}"));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Ensure the parent directory of `path` exists (mirrors the `create_dir_all`
+/// the local file writers do before a write).
+async fn ensure_parent_dirs_on(sftp: &Sftp, path: &str) -> Result<(), String> {
+    if let Some(parent) = remote_parent(path) {
+        mkdir_on(sftp, &parent).await?;
+    }
+    Ok(())
+}
+
+/// Read a remote file's whole contents on an already-open session.
+pub async fn read_file_on(sftp: &Sftp, path: &str) -> Result<Vec<u8>, String> {
+    let mut fs = sftp.fs();
+    let bytes = fs
+        .read(path)
+        .await
+        .map_err(|e| format!("sftp read failed: {e}"))?;
+    Ok(bytes.to_vec())
+}
+
+/// Write (create/truncate) a remote file with `bytes`, creating missing parent
+/// directories first — mirrors the local writers' `create_dir_all` + `write`.
+pub async fn write_file_on(sftp: &Sftp, path: &str, bytes: &[u8]) -> Result<(), String> {
+    ensure_parent_dirs_on(sftp, path).await?;
+    let mut fs = sftp.fs();
+    fs.write(path, bytes)
+        .await
+        .map_err(|e| format!("sftp write failed: {e}"))
+}
+
+/// Create an empty remote file (truncating an existing one), creating missing
+/// parents — the remote analogue of `fs::File::create`.
+pub async fn create_file_on(sftp: &Sftp, path: &str) -> Result<(), String> {
+    write_file_on(sftp, path, &[]).await
+}
+
+/// Chunk size for the streaming transfers below — bounded so an arbitrarily large
+/// file never lives fully in memory (the whole-file `read_file_on`/`write_file_on`
+/// buffer everything, which is why the git-lockstep bundle transport streams; #28n
+/// Phase 3).
+const STREAM_CHUNK: usize = 256 * 1024;
+
+/// Upload a local file to the host in bounded chunks (never buffering the whole
+/// file), creating missing parent directories first. The remote streaming analogue
+/// of `write_file_on` for large payloads (git bundles at initial pairing).
+pub async fn upload_file_streaming_on(
+    sftp: &Sftp,
+    local_path: &std::path::Path,
+    remote_path: &str,
+) -> Result<(), String> {
+    use tokio::io::AsyncReadExt;
+    ensure_parent_dirs_on(sftp, remote_path).await?;
+    let mut local = tokio::fs::File::open(local_path)
+        .await
+        .map_err(|e| format!("open local bundle failed: {e}"))?;
+    let mut remote = sftp
+        .create(remote_path)
+        .await
+        .map_err(|e| format!("sftp create failed: {e}"))?;
+    let mut buf = vec![0u8; STREAM_CHUNK];
+    loop {
+        let n = local
+            .read(&mut buf)
+            .await
+            .map_err(|e| format!("read local bundle failed: {e}"))?;
+        if n == 0 {
+            break;
+        }
+        remote
+            .write_all(&buf[..n])
+            .await
+            .map_err(|e| format!("sftp streaming write failed: {e}"))?;
+    }
+    Ok(())
+}
+
+/// Download a host file to a local path in bounded chunks (never buffering the
+/// whole file), creating missing parent directories first. The remote streaming
+/// analogue of `read_file_on` for large payloads (git bundles at initial pairing).
+pub async fn download_file_streaming_on(
+    sftp: &Sftp,
+    remote_path: &str,
+    local_path: &std::path::Path,
+) -> Result<(), String> {
+    use tokio::io::AsyncWriteExt;
+    if let Some(parent) = local_path.parent() {
+        let _ = tokio::fs::create_dir_all(parent).await;
+    }
+    let mut remote = sftp
+        .open(remote_path)
+        .await
+        .map_err(|e| format!("sftp open failed: {e}"))?;
+    let mut local = tokio::fs::File::create(local_path)
+        .await
+        .map_err(|e| format!("create local bundle failed: {e}"))?;
+    loop {
+        let buf = bytes::BytesMut::with_capacity(STREAM_CHUNK);
+        match remote
+            .read(STREAM_CHUNK as u32, buf)
+            .await
+            .map_err(|e| format!("sftp streaming read failed: {e}"))?
+        {
+            Some(chunk) if !chunk.is_empty() => local
+                .write_all(&chunk)
+                .await
+                .map_err(|e| format!("write local bundle failed: {e}"))?,
+            _ => break,
+        }
+    }
+    local
+        .flush()
+        .await
+        .map_err(|e| format!("flush local bundle failed: {e}"))
+}
+
+/// Remove a remote file on an open session.
+pub async fn remove_file_on(sftp: &Sftp, path: &str) -> Result<(), String> {
+    let mut fs = sftp.fs();
+    fs.remove_file(path)
+        .await
+        .map_err(|e| format!("sftp remove_file failed: {e}"))
+}
+
+/// Recursively remove a remote directory tree on an open session — the remote
+/// analogue of `std::fs::remove_dir_all` (SFTP RMDIR only removes an *empty*
+/// directory, so children are listed and removed depth-first first).
+pub async fn remove_dir_on(sftp: &Sftp, path: &str) -> Result<(), String> {
+    // List the directory (errors → empty/leaf, fall through to RMDIR).
+    let entries = list_dir_on(sftp, path).await.unwrap_or_default();
+    for entry in &entries {
+        let child = format!("{}/{}", path.trim_end_matches('/'), entry.name);
+        if entry.is_dir {
+            Box::pin(remove_dir_on(sftp, &child)).await?;
+        } else {
+            remove_file_on(sftp, &child).await?;
+        }
+    }
+    let mut fs = sftp.fs();
+    fs.remove_dir(path)
+        .await
+        .map_err(|e| format!("sftp remove_dir failed: {e}"))
+}
+
+/// Rename/move a remote path on an open session.
+pub async fn rename_on(sftp: &Sftp, from: &str, to: &str) -> Result<(), String> {
+    let mut fs = sftp.fs();
+    fs.rename(from, to)
+        .await
+        .map_err(|e| format!("sftp rename failed: {e}"))
+}
+
+/// `(size, modified_secs)` for a remote path on an open session. `size` is `0`
+/// and `modified_secs` is `None` when the server omits the attribute.
+pub async fn metadata_on(sftp: &Sftp, path: &str) -> Result<(u64, Option<u64>), String> {
+    let mut fs = sftp.fs();
+    let meta = fs
+        .metadata(path)
+        .await
+        .map_err(|e| format!("sftp metadata failed: {e}"))?;
+    let size = meta.len().unwrap_or(0);
+    let modified = meta.modified().map(|t| t.as_duration().as_secs());
+    Ok((size, modified))
+}
+
+/// SFTP-get a remote file into a local destination path on an open session
+/// (read the bytes, then write them locally). The primitive a per-project
+/// "download" command would call; see [`download`].
+#[allow(dead_code)] // wired by the download-routing command (Phase 3/5 follow-up)
+pub async fn download_on(
+    sftp: &Sftp,
+    remote_path: &str,
+    dest_local: &std::path::Path,
+) -> Result<(), String> {
+    let bytes = read_file_on(sftp, remote_path).await?;
+    std::fs::write(dest_local, bytes).map_err(|e| format!("write downloaded file failed: {e}"))
+}
+
+// ── One-shot wrappers (open a session, run one op, tear it down) ─────────────
+//
+// The cold-pool fallback for `commands::fs` (mirrors `list_dir` over
+// `list_dir_on`). Key/agent auth when `password` is `None`; teardown always runs.
+
+/// Open a one-shot session, run `op` against it, then close + reap (even on op
+/// error). Cuts the per-wrapper boilerplate while keeping teardown guaranteed.
+async fn with_oneshot<F, Fut, T>(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    op: F,
+) -> Result<T, String>
+where
+    F: FnOnce(Sftp) -> Fut,
+    Fut: std::future::Future<Output = (Sftp, Result<T, String>)>,
+{
+    let (sftp, child) = open_session(user, host, port, password).await?;
+    let (sftp, result) = op(sftp).await;
+    let _ = sftp.close().await;
+    reap(child).await;
+    result
+}
+
+/// One-shot remote file read.
+pub async fn read_file(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<Vec<u8>, String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = read_file_on(&sftp, path).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote file write (create/truncate, creating parents).
+pub async fn write_file(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+    bytes: &[u8],
+) -> Result<(), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = write_file_on(&sftp, path, bytes).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote empty-file create.
+pub async fn create_file(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<(), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = create_file_on(&sftp, path).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote `mkdir -p`.
+pub async fn mkdir(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<(), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = mkdir_on(&sftp, path).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote file remove.
+pub async fn remove_file(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<(), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = remove_file_on(&sftp, path).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote recursive directory remove.
+pub async fn remove_dir(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<(), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = remove_dir_on(&sftp, path).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote rename/move.
+pub async fn rename(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    from: &str,
+    to: &str,
+) -> Result<(), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = rename_on(&sftp, from, to).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot remote metadata (`(size, modified_secs)`).
+pub async fn metadata(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    path: &str,
+) -> Result<(u64, Option<u64>), String> {
+    with_oneshot(user, host, port, password, |sftp| async move {
+        let r = metadata_on(&sftp, path).await;
+        (sftp, r)
+    })
+    .await
+}
+
+/// One-shot SFTP-get a remote file into a local destination path.
+#[allow(dead_code)] // wired by the download-routing command (Phase 3/5 follow-up)
+pub async fn download(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    password: Option<&str>,
+    remote_path: &str,
+    dest_local: &std::path::Path,
+) -> Result<(), String> {
+    let bytes = read_file(user, host, port, password, remote_path).await?;
+    std::fs::write(dest_local, bytes).map_err(|e| format!("write downloaded file failed: {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn e(name: &str, is_dir: bool) -> Entry {
+        Entry {
+            name: name.to_string(),
+            is_dir,
+            size: 0,
+            modified_secs: None,
+        }
+    }
+
+    #[test]
+    fn subsystem_args_splice_dash_s_before_target() {
+        // base = [..opts.., target]; result = [..opts.., -s, target, sftp].
+        let base = vec![
+            "-o".to_string(),
+            "BatchMode=yes".to_string(),
+            "alice@host.example".to_string(),
+        ];
+        let args = sftp_subsystem_args(base).unwrap();
+        assert_eq!(
+            args,
+            vec!["-o", "BatchMode=yes", "-s", "alice@host.example", "sftp"]
+        );
+    }
+
+    #[test]
+    fn finalize_sorts_dirs_first_then_name_ci() {
+        let raw = vec![
+            e("zebra.txt", false),
+            e("Apple", true),
+            e("banana.txt", false),
+            e("Cherry", true),
+        ];
+        let names: Vec<_> = finalize_entries(raw)
+            .into_iter()
+            .map(|e| e.name)
+            .collect();
+        assert_eq!(names, vec!["Apple", "Cherry", "banana.txt", "zebra.txt"]);
+    }
+
+    #[test]
+    fn finalize_filters_dot_and_dotdot_and_blanks() {
+        let raw = vec![e(".", true), e("..", true), e("", false), e("real", true)];
+        let names: Vec<_> = finalize_entries(raw)
+            .into_iter()
+            .map(|e| e.name)
+            .collect();
+        assert_eq!(names, vec!["real"]);
+    }
+
+    #[test]
+    fn finalize_keeps_hidden_entries() {
+        let raw = vec![e(".config", true), e(".bashrc", false), e("visible", false)];
+        let out = finalize_entries(raw);
+        assert!(out.iter().any(|x| x.name == ".config" && x.is_dir));
+        assert!(out.iter().any(|x| x.name == ".bashrc" && !x.is_dir));
+    }
+
+    #[test]
+    fn child_path_joins_against_target_or_home() {
+        // "." / empty target → bare name (resolved against the SFTP home).
+        assert_eq!(resolve_child_path(".", "link"), "link");
+        assert_eq!(resolve_child_path("", "link"), "link");
+        // Absolute target → joined, with no doubled slash.
+        assert_eq!(resolve_child_path("/home/u", "link"), "/home/u/link");
+        assert_eq!(resolve_child_path("/home/u/", "link"), "/home/u/link");
+        // Root stays a single leading slash.
+        assert_eq!(resolve_child_path("/", "link"), "/link");
+    }
+
+    #[test]
+    fn remote_parent_of_paths() {
+        assert_eq!(remote_parent("/a/b/c"), Some("/a/b".to_string()));
+        assert_eq!(remote_parent("/a/b/c/"), Some("/a/b".to_string()));
+        assert_eq!(remote_parent("/a"), Some("/".to_string()));
+        // A bare leaf name (relative) has no parent.
+        assert_eq!(remote_parent("leaf"), None);
+        assert_eq!(remote_parent("/"), None);
+    }
+
+    #[test]
+    fn ancestor_dirs_walks_absolute_prefixes() {
+        assert_eq!(
+            ancestor_dirs("/a/b/c"),
+            vec!["/a".to_string(), "/a/b".to_string(), "/a/b/c".to_string()]
+        );
+        // Trailing slash trimmed; root-only path has no components.
+        assert_eq!(ancestor_dirs("/"), Vec::<String>::new());
+        // Relative path keeps the first component bare.
+        assert_eq!(
+            ancestor_dirs("a/b"),
+            vec!["a".to_string(), "a/b".to_string()]
+        );
+    }
+
+    #[test]
+    fn finalize_injection_named_dir_is_one_inert_entry() {
+        // The whole point: a hostile directory name is just data here.
+        let raw = vec![e("foo; rm -rf ~", true), e("$(touch pwned)", false)];
+        let out = finalize_entries(raw);
+        assert_eq!(out.len(), 2);
+        assert!(out.iter().any(|x| x.name == "foo; rm -rf ~" && x.is_dir));
+    }
+}
diff --git a/src-tauri/src/services/ssh_common.rs b/src-tauri/src/services/ssh_common.rs
new file mode 100644
index 0000000..c74132c
--- /dev/null
+++ b/src-tauri/src/services/ssh_common.rs
@@ -0,0 +1,2528 @@
+//! Shared SSH argv + validation helpers for remote (SSH) projects.
+//!
+//! These are the single source of truth for building validated `ssh` argv and
+//! the `[user@]host` target used by every remote path: the SFTP sessions
+//! (`services::sftp`), the pooled connection (`services::remote`), remote agent
+//! tabs and git-over-ssh (`services::ssh_exec`, `commands::git`), the reachability
+//! probe (`commands::ssh`), and `commands::git_publish`.
+//!
+//! Every argument is passed to the child process as a separate argv item (never a
+//! shell string), and values that could be mistaken for an option (a leading `-`)
+//! or that contain control characters are rejected. The one unavoidable remote
+//! shell string (the trailing command ssh hands to the remote `$SHELL -c`) is
+//! single-quoted by its caller; see `ssh_exec::shell_quote`.
+//!
+//! This module was extracted from the former `services::ssh_mount` when the
+//! sshfs/FUSE mount was removed (mount-free remote model, see
+//! `docs/mountfree_remote_plan.md`): remote projects are SSH/SFTP-native and no
+//! longer mount a local FUSE filesystem, but the SSH validation/argv helpers the
+//! mount once shared are still needed by every remote path.
+
+/// Reject values that contain control characters (incl. NUL/newline) or that
+/// begin with `-` (which `ssh`/`ls` would treat as an option). Empty values are
+/// allowed here; callers decide whether emptiness is acceptable.
+pub fn validate_arg(label: &str, value: &str) -> Result<(), String> {
+    if value.starts_with('-') {
+        return Err(format!("{label} must not start with '-'"));
+    }
+    if value.chars().any(|c| c.is_control()) {
+        return Err(format!("{label} contains invalid control characters"));
+    }
+    Ok(())
+}
+
+// ── Dial policy: who asked for this connection ──────────────────────────────
+//
+// `settings.hpc_hosts` promises that Eldrun never reaches a tagged machine *by
+// itself* (`docs/context/hpc_careful_mode.md`). That promise used to be kept
+// only in TypeScript, so every backend path that opens an `ssh` child — a
+// reachability probe, a tab respawned at relaunch, a readiness poll, an
+// auto-connect — went on dialling a cluster login node unattended, and each one
+// succeeded, because the host has a saved password.
+//
+// The rule is therefore enforced where an ssh command is **built**, not at the
+// call sites: every remote path in this tree funnels through one of the argv
+// builders below, so a caller cannot reach a tagged host by forgetting a check
+// it never knew existed. `ssh_pty_args` (`services::ssh_exec`) is the seventh
+// builder and carries the same call.
+//
+// The intent cannot ride the builders' signatures — they are reached from a
+// dozen layers with no idea *why* they are running — so it is ambient and keyed
+// by target: a user-initiated command holds a [`UserDial`] for the machine it is
+// about, and a pooled connection the user opened holds one for as long as it is
+// connected (which is what keeps a tagged project usable once connected: work on
+// a connection a person made is not Eldrun connecting by itself). Everything
+// else is [`DialIntent::Background`], the safe default — a wrong "background"
+// costs one confirmation dialog, a wrong "user-initiated" costs the promise.
+
+/// Why an ssh connection is about to be opened, as far as the *policy* cares.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DialIntent {
+    /// A person asked for this, at this machine, now.
+    UserInitiated,
+    /// Anything else: a loop, a probe, a relaunch, an armed auto-connect.
+    Background,
+}
+
+// How a command declares its intent, and why there are exactly two shapes:
+//
+//   1. **Always a gesture** — the command has no caller but a dialog, so it takes
+//      an unconditional [`user_dial`] and needs no parameter. The remote folder
+//      browser (`ssh_default_dir`/`ssh_list_dir`/`ssh_mkdir`), every `slurm_*`
+//      and `hpc_ws_*` (through `run_slurm_script`), `remote_kill_all_jobs`,
+//      `remote_tmux_kill`, `worker_sync_now`, `worker_pull_outputs`, a
+//      *confirmed* `disk_usage_scan`, and an `ssh_connect` carrying a typed
+//      password. Adding a background caller to one of these is what would make it
+//      wrong, so the rule is stated at the call site rather than in a parameter
+//      the new caller could quietly inherit.
+//
+//   2. **Both** — the same command backs a click *and* a poller/sweep, so it
+//      takes `background: Option<bool>` and only `Some(false)` counts as a
+//      gesture ([`declared_dial`]). `ssh_probe`, `remote_connect`,
+//      `remote_usage_check`, `global_machine_usage_check`,
+//      `global_machine_monitor_snapshot`, `global_machine_tmux_list`, and a
+//      **credential-less** `ssh_connect` (the readiness poll that waits for a
+//      terminal login's master is a gesture; the silent reconnect behind
+//      auto-connect is not — the two are indistinguishable from in there).
+//
+// The default is Background in **both** shapes, and deliberately so: a caller
+// that says nothing is a caller nobody has thought about, and the two mistakes
+// do not cost the same. A wrong "background" costs one confirmation dialog at a
+// machine the user tagged for exactly that purpose; a wrong "user-initiated"
+// costs the promise the tag is, silently, forever. Hence the polarity too —
+// `background: true` and `background: absent` mean the same thing, so forgetting
+// the parameter can only ever fail closed.
+
+/// Targets with at least one live authorization, [`target_key`] → refcount.
+///
+/// Refcounted rather than a flag because one machine legitimately carries
+/// several: a login node is at once a project's primary, another project's
+/// worker and a global machine, and one of them closing must not silently
+/// revoke the others.
+///
+/// **Known limit: this is process-global, not task-local.** A guard held across
+/// an `.await` — a folder browse, a `disk_usage_scan` running for minutes, a
+/// `remote_connect` inside a 10 s handshake — authorizes *any other task* dialing
+/// the same target for that window. The exposure is small and deliberate: the two
+/// background loops (`sync_auto`, `git_peer`) check the tag themselves per tick,
+/// so what remains is a `pty_spawn` restore or a readiness poll landing inside a
+/// user's own connect to the same machine — which is close to the case the
+/// standing pool authorization grants on purpose anyway. It is recorded here
+/// rather than glossed, because the guarantee this module reads as offering
+/// ("only a gesture authorizes a dial") is narrower than that in the general
+/// case. A task-local (tokio task-local / explicit-parameter) intent would close
+/// it, at the cost of threading the intent through every argv builder's call
+/// chain — the thing the ambient design exists to avoid.
+static AUTHORIZED_DIALS: std::sync::Mutex<Option<std::collections::HashMap<String, usize>>> =
+    std::sync::Mutex::new(None);
+
+/// Add (`true`) or drop (`false`) one authorization for `key`.
+fn shift_authorization(key: &str, add: bool) {
+    let Ok(mut guard) = AUTHORIZED_DIALS.lock() else {
+        return;
+    };
+    let map = guard.get_or_insert_with(std::collections::HashMap::new);
+    if add {
+        *map.entry(key.to_string()).or_insert(0) += 1;
+        return;
+    }
+    if let Some(n) = map.get_mut(key) {
+        *n = n.saturating_sub(1);
+        if *n == 0 {
+            map.remove(key);
+        }
+    }
+}
+
+/// Whether anything currently authorizes reaching `key`.
+fn dial_authorized(key: &str) -> bool {
+    AUTHORIZED_DIALS
+        .lock()
+        .ok()
+        .and_then(|g| g.as_ref().map(|m| m.contains_key(key)))
+        .unwrap_or(false)
+}
+
+/// The intent a builder must attribute to the dial it is about to make: what the
+/// ambient registry says about *this* target, defaulting to background.
+pub fn ambient_intent(user: &Option<String>, host: &str, port: Option<u16>) -> DialIntent {
+    match dial_authorized(&target_key(user.as_deref(), host, port)) {
+        true => DialIntent::UserInitiated,
+        false => DialIntent::Background,
+    }
+}
+
+/// One live "the user asked for this machine" authorization, dropped with the
+/// command that took it out. Held across `.await`s by design — the whole point is
+/// to cover an ssh argv built several layers below the click.
+pub struct UserDial {
+    key: String,
+}
+
+impl Drop for UserDial {
+    fn drop(&mut self) {
+        shift_authorization(&self.key, false);
+    }
+}
+
+/// Mark `[user@]host[:port]` user-initiated for as long as the returned guard
+/// lives. Take one at the top of any command a person triggers directly against a
+/// named machine (connect, a SLURM submit, a workspace allocation, an explicit
+/// kill), so the argv it eventually builds is not read as a background dial.
+#[must_use = "the authorization lasts only as long as the guard"]
+pub fn user_dial(user: &Option<String>, host: &str, port: Option<u16>) -> UserDial {
+    user_dial_key(&target_key(user.as_deref(), host, port))
+}
+
+/// [`user_dial`] for a caller that already holds the [`target_key`].
+#[must_use = "the authorization lasts only as long as the guard"]
+pub fn user_dial_key(key: &str) -> UserDial {
+    shift_authorization(key, true);
+    UserDial {
+        key: key.to_string(),
+    }
+}
+
+/// [`user_dial`] for a command that serves *both* a click and a poller, taking
+/// its `background: Option<bool>` parameter — the second shape described above.
+///
+/// Only an explicit `Some(false)` is a gesture. `None` reads as background on
+/// purpose: it is what an un-updated caller, a new caller, and a caller that
+/// simply forgot all send, and none of those is evidence that a person is
+/// waiting. So the parameter can only be got wrong in the direction that raises
+/// a dialog, never in the direction that dials a cluster unasked.
+#[must_use = "the authorization lasts only as long as the guard"]
+pub fn declared_dial(
+    background: Option<bool>,
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Option<UserDial> {
+    (background == Some(false)).then(|| user_dial(user, host, port))
+}
+
+/// Record that the user opened a lasting connection to this target. Unlike
+/// [`user_dial`] this is not scoped to one call: it lives until
+/// [`forget_user_connect`], because everything riding a pooled ControlMaster the
+/// user authenticated — a shell tab, a `git status`, a Sessions listing — is work
+/// on *their* connection, not Eldrun reaching out on its own. Paired one-for-one
+/// with the pool in `services::remote`.
+pub fn remember_user_connect(user: &Option<String>, host: &str, port: Option<u16>) {
+    shift_authorization(&target_key(user.as_deref(), host, port), true);
+}
+
+/// Drop the standing authorization [`remember_user_connect`] took out, when the
+/// pooled connection it stood for is torn down.
+pub fn forget_user_connect(user: &Option<String>, host: &str, port: Option<u16>) {
+    shift_authorization(&target_key(user.as_deref(), host, port), false);
+}
+
+/// The dial policy itself: refuse a **background** connection to a machine the
+/// user tagged HPC, and permit everything else.
+///
+/// The refusal carries `services::hpc_mode`'s existing `HPC_GUARD` sentinel, so
+/// `src/lib/hpcGuard.ts` already knows how to read it — the frontend can name the
+/// machine and offer to connect anyway, and confirmation stays per act. The slug
+/// is `connect`, since what was refused is the connection itself.
+pub fn authorize_dial(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+    intent: DialIntent,
+) -> Result<(), String> {
+    let key = target_key(user.as_deref(), host, port);
+    match dial_refusal(crate::services::hpc_mode::is_tagged_hpc(&key), intent, &key) {
+        Some(err) => Err(err),
+        None => Ok(()),
+    }
+}
+
+/// The decision behind [`authorize_dial`], split out so it is testable without a
+/// `settings.json` on disk: only the tagged-**and**-background pair refuses.
+fn dial_refusal(tagged: bool, intent: DialIntent, key: &str) -> Option<String> {
+    (tagged && intent == DialIntent::Background)
+        .then(|| crate::services::hpc_mode::guard_error_for("connect", key))
+}
+
+/// Build the base `ssh` argv (everything up to but not including the remote
+/// command), validating `host`/`user` and rendering the `[user@]host` target as
+/// a single argv item.
+pub fn ssh_base_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<Vec<String>, String> {
+    let host = host.trim();
+    if host.is_empty() {
+        return Err("host must not be empty".to_string());
+    }
+    validate_arg("host", host)?;
+    // The dial policy, at the choke point rather than the call site — see the
+    // section above `DialIntent`. Repeated verbatim in every builder because
+    // "every builder" is the invariant.
+    authorize_dial(user, host, port, ambient_intent(user, host, port))?;
+
+    let mut args: Vec<String> = vec![
+        "-o".to_string(),
+        "BatchMode=yes".to_string(),
+        "-o".to_string(),
+        "ConnectTimeout=10".to_string(),
+        // TOFU: auto-accept a first-contact host key (so a fresh connection does
+        // not fail with no way to answer the yes/no prompt — BatchMode can't, and
+        // the password path answers via SSH_ASKPASS which would feed the password),
+        // but still REFUSE a key that has *changed* (the MITM case).
+        "-o".to_string(),
+        "StrictHostKeyChecking=accept-new".to_string(),
+    ];
+
+    // Reuse (never create) the multiplexing master the pooled connection / an
+    // interactive login may have opened (see `ssh_exec::interactive_login_command`
+    // and `services::remote`). With `ControlMaster=no` + the shared `cm-%C`
+    // socket, an otherwise-`BatchMode=yes` probe/exec rides that authenticated
+    // master with no second prompt; if no master exists it simply falls through to
+    // normal (key/agent) auth. Unix-only — Windows OpenSSH lacks the control
+    // socket (see `ssh_pty_args`).
+    #[cfg(not(target_os = "windows"))]
+    for opt in control_reuse_opts() {
+        args.push(opt);
+    }
+
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+
+    args.push(ssh_target(user, host)?);
+
+    Ok(args)
+}
+
+/// `ssh` `-o` options that **reuse** (but never create) the shared multiplexing
+/// master socket `ssh_exec` / the pooled connection / the interactive-login
+/// command establish. `ControlMaster=no` means "use a master if one is live,
+/// otherwise connect directly" — pure opportunistic reuse that never spawns a
+/// master of its own.
+#[cfg(not(target_os = "windows"))]
+fn control_reuse_opts() -> Vec<String> {
+    let control_path = crate::services::ssh_exec::control_dir().join("cm-%C");
+    vec![
+        "-o".to_string(),
+        "ControlMaster=no".to_string(),
+        "-o".to_string(),
+        format!("ControlPath={}", control_path.to_string_lossy()),
+    ]
+}
+
+/// The canonical `user@host:port` form of an SSH target, for use as a **map key
+/// for machine identity** — never as an argv item (that is [`ssh_target`], which
+/// validates; this one only normalizes).
+///
+/// Normalization matches what "the same machine and login" means in practice: the
+/// host is case-insensitive, a target with no explicit port and one pinned to 22
+/// are the same machine, and a blank user is the same as an absent one. The user
+/// itself is matched *strictly* — a different login on the same host is a
+/// different connection, and may well have different rights on it.
+///
+/// **This must stay byte-identical to the frontend's `targetKey`**
+/// (`src/lib/machineSync.ts`). Both sides index `Settings::careful_hosts` by the
+/// string this produces, so a divergence would not fail loudly — it would quietly
+/// look up a host that is not there and answer "not careful", i.e. fail *open*,
+/// in exactly the case the flag exists to protect. `target_key_matches_frontend`
+/// below pins the shape against the cases that normalization turns on.
+pub fn target_key(user: Option<&str>, host: &str, port: Option<u16>) -> String {
+    let user = user.map(str::trim).filter(|u| !u.is_empty()).unwrap_or("");
+    format!(
+        "{user}@{}:{}",
+        host.trim().to_lowercase(),
+        port.unwrap_or(22)
+    )
+}
+
+/// Render the `[user@]host` SSH target as a single, validated argv item.
+pub fn ssh_target(user: &Option<String>, host: &str) -> Result<String, String> {
+    let host = host.trim();
+    if host.is_empty() {
+        return Err("host must not be empty".to_string());
+    }
+    validate_arg("host", host)?;
+    // A bare `host` must be only a hostname: `ssh` splits the target on the LAST
+    // `@`, so an `@` smuggled into `host` (e.g. "real.host@evil.com") would
+    // silently redirect the connection to a different server. Whitespace would
+    // likewise split into extra argv-ish tokens. Reject both here, the single
+    // choke point every base-args builder funnels the target through.
+    if host.contains('@') || host.chars().any(|c| c.is_whitespace()) {
+        return Err("host must not contain '@' or whitespace".to_string());
+    }
+    match user {
+        Some(user) => {
+            let user = user.trim();
+            if user.is_empty() {
+                return Err("user must not be empty when provided".to_string());
+            }
+            validate_arg("user", user)?;
+            Ok(format!("{user}@{host}"))
+        }
+        None => Ok(host.to_string()),
+    }
+}
+
+/// Build the password-auth ssh argv: BatchMode off and only the password method
+/// enabled, so ssh never falls back to (or hangs on) keys/keyboard-interactive.
+/// The target `[user@]host` is validated and rendered as a single argv item.
+/// Shared by the browse commands (`commands::ssh`) and the SFTP session
+/// (`services::sftp`) so both authenticate identically.
+pub fn ssh_password_base_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<Vec<String>, String> {
+    authorize_dial(user, host, port, ambient_intent(user, host, port))?;
+    let mut args: Vec<String> = vec![
+        "-o".to_string(),
+        "BatchMode=no".to_string(),
+        "-o".to_string(),
+        "ConnectTimeout=10".to_string(),
+        // TOFU first contact, refuse changed keys — see `ssh_base_args`.
+        "-o".to_string(),
+        "StrictHostKeyChecking=accept-new".to_string(),
+        "-o".to_string(),
+        "PreferredAuthentications=password".to_string(),
+        "-o".to_string(),
+        "PubkeyAuthentication=no".to_string(),
+        "-o".to_string(),
+        "NumberOfPasswordPrompts=1".to_string(),
+    ];
+
+    // Ride an existing master if one is live (key-auth `ssh_base_args` does the
+    // same). Without this, a one-shot SFTP/browse for a password-auth host whose
+    // pooled session has dropped could not reuse the master and would need the
+    // password again — which we never store, so it would simply fail. With
+    // `ControlMaster=no` + the shared `cm-%C` socket it transparently rides the
+    // still-live master; if none exists it falls through to the password prompt.
+    #[cfg(not(target_os = "windows"))]
+    for opt in control_reuse_opts() {
+        args.push(opt);
+    }
+
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(ssh_target(user, host)?);
+    Ok(args)
+}
+
+/// `ssh` `-o` options that **create and persist** the shared multiplexing master
+/// (vs [`control_reuse_opts`], which only rides an existing one). Used by the
+/// pooled connection (`services::remote`) opened on activation: it owns the master
+/// so every later sftp channel / agent tab / git-over-ssh rides it with no
+/// re-auth. `%C` is expanded by `ssh`, not the shell, so it is embedded literally.
+/// Unix-only — Windows OpenSSH lacks the control socket (see
+/// `ssh_exec::ssh_pty_args`).
+#[cfg(not(target_os = "windows"))]
+fn control_master_opts() -> Vec<String> {
+    let control_path = crate::services::ssh_exec::control_dir().join("cm-%C");
+    vec![
+        "-o".to_string(),
+        "ControlMaster=auto".to_string(),
+        "-o".to_string(),
+        format!("ControlPath={}", control_path.to_string_lossy()),
+        "-o".to_string(),
+        "ControlPersist=600".to_string(),
+    ]
+}
+
+/// Base `ssh` argv for a master-**owning** connection authenticated by key/agent
+/// (`BatchMode=yes`). Like [`ssh_base_args`] but creates + persists the shared
+/// ControlMaster (and adds keepalive for the long-lived pooled session) instead
+/// of only reusing an existing master. The validated `[user@]host` target is the
+/// final argv item. Drives the pooled SFTP session in `services::remote`.
+pub fn ssh_master_base_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<Vec<String>, String> {
+    let host = host.trim();
+    if host.is_empty() {
+        return Err("host must not be empty".to_string());
+    }
+    validate_arg("host", host)?;
+    authorize_dial(user, host, port, ambient_intent(user, host, port))?;
+
+    let mut args: Vec<String> = vec![
+        "-o".to_string(),
+        "BatchMode=yes".to_string(),
+        "-o".to_string(),
+        "ConnectTimeout=10".to_string(),
+        // TOFU first contact, refuse changed keys — see `ssh_base_args`.
+        "-o".to_string(),
+        "StrictHostKeyChecking=accept-new".to_string(),
+        "-o".to_string(),
+        "ServerAliveInterval=15".to_string(),
+        "-o".to_string(),
+        "ServerAliveCountMax=3".to_string(),
+    ];
+
+    #[cfg(not(target_os = "windows"))]
+    for opt in control_master_opts() {
+        args.push(opt);
+    }
+
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(ssh_target(user, host)?);
+    Ok(args)
+}
+
+/// Password-auth variant of [`ssh_master_base_args`] (BatchMode off, password the
+/// only enabled method) for hosts reached with a supplied password (fed to ssh via
+/// [`make_askpass`], or `sshpass` on pre-8.4 Windows). Still master-owning so the
+/// one-time password authenticates the master once and every later channel rides
+/// it with no further prompt.
+pub fn ssh_password_master_base_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<Vec<String>, String> {
+    authorize_dial(user, host, port, ambient_intent(user, host, port))?;
+    let mut args: Vec<String> = vec![
+        "-o".to_string(),
+        "BatchMode=no".to_string(),
+        "-o".to_string(),
+        "ConnectTimeout=10".to_string(),
+        // TOFU first contact, refuse changed keys — see `ssh_base_args`.
+        "-o".to_string(),
+        "StrictHostKeyChecking=accept-new".to_string(),
+        "-o".to_string(),
+        "PreferredAuthentications=password".to_string(),
+        "-o".to_string(),
+        "PubkeyAuthentication=no".to_string(),
+        "-o".to_string(),
+        "NumberOfPasswordPrompts=1".to_string(),
+        "-o".to_string(),
+        "ServerAliveInterval=15".to_string(),
+        "-o".to_string(),
+        "ServerAliveCountMax=3".to_string(),
+    ];
+
+    #[cfg(not(target_os = "windows"))]
+    for opt in control_master_opts() {
+        args.push(opt);
+    }
+
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(ssh_target(user, host)?);
+    Ok(args)
+}
+
+/// Build the key-passphrase ssh argv: pubkey auth only, BatchMode off so OpenSSH
+/// *will* ask for the passphrase of an encrypted key, and every server-facing
+/// prompt disabled ([`PASSPHRASE_SINGLE_PROMPT_OPTS`]) so the passphrase can never
+/// be offered to the host as a login secret.
+///
+/// This is the path for the case the password path cannot serve at all: a key that
+/// is encrypted on disk with no agent holding it. `BatchMode=yes` (the key-auth
+/// builders) makes OpenSSH fail rather than ask, which surfaces as a bare
+/// `Permission denied (publickey)`; `PubkeyAuthentication=no` (the password
+/// builders) means the key is never even offered. Neither can unlock a key.
+///
+/// Note there is no [`guard_first_contact`] obligation here, unlike the password
+/// builders: a passphrase never leaves this machine, so first-contact TOFU is the
+/// ordinary key-auth bargain rather than a secret released to an unvetted host.
+pub fn ssh_passphrase_base_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<Vec<String>, String> {
+    authorize_dial(user, host, port, ambient_intent(user, host, port))?;
+    let mut args = passphrase_common_opts();
+
+    #[cfg(not(target_os = "windows"))]
+    for opt in control_reuse_opts() {
+        args.push(opt);
+    }
+
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(ssh_target(user, host)?);
+    Ok(args)
+}
+
+/// Master-**owning** variant of [`ssh_passphrase_base_args`], the passphrase
+/// counterpart of [`ssh_password_master_base_args`]. Owning the master is what
+/// makes this practical: the passphrase unlocks the key once, and every later
+/// sftp channel / agent tab / git-over-ssh rides the authenticated master without
+/// the key being touched again.
+pub fn ssh_passphrase_master_base_args(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<Vec<String>, String> {
+    authorize_dial(user, host, port, ambient_intent(user, host, port))?;
+    let mut args = passphrase_common_opts();
+    args.push("-o".to_string());
+    args.push("ServerAliveInterval=15".to_string());
+    args.push("-o".to_string());
+    args.push("ServerAliveCountMax=3".to_string());
+
+    #[cfg(not(target_os = "windows"))]
+    for opt in control_master_opts() {
+        args.push(opt);
+    }
+
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(ssh_target(user, host)?);
+    Ok(args)
+}
+
+/// The `-o` options shared by both passphrase builders: everything in
+/// [`PASSPHRASE_SINGLE_PROMPT_OPTS`] plus `BatchMode=no` (without which OpenSSH
+/// never raises the passphrase prompt at all) and the usual connect timeout.
+fn passphrase_common_opts() -> Vec<String> {
+    let mut args = vec![
+        "-o".to_string(),
+        "BatchMode=no".to_string(),
+        "-o".to_string(),
+        "ConnectTimeout=10".to_string(),
+    ];
+    for opt in PASSPHRASE_SINGLE_PROMPT_OPTS {
+        args.push("-o".to_string());
+        args.push(opt.to_string());
+    }
+    args
+}
+
+/// True if `sshpass` is available on `PATH`. On Unix it is no longer needed (see
+/// [`make_askpass`]) and is only reported for diagnostics; on Windows it is the
+/// fallback when the installed OpenSSH predates `SSH_ASKPASS_REQUIRE` (< 8.4,
+/// e.g. the Win10-inbox 8.1) — see [`ssh_supports_askpass`].
+pub fn sshpass_available() -> bool {
+    crate::paths::binary_on_path("sshpass")
+}
+
+/// Parse an OpenSSH version banner (`ssh -V` output, printed to STDERR) into
+/// `(major, minor)`. Handles both the stock `OpenSSH_9.6p1 …` and the Windows
+/// `OpenSSH_for_Windows_8.6p1 …` spellings by keying on the first digit run
+/// after "OpenSSH".
+pub fn parse_openssh_version(text: &str) -> Option<(u32, u32)> {
+    let rest = &text[text.find("OpenSSH")?..];
+    let rest = &rest[rest.find(|c: char| c.is_ascii_digit())?..];
+    let mut parts = rest.split(|c: char| !c.is_ascii_digit());
+    let major = parts.next()?.parse().ok()?;
+    let minor = parts.next().and_then(|s| s.parse().ok()).unwrap_or(0);
+    Some((major, minor))
+}
+
+/// Whether OpenSSH `major.minor` honors `SSH_ASKPASS_REQUIRE=force` (added in
+/// OpenSSH 8.4). Without it, ssh only consults `SSH_ASKPASS` when there is no
+/// controlling TTY *and* `DISPLAY` is set — neither reliable from a GUI app on
+/// Windows — so the askpass path needs ≥ 8.4 and older installs fall back to
+/// `sshpass`.
+pub fn version_supports_askpass_require(major: u32, minor: u32) -> bool {
+    major > 8 || (major == 8 && minor >= 4)
+}
+
+/// Whether the `ssh` on PATH is new enough for the askpass path
+/// (`SSH_ASKPASS_REQUIRE`, OpenSSH ≥ 8.4). Cached for the process lifetime —
+/// the binary does not change under a running Eldrun. Win10's inbox OpenSSH is
+/// 8.1 (→ false, sshpass fallback); Win11's is 8.6+ (→ true).
+#[cfg(windows)]
+pub fn ssh_supports_askpass() -> bool {
+    static SUPPORTED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *SUPPORTED.get_or_init(|| {
+        crate::paths::command_no_window("ssh")
+            .arg("-V")
+            .output()
+            .ok()
+            .and_then(|out| {
+                // OpenSSH prints the version banner to STDERR.
+                let text = format!(
+                    "{}{}",
+                    String::from_utf8_lossy(&out.stdout),
+                    String::from_utf8_lossy(&out.stderr)
+                );
+                parse_openssh_version(&text)
+            })
+            .map(|(major, minor)| version_supports_askpass_require(major, minor))
+            .unwrap_or(false)
+    })
+}
+
+/// Whether non-interactive password auth works on this platform **without the user
+/// installing anything**. On Unix it always does — we feed the password through
+/// OpenSSH's own `SSH_ASKPASS` mechanism ([`make_askpass`]), no external binary.
+/// On Windows the same askpass path works when OpenSSH is ≥ 8.4
+/// ([`ssh_supports_askpass`]); older installs still need `sshpass`.
+pub fn password_auth_available() -> bool {
+    #[cfg(unix)]
+    {
+        true
+    }
+    #[cfg(windows)]
+    {
+        ssh_supports_askpass() || sshpass_available()
+    }
+    #[cfg(not(any(unix, windows)))]
+    {
+        sshpass_available()
+    }
+}
+
+/// Turn OpenSSH's stderr into a message that says what the user actually got
+/// wrong, so a headless connect (where there is no terminal to read) fails with
+/// "wrong username or password" rather than `Permission denied (publickey,
+/// password).` or — worse, when stderr was discarded — an opaque SFTP EOF.
+///
+/// Returns `None` when nothing is recognized, so callers fall back to the raw
+/// text rather than replacing a specific error with a vague guess. Matching is
+/// case-insensitive and substring-based: these strings are stable OpenSSH
+/// user-facing output, but a locale/version could reword them, and a missed match
+/// costs only the raw message.
+///
+/// Order matters — the checks run most-specific first, since a changed host key
+/// also prints "Permission denied" on some versions.
+pub fn explain_ssh_error(stderr: &str) -> Option<String> {
+    let s = stderr.to_ascii_lowercase();
+
+    // Host identity problems — never conflate these with a bad password: one is a
+    // typo, the other is a possible MITM and must be surfaced as such.
+    if s.contains("remote host identification has changed")
+        || s.contains("host key verification failed")
+    {
+        return Some(
+            "The host's SSH key has changed since you last connected. This can mean the \
+             server was rebuilt — or that the connection is being intercepted. Verify the \
+             new key with the host's admin, then remove the old entry from ~/.ssh/known_hosts."
+                .to_string(),
+        );
+    }
+
+    // Reachability — these look like auth failures to a user but no credential
+    // would fix them. Call out the VPN, since that is the usual cause here.
+    if s.contains("could not resolve hostname") || s.contains("name or service not known") {
+        return Some(
+            "Unknown host — the name could not be resolved. If this host is only visible \
+             inside the VPN, bring the tunnel up first."
+                .to_string(),
+        );
+    }
+    if s.contains("connection timed out") || s.contains("operation timed out") {
+        return Some(
+            "Timed out reaching the host. If it is VPN-gated, bring the tunnel up first; \
+             otherwise check the address and port."
+                .to_string(),
+        );
+    }
+    if s.contains("connection refused") {
+        return Some(
+            "Connection refused — the host is reachable but nothing is listening on that \
+             SSH port. Check the port, and that sshd is running."
+                .to_string(),
+        );
+    }
+    if s.contains("no route to host") || s.contains("network is unreachable") {
+        return Some(
+            "No route to the host. If it is VPN-gated, bring the tunnel up first.".to_string(),
+        );
+    }
+
+    // A *local* failure that looks like an auth failure: the key on disk could not
+    // be decrypted. Must be checked before the `permission denied` branch, which
+    // ssh also prints once the unusable key leaves it with no method left.
+    if is_wrong_passphrase(stderr) {
+        return Some(
+            "That passphrase did not unlock the SSH key. Check it and try again — this is \
+             the key's own passphrase, not your login password for the host."
+                .to_string(),
+        );
+    }
+
+    // Authentication. `Permission denied` is what a wrong password looks like; the
+    // parenthesised list is the methods the *server* offers, so it tells us what
+    // the user should have been able to use.
+    if s.contains("too many authentication failures") {
+        return Some(
+            "Too many authentication failures — the server cut the connection. This often \
+             means an ssh-agent offered several wrong keys before the password was tried."
+                .to_string(),
+        );
+    }
+    if s.contains("permission denied") {
+        // Distinguish "the password was wrong" from "this server won't take a
+        // password at all", which no amount of retyping fixes.
+        let offers_password = s.contains("password") || s.contains("keyboard-interactive");
+        return Some(if offers_password {
+            "Authentication failed — check the username and password.".to_string()
+        } else {
+            "Authentication failed — this server does not accept password logins. It wants \
+             a key (the methods it offers are listed in the ssh error). Set up an SSH key, \
+             or ask the host's admin to enable password auth."
+                .to_string()
+        });
+    }
+
+    None
+}
+
+/// The one prompt Eldrun is willing to answer automatically. OpenSSH builds its
+/// password request as `"%.30s@%.128s's password: "` (`sshconnect2.c`) — a string
+/// that has been stable for two decades and that **no other** prompt it can raise
+/// shares. Matching on it is what turns the askpass shim from "answer whatever is
+/// asked" into "answer the password request, and only that".
+///
+/// The shims below implement this same test in `sh` and PowerShell; this is the
+/// Rust statement of the contract, unit-tested against every prompt OpenSSH can
+/// actually produce so the two shell spellings have something to be checked
+/// against.
+///
+/// Why a shape test at all, when [`ssh_password_base_args`] already forbids every
+/// other prompt (`PubkeyAuthentication=no` kills the passphrase request,
+/// `PreferredAuthentications=password` kills keyboard-interactive — where the
+/// *server* writes the prompt text — and `StrictHostKeyChecking=accept-new` kills
+/// the yes/no confirmation): because that safety lives in an argv the shim knows
+/// nothing about. A future caller that attaches the askpass to args missing one of
+/// those options would silently hand the password to a prompt nobody vetted. This
+/// is the same invariant enforced where it cannot be forgotten.
+pub fn prompt_is_password_request(prompt: &str) -> bool {
+    prompt.contains("'s password:")
+}
+
+/// Which secret the user typed into the one credential field, and therefore which
+/// prompt the askpass shim is allowed to answer. The two are **not**
+/// interchangeable and must never be confused: a login password is released to the
+/// *server*, while a key passphrase is a purely local secret that only unlocks a
+/// file on this machine (the server sees a signature, never the passphrase).
+/// Sending one where the other was meant is either a failed connect or — in the
+/// passphrase-as-password direction — handing a local secret to a remote host.
+/// [`secret_attempt_order`] is ordered by exactly that asymmetry.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SecretKind {
+    /// OpenSSH's own `"user@host's password: "` request.
+    Password,
+    /// OpenSSH's `"Enter passphrase for key '…': "` request, raised when the
+    /// private key on disk is encrypted and no agent holds it.
+    KeyPassphrase,
+}
+
+/// The key-passphrase counterpart of [`prompt_is_password_request`]. OpenSSH
+/// builds this one as `"Enter passphrase for key '%.100s': "` (`sshconnect2.c`),
+/// with adjacent spellings dropping the word `key` — matching the stable
+/// `"Enter passphrase for "` prefix covers both and cannot collide with the
+/// password request or with a server-authored keyboard-interactive challenge
+/// (which [`PASSPHRASE_SINGLE_PROMPT_OPTS`] disables outright).
+pub fn prompt_is_key_passphrase_request(prompt: &str) -> bool {
+    prompt.contains("Enter passphrase for ")
+}
+
+/// Whether `prompt` is the one prompt `kind` is permitted to answer.
+pub fn prompt_matches_kind(kind: SecretKind, prompt: &str) -> bool {
+    match kind {
+        SecretKind::Password => prompt_is_password_request(prompt),
+        SecretKind::KeyPassphrase => prompt_is_key_passphrase_request(prompt),
+    }
+}
+
+/// The `ssh -o` options that reduce OpenSSH to a single answerable prompt, and
+/// therefore the precondition for attaching a password to a connection at all.
+/// Each removes one prompt: the key passphrase, the server-authored
+/// keyboard-interactive challenge, the host-key `yes/no`, and the retry loop.
+const SINGLE_PROMPT_OPTS: [&str; 4] = [
+    "PubkeyAuthentication=no",
+    "PreferredAuthentications=password",
+    "StrictHostKeyChecking=accept-new",
+    "NumberOfPasswordPrompts=1",
+];
+
+/// [`SINGLE_PROMPT_OPTS`] for the passphrase path — the mirror image. Pubkey auth
+/// is the *only* method left enabled, so the sole prompt OpenSSH can raise is the
+/// local key's passphrase: `PasswordAuthentication=no` and
+/// `KbdInteractiveAuthentication=no` remove the two server-facing prompts (a
+/// passphrase must never be offered to either), and `accept-new` removes the
+/// host-key `yes/no` exactly as it does on the password path.
+const PASSPHRASE_SINGLE_PROMPT_OPTS: [&str; 4] = [
+    "PreferredAuthentications=publickey",
+    "PasswordAuthentication=no",
+    "KbdInteractiveAuthentication=no",
+    "StrictHostKeyChecking=accept-new",
+];
+
+/// Whether `args` is an ssh argv a password may safely be attached to — i.e. one
+/// carrying every option in [`SINGLE_PROMPT_OPTS`]. Returns the first missing
+/// option so the failure names what is wrong rather than just refusing.
+///
+/// This is the invariant of the whole password path made checkable: the shim can
+/// only test the prompt it is *handed*, and which prompts exist at all is decided
+/// here. [`make_askpass`] refuses on a violation, so a future caller cannot attach
+/// the askpass to args that were never vetted — the failure mode this guards is
+/// silent, and would look exactly like a working connect.
+pub fn missing_single_prompt_opt(args: &[String]) -> Option<&'static str> {
+    missing_single_prompt_opt_for(SecretKind::Password, args)
+}
+
+/// [`missing_single_prompt_opt`] for either secret kind — the checkable form of
+/// "this argv leaves ssh exactly one prompt, and it is the one `kind` answers".
+pub fn missing_single_prompt_opt_for(kind: SecretKind, args: &[String]) -> Option<&'static str> {
+    let required: &[&'static str] = match kind {
+        SecretKind::Password => &SINGLE_PROMPT_OPTS,
+        SecretKind::KeyPassphrase => &PASSPHRASE_SINGLE_PROMPT_OPTS,
+    };
+    required
+        .iter()
+        .copied()
+        .find(|opt| !args.iter().any(|a| a == opt))
+}
+
+/// A temporary, owner-only askpass shim that feeds a password to OpenSSH via its
+/// built-in `SSH_ASKPASS` mechanism — the in-tree replacement for the external
+/// `sshpass` binary. The shim script holds **no secret**: it prints whatever is
+/// in the `ELDRUN_ASKPASS` environment variable, which we set only on the
+/// specific `ssh` child (same `/proc/<pid>/environ` exposure `sshpass -e`'s
+/// `SSHPASS` had — no worse). Pairing it with `SSH_ASKPASS_REQUIRE=force` makes
+/// OpenSSH (>= 8.4) call the shim with no controlling TTY and no `DISPLAY`, which
+/// is exactly our situation (a GUI app spawning `ssh` with piped stdio). On
+/// Windows, gate on [`ssh_supports_askpass`] before taking this path.
+///
+/// The shim is **prompt-aware**: it releases the secret only for OpenSSH's own
+/// password request ([`prompt_is_password_request`]) and answers anything else
+/// with nothing at all, recording the text it refused to a side file so the caller
+/// can show the user *what* was asked ([`Askpass::refused_prompt`]). A refusal
+/// fails the connect visibly instead of leaking the password into a prompt that
+/// was never vetted.
+///
+/// The shim files are deleted when this guard is dropped, so a caller MUST keep the
+/// guard alive until the `ssh` child has finished authenticating (i.e. until the
+/// SFTP handshake / command completes, not merely until spawn returns) — and must
+/// read [`Askpass::refused_prompt`] *before* dropping it.
+#[cfg(any(unix, windows))]
+pub struct Askpass {
+    path: std::path::PathBuf,
+    /// Windows only: the PowerShell half of the shim (`%~dpn0.ps1`), which does the
+    /// prompt test cmd.exe cannot do safely. `None` on Unix.
+    helper: Option<std::path::PathBuf>,
+    /// Where the shim records a prompt it refused to answer.
+    reject: std::path::PathBuf,
+    /// Where the shim appends one byte per prompt it *answered*. See
+    /// [`Askpass::answer_count`].
+    tally: std::path::PathBuf,
+    password: String,
+}
+
+#[cfg(any(unix, windows))]
+impl Askpass {
+    /// Environment variables to set on the `ssh` (or `ssh -s`) child so OpenSSH
+    /// obtains the password from this shim instead of a controlling TTY.
+    pub fn env_vars(&self) -> Vec<(&'static str, std::ffi::OsString)> {
+        vec![
+            (
+                "SSH_ASKPASS",
+                self.path.clone().into_os_string(),
+            ),
+            ("SSH_ASKPASS_REQUIRE", std::ffi::OsString::from("force")),
+            ("ELDRUN_ASKPASS", std::ffi::OsString::from(&self.password)),
+            (
+                "ELDRUN_ASKPASS_REJECT",
+                self.reject.clone().into_os_string(),
+            ),
+            ("ELDRUN_ASKPASS_TALLY", self.tally.clone().into_os_string()),
+        ]
+    }
+
+    /// How many times the shim released the secret — one byte appended per answer.
+    ///
+    /// This is the reliable "the secret was wrong" signal on the passphrase path,
+    /// and the reason it exists: OpenSSH re-asks for a key passphrase (three times)
+    /// **only** when the previous answer failed to decrypt the key, and — as of
+    /// current releases — says nothing about it on stderr, printing just
+    /// `Permission denied (publickey)`. So a count above one is proof the secret is
+    /// a wrong passphrase, where the stderr text is merely a hint that may not
+    /// appear at all. See [`secret_rejected_locally`], which is what callers use.
+    ///
+    /// Must be read before the guard drops (dropping deletes the file).
+    pub fn answer_count(&self) -> u32 {
+        std::fs::metadata(&self.tally)
+            .map(|m| m.len().min(u32::MAX as u64) as u32)
+            .unwrap_or(0)
+    }
+
+    /// The prompt OpenSSH raised that the shim declined to answer, if any — the
+    /// evidence behind an otherwise inexplicable "Permission denied". Returned
+    /// sanitized ([`sanitize_prompt`]) because it is **untrusted text**: on the
+    /// keyboard-interactive path it is written by the server.
+    ///
+    /// `None` is the normal case (the password prompt was answered, or ssh failed
+    /// before asking anything).
+    pub fn refused_prompt(&self) -> Option<String> {
+        let raw = std::fs::read_to_string(&self.reject).ok()?;
+        let clean = sanitize_prompt(&raw);
+        (!clean.is_empty()).then_some(clean)
+    }
+}
+
+#[cfg(any(unix, windows))]
+impl Drop for Askpass {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_file(&self.path);
+        if let Some(helper) = &self.helper {
+            let _ = std::fs::remove_file(helper);
+        }
+        let _ = std::fs::remove_file(&self.reject);
+        let _ = std::fs::remove_file(&self.tally);
+    }
+}
+
+/// Flatten an untrusted prompt into something safe to put in an error message: no
+/// control characters (a server-supplied prompt could carry ANSI escapes, and this
+/// text lands in a terminal-adjacent UI), collapsed whitespace, length-capped.
+pub fn sanitize_prompt(raw: &str) -> String {
+    let mut out = String::new();
+    let mut pending_space = false;
+    for ch in raw.chars() {
+        if ch.is_control() || ch.is_whitespace() {
+            pending_space = !out.is_empty();
+            continue;
+        }
+        if pending_space {
+            out.push(' ');
+            pending_space = false;
+        }
+        out.push(ch);
+        if out.chars().count() >= 200 {
+            out.push('…');
+            break;
+        }
+    }
+    out
+}
+
+/// The error a connect fails with when the shim refused an unexpected prompt.
+/// Names the prompt (quoted, as untrusted data) and says plainly that nothing was
+/// sent — the whole point of the refusal is lost if the user is left with a bare
+/// "Permission denied" and no idea the host asked for something else.
+pub fn unexpected_prompt_error(prompt: &str) -> String {
+    format!(
+        "The host asked for something other than a password, so Eldrun sent nothing.\n\n\
+         It asked: \"{prompt}\"\n\n\
+         Only OpenSSH's own password request is answered automatically. If this host \
+         wants a verification code, a key passphrase, or a confirmation, connect from a \
+         login terminal where you can answer it yourself."
+    )
+}
+
+/// Monotonic suffix so concurrent connects never collide on the shim filename
+/// (paired with the pid, which separates instances).
+#[cfg(any(unix, windows))]
+static ASKPASS_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+/// Body of the Unix askpass shim (`ap-*.sh`). Holds no secret: the password comes
+/// from `$ELDRUN_ASKPASS`, and the prompt to answer arrives as `$1`.
+///
+/// The `case` is [`prompt_is_password_request`] in `sh`. Anything else — a key
+/// passphrase, a host-key `yes/no`, a keyboard-interactive challenge whose text
+/// the *server* chose — is written to `$ELDRUN_ASKPASS_REJECT` and answered with
+/// nothing, so ssh fails auth instead of the secret going somewhere unvetted.
+/// Exposed cfg-free so the refusal is unit-tested on any platform.
+pub fn unix_askpass_shim_body() -> &'static str {
+    r#"#!/bin/sh
+# $1 is the prompt OpenSSH wants answered. Release the secret only for OpenSSH's
+# own password request; record and refuse everything else.
+case "$1" in
+  *"'s password:"*)
+    # One byte per answer, so the caller can tell a re-ask (i.e. the previous
+    # answer was rejected) from a first ask. See `Askpass::answer_count`.
+    printf 'x' >> "$ELDRUN_ASKPASS_TALLY" 2>/dev/null
+    printf '%s\n' "$ELDRUN_ASKPASS"
+    ;;
+  *)
+    printf '%s' "$1" > "$ELDRUN_ASKPASS_REJECT" 2>/dev/null
+    exit 1
+    ;;
+esac
+"#
+}
+
+/// [`unix_askpass_shim_body`] for the key-passphrase path: the same shim with the
+/// one permitted prompt swapped for [`prompt_is_key_passphrase_request`]. Written
+/// as a second literal script rather than a pattern injected through the
+/// environment so each shim still *states* its own contract — an env-supplied glob
+/// would land unquoted in `case`, which is precisely the kind of indirection this
+/// shim exists to avoid.
+pub fn unix_passphrase_askpass_shim_body() -> &'static str {
+    r#"#!/bin/sh
+# $1 is the prompt OpenSSH wants answered. Release the secret only for OpenSSH's
+# local key-passphrase request; record and refuse everything else — in particular
+# any prompt whose answer would travel to the server.
+case "$1" in
+  "Enter passphrase for "*)
+    # One byte per answer. OpenSSH re-asks only when the key failed to decrypt,
+    # so a tally above one IS the wrong-passphrase signal — see
+    # `Askpass::answer_count`.
+    printf 'x' >> "$ELDRUN_ASKPASS_TALLY" 2>/dev/null
+    printf '%s\n' "$ELDRUN_ASKPASS"
+    ;;
+  *)
+    printf '%s' "$1" > "$ELDRUN_ASKPASS_REJECT" 2>/dev/null
+    exit 1
+    ;;
+esac
+"#
+}
+
+/// The shim body for `kind` — [`unix_askpass_shim_body`] or
+/// [`unix_passphrase_askpass_shim_body`].
+pub fn unix_shim_body_for(kind: SecretKind) -> &'static str {
+    match kind {
+        SecretKind::Password => unix_askpass_shim_body(),
+        SecretKind::KeyPassphrase => unix_passphrase_askpass_shim_body(),
+    }
+}
+
+/// Write an owner-only (0700) askpass shim for `password` and return a guard that
+/// deletes it on drop. The shim reads the password from the `ELDRUN_ASKPASS` env
+/// var (set via [`Askpass::env_vars`]), so the secret never lands in the file.
+///
+/// `args` is the ssh argv the shim will be attached to, and is **checked, not
+/// merely recorded**: a command that does not reduce ssh to one answerable prompt
+/// ([`missing_single_prompt_opt`]) is refused outright. Pass the args from
+/// [`ssh_password_base_args`] / [`ssh_password_master_base_args`].
+#[cfg(unix)]
+pub fn make_askpass(password: &str, args: &[String]) -> Result<Askpass, String> {
+    make_askpass_for(SecretKind::Password, password, args)
+}
+
+/// [`make_askpass`] for either secret kind: same argv check (against the option
+/// set `kind` requires) and same delete-on-drop guard, with the shim body that
+/// releases the secret only to `kind`'s prompt.
+#[cfg(unix)]
+pub fn make_askpass_for(
+    kind: SecretKind,
+    password: &str,
+    args: &[String],
+) -> Result<Askpass, String> {
+    use std::io::Write;
+    use std::os::unix::fs::OpenOptionsExt;
+    use std::sync::atomic::Ordering;
+
+    if let Some(missing) = missing_single_prompt_opt_for(kind, args) {
+        return Err(format!(
+            "refusing to attach a secret to an ssh command that does not set \
+             {missing} — it could be asked for something other than the secret we hold"
+        ));
+    }
+    let dir = crate::storage::state_dir().join("ssh-askpass");
+    std::fs::create_dir_all(&dir).map_err(|e| format!("create askpass dir: {e}"))?;
+    let seq = ASKPASS_SEQ.fetch_add(1, Ordering::Relaxed);
+    let stem = format!("ap-{}-{seq}", std::process::id());
+    let path = dir.join(format!("{stem}.sh"));
+    let mut f = std::fs::OpenOptions::new()
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .mode(0o700)
+        .open(&path)
+        .map_err(|e| format!("create askpass shim: {e}"))?;
+    // The password comes from the environment; the script itself is generic.
+    f.write_all(unix_shim_body_for(kind).as_bytes())
+        .map_err(|e| format!("write askpass shim: {e}"))?;
+    Ok(Askpass {
+        path,
+        helper: None,
+        reject: dir.join(format!("{stem}.reject")),
+        tally: dir.join(format!("{stem}.tally")),
+        password: password.to_string(),
+    })
+}
+
+/// Body of the Windows askpass shim (`ap-*.cmd`). It must echo the secret via
+/// PowerShell, NOT `@echo %ELDRUN_ASKPASS%`: cmd re-parses the expanded value,
+/// so `& | < > ^` in a password would be executed/mangled. PowerShell receives
+/// the variable through the environment block and writes it verbatim. Secret-
+/// free, like the Unix shim. Exposed cfg-free so the no-interpolation property
+/// is unit-tested on Linux.
+///
+/// **Deliberately prompt-blind**, unlike [`unix_askpass_shim_body`]. Testing the
+/// prompt here would mean forwarding it into the batch file (`%1`/`%*`), and cmd
+/// re-parses batch-argument expansions exactly as it re-parses `%VAR%` — so a
+/// prompt carrying `&` would be *executed*. That trades a narrow disclosure for a
+/// command injection, on the one platform whose shell semantics cannot be checked
+/// locally. Windows therefore rests on the argv restrictions alone
+/// ([`ssh_password_base_args`], which are identical on every platform) plus the
+/// cross-platform [`guard_first_contact`]. Revisit if the shim is ever replaced by
+/// a real executable, where argv needs no shell at all.
+/// The answer tally ([`Askpass::answer_count`]) is written from inside the *same*
+/// PowerShell command, not by a `cmd` redirect: `@echo x>>"%ELDRUN_ASKPASS_TALLY%"`
+/// would put the path through exactly the `%VAR%` re-parse this shim exists to
+/// avoid, and a state-dir path carries the Windows account name. PowerShell reads
+/// it from the environment block instead, so no shell ever re-parses it.
+pub fn windows_askpass_shim_body() -> &'static str {
+    "@powershell.exe -NoProfile -NonInteractive -Command \
+     \"Add-Content -LiteralPath $env:ELDRUN_ASKPASS_TALLY -Value 'x' -NoNewline \
+     -ErrorAction SilentlyContinue; [Console]::Out.WriteLine($env:ELDRUN_ASKPASS)\"\r\n"
+}
+
+/// Windows counterpart of the Unix [`make_askpass`]: writes an `ap-{pid}-{seq}.cmd`
+/// shim (see [`windows_askpass_shim_body`]) and returns the delete-on-drop guard.
+/// Only valid when [`ssh_supports_askpass`] is true — callers gate on that and
+/// fall back to `sshpass` otherwise. No `mode(0o700)` here: the state dir is
+/// under the user profile, and the file holds no secret anyway.
+#[cfg(windows)]
+pub fn make_askpass(password: &str, args: &[String]) -> Result<Askpass, String> {
+    make_askpass_for(SecretKind::Password, password, args)
+}
+
+/// [`make_askpass`] for either secret kind. The shim body is the same on Windows
+/// either way — it is prompt-blind (see [`windows_askpass_shim_body`]) — so `kind`
+/// only selects which option set the argv is checked against.
+#[cfg(windows)]
+pub fn make_askpass_for(
+    kind: SecretKind,
+    password: &str,
+    args: &[String],
+) -> Result<Askpass, String> {
+    use std::sync::atomic::Ordering;
+
+    // The Windows shim is prompt-blind (see `windows_askpass_shim_body`), so this
+    // argv check is the ONLY thing standing between the secret and a prompt
+    // nobody vetted. It is not defence in depth here — it is the defence.
+    if let Some(missing) = missing_single_prompt_opt_for(kind, args) {
+        return Err(format!(
+            "refusing to attach a secret to an ssh command that does not set \
+             {missing} — it could be asked for something other than the secret we hold"
+        ));
+    }
+    let dir = crate::storage::state_dir().join("ssh-askpass");
+    std::fs::create_dir_all(&dir).map_err(|e| format!("create askpass dir: {e}"))?;
+    let seq = ASKPASS_SEQ.fetch_add(1, Ordering::Relaxed);
+    let stem = format!("ap-{}-{seq}", std::process::id());
+    let path = dir.join(format!("{stem}.cmd"));
+    std::fs::write(&path, windows_askpass_shim_body())
+        .map_err(|e| format!("write askpass shim: {e}"))?;
+    Ok(Askpass {
+        path,
+        // No PowerShell half on Windows: the shim is prompt-blind there, so the
+        // reject file simply never gets written and `refused_prompt` is always
+        // `None`. See `windows_askpass_shim_body`.
+        helper: None,
+        reject: dir.join(format!("{stem}.reject")),
+        tally: dir.join(format!("{stem}.tally")),
+        password: password.to_string(),
+    })
+}
+
+// ── Locked keys: which secret the one credential field actually holds ───────
+//
+// A passphrase-protected private key with no agent to hold it is the one auth
+// shape neither existing path could serve. Key auth runs `BatchMode=yes`, so
+// OpenSSH fails instead of asking and the user sees a bare
+// `Permission denied (publickey)`; the password path sets
+// `PubkeyAuthentication=no`, so the key is never offered and the typed secret
+// goes to the server as a login password — which for a passphrase means leaking a
+// local secret to the host. The helpers below decide, before either is tried,
+// whether the host resolves to an encrypted key on disk.
+
+/// Whether a private key file's contents are encrypted: `Some(true)`/`Some(false)`
+/// when the format is recognised, `None` when it is not a private key we can read
+/// (callers treat `None` as "don't know", never as "unencrypted").
+///
+/// Three formats, because a user's `~/.ssh` accumulates all of them:
+///   - PKCS#8 (`BEGIN ENCRYPTED PRIVATE KEY`) — encrypted by its very header.
+///   - Legacy PEM (`BEGIN RSA PRIVATE KEY` + `Proc-Type: 4,ENCRYPTED`).
+///   - `openssh-key-v1`, the modern default, which says nothing in its header:
+///     the cipher name is the first field of the base64 body, and `none` is the
+///     literal OpenSSH writes for an unencrypted key.
+///
+/// Pure and unit-tested — the decision it feeds (which secret goes where) is one
+/// where being wrong is a disclosure, not just a failed connect.
+pub fn private_key_is_encrypted(text: &str) -> Option<bool> {
+    use base64::Engine;
+
+    if text.contains("ENCRYPTED PRIVATE KEY") || text.contains("Proc-Type: 4,ENCRYPTED") {
+        return Some(true);
+    }
+
+    const HEADER: &str = "-----BEGIN OPENSSH PRIVATE KEY-----";
+    if let Some(start) = text.find(HEADER) {
+        // The cipher name sits within the first few dozen bytes, so decoding a
+        // prefix of the body is enough — no need to read a whole 4k RSA key.
+        let body: String = text[start + HEADER.len()..]
+            .lines()
+            .skip_while(|l| l.trim().is_empty())
+            .take_while(|l| !l.starts_with("-----"))
+            .flat_map(|l| l.chars())
+            .filter(|c| !c.is_whitespace())
+            .take(64)
+            .collect();
+        // Trim to a whole number of base64 quanta so the truncated prefix decodes.
+        let body = &body[..body.len() - body.len() % 4];
+        let raw = base64::engine::general_purpose::STANDARD_NO_PAD
+            .decode(body)
+            .ok()?;
+        const MAGIC: &[u8] = b"openssh-key-v1\0";
+        let rest = raw.strip_prefix(MAGIC)?;
+        let len = u32::from_be_bytes(rest.get(..4)?.try_into().ok()?) as usize;
+        let cipher = rest.get(4..4 + len)?;
+        return Some(cipher != b"none");
+    }
+
+    text.contains("PRIVATE KEY").then_some(false)
+}
+
+/// The identity files OpenSSH would actually offer for `[user@]host[:port]`, in
+/// its own order, after `~/.ssh/config` is applied — asked of `ssh -G` for the
+/// same reason [`resolve_host_port`] is: a `Host` alias can pin an `IdentityFile`
+/// that nothing in Eldrun's own state knows about. Paths are `~`-expanded (ssh
+/// prints them unexpanded) and returned whether or not they exist.
+pub fn resolve_identity_files(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Vec<std::path::PathBuf> {
+    let Ok(target) = ssh_target(user, host) else {
+        return Vec::new();
+    };
+    let mut cmd = crate::paths::command_no_window("ssh");
+    cmd.arg("-G");
+    if let Some(p) = port {
+        cmd.arg("-p").arg(p.to_string());
+    }
+    cmd.arg(target);
+    let Ok(out) = cmd.output() else {
+        return Vec::new();
+    };
+    String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter_map(|line| {
+            let mut tok = line.split_whitespace();
+            match (tok.next(), tok.next()) {
+                (Some("identityfile"), Some(path)) => Some(expand_home(path)),
+                _ => None,
+            }
+        })
+        .collect()
+}
+
+/// Expand a leading `~/` against the user's home. `ssh -G` prints identity paths
+/// exactly as configured, so this is the one substitution needed to open them.
+fn expand_home(path: &str) -> std::path::PathBuf {
+    match path.strip_prefix("~/") {
+        Some(rest) => crate::paths::home_dir().join(rest),
+        None => std::path::PathBuf::from(path),
+    }
+}
+
+/// Whether an ssh-agent is reachable *and* holds at least one key. When it does,
+/// an encrypted key on disk is not a problem — the agent already has the unlocked
+/// form and OpenSSH never raises a passphrase prompt.
+///
+/// **Fails closed** (returns `false`) when `ssh-add` cannot be run at all: the
+/// consequence is only that a passphrase attempt is tried first, which costs a
+/// round trip and discloses nothing.
+pub fn agent_has_keys() -> bool {
+    if std::env::var_os("SSH_AUTH_SOCK").is_none() {
+        return false;
+    }
+    crate::paths::command_no_window("ssh-add")
+        .arg("-l")
+        .output()
+        // `-l` exits 0 with the key list, 1 with "no identities", 2 with no agent.
+        .map(|out| out.status.success())
+        .unwrap_or(false)
+}
+
+/// The first identity OpenSSH would offer this host that exists on disk and is
+/// encrypted, or `None` — i.e. "this host resolves to a locked key". Returns
+/// `None` when an agent already holds keys, since then nothing is locked from
+/// OpenSSH's point of view.
+pub fn locked_identity(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Option<std::path::PathBuf> {
+    if agent_has_keys() {
+        return None;
+    }
+    resolve_identity_files(user, host, port).into_iter().find(|p| {
+        std::fs::read_to_string(p)
+            .ok()
+            .and_then(|text| private_key_is_encrypted(&text))
+            .unwrap_or(false)
+    })
+}
+
+/// The order to try the user's one typed secret in, for a host that may want
+/// either. Ordering is a **security** decision, not a heuristic preference: a
+/// passphrase tried as a password is released to the server, whereas a password
+/// tried as a passphrase only fails to decrypt a local file. So whenever the host
+/// resolves to a locked key ([`locked_identity`]), the passphrase is tried first
+/// and the password path is the fallback; otherwise there is nothing to unlock and
+/// the password is the only candidate.
+pub fn secret_attempt_order(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Vec<SecretKind> {
+    match locked_identity(user, host, port) {
+        Some(_) => vec![SecretKind::KeyPassphrase, SecretKind::Password],
+        None => vec![SecretKind::Password],
+    }
+}
+
+/// [`secret_attempt_order`] for an **async** caller, off the runtime's thread for
+/// the same reason [`guard_first_contact_async`] is: it spawns `ssh -G`/`ssh-add`
+/// and reads key files.
+pub async fn secret_attempt_order_async(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Vec<SecretKind> {
+    let (user, host) = (user.clone(), host.to_string());
+    tokio::task::spawn_blocking(move || secret_attempt_order(&user, &host, port))
+        .await
+        .unwrap_or_else(|_| vec![SecretKind::Password])
+}
+
+/// [`locked_key_hint`] for an **async** caller.
+pub async fn locked_key_hint_async(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Option<String> {
+    let (user, host) = (user.clone(), host.to_string());
+    tokio::task::spawn_blocking(move || locked_key_hint(&user, &host, port))
+        .await
+        .ok()
+        .flatten()
+}
+
+/// Whether ssh's stderr says the secret failed to *decrypt the local key* — as
+/// opposed to any failure involving the server. This is what makes the
+/// passphrase→password fallback in [`secret_attempt_order`] safe to stop early:
+/// once OpenSSH has told us the secret is a wrong passphrase, retrying it as a
+/// login password would send a local secret to the host for nothing.
+pub fn is_wrong_passphrase(stderr: &str) -> bool {
+    let s = stderr.to_ascii_lowercase();
+    s.contains("incorrect passphrase") || s.contains("error in libcrypto")
+}
+
+/// Whether a failed attempt proves the secret was rejected **locally** — i.e. it
+/// is a wrong key passphrase — and so must NOT be retried as a login password.
+///
+/// This is the gate on the passphrase→password fallback, and it is deliberately
+/// belt-and-braces because getting it wrong means sending a local secret to a
+/// remote host:
+///   - the askpass tally ([`Askpass::answer_count`]) — OpenSSH re-asks only after
+///     a failed decrypt, so >1 answer is *proof*. This is the load-bearing one:
+///     current OpenSSH prints nothing about the decrypt failure and exits with a
+///     plain `Permission denied (publickey)`.
+///   - [`is_wrong_passphrase`] on stderr — a hint that some versions do print,
+///     and the only signal available when no shim ran (the Windows `sshpass`
+///     path, which cannot serve a passphrase anyway).
+///
+/// Always false for [`SecretKind::Password`]: there is nothing after it to fall
+/// back to.
+#[cfg(any(unix, windows))]
+pub fn secret_rejected_locally(
+    kind: SecretKind,
+    askpass: Option<&Askpass>,
+    stderr: &str,
+) -> bool {
+    kind == SecretKind::KeyPassphrase
+        && (askpass.is_some_and(|a| a.answer_count() > 1) || is_wrong_passphrase(stderr))
+}
+
+/// The message for an attempt [`secret_rejected_locally`] identified — stated as
+/// what it is, since OpenSSH's own `Permission denied (publickey)` blames the
+/// server for a file that never decrypted.
+pub fn wrong_passphrase_error() -> String {
+    "That passphrase did not unlock the SSH key. Check it and try again — this is the \
+     key's own passphrase, not your login password for the host."
+        .to_string()
+}
+
+/// The advice to append when a **no-secret** key-auth connect was denied and the
+/// host resolves to a locked key — the case whose bare
+/// `Permission denied (publickey)` sends users looking for a server-side problem
+/// that isn't there. Returns `None` when nothing is locked, so the original error
+/// stands unembellished.
+pub fn locked_key_hint(user: &Option<String>, host: &str, port: Option<u16>) -> Option<String> {
+    let key = locked_identity(user, host, port)?;
+    Some(format!(
+        "The SSH key for this host ({}) is protected by a passphrase, and no ssh-agent \
+         is holding it — so the connection had no way to unlock it. Enter the key's \
+         passphrase in the password field and connect again, or run `ssh-add {}` in a \
+         terminal first to unlock it for the whole session.",
+        key.display(),
+        key.display()
+    ))
+}
+
+// ── First contact: verify the host key before releasing a password ──────────
+//
+// `StrictHostKeyChecking=accept-new` is what keeps every headless path from
+// hanging on an unanswerable yes/no, and it refuses a *changed* key outright —
+// but it accepts a *first* key silently. For key auth that is the ordinary TOFU
+// bargain. For **password** auth it is not: the secret goes to whoever answered
+// the connection, and nobody was ever shown the fingerprint they were implicitly
+// trusting. This is the one place where "show me, then decide" is load-bearing,
+// so a password is never released to a host whose key is not already known.
+//
+// No new persisted state backs this: `accept-new` writes the key to known_hosts
+// on the first successful connect, so the gate clears itself. Confirming in the
+// UI does the same thing eagerly via [`trust_host_key`].
+
+/// Marker prefix on the error a password connect fails with when the host's key
+/// has never been seen. The frontend keys on this exact string to raise the
+/// fingerprint-confirmation dialog instead of showing a dead end; keep them in
+/// step (`src/lib/hostKey.ts`).
+pub const UNKNOWN_HOST_KEY: &str = "ELDRUN_UNKNOWN_HOST_KEY";
+
+/// How OpenSSH itself resolves `[user@]host[:port]` after `~/.ssh/config` is
+/// applied — `ssh -G` prints the effective settings without connecting. Needed
+/// because a `Host` alias can map to an entirely different `hostname`/`port`, and
+/// known_hosts is keyed by the *resolved* pair: checking the alias would call a
+/// long-trusted host unknown, and scanning it would fetch nothing.
+///
+/// Falls back to the arguments as given when `ssh -G` is unavailable or silent.
+pub fn resolve_host_port(host: &str, port: Option<u16>) -> (String, u16) {
+    let fallback = (host.to_string(), port.unwrap_or(22));
+    let mut cmd = crate::paths::command_no_window("ssh");
+    cmd.arg("-G");
+    if let Some(p) = port {
+        cmd.arg("-p").arg(p.to_string());
+    }
+    cmd.arg(host);
+    let Ok(out) = cmd.output() else {
+        return fallback;
+    };
+    let text = String::from_utf8_lossy(&out.stdout);
+    let mut resolved_host = None;
+    let mut resolved_port = None;
+    for line in text.lines() {
+        let mut tok = line.split_whitespace();
+        match (tok.next(), tok.next()) {
+            (Some("hostname"), Some(v)) => resolved_host = Some(v.to_string()),
+            (Some("port"), Some(v)) => resolved_port = v.parse().ok(),
+            _ => {}
+        }
+    }
+    (
+        resolved_host.unwrap_or(fallback.0),
+        resolved_port.unwrap_or(fallback.1),
+    )
+}
+
+/// The known_hosts lookup key for a resolved host/port: a bare hostname on the
+/// default port, `[host]:port` otherwise — the bracketed form OpenSSH writes and
+/// `ssh-keygen -F` expects.
+pub fn known_hosts_key(host: &str, port: u16) -> String {
+    if port == 22 {
+        host.to_string()
+    } else {
+        format!("[{host}]:{port}")
+    }
+}
+
+/// Whether this host already has an accepted key in a known_hosts file.
+///
+/// Delegates to `ssh-keygen -F` rather than parsing known_hosts: the file is
+/// commonly hashed (`HashKnownHosts yes`), which makes a hand-rolled lookup
+/// useless, and `-F` searches the global file too.
+///
+/// **Fails open** when `ssh-keygen` cannot be run at all — it ships with the ssh
+/// client on every platform Eldrun supports, so its absence means something is
+/// broken about the install, and blocking every password connect on that would be
+/// a worse failure than the TOFU window this closes.
+pub fn host_key_known(host: &str, port: u16) -> bool {
+    let mut cmd = crate::paths::command_no_window("ssh-keygen");
+    cmd.arg("-F").arg(known_hosts_key(host, port));
+    match cmd.output() {
+        // `-F` exits 0 and prints the entry when found, 1 when not.
+        Ok(out) => out.status.success() && !out.stdout.is_empty(),
+        Err(_) => true,
+    }
+}
+
+/// Refuse to release a password to a host whose key has never been accepted.
+/// Called by every password-auth path *before* the askpass is attached; returns
+/// the [`UNKNOWN_HOST_KEY`]-marked error the frontend turns into the fingerprint
+/// dialog.
+pub fn guard_first_contact(host: &str, port: Option<u16>) -> Result<(), String> {
+    let (resolved, resolved_port) = resolve_host_port(host, port);
+    if host_key_known(&resolved, resolved_port) {
+        return Ok(());
+    }
+    Err(format!(
+        "{UNKNOWN_HOST_KEY} {resolved}:{resolved_port} — this host's SSH key has never \
+         been accepted on this machine. Verify its fingerprint before sending a password."
+    ))
+}
+
+/// [`guard_first_contact`] for an **async** caller. The gate spawns two short
+/// local subprocesses (`ssh -G`, `ssh-keygen -F` — no network), which is tens of
+/// milliseconds of a tokio worker thread blocked; the SFTP openers run on the
+/// runtime that also serves the UI's commands, so they take this form rather than
+/// paying that on an executor thread.
+pub async fn guard_first_contact_async(host: &str, port: Option<u16>) -> Result<(), String> {
+    let host = host.to_string();
+    tokio::task::spawn_blocking(move || guard_first_contact(&host, port))
+        .await
+        .map_err(|e| format!("host key check failed: {e}"))?
+}
+
+/// One host key offered by a host, as the confirmation dialog shows it.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
+pub struct HostKeyFingerprint {
+    /// Key algorithm as OpenSSH names it (`ssh-ed25519`, `rsa-sha2-512`, …).
+    pub key_type: String,
+    /// `SHA256:…` — the form OpenSSH prints in its own confirmation prompt, so the
+    /// user can compare it against what an admin or another client shows them.
+    pub fingerprint: String,
+    /// Key size in bits, as reported by `ssh-keygen -l`.
+    pub bits: u32,
+}
+
+/// Parse `ssh-keyscan` output into `(known_hosts line, fingerprint)` pairs by
+/// piping it through `ssh-keygen -lf -`. The two are zipped by position: keyscan
+/// emits one key per line and `-l` one fingerprint per line, in order.
+fn fingerprint_scan(scan: &str) -> Vec<HostKeyFingerprint> {
+    use std::io::Write;
+    use std::process::Stdio;
+
+    let lines: Vec<&str> = scan
+        .lines()
+        .map(str::trim)
+        .filter(|l| !l.is_empty() && !l.starts_with('#'))
+        .collect();
+    if lines.is_empty() {
+        return Vec::new();
+    }
+    let mut child = match crate::paths::command_no_window("ssh-keygen")
+        .arg("-l")
+        .arg("-f")
+        .arg("-")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+    {
+        Ok(c) => c,
+        Err(_) => return Vec::new(),
+    };
+    if let Some(mut stdin) = child.stdin.take() {
+        let _ = stdin.write_all(scan.as_bytes());
+    }
+    let Ok(out) = child.wait_with_output() else {
+        return Vec::new();
+    };
+    parse_keygen_fingerprints(&String::from_utf8_lossy(&out.stdout))
+}
+
+/// Parse `ssh-keygen -l` output: `<bits> SHA256:<b64> <comment> (<TYPE>)`.
+/// Pure, so the format assumption is unit-tested rather than discovered at
+/// runtime. Lines that do not match are skipped.
+pub fn parse_keygen_fingerprints(text: &str) -> Vec<HostKeyFingerprint> {
+    text.lines()
+        .filter_map(|line| {
+            let line = line.trim();
+            let mut tok = line.split_whitespace();
+            let bits: u32 = tok.next()?.parse().ok()?;
+            let fingerprint = tok.next()?.to_string();
+            if !fingerprint.starts_with("SHA256:") && !fingerprint.starts_with("MD5:") {
+                return None;
+            }
+            // The algorithm is the parenthesised last token.
+            let key_type = line
+                .rsplit_once('(')
+                .and_then(|(_, rest)| rest.strip_suffix(')'))
+                .unwrap_or("unknown")
+                .to_string();
+            Some(HostKeyFingerprint {
+                key_type,
+                fingerprint,
+                bits,
+            })
+        })
+        .collect()
+}
+
+/// Fetch the keys a host currently offers, for the confirmation dialog. One
+/// `ssh-keyscan`, bounded by its own `-T` timeout so an unreachable host fails
+/// fast instead of hanging the modal.
+///
+/// Returns the raw keyscan text alongside the fingerprints: accepting the host
+/// means appending exactly those lines to known_hosts, and re-scanning at that
+/// point would leave a window where the key shown is not the key stored.
+pub fn scan_host_keys(host: &str, port: Option<u16>) -> Result<(String, Vec<HostKeyFingerprint>), String> {
+    validate_arg("host", host)?;
+    let (resolved, resolved_port) = resolve_host_port(host, port);
+    validate_arg("host", &resolved)?;
+    let mut cmd = crate::paths::command_no_window("ssh-keyscan");
+    cmd.arg("-T").arg("8");
+    if resolved_port != 22 {
+        cmd.arg("-p").arg(resolved_port.to_string());
+    }
+    cmd.arg(&resolved);
+    let out = cmd
+        .output()
+        .map_err(|e| format!("ssh-keyscan could not be run: {e}"))?;
+    let scan = String::from_utf8_lossy(&out.stdout).to_string();
+    let keys = fingerprint_scan(&scan);
+    if keys.is_empty() {
+        let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+        return Err(if stderr.is_empty() {
+            format!("no SSH key could be read from {resolved}:{resolved_port}")
+        } else {
+            explain_ssh_error(&stderr).unwrap_or(stderr)
+        });
+    }
+    Ok((scan, keys))
+}
+
+/// Record the user's acceptance of a host's key by appending the scanned
+/// known_hosts lines — the same thing `accept-new` would have done, done
+/// deliberately after the fingerprint was shown. Idempotent-ish: a duplicate line
+/// is harmless to OpenSSH, and the [`host_key_known`] gate stops calling this once
+/// the entry exists.
+///
+/// `scan` must be the text [`scan_host_keys`] returned, so the key stored is the
+/// key the user was shown.
+pub fn trust_host_key(scan: &str) -> Result<(), String> {
+    use std::io::Write;
+
+    let lines: Vec<&str> = scan
+        .lines()
+        .map(str::trim)
+        .filter(|l| !l.is_empty() && !l.starts_with('#'))
+        .collect();
+    if lines.is_empty() {
+        return Err("nothing to trust — the host key scan was empty".to_string());
+    }
+    let dir = crate::paths::home_dir().join(".ssh");
+    std::fs::create_dir_all(&dir).map_err(|e| format!("create ~/.ssh: {e}"))?;
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let _ = std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700));
+    }
+    let path = dir.join("known_hosts");
+    let mut f = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .map_err(|e| format!("open known_hosts: {e}"))?;
+    for line in lines {
+        writeln!(f, "{line}").map_err(|e| format!("write known_hosts: {e}"))?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn target_key_matches_frontend() {
+        // The four normalizations `lib/machineSync.ts`'s `targetKey` applies. A
+        // divergence here fails OPEN (a careful host looked up under a key nobody
+        // wrote reads as "not careful"), so each is pinned rather than trusted.
+        let k = |u: Option<&str>, h: &str, p: Option<u16>| target_key(u, h, p);
+        // Host case-insensitive.
+        assert_eq!(k(Some("alice"), "Login.Example.Org", Some(22)), k(Some("alice"), "login.example.org", Some(22)));
+        // No port ≡ port 22.
+        assert_eq!(k(Some("alice"), "h", None), k(Some("alice"), "h", Some(22)));
+        // Blank user ≡ absent user.
+        assert_eq!(k(Some("   "), "h", None), k(None, "h", None));
+        // Surrounding whitespace is not part of the identity.
+        assert_eq!(k(Some(" alice "), " h ", None), k(Some("alice"), "h", None));
+        // The exact wire shape both sides format.
+        assert_eq!(k(Some("alice"), "login.example.org", Some(2222)), "alice@login.example.org:2222");
+        assert_eq!(k(None, "h", None), "@h:22");
+        // A different login on the same host is a DIFFERENT machine identity —
+        // it may hold different rights on it, so this must not collapse.
+        assert_ne!(k(Some("a"), "h", None), k(Some("b"), "h", None));
+        // A different port likewise (a tunnel/jump endpoint is not the host).
+        assert_ne!(k(Some("a"), "h", Some(22)), k(Some("a"), "h", Some(2222)));
+    }
+
+    // ── Dial policy ────────────────────────────────────────────────────────
+
+    /// The whole policy as a table. Split out of [`authorize_dial`] precisely so
+    /// it can be stated without a `settings.json` on disk: exactly one of the
+    /// four combinations refuses, and the refusal is the sentinel
+    /// `src/lib/hpcGuard.ts` already parses (three whitespace-separated fields).
+    #[test]
+    fn only_a_background_dial_at_a_tagged_host_is_refused() {
+        let key = "alice@login.example:22";
+        assert!(dial_refusal(false, DialIntent::Background, key).is_none());
+        assert!(dial_refusal(false, DialIntent::UserInitiated, key).is_none());
+        assert!(dial_refusal(true, DialIntent::UserInitiated, key).is_none());
+        let err = dial_refusal(true, DialIntent::Background, key).unwrap();
+        assert_eq!(err, "ELDRUN_HPC_GUARD connect alice@login.example:22");
+        assert_eq!(err.split_whitespace().count(), 3);
+    }
+
+    /// Background is the default, and it comes back on its own. The guard is what
+    /// scopes an authorization to one command — leaking one would silently license
+    /// every later background dial at that machine for the rest of the session.
+    #[test]
+    fn a_dial_is_background_until_something_authorizes_that_target() {
+        let (user, host) = (Some("alice".to_string()), "scope.example");
+        assert_eq!(ambient_intent(&user, host, None), DialIntent::Background);
+        {
+            let _guard = user_dial(&user, host, None);
+            assert_eq!(ambient_intent(&user, host, None), DialIntent::UserInitiated);
+            // Keyed by target: authorizing one machine authorizes only that one.
+            assert_eq!(
+                ambient_intent(&user, "elsewhere.example", None),
+                DialIntent::Background
+            );
+        }
+        assert_eq!(ambient_intent(&user, host, None), DialIntent::Background);
+    }
+
+    /// One machine legitimately carries several authorizations at once — a login
+    /// node is at once a project's primary, another project's worker and a global
+    /// machine — so releasing one must not revoke the others.
+    #[test]
+    fn authorizations_are_refcounted_rather_than_a_flag() {
+        let (user, host) = (Some("bob".to_string()), "refcount.example");
+        remember_user_connect(&user, host, None);
+        {
+            let _guard = user_dial(&user, host, None);
+            assert_eq!(ambient_intent(&user, host, None), DialIntent::UserInitiated);
+        }
+        // The scoped guard dropped; the standing pooled-connection one did not.
+        assert_eq!(ambient_intent(&user, host, None), DialIntent::UserInitiated);
+        forget_user_connect(&user, host, None);
+        assert_eq!(ambient_intent(&user, host, None), DialIntent::Background);
+    }
+
+    /// The `background` parameter's polarity, which is the whole safety property
+    /// of the second shape: `None` — an un-updated caller, a new caller, a caller
+    /// that forgot — must read the same as `Some(true)`. Only an explicit "a
+    /// person is waiting" is one.
+    #[test]
+    fn only_an_explicit_not_background_is_a_gesture() {
+        let (user, host) = (Some("alice".to_string()), "declared.example");
+        assert!(declared_dial(None, &user, host, None).is_none());
+        assert!(declared_dial(Some(true), &user, host, None).is_none());
+        let guard = declared_dial(Some(false), &user, host, None);
+        assert!(guard.is_some());
+        assert_eq!(ambient_intent(&user, host, None), DialIntent::UserInitiated);
+        drop(guard);
+        assert_eq!(ambient_intent(&user, host, None), DialIntent::Background);
+    }
+
+    /// The registry is indexed by [`target_key`], so an authorization taken with
+    /// the host spelled one way covers the same machine spelled another — the same
+    /// normalization the HPC tag itself is looked up under.
+    #[test]
+    fn an_authorization_follows_target_key_normalization() {
+        let _guard = user_dial(&Some("alice".into()), "Case.Example", None);
+        assert_eq!(
+            ambient_intent(&Some(" alice ".into()), "case.example", Some(22)),
+            DialIntent::UserInitiated
+        );
+    }
+
+    /// An ssh argv a password may legitimately be attached to — i.e. one that
+    /// leaves ssh exactly one answerable prompt.
+    /// Run an askpass shim the way OpenSSH does — argv[1] is the prompt, the
+    /// secret is in the environment — retrying while the exec reports ETXTBSY.
+    ///
+    /// The retry is about the *test suite's* concurrency, not about the shim:
+    /// Rust's `Command` forks before it execs, so a child forked by any other
+    /// test running at that instant can hold an inherited write fd to a shim
+    /// written moments earlier, and exec'ing a file some process still has open
+    /// for writing fails with ETXTBSY. Nothing serializes that, since the forking
+    /// test need not touch shims at all.
+    #[cfg(unix)]
+    fn exec_shim(ap: &Askpass, prompt: &str) -> std::process::Output {
+        let shim = ap
+            .env_vars()
+            .iter()
+            .find(|(k, _)| *k == "SSH_ASKPASS")
+            .map(|(_, v)| std::path::PathBuf::from(v))
+            .expect("shim path");
+        for _ in 0..100 {
+            let mut c = std::process::Command::new(&shim);
+            c.arg(prompt);
+            for (k, v) in ap.env_vars() {
+                c.env(k, v);
+            }
+            match c.output() {
+                Err(e) if e.kind() == std::io::ErrorKind::ExecutableFileBusy => {
+                    std::thread::sleep(std::time::Duration::from_millis(10));
+                }
+                other => return other.expect("run shim"),
+            }
+        }
+        panic!("shim stayed ETXTBSY");
+    }
+
+    /// The env var `name` the shim was handed, as a path.
+    #[cfg(unix)]
+    fn shim_file(ap: &Askpass, name: &str) -> std::path::PathBuf {
+        ap.env_vars()
+            .iter()
+            .find(|(k, _)| *k == name)
+            .map(|(_, v)| std::path::PathBuf::from(v))
+            .expect("shim env var")
+    }
+
+    fn vetted_args() -> Vec<String> {
+        ssh_password_base_args(&Some("me".to_string()), "host.example", None).unwrap()
+    }
+
+    // ── explain_ssh_error ──────────────────────────────────────────────────
+    // Headless has no terminal to read, so these strings ARE the error UI.
+
+    #[test]
+    fn explain_ssh_error_reports_a_wrong_password_as_such() {
+        // The verbatim stderr a project host returns for a bad password.
+        let msg = explain_ssh_error(
+            "alice@build.example: Permission denied (publickey,password).",
+        )
+        .unwrap();
+        assert!(msg.contains("check the username and password"), "{msg}");
+    }
+
+    #[test]
+    fn explain_ssh_error_distinguishes_a_server_that_refuses_passwords() {
+        // No amount of retyping fixes a key-only server — say so instead of
+        // sending the user round the "is my password wrong?" loop forever.
+        let msg = explain_ssh_error("git@github.com: Permission denied (publickey).").unwrap();
+        assert!(msg.contains("does not accept password logins"), "{msg}");
+        assert!(!msg.contains("check the username and password"), "{msg}");
+    }
+
+    #[test]
+    fn explain_ssh_error_never_calls_a_changed_host_key_a_bad_password() {
+        // A changed host key is a possible MITM. Some OpenSSH versions also print
+        // "Permission denied" for it, so this must be checked FIRST — misreporting
+        // it as a typo would train the user to shrug off an interception.
+        let msg = explain_ssh_error(
+            "@@@@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @@@@\n\
+             Host key verification failed.\nPermission denied (publickey,password).",
+        )
+        .unwrap();
+        assert!(msg.contains("host's SSH key has changed"), "{msg}");
+        assert!(!msg.to_lowercase().contains("check the username"), "{msg}");
+    }
+
+    #[test]
+    fn explain_ssh_error_points_at_the_vpn_for_unreachable_hosts() {
+        // These look like auth failures to a user, but no credential would fix
+        // them — and on this project's hosts the usual cause is a down tunnel.
+        for stderr in [
+            "ssh: Could not resolve hostname build.example: Name or service not known",
+            "ssh: connect to host build.example port 22: Connection timed out",
+            "ssh: connect to host build.example port 22: No route to host",
+        ] {
+            let msg = explain_ssh_error(stderr).unwrap();
+            assert!(msg.contains("VPN"), "{stderr} -> {msg}");
+        }
+        // Refused is different: something answered, so it is a port/sshd problem.
+        let refused =
+            explain_ssh_error("ssh: connect to host h port 22: Connection refused").unwrap();
+        assert!(refused.contains("nothing is listening"), "{refused}");
+    }
+
+    #[test]
+    fn explain_ssh_error_passes_unknown_stderr_through() {
+        // Unrecognized stderr must fall back to the raw text — a vague guess is
+        // worse than the real message.
+        assert_eq!(explain_ssh_error("Kex error: no common kex algorithm"), None);
+        assert_eq!(explain_ssh_error(""), None);
+    }
+
+    #[test]
+    fn validate_arg_rejects_dash_and_control() {
+        assert!(validate_arg("path", "/home/user").is_ok());
+        assert!(validate_arg("path", "-rf").is_err());
+        assert!(validate_arg("path", "a\nb").is_err());
+        assert!(validate_arg("path", "a\0b").is_err());
+    }
+
+    #[test]
+    fn base_args_renders_user_at_host_single_item_with_batchmode() {
+        let args = ssh_base_args(&Some("alice".to_string()), "host.example", None).unwrap();
+        assert_eq!(args.last().unwrap(), "alice@host.example");
+        assert!(args.iter().any(|a| a == "BatchMode=yes"));
+        assert!(args.iter().any(|a| a == "ConnectTimeout=10"));
+    }
+
+    #[test]
+    fn base_args_includes_port() {
+        let args = ssh_base_args(&None, "host", Some(2200)).unwrap();
+        let pos = args.iter().position(|a| a == "-p").unwrap();
+        assert_eq!(args[pos + 1], "2200");
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    #[test]
+    fn ssh_base_args_reuse_master_and_keep_target_last() {
+        let args = ssh_base_args(&Some("alice".to_string()), "host.example", None).unwrap();
+        assert!(args.iter().any(|a| a == "ControlMaster=no"));
+        assert!(args.iter().any(|a| a.starts_with("ControlPath=")));
+        // The validated target must remain the final argv item despite the inserted
+        // -o options, so ssh still parses it as the destination.
+        assert_eq!(args.last().unwrap(), "alice@host.example");
+        // BatchMode is still set: with no live master, auth falls back to key/agent.
+        assert!(args.iter().any(|a| a == "BatchMode=yes"));
+    }
+
+    // ── ssh_master_base_args (pooled-connection, master-owning) ────────────
+
+    #[test]
+    fn master_base_args_owns_master_and_keeps_target_last() {
+        let args = ssh_master_base_args(&Some("alice".to_string()), "host.example", None).unwrap();
+        // Target is still the final argv item despite the inserted -o options.
+        assert_eq!(args.last().unwrap(), "alice@host.example");
+        assert!(args.iter().any(|a| a == "BatchMode=yes"));
+        // Long-lived session keepalive.
+        assert!(args.iter().any(|a| a == "ServerAliveInterval=15"));
+        // Multiplexing is Unix-only: this variant CREATES (auto) the master, vs
+        // ssh_base_args which only reuses (ControlMaster=no).
+        #[cfg(not(target_os = "windows"))]
+        {
+            assert!(args.iter().any(|a| a == "ControlMaster=auto"));
+            assert!(args.iter().any(|a| a.starts_with("ControlPath=")));
+            assert!(args.iter().any(|a| a.starts_with("ControlPersist=")));
+            assert!(args.iter().any(|a| a.contains("cm-%C")));
+        }
+        #[cfg(target_os = "windows")]
+        assert!(!args.iter().any(|a| a == "ControlMaster=auto"));
+    }
+
+    #[test]
+    fn master_base_args_includes_port_and_rejects_bad_target() {
+        let args = ssh_master_base_args(&None, "host", Some(2222)).unwrap();
+        let pos = args.iter().position(|a| a == "-p").expect("-p present");
+        assert_eq!(args[pos + 1], "2222");
+        assert!(ssh_master_base_args(&None, "-evil", None).is_err());
+        assert!(ssh_master_base_args(&Some("-evil".to_string()), "host", None).is_err());
+    }
+
+    #[test]
+    fn password_base_args_disable_batchmode_and_pin_password_auth() {
+        let args = ssh_password_base_args(&Some("me".to_string()), "host.example", None).unwrap();
+        assert_eq!(args.last().unwrap(), "me@host.example");
+        assert!(args.iter().any(|a| a == "BatchMode=no"));
+        assert!(args.iter().any(|a| a == "PreferredAuthentications=password"));
+        assert!(!args.iter().any(|a| a == "BatchMode=yes"));
+    }
+
+    #[test]
+    fn password_master_base_args_pin_password_auth_and_own_master() {
+        let args =
+            ssh_password_master_base_args(&Some("me".to_string()), "host.example", None).unwrap();
+        assert_eq!(args.last().unwrap(), "me@host.example");
+        assert!(args.iter().any(|a| a == "BatchMode=no"));
+        assert!(args.iter().any(|a| a == "PreferredAuthentications=password"));
+        assert!(args.iter().any(|a| a == "PubkeyAuthentication=no"));
+        // Must never force BatchMode=yes (that would block the password prompt).
+        assert!(!args.iter().any(|a| a == "BatchMode=yes"));
+        #[cfg(not(target_os = "windows"))]
+        assert!(args.iter().any(|a| a == "ControlMaster=auto"));
+    }
+
+    #[test]
+    fn target_rejects_bad_host_and_user() {
+        assert!(ssh_target(&None, "-evil").is_err());
+        assert!(ssh_target(&Some("-evil".to_string()), "host").is_err());
+        assert!(ssh_target(&Some("  ".to_string()), "host").is_err());
+        assert!(ssh_target(&None, "   ").is_err());
+        assert_eq!(ssh_target(&None, "host.example").unwrap(), "host.example");
+    }
+
+    #[test]
+    fn target_rejects_host_with_at_or_whitespace() {
+        // `@` would make ssh split the target and redirect to a different host.
+        assert!(ssh_target(&None, "real.host@evil.com").is_err());
+        assert!(ssh_target(&Some("alice".to_string()), "real.host@evil.com").is_err());
+        // Internal whitespace would split into extra tokens.
+        assert!(ssh_target(&None, "host name").is_err());
+    }
+
+    #[test]
+    fn all_base_args_use_tofu_host_key_policy() {
+        // accept-new: auto-trust a first-contact key but refuse a changed one.
+        // Must be on every builder so key- and password-auth first connects behave
+        // identically and never hang on an unanswerable yes/no prompt.
+        for args in [
+            ssh_base_args(&Some("a".into()), "h", None).unwrap(),
+            ssh_password_base_args(&Some("a".into()), "h", None).unwrap(),
+            ssh_master_base_args(&Some("a".into()), "h", None).unwrap(),
+            ssh_password_master_base_args(&Some("a".into()), "h", None).unwrap(),
+        ] {
+            assert!(
+                args.iter().any(|a| a == "StrictHostKeyChecking=accept-new"),
+                "missing accept-new in {args:?}"
+            );
+            // Never the insecure variants that would accept a *changed* key.
+            assert!(!args.iter().any(|a| a == "StrictHostKeyChecking=no"));
+            assert!(!args.iter().any(|a| a == "StrictHostKeyChecking=off"));
+        }
+    }
+
+    #[test]
+    fn parses_openssh_version_banners() {
+        // Stock Linux and Windows-flavored banners, both to-stderr formats.
+        assert_eq!(
+            parse_openssh_version("OpenSSH_9.6p1 Ubuntu-3ubuntu13.5, OpenSSL 3.0.13"),
+            Some((9, 6))
+        );
+        assert_eq!(
+            parse_openssh_version("OpenSSH_for_Windows_8.6p1, LibreSSL 3.4.3"),
+            Some((8, 6))
+        );
+        assert_eq!(
+            parse_openssh_version("OpenSSH_for_Windows_9.5p1, LibreSSL 3.8.2"),
+            Some((9, 5))
+        );
+        assert_eq!(parse_openssh_version("not an ssh banner"), None);
+        assert_eq!(parse_openssh_version("OpenSSH_"), None);
+    }
+
+    #[test]
+    fn askpass_require_needs_openssh_8_4() {
+        // SSH_ASKPASS_REQUIRE landed in 8.4: Win10-inbox 8.1 must fall back to
+        // sshpass, Win11-inbox 8.6+ takes the askpass path.
+        assert!(!version_supports_askpass_require(8, 1));
+        assert!(!version_supports_askpass_require(8, 3));
+        assert!(version_supports_askpass_require(8, 4));
+        assert!(version_supports_askpass_require(8, 6));
+        assert!(version_supports_askpass_require(9, 0));
+        assert!(!version_supports_askpass_require(7, 9));
+    }
+
+    #[test]
+    fn windows_askpass_shim_echoes_env_without_cmd_interpolation() {
+        let body = windows_askpass_shim_body();
+        // The secret must travel via the environment…
+        assert!(body.contains("ELDRUN_ASKPASS"));
+        // …and never through cmd's %VAR% expansion, which re-parses the value
+        // (`& | < > ^` in a password would execute/mangle). PowerShell writes
+        // the variable verbatim instead.
+        assert!(!body.contains('%'), "cmd %VAR% expansion is forbidden");
+        assert!(body.contains("powershell"));
+        // @-prefixed so the command itself is not echoed into ssh's dialog.
+        assert!(body.starts_with('@'));
+        // cmd wants CRLF endings.
+        assert!(body.ends_with("\r\n"));
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn askpass_shim_is_secret_free_executable_and_self_deleting() {
+        use std::os::unix::fs::PermissionsExt;
+        let ap = make_askpass("hunter2", &vetted_args()).unwrap();
+        // Locate the shim path via its SSH_ASKPASS env var.
+        let env = ap.env_vars();
+        let shim = env
+            .iter()
+            .find(|(k, _)| *k == "SSH_ASKPASS")
+            .map(|(_, v)| std::path::PathBuf::from(v))
+            .unwrap();
+        // The password is passed only via ELDRUN_ASKPASS, never written to disk.
+        let body = std::fs::read_to_string(&shim).unwrap();
+        assert!(!body.contains("hunter2"), "shim must not embed the secret");
+        assert!(body.contains("ELDRUN_ASKPASS"));
+        assert!(env
+            .iter()
+            .any(|(k, v)| *k == "ELDRUN_ASKPASS" && v == "hunter2"));
+        assert!(env
+            .iter()
+            .any(|(k, v)| *k == "SSH_ASKPASS_REQUIRE" && v == "force"));
+        // Owner-only, executable.
+        let mode = std::fs::metadata(&shim).unwrap().permissions().mode() & 0o777;
+        assert_eq!(mode, 0o700);
+        // Dropping the guard removes the shim.
+        drop(ap);
+        assert!(!shim.exists(), "shim must be deleted on drop");
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    #[test]
+    fn password_base_args_reuse_existing_master() {
+        // A password-auth one-shot must be able to ride a live master (so a
+        // dropped pooled session can recover without the unstored password).
+        let args = ssh_password_base_args(&Some("me".to_string()), "host.example", None).unwrap();
+        assert!(args.iter().any(|a| a == "ControlMaster=no"));
+        assert!(args.iter().any(|a| a.starts_with("ControlPath=")));
+        assert_eq!(args.last().unwrap(), "me@host.example");
+    }
+
+    // ── Which prompt the askpass shim will answer ──────────────────────────
+
+    #[test]
+    fn only_openssh_own_password_request_is_answerable() {
+        // The prompt OpenSSH builds for password auth — the one and only thing
+        // Eldrun answers on the user's behalf.
+        assert!(prompt_is_password_request("alice@build.example's password: "));
+        assert!(prompt_is_password_request("alice@build.example's password:"));
+
+        // A key passphrase: a *local* secret, and not the one we hold.
+        assert!(!prompt_is_password_request(
+            "Enter passphrase for key '/home/alice/.ssh/id_ed25519': "
+        ));
+        // The host-key confirmation. Answering this with a password sends a
+        // non-"yes" to ssh, which aborts — but it is also the prompt that means
+        // "you have never seen this machine before", so it must never be automated.
+        assert!(!prompt_is_password_request(
+            "The authenticity of host 'build.example (10.0.0.1)' can't be established.\n\
+             ED25519 key fingerprint is SHA256:abc.\n\
+             Are you sure you want to continue connecting (yes/no/[fingerprint])? "
+        ));
+        // Keyboard-interactive: the *server* writes this text. This is the case the
+        // check exists for — a host asking for anything it likes and being answered
+        // with the account password.
+        assert!(!prompt_is_password_request("Verification code: "));
+        assert!(!prompt_is_password_request("(alice@build.example) Password: "));
+        assert!(!prompt_is_password_request(
+            "Enter your GitHub personal access token: "
+        ));
+        assert!(!prompt_is_password_request("Duo two-factor login for alice"));
+    }
+
+    #[test]
+    fn password_args_close_every_prompt_but_the_password_one() {
+        // The shim's shape check is defence in depth; THIS is the primary defence,
+        // and it is invisible from the shim. If any of these disappear, ssh gains a
+        // prompt nobody vetted — including keyboard-interactive, whose text the
+        // server chooses. Asserted on both password builders.
+        for args in [
+            ssh_password_base_args(&Some("a".into()), "h", None).unwrap(),
+            ssh_password_master_base_args(&Some("a".into()), "h", None).unwrap(),
+        ] {
+            let has = |opt: &str| args.iter().any(|a| a == opt);
+            // No key passphrase prompt.
+            assert!(has("PubkeyAuthentication=no"), "{args:?}");
+            // No keyboard-interactive: excludes every server-authored prompt.
+            assert!(has("PreferredAuthentications=password"), "{args:?}");
+            // No interactive host-key confirmation (and a changed key is refused).
+            assert!(has("StrictHostKeyChecking=accept-new"), "{args:?}");
+            // One shot: a server cannot re-ask until it gets an answer it likes.
+            assert!(has("NumberOfPasswordPrompts=1"), "{args:?}");
+        }
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn shim_answers_a_password_prompt_and_refuses_anything_else() {
+        // Run the real shim the way OpenSSH runs it: argv[1] is the prompt, the
+        // secret is in the environment. This is the behaviour, not a restatement
+        // of the pattern.
+        let ap = make_askpass("hunter2", &vetted_args()).unwrap();
+        let run = |prompt: &str| exec_shim(&ap, prompt);
+
+        let ok = run("alice@build.example's password: ");
+        assert!(ok.status.success());
+        assert_eq!(String::from_utf8_lossy(&ok.stdout).trim_end(), "hunter2");
+        assert_eq!(ap.refused_prompt(), None, "nothing was refused");
+
+        // A server-authored challenge gets nothing, and is recorded verbatim.
+        let bad = run("Enter your GitHub personal access token: ");
+        assert!(!bad.status.success(), "a refusal must fail the connect");
+        assert!(
+            !String::from_utf8_lossy(&bad.stdout).contains("hunter2"),
+            "the secret must not be emitted for an unexpected prompt"
+        );
+        assert_eq!(
+            ap.refused_prompt().as_deref(),
+            Some("Enter your GitHub personal access token:"),
+            "the caller must be able to tell the user what was actually asked"
+        );
+
+        // The record is part of the shim's temp files and goes with them.
+        let reject = shim_file(&ap, "ELDRUN_ASKPASS_REJECT");
+        drop(ap);
+        assert!(!reject.exists(), "the refusal record must be deleted on drop");
+    }
+
+    // ── Key passphrases: the secret that must never reach the server ───────
+
+    /// Real `ssh-keygen -t ed25519` output. Only the first base64 line matters
+    /// (the cipher name lives there), so the bodies are truncated — which is also
+    /// what `private_key_is_encrypted` reads in production.
+    const UNENCRYPTED_ED25519: &str = "-----BEGIN OPENSSH PRIVATE KEY-----\n\
+        b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAA\n\
+        -----END OPENSSH PRIVATE KEY-----\n";
+    const ENCRYPTED_ED25519: &str = "-----BEGIN OPENSSH PRIVATE KEY-----\n\
+        b3BlbnNzaC1rZXktdjEAAAAACmFlczI1Ni1jdHIAAAAGYmNyeXB0AAAAGAAA\n\
+        -----END OPENSSH PRIVATE KEY-----\n";
+
+    #[test]
+    fn private_key_encryption_is_read_from_the_openssh_v1_cipher_field() {
+        // The modern default format announces nothing in its header — `none` vs a
+        // real cipher name in the base64 body is the ONLY difference, so a reader
+        // that keys on the header would call every key unencrypted.
+        assert_eq!(private_key_is_encrypted(UNENCRYPTED_ED25519), Some(false));
+        assert_eq!(private_key_is_encrypted(ENCRYPTED_ED25519), Some(true));
+    }
+
+    #[test]
+    fn private_key_encryption_covers_the_older_formats_too() {
+        // A real `~/.ssh` accumulates all three spellings.
+        assert_eq!(
+            private_key_is_encrypted(
+                "-----BEGIN RSA PRIVATE KEY-----\n\
+                 Proc-Type: 4,ENCRYPTED\n\
+                 DEK-Info: AES-128-CBC,0123\n\nAAAA\n\
+                 -----END RSA PRIVATE KEY-----\n"
+            ),
+            Some(true)
+        );
+        assert_eq!(
+            private_key_is_encrypted(
+                "-----BEGIN ENCRYPTED PRIVATE KEY-----\nAAAA\n\
+                 -----END ENCRYPTED PRIVATE KEY-----\n"
+            ),
+            Some(true)
+        );
+        assert_eq!(
+            private_key_is_encrypted(
+                "-----BEGIN RSA PRIVATE KEY-----\nAAAA\n-----END RSA PRIVATE KEY-----\n"
+            ),
+            Some(false)
+        );
+        // Not a key at all → "don't know", never "unencrypted": the caller must be
+        // able to tell an unreadable file from a confirmed plaintext key.
+        assert_eq!(private_key_is_encrypted("ssh-ed25519 AAAAC3Nz me@box"), None);
+        assert_eq!(private_key_is_encrypted(""), None);
+    }
+
+    #[test]
+    fn the_two_prompt_tests_cannot_both_match() {
+        // The whole safety of a second askpass mode rests on this: if a passphrase
+        // shim could answer a password request (or vice versa), the argv guards
+        // would be the only thing left between a local secret and the server.
+        let password = "alice@build.example's password: ";
+        let passphrase = "Enter passphrase for key '/home/alice/.ssh/id_ed25519': ";
+        assert!(prompt_is_password_request(password));
+        assert!(!prompt_is_key_passphrase_request(password));
+        assert!(prompt_is_key_passphrase_request(passphrase));
+        assert!(!prompt_is_password_request(passphrase));
+    }
+
+    #[test]
+    fn passphrase_args_disable_every_server_facing_prompt() {
+        for args in [
+            ssh_passphrase_base_args(&Some("me".into()), "host.example", None).unwrap(),
+            ssh_passphrase_master_base_args(&Some("me".into()), "host.example", None).unwrap(),
+        ] {
+            let has = |opt: &str| args.iter().any(|a| a == opt);
+            // Pubkey only: a passphrase can never be offered as a login secret.
+            assert!(has("PreferredAuthentications=publickey"), "{args:?}");
+            assert!(has("PasswordAuthentication=no"), "{args:?}");
+            assert!(has("KbdInteractiveAuthentication=no"), "{args:?}");
+            assert!(has("StrictHostKeyChecking=accept-new"), "{args:?}");
+            // Without this OpenSSH never raises the passphrase prompt at all —
+            // which is precisely the bug this path exists to fix.
+            assert!(has("BatchMode=no"), "{args:?}");
+            assert_eq!(
+                missing_single_prompt_opt_for(SecretKind::KeyPassphrase, &args),
+                None
+            );
+        }
+    }
+
+    #[test]
+    fn a_secret_is_refused_when_the_argv_does_not_match_its_kind() {
+        // Cross-wiring the two argv builders must fail loudly, not silently send
+        // the secret to whichever prompt the other argv happens to allow.
+        let password_args = vetted_args();
+        let passphrase_args =
+            ssh_passphrase_base_args(&Some("me".into()), "host.example", None).unwrap();
+        assert!(
+            missing_single_prompt_opt_for(SecretKind::KeyPassphrase, &password_args).is_some(),
+            "password argv must not be usable for a passphrase"
+        );
+        assert!(
+            missing_single_prompt_opt_for(SecretKind::Password, &passphrase_args).is_some(),
+            "passphrase argv must not be usable for a password"
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn passphrase_shim_answers_only_the_passphrase_prompt() {
+        // Same contract as the password shim, checked by running the real script.
+        let args = ssh_passphrase_base_args(&Some("me".into()), "host.example", None).unwrap();
+        let ap = make_askpass_for(SecretKind::KeyPassphrase, "hunter2", &args).unwrap();
+        let run = |prompt: &str| exec_shim(&ap, prompt);
+
+        let ok = run("Enter passphrase for key '/home/me/.ssh/id_ed25519': ");
+        assert!(ok.status.success());
+        assert_eq!(String::from_utf8_lossy(&ok.stdout).trim_end(), "hunter2");
+
+        // The one that matters: a *password* request must get nothing, because
+        // answering it would send the key's passphrase to the remote host.
+        let bad = run("me@host.example's password: ");
+        assert!(!bad.status.success());
+        assert!(
+            !String::from_utf8_lossy(&bad.stdout).contains("hunter2"),
+            "a passphrase must never be released to a server-facing prompt"
+        );
+        assert!(ap.refused_prompt().is_some());
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn the_answer_tally_counts_re_asks_and_is_what_catches_a_wrong_passphrase() {
+        // Verified against a real host: OpenSSH re-asks a rejected passphrase three
+        // times and then exits with a bare `Permission denied (publickey,...)` —
+        // saying NOTHING about the decrypt failure. So the tally, not the stderr
+        // text, is what stops a wrong passphrase from being retried as a login
+        // password (which would send a local secret to the server).
+        let args = ssh_passphrase_base_args(&Some("me".into()), "host.example", None).unwrap();
+        let ap = make_askpass_for(SecretKind::KeyPassphrase, "hunter2", &args).unwrap();
+        let ask = |prompt: &str| {
+            exec_shim(&ap, prompt);
+        };
+
+        assert_eq!(ap.answer_count(), 0, "nothing asked yet");
+        let prompt = "Enter passphrase for key '/home/me/.ssh/id_ed25519': ";
+        ask(prompt);
+        assert_eq!(ap.answer_count(), 1);
+        // One answer is just "ssh asked once" — not yet evidence of anything.
+        assert!(!secret_rejected_locally(
+            SecretKind::KeyPassphrase,
+            Some(&ap),
+            "me@host.example: Permission denied (publickey)."
+        ));
+
+        // A re-ask can only mean the previous answer failed to decrypt the key.
+        ask(prompt);
+        assert_eq!(ap.answer_count(), 2);
+        assert!(secret_rejected_locally(
+            SecretKind::KeyPassphrase,
+            Some(&ap),
+            "me@host.example: Permission denied (publickey)."
+        ));
+        // A password has nothing to fall back to, so it is never "rejected locally"
+        // however many times it was asked.
+        assert!(!secret_rejected_locally(
+            SecretKind::Password,
+            Some(&ap),
+            "me@host.example: Permission denied (publickey)."
+        ));
+
+        let tally = shim_file(&ap, "ELDRUN_ASKPASS_TALLY");
+        drop(ap);
+        assert!(!tally.exists(), "the tally must be deleted on drop");
+    }
+
+    #[test]
+    fn a_wrong_passphrase_is_named_as_such_not_as_a_login_failure() {
+        // Verbatim OpenSSH stderr. Without this it falls through to the
+        // permission-denied branch and the user is told to check a password they
+        // never gave.
+        let msg = explain_ssh_error(
+            "Load key \"/home/me/.ssh/id_ed25519\": incorrect passphrase supplied to \
+             decrypt private key\nme@host.example: Permission denied (publickey).",
+        )
+        .unwrap();
+        assert!(msg.contains("passphrase"), "{msg}");
+        assert!(
+            !msg.contains("does not accept password logins"),
+            "a local decrypt failure must not be blamed on the server: {msg}"
+        );
+        assert!(is_wrong_passphrase("incorrect passphrase supplied"));
+        assert!(!is_wrong_passphrase(
+            "me@host.example: Permission denied (publickey)."
+        ));
+    }
+
+    #[test]
+    fn a_refused_prompt_is_flattened_before_it_is_shown() {
+        // The refused text can be server-authored, and it lands in a UI next to a
+        // terminal. Escapes and newlines must not survive into it.
+        let dirty = "\x1b[2JPassword\nfor\tthe\r\n\x07bank: ";
+        let clean = sanitize_prompt(dirty);
+        assert!(!clean.chars().any(char::is_control), "{clean:?}");
+        assert_eq!(clean, "[2JPassword for the bank:");
+
+        // And it cannot be used to flood the dialog.
+        let long = sanitize_prompt(&"x".repeat(5000));
+        assert!(long.chars().count() <= 201, "{}", long.chars().count());
+
+        // The message names what was asked, and says nothing was sent.
+        let msg = unexpected_prompt_error(&clean);
+        assert!(msg.contains("bank"), "{msg}");
+        assert!(msg.contains("sent nothing"), "{msg}");
+    }
+
+    // ── First contact ─────────────────────────────────────────────────────
+
+    #[test]
+    fn known_hosts_key_brackets_a_non_default_port() {
+        // The form OpenSSH writes and `ssh-keygen -F` expects; getting this wrong
+        // would call every non-22 host unknown, forever.
+        assert_eq!(known_hosts_key("build.example", 22), "build.example");
+        assert_eq!(known_hosts_key("build.example", 2222), "[build.example]:2222");
+    }
+
+    #[test]
+    fn keygen_fingerprints_parse_into_what_the_dialog_shows() {
+        let out = "256 SHA256:6dq1x/N4iC build.example (ED25519)\n\
+                   3072 SHA256:Zk9tQ1LmPo build.example (RSA)\n";
+        let keys = parse_keygen_fingerprints(out);
+        assert_eq!(keys.len(), 2);
+        assert_eq!(keys[0].bits, 256);
+        assert_eq!(keys[0].key_type, "ED25519");
+        assert_eq!(keys[0].fingerprint, "SHA256:6dq1x/N4iC");
+        assert_eq!(keys[1].key_type, "RSA");
+        // Junk lines are skipped rather than shown as a key with no fingerprint.
+        assert!(parse_keygen_fingerprints("# comment\nnot a key\n").is_empty());
+    }
+
+    #[test]
+    fn the_unknown_host_marker_is_what_the_frontend_matches() {
+        // The frontend keys on this exact prefix to raise the fingerprint dialog
+        // (`src/lib/hostKey.ts`); a rename here silently turns that dialog into a
+        // dead-end error message.
+        assert_eq!(UNKNOWN_HOST_KEY, "ELDRUN_UNKNOWN_HOST_KEY");
+    }
+
+    #[cfg(any(unix, windows))]
+    #[test]
+    fn a_password_cannot_be_attached_to_an_unvetted_ssh_command() {
+        // The shim can only judge the prompt it is handed; WHICH prompts exist is
+        // decided by the argv. So building the askpass against a command that has
+        // not closed the other prompts must fail outright rather than produce a
+        // working-looking connect that can be asked for anything.
+        for missing in [
+            "PubkeyAuthentication=no",
+            "PreferredAuthentications=password",
+            "StrictHostKeyChecking=accept-new",
+            "NumberOfPasswordPrompts=1",
+        ] {
+            let args: Vec<String> = vetted_args().into_iter().filter(|a| a != missing).collect();
+            assert_eq!(missing_single_prompt_opt(&args), Some(missing));
+            // Deliberately not `unwrap_err`: that needs `Debug` on `Askpass`, which
+            // holds the password — a derive here would print the secret into any
+            // panic message. Match instead.
+            match make_askpass("hunter2", &args) {
+                Ok(_) => panic!("a password was attached to args missing {missing}"),
+                Err(e) => assert!(e.contains(missing), "{e}"),
+            }
+        }
+        // Key-auth args are never a password carrier: they close none of them.
+        let key_args = ssh_base_args(&Some("me".to_string()), "host.example", None).unwrap();
+        assert!(make_askpass("hunter2", &key_args).is_err());
+        // And the real thing is accepted.
+        assert_eq!(missing_single_prompt_opt(&vetted_args()), None);
+        assert!(make_askpass("hunter2", &vetted_args()).is_ok());
+    }
+}
diff --git a/src-tauri/src/services/ssh_exec.rs b/src-tauri/src/services/ssh_exec.rs
index ca57579..e34dcd8 100644
--- a/src-tauri/src/services/ssh_exec.rs
+++ b/src-tauri/src/services/ssh_exec.rs
@@ -1,16 +1,18 @@
 //! Remote (SSH) command execution for terminal/agent tabs.
 //!
-//! A remote project's bytes are sshfs-mounted locally (see `ssh_mount`), but the
-//! user needs scripts and agents to run **on the remote host**, not locally
-//! against the mounted bytes. This module rewrites a tab's `PtyOptions` so that
-//! instead of spawning the requested command directly, the PTY spawns the local
-//! `ssh` client with a forced TTY (`-tt`). The ssh client allocates a remote
-//! PTY, so resize/kill/exit keep working through the local PTY unchanged.
+//! Remote projects are SSH/SFTP-native (no local FUSE mount): the user's scripts
+//! and agents run **on the remote host**. This module rewrites a tab's
+//! `PtyOptions` so that instead of spawning the requested command directly, the
+//! PTY spawns the local `ssh` client with a forced TTY (`-tt`). The ssh client
+//! allocates a remote PTY, so resize/kill/exit keep working through the local PTY
+//! unchanged.
 //!
-//! Detection is by the mountpoint-path convention: if a spawn's `cwd` lives
-//! under `ssh_mount::mounts_root()`, the first path component after it is the
-//! project id, from which we load the `RemoteSpec`. Local projects (and tabs
-//! flagged `local_only`, e.g. local Ollama agents) are left untouched.
+//! Remoteness is **explicit**: the frontend tags a project-scope spawn with the
+//! owning `project_id` in `PtyOptions`, and `wrap_pty_options` resolves its
+//! `RemoteSpec` via `services::remote::remote_target_for` (a `RemoteTarget`).
+//! The remote working dir is the project root (`spec.remote_path`). Local
+//! projects (and tabs flagged `local_only`, e.g. local Ollama agents, and
+//! untagged root/connection terminals) are left untouched.
 //!
 //! As elsewhere, `host`/`user`/`remote_path` are validated (no leading `-`, no
 //! control characters) and passed to `ssh` as separate argv items. The one
@@ -19,11 +21,11 @@
 //! single-quoted via `shell_quote` before it is embedded.
 
 use std::collections::HashMap;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use crate::schema::project::RemoteSpec;
 use crate::services::remote_agents;
-use crate::services::ssh_mount::{self, ssh_target, validate_arg};
+use crate::services::ssh_common::{ssh_base_args, ssh_target, validate_arg};
 use crate::storage;
 use crate::terminal::PtyOptions;
 
@@ -39,6 +41,8 @@ const SSH_KEEPALIVE: &[&str] = &[
 ];
 
 /// How long the multiplexing master stays alive after the last session closes.
+/// Multiplexing is Unix-only (see [`ssh_pty_args`]), so this is unused on Windows.
+#[cfg(not(target_os = "windows"))]
 const CONTROL_PERSIST_SECS: u32 = 600;
 
 /// Agent-auth environment variables that must **not** be forwarded to the
@@ -46,7 +50,7 @@ const CONTROL_PERSIST_SECS: u32 = 600;
 /// `~/.claude`); a forwarded local key/token would silently clobber that
 /// session (most CLIs prefer an env key over stored credentials). These are
 /// dropped from the exported env alongside `TERM`/`COLORTERM`.
-const AGENT_AUTH_ENV: &[&str] = &[
+pub(crate) const AGENT_AUTH_ENV: &[&str] = &[
     "ANTHROPIC_API_KEY",
     "ANTHROPIC_AUTH_TOKEN",
     "CLAUDE_CODE_OAUTH_TOKEN",
@@ -56,15 +60,113 @@ const AGENT_AUTH_ENV: &[&str] = &[
 ];
 
 /// Directory holding ssh ControlMaster sockets, created on demand.
-/// `<state_dir>/ssh-control` (e.g. `~/.local/share/eldrun/ssh-control`).
-fn control_dir() -> PathBuf {
+/// `<state_dir>/ssh-control` (e.g. `~/.local/share/eldrun/ssh-control`). The
+/// single shared `cm-%C` master socket here is reused by every remote path —
+/// agent tabs, the pooled SFTP session (`services::remote`/`services::sftp`),
+/// git-over-ssh, and an interactive login — so authentication happens once.
+pub(crate) fn control_dir() -> PathBuf {
     storage::state_dir().join("ssh-control")
 }
 
+/// The socket path `cm-%C` actually expands to for this target.
+///
+/// `%C` is a hash of (local host, remote host, port, user) that OpenSSH computes
+/// and we cannot, so it is *asked*: `ssh -G` prints the effective config with the
+/// token already expanded, and connects to nothing while doing it. Needed by
+/// anything that must touch the socket as a file — [`sweep_stale_control_sockets`]
+/// and `services::remote`'s teardown, which unlinks it.
+///
+/// `None` on Windows (no control socket at all) and whenever `ssh -G` cannot be
+/// run or says nothing — callers treat that as "no socket to manage", never as a
+/// path to guess at.
+pub fn resolve_control_path(spec: &RemoteSpec) -> Option<PathBuf> {
+    #[cfg(target_os = "windows")]
+    {
+        let _ = spec;
+        None
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        let target = ssh_target(&spec.user, &spec.host).ok()?;
+        let template = control_dir().join("cm-%C");
+        let mut cmd = crate::paths::command_no_window("ssh");
+        cmd.arg("-G")
+            .arg("-o")
+            .arg(format!("ControlPath={}", template.to_string_lossy()));
+        if let Some(port) = spec.port {
+            cmd.arg("-p").arg(port.to_string());
+        }
+        cmd.arg(target);
+        let out = cmd.output().ok()?;
+        String::from_utf8_lossy(&out.stdout)
+            .lines()
+            .find_map(|line| line.strip_prefix("controlpath "))
+            .map(|p| PathBuf::from(p.trim()))
+            .filter(|p| p.parent() == Some(control_dir().as_path()))
+    }
+}
+
+/// Remove `cm-*` sockets in [`control_dir`] whose master is gone — a startup
+/// sweep beside `sandbox::sweep_orphans` / `openvpn::adopt_orphans`.
+///
+/// Masters are killed by signal (`services::remote::teardown_pooled`, and rather
+/// more abruptly by a crash or an OOM), which leaves the socket file behind. A
+/// leftover socket is not inert: the next `ssh` to that target logs "ControlSocket
+/// … already exists, disabling multiplexing" and then **opens its own login** —
+/// so a single stale file silently converts every later channel on that host from
+/// one shared authenticated master into one connection each, for the rest of the
+/// run. `ssh -O check` against the explicit socket answers in microseconds and
+/// touches no network; a non-zero exit means nothing is listening, so unlink.
+///
+/// Best effort throughout: a socket we cannot classify is left alone (a live
+/// master from a *concurrent* Eldrun would answer the check and be kept).
+#[cfg(not(target_os = "windows"))]
+pub fn sweep_stale_control_sockets() {
+    let dir = control_dir();
+    let Ok(entries) = std::fs::read_dir(&dir) else {
+        return;
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if !path
+            .file_name()
+            .and_then(|n| n.to_str())
+            .is_some_and(|n| n.starts_with("cm-"))
+        {
+            continue;
+        }
+        // The host argument is required by the CLI but unused here: the socket is
+        // named outright with `-o ControlPath`, so `-O check` asks *that* file.
+        let alive = crate::paths::command_no_window("ssh")
+            .arg("-o")
+            .arg(format!("ControlPath={}", path.to_string_lossy()))
+            .arg("-O")
+            .arg("check")
+            .arg("eldrun-control-probe")
+            .output()
+            .map(|o| o.status.success())
+            // Only an `ssh` that actually RAN and said "not alive" licenses the
+            // unlink. A spawn failure (no `ssh` on PATH, fork failure, EMFILE) is
+            // not evidence about the socket, and reading it as one would delete
+            // every master in the directory — including a live one belonging to a
+            // concurrently-running Eldrun, whose channels would then each need a
+            // password nobody stored.
+            .unwrap_or(true);
+        if !alive {
+            let _ = std::fs::remove_file(&path);
+        }
+    }
+}
+
+#[cfg(target_os = "windows")]
+pub fn sweep_stale_control_sockets() {}
+
 /// Single-quote `s` for a POSIX shell, escaping embedded single quotes as
 /// `'\''`. The result parses back to exactly `s` regardless of spaces, `$`,
-/// quotes, or other metacharacters.
-fn shell_quote(s: &str) -> String {
+/// quotes, or other metacharacters. `pub(crate)` so command modules that build
+/// their own host scripts (e.g. `commands::slurm`) share this one implementation
+/// rather than reinventing shell quoting.
+pub(crate) fn shell_quote(s: &str) -> String {
     let mut out = String::with_capacity(s.len() + 2);
     out.push('\'');
     for ch in s.chars() {
@@ -78,18 +180,72 @@ fn shell_quote(s: &str) -> String {
     out
 }
 
-/// Translate a local cwd under the sshfs mount to the matching remote path.
-/// Strips the `mountpoint` prefix from `local_cwd` and joins the remainder onto
-/// `remote.remote_path`. Falls back to `remote.remote_path` when `local_cwd` is
-/// the mount root itself or is not under the mountpoint.
-pub fn remote_subdir(remote: &RemoteSpec, mountpoint: &Path, local_cwd: &str) -> String {
-    let base = remote.remote_path.trim_end_matches('/');
-    let cwd = Path::new(local_cwd);
-    match cwd.strip_prefix(mountpoint) {
-        Ok(rel) if !rel.as_os_str().is_empty() => {
-            format!("{base}/{}", rel.to_string_lossy())
+/// A POSIX-portable environment variable name (`[A-Za-z_][A-Za-z0-9_]*`). Used to
+/// gate which keys may be `export`ed into the remote `$SHELL -c` string: the
+/// value is `shell_quote`d, but the key is not (it sits left of `=`), so a key
+/// containing shell metacharacters (e.g. `A; rm -rf ~ #`) would break out of the
+/// assignment and run as a separate statement. Every key Eldrun sets today is a
+/// valid identifier; this enforces that property rather than trusting it.
+fn is_valid_env_key(k: &str) -> bool {
+    let mut chars = k.chars();
+    match chars.next() {
+        Some(c) if c.is_ascii_alphabetic() || c == '_' => {}
+        _ => return false,
+    }
+    chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
+}
+
+/// How a remote tab is wrapped in a **tmux** session on the host (TODO #85), so
+/// the work is decoupled from the disposable ssh channel and survives a drop /
+/// laptop sleep / Eldrun relaunch.
+#[derive(Debug, Clone)]
+pub enum TmuxWrap {
+    /// Start-or-attach a per-tab session (`tmux new-session -A`) that runs this
+    /// tab's target command. On first spawn it creates and runs the command; on a
+    /// reconnect/relaunch it reattaches and the target is ignored (the process is
+    /// already running) — one command that is both "start" and "resume".
+    Session(String),
+    /// Attach to an **arbitrary named** session that already exists on the host
+    /// (opened from the Sessions view, or a hand-started `tmux` session). No
+    /// target command — `new-session -A` attaches the running session, or creates
+    /// a bare login shell if the name is somehow gone.
+    Attach(String),
+}
+
+/// Wrap a resolved `exec …` line in a tmux launch (see [`TmuxWrap`]). Emitted as
+/// a POSIX-sh `if command -v tmux …` so a host **without** tmux degrades to the
+/// plain exec (today's behavior) plus a one-line notice, instead of failing —
+/// tmux is usually preinstalled on a compute/HPC host but cannot be assumed. The
+/// session gets `status off` (Eldrun already draws tabs/layout, so tmux's status
+/// bar is redundant chrome) and `mouse on` (wheel scrolls tmux history, so
+/// scrollback still feels native), chained as extra tmux commands after a literal
+/// `;` argv separator.
+fn tmux_wrap_exec(exec_line: &str, wrap: &TmuxWrap) -> String {
+    // `status off`/`mouse on` are passed as separate tmux commands: a standalone
+    // `;` token (quoted so the remote shell hands it to tmux literally, not as a
+    // shell separator) splits tmux's argv into successive commands.
+    let opts = "';' set -g status off ';' set -g mouse on";
+    match wrap {
+        TmuxWrap::Session(name) => {
+            let q = shell_quote(name);
+            // tmux runs its command argument via `sh -c`, so the (quoted) exec
+            // line — `exec "${SHELL:-/bin/bash}" -l…` — is executed exactly as it
+            // would be directly, only now inside the persistent session.
+            let target = shell_quote(exec_line);
+            format!(
+                "if command -v tmux >/dev/null 2>&1; then \
+                 exec tmux new-session -A -D -s {q} {target} {opts}; \
+                 else printf 'eldrun: tmux not found on the remote host; session persistence is OFF (install tmux to enable it)\\n' >&2; {exec_line}; fi"
+            )
+        }
+        TmuxWrap::Attach(name) => {
+            let q = shell_quote(name);
+            format!(
+                "if command -v tmux >/dev/null 2>&1; then \
+                 exec tmux new-session -A -D -s {q} {opts}; \
+                 else printf 'eldrun: tmux not found on the remote host; cannot attach session %s\\n' {q} >&2; exec \"${{SHELL:-/bin/bash}}\" -l; fi"
+            )
         }
-        _ => remote.remote_path.clone(),
     }
 }
 
@@ -107,11 +263,19 @@ pub fn remote_subdir(remote: &RemoteSpec, mountpoint: &Path, local_cwd: &str) ->
 /// `TERM`/`COLORTERM` are skipped — ssh forwards `TERM` to the remote PTY
 /// already — as are agent-auth vars (`AGENT_AUTH_ENV`), so a local key cannot
 /// clobber the remote agent's own stored login.
+///
+/// `tmux`, when `Some`, wraps the final `exec …` in a persistent tmux session
+/// (TODO #85). Everything before it — the `cd`, the sorted env exports, the
+/// agent bootstrap prelude — is preserved verbatim and nested *inside* the
+/// session, so the wrap changes only where the target runs, not what it is. A
+/// [`TmuxWrap::Attach`] ignores `local_cmd`/`local_args` (it attaches an existing
+/// session, running no fresh target).
 pub fn remote_command(
     local_cmd: &str,
     local_args: &[String],
     env: &HashMap<String, String>,
     remote_dir: &str,
+    tmux: Option<&TmuxWrap>,
 ) -> String {
     let mut parts: Vec<String> = Vec::new();
     parts.push(format!("cd {}", shell_quote(remote_dir)));
@@ -123,7 +287,8 @@ pub fn remote_command(
         .keys()
         .filter(|k| {
             let k = k.as_str();
-            k != "TERM" && k != "COLORTERM" && !AGENT_AUTH_ENV.contains(&k)
+            // is_valid_env_key gates injection via a metacharacter-bearing key.
+            is_valid_env_key(k) && k != "TERM" && k != "COLORTERM" && !AGENT_AUTH_ENV.contains(&k)
         })
         .collect();
     keys.sort();
@@ -155,9 +320,243 @@ pub fn remote_command(
         format!("exec \"${{SHELL:-/bin/bash}}\" -lc {}", shell_quote(&inner))
     };
 
+    // The tmux wrap replaces only the final `exec …`; the `cd`/exports prefix is
+    // untouched, so the session opens in the project dir with the same env.
+    let exec = match tmux {
+        Some(wrap) => tmux_wrap_exec(&exec, wrap),
+        None => exec,
+    };
+
     format!("{} && {}", parts.join(" && "), exec)
 }
 
+/// The tmux **kill-session** one-shot script fired on an *explicit* tab close of
+/// a persistent remote tab (TODO #85). Closing the tab is the destructive intent
+/// that ends the run; an app-exit / respawn leaves the session alive. A machine
+/// disconnect ends every session on that host. Run over the pooled
+/// ControlMaster via [`run_remote_script`]. The session name is `shell_quote`d
+/// (it may be an arbitrary name from the Sessions view). `|| true` keeps the
+/// exit status clean when the session is already gone.
+pub fn tmux_kill_session_script(session: &str) -> String {
+    format!("tmux kill-session -t {} 2>/dev/null || true", shell_quote(session))
+}
+
+/// Kill every tmux session owned by the connected SSH user. Used when Eldrun
+/// deliberately disconnects a remote machine, so its persistent runs do not
+/// continue without their machine connection.
+pub fn tmux_kill_server_script() -> &'static str {
+    "tmux kill-server 2>/dev/null || true"
+}
+
+/// Whether `name` is a safe tmux session name to rename **to** (TODO #85): tmux
+/// treats `:` and `.` specially, and a name with whitespace/control chars is a
+/// footgun, so a rename target must be a non-empty run of `[A-Za-z0-9_-]`. (The
+/// *source* name is not validated this way — a foreign/hand-started session may be
+/// anything — only quoted.)
+pub fn valid_tmux_session_name(name: &str) -> bool {
+    !name.is_empty()
+        && name
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
+}
+
+/// The tmux **rename-session** one-shot (TODO #85): `tmux rename-session -t <old>
+/// <new>`. Both names are `shell_quote`d (the `old` may be an arbitrary foreign
+/// name); the caller MUST have checked `new` with [`valid_tmux_session_name`].
+pub fn tmux_rename_session_script(old: &str, new: &str) -> String {
+    format!(
+        "tmux rename-session -t {} {}",
+        shell_quote(old),
+        shell_quote(new)
+    )
+}
+
+/// The `tmux ls` one-shot that backs the Sessions view (TODO #85): one tab-
+/// separated row per session — name, window count, created epoch, attached flag,
+/// last-activity epoch, the active pane's current foreground command (used to
+/// tell a busy session from one idling at its shell prompt), and the active
+/// pane's current **directory** (which is what attributes a session to a project
+/// when its *name* cannot — see [`session_visible_for_project`]).
+/// `2>/dev/null || true` makes an absent tmux or a not-running server (`tmux ls`
+/// exits non-zero with "no server running") a clean **empty** list rather than an
+/// error (see [`parse_tmux_ls`]).
+pub fn tmux_ls_script() -> &'static str {
+    "tmux ls -F '#{session_name}\t#{session_windows}\t#{session_created}\t#{session_attached}\t#{session_activity}\t#{pane_current_command}\t#{pane_current_path}' 2>/dev/null || true"
+}
+
+/// Shell/login-interpreter names `pane_current_command` reports when a session is
+/// sitting idle at its prompt (tmux prefixes a login shell with `-`, e.g. `-bash`).
+/// Anything else running in the active pane counts as the session "working".
+const IDLE_SHELL_COMMANDS: &[&str] = &[
+    "bash", "-bash", "zsh", "-zsh", "sh", "-sh", "dash", "-dash", "fish", "-fish",
+    "tcsh", "-tcsh", "csh", "-csh", "ksh", "-ksh", "pwsh", "-pwsh",
+];
+
+/// One host tmux session, as surfaced by the Sessions view (TODO #85).
+#[derive(Debug, Clone, serde::Serialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct TmuxSession {
+    /// Session name (`eldrun-<uid>` for one Eldrun started, else a foreign name).
+    pub name: String,
+    /// Number of windows in the session.
+    pub windows: u32,
+    /// Creation time, seconds since the Unix epoch (host clock).
+    pub created: u64,
+    /// Whether another client is currently attached to it.
+    pub attached: bool,
+    /// Last activity time, seconds since the Unix epoch (host clock) — bumped by
+    /// output in any of the session's panes, so it doubles as "how long idle".
+    pub activity: u64,
+    /// The active pane's current foreground command (e.g. `python`, `vim`, or a
+    /// shell name when idling at the prompt).
+    pub current_command: String,
+    /// Derived from `current_command`: false when the active pane is sitting at a
+    /// bare shell prompt, true when something else is running in it.
+    pub working: bool,
+    /// The active pane's current working directory on the host. Empty when the
+    /// host's `tmux ls` did not report it (an older format row). This is what
+    /// attributes a session whose *name* carries no project id — every session
+    /// minted before the name was scoped, and every hand-started one — to the
+    /// project whose tree it is running in (see [`session_visible_for_project`]).
+    pub current_path: String,
+}
+
+/// Parse the tab-separated output of [`tmux_ls_script`] into [`TmuxSession`]s.
+/// Empty/`no server running` output → an empty list (never an error). A row that
+/// does not have the four required fields is skipped rather than failing the whole
+/// parse (forward-compatible with an unexpected `tmux ls` build); the two trailing
+/// fields (added later) default to `0`/idle when a row is missing them, rather than
+/// dropping the whole row, so an older-format row still surfaces.
+pub fn parse_tmux_ls(output: &str) -> Vec<TmuxSession> {
+    output
+        .lines()
+        .filter_map(|line| {
+            let line = line.trim_end_matches('\r');
+            if line.is_empty() {
+                return None;
+            }
+            let mut f = line.split('\t');
+            let name = f.next()?.to_string();
+            if name.is_empty() {
+                return None;
+            }
+            let windows = f.next()?.trim().parse().ok()?;
+            let created = f.next()?.trim().parse().ok()?;
+            // tmux prints `session_attached` as a count of attached clients; any
+            // positive count means at least one client is on it.
+            let attached = f.next()?.trim().parse::<u32>().ok()? > 0;
+            let activity = f.next().and_then(|v| v.trim().parse().ok()).unwrap_or(created);
+            let current_command = f.next().map(|v| v.trim().to_string()).unwrap_or_default();
+            let current_path = f.next().map(|v| v.trim().to_string()).unwrap_or_default();
+            let working = !current_command.is_empty()
+                && !IDLE_SHELL_COMMANDS.contains(&current_command.as_str());
+            Some(TmuxSession {
+                name,
+                windows,
+                created,
+                attached,
+                activity,
+                current_command,
+                working,
+                current_path,
+            })
+        })
+        .collect()
+}
+
+/// A project id can appear verbatim in a tmux session name (it's a uuid in
+/// practice), but is not schema-guaranteed to be — mirrors the frontend's
+/// `tmuxSession.ts` sanitizer (and `services::sandbox::sanitize_key`'s pattern)
+/// so an oddly-shaped id can never produce an invalid prefix to match against.
+fn sanitize_tmux_key(id: &str) -> String {
+    let safe: String = id
+        .chars()
+        .map(|c| if c.is_ascii_alphanumeric() || c == '-' || c == '_' { c } else { '_' })
+        .collect();
+    if safe.is_empty() {
+        "x".to_string()
+    } else {
+        safe
+    }
+}
+
+/// The `eldrun-<project>--` prefix a session minted for `project_id` carries
+/// (`lib/tmuxSession.ts`'s `newTmuxSessionName`). The `--` cannot occur inside
+/// either half (a project id and a uuid are each single-hyphenated), so it
+/// unambiguously separates the project id from the trailing uuid.
+fn tmux_session_prefix_for(project_id: &str) -> String {
+    format!("eldrun-{}--", sanitize_tmux_key(project_id))
+}
+
+/// Whether host path `path` is inside (or is) `root`. Both are normalized by
+/// dropping trailing slashes, and the boundary is a real path segment — so
+/// `/code/simplegnn2` is NOT inside `/code/simplegnn`. An empty `root` matches
+/// nothing (a project with no known root can attribute nothing).
+fn path_within(path: &str, root: &str) -> bool {
+    let path = path.trim_end_matches('/');
+    let root = root.trim_end_matches('/');
+    if root.is_empty() || path.is_empty() {
+        return false;
+    }
+    path == root || path.starts_with(&format!("{root}/"))
+}
+
+/// Whether a host tmux session should appear in **this** project's Sessions view
+/// (TODO #85), on a host that several projects (and other people) share.
+///
+/// Two signals, in order:
+///
+/// 1. **The name.** A session minted after session names carried a project id is
+///    `eldrun-<project>--<uuid>`, which attributes it outright: this project's
+///    prefix ⇒ shown, another project's ⇒ hidden. Nothing else can override this.
+/// 2. **The working directory**, for every session the name cannot attribute —
+///    the `eldrun-<uuid>` ones minted before scoping existed (which on a
+///    long-running cluster host outlive the fix by weeks) and every
+///    hand-started/foreign session. A session whose active pane sits inside the
+///    project's own tree belongs to it; one running elsewhere does not.
+///
+/// A row whose host `tmux ls` reported no path at all (an older format) is
+/// **shown**: an unattributable session must not silently vanish. Nothing is
+/// truly hidden either way — the Sessions view's "all host sessions" toggle
+/// passes `include_all`, so an orphaned run always stays reachable to kill.
+pub fn session_visible_for_project(
+    name: &str,
+    current_path: &str,
+    own_project_id: &str,
+    project_root: &str,
+) -> bool {
+    if name.starts_with(&tmux_session_prefix_for(own_project_id)) {
+        return true;
+    }
+    // Another project's scoped name — the one case the name alone settles.
+    if name.starts_with("eldrun-") && name.contains("--") {
+        return false;
+    }
+    if current_path.is_empty() {
+        return true;
+    }
+    path_within(current_path, project_root)
+}
+
+/// Filter a host's tmux sessions down to the ones this project should see
+/// (TODO #85). `include_all` is the Sessions view's "all host sessions" escape
+/// hatch, which returns the listing untouched. See
+/// [`session_visible_for_project`].
+pub fn filter_sessions_for_project(
+    sessions: Vec<TmuxSession>,
+    project_id: &str,
+    project_root: &str,
+    include_all: bool,
+) -> Vec<TmuxSession> {
+    if include_all {
+        return sessions;
+    }
+    sessions
+        .into_iter()
+        .filter(|s| session_visible_for_project(&s.name, &s.current_path, project_id, project_root))
+        .collect()
+}
+
 /// Build the full `ssh` argv for an interactive remote PTY session running
 /// `remote_command`. Returned as `Vec<String>` so it is unit-testable without
 /// actually connecting.
@@ -167,17 +566,36 @@ pub fn remote_command(
 ///         [-p <port>] <[user@]host> <remote_command>`.
 pub fn ssh_pty_args(remote: &RemoteSpec, remote_command: &str) -> Result<Vec<String>, String> {
     let target = ssh_target(&remote.user, &remote.host)?;
-    let control_path = control_dir().join("cm-%C");
+    // The seventh argv builder, and the one that opens a *master* for a tab —
+    // so it carries the same dial policy as the six in `ssh_common`. A tab
+    // restored at relaunch against a tagged HPC host would otherwise reach a
+    // login node (and, tmux-wrapped, start a server there) with nobody asking.
+    crate::services::ssh_common::authorize_dial(
+        &remote.user,
+        &remote.host,
+        remote.port,
+        crate::services::ssh_common::ambient_intent(&remote.user, &remote.host, remote.port),
+    )?;
+
+    let mut args: Vec<String> = vec!["-tt".to_string()];
+
+    // Connection multiplexing (ControlMaster/ControlPath/ControlPersist) is a
+    // Unix-only OpenSSH feature: it relies on a Unix-domain control socket with
+    // file-descriptor passing, which the Windows OpenSSH client does not
+    // implement (it warns and the session can fail to bind the socket). Skip it
+    // on Windows — each tab simply opens its own connection — while keeping the
+    // reconnect/keepalive options below, which work on every platform.
+    #[cfg(not(target_os = "windows"))]
+    {
+        let control_path = control_dir().join("cm-%C");
+        args.push("-o".to_string());
+        args.push("ControlMaster=auto".to_string());
+        args.push("-o".to_string());
+        args.push(format!("ControlPath={}", control_path.to_string_lossy()));
+        args.push("-o".to_string());
+        args.push(format!("ControlPersist={CONTROL_PERSIST_SECS}"));
+    }
 
-    let mut args: Vec<String> = vec![
-        "-tt".to_string(),
-        "-o".to_string(),
-        "ControlMaster=auto".to_string(),
-        "-o".to_string(),
-        format!("ControlPath={}", control_path.to_string_lossy()),
-        "-o".to_string(),
-        format!("ControlPersist={CONTROL_PERSIST_SECS}"),
-    ];
     for a in SSH_KEEPALIVE {
         args.push((*a).to_string());
     }
@@ -190,34 +608,330 @@ pub fn ssh_pty_args(remote: &RemoteSpec, remote_command: &str) -> Result<Vec<Str
     Ok(args)
 }
 
-/// If `opts.cwd` lives under the sshfs mounts root and its project is remote,
-/// rewrite `opts` in place to run the requested command on the remote host via
-/// `ssh -tt`. No-op for local projects or cwds outside the mounts root.
+/// Build `ssh -S <shared-control-path> -O check <target>` for resolving the
+/// actual ControlMaster PID without opening a network connection. The `%C`
+/// token is expanded by OpenSSH from the same user/host/port tuple used by every
+/// remote-project channel.
+pub fn ssh_control_check_args(remote: &RemoteSpec) -> Result<Vec<String>, String> {
+    let target = ssh_target(&remote.user, &remote.host)?;
+    let control_path = control_dir().join("cm-%C");
+    let mut args = vec![
+        "-S".to_string(),
+        control_path.to_string_lossy().into_owned(),
+        "-O".to_string(),
+        "check".to_string(),
+    ];
+    if let Some(port) = remote.port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(target);
+    Ok(args)
+}
+
+/// Build the remote command string `cd <remote_path> && git <args…>` for a
+/// git-over-ssh invocation. This is the one unavoidable shell string: ssh
+/// concatenates its trailing argv and hands it to the remote `$SHELL -c`, so
+/// every token — `remote_path` and each git arg — is single-quoted via
+/// [`shell_quote`] before it is embedded (the injection-safety requirement from
+/// the mount-free plan's Security bullet). Pure + unit-testable.
+pub fn remote_git_command(remote_path: &str, git_args: &[String]) -> String {
+    let mut s = format!("cd {} && git", shell_quote(remote_path));
+    for a in git_args {
+        s.push(' ');
+        s.push_str(&shell_quote(a));
+    }
+    s
+}
+
+/// Build the full `ssh` argv for running `git <git_args>` on `spec`'s host. The
+/// shared-master base args (`ssh_base_args`: `BatchMode=yes`, `ConnectTimeout`,
+/// and — on Unix — opportunistic reuse of the `cm-%C` ControlMaster the Phase-0
+/// pooled connection / agent tabs establish) are followed by the single remote
+/// `$SHELL -c` string from [`remote_git_command`]. `remote_path`/`host`/`user`
+/// are validated (no leading `-`, no control chars) via `validate_arg`/
+/// `ssh_target` inside `ssh_base_args` and here. Returned as `Vec<String>` so it
+/// is unit-testable without connecting.
+pub fn git_ssh_args(spec: &RemoteSpec, git_args: &[String]) -> Result<Vec<String>, String> {
+    validate_arg("remote path", &spec.remote_path)?;
+    let mut args = ssh_base_args(&spec.user, &spec.host, spec.port)?;
+    args.push(remote_git_command(&spec.remote_path, git_args));
+    Ok(args)
+}
+
+/// Run `git <git_args>` on `spec`'s host over SSH (riding the shared
+/// ControlMaster) and capture its `Output`. Because git's output is plain text,
+/// the caller parses it byte-for-byte identically to a local `git` invocation —
+/// that is what lets `commands::git` reuse every existing parser unchanged for
+/// remote projects. The remote `git`'s credentials/SSH keys are the host's own
+/// (the process runs there), so e.g. `push` authenticates with the host login.
+pub fn run_git_remote(
+    spec: &RemoteSpec,
+    git_args: &[String],
+) -> Result<std::process::Output, String> {
+    let args = git_ssh_args(spec, git_args)?;
+    crate::paths::command_no_window("ssh")
+        .args(&args)
+        .output()
+        .map_err(|e| format!("failed to run git over ssh: {e}"))
+}
+
+/// Run a single shell command on `spec`'s host over SSH (riding the shared
+/// ControlMaster) and capture its `Output`. The command string is handed to the
+/// remote `$SHELL -c`, so the caller MUST `shell_quote` any path/argument it
+/// embeds. Used for cheap host capability probes (e.g. `command -v rsync`).
+pub fn run_remote_shell(spec: &RemoteSpec, command: &str) -> Result<std::process::Output, String> {
+    let mut args = ssh_base_args(&spec.user, &spec.host, spec.port)?;
+    args.push(command.to_string());
+    crate::paths::command_no_window("ssh")
+        .args(&args)
+        .output()
+        .map_err(|e| format!("failed to run command over ssh: {e}"))
+}
+
+/// Run a POSIX-`sh` script inside the project's remote directory (`cd <path> && <script>`),
+/// riding the shared ControlMaster. This is how `services::git_peer` collapses a probe
+/// that cost six SSH round trips into one (#28p D5).
+///
+/// **`script` is embedded verbatim** — it is the shell program, so it cannot be quoted.
+/// Callers must therefore pass a *constant* script, or one built only from values they
+/// have proven inert (`git_peer::ancestry_script` interpolates hex object names and
+/// nothing else). Never interpolate a path, branch name, or any other user-controlled
+/// string into it; `remote_path` is the sole variable here and it is `shell_quote`d.
+pub fn run_remote_script(spec: &RemoteSpec, script: &str) -> Result<std::process::Output, String> {
+    validate_arg("remote path", &spec.remote_path)?;
+    // The newline before `}` terminates the group's last command, so a script may end in
+    // either `fi` or a trailing `;` without a syntax error either way.
+    let cmd = format!("cd {} && {{ {script}\n}}", shell_quote(&spec.remote_path));
+    run_remote_shell(spec, &cmd)
+}
+
+/// Best-effort recursive byte size of a directory on the host, over SSH.
+///
+/// Reports **apparent** size — the sum of each file's `st_size` — to match every
+/// other size figure in the app: the local walk ([`crate::commands::fs`]'s
+/// `walk_dir_size`) and the per-file SFTP listing sizes both use `st_size`. Plain
+/// `du` instead reports **disk-block allocation** (each file rounded up to a 4 KB
+/// block), which made an identical folder read *larger* over SSH than its local
+/// mirror — e.g. 452 KB vs 377 KB for 31 small files, purely from block rounding.
+///
+/// `du -sb` gives exact apparent bytes on GNU coreutils (the usual Linux dev
+/// host). BSD/macOS `du` has no `-b`, so when it produces nothing we fall back to
+/// `du -sk` (1024-byte *block* units) × 1024 — approximate there, but no worse
+/// than the previous behavior. The shell always emits **bytes**, so the parse
+/// below never rescales. The path is validated + single-quoted; a `du` error
+/// (e.g. unreadable dir) yields 0 rather than failing the whole listing.
+pub fn remote_dir_size(spec: &RemoteSpec, remote_dir: &str) -> Result<u64, String> {
+    validate_arg("remote path", remote_dir)?;
+    let q = shell_quote(remote_dir);
+    let cmd = format!(
+        "s=$(du -sb {q} 2>/dev/null | cut -f1); \
+         if [ -n \"$s\" ]; then echo \"$s\"; \
+         else du -sk {q} 2>/dev/null | cut -f1 | awk '{{print $1*1024}}'; fi"
+    );
+    let out = run_remote_shell(spec, &cmd)?;
+    let bytes: u64 = String::from_utf8_lossy(&out.stdout)
+        .trim()
+        .lines()
+        .next()
+        .unwrap_or("")
+        .trim()
+        .parse()
+        .unwrap_or(0);
+    Ok(bytes)
+}
+
+/// Full recursive size tree of a directory on the host, for the Disk Usage
+/// Analyzer pane.
+///
+/// One `du -ak` round-trip (riding the shared ControlMaster) rather than an
+/// N-call SFTP walk: `-a` reports files as well as directories, `-k` fixes the
+/// unit at 1024-byte blocks (portable across GNU and BSD/macOS `du`, unlike
+/// GNU-only `-b`), and `-x` keeps the scan on one filesystem so a network mount
+/// or `/proc` under the root cannot make it run forever. `du` dedups hard links
+/// itself. Parsing lives in [`crate::duscan::parse_du_output`], which is where the
+/// output shape is documented and tested. The path is validated + single-quoted.
+pub fn remote_du_tree(spec: &RemoteSpec, remote_dir: &str) -> Result<crate::duscan::DuScan, String> {
+    validate_arg("remote path", remote_dir)?;
+    let cmd = format!("du -ak -x {} 2>/dev/null", shell_quote(remote_dir));
+    let out = run_remote_shell(spec, &cmd)?;
+    // `du` exits non-zero when *any* entry was unreadable, having still printed
+    // everything it could reach — so the status is ignored and stdout is parsed
+    // regardless. An empty stdout (a genuinely dead connection) fails in the parser.
+    crate::duscan::parse_du_output(remote_dir, &String::from_utf8_lossy(&out.stdout))
+}
+
+/// Raw `du -ak -x` capture of a host directory, riding the shared ControlMaster.
+///
+/// The same command `remote_du_tree` runs, but handed back as **text** rather than
+/// pruned into a `DuScan`: the giant-folder census (`services::big_folders`) needs
+/// every line — the emit caps that make a size *tree* renderable would silently
+/// drop the folders it exists to find. One round trip; `-x` stays on this
+/// filesystem, so a network mount under the project root isn't measured as project
+/// data. `du` exits non-zero on any unreadable entry having printed the rest, so
+/// stdout is returned regardless of status.
+pub fn remote_du_raw(spec: &RemoteSpec, remote_dir: &str) -> Result<String, String> {
+    validate_arg("remote path", remote_dir)?;
+    let cmd = format!("du -ak -x {} 2>/dev/null", shell_quote(remote_dir));
+    let out = run_remote_shell(spec, &cmd)?;
+    let text = String::from_utf8_lossy(&out.stdout).into_owned();
+    if text.trim().is_empty() {
+        return Err("du returned nothing (is the host reachable?)".to_string());
+    }
+    Ok(text)
+}
+
+/// Best-effort create `spec.remote_path` (and parents) on the host over SSH,
+/// riding the shared ControlMaster. Used when a new remote project is created so
+/// agent tabs / git can `cd` into the project root. `mkdir -p <path>` is handed
+/// to the remote `$SHELL -c`, so the path is single-quoted via `shell_quote` and
+/// validated (no leading `-`, no control chars). Returns the trimmed stderr on
+/// failure; callers treat it as best-effort.
+pub fn remote_mkdir_p(spec: &RemoteSpec) -> Result<(), String> {
+    validate_arg("remote path", &spec.remote_path)?;
+    let mut args = ssh_base_args(&spec.user, &spec.host, spec.port)?;
+    args.push(format!("mkdir -p {}", shell_quote(&spec.remote_path)));
+    let out = crate::paths::command_no_window("ssh")
+        .args(&args)
+        .output()
+        .map_err(|e| format!("failed to run mkdir over ssh: {e}"))?;
+    if out.status.success() {
+        Ok(())
+    } else {
+        Err(String::from_utf8_lossy(&out.stderr).trim().to_string())
+    }
+}
+
+/// Best-effort `git init` on the host inside `spec.remote_path`, but only when
+/// that dir is not already a git work tree. Used when a remote project is
+/// imported **with git support** (`git_type != "none"`) onto a host tree that
+/// carries no repo: it gives git lockstep a repo on the (authoritative) host to
+/// pair the local mirror from, matching how a fresh remote *create* leaves the
+/// mirror as the repo. Idempotent — a path that is already a repo is left
+/// untouched. The command is handed to the remote `$SHELL -c`, so the path is
+/// single-quoted via `shell_quote` and validated; rides the shared ControlMaster.
+pub fn remote_git_init(spec: &RemoteSpec) -> Result<(), String> {
+    validate_arg("remote path", &spec.remote_path)?;
+    let mut args = ssh_base_args(&spec.user, &spec.host, spec.port)?;
+    let path = shell_quote(&spec.remote_path);
+    args.push(format!(
+        "cd {path} && git rev-parse --is-inside-work-tree >/dev/null 2>&1 || git init"
+    ));
+    let out = crate::paths::command_no_window("ssh")
+        .args(&args)
+        .output()
+        .map_err(|e| format!("failed to run git init over ssh: {e}"))?;
+    if out.status.success() {
+        Ok(())
+    } else {
+        Err(String::from_utf8_lossy(&out.stderr).trim().to_string())
+    }
+}
+
+/// Build a ready-to-run shell command string that opens an **interactive** ssh
+/// login to `[user@]host[:port]`, sharing the same multiplexing master socket
+/// (`ControlPath`) the terminal/agent tabs use.
+///
+/// Typed into a root-scope shell tab (see the frontend `openConnectionInRoot`)
+/// when the user has turned **off** headless connections: the password is entered
+/// directly in the visible terminal — Eldrun never handles it — and because the
+/// login shares `cm-%C` with [`ssh_pty_args`], the pooled SFTP session, file
+/// browse, and git-over-ssh all ride the authenticated master without a second
+/// prompt. On Unix this enables `ControlMaster=auto`; on Windows
+/// multiplexing is unavailable so the login simply opens its own connection. The
+/// control-socket dir is created here so ssh can bind the master. Each argv item
+/// is shell-quoted before being joined, so spaces/metacharacters stay inert.
+pub fn interactive_login_command(
+    user: &Option<String>,
+    host: &str,
+    port: Option<u16>,
+) -> Result<String, String> {
+    let target = ssh_target(user, host)?;
+    let mut args: Vec<String> = vec!["ssh".to_string()];
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        let _ = std::fs::create_dir_all(control_dir());
+        let control_path = control_dir().join("cm-%C");
+        args.push("-o".to_string());
+        args.push("ControlMaster=auto".to_string());
+        args.push("-o".to_string());
+        args.push(format!("ControlPath={}", control_path.to_string_lossy()));
+        args.push("-o".to_string());
+        args.push(format!("ControlPersist={CONTROL_PERSIST_SECS}"));
+    }
+
+    for a in SSH_KEEPALIVE {
+        args.push((*a).to_string());
+    }
+    if let Some(port) = port {
+        args.push("-p".to_string());
+        args.push(port.to_string());
+    }
+    args.push(target);
+
+    Ok(args
+        .iter()
+        .map(|a| shell_quote(a))
+        .collect::<Vec<_>>()
+        .join(" "))
+}
+
+/// If `opts` belongs to a remote project, rewrite it in place to run the
+/// requested command on the remote host via `ssh -tt`. No-op for local projects.
+///
+/// Remoteness is detected from `opts.project_id` (the explicit signal the
+/// frontend sets for project-scope tabs): `remote_target_for` resolves it to a
+/// `RemoteTarget`, or returns `None` for a local project. A spawn with no
+/// `project_id` (root/connection terminals, `local_only` tabs) is always local.
+/// The remote working dir is the project root (`spec.remote_path`).
 ///
 /// On success, `opts.cmd` becomes `"ssh"`, `opts.args` the ssh argv, and
 /// `opts.cwd` a stable local directory (the ssh client's local cwd is
 /// irrelevant). Validation/connection failures surface as `Err`.
 pub fn wrap_pty_options(opts: &mut PtyOptions) -> Result<(), String> {
-    let project_id = match project_id_from_cwd(&opts.cwd) {
-        Some(id) => id,
-        None => return Ok(()), // not under the mounts root → local project
+    let host_id = opts
+        .remote_host_id
+        .as_deref()
+        .unwrap_or(crate::services::remote::PRIMARY_HOST);
+    use crate::services::remote::{remote_target_for, remote_target_for_host, PRIMARY_HOST};
+    let target = match &opts.project_id {
+        Some(id) => match remote_target_for_host(id, host_id) {
+            Some(t) => t,
+            // A worker id that no longer resolves (the machine was removed while a
+            // tab still pointed at it) falls back to the PRIMARY on a remote project
+            // rather than silently running local in the remote cwd (plan §8). A
+            // genuinely local project still resolves to nothing → left as-is.
+            None => match remote_target_for(id).filter(|_| host_id != PRIMARY_HOST) {
+                Some(t) => t,
+                None => return Ok(()),
+            },
+        },
+        None => return Ok(()), // untagged spawn (root/connection/local_only) → local
     };
 
-    let project = crate::commands::ssh::load_project_by_id(&project_id)?;
-    let remote = match project.remote.as_ref() {
-        Some(r) => r,
-        None => return Ok(()), // mounts-root path but no remote spec → leave as-is
-    };
-
-    let mountpoint = ssh_mount::mountpoint_for(&project_id);
-    let remote_dir = remote_subdir(remote, &mountpoint, &opts.cwd);
+    // Remote working dir is the project root on the host. There is no local
+    // mountpoint to strip a subdir against (mount-free remote model).
+    let remote_dir = target.spec.remote_path.trim_end_matches('/').to_string();
     validate_arg("remote dir", &remote_dir)?;
 
     // Ensure the control-socket directory exists before ssh tries to bind it.
     let _ = std::fs::create_dir_all(control_dir());
 
-    let cmd_string = remote_command(&opts.cmd, &opts.args, &opts.env, &remote_dir);
-    let args = ssh_pty_args(remote, &cmd_string)?;
+    // Persistent-session (tmux) wrap, TODO #85. An explicit attach (Sessions view /
+    // restored attach tab) wins; otherwise a per-tab `tmux_session` name — minted
+    // and persisted by the frontend for shell/script tabs of a persist-enabled
+    // remote project (so it is stable across a relaunch, unlike the PTY id) — spawns
+    // or reattaches that session. Absent (agent tabs, persistence off, local) →
+    // today's plain exec.
+    let tmux = match (&opts.tmux_attach, &opts.tmux_session) {
+        (Some(name), _) => Some(TmuxWrap::Attach(name.clone())),
+        (None, Some(name)) => Some(TmuxWrap::Session(name.clone())),
+        (None, None) => None,
+    };
+
+    let cmd_string = remote_command(&opts.cmd, &opts.args, &opts.env, &remote_dir, tmux.as_ref());
+    let args = ssh_pty_args(&target.spec, &cmd_string)?;
 
     opts.cmd = "ssh".to_string();
     opts.args = args;
@@ -229,16 +943,6 @@ pub fn wrap_pty_options(opts: &mut PtyOptions) -> Result<(), String> {
     Ok(())
 }
 
-/// Extract `<project-id>` from a cwd of the form
-/// `<mounts_root>/<project-id>[/subdir…]`, or `None` if `cwd` is not under the
-/// mounts root.
-fn project_id_from_cwd(cwd: &str) -> Option<String> {
-    let root = ssh_mount::mounts_root();
-    let rel = Path::new(cwd).strip_prefix(&root).ok()?;
-    let first = rel.components().next()?;
-    Some(first.as_os_str().to_string_lossy().into_owned())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -250,6 +954,10 @@ mod tests {
             port,
             remote_path: remote_path.to_string(),
             openvpn: None,
+            auto_connect: None,
+            key_auth: None,
+            persist_sessions: None,
+            label: None,
             extra: HashMap::new(),
         }
     }
@@ -265,44 +973,11 @@ mod tests {
         assert_eq!(shell_quote("a'b"), "'a'\\''b'");
     }
 
-    // ── remote_subdir ──────────────────────────────────────────────────────
-
-    #[test]
-    fn remote_subdir_root_is_remote_path() {
-        let s = spec(None, "h", None, "/srv/project");
-        let mp = Path::new("/mounts/p1");
-        assert_eq!(remote_subdir(&s, mp, "/mounts/p1"), "/srv/project");
-    }
-
-    #[test]
-    fn remote_subdir_nested_appends_relative() {
-        let s = spec(None, "h", None, "/srv/project");
-        let mp = Path::new("/mounts/p1");
-        assert_eq!(
-            remote_subdir(&s, mp, "/mounts/p1/sub/dir"),
-            "/srv/project/sub/dir"
-        );
-    }
-
-    #[test]
-    fn remote_subdir_trailing_slash_remote_path() {
-        let s = spec(None, "h", None, "/srv/project/");
-        let mp = Path::new("/mounts/p1");
-        assert_eq!(remote_subdir(&s, mp, "/mounts/p1/x"), "/srv/project/x");
-    }
-
-    #[test]
-    fn remote_subdir_outside_mount_falls_back() {
-        let s = spec(None, "h", None, "/srv/project");
-        let mp = Path::new("/mounts/p1");
-        assert_eq!(remote_subdir(&s, mp, "/somewhere/else"), "/srv/project");
-    }
-
     // ── remote_command ─────────────────────────────────────────────────────
 
     #[test]
     fn remote_command_shell_uses_login_shell() {
-        let cmd = remote_command("", &[], &HashMap::new(), "/srv/p");
+        let cmd = remote_command("", &[], &HashMap::new(), "/srv/p", None);
         assert_eq!(cmd, "cd '/srv/p' && exec \"${SHELL:-/bin/bash}\" -l");
     }
 
@@ -318,6 +993,7 @@ mod tests {
             &["--foo".to_string(), "bar baz".to_string()],
             &HashMap::new(),
             "/srv/p",
+            None,
         );
         assert_eq!(
             cmd,
@@ -328,7 +1004,7 @@ mod tests {
 
     #[test]
     fn remote_command_agent_bootstraps_known_cli() {
-        let cmd = remote_command("claude", &[], &HashMap::new(), "/srv/p");
+        let cmd = remote_command("claude", &[], &HashMap::new(), "/srv/p", None);
         // Runs inside a login shell …
         assert!(cmd.starts_with("cd '/srv/p' && exec \"${SHELL:-/bin/bash}\" -lc "));
         // … with a detect-and-install prelude for the known CLI …
@@ -346,7 +1022,7 @@ mod tests {
         env.insert("COLORTERM".to_string(), "truecolor".to_string());
         env.insert("B_VAR".to_string(), "2".to_string());
         env.insert("A_VAR".to_string(), "x y".to_string());
-        let cmd = remote_command("sh", &[], &env, "/srv/p");
+        let cmd = remote_command("sh", &[], &env, "/srv/p", None);
         assert_eq!(
             cmd,
             "cd '/srv/p' && export A_VAR='x y' && export B_VAR='2' && \
@@ -360,7 +1036,7 @@ mod tests {
         env.insert("ANTHROPIC_API_KEY".to_string(), "sk-local".to_string());
         env.insert("OPENAI_API_KEY".to_string(), "sk-oai".to_string());
         env.insert("KEEP_ME".to_string(), "1".to_string());
-        let cmd = remote_command("sh", &[], &env, "/srv/p");
+        let cmd = remote_command("sh", &[], &env, "/srv/p", None);
         // Auth vars (and their values) are never exported to the remote …
         assert!(!cmd.contains("ANTHROPIC_API_KEY"));
         assert!(!cmd.contains("OPENAI_API_KEY"));
@@ -370,6 +1046,191 @@ mod tests {
         assert!(cmd.contains("export KEEP_ME='1'"));
     }
 
+    #[test]
+    fn remote_command_drops_env_key_with_shell_metachars() {
+        // A key carrying shell metacharacters can't be made safe by quoting the
+        // value (the key sits left of `=`), so it must be dropped entirely rather
+        // than emitted as `export <metachars>=…`.
+        let mut env = HashMap::new();
+        env.insert("A; touch /tmp/pwned #".to_string(), "v".to_string());
+        env.insert("GOOD_VAR".to_string(), "1".to_string());
+        let cmd = remote_command("sh", &[], &env, "/srv/p", None);
+        assert!(!cmd.contains("touch /tmp/pwned"));
+        assert!(!cmd.contains("export A;"));
+        assert!(cmd.contains("export GOOD_VAR='1'"));
+    }
+
+    // ── tmux wrap (TODO #85) ───────────────────────────────────────────────
+
+    #[test]
+    fn remote_command_off_is_unchanged() {
+        // With no tmux wrap the output is byte-for-byte the pre-#85 command: the
+        // cd/exports/exec nesting is untouched.
+        let mut env = HashMap::new();
+        env.insert("K".to_string(), "v".to_string());
+        assert_eq!(
+            remote_command("", &[], &env, "/srv/p", None),
+            "cd '/srv/p' && export K='v' && exec \"${SHELL:-/bin/bash}\" -l"
+        );
+    }
+
+    #[test]
+    fn remote_command_tmux_wraps_shell_tab() {
+        let wrap = TmuxWrap::Session("eldrun-p1_shell-1".to_string());
+        let cmd = remote_command("", &[], &HashMap::new(), "/srv/p", Some(&wrap));
+        // cd prefix is preserved verbatim…
+        assert!(cmd.starts_with("cd '/srv/p' && "));
+        // …and the exec is a new-session -A -D on the derived name, with the login
+        // shell exec nested as tmux's (quoted) command argument.
+        assert!(cmd.contains("command -v tmux >/dev/null 2>&1"));
+        assert!(cmd.contains("exec tmux new-session -A -D -s 'eldrun-p1_shell-1' "));
+        assert!(cmd.contains("'exec \"${SHELL:-/bin/bash}\" -l'"));
+        // status/mouse options are chained as separate tmux commands.
+        assert!(cmd.contains("';' set -g status off ';' set -g mouse on"));
+        // Fallback: a host without tmux still runs the plain exec.
+        assert!(cmd.contains("session persistence is OFF"));
+        assert!(cmd.contains("; exec \"${SHELL:-/bin/bash}\" -l; fi"));
+    }
+
+    #[test]
+    fn remote_command_tmux_wraps_command_tab_preserving_prelude() {
+        let wrap = TmuxWrap::Session("eldrun-p1_a1".to_string());
+        let cmd = remote_command("claude", &[], &HashMap::new(), "/srv/p", Some(&wrap));
+        // The agent bootstrap prelude is nested INSIDE the tmux target unchanged…
+        assert!(cmd.contains("command -v claude >/dev/null 2>&1"));
+        assert!(cmd.contains("npm install -g @anthropic-ai/claude-code"));
+        // …and the whole `$SHELL -lc '<prelude; exec claude>'` line is tmux's
+        // (quoted) command argument on the persistent session.
+        assert!(cmd.contains("exec tmux new-session -A -D -s 'eldrun-p1_a1' "));
+    }
+
+    #[test]
+    fn remote_command_tmux_attach_ignores_target() {
+        let wrap = TmuxWrap::Attach("train".to_string());
+        // Even with a target command, an attach ignores it and just reattaches the
+        // named (possibly hand-started) session.
+        let cmd = remote_command("python", &["run.py".to_string()], &HashMap::new(), "/srv/p", Some(&wrap));
+        assert!(cmd.contains("exec tmux new-session -A -D -s 'train' "));
+        // No fresh target is exec'd inside the attach (the session already runs).
+        assert!(!cmd.contains("run.py"));
+    }
+
+    #[test]
+    fn tmux_kill_session_script_quotes_name() {
+        assert_eq!(
+            tmux_kill_session_script("eldrun-p1_shell-1"),
+            "tmux kill-session -t 'eldrun-p1_shell-1' 2>/dev/null || true"
+        );
+        // An arbitrary/foreign name is single-quoted so it can't break out.
+        assert!(tmux_kill_session_script("a'b").contains("'a'\\''b'"));
+    }
+
+    #[test]
+    fn tmux_kill_server_script_is_best_effort() {
+        assert_eq!(tmux_kill_server_script(), "tmux kill-server 2>/dev/null || true");
+    }
+
+    #[test]
+    fn parse_tmux_ls_reads_rows_and_tolerates_empty() {
+        let out = "eldrun-p1_shell-1\t2\t1700000000\t1\t1700003600\t-bash\t/code/p1\ntrain\t1\t1700000500\t0\t1700009000\tpython\t/code/p1/run\n";
+        let v = parse_tmux_ls(out);
+        assert_eq!(v.len(), 2);
+        assert_eq!(v[0], TmuxSession { name: "eldrun-p1_shell-1".into(), windows: 2, created: 1_700_000_000, attached: true, activity: 1_700_003_600, current_command: "-bash".into(), working: false, current_path: "/code/p1".into() });
+        assert_eq!(v[1], TmuxSession { name: "train".into(), windows: 1, created: 1_700_000_500, attached: false, activity: 1_700_009_000, current_command: "python".into(), working: true, current_path: "/code/p1/run".into() });
+        // "no server running" / absent tmux → empty output → zero sessions.
+        assert!(parse_tmux_ls("").is_empty());
+        assert!(parse_tmux_ls("\n").is_empty());
+        // A malformed row is skipped, not fatal.
+        assert!(parse_tmux_ls("onlyname\n").is_empty());
+    }
+
+    #[test]
+    fn parse_tmux_ls_defaults_missing_trailing_fields() {
+        // A row from an older-format `tmux ls` (missing activity/current_command)
+        // still surfaces, rather than being dropped, with activity falling back to
+        // `created` and the session read as idle.
+        let v = parse_tmux_ls("legacy\t1\t1700000000\t0\n");
+        assert_eq!(v.len(), 1);
+        assert_eq!(v[0].activity, 1_700_000_000);
+        assert_eq!(v[0].current_command, "");
+        assert_eq!(v[0].current_path, "");
+        assert!(!v[0].working);
+    }
+
+    #[test]
+    fn path_within_respects_segment_boundaries() {
+        assert!(path_within("/code/proj", "/code/proj"));
+        assert!(path_within("/code/proj/sub/dir", "/code/proj"));
+        assert!(path_within("/code/proj/", "/code/proj"));
+        // A sibling that merely shares a prefix is NOT inside it.
+        assert!(!path_within("/code/proj2", "/code/proj"));
+        assert!(!path_within("/code", "/code/proj"));
+        // Nothing is inside an unknown root.
+        assert!(!path_within("/code/proj", ""));
+    }
+
+    #[test]
+    fn session_visible_scopes_by_name_then_by_working_directory() {
+        let root = "/code/p1";
+        // 1. The name settles it when it carries a project id, whatever the path.
+        assert!(session_visible_for_project("eldrun-p1--abcd", "/somewhere/else", "p1", root));
+        assert!(!session_visible_for_project("eldrun-p2--abcd", "/code/p1", "p1", root));
+        // 2. Otherwise the working directory does. A legacy (pre-scoping) session
+        //    running in this project's tree is this project's.
+        assert!(session_visible_for_project("eldrun-legacyuuid", "/code/p1/src", "p1", root));
+        // …and one running in ANOTHER project's tree is not.
+        assert!(!session_visible_for_project("eldrun-legacyuuid", "/code/p2", "p1", root));
+        // A hand-started session is attributed the same way.
+        assert!(session_visible_for_project("train", "/code/p1", "p1", root));
+        assert!(!session_visible_for_project("train", "/home/me", "p1", root));
+        // A row whose host reported no path at all is unattributable → shown,
+        // never silently dropped.
+        assert!(session_visible_for_project("train", "", "p1", root));
+        // An id needing sanitizing is matched consistently on both sides.
+        assert!(session_visible_for_project("eldrun-we_rd--abcd", "/elsewhere", "we:rd", root));
+    }
+
+    #[test]
+    fn filter_sessions_for_project_scopes_and_honours_include_all() {
+        let s = |name: &str, path: &str| TmuxSession {
+            name: name.into(), windows: 1, created: 0, attached: false, activity: 0,
+            current_command: "".into(), working: false, current_path: path.into(),
+        };
+        let sessions = vec![
+            s("eldrun-p1--a", "/code/p1"),
+            s("eldrun-p2--b", "/code/p2"),
+            s("train", "/code/p1"),          // hand-started inside this project
+            s("other", "/home/me"),          // hand-started elsewhere
+            s("eldrun-legacyuuid", "/code/p1/run"), // pre-scoping, this project's tree
+            s("eldrun-legacyother", "/code/p2/run"), // pre-scoping, another's tree
+        ];
+        let kept = filter_sessions_for_project(sessions.clone(), "p1", "/code/p1", false);
+        let names: Vec<&str> = kept.iter().map(|x| x.name.as_str()).collect();
+        assert_eq!(names, vec!["eldrun-p1--a", "train", "eldrun-legacyuuid"]);
+        // The escape hatch returns the host listing untouched, so an orphaned run
+        // is always reachable to kill.
+        assert_eq!(filter_sessions_for_project(sessions, "p1", "/code/p1", true).len(), 6);
+    }
+
+    #[test]
+    fn tmux_ls_script_tolerates_no_server() {
+        let s = tmux_ls_script();
+        assert!(s.contains("tmux ls -F"));
+        // "no server running" (non-zero exit) and absent tmux both collapse to
+        // empty output rather than an error.
+        assert!(s.contains("2>/dev/null || true"));
+    }
+
+    #[test]
+    fn is_valid_env_key_matches_posix_identifiers() {
+        assert!(is_valid_env_key("ELDRUN_TAB_UID"));
+        assert!(is_valid_env_key("_x9"));
+        assert!(!is_valid_env_key("9leading"));
+        assert!(!is_valid_env_key("has space"));
+        assert!(!is_valid_env_key("a;b"));
+        assert!(!is_valid_env_key(""));
+    }
+
     // ── ssh_pty_args ───────────────────────────────────────────────────────
 
     #[test]
@@ -378,9 +1239,15 @@ mod tests {
         let args = ssh_pty_args(&s, "cd '/srv/p' && exec sh").unwrap();
 
         assert_eq!(args[0], "-tt");
-        assert!(args.iter().any(|a| a == "ControlMaster=auto"));
-        assert!(args.iter().any(|a| a.starts_with("ControlPath=")));
-        assert!(args.iter().any(|a| a.starts_with("ControlPersist=")));
+        // Multiplexing is Unix-only: present on Unix, omitted on Windows.
+        #[cfg(not(target_os = "windows"))]
+        {
+            assert!(args.iter().any(|a| a == "ControlMaster=auto"));
+            assert!(args.iter().any(|a| a.starts_with("ControlPath=")));
+            assert!(args.iter().any(|a| a.starts_with("ControlPersist=")));
+        }
+        #[cfg(target_os = "windows")]
+        assert!(!args.iter().any(|a| a == "ControlMaster=auto"));
         assert!(args.iter().any(|a| a == "ServerAliveInterval=15"));
         // Interactive PTY: BatchMode must NOT be forced.
         assert!(!args.iter().any(|a| a == "BatchMode=yes"));
@@ -405,20 +1272,131 @@ mod tests {
         assert!(ssh_pty_args(&s, "exec sh").is_err());
     }
 
-    // ── project_id_from_cwd ────────────────────────────────────────────────
+    #[test]
+    fn ssh_control_check_uses_shared_path_and_target() {
+        let args = ssh_control_check_args(&spec(Some("alice"), "host.example", Some(2200), "/p"))
+            .unwrap();
+        assert_eq!(args[0], "-S");
+        assert!(args[1].contains("cm-%C"));
+        assert!(args.windows(2).any(|w| w == ["-O", "check"]));
+        assert!(args.windows(2).any(|w| w == ["-p", "2200"]));
+        assert_eq!(args.last().unwrap(), "alice@host.example");
+    }
+
+    // ── interactive_login_command ──────────────────────────────────────────
 
     #[test]
-    fn project_id_from_cwd_outside_mounts_is_none() {
-        assert_eq!(project_id_from_cwd("/home/user/proj"), None);
+    fn interactive_login_command_shape() {
+        let cmd =
+            interactive_login_command(&Some("alice".to_string()), "host.example", None).unwrap();
+        // Starts with a (quoted) ssh and ends with the (quoted) target.
+        assert!(cmd.starts_with("'ssh' "));
+        assert!(cmd.contains("'alice@host.example'"));
+        // Multiplexing master is SHARED with ssh_pty_args (same cm-%C socket), so a
+        // root-terminal login's auth is reused by the headless mount/check.
+        #[cfg(not(target_os = "windows"))]
+        {
+            assert!(cmd.contains("ControlMaster=auto"));
+            assert!(cmd.contains("cm-%C"));
+            assert!(cmd.contains("ControlPersist="));
+        }
+        #[cfg(target_os = "windows")]
+        assert!(!cmd.contains("ControlMaster=auto"));
     }
 
     #[test]
-    fn project_id_from_cwd_extracts_id() {
-        let root = ssh_mount::mounts_root();
-        let cwd = root.join("abc-123").join("sub");
+    fn interactive_login_command_includes_port() {
+        let cmd = interactive_login_command(&None, "h", Some(2222)).unwrap();
+        assert!(cmd.contains("'-p' '2222'"));
+        assert!(cmd.trim_end().ends_with("'h'"));
+    }
+
+    #[test]
+    fn interactive_login_command_rejects_bad_target() {
+        assert!(interactive_login_command(&None, "-evil", None).is_err());
+        assert!(interactive_login_command(&Some("-evil".to_string()), "h", None).is_err());
+    }
+
+    // ── wrap_pty_options detection ─────────────────────────────────────────
+
+    fn local_opts(cwd: &str, project_id: Option<&str>) -> PtyOptions {
+        PtyOptions {
+            id: "t".to_string(),
+            cmd: "bash".to_string(),
+            args: vec![],
+            env: HashMap::new(),
+            cwd: cwd.to_string(),
+            cols: 80,
+            rows: 24,
+            local_only: false,
+            sandbox: false,
+            project_id: project_id.map(str::to_string),
+            remote_host_id: None,
+            tmux_session: None,
+            tmux_attach: None,
+        }
+    }
+
+    #[test]
+    fn wrap_pty_options_none_id_is_local_noop() {
+        // No explicit project_id (root/connection/local_only spawn) → always
+        // local, so the spawn is left untouched (mount-free: there is no cwd
+        // mountpoint to sniff).
+        let mut opts = local_opts("/home/user/proj", None);
+        wrap_pty_options(&mut opts).unwrap();
+        assert_eq!(opts.cmd, "bash");
+        assert!(opts.args.is_empty());
+    }
+
+    // ── git over ssh ───────────────────────────────────────────────────────
+
+    #[test]
+    fn remote_git_command_quotes_path_and_each_arg() {
+        let cmd = remote_git_command(
+            "/srv/my project",
+            &["status".to_string(), "--porcelain".to_string()],
+        );
+        assert_eq!(cmd, "cd '/srv/my project' && git 'status' '--porcelain'");
+    }
+
+    #[test]
+    fn remote_git_command_no_args_is_bare_git() {
+        assert_eq!(remote_git_command("/srv/p", &[]), "cd '/srv/p' && git");
+    }
+
+    #[test]
+    fn git_ssh_args_shape_target_then_remote_command_last() {
+        let s = spec(Some("alice"), "host.example", None, "/srv/p");
+        let args = git_ssh_args(&s, &["status".to_string(), "--porcelain".to_string()]).unwrap();
+        // BatchMode (rides/falls-back to key auth), target present as one item.
+        assert!(args.iter().any(|a| a == "BatchMode=yes"));
+        assert!(args.iter().any(|a| a == "alice@host.example"));
+        // The remote $SHELL -c string is the final argv item.
         assert_eq!(
-            project_id_from_cwd(&cwd.to_string_lossy()),
-            Some("abc-123".to_string())
+            args.last().unwrap(),
+            "cd '/srv/p' && git 'status' '--porcelain'"
         );
+        // Opportunistic ControlMaster reuse on Unix (shared cm-%C socket).
+        #[cfg(not(target_os = "windows"))]
+        {
+            assert!(args.iter().any(|a| a == "ControlMaster=no"));
+            assert!(args.iter().any(|a| a.contains("cm-%C")));
+        }
+    }
+
+    #[test]
+    fn git_ssh_args_includes_port() {
+        let s = spec(None, "h", Some(2222), "/p");
+        let args = git_ssh_args(&s, &["log".to_string()]).unwrap();
+        let pos = args.iter().position(|a| a == "-p").expect("-p present");
+        assert_eq!(args[pos + 1], "2222");
+    }
+
+    #[test]
+    fn git_ssh_args_rejects_bad_remote_path_and_host() {
+        // A remote path that could be read as an option is rejected before any
+        // ssh runs (it would otherwise be embedded in the remote shell string).
+        assert!(git_ssh_args(&spec(None, "h", None, "-rf"), &["status".to_string()]).is_err());
+        assert!(git_ssh_args(&spec(None, "-evil", None, "/p"), &["status".to_string()]).is_err());
     }
 }
diff --git a/src-tauri/src/services/ssh_mount.rs b/src-tauri/src/services/ssh_mount.rs
deleted file mode 100644
index 860a69b..0000000
--- a/src-tauri/src/services/ssh_mount.rs
+++ /dev/null
@@ -1,406 +0,0 @@
-//! sshfs mount lifecycle for remote (SSH) projects.
-//!
-//! A remote project's bytes live on `host:remote_path`; on activation we
-//! `sshfs`-mount that remote directory to a local mountpoint under
-//! `~/.local/share/eldrun/mounts/<project-id>/`. The project's `directory`
-//! field then points at the mountpoint so all existing local code (file tree,
-//! PTY cwd, git) keeps working unchanged.
-//!
-//! As in `commands/ssh.rs`, every argument is passed to the child process as a
-//! separate argv item (never a shell string), and values that could be mistaken
-//! for an option (a leading `-`) or that contain control characters are
-//! rejected. The validation/argv helpers here are the single source of truth;
-//! `commands::ssh` re-uses `validate_arg`/`ssh_base_args` from this module.
-
-use std::path::{Path, PathBuf};
-use std::process::Command;
-
-use crate::schema::project::RemoteSpec;
-use crate::storage;
-
-/// Reject values that contain control characters (incl. NUL/newline) or that
-/// begin with `-` (which `ssh`/`sshfs`/`ls` would treat as an option). Empty
-/// values are allowed here; callers decide whether emptiness is acceptable.
-pub fn validate_arg(label: &str, value: &str) -> Result<(), String> {
-    if value.starts_with('-') {
-        return Err(format!("{label} must not start with '-'"));
-    }
-    if value.chars().any(|c| c.is_control()) {
-        return Err(format!("{label} contains invalid control characters"));
-    }
-    Ok(())
-}
-
-/// Build the base `ssh` argv (everything up to but not including the remote
-/// command), validating `host`/`user` and rendering the `[user@]host` target as
-/// a single argv item.
-pub fn ssh_base_args(
-    user: &Option<String>,
-    host: &str,
-    port: Option<u16>,
-) -> Result<Vec<String>, String> {
-    let host = host.trim();
-    if host.is_empty() {
-        return Err("host must not be empty".to_string());
-    }
-    validate_arg("host", host)?;
-
-    let mut args: Vec<String> = vec![
-        "-o".to_string(),
-        "BatchMode=yes".to_string(),
-        "-o".to_string(),
-        "ConnectTimeout=10".to_string(),
-    ];
-
-    if let Some(port) = port {
-        args.push("-p".to_string());
-        args.push(port.to_string());
-    }
-
-    args.push(ssh_target(user, host)?);
-
-    Ok(args)
-}
-
-/// Render the `[user@]host` SSH target as a single, validated argv item.
-pub fn ssh_target(user: &Option<String>, host: &str) -> Result<String, String> {
-    let host = host.trim();
-    if host.is_empty() {
-        return Err("host must not be empty".to_string());
-    }
-    validate_arg("host", host)?;
-    match user {
-        Some(user) => {
-            let user = user.trim();
-            if user.is_empty() {
-                return Err("user must not be empty when provided".to_string());
-            }
-            validate_arg("user", user)?;
-            Ok(format!("{user}@{host}"))
-        }
-        None => Ok(host.to_string()),
-    }
-}
-
-/// Local mountpoint for a remote project:
-/// `<state_dir>/mounts/<project-id>` (e.g.
-/// `~/.local/share/eldrun/mounts/<project-id>`).
-pub fn mountpoint_for(project_id: &str) -> PathBuf {
-    storage::state_dir().join("mounts").join(project_id)
-}
-
-/// Root directory that holds every project's mountpoint.
-pub fn mounts_root() -> PathBuf {
-    storage::state_dir().join("mounts")
-}
-
-/// True if `sshfs` is available on `PATH`.
-pub fn sshfs_available() -> bool {
-    which_exists("sshfs")
-}
-
-/// True if `sshpass` is available on `PATH`. Required for password auth, which
-/// otherwise cannot run non-interactively (ssh reads the passphrase from the
-/// controlling TTY, which we do not have).
-pub fn sshpass_available() -> bool {
-    which_exists("sshpass")
-}
-
-fn which_exists(bin: &str) -> bool {
-    Command::new("which")
-        .arg(bin)
-        .output()
-        .map(|o| o.status.success())
-        .unwrap_or(false)
-}
-
-/// True if `path` is currently a mountpoint. Reads `/proc/mounts` (Linux) and
-/// falls back to `mountpoint -q` where that file is unavailable.
-pub fn is_mounted(path: &Path) -> bool {
-    let target = path.to_string_lossy();
-    if let Ok(contents) = std::fs::read_to_string("/proc/mounts") {
-        for line in contents.lines() {
-            // fields: <src> <mountpoint> <fstype> <opts> ...
-            if let Some(mp) = line.split_whitespace().nth(1) {
-                // /proc/mounts escapes spaces as \040; a plain compare is enough
-                // for our mount paths (project ids never contain spaces).
-                if mp == target {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    Command::new("mountpoint")
-        .arg("-q")
-        .arg(path)
-        .status()
-        .map(|s| s.success())
-        .unwrap_or(false)
-}
-
-/// The `sshfs` options we always pass (after `-o`): non-interactive auth plus
-/// resilient reconnect/keepalive so a flaky link recovers instead of wedging.
-const SSHFS_OPTS: &str = "BatchMode=yes,reconnect,ServerAliveInterval=15,ServerAliveCountMax=3";
-
-/// Build the full `sshfs` argv for mounting `remote` at `mountpoint`.
-/// Returned as `Vec<String>` so it is unit-testable without actually mounting.
-///
-/// Shape: `sshfs [user@]host:remote_path <mountpoint> [-p <port>] -o <opts>`.
-pub fn sshfs_args(remote: &RemoteSpec, mountpoint: &Path) -> Result<Vec<String>, String> {
-    let remote_path = remote.remote_path.trim();
-    if remote_path.is_empty() {
-        return Err("remote path must not be empty".to_string());
-    }
-    validate_arg("remote path", remote_path)?;
-
-    let target = ssh_target(&remote.user, &remote.host)?;
-    // `[user@]host:remote_path` is a single argv item for sshfs.
-    let source = format!("{target}:{remote_path}");
-
-    let mut args: Vec<String> = vec![source, mountpoint.to_string_lossy().into_owned()];
-    if let Some(port) = remote.port {
-        args.push("-p".to_string());
-        args.push(port.to_string());
-    }
-    args.push("-o".to_string());
-    args.push(SSHFS_OPTS.to_string());
-    Ok(args)
-}
-
-/// Ensure `remote` is mounted at its project mountpoint, returning the
-/// mountpoint. No-op if already mounted. Creates the mountpoint directory.
-pub fn mount(remote: &RemoteSpec, project_id: &str) -> Result<PathBuf, String> {
-    let mountpoint = mountpoint_for(project_id);
-
-    std::fs::create_dir_all(&mountpoint)
-        .map_err(|e| format!("failed to create mountpoint {}: {e}", mountpoint.display()))?;
-
-    if is_mounted(&mountpoint) {
-        return Ok(mountpoint);
-    }
-
-    if !sshfs_available() {
-        return Err(
-            "sshfs not found — install sshfs/FUSE to use remote projects".to_string(),
-        );
-    }
-
-    let args = sshfs_args(remote, &mountpoint)?;
-    let output = Command::new("sshfs")
-        .args(&args)
-        .output()
-        .map_err(|e| format!("failed to run sshfs: {e}"))?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
-        let msg = if stderr.is_empty() {
-            "sshfs mount failed".to_string()
-        } else {
-            stderr
-        };
-        return Err(msg);
-    }
-
-    Ok(mountpoint)
-}
-
-/// Unmount `path` if it is mounted. Tries `fusermount -u`, then falls back to
-/// `umount`. A "not mounted" path is treated as success (idempotent).
-pub fn unmount(path: &Path) -> Result<(), String> {
-    if !is_mounted(path) {
-        return Ok(());
-    }
-
-    // Preferred: fusermount -u (FUSE unmount, no root needed).
-    let fuser = Command::new("fusermount").arg("-u").arg(path).output();
-    if let Ok(out) = &fuser {
-        if out.status.success() {
-            return Ok(());
-        }
-    }
-
-    // Fallback: umount.
-    let umount = Command::new("umount").arg(path).output();
-    match umount {
-        Ok(out) if out.status.success() => Ok(()),
-        Ok(out) => {
-            // If it became unmounted in the meantime, succeed.
-            if !is_mounted(path) {
-                return Ok(());
-            }
-            let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
-            let fuser_err = fuser
-                .ok()
-                .map(|o| String::from_utf8_lossy(&o.stderr).trim().to_string())
-                .unwrap_or_default();
-            Err(format!(
-                "failed to unmount {}: {}",
-                path.display(),
-                if stderr.is_empty() { fuser_err } else { stderr }
-            ))
-        }
-        Err(e) => {
-            if !is_mounted(path) {
-                return Ok(());
-            }
-            Err(format!("failed to run umount on {}: {e}", path.display()))
-        }
-    }
-}
-
-// NOTE (project-removal unmount): there is no project-delete command today, so
-// a remote project's mount is only torn down at app exit (`unmount_all`). When a
-// delete command is added it should call `unmount(&mountpoint_for(id))` and
-// remove the now-empty mountpoint dir. Until then, a removed-from-the-list
-// remote project's stale mount is cleaned up on the next app exit. Stale mounts
-// after a hard crash are benign: `mount()` is idempotent (no-op if already
-// mounted), so re-launch reuses the existing mount.
-
-/// Best-effort unmount of every eldrun mount under `mounts/`. Used at app exit.
-/// Errors are logged, not propagated, so cleanup never blocks shutdown.
-pub fn unmount_all() {
-    let root = mounts_root();
-    let entries = match std::fs::read_dir(&root) {
-        Ok(e) => e,
-        Err(_) => return, // no mounts dir → nothing to do
-    };
-    for entry in entries.flatten() {
-        let path = entry.path();
-        if path.is_dir() && is_mounted(&path) {
-            if let Err(e) = unmount(&path) {
-                eprintln!("ssh_mount: unmount {} failed: {e}", path.display());
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::collections::HashMap;
-
-    fn spec(
-        user: Option<&str>,
-        host: &str,
-        port: Option<u16>,
-        remote_path: &str,
-    ) -> RemoteSpec {
-        RemoteSpec {
-            user: user.map(str::to_string),
-            host: host.to_string(),
-            port,
-            remote_path: remote_path.to_string(),
-            openvpn: None,
-            extra: HashMap::new(),
-        }
-    }
-
-    // ── mountpoint_for ─────────────────────────────────────────────────────
-
-    #[test]
-    fn mountpoint_for_is_under_mounts_subdir_named_by_id() {
-        let mp = mountpoint_for("abc-123");
-        assert_eq!(mp.file_name().unwrap(), "abc-123");
-        let parent = mp.parent().unwrap();
-        assert_eq!(parent.file_name().unwrap(), "mounts");
-        // grandparent is the eldrun state dir.
-        let grandparent = parent.parent().unwrap();
-        assert_eq!(grandparent.file_name().unwrap(), "eldrun");
-        assert_eq!(mp, storage::state_dir().join("mounts").join("abc-123"));
-    }
-
-    #[test]
-    fn mounts_root_is_state_dir_mounts() {
-        assert_eq!(mounts_root(), storage::state_dir().join("mounts"));
-    }
-
-    // ── sshfs_args ─────────────────────────────────────────────────────────
-
-    #[test]
-    fn sshfs_args_basic_shape_user_host_path() {
-        let s = spec(Some("alice"), "host.example", None, "/srv/project");
-        let mp = PathBuf::from("/tmp/mnt/p1");
-        let args = sshfs_args(&s, &mp).unwrap();
-
-        // First item: [user@]host:remote_path as one argv.
-        assert_eq!(args[0], "alice@host.example:/srv/project");
-        // Second item: the mountpoint.
-        assert_eq!(args[1], "/tmp/mnt/p1");
-        // -o opts present with all required flags.
-        let o = args.iter().position(|a| a == "-o").expect("-o present");
-        let opts = &args[o + 1];
-        assert!(opts.contains("BatchMode=yes"));
-        assert!(opts.contains("reconnect"));
-        assert!(opts.contains("ServerAliveInterval=15"));
-        assert!(opts.contains("ServerAliveCountMax=3"));
-        // No port flag when port is None.
-        assert!(!args.iter().any(|a| a == "-p"));
-    }
-
-    #[test]
-    fn sshfs_args_no_user_uses_bare_host() {
-        let s = spec(None, "host.example", None, "/data");
-        let args = sshfs_args(&s, Path::new("/tmp/m")).unwrap();
-        assert_eq!(args[0], "host.example:/data");
-    }
-
-    #[test]
-    fn sshfs_args_includes_port_flag() {
-        let s = spec(Some("u"), "h", Some(2222), "/p");
-        let args = sshfs_args(&s, Path::new("/tmp/m")).unwrap();
-        let pos = args.iter().position(|a| a == "-p").expect("-p present");
-        assert_eq!(args[pos + 1], "2222");
-    }
-
-    #[test]
-    fn sshfs_args_rejects_leading_dash_remote_path() {
-        let s = spec(None, "h", None, "-oProxyCommand=evil");
-        assert!(sshfs_args(&s, Path::new("/tmp/m")).is_err());
-    }
-
-    #[test]
-    fn sshfs_args_rejects_control_chars_in_path() {
-        let s = spec(None, "h", None, "/a\nb");
-        assert!(sshfs_args(&s, Path::new("/tmp/m")).is_err());
-    }
-
-    #[test]
-    fn sshfs_args_rejects_empty_remote_path() {
-        let s = spec(None, "h", None, "   ");
-        assert!(sshfs_args(&s, Path::new("/tmp/m")).is_err());
-    }
-
-    #[test]
-    fn sshfs_args_rejects_bad_host_and_user() {
-        assert!(sshfs_args(&spec(None, "-evil", None, "/p"), Path::new("/tmp/m")).is_err());
-        assert!(sshfs_args(&spec(Some("-evil"), "h", None, "/p"), Path::new("/tmp/m")).is_err());
-        assert!(sshfs_args(&spec(Some("  "), "h", None, "/p"), Path::new("/tmp/m")).is_err());
-        assert!(sshfs_args(&spec(None, "   ", None, "/p"), Path::new("/tmp/m")).is_err());
-    }
-
-    // ── ssh_base_args / validate_arg (shared helpers) ──────────────────────
-
-    #[test]
-    fn base_args_renders_user_at_host_single_item_with_batchmode() {
-        let args = ssh_base_args(&Some("alice".to_string()), "host.example", None).unwrap();
-        assert_eq!(args.last().unwrap(), "alice@host.example");
-        assert!(args.iter().any(|a| a == "BatchMode=yes"));
-        assert!(args.iter().any(|a| a == "ConnectTimeout=10"));
-    }
-
-    #[test]
-    fn base_args_includes_port() {
-        let args = ssh_base_args(&None, "host", Some(2200)).unwrap();
-        let pos = args.iter().position(|a| a == "-p").unwrap();
-        assert_eq!(args[pos + 1], "2200");
-    }
-
-    #[test]
-    fn validate_arg_rejects_dash_and_control() {
-        assert!(validate_arg("path", "/home/user").is_ok());
-        assert!(validate_arg("path", "-rf").is_err());
-        assert!(validate_arg("path", "a\nb").is_err());
-        assert!(validate_arg("path", "a\0b").is_err());
-    }
-}
diff --git a/src-tauri/src/services/sync_auto.rs b/src-tauri/src/services/sync_auto.rs
new file mode 100644
index 0000000..0ef3930
--- /dev/null
+++ b/src-tauri/src/services/sync_auto.rs
@@ -0,0 +1,507 @@
+//! Auto-sync reconcile engine for remote (SSH) projects.
+//!
+//! Sits on top of the manual selective-sync core (`services::remote_sync`,
+//! `commands::sync`): when the user marks a file/folder **auto-sync**
+//! (`SyncEntry::auto_sync`, set via `sync_set_auto`), a per-project background
+//! task keeps it in sync bidirectionally without a click. It reuses every
+//! `remote_sync` primitive (`walk_host_files`, `walk_mirror_files`, `divergence`,
+//! `push_decision`, `pull_file`, `push_file_atomic`, `record_*`, `save_manifest`)
+//! — this module only adds the *trigger* (a mirror filesystem watcher + an
+//! interval) and the *policy* (act on the safe direction; never auto-touch an
+//! amber/orange conflict).
+//!
+//! Lifecycle: `start` is called after a successful `remote_connect` and `stop`
+//! from `remote_disconnect`; `stop_all` runs at app exit. One task per project,
+//! so reconcile passes never overlap; cross-task safety (vs. manual sync
+//! commands) comes from the single-writer `SyncManifestState` mutex.
+//!
+//! Safe-direction policy per file, judged by `remote_sync::divergence` against
+//! the recorded bases:
+//!   - host moved, local unchanged  → PULL host→local
+//!   - local moved, host unchanged  → PUSH local→host (guarded by `push_decision`)
+//!   - both moved (AMBER/orange)    → SKIP, left for manual resolution
+//!   - neither moved (green)        → no-op
+//! Deletions are intentionally NOT propagated in v1 (a gone host side reads as
+//! "couldn't check" and a gone local side's push errors out and is skipped) —
+//! the conservative "never destructive automatically" stance.
+
+use std::collections::{BTreeSet, HashMap, HashSet};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use notify::{RecursiveMode, Watcher};
+use serde::Serialize;
+use tauri::{AppHandle, Emitter};
+use tokio::sync::{mpsc, Mutex, Notify};
+use tokio::time::MissedTickBehavior;
+
+use crate::schema::net_usage;
+use crate::services::remote::{pooled_sftp, remote_target_for, RemotePoolState, RemoteTarget};
+use crate::services::remote_sync::{
+    self, ensure_loaded, mirror_dir, mirror_local_path, Manifest, PushDecision, SyncManifestState,
+};
+use crate::services::sftp;
+
+/// Host re-stat cadence: how often a connected project's auto paths are checked
+/// for incoming host changes (the local side is also caught near-instantly by the
+/// mirror watcher).
+const AUTO_INTERVAL: Duration = Duration::from_secs(25);
+/// Coalesce a burst of mirror writes into one pass: after the first watcher event
+/// we wait this long, absorbing further events, before reconciling.
+const DEBOUNCE: Duration = Duration::from_millis(1500);
+
+/// One running auto-sync task: its cancel signal, its join handle, and the mirror
+/// watcher whose lifetime is tied to the task (dropping it unwatches).
+pub struct AutoSyncTask {
+    cancel: Arc<Notify>,
+    join: tokio::task::JoinHandle<()>,
+    /// When set, `reconcile_pass` early-returns so a git checkout (`services::
+    /// git_peer`) can rewrite the mirror without those writes being pulled/pushed.
+    /// `git_peer` re-stamps the file-sync bases before clearing this, so the next
+    /// pass reads the rewritten tracked files as green rather than as local edits.
+    paused: Arc<AtomicBool>,
+}
+
+/// Tauri-managed registry of per-project auto-sync tasks, keyed by project id.
+pub type AutoSyncState = Arc<Mutex<HashMap<String, AutoSyncTask>>>;
+
+/// Build a fresh, empty registry for `tauri::Builder::manage`.
+pub fn new_state() -> AutoSyncState {
+    Arc::new(Mutex::new(HashMap::new()))
+}
+
+/// Payload of the `auto-sync` event, emitted after a pass that transferred
+/// anything so the frontend can refresh its sync status (and optionally surface a
+/// "N synced, M conflicts" hint).
+#[derive(Clone, Serialize)]
+struct AutoSyncEvent {
+    project_id: String,
+    pulled: usize,
+    pushed: usize,
+    skipped_amber: usize,
+}
+
+/// Start the per-project auto-sync task (idempotent; no-op for a local project).
+/// Spawns a recursive filesystem watcher on the local mirror plus the reconcile
+/// loop. Called after `remote_connect` succeeds.
+pub async fn start(
+    app: AppHandle,
+    pool: RemotePoolState,
+    manifest: SyncManifestState,
+    state: &AutoSyncState,
+    project_id: &str,
+) {
+    // Only remote projects have a host to sync against.
+    let Some(target) = remote_target_for(project_id) else {
+        return;
+    };
+    // …and a host the user tagged HPC gets no *background* sync at all. Every
+    // pass walks the host tree over SFTP, and on a cluster that tree is normally
+    // on the parallel filesystem, where a recursive walk is a metadata storm
+    // against a shared server — at a 25 s cadence, unasked for, for as long as the
+    // project is open. Manual sync (the file view's push/pull) is untouched: the
+    // objection is to the cadence, not to the transfer.
+    if crate::services::hpc_mode::is_hpc_spec(&target.spec) {
+        return;
+    }
+    let mut guard = state.lock().await;
+    if guard.contains_key(project_id) {
+        return; // already running
+    }
+
+    // Mirror watcher → mpsc into the loop (debounced there). The mirror must
+    // exist for the recursive watch to attach (connect() already creates it, but
+    // be defensive for a first-ever run).
+    //
+    // The watcher itself is attached by the loop, not here, and only once the
+    // manifest actually marks something for auto-sync — see `attach_watcher`.
+    let mirror = mirror_dir(project_id);
+    let _ = std::fs::create_dir_all(&mirror);
+    let (tx, rx) = mpsc::unbounded_channel::<()>();
+
+    let cancel = Arc::new(Notify::new());
+    let paused = Arc::new(AtomicBool::new(false));
+    let join = tokio::spawn(run_loop(
+        app,
+        pool,
+        manifest,
+        target,
+        project_id.to_string(),
+        mirror,
+        tx,
+        rx,
+        cancel.clone(),
+        paused.clone(),
+    ));
+    guard.insert(
+        project_id.to_string(),
+        AutoSyncTask {
+            cancel,
+            join,
+            paused,
+        },
+    );
+}
+
+/// Pause the project's auto-sync reconcile passes (no-op if no task). Used by
+/// `services::git_peer` around a coordinated checkout so the checkout's mirror
+/// writes are neither pulled nor pushed. Idempotent.
+pub async fn pause(state: &AutoSyncState, project_id: &str) {
+    if let Some(t) = state.lock().await.get(project_id) {
+        t.paused.store(true, Ordering::SeqCst);
+    }
+}
+
+/// Resume the project's auto-sync reconcile passes (no-op if no task). The caller
+/// must have re-stamped any checkout-rewritten tracked-file bases first, else the
+/// next pass will treat them as local edits. Idempotent.
+pub async fn resume(state: &AutoSyncState, project_id: &str) {
+    if let Some(t) = state.lock().await.get(project_id) {
+        t.paused.store(false, Ordering::SeqCst);
+    }
+}
+
+/// Stop the project's auto-sync task (no-op if none). Drops the watcher (unwatch),
+/// cancels the loop, and awaits its join under a bounded timeout so a stuck pass
+/// can't hang disconnect.
+pub async fn stop(state: &AutoSyncState, project_id: &str) {
+    let task = state.lock().await.remove(project_id);
+    if let Some(t) = task {
+        t.cancel.notify_one();
+        let _ = tokio::time::timeout(Duration::from_secs(5), t.join).await;
+    }
+}
+
+/// Stop every auto-sync task. Used at app exit before tearing down the pool.
+pub async fn stop_all(state: &AutoSyncState) {
+    let tasks: Vec<AutoSyncTask> = state.lock().await.drain().map(|(_, t)| t).collect();
+    for t in tasks {
+        t.cancel.notify_one();
+        let _ = tokio::time::timeout(Duration::from_secs(5), t.join).await;
+    }
+}
+
+/// Attach the mirror watcher, but only once the manifest marks *something* for
+/// auto-sync. No-op if already attached, or if there is still nothing marked.
+///
+/// Byte-sync scope is opt-in per path (no marker ⇒ nothing crosses), so a remote
+/// project that has never marked anything — the common case — used to pay for a
+/// recursive watch it could not act on: `reconcile_pass` collects the `auto_sync`
+/// entries and returns immediately when there are none, but the watch had already
+/// cost one inotify watch per directory in the mirror (8017 on a measured project
+/// with two virtualenvs), each event waking a thread to send on a channel whose
+/// consumer would bail. Deferring the attach makes that cost follow the feature.
+///
+/// Re-checked on every interval tick rather than wired into `sync_set_auto`, which
+/// deliberately transfers nothing and leaves the engine to act on its next pass —
+/// so the marker and the watcher stay decoupled, and a manifest edited by any
+/// route (command, import, hand-edited file) is picked up the same way.
+async fn ensure_watcher(
+    slot: &mut Option<notify::RecommendedWatcher>,
+    manifest: &SyncManifestState,
+    project_id: &str,
+    mirror: &std::path::Path,
+    tx: &mpsc::UnboundedSender<()>,
+) {
+    if slot.is_some() {
+        return;
+    }
+    {
+        let mut g = manifest.lock().await;
+        let m = ensure_loaded(&mut g, project_id);
+        if !m.values().any(|e| e.auto_sync) {
+            return;
+        }
+    }
+    let tx = tx.clone();
+    let Ok(mut w) = notify::recommended_watcher(move |res: notify::Result<notify::Event>| {
+        if res.is_ok() {
+            let _ = tx.send(());
+        }
+    }) else {
+        return; // no watcher → interval passes still run, just less promptly
+    };
+    if w.watch(mirror, RecursiveMode::Recursive).is_ok() {
+        *slot = Some(w);
+    }
+}
+
+/// The per-project loop: reconcile on a fixed interval (host changes) and shortly
+/// after any mirror write (local changes), until cancelled. A single task ⇒ passes
+/// are serialized and never overlap.
+/// Whether this loop's host is tagged HPC **right now** — the same gate `start()`
+/// applies, asked again on every tick so tagging a machine mid-session actually
+/// stops the traffic rather than only preventing the next start.
+fn hpc_now(target: &RemoteTarget) -> bool {
+    crate::services::hpc_mode::is_hpc_spec(&target.spec)
+}
+
+async fn run_loop(
+    app: AppHandle,
+    pool: RemotePoolState,
+    manifest: SyncManifestState,
+    target: RemoteTarget,
+    project_id: String,
+    mirror: std::path::PathBuf,
+    tx: mpsc::UnboundedSender<()>,
+    mut rx: mpsc::UnboundedReceiver<()>,
+    cancel: Arc<Notify>,
+    paused: Arc<AtomicBool>,
+) {
+    let mut interval = tokio::time::interval(AUTO_INTERVAL);
+    interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
+    // Dropped with the task (cancel/stop) → unwatch, exactly as the old field on
+    // `AutoSyncTask` did. `None` until the manifest marks something; see below.
+    let mut watcher: Option<notify::RecommendedWatcher> = None;
+    ensure_watcher(&mut watcher, &manifest, &project_id, &mirror, &tx).await;
+    loop {
+        tokio::select! {
+            _ = cancel.notified() => break,
+            _ = interval.tick() => {
+                // Re-read the tag, don't trust the one `start()` saw: tagging a
+                // machine is normally something the user does *because* they
+                // noticed the traffic, and a gate evaluated once at connect would
+                // leave the loop they are trying to stop running until the next
+                // disconnect. Breaking ends the task; `stop()` then finds it
+                // already finished, which is the same state as a cancel.
+                if hpc_now(&target) { break; }
+                if paused.load(Ordering::SeqCst) { continue; }
+                // Cheap once attached; this is what picks up a `sync_set_auto` that
+                // marked the first path after the task was already running.
+                ensure_watcher(&mut watcher, &manifest, &project_id, &mirror, &tx).await;
+                reconcile_pass(Some(&app), &pool, &manifest, &target, &project_id).await;
+            }
+            res = rx.recv() => {
+                if res.is_none() { break; } // watcher gone → stop
+                // Debounce: absorb the rest of the burst before reconciling.
+                loop {
+                    tokio::select! {
+                        _ = cancel.notified() => return,
+                        _ = tokio::time::sleep(DEBOUNCE) => break,
+                        res = rx.recv() => { if res.is_none() { return; } }
+                    }
+                }
+                // The watcher fires on local edits, which are exactly as much
+                // host traffic as a tick — same re-check as the interval arm.
+                if hpc_now(&target) { break; }
+                // Skip the pass while a checkout is rewriting the mirror; the writes
+                // that queued these watcher events are re-based by git_peer before
+                // resume, so dropping this pass loses nothing.
+                if paused.load(Ordering::SeqCst) { continue; }
+                reconcile_pass(Some(&app), &pool, &manifest, &target, &project_id).await;
+            }
+        }
+    }
+}
+
+/// Run exactly one byte-sync reconcile pass, synchronously, with no watcher, no
+/// interval, and no UI event. This is the same pass [`run_loop`] drives — the loop
+/// contributes only the *when*.
+///
+/// Exists for the live-SSH lockstep driver (`examples/lockstep_drv.rs`), which walks
+/// `docs/git_lockstep_case_matrix.md` against a real host: the byte-sync half of the
+/// BS+LS cases has to be the real engine, or the matrix proves nothing about the code
+/// that ships.
+pub async fn reconcile_once(
+    pool: &RemotePoolState,
+    manifest: &SyncManifestState,
+    target: &RemoteTarget,
+    project_id: &str,
+) {
+    reconcile_pass(None, pool, manifest, target, project_id).await;
+}
+
+/// Subtract the git-tracked set from the byte-sync candidates when lockstep owns them
+/// (#28p D1). A no-op when lockstep is off, so a project that never opted in keeps
+/// exactly today's behaviour — including its behaviour for files git happens to track.
+/// Pure.
+pub fn drop_tracked(
+    candidates: &mut BTreeSet<String>,
+    tracked: &HashSet<String>,
+    lockstep_enabled: bool,
+) {
+    if !lockstep_enabled || tracked.is_empty() {
+        return;
+    }
+    candidates.retain(|rel| !tracked.contains(rel));
+}
+
+/// One reconcile pass over the project's auto-sync paths. Bails gracefully if the
+/// pool is cold/dead. Reuses the `remote_sync` primitives throughout.
+///
+/// `app` is `None` when the pass is driven outside the app (see [`reconcile_once`]);
+/// it is used for nothing but the completion event.
+async fn reconcile_pass(
+    app: Option<&AppHandle>,
+    pool: &RemotePoolState,
+    manifest: &SyncManifestState,
+    target: &RemoteTarget,
+    project_id: &str,
+) {
+    // Bail if the connection is cold or the ssh child died (keepalive evicted it).
+    let Some(sftp) = pooled_sftp(pool, project_id).await else {
+        return;
+    };
+
+    // Snapshot the manifest and collect the auto markers under the lock.
+    let (snapshot, auto_dirs, auto_files): (Manifest, Vec<String>, Vec<String>) = {
+        let mut g = manifest.lock().await;
+        let m = ensure_loaded(&mut g, project_id);
+        let dirs = m
+            .iter()
+            .filter(|(_, e)| e.auto_sync && e.is_dir)
+            .map(|(k, _)| k.clone())
+            .collect();
+        let files = m
+            .iter()
+            .filter(|(_, e)| e.auto_sync && !e.is_dir)
+            .map(|(k, _)| k.clone())
+            .collect();
+        (m.clone(), dirs, files)
+    };
+    if auto_dirs.is_empty() && auto_files.is_empty() {
+        return;
+    }
+
+    // Candidate files = auto single-file entries ∪ host walk of each auto dir ∪
+    // mirror walk of each auto dir (so new files on EITHER side are picked up).
+    // An auto dir may be the project root (""), i.e. project-wide auto-sync-all,
+    // in which case the walks cover the whole tree.
+    let mut candidates: BTreeSet<String> = auto_files.into_iter().collect();
+    for d in &auto_dirs {
+        match remote_sync::walk_host_files(&sftp, &target.spec.remote_path, d).await {
+            Ok(files) => candidates.extend(files.into_iter().map(|f| f.rel)),
+            Err(_) => return, // connection dropped mid-walk → abandon this pass
+        }
+        if let Ok(local) = remote_sync::walk_mirror_files(project_id, d) {
+            candidates.extend(local);
+        }
+    }
+    // Drop paths carved out by a local OFF override (an `auto_off` on the file or a
+    // nearer directory marker): the reconcile only touches paths whose *effective*
+    // auto-sync is on, so a project-wide auto can still exclude individual subtrees.
+    candidates.retain(|rel| remote_sync::is_auto(&snapshot, rel));
+
+    // #28p D1: with git lockstep on, the tracked tree belongs to lockstep — it delivers
+    // those files as *commits*. Shipping them here as loose bytes first lands them on
+    // the peer untracked, which then blocks the very fast-forward that would have
+    // delivered them properly (git refuses to overwrite an untracked file even when it
+    // is byte-identical). Which of those two happened used to be decided by a debounce
+    // race between the two engines — nondeterministically wedging the project.
+    drop_tracked(
+        &mut candidates,
+        &crate::services::git_peer::tracked_paths(project_id),
+        crate::services::git_peer::load_state(project_id).enabled,
+    );
+
+    let mut pulled = 0usize;
+    let mut pushed = 0usize;
+    let mut skipped = 0usize;
+    for rel in candidates {
+        let host_abs = remote_sync::join_remote(&target.spec.remote_path, &rel);
+        // `Option`, distinguishing a gone host path (None) from an empty file —
+        // the same input `push_decision`/`divergence` expect (matches sync_push).
+        let host = sftp::metadata_on(&sftp, &host_abs).await.ok();
+        let local_path = mirror_local_path(project_id, &rel);
+        let local = std::fs::metadata(&local_path)
+            .ok()
+            .map(|m| remote_sync::local_meta(&m));
+        let entry = snapshot.get(&rel).cloned().unwrap_or_default();
+
+        match remote_sync::divergence(&entry, host, local) {
+            (false, false) => {} // green
+            (true, false) => {
+                // Host changed only → pull. `host` is Some here (divergence only
+                // flags the host side from a real stat).
+                if let Some((hsize, _)) = host {
+                    match remote_sync::pull_file(&sftp, &host_abs, hsize, &local_path).await {
+                        Ok((ls, lm)) => {
+                            let (hs, hm) = host.unwrap_or((hsize, None));
+                            let mut g = manifest.lock().await;
+                            let m = ensure_loaded(&mut g, project_id);
+                            remote_sync::record_pull(m, &rel, hs, hm, ls, lm);
+                            let _ = remote_sync::save_manifest(project_id, m);
+                            net_usage::record_files(project_id, 1, 0);
+                            pulled += 1;
+                        }
+                        Err(e) => eprintln!("auto-sync: pull skip '{rel}': {e}"),
+                    }
+                }
+            }
+            (false, true) => {
+                // Local changed only → push, but only if the host still matches the
+                // recorded base (never clobber a racing host change).
+                if remote_sync::push_decision(&entry, host) == PushDecision::Safe {
+                    match remote_sync::push_file_atomic(&sftp, &local_path, &host_abs).await {
+                        Ok((hs, hm)) => {
+                            let (ls, lm) =
+                                remote_sync::local_size_mtime(std::fs::metadata(&local_path).ok());
+                            let mut g = manifest.lock().await;
+                            let m = ensure_loaded(&mut g, project_id);
+                            remote_sync::record_push(m, &rel, hs, hm, ls, lm);
+                            let _ = remote_sync::save_manifest(project_id, m);
+                            net_usage::record_files(project_id, 0, 1);
+                            pushed += 1;
+                        }
+                        Err(e) => eprintln!("auto-sync: push skip '{rel}': {e}"),
+                    }
+                } else {
+                    skipped += 1; // host raced → treat as a conflict, leave for manual
+                }
+            }
+            (true, true) => skipped += 1, // AMBER/orange → never auto-synced
+        }
+    }
+
+    if pulled + pushed > 0 {
+        if let Some(app) = app {
+            let _ = app.emit(
+                "auto-sync",
+                AutoSyncEvent {
+                    project_id: project_id.to_string(),
+                    pulled,
+                    pushed,
+                    skipped_amber: skipped,
+                },
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn set(items: &[&str]) -> BTreeSet<String> {
+        items.iter().map(|s| s.to_string()).collect()
+    }
+    fn hset(items: &[&str]) -> HashSet<String> {
+        items.iter().map(|s| s.to_string()).collect()
+    }
+
+    #[test]
+    fn tracked_files_are_left_to_lockstep_when_it_is_on() {
+        // #28p D1: byte-sync must not ship a git-tracked file as loose bytes — landing
+        // it untracked on the peer is what blocks the fast-forward that would have
+        // delivered it as a commit.
+        let mut c = set(&["src/a.rs", "notes.md", "build/out.bin"]);
+        drop_tracked(&mut c, &hset(&["src/a.rs", "README.md"]), true);
+        assert_eq!(c, set(&["notes.md", "build/out.bin"]));
+    }
+
+    #[test]
+    fn lockstep_off_changes_nothing() {
+        // A project that never opted in keeps exactly today's behaviour, tracked files
+        // and all — this fix must not quietly stop syncing files for those projects.
+        let mut c = set(&["src/a.rs", "notes.md"]);
+        drop_tracked(&mut c, &hset(&["src/a.rs"]), false);
+        assert_eq!(c, set(&["src/a.rs", "notes.md"]));
+
+        // An empty tracked set (an unborn repo, or `git ls-files` failing) is likewise a
+        // no-op: degrade to the old behaviour rather than syncing nothing at all.
+        let mut c = set(&["src/a.rs"]);
+        drop_tracked(&mut c, &HashSet::new(), true);
+        assert_eq!(c, set(&["src/a.rs"]));
+    }
+}
diff --git a/src-tauri/src/services/terminal_service.rs b/src-tauri/src/services/terminal_service.rs
index 6af6f34..ac6b4b8 100644
--- a/src-tauri/src/services/terminal_service.rs
+++ b/src-tauri/src/services/terminal_service.rs
@@ -11,13 +11,19 @@ use crate::storage;
 /// `groups` is the opaque split/group layout tree (None clears it).
 /// `sessions` is the opaque list of open agent-session UUIDs: `Some([])` clears
 /// it, `Some(list)` replaces it, and `None` leaves the stored value untouched.
+///
+/// `allow_clear` is what makes an EMPTY `tabs` mean "the user closed every tab"
+/// rather than "the caller had nothing loaded". Only the frontend can tell those
+/// apart, and it only knows for a scope it actually hydrated — see the guard in
+/// `write_terminal_session`.
 pub fn save_tab_layout(
     local_file: &str,
     tabs: &[TabEntry],
     groups: Option<Value>,
     sessions: Option<Value>,
+    allow_clear: bool,
 ) -> Result<(), String> {
-    write_terminal_session(local_file, tabs, 0, groups, sessions)
+    write_terminal_session(local_file, tabs, 0, groups, sessions, allow_clear)
 }
 
 /// Save tab layout with the active tab index.
@@ -31,7 +37,10 @@ pub fn save_terminal_session(
 ) -> Result<(), String> {
     // The project-switch snapshot carries no session list; leave the persisted
     // UUIDs untouched (the active project's debounced save_tab_layout owns them).
-    write_terminal_session(local_file, tabs, active_tab_index, groups, None)
+    // It also never clears: a snapshot is a picture of what was in memory, and an
+    // empty one is far more likely to mean "this scope was never loaded" than
+    // "the user closed everything" — the debounced save owns that intent.
+    write_terminal_session(local_file, tabs, active_tab_index, groups, None, false)
 }
 
 fn write_terminal_session(
@@ -40,7 +49,27 @@ fn write_terminal_session(
     active_tab_index: usize,
     groups: Option<Value>,
     sessions: Option<Value>,
+    allow_clear: bool,
 ) -> Result<(), String> {
+    // An empty layout is DESTRUCTIVE — it drops `tab_layout`/`tab_groups` from
+    // project.json *and* overwrites the `.eldrun` mirror with an empty one, in a
+    // single call. The two are written from the same array, so the mirror is not a
+    // backup: one empty save takes both copies, and a persisted agent tab's
+    // `sessionId` is the only handle on its conversation.
+    //
+    // That is fine when the user really did close every tab, and catastrophic
+    // otherwise — and "otherwise" is reachable, which is how a live project lost four
+    // tabs on detach: the frontend's debounced autosave persists the tab store's
+    // CURRENT scope into the ACTIVE project's `local_file`, two values it tracks
+    // independently. Detach swaps `local_file` (state dir → promoted mirror) under
+    // a store whose scope has not caught up, the per-scope tab filter correctly
+    // refuses to write another project's tabs into this file, and what lands is an
+    // empty list that reads exactly like a deliberate close-all.
+    //
+    // So an empty layout only clears when the caller states it means one.
+    if tabs.is_empty() && !allow_clear {
+        return Ok(());
+    }
     let path = PathBuf::from(local_file);
     let mut project: crate::schema::project::Project =
         storage::read_json(&path).unwrap_or_default();
diff --git a/src-tauri/src/services/tmux_local.rs b/src-tauri/src/services/tmux_local.rs
new file mode 100644
index 0000000..2544723
--- /dev/null
+++ b/src-tauri/src/services/tmux_local.rs
@@ -0,0 +1,209 @@
+//! Persistent **local** (tmux) sessions (TODO #85 extension).
+//!
+//! The remote half of persistent sessions runs tmux on the SSH host; this runs it
+//! on the **local machine** so a local project's shell/script tab (a Python run, a
+//! long build) keeps going if Eldrun **crashes** — and reattaches on restart —
+//! instead of dying with the PTY. It works because the tmux **server** is a
+//! daemon: the PTY only holds a tmux *client*, so when Eldrun (and the client)
+//! goes away the session and its processes live on under the server, and a
+//! respawn's `tmux new-session -A` reattaches them.
+//!
+//! **Unix only.** There is no tmux on Windows, so every entry point here no-ops
+//! there (guarded by [`tmux_available`], which is `false` on Windows), leaving the
+//! tab to spawn exactly as before.
+//!
+//! Unlike the remote wrap (which emits a `$SHELL -c` *string* for ssh), the local
+//! wrap rewrites `PtyOptions.{cmd,args}` into a direct `tmux` **argv** — the PTY
+//! spawns `tmux` itself, and `cwd`/`env` set on the client are inherited by a
+//! freshly-created session.
+
+use crate::terminal::PtyOptions;
+
+/// Single-quote `s` for a POSIX shell (mirrors `ssh_exec::shell_quote`). Used only
+/// to fold a command tab's `cmd`+`args` into the single command string tmux hands
+/// to `sh -c`.
+fn shell_quote(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() + 2);
+    out.push('\'');
+    for ch in s.chars() {
+        if ch == '\'' {
+            out.push_str("'\\''");
+        } else {
+            out.push(ch);
+        }
+    }
+    out.push('\'');
+    out
+}
+
+/// Whether a usable `tmux` is on `PATH`. Cached after the first probe (the answer
+/// cannot change within a run). Always `false` on Windows, which is what makes
+/// every wrap here a no-op there.
+#[cfg(unix)]
+pub fn tmux_available() -> bool {
+    use std::sync::OnceLock;
+    static AVAILABLE: OnceLock<bool> = OnceLock::new();
+    *AVAILABLE.get_or_init(|| {
+        crate::paths::command_no_window("tmux")
+            .arg("-V")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+    })
+}
+
+#[cfg(not(unix))]
+pub fn tmux_available() -> bool {
+    false
+}
+
+/// Build the `tmux` argv (the value of `PtyOptions.args`, with `cmd` = `"tmux"`)
+/// that spawns-or-attaches the session named `session`. Pure + unit-testable.
+///
+/// `target_cmd` empty ⇒ a bare `new-session` whose command is tmux's default
+/// (the login shell) — the shell-tab / typed-command case (e.g. a Python run typed
+/// into the shell), where the shell **outlives** the command so the session
+/// survives its completion. `target_cmd` set (a command tab) ⇒ tmux runs
+/// `<cmd> <args>; exec "$SHELL" -l`, i.e. the command, then a login shell, so the
+/// session likewise persists after the command exits (reattach shows the result
+/// rather than re-running it — the resumable-command-tab guarantee).
+///
+/// `-A` = attach if it exists / create otherwise (one command that is both start
+/// and resume); `-D` = detach any other client (a stale one from before a
+/// crash/reload); `status off` / `mouse on` are chained as separate tmux commands
+/// after a literal `;` argv item (tmux splits its argv on a standalone `;`).
+pub fn local_tmux_args(session: &str, target_cmd: &str, target_args: &[String]) -> Vec<String> {
+    let mut args: Vec<String> = vec![
+        "new-session".into(),
+        "-A".into(),
+        "-D".into(),
+        "-s".into(),
+        session.to_string(),
+    ];
+    if !target_cmd.is_empty() {
+        // One positional arg = the command line tmux runs via `sh -c`. Keeping a
+        // login shell after it is what makes a finished run reattachable.
+        let mut line = shell_quote(target_cmd);
+        for a in target_args {
+            line.push(' ');
+            line.push_str(&shell_quote(a));
+        }
+        line.push_str("; exec \"${SHELL:-/bin/bash}\" -l");
+        args.push(line);
+    }
+    // Session options as trailing tmux commands (standalone ';' tokens split argv).
+    for tok in [";", "set", "-g", "status", "off", ";", "set", "-g", "mouse", "on"] {
+        args.push(tok.to_string());
+    }
+    args
+}
+
+/// `tmux kill-session -t <session>` argv, for the explicit-close / Sessions-view
+/// kill of a local persistent tab. `|| true` is unnecessary here (a missing
+/// session just exits non-zero, which the fire-and-forget caller ignores).
+pub fn local_tmux_kill_args(session: &str) -> Vec<String> {
+    vec!["kill-session".into(), "-t".into(), session.to_string()]
+}
+
+/// `tmux rename-session -t <old> <new>` argv.
+pub fn local_tmux_rename_args(old: &str, new: &str) -> Vec<String> {
+    vec![
+        "rename-session".into(),
+        "-t".into(),
+        old.to_string(),
+        new.to_string(),
+    ]
+}
+
+/// `tmux ls -F …` argv for listing local sessions (same format the remote path
+/// parses via `ssh_exec::parse_tmux_ls`).
+pub fn local_tmux_ls_args() -> Vec<String> {
+    vec![
+        "ls".into(),
+        "-F".into(),
+        "#{session_name}\t#{session_windows}\t#{session_created}\t#{session_attached}\t#{session_activity}\t#{pane_current_command}\t#{pane_current_path}".into(),
+    ]
+}
+
+/// Rewrite `opts` to spawn the tab inside a **local** tmux session when it carries
+/// a `tmux_session` name and tmux is available. No-op otherwise (no name, or no
+/// tmux — including all of Windows), leaving the tab to spawn exactly as before.
+///
+/// Only the resolved local command is rewritten; `cwd`/`env` are left for
+/// `build_command` to apply to the `tmux` client, so a freshly-created session
+/// inherits them. Callers must ensure this runs only for a **local** spawn (not an
+/// `ssh`/`docker`-wrapped one) — see `commands::terminal::pty_spawn`.
+pub fn wrap_pty_options_local(opts: &mut PtyOptions) {
+    if !tmux_available() {
+        return;
+    }
+    let Some(session) = opts.tmux_session.clone() else {
+        return;
+    };
+    let args = local_tmux_args(&session, &opts.cmd, &opts.args);
+    opts.cmd = "tmux".to_string();
+    opts.args = args;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shell_tab_uses_default_login_shell_and_options() {
+        // No target command → bare new-session (tmux's default login shell) so the
+        // shell survives a typed command's completion; options chained after `;`.
+        let args = local_tmux_args("eldrun-abc", "", &[]);
+        assert_eq!(
+            args,
+            vec![
+                "new-session", "-A", "-D", "-s", "eldrun-abc",
+                ";", "set", "-g", "status", "off",
+                ";", "set", "-g", "mouse", "on",
+            ]
+        );
+    }
+
+    #[test]
+    fn command_tab_runs_command_then_keeps_a_shell() {
+        // A command tab keeps a login shell AFTER the command so the finished run
+        // reattaches (resumable-command-tab guarantee) instead of re-running.
+        let args = local_tmux_args("eldrun-x", "python", &["train.py".into()]);
+        assert_eq!(args[0], "new-session");
+        assert!(args.iter().any(|a| a == "eldrun-x"));
+        let target = &args[5];
+        assert_eq!(target, "'python' 'train.py'; exec \"${SHELL:-/bin/bash}\" -l");
+        // Options still trail.
+        assert!(args.windows(2).any(|w| w == [";".to_string(), "set".to_string()]));
+    }
+
+    #[test]
+    fn kill_and_rename_argv() {
+        assert_eq!(local_tmux_kill_args("s"), vec!["kill-session", "-t", "s"]);
+        assert_eq!(
+            local_tmux_rename_args("old", "new"),
+            vec!["rename-session", "-t", "old", "new"]
+        );
+    }
+
+    #[test]
+    fn wrap_no_session_is_noop() {
+        let mut opts = PtyOptions {
+            id: "t".into(),
+            cmd: "bash".into(),
+            args: vec![],
+            env: Default::default(),
+            cwd: "/p".into(),
+            cols: 80,
+            rows: 24,
+            local_only: false,
+            sandbox: false,
+            project_id: Some("p".into()),
+            remote_host_id: None,
+            tmux_session: None,
+            tmux_attach: None,
+        };
+        wrap_pty_options_local(&mut opts);
+        assert_eq!(opts.cmd, "bash");
+    }
+}
diff --git a/src-tauri/src/services/usage_stats.rs b/src-tauri/src/services/usage_stats.rs
new file mode 100644
index 0000000..4c66146
--- /dev/null
+++ b/src-tauri/src/services/usage_stats.rs
@@ -0,0 +1,586 @@
+//! File-churn watcher behind the daily recap's "created / modified / deleted".
+//!
+//! A recursive `notify` watcher on the active project's root. It is deliberately
+//! separate from `commands::fs_watch`, which watches exactly one directory
+//! non-recursively and exists to refresh the file tree — it would see nothing of
+//! what an agent does three directories down.
+//!
+//! Three things make the raw event stream usable as a statistic:
+//!
+//! 1. **Ignore rules** ([`is_ignored`]) — `.git`, `node_modules`, `target`, build
+//!    output and editor scratch files. Without them a single `cargo build` would
+//!    report tens of thousands of "modified files".
+//! 2. **A per-path cooldown** ([`Debouncer`]) — one editor save fires a burst of
+//!    raw events; a new file fires Create *and* Modify. The cooldown collapses
+//!    each burst to the one event that characterises it.
+//! 3. **Batched flushes** — counters accumulate in memory and reach disk every
+//!    [`FLUSH_INTERVAL_SECS`], so a `git checkout` costs one file rewrite.
+//!
+//! **Local filesystems only.** inotify cannot see an SFTP tree, so a remote
+//! project records file stats only through its local mirror (an ordinary local
+//! path, watched normally). A remote project with no mirror reports nothing —
+//! which the recap states, rather than showing a misleading zero.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use notify::{recommended_watcher, EventKind, RecursiveMode, Watcher};
+
+use crate::schema::usage_stats::{metric, Counters};
+
+/// How long after counting an event for a path we ignore further events for it.
+///
+/// Long enough to swallow the burst from one save (and the Modify that trails a
+/// Create), short enough that genuinely repeated edits — an agent rewriting the
+/// same file through a task — still register separately.
+const COOLDOWN: Duration = Duration::from_millis(1500);
+
+/// How often the in-memory counters are folded into `usage_stats.json`.
+const FLUSH_INTERVAL_SECS: u64 = 30;
+
+/// Directory names whose entire subtree is ignored. These churn constantly under
+/// builds and dependency installs, and none of it is work the user did.
+const IGNORED_DIRS: &[&str] = &[
+    ".git",
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    ".next",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".cargo",
+    ".gradle",
+    ".idea",
+    "vendor",
+];
+
+/// Suffixes of editor scratch/lock files — churn that represents no real edit.
+const IGNORED_SUFFIXES: &[&str] = &[".swp", ".swx", ".tmp", ".lock", "~"];
+
+/// Whether a single directory NAME names an ignored subtree.
+///
+/// Exact matching against [`IGNORED_DIRS`] is not enough for virtualenvs, which
+/// are named by their owner rather than by convention: `venv` and `.venv` are in
+/// the list, but a second environment beside them is routinely `venv-rocm`,
+/// `venv313`, `.venv-cuda`… Those are thousands of directories each, and missing
+/// one does not merely cost watch churn — every write inside it is counted as
+/// work the user did, so the recap's file-churn figure reports a `pip install`
+/// as a day's editing. Hence the venv rule is a *shape* (a `venv`/`.venv` stem,
+/// or a `-venv`/`_venv` suffix), not a fixed list.
+pub fn is_ignored_dir_name(name: &str) -> bool {
+    if IGNORED_DIRS.contains(&name) {
+        return true;
+    }
+    let stem = name.strip_prefix('.').unwrap_or(name);
+    stem.starts_with("venv") || name.ends_with("-venv") || name.ends_with("_venv")
+}
+
+/// Whether a path should never contribute to file-churn counts.
+///
+/// Pure, so every rule below is unit-tested without touching a filesystem.
+pub fn is_ignored(path: &Path) -> bool {
+    for component in path.components() {
+        let Some(name) = component.as_os_str().to_str() else {
+            continue;
+        };
+        if is_ignored_dir_name(name) {
+            return true;
+        }
+    }
+    let Some(file_name) = path.file_name().and_then(|n| n.to_str()) else {
+        return false;
+    };
+    if IGNORED_SUFFIXES.iter().any(|s| file_name.ends_with(s)) {
+        return true;
+    }
+    // Emacs lock files (`.#foo`) and vim's atomic-write probe file (`4913`).
+    file_name.starts_with(".#") || file_name == "4913"
+}
+
+/// Map a raw `notify` event to the metric it should count, or `None` when it is
+/// not a change worth counting (access, metadata-only, ignored path, …).
+///
+/// Pure — the watcher's whole classification is testable without a watcher.
+pub fn classify_fs_event(kind: &EventKind, path: &Path) -> Option<&'static str> {
+    if is_ignored(path) {
+        return None;
+    }
+    match kind {
+        EventKind::Create(_) => Some(metric::FILE_CREATED),
+        EventKind::Remove(_) => Some(metric::FILE_DELETED),
+        // A rename shows up as Modify(Name); count it as a modification rather
+        // than inventing a create+delete pair for what the user sees as one act.
+        EventKind::Modify(_) => Some(metric::FILE_MODIFIED),
+        // Access / Any / Other: opening or stat-ing a file is not churn.
+        _ => None,
+    }
+}
+
+/// Per-path cooldown collapsing a burst of raw events into one counted event.
+///
+/// A save fires several Modify events; a new file fires Create then Modify. After
+/// counting anything for a path we ignore that path for [`COOLDOWN`] — with one
+/// exception: a **delete always counts** and clears the cooldown, so a file
+/// created and immediately removed reports both, and a delete right after an edit
+/// is never swallowed.
+#[derive(Default)]
+pub struct Debouncer {
+    last: HashMap<PathBuf, Instant>,
+}
+
+impl Debouncer {
+    /// Whether this (path, metric) should be counted now. Takes `now` explicitly
+    /// so the cooldown is testable without sleeping.
+    pub fn should_count(&mut self, path: &Path, key: &str, now: Instant) -> bool {
+        if key == metric::FILE_DELETED {
+            // The file is gone: no further events can arrive for it, and any
+            // cooldown left over from its creation/edits must not hide its death.
+            self.last.remove(path);
+            return true;
+        }
+        if let Some(&seen) = self.last.get(path) {
+            if now.duration_since(seen) < COOLDOWN {
+                return false;
+            }
+        }
+        self.last.insert(path.to_path_buf(), now);
+        true
+    }
+
+    /// Drop cooldown entries older than the window. Called on each flush so the
+    /// map cannot grow without bound over a long session (a `git checkout` can
+    /// touch thousands of distinct paths).
+    pub fn prune(&mut self, now: Instant) {
+        self.last
+            .retain(|_, seen| now.duration_since(*seen) < COOLDOWN);
+    }
+}
+
+/// Counters observed since the last flush, keyed by project id.
+type Pending = Arc<Mutex<HashMap<String, Counters>>>;
+
+/// The live watcher (dropping it unwatches) plus what it is watching. `None` when
+/// no local project is active.
+struct Active {
+    project_id: String,
+    root: PathBuf,
+    _watcher: notify::RecommendedWatcher,
+}
+
+/// Managed state: the pending counters and the single active watcher.
+#[derive(Clone)]
+pub struct UsageWatchState {
+    pending: Pending,
+    active: Arc<Mutex<Option<Active>>>,
+}
+
+pub fn new_state() -> UsageWatchState {
+    UsageWatchState {
+        pending: Arc::new(Mutex::new(HashMap::new())),
+        active: Arc::new(Mutex::new(None)),
+    }
+}
+
+impl UsageWatchState {
+    /// Fold one counted event into the pending batch.
+    fn bump(&self, project_id: &str, key: &str) {
+        let mut pending = self.pending.lock().unwrap();
+        let counters = pending.entry(project_id.to_string()).or_default();
+        let slot = counters.entry(key.to_string()).or_insert(0);
+        *slot = slot.saturating_add(1);
+    }
+
+    /// Take everything accumulated so far, leaving the batch empty.
+    fn drain(&self) -> HashMap<String, Counters> {
+        std::mem::take(&mut *self.pending.lock().unwrap())
+    }
+}
+
+/// The directory whose churn should be attributed to `project_id`, or `None`
+/// when there is nothing watchable.
+///
+/// A **remote** project's tree lives on the host and inotify cannot see it, so
+/// what gets watched is its **local mirror** — an ordinary local directory — and
+/// a remote project with no mirror yet is simply not watched. A **local**
+/// project is watched at its own directory.
+///
+/// Resolved here rather than passed in by the frontend: which directory actually
+/// holds a project's files is a backend fact (the mirror path is derived, not
+/// stored on the project), and the frontend has no business knowing it.
+pub fn watch_root_for(project_id: &str) -> Option<PathBuf> {
+    if crate::services::remote::remote_target_for(project_id).is_some() {
+        let mirror = crate::services::remote_sync::mirror_dir(project_id);
+        return mirror.is_dir().then_some(mirror);
+    }
+    let dir = crate::services::remote::project_directory(project_id)?;
+    let path = PathBuf::from(dir);
+    path.is_dir().then_some(path)
+}
+
+/// Attach the watch to `root`'s tree, descending it ourselves so that an ignored
+/// subtree is never watched in the first place.
+///
+/// `RecursiveMode::Recursive` on the root would be one line, and was — but it asks
+/// the kernel for one inotify watch per directory *including* the ones
+/// [`is_ignored`] exists to throw away. On a real project that is not a rounding
+/// error: a tree with two virtualenvs measured 8017 watches, of which ~85% were
+/// venv internals whose every event was queued, delivered, woken a thread for, and
+/// then discarded. Pruning here makes the kernel stop reporting what we were only
+/// going to drop.
+///
+/// The trade-off is deliberate: a directory created *after* this pass is not
+/// watched (its own creation is still seen, since its parent is). Re-watching
+/// happens on the next project switch, and the payload is a usage counter — a
+/// newly-created folder's churn going uncounted until then is worth the ~98%
+/// reduction in watch load.
+/// `excluded` additionally drops the subtrees the user excluded by hand (the file
+/// tree's "Exclude from scans"), so one list governs every scan rather than the
+/// size walk and the churn watcher each having their own notion of "skip this".
+fn watch_pruned(
+    watcher: &mut notify::RecommendedWatcher,
+    root: &Path,
+    excluded: &std::collections::HashSet<String>,
+) {
+    // (dir, project-relative path) — the rel is what the exclusion list speaks.
+    let mut stack = vec![(root.to_path_buf(), String::new())];
+    while let Some((dir, rel)) = stack.pop() {
+        // NonRecursive: every directory gets its own watch, so files anywhere in
+        // the surviving tree are still reported — only the ignored subtrees are
+        // absent, which a recursive watch could not express.
+        if watcher.watch(&dir, RecursiveMode::NonRecursive).is_err() {
+            continue; // vanished mid-walk, or the watch limit is exhausted
+        }
+        let Ok(entries) = std::fs::read_dir(&dir) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            // Never follow a symlink: a link pointing up the tree would loop, and
+            // one pointing out of the project would watch someone else's files.
+            if !entry.file_type().is_ok_and(|t| t.is_dir()) {
+                continue;
+            }
+            let name = entry.file_name();
+            let Some(name) = name.to_str() else { continue };
+            if is_ignored_dir_name(name) {
+                continue;
+            }
+            let child_rel = if rel.is_empty() { name.to_string() } else { format!("{rel}/{name}") };
+            if excluded.contains(&child_rel) {
+                continue;
+            }
+            stack.push((entry.path(), child_rel));
+        }
+    }
+}
+
+/// The user's own scan-exclusion list for `project_id` — `scan_excluded_paths` in
+/// the project's `project.json`, the same list the file tree writes and the size
+/// walk reads (`commands::fs::excluded_rel_set`).
+///
+/// Read from the project's *state* directory, which is where `project.json` lives
+/// for a local and a remote project alike — the remote one's watch root is its
+/// mirror, a different path entirely, so resolving the list from the watch root
+/// would find nothing.
+fn user_excluded_dirs(project_id: &str) -> std::collections::HashSet<String> {
+    let Some(dir) = crate::services::remote::project_directory(project_id) else {
+        return Default::default();
+    };
+    let Ok(raw) = std::fs::read_to_string(PathBuf::from(dir).join("project.json")) else {
+        return Default::default();
+    };
+    let Ok(json) = serde_json::from_str::<serde_json::Value>(&raw) else {
+        return Default::default();
+    };
+    let list: Vec<String> = json
+        .get("scan_excluded_paths")
+        .and_then(|v| v.as_array())
+        .map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_string)).collect())
+        .unwrap_or_default();
+    crate::commands::fs::excluded_rel_set(&list)
+}
+
+/// Watch `project_id`'s tree (recursively), replacing any previous watch. An
+/// empty id — or a project with nothing watchable — just stops watching.
+///
+/// One watcher at a time: the recap counts what you are working on, and watching
+/// every project a user has ever opened would mean an inotify tree per project.
+pub fn watch_project(state: &UsageWatchState, project_id: &str) -> Result<(), String> {
+    let mut guard = state.active.lock().unwrap();
+
+    let Some(root) = (!project_id.is_empty())
+        .then(|| watch_root_for(project_id))
+        .flatten()
+    else {
+        *guard = None; // dropping the watcher unwatches
+        return Ok(());
+    };
+
+    let canonical = std::fs::canonicalize(&root).map_err(|e| e.to_string())?;
+    if let Some(active) = guard.as_ref() {
+        if active.root == canonical && active.project_id == project_id {
+            return Ok(()); // already watching exactly this
+        }
+    }
+
+    let owner = project_id.to_string();
+    let state_for_cb = state.clone();
+    let mut debouncer = Debouncer::default();
+
+    let mut watcher = recommended_watcher(move |res: notify::Result<notify::Event>| {
+        let Ok(event) = res else { return };
+        let now = Instant::now();
+        for path in &event.paths {
+            let Some(key) = classify_fs_event(&event.kind, path) else {
+                continue;
+            };
+            if debouncer.should_count(path, key, now) {
+                state_for_cb.bump(&owner, key);
+            }
+        }
+        debouncer.prune(now);
+    })
+    .map_err(|e| e.to_string())?;
+
+    watch_pruned(&mut watcher, &canonical, &user_excluded_dirs(project_id));
+
+    // Replacing the stored watcher drops the previous one, unwatching it.
+    *guard = Some(Active {
+        project_id: project_id.to_string(),
+        root: canonical,
+        _watcher: watcher,
+    });
+    Ok(())
+}
+
+/// Start the periodic flush of watched churn into `usage_stats.json`. One
+/// detached task for the life of the process.
+pub fn start(state: UsageWatchState) {
+    tauri::async_runtime::spawn(async move {
+        loop {
+            tokio::time::sleep(Duration::from_secs(FLUSH_INTERVAL_SECS)).await;
+            let batch = state.drain();
+            if batch.is_empty() {
+                continue;
+            }
+            // The store is a read-modify-write of a JSON file: keep it off the
+            // async runtime's worker.
+            let _ = tokio::task::spawn_blocking(move || {
+                for (project_id, counters) in batch {
+                    crate::schema::usage_stats::record(&project_id, &counters);
+                }
+            })
+            .await;
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use notify::event::{CreateKind, DataChange, ModifyKind, RemoveKind};
+
+    fn p(s: &str) -> PathBuf {
+        PathBuf::from(s)
+    }
+
+    // ── is_ignored ─────────────────────────────────────────────────────────
+
+    #[test]
+    fn ordinary_source_files_are_not_ignored() {
+        assert!(!is_ignored(&p("/home/me/proj/src/lib.rs")));
+        assert!(!is_ignored(&p("/home/me/proj/README.md")));
+        // A dotted directory that is NOT in the list must still count — .github
+        // workflows are real work.
+        assert!(!is_ignored(&p("/home/me/proj/.github/workflows/ci.yml")));
+    }
+
+    #[test]
+    fn build_and_vcs_subtrees_are_ignored() {
+        // Without these one `cargo build` would report tens of thousands of
+        // "modified files" and swamp every real edit.
+        assert!(is_ignored(&p("/home/me/proj/.git/index")));
+        assert!(is_ignored(&p("/home/me/proj/target/debug/build/x.o")));
+        assert!(is_ignored(&p("/home/me/proj/node_modules/react/index.js")));
+        assert!(is_ignored(&p("/home/me/proj/dist/bundle.js")));
+        assert!(is_ignored(&p("/home/me/proj/__pycache__/mod.pyc")));
+    }
+
+    #[test]
+    fn ignored_dir_matches_at_any_depth() {
+        assert!(is_ignored(&p("/a/b/c/node_modules/d/e/f.js")));
+        assert!(is_ignored(&p("/a/node_modules/b/node_modules/c.js")));
+    }
+
+    #[test]
+    fn virtualenvs_are_ignored_by_shape_not_by_exact_name() {
+        // A venv is named by its owner, so an exact-name list only ever catches the
+        // first one. A measured project carried `venv` AND `venv-rocm` side by side:
+        // the second slipped through, and every `pip install` inside it was counted
+        // as the user's own file churn.
+        assert!(is_ignored(&p("/home/me/proj/venv/lib/python3.12/site.py")));
+        assert!(is_ignored(&p("/home/me/proj/venv-rocm/lib/python3.12/site.py")));
+        assert!(is_ignored(&p("/home/me/proj/.venv-cuda/bin/python")));
+        assert!(is_ignored(&p("/home/me/proj/venv313/bin/python")));
+        assert!(is_ignored(&p("/home/me/proj/project_venv/bin/python")));
+        assert!(is_ignored(&p("/home/me/proj/api-venv/bin/python")));
+        // …but the shape must not swallow ordinary source directories that merely
+        // start with the same letters.
+        assert!(!is_ignored(&p("/home/me/proj/vendored_ui/main.ts")));
+        assert!(!is_ignored(&p("/home/me/proj/environments/prod.yaml")));
+        assert!(!is_ignored(&p("/home/me/proj/ven/notes.md")));
+    }
+
+    #[test]
+    fn a_file_merely_named_like_an_ignored_dir_is_not_ignored() {
+        // "target" as a *file* is source, not a build directory.
+        assert!(!is_ignored(&p("/home/me/proj/src/target.rs")));
+        assert!(!is_ignored(&p("/home/me/proj/build.rs")));
+    }
+
+    #[test]
+    fn editor_scratch_files_are_ignored() {
+        assert!(is_ignored(&p("/proj/.lib.rs.swp")));
+        assert!(is_ignored(&p("/proj/lib.rs~")));
+        assert!(is_ignored(&p("/proj/.#lib.rs")));
+        assert!(is_ignored(&p("/proj/4913"))); // vim's atomic-write probe
+        assert!(is_ignored(&p("/proj/Cargo.lock")));
+    }
+
+    // ── classify_fs_event ──────────────────────────────────────────────────
+
+    #[test]
+    fn create_modify_remove_map_to_their_metrics() {
+        let path = p("/proj/src/lib.rs");
+        assert_eq!(
+            classify_fs_event(&EventKind::Create(CreateKind::File), &path),
+            Some(metric::FILE_CREATED)
+        );
+        assert_eq!(
+            classify_fs_event(&EventKind::Modify(ModifyKind::Data(DataChange::Content)), &path),
+            Some(metric::FILE_MODIFIED)
+        );
+        assert_eq!(
+            classify_fs_event(&EventKind::Remove(RemoveKind::File), &path),
+            Some(metric::FILE_DELETED)
+        );
+    }
+
+    #[test]
+    fn access_events_are_not_churn() {
+        // Reading a file is not work done to it — an agent grepping the tree must
+        // not read as thousands of modifications.
+        let path = p("/proj/src/lib.rs");
+        assert_eq!(
+            classify_fs_event(&EventKind::Access(notify::event::AccessKind::Read), &path),
+            None
+        );
+    }
+
+    #[test]
+    fn events_on_ignored_paths_classify_to_nothing() {
+        assert_eq!(
+            classify_fs_event(
+                &EventKind::Modify(ModifyKind::Data(DataChange::Content)),
+                &p("/proj/target/debug/x.o")
+            ),
+            None
+        );
+    }
+
+    // ── Debouncer ──────────────────────────────────────────────────────────
+
+    #[test]
+    fn a_burst_of_modifies_on_one_path_counts_once() {
+        let mut d = Debouncer::default();
+        let path = p("/proj/a.rs");
+        let t0 = Instant::now();
+        assert!(d.should_count(&path, metric::FILE_MODIFIED, t0));
+        // One editor save fires several raw Modify events back to back.
+        assert!(!d.should_count(&path, metric::FILE_MODIFIED, t0 + Duration::from_millis(5)));
+        assert!(!d.should_count(&path, metric::FILE_MODIFIED, t0 + Duration::from_millis(300)));
+    }
+
+    #[test]
+    fn a_new_file_counts_as_created_not_created_plus_modified() {
+        let mut d = Debouncer::default();
+        let path = p("/proj/new.rs");
+        let t0 = Instant::now();
+        assert!(d.should_count(&path, metric::FILE_CREATED, t0));
+        // Create is immediately followed by the Modify that writes the content.
+        assert!(!d.should_count(&path, metric::FILE_MODIFIED, t0 + Duration::from_millis(10)));
+    }
+
+    #[test]
+    fn edits_further_apart_than_the_cooldown_count_separately() {
+        let mut d = Debouncer::default();
+        let path = p("/proj/a.rs");
+        let t0 = Instant::now();
+        assert!(d.should_count(&path, metric::FILE_MODIFIED, t0));
+        assert!(d.should_count(&path, metric::FILE_MODIFIED, t0 + COOLDOWN));
+    }
+
+    #[test]
+    fn a_delete_always_counts_even_inside_the_cooldown() {
+        // Otherwise a file edited and then removed would report only the edit.
+        let mut d = Debouncer::default();
+        let path = p("/proj/a.rs");
+        let t0 = Instant::now();
+        assert!(d.should_count(&path, metric::FILE_MODIFIED, t0));
+        assert!(d.should_count(&path, metric::FILE_DELETED, t0 + Duration::from_millis(10)));
+    }
+
+    #[test]
+    fn a_delete_clears_the_cooldown_so_a_recreate_counts() {
+        let mut d = Debouncer::default();
+        let path = p("/proj/a.rs");
+        let t0 = Instant::now();
+        assert!(d.should_count(&path, metric::FILE_CREATED, t0));
+        assert!(d.should_count(&path, metric::FILE_DELETED, t0 + Duration::from_millis(10)));
+        assert!(d.should_count(&path, metric::FILE_CREATED, t0 + Duration::from_millis(20)));
+    }
+
+    #[test]
+    fn distinct_paths_do_not_share_a_cooldown() {
+        let mut d = Debouncer::default();
+        let t0 = Instant::now();
+        assert!(d.should_count(&p("/proj/a.rs"), metric::FILE_MODIFIED, t0));
+        assert!(d.should_count(&p("/proj/b.rs"), metric::FILE_MODIFIED, t0));
+    }
+
+    #[test]
+    fn prune_drops_expired_entries_so_the_map_stays_bounded() {
+        let mut d = Debouncer::default();
+        let t0 = Instant::now();
+        for i in 0..100 {
+            d.should_count(&p(&format!("/proj/f{i}.rs")), metric::FILE_MODIFIED, t0);
+        }
+        assert_eq!(d.last.len(), 100);
+        d.prune(t0 + COOLDOWN);
+        assert!(d.last.is_empty(), "expired cooldowns must not accumulate");
+    }
+
+    // ── pending accumulator ────────────────────────────────────────────────
+
+    #[test]
+    fn bump_accumulates_and_drain_empties() {
+        let state = new_state();
+        state.bump("p1", metric::FILE_MODIFIED);
+        state.bump("p1", metric::FILE_MODIFIED);
+        state.bump("p1", metric::FILE_CREATED);
+        state.bump("p2", metric::FILE_DELETED);
+
+        let batch = state.drain();
+        assert_eq!(batch["p1"][metric::FILE_MODIFIED], 2);
+        assert_eq!(batch["p1"][metric::FILE_CREATED], 1);
+        assert_eq!(batch["p2"][metric::FILE_DELETED], 1);
+
+        // A drained batch must not be re-counted on the next flush.
+        assert!(state.drain().is_empty());
+    }
+}
diff --git a/src-tauri/src/services/window_service.rs b/src-tauri/src/services/window_service.rs
index f56f6ac..26fd7fa 100644
--- a/src-tauri/src/services/window_service.rs
+++ b/src-tauri/src/services/window_service.rs
@@ -9,6 +9,24 @@ use crate::schema::session::WindowSession;
 use crate::services::terminal_service::eldrun_sessions_dir;
 use crate::storage;
 
+/// Physical monitor rects as reported by a live window (#42), for validating a
+/// detached popout's restore geometry on switch-back. Mirrors the mapping
+/// `lib.rs` uses at startup for the main window.
+pub fn monitor_rects(
+    win: &tauri::WebviewWindow,
+) -> Vec<crate::services::window_state::MonitorRect> {
+    win.available_monitors()
+        .unwrap_or_default()
+        .iter()
+        .map(|m| crate::services::window_state::MonitorRect {
+            x: m.position().x,
+            y: m.position().y,
+            w: m.size().width,
+            h: m.size().height,
+        })
+        .collect()
+}
+
 pub fn hide_windows(backend: &dyn WorkspaceBackend, window_ids: &[u64]) {
     for &wid in window_ids {
         if let Err(e) = backend.hide_window(wid) {
@@ -93,6 +111,42 @@ pub fn load_window_session(local_file: &str) -> WindowSession {
     WindowSession::default()
 }
 
+/// Back-populate `window_id` for project-owned windows whose id was never
+/// resolved at launch time. For each window matching `project_id` that is
+/// project-owned and currently has no `window_id`, call `resolve(pid)` and store
+/// the result. Used on Windows just before the project-switch hide so a
+/// launch-time miss (the visible top-level belonging to a child of the spawned
+/// pid, or a cold-start race) is no longer permanent — the resolved id then
+/// flows through the unchanged id-based hide AND switch-back show paths.
+///
+/// Pure over its inputs (the resolver is injected), so it is unit-tested with a
+/// fake resolver on any OS. Only the `None`-id case is touched, so windows that
+/// already resolved their id are left exactly as-is.
+///
+/// Detached subwindows (#42) are deliberately EXCLUDED even though they are
+/// project-owned: they carry Eldrun's OWN pid (subwindow.rs), so resolving by
+/// pid here could match an arbitrary Eldrun-owned top-level (the main window or
+/// another detached window) and back-populate the wrong HWND. They resolve their
+/// own id by Tauri label and park via the separate `hide()`/`show()` path
+/// (project_runtime steps 5b/8b), so they never need — and must not undergo —
+/// pid-based re-resolution. This keeps the never-touch-the-wrong-Eldrun-window
+/// invariant structural rather than reliant on label resolution always succeeding.
+pub fn resolve_missing_window_ids(
+    windows: &mut HashMap<String, TrackedWindow>,
+    project_id: Option<&str>,
+    resolve: impl Fn(u32) -> Option<u64>,
+) {
+    for w in windows.values_mut() {
+        if w.project_id.as_deref() == project_id
+            && is_project_owned(&w.origin)
+            && w.origin != ORIGIN_DETACHED_SUBWINDOW
+            && w.window_id.is_none()
+        {
+            w.window_id = resolve(w.pid);
+        }
+    }
+}
+
 fn is_project_owned(origin: &str) -> bool {
     matches!(
         origin,
@@ -175,6 +229,65 @@ mod tests {
         assert_eq!(ids, vec!["detached-p1-g3".to_string()]);
     }
 
+    #[test]
+    fn resolve_missing_window_ids_back_populates_only_unresolved_project_owned() {
+        let mut wins = registry(vec![
+            tracked("a", Some("p1"), ORIGIN_RIGHT_FILE_TREE, None), // pid 10
+            tracked("b", Some("p1"), ORIGIN_RIGHT_FILE_TREE, Some(5)), // pid 11
+            tracked("c", Some("p1"), ORIGIN_GLOBAL_APP, None),     // pid 12
+            tracked("d", Some("p2"), ORIGIN_RIGHT_FILE_TREE, None), // pid 13
+        ]);
+        // Give each a distinct pid so the fake resolver can be asserted per-window.
+        wins.get_mut("a").unwrap().pid = 10;
+        wins.get_mut("b").unwrap().pid = 11;
+        wins.get_mut("c").unwrap().pid = 12;
+        wins.get_mut("d").unwrap().pid = 13;
+
+        resolve_missing_window_ids(&mut wins, Some("p1"), |pid| Some(pid as u64 * 100));
+
+        // (a) unresolved + project-owned + this project → back-populated.
+        assert_eq!(wins["a"].window_id, Some(1000));
+        // (b) already resolved → left untouched (not overwritten).
+        assert_eq!(wins["b"].window_id, Some(5));
+        // (c) global app is not project-owned → never resolved.
+        assert_eq!(wins["c"].window_id, None);
+        // (d) different project → out of scope.
+        assert_eq!(wins["d"].window_id, None);
+    }
+
+    #[test]
+    fn resolve_missing_window_ids_leaves_none_when_resolver_fails() {
+        let mut wins = registry(vec![tracked(
+            "a",
+            Some("p1"),
+            ORIGIN_RIGHT_FILE_TREE,
+            None,
+        )]);
+        // A window the OS could not map (e.g. opener::open pid=0) stays unparked.
+        resolve_missing_window_ids(&mut wins, Some("p1"), |_pid| None);
+        assert_eq!(wins["a"].window_id, None);
+    }
+
+    #[test]
+    fn resolve_missing_window_ids_never_touches_detached_subwindows() {
+        // Detached subwindows carry Eldrun's OWN pid, so pid-based resolution
+        // could match an arbitrary Eldrun top-level. They must be excluded from
+        // re-resolution even though they are project-owned (they park via the
+        // Tauri label path instead). A resolver that would resolve anything must
+        // still leave a None-id detached window untouched.
+        let mut wins = registry(vec![tracked(
+            "detached-p1-g1",
+            Some("p1"),
+            ORIGIN_DETACHED_SUBWINDOW,
+            None,
+        )]);
+        resolve_missing_window_ids(&mut wins, Some("p1"), |pid| Some(pid as u64 * 100));
+        assert_eq!(
+            wins["detached-p1-g1"].window_id, None,
+            "a detached subwindow must never be pid-resolved at hide time"
+        );
+    }
+
     #[test]
     fn detached_labels_select_only_this_projects_detached_windows() {
         // #42: the Wayland/null fallback hides/shows detached windows by Tauri
diff --git a/src-tauri/src/services/window_state.rs b/src-tauri/src/services/window_state.rs
new file mode 100644
index 0000000..9969eb3
--- /dev/null
+++ b/src-tauri/src/services/window_state.rs
@@ -0,0 +1,340 @@
+//! Startup geometry for the MAIN window: decide where to reopen it from the
+//! rect saved on the last run (`settings.window_state`).
+//!
+//! Pure and `AppHandle`-free so every rule below is unit-tested on any OS; the
+//! Tauri calls that consume the result live in `lib.rs`'s `setup`.
+//!
+//! The job is *not* "apply the saved rect". It is "apply the saved rect only if a
+//! currently-connected monitor can still host it". A user who saved Eldrun on an
+//! external display and then undocked would otherwise get a window mapped at
+//! x=2400 on a laptop whose only screen ends at 1920 — off-screen, unreachable,
+//! and indistinguishable from "Eldrun didn't start". Whenever we can't place the
+//! rect confidently we return `None`, which means "leave the window exactly as
+//! `tauri.conf.json` configured it" (maximized, WM's choice of monitor) — i.e. we
+//! degrade to today's behaviour rather than to a broken one.
+//!
+//! All coordinates are PHYSICAL desktop pixels (see `schema::settings::WindowState`).
+
+use crate::schema::settings::WindowState;
+
+/// One connected monitor's position and size in physical desktop px, as reported
+/// by Tauri's `available_monitors()`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct MonitorRect {
+    pub x: i32,
+    pub y: i32,
+    pub w: u32,
+    pub h: u32,
+}
+
+/// How much of the saved window must still land on a real monitor for us to trust
+/// it. Sized to be a grabbable strip of title bar — enough that the user can
+/// always drag the window back into view. Below this we discard the saved rect
+/// entirely rather than place a window the user can't reach.
+const MIN_VISIBLE_W: i64 = 200;
+const MIN_VISIBLE_H: i64 = 80;
+
+/// Floor for a restored window, matching `minWidth`/`minHeight` in
+/// `tauri.conf.json`. A corrupt or hand-edited `settings.json` can't shrink the
+/// window to nothing.
+const MIN_W: u32 = 800;
+const MIN_H: u32 = 600;
+
+/// The geometry to apply to the main window at startup, or `None` to leave it as
+/// `tauri.conf.json` configured it.
+///
+/// `None` is returned when there is nothing saved, when Tauri reports no monitors
+/// (it can return an empty list on a compositor that hasn't settled — guessing
+/// from a saved rect we can't validate is worse than the default), or when the
+/// saved rect no longer meaningfully overlaps any connected monitor.
+///
+/// Otherwise the rect is fitted to the monitor it overlaps most: clamped to that
+/// monitor's size and shifted so it sits fully inside it. `maximized` passes
+/// straight through — a maximized window still needs its rect resolved, because
+/// that rect is what decides *which monitor* it re-maximizes on.
+pub fn resolve_startup_geometry(
+    saved: Option<WindowState>,
+    monitors: &[MonitorRect],
+) -> Option<WindowState> {
+    let saved = saved?;
+    if monitors.is_empty() {
+        return None;
+    }
+    // A zero/negative-sized saved rect can't be intersected meaningfully.
+    if saved.w == 0 || saved.h == 0 {
+        return None;
+    }
+
+    let best = monitors
+        .iter()
+        .max_by_key(|m| overlap_area(&saved, m))
+        .copied()?;
+
+    let (ow, oh) = overlap_dims(&saved, &best);
+    if ow < MIN_VISIBLE_W || oh < MIN_VISIBLE_H {
+        return None;
+    }
+
+    // Fit to the monitor: never wider/taller than the screen, never below the
+    // configured minimum, then slid back inside if it hangs off an edge.
+    let w = saved.w.clamp(MIN_W.min(best.w), best.w);
+    let h = saved.h.clamp(MIN_H.min(best.h), best.h);
+    let x = saved.x.clamp(best.x, best.x + best.w as i32 - w as i32);
+    let y = saved.y.clamp(best.y, best.y + best.h as i32 - h as i32);
+
+    Some(WindowState {
+        x,
+        y,
+        w,
+        h,
+        maximized: saved.maximized,
+    })
+}
+
+/// Geometry to re-apply to a DETACHED popout on project switch-back (#42).
+///
+/// The switch path hides an inactive project's popouts and re-shows them on
+/// switch-back; `hide()`/`show()` lets the WM move the window — typically onto
+/// the primary monitor — so the geometry captured just before hiding must be
+/// re-applied, or a multi-monitor popout lands on the wrong screen. This
+/// validates that captured rect against the CURRENTLY connected monitors (the
+/// same monitor-fit the main window uses at startup) so a monitor unplugged
+/// while the project was inactive can't strand the popout off-screen.
+///
+/// Two things differ from [`resolve_startup_geometry`]:
+///   * An **empty** monitor list re-applies the captured rect unchanged rather
+///     than giving up — mid-session the rect is known-good (the popout was just
+///     visible there) and a transient empty read is no reason to leave it
+///     WM-misplaced.
+///   * It imposes **no minimum size**. A borderless popout has no configured
+///     `minWidth`/`minHeight` (the main window does), so growing it to 800×600
+///     would silently resize a deliberately small popout.
+///
+/// Returns `None` only when the captured rect is degenerate, or when it no
+/// longer meaningfully overlaps any connected monitor (the display it lived on
+/// was unplugged) — in which case the caller leaves the WM's placement rather
+/// than flinging the window off-screen.
+pub fn resolve_detached_geometry(
+    saved: WindowState,
+    monitors: &[MonitorRect],
+) -> Option<WindowState> {
+    if saved.w == 0 || saved.h == 0 {
+        return None;
+    }
+    if monitors.is_empty() {
+        return Some(saved);
+    }
+
+    let best = monitors
+        .iter()
+        .max_by_key(|m| overlap_area(&saved, m))
+        .copied()?;
+
+    let (ow, oh) = overlap_dims(&saved, &best);
+    if ow < MIN_VISIBLE_W || oh < MIN_VISIBLE_H {
+        return None;
+    }
+
+    // Fit to the monitor WITHOUT a minimum-size floor: never larger than the
+    // screen, then slid back inside if it hangs off an edge.
+    let w = saved.w.min(best.w);
+    let h = saved.h.min(best.h);
+    let x = saved.x.clamp(best.x, best.x + best.w as i32 - w as i32);
+    let y = saved.y.clamp(best.y, best.y + best.h as i32 - h as i32);
+    Some(WindowState { x, y, w, h, maximized: false })
+}
+
+/// Width/height of the intersection between a saved window rect and a monitor, in
+/// physical px. `i64` because `x + w` on two `i32`s can overflow in principle and
+/// these feed a comparison, not a coordinate.
+fn overlap_dims(s: &WindowState, m: &MonitorRect) -> (i64, i64) {
+    let (sx, sy) = (s.x as i64, s.y as i64);
+    let (sx2, sy2) = (sx + s.w as i64, sy + s.h as i64);
+    let (mx, my) = (m.x as i64, m.y as i64);
+    let (mx2, my2) = (mx + m.w as i64, my + m.h as i64);
+    let w = (sx2.min(mx2) - sx.max(mx)).max(0);
+    let h = (sy2.min(my2) - sy.max(my)).max(0);
+    (w, h)
+}
+
+fn overlap_area(s: &WindowState, m: &MonitorRect) -> i64 {
+    let (w, h) = overlap_dims(s, m);
+    w * h
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The dev desk this feature was written for: two 1920x1080 monitors side by
+    /// side, DP-6 at the origin and DP-7 to its right.
+    fn two_monitors() -> Vec<MonitorRect> {
+        vec![
+            MonitorRect { x: 0, y: 0, w: 1920, h: 1080 },
+            MonitorRect { x: 1920, y: 0, w: 1920, h: 1080 },
+        ]
+    }
+
+    fn only_primary() -> Vec<MonitorRect> {
+        vec![MonitorRect { x: 0, y: 0, w: 1920, h: 1080 }]
+    }
+
+    fn ws(x: i32, y: i32, w: u32, h: u32) -> WindowState {
+        WindowState { x, y, w, h, maximized: false }
+    }
+
+    #[test]
+    fn nothing_saved_keeps_the_configured_default() {
+        assert_eq!(resolve_startup_geometry(None, &two_monitors()), None);
+    }
+
+    #[test]
+    fn no_monitors_reported_keeps_the_configured_default() {
+        // Rather than trust a rect we cannot validate against anything.
+        assert_eq!(resolve_startup_geometry(Some(ws(0, 0, 1400, 900)), &[]), None);
+    }
+
+    #[test]
+    fn window_on_the_secondary_monitor_is_returned_unchanged() {
+        // THE core case: Eldrun was on DP-7, it must come back on DP-7.
+        let saved = ws(2200, 100, 1400, 900);
+        assert_eq!(
+            resolve_startup_geometry(Some(saved), &two_monitors()),
+            Some(saved)
+        );
+    }
+
+    #[test]
+    fn unplugging_the_saved_monitor_falls_back_to_the_default() {
+        // Saved on DP-7 (x=2200), which is now gone. The rect overlaps the
+        // remaining monitor by nothing at all, so we must NOT place the window
+        // there-ish — we hand back None and let the config maximize it.
+        let saved = ws(2200, 100, 1400, 900);
+        assert_eq!(resolve_startup_geometry(Some(saved), &only_primary()), None);
+    }
+
+    #[test]
+    fn a_sliver_of_overlap_is_not_enough_to_trust_the_rect() {
+        // 20px of the window pokes onto the primary monitor — far too little to
+        // grab. Treated the same as the monitor being gone.
+        let saved = ws(1900, 100, 1400, 900);
+        assert_eq!(resolve_startup_geometry(Some(saved), &only_primary()), None);
+    }
+
+    #[test]
+    fn a_window_hanging_off_an_edge_is_slid_back_inside() {
+        // Mostly on the primary monitor but running past its right edge.
+        let saved = ws(1000, 400, 1400, 900);
+        let got = resolve_startup_geometry(Some(saved), &only_primary()).unwrap();
+        assert_eq!(got.w, 1400, "size is fine, only the origin was wrong");
+        assert_eq!(got.h, 900);
+        assert_eq!(got.x, 520, "flush against the monitor's right edge");
+        assert_eq!(got.y, 180, "flush against its bottom edge");
+    }
+
+    #[test]
+    fn a_window_larger_than_its_monitor_is_shrunk_to_fit() {
+        // e.g. saved on a 4K screen, reopened on a 1080p one.
+        let saved = ws(0, 0, 3840, 2160);
+        let got = resolve_startup_geometry(Some(saved), &only_primary()).unwrap();
+        assert_eq!((got.x, got.y, got.w, got.h), (0, 0, 1920, 1080));
+    }
+
+    #[test]
+    fn a_maximized_window_still_resolves_its_rect() {
+        // The rect is what decides WHICH monitor it re-maximizes on, so it must
+        // survive even though the window will immediately be maximized over it.
+        let saved = WindowState { x: 2200, y: 100, w: 1400, h: 900, maximized: true };
+        let got = resolve_startup_geometry(Some(saved), &two_monitors()).unwrap();
+        assert!(got.maximized);
+        assert_eq!(got.x, 2200, "still on DP-7, so it maximizes there and not on DP-6");
+    }
+
+    #[test]
+    fn a_degenerate_saved_rect_is_ignored() {
+        // A hand-edited or truncated settings.json must not produce a 0-px window.
+        assert_eq!(resolve_startup_geometry(Some(ws(0, 0, 0, 900)), &only_primary()), None);
+        assert_eq!(resolve_startup_geometry(Some(ws(0, 0, 1400, 0)), &only_primary()), None);
+    }
+
+    #[test]
+    fn a_tiny_saved_rect_is_discarded_rather_than_grown() {
+        // 100x50 is smaller than the grabbable minimum however it is placed, so it
+        // fails the visibility check and we fall back to the default. We never
+        // invent a geometry the user never had.
+        assert_eq!(
+            resolve_startup_geometry(Some(ws(10, 10, 100, 50)), &only_primary()),
+            None
+        );
+    }
+
+    #[test]
+    fn an_ordinary_rect_well_inside_a_monitor_is_left_alone() {
+        let got = resolve_startup_geometry(Some(ws(10, 10, 900, 700)), &only_primary()).unwrap();
+        assert_eq!((got.x, got.y, got.w, got.h), (10, 10, 900, 700));
+    }
+
+    #[test]
+    fn the_monitor_with_the_most_overlap_wins() {
+        // Straddling the seam, but mostly on DP-7 → fitted onto DP-7.
+        let saved = ws(1800, 100, 1400, 900);
+        let got = resolve_startup_geometry(Some(saved), &two_monitors()).unwrap();
+        assert_eq!(got.x, 1920, "slid right, flush with DP-7's left edge");
+        assert_eq!(got.w, 1400, "not resized — it fits DP-7 fine");
+    }
+
+    // ── resolve_detached_geometry (#42 switch-back popout restore) ──────────
+
+    #[test]
+    fn detached_popout_on_the_secondary_monitor_is_restored_there() {
+        // THE bug: switching back must land the popout on DP-7, not DP-6.
+        let saved = ws(2200, 150, 900, 640);
+        assert_eq!(
+            resolve_detached_geometry(saved, &two_monitors()),
+            Some(saved),
+        );
+    }
+
+    #[test]
+    fn detached_empty_monitor_list_reapplies_the_captured_rect() {
+        // Mid-session the captured rect was valid moments ago; a transient empty
+        // monitor read is no reason to leave the popout WM-misplaced. Unlike the
+        // startup resolver, which returns None here.
+        let saved = ws(2200, 150, 900, 640);
+        assert_eq!(resolve_detached_geometry(saved, &[]), Some(saved));
+    }
+
+    #[test]
+    fn detached_small_popout_is_not_grown_to_a_minimum() {
+        // A borderless popout has no configured minimum size — a deliberately
+        // small one must come back the same size, not grown to 800×600 the way
+        // the main-window resolver would.
+        let saved = ws(300, 300, 420, 320);
+        let got = resolve_detached_geometry(saved, &only_primary()).unwrap();
+        assert_eq!((got.w, got.h), (420, 320), "kept its small size");
+        assert_eq!((got.x, got.y), (300, 300));
+    }
+
+    #[test]
+    fn detached_popout_on_an_unplugged_monitor_falls_back_to_wm_placement() {
+        // The display it lived on is gone → None, so the caller leaves the WM's
+        // placement rather than flinging it off-screen.
+        let saved = ws(2200, 150, 900, 640);
+        assert_eq!(resolve_detached_geometry(saved, &only_primary()), None);
+    }
+
+    #[test]
+    fn detached_popout_hanging_off_an_edge_is_slid_back_inside() {
+        let saved = ws(1600, 800, 900, 640);
+        let got = resolve_detached_geometry(saved, &only_primary()).unwrap();
+        assert_eq!(got.w, 900, "size fine, only origin was off");
+        assert_eq!(got.x, 1020, "flush against the monitor's right edge");
+        assert_eq!(got.y, 440, "flush against its bottom edge");
+    }
+
+    #[test]
+    fn detached_degenerate_rect_is_ignored() {
+        assert_eq!(resolve_detached_geometry(ws(0, 0, 0, 640), &only_primary()), None);
+        assert_eq!(resolve_detached_geometry(ws(0, 0, 900, 0), &only_primary()), None);
+    }
+}
diff --git a/src-tauri/src/services/worker_sync.rs b/src-tauri/src/services/worker_sync.rs
new file mode 100644
index 0000000..0aadb5d
--- /dev/null
+++ b/src-tauri/src/services/worker_sync.rs
@@ -0,0 +1,688 @@
+//! Worker code sync — one-way, code-only push fan-out (`docs/multi_host_remote_plan.md` §2).
+//!
+//! The canonical source is the **local mirror** — already lockstep-paired with the
+//! primary (`git_peer`), so it always holds the project's current committed code.
+//! Each extra "worker" host (`schema::project::ComputeHost`) is fed *from the
+//! mirror*, one-way, tracked files only:
+//!
+//! 1. On the mirror, `git bundle` the current HEAD (incremental `--not <last_head>`
+//!    when we know what the worker already has).
+//! 2. Ship the bundle to `worker:<remote_path>/.eldrun-worker.bundle` over the
+//!    worker's pooled SFTP session.
+//! 3. On the worker: `git init` (idempotent), `git fetch` the bundle, then
+//!    `git reset --hard FETCH_HEAD` — **tracked files only, never `git clean`**.
+//!
+//! This inherits none of the hard parts of the primary's bidirectional lockstep:
+//! a worker tree is never read back, so there is no divergence, no conflict, and no
+//! destructive local-loss to audit. The single load-bearing invariant is that the
+//! worker sync **must never `git clean`** — untracked experiment outputs survive
+//! every sync by construction (plan §8).
+
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Emitter};
+use tokio::sync::Mutex;
+
+use crate::services::git_peer::{bundle_create_args, Peer};
+use crate::services::remote::{self, RemotePoolState, PRIMARY_HOST};
+use crate::services::remote_sync::mirror_dir;
+use crate::services::{sftp, ssh_exec};
+use crate::storage;
+
+/// The bundle filename shipped into a worker's `remote_path`. A relative name, so
+/// the worker-side script (which runs `cd <remote_path> && …`) never has to
+/// interpolate a path.
+const WORKER_BUNDLE: &str = ".eldrun-worker.bundle";
+
+/// In-memory fan-out registry: the `(project, host)` keys currently syncing, used
+/// as a crude in-flight lock so a commit-triggered and a connect-triggered push to
+/// the same worker never race to write its bundle file. The durable per-worker
+/// `last_head` lives on disk (see [`worker_state_path`]).
+#[derive(Default)]
+pub struct WorkerSyncRegistry {
+    in_flight: HashSet<String>,
+}
+
+/// Managed-state handle to the worker-sync registry.
+pub type WorkerSyncState = Arc<Mutex<WorkerSyncRegistry>>;
+
+/// Build a fresh, empty worker-sync registry for `tauri::Builder::manage`.
+pub fn new_state() -> WorkerSyncState {
+    Arc::new(Mutex::new(WorkerSyncRegistry::default()))
+}
+
+/// Durable per-worker state (`worker_sync.json`): the commit last successfully
+/// pushed to this worker, so the next push can be an incremental bundle.
+#[derive(Default, Serialize, Deserialize)]
+struct WorkerRecord {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    last_head: Option<String>,
+}
+
+/// The outcome of one worker fan-out, emitted to the frontend as a
+/// `worker-sync-report` event so the "Remote machines…" section can show a
+/// "last synced: <commit>" line.
+#[derive(Clone, Serialize)]
+pub struct WorkerSyncReport {
+    pub project_id: String,
+    pub host_id: String,
+    /// The commit now on the worker's tracked tree (short sha), when known.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub head: Option<String>,
+    pub ok: bool,
+    /// Nothing to do — the worker is already at HEAD, or the mirror has no commit.
+    pub skipped: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+
+/// Where a worker's durable `worker_sync.json` lives: under the project's slot in
+/// the local state dir, per host. Independent of the mirror so it survives a mirror
+/// relocation.
+fn worker_state_path(project_id: &str, host_id: &str) -> PathBuf {
+    storage::state_dir()
+        .join("remote-projects")
+        .join(project_id)
+        .join("workers")
+        .join(format!("{host_id}.json"))
+}
+
+/// The local scratch path for a worker's outbound bundle (beside its state file).
+fn local_bundle_path(project_id: &str, host_id: &str) -> PathBuf {
+    storage::state_dir()
+        .join("remote-projects")
+        .join(project_id)
+        .join("workers")
+        .join(format!("{host_id}.bundle"))
+}
+
+fn read_record(project_id: &str, host_id: &str) -> WorkerRecord {
+    let path = worker_state_path(project_id, host_id);
+    if path.exists() {
+        storage::read_json(&path).unwrap_or_default()
+    } else {
+        WorkerRecord::default()
+    }
+}
+
+fn write_record(project_id: &str, host_id: &str, rec: &WorkerRecord) {
+    let path = worker_state_path(project_id, host_id);
+    if let Some(parent) = path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    let _ = storage::write_json(&path, rec);
+}
+
+/// The mirror's current HEAD commit sha, or `None` when the mirror has no commit
+/// yet (unborn HEAD) or is unreadable.
+fn mirror_head(mirror: &Path) -> Option<String> {
+    let out = Peer::Local(mirror.to_path_buf())
+        .run(&["rev-parse", "--verify", "--quiet", "HEAD"])
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    let sha = String::from_utf8_lossy(&out.stdout).trim().to_string();
+    if sha.is_empty() {
+        None
+    } else {
+        Some(sha)
+    }
+}
+
+/// Build the outbound bundle on the mirror. `exclude` (the worker's `last_head`)
+/// makes it a thin incremental bundle when the worker already has that commit.
+/// Returns `Ok(true)` for git's "Refusing to create empty bundle" — i.e. nothing to
+/// send — and `Ok(false)` when a bundle was written. Any other failure is `Err`.
+fn build_bundle(mirror: &Path, bundle_path: &Path, exclude: Option<&str>) -> Result<bool, String> {
+    if let Some(parent) = bundle_path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    let excludes: Vec<String> = exclude.map(|s| vec![s.to_string()]).unwrap_or_default();
+    let path_str = bundle_path.to_string_lossy().to_string();
+    // Positive is `HEAD` (a ref, not a raw sha — `git bundle` needs a ref name);
+    // excludes are rev-list args and may be raw shas.
+    let args = bundle_create_args(&path_str, &["HEAD"], &excludes);
+    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
+    let out = Peer::Local(mirror.to_path_buf()).run(&arg_refs)?;
+    if out.status.success() {
+        return Ok(false);
+    }
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    if stderr.contains("Refusing to create empty bundle") {
+        return Ok(true); // worker already has HEAD — nothing to send
+    }
+    Err(format!("git bundle create failed: {}", stderr.trim()))
+}
+
+/// The constant worker-side script: init (idempotent), fetch the shipped bundle,
+/// then move the **tracked** tree to it. It **never** `git clean`s, so untracked
+/// experiment outputs survive; the bundle is removed after applying. Constant text
+/// (no interpolation), so it is safe to hand to `run_remote_script`.
+fn worker_apply_script() -> String {
+    format!(
+        "git init -q && \
+         git fetch -q --no-tags {bundle} && \
+         git -c advice.detachedHead=false reset -q --hard FETCH_HEAD && \
+         rm -f {bundle}",
+        bundle = WORKER_BUNDLE
+    )
+}
+
+/// Push the mirror's current HEAD to one worker's tracked tree (plan §2). `force`
+/// bypasses the "already at last_head" short-circuit (the manual "Sync code now").
+///
+/// Returns a [`WorkerSyncReport`]; it does **not** emit the event (the caller may
+/// batch a fan-out). Blocking git + async SFTP are interleaved, so this awaits.
+pub async fn sync_worker(
+    pool: &RemotePoolState,
+    project_id: &str,
+    host_id: &str,
+    force: bool,
+) -> WorkerSyncReport {
+    let report_err = |msg: String| WorkerSyncReport {
+        project_id: project_id.to_string(),
+        host_id: host_id.to_string(),
+        head: None,
+        ok: false,
+        skipped: false,
+        error: Some(msg),
+    };
+
+    if host_id == PRIMARY_HOST {
+        return report_err("primary is not a worker".to_string());
+    }
+    // A SHARED-FILESYSTEM worker sees the primary's project folder directly, so
+    // there is nothing to copy — and running git here would operate inside the
+    // primary's real working tree. Never sync it; report a no-op skip. This is a
+    // defensive guard (the connect path and `fan_out` already skip shared hosts),
+    // so even a stray `worker_sync_now` on one can do no harm.
+    if remote::compute_hosts_for(project_id)
+        .into_iter()
+        .any(|h| h.id == host_id && h.shared_fs)
+    {
+        return WorkerSyncReport {
+            project_id: project_id.to_string(),
+            host_id: host_id.to_string(),
+            head: None,
+            ok: true,
+            skipped: true,
+            error: None,
+        };
+    }
+    let Some(target) = remote::remote_target_for_host(project_id, host_id) else {
+        return report_err("unknown worker host".to_string());
+    };
+    let spec = target.spec;
+
+    let mirror = mirror_dir(project_id);
+    let Some(head) = mirror_head(&mirror) else {
+        // Nothing committed yet — a worker legitimately has no code to receive.
+        return WorkerSyncReport {
+            project_id: project_id.to_string(),
+            host_id: host_id.to_string(),
+            head: None,
+            ok: true,
+            skipped: true,
+            error: None,
+        };
+    };
+
+    let last_head = read_record(project_id, host_id).last_head;
+    if !force && last_head.as_deref() == Some(head.as_str()) {
+        return WorkerSyncReport {
+            project_id: project_id.to_string(),
+            host_id: host_id.to_string(),
+            head: Some(short_sha(&head)),
+            ok: true,
+            skipped: true,
+            error: None,
+        };
+    }
+
+    // Attempt an incremental bundle first (excluding the worker's last_head); on any
+    // apply failure — most likely a missing prerequisite because the worker's tree
+    // drifted from what we recorded — retry with a full bundle, which is always
+    // correct (merely larger).
+    let mut attempts: Vec<Option<String>> = Vec::new();
+    if let Some(last) = last_head.clone() {
+        attempts.push(Some(last));
+    }
+    attempts.push(None); // full bundle fallback (and first attempt when no last_head)
+
+    let mut last_err: Option<String> = None;
+    for exclude in attempts {
+        match push_once(pool, project_id, host_id, &spec, &mirror, exclude.as_deref()).await {
+            Ok(true) => {
+                // Empty bundle — worker already at HEAD. Record and finish.
+                write_record(project_id, host_id, &WorkerRecord { last_head: Some(head.clone()) });
+                return WorkerSyncReport {
+                    project_id: project_id.to_string(),
+                    host_id: host_id.to_string(),
+                    head: Some(short_sha(&head)),
+                    ok: true,
+                    skipped: true,
+                    error: None,
+                };
+            }
+            Ok(false) => {
+                write_record(project_id, host_id, &WorkerRecord { last_head: Some(head.clone()) });
+                return WorkerSyncReport {
+                    project_id: project_id.to_string(),
+                    host_id: host_id.to_string(),
+                    head: Some(short_sha(&head)),
+                    ok: true,
+                    skipped: false,
+                    error: None,
+                };
+            }
+            Err(e) => last_err = Some(e),
+        }
+    }
+    report_err(last_err.unwrap_or_else(|| "worker sync failed".to_string()))
+}
+
+/// One push attempt with a given `exclude`. `Ok(true)` = nothing to send (empty
+/// bundle); `Ok(false)` = applied on the worker; `Err` = build/ship/apply failure.
+async fn push_once(
+    pool: &RemotePoolState,
+    project_id: &str,
+    host_id: &str,
+    spec: &crate::schema::project::RemoteSpec,
+    mirror: &Path,
+    exclude: Option<&str>,
+) -> Result<bool, String> {
+    let bundle_path = local_bundle_path(project_id, host_id);
+
+    // 1. Build the bundle on the mirror (blocking git).
+    let mirror_owned = mirror.to_path_buf();
+    let bundle_owned = bundle_path.clone();
+    let exclude_owned = exclude.map(str::to_string);
+    let empty = tauri::async_runtime::spawn_blocking(move || {
+        build_bundle(&mirror_owned, &bundle_owned, exclude_owned.as_deref())
+    })
+    .await
+    .map_err(|e| e.to_string())??;
+    if empty {
+        return Ok(true);
+    }
+
+    // 2. Ensure the worker root exists and ship the bundle over its pooled SFTP.
+    let spec_for_mkdir = spec.clone();
+    tauri::async_runtime::spawn_blocking(move || ssh_exec::remote_mkdir_p(&spec_for_mkdir))
+        .await
+        .map_err(|e| e.to_string())?
+        .map_err(|e| format!("could not create worker dir: {e}"))?;
+
+    let remote_bundle = format!("{}/{}", spec.remote_path.trim_end_matches('/'), WORKER_BUNDLE);
+    let sftp = remote::pooled_sftp_host(pool, project_id, host_id)
+        .await
+        .ok_or_else(|| "worker not connected".to_string())?;
+    sftp::upload_file_streaming_on(&sftp, &bundle_path, &remote_bundle).await?;
+    let _ = std::fs::remove_file(&bundle_path);
+
+    // 3. Apply on the worker (blocking ssh). Tracked files only — never git clean.
+    let spec_for_apply = spec.clone();
+    let out = tauri::async_runtime::spawn_blocking(move || {
+        ssh_exec::run_remote_script(&spec_for_apply, &worker_apply_script())
+    })
+    .await
+    .map_err(|e| e.to_string())??;
+    if !out.status.success() {
+        return Err(format!(
+            "worker apply failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        ));
+    }
+    Ok(false)
+}
+
+/// A short (7-char) sha for display, unchanged when already shorter.
+fn short_sha(sha: &str) -> String {
+    sha.chars().take(7).collect()
+}
+
+/// Whether a worker should receive the commit-triggered code fan-out. A
+/// **shared-filesystem** worker never does — it has no copy of its own (its tree IS
+/// the primary's, moved by the primary's own sync), and running git on it would
+/// operate inside the primary's real working tree. A **synced-copy** worker does,
+/// unless `sync_code` is unticked (manual-sync only). Pure, so it is unit-tested.
+fn wants_code_fanout(host: &crate::schema::project::ComputeHost) -> bool {
+    !host.shared_fs && host.sync_code
+}
+
+/// Fan out the current mirror HEAD to **every connected, `sync_code`** worker of a
+/// project, emitting a `worker-sync-report` per worker. The commit-trigger and
+/// manual "Push code to machines" entry point (plan §2 triggers). Best-effort per
+/// worker — one worker failing never blocks the others.
+pub async fn fan_out(
+    app: &AppHandle,
+    pool: &RemotePoolState,
+    state: &WorkerSyncState,
+    project_id: &str,
+    force: bool,
+) {
+    for host in remote::compute_hosts_for(project_id) {
+        if !wants_code_fanout(&host) {
+            continue;
+        }
+        if !remote::is_connected_host(pool, project_id, &host.id).await {
+            continue;
+        }
+        sync_worker_guarded(app, pool, state, project_id, &host.id, force).await;
+    }
+}
+
+/// One worker's fan-out with the in-flight lock + event emit. Skips silently if a
+/// sync to the same worker is already running.
+async fn sync_worker_guarded(
+    app: &AppHandle,
+    pool: &RemotePoolState,
+    state: &WorkerSyncState,
+    project_id: &str,
+    host_id: &str,
+    force: bool,
+) {
+    let key = format!("{project_id}\u{1}{host_id}");
+    {
+        let mut guard = state.lock().await;
+        if !guard.in_flight.insert(key.clone()) {
+            return; // already syncing this worker
+        }
+    }
+    let report = sync_worker(pool, project_id, host_id, force).await;
+    {
+        let mut guard = state.lock().await;
+        guard.in_flight.remove(&key);
+    }
+    let _ = app.emit("worker-sync-report", &report);
+}
+
+// ── Output pull-back (§4.4) — the ONLY worker→local byte path, user-initiated ──
+
+/// One untracked worker file (an experiment output): its byte size + repo-relative
+/// path. Parsed from the worker-side `ls-files --others` listing.
+#[derive(Clone, Serialize)]
+pub struct WorkerOutput {
+    pub rel: String,
+    pub bytes: u64,
+}
+
+/// A size preview of what a "Pull outputs" would fetch (plan §4.4 size-confirm): a
+/// worker's untracked (output) files never touched by the code sync.
+#[derive(Clone, Serialize)]
+pub struct WorkerOutputsPreview {
+    pub files: usize,
+    pub bytes: u64,
+}
+
+/// The result of a completed output pull: how many files landed, total bytes, the
+/// local destination folder, and any per-file errors (best-effort).
+#[derive(Clone, Serialize)]
+pub struct WorkerPullReport {
+    pub pulled: usize,
+    pub bytes: u64,
+    pub dest: String,
+    pub errors: Vec<String>,
+}
+
+/// The constant worker-side script listing untracked (output) files with sizes:
+/// `<bytes>\t<relpath>` per line. `git clean` is never run — this only *reads*.
+/// (A path containing a newline would split; experiment outputs effectively never
+/// do, and the tradeoff buys a one-round-trip listing.)
+fn outputs_list_script() -> &'static str {
+    "git ls-files --others --exclude-standard | while IFS= read -r f; do \
+       sz=$(stat -c %s \"$f\" 2>/dev/null || echo 0); \
+       printf '%s\\t%s\\n' \"$sz\" \"$f\"; \
+     done"
+}
+
+/// Parse the `<bytes>\t<relpath>` listing into [`WorkerOutput`]s. Pure. Skips
+/// blank/malformed lines and anything with a `..` segment or an absolute path (a
+/// download-target traversal guard).
+pub fn parse_outputs_listing(stdout: &str) -> Vec<WorkerOutput> {
+    stdout
+        .lines()
+        .filter_map(|line| {
+            let (size, rel) = line.split_once('\t')?;
+            let rel = rel.trim_end_matches('\r');
+            if rel.is_empty() || rel.starts_with('/') {
+                return None;
+            }
+            if rel.split(['/', '\\']).any(|seg| seg == "..") {
+                return None;
+            }
+            let bytes: u64 = size.trim().parse().ok()?;
+            Some(WorkerOutput { rel: rel.to_string(), bytes })
+        })
+        .collect()
+}
+
+/// The local folder a worker's pulled outputs land in: `outputs/<label>/` under the
+/// project's state slot. Deliberately NOT inside the git mirror (untracked bytes
+/// there would fall to byte-sync and could reach the primary).
+fn outputs_dest(project_id: &str, label: &str) -> PathBuf {
+    let safe: String = label
+        .chars()
+        .map(|c| if c.is_ascii_alphanumeric() || c == '-' || c == '_' { c } else { '-' })
+        .collect();
+    let safe = if safe.trim_matches('-').is_empty() { "worker".to_string() } else { safe };
+    storage::state_dir()
+        .join("remote-projects")
+        .join(project_id)
+        .join("outputs")
+        .join(safe)
+}
+
+/// List a worker's untracked output files (blocking ssh).
+async fn list_outputs(spec: &crate::schema::project::RemoteSpec) -> Result<Vec<WorkerOutput>, String> {
+    let spec = spec.clone();
+    let out = tauri::async_runtime::spawn_blocking(move || {
+        ssh_exec::run_remote_script(&spec, outputs_list_script())
+    })
+    .await
+    .map_err(|e| e.to_string())??;
+    if !out.status.success() {
+        return Err(format!(
+            "listing worker outputs failed: {}",
+            String::from_utf8_lossy(&out.stderr).trim()
+        ));
+    }
+    Ok(parse_outputs_listing(&String::from_utf8_lossy(&out.stdout)))
+}
+
+/// Preview the size of a worker's pullable outputs (plan §4.4 size-confirm).
+pub async fn preview_outputs(
+    project_id: &str,
+    host_id: &str,
+) -> Result<WorkerOutputsPreview, String> {
+    let target = remote::remote_target_for_host(project_id, host_id)
+        .ok_or_else(|| "unknown worker host".to_string())?;
+    let files = list_outputs(&target.spec).await?;
+    Ok(WorkerOutputsPreview {
+        files: files.len(),
+        bytes: files.iter().map(|f| f.bytes).sum(),
+    })
+}
+
+/// Pull a worker's untracked outputs into `outputs/<label>/` (plan §4.4). The one
+/// place worker→local bytes ever move, and only on this explicit call. Best-effort
+/// per file — one download failing never aborts the rest.
+pub async fn pull_outputs(
+    pool: &RemotePoolState,
+    project_id: &str,
+    host_id: &str,
+) -> Result<WorkerPullReport, String> {
+    let target = remote::remote_target_for_host(project_id, host_id)
+        .ok_or_else(|| "unknown worker host".to_string())?;
+    let spec = target.spec;
+    let label = remote::compute_hosts_for(project_id)
+        .into_iter()
+        .find(|h| h.id == host_id)
+        .map(|h| h.display_label().to_string())
+        .unwrap_or_else(|| host_id.to_string());
+
+    let files = list_outputs(&spec).await?;
+    let dest = outputs_dest(project_id, &label);
+    let _ = std::fs::create_dir_all(&dest);
+
+    let sftp = remote::pooled_sftp_host(pool, project_id, host_id)
+        .await
+        .ok_or_else(|| "worker not connected".to_string())?;
+    let root = spec.remote_path.trim_end_matches('/');
+
+    let mut pulled = 0usize;
+    let mut bytes = 0u64;
+    let mut errors = Vec::new();
+    for f in &files {
+        let remote_path = format!("{root}/{}", f.rel);
+        let local_path = dest.join(&f.rel);
+        match sftp::download_file_streaming_on(&sftp, &remote_path, &local_path).await {
+            Ok(()) => {
+                pulled += 1;
+                bytes += f.bytes;
+            }
+            Err(e) => errors.push(format!("{}: {e}", f.rel)),
+        }
+    }
+    Ok(WorkerPullReport {
+        pulled,
+        bytes,
+        dest: dest.to_string_lossy().into_owned(),
+        errors,
+    })
+}
+
+/// Kicked by `remote_connect` when a **worker** host connects: bring its tracked
+/// tree up to the current HEAD. Fire-and-forget from the connect path.
+pub async fn on_worker_connect(
+    app: AppHandle,
+    pool: RemotePoolState,
+    state: WorkerSyncState,
+    project_id: &str,
+    host_id: &str,
+) {
+    sync_worker_guarded(&app, &pool, &state, project_id, host_id, false).await;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn worker_apply_script_never_cleans_and_resets_tracked() {
+        let s = worker_apply_script();
+        // The single load-bearing invariant (plan §8): the worker sync must NEVER
+        // `git clean` — that is what lets untracked experiment outputs survive.
+        assert!(!s.contains("clean"), "worker script must never git clean: {s}");
+        // It moves the TRACKED tree via reset --hard to the fetched HEAD.
+        assert!(s.contains("reset -q --hard FETCH_HEAD"));
+        assert!(s.contains("git fetch"));
+        assert!(s.contains("git init"));
+        // The bundle is a relative name (the script runs `cd <remote_path> && …`).
+        assert!(s.contains(WORKER_BUNDLE));
+        assert!(!WORKER_BUNDLE.starts_with('/'));
+    }
+
+    #[test]
+    fn parse_outputs_listing_skips_traversal_and_bad_lines() {
+        let stdout = "1024\tcheckpoints/model.bin\n\
+                      0\tlogs/run.log\n\
+                      \n\
+                      512\t../escape.txt\n\
+                      99\t/abs/path\n\
+                      notanumber\tfoo\n\
+                      2048\tnested/dir/weights.pt\r";
+        let out = parse_outputs_listing(stdout);
+        let rels: Vec<&str> = out.iter().map(|o| o.rel.as_str()).collect();
+        assert_eq!(rels, ["checkpoints/model.bin", "logs/run.log", "nested/dir/weights.pt"]);
+        assert_eq!(out[0].bytes, 1024);
+        assert_eq!(out[2].bytes, 2048); // trailing \r stripped from the path
+    }
+
+    #[test]
+    fn outputs_dest_sanitizes_label() {
+        let p = outputs_dest("proj1", "gpu-2/../etc");
+        // No traversal (or path separator) survives the label sanitizer, so the
+        // dest can never climb out of the project's outputs folder.
+        let s = p.to_string_lossy();
+        assert!(!s.contains(".."));
+        assert!(s.ends_with("gpu-2----etc"));
+        // An all-junk label falls back to "worker" rather than an empty segment.
+        assert!(outputs_dest("p", "///").to_string_lossy().ends_with("worker"));
+    }
+
+    #[test]
+    fn shared_fs_worker_is_never_fanned_out() {
+        use crate::schema::project::{ComputeHost, RemoteSpec};
+        let mk = |shared_fs: bool, sync_code: bool| ComputeHost {
+            id: "h1".into(),
+            sync_code,
+            pull_outputs: false,
+            shared_fs,
+            spec: RemoteSpec {
+                user: None,
+                host: "gpu-2".into(),
+                port: None,
+                remote_path: "/home/me/project".into(),
+                openvpn: None,
+                auto_connect: None,
+                key_auth: None,
+                persist_sessions: None,
+                label: None,
+                extra: Default::default(),
+            },
+        };
+        // A shared-filesystem host is NEVER synced — the load-bearing guard that
+        // keeps git off the primary's real working tree — regardless of sync_code.
+        assert!(!wants_code_fanout(&mk(true, true)));
+        assert!(!wants_code_fanout(&mk(true, false)));
+        // A synced-copy host is synced iff sync_code is on.
+        assert!(wants_code_fanout(&mk(false, true)));
+        assert!(!wants_code_fanout(&mk(false, false)));
+    }
+
+    #[test]
+    fn short_sha_truncates() {
+        assert_eq!(short_sha("0123456789abcdef"), "0123456");
+        assert_eq!(short_sha("abc"), "abc");
+    }
+
+    #[test]
+    fn build_bundle_makes_incremental_and_survives_untracked() {
+        // Drive a real mirror repo (like examples/lockstep_drv.rs): a commit, an
+        // untracked output file, then a bundle of HEAD. This proves `build_bundle`
+        // reports a non-empty bundle and that the untracked file is irrelevant to it
+        // (git bundle carries objects + HEAD only, never the worktree's untracked
+        // bytes — the read half of the "outputs survive" guarantee).
+        let tmp = std::env::temp_dir().join(format!("eldrun-ws-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&tmp);
+        std::fs::create_dir_all(&tmp).unwrap();
+        let git = |args: &[&str]| {
+            Peer::Local(tmp.clone()).run(args).unwrap()
+        };
+        assert!(git(&["init", "-q"]).status.success());
+        let _ = git(&["config", "user.email", "t@e"]);
+        let _ = git(&["config", "user.name", "t"]);
+        std::fs::write(tmp.join("code.txt"), b"v1").unwrap();
+        assert!(git(&["add", "code.txt"]).status.success());
+        assert!(git(&["commit", "-q", "-m", "c1"]).status.success());
+        // An untracked experiment output — must never appear in the bundle.
+        std::fs::write(tmp.join("checkpoint.bin"), b"weights").unwrap();
+
+        let head = mirror_head(&tmp).expect("committed HEAD");
+        assert!(!head.is_empty());
+        let bundle = tmp.join("out.bundle");
+        let empty = build_bundle(&tmp, &bundle, None).expect("bundle builds");
+        assert!(!empty, "a fresh commit is not an empty bundle");
+        assert!(bundle.exists());
+        // A re-bundle excluding HEAD itself is empty ("nothing new to send").
+        let empty2 = build_bundle(&tmp, &tmp.join("out2.bundle"), Some(&head)).expect("ok");
+        assert!(empty2, "excluding HEAD yields an empty (already-synced) bundle");
+
+        let _ = std::fs::remove_dir_all(&tmp);
+    }
+}
diff --git a/src-tauri/src/storage.rs b/src-tauri/src/storage.rs
index 01b7112..37ea650 100644
--- a/src-tauri/src/storage.rs
+++ b/src-tauri/src/storage.rs
@@ -25,6 +25,30 @@ where
     Ok(())
 }
 
+/// Serialize and write a JSON file **atomically**: the bytes land in a temp file
+/// beside the target and are then `rename`d over it, so a reader (or a crash)
+/// never observes a half-written file.
+///
+/// [`write_json`] truncates in place, which is fine for a store with one writer
+/// that rewrites it rarely. Prefer this for a store written from several places
+/// (see `schema::usage_stats`, fed by both the frontend flush and the file
+/// watcher). Same rename trick as `services::agent_session::write_live_session_in`.
+pub fn write_json_atomic<T>(path: &Path, value: &T) -> Result<(), Box<dyn std::error::Error>>
+where
+    T: serde::Serialize,
+{
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    let json = serde_json::to_string_pretty(value)?;
+    // The temp file must sit on the same filesystem as the target for `rename`
+    // to be atomic, so it goes in the target's own directory rather than /tmp.
+    let tmp = path.with_extension("json.tmp");
+    fs::write(&tmp, json)?;
+    fs::rename(&tmp, path)?;
+    Ok(())
+}
+
 /// State directory for Eldrun's JSON files.
 ///
 /// Linux: `~/.local/share/eldrun/` — matches the Python app's hard-coded path
@@ -71,6 +95,14 @@ pub fn today_utc() -> String {
     format!("{y:04}-{m:02}-{d:02}")
 }
 
+/// Current UTC hour as "YYYY-MM-DDTHH" — a sortable stamp whose first ten
+/// characters are exactly [`today_utc`], so an hour bucket always folds into the
+/// right day bucket.
+pub fn hour_utc() -> String {
+    let (y, m, d, h, ..) = epoch_to_utc(now_secs());
+    format!("{y:04}-{m:02}-{d:02}T{h:02}")
+}
+
 /// Current timestamp as ISO-8601 UTC string (seconds precision).
 pub fn iso_now() -> String {
     let (y, mo, d, h, mi, s) = epoch_to_utc(now_secs());
@@ -140,6 +172,31 @@ mod tests {
         assert_eq!(today_utc(), today_utc());
     }
 
+    // ── hour_utc ───────────────────────────────────────────────────────────
+
+    #[test]
+    fn hour_utc_has_hour_stamp_format() {
+        let s = hour_utc();
+        assert_eq!(s.len(), 13, "expected YYYY-MM-DDTHH, got {s}");
+        let (date, hour) = s.split_once('T').expect("T separator");
+        assert_eq!(date.len(), 10);
+        let h: u32 = hour.parse().expect("hour numeric");
+        assert!(h <= 23, "hour range: {h}");
+    }
+
+    #[test]
+    fn hour_utc_is_prefixed_by_today_utc() {
+        // net_usage derives the day bucket from the hour stamp's first ten
+        // chars, so a divergence here would silently misfile every byte.
+        let hour = hour_utc();
+        let today = today_utc();
+        assert_eq!(
+            &hour[..10],
+            today,
+            "hour_utc must carry today_utc's date: hour={hour} today={today}"
+        );
+    }
+
     // ── iso_now ────────────────────────────────────────────────────────────
 
     #[test]
@@ -343,4 +400,42 @@ mod tests {
         let back: Vec<String> = read_json(&path).unwrap();
         assert_eq!(back, vec!["second", "third"]);
     }
+
+    // ── write_json_atomic ─────────────────────────────────────────────────
+
+    #[test]
+    fn write_json_atomic_roundtrips() {
+        let tmp = tempfile::tempdir().unwrap();
+        let path = tmp.path().join("atomic.json");
+        write_json_atomic(&path, &vec![7u32, 8, 9]).unwrap();
+        let back: Vec<u32> = read_json(&path).unwrap();
+        assert_eq!(back, vec![7, 8, 9]);
+    }
+
+    #[test]
+    fn write_json_atomic_creates_parent_dirs() {
+        let tmp = tempfile::tempdir().unwrap();
+        let path = tmp.path().join("deep/nested/atomic.json");
+        write_json_atomic(&path, &vec![1u32]).unwrap();
+        assert!(path.exists());
+    }
+
+    #[test]
+    fn write_json_atomic_overwrites_and_leaves_no_temp_behind() {
+        let tmp = tempfile::tempdir().unwrap();
+        let path = tmp.path().join("data.json");
+        write_json_atomic(&path, &vec!["first"]).unwrap();
+        write_json_atomic(&path, &vec!["second"]).unwrap();
+        let back: Vec<String> = read_json(&path).unwrap();
+        assert_eq!(back, vec!["second"]);
+        // The rename must have consumed the temp file; a leftover would
+        // accumulate one stale sibling per write.
+        let strays: Vec<_> = std::fs::read_dir(tmp.path())
+            .unwrap()
+            .filter_map(|e| e.ok())
+            .map(|e| e.file_name().to_string_lossy().to_string())
+            .filter(|n| n.ends_with(".tmp"))
+            .collect();
+        assert!(strays.is_empty(), "temp files left behind: {strays:?}");
+    }
 }
diff --git a/src-tauri/src/sysstat.rs b/src-tauri/src/sysstat.rs
index be13eca..dd34aea 100644
--- a/src-tauri/src/sysstat.rs
+++ b/src-tauri/src/sysstat.rs
@@ -1,20 +1,136 @@
-//! Lightweight per-process CPU sampling via `/proc` (Linux only).
+//! Lightweight per-process CPU/memory sampling for the project resource readout.
 //!
-//! Used to surface a project's live CPU usage in the project-switcher pill popup.
-//! A project's "processes" are the PTY child shells plus every descendant they
-//! have spawned (an agent CLI, its subprocesses, etc.), so usage reflects the
-//! whole working tree rooted at the project's terminals.
+//! Used to surface a project's live CPU/RSS usage in the project-switcher pill
+//! popup. A project's "processes" are the PTY child shells plus every descendant
+//! they have spawned (an agent CLI, its subprocesses, etc.), so usage reflects
+//! the whole working tree rooted at the project's terminals.
 //!
-//! On non-Linux targets these helpers are absent; the calling command returns 0.
-
-#![cfg(target_os = "linux")]
+//! The platform-neutral layer (process-tree cache + BFS, sum helpers) is shared;
+//! the actual sampling is delegated to a per-OS [`platform`] backend:
+//! - **Linux** reads `/proc` (`stat`/`status`/`cmdline`).
+//! - **Windows** uses ToolHelp snapshots + `GetProcessTimes`/`GetProcessMemoryInfo`.
+//! - **Any other OS** falls back to empty/zero results, so callers degrade to a
+//!   `0` readout instead of failing to build.
+//!
+//! CPU time is reported in opaque "ticks": [`sum_jiffies`] returns a tick count
+//! and [`clk_tck`] the ticks-per-second, so the caller's
+//! `busy_secs = ticks / clk_tck()` formula is correct on every backend (Linux
+//! jiffies + USER_HZ; Windows 100-ns units + 10_000_000).
 
+use serde::Serialize;
 use std::collections::HashMap;
-use std::fs;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 
+/// Cumulative CPU jiffies for one core (or the machine aggregate), as read from
+/// `/proc/stat`. `busy = total − idle − iowait`. CPU **percentages** are derived
+/// on the frontend from the delta of two successive snapshots
+/// (`(busy_now − busy_prev) / (total_now − total_prev)`), so these counters carry
+/// no timestamp of their own — the ratio is wall-clock-independent.
+#[derive(Serialize, Clone, Copy, Default)]
+pub struct CpuTimes {
+    pub busy: u64,
+    pub total: u64,
+}
+
+/// One process in a [`SystemSnapshot`]. `cpu_jiffies` is the cumulative
+/// utime+stime; the frontend turns successive samples into a live CPU%.
+#[derive(Serialize, Clone, Default)]
+pub struct ProcSample {
+    pub pid: u32,
+    pub ppid: u32,
+    pub comm: String,
+    pub cmdline: String,
+    pub state: String,
+    pub rss_kib: u64,
+    pub cpu_jiffies: u64,
+    pub threads: u32,
+    /// Owning user's name, resolved from the machine's own passwd database
+    /// (`/etc/passwd` locally, `getent passwd` on a remote host) so the pane can
+    /// group the process table by user — the same per-user "who's loading the
+    /// host" statistic the connect-time usage dialog shows. Empty when the
+    /// backend can't resolve an owner (Windows/macOS, an unmapped uid), which the
+    /// frontend reads as "no per-user data" and hides the section. An unmapped
+    /// uid falls back to `#<uid>` rather than an empty string.
+    #[serde(default)]
+    pub user: String,
+}
+
+/// One interactive login session on the sampled host, from `who`. Mirrors the
+/// connect-time remote-usage dialog's `UserSession`: `user` is the login name,
+/// `tty` the terminal, `detail` the rest of the `who` line verbatim (login time,
+/// origin `(host)`). Populated **only on the remote path** — the local pane never
+/// shows the "Logged in" panel, since local sampling is always just this user.
+#[derive(Serialize, Clone, Default)]
+pub struct LoginSession {
+    pub user: String,
+    pub tty: String,
+    pub detail: String,
+    /// Whether this session belongs to the account Eldrun is sampling *as* (the
+    /// host's `ME` line — see [`parse_who`]). The pane marks the row "you"; it is
+    /// also what lets the sampling account appear at all on a host where `who`
+    /// has no record of it (the synthesized row below).
+    #[serde(default)]
+    pub is_self: bool,
+}
+
+/// A single whole-system sample backing the htop-like monitor pane. Everything
+/// here is a *cumulative* counter or an instantaneous gauge; the pane computes
+/// per-core and per-process CPU% by diffing two of these (see the module notes on
+/// [`CpuTimes`]). `supported` is `false` on platforms without a `/proc`-style
+/// enumeration, letting the UI show a graceful "Linux only" placeholder.
+#[derive(Serialize, Clone, Default)]
+pub struct SystemSnapshot {
+    pub supported: bool,
+    pub clk_tck: u64,
+    pub num_cores: u32,
+    pub cpu: CpuTimes,
+    pub per_core: Vec<CpuTimes>,
+    pub mem_total_kib: u64,
+    pub mem_available_kib: u64,
+    pub swap_total_kib: u64,
+    pub swap_free_kib: u64,
+    pub load_avg: [f64; 3],
+    pub uptime_secs: f64,
+    pub processes: Vec<ProcSample>,
+    /// Every GPU the machine will report memory for; empty when none can be read
+    /// (macOS, an Intel-only box, no `nvidia-smi`). See [`crate::gpustat`].
+    pub gpus: Vec<crate::gpustat::GpuSample>,
+    /// Per-process GPU memory. Populated only on the **remote** path (sampled on
+    /// the host alongside the snapshot); the local pane fills it from the dedicated
+    /// `gpu_process_snapshot` command instead, so this stays empty locally.
+    #[serde(default)]
+    pub gpu_procs: Vec<crate::gpustat::GpuProc>,
+    /// Whole-package CPU temperature in °C, when a CPU hwmon sensor exposes one
+    /// (`coretemp` on Intel, `k10temp`/`zenpower` on AMD Zen). `None` when no such
+    /// sensor is present, or on a backend that can't read one (Windows/macOS/other)
+    /// — never a fake zero, matching the GPU sensors.
+    #[serde(default)]
+    pub cpu_temp_c: Option<f64>,
+    /// Hottest DIMM temperature in °C, when the board exposes an on-module thermal
+    /// sensor (`jc42` on DDR3/DDR4, `spd5118` on DDR5). The *max* across modules, so
+    /// it reads as "how hot is memory". `None` when no such sensor is present (most
+    /// desktops don't wire one) or the backend can't read one — never a fake zero.
+    #[serde(default)]
+    pub mem_temp_c: Option<f64>,
+    /// Interactive login sessions on the host (from `who`), backing the pane's
+    /// "Logged in" panel — the same per-user session view the connect-time
+    /// remote-usage dialog shows. Populated only on the **remote** path; empty
+    /// locally (the panel is remote-only, since local sampling is always just this
+    /// user, so it would be a single trivial row).
+    #[serde(default)]
+    pub sessions: Vec<LoginSession>,
+    /// Whether the sample was taken in **careful mode** — the reduced collection
+    /// an HPC login node's usage rules require (see [`REMOTE_SNAPSHOT_SCRIPT`]
+    /// and `docs/context/hpc_careful_mode.md`). Decided by the *host* (SLURM on
+    /// `PATH`), so the pane learns it from the first sample rather than being
+    /// told; it then polls more gently and says what it is (and isn't) showing.
+    /// Always `false` for a local sample — this machine is the user's own.
+    #[serde(default)]
+    pub careful: bool,
+}
+
 /// Generation counter bumped whenever a PTY is spawned or dies (see
 /// [`invalidate_descendant_cache`]). A change forces [`descendant_pids`] to
 /// rebuild its cached process tree instead of reusing the previous walk.
@@ -44,21 +160,16 @@ pub fn invalidate_descendant_cache() {
     PROC_TREE_GEN.fetch_add(1, Ordering::Relaxed);
 }
 
-/// Kernel clock ticks per second (USER_HZ). Used to convert jiffies → seconds.
+/// Ticks per second for the current backend (Linux USER_HZ, Windows 100-ns
+/// units). Used to convert [`sum_jiffies`] ticks → seconds.
 pub fn clk_tck() -> u64 {
-    // SAFETY: sysconf is async-signal-safe and takes no pointers.
-    let v = unsafe { libc::sysconf(libc::_SC_CLK_TCK) };
-    if v > 0 {
-        v as u64
-    } else {
-        100
-    }
+    platform::clk_tck()
 }
 
 /// All pids that are `roots` or descendants of a root, deduplicated.
 ///
-/// Resolving the tree means walking all of `/proc`, which is the per-sample hot
-/// path. To avoid repeating that walk on every CPU sample (e.g. each pill hover),
+/// Resolving the tree means enumerating every process, which is the per-sample
+/// hot path. To avoid repeating that on every CPU sample (e.g. each pill hover),
 /// the result is cached keyed by the (sorted) root set. The cache is reused while
 /// (a) the spawn/death generation counter is unchanged — the PTY layer calls
 /// [`invalidate_descendant_cache`] on every spawn/death — and (b) the entry is
@@ -97,25 +208,12 @@ pub fn descendant_pids(roots: &[u32]) -> Vec<u32> {
     pids
 }
 
-/// Walk `/proc` once to build a pid → ppid map, then collect every pid whose
-/// ancestor chain reaches one of the roots. The uncached core of
-/// [`descendant_pids`].
+/// Build a pid → ppid map from the backend, then collect every pid whose ancestor
+/// chain reaches one of the roots. The uncached core of [`descendant_pids`].
 fn compute_descendant_pids(roots: &[u32]) -> Vec<u32> {
     use std::collections::{HashSet, VecDeque};
 
-    // pid → ppid for every live process.
-    let mut parent: HashMap<u32, u32> = HashMap::new();
-    if let Ok(entries) = fs::read_dir("/proc") {
-        for entry in entries.flatten() {
-            let name = entry.file_name();
-            let Some(pid) = name.to_str().and_then(|s| s.parse::<u32>().ok()) else {
-                continue;
-            };
-            if let Some(ppid) = read_ppid(pid) {
-                parent.insert(pid, ppid);
-            }
-        }
-    }
+    let parent = platform::parent_map();
 
     // children adjacency for a single BFS pass.
     let mut children: HashMap<u32, Vec<u32>> = HashMap::new();
@@ -142,86 +240,1972 @@ fn compute_descendant_pids(roots: &[u32]) -> Vec<u32> {
     seen.into_iter().collect()
 }
 
-/// Sum of utime + stime (in jiffies) across `pids`. Dead pids are skipped.
+/// Sum of busy CPU ticks across `pids` (Linux utime+stime jiffies; Windows
+/// kernel+user 100-ns units). Dead pids are skipped.
 pub fn sum_jiffies(pids: &[u32]) -> u64 {
-    pids.iter().filter_map(|&pid| read_proc_time(pid)).sum()
+    pids.iter().filter_map(|&pid| platform::proc_ticks(pid)).sum()
 }
 
 /// Sum resident memory across `pids`, in KiB. Dead pids are skipped.
 pub fn sum_rss_kib(pids: &[u32]) -> u64 {
-    pids.iter().filter_map(|&pid| read_rss_kib(pid)).sum()
+    pids.iter().filter_map(|&pid| platform::rss_kib(pid)).sum()
 }
 
-/// Parent pid for a live process.
+/// Parent pid for a live process, if resolvable on this backend.
 pub fn ppid(pid: u32) -> Option<u32> {
-    read_ppid(pid)
+    platform::ppid(pid)
 }
 
-/// Command line for a live process, with NUL separators normalized to spaces.
+/// Command line for a live process, if resolvable on this backend.
 pub fn cmdline(pid: u32) -> Option<String> {
-    let bytes = fs::read(format!("/proc/{pid}/cmdline")).ok()?;
-    if bytes.is_empty() {
+    platform::cmdline(pid)
+}
+
+/// A whole-system sample (all processes + per-core CPU + memory/load) for the
+/// htop-like monitor pane. Delegates to the per-OS backend; non-`/proc` targets
+/// return `SystemSnapshot { supported: false, .. }`.
+///
+/// The GPUs are stapled on here rather than inside each backend: they are read
+/// from a different place entirely ([`crate::gpustat`] — DRM sysfs or
+/// `nvidia-smi`, both of which have their own per-OS story) and an empty list is
+/// a legitimate answer on every platform, including a supported one.
+pub fn system_snapshot() -> SystemSnapshot {
+    let mut snapshot = platform::system_snapshot();
+    snapshot.gpus = crate::gpustat::snapshot();
+    snapshot
+}
+
+// ── Pure `/proc` parsers ─────────────────────────────────────────────────────
+// Factored out of the Linux backend so they can be unit-tested from string
+// fixtures without a live `/proc`. Compiled on *every* host OS (not just Linux)
+// because `parse_remote_snapshot` reuses them to parse a remote Linux host's
+// `/proc` fetched over SSH — the host is Linux even when this machine is not.
+
+/// Parse one `cpu`/`cpuN` line of `/proc/stat` into cumulative busy/total ticks.
+/// `total` is the sum of every column; `busy = total − idle − iowait`.
+fn parse_cpu_line(line: &str) -> Option<CpuTimes> {
+    let mut it = line.split_whitespace();
+    it.next()?; // "cpu" / "cpuN" label
+    let nums: Vec<u64> = it.filter_map(|t| t.parse::<u64>().ok()).collect();
+    if nums.len() < 4 {
         return None;
     }
-    let cmd = bytes
-        .split(|b| *b == 0)
-        .filter(|part| !part.is_empty())
-        .map(|part| String::from_utf8_lossy(part))
-        .collect::<Vec<_>>()
-        .join(" ");
-    if cmd.is_empty() { None } else { Some(cmd) }
-}
-
-/// Parent pid from `/proc/<pid>/stat` (field 4, after the comm field).
-fn read_ppid(pid: u32) -> Option<u32> {
-    let stat = fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
-    // comm (field 2) may contain spaces/parens, so split after the last ')'.
-    let rest = stat.rsplit_once(')')?.1;
-    // rest = " S <ppid> ..." → fields[0]="" , [1]=state, [2]=ppid
-    rest.split_whitespace().nth(1)?.parse().ok()
-}
-
-/// utime + stime (jiffies) from `/proc/<pid>/stat` (fields 14 and 15).
-fn read_proc_time(pid: u32) -> Option<u64> {
-    let stat = fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
-    let rest = stat.rsplit_once(')')?.1;
-    let fields: Vec<&str> = rest.split_whitespace().collect();
-    // After ')' fields are 1-indexed as in proc(5): [0]=state(field 3).
-    // utime=field 14 → index 11, stime=field 15 → index 12.
+    let total: u64 = nums.iter().sum();
+    let idle = nums[3];
+    let iowait = nums.get(4).copied().unwrap_or(0);
+    Some(CpuTimes {
+        busy: total.saturating_sub(idle).saturating_sub(iowait),
+        total,
+    })
+}
+
+/// Parse `/proc/stat` into (aggregate, per-core) cumulative CPU times. The
+/// aggregate is the `cpu ` line; each `cpuN` line is one core, in order.
+fn parse_cpu_stat(content: &str) -> (CpuTimes, Vec<CpuTimes>) {
+    let mut agg = CpuTimes::default();
+    let mut per_core = Vec::new();
+    for line in content.lines() {
+        let Some(rest) = line.strip_prefix("cpu") else {
+            continue;
+        };
+        match rest.chars().next() {
+            Some(' ') => {
+                if let Some(ct) = parse_cpu_line(line) {
+                    agg = ct;
+                }
+            }
+            Some(c) if c.is_ascii_digit() => {
+                if let Some(ct) = parse_cpu_line(line) {
+                    per_core.push(ct);
+                }
+            }
+            _ => {}
+        }
+    }
+    (agg, per_core)
+}
+
+/// Extract (MemTotal, MemAvailable, SwapTotal, SwapFree) from `/proc/meminfo`,
+/// all in KiB. Missing keys default to 0.
+fn parse_meminfo(content: &str) -> (u64, u64, u64, u64) {
+    let get = |key: &str| -> u64 {
+        content
+            .lines()
+            .find_map(|l| l.strip_prefix(key))
+            .and_then(|r| r.split_whitespace().next())
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(0)
+    };
+    (
+        get("MemTotal:"),
+        get("MemAvailable:"),
+        get("SwapTotal:"),
+        get("SwapFree:"),
+    )
+}
+
+/// First three floats of `/proc/loadavg` (1/5/15-minute load averages).
+fn parse_loadavg(content: &str) -> [f64; 3] {
+    let mut it = content.split_whitespace();
+    let mut next = || it.next().and_then(|v| v.parse::<f64>().ok()).unwrap_or(0.0);
+    [next(), next(), next()]
+}
+
+/// Parse a `/proc/<pid>/stat` line into (comm, state, ppid, cpu_jiffies,
+/// threads). `comm` sits between the first `(` and last `)` and may itself
+/// contain spaces/parens, so fields are indexed *after* the last `)`:
+/// index 0 = state (field 3), 1 = ppid (field 4), 11 = utime (14),
+/// 12 = stime (15), 17 = num_threads (20).
+fn parse_pid_stat(content: &str) -> Option<(String, String, u32, u64, u32)> {
+    let open = content.find('(')?;
+    let close = content.rfind(')')?;
+    let comm = content.get(open + 1..close)?.to_string();
+    let fields: Vec<&str> = content.get(close + 1..)?.split_whitespace().collect();
+    let state = (*fields.first()?).to_string();
+    let ppid: u32 = fields.get(1)?.parse().ok()?;
     let utime: u64 = fields.get(11)?.parse().ok()?;
     let stime: u64 = fields.get(12)?.parse().ok()?;
-    Some(utime + stime)
+    let threads: u32 = fields.get(17)?.parse().ok()?;
+    Some((comm, state, ppid, utime + stime, threads))
+}
+
+/// Parse `getent passwd` / `/etc/passwd` content into a uid → username map. Each
+/// line is `name:passwd:uid:gid:gecos:home:shell`; only `name` (field 0) and
+/// `uid` (field 2) are read, malformed lines skipped. The *first* name wins when
+/// two entries share a uid (a deliberate alias), so the mapping is stable.
+fn parse_passwd(content: &str) -> HashMap<u32, String> {
+    let mut map: HashMap<u32, String> = HashMap::new();
+    for line in content.lines() {
+        let mut it = line.split(':');
+        let name = it.next().unwrap_or("");
+        let _passwd = it.next();
+        let Some(uid) = it.next().and_then(|s| s.trim().parse::<u32>().ok()) else {
+            continue;
+        };
+        if !name.is_empty() {
+            map.entry(uid).or_insert_with(|| name.to_string());
+        }
+    }
+    map
+}
+
+/// Resolve a numeric uid to a display name via a passwd map, falling back to
+/// `#<uid>` for a uid the map doesn't cover (an NSS-only account the file walk
+/// missed, or a process whose owner was removed) rather than an empty string.
+/// The one label every foreign process carries in careful mode. Not a user name
+/// and deliberately not a uid: the point is that a careful sample can say how
+/// loaded the machine is without attributing any of that load to a person.
+pub const OTHER_USERS: &str = "other users";
+
+fn username_for(uid: u32, map: &HashMap<u32, String>) -> String {
+    map.get(&uid)
+        .cloned()
+        .unwrap_or_else(|| format!("#{uid}"))
+}
+
+/// The `tty`/`detail` a synthesized self-session carries — the row that says "you
+/// are on this host" when `who` has no record of the sampling account (see
+/// [`parse_who`]). Not a terminal name, because there is no terminal: it is the
+/// pooled SSH connection this very sample arrived over.
+const SELF_SESSION_TTY: &str = "ssh";
+const SELF_SESSION_DETAIL: &str = "(this Eldrun connection — no tty)";
+
+/// Parse `who` output into one [`LoginSession`] per non-blank line. Each line is
+/// `user  tty  <login-time> (<origin>)`; the first two whitespace fields are the
+/// user and tty, everything after is kept verbatim as `detail`. Matches
+/// `services::remote_usage::parse_who` so the pane's "Logged in" panel reads
+/// identically to the connect-time dialog's.
+///
+/// `me` is the sampling account's login name **on that host** (the script's `ME`
+/// line), and it is what fixes the panel's oldest oddity: it listed everyone
+/// *except* the person reading it. `who` reports utmp, and utmp only gets an entry
+/// when sshd allocates a **pty** — the monitor's own probe (and the pooled
+/// ControlMaster behind it) runs without one, so unless the user happens to have an
+/// interactive terminal tab open on that host, their own presence is invisible while
+/// every other logged-in person shows. So a matching row is flagged `is_self`, and
+/// when there is no matching row at all one is **synthesized**: the connection this
+/// snapshot arrived over is a real session on that machine, it simply is not one
+/// utmp records. On a careful (HPC) host, where `who` is pre-filtered to this
+/// account, that synthesized row is also what turns a panel reading "no interactive
+/// logins" into the truthful "you, and nothing collected about anyone else".
+fn parse_who(content: &str, me: &str) -> Vec<LoginSession> {
+    let mut sessions: Vec<LoginSession> = content
+        .lines()
+        .filter(|l| !l.trim().is_empty())
+        .filter_map(|l| {
+            let mut parts = l.split_whitespace();
+            let user = parts.next()?.to_string();
+            let tty = parts.next().unwrap_or("").to_string();
+            let detail = parts.collect::<Vec<_>>().join(" ");
+            let is_self = !me.is_empty() && user == me;
+            Some(LoginSession {
+                user,
+                tty,
+                detail,
+                is_self,
+            })
+        })
+        .collect();
+    if !me.is_empty() && !sessions.iter().any(|s| s.is_self) {
+        sessions.insert(
+            0,
+            LoginSession {
+                user: me.to_string(),
+                tty: SELF_SESSION_TTY.to_string(),
+                detail: SELF_SESSION_DETAIL.to_string(),
+                is_self: true,
+            },
+        );
+    }
+    sessions
+}
+
+/// hwmon `name` values that identify a CPU **package** temperature sensor: Intel
+/// exposes `coretemp`, AMD Zen `k10temp` (or the out-of-tree `zenpower`), some
+/// ARM/embedded boards `cpu_thermal`. Anything else (a GPU's `amdgpu`, a
+/// mainboard SuperIO chip, an NVMe drive) is deliberately excluded — a wrong
+/// sensor reported as "CPU" is worse than reporting none.
+fn is_cpu_hwmon(name: &str) -> bool {
+    matches!(name.trim(), "coretemp" | "k10temp" | "zenpower" | "cpu_thermal")
+}
+
+/// hwmon `name` values that identify an on-DIMM **memory** temperature sensor:
+/// `jc42` (the JEDEC JC42.4 sensor on DDR3/DDR4 modules) and `spd5118` (the DDR5
+/// SPD-hub temperature sensor). One hwmon appears per populated module that has
+/// one, so the reader takes the *hottest*. Anything else is excluded — a
+/// mainboard/SuperIO channel mislabelled as memory would be worse than none.
+fn is_mem_hwmon(name: &str) -> bool {
+    matches!(name.trim(), "jc42" | "spd5118")
+}
+
+/// Choose the reading that best represents the whole CPU package from one hwmon's
+/// temperature channels, each a `(label, milli_celsius)` pair. Prefers an explicit
+/// package/control label — `Package id 0` (Intel `coretemp`), `Tctl`/`Tdie` (AMD
+/// `k10temp`) — over a per-core channel; failing that, the first channel
+/// (`temp1_input`), which is the package on a single-channel sensor. Returns °C
+/// (millidegrees ÷ 1000), or `None` when there are no channels.
+fn pick_cpu_temp(channels: &[(Option<String>, f64)]) -> Option<f64> {
+    let preferred = channels.iter().find(|(label, _)| {
+        label.as_deref().is_some_and(|l| {
+            let l = l.trim();
+            l.starts_with("Package") || l == "Tctl" || l == "Tdie"
+        })
+    });
+    preferred
+        .or_else(|| channels.first())
+        .map(|(_, milli)| milli / 1000.0)
+}
+
+// ── Remote (`ssh`) whole-system snapshot ────────────────────────────────────
+// A remote project's System Monitor reads the *host's* `/proc` over the shared
+// ControlMaster, exactly as the Disk Usage pane reads the host's `du`. The
+// snapshot shape is identical to the local one, so the frontend pane needs no
+// per-source branch — only the pure parsers above, fed the host's `/proc` bytes.
+
+/// POSIX-`sh` script run on the host (via `services::ssh_exec::run_remote_script`)
+/// to capture one whole-system sample from its `/proc`.
+///
+/// **Constant** — `run_remote_script` embeds it verbatim (no quoting), so nothing
+/// may be interpolated in; the only variable in that call is the `cd`-target
+/// `remote_path`, which it quotes and which this script ignores. Output is
+/// line-oriented and consumed by [`parse_remote_snapshot`]: a `CLK` line, then the
+/// `@SECTION@` blocks carrying the raw kernel files verbatim. `@GPU@` carries the
+/// host's GPUs — `NVSMI`/`NVPROC` lines are the `nvidia-smi` CSV verbatim (reusing
+/// the same parsers as the local read), and `AMD\t<card>\t<key>\t<value>` lines
+/// ship one DRM sysfs file each so `parse_drm_card` runs unchanged on them. The
+/// `@WHO@` block carries the host's `who` output verbatim for the pane's "Logged
+/// in" panel ([`parse_who`]), preceded by an `ME` line naming the account the
+/// script is running as — `who` reports utmp, which has no entry for a session
+/// without a pty, so without it the one person the panel could never list was the
+/// user reading it. The
+/// `@PASSWD@` block ships the host's `getent passwd` (or `/etc/passwd`) verbatim so
+/// [`parse_passwd`] can map each process's owner uid to a name on the *host's*
+/// account database, not this machine's.
+///
+/// **The process walk is fork-bounded, and that is the whole point.** Under
+/// `@PROCS@` comes one `S`/`U`/`R` line per process, each *keyed by pid*
+/// (`<tag>\t<pid>\t<value>`): the raw `/proc/<pid>/stat` line, the owner uid from
+/// `/proc/<pid>/status`, and `VmRSS` in KiB. All three come from a **single**
+/// `awk` that walks every `/proc/<pid>` itself via `getline`. The earlier shape —
+/// a `sh` loop forking `cat` + `awk` + `tr` *per process* — cost ~3 execs per pid,
+/// which on a busy multi-user host (an HPC login node) is thousands of process
+/// spawns every poll: measured at **2.3 s of host CPU for 544 processes**, i.e.
+/// ~78% of a core sustained against this pane's 3 s cadence. The same capture as
+/// one `awk` pass measures ~0.02 s. A poll must cost the host less than the host
+/// is worth watching for.
+///
+/// Cmdlines therefore ride their own `@CMDLINE@` block, captured by **one**
+/// `grep -aH '' /proc/[0-9]*/cmdline` piped through **one** `tr '\0' ' '` (NULs
+/// become spaces so each process stays on one line, as before). They are keyed by
+/// the `/proc/<pid>/cmdline:` prefix grep emits rather than zipped positionally
+/// with `@PROCS@`, because a kernel thread's cmdline is empty and so contributes
+/// no line at all — the two blocks genuinely do not line up. A host with no
+/// `grep` degrades to every process showing its `[comm]`, never to a wrong name.
+///
+/// `@PASSWD2@`, shipped *after* `@PROCS@`, resolves each uid the walk actually saw
+/// via a **targeted** `getent passwd <uid>` lookup — the supplement that makes the
+/// "Logged in" panel's per-user CPU/MEM match `who`'s names on an NSS setup that
+/// serves point lookups but not enumeration (SSSD's default `enumerate = false`,
+/// common on LDAP-backed and HPC/institutional hosts): a bare `getent
+/// passwd`/`/etc/passwd` dump then lists only local accounts, so a directory-backed
+/// user's processes fall back to `#<uid>` and never match their `who` session name,
+/// reading as a permanently 0% row. It is **one** `getent` for every uid at once
+/// (it takes many keys), not one per uid — the same fork-per-item trap, and on a
+/// directory-backed host each of those forks was also an LDAP round trip.
+/// `parse_remote_snapshot` defers owner resolution until both blocks have arrived,
+/// merging `@PASSWD2@` into whatever `@PASSWD@` left unmapped.
+///
+/// A process whose `status` withheld `Uid:` ships **no** `U` line rather than a
+/// `0`, which would silently read as root; the parser leaves such an owner blank.
+/// The `/proc/[0-9]*` globs are now `exec` **arguments** rather than shell-loop
+/// iterations, so they are bounded by `ARG_MAX` where the old loop was not — at
+/// ~21 bytes per pid against a typical 2 MB limit that is ~100k processes, some
+/// 20× beyond any host this pane is pointed at, but it is the reason the walk is
+/// two awk invocations over one glob each and not one over several.
+/// The script also ends in a `:` so its exit status is always 0 — the
+/// global-machine path (`run_ssh_auth` → `capture`) treats a non-zero remote exit
+/// as a failed probe, and a trailing `getent` that simply found no match must not
+/// discard an otherwise complete snapshot.
+///
+/// ## Careful mode (HPC hosts)
+///
+/// A shared cluster login node is not an ordinary dev box: its usage rules forbid
+/// determining other users' account names and using information about them that
+/// happens to be readable, and its operators expect a login node not to carry a
+/// sustained background load (`docs/context/hpc_careful_mode.md`). So on a host
+/// that looks like a cluster — SLURM on `PATH` — this script **collects less**:
+///
+/// * `@PASSWD@` ships only the *sampling* user's own entry, never the directory
+///   dump, and `@PASSWD2@` (the per-uid supplement) is skipped entirely, so no
+///   foreign account name is ever read;
+/// * `@CMDLINE@` covers only the sampling user's own processes — a foreign
+///   process ships no argv, and its `comm` is redacted to `(other)` inside the
+///   `@PROCS@` walk, so what other people run never leaves the cluster;
+/// * a foreign process ships **no** `U` line, so it cannot be attributed to a
+///   person; the parser buckets all of them into one `other users` row, which is
+///   the only figure the pane actually needs from them ("how much of this machine
+///   isn't mine");
+/// * `@WHO@` is filtered to the sampling user's own sessions, and `nvidia-smi`'s
+///   per-process query (`NVPROC`) is not run at all.
+///
+/// The mode is reported back on the leading `CAREFUL` line so the pane can also
+/// poll more gently (`SystemMonitorPane`'s `CAREFUL_POLL_MS`) and say what it is
+/// doing.
+///
+/// **Who decides.** The `sbatch` probe below is now only a fallback: the monitor
+/// passes the machine's stored mode on every poll ([`remote_snapshot_script`]),
+/// and careful is the default for every remote machine — so the probe matters
+/// only for a caller with no answer to pass. That is why the script reads
+/// `ELDRUN_CAREFUL` *before* probing, and why an explicit `0` has to be honoured
+/// as well as an explicit `1`: without it, a machine the user owns and told
+/// Eldrun to read fully would still be redacted the moment it happened to have a
+/// scheduler installed.
+pub const REMOTE_SNAPSHOT_SCRIPT: &str = r#"
+_careful="${ELDRUN_CAREFUL:-}"
+if [ -z "$_careful" ]; then
+  if command -v sbatch >/dev/null 2>&1 || command -v sinfo >/dev/null 2>&1 \
+     || command -v squeue >/dev/null 2>&1; then _careful=1; else _careful=0; fi
+fi
+_myuid=$(id -u 2>/dev/null || echo -1)
+_myname=$(id -un 2>/dev/null || echo '')
+printf 'CAREFUL\t%s\n' "$_careful"
+printf 'ME\t%s\n' "$_myname"
+printf 'CLK\t%s\n' "$(getconf CLK_TCK 2>/dev/null || echo 100)"
+printf '@STAT@\n'; cat /proc/stat 2>/dev/null
+printf '@MEM@\n'; cat /proc/meminfo 2>/dev/null
+printf '@LOAD@\n'; cat /proc/loadavg 2>/dev/null
+printf '@UP@\n'; cat /proc/uptime 2>/dev/null
+printf '@WHO@\n'
+if [ "$_careful" = 1 ]; then
+  who 2>/dev/null | awk -v me="$_myname" '$1 == me'
+else
+  who 2>/dev/null
+fi
+printf '@GPU@\n'
+if command -v nvidia-smi >/dev/null 2>&1; then
+  nvidia-smi --query-gpu=name,memory.used,memory.total,utilization.gpu,temperature.gpu,power.draw,power.limit,clocks.sm,clocks.mem,fan.speed,driver_version,pcie.link.gen.current,pcie.link.width.current --format=csv,noheader,nounits 2>/dev/null | sed 's/^/NVSMI\t/'
+  if [ "$_careful" != 1 ]; then
+    nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv,noheader,nounits 2>/dev/null | sed 's/^/NVPROC\t/'
+  fi
+fi
+for c in /sys/class/drm/card[0-9]*; do
+  d="$c/device"
+  [ -r "$d/mem_info_vram_total" ] || continue
+  i=${c##*/}; i=${i#card}
+  h=$(ls -d "$d"/hwmon/hwmon* 2>/dev/null | head -n1)
+  printf 'AMD\t%s\tdriver\t%s\n' "$i" "$(sed -n 's/^DRIVER=//p' "$d/uevent" 2>/dev/null)"
+  printf 'AMD\t%s\tvendor\t%s\n' "$i" "$(cat "$d/vendor" 2>/dev/null)"
+  printf 'AMD\t%s\tdevice\t%s\n' "$i" "$(cat "$d/device" 2>/dev/null)"
+  printf 'AMD\t%s\tvram_used\t%s\n' "$i" "$(cat "$d/mem_info_vram_used" 2>/dev/null)"
+  printf 'AMD\t%s\tvram_total\t%s\n' "$i" "$(cat "$d/mem_info_vram_total" 2>/dev/null)"
+  printf 'AMD\t%s\tgtt_used\t%s\n' "$i" "$(cat "$d/mem_info_gtt_used" 2>/dev/null)"
+  printf 'AMD\t%s\tgtt_total\t%s\n' "$i" "$(cat "$d/mem_info_gtt_total" 2>/dev/null)"
+  printf 'AMD\t%s\tbusy\t%s\n' "$i" "$(cat "$d/gpu_busy_percent" 2>/dev/null)"
+  printf 'AMD\t%s\tsclk\t%s\n' "$i" "$(grep '\*' "$d/pp_dpm_sclk" 2>/dev/null | head -n1)"
+  printf 'AMD\t%s\tmclk\t%s\n' "$i" "$(grep '\*' "$d/pp_dpm_mclk" 2>/dev/null | head -n1)"
+  printf 'AMD\t%s\tlink_speed\t%s\n' "$i" "$(cat "$d/current_link_speed" 2>/dev/null)"
+  printf 'AMD\t%s\tlink_width\t%s\n' "$i" "$(cat "$d/current_link_width" 2>/dev/null)"
+  printf 'AMD\t%s\ttemp\t%s\n' "$i" "$(cat "$h/temp1_input" 2>/dev/null)"
+  printf 'AMD\t%s\tpower\t%s\n' "$i" "$(cat "$h/power1_average" 2>/dev/null || cat "$h/power1_input" 2>/dev/null)"
+  printf 'AMD\t%s\tpower_cap\t%s\n' "$i" "$(cat "$h/power1_cap" 2>/dev/null)"
+  printf 'AMD\t%s\tpwm\t%s\n' "$i" "$(cat "$h/pwm1" 2>/dev/null)"
+  printf 'AMD\t%s\tpwm_max\t%s\n' "$i" "$(cat "$h/pwm1_max" 2>/dev/null)"
+done
+printf '@CPUTEMP@\n'
+for h in /sys/class/hwmon/hwmon*; do
+  n=$(cat "$h/name" 2>/dev/null)
+  case "$n" in coretemp|k10temp|zenpower|cpu_thermal) ;; *) continue ;; esac
+  for t in "$h"/temp*_input; do
+    [ -r "$t" ] || continue
+    printf 'T\t%s\t%s\n' "$(cat "${t%_input}_label" 2>/dev/null)" "$(cat "$t" 2>/dev/null)"
+  done
+done
+printf '@MEMTEMP@\n'
+for h in /sys/class/hwmon/hwmon*; do
+  n=$(cat "$h/name" 2>/dev/null)
+  case "$n" in jc42|spd5118) ;; *) continue ;; esac
+  printf 'M\t%s\n' "$(cat "$h/temp1_input" 2>/dev/null)"
+done
+printf '@PASSWD@\n'
+if [ "$_careful" = 1 ]; then
+  getent passwd "$_myuid" 2>/dev/null
+else
+  getent passwd 2>/dev/null || cat /etc/passwd 2>/dev/null
+fi
+printf '@PROCS@\n'
+awk -v careful="$_careful" -v me="$_myuid" '
+BEGIN {
+  careful = careful + 0; me = me + 0
+  for (i = 1; i < ARGC; i++) {
+    d = ARGV[i]
+    if ((getline s < (d "/stat")) <= 0) { close(d "/stat"); continue }
+    close(d "/stat")
+    if (s == "") continue
+    p = substr(d, 7)
+    u = -1; r = 0
+    while ((getline l < (d "/status")) > 0) {
+      if (l ~ /^Uid:/) { split(l, f, "[ \t]+"); u = f[2] + 0 }
+      else if (l ~ /^VmRSS:/) { split(l, f, "[ \t]+"); r = f[2] + 0 }
+    }
+    close(d "/status")
+    mine = (u == me)
+    if (careful == 1 && !mine) { sub(/\(.*\)/, "(other)", s) }
+    printf "S\t%s\t%s\n", p, s
+    if (u >= 0 && (careful != 1 || mine)) printf "U\t%s\t%s\n", p, u
+    printf "R\t%s\t%s\n", p, r
+  }
+  exit
+}' /proc/[0-9]*
+printf '@CMDLINE@\n'
+if [ "$_careful" = 1 ]; then
+  _mypids=$(ps -u "$_myuid" -o pid= 2>/dev/null)
+  if [ -z "$_mypids" ]; then
+    _mypids=$(awk -v me="$_myuid" '
+BEGIN {
+  me = me + 0
+  for (i = 1; i < ARGC; i++) {
+    d = ARGV[i]; u = -1
+    while ((getline l < (d "/status")) > 0) {
+      if (l ~ /^Uid:/) { split(l, f, "[ \t]+"); u = f[2] + 0; break }
+    }
+    close(d "/status")
+    if (u == me) print substr(d, 7)
+  }
+  exit
+}' /proc/[0-9]*)
+  fi
+  for p in $_mypids; do
+    [ -r "/proc/$p/cmdline" ] || continue
+    printf '/proc/%s/cmdline:' "$p"
+    tr '\0' ' ' < "/proc/$p/cmdline" 2>/dev/null
+    printf '\n'
+  done
+else
+  grep -aH '' /proc/[0-9]*/cmdline 2>/dev/null | tr '\0' ' '
+fi
+printf '@PASSWD2@\n'
+if [ "$_careful" = 1 ]; then
+  :
+else
+_uids=$(awk '
+BEGIN {
+  for (i = 1; i < ARGC; i++) {
+    f = ARGV[i] "/status"
+    while ((getline l < f) > 0) {
+      if (l ~ /^Uid:/) {
+        split(l, a, "[ \t]+")
+        if (!(a[2] in seen)) { seen[a[2]] = 1; printf "%s ", a[2] }
+        break
+      }
+    }
+    close(f)
+  }
+  exit
+}' /proc/[0-9]*)
+if [ -n "$_uids" ]; then getent passwd $_uids 2>/dev/null; fi
+fi
+:
+"#;
+
+/// [`REMOTE_SNAPSHOT_SCRIPT`] with careful mode pinned by the caller, or left to
+/// the host to decide.
+///
+/// `Some(true)`/`Some(false)` pin `ELDRUN_CAREFUL`, so the script skips its own
+/// `sbatch` probe entirely; `None` leaves the probe in place. **Both** directions
+/// are pinnable, which is the change the per-machine switch needed: careful is
+/// now the default for every remote machine (`src/lib/carefulHost.ts`), so the
+/// only way to get a full reading of a machine the user owns is for their answer
+/// to outrank host-side detection. That answer is the *user's*, recorded per SSH
+/// target and deliberate — the asymmetry the old force-on-only signature encoded
+/// (a probe must never talk a cluster down) applies to a guess, not to a person
+/// telling Eldrun whose machine it is.
+///
+/// `None` is now only for a caller with no stored answer to pass on, where the
+/// host's own SLURM check is still the best available signal.
+pub fn remote_snapshot_script(careful: Option<bool>) -> String {
+    match careful {
+        Some(true) => format!("ELDRUN_CAREFUL=1\n{REMOTE_SNAPSHOT_SCRIPT}"),
+        Some(false) => format!("ELDRUN_CAREFUL=0\n{REMOTE_SNAPSHOT_SCRIPT}"),
+        None => REMOTE_SNAPSHOT_SCRIPT.to_string(),
+    }
 }
 
-/// Resident set size from `/proc/<pid>/status`, in KiB.
-fn read_rss_kib(pid: u32) -> Option<u64> {
-    let status = fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
-    for line in status.lines() {
-        let Some(rest) = line.strip_prefix("VmRSS:") else {
+/// Assemble a [`SystemSnapshot`] from the output of [`REMOTE_SNAPSHOT_SCRIPT`],
+/// reusing the same pure `/proc` parsers the local Linux backend uses. `supported`
+/// is always `true` (the host is assumed Linux; a host with no `/proc` simply
+/// yields zeroed CPU/memory and an empty process table). The `@GPU@` block is fed
+/// through the very same `gpustat` parsers as the local read, so a host GPU shows
+/// with the same memory/sensor detail; `gpu_procs` carries the host's per-process
+/// GPU memory (NVIDIA only — the AMD `fdinfo` walk is local-only, too heavy to run
+/// per remote poll).
+pub fn parse_remote_snapshot(raw: &str) -> SystemSnapshot {
+    use std::collections::BTreeMap;
+    enum Sec {
+        None,
+        Stat,
+        Mem,
+        Load,
+        Up,
+        Who,
+        Gpu,
+        CpuTemp,
+        MemTemp,
+        Passwd,
+        Passwd2,
+        Procs,
+        Cmdline,
+    }
+    let mut sec = Sec::None;
+    let mut clk: u64 = 100;
+    // Set by the host's leading `CAREFUL` line: this sample deliberately carries
+    // no third-party account name, argv or session (see `REMOTE_SNAPSHOT_SCRIPT`).
+    let mut careful = false;
+    // The sampling account's login name on the host, from the leading `ME` line;
+    // empty when the host couldn't say (`id -un` failed), which simply leaves the
+    // session rows unflagged rather than inventing an owner.
+    let mut me = String::new();
+    let mut stat_buf = String::new();
+    let mut mem_buf = String::new();
+    let mut load_buf = String::new();
+    let mut up_buf = String::new();
+    let mut who_buf = String::new();
+    // The host's bulk passwd db (shipped under @PASSWD@) and, after @PROCS@, the
+    // targeted per-uid supplement (@PASSWD2@ — see `REMOTE_SNAPSHOT_SCRIPT`'s doc
+    // for why enumeration alone can miss an NSS/LDAP-backed account). Owner
+    // resolution is deferred until both have fully arrived, so `processes` is
+    // built with each entry's raw uid alongside it (`proc_uid`, 1:1 by index) and
+    // resolved to a name in one final pass below.
+    let mut passwd_buf = String::new();
+    let mut passwd2_buf = String::new();
+    let mut processes: Vec<ProcSample> = Vec::new();
+    let mut proc_uid: Vec<Option<u32>> = Vec::new();
+    // GPU accumulators: the `nvidia-smi` CSV rebuilt line-by-line for its parsers,
+    // and one `DrmFiles` per AMD card index assembled from its shipped sysfs files.
+    let mut nvsmi = String::new();
+    let mut nvproc = String::new();
+    let mut amd_cards: BTreeMap<u32, crate::gpustat::DrmFiles> = BTreeMap::new();
+    // CPU hwmon channels shipped as `T\t<label>\t<milli_celsius>` under @CPUTEMP@.
+    let mut cpu_temp_channels: Vec<(Option<String>, f64)> = Vec::new();
+    // Hottest DIMM temp in °C, from `M\t<milli>` lines under @MEMTEMP@ (one per module).
+    let mut mem_temp_c: Option<f64> = None;
+
+    // One accumulator per pid, filled from the pid-keyed `@PROCS@` lines and then
+    // the separate `@CMDLINE@` block. Keyed rather than positional because those
+    // two blocks are captured by two independent passes over `/proc` (see
+    // `REMOTE_SNAPSHOT_SCRIPT`) and a kernel thread appears in only the first, so
+    // there is no position to zip them by.
+    #[derive(Default)]
+    struct ProcAccum {
+        stat: String,
+        uid: Option<u32>,
+        rss_kib: u64,
+        cmdline: Option<String>,
+    }
+    let mut proc_acc: BTreeMap<u32, ProcAccum> = BTreeMap::new();
+
+    for line in raw.lines() {
+        match line {
+            "@STAT@" => {
+                sec = Sec::Stat;
+                continue;
+            }
+            "@MEM@" => {
+                sec = Sec::Mem;
+                continue;
+            }
+            "@LOAD@" => {
+                sec = Sec::Load;
+                continue;
+            }
+            "@UP@" => {
+                sec = Sec::Up;
+                continue;
+            }
+            "@WHO@" => {
+                sec = Sec::Who;
+                continue;
+            }
+            "@GPU@" => {
+                sec = Sec::Gpu;
+                continue;
+            }
+            "@CPUTEMP@" => {
+                sec = Sec::CpuTemp;
+                continue;
+            }
+            "@MEMTEMP@" => {
+                sec = Sec::MemTemp;
+                continue;
+            }
+            "@PASSWD@" => {
+                sec = Sec::Passwd;
+                continue;
+            }
+            "@PASSWD2@" => {
+                sec = Sec::Passwd2;
+                continue;
+            }
+            "@PROCS@" => {
+                sec = Sec::Procs;
+                continue;
+            }
+            "@CMDLINE@" => {
+                sec = Sec::Cmdline;
+                continue;
+            }
+            _ => {}
+        }
+        if let Some(rest) = line.strip_prefix("CAREFUL\t") {
+            careful = rest.trim() == "1";
+            continue;
+        }
+        // Who Eldrun is on this host — the account the "Logged in" panel would
+        // otherwise be the only one never to mention (see `parse_who`).
+        if let Some(rest) = line.strip_prefix("ME\t") {
+            me = rest.trim().to_string();
+            continue;
+        }
+        if let Some(rest) = line.strip_prefix("CLK\t") {
+            if let Ok(v) = rest.trim().parse::<u64>() {
+                if v > 0 {
+                    clk = v;
+                }
+            }
+            continue;
+        }
+        match sec {
+            Sec::Stat => {
+                stat_buf.push_str(line);
+                stat_buf.push('\n');
+            }
+            Sec::Mem => {
+                mem_buf.push_str(line);
+                mem_buf.push('\n');
+            }
+            Sec::Load => {
+                load_buf.push_str(line);
+                load_buf.push('\n');
+            }
+            Sec::Up => {
+                up_buf.push_str(line);
+                up_buf.push('\n');
+            }
+            Sec::Who => {
+                who_buf.push_str(line);
+                who_buf.push('\n');
+            }
+            Sec::Gpu => {
+                if let Some(rest) = line.strip_prefix("NVSMI\t") {
+                    nvsmi.push_str(rest);
+                    nvsmi.push('\n');
+                } else if let Some(rest) = line.strip_prefix("NVPROC\t") {
+                    nvproc.push_str(rest);
+                    nvproc.push('\n');
+                } else if let Some(rest) = line.strip_prefix("AMD\t") {
+                    // `<index>\t<key>\t<value>`; an empty value = a file the host
+                    // didn't expose, so skip it rather than store a blank.
+                    let mut it = rest.splitn(3, '\t');
+                    if let (Some(idx), Some(key), Some(val)) = (it.next(), it.next(), it.next()) {
+                        if !val.is_empty() {
+                            if let Ok(idx) = idx.parse::<u32>() {
+                                crate::gpustat::set_drm_field(
+                                    amd_cards.entry(idx).or_default(),
+                                    key,
+                                    val,
+                                );
+                            }
+                        }
+                    }
+                }
+            }
+            Sec::CpuTemp => {
+                // `T\t<label>\t<milli>`; an empty label ⇒ no `tempN_label` file,
+                // an empty/garbage value ⇒ a channel the host couldn't read (skip).
+                if let Some(rest) = line.strip_prefix("T\t") {
+                    let mut it = rest.splitn(2, '\t');
+                    let label = it.next().unwrap_or("").trim();
+                    if let Some(milli) = it.next().and_then(|v| v.trim().parse::<f64>().ok()) {
+                        let label = (!label.is_empty()).then(|| label.to_string());
+                        cpu_temp_channels.push((label, milli));
+                    }
+                }
+            }
+            Sec::MemTemp => {
+                // `M\t<milli>`; keep the hottest module, skipping blanks/garbage.
+                if let Some(rest) = line.strip_prefix("M\t") {
+                    if let Ok(milli) = rest.trim().parse::<f64>() {
+                        let c = milli / 1000.0;
+                        mem_temp_c = Some(mem_temp_c.map_or(c, |h| h.max(c)));
+                    }
+                }
+            }
+            Sec::Passwd => {
+                passwd_buf.push_str(line);
+                passwd_buf.push('\n');
+            }
+            Sec::Passwd2 => {
+                passwd2_buf.push_str(line);
+                passwd2_buf.push('\n');
+            }
+            Sec::Procs => {
+                // `<tag>\t<pid>\t<value>` — `S` the raw `/proc/<pid>/stat` line,
+                // `U` the owner uid, `R` `VmRSS` in KiB. `S` is what declares a
+                // process exists, so `U`/`R` only ever fill an entry it opened.
+                let mut it = line.splitn(3, '\t');
+                let (Some(tag), Some(pid), Some(val)) = (it.next(), it.next(), it.next()) else {
+                    continue;
+                };
+                let Ok(pid) = pid.trim().parse::<u32>() else {
+                    continue;
+                };
+                match tag {
+                    "S" => proc_acc.entry(pid).or_default().stat = val.to_string(),
+                    "U" => {
+                        if let Some(acc) = proc_acc.get_mut(&pid) {
+                            acc.uid = val.trim().parse().ok();
+                        }
+                    }
+                    "R" => {
+                        if let Some(acc) = proc_acc.get_mut(&pid) {
+                            acc.rss_kib = val.trim().parse().unwrap_or(0);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            Sec::Cmdline => {
+                // `/proc/<pid>/cmdline:<args>` — `grep -aH` over the whole glob,
+                // NULs already spaces. A pid with no `@PROCS@` entry (a process
+                // that started between the two passes) is dropped rather than
+                // invented, and an arg containing a literal newline splits into a
+                // prefix-less continuation line that is dropped, as before.
+                let Some(rest) = line.strip_prefix("/proc/") else {
+                    continue;
+                };
+                let Some((pid, tail)) = rest.split_once('/') else {
+                    continue;
+                };
+                let Some(args) = tail.strip_prefix("cmdline:") else {
+                    continue;
+                };
+                let Ok(pid) = pid.parse::<u32>() else {
+                    continue;
+                };
+                if let Some(acc) = proc_acc.get_mut(&pid) {
+                    acc.cmdline = Some(args.to_string());
+                }
+            }
+            Sec::None => {}
+        }
+    }
+
+    // Build the process table now that both blocks are in. Owner resolution is
+    // deferred one step further (until @PASSWD2@'s targeted lookups below), so
+    // `user` starts empty and the raw uid rides alongside in `proc_uid`, 1:1 by
+    // index.
+    for (pid, acc) in proc_acc {
+        let Some((comm, state, ppid, cpu_jiffies, threads)) = parse_pid_stat(&acc.stat) else {
             continue;
         };
-        return rest.split_whitespace().next()?.parse().ok();
+        let cmdline = acc
+            .cmdline
+            .filter(|c| !c.trim().is_empty())
+            .unwrap_or_else(|| format!("[{comm}]"));
+        processes.push(ProcSample {
+            pid,
+            ppid,
+            comm,
+            cmdline,
+            state,
+            rss_kib: acc.rss_kib,
+            cpu_jiffies,
+            threads,
+            user: String::new(),
+        });
+        proc_uid.push(acc.uid);
+    }
+
+    // Resolve every process's owner now that both passwd blocks are in: the bulk
+    // `@PASSWD@` dump first, then `@PASSWD2@`'s per-uid lookups filling whatever
+    // uid it left unmapped (an enumeration-only gap, not a real unmapped uid, so
+    // the bulk name wins on a conflict rather than being overwritten).
+    let mut uid_to_name = parse_passwd(&passwd_buf);
+    for (uid, name) in parse_passwd(&passwd2_buf) {
+        uid_to_name.entry(uid).or_insert(name);
+    }
+    for (proc, uid) in processes.iter_mut().zip(proc_uid.iter()) {
+        // An owner uid the host didn't report (unreadable status) leaves the user
+        // empty rather than mislabelling it `#0` (root).
+        if let Some(uid) = uid {
+            proc.user = username_for(*uid, &uid_to_name);
+        } else if careful {
+            // Careful mode ships no `U` line for a process that isn't ours, so
+            // every one of them lands here — bucketed under a single label rather
+            // than a uid each, which would be a per-person breakdown by another
+            // name. "How much of this machine isn't mine" is the whole figure the
+            // pane needs from them.
+            proc.user = OTHER_USERS.to_string();
+        }
+    }
+
+    let (cpu, per_core) = parse_cpu_stat(&stat_buf);
+    let (mem_total_kib, mem_available_kib, swap_total_kib, swap_free_kib) = parse_meminfo(&mem_buf);
+    let load_avg = parse_loadavg(&load_buf);
+    let uptime_secs = up_buf
+        .split_whitespace()
+        .next()
+        .and_then(|v| v.parse::<f64>().ok())
+        .unwrap_or(0.0);
+
+    // AMD cards (via the shared `parse_drm_card`) then NVIDIA (via the shared
+    // `parse_nvidia_smi`), so the host reading matches the local one field-for-field.
+    let mut gpus: Vec<crate::gpustat::GpuSample> = amd_cards
+        .into_iter()
+        .filter_map(|(idx, files)| crate::gpustat::parse_drm_card(idx, &files))
+        .collect();
+    gpus.extend(crate::gpustat::parse_nvidia_smi(&nvsmi));
+    let gpu_procs = crate::gpustat::parse_nvidia_apps(&nvproc);
+    let cpu_temp_c = pick_cpu_temp(&cpu_temp_channels);
+    let sessions = parse_who(&who_buf, &me);
+
+    SystemSnapshot {
+        supported: true,
+        clk_tck: clk,
+        num_cores: per_core.len() as u32,
+        cpu,
+        per_core,
+        mem_total_kib,
+        mem_available_kib,
+        swap_total_kib,
+        swap_free_kib,
+        load_avg,
+        uptime_secs,
+        processes,
+        gpus,
+        gpu_procs,
+        cpu_temp_c,
+        mem_temp_c,
+        sessions,
+        careful,
+    }
+}
+
+// ── Pure Windows decoders (compiled under test on any OS) ───────────────────
+// Factored out of the Windows backend so they can be unit-tested from byte
+// fixtures without a live Win32 (pattern: the `/proc` parsers above).
+
+/// Byte size of one `SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION` entry as
+/// returned by `NtQuerySystemInformation` class 8: five LARGE_INTEGER times
+/// (Idle, Kernel, User, Dpc, Interrupt) + ULONG InterruptCount + padding.
+#[cfg(any(target_os = "windows", test))]
+const PROCESSOR_PERF_ENTRY_BYTES: usize = 48;
+
+/// Parse the raw buffer written by `NtQuerySystemInformation(8, …)` into one
+/// [`CpuTimes`] per processor. KernelTime INCLUDES IdleTime (same convention as
+/// `GetSystemTimes`), so `total = kernel + user` and `busy = total − idle`. A
+/// trailing partial entry is ignored; negative times (never expected) clamp to 0.
+#[cfg(any(target_os = "windows", test))]
+fn parse_processor_perf_buffer(buf: &[u8]) -> Vec<CpuTimes> {
+    buf.chunks_exact(PROCESSOR_PERF_ENTRY_BYTES)
+        .map(|chunk| {
+            let time = |off: usize| {
+                i64::from_le_bytes(chunk[off..off + 8].try_into().unwrap()).max(0) as u64
+            };
+            let (idle, kernel, user) = (time(0), time(8), time(16));
+            let total = kernel + user;
+            CpuTimes {
+                busy: total.saturating_sub(idle),
+                total,
+            }
+        })
+        .collect()
+}
+
+/// Decode a NUL-terminated ANSI `CHAR` buffer (a `PROCESSENTRY32.szExeFile`,
+/// or a macOS `proc_bsdinfo.pbi_comm`) into a `String`, lossily for non-UTF-8
+/// bytes.
+#[cfg(any(target_os = "windows", target_os = "macos", test))]
+fn decode_ansi_nul(raw: &[i8]) -> String {
+    let bytes: Vec<u8> = raw
+        .iter()
+        .take_while(|&&c| c != 0)
+        .map(|&c| c as u8)
+        .collect();
+    String::from_utf8_lossy(&bytes).into_owned()
+}
+
+// ── Pure macOS decoders (compiled under test on any OS) ─────────────────────
+
+/// Convert the flat tick array written by `host_processor_info`
+/// (`PROCESSOR_CPU_LOAD_INFO`: 4 cumulative `u32` tick counters per core, in
+/// CPU_STATE order user/system/idle/nice) into one [`CpuTimes`] per core, with
+/// ticks scaled to nanoseconds (`ns_per_tick = 1e9 / clk_tck`). The macOS
+/// "tick" unit for per-PROCESS times is already nanoseconds (`clk_tck()` is
+/// 1e9), so machine times MUST be converted to ns too — the frontend divides
+/// per-process by machine deltas and the units have to match. `busy` is
+/// user+system+nice; `total` adds idle. A trailing partial chunk is ignored.
+#[cfg(any(target_os = "macos", test))]
+fn parse_host_processor_ticks(ticks: &[u32], ns_per_tick: u64) -> Vec<CpuTimes> {
+    const CPU_STATE_USER: usize = 0;
+    const CPU_STATE_SYSTEM: usize = 1;
+    const CPU_STATE_IDLE: usize = 2;
+    const CPU_STATE_NICE: usize = 3;
+    ticks
+        .chunks_exact(4)
+        .map(|c| {
+            let busy = (c[CPU_STATE_USER] as u64
+                + c[CPU_STATE_SYSTEM] as u64
+                + c[CPU_STATE_NICE] as u64)
+                * ns_per_tick;
+            CpuTimes {
+                busy,
+                total: busy + c[CPU_STATE_IDLE] as u64 * ns_per_tick,
+            }
+        })
+        .collect()
+}
+
+/// Map a BSD `pbi_status` process state to the Linux-style single letter the
+/// monitor pane already renders: SRUN→R, SSLEEP→S, SSTOP→T, SZOMB→Z (SIDL→I;
+/// anything unknown → empty).
+#[cfg(any(target_os = "macos", test))]
+fn bsd_process_state(status: u32) -> String {
+    match status {
+        1 => "I", // SIDL — process being created
+        2 => "R", // SRUN
+        3 => "S", // SSLEEP
+        4 => "T", // SSTOP
+        5 => "Z", // SZOMB
+        _ => "",
+    }
+    .to_string()
+}
+
+// ── Linux backend (`/proc`) ─────────────────────────────────────────────────
+#[cfg(target_os = "linux")]
+mod platform {
+    use std::collections::HashMap;
+    use std::fs;
+
+    /// Kernel clock ticks per second (USER_HZ). Used to convert jiffies → seconds.
+    pub fn clk_tck() -> u64 {
+        // SAFETY: sysconf is async-signal-safe and takes no pointers.
+        let v = unsafe { libc::sysconf(libc::_SC_CLK_TCK) };
+        if v > 0 {
+            v as u64
+        } else {
+            100
+        }
+    }
+
+    /// pid → ppid for every live process, from a single `/proc` walk.
+    pub fn parent_map() -> HashMap<u32, u32> {
+        let mut parent: HashMap<u32, u32> = HashMap::new();
+        if let Ok(entries) = fs::read_dir("/proc") {
+            for entry in entries.flatten() {
+                let name = entry.file_name();
+                let Some(pid) = name.to_str().and_then(|s| s.parse::<u32>().ok()) else {
+                    continue;
+                };
+                if let Some(ppid) = ppid(pid) {
+                    parent.insert(pid, ppid);
+                }
+            }
+        }
+        parent
+    }
+
+    /// utime + stime (jiffies) from `/proc/<pid>/stat` (fields 14 and 15).
+    pub fn proc_ticks(pid: u32) -> Option<u64> {
+        let stat = fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
+        let rest = stat.rsplit_once(')')?.1;
+        let fields: Vec<&str> = rest.split_whitespace().collect();
+        // After ')' fields are 1-indexed as in proc(5): [0]=state(field 3).
+        // utime=field 14 → index 11, stime=field 15 → index 12.
+        let utime: u64 = fields.get(11)?.parse().ok()?;
+        let stime: u64 = fields.get(12)?.parse().ok()?;
+        Some(utime + stime)
+    }
+
+    /// Resident set size from `/proc/<pid>/status`, in KiB.
+    pub fn rss_kib(pid: u32) -> Option<u64> {
+        let status = fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
+        for line in status.lines() {
+            let Some(rest) = line.strip_prefix("VmRSS:") else {
+                continue;
+            };
+            return rest.split_whitespace().next()?.parse().ok();
+        }
+        None
+    }
+
+    /// Parent pid from `/proc/<pid>/stat` (field 4, after the comm field).
+    pub fn ppid(pid: u32) -> Option<u32> {
+        let stat = fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;
+        // comm (field 2) may contain spaces/parens, so split after the last ')'.
+        let rest = stat.rsplit_once(')')?.1;
+        // rest = " S <ppid> ..." → fields[0]="" , [1]=state, [2]=ppid
+        rest.split_whitespace().nth(1)?.parse().ok()
+    }
+
+    /// Command line for a live process, with NUL separators normalized to spaces.
+    pub fn cmdline(pid: u32) -> Option<String> {
+        let bytes = fs::read(format!("/proc/{pid}/cmdline")).ok()?;
+        if bytes.is_empty() {
+            return None;
+        }
+        let cmd = bytes
+            .split(|b| *b == 0)
+            .filter(|part| !part.is_empty())
+            .map(|part| String::from_utf8_lossy(part))
+            .collect::<Vec<_>>()
+            .join(" ");
+        if cmd.is_empty() {
+            None
+        } else {
+            Some(cmd)
+        }
+    }
+
+    /// Whole-package CPU temperature in °C from the first CPU hwmon that exposes
+    /// one, or `None`. Scans `/sys/class/hwmon/hwmon*`, matches the sensor by its
+    /// `name` ([`super::is_cpu_hwmon`]), reads every `tempN_input` with its optional
+    /// `tempN_label`, and lets [`super::pick_cpu_temp`] choose the package channel.
+    /// No tool spawn and no root — the same cheap sysfs read the GPU sensors use.
+    pub fn cpu_temp_c() -> Option<f64> {
+        for entry in fs::read_dir("/sys/class/hwmon").ok()?.flatten() {
+            let base = entry.path();
+            let name = fs::read_to_string(base.join("name")).unwrap_or_default();
+            if !super::is_cpu_hwmon(&name) {
+                continue;
+            }
+            let mut channels: Vec<(Option<String>, f64)> = Vec::new();
+            for i in 1..=32u32 {
+                let Ok(raw) = fs::read_to_string(base.join(format!("temp{i}_input"))) else {
+                    continue;
+                };
+                let Ok(milli) = raw.trim().parse::<f64>() else {
+                    continue;
+                };
+                let label = fs::read_to_string(base.join(format!("temp{i}_label")))
+                    .ok()
+                    .map(|s| s.trim().to_string());
+                channels.push((label, milli));
+            }
+            if let Some(t) = super::pick_cpu_temp(&channels) {
+                return Some(t);
+            }
+        }
+        None
+    }
+
+    /// Hottest DIMM temperature in °C across every on-module memory sensor
+    /// (`jc42`/`spd5118`, one hwmon per populated module), or `None` when the board
+    /// exposes none. `temp1_input` is the module's only channel. Same cheap sysfs
+    /// read the CPU/GPU sensors use — no tool spawn, no root.
+    pub fn mem_temp_c() -> Option<f64> {
+        let mut hottest: Option<f64> = None;
+        for entry in fs::read_dir("/sys/class/hwmon").ok()?.flatten() {
+            let base = entry.path();
+            let name = fs::read_to_string(base.join("name")).unwrap_or_default();
+            if !super::is_mem_hwmon(&name) {
+                continue;
+            }
+            let Ok(raw) = fs::read_to_string(base.join("temp1_input")) else {
+                continue;
+            };
+            let Ok(milli) = raw.trim().parse::<f64>() else {
+                continue;
+            };
+            let c = milli / 1000.0;
+            hottest = Some(hottest.map_or(c, |h| h.max(c)));
+        }
+        hottest
+    }
+
+    /// Whole-system sample from `/proc`: aggregate + per-core CPU, memory/swap,
+    /// load, uptime, and every process (one `/proc/<pid>/{stat,status,cmdline}`
+    /// read each). Kernel threads (empty `cmdline`) fall back to `[comm]`.
+    pub fn system_snapshot() -> super::SystemSnapshot {
+        use super::{ProcSample, SystemSnapshot};
+        use std::os::unix::fs::MetadataExt;
+
+        // Resolve each process's owner uid to a name via the machine's own
+        // `/etc/passwd`, read once. NSS-only accounts (LDAP/SSSD) the file walk
+        // misses fall back to `#<uid>` in `username_for` — the remote path uses
+        // `getent`, which is NSS-aware, so this file read is the local-only gap.
+        let passwd = super::parse_passwd(&fs::read_to_string("/etc/passwd").unwrap_or_default());
+
+        let (cpu, per_core) =
+            super::parse_cpu_stat(&fs::read_to_string("/proc/stat").unwrap_or_default());
+        let (mem_total_kib, mem_available_kib, swap_total_kib, swap_free_kib) =
+            super::parse_meminfo(&fs::read_to_string("/proc/meminfo").unwrap_or_default());
+        let load_avg =
+            super::parse_loadavg(&fs::read_to_string("/proc/loadavg").unwrap_or_default());
+        let uptime_secs = fs::read_to_string("/proc/uptime")
+            .ok()
+            .and_then(|c| c.split_whitespace().next()?.parse::<f64>().ok())
+            .unwrap_or(0.0);
+
+        let mut processes = Vec::new();
+        if let Ok(entries) = fs::read_dir("/proc") {
+            for entry in entries.flatten() {
+                let name = entry.file_name();
+                let Some(pid) = name.to_str().and_then(|s| s.parse::<u32>().ok()) else {
+                    continue;
+                };
+                let Ok(stat) = fs::read_to_string(format!("/proc/{pid}/stat")) else {
+                    continue;
+                };
+                let Some((comm, state, ppid, cpu_jiffies, threads)) = super::parse_pid_stat(&stat)
+                else {
+                    continue;
+                };
+                let cmdline = cmdline(pid).unwrap_or_else(|| format!("[{comm}]"));
+                // The process's owner is the uid owning its `/proc/<pid>` dir.
+                let user = fs::metadata(format!("/proc/{pid}"))
+                    .map(|m| super::username_for(m.uid(), &passwd))
+                    .unwrap_or_default();
+                processes.push(ProcSample {
+                    pid,
+                    ppid,
+                    comm,
+                    cmdline,
+                    state,
+                    rss_kib: rss_kib(pid).unwrap_or(0),
+                    cpu_jiffies,
+                    threads,
+                    user,
+                });
+            }
+        }
+
+        SystemSnapshot {
+            supported: true,
+            clk_tck: clk_tck(),
+            num_cores: per_core.len() as u32,
+            cpu,
+            per_core,
+            mem_total_kib,
+            mem_available_kib,
+            swap_total_kib,
+            swap_free_kib,
+            load_avg,
+            uptime_secs,
+            processes,
+            gpus: Vec::new(), // filled by `system_snapshot()`, not by this backend
+            gpu_procs: Vec::new(),
+            cpu_temp_c: cpu_temp_c(),
+            mem_temp_c: mem_temp_c(),
+            sessions: Vec::new(), // remote-only (the pane's "Logged in" panel)
+            careful: false,       // a local sample: this machine is the user's own
+        }
+    }
+}
+
+// ── Windows backend (ToolHelp + Win32) ──────────────────────────────────────
+#[cfg(target_os = "windows")]
+mod platform {
+    use std::collections::HashMap;
+    use windows::Win32::Foundation::{CloseHandle, FILETIME, HANDLE};
+    use windows::Win32::System::Diagnostics::ToolHelp::{
+        CreateToolhelp32Snapshot, Process32First, Process32Next, PROCESSENTRY32, TH32CS_SNAPPROCESS,
+    };
+    use windows::Win32::System::ProcessStatus::{GetProcessMemoryInfo, PROCESS_MEMORY_COUNTERS};
+    use windows::Win32::System::Threading::{
+        GetProcessTimes, OpenProcess, PROCESS_QUERY_LIMITED_INFORMATION,
+    };
+
+    /// Windows has no USER_HZ; `GetProcessTimes` reports in 100-ns units, so the
+    /// ticks-per-second the caller divides by is 10_000_000.
+    pub fn clk_tck() -> u64 {
+        10_000_000
+    }
+
+    /// pid → ppid for every live process, from a single ToolHelp snapshot.
+    pub fn parent_map() -> HashMap<u32, u32> {
+        let mut map = HashMap::new();
+        // SAFETY: snapshot is closed before returning; the entry is fully
+        // initialized (dwSize set) before Process32First reads it.
+        unsafe {
+            let Ok(snapshot) = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) else {
+                return map;
+            };
+            let mut entry = PROCESSENTRY32 {
+                dwSize: std::mem::size_of::<PROCESSENTRY32>() as u32,
+                ..Default::default()
+            };
+            if Process32First(snapshot, &mut entry).is_ok() {
+                loop {
+                    map.insert(entry.th32ProcessID, entry.th32ParentProcessID);
+                    if Process32Next(snapshot, &mut entry).is_err() {
+                        break;
+                    }
+                }
+            }
+            let _ = CloseHandle(snapshot);
+        }
+        map
+    }
+
+    /// Open a process for query, run `f` with the handle, and always close it.
+    fn with_process<T>(pid: u32, f: impl FnOnce(HANDLE) -> Option<T>) -> Option<T> {
+        // SAFETY: the handle is closed before returning regardless of `f`'s result.
+        let handle =
+            unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, false, pid) }.ok()?;
+        let out = f(handle);
+        unsafe {
+            let _ = CloseHandle(handle);
+        }
+        out
+    }
+
+    /// kernel + user CPU time in 100-ns units, via `GetProcessTimes`.
+    pub fn proc_ticks(pid: u32) -> Option<u64> {
+        with_process(pid, |handle| {
+            let mut creation = FILETIME::default();
+            let mut exit = FILETIME::default();
+            let mut kernel = FILETIME::default();
+            let mut user = FILETIME::default();
+            // SAFETY: all four FILETIME out-params are valid for the call.
+            unsafe { GetProcessTimes(handle, &mut creation, &mut exit, &mut kernel, &mut user) }
+                .ok()?;
+            Some(filetime_units(kernel) + filetime_units(user))
+        })
+    }
+
+    /// Working-set size in KiB, via `GetProcessMemoryInfo`.
+    pub fn rss_kib(pid: u32) -> Option<u64> {
+        with_process(pid, |handle| {
+            let mut counters = PROCESS_MEMORY_COUNTERS::default();
+            // SAFETY: `counters` is valid and `cb` matches its size.
+            unsafe {
+                GetProcessMemoryInfo(
+                    handle,
+                    &mut counters,
+                    std::mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32,
+                )
+            }
+            .ok()?;
+            Some(counters.WorkingSetSize as u64 / 1024)
+        })
+    }
+
+    pub fn ppid(pid: u32) -> Option<u32> {
+        parent_map().get(&pid).copied()
+    }
+
+    /// Not resolved on Windows (only used by the Linux-specific `tauri dev`
+    /// process-root heuristic); returns `None` so callers fall back gracefully.
+    pub fn cmdline(_pid: u32) -> Option<String> {
+        None
+    }
+
+    fn filetime_units(ft: FILETIME) -> u64 {
+        ((ft.dwHighDateTime as u64) << 32) | ft.dwLowDateTime as u64
+    }
+
+    /// Per-core cumulative CPU times via `NtQuerySystemInformation` class 8
+    /// (`SystemProcessorPerformanceInformation`). The windows crate does not
+    /// bind this ntdll call, so it is declared manually; a failed query
+    /// degrades to an empty per-core list (the pane then shows only the
+    /// aggregate bar). The raw buffer decode is the pure, unit-tested
+    /// [`super::parse_processor_perf_buffer`].
+    fn query_per_core_times() -> Vec<super::CpuTimes> {
+        #[link(name = "ntdll")]
+        extern "system" {
+            fn NtQuerySystemInformation(
+                class: u32,
+                info: *mut core::ffi::c_void,
+                len: u32,
+                return_len: *mut u32,
+            ) -> i32;
+        }
+        const SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION: u32 = 8;
+        // 64 KiB holds > 1300 processors at 48 bytes each.
+        let mut buf = vec![0u8; 64 * 1024];
+        let mut ret_len: u32 = 0;
+        // SAFETY: the buffer length is passed exactly; ntdll writes at most
+        // that many bytes and reports how many in `ret_len`, which bounds the
+        // parse below. A non-zero NTSTATUS means nothing was written.
+        let status = unsafe {
+            NtQuerySystemInformation(
+                SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION,
+                buf.as_mut_ptr() as *mut core::ffi::c_void,
+                buf.len() as u32,
+                &mut ret_len,
+            )
+        };
+        if status != 0 {
+            return Vec::new();
+        }
+        buf.truncate((ret_len as usize).min(buf.len()));
+        super::parse_processor_perf_buffer(&buf)
+    }
+
+    /// Whole-system sample via Win32: `GetSystemTimes` (aggregate CPU; kernel
+    /// time INCLUDES idle, so total = kernel+user and busy = total−idle),
+    /// ntdll per-core times, `GlobalMemoryStatusEx` (swap ≈ pagefile −
+    /// physical, both counters include RAM), `GetTickCount64` uptime, and one
+    /// ToolHelp walk for the process table. Windows has no load average, so
+    /// `load_avg` stays `[0.0; 3]` and the pane hides it. All CPU counters are
+    /// 100-ns units to match `proc_ticks`/`clk_tck` — the frontend divides
+    /// per-process ticks by machine ticks, so the units MUST agree.
+    pub fn system_snapshot() -> super::SystemSnapshot {
+        use super::{CpuTimes, ProcSample, SystemSnapshot};
+        use windows::Win32::System::SystemInformation::{
+            GetSystemInfo, GetTickCount64, GlobalMemoryStatusEx, MEMORYSTATUSEX, SYSTEM_INFO,
+        };
+        use windows::Win32::System::Threading::GetSystemTimes;
+
+        let mut idle = FILETIME::default();
+        let mut kernel = FILETIME::default();
+        let mut user = FILETIME::default();
+        // SAFETY: three valid FILETIME out-params, written on success only.
+        let cpu = if unsafe {
+            GetSystemTimes(
+                Some(&mut idle as *mut _),
+                Some(&mut kernel as *mut _),
+                Some(&mut user as *mut _),
+            )
+        }
+        .is_ok()
+        {
+            let total = filetime_units(kernel) + filetime_units(user);
+            CpuTimes {
+                busy: total.saturating_sub(filetime_units(idle)),
+                total,
+            }
+        } else {
+            CpuTimes::default()
+        };
+
+        let per_core = query_per_core_times();
+
+        let mut mem = MEMORYSTATUSEX {
+            dwLength: std::mem::size_of::<MEMORYSTATUSEX>() as u32,
+            ..Default::default()
+        };
+        // SAFETY: `mem` is valid and its dwLength is set as the API requires.
+        let (mem_total_kib, mem_available_kib, swap_total_kib, swap_free_kib) =
+            if unsafe { GlobalMemoryStatusEx(&mut mem) }.is_ok() {
+                (
+                    mem.ullTotalPhys / 1024,
+                    mem.ullAvailPhys / 1024,
+                    mem.ullTotalPageFile.saturating_sub(mem.ullTotalPhys) / 1024,
+                    mem.ullAvailPageFile.saturating_sub(mem.ullAvailPhys) / 1024,
+                )
+            } else {
+                (0, 0, 0, 0)
+            };
+
+        let num_cores = {
+            let mut info = SYSTEM_INFO::default();
+            // SAFETY: plain out-param write into a valid SYSTEM_INFO.
+            unsafe { GetSystemInfo(&mut info) };
+            info.dwNumberOfProcessors
+        };
+
+        // SAFETY: no arguments; returns milliseconds since boot.
+        let uptime_secs = unsafe { GetTickCount64() } as f64 / 1000.0;
+
+        // One ToolHelp walk for identity fields (pid/ppid/name/threads), then
+        // per-pid CPU/RSS queries. A pid we cannot open (system/elevated)
+        // keeps its identity row with zeroed usage, matching the Linux
+        // behavior of unreadable /proc entries as closely as possible.
+        let mut processes = Vec::new();
+        // SAFETY: snapshot is closed before returning; the entry is fully
+        // initialized (dwSize set) before Process32First reads it.
+        unsafe {
+            if let Ok(snapshot) = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) {
+                let mut entry = PROCESSENTRY32 {
+                    dwSize: std::mem::size_of::<PROCESSENTRY32>() as u32,
+                    ..Default::default()
+                };
+                if Process32First(snapshot, &mut entry).is_ok() {
+                    loop {
+                        let pid = entry.th32ProcessID;
+                        let comm = super::decode_ansi_nul(&entry.szExeFile);
+                        processes.push(ProcSample {
+                            pid,
+                            ppid: entry.th32ParentProcessID,
+                            cmdline: format!("[{comm}]"),
+                            comm,
+                            state: String::new(),
+                            rss_kib: rss_kib(pid).unwrap_or(0),
+                            cpu_jiffies: proc_ticks(pid).unwrap_or(0),
+                            threads: entry.cntThreads,
+                            // No cheap per-process owner lookup here; the pane hides
+                            // the per-user section when no process reports one.
+                            user: String::new(),
+                        });
+                        if Process32Next(snapshot, &mut entry).is_err() {
+                            break;
+                        }
+                    }
+                }
+                let _ = CloseHandle(snapshot);
+            }
+        }
+
+        SystemSnapshot {
+            supported: true,
+            clk_tck: clk_tck(),
+            num_cores,
+            cpu,
+            per_core,
+            mem_total_kib,
+            mem_available_kib,
+            swap_total_kib,
+            swap_free_kib,
+            load_avg: [0.0; 3],
+            uptime_secs,
+            processes,
+            gpus: Vec::new(), // filled by `system_snapshot()`, not by this backend
+            gpu_procs: Vec::new(),
+            cpu_temp_c: None, // no cheap CPU thermal read on this backend
+            mem_temp_c: None, // nor a memory thermal read
+            sessions: Vec::new(), // remote-only (the pane's "Logged in" panel)
+            careful: false,       // a local sample: this machine is the user's own
+        }
+    }
+}
+
+// ── macOS backend (libproc) ─────────────────────────────────────────────────
+#[cfg(target_os = "macos")]
+mod platform {
+    use std::collections::HashMap;
+
+    /// Ticks per second for [`proc_ticks`]: macOS task CPU times are nanoseconds,
+    /// so one "tick" is one nanosecond and there are 1e9 per second.
+    pub fn clk_tck() -> u64 {
+        1_000_000_000
+    }
+
+    /// Fill a `proc_taskinfo` for `pid` (CPU time + RSS). `None` if the process is
+    /// gone or the call did not write a full struct.
+    fn task_info(pid: u32) -> Option<libc::proc_taskinfo> {
+        // SAFETY: `proc_pidinfo` writes at most `size` bytes into `info`, which is
+        // a zero-initialized, correctly-sized `proc_taskinfo`. We pass its real
+        // size and accept the result only when the kernel wrote the whole struct,
+        // so we never read uninitialized fields.
+        unsafe {
+            let mut info: libc::proc_taskinfo = std::mem::zeroed();
+            let size = std::mem::size_of::<libc::proc_taskinfo>() as libc::c_int;
+            let ret = libc::proc_pidinfo(
+                pid as libc::c_int,
+                libc::PROC_PIDTASKINFO,
+                0,
+                &mut info as *mut _ as *mut libc::c_void,
+                size,
+            );
+            if ret == size { Some(info) } else { None }
+        }
+    }
+
+    /// Fill a `proc_bsdinfo` for `pid` (used for the parent pid). Same contract as
+    /// [`task_info`].
+    fn bsd_info(pid: u32) -> Option<libc::proc_bsdinfo> {
+        // SAFETY: identical contract to `task_info` but for the BSD-info flavor:
+        // `info` is zero-initialized and correctly sized, and a short/failed write
+        // (ret != size) is rejected before any field is read.
+        unsafe {
+            let mut info: libc::proc_bsdinfo = std::mem::zeroed();
+            let size = std::mem::size_of::<libc::proc_bsdinfo>() as libc::c_int;
+            let ret = libc::proc_pidinfo(
+                pid as libc::c_int,
+                libc::PROC_PIDTBSDINFO,
+                0,
+                &mut info as *mut _ as *mut libc::c_void,
+                size,
+            );
+            if ret == size { Some(info) } else { None }
+        }
+    }
+
+    /// Total user + system CPU time for `pid`, in nanoseconds (the macOS "tick").
+    pub fn proc_ticks(pid: u32) -> Option<u64> {
+        let info = task_info(pid)?;
+        Some(info.pti_total_user.wrapping_add(info.pti_total_system))
+    }
+
+    /// Resident set size for `pid`, in KiB (`pti_resident_size` is bytes).
+    pub fn rss_kib(pid: u32) -> Option<u64> {
+        let info = task_info(pid)?;
+        Some(info.pti_resident_size / 1024)
+    }
+
+    /// Parent pid for `pid` via the BSD-info flavor.
+    pub fn ppid(pid: u32) -> Option<u32> {
+        Some(bsd_info(pid)?.pbi_ppid)
+    }
+
+    /// Process args on macOS are only reachable via `sysctl KERN_PROCARGS2`; the
+    /// sole caller is a Linux-only "tauri dev" heuristic, so we skip it.
+    pub fn cmdline(_pid: u32) -> Option<String> {
+        None
+    }
+
+    /// pid → ppid for every live process: enumerate all pids with
+    /// `proc_listallpids`, then resolve each parent via [`ppid`].
+    pub fn parent_map() -> HashMap<u32, u32> {
+        let mut parent: HashMap<u32, u32> = HashMap::new();
+        for pid in all_pids() {
+            if let Some(pp) = ppid(pid) {
+                parent.insert(pid, pp);
+            }
+        }
+        parent
+    }
+
+    /// All live pids via `proc_listallpids`. Empty vec on failure.
+    ///
+    /// `proc_listallpids` returns a *count* of pids (it divides the kernel's
+    /// byte count by `sizeof(pid_t)`): with a null buffer it reports how many
+    /// pids exist, and with a real buffer it reports how many it filled in.
+    fn all_pids() -> Vec<u32> {
+        // SAFETY: the first call passes a null buffer / zero size, so the kernel
+        // only reports the pid count and writes nothing. We then size a buffer to
+        // that count plus slack (covering processes spawned between the two
+        // calls), pass its length in *bytes*, and use the returned pid count to
+        // bound how many entries we read back — never more than we allocated.
+        unsafe {
+            let count = libc::proc_listallpids(std::ptr::null_mut(), 0);
+            if count <= 0 {
+                return Vec::new();
+            }
+            let cap = count as usize + 64;
+            let mut pids = vec![0i32; cap];
+            let filled = libc::proc_listallpids(
+                pids.as_mut_ptr() as *mut libc::c_void,
+                (cap * std::mem::size_of::<i32>()) as libc::c_int,
+            );
+            if filled <= 0 {
+                return Vec::new();
+            }
+            pids.truncate(filled as usize);
+            pids.into_iter()
+                .filter(|&p| p > 0)
+                .map(|p| p as u32)
+                .collect()
+        }
+    }
+
+    // ── whole-system snapshot (mach host FFI) ───────────────────────────────
+    //
+    // The mach host calls below are not in the `libc` crate, so they are
+    // declared manually (same raw-FFI pattern as the libproc calls above; all
+    // live in the always-linked libSystem).
+
+    extern "C" {
+        fn mach_host_self() -> u32;
+        fn host_processor_info(
+            host: u32,
+            flavor: i32,
+            out_processor_count: *mut u32,
+            out_processor_info: *mut *mut u32,
+            out_processor_info_count: *mut u32,
+        ) -> i32;
+        fn host_statistics64(host: u32, flavor: i32, info: *mut i32, count: *mut u32) -> i32;
+        fn vm_deallocate(task: u32, address: usize, size: usize) -> i32;
+        static mach_task_self_: u32;
+    }
+
+    /// `PROCESSOR_CPU_LOAD_INFO`.
+    const CPU_LOAD_INFO: i32 = 2;
+    /// `HOST_VM_INFO64`.
+    const HOST_VM_INFO64: i32 = 4;
+    /// sysctl MIB names (numeric so no reliance on libc exposing each const).
+    const CTL_KERN: i32 = 1;
+    const KERN_BOOTTIME: i32 = 21;
+    const CTL_VM: i32 = 2;
+    const VM_SWAPUSAGE: i32 = 5;
+    const CTL_HW: i32 = 6;
+    const HW_MEMSIZE: i32 = 24;
+
+    /// The head of `struct vm_statistics64` — only the leading fixed-width
+    /// counters this module reads. `host_statistics64` copies out at most the
+    /// count we pass, so declaring a prefix is sound (the kernel truncates to
+    /// the caller's count; it never writes past it).
+    #[repr(C)]
+    #[derive(Default, Clone, Copy)]
+    struct VmStatistics64Head {
+        free_count: u32,
+        active_count: u32,
+        inactive_count: u32,
+        wire_count: u32,
+    }
+
+    /// Generic fixed-size sysctl read. `None` when the kernel rejects the MIB
+    /// or writes a different size than expected.
+    fn sysctl_read<T>(mib: &mut [i32]) -> Option<T> {
+        // SAFETY: every T used here is a plain-old-data sysctl out-struct
+        // (u64 / libc::timeval / libc::xsw_usage), for which an all-zero bit
+        // pattern is a valid value; sysctl writes at most `len` bytes into it
+        // and updates `len`, and the result is used only when the kernel
+        // reported writing the full struct.
+        unsafe {
+            let mut out: T = std::mem::zeroed();
+            let mut len = std::mem::size_of::<T>();
+            let rc = libc::sysctl(
+                mib.as_mut_ptr(),
+                mib.len() as u32,
+                &mut out as *mut T as *mut libc::c_void,
+                &mut len,
+                std::ptr::null_mut(),
+                0,
+            );
+            (rc == 0 && len == std::mem::size_of::<T>()).then_some(out)
+        }
+    }
+
+    /// Per-core cumulative CPU times in nanoseconds, via `host_processor_info`.
+    /// Failure degrades to an empty per-core list. The raw tick decode is the
+    /// pure, unit-tested [`super::parse_host_processor_ticks`].
+    fn per_core_times(ns_per_tick: u64) -> Vec<super::CpuTimes> {
+        let mut cpu_count: u32 = 0;
+        let mut info: *mut u32 = std::ptr::null_mut();
+        let mut info_count: u32 = 0;
+        // SAFETY: all three out-params are valid; on KERN_SUCCESS the kernel
+        // vm_allocates `info` (info_count u32s), which we copy out of and then
+        // vm_deallocate exactly once with the byte size it reported.
+        unsafe {
+            let rc = host_processor_info(
+                mach_host_self(),
+                CPU_LOAD_INFO,
+                &mut cpu_count,
+                &mut info,
+                &mut info_count,
+            );
+            if rc != 0 || info.is_null() {
+                return Vec::new();
+            }
+            let ticks = std::slice::from_raw_parts(info, info_count as usize).to_vec();
+            let _ = vm_deallocate(
+                mach_task_self_,
+                info as usize,
+                info_count as usize * std::mem::size_of::<u32>(),
+            );
+            super::parse_host_processor_ticks(&ticks, ns_per_tick)
+        }
+    }
+
+    /// Whole-system sample via mach/sysctl/libproc. All CPU counters are in
+    /// nanoseconds to match `proc_ticks`/`clk_tck` (1e9) — the frontend
+    /// divides per-process by machine deltas, so the units MUST agree; the
+    /// host tick counters are converted via `1e9 / _SC_CLK_TCK`.
+    ///
+    /// Visibility caveat: unprivileged `proc_pidinfo` only inspects the
+    /// calling user's processes, so other users' (and most system) processes
+    /// appear without CPU/RSS detail — they are skipped entirely rather than
+    /// listed as zero rows (TODO 31c).
+    pub fn system_snapshot() -> super::SystemSnapshot {
+        use super::{ProcSample, SystemSnapshot};
+
+        // SAFETY: sysconf takes no pointers.
+        let clk = unsafe { libc::sysconf(libc::_SC_CLK_TCK) };
+        let ns_per_tick = if clk > 0 { 1_000_000_000 / clk as u64 } else { 10_000_000 };
+
+        let per_core = per_core_times(ns_per_tick);
+        let cpu = super::CpuTimes {
+            busy: per_core.iter().map(|c| c.busy).sum(),
+            total: per_core.iter().map(|c| c.total).sum(),
+        };
+
+        let mem_total_kib = sysctl_read::<u64>(&mut [CTL_HW, HW_MEMSIZE])
+            .map(|bytes| bytes / 1024)
+            .unwrap_or(0);
+        // SAFETY: sysconf takes no pointers.
+        let page_kib = {
+            let ps = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
+            if ps > 0 { ps as u64 / 1024 } else { 4 }
+        };
+        let mem_available_kib = {
+            let mut head = VmStatistics64Head::default();
+            let mut count = (std::mem::size_of::<VmStatistics64Head>()
+                / std::mem::size_of::<i32>()) as u32;
+            // SAFETY: `head` is a valid prefix buffer and `count` is its exact
+            // size in integer_t units; the kernel copies out at most `count`.
+            let rc = unsafe {
+                host_statistics64(
+                    mach_host_self(),
+                    HOST_VM_INFO64,
+                    &mut head as *mut VmStatistics64Head as *mut i32,
+                    &mut count,
+                )
+            };
+            if rc == 0 {
+                // free + inactive ≈ reclaimable, the usual "available" proxy.
+                (head.free_count as u64 + head.inactive_count as u64) * page_kib
+            } else {
+                0
+            }
+        };
+
+        let (swap_total_kib, swap_free_kib) =
+            sysctl_read::<libc::xsw_usage>(&mut [CTL_VM, VM_SWAPUSAGE])
+                .map(|xsw| (xsw.xsu_total / 1024, xsw.xsu_avail / 1024))
+                .unwrap_or((0, 0));
+
+        let mut load_avg = [0.0f64; 3];
+        // SAFETY: getloadavg writes at most 3 doubles into the array.
+        unsafe {
+            let _ = libc::getloadavg(load_avg.as_mut_ptr(), 3);
+        }
+
+        let uptime_secs = sysctl_read::<libc::timeval>(&mut [CTL_KERN, KERN_BOOTTIME])
+            .map(|boot| {
+                let now = std::time::SystemTime::now()
+                    .duration_since(std::time::UNIX_EPOCH)
+                    .unwrap_or_default()
+                    .as_secs() as i64;
+                (now - boot.tv_sec).max(0) as f64
+            })
+            .unwrap_or(0.0);
+
+        // Process table: pids we can't inspect (other users, most system
+        // daemons — see the visibility caveat above) are skipped.
+        let mut processes = Vec::new();
+        for pid in all_pids() {
+            let Some(task) = task_info(pid) else {
+                continue;
+            };
+            let Some(bsd) = bsd_info(pid) else {
+                continue;
+            };
+            let comm = super::decode_ansi_nul(&bsd.pbi_comm);
+            processes.push(ProcSample {
+                pid,
+                ppid: bsd.pbi_ppid,
+                cmdline: format!("[{comm}]"),
+                comm,
+                state: super::bsd_process_state(bsd.pbi_status),
+                rss_kib: task.pti_resident_size / 1024,
+                cpu_jiffies: task.pti_total_user.wrapping_add(task.pti_total_system),
+                threads: task.pti_threadnum.max(0) as u32,
+                // Owner name isn't resolved here (only the calling user's processes
+                // are visible anyway); the pane hides the per-user section when no
+                // process reports one.
+                user: String::new(),
+            });
+        }
+
+        SystemSnapshot {
+            supported: true,
+            clk_tck: clk_tck(), // 1e9 — everything above is in ns
+            num_cores: per_core.len() as u32,
+            cpu,
+            per_core,
+            mem_total_kib,
+            mem_available_kib,
+            swap_total_kib,
+            swap_free_kib,
+            load_avg,
+            uptime_secs,
+            processes,
+            gpus: Vec::new(), // filled by `system_snapshot()`, not by this backend
+            gpu_procs: Vec::new(),
+            cpu_temp_c: None, // no cheap CPU thermal read on this backend
+            mem_temp_c: None, // nor a memory thermal read
+            sessions: Vec::new(), // remote-only (the pane's "Logged in" panel)
+            careful: false,       // a local sample: this machine is the user's own
+        }
+    }
+}
+
+// ── Fallback backend (other OSes) ───────────────────────────────────────────
+// Targets with no `/proc`, no ToolHelp, and no libproc; the readout degrades to
+// zero rather than failing to compile.
+#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
+mod platform {
+    use std::collections::HashMap;
+
+    pub fn clk_tck() -> u64 {
+        // Arbitrary positive value; `sum_jiffies` is always 0 here so the derived
+        // CPU percentage is 0 regardless, and callers never divide by zero.
+        100
+    }
+
+    pub fn parent_map() -> HashMap<u32, u32> {
+        HashMap::new()
+    }
+
+    pub fn proc_ticks(_pid: u32) -> Option<u64> {
+        None
+    }
+
+    pub fn rss_kib(_pid: u32) -> Option<u64> {
+        None
+    }
+
+    pub fn ppid(_pid: u32) -> Option<u32> {
+        None
+    }
+
+    pub fn cmdline(_pid: u32) -> Option<String> {
+        None
+    }
+
+    /// No `/proc`-style enumeration here: return an unsupported snapshot so the
+    /// monitor pane degrades to a placeholder rather than failing to build.
+    pub fn system_snapshot() -> super::SystemSnapshot {
+        super::SystemSnapshot::default()
     }
-    None
+}
+
+/// Serializes every test that touches the process-tree cache globals. They all
+/// mutate `DESCENDANT_CACHE` or bump `PROC_TREE_GEN`, so running them
+/// concurrently races on that shared state: a seeded synthetic entry is either
+/// overwritten or invalidated out from under the test that seeded it. Lives at
+/// module level rather than inside `mod tests` because the racing callers are in
+/// *other* modules' test code (`terminal::tests` spawns a PTY and invalidates the
+/// cache in a poll loop), and they must take the same lock.
+#[cfg(test)]
+pub(crate) static CACHE_TEST_LOCK: Mutex<()> = Mutex::new(());
+
+/// Take [`CACHE_TEST_LOCK`] for the duration of a test, tolerating poisoning.
+/// A test that trips an assertion while holding the lock poisons it; without
+/// this, every later cache test fails on the poison rather than on its own
+/// behaviour, turning one real failure into a cascade of phantom ones.
+#[cfg(test)]
+pub(crate) fn lock_cache_for_test() -> std::sync::MutexGuard<'static, ()> {
+    CACHE_TEST_LOCK.lock().unwrap_or_else(|e| e.into_inner())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    /// Serializes the cache-mechanics tests: they all mutate the process-global
-    /// `DESCENDANT_CACHE`, so running them concurrently (or alongside other tests
-    /// that call `descendant_pids`) would race on that shared entry.
-    static CACHE_TEST_LOCK: Mutex<()> = Mutex::new(());
-
     #[test]
     fn clk_tck_is_positive() {
-        assert!(clk_tck() > 0, "USER_HZ must be positive");
+        assert!(clk_tck() > 0, "ticks-per-second must be positive");
+    }
+
+    #[test]
+    fn is_cpu_hwmon_matches_only_cpu_sensors() {
+        assert!(is_cpu_hwmon("coretemp"));
+        assert!(is_cpu_hwmon("k10temp"));
+        assert!(is_cpu_hwmon("zenpower"));
+        assert!(is_cpu_hwmon("cpu_thermal\n"), "trailing newline is trimmed");
+        assert!(!is_cpu_hwmon("amdgpu"), "a GPU sensor is not the CPU");
+        assert!(!is_cpu_hwmon("nvme"));
+        assert!(!is_cpu_hwmon(""));
+    }
+
+    #[test]
+    fn pick_cpu_temp_prefers_package_channel() {
+        // Intel coretemp: `Package id 0` wins over the per-core channels.
+        let intel = vec![
+            (Some("Core 0".to_string()), 45000.0),
+            (Some("Package id 0".to_string()), 52000.0),
+            (Some("Core 1".to_string()), 47000.0),
+        ];
+        assert_eq!(pick_cpu_temp(&intel), Some(52.0));
+
+        // AMD k10temp: `Tctl` wins over `Tccd1`.
+        let amd = vec![
+            (Some("Tccd1".to_string()), 58000.0),
+            (Some("Tctl".to_string()), 61000.0),
+        ];
+        assert_eq!(pick_cpu_temp(&amd), Some(61.0));
+
+        // No labels at all: fall back to the first channel (temp1_input).
+        let bare = vec![(None, 40000.0), (None, 99000.0)];
+        assert_eq!(pick_cpu_temp(&bare), Some(40.0));
+
+        // No channels: unknown, never a fake zero.
+        assert_eq!(pick_cpu_temp(&[]), None);
+    }
+
+    #[test]
+    fn remote_snapshot_reads_cpu_temp() {
+        let raw = "\
+CLK\t100
+@STAT@
+cpu  1 2 3 4 5 6 7 8
+@CPUTEMP@
+T\tCore 0\t45000
+T\tPackage id 0\t53000
+@PROCS@
+";
+        let snap = parse_remote_snapshot(raw);
+        assert_eq!(snap.cpu_temp_c, Some(53.0), "host package temp is surfaced");
+    }
+
+    #[test]
+    fn is_mem_hwmon_matches_only_dimm_sensors() {
+        assert!(is_mem_hwmon("jc42"), "DDR3/DDR4 on-module sensor");
+        assert!(is_mem_hwmon("spd5118\n"), "DDR5 SPD hub, newline trimmed");
+        assert!(!is_mem_hwmon("coretemp"), "a CPU sensor is not memory");
+        assert!(!is_mem_hwmon("amdgpu"));
+        assert!(!is_mem_hwmon(""));
+    }
+
+    #[test]
+    fn remote_snapshot_reads_hottest_dimm_temp() {
+        let raw = "\
+CLK\t100
+@STAT@
+cpu  1 2 3 4 5 6 7 8
+@MEMTEMP@
+M\t41000
+M\t46500
+M\t44000
+@PROCS@
+";
+        let snap = parse_remote_snapshot(raw);
+        assert_eq!(snap.mem_temp_c, Some(46.5), "hottest module wins");
+    }
+
+    #[test]
+    fn remote_snapshot_has_no_mem_temp_when_section_empty() {
+        let raw = "CLK\t100\n@STAT@\ncpu  1 2 3 4 5 6 7 8\n@MEMTEMP@\n@PROCS@\n";
+        assert_eq!(parse_remote_snapshot(raw).mem_temp_c, None);
     }
 
     #[test]
     fn descendant_pids_includes_its_own_root() {
-        let _guard = CACHE_TEST_LOCK.lock().unwrap();
+        let _guard = lock_cache_for_test();
         let me = std::process::id();
         let pids = descendant_pids(&[me]);
         assert!(pids.contains(&me), "descendant set must contain the root pid itself");
@@ -234,7 +2218,7 @@ mod tests {
 
     #[test]
     fn descendant_pids_serves_cache_hit_for_unchanged_generation() {
-        let _guard = CACHE_TEST_LOCK.lock().unwrap();
+        let _guard = lock_cache_for_test();
         // Directly exercise the cache mechanics independent of the live process
         // tree (other parallel tests fork children, so the *real* tree is not a
         // stable fixture). Seed the cache with a synthetic entry, then confirm a
@@ -253,18 +2237,18 @@ mod tests {
             });
         }
         // Same roots + same generation + fresh → cache hit returns the seeded set
-        // (which could never come from a real /proc walk for pid 424242).
+        // (which could never come from a real process walk for pid 424242).
         assert_eq!(descendant_pids(&[424242]), fake_pids);
 
         // Invalidation bumps the generation, so the stale synthetic entry is no
-        // longer reused — the rebuild walks /proc and 999999 is gone.
+        // longer reused — the rebuild walks the real tree and 999999 is gone.
         invalidate_descendant_cache();
         assert_ne!(descendant_pids(&[424242]), fake_pids);
     }
 
     #[test]
     fn descendant_pids_cache_keys_on_root_set() {
-        let _guard = CACHE_TEST_LOCK.lock().unwrap();
+        let _guard = lock_cache_for_test();
         // A seeded entry for one root set must not satisfy a query for another.
         let gen = PROC_TREE_GEN.load(Ordering::Relaxed);
         {
@@ -281,6 +2265,10 @@ mod tests {
         assert!(!other.contains(&222222));
     }
 
+    // The sampling assertions below rely on a real process backend (Linux `/proc`
+    // or Windows ToolHelp). On the zero fallback they would trivially fail, so
+    // they are scoped to the two backends that actually sample.
+    #[cfg(any(target_os = "linux", target_os = "windows"))]
     #[test]
     fn sum_jiffies_counts_a_live_process_and_skips_dead_ones() {
         let me = std::process::id();
@@ -290,15 +2278,529 @@ mod tests {
             acc = acc.wrapping_add(i);
         }
         assert!(acc > 0);
-        assert!(sum_jiffies(&[me]) > 0, "the running test process should report jiffies");
+        assert!(sum_jiffies(&[me]) > 0, "the running test process should report ticks");
         // A pid that cannot exist contributes nothing rather than panicking.
         assert_eq!(sum_jiffies(&[u32::MAX]), 0);
     }
 
+    #[cfg(any(target_os = "linux", target_os = "windows"))]
     #[test]
     fn sum_rss_counts_a_live_process_and_skips_dead_ones() {
         let me = std::process::id();
         assert!(sum_rss_kib(&[me]) > 0, "the running test process should report RSS");
         assert_eq!(sum_rss_kib(&[u32::MAX]), 0);
     }
+
+    // ── /proc string parsers (pure; run on any OS) ──────────────────────────
+
+    #[test]
+    fn parse_cpu_stat_splits_aggregate_and_cores() {
+        let stat = "\
+cpu  100 20 30 1000 40 5 5 0 0 0
+cpu0 60 10 15 500 20 3 2 0 0 0
+cpu1 40 10 15 500 20 2 3 0 0 0
+intr 12345
+ctxt 67890
+";
+        let (agg, cores) = parse_cpu_stat(stat);
+        // total = sum of all columns; busy = total - idle - iowait.
+        assert_eq!(agg.total, 100 + 20 + 30 + 1000 + 40 + 5 + 5);
+        assert_eq!(agg.busy, agg.total - 1000 - 40);
+        assert_eq!(cores.len(), 2);
+        assert_eq!(cores[0].total, 60 + 10 + 15 + 500 + 20 + 3 + 2);
+        assert_eq!(cores[0].busy, cores[0].total - 500 - 20);
+    }
+
+    #[test]
+    fn parse_meminfo_reads_selected_keys() {
+        let mem = "\
+MemTotal:       16308668 kB
+MemFree:         1234567 kB
+MemAvailable:    9876543 kB
+Buffers:          123456 kB
+SwapTotal:       2097148 kB
+SwapFree:        2000000 kB
+";
+        let (total, avail, swap_total, swap_free) = parse_meminfo(mem);
+        assert_eq!(total, 16_308_668);
+        assert_eq!(avail, 9_876_543);
+        assert_eq!(swap_total, 2_097_148);
+        assert_eq!(swap_free, 2_000_000);
+        // A missing key defaults to 0 rather than panicking.
+        assert_eq!(parse_meminfo("MemTotal: 42 kB").1, 0);
+    }
+
+    #[test]
+    fn parse_loadavg_reads_three_floats() {
+        assert_eq!(parse_loadavg("0.52 0.58 0.59 1/1234 56789"), [0.52, 0.58, 0.59]);
+        // Short/garbage input degrades to zeros.
+        assert_eq!(parse_loadavg(""), [0.0, 0.0, 0.0]);
+    }
+
+    // ── Windows byte decoders (pure; run on any OS) ─────────────────────────
+
+    /// Build one 48-byte SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION entry.
+    fn perf_entry(idle: i64, kernel: i64, user: i64) -> Vec<u8> {
+        let mut out = Vec::with_capacity(PROCESSOR_PERF_ENTRY_BYTES);
+        for v in [idle, kernel, user, 0i64, 0i64] {
+            out.extend_from_slice(&v.to_le_bytes());
+        }
+        out.extend_from_slice(&[0u8; 8]); // InterruptCount + padding
+        out
+    }
+
+    #[test]
+    fn parse_processor_perf_buffer_derives_busy_and_total() {
+        let mut buf = perf_entry(1_000, 1_500, 300); // kernel includes idle
+        buf.extend(perf_entry(0, 200, 100));
+        let cores = parse_processor_perf_buffer(&buf);
+        assert_eq!(cores.len(), 2);
+        assert_eq!(cores[0].total, 1_800);
+        assert_eq!(cores[0].busy, 800); // (kernel − idle) + user
+        assert_eq!(cores[1].total, 300);
+        assert_eq!(cores[1].busy, 300);
+    }
+
+    #[test]
+    fn parse_processor_perf_buffer_ignores_partial_tail_and_clamps() {
+        // A short trailing chunk (returned length mid-entry) is dropped, and a
+        // negative time (corrupt input) clamps to 0 instead of wrapping.
+        let mut buf = perf_entry(-5, -10, 40);
+        buf.extend_from_slice(&[0u8; 20]);
+        let cores = parse_processor_perf_buffer(&buf);
+        assert_eq!(cores.len(), 1);
+        assert_eq!(cores[0].total, 40);
+        assert_eq!(cores[0].busy, 40);
+        assert!(parse_processor_perf_buffer(&[]).is_empty());
+    }
+
+    #[test]
+    fn decode_ansi_nul_stops_at_nul_and_is_lossy() {
+        let mut raw = [0i8; 16];
+        for (i, b) in b"explorer.exe".iter().enumerate() {
+            raw[i] = *b as i8;
+        }
+        raw[13] = b'x' as i8; // garbage after the NUL must be ignored
+        assert_eq!(decode_ansi_nul(&raw), "explorer.exe");
+        assert_eq!(decode_ansi_nul(&[-28, 0]), "\u{fffd}"); // lone 0xE4 byte
+        assert_eq!(decode_ansi_nul(&[]), "");
+    }
+
+    // ── macOS decoders (pure; run on any OS) ────────────────────────────────
+
+    #[test]
+    fn parse_host_processor_ticks_scales_to_ns_and_sums_busy() {
+        // Two cores, CPU_STATE order user/system/idle/nice, clk_tck=100 →
+        // ns_per_tick = 10_000_000.
+        let ticks = [100u32, 50, 800, 10, 0, 0, 1000, 0];
+        let cores = parse_host_processor_ticks(&ticks, 10_000_000);
+        assert_eq!(cores.len(), 2);
+        assert_eq!(cores[0].busy, (100 + 50 + 10) * 10_000_000);
+        assert_eq!(cores[0].total, (100 + 50 + 10 + 800) * 10_000_000);
+        assert_eq!(cores[1].busy, 0);
+        assert_eq!(cores[1].total, 1000 * 10_000_000);
+    }
+
+    #[test]
+    fn parse_host_processor_ticks_ignores_partial_tail() {
+        // A truncated final chunk (interrupted copy-out) is dropped, and huge
+        // cumulative counters don't overflow at ns scale within u64.
+        let cores = parse_host_processor_ticks(&[u32::MAX, 0, u32::MAX, 0, 7, 7], 10_000_000);
+        assert_eq!(cores.len(), 1);
+        assert_eq!(cores[0].busy, u32::MAX as u64 * 10_000_000);
+        assert!(parse_host_processor_ticks(&[1, 2, 3], 1).is_empty());
+    }
+
+    #[test]
+    fn bsd_process_state_maps_to_linux_letters() {
+        assert_eq!(bsd_process_state(2), "R"); // SRUN
+        assert_eq!(bsd_process_state(3), "S"); // SSLEEP
+        assert_eq!(bsd_process_state(4), "T"); // SSTOP
+        assert_eq!(bsd_process_state(5), "Z"); // SZOMB
+        assert_eq!(bsd_process_state(1), "I"); // SIDL
+        assert_eq!(bsd_process_state(0), "");
+        assert_eq!(bsd_process_state(99), "");
+    }
+
+    #[test]
+    fn parse_pid_stat_handles_comm_with_spaces_and_parens() {
+        // comm = "Web Content" (spaces); a naive whitespace split would misalign
+        // every field — parsing must key off the last ')'.
+        let line = "1234 (Web (Content)) S 1000 1234 1000 0 -1 4194560 \
+100 0 0 0 4200 1300 0 0 20 0 27 0 999 0 0";
+        let (comm, state, ppid, cpu, threads) = parse_pid_stat(line).unwrap();
+        assert_eq!(comm, "Web (Content)");
+        assert_eq!(state, "S");
+        assert_eq!(ppid, 1000);
+        assert_eq!(cpu, 4200 + 1300); // utime + stime
+        assert_eq!(threads, 27);
+    }
+
+    #[test]
+    fn parse_remote_snapshot_assembles_from_script_output() {
+        // A minimal but complete capture in the wire format REMOTE_SNAPSHOT_SCRIPT
+        // emits: a CLK line, `@SECTION@` blocks of raw kernel files (incl. `who`),
+        // pid-keyed S/R lines under `@PROCS@`, then the separate `@CMDLINE@` block.
+        // One core, 8 GiB RAM, two processes — one with a real cmdline, one kernel
+        // thread, which (having an empty cmdline) `grep` emits NO line for at all,
+        // exercising the `[comm]` fallback on a genuinely absent entry.
+        let raw = "CLK\t100\n\
+@STAT@\n\
+cpu  100 0 50 800 0 0 0 0 0 0\n\
+cpu0 100 0 50 800 0 0 0 0 0 0\n\
+intr 12345\n\
+@MEM@\n\
+MemTotal:        8192000 kB\n\
+MemAvailable:    4096000 kB\n\
+SwapTotal:       2048000 kB\n\
+SwapFree:        2048000 kB\n\
+@LOAD@\n\
+0.50 0.40 0.30 1/234 5678\n\
+@UP@\n\
+123456.78 987654.32\n\
+@WHO@\n\
+alice    pts/0        2026-07-18 09:12 (203.0.113.5)\n\
+alice    pts/1        2026-07-18 09:20 (203.0.113.5)\n\
+bob      tty1         2026-07-17 22:03\n\
+@PROCS@\n\
+S\t42\t42 (bash) S 1 42 42 0 -1 4194304 100 0 0 0 12 8 0 0 20 0 3 0 999 0 0\n\
+R\t42\t2048\n\
+S\t7\t7 (kworker/0:1) I 2 0 0 0 -1 69238880 0 0 0 0 5 2 0 0 20 0 1 0 50 0 0\n\
+R\t7\t0\n\
+@CMDLINE@\n\
+/proc/42/cmdline:/usr/bin/bash -i\n";
+
+        let snap = parse_remote_snapshot(raw);
+        assert!(snap.supported);
+        assert_eq!(snap.clk_tck, 100);
+        assert_eq!(snap.num_cores, 1);
+        assert_eq!(snap.per_core.len(), 1);
+        // total = sum of all columns; busy = total − idle − iowait (800 idle here).
+        assert_eq!(snap.cpu.total, 100 + 50 + 800);
+        assert_eq!(snap.cpu.busy, 150);
+        assert_eq!(snap.mem_total_kib, 8_192_000);
+        assert_eq!(snap.mem_available_kib, 4_096_000);
+        assert_eq!(snap.swap_total_kib, 2_048_000);
+        assert_eq!(snap.load_avg, [0.50, 0.40, 0.30]);
+        assert_eq!(snap.uptime_secs as u64, 123_456);
+        assert!(snap.gpus.is_empty());
+
+        // Looked up by pid, not by index: the blocks are joined on the pid key, so
+        // the table's order is not what this is asserting.
+        assert_eq!(snap.processes.len(), 2);
+        let by_pid = |pid: u32| snap.processes.iter().find(|p| p.pid == pid).unwrap();
+        let bash = by_pid(42);
+        assert_eq!(bash.ppid, 1);
+        assert_eq!(bash.comm, "bash");
+        assert_eq!(bash.state, "S");
+        assert_eq!(bash.rss_kib, 2048);
+        assert_eq!(bash.cpu_jiffies, 12 + 8);
+        assert_eq!(bash.threads, 3);
+        assert_eq!(bash.cmdline, "/usr/bin/bash -i");
+        // Kernel thread: no `@CMDLINE@` line at all falls back to `[comm]`.
+        let kworker = by_pid(7);
+        assert_eq!(kworker.rss_kib, 0);
+        assert_eq!(kworker.cmdline, "[kworker/0:1]");
+
+        // `who` → login sessions for the "Logged in" panel: three sessions across
+        // two users, the tail of each line kept verbatim as `detail`.
+        assert_eq!(snap.sessions.len(), 3);
+        assert_eq!(snap.sessions[0].user, "alice");
+        assert_eq!(snap.sessions[0].tty, "pts/0");
+        assert!(snap.sessions[0].detail.contains("203.0.113.5"));
+        assert_eq!(snap.sessions[2].user, "bob");
+        assert_eq!(snap.sessions[2].tty, "tty1");
+        // No `ME` line (a host whose `id -un` said nothing): no row is invented and
+        // none is flagged, rather than an owner being guessed.
+        assert!(!snap.sessions.iter().any(|s| s.is_self));
+    }
+
+    #[test]
+    fn who_synthesizes_the_sampling_account_when_utmp_has_no_record() {
+        // The bug this fixes: `who` reads utmp, which only gets an entry when sshd
+        // allocated a pty. The monitor's own probe rides the pooled (non-pty)
+        // master, so a user with no terminal tab open on the host saw everyone
+        // logged in EXCEPT themselves.
+        let who = "\
+alice    pts/0        2026-07-18 09:12 (203.0.113.5)\n\
+bob      tty1         2026-07-17 22:03\n";
+        let sessions = parse_who(who, "carol");
+        assert_eq!(sessions.len(), 3);
+        // The synthesized row comes first and is flagged; the others are untouched.
+        assert_eq!(sessions[0].user, "carol");
+        assert!(sessions[0].is_self);
+        assert_eq!(sessions[0].tty, SELF_SESSION_TTY);
+        assert!(!sessions[1].is_self && !sessions[2].is_self);
+
+        // An account that DOES hold a pty session is only flagged — never doubled.
+        let sessions = parse_who(who, "alice");
+        assert_eq!(sessions.len(), 2);
+        assert_eq!(sessions[0].user, "alice");
+        assert!(sessions[0].is_self);
+        assert_eq!(sessions[0].tty, "pts/0");
+        assert!(!sessions[1].is_self);
+
+        // Careful mode ships only this account's own `who` lines — and an HPC login
+        // node the user reached without a pty ships none at all, which is exactly
+        // the case that used to read "no interactive logins on this host".
+        let sessions = parse_who("", "carol");
+        assert_eq!(sessions.len(), 1);
+        assert!(sessions[0].is_self);
+
+        // Unknown account: nothing invented.
+        assert!(parse_who("", "").is_empty());
+    }
+
+    #[test]
+    fn parse_passwd_maps_uid_to_name() {
+        let content = "\
+root:x:0:0:root:/root:/bin/bash
+alice:x:1000:1000:Alice:/home/alice:/bin/bash
+bob:x:1001:1001::/home/bob:/bin/zsh
+# a comment line is skipped
+malformed-no-uid
+daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
+";
+        let map = parse_passwd(content);
+        assert_eq!(map.get(&0).map(String::as_str), Some("root"));
+        assert_eq!(map.get(&1000).map(String::as_str), Some("alice"));
+        assert_eq!(map.get(&1001).map(String::as_str), Some("bob"));
+        assert_eq!(map.get(&1).map(String::as_str), Some("daemon"));
+        // A known uid resolves to its name; an unknown one falls back to `#<uid>`.
+        assert_eq!(username_for(1000, &map), "alice");
+        assert_eq!(username_for(4242, &map), "#4242");
+    }
+
+    #[test]
+    fn parse_remote_snapshot_joins_cmdline_by_pid() {
+        // `@CMDLINE@` is captured by its own pass over `/proc` (one `grep`, not a
+        // fork per process), so it neither lines up positionally with `@PROCS@`
+        // nor is guaranteed to describe the same set of pids. The join is on the
+        // pid grep puts in its `/proc/<pid>/cmdline:` prefix, and this pins the
+        // four ways that block can disagree with the process table.
+        let raw = "CLK\t100\n\
+@PROCS@\n\
+S\t42\t42 (bash) S 1 42 42 0 -1 4194304 100 0 0 0 12 8 0 0 20 0 3 0 999 0 0\n\
+R\t42\t2048\n\
+S\t7\t7 (kworker/0:1) I 2 0 0 0 -1 69238880 0 0 0 0 5 2 0 0 20 0 1 0 50 0 0\n\
+R\t7\t0\n\
+@CMDLINE@\n\
+/proc/999/cmdline:started-after-the-procs-pass\n\
+/proc/42/cmdline:env PATH=/usr/bin:/bin prog --flag\n\
+a continuation line from an arg containing a newline\n";
+
+        let snap = parse_remote_snapshot(raw);
+        let by_pid = |pid: u32| snap.processes.iter().find(|p| p.pid == pid).unwrap();
+        // A cmdline is not split on its own colons — only the grep prefix is.
+        assert_eq!(by_pid(42).cmdline, "env PATH=/usr/bin:/bin prog --flag");
+        // No `@CMDLINE@` line at all (a kernel thread's is empty, so grep emits
+        // nothing for it) → the `[comm]` fallback, not a blank name.
+        assert_eq!(by_pid(7).cmdline, "[kworker/0:1]");
+        // A cmdline for a pid the `@PROCS@` pass never saw invents no process:
+        // `S` is what declares one exists.
+        assert_eq!(snap.processes.len(), 2);
+        assert!(snap.processes.iter().all(|p| p.pid != 999));
+    }
+
+    #[test]
+    fn parse_remote_snapshot_resolves_process_owner() {
+        // The @PASSWD@ block feeds the uid→name map; each process's `U` line names
+        // its owner uid, resolved against that map (an unmapped uid → `#<uid>`).
+        let raw = "CLK\t100\n\
+@PASSWD@\n\
+root:x:0:0:root:/root:/bin/bash\n\
+alice:x:1000:1000:Alice:/home/alice:/bin/bash\n\
+@PROCS@\n\
+S\t42\t42 (bash) S 1 42 42 0 -1 4194304 100 0 0 0 12 8 0 0 20 0 3 0 999 0 0\n\
+U\t42\t1000\n\
+R\t42\t2048\n\
+S\t1\t1 (systemd) S 0 1 1 0 -1 4194560 200 0 0 0 5 5 0 0 20 0 1 0 5 0 0\n\
+U\t1\t0\n\
+R\t1\t4096\n\
+S\t99\t99 (weird) S 1 99 99 0 -1 4194304 1 0 0 0 1 1 0 0 20 0 1 0 100 0 0\n\
+U\t99\t7777\n\
+R\t99\t128\n\
+S\t55\t55 (silent) S 1 55 55 0 -1 4194304 1 0 0 0 1 1 0 0 20 0 1 0 100 0 0\n\
+R\t55\t64\n\
+@CMDLINE@\n\
+/proc/42/cmdline:/usr/bin/bash -i\n\
+/proc/1/cmdline:/sbin/init\n\
+/proc/99/cmdline:weird\n";
+
+        let snap = parse_remote_snapshot(raw);
+        let by_pid = |pid: u32| snap.processes.iter().find(|p| p.pid == pid).unwrap();
+        assert_eq!(snap.processes.len(), 4);
+        assert_eq!(by_pid(42).user, "alice");
+        assert_eq!(by_pid(1).user, "root");
+        // An owner uid with no passwd entry falls back to `#<uid>`.
+        assert_eq!(by_pid(99).user, "#7777");
+        // pid 55 shipped no `U` line at all (its `status` withheld `Uid:`). That
+        // must read as "owner unknown" — blank — and NOT as uid 0, which the old
+        // `${u:-0}` default turned every unreadable process into root.
+        assert_eq!(by_pid(55).user, "");
+        // No `CAREFUL` line at all is an ordinary (non-HPC) host: full collection,
+        // and an unknown owner stays unknown rather than being bucketed.
+        assert!(!snap.careful);
+    }
+
+    #[test]
+    fn a_careful_sample_keeps_own_processes_and_buckets_everyone_else() {
+        // What an HPC login node ships (`docs/context/hpc_careful_mode.md`): the
+        // leading `CAREFUL` flag, a `@PASSWD@` holding ONLY the sampling account,
+        // `U` lines only for its own processes, every foreign `comm` redacted to
+        // `(other)` in the stat line, and cmdlines only for its own pids.
+        let raw = "CAREFUL\t1\n\
+CLK\t100\n\
+@WHO@\n\
+alice    pts/0        2026-07-18 09:12\n\
+@PASSWD@\n\
+alice:x:1000:1000:Alice:/home/alice:/bin/bash\n\
+@PROCS@\n\
+S\t42\t42 (python3) S 1 42 42 0 -1 4194304 100 0 0 0 12 8 0 0 20 0 3 0 999 0 0\n\
+U\t42\t1000\n\
+R\t42\t2048\n\
+S\t77\t77 (other) S 1 77 77 0 -1 4194304 100 0 0 0 90 10 0 0 20 0 8 0 400 0 0\n\
+R\t77\t8192\n\
+S\t78\t78 (other) S 1 78 78 0 -1 4194304 100 0 0 0 30 5 0 0 20 0 2 0 410 0 0\n\
+R\t78\t4096\n\
+@CMDLINE@\n\
+/proc/42/cmdline:python3 train.py --epochs 3\n\
+@PASSWD2@\n";
+
+        let snap = parse_remote_snapshot(raw);
+        assert!(snap.careful);
+        let by_pid = |pid: u32| snap.processes.iter().find(|p| p.pid == pid).unwrap();
+        // Own process: full detail, resolved against the one passwd entry shipped.
+        assert_eq!(by_pid(42).user, "alice");
+        assert_eq!(by_pid(42).cmdline, "python3 train.py --epochs 3");
+        // Everyone else: still counted (that is the "how loaded is this node"
+        // half), but under ONE label — not a uid each, which would be the same
+        // per-person breakdown by another name — and with no command to read.
+        assert_eq!(by_pid(77).user, OTHER_USERS);
+        assert_eq!(by_pid(78).user, OTHER_USERS);
+        assert_eq!(by_pid(77).cmdline, "[other]");
+        assert_eq!(by_pid(77).rss_kib, 8192);
+        assert_eq!(by_pid(77).cpu_jiffies, 90 + 10);
+        // The bucket is one row in the pane's per-user breakdown, whatever the
+        // number of foreign processes behind it.
+        let labels: std::collections::BTreeSet<&str> =
+            snap.processes.iter().map(|p| p.user.as_str()).collect();
+        assert_eq!(labels.len(), 2);
+    }
+
+    #[test]
+    fn careful_mode_is_pinned_by_prefix_or_left_to_the_host() {
+        // A caller with an answer pins it in either direction; `None` leaves the
+        // script's own SLURM probe to decide.
+        let forced = remote_snapshot_script(Some(true));
+        assert!(forced.starts_with("ELDRUN_CAREFUL=1\n"));
+        assert!(forced.ends_with(REMOTE_SNAPSHOT_SCRIPT));
+        assert!(remote_snapshot_script(Some(false)).starts_with("ELDRUN_CAREFUL=0\n"));
+        assert_eq!(remote_snapshot_script(None), REMOTE_SNAPSHOT_SCRIPT);
+        // The host-side detection and every collection branch it gates.
+        assert!(REMOTE_SNAPSHOT_SCRIPT.contains("command -v sbatch"));
+        assert!(REMOTE_SNAPSHOT_SCRIPT.contains("getent passwd \"$_myuid\""));
+        assert!(REMOTE_SNAPSHOT_SCRIPT.contains("(other)"));
+    }
+
+    #[test]
+    fn parse_remote_snapshot_falls_back_to_passwd2_for_a_missing_uid() {
+        // Regression for the "Logged in" panel reading a permanent 0%: on an NSS
+        // setup that serves point lookups but not enumeration (SSSD's default
+        // `enumerate = false`), the bulk `@PASSWD@` dump lists only `root` — a
+        // directory-backed user like `carol` (uid 2000) is missing from it — but
+        // `@PASSWD2@`'s targeted per-uid lookup (which the script runs for every
+        // uid actually seen under `@PROCS@`) still resolves it. Her `who` name and
+        // her process owner must end up as the exact same string, or the "Logged
+        // in" panel's username-keyed CPU/MEM lookup misses and reads 0.
+        let raw = "CLK\t100\n\
+@WHO@\n\
+carol    pts/0        2026-07-18 09:12\n\
+@PASSWD@\n\
+root:x:0:0:root:/root:/bin/bash\n\
+@PROCS@\n\
+S\t42\t42 (bash) S 1 42 42 0 -1 4194304 100 0 0 0 12 8 0 0 20 0 3 0 999 0 0\n\
+U\t42\t2000\n\
+R\t42\t2048\n\
+@CMDLINE@\n\
+/proc/42/cmdline:/usr/bin/bash -i\n\
+@PASSWD2@\n\
+carol:x:2000:2000:Carol:/home/carol:/bin/bash\n";
+
+        let snap = parse_remote_snapshot(raw);
+        assert_eq!(snap.processes.len(), 1);
+        assert_eq!(snap.processes[0].user, "carol", "resolved via the @PASSWD2@ supplement");
+        assert_eq!(snap.sessions[0].user, "carol");
+        assert_eq!(
+            snap.processes[0].user, snap.sessions[0].user,
+            "the process owner and the who-reported name must match for the \
+             \"Logged in\" panel's username-keyed lookup to attribute her CPU/MEM"
+        );
+    }
+
+    #[test]
+    fn parse_remote_snapshot_prefers_bulk_passwd_over_passwd2_on_conflict() {
+        // @PASSWD2@ only fills gaps the bulk dump left — it must never override an
+        // already-resolved name (`or_insert`, not overwrite).
+        let raw = "CLK\t100\n\
+@PASSWD@\n\
+alice:x:1000:1000:Alice:/home/alice:/bin/bash\n\
+@PROCS@\n\
+S\t42\t42 (bash) S 1 42 42 0 -1 4194304 100 0 0 0 12 8 0 0 20 0 3 0 999 0 0\n\
+U\t42\t1000\n\
+R\t42\t2048\n\
+@CMDLINE@\n\
+/proc/42/cmdline:/usr/bin/bash -i\n\
+@PASSWD2@\n\
+someone-else:x:1000:1000:Someone Else:/home/x:/bin/bash\n";
+
+        let snap = parse_remote_snapshot(raw);
+        assert_eq!(snap.processes[0].user, "alice");
+    }
+
+    #[test]
+    fn parse_remote_snapshot_reads_the_gpu_section() {
+        // The `@GPU@` wire format: an AMD card shipped file-by-file, an NVIDIA card
+        // as raw nvidia-smi CSV, and one NVIDIA compute process. A blank AMD value
+        // (a file the host didn't expose) must be skipped, not stored.
+        let raw = "CLK\t100\n\
+@GPU@\n\
+NVSMI\tNVIDIA RTX A4000, 2048, 16376, 55, 63, 90.0, 140, 1800, 7000, 44, 550.90.07, 4, 16\n\
+NVPROC\t4321, python, 1536\n\
+AMD\t1\tdriver\tamdgpu\n\
+AMD\t1\tvendor\t0x1002\n\
+AMD\t1\tvram_used\t440770560\n\
+AMD\t1\tvram_total\t536870912\n\
+AMD\t1\tgtt_used\t18052190208\n\
+AMD\t1\tgtt_total\t65855619072\n\
+AMD\t1\tbusy\t72\n\
+AMD\t1\ttemp\t58000\n\
+AMD\t1\tsclk\t2: 2900Mhz *\n\
+AMD\t1\tlink_speed\t\n\
+@PROCS@\n";
+
+        let snap = parse_remote_snapshot(raw);
+        assert_eq!(snap.gpus.len(), 2, "one AMD card + one NVIDIA card");
+
+        // AMD card comes first (built from the shipped sysfs files).
+        let amd = &snap.gpus[0];
+        assert_eq!(amd.driver, "amdgpu");
+        assert_eq!(amd.vram_total, 536_870_912);
+        assert_eq!(amd.shared_total, 65_855_619_072);
+        assert_eq!(amd.busy_percent, Some(72.0));
+        assert_eq!(amd.temp_c, Some(58.0));
+        assert_eq!(amd.sclk_mhz, Some(2900));
+        assert_eq!(amd.pcie_gen, None, "a blank link_speed line was skipped");
+
+        // NVIDIA card, parsed by the same CSV reader as the local path.
+        let nv = &snap.gpus[1];
+        assert_eq!(nv.driver, "nvidia");
+        assert_eq!(nv.temp_c, Some(63.0));
+        assert_eq!(nv.power_w, Some(90.0));
+        assert_eq!(nv.driver_version.as_deref(), Some("550.90.07"));
+
+        assert_eq!(snap.gpu_procs.len(), 1);
+        assert_eq!(snap.gpu_procs[0].pid, 4321);
+        assert_eq!(snap.gpu_procs[0].mem_bytes, 1536 * 1024 * 1024);
+    }
 }
diff --git a/src-tauri/src/terminal/mod.rs b/src-tauri/src/terminal/mod.rs
index fcd8ca9..ba64772 100644
--- a/src-tauri/src/terminal/mod.rs
+++ b/src-tauri/src/terminal/mod.rs
@@ -48,6 +48,44 @@ pub struct PtyOptions {
     /// (e.g. Ollama `local_agent` tabs that depend on local `VIBE_HOME`).
     #[serde(default)]
     pub local_only: bool,
+    /// When true, run this (agent) tab inside a Docker sandbox that mounts only
+    /// the project directory. Set by the frontend only for `kind:"agent"` tabs
+    /// of a project whose sandbox toggle is enabled. See `services::sandbox`.
+    #[serde(default)]
+    pub sandbox: bool,
+    /// The owning project's id, set by the frontend for tabs that belong to a
+    /// project scope (not the root scope). It makes remoteness **explicit**: the
+    /// ssh-wrap spawn path resolves the project's `RemoteSpec` from this id (via
+    /// `services::remote::remote_target_for`) instead of sniffing whether `cwd`
+    /// lives under the sshfs mounts root. `None` for root/connection terminals
+    /// (and any spawn path not yet updated), where the cwd-sniffing fallback
+    /// still applies. Harmless for local projects — they resolve to no remote.
+    #[serde(default)]
+    pub project_id: Option<String>,
+    /// Which of the project's remote hosts this tab runs on
+    /// (`docs/multi_host_remote_plan.md`): `None`/`"primary"` = the primary remote
+    /// (`Project.remote`), any other id = an extra "worker" host from
+    /// `compute_hosts`. Set by the frontend from the tab's `host:<id>` location.
+    /// Ignored for a local project (resolves to no remote).
+    #[serde(default)]
+    pub remote_host_id: Option<String>,
+    /// Persistent remote session (TODO #85): the **stable tmux session name** to
+    /// spawn-or-attach on the host, wrapping the spawn in `tmux new-session -A` so
+    /// the run survives an SSH drop / laptop sleep / Eldrun relaunch. The frontend
+    /// mints it once per shell tab and **persists it** (`TabEntry.tmuxSession`), so
+    /// it is stable across a relaunch even though the tab's PTY id (`scope:key`) is
+    /// regenerated on restore — that stability is what makes reattach work. Set
+    /// only for remote shell/script tabs of a persist-enabled project (agent tabs
+    /// are excluded — they resume via their own session). `None`/local → no wrap.
+    #[serde(default)]
+    pub tmux_session: Option<String>,
+    /// Attach this tab to an **existing named** tmux session on the host instead
+    /// of spawning a fresh one (TODO #85): set when a tab is opened from the
+    /// Sessions view onto a running (possibly hand-started) session, and persisted
+    /// so the tab reattaches to that same session across a restart. Takes
+    /// precedence over `tmux_session` when set. No-op for a local project.
+    #[serde(default)]
+    pub tmux_attach: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -79,12 +117,90 @@ struct PtyEntry {
 
 /// Invalidate the cached process tree used for CPU sampling. Called whenever a
 /// PTY is spawned or dies so the next `sysstat::descendant_pids` rebuilds rather
-/// than reusing a stale walk. No-op off Linux (sysstat is Linux-only).
+/// than reusing a stale walk. `sysstat` is cross-platform (Linux/Windows sample,
+/// other OSes return zero), so this is a plain atomic bump everywhere.
 fn invalidate_proc_tree_cache() {
-    #[cfg(target_os = "linux")]
     crate::sysstat::invalidate_descendant_cache();
 }
 
+/// How aggressively [`reap_child_subtree`] signals a doomed process subtree.
+enum ReapMode {
+    /// SIGTERM now, then SIGKILL any survivors after a short grace period on a
+    /// detached thread. Used on tab close / respawn, where the app stays alive
+    /// long enough to deliver the escalation.
+    Graceful,
+    /// SIGKILL immediately. Used at app exit, where a delayed escalation thread
+    /// would be torn down with the process before it could fire.
+    Immediate,
+}
+
+/// Best-effort abort of a PTY child's **entire process subtree**.
+///
+/// `portable_pty`'s [`Child::kill`] signals only the shell leader; anything it
+/// spawned (a dev server, a build, a training run) is otherwise orphaned and
+/// keeps running after its tab — or the whole app — is gone. So we walk the
+/// subtree rooted at the leader and signal every pid. The walk must happen
+/// *before* the leader is killed: once it dies its children reparent to init and
+/// the tree rooted at its pid is no longer reachable.
+///
+/// The leader pid is included in the returned set; re-signalling a leader the
+/// caller also `Child::kill`s is a harmless no-op (a dead pid yields ESRCH).
+fn reap_child_subtree(leader_pid: u32, mode: ReapMode) {
+    // Force a fresh process-tree walk rather than reusing a cached CPU sample
+    // that may predate a just-spawned child.
+    crate::sysstat::invalidate_descendant_cache();
+    let subtree = crate::sysstat::descendant_pids(&[leader_pid]);
+    reap_pids(subtree, mode);
+}
+
+/// Signal a set of pids best-effort. Every pid came from a live process walk
+/// moments earlier, so a stale one is expected and ignored (ESRCH on Unix, a
+/// failed `OpenProcess` on Windows).
+#[cfg(unix)]
+fn reap_pids(pids: Vec<u32>, mode: ReapMode) {
+    if pids.is_empty() {
+        return;
+    }
+    // SAFETY: `libc::kill` takes no pointers and a real signal number; a stale
+    // pid returns ESRCH, which we ignore.
+    let signal = |pids: &[u32], sig: libc::c_int| unsafe {
+        for &pid in pids {
+            libc::kill(pid as libc::pid_t, sig);
+        }
+    };
+    match mode {
+        ReapMode::Immediate => signal(&pids, libc::SIGKILL),
+        ReapMode::Graceful => {
+            signal(&pids, libc::SIGTERM);
+            std::thread::spawn(move || {
+                std::thread::sleep(Duration::from_secs(2));
+                signal(&pids, libc::SIGKILL);
+            });
+        }
+    }
+}
+
+/// Windows has no SIGTERM/SIGKILL split — `TerminateProcess` is the only per-pid
+/// primitive — so both modes reap immediately.
+#[cfg(windows)]
+fn reap_pids(pids: Vec<u32>, _mode: ReapMode) {
+    use windows::Win32::Foundation::CloseHandle;
+    use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
+    for pid in pids {
+        // SAFETY: the handle is closed before the next iteration; a failed open
+        // (the pid already exited) is ignored.
+        unsafe {
+            if let Ok(handle) = OpenProcess(PROCESS_TERMINATE, false, pid) {
+                let _ = TerminateProcess(handle, 1);
+                let _ = CloseHandle(handle);
+            }
+        }
+    }
+}
+
+#[cfg(not(any(unix, windows)))]
+fn reap_pids(_pids: Vec<u32>, _mode: ReapMode) {}
+
 // ── PtyRegistry ───────────────────────────────────────────────────────────
 
 #[derive(Default)]
@@ -112,6 +228,12 @@ impl PtyRegistry {
         let crash_times = match self.entries.remove(&id) {
             Some(mut old) => {
                 old.dead.store(true, Ordering::SeqCst);
+                // A respawn under the same id replaces the old child; reap its
+                // whole subtree, not just the leader, so a process it spawned
+                // does not survive the tab it belonged to.
+                if let Some(pid) = old.child.process_id() {
+                    reap_child_subtree(pid, ReapMode::Graceful);
+                }
                 let _ = old.child.kill();
                 old.crash_times
             }
@@ -142,10 +264,63 @@ impl PtyRegistry {
     pub fn kill(&mut self, id: &str) {
         if let Some(mut e) = self.entries.remove(id) {
             e.dead.store(true, Ordering::SeqCst);
+            // Abort the child's whole process subtree, not just the shell leader.
+            // `child.kill()` below reaps only the leader, so a long-running
+            // descendant (a dev server, a build, a training run) started in the
+            // tab would otherwise be orphaned and keep running after the tab
+            // closes. Gather the subtree first — it is unreachable once the
+            // leader dies and its children reparent to init.
+            if let Some(pid) = e.child.process_id() {
+                reap_child_subtree(pid, ReapMode::Graceful);
+            }
             let _ = e.child.kill();
             // The tree shrank; drop the cached descendant-pid set.
             invalidate_proc_tree_cache();
+            // The tab is gone for good, so stop watching for its Codex session.
+            crate::services::codex_bind::untrack_now(id);
+            // Containerized tab: killing the child above only killed the
+            // `docker exec` CLIENT — TERM the process inside the container too
+            // (best-effort, no-op for tabs that never containerized).
+            crate::services::sandbox::kill_tab_process(id);
+        }
+    }
+
+    /// Abort every live PTY and its process subtree. Called once at app exit so
+    /// no terminal's inner process (a dev server, a build, a training run)
+    /// outlives Eldrun — dropping the registry alone kills only the shell
+    /// leaders and orphans everything they spawned. Uses [`ReapMode::Immediate`]
+    /// because a delayed escalation thread would die with the exiting process.
+    pub fn kill_all(&mut self) {
+        // One process-tree walk over all leaders (their subtrees include the
+        // leader pids themselves, which `child.kill()` below re-kills harmlessly).
+        let leaders: Vec<u32> = self
+            .entries
+            .values()
+            .filter_map(|e| e.child.process_id())
+            .collect();
+        crate::sysstat::invalidate_descendant_cache();
+        let subtree = crate::sysstat::descendant_pids(&leaders);
+
+        for (id, mut e) in self.entries.drain() {
+            e.dead.store(true, Ordering::SeqCst);
+            let _ = e.child.kill();
+            // Containerized tab: also TERM the in-container process (the docker
+            // exec client we just killed is not it).
+            crate::services::sandbox::kill_tab_process(&id);
         }
+        reap_pids(subtree, ReapMode::Immediate);
+        invalidate_proc_tree_cache();
+    }
+
+    /// True when any live (not-yet-dead) PTY belongs to `scope`. PTY ids are
+    /// `<scope>:<tab-key>` (CenterPanel), so a prefix match is authoritative.
+    /// Used by the project-container teardown to keep a deactivated project's
+    /// container alive while background tabs still run inside it.
+    pub fn any_live_for_scope(&self, scope: &str) -> bool {
+        let prefix = format!("{scope}:");
+        self.entries
+            .iter()
+            .any(|(id, e)| id.starts_with(&prefix) && !e.dead.load(Ordering::SeqCst))
     }
 
     /// OS process id of the child for `id`, if it is still tracked.
@@ -188,10 +363,19 @@ pub fn spawn_pty(
 
     let pty_system = NativePtySystem::default();
 
+    // Never open a zero-size PTY. A 0-col/0-row size can slip in if the caller
+    // spawns before xterm has measured a layout box; Unix ptys tolerate it but
+    // Windows ConPTY accepts it silently and then emits no output, which shows up
+    // as a black, dead agent tab. Clamp to a sane default so the child always has
+    // a usable window — the frontend re-sends the real size via `pty_resize` as
+    // soon as the pane is fitted.
+    let cols = if opts.cols == 0 { 80 } else { opts.cols };
+    let rows = if opts.rows == 0 { 24 } else { opts.rows };
+
     let pair = pty_system
         .openpty(PtySize {
-            rows: opts.rows,
-            cols: opts.cols,
+            rows,
+            cols,
             pixel_width: 0,
             pixel_height: 0,
         })
@@ -244,6 +428,11 @@ pub fn spawn_pty(
     });
 
     let id = opts.id.clone();
+    // Token for this *particular* spawn's Codex session tracking (None for any
+    // tab the binder isn't following). A re-spawn under the same id replaces the
+    // tracking and mints a new token, so the old process exiting below can only
+    // ever tear down its own.
+    let bind_seq = crate::services::codex_bind::current_seq(&opts.id);
     tokio::spawn(async move {
         let mut batch: Vec<u8> = Vec::with_capacity(BATCH_MAX_BYTES);
         let mut last_emit = Instant::now();
@@ -295,6 +484,10 @@ pub fn spawn_pty(
         // The child exited on its own; its subtree is gone, so the next CPU
         // sample must rebuild rather than count dead pids.
         invalidate_proc_tree_cache();
+        // Codex quit by itself (`/exit`, crash) — stop watching for its session.
+        if let Some(seq) = bind_seq {
+            crate::services::codex_bind::untrack(&id, seq);
+        }
         let _ = app.emit("terminal-exit", TerminalExit { id, code: None });
     });
 
@@ -339,15 +532,57 @@ pub fn default_shell() -> String {
 
 // ── Command builder ────────────────────────────────────────────────────────
 
+/// Wrap a resolved absolute executable path into a `CommandBuilder`. A `.exe`
+/// (or a Unix binary) runs directly; a `.cmd`/`.bat` shim (npm-style) needs
+/// `cmd.exe /c` and a `.ps1` needs PowerShell, since `CreateProcess` can't exec
+/// those directly inside the PTY.
+fn command_for_resolved(path: std::path::PathBuf) -> CommandBuilder {
+    let ext = path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.to_ascii_lowercase());
+    match ext.as_deref() {
+        Some("cmd") | Some("bat") => {
+            let mut c = CommandBuilder::new("cmd.exe");
+            c.arg("/c");
+            c.arg(path);
+            c
+        }
+        Some("ps1") => {
+            let mut c = CommandBuilder::new("powershell.exe");
+            c.arg("-NoProfile");
+            c.arg("-ExecutionPolicy");
+            c.arg("Bypass");
+            c.arg("-File");
+            c.arg(path);
+            c
+        }
+        _ => CommandBuilder::new(path),
+    }
+}
+
 fn build_command(opts: &PtyOptions) -> CommandBuilder {
     let cmd_str = if opts.cmd.is_empty() { default_shell() } else { opts.cmd.clone() };
-    let mut cmd = CommandBuilder::new(&cmd_str);
+    // A bare tool name (e.g. "vibe"/"ollama") that Eldrun detected as installed
+    // may still not be launchable on Windows: winget/uv/npm install into per-user
+    // dirs (%LOCALAPPDATA%\Programs, %USERPROFILE%\.local\bin, %APPDATA%\npm, …)
+    // that the PATH this process inherited often omits. Resolve to an absolute
+    // path so the spawn finds it. No-op when the name already resolves on PATH or
+    // carries a path — so ssh/docker-wrapped tabs (cmd "ssh"/"docker", both on
+    // PATH) keep their remote/in-container binary names, which live in `args`.
+    let mut cmd = match crate::paths::resolve_offpath_binary(&cmd_str) {
+        Some(resolved) => command_for_resolved(resolved),
+        None => CommandBuilder::new(&cmd_str),
+    };
     for arg in &opts.args {
         cmd.arg(arg);
     }
     cmd.cwd(&opts.cwd);
     cmd.env("TERM", "xterm-256color");
     cmd.env("COLORTERM", "truecolor");
+    if let Some(path) = crate::paths::effective_path() {
+        cmd.env("PATH", path);
+    }
     for (k, v) in &opts.env {
         cmd.env(k, v);
     }
@@ -402,4 +637,70 @@ mod tests {
 
         registry.lock().unwrap().kill("test");
     }
+
+    /// Closing a tab must abort the process **inside** it, not just the shell
+    /// leader: a `sh` whose child is a long-running `sleep` must leave no live
+    /// `sleep` behind once the PTY is killed.
+    #[test]
+    fn kill_reaps_the_child_subtree() {
+        // This test invalidates and repopulates the process-tree cache in its
+        // poll loop below, which is exactly the global state sysstat's
+        // cache-mechanics tests seed synthetic entries into. Share their lock so
+        // the two never interleave.
+        let _cache_guard = crate::sysstat::lock_cache_for_test();
+        let pty_system = NativePtySystem::default();
+        let pair = pty_system
+            .openpty(PtySize { rows: 24, cols: 80, pixel_width: 0, pixel_height: 0 })
+            .expect("openpty");
+
+        // The trailing `; true` defeats the shell's exec-optimization so `sleep`
+        // is a genuine *child* of `sh` (the leader), not the leader itself.
+        let mut cmd = CommandBuilder::new("sh");
+        cmd.arg("-c");
+        cmd.arg("sleep 300; true");
+        let child = pair.slave.spawn_command(cmd).expect("spawn sh");
+        let leader = child.process_id().expect("leader pid");
+        let writer = pair.master.take_writer().expect("take writer");
+        let master = pair.master;
+
+        let registry = Arc::new(Mutex::new(PtyRegistry::default()));
+        let dead = Arc::new(AtomicBool::new(false));
+        registry
+            .lock()
+            .unwrap()
+            .insert("test".to_string(), master, writer, child, dead);
+
+        // SAFETY: kill(pid, 0) probes existence without signalling; no pointers.
+        let alive = |pid: u32| unsafe { libc::kill(pid as libc::pid_t, 0) == 0 };
+
+        // Wait for the `sleep` child to appear as a descendant of the leader.
+        let mut sleep_pid = None;
+        for _ in 0..100 {
+            crate::sysstat::invalidate_descendant_cache();
+            if let Some(&pid) = crate::sysstat::descendant_pids(&[leader])
+                .iter()
+                .find(|&&p| p != leader)
+            {
+                sleep_pid = Some(pid);
+                break;
+            }
+            std::thread::sleep(Duration::from_millis(20));
+        }
+        let sleep_pid = sleep_pid.expect("sleep child should have spawned");
+        assert!(alive(sleep_pid), "sleep child should be running before kill");
+
+        registry.lock().unwrap().kill("test");
+
+        // The graceful SIGTERM terminates `sleep` (default disposition); init
+        // then reaps the reparented zombie. Poll until the pid is truly gone.
+        let mut gone = false;
+        for _ in 0..250 {
+            if !alive(sleep_pid) {
+                gone = true;
+                break;
+            }
+            std::thread::sleep(Duration::from_millis(20));
+        }
+        assert!(gone, "the inner process must be aborted when the tab is closed");
+    }
 }
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 8155bf5..c98de19 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,6 +1,6 @@
 {
   "productName": "Eldrun",
-  "version": "0.1.0",
+  "version": "0.1.40",
   "identifier": "io.github.fseiffarth.eldrun",
   "build": {
     "frontendDist": "../dist",
@@ -20,7 +20,9 @@
         "dragDropEnabled": false,
         "decorations": false,
         "transparent": false,
-        "fullscreen": true
+        "fullscreen": false,
+        "maximized": true,
+        "visible": false
       }
     ],
     "security": {
@@ -29,7 +31,11 @@
   },
   "bundle": {
     "active": true,
-    "targets": ["deb", "appimage", "nsis"],
+    "targets": [
+      "deb",
+      "appimage",
+      "nsis"
+    ],
     "icon": [
       "icons/32x32.png",
       "icons/128x128.png",
diff --git a/src-tauri/tauri.macos.conf.json b/src-tauri/tauri.macos.conf.json
new file mode 100644
index 0000000..467baae
--- /dev/null
+++ b/src-tauri/tauri.macos.conf.json
@@ -0,0 +1,34 @@
+{
+  "app": {
+    "windows": [
+      {
+        "title": "Eldrun",
+        "width": 1400,
+        "height": 900,
+        "minWidth": 800,
+        "minHeight": 600,
+        "resizable": true,
+        "dragDropEnabled": false,
+        "decorations": true,
+        "transparent": false,
+        "fullscreen": false,
+        "titleBarStyle": "Overlay",
+        "hiddenTitle": true
+      }
+    ]
+  },
+  "bundle": {
+    "targets": ["dmg", "app"],
+    "category": "DeveloperTool",
+    "macOS": {
+      "minimumSystemVersion": "10.15",
+      "entitlements": "entitlements.plist",
+      "hardenedRuntime": true,
+      "dmg": {
+        "appPosition": { "x": 180, "y": 170 },
+        "applicationFolderPosition": { "x": 480, "y": 170 },
+        "windowSize": { "width": 660, "height": 400 }
+      }
+    }
+  }
+}
diff --git a/src-tauri/tests/file_ops_tests.rs b/src-tauri/tests/file_ops_tests.rs
index 6b98f9f..3311817 100644
--- a/src-tauri/tests/file_ops_tests.rs
+++ b/src-tauri/tests/file_ops_tests.rs
@@ -6,7 +6,8 @@
 use std::fs;
 
 use eldrun_lib::commands::fs::{
-    create_dir, create_file, delete_dir, delete_file, list_dir, rename_path,
+    create_dir_local, create_file_local, delete_dir_local, delete_file_local, list_dir_local,
+    rename_path_local,
 };
 use eldrun_lib::commands::projects::scaffold_project;
 use tempfile::TempDir;
@@ -34,7 +35,7 @@ fn list_dir_lists_files_and_dirs() {
     fs::create_dir_all(tmp.path().join("src")).unwrap();
     fs::write(tmp.path().join("src/main.rs"), "fn main() {}").unwrap();
 
-    let entries = list_dir(dir, "".to_string()).unwrap();
+    let entries = list_dir_local(&dir, "").unwrap();
     let names: Vec<&str> = entries.iter().map(|e| e.name.as_str()).collect();
     assert!(names.contains(&"src"), "src dir must appear");
     assert!(names.contains(&"README.md"), "README.md must appear");
@@ -48,7 +49,7 @@ fn list_dir_dirs_come_before_files() {
     fs::write(tmp.path().join("aaa.txt"), "").unwrap();
     fs::create_dir_all(tmp.path().join("zzz_dir")).unwrap();
 
-    let entries = list_dir(dir, "".to_string()).unwrap();
+    let entries = list_dir_local(&dir, "").unwrap();
     let first = entries.first().expect("at least one entry");
     assert!(first.is_dir, "directories must sort before files");
 }
@@ -62,7 +63,7 @@ fn list_dir_hides_eldrun_directory() {
     fs::write(tmp.path().join(".eldrun/sessions/terminals.json"), "{}").unwrap();
     fs::write(tmp.path().join("visible.txt"), "hi").unwrap();
 
-    let entries = list_dir(dir, "".to_string()).unwrap();
+    let entries = list_dir_local(&dir, "").unwrap();
     let names: Vec<&str> = entries.iter().map(|e| e.name.as_str()).collect();
     assert!(!names.contains(&".eldrun"), ".eldrun must be hidden");
     assert!(names.contains(&"visible.txt"));
@@ -73,7 +74,7 @@ fn list_dir_rejects_path_traversal() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = list_dir(dir, "../".to_string());
+    let result = list_dir_local(&dir, "../");
     assert!(result.is_err(), "path traversal must be rejected");
 }
 
@@ -85,7 +86,7 @@ fn list_dir_returns_subdirectory_contents() {
     fs::create_dir_all(tmp.path().join("sub")).unwrap();
     fs::write(tmp.path().join("sub/child.txt"), "hello").unwrap();
 
-    let entries = list_dir(dir, "sub".to_string()).unwrap();
+    let entries = list_dir_local(&dir, "sub").unwrap();
     let names: Vec<&str> = entries.iter().map(|e| e.name.as_str()).collect();
     assert!(names.contains(&"child.txt"));
 }
@@ -97,7 +98,7 @@ fn list_dir_entry_has_extension_field() {
 
     fs::write(tmp.path().join("notes.md"), "# notes").unwrap();
 
-    let entries = list_dir(dir, "".to_string()).unwrap();
+    let entries = list_dir_local(&dir, "").unwrap();
     let md = entries.iter().find(|e| e.name == "notes.md").unwrap();
     assert_eq!(md.extension.as_deref(), Some(".md"));
 }
@@ -109,7 +110,7 @@ fn list_dir_directory_has_zero_size() {
 
     fs::create_dir_all(tmp.path().join("subdir")).unwrap();
 
-    let entries = list_dir(dir, "".to_string()).unwrap();
+    let entries = list_dir_local(&dir, "").unwrap();
     let subdir = entries.iter().find(|e| e.name == "subdir" && e.is_dir).unwrap();
     assert_eq!(subdir.size, 0);
 }
@@ -121,7 +122,7 @@ fn create_file_creates_an_empty_file() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    create_file(dir, "new_file.txt".to_string()).unwrap();
+    create_file_local(&dir, "new_file.txt").unwrap();
 
     assert!(tmp.path().join("new_file.txt").exists());
 }
@@ -131,7 +132,7 @@ fn create_file_creates_parent_dirs() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    create_file(dir, "deep/nested/file.rs".to_string()).unwrap();
+    create_file_local(&dir, "deep/nested/file.rs").unwrap();
 
     assert!(tmp.path().join("deep/nested/file.rs").exists());
 }
@@ -141,7 +142,7 @@ fn create_file_rejects_path_traversal() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = create_file(dir, "../escape.txt".to_string());
+    let result = create_file_local(&dir, "../escape.txt");
     assert!(result.is_err(), "traversal must be rejected");
 }
 
@@ -152,7 +153,7 @@ fn create_dir_makes_new_directory() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    create_dir(dir, "new_dir".to_string()).unwrap();
+    create_dir_local(&dir, "new_dir").unwrap();
 
     assert!(tmp.path().join("new_dir").is_dir());
 }
@@ -162,7 +163,7 @@ fn create_dir_creates_nested_dirs() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    create_dir(dir, "a/b/c".to_string()).unwrap();
+    create_dir_local(&dir, "a/b/c").unwrap();
 
     assert!(tmp.path().join("a/b/c").is_dir());
 }
@@ -172,7 +173,7 @@ fn create_dir_rejects_path_traversal() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = create_dir(dir, "../evil_dir".to_string());
+    let result = create_dir_local(&dir, "../evil_dir");
     assert!(result.is_err(), "traversal must be rejected");
 }
 
@@ -186,7 +187,7 @@ fn delete_file_removes_a_file() {
     let f = tmp.path().join("todelete.txt");
     fs::write(&f, "bye").unwrap();
 
-    delete_file(dir, "todelete.txt".to_string()).unwrap();
+    delete_file_local(&dir, "todelete.txt").unwrap();
 
     assert!(!f.exists(), "file must be deleted");
 }
@@ -198,7 +199,7 @@ fn delete_file_rejects_directories() {
 
     fs::create_dir_all(tmp.path().join("mydir")).unwrap();
 
-    let result = delete_file(dir, "mydir".to_string());
+    let result = delete_file_local(&dir, "mydir");
     assert!(result.is_err(), "delete_file must refuse directories");
 }
 
@@ -207,7 +208,7 @@ fn delete_file_rejects_path_traversal() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = delete_file(dir, "../somewhere.txt".to_string());
+    let result = delete_file_local(&dir, "../somewhere.txt");
     assert!(result.is_err());
 }
 
@@ -221,7 +222,7 @@ fn delete_dir_removes_directory_tree() {
     fs::create_dir_all(tmp.path().join("subtree/inner")).unwrap();
     fs::write(tmp.path().join("subtree/inner/file.txt"), "data").unwrap();
 
-    delete_dir(dir, "subtree".to_string()).unwrap();
+    delete_dir_local(&dir, "subtree").unwrap();
 
     assert!(!tmp.path().join("subtree").exists(), "dir tree must be removed");
 }
@@ -231,11 +232,11 @@ fn delete_dir_rejects_project_root() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = delete_dir(dir.clone(), "".to_string());
+    let result = delete_dir_local(&dir, "");
     // Either error, or we pass root as rel and it canonicalizes to root.
     // The command uses canonical() so passing "" will fail to canonicalize.
     // Passing "." expands to root — that must be rejected.
-    let result2 = delete_dir(dir, ".".to_string());
+    let result2 = delete_dir_local(&dir, ".");
     // At least one of these must error.
     assert!(result.is_err() || result2.is_err(), "deleting project root must be rejected");
 }
@@ -247,7 +248,7 @@ fn delete_dir_rejects_files() {
 
     fs::write(tmp.path().join("afile.txt"), "content").unwrap();
 
-    let result = delete_dir(dir, "afile.txt".to_string());
+    let result = delete_dir_local(&dir, "afile.txt");
     assert!(result.is_err(), "delete_dir must refuse files");
 }
 
@@ -256,7 +257,7 @@ fn delete_dir_rejects_path_traversal() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = delete_dir(dir, "../outside".to_string());
+    let result = delete_dir_local(&dir, "../outside");
     assert!(result.is_err());
 }
 
@@ -269,7 +270,7 @@ fn rename_path_renames_a_file() {
 
     fs::write(tmp.path().join("old.txt"), "content").unwrap();
 
-    rename_path(dir, "old.txt".to_string(), "new.txt".to_string()).unwrap();
+    rename_path_local(&dir, "old.txt", "new.txt").unwrap();
 
     assert!(!tmp.path().join("old.txt").exists());
     assert!(tmp.path().join("new.txt").exists());
@@ -284,7 +285,7 @@ fn rename_path_renames_a_directory() {
     fs::create_dir_all(tmp.path().join("old_dir")).unwrap();
     fs::write(tmp.path().join("old_dir/file.txt"), "hi").unwrap();
 
-    rename_path(dir, "old_dir".to_string(), "new_dir".to_string()).unwrap();
+    rename_path_local(&dir, "old_dir", "new_dir").unwrap();
 
     assert!(!tmp.path().join("old_dir").exists());
     assert!(tmp.path().join("new_dir").is_dir());
@@ -296,7 +297,7 @@ fn rename_path_rejects_source_traversal() {
     let tmp = setup();
     let dir = project_dir(&tmp);
 
-    let result = rename_path(dir, "../outside.txt".to_string(), "safe.txt".to_string());
+    let result = rename_path_local(&dir, "../outside.txt", "safe.txt");
     assert!(result.is_err(), "traversal of old path must be rejected");
 }
 
@@ -307,7 +308,7 @@ fn rename_path_rejects_dest_traversal() {
 
     fs::write(tmp.path().join("file.txt"), "content").unwrap();
 
-    let result = rename_path(dir, "file.txt".to_string(), "../../../evil.txt".to_string());
+    let result = rename_path_local(&dir, "file.txt", "../../../evil.txt");
     assert!(result.is_err(), "traversal of new name must be rejected");
 }
 
@@ -316,7 +317,7 @@ fn rename_path_rejects_dest_traversal() {
 #[test]
 fn scaffold_project_integration_creates_full_structure() {
     let tmp = setup();
-    scaffold_project(tmp.path()).unwrap();
+    scaffold_project(tmp.path(), true).unwrap();
 
     // Every canonical scaffold file must be present.
     for f in &[
@@ -337,7 +338,7 @@ fn scaffold_project_integration_creates_full_structure() {
 #[test]
 fn scaffold_project_gitignore_contains_eldrun() {
     let tmp = setup();
-    scaffold_project(tmp.path()).unwrap();
+    scaffold_project(tmp.path(), true).unwrap();
 
     let gitignore = fs::read_to_string(tmp.path().join(".gitignore")).unwrap();
     assert!(
@@ -349,7 +350,7 @@ fn scaffold_project_gitignore_contains_eldrun() {
 #[test]
 fn scaffold_project_claude_settings_is_valid_json() {
     let tmp = setup();
-    scaffold_project(tmp.path()).unwrap();
+    scaffold_project(tmp.path(), true).unwrap();
 
     let content = fs::read_to_string(tmp.path().join(".claude/settings.json")).unwrap();
     let parsed: serde_json::Value = serde_json::from_str(&content)
diff --git a/src-tauri/tests/no_foreign_config_writes.rs b/src-tauri/tests/no_foreign_config_writes.rs
new file mode 100644
index 0000000..2c4e49c
--- /dev/null
+++ b/src-tauri/tests/no_foreign_config_writes.rs
@@ -0,0 +1,85 @@
+//! Regression guard: Eldrun must NEVER write into another application's config
+//! to redirect its behavior — specifically, it must not edit a browser's
+//! download directory (Firefox `prefs.js`, Chromium `Preferences`).
+//!
+//! An earlier version did exactly this (the removed
+//! `commands/downloads.rs::configure_browser_downloads`, which set
+//! `browser.download.dir` / `browser.download.folderList` and the Chromium
+//! `default_directory`). It was ripped out on 2026-06-30; this test fails the
+//! build if any such foreign-config write marker reappears in the source tree.
+//!
+//! Privacy: the scan reads only files under this crate's own `src/` tree, and on
+//! failure reports only the repo-relative file path and the matched marker —
+//! never file contents, absolute paths, or any user/home data. This test file
+//! is excluded from its own scan so its marker literals don't self-match
+//! (mirroring how `scripts/privacy-check.sh` excludes itself).
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// Substrings that only make sense if we're editing a browser's config. None of
+/// these legitimately appear in Eldrun's own source; the read-only downloads
+/// feature (`list_recent_downloads` / `download_sources`) uses none of them.
+const FORBIDDEN_MARKERS: &[&str] = &[
+    "browser.download.",   // Firefox download-dir prefs (dir/folderList/useDownloadDir)
+    "prefs.js",            // Firefox profile prefs file
+    "default_directory",   // Chromium `download.default_directory` pref key
+    ".parentlock",         // Firefox profile lock the old editor checked
+];
+
+/// Recursively collect every `.rs` file under `dir`.
+fn collect_rs_files(dir: &Path, out: &mut Vec<PathBuf>) {
+    let entries = match fs::read_dir(dir) {
+        Ok(e) => e,
+        Err(_) => return,
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            collect_rs_files(&path, out);
+        } else if path.extension().and_then(|e| e.to_str()) == Some("rs") {
+            out.push(path);
+        }
+    }
+}
+
+#[test]
+fn no_source_writes_foreign_browser_config() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let src_dir = manifest_dir.join("src");
+
+    let mut files = Vec::new();
+    collect_rs_files(&src_dir, &mut files);
+    assert!(
+        !files.is_empty(),
+        "guard scanned no source files — expected {}/**.rs to exist",
+        src_dir.display()
+    );
+
+    // Report only repo-relative paths + the matched marker; never file contents.
+    let mut violations: Vec<String> = Vec::new();
+    for file in &files {
+        let content = match fs::read_to_string(file) {
+            Ok(c) => c,
+            Err(_) => continue,
+        };
+        let rel = file
+            .strip_prefix(&manifest_dir)
+            .unwrap_or(file)
+            .to_string_lossy()
+            .to_string();
+        for marker in FORBIDDEN_MARKERS {
+            if content.contains(marker) {
+                violations.push(format!("  {rel}: contains forbidden marker `{marker}`"));
+            }
+        }
+    }
+
+    assert!(
+        violations.is_empty(),
+        "Eldrun must never write another app's config (browser download dir).\n\
+         This is the removed commands/downloads.rs behavior — do not reintroduce it.\n\
+         Offending source:\n{}",
+        violations.join("\n")
+    );
+}
diff --git a/src-tauri/tests/projects_commands.rs b/src-tauri/tests/projects_commands.rs
index 819648a..f227f96 100644
--- a/src-tauri/tests/projects_commands.rs
+++ b/src-tauri/tests/projects_commands.rs
@@ -4,9 +4,12 @@ use std::path::{Path, PathBuf};
 use std::sync::{Mutex, OnceLock};
 
 use eldrun_lib::commands::projects::{
-    create_project, get_projects, import_project, load_project, set_project_description,
-    CreateProjectRequest, ImportProjectRequest,
+    archive_project, create_project, delete_archived_project, get_projects, import_project,
+    list_archived_projects, load_project, restore_archived_project, set_project_auto_connect,
+    set_project_description, set_project_sandbox, set_project_sandbox_spec, CreateProjectRequest,
+    ImportProjectRequest,
 };
+use eldrun_lib::schema::project::{RemoteSpec, SandboxSpec};
 use tempfile::{Builder, TempDir};
 
 const SCAFFOLDS: &[(&str, &str)] = &[
@@ -17,7 +20,7 @@ const SCAFFOLDS: &[(&str, &str)] = &[
     ("ROADMAP.md", "# Roadmap\n"),
     ("STATUS.md", "# Status\n"),
     ("README.md", "# Project\n"),
-    (".gitignore", "__pycache__/\n*.pyc\n.venv/\nnode_modules/\ntarget/\ndist/\nbuild/\n.env\n.env.local\n.DS_Store\n*.log\n*.swp\n*.swo\n.idea/\n.eldrun/\n"),
+    (".gitignore", "__pycache__/\n*.pyc\n.venv/\nnode_modules/\ntarget/\ndist/\nbuild/\n.env\n.env.local\n.DS_Store\n*.log\n*.swp\n*.swo\n.idea/\n.eldrun/\nproject.json\n"),
     (".claude/settings.json", r#"{"permissions":{"allow":[],"deny":[]}}"#),
 ];
 
@@ -37,28 +40,47 @@ fn test_lock() -> &'static Mutex<()> {
     LOCK.get_or_init(|| Mutex::new(()))
 }
 
+/// Every env var the backend resolves user-state locations from. `HOME` feeds
+/// `paths::home_dir`/`storage::state_dir` on Unix; on Windows `home_dir` reads
+/// `USERPROFILE` (then `HOMEDRIVE`/`HOMEPATH`) and `state_dir` reads `APPDATA` —
+/// overriding only `HOME` there sent every test write into the REAL
+/// `~\eldrun\projects` and `%APPDATA%\eldrun\projects.json` (junk projects in
+/// the user's live store). All of them must point into the temp home.
+const HOME_ENV_KEYS: &[&str] = &["HOME", "USERPROFILE", "HOMEDRIVE", "HOMEPATH", "APPDATA"];
+
 struct HomeGuard {
-    old_home: Option<std::ffi::OsString>,
+    old: Vec<(&'static str, Option<std::ffi::OsString>)>,
 }
 
 impl HomeGuard {
     fn set(home: &Path) -> Self {
-        let old_home = env::var_os("HOME");
-        // HOME is mutated only while holding the test lock.
+        // Env is mutated only while holding the test lock.
+        let old = HOME_ENV_KEYS
+            .iter()
+            .map(|&key| (key, env::var_os(key)))
+            .collect();
         unsafe {
             env::set_var("HOME", home);
+            env::set_var("USERPROFILE", home);
+            // Neutralize the HOMEDRIVE/HOMEPATH fallback rather than try to
+            // split a temp path into drive+path.
+            env::remove_var("HOMEDRIVE");
+            env::remove_var("HOMEPATH");
+            env::set_var("APPDATA", home.join("AppData").join("Roaming"));
         }
-        Self { old_home }
+        Self { old }
     }
 }
 
 impl Drop for HomeGuard {
     fn drop(&mut self) {
-        // Restore the caller's HOME as soon as the scoped test ends.
+        // Restore the caller's env as soon as the scoped test ends.
         unsafe {
-            match &self.old_home {
-                Some(home) => env::set_var("HOME", home),
-                None => env::remove_var("HOME"),
+            for (key, value) in &self.old {
+                match value {
+                    Some(v) => env::set_var(key, v),
+                    None => env::remove_var(key),
+                }
             }
         }
     }
@@ -147,7 +169,9 @@ fn create_project_preserves_existing_scaffolds() {
             directory: target.path().to_string_lossy().to_string(),
             description: Some("Create description".to_string()),
             git_type: None,
+            skip_scaffold: false,
             remote: None,
+            mirror_parent: None,
         };
 
         let entry = create_project(req).expect("create project");
@@ -170,6 +194,156 @@ fn create_project_preserves_existing_scaffolds() {
     });
 }
 
+/// A new **git-backed** remote project starts with lockstep ON, so the git-tracked
+/// tree is kept in step semantically (commits/refs) from the first launch instead
+/// of waiting for the user to find the toggle. This is the same default
+/// `extend_project_to_remote` applies, and it is safe for the same reason: the host
+/// root was just created empty, so the first pass can only seed one direction.
+///
+/// The companion half of the default is that byte-sync stays opt-in per path (no
+/// marker ⇒ `is_auto` false), which is what leaves gitignored host-side data — the
+/// experiment output a remote project exists to produce — where it is.
+#[test]
+fn create_remote_project_enables_lockstep_when_git_backed() {
+    with_isolated_home("remote-lockstep-home", |_| {
+        let mirror_parent = tempdir_in_test_projects("remote-ls-mirror");
+        let req = CreateProjectRequest {
+            name: "remote-git-project".to_string(),
+            directory: String::new(),
+            description: None,
+            git_type: Some("local".to_string()),
+            skip_scaffold: false,
+            remote: Some(RemoteSpec {
+                user: Some("alice".to_string()),
+                host: "nonexistent.invalid".to_string(),
+                port: None,
+                remote_path: "/home/alice/work".to_string(),
+                openvpn: None,
+                auto_connect: None,
+                key_auth: None,
+                persist_sessions: None,
+                label: None,
+                extra: Default::default(),
+            }),
+            mirror_parent: Some(mirror_parent.path().to_string_lossy().to_string()),
+        };
+
+        let entry = create_project(req).expect("create remote git project");
+        let state = eldrun_lib::services::git_peer::load_state(&entry.id);
+        assert!(
+            state.enabled,
+            "a git-backed remote project should start with lockstep enabled"
+        );
+    });
+}
+
+/// The gate is the mirror actually being a repo, not the `git_type` tag: a
+/// `none` project has no history to seed a pairing from, so lockstep stays off
+/// (its default) rather than being enabled over an empty non-repo.
+#[test]
+fn create_remote_project_leaves_lockstep_off_without_git() {
+    with_isolated_home("remote-nolockstep-home", |_| {
+        let mirror_parent = tempdir_in_test_projects("remote-nols-mirror");
+        let req = CreateProjectRequest {
+            name: "remote-plain-project".to_string(),
+            directory: String::new(),
+            description: None,
+            git_type: Some("none".to_string()),
+            skip_scaffold: false,
+            remote: Some(RemoteSpec {
+                user: Some("alice".to_string()),
+                host: "nonexistent.invalid".to_string(),
+                port: None,
+                remote_path: "/home/alice/work".to_string(),
+                openvpn: None,
+                auto_connect: None,
+                key_auth: None,
+                persist_sessions: None,
+                label: None,
+                extra: Default::default(),
+            }),
+            mirror_parent: Some(mirror_parent.path().to_string_lossy().to_string()),
+        };
+
+        let entry = create_project(req).expect("create remote non-git project");
+        let state = eldrun_lib::services::git_peer::load_state(&entry.id);
+        assert!(
+            !state.enabled,
+            "a non-git remote project has nothing to keep in step; lockstep stays off"
+        );
+    });
+}
+
+#[test]
+fn create_remote_project_scaffolds_the_local_mirror() {
+    with_isolated_home("remote-home", |_| {
+        // Where the local mirror twin (working copy) should land. The host is a
+        // reserved `.invalid` name so the best-effort remote `mkdir -p` fails fast
+        // (NXDOMAIN) without touching the network — scaffolding the mirror must
+        // happen regardless, since bytes only reach the host on a manual push.
+        let mirror_parent = tempdir_in_test_projects("remote-mirror");
+
+        let req = CreateProjectRequest {
+            name: "remote-project".to_string(),
+            directory: String::new(),
+            description: Some("Remote description".to_string()),
+            git_type: Some("none".to_string()),
+            skip_scaffold: false,
+            remote: Some(RemoteSpec {
+                user: Some("alice".to_string()),
+                host: "nonexistent.invalid".to_string(),
+                port: None,
+                remote_path: "/home/alice/work".to_string(),
+                openvpn: None,
+                auto_connect: None,
+                key_auth: None,
+                persist_sessions: None,
+                label: None,
+                extra: Default::default(),
+            }),
+            mirror_parent: Some(mirror_parent.path().to_string_lossy().to_string()),
+        };
+
+        let entry = create_project(req).expect("create remote project");
+        assert!(
+            entry.extra.contains_key("remote"),
+            "entry should carry a remote spec"
+        );
+
+        // The scaffold lives in the local mirror, not the (project.json-only)
+        // state directory the entry's local_file points at.
+        let mirror = entry
+            .extra
+            .get("mirror")
+            .and_then(|v| v.as_str())
+            .expect("remote entry carries a mirror path");
+        let mirror_dir = Path::new(mirror);
+        for (name, default_content) in SCAFFOLDS {
+            // `.gitignore` is a git-axis artifact: a `git_type: "none"` project
+            // never gets one written, so it must be absent from the mirror.
+            if *name == ".gitignore" {
+                assert!(
+                    !mirror_dir.join(name).exists(),
+                    "git_type none must not scaffold a .gitignore"
+                );
+                continue;
+            }
+            let path = mirror_dir.join(name);
+            assert!(path.exists(), "missing mirror scaffold: {name}");
+            let actual = fs::read_to_string(&path).expect("read mirror scaffold");
+            assert_eq!(&actual, default_content, "unexpected contents for {name}");
+        }
+
+        // git_type "none" means no repo was initialized in the mirror.
+        assert!(
+            !mirror_dir.join(".git").exists(),
+            "git_type none must not init a mirror repo"
+        );
+
+        assert_project_registered(&PathBuf::from(&entry.local_file), "remote-project");
+    });
+}
+
 #[test]
 fn import_project_copy_creates_missing_scaffolds_without_overwriting_existing_ones() {
     with_isolated_home("copy-home", |_| {
@@ -186,6 +360,7 @@ fn import_project_copy_creates_missing_scaffolds_without_overwriting_existing_on
             manual_validation_confirmed: Some(true),
             skip_scaffold: false,
             remote: None,
+            mirror_parent: None,
         };
 
         let entry = import_project(req).expect("import copy");
@@ -227,6 +402,7 @@ fn import_project_move_creates_missing_scaffolds_without_overwriting_existing_on
             manual_validation_confirmed: Some(true),
             skip_scaffold: false,
             remote: None,
+            mirror_parent: None,
         };
 
         let entry = import_project(req).expect("import move");
@@ -263,6 +439,7 @@ fn import_project_keep_creates_missing_scaffolds_in_place_without_overwriting_ex
             manual_validation_confirmed: None,
             skip_scaffold: false,
             remote: None,
+            mirror_parent: None,
         };
 
         let entry = import_project(req).expect("import keep");
@@ -301,6 +478,7 @@ fn import_project_skip_scaffold_does_not_add_missing_scaffold_files() {
             manual_validation_confirmed: None,
             skip_scaffold: true,
             remote: None,
+            mirror_parent: None,
         };
 
         let entry = import_project(req).expect("import skip-scaffold");
@@ -335,7 +513,9 @@ fn set_project_description_writes_both_projects_json_and_project_json() {
             directory: target.path().to_string_lossy().to_string(),
             description: Some("original".to_string()),
             git_type: None,
+            skip_scaffold: false,
             remote: None,
+            mirror_parent: None,
         })
         .expect("create project");
 
@@ -366,3 +546,260 @@ fn set_project_description_writes_both_projects_json_and_project_json() {
         assert!(project.description.is_none());
     });
 }
+
+// ── Archive (delete → restorable) ──────────────────────────────────────────
+
+fn new_local_project(name: &str, target: &Path) -> eldrun_lib::schema::projects::ProjectEntry {
+    seed_project(target, name);
+    create_project(CreateProjectRequest {
+        name: name.to_string(),
+        directory: target.to_string_lossy().to_string(),
+        description: None,
+        git_type: None,
+        skip_scaffold: false,
+        remote: None,
+        mirror_parent: None,
+    })
+    .expect("create project")
+}
+
+#[test]
+fn archive_and_restore_local_project_roundtrip() {
+    with_isolated_home("archive-home", |_| {
+        let target = tempdir_in_test_projects("archive-target");
+        let entry = new_local_project("arch-project", target.path());
+        let id = entry.id.clone();
+        let dir = target.path().to_path_buf();
+        assert!(dir.join("project.json").exists());
+
+        // Archive: the on-disk dir moves out and the pill drops from the list.
+        archive_project(id.clone(), "2026-07-01T00:00:00+00:00".to_string()).expect("archive");
+        assert!(
+            !dir.join("project.json").exists(),
+            "original project dir should have moved into the archive"
+        );
+        assert!(
+            get_projects().unwrap().iter().all(|p| p.id != id),
+            "archived project must be gone from projects.json"
+        );
+        let archived = list_archived_projects().expect("list archived");
+        assert_eq!(archived.len(), 1);
+        assert_eq!(archived[0].id, id);
+        assert_eq!(archived[0].name, "arch-project");
+        assert!(!archived[0].remote);
+
+        // Restore: comes back inactive, the folder + files return, archive empties.
+        let restored = restore_archived_project(id.clone()).expect("restore");
+        assert_eq!(restored.status, "inactive");
+        assert_eq!(restored.id, id);
+        assert!(get_projects().unwrap().iter().any(|p| p.id == id));
+        assert!(list_archived_projects().unwrap().is_empty());
+        let restored_dir = PathBuf::from(&restored.local_file)
+            .parent()
+            .expect("restored project file parent")
+            .to_path_buf();
+        assert!(restored_dir.join("notes.txt").exists());
+        assert!(restored_dir.join("nested/info.txt").exists());
+    });
+}
+
+#[test]
+fn permanent_delete_removes_archived_project() {
+    with_isolated_home("archive-del-home", |_| {
+        let target = tempdir_in_test_projects("archive-del-target");
+        let entry = new_local_project("del-project", target.path());
+        let id = entry.id.clone();
+
+        archive_project(id.clone(), "2026-07-01T00:00:00+00:00".to_string()).expect("archive");
+        assert_eq!(list_archived_projects().unwrap().len(), 1);
+
+        delete_archived_project(id.clone()).expect("delete forever");
+        assert!(
+            list_archived_projects().unwrap().is_empty(),
+            "archive must be empty after permanent delete"
+        );
+        // Restoring a permanently-deleted project is an error (nothing to read).
+        assert!(restore_archived_project(id).is_err());
+    });
+}
+
+/// Project containers, Phase 0: the toggle must be **spec-preserving** —
+/// re-enabling used to write `SandboxSpec::default()`, wiping hand-tuned
+/// `image`/`memory`/`network`/…. Only `enabled` flips now; the knobs survive a
+/// disable/enable round-trip in BOTH stores. And the *first* enable
+/// auto-detects an in-repo `Dockerfile` as the container source (Phase 4).
+#[test]
+fn set_project_sandbox_preserves_spec_and_detects_dockerfile() {
+    with_isolated_home("sandbox-home", |_| {
+        let target = tempdir_in_test_projects("sandbox-target");
+        let entry = new_local_project("sandbox-project", target.path());
+        let id = entry.id.clone();
+
+        // The project carries a root Dockerfile → the first enable adopts it.
+        fs::write(target.path().join("Dockerfile"), "FROM debian:stable\n").expect("dockerfile");
+        let spec = set_project_sandbox(id.clone(), true).expect("enable");
+        assert!(spec.enabled);
+        assert_eq!(spec.dockerfile.as_deref(), Some("Dockerfile"));
+
+        // Hand-tune the knobs, then flip the toggle off and back on: every
+        // field must survive; only `enabled` may change.
+        let tuned = SandboxSpec {
+            enabled: true,
+            image: None,
+            dockerfile: Some("Dockerfile".to_string()),
+            pids_limit: Some(256),
+            memory: Some("4g".to_string()),
+            cpus: None,
+            network: Some("none".to_string()),
+            readonly_rootfs: true,
+            extra: Default::default(),
+        };
+        set_project_sandbox_spec(id.clone(), tuned).expect("store tuned spec");
+
+        let off = set_project_sandbox(id.clone(), false).expect("disable");
+        assert!(!off.enabled);
+        assert_eq!(off.memory.as_deref(), Some("4g"), "disable must not wipe the spec");
+
+        let on = set_project_sandbox(id.clone(), true).expect("re-enable");
+        assert!(on.enabled);
+        assert_eq!(on.pids_limit, Some(256));
+        assert_eq!(on.memory.as_deref(), Some("4g"));
+        assert_eq!(on.network.as_deref(), Some("none"));
+        assert!(on.readonly_rootfs);
+        assert_eq!(on.dockerfile.as_deref(), Some("Dockerfile"));
+
+        // Both stores carry the tuned spec: the projects.json mirror (what the
+        // spawn path reads) and the project's own project.json.
+        let entry = get_projects()
+            .expect("list")
+            .into_iter()
+            .find(|p| p.id == id)
+            .expect("entry");
+        let mirrored: SandboxSpec = serde_json::from_value(
+            entry.extra.get("sandbox").cloned().expect("sandbox mirrored"),
+        )
+        .expect("parse mirrored spec");
+        assert!(mirrored.enabled && mirrored.readonly_rootfs);
+        assert_eq!(mirrored.pids_limit, Some(256));
+
+        let project: eldrun_lib::schema::project::Project = serde_json::from_str(
+            &fs::read_to_string(&entry.local_file).expect("read project.json"),
+        )
+        .expect("parse project.json");
+        let stored = project.sandbox.expect("project.json carries the spec");
+        assert!(stored.enabled && stored.readonly_rootfs);
+        assert_eq!(stored.network.as_deref(), Some("none"));
+    });
+}
+
+/// Legacy specs (predating the `dockerfile` field) parse unchanged, and a spec
+/// carrying it round-trips.
+#[test]
+fn sandbox_spec_roundtrips_and_reads_legacy_shape() {
+    let legacy: SandboxSpec =
+        serde_json::from_str(r#"{"enabled":true,"image":"img:1","memory":"2g"}"#)
+            .expect("legacy spec parses");
+    assert!(legacy.enabled);
+    assert_eq!(legacy.image.as_deref(), Some("img:1"));
+    assert_eq!(legacy.dockerfile, None);
+
+    let spec = SandboxSpec {
+        enabled: true,
+        dockerfile: Some("docker/Dockerfile.dev".to_string()),
+        ..Default::default()
+    };
+    let back: SandboxSpec =
+        serde_json::from_str(&serde_json::to_string(&spec).expect("serialize")).expect("parse");
+    assert_eq!(back.dockerfile.as_deref(), Some("docker/Dockerfile.dev"));
+}
+
+#[test]
+fn archive_rejects_traversal_ids_and_missing_projects() {
+    with_isolated_home("archive-guard-home", |_| {
+        assert!(archive_project("../evil".to_string(), "x".to_string()).is_err());
+        assert!(archive_project("no-such-id".to_string(), "x".to_string()).is_err());
+    });
+}
+
+/// The auto-connect opt-in has to survive a restart, and it is read from
+/// `projects.json` (the always-local source of truth for a remote project, whose
+/// own `project.json` may live behind the host) — so both copies must carry it, and
+/// clearing it must *remove* the field rather than store `false`, so an opted-out
+/// project is byte-identical to one that never opted in.
+#[test]
+fn set_project_auto_connect_writes_both_copies_and_clears() {
+    with_isolated_home("auto-connect-home", |_| {
+        let mirror_parent = tempdir_in_test_projects("auto-connect-mirror");
+        let entry = create_project(CreateProjectRequest {
+            name: "auto-connect".to_string(),
+            directory: String::new(),
+            description: None,
+            git_type: Some("none".to_string()),
+            skip_scaffold: true,
+            remote: Some(RemoteSpec {
+                user: Some("alice".to_string()),
+                host: "nonexistent.invalid".to_string(),
+                port: None,
+                remote_path: "/home/alice/work".to_string(),
+                openvpn: None,
+                auto_connect: None,
+                key_auth: None,
+                persist_sessions: None,
+                label: None,
+                extra: Default::default(),
+            }),
+            mirror_parent: Some(mirror_parent.path().to_string_lossy().to_string()),
+        })
+        .expect("create remote project");
+
+        // Reads `auto_connect` off the entry's flattened `remote` in projects.json.
+        let registered = |id: &str| -> Option<bool> {
+            get_projects()
+                .expect("get projects")
+                .into_iter()
+                .find(|p| p.id == id)?
+                .extra
+                .get("remote")?
+                .get("auto_connect")?
+                .as_bool()
+        };
+        let on_disk = |local_file: &str| -> Option<bool> {
+            load_project(local_file.to_string())
+                .expect("load project.json")
+                .remote?
+                .auto_connect
+        };
+
+        assert_eq!(registered(&entry.id), None, "starts opted out");
+
+        assert!(set_project_auto_connect(entry.id.clone(), true).expect("opt in"));
+        assert_eq!(registered(&entry.id), Some(true));
+        assert_eq!(on_disk(&entry.local_file), Some(true));
+
+        assert!(!set_project_auto_connect(entry.id.clone(), false).expect("opt out"));
+        assert_eq!(registered(&entry.id), None, "cleared, not stored as false");
+        assert_eq!(on_disk(&entry.local_file), None);
+    });
+}
+
+/// A local project has no SSH connection to automate, so the opt-in must be
+/// refused rather than silently written into a spec that doesn't exist.
+#[test]
+fn set_project_auto_connect_rejects_local_and_unknown_projects() {
+    with_isolated_home("auto-connect-local-home", |_| {
+        let target = tempdir_in_test_projects("auto-connect-local");
+        let entry = create_project(CreateProjectRequest {
+            name: "local-project".to_string(),
+            directory: target.path().to_string_lossy().to_string(),
+            description: None,
+            git_type: Some("none".to_string()),
+            skip_scaffold: true,
+            remote: None,
+            mirror_parent: None,
+        })
+        .expect("create local project");
+
+        assert!(set_project_auto_connect(entry.id, true).is_err());
+        assert!(set_project_auto_connect("no-such-id".to_string(), true).is_err());
+    });
+}
diff --git a/src-tauri/tests/schema_edge_cases.rs b/src-tauri/tests/schema_edge_cases.rs
index 61cee9e..0212291 100644
--- a/src-tauri/tests/schema_edge_cases.rs
+++ b/src-tauri/tests/schema_edge_cases.rs
@@ -37,23 +37,15 @@ fn settings_explicit_color_scheme_is_returned() {
 }
 
 #[test]
-fn settings_workspace_management_defaults_false() {
+fn settings_debug_defaults_off() {
     let s = Settings::default();
-    assert!(!s.workspace_management());
-}
-
-#[test]
-fn settings_explicit_workspace_management_true() {
-    let mut s = Settings::default();
-    s.workspace_management = Some(true);
-    assert!(s.workspace_management());
+    assert_eq!(s.debug, None);
 }
 
 #[test]
 fn settings_empty_json_parses_to_defaults() {
     let s: Settings = parse("{}");
     assert!(s.color_scheme.is_none());
-    assert!(s.terminal_command.is_none());
     assert!(s.global_apps.is_none());
 }
 
@@ -94,15 +86,11 @@ fn settings_unknown_fields_preserved_in_extra() {
 #[test]
 fn settings_roundtrip_preserves_all_known_fields() {
     let s: Settings = parse(r#"{
-        "terminal_command": "konsole",
-        "workspace_management": true,
         "color_scheme": "light",
         "ollama_host": "http://localhost:11434",
         "ollama_model": "mistral"
     }"#);
     let back = roundtrip(&s);
-    assert_eq!(back.terminal_command.as_deref(), Some("konsole"));
-    assert_eq!(back.workspace_management, Some(true));
     assert_eq!(back.color_scheme.as_deref(), Some("light"));
     assert_eq!(back.ollama_host.as_deref(), Some("http://localhost:11434"));
     assert_eq!(back.ollama_model.as_deref(), Some("mistral"));
diff --git a/src-tauri/tests/services_tests.rs b/src-tauri/tests/services_tests.rs
index b95b86e..fa96bae 100644
--- a/src-tauri/tests/services_tests.rs
+++ b/src-tauri/tests/services_tests.rs
@@ -229,7 +229,7 @@ fn save_and_load_tab_layout_roundtrip() {
         },
     ];
 
-    terminal_service::save_tab_layout(&local_file_str, &tabs, None, None).unwrap();
+    terminal_service::save_tab_layout(&local_file_str, &tabs, None, None, true).unwrap();
     let loaded = terminal_service::load_tab_layout(&local_file_str);
 
     assert_eq!(loaded.len(), 2);
@@ -269,7 +269,7 @@ fn save_tab_layout_round_trips_agent_session_id() {
         },
     ];
 
-    terminal_service::save_tab_layout(&local_file_str, &tabs, None, None).unwrap();
+    terminal_service::save_tab_layout(&local_file_str, &tabs, None, None, true).unwrap();
     let loaded = terminal_service::load_tab_layout(&local_file_str);
 
     assert_eq!(loaded.len(), 2);
@@ -313,7 +313,7 @@ fn save_tab_layout_preserves_other_project_fields() {
         session_id: None,
         extra: Default::default(),
     }];
-    terminal_service::save_tab_layout(&local_file_str, &tabs, None, None).unwrap();
+    terminal_service::save_tab_layout(&local_file_str, &tabs, None, None, true).unwrap();
 
     let reloaded: Project = eldrun_lib::storage::read_json(&local_file).unwrap();
     assert_eq!(reloaded.id, "preserve-me");
@@ -336,7 +336,7 @@ fn save_tab_layout_persists_open_session_uuids() {
     let sessions = serde_json::json!([
         { "sessionId": "11111111-1111-4111-8111-111111111111", "cmd": "claude", "label": "Claude" }
     ]);
-    terminal_service::save_tab_layout(&path_str, &[], None, Some(sessions.clone())).unwrap();
+    terminal_service::save_tab_layout(&path_str, &[], None, Some(sessions.clone()), true).unwrap();
 
     let reloaded: Project = eldrun_lib::storage::read_json(&local_file).unwrap();
     assert_eq!(reloaded.open_tab_sessions, Some(sessions));
@@ -347,7 +347,7 @@ fn save_tab_layout_persists_open_session_uuids() {
     let reloaded: Project = eldrun_lib::storage::read_json(&local_file).unwrap();
     assert!(reloaded.open_tab_sessions.is_some());
 
-    terminal_service::save_tab_layout(&path_str, &[], None, Some(serde_json::json!([]))).unwrap();
+    terminal_service::save_tab_layout(&path_str, &[], None, Some(serde_json::json!([])), true).unwrap();
     let reloaded: Project = eldrun_lib::storage::read_json(&local_file).unwrap();
     assert_eq!(reloaded.open_tab_sessions, None);
 }
@@ -372,9 +372,8 @@ fn load_open_apps_returns_empty_when_none_saved() {
     assert!(loaded.is_empty());
 }
 
-#[test]
-fn save_empty_tabs_clears_layout_field() {
-    let tmp = TempDir::new().unwrap();
+/// A project holding one saved tab, for the two empty-save tests below.
+fn project_with_one_tab(tmp: &TempDir) -> String {
     let project = Project {
         id: "p".to_string(),
         name: "P".to_string(),
@@ -384,20 +383,65 @@ fn save_empty_tabs_clears_layout_field() {
             label: "Old".to_string(),
             cmd: "bash".to_string(),
             cwd: "/tmp".to_string(),
-            session_id: None,
+            session_id: Some("11111111-1111-4111-8111-111111111111".to_string()),
             extra: Default::default(),
         }]),
         ..Default::default()
     };
-    let local_file = write_project_json(tmp.path(), &project);
-    let path_str = local_file.to_string_lossy().to_string();
+    write_project_json(tmp.path(), &project)
+        .to_string_lossy()
+        .to_string()
+}
 
-    terminal_service::save_tab_layout(&path_str, &[], None, None).unwrap();
+#[test]
+fn save_empty_tabs_clears_layout_field_when_clearing_is_allowed() {
+    let tmp = TempDir::new().unwrap();
+    let path_str = project_with_one_tab(&tmp);
+
+    // The user really did close every tab.
+    terminal_service::save_tab_layout(&path_str, &[], None, None, true).unwrap();
 
     let loaded = terminal_service::load_tab_layout(&path_str);
     assert!(loaded.is_empty());
 }
 
+/// The DemoProj regression: an empty layout arriving from a caller that cannot
+/// vouch for it must NOT erase the saved one.
+///
+/// Detach swaps a project's `local_file` (remote state dir → promoted mirror) while
+/// the tab store's scope has not caught up; the debounced autosave then persists the
+/// wrong scope's tabs into that file, the per-scope filter drops every one of them as
+/// foreign, and what arrives is `[]` — indistinguishable from a close-all, and fatal.
+/// It took `tab_layout`, `tab_groups` and the `.eldrun` session mirror in one call,
+/// and with them the `sessionId`s that were the only handle on three live Claude
+/// conversations. Empty now clears only when the caller says it means one.
+#[test]
+fn save_empty_tabs_preserves_layout_when_clearing_is_not_allowed() {
+    let tmp = TempDir::new().unwrap();
+    let path_str = project_with_one_tab(&tmp);
+
+    terminal_service::save_tab_layout(&path_str, &[], None, None, false).unwrap();
+
+    let loaded = terminal_service::load_tab_layout(&path_str);
+    assert_eq!(loaded.len(), 1, "an unvouched empty save must not erase tabs");
+    assert_eq!(loaded[0].key, "old");
+    assert_eq!(
+        loaded[0].session_id.as_deref(),
+        Some("11111111-1111-4111-8111-111111111111"),
+        "the agent's session id is the handle on its conversation"
+    );
+
+    // …and it must not have emptied the `.eldrun` mirror either — that file WINS on
+    // load, so clobbering it would lose the tabs even with project.json intact.
+    let sessions_dir = terminal_service::eldrun_sessions_dir(&path_str).unwrap();
+    let mirror = sessions_dir.join("terminals.json");
+    if mirror.exists() {
+        let session: eldrun_lib::schema::session::TerminalSession =
+            eldrun_lib::storage::read_json(&mirror).unwrap();
+        assert_eq!(session.tab_layout.len(), 1);
+    }
+}
+
 // ── terminal_service: .eldrun/sessions/ ───────────────────────────────────
 
 #[test]
diff --git a/src/App.tsx b/src/App.tsx
index fec1243..5fe5c0c 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,6 +1,8 @@
 import { AppShell } from "./components/layout/AppShell";
 import { DetachedApp } from "./components/layout/DetachedApp";
+import { DeckAudienceApp } from "./components/embed/deck/DeckAudienceApp";
 import { parseDetachedParam } from "./stores/detached";
+import { parsePresentParam } from "./lib/viewers/deck/present";
 
 export function App() {
   // #42: when launched with `?detached=<scope>:<group>` (a popped-out subwindow),
@@ -11,5 +13,12 @@ export function App() {
   if (detached) {
     return <DetachedApp param={detached} />;
   }
+  // M#90: `?present=<label>` is the deck presenter's AUDIENCE window — the one
+  // that goes on the projector. Lighter still than a popout: no tabs, no layout,
+  // no store, just the slide it is told to show.
+  const present = parsePresentParam(window.location.search);
+  if (present) {
+    return <DeckAudienceApp label={present} />;
+  }
   return <AppShell />;
 }
diff --git a/src/CLAUDE.md b/src/CLAUDE.md
new file mode 100644
index 0000000..f9406d2
--- /dev/null
+++ b/src/CLAUDE.md
@@ -0,0 +1,152 @@
+# ProjectEldrun — Frontend File Map (`src/`)
+
+Only the load-bearing files are listed; the tree is the source of truth. See
+the root `CLAUDE.md` for project-wide context (running, persistence, dev
+workflow); see `src-tauri/CLAUDE.md` for the backend file map.
+
+**Entry & shell**
+
+| File | Purpose |
+|------|---------|
+| `src/App.tsx` | Root component, theme injection, global key handlers. |
+| `src/main.tsx` | React entry point. |
+| `src/crashReporter.ts` | Captures/forwards WebKitGTK renderer crashes to the backend. |
+| `src/types/index.ts` | Shared TypeScript types. |
+
+**Layout (`src/components/layout/`)**
+
+| File | Purpose |
+|------|---------|
+| `AppShell.tsx` | Top-level layout: header, center, right-panel wiring. |
+| `HeaderBar.tsx` | Window drag handle + hosts the project switcher in the header. |
+| `GlobalAppBar.tsx` | Global toolbar / app launcher (`GLOBAL_APP_ROLES`). |
+| `GlobalAppMenu.tsx` | Context menu for a global-app toolbar button. |
+| `CenterPanel.tsx` | Tab/subwindow tiling host; keeps all panes mounted across scope switches. |
+| `DetachedCenterPanel.tsx` | Center-panel variant rendered inside a detached OS window. |
+| `DetachedApp.tsx` | Root component for a popped-out/detached subwindow (#42). |
+| `ProjectSwitcher.tsx` | Thin composition root: pill strip + search/dialog/settings wiring. Re-exports scaffold helpers. |
+| `ProjectSearch.tsx` *(in `projects/`)* | Inactive-project/box search box + results popover. |
+| `ProjectDialog.tsx` *(in `projects/`)* | New/Import project dialog incl. SSH + OpenVPN + scaffold-fill sub-flows. An import's source is a local folder, a GitHub/GitLab **clone** (`git_clone` lands the tree, then the ordinary import registers it in place), or a **fork** of one (`git_fork_clone` — the same landing, preceded by creating the user's own copy on the host so the project has something to push to, with the original left as `upstream`). Fork adds only a *Host type* row (detect-from-URL / GitHub / GitLab: a self-hosted host names neither, and the provider decides which CLI runs) and a `gh`/`glab` install banner; every other branch is the clone's, since a fork import *is* a clone import. |
+| `SettingsPanel.tsx` | Settings dialog + sub-panels (theme/git/layout, global apps, file-type apps, Ollama, shortcuts, help). |
+| `RightPanel.tsx` | File-tree overlay panel. A thin host: its whole file *viewer* is the shared `files/ProjectFilesView` (same component the Files (Project) tab renders). It owns only what is panel-specific — the active-project identity it forwards, the browsed-folder in the projects store, and the three window-chrome fragments it injects as slots (📌 pin, the resize border, the "Hidden subwindows" list). |
+| `VpnPasswordPrompt.tsx` | Modal prompting for an OpenVPN password on activation. |
+| `LogoIcon.tsx` | Inline SVG logo. |
+
+**Projects, header widgets, tabs, terminal, files, embed, common**
+
+| File | Purpose |
+|------|---------|
+| `projects/ProjectPill.tsx` | Individual project pill (click/close/drag-reorder/group). Its "Remote machines…" Runtime item opens `RemoteMachinesWindow`. |
+| `projects/HpcPipelineWizard.tsx` | **The guided HPC/SLURM pipeline wizard** (`docs/quirky-knitting-umbrella` plan Phases B + C), launched from the project-switcher **+** menu ("HPC pipeline…"). A 6-step stepper that **composes existing flows** rather than reimplementing them: **Login** (`RemoteProjectSection` + `useRemoteSession`) → **Project** (name + local-mirror location) → **Workspace** (`lib/hpcWorkspace`: allocate or adopt an `hpc-workspace`, **then** `create_project`) → **Load data** (skippable; picks local files → `remote_upload_file` streams them to the host over the pooled SFTP) → **Run job** (edits a starter `.slurm`'s `#SBATCH` via the Phase-A splice helpers, writes it to the host, and Phase-A `submitSlurmJob`) → **Watch** (the log tab is already tailing; points at the Jobs view). The **Workspace** step is why project creation moved to the end of it: a cluster's `$HOME` is a small quota'd code filesystem, so the data belongs in a time-limited workspace on the parallel filesystem — and the integration is exactly one assignment, `remoteChosenPath = <workspace path>`, since `buildRemoteSpec` derives the host root from it and **every** transport (SFTP upload, byte-sync, git lockstep, run tabs) follows. The alternative layout (project in the browsed `$HOME` folder + the workspace symlinked in as `./data` via `hpc_ws_link`) is offered with its caveat stated: byte-sync never follows a symlink. A host with no workspace tooling skips the step's content and keeps the same single Create button. The step also offers the **home anchor** (default on): a small `~/eldrun/<project>/` with `logs/`, a `workspace` symlink and an append-only record — the only thing that still names the workspace after expiry deletes it — after which the starter script's `--output` is spliced to write job logs there. `HpcPipelineWizardHost` is mounted once in `AppShell`, driven by `stores/hpcPipeline`. Untested. |
+| `projects/RemoteMachinesWindow.tsx` | **The one unified remote hub** (`docs/multi_host_remote_plan.md` §4.4): one entry per host — the **primary** first (it owns files/git/mirror; Connect/Manage only, no sync/pull/remove), then each extra "worker" machine — plus **Add a machine**. Every host's Connect/Manage opens the shared per-host `RemoteConnectDialog` (primary → `"primary"`, worker → its id), which renders on an *elevated* backdrop (`.modal-backdrop-elevated`) so the detail sits above this hub. Workers also get "Sync code now", "Pull outputs…" (size-confirmed), and the shared-fs/`sync_code` toggles. The Add-machine form opens on **"Your machines"** — the header's **global machines** (`stores/globalMachines`), offered here rather than only from the other end: a global machine is already set up and already authenticated, so retyping its address and logging into it a second time was work the dialog could do itself. A row's **Add** seeds the same confirm-shared-path panel the header menu's handoff does (`pendingDrop` → add + connect, shared-fs), so there is one add-and-connect path, not a second copy of it; **Use in the form** just fills the address/user/label for the ordinary flow (browse the folder, or sync a copy). A machine already this project's primary or worker — matched by SSH **target**, never by id, since a project host is a copy by value (`lib/machineSync`'s `sameTarget`) — is shown as "Already added" with no action. The Add-machine form's remote path can be **typed or browsed** — a **connect-then-browse** picker that runs on the SHARED login mechanism (`useRemoteBrowse` hook + `RemoteFolderBrowser` component, the exact same connect/list/mkdir machinery the new/extend-project flow uses), so there is one implementation of "log in to a host and browse it", not a worker-specific copy. Only the fields around it are this dialog's own. It connects with a transient, unsaved password (key-auth if blank) — **or**, with **"Sign in in a terminal"** (`TerminalSignInToggle`, on by default in non-headless mode), in an embedded login terminal whose ControlMaster the browse then rides via `useRemoteBrowse.openSession`, so a host that asks for a challenge code can be added at all — and browses to the folder: the existing shared folder for a shared-fs worker, or the (creatable) destination for a synced copy. Standard `modal-backdrop`+`project-dialog` chrome (worker cards = `.remote-machine-*` in themes.css). Mounted once as `RemoteMachinesDialogHost` in AppShell, driven by `stores/remoteMachines`; opened from **any of the pill's connection lamps** (`header/RemoteConnMenu` — every lamp now opens this hub, not a per-host connect), the pill's Runtime item, and the file viewer's **SSH (remote) type tag** right-click (`ProjectFilesView`, now a single "Remote machines…" item). Workers are one-way read-only experiment machines; the primary stays the project's `remote`. |
+| `projects/useRemoteBrowse.ts` | **The** shared "log in to a host + browse its filesystem over SFTP" state machine — the ONE implementation of *how* a remote connect + folder browse works, so the primary machine and further (worker) machines never carry two copies. A live session is a FROZEN `(conn, password)` pair (a credential edit means `reset`+reconnect); the listing auto-refreshes on path/conn change. `connect` (ssh_connect + remember + open start dir), `openSession` (freeze a session another path already authenticated, e.g. a non-headless login terminal's ControlMaster), `enter`/`goUp`/`jump`/`mkdir`/`reset`. Used by `useRemoteSession` (new/extend-project) and `RemoteMachinesWindow` (add-worker); each keeps its own fields/steps/VPN around it. |
+| `projects/RemoteFolderBrowser.tsx` | **The** remote folder-picker UI (`.remote-browser` chrome: breadcrumb, go-up, recently-used jump, inline new-folder, listing, footer), rendered by both the new/extend-project flow (`RemoteProjectSection`) and the add-worker flow (`RemoteMachinesWindow`) so the browse step is one component, not two. Owns only the new-folder input text; everything else is the caller's (fed from `useRemoteBrowse`). Exports `remoteEntryExt` (file-type icon helper). |
+| `projects/TerminalSignInToggle.tsx` | **The** "Sign in in a terminal" switch — the non-headless login offered **per connect**, on both channels of both connect dialogs (`RemoteConnectDialog`, `RemoteProjectSection`), default **off**. It exists because headless can only ask what it has fields for: a host or tunnel that answers with a challenge/OTP or a second prompt can never be logged into from them, however many retries. Flipping it on swaps the password fields for the same embedded login terminal `connections_headless: false` uses. Never writes the global setting (a mode is the user's statement, not a failed handshake's), never offered on Windows (no ControlMaster to ride — the `winManual` reason), and never discards a saved credential: the Save password row renders from *both* halves of the section. The VPN modal's equivalent is a button (`stores/vpnPrompt`'s `handoffToTerminal`). See `docs/context/remote_credentials.md`. |
+| `projects/CredentialPasteBar.tsx` | **The** "Type it for me" row above an embedded **login terminal** — the buttons that put a known login name, and a *saved* password, at the terminal's cursor. It exists because a terminal login and a saved credential were never the contradiction they look like: non-headless means Eldrun does not *handle* the secret (the host asks, the user answers, in a terminal they can see), not that the keychain is empty — a password saved from a headless connect, or from the header's VPN menu, was simply unreachable there and got retyped into every login. The secret never enters the frontend: a password button calls the backend `credential_paste_to_pty`, which reads the keychain and writes the bytes into the PTY itself; only non-secrets (an SSH login name, a VPN auth username the dialog already shows in a plain field) are pasted from here via the ordinary `pty_write`. Nothing is submitted — a paste is not a login, so the line stays correctable until the user presses Enter. `sshPasteEntries`/`vpnPasteEntries` build the button sets once for all three surfaces (`RemoteConnectDialog`, `RemoteProjectSection`, `RemoteMachinesWindow`); an unsaved target (or a locked keyring, which reads the same) reports "nothing saved for this login" rather than pasting an empty secret. Untested. |
+| `projects/BigFolderExcludeDialog.tsx` | "These folders are giant — sync them?", asked **once**, at setup (opened by the new/import-remote and extend-to-remote flows via `stores/bigFolders`, and re-openable from the file view's "Large folders…"). Mounted once as `BigFolderDialogHost` in AppShell, for the same reason the remote-machines manager is: the project that asked may not be active by the time its census returns. Lists each folder with **both** sides' numbers (a dash where the folder doesn't exist there — at setup that distinction is the whole point: host bytes are usually experiment output that should stay, local bytes are usually a build/venv that should never go up), ticked to exclude by default, and re-runs the census when the project's SSH lamp turns green so a not-yet-connected project fills in its host column. Writes `sync_set_excluded` — the marker the whole-project pull/push honours, not just the auto engine. |
+| `projects/BoxPill.tsx` | Project-box pill (meta-grouping, #13/#41). |
+| `projects/ActivityCalendar.tsx` | Per-project activity calendar heatmap (unrelated to the calendar tab). |
+| `projects/scaffold.ts` | Pure helpers: name sanitize, SSH-address parse, scaffold/description fill prompts. |
+| `calendar/CalendarPane.tsx` | Calendar tab shell: toolbar, search, ICS import/export, view switch. |
+| `calendar/TimeGrid.tsx` | Day/week hour grid: positioned blocks, drag-create/move/resize, now-line. |
+| `calendar/MonthView.tsx` | Month + multiweek grid, with multi-day spanning bars. |
+| `calendar/AgendaView.tsx` / `calendar/TasksView.tsx` | Flat upcoming list; to-do (VTODO) list. |
+| `calendar/EventDialog.tsx` | Event editor (repeat, reminders, category) + this-vs-all-occurrences prompt. |
+| `calendar/CalendarSidebar.tsx` | Mini-month + calendar list (color, visibility). |
+| `calendar/AlarmPopup.tsx` | In-app reminder popup (snooze/dismiss); mounted in `AppShell`. |
+| `header/Clock.tsx` | Header clock. |
+| `header/AppTimerDisplay.tsx` | Active-project time-tracking readout. |
+| `header/AppResourceDisplay.tsx` | CPU/RAM/GPU readout. The GPU row is the **device's** memory + utilization (`gpustat`), not Ollama's models — those are one line of its tooltip, and the whole reading only on a machine whose GPU can't be read, where it falls back to the old Ollama-only figure rather than showing a zero. |
+| `header/ConnTypeIcon.tsx` | Local/remote (SSH) connection-type icon. |
+| `header/MachinesIndicator.tsx` | Machine-wide **global machines** (SSH hosts no project owns): the VPN indicator's pattern applied to SSH — authenticated once, with no project or path attached, then connected/monitored/reordered from the header. **Opens on click, never on hover**, and its open-sweep is rate-limited (60 s per machine, in-flight-guarded) and skips HPC-tagged rows — `ssh_probe` is a full authenticated login on each host, so a hover-opened menu logged Eldrun into the whole fleet as the pointer crossed the header. A row reads **two** maps, not one: `status` (a session this app opened) and `reachable` (the last probe), which is what lets it distinguish connected · stale (session held but no answer) · up · no answer · not checked, instead of painting a probe green. A machine reaches a project **only** through a row's "add to a project" picker (`⇥`), which lists the *open* projects and names the outcome for each: a **remote** project gains it as a `shared_fs` compute host (`stores/remoteMachines`'s `pendingDrop` → `RemoteMachinesWindow`), a **local** one is offered "Extend to remote" with it as the primary (`requestExtend` → the target's `ProjectPill`, which owns that dialog). Attaching is deliberately **not** a drag: a native HTML5 drag out of a hover-menu is unworkable under WebKitGTK (the menu closes or hangs mid-drag, and a drop that misses its target never fires, leaving the row stuck in a dimmed drag state nothing can clear) — and its target lives outside this list anyway. Rows *do* **reorder by dragging their grip**, on **pointer** events (the same choice `TabBar`/`YamlTree` made), with a keyboard ↑/↓ equivalent on the focused grip: the DOM order is frozen for the gesture and the other rows merely `transform` aside to open the landing slot, so the rects measured at pointerdown never shift under the cursor they're compared to. **Removing a machine actively disconnects it first** when it is live (`stores/globalMachines`' `remove` → `disconnect`) — dropping the row otherwise strands an SSH master, and any tmux job under it, with no handle left in the UI. Also the one entry point to **"Remote host usage…"** (`common/RemoteUsageWarningDialog` via `stores/remoteUsage`'s `open`): that report used to put itself on screen after every remote connect; it is on demand only now, and its subject is **this list** — a section per global machine in this menu's order, then the active project's own hosts not already in it (matched by SSH target, never by id) — read on demand rather than swept: opening it used to authenticate against every machine ever added, so a disconnected or HPC-tagged host now renders from cache with its own **Read now**. The **add-a-machine** form also carries **"Sign in in a terminal"** (`projects/TerminalSignInToggle`, on by default in non-headless mode): the login goes to the **root terminal** rather than an embedded PTY (a hangover from when this menu closed on mouse-out; it now opens on click and dismisses on Escape / an outside click) — and once a credential-less `ssh_connect` rides the master it left behind, the machine is `register`ed (persist without a second authentication) rather than `add`ed. Two probe commands sit behind that one list: a global machine authenticates ad-hoc (`global_machine_usage_check`, the twin of `global_machine_monitor_snapshot`), a project host rides its pooled ControlMaster (`remote_usage_check`); same script, same parser, so the sections read alike. |
+| `header/VpnIndicator.tsx` | Machine-wide OpenVPN control: always present, lists stored `.ovpn`s, connects/disconnects a tunnel with or without a project behind it, names its holders, and arms one to connect on launch. |
+| `header/WindowControls.tsx` | Minimize/maximize/close window buttons. |
+| `tabs/TabBar.tsx` | Per-subwindow tab strip (add/rename/close, pointer-based DnD). |
+| `tabs/Subwindow.tsx` | A single tiled subwindow (tab group). Its body is a row: the measured pane region + (when the group's `filesOpen` is set) the docked per-subwindow file viewer. |
+| `tabs/agentModes.ts` | Planner/doer capability table: which agents can be launched into a Plan/Auto mode **and** resume on the respawn that costs (Claude + Gemini), plus the idempotent arg rewrite. |
+| `tabs/commitDrop.ts` / `tabs/commitFileDrop.ts` | Apply a tab/file drag-drop into the layout tree. |
+| `tabs/dragGeometry.ts` | Drop-zone/split geometry math for tab drags. |
+| `terminal/TerminalView.tsx` | xterm.js terminal wrapper + PTY I/O. |
+| `files/FileTreeSearch.tsx` | The flat result list `FileTree` shows in place of the browsed listing while its search box holds a query. Two modes: **name** (literal case-insensitive substring match on paths from `list_project_paths`, basename hits ranked first — deliberately NOT a fuzzy subsequence, which matches nearly everything) and **content** (literal line search via `project_search`, the same backend the right panel's Search view uses). Every result does both **jump-to-path** (reveal + select in the tree, via `FileTree`'s `revealPath`) and **open** (content hits open at the matched line). Confined to the browsed folder by default (`scopeRel`) with a **root** toggle for the whole project — content search walks only the scope; filename results filter to it. Local-source only — both backends walk the canonical local path — so `FileTree` only shows the box for a non-remote-source tree. |
+| `files/FileTree.tsx` | Project file tree with git markers, fs-watch refresh. Hosts the in-tree search box + `FileTreeSearch` results and owns `revealPath` (jump-to-path: navigate to a rel path's folder, select + scroll the row). Owns the file drag-and-drop: pointer-drag a file onto a tab bar (→ embed/split/popout, via `stores/drag` + `commitFileDrop`), onto a folder row to move it, ctrl+drag to export it to the OS. Its "Open in a new tab" is a *host* callback (`onOpenFolderTab`), not a store call — a tree with no way to own a tab (a box root, a popout running on a streamed copy of the tabs) simply doesn't pass one, instead of offering an action that would go nowhere. |
+| `files/ProjectFilesPane.tsx` | **The** project file view — tree, sort row, remote sync row, Downloads — rendered *twice*: by `RightPanel` and by the Files (Project) tab. One component, so the panel and the tab can never drift into two different file views of the same project (the bargain `PageStrip` strikes between the print preview and the PDF rail). What each host still owns is exactly what must differ: the browsed folder (two views of one project must not yank each other around), the sort (the panel unmounts the pane for Git/Search and the order has to survive the trip back), and where the Remote/Local switch sits. Also home to `useFileSource` (defaults to whichever side is *usable* — a disconnected remote opens on the mirror, not on a Connect prompt) and `useRemoteBlocked` (the gate every SFTP/git probe needs: they are synchronous Tauri commands, so dispatching one at a dead session freezes the window). |
+| `files/ProjectFilesView.tsx` | **The** whole file *viewer* — view switcher (Files / Git / Search / Apps / Orange), inline git action bar + `GitHistory`, `SearchPanel`, tracked-windows list, diverged-files (orange) list, type tags, hover card, SSH logout, import / open-in-OS / downloads / settings — wrapped around `ProjectFilesPane`. Rendered *twice*, by `RightPanel` and by the Files (Project) tab, so the panel and the tab can never drift into two different file *viewers* (the same bargain `ProjectFilesPane` strikes for the tree). Each host owns only what must differ: identity (panel = active project, tab = its own scope), the browsed folder, the `useFileSource` hook, and the panel-only window chrome — injected via the `resizeHandle`/`pin`/`hidden` ReactNode slots, so a tab (which has none) simply passes none. `active` gates git/windows probes + the pill dirty-dot write (a closed panel / background tab never churns); `mountTree` keeps the tree + fs-watch alive (a background tab keeps its tree even when not probing). Also hosts the **HPC** surfaces (`docs/hpc_workspace_plan.md`): the Jobs view's workspace list (remaining time toned, **Extend**, **Move here**, **Pull logs**) and the **expiry banner** — raised in *every* view, not just Jobs, because for a project whose root lives in a workspace an expiry deletes the host tree itself, and a warning nobody navigates to is not a warning. The workspace read therefore also runs outside the Jobs view whenever the project records a workspace. |
+| `files/ProjectFilesTab.tsx` | The Files (Project) tab: a thin host that renders `ProjectFilesView` (so it has *exactly* the panel's features). It resolves the project from its own `scope` and keeps the browsed folder on the *tab* (`TabEntry.folder`, persisted), which is what makes "Open in a new tab" on a folder mean anything after a restart. Passes no window-chrome slots. Also exports `openProjectFilesTab` (kept here to avoid a `ProjectFilesView`↔tab import cycle). |
+| `files/SubwindowFilesSidebar.tsx` | The per-subwindow right file viewer (◫ on every tab bar, main window and popouts): a resizable column docked on a subwindow's right edge, hosting the SAME `ProjectFilesTab` host the Files (Project) tab is — so all viewer surfaces stay one component. State (`filesOpen`/`filesWidth`/`filesFolder` — open flag, column width, and the browsed folder) lives on the layout tree's `GroupNode`, so it persists with the layout, travels with a detach, reaches a popout via the streamed `files` detached edit, and is freed when the subwindow (group) is dropped; the sidebar renders BESIDE the measured pane region, which is what keeps the main window's flat pane layer from painting over it. |
+| `files/importDrop.tsx` | OS-file drop → copy into the project, with the collision prompt (`useImportDrop`). Shared by the panel and the tab so an import behaves the same wherever it lands. WebKitGTK withholds dropped paths from HTML5 drops and only leaks one via `text/html`, which is why the picker (`⬇`) — not the drop — is the reliable multi-file route. |
+| `files/ProjectFilesSettings.tsx` | The tree's hide-these-endings lists (read from / written to the project's own `project.json`, hence shared by both file views) + the Project Settings dialog that edits them. |
+| `files/FileBrowser.tsx` | The *other* files tab: a two-pane explorer (list/icons, columns, history). Deliberately not the tree — no drag-and-drop, no git markers; both are offered. |
+| `files/GitHistory.tsx` | Commit history / commit / push UI. |
+| `files/SetDefaultAppDialog.tsx` | Pick the default app for a file type. |
+| `embed/EmbedPane.tsx` | Hosts an embedded external app window. |
+| `embed/FileViewerPane.tsx` | In-app viewers (image, markdown, code, TeX/SyncTeX) + shared viewer plumbing. |
+| `embed/YamlTree.tsx` | The YAML/JSON structure tree: the editable half of the viewer, the way the rendered preview is markdown's. It renders *rows*, but it edits *text* — every action splices the draft `TextView` already owns, so Tree and Source need no conversion between them and a tree edit is an ordinary dirty/undoable/saveable change. A flow (JSON) container is badged as such, because that is the style its edits will keep. A key wears its `#` comment on its **hover** and a `#` marker when it has one (a config file's comments are the half worth reading, so they are not hidden behind a hover — only their text is). Reordering is a **pointer** drag from the row's grip (HTML5 DnD does not work under WebKitGTK, and mid-gesture listeners get dropped, so every handler is bound to the grip up front); it lives in `YamlRows` because a node can only be reordered **among its siblings** — dragging a key into another mapping is a re-parent, not a reorder. Every entry also has a **copy** button feeding an app-wide buffer (plus the system clipboard as text) and a click-placed **paste cursor**: the cursor only lands where the entry *fits* (`canPasteAfter` — mapping entry into a map, item into a list, block/flow never mixed), so a paste can never tear the file. |
+| `embed/YamlGrid.tsx` | The YAML/JSON **card view** — an *optional* view for structured YAML/JSON, beside Tree (the default) and Source (#yaml-grid; the toggle reads "Cards"). A **drill navigation, not an infinite nest**: one card is "main" at a time; the grid shows a breadcrumb from the document down to it, the main card's *level* (its siblings, so you can step sideways without going up first), and the main card's *children* as the next level below. A card shows only its own **scalar fields** — its nested collections are reached by clicking its title (or its "N groups" footer), which opens it as the new main and reveals them as the next level; a card with no nested collection gets a static (non-clickable) title. With nothing focused the grid is the top overview: a root map is one `document` card, a root list is a card per item. A list item's card is titled by its name-ish field (`name`/`id`/…) or `Item N`, never `#0`. **Cards reorder by dragging** among their siblings — pointer-based from a grip (HTML5 DnD is dropped by WebKitGTK) — committed as one `moveNodeTo` splice, exactly as `YamlRows` does. Like `YamlTree` it renders controls but edits *text* — every action splices the same draft via `lib/viewers/yaml`'s ops (`setValue`; `addChild` for `+ field`/`+ card`/`+ value`; `deleteNode`; `duplicateNode`; `moveNodeTo`), so a card edit is an ordinary dirty/undoable/saveable change and Cards/Tree/Source are three views on one text. A value it can't safely rewrite is shown, not offered (`source only`). `TextView` opens YAML in **Tree** by default; the Cards toggle appears only for a file that nests something to card (no `hasCards` ⇒ hidden), and the card view still needs work. |
+| `embed/TableView.tsx` | The CSV/TSV table (and, read-only, the `.xlsx` sheet). Like `YamlTree`, it renders *rows* but edits *text* — a cell edit splices the draft `useEditableFile` owns, so it is an ordinary dirty/undoable/saveable change and every cell nobody touched keeps its bytes. Hence sort and filter carry each row's **source** index (`RowRef`): a splice must address the row a cell came *from*, not the row it sits on. The separator is a **guess the reader can overrule** — sniffed, then offered in the header (Auto/comma/semicolon/tab/pipe/custom); an override persists per tab, Auto does not. Columns hide by name from `ColumnsMenu` (click to hide, click again to show; multi-select, so it stays open), which is why the row filter searches only the **visible** columns and why hiding is dropped when the delimiter changes — a hidden column is an *index*, and another separator cuts the row into different ones. Only the visible rows render, which is why the column widths are measured over the whole file up front: sized to what is on screen, every column would resize as you scrolled. |
+| `embed/GifView.tsx` | The animated-GIF viewer (#gifviewer): the plain image viewer already *animates* a GIF (the webview animates `<img>` natively) but offers no control, so this one decodes the frames itself (`lib/viewers/gif.ts`) onto a `<canvas>` and adds the transport — play/pause, frame stepping, scrubber, speed, loop, frame/delay readout — over the image viewer's exact zoom/pan (shared exported pieces: `zoomOffset`/`clampScale`/`useNonPassiveWheel`). Playback is a rAF timestamp accumulator, so per-frame delays are honored without drift; authored sub-20ms delays play at the 100ms browser convention. A GIF the decoder can't handle degrades to the native animated `<img>` — never worse than before the viewer existed. No Annotate: flattening to PNG would silently destroy the animation. |
+| `embed/pdf/PdfViewer.tsx` | The PDF viewer: pdf.js canvas stack, zoom/find/print toolbar, SyncTeX, page rail, and the **contents** sidebar (chapters, ☰ at the toolbar's far left). Renders an *arrangement* (`pageModel`), not the file — so reorder/delete/turn/merge are array ops, and nothing is written until Save. |
+| `embed/pdf/pdfDoc.ts` | The open source documents an arrangement draws from, and `buildPdf` — the ONLY place a PDF is written (pdf-lib, on save). |
+| `embed/pdf/outline.ts` | The contents/chapters model (#pdf-outline), pure. `loadOutline` resolves the PDF's **embedded** outline (bookmarks) to 1-based file pages (named + explicit dests); `detectHeadings` is the **font-size fallback** used only when there's no embedded outline — it infers a heading tree from the text's typography (body-size mode, line grouping, running-header drop, nest-by-size). Jumps map a file page to whichever sheet shows it, so they survive page rearrangement. Tested in `src/__tests__/PdfOutline.test.ts`. |
+| `common/PageStrip.tsx` | **The** page-thumbnail strip: drag-reorder, shift-select, turn, delete, right-click. Used twice — horizontally by the print preview, vertically as the PDF viewer's page rail. |
+| `common/mountPageStrip.tsx` | `createRoot` adapter letting the imperative print modal host `PageStrip`. |
+| `common/Dropdown.tsx`, `common/OrbitSpinner.tsx` | Shared primitives. |
+| `common/ConnLamp.tsx` | Red/orange/green SSH/OpenVPN status lamp (dialog + header). |
+| `common/LocalLossDialog.tsx` | Warns that lockstep or sync **destroyed something in the local mirror** (#28q). Mounted at the shell, like the alarm popup: a background pass can delete a file while the user is three tabs away. It reports, it does not confirm — the write has already happened; the gates that prevent one live upstream. |
+| `stats/StatsRecap.tsx` | Usage recap dialog: agents/models used, prompts asked, file churn, commits, time per project, Day/Week/Month. |
+| `stats/StatsRecapHost.tsx` | Decides when the recap is on screen: once per day at launch (anchored on *yesterday*), or on demand via the `eldrun:open-stats` event. Mounted in `AppShell`. |
+
+**Stores (`src/stores/`), hooks, lib**
+
+| File | Purpose |
+|------|---------|
+| `projects.ts` | Project list, active project, CRUD, `setActive`. |
+| `tabs.ts` | Tab/subwindow layout tree per scope; tab persistence policy. |
+| `boxes.ts` | Project boxes (meta-grouping) CRUD + membership. |
+| `settings.ts` | App settings (theme, default agent, git profile, shortcuts, etc.). |
+| `windows.ts` | Embedded app windows. |
+| `detached.ts` | Detached/popped-out subwindow state (#42). |
+| `drag.ts` | Isolated per-frame drag state (reference for fine-grained selectors). |
+| `activity.ts` | PTY-output activity outside React (`lastOutputByPty`). |
+| `timer.ts` | Per-project time-tracking state. |
+| `usage.ts` | Usage counters: in-memory accumulator (`bumpUsage`) flushed in batches to `usage_bump`, + the recap's read store. |
+| `hpcPipeline.ts` | Open/closed state for the guided HPC pipeline wizard (`docs/quirky-knitting-umbrella` Phase B) — one boolean + open/close, so the **+** menu launches `HpcPipelineWizardHost` (mounted in `AppShell`) without prop-drilling. Mirrors `remoteMachines`. |
+| `hpcJobs.ts` | SLURM jobs this session submitted, per project (`docs/quirky-knitting-umbrella` plan) — so the Jobs view shows a just-submitted job (and can re-open its log) before the next `squeue` poll, and can resolve a job id back to its out-file. `squeue` on the host is the source of truth; this is only the small in-memory memory of "what did I launch, and where's its log" (no persistence — out-paths are re-derivable via `scontrol`). |
+| `calendar.ts` | Global calendars/events/tasks store (one `calendar.json` across all scopes). |
+| `alarms.ts` | Reminder ticker: fires an OS notification + the in-app popup, exactly once each. |
+| `linkRouting.ts` | Routing of clicked links/URIs to viewers or external apps. |
+| `pdfSync.ts` | Bidirectional PDF/SyncTeX sync state. |
+| `pdfDrag.ts` | Dragging PDF pages between page strips, incl. across two Eldrun windows: strip registry + the `PDF_DRAG_*`/`PDF_DROP_ACK` protocol (OS-cursor stream in physical desktop px; bytes ride the backend `pdf_clip` slot, never the event payload). |
+| `editorJump.ts` | Cross-pane jump-to-location requests. |
+| `vpnPrompt.ts` | State backing `VpnPasswordPrompt`. |
+| `remoteStatus.ts` | Live SSH/VPN connection state for the header lamps. `byProject` holds the PRIMARY host (unchanged — the ~300 file/git readers only ever want the primary); **multi-host** worker hosts (`docs/multi_host_remote_plan.md`) live in `byHost[projectId][hostId]`, read via `sshOf`/`vpnOf`/`hostStateOf` which route `"primary"` to `byProject`. `setSsh`/`setVpn` take an optional `hostId`. |
+| `localLoss.ts` | The active project's local-loss log (#28q). Pulled from the backend's on-disk record — not pushed as an event — so a deletion during a background pass, or while the app was closed, still surfaces. |
+| `vpnStatus.ts` | **Machine-level** OpenVPN state, keyed by config path: the tunnel reroutes the whole OS, so it outlives the project view and is shared between projects. Owns the holder refcount (`releaseVpn`) and the `markVpn*` helpers. |
+| `hooks/useKeyboard.ts` | Global keyboard-shortcut hook. |
+| `lib/shortcuts.ts` | Shortcut definitions, chord parsing/resolution. |
+| `lib/codexHooks.ts` | Codex hook-trust state + the one-click "open Codex on `/hooks`" fix. |
+| `lib/vpnConnect.ts` | The silent-connect gate: ask `vpn_can_connect_silently` **before** connecting, because `pkexec` prompts the user before OpenVPN validates anything — a doomed attempt costs a polkit dialog, and the modal after it costs a second. Store-free, so `stores/projects` can use it. |
+| `lib/vpnAutoConnect.ts` | "Connect on launch", armed per `.ovpn` (`settings.vpn_auto_connect`): the machine-level twin of a project's `remote.auto_connect`, and like it, never prompts — re-checked at launch, so a stale opt-in leaves the tunnel down. Also home to `openVpnLoginInTerminal` + `pollVpnUp`: **the** non-headless VPN login (arm the tunnel, hand the connect command to a root-terminal tab, poll `openvpn_status` to a terminal mark), shared by the paths that are always non-headless *and* by the headless surfaces falling back to it for one connect (`stores/vpnPrompt`'s `useTerminal`). |
+| `lib/i18n.ts` | **The** internationalization module — the ONE place every UI language lives (`en`/`de`/`es`/`fr`/`it`), so adding a string or a language is a single edit here, never a hunt through the tree. Dependency-free: a flat `lang → (key → text)` map with **English as the source of truth** (it holds every key; other languages fall back to English then the raw key, so a half-translated language degrades gracefully). The live language is a tiny zustand store (`useI18nStore`) seeded from a `localStorage` cache (first-paint before settings load) and driven by `applyLanguage`; **switching is instant** — `useT()` subscribers re-render in place, no reload. Persistence rides `Settings.language` (`stores/settings` `setLanguage` + `applyLanguage` on load; broadcast to popouts via `LANGUAGE_CHANGED_EVENT`, mirroring the theme path). Currently wired through the Settings dialog's main panel; extend coverage by routing more strings through `t()`. Tested in `src/__tests__/i18n.test.ts`. |
+| `lib/machineSync.ts` | Keeps a **global machine** (header "Machines") and the **project host** it also is (a project's primary `remote`, or a `compute_hosts` worker) in step. The two are never linked by id — dropping a machine onto a project copies it by *value* — so the only bridge is the **SSH target** (`user@host:port`), which `sameTarget` owns (host case-insensitive, default port 22, empty user ≡ absent; a different login on the same host is a *different* connection). The physical connection genuinely is shared (one ControlMaster per target), so this mostly reconciles two status stores rather than opening a second socket. Two asymmetric rules keep it from looping or lying. **Global → project** rides a *subscription* on the machine's `status` → `connected`, so it fires whichever action connected the machine rather than the two that used to call it by hand (a machine turned green by a probe never reached its project at all — the "machine green, project disconnected" bug). It can be a subscription now because `status` no longer answers "reachable": `probeAll` writes `reachable`, and only a session this app opened writes `status`. For the **active** project it opens the real pool (`remote_connect`); for a loaded-but-inactive one it writes **nothing** — a mirrored green lamp both lied (no pooled session behind it) and *blocked* the later real connect, since activation only proceeds from `off`. Skips a host tagged HPC before opening a pool: `remote_connect` raises a `ControlPersist=600` master, the standing presence the tag forbids. (Disconnect stays imperative — it has to mirror the teardown *before* `remote_kill_all_jobs`, an ordering a subscriber cannot reconstruct.) **Project → global** is a *subscription* (`initMachineSync`, installed once in `AppShell`) that only ever **upgrades** a matching machine to `connected` — `off` is deliberately never propagated upward, because a project deactivating *clears* its lamps and would otherwise knock an independently-connected machine offline. No loop is possible: the global store's `setStatus` never writes `remoteStatus`, so the subscription can't re-enter the imperative path. |
+| `lib/viewers/{fileUtils,markdown,highlight,tex}.ts` | Pure viewer logic (XSS-safe markdown/highlight, TeX, file utils). |
+| `lib/viewers/python.ts` | Python editor intelligence (#87), all pure — every fs touch is injected. Two halves: **breakpoints** (pdb refuses blank/comment lines, so a gutter click *snaps* to the next executable one; a line number re-points at the wrong statement when you type above it, so every edit *remaps* them) and **go-to-definition** (a *lexical* import-graph walk — relative levels, aliases, `__init__` re-exports, src-layout — not a type inferencer). Only names it can actually follow are underlined, so the ctrl+click affordance never lies. |
+| `lib/slurm.ts` | **SLURM run/watch glue for HPC projects** (`docs/quirky-knitting-umbrella` plan), modeled on `pythonRun.ts`. Two halves: (1) **pure text helpers** — `isSlurmScript` (has a `#SBATCH` line), `parseSbatchDirectives`/`directiveValue`/`spliceDirective` (the render-rows/edit-text bargain the YAML/table viewers use: the directive form edits the script's `#SBATCH` lines by **splicing**, never re-serializing, so comments/untouched lines/the flag spelling all survive and each edit is an ordinary dirty/undoable change; short flags fold into their long key); (2) **tab glue** — the **log window** (`tail -n +1 -F <out>`, follows-by-name so it waits out the queue) and the **interactive shell** (`srun --pty … bash -l`, lands on a compute node — the compliant path) are just terminal tabs, exactly as a Python run is, so they inherit host locality + tmux persistence for free. `submitSlurmJob` invokes `slurm_submit`, opens the log tab, and records the job in `stores/hpcJobs`. Passes the file's **absolute** path as the script id so one command works remote or local. Untested until cluster QA. |
+| `lib/hpcWorkspace.ts` | **HPC workspaces** (`docs/quirky-knitting-umbrella` Phase C; backend `commands::hpc_ws`) — the step that must happen *before* any data reaches a cluster. `$HOME` there is a small quota'd filesystem for code; the bulk data belongs in a **workspace**: a directory on the parallel filesystem with a name, a duration and an expiry after which it is **deleted**. Invoke wrappers (`wsAvailable`/`wsList`/`wsAllocate`/`wsExtend`/`wsRelease`/`wsLink`) plus the pure helpers the two surfaces share — `projectPathIn` (where a project inside a workspace goes), `remainingLabel`/`expiryTone` (the clock, toned because expiry *deletes*), `defaultFilesystem`, and the `wsTargetFor{Project,Host}` pair that encodes the one asymmetry: a workspace is usually allocated **before the project exists**, so the command can also run against a bare, just-authenticated host. `linkedWorkspaceCaveat` is the single wording of "a symlinked workspace is reachable to the host's tools, not to Eldrun's byte-sync" (which is lstat-typed and skips symlinks by design). Also the **anchor + lifecycle** half (`docs/hpc_workspace_plan.md` Phases 1–2): `wsAnchor`/`setProjectHpc` (the small `$HOME` folder — `logs/`, a `workspace` link, an append-only record — plus the `ProjectEntry.hpc` record that is the ONLY thing naming the workspace once it is deleted), `defaultAnchorRel`/`logOutputPattern` (`eldrun/<name>` and the `--output` that puts a job's log where it outlives the workspace it ran in), `findProjectWorkspace` (**by recorded id first, then by path containment** — a plain `startsWith` would match `…-demo2` against `…-demo` and point Extend at the wrong allocation), `shouldWarnExpiry`, `moveProjectRoot` and `pullLogs`. Plus `scratchCandidates`/`freeSpaceLabel` for a cluster with **no** workspace tooling — the site's own `$SCRATCH`/`$WORK`/… offered as the project root, since otherwise such a project lands in `$HOME`, the failure the step exists to prevent. Site-agnostic throughout — the host is asked what it offers, and the only site strings anywhere in the feature are inside test fixtures. Tested in `src/__tests__/HpcWorkspace.test.ts`; untested against a real cluster. |
+| `lib/pythonRun.ts` | Run/Debug a Python file (#87) by opening a **terminal tab** — not a bespoke exec path. That is what makes it inherit remote-host and container locality for free (the *tab* carries both) and stay a real interactive terminal (`input()`, `Ctrl+C`, output survives exit). Debug is pdb pre-loaded with the gutter's breakpoints (`-c "b f:N" … -c continue`). **Which** Python it runs is asked of the backend (`python_interpreter_for`), never re-derived here: two interpreter rankings that can disagree is a bug waiting to happen, and only the backend can see conda/poetry at all. |
+| `lib/experimental.ts` | The experimental-flag gate: **off for everyone, on in debug mode** (unset ≠ false — it falls back to `settings.debug`, so a flag still moving is invisible to someone *using* Eldrun and present by default for someone *building* it). Read a flag via `useExperimental`, never `settings.<flag> ?? false` — that spelling is what makes a flag miss the debug default. Gates `agent_mode_toggle` and `python_run_debug`. |
+| `lib/tmuxSession.ts` | Persistent remote sessions (TODO #85), the frontend mint + decision helpers. `newTmuxSessionName()` mints the stable `eldrun-<uuid>` a shell tab persists as `TabEntry.tmuxSession` (minted once at creation — the tab's PTY id is *not* stable, `loadFromLayout` regenerates the key, so a derived name would fork a second session on relaunch instead of reattaching). `persistSessionsEnabled` encodes **default ON** (`persist_sessions !== false`); `shouldPersistTab` = a **shell** tab (Python runs open one) on a **remote host** of a persist-enabled project; `shouldPersistLocalTab` = a shell tab running **locally** (a local project, or a remote project's mirror tab) with `persist_local_sessions` on (Unix) — for surviving an Eldrun crash. Never agents, never root. The actual tmux wrap is the backend's; this only mints the name + picks *which* tabs get it. |
+| `lib/closeRemoteTab.ts` | The tab-close (detach) path for a persistent tab (TODO #85). Closing a tab is **non-destructive**: `closeTabWithConfirm` just `removeTab`s, which unmounts the pane and kills only the ssh/PTY *client*, so the tmux session lives on under its daemon and stays reattachable from the Sessions view — a quit/crash/respawn leave it alive. Disconnecting a remote machine instead ends that host's tmux sessions before dropping its pool. A session's **×** (kill) in the Sessions view (`remote_tmux_kill`/`local_tmux_kill`) ends just that session. `persistentSessionOf`/`localPersistentSessionOf` classify which session a tab owns (the Sessions view marks owned rows). Reads the tabs/projects/settings stores, so it lives here — `stores/projects` already imports `stores/tabs`, so a store-level import back would be a cycle. |
+| `lib/viewers/yaml.ts` | The YAML/JSON tree model + its edit ops, all pure. The tree is a **view on the text**: every edit is a surgical splice, never a re-serialization of the parsed model — the only way a config file's **comments** survive an edit, and what lets Tree and Source share one draft. **Both** YAML syntaxes are first-class: *block* (indentation) and *flow* (`{a: 1}` — i.e. **JSON**, inline or spread over lines). Which one a node is written in decides how it is edited (block → line splice, flow → span splice) and the tree keeps the author's choice, so `[a, b]` grows to `[a, b, c]` and is never quietly rewritten into block. `strict` (a `.json` file) is the only dialect knob: no plain scalars, so keys and strings are quoted. **Comments are a node's own, not scenery** — a `#` is the only place YAML documents a key, so each node reads the one behind its value *and* the run directly above it at its own indent, and `setComment` writes back wherever the author already wrote (a new one goes behind, which adds no line). The consequence is in the edits: a comment **travels with its node**, so deleting or reordering a key takes its description along rather than leaving it to re-attach itself to whichever key slid into that place. `moveNodeTo` is the one reorder op (the ↑/↓ buttons are `to = at ± 1`): a drag across five rows is **one** splice, not five swaps — every splice invalidates the offsets after it. A construct it could not rewrite without botching it (anchor, alias, merge key, plain scalar continued across lines) still *renders* but comes back `editable: false`; a line it can't classify at all fails the parse and defers to Source. |
+| `lib/viewers/yamlGrid.ts` | The YAML/JSON **card grid** helpers (#yaml-grid), all pure. `hasCards` is the toggle gate (true when a collection nests another); `isContainer`/`cellKind`/`nestedLabel` classify a node so the card view never offers a control it can't honour — every EDIT is still delegated back to `yaml.ts`'s splice ops (the view-on-text bargain: comments/quoting/untouched bytes survive). Also keeps the **tabular** model (`gridModelFor`/`gridCandidates`/`hasGrid`): the flat rows × columns view of a single list/map-of-records — the card view doesn't render it, but it stays a tested, reusable "is this region a table?" helper. Tested in `src/__tests__/YamlGrid.test.ts`. |
+| `lib/viewers/table.ts` | The CSV/TSV model + its edit ops, all pure. Two things it exists to say. **The separator is guessed, not known** — `.csv` never states which character separates the columns, so assuming comma from the extension is exactly what renders a `;`-delimited export as one tall column; `sniffDelimiter` scores each candidate by parsing a sample *with* it (a comma inside a quoted field cannot fool the `;` reading) and asking how rectangular the result is, rejecting any character that never splits a row however consistently it fails to appear. And **the table is a view on the text**: `parseTable` hands back each cell's source span, so `replaceCell`/`insertRowAfter`/`deleteRow` are surgical splices — the only way editing one cell leaves every other field's quoting, the file's line endings and its delimiter byte-for-byte alone. Same bargain `yaml.ts` strikes for comments. |
+| `lib/viewers/gif.ts` | The GIF decoder, all pure — takes a `Uint8Array`, never touches the fs (WebKitGTK has no `ImageDecoder` API, so frame control means decoding LZW + interlace + disposal 0–3 ourselves; GIF89a is frozen, so no maintenance tail). Two ideas: **every frame composites to a full-canvas RGBA buffer** (GIF has no keyframes — frame N is a patch on N−1's state, so upfront full frames are what make scrubbing O(1); memory is bounded by `maxPixelBytes`, beyond which the result says `truncated`), and **delays are stored as authored, played by convention** (`effectiveDelayMs`: <20ms means "browser default" = 100ms — files were authored against that clamp). Disposal 2 clears to *transparent*, not the spec's background color, because that is what every browser does. Corruption after ≥1 good frame returns the clean prefix + `truncated`; before it, throws. |
+| `lib/viewers/pageModel.ts` | **The** page-arrangement model (`PageRef{id,src,page,rot}` list) shared by the print preview and the PDF page rail: move/delete/rotate/duplicate/insert, all pure. |
+| `lib/usageRollup.ts` | Folds UTC day/hour buckets into today/week/month windows. Generic over the payload — shared by `NetworkTrafficPane` (bytes) and the recap (counters). |
+| `lib/gpu.ts` | The GPU-memory arithmetic shared by its three surfaces (header row, system monitor, local-model menu), pure; sampling is the backend's `gpustat`. The one idea: **GPU memory is the two pools summed** — the dedicated VRAM carve-out *and* the shared pool mapped from system RAM — because on an APU the carve-out is only the framebuffer (~86% full forever, meaningless) while a model actually lands in the shared half; on a discrete card the shared half is 0 and the sum is plain VRAM. Hence `gpuTone` tones by **ratio**: the old row's absolute 1 GB/2 GB thresholds suited a figure counting only Ollama's models and would peg a device-wide one at "hot" permanently. Also home to the **sensor** formatters (`formatTempC`/`formatWatts`/`formatMhz`/`formatFan`/`gpuLinkLabel`) and the `GpuProc` type: each formatter returns `null` for an unreported reading so the UI omits it rather than print a fake zero, and `gpuAdapterTooltip` appends only the sensors the driver actually gave. The system-monitor pane renders these as a per-adapter GPU card (VRAM + Util meters, sensor strip) plus a once-only per-process GPU-memory list (locally from `gpu_process_snapshot`; for a remote source, from the host-sampled `SystemSnapshot.gpu_procs` in the same poll). |
+| `lib/usageMetrics.ts` | The metric keys (mirrors `schema::usage_stats::metric`) + how a tab maps to an agent or a local model. |
+| `lib/promptCount.ts` | "Enter with content pending = one submit" — the prompt/command heuristic, fed from `TerminalView`'s `onData`. |
+| `lib/calendarTime.ts` | Calendar date math: local wall-clock stamps, exclusive ends, overlap layout. |
+| `lib/recurrence.ts` | Recurrence expansion (`expandEvents`) + exdate/override editing. |
+| `lib/ics.ts` | iCalendar parse/serialize (VEVENT/VTODO/VALARM/RRULE), folding + escaping. |
+| `lib/alarms.ts` | Pure alarm logic: which reminders are due, fire-once keys, snooze. |
+| `lib/calendarCategories.ts` | Event category → color palette. |
diff --git a/src/__tests__/AgentMode.test.ts b/src/__tests__/AgentMode.test.ts
new file mode 100644
index 0000000..b2b404f
--- /dev/null
+++ b/src/__tests__/AgentMode.test.ts
@@ -0,0 +1,232 @@
+/**
+ * Per-tab planner/doer mode (experimental `agent_mode_toggle`). The mode is a
+ * *launch flag*, so it lives in the tab's args and switching it respawns the PTY;
+ * the durable record is `TabEntry.agentMode`, because args are rebuilt from
+ * scratch on restore. These tests lock the capability gate, the idempotence of the
+ * arg rewrite (a stacked `--permission-mode` would be a broken launch), the
+ * initialInput retirement, and the save → project.json → load round-trip that makes
+ * the split survive a restart.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import { supportsAgentMode, withAgentMode } from "../components/tabs/agentModes";
+import { useTabsStore, type SavedLayoutTree } from "../stores/tabs";
+
+const invokeMock = vi.mocked(invoke);
+
+function resetStore() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+describe("agent-mode capability gate", () => {
+  it("admits Claude and Gemini — both have an absolute mode flag and a working resume", () => {
+    expect(supportsAgentMode("claude")).toBe(true);
+    // Gemini has --approval-mode (absolute) AND resumes (continue-last).
+    expect(supportsAgentMode("gemini")).toBe(true);
+    // Codex resumes, but has no plan mode (only a read-only sandbox).
+    expect(supportsAgentMode("codex")).toBe(false);
+    expect(supportsAgentMode("vibe")).toBe(false);
+    expect(supportsAgentMode("")).toBe(false);
+  });
+
+  it("leaves an unsupported agent's args strictly alone (same reference)", () => {
+    const args = ["--continue"];
+    expect(withAgentMode("codex", args, "plan")).toBe(args);
+  });
+});
+
+describe("withAgentMode", () => {
+  it("maps plan → plan and auto → acceptEdits (NOT bypassPermissions)", () => {
+    expect(withAgentMode("claude", [], "plan")).toEqual(["--permission-mode", "plan"]);
+    expect(withAgentMode("claude", [], "auto")).toEqual(["--permission-mode", "acceptEdits"]);
+  });
+
+  it("maps Gemini plan → plan and auto → auto_edit (NOT yolo)", () => {
+    expect(withAgentMode("gemini", [], "plan")).toEqual(["--approval-mode", "plan"]);
+    expect(withAgentMode("gemini", [], "auto")).toEqual(["--approval-mode", "auto_edit"]);
+    // "auto" must never reach the auto-approve-ALL level.
+    expect(withAgentMode("gemini", [], "auto")).not.toContain("yolo");
+  });
+
+  it("is idempotent for Gemini too, and re-applies onto its continue-last resume args", () => {
+    let args = withAgentMode("gemini", ["--resume", "latest"], "plan");
+    args = withAgentMode("gemini", args, "auto");
+    expect(args).toEqual(["--resume", "latest", "--approval-mode", "auto_edit"]);
+    expect(args.filter((a) => a === "--approval-mode")).toHaveLength(1);
+  });
+
+  it("is idempotent: repeated toggling never stacks the flag", () => {
+    let args = withAgentMode("claude", [], "plan");
+    args = withAgentMode("claude", args, "auto");
+    args = withAgentMode("claude", args, "plan");
+    expect(args).toEqual(["--permission-mode", "plan"]);
+    expect(args.filter((a) => a === "--permission-mode")).toHaveLength(1);
+  });
+
+  it("preserves sibling args — the session id must survive the rewrite", () => {
+    const args = withAgentMode("claude", ["--session-id", "uuid-1", "--remote-control"], "auto");
+    expect(args).toEqual([
+      "--session-id",
+      "uuid-1",
+      "--remote-control",
+      "--permission-mode",
+      "acceptEdits",
+    ]);
+  });
+
+  it("strips the old flag's VALUE too, not just the flag", () => {
+    // A naive filter would leave a bare "plan" behind, which Claude would read as
+    // a prompt argument.
+    const args = withAgentMode("claude", ["--permission-mode", "plan", "--resume", "id"], "auto");
+    expect(args).not.toContain("plan");
+    expect(args).toEqual(["--resume", "id", "--permission-mode", "acceptEdits"]);
+  });
+});
+
+describe("setAgentMode", () => {
+  beforeEach(resetStore);
+
+  it("records the mode and folds it into the launch args (which drives the respawn)", () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    const tab = store.addTab({
+      label: "Claude",
+      cmd: "claude",
+      cwd: "/p",
+      kind: "agent",
+      args: ["--session-id", "uuid-1"],
+    });
+
+    useTabsStore.getState().setAgentMode(tab.key, "plan");
+    const t = useTabsStore.getState().tabs.find((x) => x.key === tab.key);
+    expect(t?.agentMode).toBe("plan");
+    expect(t?.args).toEqual(["--session-id", "uuid-1", "--permission-mode", "plan"]);
+  });
+
+  it("retires initialInput, so the respawn can't re-type /rename into a resumed session", () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    const tab = store.addTab({
+      label: "Claude",
+      cmd: "claude",
+      cwd: "/p",
+      kind: "agent",
+      initialInput: "/rename proj",
+    });
+
+    useTabsStore.getState().setAgentMode(tab.key, "auto");
+    expect(
+      useTabsStore.getState().tabs.find((x) => x.key === tab.key)?.initialInput,
+    ).toBeUndefined();
+  });
+
+  it("no-ops (stable array) when unchanged, and for an agent with no mode support", () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    const claude = store.addTab({ label: "Claude", cmd: "claude", cwd: "/p", kind: "agent" });
+    const codex = useTabsStore
+      .getState()
+      .addTab({ label: "Codex", cmd: "codex", cwd: "/p", kind: "agent" });
+
+    useTabsStore.getState().setAgentMode(claude.key, "plan");
+    const before = useTabsStore.getState().tabs;
+    useTabsStore.getState().setAgentMode(claude.key, "plan");
+    expect(useTabsStore.getState().tabs).toBe(before);
+
+    // Codex has no mode mapping — the store must not record a mode it never passed.
+    useTabsStore.getState().setAgentMode(codex.key, "plan");
+    expect(useTabsStore.getState().tabs).toBe(before);
+    expect(
+      useTabsStore.getState().tabs.find((t) => t.key === codex.key)?.agentMode,
+    ).toBeUndefined();
+  });
+});
+
+describe("agentMode round-trips through save/load", () => {
+  beforeEach(() => {
+    invokeMock.mockClear();
+    resetStore();
+  });
+
+  it("persists agentMode in the saved tab layout", async () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    const tab = store.addTab({
+      label: "Claude",
+      cmd: "claude",
+      cwd: "/p",
+      kind: "agent",
+      sessionId: "uuid-1",
+      args: ["--session-id", "uuid-1"],
+    });
+    useTabsStore.getState().setAgentMode(tab.key, "plan");
+
+    await useTabsStore.getState().saveLayout("/p/project.json");
+
+    const call = invokeMock.mock.calls.find((c) => c[0] === "save_tab_layout");
+    expect(call).toBeTruthy();
+    const arg = call![1] as {
+      tabs: { label: string; agentMode?: string }[];
+      groups: SavedLayoutTree | null;
+    };
+    expect(arg.tabs.find((t) => t.label === "Claude")?.agentMode).toBe("plan");
+  });
+
+  it("restores the mode ONTO the rebuilt resume args", () => {
+    // The restore path rebuilds args from RESUMABLE_AGENTS, so the mode flag has to
+    // be re-applied on top of `--resume <id>` — otherwise the tab silently comes
+    // back in the agent's default mode and the planner/doer split is lost.
+    useTabsStore.getState().loadFromLayout(
+      [
+        {
+          key: "agent-9",
+          label: "Claude",
+          cmd: "claude",
+          cwd: "/p",
+          kind: "agent",
+          sessionId: "uuid-1",
+          agentMode: "plan",
+        },
+      ],
+      "/p",
+      "p",
+    );
+    const tabs = useTabsStore.getState().tabsByScope["p"];
+    expect(tabs).toHaveLength(1);
+    expect(tabs[0].agentMode).toBe("plan");
+    expect(tabs[0].args).toEqual(["--resume", "uuid-1", "--permission-mode", "plan"]);
+  });
+
+  it("a tab with no persisted mode restores exactly as before (no flag added)", () => {
+    useTabsStore.getState().loadFromLayout(
+      [
+        {
+          key: "agent-9",
+          label: "Claude",
+          cmd: "claude",
+          cwd: "/p",
+          kind: "agent",
+          sessionId: "uuid-1",
+        },
+      ],
+      "/p",
+      "p",
+    );
+    const tabs = useTabsStore.getState().tabsByScope["p"];
+    expect(tabs[0].args).toEqual(["--resume", "uuid-1"]);
+    expect(tabs[0].agentMode).toBeUndefined();
+  });
+});
diff --git a/src/__tests__/AgentModeBadge.test.tsx b/src/__tests__/AgentModeBadge.test.tsx
new file mode 100644
index 0000000..e7ccbe9
--- /dev/null
+++ b/src/__tests__/AgentModeBadge.test.tsx
@@ -0,0 +1,127 @@
+/**
+ * The planner/doer badge as the user actually meets it: rendered by the real
+ * TabBar, driven by real clicks. The unit tests in AgentMode.test.ts prove the arg
+ * rewrite; these prove the badge is *gated* correctly (experimental setting off →
+ * it does not exist; unsupported agent → it does not exist) and that clicking it
+ * flips the mode and rewrites the launch args — which is what respawns the PTY.
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { render, fireEvent, cleanup } from "@testing-library/react";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn().mockResolvedValue([]) }));
+
+import { TabBar } from "../components/tabs/TabBar";
+import { allGroups, useTabsStore } from "../stores/tabs";
+import { useDragStore } from "../stores/drag";
+import { useSettingsStore } from "../stores/settings";
+import { useActivityStore } from "../stores/activity";
+
+function reset(agentModeToggle: boolean) {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+  useDragStore.setState({ drag: null });
+  useSettingsStore.setState({ settings: { agent_mode_toggle: agentModeToggle }, loaded: true });
+  useActivityStore.setState({ busyByTab: {} });
+}
+
+/**
+ * Seed one agent tab and render its bar. `busy` marks the tab's PTY as mid-turn
+ * BEFORE the render — the bar reads the busy map during render, so setting it
+ * afterwards would leave the click handler closed over the stale (empty) map.
+ */
+function seedAgent(cmd: string, busy = false) {
+  useTabsStore.getState().addTab({
+    label: cmd,
+    cmd,
+    cwd: "/p",
+    kind: "agent",
+    args: ["--session-id", "uuid-1"],
+  });
+  const group = allGroups(useTabsStore.getState().layout)[0];
+  const key = group.tabKeys[0];
+  // Busy is keyed by the composed PTY id (`<scope>:<tabKey>`).
+  if (busy) useActivityStore.setState({ busyByTab: { [`p:${key}`]: true } });
+  const { container } = render(
+    <TabBar groupId={group.id} projectCwd="/p" showGroupClose={false} />,
+  );
+  return { container, key };
+}
+
+const tabOf = (key: string) => useTabsStore.getState().tabs.find((t) => t.key === key);
+
+afterEach(cleanup);
+
+describe("Plan/Auto badge gating", () => {
+  it("does not exist while the experimental setting is off", () => {
+    reset(false);
+    const { container } = seedAgent("claude");
+    expect(container.querySelector(".tab-agent-mode")).toBeNull();
+  });
+
+  it("does not exist on an agent that can't be mode-switched safely (Codex)", () => {
+    reset(true);
+    const { container } = seedAgent("codex");
+    expect(container.querySelector(".tab-agent-mode")).toBeNull();
+  });
+
+  it("shows on a Claude tab, starting in the agent's own default (unset)", () => {
+    reset(true);
+    const { container } = seedAgent("claude");
+    const badge = container.querySelector(".tab-agent-mode");
+    expect(badge).toBeTruthy();
+    expect(badge!.className).toContain("unset");
+  });
+});
+
+describe("clicking the badge", () => {
+  beforeEach(() => reset(true));
+
+  it("goes unset → Plan, folding the flag into the launch args", () => {
+    const { container, key } = seedAgent("claude");
+    fireEvent.click(container.querySelector(".tab-agent-mode")!);
+
+    expect(tabOf(key)?.agentMode).toBe("plan");
+    // The args are what TerminalView keys its spawn effect on — this rewrite IS
+    // the respawn.
+    expect(tabOf(key)?.args).toEqual(["--session-id", "uuid-1", "--permission-mode", "plan"]);
+    expect(container.querySelector(".tab-agent-mode")!.className).toContain("plan");
+  });
+
+  it("does not start a tab drag (the badge is self-contained)", () => {
+    const { container } = seedAgent("claude");
+    fireEvent.pointerDown(container.querySelector(".tab-agent-mode")!);
+    expect(useDragStore.getState().drag).toBeNull();
+  });
+
+  it("asks first when the agent is mid-turn, and leaves it alone if declined", () => {
+    const { container, key } = seedAgent("claude", true);
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(false);
+
+    fireEvent.click(container.querySelector(".tab-agent-mode")!);
+
+    // Declining must not restart the agent — the args (and so the PTY) stand.
+    expect(confirmSpy).toHaveBeenCalledOnce();
+    expect(tabOf(key)?.agentMode).toBeUndefined();
+    expect(tabOf(key)?.args).toEqual(["--session-id", "uuid-1"]);
+    confirmSpy.mockRestore();
+  });
+
+  it("switches a mid-turn agent when the restart is accepted", () => {
+    const { container, key } = seedAgent("claude", true);
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(true);
+
+    fireEvent.click(container.querySelector(".tab-agent-mode")!);
+
+    expect(tabOf(key)?.agentMode).toBe("plan");
+    expect(tabOf(key)?.args).toEqual(["--session-id", "uuid-1", "--permission-mode", "plan"]);
+    confirmSpy.mockRestore();
+  });
+});
diff --git a/src/__tests__/Alarms.test.ts b/src/__tests__/Alarms.test.ts
new file mode 100644
index 0000000..90c1b2d
--- /dev/null
+++ b/src/__tests__/Alarms.test.ts
@@ -0,0 +1,198 @@
+import { describe, expect, it } from "vitest";
+import {
+  alarmKey,
+  alarmTime,
+  alarmWindow,
+  describeLead,
+  dueAlarms,
+  snooze,
+  wokenSnoozes,
+} from "../lib/alarms";
+import type { Occurrence } from "../types";
+
+function occ(over: Partial<Occurrence> = {}): Occurrence {
+  return {
+    eventId: "e1",
+    occurrenceStart: "2026-07-08T09:00",
+    start: "2026-07-08T09:00",
+    end: "2026-07-08T10:00",
+    allDay: false,
+    title: "standup",
+    location: "",
+    notes: "",
+    category: "",
+    status: "confirmed",
+    calendarId: "default",
+    recurring: false,
+    alarms: [{ minutes_before: 15 }],
+    ...over,
+  };
+}
+
+/** A local Date at the given civil moment (the calendar is wall-clock). */
+const at = (y: number, mo: number, d: number, h: number, mi: number) =>
+  new Date(y, mo - 1, d, h, mi);
+
+describe("alarmTime", () => {
+  it("subtracts the offset from a timed start", () => {
+    expect(alarmTime(occ(), 15)).toBe("2026-07-08T08:45");
+    expect(alarmTime(occ(), 60)).toBe("2026-07-08T08:00");
+    expect(alarmTime(occ(), 1440)).toBe("2026-07-07T09:00");
+  });
+
+  it("anchors an all-day event's reminders to 09:00, not midnight", () => {
+    // A "1 day before" on a birthday should arrive the previous morning, not at
+    // 00:00 the previous night.
+    const birthday = occ({ start: "2026-07-08", end: "2026-07-09", allDay: true });
+    expect(alarmTime(birthday, 1440)).toBe("2026-07-07T09:00");
+    expect(alarmTime(birthday, 0)).toBe("2026-07-08T09:00");
+  });
+
+  it("handles a zero offset (at the time of the event)", () => {
+    expect(alarmTime(occ(), 0)).toBe("2026-07-08T09:00");
+  });
+});
+
+describe("dueAlarms", () => {
+  const none = new Set<string>();
+
+  it("does not fire before its time", () => {
+    // 08:44 — one minute early.
+    expect(dueAlarms([occ()], none, at(2026, 7, 8, 8, 44))).toHaveLength(0);
+  });
+
+  it("fires once its time arrives", () => {
+    const due = dueAlarms([occ()], none, at(2026, 7, 8, 8, 45));
+    expect(due).toHaveLength(1);
+    expect(due[0].title).toBe("standup");
+    expect(due[0].minutesBefore).toBe(15);
+  });
+
+  it("fires a reminder that came due while the app was closed", () => {
+    // The reminder was due at 08:45; the app only opened at 09:30.
+    expect(dueAlarms([occ()], none, at(2026, 7, 8, 9, 30))).toHaveLength(1);
+  });
+
+  it("does not fire a stale reminder from days ago", () => {
+    // Well past the grace window — showing this now would be noise.
+    expect(dueAlarms([occ()], none, at(2026, 7, 20, 9, 0))).toHaveLength(0);
+  });
+
+  it("respects a custom grace window", () => {
+    // 2h late, with a 1h grace → suppressed.
+    expect(dueAlarms([occ()], none, at(2026, 7, 8, 10, 45), 60)).toHaveLength(0);
+    // ...and with a 3h grace → shown.
+    expect(dueAlarms([occ()], none, at(2026, 7, 8, 10, 45), 180)).toHaveLength(1);
+  });
+
+  it("NEVER re-fires an alarm already fired", () => {
+    const fired = new Set([alarmKey("e1", "2026-07-08T09:00", 15)]);
+    expect(dueAlarms([occ()], fired, at(2026, 7, 8, 8, 45))).toHaveLength(0);
+  });
+
+  it("fires each of an event's several reminders independently", () => {
+    const e = occ({ alarms: [{ minutes_before: 15 }, { minutes_before: 1440 }] });
+    // The day-before reminder is due; the 15-minute one is not.
+    const early = dueAlarms([e], none, at(2026, 7, 7, 9, 0));
+    expect(early.map((a) => a.minutesBefore)).toEqual([1440]);
+
+    // By 08:45 on the day, only the 15-minute one is still unfired.
+    const fired = new Set([alarmKey("e1", "2026-07-08T09:00", 1440)]);
+    const late = dueAlarms([e], fired, at(2026, 7, 8, 8, 45));
+    expect(late.map((a) => a.minutesBefore)).toEqual([15]);
+  });
+
+  it("keys each occurrence of a series separately", () => {
+    // Two occurrences of the same recurring event; dismissing Wednesday's must not
+    // dismiss Thursday's.
+    const wed = occ({ occurrenceStart: "2026-07-08T09:00", start: "2026-07-08T09:00", recurring: true });
+    const thu = occ({ occurrenceStart: "2026-07-09T09:00", start: "2026-07-09T09:00", recurring: true });
+    const fired = new Set([alarmKey("e1", "2026-07-08T09:00", 15)]);
+
+    const due = dueAlarms([wed, thu], fired, at(2026, 7, 9, 8, 45));
+    expect(due).toHaveLength(1);
+    expect(due[0].occurrenceStart).toBe("2026-07-09T09:00");
+  });
+
+  it("ignores occurrences with no reminders", () => {
+    expect(dueAlarms([occ({ alarms: [] })], none, at(2026, 7, 8, 9, 0))).toHaveLength(0);
+  });
+
+  it("sorts the most imminent first", () => {
+    const a = occ({ eventId: "a", start: "2026-07-08T14:00", occurrenceStart: "2026-07-08T14:00" });
+    const b = occ({ eventId: "b", start: "2026-07-08T10:00", occurrenceStart: "2026-07-08T10:00" });
+    const due = dueAlarms([a, b], none, at(2026, 7, 8, 13, 50));
+    expect(due.map((x) => x.eventId)).toEqual(["b", "a"]);
+  });
+});
+
+describe("alarmKey", () => {
+  it("distinguishes event, occurrence and offset", () => {
+    expect(alarmKey("e1", "2026-07-08T09:00", 15)).not.toBe(alarmKey("e2", "2026-07-08T09:00", 15));
+    expect(alarmKey("e1", "2026-07-08T09:00", 15)).not.toBe(alarmKey("e1", "2026-07-09T09:00", 15));
+    expect(alarmKey("e1", "2026-07-08T09:00", 15)).not.toBe(alarmKey("e1", "2026-07-08T09:00", 30));
+  });
+
+  it("is stable for the same alarm", () => {
+    expect(alarmKey("e1", "2026-07-08T09:00", 15)).toBe(alarmKey("e1", "2026-07-08T09:00", 15));
+  });
+});
+
+describe("alarmWindow", () => {
+  it("reaches back a day, to catch a reminder missed while closed", () => {
+    const w = alarmWindow([{ alarms: [{ minutes_before: 15 }] }], at(2026, 7, 8, 12, 0));
+    expect(w.start).toBe("2026-07-07");
+  });
+
+  it("reaches forward far enough to see the longest lead time", () => {
+    // A "1 day before" reminder needs tomorrow's events in view.
+    const w = alarmWindow([{ alarms: [{ minutes_before: 1440 }] }], at(2026, 7, 8, 12, 0));
+    expect(w.end >= "2026-07-11").toBe(true);
+  });
+
+  it("copes with no reminders at all", () => {
+    const w = alarmWindow([], at(2026, 7, 8, 12, 0));
+    expect(w.start).toBe("2026-07-07");
+    expect(w.end > w.start).toBe(true);
+  });
+});
+
+describe("snooze", () => {
+  it("comes back after the snooze period", () => {
+    const alarm = dueAlarms([occ()], new Set(), at(2026, 7, 8, 8, 45))[0];
+    const s = snooze(alarm, 5, at(2026, 7, 8, 8, 45));
+    expect(s.at).toBe("2026-07-08T08:50");
+
+    // Not yet.
+    expect(wokenSnoozes([s], at(2026, 7, 8, 8, 49))).toHaveLength(0);
+    // Now.
+    expect(wokenSnoozes([s], at(2026, 7, 8, 8, 50))).toHaveLength(1);
+  });
+
+  it("carries the alarm through, so it can be re-shown", () => {
+    const alarm = dueAlarms([occ()], new Set(), at(2026, 7, 8, 8, 45))[0];
+    const s = snooze(alarm, 5, at(2026, 7, 8, 8, 45));
+    expect(wokenSnoozes([s], at(2026, 7, 8, 9, 0))[0].alarm.title).toBe("standup");
+  });
+
+  it("snoozing to tomorrow rolls the date", () => {
+    const alarm = dueAlarms([occ()], new Set(), at(2026, 7, 8, 8, 45))[0];
+    const s = snooze(alarm, 24 * 60, at(2026, 7, 8, 23, 30));
+    expect(s.at).toBe("2026-07-09T23:30");
+  });
+});
+
+describe("describeLead", () => {
+  it("describes the common offsets", () => {
+    expect(describeLead(0)).toBe("now");
+    expect(describeLead(1)).toBe("in 1 minute");
+    expect(describeLead(15)).toBe("in 15 minutes");
+    expect(describeLead(60)).toBe("in 1 hour");
+    expect(describeLead(120)).toBe("in 2 hours");
+    expect(describeLead(1440)).toBe("in 1 day");
+  });
+
+  it("describes an offset AFTER the start", () => {
+    expect(describeLead(-15)).toBe("15 minutes ago");
+  });
+});
diff --git a/src/__tests__/AppShellClose.test.tsx b/src/__tests__/AppShellClose.test.tsx
index 00ce4ed..1fab1a0 100644
--- a/src/__tests__/AppShellClose.test.tsx
+++ b/src/__tests__/AppShellClose.test.tsx
@@ -25,33 +25,55 @@ vi.mock("@tauri-apps/api/window", () => ({
     // AppShell installs a WebKitGTK onResized→DOM-resize bridge; the mock must
     // provide it (returns an unlisten) or the effect throws at mount.
     onResized: vi.fn().mockResolvedValue(() => {}),
+    onScaleChanged: vi.fn().mockResolvedValue(() => {}),
   }),
 }));
 
 vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn().mockResolvedValue(null) }));
 vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn().mockResolvedValue(() => {}) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ message: vi.fn().mockResolvedValue(undefined) }));
 
 // Paths below are relative to this test file (src/__tests__/), matching the
 // resolved module IDs that AppShell uses (src/stores/ and src/components/layout/).
-vi.mock("../stores/projects", () => ({
-  useProjectsStore: vi.fn((sel: (s: object) => unknown) =>
-    sel({
-      load: vi.fn(),
-      loaded: true,
-      activeId: null,
-      switchToast: null,
-      clearSwitchToast: vi.fn(),
-      projects: [],
-    }),
-  ),
-  // AppShell subscribes to runtime-switch events on mount; provide a no-op.
-  listenProjectRuntimeSwitched: vi.fn().mockResolvedValue(() => {}),
-}));
-vi.mock("../stores/settings", () => ({
-  useSettingsStore: vi.fn((sel: (s: object) => unknown) =>
-    sel({ load: vi.fn() }),
-  ),
-}));
+vi.mock("../stores/projects", () => {
+  const state = {
+    load: vi.fn(),
+    loaded: true,
+    activeId: null,
+    switchToast: null,
+    clearSwitchToast: vi.fn(),
+    projects: [],
+  };
+  return {
+    // The close handler reads the store imperatively (getState) to flush the
+    // active scope's tab layout, so the mock must carry it alongside the hook.
+    useProjectsStore: Object.assign(
+      vi.fn((sel: (s: object) => unknown) => sel(state)),
+      { getState: () => state },
+    ),
+    // AppShell subscribes to runtime-switch events on mount; provide a no-op.
+    listenProjectRuntimeSwitched: vi.fn().mockResolvedValue(() => {}),
+  };
+});
+vi.mock("../stores/settings", () => {
+  // The auto-reconnect sweep reads settings imperatively (getState) to skip
+  // HPC-tagged machines, so the mock must carry getState alongside the hook.
+  // It also awaits whenSettingsLoaded before the machine sweep; the mock store
+  // never loads, so resolve that immediately and let the `machines_enabled`
+  // gate stop the sweep — an unmocked export throws out of an unawaited
+  // promise, i.e. an unhandled error this test can neither see nor catch.
+  // `loaded` stays false on purpose: the other launch-time hosts (the stats
+  // recap) gate on it, and flipping it would run them against this same
+  // deliberately-minimal mock.
+  const state = { load: vi.fn(), settings: null, loaded: false };
+  return {
+    useSettingsStore: Object.assign(
+      vi.fn((sel: (s: object) => unknown) => sel(state)),
+      { getState: () => state },
+    ),
+    whenSettingsLoaded: () => Promise.resolve(),
+  };
+});
 // AppShell loads boxes once projects are loaded; provide a no-op so the effect
 // doesn't reach into the (mocked) projects store's setState.
 vi.mock("../stores/boxes", () => ({
@@ -75,12 +97,16 @@ vi.mock("../components/layout/GlobalAppBar", () => ({ GlobalAppBar: () => null }
 vi.mock("../hooks/useKeyboard", () => ({ useKeyboard: vi.fn() }));
 
 import { AppShell } from "../components/layout/AppShell";
+import { invoke } from "@tauri-apps/api/core";
+import { message } from "@tauri-apps/plugin-dialog";
 
 describe("AppShell close handler", () => {
   beforeEach(() => {
     shared.flush.mockClear();
     shared.destroy.mockClear();
     shared.handler = null;
+    (invoke as ReturnType<typeof vi.fn>).mockReset().mockResolvedValue(null);
+    (message as ReturnType<typeof vi.fn>).mockClear();
   });
 
   it("prevents default, flushes timer, then destroys the window", async () => {
@@ -111,4 +137,25 @@ describe("AppShell close handler", () => {
 
     expect(shared.destroy).toHaveBeenCalledOnce();
   });
+
+  it("warns but still destroys the window when the VPN teardown is declined", async () => {
+    // A dismissed pkexec prompt makes `openvpn_disconnect_all_on_quit` reject —
+    // the quit must warn, not abort (the backend already recorded the decline so
+    // RunEvent::Exit won't re-prompt with the window gone).
+    (invoke as ReturnType<typeof vi.fn>).mockImplementation((cmd: string) =>
+      cmd === "openvpn_disconnect_all_on_quit"
+        ? Promise.reject(new Error("openvpn teardown was not authorized"))
+        : Promise.resolve(null),
+    );
+
+    render(<AppShell />);
+    expect(shared.handler).not.toBeNull();
+
+    await act(async () => {
+      await shared.handler!({ preventDefault: vi.fn() });
+    });
+
+    expect(message).toHaveBeenCalledOnce();
+    expect(shared.destroy).toHaveBeenCalledOnce();
+  });
 });
diff --git a/src/__tests__/AutoReload.test.tsx b/src/__tests__/AutoReload.test.tsx
index 9c22c9f..dc68b3a 100644
--- a/src/__tests__/AutoReload.test.tsx
+++ b/src/__tests__/AutoReload.test.tsx
@@ -63,7 +63,7 @@ describe("diff-aware auto-reload (#43)", () => {
     // Let the poll fire and the re-read resolve.
     await waitFor(
       () => expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(V2),
-      { timeout: 4000 },
+      { timeout: 12000 },
     );
     // No reconcile banner for a clean reload.
     expect(screen.queryByRole("alert")).toBeNull();
@@ -84,7 +84,7 @@ describe("diff-aware auto-reload (#43)", () => {
     diskMtime = 2000;
 
     // A banner appears; the dirty buffer is preserved (not overwritten).
-    await waitFor(() => expect(screen.getByRole("alert")).toBeTruthy(), { timeout: 4000 });
+    await waitFor(() => expect(screen.getByRole("alert")).toBeTruthy(), { timeout: 12000 });
     expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe("my unsaved work");
     expect(screen.getByRole("button", { name: /reload/i })).toBeTruthy();
     expect(screen.getByRole("button", { name: /keep mine/i })).toBeTruthy();
diff --git a/src/__tests__/Autocomplete.test.tsx b/src/__tests__/Autocomplete.test.tsx
index e03e218..212260c 100644
--- a/src/__tests__/Autocomplete.test.tsx
+++ b/src/__tests__/Autocomplete.test.tsx
@@ -3,6 +3,10 @@
  *  - Ctrl+Space requests a completion ONLY when the per-type setting is on, after
  *    ensure_ollama_running; the suggestion renders as ghost text and Tab accepts.
  *  - When the setting is OFF, Ctrl+Space never calls out (privacy gate).
+ *  - Partial accept: → (Right) inserts only the next word and keeps the rest
+ *    ghosted; a later plain Tab finishes it.
+ *  - Completion-length modes: requests carry the active `mode`, and Shift+Tab
+ *    toggles it (sentence → block → scope) then re-requests.
  */
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { render, screen, act, waitFor, fireEvent } from "@testing-library/react";
@@ -12,6 +16,29 @@ vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
 vi.mock("../stores/windows", () => ({
   useWindowsStore: { getState: () => ({ openFile: () => Promise.resolve() }) },
 }));
+// The file at /p/foo.py belongs to a project rooted at /p, so the context-file
+// picker (#45) lists that project's files.
+vi.mock("../stores/projects", () => {
+  const state = {
+    projects: [
+      { id: "proj", directory: "/p", local_file: "/p/project.json" },
+      {
+        id: "win",
+        directory: "C:\\Work\\Demo",
+        local_file: "C:\\Work\\Demo\\project.json",
+      },
+    ],
+    activeId: "proj",
+  };
+  // Callable like a real zustand hook (selector) AND exposes getState(), since
+  // FileViewerPane reads it both ways (subscribes for the disconnected gate,
+  // reads getState() in handlers).
+  const useProjectsStore = Object.assign(
+    (sel?: (s: typeof state) => unknown) => (sel ? sel(state) : state),
+    { getState: () => state },
+  );
+  return { useProjectsStore };
+});
 
 const SOURCE = "def foo():\n    ";
 
@@ -31,17 +58,22 @@ function setup() {
   mockInvoke.mockImplementation((cmd: string) => {
     if (cmd === "read_file_text") return Promise.resolve(SOURCE);
     if (cmd === "file_mtime") return Promise.resolve(1000);
+    if (cmd === "list_project_paths")
+      return Promise.resolve([{ path: "helper.py", is_dir: false }]);
     if (cmd === "ensure_ollama_running") return Promise.resolve(null);
+    // Completion runs against whichever model is currently loaded in memory.
+    if (cmd === "list_ollama_models_detailed")
+      return Promise.resolve([{ name: "llama3.2:3b", running: true }]);
     if (cmd === "complete_text") return Promise.resolve("return 42");
     return Promise.resolve(null);
   });
 }
 
-async function renderTextView() {
+async function renderTextView(path = "/p/foo.py") {
   vi.resetModules();
   const { FileViewerPane } = await import("../components/embed/FileViewerPane");
   await act(async () => {
-    render(<FileViewerPane viewer="text" path="/p/foo.py" projectId="proj" />);
+    render(<FileViewerPane viewer="text" path={path} projectId="proj" />);
   });
 }
 
@@ -59,7 +91,7 @@ describe("local autocomplete (#45)", () => {
     await act(async () => {
       fireEvent.keyDown(textarea, { key: " ", ctrlKey: true });
     });
-    expect(mockInvoke).not.toHaveBeenCalledWith("ensure_ollama_running");
+    expect(mockInvoke).not.toHaveBeenCalledWith("list_ollama_models_detailed");
     expect(mockInvoke).not.toHaveBeenCalledWith("complete_text", expect.anything());
   });
 
@@ -75,8 +107,9 @@ describe("local autocomplete (#45)", () => {
       fireEvent.keyDown(textarea, { key: " ", ctrlKey: true });
     });
 
-    // It ensures Ollama is up first (privacy/local-only), then completes.
-    await waitFor(() => expect(mockInvoke).toHaveBeenCalledWith("ensure_ollama_running"));
+    // It resolves the currently-loaded local model first (local-only), then
+    // completes against it.
+    await waitFor(() => expect(mockInvoke).toHaveBeenCalledWith("list_ollama_models_detailed"));
     await waitFor(() =>
       expect(mockInvoke).toHaveBeenCalledWith(
         "complete_text",
@@ -94,4 +127,127 @@ describe("local autocomplete (#45)", () => {
       expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE + "return 42"),
     );
   });
+
+  it("→ (Right) accepts only the next word, keeping the rest ghosted; Tab finishes it", async () => {
+    autocompleteOn = true;
+    await renderTextView();
+    const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
+    await waitFor(() => expect(textarea.value).toBe(SOURCE));
+    textarea.selectionStart = textarea.selectionEnd = SOURCE.length;
+
+    await act(async () => {
+      fireEvent.keyDown(textarea, { key: " ", ctrlKey: true });
+    });
+    // Suggestion is the two-word "return 42".
+    await waitFor(() => expect(screen.getByText("return 42")).toBeTruthy());
+
+    // Right inserts just "return", leaving " 42" ghosted.
+    await act(async () => {
+      fireEvent.keyDown(textarea, { key: "ArrowRight" });
+    });
+    await waitFor(() =>
+      expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE + "return"),
+    );
+    await waitFor(() => expect(screen.getByText("42")).toBeTruthy());
+
+    // Plain Tab now accepts the remaining " 42".
+    await act(async () => {
+      fireEvent.keyDown(textarea, { key: "Tab" });
+    });
+    await waitFor(() =>
+      expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE + "return 42"),
+    );
+  });
+
+  it("Shift+Tab toggles to Block mode and re-requests in it", async () => {
+    autocompleteOn = true;
+    await renderTextView();
+    const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
+    await waitFor(() => expect(textarea.value).toBe(SOURCE));
+    textarea.selectionStart = textarea.selectionEnd = SOURCE.length;
+
+    // First request defaults to "sentence" mode; its suggestion must be showing
+    // for Shift+Tab to toggle (vs. its normal outdent role).
+    await act(async () => {
+      fireEvent.keyDown(textarea, { key: " ", ctrlKey: true });
+    });
+    await waitFor(() =>
+      expect(mockInvoke).toHaveBeenCalledWith("complete_text", expect.objectContaining({ mode: "sentence" })),
+    );
+    await waitFor(() => expect(screen.getByText("return 42")).toBeTruthy());
+
+    // Shift+Tab advances sentence → block and re-requests.
+    await act(async () => {
+      fireEvent.keyDown(textarea, { key: "Tab", shiftKey: true });
+    });
+    await waitFor(() =>
+      expect(mockInvoke).toHaveBeenCalledWith("complete_text", expect.objectContaining({ mode: "block" })),
+    );
+  });
+
+  it("attaches a project file as context and forwards it to complete_text (#45)", async () => {
+    autocompleteOn = true;
+    await renderTextView();
+    const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
+    await waitFor(() => expect(textarea.value).toBe(SOURCE));
+    textarea.selectionStart = textarea.selectionEnd = SOURCE.length;
+
+    // Open the context-file picker and pick the project's helper file.
+    await act(async () => {
+      fireEvent.click(screen.getByTitle("Add a project file as autocomplete context"));
+    });
+    const row = await screen.findByText("helper.py");
+    await act(async () => {
+      fireEvent.mouseDown(row);
+    });
+    // The chip for the attached file shows in the context bar.
+    await waitFor(() => expect(screen.getByTitle("helper.py")).toBeTruthy());
+
+    // Requesting a completion now carries the attached file as context.
+    await act(async () => {
+      fireEvent.keyDown(textarea, { key: " ", ctrlKey: true });
+    });
+    await waitFor(() =>
+      expect(mockInvoke).toHaveBeenCalledWith(
+        "complete_text",
+        expect.objectContaining({
+          context: [{ name: "helper.py", content: SOURCE }],
+        }),
+      ),
+    );
+  });
+
+  it("selects a Windows project with mixed separators and casing", async () => {
+    autocompleteOn = true;
+    await renderTextView("c:/work/demo/src/foo.py");
+    await act(async () => {
+      fireEvent.click(screen.getByTitle("Add a project file as autocomplete context"));
+    });
+    await waitFor(() =>
+      expect(mockInvoke).toHaveBeenCalledWith("list_project_paths", {
+        projectDir: "C:\\Work\\Demo",
+      }),
+    );
+  });
+
+  it("auto-suggests after an idle pause once typing (no Ctrl+Space needed)", async () => {
+    autocompleteOn = true;
+    await renderTextView();
+    const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
+    await waitFor(() => expect(textarea.value).toBe(SOURCE));
+
+    // Focus + type a char: the focused editor auto-requests after the debounce.
+    textarea.focus();
+    const typed = SOURCE + "r";
+    await act(async () => {
+      fireEvent.change(textarea, { target: { value: typed } });
+    });
+    textarea.selectionStart = textarea.selectionEnd = typed.length;
+
+    await waitFor(
+      () => expect(mockInvoke).toHaveBeenCalledWith("complete_text", expect.anything()),
+      { timeout: 2000 },
+    );
+    await waitFor(() => expect(screen.getByText("return 42")).toBeTruthy());
+  });
 });
diff --git a/src/__tests__/BoxRendering.test.tsx b/src/__tests__/BoxRendering.test.tsx
index 8671d0d..e7c0744 100644
--- a/src/__tests__/BoxRendering.test.tsx
+++ b/src/__tests__/BoxRendering.test.tsx
@@ -5,6 +5,11 @@
  * Clicking the pill opens the box; clicking a member switches to that project;
  * dropping a pill on the box assigns it (and does NOT reorder, S3). An orphaned
  * box_id (no matching box) renders the pill inline (S1).
+ *
+ * The pill drag is pointer-driven (see ProjectPill's `startPillDrag`), not
+ * native HTML5 DnD — jsdom gives every element a zero-sized rect, so the drag's
+ * hit-testing is driven by stubbing `getBoundingClientRect`, the same approach
+ * `PageStrip.test.tsx`/`DragDropSplit.test.tsx` take for their pointer drags.
  */
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { render, act, fireEvent } from "@testing-library/react";
@@ -16,6 +21,7 @@ vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn().mockResolvedValue(nu
 import { ProjectSwitcher } from "../components/layout/ProjectSwitcher";
 import { useProjectsStore } from "../stores/projects";
 import { useBoxesStore } from "../stores/boxes";
+import { usePillDragStore } from "../stores/pillDrag";
 
 function proj(id: string, position: number, boxId?: string): ProjectEntry {
   return {
@@ -32,19 +38,49 @@ function box(id: string, members: string[], position = 5): ProjectBox {
   return { id, name: id, member_ids: members, position };
 }
 
-function dt(projectId: string) {
-  const data: Record<string, string> = { "application/x-eldrun-project": projectId };
-  return {
-    types: ["application/x-eldrun-project"],
-    getData: (t: string) => data[t] ?? "",
-    setData: (t: string, v: string) => {
-      data[t] = v;
-    },
-    dropEffect: "none",
-  };
+/** Give an element a fixed layout rect, since jsdom's is always zero-sized. */
+function layOut(
+  el: HTMLElement,
+  r: { left: number; right: number; top: number; bottom: number },
+) {
+  vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+    left: r.left,
+    right: r.right,
+    top: r.top,
+    bottom: r.bottom,
+    width: r.right - r.left,
+    height: r.bottom - r.top,
+    x: r.left,
+    y: r.top,
+    toJSON: () => ({}),
+  } as DOMRect);
+}
+
+/** Dispatch a pointer event the way the existing drag tests do (`PageStrip`,
+ *  `DragDropSplit`): jsdom's PointerEvent doesn't carry the fields the pointer
+ *  gesture reads, so a plain Event is decorated with them. */
+function pointer(
+  type: string,
+  x: number,
+  y: number,
+  target: EventTarget,
+  opts: { altKey?: boolean } = {},
+) {
+  const ev = new Event(type, { bubbles: true, cancelable: true });
+  Object.assign(ev, { clientX: x, clientY: y, button: 0, pointerId: 1, altKey: !!opts.altKey });
+  act(() => {
+    target.dispatchEvent(ev);
+  });
+}
+
+function findPill(container: HTMLElement, name: string): HTMLElement {
+  return [...container.querySelectorAll(".project-pill:not(.is-box)")].find(
+    (el) => el.querySelector(".project-pill-label")?.textContent === name,
+  ) as HTMLElement;
 }
 
 beforeEach(() => {
+  usePillDragStore.getState().end();
   useProjectsStore.setState({ projects: [], activeId: null, loaded: true });
   useBoxesStore.setState({ boxes: [], loaded: true });
 });
@@ -177,11 +213,14 @@ describe("box pill rendering", () => {
 
     const container = await renderSwitcher();
     const boxPill = container.querySelector(".project-pill.is-box") as HTMLElement;
-    const dataTransfer = dt("p2");
+    const p2Pill = findPill(container, "p2");
+    layOut(p2Pill, { left: 0, right: 50, top: 0, bottom: 40 });
+    layOut(boxPill, { left: 100, right: 160, top: 0, bottom: 40 });
 
     await act(async () => {
-      fireEvent.dragOver(boxPill, { dataTransfer });
-      fireEvent.drop(boxPill, { dataTransfer });
+      pointer("pointerdown", 10, 10, p2Pill);
+      pointer("pointermove", 130, 10, window);
+      pointer("pointerup", 130, 10, window);
     });
 
     expect(assignToBox).toHaveBeenCalledWith("p2", "boxA");
@@ -202,16 +241,15 @@ describe("box pill rendering", () => {
     });
 
     const container = await renderSwitcher();
-    const p2Pill = [...container.querySelectorAll(".project-pill")].find(
-      (el) => el.querySelector(".project-pill-label")?.textContent === "p2",
-    ) as HTMLElement;
-    expect(p2Pill).toBeTruthy();
+    const p1Pill = findPill(container, "p1");
+    const p2Pill = findPill(container, "p2");
+    layOut(p1Pill, { left: 0, right: 50, top: 0, bottom: 40 });
+    layOut(p2Pill, { left: 100, right: 150, top: 0, bottom: 40 });
 
     await act(async () => {
-      const event = new Event("drop", { bubbles: true, cancelable: true });
-      Object.defineProperty(event, "dataTransfer", { value: dt("p1") });
-      Object.defineProperty(event, "altKey", { value: true });
-      fireEvent(p2Pill, event);
+      pointer("pointerdown", 10, 10, p1Pill);
+      pointer("pointermove", 120, 10, window, { altKey: true });
+      pointer("pointerup", 120, 10, window, { altKey: true });
     });
 
     expect(createBox).toHaveBeenCalledWith("New Box");
@@ -232,35 +270,55 @@ describe("box pill rendering", () => {
     });
 
     const container = await renderSwitcher();
-    const p2Pill = [...container.querySelectorAll(".project-pill")].find(
-      (el) => el.querySelector(".project-pill-label")?.textContent === "p2",
-    ) as HTMLElement;
+    const p1Pill = findPill(container, "p1");
+    const p2Pill = findPill(container, "p2");
+    layOut(p1Pill, { left: 0, right: 50, top: 0, bottom: 40 });
+    layOut(p2Pill, { left: 100, right: 150, top: 0, bottom: 40 });
 
     await act(async () => {
-      fireEvent.drop(p2Pill, { dataTransfer: dt("p1") });
+      pointer("pointerdown", 10, 10, p1Pill);
+      // Past p2's midpoint (125): with only these two pills, p1 landing
+      // "after" p2 is the only real move available (it's already right
+      // before p2), so the cursor must clear the midpoint to signal it.
+      pointer("pointermove", 140, 10, window);
+      pointer("pointerup", 140, 10, window);
     });
 
     expect(reorderProjects).toHaveBeenCalledWith("p1", "p2");
     expect(createBox).not.toHaveBeenCalled();
   });
 
-  it("dropping a pill on the ungrouped strip calls assignToBox(id, null)", async () => {
-    const assignToBox = vi.fn().mockResolvedValue(undefined);
-    useBoxesStore.setState({ boxes: [box("boxA", ["p1"])], assignToBox });
+  it("dropping into the gap between two OTHER pills lands there, not one further right", async () => {
+    // Regression: landing "before OTHERS[k]" by targeting OTHERS[k] directly
+    // is only correct when OTHERS[k] sat to the LEFT of the dragged pill's
+    // start position; when it sat to the right, `onReorder` lands the pill
+    // AFTER that target, one slot further than intended — the reported bug.
+    const reorderProjects = vi.fn().mockResolvedValue(undefined);
+    useBoxesStore.setState({ boxes: [] });
     useProjectsStore.setState({
-      projects: [proj("p1", 10, "boxA"), proj("p2", 20)],
+      projects: [proj("p1", 10), proj("p2", 20), proj("p3", 30)],
       activeId: null,
       loaded: true,
+      reorderProjects,
     });
 
     const container = await renderSwitcher();
-    const strip = container.querySelector(".project-pills-scroll") as HTMLElement;
+    const p1Pill = findPill(container, "p1");
+    const p2Pill = findPill(container, "p2");
+    const p3Pill = findPill(container, "p3");
+    layOut(p1Pill, { left: 0, right: 50, top: 0, bottom: 40 });
+    layOut(p2Pill, { left: 100, right: 150, top: 0, bottom: 40 });
+    layOut(p3Pill, { left: 200, right: 250, top: 0, bottom: 40 });
 
     await act(async () => {
-      fireEvent.dragOver(strip, { dataTransfer: dt("p1") });
-      fireEvent.drop(strip, { dataTransfer: dt("p1") });
+      pointer("pointerdown", 10, 10, p1Pill);
+      // Past p2's midpoint (125) but well before p3's (225) — the gap
+      // between p2 and p3, not "onto" either.
+      pointer("pointermove", 180, 10, window);
+      pointer("pointerup", 180, 10, window);
     });
 
-    expect(assignToBox).toHaveBeenCalledWith("p1", null);
+    // p1 lands between p2 and p3 — i.e. immediately AFTER p2 — not after p3.
+    expect(reorderProjects).toHaveBeenCalledWith("p1", "p2");
   });
 });
diff --git a/src/__tests__/CalendarTime.test.ts b/src/__tests__/CalendarTime.test.ts
new file mode 100644
index 0000000..c7c6a02
--- /dev/null
+++ b/src/__tests__/CalendarTime.test.ts
@@ -0,0 +1,427 @@
+import { describe, expect, it } from "vitest";
+import {
+  addDays,
+  addMinutes,
+  addMonths,
+  addYears,
+  allDayEndToLastDay,
+  dateRange,
+  lastDayToAllDayEnd,
+  daysBetween,
+  daySlice,
+  formatTime,
+  isMultiDay,
+  layoutOverlaps,
+  minutesBetween,
+  minutesIntoDay,
+  monthGrid,
+  normalizeSpan,
+  parseStamp,
+  spanCoversDate,
+  spanDates,
+  startOfWeek,
+  weekdayOf,
+  weekDates,
+  MINUTES_PER_DAY,
+} from "../lib/calendarTime";
+
+describe("parseStamp", () => {
+  it("parses a bare date as date-only", () => {
+    expect(parseStamp("2026-07-08")).toEqual({
+      year: 2026, month: 7, day: 8, hour: 0, minute: 0, dateOnly: true,
+    });
+  });
+
+  it("parses a timed stamp", () => {
+    expect(parseStamp("2026-07-08T09:30")).toEqual({
+      year: 2026, month: 7, day: 8, hour: 9, minute: 30, dateOnly: false,
+    });
+  });
+
+  it("rejects garbage and impossible dates", () => {
+    expect(parseStamp("nope")).toBeNull();
+    expect(parseStamp("2026-13-01")).toBeNull();
+    expect(parseStamp("2026-02-30")).toBeNull();
+    expect(parseStamp("2026-07-08T25:00")).toBeNull();
+  });
+
+  it("accepts Feb 29 only in a leap year", () => {
+    expect(parseStamp("2024-02-29")).not.toBeNull();
+    expect(parseStamp("2026-02-29")).toBeNull();
+  });
+});
+
+describe("addDays", () => {
+  it("rolls month and year boundaries", () => {
+    expect(addDays("2026-07-31", 1)).toBe("2026-08-01");
+    expect(addDays("2026-12-31", 1)).toBe("2027-01-01");
+    expect(addDays("2026-01-01", -1)).toBe("2025-12-31");
+  });
+
+  it("handles leap February", () => {
+    expect(addDays("2024-02-28", 1)).toBe("2024-02-29");
+    expect(addDays("2026-02-28", 1)).toBe("2026-03-01");
+  });
+
+  it("preserves the time part of a timed stamp", () => {
+    expect(addDays("2026-07-08T09:30", 1)).toBe("2026-07-09T09:30");
+  });
+
+  it("keeps a bare date bare", () => {
+    expect(addDays("2026-07-08", 1)).toBe("2026-07-09");
+  });
+
+  it("survives a DST spring-forward boundary", () => {
+    // In most northern-hemisphere zones the clocks jump in late March. Stepping a
+    // day across it must still advance exactly one calendar day (the noon anchor).
+    expect(addDays("2026-03-28", 1)).toBe("2026-03-29");
+    expect(addDays("2026-03-29", 1)).toBe("2026-03-30");
+    // ...and in the US zones, mid-March.
+    expect(addDays("2026-03-07", 1)).toBe("2026-03-08");
+    expect(addDays("2026-03-08", 1)).toBe("2026-03-09");
+  });
+
+  it("survives a DST fall-back boundary", () => {
+    expect(addDays("2026-10-24", 1)).toBe("2026-10-25");
+    expect(addDays("2026-11-01", 1)).toBe("2026-11-02");
+  });
+
+  it("leaves garbage alone", () => {
+    expect(addDays("nope", 1)).toBe("nope");
+  });
+});
+
+describe("addMonths / addYears", () => {
+  it("clamps the day to the target month", () => {
+    expect(addMonths("2026-01-31", 1)).toBe("2026-02-28");
+    expect(addMonths("2024-01-31", 1)).toBe("2024-02-29");
+    expect(addMonths("2026-03-31", 1)).toBe("2026-04-30");
+  });
+
+  it("rolls across a year", () => {
+    expect(addMonths("2026-12-15", 1)).toBe("2027-01-15");
+    expect(addMonths("2026-01-15", -1)).toBe("2025-12-15");
+  });
+
+  it("preserves the time part", () => {
+    expect(addMonths("2026-01-15T08:45", 1)).toBe("2026-02-15T08:45");
+  });
+
+  it("clamps Feb 29 in a common year", () => {
+    expect(addYears("2024-02-29", 1)).toBe("2025-02-28");
+    expect(addYears("2024-02-29", 4)).toBe("2028-02-29");
+  });
+});
+
+describe("addMinutes", () => {
+  it("rolls across midnight in both directions", () => {
+    expect(addMinutes("2026-07-08T23:30", 60)).toBe("2026-07-09T00:30");
+    expect(addMinutes("2026-07-08T00:15", -30)).toBe("2026-07-07T23:45");
+    expect(addMinutes("2026-12-31T23:00", 120)).toBe("2027-01-01T01:00");
+  });
+
+  it("passes a date-only stamp through untouched", () => {
+    expect(addMinutes("2026-07-08", 60)).toBe("2026-07-08");
+  });
+});
+
+describe("durations", () => {
+  it("counts whole days between dates", () => {
+    expect(daysBetween("2026-07-08", "2026-07-09")).toBe(1);
+    expect(daysBetween("2026-07-08", "2026-07-08")).toBe(0);
+    expect(daysBetween("2026-07-09", "2026-07-08")).toBe(-1);
+    expect(daysBetween("2026-12-31", "2027-01-01")).toBe(1);
+  });
+
+  it("counts days across a DST boundary without rounding off", () => {
+    // A naive (b-a)/86400000 without rounding returns 0.958… or 1.041… here.
+    expect(daysBetween("2026-03-28", "2026-03-29")).toBe(1);
+    expect(daysBetween("2026-10-24", "2026-10-25")).toBe(1);
+  });
+
+  it("counts minutes across a day boundary", () => {
+    expect(minutesBetween("2026-07-08T09:00", "2026-07-08T10:30")).toBe(90);
+    expect(minutesBetween("2026-07-08T23:00", "2026-07-09T01:00")).toBe(120);
+  });
+
+  it("reports minutes into the day", () => {
+    expect(minutesIntoDay("2026-07-08T09:30")).toBe(570);
+    expect(minutesIntoDay("2026-07-08")).toBe(0);
+  });
+});
+
+describe("weeks and grids", () => {
+  it("finds the week start for both conventions", () => {
+    // 2026-07-08 is a Wednesday.
+    expect(weekdayOf("2026-07-08")).toBe(3);
+    expect(startOfWeek("2026-07-08", 0)).toBe("2026-07-05"); // Sunday
+    expect(startOfWeek("2026-07-08", 1)).toBe("2026-07-06"); // Monday
+  });
+
+  it("keeps a day that IS the week start put", () => {
+    expect(startOfWeek("2026-07-05", 0)).toBe("2026-07-05");
+    expect(startOfWeek("2026-07-06", 1)).toBe("2026-07-06");
+  });
+
+  it("puts Sunday at the END of a Monday-start week", () => {
+    // The classic off-by-one: Sunday (dow 0) with weekStart 1 belongs to the week
+    // that began the PREVIOUS Monday, not the one starting tomorrow.
+    expect(startOfWeek("2026-07-12", 1)).toBe("2026-07-06");
+    const week = weekDates("2026-07-12", 1);
+    expect(week[week.length - 1]).toBe("2026-07-12");
+  });
+
+  it("builds a 7-day week", () => {
+    expect(weekDates("2026-07-08", 1)).toEqual([
+      "2026-07-06", "2026-07-07", "2026-07-08", "2026-07-09",
+      "2026-07-10", "2026-07-11", "2026-07-12",
+    ]);
+  });
+
+  it("builds a 6-week month grid that brackets the month", () => {
+    const grid = monthGrid(2026, 7, 0);
+    expect(grid).toHaveLength(6);
+    expect(grid[0]).toHaveLength(7);
+    // July 2026 starts on a Wednesday, so a Sunday-start grid opens on Jun 28.
+    expect(grid[0][0]).toBe("2026-06-28");
+    expect(grid.flat()).toContain("2026-07-01");
+    expect(grid.flat()).toContain("2026-07-31");
+  });
+
+  it("honours a custom week count for the multiweek view", () => {
+    expect(monthGrid(2026, 7, 1, 2)).toHaveLength(2);
+  });
+
+  it("yields consecutive dates in a range", () => {
+    expect(dateRange("2026-07-30", 3)).toEqual(["2026-07-30", "2026-07-31", "2026-08-01"]);
+  });
+});
+
+describe("normalizeSpan", () => {
+  it("gives a timed event with a missing end a minimum length", () => {
+    expect(normalizeSpan({ start: "2026-07-08T09:00", end: "", allDay: false }))
+      .toEqual({ start: "2026-07-08T09:00", end: "2026-07-08T09:15", allDay: false });
+  });
+
+  it("repairs an end that precedes its start", () => {
+    const s = normalizeSpan({
+      start: "2026-07-08T09:00", end: "2026-07-08T08:00", allDay: false,
+    });
+    expect(s.end).toBe("2026-07-08T09:15");
+  });
+
+  it("gives an all-day event with a bad end its single day back", () => {
+    expect(normalizeSpan({ start: "2026-07-08", end: "", allDay: true }))
+      .toEqual({ start: "2026-07-08", end: "2026-07-09", allDay: true });
+  });
+
+  it("leaves a well-formed span alone", () => {
+    const span = { start: "2026-07-08T09:00", end: "2026-07-08T10:00", allDay: false };
+    expect(normalizeSpan(span)).toEqual(span);
+  });
+});
+
+describe("span coverage (exclusive ends)", () => {
+  const allDayOneDay = { start: "2026-07-08", end: "2026-07-09", allDay: true };
+  const allDayThreeDay = { start: "2026-07-08", end: "2026-07-11", allDay: true };
+  const timed = { start: "2026-07-08T09:00", end: "2026-07-08T10:00", allDay: false };
+
+  it("covers exactly its one day for a single all-day event", () => {
+    expect(spanCoversDate(allDayOneDay, "2026-07-08")).toBe(true);
+    // The exclusive end day is NOT covered.
+    expect(spanCoversDate(allDayOneDay, "2026-07-09")).toBe(false);
+    expect(spanCoversDate(allDayOneDay, "2026-07-07")).toBe(false);
+    expect(spanDates(allDayOneDay)).toEqual(["2026-07-08"]);
+    expect(isMultiDay(allDayOneDay)).toBe(false);
+  });
+
+  it("covers every day of a multi-day all-day event but not the end day", () => {
+    expect(spanDates(allDayThreeDay)).toEqual(["2026-07-08", "2026-07-09", "2026-07-10"]);
+    expect(spanCoversDate(allDayThreeDay, "2026-07-11")).toBe(false);
+    expect(isMultiDay(allDayThreeDay)).toBe(true);
+  });
+
+  it("covers a single day for a timed event", () => {
+    expect(spanDates(timed)).toEqual(["2026-07-08"]);
+    expect(isMultiDay(timed)).toBe(false);
+  });
+
+  it("does not let a timed event ending at midnight claim the next day", () => {
+    // 22:00 → 00:00 is a Wednesday event, not a Wednesday+Thursday one.
+    const overnight = { start: "2026-07-08T22:00", end: "2026-07-09T00:00", allDay: false };
+    expect(spanDates(overnight)).toEqual(["2026-07-08"]);
+    expect(spanCoversDate(overnight, "2026-07-09")).toBe(false);
+  });
+
+  it("spans both days for a timed event crossing midnight", () => {
+    const overnight = { start: "2026-07-08T22:00", end: "2026-07-09T02:00", allDay: false };
+    expect(spanDates(overnight)).toEqual(["2026-07-08", "2026-07-09"]);
+    expect(isMultiDay(overnight)).toBe(true);
+  });
+});
+
+describe("daySlice", () => {
+  it("slices a same-day timed event to its own extent", () => {
+    expect(daySlice({ start: "2026-07-08T09:00", end: "2026-07-08T10:30", allDay: false }, "2026-07-08"))
+      .toEqual({ startMin: 540, endMin: 630 });
+  });
+
+  it("clips a midnight-crossing event to each day", () => {
+    const overnight = { start: "2026-07-08T22:00", end: "2026-07-09T02:00", allDay: false };
+    expect(daySlice(overnight, "2026-07-08")).toEqual({ startMin: 1320, endMin: MINUTES_PER_DAY });
+    expect(daySlice(overnight, "2026-07-09")).toEqual({ startMin: 0, endMin: 120 });
+  });
+
+  it("fills the whole of a middle day of a long event", () => {
+    const long = { start: "2026-07-08T22:00", end: "2026-07-11T02:00", allDay: false };
+    expect(daySlice(long, "2026-07-09")).toEqual({ startMin: 0, endMin: MINUTES_PER_DAY });
+    expect(daySlice(long, "2026-07-10")).toEqual({ startMin: 0, endMin: MINUTES_PER_DAY });
+  });
+
+  it("returns null for a day the event does not touch", () => {
+    expect(daySlice({ start: "2026-07-08T09:00", end: "2026-07-08T10:00", allDay: false }, "2026-07-09"))
+      .toBeNull();
+  });
+});
+
+describe("all-day end conversion (picker ↔ storage)", () => {
+  it("shows the stored exclusive end as the inclusive last day", () => {
+    // Stored 2026-07-09 (exclusive) is a one-day event ON the 8th.
+    expect(allDayEndToLastDay("2026-07-09")).toBe("2026-07-08");
+    // A three-day block: stored end 07-11 → last day shown is the 10th.
+    expect(allDayEndToLastDay("2026-07-11")).toBe("2026-07-10");
+  });
+
+  it("stores the picker's last day as the exclusive end", () => {
+    expect(lastDayToAllDayEnd("2026-07-08")).toBe("2026-07-09");
+    expect(lastDayToAllDayEnd("2026-07-10")).toBe("2026-07-11");
+  });
+
+  it("round-trips in both directions", () => {
+    for (const stored of ["2026-07-09", "2026-03-01", "2027-01-01"]) {
+      expect(lastDayToAllDayEnd(allDayEndToLastDay(stored))).toBe(stored);
+    }
+    for (const shown of ["2026-07-08", "2026-02-28", "2026-12-31"]) {
+      expect(allDayEndToLastDay(lastDayToAllDayEnd(shown))).toBe(shown);
+    }
+  });
+
+  it("a same-day all-day event never ends before it starts", () => {
+    // The regression: a new-event draft whose end was fed through the wrong
+    // direction landed the end a DAY BEFORE the start, and the save was rejected.
+    const start = "2026-07-08";
+    const lastDay = start; // "ends on" the same day it starts
+    expect(lastDayToAllDayEnd(lastDay) > start).toBe(true);
+  });
+
+  it("tolerates a timed stamp by using its date half", () => {
+    expect(allDayEndToLastDay("2026-07-09T10:00")).toBe("2026-07-08");
+    expect(lastDayToAllDayEnd("2026-07-08T10:00")).toBe("2026-07-09");
+  });
+
+  it("leaves garbage alone", () => {
+    expect(allDayEndToLastDay("")).toBe("");
+    expect(lastDayToAllDayEnd("nope")).toBe("nope");
+  });
+});
+
+describe("layoutOverlaps", () => {
+  it("gives a lone event the full width", () => {
+    expect(layoutOverlaps([{ startMin: 540, endMin: 600 }]))
+      .toEqual([{ left: 0, width: 1, column: 0, columns: 1 }]);
+  });
+
+  it("gives two non-overlapping events the full width each", () => {
+    const out = layoutOverlaps([
+      { startMin: 540, endMin: 600 },
+      { startMin: 600, endMin: 660 },
+    ]);
+    expect(out[0].width).toBe(1);
+    expect(out[1].width).toBe(1);
+  });
+
+  it("splits two overlapping events in half", () => {
+    const out = layoutOverlaps([
+      { startMin: 540, endMin: 660 },
+      { startMin: 600, endMin: 720 },
+    ]);
+    expect(out[0]).toEqual({ left: 0, width: 0.5, column: 0, columns: 2 });
+    expect(out[1]).toEqual({ left: 0.5, width: 0.5, column: 1, columns: 2 });
+  });
+
+  it("splits three mutually overlapping events into thirds", () => {
+    const out = layoutOverlaps([
+      { startMin: 540, endMin: 700 },
+      { startMin: 560, endMin: 700 },
+      { startMin: 580, endMin: 700 },
+    ]);
+    expect(out.map((p) => p.columns)).toEqual([3, 3, 3]);
+    expect(out.map((p) => p.column)).toEqual([0, 1, 2]);
+  });
+
+  it("reuses a freed column within a cluster", () => {
+    // A runs 9-12; B 9-10; C 10-11. B and C never overlap, so C takes the column
+    // B vacated — the cluster needs 2 columns, not 3.
+    const [a, b, c] = layoutOverlaps([
+      { startMin: 540, endMin: 720 },
+      { startMin: 540, endMin: 600 },
+      { startMin: 600, endMin: 660 },
+    ]);
+    expect([a, b, c].every((p) => p.columns === 2)).toBe(true);
+    expect(b.column).not.toBe(a.column); // B overlaps A → must be beside it
+    expect(c.column).toBe(b.column); // C reuses the column B freed
+  });
+
+  it("keeps separate clusters independent", () => {
+    // Two overlap in the morning; one sits alone in the afternoon and keeps 100%.
+    const out = layoutOverlaps([
+      { startMin: 540, endMin: 660 },
+      { startMin: 600, endMin: 720 },
+      { startMin: 900, endMin: 960 },
+    ]);
+    expect(out[0].columns).toBe(2);
+    expect(out[1].columns).toBe(2);
+    expect(out[2]).toEqual({ left: 0, width: 1, column: 0, columns: 1 });
+  });
+
+  it("treats touching events as non-overlapping", () => {
+    // 9-10 and 10-11 share only an instant; they should not be split.
+    const out = layoutOverlaps([
+      { startMin: 540, endMin: 600 },
+      { startMin: 600, endMin: 660 },
+    ]);
+    expect(out.every((p) => p.columns === 1)).toBe(true);
+  });
+
+  it("returns placements aligned with the input order, not sorted order", () => {
+    // Input is deliberately out of chronological order.
+    const out = layoutOverlaps([
+      { startMin: 600, endMin: 720 },
+      { startMin: 540, endMin: 660 },
+    ]);
+    // The 09:00 event (index 1) must be the one in column 0.
+    expect(out[1].column).toBe(0);
+    expect(out[0].column).toBe(1);
+  });
+
+  it("handles an empty list", () => {
+    expect(layoutOverlaps([])).toEqual([]);
+  });
+});
+
+describe("formatTime", () => {
+  it("passes 24h through", () => {
+    expect(formatTime("09:00", true)).toBe("09:00");
+    expect(formatTime("17:30", true)).toBe("17:30");
+  });
+
+  it("converts to 12h with a suffix", () => {
+    expect(formatTime("09:00", false)).toBe("9:00 AM");
+    expect(formatTime("17:30", false)).toBe("5:30 PM");
+  });
+
+  it("renders both noon and midnight as 12", () => {
+    expect(formatTime("00:00", false)).toBe("12:00 AM");
+    expect(formatTime("12:00", false)).toBe("12:00 PM");
+  });
+});
diff --git a/src/__tests__/CarefulHost.test.ts b/src/__tests__/CarefulHost.test.ts
new file mode 100644
index 0000000..ee09a16
--- /dev/null
+++ b/src/__tests__/CarefulHost.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  carefulIsExplicit,
+  clearCarefulPatch,
+  isCarefulHost,
+  primaryTargetOf,
+  setCarefulPatch,
+  targetOfSpec,
+} from "../lib/carefulHost";
+import { targetKey } from "../lib/machineSync";
+import type { ProjectEntry, Settings } from "../types";
+
+const login = { user: "alice", host: "login.example.org", port: 22 };
+
+describe("careful-host resolution", () => {
+  it("treats an unanswered remote machine as careful, and a local one never", () => {
+    // The failure direction, and the reason there is no HPC detection left: a
+    // wrong careful costs a thinner table, a wrong full reading costs a policy
+    // violation on someone else's cluster. Only "no target" — the local machine,
+    // where Eldrun is not a guest — reads false.
+    expect(isCarefulHost({}, login)).toBe(true);
+    expect(isCarefulHost({}, null)).toBe(false);
+    expect(isCarefulHost({}, { host: "" })).toBe(false);
+  });
+
+  it("lets an explicit OFF outrank the careful default", () => {
+    // The reason careful_hosts is a map to boolean rather than a set of hosts:
+    // in a set, "off" and "never asked" are the same value, so a machine the user
+    // switched to a full reading would revert to careful at every read.
+    const settings: Settings = { careful_hosts: { [targetKey(login)]: false } };
+    expect(isCarefulHost(settings, login)).toBe(false);
+  });
+
+  it("keeps an explicit ON, which is also what the default would say", () => {
+    const settings: Settings = { careful_hosts: { [targetKey(login)]: true } };
+    expect(isCarefulHost(settings, login)).toBe(true);
+  });
+
+  it("treats one machine reached under different spellings as the same host", () => {
+    // The whole point of keying by target rather than by host id: the same login
+    // node is a primary remote, a worker and a global machine, written down three
+    // times, and must not be careful in one place and not in another.
+    const settings: Settings = { careful_hosts: { [targetKey(login)]: true } };
+    expect(isCarefulHost(settings, { user: "alice", host: "LOGIN.example.org", port: 22 })).toBe(true);
+    expect(isCarefulHost(settings, { user: "alice", host: "login.example.org" })).toBe(true);
+    expect(isCarefulHost(settings, { user: " alice ", host: " login.example.org " })).toBe(true);
+  });
+
+  it("does not carry an answer across a different login or port", () => {
+    // A different login on the same box is a different connection, so the "this
+    // one is mine" answer must not follow it — it falls back to careful.
+    const settings: Settings = { careful_hosts: { [targetKey(login)]: false } };
+    expect(isCarefulHost(settings, { user: "someone-else", host: "login.example.org" })).toBe(true);
+    expect(isCarefulHost(settings, { user: "alice", host: "login.example.org", port: 2222 })).toBe(
+      true,
+    );
+  });
+
+  it("distinguishes an explicit answer from the default", () => {
+    expect(carefulIsExplicit({}, login)).toBe(false);
+    const settings: Settings = { careful_hosts: { [targetKey(login)]: false } };
+    expect(carefulIsExplicit(settings, login)).toBe(true);
+  });
+
+  it("merges rather than replaces when recording an answer", () => {
+    // Settings are saved WHOLE, so a patch that replaced the map would drop every
+    // other host's answer on the floor.
+    const other = targetKey({ host: "other.example.org" });
+    const settings: Settings = { careful_hosts: { [other]: true } };
+    const patch = setCarefulPatch(settings, login, true);
+    expect(patch.careful_hosts).toEqual({ [other]: true, [targetKey(login)]: true });
+  });
+
+  it("returns a host to the careful default when its answer is cleared", () => {
+    const settings: Settings = { careful_hosts: { [targetKey(login)]: false } };
+    const patch = clearCarefulPatch(settings, login);
+    expect(patch.careful_hosts).toEqual({});
+    expect(isCarefulHost(patch as Settings, login)).toBe(true);
+  });
+
+  it("reads no target from a local project and the primary from a remote one", () => {
+    expect(primaryTargetOf({ id: "p" } as ProjectEntry)).toBeNull();
+    const remote = {
+      id: "p",
+      remote: { user: "alice", host: "login.example.org", port: 22, remote_path: "/home/x" },
+    } as ProjectEntry;
+    expect(primaryTargetOf(remote)).toEqual(login);
+  });
+
+  it("agrees byte-for-byte with the Rust target_key", () => {
+    // Both sides index settings.careful_hosts by this exact string. A divergence
+    // would not fail loudly — it would look up a host nobody wrote and answer
+    // "not careful", i.e. fail OPEN in the case the flag exists to protect. These
+    // two literals are duplicated verbatim in `ssh_common::tests
+    // ::target_key_matches_frontend`; changing one must break the other.
+    expect(targetKey({ user: "alice", host: "login.example.org", port: 2222 })).toBe(
+      "alice@login.example.org:2222",
+    );
+    expect(targetKey({ host: "h" })).toBe("@h:22");
+  });
+
+  it("reads one target out of any RemoteSpec-shaped record", () => {
+    // A primary remote, a compute host and a global machine all spell user/host/
+    // port the same way, which is what lets one key span all three tables.
+    expect(targetOfSpec({ user: "alice", host: "login.example.org", port: 22 })).toEqual(login);
+    expect(targetOfSpec({ user: "", host: "h", port: null })).toEqual({
+      user: undefined,
+      host: "h",
+      port: undefined,
+    });
+    expect(targetOfSpec(null)).toBeNull();
+  });
+});
diff --git a/src/__tests__/CenterPanelSessionRestore.test.tsx b/src/__tests__/CenterPanelSessionRestore.test.tsx
index 4b9defb..ce00360 100644
--- a/src/__tests__/CenterPanelSessionRestore.test.tsx
+++ b/src/__tests__/CenterPanelSessionRestore.test.tsx
@@ -318,13 +318,39 @@ describe("loadFromLayout — resume args", () => {
     expect(tab.sessionId).toBeUndefined();
   });
 
-  it("non-resumable agent (gemini) with a sessionId gets no resume args", () => {
+  it("continue-last agent (gemini) restores with --resume latest and carries sessionId", () => {
     const layout = [
       { key: "agent-1", label: "gemini", cmd: "gemini", cwd: "/stale", kind: "agent" as const, sessionId: "abc" },
     ];
 
     useTabsStore.getState().loadFromLayout(layout, "/project-r-dir", "project-r");
 
+    const tab = useTabsStore.getState().tabsByScope["project-r"]![0];
+    // Gemini's `--resume` continues the project's most-recent session ("latest"),
+    // since its `--resume` takes latest/index, not the launch uuid.
+    expect(tab.args).toEqual(["--resume", "latest"]);
+    expect(tab.sessionId).toBe("abc");
+  });
+
+  it("continue-last agent (Mistral/vibe) restores with --continue and carries sessionId", () => {
+    const layout = [
+      { key: "agent-1", label: "vibe", cmd: "vibe", cwd: "/stale", kind: "agent" as const, sessionId: "vibe-key-1" },
+    ];
+
+    useTabsStore.getState().loadFromLayout(layout, "/project-r-dir", "project-r");
+
+    const tab = useTabsStore.getState().tabsByScope["project-r"]![0];
+    expect(tab.args).toEqual(["--continue"]);
+    expect(tab.sessionId).toBe("vibe-key-1");
+  });
+
+  it("agent with no wired resume (aider) with a sessionId gets no resume args", () => {
+    const layout = [
+      { key: "agent-1", label: "aider", cmd: "aider", cwd: "/stale", kind: "agent" as const, sessionId: "abc" },
+    ];
+
+    useTabsStore.getState().loadFromLayout(layout, "/project-r-dir", "project-r");
+
     const tab = useTabsStore.getState().tabsByScope["project-r"]![0];
     expect(tab.args).toEqual([]);
     // sessionId is still carried through (durable), but no resume launch.
diff --git a/src/__tests__/CloneImport.test.ts b/src/__tests__/CloneImport.test.ts
new file mode 100644
index 0000000..1bfc6fc
--- /dev/null
+++ b/src/__tests__/CloneImport.test.ts
@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import {
+  isCloneUrl,
+  providerFromCloneUrl,
+  repoNameFromCloneUrl,
+  sanitizeName,
+} from "../components/projects/scaffold";
+
+// The import dialog's "GitHub / GitLab repository (clone)" source. `isCloneUrl`
+// gates the Import button; the backend's `validate_clone_url` is the real guard
+// and these cases are kept in step with its Rust tests.
+describe("clone URL validation", () => {
+  it("accepts the supported URL forms", () => {
+    for (const url of [
+      "https://github.com/owner/repo.git",
+      "https://gitlab.com/group/sub/repo",
+      "http://git.internal/owner/repo.git",
+      "ssh://git@github.com:22/owner/repo.git",
+      "git://git.internal/repo.git",
+      "git@github.com:owner/repo.git",
+      "gitlab.com:group/repo.git",
+      "  https://github.com/owner/repo.git  ",
+    ]) {
+      expect(isCloneUrl(url), url).toBe(true);
+    }
+  });
+
+  it("rejects everything else", () => {
+    for (const url of [
+      "",
+      "   ",
+      // git's transport-helper form: `ext::<command>` RUNS the command.
+      "ext::sh -c 'touch /tmp/pwned'",
+      "file:///etc",
+      "/etc/passwd",
+      "../repo",
+      "github.com/owner/repo",
+      "--upload-pack=x:y",
+    ]) {
+      expect(isCloneUrl(url), url).toBe(false);
+    }
+  });
+});
+
+describe("project name from a clone URL", () => {
+  it("takes the repository's own name, without .git", () => {
+    expect(repoNameFromCloneUrl("https://github.com/owner/my-repo.git")).toBe("my-repo");
+    expect(repoNameFromCloneUrl("https://gitlab.com/group/sub/my-repo")).toBe("my-repo");
+    expect(repoNameFromCloneUrl("git@github.com:owner/my-repo.git")).toBe("my-repo");
+    // A trailing slash (copied from the browser's address bar) is not a segment.
+    expect(repoNameFromCloneUrl("https://github.com/owner/my-repo/")).toBe("my-repo");
+    // scp-like with no path separator: the repo is the whole path.
+    expect(repoNameFromCloneUrl("git@host:repo.git")).toBe("repo");
+  });
+
+  it("yields nothing name-like for an empty URL", () => {
+    expect(repoNameFromCloneUrl("")).toBe("");
+    expect(repoNameFromCloneUrl("   ")).toBe("");
+  });
+
+  it("survives sanitizing into the destination folder name", () => {
+    // The clone lands at `<location>/<sanitizeName(name)>`, so a repo name with
+    // characters the project-name sanitizer strips must still yield a folder.
+    expect(sanitizeName(repoNameFromCloneUrl("https://github.com/owner/My.Repo.git"))).toBe("my-repo");
+  });
+});
+
+// The "fork, then clone" import source: a fork is made by the provider's own CLI
+// (`gh`/`glab`), so which provider a URL belongs to decides which binary runs.
+// Twin of `provider_from_host` in `commands/git_fork.rs`.
+describe("provider from a clone URL", () => {
+  it("reads the provider off a host that names itself", () => {
+    expect(providerFromCloneUrl("https://github.com/owner/repo.git")).toBe("github");
+    expect(providerFromCloneUrl("git@github.com:owner/repo.git")).toBe("github");
+    expect(providerFromCloneUrl("https://gitlab.com/group/sub/repo")).toBe("gitlab");
+    expect(providerFromCloneUrl("ssh://git@gitlab.example.org:2222/owner/repo.git")).toBe("gitlab");
+    // Userinfo and port are not part of the host.
+    expect(providerFromCloneUrl("https://user@github.com:8443/owner/repo")).toBe("github");
+  });
+
+  it("says nothing for a host that does not name itself", () => {
+    // A self-hosted instance — the dialog then asks which it is rather than
+    // guessing a CLI.
+    expect(providerFromCloneUrl("https://git.internal/owner/repo.git")).toBe("");
+    expect(providerFromCloneUrl("")).toBe("");
+  });
+});
diff --git a/src/__tests__/CodexHooksTab.test.ts b/src/__tests__/CodexHooksTab.test.ts
new file mode 100644
index 0000000..9d6a6a3
--- /dev/null
+++ b/src/__tests__/CodexHooksTab.test.ts
@@ -0,0 +1,70 @@
+/**
+ * The one-click fix for Codex's hook trust gate.
+ *
+ * Codex refuses to run Eldrun's SessionStart hook until the user enables it in
+ * Codex's own `/hooks` list, and until then Codex tabs resume off a heuristic
+ * fallback rather than the exact recorded session. Per Eldrun's install-via-tab
+ * policy, the remedy must be a click that *opens Codex on that list* — never a
+ * command handed to the user to run themselves. See lib/codexHooks.ts.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn().mockResolvedValue(undefined) }));
+
+import { codexHookNeedsTrust, openCodexHooksTab } from "../lib/codexHooks";
+import { useTabsStore } from "../stores/tabs";
+import { useProjectsStore } from "../stores/projects";
+
+describe("codexHookNeedsTrust", () => {
+  it("flags only the states in which Codex won't run the hook", () => {
+    expect(codexHookNeedsTrust("untrusted")).toBe(true);
+    expect(codexHookNeedsTrust("disabled")).toBe(true);
+    // Working, Codex not installed, or not probed yet → nothing to nag about.
+    expect(codexHookNeedsTrust("enabled")).toBe(false);
+    expect(codexHookNeedsTrust("no_codex")).toBe(false);
+    expect(codexHookNeedsTrust("not_registered")).toBe(false);
+    expect(codexHookNeedsTrust(null)).toBe(false);
+  });
+});
+
+describe("openCodexHooksTab", () => {
+  beforeEach(() => {
+    useTabsStore.setState({ tabsByScope: {} });
+    useProjectsStore.setState({ rootDir: "/home/u/eldrun/root", activeId: "p1" });
+  });
+
+  it("opens a real Codex tab in the root scope, already on /hooks", () => {
+    openCodexHooksTab();
+
+    // Root scope: the hook is machine-global (~/.codex/config.toml), not a
+    // per-project setting — and the user's active project stays put.
+    const root = useTabsStore.getState().tabsByScope["root"] ?? [];
+    expect(root).toHaveLength(1);
+    expect(useProjectsStore.getState().activeId).toBe("p1");
+
+    const tab = root[0];
+    expect(tab.cmd).toBe("codex");
+    expect(tab.kind).toBe("agent");
+    expect(tab.cwd).toBe("/home/u/eldrun/root");
+    // TerminalView types + submits this once Codex is up, so the user lands in
+    // the hooks list rather than being told to type it.
+    expect(tab.initialInput).toBe("/hooks");
+  });
+
+  it("is an ordinary tracked Codex tab, not a special case", () => {
+    openCodexHooksTab();
+    const tab = (useTabsStore.getState().tabsByScope["root"] ?? [])[0];
+
+    // Built through buildStaticTabSpec, so it mints a session key like any other
+    // Codex tab: it is itself resumable, and the binder can follow it.
+    expect(tab.sessionId).toBeTruthy();
+    expect(tab.env?.ELDRUN_TAB_UID).toBe(tab.sessionId);
+    // Codex mints its own session id, so nothing is passed on the command line.
+    expect(tab.args ?? []).toEqual([]);
+  });
+
+  it("points the user at where it opened it", () => {
+    openCodexHooksTab();
+    expect(useProjectsStore.getState().switchToast).toMatch(/root terminal/i);
+  });
+});
diff --git a/src/__tests__/Coords.test.ts b/src/__tests__/Coords.test.ts
new file mode 100644
index 0000000..9f733c3
--- /dev/null
+++ b/src/__tests__/Coords.test.ts
@@ -0,0 +1,224 @@
+/**
+ * #42: the canonical cross-window coordinate space (physical desktop px) and the
+ * per-platform drag-event flags. These pure helpers are the safety net that makes
+ * the detached drag-drop DPI-correct on Windows/macOS without regressing Linux —
+ * the app can't be launched in CI, so the round-trips below are the proof that the
+ * physical↔client mapping (and the engine flag table) is correct under scaling.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+// coords.ts imports cursorPosition/getCurrentWindow at module load; the pure
+// helpers under test don't call them, but stub the module so the import is inert.
+vi.mock("@tauri-apps/api/window", () => ({
+  cursorPosition: vi.fn(() => Promise.resolve({ x: 0, y: 0 })),
+  getCurrentWindow: vi.fn(() => ({})),
+}));
+
+import {
+  physToClient,
+  clientToPhys,
+  pointInOuter,
+  type WindowFrame,
+} from "../lib/coords";
+
+/** A frame with deliberately DIFFERENT inner vs outer origins, so a test can prove
+ *  the client mapping uses `innerPhys` only (Windows invisible frame / macOS title
+ *  area would make outer ≠ inner). */
+function frame(opts: {
+  inner: { x: number; y: number };
+  outer?: { x: number; y: number };
+  size?: { w: number; h: number };
+  scale: number;
+}): WindowFrame {
+  return {
+    innerPhys: opts.inner,
+    outerPhys: opts.outer ?? opts.inner,
+    outerSize: opts.size ?? { w: 800, h: 600 },
+    scale: opts.scale,
+  };
+}
+
+describe("physToClient / clientToPhys round-trip", () => {
+  const scales = [1, 1.25, 1.5, 2.0];
+  // Non-zero AND negative origins (a monitor left/above the primary has negative
+  // physical coordinates under a multi-monitor desktop).
+  const origins = [
+    { x: 0, y: 0 },
+    { x: 1920, y: 0 },
+    { x: -1920, y: -200 },
+    { x: 137, y: -1080 },
+  ];
+
+  for (const scale of scales) {
+    for (const inner of origins) {
+      it(`is identity through physical→client→physical at scale ${scale}, origin (${inner.x},${inner.y})`, () => {
+        const f = frame({ inner, scale });
+        for (const p of [
+          { x: inner.x, y: inner.y },
+          { x: inner.x + 400, y: inner.y + 300 },
+          // A point OUTSIDE the viewport (extrapolation): the cursor is over
+          // ANOTHER window when the popout streams its position.
+          { x: inner.x - 250, y: inner.y + 5000 },
+        ]) {
+          const c = physToClient(f, p);
+          const back = clientToPhys(f, c);
+          expect(back.x).toBeCloseTo(p.x, 6);
+          expect(back.y).toBeCloseTo(p.y, 6);
+        }
+      });
+    }
+  }
+
+  it("divides the physical delta by the window's own scale", () => {
+    const f = frame({ inner: { x: 100, y: 50 }, scale: 2 });
+    // 300 physical px right of the inner origin = 150 client (CSS) px at DPR 2.
+    expect(physToClient(f, { x: 400, y: 50 })).toEqual({ x: 150, y: 0 });
+    expect(physToClient(f, { x: 100, y: 250 })).toEqual({ x: 0, y: 100 });
+  });
+
+  it("maps client px back out through the same scale", () => {
+    const f = frame({ inner: { x: 100, y: 50 }, scale: 1.5 });
+    expect(clientToPhys(f, { x: 200, y: 100 })).toEqual({ x: 100 + 300, y: 50 + 150 });
+  });
+});
+
+describe("physToClient ignores outerPhys (uses innerPhys only)", () => {
+  it("returns the same client point regardless of the outer origin", () => {
+    const inner = { x: 1000, y: 500 };
+    const p = { x: 1240, y: 740 };
+    // Three frames identical except for their OUTER origin (frame/shadow offset).
+    const a = physToClient(frame({ inner, outer: inner, scale: 1.25 }), p);
+    const b = physToClient(frame({ inner, outer: { x: 992, y: 470 }, scale: 1.25 }), p);
+    const c = physToClient(frame({ inner, outer: { x: -50, y: -50 }, scale: 1.25 }), p);
+    expect(b).toEqual(a);
+    expect(c).toEqual(a);
+  });
+});
+
+describe("pointInOuter — physical AABB against the outer rect", () => {
+  const f = frame({
+    inner: { x: 110, y: 140 },
+    outer: { x: 100, y: 120 },
+    size: { w: 400, h: 300 },
+    scale: 1.5,
+  });
+  it("is true strictly inside", () => {
+    expect(pointInOuter(f, { x: 300, y: 250 })).toBe(true);
+  });
+  it("is true on every corner (inclusive bounds)", () => {
+    expect(pointInOuter(f, { x: 100, y: 120 })).toBe(true);
+    expect(pointInOuter(f, { x: 500, y: 120 })).toBe(true);
+    expect(pointInOuter(f, { x: 100, y: 420 })).toBe(true);
+    expect(pointInOuter(f, { x: 500, y: 420 })).toBe(true);
+  });
+  it("is false just outside each edge", () => {
+    expect(pointInOuter(f, { x: 99, y: 250 })).toBe(false);
+    expect(pointInOuter(f, { x: 501, y: 250 })).toBe(false);
+    expect(pointInOuter(f, { x: 300, y: 119 })).toBe(false);
+    expect(pointInOuter(f, { x: 300, y: 421 })).toBe(false);
+  });
+  it("does not involve scale (both operands are physical)", () => {
+    const f2 = frame({ inner: { x: 0, y: 0 }, outer: { x: 0, y: 0 }, size: { w: 10, h: 10 }, scale: 3 });
+    expect(pointInOuter(f2, { x: 5, y: 5 })).toBe(true);
+    expect(pointInOuter(f2, { x: 11, y: 5 })).toBe(false);
+  });
+});
+
+describe("dragPlatform — per-platform event flags", () => {
+  // dragPlatform is computed once at module load from navigator.platform, so each
+  // case stubs the platform and re-imports the module fresh.
+  const original = Object.getOwnPropertyDescriptor(navigator, "platform");
+  async function loadFor(platform: string) {
+    Object.defineProperty(navigator, "platform", { value: platform, configurable: true });
+    vi.resetModules();
+    return (await import("../lib/dragPlatform")).dragPlatform;
+  }
+  beforeEach(() => vi.resetModules());
+  afterEach(() => {
+    if (original) Object.defineProperty(navigator, "platform", original);
+  });
+
+  it("Linux (WebKitGTK): cancel commits, no capture, window follows", async () => {
+    const p = await loadFor("Linux x86_64");
+    expect(p).toEqual({
+      cancelCommits: true,
+      needsPointerCapture: false,
+      followWindowOnDockDrag: true,
+    });
+  });
+
+  it("Windows (WebView2): cancel commits, capture needed, no window follow", async () => {
+    // WebView2 ends these drags with `pointercancel` (preventDefault'd pointerdown
+    // + capture on the collapsing `.tab`), so cancel must COMMIT, like WebKitGTK —
+    // a genuine capture loss is caught by the blur→abort net instead.
+    const p = await loadFor("Win32");
+    expect(p).toEqual({
+      cancelCommits: true,
+      needsPointerCapture: true,
+      followWindowOnDockDrag: false,
+    });
+  });
+
+  it("macOS (WKWebView): cancel aborts, capture needed, no window follow", async () => {
+    const p = await loadFor("MacIntel");
+    expect(p).toEqual({
+      cancelCommits: false,
+      needsPointerCapture: true,
+      followWindowOnDockDrag: false,
+    });
+  });
+});
+
+describe("bindDragRelease — Shift survives a modifier-less pointercancel", () => {
+  // WebView2 ends drags with a SYNTHESIZED pointercancel that carries no
+  // modifier state, so the binding must track Shift itself (keydown/keyup +
+  // pointermove) rather than trust the terminal event. jsdom has no
+  // PointerEvent; MouseEvent carries shiftKey and listeners match on type.
+  const original = Object.getOwnPropertyDescriptor(navigator, "platform");
+  async function loadFor(platform: string) {
+    Object.defineProperty(navigator, "platform", { value: platform, configurable: true });
+    vi.resetModules();
+    return (await import("../lib/dragPlatform")).bindDragRelease;
+  }
+  afterEach(() => {
+    if (original) Object.defineProperty(navigator, "platform", original);
+  });
+
+  it("commits shift=true from a prior shift-held pointermove (WebView2 cancel)", async () => {
+    const bind = await loadFor("Win32");
+    const onCommit = vi.fn();
+    const onAbort = vi.fn();
+    bind({ onCommit, onAbort });
+    window.dispatchEvent(new MouseEvent("pointermove", { shiftKey: true }));
+    window.dispatchEvent(new MouseEvent("pointercancel", { shiftKey: false }));
+    expect(onCommit).toHaveBeenCalledWith(true);
+    expect(onAbort).not.toHaveBeenCalled();
+  });
+
+  it("counts a Shift pressed while stationary (keydown, no pointermove)", async () => {
+    const bind = await loadFor("Win32");
+    const onCommit = vi.fn();
+    bind({ onCommit, onAbort: vi.fn() });
+    window.dispatchEvent(new KeyboardEvent("keydown", { key: "Shift", shiftKey: true }));
+    window.dispatchEvent(new MouseEvent("pointercancel", { shiftKey: false }));
+    expect(onCommit).toHaveBeenCalledWith(true);
+  });
+
+  it("a Shift released again before the drop commits shift=false", async () => {
+    const bind = await loadFor("Win32");
+    const onCommit = vi.fn();
+    bind({ onCommit, onAbort: vi.fn() });
+    window.dispatchEvent(new MouseEvent("pointermove", { shiftKey: true }));
+    window.dispatchEvent(new KeyboardEvent("keyup", { key: "Shift", shiftKey: false }));
+    window.dispatchEvent(new MouseEvent("pointercancel", { shiftKey: false }));
+    expect(onCommit).toHaveBeenCalledWith(false);
+  });
+
+  it("a genuine pointerup keeps its own shiftKey (Linux unchanged)", async () => {
+    const bind = await loadFor("Linux x86_64");
+    const onCommit = vi.fn();
+    bind({ onCommit, onAbort: vi.fn() });
+    window.dispatchEvent(new MouseEvent("pointerup", { shiftKey: true }));
+    expect(onCommit).toHaveBeenCalledWith(true);
+  });
+});
diff --git a/src/__tests__/CredentialPaste.test.tsx b/src/__tests__/CredentialPaste.test.tsx
new file mode 100644
index 0000000..2ff06b4
--- /dev/null
+++ b/src/__tests__/CredentialPaste.test.tsx
@@ -0,0 +1,123 @@
+/**
+ * "Type it for me" above a login terminal (`CredentialPasteBar`).
+ *
+ * The point of the feature is that a *saved* credential is reachable from a
+ * *terminal* login — the mode in which Eldrun deliberately handles no passwords —
+ * without the secret ever entering the frontend. So the two things worth locking in
+ * are exactly the two that could regress into a leak or into uselessness:
+ *
+ *  1. **A secret is never fetched into JS.** The password button calls
+ *     `credential_paste_to_pty` (backend reads the keychain, backend writes the PTY)
+ *     and nothing else — in particular nothing that *returns* a password.
+ *  2. **A non-secret is typed as a keystroke.** The login name is already on screen,
+ *     so it goes through the ordinary `pty_write`, with no trailing newline: a paste
+ *     is not a login, and the user presses Enter.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve(true)) }));
+
+import {
+  CredentialPasteBar,
+  sshPasteEntries,
+  vpnPasteEntries,
+} from "../components/projects/CredentialPasteBar";
+import { translate, type TranslationKey } from "../lib/i18n";
+
+const t = (key: TranslationKey, params?: Record<string, string | number>) =>
+  translate("en", key, params);
+
+const invokeMock = vi.mocked(invoke);
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation(() => Promise.resolve(true));
+});
+
+describe("CredentialPasteBar", () => {
+  it("types the login name straight into the PTY, with no newline", async () => {
+    render(
+      <CredentialPasteBar
+        ptyId="pty-1"
+        entries={sshPasteEntries(t, { user: "alice", host: "host.example", saved: false })}
+      />,
+    );
+    await userEvent.click(screen.getByRole("button", { name: /paste username/i }));
+    const [cmd, args] = invokeMock.mock.calls[0] as [string, { id: string; data: Uint8Array }];
+    expect(cmd).toBe("pty_write");
+    expect(args.id).toBe("pty-1");
+    expect(new TextDecoder().decode(args.data)).toBe("alice");
+  });
+
+  it("pastes a saved password through the backend, never fetching it", async () => {
+    render(
+      <CredentialPasteBar
+        ptyId="pty-1"
+        entries={sshPasteEntries(t, { user: "alice", host: "host.example", port: 2222, saved: true })}
+      />,
+    );
+    await userEvent.click(screen.getByRole("button", { name: /paste password/i }));
+    expect(invokeMock).toHaveBeenCalledTimes(1);
+    expect(invokeMock).toHaveBeenCalledWith("credential_paste_to_pty", {
+      pty: "pty-1",
+      // The login name being typed into *this* terminal keys the credential.
+      target: { kind: "ssh-password", user: "alice", host: "host.example", port: 2222 },
+    });
+  });
+
+  it("offers no password button when nothing is saved for the target", () => {
+    render(
+      <CredentialPasteBar
+        ptyId="pty-1"
+        entries={sshPasteEntries(t, { user: "alice", host: "host.example", saved: false })}
+      />,
+    );
+    expect(screen.queryByRole("button", { name: /paste password/i })).toBeNull();
+  });
+
+  it("says so when the keychain answers empty, rather than pasting nothing", async () => {
+    invokeMock.mockImplementation(() => Promise.resolve(false));
+    render(
+      <CredentialPasteBar
+        ptyId="pty-1"
+        entries={sshPasteEntries(t, { user: "bob", host: "host.example", saved: true })}
+      />,
+    );
+    await userEvent.click(screen.getByRole("button", { name: /paste password/i }));
+    expect(await screen.findByText(/nothing saved/i)).toBeTruthy();
+  });
+
+  it("gives an auth-user-pass + encrypted-key tunnel a button per secret", () => {
+    const entries = vpnPasteEntries(t, {
+      config: "/store/office.ovpn",
+      username: "alice",
+      saved: true,
+      needsUsername: true,
+      needsKeyPassphrase: true,
+    });
+    expect(entries.map((e) => e.label)).toEqual([
+      "Paste username",
+      "Paste password",
+      "Paste key passphrase",
+    ]);
+  });
+
+  it("renders nothing for a tunnel with no config and no saved secret", () => {
+    const { container } = render(
+      <CredentialPasteBar
+        ptyId="pty-1"
+        entries={vpnPasteEntries(t, {
+          config: "",
+          saved: false,
+          needsUsername: false,
+          needsKeyPassphrase: false,
+        })}
+      />,
+    );
+    expect(container.firstChild).toBeNull();
+  });
+});
diff --git a/src/__tests__/CrossSubwindowTabDrag.test.ts b/src/__tests__/CrossSubwindowTabDrag.test.ts
new file mode 100644
index 0000000..3e19729
--- /dev/null
+++ b/src/__tests__/CrossSubwindowTabDrag.test.ts
@@ -0,0 +1,98 @@
+/**
+ * Regression guard for the tab-drag operations a user performs across tiled
+ * subwindows: moving a tab from one subwindow into another (both surviving),
+ * and splitting a subwindow inside an already-split layout to carve a third.
+ *
+ * These exercise the store authority (`moveTab` / `splitWithTab`) that the
+ * pointer-drag in TabBar/CenterPanel commits into. If these pass, a runtime
+ * "can't drag across subwindows / can't split" report is NOT a layout-logic
+ * regression — look at the pointer/event layer (e.g. `dragDropEnabled` must be
+ * false so WebKitGTK doesn't hijack the pointer with pointercancel).
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn() }));
+
+import {
+  useTabsStore,
+  allGroups,
+  type GroupNode,
+  type SplitNode,
+} from "../stores/tabs";
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+const s = () => useTabsStore.getState();
+
+/** Build two subwindows side by side: left = [a1, a2], right = [b]. */
+function twoSubwindows() {
+  const a1 = s().addTab(tab("a1"));
+  const a2 = s().addTab(tab("a2"));
+  const rootGid = (s().layout as GroupNode).id;
+  const b = s().addTab(tab("b")); // joins the same group as a1/a2…
+  s().splitWithTab(b.key, rootGid, "right"); // …then splits off to the right
+  const root = s().layout as SplitNode;
+  const left = root.children[0] as GroupNode;
+  const right = root.children[1] as GroupNode;
+  expect(left.tabKeys).toEqual([a1.key, a2.key]);
+  expect(right.tabKeys).toEqual([b.key]);
+  return { a1, a2, b, left, right };
+}
+
+describe("tabs store — cross-subwindow drag", () => {
+  beforeEach(reset);
+
+  it("moves a tab from one subwindow into another, both subwindows surviving", () => {
+    const { a1, a2, b, right } = twoSubwindows();
+
+    // Drag a2 out of the left subwindow into the right one. The left still
+    // holds a1, so the split must NOT collapse — we still have two subwindows.
+    s().moveTab(a2.key, right.id);
+
+    const root = s().layout as SplitNode;
+    expect(root.type).toBe("split");
+    expect(root.children).toHaveLength(2);
+    const [left2, right2] = root.children as GroupNode[];
+    expect(left2.tabKeys).toEqual([a1.key]);
+    expect(right2.tabKeys.sort()).toEqual([a2.key, b.key].sort());
+    // The moved tab is the active one in its new home.
+    expect(right2.activeKey).toBe(a2.key);
+  });
+
+  it("moveTab can land the tab at a specific index in the target subwindow", () => {
+    const { a2, b, right } = twoSubwindows();
+    s().moveTab(a2.key, right.id, 0); // drop before b
+    const right2 = (s().layout as SplitNode).children[1] as GroupNode;
+    expect(right2.tabKeys).toEqual([a2.key, b.key]);
+  });
+
+  it("splits a subwindow inside an existing split to create a third subwindow", () => {
+    const { a1, a2, b, right } = twoSubwindows();
+
+    // Drop a2 onto the bottom edge of the right subwindow → a new group below.
+    s().splitWithTab(a2.key, right.id, "bottom");
+
+    const groups = allGroups(s().layout);
+    expect(groups).toHaveLength(3);
+    const keySets = groups.map((g) => g.tabKeys);
+    // Left keeps a1; right keeps b; a2 is alone in the new subwindow.
+    expect(keySets.some((k) => k.length === 1 && k[0] === a1.key)).toBe(true);
+    expect(keySets.some((k) => k.length === 1 && k[0] === b.key)).toBe(true);
+    expect(keySets.some((k) => k.length === 1 && k[0] === a2.key)).toBe(true);
+  });
+});
diff --git a/src/__tests__/CustomAgents.test.ts b/src/__tests__/CustomAgents.test.ts
new file mode 100644
index 0000000..b6dd20f
--- /dev/null
+++ b/src/__tests__/CustomAgents.test.ts
@@ -0,0 +1,93 @@
+/**
+ * Custom agents (Settings.custom_agents): a user-defined CLI offered in the
+ * add-tab menu's Agents group. These tests lock in the two pure helpers that
+ * make a custom agent behave like a built-in one — `buildStaticTabSpec` (the
+ * launch-spec builder, including the resume-flag → restart-resumable promotion)
+ * and `agentMenuEntries` (the shared Agents-group row builder).
+ */
+import { describe, it, expect } from "vitest";
+
+import {
+  agentMenuEntries,
+  buildStaticTabSpec,
+  customAgentToItem,
+} from "../components/tabs/newTabItems";
+import { isResumableAgentTab } from "../stores/tabs";
+import type { CustomAgent } from "../types";
+
+describe("buildStaticTabSpec — custom agents", () => {
+  it("launches a bare custom agent as a launch-only agent tab", () => {
+    const ca: CustomAgent = { id: "1", label: "Mine", cmd: "my-agent" };
+    const spec = buildStaticTabSpec(customAgentToItem(ca), "/proj", "Proj");
+    expect(spec.kind).toBe("agent");
+    expect(spec.cmd).toBe("my-agent");
+    expect(spec.args).toEqual([]);
+    // No resume flag → not restart-resumable → no minted session id / tab uid.
+    expect(spec.resumeArgs).toBeUndefined();
+    expect(spec.sessionId).toBeUndefined();
+    expect(spec.env?.ELDRUN_TAB_UID).toBeUndefined();
+    expect(isResumableAgentTab({ ...spec })).toBe(false);
+  });
+
+  it("prepends the custom agent's own args", () => {
+    const ca: CustomAgent = {
+      id: "1",
+      label: "Mine",
+      cmd: "my-agent",
+      args: ["--model", "x"],
+    };
+    const spec = buildStaticTabSpec(customAgentToItem(ca), "/proj", "Proj");
+    expect(spec.args).toEqual(["--model", "x"]);
+  });
+
+  it("promotes a custom agent with a resume flag to restart-resumable", () => {
+    const ca: CustomAgent = {
+      id: "1",
+      label: "Mine",
+      cmd: "my-agent",
+      resumeArgs: ["--continue"],
+    };
+    const spec = buildStaticTabSpec(customAgentToItem(ca), "/proj", "Proj");
+    expect(spec.resumeArgs).toEqual(["--continue"]);
+    // A session id is minted so the tab satisfies the persistence gate, and the
+    // tab is tagged with the ELDRUN_TAB_UID env var like the built-in resumables.
+    expect(typeof spec.sessionId).toBe("string");
+    expect(spec.env?.ELDRUN_TAB_UID).toBe(spec.sessionId);
+    expect(isResumableAgentTab({ ...spec })).toBe(true);
+  });
+});
+
+describe("agentMenuEntries", () => {
+  const custom: CustomAgent[] = [
+    { id: "a", label: "Present", cmd: "here" },
+    { id: "b", label: "Absent", cmd: "gone" },
+  ];
+
+  it("lists installed built-ins, then custom agents, then the add row", () => {
+    const entries = agentMenuEntries({
+      installedBuiltins: new Set(["claude"]),
+      installedCmds: new Set(["here"]),
+      customAgents: custom,
+      pick: () => {},
+      onAddCustom: () => {},
+    });
+    const labels = entries.map((e) => e.label);
+    expect(labels).toEqual(["Claude", "Present", "Absent (not found)", "Add agent…"]);
+    // The known-missing custom agent is greyed out; the present one is pickable.
+    const present = entries.find((e) => e.key === "custom:a");
+    const absent = entries.find((e) => e.key === "custom:b");
+    expect(present?.disabled).toBeFalsy();
+    expect(absent?.disabled).toBe(true);
+  });
+
+  it("hides built-ins until their probe resolves, but the add row is always present", () => {
+    const entries = agentMenuEntries({
+      installedBuiltins: null,
+      installedCmds: null,
+      customAgents: [],
+      pick: () => {},
+      onAddCustom: () => {},
+    });
+    expect(entries.map((e) => e.key)).toEqual(["__add_custom_agent__"]);
+  });
+});
diff --git a/src/__tests__/DecideDetachedDrop.test.ts b/src/__tests__/DecideDetachedDrop.test.ts
new file mode 100644
index 0000000..ea4a8d0
--- /dev/null
+++ b/src/__tests__/DecideDetachedDrop.test.ts
@@ -0,0 +1,91 @@
+/**
+ * #42: the UNIFIED cross-window drop decision (`decideDetachedTabDrop` /
+ * `decideDetachedGroupDrop`). These pure functions choose ONE destination for a
+ * dragged popout tab/group the SAME way regardless of which window the drag began
+ * in — the main-window host (`CenterPanel`'s `DETACHED_DRAG_END`) dispatches on
+ * their result. Guards the two reported bugs at the decision level:
+ *   • Shift over the SOURCE popout must resolve to `newWindow`, not a local no-op
+ *     (the old "shift-drop over same popout hangs" bug).
+ *   • A tab over a SIBLING popout must resolve to `dockDetached`, not `newWindow`
+ *     (the old "popout→popout spawns a stray window" bug).
+ */
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn() }));
+
+import { decideDetachedTabDrop, decideDetachedGroupDrop } from "../stores/detached";
+
+const base = {
+  cancelled: false,
+  shift: false,
+  inMain: false,
+  overPopoutId: null as string | null,
+  srcGroupId: "src",
+};
+
+describe("decideDetachedTabDrop", () => {
+  it("cancelled → local (the source popout already handled it / no-op)", () => {
+    expect(decideDetachedTabDrop({ ...base, cancelled: true }).kind).toBe("local");
+    // Cancel wins even when shift / inMain / a sibling are also set.
+    expect(
+      decideDetachedTabDrop({
+        ...base,
+        cancelled: true,
+        shift: true,
+        inMain: true,
+        overPopoutId: "b",
+      }).kind,
+    ).toBe("local");
+  });
+
+  it("Shift → newWindow, overriding main, sibling, and the source popout", () => {
+    expect(decideDetachedTabDrop({ ...base, shift: true }).kind).toBe("newWindow");
+    expect(decideDetachedTabDrop({ ...base, shift: true, inMain: true }).kind).toBe("newWindow");
+    expect(decideDetachedTabDrop({ ...base, shift: true, overPopoutId: "b" }).kind).toBe(
+      "newWindow",
+    );
+    // Shift over the SOURCE popout itself — the old hang — now resolves cleanly.
+    expect(decideDetachedTabDrop({ ...base, shift: true, overPopoutId: "src" }).kind).toBe(
+      "newWindow",
+    );
+  });
+
+  it("over a SIBLING popout → dockDetached into it (wins over inMain)", () => {
+    expect(decideDetachedTabDrop({ ...base, overPopoutId: "b" })).toEqual({
+      kind: "dockDetached",
+      toGroupId: "b",
+    });
+    // A popout overlapping the main window: the popout wins.
+    expect(
+      decideDetachedTabDrop({ ...base, overPopoutId: "b", inMain: true }).kind,
+    ).toBe("dockDetached");
+  });
+
+  it("the SOURCE popout is never a sibling dock target", () => {
+    // overPopoutId === source is ignored (a self-drop is committed locally in the
+    // popout); with no shift and not inMain it falls through to free-space newWindow.
+    expect(decideDetachedTabDrop({ ...base, overPopoutId: "src" }).kind).toBe("newWindow");
+    expect(decideDetachedTabDrop({ ...base, overPopoutId: "src", inMain: true }).kind).toBe(
+      "dockMain",
+    );
+  });
+
+  it("over the MAIN window → dockMain; free space → newWindow", () => {
+    expect(decideDetachedTabDrop({ ...base, inMain: true }).kind).toBe("dockMain");
+    expect(decideDetachedTabDrop({ ...base }).kind).toBe("newWindow");
+  });
+});
+
+describe("decideDetachedGroupDrop", () => {
+  it("Shift / cancelled / free space / sibling popout → float (stays its own window)", () => {
+    expect(decideDetachedGroupDrop({ ...base, shift: true }).kind).toBe("float");
+    expect(decideDetachedGroupDrop({ ...base, cancelled: true }).kind).toBe("float");
+    expect(decideDetachedGroupDrop({ ...base }).kind).toBe("float");
+    expect(decideDetachedGroupDrop({ ...base, overPopoutId: "b" }).kind).toBe("float");
+  });
+
+  it("over the MAIN window → dockMain, but Shift over main still floats", () => {
+    expect(decideDetachedGroupDrop({ ...base, inMain: true }).kind).toBe("dockMain");
+    expect(decideDetachedGroupDrop({ ...base, shift: true, inMain: true }).kind).toBe("float");
+  });
+});
diff --git a/src/__tests__/DeckExport.test.ts b/src/__tests__/DeckExport.test.ts
new file mode 100644
index 0000000..6f35d34
--- /dev/null
+++ b/src/__tests__/DeckExport.test.ts
@@ -0,0 +1,423 @@
+/**
+ * Tests for text layout (`deck/fonts`) and the PDF export (`deck/export`).
+ *
+ * The fonts half matters because **the editor and the exporter share it** — that
+ * shared measurement is the only thing preventing the classic
+ * WYSIWYG-over-PDF failure where the export silently reflows a paragraph.
+ *
+ * The export half is deliberately structural rather than pixel-exact: it asserts
+ * page counts, that every object kind draws without throwing, and — most
+ * usefully — that the things pdf-lib *cannot* do (crop an image, embed a GIF,
+ * find a missing icon) surface as warnings instead of vanishing.
+ */
+
+import { describe, it, expect, beforeAll } from "vitest";
+import { PDFDocument, StandardFonts } from "pdf-lib";
+import {
+  type TextMetrics,
+  listMarker,
+  loadMetrics,
+  lineOffset,
+  standardFontFor,
+  wrapText,
+} from "../lib/viewers/deck/fonts";
+import { exportDeck, exportPathFor } from "../lib/viewers/deck/export";
+import {
+  type Deck,
+  type DeckObject,
+  type TextStyle,
+  blankSlide,
+  defaultTextStyle,
+  emptyDeck,
+} from "../lib/viewers/deck/model";
+
+let metrics: TextMetrics;
+beforeAll(async () => {
+  metrics = await loadMetrics();
+});
+
+const style = (over: Partial<TextStyle> = {}): TextStyle => ({
+  ...defaultTextStyle(),
+  ...over,
+});
+
+describe("standard font mapping", () => {
+  it("maps each family and variant to its standard-14 face", () => {
+    expect(standardFontFor({ family: "sans", bold: false, italic: false })).toBe(
+      StandardFonts.Helvetica,
+    );
+    expect(standardFontFor({ family: "sans", bold: true, italic: true })).toBe(
+      StandardFonts.HelveticaBoldOblique,
+    );
+    expect(standardFontFor({ family: "serif", bold: true, italic: false })).toBe(
+      StandardFonts.TimesRomanBold,
+    );
+    expect(standardFontFor({ family: "mono", bold: false, italic: true })).toBe(
+      StandardFonts.CourierOblique,
+    );
+  });
+});
+
+describe("metrics", () => {
+  it("measures a wider string as wider, and bold as wider than regular", () => {
+    const s = style();
+    expect(metrics.width("iiii", s)).toBeLessThan(metrics.width("WWWW", s));
+    expect(metrics.width("Hello", s)).toBeLessThan(
+      metrics.width("Hello", style({ bold: true })),
+    );
+  });
+
+  it("scales linearly with size", () => {
+    const at10 = metrics.width("Hello", style({ size: 10 }));
+    const at20 = metrics.width("Hello", style({ size: 20 }));
+    expect(at20).toBeCloseTo(at10 * 2, 3);
+  });
+
+  it("gives an ascent smaller than the full height — that gap is the descender", () => {
+    const s = style({ size: 20 });
+    expect(metrics.ascent(s)).toBeGreaterThan(0);
+    expect(metrics.ascent(s)).toBeLessThan(metrics.height(s));
+  });
+
+  it("estimates rather than throwing on a character outside WinAnsi", () => {
+    // A CJK glyph the standard-14 fonts cannot measure. It must not return 0,
+    // which would collapse the line.
+    expect(metrics.width("漢字漢字", style())).toBeGreaterThan(0);
+  });
+});
+
+describe("wrapText", () => {
+  const s = style({ size: 12 });
+
+  it("keeps a short line whole", () => {
+    const lines = wrapText(metrics, "Hello world", s, 500);
+    expect(lines).toHaveLength(1);
+    expect(lines[0].text).toBe("Hello world");
+  });
+
+  it("breaks on words, and every line fits", () => {
+    const lines = wrapText(metrics, "the quick brown fox jumps over the lazy dog", s, 60);
+    expect(lines.length).toBeGreaterThan(1);
+    for (const l of lines) expect(l.width).toBeLessThanOrEqual(60.001);
+  });
+
+  it("never leaves trailing whitespace measured into a line", () => {
+    const lines = wrapText(metrics, "alpha beta gamma delta", s, 50);
+    for (const l of lines) expect(l.text).toBe(l.text.trimEnd());
+  });
+
+  it("breaks a single over-long word by character rather than overflowing", () => {
+    const lines = wrapText(metrics, "https://example.com/a/very/long/path/indeed", s, 40);
+    expect(lines.length).toBeGreaterThan(1);
+    for (const l of lines) expect(l.width).toBeLessThanOrEqual(40.001);
+  });
+
+  it("always breaks at an explicit newline", () => {
+    const lines = wrapText(metrics, "one\ntwo\nthree", s, 1000);
+    expect(lines.map((l) => l.text)).toEqual(["one", "two", "three"]);
+    expect(lines.map((l) => l.source)).toEqual([0, 1, 2]);
+  });
+
+  it("keeps an empty line rather than swallowing it", () => {
+    const lines = wrapText(metrics, "a\n\nb", s, 1000);
+    expect(lines).toHaveLength(3);
+    expect(lines[1].text).toBe("");
+  });
+
+  it("marks only the FIRST visual line of a wrapped list item", () => {
+    const lines = wrapText(
+      metrics,
+      "a list item long enough to wrap onto a second line\nsecond item",
+      s,
+      60,
+      { kind: "number", start: 1 },
+    );
+    const first = lines.filter((l) => l.source === 0);
+    expect(first.length).toBeGreaterThan(1);
+    expect(first[0].marker).toBe("1.");
+    expect(first.slice(1).every((l) => l.marker === undefined)).toBe(true);
+    expect(lines.find((l) => l.source === 1)?.marker).toBe("2.");
+  });
+
+  it("indents every line of a list, including the continuations", () => {
+    const lines = wrapText(metrics, "wrapping list item text here", s, 50, {
+      kind: "bullet",
+      start: 1,
+    });
+    expect(lines.every((l) => l.indent > 0)).toBe(true);
+    expect(new Set(lines.map((l) => l.indent)).size).toBe(1);
+  });
+});
+
+describe("list markers", () => {
+  it("spells each kind", () => {
+    expect(listMarker("bullet", 0, 1)).toBe("•");
+    expect(listMarker("number", 2, 1)).toBe("3.");
+    expect(listMarker("alpha", 0, 1)).toBe("a.");
+    expect(listMarker("roman", 3, 1)).toBe("iv.");
+  });
+
+  it("honours a non-1 start", () => {
+    expect(listMarker("number", 0, 5)).toBe("5.");
+  });
+
+  it("wraps alphabetic past 26 instead of producing 'aa'", () => {
+    expect(listMarker("alpha", 26, 1)).toBe("a.");
+  });
+});
+
+describe("lineOffset", () => {
+  const line = { text: "x", indent: 10, width: 30, source: 0 };
+  it("puts a left-aligned line at the indent", () => {
+    expect(lineOffset(line, style({ align: "left" }), 100)).toBe(10);
+  });
+  it("centres within the space after the indent, not the whole box", () => {
+    // avail = 100 - 10 = 90; (90 - 30) / 2 = 30; + indent.
+    expect(lineOffset(line, style({ align: "center" }), 100)).toBeCloseTo(40);
+  });
+  it("right-aligns to the box's far edge", () => {
+    expect(lineOffset(line, style({ align: "right" }), 100)).toBeCloseTo(70);
+  });
+  it("never produces a negative offset for a line wider than its box", () => {
+    const wide = { ...line, width: 500 };
+    expect(lineOffset(wide, style({ align: "center" }), 100)).toBe(10);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+
+/** A minimal single-page PDF to act as a base plate. */
+async function basePdf(pages = 1): Promise<Uint8Array> {
+  const doc = await PDFDocument.create();
+  for (let i = 0; i < pages; i += 1) doc.addPage([400, 200]);
+  return doc.save();
+}
+
+/** A 1×1 PNG. */
+const PNG_1PX = Uint8Array.from(
+  atob(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
+  ),
+  (c) => c.charCodeAt(0),
+);
+
+function deckWith(objects: DeckObject[], slides = 1): Deck {
+  const d = emptyDeck("talk.pdf");
+  d.pageWidth = 400;
+  d.pageHeight = 200;
+  d.slides = Array.from({ length: slides }, (_, i) => ({
+    ...blankSlide(i + 1),
+    objects: i === 0 ? objects : [],
+  }));
+  return d;
+}
+
+const common = { x: 0.1, y: 0.1, w: 0.3, h: 0.2, rot: 0, opacity: 1 };
+
+describe("exportDeck", () => {
+  it("writes one page per slide, from the base plate", async () => {
+    const r = await exportDeck({
+      deck: deckWith([], 3),
+      baseBytes: await basePdf(3),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.pages).toBe(3);
+    expect(r.warnings).toEqual([]);
+    // A real PDF, not an empty buffer.
+    expect(new TextDecoder().decode(r.bytes.slice(0, 5))).toBe("%PDF-");
+  });
+
+  it("still produces pages when there is no base plate at all", async () => {
+    const r = await exportDeck({
+      deck: deckWith([], 2),
+      baseBytes: null,
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.pages).toBe(2);
+  });
+
+  it("draws every object kind without throwing", async () => {
+    const objects: DeckObject[] = [
+      {
+        ...common,
+        id: "t",
+        kind: "text",
+        text: "Hello\nthere",
+        style: style(),
+        padding: 2,
+        list: { kind: "bullet", start: 1 },
+        fill: "#eeeeee",
+      },
+      {
+        ...common,
+        id: "s",
+        kind: "shape",
+        shape: "arrow",
+        stroke: "#ff0000",
+        strokeWidth: 2,
+        head: "arrow",
+        tail: "dot",
+      },
+      { ...common, id: "i", kind: "icon", icon: "star", color: "#0000ff", strokeWidth: 1.5 },
+      { ...common, id: "m", kind: "image", src: "pic.png", fit: "contain" },
+    ];
+    const r = await exportDeck({
+      deck: deckWith(objects),
+      baseBytes: await basePdf(),
+      images: new Map([["pic.png", PNG_1PX]]),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.pages).toBe(1);
+    expect(r.warnings).toEqual([]);
+  });
+
+  it("draws rotated objects too", async () => {
+    const r = await exportDeck({
+      deck: deckWith([
+        { ...common, id: "s", kind: "shape", shape: "rect", stroke: "#000000", strokeWidth: 1, rot: 37 },
+        {
+          ...common,
+          id: "t",
+          kind: "text",
+          text: "tilted",
+          style: style(),
+          padding: 1,
+          rot: -12,
+        },
+      ]),
+      baseBytes: await basePdf(),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.warnings).toEqual([]);
+  });
+
+  it("skips a hidden object", async () => {
+    const r = await exportDeck({
+      deck: deckWith([
+        { ...common, id: "m", kind: "image", src: "gone.png", fit: "contain", hidden: true },
+      ]),
+      baseBytes: await basePdf(),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    // Hidden, so its absent bytes are not even looked for.
+    expect(r.warnings).toEqual([]);
+  });
+
+  it("WARNS rather than silently dropping a missing image", async () => {
+    const r = await exportDeck({
+      deck: deckWith([{ ...common, id: "m", kind: "image", src: "gone.png", fit: "contain" }]),
+      baseBytes: await basePdf(),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.warnings.join(" ")).toContain("gone.png");
+  });
+
+  it("warns that `cover` cannot be cropped, and fits instead", async () => {
+    const r = await exportDeck({
+      deck: deckWith([{ ...common, id: "m", kind: "image", src: "pic.png", fit: "cover" }]),
+      baseBytes: await basePdf(),
+      images: new Map([["pic.png", PNG_1PX]]),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.warnings.join(" ")).toContain("cover");
+  });
+
+  it("warns about an icon this build does not have", async () => {
+    const r = await exportDeck({
+      deck: deckWith([
+        { ...common, id: "i", kind: "icon", icon: "from-the-future", color: "#000000", strokeWidth: 1 },
+      ]),
+      baseBytes: await basePdf(),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.warnings.join(" ")).toContain("from-the-future");
+  });
+
+  it("writes a poster PAGE for an interstitial, between its slides", async () => {
+    const deck = deckWith([], 2);
+    deck.slides[0].after = {
+      id: "g1",
+      src: "anim.gif",
+      fit: "contain",
+      background: "#000000",
+      advance: { on: "manual" },
+      poster: 0,
+    };
+    const r = await exportDeck({
+      deck,
+      baseBytes: await basePdf(2),
+      images: new Map(),
+      posters: new Map([["g1", PNG_1PX]]),
+      metrics,
+    });
+    expect(r.pages).toBe(3); // slide, poster, slide
+    expect(r.warnings).toEqual([]);
+  });
+
+  it("omits interstitial pages when the deck says not to", async () => {
+    const deck = deckWith([], 2);
+    deck.theme.exportInterstitials = false;
+    deck.slides[0].after = {
+      id: "g1",
+      src: "anim.gif",
+      fit: "contain",
+      background: "#000000",
+      advance: { on: "manual" },
+      poster: 0,
+    };
+    const r = await exportDeck({
+      deck,
+      baseBytes: await basePdf(2),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.pages).toBe(2);
+  });
+
+  it("produces a valid one-page PDF for a deck with no slides at all", async () => {
+    const r = await exportDeck({
+      deck: emptyDeck(null),
+      baseBytes: null,
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.pages).toBe(1);
+    expect(r.warnings.join(" ")).toContain("no slides");
+  });
+
+  it("survives a corrupt base plate instead of failing the whole export", async () => {
+    const r = await exportDeck({
+      deck: deckWith([], 2),
+      baseBytes: new Uint8Array([1, 2, 3, 4]),
+      images: new Map(),
+      posters: new Map(),
+      metrics,
+    });
+    expect(r.pages).toBe(2); // blank pages at the deck's own size
+    expect(r.warnings.join(" ")).toContain("base PDF");
+  });
+});
+
+describe("exportPathFor", () => {
+  it("names the output beside the deck", () => {
+    expect(exportPathFor("/p/talk.eldeck.json")).toBe("/p/talk.export.pdf");
+  });
+});
diff --git a/src/__tests__/DeckModel.test.ts b/src/__tests__/DeckModel.test.ts
new file mode 100644
index 0000000..2131c21
--- /dev/null
+++ b/src/__tests__/DeckModel.test.ts
@@ -0,0 +1,231 @@
+/**
+ * Tests for the deck model (`lib/viewers/deck/model`) — the native presenter's
+ * pure core (`docs/deck_presenter_plan.md`).
+ *
+ * The cases worth reading are the ones encoding a decision rather than a
+ * mechanism: that `locked` is enforced in the model and not at every call site,
+ * that a raise of several adjacent objects moves them as a block instead of
+ * deadlocking against each other, that distribution equalises *gaps* rather than
+ * origins, and that the presenter sequence expands builds and interstitials into
+ * one flat list so `←` can step a build backwards.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  type Deck,
+  type DeckObject,
+  type ObjectList,
+  type Slide,
+  addObject,
+  alignObjects,
+  blankSlide,
+  boundingBox,
+  distributeObjects,
+  duplicateObjects,
+  emptyDeck,
+  lowerObjects,
+  maxBuildStep,
+  moveObjects,
+  moveSlides,
+  raiseObjects,
+  removeObjects,
+  resetIdCounter,
+  sequence,
+  setIdSuffixSource,
+  stagger,
+  toBack,
+  toFront,
+  updateObjects,
+  visibleAt,
+} from "../lib/viewers/deck/model";
+
+/** A deterministic id source, so assertions can name ids. */
+beforeEach(() => {
+  resetIdCounter();
+  setIdSuffixSource(() => "");
+});
+
+function box(id: string, x: number, y: number, w = 0.1, h = 0.1): DeckObject {
+  return {
+    id,
+    kind: "shape",
+    shape: "rect",
+    stroke: "#111111",
+    strokeWidth: 1,
+    x,
+    y,
+    w,
+    h,
+    rot: 0,
+    opacity: 1,
+  };
+}
+
+describe("object list ops", () => {
+  it("appends on top, because the list IS the z-order", () => {
+    const list = addObject([box("a", 0, 0)], box("b", 0.5, 0.5));
+    expect(list.map((o) => o.id)).toEqual(["a", "b"]);
+  });
+
+  it("skips locked objects on update, move and remove", () => {
+    const list: ObjectList = [{ ...box("a", 0, 0), locked: true }, box("b", 0, 0)];
+
+    expect(moveObjects(list, ["a", "b"], 0.1, 0.1).map((o) => o.x)).toEqual([0, 0.1]);
+    expect(removeObjects(list, ["a", "b"]).map((o) => o.id)).toEqual(["a"]);
+    expect(
+      updateObjects(list, ["a", "b"], (o) => ({ ...o, opacity: 0.5 })).map((o) => o.opacity),
+    ).toEqual([1, 0.5]);
+  });
+
+  it("duplicates with fresh ids, offset so the copy is visible", () => {
+    const { list, ids } = duplicateObjects([box("a", 0.2, 0.2)], ["a"]);
+    expect(list).toHaveLength(2);
+    expect(ids).toHaveLength(1);
+    expect(ids[0]).not.toBe("a");
+    expect(list[1].x).toBeCloseTo(0.22);
+    expect(list[1].y).toBeCloseTo(0.22);
+  });
+});
+
+describe("z-order", () => {
+  const list = [box("a", 0, 0), box("b", 0, 0), box("c", 0, 0), box("d", 0, 0)];
+
+  it("moves a multi-selection to front as a block, preserving its order", () => {
+    expect(toFront(list, ["a", "c"]).map((o) => o.id)).toEqual(["b", "d", "a", "c"]);
+    expect(toBack(list, ["b", "d"]).map((o) => o.id)).toEqual(["b", "d", "a", "c"]);
+  });
+
+  it("raises adjacent selected objects together instead of deadlocking", () => {
+    // b and c are adjacent and both selected. Swapping naively from the bottom
+    // would have b swap with c (both selected), leaving the block where it was.
+    expect(raiseObjects(list, ["b", "c"]).map((o) => o.id)).toEqual(["a", "d", "b", "c"]);
+    expect(lowerObjects(list, ["b", "c"]).map((o) => o.id)).toEqual(["b", "c", "a", "d"]);
+  });
+
+  it("leaves the topmost object alone on raise", () => {
+    expect(raiseObjects(list, ["d"]).map((o) => o.id)).toEqual(["a", "b", "c", "d"]);
+    expect(lowerObjects(list, ["a"]).map((o) => o.id)).toEqual(["a", "b", "c", "d"]);
+  });
+});
+
+describe("align", () => {
+  it("aligns a SINGLE object to the page — otherwise it would be a no-op", () => {
+    const list = [box("a", 0.3, 0.3, 0.2, 0.2)];
+    expect(alignObjects(list, ["a"], "left")[0].x).toBeCloseTo(0);
+    expect(alignObjects(list, ["a"], "hcenter")[0].x).toBeCloseTo(0.4);
+    expect(alignObjects(list, ["a"], "right")[0].x).toBeCloseTo(0.8);
+    expect(alignObjects(list, ["a"], "bottom")[0].y).toBeCloseTo(0.8);
+  });
+
+  it("aligns a multi-selection to its own bounding box", () => {
+    const list = [box("a", 0.2, 0, 0.1, 0.1), box("b", 0.5, 0, 0.3, 0.1)];
+    const out = alignObjects(list, ["a", "b"], "left");
+    expect(out.map((o) => o.x)).toEqual([0.2, 0.2]);
+
+    const right = alignObjects(list, ["a", "b"], "right");
+    // Bounding box spans 0.2 → 0.8, so both far edges land on 0.8.
+    expect(right[0].x).toBeCloseTo(0.7);
+    expect(right[1].x).toBeCloseTo(0.5);
+  });
+});
+
+describe("distribute", () => {
+  it("equalises the GAPS, not the origins, so mixed widths look right", () => {
+    const list = [
+      box("a", 0, 0, 0.1, 0.1),
+      box("b", 0.3, 0, 0.4, 0.1), // deliberately much wider
+      box("c", 0.9, 0, 0.1, 0.1),
+    ];
+    const out = distributeObjects(list, ["a", "b", "c"], "h");
+    const by = (id: string) => out.find((o) => o.id === id)!;
+    const gap1 = by("b").x - (by("a").x + by("a").w);
+    const gap2 = by("c").x - (by("b").x + by("b").w);
+    expect(gap1).toBeCloseTo(gap2);
+    // The outermost two must not move.
+    expect(by("a").x).toBeCloseTo(0);
+    expect(by("c").x).toBeCloseTo(0.9);
+  });
+
+  it("needs three objects to mean anything", () => {
+    const list = [box("a", 0, 0), box("b", 0.5, 0)];
+    expect(distributeObjects(list, ["a", "b"], "h")).toEqual(list);
+  });
+});
+
+describe("bounding box", () => {
+  it("is the tight box, and is zero for nothing", () => {
+    expect(boundingBox([])).toEqual({ x: 0, y: 0, w: 0, h: 0 });
+    const b = boundingBox([box("a", 0.2, 0.1, 0.1, 0.1), box("b", 0.5, 0.4, 0.2, 0.2)]);
+    expect(b.x).toBeCloseTo(0.2);
+    expect(b.y).toBeCloseTo(0.1);
+    expect(b.w).toBeCloseTo(0.5);
+    expect(b.h).toBeCloseTo(0.5);
+  });
+});
+
+describe("slides", () => {
+  it("moves a block using the survivor-index convention pageModel uses", () => {
+    const slides = [1, 2, 3, 4].map((p) => ({ ...blankSlide(p), id: `s${p}` }));
+    // "insert before the 0th survivor" — the survivors are s1, s2, s4.
+    expect(moveSlides(slides, ["s3"], 0).map((s) => s.id)).toEqual(["s3", "s1", "s2", "s4"]);
+    // An index past the end appends.
+    expect(moveSlides(slides, ["s1"], 99).map((s) => s.id)).toEqual(["s2", "s3", "s4", "s1"]);
+  });
+});
+
+describe("presenter sequence", () => {
+  function deckWith(slides: Slide[]): Deck {
+    return { ...emptyDeck("talk.pdf"), slides };
+  }
+
+  it("expands each slide's build steps into its own stop", () => {
+    const s = blankSlide(1);
+    s.objects = [
+      { ...box("a", 0, 0), build: { step: 0, effect: "fade" } },
+      { ...box("b", 0, 0), build: { step: 2, effect: "fade" } },
+    ];
+    expect(maxBuildStep(s)).toBe(2);
+    expect(sequence(deckWith([s]))).toEqual([
+      { kind: "slide", slide: 0, step: 0 },
+      { kind: "slide", slide: 0, step: 1 },
+      { kind: "slide", slide: 0, step: 2 },
+    ]);
+  });
+
+  it("puts an interstitial BETWEEN two slides, as its own stop", () => {
+    const a = blankSlide(1);
+    a.after = {
+      id: "g1",
+      src: "anim.gif",
+      fit: "contain",
+      background: "#000000",
+      advance: { on: "manual" },
+      poster: 0,
+    };
+    const b = blankSlide(2);
+    expect(sequence(deckWith([a, b]))).toEqual([
+      { kind: "slide", slide: 0, step: 0 },
+      { kind: "interstitial", slide: 0 },
+      { kind: "slide", slide: 1, step: 0 },
+    ]);
+  });
+
+  it("hides an object until its build step, and never shows a hidden one", () => {
+    const shown = { ...box("a", 0, 0), build: { step: 2, effect: "fade" as const } };
+    expect(visibleAt(shown, 1)).toBe(false);
+    expect(visibleAt(shown, 2)).toBe(true);
+    expect(visibleAt({ ...shown, hidden: true }, 5)).toBe(false);
+    // No build at all = visible on entry.
+    expect(visibleAt(box("b", 0, 0), 0)).toBe(true);
+  });
+});
+
+describe("stagger", () => {
+  it("assigns consecutive steps in paint order — the one-click list reveal", () => {
+    const list = [box("a", 0, 0), box("b", 0, 0), box("c", 0, 0)];
+    const out = stagger(list, ["c", "a", "b"], 1);
+    // Paint order wins over the order the ids were passed in.
+    expect(out.map((o) => o.build?.step)).toEqual([1, 2, 3]);
+    expect(out.every((o) => o.build?.effect === "fade")).toBe(true);
+  });
+});
diff --git a/src/__tests__/DeckPresent.test.ts b/src/__tests__/DeckPresent.test.ts
new file mode 100644
index 0000000..8efa648
--- /dev/null
+++ b/src/__tests__/DeckPresent.test.ts
@@ -0,0 +1,237 @@
+/**
+ * Tests for the dual-window presenter's link (`lib/viewers/deck/present`) —
+ * the protocol and the navigation arithmetic the two windows share
+ * (`docs/deck_presenter_plan.md` §6).
+ *
+ * The cases worth reading are the ones that encode a decision. That the window
+ * label is derived from the deck's *path*, so opening the second display twice
+ * for one talk targets one window rather than stacking two on the projector.
+ * That `?present=` is validated rather than trusted, since it names a window and
+ * lands in a URL. That `←` from a build steps the build back while `↑` skips the
+ * whole slide — the difference between surviving an audience question and losing
+ * the slide to it. And that both windows share ONE key→action map, because a
+ * clicker bound to whichever display has focus must not mean two different
+ * things.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  type NavAction,
+  applyNav,
+  clampStop,
+  keyToAction,
+  parsePresentParam,
+  presentSeedEvent,
+  presentStateEvent,
+  presenterLabel,
+  slideStopIndex,
+  stepSlide,
+} from "../lib/viewers/deck/present";
+import { type Deck, emptyDeck, blankSlide, sequence } from "../lib/viewers/deck/model";
+
+/** A deck of three slides: the middle one has two builds, the first a GIF after it. */
+function deckFixture(): Deck {
+  const deck = emptyDeck("talk.pdf");
+  const s0 = blankSlide(1);
+  const s1 = blankSlide(2);
+  const s2 = blankSlide(3);
+  s0.after = {
+    id: "gif1",
+    src: "clip.gif",
+    fit: "contain",
+    background: "#000000",
+    advance: { on: "manual" },
+    poster: 0,
+  };
+  s1.objects = [
+    {
+      id: "a",
+      kind: "text",
+      text: "one",
+      style: deck.theme.text,
+      padding: 2,
+      x: 0.1,
+      y: 0.1,
+      w: 0.2,
+      h: 0.1,
+      rot: 0,
+      opacity: 1,
+      build: { step: 1, effect: "fade" },
+    },
+    {
+      id: "b",
+      kind: "text",
+      text: "two",
+      style: deck.theme.text,
+      padding: 2,
+      x: 0.1,
+      y: 0.3,
+      w: 0.2,
+      h: 0.1,
+      rot: 0,
+      opacity: 1,
+      build: { step: 2, effect: "fade" },
+    },
+  ];
+  return { ...deck, slides: [s0, s1, s2] };
+}
+
+describe("window identity", () => {
+  it("derives one stable label per deck path", () => {
+    const a = presenterLabel("/home/x/talk.eldeck.json");
+    expect(a).toBe(presenterLabel("/home/x/talk.eldeck.json"));
+    // Opening the second display for a DIFFERENT deck must not re-use the window
+    // already showing the first one.
+    expect(a).not.toBe(presenterLabel("/home/x/other.eldeck.json"));
+    // The prefix is load-bearing: it is what `capabilities/default.json` grants
+    // window permissions by, and what the backend validates.
+    expect(a.startsWith("present-")).toBe(true);
+    expect(/^present-[A-Za-z0-9_-]+$/.test(a)).toBe(true);
+  });
+
+  it("accepts only a well-formed ?present= label", () => {
+    const label = presenterLabel("/tmp/t.eldeck.json");
+    expect(parsePresentParam(`?present=${label}`)).toBe(label);
+    // Absent → the ordinary shell renders.
+    expect(parsePresentParam("")).toBeNull();
+    expect(parsePresentParam("?detached=p:g1")).toBeNull();
+    // The value names a window and goes into a URL, so anything shaped wrong is
+    // refused here rather than handed on.
+    expect(parsePresentParam("?present=main")).toBeNull();
+    expect(parsePresentParam("?present=present-../etc")).toBeNull();
+    expect(parsePresentParam("?present=present-")).toBeNull();
+  });
+
+  it("namespaces the seed and state channels per window", () => {
+    expect(presentSeedEvent("present-a")).not.toBe(presentSeedEvent("present-b"));
+    expect(presentStateEvent("present-a")).not.toBe(presentSeedEvent("present-a"));
+  });
+});
+
+describe("navigation", () => {
+  const deck = deckFixture();
+  const stops = sequence(deck);
+
+  it("flattens builds and interstitials into one ordered list", () => {
+    // slide 0 (step 0) · its GIF · slide 1 steps 0,1,2 · slide 2 (step 0)
+    expect(stops).toEqual([
+      { kind: "slide", slide: 0, step: 0 },
+      { kind: "interstitial", slide: 0 },
+      { kind: "slide", slide: 1, step: 0 },
+      { kind: "slide", slide: 1, step: 1 },
+      { kind: "slide", slide: 1, step: 2 },
+      { kind: "slide", slide: 2, step: 0 },
+    ]);
+  });
+
+  it("clamps at both ends instead of wrapping", () => {
+    // Wrapping mid-talk sends you to slide 1 in front of a room.
+    expect(clampStop(stops, -3)).toBe(0);
+    expect(clampStop(stops, 99)).toBe(stops.length - 1);
+    expect(applyNav(stops, 0, { kind: "prev" })).toBe(0);
+    expect(applyNav(stops, stops.length - 1, { kind: "next" })).toBe(stops.length - 1);
+  });
+
+  it("steps a build backwards rather than losing the slide", () => {
+    // Sitting on slide 1's second build; `←` must undo that reveal.
+    const at = stops.findIndex((s) => s.kind === "slide" && s.slide === 1 && s.step === 2);
+    expect(applyNav(stops, at, { kind: "prev" })).toBe(at - 1);
+    expect(stops[at - 1]).toEqual({ kind: "slide", slide: 1, step: 1 });
+  });
+
+  it("enters an interstitial rather than skipping past it", () => {
+    expect(applyNav(stops, 0, { kind: "next" })).toBe(1);
+    expect(stops[1].kind).toBe("interstitial");
+    // …and leaving it lands on the next slide, so it costs exactly one stop.
+    expect(stops[applyNav(stops, 1, { kind: "next" })]).toEqual({
+      kind: "slide",
+      slide: 1,
+      step: 0,
+    });
+  });
+
+  it("skips the remaining builds on a whole-slide step", () => {
+    const at = stops.findIndex((s) => s.kind === "slide" && s.slide === 1 && s.step === 0);
+    expect(stops[stepSlide(stops, at, 1)]).toEqual({ kind: "slide", slide: 2, step: 0 });
+    // Backwards lands on the slide's ENTRY stop, not its last build: a slide you
+    // go back to should look the way the room first saw it.
+    expect(stops[stepSlide(stops, at, -1)]).toEqual({ kind: "slide", slide: 0, step: 0 });
+  });
+
+  it("does nothing when a whole-slide step would run off the deck", () => {
+    const last = stops.length - 1;
+    expect(stepSlide(stops, last, 1)).toBe(last);
+    expect(stepSlide(stops, 0, -1)).toBe(0);
+  });
+
+  it("jumps to a slide's entry stop, and refuses a slide that is not there", () => {
+    expect(slideStopIndex(stops, 2)).toBe(stops.length - 1);
+    expect(slideStopIndex(stops, 7)).toBe(-1);
+    const at = 3;
+    expect(applyNav(stops, at, { kind: "goto", slide: 7 })).toBe(at);
+    expect(stops[applyNav(stops, at, { kind: "goto", slide: 0 })]).toEqual({
+      kind: "slide",
+      slide: 0,
+      step: 0,
+    });
+  });
+
+  it("leaves the index alone for the actions that are not movements", () => {
+    const at = 2;
+    for (const action of [
+      { kind: "close" },
+      { kind: "blank", mode: "black" },
+    ] as NavAction[]) {
+      expect(applyNav(stops, at, action)).toBe(at);
+    }
+  });
+
+  it("first/last reach the ends of a deck with builds", () => {
+    expect(applyNav(stops, 3, { kind: "first" })).toBe(0);
+    expect(applyNav(stops, 0, { kind: "last" })).toBe(stops.length - 1);
+  });
+
+  it("handles an empty deck without throwing", () => {
+    const empty = sequence(emptyDeck(null));
+    expect(applyNav(empty, 0, { kind: "next" })).toBe(0);
+    expect(stepSlide(empty, 0, 1)).toBe(0);
+    expect(slideStopIndex(empty, 0)).toBe(-1);
+  });
+});
+
+describe("the shared key map", () => {
+  it("gives both windows the same meaning for the same key", () => {
+    expect(keyToAction(" ")).toEqual({ kind: "next" });
+    expect(keyToAction("ArrowRight")).toEqual({ kind: "next" });
+    expect(keyToAction("PageDown")).toEqual({ kind: "next" });
+    expect(keyToAction("ArrowLeft")).toEqual({ kind: "prev" });
+    expect(keyToAction("PageUp")).toEqual({ kind: "prev" });
+    expect(keyToAction("ArrowDown")).toEqual({ kind: "slide", delta: 1 });
+    expect(keyToAction("ArrowUp")).toEqual({ kind: "slide", delta: -1 });
+    expect(keyToAction("Home")).toEqual({ kind: "first" });
+    expect(keyToAction("End")).toEqual({ kind: "last" });
+    expect(keyToAction("Escape")).toEqual({ kind: "close" });
+  });
+
+  it("treats B and W as the two blank screens, either case", () => {
+    expect(keyToAction("b")).toEqual({ kind: "blank", mode: "black" });
+    expect(keyToAction("B")).toEqual({ kind: "blank", mode: "black" });
+    expect(keyToAction("w")).toEqual({ kind: "blank", mode: "white" });
+    expect(keyToAction("W")).toEqual({ kind: "blank", mode: "white" });
+  });
+
+  it("reports digits for the caller to accumulate into a goto", () => {
+    expect(keyToAction("4")).toEqual({ kind: "digit", digit: "4" });
+    // Enter is deliberately NOT claimed here: only the caller knows whether a
+    // number is pending.
+    expect(keyToAction("Enter")).toBeNull();
+  });
+
+  it("claims nothing it does not own", () => {
+    // The presenter window's own overlays (G/N/D) never reach this map, so they
+    // stay local to the speaker's screen.
+    for (const k of ["g", "n", "d", "F5", "Tab", "a"]) {
+      expect(keyToAction(k)).toBeNull();
+    }
+  });
+});
diff --git a/src/__tests__/DeckSidecar.test.ts b/src/__tests__/DeckSidecar.test.ts
new file mode 100644
index 0000000..9e46e57
--- /dev/null
+++ b/src/__tests__/DeckSidecar.test.ts
@@ -0,0 +1,403 @@
+/**
+ * Tests for the deck sidecar (`lib/viewers/deck/sidecar`).
+ *
+ * Two properties carry the whole feature and are tested hardest here:
+ *
+ *  1. **Parsing never throws and never cascades.** A deck is hand-editable text
+ *     under git, so one badly merged object must not cost the author the other
+ *     twenty slides.
+ *  2. **Re-anchoring never silently drops a layer.** TeX rewrites the base PDF on
+ *     every compile; inserting one slide renumbers every page after it. Anything
+ *     `reconcile` cannot place has to end up in `detached`, not in the bin.
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  type BasePage,
+  deckPathForPdf,
+  fingerprint,
+  normalizeDeck,
+  parseDeck,
+  pdfPathForDeck,
+  reattach,
+  reconcile,
+  serializeDeck,
+} from "../lib/viewers/deck/sidecar";
+import {
+  type Deck,
+  type DeckObject,
+  type Slide,
+  blankSlide,
+  emptyDeck,
+  resetIdCounter,
+  setIdSuffixSource,
+} from "../lib/viewers/deck/model";
+
+beforeEach(() => {
+  resetIdCounter();
+  setIdSuffixSource(() => "");
+});
+
+function textObj(id: string, text = "hello"): DeckObject {
+  return {
+    id,
+    kind: "text",
+    text,
+    style: {
+      family: "sans",
+      size: 14,
+      bold: false,
+      italic: false,
+      color: "#111111",
+      align: "left",
+      lineHeight: 1.25,
+    },
+    padding: 2,
+    x: 0.1,
+    y: 0.1,
+    w: 0.3,
+    h: 0.1,
+    rot: 0,
+    opacity: 1,
+  };
+}
+
+function page(n: number, text: string, lines?: number[]): BasePage {
+  return { page: n, width: 364, height: 205, text, ...(lines ? { lines } : {}) };
+}
+
+describe("TeX-figure objects", () => {
+  it("round-trips an image object's texSrc", () => {
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [
+        {
+          ...blankSlide(1),
+          objects: [
+            {
+              id: "o1",
+              kind: "image",
+              src: "talk.tex-figures/o1.png",
+              texSrc: "talk.tex-figures/o1.tex",
+              fit: "contain",
+              x: 0.1,
+              y: 0.1,
+              w: 0.2,
+              h: 0.2,
+              rot: 0,
+              opacity: 1,
+            },
+          ],
+        },
+      ],
+    };
+    const { deck: parsed } = parseDeck(serializeDeck(deck));
+    const obj = parsed.slides[0].objects[0] as Extract<DeckObject, { kind: "image" }>;
+    expect(obj.texSrc).toBe("talk.tex-figures/o1.tex");
+  });
+
+  it("drops texSrc for an ordinary image rather than inventing one", () => {
+    const { deck } = normalizeDeck({
+      slides: [
+        {
+          id: "s1",
+          anchor: { page: 1 },
+          objects: [{ kind: "image", src: "pic.png" }],
+        },
+      ],
+    });
+    const obj = deck.slides[0].objects[0] as Extract<DeckObject, { kind: "image" }>;
+    expect(obj.texSrc).toBeUndefined();
+  });
+});
+
+describe("paths", () => {
+  it("pairs a deck with its base PDF, both ways", () => {
+    expect(deckPathForPdf("/p/talk.pdf")).toBe("/p/talk.eldeck.json");
+    expect(deckPathForPdf("/p/talk.PDF")).toBe("/p/talk.eldeck.json");
+    expect(pdfPathForDeck("/p/talk.eldeck.json")).toBe("/p/talk.pdf");
+  });
+});
+
+describe("serialization", () => {
+  it("round-trips, and formats to diff line-by-line", () => {
+    const deck = { ...emptyDeck("talk.pdf"), slides: [blankSlide(1)] };
+    const text = serializeDeck(deck);
+    expect(text.endsWith("\n")).toBe(true);
+    expect(text.split("\n").length).toBeGreaterThan(10); // not one compact line
+    expect(parseDeck(text).deck).toEqual(deck);
+  });
+});
+
+describe("defensive parsing", () => {
+  it("returns an empty deck rather than throwing on junk", () => {
+    expect(parseDeck("{not json").error).toBeTruthy();
+    expect(parseDeck("[]").error).toBeTruthy();
+    expect(parseDeck("{not json").deck.slides).toEqual([]);
+  });
+
+  it("drops one unrenderable object without losing the rest of the slide", () => {
+    const { deck, repaired } = normalizeDeck({
+      slides: [
+        {
+          id: "s1",
+          anchor: { page: 1 },
+          objects: [
+            textObj("keep"),
+            { kind: "image" }, // no src — cannot render, cannot repair
+            { kind: "from-the-future" }, // a newer build's object
+          ],
+        },
+      ],
+    });
+    expect(deck.slides[0].objects.map((o) => o.id)).toEqual(["keep"]);
+    expect(repaired).toContain("object");
+  });
+
+  it("coerces out-of-range and wrong-typed fields to something renderable", () => {
+    const { deck } = normalizeDeck({
+      pageWidth: "wide",
+      slides: [
+        {
+          anchor: { page: -4 },
+          objects: [{ ...textObj("a"), opacity: 5, style: { size: -2, color: "puce" } }],
+        },
+      ],
+    });
+    expect(deck.pageWidth).toBeGreaterThan(0);
+    expect(deck.slides[0].anchor.page).toBe(1);
+    const o = deck.slides[0].objects[0] as Extract<DeckObject, { kind: "text" }>;
+    expect(o.opacity).toBe(1);
+    expect(o.style.size).toBeGreaterThan(0);
+    expect(o.style.color).toBe("#111111"); // "puce" is not a hex color
+  });
+
+  it("flags a deck written by a newer build instead of pretending it is fine", () => {
+    expect(normalizeDeck({ version: 99 }).repaired).toContain("newer");
+  });
+
+  it("mints ids for objects that lost theirs in a merge", () => {
+    const { deck } = normalizeDeck({
+      slides: [{ anchor: { page: 1 }, objects: [{ ...textObj("a"), id: undefined }] }],
+    });
+    expect(deck.slides[0].objects[0].id).toBeTruthy();
+  });
+});
+
+describe("fingerprint", () => {
+  it("survives an edit past the covered prefix", () => {
+    const head = "Introduction to the thing ".repeat(10); // comfortably > 200 chars
+    expect(fingerprint({ width: 364, height: 205, text: `${head} early ending` })).toBe(
+      fingerprint({ width: 364, height: 205, text: `${head} a completely different tail` }),
+    );
+  });
+
+  it("distinguishes two different slides, and two page sizes", () => {
+    const a = fingerprint({ width: 364, height: 205, text: "Results" });
+    const b = fingerprint({ width: 364, height: 205, text: "Method" });
+    const c = fingerprint({ width: 595, height: 842, text: "Results" });
+    expect(a).not.toBe(b);
+    expect(a).not.toBe(c);
+  });
+
+  it("ignores whitespace and case, which the extractor varies", () => {
+    expect(fingerprint({ width: 1, height: 1, text: "  A   B \n C " })).toBe(
+      fingerprint({ width: 1, height: 1, text: "a b c" }),
+    );
+  });
+});
+
+describe("reconcile", () => {
+  /** A two-slide deck whose second slide carries a layer. */
+  function deckOf(texts: string[], withLayerOn = 1): Deck {
+    const pages = texts.map((t, i) => page(i + 1, t));
+    const slides: Slide[] = texts.map((_t, i) => ({
+      ...blankSlide(i + 1),
+      id: `s${i + 1}`,
+      anchor: { page: i + 1, print: fingerprint(pages[i]) },
+      objects: i === withLayerOn ? [textObj(`o${i}`)] : [],
+    }));
+    return { ...emptyDeck("talk.pdf"), slides };
+  }
+
+  it("does nothing when nothing moved — the common case", () => {
+    const deck = deckOf(["Intro", "Method", "Results"]);
+    const pages = ["Intro", "Method", "Results"].map((t, i) => page(i + 1, t));
+    const r = reconcile(deck, pages);
+    expect(r.unchanged).toBe(true);
+    expect(r.moved).toBe(0);
+    expect(r.detached).toBe(0);
+  });
+
+  it("preserves the deck's OWN slide order — a manual reorder survives a reload", () => {
+    // A three-page base, but the author reordered the slides so the deck presents
+    // page 3, then 1, then 2. Each slide still backs its original page.
+    const pages = ["Intro", "Method", "Results"].map((t, i) => page(i + 1, t));
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [
+        { ...blankSlide(3), id: "s3", anchor: { page: 3, print: fingerprint(pages[2]) } },
+        {
+          ...blankSlide(1),
+          id: "s1",
+          anchor: { page: 1, print: fingerprint(pages[0]) },
+          objects: [textObj("o1")],
+        },
+        { ...blankSlide(2), id: "s2", anchor: { page: 2, print: fingerprint(pages[1]) } },
+      ],
+    };
+
+    const r = reconcile(deck, pages);
+    // The reordered sequence must come back verbatim, not re-sorted into page order.
+    expect(r.deck.slides.map((s) => s.id)).toEqual(["s3", "s1", "s2"]);
+    // Each slide still backs the page it always did — nothing moved, nothing lost.
+    expect(r.moved).toBe(0);
+    expect(r.added).toBe(0);
+    expect(r.detached).toBe(0);
+    expect(r.deck.slides.map((s) => s.anchor.page)).toEqual([3, 1, 2]);
+    // And the layer is still on its slide.
+    expect(r.deck.slides.find((s) => s.id === "s1")!.objects.map((o) => o.id)).toEqual(["o1"]);
+  });
+
+  it("keeps a DUPLICATED slide — two slides may share one base page", () => {
+    // The author copied slide 1; the copy backs the same page and carries its own
+    // (freshly-ided) layer. Both must survive a reload rather than the copy being
+    // dropped for want of a page of its own.
+    const pages = ["Intro", "Method"].map((t, i) => page(i + 1, t));
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [
+        {
+          ...blankSlide(1),
+          id: "s1",
+          anchor: { page: 1, print: fingerprint(pages[0]) },
+          objects: [textObj("o1")],
+        },
+        {
+          ...blankSlide(1),
+          id: "s1copy",
+          anchor: { page: 1, print: fingerprint(pages[0]) },
+          objects: [textObj("o1copy")],
+        },
+        { ...blankSlide(2), id: "s2", anchor: { page: 2, print: fingerprint(pages[1]) } },
+      ],
+    };
+
+    const r = reconcile(deck, pages);
+    expect(r.detached).toBe(0);
+    expect(r.added).toBe(0);
+    expect(r.deck.slides.map((s) => s.id)).toEqual(["s1", "s1copy", "s2"]);
+    // Both copies back page 1; the second slide backs page 2.
+    expect(r.deck.slides.map((s) => s.anchor.page)).toEqual([1, 1, 2]);
+    expect(r.deck.slides[1].objects.map((o) => o.id)).toEqual(["o1copy"]);
+  });
+
+  it("follows a layer when a slide is INSERTED above it", () => {
+    const deck = deckOf(["Intro", "Method", "Results"]); // layer on "Method"
+    const pages = ["Intro", "NEW", "Method", "Results"].map((t, i) => page(i + 1, t));
+
+    const r = reconcile(deck, pages);
+    expect(r.detached).toBe(0);
+    expect(r.added).toBe(1);
+    expect(r.deck.slides).toHaveLength(4);
+    // The layer must now be on page 3, which is where "Method" went.
+    const withLayer = r.deck.slides.find((s) => s.objects.length > 0)!;
+    expect(withLayer.anchor.page).toBe(3);
+  });
+
+  it("prefers the SyncTeX line over everything, so retitling a slide is safe", () => {
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf", "talk.tex"),
+      slides: [
+        { ...blankSlide(1), id: "s1", anchor: { page: 1, line: 10, print: "stale" } },
+        {
+          ...blankSlide(2),
+          id: "s2",
+          anchor: { page: 2, line: 40, print: "stale" },
+          objects: [textObj("o")],
+        },
+      ],
+    };
+    // The slide moved to page 1 AND its title changed, so the fingerprint is no
+    // help at all. Only the source line still identifies it.
+    const pages = [page(1, "Renamed Method", [40]), page(2, "Intro", [10])];
+
+    const r = reconcile(deck, pages);
+    expect(r.detached).toBe(0);
+    const withLayer = r.deck.slides.find((s) => s.objects.length > 0)!;
+    expect(withLayer.anchor.page).toBe(1);
+  });
+
+  it("refuses to guess between two IDENTICAL pages", () => {
+    const dup = fingerprint(page(1, "Section"));
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [
+        { ...blankSlide(1), id: "s1", anchor: { page: 1, print: dup }, objects: [textObj("a")] },
+        { ...blankSlide(9), id: "s2", anchor: { page: 9, print: dup } },
+      ],
+    };
+    const pages = [page(1, "Section"), page(2, "Section")];
+    const r = reconcile(deck, pages);
+    // Ambiguous fingerprints are ignored; order decides instead, and nothing is
+    // lost either way.
+    expect(r.detached).toBe(0);
+    expect(r.deck.slides).toHaveLength(2);
+    expect(r.deck.slides.some((s) => s.objects.length > 0)).toBe(true);
+  });
+
+  it("detaches a layer rather than dropping it when the base loses pages", () => {
+    const deck = deckOf(["Intro", "Method", "Results"], 2); // layer on "Results"
+    const pages = [page(1, "Intro")];
+
+    const r = reconcile(deck, pages);
+    expect(r.deck.slides).toHaveLength(1);
+    expect(r.detached).toBe(1);
+    expect(r.deck.detached[0].objects.map((o) => o.id)).toEqual(["o2"]);
+  });
+
+  it("drops EMPTY orphan slides silently — there is nothing to lose", () => {
+    const deck = deckOf(["Intro", "Method", "Results"], -1); // no layers anywhere
+    const r = reconcile(deck, [page(1, "Intro")]);
+    expect(r.detached).toBe(0);
+    expect(r.deck.detached).toEqual([]);
+  });
+
+  it("treats a base that reports zero pages as a failed load, not an empty one", () => {
+    const deck = deckOf(["Intro", "Method"]);
+    const r = reconcile(deck, []);
+    expect(r.deck.slides).toHaveLength(2);
+    expect(r.deck.detached).toEqual([]);
+  });
+
+  it("adopts the base's real page size", () => {
+    const deck = deckOf(["Intro"]);
+    const r = reconcile(deck, [{ page: 1, width: 595, height: 842, text: "Intro" }]);
+    expect(r.deck.pageWidth).toBe(595);
+    expect(r.deck.pageHeight).toBe(842);
+  });
+});
+
+describe("reattach", () => {
+  it("MERGES onto the slide instead of replacing what is already there", () => {
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [{ ...blankSlide(1), id: "s1", objects: [textObj("already")], notes: "mine" }],
+      detached: [{ from: { page: 4 }, objects: [textObj("orphan")], notes: "theirs" }],
+    };
+    const out = reattach(deck, 0, 0);
+    expect(out.slides[0].objects.map((o) => o.id)).toEqual(["already", "orphan"]);
+    expect(out.slides[0].notes).toBe("mine\n\ntheirs");
+    expect(out.detached).toEqual([]);
+  });
+
+  it("ignores an out-of-range target rather than corrupting the deck", () => {
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [blankSlide(1)],
+      detached: [{ from: { page: 4 }, objects: [textObj("orphan")], notes: "" }],
+    };
+    expect(reattach(deck, 0, 9)).toEqual(deck);
+    expect(reattach(deck, 9, 0)).toEqual(deck);
+  });
+});
diff --git a/src/__tests__/DeckSnap.test.ts b/src/__tests__/DeckSnap.test.ts
new file mode 100644
index 0000000..f550814
--- /dev/null
+++ b/src/__tests__/DeckSnap.test.ts
@@ -0,0 +1,191 @@
+/**
+ * Tests for deck snapping (`lib/viewers/deck/snap`).
+ *
+ * This module gets the heaviest coverage in the feature for a specific reason: a
+ * sign error in snapping is invisible in code review and infuriating in use. The
+ * cases below pin the decisions rather than the arithmetic — that the threshold
+ * is per-axis (a widescreen page makes a single scalar twice as grabby
+ * vertically), that a resize handle only ever moves its own edges, that the
+ * winner is the smallest *correction* rather than the nearest target, and that
+ * every guide returned is one the result genuinely snapped to.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  type SnapContext,
+  MIN_SIZE,
+  axisLock,
+  snapMove,
+  snapResize,
+  thresholdFor,
+} from "../lib/viewers/deck/snap";
+import type { Box } from "../lib/viewers/deck/model";
+
+const ctx = (over: Partial<SnapContext> = {}): SnapContext => ({
+  others: [],
+  margin: 0,
+  threshold: { x: 0.02, y: 0.02 },
+  enabled: true,
+  ...over,
+});
+
+const box = (x: number, y: number, w = 0.2, h = 0.2): Box => ({ x, y, w, h });
+
+describe("threshold", () => {
+  it("is per-axis, so a widescreen page snaps evenly in both directions", () => {
+    const t = thresholdFor(8, 1600, 900);
+    expect(t.x).toBeCloseTo(0.005);
+    expect(t.y).toBeCloseTo(8 / 900);
+    expect(t.y).toBeGreaterThan(t.x); // the whole point
+  });
+
+  it("degrades to zero rather than dividing by zero before first layout", () => {
+    expect(thresholdFor(8, 0, 0)).toEqual({ x: 0, y: 0 });
+  });
+});
+
+describe("snapMove", () => {
+  it("does nothing at all when suspended (Alt)", () => {
+    const r = snapMove(box(0.001, 0.001), ctx({ enabled: false }));
+    expect(r).toEqual({ x: 0.001, y: 0.001, guides: [] });
+  });
+
+  it("snaps the near edge to the page edge", () => {
+    const r = snapMove(box(0.005, 0.005), ctx());
+    expect(r.x).toBeCloseTo(0);
+    expect(r.y).toBeCloseTo(0);
+    expect(r.guides.every((g) => g.kind === "page")).toBe(true);
+  });
+
+  it("snaps the CENTER to the page centre", () => {
+    // Box is 0.2 wide, so centring puts its origin at 0.4.
+    const r = snapMove(box(0.39, 0), ctx());
+    expect(r.x).toBeCloseTo(0.4);
+  });
+
+  it("snaps the FAR edge to the page's far edge", () => {
+    const r = snapMove(box(0.795, 0), ctx());
+    expect(r.x).toBeCloseTo(0.8); // 0.8 + 0.2 = 1
+  });
+
+  it("picks the smallest correction, not the first or nearest target", () => {
+    // The near edge is 0.015 from the page edge; the centre is 0.005 from 0.5.
+    // The centre must win.
+    const r = snapMove(box(0.395, 0), ctx({ threshold: { x: 0.05, y: 0.05 } }));
+    expect(r.x).toBeCloseTo(0.4);
+  });
+
+  it("snaps to another object's edges and centre", () => {
+    // Deliberately NOT at 0.5: an object edge sitting on the page centre is a
+    // real tie, and the page target legitimately wins it (see below).
+    const other = box(0.62, 0.5, 0.2, 0.2);
+    const r = snapMove(box(0.625, 0), ctx({ others: [other] }));
+    expect(r.x).toBeCloseTo(0.62);
+    expect(r.guides.find((g) => g.axis === "x")?.kind).toBe("object");
+  });
+
+  it("reports the PAGE guide when an object edge happens to sit on it", () => {
+    // Both targets are at 0.5 and the correction is identical, so which one is
+    // 'the' reason is a genuine tie. Naming the page is the more useful answer,
+    // and pinning it here stops the tie-break drifting silently.
+    const r = snapMove(box(0.505, 0), ctx({ others: [box(0.5, 0.5, 0.2, 0.2)] }));
+    expect(r.x).toBeCloseTo(0.5);
+    expect(r.guides.find((g) => g.axis === "x")?.kind).toBe("page");
+  });
+
+  it("snaps to the safe margin when one is set", () => {
+    const r = snapMove(box(0.045, 0), ctx({ margin: 0.05 }));
+    expect(r.x).toBeCloseTo(0.05);
+    expect(r.guides.find((g) => g.axis === "x")?.kind).toBe("margin");
+  });
+
+  it("leaves a far-away box completely alone", () => {
+    const r = snapMove(box(0.333, 0.222), ctx());
+    expect(r.x).toBe(0.333);
+    expect(r.y).toBe(0.222);
+    expect(r.guides).toEqual([]);
+  });
+
+  it("snaps to an equal gap — distribute-by-drag", () => {
+    // a and b sit 0.1 apart. Dragging c near "0.1 after b" must lock to it.
+    const a = box(0.0, 0, 0.1, 0.1);
+    const b = box(0.2, 0, 0.1, 0.1); // gap a→b = 0.1
+    const r = snapMove(box(0.395, 0, 0.1, 0.1), ctx({ others: [a, b] }));
+    expect(r.x).toBeCloseTo(0.4); // 0.3 (b's right edge) + 0.1
+    expect(r.guides.some((g) => g.kind === "spacing")).toBe(true);
+  });
+
+  it("ignores a 'gap' between two overlapping objects", () => {
+    const a = box(0, 0, 0.5, 0.1);
+    const b = box(0.2, 0, 0.5, 0.1); // overlaps a — negative gap
+    const r = snapMove(box(0.333, 0.5, 0.1, 0.1), ctx({ others: [a, b] }));
+    expect(r.guides.some((g) => g.kind === "spacing")).toBe(false);
+  });
+
+  it("returns a guide spanning both the moving box and what it aligned with", () => {
+    const other = box(0.5, 0.8, 0.2, 0.1); // far below
+    const r = snapMove(box(0.505, 0.1, 0.2, 0.1), ctx({ others: [other] }));
+    const g = r.guides.find((gg) => gg.axis === "x")!;
+    expect(g.from).toBeCloseTo(0.1); // top of the moving box
+    expect(g.to).toBeCloseTo(0.9); // bottom of the other one
+  });
+});
+
+describe("snapResize", () => {
+  it("moves ONLY the edges its handle owns", () => {
+    // The west edge is near 0, but we drag the east handle: x must not move.
+    const r = snapResize(box(0.004, 0.3, 0.5, 0.2), "e", ctx());
+    expect(r.box.x).toBeCloseTo(0.004);
+  });
+
+  it("snaps the dragged east edge to the page edge", () => {
+    const r = snapResize(box(0.2, 0.3, 0.795, 0.2), "e", ctx());
+    expect(r.box.x + r.box.w).toBeCloseTo(1);
+    expect(r.box.x).toBeCloseTo(0.2);
+  });
+
+  it("snaps the dragged west edge without moving the east one", () => {
+    const r = snapResize(box(0.004, 0.3, 0.5, 0.2), "w", ctx());
+    expect(r.box.x).toBeCloseTo(0);
+    expect(r.box.x + r.box.w).toBeCloseTo(0.504); // right edge held
+  });
+
+  it("snaps a corner on both axes at once", () => {
+    const r = snapResize(box(0.2, 0.2, 0.795, 0.795), "se", ctx());
+    expect(r.box.w).toBeCloseTo(0.8);
+    expect(r.box.h).toBeCloseTo(0.8);
+    expect(r.guides).toHaveLength(2);
+  });
+
+  it("snaps to ANOTHER object's exact width — same-size", () => {
+    const other = box(0.5, 0.5, 0.3, 0.1);
+    // Dragging east to a width of 0.295: the page targets are far away, so the
+    // only thing in range is "same width as `other`".
+    const r = snapResize(box(0.1, 0.1, 0.295, 0.1), "e", ctx({ others: [other] }));
+    expect(r.box.w).toBeCloseTo(0.3);
+    expect(r.guides.some((g) => g.kind === "size")).toBe(true);
+  });
+
+  it("never lets a handle invert or collapse the box", () => {
+    const r = snapResize(box(0.5, 0.5, -0.4, 0), "e", ctx({ enabled: false }));
+    expect(r.box.w).toBe(MIN_SIZE);
+    expect(r.box.h).toBe(MIN_SIZE);
+  });
+
+  it("still clamps when snapping is suspended", () => {
+    const r = snapResize(box(0.004, 0.3, 0.5, 0.2), "w", ctx({ enabled: false }));
+    expect(r.box.x).toBe(0.004);
+    expect(r.guides).toEqual([]);
+  });
+});
+
+describe("axisLock", () => {
+  it("keeps the dominant axis and zeroes the other", () => {
+    expect(axisLock(0.3, 0.1)).toEqual({ dx: 0.3, dy: 0 });
+    expect(axisLock(0.1, -0.3)).toEqual({ dx: 0, dy: -0.3 });
+  });
+
+  it("breaks an exact tie toward horizontal, deterministically", () => {
+    expect(axisLock(0.2, 0.2)).toEqual({ dx: 0.2, dy: 0 });
+  });
+});
diff --git a/src/__tests__/DeckTemplate.test.ts b/src/__tests__/DeckTemplate.test.ts
new file mode 100644
index 0000000..c7caa48
--- /dev/null
+++ b/src/__tests__/DeckTemplate.test.ts
@@ -0,0 +1,115 @@
+/**
+ * Tests for the starter-LaTeX generator (`lib/viewers/deck/template`).
+ *
+ * The generator exists so that making a presentation does not require knowing
+ * TeX, which means the one thing it must never do is emit something that fails
+ * to compile — a broken starter is worse than no starter, because the user has
+ * no way to tell whether the deck or their machine is at fault. Hence the escape
+ * tests: a project called `R&D 100%` is an ordinary folder name and a LaTeX
+ * syntax error.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  starterTex,
+  starterTexFigure,
+  texEscape,
+  texPathForDeck,
+  titleFromPath,
+} from "../lib/viewers/deck/template";
+
+describe("texEscape", () => {
+  it("escapes the characters that would otherwise be LaTeX syntax", () => {
+    expect(texEscape("R&D")).toBe("R\\&D");
+    expect(texEscape("100%")).toBe("100\\%");
+    expect(texEscape("a_b")).toBe("a\\_b");
+    expect(texEscape("{x}")).toBe("\\{x\\}");
+    expect(texEscape("$5")).toBe("\\$5");
+    expect(texEscape("#1")).toBe("\\#1");
+  });
+
+  it("escapes backslashes FIRST, so its own escapes are not re-escaped", () => {
+    // Getting this order wrong turns `\&` into `\textbackslash{}&` — a classic.
+    expect(texEscape("a\\b")).toBe("a\\textbackslash{}b");
+    expect(texEscape("&")).toBe("\\&");
+  });
+
+  it("handles the two that need a command rather than a backslash", () => {
+    expect(texEscape("~")).toBe("\\textasciitilde{}");
+    expect(texEscape("^")).toBe("\\textasciicircum{}");
+  });
+
+  it("leaves ordinary text completely alone", () => {
+    expect(texEscape("A perfectly normal title")).toBe("A perfectly normal title");
+  });
+});
+
+describe("starterTex", () => {
+  it("is a complete, balanced document", () => {
+    const tex = starterTex({ title: "Talk" });
+    expect(tex).toContain("\\documentclass[aspectratio=169]{beamer}");
+    expect(tex).toContain("\\begin{document}");
+    expect(tex).toContain("\\end{document}");
+    // Every environment it opens, it closes.
+    const opens = (tex.match(/\\begin\{frame\}/g) ?? []).length;
+    const closes = (tex.match(/\\end\{frame\}/g) ?? []).length;
+    expect(opens).toBe(closes);
+    expect(opens).toBeGreaterThan(1);
+  });
+
+  it("routes the title and author through the escaper", () => {
+    const tex = starterTex({ title: "R&D: 100% of it", author: "A_B" });
+    expect(tex).toContain("\\title{R\\&D: 100\\% of it}");
+    expect(tex).toContain("\\author{A\\_B}");
+  });
+
+  it("comments out the author line when there is none, rather than emitting an empty one", () => {
+    const tex = starterTex({ title: "Talk" });
+    expect(tex).not.toMatch(/^\\author\{\}$/m);
+    expect(tex).toContain("% \\author{Your name}");
+  });
+
+  it("defaults the first section instead of emitting an empty heading", () => {
+    expect(starterTex({ title: "T" })).toContain("\\section{Introduction}");
+    expect(starterTex({ title: "T", section: "  " })).toContain("\\section{Introduction}");
+    expect(starterTex({ title: "T", section: "Method" })).toContain("\\section{Method}");
+  });
+
+  it("says in the file itself that Eldrun will not write to it again", () => {
+    // The promise this whole path rests on; worth pinning so a later edit to the
+    // template cannot quietly drop it.
+    expect(starterTex({ title: "T" })).toMatch(/never writes back/i);
+  });
+});
+
+describe("starterTexFigure", () => {
+  it("is a complete, balanced standalone document", () => {
+    const tex = starterTexFigure();
+    expect(tex).toContain("\\documentclass[border=4pt]{standalone}");
+    expect(tex).toContain("\\begin{document}");
+    expect(tex).toContain("\\end{document}");
+  });
+
+  it("says Eldrun will keep the slide's raster in sync on recompile", () => {
+    expect(starterTexFigure()).toMatch(/updates it/i);
+  });
+});
+
+describe("titleFromPath", () => {
+  it("turns a filename into something presentable", () => {
+    expect(titleFromPath("/p/my-great-talk.eldeck.json")).toBe("My great talk");
+    expect(titleFromPath("/p/my_great_talk.tex")).toBe("My great talk");
+    expect(titleFromPath("/p/results.pdf")).toBe("Results");
+  });
+
+  it("falls back rather than producing an empty title", () => {
+    expect(titleFromPath("/p/.eldeck.json")).toBe("Presentation");
+    expect(titleFromPath("")).toBe("Presentation");
+  });
+});
+
+describe("texPathForDeck", () => {
+  it("names the source beside the deck", () => {
+    expect(texPathForDeck("/p/talk.eldeck.json")).toBe("/p/talk.tex");
+  });
+});
diff --git a/src/__tests__/DeckTexPanel.test.ts b/src/__tests__/DeckTexPanel.test.ts
new file mode 100644
index 0000000..029313c
--- /dev/null
+++ b/src/__tests__/DeckTexPanel.test.ts
@@ -0,0 +1,61 @@
+/**
+ * Tests for `texFigures` (`components/embed/deck/DeckTexPanel`) — the pure part
+ * of the deck-wide TeX-figure list: which objects it collects and in what order.
+ */
+
+import { describe, it, expect } from "vitest";
+import { texFigures } from "../components/embed/deck/DeckTexPanel";
+import { type Deck, blankSlide, emptyDeck } from "../lib/viewers/deck/model";
+
+function texImage(id: string, texSrc: string) {
+  return {
+    id,
+    kind: "image" as const,
+    src: `${id}.png`,
+    texSrc,
+    fit: "contain" as const,
+    x: 0,
+    y: 0,
+    w: 0.2,
+    h: 0.2,
+    rot: 0,
+    opacity: 1,
+  };
+}
+
+function plainImage(id: string) {
+  return {
+    id,
+    kind: "image" as const,
+    src: `${id}.png`,
+    fit: "contain" as const,
+    x: 0,
+    y: 0,
+    w: 0.2,
+    h: 0.2,
+    rot: 0,
+    opacity: 1,
+  };
+}
+
+describe("texFigures", () => {
+  it("finds only image objects that carry a texSrc, across every slide", () => {
+    const deck: Deck = {
+      ...emptyDeck("talk.pdf"),
+      slides: [
+        { ...blankSlide(1), objects: [plainImage("a"), texImage("b", "b.tex")] },
+        { ...blankSlide(2), objects: [] },
+        { ...blankSlide(3), objects: [texImage("c", "c.tex")] },
+      ],
+    };
+    expect(texFigures(deck).map((f) => [f.slideIndex, f.obj.id])).toEqual([
+      [0, "b"],
+      [2, "c"],
+    ]);
+  });
+
+  it("returns an empty list for a deck with no TeX figures", () => {
+    const deck: Deck = { ...emptyDeck("talk.pdf"), slides: [blankSlide(1)] };
+    expect(texFigures(deck)).toEqual([]);
+  });
+});
diff --git a/src/__tests__/DeckTransform.test.ts b/src/__tests__/DeckTransform.test.ts
new file mode 100644
index 0000000..990a9a5
--- /dev/null
+++ b/src/__tests__/DeckTransform.test.ts
@@ -0,0 +1,139 @@
+/**
+ * Tests for the deck's coordinate transform (`lib/viewers/deck/transform`).
+ *
+ * This is the module most likely to be quietly wrong, because nothing else in the
+ * repo does a bottom-left flip and there is no reference implementation to
+ * compare against — the PDF viewer works entirely in pdf.js's already-flipped
+ * viewport space. A sign error here puts every exported object in the wrong half
+ * of the page, which is obvious in a rendered PDF and invisible in a diff.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  fitSquare,
+  parseColor,
+  pdfPlacement,
+  toPdfRect,
+} from "../lib/viewers/deck/transform";
+
+const PAGE_W = 400;
+const PAGE_H = 200;
+
+describe("toPdfRect", () => {
+  it("flips y: the TOP of the deck is the HIGH y of the PDF", () => {
+    // A box at the very top of the slide.
+    const top = toPdfRect({ x: 0, y: 0, w: 0.5, h: 0.25 }, PAGE_W, PAGE_H);
+    expect(top.top).toBe(200); // top edge = page top
+    expect(top.y).toBe(150); // bottom edge = 200 - 50
+    expect(top.h).toBe(50);
+
+    // The same box at the very bottom.
+    const bottom = toPdfRect({ x: 0, y: 0.75, w: 0.5, h: 0.25 }, PAGE_W, PAGE_H);
+    expect(bottom.top).toBe(50);
+    expect(bottom.y).toBe(0);
+  });
+
+  it("leaves x alone — only the vertical axis is flipped", () => {
+    const r = toPdfRect({ x: 0.25, y: 0.5, w: 0.5, h: 0.5 }, PAGE_W, PAGE_H);
+    expect(r.x).toBe(100);
+    expect(r.w).toBe(200);
+  });
+
+  it("keeps `top` and `y` exactly one height apart", () => {
+    const r = toPdfRect({ x: 0.1, y: 0.3, w: 0.2, h: 0.4 }, PAGE_W, PAGE_H);
+    expect(r.top - r.y).toBeCloseTo(r.h);
+  });
+});
+
+describe("pdfPlacement", () => {
+  const rect = toPdfRect({ x: 0.25, y: 0.25, w: 0.5, h: 0.5 }, PAGE_W, PAGE_H);
+  // → x 100..300, y 50..150, centre (200, 100).
+
+  it("is the plain top-left corner when nothing is rotated", () => {
+    const p = pdfPlacement(rect, 0);
+    expect(p).toEqual({ x: 100, y: 150, rotate: 0 });
+  });
+
+  it("offsets INTO the box in y-down terms", () => {
+    // 10pt right and 20pt DOWN from the box's top-left.
+    const p = pdfPlacement(rect, 0, 10, 20);
+    expect(p.x).toBe(110);
+    expect(p.y).toBe(130); // down the slide = lower PDF y
+  });
+
+  it("negates the angle, because PDF rotates counter-clockwise", () => {
+    expect(pdfPlacement(rect, 90).rotate).toBe(-90);
+    expect(pdfPlacement(rect, -30).rotate).toBe(30);
+  });
+
+  it("rotates the anchor about the box's CENTRE, not about the corner", () => {
+    // Worked by hand, in SCREEN terms, then flipped — which is the only way to
+    // check this without a renderer.
+    //
+    // The box is 200 × 100 centred at screen (200, 100); its top-left corner is
+    // at screen (100, 50). A quarter turn clockwise sends an offset (x, y) to
+    // (−y, x), so (−100, −50) becomes (50, −100) and the corner lands at screen
+    // (250, 0) — the top of a now 100 × 200 upright box. Flipped: PDF (250, 200).
+    const p = pdfPlacement(rect, 90);
+    expect(p.x).toBeCloseTo(250);
+    expect(p.y).toBeCloseTo(200);
+  });
+
+  it("a half turn puts the origin diagonally opposite, through the centre", () => {
+    const p = pdfPlacement(rect, 180);
+    expect(p.x).toBeCloseTo(300);
+    expect(p.y).toBeCloseTo(50);
+  });
+
+  it("a full turn is the identity", () => {
+    const p = pdfPlacement(rect, 360);
+    expect(p.x).toBeCloseTo(100);
+    expect(p.y).toBeCloseTo(150);
+  });
+
+  it("preserves the distance from the centre for any angle", () => {
+    const cx = rect.x + rect.w / 2;
+    const cy = rect.y + rect.h / 2;
+    const d0 = Math.hypot(rect.x - cx, rect.top - cy);
+    for (const deg of [17, 45, 123, 270, -88]) {
+      const p = pdfPlacement(rect, deg);
+      expect(Math.hypot(p.x - cx, p.y - cy)).toBeCloseTo(d0);
+    }
+  });
+});
+
+describe("parseColor", () => {
+  it("reads the three hex lengths", () => {
+    expect(parseColor("#000")).toEqual({ r: 0, g: 0, b: 0, a: 1 });
+    expect(parseColor("#ffffff")).toEqual({ r: 1, g: 1, b: 1, a: 1 });
+    const half = parseColor("#00000080")!;
+    expect(half.a).toBeCloseTo(128 / 255);
+  });
+
+  it("expands shorthand by doubling each digit", () => {
+    expect(parseColor("#f00")).toEqual(parseColor("#ff0000"));
+  });
+
+  it("returns null for anything it cannot read, rather than a wrong colour", () => {
+    expect(parseColor("red")).toBeNull();
+    expect(parseColor("#12345")).toBeNull();
+    expect(parseColor(undefined)).toBeNull();
+  });
+});
+
+describe("fitSquare", () => {
+  it("centres a square glyph box in a wide rect", () => {
+    const r = toPdfRect({ x: 0, y: 0, w: 0.5, h: 0.5 }, 400, 200); // 200 × 100
+    const f = fitSquare(r, 24);
+    expect(f.scale).toBeCloseTo(100 / 24); // the SHORT side wins
+    expect(f.offsetX).toBeCloseTo(50); // (200 - 100) / 2
+    expect(f.offsetY).toBeCloseTo(0);
+  });
+
+  it("centres vertically in a tall rect", () => {
+    const r = toPdfRect({ x: 0, y: 0, w: 0.25, h: 1 }, 400, 200); // 100 × 200
+    const f = fitSquare(r, 24);
+    expect(f.offsetX).toBeCloseTo(0);
+    expect(f.offsetY).toBeCloseTo(50);
+  });
+});
diff --git a/src/__tests__/DeckView.test.ts b/src/__tests__/DeckView.test.ts
new file mode 100644
index 0000000..3995028
--- /dev/null
+++ b/src/__tests__/DeckView.test.ts
@@ -0,0 +1,28 @@
+/**
+ * Tests for the small pure pieces exported from `components/embed/deck/DeckView`
+ * — currently just the slide-overview rail's resize clamp, mirroring the same
+ * bounds-check test `SubwindowFilesSidebar.test.ts` runs for its own resizable
+ * column.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  DECK_RAIL_MAX_WIDTH,
+  DECK_RAIL_MIN_WIDTH,
+  clampRailWidth,
+} from "../components/embed/deck/DeckView";
+
+describe("clampRailWidth", () => {
+  it("clamps to the documented bounds", () => {
+    expect(clampRailWidth(1)).toBe(DECK_RAIL_MIN_WIDTH);
+    expect(clampRailWidth(10_000)).toBe(DECK_RAIL_MAX_WIDTH);
+  });
+
+  it("rounds to a whole pixel", () => {
+    expect(clampRailWidth(150.6)).toBe(151);
+  });
+
+  it("leaves an in-range width alone", () => {
+    expect(clampRailWidth(150)).toBe(150);
+  });
+});
diff --git a/src/__tests__/DefaultAppExecMatch.test.ts b/src/__tests__/DefaultAppExecMatch.test.ts
new file mode 100644
index 0000000..7132da9
--- /dev/null
+++ b/src/__tests__/DefaultAppExecMatch.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { execMatchesApp } from "../components/files/SetDefaultAppDialog";
+
+describe("execMatchesApp", () => {
+  it("matches an exact single-word exec", () => {
+    expect(execMatchesApp("gimp-3.2", "gimp-3.2")).toBe(true);
+    expect(execMatchesApp("vim", "gimp-3.2")).toBe(false);
+  });
+
+  it("matches when the saved exec is the app's command plus trailing args", () => {
+    // sharun AppImage: the saved exec carries the `kicad` binary selector the
+    // `.desktop` Exec lacks — re-selecting KiCad must still count as a match.
+    expect(
+      execMatchesApp(
+        "/opt/kicad-10.0.3-x86_64.AppImage kicad",
+        "/opt/kicad-10.0.3-x86_64.AppImage",
+      ),
+    ).toBe(true);
+  });
+
+  it("matches a full multi-word launcher line exactly (Flatpak)", () => {
+    const line =
+      "/usr/bin/flatpak run --branch=stable com.prusa3d.PrusaSlicer";
+    expect(execMatchesApp(line, line)).toBe(true);
+  });
+
+  it("does not match when the app command is longer than the saved exec", () => {
+    expect(
+      execMatchesApp(
+        "/opt/kicad-10.0.3-x86_64.AppImage",
+        "/opt/kicad-10.0.3-x86_64.AppImage kicad",
+      ),
+    ).toBe(false);
+  });
+
+  it("does not match a different program", () => {
+    expect(
+      execMatchesApp("/opt/kicad-10.0.3-x86_64.AppImage kicad", "/usr/bin/gimp"),
+    ).toBe(false);
+  });
+
+  it("treats an empty saved exec as no match", () => {
+    expect(execMatchesApp("", "gimp-3.2")).toBe(false);
+    expect(execMatchesApp("   ", "gimp-3.2")).toBe(false);
+  });
+
+  it("ignores surrounding and repeated whitespace", () => {
+    expect(
+      execMatchesApp("  /opt/app.AppImage   kicad ", "/opt/app.AppImage"),
+    ).toBe(true);
+  });
+});
diff --git a/src/__tests__/DetachFromRemote.test.ts b/src/__tests__/DetachFromRemote.test.ts
new file mode 100644
index 0000000..7224feb
--- /dev/null
+++ b/src/__tests__/DetachFromRemote.test.ts
@@ -0,0 +1,141 @@
+/**
+ * Detaching a project from its SSH host must re-point its tabs.
+ *
+ * The live bug this pins (DemoProj): while a project is remote its `directory` is the
+ * state dir `~/.local/share/eldrun/remote-projects/<id>/`, and `loadFromLayout` stores
+ * exactly that as every tab's `cwd`. Nothing ever noticed, because `localTabCwd` rewrote
+ * it at render time to the real mirror — an override gated on `isRemoteProject`.
+ *
+ * Detach flips that gate to false. The override stops firing, every tab falls back to the
+ * stored cwd it should never have had, and agents relaunch inside the state dir — which
+ * detach has just emptied. Claude keys its session history by cwd, so `--resume` then finds
+ * no conversation (it lives under the mirror's path) and the agent starts asking for
+ * permissions under `.local/share/eldrun/remote-projects/…`.
+ *
+ * So: the fallback path is real, it is reachable, and `detachScopeFromRemote` is what keeps
+ * it from being taken.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import { localTabCwd, useTabsStore, type TabEntry } from "../stores/tabs";
+
+const STATE_DIR = "/home/u/.local/share/eldrun/remote-projects/pid";
+const MIRROR = "/home/u/Documents/CodeProjectsGit/DemoProj";
+
+function tab(over: Partial<TabEntry>): TabEntry {
+  return {
+    key: "agent-1",
+    label: "Claude",
+    cmd: "claude",
+    args: [],
+    env: {},
+    cwd: STATE_DIR,
+    kind: "agent",
+    scope: "pid",
+    ...over,
+  } as TabEntry;
+}
+
+function seed(tabs: TabEntry[]) {
+  useTabsStore.setState({
+    scope: "pid",
+    tabsByScope: { pid: tabs },
+    layoutByScope: { pid: null },
+    focusedGroupByScope: { pid: null },
+    tabs,
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+beforeEach(() => {
+  vi.mocked(invoke).mockClear();
+});
+
+describe("localTabCwd — why detach breaks tabs", () => {
+  it("hides the bad cwd while remote, and exposes it the instant the project is local", () => {
+    const t = { kind: "agent" as const, location: "local" as const };
+
+    // Remote: the stored state-dir cwd is overridden by the mirror. Looks fine.
+    expect(
+      localTabCwd(t, {
+        isRemoteProject: true,
+        projectDirectory: STATE_DIR,
+        fallback: STATE_DIR,
+        mirror: MIRROR,
+      }),
+    ).toBe(MIRROR);
+
+    // Detached: no override — the tab falls straight back to the cwd it was storing all
+    // along. THIS is the `.local/share/eldrun/remote-projects/…` the agent ends up in.
+    expect(
+      localTabCwd(t, {
+        isRemoteProject: false,
+        projectDirectory: MIRROR,
+        fallback: STATE_DIR,
+        mirror: null,
+      }),
+    ).toBe(STATE_DIR);
+  });
+});
+
+describe("detachScopeFromRemote", () => {
+  it("moves every tab's cwd out of the state dir and into the promoted mirror", () => {
+    seed([
+      tab({ key: "agent-1", cwd: STATE_DIR, location: "local" }),
+      tab({ key: "agent-2", cwd: `${STATE_DIR}/sub`, location: "local", label: "Claude 2" }),
+    ]);
+
+    useTabsStore.getState().detachScopeFromRemote("pid", STATE_DIR, MIRROR);
+
+    const tabs = useTabsStore.getState().tabsByScope.pid;
+    expect(tabs[0].cwd).toBe(MIRROR);
+    // A cwd *under* the old dir keeps its suffix rather than being flattened.
+    expect(tabs[1].cwd).toBe(`${MIRROR}/sub`);
+    // And the resolver now agrees, because the fallback is finally correct.
+    expect(
+      localTabCwd(tabs[0], {
+        isRemoteProject: false,
+        projectDirectory: MIRROR,
+        fallback: tabs[0].cwd,
+        mirror: null,
+      }),
+    ).toBe(MIRROR);
+  });
+
+  it("brings host-located tabs home — their cwd is a path on a machine we no longer have", () => {
+    seed([
+      tab({ key: "shell-1", kind: "shell", cmd: "bash", cwd: "/home/remote/Code/demoproj", location: "remote" }),
+    ]);
+
+    useTabsStore.getState().detachScopeFromRemote("pid", STATE_DIR, MIRROR);
+
+    const t = useTabsStore.getState().tabsByScope.pid[0];
+    expect(t.cwd).toBe(MIRROR);
+    expect(t.location).toBeUndefined(); // back to the kind's default (local)
+  });
+
+  it("leaves a tab already sitting in the mirror alone", () => {
+    seed([tab({ key: "shell-1", kind: "shell", cmd: "bash", cwd: `${MIRROR}/src`, location: "local" })]);
+
+    useTabsStore.getState().detachScopeFromRemote("pid", STATE_DIR, MIRROR);
+
+    expect(useTabsStore.getState().tabsByScope.pid[0].cwd).toBe(`${MIRROR}/src`);
+  });
+
+  it("is a no-op when there is nothing to move", () => {
+    seed([tab({ key: "agent-1", cwd: MIRROR, location: "local" })]);
+    const before = useTabsStore.getState().tabsByScope.pid;
+
+    useTabsStore.getState().detachScopeFromRemote("pid", STATE_DIR, MIRROR);
+    useTabsStore.getState().detachScopeFromRemote("pid", MIRROR, MIRROR); // same dir
+    useTabsStore.getState().detachScopeFromRemote("pid", "", MIRROR); // no old dir
+
+    expect(useTabsStore.getState().tabsByScope.pid).toBe(before);
+  });
+});
diff --git a/src/__tests__/DetachedHost.test.ts b/src/__tests__/DetachedHost.test.ts
index aa7a434..1e6f37b 100644
--- a/src/__tests__/DetachedHost.test.ts
+++ b/src/__tests__/DetachedHost.test.ts
@@ -61,6 +61,7 @@ import {
   DETACHED_EDIT,
   DETACHED_DOCK,
   DETACHED_CLOSE,
+  DETACHED_HIDE,
   detachedSeedEvent,
   type DetachedSeed,
 } from "../stores/detached";
@@ -79,6 +80,7 @@ function reset() {
     layoutByScope: {},
     focusedGroupByScope: {},
     detachedGroupsByScope: {},
+    hiddenGroupsByScope: {},
     tabs: [],
     layout: null,
     focusedGroupId: null,
@@ -110,6 +112,7 @@ describe("detached host (#42)", () => {
     expect(handlers.has(DETACHED_EDIT)).toBe(true);
     expect(handlers.has(DETACHED_DOCK)).toBe(true);
     expect(handlers.has(DETACHED_CLOSE)).toBe(true);
+    expect(handlers.has(DETACHED_HIDE)).toBe(true);
   });
 
   it("a seed request emits the group's tabs + subtree to the requesting label", async () => {
@@ -124,7 +127,7 @@ describe("detached host (#42)", () => {
     expect(seedEvent).toBeDefined();
     const seed = seedEvent!.payload as DetachedSeed;
     expect(seed.tabs.map((t) => t.key)).toEqual([bKey]);
-    expect(seed.subtree.tabKeys).toEqual([bKey]);
+    expect((seed.subtree as GroupNode).tabKeys).toEqual([bKey]);
   });
 
   it("an edit is applied to the host's detached record", async () => {
@@ -138,6 +141,80 @@ describe("detached host (#42)", () => {
     expect(useTabsStore.getState().detachedGroupsByScope["p"]).toHaveLength(1);
   });
 
+  it("an 'add' edit mints a tab into the popout's subtree, keeps the PTY in the main store, and re-seeds", async () => {
+    const { groupId, label, bKey } = detachSecond();
+    await listenDetachedHost();
+    emitted.length = 0;
+
+    handlers.get(DETACHED_EDIT)!({
+      payload: {
+        scope: "p",
+        groupId,
+        edit: {
+          kind: "add",
+          targetGroupId: groupId,
+          tab: { label: "new", cmd: "bash", cwd: "/p", kind: "shell" },
+        },
+      },
+    });
+
+    // The popout's subtree now holds the original tab + the freshly-minted one.
+    const rec = useTabsStore.getState().detachedGroupsByScope["p"]![0];
+    const subKeys = (rec.subtree as GroupNode).tabKeys;
+    expect(subKeys).toHaveLength(2);
+    expect(subKeys[0]).toBe(bKey);
+    const newKey = subKeys[1];
+    // It became the active tab of the popout group.
+    expect((rec.subtree as GroupNode).activeKey).toBe(newKey);
+    // The payload lives in the main store (its pane mounts + owns the PTY there).
+    const payload = useTabsStore.getState().tabsByScope["p"]!.find((t) => t.key === newKey);
+    expect(payload).toMatchObject({ label: "new", cmd: "bash", kind: "shell", scope: "p" });
+    // The popout is re-seeded so it renders (+ attaches to) the new tab, tagged
+    // as the landed key so it plays the drop-in flourish.
+    const seed = emitted.find((e) => e.event === detachedSeedEvent(label));
+    expect(seed).toBeDefined();
+    const payloadSeed = seed!.payload as DetachedSeed & { landedKey?: string };
+    expect(payloadSeed.landedKey).toBe(newKey);
+    expect(payloadSeed.tabs.map((t) => t.key)).toEqual([bKey, newKey]);
+  });
+
+  it("an 'add' edit with a side edge carves a NEW pane in the popout (a file dropped on a body edge)", async () => {
+    const { groupId, label, bKey } = detachSecond();
+    await listenDetachedHost();
+    emitted.length = 0;
+
+    handlers.get(DETACHED_EDIT)!({
+      payload: {
+        scope: "p",
+        groupId,
+        edit: {
+          kind: "add",
+          targetGroupId: groupId,
+          edge: "right",
+          tab: { label: "readme.md", cmd: "", cwd: "/p", kind: "embed", embedPath: "/p/readme.md" },
+        },
+      },
+    });
+
+    // The popout's subtree is now a split: the original group + a NEW group
+    // holding the dropped file's embed tab (the target's own tab is untouched).
+    const rec = useTabsStore.getState().detachedGroupsByScope["p"]![0];
+    const sub = rec.subtree as { type: string; children: GroupNode[] };
+    expect(sub.type).toBe("split");
+    expect(sub.children).toHaveLength(2);
+    const original = sub.children.find((g) => g.tabKeys.includes(bKey))!;
+    const carved = sub.children.find((g) => !g.tabKeys.includes(bKey))!;
+    expect(original.tabKeys).toEqual([bKey]);
+    expect(carved.tabKeys).toHaveLength(1);
+    const newKey = carved.tabKeys[0];
+    // The embed payload lives in the main store (its pane mounts + owns anything).
+    const payload = useTabsStore.getState().tabsByScope["p"]!.find((t) => t.key === newKey);
+    expect(payload).toMatchObject({ kind: "embed", embedPath: "/p/readme.md", scope: "p" });
+    // The popout is re-seeded with the landed key so it renders the new pane.
+    const seed = emitted.find((e) => e.event === detachedSeedEvent(label));
+    expect((seed!.payload as DetachedSeed & { landedKey?: string }).landedKey).toBe(newKey);
+  });
+
   it("an active-scope dock re-docks the group and closes the OS window", async () => {
     const { groupId, label } = detachSecond();
     await listenDetachedHost();
@@ -162,6 +239,45 @@ describe("detached host (#42)", () => {
     expect(invokeMock).toHaveBeenCalledWith("attach_subwindow", { registryId: label });
   });
 
+  it("a hide parks the group in the scope's Hidden list, keeps its tabs, and closes the window", async () => {
+    const { groupId, label, bKey } = detachSecond();
+    await listenDetachedHost();
+    invokeMock.mockClear();
+
+    handlers.get(DETACHED_HIDE)!({ payload: { scope: "p", groupId } });
+
+    // Moved out of the detached record and into the scope's hidden list…
+    expect(useTabsStore.getState().detachedGroupsByScope["p"]).toHaveLength(0);
+    const hidden = useTabsStore.getState().hiddenGroupsByScope["p"];
+    expect(hidden).toHaveLength(1);
+    expect(hidden![0].id).toBe(groupId);
+    // …with its tab payload intact (PTY stays mounted, unlike a WM-close)…
+    expect(useTabsStore.getState().tabsByScope["p"]?.some((t) => t.key === bKey)).toBe(true);
+    expect(invokeMock).not.toHaveBeenCalledWith("pty_kill", expect.anything());
+    // …and the OS window closed (registry entry dropped).
+    expect(invokeMock).toHaveBeenCalledWith("attach_subwindow", { registryId: label });
+  });
+
+  it("a hide persists the (parked) scope so it restores as hidden, not detached", async () => {
+    const { groupId } = detachSecond();
+    useTabsStore.setState({ scope: "other" });
+    useProjectsStore.setState({
+      projects: [{ id: "p", name: "p", local_file: "/p/project.json" } as never],
+    });
+    await listenDetachedHost();
+    invokeMock.mockClear();
+
+    handlers.get(DETACHED_HIDE)!({ payload: { scope: "p", groupId } });
+
+    // The record still moved to hidden even for an inactive scope…
+    expect(useTabsStore.getState().hiddenGroupsByScope["p"]).toHaveLength(1);
+    // …and the scope is persisted so disk agrees (saved as hidden).
+    expect(invokeMock).toHaveBeenCalledWith(
+      "save_tab_layout",
+      expect.objectContaining({ localFile: "/p/project.json" }),
+    );
+  });
+
   it("a WM-close drops the group's tabs (no dock-back), kills their PTYs, and closes the window", async () => {
     const { groupId, label, bKey } = detachSecond();
     await listenDetachedHost();
diff --git a/src/__tests__/DetachedPaneDock.test.ts b/src/__tests__/DetachedPaneDock.test.ts
new file mode 100644
index 0000000..6ac8391
--- /dev/null
+++ b/src/__tests__/DetachedPaneDock.test.ts
@@ -0,0 +1,223 @@
+/**
+ * #42: dragging ONE PANE (inner group) out of a MULTI-pane detached popout.
+ *
+ * Regression for the "pane drop docked EVERY subwindow" bug: the pane's bar grip
+ * used to start a whole-popout drag, so releasing it over the main window ran
+ * `attachGroup(popoutId)` and re-injected the popout's ENTIRE subtree — every
+ * sibling pane — into the main layout. The pane path must move ONLY the dragged
+ * group and leave the siblings floating.
+ *
+ * Covers: the pure `decideDetachedPaneDrop` ladder, `attachDetachedPane`
+ * (multi-pane extraction, sibling survival, lone-pane delegation to the
+ * whole-group dock), and `detachPaneToNewWindow` (free-space release; lone-pane
+ * refusal).
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const { invokeMock } = vi.hoisted(() => ({
+  invokeMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+
+import { decideDetachedPaneDrop } from "../stores/detached";
+import {
+  useTabsStore,
+  allGroups,
+  orderedTabKeys,
+  type GroupNode,
+  type SplitNode,
+} from "../stores/tabs";
+
+const base = {
+  cancelled: false,
+  shift: false,
+  inMain: false,
+  overPopoutId: null as string | null,
+  srcGroupId: "src",
+};
+
+describe("decideDetachedPaneDrop", () => {
+  it("cancelled → none, winning over everything else", () => {
+    expect(decideDetachedPaneDrop({ ...base, cancelled: true }).kind).toBe("none");
+    expect(
+      decideDetachedPaneDrop({
+        ...base,
+        cancelled: true,
+        shift: true,
+        inMain: true,
+        overPopoutId: "b",
+      }).kind,
+    ).toBe("none");
+  });
+
+  it("Shift → newWindow, overriding main and popouts", () => {
+    expect(decideDetachedPaneDrop({ ...base, shift: true }).kind).toBe("newWindow");
+    expect(decideDetachedPaneDrop({ ...base, shift: true, inMain: true }).kind).toBe("newWindow");
+    expect(decideDetachedPaneDrop({ ...base, shift: true, overPopoutId: "b" }).kind).toBe(
+      "newWindow",
+    );
+  });
+
+  it("over a SIBLING popout → none (no pane→popout merge), even over main", () => {
+    expect(decideDetachedPaneDrop({ ...base, overPopoutId: "b" }).kind).toBe("none");
+    expect(decideDetachedPaneDrop({ ...base, overPopoutId: "b", inMain: true }).kind).toBe("none");
+  });
+
+  it("the SOURCE popout doesn't count as a sibling — inMain still docks", () => {
+    expect(decideDetachedPaneDrop({ ...base, overPopoutId: "src", inMain: true }).kind).toBe(
+      "dockMain",
+    );
+  });
+
+  it("over the main window → dockMain; free space → newWindow", () => {
+    expect(decideDetachedPaneDrop({ ...base, inMain: true }).kind).toBe("dockMain");
+    expect(decideDetachedPaneDrop({ ...base }).kind).toBe("newWindow");
+  });
+});
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  invokeMock.mockClear();
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    pendingRespawnByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+/**
+ * Build the bug's exact shape: a main layout of [a] plus a detached TWO-pane
+ * popout holding [b] and [c] (detach a two-tab group, then split it inside the
+ * popout). Returns the popout id + the two inner pane groups.
+ */
+function twoPanePopout() {
+  const store = useTabsStore.getState();
+  const a = store.addTab(tab("a"));
+  const b = store.addTab(tab("b"));
+  const c = store.addTab(tab("c"));
+  const rootGid = (useTabsStore.getState().layout as GroupNode).id;
+  // Move b+c into their own group to the right, then detach that group.
+  useTabsStore.getState().splitWithTab(b.key, rootGid, "right");
+  const right = (useTabsStore.getState().layout as SplitNode).children[1] as GroupNode;
+  useTabsStore.getState().moveTab(c.key, right.id);
+  const label = useTabsStore.getState().detachGroup(right.id)!;
+  expect(label).toBeTruthy();
+  const popoutId = right.id;
+  // Split inside the popout: [b] | [c].
+  useTabsStore.getState().splitDetachedGroup("p", popoutId, c.key, popoutId, "right");
+  const entry = useTabsStore.getState().detachedGroupsByScope.p.find((d) => d.id === popoutId)!;
+  const panes = allGroups(entry.subtree);
+  expect(panes).toHaveLength(2);
+  const paneB = panes.find((g) => g.tabKeys.includes(b.key))!;
+  const paneC = panes.find((g) => g.tabKeys.includes(c.key))!;
+  return { a, b, c, popoutId, paneB, paneC };
+}
+
+describe("tabs store — attachDetachedPane (#42)", () => {
+  beforeEach(reset);
+
+  it("docks ONLY the dragged pane; the sibling pane stays floating (the regression)", () => {
+    const { a, b, c, popoutId, paneC } = twoPanePopout();
+    invokeMock.mockClear();
+
+    useTabsStore.getState().attachDetachedPane("p", popoutId, paneC.id);
+
+    // Main layout gained exactly c — never b (the old bug docked the whole subtree).
+    const mainKeys = orderedTabKeys(useTabsStore.getState().layout);
+    expect(mainKeys).toContain(a.key);
+    expect(mainKeys).toContain(c.key);
+    expect(mainKeys).not.toContain(b.key);
+    // The popout survives, holding just the remaining pane.
+    const entry = useTabsStore.getState().detachedGroupsByScope.p.find((d) => d.id === popoutId)!;
+    expect(entry).toBeTruthy();
+    expect(orderedTabKeys(entry.subtree)).toEqual([b.key]);
+    // Its OS window must NOT close.
+    expect(invokeMock).not.toHaveBeenCalledWith("attach_subwindow", expect.anything());
+    // No payload lost or duplicated.
+    expect(useTabsStore.getState().tabsByScope.p).toHaveLength(3);
+  });
+
+  it("merges into a center target group instead of splitting when asked", () => {
+    const { a, c, popoutId, paneC } = twoPanePopout();
+    const mainGroup = allGroups(useTabsStore.getState().layout)[0];
+    useTabsStore
+      .getState()
+      .attachDetachedPane("p", popoutId, paneC.id, { targetGroupId: mainGroup.id, edge: "center" });
+    const groups = allGroups(useTabsStore.getState().layout);
+    const merged = groups.find((g) => g.id === mainGroup.id)!;
+    expect(merged.tabKeys).toEqual([a.key, c.key]);
+    expect(merged.activeKey).toBe(c.key);
+  });
+
+  it("the popout's ONLY pane delegates to the whole-group dock (window closes)", () => {
+    const { b, c, popoutId, paneB, paneC } = twoPanePopout();
+    useTabsStore.getState().attachDetachedPane("p", popoutId, paneC.id);
+    invokeMock.mockClear();
+    // Now the popout is single-pane; its subtree root collapsed to paneB's group.
+    useTabsStore.getState().attachDetachedPane("p", popoutId, paneB.id);
+    const mainKeys = orderedTabKeys(useTabsStore.getState().layout);
+    expect(mainKeys).toContain(b.key);
+    expect(mainKeys).toContain(c.key);
+    expect(useTabsStore.getState().detachedGroupsByScope.p).toHaveLength(0);
+    expect(invokeMock).toHaveBeenCalledWith("attach_subwindow", expect.anything());
+  });
+
+  it("no-ops when the popout or pane is gone", () => {
+    const { popoutId, paneC } = twoPanePopout();
+    const before = useTabsStore.getState();
+    useTabsStore.getState().attachDetachedPane("p", "nope", paneC.id);
+    useTabsStore.getState().attachDetachedPane("p", popoutId, "nope");
+    expect(useTabsStore.getState().layout).toBe(before.layout);
+    expect(useTabsStore.getState().detachedGroupsByScope).toBe(before.detachedGroupsByScope);
+  });
+});
+
+describe("tabs store — detachPaneToNewWindow (#42)", () => {
+  beforeEach(reset);
+
+  it("pops the pane into its own popout, leaving the sibling in the source", () => {
+    const { b, c, popoutId, paneC } = twoPanePopout();
+    invokeMock.mockClear();
+    const bounds = { x: 10, y: 20, w: 900, h: 640 };
+
+    const label = useTabsStore.getState().detachPaneToNewWindow("p", popoutId, paneC.id, bounds);
+
+    expect(label).toBeTruthy();
+    const entries = useTabsStore.getState().detachedGroupsByScope.p;
+    expect(entries).toHaveLength(2);
+    const src = entries.find((d) => d.id === popoutId)!;
+    const fresh = entries.find((d) => d.label === label)!;
+    expect(orderedTabKeys(src.subtree)).toEqual([b.key]);
+    expect(orderedTabKeys(fresh.subtree)).toEqual([c.key]);
+    expect(fresh.bounds).toEqual(bounds);
+    expect(invokeMock).toHaveBeenCalledWith("detach_subwindow", expect.objectContaining({
+      projectId: "p",
+      x: 10,
+      y: 20,
+    }));
+  });
+
+  it("refuses the popout's only pane — it already IS that pane's window", () => {
+    const { popoutId, paneC } = twoPanePopout();
+    useTabsStore.getState().attachDetachedPane("p", popoutId, paneC.id);
+    const entry = useTabsStore.getState().detachedGroupsByScope.p[0];
+    const lone = allGroups(entry.subtree)[0];
+    invokeMock.mockClear();
+    const label = useTabsStore
+      .getState()
+      .detachPaneToNewWindow("p", popoutId, lone.id, { x: 0, y: 0, w: 100, h: 100 });
+    expect(label).toBeNull();
+    expect(useTabsStore.getState().detachedGroupsByScope.p).toHaveLength(1);
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/DetachedShiftNewWindow.test.ts b/src/__tests__/DetachedShiftNewWindow.test.ts
new file mode 100644
index 0000000..f7337bd
--- /dev/null
+++ b/src/__tests__/DetachedShiftNewWindow.test.ts
@@ -0,0 +1,91 @@
+/**
+ * #42 (bug 1): Shift-dropping a tab out of a popout must pop it into its OWN new
+ * window. For a MULTI-tab popout that spawns a fresh single-tab popout; for a
+ * LONE-tab popout it must be a clean no-op (the source is already its own window),
+ * never the old local-split + Shift-bail hang.
+ *
+ * The host's `newWindow` branch (`decideDetachedTabDrop` → this action) commits
+ * into `detachTabToNewWindow`; this pins its two outcomes directly.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const { invokeMock } = vi.hoisted(() => ({
+  invokeMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+
+import { useTabsStore, allGroups, orderedTabKeys } from "../stores/tabs";
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  invokeMock.mockClear();
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    pendingRespawnByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+const s = () => useTabsStore.getState();
+const gid = (key: string) => allGroups(s().layout).find((g) => g.tabKeys.includes(key))!.id;
+const entry = (id: string) => s().detachedGroupsByScope["p"].find((d) => d.id === id);
+
+describe("tabs store — Shift-pop a popout tab into a new window (#42)", () => {
+  beforeEach(reset);
+
+  it("multi-tab popout: pops the tab into a fresh single-tab popout, source shrinks", () => {
+    const keep = s().addTab(tab("keep"));
+    const x = s().addTab(tab("x"));
+    const y = s().addTab(tab("y"));
+    const rootGid = gid(keep.key);
+    s().splitWithTab(x.key, rootGid, "right"); // [x] alone
+    s().moveTab(y.key, gid(x.key)); // SRC popout content = [x, y]
+    const srcId = gid(x.key);
+    s().detachGroup(srcId, { skipBackend: true });
+    invokeMock.mockClear();
+
+    const label = s().detachTabToNewWindow("p", srcId, x.key, { x: 10, y: 20, w: 900, h: 640 });
+
+    expect(label).toBeTruthy();
+    // Source popout shrinks to just y; a new detached record holds x alone.
+    expect(orderedTabKeys(entry(srcId)!.subtree)).toEqual([y.key]);
+    const fresh = s().detachedGroupsByScope["p"].find((d) => d.label === label)!;
+    expect(orderedTabKeys(fresh.subtree)).toEqual([x.key]);
+    // The new OS window is spawned; the payload stays shared (PTY survives).
+    expect(invokeMock).toHaveBeenCalledWith(
+      "detach_subwindow",
+      expect.objectContaining({ projectId: "p", groupId: expect.any(String) }),
+    );
+    expect(s().tabsByScope["p"].map((t) => t.key).sort()).toEqual(
+      [keep.key, x.key, y.key].sort(),
+    );
+  });
+
+  it("lone-tab popout: no-op (no new record, no window) — the no-hang guarantee", () => {
+    const keep = s().addTab(tab("keep"));
+    const x = s().addTab(tab("x"));
+    const rootGid = gid(keep.key);
+    s().splitWithTab(x.key, rootGid, "right"); // SRC popout content = [x]
+    const srcId = gid(x.key);
+    s().detachGroup(srcId, { skipBackend: true });
+    invokeMock.mockClear();
+    const before = s().detachedGroupsByScope["p"].length;
+
+    const label = s().detachTabToNewWindow("p", srcId, x.key, { x: 0, y: 0, w: 900, h: 640 });
+
+    expect(label).toBeNull();
+    expect(s().detachedGroupsByScope["p"]).toHaveLength(before);
+    expect(orderedTabKeys(entry(srcId)!.subtree)).toEqual([x.key]);
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/DetachedSplit.test.ts b/src/__tests__/DetachedSplit.test.ts
new file mode 100644
index 0000000..a4d2763
--- /dev/null
+++ b/src/__tests__/DetachedSplit.test.ts
@@ -0,0 +1,164 @@
+/**
+ * Multi-pane popouts — Phase 1 (store foundation): splitting a tab INSIDE a
+ * detached popout turns its single-group `subtree` into a split tree, mirroring
+ * the main window's `splitWithTab` but mutating the detached record. Also guards
+ * the single-group invariant is no longer assumed (the subtree is a LayoutNode).
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn() }));
+
+import {
+  useTabsStore,
+  allGroups,
+  orderedTabKeys,
+  splitSubtree,
+  withDetachedDocked,
+  type GroupNode,
+  type SplitNode,
+  type SavedLayoutTree,
+} from "../stores/tabs";
+import { applyEditToSubtree } from "../stores/detached";
+
+/** Collect every tab key referenced by a serialized tree. */
+function savedKeys(tree: SavedLayoutTree | null): string[] {
+  if (!tree) return [];
+  if (tree.type === "group") return tree.tabKeys;
+  return tree.children.flatMap(savedKeys);
+}
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    pendingRespawnByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+const s = () => useTabsStore.getState();
+
+/** Detach a 2-tab group [a,b] into a popout, leaving another group behind so the
+ *  detach is allowed (a lone group can't detach). Returns the popout record. */
+function popoutWithTwoTabs() {
+  const a = s().addTab(tab("a"));
+  const b = s().addTab(tab("b"));
+  const lid = (s().layout as GroupNode).id;
+  const c = s().addTab(tab("c"));
+  s().splitWithTab(c.key, lid, "right"); // L=[a,b], R=[c]
+  const label = s().detachGroup(lid, { skipBackend: true });
+  expect(label).toBeTruthy();
+  const det = s().detachedGroupsByScope["p"][0];
+  expect(det.subtree.type).toBe("group");
+  expect((det.subtree as GroupNode).tabKeys).toEqual([a.key, b.key]);
+  return { a, b, c, det };
+}
+
+describe("tabs store — split inside a detached popout", () => {
+  beforeEach(reset);
+
+  it("turns the popout's single-group subtree into a 2-pane split", () => {
+    const { a, b, det } = popoutWithTwoTabs();
+    const groupId = det.subtree.id;
+
+    s().splitDetachedGroup("p", det.id, b.key, groupId, "right");
+
+    const det2 = s().detachedGroupsByScope["p"][0];
+    expect(det2.id).toBe(det.id); // popout identity unchanged
+    expect(det2.subtree.type).toBe("split");
+    const split = det2.subtree as SplitNode;
+    expect(split.dir).toBe("row");
+    expect(split.children).toHaveLength(2);
+    const [g1, g2] = split.children as GroupNode[];
+    expect(g1.tabKeys).toEqual([a.key]);
+    expect(g2.tabKeys).toEqual([b.key]);
+    // Both tabs still belong to the popout (nothing leaked to the main layout).
+    expect(orderedTabKeys(det2.subtree).sort()).toEqual([a.key, b.key].sort());
+    expect(s().detachedGroupsByScope["p"]).toHaveLength(1);
+  });
+
+  it("splits along the column axis for a top/bottom edge", () => {
+    const { a, b, det } = popoutWithTwoTabs();
+    s().splitDetachedGroup("p", det.id, b.key, det.subtree.id, "bottom");
+    const split = s().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    expect(split.dir).toBe("column");
+    const [g1, g2] = split.children as GroupNode[];
+    expect(g1.tabKeys).toEqual([a.key]); // original stays first (top)
+    expect(g2.tabKeys).toEqual([b.key]); // new pane below
+  });
+
+  it("is a no-op when splitting a group's only tab onto its own edge", () => {
+    const { a, b, det } = popoutWithTwoTabs();
+    // First split → two single-tab panes.
+    s().splitDetachedGroup("p", det.id, b.key, det.subtree.id, "right");
+    const split = s().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    const paneA = (split.children as GroupNode[]).find((g) => g.tabKeys[0] === a.key)!;
+    // Splitting paneA's lone tab onto paneA's own edge must do nothing.
+    s().splitDetachedGroup("p", det.id, a.key, paneA.id, "left");
+    const after = s().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    expect(allGroups(after)).toHaveLength(2);
+  });
+
+  it("a 'split' DetachedEdit streamed from the popout splits the host's record", () => {
+    const { a, b, det } = popoutWithTwoTabs();
+    s().applyDetachedEdit("p", det.id, {
+      kind: "split",
+      key: b.key,
+      targetGroupId: det.subtree.id,
+      edge: "right",
+    });
+    const sub = s().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    expect(sub.type).toBe("split");
+    expect((sub.children as GroupNode[]).map((g) => g.tabKeys)).toEqual([[a.key], [b.key]]);
+  });
+});
+
+describe("detached — split via applyEditToSubtree (popout-local, pure)", () => {
+  it("splits a single-group subtree into a 2-pane tree", () => {
+    const g: GroupNode = { type: "group", id: "g1", tabKeys: ["a", "b"], activeKey: "a" };
+    const next = applyEditToSubtree(g, {
+      kind: "split",
+      key: "b",
+      targetGroupId: "g1",
+      edge: "bottom",
+    }) as SplitNode;
+    expect(next.type).toBe("split");
+    expect(next.dir).toBe("column");
+    expect((next.children as GroupNode[]).map((c) => c.tabKeys)).toEqual([["a"], ["b"]]);
+  });
+
+  it("matches the pure splitSubtree helper for the same inputs", () => {
+    const g: GroupNode = { type: "group", id: "g1", tabKeys: ["a", "b"], activeKey: "a" };
+    const viaHelper = splitSubtree(g, "b", "g1", "right") as SplitNode;
+    expect(viaHelper.type).toBe("split");
+    expect(orderedTabKeys(viaHelper).sort()).toEqual(["a", "b"]);
+  });
+});
+
+describe("detached — split popout persistence (respawns detached on restart)", () => {
+  beforeEach(reset);
+
+  it("tags the split popout detached so restore re-opens it as a floating window", () => {
+    const { a, b, det } = popoutWithTwoTabs();
+    s().splitDetachedGroup("p", det.id, b.key, det.subtree.id, "right");
+    const split = s().detachedGroupsByScope["p"][0];
+
+    const saved = withDetachedDocked(null, [split]);
+    // Both tabs are referenced by the saved tree → they persist across a restart.
+    expect(savedKeys(saved).sort()).toEqual([a.key, b.key].sort());
+    // The split structure is preserved AND tagged detached (with its bounds) so
+    // the respawn path re-detaches the whole subtree rather than docking it.
+    expect(saved?.type).toBe("split");
+    expect(saved?.type === "split" ? saved.detached : undefined).toBe(true);
+  });
+});
diff --git a/src/__tests__/DetachedSync.test.ts b/src/__tests__/DetachedSync.test.ts
index c18c0aa..1f99c8e 100644
--- a/src/__tests__/DetachedSync.test.ts
+++ b/src/__tests__/DetachedSync.test.ts
@@ -12,7 +12,7 @@ import {
   applyRenameToTabs,
   detachedSeedEvent,
 } from "../stores/detached";
-import type { GroupNode, TabEntry } from "../stores/tabs";
+import type { GroupNode, LayoutNode, SplitNode, TabEntry } from "../stores/tabs";
 
 function tab(key: string, label = key): TabEntry {
   return { key, scope: "p", label, cmd: "bash", cwd: "/p", kind: "shell" };
@@ -58,19 +58,19 @@ describe("detached — buildSeed", () => {
 describe("detached — applyEditToSubtree", () => {
   it("activate switches activeKey only for an owned key", () => {
     const sub = group(["a", "b"], "a");
-    expect(applyEditToSubtree(sub, { kind: "activate", key: "b" }).activeKey).toBe("b");
+    expect((applyEditToSubtree(sub, { kind: "activate", key: "b" }) as GroupNode).activeKey).toBe("b");
     // A non-owned key is a no-op.
     expect(applyEditToSubtree(sub, { kind: "activate", key: "z" })).toBe(sub);
   });
 
   it("close drops the key and re-derives activeKey when it was active", () => {
-    const next = applyEditToSubtree(group(["a", "b"], "a"), { kind: "close", key: "a" });
+    const next = applyEditToSubtree(group(["a", "b"], "a"), { kind: "close", key: "a" }) as GroupNode;
     expect(next.tabKeys).toEqual(["b"]);
     expect(next.activeKey).toBe("b");
   });
 
   it("close keeps activeKey when a non-active key is closed", () => {
-    const next = applyEditToSubtree(group(["a", "b"], "b"), { kind: "close", key: "a" });
+    const next = applyEditToSubtree(group(["a", "b"], "b"), { kind: "close", key: "a" }) as GroupNode;
     expect(next.tabKeys).toEqual(["b"]);
     expect(next.activeKey).toBe("b");
   });
@@ -79,7 +79,7 @@ describe("detached — applyEditToSubtree", () => {
     const next = applyEditToSubtree(group(["a", "b", "c"], "b"), {
       kind: "reorder",
       tabKeys: ["c", "b", "a"],
-    });
+    }) as GroupNode;
     expect(next.tabKeys).toEqual(["c", "b", "a"]);
     expect(next.activeKey).toBe("b");
   });
@@ -93,6 +93,103 @@ describe("detached — applyEditToSubtree", () => {
     const sub = group(["a", "b"], "a");
     expect(applyEditToSubtree(sub, { kind: "rename", key: "a", label: "x" })).toBe(sub);
   });
+
+  it("split carves a tab out into a new pane beside its group", () => {
+    const sub = group(["a", "b"], "a");
+    const next = applyEditToSubtree(sub, {
+      kind: "split",
+      key: "b",
+      targetGroupId: "g-1",
+      edge: "right",
+    }) as SplitNode;
+    expect(next.type).toBe("split");
+    expect(next.dir).toBe("row");
+    const [left, right] = next.children as GroupNode[];
+    expect(left.tabKeys).toEqual(["a"]);
+    expect(right.tabKeys).toEqual(["b"]);
+  });
+
+  it("split of a group's only tab is a no-op (keeps the subtree)", () => {
+    const sub = group(["a"], "a");
+    expect(
+      applyEditToSubtree(sub, { kind: "split", key: "a", targetGroupId: "g-1", edge: "right" }),
+    ).toBe(sub);
+  });
+
+  it("move merges a tab into another group's bar at the slot", () => {
+    // Split b out of [a, b] → row[ group[a], group[b] ], then split c... build a
+    // two-group popout with [a, b] | [c] and merge a into the [c] group at slot 0.
+    const split = applyEditToSubtree(group(["a", "b", "c"], "a"), {
+      kind: "split",
+      key: "c",
+      targetGroupId: "g-1",
+      edge: "right",
+    }) as SplitNode;
+    const [leftG, rightG] = split.children as GroupNode[];
+    expect(leftG.tabKeys).toEqual(["a", "b"]);
+    expect(rightG.tabKeys).toEqual(["c"]);
+    const merged = applyEditToSubtree(split, {
+      kind: "move",
+      key: "a",
+      targetGroupId: rightG.id,
+      index: 0,
+    }) as SplitNode;
+    const [l, r] = merged.children as GroupNode[];
+    expect(l.tabKeys).toEqual(["b"]);
+    expect(r.tabKeys).toEqual(["a", "c"]);
+    expect(r.activeKey).toBe("a");
+  });
+
+  it("move of a pane's only tab collapses the split back to one group", () => {
+    const split = applyEditToSubtree(group(["a", "b"], "a"), {
+      kind: "split",
+      key: "b",
+      targetGroupId: "g-1",
+      edge: "right",
+    }) as SplitNode;
+    const [leftG, rightG] = split.children as GroupNode[];
+    // Move b (the only tab of the right pane) onto the left group → un-split.
+    const merged = applyEditToSubtree(split, {
+      kind: "move",
+      key: "b",
+      targetGroupId: leftG.id,
+    });
+    expect((merged as GroupNode).type).toBe("group");
+    expect((merged as GroupNode).tabKeys).toEqual(["a", "b"]);
+    void rightG;
+  });
+
+  it("move into the tab's own group is a no-op (within-group reorder is separate)", () => {
+    const sub = group(["a", "b"], "a");
+    expect(applyEditToSubtree(sub, { kind: "move", key: "a", targetGroupId: "g-1" })).toBe(sub);
+  });
+
+  it("resize adjusts a split's divider fractions, clamped, leaving the pair sum", () => {
+    const sub: LayoutNode = applyEditToSubtree(group(["a", "b"], "a"), {
+      kind: "split",
+      key: "b",
+      targetGroupId: "g-1",
+      edge: "right",
+    })!;
+    const split = sub as SplitNode;
+    const next = applyEditToSubtree(split, {
+      kind: "resize",
+      splitId: split.id,
+      dividerIndex: 0,
+      fraction: 0.7,
+    }) as SplitNode;
+    expect(next.sizes[0]).toBeCloseTo(0.7);
+    expect(next.sizes[0] + next.sizes[1]).toBeCloseTo(1);
+    // Out-of-range fraction is clamped to the [min, pair-min] window.
+    const clampedHigh = applyEditToSubtree(split, {
+      kind: "resize",
+      splitId: split.id,
+      dividerIndex: 0,
+      fraction: 5,
+    }) as SplitNode;
+    expect(clampedHigh.sizes[0]).toBeLessThan(1);
+    expect(clampedHigh.sizes[0]).toBeGreaterThan(0.9);
+  });
 });
 
 describe("detached — applyRenameToTabs", () => {
diff --git a/src/__tests__/DetachedToDetachedDock.test.ts b/src/__tests__/DetachedToDetachedDock.test.ts
new file mode 100644
index 0000000..b49b86b
--- /dev/null
+++ b/src/__tests__/DetachedToDetachedDock.test.ts
@@ -0,0 +1,136 @@
+/**
+ * #42 (bug 4): move a tab from one open popout INTO another open popout of the
+ * same scope — the store side of the "attach a detached-window tab to another
+ * detached window" fix. `moveTabBetweenDetached` strips the tab from the source
+ * popout's subtree, places it in the destination's, keeps the payload (and thus
+ * the main-owned PTY) alive, and closes the source's OS window when it empties.
+ *
+ * This is the authority the host (`CenterPanel`'s `DETACHED_DRAG_END`) commits
+ * into for a `dockDetached` decision; if these pass, a runtime "popout→popout
+ * drag opens a stray new window" report is in the pointer/event layer, not here.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const { invokeMock } = vi.hoisted(() => ({
+  invokeMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+
+import { useTabsStore, allGroups, orderedTabKeys } from "../stores/tabs";
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  invokeMock.mockClear();
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    pendingRespawnByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+const s = () => useTabsStore.getState();
+const gid = (key: string) => allGroups(s().layout).find((g) => g.tabKeys.includes(key))!.id;
+const entry = (id: string) => s().detachedGroupsByScope["p"].find((d) => d.id === id);
+
+/**
+ * Build a keep-alive in-window group plus a SRC popout `[x, y]` and a DST popout
+ * `[z]`. The keep-alive group is required so detaching both others is allowed
+ * (`detachGroup` refuses the lone group). Returns the popout record ids + keys.
+ */
+function twoPopoutsSrcHasTwo() {
+  const keep = s().addTab(tab("keep"));
+  const x = s().addTab(tab("x"));
+  const y = s().addTab(tab("y"));
+  const z = s().addTab(tab("z"));
+  const rootGid = gid(keep.key);
+  s().splitWithTab(z.key, rootGid, "right"); // DST group = [z]
+  s().splitWithTab(x.key, rootGid, "bottom"); // [x] alone
+  s().moveTab(y.key, gid(x.key)); // SRC group = [x, y]
+  const srcId = gid(x.key);
+  const dstId = gid(z.key);
+  const srcLabel = s().detachGroup(srcId, { skipBackend: true })!;
+  s().detachGroup(dstId, { skipBackend: true });
+  invokeMock.mockClear();
+  return { keep, x, y, z, srcId, dstId, srcLabel };
+}
+
+/** Same, but the SRC popout holds a single tab `[x]` (so a move empties it). */
+function twoPopoutsSrcHasOne() {
+  const keep = s().addTab(tab("keep"));
+  const x = s().addTab(tab("x"));
+  const z = s().addTab(tab("z"));
+  const rootGid = gid(keep.key);
+  s().splitWithTab(z.key, rootGid, "right"); // DST = [z]
+  s().splitWithTab(x.key, rootGid, "bottom"); // SRC = [x]
+  const srcId = gid(x.key);
+  const dstId = gid(z.key);
+  const srcLabel = s().detachGroup(srcId, { skipBackend: true })!;
+  s().detachGroup(dstId, { skipBackend: true });
+  invokeMock.mockClear();
+  return { keep, x, z, srcId, dstId, srcLabel };
+}
+
+describe("tabs store — move a tab between two detached popouts (#42)", () => {
+  beforeEach(reset);
+
+  it("moves the tab into the sibling popout; the source shrinks but survives", () => {
+    const { keep, x, y, z, srcId, dstId } = twoPopoutsSrcHasTwo();
+
+    s().moveTabBetweenDetached("p", srcId, dstId, x.key);
+
+    // Source popout still open, now holding only y; destination holds z + x.
+    expect(orderedTabKeys(entry(srcId)!.subtree)).toEqual([y.key]);
+    expect(orderedTabKeys(entry(dstId)!.subtree).sort()).toEqual([z.key, x.key].sort());
+    // Every payload survives (the shared, main-owned PTYs never die).
+    expect(s().tabsByScope["p"].map((t) => t.key).sort()).toEqual(
+      [keep.key, x.key, y.key, z.key].sort(),
+    );
+    // The source wasn't emptied → no OS-window teardown.
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("closes the source popout's OS window when the move empties it", () => {
+    const { x, z, srcId, dstId, srcLabel } = twoPopoutsSrcHasOne();
+
+    s().moveTabBetweenDetached("p", srcId, dstId, x.key);
+
+    // Source record dropped; destination holds z + x.
+    expect(entry(srcId)).toBeUndefined();
+    expect(s().detachedGroupsByScope["p"]).toHaveLength(1);
+    expect(orderedTabKeys(entry(dstId)!.subtree).sort()).toEqual([z.key, x.key].sort());
+    // The emptied popout's OS window is closed via attach_subwindow.
+    expect(invokeMock).toHaveBeenCalledWith("attach_subwindow", { registryId: srcLabel });
+  });
+
+  it("skipBackend suppresses the OS-window teardown on empty", () => {
+    const { x, srcId, dstId } = twoPopoutsSrcHasOne();
+
+    s().moveTabBetweenDetached("p", srcId, dstId, x.key, undefined, { skipBackend: true });
+
+    expect(entry(srcId)).toBeUndefined();
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("no-ops (no state change, no backend call) on illegal moves", () => {
+    const { x, srcId, dstId } = twoPopoutsSrcHasTwo();
+    const snapshot = JSON.stringify(s().detachedGroupsByScope["p"]);
+
+    s().moveTabBetweenDetached("p", srcId, dstId, "nope"); // tab absent from source
+    s().moveTabBetweenDetached("p", "ghost", dstId, x.key); // source popout gone
+    s().moveTabBetweenDetached("p", srcId, "ghost", x.key); // dest popout gone
+    s().moveTabBetweenDetached("p", srcId, srcId, x.key); // src === dst
+
+    expect(JSON.stringify(s().detachedGroupsByScope["p"])).toBe(snapshot);
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/DirSizeGuard.test.ts b/src/__tests__/DirSizeGuard.test.ts
new file mode 100644
index 0000000..a5676d8
--- /dev/null
+++ b/src/__tests__/DirSizeGuard.test.ts
@@ -0,0 +1,145 @@
+/**
+ * The file tree's folder sizes must never be able to freeze the app.
+ *
+ * They are a display aid — the tree renders fine without them — but for a remote
+ * project each one is a `du` over SSH, and the tree fires one per visible folder
+ * at once. When the network under the project goes away (a dropped VPN tunnel,
+ * a suspended laptop) those calls do not *fail*: a black-holed socket returns no
+ * error, so each blocks until ssh's keepalive gives up ~45s later, holding a
+ * backend blocking-pool thread the whole time. Opening one folder of thirty
+ * subfolders then meant thirty stalled threads and a frozen UI.
+ *
+ * These lock the three limits that prevent that, and — just as importantly — the
+ * cases where the guard must stay out of the way.
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+
+import {
+  DirSizeUnavailable,
+  FAILURES_TO_OPEN,
+  MAX_CONCURRENT,
+  OPEN_MS,
+  TIMEOUT_MS,
+  guardedDirSize,
+  isHostTimeout,
+  resetDirSizeGuard,
+} from "../lib/dirSizeGuard";
+
+const PROJECT = "/home/u/eldrun/projects/demo";
+
+/** A call that never settles — what a black-holed SSH round trip looks like. */
+const hangs = () => new Promise<number>(() => {});
+
+beforeEach(() => {
+  resetDirSizeGuard();
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  resetDirSizeGuard();
+});
+
+describe("timeout", () => {
+  it("gives up on a call that never answers instead of hanging forever", async () => {
+    const settled = vi.fn();
+    const p = guardedDirSize(PROJECT, hangs).then(settled, settled);
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS - 1);
+    expect(settled).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(2);
+    await p;
+    expect(settled).toHaveBeenCalledOnce();
+    expect(isHostTimeout(settled.mock.calls[0][0])).toBe(true);
+  });
+
+  it("passes a prompt answer straight through", async () => {
+    await expect(guardedDirSize(PROJECT, () => Promise.resolve(4096))).resolves.toBe(4096);
+  });
+});
+
+describe("concurrency cap", () => {
+  it("holds calls beyond the cap back rather than dispatching them all at once", async () => {
+    const started = vi.fn();
+    for (let i = 0; i < MAX_CONCURRENT + 3; i += 1) {
+      void guardedDirSize(PROJECT, () => {
+        started();
+        return hangs();
+      }).catch(() => {});
+    }
+    await vi.advanceTimersByTimeAsync(0);
+    // The point: a wide folder must not fire one call per subfolder into a
+    // network that isn't answering.
+    expect(started).toHaveBeenCalledTimes(MAX_CONCURRENT);
+  });
+
+  it("hands a freed slot to the next waiter", async () => {
+    const started = vi.fn();
+    for (let i = 0; i < MAX_CONCURRENT + 1; i += 1) {
+      void guardedDirSize(PROJECT, () => {
+        started();
+        return hangs();
+      }).catch(() => {});
+    }
+    await vi.advanceTimersByTimeAsync(0);
+    expect(started).toHaveBeenCalledTimes(MAX_CONCURRENT);
+    // First in flight times out → its slot goes to the queued call.
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS + 1);
+    expect(started).toHaveBeenCalledTimes(MAX_CONCURRENT + 1);
+  });
+});
+
+describe("circuit breaker", () => {
+  /** Time out `n` calls back to back. */
+  async function timeOut(n: number) {
+    for (let i = 0; i < n; i += 1) {
+      const p = guardedDirSize(PROJECT, hangs).catch((e) => e);
+      await vi.advanceTimersByTimeAsync(TIMEOUT_MS + 1);
+      await p;
+    }
+  }
+
+  it("refuses instantly once the host has repeatedly failed to answer", async () => {
+    await timeOut(FAILURES_TO_OPEN);
+    // This is the whole point: the 30th folder costs nothing at all, instead of
+    // each one paying the timeout in turn.
+    const run = vi.fn(hangs);
+    await expect(guardedDirSize(PROJECT, run)).rejects.toBeInstanceOf(DirSizeUnavailable);
+    expect(run).not.toHaveBeenCalled();
+  });
+
+  it("does not open on failures that are not timeouts", async () => {
+    // An unreadable folder answered fine — it says nothing about the host, so it
+    // must not push the project toward a trip.
+    for (let i = 0; i < FAILURES_TO_OPEN + 2; i += 1) {
+      await guardedDirSize(PROJECT, () => Promise.reject(new Error("permission denied"))).catch(
+        () => {},
+      );
+    }
+    await expect(guardedDirSize(PROJECT, () => Promise.resolve(7))).resolves.toBe(7);
+  });
+
+  it("lets a retry through once the open window elapses", async () => {
+    await timeOut(FAILURES_TO_OPEN);
+    await vi.advanceTimersByTimeAsync(OPEN_MS + 1);
+    await expect(guardedDirSize(PROJECT, () => Promise.resolve(11))).resolves.toBe(11);
+  });
+
+  it("closes again on the first success, so one good answer restores the tree", async () => {
+    await timeOut(FAILURES_TO_OPEN - 1);
+    await expect(guardedDirSize(PROJECT, () => Promise.resolve(1))).resolves.toBe(1);
+    // The earlier timeouts are forgiven — the next timeout starts a fresh count
+    // rather than tripping the breaker immediately.
+    const p = guardedDirSize(PROJECT, hangs).catch((e) => e);
+    await vi.advanceTimersByTimeAsync(TIMEOUT_MS + 1);
+    await p;
+    const run = vi.fn(() => Promise.resolve(2));
+    await expect(guardedDirSize(PROJECT, run)).resolves.toBe(2);
+    expect(run).toHaveBeenCalledOnce();
+  });
+
+  it("is per project — one dead host does not stop another project's tree", async () => {
+    await timeOut(FAILURES_TO_OPEN);
+    await expect(guardedDirSize(PROJECT, hangs)).rejects.toBeInstanceOf(DirSizeUnavailable);
+    await expect(guardedDirSize("/home/u/other", () => Promise.resolve(99))).resolves.toBe(99);
+  });
+});
diff --git a/src/__tests__/DiskUsage.test.ts b/src/__tests__/DiskUsage.test.ts
new file mode 100644
index 0000000..5e89a5f
--- /dev/null
+++ b/src/__tests__/DiskUsage.test.ts
@@ -0,0 +1,247 @@
+import { describe, expect, it } from "vitest";
+import {
+  flattenRows,
+  formatBytes,
+  layoutRings,
+  ringPath,
+  sharePercent,
+  squarify,
+  type DuNode,
+} from "../lib/diskUsage";
+
+const TAU = Math.PI * 2;
+
+function file(name: string, size: number, parent = ""): DuNode {
+  return {
+    name,
+    path: `${parent}/${name}`,
+    size,
+    is_dir: false,
+    children: [],
+    hidden_children: 0,
+    hidden_bytes: 0,
+  };
+}
+
+function dir(name: string, children: DuNode[], parent = "", hidden = { count: 0, bytes: 0 }): DuNode {
+  const path = `${parent}/${name}`;
+  return {
+    name,
+    path,
+    size: children.reduce((s, c) => s + c.size, 0) + hidden.bytes,
+    is_dir: true,
+    children: [...children].sort((a, b) => b.size - a.size),
+    hidden_children: hidden.count,
+    hidden_bytes: hidden.bytes,
+  };
+}
+
+/** /root { big/ { b.bin 600, c.bin 200 }, small.bin 200 } — 1000 bytes total. */
+function tree(): DuNode {
+  const big = dir("big", [file("b.bin", 600, "/root/big"), file("c.bin", 200, "/root/big")], "/root");
+  return dir("root", [big, file("small.bin", 200, "/root")], "");
+}
+
+describe("formatBytes", () => {
+  it("steps through the units at each 1024 boundary", () => {
+    expect(formatBytes(0)).toBe("0 B");
+    expect(formatBytes(1023)).toBe("1023 B");
+    expect(formatBytes(1024)).toBe("1.0 K");
+    expect(formatBytes(1024 * 1024)).toBe("1.0 M");
+    expect(formatBytes(1024 ** 3)).toBe("1.00 G");
+    expect(formatBytes(1024 ** 4)).toBe("1.00 T");
+  });
+
+  it("drops the decimal once a unit reaches double digits", () => {
+    expect(formatBytes(10 * 1024)).toBe("10 K");
+    expect(formatBytes(9.5 * 1024)).toBe("9.5 K");
+  });
+
+  it("renders a non-size as a dash rather than NaN", () => {
+    expect(formatBytes(NaN)).toBe("—");
+    expect(formatBytes(-1)).toBe("—");
+  });
+});
+
+describe("sharePercent", () => {
+  it("is a percentage of the parent, and 0 when the parent is empty", () => {
+    expect(sharePercent(250, 1000)).toBe(25);
+    expect(sharePercent(5, 0)).toBe(0);
+  });
+});
+
+describe("flattenRows", () => {
+  it("yields only the root when nothing is expanded", () => {
+    const rows = flattenRows(tree(), new Set());
+    expect(rows).toHaveLength(1);
+    expect(rows[0].node.name).toBe("root");
+    expect(rows[0].depth).toBe(0);
+    expect(rows[0].expandable).toBe(true);
+  });
+
+  it("reveals a directory's children, biggest first, when it is expanded", () => {
+    const rows = flattenRows(tree(), new Set(["/root"]));
+    expect(rows.map((r) => r.node.name)).toEqual(["root", "big", "small.bin"]);
+    expect(rows.map((r) => r.depth)).toEqual([0, 1, 1]);
+  });
+
+  it("recurses into nested expanded directories and carries the parent size", () => {
+    const rows = flattenRows(tree(), new Set(["/root", "/root/big"]));
+    expect(rows.map((r) => r.node.name)).toEqual(["root", "big", "b.bin", "c.bin", "small.bin"]);
+    // b.bin's share bar is drawn against `big` (800), not the root (1000).
+    const bBin = rows.find((r) => r.node.name === "b.bin")!;
+    expect(bBin.parentSize).toBe(800);
+    expect(bBin.expandable).toBe(false);
+  });
+
+  it("ignores an expanded path that has no children to show", () => {
+    const rows = flattenRows(tree(), new Set(["/root", "/root/small.bin"]));
+    expect(rows.map((r) => r.node.name)).toEqual(["root", "big", "small.bin"]);
+  });
+});
+
+describe("layoutRings", () => {
+  it("does not draw the root — it is the centre disc", () => {
+    const arcs = layoutRings(tree());
+    expect(arcs.every((a) => a.depth >= 1)).toBe(true);
+    expect(arcs.some((a) => a.node?.name === "root")).toBe(false);
+  });
+
+  it("gives each ring's slices the full circle, split by size", () => {
+    const arcs = layoutRings(tree());
+    const ring1 = arcs.filter((a) => a.depth === 1);
+    expect(ring1.map((a) => a.node?.name)).toEqual(["big", "small.bin"]);
+
+    // big is 800/1000 of the root, small.bin the remaining 200/1000.
+    expect(ring1[0].a1 - ring1[0].a0).toBeCloseTo(TAU * 0.8);
+    expect(ring1[1].a1 - ring1[1].a0).toBeCloseTo(TAU * 0.2);
+    // ...and together they close the circle with no gap.
+    expect(ring1[0].a0).toBeCloseTo(0);
+    expect(ring1[ring1.length - 1].a1).toBeCloseTo(TAU);
+  });
+
+  it("nests a child inside its parent's sweep", () => {
+    const arcs = layoutRings(tree());
+    const big = arcs.find((a) => a.node?.name === "big")!;
+    const ring2 = arcs.filter((a) => a.depth === 2);
+    expect(ring2.map((a) => a.node?.name)).toEqual(["b.bin", "c.bin"]);
+    for (const arc of ring2) {
+      expect(arc.a0).toBeGreaterThanOrEqual(big.a0 - 1e-9);
+      expect(arc.a1).toBeLessThanOrEqual(big.a1 + 1e-9);
+    }
+    // b.bin is 600/800 of big.
+    expect(ring2[0].a1 - ring2[0].a0).toBeCloseTo((big.a1 - big.a0) * 0.75);
+  });
+
+  it("colours a whole branch from its top-level ancestor", () => {
+    const arcs = layoutRings(tree());
+    const big = arcs.find((a) => a.node?.name === "big")!;
+    const bBin = arcs.find((a) => a.node?.name === "b.bin")!;
+    const small = arcs.find((a) => a.node?.name === "small.bin")!;
+    expect(bBin.colorIndex).toBe(big.colorIndex);
+    expect(small.colorIndex).not.toBe(big.colorIndex);
+  });
+
+  it("stops at maxDepth", () => {
+    const arcs = layoutRings(tree(), 1);
+    expect(arcs.every((a) => a.depth === 1)).toBe(true);
+  });
+
+  it("drops slivers thinner than the minimum angle, along with their subtrees", () => {
+    const speck = dir("speck", [file("tiny.bin", 1, "/root/speck")], "/root");
+    const root = dir("root", [file("huge.bin", 1_000_000, "/root"), speck], "");
+    const arcs = layoutRings(root, 6, 1.2);
+    expect(arcs.map((a) => a.node?.name)).toEqual(["huge.bin"]);
+  });
+
+  it("draws the capped remainder of a wide directory as an 'others' slice", () => {
+    const root = dir("root", [file("a.bin", 750, "/root")], "", { count: 9, bytes: 250 });
+    const arcs = layoutRings(root);
+    const others = arcs.find((a) => a.node === null)!;
+    expect(others).toBeDefined();
+    expect(others.a1 - others.a0).toBeCloseTo(TAU * 0.25);
+    // It sits after the real children, closing the circle.
+    expect(others.a1).toBeCloseTo(TAU);
+  });
+});
+
+describe("ringPath", () => {
+  it("starts at 12 o'clock and sweeps clockwise", () => {
+    const d = ringPath(0, 0, 10, 20, 0, Math.PI / 2);
+    // Outer start point: straight up from the centre.
+    expect(d.startsWith("M 0 -20")).toBe(true);
+    // A quarter turn clockwise lands on the +x axis, so it is the short way round.
+    expect(d).toContain("A 20 20 0 0 1 20 ");
+  });
+
+  it("flags the large-arc case past a half turn", () => {
+    const d = ringPath(0, 0, 5, 10, 0, Math.PI * 1.5);
+    expect(d).toContain("A 10 10 0 1 1");
+  });
+
+  it("keeps a full-circle sector drawable by stopping just short of closing", () => {
+    const d = ringPath(0, 0, 5, 10, 0, TAU);
+    // Coincident endpoints would render nothing, so the sweep is nudged back.
+    expect(d).not.toContain("NaN");
+    const [, endX] = /A 10 10 0 1 1 (-?[\d.]+) (-?[\d.]+)/.exec(d)!;
+    expect(Math.abs(Number(endX))).toBeLessThan(0.01);
+  });
+});
+
+describe("squarify", () => {
+  const box = { x: 0, y: 0, w: 400, h: 300 };
+
+  it("tiles the box exactly, with areas proportional to size", () => {
+    const cells = squarify(tree(), box);
+    expect(cells.map((c) => c.node?.name).sort()).toEqual(["big", "small.bin"]);
+
+    const area = box.w * box.h;
+    const total = cells.reduce((s, c) => s + c.w * c.h, 0);
+    expect(total).toBeCloseTo(area, 6);
+
+    const big = cells.find((c) => c.node?.name === "big")!;
+    expect(big.w * big.h).toBeCloseTo(area * 0.8, 6);
+  });
+
+  it("keeps every cell inside the box", () => {
+    const many = dir(
+      "root",
+      Array.from({ length: 25 }, (_, i) => file(`f${i}.bin`, (i + 1) * 37, "/root")),
+      "",
+    );
+    for (const cell of squarify(many, box)) {
+      expect(cell.x).toBeGreaterThanOrEqual(-1e-6);
+      expect(cell.y).toBeGreaterThanOrEqual(-1e-6);
+      expect(cell.x + cell.w).toBeLessThanOrEqual(box.x + box.w + 1e-6);
+      expect(cell.y + cell.h).toBeLessThanOrEqual(box.y + box.h + 1e-6);
+      expect(cell.w).toBeGreaterThan(0);
+      expect(cell.h).toBeGreaterThan(0);
+    }
+  });
+
+  it("produces squarer cells than a naive slice-and-dice would", () => {
+    const many = dir(
+      "root",
+      Array.from({ length: 12 }, (_, i) => file(`f${i}.bin`, 100, "/root")),
+      "",
+    );
+    const cells = squarify(many, box);
+    expect(cells).toHaveLength(12);
+    // 12 equal cells in a 400×300 box: a slice-and-dice would give 33×300 slivers
+    // (ratio 9); squarified cells should be far closer to square.
+    const worst = Math.max(...cells.map((c) => Math.max(c.w / c.h, c.h / c.w)));
+    expect(worst).toBeLessThan(2);
+  });
+
+  it("gives the capped remainder its own cell", () => {
+    const root = dir("root", [file("a.bin", 750, "/root")], "", { count: 9, bytes: 250 });
+    const cells = squarify(root, box);
+    const others = cells.find((c) => c.node === null)!;
+    expect(others.w * others.h).toBeCloseTo(box.w * box.h * 0.25, 6);
+  });
+
+  it("returns nothing for an empty node or a collapsed box", () => {
+    expect(squarify(dir("empty", []), box)).toEqual([]);
+    expect(squarify(tree(), { x: 0, y: 0, w: 0, h: 300 })).toEqual([]);
+  });
+});
diff --git a/src/__tests__/DragDropSplit.test.tsx b/src/__tests__/DragDropSplit.test.tsx
index fab9c36..d5aad83 100644
--- a/src/__tests__/DragDropSplit.test.tsx
+++ b/src/__tests__/DragDropSplit.test.tsx
@@ -16,6 +16,24 @@ import { act, render, cleanup } from "@testing-library/react";
 
 vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve(undefined)) }));
 
+// CenterPanel installs detached-drag listeners and reads the window origin on
+// mount; none of that is exercised here, so stub the Tauri window/event APIs.
+vi.mock("@tauri-apps/api/event", () => ({
+  listen: vi.fn(() => Promise.resolve(() => {})),
+  emit: vi.fn(() => Promise.resolve()),
+}));
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({
+    scaleFactor: () => Promise.resolve(1),
+    innerPosition: () => Promise.resolve({ toLogical: () => ({ x: 0, y: 0 }) }),
+    onMoved: () => Promise.resolve(() => {}),
+    onResized: () => Promise.resolve(() => {}),
+  }),
+  // A drag starts a 16ms cursor-position poll (coords.startCursorPoll); the mock
+  // must export it or the polling timer throws a synchronous (uncatchable) error.
+  cursorPosition: () => Promise.resolve({ x: 0, y: 0 }),
+}));
+
 // The pane contents are irrelevant to the drop pipeline and pull in xterm.js /
 // FUSE-ish browser APIs jsdom lacks. Stub them with inert markers.
 vi.mock("../components/terminal/TerminalView", () => ({
diff --git a/src/__tests__/DragPreviewCollapse.test.ts b/src/__tests__/DragPreviewCollapse.test.ts
new file mode 100644
index 0000000..3f0b795
--- /dev/null
+++ b/src/__tests__/DragPreviewCollapse.test.ts
@@ -0,0 +1,133 @@
+/**
+ * Live source-subwindow collapse during a tab drag (dragPreviewLayout). When a
+ * subwindow's ONLY tab is dragged, the rendered layout prunes that subwindow so
+ * its siblings reflow to fill — it closes "on dragging", not just on the drop.
+ * This is render-only: the helper returns a NEW tree and never mutates the store
+ * layout (an aborted drag restores instantly), and only fires for the lone-tab
+ * case in a multi-subwindow layout.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn() }));
+
+import {
+  useTabsStore,
+  allGroups,
+  findGroup,
+  type GroupNode,
+  type SplitNode,
+} from "../stores/tabs";
+import { dragPreviewLayout } from "../components/tabs/dragPreview";
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+const s = () => useTabsStore.getState();
+
+/** Two side-by-side subwindows, each holding a single tab: left=[a], right=[b]. */
+function twoLoneSubwindows() {
+  const a = s().addTab(tab("a"));
+  const b = s().addTab(tab("b"));
+  const rootGid = (s().layout as GroupNode).id;
+  s().splitWithTab(b.key, rootGid, "right");
+  const root = s().layout as SplitNode;
+  const left = root.children[0] as GroupNode;
+  const right = root.children[1] as GroupNode;
+  expect(left.tabKeys).toEqual([a.key]);
+  expect(right.tabKeys).toEqual([b.key]);
+  return { a, b, left, right };
+}
+
+describe("dragPreviewLayout — live source-subwindow collapse", () => {
+  beforeEach(reset);
+
+  it("collapses the lone-tab source to its sibling while dragging it", () => {
+    const { a, b, left } = twoLoneSubwindows();
+    const layout = s().layout;
+
+    const preview = dragPreviewLayout(layout, "tab", a.key, left.id, false);
+
+    // The left (source) subwindow is pruned → the split unwraps to the lone right
+    // group, which now fills the panel.
+    expect(preview?.type).toBe("group");
+    expect((preview as GroupNode).tabKeys).toEqual([b.key]);
+    // The store layout itself is untouched (still the two-group split).
+    expect(s().layout).toBe(layout);
+    expect(allGroups(s().layout)).toHaveLength(2);
+  });
+
+  it("leaves the layout unchanged when the source group has other tabs", () => {
+    // left=[a1,a2], right=[b]; drag a1 — its subwindow survives (a2 stays), so no
+    // live collapse.
+    const a1 = s().addTab(tab("a1"));
+    const a2 = s().addTab(tab("a2"));
+    const rootGid = (s().layout as GroupNode).id;
+    const b = s().addTab(tab("b"));
+    s().splitWithTab(b.key, rootGid, "right");
+    const layout = s().layout;
+    const left = (layout as SplitNode).children[0] as GroupNode;
+    expect(left.tabKeys).toEqual([a1.key, a2.key]);
+
+    const preview = dragPreviewLayout(layout, "tab", a1.key, left.id, false);
+    expect(preview).toBe(layout); // unchanged
+  });
+
+  it("leaves the layout unchanged when it is the only subwindow", () => {
+    const a = s().addTab(tab("a"));
+    const layout = s().layout;
+    const gid = (layout as GroupNode).id;
+    // Lone tab AND only subwindow → nothing to expand into, so no collapse.
+    expect(dragPreviewLayout(layout, "tab", a.key, gid, false)).toBe(layout);
+  });
+
+  it("ignores non-tab drags (file/link/detached) and missing drag state", () => {
+    const { a, left } = twoLoneSubwindows();
+    const layout = s().layout;
+    expect(dragPreviewLayout(layout, "file", "", "", false)).toBe(layout);
+    expect(dragPreviewLayout(layout, null, null, null, false)).toBe(layout);
+    // A tab drag whose source group doesn't match (stale id) is a no-op too.
+    expect(dragPreviewLayout(layout, "tab", a.key, "g-nonexistent", false)).toBe(layout);
+    void left;
+  });
+
+  it("does not collapse while a group is fullscreen", () => {
+    const { a, left } = twoLoneSubwindows();
+    const layout = s().layout;
+    expect(dragPreviewLayout(layout, "tab", a.key, left.id, true)).toBe(layout);
+  });
+
+  it("collapses a lone source nested in a 3-way split, keeping the other two", () => {
+    // Build [G(a), G(b), G(c)] then drag b (the middle lone tab).
+    const a = s().addTab(tab("a"));
+    const b = s().addTab(tab("b"));
+    const c = s().addTab(tab("c"));
+    const gid = (s().layout as GroupNode).id;
+    s().splitWithTab(b.key, gid, "right");
+    const grps = allGroups(s().layout);
+    s().splitWithTab(c.key, grps[grps.length - 1].id, "right");
+    const layout = s().layout;
+    const bGroup = allGroups(layout).find((g) => g.tabKeys[0] === b.key)!;
+
+    const preview = dragPreviewLayout(layout, "tab", b.key, bGroup.id, false);
+    const previewGroups = allGroups(preview);
+    expect(previewGroups).toHaveLength(2);
+    expect(previewGroups.map((g) => g.tabKeys[0]).sort()).toEqual([a.key, c.key].sort());
+    // b's group is gone from the preview, but still present in the live store.
+    expect(findGroup(preview, bGroup.id)).toBeNull();
+    expect(findGroup(s().layout, bGroup.id)).toBeTruthy();
+  });
+});
diff --git a/src/__tests__/EditorChangeMark.test.ts b/src/__tests__/EditorChangeMark.test.ts
index e7304f4..ec912bd 100644
--- a/src/__tests__/EditorChangeMark.test.ts
+++ b/src/__tests__/EditorChangeMark.test.ts
@@ -1,10 +1,19 @@
 /**
- * Unit tests for the last-change marker helpers: `diffRange` (the inserted/
- * replaced run between two drafts) and `decorateChangeRange` (the transparent
- * overlay that tints that run). Mirrors the search-decoration tests.
+ * Unit tests for the change-tint trail helpers: `diffRange`/`editSpan` (the
+ * inserted/replaced run between two drafts), `remapChangeRange` (re-mapping an
+ * older run through a fresh edit), and `decorateChangeRanges` (the transparent
+ * overlay that tints those runs, sequenced new→old by tier). Mirrors the
+ * search-decoration tests.
  */
 import { describe, it, expect } from "vitest";
-import { diffRange, decorateChangeRange } from "../components/embed/FileViewerPane";
+import {
+  diffRange,
+  editSpan,
+  remapChangeRange,
+  decorateChangeRanges,
+  decorateDeleteRanges,
+  deletionGhostText,
+} from "../components/embed/FileViewerPane";
 
 describe("diffRange", () => {
   it("returns null when the text is unchanged", () => {
@@ -42,26 +51,143 @@ describe("diffRange", () => {
   });
 });
 
-describe("decorateChangeRange", () => {
-  it("wraps only the changed run in a change-mark span, escaping the rest", () => {
-    expect(decorateChangeRange("a<b>c", { start: 1, end: 4 })).toBe(
-      'a<span class="file-viewer-change-mark">&lt;b&gt;</span>c',
+describe("editSpan", () => {
+  it("returns null for equal strings", () => {
+    expect(editSpan("hi", "hi")).toBeNull();
+  });
+
+  it("reports the inserted run's prev/next ends (equal for a pure insert)", () => {
+    // "ab|cd" → "abXYcd": replaces prev[2,2] with next[2,4]
+    expect(editSpan("abcd", "abXYcd")).toEqual({ start: 2, endPrev: 2, endNext: 4 });
+  });
+
+  it("reports a pure deletion as a zero-width run in `next`", () => {
+    // remove "XY" from "abXYcd": replaces prev[2,4] with next[2,2]
+    expect(editSpan("abXYcd", "abcd")).toEqual({ start: 2, endPrev: 4, endNext: 2 });
+  });
+
+  it("reports a replacement spanning both prev and next runs", () => {
+    expect(editSpan("abcd", "aXYZd")).toEqual({ start: 1, endPrev: 3, endNext: 4 });
+  });
+});
+
+describe("remapChangeRange", () => {
+  // An insert of "XY" at offset 2: prev[2,2] → next[2,4], delta +2.
+  const insert = { start: 2, endPrev: 2, endNext: 4 };
+
+  it("leaves a range entirely before the edit untouched", () => {
+    expect(remapChangeRange({ start: 0, end: 2 }, insert)).toEqual({ start: 0, end: 2 });
+  });
+
+  it("shifts a range entirely after the edit by the length delta", () => {
+    expect(remapChangeRange({ start: 2, end: 4 }, insert)).toEqual({ start: 4, end: 6 });
+  });
+
+  it("drops a range overlapping the edited region", () => {
+    expect(remapChangeRange({ start: 1, end: 3 }, insert)).toBeNull();
+  });
+
+  it("shifts later ranges left through a deletion", () => {
+    // remove "XY" from offset 2: prev[2,4] → next[2,2], delta -2.
+    const del = { start: 2, endPrev: 4, endNext: 2 };
+    expect(remapChangeRange({ start: 6, end: 8 }, del)).toEqual({ start: 4, end: 6 });
+  });
+});
+
+describe("decorateChangeRanges", () => {
+  it("wraps a single run in a tiered change-mark span, escaping the rest", () => {
+    expect(decorateChangeRanges("a<b>c", [{ start: 1, end: 4, tier: 0 }])).toBe(
+      'a<span class="file-viewer-change-mark tier-0">&lt;b&gt;</span>c',
+    );
+  });
+
+  it("tints several runs in source order with their own tiers", () => {
+    expect(
+      decorateChangeRanges("abcde", [
+        { start: 3, end: 4, tier: 0 },
+        { start: 0, end: 1, tier: 1 },
+      ]),
+    ).toBe(
+      '<span class="file-viewer-change-mark tier-1">a</span>bc' +
+        '<span class="file-viewer-change-mark tier-0">d</span>e',
     );
   });
 
-  it("escapes HTML inside the marked run too", () => {
-    expect(decorateChangeRange("x&y", { start: 1, end: 2 })).toBe(
-      'x<span class="file-viewer-change-mark">&amp;</span>y',
+  it("escapes HTML inside a marked run too", () => {
+    expect(decorateChangeRanges("x&y", [{ start: 1, end: 2, tier: 2 }])).toBe(
+      'x<span class="file-viewer-change-mark tier-2">&amp;</span>y',
     );
   });
 
   it("clamps an out-of-range end to the source length", () => {
-    expect(decorateChangeRange("hi", { start: 0, end: 99 })).toBe(
-      '<span class="file-viewer-change-mark">hi</span>',
+    expect(decorateChangeRanges("hi", [{ start: 0, end: 99, tier: 0 }])).toBe(
+      '<span class="file-viewer-change-mark tier-0">hi</span>',
     );
   });
 
-  it("emits plain escaped text for a degenerate (empty) range", () => {
-    expect(decorateChangeRange("a<b", { start: 2, end: 2 })).toBe("a&lt;b");
+  it("emits plain escaped text when there are no usable ranges", () => {
+    expect(decorateChangeRanges("a<b", [{ start: 2, end: 2, tier: 0 }])).toBe("a&lt;b");
+  });
+});
+
+describe("decorateDeleteRanges", () => {
+  it("injects the deleted text at its anchor with a zero fade offset", () => {
+    // "hello world" had "world" removed → draft is "hello ", ghost anchored at 6.
+    expect(
+      decorateDeleteRanges("hello ", [{ id: 1, pos: 6, text: "world", born: 1000 }], 1000),
+    ).toBe(
+      'hello <span class="file-viewer-delete-mark" style="animation-delay:-0ms">world</span>',
+    );
+  });
+
+  it("offsets the fade by the elapsed time since the ghost was born", () => {
+    expect(
+      decorateDeleteRanges("ab", [{ id: 1, pos: 2, text: "c", born: 500 }], 1700),
+    ).toBe(
+      'ab<span class="file-viewer-delete-mark" style="animation-delay:-1200ms">c</span>',
+    );
+  });
+
+  it("escapes HTML in both the surrounding source and the deleted text", () => {
+    expect(
+      decorateDeleteRanges("x&y", [{ id: 1, pos: 1, text: "<b>", born: 0 }], 0),
+    ).toBe(
+      'x<span class="file-viewer-delete-mark" style="animation-delay:-0ms">&lt;b&gt;</span>&amp;y',
+    );
+  });
+
+  it("orders several ghosts by anchor and clamps an out-of-range anchor", () => {
+    expect(
+      decorateDeleteRanges(
+        "abc",
+        [
+          { id: 2, pos: 99, text: "Z", born: 0 },
+          { id: 1, pos: 1, text: "Y", born: 0 },
+        ],
+        0,
+      ),
+    ).toBe(
+      'a<span class="file-viewer-delete-mark" style="animation-delay:-0ms">Y</span>bc' +
+        '<span class="file-viewer-delete-mark" style="animation-delay:-0ms">Z</span>',
+    );
+  });
+});
+
+describe("deletionGhostText", () => {
+  it("trims a trailing space off the removed run", () => {
+    expect(deletionGhostText("big ")).toBe("big");
+  });
+
+  it("trims a leading space off the removed run", () => {
+    expect(deletionGhostText(" world")).toBe("world");
+  });
+
+  it("leaves a run with no surrounding whitespace unchanged", () => {
+    expect(deletionGhostText("world")).toBe("world");
+  });
+
+  it("returns null for a whitespace-only removal so no ghost is spawned", () => {
+    expect(deletionGhostText(" ")).toBeNull();
+    expect(deletionGhostText("\n")).toBeNull();
   });
 });
diff --git a/src/__tests__/EmbedCapabilityGate.test.ts b/src/__tests__/EmbedCapabilityGate.test.ts
index 729b481..3febb33 100644
--- a/src/__tests__/EmbedCapabilityGate.test.ts
+++ b/src/__tests__/EmbedCapabilityGate.test.ts
@@ -131,6 +131,9 @@ describe("commitFileDrop — dragged out of the window (detachBounds)", () => {
       "mousepad",
       "p",
       "file_drag_out",
+      // The external app is placed at the drop rectangle's origin, so it lands
+      // on the monitor the file was actually dragged onto.
+      { x: bounds.x, y: bounds.y },
     );
     // No standalone Eldrun window was spawned for it.
     expect(useTabsStore.getState().detachedGroupsByScope["p"] ?? []).toHaveLength(0);
diff --git a/src/__tests__/Experimental.test.ts b/src/__tests__/Experimental.test.ts
new file mode 100644
index 0000000..3dde60c
--- /dev/null
+++ b/src/__tests__/Experimental.test.ts
@@ -0,0 +1,45 @@
+/**
+ * The experimental-flag rule (`lib/experimental.ts`): a flag is a tri-state, and
+ * *unset* means "whatever debug mode says". Explicit always wins — in both
+ * directions, which is the half that is easy to get wrong.
+ */
+import { describe, it, expect } from "vitest";
+import { experimentalEnabled, EXPERIMENTAL_FLAGS } from "../lib/experimental";
+import type { Settings } from "../types";
+
+const s = (o: Partial<Settings>): Settings => o as Settings;
+
+describe("experimentalEnabled", () => {
+  it("is off when the flag is unset and debug mode is off", () => {
+    expect(experimentalEnabled(s({}), "python_run_debug")).toBe(false);
+    expect(experimentalEnabled(s({ debug: false }), "python_run_debug")).toBe(false);
+  });
+
+  it("is on when the flag is unset and debug mode is on", () => {
+    // The point of the gate: a new experiment reaches a debug build with no toggle.
+    expect(experimentalEnabled(s({ debug: true }), "python_run_debug")).toBe(true);
+    expect(experimentalEnabled(s({ debug: true }), "agent_mode_toggle")).toBe(true);
+  });
+
+  it("lets an explicit value win over debug mode, both ways", () => {
+    // Off while in debug mode — "turn this off" must work for the people most
+    // likely to hit a broken experiment.
+    expect(experimentalEnabled(s({ debug: true, python_run_debug: false }), "python_run_debug"))
+      .toBe(false);
+    // On without debug mode — an ordinary user can opt into one experiment.
+    expect(experimentalEnabled(s({ python_run_debug: true }), "python_run_debug")).toBe(true);
+  });
+
+  it("treats settings that have not loaded yet as off", () => {
+    expect(experimentalEnabled(null, "python_run_debug")).toBe(false);
+    expect(experimentalEnabled(undefined, "agent_mode_toggle")).toBe(false);
+  });
+
+  it("applies the same rule to every flag in the list", () => {
+    for (const flag of EXPERIMENTAL_FLAGS) {
+      expect(experimentalEnabled(s({}), flag)).toBe(false);
+      expect(experimentalEnabled(s({ debug: true }), flag)).toBe(true);
+      expect(experimentalEnabled(s({ debug: true, [flag]: false }), flag)).toBe(false);
+    }
+  });
+});
diff --git a/src/__tests__/FileDropIntoPopout.test.ts b/src/__tests__/FileDropIntoPopout.test.ts
new file mode 100644
index 0000000..90d69cd
--- /dev/null
+++ b/src/__tests__/FileDropIntoPopout.test.ts
@@ -0,0 +1,116 @@
+/**
+ * A file dragged from the right panel and released OVER an open popout must dock
+ * into it as an embed tab — mirroring a tab dragged onto a popout — instead of
+ * spawning a new standalone window. commitFileDrop's `detachedTarget` branch
+ * creates the embed tab in the scope, moves it into the popout's subtree
+ * (addTab + dockTabIntoDetached), and re-seeds the popout with the new key as
+ * `landedKey` so it plays the drop-in landing.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const { invokeMock, emitMock } = vi.hoisted(() => ({
+  invokeMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+  emitMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+vi.mock("@tauri-apps/api/event", () => ({ emit: (...a: unknown[]) => emitMock(...a) }));
+// detachedDropTargets imports WebviewWindow at module load; it is only exercised
+// by the live drag session (not this commit path), so a bare stub is enough.
+vi.mock("@tauri-apps/api/webviewWindow", () => ({ WebviewWindow: {} }));
+
+const openFileMock = vi.fn(() => Promise.resolve({} as never));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: { getState: () => ({ openFile: openFileMock }) },
+}));
+
+import { commitFileDrop } from "../components/tabs/commitFileDrop";
+import { detachedSeedEvent } from "../stores/detached";
+import { useTabsStore, type GroupNode, type SplitNode } from "../stores/tabs";
+import { type TabDrag, type EmbedCap } from "../stores/drag";
+
+const PASS: EmbedCap = { os_embeddable: true, app_embeddable: true, resolved_exec: "mousepad" };
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+// Build [G1=[b,c] (detached), G2=[a] (live)] and return ids + keys + popout label.
+function setup() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+  useTabsStore.getState().setScope("p");
+  const a = useTabsStore.getState().addTab(tab("a"));
+  const b = useTabsStore.getState().addTab(tab("b"));
+  const c = useTabsStore.getState().addTab(tab("c"));
+  const rootGid = (useTabsStore.getState().layout as GroupNode).id;
+  useTabsStore.getState().splitWithTab(a.key, rootGid, "right"); // G1=[b,c], new=[a]
+  const root = useTabsStore.getState().layout as SplitNode;
+  const left = root.children[0] as GroupNode; // [b,c]
+  const right = root.children[1] as GroupNode; // [a]
+  useTabsStore.getState().detachGroup(left.id); // detach [b,c]
+  const entry = useTabsStore.getState().detachedGroupsByScope["p"][0];
+  invokeMock.mockClear();
+  emitMock.mockClear();
+  return { a, b, c, g1: left.id, g2: right.id, label: entry.label };
+}
+
+function fileDrag(): TabDrag {
+  return {
+    kind: "file",
+    key: "",
+    fromGroup: "",
+    label: "notes.md",
+    pointerX: 0,
+    pointerY: 0,
+    overGroup: null,
+    edge: null,
+    reorderGroup: null,
+    reorderIndex: null,
+    filePath: "/p/notes.md",
+    fileName: "notes.md",
+    embedCap: PASS,
+  };
+}
+
+describe("commitFileDrop — dock a file INTO a popout", () => {
+  beforeEach(() => openFileMock.mockClear());
+
+  it("appends a new embed tab to the popout's subtree as its active tab", () => {
+    const { b, c, g1 } = setup();
+    commitFileDrop(fileDrag(), "p", "/p", null, { scope: "p", groupId: g1 });
+
+    const det = useTabsStore.getState().detachedGroupsByScope["p"];
+    expect(det).toHaveLength(1);
+    const sub = det[0].subtree as GroupNode;
+    const embed = useTabsStore.getState().tabs.find((t) => t.kind === "embed")!;
+    expect(embed.label).toBe("notes.md");
+    expect(embed.embedPath).toBe("/p/notes.md");
+    // Docked at the end of the popout's bar and activated there.
+    expect(sub.tabKeys).toEqual([b.key, c.key, embed.key]);
+    expect(sub.activeKey).toBe(embed.key);
+    // It never opens externally and spawns no new window.
+    expect(openFileMock).not.toHaveBeenCalled();
+  });
+
+  it("re-seeds the popout with the docked key as landedKey", () => {
+    const { label, g1 } = setup();
+    commitFileDrop(fileDrag(), "p", "/p", null, { scope: "p", groupId: g1 });
+
+    const embed = useTabsStore.getState().tabs.find((t) => t.kind === "embed")!;
+    const seedCall = emitMock.mock.calls.find((c) => c[0] === detachedSeedEvent(label));
+    expect(seedCall).toBeTruthy();
+    const payload = seedCall![1] as { landedKey?: string; tabs: { key: string }[] };
+    expect(payload.landedKey).toBe(embed.key);
+    // The seed carries the popout's tabs including the freshly-docked embed.
+    expect(payload.tabs.some((t) => t.key === embed.key)).toBe(true);
+  });
+});
diff --git a/src/__tests__/FileDropOccludedPopout.test.ts b/src/__tests__/FileDropOccludedPopout.test.ts
new file mode 100644
index 0000000..b614f16
--- /dev/null
+++ b/src/__tests__/FileDropOccludedPopout.test.ts
@@ -0,0 +1,123 @@
+/**
+ * Regression: a file dragged from the right panel and released INSIDE the main
+ * window must split in-window even when an OCCLUDED popout (one behind the main
+ * window) happens to sit under the cursor. Previously FileTree folded
+ * `overDetached` into its "outside the window" test, so an occluded popout — which
+ * the frontmost guard correctly refuses to dock into — still forced a brand-new
+ * standalone viewer window instead of an in-window split.
+ *
+ * The decision now lives in the pure `fileDropGoesToNewWindow`: only Shift or a
+ * release genuinely outside the viewport opens a new window; a popout under the
+ * cursor never does. Part A pins that predicate; Part B locks the user-facing
+ * outcome — with `detachBounds === null` (what an occluded popout now yields) a
+ * viewer file splits in-window rather than detaching.
+ */
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+const openFileMock = vi.fn(() => Promise.resolve({} as never));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: { getState: () => ({ openFile: openFileMock }) },
+}));
+
+import { commitFileDrop, fileDropGoesToNewWindow } from "../components/tabs/commitFileDrop";
+import { useTabsStore, allGroups, type GroupNode, type SplitNode } from "../stores/tabs";
+import { type TabDrag, type EmbedCap } from "../stores/drag";
+
+const PASS: EmbedCap = { os_embeddable: true, app_embeddable: true, resolved_exec: "mousepad" };
+const VIEWPORT = { w: 1000, h: 800 };
+
+describe("fileDropGoesToNewWindow — only Shift or a truly-outside release detaches", () => {
+  it("stays in-window for a release inside the viewport with no Shift", () => {
+    // This is the occluded-popout case: an invisible popout behind the cursor
+    // must NOT force a new window — the main window is what's actually under it.
+    expect(
+      fileDropGoesToNewWindow({ shiftKey: false, lastClient: { x: 500, y: 400 }, viewport: VIEWPORT }),
+    ).toBe(false);
+  });
+
+  it("detaches when Shift is held (explicit new-window override)", () => {
+    expect(
+      fileDropGoesToNewWindow({ shiftKey: true, lastClient: { x: 500, y: 400 }, viewport: VIEWPORT }),
+    ).toBe(true);
+  });
+
+  it("detaches when the release is outside any viewport edge", () => {
+    const inside = { x: 500, y: 400 };
+    expect(fileDropGoesToNewWindow({ shiftKey: false, lastClient: { ...inside, x: -1 }, viewport: VIEWPORT })).toBe(true);
+    expect(fileDropGoesToNewWindow({ shiftKey: false, lastClient: { ...inside, y: -1 }, viewport: VIEWPORT })).toBe(true);
+    expect(fileDropGoesToNewWindow({ shiftKey: false, lastClient: { ...inside, x: VIEWPORT.w }, viewport: VIEWPORT })).toBe(true);
+    expect(fileDropGoesToNewWindow({ shiftKey: false, lastClient: { ...inside, y: VIEWPORT.h }, viewport: VIEWPORT })).toBe(true);
+  });
+});
+
+function seedOneGroup() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+  const store = useTabsStore.getState();
+  store.setScope("p");
+  const a = store.addTab({ label: "a", cmd: "bash", cwd: "/p", kind: "shell" });
+  const b = store.addTab({ label: "b", cmd: "bash", cwd: "/p", kind: "shell" });
+  const groupId = (useTabsStore.getState().layout as GroupNode).id;
+  return { a, b, groupId };
+}
+
+// A viewer file dropped over a subwindow body edge — mirrors the user's repro
+// (a markdown/pdf file, the kind that wrongly spawned a standalone viewer window).
+function viewerDropOnEdge(groupId: string): TabDrag {
+  return {
+    kind: "file",
+    key: "",
+    fromGroup: "",
+    label: "notes.md",
+    pointerX: 0,
+    pointerY: 0,
+    overGroup: groupId,
+    edge: "right",
+    reorderGroup: null,
+    reorderIndex: null,
+    filePath: "/p/notes.md",
+    fileName: "notes.md",
+    viewer: "markdown",
+    embedCap: PASS,
+  };
+}
+
+describe("commitFileDrop — occluded popout yields an in-window split, not a new window", () => {
+  it("splits in-window (no detach) for a viewer file with detachBounds === null", () => {
+    const { a, b, groupId } = seedOneGroup();
+    // detachNewTab is the standalone-window path the bug wrongly took; it must
+    // not fire when the release resolves to an in-window target.
+    const detachSpy = vi.spyOn(useTabsStore.getState(), "detachNewTab");
+
+    // null detachBounds is exactly what the fix now produces for an occluded
+    // popout under the cursor (fileDropGoesToNewWindow → false).
+    commitFileDrop(viewerDropOnEdge(groupId), "p", "/p", null);
+
+    const layout = useTabsStore.getState().layout as SplitNode;
+    expect(layout.type).toBe("split");
+    const groups = allGroups(layout);
+    expect(groups).toHaveLength(2);
+
+    const orig = groups.find((g) => g.id === groupId)!;
+    expect(orig.tabKeys).toEqual([a.key, b.key]); // untouched
+    const embed = useTabsStore.getState().tabs.find((t) => t.kind === "embed")!;
+    expect(embed.label).toBe("notes.md");
+    expect(embed.viewer).toBe("markdown");
+    const newGroup = groups.find((g) => g.id !== groupId)!;
+    expect(newGroup.tabKeys).toEqual([embed.key]);
+
+    // Crucially: no standalone window and no external open.
+    expect(detachSpy).not.toHaveBeenCalled();
+    expect(openFileMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/FileTabSync.test.ts b/src/__tests__/FileTabSync.test.ts
new file mode 100644
index 0000000..c9e432d
--- /dev/null
+++ b/src/__tests__/FileTabSync.test.ts
@@ -0,0 +1,112 @@
+/**
+ * Delete/rename tab-sync: when a file is deleted or renamed/moved from the file
+ * tree/browser, its open viewer tabs must close (delete) or follow to the new
+ * path (rename). Covers the `retargetTabs` store action and the current-scope
+ * `closeTabsForDeletedPath`/`retargetTabsForRenamedPath` orchestration (no
+ * detached popouts here — those are exercised via the detached protocol tests).
+ * See src/components/files/fileTabSync.ts + tabs.ts retargetTabs.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn().mockResolvedValue(undefined) }));
+vi.mock("@tauri-apps/api/event", () => ({ emit: vi.fn(), listen: vi.fn() }));
+
+import { useTabsStore, type GroupNode, type TabEntry } from "../stores/tabs";
+import {
+  closeTabsForDeletedPath,
+  retargetTabsForRenamedPath,
+} from "../components/files/fileTabSync";
+
+function embedTab(key: string, embedPath: string, label = embedPath.slice(embedPath.lastIndexOf("/") + 1)): TabEntry {
+  return { key, scope: "p", label, cmd: "", cwd: "/p", kind: "embed", embedPath, viewer: "markdown" };
+}
+function shellTab(key: string): TabEntry {
+  return { key, scope: "p", label: key, cmd: "", cwd: "/p", kind: "shell" };
+}
+function group(id: string, tabKeys: string[]): GroupNode {
+  return { type: "group", id, tabKeys, activeKey: tabKeys[0] ?? null };
+}
+
+function seed(tabs: TabEntry[]) {
+  useTabsStore.setState({
+    scope: "p",
+    tabs,
+    activeKey: tabs[0]?.key ?? null,
+    layout: group("g", tabs.map((t) => t.key)),
+    focusedGroupId: "g",
+    tabsByScope: { p: tabs },
+    layoutByScope: { p: group("g", tabs.map((t) => t.key)) },
+    focusedGroupByScope: { p: "g" },
+    detachedGroupsByScope: {},
+  });
+}
+
+describe("tabs store — retargetTabs", () => {
+  beforeEach(() => {
+    seed([
+      embedTab("t1", "/p/notes.md"),
+      embedTab("t2", "/p/sub/a.md"),
+      shellTab("t3"),
+    ]);
+  });
+
+  it("rewrites an exact-match embedPath and refreshes the default label", () => {
+    useTabsStore.getState().retargetTabs("/p/notes.md", "/p/renamed.md");
+    const t1 = useTabsStore.getState().tabsByScope.p.find((t) => t.key === "t1")!;
+    expect(t1.embedPath).toBe("/p/renamed.md");
+    expect(t1.label).toBe("renamed.md");
+    // Flat mirror stays in sync so the active-scope CenterPanel re-renders.
+    expect(useTabsStore.getState().tabs.find((t) => t.key === "t1")!.embedPath).toBe("/p/renamed.md");
+  });
+
+  it("keeps a user-renamed label instead of clobbering it", () => {
+    seed([embedTab("t1", "/p/notes.md", "My Notes")]);
+    useTabsStore.getState().retargetTabs("/p/notes.md", "/p/renamed.md");
+    const t1 = useTabsStore.getState().tabsByScope.p[0];
+    expect(t1.embedPath).toBe("/p/renamed.md");
+    expect(t1.label).toBe("My Notes");
+  });
+
+  it("prefix-swaps tabs under a renamed/moved directory (label untouched)", () => {
+    useTabsStore.getState().retargetTabs("/p/sub", "/p/moved");
+    const t2 = useTabsStore.getState().tabsByScope.p.find((t) => t.key === "t2")!;
+    expect(t2.embedPath).toBe("/p/moved/a.md");
+    expect(t2.label).toBe("a.md");
+    // A sibling not under the directory is untouched.
+    expect(useTabsStore.getState().tabsByScope.p.find((t) => t.key === "t1")!.embedPath).toBe("/p/notes.md");
+  });
+
+  it("ignores non-embed tabs and is a no-op when nothing matches", () => {
+    const before = useTabsStore.getState().tabsByScope.p;
+    useTabsStore.getState().retargetTabs("/p/absent.md", "/p/x.md");
+    expect(useTabsStore.getState().tabsByScope.p).toBe(before);
+  });
+});
+
+describe("fileTabSync — current scope, no popouts", () => {
+  beforeEach(() => {
+    seed([
+      embedTab("t1", "/p/notes.md"),
+      embedTab("t2", "/p/sub/a.md"),
+      embedTab("t3", "/p/sub/b.md"),
+    ]);
+  });
+
+  it("closeTabsForDeletedPath removes the exact viewer tab", () => {
+    closeTabsForDeletedPath("/p/notes.md");
+    const keys = useTabsStore.getState().tabsByScope.p.map((t) => t.key);
+    expect(keys).toEqual(["t2", "t3"]);
+  });
+
+  it("closeTabsForDeletedPath removes every tab under a deleted folder", () => {
+    closeTabsForDeletedPath("/p/sub");
+    const keys = useTabsStore.getState().tabsByScope.p.map((t) => t.key);
+    expect(keys).toEqual(["t1"]);
+  });
+
+  it("retargetTabsForRenamedPath follows the file to its new path", () => {
+    retargetTabsForRenamedPath("/p/notes.md", "/p/renamed.md");
+    const t1 = useTabsStore.getState().tabsByScope.p.find((t) => t.key === "t1")!;
+    expect(t1.embedPath).toBe("/p/renamed.md");
+  });
+});
diff --git a/src/__tests__/FileTreeDirSize.test.tsx b/src/__tests__/FileTreeDirSize.test.tsx
new file mode 100644
index 0000000..0ac5d53
--- /dev/null
+++ b/src/__tests__/FileTreeDirSize.test.tsx
@@ -0,0 +1,177 @@
+/**
+ * Regression test for the folder-size holes in the right-panel file tree.
+ *
+ * `load()` sets rawEntries, which fires the size-fetch effects, and only THEN
+ * awaits `git_file_statuses` — whose result changes `sections`' identity. When
+ * the effects cancelled on that (a `cancelled` flag in their cleanup), every
+ * size call still walking at that moment had its bytes thrown away, while the
+ * `requestedSizes` guard kept the folder from ever being re-requested. Small
+ * folders won the race and showed a size; a big one — `results/` in a training
+ * project, exactly what the feature is for — never did.
+ *
+ * So: resolve `dir_size_breakdown` only AFTER `git_file_statuses` has landed,
+ * and assert the size still renders.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act } from "@testing-library/react";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("../stores/projects", () => ({ useProjectsStore: vi.fn() }));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: () => ({ windows: [], refresh: vi.fn(), untrack: vi.fn() }),
+}));
+vi.mock("../stores/settings", () => ({ useSettingsStore: () => null }));
+
+import { useProjectsStore } from "../stores/projects";
+import { RightPanel } from "../components/layout/RightPanel";
+
+const mockUseProjectsStore = vi.mocked(useProjectsStore);
+
+const ACTIVE_PROJECT = {
+  id: "proj-1",
+  name: "demoproj",
+  status: "active",
+  position: 0,
+  local_file: "/tmp/demoproj/project.json",
+};
+
+function dirEntry(name: string) {
+  return {
+    name,
+    path: `/tmp/demoproj/${name}`,
+    is_dir: true,
+    size: 0,
+    extension: null,
+    mime: null,
+  };
+}
+
+describe("file tree folder sizes", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const state = {
+      projects: [ACTIVE_PROJECT],
+      activeId: "proj-1",
+      rightPanelFolderByProject: {},
+      setRightPanelFolder: vi.fn(),
+    } as unknown as ReturnType<typeof useProjectsStore>;
+    mockUseProjectsStore.mockImplementation(((selector?: (s: typeof state) => unknown) =>
+      selector ? selector(state) : state) as typeof useProjectsStore);
+  });
+
+  it("shows a folder's size even when the walk outlives the git-status round-trip", async () => {
+    // Two round-trips held open by hand. They must land in this order, and each
+    // in its OWN render — that is the whole bug. Resolving them both eagerly lets
+    // React batch `setRawEntries` and `setGitStatuses` into one render, the size
+    // effect never sees the intermediate state, and the race can't happen at all.
+    const deferred = <T,>() => {
+      let release!: (v: T) => void;
+      const promise = new Promise<T>((res) => { release = res; });
+      return { promise, release };
+    };
+    const statuses = deferred<Record<string, string>>();
+    const size = deferred<{ total: number; ignored: number }>();
+
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "list_dir") return Promise.resolve([dirEntry("results")]);
+      // New object identity when it lands → `sections` recomputes → the effects'
+      // old cleanup fired and cancelled the size call still in flight.
+      if (cmd === "git_file_statuses") return statuses.promise;
+      if (cmd === "dir_size_breakdown") return size.promise; // the slow walk
+      if (cmd === "dir_size") return Promise.resolve(0);
+      if (cmd === "git_status")
+        return Promise.resolve({ staged: 0, unstaged: 0, untracked: 0, has_remote: false, is_repo: false });
+      if (cmd === "git_unpushed_commits") return Promise.resolve([]);
+      if (cmd === "load_project") return Promise.resolve({});
+      if (cmd === "list_project_endings") return Promise.resolve([]);
+      return Promise.resolve(null);
+    });
+
+    // 1. The listing lands and renders; the size effect dispatches the walk.
+    await act(async () => {
+      render(<RightPanel open={true} />);
+    });
+    expect(await screen.findByText("results")).toBeTruthy();
+    expect(mockInvoke).toHaveBeenCalledWith(
+      "dir_size_breakdown",
+      expect.objectContaining({ relPath: "results" }),
+    );
+
+    // 2. Git statuses land while the walk is still running.
+    await act(async () => {
+      statuses.release({});
+      await statuses.promise;
+    });
+
+    // 3. Only now does the walk finish: 2 GiB.
+    await act(async () => {
+      size.release({ total: 2 * 1024 * 1024 * 1024, ignored: 0 });
+      await size.promise;
+    });
+
+    // Scoped to the row: the section-total line shows the same figure.
+    const row = screen.getByText("results").closest(".file-entry");
+    expect(row?.querySelector(".file-size")?.textContent).toBe("2.0 GB");
+  });
+
+  it("never walks a folder excluded from scans", async () => {
+    // The point of the feature is the *absence* of the call: a 50 GB virtualenv
+    // is not made cheap by discarding its result, only by never descending it.
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "list_dir") return Promise.resolve([dirEntry("venv"), dirEntry("src")]);
+      if (cmd === "git_file_statuses") return Promise.resolve({});
+      if (cmd === "dir_size_breakdown") return Promise.resolve({ total: 10, ignored: 0 });
+      if (cmd === "dir_size") return Promise.resolve(10);
+      if (cmd === "git_status")
+        return Promise.resolve({ staged: 0, unstaged: 0, untracked: 0, has_remote: false, is_repo: false });
+      if (cmd === "git_unpushed_commits") return Promise.resolve([]);
+      // The project's saved exclusion list — `venv` is out, `src` is not.
+      if (cmd === "load_project") return Promise.resolve({ scan_excluded_paths: ["venv"] });
+      if (cmd === "list_project_endings") return Promise.resolve([]);
+      return Promise.resolve(null);
+    });
+
+    await act(async () => {
+      render(<RightPanel open={true} />);
+    });
+    expect(await screen.findByText("venv")).toBeTruthy();
+
+    const walked = (relPath: string) =>
+      mockInvoke.mock.calls.some(
+        ([cmd, args]) =>
+          (cmd === "dir_size" || cmd === "dir_size_breakdown") &&
+          (args as { relPath?: string } | undefined)?.relPath === relPath,
+      );
+    expect(walked("venv")).toBe(false);
+    expect(walked("src")).toBe(true);
+
+    // The row still lists — the exclusion has to stay reversible from the row it
+    // applies to — but says so instead of showing a stale or absent size.
+    const row = screen.getByText("venv").closest(".file-entry");
+    expect(row?.querySelector(".file-size")?.textContent).toBe("not scanned");
+  });
+
+  it("moves an entirely ignored folder out of the normal 0 B list when statuses omit it", async () => {
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "list_dir") return Promise.resolve([dirEntry("cache")]);
+      if (cmd === "git_file_statuses") return Promise.resolve({});
+      if (cmd === "dir_size_breakdown") return Promise.resolve({ total: 4096, ignored: 4096 });
+      if (cmd === "dir_size") return Promise.resolve(4096);
+      if (cmd === "git_status")
+        return Promise.resolve({ staged: 0, unstaged: 0, untracked: 0, has_remote: false, is_repo: true });
+      if (cmd === "git_unpushed_commits") return Promise.resolve([]);
+      if (cmd === "load_project") return Promise.resolve({});
+      if (cmd === "list_project_endings") return Promise.resolve([]);
+      return Promise.resolve(null);
+    });
+
+    await act(async () => {
+      render(<RightPanel open={true} />);
+    });
+
+    expect(await screen.findByText("gitignored (1)")).toBeTruthy();
+    expect(screen.queryByText("cache")).toBeNull();
+  });
+});
diff --git a/src/__tests__/FileTreeNav.test.tsx b/src/__tests__/FileTreeNav.test.tsx
index 21a2af3..b92697d 100644
--- a/src/__tests__/FileTreeNav.test.tsx
+++ b/src/__tests__/FileTreeNav.test.tsx
@@ -1,7 +1,8 @@
 /**
  * Render tests for the right-panel file tree navigation:
- * - #2 (Group D.1): a file's `.file-name` span carries a native `title` with the
- *   full name so long names are readable on hover (CSS ellipsis aside).
+ * - #2 (Group D.1): a file's full name is readable on hover via the existing
+ *   custom `.file-tooltip` popup (not a native `title` attribute — that used
+ *   to render as an unthemed OS tooltip instead of the app's own hover UI).
  * - #3 (Group D.1): entering a subfolder renders a breadcrumb (↑, ⌂ root crumb,
  *   and a crumb per path segment); clicking the root crumb navigates back.
  */
@@ -55,6 +56,7 @@ function setupInvoke() {
       );
     }
     if (cmd === "git_status") return Promise.resolve({ staged: 0, unstaged: 0, untracked: 0, has_remote: false, is_repo: false });
+    if (cmd === "git_unpushed_commits") return Promise.resolve([]);
     if (cmd === "git_file_statuses") return Promise.resolve({});
     if (cmd === "load_project") return Promise.resolve({});
     if (cmd === "list_project_endings") return Promise.resolve([]);
@@ -72,16 +74,31 @@ describe("file tree navigation", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     setupInvoke();
-    mockUseProjectsStore.mockReturnValue(
-      { projects: [ACTIVE_PROJECT], activeId: "proj-1" } as ReturnType<typeof useProjectsStore>,
-    );
+    // Apply the selector like real zustand: FileTree subscribes with selectors
+    // (e.g. `(s) => !!s.projects.find(...)?.remote`), so the mock must run the
+    // selector against the state — returning the whole state object would make
+    // those boolean selectors truthy (a non-empty object) and mis-flag the local
+    // test project as remote.
+    const state = {
+      projects: [ACTIVE_PROJECT],
+      activeId: "proj-1",
+      rightPanelFolderByProject: {},
+      setRightPanelFolder: vi.fn(),
+    } as unknown as ReturnType<typeof useProjectsStore>;
+    mockUseProjectsStore.mockImplementation(((selector?: (s: typeof state) => unknown) =>
+      selector ? selector(state) : state) as typeof useProjectsStore);
   });
 
-  it("#2 shows the full file name in a title attribute", async () => {
+  it("#2 shows the full file name in the hover tooltip, not a title attribute", async () => {
     await renderPanel();
     const nameSpan = await screen.findByText(LONG_NAME);
     expect(nameSpan.classList.contains("file-name")).toBe(true);
-    expect(nameSpan.getAttribute("title")).toBe(LONG_NAME);
+    expect(nameSpan.getAttribute("title")).toBeNull();
+
+    const row = nameSpan.closest(".file-entry");
+    expect(row).toBeTruthy();
+    fireEvent.mouseEnter(row!);
+    expect(await screen.findByText(LONG_NAME, { selector: ".file-tooltip-name" })).toBeTruthy();
   });
 
   it("#3 builds a breadcrumb on entering a subfolder and the root crumb goes back", async () => {
@@ -107,13 +124,37 @@ describe("file tree navigation", () => {
     expect(document.querySelector(".file-tree-breadcrumb")).toBeNull();
   });
 
+  it("seeds relPath from the saved folder so a mount never flashes root", () => {
+    // Store remembers `proj-1` was last browsing the `sub` folder.
+    const state = {
+      projects: [ACTIVE_PROJECT],
+      activeId: "proj-1",
+      rightPanelFolderByProject: { "proj-1": "sub" },
+      setRightPanelFolder: vi.fn(),
+    } as unknown as ReturnType<typeof useProjectsStore>;
+    mockUseProjectsStore.mockImplementation(((selector?: (s: typeof state) => unknown) =>
+      selector ? selector(state) : state) as typeof useProjectsStore);
+
+    // Synchronous render (no awaited flush): the async `load("sub")` has NOT
+    // resolved yet, so `relPath` reflects only its initial value. With the fix it
+    // is seeded from `initialRelPath="sub"`, so the breadcrumb (driven by
+    // `relPath`, not the entry listing) is on screen on the first commit. The old
+    // `useState("")` would render root here and only reach `sub` after the load
+    // resolved — the "flash root" this test guards against.
+    render(<RightPanel open={true} />);
+    expect(document.querySelector(".file-tree-breadcrumb")).not.toBeNull();
+    expect(document.querySelector(".file-tree-crumb[title='Project root']")).toBeTruthy();
+  });
+
   it("#1 'New File' from the context menu prompts and calls create_file", async () => {
     const user = userEvent.setup();
     const promptSpy = vi.spyOn(window, "prompt").mockReturnValue("created.ts");
     await renderPanel();
 
-    // Right-click an entry to open the shared context menu, then choose New File.
-    fireEvent.contextMenu(await screen.findByText("sub"));
+    // Right-click the file-tree background to open the root context menu (New
+    // File / New Folder live there, not on the per-entry menu), then choose New File.
+    await screen.findByText("sub");
+    fireEvent.contextMenu(document.querySelector(".file-tree")!);
     await user.click(await screen.findByText("New File"));
 
     expect(promptSpy).toHaveBeenCalled();
diff --git a/src/__tests__/FileTreeRowCap.test.tsx b/src/__tests__/FileTreeRowCap.test.tsx
new file mode 100644
index 0000000..b874df3
--- /dev/null
+++ b/src/__tests__/FileTreeRowCap.test.tsx
@@ -0,0 +1,150 @@
+/**
+ * Regression test for the render cap on the right-panel file tree.
+ *
+ * The tree renders its rows unvirtualized, and each row is ~16 elements with
+ * ~11 handlers that are rebuilt on every render of the component. A folder with
+ * thousands of files therefore built six figures of DOM and re-reconciled the
+ * lot every time a folder size landed, a sync status refreshed, or the pointer
+ * moved — which is what made a real project (an ML sweep whose `results/` holds
+ * one CSV per config × per validation step, 8316 of them, with the gitignored
+ * section expanded) freeze the whole window while the CPU sat idle: the cost was
+ * layout and paint in a software-rendered webview, not compute.
+ *
+ * So: render at most ROW_CAP_STEP rows, with a footer that reveals another page.
+ * The count in a section header must keep reporting the WHOLE folder — a header
+ * that counted only the rendered page would quietly misreport what is on disk.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act, fireEvent } from "@testing-library/react";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("../stores/projects", () => ({ useProjectsStore: vi.fn() }));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: () => ({ windows: [], refresh: vi.fn(), untrack: vi.fn() }),
+}));
+vi.mock("../stores/settings", () => ({ useSettingsStore: () => null }));
+
+import { useProjectsStore } from "../stores/projects";
+import { RightPanel } from "../components/layout/RightPanel";
+
+const mockUseProjectsStore = vi.mocked(useProjectsStore);
+
+// Mirrors ROW_CAP_STEP in FileTree.tsx. Kept as a literal rather than exported
+// from the component: the test is asserting the user-visible contract ("a page
+// at a time"), so it should fail if the page size silently changes.
+const CAP = 100;
+// Two full pages plus a short one, so the last click can assert that the footer
+// reveals only the remainder and then retires.
+const TOTAL = 250;
+
+const ACTIVE_PROJECT = {
+  id: "proj-1",
+  name: "demoproj",
+  status: "active",
+  position: 0,
+  local_file: "/tmp/demoproj/project.json",
+};
+
+function fileEntry(name: string) {
+  return {
+    name,
+    path: `/tmp/demoproj/${name}`,
+    is_dir: false,
+    size: 10,
+    extension: "csv",
+    mime: null,
+  };
+}
+
+/** `TOTAL` plain files, the shape of one sweep's results folder. */
+const BIG_LISTING = Array.from({ length: TOTAL }, (_, i) =>
+  fileEntry(`run_${String(i).padStart(5, "0")}.csv`),
+);
+
+function baseInvoke(cmd: string) {
+  if (cmd === "list_dir") return Promise.resolve(BIG_LISTING);
+  if (cmd === "git_file_statuses") return Promise.resolve({});
+  if (cmd === "dir_size_breakdown") return Promise.resolve({ total: 0, ignored: 0 });
+  if (cmd === "dir_size") return Promise.resolve(0);
+  if (cmd === "git_status")
+    return Promise.resolve({ staged: 0, unstaged: 0, untracked: 0, has_remote: false, is_repo: false });
+  if (cmd === "git_unpushed_commits") return Promise.resolve([]);
+  if (cmd === "load_project") return Promise.resolve({});
+  if (cmd === "list_project_endings") return Promise.resolve([]);
+  return Promise.resolve(null);
+}
+
+describe("file tree render cap", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const state = {
+      projects: [ACTIVE_PROJECT],
+      activeId: "proj-1",
+      rightPanelFolderByProject: {},
+      setRightPanelFolder: vi.fn(),
+    } as unknown as ReturnType<typeof useProjectsStore>;
+    mockUseProjectsStore.mockImplementation(((selector?: (s: typeof state) => unknown) =>
+      selector ? selector(state) : state) as typeof useProjectsStore);
+    mockInvoke.mockImplementation(baseInvoke);
+  });
+
+  const rowCount = () => document.querySelectorAll(".file-entry").length;
+
+  it("renders one page of a huge folder instead of all of it", async () => {
+    await act(async () => {
+      render(<RightPanel open={true} />);
+    });
+    expect(await screen.findByText("run_00000.csv")).toBeTruthy();
+
+    // The bug: every one of the 1200 rows in the DOM. The fix: exactly one page.
+    expect(rowCount()).toBe(CAP);
+    // A row past the cap is genuinely absent, not merely hidden — the whole
+    // point is that it costs no DOM.
+    expect(screen.queryByText(`run_${String(CAP).padStart(5, "0")}.csv`)).toBeNull();
+  });
+
+  it("reveals another page per click, and says how many are held back", async () => {
+    await act(async () => {
+      render(<RightPanel open={true} />);
+    });
+    await screen.findByText("run_00000.csv");
+
+    const more = () => document.querySelector<HTMLButtonElement>(".file-tree-more");
+
+    // The footer names the remainder rather than leaving it a mystery.
+    expect(more()?.textContent).toContain(String(TOTAL - CAP));
+
+    await act(async () => {
+      fireEvent.click(more()!);
+    });
+    expect(rowCount()).toBe(2 * CAP);
+    // The revealed page EXTENDS the list — the first row is still the first row,
+    // so raising the cap never reshuffles what the user was looking at.
+    expect(screen.getByText("run_00000.csv")).toBeTruthy();
+    expect(screen.getByText(`run_${String(CAP).padStart(5, "0")}.csv`)).toBeTruthy();
+
+    // Last page: the folder is fully reachable and the footer retires.
+    await act(async () => {
+      fireEvent.click(more()!);
+    });
+    expect(rowCount()).toBe(TOTAL);
+    expect(more()).toBeNull();
+  });
+
+  it("leaves an ordinary folder untouched — no cap footer, every row rendered", async () => {
+    const small = Array.from({ length: 12 }, (_, i) => fileEntry(`a_${i}.csv`));
+    mockInvoke.mockImplementation((cmd: string) =>
+      cmd === "list_dir" ? Promise.resolve(small) : baseInvoke(cmd),
+    );
+
+    await act(async () => {
+      render(<RightPanel open={true} />);
+    });
+    expect(await screen.findByText("a_0.csv")).toBeTruthy();
+
+    expect(rowCount()).toBe(small.length);
+    expect(document.querySelector(".file-tree-more")).toBeNull();
+  });
+});
diff --git a/src/__tests__/FileTreeSelection.test.ts b/src/__tests__/FileTreeSelection.test.ts
new file mode 100644
index 0000000..3a020c3
--- /dev/null
+++ b/src/__tests__/FileTreeSelection.test.ts
@@ -0,0 +1,76 @@
+/**
+ * Pure multi-selection logic for the right-panel file tree: a shift-range spans
+ * the contiguous slice of the visible order, ctrl/cmd toggles a single row, and
+ * a plain click collapses to one. These lock the range math (order-independent,
+ * inclusive) and the click state machine (selection + anchor transitions).
+ */
+import { describe, it, expect } from "vitest";
+
+import { rangeSelect, nextSelection } from "../lib/viewers/fileUtils";
+
+const ORDER = ["/p/a", "/p/b", "/p/c", "/p/d", "/p/e"];
+
+describe("rangeSelect", () => {
+  it("returns the inclusive slice anchor→target", () => {
+    expect(rangeSelect(ORDER, "/p/b", "/p/d")).toEqual(["/p/b", "/p/c", "/p/d"]);
+  });
+
+  it("is order-independent (target above anchor)", () => {
+    expect(rangeSelect(ORDER, "/p/d", "/p/b")).toEqual(["/p/b", "/p/c", "/p/d"]);
+  });
+
+  it("a single-row range is just that row", () => {
+    expect(rangeSelect(ORDER, "/p/c", "/p/c")).toEqual(["/p/c"]);
+  });
+
+  it("falls back to the target when an endpoint is gone", () => {
+    expect(rangeSelect(ORDER, "/p/gone", "/p/c")).toEqual(["/p/c"]);
+  });
+});
+
+describe("nextSelection", () => {
+  it("plain click selects only the row and sets the anchor", () => {
+    const r = nextSelection(new Set(["/p/a", "/p/b"]), ORDER, "/p/a", "/p/d", {
+      shift: false,
+      toggle: false,
+    });
+    expect([...r.selected]).toEqual(["/p/d"]);
+    expect(r.anchor).toBe("/p/d");
+  });
+
+  it("shift+anchor replaces selection with the range, anchor unchanged", () => {
+    const r = nextSelection(new Set(["/p/b"]), ORDER, "/p/b", "/p/e", {
+      shift: true,
+      toggle: false,
+    });
+    expect([...r.selected]).toEqual(["/p/b", "/p/c", "/p/d", "/p/e"]);
+    expect(r.anchor).toBe("/p/b");
+  });
+
+  it("shift without an anchor behaves like a plain click", () => {
+    const r = nextSelection(new Set(["/p/a"]), ORDER, null, "/p/c", {
+      shift: true,
+      toggle: false,
+    });
+    expect([...r.selected]).toEqual(["/p/c"]);
+    expect(r.anchor).toBe("/p/c");
+  });
+
+  it("toggle adds a row and moves the anchor", () => {
+    const r = nextSelection(new Set(["/p/a"]), ORDER, "/p/a", "/p/c", {
+      shift: false,
+      toggle: true,
+    });
+    expect([...r.selected].sort()).toEqual(["/p/a", "/p/c"]);
+    expect(r.anchor).toBe("/p/c");
+  });
+
+  it("toggle removes an already-selected row", () => {
+    const r = nextSelection(new Set(["/p/a", "/p/c"]), ORDER, "/p/a", "/p/c", {
+      shift: false,
+      toggle: true,
+    });
+    expect([...r.selected]).toEqual(["/p/a"]);
+    expect(r.anchor).toBe("/p/c");
+  });
+});
diff --git a/src/__tests__/FileViewNoTabsLoop.test.tsx b/src/__tests__/FileViewNoTabsLoop.test.tsx
new file mode 100644
index 0000000..edea13e
--- /dev/null
+++ b/src/__tests__/FileViewNoTabsLoop.test.tsx
@@ -0,0 +1,63 @@
+/**
+ * Regression: the shared file viewer (`ProjectFilesView`, rendered by the right
+ * panel and the Files tab) must not infinite-loop when the active scope has no
+ * registered tabs.
+ *
+ * The Sessions feature added `useTabsStore((s) => s.tabsByScope[scope] ?? [])`.
+ * A Zustand selector that returns a FRESH `[]` when the scope is absent yields a
+ * new snapshot on every render, so `useSyncExternalStore` re-renders forever
+ * ("The result of getSnapshot should be cached" → "Maximum update depth
+ * exceeded"). With no error boundary in the tree, that thrown loop unmounts the
+ * WHOLE app — which is why the symptom was "the project pills vanished": the
+ * header's pill strip is a sibling that React tears down along with everything
+ * else. The fix coalesces to a stable empty array OUTSIDE the selector.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, act } from "@testing-library/react";
+import type { ProjectEntry } from "../types";
+
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: vi.fn((cmd: string) => Promise.resolve(cmd === "git_repo_root" ? null : [])),
+}));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn().mockResolvedValue(() => {}) }));
+
+import { RightPanel } from "../components/layout/RightPanel";
+import { useProjectsStore } from "../stores/projects";
+import { useBoxesStore } from "../stores/boxes";
+import { useTabsStore } from "../stores/tabs";
+
+function proj(id: string): ProjectEntry {
+  return { id, name: id, status: "active", position: 10, local_file: `/p/${id}/project.json` };
+}
+
+beforeEach(() => {
+  useProjectsStore.setState({ projects: [], activeId: null, loaded: true });
+  useBoxesStore.setState({ boxes: [], loaded: true });
+  // The key precondition: the active scope has NO entry in tabsByScope.
+  useTabsStore.setState({ scope: "p1", tabsByScope: {} });
+});
+
+describe("ProjectFilesView with no tabs for the scope", () => {
+  it("renders without an infinite update loop", async () => {
+    useProjectsStore.setState({ projects: [proj("p1")], activeId: "p1", loaded: true });
+    useTabsStore.setState({ scope: "p1", tabsByScope: {} });
+
+    // Before the fix this render threw "Maximum update depth exceeded" from the
+    // unstable `tabsByScope[scope] ?? []` selector; the mount should now be quiet.
+    let container!: HTMLElement;
+    await act(async () => {
+      ({ container } = render(<RightPanel open={true} />));
+    });
+
+    expect(container.querySelector(".project-files-view, .file-tree, .project-files")).toBeTruthy();
+  });
+
+  it("selecting the scope's tabs returns a stable reference across calls", () => {
+    // The selector must hand back the SAME array object when the scope is absent,
+    // or useSyncExternalStore treats every render as a store change.
+    const sel = (s: { tabsByScope: Record<string, unknown[]> }) => s.tabsByScope["missing"];
+    const a = useTabsStore.getState().tabsByScope["missing"];
+    const b = sel(useTabsStore.getState());
+    expect(a).toBe(b); // both undefined — a stable reference, not a fresh []
+  });
+});
diff --git a/src/__tests__/FontSize.test.tsx b/src/__tests__/FontSize.test.tsx
index aa84922..b4e52e5 100644
--- a/src/__tests__/FontSize.test.tsx
+++ b/src/__tests__/FontSize.test.tsx
@@ -1,13 +1,16 @@
 /**
- * Tests for the code-editor text-size control:
- *  - the persisted per-type `viewer_prefs[type].font_size` drives the editor's
- *    --code-font-size / --code-line-height CSS variables (so the gutter and
- *    overlay layers scale together);
- *  - the A+/A− buttons (and Ctrl +/−) persist a clamped new size via
- *    updateSettings, merging the whole viewer_prefs map.
+ * Tests for the code-editor text-size control (#48):
+ *  - the effective size drives the editor's --code-font-size / --code-line-height
+ *    CSS variables (so the gutter and overlay layers scale together);
+ *  - zoom is TAB-LOCAL: A+/A− (and Ctrl +/−) persist the new size on the tab's
+ *    `viewerState.fontSize` — NOT the global per-type `viewer_prefs` — so zooming
+ *    one tab never resizes other viewers of the same type, and the size survives
+ *    an Eldrun restart (re-seeded from the persisted viewerState);
+ *  - until the tab is zoomed it tracks the per-type `viewer_prefs[type].font_size`
+ *    default reactively.
  */
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render, screen, act, waitFor, fireEvent } from "@testing-library/react";
+import { render, screen, act, waitFor, fireEvent, cleanup } from "@testing-library/react";
 
 const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
 vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
@@ -15,8 +18,9 @@ vi.mock("../stores/windows", () => ({
   useWindowsStore: { getState: () => ({ openFile: () => Promise.resolve() }) },
 }));
 
-// A settings-store mock exposing BOTH the selector call form (used during render)
-// and `.getState()` (used by the inc/dec callbacks to read+merge viewer_prefs).
+// Settings-store mock exposing the per-type `viewer_prefs` defaults (selector +
+// getState). `updateSettings` is spied so the tests can assert it is NOT touched
+// by the per-tab zoom anymore.
 const { mockUpdate, prefsRef } = vi.hoisted(() => ({
   mockUpdate: vi.fn(),
   prefsRef: { current: {} as Record<string, { font_size?: number }> },
@@ -31,7 +35,33 @@ vi.mock("../stores/settings", () => {
   return { useSettingsStore: hook };
 });
 
+// Tabs-store mock backing the per-tab viewerState. `setViewerState` records the
+// patch AND merges it into the tab so a re-render (a "restart") re-seeds the
+// persisted size. Real exports (findGroupOfTab/getDetachedViewerState/…) are kept
+// so the rest of FileViewerPane still resolves.
+type Tab = { key: string; kind?: string; viewerState?: Record<string, unknown> };
+const { mockSetViewerState, tabsRef } = vi.hoisted(() => ({
+  mockSetViewerState: vi.fn(),
+  tabsRef: { current: [] as Tab[] },
+}));
+vi.mock("../stores/tabs", async (importActual) => {
+  const actual = await importActual<Record<string, unknown>>();
+  const state = () => ({
+    tabs: tabsRef.current,
+    setActive: vi.fn(),
+    setViewerState: (key: string, patch: Record<string, unknown>) => {
+      mockSetViewerState(key, patch);
+      const t = tabsRef.current.find((x) => x.key === key);
+      if (t) t.viewerState = { ...t.viewerState, ...patch };
+    },
+  });
+  const hook = (sel?: (s: unknown) => unknown) => (sel ? sel(state()) : state());
+  (hook as unknown as { getState: typeof state }).getState = state;
+  return { ...actual, useTabsStore: hook };
+});
+
 const SOURCE = "hello\nworld\n";
+const TAB_KEY = "t1";
 
 function setup() {
   mockInvoke.mockImplementation((cmd: string) => {
@@ -45,7 +75,7 @@ async function renderTextView() {
   vi.resetModules();
   const { FileViewerPane } = await import("../components/embed/FileViewerPane");
   await act(async () => {
-    render(<FileViewerPane viewer="text" path="/p/notes.txt" projectId="proj" />);
+    render(<FileViewerPane viewer="text" path="/p/notes.txt" projectId="proj" tabKey={TAB_KEY} />);
   });
 }
 
@@ -53,7 +83,7 @@ async function renderMarkdownView() {
   vi.resetModules();
   const { FileViewerPane } = await import("../components/embed/FileViewerPane");
   await act(async () => {
-    render(<FileViewerPane viewer="markdown" path="/p/notes.md" projectId="proj" />);
+    render(<FileViewerPane viewer="markdown" path="/p/notes.md" projectId="proj" tabKey={TAB_KEY} />);
   });
 }
 
@@ -61,10 +91,11 @@ describe("editor text-size control", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     prefsRef.current = {};
+    tabsRef.current = [{ key: TAB_KEY, kind: "embed", viewerState: {} }];
     setup();
   });
 
-  it("applies the persisted font_size as the editor CSS variables", async () => {
+  it("applies the persisted per-type font_size as the editor CSS variables", async () => {
     prefsRef.current = { text: { font_size: 16 } };
     await renderTextView();
     await waitFor(() =>
@@ -78,7 +109,7 @@ describe("editor text-size control", () => {
     expect(screen.getByRole("button", { name: "Reset text size" }).textContent).toBe("16");
   });
 
-  it("persists a larger size when A+ is clicked", async () => {
+  it("persists a larger size on THIS tab (not global settings) when A+ is clicked", async () => {
     await renderTextView();
     await waitFor(() =>
       expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE),
@@ -86,22 +117,61 @@ describe("editor text-size control", () => {
     await act(async () => {
       fireEvent.click(screen.getByRole("button", { name: "Increase text size" }));
     });
-    expect(mockUpdate).toHaveBeenCalledWith({ viewer_prefs: { text: { font_size: 13 } } });
+    // Written to the tab's viewerState — not the global per-type viewer_prefs.
+    expect(mockSetViewerState).toHaveBeenCalledWith(TAB_KEY, { fontSize: 13 });
+    expect(mockUpdate).not.toHaveBeenCalled();
+    expect(screen.getByRole("button", { name: "Reset text size" }).textContent).toBe("13");
   });
 
-  it("shrinks on Ctrl+− from the editor", async () => {
-    prefsRef.current = { text: { font_size: 14 } };
+  it("shrinks on Ctrl+− from the editor and persists on the tab", async () => {
+    tabsRef.current[0].viewerState = { fontSize: 14 };
     await renderTextView();
     const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
     await waitFor(() => expect(textarea.value).toBe(SOURCE));
     await act(async () => {
       fireEvent.keyDown(textarea, { key: "-", ctrlKey: true });
     });
-    expect(mockUpdate).toHaveBeenCalledWith({ viewer_prefs: { text: { font_size: 13 } } });
+    expect(mockSetViewerState).toHaveBeenCalledWith(TAB_KEY, { fontSize: 13 });
+    expect(mockUpdate).not.toHaveBeenCalled();
+  });
+
+  it("restores the persisted tab size across an Eldrun restart", async () => {
+    // First session: zoom this tab up to 13, which persists on its viewerState.
+    await renderTextView();
+    await waitFor(() =>
+      expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE),
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Increase text size" }));
+    });
+    expect(tabsRef.current[0].viewerState).toMatchObject({ fontSize: 13 });
+    // Restart: tear down this session, then remount. The tab (and its
+    // viewerState) survives; the viewer re-seeds the size from it.
+    cleanup();
+    await renderTextView();
+    await waitFor(() =>
+      expect(screen.getByRole("button", { name: "Reset text size" }).textContent).toBe("13"),
+    );
+  });
+
+  it("Reset clears the tab override, falling back to the per-type default", async () => {
+    prefsRef.current = { text: { font_size: 20 } };
+    tabsRef.current[0].viewerState = { fontSize: 10 };
+    await renderTextView();
+    await waitFor(() =>
+      expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE),
+    );
+    expect(screen.getByRole("button", { name: "Reset text size" }).textContent).toBe("10");
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Reset text size" }));
+    });
+    // Override cleared → falls back to the per-type default (20).
+    expect(mockSetViewerState).toHaveBeenCalledWith(TAB_KEY, { fontSize: undefined });
+    expect(screen.getByRole("button", { name: "Reset text size" }).textContent).toBe("20");
   });
 
   it("clamps at the minimum size", async () => {
-    prefsRef.current = { text: { font_size: 8 } };
+    tabsRef.current[0].viewerState = { fontSize: 8 };
     await renderTextView();
     await waitFor(() =>
       expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE),
@@ -110,13 +180,14 @@ describe("editor text-size control", () => {
     expect(dec.disabled).toBe(true);
   });
 
-  it("offers the control in the markdown viewer and persists under the markdown key", async () => {
+  it("offers the control in the markdown viewer and persists on the tab", async () => {
     await renderMarkdownView();
     // The preview renders the markdown body; the size control sits in the header.
     await waitFor(() => expect(document.querySelector(".markdown-body")).not.toBeNull());
     await act(async () => {
       fireEvent.click(screen.getByRole("button", { name: "Increase text size" }));
     });
-    expect(mockUpdate).toHaveBeenCalledWith({ viewer_prefs: { markdown: { font_size: 13 } } });
+    expect(mockSetViewerState).toHaveBeenCalledWith(TAB_KEY, { fontSize: 13 });
+    expect(mockUpdate).not.toHaveBeenCalled();
   });
 });
diff --git a/src/__tests__/Gif.test.ts b/src/__tests__/Gif.test.ts
new file mode 100644
index 0000000..2459959
--- /dev/null
+++ b/src/__tests__/Gif.test.ts
@@ -0,0 +1,460 @@
+import { describe, it, expect } from "vitest";
+import {
+  decodeGif,
+  openGif,
+  effectiveDelayMs,
+  GifDecodeError,
+  type GifData,
+} from "../lib/viewers/gif";
+
+// ── Test-side GIF builder ─────────────────────────────────────────────────────
+// A minimal GIF encoder so each case reads as "this picture, these frames"
+// instead of a hex dump. The LZW half only ever emits literal codes, but it
+// must mirror the decoder's dictionary growth exactly: the decoder adds an
+// entry per code (after the first since a clear) whether or not the encoder
+// uses them, and the CODE WIDTH grows when the dictionary fills it — so the
+// encoder tracks the same counters to write each code at the width the decoder
+// will read it.
+
+function lzwEncodeLiterals(
+  minCodeSize: number,
+  indices: number[],
+  clearEvery?: number,
+): Uint8Array {
+  const clear = 1 << minCodeSize;
+  const eoi = clear + 1;
+  let codeSize = minCodeSize + 1;
+  let dictSize = eoi + 1;
+  let sinceClear = 0;
+  const out: number[] = [];
+  let acc = 0;
+  let nbits = 0;
+  const emit = (code: number) => {
+    acc |= code << nbits;
+    nbits += codeSize;
+    while (nbits >= 8) {
+      out.push(acc & 0xff);
+      acc >>= 8;
+      nbits -= 8;
+    }
+  };
+  emit(clear);
+  for (const index of indices) {
+    if (clearEvery && sinceClear === clearEvery) {
+      emit(clear);
+      codeSize = minCodeSize + 1;
+      dictSize = eoi + 1;
+      sinceClear = 0;
+    }
+    emit(index);
+    // The decoder adds a dictionary entry for every code after the first since
+    // the last clear, growing the code width when the dictionary fills it.
+    if (sinceClear > 0 && dictSize < 4096) {
+      dictSize++;
+      if (dictSize === 1 << codeSize && codeSize < 12) codeSize++;
+    }
+    sinceClear++;
+  }
+  emit(eoi);
+  if (nbits > 0) out.push(acc & 0xff);
+  return Uint8Array.from(out);
+}
+
+type Rgb = [number, number, number];
+
+interface TestFrame {
+  /** [left, top, w, h]; defaults to the full logical screen. */
+  rect?: [number, number, number, number];
+  /** Palette indices in row-major FILE order (pre-interlace when `interlace`). */
+  indices: number[];
+  /** Local color table (overrides the global for this frame). */
+  lct?: Rgb[];
+  /** Graphic Control Extension; omitted = no GCE (delay 0, disposal 0). */
+  gce?: { delay?: number; transparent?: number; disposal?: number };
+  interlace?: boolean;
+  /** Raw pre-encoded LZW payload (minCodeSize + data), for hand-built streams. */
+  rawLzw?: { minCodeSize: number; data: number[] };
+  clearEvery?: number;
+}
+
+function colorTable(colors: Rgb[]): { bytes: number[]; sizeField: number } {
+  // Table length must be a power of two with at least 2 entries.
+  let size = 2;
+  while (size < colors.length) size *= 2;
+  const bytes: number[] = [];
+  for (let i = 0; i < size; i++) {
+    const [r, g, b] = colors[i] ?? [0, 0, 0];
+    bytes.push(r, g, b);
+  }
+  return { bytes, sizeField: Math.log2(size) - 1 };
+}
+
+function subBlocks(data: Uint8Array): number[] {
+  const out: number[] = [];
+  for (let i = 0; i < data.length; i += 255) {
+    const chunk = data.subarray(i, i + 255);
+    out.push(chunk.length, ...chunk);
+  }
+  out.push(0);
+  return out;
+}
+
+function buildGif({
+  width,
+  height,
+  gct,
+  frames,
+  netscapeLoops,
+  version = "GIF89a",
+  trailer = true,
+}: {
+  width: number;
+  height: number;
+  gct?: Rgb[];
+  frames: TestFrame[];
+  /** Netscape iteration count (0 = forever). */
+  netscapeLoops?: number;
+  version?: string;
+  trailer?: boolean;
+}): Uint8Array {
+  const out: number[] = [...version].map((ch) => ch.charCodeAt(0));
+  out.push(width & 0xff, width >> 8, height & 0xff, height >> 8);
+  if (gct) {
+    const t = colorTable(gct);
+    out.push(0x80 | t.sizeField, 0, 0, ...t.bytes);
+  } else {
+    out.push(0, 0, 0);
+  }
+  if (netscapeLoops !== undefined) {
+    out.push(0x21, 0xff, 11, ...[..."NETSCAPE2.0"].map((ch) => ch.charCodeAt(0)));
+    out.push(3, 1, netscapeLoops & 0xff, netscapeLoops >> 8, 0);
+  }
+  for (const f of frames) {
+    if (f.gce) {
+      const disposal = f.gce.disposal ?? 0;
+      const flags = (disposal << 2) | (f.gce.transparent !== undefined ? 1 : 0);
+      const delay = f.gce.delay ?? 0;
+      out.push(0x21, 0xf9, 4, flags, delay & 0xff, delay >> 8, f.gce.transparent ?? 0, 0);
+    }
+    const [left, top, w, h] = f.rect ?? [0, 0, width, height];
+    let dFlags = f.interlace ? 0x40 : 0;
+    let lctBytes: number[] = [];
+    if (f.lct) {
+      const t = colorTable(f.lct);
+      dFlags |= 0x80 | t.sizeField;
+      lctBytes = t.bytes;
+    }
+    out.push(0x2c, left & 0xff, left >> 8, top & 0xff, top >> 8, w & 0xff, w >> 8, h & 0xff, h >> 8, dFlags, ...lctBytes);
+    if (f.rawLzw) {
+      out.push(f.rawLzw.minCodeSize, ...subBlocks(Uint8Array.from(f.rawLzw.data)));
+    } else {
+      const tableLen = (f.lct ?? gct ?? []).length;
+      const minCodeSize = Math.max(2, Math.ceil(Math.log2(Math.max(tableLen, 2))));
+      out.push(minCodeSize, ...subBlocks(lzwEncodeLiterals(minCodeSize, f.indices, f.clearEvery)));
+    }
+  }
+  if (trailer) out.push(0x3b);
+  return Uint8Array.from(out);
+}
+
+// ── Pixel helpers ─────────────────────────────────────────────────────────────
+
+const RED: Rgb = [255, 0, 0];
+const GREEN: Rgb = [0, 255, 0];
+const BLUE: Rgb = [0, 0, 255];
+const WHITE: Rgb = [255, 255, 255];
+
+function px(gif: GifData, frame: number, x: number, y: number): number[] {
+  const p = (y * gif.width + x) * 4;
+  return Array.from(gif.frames[frame].pixels.subarray(p, p + 4));
+}
+
+const opaque = (c: Rgb) => [...c, 255];
+const CLEAR = [0, 0, 0, 0];
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("decodeGif basics", () => {
+  it("decodes a 2×2 single-frame GIF87a", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 2,
+        height: 2,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [{ indices: [0, 1, 2, 3] }],
+        version: "GIF87a",
+      }),
+    );
+    expect(gif.width).toBe(2);
+    expect(gif.height).toBe(2);
+    expect(gif.frames).toHaveLength(1);
+    expect(gif.loopCount).toBe(1); // no Netscape extension = play once
+    expect(gif.truncated).toBe(false);
+    expect(gif.frames[0].delayMs).toBe(0); // GIF87a has no GCE
+    expect(px(gif, 0, 0, 0)).toEqual(opaque(RED));
+    expect(px(gif, 0, 1, 0)).toEqual(opaque(GREEN));
+    expect(px(gif, 0, 0, 1)).toEqual(opaque(BLUE));
+    expect(px(gif, 0, 1, 1)).toEqual(opaque(WHITE));
+  });
+
+  it("carries the authored delay (hundredths × 10) and the Netscape loop count", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 1,
+        height: 1,
+        gct: [RED, GREEN],
+        netscapeLoops: 0, // loop forever
+        frames: [
+          { indices: [0], gce: { delay: 5 } },
+          { indices: [1], gce: { delay: 200 } },
+        ],
+      }),
+    );
+    expect(gif.loopCount).toBe(0);
+    expect(gif.frames[0].delayMs).toBe(50);
+    expect(gif.frames[1].delayMs).toBe(2000);
+  });
+
+  it("rejects a non-GIF header", () => {
+    expect(() => decodeGif(Uint8Array.from([1, 2, 3, 4, 5, 6, 7, 8]))).toThrow(GifDecodeError);
+    expect(() => decodeGif(new TextEncoder().encode("PNG89a xxxxxxxx"))).toThrow(/not a GIF/);
+  });
+
+  it("decodes the canonical 1×1 transparent GIF", () => {
+    const bytes = Uint8Array.from(
+      atob("R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"),
+      (ch) => ch.charCodeAt(0),
+    );
+    const gif = decodeGif(bytes);
+    expect(gif.width).toBe(1);
+    expect(gif.height).toBe(1);
+    expect(gif.frames).toHaveLength(1);
+    expect(px(gif, 0, 0, 0)).toEqual(CLEAR); // transparent index left the canvas clear
+  });
+});
+
+describe("compositing and disposal", () => {
+  it("disposal 1 (keep): the next frame composites over this one", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 2,
+        height: 2,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [
+          { indices: [0, 0, 0, 0], gce: { disposal: 1 } },
+          // Right column only.
+          { rect: [1, 0, 1, 2], indices: [2, 2] },
+        ],
+      }),
+    );
+    expect(px(gif, 1, 0, 0)).toEqual(opaque(RED)); // left column survives
+    expect(px(gif, 1, 1, 0)).toEqual(opaque(BLUE));
+    expect(px(gif, 1, 1, 1)).toEqual(opaque(BLUE));
+  });
+
+  it("the transparent index leaves the underlying pixel", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 2,
+        height: 1,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [
+          { indices: [0, 1], gce: { disposal: 1 } },
+          // Index 3 is transparent: only the second pixel changes.
+          { indices: [3, 2], gce: { transparent: 3 } },
+        ],
+      }),
+    );
+    expect(px(gif, 1, 0, 0)).toEqual(opaque(RED));
+    expect(px(gif, 1, 1, 0)).toEqual(opaque(BLUE));
+  });
+
+  it("disposal 2 clears the frame's rect to TRANSPARENT (browser behavior, not spec background)", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 2,
+        height: 2,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [
+          { indices: [0, 0, 0, 0], gce: { disposal: 2 } },
+          { rect: [0, 0, 1, 1], indices: [2] },
+        ],
+      }),
+    );
+    // Frame 1 itself shows normally…
+    expect(px(gif, 0, 0, 0)).toEqual(opaque(RED));
+    // …but frame 2 starts from a cleared canvas: only its own pixel is set.
+    expect(px(gif, 1, 0, 0)).toEqual(opaque(BLUE));
+    expect(px(gif, 1, 1, 0)).toEqual(CLEAR);
+    expect(px(gif, 1, 0, 1)).toEqual(CLEAR);
+    expect(px(gif, 1, 1, 1)).toEqual(CLEAR);
+  });
+
+  it("disposal 3 restores the canvas from before the frame drew", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 2,
+        height: 1,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [
+          { indices: [0, 0], gce: { disposal: 1 } },
+          { indices: [2, 2], gce: { disposal: 3 } }, // full blue, then restore
+          { rect: [0, 0, 1, 1], indices: [1] },
+        ],
+      }),
+    );
+    expect(px(gif, 1, 0, 0)).toEqual(opaque(BLUE)); // frame 2 shows its own draw
+    expect(px(gif, 2, 0, 0)).toEqual(opaque(GREEN)); // frame 3's own pixel
+    expect(px(gif, 2, 1, 0)).toEqual(opaque(RED)); // restored, not blue
+  });
+
+  it("a local color table overrides the global one", () => {
+    const gif = decodeGif(
+      buildGif({
+        width: 1,
+        height: 1,
+        gct: [RED, GREEN],
+        frames: [{ indices: [0], lct: [BLUE, WHITE] }],
+      }),
+    );
+    expect(px(gif, 0, 0, 0)).toEqual(opaque(BLUE));
+  });
+
+  it("reorders interlaced rows into display order", () => {
+    // 1×8: file rows land on display rows 0,4,2,6,1,3,5,7 (the 4-pass scheme).
+    const shades: Rgb[] = Array.from({ length: 8 }, (_, i) => [i * 30, i * 30, i * 30]);
+    const gif = decodeGif(
+      buildGif({
+        width: 1,
+        height: 8,
+        gct: shades,
+        frames: [{ indices: [0, 1, 2, 3, 4, 5, 6, 7], interlace: true }],
+      }),
+    );
+    const fileOrderOfRow = [0, 4, 2, 5, 1, 6, 3, 7]; // inverse of [0,4,2,6,1,3,5,7]
+    for (let y = 0; y < 8; y++) {
+      expect(px(gif, 0, 0, y)).toEqual(opaque(shades[fileOrderOfRow[y]]));
+    }
+  });
+});
+
+describe("LZW", () => {
+  it("round-trips a stream long enough to grow the code width", () => {
+    const w = 10;
+    const h = 10;
+    const indices = Array.from({ length: w * h }, (_, i) => (i * 7) % 16);
+    const palette: Rgb[] = Array.from({ length: 16 }, (_, i) => [i * 16, 255 - i * 16, i]);
+    const gif = decodeGif(buildGif({ width: w, height: h, gct: palette, frames: [{ indices }] }));
+    for (let i = 0; i < indices.length; i++) {
+      expect(px(gif, 0, i % w, Math.floor(i / w))).toEqual(opaque(palette[indices[i]]));
+    }
+  });
+
+  it("handles mid-stream clear codes", () => {
+    const indices = Array.from({ length: 64 }, (_, i) => i % 4);
+    const gif = decodeGif(
+      buildGif({
+        width: 8,
+        height: 8,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [{ indices, clearEvery: 7 }],
+      }),
+    );
+    expect(px(gif, 0, 0, 0)).toEqual(opaque(RED));
+    expect(px(gif, 0, 5, 3)).toEqual(opaque(GREEN)); // index (3*8+5)%4 = 1
+    expect(px(gif, 0, 7, 7)).toEqual(opaque(WHITE));
+  });
+
+  it("decodes the KwKwK case (a code that IS the next dictionary slot)", () => {
+    // Hand-packed stream for "aaaa" with minCodeSize 2:
+    // clear(4), 0, 6 ← the KwKwK code, 0, eoi(5) — widths 3,3,3,3,4 bits.
+    const gif = decodeGif(
+      buildGif({
+        width: 2,
+        height: 2,
+        gct: [RED, GREEN, BLUE, WHITE],
+        frames: [{ indices: [], rawLzw: { minCodeSize: 2, data: [0x84, 0x51] } }],
+      }),
+    );
+    for (const [x, y] of [[0, 0], [1, 0], [0, 1], [1, 1]] as const) {
+      expect(px(gif, 0, x, y)).toEqual(opaque(RED));
+    }
+  });
+});
+
+describe("truncation and caps", () => {
+  it("returns the complete frames of a truncated file with truncated: true", () => {
+    const whole = buildGif({
+      width: 2,
+      height: 2,
+      gct: [RED, GREEN, BLUE, WHITE],
+      frames: [
+        { indices: [0, 0, 0, 0], gce: { delay: 10 } },
+        { indices: [1, 1, 1, 1], gce: { delay: 10 } },
+      ],
+    });
+    // Cut into frame 2's data (also drops the trailer).
+    const gif = decodeGif(whole.subarray(0, whole.length - 4));
+    expect(gif.frames).toHaveLength(1);
+    expect(gif.truncated).toBe(true);
+    expect(px(gif, 0, 0, 0)).toEqual(opaque(RED));
+  });
+
+  it("throws when not even one frame decodes", () => {
+    const whole = buildGif({
+      width: 2,
+      height: 2,
+      gct: [RED, GREEN],
+      frames: [{ indices: [0, 0, 0, 0] }],
+    });
+    expect(() => decodeGif(whole.subarray(0, 20))).toThrow(GifDecodeError);
+  });
+
+  it("stops at maxPixelBytes and marks the result truncated", () => {
+    const bytes = buildGif({
+      width: 2,
+      height: 2,
+      gct: [RED, GREEN],
+      frames: [
+        { indices: [0, 0, 0, 0] },
+        { indices: [1, 1, 1, 1] },
+      ],
+    });
+    // One 2×2 RGBA frame = 16 bytes: the cap admits exactly one frame.
+    const gif = decodeGif(bytes, { maxPixelBytes: 16 });
+    expect(gif.frames).toHaveLength(1);
+    expect(gif.truncated).toBe(true);
+    // Untouched, both frames decode.
+    expect(decodeGif(bytes).frames).toHaveLength(2);
+  });
+
+  it("streams frames one at a time via openGif", () => {
+    const stream = openGif(
+      buildGif({
+        width: 1,
+        height: 1,
+        gct: [RED, GREEN],
+        frames: [{ indices: [0] }, { indices: [1] }],
+      }),
+    );
+    expect(stream.width).toBe(1);
+    const f1 = stream.nextFrame();
+    const f2 = stream.nextFrame();
+    expect(f1).not.toBeNull();
+    expect(f2).not.toBeNull();
+    expect(stream.nextFrame()).toBeNull();
+    expect(stream.nextFrame()).toBeNull(); // stays done
+    expect(stream.truncated).toBe(false);
+  });
+});
+
+describe("effectiveDelayMs", () => {
+  it("bumps sub-20ms authored delays to the 100ms browser convention", () => {
+    expect(effectiveDelayMs(0)).toBe(100);
+    expect(effectiveDelayMs(10)).toBe(100);
+  });
+  it("honors 20ms and above exactly", () => {
+    expect(effectiveDelayMs(20)).toBe(20);
+    expect(effectiveDelayMs(500)).toBe(500);
+  });
+});
diff --git a/src/__tests__/GifView.test.tsx b/src/__tests__/GifView.test.tsx
new file mode 100644
index 0000000..b9cce88
--- /dev/null
+++ b/src/__tests__/GifView.test.tsx
@@ -0,0 +1,158 @@
+/**
+ * Tests for the animated-GIF viewer (#gifviewer): the REAL decoder runs over a
+ * hand-built two-frame GIF served through the mocked `read_file_bytes`, and the
+ * transport (frame counter, play/pause, stepping) drives a stubbed canvas
+ * context (jsdom has none). Auto-reload parity with the image viewer (#68) is
+ * covered by the mtime-advance case.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, act, waitFor, fireEvent, screen } from "@testing-library/react";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: { getState: () => ({ openFile: () => Promise.resolve() }) },
+}));
+vi.mock("../stores/settings", () => ({
+  useSettingsStore: (sel: (s: unknown) => unknown) =>
+    sel({ settings: { viewer_prefs: {} } }),
+}));
+
+// A real 1×1 two-frame GIF89a (2-entry palette: red, green), each frame with an
+// authored 10s delay so autoplay can't advance mid-assertion. Byte-for-byte:
+// header + LSD + GCT, then per frame a GCE (delay 1000 hundredths) + descriptor
+// + a literal LZW stream (clear, index, EOI), then the trailer.
+// prettier-ignore
+const TWO_FRAME_GIF = [
+  0x47, 0x49, 0x46, 0x38, 0x39, 0x61,             // "GIF89a"
+  0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00,       // 1×1, global color table (2)
+  0xff, 0x00, 0x00,  0x00, 0xff, 0x00,            // palette: red, green
+  0x21, 0xf9, 0x04, 0x00, 0xe8, 0x03, 0x00, 0x00, // GCE: delay 1000 (10 s)
+  0x2c, 0, 0, 0, 0, 0x01, 0x00, 0x01, 0x00, 0x00, // frame 1 descriptor
+  0x02, 0x02, 0x44, 0x01, 0x00,                   // LZW: clear, 0, EOI
+  0x21, 0xf9, 0x04, 0x00, 0xe8, 0x03, 0x00, 0x00, // GCE: delay 1000 (10 s)
+  0x2c, 0, 0, 0, 0, 0x01, 0x00, 0x01, 0x00, 0x00, // frame 2 descriptor
+  0x02, 0x02, 0x4c, 0x01, 0x00,                   // LZW: clear, 1, EOI
+  0x3b,                                           // trailer
+];
+
+let diskMtime = 1000;
+
+function countReadBytes() {
+  return mockInvoke.mock.calls.filter((c) => c[0] === "read_file_bytes").length;
+}
+
+const putImageData = vi.fn();
+
+async function renderGifView() {
+  vi.resetModules();
+  const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+  await act(async () => {
+    render(<FileViewerPane viewer="gif" path="/p/anim.gif" projectId="proj" />);
+  });
+}
+
+describe("GifView", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    diskMtime = 1000;
+    // jsdom has no canvas backend: getContext returns null and would leave the
+    // draw effect dead. A putImageData spy is all the viewer itself needs, but
+    // this prototype override is global, so it also answers every canvas the
+    // FileViewerPane chrome mounts alongside it — including PresentationOverlay's
+    // marker/laser canvases, which need a full no-op 2D context or they throw.
+    HTMLCanvasElement.prototype.getContext = vi.fn(
+      () =>
+        ({
+          putImageData,
+          clearRect: vi.fn(),
+          save: vi.fn(),
+          restore: vi.fn(),
+          beginPath: vi.fn(),
+          moveTo: vi.fn(),
+          lineTo: vi.fn(),
+          arc: vi.fn(),
+          stroke: vi.fn(),
+          fill: vi.fn(),
+        }) as unknown as CanvasRenderingContext2D,
+    ) as unknown as typeof HTMLCanvasElement.prototype.getContext;
+    // This jsdom build exposes no ImageData global; the viewer only ever hands
+    // it to the (stubbed) putImageData, so a data/width/height shell suffices.
+    globalThis.ImageData ??= class {
+      constructor(
+        public data: Uint8ClampedArray,
+        public width: number,
+        public height: number,
+      ) {}
+    } as unknown as typeof ImageData;
+    // jsdom may lack rAF depending on visual pretence; the playback loop only
+    // needs it to exist (the 10 s frame delay keeps it from ever advancing).
+    globalThis.requestAnimationFrame ??= (cb) =>
+      setTimeout(() => cb(performance.now()), 16) as unknown as number;
+    globalThis.cancelAnimationFrame ??= (id) => clearTimeout(id);
+    globalThis.URL.createObjectURL ??= vi.fn(() => "blob:mock");
+    globalThis.URL.revokeObjectURL ??= vi.fn();
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "read_file_bytes") return Promise.resolve([...TWO_FRAME_GIF]);
+      if (cmd === "file_mtime") return Promise.resolve(diskMtime);
+      return Promise.resolve(null);
+    });
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("decodes the frames, autoplays, and steps/pauses via the transport", async () => {
+    await renderGifView();
+
+    // The real decoder ran over the mock bytes: 2 frames, frame 1 on screen.
+    await waitFor(() => expect(screen.getByText(/1 \/ 2/)).toBeTruthy());
+    expect(putImageData).toHaveBeenCalled();
+    const draws = putImageData.mock.calls.length;
+
+    // Autoplay is on (matches the old <img> behavior), so the toggle says Pause.
+    expect(screen.getByRole("button", { name: "Pause" })).toBeTruthy();
+
+    // Stepping pauses and advances the counter + redraws the canvas.
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Next frame" }));
+    });
+    expect(screen.getByText(/2 \/ 2/)).toBeTruthy();
+    expect(putImageData.mock.calls.length).toBeGreaterThan(draws);
+    expect(screen.getByRole("button", { name: "Play" })).toBeTruthy();
+
+    // Prev wraps back to frame 1.
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Previous frame" }));
+    });
+    expect(screen.getByText(/1 \/ 2/)).toBeTruthy();
+
+    // The readout shows the authored 10 s delay verbatim (≥20ms is honored).
+    expect(screen.getByText(/10000 ms/)).toBeTruthy();
+  });
+
+  it("re-reads and re-decodes when the file's mtime advances on disk (#68)", async () => {
+    await renderGifView();
+    await waitFor(() => expect(countReadBytes()).toBe(1));
+
+    diskMtime = 2000;
+    await waitFor(() => expect(countReadBytes()).toBe(2), { timeout: 12000 });
+
+    // No further change → no further read.
+    await new Promise((r) => setTimeout(r, 1800));
+    expect(countReadBytes()).toBe(2);
+  });
+
+  it("degrades to native <img> playback when the bytes aren't a decodable GIF", async () => {
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "read_file_bytes") return Promise.resolve([1, 2, 3, 4, 5, 6, 7, 8]);
+      if (cmd === "file_mtime") return Promise.resolve(diskMtime);
+      return Promise.resolve(null);
+    });
+    await renderGifView();
+    await waitFor(() => expect(screen.getByText(/native playback/)).toBeTruthy());
+    // The fallback <img> is up; the transport is not.
+    expect(document.querySelector(".gif-fallback img")).toBeTruthy();
+    expect(screen.queryByRole("button", { name: "Next frame" })).toBeNull();
+  });
+});
diff --git a/src/__tests__/GitChangeTree.test.ts b/src/__tests__/GitChangeTree.test.ts
new file mode 100644
index 0000000..67c944d
--- /dev/null
+++ b/src/__tests__/GitChangeTree.test.ts
@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { buildTree, type FileChange } from "../components/files/GitChangeTree";
+
+const c = (path: string, added: number, deleted: number, binary = false): FileChange => ({
+  path,
+  added,
+  deleted,
+  binary,
+});
+
+describe("buildTree", () => {
+  it("nests files under their folders", () => {
+    const root = buildTree([c("src/a.ts", 1, 0), c("src/sub/b.ts", 2, 0), c("top.ts", 5, 0)]);
+    const names = root.children.map((n) => n.name);
+    // Folders sort before files.
+    expect(names).toEqual(["src", "top.ts"]);
+    const src = root.children.find((n) => n.name === "src")!;
+    expect(src.isDir).toBe(true);
+    expect(src.children.map((n) => n.name)).toEqual(["sub", "a.ts"]);
+  });
+
+  it("aggregates +/- line stats up into directories", () => {
+    const root = buildTree([c("src/a.ts", 10, 3), c("src/sub/b.ts", 4, 1)]);
+    const src = root.children.find((n) => n.name === "src")!;
+    expect(src.added).toBe(14);
+    expect(src.deleted).toBe(4);
+  });
+
+  it("marks a directory binary only when every file under it is binary", () => {
+    const allBin = buildTree([c("a/x.png", 0, 0, true), c("a/y.jpg", 0, 0, true)]);
+    expect(allBin.children[0].binary).toBe(true);
+
+    const mixed = buildTree([c("a/x.png", 0, 0, true), c("a/y.ts", 3, 0, false)]);
+    expect(mixed.children[0].binary).toBe(false);
+  });
+});
diff --git a/src/__tests__/GitDirtyState.test.ts b/src/__tests__/GitDirtyState.test.ts
new file mode 100644
index 0000000..313eac4
--- /dev/null
+++ b/src/__tests__/GitDirtyState.test.ts
@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { gitDirtyState } from "../stores/gitDirty";
+
+const status = (over: Partial<{ staged: number; unstaged: number; untracked: number; is_repo: boolean }>) => ({
+  staged: 0,
+  unstaged: 0,
+  untracked: 0,
+  has_remote: false,
+  is_repo: true,
+  ...over,
+});
+
+describe("gitDirtyState", () => {
+  it("reports clean for a non-repo regardless of counts", () => {
+    expect(gitDirtyState(status({ is_repo: false, untracked: 5, staged: 2 }), 3)).toBe("clean");
+  });
+
+  it("reports clean when nothing is pending", () => {
+    expect(gitDirtyState(status({}), 0)).toBe("clean");
+  });
+
+  it("reports dirty for untracked or unstaged working-tree changes", () => {
+    expect(gitDirtyState(status({ untracked: 1 }), 0)).toBe("dirty");
+    expect(gitDirtyState(status({ unstaged: 1 }), 0)).toBe("dirty");
+  });
+
+  it("reports staged when only staged changes exist", () => {
+    expect(gitDirtyState(status({ staged: 2 }), 0)).toBe("staged");
+  });
+
+  it("reports unpushed when only local commits are ahead", () => {
+    expect(gitDirtyState(status({}), 4)).toBe("unpushed");
+  });
+
+  it("prioritizes dirty over staged over unpushed", () => {
+    expect(gitDirtyState(status({ untracked: 1, staged: 1 }), 2)).toBe("dirty");
+    expect(gitDirtyState(status({ staged: 1 }), 2)).toBe("staged");
+  });
+});
diff --git a/src/__tests__/GitLockstep.test.tsx b/src/__tests__/GitLockstep.test.tsx
new file mode 100644
index 0000000..f57da28
--- /dev/null
+++ b/src/__tests__/GitLockstep.test.tsx
@@ -0,0 +1,279 @@
+/**
+ * Tests for git-aware local↔remote lockstep sync UI (#28n, Phase 1) in GitHistory:
+ * - a remote project with lockstep enabled routes branch checkout through
+ *   `git_peer_checkout` (host-initiated), not the bare `git_checkout`;
+ * - the status pill reflects the backend `GitPeerState`;
+ * - with lockstep disabled the checkout falls back to `git_checkout`;
+ * - a local project (no projectId/remote) never shows the lockstep bar.
+ *
+ * Plus the hardening UI (#28p): the disconnected state (D4), the pairing-overwrite
+ * confirm that must name the files it would destroy (D3), the backup-ref list and
+ * restore (D6), and the hand-resolve-in-a-terminal escape hatch + informed head display
+ * (D8).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("@tauri-apps/api/event", () => ({
+  listen: vi.fn().mockResolvedValue(() => {}),
+}));
+
+import { GitHistory } from "../components/files/GitHistory";
+import { useTabsStore } from "../stores/tabs";
+
+const COMMITS = [
+  { hash: "aaa111", short: "aaa111", subject: "feat", author: "me", date: "2d", refs: "HEAD -> main", is_head: true, parents: [] },
+];
+const BRANCHES = [
+  { name: "main", is_current: true, is_remote: false },
+  { name: "feature", is_current: false, is_remote: false },
+];
+
+function setup(peerState: unknown) {
+  mockInvoke.mockImplementation((cmd: string) => {
+    if (cmd === "git_log") return Promise.resolve(COMMITS);
+    if (cmd === "git_branches") return Promise.resolve(BRANCHES);
+    if (cmd === "git_worktree_list") return Promise.resolve([]);
+    if (cmd === "git_peer_status") return Promise.resolve(peerState);
+    if (cmd === "git_peer_checkout") return Promise.resolve(peerState);
+    if (cmd === "git_peer_resolve") return Promise.resolve({ ...(peerState as object), status: "synchronized", detail: null });
+    if (cmd === "git_checkout") return Promise.resolve(null);
+    return Promise.resolve(null);
+  });
+}
+
+const ENABLED = {
+  enabled: true,
+  status: "synchronized",
+  detail: null,
+  localHead: { kind: "branch", name: "main", sha: "a" },
+  remoteHead: { kind: "branch", name: "main", sha: "a" },
+  lastSyncTs: 1,
+  localSubject: null,
+  remoteSubject: null,
+  pairingConflict: null,
+};
+const DISABLED = { ...ENABLED, enabled: false };
+
+async function renderRemote(peerState: unknown) {
+  await act(async () => {
+    render(<GitHistory projectDir="/p" projectId="proj1" remote />);
+  });
+  void peerState;
+}
+
+describe("#28n git lockstep UI", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("shows the status pill and routes checkout through git_peer_checkout when enabled", async () => {
+    setup(ENABLED);
+    const user = userEvent.setup();
+    await renderRemote(ENABLED);
+
+    // Pill reflects backend status.
+    expect(await screen.findByText("synchronized")).toBeTruthy();
+
+    await user.click(await screen.findByRole("button", { name: "feature" }));
+    expect(mockInvoke).toHaveBeenCalledWith("git_peer_checkout", {
+      projectId: "proj1",
+      target: "feature",
+      initiatingSide: "remote",
+    });
+    expect(mockInvoke).not.toHaveBeenCalledWith("git_checkout", expect.anything());
+  });
+
+  it("falls back to git_checkout when lockstep is disabled", async () => {
+    setup(DISABLED);
+    const user = userEvent.setup();
+    await renderRemote(DISABLED);
+
+    await user.click(await screen.findByRole("button", { name: "feature" }));
+    expect(mockInvoke).toHaveBeenCalledWith("git_checkout", { projectDir: "/p", target: "feature" });
+    expect(mockInvoke).not.toHaveBeenCalledWith("git_peer_checkout", expect.anything());
+  });
+
+  it("offers Use local / Use remote when desynchronized and routes to git_peer_resolve", async () => {
+    const DESYNC = { ...ENABLED, status: "desynchronized", detail: "Diverged: main" };
+    setup(DESYNC);
+    const user = userEvent.setup();
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(true);
+    await renderRemote(DESYNC);
+
+    // The desync detail + both authority buttons render.
+    expect(await screen.findByText("Diverged: main")).toBeTruthy();
+    await user.click(await screen.findByRole("button", { name: "Use remote" }));
+    expect(confirmSpy).toHaveBeenCalled();
+    expect(mockInvoke).toHaveBeenCalledWith("git_peer_resolve", {
+      projectId: "proj1",
+      authority: "remote",
+    });
+    confirmSpy.mockRestore();
+  });
+
+  it("does not resolve when the confirm is dismissed", async () => {
+    const DESYNC = { ...ENABLED, status: "desynchronized", detail: "Diverged: main" };
+    setup(DESYNC);
+    const user = userEvent.setup();
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(false);
+    await renderRemote(DESYNC);
+
+    await user.click(await screen.findByRole("button", { name: "Use local" }));
+    expect(mockInvoke).not.toHaveBeenCalledWith("git_peer_resolve", expect.anything());
+    confirmSpy.mockRestore();
+  });
+
+  it("does not render the lockstep bar for a local project", async () => {
+    setup(null);
+    await act(async () => {
+      render(<GitHistory projectDir="/p" />);
+    });
+    expect(screen.queryByText(/Lockstep/)).toBeNull();
+    expect(mockInvoke).not.toHaveBeenCalledWith("git_peer_status", expect.anything());
+  });
+});
+
+describe("#28p git lockstep hardening UI", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("D4: renders the disconnected state and disables Sync now", async () => {
+    // The whole point of D4: a cold pool must not read as a green "synchronized".
+    const OFFLINE = {
+      ...ENABLED,
+      status: "disconnected",
+      detail: "Not connected to the remote host",
+    };
+    setup(OFFLINE);
+    await renderRemote(OFFLINE);
+
+    expect(await screen.findByText("disconnected")).toBeTruthy();
+    const sync = await screen.findByRole("button", { name: "Sync now" });
+    expect((sync as HTMLButtonElement).disabled).toBe(true);
+    // No authority actions: there is nothing to resolve against an unseen host.
+    expect(screen.queryByRole("button", { name: "Use local" })).toBeNull();
+  });
+
+  it("D3: a pairing conflict offers only the confirm that names the files at risk", async () => {
+    const CONFLICT = {
+      ...ENABLED,
+      status: "desynchronized",
+      detail: "Pairing would overwrite 2 file(s) on the host that differ: README.md, src/a.rs",
+      pairingConflict: { sourceIsLocal: true, paths: ["README.md", "src/a.rs"] },
+    };
+    setup(CONFLICT);
+    const user = userEvent.setup();
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(true);
+    await renderRemote(CONFLICT);
+
+    // Use-local/Use-remote would be meaningless (nothing is paired yet) — the only
+    // action is the one that has named what it would destroy.
+    expect(screen.queryByRole("button", { name: "Use local" })).toBeNull();
+    await user.click(await screen.findByRole("button", { name: /Overwrite 2 file/ }));
+
+    // The confirm must actually list the files — that is the whole safety property.
+    expect(confirmSpy.mock.calls[0][0]).toContain("README.md");
+    expect(mockInvoke).toHaveBeenCalledWith("git_peer_pair_confirm", { projectId: "proj1" });
+    confirmSpy.mockRestore();
+  });
+
+  it("D3: dismissing the overwrite confirm pairs nothing", async () => {
+    const CONFLICT = {
+      ...ENABLED,
+      status: "desynchronized",
+      detail: "Pairing would overwrite 1 file(s) on the host that differ: README.md",
+      pairingConflict: { sourceIsLocal: true, paths: ["README.md"] },
+    };
+    setup(CONFLICT);
+    const user = userEvent.setup();
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(false);
+    await renderRemote(CONFLICT);
+
+    await user.click(await screen.findByRole("button", { name: /Overwrite 1 file/ }));
+    expect(mockInvoke).not.toHaveBeenCalledWith("git_peer_pair_confirm", expect.anything());
+    confirmSpy.mockRestore();
+  });
+
+  it("D6: Backups lists the safety refs and routes Restore to the backend", async () => {
+    const DESYNC = { ...ENABLED, status: "desynchronized", detail: "Diverged: main" };
+    setup(DESYNC);
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "git_log") return Promise.resolve(COMMITS);
+      if (cmd === "git_branches") return Promise.resolve(BRANCHES);
+      if (cmd === "git_worktree_list") return Promise.resolve([]);
+      if (cmd === "git_peer_status") return Promise.resolve(DESYNC);
+      if (cmd === "git_peer_backups")
+        return Promise.resolve([
+          {
+            peer: "remote",
+            refname: "refs/eldrun/backup/1735689600/main",
+            ts: 1735689600,
+            branch: "main",
+            sha: "deadbeefcafe",
+            subject: "The tip a resolve overwrote",
+          },
+        ]);
+      return Promise.resolve(DESYNC);
+    });
+    const user = userEvent.setup();
+    const confirmSpy = vi.spyOn(window, "confirm").mockReturnValue(true);
+    await renderRemote(DESYNC);
+
+    await user.click(await screen.findByRole("button", { name: "Backups" }));
+    expect(await screen.findByText("The tip a resolve overwrote")).toBeTruthy();
+
+    await user.click(await screen.findByRole("button", { name: "Restore" }));
+    expect(mockInvoke).toHaveBeenCalledWith("git_peer_restore_backup", {
+      projectId: "proj1",
+      peer: "remote",
+      refname: "refs/eldrun/backup/1735689600/main",
+    });
+    confirmSpy.mockRestore();
+  });
+
+  it("D8: Resolve in terminal opens a local shell tab in the mirror", async () => {
+    const DESYNC = { ...ENABLED, status: "desynchronized", detail: "Diverged: main" };
+    setup(DESYNC);
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "git_log") return Promise.resolve(COMMITS);
+      if (cmd === "git_branches") return Promise.resolve(BRANCHES);
+      if (cmd === "git_worktree_list") return Promise.resolve([]);
+      if (cmd === "git_peer_mirror_dir") return Promise.resolve("/home/me/mirror");
+      return Promise.resolve(DESYNC);
+    });
+    const user = userEvent.setup();
+    const addTab = vi.spyOn(useTabsStore.getState(), "addTab");
+    await renderRemote(DESYNC);
+
+    await user.click(await screen.findByRole("button", { name: "Resolve in terminal" }));
+
+    const tab = addTab.mock.calls[0][0];
+    expect(tab.kind).toBe("shell");
+    expect(tab.cwd).toBe("/home/me/mirror");
+    // A remote-located shell would cd into the HOST tree, where the parked peer ref
+    // isn't — the merge has to happen in the local mirror.
+    expect(tab.location).toBe("local");
+    expect(tab.initialInput).toContain("refs/eldrun/peer/main");
+    addTab.mockRestore();
+  });
+
+  it("D8: the desync bar shows both heads so the authority choice is informed", async () => {
+    const DESYNC = {
+      ...ENABLED,
+      status: "desynchronized",
+      detail: "Diverged: main",
+      localHead: { kind: "branch", name: "main", sha: "1111111abc" },
+      remoteHead: { kind: "branch", name: "main", sha: "2222222def" },
+      localSubject: "My local work",
+      remoteSubject: "Their host work",
+    };
+    setup(DESYNC);
+    await renderRemote(DESYNC);
+
+    const bar = await screen.findByText(/local: main 1111111/);
+    expect(bar.textContent).toContain("My local work");
+    expect(bar.textContent).toContain("Their host work");
+    expect(bar.textContent).toContain("2222222");
+  });
+});
diff --git a/src/__tests__/GitStatusColors.test.tsx b/src/__tests__/GitStatusColors.test.tsx
index b04b809..423d0ce 100644
--- a/src/__tests__/GitStatusColors.test.tsx
+++ b/src/__tests__/GitStatusColors.test.tsx
@@ -35,6 +35,8 @@ const ACTIVE_PROJECT = {
   local_file: "/tmp/test-project/project.json",
 };
 
+type Change = { path: string; added: number; deleted: number; binary: boolean };
+
 function setupInvoke({
   staged = 0,
   unstaged = 0,
@@ -42,11 +44,13 @@ function setupInvoke({
   has_remote = true,
   fileList = {} as Record<string, string>,
   unpushedCommits = [] as string[],
+  changeStats = {} as Record<string, Change[]>,
 } = {}) {
-  mockInvoke.mockImplementation((cmd: string) => {
+  mockInvoke.mockImplementation((cmd: string, args?: { scope?: string }) => {
     if (cmd === "git_status") return Promise.resolve({ staged, unstaged, untracked, has_remote, is_repo: true });
     if (cmd === "git_file_statuses") return Promise.resolve(fileList);
     if (cmd === "git_unpushed_commits") return Promise.resolve(unpushedCommits);
+    if (cmd === "git_change_stats") return Promise.resolve(changeStats[args?.scope ?? ""] ?? []);
     if (cmd === "load_project") return Promise.resolve({});
     if (cmd === "list_project_endings") return Promise.resolve([]);
     if (cmd === "list_dir") return Promise.resolve([]);
@@ -104,8 +108,8 @@ describe("git action button bars", () => {
     expect(bar.style.background).toBe("rgb(227, 179, 65)");
   });
 
-  it("Push button has green status bar when remote present", async () => {
-    setupInvoke({ has_remote: true });
+  it("Push button has green status bar when remote present and commits ahead", async () => {
+    setupInvoke({ has_remote: true, unpushedCommits: ["abc123"] });
     await renderOpenPanel();
     const bar = await screen.findByTestId("push-bar");
     expect(bar.style.background).toBe("rgb(63, 185, 80)");
@@ -116,9 +120,27 @@ describe("git action button bars", () => {
     await renderOpenPanel();
     expect(screen.queryByTestId("push-bar")).toBeNull();
   });
+
+  it("Add button is hidden when nothing to stage", async () => {
+    setupInvoke({ unstaged: 0, untracked: 0 });
+    await renderOpenPanel();
+    expect(screen.queryByTestId("add-bar")).toBeNull();
+  });
+
+  it("Commit button is hidden when nothing staged", async () => {
+    setupInvoke({ staged: 0 });
+    await renderOpenPanel();
+    expect(screen.queryByTestId("commit-bar")).toBeNull();
+  });
+
+  it("Push button is hidden when remote present but no commits ahead", async () => {
+    setupInvoke({ has_remote: true, unpushedCommits: [] });
+    await renderOpenPanel();
+    expect(screen.queryByTestId("push-bar")).toBeNull();
+  });
 });
 
-describe("git button hover lists", () => {
+describe("git change tree", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockUseProjectsStore.mockReturnValue({ projects: [ACTIVE_PROJECT], activeId: "proj-1" } as ReturnType<typeof useProjectsStore>);
@@ -132,57 +154,70 @@ describe("git button hover lists", () => {
     return result!;
   }
 
-  it("hovering Add shows untracked and modified files", async () => {
+  it("the tree is closed until its caret is clicked", async () => {
+    setupInvoke({ untracked: 1, changeStats: { unstaged: [{ path: "new.ts", added: 3, deleted: 0, binary: false }] } });
+    await renderOpenPanel();
+    await screen.findByTitle(/Stage all changes/);
+    expect(screen.queryByTestId("git-change-tree")).toBeNull();
+  });
+
+  it("opening Add shows the changed files with +/- stats", async () => {
     const user = userEvent.setup();
     setupInvoke({
       untracked: 1,
       unstaged: 1,
-      fileList: { "new.ts": "untracked", "changed.ts": "modified", "staged.ts": "staged" },
+      changeStats: {
+        unstaged: [
+          { path: "src/changed.ts", added: 12, deleted: 5, binary: false },
+          { path: "new.ts", added: 3, deleted: 0, binary: false },
+        ],
+      },
     });
     await renderOpenPanel();
-    const addBtn = await screen.findByTitle(/Stage all changes/);
-    await user.hover(addBtn);
-    const list = await screen.findByTestId("git-hover-list");
-    expect(list.textContent).toContain("new.ts");
-    expect(list.textContent).toContain("changed.ts");
-    expect(list.textContent).not.toContain("staged.ts");
-  });
-
-  it("hovering Commit shows staged files", async () => {
+    const toggle = await screen.findByLabelText("Show changed files");
+    await user.click(toggle);
+    const tree = await screen.findByTestId("git-change-tree");
+    expect(tree.textContent).toContain("changed.ts");
+    expect(tree.textContent).toContain("new.ts");
+    expect(tree.textContent).toContain("+12");
+    expect(tree.textContent).toContain("-5");
+    // The directory is rendered as a navigable node above its file.
+    expect(tree.textContent).toContain("src");
+  });
+
+  it("opening Commit requests the staged scope", async () => {
     const user = userEvent.setup();
     setupInvoke({
-      staged: 2,
-      fileList: { "staged.ts": "staged", "other.ts": "staged", "untracked.ts": "untracked" },
+      staged: 1,
+      changeStats: { staged: [{ path: "staged.ts", added: 7, deleted: 1, binary: false }] },
     });
     await renderOpenPanel();
-    const commitBtn = await screen.findByTitle(/Commit 2 staged/);
-    await user.hover(commitBtn);
-    const list = await screen.findByTestId("git-hover-list");
-    expect(list.textContent).toContain("staged.ts");
-    expect(list.textContent).toContain("other.ts");
-    expect(list.textContent).not.toContain("untracked.ts");
+    const toggle = await screen.findByLabelText("Show staged files");
+    await user.click(toggle);
+    const tree = await screen.findByTestId("git-change-tree");
+    expect(tree.textContent).toContain("staged.ts");
+    expect(tree.textContent).toContain("+7");
+    expect(mockInvoke).toHaveBeenCalledWith("git_change_stats", { projectDir: expect.any(String), scope: "staged" });
   });
 
-  it("hovering Push shows unpushed commit messages", async () => {
+  it("clicking the caret again closes the tree", async () => {
     const user = userEvent.setup();
-    setupInvoke({
-      has_remote: true,
-      unpushedCommits: ["abc1234 feat: add widget", "def5678 fix: correct typo"],
-    });
+    setupInvoke({ staged: 1, changeStats: { staged: [{ path: "staged.ts", added: 1, deleted: 0, binary: false }] } });
     await renderOpenPanel();
-    const pushBtn = await screen.findByTitle("Push to remote");
-    await user.hover(pushBtn);
-    const list = await screen.findByTestId("git-hover-list");
-    expect(list.textContent).toContain("feat: add widget");
-    expect(list.textContent).toContain("fix: correct typo");
+    const toggle = await screen.findByLabelText("Show staged files");
+    await user.click(toggle);
+    await screen.findByTestId("git-change-tree");
+    await user.click(toggle);
+    expect(screen.queryByTestId("git-change-tree")).toBeNull();
   });
 
-  it("hover list is absent when there are no items", async () => {
+  it("shows 'No changes' when the scope is empty", async () => {
     const user = userEvent.setup();
-    setupInvoke({ staged: 1, fileList: {} });
+    setupInvoke({ staged: 1, changeStats: { staged: [] } });
     await renderOpenPanel();
-    const commitBtn = await screen.findByTitle(/Commit 1 staged/);
-    await user.hover(commitBtn);
-    expect(screen.queryByTestId("git-hover-list")).toBeNull();
+    const toggle = await screen.findByLabelText("Show staged files");
+    await user.click(toggle);
+    const tree = await screen.findByTestId("git-change-tree");
+    expect(tree.textContent).toContain("No changes");
   });
 });
diff --git a/src/__tests__/GitWorktree.test.tsx b/src/__tests__/GitWorktree.test.tsx
new file mode 100644
index 0000000..c9c2729
--- /dev/null
+++ b/src/__tests__/GitWorktree.test.tsx
@@ -0,0 +1,101 @@
+/**
+ * Tests for the Git worktree UI in GitHistory (#23, TODO Group E):
+ * - lists worktrees in a "Worktrees" section;
+ * - the create form sends git_worktree_add with the right (camelCase) args;
+ * - removing a non-main worktree sends git_worktree_remove for that path;
+ * - the main worktree has no enabled remove control.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+
+import { GitHistory } from "../components/files/GitHistory";
+
+const COMMITS = [
+  { hash: "aaa111", short: "aaa111", subject: "feat: add widget", author: "me", date: "2d ago", refs: "HEAD -> main", is_head: true, parents: ["bbb222"] },
+];
+
+const BRANCHES = [
+  { name: "main", is_current: true, is_remote: false },
+  { name: "feature", is_current: false, is_remote: false },
+  { name: "origin/main", is_current: false, is_remote: true },
+];
+
+const WORKTREES = [
+  { path: "/p", branch: "main", head: "aaa111aaa", is_main: true, is_locked: false, is_bare: false },
+  { path: "/p-feature", branch: "feature", head: "ccc333ccc", is_main: false, is_locked: false, is_bare: false },
+];
+
+function setupInvoke() {
+  mockInvoke.mockImplementation((cmd: string) => {
+    if (cmd === "git_log") return Promise.resolve(COMMITS);
+    if (cmd === "git_branches") return Promise.resolve(BRANCHES);
+    if (cmd === "git_worktree_list") return Promise.resolve(WORKTREES);
+    if (cmd === "git_worktree_add") return Promise.resolve(null);
+    if (cmd === "git_worktree_remove") return Promise.resolve(null);
+    if (cmd === "git_commit_message") return Promise.resolve("feat: add widget");
+    return Promise.resolve(null);
+  });
+}
+
+async function renderHistory() {
+  await act(async () => {
+    render(<GitHistory projectDir="/p" />);
+  });
+}
+
+describe("#23 git worktrees", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupInvoke();
+  });
+
+  it("lists the worktrees", async () => {
+    await renderHistory();
+    expect(await screen.findByText("Worktrees")).toBeTruthy();
+    // main worktree (branch "main") and the linked "feature" worktree.
+    // Scope to the worktree pill: "feature" also appears as a branch pill.
+    const featurePill = (await screen.findByTitle("/p-feature")) as HTMLElement;
+    expect(featurePill.textContent).toContain("feature");
+  });
+
+  it("create form sends git_worktree_add with camelCase args", async () => {
+    const user = userEvent.setup();
+    await renderHistory();
+    await screen.findByText("Worktrees");
+
+    await user.click(screen.getByRole("button", { name: "+ Worktree" }));
+    // Branch picker is the themed Dropdown (title "Branch"): open it, pick "feature".
+    await user.click(screen.getByTitle("Branch"));
+    await user.click(screen.getByRole("option", { name: "feature" }));
+    await user.type(screen.getByLabelText("Worktree path"), "/tmp/wt");
+    await user.click(screen.getByRole("button", { name: "Create" }));
+
+    expect(mockInvoke).toHaveBeenCalledWith("git_worktree_add", {
+      projectDir: "/p",
+      path: "/tmp/wt",
+      branch: "feature",
+      newBranch: false,
+    });
+  });
+
+  it("removing a non-main worktree calls git_worktree_remove for its path", async () => {
+    const user = userEvent.setup();
+    await renderHistory();
+    const pill = (await screen.findByTitle("/p-feature")) as HTMLElement;
+    await user.click(within(pill).getByRole("button", { name: /Remove worktree/ }));
+    expect(mockInvoke).toHaveBeenCalledWith(
+      "git_worktree_remove",
+      expect.objectContaining({ projectDir: "/p", path: "/p-feature" }),
+    );
+  });
+
+  it("the main worktree has no remove control", async () => {
+    await renderHistory();
+    const mainPill = (await screen.findByTitle("/p")) as HTMLElement;
+    expect(within(mainPill).queryByRole("button", { name: /Remove worktree/ })).toBeNull();
+  });
+});
diff --git a/src/__tests__/GlobalMachinesIdempotence.test.ts b/src/__tests__/GlobalMachinesIdempotence.test.ts
new file mode 100644
index 0000000..1ae6372
--- /dev/null
+++ b/src/__tests__/GlobalMachinesIdempotence.test.ts
@@ -0,0 +1,113 @@
+/**
+ * Regression test for the renderer spin: a lamp write that changes nothing must
+ * not notify.
+ *
+ * `setStatus` and `probeAll` rebuilt `status` unconditionally, and zustand
+ * notifies on identity — so writing a machine the state it was already in woke
+ * every subscriber of this store. `MachinesIndicator` alone holds fourteen
+ * selectors against it, so one no-op re-ran all fourteen and re-rendered the
+ * header, which re-rendered the project pills, the file panel and the tree under
+ * them.
+ *
+ * Measured in the running app, idle, via the perf probe:
+ *
+ *              before                     after
+ *   commits    150 per 10s                33 per 10s
+ *   gm writes  66 per 10s (64 = status)   0
+ *   stalls     1 x 263ms per 10s          0
+ *
+ * That is the whole of the "WebKit renderer pegged, window unresponsive" report:
+ * the main thread was re-rendering the entire chrome ~14 times a second for no
+ * state change at all.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+// Pulled in by the store's connect/disconnect paths; irrelevant here.
+vi.mock("../lib/machineSync", () => ({
+  syncGlobalConnected: vi.fn(),
+  syncGlobalDisconnected: vi.fn(),
+}));
+
+import { useGlobalMachinesStore } from "../stores/globalMachines";
+import { useSettingsStore } from "../stores/settings";
+import type { Settings } from "../types";
+
+const MACHINES = [
+  { id: "m1", host: "a.example", user: "u" },
+  { id: "m2", host: "b.example", user: "u" },
+];
+
+describe("globalMachines — a no-op status write must not notify", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    useGlobalMachinesStore.setState({
+      machines: MACHINES as never,
+      status: { m1: "connected", m2: "connected" },
+      reachable: { m1: true, m2: true },
+      loaded: true,
+    });
+    // `probeAll` skips HPC-tagged machines via `mayAutoTouch`, which fails closed on
+    // an unloaded settings store — without this it would sweep nothing at all.
+    useSettingsStore.setState({ settings: {} as Settings, loaded: true });
+  });
+
+  it("setStatus does not notify when the lamp already holds that value", () => {
+    const seen = vi.fn();
+    const unsub = useGlobalMachinesStore.subscribe(seen);
+
+    useGlobalMachinesStore.getState().setStatus("m1", "connected");
+    expect(seen).not.toHaveBeenCalled();
+
+    // A real transition must still get through — the fix must not make the lamp
+    // stop working, which would be a far worse bug than the one it cures.
+    useGlobalMachinesStore.getState().setStatus("m1", "error");
+    expect(seen).toHaveBeenCalledTimes(1);
+    expect(useGlobalMachinesStore.getState().status.m1).toBe("error");
+
+    unsub();
+  });
+
+  it("probeAll does not notify when every machine is already in the probed state", async () => {
+    // Both already reachable, and both probe ok → nothing changed.
+    mockInvoke.mockResolvedValue({ ok: true });
+    const seen = vi.fn();
+    const unsub = useGlobalMachinesStore.subscribe(seen);
+
+    await useGlobalMachinesStore.getState().probeAll();
+    // This is the valuable half: `probeAll` writes EVERY machine at once, so on a
+    // fleet of N an unchanged sweep used to invalidate the whole list at once.
+    expect(seen).not.toHaveBeenCalled();
+
+    unsub();
+  });
+
+  // The expectation moved from `status` to `reachable` on purpose. A probe answers
+  // "did the host answer", which is NOT "does this app hold a session on it" — and
+  // `status` means the second, because `lib/machineSync` propagates it onto any
+  // project holding the same host and opens that project's pool. Letting a hover-time
+  // sweep write `status` is what lit a machine green with no session behind it while
+  // the project stayed unconnected. The idempotence guarantee this file exists for is
+  // unchanged; only the field it guards moved.
+  it("probeAll still notifies, once, when a machine actually changed — on `reachable`", async () => {
+    mockInvoke.mockImplementation((_cmd: string, args: { host?: string }) =>
+      Promise.resolve({ ok: args?.host !== "b.example" }),
+    );
+    const seen = vi.fn();
+    const unsub = useGlobalMachinesStore.subscribe(seen);
+
+    await useGlobalMachinesStore.getState().probeAll();
+
+    expect(seen).toHaveBeenCalledTimes(1);
+    expect(useGlobalMachinesStore.getState().reachable).toEqual({ m1: true, m2: false });
+    // …and the session lamps are left exactly as they were: nothing about a probe
+    // opens or ends a session.
+    expect(useGlobalMachinesStore.getState().status).toEqual({
+      m1: "connected",
+      m2: "connected",
+    });
+
+    unsub();
+  });
+});
diff --git a/src/__tests__/GrammarCheck.test.ts b/src/__tests__/GrammarCheck.test.ts
new file mode 100644
index 0000000..92c6ac0
--- /dev/null
+++ b/src/__tests__/GrammarCheck.test.ts
@@ -0,0 +1,117 @@
+/**
+ * Unit tests for the local-model grammar-check helpers: `resolveGrammarRanges`
+ * (mapping model-reported issues to concrete `{start,end}` ranges in the draft)
+ * and `decorateGrammarRanges` (the transparent overlay that underlines them).
+ * Mirrors the search/change-decoration tests.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  resolveGrammarRanges,
+  decorateGrammarRanges,
+  type GrammarRange,
+} from "../components/embed/FileViewerPane";
+import type { GrammarIssue } from "../types";
+
+const issue = (over: Partial<GrammarIssue>): GrammarIssue => ({
+  line: 1,
+  bad: "",
+  suggestion: "",
+  category: "grammar",
+  message: "",
+  ...over,
+});
+
+describe("resolveGrammarRanges", () => {
+  it("returns no ranges for no issues", () => {
+    expect(resolveGrammarRanges("hello", [])).toEqual([]);
+  });
+
+  it("locates a misspelling on its reported line", () => {
+    const text = "The quick brown fox\njumps over teh lazy dog";
+    const ranges = resolveGrammarRanges(text, [
+      issue({ line: 2, bad: "teh", suggestion: "the", category: "spelling" }),
+    ]);
+    expect(ranges).toHaveLength(1);
+    const start = text.indexOf("teh");
+    expect(ranges[0].start).toBe(start);
+    expect(ranges[0].end).toBe(start + 3);
+    expect(ranges[0].issue.category).toBe("spelling");
+  });
+
+  it("uses the line hint to disambiguate duplicate words", () => {
+    // "is" appears on both lines; the issue on line 2 must map to the 2nd one.
+    const text = "this is fine\nthis is wrong";
+    const ranges = resolveGrammarRanges(text, [
+      issue({ line: 2, bad: "is" }),
+    ]);
+    expect(ranges).toHaveLength(1);
+    // Second "is" is after the newline.
+    expect(ranges[0].start).toBeGreaterThan(text.indexOf("\n"));
+  });
+
+  it("maps two issues on the same line to distinct occurrences", () => {
+    const text = "na na na";
+    const ranges = resolveGrammarRanges(text, [
+      issue({ line: 1, bad: "na" }),
+      issue({ line: 1, bad: "na" }),
+    ]);
+    expect(ranges).toHaveLength(2);
+    expect(ranges[0].start).toBe(0);
+    expect(ranges[1].start).toBe(3);
+  });
+
+  it("falls back to a whole-document search when the line drifted", () => {
+    const text = "alpha\nbeta\ngamma";
+    // Report "gamma" on a line that no longer holds it; it should still resolve.
+    const ranges = resolveGrammarRanges(text, [issue({ line: 1, bad: "gamma" })]);
+    expect(ranges).toHaveLength(1);
+    expect(ranges[0].start).toBe(text.indexOf("gamma"));
+  });
+
+  it("skips an issue whose text is nowhere in the draft", () => {
+    expect(resolveGrammarRanges("clean text", [issue({ bad: "zzz" })])).toEqual([]);
+  });
+
+  it("sorts by start and prunes overlapping ranges", () => {
+    const text = "overlapping";
+    const ranges = resolveGrammarRanges(text, [
+      issue({ line: 1, bad: "lapp" }), // starts at 4
+      issue({ line: 1, bad: "over" }), // starts at 0
+      issue({ line: 1, bad: "verlap" }), // 1..7 overlaps "over" → dropped
+    ]);
+    const starts = ranges.map((r) => r.start);
+    // Sorted ascending, no overlap with a prior range's end.
+    expect(starts).toEqual([...starts].sort((a, b) => a - b));
+    for (let i = 1; i < ranges.length; i++) {
+      expect(ranges[i].start).toBeGreaterThanOrEqual(ranges[i - 1].end);
+    }
+  });
+});
+
+describe("decorateGrammarRanges", () => {
+  const r = (start: number, end: number, category: GrammarRange["issue"]["category"]): GrammarRange => ({
+    start,
+    end,
+    issue: issue({ category, bad: "x" }),
+  });
+
+  it("returns plain escaped text when there are no ranges", () => {
+    expect(decorateGrammarRanges("a<b", [])).toBe("a&lt;b");
+  });
+
+  it("wraps each range in a category-tagged mark span, escaping the rest", () => {
+    // "ab cd" — mark "ab" (spelling) and "cd" (grammar).
+    const html = decorateGrammarRanges("ab cd", [r(0, 2, "spelling"), r(3, 5, "grammar")]);
+    expect(html).toBe(
+      '<span class="file-viewer-grammar-mark cat-spelling" data-gi="0">ab</span>' +
+        " " +
+        '<span class="file-viewer-grammar-mark cat-grammar" data-gi="1">cd</span>',
+    );
+  });
+
+  it("escapes HTML inside a marked run", () => {
+    expect(decorateGrammarRanges("<x>", [r(0, 3, "style")])).toBe(
+      '<span class="file-viewer-grammar-mark cat-style" data-gi="0">&lt;x&gt;</span>',
+    );
+  });
+});
diff --git a/src/__tests__/HeadlessSshConnect.test.ts b/src/__tests__/HeadlessSshConnect.test.ts
new file mode 100644
index 0000000..059da08
--- /dev/null
+++ b/src/__tests__/HeadlessSshConnect.test.ts
@@ -0,0 +1,148 @@
+/**
+ * Headless SSH connect — the typed password must reach the *pooled* connection,
+ * not just the probe.
+ *
+ * `connectSshHeadless` makes two backend calls. `ssh_connect` only probes: it
+ * runs a throwaway ssh with `ControlMaster=no` (reuse-only — it never *creates* a
+ * master), so a successful probe leaves nothing behind to ride. `remote_connect`
+ * is the one that opens the master-owning pooled SSH/SFTP session, and it needs
+ * the password itself; handed `null` it drops to key/agent auth, which a
+ * password-auth host rejects. It falls back to a *saved* password, so the bug hid
+ * behind the (default-off) "Save password" toggle: connecting worked only if you
+ * happened to tick it.
+ *
+ * These lock the password reaching BOTH calls, and lock the two paths that
+ * legitimately pass `null` so they aren't "fixed" into leaking a password they
+ * don't have.
+ *
+ * The `remember` argument is `null` here, not `false`, and the type now forbids
+ * `false` outright: `false` is `Remember::Clear`, so a *successful* connect
+ * carrying it deletes the saved password it just authenticated with.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn() }));
+
+import { useRemoteReconnect } from "../components/projects/useRemoteReconnect";
+import type { ProjectEntry } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+const PROJECT = {
+  id: "p1",
+  name: "sshtest",
+  directory: "/local/state/p1",
+  remote: { user: "alice", host: "host.example", port: 2222, remote_path: "/srv/work" },
+} as unknown as ProjectEntry;
+
+/** Args of the first call to `cmd`, or undefined if it was never invoked. */
+const argsOf = (cmd: string) =>
+  invokeMock.mock.calls.find(([name]) => name === cmd)?.[1] as
+    | Record<string, unknown>
+    | undefined;
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    // Queried on mount; both must resolve or the hook's effects reject.
+    if (cmd === "remote_saved_password_state") {
+      return Promise.resolve({ saved: false, keyring: "unlocked" });
+    }
+    if (cmd === "vpn_has_saved_password") return Promise.resolve(false);
+    if (cmd === "ssh_connect") return Promise.resolve({ saved: false, save_error: null });
+    if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+    if (cmd === "openvpn_auth_needs") {
+      return Promise.resolve({ username: false, keyPassphrase: false });
+    }
+    return Promise.resolve();
+  });
+});
+
+describe("headless SSH connect", () => {
+  it("hands the typed password to the pooled connection, not just the probe", async () => {
+    const { result } = renderHook(() => useRemoteReconnect(PROJECT));
+
+    await act(async () => {
+      await result.current.connectSshHeadless("s3cret", null);
+    });
+
+    // The probe authenticates against the host target…
+    expect(argsOf("ssh_connect")).toMatchObject({
+      user: "alice",
+      host: "host.example",
+      port: 2222,
+      password: "s3cret",
+    });
+
+    // …but the pooled session is what actually opens the master, so it needs the
+    // password too. Passing `null` here is the bug: it silently downgrades to
+    // key/agent auth and only worked when a password happened to be saved.
+    expect(argsOf("remote_connect")).toEqual({
+      projectId: "p1",
+      hostId: "primary",
+      password: "s3cret",
+      // A Connect click, not a sweep: `remote_connect` defaults to *background*,
+      // which a host tagged HPC refuses outright.
+      background: false,
+    });
+
+    await waitFor(() => expect(result.current.sshStatus).toBe("connected"));
+  });
+
+  it("sends a blank password as null, so the backend falls back to key auth or the keychain", async () => {
+    // Two callers hand this an empty string: the Windows `winManual` key-auth
+    // Connect, and a user who leaves the field blank because a password is already
+    // saved (it can't be pre-filled — the secret never leaves the backend). Both
+    // mean "nothing given", so it must reach the backend as `null`, not "".
+    //
+    // `""` is not a harmless synonym: `remote::connect` only falls back (to the
+    // saved password, then to key/agent auth) when the password is absent, so a
+    // literal empty string was used *as* the password and the pooled connect failed
+    // with a perfectly good credential sitting in the keychain.
+    const { result } = renderHook(() => useRemoteReconnect(PROJECT));
+
+    await act(async () => {
+      await result.current.connectSshHeadless("", null);
+    });
+
+    expect(argsOf("ssh_connect")).toMatchObject({ password: null });
+    expect(argsOf("remote_connect")).toEqual({
+      projectId: "p1",
+      hostId: "primary",
+      password: null,
+      background: false,
+    });
+  });
+
+  it("surfaces a failed pooled connect as an error, not a green lamp", async () => {
+    // A probe can succeed while the pool fails (exactly the shape of the bug).
+    // The lamp must follow `remote_connect`, not `ssh_connect`.
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "remote_saved_password_state") {
+        return Promise.resolve({ saved: false, keyring: "unlocked" });
+      }
+      if (cmd === "vpn_has_saved_password") return Promise.resolve(false);
+      if (cmd === "ssh_connect") return Promise.resolve({ saved: false, save_error: null });
+      if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+      if (cmd === "openvpn_auth_needs") {
+        return Promise.resolve({ username: false, keyPassphrase: false });
+      }
+      if (cmd === "remote_connect") return Promise.reject("Permission denied (publickey,password).");
+      return Promise.resolve();
+    });
+
+    const { result } = renderHook(() => useRemoteReconnect(PROJECT));
+
+    await act(async () => {
+      await result.current.connectSshHeadless("s3cret", null);
+    });
+
+    await waitFor(() => expect(result.current.sshStatus).toBe("error"));
+    expect(result.current.sshError).toContain("Permission denied");
+  });
+});
diff --git a/src/__tests__/HiddenFilesSection.test.ts b/src/__tests__/HiddenFilesSection.test.ts
deleted file mode 100644
index 9c855a5..0000000
--- a/src/__tests__/HiddenFilesSection.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Tests for the right-panel "hidden files" section data source (#29, Group N):
- * - hiddenEntries surfaces dotfiles that visibleEntries drops from the inline tree
- * - standard/scaffold, internal, .gitignore, and user-hidden items stay out of it
- * - the two functions never overlap, so an entry shows in exactly one place
- */
-import { describe, it, expect } from "vitest";
-import { visibleEntries, hiddenEntries, type FileEntry } from "../lib/viewers/fileUtils";
-
-function entry(name: string, over: Partial<FileEntry> = {}): FileEntry {
-  return {
-    name,
-    path: `/proj/${name}`,
-    is_dir: false,
-    size: 0,
-    extension: name.includes(".") ? name.slice(name.lastIndexOf(".")) : null,
-    mime: null,
-    ...over,
-  };
-}
-
-const base = { showHidden: false, showStandardFiles: true } as const;
-
-describe("hiddenEntries", () => {
-  it("collects dotfiles that the inline tree hides", () => {
-    const entries = [entry("src", { is_dir: true }), entry(".env"), entry(".cache", { is_dir: true })];
-    const hidden = hiddenEntries(entries, { showHidden: false });
-    expect(hidden.map((e) => e.name)).toEqual([".cache", ".env"]);
-  });
-
-  it("keeps .gitignore, scaffold, and internal files out of the bucket", () => {
-    const entries = [entry(".gitignore"), entry(".claude", { is_dir: true }), entry("project.json")];
-    expect(hiddenEntries(entries, { showHidden: false })).toEqual([]);
-  });
-
-  it("respects hiddenPaths and hiddenEndings (those stay fully hidden)", () => {
-    const entries = [entry(".env"), entry(".secret"), entry(".tmp")];
-    const hidden = hiddenEntries(entries, {
-      showHidden: false,
-      hiddenPaths: [".secret"],
-      hiddenEndings: [".tmp"],
-    });
-    expect(hidden.map((e) => e.name)).toEqual([".env"]);
-  });
-
-  it("is empty when showHidden is on (dotfiles render inline instead)", () => {
-    const entries = [entry(".env"), entry(".cache", { is_dir: true })];
-    expect(hiddenEntries(entries, { showHidden: true })).toEqual([]);
-  });
-
-  it("never overlaps with the inline visible set", () => {
-    const entries = [entry("src", { is_dir: true }), entry(".env"), entry(".gitignore")];
-    const visible = new Set(visibleEntries(entries, base).map((e) => e.name));
-    const hidden = new Set(hiddenEntries(entries, base).map((e) => e.name));
-    for (const name of hidden) expect(visible.has(name)).toBe(false);
-    expect(hidden.has(".env")).toBe(true);
-  });
-});
diff --git a/src/__tests__/Highlight.test.ts b/src/__tests__/Highlight.test.ts
index 0b85ee8..4d13d13 100644
--- a/src/__tests__/Highlight.test.ts
+++ b/src/__tests__/Highlight.test.ts
@@ -12,6 +12,8 @@ describe("languageForPath", () => {
     expect(languageForPath("style.scss")).toBe("css");
     expect(languageForPath("paper.tex")).toBe("tex");
     expect(languageForPath("macros.sty")).toBe("tex");
+    expect(languageForPath("README.md")).toBe("markdown");
+    expect(languageForPath("notes.markdown")).toBe("markdown");
   });
 
   it("maps well-known extensionless filenames", () => {
@@ -83,4 +85,30 @@ describe("highlight", () => {
     const html = highlight('x = """line1\nline2"""', "python")!;
     expect(html).toContain('<span class="tok-string">&quot;&quot;&quot;line1\nline2&quot;&quot;&quot;</span>');
   });
+
+  it("highlights markdown headings, emphasis, code, and links", () => {
+    const src = "# Title\n**bold** and *em* with `code`\n[text](http://x)";
+    const html = highlight(src, "markdown")!;
+    expect(html).toContain('<span class="tok-md-heading"># Title</span>');
+    expect(html).toContain('<span class="tok-md-strong">**bold**</span>');
+    expect(html).toContain('<span class="tok-md-em">*em*</span>');
+    expect(html).toContain('<span class="tok-md-code">`code`</span>');
+    expect(html).toContain('<span class="tok-md-link">text</span>');
+    expect(html).toContain('<span class="tok-md-url">http://x</span>');
+  });
+
+  it("highlights markdown fences, blockquotes, and list markers", () => {
+    const html = highlight("> quote\n- item\n```\nraw *not em*\n```", "markdown")!;
+    expect(html).toContain('<span class="tok-md-quote">&gt; </span>');
+    expect(html).toContain('<span class="tok-md-list">-</span>');
+    expect(html).toContain('<span class="tok-md-code">```</span>');
+    // Content inside a fence is verbatim, not inline-tokenized.
+    expect(html).toContain('<span class="tok-md-code">raw *not em*</span>');
+  });
+
+  it("does not treat intra-word underscores or spaced asterisks as emphasis", () => {
+    const html = highlight("some_var_name and 2 * 3 * 4", "markdown")!;
+    expect(html).not.toContain("tok-md-em");
+    expect(html).not.toContain("tok-md-strong");
+  });
 });
diff --git a/src/__tests__/HintSelection.test.ts b/src/__tests__/HintSelection.test.ts
new file mode 100644
index 0000000..c1759bb
--- /dev/null
+++ b/src/__tests__/HintSelection.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { pickHint, type HintCtx } from "../lib/hints";
+
+const empty: HintCtx = { projectCount: 0, activeId: null };
+const active: HintCtx = { projectCount: 1, activeId: "p1" };
+
+describe("pickHint", () => {
+  it("offers create-project first on an empty workspace", () => {
+    expect(pickHint(empty, new Set(), true)).toBe("create-project");
+  });
+
+  it("does not offer create-project once a project exists", () => {
+    const picked = pickHint(active, new Set(), true);
+    expect(picked).not.toBe("create-project");
+    expect(picked).toBe("add-tab"); // highest-priority eligible with an active project
+  });
+
+  it("skips seen hints and falls through by priority", () => {
+    expect(pickHint(active, new Set(["add-tab"]), true)).toBe("toggle-panels");
+    expect(pickHint(active, new Set(["add-tab", "toggle-panels"]), true)).toBe("file-tree");
+  });
+
+  it("returns null when every eligible hint is seen", () => {
+    const all = new Set(["create-project", "add-tab", "toggle-panels", "file-tree"]);
+    expect(pickHint(active, all, true)).toBeNull();
+  });
+
+  it("returns null when hints are disabled", () => {
+    expect(pickHint(empty, new Set(), false)).toBeNull();
+  });
+
+  it("nags about an untrusted Codex hook ahead of the onboarding hints", () => {
+    // Situational and actionable, so it outranks add-tab (80) — but never the
+    // empty-workspace prompt (100), which is the more urgent thing to do.
+    const ctx: HintCtx = { ...active, codexHookNeedsTrust: true };
+    expect(pickHint(ctx, new Set(), true)).toBe("codex-hook-trust");
+    expect(pickHint({ ...empty, codexHookNeedsTrust: true }, new Set(), true)).toBe(
+      "create-project",
+    );
+  });
+
+  it("stays quiet about Codex when the hook is fine or unprobed", () => {
+    // Absent (no Codex tab open) and false (hook trusted) both mean: say nothing.
+    expect(pickHint(active, new Set(), true)).toBe("add-tab");
+    expect(pickHint({ ...active, codexHookNeedsTrust: false }, new Set(), true)).toBe(
+      "add-tab",
+    );
+  });
+});
diff --git a/src/__tests__/HostKeyConfirm.test.ts b/src/__tests__/HostKeyConfirm.test.ts
new file mode 100644
index 0000000..d4d34ef
--- /dev/null
+++ b/src/__tests__/HostKeyConfirm.test.ts
@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const invokeMock = vi.fn();
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+
+import { UNKNOWN_HOST_KEY, unknownHostKeyTarget, withHostKeyConfirm } from "../lib/hostKey";
+import { useHostKeyPromptStore } from "../stores/hostKeyPrompt";
+
+/**
+ * The first-contact host-key gate, from the frontend's side.
+ *
+ * The whole recovery flow hangs off one string: the backend's refusal carries
+ * `ELDRUN_UNKNOWN_HOST_KEY <host:port>`, and the wrapper reads the target out of
+ * *the error itself* rather than from the call site. So the parse and the
+ * retry-once-on-accept contract are what these cover.
+ */
+
+const REFUSAL = `${UNKNOWN_HOST_KEY} build.example:2222 — this host's SSH key has never been accepted on this machine.`;
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  // Seed "loading", never "ready": a wait for `ready` would otherwise pass
+  // instantly against the seed, before the dialog has even opened.
+  useHostKeyPromptStore.setState({ pending: null, status: "loading", error: "", keys: [], scan: "" });
+});
+
+describe("unknownHostKeyTarget", () => {
+  it("reads the resolved target out of the refusal", () => {
+    expect(unknownHostKeyTarget(REFUSAL)).toBe("build.example:2222");
+    // Tauri rejections arrive as strings, but an Error must work too.
+    expect(unknownHostKeyTarget(new Error(REFUSAL))).toBe("build.example:2222");
+  });
+
+  it("does not claim an ordinary auth failure", () => {
+    // Every other connect error must fall through untouched — misreading one as a
+    // host-key problem would put a fingerprint dialog in front of a typo'd password.
+    expect(unknownHostKeyTarget("Permission denied (publickey,password).")).toBeNull();
+    expect(unknownHostKeyTarget("")).toBeNull();
+    expect(unknownHostKeyTarget(undefined)).toBeNull();
+  });
+});
+
+describe("withHostKeyConfirm", () => {
+  it("passes a successful connect straight through without asking", async () => {
+    const attempt = vi.fn().mockResolvedValue("ok");
+    await expect(withHostKeyConfirm(attempt)).resolves.toBe("ok");
+    expect(attempt).toHaveBeenCalledTimes(1);
+    expect(useHostKeyPromptStore.getState().pending).toBeNull();
+  });
+
+  it("re-throws any other failure without opening the dialog", async () => {
+    const attempt = vi.fn().mockRejectedValue("Permission denied (publickey,password).");
+    await expect(withHostKeyConfirm(attempt)).rejects.toBe(
+      "Permission denied (publickey,password).",
+    );
+    expect(attempt).toHaveBeenCalledTimes(1);
+    expect(useHostKeyPromptStore.getState().pending).toBeNull();
+  });
+
+  it("retries exactly once after the user accepts the fingerprint", async () => {
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "ssh_host_key_preview")
+        return Promise.resolve({
+          target: "build.example:2222",
+          known: false,
+          keys: [{ keyType: "ED25519", fingerprint: "SHA256:abc", bits: 256 }],
+          scan: "[build.example]:2222 ssh-ed25519 AAAA",
+        });
+      if (cmd === "ssh_trust_host_key") return Promise.resolve();
+      return Promise.reject(new Error(`unexpected ${cmd}`));
+    });
+
+    const attempt = vi.fn().mockRejectedValueOnce(REFUSAL).mockResolvedValueOnce("connected");
+    const done = withHostKeyConfirm(attempt);
+
+    // The dialog opens on the target parsed out of the error, and the preview is
+    // fetched for the split host/port — not the joined string.
+    // The scan is what Accept needs, so it is what "the dialog is ready" means.
+    await vi.waitFor(() => expect(useHostKeyPromptStore.getState().scan).not.toBe(""));
+    expect(useHostKeyPromptStore.getState().status).toBe("ready");
+    expect(useHostKeyPromptStore.getState().pending?.target).toBe("build.example:2222");
+    expect(invokeMock).toHaveBeenCalledWith("ssh_host_key_preview", {
+      host: "build.example",
+      port: 2222,
+    });
+
+    await useHostKeyPromptStore.getState().accept();
+    await expect(done).resolves.toBe("connected");
+    expect(attempt).toHaveBeenCalledTimes(2);
+    // What is stored is what was shown — the scan is handed back verbatim, never
+    // re-fetched at accept time.
+    expect(invokeMock).toHaveBeenCalledWith("ssh_trust_host_key", {
+      scan: "[build.example]:2222 ssh-ed25519 AAAA",
+    });
+  });
+
+  it("does not retry when the user declines, and keeps the original error", async () => {
+    invokeMock.mockResolvedValue({
+      target: "build.example:2222",
+      known: false,
+      keys: [{ keyType: "ED25519", fingerprint: "SHA256:abc", bits: 256 }],
+      scan: "line",
+    });
+    const attempt = vi.fn().mockRejectedValue(REFUSAL);
+    const done = withHostKeyConfirm(attempt);
+    await vi.waitFor(() => expect(useHostKeyPromptStore.getState().pending).not.toBeNull());
+
+    useHostKeyPromptStore.getState().cancel();
+    // Declining is a decision, not a new error: the caller sees the connect failure
+    // it would have seen anyway, so its lamp/message stay truthful.
+    await expect(done).rejects.toBe(REFUSAL);
+    expect(attempt).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries without asking when the key turned out to be known already", async () => {
+    // Another connect accepted this host while we were about to ask. There is
+    // nothing left to confirm, so the caller must not be shown a dialog it would
+    // only have to dismiss.
+    invokeMock.mockResolvedValue({ target: "build.example:22", known: true, keys: [], scan: "" });
+    const attempt = vi.fn().mockRejectedValueOnce(REFUSAL).mockResolvedValueOnce("connected");
+    await expect(withHostKeyConfirm(attempt)).resolves.toBe("connected");
+    expect(attempt).toHaveBeenCalledTimes(2);
+    expect(invokeMock).not.toHaveBeenCalledWith("ssh_trust_host_key", expect.anything());
+    expect(useHostKeyPromptStore.getState().pending).toBeNull();
+  });
+
+  it("offers nothing to accept when the host key cannot be read", async () => {
+    // No fingerprint ⇒ no question can be asked. The modal must not present an
+    // Accept that would trust an empty scan.
+    invokeMock.mockRejectedValue("no route to host");
+    const attempt = vi.fn().mockRejectedValue(REFUSAL);
+    const done = withHostKeyConfirm(attempt);
+    await vi.waitFor(() => expect(useHostKeyPromptStore.getState().status).toBe("error"));
+    expect(useHostKeyPromptStore.getState().scan).toBe("");
+
+    await useHostKeyPromptStore.getState().accept(); // a no-op with no scan
+    expect(invokeMock).not.toHaveBeenCalledWith("ssh_trust_host_key", expect.anything());
+    useHostKeyPromptStore.getState().cancel();
+    await expect(done).rejects.toBe(REFUSAL);
+  });
+});
diff --git a/src/__tests__/HpcWorkspace.test.ts b/src/__tests__/HpcWorkspace.test.ts
new file mode 100644
index 0000000..194c7d6
--- /dev/null
+++ b/src/__tests__/HpcWorkspace.test.ts
@@ -0,0 +1,187 @@
+/**
+ * The HPC **workspace** helpers (`lib/hpcWorkspace.ts`), all pure. A workspace is
+ * a time-limited directory on a cluster's parallel filesystem — the place a
+ * project's data must live so it never fills the user's home quota — and it is
+ * *deleted* when it expires. These tests pin the two things the UI derives from a
+ * workspace: where a project inside it goes (the whole integration is that this
+ * path becomes the project's remote root), and how loudly the remaining time is
+ * said.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  projectPathIn,
+  remainingLabel,
+  expiryTone,
+  defaultFilesystem,
+  defaultAnchorRel,
+  logOutputPattern,
+  freeSpaceLabel,
+  findProjectWorkspace,
+  shouldWarnExpiry,
+  wsTargetForHost,
+  wsTargetForProject,
+  type HpcWorkspace,
+} from "../lib/hpcWorkspace";
+
+const WS: HpcWorkspace = {
+  id: "demo",
+  path: "/lustre/scratch/data/alice-demo",
+  filesystem: "scratch",
+  remaining: "89 days 23 hours",
+  remaining_days: 89,
+  extensions: 3,
+};
+
+describe("projectPathIn", () => {
+  it("puts the project inside the workspace", () => {
+    expect(projectPathIn(WS, "my-experiment")).toBe(
+      "/lustre/scratch/data/alice-demo/my-experiment",
+    );
+  });
+
+  it("tolerates a trailing slash and an empty name", () => {
+    expect(projectPathIn({ path: "/lustre/x/" }, "p")).toBe("/lustre/x/p");
+    expect(projectPathIn(WS, "")).toBe("/lustre/scratch/data/alice-demo");
+  });
+});
+
+describe("remainingLabel", () => {
+  it("summarizes days and extensions", () => {
+    expect(remainingLabel(WS)).toBe("89 days left · 3 extensions");
+  });
+
+  it("singularizes", () => {
+    expect(remainingLabel({ ...WS, remaining_days: 1, extensions: 1 })).toBe(
+      "1 day left · 1 extension",
+    );
+  });
+
+  it("falls back to the tooling's own phrasing, and says nothing when it said nothing", () => {
+    const { remaining_days: _d, extensions: _e, ...rest } = WS;
+    expect(remainingLabel(rest)).toBe("89 days 23 hours left");
+    expect(remainingLabel({ id: "x", path: "/x" })).toBe("");
+  });
+});
+
+describe("expiryTone", () => {
+  it("escalates as the deletion date approaches", () => {
+    expect(expiryTone(WS)).toBe("ok");
+    expect(expiryTone({ ...WS, remaining_days: 7 })).toBe("warn");
+    expect(expiryTone({ ...WS, remaining_days: 2 })).toBe("urgent");
+    expect(expiryTone({ ...WS, remaining_days: 0 })).toBe("urgent");
+  });
+
+  it("invents no colour when the site reported no remaining time", () => {
+    expect(expiryTone({ id: "x", path: "/x" })).toBe("none");
+  });
+});
+
+describe("defaultFilesystem", () => {
+  it("is the location the site itself marked default", () => {
+    expect(
+      defaultFilesystem({
+        available: true,
+        filesystems: [
+          { name: "scratch", default: true },
+          { name: "mlnvme", default: false },
+        ],
+      }),
+    ).toBe("scratch");
+    expect(defaultFilesystem({ available: true, filesystems: [] })).toBeUndefined();
+    expect(defaultFilesystem(null)).toBeUndefined();
+  });
+});
+
+describe("the home anchor", () => {
+  it("defaults to eldrun/<safe-name> under the cluster home", () => {
+    expect(defaultAnchorRel("my-experiment")).toBe("eldrun/my-experiment");
+    // Anything the backend's path-segment validation would reject is folded out
+    // here rather than surfacing as a remote error.
+    expect(defaultAnchorRel("my project!")).toBe("eldrun/my-project");
+    expect(defaultAnchorRel("")).toBe("eldrun/project");
+  });
+
+  it("routes job logs into it with SLURM's own job-id token", () => {
+    expect(logOutputPattern("/home/u/eldrun/p/logs")).toBe("/home/u/eldrun/p/logs/slurm-%j.out");
+    expect(logOutputPattern("/home/u/eldrun/p/logs/")).toBe("/home/u/eldrun/p/logs/slurm-%j.out");
+  });
+});
+
+describe("findProjectWorkspace", () => {
+  const list: HpcWorkspace[] = [
+    { id: "other", path: "/lustre/scratch/data/alice-other" },
+    WS,
+  ];
+
+  it("prefers the recorded id — the handle that survives the directory", () => {
+    expect(findProjectWorkspace(list, { workspace_id: "demo" }, undefined)?.id).toBe("demo");
+  });
+
+  it("falls back to the workspace the project's root sits inside", () => {
+    expect(
+      findProjectWorkspace(list, undefined, "/lustre/scratch/data/alice-demo/my-experiment")?.id,
+    ).toBe("demo");
+    // The root IS the workspace (no sub-folder) still counts.
+    expect(findProjectWorkspace(list, undefined, "/lustre/scratch/data/alice-demo")?.id).toBe("demo");
+  });
+
+  it("does not match a workspace that merely shares a path prefix", () => {
+    // `…alice-demo2` starts with `…alice-demo` as a *string*, but is another
+    // workspace — matching it would point Extend at the wrong allocation.
+    expect(
+      findProjectWorkspace(list, undefined, "/lustre/scratch/data/alice-demo2/p"),
+    ).toBeUndefined();
+    expect(findProjectWorkspace(list, undefined, undefined)).toBeUndefined();
+  });
+
+  it("survives a recorded id the host no longer lists (a released workspace)", () => {
+    expect(findProjectWorkspace(list, { workspace_id: "gone" }, undefined)).toBeUndefined();
+  });
+});
+
+describe("shouldWarnExpiry", () => {
+  it("warns inside the last week, never without a reading", () => {
+    expect(shouldWarnExpiry(WS)).toBe(false);
+    expect(shouldWarnExpiry({ ...WS, remaining_days: 7 })).toBe(true);
+    expect(shouldWarnExpiry({ ...WS, remaining_days: 1 })).toBe(true);
+    expect(shouldWarnExpiry({ id: "x", path: "/x" })).toBe(false);
+    expect(shouldWarnExpiry(undefined)).toBe(false);
+  });
+});
+
+describe("freeSpaceLabel", () => {
+  it("scales the probe's KiB into binary units, and says nothing when df did not", () => {
+    expect(freeSpaceLabel(512)).toBe("512 KB free");
+    expect(freeSpaceLabel(1024 * 1024 * 1024 * 2)).toBe("2.0 TB free");
+    expect(freeSpaceLabel(undefined)).toBe("");
+    expect(freeSpaceLabel(NaN)).toBe("");
+  });
+});
+
+describe("targets", () => {
+  it("a host target carries the credential only when there is one", () => {
+    expect(wsTargetForHost({ user: "alice", host: "cluster", port: 22 }, "pw")).toEqual({
+      user: "alice",
+      host: "cluster",
+      port: 22,
+      password: "pw",
+    });
+    // No password ⇒ the field is absent, so the backend falls through to a saved
+    // credential and then to key/agent auth rather than being handed "".
+    expect(wsTargetForHost({ user: null, host: "cluster", port: null }, "")).toEqual({
+      user: undefined,
+      host: "cluster",
+      port: undefined,
+    });
+  });
+
+  it("a project target names the project, and a host only when it isn't the primary", () => {
+    expect(wsTargetForProject("/home/u/.local/share/eldrun/remote-projects/p")).toEqual({
+      projectDir: "/home/u/.local/share/eldrun/remote-projects/p",
+    });
+    expect(wsTargetForProject("/dir", "worker-1")).toEqual({
+      projectDir: "/dir",
+      hostId: "worker-1",
+    });
+  });
+});
diff --git a/src/__tests__/Ics.test.ts b/src/__tests__/Ics.test.ts
new file mode 100644
index 0000000..9f2489a
--- /dev/null
+++ b/src/__tests__/Ics.test.ts
@@ -0,0 +1,477 @@
+import { describe, expect, it } from "vitest";
+import {
+  escapeText,
+  fold,
+  formatIcsDate,
+  formatRrule,
+  formatTrigger,
+  parseIcs,
+  parseIcsDate,
+  parseLine,
+  parseRrule,
+  parseTrigger,
+  serializeIcs,
+  unescapeText,
+  unfold,
+} from "../lib/ics";
+import type { CalendarEvent, CalendarTask } from "../types";
+
+function event(over: Partial<CalendarEvent> = {}): CalendarEvent {
+  return {
+    id: "e1",
+    calendar_id: "default",
+    start: "2026-07-08T09:00",
+    end: "2026-07-08T10:00",
+    all_day: false,
+    title: "standup",
+    ...over,
+  };
+}
+
+const AT = new Date(Date.UTC(2026, 6, 1, 12, 0, 0));
+
+describe("line folding", () => {
+  it("stitches a folded line back together", () => {
+    const text = "SUMMARY:a very long\r\n  continuation\r\nLOCATION:room";
+    expect(unfold(text)).toEqual(["SUMMARY:a very long continuation", "LOCATION:room"]);
+  });
+
+  it("unfolds a tab continuation too", () => {
+    expect(unfold("SUMMARY:one\r\n\ttwo")).toEqual(["SUMMARY:onetwo"]);
+  });
+
+  it("folds a long line at 75 octets", () => {
+    const long = "DESCRIPTION:" + "x".repeat(200);
+    const folded = fold(long);
+    expect(folded).toContain("\r\n ");
+    // Round-trip: folding then unfolding gives the original back.
+    expect(unfold(folded)).toEqual([long]);
+  });
+
+  it("leaves a short line alone", () => {
+    expect(fold("SUMMARY:hi")).toBe("SUMMARY:hi");
+  });
+
+  it("drops blank lines", () => {
+    expect(unfold("A:1\r\n\r\nB:2")).toEqual(["A:1", "B:2"]);
+  });
+});
+
+describe("escaping", () => {
+  it("escapes the special characters", () => {
+    expect(escapeText("a,b;c\\d\ne")).toBe("a\\,b\\;c\\\\d\\ne");
+  });
+
+  it("round-trips", () => {
+    const s = "Meeting, room 2; \\ the \"big\" one\nsecond line";
+    expect(unescapeText(escapeText(s))).toBe(s);
+  });
+
+  it("unescapes \\n and \\N alike", () => {
+    expect(unescapeText("a\\nb")).toBe("a\nb");
+    expect(unescapeText("a\\Nb")).toBe("a\nb");
+  });
+});
+
+describe("parseLine", () => {
+  it("splits name, params and value", () => {
+    expect(parseLine("DTSTART;VALUE=DATE:20260708")).toEqual({
+      name: "DTSTART",
+      params: { VALUE: "DATE" },
+      value: "20260708",
+    });
+  });
+
+  it("does not split on a colon inside a quoted param", () => {
+    const line = parseLine('X-A;CN="a:b":value');
+    expect(line?.params.CN).toBe("a:b");
+    expect(line?.value).toBe("value");
+  });
+
+  it("keeps colons in the value", () => {
+    expect(parseLine("DESCRIPTION:see http://x.test")?.value).toBe("see http://x.test");
+  });
+
+  it("returns null for a line with no colon", () => {
+    expect(parseLine("GARBAGE")).toBeNull();
+  });
+});
+
+describe("dates", () => {
+  it("parses a DATE as all-day", () => {
+    expect(parseIcsDate("20260708")).toEqual({ stamp: "2026-07-08", dateOnly: true });
+  });
+
+  it("parses a floating DATE-TIME", () => {
+    expect(parseIcsDate("20260708T090000")).toEqual({
+      stamp: "2026-07-08T09:00",
+      dateOnly: false,
+    });
+  });
+
+  it("converts a UTC DATE-TIME into local time", () => {
+    // Whatever the runner's zone, the parsed local stamp must denote the same
+    // instant as the UTC input.
+    const parsed = parseIcsDate("20260708T120000Z")!;
+    const asLocal = new Date(
+      Number(parsed.stamp.slice(0, 4)),
+      Number(parsed.stamp.slice(5, 7)) - 1,
+      Number(parsed.stamp.slice(8, 10)),
+      Number(parsed.stamp.slice(11, 13)),
+      Number(parsed.stamp.slice(14, 16)),
+    );
+    expect(asLocal.getTime()).toBe(Date.UTC(2026, 6, 8, 12, 0));
+  });
+
+  it("rejects garbage", () => {
+    expect(parseIcsDate("nope")).toBeNull();
+  });
+
+  it("formats both forms", () => {
+    expect(formatIcsDate("2026-07-08", true)).toBe("20260708");
+    expect(formatIcsDate("2026-07-08T09:05", false)).toBe("20260708T090500");
+  });
+});
+
+describe("RRULE", () => {
+  it("parses the common rules", () => {
+    expect(parseRrule("FREQ=DAILY")).toMatchObject({ freq: "daily", interval: 1 });
+    expect(parseRrule("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,FR")).toMatchObject({
+      freq: "weekly", interval: 2, byweekday: [1, 5],
+    });
+    expect(parseRrule("FREQ=MONTHLY;BYMONTHDAY=15")).toMatchObject({
+      freq: "monthly", bymonthday: 15,
+    });
+    expect(parseRrule("FREQ=DAILY;COUNT=5")).toMatchObject({ count: 5 });
+    expect(parseRrule("FREQ=DAILY;UNTIL=20261231")).toMatchObject({ until: "2026-12-31" });
+  });
+
+  it("strips an ordinal BYDAY prefix down to the weekday", () => {
+    // "2MO" (the 2nd Monday) degrades to plain Monday — the model holds no ordinal.
+    expect(parseRrule("FREQ=MONTHLY;BYDAY=2MO")).toMatchObject({ byweekday: [1] });
+    expect(parseRrule("FREQ=MONTHLY;BYDAY=-1FR")).toMatchObject({ byweekday: [5] });
+  });
+
+  it("drops an unsupported FREQ rather than guessing", () => {
+    expect(parseRrule("FREQ=HOURLY;INTERVAL=2")).toBeNull();
+    expect(parseRrule("INTERVAL=2")).toBeNull();
+  });
+
+  it("formats a rule", () => {
+    expect(formatRrule({ freq: "weekly", interval: 2, byweekday: [1, 5] }))
+      .toBe("FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,FR");
+    expect(formatRrule({ freq: "daily", interval: 1 })).toBe("FREQ=DAILY");
+    expect(formatRrule({ freq: "daily", interval: 1, count: 3 })).toBe("FREQ=DAILY;COUNT=3");
+    expect(formatRrule({ freq: "daily", interval: 1, until: "2026-12-31" }))
+      .toBe("FREQ=DAILY;UNTIL=20261231");
+  });
+
+  it("round-trips", () => {
+    const rule = { freq: "weekly" as const, interval: 3, byweekday: [1, 3], count: 8 };
+    expect(parseRrule(formatRrule(rule))).toMatchObject(rule);
+  });
+});
+
+describe("VALARM triggers", () => {
+  it("parses a negative duration as minutes BEFORE", () => {
+    expect(parseTrigger("-PT15M")).toBe(15);
+    expect(parseTrigger("-PT1H")).toBe(60);
+    expect(parseTrigger("-P1D")).toBe(1440);
+    expect(parseTrigger("-PT1H30M")).toBe(90);
+  });
+
+  it("parses a positive duration as negative minutes-before (i.e. after the start)", () => {
+    expect(parseTrigger("PT15M")).toBe(-15);
+  });
+
+  it("parses a zero trigger", () => {
+    expect(parseTrigger("PT0S")).toBe(0);
+  });
+
+  it("formats", () => {
+    expect(formatTrigger(15)).toBe("-PT15M");
+    expect(formatTrigger(60)).toBe("-PT1H");
+    expect(formatTrigger(1440)).toBe("-P1D");
+    expect(formatTrigger(90)).toBe("-PT1H30M");
+    expect(formatTrigger(0)).toBe("PT0S");
+  });
+
+  it("round-trips", () => {
+    for (const m of [0, 5, 15, 30, 60, 90, 1440]) {
+      expect(parseTrigger(formatTrigger(m))).toBe(m);
+    }
+  });
+});
+
+describe("parseIcs", () => {
+  it("parses a timed VEVENT", () => {
+    const { events } = parseIcs(
+      [
+        "BEGIN:VCALENDAR",
+        "BEGIN:VEVENT",
+        "UID:1",
+        "DTSTART:20260708T090000",
+        "DTEND:20260708T100000",
+        "SUMMARY:standup",
+        "LOCATION:room 2",
+        "DESCRIPTION:daily sync",
+        "STATUS:CONFIRMED",
+        "END:VEVENT",
+        "END:VCALENDAR",
+      ].join("\r\n"),
+    );
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      start: "2026-07-08T09:00",
+      end: "2026-07-08T10:00",
+      all_day: false,
+      title: "standup",
+      location: "room 2",
+      notes: "daily sync",
+      status: "confirmed",
+    });
+  });
+
+  it("parses an all-day VEVENT, keeping the exclusive end", () => {
+    const { events } = parseIcs(
+      [
+        "BEGIN:VEVENT",
+        "DTSTART;VALUE=DATE:20260708",
+        "DTEND;VALUE=DATE:20260709",
+        "SUMMARY:holiday",
+        "END:VEVENT",
+      ].join("\r\n"),
+    );
+    expect(events[0]).toMatchObject({
+      start: "2026-07-08", end: "2026-07-09", all_day: true,
+    });
+  });
+
+  it("defaults a missing DTEND", () => {
+    const timed = parseIcs("BEGIN:VEVENT\r\nDTSTART:20260708T090000\r\nSUMMARY:x\r\nEND:VEVENT");
+    expect(timed.events[0].end).toBe("2026-07-08T10:00"); // +1h
+
+    const allDay = parseIcs("BEGIN:VEVENT\r\nDTSTART;VALUE=DATE:20260708\r\nSUMMARY:x\r\nEND:VEVENT");
+    expect(allDay.events[0].end).toBe("2026-07-09"); // +1 day
+  });
+
+  it("parses RRULE, EXDATE and VALARM", () => {
+    const { events } = parseIcs(
+      [
+        "BEGIN:VEVENT",
+        "DTSTART:20260708T090000",
+        "DTEND:20260708T093000",
+        "SUMMARY:standup",
+        "RRULE:FREQ=DAILY;COUNT=10",
+        "EXDATE:20260710T090000",
+        "BEGIN:VALARM",
+        "ACTION:DISPLAY",
+        "TRIGGER:-PT15M",
+        "END:VALARM",
+        "END:VEVENT",
+      ].join("\r\n"),
+    );
+    expect(events[0].rrule).toMatchObject({ freq: "daily", count: 10 });
+    expect(events[0].exdates).toEqual(["2026-07-10T09:00"]);
+    expect(events[0].alarms).toEqual([{ minutes_before: 15 }]);
+  });
+
+  it("parses several EXDATEs on one line", () => {
+    const { events } = parseIcs(
+      [
+        "BEGIN:VEVENT",
+        "DTSTART:20260708T090000",
+        "SUMMARY:x",
+        "EXDATE:20260710T090000,20260711T090000",
+        "END:VEVENT",
+      ].join("\r\n"),
+    );
+    expect(events[0].exdates).toEqual(["2026-07-10T09:00", "2026-07-11T09:00"]);
+  });
+
+  it("parses a VTODO", () => {
+    const { tasks } = parseIcs(
+      [
+        "BEGIN:VTODO",
+        "SUMMARY:write the plan",
+        "DUE;VALUE=DATE:20260710",
+        "PRIORITY:1",
+        "PERCENT-COMPLETE:50",
+        "END:VTODO",
+      ].join("\r\n"),
+    );
+    expect(tasks[0]).toMatchObject({
+      title: "write the plan", due: "2026-07-10", priority: 1, percent: 50,
+    });
+  });
+
+  it("treats a COMPLETED VTODO as done", () => {
+    const { tasks } = parseIcs(
+      [
+        "BEGIN:VTODO",
+        "SUMMARY:done thing",
+        "STATUS:COMPLETED",
+        "COMPLETED:20260709T120000",
+        "END:VTODO",
+      ].join("\r\n"),
+    );
+    expect(tasks[0].percent).toBe(100);
+    expect(tasks[0].completed).toBe("2026-07-09T12:00");
+  });
+
+  it("skips unsupported components instead of importing junk", () => {
+    const { events, tasks, skipped } = parseIcs(
+      [
+        "BEGIN:VCALENDAR",
+        "BEGIN:VTIMEZONE",
+        "TZID:Europe/Berlin",
+        "END:VTIMEZONE",
+        "BEGIN:VEVENT",
+        "DTSTART:20260708T090000",
+        "SUMMARY:real",
+        "END:VEVENT",
+        "END:VCALENDAR",
+      ].join("\r\n"),
+    );
+    expect(events).toHaveLength(1);
+    expect(tasks).toHaveLength(0);
+    expect(skipped).toBe(0);
+  });
+
+  it("counts a VEVENT with no DTSTART as skipped", () => {
+    const { events, skipped } = parseIcs("BEGIN:VEVENT\r\nSUMMARY:no start\r\nEND:VEVENT");
+    expect(events).toHaveLength(0);
+    expect(skipped).toBe(1);
+  });
+
+  it("handles CRLF, LF and folded input alike", () => {
+    const lf = parseIcs("BEGIN:VEVENT\nDTSTART:20260708T090000\nSUMMARY:x\nEND:VEVENT");
+    expect(lf.events).toHaveLength(1);
+  });
+
+  it("unescapes text values", () => {
+    const { events } = parseIcs(
+      "BEGIN:VEVENT\r\nDTSTART:20260708T090000\r\nSUMMARY:Lunch\\, then talk\r\nEND:VEVENT",
+    );
+    expect(events[0].title).toBe("Lunch, then talk");
+  });
+
+  it("parses multiple events", () => {
+    const { events } = parseIcs(
+      [
+        "BEGIN:VEVENT", "DTSTART:20260708T090000", "SUMMARY:a", "END:VEVENT",
+        "BEGIN:VEVENT", "DTSTART:20260709T090000", "SUMMARY:b", "END:VEVENT",
+      ].join("\r\n"),
+    );
+    expect(events.map((e) => e.title)).toEqual(["a", "b"]);
+  });
+});
+
+describe("serializeIcs", () => {
+  it("writes a well-formed calendar", () => {
+    const out = serializeIcs([event()], [], AT);
+    expect(out).toContain("BEGIN:VCALENDAR");
+    expect(out).toContain("VERSION:2.0");
+    expect(out).toContain("BEGIN:VEVENT");
+    expect(out).toContain("DTSTART:20260708T090000");
+    expect(out).toContain("DTEND:20260708T100000");
+    expect(out).toContain("SUMMARY:standup");
+    expect(out).toContain("END:VCALENDAR");
+    expect(out.endsWith("\r\n")).toBe(true);
+  });
+
+  it("marks an all-day event with VALUE=DATE", () => {
+    const out = serializeIcs(
+      [event({ start: "2026-07-08", end: "2026-07-09", all_day: true })], [], AT,
+    );
+    expect(out).toContain("DTSTART;VALUE=DATE:20260708");
+    expect(out).toContain("DTEND;VALUE=DATE:20260709");
+  });
+
+  it("writes alarms as VALARM blocks", () => {
+    const out = serializeIcs([event({ alarms: [{ minutes_before: 15 }] })], [], AT);
+    expect(out).toContain("BEGIN:VALARM");
+    expect(out).toContain("TRIGGER:-PT15M");
+    expect(out).toContain("ACTION:DISPLAY");
+  });
+
+  it("escapes text on the way out", () => {
+    const out = serializeIcs([event({ title: "Lunch, then talk" })], [], AT);
+    expect(out).toContain("SUMMARY:Lunch\\, then talk");
+  });
+
+  it("writes a VTODO", () => {
+    const task: CalendarTask = {
+      id: "t1", calendar_id: "default", title: "write plan",
+      due: "2026-07-10", priority: 1, percent: 100, completed: "2026-07-09T12:00",
+    };
+    const out = serializeIcs([], [task], AT);
+    expect(out).toContain("BEGIN:VTODO");
+    expect(out).toContain("SUMMARY:write plan");
+    expect(out).toContain("DUE:20260710");
+    expect(out).toContain("PRIORITY:1");
+    expect(out).toContain("STATUS:COMPLETED");
+  });
+});
+
+describe("round-trip", () => {
+  it("survives a full event unchanged", () => {
+    const original = event({
+      start: "2026-07-08T09:00",
+      end: "2026-07-08T09:30",
+      title: "Lunch, then talk",
+      location: "room 2; upstairs",
+      notes: "line one\nline two",
+      category: "work",
+      status: "tentative",
+      rrule: { freq: "weekly", interval: 2, byweekday: [1, 5], count: 6 },
+      exdates: ["2026-07-20T09:00"],
+      alarms: [{ minutes_before: 15 }, { minutes_before: 1440 }],
+    });
+
+    const { events } = parseIcs(serializeIcs([original], [], AT));
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      start: original.start,
+      end: original.end,
+      all_day: false,
+      title: original.title,
+      location: original.location,
+      notes: original.notes,
+      category: original.category,
+      status: original.status,
+      exdates: original.exdates,
+      alarms: original.alarms,
+    });
+    expect(events[0].rrule).toMatchObject(original.rrule!);
+  });
+
+  it("survives an all-day multi-day event", () => {
+    const original = event({
+      start: "2026-07-08", end: "2026-07-11", all_day: true, title: "conference",
+    });
+    const { events } = parseIcs(serializeIcs([original], [], AT));
+    expect(events[0]).toMatchObject({
+      start: "2026-07-08", end: "2026-07-11", all_day: true, title: "conference",
+    });
+  });
+
+  it("survives a long line that has to be folded", () => {
+    const original = event({ notes: "x".repeat(300) });
+    const { events } = parseIcs(serializeIcs([original], [], AT));
+    expect(events[0].notes).toBe("x".repeat(300));
+  });
+
+  it("survives a task", () => {
+    const task: CalendarTask = {
+      id: "t1", calendar_id: "default", title: "write plan", notes: "the whole thing",
+      due: "2026-07-10", start: null, priority: 1, percent: 50, completed: null,
+      category: "work", alarms: [{ minutes_before: 60 }],
+    };
+    const { tasks } = parseIcs(serializeIcs([], [task], AT));
+    expect(tasks[0]).toMatchObject({
+      title: "write plan", notes: "the whole thing", due: "2026-07-10",
+      priority: 1, percent: 50, category: "work", alarms: [{ minutes_before: 60 }],
+    });
+  });
+});
diff --git a/src/__tests__/ImageAutoReload.test.tsx b/src/__tests__/ImageAutoReload.test.tsx
index 15a3ca4..6352267 100644
--- a/src/__tests__/ImageAutoReload.test.tsx
+++ b/src/__tests__/ImageAutoReload.test.tsx
@@ -55,7 +55,7 @@ describe("image auto-reload (#68)", () => {
 
     // External change: a newer mtime should trigger exactly one more read.
     diskMtime = 2000;
-    await waitFor(() => expect(countReadBytes()).toBe(2), { timeout: 4000 });
+    await waitFor(() => expect(countReadBytes()).toBe(2), { timeout: 12000 });
 
     // A second poll with no further change must not re-read again.
     await new Promise((r) => setTimeout(r, 1800));
diff --git a/src/__tests__/InstallCommand.test.ts b/src/__tests__/InstallCommand.test.ts
new file mode 100644
index 0000000..13aab12
--- /dev/null
+++ b/src/__tests__/InstallCommand.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { installShellCommand } from "../lib/installCommand";
+
+describe("installShellCommand", () => {
+  it("selects Bash explicitly for Bash installers", () => {
+    expect(installShellCommand("bash")).toBe("/bin/bash");
+  });
+
+  it("selects PowerShell explicitly for PowerShell installers", () => {
+    expect(installShellCommand("powershell")).toBe("powershell.exe");
+  });
+
+  it("leaves shell-neutral commands on the default shell", () => {
+    expect(installShellCommand("default")).toBe("");
+  });
+});
diff --git a/src/__tests__/InternalViewer.test.ts b/src/__tests__/InternalViewer.test.ts
index c80bacd..10b3f08 100644
--- a/src/__tests__/InternalViewer.test.ts
+++ b/src/__tests__/InternalViewer.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import {
   internalViewerFor,
+  disabledViewers,
   isDeferredOfficeFile,
   type FileEntry,
 } from "../lib/viewers/fileUtils";
@@ -21,8 +22,23 @@ describe("internalViewerFor", () => {
 
   it("maps common text/code extensions to the text viewer", () => {
     expect(internalViewerFor(file("main.rs", ".rs"))).toBe("text");
-    expect(internalViewerFor(file("data.json", ".json"))).toBe("text");
     expect(internalViewerFor(file("notes.txt", ".txt"))).toBe("text");
+    expect(internalViewerFor(file("Cargo.toml", ".toml"))).toBe("text");
+  });
+
+  it("maps YAML and JSON to the structure tree (#yaml)", () => {
+    // JSON is YAML's flow syntax, so both open in the same tree — with Source as
+    // the same code editor they used to open in.
+    expect(internalViewerFor(file("config.yaml", ".yaml"))).toBe("yaml");
+    expect(internalViewerFor(file("config.yml", ".yml"))).toBe("yaml");
+    expect(internalViewerFor(file("data.json", ".json"))).toBe("yaml");
+  });
+
+  it("falls back to the plain editor when the tree is opted out (#48)", () => {
+    // Turning off the tree is a vote against the tree, not against editing YAML
+    // in Eldrun — so it drops back to the code editor, not to an external app.
+    expect(internalViewerFor(file("data.json", ".json"), new Set(["yaml"] as const))).toBe("text");
+    expect(internalViewerFor(file("c.yaml", ".yaml"), new Set(["yaml", "text"] as const))).toBeNull();
   });
 
   it("maps well-known extensionless filenames to the text viewer", () => {
@@ -34,11 +50,45 @@ describe("internalViewerFor", () => {
     expect(internalViewerFor(file("photo.png", ".png"))).toBe("image");
     expect(internalViewerFor(file("photo.jpg", ".jpg"))).toBe("image");
     expect(internalViewerFor(file("photo.jpeg", ".jpeg"))).toBe("image");
-    expect(internalViewerFor(file("anim.gif", ".gif"))).toBe("image");
   });
 
-  it("keeps SVG as text (editable XML), not image", () => {
-    expect(internalViewerFor(file("icon.svg", ".svg"))).toBe("text");
+  it("maps .gif to the animated-GIF viewer (wins over the generic image viewer)", () => {
+    expect(internalViewerFor(file("anim.gif", ".gif"))).toBe("gif");
+    // Opting the transport out (#48) degrades to the image viewer — the webview
+    // still animates <img> GIFs natively, it just loses frame control.
+    expect(internalViewerFor(file("anim.gif", ".gif"), new Set(["gif"] as const))).toBe("image");
+    expect(
+      internalViewerFor(file("anim.gif", ".gif"), new Set(["gif", "image"] as const)),
+    ).toBeNull();
+    const disabled = disabledViewers({ gif: { enabled: false } });
+    expect(disabled.has("gif")).toBe(true);
+    expect(internalViewerFor(file("anim.gif", ".gif"), disabled)).toBe("image");
+  });
+
+  it("maps .html/.htm/.svg to the rendered-preview viewer (wins over text)", () => {
+    expect(internalViewerFor(file("page.html", ".html"))).toBe("html");
+    expect(internalViewerFor(file("page.htm", ".htm"))).toBe("html");
+    expect(internalViewerFor(file("icon.svg", ".svg"))).toBe("html");
+    // Opting the viewer out (#48) falls through (SVG XML stays openable
+    // externally rather than as the in-app preview).
+    expect(internalViewerFor(file("icon.svg", ".svg"), new Set(["html"]))).toBeNull();
+  });
+
+  it("maps audio/video to the media player", () => {
+    expect(internalViewerFor(file("song.mp3", ".mp3"))).toBe("media");
+    expect(internalViewerFor(file("clip.mp4", ".mp4"))).toBe("media");
+    expect(internalViewerFor(file("clip.webm", ".webm"))).toBe("media");
+  });
+
+  it("maps SQLite databases to the sqlite browser", () => {
+    expect(internalViewerFor(file("app.db", ".db"))).toBe("sqlite");
+    expect(internalViewerFor(file("app.sqlite", ".sqlite"))).toBe("sqlite");
+    expect(internalViewerFor(file("app.sqlite3", ".sqlite3"))).toBe("sqlite");
+  });
+
+  it("maps spreadsheets to the table viewer (no longer deferred)", () => {
+    expect(internalViewerFor(file("book.xlsx", ".xlsx"))).toBe("table");
+    expect(internalViewerFor(file("book.xls", ".xls"))).toBe("table");
   });
 
   it("maps .tex to the dedicated LaTeX viewer, but .bib stays text", () => {
@@ -46,21 +96,85 @@ describe("internalViewerFor", () => {
     expect(internalViewerFor(file("refs.bib", ".bib"))).toBe("text");
   });
 
+  it("maps .csv/.tsv to the table viewer (wins over generic text)", () => {
+    expect(internalViewerFor(file("data.csv", ".csv"))).toBe("table");
+    expect(internalViewerFor(file("data.tsv", ".tsv"))).toBe("table");
+  });
+
+  it("maps .ipynb to the notebook viewer", () => {
+    expect(internalViewerFor(file("nb.ipynb", ".ipynb"))).toBe("notebook");
+  });
+
+  it("maps .diff/.patch to the diff viewer (wins over generic text)", () => {
+    expect(internalViewerFor(file("change.diff", ".diff"))).toBe("diff");
+    expect(internalViewerFor(file("change.patch", ".patch"))).toBe("diff");
+  });
+
   it("returns null for non-viewable binaries and directories", () => {
     expect(internalViewerFor(file("app.bin", ".bin"))).toBeNull();
     expect(internalViewerFor(file("lib.so", ".so"))).toBeNull();
     expect(internalViewerFor({ ...file("src", null), is_dir: true })).toBeNull();
   });
 
-  it("DEFERRED (#51): .odt/.xlsx have no native viewer (open externally)", () => {
-    // DECISION B: office/spreadsheet rendering is deferred; these resolve to null
-    // so they fall through to the external-app path.
-    expect(internalViewerFor(file("report.odt", ".odt"))).toBeNull();
-    expect(internalViewerFor(file("data.xlsx", ".xlsx"))).toBeNull();
+  it("maps .odt to the OpenDocument Text viewer (#51 lightweight)", () => {
+    expect(internalViewerFor(file("report.odt", ".odt"))).toBe("odt");
+    // Opting the viewer out (#48) falls through to the external-app path.
+    expect(internalViewerFor(file("report.odt", ".odt"), new Set(["odt"]))).toBeNull();
+  });
+
+  it("DEFERRED (#51): remaining word-processing/presentation formats open externally", () => {
+    // DECISION B: .docx/.pptx/.ods/.odp rendering is still deferred; these resolve
+    // to null so they fall through to the external-app path.
+    expect(internalViewerFor(file("doc.docx", ".docx"))).toBeNull();
     expect(internalViewerFor(file("slides.pptx", ".pptx"))).toBeNull();
+    expect(internalViewerFor(file("sheet.ods", ".ods"))).toBeNull();
     // …and they are recognised as deferred office files, not generic binaries.
-    expect(isDeferredOfficeFile(file("report.odt", ".odt"))).toBe(true);
-    expect(isDeferredOfficeFile(file("data.xlsx", ".xlsx"))).toBe(true);
+    expect(isDeferredOfficeFile(file("doc.docx", ".docx"))).toBe(true);
+    expect(isDeferredOfficeFile(file("sheet.ods", ".ods"))).toBe(true);
     expect(isDeferredOfficeFile(file("main.rs", ".rs"))).toBe(false);
   });
 });
+
+describe("internalViewerFor opt-out (#48)", () => {
+  it("returns null for a type the user disabled so it opens externally", () => {
+    const disabled = new Set(["pdf" as const]);
+    expect(internalViewerFor(file("doc.pdf", ".pdf"), disabled)).toBeNull();
+    // other types are unaffected by a pdf-only opt-out
+    expect(internalViewerFor(file("main.rs", ".rs"), disabled)).toBe("text");
+  });
+
+  it("renders normally when the disabled set is empty or omitted", () => {
+    expect(internalViewerFor(file("doc.pdf", ".pdf"), new Set())).toBe("pdf");
+    expect(internalViewerFor(file("doc.pdf", ".pdf"))).toBe("pdf");
+  });
+});
+
+describe("disabledViewers (#48)", () => {
+  it("treats absent/true prefs as enabled and false as disabled", () => {
+    expect(disabledViewers(undefined).size).toBe(0);
+    expect(disabledViewers({}).size).toBe(0);
+    expect(disabledViewers({ pdf: {} }).size).toBe(0);
+    expect(disabledViewers({ pdf: { enabled: true } }).size).toBe(0);
+    const off = disabledViewers({ pdf: { enabled: false }, tex: { enabled: false } });
+    expect(off.has("pdf")).toBe(true);
+    expect(off.has("tex")).toBe(true);
+    expect(off.has("text")).toBe(false);
+  });
+
+  it("supports opting out the new table/notebook/diff viewers", () => {
+    // A disabled type returns null so the file opens externally instead.
+    const disabled = disabledViewers({
+      table: { enabled: false },
+      notebook: { enabled: false },
+      diff: { enabled: false },
+    });
+    expect(disabled.has("table")).toBe(true);
+    expect(disabled.has("notebook")).toBe(true);
+    expect(disabled.has("diff")).toBe(true);
+    expect(internalViewerFor(file("data.csv", ".csv"), disabled)).toBeNull();
+    // .ipynb is not in TEXT_EXTS, so opting the notebook viewer out opens it
+    // externally rather than falling back to raw text.
+    expect(internalViewerFor(file("nb.ipynb", ".ipynb"), disabled)).toBeNull();
+    expect(internalViewerFor(file("change.diff", ".diff"), disabled)).toBeNull();
+  });
+});
diff --git a/src/__tests__/KeyboardNav.test.tsx b/src/__tests__/KeyboardNav.test.tsx
index 15b2285..420ff74 100644
--- a/src/__tests__/KeyboardNav.test.tsx
+++ b/src/__tests__/KeyboardNav.test.tsx
@@ -4,7 +4,8 @@
  * Mounts the real useKeyboard hook and dispatches real keydown events on
  * `window`, asserting each chord drives the right store action:
  *   - Shift+Tab cycles tabs within the focused subwindow (wraps);
- *   - Shift+Arrow focuses the neighbouring subwindow;
+ *   - Shift+Left/Right cycle the active tab within the focused subwindow;
+ *   - Shift+Up/Down preview a subwindow; focus commits on Shift release;
  *   - Ctrl+Enter toggles fullscreen, Escape exits it;
  *   - Ctrl+W closes the active tab; Shift+Ctrl+W closes the subwindow;
  *   - Shift+Ctrl+Tab cycles to the next active project;
@@ -25,6 +26,7 @@ import { useKeyboard } from "../hooks/useKeyboard";
 import { allGroups, useTabsStore } from "../stores/tabs";
 import { useProjectsStore } from "../stores/projects";
 import { useSettingsStore } from "../stores/settings";
+import { useSubwindowNavStore } from "../stores/subwindowNav";
 
 function Harness() {
   useKeyboard({ onTogglePanels: () => {} });
@@ -51,9 +53,16 @@ function key(init: Partial<KeyboardEventInit> & { key: string }) {
   });
 }
 
+function keyUp(init: Partial<KeyboardEventInit> & { key: string }) {
+  act(() => {
+    window.dispatchEvent(new KeyboardEvent("keyup", { bubbles: true, ...init }));
+  });
+}
+
 describe("#62 keyboard nav wiring", () => {
   beforeEach(() => {
     resetTabs();
+    useSubwindowNavStore.getState().end();
     useSettingsStore.setState({ settings: null });
     cleanup();
   });
@@ -76,7 +85,25 @@ describe("#62 keyboard nav wiring", () => {
     expect(useTabsStore.getState().activeKey).toBe(group.tabKeys[1]);
   });
 
-  it("Shift+ArrowRight focuses the neighbouring subwindow", () => {
+  it("Shift+Left/Right cycle the active tab within the focused subwindow", () => {
+    const store = useTabsStore.getState();
+    store.addTab({ label: "t1", cmd: "bash", cwd: "/p", kind: "shell" });
+    store.addTab({ label: "t2", cmd: "bash", cwd: "/p", kind: "shell" });
+    store.addTab({ label: "t3", cmd: "bash", cwd: "/p", kind: "shell" });
+    const group = allGroups(useTabsStore.getState().layout)[0];
+    useTabsStore.getState().focusGroup(group.id);
+    render(<Harness />);
+
+    // Active is t3 (index 2). Right → next, wraps to index 0.
+    expect(useTabsStore.getState().activeKey).toBe(group.tabKeys[2]);
+    key({ key: "ArrowRight", shiftKey: true });
+    expect(useTabsStore.getState().activeKey).toBe(group.tabKeys[0]);
+    // Left → previous, wraps back to index 2.
+    key({ key: "ArrowLeft", shiftKey: true });
+    expect(useTabsStore.getState().activeKey).toBe(group.tabKeys[2]);
+  });
+
+  it("Shift+Down previews a subwindow and commits focus on Shift release", () => {
     const store = useTabsStore.getState();
     store.addTab({ label: "a", cmd: "bash", cwd: "/p", kind: "shell" });
     const b = store.addTab({ label: "b", cmd: "bash", cwd: "/p", kind: "shell" });
@@ -88,8 +115,16 @@ describe("#62 keyboard nav wiring", () => {
     useTabsStore.getState().focusGroup(aGroup.id);
     render(<Harness />);
 
-    key({ key: "ArrowRight", shiftKey: true });
+    // Shift+Down enters nav preview on the next subwindow, WITHOUT moving focus.
+    key({ key: "ArrowDown", shiftKey: true });
+    expect(useSubwindowNavStore.getState().active).toBe(true);
+    expect(useSubwindowNavStore.getState().previewGroupId).toBe(bGroup.id);
+    expect(useTabsStore.getState().focusedGroupId).toBe(aGroup.id);
+
+    // Releasing Shift commits focus to the previewed subwindow and clears nav.
+    keyUp({ key: "Shift", shiftKey: false });
     expect(useTabsStore.getState().focusedGroupId).toBe(bGroup.id);
+    expect(useSubwindowNavStore.getState().active).toBe(false);
   });
 
   it("Ctrl+Enter toggles fullscreen and Escape exits it", () => {
diff --git a/src/__tests__/Lessons.test.ts b/src/__tests__/Lessons.test.ts
new file mode 100644
index 0000000..1e9a434
--- /dev/null
+++ b/src/__tests__/Lessons.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { LESSON_CATEGORIES, LESSONS } from "../lib/lessons";
+
+const PLACEMENTS = new Set(["top", "bottom", "left", "right"]);
+
+describe("LESSONS catalog", () => {
+  it("covers the requested lessons with unique ids, ordered easy → hard", () => {
+    const ids = LESSONS.map((l) => l.id);
+    expect(new Set(ids).size).toBe(ids.length);
+    expect(ids).toEqual([
+      // Basics
+      "add-project",
+      "import-project",
+      "add-tab",
+      "native-viewer",
+      "arrange-tabs",
+      "yaml-viewer",
+      "pdf-viewer",
+      "run-python",
+      "file-search",
+      "calendar",
+      "usage-recap",
+      // Agents & models
+      "install-agent",
+      "local-model",
+      "add-local-model",
+      // Advanced
+      "project-boxes",
+      "docker-sandbox",
+      "add-ssh-project",
+      "ssh-via-openvpn",
+      "vpn-tunnel",
+      "extend-to-remote",
+      "compute-machines",
+      "persistent-sessions",
+      "hpc-pipeline",
+    ]);
+  });
+
+  it("uses known categories that stay contiguous in tier order", () => {
+    // Every lesson's category is one of the declared tiers.
+    for (const lesson of LESSONS) {
+      expect(LESSON_CATEGORIES).toContain(lesson.category);
+    }
+    // Lessons are grouped: each category appears as a single contiguous run,
+    // and the runs follow LESSON_CATEGORIES' easy → hard order.
+    const seenOrder = LESSONS.map((l) => l.category).filter(
+      (cat, i, arr) => i === 0 || arr[i - 1] !== cat,
+    );
+    expect(seenOrder).toEqual([...LESSON_CATEGORIES]);
+  });
+
+  it("gives every lesson a title, blurb, and at least three steps", () => {
+    for (const lesson of LESSONS) {
+      expect(lesson.title.length).toBeGreaterThan(0);
+      expect(lesson.blurb.length).toBeGreaterThan(0);
+      expect(lesson.steps.length).toBeGreaterThanOrEqual(3);
+    }
+  });
+
+  it("gives every step a unique id (within its lesson), valid placement, and copy", () => {
+    for (const lesson of LESSONS) {
+      const stepIds = lesson.steps.map((s) => s.id);
+      expect(new Set(stepIds).size).toBe(stepIds.length);
+      for (const step of lesson.steps) {
+        expect(PLACEMENTS.has(step.placement)).toBe(true);
+        expect(step.title.length).toBeGreaterThan(0);
+        expect(step.body.length).toBeGreaterThan(0);
+        // anchor is either null (centered card) or a non-empty selector.
+        expect(step.anchor === null || step.anchor.length > 0).toBe(true);
+      }
+    }
+  });
+});
diff --git a/src/__tests__/LineDiff.test.ts b/src/__tests__/LineDiff.test.ts
new file mode 100644
index 0000000..e12cb43
--- /dev/null
+++ b/src/__tests__/LineDiff.test.ts
@@ -0,0 +1,118 @@
+/**
+ * Unit tests for the pure line-diff/merge logic behind the three-column compare
+ * view: `diffLines` alignment, `groupChanges` blocking, `buildMerged` assembly,
+ * and the context-anchored `locateBlock`/`applyBlockToggle` splice used to edit a
+ * hand-edited merge buffer. Mirrors the `diff.ts` test style.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  diffLines,
+  groupChanges,
+  buildMerged,
+  locateBlock,
+  applyBlockToggle,
+  canToggle,
+  type Decision,
+} from "../lib/viewers/linediff";
+
+describe("diffLines", () => {
+  it("marks identical text as all-same", () => {
+    const rows = diffLines("a\nb\nc", "a\nb\nc");
+    expect(rows.every((r) => r.kind === "same")).toBe(true);
+    expect(rows.map((r) => r.right)).toEqual(["a", "b", "c"]);
+  });
+
+  it("pairs a replaced line as a change row", () => {
+    const rows = diffLines("a\nb\nc", "a\nB\nc");
+    expect(rows.map((r) => r.kind)).toEqual(["same", "change", "same"]);
+    expect(rows[1]).toEqual({ left: "b", right: "B", kind: "change" });
+  });
+
+  it("represents a pure insertion as an add row", () => {
+    const rows = diffLines("a\nc", "a\nb\nc");
+    const add = rows.find((r) => r.kind === "add");
+    expect(add).toEqual({ left: null, right: "b", kind: "add" });
+  });
+
+  it("represents a pure deletion as a del row", () => {
+    const rows = diffLines("a\nb\nc", "a\nc");
+    const del = rows.find((r) => r.kind === "del");
+    expect(del).toEqual({ left: "b", right: null, kind: "del" });
+  });
+});
+
+describe("groupChanges", () => {
+  it("collapses consecutive non-same rows into one block with context", () => {
+    const rows = diffLines("a\nb\nc\nd", "a\nX\nY\nd");
+    const blocks = groupChanges(rows);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].oldLines).toEqual(["b", "c"]);
+    expect(blocks[0].newLines).toEqual(["X", "Y"]);
+    expect(blocks[0].contextBefore).toEqual(["a"]);
+    expect(blocks[0].contextAfter).toEqual(["d"]);
+  });
+
+  it("separates changes divided by unchanged lines into distinct blocks", () => {
+    const rows = diffLines("a\nb\nc\nd\ne", "A\nb\nc\nd\nE");
+    const blocks = groupChanges(rows);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].id).toBe(0);
+    expect(blocks[1].id).toBe(1);
+  });
+});
+
+describe("buildMerged", () => {
+  const oldText = "a\nb\nc\nd";
+  const newText = "a\nX\nY\nd";
+  const rows = diffLines(oldText, newText);
+  const blocks = groupChanges(rows);
+
+  it("all-accepted reproduces the new text", () => {
+    expect(buildMerged(rows, blocks, {})).toBe(newText);
+  });
+
+  it("all-rejected reproduces the old text", () => {
+    const decisions: Record<number, Decision> = { 0: "reject" };
+    expect(buildMerged(rows, blocks, decisions)).toBe(oldText);
+  });
+});
+
+describe("locateBlock / applyBlockToggle", () => {
+  const oldText = "top\na\nb\nc\np\nq\nr\ns\nbottom";
+  const newText = "top\na\nX\nc\np\nq\nr\ns\nbottom";
+  const rows = diffLines(oldText, newText);
+  const blocks = groupChanges(rows);
+  const block = blocks[0];
+
+  it("locates the accepted side in the merge buffer", () => {
+    const loc = locateBlock(newText.split("\n"), block, "accept");
+    expect(loc).not.toBeNull();
+    // the "X" line sits at index 2 in the new text
+    expect(loc).toEqual({ start: 2, len: 1 });
+  });
+
+  it("toggles accept → reject by splicing old lines back in", () => {
+    const res = applyBlockToggle(newText, block, "accept");
+    expect(res).not.toBeNull();
+    expect(res!.decision).toBe("reject");
+    expect(res!.text).toBe(oldText);
+  });
+
+  it("preserves an unrelated manual edit while toggling", () => {
+    const edited = newText.replace("bottom", "bottom-edited");
+    const res = applyBlockToggle(edited, block, "accept");
+    expect(res).not.toBeNull();
+    expect(res!.text).toBe(oldText.replace("bottom", "bottom-edited"));
+  });
+
+  it("disables the toggle when the changed line is ambiguous with no context", () => {
+    // A one-line change with no surrounding context (`a` → `X`), then a merge
+    // buffer where "X" appears twice — the block can't be located uniquely.
+    const b = groupChanges(diffLines("a", "X"))[0];
+    expect(b.contextBefore).toEqual([]);
+    expect(b.newLines).toEqual(["X"]);
+    const ambiguous = "X\nfoo\nX";
+    expect(canToggle(ambiguous, b, "accept")).toBe(false);
+    expect(applyBlockToggle(ambiguous, b, "accept")).toBeNull();
+  });
+});
diff --git a/src/__tests__/LocalLossDialog.test.tsx b/src/__tests__/LocalLossDialog.test.tsx
new file mode 100644
index 0000000..8d2f8bd
--- /dev/null
+++ b/src/__tests__/LocalLossDialog.test.tsx
@@ -0,0 +1,134 @@
+/**
+ * Tests for the local-loss warning (#28q): the dialog that says a file on the LOCAL side
+ * was deleted or overwritten by git lockstep or by sync.
+ *
+ * The behaviours worth pinning are the ones that decide whether the warning can be
+ * trusted at all:
+ * - it raises unacknowledged losses for the active project, naming the files;
+ * - an unrecoverable loss says so, rather than leaving the recovery line blank (a blank
+ *   line reads as "git has a copy", which is exactly the wrong thing to assume);
+ * - "Got it" acknowledges through the backend, so a dismissal survives a relaunch;
+ * - an acknowledged log never re-raises;
+ * - a log belonging to a project the user has since switched away from is never shown
+ *   over the project now on screen.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("@tauri-apps/api/event", () => ({
+  listen: vi.fn().mockResolvedValue(() => {}),
+}));
+
+import { LocalLossDialog } from "../components/common/LocalLossDialog";
+import { useLocalLossStore } from "../stores/localLoss";
+import { useProjectsStore } from "../stores/projects";
+
+const DELETED = {
+  ts: 1_752_000_000,
+  source: "git",
+  kind: "deleted",
+  op: "checkout 'main' (following the host)",
+  paths: ["src/gone.rs", "docs/notes.md"],
+  total: 2,
+  recovery: "Still in git — restore a file with:  git -C /mirror checkout abc123 -- <path>",
+  acked: false,
+};
+const OVERWRITTEN = {
+  ts: 1_752_000_050,
+  source: "sync",
+  kind: "overwritten",
+  op: "Sync now (re-pulled every selected file)",
+  paths: ["notes/draft.txt"],
+  total: 1,
+  recovery: null, // byte-sync overwrote edits that existed nowhere else
+  acked: false,
+};
+
+/** Mock the backend log per project — losses belong to one project, never to "any". */
+function setLogs(byProject: Record<string, unknown[]>) {
+  mockInvoke.mockImplementation((cmd: string, args?: { projectId?: string }) => {
+    if (cmd === "local_loss_list") {
+      return Promise.resolve(byProject[args?.projectId ?? ""] ?? []);
+    }
+    return Promise.resolve(null);
+  });
+}
+
+const setLog = (entries: unknown[]) => setLogs({ proj1: entries });
+
+async function renderFor(projectId: string | null) {
+  useProjectsStore.setState({ activeId: projectId ?? undefined } as never);
+  useLocalLossStore.setState({ entries: [], projectId: null });
+  await act(async () => {
+    render(<LocalLossDialog />);
+  });
+}
+
+describe("#28q local-loss warning", () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it("raises a deletion, naming the files and how to get them back", async () => {
+    setLog([DELETED]);
+    await renderFor("proj1");
+
+    expect(mockInvoke).toHaveBeenCalledWith("local_loss_list", { projectId: "proj1" });
+    expect(screen.getByText(/2 files deleted locally/i)).toBeTruthy();
+    expect(screen.getByText("src/gone.rs")).toBeTruthy();
+    expect(screen.getByText("docs/notes.md")).toBeTruthy();
+    expect(screen.getByText(/git -C \/mirror checkout abc123/)).toBeTruthy();
+  });
+
+  it("says outright when the content cannot be recovered", async () => {
+    // The sync case: a pull wrote the host's bytes over local edits that were never
+    // pushed or committed anywhere. There is no backup ref, no reflog, nothing — and the
+    // dialog must say that rather than show an empty recovery line.
+    setLog([OVERWRITTEN]);
+    await renderFor("proj1");
+
+    expect(screen.getByText(/1 file overwritten locally/i)).toBeTruthy();
+    expect(screen.getByText(/cannot be recovered/i)).toBeTruthy();
+  });
+
+  it("acknowledges through the backend, so a dismissal survives a relaunch", async () => {
+    setLog([DELETED, OVERWRITTEN]);
+    await renderFor("proj1");
+
+    await act(async () => {
+      await userEvent.click(screen.getByRole("button", { name: /got it/i }));
+    });
+
+    expect(mockInvoke).toHaveBeenCalledWith("local_loss_ack", { projectId: "proj1" });
+    expect(screen.queryByText(/deleted locally/i)).toBeNull();
+  });
+
+  it("never re-raises an already-acknowledged loss", async () => {
+    setLog([{ ...DELETED, acked: true }]);
+    await renderFor("proj1");
+
+    expect(screen.queryByText(/deleted locally/i)).toBeNull();
+  });
+
+  it("never shows one project's losses over another project", async () => {
+    // proj2 has lost nothing; proj1 has. Switching to proj2 must clear the warning…
+    setLogs({ proj1: [DELETED], proj2: [] });
+    await renderFor("proj1");
+    expect(screen.getByText(/2 files deleted locally/i)).toBeTruthy();
+
+    await act(async () => {
+      useProjectsStore.setState({ activeId: "proj2" } as never);
+    });
+    expect(screen.queryByText("src/gone.rs")).toBeNull();
+
+    // …and a proj1 fetch that lands *after* the switch (the real race — these reads are
+    // fired by background lockstep/sync passes) must not paint proj1's deletions over
+    // proj2 either. The store records which project a log belongs to precisely so this
+    // cannot happen.
+    await act(async () => {
+      useLocalLossStore.setState({ entries: [DELETED] as never, projectId: "proj1" });
+    });
+    expect(screen.queryByText("src/gone.rs")).toBeNull();
+  });
+});
diff --git a/src/__tests__/Markdown.test.ts b/src/__tests__/Markdown.test.ts
index bd7452e..65c2eb6 100644
--- a/src/__tests__/Markdown.test.ts
+++ b/src/__tests__/Markdown.test.ts
@@ -110,4 +110,27 @@ describe("renderMarkdown", () => {
   it("gives headings slug ids for in-document anchors", () => {
     expect(renderMarkdown("## Hello World")).toContain('<h2 id="hello-world">');
   });
+
+  it("emits remote and data images directly", () => {
+    expect(renderMarkdown("![badge](https://img.shields.io/x.svg)")).toContain(
+      '<img src="https://img.shields.io/x.svg" alt="badge" />',
+    );
+    expect(renderMarkdown("![d](data:image/png;base64,AAAA)")).toContain(
+      '<img src="data:image/png;base64,AAAA" alt="d" />',
+    );
+  });
+
+  it("tags local images for the viewer to resolve from disk", () => {
+    for (const src of ["images/logo.png", "./docs/logo.png", "../a/b.png", "/abs/y.png"]) {
+      const html = renderMarkdown(`![logo](${src})`);
+      expect(html).toContain(`<img class="md-img-local" data-md-src="${src}" alt="logo" />`);
+    }
+    // The title clause is stripped from the resolved path.
+    expect(renderMarkdown('![logo](./l.png "a title")')).toContain('data-md-src="./l.png"');
+  });
+
+  it("rejects images with an unsafe scheme", () => {
+    const html = renderMarkdown("![x](javascript:alert(1))");
+    expect(html).not.toContain("<img");
+  });
 });
diff --git a/src/__tests__/NativeEditorCaret.test.ts b/src/__tests__/NativeEditorCaret.test.ts
new file mode 100644
index 0000000..9c95774
--- /dev/null
+++ b/src/__tests__/NativeEditorCaret.test.ts
@@ -0,0 +1,260 @@
+/**
+ * Regression tests for CARET / INSERT-POSITION correctness in the native in-app
+ * code editors (the shared `CodeEditor` behind the text / markdown / TeX / code
+ * viewers).
+ *
+ * These bugs keep coming back whenever unrelated editor work touches the
+ * overlay/line-height plumbing, so the invariants are pinned here:
+ *
+ *  1. VERTICAL alignment ("caret sits below the coloured glyphs, drifting down
+ *     the file"). The editor stacks a transparent <textarea> (owns the caret)
+ *     over a syntax-highlighted <pre> (owns the visible glyphs). WebKitGTK lays
+ *     the textarea's lines out as whole-device-pixel boxes while the <pre> uses
+ *     the exact fractional multiple; under a fractional display scale those
+ *     diverge and ACCUMULATE — the caret drifts a full line off by the bottom.
+ *     `snapToDevicePx` is the fix: snap the shared line-height so both layers
+ *     land on the same device-pixel grid. We model both layouts and assert the
+ *     drift is zero with snapping (and non-zero without, so the model is real).
+ *
+ *  2. INSERT positions: Tab / Shift+Tab indentation must land the caret and keep
+ *     the selection exactly (`applyIndent`), and a SyncTeX reverse-search jump
+ *     must place the caret at the right source offset (`lineStartOffset` +
+ *     column, clamped to the line).
+ *
+ * The horizontal "caret is left of the click on some lines" symptom is a metric
+ * divergence between the layers (font/kerning/tab-size); that invariant is
+ * locked in `NativeEditorMetricsCss.test.ts`, and the rendered device-pixel snap
+ * in `NativeEditorCaretLayout.test.tsx`.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  snapToDevicePx,
+  applyIndent,
+} from "../components/embed/FileViewerPane";
+import { lineStartOffset, offsetToLineCol } from "../lib/viewers/tex";
+
+// --- vertical caret/glyph drift model ---------------------------------------
+//
+// Reproduce the two competing layouts EXACTLY as WebKitGTK does (see the
+// `snapToDevicePx` doc comment). Both are fed the SAME CSS line-height `lhCss`;
+// they only diverge in how each rounds to device pixels.
+//
+//   overlay <pre>  : row n top (device px) = round(n · lhCss · dpr)   (fractional multiple)
+//   <textarea>     : row n top (device px) = n · round(lhCss · dpr)   (whole-box stacking)
+//
+// The caret rides the textarea; the visible glyph rides the <pre>. Their
+// difference is exactly the caret-vs-glyph vertical drift a user sees.
+const overlayRowTop = (n: number, lhCss: number, dpr: number) =>
+  Math.round(n * lhCss * dpr);
+const textareaRowTop = (n: number, lhCss: number, dpr: number) =>
+  n * Math.round(lhCss * dpr);
+const caretDrift = (n: number, lhCss: number, dpr: number) =>
+  textareaRowTop(n, lhCss, dpr) - overlayRowTop(n, lhCss, dpr);
+
+// Fractional display scales that actually ship (125%, 150%, 175%, 133%, …), plus
+// a couple of awkward ones. Integer scales (1, 2, 3) are covered separately.
+const FRACTIONAL_DPRS = [1.1, 1.25, 1.333333, 1.5, 1.75, 2.25, 2.5, 1.2];
+// Raw line-heights the size control produces: round(fontSize · 1.5) over the
+// editor's whole font-size range (see EDITOR_LINE_RATIO / the A± control).
+const RAW_LINE_HEIGHTS = Array.from({ length: 24 }, (_, i) =>
+  Math.round((8 + i) * 1.5),
+);
+
+describe("snapToDevicePx", () => {
+  it("is a no-op for whole-pixel line-heights at integer device-pixel ratios", () => {
+    // The size control only ever produces whole-pixel line-heights (round(font·1.5)),
+    // and at an integer dpr those already sit on the device grid → nothing to snap.
+    for (const dpr of [1, 2, 3]) {
+      for (const px of [12, 18, 21, 24, 27]) {
+        expect(snapToDevicePx(px, dpr)).toBe(px);
+      }
+    }
+  });
+
+  it("lands the line-height on a whole number of device pixels", () => {
+    for (const dpr of FRACTIONAL_DPRS) {
+      for (const px of RAW_LINE_HEIGHTS) {
+        const snapped = snapToDevicePx(px, dpr);
+        const devicePx = snapped * dpr;
+        // Snapped × dpr must be (within fp tolerance) an integer of device px —
+        // that is the whole point: both layers now share the same device grid.
+        expect(Math.abs(devicePx - Math.round(devicePx))).toBeLessThan(1e-6);
+      }
+    }
+  });
+
+  it("snaps to the NEAREST device-pixel grid line (≤ half a device px moved)", () => {
+    for (const dpr of FRACTIONAL_DPRS) {
+      for (const px of RAW_LINE_HEIGHTS) {
+        const snapped = snapToDevicePx(px, dpr);
+        // The correction never moves the line-height more than half a device px,
+        // so text size is visually preserved while the grid is fixed.
+        expect(Math.abs(snapped - px) * dpr).toBeLessThanOrEqual(0.5 + 1e-9);
+      }
+    }
+  });
+});
+
+describe("caret-vs-glyph vertical drift (the recurring bug)", () => {
+  it("REPRODUCES: without snapping the caret drifts off the glyphs and accumulates", () => {
+    // Guard against a false-green model: prove the raw layouts really do diverge,
+    // so the with-snapping assertion below is meaningful. On a fractional scale
+    // with an odd line-height, the caret drifts more than a full CSS line within
+    // a few hundred lines.
+    const dpr = 1.5;
+    const lhCss = 21; // odd → 21·1.5 = 31.5, not on the device grid
+    const maxDrift = Math.max(
+      ...Array.from({ length: 400 }, (_, n) =>
+        Math.abs(caretDrift(n, lhCss, dpr) / dpr),
+      ),
+    );
+    // Drifts well past a whole line (21 CSS px) — this is the "caret a line below
+    // the text by the bottom of the file" the user reported.
+    expect(maxDrift).toBeGreaterThan(lhCss);
+  });
+
+  it("FIXED: with snapToDevicePx the caret sits on the glyphs on EVERY line", () => {
+    // The exact invariant the editor depends on: feed the SAME snapped line-height
+    // to both layers and the per-row advance is identical, so nothing accumulates
+    // no matter how long the file or how awkward the display scale.
+    for (const dpr of [1, 2, 3, ...FRACTIONAL_DPRS]) {
+      for (const raw of RAW_LINE_HEIGHTS) {
+        const lhCss = snapToDevicePx(raw, dpr);
+        for (const n of [0, 1, 2, 10, 100, 999, 3000]) {
+          expect(caretDrift(n, lhCss, dpr)).toBe(0);
+        }
+      }
+    }
+  });
+
+  it("FIXED: caret is neither above NOR below the glyphs (drift is exactly 0, not just small)", () => {
+    // The user has seen it both ways (above and below) across regressions; assert
+    // the signed drift is zero so neither direction can creep back.
+    const dpr = 1.25;
+    for (const raw of RAW_LINE_HEIGHTS) {
+      const lhCss = snapToDevicePx(raw, dpr);
+      for (let n = 0; n <= 2000; n += 7) {
+        expect(caretDrift(n, lhCss, dpr)).toBe(0);
+      }
+    }
+  });
+});
+
+// --- Tab / Shift+Tab insert positions ---------------------------------------
+
+/** Build a real jsdom textarea with a value + selection for `applyIndent`. */
+function ta(value: string, selStart: number, selEnd = selStart): HTMLTextAreaElement {
+  const el = document.createElement("textarea");
+  el.value = value;
+  el.setSelectionRange(selStart, selEnd);
+  return el;
+}
+
+const INDENT = "    "; // 4 spaces (mirrors the editor's INDENT)
+
+describe("applyIndent — Tab / Shift+Tab caret & selection", () => {
+  it("inserts one indent AT THE CARET and moves the caret past it", () => {
+    // "abc|def" + Tab → "abc    |def"; caret advances by exactly the indent width.
+    const r = applyIndent(ta("abcdef", 3), false);
+    expect(r).not.toBeNull();
+    expect(r!.value).toBe("abc" + INDENT + "def");
+    expect(r!.selStart).toBe(3 + INDENT.length);
+    expect(r!.selEnd).toBe(3 + INDENT.length);
+  });
+
+  it("inserts at the caret even at the very start of a line, not the line start heuristic", () => {
+    // Caret at start of the 2nd line ("a\n|b") → indent goes at the caret.
+    const r = applyIndent(ta("a\nb", 2), false);
+    expect(r!.value).toBe("a\n" + INDENT + "b");
+    expect(r!.selStart).toBe(2 + INDENT.length);
+  });
+
+  it("indents every line a multi-line selection touches and keeps the selection over the same text", () => {
+    // Select "a\nb" in "a\nb\nc"; Tab indents both lines.
+    const r = applyIndent(ta("a\nb\nc", 0, 3), false);
+    expect(r!.value).toBe(INDENT + "a\n" + INDENT + "b\nc");
+    // First line shifts by one indent; the selection end shifts by both indents.
+    expect(r!.selStart).toBe(INDENT.length); // 4
+    expect(r!.selEnd).toBe(3 + 2 * INDENT.length); // 11
+    // The selected slice still spans exactly the two (now-indented) lines.
+    expect(r!.value.slice(r!.selStart, r!.selEnd)).toBe("a\n" + INDENT + "b");
+  });
+
+  it("extends indentation to the whole first line when the selection starts mid-line", () => {
+    // Selection begins inside the first line ("x[x\ny]y"): the indent still lands
+    // at the line start, and the anchor is pushed right by the indent width.
+    const r = applyIndent(ta("xx\nyy", 1, 4), false);
+    expect(r!.value).toBe(INDENT + "xx\n" + INDENT + "yy");
+    expect(r!.selStart).toBe(1 + INDENT.length); // 5
+    expect(r!.selEnd).toBe(4 + 2 * INDENT.length); // 12
+  });
+
+  it("outdent strips one indent from each selected line", () => {
+    const r = applyIndent(ta(INDENT + "a\n" + INDENT + "b", 0, (INDENT + "a\n" + INDENT + "b").length), true);
+    expect(r!.value).toBe("a\nb");
+  });
+
+  it("outdent removes only the leading whitespace that exists (fewer than a full indent)", () => {
+    // Two leading spaces → only two are stripped, caret never crosses the line start.
+    const r = applyIndent(ta("  a", 3, 3), true);
+    expect(r!.value).toBe("a");
+    // selStart clamps to the line start (0), never negative / into the prior line.
+    expect(r!.selStart).toBeGreaterThanOrEqual(0);
+  });
+
+  it("outdent on a line with no leading whitespace is a no-op on the text", () => {
+    const r = applyIndent(ta("abc\ndef", 0, 7), true);
+    expect(r!.value).toBe("abc\ndef");
+  });
+});
+
+// --- SyncTeX reverse-search caret placement ---------------------------------
+//
+// Mirrors the `gotoLine` effect in CodeEditor: place the caret at (1-based)
+// line/column, clamping the column to the line end so a stale SyncTeX column
+// can't spill onto the next line. Kept in lock-step with the component via the
+// exported `lineStartOffset` it is built on.
+function caretOffsetForLineCol(text: string, line: number, column: number): number {
+  const lineStart = lineStartOffset(text, line);
+  if (!column || column <= 1) return lineStart;
+  const nl = text.indexOf("\n", lineStart);
+  const lineEnd = nl === -1 ? text.length : nl;
+  return Math.min(lineStart + (column - 1), lineEnd);
+}
+
+describe("reverse-search caret placement (line/column → insert offset)", () => {
+  const TEXT = "\\section{Intro}\nHello world\nsecond paragraph here\n";
+
+  it("column ≤ 1 (or 0, SyncTeX's no-column sentinel) lands at the line start", () => {
+    expect(caretOffsetForLineCol(TEXT, 2, 0)).toBe(lineStartOffset(TEXT, 2));
+    expect(caretOffsetForLineCol(TEXT, 2, 1)).toBe(lineStartOffset(TEXT, 2));
+    // And that offset is genuinely the first char of line 2 ("Hello world").
+    expect(TEXT.slice(caretOffsetForLineCol(TEXT, 2, 1), caretOffsetForLineCol(TEXT, 2, 1) + 5)).toBe("Hello");
+  });
+
+  it("offsets into the line by (column − 1) and round-trips through offsetToLineCol", () => {
+    // Caret at line 2, column 7 → the 'w' of "world".
+    const off = caretOffsetForLineCol(TEXT, 2, 7);
+    expect(TEXT[off]).toBe("w");
+    expect(offsetToLineCol(TEXT, off)).toEqual({ line: 2, column: 7 });
+  });
+
+  it("clamps an over-long (stale) column to the line end, never spilling to the next line", () => {
+    const off = caretOffsetForLineCol(TEXT, 2, 999);
+    const { line } = offsetToLineCol(TEXT, off);
+    expect(line).toBe(2); // still on line 2, not line 3
+    // Exactly at the newline that ends line 2.
+    expect(TEXT[off]).toBe("\n");
+  });
+
+  it("places every in-range (line, column) at an offset that round-trips exactly", () => {
+    const lines = TEXT.split("\n");
+    for (let l = 1; l <= lines.length; l++) {
+      const len = lines[l - 1].length;
+      for (let c = 1; c <= len + 1; c++) {
+        const off = caretOffsetForLineCol(TEXT, l, c);
+        expect(offsetToLineCol(TEXT, off)).toEqual({ line: l, column: c });
+      }
+    }
+  });
+});
diff --git a/src/__tests__/NativeEditorCaretLayout.test.tsx b/src/__tests__/NativeEditorCaretLayout.test.tsx
new file mode 100644
index 0000000..9cf2301
--- /dev/null
+++ b/src/__tests__/NativeEditorCaretLayout.test.tsx
@@ -0,0 +1,117 @@
+/**
+ * DOM regression test for the vertical caret drift ("caret ends up a line below
+ * the coloured text further down the file").
+ *
+ * `NativeEditorCaret.test.ts` proves the `snapToDevicePx` MATH is correct; this
+ * test proves the editor actually APPLIES it — i.e. the rendered
+ * `--code-line-height` custom property (which both the <textarea> and the glyph
+ * <pre> layers read) lands on a whole number of device pixels under a fractional
+ * display scale. If a future edit computes the line-height without snapping, the
+ * variable falls off the device grid and this fails, instead of the caret
+ * silently drifting again in the running app.
+ *
+ * jsdom has no layout engine and doesn't apply external CSS, so we can only read
+ * the inline custom property — but that variable IS the single knob both layers
+ * share, so asserting it is snapped guards the whole alignment.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, act, waitFor } from "@testing-library/react";
+import { snapToDevicePx } from "../components/embed/FileViewerPane";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: { getState: () => ({ openFile: () => Promise.resolve() }) },
+}));
+
+const { prefsRef } = vi.hoisted(() => ({
+  prefsRef: { current: {} as Record<string, { font_size?: number }> },
+}));
+vi.mock("../stores/settings", () => {
+  const state = () => ({
+    settings: { autosave: false, viewer_prefs: prefsRef.current },
+    updateSettings: vi.fn(),
+  });
+  const hook = (sel: (s: unknown) => unknown) => sel(state());
+  (hook as unknown as { getState: typeof state }).getState = state;
+  return { useSettingsStore: hook };
+});
+
+type Tab = { key: string; kind?: string; viewerState?: Record<string, unknown> };
+const { tabsRef } = vi.hoisted(() => ({ tabsRef: { current: [] as Tab[] } }));
+vi.mock("../stores/tabs", async (importActual) => {
+  const actual = await importActual<Record<string, unknown>>();
+  const state = () => ({
+    tabs: tabsRef.current,
+    setActive: vi.fn(),
+    setViewerState: vi.fn(),
+  });
+  const hook = (sel?: (s: unknown) => unknown) => (sel ? sel(state()) : state());
+  (hook as unknown as { getState: typeof state }).getState = state;
+  return { ...actual, useTabsStore: hook };
+});
+
+const SOURCE = "line one\nline two\nline three\n";
+const TAB_KEY = "t1";
+
+function setDpr(dpr: number) {
+  Object.defineProperty(window, "devicePixelRatio", {
+    configurable: true,
+    value: dpr,
+  });
+}
+
+async function renderTextViewAt(fontSize: number, dpr: number) {
+  prefsRef.current = { text: { font_size: fontSize } };
+  setDpr(dpr);
+  vi.resetModules();
+  const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+  await act(async () => {
+    render(<FileViewerPane viewer="text" path="/p/notes.txt" projectId="proj" tabKey={TAB_KEY} />);
+  });
+  await waitFor(() =>
+    expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toBe(SOURCE),
+  );
+  return document.querySelector(".file-viewer-code") as HTMLElement;
+}
+
+const lineHeightPx = (code: HTMLElement) =>
+  parseFloat(code.style.getPropertyValue("--code-line-height"));
+
+describe("editor line-height is snapped to the device-pixel grid", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tabsRef.current = [{ key: TAB_KEY, kind: "embed", viewerState: {} }];
+    mockInvoke.mockImplementation((cmd: string) => {
+      if (cmd === "read_file_text") return Promise.resolve(SOURCE);
+      if (cmd === "file_mtime") return Promise.resolve(1000);
+      return Promise.resolve(null);
+    });
+  });
+  afterEach(() => setDpr(1));
+
+  it("lands the rendered line-height on whole device pixels under a fractional scale", async () => {
+    // fontSize 14 → raw line-height round(14·1.5)=21; at 150% scale 21·1.5=31.5 is
+    // OFF the device grid, so the editor must snap it (→ 32/1.5 = 21.333px).
+    const dpr = 1.5;
+    const raw = Math.round(14 * 1.5); // 21
+    const code = await renderTextViewAt(14, dpr);
+    const px = lineHeightPx(code);
+
+    // It landed on the grid …
+    expect(Math.abs(px * dpr - Math.round(px * dpr))).toBeLessThan(1e-6);
+    // … at the RIGHT grid line (the snap of the raw height, not some other row) …
+    expect(px).toBeCloseTo(snapToDevicePx(raw, dpr), 6);
+    expect(Math.round(px * dpr)).toBe(Math.round(raw * dpr)); // 32 device px
+    // … and it genuinely moved off the un-snapped value (proves snapping ran).
+    expect(px).not.toBe(raw);
+    // Font-size still tracks the chosen size, so the two layers scale together.
+    expect(code.style.getPropertyValue("--code-font-size")).toBe("14px");
+  });
+
+  it("is a no-op at an integer scale (line-height stays the raw value)", async () => {
+    const code = await renderTextViewAt(16, 2);
+    // 16 → 24; 24·2 = 48 already whole, so no correction.
+    expect(lineHeightPx(code)).toBe(24);
+  });
+});
diff --git a/src/__tests__/NativeEditorMetricsCss.test.ts b/src/__tests__/NativeEditorMetricsCss.test.ts
new file mode 100644
index 0000000..04b031a
--- /dev/null
+++ b/src/__tests__/NativeEditorMetricsCss.test.ts
@@ -0,0 +1,161 @@
+/**
+ * Regression lock for the "caret is left of the click, but only on some lines"
+ * bug in the native code editor.
+ *
+ * The editor stacks a transparent <textarea> (owns the caret and the click →
+ * offset hit-testing) over one or more syntax/decoration <pre> overlay layers
+ * (own the glyphs the user actually sees). The caret only stays under the glyph
+ * the user clicked if EVERY text-metric-affecting CSS property is byte-for-byte
+ * identical across all layers — same font, same size, same line-height, same
+ * tab-size, same kerning/ligature/precision settings, same padding origin.
+ *
+ * When they drift apart the caret and the glyphs diverge *content-dependently* —
+ * e.g. a stray `tab-size: 2` on one layer only skews lines that contain tabs,
+ * and different kerning skews only lines with kerning pairs. That is exactly the
+ * "only some lines" symptom, and it keeps reappearing because these parallel CSS
+ * rules are edited independently.
+ *
+ * This test parses `themes.css` and asserts the effective metric set of the
+ * <textarea> equals that of the highlight layer AND every decoration overlay, so
+ * any future edit that desyncs one layer fails here instead of in the user's eye.
+ */
+import { describe, it, expect } from "vitest";
+// Read the stylesheet at test time. A `?raw` import yields "" under the config's
+// `css: false`, so go through node's fs instead. The project has no @types/node,
+// so tsc can't see the builtin — suppress just that resolution error; vitest
+// resolves it fine at runtime. Vitest runs from the repo root → repo-relative path.
+// @ts-expect-error node:fs has no type declarations in this project (no @types/node)
+import { readFileSync } from "node:fs";
+
+const CSS: string = readFileSync("src/styles/themes.css", "utf8");
+
+type Decls = Record<string, string>;
+interface Rule {
+  selectors: string[];
+  decls: Decls;
+}
+
+/** Parse every innermost rule (a selector list + its flat declaration block).
+ *  Declaration bodies never contain braces, so the innermost-match regex skips
+ *  @media wrappers cleanly — good enough for the top-level editor rules here. */
+function parseRules(css: string): Rule[] {
+  const noComments = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const rules: Rule[] = [];
+  const re = /([^{}]+)\{([^{}]*)\}/g;
+  for (let m = re.exec(noComments); m; m = re.exec(noComments)) {
+    const selectors = m[1]
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    const decls: Decls = {};
+    for (const d of m[2].split(";")) {
+      const i = d.indexOf(":");
+      if (i < 0) continue;
+      const prop = d.slice(0, i).trim().toLowerCase();
+      const val = d
+        .slice(i + 1)
+        .trim()
+        .replace(/\s+/g, " ");
+      if (prop) decls[prop] = val;
+    }
+    rules.push({ selectors, decls });
+  }
+  return rules;
+}
+
+const RULES = parseRules(CSS);
+
+/** The merged declarations of every rule that targets `selector` exactly (as a
+ *  whole selector-list member), in source order (later wins). */
+function declsFor(selector: string): Decls {
+  const out: Decls = {};
+  for (const r of RULES) if (r.selectors.includes(selector)) Object.assign(out, r.decls);
+  return out;
+}
+
+// The <textarea>'s effective style is `.file-viewer-editor` (base) overridden by
+// `.file-viewer-code-editor` (equal specificity, later in source → wins).
+const TEXTAREA: Decls = {
+  ...declsFor(".file-viewer-editor"),
+  ...declsFor(".file-viewer-code-editor"),
+};
+
+// The layers that must line up glyph-for-glyph under the caret.
+const OVERLAY_SELECTORS = [
+  ".file-viewer-highlight",
+  ".file-viewer-link-layer",
+  ".file-viewer-search-layer",
+  ".file-viewer-change-layer",
+  ".file-viewer-delete-layer",
+  ".file-viewer-grammar-layer",
+  ".file-viewer-ghost",
+];
+
+// Every property that moves a glyph horizontally or vertically. If any of these
+// differs between the caret layer and a glyph layer, the caret drifts off the
+// text (globally, or on just the lines that trigger that property).
+const METRIC_PROPS = [
+  "font-family",
+  "font-size",
+  "line-height",
+  "letter-spacing",
+  "word-spacing",
+  "tab-size",
+  "white-space",
+  "font-variant-ligatures",
+  "font-feature-settings",
+  "font-kerning",
+  "text-rendering",
+  "padding",
+];
+
+describe("native editor layer metric parity (themes.css)", () => {
+  it("the CSS actually defines the editor + overlay rules (guards against a silent rename)", () => {
+    // Without this, a renamed class would make declsFor return {} and the parity
+    // assertions below would vacuously pass.
+    expect(Object.keys(declsFor(".file-viewer-editor")).length).toBeGreaterThan(0);
+    expect(TEXTAREA["line-height"]).toBeTruthy();
+    expect(TEXTAREA["font-size"]).toBeTruthy();
+    for (const sel of OVERLAY_SELECTORS) {
+      const d = declsFor(sel);
+      expect(d["line-height"], `${sel} missing line-height`).toBeTruthy();
+      expect(d["font-size"], `${sel} missing font-size`).toBeTruthy();
+    }
+  });
+
+  it("the <textarea> resolves to the canonical editor metrics", () => {
+    // Pin the exact effective values so a change that moves BOTH layers together
+    // to something wrong (e.g. re-enabling kerning everywhere) is still caught.
+    expect(TEXTAREA["font-size"]).toBe("var(--code-font-size, 12px)");
+    expect(TEXTAREA["line-height"]).toBe("var(--code-line-height, 18px)");
+    expect(TEXTAREA["white-space"]).toBe("pre");
+    expect(TEXTAREA["tab-size"]).toBe("4"); // NOT the base rule's 2 — it must be overridden
+    expect(TEXTAREA["font-variant-ligatures"]).toBe("none");
+    expect(TEXTAREA["font-kerning"]).toBe("none");
+    expect(TEXTAREA["text-rendering"]).toBe("geometricPrecision");
+    expect(TEXTAREA["padding"]).toBe("10px 12px");
+  });
+
+  for (const sel of OVERLAY_SELECTORS) {
+    it(`${sel} shares every glyph-metric property with the <textarea>`, () => {
+      const overlay = declsFor(sel);
+      for (const prop of METRIC_PROPS) {
+        expect(
+          overlay[prop],
+          `${sel} "${prop}" (${overlay[prop]}) must equal the textarea's (${TEXTAREA[prop]}) or the caret drifts off the glyphs`,
+        ).toBe(TEXTAREA[prop]);
+      }
+    });
+  }
+
+  it("no layer sets letter-spacing or word-spacing (any value would desync advances)", () => {
+    // These default to `normal` everywhere; asserting they are UNSET keeps a
+    // future one-layer tweak from silently reintroducing per-line drift.
+    expect(TEXTAREA["letter-spacing"]).toBeUndefined();
+    expect(TEXTAREA["word-spacing"]).toBeUndefined();
+    for (const sel of OVERLAY_SELECTORS) {
+      expect(declsFor(sel)["letter-spacing"]).toBeUndefined();
+      expect(declsFor(sel)["word-spacing"]).toBeUndefined();
+    }
+  });
+});
diff --git a/src/__tests__/NetworkTraffic.test.ts b/src/__tests__/NetworkTraffic.test.ts
new file mode 100644
index 0000000..e770612
--- /dev/null
+++ b/src/__tests__/NetworkTraffic.test.ts
@@ -0,0 +1,161 @@
+import { describe, expect, it } from "vitest";
+import {
+  aggregateInterfaceCounters,
+  formatBytes,
+  formatFileCount,
+  rateFromSamples,
+  isoWeekKeys,
+  summarizeNetFileUsage,
+  summarizeNetUsage,
+} from "../components/monitoring/NetworkTrafficPane";
+
+describe("network traffic calculations", () => {
+  it("aggregates only active non-loopback interfaces by default", () => {
+    const counters = aggregateInterfaceCounters(
+      [
+        { name: "lo", rxBytes: 100, txBytes: 200, up: true, loopback: true },
+        { name: "eth0", rxBytes: 1_000, txBytes: 2_000, up: true, loopback: false },
+        { name: "wlan0", rxBytes: 4_000, txBytes: 8_000, up: false, loopback: false },
+        { name: "tun0", rxBytes: 16_000, txBytes: 32_000, up: true, loopback: false },
+      ],
+      "aggregate",
+    );
+    expect(counters).toEqual({ id: "aggregate", rx: 17_000, tx: 34_000 });
+  });
+
+  it("selects a named interface including loopback or a down interface", () => {
+    const counters = aggregateInterfaceCounters(
+      [{ name: "lo", rxBytes: 12, txBytes: 34, up: true, loopback: true }],
+      "lo",
+    );
+    expect(counters).toEqual({ id: "lo", rx: 12, tx: 34 });
+  });
+
+  it("derives rates from elapsed time and rejects resets", () => {
+    const previous = { id: "eth0", at: 1_000, rx: 10_000, tx: 20_000 };
+    expect(
+      rateFromSamples(previous, { id: "eth0", at: 3_000, rx: 14_000, tx: 22_000 }),
+    ).toEqual({ rxRate: 2_000, txRate: 1_000, rxDelta: 4_000, txDelta: 2_000 });
+    expect(
+      rateFromSamples(previous, { id: "eth0", at: 3_000, rx: 1, tx: 1 }),
+    ).toEqual({ rxRate: 0, txRate: 0, rxDelta: 0, txDelta: 0 });
+    expect(
+      rateFromSamples(previous, { id: "new-connection", at: 3_000, rx: 14_000, tx: 22_000 }),
+    ).toEqual({ rxRate: 0, txRate: 0, rxDelta: 0, txDelta: 0 });
+  });
+
+  it("formats byte counts compactly", () => {
+    expect(formatBytes(0)).toBe("0 B");
+    expect(formatBytes(1536)).toBe("1.5 KiB");
+    expect(formatBytes(2 * 1024 * 1024)).toBe("2.0 MiB");
+  });
+
+  it("summarizes persisted usage into hour / today / week / month / overall (UTC)", () => {
+    // 2026-07-03T12:30Z is a Friday → hour 2026-07-03T12, ISO week Mon 06-29
+    // through Sun 07-05, month 2026-07. 06-28 (Sunday) is the week before, and
+    // the three June days sit in the month before.
+    const now = Date.parse("2026-07-03T12:30:00Z");
+    const totals = summarizeNetUsage(
+      {
+        hours: {
+          "2026-07-03T12": { rx: 7, tx: 3 },
+          "2026-07-03T11": { rx: 93, tx: 37 },
+        },
+        days: {
+          "2026-07-03": { rx: 100, tx: 40 },
+          "2026-06-30": { rx: 10, tx: 5 },
+          "2026-06-29": { rx: 1, tx: 1 },
+          "2026-06-28": { rx: 1_000, tx: 2_000 },
+        },
+      },
+      now,
+    );
+    expect(totals.hour).toEqual({ rx: 7, tx: 3 });
+    expect(totals.today).toEqual({ rx: 100, tx: 40 });
+    expect(totals.week).toEqual({ rx: 111, tx: 46 });
+    expect(totals.month).toEqual({ rx: 100, tx: 40 });
+    expect(totals.overall).toEqual({ rx: 1_111, tx: 2_046 });
+  });
+
+  it("keeps day-derived totals intact when the hour window has been pruned", () => {
+    // Hours are retained for 14 days, days forever: an old day still counts
+    // toward week/month/overall with no hour bucket left to back it.
+    const totals = summarizeNetUsage(
+      { hours: {}, days: { "2026-05-02": { rx: 500, tx: 100 } } },
+      Date.parse("2026-07-03T12:00:00Z"),
+    );
+    expect(totals.hour).toEqual({ rx: 0, tx: 0 });
+    expect(totals.overall).toEqual({ rx: 500, tx: 100 });
+  });
+
+  it("returns zero totals for an empty usage report", () => {
+    const totals = summarizeNetUsage({ hours: {}, days: {} }, Date.parse("2026-07-03T12:00:00Z"));
+    expect(totals.hour).toEqual({ rx: 0, tx: 0 });
+    expect(totals.today).toEqual({ rx: 0, tx: 0 });
+    expect(totals.week).toEqual({ rx: 0, tx: 0 });
+    expect(totals.month).toEqual({ rx: 0, tx: 0 });
+    expect(totals.overall).toEqual({ rx: 0, tx: 0 });
+  });
+
+  it("anchors the ISO week to Monday, including on its Monday and Sunday edges", () => {
+    const week = [
+      "2026-06-29",
+      "2026-06-30",
+      "2026-07-01",
+      "2026-07-02",
+      "2026-07-03",
+      "2026-07-04",
+      "2026-07-05",
+    ];
+    // Monday 00:00 and Sunday 23:59 UTC must yield the same seven days — the
+    // Sunday edge is the one a naive getUTCDay()-based offset gets wrong.
+    expect(isoWeekKeys(Date.parse("2026-06-29T00:00:00Z"))).toEqual(week);
+    expect(isoWeekKeys(Date.parse("2026-07-03T12:30:00Z"))).toEqual(week);
+    expect(isoWeekKeys(Date.parse("2026-07-05T23:59:59Z"))).toEqual(week);
+    // The next Monday rolls over to a fresh week.
+    expect(isoWeekKeys(Date.parse("2026-07-06T00:00:00Z"))[0]).toBe("2026-07-06");
+  });
+
+  it("summarizes per-project FILE counts into hour / today / week / month / overall", () => {
+    const now = Date.parse("2026-07-03T12:30:00Z");
+    const totals = summarizeNetFileUsage(
+      {
+        hours: {},
+        days: {},
+        fileHours: {
+          "2026-07-03T12": { down: 2, up: 0 },
+          "2026-07-03T11": { down: 5, up: 1 },
+        },
+        fileDays: {
+          "2026-07-03": { down: 9, up: 3 },
+          "2026-06-30": { down: 1, up: 0 },
+          "2026-06-28": { down: 100, up: 20 },
+        },
+      },
+      now,
+    );
+    expect(totals.hour).toEqual({ down: 2, up: 0 });
+    expect(totals.today).toEqual({ down: 9, up: 3 });
+    expect(totals.week).toEqual({ down: 10, up: 3 });
+    expect(totals.month).toEqual({ down: 9, up: 3 });
+    expect(totals.overall).toEqual({ down: 110, up: 23 });
+  });
+
+  it("returns zero file totals when the report has no file-count maps yet", () => {
+    const totals = summarizeNetFileUsage(
+      { hours: {}, days: {} },
+      Date.parse("2026-07-03T12:00:00Z"),
+    );
+    expect(totals.hour).toEqual({ down: 0, up: 0 });
+    expect(totals.overall).toEqual({ down: 0, up: 0 });
+  });
+
+  it("formats file counts with locale grouping", () => {
+    expect(formatFileCount(0)).toBe("0");
+    // The grouping separator is deliberately the *runtime's* locale ("," en,
+    // "." de, narrow-NBSP fr…), so pin the expectation to the same API rather
+    // than to en-US — hardcoding "1,234" fails on any non-English machine.
+    expect(formatFileCount(1234)).toBe((1234).toLocaleString());
+    expect(formatFileCount(1234)).toMatch(/^1\D234$/); // grouping did happen
+  });
+});
diff --git a/src/__tests__/PageModel.test.ts b/src/__tests__/PageModel.test.ts
new file mode 100644
index 0000000..021eb86
--- /dev/null
+++ b/src/__tests__/PageModel.test.ts
@@ -0,0 +1,160 @@
+/**
+ * Tests for the shared page-arrangement model (`lib/viewers/pageModel`) — the one
+ * the print preview's strip and the PDF viewer's page rail both edit.
+ *
+ * The first block is the print preview's ORIGINAL arrangement/rotation suite, moved
+ * here verbatim in behaviour and re-expressed against the generalised model. It is
+ * what pins the port down: if `movePages`/`deletePages`/`rotatePages` ever stop
+ * agreeing with the old `movePage`/`removePage`/`rotatePage`, these fail.
+ *
+ * The second block covers what the old model could not express at all — multi-page
+ * moves, several source documents, and independently-turned duplicates.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  SELF,
+  initialPages,
+  pagesOf,
+  movePages,
+  deletePages,
+  rotatePages,
+  duplicatePages,
+  insertPages,
+  isPristine,
+  type PageList,
+} from "../lib/viewers/pageModel";
+
+/** The arrangement as "which original page sits on each sheet" — the old `order`. */
+const order = (list: PageList): number[] => list.map((r) => r.page);
+/** The id of the sheet currently at `index`. */
+const idAt = (list: PageList, index: number): string => list[index].id;
+/** The rotation of the sheet showing original page `page`. */
+const rotOf = (list: PageList, page: number): number =>
+  list.find((r) => r.page === page)?.rot ?? 0;
+
+describe("page arrangement (the print preview's original suite, on the shared model)", () => {
+  it("moves a page to a new position", () => {
+    // `movePages`' index counts the sheets NOT being moved, which is precisely the
+    // convention the old `movePage(order, from, to)` used.
+    const four = initialPages(4);
+    expect(order(movePages(four, [idAt(four, 0)], 2))).toEqual([2, 3, 1, 4]);
+    expect(order(movePages(four, [idAt(four, 3)], 0))).toEqual([4, 1, 2, 3]);
+
+    const three = initialPages(3);
+    // A no-op move and an unknown id leave the order untouched.
+    expect(order(movePages(three, [idAt(three, 1)], 1))).toEqual([1, 2, 3]);
+    expect(order(movePages(three, ["nope"], 0))).toEqual([1, 2, 3]);
+    // Past the end clamps to last.
+    expect(order(movePages(three, [idAt(three, 0)], 99))).toEqual([2, 3, 1]);
+  });
+
+  it("removes a page", () => {
+    const three = initialPages(3);
+    expect(order(deletePages(three, [idAt(three, 1)]))).toEqual([1, 3]);
+    expect(order(deletePages(three, ["nope"]))).toEqual([1, 2, 3]);
+  });
+
+  it("turns a page a quarter at a time and wraps back to upright", () => {
+    let list = initialPages(3);
+    const id = idAt(list, 1); // original page 2
+    list = rotatePages(list, [id]);
+    expect(rotOf(list, 2)).toBe(90);
+    list = rotatePages(list, [id]);
+    expect(rotOf(list, 2)).toBe(180);
+    list = rotatePages(rotatePages(list, [id]), [id]);
+    // Four turns is a full circle: the page is upright again.
+    expect(rotOf(list, 2)).toBe(0);
+  });
+
+  it("turns counter-clockwise and leaves other pages alone", () => {
+    let list = initialPages(3);
+    list = rotatePages(list, [idAt(list, 0)]); // page 1 → 90°
+    list = rotatePages(list, [idAt(list, 2)], -90); // page 3 → 270°
+    expect(rotOf(list, 3)).toBe(270);
+    expect(rotOf(list, 1)).toBe(90);
+    expect(rotOf(list, 2)).toBe(0);
+  });
+
+  it("carries a page's turn with it when the page is reordered", () => {
+    // The old model keyed rotation by original page number to survive reordering;
+    // here the turn simply rides along on the entry, which is stronger.
+    let list = initialPages(3);
+    list = rotatePages(list, [idAt(list, 2)]); // page 3 → 90°
+    list = movePages(list, [idAt(list, 2)], 0); // drag page 3 to the front
+    expect(order(list)).toEqual([3, 1, 2]);
+    expect(list[0].rot).toBe(90);
+  });
+
+  it("starts from the document's own order", () => {
+    expect(order(initialPages(3))).toEqual([1, 2, 3]);
+    expect(initialPages(0)).toEqual([]);
+    expect(initialPages(3).every((r) => r.src === SELF && r.rot === 0)).toBe(true);
+  });
+
+  it("knows when the arrangement is still untouched", () => {
+    const list = initialPages(3);
+    expect(isPristine(list, 3)).toBe(true);
+    expect(isPristine(deletePages(list, [idAt(list, 0)]), 3)).toBe(false);
+    expect(isPristine(movePages(list, [idAt(list, 0)], 2), 3)).toBe(false);
+    expect(isPristine(rotatePages(list, [idAt(list, 0)]), 3)).toBe(false);
+  });
+});
+
+describe("page arrangement (what the old per-document model could not express)", () => {
+  it("moves a multi-page selection as one block, keeping its internal order", () => {
+    const five = initialPages(5);
+    const picked = [idAt(five, 1), idAt(five, 2)]; // pages 2 and 3
+    // Land them after page 5: the survivors are [1,4,5], so index 3 is the end.
+    expect(order(movePages(five, picked, 3))).toEqual([1, 4, 5, 2, 3]);
+    // ...and at the very front.
+    expect(order(movePages(five, picked, 0))).toEqual([2, 3, 1, 4, 5]);
+  });
+
+  it("moves a DISCONTIGUOUS selection as one block", () => {
+    const five = initialPages(5);
+    const picked = [idAt(five, 0), idAt(five, 4)]; // pages 1 and 5
+    // Survivors are [2,3,4]; inserting before the 2nd survivor puts the block
+    // between pages 2 and 3, and the block keeps its own order (1 then 5).
+    expect(order(movePages(five, picked, 1))).toEqual([2, 1, 5, 3, 4]);
+  });
+
+  it("deletes a multi-page selection in one step", () => {
+    const five = initialPages(5);
+    expect(order(deletePages(five, [idAt(five, 0), idAt(five, 3)]))).toEqual([2, 3, 5]);
+  });
+
+  it("turns a duplicated page independently of its twin", () => {
+    // The old model keyed rotation by original page number, so both copies of a
+    // page necessarily turned together. Here they do not.
+    let list = initialPages(2);
+    list = duplicatePages(list, [idAt(list, 0)]); // page 1 twice, adjacent
+    expect(order(list)).toEqual([1, 1, 2]);
+    expect(list[0].id).not.toBe(list[1].id);
+
+    list = rotatePages(list, [idAt(list, 1)]); // turn only the copy
+    expect(list[0].rot).toBe(0);
+    expect(list[1].rot).toBe(90);
+  });
+
+  it("merges pages from another document, keeping each sheet's own source", () => {
+    const mine = initialPages(2); // "self": pages 1, 2
+    const other = pagesOf("doc-b", 3); // another PDF: pages 1..3
+    const merged = insertPages(mine, other.slice(0, 2), 1); // its 1-2 after my page 1
+
+    expect(merged.map((r) => [r.src, r.page])).toEqual([
+      [SELF, 1],
+      ["doc-b", 1],
+      ["doc-b", 2],
+      [SELF, 2],
+    ]);
+    // A merged arrangement is never "pristine", however many pages it happens to have.
+    expect(isPristine(merged, 4)).toBe(false);
+  });
+
+  it("gives inserted pages fresh ids, so re-inserting the same pages never collides", () => {
+    const mine = initialPages(2);
+    const twice = insertPages(insertPages(mine, mine, 0), mine, 0);
+    expect(twice).toHaveLength(6);
+    expect(new Set(twice.map((r) => r.id)).size).toBe(6);
+  });
+});
diff --git a/src/__tests__/PageStrip.test.tsx b/src/__tests__/PageStrip.test.tsx
new file mode 100644
index 0000000..7fb0e94
--- /dev/null
+++ b/src/__tests__/PageStrip.test.tsx
@@ -0,0 +1,202 @@
+/**
+ * Tests for the shared page strip (`components/common/PageStrip`) — the widget the
+ * print preview's strip and the PDF viewer's page rail are both instances of.
+ *
+ * `insertionIndexAt` is the pure core of the drag (which gap the pointer is in), so
+ * it is tested directly and on both axes. The component tests then cover the parts
+ * that only exist once mounted: shift-selection, and acting on a whole selection.
+ *
+ * jsdom gives every element a zero-sized rect, so the drag's hit-testing is driven
+ * by stubbing `getBoundingClientRect` — the same approach `DragDropSplit.test.tsx`
+ * takes for the tab drag.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { useState } from "react";
+import { PageStrip, insertionIndexAt, type CardBox } from "../components/common/PageStrip";
+import { initialPages, type PageList } from "../lib/viewers/pageModel";
+
+const box = (index: number, left: number, top: number): CardBox => ({
+  index,
+  left,
+  top,
+  right: left + 50,
+  bottom: top + 70,
+});
+
+describe("insertionIndexAt", () => {
+  // Three cards laid out left-to-right at x = 0, 60, 120 (each 50 wide).
+  const row = [box(0, 0, 0), box(1, 60, 0), box(2, 120, 0)];
+  // ...and the same three stacked top-to-bottom at y = 0, 80, 160 (each 70 tall).
+  const column = [box(0, 0, 0), box(1, 0, 80), box(2, 0, 160)];
+
+  it("lands before the first card whose midpoint the pointer has not passed (row)", () => {
+    expect(insertionIndexAt(row, 5, 0, "row")).toBe(0); // left of card 0's middle
+    expect(insertionIndexAt(row, 40, 0, "row")).toBe(1); // past card 0's middle
+    expect(insertionIndexAt(row, 100, 0, "row")).toBe(2);
+    expect(insertionIndexAt(row, 999, 0, "row")).toBe(3); // past them all → append
+  });
+
+  it("measures along the y axis in a column, not the x axis", () => {
+    expect(insertionIndexAt(column, 0, 5, "column")).toBe(0);
+    expect(insertionIndexAt(column, 0, 50, "column")).toBe(1);
+    expect(insertionIndexAt(column, 0, 999, "column")).toBe(3);
+    // A big x means nothing in a column — only the y axis is consulted.
+    expect(insertionIndexAt(column, 999, 5, "column")).toBe(0);
+  });
+
+  it("appends when there is nothing to compare against", () => {
+    expect(insertionIndexAt([], 10, 10, "row")).toBe(0);
+  });
+});
+
+/** A strip wired to real state, so edits round-trip like they do in the app. */
+function Harness({
+  initial,
+  onPages,
+}: {
+  initial: PageList;
+  onPages?: (p: PageList) => void;
+}) {
+  const [pages, setPages] = useState(initial);
+  return (
+    <PageStrip
+      pages={pages}
+      orientation="row"
+      onChange={(next) => {
+        setPages(next);
+        onPages?.(next);
+      }}
+      renderThumb={(ref) => <span className="thumb">{ref.page}</span>}
+      titleFor={(ref) => `Page ${ref.page}`}
+    />
+  );
+}
+
+const cards = () => screen.getAllByRole("listitem");
+const pageNumbers = () => cards().map((c) => c.querySelector(".thumb")?.textContent);
+
+/**
+ * Dispatch a pointer event the way the existing drag tests do (`DragDropSplit`):
+ * jsdom's PointerEvent doesn't carry the fields we read, so a plain Event is
+ * decorated with them, and `act` flushes the React state the handler sets.
+ */
+function pointer(type: string, x: number, y: number, target: EventTarget) {
+  const ev = new Event(type, { bubbles: true, cancelable: true });
+  Object.assign(ev, { clientX: x, clientY: y, button: 0, pointerId: 1 });
+  act(() => {
+    target.dispatchEvent(ev);
+  });
+}
+
+/** Give the cards a layout: jsdom has none, so the drag has nothing to aim at. */
+function layOutRow(els: HTMLElement[]) {
+  els.forEach((el, i) => {
+    vi.spyOn(el, "getBoundingClientRect").mockReturnValue({
+      left: i * 60,
+      right: i * 60 + 50,
+      top: 0,
+      bottom: 70,
+      width: 50,
+      height: 70,
+      x: i * 60,
+      y: 0,
+      toJSON: () => ({}),
+    } as DOMRect);
+  });
+}
+
+describe("PageStrip", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("deletes the whole selection when a selected card's ✕ is pressed", async () => {
+    const user = userEvent.setup();
+    render(<Harness initial={initialPages(4)} />);
+    expect(pageNumbers()).toEqual(["1", "2", "3", "4"]);
+
+    // Select pages 2..3 with a shift-click range, then delete via page 2's ✕.
+    await user.click(cards()[1]);
+    await user.keyboard("{Shift>}");
+    await user.click(cards()[2]);
+    await user.keyboard("{/Shift}");
+
+    expect(cards()[1].className).toContain("is-selected");
+    expect(cards()[2].className).toContain("is-selected");
+
+    await user.click(cards()[1].querySelector(".page-strip-del") as HTMLElement);
+    expect(pageNumbers()).toEqual(["1", "4"]);
+  });
+
+  it("acts on only the clicked card when it is outside the selection", async () => {
+    const user = userEvent.setup();
+    render(<Harness initial={initialPages(3)} />);
+
+    await user.click(cards()[0]); // select page 1
+    // ...then delete page 3, which is NOT selected: page 1 must survive.
+    await user.click(cards()[2].querySelector(".page-strip-del") as HTMLElement);
+    expect(pageNumbers()).toEqual(["1", "2"]);
+  });
+
+  it("turns a page, and marks a quarter turn so the thumbnail's box is swapped", async () => {
+    const user = userEvent.setup();
+    render(<Harness initial={initialPages(2)} />);
+
+    await user.click(cards()[0].querySelector(".page-strip-rotate") as HTMLElement);
+    expect(cards()[0].className).toContain("is-quarter-turned");
+    expect(cards()[0].getAttribute("style")).toContain("90deg");
+
+    // A second turn is a half turn: upright box again, but still rotated.
+    await user.click(cards()[0].querySelector(".page-strip-rotate") as HTMLElement);
+    expect(cards()[0].className).not.toContain("is-quarter-turned");
+    expect(cards()[0].getAttribute("style")).toContain("180deg");
+  });
+
+  it("reorders by dragging a card past a neighbour's midpoint", () => {
+    const seen: PageList[] = [];
+    render(<Harness initial={initialPages(3)} onPages={(p) => seen.push(p)} />);
+    layOutRow(cards());
+
+    // Press page 1 and drag it right, past page 3's midpoint (x = 145).
+    pointer("pointerdown", 10, 10, cards()[0]);
+    pointer("pointermove", 150, 10, window);
+    pointer("pointerup", 150, 10, window);
+
+    expect(pageNumbers()).toEqual(["2", "3", "1"]);
+    expect(seen[seen.length - 1].map((r) => r.page)).toEqual([2, 3, 1]);
+  });
+
+  it("drags a whole shift-selected block, keeping its internal order", async () => {
+    const user = userEvent.setup();
+    render(<Harness initial={initialPages(4)} />);
+
+    // Select pages 1..2, then drag them to the end.
+    await user.click(cards()[0]);
+    await user.keyboard("{Shift>}");
+    await user.click(cards()[1]);
+    await user.keyboard("{/Shift}");
+
+    layOutRow(cards());
+    pointer("pointerdown", 10, 10, cards()[0]);
+    pointer("pointermove", 400, 10, window);
+    pointer("pointerup", 400, 10, window);
+
+    expect(pageNumbers()).toEqual(["3", "4", "1", "2"]);
+  });
+
+  it("puts the arrangement back if the drag is abandoned with Escape", () => {
+    render(<Harness initial={initialPages(3)} />);
+    layOutRow(cards());
+
+    pointer("pointerdown", 10, 10, cards()[0]);
+    pointer("pointermove", 150, 10, window);
+    expect(pageNumbers()).toEqual(["2", "3", "1"]); // moved live under the pointer
+
+    act(() => {
+      window.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
+    });
+    expect(pageNumbers()).toEqual(["1", "2", "3"]); // ...and put back
+  });
+});
diff --git a/src/__tests__/Paths.test.ts b/src/__tests__/Paths.test.ts
new file mode 100644
index 0000000..ca61d74
--- /dev/null
+++ b/src/__tests__/Paths.test.ts
@@ -0,0 +1,114 @@
+import { describe, it, expect } from "vitest";
+import {
+  basename,
+  dirname,
+  isAbsolute,
+  normalizePath,
+  resolvePath,
+  toFileUri,
+  fromFileUri,
+  isPathWithin,
+} from "../lib/paths";
+
+// The helpers must accept BOTH separator styles: absolute paths reach the UI with
+// native separators (backslashes + drive letter on Windows), while backend "rel"
+// paths are always forward-slash. These cases pin both, so the same component code
+// is correct on Windows and Unix — the bug behind blank SVG/PNG in the markdown
+// viewer on Windows.
+
+describe("basename", () => {
+  it("handles POSIX and Windows absolute paths", () => {
+    expect(basename("/home/u/pics/cat.png")).toBe("cat.png");
+    expect(basename("C:\\Users\\u\\pics\\cat.png")).toBe("cat.png");
+    expect(basename("C:/Users/u/pics/cat.png")).toBe("cat.png");
+  });
+  it("handles forward-slash rel paths unchanged", () => {
+    expect(basename("docs/img/logo.svg")).toBe("logo.svg");
+  });
+  it("ignores trailing separators and bare roots", () => {
+    expect(basename("/home/u/dir/")).toBe("dir");
+    expect(basename("C:\\")).toBe("");
+    expect(basename("/")).toBe("");
+  });
+});
+
+describe("dirname", () => {
+  it("returns the containing directory in the input's style", () => {
+    expect(dirname("/home/u/readme.md")).toBe("/home/u");
+    expect(dirname("C:\\Users\\u\\readme.md")).toBe("C:\\Users\\u");
+  });
+  it("preserves the root", () => {
+    expect(dirname("/a")).toBe("/");
+    expect(dirname("C:\\a")).toBe("C:\\");
+  });
+});
+
+describe("isAbsolute", () => {
+  it("recognises POSIX, Windows drive, and UNC paths", () => {
+    expect(isAbsolute("/home/u")).toBe(true);
+    expect(isAbsolute("C:\\Users")).toBe(true);
+    expect(isAbsolute("C:/Users")).toBe(true);
+    expect(isAbsolute("\\\\server\\share")).toBe(true);
+    expect(isAbsolute("docs/img.png")).toBe(false);
+    expect(isAbsolute("img.png")).toBe(false);
+  });
+});
+
+describe("normalizePath", () => {
+  it("resolves . and .. preserving root and style", () => {
+    expect(normalizePath("/home/u/../v/./x")).toBe("/home/v/x");
+    expect(normalizePath("C:\\Users\\u\\..\\v\\.\\x")).toBe("C:\\Users\\v\\x");
+  });
+  it("preserves UNC shares as roots and clamps traversal there", () => {
+    expect(normalizePath("\\\\server\\share\\a\\..\\b")).toBe("\\\\server\\share\\b");
+    expect(normalizePath("\\\\server\\share\\..\\..\\escape")).toBe(
+      "\\\\server\\share\\escape",
+    );
+  });
+});
+
+describe("isPathWithin", () => {
+  it("handles Windows drives case-insensitively with mixed separators", () => {
+    expect(isPathWithin("c:\\Users\\A\\project\\src\\x.ts", "C:/users/a/project")).toBe(true);
+    expect(isPathWithin("C:\\work\\project-two", "c:\\work\\project")).toBe(false);
+  });
+  it("handles UNC paths case-insensitively and POSIX paths case-sensitively", () => {
+    expect(isPathWithin("\\\\SERVER\\Share\\Repo\\x", "\\\\server\\share\\repo")).toBe(true);
+    expect(isPathWithin("/Work/repo/x", "/work/repo")).toBe(false);
+    expect(isPathWithin("/work/repository", "/work/repo")).toBe(false);
+  });
+});
+
+describe("resolvePath", () => {
+  it("joins a relative target onto a directory, per OS", () => {
+    expect(resolvePath("/home/u/docs", "img/p.png")).toBe("/home/u/docs/img/p.png");
+    expect(resolvePath("C:\\Users\\u\\docs", "img/p.png")).toBe(
+      "C:\\Users\\u\\docs\\img\\p.png",
+    );
+  });
+  it("returns an absolute target as-is (normalised)", () => {
+    expect(resolvePath("/anywhere", "/etc/host")).toBe("/etc/host");
+    expect(resolvePath("C:\\anywhere", "D:\\data\\x.png")).toBe("D:\\data\\x.png");
+  });
+});
+
+describe("toFileUri / fromFileUri round-trip", () => {
+  it("encodes POSIX paths", () => {
+    expect(toFileUri("/home/u/my pics/a b.png")).toBe(
+      "file:///home/u/my%20pics/a%20b.png",
+    );
+  });
+  it("encodes Windows drive paths with the extra slash", () => {
+    expect(toFileUri("C:\\Users\\u\\a b.png")).toBe("file:///C:/Users/u/a%20b.png");
+  });
+  it("decodes back, stripping the Windows leading slash", () => {
+    expect(fromFileUri("file:///home/u/a%20b.png")).toBe("/home/u/a b.png");
+    expect(fromFileUri("file:///C:/Users/u/a%20b.png")).toBe("C:/Users/u/a b.png");
+    expect(fromFileUri("https://example.com")).toBeNull();
+  });
+  it("round-trips UNC paths without dropping server/share", () => {
+    const path = "\\\\server\\share\\folder\\a b.png";
+    expect(toFileUri(path)).toBe("file://server/share/folder/a%20b.png");
+    expect(fromFileUri(toFileUri(path))).toBe(path);
+  });
+});
diff --git a/src/__tests__/PdfOutline.test.ts b/src/__tests__/PdfOutline.test.ts
new file mode 100644
index 0000000..a1f5ccc
--- /dev/null
+++ b/src/__tests__/PdfOutline.test.ts
@@ -0,0 +1,203 @@
+/**
+ * The PDF outline model (#pdf-outline) — the pure resolver that turns pdf.js's
+ * raw bookmark tree into a jump-ready chapter tree.
+ *
+ * The load-bearing properties pinned here: destinations resolve to 1-based FILE
+ * pages (named strings and explicit arrays alike); an unresolvable destination
+ * degrades to a null page rather than failing the whole load; nesting and ids are
+ * preserved; and a document with no outline yields an empty list.
+ */
+import { describe, it, expect } from "vitest";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import {
+  loadOutline,
+  detectHeadings,
+  flattenOutline,
+  type OutlineNode,
+  type HeadingRun,
+} from "../components/embed/pdf/outline";
+
+/**
+ * A minimal fake pdf.js document: `getOutline` returns the given raw tree,
+ * `getPageIndex` maps a fake `{num}` ref to a 0-based index (num → num), and
+ * `getDestination` resolves a named string to an explicit dest array.
+ */
+function fakeDoc(
+  outline: unknown,
+  named: Record<string, unknown[]> = {},
+): PDFDocumentProxy {
+  return {
+    getOutline: async () => outline,
+    getDestination: async (name: string) => named[name] ?? null,
+    getPageIndex: async (ref: { num?: number }) => {
+      if (ref && typeof ref.num === "number") return ref.num;
+      throw new Error("bad ref");
+    },
+  } as unknown as PDFDocumentProxy;
+}
+
+describe("loadOutline", () => {
+  it("returns [] for a document with no outline", async () => {
+    expect(await loadOutline(fakeDoc(null))).toEqual([]);
+    expect(await loadOutline(fakeDoc([]))).toEqual([]);
+  });
+
+  it("resolves an explicit destination array to a 1-based page", async () => {
+    const doc = fakeDoc([
+      { title: "Chapter 1", dest: [{ num: 0 }, { name: "XYZ" }], items: [] },
+      { title: "Chapter 2", dest: [{ num: 4 }, { name: "XYZ" }], items: [] },
+    ]);
+    const nodes = await loadOutline(doc);
+    expect(nodes.map((n) => [n.title, n.page])).toEqual([
+      ["Chapter 1", 1],
+      ["Chapter 2", 5],
+    ]);
+  });
+
+  it("resolves a named destination via getDestination", async () => {
+    const doc = fakeDoc(
+      [{ title: "Intro", dest: "intro-anchor", items: [] }],
+      { "intro-anchor": [{ num: 2 }, { name: "Fit" }] },
+    );
+    const [node] = await loadOutline(doc);
+    expect(node.page).toBe(3);
+  });
+
+  it("accepts a numeric page index in slot 0", async () => {
+    const doc = fakeDoc([{ title: "Cover", dest: [3], items: [] }]);
+    const [node] = await loadOutline(doc);
+    expect(node.page).toBe(4);
+  });
+
+  it("keeps a node whose destination cannot resolve, with a null page", async () => {
+    const doc = fakeDoc([
+      { title: "Broken", dest: [{}, { name: "XYZ" }], items: [] },
+      { title: "Missing name", dest: "not-in-map", items: [] },
+      { title: "No dest", dest: null, items: [] },
+    ]);
+    const nodes = await loadOutline(doc);
+    expect(nodes.map((n) => n.page)).toEqual([null, null, null]);
+    expect(nodes.map((n) => n.title)).toEqual(["Broken", "Missing name", "No dest"]);
+  });
+
+  it("preserves nesting and assigns path-derived ids", async () => {
+    const doc = fakeDoc([
+      {
+        title: "Part I",
+        dest: [{ num: 0 }],
+        items: [
+          { title: "Section A", dest: [{ num: 1 }], items: [] },
+          { title: "Section B", dest: [{ num: 2 }], items: [] },
+        ],
+      },
+    ]);
+    const [part] = await loadOutline(doc);
+    expect(part.id).toBe("0");
+    expect(part.children.map((c) => c.id)).toEqual(["0.0", "0.1"]);
+    expect(part.children.map((c) => c.page)).toEqual([2, 3]);
+  });
+
+  it("falls back to 'Untitled' for a blank title", async () => {
+    const doc = fakeDoc([{ title: "", dest: [{ num: 0 }], items: [] }]);
+    const [node] = await loadOutline(doc);
+    expect(node.title).toBe("Untitled");
+  });
+});
+
+describe("detectHeadings (font-size fallback)", () => {
+  // A page of body text at size 10, one run per line.
+  const body = (page: number, lines: number, startY = 100): HeadingRun[] =>
+    Array.from({ length: lines }, (_, i) => ({
+      str: "the quick brown fox jumps over the lazy dog and runs on",
+      size: 10,
+      page,
+      x: 50,
+      y: startY + i * 12,
+    }));
+
+  const heading = (str: string, size: number, page: number, y: number): HeadingRun => ({
+    str,
+    size,
+    page,
+    x: 50,
+    y,
+  });
+
+  it("returns [] with no runs, or when nothing beats body size", () => {
+    expect(detectHeadings([])).toEqual([]);
+    expect(detectHeadings(body(1, 20))).toEqual([]);
+  });
+
+  it("picks out a run set distinctly larger than body text", () => {
+    const runs = [
+      heading("Chapter One", 20, 1, 40),
+      ...body(1, 20),
+      heading("Chapter Two", 20, 5, 40),
+      ...body(5, 20),
+    ];
+    const nodes = detectHeadings(runs);
+    expect(nodes.map((n) => [n.title, n.page])).toEqual([
+      ["Chapter One", 1],
+      ["Chapter Two", 5],
+    ]);
+  });
+
+  it("nests smaller headings under larger ones by size", () => {
+    const runs = [
+      heading("Part I", 22, 1, 40),
+      heading("Section A", 16, 1, 80),
+      heading("Section B", 16, 2, 40),
+      heading("Part II", 22, 5, 40),
+      ...body(1, 15),
+      ...body(2, 15),
+      ...body(5, 15),
+    ];
+    const nodes = detectHeadings(runs);
+    expect(nodes.map((n) => n.title)).toEqual(["Part I", "Part II"]);
+    expect(nodes[0].children.map((c) => [c.title, c.page])).toEqual([
+      ["Section A", 1],
+      ["Section B", 2],
+    ]);
+  });
+
+  it("groups runs on the same line into one heading", () => {
+    const runs = [
+      heading("Chapter ", 20, 1, 40),
+      { ...heading("One", 20, 1, 40), x: 140 },
+      ...body(1, 20),
+    ];
+    expect(detectHeadings(runs).map((n) => n.title)).toEqual(["Chapter One"]);
+  });
+
+  it("drops running headers (same big text repeated across many pages)", () => {
+    const runs: HeadingRun[] = [];
+    // A running header appearing at the top of 8 pages, plus real body text.
+    for (let p = 1; p <= 8; p++) {
+      runs.push(heading("A Very Long Book Title", 14, p, 20));
+      runs.push(...body(p, 20));
+    }
+    // One genuine chapter heading, on a single page.
+    runs.push(heading("Real Chapter", 20, 3, 60));
+    const nodes = detectHeadings(runs);
+    expect(nodes.map((n) => n.title)).toEqual(["Real Chapter"]);
+  });
+});
+
+describe("flattenOutline", () => {
+  it("flattens in visit order with depths", () => {
+    const tree: OutlineNode[] = [
+      {
+        id: "0",
+        title: "A",
+        page: 1,
+        children: [{ id: "0.0", title: "A.1", page: 2, children: [] }],
+      },
+      { id: "1", title: "B", page: 5, children: [] },
+    ];
+    expect(flattenOutline(tree).map((e) => [e.node.title, e.depth])).toEqual([
+      ["A", 0],
+      ["A.1", 1],
+      ["B", 0],
+    ]);
+  });
+});
diff --git a/src/__tests__/PdfPageDrag.test.ts b/src/__tests__/PdfPageDrag.test.ts
new file mode 100644
index 0000000..e33bf69
--- /dev/null
+++ b/src/__tests__/PdfPageDrag.test.ts
@@ -0,0 +1,257 @@
+/**
+ * Tests for cross-viewer / cross-window PDF page dragging (`stores/pdfDrag`).
+ *
+ * The two things that MUST hold, because getting either wrong loses a page:
+ *
+ *  1. **Exactly one window claims a drop.** Every window receives the same broadcast
+ *     END; only the one whose outer rect actually contains the released cursor may
+ *     take the pages and acknowledge. A window the cursor is nowhere near must stay
+ *     silent — otherwise the pages land in two documents at once.
+ *
+ *  2. **A Shift-drag (a MOVE) deletes from the source only once the drop is
+ *     acknowledged.** Released over empty desktop, or over a window that refuses it,
+ *     the pages must survive.
+ *
+ * Tauri's event bus and window geometry are mocked, so the whole protocol runs in
+ * jsdom without a real second window.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// ── Tauri mocks ──────────────────────────────────────────────────────────────
+/** Every event emitted by the code under test, in order. */
+const emitted: { event: string; payload: unknown }[] = [];
+/** Handlers registered via `listen`, by event name. */
+const handlers = new Map<string, ((ev: { payload: unknown }) => void)[]>();
+
+/** Deliver an event to this window's listeners, as the Tauri bus would. */
+function deliver(event: string, payload: unknown) {
+  for (const h of handlers.get(event) ?? []) h({ payload });
+}
+
+vi.mock("@tauri-apps/api/event", () => ({
+  emit: (event: string, payload: unknown) => {
+    emitted.push({ event, payload });
+    return Promise.resolve();
+  },
+  listen: (event: string, handler: (ev: { payload: unknown }) => void) => {
+    const list = handlers.get(event) ?? [];
+    list.push(handler);
+    handlers.set(event, list);
+    return Promise.resolve(() => {
+      const cur = handlers.get(event) ?? [];
+      handlers.set(
+        event,
+        cur.filter((h) => h !== handler),
+      );
+    });
+  },
+}));
+
+// This window sits at physical (1000,1000), 800x600, scale 1. So desktop point
+// (1100,1100) is inside it (client 100,100), and (50,50) is far outside.
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({
+    label: "main",
+    innerPosition: () => Promise.resolve({ x: 1000, y: 1000 }),
+    outerPosition: () => Promise.resolve({ x: 1000, y: 1000 }),
+    outerSize: () => Promise.resolve({ width: 800, height: 600 }),
+    scaleFactor: () => Promise.resolve(1),
+  }),
+  cursorPosition: () => Promise.resolve({ x: 0, y: 0 }),
+}));
+
+import {
+  registerPageStrip,
+  resolveDropTarget,
+  listenForeignPageDrags,
+  awaitDropAck,
+  PDF_DRAG_START,
+  PDF_DRAG_END,
+  PDF_DROP_ACK,
+  type PageTransfer,
+} from "../stores/pdfDrag";
+
+/** A strip occupying client rect (0,0)-(200,400), which imports into `landed`. */
+function mountStrip(id: string, landed: { transfer: PageTransfer; index: number }[]) {
+  const el = document.createElement("div");
+  el.getBoundingClientRect = () =>
+    ({ left: 0, top: 0, right: 200, bottom: 400, width: 200, height: 400 }) as DOMRect;
+  document.body.appendChild(el);
+  return registerPageStrip(id, {
+    el,
+    indexAt: () => 3, // a fixed insertion point; the geometry itself is tested elsewhere
+    onImport: (transfer, index) => landed.push({ transfer, index }),
+    setCaret: () => {},
+  });
+}
+
+/** Let the mocked promises (snapshotFrame, listen registration) settle. */
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+describe("cross-window page drops", () => {
+  let unlisten: (() => void) | null = null;
+
+  beforeEach(() => {
+    emitted.length = 0;
+    handlers.clear();
+    document.body.innerHTML = "";
+  });
+
+  afterEach(() => {
+    unlisten?.();
+    unlisten = null;
+  });
+
+  it("claims a drop released over THIS window, and acknowledges it", async () => {
+    const landed: { transfer: PageTransfer; index: number }[] = [];
+    const unmount = mountStrip("rail-a", landed);
+    unlisten = await listenForeignPageDrags();
+
+    // A drag starts in another window; we snapshot our own frame.
+    deliver(PDF_DRAG_START, { originLabel: "detached_1", count: 2 });
+    await settle();
+
+    // ...and is released at desktop (1100,1100) — inside us, over the strip.
+    deliver(PDF_DRAG_END, {
+      originLabel: "detached_1",
+      token: "clip1",
+      count: 2,
+      physX: 1100,
+      physY: 1100,
+      shift: false,
+      cancelled: false,
+    });
+
+    expect(landed).toEqual([{ transfer: { token: "clip1", count: 2 }, index: 3 }]);
+    expect(emitted).toContainEqual({
+      event: PDF_DROP_ACK,
+      payload: { token: "clip1", accepted: true },
+    });
+    unmount();
+  });
+
+  it("ignores a drop released over a DIFFERENT window, and does not acknowledge it", async () => {
+    const landed: { transfer: PageTransfer; index: number }[] = [];
+    const unmount = mountStrip("rail-a", landed);
+    unlisten = await listenForeignPageDrags();
+
+    deliver(PDF_DRAG_START, { originLabel: "detached_1", count: 1 });
+    await settle();
+
+    // Released at desktop (50,50): nowhere near us. Were we to claim it, the pages
+    // would be inserted in two documents at once.
+    deliver(PDF_DRAG_END, {
+      originLabel: "detached_1",
+      token: "clip9",
+      count: 1,
+      physX: 50,
+      physY: 50,
+      shift: true,
+      cancelled: false,
+    });
+
+    expect(landed).toEqual([]);
+    expect(emitted.filter((e) => e.event === PDF_DROP_ACK)).toEqual([]);
+    unmount();
+  });
+
+  it("ignores the drag it emitted itself (the bus echoes to the sender)", async () => {
+    const landed: { transfer: PageTransfer; index: number }[] = [];
+    const unmount = mountStrip("rail-a", landed);
+    unlisten = await listenForeignPageDrags();
+
+    // Same label as this window: our OWN drag, already handled through the DOM.
+    // Acting on it as well would import the pages a second time.
+    deliver(PDF_DRAG_START, { originLabel: "main", count: 1 });
+    await settle();
+    deliver(PDF_DRAG_END, {
+      originLabel: "main",
+      token: "clip2",
+      count: 1,
+      physX: 1100,
+      physY: 1100,
+      shift: false,
+      cancelled: false,
+    });
+
+    expect(landed).toEqual([]);
+    expect(emitted.filter((e) => e.event === PDF_DROP_ACK)).toEqual([]);
+    unmount();
+  });
+
+  it("does not claim a cancelled drag", async () => {
+    const landed: { transfer: PageTransfer; index: number }[] = [];
+    const unmount = mountStrip("rail-a", landed);
+    unlisten = await listenForeignPageDrags();
+
+    deliver(PDF_DRAG_START, { originLabel: "detached_1", count: 1 });
+    await settle();
+    deliver(PDF_DRAG_END, {
+      originLabel: "detached_1",
+      token: "clip3",
+      count: 1,
+      physX: 1100,
+      physY: 1100,
+      shift: false,
+      cancelled: true,
+    });
+
+    expect(landed).toEqual([]);
+    unmount();
+  });
+});
+
+describe("the move (Shift) handshake", () => {
+  beforeEach(() => {
+    emitted.length = 0;
+    handlers.clear();
+  });
+
+  it("reports the drop as taken once a window acknowledges it", async () => {
+    const pending = awaitDropAck("clip1", 1000);
+    await settle();
+    deliver(PDF_DROP_ACK, { token: "clip1", accepted: true });
+    await expect(pending).resolves.toBe(true);
+  });
+
+  it("does NOT report a drop as taken when it was refused", async () => {
+    const pending = awaitDropAck("clip1", 1000);
+    await settle();
+    deliver(PDF_DROP_ACK, { token: "clip1", accepted: false });
+    await expect(pending).resolves.toBe(false);
+  });
+
+  it("ignores an acknowledgement for a DIFFERENT transfer", async () => {
+    const pending = awaitDropAck("clip1", 60);
+    await settle();
+    deliver(PDF_DROP_ACK, { token: "someone-elses", accepted: true });
+    // Nobody acknowledged OUR pages, so a Shift-drag must not delete them.
+    await expect(pending).resolves.toBe(false);
+  });
+
+  it("gives up when nobody claims the drop, so a move never destroys the pages", async () => {
+    // Released over empty desktop: no window takes them. The source keeps them.
+    await expect(awaitDropAck("clip1", 60)).resolves.toBe(false);
+  });
+});
+
+describe("resolveDropTarget", () => {
+  beforeEach(() => {
+    document.body.innerHTML = "";
+  });
+
+  it("finds the strip under the point, and where in it the pages land", () => {
+    const landed: { transfer: PageTransfer; index: number }[] = [];
+    const unmount = mountStrip("rail-a", landed);
+    expect(resolveDropTarget({ x: 100, y: 100 })).toEqual({ stripId: "rail-a", index: 3 });
+    expect(resolveDropTarget({ x: 900, y: 900 })).toBeNull(); // outside every strip
+    unmount();
+  });
+
+  it("skips the strip the drag came from — that is a reorder, not a transfer", () => {
+    const landed: { transfer: PageTransfer; index: number }[] = [];
+    const unmount = mountStrip("rail-a", landed);
+    expect(resolveDropTarget({ x: 100, y: 100 }, "rail-a")).toBeNull();
+    unmount();
+  });
+});
diff --git a/src/__tests__/PdfSave.test.ts b/src/__tests__/PdfSave.test.ts
new file mode 100644
index 0000000..d13d647
--- /dev/null
+++ b/src/__tests__/PdfSave.test.ts
@@ -0,0 +1,117 @@
+/**
+ * Tests for the one place a PDF is actually written (`components/embed/pdf/pdfDoc`).
+ *
+ * These run pdf-lib end to end in memory — real PDFs are built, saved, and read back
+ * — so what is asserted is the bytes' actual page order, size and rotation, not a
+ * mock's call log. Nothing touches the disk.
+ */
+import { describe, it, expect } from "vitest";
+import { PDFDocument, degrees } from "pdf-lib";
+import { buildPdf, type PdfSources } from "../components/embed/pdf/pdfDoc";
+import { SELF, initialPages, pagesOf, insertPages, rotatePages, deletePages, movePages } from "../lib/viewers/pageModel";
+
+/**
+ * A PDF whose pages have distinct, recognisable widths (100, 200, 300…), so the page
+ * order of a rebuilt document can be read straight back off the geometry.
+ */
+async function makePdf(widths: number[], rotate = 0): Promise<Uint8Array> {
+  const doc = await PDFDocument.create();
+  for (const w of widths) {
+    const page = doc.addPage([w, 400]);
+    if (rotate) page.setRotation(degrees(rotate));
+  }
+  return doc.save();
+}
+
+/** The widths of each page of a saved PDF, in order — i.e. which page went where. */
+async function widthsOf(bytes: Uint8Array): Promise<number[]> {
+  const doc = await PDFDocument.load(bytes);
+  return doc.getPages().map((p) => Math.round(p.getWidth()));
+}
+
+async function rotationsOf(bytes: Uint8Array): Promise<number[]> {
+  const doc = await PDFDocument.load(bytes);
+  return doc.getPages().map((p) => p.getRotation().angle);
+}
+
+/** Sources map holding just the document under test — `openSource` needs pdf.js, so
+ *  the bytes are supplied directly (only `bytes` is read at save time). */
+const sourcesOf = (entries: Record<string, Uint8Array>): PdfSources =>
+  new Map(
+    Object.entries(entries).map(([id, bytes]) => [
+      id,
+      { bytes, doc: undefined as never },
+    ]),
+  );
+
+describe("buildPdf", () => {
+  it("writes the pages in the arrangement's order", async () => {
+    const bytes = await makePdf([100, 200, 300]);
+    const sources = sourcesOf({ [SELF]: bytes });
+
+    const pages = initialPages(3);
+    // Drag page 3 to the front.
+    const moved = movePages(pages, [pages[2].id], 0);
+
+    expect(await widthsOf(await buildPdf(moved, sources))).toEqual([300, 100, 200]);
+  });
+
+  it("drops deleted pages from the written file", async () => {
+    const bytes = await makePdf([100, 200, 300]);
+    const sources = sourcesOf({ [SELF]: bytes });
+
+    const pages = initialPages(3);
+    const kept = deletePages(pages, [pages[1].id]);
+
+    expect(await widthsOf(await buildPdf(kept, sources))).toEqual([100, 300]);
+  });
+
+  it("merges pages from a second document, interleaved with the first", async () => {
+    const mine = await makePdf([100, 200]);
+    const other = await makePdf([700, 800, 900]);
+    const sources = sourcesOf({ [SELF]: mine, "src1": other });
+
+    const pages = initialPages(2);
+    // Splice the other document's pages 1-2 in between my two pages.
+    const merged = insertPages(pages, pagesOf("src1", 3).slice(0, 2), 1);
+
+    expect(await widthsOf(await buildPdf(merged, sources))).toEqual([100, 700, 800, 200]);
+  });
+
+  it("adds the viewer's turn to the page's existing rotation", async () => {
+    // The source page is already turned 90°; the viewer turns it another 90°.
+    const bytes = await makePdf([100, 200], 90);
+    const sources = sourcesOf({ [SELF]: bytes });
+
+    const pages = initialPages(2);
+    const turned = rotatePages(pages, [pages[0].id], 90);
+
+    expect(await rotationsOf(await buildPdf(turned, sources))).toEqual([180, 90]);
+  });
+
+  it("gives a duplicated page its own copy, turnable on its own", async () => {
+    const bytes = await makePdf([100, 200]);
+    const sources = sourcesOf({ [SELF]: bytes });
+
+    // Page 1 twice, with only the second copy turned — the thing the old
+    // rotation-keyed-by-page-number model could not represent.
+    const pages = initialPages(2);
+    const dup = insertPages(pages, [pages[0]], 1);
+    const turned = rotatePages(dup, [dup[1].id], 90);
+
+    const out = await buildPdf(turned, sources);
+    expect(await widthsOf(out)).toEqual([100, 100, 200]);
+    expect(await rotationsOf(out)).toEqual([0, 90, 0]);
+  });
+
+  it("refuses to write a document with no pages", async () => {
+    const sources = sourcesOf({ [SELF]: await makePdf([100]) });
+    await expect(buildPdf([], sources)).rejects.toThrow(/at least one page/);
+  });
+
+  it("fails loudly when a merged source is no longer open", async () => {
+    const sources = sourcesOf({ [SELF]: await makePdf([100]) });
+    const orphan = pagesOf("gone", 1);
+    await expect(buildPdf(orphan, sources)).rejects.toThrow(/no longer open/);
+  });
+});
diff --git a/src/__tests__/PillRunningIndicator.test.ts b/src/__tests__/PillRunningIndicator.test.ts
index a826c8b..8a5b13e 100644
--- a/src/__tests__/PillRunningIndicator.test.ts
+++ b/src/__tests__/PillRunningIndicator.test.ts
@@ -1,19 +1,27 @@
 /**
  * Tests for the running-task indicator data source (#9, Group D):
- * - notePtyOutput marks a PTY's scope busy for the duration of the window
+ * - sustained PTY output marks a scope/tab busy (onset debounce ignores blips)
  * - busy state clears once output goes stale
  * - only scopes whose tabs produced recent output are flagged
+ * Plus the per-tab/-scope "needs attention" state an unwatched agent tab raises
+ * once its output goes quiet — finished (done) vs blocked on a prompt (decision).
+ * Both "working" and "done" require the tab to have been COMMANDED this session
+ * (noteUserInput): a restored tab replaying its resume banner shows nothing.
  */
 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
 import {
   useActivityStore,
   notePtyOutput,
+  notePtySpawn,
+  noteUserInput,
   _clearPtyActivityForTest,
 } from "../stores/activity";
 import { useTabsStore } from "../stores/tabs";
 
+// PTY ids are composed `<scope>:<tabKey>` in production (what the backend emits
+// and AppShell feeds into notePtyOutput), and every derived map is keyed the same
+// way, so the tests feed and read the same form.
 function seedTabs() {
-  // Two project scopes, each with one PTY tab whose key doubles as the PTY id.
   useTabsStore.setState({
     tabsByScope: {
       "proj-a": [
@@ -23,29 +31,123 @@ function seedTabs() {
         { key: "shell-1", label: "b", cmd: "", cwd: "/b", kind: "shell" },
       ],
     },
+    // Viewing project B, so proj-a's agent-1 is a background tab: never looked at.
+    scope: "proj-b",
+    layoutByScope: {
+      "proj-a": { type: "group", id: "g-a", tabKeys: ["agent-1"], activeKey: "agent-1" },
+      "proj-b": { type: "group", id: "g-b", tabKeys: ["shell-1"], activeKey: "shell-1" },
+    },
+    detachedGroupsByScope: {},
   });
 }
 
+// Feed a PTY output (gaps < BUSY_WINDOW_MS) long enough to age past the onset
+// debounce (WORK_ONSET_MS = 1500) — the shape of a resume banner or replayed
+// transcript when nothing has been typed into the tab.
+function replayOutput(id: string, totalMs = 1600) {
+  notePtyOutput(id, "working…\n");
+  for (let elapsed = 0; elapsed < totalMs; elapsed += 400) {
+    vi.advanceTimersByTime(400);
+    notePtyOutput(id, "working…\n");
+  }
+}
+
+// The same sustained output, but COMMANDED: the user typed into the tab first,
+// which is what lets it register as "working" at all.
+function sustainOutput(id: string, totalMs = 1600) {
+  noteUserInput(id);
+  replayOutput(id, totalMs);
+}
+
+// Same, but for several PTYs at once. They must be fed in lockstep: sustaining
+// them one after the other would let the first go stale (its last output ages
+// past BUSY_WINDOW_MS) while the second is still being fed.
+function sustainAll(ids: string[], totalMs = 1600) {
+  ids.forEach((id) => {
+    noteUserInput(id);
+    notePtyOutput(id, "working…\n");
+  });
+  for (let elapsed = 0; elapsed < totalMs; elapsed += 400) {
+    vi.advanceTimersByTime(400);
+    ids.forEach((id) => notePtyOutput(id, "working…\n"));
+  }
+}
+
+// An agent turn that ends with an ordinary result on screen, then the silence
+// that tells the store the turn is over (> DONE_QUIET_MS = 2500).
+function runThenFinish(id: string) {
+  sustainOutput(id);
+  notePtyOutput(id, "\x1b[1mAll 12 tests pass.\x1b[0m\n");
+  vi.advanceTimersByTime(2600);
+}
+
+// An agent turn that ends on a permission prompt — colour-coded, as it arrives
+// off the wire — then the short silence a blocked agent sits in.
+function runThenPrompt(id: string) {
+  sustainOutput(id);
+  notePtyOutput(
+    id,
+    "Do you want to make this edit?\n\x1b[32m❯ 1. Yes\x1b[0m\n  2. No, tell Claude what to do\n",
+  );
+  vi.advanceTimersByTime(700); // past DECISION_QUIET_MS (600), well under DONE_QUIET_MS
+}
+
 describe("activity store running indicator", () => {
   beforeEach(() => {
     vi.useFakeTimers();
     seedTabs();
     _clearPtyActivityForTest();
-    useActivityStore.setState({ busyByScope: {}, busyByTab: {} });
   });
   afterEach(() => {
     vi.useRealTimers();
   });
 
-  it("flags the scope of a PTY that just emitted output", () => {
-    notePtyOutput("agent-1");
+  it("flags the scope of a PTY producing sustained output", () => {
+    sustainOutput("proj-a:agent-1");
     useActivityStore.getState().recompute();
     expect(useActivityStore.getState().busyByScope["proj-a"]).toBe(true);
     expect(useActivityStore.getState().busyByScope["proj-b"]).toBeUndefined();
   });
 
+  it("ignores a lone output blip (onset debounce)", () => {
+    noteUserInput("proj-a:agent-1");
+    notePtyOutput("proj-a:agent-1");
+    vi.advanceTimersByTime(300); // within the busy window, but well under onset
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().busyByScope["proj-a"] ?? false).toBe(false);
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"] ?? false).toBe(false);
+  });
+
+  it("keeps a bursty stream working across a short quiet gap", () => {
+    // Gaps under BUSY_WINDOW_MS belong to the SAME burst, so they must not reset
+    // the onset — otherwise bursty agent output could never age past the debounce
+    // and the working indicator would never appear at all.
+    noteUserInput("proj-a:agent-1");
+    notePtyOutput("proj-a:agent-1"); // onset at t0
+    vi.advanceTimersByTime(700); // < BUSY_WINDOW_MS (800) → still one burst
+    notePtyOutput("proj-a:agent-1");
+    vi.advanceTimersByTime(700);
+    notePtyOutput("proj-a:agent-1");
+    vi.advanceTimersByTime(200); // t=1600: past WORK_ONSET_MS, last output 200ms ago
+
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"]).toBe(true);
+  });
+
+  it("re-applies the onset debounce to a burst that starts after a long gap", () => {
+    sustainOutput("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"]).toBe(true);
+
+    vi.advanceTimersByTime(900); // > BUSY_WINDOW_MS → the burst has ended
+    notePtyOutput("proj-a:agent-1"); // a fresh burst: onset restarts from here
+    useActivityStore.getState().recompute();
+    // Recent output, but the new burst has not been sustained — not working yet.
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"] ?? false).toBe(false);
+  });
+
   it("clears busy once output is older than the window", () => {
-    notePtyOutput("agent-1");
+    sustainOutput("proj-a:agent-1");
     useActivityStore.getState().recompute();
     expect(useActivityStore.getState().busyByScope["proj-a"]).toBe(true);
 
@@ -55,20 +157,393 @@ describe("activity store running indicator", () => {
   });
 
   it("does not flag a scope whose PTYs have been silent", () => {
-    notePtyOutput("shell-1");
+    sustainOutput("proj-b:shell-1");
     useActivityStore.getState().recompute();
     expect(useActivityStore.getState().busyByScope["proj-b"]).toBe(true);
     expect(useActivityStore.getState().busyByScope["proj-a"] ?? false).toBe(false);
   });
 
-  it("flags the individual tab that emitted output and clears when stale", () => {
-    notePtyOutput("agent-1");
+  it("flags the individual tab that produced output and clears when stale", () => {
+    sustainOutput("proj-a:agent-1");
     useActivityStore.getState().recompute();
-    expect(useActivityStore.getState().busyByTab["agent-1"]).toBe(true);
-    expect(useActivityStore.getState().busyByTab["shell-1"]).toBeUndefined();
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"]).toBe(true);
+    expect(useActivityStore.getState().busyByTab["proj-b:shell-1"]).toBeUndefined();
 
     vi.advanceTimersByTime(1000); // > BUSY_WINDOW_MS (800)
     useActivityStore.getState().recompute();
-    expect(useActivityStore.getState().busyByTab["agent-1"] ?? false).toBe(false);
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"] ?? false).toBe(false);
+  });
+
+  it("never marks an uncommanded tab working (restored tab replaying its resume banner)", () => {
+    // On app launch / project reopen a resumed agent streams its whole prior
+    // transcript — sustained real output, but nobody asked it for anything, so
+    // it must not pulse "working" nor light the project pill.
+    replayOutput("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"] ?? false).toBe(false);
+    expect(useActivityStore.getState().busyByScope["proj-a"] ?? false).toBe(false);
+  });
+});
+
+describe("activity store attention state", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    seedTabs();
+    _clearPtyActivityForTest();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("flags an agent that went quiet with an unread result as done", () => {
+    // The case that used to leave the tab plain white: the agent simply stops.
+    // No terminal bell is involved — most agents never ring one.
+    runThenFinish("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBe("done");
+  });
+
+  it("flags an agent waiting on a choice prompt as a decision", () => {
+    runThenPrompt("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBe("decision");
+  });
+
+  it("never flags uncommanded output as done (resume/restart replay)", () => {
+    // The restored-tab case: on launch or project reopen the agent replays its
+    // banner and prior transcript, then goes quiet. Nobody typed anything, so
+    // the quiet is not a finished turn — no green tab, no green pill.
+    replayOutput("proj-a:agent-1");
+    notePtyOutput("proj-a:agent-1", "── session resumed ──\n");
+    vi.advanceTimersByTime(2600); // well past DONE_QUIET_MS
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBeUndefined();
+  });
+
+  it("still flags a live prompt in uncommanded output (resumed agent at a real decision)", () => {
+    // A resumed agent genuinely sitting at an unanswered prompt is real signal:
+    // decision is deliberately exempt from the commanded-this-session gate.
+    notePtyOutput(
+      "proj-a:agent-1",
+      "Do you want to make this edit?\n\x1b[32m❯ 1. Yes\x1b[0m\n  2. No, tell Claude what to do\n",
+    );
+    vi.advanceTimersByTime(700); // past DECISION_QUIET_MS
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+  });
+
+  it("wipes the input stamp on respawn, so the successor's replay stays silent", () => {
+    runThenFinish("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+
+    // The project is closed and reopened in-session: the PTY respawns under the
+    // same id. Input sent to the old program mustn't license the new one.
+    notePtySpawn("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+
+    replayOutput("proj-a:agent-1"); // the respawned agent replays the session
+    vi.advanceTimersByTime(2600);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+    expect(useActivityStore.getState().busyByTab["proj-a:agent-1"] ?? false).toBe(false);
+  });
+
+  it("says nothing while the agent is still streaming", () => {
+    sustainOutput("proj-a:agent-1");
+    vi.advanceTimersByTime(300); // still mid-burst
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+  });
+
+  it("stops calling a prompt live once it has been answered", () => {
+    // The tail is per output BURST. A prompt sits quiet while it waits on the
+    // human, so the work that follows the answer necessarily arrives as a fresh
+    // burst — which drops the answered menu from the tail instead of leaving the
+    // tab stuck on orange for the rest of the turn.
+    runThenPrompt("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+
+    vi.advanceTimersByTime(4000); // the human reads the prompt and answers
+    runThenFinish("proj-a:agent-1"); // back to work, then a plain result
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+  });
+
+  it("rolls a decision up over a done when one scope holds both", () => {
+    // The project pill shows a single kind for the whole scope, so a tab blocked
+    // on a decision must outrank a sibling that merely finished.
+    useTabsStore.setState({
+      tabsByScope: {
+        "proj-a": [
+          { key: "agent-1", label: "a", cmd: "claude", cwd: "/a", kind: "agent" },
+          { key: "agent-2", label: "a2", cmd: "claude", cwd: "/a", kind: "agent" },
+        ],
+      },
+    });
+    runThenFinish("proj-a:agent-1");
+    runThenPrompt("proj-a:agent-2");
+    useActivityStore.getState().recompute();
+
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-2"]).toBe("decision");
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBe("decision");
+  });
+
+  it("never flags a tab that lives in a detached popout (#42)", () => {
+    // The popout has its own window and its own tab strip; this window can't tell
+    // whether the user is watching it, and nothing here could ever clear a flag
+    // raised for it — so it would have left the project pill glowing for good.
+    useTabsStore.setState({
+      layoutByScope: { "proj-a": null },
+      detachedGroupsByScope: {
+        "proj-a": [
+          {
+            id: "d-1",
+            label: "detached-proj-a-g-a",
+            subtree: {
+              type: "group",
+              id: "g-a",
+              tabKeys: ["agent-1"],
+              activeKey: "agent-1",
+            },
+          },
+        ],
+      },
+    });
+    runThenFinish("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBeUndefined();
+  });
+
+  it("never flags a non-agent (shell) tab", () => {
+    // A shell finishing a build is not an agent asking to be looked at.
+    runThenFinish("proj-b:shell-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-b:shell-1"]).toBeUndefined();
+  });
+
+  it("does not flag the tab the user is looking at, and treats its output as read", () => {
+    useTabsStore.setState({ scope: "proj-a" }); // agent-1 is now the visible tab
+    runThenFinish("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+
+    // Looking away afterwards must not raise a flag for output already seen.
+    useTabsStore.setState({ scope: "proj-b" });
+    vi.advanceTimersByTime(5000);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+  });
+
+  it("keeps flagging a decision on the tab the user IS looking at", () => {
+    // A blocked agent stays blocked while you look at it — the flag is about the
+    // agent's state, not about unread output. (Contrast the "done" case above:
+    // that one IS about unread output, so viewing the tab retires it.)
+    useTabsStore.setState({ scope: "proj-a" }); // agent-1 is now the visible tab
+    runThenPrompt("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+
+    // And it holds tick after tick: looking at a prompt does not answer it.
+    vi.advanceTimersByTime(5000);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBe("decision");
+  });
+
+  it("retires a watched decision when it is answered", () => {
+    // Input is what clears it — the keystroke that picks an option drops the tail
+    // the prompt was matched from (noteUserInput), so the answered menu can't be
+    // matched again as a live one even before the agent's reply arrives.
+    useTabsStore.setState({ scope: "proj-a" });
+    runThenPrompt("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+
+    noteUserInput("proj-a:agent-1"); // the human picks an option
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+  });
+
+  it("does not clear a live decision when the tab is merely viewed", () => {
+    // Switching TO the tab marks its output read (clearAttention), which must not
+    // knock the lamp out for one tick just for `recompute` to raise it right back.
+    runThenPrompt("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+
+    useActivityStore.getState().clearAttention("proj-a:agent-1");
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("decision");
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBe("decision");
+  });
+
+  it("clears the flag (and scope rollup) once the tab is viewed, for good", () => {
+    runThenFinish("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+
+    useActivityStore.getState().clearAttention("proj-a:agent-1");
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+    expect(useActivityStore.getState().attentionByScope["proj-a"]).toBeUndefined();
+
+    // And the next interval tick must not raise it again from the same output.
+    vi.advanceTimersByTime(1000);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBeUndefined();
+  });
+
+  it("lets a terminal bell shortcut the quiet window", () => {
+    // An agent that rings the bell is asking for attention NOW, so it doesn't
+    // have to sit out the full silence to count as finished.
+    sustainOutput("proj-a:agent-1");
+    notePtyOutput("proj-a:agent-1", "Done.\n");
+    useActivityStore.getState().noteBell("proj-a:agent-1");
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+  });
+
+  it("ignores a bell from a bare (colon-less) pty id", () => {
+    useActivityStore.getState().noteBell("agent-1");
+    expect(useActivityStore.getState().attentionByTab["agent-1"]).toBeUndefined();
+  });
+});
+
+describe("activity store per-scope status counts (pill status bars)", () => {
+  // Three agent tabs in one project, so a scope can hold several states at once
+  // — the whole point of the bars over the old single-state pill glow.
+  function seedThreeAgents() {
+    useTabsStore.setState({
+      tabsByScope: {
+        "proj-a": [
+          { key: "agent-1", label: "a1", cmd: "claude", cwd: "/a", kind: "agent" },
+          { key: "agent-2", label: "a2", cmd: "claude", cwd: "/a", kind: "agent" },
+          { key: "agent-3", label: "a3", cmd: "claude", cwd: "/a", kind: "agent" },
+        ],
+      },
+      scope: "proj-b", // none of proj-a's tabs are being looked at
+      layoutByScope: {
+        "proj-a": {
+          type: "group",
+          id: "g-a",
+          tabKeys: ["agent-1", "agent-2", "agent-3"],
+          activeKey: "agent-1",
+        },
+      },
+      detachedGroupsByScope: {},
+    });
+  }
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    seedThreeAgents();
+    _clearPtyActivityForTest();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("counts one working bar per working tab", () => {
+    sustainAll(["proj-a:agent-1", "proj-a:agent-2"]);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toEqual({
+      working: 2,
+      decision: 0,
+      done: 0,
+    });
+  });
+
+  it("tallies decision and done bars separately", () => {
+    runThenPrompt("proj-a:agent-1");
+    runThenFinish("proj-a:agent-2");
+    runThenFinish("proj-a:agent-3");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toEqual({
+      working: 0,
+      decision: 1,
+      done: 2,
+    });
+  });
+
+  it("counts a working tab once — working outranks its own attention flag", () => {
+    // Same precedence the tab bar uses for its glow, so the bars can't disagree
+    // with the tabs they stand for (and the bar count never exceeds the tab count).
+    runThenFinish("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().attentionByTab["proj-a:agent-1"]).toBe("done");
+
+    sustainOutput("proj-a:agent-1"); // it's off again
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toEqual({
+      working: 1,
+      decision: 0,
+      done: 0,
+    });
+  });
+
+  it("counts the tabs of the SELECTED project too, including the visible one", () => {
+    // The strip answers "is anything still running in there?" — a question the
+    // project you are currently in has just as much right to answer. Selecting a
+    // project used to empty its bars, which read as "nothing running".
+    useTabsStore.setState({ scope: "proj-a" }); // agent-1 is the visible tab
+    sustainAll(["proj-a:agent-1", "proj-a:agent-2"]);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toEqual({
+      working: 2,
+      decision: 0,
+      done: 0,
+    });
+  });
+
+  it("keeps a decision bar for the selected project's visible tab", () => {
+    useTabsStore.setState({ scope: "proj-a" }); // agent-1 is the visible tab
+    runThenPrompt("proj-a:agent-1");
+    vi.advanceTimersByTime(200); // let the prompt's own output age out of the busy
+    // window (800ms), so the tab reads as blocked rather than still writing
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toEqual({
+      working: 0,
+      decision: 1,
+      done: 0,
+    });
+  });
+
+  it("drops the scope entirely once its tabs go idle with nothing to report", () => {
+    sustainOutput("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toBeDefined();
+
+    // Idle, but not yet long enough to call the turn done: no bars at all.
+    vi.advanceTimersByTime(1000); // > BUSY_WINDOW_MS, < DONE_QUIET_MS
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toBeUndefined();
+  });
+
+  it("drops a done bar once its tab is viewed", () => {
+    runThenFinish("proj-a:agent-1");
+    runThenFinish("proj-a:agent-2");
+    useActivityStore.getState().recompute();
+    useActivityStore.getState().clearAttention("proj-a:agent-1");
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toEqual({
+      working: 0,
+      decision: 0,
+      done: 1,
+    });
+  });
+
+  it("keeps a scope's counts object identical when nothing changed", () => {
+    // The pill selector reads this object by reference, so a recompute tick that
+    // changes nothing must not hand it a fresh one — that would re-render every
+    // pill on every interval.
+    sustainOutput("proj-a:agent-1");
+    useActivityStore.getState().recompute();
+    const first = useActivityStore.getState().statusCountsByScope["proj-a"];
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().statusCountsByScope["proj-a"]).toBe(first);
   });
 });
diff --git a/src/__tests__/PrintDoc.test.ts b/src/__tests__/PrintDoc.test.ts
new file mode 100644
index 0000000..46e957f
--- /dev/null
+++ b/src/__tests__/PrintDoc.test.ts
@@ -0,0 +1,255 @@
+/**
+ * Tests for the pure part of the viewer print pipeline (`lib/viewers/print`):
+ * `buildPrintDoc` assembles a self-contained print document from a body + css.
+ * The DOM driver (`printDocument`) and pdf.js rasteriser are exercised at
+ * runtime, not here.
+ *
+ * The *arrangement* itself (moving/deleting/turning pages) now lives in the shared
+ * `lib/viewers/pageModel` and is tested in `PageModel.test.ts`. What stays here is
+ * the print-specific reading of an arrangement: `printSequence`.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  buildPrintDoc,
+  buildOptionsCss,
+  parsePageRange,
+  selectedPages,
+  printSequence,
+  thumbSizePx,
+  contentBoxCm,
+  loadPrintOptions,
+  savePrintOptions,
+  sanitizePrintOptions,
+  DEFAULT_PRINT_OPTIONS,
+  TEXT_PRINT_CSS,
+  MARKDOWN_PRINT_CSS,
+  type PrintOptions,
+} from "../lib/viewers/print";
+import {
+  initialPages,
+  movePages,
+  deletePages,
+  type PageList,
+} from "../lib/viewers/pageModel";
+
+const withOpts = (patch: Partial<PrintOptions>): PrintOptions => ({
+  ...DEFAULT_PRINT_OPTIONS,
+  ...patch,
+});
+
+describe("buildPrintDoc", () => {
+  it("produces a complete, self-contained HTML document", () => {
+    const doc = buildPrintDoc("<p>hi</p>", ".x{color:red}", "Note");
+    expect(doc.startsWith("<!doctype html>")).toBe(true);
+    expect(doc).toContain('<meta charset="utf-8">');
+    expect(doc).toContain("<body><p>hi</p></body>");
+    // Caller CSS is inlined into the <style> after the print base.
+    expect(doc).toContain(".x{color:red}");
+    // Print base: page margins so nothing prints edge-to-edge.
+    expect(doc).toContain("@page{margin:1.5cm}");
+  });
+
+  it("sets and escapes the document title", () => {
+    const doc = buildPrintDoc("", "", 'a"b & <c>');
+    expect(doc).toContain("<title>a&quot;b &amp; &lt;c></title>");
+  });
+
+  it("defaults the title when none is given", () => {
+    expect(buildPrintDoc("", "")).toContain("<title>Print</title>");
+  });
+
+  it("does not escape the body (caller-trusted markup)", () => {
+    // The body is already sanitised/escaped by the caller (renderMarkdown or
+    // escapeHtml), so buildPrintDoc must pass it through verbatim.
+    const doc = buildPrintDoc('<pre class="print-pre">a &lt; b</pre>', TEXT_PRINT_CSS);
+    expect(doc).toContain('<pre class="print-pre">a &lt; b</pre>');
+  });
+
+  it("exposes stylesheets targeting the expected structures", () => {
+    expect(MARKDOWN_PRINT_CSS).toContain(".markdown-body");
+    expect(TEXT_PRINT_CSS).toContain("pre.print-pre");
+  });
+
+  it("gives md/txt real print margins via body padding, not @page alone", () => {
+    // WebKitGTK ignores the @page margin box, so margins must come from body
+    // padding (honored by every engine). @page is zeroed so Chromium-based
+    // WebView2 does not stack its own margin on top. Regression guard: these
+    // margins previously existed only as @page and printed edge-to-edge.
+    for (const css of [MARKDOWN_PRINT_CSS, TEXT_PRINT_CSS]) {
+      expect(css).toContain("body{padding:2.54cm}");
+      expect(css).toContain("@page{margin:0}");
+    }
+  });
+});
+
+describe("parsePageRange", () => {
+  it("parses single pages, ranges and open-ended ranges", () => {
+    expect(parsePageRange("1-3, 5", 10)).toEqual([1, 2, 3, 5]);
+    expect(parsePageRange("2 4", 10)).toEqual([2, 4]);
+    expect(parsePageRange("7-", 9)).toEqual([7, 8, 9]);
+    expect(parsePageRange("-3", 9)).toEqual([1, 2, 3]);
+  });
+
+  it("clamps to the document, dedupes and sorts", () => {
+    expect(parsePageRange("9, 2-4, 3, 0", 5)).toEqual([2, 3, 4]);
+    // Reversed bounds are read as the range the user meant.
+    expect(parsePageRange("4-2", 5)).toEqual([2, 3, 4]);
+  });
+
+  it("drops garbage instead of throwing (it runs on every keystroke)", () => {
+    expect(parsePageRange("", 5)).toEqual([]);
+    // "abc" and a bare "-" carry no page, so only the "2" survives.
+    expect(parsePageRange("abc, 2, -, ,", 5)).toEqual([2]);
+    expect(parsePageRange("1-2", 0)).toEqual([]);
+  });
+});
+
+describe("selectedPages", () => {
+  it("selects all / odd / even / a custom range", () => {
+    expect(selectedPages(withOpts({ pages: "all" }), 4)).toEqual([1, 2, 3, 4]);
+    expect(selectedPages(withOpts({ pages: "odd" }), 5)).toEqual([1, 3, 5]);
+    expect(selectedPages(withOpts({ pages: "even" }), 5)).toEqual([2, 4]);
+    expect(selectedPages(withOpts({ pages: "custom", range: "2-3" }), 5)).toEqual([2, 3]);
+  });
+
+  it("selects nothing in a document with no pages (a flowing document)", () => {
+    expect(selectedPages(DEFAULT_PRINT_OPTIONS, 0)).toEqual([]);
+  });
+});
+
+describe("what actually prints", () => {
+  /** The arrangement as original page numbers, which is what lands on paper. */
+  const printed = (list: PageList, opts: PrintOptions): number[] =>
+    printSequence(list, opts).map((r) => r.page);
+
+  it("prints the arrangement, with the selection counting arranged positions", () => {
+    const three = initialPages(3);
+    const arranged = movePages(three, [three[2].id], 0); // page 3 dragged to the front
+    expect(arranged.map((r) => r.page)).toEqual([3, 1, 2]);
+
+    expect(printed(arranged, withOpts({ pages: "all" }))).toEqual([3, 1, 2]);
+    // "1-2" means the first two sheets *as arranged*, not original pages 1 and 2.
+    expect(printed(arranged, withOpts({ pages: "custom", range: "1-2" }))).toEqual([3, 1]);
+    expect(printed(arranged, withOpts({ pages: "odd" }))).toEqual([3, 2]);
+
+    // Deleted pages are simply gone from the arrangement.
+    const minusPage1 = deletePages(arranged, [three[0].id]);
+    expect(printed(minusPage1, withOpts({ pages: "all" }))).toEqual([3, 2]);
+  });
+
+  it("prints nothing from an empty arrangement", () => {
+    expect(printSequence([], DEFAULT_PRINT_OPTIONS)).toEqual([]);
+  });
+});
+
+describe("sheet geometry", () => {
+  it("gives the strip cards the sheet's proportions", () => {
+    // Portrait A4 → upright card; landscape → a card wider than it is tall.
+    expect(thumbSizePx(withOpts({ paper: "A4" }))).toEqual([59, 84]);
+    expect(thumbSizePx(withOpts({ paper: "A4", orientation: "landscape" }))).toEqual([
+      119, 84,
+    ]);
+    expect(thumbSizePx(withOpts({ paper: "Letter" }))).toEqual([65, 84]);
+  });
+
+  it("computes the printable box as the sheet minus both margins", () => {
+    expect(contentBoxCm(withOpts({ paper: "A4", margin: "normal" }))).toEqual([15.92, 24.62]);
+    expect(contentBoxCm(withOpts({ paper: "A4", margin: "none" }))).toEqual([21, 29.7]);
+    expect(
+      contentBoxCm(withOpts({ paper: "A4", orientation: "landscape", margin: "none" })),
+    ).toEqual([29.7, 21]);
+  });
+
+  it("fits a quarter-turned page by swapping its box, not by overflowing", () => {
+    // transform does not change the layout box, so a turned page is centred out
+    // of flow and pre-constrained to the swapped printable box.
+    const css = buildOptionsCss(withOpts({ paper: "A4", margin: "none" }));
+    expect(css).toContain(".print-page.eldrun-rot-90,.print-page.eldrun-rot-270");
+    expect(css).toContain("max-width:29.7cm;max-height:21cm");
+    expect(css).toContain("rotate(90deg)");
+    expect(css).toContain("rotate(270deg)");
+    expect(css).toContain(".print-page.eldrun-rot-180 img{transform:rotate(180deg)}");
+  });
+});
+
+describe("buildOptionsCss", () => {
+  it("sets the sheet from paper + orientation, landscape swapping the sides", () => {
+    expect(buildOptionsCss(withOpts({ paper: "A4" }))).toContain("@page{size:21cm 29.7cm");
+    expect(buildOptionsCss(withOpts({ paper: "A4", orientation: "landscape" }))).toContain(
+      "@page{size:29.7cm 21cm",
+    );
+    expect(buildOptionsCss(withOpts({ paper: "Letter" }))).toContain(
+      "@page{size:21.59cm 27.94cm",
+    );
+  });
+
+  it("applies margins as body padding, never as an @page margin", () => {
+    // WebKitGTK ignores the @page margin box — a margin set only there prints
+    // edge-to-edge. Same reason the viewer stylesheets pad the body.
+    const css = buildOptionsCss(withOpts({ margin: "wide" }));
+    expect(css).toContain("padding:3.81cm");
+    expect(css).toContain("@page{size:21cm 29.7cm;margin:0}");
+    expect(buildOptionsCss(withOpts({ margin: "none" }))).toContain("padding:0cm");
+  });
+
+  it("scales content with zoom and divides the on-screen sheet by it", () => {
+    // zoom multiplies the sheet box back to true paper size, so the preview
+    // shows a real A4 sheet with smaller content — like a printer's scale.
+    const css = buildOptionsCss(withOpts({ scale: 50 }));
+    expect(css).toContain("zoom:0.5");
+    expect(css).toContain("width:42cm");
+    expect(css).toContain("min-height:59.4cm");
+  });
+
+  it("emits grayscale, background and page-number rules only when enabled", () => {
+    const off = buildOptionsCss(DEFAULT_PRINT_OPTIONS);
+    expect(off).not.toContain("grayscale(1)");
+    expect(off).not.toContain("attr(data-page)");
+    // Backgrounds default to on: colors print rather than being stripped.
+    expect(off).toContain("print-color-adjust:exact");
+    expect(off).not.toContain("background:transparent!important");
+
+    const on = buildOptionsCss(
+      withOpts({ grayscale: true, background: false, pageNumbers: true }),
+    );
+    expect(on).toContain("body{filter:grayscale(1)}");
+    expect(on).toContain("body *{background:transparent!important");
+    expect(on).toContain(".print-page::after{content:attr(data-page)");
+  });
+
+  it("always hides deselected pages via the shared class", () => {
+    expect(buildOptionsCss(DEFAULT_PRINT_OPTIONS)).toContain(
+      ".eldrun-print-hidden{display:none!important}",
+    );
+  });
+});
+
+describe("loadPrintOptions", () => {
+  it("carries the printer settings over but never the page selection", () => {
+    savePrintOptions(
+      withOpts({ paper: "Legal", margin: "wide", pages: "custom", range: "2-3" }),
+    );
+    const loaded = loadPrintOptions();
+    expect(loaded.paper).toBe("Legal");
+    expect(loaded.margin).toBe("wide");
+    // A range typed for one document must not silently drop pages of the next.
+    expect(loaded.pages).toBe("all");
+    expect(loaded.range).toBe("");
+  });
+});
+
+describe("sanitizePrintOptions", () => {
+  it("falls back to the defaults for missing or bogus stored values", () => {
+    expect(sanitizePrintOptions(null)).toEqual(DEFAULT_PRINT_OPTIONS);
+    expect(sanitizePrintOptions({ paper: "B7", pages: "some", scale: "x" })).toEqual(
+      DEFAULT_PRINT_OPTIONS,
+    );
+  });
+
+  it("keeps valid values and clamps the scale", () => {
+    const o = sanitizePrintOptions({ paper: "Legal", scale: 5000, grayscale: true });
+    expect(o.paper).toBe("Legal");
+    expect(o.scale).toBe(400);
+    expect(o.grayscale).toBe(true);
+  });
+});
diff --git a/src/__tests__/ProjectDirectory.test.ts b/src/__tests__/ProjectDirectory.test.ts
new file mode 100644
index 0000000..ca302c1
--- /dev/null
+++ b/src/__tests__/ProjectDirectory.test.ts
@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { resolveProjectDirectory, type ProjectEntry } from "../types";
+
+describe("resolveProjectDirectory", () => {
+  it("recovers legacy Windows local_file paths", () => {
+    const project = {
+      local_file: "C:\\Users\\alice\\eldrun\\projects\\demo\\project.json",
+    } as ProjectEntry;
+    expect(resolveProjectDirectory(project)).toBe(
+      "C:\\Users\\alice\\eldrun\\projects\\demo",
+    );
+  });
+});
diff --git a/src/__tests__/ProjectFilesTab.test.ts b/src/__tests__/ProjectFilesTab.test.ts
new file mode 100644
index 0000000..128cb28
--- /dev/null
+++ b/src/__tests__/ProjectFilesTab.test.ts
@@ -0,0 +1,108 @@
+/**
+ * The "Files (Project)" tab kind — the right panel's file view hosted in a tab.
+ * Two things must hold for it, and neither is visible from the pane itself:
+ * the tab is recovered from its bare command on restore (a persisted layout
+ * stores `cmd`, and a kind Eldrun can't recover would come back a shell), and
+ * the folder it was opened on is part of what survives — the whole point of
+ * "Open in a new tab" on a folder is that the tab IS that folder.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import {
+  PROJECT_FILES_TAB_CMD,
+  cmdToKind,
+  isRestorableKind,
+  isRestorableTab,
+  useTabsStore,
+  type GroupNode,
+} from "../stores/tabs";
+
+const invokeMock = vi.mocked(invoke);
+
+describe("projectfiles tab kind", () => {
+  it("recovers its kind from the bare command", () => {
+    expect(cmdToKind(PROJECT_FILES_TAB_CMD)).toBe("projectfiles");
+    // The separate FileBrowser tab keeps its own command and kind.
+    expect(cmdToKind("__eldrun_files__")).toBe("files");
+  });
+
+  it("survives a restart (a pure frontend pane, like the files tab)", () => {
+    expect(isRestorableKind("projectfiles")).toBe(true);
+    expect(
+      isRestorableTab({ kind: "projectfiles", cmd: PROJECT_FILES_TAB_CMD }),
+    ).toBe(true);
+  });
+});
+
+describe("a projectfiles tab's browsed folder", () => {
+  beforeEach(() => {
+    invokeMock.mockClear();
+    useTabsStore.setState({
+      scope: "p1",
+      tabs: [
+        {
+          key: "f1",
+          scope: "p1",
+          label: "src",
+          cmd: PROJECT_FILES_TAB_CMD,
+          cwd: "/p/p1",
+          kind: "projectfiles",
+          folder: "src",
+        },
+      ],
+      activeKey: "f1",
+      layout: { type: "group", id: "g1", tabKeys: ["f1"], activeKey: "f1" } as GroupNode,
+      focusedGroupId: "g1",
+      tabsByScope: {
+        p1: [
+          {
+            key: "f1",
+            scope: "p1",
+            label: "src",
+            cmd: PROJECT_FILES_TAB_CMD,
+            cwd: "/p/p1",
+            kind: "projectfiles",
+            folder: "src",
+          },
+        ],
+      },
+      layoutByScope: {
+        p1: { type: "group", id: "g1", tabKeys: ["f1"], activeKey: "f1" } as GroupNode,
+      },
+      focusedGroupByScope: { p1: "g1" },
+    });
+  });
+
+  it("setTabFolder records a navigation, and is a no-op when unchanged", () => {
+    const before = useTabsStore.getState().tabs;
+    useTabsStore.getState().setTabFolder("f1", "src");
+    // Unchanged → the tabs array is not churned (which would wake saveLayout).
+    expect(useTabsStore.getState().tabs).toBe(before);
+
+    useTabsStore.getState().setTabFolder("f1", "src/components");
+    expect(useTabsStore.getState().tabs[0].folder).toBe("src/components");
+  });
+
+  it("persists the folder, and restores the tab on it", async () => {
+    await useTabsStore.getState().saveLayout("/p/p1/project.json");
+    const saved = invokeMock.mock.calls.find(([cmd]) => cmd === "save_tab_layout");
+    expect(saved).toBeTruthy();
+    const layout = (saved![1] as { tabs: Array<Record<string, unknown>> }).tabs;
+    expect(layout).toHaveLength(1);
+    expect(layout[0]).toMatchObject({ kind: "projectfiles", folder: "src" });
+
+    useTabsStore.getState().loadFromLayout(
+      layout as never,
+      "/p/p1",
+      "p1",
+      { type: "group", id: "g1", tabKeys: [String(layout[0].key)], activeKey: String(layout[0].key) } as never,
+    );
+    const restored = useTabsStore.getState().tabs[0];
+    expect(restored.kind).toBe("projectfiles");
+    expect(restored.folder).toBe("src");
+  });
+});
diff --git a/src/__tests__/ProjectPillsRender.test.tsx b/src/__tests__/ProjectPillsRender.test.tsx
new file mode 100644
index 0000000..fbc6303
--- /dev/null
+++ b/src/__tests__/ProjectPillsRender.test.tsx
@@ -0,0 +1,102 @@
+/**
+ * Regression: the project switcher must render one pill per active project.
+ * A crash or bad filter in the pill strip made the pills vanish entirely — a
+ * severe bug, since the switcher is the primary way to move between projects.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, act } from "@testing-library/react";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn().mockResolvedValue(null) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn().mockResolvedValue(() => {}) }));
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({ startDragging: () => Promise.resolve() }),
+}));
+vi.mock("@tauri-apps/plugin-dialog", () => ({
+  open: vi.fn().mockResolvedValue(null),
+  confirm: vi.fn().mockResolvedValue(false),
+  message: vi.fn().mockResolvedValue(null),
+}));
+
+import { ProjectSwitcher } from "../components/layout/ProjectSwitcher";
+import { useProjectsStore } from "../stores/projects";
+import { useBoxesStore } from "../stores/boxes";
+import type { ProjectEntry } from "../types";
+
+function proj(id: string, position: number, extra: Partial<ProjectEntry> = {}): ProjectEntry {
+  return {
+    id,
+    name: `Project ${id}`,
+    status: "active",
+    position,
+    local_file: `/tmp/${id}/project.json`,
+    directory: `/tmp/${id}`,
+    ...extra,
+  };
+}
+
+describe("project switcher pill rendering", () => {
+  beforeEach(() => {
+    useBoxesStore.setState({ boxes: [] });
+    useProjectsStore.setState({ projects: [], activeId: null, loaded: true });
+  });
+
+  it("renders one pill per active project", async () => {
+    useProjectsStore.setState({
+      projects: [proj("a", 0), proj("b", 1), proj("c", 2)],
+      activeId: "a",
+      loaded: true,
+    });
+
+    let container: HTMLElement;
+    await act(async () => {
+      ({ container } = render(<ProjectSwitcher open />));
+    });
+
+    const pills = container!.querySelectorAll(".project-pill");
+    expect(pills.length).toBe(3);
+  });
+
+  it("renders a pill for a remote project (matches real on-disk shape)", async () => {
+    useProjectsStore.setState({
+      projects: [
+        proj("a", 0),
+        proj("ssh", 1, {
+          name: "SSH Git Test",
+          git_type: "local",
+          remote: {
+            auto_connect: true,
+            host: "example.host",
+            key_auth: false,
+            openvpn: { config: "/x/y.ovpn", username: "u" },
+            remote_path: "/home/u/proj",
+            user: "u",
+          },
+        } as Partial<ProjectEntry>),
+      ],
+      activeId: "a",
+      loaded: true,
+    });
+
+    let container: HTMLElement;
+    await act(async () => {
+      ({ container } = render(<ProjectSwitcher open />));
+    });
+
+    expect(container!.querySelectorAll(".project-pill").length).toBe(2);
+  });
+
+  it("hides inactive projects but keeps the active ones", async () => {
+    useProjectsStore.setState({
+      projects: [proj("a", 0), proj("b", 1, { status: "inactive" }), proj("c", 2)],
+      activeId: "a",
+      loaded: true,
+    });
+
+    let container: HTMLElement;
+    await act(async () => {
+      ({ container } = render(<ProjectSwitcher open />));
+    });
+
+    expect(container!.querySelectorAll(".project-pill").length).toBe(2);
+  });
+});
diff --git a/src/__tests__/ProjectTypeTags.test.ts b/src/__tests__/ProjectTypeTags.test.ts
new file mode 100644
index 0000000..0650965
--- /dev/null
+++ b/src/__tests__/ProjectTypeTags.test.ts
@@ -0,0 +1,133 @@
+/**
+ * The user-facing project "type" labels/badges. A project's type is the product
+ * of two independent axes — the git axis (6 label states: no-git, local, and
+ * remote-private/remote-public each forking by GitHub/GitLab provider) and the
+ * connection axis (local files vs an SSH host, i.e. `project.remote` set) — for
+ * 12 combinations in all. A transient "no scaffold" warning stacks on top as a
+ * separate axis. These tests lock the derivation in `projectTypeTags` /
+ * `gitTypeLabel` / `providerName` (pure, extracted from `ProjectPill.tsx`).
+ */
+import { describe, it, expect } from "vitest";
+
+import { providerName, gitTypeLabel, projectTypeTags } from "../components/projects/projectTypeTags";
+import { formatRemoteTarget, type ProjectEntry, type RemoteSpec } from "../types";
+
+const SSH: RemoteSpec = { user: "ada", host: "box.example", remote_path: "/srv/app" };
+
+/** Minimal entry carrying only the fields the tag logic reads. `git_type` rides
+ *  the `[key: string]: unknown` index signature, so it is set via `extra`. */
+function entry(extra: Partial<ProjectEntry> & Record<string, unknown> = {}): ProjectEntry {
+  return {
+    id: "p1",
+    name: "Proj",
+    status: "inactive",
+    position: 0,
+    local_file: "proj",
+    ...extra,
+  };
+}
+
+/** Compare only the load-bearing facets of each tag (key/label/color); static
+ *  tooltip wording is asserted separately where it carries logic. */
+function facets(tags: ReturnType<typeof projectTypeTags>) {
+  return tags.map((t) => ({ key: t.key, label: t.label, color: t.color }));
+}
+
+const GIT = { key: "git", label: "git", color: "#3fb950" };
+const NO_GIT = { key: "git", label: "no git", color: "#8b949e" };
+const GITHUB = { key: "provider", label: "GitHub", color: "#a371f7" };
+const GITLAB = { key: "provider", label: "GitLab", color: "#fc6d26" };
+const SSH_TAG = { key: "ssh", label: "SSH", color: "#58a6ff" };
+
+/** The 6 git-label states, each as (git_type, git_provider) → expected git-axis
+ *  tag facets (before the connection axis is layered on). */
+const GIT_STATES: Array<{ name: string; extra: Record<string, unknown>; tags: typeof GIT[] }> = [
+  { name: "no git", extra: { git_type: "none" }, tags: [NO_GIT] },
+  { name: "local", extra: { git_type: "local" }, tags: [GIT] },
+  { name: "remote-private · GitHub", extra: { git_type: "remote-private", git_provider: "github" }, tags: [GIT, GITHUB] },
+  { name: "remote-private · GitLab", extra: { git_type: "remote-private", git_provider: "gitlab" }, tags: [GIT, GITLAB] },
+  { name: "remote-public · GitHub", extra: { git_type: "remote-public", git_provider: "github" }, tags: [GIT, GITHUB] },
+  { name: "remote-public · GitLab", extra: { git_type: "remote-public", git_provider: "gitlab" }, tags: [GIT, GITLAB] },
+];
+
+describe("projectTypeTags — the 12 project combinations", () => {
+  for (const state of GIT_STATES) {
+    it(`${state.name} · local files`, () => {
+      const tags = projectTypeTags(entry(state.extra), false);
+      expect(facets(tags)).toEqual(state.tags);
+    });
+
+    it(`${state.name} · SSH host`, () => {
+      const tags = projectTypeTags(entry({ ...state.extra, remote: SSH }), false);
+      expect(facets(tags)).toEqual([...state.tags, SSH_TAG]);
+      // The SSH tag's title carries the resolved host target.
+      const ssh = tags.find((t) => t.key === "ssh");
+      expect(ssh?.title).toContain(formatRemoteTarget(SSH));
+    });
+  }
+
+  it("covers exactly 12 git×connection combinations", () => {
+    expect(GIT_STATES.length * 2).toBe(12);
+  });
+});
+
+describe("projectTypeTags — stacked / edge axes", () => {
+  it("adds the amber 'no scaffold' tag when scaffold is missing", () => {
+    const tags = projectTypeTags(entry({ git_type: "local" }), true);
+    expect(facets(tags)).toContainEqual({ key: "scaffold", label: "no scaffold", color: "#d29922" });
+  });
+
+  it("stacks all independent axes: public GitHub on an SSH host with missing scaffold", () => {
+    const tags = projectTypeTags(
+      entry({ git_type: "remote-public", git_provider: "github", remote: SSH }),
+      true,
+    );
+    expect(facets(tags)).toEqual([
+      GIT,
+      GITHUB,
+      SSH_TAG,
+      { key: "scaffold", label: "no scaffold", color: "#d29922" },
+    ]);
+  });
+
+  it("defaults a non-string git_type to a local repo", () => {
+    const tags = projectTypeTags(entry({ git_type: 42 }), false);
+    expect(facets(tags)).toEqual([GIT]);
+  });
+
+  it("defaults missing git_type to a local repo", () => {
+    expect(facets(projectTypeTags(entry(), false))).toEqual([GIT]);
+  });
+
+  it("treats a published project with no recorded provider as GitHub", () => {
+    const tags = projectTypeTags(entry({ git_type: "remote-public" }), false);
+    expect(facets(tags)).toEqual([GIT, GITHUB]);
+  });
+});
+
+describe("gitTypeLabel", () => {
+  it("labels remote states with provider · visibility", () => {
+    expect(gitTypeLabel("remote-public", "github")).toBe("GitHub · public");
+    expect(gitTypeLabel("remote-public", "gitlab")).toBe("GitLab · public");
+    expect(gitTypeLabel("remote-private", "github")).toBe("GitHub · private");
+    expect(gitTypeLabel("remote-private", "gitlab")).toBe("GitLab · private");
+  });
+
+  it("labels the no-git and local states", () => {
+    expect(gitTypeLabel("none")).toBe("No git (no repo)");
+    expect(gitTypeLabel("local")).toBe("Local repo (not pushed)");
+  });
+
+  it("falls through unknown/undefined git_type to the local-repo label", () => {
+    expect(gitTypeLabel(undefined)).toBe("Local repo (not pushed)");
+    expect(gitTypeLabel("weird")).toBe("Local repo (not pushed)");
+  });
+});
+
+describe("providerName", () => {
+  it("returns GitLab only for the gitlab id, GitHub otherwise", () => {
+    expect(providerName("gitlab")).toBe("GitLab");
+    expect(providerName("github")).toBe("GitHub");
+    expect(providerName(undefined)).toBe("GitHub");
+  });
+});
diff --git a/src/__tests__/PromptCount.test.ts b/src/__tests__/PromptCount.test.ts
new file mode 100644
index 0000000..a1fc72a
--- /dev/null
+++ b/src/__tests__/PromptCount.test.ts
@@ -0,0 +1,123 @@
+/**
+ * Locks the "you asked them N things" heuristic.
+ *
+ * Eldrun only sees the bytes going into an agent's PTY, so a submitted prompt is
+ * inferred: Enter pressed with content typed since the last Enter. The cases that
+ * matter are the ones that must NOT count — arrow keys (escape sequences whose
+ * payload bytes are printable), Ctrl-C, and a bare Enter on an empty line — and
+ * the one that must count as exactly one: paste, then Enter.
+ */
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  _resetPromptCountForTest,
+  forgetPty,
+  hasContent,
+  hasSubmit,
+  noteInput,
+} from "../lib/promptCount";
+
+const PTY = "proj-a:agent-1";
+
+beforeEach(_resetPromptCountForTest);
+
+describe("hasContent", () => {
+  it("sees printable text", () => {
+    expect(hasContent("hello")).toBe(true);
+    expect(hasContent("a")).toBe(true);
+  });
+
+  it("does not see an arrow key", () => {
+    // "\x1b[A" — a naive scan would count the "[" and "A" as two typed chars, so
+    // walking history would look like composing a prompt.
+    expect(hasContent("\x1b[A")).toBe(false);
+    expect(hasContent("\x1b[B")).toBe(false);
+    expect(hasContent("\x1b[1;5C")).toBe(false); // ctrl+right
+  });
+
+  it("does not see control characters", () => {
+    expect(hasContent("\x03")).toBe(false); // ctrl+c
+    expect(hasContent("\t")).toBe(false);
+    expect(hasContent("\x7f")).toBe(false); // backspace
+    expect(hasContent("\r")).toBe(false);
+    expect(hasContent("")).toBe(false);
+  });
+
+  it("sees content mixed in with control bytes", () => {
+    expect(hasContent("hi\r")).toBe(true);
+  });
+});
+
+describe("hasSubmit", () => {
+  it("recognises carriage return and newline", () => {
+    expect(hasSubmit("\r")).toBe(true);
+    expect(hasSubmit("\n")).toBe(true);
+    expect(hasSubmit("hello")).toBe(false);
+  });
+});
+
+describe("noteInput", () => {
+  it("counts one submit for typing then Enter", () => {
+    expect(noteInput(PTY, "f")).toBe(0);
+    expect(noteInput(PTY, "i")).toBe(0);
+    expect(noteInput(PTY, "x")).toBe(0);
+    expect(noteInput(PTY, "\r")).toBe(1);
+  });
+
+  it("does not count a bare Enter on an empty line", () => {
+    // Scrolling an agent's menu or accepting a default is not a question asked.
+    expect(noteInput(PTY, "\r")).toBe(0);
+    expect(noteInput(PTY, "\r")).toBe(0);
+  });
+
+  it("does not count Enter again after a submit with nothing retyped", () => {
+    noteInput(PTY, "hi");
+    expect(noteInput(PTY, "\r")).toBe(1);
+    expect(noteInput(PTY, "\r")).toBe(0);
+  });
+
+  it("counts a paste followed by Enter exactly once", () => {
+    // A paste arrives as a single onData chunk.
+    expect(noteInput(PTY, "please refactor the parser")).toBe(0);
+    expect(noteInput(PTY, "\r")).toBe(1);
+  });
+
+  it("counts a chunk that carries both content and Enter as one submit", () => {
+    expect(noteInput(PTY, "hello\r")).toBe(1);
+  });
+
+  it("counts a multi-line paste as one thing asked, not one per line", () => {
+    expect(noteInput(PTY, "line one\nline two\nline three\n")).toBe(1);
+  });
+
+  it("does not count arrow keys followed by Enter", () => {
+    expect(noteInput(PTY, "\x1b[A")).toBe(0);
+    expect(noteInput(PTY, "\r")).toBe(0);
+  });
+
+  it("does not count Ctrl-C followed by Enter", () => {
+    expect(noteInput(PTY, "\x03")).toBe(0);
+    expect(noteInput(PTY, "\r")).toBe(0);
+  });
+
+  it("counts two prompts across two rounds", () => {
+    noteInput(PTY, "first");
+    expect(noteInput(PTY, "\r")).toBe(1);
+    noteInput(PTY, "second");
+    expect(noteInput(PTY, "\r")).toBe(1);
+  });
+
+  it("keeps separate PTYs independent", () => {
+    const other = "proj-b:agent-1";
+    noteInput(PTY, "typed here");
+    // The other terminal has nothing pending, so its Enter must not steal the
+    // first one's content.
+    expect(noteInput(other, "\r")).toBe(0);
+    expect(noteInput(PTY, "\r")).toBe(1);
+  });
+
+  it("forgetPty drops pending state so a recycled id does not inherit it", () => {
+    noteInput(PTY, "half-typed");
+    forgetPty(PTY);
+    expect(noteInput(PTY, "\r")).toBe(0);
+  });
+});
diff --git a/src/__tests__/PythonIntel.test.ts b/src/__tests__/PythonIntel.test.ts
new file mode 100644
index 0000000..eebd40d
--- /dev/null
+++ b/src/__tests__/PythonIntel.test.ts
@@ -0,0 +1,445 @@
+import { describe, it, expect } from "vitest";
+import {
+  findDef,
+  findPythonDefs,
+  isExecutableLine,
+  isPythonMainScript,
+  isPythonPath,
+  modulePathCandidates,
+  parsePythonImports,
+  pythonLinkRanges,
+  pythonRefAt,
+  pythonTokens,
+  remapBreakpoints,
+  resolvePythonDefinition,
+  snapBreakpointLine,
+} from "../lib/viewers/python";
+
+describe("isPythonPath", () => {
+  it("accepts python sources and rejects everything else", () => {
+    expect(isPythonPath("/a/b/main.py")).toBe(true);
+    expect(isPythonPath("/a/b/stub.pyi")).toBe(true);
+    expect(isPythonPath("/a/b/MAIN.PY")).toBe(true);
+    expect(isPythonPath("/a/b/notes.md")).toBe(false);
+    expect(isPythonPath("/a/pyproject.toml")).toBe(false);
+  });
+});
+
+describe("isPythonMainScript", () => {
+  it("accepts the standard module-level guard, either quote style", () => {
+    expect(isPythonMainScript('if __name__ == "__main__":\n    main()\n')).toBe(true);
+    expect(isPythonMainScript("if __name__ == '__main__':\n    main()\n")).toBe(true);
+  });
+
+  it("tolerates extra spacing around the guard", () => {
+    expect(isPythonMainScript('if __name__   ==   "__main__" :\n    main()\n')).toBe(true);
+  });
+
+  it("rejects a plain module with no entrypoint guard", () => {
+    expect(isPythonMainScript("def helper():\n    return 1\n")).toBe(false);
+  });
+
+  it("rejects an indented guard (inside a function/class, not module level)", () => {
+    expect(isPythonMainScript('def f():\n    if __name__ == "__main__":\n        pass\n')).toBe(false);
+  });
+
+  it("rejects mismatched quotes", () => {
+    expect(isPythonMainScript("if __name__ == \"__main__':\n    main()\n")).toBe(false);
+  });
+});
+
+// ── Breakpoints ──────────────────────────────────────────────────────────────
+
+describe("isExecutableLine", () => {
+  it("rejects the lines pdb refuses to break on", () => {
+    expect(isExecutableLine("x = 1")).toBe(true);
+    expect(isExecutableLine("    return x")).toBe(true);
+    expect(isExecutableLine("")).toBe(false);
+    expect(isExecutableLine("   ")).toBe(false);
+    expect(isExecutableLine("# a comment")).toBe(false);
+    // A decorator runs at definition time, not at the call — breaking there
+    // fires on import, which is never what the click meant.
+    expect(isExecutableLine("@lru_cache")).toBe(false);
+  });
+});
+
+describe("snapBreakpointLine", () => {
+  const src = ["# header", "", "import os", "", "", "def f():", "    return 1"].join("\n");
+
+  it("keeps an already-executable line", () => {
+    expect(snapBreakpointLine(src, 3)).toBe(3);
+    expect(snapBreakpointLine(src, 7)).toBe(7);
+  });
+
+  it("snaps a blank or comment line down to the next executable one", () => {
+    expect(snapBreakpointLine(src, 1)).toBe(3); // comment → import
+    expect(snapBreakpointLine(src, 4)).toBe(6); // blank → def
+  });
+
+  it("returns null when nothing below is executable", () => {
+    expect(snapBreakpointLine("x = 1\n\n\n", 2)).toBeNull();
+  });
+});
+
+describe("remapBreakpoints", () => {
+  const src = ["import os", "", "def f():", "    return 1", "", "def g():", "    return 2"].join(
+    "\n",
+  );
+
+  it("is a no-op when the text is unchanged", () => {
+    expect(remapBreakpoints(src, src, [4, 7])).toEqual([4, 7]);
+  });
+
+  it("shifts breakpoints below an insertion", () => {
+    const next = ["import os", "import sys", "", "def f():", "    return 1", "", "def g():", "    return 2"].join("\n");
+    // Both defs moved down one line; the dots must follow them.
+    expect(remapBreakpoints(src, next, [4, 7])).toEqual([5, 8]);
+  });
+
+  it("shifts breakpoints up when lines above are deleted", () => {
+    const next = ["def f():", "    return 1", "", "def g():", "    return 2"].join("\n");
+    expect(remapBreakpoints(src, next, [4, 7])).toEqual([2, 5]);
+  });
+
+  it("leaves breakpoints above an edit alone", () => {
+    const next = src.replace("    return 2", "    return 99");
+    expect(remapBreakpoints(src, next, [4])).toEqual([4]);
+  });
+
+  it("drops a breakpoint whose own line was replaced", () => {
+    // Line 4 (`return 1`) is the edited span — the statement it named is gone,
+    // so the dot goes with it rather than silently pointing at something else.
+    const next = src.replace("    return 1", "    return 1 + 1\n    print('x')");
+    expect(remapBreakpoints(src, next, [4, 7])).toEqual([8]);
+  });
+
+  it("keeps the result sorted and deduplicated", () => {
+    const next = ["def f():", "    return 1", "", "def g():", "    return 2"].join("\n");
+    expect(remapBreakpoints(src, next, [7, 4])).toEqual([2, 5]);
+  });
+});
+
+// ── Lexing ───────────────────────────────────────────────────────────────────
+
+describe("pythonTokens", () => {
+  it("skips comments and string bodies", () => {
+    const names = pythonTokens(`x = "import os"  # import sys\ny = 1`).map((t) => t.name);
+    expect(names).toEqual(["x", "y"]);
+  });
+
+  it("skips triple-quoted docstrings", () => {
+    const src = `"""\nmodule docstring mentioning helper\n"""\nimport helper`;
+    const names = pythonTokens(src).map((t) => t.name);
+    expect(names).toEqual(["import", "helper"]);
+  });
+
+  it("treats an f-string prefix as part of the literal", () => {
+    const names = pythonTokens(`msg = f"hello {name}"`).map((t) => t.name);
+    // `f` is a prefix, not a name; the literal body (incl. the interpolation) is
+    // skipped wholesale.
+    expect(names).toEqual(["msg"]);
+  });
+
+  it("records the qualifier of a dotted access", () => {
+    const toks = pythonTokens("os.path.join(a)");
+    expect(toks.map((t) => [t.name, t.qualifier])).toEqual([
+      ["os", null],
+      ["path", "os"],
+      ["join", "path"],
+      ["a", null],
+    ]);
+  });
+
+  it("does not carry a qualifier across an unrelated token", () => {
+    const toks = pythonTokens("foo(bar)");
+    expect(toks.find((t) => t.name === "bar")?.qualifier).toBeNull();
+  });
+});
+
+describe("pythonRefAt", () => {
+  const src = "import os\nos.getcwd()\n";
+  it("finds the name under the caret with its qualifier", () => {
+    const ref = pythonRefAt(src, src.indexOf("getcwd") + 2);
+    expect(ref?.name).toBe("getcwd");
+    expect(ref?.qualifier).toBe("os");
+  });
+  it("matches a caret resting just after a name", () => {
+    expect(pythonRefAt("x = 1", 1)?.name).toBe("x");
+  });
+  it("returns null off a name", () => {
+    expect(pythonRefAt("x = 1", 3)).toBeNull(); // in the whitespace after `=`
+    expect(pythonRefAt("     ", 3)).toBeNull();
+  });
+});
+
+// ── Definitions ──────────────────────────────────────────────────────────────
+
+describe("findPythonDefs", () => {
+  it("finds defs, async defs, classes and module-level bindings", () => {
+    const src = [
+      "TIMEOUT = 30",
+      "class Client:",
+      "    def send(self):",
+      "        pass",
+      "async def fetch(url):",
+      "    pass",
+    ].join("\n");
+    expect(findPythonDefs(src)).toEqual([
+      { name: "TIMEOUT", line: 1, column: 0, kind: "var" },
+      { name: "Client", line: 2, column: 6, kind: "class" },
+      { name: "send", line: 3, column: 8, kind: "def" },
+      { name: "fetch", line: 5, column: 10, kind: "def" },
+    ]);
+  });
+
+  it("does not mistake an equality test for a binding", () => {
+    expect(findPythonDefs("x == 1")).toEqual([]);
+  });
+
+  it("prefers a def over a bare assignment of the same name", () => {
+    const src = "def f():\n    pass\nf = None";
+    expect(findDef(src, "f")).toMatchObject({ line: 1, kind: "def" });
+  });
+});
+
+// ── Imports ──────────────────────────────────────────────────────────────────
+
+describe("parsePythonImports", () => {
+  it("parses plain imports, including dotted and aliased", () => {
+    expect(parsePythonImports("import os")).toEqual([
+      { local: "os", module: "os", level: 0, symbol: "" },
+    ]);
+    // `import a.b` binds the ROOT name `a`, not `b`.
+    expect(parsePythonImports("import pkg.sub")).toEqual([
+      { local: "pkg", module: "pkg.sub", level: 0, symbol: "" },
+    ]);
+    expect(parsePythonImports("import numpy as np")).toEqual([
+      { local: "np", module: "numpy", level: 0, symbol: "" },
+    ]);
+  });
+
+  it("parses from-imports, relative levels and aliases", () => {
+    expect(parsePythonImports("from .util import helper")).toEqual([
+      { local: "helper", module: "util", level: 1, symbol: "helper" },
+    ]);
+    expect(parsePythonImports("from ..pkg.mod import a, b as c")).toEqual([
+      { local: "a", module: "pkg.mod", level: 2, symbol: "a" },
+      { local: "c", module: "pkg.mod", level: 2, symbol: "b" },
+    ]);
+    expect(parsePythonImports("from . import sibling")).toEqual([
+      { local: "sibling", module: "", level: 1, symbol: "sibling" },
+    ]);
+  });
+
+  it("folds a parenthesised multi-line import list", () => {
+    const src = "from .models import (\n    User,\n    Order as Purchase,\n)";
+    expect(parsePythonImports(src)).toEqual([
+      { local: "User", module: "models", level: 1, symbol: "User" },
+      { local: "Purchase", module: "models", level: 1, symbol: "Order" },
+    ]);
+  });
+
+  it("ignores the word 'import' inside a docstring or comment", () => {
+    expect(parsePythonImports(`"""\nfrom fake import nothing\n"""`)).toEqual([]);
+    expect(parsePythonImports("# from fake import nothing")).toEqual([]);
+  });
+
+  it("skips a star import rather than binding a bogus name", () => {
+    expect(parsePythonImports("from os import *")).toEqual([]);
+  });
+});
+
+// ── Module resolution ────────────────────────────────────────────────────────
+
+describe("modulePathCandidates", () => {
+  it("anchors a relative import at the importing file's directory", () => {
+    expect(
+      modulePathCandidates({ module: "util", level: 1 }, "/proj/pkg/main.py", "/proj"),
+    ).toEqual(["/proj/pkg/util.py", "/proj/pkg/util/__init__.py"]);
+  });
+
+  it("climbs one directory per extra dot", () => {
+    expect(
+      modulePathCandidates({ module: "shared", level: 2 }, "/proj/pkg/sub/main.py", "/proj"),
+    ).toEqual(["/proj/pkg/shared.py", "/proj/pkg/shared/__init__.py"]);
+  });
+
+  it("probes project root, src-layout and the file's own dir for an absolute import", () => {
+    expect(
+      modulePathCandidates({ module: "pkg.mod", level: 0 }, "/proj/app/main.py", "/proj"),
+    ).toEqual([
+      "/proj/pkg/mod.py",
+      "/proj/pkg/mod/__init__.py",
+      "/proj/src/pkg/mod.py",
+      "/proj/src/pkg/mod/__init__.py",
+      "/proj/app/pkg/mod.py",
+      "/proj/app/pkg/mod/__init__.py",
+    ]);
+  });
+
+  it("names the package directory itself for a bare `from . import x`", () => {
+    expect(modulePathCandidates({ module: "", level: 1 }, "/proj/pkg/main.py", "/proj")).toEqual([
+      "/proj/pkg/__init__.py",
+    ]);
+  });
+});
+
+// ── Go-to-definition ─────────────────────────────────────────────────────────
+
+/** A fake project tree: the injected reader is the only filesystem the resolver
+ *  ever sees, which is what keeps it testable without a host. */
+function reader(files: Record<string, string>) {
+  return async (p: string) => files[p] ?? null;
+}
+
+describe("resolvePythonDefinition", () => {
+  const MAIN = "/proj/main.py";
+
+  it("resolves a symbol imported from a sibling module", async () => {
+    const main = "from .util import helper\n\nhelper()\n";
+    const files = {
+      "/proj/util.py": "import os\n\n\ndef helper(x):\n    return x\n",
+    };
+    const loc = await resolvePythonDefinition(
+      main,
+      main.lastIndexOf("helper") + 1,
+      MAIN,
+      "/proj",
+      reader(files),
+    );
+    expect(loc).toEqual({ path: "/proj/util.py", line: 4, column: 4 });
+  });
+
+  it("resolves an attribute of an imported module", async () => {
+    const main = "import util\n\nutil.helper()\n";
+    const files = { "/proj/util.py": "def helper():\n    pass\n" };
+    const loc = await resolvePythonDefinition(
+      main,
+      main.indexOf("util.helper") + 6,
+      MAIN,
+      "/proj",
+      reader(files),
+    );
+    expect(loc).toEqual({ path: "/proj/util.py", line: 1, column: 4 });
+  });
+
+  it("resolves a name defined in the same file", async () => {
+    const main = "def local():\n    pass\n\nlocal()\n";
+    const loc = await resolvePythonDefinition(
+      main,
+      main.lastIndexOf("local") + 1,
+      MAIN,
+      "/proj",
+      reader({}),
+    );
+    expect(loc).toEqual({ path: MAIN, line: 1, column: 4 });
+  });
+
+  it("resolves self.method to the method in this file", async () => {
+    const main = ["class C:", "    def run(self):", "        self.step()", "    def step(self):", "        pass"].join("\n");
+    const loc = await resolvePythonDefinition(
+      main,
+      main.indexOf("self.step") + 6,
+      MAIN,
+      "/proj",
+      reader({}),
+    );
+    expect(loc).toEqual({ path: MAIN, line: 4, column: 8 });
+  });
+
+  it("follows a re-export through a package __init__", async () => {
+    const main = "from .pkg import thing\n\nthing()\n";
+    const files = {
+      "/proj/pkg/__init__.py": "from .impl import thing\n",
+      "/proj/pkg/impl.py": "\ndef thing():\n    pass\n",
+    };
+    const loc = await resolvePythonDefinition(
+      main,
+      main.lastIndexOf("thing") + 1,
+      MAIN,
+      "/proj",
+      reader(files),
+    );
+    expect(loc).toEqual({ path: "/proj/pkg/impl.py", line: 2, column: 4 });
+  });
+
+  it("opens the module itself when the import names a submodule, not a symbol", async () => {
+    const main = "from pkg import mod\n\nmod.f()\n";
+    const files = { "/proj/pkg/mod.py": "def f():\n    pass\n" };
+    // Clicking `mod` — it is not a def inside pkg, it IS pkg/mod.py.
+    const loc = await resolvePythonDefinition(
+      main,
+      main.indexOf("import mod") + 8,
+      MAIN,
+      "/proj",
+      reader(files),
+    );
+    expect(loc).toEqual({ path: "/proj/pkg/mod.py", line: 1, column: 0 });
+  });
+
+  it("returns null for an unresolvable name rather than guessing", async () => {
+    const main = "import os\n\nos.getcwd()\nmystery()\n";
+    expect(
+      await resolvePythonDefinition(main, main.indexOf("mystery") + 1, MAIN, "/proj", reader({})),
+    ).toBeNull();
+    // A stdlib module that isn't in the project tree also has no local file.
+    expect(
+      await resolvePythonDefinition(main, main.indexOf("getcwd") + 1, MAIN, "/proj", reader({})),
+    ).toBeNull();
+  });
+
+  it("terminates on a circular re-export instead of hanging", async () => {
+    const main = "from .a import thing\n";
+    const files = {
+      // a re-exports from b, b re-exports back from a — legal, and it happens.
+      "/proj/a.py": "from .b import thing\n",
+      "/proj/b.py": "from .a import thing\n",
+    };
+    const loc = await resolvePythonDefinition(
+      main,
+      main.indexOf("thing") + 1,
+      MAIN,
+      "/proj",
+      reader(files),
+    );
+    expect(loc).toBeNull();
+  });
+});
+
+// ── Link ranges (what ctrl+click underlines) ─────────────────────────────────
+
+describe("pythonLinkRanges", () => {
+  const rangesOf = (src: string) =>
+    pythonLinkRanges(src).map((r) => src.slice(r.start, r.end));
+
+  it("underlines uses of imported names and local defs", () => {
+    const src = "from .util import helper\n\ndef run():\n    helper()\n\nrun()\n";
+    expect(rangesOf(src)).toEqual(["helper", "helper", "run"]);
+  });
+
+  it("underlines an attribute of an imported module, and the module itself", () => {
+    const src = "import util\n\nutil.helper()\n";
+    // `util` at the import site + at the use site, and the attribute.
+    expect(rangesOf(src)).toEqual(["util", "util", "helper"]);
+  });
+
+  it("does not underline a definition site — jumping to it would be a no-op", () => {
+    const src = "def solo():\n    pass\n";
+    expect(rangesOf(src)).toEqual([]);
+  });
+
+  it("does not underline an unresolvable name, so the affordance never lies", () => {
+    const src = "mystery()\nobj.method()\n";
+    expect(rangesOf(src)).toEqual([]);
+  });
+
+  it("does not underline keywords or names inside strings", () => {
+    const src = "from .util import helper\n\nreturn_value = 'helper'\n";
+    expect(rangesOf(src)).toEqual(["helper"]);
+  });
+
+  it("underlines self.method only when the method exists in this file", () => {
+    const src = ["class C:", "    def run(self):", "        self.step()", "        self.absent()", "    def step(self):", "        pass"].join("\n");
+    expect(rangesOf(src)).toEqual(["step"]);
+  });
+});
diff --git a/src/__tests__/PythonRun.test.ts b/src/__tests__/PythonRun.test.ts
new file mode 100644
index 0000000..5ed6981
--- /dev/null
+++ b/src/__tests__/PythonRun.test.ts
@@ -0,0 +1,112 @@
+import { describe, it, expect } from "vitest";
+import {
+  buildDebugCommand,
+  buildRunCommand,
+  pyTabLabel,
+  runCwd,
+  shellQuote,
+  systemInterpreter,
+} from "../lib/pythonRun";
+
+describe("shellQuote", () => {
+  it("single-quotes on unix and escapes an embedded quote", () => {
+    expect(shellQuote("/a/b c.py", "unix")).toBe("'/a/b c.py'");
+    expect(shellQuote("it's.py", "unix")).toBe(`'it'\\''s.py'`);
+  });
+
+  it("double-quotes on windows (cmd.exe has no single-quote syntax)", () => {
+    expect(shellQuote("C:\\a b\\x.py", "windows")).toBe('"C:\\a b\\x.py"');
+    expect(shellQuote('a"b', "windows")).toBe('"a""b"');
+  });
+});
+
+describe("systemInterpreter", () => {
+  // Interpreter *selection* (venv/poetry/conda/pyenv precedence) lives in the
+  // backend (`commands::python`) and is tested there — one ranking, one place.
+  // What the frontend still owns is the last-resort fallback when the backend
+  // can't be reached at all, so Run degrades instead of refusing.
+  it("is the platform's system python", () => {
+    expect(systemInterpreter("unix")).toBe("python3");
+    expect(systemInterpreter("windows")).toBe("python");
+  });
+});
+
+describe("buildRunCommand", () => {
+  it("quotes both the interpreter and the file", () => {
+    expect(buildRunCommand(".venv/bin/python", "/proj/a b/main.py", "unix")).toBe(
+      "'.venv/bin/python' '/proj/a b/main.py'",
+    );
+  });
+
+  it("appends the user's arguments verbatim after the file", () => {
+    // The args are a raw shell string the host shell parses, not one quoted
+    // token — so `--epochs 5 "out dir"` reaches the program as three arguments.
+    expect(
+      buildRunCommand("python3", "/proj/main.py", "unix", '--epochs 5 "out dir"'),
+    ).toBe(`'python3' '/proj/main.py' --epochs 5 "out dir"`);
+  });
+
+  it("adds nothing for empty or whitespace-only args", () => {
+    expect(buildRunCommand("python3", "/proj/main.py", "unix", "")).toBe(
+      "'python3' '/proj/main.py'",
+    );
+    expect(buildRunCommand("python3", "/proj/main.py", "unix", "   ")).toBe(
+      "'python3' '/proj/main.py'",
+    );
+  });
+});
+
+describe("buildDebugCommand", () => {
+  const FILE = "/proj/main.py";
+
+  it("pre-loads the breakpoints and runs straight to the first one", () => {
+    expect(buildDebugCommand("python3", FILE, [12, 4], "unix")).toBe(
+      "'python3' -m pdb -c 'b /proj/main.py:4' -c 'b /proj/main.py:12' -c 'continue' '/proj/main.py'",
+    );
+  });
+
+  it("omits `continue` with no breakpoints, so pdb stops at the first line", () => {
+    // With a trailing `continue` and nothing to break on, pdb would run the
+    // program to completion — "debug" would be indistinguishable from "run".
+    expect(buildDebugCommand("python3", FILE, [], "unix")).toBe(
+      "'python3' -m pdb '/proj/main.py'",
+    );
+  });
+
+  it("sorts and deduplicates the breakpoint lines", () => {
+    const cmd = buildDebugCommand("python3", FILE, [9, 3, 9], "unix");
+    expect(cmd.match(/-c 'b [^']+'/g)).toEqual([
+      "-c 'b /proj/main.py:3'",
+      "-c 'b /proj/main.py:9'",
+    ]);
+  });
+
+  it("quotes a windows path (whose drive colon must survive pdb's file:line split)", () => {
+    expect(buildDebugCommand("python", "C:\\p\\main.py", [7], "windows")).toBe(
+      '"python" -m pdb -c "b C:\\p\\main.py:7" -c "continue" "C:\\p\\main.py"',
+    );
+  });
+
+  it("passes the script's arguments after the file, as pdb expects", () => {
+    expect(buildDebugCommand("python3", FILE, [12], "unix", "--verbose in.txt")).toBe(
+      "'python3' -m pdb -c 'b /proj/main.py:12' -c 'continue' '/proj/main.py' --verbose in.txt",
+    );
+  });
+});
+
+describe("pyTabLabel", () => {
+  it("names the tab after the file, marked by mode", () => {
+    expect(pyTabLabel("run", "/proj/pkg/main.py")).toBe("▶ main.py");
+    expect(pyTabLabel("debug", "/proj/pkg/main.py")).toBe("🐞 main.py");
+  });
+});
+
+describe("runCwd", () => {
+  it("runs from the project root when there is one", () => {
+    expect(runCwd("/proj", "/proj/pkg/main.py")).toBe("/proj");
+  });
+  it("falls back to the file's own directory outside a project", () => {
+    expect(runCwd(null, "/tmp/scratch/main.py")).toBe("/tmp/scratch");
+    expect(runCwd("", "/tmp/scratch/main.py")).toBe("/tmp/scratch");
+  });
+});
diff --git a/src/__tests__/PythonRunArgs.test.ts b/src/__tests__/PythonRunArgs.test.ts
new file mode 100644
index 0000000..2e43c46
--- /dev/null
+++ b/src/__tests__/PythonRunArgs.test.ts
@@ -0,0 +1,57 @@
+/**
+ * Python Run/Debug arguments (#py) are kept PER FILE — keyed by absolute path in
+ * global settings — not per tab, so every viewer of the same script shares one
+ * set of args and they survive an Eldrun restart (settings.json). These tests
+ * lock the store action that owns that map: set, share-by-path, and clear-prunes.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import { useSettingsStore } from "../stores/settings";
+
+const invokeMock = vi.mocked(invoke);
+
+function reset() {
+  invokeMock.mockClear();
+  useSettingsStore.setState({ settings: {}, loaded: true });
+}
+
+describe("setPythonRunArgs (per-file run args)", () => {
+  beforeEach(reset);
+
+  it("stores args keyed by the file's absolute path", async () => {
+    await useSettingsStore.getState().setPythonRunArgs("/p/main.py", "--epochs 5 data.csv");
+    expect(useSettingsStore.getState().settings?.python_run_args).toEqual({
+      "/p/main.py": "--epochs 5 data.csv",
+    });
+    // Persisted through the ordinary settings write (settings.json, round-tripped
+    // via the backend's `extra` catch-all — no bespoke command).
+    const saved = invokeMock.mock.calls.find((c) => c[0] === "save_settings");
+    expect(saved).toBeTruthy();
+  });
+
+  it("trims and keeps distinct files independent (shared only within one path)", async () => {
+    await useSettingsStore.getState().setPythonRunArgs("/p/a.py", "  --x 1  ");
+    await useSettingsStore.getState().setPythonRunArgs("/p/b.py", "--y 2");
+    expect(useSettingsStore.getState().settings?.python_run_args).toEqual({
+      "/p/a.py": "--x 1",
+      "/p/b.py": "--y 2",
+    });
+  });
+
+  it("clears an entry (empty string) by pruning it, not storing ''", async () => {
+    await useSettingsStore.getState().setPythonRunArgs("/p/main.py", "--epochs 5");
+    await useSettingsStore.getState().setPythonRunArgs("/p/main.py", "");
+    expect(useSettingsStore.getState().settings?.python_run_args).toEqual({});
+  });
+
+  it("is a no-op when the args are unchanged (no redundant settings write)", async () => {
+    await useSettingsStore.getState().setPythonRunArgs("/p/main.py", "--epochs 5");
+    invokeMock.mockClear();
+    await useSettingsStore.getState().setPythonRunArgs("/p/main.py", "--epochs 5");
+    expect(invokeMock.mock.calls.some((c) => c[0] === "save_settings")).toBe(false);
+  });
+});
diff --git a/src/__tests__/PythonViewer.test.tsx b/src/__tests__/PythonViewer.test.tsx
new file mode 100644
index 0000000..dd42dbc
--- /dev/null
+++ b/src/__tests__/PythonViewer.test.tsx
@@ -0,0 +1,354 @@
+/**
+ * Python features in the native code viewer (#py), driven through the real UI:
+ *  - Run/Debug open a terminal tab in the file's OWN project scope, running the
+ *    venv interpreter when the project has one.
+ *  - The gutter sets breakpoints (snapping off blank/comment lines), and Debug
+ *    hands them to pdb.
+ *  - Ctrl+Click on an imported name opens the defining file at its `def`.
+ *  - None of it appears for a non-Python file.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act, waitFor, fireEvent } from "@testing-library/react";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("@tauri-apps/api/event", () => ({
+  emit: vi.fn(() => Promise.resolve()),
+  listen: vi.fn(() => Promise.resolve(() => {})),
+}));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: { getState: () => ({ openFile: () => Promise.resolve() }) },
+}));
+// Run/Debug + the gutter are behind the experimental `python_run_debug` setting;
+// the tests below turn it on, and the last block asserts what is left with it off.
+const { settingsState } = vi.hoisted(() => ({
+  settingsState: {
+    settings: { autosave: false, viewer_prefs: {}, python_run_debug: true } as Record<
+      string,
+      unknown
+    >,
+  },
+}));
+vi.mock("../stores/settings", () => ({
+  useSettingsStore: Object.assign((sel: (s: unknown) => unknown) => sel(settingsState), {
+    getState: () => settingsState,
+  }),
+}));
+vi.mock("../stores/projects", () => {
+  const state = {
+    projects: [{ id: "proj", directory: "/p", local_file: "/p/project.json" }],
+    activeId: "proj",
+  };
+  const useProjectsStore = Object.assign(
+    (sel?: (s: typeof state) => unknown) => (sel ? sel(state) : state),
+    { getState: () => state },
+  );
+  return { useProjectsStore };
+});
+
+// The tabs store is mocked so the test can assert on exactly what Run/Debug and
+// go-to-definition ask it to open, without standing up a layout tree.
+const { addTabToScope, addTab, setActive, removeTab, setViewerState } = vi.hoisted(() => ({
+  addTabToScope: vi.fn((_scope: string, tab: Record<string, unknown>) => ({ ...tab, key: "t1" })),
+  addTab: vi.fn((tab: Record<string, unknown>) => ({ ...tab, key: "t2" })),
+  setActive: vi.fn(),
+  removeTab: vi.fn(),
+  setViewerState: vi.fn(),
+}));
+vi.mock("../stores/tabs", () => {
+  const state = {
+    tabs: [] as Record<string, unknown>[],
+    layout: null,
+    addTabToScope,
+    addTab,
+    setActive,
+    removeTab,
+    setViewerState,
+    splitWithNewTab: vi.fn(() => null),
+  };
+  const useTabsStore = Object.assign(
+    (sel?: (s: typeof state) => unknown) => (sel ? sel(state) : state),
+    { getState: () => state },
+  );
+  return {
+    useTabsStore,
+    findGroupOfTab: () => null,
+    getDetachedViewerState: () => undefined,
+  };
+});
+
+// Run/Debug only show for a "main" script (a module-level `__main__` guard),
+// so the fixture needs one — kept on line 3 so the blank-line-2-snaps-to-3
+// breakpoint tests below still land where they expect.
+const MAIN = 'from .util import helper\n\nif __name__ == "__main__":\n    helper()\n';
+const UTIL = "import os\n\n\ndef helper(x):\n    return x\n";
+
+/** What the backend's interpreter resolver hands back (#87): the project's pinned
+ *  choice, else the best auto-detected environment. The *precedence* is the
+ *  backend's business (`commands::python`, tested there); here it is simply the
+ *  answer Run/Debug are obliged to use. */
+let interpreter = "python3";
+
+function setup() {
+  interpreter = "python3";
+  settingsState.settings.python_run_debug = true;
+  mockInvoke.mockImplementation((cmd: string, args: Record<string, unknown> = {}) => {
+    if (cmd === "read_file_text") {
+      const path = args.path as string;
+      if (path === "/p/main.py") return Promise.resolve(MAIN);
+      if (path === "/p/util.py") return Promise.resolve(UTIL);
+      if (path === "/p/notes.txt") return Promise.resolve("plain text\n");
+      return Promise.reject(new Error("no such file"));
+    }
+    if (cmd === "file_mtime") return Promise.resolve(1000);
+    if (cmd === "python_interpreter_for") return Promise.resolve(interpreter);
+    return Promise.resolve(null);
+  });
+}
+
+async function renderViewer(path = "/p/main.py") {
+  vi.resetModules();
+  const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+  await act(async () => {
+    render(<FileViewerPane viewer="text" path={path} projectId="proj" />);
+  });
+  const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
+  await waitFor(() => expect(textarea.value.length).toBeGreaterThan(0));
+  return textarea;
+}
+
+/** The tab Run/Debug opened. */
+function launchedTab() {
+  expect(addTabToScope).toHaveBeenCalledTimes(1);
+  const [scope, tab] = addTabToScope.mock.calls[0] as [string, Record<string, unknown>];
+  return { scope, tab };
+}
+
+describe("python run/debug (#py)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  it("Run opens a shell tab in the file's project scope, running the file", async () => {
+    await renderViewer();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Run file"));
+    });
+
+    const { scope, tab } = launchedTab();
+    // The file's OWN project, not whichever is globally active.
+    expect(scope).toBe("proj");
+    expect(tab.kind).toBe("shell");
+    expect(tab.cwd).toBe("/p");
+    expect(tab.initialInput).toBe("'python3' '/p/main.py'");
+    expect(setActive).toHaveBeenCalledWith("t1");
+  });
+
+  it("Run uses the interpreter the backend resolved, not a bare python3", async () => {
+    await renderViewer();
+    // The project's venv (or conda env, or a pinned interpreter) — running with
+    // the system python3 would ModuleNotFoundError on the project's own deps.
+    interpreter = ".venv/bin/python";
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Run file"));
+    });
+    expect(launchedTab().tab.initialInput).toBe("'.venv/bin/python' '/p/main.py'");
+  });
+
+  it("Debug runs pdb under that same interpreter", async () => {
+    await renderViewer();
+    interpreter = "/opt/conda/envs/ml/bin/python";
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Debug file"));
+    });
+    expect(launchedTab().tab.initialInput).toBe(
+      "'/opt/conda/envs/ml/bin/python' -m pdb '/p/main.py'",
+    );
+  });
+
+  it("Debug with no breakpoints runs pdb, which stops at the first line", async () => {
+    await renderViewer();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Debug file"));
+    });
+    expect(launchedTab().tab.initialInput).toBe("'python3' -m pdb '/p/main.py'");
+  });
+
+  it("a gutter click sets a breakpoint, and Debug hands it to pdb", async () => {
+    await renderViewer();
+    // Line 3 is the `if __name__ == "__main__":` guard.
+    const line3 = screen.getByLabelText("Break on line 3");
+    expect(line3.getAttribute("aria-pressed")).toBe("false");
+    await act(async () => {
+      fireEvent.click(line3);
+    });
+    expect(
+      screen.getByLabelText("Remove breakpoint on line 3").getAttribute("aria-pressed"),
+    ).toBe("true");
+
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Debug file"));
+    });
+    expect(launchedTab().tab.initialInput).toBe(
+      "'python3' -m pdb -c 'b /p/main.py:3' -c 'continue' '/p/main.py'",
+    );
+  });
+
+  it("a click on a blank line snaps down to the next executable line", async () => {
+    await renderViewer();
+    // Line 2 is blank — pdb refuses to break there, so the dot lands on line 3.
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Break on line 2"));
+    });
+    expect(screen.queryByLabelText("Remove breakpoint on line 2")).toBeNull();
+    expect(screen.queryByLabelText("Remove breakpoint on line 3")).not.toBeNull();
+  });
+
+  it("clicking a set breakpoint clears it", async () => {
+    await renderViewer();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Break on line 3"));
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Remove breakpoint on line 3"));
+    });
+    expect(screen.getByLabelText("Break on line 3").getAttribute("aria-pressed")).toBe("false");
+  });
+
+  it("re-running replaces the previous run tab for the same file", async () => {
+    // A live run tab for this file, marked by the env vars openPythonTab writes.
+    const { useTabsStore } = await import("../stores/tabs");
+    const state = useTabsStore.getState() as unknown as { tabs: Record<string, unknown>[] };
+    state.tabs = [
+      {
+        key: "old",
+        kind: "shell",
+        env: { ELDRUN_PY_TARGET: "/p/main.py", ELDRUN_PY_MODE: "run" },
+      },
+    ];
+    await renderViewer();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Run file"));
+    });
+    // Killed rather than re-typed into: the old PTY may still be busy.
+    expect(removeTab).toHaveBeenCalledWith("old");
+    expect(addTabToScope).toHaveBeenCalledTimes(1);
+    state.tabs = [];
+  });
+});
+
+describe("python go-to-definition (#py)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  it("Ctrl+Click on an imported name opens the defining file at its def", async () => {
+    const textarea = await renderViewer();
+    // Caret inside the `helper()` call on line 3.
+    const caret = MAIN.lastIndexOf("helper") + 2;
+    textarea.selectionStart = textarea.selectionEnd = caret;
+
+    await act(async () => {
+      fireEvent.click(textarea, { ctrlKey: true });
+    });
+
+    // The sibling module was resolved and opened as its own viewer tab.
+    await waitFor(() => expect(addTab).toHaveBeenCalled());
+    const opened = addTab.mock.calls[0][0] as Record<string, unknown>;
+    expect(opened.embedPath).toBe("/p/util.py");
+    expect(opened.kind).toBe("embed");
+  });
+
+  it("a plain click (no modifier) never navigates", async () => {
+    const textarea = await renderViewer();
+    textarea.selectionStart = textarea.selectionEnd = MAIN.lastIndexOf("helper") + 2;
+    await act(async () => {
+      fireEvent.click(textarea);
+    });
+    expect(addTab).not.toHaveBeenCalled();
+  });
+
+  it("Ctrl+Click on an unresolvable name does nothing", async () => {
+    const textarea = await renderViewer();
+    // `os` is imported by util.py, not by this file, and is not in the tree.
+    textarea.selectionStart = textarea.selectionEnd = MAIN.indexOf("from") + 1;
+    await act(async () => {
+      fireEvent.click(textarea, { ctrlKey: true });
+    });
+    expect(addTab).not.toHaveBeenCalled();
+  });
+});
+
+describe("a plain module (no __main__ guard) keeps no Run/Debug", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  it("hides Run/Debug on a Python file with nothing to execute", async () => {
+    await renderViewer("/p/util.py");
+    expect(screen.queryByLabelText("Run file")).toBeNull();
+    expect(screen.queryByLabelText("Debug file")).toBeNull();
+  });
+});
+
+describe("non-Python files keep the plain editor", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  it("shows no Run/Debug buttons and no breakpoint gutter", async () => {
+    await renderViewer("/p/notes.txt");
+    expect(screen.queryByLabelText("Run file")).toBeNull();
+    expect(screen.queryByLabelText("Debug file")).toBeNull();
+    expect(screen.queryByLabelText("Break on line 1")).toBeNull();
+  });
+});
+
+describe("the experimental gate (`python_run_debug`, default off)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+    delete settingsState.settings.python_run_debug; // unset, not false
+  });
+
+  it("hides Debug and the breakpoint gutter on a Python file, but keeps Run", async () => {
+    await renderViewer();
+    // Run is deliberately ungated: it opens a plain terminal tab, nothing
+    // experimental about it. Only Debug (pdb) and the gutter that feeds it
+    // sit behind the flag.
+    expect(screen.queryByLabelText("Run file")).not.toBeNull();
+    expect(screen.queryByLabelText("Debug file")).toBeNull();
+    // The gutter exists only to feed Debug, so it goes with it.
+    expect(screen.queryByLabelText("Break on line 3")).toBeNull();
+  });
+
+  it("debug mode turns it on with no toggle to tick", async () => {
+    settingsState.settings.debug = true;
+    await renderViewer();
+    expect(screen.queryByLabelText("Run file")).not.toBeNull();
+    expect(screen.queryByLabelText("Break on line 3")).not.toBeNull();
+    delete settingsState.settings.debug;
+  });
+
+  it("an explicit off still wins inside debug mode", async () => {
+    settingsState.settings.debug = true;
+    settingsState.settings.python_run_debug = false;
+    await renderViewer();
+    expect(screen.queryByLabelText("Debug file")).toBeNull();
+    delete settingsState.settings.debug;
+  });
+
+  it("still follows Ctrl+Click to a definition — reading is not running", async () => {
+    const textarea = await renderViewer();
+    textarea.selectionStart = textarea.selectionEnd = MAIN.lastIndexOf("helper") + 2;
+    await act(async () => {
+      fireEvent.click(textarea, { ctrlKey: true });
+    });
+    await waitFor(() => expect(addTab).toHaveBeenCalled());
+    expect((addTab.mock.calls[0][0] as Record<string, unknown>).embedPath).toBe("/p/util.py");
+  });
+});
diff --git a/src/__tests__/ReadmeDefaultTab.test.tsx b/src/__tests__/ReadmeDefaultTab.test.tsx
deleted file mode 100644
index 2217c34..0000000
--- a/src/__tests__/ReadmeDefaultTab.test.tsx
+++ /dev/null
@@ -1,100 +0,0 @@
-/**
- * #57 — open README.md by default for a project with no tabs to restore.
- *
- * Tests the `openReadmeDefaultTab` helper that CenterPanel's first-visit restore
- * branch calls when a project yields zero restorable tabs:
- *   - README.md present → exactly one in-app markdown viewer embed tab is seeded;
- *   - README.md absent → no tab is created;
- *   - a scope already initialized (visited & emptied, or populated by a
- *     concurrent switch) is never re-seeded;
- *   - the root scope path is the caller's responsibility — here we assert the
- *     helper no-ops with an empty cwd (root has no project dir).
- */
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-const { invokeMock } = vi.hoisted(() => ({ invokeMock: vi.fn() }));
-vi.mock("@tauri-apps/api/core", () => ({ invoke: invokeMock }));
-
-import { openReadmeDefaultTab } from "../components/layout/CenterPanel";
-import { useTabsStore } from "../stores/tabs";
-
-function reset() {
-  useTabsStore.setState({
-    scope: "p1",
-    tabsByScope: {},
-    layoutByScope: {},
-    focusedGroupByScope: {},
-    tabs: [],
-    layout: null,
-    focusedGroupId: null,
-    activeKey: null,
-  });
-  invokeMock.mockReset();
-}
-
-const dirWith = (...names: string[]) =>
-  names.map((name) => ({ name, is_dir: false }));
-
-describe("#57 README default tab", () => {
-  beforeEach(reset);
-
-  it("creates a markdown viewer embed tab when README.md exists", async () => {
-    invokeMock.mockResolvedValueOnce(dirWith("README.md", "src", "package.json"));
-
-    await openReadmeDefaultTab("/proj", "p1");
-
-    const tabs = useTabsStore.getState().tabsByScope["p1"];
-    expect(tabs).toHaveLength(1);
-    const tab = tabs[0];
-    expect(tab.kind).toBe("embed");
-    expect(tab.viewer).toBe("markdown");
-    expect(tab.label).toBe("README.md");
-    expect(tab.embedPath).toBe("/proj/README.md");
-    expect(tab.scope).toBe("p1");
-    // list_dir was the only backend call (no new command needed).
-    expect(invokeMock).toHaveBeenCalledWith("list_dir", { projectDir: "/proj", relPath: "" });
-  });
-
-  it("creates no tab when README.md is absent", async () => {
-    invokeMock.mockResolvedValueOnce(dirWith("src", "package.json"));
-
-    await openReadmeDefaultTab("/proj", "p1");
-
-    expect(useTabsStore.getState().tabsByScope["p1"]).toBeUndefined();
-  });
-
-  it("does not seed a README tab into an already-initialized scope", async () => {
-    // Scope p1 was visited and emptied (key present, value []).
-    useTabsStore.setState((s) => ({ tabsByScope: { ...s.tabsByScope, p1: [] } }));
-    invokeMock.mockResolvedValueOnce(dirWith("README.md"));
-
-    await openReadmeDefaultTab("/proj", "p1");
-
-    expect(useTabsStore.getState().tabsByScope["p1"]).toEqual([]);
-  });
-
-  it("does not re-seed when a concurrent switch populates the scope mid-check", async () => {
-    invokeMock.mockImplementationOnce(async () => {
-      // Simulate switch_project_runtime landing while list_dir is in flight.
-      useTabsStore.getState().loadFromLayout(
-        [{ key: "s1", label: "bash", cmd: "bash", cwd: "/proj", kind: "shell" as const }],
-        "/proj",
-        "p1",
-      );
-      return dirWith("README.md");
-    });
-
-    await openReadmeDefaultTab("/proj", "p1");
-
-    // The shell tab from the concurrent switch survives; no README was added.
-    const tabs = useTabsStore.getState().tabsByScope["p1"];
-    expect(tabs).toHaveLength(1);
-    expect(tabs[0].kind).toBe("shell");
-  });
-
-  it("no-ops for an empty cwd (root scope has no project dir)", async () => {
-    await openReadmeDefaultTab("", "root");
-    expect(invokeMock).not.toHaveBeenCalled();
-    expect(useTabsStore.getState().tabsByScope["root"]).toBeUndefined();
-  });
-});
diff --git a/src/__tests__/Recurrence.test.ts b/src/__tests__/Recurrence.test.ts
new file mode 100644
index 0000000..001d5c2
--- /dev/null
+++ b/src/__tests__/Recurrence.test.ts
@@ -0,0 +1,347 @@
+import { describe, expect, it } from "vitest";
+import {
+  describeRrule,
+  excludeOccurrence,
+  expandEvent,
+  expandEvents,
+  occurrencesOn,
+  overrideOccurrence,
+} from "../lib/recurrence";
+import type { CalendarEvent, Rrule } from "../types";
+
+function event(over: Partial<CalendarEvent> = {}): CalendarEvent {
+  return {
+    id: "e1",
+    calendar_id: "default",
+    start: "2026-07-08T09:00",
+    end: "2026-07-08T10:00",
+    all_day: false,
+    title: "standup",
+    ...over,
+  };
+}
+
+function rule(over: Partial<Rrule> = {}): Rrule {
+  return { freq: "daily", interval: 1, ...over };
+}
+
+/** The rule-generated starts, which is what exdates/overrides key on. */
+const starts = (e: CalendarEvent, a: string, b: string) =>
+  expandEvent(e, a, b).map((o) => o.occurrenceStart);
+
+describe("non-recurring events", () => {
+  it("yields exactly one occurrence inside the window", () => {
+    const out = expandEvent(event(), "2026-07-01", "2026-08-01");
+    expect(out).toHaveLength(1);
+    expect(out[0].start).toBe("2026-07-08T09:00");
+    expect(out[0].end).toBe("2026-07-08T10:00");
+    expect(out[0].recurring).toBe(false);
+  });
+
+  it("yields nothing outside the window", () => {
+    expect(expandEvent(event(), "2026-09-01", "2026-10-01")).toHaveLength(0);
+  });
+
+  it("still shows a multi-day event that STARTED before the window", () => {
+    // A conference running Jun 29 - Jul 3; the July window must still see it.
+    const conf = event({ start: "2026-06-29", end: "2026-07-04", all_day: true });
+    const out = expandEvent(conf, "2026-07-01", "2026-08-01");
+    expect(out).toHaveLength(1);
+  });
+
+  it("drops a garbage start rather than throwing", () => {
+    expect(expandEvent(event({ start: "nope" }), "2026-07-01", "2026-08-01")).toEqual([]);
+  });
+});
+
+describe("daily recurrence", () => {
+  it("fires every day", () => {
+    const e = event({ rrule: rule() });
+    expect(starts(e, "2026-07-08", "2026-07-12")).toEqual([
+      "2026-07-08T09:00", "2026-07-09T09:00", "2026-07-10T09:00", "2026-07-11T09:00",
+    ]);
+  });
+
+  it("honours an interval", () => {
+    const e = event({ rrule: rule({ interval: 3 }) });
+    expect(starts(e, "2026-07-08", "2026-07-18")).toEqual([
+      "2026-07-08T09:00", "2026-07-11T09:00", "2026-07-14T09:00", "2026-07-17T09:00",
+    ]);
+  });
+
+  it("treats a 0 interval as 1 instead of looping forever", () => {
+    const e = event({ rrule: rule({ interval: 0 }) });
+    expect(starts(e, "2026-07-08", "2026-07-11")).toHaveLength(3);
+  });
+
+  it("carries the master's duration to every occurrence", () => {
+    const e = event({ end: "2026-07-08T09:30", rrule: rule() });
+    const out = expandEvent(e, "2026-07-08", "2026-07-10");
+    expect(out[1].start).toBe("2026-07-09T09:00");
+    expect(out[1].end).toBe("2026-07-09T09:30");
+  });
+
+  it("never fires before the master's own start", () => {
+    const e = event({ rrule: rule() });
+    // Window opens a week early; the series still begins on the 8th.
+    expect(starts(e, "2026-07-01", "2026-07-10")[0]).toBe("2026-07-08T09:00");
+  });
+
+  it("crosses a DST boundary without dropping or duplicating a day", () => {
+    const e = event({ start: "2026-03-27T09:00", end: "2026-03-27T10:00", rrule: rule() });
+    expect(starts(e, "2026-03-27", "2026-03-31")).toEqual([
+      "2026-03-27T09:00", "2026-03-28T09:00", "2026-03-29T09:00", "2026-03-30T09:00",
+    ]);
+  });
+});
+
+describe("weekly recurrence", () => {
+  it("fires on the master's weekday when no byweekday is given", () => {
+    // 2026-07-08 is a Wednesday.
+    const e = event({ rrule: rule({ freq: "weekly" }) });
+    expect(starts(e, "2026-07-08", "2026-08-01")).toEqual([
+      "2026-07-08T09:00", "2026-07-15T09:00", "2026-07-22T09:00", "2026-07-29T09:00",
+    ]);
+  });
+
+  it("fires on each selected weekday", () => {
+    // Mon (1) and Fri (5), starting Wed Jul 8 → Fri 10, Mon 13, Fri 17...
+    const e = event({ rrule: rule({ freq: "weekly", byweekday: [1, 5] }) });
+    expect(starts(e, "2026-07-08", "2026-07-20")).toEqual([
+      "2026-07-10T09:00", "2026-07-13T09:00", "2026-07-17T09:00",
+    ]);
+  });
+
+  it("includes the master's own weekday when it is selected", () => {
+    // Wed (3) is the master's weekday, so the master itself is occurrence one.
+    const e = event({ rrule: rule({ freq: "weekly", byweekday: [3, 5] }) });
+    expect(starts(e, "2026-07-08", "2026-07-18")).toEqual([
+      "2026-07-08T09:00", "2026-07-10T09:00", "2026-07-15T09:00", "2026-07-17T09:00",
+    ]);
+  });
+
+  it("skips whole weeks with an interval", () => {
+    const e = event({ rrule: rule({ freq: "weekly", byweekday: [3], interval: 2 }) });
+    expect(starts(e, "2026-07-08", "2026-08-06")).toEqual([
+      "2026-07-08T09:00", "2026-07-22T09:00", "2026-08-05T09:00",
+    ]);
+  });
+});
+
+describe("monthly recurrence", () => {
+  it("fires on the master's day of month", () => {
+    const e = event({ rrule: rule({ freq: "monthly" }) });
+    expect(starts(e, "2026-07-08", "2026-11-01")).toEqual([
+      "2026-07-08T09:00", "2026-08-08T09:00", "2026-09-08T09:00", "2026-10-08T09:00",
+    ]);
+  });
+
+  it("clamps a 31st master into shorter months when stepping", () => {
+    // Without bymonthday, stepping uses addMonths, which clamps.
+    const e = event({ start: "2026-01-31T09:00", end: "2026-01-31T10:00", rrule: rule({ freq: "monthly" }) });
+    const got = starts(e, "2026-01-01", "2026-04-01");
+    expect(got).toContain("2026-01-31T09:00");
+    expect(got).toContain("2026-02-28T09:00");
+  });
+
+  it("SKIPS months too short for an explicit bymonthday", () => {
+    // "the 31st of the month" simply has no February — the iCalendar behaviour.
+    const e = event({ start: "2026-01-31T09:00", end: "2026-01-31T10:00",
+      rrule: rule({ freq: "monthly", bymonthday: 31 }) });
+    const got = starts(e, "2026-01-01", "2026-05-01");
+    expect(got).toEqual(["2026-01-31T09:00", "2026-03-31T09:00"]);
+    expect(got.some((s) => s.startsWith("2026-02"))).toBe(false);
+    expect(got.some((s) => s.startsWith("2026-04"))).toBe(false); // April has 30
+  });
+
+  it("honours bymonthday with an interval", () => {
+    const e = event({ start: "2026-01-15T09:00", end: "2026-01-15T10:00",
+      rrule: rule({ freq: "monthly", bymonthday: 15, interval: 2 }) });
+    expect(starts(e, "2026-01-01", "2026-06-01")).toEqual([
+      "2026-01-15T09:00", "2026-03-15T09:00", "2026-05-15T09:00",
+    ]);
+  });
+});
+
+describe("yearly recurrence", () => {
+  it("fires once a year", () => {
+    const e = event({ rrule: rule({ freq: "yearly" }) });
+    expect(starts(e, "2026-01-01", "2029-01-01")).toEqual([
+      "2026-07-08T09:00", "2027-07-08T09:00", "2028-07-08T09:00",
+    ]);
+  });
+
+  it("clamps a Feb 29 master into common years", () => {
+    const e = event({ start: "2024-02-29T09:00", end: "2024-02-29T10:00", rrule: rule({ freq: "yearly" }) });
+    const got = starts(e, "2024-01-01", "2026-06-01");
+    expect(got).toContain("2024-02-29T09:00");
+    expect(got).toContain("2025-02-28T09:00");
+  });
+});
+
+describe("rule ends", () => {
+  it("stops after `count` occurrences", () => {
+    const e = event({ rrule: rule({ count: 3 }) });
+    expect(starts(e, "2026-07-08", "2026-08-01")).toEqual([
+      "2026-07-08T09:00", "2026-07-09T09:00", "2026-07-10T09:00",
+    ]);
+  });
+
+  it("stops after `until`, inclusive of that date", () => {
+    const e = event({ rrule: rule({ until: "2026-07-10" }) });
+    expect(starts(e, "2026-07-08", "2026-08-01")).toEqual([
+      "2026-07-08T09:00", "2026-07-09T09:00", "2026-07-10T09:00",
+    ]);
+  });
+
+  it("counts occurrences from the series start, not the window start", () => {
+    // count:3 means 3 occurrences EVER. A window opening on the 10th must show
+    // only the third one, not three fresh ones.
+    const e = event({ rrule: rule({ count: 3 }) });
+    const out = expandEvent(e, "2026-07-10", "2026-08-01");
+    expect(out.map((o) => o.occurrenceStart)).toEqual(["2026-07-10T09:00"]);
+  });
+
+  it("an endless rule is bounded by the window, not by memory", () => {
+    const e = event({ rrule: rule() });
+    const out = expandEvent(e, "2026-07-08", "2026-07-15");
+    expect(out).toHaveLength(7);
+  });
+});
+
+describe("exdates — 'this event only' delete", () => {
+  it("drops the excluded occurrence and keeps the rest", () => {
+    const e = event({ rrule: rule(), exdates: ["2026-07-09T09:00"] });
+    expect(starts(e, "2026-07-08", "2026-07-12")).toEqual([
+      "2026-07-08T09:00", "2026-07-10T09:00", "2026-07-11T09:00",
+    ]);
+  });
+
+  it("excludeOccurrence adds the exdate", () => {
+    const e = excludeOccurrence(event({ rrule: rule() }), "2026-07-09T09:00");
+    expect(e.exdates).toEqual(["2026-07-09T09:00"]);
+    expect(starts(e, "2026-07-08", "2026-07-11")).toEqual([
+      "2026-07-08T09:00", "2026-07-10T09:00",
+    ]);
+  });
+
+  it("excluding an occurrence discards its now-dead override", () => {
+    let e = overrideOccurrence(event({ rrule: rule() }), "2026-07-09T09:00", { title: "moved" });
+    e = excludeOccurrence(e, "2026-07-09T09:00");
+    expect(e.overrides).toEqual([]);
+  });
+});
+
+describe("overrides — 'this event only' edit", () => {
+  it("applies an edited title to just that occurrence", () => {
+    const e = overrideOccurrence(event({ rrule: rule() }), "2026-07-09T09:00", { title: "retro" });
+    const out = expandEvent(e, "2026-07-08", "2026-07-11");
+    expect(out.map((o) => o.title)).toEqual(["standup", "retro", "standup"]);
+  });
+
+  it("moves just that occurrence, keeping its duration", () => {
+    const e = overrideOccurrence(event({ rrule: rule() }), "2026-07-09T09:00", {
+      start: "2026-07-09T14:00",
+    });
+    const out = expandEvent(e, "2026-07-08", "2026-07-11");
+    const moved = out.find((o) => o.occurrenceStart === "2026-07-09T09:00")!;
+    expect(moved.start).toBe("2026-07-09T14:00");
+    expect(moved.end).toBe("2026-07-09T15:00"); // the master's 1h duration
+  });
+
+  it("keys on the ORIGINAL start, so a moved occurrence still matches", () => {
+    // The override moved it to the 14:00 slot, but its key stays the 09:00 one it
+    // was generated at — otherwise the next expansion would lose the edit.
+    const e = overrideOccurrence(event({ rrule: rule() }), "2026-07-09T09:00", {
+      start: "2026-07-09T14:00", title: "moved",
+    });
+    const again = expandEvent(e, "2026-07-08", "2026-07-11");
+    const moved = again.find((o) => o.start === "2026-07-09T14:00")!;
+    expect(moved.title).toBe("moved");
+    expect(moved.occurrenceStart).toBe("2026-07-09T09:00");
+  });
+
+  it("re-overriding the same occurrence replaces, not duplicates", () => {
+    let e = overrideOccurrence(event({ rrule: rule() }), "2026-07-09T09:00", { title: "a" });
+    e = overrideOccurrence(e, "2026-07-09T09:00", { title: "b" });
+    expect(e.overrides).toHaveLength(1);
+    expect(e.overrides![0].title).toBe("b");
+  });
+
+  it("an override leaves the other occurrences untouched", () => {
+    const e = overrideOccurrence(event({ rrule: rule() }), "2026-07-09T09:00", {
+      start: "2026-07-09T14:00",
+    });
+    const out = expandEvent(e, "2026-07-08", "2026-07-11");
+    expect(out.find((o) => o.occurrenceStart === "2026-07-10T09:00")!.start).toBe("2026-07-10T09:00");
+  });
+});
+
+describe("all-day recurrence", () => {
+  it("keeps the exclusive end one day out", () => {
+    const e = event({ start: "2026-07-08", end: "2026-07-09", all_day: true, rrule: rule() });
+    const out = expandEvent(e, "2026-07-08", "2026-07-11");
+    expect(out[0]).toMatchObject({ start: "2026-07-08", end: "2026-07-09", allDay: true });
+    expect(out[1]).toMatchObject({ start: "2026-07-09", end: "2026-07-10" });
+  });
+
+  it("carries a multi-day span to each occurrence", () => {
+    // A 3-day all-day block repeating weekly.
+    const e = event({ start: "2026-07-08", end: "2026-07-11", all_day: true,
+      rrule: rule({ freq: "weekly" }) });
+    const out = expandEvent(e, "2026-07-08", "2026-07-20");
+    expect(out[0]).toMatchObject({ start: "2026-07-08", end: "2026-07-11" });
+    expect(out[1]).toMatchObject({ start: "2026-07-15", end: "2026-07-18" });
+  });
+});
+
+describe("expandEvents", () => {
+  it("sorts all-day first, then chronologically", () => {
+    const out = expandEvents(
+      [
+        event({ id: "b", start: "2026-07-08T14:00", end: "2026-07-08T15:00", title: "late" }),
+        event({ id: "a", start: "2026-07-08T09:00", end: "2026-07-08T10:00", title: "early" }),
+        event({ id: "c", start: "2026-07-08", end: "2026-07-09", all_day: true, title: "allday" }),
+      ],
+      "2026-07-08",
+      "2026-07-09",
+    );
+    expect(out.map((o) => o.title)).toEqual(["allday", "early", "late"]);
+  });
+
+  it("drops events on hidden calendars", () => {
+    const out = expandEvents(
+      [
+        event({ id: "a", calendar_id: "default", title: "shown" }),
+        event({ id: "b", calendar_id: "work", title: "hidden" }),
+      ],
+      "2026-07-08",
+      "2026-07-09",
+      new Set(["default"]),
+    );
+    expect(out.map((o) => o.title)).toEqual(["shown"]);
+  });
+
+  it("finds the occurrences of a given day", () => {
+    const occ = expandEvents([event({ rrule: rule() })], "2026-07-08", "2026-07-12");
+    expect(occurrencesOn(occ, "2026-07-10")).toHaveLength(1);
+    expect(occurrencesOn(occ, "2026-07-20")).toHaveLength(0);
+  });
+});
+
+describe("describeRrule", () => {
+  it("describes the common rules", () => {
+    expect(describeRrule(null)).toBe("Does not repeat");
+    expect(describeRrule(rule())).toBe("Daily");
+    expect(describeRrule(rule({ interval: 3 }))).toBe("Every 3 days");
+    expect(describeRrule(rule({ freq: "weekly", byweekday: [1, 5] })))
+      .toBe("Weekly on Monday, Friday");
+    expect(describeRrule(rule({ freq: "monthly", bymonthday: 15 }))).toBe("Monthly on day 15");
+    expect(describeRrule(rule({ freq: "yearly" }))).toBe("Yearly");
+  });
+
+  it("appends the rule's end", () => {
+    expect(describeRrule(rule({ count: 5 }))).toBe("Daily, 5 times");
+    expect(describeRrule(rule({ until: "2026-12-31" }))).toBe("Daily, until 2026-12-31");
+  });
+});
diff --git a/src/__tests__/RemoteActivateConnect.test.ts b/src/__tests__/RemoteActivateConnect.test.ts
new file mode 100644
index 0000000..592ee55
--- /dev/null
+++ b/src/__tests__/RemoteActivateConnect.test.ts
@@ -0,0 +1,520 @@
+/**
+ * Auto-connect: a remote project that opted in comes up by itself — silently.
+ *
+ * The default stays what it always was: a remote project surfaces disconnected and
+ * the user brings it up from the pill's connection lamp. The opt-in
+ * (`remote.auto_connect`, offered only once a saved password or key auth makes the
+ * connect promptless) changes that for one project: it is connected on launch and
+ * on activation, and it *never* prompts — a stale opt-in degrades to staying
+ * disconnected rather than ambushing the user with a modal.
+ *
+ * The load-bearing case is the VPN, because whether the tunnel is needed is a
+ * property of the *network*, not of the project: the same host is reachable
+ * directly at the office and only through the tunnel from home. So auto-connect
+ * probes instead of assuming — and escalates to the tunnel only when the host is
+ * genuinely unreachable, never when it merely rejected a credential.
+ */
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+
+import { retryAutoConnectAfterVpn, useProjectsStore } from "../stores/projects";
+import { useConnectDialogStore } from "../stores/connectDialog";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+import { useSettingsStore } from "../stores/settings";
+import { useTabsStore } from "../stores/tabs";
+import { useVpnStatusStore } from "../stores/vpnStatus";
+import { forgetConnection } from "../lib/remoteConnect";
+import type { ProjectEntry, RemoteSpec, Settings, SshProbe } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+const REACHABLE: SshProbe = { ok: true, unreachable: false, error: "" };
+const UNREACHABLE: SshProbe = {
+  ok: false,
+  unreachable: true,
+  error: "ssh: connect to host host.example port 22: Connection timed out",
+};
+const REJECTED: SshProbe = {
+  ok: false,
+  unreachable: false,
+  error: "alice@host.example: Permission denied (publickey,password).",
+};
+
+const project = (id: string, remote?: Partial<RemoteSpec>): ProjectEntry =>
+  ({
+    id,
+    name: id,
+    directory: `/local/${id}`,
+    position: 0,
+    status: "active",
+    ...(remote
+      ? { remote: { user: "alice", host: "host.example", remote_path: "/srv/work", ...remote } }
+      : {}),
+  }) as unknown as ProjectEntry;
+
+/**
+ * Drive the mocked backend. `probe` is what `ssh_probe` answers (an array is
+ * consumed one call at a time, so a connect can be unreachable and then reachable
+ * once the tunnel is up); every other command resolves unless overridden.
+ */
+const backend = (opts: {
+  probe?: SshProbe | SshProbe[];
+  sshSaved?: boolean;
+  vpnSaved?: boolean;
+  vpnFails?: boolean;
+  /** Non-headless: how many readiness polls fail before the root-terminal login's
+   *  ControlMaster answers (`Infinity` = the user never authenticates). */
+  loginReadyAfter?: number;
+  /** Non-headless: `openvpn_status` answers true from this poll onwards. */
+  vpnUpAfter?: number;
+}) => {
+  const probes = Array.isArray(opts.probe) ? [...opts.probe] : opts.probe ? [opts.probe] : [];
+  let sshConnects = 0;
+  let vpnStatusChecks = 0;
+  invokeMock.mockImplementation((cmd: string) => {
+    switch (cmd) {
+      case "ssh_probe":
+        return Promise.resolve(probes.length > 1 ? probes.shift()! : (probes[0] ?? REACHABLE));
+      case "remote_has_saved_password":
+        return Promise.resolve(opts.sshSaved ?? true);
+      // The eligibility gate reads the tri-state now, so that "not saved" and
+      // "keyring unreadable" can be told apart in what the user is told. An
+      // unmocked resolve here would answer `undefined`, which reads as neither.
+      case "remote_saved_password_state":
+        return Promise.resolve({ saved: opts.sshSaved ?? true, keyring: "unlocked" });
+      case "vpn_has_saved_password":
+        return Promise.resolve(opts.vpnSaved ?? false);
+      case "openvpn_connect":
+        return opts.vpnFails ? Promise.reject("tunnel failed") : Promise.resolve();
+      case "remote_login_command":
+        return Promise.resolve("ssh -tt alice@host.example");
+      case "openvpn_login_command":
+        return Promise.resolve("pkexec openvpn --config /cfg.ovpn");
+      case "openvpn_status":
+        return Promise.resolve(++vpnStatusChecks > (opts.vpnUpAfter ?? Infinity));
+      case "ssh_connect":
+        return sshConnects++ >= (opts.loginReadyAfter ?? 0)
+          ? Promise.resolve()
+          : Promise.reject("not authenticated yet");
+      default:
+        return Promise.resolve();
+    }
+  });
+};
+
+/** Resolve the microtasks the fire-and-forget connect chain runs on. */
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+const sshLamp = () => useRemoteStatusStore.getState().byProject.remote1?.ssh;
+const vpnLamp = () => useRemoteStatusStore.getState().byProject.remote1?.vpn;
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation(() => Promise.resolve());
+  useConnectDialogStore.setState({ projectId: null });
+  useRemoteStatusStore.setState({ byProject: {} });
+  useProjectsStore.setState({ projects: [], activeId: null });
+  // Settings must be **loaded** for auto-connect to run at all: the HPC gate
+  // (`lib/hpcHost`'s `mayAutoTouch`) fails closed on an unloaded store, because
+  // "we haven't read the tag yet" must not authorise a connect. The app has them
+  // by the time any project is activated — `load()` now waits for them — so the
+  // tests give them too. The tag map is empty, so no host here is HPC-tagged.
+  useSettingsStore.setState({ settings: {} as Settings, loaded: true });
+});
+
+describe("auto-connect opt-in", () => {
+  it("connects a flagged project silently, without touching the VPN", async () => {
+    backend({ probe: REACHABLE, sshSaved: true });
+    useProjectsStore.setState({ projects: [project("remote1", { auto_connect: true })] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    expect(invokeMock).toHaveBeenCalledWith("remote_connect", {
+      projectId: "remote1",
+      password: null,
+    });
+    expect(sshLamp()).toBe("connected");
+    // Reachable directly: the tunnel is unnecessary on this network and must stay down.
+    expect(invokeMock).not.toHaveBeenCalledWith("openvpn_connect", expect.anything());
+    // Nothing to ask for — the modal must stay shut.
+    expect(useConnectDialogStore.getState().projectId).toBeNull();
+  });
+
+  it("leaves an unflagged remote project disconnected, and never prompts", async () => {
+    backend({ probe: REACHABLE, sshSaved: true });
+    useProjectsStore.setState({ projects: [project("remote1")] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    expect(invokeMock).not.toHaveBeenCalledWith("remote_connect", expect.anything());
+    expect(sshLamp()).toBeUndefined();
+    expect(useConnectDialogStore.getState().projectId).toBeNull();
+  });
+
+  it("connects the initially-active flagged project on launch", async () => {
+    backend({ probe: REACHABLE, sshSaved: true });
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "get_projects")
+        return Promise.resolve([{ ...project("remote1", { auto_connect: true }), status: "current" }]);
+      if (cmd === "ssh_probe") return Promise.resolve(REACHABLE);
+      if (cmd === "remote_has_saved_password") return Promise.resolve(true);
+      return Promise.resolve();
+    });
+
+    await useProjectsStore.getState().load();
+    await settle();
+
+    expect(invokeMock).toHaveBeenCalledWith("remote_connect", {
+      projectId: "remote1",
+      password: null,
+    });
+    expect(sshLamp()).toBe("connected");
+  });
+
+  it("brings the VPN up when the host is unreachable, then connects", async () => {
+    // The other network: the host answers only through the tunnel.
+    backend({
+      probe: [UNREACHABLE, REACHABLE],
+      sshSaved: true,
+      vpnSaved: true,
+    });
+    useProjectsStore.setState({
+      projects: [
+        project("remote1", { auto_connect: true, openvpn: { config: "/cfg.ovpn" } }),
+      ],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    expect(invokeMock).toHaveBeenCalledWith("openvpn_connect", {
+      config: "/cfg.ovpn",
+      username: null,
+      password: null,
+      keyPassphrase: null,
+      // `null`, never `false`: the backend reads `false` as "the user unticked Save
+      // passphrase" and clears the keychain — an auto-connect would then delete the
+      // passphrase it just used, and prompt on the next launch.
+      remember: null,
+    });
+    expect(vpnLamp()).toBe("connected");
+    expect(sshLamp()).toBe("connected");
+  });
+
+  it("does not bring the VPN up when the host merely rejected the credential", async () => {
+    // No tunnel fixes a wrong password, and it is not wanted on this network.
+    backend({ probe: REJECTED, sshSaved: true, vpnSaved: true });
+    useProjectsStore.setState({
+      projects: [
+        project("remote1", { auto_connect: true, openvpn: { config: "/cfg.ovpn" } }),
+      ],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    expect(invokeMock).not.toHaveBeenCalledWith("openvpn_connect", expect.anything());
+    expect(invokeMock).not.toHaveBeenCalledWith("remote_connect", expect.anything());
+    expect(sshLamp()).toBe("error");
+    // A failed auto-connect stays quiet: red lamp, no modal.
+    expect(useConnectDialogStore.getState().projectId).toBeNull();
+  });
+
+  it("stays disconnected when the saved password has since been forgotten", async () => {
+    // Stale opt-in: the toggle is on but the keychain entry is gone and the host is
+    // not key-auth. Connecting would prompt, so we must not connect at all.
+    backend({ probe: REACHABLE, sshSaved: false });
+    useProjectsStore.setState({ projects: [project("remote1", { auto_connect: true })] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    expect(invokeMock).not.toHaveBeenCalledWith("ssh_probe", expect.anything());
+    expect(invokeMock).not.toHaveBeenCalledWith("remote_connect", expect.anything());
+    expect(useConnectDialogStore.getState().projectId).toBeNull();
+  });
+
+  it("auto-connects a key-auth host with nothing in the keychain", async () => {
+    backend({ probe: REACHABLE, sshSaved: false });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true, key_auth: true })],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    expect(sshLamp()).toBe("connected");
+  });
+
+  it("abandons the connect — and the lamp — when the user switches away mid-probe", async () => {
+    let resolveProbe: ((p: SshProbe) => void) | undefined;
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "ssh_probe") return new Promise((res) => (resolveProbe = res as never));
+      if (cmd === "remote_has_saved_password") return Promise.resolve(true);
+      return Promise.resolve();
+    });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true }), project("local1")],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+    expect(sshLamp()).toBe("connecting"); // probe in flight — the lamp is ours
+
+    // Switch away while the probe is still in flight, then let it come back.
+    await useProjectsStore.getState().setActive("local1");
+    resolveProbe?.(REACHABLE);
+    await settle();
+
+    expect(invokeMock).not.toHaveBeenCalledWith("remote_connect", expect.anything());
+    // A lamp stuck on "connecting" would lie in the header *and* wedge the project
+    // shut — the next auto-connect only fires from "off".
+    expect(sshLamp()).toBe("off");
+  });
+
+  it("does not re-attack a host that already failed this session", async () => {
+    backend({ probe: REJECTED, sshSaved: true });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true }), project("local1")],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+    expect(sshLamp()).toBe("error");
+
+    const probesAfterFirst = invokeMock.mock.calls.filter(([cmd]) => cmd === "ssh_probe").length;
+    await useProjectsStore.getState().setActive("local1");
+    await useProjectsStore.getState().setActive("remote1");
+    await settle();
+
+    // Switching back and forth must not re-probe an unreachable host every time.
+    expect(invokeMock.mock.calls.filter(([cmd]) => cmd === "ssh_probe")).toHaveLength(
+      probesAfterFirst,
+    );
+  });
+});
+
+/**
+ * The same opt-in, in the mode where Eldrun handles no passwords at all
+ * (`connections_headless` off).
+ *
+ * The headless gate — a saved SSH password, or a `key_auth` host — can never pass
+ * there: nothing is ever written to the keychain in that mode, so auto-connect used
+ * to reject *every* project and do nothing at all, silently. The substitution is the
+ * one the header's "Connect on launch" already makes for a tunnel: the connect
+ * command opens in the **root terminal** for the user to authenticate, and the pooled
+ * connection then rides the ControlMaster that login leaves behind. The promise the
+ * toggle keeps is unchanged — no modal is ever raised — but it is kept differently.
+ */
+describe("auto-connect with connections_headless off", () => {
+  const rootTabs = () => useTabsStore.getState().tabsByScope.root ?? [];
+  const rootInputs = () => rootTabs().map((t) => t.initialInput);
+
+  beforeEach(() => {
+    useSettingsStore.setState({
+      settings: { connections_headless: false } as unknown as Settings,
+      loaded: true,
+    });
+    useTabsStore.setState({ tabsByScope: {}, layoutByScope: {} });
+    // The machine-wide VPN store is the thing a phantom would strand — start clean so
+    // an assertion of "no entry" means this test, not a leftover from another.
+    useVpnStatusStore.setState({ byConfig: {}, holders: {} });
+    // The root-terminal dedupe is module-level and session-lived by design (a project
+    // re-activated five times gets one login tab, not five), so each test has to hand
+    // its keys back or only the first would open one.
+    forgetConnection("ssh:alice@host.example:");
+    forgetConnection("vpn:/cfg.ovpn");
+    vi.useFakeTimers();
+  });
+
+  afterEach(async () => {
+    // Drain any readiness poll still in flight: its `autoConnecting` claim is only
+    // released when it resolves, and that claim is module-level too.
+    await vi.advanceTimersByTimeAsync(3000 * 41);
+    vi.useRealTimers();
+    useSettingsStore.setState({ settings: null, loaded: false });
+  });
+
+  it("opens the SSH login in the root terminal, then connects once it is authenticated", async () => {
+    // A password host: nothing saved, no key auth — exactly the project the headless
+    // gate used to reject outright.
+    backend({ probe: REJECTED, sshSaved: false, loginReadyAfter: 1 });
+    useProjectsStore.setState({ projects: [project("remote1", { auto_connect: true })] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+    // The login is waiting for the user; the lamp says so rather than going red.
+    expect(rootInputs()).toContain("ssh -tt alice@host.example");
+    expect(sshLamp()).toBe("connecting");
+    expect(useConnectDialogStore.getState().projectId).toBeNull();
+
+    // First readiness poll fails (not authenticated yet), the second rides the master.
+    await vi.advanceTimersByTimeAsync(7000);
+
+    expect(invokeMock).toHaveBeenCalledWith("remote_connect", {
+      projectId: "remote1",
+      hostId: null,
+      password: null,
+      // The pool rode the login's master, so the connect says nothing about how the
+      // host authenticates — the backend must not record `key_auth` off the back of
+      // it (`record_key_auth`), or this password host would claim a promptless
+      // connect it can't deliver the next time headless mode is on.
+      viaLogin: true,
+    });
+    expect(sshLamp()).toBe("connected");
+  });
+
+  it("connects a key-auth host with no terminal at all", async () => {
+    backend({ probe: REACHABLE, sshSaved: false });
+    useProjectsStore.setState({ projects: [project("remote1", { auto_connect: true })] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+
+    // The probe authenticated: there is nothing for the user to type, so no login tab.
+    expect(rootTabs()).toHaveLength(0);
+    expect(sshLamp()).toBe("connected");
+  });
+
+  it("surfaces the VPN login in the root terminal when the host is unreachable", async () => {
+    backend({ probe: UNREACHABLE, sshSaved: false });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true, openvpn: { config: "/cfg.ovpn" } })],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+    expect(rootInputs()).toContain("pkexec openvpn --config /cfg.ovpn");
+    // Eldrun never handles the passphrase here, so the headless connect must not fire.
+    expect(invokeMock).not.toHaveBeenCalledWith("openvpn_connect", expect.anything());
+    // Red, not "connecting" — the host is unreachable until the tunnel is up, and red
+    // is what `retryAutoConnectAfterVpn` clears once the tunnel actually comes up.
+    expect(sshLamp()).toBe("error");
+  });
+
+  // The regression that stranded the header on a phantom yellow tunnel: an unattended
+  // project poll that marked the *machine-wide* VPN "connecting" and then never
+  // resolved it. The header's Disconnect is disabled while "connecting" and the
+  // Connect dialog reads "connecting" as a live tunnel, so a phantom is un-stoppable
+  // AND un-reconnectable. Non-headless auto-connect must therefore NEVER put a config
+  // into the machine-wide store — the lamp belongs to `VpnIndicator`'s reconcile,
+  // which is driven by the backend's real tunnel set and cannot strand.
+  it("never marks the machine-wide tunnel connecting from auto-connect (no phantom)", async () => {
+    backend({ probe: UNREACHABLE, sshSaved: false });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true, openvpn: { config: "/cfg.ovpn" } })],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    // Run out the whole poll window that the old code would have spun on.
+    await vi.advanceTimersByTimeAsync(3000 * 45);
+
+    // The machine-wide store is untouched — no "connecting", no entry at all — so the
+    // header's Disconnect stays enabled and the dialog never thinks a tunnel is up.
+    // This is the load-bearing assertion: the phantom lived here.
+    expect(useVpnStatusStore.getState().byConfig).toEqual({});
+    // The project's own VPN lamp is likewise never stuck yellow (it defaults to "off"
+    // as a side effect of setting the SSH lamp; it must never be "connecting").
+    expect(vpnLamp()).not.toBe("connecting");
+    // Eldrun handles no passphrase here, so no silent connect fires.
+    expect(invokeMock).not.toHaveBeenCalledWith("openvpn_connect", expect.anything());
+  });
+
+  it("completes once the machine-wide reconcile reports the tunnel up", async () => {
+    // First activation: unreachable, so the VPN login is surfaced and SSH goes red.
+    backend({ probe: UNREACHABLE, sshSaved: false });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true, openvpn: { config: "/cfg.ovpn" } })],
+    });
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+    expect(sshLamp()).toBe("error");
+
+    // The user authenticates the tunnel; `VpnIndicator.refresh` reconciles it up and
+    // the store's subscriber fires `retryAutoConnectAfterVpn`. The host now answers
+    // and takes key auth, so the pool connects with no login tab.
+    backend({ probe: REACHABLE, sshSaved: false });
+    retryAutoConnectAfterVpn();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(sshLamp()).toBe("connected");
+    expect(invokeMock).toHaveBeenCalledWith(
+      "remote_connect",
+      expect.objectContaining({ projectId: "remote1" }),
+    );
+  });
+
+  it("leaves the tunnel alone when the host merely rejected the credential", async () => {
+    // Reachable but unauthenticated is the *normal* state of a password host here —
+    // it must not be read as "the network needs the VPN".
+    backend({ probe: REJECTED, sshSaved: false, loginReadyAfter: Infinity });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true, openvpn: { config: "/cfg.ovpn" } })],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(invokeMock).not.toHaveBeenCalledWith("openvpn_login_command", expect.anything());
+    expect(rootInputs()).toContain("ssh -tt alice@host.example");
+  });
+
+  it("gives up on a login that is never authenticated, without prompting", async () => {
+    backend({ probe: REJECTED, sshSaved: false, loginReadyAfter: Infinity });
+    useProjectsStore.setState({ projects: [project("remote1", { auto_connect: true })] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+    // ~2 min of polling (40 × 3s), then the lamp goes red and the polling stops.
+    await vi.advanceTimersByTimeAsync(3000 * 41);
+
+    expect(sshLamp()).toBe("error");
+    expect(invokeMock).not.toHaveBeenCalledWith("remote_connect", expect.anything());
+    expect(useConnectDialogStore.getState().projectId).toBeNull();
+  });
+
+  it("still leaves an unflagged project disconnected", async () => {
+    backend({ probe: REJECTED, sshSaved: false });
+    useProjectsStore.setState({ projects: [project("remote1")] });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(5000);
+
+    expect(rootTabs()).toHaveLength(0);
+    expect(sshLamp()).toBeUndefined();
+  });
+
+  it("treats a closed login tab as 'not now' — disconnected, and re-offered next time", async () => {
+    backend({ probe: REJECTED, sshSaved: false, loginReadyAfter: Infinity });
+    useProjectsStore.setState({
+      projects: [project("remote1", { auto_connect: true }), project("local1")],
+    });
+
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+    const login = rootTabs()[0];
+    expect(login.initialInput).toBe("ssh -tt alice@host.example");
+
+    // The user closes the login instead of authenticating.
+    useTabsStore.getState().removeTab(login.key);
+    await vi.advanceTimersByTimeAsync(4000);
+
+    // Not an error: nothing failed, the user declined. The distinction is load-bearing
+    // — the re-attempt guard only fires from "off", so a red lamp here would wedge the
+    // project shut until the pill's lamp was clicked.
+    expect(sshLamp()).toBe("off");
+
+    // And the dedupe expired with the tab, so switching back offers the login again
+    // rather than silently waiting on a master that is never coming.
+    await useProjectsStore.getState().setActive("local1");
+    await useProjectsStore.getState().setActive("remote1");
+    await vi.advanceTimersByTimeAsync(0);
+    expect(rootInputs()).toContain("ssh -tt alice@host.example");
+  });
+});
diff --git a/src/__tests__/RemoteCreateCredentials.test.tsx b/src/__tests__/RemoteCreateCredentials.test.tsx
new file mode 100644
index 0000000..5d3856d
--- /dev/null
+++ b/src/__tests__/RemoteCreateCredentials.test.tsx
@@ -0,0 +1,245 @@
+/**
+ * The create/extend dialogs save credentials the same way the Connect modal does —
+ * and hand the one they just used to the connection that follows.
+ *
+ * Two gaps this pins shut:
+ *
+ *  1. **No "Save password" in the create/extend flow.** The keychain is keyed by
+ *     *host target* (and by config path for a tunnel), not by project — so there was
+ *     never a reason the toggle couldn't live here too. Without it, a project set up
+ *     with a typed password asked for it again on the very next activation, and
+ *     auto-connect could not be offered at all.
+ *  2. **The first pooled connect went out password-less.** It only worked because the
+ *     dialog's ControlMaster was still up — and the backend reads "no password given,
+ *     none saved" as *key* auth, so it recorded `key_auth: true` on a password host.
+ *     The project then claimed to be auto-connect-eligible and failed on next launch.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn() }));
+vi.mock("../components/terminal/TerminalView", () => ({ TerminalView: () => null }));
+
+import { ExtendToRemoteDialog } from "../components/projects/ExtendToRemoteDialog";
+import { useProjectsStore } from "../stores/projects";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+import { useSettingsStore } from "../stores/settings";
+import { useVpnStatusStore } from "../stores/vpnStatus";
+import type { ProjectEntry } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+const PROJECT = {
+  id: "p1",
+  name: "sshtest",
+  directory: "/home/u/eldrun/projects/sshtest",
+  position: 0,
+  status: "active",
+} as unknown as ProjectEntry;
+
+/** Args of the last call to `cmd` (or undefined if it was never called). */
+const lastArgs = (cmd: string) => {
+  const calls = invokeMock.mock.calls.filter(([name]) => name === cmd);
+  return calls[calls.length - 1]?.[1] as Record<string, unknown> | undefined;
+};
+
+/** Whether a password is already in the keychain for the host we type below. */
+let sshPasswordSaved = false;
+
+beforeEach(() => {
+  // The VPN connect renders the live handshake log, which scrolls itself into view.
+  // jsdom has no layout, hence no scrollIntoView.
+  HTMLElement.prototype.scrollIntoView = vi.fn();
+  sshPasswordSaved = false;
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    // Asked through the state command now: it reports whether the store was
+    // *readable* as well, because a locked keyring answers a plain lookup exactly
+    // like an empty one (see `useSavedCredential`).
+    if (cmd === "remote_saved_password_state") {
+      return Promise.resolve({ saved: sshPasswordSaved, keyring: "unlocked" });
+    }
+    if (cmd === "ssh_connect") {
+      return Promise.resolve({ saved: sshPasswordSaved, save_error: null });
+    }
+    if (cmd === "vpn_has_saved_password") return Promise.resolve(false);
+    if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+    if (cmd === "ssh_list_addresses" || cmd === "remote_list_paths") return Promise.resolve([]);
+    if (cmd === "ssh_tooling_status") {
+      return Promise.resolve({ password_auth: true, openvpn: true });
+    }
+    if (cmd === "ssh_default_dir") return Promise.resolve("/home/alice");
+    if (cmd === "ssh_list_dir") return Promise.resolve([]);
+    return Promise.resolve();
+  });
+
+  useSettingsStore.setState({ settings: { connections_headless: true } as never });
+  useProjectsStore.setState({
+    projects: [PROJECT],
+    extendProjectToRemote: vi.fn(() => Promise.resolve()),
+  } as never);
+  useRemoteStatusStore.setState({ byProject: {} } as never);
+  useVpnStatusStore.setState({ byConfig: {}, holders: {} });
+});
+
+/** Fill in the SSH address + password of the connect step. */
+async function fillSsh(password: string) {
+  await userEvent.type(await screen.findByPlaceholderText(/user@host/i), "alice@host.example");
+  if (password) {
+    await userEvent.type(screen.getByPlaceholderText(/key's passphrase/i), password);
+  }
+}
+
+describe("the create/extend dialog can save the SSH password", () => {
+  it("passes the ticked checkbox to the connect, so the working password is stored", async () => {
+    render(<ExtendToRemoteDialog project={PROJECT} onClose={() => {}} />);
+    await fillSsh("hunter2");
+
+    await userEvent.click(screen.getByRole("checkbox", { name: /save password/i }));
+    await userEvent.click(screen.getByRole("button", { name: /^connect$/i }));
+
+    await waitFor(() =>
+      expect(lastArgs("ssh_connect")).toMatchObject({ password: "hunter2", remember: true }),
+    );
+  });
+
+  it("leaves it unticked by default — and an unticked box NEVER clears the keychain", async () => {
+    // This expectation used to be `remember: false`, i.e. it asserted the
+    // data-loss bug. `false` is not "don't save": it is `Remember::Clear`, and
+    // since `ssh_connect` resolves `typed || saved` *before* it writes, a
+    // *successful* connect carrying it deletes the password it just
+    // authenticated with. That is how a real host's saved password was
+    // destroyed by ordinary use.
+    //
+    // An unticked box now means "leave the keychain alone" — `null`. Deleting is
+    // the explicit forget's job alone (the untick handler calls it directly, and
+    // the test below locks that).
+    render(<ExtendToRemoteDialog project={PROJECT} onClose={() => {}} />);
+    await fillSsh("hunter2");
+
+    await userEvent.click(screen.getByRole("button", { name: /^connect$/i }));
+
+    await waitFor(() => expect(lastArgs("ssh_connect")).toMatchObject({ remember: null }));
+  });
+
+  it("pre-ticks for a host that already has a saved password, and unticking deletes it", async () => {
+    // Pre-ticked matters for more than looks: `remember: false` is an explicit
+    // untick, so connecting with the box unticked would *clear* the credential
+    // another project saved for this same host.
+    sshPasswordSaved = true;
+    render(<ExtendToRemoteDialog project={PROJECT} onClose={() => {}} />);
+    await fillSsh("");
+
+    const save = await screen.findByRole<HTMLInputElement>("checkbox", { name: /save password/i });
+    await waitFor(() => expect(save.checked).toBe(true));
+    // And the field says the saved one will be used — it can't be pre-filled.
+    expect(screen.getByPlaceholderText(/using saved password/i)).toBeTruthy();
+
+    await userEvent.click(save);
+    await waitFor(() =>
+      expect(lastArgs("remote_forget_password")).toMatchObject({ host: "host.example" }),
+    );
+    expect(save.checked).toBe(false);
+  });
+});
+
+describe("the create/extend dialog can save the VPN passphrase", () => {
+  const VPN_CONFIG = "/store/office.ovpn";
+
+  it("passes the ticked checkbox to the tunnel's connect", async () => {
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_list_configs") {
+        return Promise.resolve([{ path: VPN_CONFIG, name: "office.ovpn" }]);
+      }
+      if (cmd === "remote_saved_password_state") {
+        return Promise.resolve({ saved: false, keyring: "unlocked" });
+      }
+      if (cmd === "ssh_connect") return Promise.resolve({ saved: false, save_error: null });
+      if (cmd === "vpn_has_saved_password") return Promise.resolve(false);
+      if (cmd === "ssh_list_addresses" || cmd === "remote_list_paths") return Promise.resolve([]);
+      if (cmd === "ssh_tooling_status") {
+        return Promise.resolve({ password_auth: true, openvpn: true });
+      }
+      if (cmd === "openvpn_auth_needs") {
+        return Promise.resolve({ username: false, keyPassphrase: false });
+      }
+      return Promise.resolve();
+    });
+
+    render(<ExtendToRemoteDialog project={PROJECT} onClose={() => {}} />);
+
+    await userEvent.click(
+      await screen.findByRole("checkbox", { name: /connect via openvpn/i }),
+    );
+    // Pick the stored config from the recents dropdown.
+    await userEvent.click(await screen.findByTitle(/reuse a previously-used openvpn config/i));
+    await userEvent.click(await screen.findByRole("option", { name: /office\.ovpn/i }));
+
+    await userEvent.type(await screen.findByPlaceholderText(/vpn passphrase/i), "s3cret");
+    await userEvent.click(await screen.findByRole("checkbox", { name: /save passphrase/i }));
+    await userEvent.click(screen.getByRole("button", { name: /connect vpn/i }));
+
+    await waitFor(() =>
+      expect(lastArgs("openvpn_connect")).toMatchObject({
+        config: VPN_CONFIG,
+        password: "s3cret",
+        remember: true,
+      }),
+    );
+  });
+});
+
+describe("the credential the dialog used is the one the project connects with", () => {
+  it("hands the typed password to the pooled connect after extending", async () => {
+    render(<ExtendToRemoteDialog project={PROJECT} onClose={() => {}} />);
+    await fillSsh("hunter2");
+    await userEvent.click(screen.getByRole("button", { name: /^connect$/i }));
+
+    // Connected → the browse step opens on the remote home dir; take it as-is.
+    await userEvent.click(await screen.findByRole("button", { name: /use this folder/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /extend to remote/i }));
+
+    await waitFor(() =>
+      expect(lastArgs("remote_connect")).toEqual({
+        projectId: "p1",
+        password: "hunter2",
+        // A password was handed over, so the connect proves how the host
+        // authenticates on its own — nothing is being ridden.
+        viaLogin: false,
+        // The user clicked "Extend to remote"; `remote_connect` defaults to
+        // *background*, which a host tagged HPC refuses outright.
+        background: false,
+      }),
+    );
+    // A password-less connect here would have been recorded as key auth (it rides the
+    // master the dialog left up), which is what made auto-connect lie.
+    expect(useProjectsStore.getState().extendProjectToRemote).toHaveBeenCalled();
+  });
+
+  it("sends no password for a key-auth host — there is nothing to hand over", async () => {
+    render(<ExtendToRemoteDialog project={PROJECT} onClose={() => {}} />);
+    await fillSsh("");
+    await userEvent.click(screen.getByRole("button", { name: /^connect$/i }));
+
+    await userEvent.click(await screen.findByRole("button", { name: /use this folder/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /extend to remote/i }));
+
+    await waitFor(() =>
+      expect(lastArgs("remote_connect")).toEqual({
+        projectId: "p1",
+        password: null,
+        // Nothing to hand over means this connect can only be riding the master the
+        // dialog's own login left up — so it must not be written down as key auth
+        // (the backend's `record_key_auth` skips it). A genuinely key-auth host still
+        // records itself on its next ordinary activation connect.
+        viaLogin: true,
+        background: false,
+      }),
+    );
+  });
+});
diff --git a/src/__tests__/RemoteSavedCredentials.test.tsx b/src/__tests__/RemoteSavedCredentials.test.tsx
new file mode 100644
index 0000000..a5616ad
--- /dev/null
+++ b/src/__tests__/RemoteSavedCredentials.test.tsx
@@ -0,0 +1,131 @@
+/**
+ * Saved credentials in the Connect modal.
+ *
+ * Two rules, both reported as bugs:
+ *
+ *  1. **Unticking "Save password" deletes it — now.** The keychain was only cleared
+ *     on the *next* successful connect (`remember: false` → `Remember::Clear`), so a
+ *     user who unticked and closed the modal left the password they had just asked
+ *     to drop sitting in the OS keychain, possibly forever.
+ *
+ *  2. **A saved credential is used when the field is left blank.** It can't be
+ *     pre-filled — the secret never leaves the backend — so the field advertises
+ *     that blank means "use the saved one". (The wire-level half of this, sending
+ *     `null` rather than `""` so the backend actually falls back, is locked in
+ *     `HeadlessSshConnect.test.ts`.)
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn() }));
+vi.mock("../components/terminal/TerminalView", () => ({ TerminalView: () => null }));
+
+import { RemoteConnectDialog } from "../components/projects/RemoteConnectDialog";
+import { useProjectsStore } from "../stores/projects";
+import { useConnectDialogStore } from "../stores/connectDialog";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+import { useSettingsStore } from "../stores/settings";
+import type { ProjectEntry } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+const VPN_CONFIG = "/store/office.ovpn";
+
+const PROJECT = {
+  id: "p1",
+  name: "sshtest",
+  directory: "/local/state/p1",
+  position: 0,
+  status: "active",
+  remote: {
+    user: "alice",
+    host: "host.example",
+    remote_path: "/srv/work",
+    openvpn: { config: VPN_CONFIG },
+  },
+} as unknown as ProjectEntry;
+
+const calledWith = (cmd: string) => invokeMock.mock.calls.filter(([name]) => name === cmd);
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    // Both secrets are already in the keychain — the state the toggles reflect.
+    // The SSH half is asked through `remote_saved_password_state` now, which
+    // answers *whether the store was readable* as well: a locked keyring reads
+    // exactly like an empty one, and conflating the two is what let a connect
+    // delete a saved password (see `useSavedCredential`).
+    if (cmd === "remote_saved_password_state") {
+      return Promise.resolve({ saved: true, keyring: "unlocked" });
+    }
+    if (cmd === "vpn_has_saved_password") return Promise.resolve(true);
+    if (cmd === "ssh_connect") return Promise.resolve({ saved: true, save_error: null });
+    if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+    if (cmd === "openvpn_auth_needs") {
+      return Promise.resolve({ username: false, keyPassphrase: false });
+    }
+    return Promise.resolve();
+  });
+
+  useSettingsStore.setState({ settings: { connections_headless: true } as never });
+  useProjectsStore.setState({ projects: [PROJECT] } as never);
+  useConnectDialogStore.setState({ projectId: PROJECT.id } as never);
+  useRemoteStatusStore.setState({ byProject: { p1: { ssh: "off", vpn: "off" } } } as never);
+});
+
+describe("saved credentials", () => {
+  it("pre-ticks the SSH toggle from the keychain and says the saved password will be used", async () => {
+    render(<RemoteConnectDialog />);
+
+    const save = await screen.findByRole<HTMLInputElement>("checkbox", { name: /save password/i });
+    await waitFor(() => expect(save.checked).toBe(true));
+    // The field stays empty (the secret never comes back to the UI), so it has to
+    // say that leaving it blank is the way to use what's saved.
+    expect(screen.getByPlaceholderText(/using saved secret/i)).toBeTruthy();
+  });
+
+  it("deletes the saved SSH password the moment the toggle is unticked", async () => {
+    render(<RemoteConnectDialog />);
+
+    const save = await screen.findByRole<HTMLInputElement>("checkbox", { name: /save password/i });
+    await waitFor(() => expect(save.checked).toBe(true));
+
+    await userEvent.click(save);
+
+    await waitFor(() =>
+      expect(calledWith("remote_forget_password")).toEqual([
+        ["remote_forget_password", { user: "alice", host: "host.example", port: null }],
+      ]),
+    );
+    // Not a connect: forgetting a credential and dropping the connection are
+    // separate acts.
+    expect(calledWith("remote_disconnect")).toEqual([]);
+  });
+
+  it("deletes the saved VPN passphrase the moment its toggle is unticked", async () => {
+    render(<RemoteConnectDialog />);
+
+    // The VPN fields live behind the (default-off) "Connect via OpenVPN" opt-in.
+    await userEvent.click(
+      await screen.findByRole("checkbox", { name: /connect via openvpn/i }),
+    );
+
+    const save = await screen.findByRole<HTMLInputElement>("checkbox", {
+      name: /save passphrase/i,
+    });
+    await waitFor(() => expect(save.checked).toBe(true));
+
+    await userEvent.click(save);
+
+    await waitFor(() =>
+      expect(calledWith("vpn_forget_password")).toEqual([
+        ["vpn_forget_password", { config: VPN_CONFIG }],
+      ]),
+    );
+  });
+});
diff --git a/src/__tests__/RemoteVpnDisconnect.test.tsx b/src/__tests__/RemoteVpnDisconnect.test.tsx
new file mode 100644
index 0000000..4ed8d01
--- /dev/null
+++ b/src/__tests__/RemoteVpnDisconnect.test.tsx
@@ -0,0 +1,134 @@
+/**
+ * VPN-only teardown: a tunnel that is up while SSH is down must still be
+ * disconnectable.
+ *
+ * The reported dead end: the VPN comes up, SSH then fails (wrong network, rejected
+ * credential, host down) — and the Connect modal offered no way to bring the tunnel
+ * back down. Three things had to line up for that:
+ *
+ *  1. the VPN section was collapsed on open (its opt-in toggle defaults to off), so
+ *     a live tunnel was invisible;
+ *  2. the headless VPN button row only had a "Stop" while *connecting*, never a
+ *     disconnect once connected; and
+ *  3. the modal's Disconnect was gated on `sshStatus !== "off"` — so with SSH never
+ *     connected (or already reset by its own Stop), it wasn't rendered at all.
+ *
+ * Each is locked below. The teardown must also be *VPN-only*: it may not drop the
+ * SSH pool as a side effect.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn() }));
+// The dialog only mounts a TerminalView on the non-headless path (none of these
+// cases), but the import pulls xterm into jsdom — stub it out.
+vi.mock("../components/terminal/TerminalView", () => ({ TerminalView: () => null }));
+
+import { RemoteConnectDialog } from "../components/projects/RemoteConnectDialog";
+import { useProjectsStore } from "../stores/projects";
+import { useConnectDialogStore } from "../stores/connectDialog";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+import { useSettingsStore } from "../stores/settings";
+import { useVpnStatusStore } from "../stores/vpnStatus";
+import type { ProjectEntry } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+const VPN_CONFIG = "/store/office.ovpn";
+
+const PROJECT = {
+  id: "p1",
+  name: "sshtest",
+  directory: "/local/state/p1",
+  position: 0,
+  status: "active",
+  remote: {
+    user: "alice",
+    host: "host.example",
+    remote_path: "/srv/work",
+    openvpn: { config: VPN_CONFIG },
+  },
+} as unknown as ProjectEntry;
+
+const calledWith = (cmd: string) => invokeMock.mock.calls.filter(([name]) => name === cmd);
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    if (cmd === "remote_has_saved_password" || cmd === "vpn_has_saved_password") {
+      return Promise.resolve(false);
+    }
+    if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+    if (cmd === "openvpn_auth_needs") {
+      return Promise.resolve({ username: false, keyPassphrase: false });
+    }
+    return Promise.resolve();
+  });
+
+  useSettingsStore.setState({ settings: { connections_headless: true } as never });
+  useProjectsStore.setState({ projects: [PROJECT] } as never);
+  useConnectDialogStore.setState({ projectId: PROJECT.id } as never);
+  // The state under test: tunnel up, SSH never got anywhere.
+  useRemoteStatusStore.setState({ byProject: { p1: { ssh: "off", vpn: "connected" } } } as never);
+  useVpnStatusStore.setState({ byConfig: {}, holders: {} });
+});
+
+describe("VPN-only disconnect (tunnel up, SSH down)", () => {
+  it("opens the VPN section by itself when a tunnel is already up", async () => {
+    // A live tunnel must never hide behind the collapsed opt-in: that is precisely
+    // the state in which the user needs the section — to bring it down.
+    render(<RemoteConnectDialog />);
+
+    const toggle = await screen.findByRole<HTMLInputElement>("checkbox", {
+      name: /connect via openvpn/i,
+    });
+    expect(toggle.checked).toBe(true);
+  });
+
+  it("collapses to the already-up notice when a matching tunnel was started globally, not by this project", async () => {
+    // A tunnel that matches this project's stored config but was brought up by the
+    // header (or another project) is not this project's own — it must not be
+    // silently adopted as a holder here (see `useRemoteReconnect`), or logging out
+    // of *this* project could later drop the tunnel out from under whoever actually
+    // started it. It gets the same collapsed notice every other dialog shows.
+    useRemoteStatusStore.setState({ byProject: { p1: { ssh: "off", vpn: "off" } } } as never);
+    useVpnStatusStore.setState({
+      byConfig: { [VPN_CONFIG]: "connected" },
+      holders: {},
+    });
+
+    render(<RemoteConnectDialog />);
+
+    expect(await screen.findByText(/openvpn tunnel already up/i)).toBeTruthy();
+    expect(screen.queryByRole("checkbox", { name: /connect via openvpn/i })).toBeNull();
+    expect(useRemoteStatusStore.getState().byProject.p1?.vpn).toBe("off");
+    expect(useVpnStatusStore.getState().holders[VPN_CONFIG] ?? []).toEqual([]);
+  });
+
+  it("offers a VPN disconnect while connected, and drops only the tunnel", async () => {
+    render(<RemoteConnectDialog />);
+
+    const disconnectVpn = await screen.findByRole("button", { name: /disconnect vpn/i });
+    await userEvent.click(disconnectVpn);
+
+    await waitFor(() =>
+      expect(calledWith("openvpn_disconnect")).toEqual([["openvpn_disconnect", { config: VPN_CONFIG }]]),
+    );
+    // VPN-only: the SSH pool is a separate channel and must be left alone.
+    expect(calledWith("remote_disconnect")).toEqual([]);
+    expect(useRemoteStatusStore.getState().byProject.p1?.vpn).toBe("off");
+  });
+
+  it("still renders the modal's Disconnect when only the VPN is up", async () => {
+    // Gating this on `sshStatus !== "off"` is what left the tunnel with no way out.
+    render(<RemoteConnectDialog />);
+
+    // findByRole throws if it isn't rendered — that failure *is* the regression.
+    expect(await screen.findByRole("button", { name: /^disconnect$/i })).toBeTruthy();
+  });
+});
diff --git a/src/__tests__/ResolvePaneTarget.test.ts b/src/__tests__/ResolvePaneTarget.test.ts
new file mode 100644
index 0000000..a614245
--- /dev/null
+++ b/src/__tests__/ResolvePaneTarget.test.ts
@@ -0,0 +1,59 @@
+/**
+ * #42: the host-side per-pane hit-test for dropping a tab/file from the main
+ * window INTO a split popout. The popout reports its pane geometry (client px) and
+ * the host resolves the cursor SYNCHRONOUSLY here — so the release docks into the
+ * pane actually under the cursor (a body edge splits, a bar merges), never always
+ * the first pane, with no cross-window round-trip race.
+ */
+import { describe, it, expect, vi } from "vitest";
+
+// detachedDropTargets pulls in tauri + the tabs store at import; stub the IPC bits.
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ emit: vi.fn(), listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/api/webviewWindow", () => ({ WebviewWindow: {} }));
+
+import { resolvePaneTarget } from "../components/tabs/detachedDropTargets";
+import type { PaneRect } from "../stores/detached";
+
+// Two side-by-side panes: A spans x[0,200), B spans x[200,400); each has a 30px
+// bar atop a body. y[0,30)=bar, y[30,300)=body.
+const PANES: PaneRect[] = [
+  { groupId: "A", bar: { left: 0, top: 0, right: 200, bottom: 30 }, body: { left: 0, top: 30, right: 200, bottom: 300 } },
+  { groupId: "B", bar: { left: 200, top: 0, right: 400, bottom: 30 }, body: { left: 200, top: 30, right: 400, bottom: 300 } },
+];
+
+describe("resolvePaneTarget — host-side per-pane hit-test", () => {
+  it("over pane B's bar → merge into B (center), not the first pane", () => {
+    expect(resolvePaneTarget(PANES, 300, 15)).toEqual({ groupId: "B", edge: "center" });
+  });
+
+  it("over pane A's bar → merge into A", () => {
+    expect(resolvePaneTarget(PANES, 100, 15)).toEqual({ groupId: "A", edge: "center" });
+  });
+
+  it("over pane B's body center → merge into B (center)", () => {
+    expect(resolvePaneTarget(PANES, 300, 165)).toEqual({ groupId: "B", edge: "center" });
+  });
+
+  it("over pane B's right edge → split B to the right", () => {
+    const t = resolvePaneTarget(PANES, 395, 165);
+    expect(t?.groupId).toBe("B");
+    expect(t?.edge).toBe("right");
+  });
+
+  it("over pane A's left edge → split A to the left", () => {
+    const t = resolvePaneTarget(PANES, 5, 165);
+    expect(t?.groupId).toBe("A");
+    expect(t?.edge).toBe("left");
+  });
+
+  it("over pane A's bottom edge → split A to the bottom", () => {
+    const t = resolvePaneTarget(PANES, 100, 295);
+    expect(t?.groupId).toBe("A");
+    expect(t?.edge).toBe("bottom");
+  });
+
+  it("outside every pane → null (host falls back to first-pane append)", () => {
+    expect(resolvePaneTarget(PANES, 500, 500)).toBeNull();
+  });
+});
diff --git a/src/__tests__/RightPanelBox.test.tsx b/src/__tests__/RightPanelBox.test.tsx
index e959880..8d7e027 100644
--- a/src/__tests__/RightPanelBox.test.tsx
+++ b/src/__tests__/RightPanelBox.test.tsx
@@ -7,7 +7,11 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import { render, act } from "@testing-library/react";
 import type { ProjectBox, ProjectEntry } from "../types";
 
-vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn().mockResolvedValue([]) }));
+vi.mock("@tauri-apps/api/core", () => ({
+  // Listing commands resolve to []; git_repo_root returns a path string or null,
+  // so the blanket [] would leak a non-string into ProjectFilesView's norm().
+  invoke: vi.fn((cmd: string) => Promise.resolve(cmd === "git_repo_root" ? null : [])),
+}));
 vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn().mockResolvedValue(() => {}) }));
 
 import { RightPanel } from "../components/layout/RightPanel";
diff --git a/src/__tests__/RunFilePulse.test.ts b/src/__tests__/RunFilePulse.test.ts
new file mode 100644
index 0000000..c0c722f
--- /dev/null
+++ b/src/__tests__/RunFilePulse.test.ts
@@ -0,0 +1,97 @@
+/**
+ * The green-pulse run-button state: a run-launched terminal tab (Python
+ * Run/Debug or a foreground shell run) is tagged with `TabEntry.runFile`, and
+ * while it produces sustained output the activity store lists that file in
+ * `runningRunFiles` — which drives the ▶ run button's green pulse in the file
+ * tree. Busy-gated (commanded + sustained past the onset), and dropped the
+ * moment the tab closes or goes quiet, mirroring `busyByTab`.
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import {
+  useActivityStore,
+  notePtyOutput,
+  noteUserInput,
+  _clearPtyActivityForTest,
+} from "../stores/activity";
+import { useTabsStore } from "../stores/tabs";
+
+const RUN_PATH = "/proj/run_me.py";
+
+function seedRunTab() {
+  useTabsStore.setState({
+    tabsByScope: {
+      "proj-a": [
+        {
+          key: "shell-1",
+          label: "▶ run_me.py",
+          cmd: "",
+          cwd: "/proj",
+          kind: "shell",
+          runFile: RUN_PATH,
+        },
+      ],
+    },
+    scope: "proj-a",
+    layoutByScope: {
+      "proj-a": { type: "group", id: "g-a", tabKeys: ["shell-1"], activeKey: "shell-1" },
+    },
+    detachedGroupsByScope: {},
+  });
+}
+
+// Commanded (noteUserInput) + sustained output past WORK_ONSET_MS (1500), the
+// shape the store requires before a tab counts as "working".
+function sustain(id: string, totalMs = 1600) {
+  noteUserInput(id);
+  notePtyOutput(id, "running…\n");
+  for (let elapsed = 0; elapsed < totalMs; elapsed += 400) {
+    vi.advanceTimersByTime(400);
+    notePtyOutput(id, "running…\n");
+  }
+}
+
+describe("activity store runningRunFiles (run-button pulse)", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    _clearPtyActivityForTest();
+    useActivityStore.setState({ runningRunFiles: new Set() });
+    seedRunTab();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("lists a busy run tab's file, and clears it once output goes quiet", () => {
+    sustain("proj-a:shell-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().runningRunFiles.has(RUN_PATH)).toBe(true);
+
+    // Output goes stale (> BUSY_WINDOW_MS = 800): the tab is no longer busy, so
+    // its file drops out of the set.
+    vi.advanceTimersByTime(1000);
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().runningRunFiles.has(RUN_PATH)).toBe(false);
+  });
+
+  it("drops the file when the run tab is removed mid-run", () => {
+    sustain("proj-a:shell-1");
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().runningRunFiles.has(RUN_PATH)).toBe(true);
+
+    useTabsStore.setState({ tabsByScope: {}, layoutByScope: {} });
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().runningRunFiles.has(RUN_PATH)).toBe(false);
+  });
+
+  it("never lights up a restored, uncommanded run tab (resume replay)", () => {
+    // Same sustained output, but WITHOUT noteUserInput — a restored tab replaying
+    // banner text nobody asked for. Busy-gating must keep it dark.
+    notePtyOutput("proj-a:shell-1", "restored\n");
+    for (let elapsed = 0; elapsed < 1600; elapsed += 400) {
+      vi.advanceTimersByTime(400);
+      notePtyOutput("proj-a:shell-1", "restored\n");
+    }
+    useActivityStore.getState().recompute();
+    expect(useActivityStore.getState().runningRunFiles.has(RUN_PATH)).toBe(false);
+  });
+});
diff --git a/src/__tests__/ScaffoldRepair.test.ts b/src/__tests__/ScaffoldRepair.test.ts
new file mode 100644
index 0000000..958f57a
--- /dev/null
+++ b/src/__tests__/ScaffoldRepair.test.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import {
+  describeScaffoldRepair,
+  scaffoldRepairIsEmpty,
+  summarizeScaffoldRepair,
+  type ProjectScaffoldRepair,
+} from "../components/projects/scaffold";
+
+describe("scaffold repair summaries", () => {
+  it("reports an empty report as already up to date", () => {
+    const report = { createdFiles: [], gitignoreLinesAdded: [], gitInitialized: false };
+    expect(scaffoldRepairIsEmpty(report)).toBe(true);
+    expect(summarizeScaffoldRepair(report)).toBe("already up to date");
+  });
+
+  it("summarizes created files, gitignore lines, and git init together", () => {
+    const report = {
+      createdFiles: ["DOCUMENTATION.md", ".claude/settings.json"],
+      gitignoreLinesAdded: ["project.json"],
+      gitInitialized: true,
+    };
+    expect(scaffoldRepairIsEmpty(report)).toBe(false);
+    expect(summarizeScaffoldRepair(report)).toBe(
+      "added DOCUMENTATION.md, .claude/settings.json; .gitignore +project.json; git init",
+    );
+  });
+
+  it("prefixes the project name for a multi-project toast", () => {
+    const repair: ProjectScaffoldRepair = {
+      projectId: "abc",
+      name: "MyProject",
+      targetDir: "/home/u/eldrun/projects/myproject",
+      report: { createdFiles: ["TODO.md"], gitignoreLinesAdded: [], gitInitialized: false },
+    };
+    expect(describeScaffoldRepair(repair)).toBe("MyProject: added TODO.md");
+  });
+});
diff --git a/src/__tests__/ScrollSync.test.ts b/src/__tests__/ScrollSync.test.ts
new file mode 100644
index 0000000..0fbf48b
--- /dev/null
+++ b/src/__tests__/ScrollSync.test.ts
@@ -0,0 +1,93 @@
+/**
+ * Proportional scroll-linking between two side-by-side viewer subwindows. The
+ * store holds symmetric links keyed by group id and forwards one pane's scroll
+ * ratio to its linked partner's handle, guarding against the feedback bounce the
+ * induced scroll would otherwise cause. These tests lock the link matching, the
+ * ratio forwarding + suppress guard, and the prune-on-stale behaviour.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { useScrollSyncStore, type ScrollHandle } from "../stores/scrollSync";
+
+function reset() {
+  useScrollSyncStore.setState({ links: {}, handles: new Map() });
+}
+
+describe("scrollSync links", () => {
+  beforeEach(reset);
+
+  it("toggleLink creates a symmetric pair and toggles it off", () => {
+    const s = useScrollSyncStore.getState();
+    s.toggleLink("a", "b");
+    expect(useScrollSyncStore.getState().isLinked("a", "b")).toBe(true);
+    expect(useScrollSyncStore.getState().isLinked("b", "a")).toBe(true);
+
+    useScrollSyncStore.getState().toggleLink("a", "b");
+    expect(useScrollSyncStore.getState().isLinked("a", "b")).toBe(false);
+    expect(useScrollSyncStore.getState().isLinked("b", "a")).toBe(false);
+  });
+
+  it("a new link on an already-linked group drops the prior pairing on both sides", () => {
+    useScrollSyncStore.getState().toggleLink("a", "b");
+    useScrollSyncStore.getState().toggleLink("a", "c");
+    const { isLinked } = useScrollSyncStore.getState();
+    expect(isLinked("a", "c")).toBe(true);
+    expect(isLinked("a", "b")).toBe(false);
+    // b is now orphaned, not silently still pointing at a.
+    expect(useScrollSyncStore.getState().links["b"]).toBeUndefined();
+  });
+
+  it("prune drops any link whose endpoints are no longer both valid", () => {
+    useScrollSyncStore.getState().toggleLink("a", "b");
+    useScrollSyncStore.getState().prune(new Set(["a"])); // b gone
+    expect(useScrollSyncStore.getState().isLinked("a", "b")).toBe(false);
+    expect(useScrollSyncStore.getState().links).toEqual({});
+  });
+});
+
+describe("scrollSync report", () => {
+  beforeEach(reset);
+
+  it("forwards the source ratio to the linked partner's handle", () => {
+    const applyA = vi.fn();
+    const applyB = vi.fn();
+    const s = useScrollSyncStore.getState();
+    s.register("a", { applyRatio: applyA });
+    s.register("b", { applyRatio: applyB });
+    s.toggleLink("a", "b");
+
+    useScrollSyncStore.getState().report("a", 0.5);
+    expect(applyB).toHaveBeenCalledWith(0.5);
+    expect(applyA).not.toHaveBeenCalled();
+  });
+
+  it("does nothing for an unlinked group", () => {
+    const applyB = vi.fn();
+    useScrollSyncStore.getState().register("b", { applyRatio: applyB });
+    useScrollSyncStore.getState().report("a", 0.5);
+    expect(applyB).not.toHaveBeenCalled();
+  });
+
+  it("suppresses the partner's echoed report so the two panes don't fight", () => {
+    // Simulate the induced scroll: applying a ratio to the partner fires its own
+    // scroll, which reports back. That echo must be swallowed within the tick.
+    const applyA = vi.fn();
+    const partnerReports: number[] = [];
+    const handleB: ScrollHandle = {
+      applyRatio: (r) => {
+        partnerReports.push(r);
+        // The write to B's scrollTop fires B's scroll handler synchronously here.
+        useScrollSyncStore.getState().report("b", r);
+      },
+    };
+    const s = useScrollSyncStore.getState();
+    s.register("a", { applyRatio: applyA });
+    s.register("b", handleB);
+    s.toggleLink("a", "b");
+
+    useScrollSyncStore.getState().report("a", 0.5);
+    expect(partnerReports).toEqual([0.5]);
+    // The echo from B must NOT bounce back into A while suppressed.
+    expect(applyA).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/ShellScriptRun.test.ts b/src/__tests__/ShellScriptRun.test.ts
new file mode 100644
index 0000000..81e00f9
--- /dev/null
+++ b/src/__tests__/ShellScriptRun.test.ts
@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { shellScriptRunPlan } from "../lib/shellScriptRun";
+import type { ProjectEntry } from "../types";
+
+const remoteProject: ProjectEntry = {
+  id: "demoproj",
+  name: "demoproj",
+  status: "active",
+  position: 0,
+  local_file: "/state/demoproj/project.json",
+  directory: "/state/demoproj",
+  remote: {
+    user: "alice",
+    host: "gpu",
+    remote_path: "/home/alice/demoproj",
+  },
+};
+
+describe("shell script run planning", () => {
+  it("runs a remote-source script relative to the host project root", () => {
+    const plan = shellScriptRunPlan({
+      project: remoteProject,
+      treeRoot: "/state/demoproj",
+      syncSource: "remote",
+      scriptPath: "/home/alice/demoproj/install.sh",
+      interp: "bash",
+    });
+
+    expect(plan).toMatchObject({
+      cwd: "/home/alice/demoproj",
+      scriptRel: "install.sh",
+      initialInput: "bash 'install.sh'",
+      location: "remote",
+    });
+  });
+
+  it("runs a local-source script relative to the mirror and pins local locality", () => {
+    const plan = shellScriptRunPlan({
+      project: remoteProject,
+      treeRoot: "/state/demoproj/mirror",
+      syncSource: "local",
+      scriptPath: "/state/demoproj/mirror/install.sh",
+      interp: "bash",
+    });
+
+    expect(plan).toMatchObject({
+      cwd: "/state/demoproj/mirror",
+      scriptRel: "install.sh",
+      initialInput: "bash 'install.sh'",
+      location: "local",
+    });
+  });
+
+  it("runs on the chosen worker machine when a run-host preference is set", () => {
+    const plan = shellScriptRunPlan({
+      project: remoteProject,
+      treeRoot: "/state/demoproj",
+      syncSource: "remote",
+      scriptPath: "/home/alice/demoproj/train.sh",
+      interp: "bash",
+      runHostPref: "host:worker1",
+    });
+
+    // The chosen machine wins over the browsed side; the script path stays
+    // project-relative so it resolves against that host's own project root (the
+    // backend re-cds into the worker's remote_path).
+    expect(plan).toMatchObject({
+      cwd: "/home/alice/demoproj",
+      scriptRel: "train.sh",
+      initialInput: "bash 'train.sh'",
+      location: "host:worker1",
+    });
+  });
+
+  it("sends a mirror-browsed script to the chosen remote machine", () => {
+    // Browsing the local mirror but with a worker chosen: the run still lands on
+    // the worker, and scriptRel (project-relative) resolves there.
+    const plan = shellScriptRunPlan({
+      project: remoteProject,
+      treeRoot: "/state/demoproj/mirror",
+      syncSource: "local",
+      scriptPath: "/state/demoproj/mirror/train.sh",
+      interp: "bash",
+      runHostPref: "host:worker1",
+    });
+
+    expect(plan).toMatchObject({
+      cwd: "/home/alice/demoproj",
+      scriptRel: "train.sh",
+      location: "host:worker1",
+    });
+  });
+
+  it("refuses to build bash with an empty script path", () => {
+    expect(
+      shellScriptRunPlan({
+        project: remoteProject,
+        treeRoot: "/state/demoproj",
+        syncSource: "remote",
+        scriptPath: "/tmp/install.sh",
+        interp: "bash",
+      }),
+    ).toBeNull();
+  });
+});
diff --git a/src/__tests__/Slurm.test.ts b/src/__tests__/Slurm.test.ts
new file mode 100644
index 0000000..8c5043e
--- /dev/null
+++ b/src/__tests__/Slurm.test.ts
@@ -0,0 +1,121 @@
+/**
+ * The SLURM (HPC) text helpers (`lib/slurm.ts`), all pure — the directive form is
+ * a *view on the text*, exactly like the YAML/table viewers: every edit splices the
+ * script's `#SBATCH` lines rather than re-serializing, so unrelated lines, comments
+ * and the flag spelling the author used all survive. These tests pin that bargain
+ * plus the command builders for the log tail and the interactive `srun` shell.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  isSlurmScript,
+  parseSbatchDirectives,
+  directiveValue,
+  spliceDirective,
+  buildInteractiveCommand,
+  buildTailCommand,
+} from "../lib/slurm";
+
+const SCRIPT = `#!/bin/bash
+#SBATCH --job-name=train
+#SBATCH --time=01:00:00
+#SBATCH -c 4
+# a normal comment
+module load python
+srun python train.py
+`;
+
+describe("isSlurmScript", () => {
+  it("is true only when a #SBATCH directive is present", () => {
+    expect(isSlurmScript(SCRIPT)).toBe(true);
+    expect(isSlurmScript("#!/bin/bash\necho hi\n")).toBe(false);
+    // A bare `#SBATCH` comment with no flag is not a directive.
+    expect(isSlurmScript("#SBATCH\n")).toBe(false);
+  });
+});
+
+describe("parseSbatchDirectives", () => {
+  it("normalizes short flags to their long key", () => {
+    const fields = parseSbatchDirectives(SCRIPT);
+    expect(directiveValue(fields, "job-name")).toBe("train");
+    expect(directiveValue(fields, "time")).toBe("01:00:00");
+    // `-c 4` folds into `cpus-per-task`.
+    expect(directiveValue(fields, "cpus-per-task")).toBe("4");
+  });
+
+  it("returns empty for an absent key", () => {
+    expect(directiveValue(parseSbatchDirectives(SCRIPT), "mem")).toBe("");
+  });
+
+  it("folds the `-A` short flag into `account`", () => {
+    const fields = parseSbatchDirectives("#!/bin/bash\n#SBATCH -A ag-foo\n");
+    expect(directiveValue(fields, "account")).toBe("ag-foo");
+  });
+});
+
+describe("spliceDirective", () => {
+  it("rewrites an existing directive in place, keeping the flag spelling", () => {
+    const next = spliceDirective(SCRIPT, "time", "02:30:00");
+    expect(next).toContain("#SBATCH --time=02:30:00");
+    expect(next).not.toContain("01:00:00");
+    // The short-flag directive keeps its short form when edited by long key.
+    const next2 = spliceDirective(SCRIPT, "cpus-per-task", "8");
+    expect(next2).toContain("#SBATCH -c 8");
+  });
+
+  it("leaves every other line byte-identical", () => {
+    const next = spliceDirective(SCRIPT, "time", "02:30:00");
+    // Only the one directive line changed; the comment, module load and srun stay.
+    expect(next).toContain("# a normal comment");
+    expect(next).toContain("module load python");
+    expect(next).toContain("srun python train.py");
+    expect(next.split("\n").length).toBe(SCRIPT.split("\n").length);
+  });
+
+  it("inserts a new directive after the last existing one", () => {
+    const next = spliceDirective(SCRIPT, "mem", "16G");
+    const lines = next.split("\n");
+    const memIdx = lines.findIndex((l) => l.includes("--mem=16G"));
+    const cIdx = lines.findIndex((l) => l.includes("-c 4"));
+    expect(memIdx).toBeGreaterThan(-1);
+    // Grouped with the other directives (right after the last one), not at the end.
+    expect(memIdx).toBe(cIdx + 1);
+  });
+
+  it("inserts after a shebang when there are no directives yet", () => {
+    const next = spliceDirective("#!/bin/bash\necho hi\n", "time", "00:10:00");
+    const lines = next.split("\n");
+    expect(lines[0]).toBe("#!/bin/bash");
+    expect(lines[1]).toBe("#SBATCH --time=00:10:00");
+  });
+
+  it("removes the directive when the value is cleared", () => {
+    const next = spliceDirective(SCRIPT, "time", "");
+    expect(next).not.toContain("--time");
+    // The others remain.
+    expect(next).toContain("--job-name=train");
+  });
+});
+
+describe("command builders", () => {
+  it("tails the log by name with retry", () => {
+    expect(buildTailCommand("/home/a/p/slurm-42.out")).toBe(
+      "tail -n +1 -F '/home/a/p/slurm-42.out'",
+    );
+  });
+
+  it("builds an srun --pty command from the set resources only", () => {
+    expect(
+      buildInteractiveCommand({ time: "01:00:00", cpus: "4", mem: "8G", gpus: "1" }),
+    ).toBe("srun --pty --time=01:00:00 --cpus-per-task=4 --mem=8G --gpus=1 bash -l");
+    // Empty fields are omitted; a bare session still lands on bash -l.
+    expect(buildInteractiveCommand({})).toBe("srun --pty bash -l");
+  });
+
+  it("emits --account first, before the other resources", () => {
+    // --account is mandatory on group-allocated clusters; an interactive srun
+    // without it is rejected.
+    expect(
+      buildInteractiveCommand({ account: "ag-foo", partition: "mlgpu", gpus: "2" }),
+    ).toBe("srun --pty --account=ag-foo --partition=mlgpu --gpus=2 bash -l");
+  });
+});
diff --git a/src/__tests__/SplitLayout.test.ts b/src/__tests__/SplitLayout.test.ts
index f50131e..80875f2 100644
--- a/src/__tests__/SplitLayout.test.ts
+++ b/src/__tests__/SplitLayout.test.ts
@@ -402,14 +402,14 @@ describe("tabs store — split layout", () => {
       useTabsStore.getState().loadFromLayout(
         [
           { key: "a1", label: "claude", cmd: "claude", cwd: "/x", kind: "agent" },
-          { key: "a2", label: "gemini", cmd: "gemini", cwd: "/x", kind: "agent", sessionId: "g" },
+          { key: "a2", label: "aider", cmd: "aider", cwd: "/x", kind: "agent", sessionId: "g" },
         ],
         "/proj",
         "p",
       );
       const tabs = useTabsStore.getState().tabs;
       expect(tabs[0].args).toEqual([]); // claude, no sessionId
-      expect(tabs[1].args).toEqual([]); // gemini not in RESUMABLE_AGENTS
+      expect(tabs[1].args).toEqual([]); // aider not in RESUMABLE_AGENTS
     });
   });
 
diff --git a/src/__tests__/SplitPopoutRespawn.test.ts b/src/__tests__/SplitPopoutRespawn.test.ts
new file mode 100644
index 0000000..fac31d0
--- /dev/null
+++ b/src/__tests__/SplitPopoutRespawn.test.ts
@@ -0,0 +1,137 @@
+/**
+ * #42 (multi-pane, "Phase 4"): a SPLIT detached popout must respawn as a floating
+ * window on restart — NOT dock back into the main panel. Previously
+ * withDetachedDocked tagged only single-group popouts, so a split popout's subtree
+ * was persisted untagged and restored docked. Now the split node carries the
+ * detached tag (through prune + deserialize) and the respawn path re-detaches the
+ * whole split subtree by id.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const { invokeMock } = vi.hoisted(() => ({
+  invokeMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+
+import {
+  useTabsStore,
+  findSplit,
+  orderedTabKeys,
+  allGroups,
+  type SplitNode,
+} from "../stores/tabs";
+
+function reset() {
+  invokeMock.mockClear();
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    pendingRespawnByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+  useTabsStore.getState().setScope("p");
+}
+
+const BOUNDS = { x: 10, y: 20, w: 800, h: 600 };
+
+// Scope "p": in-window group holds tab a; a split popout holds [b] | [c].
+function seedSplitPopout() {
+  const a = useTabsStore.getState().addTab({ label: "a", cmd: "bash", cwd: "/p", kind: "shell" });
+  const b = { key: "kb", label: "b", cmd: "bash", cwd: "/p", kind: "shell" as const };
+  const c = { key: "kc", label: "c", cmd: "bash", cwd: "/p", kind: "shell" as const };
+  useTabsStore.setState((s) => ({
+    tabsByScope: { ...s.tabsByScope, p: [...(s.tabsByScope.p ?? []), b, c] },
+    tabs: [...s.tabs, b, c],
+    detachedGroupsByScope: {
+      p: [
+        {
+          id: "s-pop",
+          label: "detached-p-s-pop",
+          bounds: BOUNDS,
+          subtree: {
+            type: "split",
+            id: "s-pop",
+            dir: "row",
+            sizes: [0.5, 0.5],
+            children: [
+              { type: "group", id: "g-b", tabKeys: ["kb"], activeKey: "kb" },
+              { type: "group", id: "g-c", tabKeys: ["kc"], activeKey: "kc" },
+            ],
+          } as SplitNode,
+        },
+      ],
+    },
+  }));
+  return { a, b, c };
+}
+
+describe("split popout respawns detached on restart (#42)", () => {
+  beforeEach(reset);
+
+  it("persists the split tagged detached, with its bounds", () => {
+    seedSplitPopout();
+    const snap = useTabsStore.getState().snapshotScopeForSwitch("p");
+    const tree = snap.tabGroups!;
+    expect(tree.type).toBe("split"); // [inWindow group, detached split]
+    const taggedSplit =
+      tree.type === "split"
+        ? tree.children.find((c) => c.type === "split" && c.detached)
+        : undefined;
+    expect(taggedSplit).toBeTruthy();
+    expect(taggedSplit && "bounds" in taggedSplit ? taggedSplit.bounds : undefined).toEqual(BOUNDS);
+  });
+
+  it("restores the split docked AND queues exactly one respawn target for it", () => {
+    seedSplitPopout();
+    const snap = useTabsStore.getState().snapshotScopeForSwitch("p");
+
+    reset(); // simulate restart
+    useTabsStore.getState().loadFromLayout(snap.tabs, "/p", "p", snap.tabGroups ?? undefined);
+
+    // All three tabs restored DOCKED so their panes mount before the re-detach.
+    const layout = useTabsStore.getState().layoutByScope["p"];
+    expect(orderedTabKeys(layout)).toHaveLength(3);
+
+    // Exactly one respawn target, carrying the popout's bounds, pointing at a
+    // SPLIT node in the restored (docked) layout.
+    const pending = useTabsStore.getState().pendingRespawnByScope["p"];
+    expect(pending).toHaveLength(1);
+    expect(pending[0].bounds).toEqual(BOUNDS);
+    expect(findSplit(layout, pending[0].id)).toBeTruthy();
+  });
+
+  it("detachGroup re-detaches the whole split subtree by its id", () => {
+    seedSplitPopout();
+    const snap = useTabsStore.getState().snapshotScopeForSwitch("p");
+    reset();
+    useTabsStore.getState().loadFromLayout(snap.tabs, "/p", "p", snap.tabGroups ?? undefined);
+
+    const target = useTabsStore.getState().pendingRespawnByScope["p"][0];
+    const label = useTabsStore
+      .getState()
+      .detachGroup(target.id, { bounds: target.bounds, allowLastGroup: true, skipBackend: true });
+    expect(label).toBe(`detached-p-${target.id}`);
+
+    // The split left the in-window layout; only the single in-window tab remains.
+    const layout = useTabsStore.getState().layoutByScope["p"];
+    expect(allGroups(layout).map((g) => g.tabKeys).flat()).toHaveLength(1);
+
+    // It is now a detached popout whose subtree is a 2-pane split holding b and c.
+    const det = useTabsStore.getState().detachedGroupsByScope["p"];
+    expect(det).toHaveLength(1);
+    expect(det[0].subtree.type).toBe("split");
+    const popoutKeys = orderedTabKeys(det[0].subtree);
+    expect(popoutKeys).toHaveLength(2);
+    // Tab payloads survive the round trip (the panes keep their PTYs).
+    const labels = popoutKeys.map(
+      (k) => useTabsStore.getState().tabs.find((t) => t.key === k)?.label,
+    );
+    expect(labels.sort()).toEqual(["b", "c"]);
+  });
+});
diff --git a/src/__tests__/SubwindowDetach.test.ts b/src/__tests__/SubwindowDetach.test.ts
index 3bfcf7c..98b704e 100644
--- a/src/__tests__/SubwindowDetach.test.ts
+++ b/src/__tests__/SubwindowDetach.test.ts
@@ -90,7 +90,7 @@ describe("tabs store — detach / attach subwindow (#42)", () => {
     const detached = useTabsStore.getState().detachedGroupsByScope["p"];
     expect(detached).toHaveLength(1);
     expect(detached[0].id).toBe(right.id);
-    expect(detached[0].subtree.tabKeys).toEqual([b.key]);
+    expect((detached[0].subtree as GroupNode).tabKeys).toEqual([b.key]);
     expect(useTabsStore.getState().tabs.map((t) => t.key).sort()).toEqual(
       [a.key, b.key].sort(),
     );
@@ -275,7 +275,7 @@ describe("tabs store — detach / attach subwindow (#42)", () => {
     expect(useTabsStore.getState().layout).toBeNull();
     const detached = useTabsStore.getState().detachedGroupsByScope["p"];
     expect(detached).toHaveLength(1);
-    expect(detached[0].subtree.tabKeys).toEqual([a.key]);
+    expect((detached[0].subtree as GroupNode).tabKeys).toEqual([a.key]);
     expect(invokeMock).toHaveBeenCalledWith(
       "detach_subwindow",
       expect.objectContaining({ projectId: "p", groupId: gid }),
@@ -366,7 +366,7 @@ describe("tabs store — drag a tab/file to another monitor → standalone windo
     // A fresh single-tab detached group references `b`; its payload survives.
     const detached = useTabsStore.getState().detachedGroupsByScope["p"];
     expect(detached).toHaveLength(1);
-    expect(detached[0].subtree.tabKeys).toEqual([b.key]);
+    expect((detached[0].subtree as GroupNode).tabKeys).toEqual([b.key]);
     expect(detached[0].bounds).toEqual(bounds);
     expect(label).toBe(`detached-p-${detached[0].id}`);
     // The new group id is distinct from the source group it left.
@@ -394,7 +394,7 @@ describe("tabs store — drag a tab/file to another monitor → standalone windo
     expect(useTabsStore.getState().layout).toBeNull();
     const detached = useTabsStore.getState().detachedGroupsByScope["p"];
     expect(detached).toHaveLength(1);
-    expect(detached[0].subtree.tabKeys).toEqual([a.key]);
+    expect((detached[0].subtree as GroupNode).tabKeys).toEqual([a.key]);
     // Payload still present so the detached window can render it.
     expect(useTabsStore.getState().tabs.map((t) => t.key)).toEqual([a.key]);
   });
@@ -424,7 +424,7 @@ describe("tabs store — drag a tab/file to another monitor → standalone windo
     const detached = useTabsStore.getState().detachedGroupsByScope["p"];
     expect(detached).toHaveLength(1);
     expect(label).toBe(`detached-p-${detached[0].id}`);
-    const newKey = detached[0].subtree.tabKeys[0];
+    const newKey = (detached[0].subtree as GroupNode).tabKeys[0];
     expect(newKey).not.toBe(a.key);
 
     // The fresh tab payload is in tabsByScope, scope-stamped, embed kind.
@@ -476,7 +476,7 @@ describe("tabs store — dock a single popout tab back (#42 attachDetachedTab)",
     // The popout keeps c; every payload survives. Window stays open.
     const det = useTabsStore.getState().detachedGroupsByScope["p"];
     expect(det).toHaveLength(1);
-    expect(det[0].subtree.tabKeys).toEqual([c.key]);
+    expect((det[0].subtree as GroupNode).tabKeys).toEqual([c.key]);
     expect(useTabsStore.getState().tabs.map((t) => t.key).sort()).toEqual(
       [a.key, b.key, c.key].sort(),
     );
@@ -530,8 +530,132 @@ describe("tabs store — dock a single popout tab back (#42 attachDetachedTab)",
       targetGroupId: g2,
     });
     expect(useTabsStore.getState().layout).toBe(before);
-    expect(useTabsStore.getState().detachedGroupsByScope["p"][0].subtree.tabKeys)
+    expect((useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as GroupNode).tabKeys)
       .toEqual([b.key, useTabsStore.getState().tabs.find((t) => t.label === "c")!.key]);
     expect(invokeMock).not.toHaveBeenCalled();
   });
 });
+
+describe("tabs store — dock a main-window tab INTO a popout (#42 dockTabIntoDetached)", () => {
+  beforeEach(reset);
+
+  // Build [G1=[b,c] (detached), G2=[a] (live)] and return ids + keys. Mirrors the
+  // attachDetachedTab setup; here a live tab is dragged INTO the popout instead.
+  function setup() {
+    const a = useTabsStore.getState().addTab(tab("a"));
+    const b = useTabsStore.getState().addTab(tab("b"));
+    const c = useTabsStore.getState().addTab(tab("c")); // G1=[a,b,c]
+    const rootGid = (useTabsStore.getState().layout as GroupNode).id;
+    useTabsStore.getState().splitWithTab(a.key, rootGid, "right"); // G1=[b,c], new=[a]
+    const root = useTabsStore.getState().layout as SplitNode;
+    const left = root.children[0] as GroupNode; // [b,c]
+    const right = root.children[1] as GroupNode; // [a]
+    useTabsStore.getState().detachGroup(left.id); // detach [b,c]
+    invokeMock.mockClear();
+    return { a, b, c, g1: left.id, g2: right.id };
+  }
+
+  it("moves a live tab into the popout's group, activates it, and keeps payloads", () => {
+    const { a, b, c, g1 } = setup();
+    useTabsStore.getState().dockTabIntoDetached("p", g1, a.key);
+
+    // a is appended to the popout's subtree and is the popout's active tab.
+    const det = useTabsStore.getState().detachedGroupsByScope["p"];
+    expect(det).toHaveLength(1);
+    expect((det[0].subtree as GroupNode).tabKeys).toEqual([b.key, c.key, a.key]);
+    expect((det[0].subtree as GroupNode).activeKey).toBe(a.key);
+
+    // G2 emptied → the main center has no layout, but every payload survives so
+    // the popout (and the main's hidden-but-mounted pane) keep the PTY alive.
+    expect(useTabsStore.getState().layout).toBeNull();
+    expect(useTabsStore.getState().tabs.map((t) => t.key).sort()).toEqual(
+      [a.key, b.key, c.key].sort(),
+    );
+    // No backend call — docking into an existing popout opens no window.
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("leaves the source group intact when other tabs remain in it", () => {
+    const { a, g1 } = setup();
+    const d = useTabsStore.getState().addTab(tab("d")); // joins the focused G2 → [a,d]
+    useTabsStore.getState().dockTabIntoDetached("p", g1, a.key);
+
+    // Source group keeps d; the popout gained a.
+    const layout = useTabsStore.getState().layout as GroupNode;
+    expect(layout.type).toBe("group");
+    expect(layout.tabKeys).toEqual([d.key]);
+    const popoutKeys = (useTabsStore.getState().detachedGroupsByScope["p"][0]
+      .subtree as GroupNode).tabKeys;
+    expect(popoutKeys[popoutKeys.length - 1]).toBe(a.key);
+  });
+
+  it("no-ops for an unknown popout, a foreign tab, or a tab already in the popout", () => {
+    const { a, b, g1 } = setup();
+    const before = useTabsStore.getState().layout;
+    const subBefore =
+      (useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as GroupNode).tabKeys;
+    useTabsStore.getState().dockTabIntoDetached("p", "missing", a.key);
+    useTabsStore.getState().dockTabIntoDetached("p", g1, "nope");
+    useTabsStore.getState().dockTabIntoDetached("p", g1, b.key); // already in popout
+    expect(useTabsStore.getState().layout).toBe(before);
+    expect(
+      (useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as GroupNode).tabKeys,
+    ).toBe(subBefore);
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  // #42: docking into a SPLIT (multi-pane) popout targets the resolved pane, not
+  // always the first one. Turn the popout [b,c] into a 2-pane split [b] | [c].
+  function splitSetup() {
+    const ids = setup(); // popout g1=[b,c]
+    useTabsStore.getState().splitDetachedGroup("p", ids.g1, ids.c.key, ids.g1, "right");
+    const sub = useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    const paneB = sub.children[0] as GroupNode; // [b] (keeps g1)
+    const paneC = sub.children[1] as GroupNode; // [c] (fresh id)
+    invokeMock.mockClear();
+    return { ...ids, paneB: paneB.id, paneC: paneC.id };
+  }
+
+  it("docks into the SPECIFIC pane (center merge), not the first one", () => {
+    const { a, c, paneC } = splitSetup();
+    const popoutId = useTabsStore.getState().detachedGroupsByScope["p"][0].id;
+    useTabsStore.getState().dockTabIntoDetached("p", popoutId, a.key, {
+      groupId: paneC,
+      edge: "center",
+    });
+    const sub = useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    const cPane = sub.children.find((g) => (g as GroupNode).id === paneC) as GroupNode;
+    expect(cPane.tabKeys).toEqual([c.key, a.key]); // merged into the c-pane, active
+    expect(cPane.activeKey).toBe(a.key);
+  });
+
+  it("docks at a body EDGE → carves a new pane in the popout", () => {
+    const { a, paneB } = splitSetup();
+    const popoutId = useTabsStore.getState().detachedGroupsByScope["p"][0].id;
+    useTabsStore.getState().dockTabIntoDetached("p", popoutId, a.key, {
+      groupId: paneB,
+      edge: "bottom",
+    });
+    // The popout now has 3 panes (b | c, with b split into b/a vertically); a sits
+    // alone in its own fresh group and is active there.
+    const sub = useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    const aGroup = allGroupsOf(sub).find((g) => g.tabKeys.includes(a.key))!;
+    expect(aGroup.tabKeys).toEqual([a.key]);
+    expect(aGroup.activeKey).toBe(a.key);
+  });
+
+  it("docks at a bar SLOT (index) → inserts into that pane at the slot", () => {
+    const { a, c, paneC } = splitSetup();
+    const popoutId = useTabsStore.getState().detachedGroupsByScope["p"][0].id;
+    useTabsStore.getState().dockTabIntoDetached("p", popoutId, a.key, { groupId: paneC, index: 0 });
+    const sub = useTabsStore.getState().detachedGroupsByScope["p"][0].subtree as SplitNode;
+    const cPane = sub.children.find((g) => (g as GroupNode).id === paneC) as GroupNode;
+    expect(cPane.tabKeys).toEqual([a.key, c.key]); // inserted before c
+  });
+});
+
+/** Flatten every group in a subtree (test-local; mirrors allGroups). */
+function allGroupsOf(node: SplitNode | GroupNode): GroupNode[] {
+  if (node.type === "group") return [node];
+  return node.children.flatMap((c) => allGroupsOf(c as SplitNode | GroupNode));
+}
diff --git a/src/__tests__/SubwindowFilesSidebar.test.ts b/src/__tests__/SubwindowFilesSidebar.test.ts
new file mode 100644
index 0000000..514dd94
--- /dev/null
+++ b/src/__tests__/SubwindowFilesSidebar.test.ts
@@ -0,0 +1,205 @@
+/**
+ * Per-subwindow right file viewer (◫): the open flag + column width live on the
+ * group NODE (GroupNode.filesOpen/filesWidth), so they must (1) flip via the
+ * store actions, (2) survive serialize → prune → restore (a restart), (3) travel
+ * with a detach (pop-out), and (4) be reachable from a popout via the streamed
+ * "files" detached edit.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn() }));
+
+import {
+  useTabsStore,
+  serializeTree,
+  pruneSavedTree,
+  findGroup,
+  allGroups,
+  type GroupNode,
+  type LayoutNode,
+} from "../stores/tabs";
+import { applyEditToSubtree } from "../stores/detached";
+import {
+  clampFilesWidth,
+  MIN_GROUP_FILES_WIDTH,
+  MAX_GROUP_FILES_WIDTH,
+} from "../components/files/SubwindowFilesSidebar";
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+/** Build a single-group scope holding a,b and select it. */
+function seed() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    hiddenGroupsByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+  for (const k of ["a", "b"]) useTabsStore.getState().addTab(tab(k));
+}
+
+function group(): GroupNode {
+  return useTabsStore.getState().layout as GroupNode;
+}
+
+describe("tabs store — per-subwindow file viewer (setGroupFiles/setGroupFilesWidth)", () => {
+  beforeEach(seed);
+
+  it("toggles filesOpen on the group node and mirrors it into the scope layout", () => {
+    expect(group().filesOpen).toBeUndefined();
+    useTabsStore.getState().setGroupFiles(group().id, true);
+    expect(group().filesOpen).toBe(true);
+    const stored = useTabsStore.getState().layoutByScope["p"] as GroupNode;
+    expect(stored.filesOpen).toBe(true);
+    useTabsStore.getState().setGroupFiles(group().id, false);
+    expect(group().filesOpen).toBe(false);
+  });
+
+  it("stores the column width", () => {
+    useTabsStore.getState().setGroupFilesWidth(group().id, 420);
+    expect(group().filesWidth).toBe(420);
+  });
+
+  it("stores the browsed folder and no-ops on an unchanged one", () => {
+    useTabsStore.getState().setGroupFilesFolder(group().id, "src/lib");
+    expect(group().filesFolder).toBe("src/lib");
+    // Unchanged → same layout object (no churn / debounce wake), like setTabFolder.
+    const before = useTabsStore.getState().layout;
+    useTabsStore.getState().setGroupFilesFolder(group().id, "src/lib");
+    expect(useTabsStore.getState().layout).toBe(before);
+  });
+
+  it("is a no-op for a group that isn't in the live layout", () => {
+    const before = useTabsStore.getState().layout;
+    useTabsStore.getState().setGroupFiles("nope", true);
+    expect(useTabsStore.getState().layout).toBe(before);
+  });
+});
+
+describe("per-subwindow file viewer — persistence round-trip", () => {
+  beforeEach(seed);
+
+  it("serializeTree carries filesOpen/filesWidth/filesFolder, and pruneSavedTree keeps them", () => {
+    useTabsStore.getState().setGroupFiles(group().id, true);
+    useTabsStore.getState().setGroupFilesWidth(group().id, 350);
+    useTabsStore.getState().setGroupFilesFolder(group().id, "src/lib");
+    const saved = serializeTree(useTabsStore.getState().layout)!;
+    expect(saved).toMatchObject({
+      type: "group",
+      filesOpen: true,
+      filesWidth: 350,
+      filesFolder: "src/lib",
+    });
+    const keep = new Set(group().tabKeys);
+    const pruned = pruneSavedTree(saved, keep)!;
+    expect(pruned).toMatchObject({ filesOpen: true, filesWidth: 350, filesFolder: "src/lib" });
+  });
+
+  it("a closed viewer serializes with no filesOpen/filesFolder key at all", () => {
+    const saved = serializeTree(useTabsStore.getState().layout)!;
+    expect("filesOpen" in saved).toBe(false);
+    expect("filesWidth" in saved).toBe(false);
+    expect("filesFolder" in saved).toBe(false);
+  });
+
+  it("loadFromLayout restores the flag + width + folder onto the rebuilt group", () => {
+    useTabsStore.getState().setGroupFiles(group().id, true);
+    useTabsStore.getState().setGroupFilesWidth(group().id, 350);
+    useTabsStore.getState().setGroupFilesFolder(group().id, "src/lib");
+    const savedTabs = useTabsStore.getState().tabs.map((t) => ({ ...t }));
+    const savedTree = serializeTree(useTabsStore.getState().layout);
+    useTabsStore.getState().loadFromLayout(savedTabs as never, "/p", "p", savedTree as never);
+    const restored = useTabsStore.getState().layout as GroupNode;
+    expect(restored.filesOpen).toBe(true);
+    expect(restored.filesWidth).toBe(350);
+    expect(restored.filesFolder).toBe("src/lib");
+  });
+});
+
+describe("per-subwindow file viewer — detach + popout edits", () => {
+  beforeEach(seed);
+
+  it("detachGroup carries the flag into the detached record", () => {
+    // A second group so the detach isn't refused (can't detach the lone group).
+    const gid = group().id;
+    useTabsStore.getState().setGroupFiles(gid, true);
+    const b = useTabsStore.getState().tabs[1];
+    useTabsStore.getState().splitWithTab(b.key, gid, "right");
+    expect(allGroups(useTabsStore.getState().layout).length).toBe(2);
+    const label = useTabsStore.getState().detachGroup(gid, { skipBackend: true });
+    expect(label).toBeTruthy();
+    const rec = useTabsStore.getState().detachedGroupsByScope["p"][0];
+    expect(findGroup(rec.subtree, gid)?.filesOpen).toBe(true);
+  });
+
+  it('applyEditToSubtree("files") flips the flag / sets the width on the target group', () => {
+    const sub: LayoutNode = {
+      type: "group",
+      id: "g1",
+      tabKeys: ["t1"],
+      activeKey: "t1",
+    };
+    const opened = applyEditToSubtree(sub, { kind: "files", groupId: "g1", open: true })!;
+    expect((opened as GroupNode).filesOpen).toBe(true);
+    const resized = applyEditToSubtree(opened, { kind: "files", groupId: "g1", width: 400 })!;
+    expect((resized as GroupNode).filesWidth).toBe(400);
+    // The open flag survives a width-only edit.
+    expect((resized as GroupNode).filesOpen).toBe(true);
+    const browsed = applyEditToSubtree(resized, {
+      kind: "files",
+      groupId: "g1",
+      folder: "docs",
+    })!;
+    expect((browsed as GroupNode).filesFolder).toBe("docs");
+    // The open flag + width survive a folder-only edit.
+    expect((browsed as GroupNode).filesOpen).toBe(true);
+    expect((browsed as GroupNode).filesWidth).toBe(400);
+    // An edit for an unknown group leaves the subtree unchanged.
+    const noop = applyEditToSubtree(resized, { kind: "files", groupId: "gX", open: false })!;
+    expect((noop as GroupNode).filesOpen).toBe(true);
+  });
+
+  it('applyDetachedEdit("files") updates the main-side detached record', () => {
+    useTabsStore.setState({
+      detachedGroupsByScope: {
+        p: [
+          {
+            id: "d1",
+            label: "detached-p-d1",
+            subtree: { type: "group", id: "gd", tabKeys: ["x"], activeKey: "x" },
+          },
+        ],
+      },
+    });
+    useTabsStore
+      .getState()
+      .applyDetachedEdit("p", "d1", {
+        kind: "files",
+        groupId: "gd",
+        open: true,
+        width: 280,
+        folder: "src",
+      });
+    const rec = useTabsStore.getState().detachedGroupsByScope["p"][0];
+    const g = findGroup(rec.subtree, "gd")!;
+    expect(g.filesOpen).toBe(true);
+    expect(g.filesWidth).toBe(280);
+    expect(g.filesFolder).toBe("src");
+  });
+});
+
+describe("clampFilesWidth", () => {
+  it("clamps into the sidebar's min/max range", () => {
+    expect(clampFilesWidth(10)).toBe(MIN_GROUP_FILES_WIDTH);
+    expect(clampFilesWidth(10_000)).toBe(MAX_GROUP_FILES_WIDTH);
+    expect(clampFilesWidth(333.4)).toBe(333);
+  });
+});
diff --git a/src/__tests__/SubwindowHide.test.ts b/src/__tests__/SubwindowHide.test.ts
new file mode 100644
index 0000000..f164069
--- /dev/null
+++ b/src/__tests__/SubwindowHide.test.ts
@@ -0,0 +1,291 @@
+/**
+ * Hide / unhide / close a tiling subwindow (group) in the tabs store.
+ *
+ * Hiding is "detach minus the OS window": the group leaves `layoutByScope` and
+ * is parked in `hiddenGroupsByScope`, while its tab payloads stay in
+ * `tabsByScope` (so the flat pane layer keeps their PTYs mounted, hidden).
+ * Covers: hide strips + parks the group and keeps payloads; hiding the last
+ * group is allowed (empties the layout); unhide re-injects with regenerated ids
+ * and can restore focused on a chosen tab; closeHiddenGroup discards the tabs;
+ * and the persist round-trip (snapshot → loadFromLayout) restores it STILL
+ * hidden rather than docked live.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+const { invokeMock } = vi.hoisted(() => ({
+  invokeMock: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invokeMock(...a) }));
+
+import {
+  useTabsStore,
+  findGroup,
+  allGroups,
+  orderedTabKeys,
+  serializeTree,
+  pruneSavedTree,
+  withHiddenDocked,
+  hiddenTabKeys,
+  type GroupNode,
+  type SplitNode,
+} from "../stores/tabs";
+
+function tab(label: string) {
+  return { label, cmd: "bash", cwd: "/p", kind: "shell" as const };
+}
+
+function reset() {
+  invokeMock.mockClear();
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    detachedGroupsByScope: {},
+    hiddenGroupsByScope: {},
+    pendingRespawnByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+    fullscreenGroupId: null,
+  });
+}
+
+/** Build a 2-group row split [G(a), G(b)] and return the keys + group ids. */
+function twoGroups() {
+  const a = useTabsStore.getState().addTab(tab("a"));
+  const b = useTabsStore.getState().addTab(tab("b"));
+  const rootGid = (useTabsStore.getState().layout as GroupNode).id;
+  useTabsStore.getState().splitWithTab(b.key, rootGid, "right");
+  const root = useTabsStore.getState().layout as SplitNode;
+  const left = root.children[0] as GroupNode; // [a]
+  const right = root.children[1] as GroupNode; // [b]
+  return { a, b, left, right };
+}
+
+/** Flatten every tabKey referenced by a serialized layout tree. */
+function collectSavedKeys(tree: ReturnType<typeof serializeTree>): string[] {
+  if (!tree) return [];
+  if (tree.type === "group") return [...tree.tabKeys];
+  return tree.children.flatMap(collectSavedKeys);
+}
+
+/** Find the (first) node tagged `hidden` in a serialized tree. */
+function findHiddenNode(
+  tree: ReturnType<typeof serializeTree>,
+): NonNullable<ReturnType<typeof serializeTree>> | null {
+  if (!tree) return null;
+  if (tree.hidden) return tree;
+  if (tree.type === "split") {
+    for (const c of tree.children) {
+      const hit = findHiddenNode(c);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+
+describe("tabs store — hide / unhide subwindow", () => {
+  beforeEach(reset);
+
+  it("hide removes the group from the layout but keeps its tab payloads", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+
+    const layout = useTabsStore.getState().layout as GroupNode;
+    // Tree collapsed to the lone surviving group holding `a`.
+    expect(layout.type).toBe("group");
+    expect(layout.tabKeys).toEqual([a.key]);
+    expect(findGroup(layout, right.id)).toBeNull();
+
+    // The hidden group is recorded; b's payload survives in tabsByScope.
+    const hidden = useTabsStore.getState().hiddenGroupsByScope["p"];
+    expect(hidden).toHaveLength(1);
+    expect(hidden[0].id).toBe(right.id);
+    expect((hidden[0].subtree as GroupNode).tabKeys).toEqual([b.key]);
+    expect(useTabsStore.getState().tabs.map((t) => t.key).sort()).toEqual(
+      [a.key, b.key].sort(),
+    );
+
+    // Hiding never spawns an OS window (unlike detach).
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("moves focus off a hidden group onto a survivor", () => {
+    const { left, right } = twoGroups();
+    // Focus the group about to be hidden.
+    useTabsStore.getState().focusGroup(right.id);
+    useTabsStore.getState().hideGroup(right.id);
+    // Focus re-picked onto the surviving group.
+    expect(useTabsStore.getState().focusedGroupId).toBe(left.id);
+  });
+
+  it("allows hiding the last group (empties the layout → placeholder)", () => {
+    const a = useTabsStore.getState().addTab(tab("a"));
+    const gid = (useTabsStore.getState().layout as GroupNode).id;
+    useTabsStore.getState().hideGroup(gid);
+
+    // Unlike closeGroup/detachGroup's refusal, the lone group hides: layout null.
+    expect(useTabsStore.getState().layout).toBeNull();
+    const hidden = useTabsStore.getState().hiddenGroupsByScope["p"];
+    expect(hidden).toHaveLength(1);
+    expect((hidden[0].subtree as GroupNode).tabKeys).toEqual([a.key]);
+    // Payload survives so the pane stays mounted (hidden) and the PTY lives.
+    expect(useTabsStore.getState().tabs.map((t) => t.key)).toEqual([a.key]);
+  });
+
+  it("unhide re-injects the group with regenerated ids and clears the entry", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+
+    useTabsStore.getState().unhideGroup(right.id);
+
+    const layout = useTabsStore.getState().layout as SplitNode;
+    expect(layout.type).toBe("split");
+    const keys = allGroups(layout).flatMap((g) => g.tabKeys).sort();
+    expect(keys).toEqual([a.key, b.key].sort());
+    // The restored group's node id was regenerated (not the old right.id).
+    expect(findGroup(layout, right.id)).toBeNull();
+    // The hidden entry is gone; no IPC.
+    expect(useTabsStore.getState().hiddenGroupsByScope["p"]).toHaveLength(0);
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("unhide with activeKey restores focused on that tab", () => {
+    // A 2-tab group [b, c] hidden whole; restore focused on c (not the first).
+    const a = useTabsStore.getState().addTab(tab("a"));
+    const b = useTabsStore.getState().addTab(tab("b"));
+    const c = useTabsStore.getState().addTab(tab("c"));
+    const rootGid = (useTabsStore.getState().layout as GroupNode).id;
+    // Split [a] off so [b,c] is its own group.
+    useTabsStore.getState().splitWithTab(a.key, rootGid, "right");
+    const root = useTabsStore.getState().layout as SplitNode;
+    const bc = root.children[0] as GroupNode; // [b, c]
+    useTabsStore.getState().hideGroup(bc.id);
+
+    useTabsStore.getState().unhideGroup(bc.id, { activeKey: c.key });
+
+    const restored = allGroups(useTabsStore.getState().layout).find((g) =>
+      g.tabKeys.includes(b.key),
+    )!;
+    expect(restored.tabKeys.sort()).toEqual([b.key, c.key].sort());
+    expect(restored.activeKey).toBe(c.key);
+  });
+
+  it("unhide installs as root when the in-window tree emptied while hidden", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+    // Close the remaining in-window group's tab, emptying the layout.
+    useTabsStore.getState().removeTab(a.key);
+    expect(useTabsStore.getState().layout).toBeNull();
+
+    useTabsStore.getState().unhideGroup(right.id);
+    const layout = useTabsStore.getState().layout as GroupNode;
+    expect(layout.type).toBe("group");
+    expect(layout.tabKeys).toEqual([b.key]);
+  });
+
+  it("closeHiddenGroup discards the hidden group's tabs and record", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+
+    useTabsStore.getState().closeHiddenGroup(right.id);
+
+    // The hidden record is gone and b's payload is dropped (its PTY dies when the
+    // flat pane layer stops rendering the key).
+    expect(useTabsStore.getState().hiddenGroupsByScope["p"] ?? []).toHaveLength(0);
+    expect(useTabsStore.getState().tabs.map((t) => t.key)).toEqual([a.key]);
+    void b;
+  });
+
+  it("hide/unhide/close no-op for an unknown id", () => {
+    const { a } = twoGroups();
+    const before = useTabsStore.getState().layout;
+    useTabsStore.getState().hideGroup("missing");
+    useTabsStore.getState().unhideGroup("missing");
+    useTabsStore.getState().closeHiddenGroup("missing");
+    expect(useTabsStore.getState().layout).toBe(before);
+    expect(useTabsStore.getState().hiddenGroupsByScope["p"] ?? []).toHaveLength(0);
+    void a;
+  });
+});
+
+describe("tabs store — hidden-subwindow persistence", () => {
+  beforeEach(reset);
+
+  it("withHiddenDocked folds hidden groups into the tree tagged `hidden`", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+
+    const layout = useTabsStore.getState().layout;
+    const hidden = useTabsStore.getState().hiddenGroupsByScope["p"];
+    const merged = withHiddenDocked(serializeTree(layout), hidden);
+
+    // Both a's docked group and the hidden group's tab persist.
+    expect(collectSavedKeys(merged).sort()).toEqual([a.key, b.key].sort());
+    // The hidden group is tagged so restore re-parks it.
+    const tagged = findHiddenNode(merged);
+    expect(tagged).not.toBeNull();
+    expect((tagged as { tabKeys: string[] }).tabKeys).toEqual([b.key]);
+    // Owned-keys union counts hidden tabs.
+    expect(hiddenTabKeys(hidden)).toEqual([b.key]);
+  });
+
+  it("pruning preserves the hidden tag (restores parked, not docked)", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+    const merged = withHiddenDocked(
+      serializeTree(useTabsStore.getState().layout),
+      useTabsStore.getState().hiddenGroupsByScope["p"],
+    );
+    const pruned = pruneSavedTree(merged, new Set([a.key, b.key]));
+    expect(findHiddenNode(pruned)).not.toBeNull();
+  });
+
+  it("round-trips through snapshot → loadFromLayout still hidden", () => {
+    const { a, b, right } = twoGroups();
+    useTabsStore.getState().hideGroup(right.id);
+
+    const snap = useTabsStore.getState().snapshotScopeForSwitch("p");
+    const savedTabs = snap.tabs.map((t) => ({
+      key: t.key,
+      label: t.label,
+      cmd: t.cmd,
+      cwd: t.cwd,
+      kind: t.kind,
+    }));
+
+    // Simulate a restart into a fresh scope.
+    reset();
+    useTabsStore.getState().loadFromLayout(savedTabs, "/p", "p2", snap.tabGroups ?? undefined);
+
+    // The visible layout is only the group holding `a` (b's group stayed hidden).
+    const visible = allGroups(useTabsStore.getState().layoutByScope["p2"]);
+    expect(visible).toHaveLength(1);
+    expect(visible[0].tabKeys.map(labelOf("p2")).sort()).toEqual(["a"]);
+
+    // The hidden group came back parked, referencing the restored `b` tab.
+    const hidden = useTabsStore.getState().hiddenGroupsByScope["p2"];
+    expect(hidden).toHaveLength(1);
+    const hiddenLabels = orderedTabKeys(hidden[0].subtree).map(labelOf("p2"));
+    expect(hiddenLabels).toEqual(["b"]);
+
+    void a;
+    void b;
+    void right;
+  });
+
+  it("withHiddenDocked returns the in-window tree unchanged with no hidden groups", () => {
+    twoGroups();
+    const layout = serializeTree(useTabsStore.getState().layout);
+    expect(withHiddenDocked(layout, [])).toBe(layout);
+    expect(withHiddenDocked(layout, undefined)).toBe(layout);
+  });
+});
+
+/** Resolve a tab key to its label within a scope (post-restore key remap). */
+function labelOf(scope: string) {
+  return (key: string) =>
+    useTabsStore.getState().tabsByScope[scope]?.find((t) => t.key === key)?.label ?? key;
+}
diff --git a/src/__tests__/SyncStore.test.ts b/src/__tests__/SyncStore.test.ts
new file mode 100644
index 0000000..48cef89
--- /dev/null
+++ b/src/__tests__/SyncStore.test.ts
@@ -0,0 +1,97 @@
+/**
+ * SSH-sync Phase 1 — the frontend sync store. Locks that the manifest cache
+ * indexes `sync_status` rows by path, that the actions invoke the matching
+ * backend commands (and refresh afterwards), and that the `sync-progress` stream
+ * updates the in-flight progress / refreshes on completion.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve([])) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+
+import { useSyncStore, listenSyncProgress } from "../stores/sync";
+
+const invokeMock = vi.mocked(invoke);
+const listenMock = vi.mocked(listen);
+
+function reset() {
+  invokeMock.mockReset();
+  invokeMock.mockResolvedValue([] as never);
+  useSyncStore.setState({ byProject: {}, progressByProject: {} });
+}
+
+describe("sync store actions", () => {
+  beforeEach(reset);
+
+  it("refreshStatus indexes rows by rel_path", async () => {
+    invokeMock.mockResolvedValueOnce([
+      { rel_path: "src/main.rs", is_dir: false, selected: true, state: "green" },
+      { rel_path: "docs", is_dir: true, selected: true, state: "green" },
+    ] as never);
+    await useSyncStore.getState().refreshStatus("p1");
+    const m = useSyncStore.getState().byProject["p1"];
+    expect(m["src/main.rs"]).toEqual({ state: "green", selected: true, isDir: false });
+    expect(m["docs"].isDir).toBe(true);
+  });
+
+  it("pull invokes sync_pull then refreshes status", async () => {
+    await useSyncStore.getState().pull("p1", "src/lib.rs");
+    const calls = invokeMock.mock.calls.map((c) => c[0]);
+    expect(calls).toContain("sync_pull");
+    expect(calls).toContain("sync_status");
+    const pullArgs = invokeMock.mock.calls.find((c) => c[0] === "sync_pull")![1];
+    expect(pullArgs).toEqual({ projectId: "p1", relPath: "src/lib.rs" });
+  });
+
+  it("markSelected forwards the selection + dir flag", async () => {
+    await useSyncStore.getState().markSelected("p1", ["a", "b"], false, true);
+    const args = invokeMock.mock.calls.find((c) => c[0] === "sync_mark_selected")![1];
+    expect(args).toEqual({ projectId: "p1", relPaths: ["a", "b"], selected: false, isDir: true });
+  });
+
+  it("syncWholeProject and syncNow call their commands", async () => {
+    await useSyncStore.getState().syncWholeProject("p1");
+    await useSyncStore.getState().syncNow("p1");
+    const calls = invokeMock.mock.calls.map((c) => c[0]);
+    expect(calls).toContain("sync_whole_project");
+    expect(calls).toContain("sync_now");
+  });
+
+  it("push forwards force + returns conflicts", async () => {
+    invokeMock.mockResolvedValueOnce({ pushed: 1, conflicts: ["a.txt"] } as never);
+    const res = await useSyncStore.getState().push("p1", "a.txt", false);
+    expect(res).toEqual({ pushed: 1, conflicts: ["a.txt"] });
+    const args = invokeMock.mock.calls.find((c) => c[0] === "sync_push")![1];
+    expect(args).toEqual({ projectId: "p1", relPath: "a.txt", force: false });
+    // It refreshes status afterwards.
+    expect(invokeMock.mock.calls.some((c) => c[0] === "sync_status")).toBe(true);
+  });
+});
+
+describe("sync-progress subscription", () => {
+  beforeEach(() => {
+    reset();
+    listenMock.mockClear();
+  });
+
+  it("tracks in-flight progress and clears + refreshes on done", async () => {
+    let handler: ((ev: { payload: unknown }) => void) | null = null;
+    listenMock.mockImplementationOnce((_evt, cb) => {
+      handler = cb as typeof handler;
+      return Promise.resolve(() => {});
+    });
+    await listenSyncProgress();
+    expect(handler).toBeTruthy();
+
+    handler!({ payload: { project_id: "p1", phase: "file", rel_path: "a.txt", done: 1, total: 3 } });
+    expect(useSyncStore.getState().progressByProject["p1"]).toEqual({ rel: "a.txt", done: 1, total: 3 });
+
+    handler!({ payload: { project_id: "p1", phase: "done", rel_path: "", done: 3, total: 3 } });
+    expect(useSyncStore.getState().progressByProject["p1"]).toBeNull();
+    // The done event triggers a status refresh.
+    expect(invokeMock.mock.calls.some((c) => c[0] === "sync_status")).toBe(true);
+  });
+});
diff --git a/src/__tests__/SystemMonitorSampling.test.ts b/src/__tests__/SystemMonitorSampling.test.ts
new file mode 100644
index 0000000..67d0ea5
--- /dev/null
+++ b/src/__tests__/SystemMonitorSampling.test.ts
@@ -0,0 +1,76 @@
+/**
+ * The htop-like monitor derives every live percentage on the frontend from the
+ * delta of two successive backend snapshots (the backend only ships cumulative
+ * counters). These tests lock that delta math: per-core CPU%, per-process CPU%
+ * (top-style, normalised by core count), and MEM% — including the first-frame
+ * and counter-reset guards that keep a fresh or pid-reused sample from spiking.
+ */
+import { describe, it, expect } from "vitest";
+
+import {
+  coreUsagePercent,
+  procCpuPercent,
+  memPercent,
+  type CpuTimes,
+} from "../components/monitoring/SystemMonitorPane";
+
+describe("coreUsagePercent", () => {
+  it("is 0 on the first frame (no previous sample)", () => {
+    expect(coreUsagePercent(undefined, { busy: 50, total: 100 })).toBe(0);
+  });
+
+  it("computes busyΔ / totalΔ as a percentage", () => {
+    const prev: CpuTimes = { busy: 100, total: 400 };
+    const next: CpuTimes = { busy: 150, total: 500 };
+    // busyΔ=50 over totalΔ=100 → 50%.
+    expect(coreUsagePercent(prev, next)).toBeCloseTo(50);
+  });
+
+  it("returns 0 on a non-positive total delta (idle/stale sample)", () => {
+    const same: CpuTimes = { busy: 100, total: 400 };
+    expect(coreUsagePercent(same, same)).toBe(0);
+  });
+
+  it("returns 0 on a negative busy delta (counter reset)", () => {
+    expect(coreUsagePercent({ busy: 200, total: 400 }, { busy: 10, total: 500 })).toBe(0);
+  });
+
+  it("clamps to 100", () => {
+    // Impossible-but-defensive: busyΔ exceeds totalΔ.
+    expect(coreUsagePercent({ busy: 0, total: 0 }, { busy: 500, total: 100 })).toBe(100);
+  });
+});
+
+describe("procCpuPercent", () => {
+  it("is 0 on the first frame (no previous jiffies)", () => {
+    expect(procCpuPercent(undefined, 1000, 400, 8)).toBe(0);
+  });
+
+  it("normalises by core count (top-style % of one core)", () => {
+    // A process that used 100 jiffies while the whole machine advanced 400 total
+    // jiffies, on an 8-core box: (100/400)*8*100 = 200% (two cores busy).
+    expect(procCpuPercent(900, 1000, 400, 8)).toBeCloseTo(200);
+  });
+
+  it("single-core box reports plain ratio", () => {
+    expect(procCpuPercent(0, 50, 100, 1)).toBeCloseTo(50);
+  });
+
+  it("returns 0 on a non-positive total delta", () => {
+    expect(procCpuPercent(900, 1000, 0, 8)).toBe(0);
+  });
+
+  it("returns 0 on a negative process delta (pid reuse / respawn)", () => {
+    expect(procCpuPercent(1000, 10, 400, 8)).toBe(0);
+  });
+});
+
+describe("memPercent", () => {
+  it("computes rss / total as a percentage", () => {
+    expect(memPercent(2048, 8192)).toBeCloseTo(25);
+  });
+
+  it("returns 0 when total is unknown", () => {
+    expect(memPercent(2048, 0)).toBe(0);
+  });
+});
diff --git a/src/__tests__/TabInlineRename.test.tsx b/src/__tests__/TabInlineRename.test.tsx
index be97f18..a4d358b 100644
--- a/src/__tests__/TabInlineRename.test.tsx
+++ b/src/__tests__/TabInlineRename.test.tsx
@@ -1,10 +1,13 @@
 /**
- * #56 — right-click a tab enters inline rename mode (no context menu, no prompt).
+ * #56 — SHIFT+right-click a tab enters inline rename mode (no menu, no prompt).
+ * Plain right-click opens the tab context menu instead (which carries its own
+ * "Rename" item routing back into the same inline editor).
  *
  * Renders the real TabBar and drives the contextmenu / keyboard path through
  * React's own event system to prove:
- *   - contextmenu on a tab swaps the label for a focused, text-selected input
- *     and shows NO context menu;
+ *   - shift+contextmenu on a tab swaps the label for a focused, text-selected
+ *     input and shows NO context menu;
+ *   - a plain contextmenu opens the menu and does NOT start renaming;
  *   - typing + Enter commits the new label via renameTab;
  *   - Escape discards the edit, leaving the original label;
  *   - a pointerdown on the editing input does not start a tab drag.
@@ -45,13 +48,13 @@ describe("#56 inline tab rename", () => {
     cleanup();
   });
 
-  it("contextmenu shows an input (label selected) and no context menu", () => {
+  it("shift+contextmenu shows an input (label selected) and no context menu", () => {
     const { groupId } = seedOneTab("shell");
     const { container } = render(
       <TabBar groupId={groupId} projectCwd="/p" showGroupClose={false} />,
     );
     const tab = container.querySelector(".tab")!;
-    fireEvent.contextMenu(tab);
+    fireEvent.contextMenu(tab, { shiftKey: true });
 
     const input = container.querySelector("input.tab-label-edit") as HTMLInputElement | null;
     expect(input).toBeTruthy();
@@ -59,18 +62,31 @@ describe("#56 inline tab rename", () => {
     // The whole label is selected for a fast retype.
     expect(input!.selectionStart).toBe(0);
     expect(input!.selectionEnd).toBe("shell".length);
-    // No old-style tab context menu.
-    expect(document.querySelector(".tab-context-menu")).toBeNull();
+    // Shift goes STRAIGHT to rename — the menu is skipped entirely. (It portals
+    // to document.body, so look there rather than in the container.)
+    expect(document.querySelector(".tab-new-menu")).toBeNull();
     // The plain label span is gone while editing.
     expect(container.querySelector(".tab-label")).toBeNull();
   });
 
+  it("plain contextmenu opens the tab menu and does NOT start renaming", () => {
+    const { groupId } = seedOneTab("shell");
+    const { container } = render(
+      <TabBar groupId={groupId} projectCwd="/p" showGroupClose={false} />,
+    );
+    fireEvent.contextMenu(container.querySelector(".tab")!);
+
+    expect(document.querySelector(".tab-new-menu")).toBeTruthy();
+    expect(container.querySelector("input.tab-label-edit")).toBeNull();
+    expect(container.querySelector(".tab-label")!.textContent).toBe("shell");
+  });
+
   it("typing + Enter renames the tab and closes the editor", () => {
     const { groupId, key } = seedOneTab("old");
     const { container } = render(
       <TabBar groupId={groupId} projectCwd="/p" showGroupClose={false} />,
     );
-    fireEvent.contextMenu(container.querySelector(".tab")!);
+    fireEvent.contextMenu(container.querySelector(".tab")!, { shiftKey: true });
     const input = container.querySelector("input.tab-label-edit") as HTMLInputElement;
     fireEvent.change(input, { target: { value: "renamed" } });
     fireEvent.keyDown(input, { key: "Enter" });
@@ -85,7 +101,7 @@ describe("#56 inline tab rename", () => {
     const { container } = render(
       <TabBar groupId={groupId} projectCwd="/p" showGroupClose={false} />,
     );
-    fireEvent.contextMenu(container.querySelector(".tab")!);
+    fireEvent.contextMenu(container.querySelector(".tab")!, { shiftKey: true });
     const input = container.querySelector("input.tab-label-edit") as HTMLInputElement;
     fireEvent.change(input, { target: { value: "discarded" } });
     fireEvent.keyDown(input, { key: "Escape" });
@@ -100,7 +116,7 @@ describe("#56 inline tab rename", () => {
     const { container } = render(
       <TabBar groupId={groupId} projectCwd="/p" showGroupClose={false} />,
     );
-    fireEvent.contextMenu(container.querySelector(".tab")!);
+    fireEvent.contextMenu(container.querySelector(".tab")!, { shiftKey: true });
     const input = container.querySelector("input.tab-label-edit") as HTMLInputElement;
     fireEvent.pointerDown(input, { button: 0, clientX: 10, clientY: 10 });
     // Moving far would normally cross the drag threshold; the input's
diff --git a/src/__tests__/TabLocality.test.ts b/src/__tests__/TabLocality.test.ts
new file mode 100644
index 0000000..32efb1b
--- /dev/null
+++ b/src/__tests__/TabLocality.test.ts
@@ -0,0 +1,147 @@
+/**
+ * SSH-sync Phase 0 — per-tab local/remote locality axis. Agent tabs default
+ * LOCAL (run in the project mirror), shell tabs default REMOTE (run on the host
+ * over ssh); local_agent is fixed-local; the choice is user-toggleable via
+ * setTabLocation and survives the save → project.json → load round-trip. These
+ * tests lock the defaults, the resolver, the cwd resolution, and the round-trip.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import {
+  defaultLocationForKind,
+  effectiveTabLocation,
+  isLocatableKind,
+  localTabCwd,
+  useTabsStore,
+  type SavedLayoutTree,
+} from "../stores/tabs";
+
+const invokeMock = vi.mocked(invoke);
+
+function resetStore() {
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+describe("locality defaults + resolver", () => {
+  it("agents default local, shells default remote", () => {
+    expect(defaultLocationForKind("agent")).toBe("local");
+    expect(defaultLocationForKind("shell")).toBe("remote");
+  });
+
+  it("effectiveTabLocation honors an explicit override, else the kind default", () => {
+    expect(effectiveTabLocation({ kind: "agent" })).toBe("local");
+    expect(effectiveTabLocation({ kind: "shell" })).toBe("remote");
+    expect(effectiveTabLocation({ kind: "agent", location: "remote" })).toBe("remote");
+    expect(effectiveTabLocation({ kind: "shell", location: "local" })).toBe("local");
+    // local_agent is fixed-local regardless of any stored value.
+    expect(effectiveTabLocation({ kind: "local_agent", location: "remote" })).toBe("local");
+  });
+
+  it("only agent/shell tabs are locatable", () => {
+    expect(isLocatableKind("agent")).toBe(true);
+    expect(isLocatableKind("shell")).toBe(true);
+    expect(isLocatableKind("local_agent")).toBe(false);
+    expect(isLocatableKind("files")).toBe(false);
+    expect(isLocatableKind("embed")).toBe(false);
+  });
+});
+
+describe("localTabCwd", () => {
+  const opts = (over = {}) => ({
+    isRemoteProject: true,
+    projectDirectory: "/state/remote-projects/p1",
+    fallback: "/ignored",
+    ...over,
+  });
+
+  it("routes a local-on-remote tab into the project mirror dir", () => {
+    expect(localTabCwd({ kind: "agent" }, opts())).toBe("/state/remote-projects/p1/mirror");
+  });
+
+  it("leaves a remote-running tab on its own cwd (ignored by the ssh wrap)", () => {
+    expect(localTabCwd({ kind: "shell" }, opts())).toBe("/ignored");
+    // An agent explicitly switched to remote also keeps the fallback.
+    expect(localTabCwd({ kind: "agent", location: "remote" }, opts())).toBe("/ignored");
+  });
+
+  it("is inert on a local project (always the tab's own cwd)", () => {
+    expect(localTabCwd({ kind: "agent" }, opts({ isRemoteProject: false }))).toBe("/ignored");
+  });
+});
+
+describe("setTabLocation", () => {
+  beforeEach(resetStore);
+
+  it("flips a tab's locality and is a no-op when unchanged", () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    const tab = store.addTab({ label: "Claude", cmd: "claude", cwd: "/p", kind: "agent" });
+
+    useTabsStore.getState().setTabLocation(tab.key, "remote");
+    expect(
+      useTabsStore.getState().tabs.find((t) => t.key === tab.key)?.location,
+    ).toBe("remote");
+
+    const before = useTabsStore.getState().tabs;
+    useTabsStore.getState().setTabLocation(tab.key, "remote");
+    // Re-setting the same value leaves the tabs array reference untouched.
+    expect(useTabsStore.getState().tabs).toBe(before);
+  });
+});
+
+describe("location round-trips through save/load", () => {
+  beforeEach(() => {
+    invokeMock.mockClear();
+    resetStore();
+  });
+
+  it("persists location in the saved tab layout", async () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    const tab = store.addTab({ label: "Shell", cmd: "", cwd: "/p", kind: "shell" });
+    useTabsStore.getState().setTabLocation(tab.key, "local");
+
+    await useTabsStore.getState().saveLayout("/p/project.json");
+
+    const call = invokeMock.mock.calls.find((c) => c[0] === "save_tab_layout");
+    expect(call).toBeTruthy();
+    const arg = call![1] as {
+      tabs: { label: string; location?: string }[];
+      groups: SavedLayoutTree | null;
+    };
+    expect(arg.tabs.find((t) => t.label === "Shell")?.location).toBe("local");
+  });
+
+  it("restores location onto the rebuilt tab", () => {
+    useTabsStore.getState().loadFromLayout(
+      [
+        {
+          key: "agent-9",
+          label: "Claude",
+          cmd: "claude",
+          cwd: "/p",
+          kind: "agent",
+          location: "remote",
+        },
+      ],
+      "/p",
+      "p",
+    );
+    const tabs = useTabsStore.getState().tabsByScope["p"];
+    expect(tabs).toHaveLength(1);
+    expect(tabs[0].location).toBe("remote");
+  });
+});
diff --git a/src/__tests__/TabPersistClearGuard.test.ts b/src/__tests__/TabPersistClearGuard.test.ts
new file mode 100644
index 0000000..ac7aeda
--- /dev/null
+++ b/src/__tests__/TabPersistClearGuard.test.ts
@@ -0,0 +1,118 @@
+/**
+ * An empty layout must not be able to erase a saved one.
+ *
+ * Saving empty is destructive on the backend: it drops `tab_layout` + `tab_groups`
+ * from project.json AND overwrites the `.eldrun` session mirror, both from the same
+ * array in the same call — so the mirror is no backup, and a resumable agent tab's
+ * `sessionId` (the only handle on its conversation) goes with them.
+ *
+ * The live bug (DemoProj, four tabs incl. three Claude conversations): the debounced
+ * autosave persisted the tab store's CURRENT scope into the ACTIVE project's
+ * `local_file`, two independently tracked values. Detach swaps `local_file` (remote
+ * state dir → promoted mirror) under a store whose scope hasn't caught up; the
+ * per-scope filter then correctly refuses to write the other scope's tabs into that
+ * file, and what reaches the backend is `[]` — indistinguishable from a deliberate
+ * close-all, and fatal.
+ *
+ * So the frontend must now VOUCH for an empty save (`allowClear`), and it can only do
+ * that for a scope it actually hydrated which genuinely holds no tabs. These tests
+ * lock that down; `save_empty_tabs_preserves_layout_when_clearing_is_not_allowed`
+ * (services_tests.rs) locks down the backend honouring it.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import { useTabsStore, type TabEntry } from "../stores/tabs";
+
+const invokeMock = vi.mocked(invoke);
+const LOCAL_FILE = "/p/project.json";
+
+function agentTab(over: Partial<TabEntry> = {}): TabEntry {
+  return {
+    key: "agent-2",
+    label: "Claude",
+    cmd: "claude",
+    args: [],
+    env: {},
+    cwd: "/p",
+    kind: "agent",
+    scope: "pid",
+    sessionId: "6252990e-a459-46c6-8c43-f1d2f68dc4b3",
+    ...over,
+  } as TabEntry;
+}
+
+/** Seed the store, optionally leaving the scope entirely UN-hydrated. */
+function seed(tabs: TabEntry[] | undefined) {
+  useTabsStore.setState({
+    scope: "pid",
+    tabsByScope: tabs === undefined ? {} : { pid: tabs },
+    layoutByScope: { pid: null },
+    focusedGroupByScope: { pid: null },
+    detachedGroupsByScope: {},
+    tabs: tabs ?? [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+}
+
+/** The `allowClear` flag on the save_tab_layout invoke, plus the tabs it sent. */
+function lastSave() {
+  const call = invokeMock.mock.calls.find((c) => c[0] === "save_tab_layout");
+  if (!call) return null;
+  const arg = call[1] as { tabs: unknown[]; allowClear: boolean };
+  return { tabs: arg.tabs, allowClear: arg.allowClear };
+}
+
+beforeEach(() => {
+  invokeMock.mockClear();
+});
+
+describe("persistScope — an empty layout only clears when it is meant", () => {
+  it("vouches for the empty save when a hydrated scope genuinely holds no tabs", async () => {
+    // The user closed the last tab. This is a real close-all and must persist.
+    seed([]);
+    await useTabsStore.getState().persistScope("pid", LOCAL_FILE);
+
+    expect(lastSave()).toEqual({ tabs: [], allowClear: true });
+  });
+
+  it("refuses to vouch for a scope it never hydrated", async () => {
+    // Nothing was ever restored for `pid` — its emptiness is ignorance, not intent.
+    // (A project whose restore finds no restorable tabs never creates the scope key.)
+    seed(undefined);
+    await useTabsStore.getState().persistScope("pid", LOCAL_FILE);
+
+    expect(lastSave()).toEqual({ tabs: [], allowClear: false });
+  });
+
+  it("refuses to vouch when the scope holds tabs that all get filtered out", async () => {
+    // THE DemoProj CASE. The scope holds tabs, but every one of them belongs to a
+    // different scope — the pairing drifted — so the keep-filter drops them all and
+    // the persisted layout comes out empty. It looks exactly like a close-all. It is
+    // not one, and it must never erase the three Claude conversations on disk.
+    seed([agentTab({ scope: "a-different-project" })]);
+    await useTabsStore.getState().persistScope("pid", LOCAL_FILE);
+
+    const save = lastSave();
+    expect(save?.tabs).toEqual([]);
+    expect(save?.allowClear).toBe(false);
+  });
+
+  it("still persists a real layout, and carries the agent's sessionId", async () => {
+    seed([agentTab()]);
+    await useTabsStore.getState().persistScope("pid", LOCAL_FILE);
+
+    const save = lastSave();
+    expect(save?.tabs).toHaveLength(1);
+    expect((save?.tabs[0] as { sessionId?: string }).sessionId).toBe(
+      "6252990e-a459-46c6-8c43-f1d2f68dc4b3",
+    );
+    // Non-empty saves are unaffected by the guard either way.
+    expect(save?.allowClear).toBe(false);
+  });
+});
diff --git a/src/__tests__/TabPersistFilter.test.ts b/src/__tests__/TabPersistFilter.test.ts
index 5dfcd7a..377aeff 100644
--- a/src/__tests__/TabPersistFilter.test.ts
+++ b/src/__tests__/TabPersistFilter.test.ts
@@ -1,8 +1,9 @@
 /**
  * Save-side tab persistence filtering. Shell/files tabs always survive a
- * restart. Resumable agent tabs (Claude or Codex with a sessionId) now survive
- * too and carry their sessionId; an agent tab without a sessionId, or a
- * not-yet-wired agent (Gemini/Vibe), is still dropped. These tests lock in
+ * restart. Resumable agent tabs (Claude, Codex, Gemini, Mistral/vibe and the
+ * other continue-last agents, each with a sessionId) now survive too and carry
+ * their sessionId; an agent tab without a sessionId, or an agent with no wired
+ * resume (Aider), is still dropped. These tests lock in
  * saveLayout's keep-filter and the shared pruneSavedTree / isRestorableKind /
  * isResumableAgentTab / isRestorableTab helpers.
  */
@@ -24,17 +25,18 @@ import {
 const invokeMock = vi.mocked(invoke);
 
 describe("isRestorableKind", () => {
-  it("keeps shell and files, drops agent and local_agent", () => {
+  it("keeps shell, files, and network; drops agent and local_agent", () => {
     expect(isRestorableKind("shell")).toBe(true);
     expect(isRestorableKind("files")).toBe(true);
+    expect(isRestorableKind("network")).toBe(true);
     expect(isRestorableKind("agent")).toBe(false);
     expect(isRestorableKind("local_agent")).toBe(false);
   });
 });
 
 describe("isResumableAgentTab / isRestorableTab", () => {
-  it("treats a Claude or Codex agent tab with a sessionId as resumable", () => {
-    for (const cmd of ["claude", "codex"]) {
+  it("treats a resumable agent tab (Claude, Codex, Gemini, vibe) with a sessionId as resumable", () => {
+    for (const cmd of ["claude", "codex", "gemini", "vibe"]) {
       const tab = { kind: "agent" as const, cmd, sessionId: "abc-123" };
       expect(isResumableAgentTab(tab)).toBe(true);
       expect(isRestorableTab(tab)).toBe(true);
@@ -42,21 +44,38 @@ describe("isResumableAgentTab / isRestorableTab", () => {
   });
 
   it("drops a resumable-agent tab without a sessionId", () => {
-    for (const cmd of ["claude", "codex"]) {
+    for (const cmd of ["claude", "codex", "gemini", "vibe"]) {
       const tab = { kind: "agent" as const, cmd };
       expect(isResumableAgentTab(tab)).toBe(false);
       expect(isRestorableTab(tab)).toBe(false);
     }
   });
 
-  it("drops a not-yet-wired agent even with a sessionId", () => {
-    for (const cmd of ["gemini", "vibe"]) {
+  it("drops an agent with no wired resume even with a sessionId", () => {
+    for (const cmd of ["aider"]) {
       const tab = { kind: "agent" as const, cmd, sessionId: "abc-123" };
       expect(isResumableAgentTab(tab)).toBe(false);
       expect(isRestorableTab(tab)).toBe(false);
     }
   });
 
+  it("treats a custom agent with resumeArgs + a sessionId as resumable", () => {
+    const tab = {
+      kind: "agent" as const,
+      cmd: "my-agent",
+      sessionId: "abc-123",
+      resumeArgs: ["--continue"],
+    };
+    expect(isResumableAgentTab(tab)).toBe(true);
+    expect(isRestorableTab(tab)).toBe(true);
+  });
+
+  it("drops a launch-only custom agent (unknown cmd, no resumeArgs)", () => {
+    const tab = { kind: "agent" as const, cmd: "my-agent", sessionId: "abc-123" };
+    expect(isResumableAgentTab(tab)).toBe(false);
+    expect(isRestorableTab(tab)).toBe(false);
+  });
+
   it("keeps shell/files tabs via kind regardless of sessionId", () => {
     expect(isRestorableTab({ kind: "shell", cmd: "bash" })).toBe(true);
     expect(isRestorableTab({ kind: "files", cmd: "__eldrun_files__" })).toBe(true);
@@ -162,7 +181,7 @@ describe("saveLayout — persists restorable tabs (incl. resumable agents)", ()
     expect(codex?.sessionId).toBe("codex-key-1");
   });
 
-  it("drops a not-yet-wired agent even with a sessionId", async () => {
+  it("persists a continue-last agent (gemini) with its sessionId", async () => {
     const store = useTabsStore.getState();
     store.setScope("p");
     store.addTab({
@@ -176,6 +195,28 @@ describe("saveLayout — persists restorable tabs (incl. resumable agents)", ()
 
     await useTabsStore.getState().saveLayout("/p/project.json");
 
+    const call = invokeMock.mock.calls.find((c) => c[0] === "save_tab_layout");
+    const arg = call![1] as {
+      tabs: { kind: string; cmd: string; sessionId?: string }[];
+    };
+    const gemini = arg.tabs.find((t) => t.cmd === "gemini");
+    expect(gemini?.sessionId).toBe("abc-123");
+  });
+
+  it("drops an agent with no wired resume (aider) even with a sessionId", async () => {
+    const store = useTabsStore.getState();
+    store.setScope("p");
+    store.addTab({
+      label: "aider",
+      cmd: "aider",
+      cwd: "/p",
+      kind: "agent",
+      sessionId: "abc-123",
+    });
+    store.addTab({ label: "bash", cmd: "bash", cwd: "/p", kind: "shell" });
+
+    await useTabsStore.getState().saveLayout("/p/project.json");
+
     const call = invokeMock.mock.calls.find((c) => c[0] === "save_tab_layout");
     const arg = call![1] as { tabs: { kind: string }[]; groups: SavedLayoutTree | null };
     expect(arg.tabs.map((t) => t.kind)).toEqual(["shell"]);
diff --git a/src/__tests__/TerminalAttachOnly.test.tsx b/src/__tests__/TerminalAttachOnly.test.tsx
index 996d745..b446f36 100644
--- a/src/__tests__/TerminalAttachOnly.test.tsx
+++ b/src/__tests__/TerminalAttachOnly.test.tsx
@@ -38,9 +38,16 @@ vi.mock("@xterm/xterm", () => ({
     write() {}
     onData() {}
     onResize() {}
+    onBell() {}
+    onTitleChange() {}
+    onSelectionChange() {}
+    buffer = { active: { length: 0, getLine: () => null } };
+    attachCustomKeyEventHandler() {}
+    getSelection() { return ""; }
     focus() {}
     dispose() {}
     options = {};
+    parser = { registerOscHandler: () => ({ dispose() {} }) };
   },
 }));
 vi.mock("@xterm/addon-fit", () => ({
diff --git a/src/__tests__/TerminalControl.test.ts b/src/__tests__/TerminalControl.test.ts
new file mode 100644
index 0000000..254c029
--- /dev/null
+++ b/src/__tests__/TerminalControl.test.ts
@@ -0,0 +1,36 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  claimInitialInput,
+  clearClaimedInitialInputsForTest,
+  initialInputForPty,
+  isTerminalIdentityResponse,
+} from "../lib/terminalControl";
+
+describe("terminal control helpers", () => {
+  beforeEach(() => {
+    clearClaimedInitialInputsForTest();
+  });
+
+  it("detects xterm identity replies that must not become shell input", () => {
+    expect(isTerminalIdentityResponse("\x1b[>0;276;0c")).toBe(true);
+    expect(isTerminalIdentityResponse("\x1b[?1;2c")).toBe(true);
+    expect(isTerminalIdentityResponse("\x1b[>0;276;0c\x1b[?1;2c")).toBe(true);
+  });
+
+  it("does not classify ordinary command text as a terminal identity reply", () => {
+    expect(isTerminalIdentityResponse("PATH=/usr/bin:$PATH bash 'install.sh'")).toBe(false);
+    expect(isTerminalIdentityResponse("0;276;0cPATH=/usr/bin:$PATH bash 'install.sh'")).toBe(false);
+  });
+
+  it("clears shell readline before auto-typing commands", () => {
+    expect(initialInputForPty("bash 'install.sh'", "shell")).toBe("\x15bash 'install.sh'");
+    expect(initialInputForPty("/hooks", "agent")).toBe("/hooks");
+  });
+
+  it("claims a given initial input only once per PTY id", () => {
+    expect(claimInitialInput("p:shell-1", "bash 'install.sh'")).toBe(true);
+    expect(claimInitialInput("p:shell-1", "bash 'install.sh'")).toBe(false);
+    expect(claimInitialInput("p:shell-2", "bash 'install.sh'")).toBe(true);
+    expect(claimInitialInput("p:shell-1", "bash 'other.sh'")).toBe(true);
+  });
+});
diff --git a/src/__tests__/TerminalThemeRenderer.test.tsx b/src/__tests__/TerminalThemeRenderer.test.tsx
new file mode 100644
index 0000000..df44575
--- /dev/null
+++ b/src/__tests__/TerminalThemeRenderer.test.tsx
@@ -0,0 +1,218 @@
+/**
+ * Regression test for the most common error in the crash log — thrown on EVERY
+ * launch, ~4-5s in:
+ *
+ *   TypeError: undefined is not an object (evaluating 'this._renderer.value.dimensions')
+ *     dimensions@.../@xterm_xterm.js
+ *     syncScrollArea@.../@xterm_xterm.js
+ *
+ * Assigning `term.options.theme` makes xterm refresh through its renderer, and
+ * that renderer exists ONLY between `open()` and `dispose()`. The theme effect
+ * guarded on `termRef.current` alone, which is true for a terminal that has been
+ * constructed but not opened — and that is the normal state of a restored tab at
+ * launch: `colorScheme` comes from the settings store, which loads a few seconds
+ * AFTER the tabs mount, so the scheme arriving flipped the effect over a whole
+ * layout's worth of unopened terminals at once.
+ *
+ * The mock below models the one xterm behaviour that matters: a `theme` write is
+ * legal only while a renderer exists.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, act } from "@testing-library/react";
+
+class ResizeObserverStub {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+}
+(globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = ResizeObserverStub;
+
+const { invoke, themeWrites, liveTerminals } = vi.hoisted(() => ({
+  invoke: vi.fn((..._a: unknown[]) => Promise.resolve(undefined)),
+  themeWrites: [] as unknown[],
+  liveTerminals: [] as { opened: boolean; disposed: boolean }[],
+}));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: (...a: unknown[]) => invoke(...a) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn().mockResolvedValue(() => {}) }));
+
+vi.mock("@xterm/xterm", () => ({
+  Terminal: class {
+    cols = 80;
+    rows = 24;
+    // Stands in for xterm's `_renderer.value`: absent before open, absent again
+    // after dispose. A theme write outside that window is what throws.
+    renderer: object | null = null;
+    state = { opened: false, disposed: false };
+    options: Record<string, unknown>;
+    constructor() {
+      liveTerminals.push(this.state);
+      const state = this.state;
+      const self = this;
+      this.options = new Proxy({} as Record<string, unknown>, {
+        set(target, key, value) {
+          if (key === "theme") {
+            if (!self.renderer) {
+              throw new TypeError(
+                `undefined is not an object (evaluating 'this._renderer.value.dimensions') ` +
+                  `[opened=${state.opened} disposed=${state.disposed}]`,
+              );
+            }
+            themeWrites.push(value);
+          }
+          target[key as string] = value;
+          return true;
+        },
+      });
+    }
+    loadAddon() {}
+    open() {
+      this.renderer = {};
+      this.state.opened = true;
+    }
+    write() {}
+    onData() {}
+    onResize() {}
+    onBell() {}
+    onTitleChange() {}
+    onSelectionChange() {}
+    buffer = { active: { length: 0, getLine: () => null } };
+    attachCustomKeyEventHandler() {}
+    getSelection() {
+      return "";
+    }
+    focus() {}
+    dispose() {
+      this.renderer = null;
+      this.state.disposed = true;
+    }
+    parser = { registerOscHandler: () => ({ dispose() {} }) };
+  },
+}));
+vi.mock("@xterm/addon-fit", () => ({ FitAddon: class { fit() {} dispose() {} } }));
+vi.mock("@xterm/addon-web-links", () => ({ WebLinksAddon: class {} }));
+vi.mock("@xterm/xterm/css/xterm.css", () => ({}));
+
+// Mutable so a test can reproduce "settings landed after the tabs mounted".
+let colorScheme: string | undefined;
+vi.mock("../stores/settings", () => ({
+  useSettingsStore: vi.fn((sel: (s: object) => unknown) => sel({ settings: { color_scheme: colorScheme } })),
+}));
+
+import { TerminalView } from "../components/terminal/TerminalView";
+
+/** jsdom reports a zero-sized, unparented box, so `hasLayout()` is false and the
+ *  terminal never opens — which is exactly the unopened state we want to test.
+ *  Flipping this on lets `tryOpen` succeed. */
+function giveLayout(on: boolean) {
+  for (const [prop, value] of [
+    ["clientWidth", on ? 800 : 0],
+    ["clientHeight", on ? 600 : 0],
+  ] as const) {
+    Object.defineProperty(HTMLElement.prototype, prop, { configurable: true, value });
+  }
+  Object.defineProperty(HTMLElement.prototype, "offsetParent", {
+    configurable: true,
+    get() {
+      return on ? document.body : null;
+    },
+  });
+}
+
+describe("TerminalView — theme writes never reach a rendererless xterm", () => {
+  beforeEach(() => {
+    invoke.mockClear();
+    themeWrites.length = 0;
+    liveTerminals.length = 0;
+    colorScheme = undefined;
+    giveLayout(false);
+  });
+
+  it("survives the settings-load theme change while the terminal is still closed", async () => {
+    // The launch shape: tabs mount with no layout box yet (hidden / still tiling),
+    // so nothing opens. This is the state the crash was thrown in.
+    let rerender: (ui: React.ReactElement) => void = () => {};
+    await act(async () => {
+      const r = render(<TerminalView id="p:a" cmd="bash" cwd="/p" visible={false} focused={false} />);
+      rerender = r.rerender;
+    });
+    expect(liveTerminals[0]?.opened).toBe(false);
+
+    // Settings land: `color_scheme` goes undefined → "dark". Before the fix this
+    // threw straight out of the effect on every unopened terminal.
+    colorScheme = "dark";
+    await act(async () => {
+      rerender(<TerminalView id="p:a" cmd="bash" cwd="/p" visible={false} focused={false} />);
+    });
+
+    // Not merely "didn't throw": the write must have been SKIPPED, not swallowed.
+    expect(themeWrites).toHaveLength(0);
+  });
+
+  it("adopts the scheme that landed while it was closed, at open time", async () => {
+    let rerender: (ui: React.ReactElement) => void = () => {};
+    await act(async () => {
+      const r = render(<TerminalView id="p:b" cmd="bash" cwd="/p" visible={false} focused={false} />);
+      rerender = r.rerender;
+    });
+
+    // Scheme arrives while closed (skipped), then the pane gains a layout box.
+    colorScheme = "light";
+    giveLayout(true);
+    await act(async () => {
+      rerender(<TerminalView id="p:b" cmd="bash" cwd="/p" visible focused={false} />);
+    });
+
+    // Skipping the closed write would strand the terminal on its constructed
+    // (undefined-scheme) theme, so opening has to re-apply the current one.
+    expect(liveTerminals[0]?.opened).toBe(true);
+    expect(themeWrites).toHaveLength(1);
+  });
+
+  it("still re-themes a terminal that IS open", async () => {
+    giveLayout(true);
+    colorScheme = "dark";
+    let rerender: (ui: React.ReactElement) => void = () => {};
+    await act(async () => {
+      const r = render(<TerminalView id="p:c" cmd="bash" cwd="/p" visible focused={false} />);
+      rerender = r.rerender;
+    });
+    const afterOpen = themeWrites.length;
+
+    colorScheme = "light_lavender";
+    await act(async () => {
+      rerender(<TerminalView id="p:c" cmd="bash" cwd="/p" visible focused={false} />);
+    });
+    expect(themeWrites.length).toBe(afterOpen + 1);
+  });
+
+  it("disposes cleanly when the spawn effect re-runs, and themes the new terminal", async () => {
+    giveLayout(true);
+    colorScheme = "dark";
+    let rerender: (ui: React.ReactElement) => void = () => {};
+    await act(async () => {
+      const r = render(<TerminalView id="p:d" cmd="bash" cwd="/p" visible focused={false} />);
+      rerender = r.rerender;
+    });
+
+    // A spawn dep changes (an agent-mode flip / container toggle / host switch):
+    // the old terminal is disposed and a new one built. The stale refs must not
+    // survive the swap, or the next theme write lands on the disposed one.
+    colorScheme = "light";
+    await act(async () => {
+      rerender(<TerminalView id="p:d" cmd="zsh" cwd="/p" visible focused={false} />);
+    });
+
+    expect(liveTerminals).toHaveLength(2);
+    expect(liveTerminals[0].disposed).toBe(true);
+    expect(liveTerminals[1].disposed).toBe(false);
+
+    // Neither the ResizeObserver (stubbed) nor the `visible` effect (its deps did
+    // not change) reopens the replacement — the open watchdog does, which is
+    // precisely the case it was added for. Wait it out rather than pretend the
+    // terminal is already open.
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 300));
+    });
+    expect(liveTerminals[1].opened).toBe(true);
+  });
+});
diff --git a/src/__tests__/TexErrors.test.ts b/src/__tests__/TexErrors.test.ts
index d111ef1..007a322 100644
--- a/src/__tests__/TexErrors.test.ts
+++ b/src/__tests__/TexErrors.test.ts
@@ -64,4 +64,19 @@ describe("resolveTexErrorPath", () => {
   it("strips a trailing slash on the build dir", () => {
     expect(resolveTexErrorPath("/home/u/proj/", "./doc.tex")).toBe("/home/u/proj/doc.tex");
   });
+
+  it("resolves against a native Windows build dir, joining with backslashes", () => {
+    expect(resolveTexErrorPath("C:\\Users\\u\\proj", ".\\doc.tex")).toBe(
+      "C:\\Users\\u\\proj\\doc.tex",
+    );
+    expect(resolveTexErrorPath("C:\\Users\\u\\proj", "chapters/intro.tex")).toBe(
+      "C:\\Users\\u\\proj\\chapters\\intro.tex",
+    );
+  });
+
+  it("passes a Windows absolute path through unchanged", () => {
+    expect(resolveTexErrorPath("C:\\Users\\u\\proj", "C:\\texmf\\x.sty")).toBe(
+      "C:\\texmf\\x.sty",
+    );
+  });
 });
diff --git a/src/__tests__/TexLinks.test.ts b/src/__tests__/TexLinks.test.ts
index 300360e..8b0fdef 100644
--- a/src/__tests__/TexLinks.test.ts
+++ b/src/__tests__/TexLinks.test.ts
@@ -119,6 +119,19 @@ describe("resolveTexRef", () => {
   it("returns null for a bare \\includegraphics (extension unknown without probing)", () => {
     expect(resolveTexRef(MAIN, { command: "includegraphics", token: "figs/plot" })).toBeNull();
   });
+
+  it("resolves a token against a native Windows .tex path, joining with backslashes", () => {
+    const win = "C:\\Users\\u\\proj\\paper.tex";
+    expect(resolveTexRef(win, { command: "input", token: "chapters/intro" })).toEqual({
+      path: "C:\\Users\\u\\proj\\chapters\\intro.tex",
+      viewer: "tex",
+      label: "intro.tex",
+    });
+    // `..` segments collapse against the Windows directory too.
+    expect(resolveTexRef(win, { command: "input", token: "../shared/defs" })?.path).toBe(
+      "C:\\Users\\u\\shared\\defs.tex",
+    );
+  });
 });
 
 describe("resolveTexRefAsync (\\includegraphics directory probe)", () => {
diff --git a/src/__tests__/TexSync.test.ts b/src/__tests__/TexSync.test.ts
index 9785abf..e8e6617 100644
--- a/src/__tests__/TexSync.test.ts
+++ b/src/__tests__/TexSync.test.ts
@@ -14,6 +14,7 @@ import {
   refineToWord,
   forwardInputCandidates,
   pickSyncRect,
+  pdfPageMatches,
   sourceColumnFraction,
   type SyncRect,
   type TextItemBox,
@@ -42,6 +43,54 @@ describe("SyncTeX coordinate math", () => {
   });
 });
 
+describe("pdfPageMatches (#71 — Ctrl+F over a PDF page's text)", () => {
+  // A single 11-char run "hello world" laid out 10 big points per character.
+  const oneRun: TextItemBox[] = [{ str: "hello world", x: 0, y: 0, w: 110, h: 10 }];
+
+  it("slices a single run to the matched character span", () => {
+    // "world" is chars 6..11 → x 60, width 50.
+    expect(pdfPageMatches(oneRun, 1, "world", false)).toEqual([
+      [{ page: 1, x: 60, y: 0, w: 50, h: 10 }],
+    ]);
+  });
+
+  it("is case-insensitive by default and case-sensitive on request", () => {
+    const run: TextItemBox[] = [{ str: "Hello", x: 0, y: 0, w: 50, h: 10 }];
+    expect(pdfPageMatches(run, 1, "hello", false)).toEqual([
+      [{ page: 1, x: 0, y: 0, w: 50, h: 10 }],
+    ]);
+    expect(pdfPageMatches(run, 1, "hello", true)).toEqual([]);
+  });
+
+  it("returns one box per run a match straddles", () => {
+    const runs: TextItemBox[] = [
+      { str: "foo", x: 0, y: 0, w: 30, h: 10 },
+      { str: "bar", x: 30, y: 0, w: 30, h: 10 },
+    ];
+    // "ooba" spans the join: "oo" in run 0 (x 10, w 20) + "ba" in run 1 (x 30, w 20).
+    expect(pdfPageMatches(runs, 2, "ooba", false)).toEqual([
+      [
+        { page: 2, x: 10, y: 0, w: 20, h: 10 },
+        { page: 2, x: 30, y: 0, w: 20, h: 10 },
+      ],
+    ]);
+  });
+
+  it("finds every non-overlapping occurrence", () => {
+    const run: TextItemBox[] = [{ str: "aaaa", x: 0, y: 0, w: 40, h: 10 }];
+    const out = pdfPageMatches(run, 1, "aa", false);
+    expect(out).toEqual([
+      [{ page: 1, x: 0, y: 0, w: 20, h: 10 }],
+      [{ page: 1, x: 20, y: 0, w: 20, h: 10 }],
+    ]);
+  });
+
+  it("yields nothing for an empty query or no hit", () => {
+    expect(pdfPageMatches(oneRun, 1, "", false)).toEqual([]);
+    expect(pdfPageMatches(oneRun, 1, "zzz", false)).toEqual([]);
+  });
+});
+
 describe("sourceColumnFraction (caret position along its source line)", () => {
   const text = "hello world foo\nsecond line here\n";
 
@@ -364,6 +413,26 @@ describe("forwardInputCandidates (SyncTeX forward-search path spellings)", () =>
       "./x.tex",
     ]);
   });
+
+  it("handles native Windows paths, emitting forward-slash relatives SyncTeX stored", () => {
+    // The absolute spelling keeps native backslashes; the build-dir-relative and
+    // basename spellings use forward slashes (what TeX writes into the .synctex).
+    expect(
+      forwardInputCandidates("C:\\proj\\paper\\chapters\\intro.tex", "C:\\proj\\paper"),
+    ).toEqual([
+      "C:\\proj\\paper\\chapters\\intro.tex",
+      "chapters/intro.tex",
+      "./chapters/intro.tex",
+      "intro.tex",
+      "./intro.tex",
+    ]);
+    // Trailing separator on the build dir and a file directly in it.
+    expect(forwardInputCandidates("C:\\proj\\paper\\main.tex", "C:\\proj\\paper\\")).toEqual([
+      "C:\\proj\\paper\\main.tex",
+      "main.tex",
+      "./main.tex",
+    ]);
+  });
 });
 
 describe("editorJump store", () => {
diff --git a/src/__tests__/TmuxSessions.test.ts b/src/__tests__/TmuxSessions.test.ts
new file mode 100644
index 0000000..d700f9d
--- /dev/null
+++ b/src/__tests__/TmuxSessions.test.ts
@@ -0,0 +1,150 @@
+/**
+ * Persistent remote sessions (TODO #85) — the frontend half.
+ *
+ * Covers the pure decision/derivation helpers (session-name derivation MUST
+ * mirror the backend `ssh_exec::tmux_session_name`; the default-ON gate; the
+ * shell-only/remote-only persistence rule) and the restore round-trip that proves
+ * a Sessions-view **attach** tab reattaches to the same named session after a
+ * restart (its `tmuxAttach` survives save→load).
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import {
+  newTmuxSessionName,
+  persistSessionsEnabled,
+  shouldPersistTab,
+  shouldPersistLocalTab,
+} from "../lib/tmuxSession";
+import { useTabsStore } from "../stores/tabs";
+import type { RemoteSpec } from "../types";
+
+const remote = (over: Partial<RemoteSpec> = {}): RemoteSpec => ({
+  host: "gpu.example",
+  remote_path: "/home/me/proj",
+  ...over,
+});
+
+describe("newTmuxSessionName", () => {
+  it("mints a tmux-safe (uuid-based) name — no `:`/`.` that tmux treats specially", () => {
+    const name = newTmuxSessionName("p1");
+    expect(name.startsWith("eldrun-")).toBe(true);
+    expect(name).not.toMatch(/[:.\s]/);
+    // Distinct per call, so each shell tab owns its own host session.
+    expect(newTmuxSessionName("p1")).not.toBe(name);
+  });
+
+  it("embeds the owning scope so the Sessions view can filter by project", () => {
+    expect(newTmuxSessionName("proj-1")).toMatch(/^eldrun-proj-1--/);
+    // A scope with tmux-unsafe characters is sanitized, never dropped or thrown.
+    expect(newTmuxSessionName("weird:scope.id")).toMatch(/^eldrun-weird_scope_id--/);
+  });
+});
+
+describe("persistSessionsEnabled — default ON", () => {
+  it("is on for a remote project unless explicitly opted out", () => {
+    expect(persistSessionsEnabled(remote())).toBe(true); // undefined ⇒ on
+    expect(persistSessionsEnabled(remote({ persist_sessions: true }))).toBe(true);
+    expect(persistSessionsEnabled(remote({ persist_sessions: false }))).toBe(false);
+    // No remote project ⇒ nothing to persist.
+    expect(persistSessionsEnabled(undefined)).toBe(false);
+    expect(persistSessionsEnabled(null)).toBe(false);
+  });
+});
+
+describe("shouldPersistTab — shell + remote host + enabled", () => {
+  it("persists a remote shell tab, but never an agent, a local tab, or an opted-out project", () => {
+    expect(shouldPersistTab("shell", "primary", remote())).toBe(true);
+    expect(shouldPersistTab("shell", "h1", remote())).toBe(true); // a worker host too
+    // Agent tabs resume via their own session — excluded.
+    expect(shouldPersistTab("agent", "primary", remote())).toBe(false);
+    expect(shouldPersistTab("local_agent", "primary", remote())).toBe(false);
+    // A local-running tab (hostId null) has no host session.
+    expect(shouldPersistTab("shell", null, remote())).toBe(false);
+    // Opted out.
+    expect(shouldPersistTab("shell", "primary", remote({ persist_sessions: false }))).toBe(false);
+  });
+});
+
+describe("shouldPersistLocalTab — local shell tabs on Unix", () => {
+  it("persists a local project shell tab (non-root) when enabled; excludes agents/root/disabled", () => {
+    expect(shouldPersistLocalTab("shell", "p1", true, true)).toBe(true);
+    // A remote project's local (mirror) tab counts too (localRunning=true).
+    expect(shouldPersistLocalTab("shell", "p1", true, true)).toBe(true);
+    // Agents never persist locally either.
+    expect(shouldPersistLocalTab("agent", "p1", true, true)).toBe(false);
+    // The root control terminal is excluded.
+    expect(shouldPersistLocalTab("shell", "root", true, true)).toBe(false);
+    // A tab actually running on a remote host is not a local session.
+    expect(shouldPersistLocalTab("shell", "p1", false, true)).toBe(false);
+    // Disabled (setting off, or Windows folded into localEnabled) → off.
+    expect(shouldPersistLocalTab("shell", "p1", true, false)).toBe(false);
+  });
+});
+
+describe("attach tab restore", () => {
+  beforeEach(() => {
+    useTabsStore.setState({
+      tabsByScope: {},
+      layoutByScope: {},
+      focusedGroupByScope: {},
+      scope: "p",
+    } as never);
+  });
+
+  it("preserves tmuxAttach onto the rebuilt shell tab so it reattaches to the same session", () => {
+    useTabsStore.getState().loadFromLayout(
+      [
+        {
+          key: "shell-7",
+          label: "train",
+          cmd: "",
+          cwd: "/p",
+          kind: "shell",
+          location: "remote",
+          tmuxAttach: "train",
+        },
+      ],
+      "/p",
+      "p",
+    );
+    const tabs = useTabsStore.getState().tabsByScope["p"];
+    expect(tabs).toHaveLength(1);
+    expect(tabs[0].tmuxAttach).toBe("train");
+    expect(tabs[0].kind).toBe("shell");
+  });
+
+  it("keeps the SAME tmuxSession across a restart even though the key is regenerated (reattach, not fork)", () => {
+    useTabsStore.getState().loadFromLayout(
+      [
+        {
+          key: "shell-3", // saved key — regenerated on restore
+          label: "run",
+          cmd: "",
+          cwd: "/p",
+          kind: "shell",
+          location: "remote",
+          tmuxSession: "eldrun-fixed-uuid",
+        },
+      ],
+      "/p",
+      "p",
+    );
+    const tab = useTabsStore.getState().tabsByScope["p"][0];
+    // The key changed (fresh mint) but the session name is stable → the tab
+    // reattaches to the SAME host session rather than spawning a second one.
+    expect(tab.key).not.toBe("shell-3");
+    expect(tab.tmuxSession).toBe("eldrun-fixed-uuid");
+  });
+
+  it("mints a stable tmuxSession for a shell tab persisted before the feature existed", () => {
+    useTabsStore.getState().loadFromLayout(
+      [{ key: "shell-1", label: "sh", cmd: "", cwd: "/p", kind: "shell" }],
+      "/p",
+      "p",
+    );
+    const tab = useTabsStore.getState().tabsByScope["p"][0];
+    expect(tab.tmuxSession).toMatch(/^eldrun-/);
+  });
+});
diff --git a/src/__tests__/TourSelection.test.ts b/src/__tests__/TourSelection.test.ts
new file mode 100644
index 0000000..59c49b3
--- /dev/null
+++ b/src/__tests__/TourSelection.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import {
+  TOUR_STEPS,
+  isStepEligible,
+  nextEligibleIndex,
+  prevEligibleIndex,
+  type TourCtx,
+} from "../lib/tour";
+
+const empty: TourCtx = { projectCount: 0, activeId: null };
+const active: TourCtx = { projectCount: 2, activeId: "p1" };
+
+const idx = (id: string) => TOUR_STEPS.findIndex((s) => s.id === id);
+
+describe("tour step eligibility", () => {
+  it("hides the switch-projects step on an empty workspace", () => {
+    const step = TOUR_STEPS[idx("switch-projects")];
+    expect(isStepEligible(step, empty)).toBe(false);
+    expect(isStepEligible(step, active)).toBe(true);
+  });
+
+  it("treats steps without a `when` predicate as always eligible", () => {
+    const step = TOUR_STEPS[idx("root-terminal")];
+    expect(isStepEligible(step, empty)).toBe(true);
+    expect(isStepEligible(step, active)).toBe(true);
+  });
+});
+
+describe("nextEligibleIndex", () => {
+  it("starts at the first step when everything is eligible", () => {
+    expect(nextEligibleIndex(TOUR_STEPS, active, 0)).toBe(0);
+  });
+
+  it("skips an ineligible step (no project ⇒ no switch-projects)", () => {
+    const from = idx("switch-projects") + 1;
+    expect(nextEligibleIndex(TOUR_STEPS, empty, from)).toBe(idx("add-tab"));
+  });
+
+  it("returns steps.length when it runs off the end (finish signal)", () => {
+    expect(nextEligibleIndex(TOUR_STEPS, active, TOUR_STEPS.length)).toBe(TOUR_STEPS.length);
+  });
+});
+
+describe("prevEligibleIndex", () => {
+  it("walks back over an ineligible step", () => {
+    const from = idx("add-tab") - 1; // sits on switch-projects
+    expect(prevEligibleIndex(TOUR_STEPS, empty, from)).toBe(idx("remote-projects"));
+  });
+
+  it("returns -1 before the first step", () => {
+    expect(prevEligibleIndex(TOUR_STEPS, active, -1)).toBe(-1);
+  });
+});
diff --git a/src/__tests__/UsageMetrics.test.ts b/src/__tests__/UsageMetrics.test.ts
new file mode 100644
index 0000000..4112822
--- /dev/null
+++ b/src/__tests__/UsageMetrics.test.ts
@@ -0,0 +1,108 @@
+/**
+ * Locks how a tab is classified for the usage recap.
+ *
+ * "By model" is the whole point of the agent stats, and a local model is not a
+ * field on the tab — it is carried in the env Eldrun spawns it with. The trap is
+ * that a local model driven through `vibe` still has `cmd: "vibe"`, so a
+ * cmd-only classification would file every local model under "Mistral".
+ */
+import { describe, expect, it } from "vitest";
+import { METRIC, agentLabel, agentMetricLeaf, agentPromptLeaf, sub } from "../lib/usageMetrics";
+
+describe("agentMetricLeaf", () => {
+  it("files a cloud agent under its command", () => {
+    expect(agentMetricLeaf({ kind: "agent", cmd: "claude" })).toEqual({
+      prefix: METRIC.AGENT_TAB,
+      leaf: "claude",
+    });
+    expect(agentMetricLeaf({ kind: "agent", cmd: "codex" })).toEqual({
+      prefix: METRIC.AGENT_TAB,
+      leaf: "codex",
+    });
+  });
+
+  it("files a local agent under its MODEL, not its driving command", () => {
+    // The `vibe` route: cmd is "vibe" for every local model, so the model has to
+    // come from the env or they would all collapse into one bucket.
+    expect(
+      agentMetricLeaf({
+        kind: "local_agent",
+        cmd: "vibe",
+        env: { ELDRUN_LOCAL_MODEL: "qwen3:8b", VIBE_ACTIVE_MODEL: "eldrun-qwen3" },
+      }),
+    ).toEqual({ prefix: METRIC.AGENT_TAB_LOCAL, leaf: "qwen3:8b" });
+  });
+
+  it("prefers the model the user picked over the resolved vibe alias", () => {
+    const id = agentMetricLeaf({
+      kind: "local_agent",
+      cmd: "vibe",
+      env: { ELDRUN_LOCAL_MODEL: "llama3.1:8b", VIBE_ACTIVE_MODEL: "eldrun-alias" },
+    });
+    expect(id?.leaf).toBe("llama3.1:8b");
+  });
+
+  it("falls back to the vibe alias when only that is present", () => {
+    // Tabs restored from a layout written by an older Eldrun have no
+    // ELDRUN_LOCAL_MODEL; naming them by the alias beats losing them.
+    expect(
+      agentMetricLeaf({
+        kind: "local_agent",
+        cmd: "vibe",
+        env: { VIBE_ACTIVE_MODEL: "eldrun-qwen3" },
+      }),
+    ).toEqual({ prefix: METRIC.AGENT_TAB_LOCAL, leaf: "eldrun-qwen3" });
+  });
+
+  it("falls back to the command for a local agent with no model recorded", () => {
+    // Rather than filing it under an empty key.
+    expect(agentMetricLeaf({ kind: "local_agent", cmd: "vibe", env: {} })).toEqual({
+      prefix: METRIC.AGENT_TAB,
+      leaf: "vibe",
+    });
+  });
+
+  it("classifies non-agent tabs as nothing", () => {
+    expect(agentMetricLeaf({ kind: "shell", cmd: "bash" })).toBeNull();
+    expect(agentMetricLeaf({ kind: "files", cmd: "__eldrun_files__" })).toBeNull();
+    expect(agentMetricLeaf({ kind: "network", cmd: "__eldrun_network__" })).toBeNull();
+  });
+});
+
+describe("agentPromptLeaf", () => {
+  it("namespaces a local model so it cannot collide with a cloud agent", () => {
+    // Both prompts and "tabs used" key off this leaf; without the prefix a local
+    // model named like an agent would merge with it.
+    expect(
+      agentPromptLeaf({ kind: "local_agent", cmd: "vibe", env: { ELDRUN_LOCAL_MODEL: "qwen3:8b" } }),
+    ).toBe("local.qwen3:8b");
+    expect(agentPromptLeaf({ kind: "agent", cmd: "claude" })).toBe("claude");
+  });
+
+  it("is null for a shell tab, so shell input is counted as a command not a prompt", () => {
+    expect(agentPromptLeaf({ kind: "shell", cmd: "bash" })).toBeNull();
+  });
+});
+
+describe("agentLabel", () => {
+  it("gives known agents their product names", () => {
+    expect(agentLabel("claude")).toBe("Claude");
+    expect(agentLabel("cursor-agent")).toBe("Cursor");
+  });
+
+  it("shows a local model by its bare name", () => {
+    expect(agentLabel("local.qwen3:8b")).toBe("qwen3:8b");
+  });
+
+  it("renders an unknown agent as-is rather than dropping it", () => {
+    // The key space is open — a new agent must still show up in the recap.
+    expect(agentLabel("some-new-agent")).toBe("some-new-agent");
+  });
+});
+
+describe("sub", () => {
+  it("composes dotted metric keys", () => {
+    expect(sub(METRIC.AGENT_PROMPT, "claude")).toBe("agent.prompt.claude");
+    expect(sub(METRIC.AGENT_ACTIVE, "local.qwen3:8b")).toBe("agent.active.local.qwen3:8b");
+  });
+});
diff --git a/src/__tests__/UsageRollup.test.ts b/src/__tests__/UsageRollup.test.ts
new file mode 100644
index 0000000..b857074
--- /dev/null
+++ b/src/__tests__/UsageRollup.test.ts
@@ -0,0 +1,165 @@
+/**
+ * Locks the bucket → calendar-window folding behind the usage recap.
+ *
+ * The store buckets by UTC ("YYYY-MM-DD" / "YYYY-MM-DDTHH"), so every window has
+ * to be computed in UTC too — a local-time fold would silently misfile the hours
+ * around midnight. The ISO-week boundary is the case that breaks naive
+ * implementations (a Sunday belongs to the week that started the *previous*
+ * Monday), and `breakdown`'s namespace exclusion is what keeps a local model from
+ * being counted twice.
+ */
+import { describe, expect, it } from "vitest";
+import {
+  addCounters,
+  breakdown,
+  countersForPeriod,
+  dayKey,
+  hourKey,
+  isoWeekKeys,
+  periodKeys,
+  sumCounters,
+  totalOf,
+  type Counters,
+} from "../lib/usageRollup";
+
+// 2026-07-13 is a Monday; 2026-07-19 the Sunday that closes the same ISO week.
+const MONDAY = Date.UTC(2026, 6, 13, 12, 0, 0);
+const SUNDAY = Date.UTC(2026, 6, 19, 23, 30, 0);
+
+describe("bucket keys", () => {
+  it("derives UTC day and hour keys", () => {
+    expect(dayKey(MONDAY)).toBe("2026-07-13");
+    expect(hourKey(MONDAY)).toBe("2026-07-13T12");
+  });
+
+  it("keeps the day key as the hour key's prefix", () => {
+    // The backend folds an hour bucket into a day by taking its first ten chars;
+    // if these two ever disagreed every counter would be misfiled.
+    expect(hourKey(MONDAY).slice(0, 10)).toBe(dayKey(MONDAY));
+  });
+});
+
+describe("isoWeekKeys", () => {
+  it("returns Monday through Sunday for a mid-week day", () => {
+    expect(isoWeekKeys(MONDAY)).toEqual([
+      "2026-07-13", "2026-07-14", "2026-07-15", "2026-07-16",
+      "2026-07-17", "2026-07-18", "2026-07-19",
+    ]);
+  });
+
+  it("puts a Sunday in the week that began the previous Monday", () => {
+    // The trap: getUTCDay() is 0 on Sunday, so a naive `now - day*86400e3` would
+    // roll Sunday forward into the NEXT week and report an empty one.
+    expect(isoWeekKeys(SUNDAY)[0]).toBe("2026-07-13");
+    expect(isoWeekKeys(SUNDAY)).toEqual(isoWeekKeys(MONDAY));
+  });
+});
+
+describe("periodKeys", () => {
+  it("day is just that date", () => {
+    expect(periodKeys("day", MONDAY)).toEqual(["2026-07-13"]);
+  });
+
+  it("week is the calendar ISO week, not a rolling seven days", () => {
+    expect(periodKeys("week", MONDAY)).toEqual(isoWeekKeys(MONDAY));
+  });
+
+  it("month spans every day of the calendar month", () => {
+    const keys = periodKeys("month", MONDAY);
+    expect(keys).toHaveLength(31); // July
+    expect(keys[0]).toBe("2026-07-01");
+    expect(keys[30]).toBe("2026-07-31");
+  });
+
+  it("month handles a short month without spilling into the next", () => {
+    const feb = Date.UTC(2026, 1, 15);
+    const keys = periodKeys("month", feb);
+    expect(keys).toHaveLength(28); // 2026 is not a leap year
+    expect(keys[27]).toBe("2026-02-28");
+  });
+
+  it("month handles a leap February", () => {
+    expect(periodKeys("month", Date.UTC(2024, 1, 15))).toHaveLength(29);
+  });
+});
+
+describe("counter folding", () => {
+  const days: Record<string, Counters> = {
+    "2026-07-13": { "agent.prompt.claude": 10, "shell.command": 4 },
+    "2026-07-15": { "agent.prompt.claude": 5, "agent.prompt.codex": 2 },
+    // Previous month — must never leak into July's windows.
+    "2026-06-30": { "agent.prompt.claude": 999 },
+  };
+
+  it("sums the buckets of a period and ignores the rest", () => {
+    const week = countersForPeriod({ days }, "week", MONDAY);
+    expect(week["agent.prompt.claude"]).toBe(15);
+    expect(week["agent.prompt.codex"]).toBe(2);
+    expect(week["shell.command"]).toBe(4);
+  });
+
+  it("does not leak an adjacent month into the month window", () => {
+    const month = countersForPeriod({ days }, "month", MONDAY);
+    expect(month["agent.prompt.claude"]).toBe(15); // not 1014
+  });
+
+  it("a day window sees only that day", () => {
+    expect(countersForPeriod({ days }, "day", MONDAY)).toEqual({
+      "agent.prompt.claude": 10,
+      "shell.command": 4,
+    });
+  });
+
+  it("absent buckets contribute nothing rather than throwing", () => {
+    expect(sumCounters(undefined, ["2026-07-13"])).toEqual({});
+    expect(sumCounters(days, ["1999-01-01"])).toEqual({});
+  });
+
+  it("addCounters merges in place", () => {
+    const into: Counters = { a: 1 };
+    addCounters(into, { a: 2, b: 3 });
+    addCounters(into, undefined);
+    expect(into).toEqual({ a: 3, b: 3 });
+  });
+});
+
+describe("breakdown", () => {
+  const counters: Counters = {
+    "agent.tab.claude": 2,
+    "agent.tab.codex": 1,
+    "agent.tab.local.qwen3:8b": 3,
+    "agent.tab.local.llama3.1:8b": 1,
+    "shell.command": 40,
+  };
+
+  it("splits an open-ended namespace by its leaf", () => {
+    expect(breakdown(counters, "agent.tab.local")).toEqual({
+      "qwen3:8b": 3,
+      "llama3.1:8b": 1,
+    });
+  });
+
+  it("keeps a model name containing dots intact", () => {
+    // A leaf may legitimately contain dots, so "does the leaf have a dot" is NOT
+    // a usable test for "is this a deeper namespace".
+    expect(breakdown(counters, "agent.tab.local")["llama3.1:8b"]).toBe(1);
+  });
+
+  it("excludes a deeper namespace so local models are not double-counted", () => {
+    // Without the exclusion, agent.tab would also fold in every agent.tab.local.*
+    // key — reporting each local tab both as its model and as an agent.
+    expect(breakdown(counters, "agent.tab", ["agent.tab.local"])).toEqual({
+      claude: 2,
+      codex: 1,
+    });
+  });
+
+  it("ignores keys outside the prefix", () => {
+    expect(breakdown(counters, "agent.tab", ["agent.tab.local"])["shell.command"]).toBeUndefined();
+  });
+
+  it("totalOf sums a breakdown", () => {
+    expect(totalOf(breakdown(counters, "agent.tab", ["agent.tab.local"]))).toBe(3);
+    expect(totalOf({})).toBe(0);
+  });
+});
diff --git a/src/__tests__/UsageStore.test.ts b/src/__tests__/UsageStore.test.ts
new file mode 100644
index 0000000..3679340
--- /dev/null
+++ b/src/__tests__/UsageStore.test.ts
@@ -0,0 +1,141 @@
+/**
+ * Locks the usage store's write path.
+ *
+ * Counters are accumulated in memory and flushed in batches, so the invariants
+ * that matter are: one `usage_bump` per scope (not per event), fractional seconds
+ * survive as whole seconds (the backend store is u64-typed — a float would fail
+ * to deserialize and lose the batch), a drained batch is never re-sent, and a tab
+ * counts as "used" once a day however often it is prompted.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import {
+  _pendingUsageForTest,
+  _resetUsageForTest,
+  bumpUsage,
+  flushUsage,
+  markAgentActive,
+} from "../stores/usage";
+
+const invokeMock = vi.mocked(invoke);
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockResolvedValue(undefined as never);
+  _resetUsageForTest();
+});
+
+/** The metrics payload `usage_bump` was called with for a scope. */
+function payloadFor(scope: string): Record<string, number> | undefined {
+  const call = invokeMock.mock.calls.find(
+    (c) => c[0] === "usage_bump" && (c[1] as { projectId: string }).projectId === scope,
+  );
+  return call ? (call[1] as { metrics: Record<string, number> }).metrics : undefined;
+}
+
+describe("bumpUsage", () => {
+  it("accumulates repeated bumps rather than sending each one", () => {
+    bumpUsage("p1", "shell.command");
+    bumpUsage("p1", "shell.command");
+    bumpUsage("p1", "shell.command");
+    expect(_pendingUsageForTest()["p1"]["shell.command"]).toBe(3);
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("keeps scopes separate", () => {
+    bumpUsage("p1", "tab.opened");
+    bumpUsage("p2", "tab.opened");
+    expect(_pendingUsageForTest()["p1"]["tab.opened"]).toBe(1);
+    expect(_pendingUsageForTest()["p2"]["tab.opened"]).toBe(1);
+  });
+
+  it("ignores non-positive and non-finite amounts", () => {
+    bumpUsage("p1", "agent.worked_s", 0);
+    bumpUsage("p1", "agent.worked_s", -5);
+    bumpUsage("p1", "agent.worked_s", NaN);
+    bumpUsage("", "tab.opened");
+    expect(_pendingUsageForTest()).toEqual({});
+  });
+});
+
+describe("flushUsage", () => {
+  it("sends one usage_bump per scope", async () => {
+    bumpUsage("p1", "shell.command", 2);
+    bumpUsage("p1", "tab.opened");
+    bumpUsage("p2", "tab.opened");
+    await flushUsage();
+
+    const bumps = invokeMock.mock.calls.filter((c) => c[0] === "usage_bump");
+    expect(bumps).toHaveLength(2);
+    expect(payloadFor("p1")).toEqual({ "shell.command": 2, "tab.opened": 1 });
+    expect(payloadFor("p2")).toEqual({ "tab.opened": 1 });
+  });
+
+  it("clears the batch so a second flush re-sends nothing", async () => {
+    bumpUsage("p1", "tab.opened");
+    await flushUsage();
+    invokeMock.mockClear();
+
+    await flushUsage();
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when there is nothing pending", async () => {
+    await flushUsage();
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("rounds fractional seconds to integers", async () => {
+    // Agent working time arrives as a sub-second slice per activity tick. The
+    // backend counter is u64: a float would fail to deserialize and drop the
+    // whole batch, and flooring each slice on arrival would round every one to 0.
+    bumpUsage("p1", "agent.worked_s", 0.4);
+    bumpUsage("p1", "agent.worked_s", 0.4);
+    bumpUsage("p1", "agent.worked_s", 0.4);
+    await flushUsage();
+
+    const metrics = payloadFor("p1")!;
+    expect(metrics["agent.worked_s"]).toBe(1); // 1.2 → 1
+    expect(Number.isInteger(metrics["agent.worked_s"])).toBe(true);
+  });
+
+  it("drops a counter that rounds to zero instead of sending a no-op", async () => {
+    bumpUsage("p1", "agent.worked_s", 0.2);
+    bumpUsage("p1", "tab.opened", 1);
+    await flushUsage();
+
+    const metrics = payloadFor("p1")!;
+    expect(metrics["agent.worked_s"]).toBeUndefined();
+    expect(metrics["tab.opened"]).toBe(1);
+  });
+
+  it("does not send a scope whose every counter rounded away", async () => {
+    bumpUsage("p1", "agent.worked_s", 0.1);
+    await flushUsage();
+    expect(invokeMock).not.toHaveBeenCalled();
+  });
+
+  it("survives a failing invoke without throwing", async () => {
+    invokeMock.mockRejectedValue(new Error("backend down") as never);
+    bumpUsage("p1", "tab.opened");
+    await expect(flushUsage()).resolves.toBeUndefined();
+  });
+});
+
+describe("markAgentActive", () => {
+  it("counts a tab once however many times it is prompted", () => {
+    expect(markAgentActive("p1", "p1:agent-1", "agent.active.claude")).toBe(true);
+    expect(markAgentActive("p1", "p1:agent-1", "agent.active.claude")).toBe(false);
+    expect(markAgentActive("p1", "p1:agent-1", "agent.active.claude")).toBe(false);
+    expect(_pendingUsageForTest()["p1"]["agent.active.claude"]).toBe(1);
+  });
+
+  it("counts two different tabs separately", () => {
+    markAgentActive("p1", "p1:agent-1", "agent.active.claude");
+    markAgentActive("p1", "p1:agent-2", "agent.active.claude");
+    expect(_pendingUsageForTest()["p1"]["agent.active.claude"]).toBe(2);
+  });
+});
diff --git a/src/__tests__/UsageTabCounting.test.ts b/src/__tests__/UsageTabCounting.test.ts
new file mode 100644
index 0000000..d1b8041
--- /dev/null
+++ b/src/__tests__/UsageTabCounting.test.ts
@@ -0,0 +1,115 @@
+/**
+ * Locks which tabs the usage recap counts as "opened".
+ *
+ * Counting lives in `addTab` rather than at the backend's `pty_spawn` because the
+ * spawn fires again for every resumable agent tab respawned on relaunch — so
+ * counting there would report a fresh "agent tab opened" each morning for tabs
+ * opened days ago. That makes two things load-bearing and easy to regress:
+ *
+ *  - `loadFromLayout` (restore) must NOT go through `addTab`.
+ *  - the root scope's auto-seeded 3D-blob tab must opt out — Eldrun opened it,
+ *    not the user.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+
+import { useTabsStore, BLOB_TAB_CMD } from "../stores/tabs";
+import { _pendingUsageForTest, _resetUsageForTest } from "../stores/usage";
+import { METRIC } from "../lib/usageMetrics";
+
+function counters(scope: string): Record<string, number> {
+  return _pendingUsageForTest()[scope] ?? {};
+}
+
+beforeEach(() => {
+  _resetUsageForTest();
+  useTabsStore.setState({
+    scope: "p1",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+  });
+});
+
+describe("agent tab opens", () => {
+  it("counts a cloud agent tab under its command", () => {
+    useTabsStore.getState().addTab({ label: "Claude", cmd: "claude", cwd: "/p", kind: "agent" });
+
+    expect(counters("p1")[`${METRIC.AGENT_TAB}.claude`]).toBe(1);
+    expect(counters("p1")[METRIC.TAB_OPENED]).toBe(1);
+  });
+
+  it("counts a local agent tab under its MODEL", () => {
+    useTabsStore.getState().addTab({
+      label: "qwen3:8b",
+      cmd: "vibe",
+      cwd: "/p",
+      kind: "local_agent",
+      env: { ELDRUN_LOCAL_MODEL: "qwen3:8b" },
+    });
+
+    expect(counters("p1")[`${METRIC.AGENT_TAB_LOCAL}.qwen3:8b`]).toBe(1);
+    // ...and NOT as a "vibe" agent, which is merely the driver.
+    expect(counters("p1")[`${METRIC.AGENT_TAB}.vibe`]).toBeUndefined();
+  });
+
+  it("counts a shell tab as a tab but not as an agent", () => {
+    useTabsStore.getState().addTab({ label: "Shell", cmd: "bash", cwd: "/p", kind: "shell" });
+
+    expect(counters("p1")[METRIC.TAB_OPENED]).toBe(1);
+    expect(counters("p1")[`${METRIC.AGENT_TAB}.bash`]).toBeUndefined();
+  });
+
+  it("attributes a tab added to another scope to THAT scope", () => {
+    useTabsStore.getState().addTabToScope("p2", {
+      label: "Codex", cmd: "codex", cwd: "/p2", kind: "agent",
+    });
+
+    expect(counters("p2")[`${METRIC.AGENT_TAB}.codex`]).toBe(1);
+    expect(counters("p1")).toEqual({});
+  });
+});
+
+describe("tabs Eldrun opens by itself", () => {
+  it("does not count the auto-seeded root 3D-blob tab", () => {
+    useTabsStore.setState({ scope: "root" });
+    useTabsStore.getState().addTab(
+      { label: "Projects", cmd: BLOB_TAB_CMD, cwd: "", kind: "projects3d" },
+      { seeded: true },
+    );
+
+    // The user did not open this; the recap must not claim they did.
+    expect(counters("root")).toEqual({});
+  });
+});
+
+describe("restore", () => {
+  it("does not count tabs restored from a saved layout", () => {
+    // The whole reason counting lives in addTab: a restored Claude tab was opened
+    // days ago, and must not read as a fresh agent tab every launch.
+    useTabsStore.getState().loadFromLayout(
+      [
+        { key: "agent-1", label: "Claude", cmd: "claude", cwd: "/p", kind: "agent", sessionId: "s1" },
+        { key: "shell-1", label: "Shell", cmd: "bash", cwd: "/p", kind: "shell" },
+      ],
+      "/p",
+      "p1",
+    );
+
+    expect(useTabsStore.getState().tabsByScope["p1"]).toHaveLength(2);
+    expect(counters("p1")).toEqual({});
+  });
+});
+
+describe("tab closes", () => {
+  it("counts a close", () => {
+    const tab = useTabsStore.getState().addTab({
+      label: "Shell", cmd: "bash", cwd: "/p", kind: "shell",
+    });
+    useTabsStore.getState().removeTab(tab.key);
+
+    expect(counters("p1")[METRIC.TAB_CLOSED]).toBe(1);
+  });
+});
diff --git a/src/__tests__/ViewerFormat.test.ts b/src/__tests__/ViewerFormat.test.ts
new file mode 100644
index 0000000..2fcbaea
--- /dev/null
+++ b/src/__tests__/ViewerFormat.test.ts
@@ -0,0 +1,136 @@
+/**
+ * Tests for the per-format viewer helpers (Group K extras):
+ *  - capability derivation from a path (format lang, validation lang, preview),
+ *  - in-process JSON prettify,
+ *  - the Markdown toolbar transforms (toggle inline, cycle heading, line prefix,
+ *    link) and table-of-contents generation,
+ *  - the sandboxed CSS preview document.
+ * All pure — no React/Tauri needed.
+ */
+import { describe, it, expect } from "vitest";
+import {
+  formatLangForPath,
+  isInProcessJson,
+  validationLangForPath,
+  previewKindForPath,
+  formatJsonText,
+  buildPreviewDoc,
+} from "../lib/viewers/format";
+import {
+  toggleInline,
+  cycleHeading,
+  toggleLinePrefix,
+  makeLink,
+  generateToc,
+  slugify,
+} from "../lib/viewers/markdownEdit";
+
+describe("format capabilities by path", () => {
+  it("maps extensions to a backend formatter lang", () => {
+    expect(formatLangForPath("/a/style.css")).toBe("css");
+    expect(formatLangForPath("/a/app.tsx")).toBe("tsx");
+    expect(formatLangForPath("/a/main.py")).toBe("python");
+    expect(formatLangForPath("/a/mod.rs")).toBe("rust");
+    expect(formatLangForPath("/a/notes.txt")).toBeNull();
+  });
+
+  it("treats .json as in-process (no external formatter)", () => {
+    expect(isInProcessJson("/a/data.json")).toBe(true);
+    expect(formatLangForPath("/a/data.json")).toBeNull();
+    expect(isInProcessJson("/a/data.yaml")).toBe(false);
+  });
+
+  it("picks the validation language", () => {
+    expect(validationLangForPath("/a/data.json")).toBe("json");
+    expect(validationLangForPath("/a/conf.yaml")).toBe("yaml");
+    expect(validationLangForPath("/a/conf.yml")).toBe("yaml");
+    expect(validationLangForPath("/a/main.rs")).toBeNull();
+  });
+
+  it("picks the preview kind", () => {
+    expect(previewKindForPath("/a/page.html")).toBe("html");
+    expect(previewKindForPath("/a/logo.svg")).toBe("svg");
+    expect(previewKindForPath("/a/style.css")).toBe("css");
+    // SCSS/LESS need compilation, so they are edit-only (no preview).
+    expect(previewKindForPath("/a/style.scss")).toBeNull();
+    expect(previewKindForPath("/a/main.py")).toBeNull();
+  });
+});
+
+describe("formatJsonText", () => {
+  it("pretty-prints valid JSON with a trailing newline", () => {
+    const res = formatJsonText('{"b":1,"a":2}');
+    expect(res.ok).toBe(true);
+    if (res.ok) expect(res.text).toBe('{\n  "b": 1,\n  "a": 2\n}\n');
+  });
+
+  it("reports an error for invalid JSON", () => {
+    const res = formatJsonText("{ not json }");
+    expect(res.ok).toBe(false);
+  });
+});
+
+describe("buildPreviewDoc", () => {
+  it("returns HTML/SVG source verbatim", () => {
+    expect(buildPreviewDoc("html", "<h1>hi</h1>")).toBe("<h1>hi</h1>");
+    expect(buildPreviewDoc("svg", "<svg/>")).toBe("<svg/>");
+  });
+
+  it("injects CSS into a sample document", () => {
+    const doc = buildPreviewDoc("css", "h1 { color: red }");
+    expect(doc).toContain("<style>");
+    expect(doc).toContain("h1 { color: red }");
+    expect(doc).toContain("<h1>Heading 1</h1>");
+  });
+});
+
+describe("markdown toolbar transforms", () => {
+  it("wraps and unwraps an inline marker", () => {
+    const wrapped = toggleInline("ab", 0, 2, "**");
+    expect(wrapped.value).toBe("**ab**");
+    expect(wrapped.value.slice(wrapped.selStart, wrapped.selEnd)).toBe("ab");
+    // Toggling again (markers just outside the selection) removes them.
+    const back = toggleInline(wrapped.value, wrapped.selStart, wrapped.selEnd, "**");
+    expect(back.value).toBe("ab");
+  });
+
+  it("cycles a heading none → # → ## → ### → none", () => {
+    let v = "Title";
+    v = cycleHeading(v, 0).value; expect(v).toBe("# Title");
+    v = cycleHeading(v, 0).value; expect(v).toBe("## Title");
+    v = cycleHeading(v, 0).value; expect(v).toBe("### Title");
+    v = cycleHeading(v, 0).value; expect(v).toBe("Title");
+  });
+
+  it("toggles a bullet prefix across selected lines", () => {
+    const v = "one\ntwo";
+    const on = toggleLinePrefix(v, 0, v.length, "- ");
+    expect(on.value).toBe("- one\n- two");
+    const off = toggleLinePrefix(on.value, 0, on.value.length, "- ");
+    expect(off.value).toBe("one\ntwo");
+  });
+
+  it("makes a link from a selection and selects the url placeholder", () => {
+    const r = makeLink("see here", 4, 8); // "here"
+    expect(r.value).toBe("see [here](url)");
+    expect(r.value.slice(r.selStart, r.selEnd)).toBe("url");
+  });
+});
+
+describe("table of contents", () => {
+  it("nests headings by level and links to slugs", () => {
+    const md = "# A\n## B C\n### D\n# A\n";
+    expect(generateToc(md)).toBe(
+      ["- [A](#a)", "  - [B C](#b-c)", "    - [D](#d)", "- [A](#a-1)"].join("\n"),
+    );
+  });
+
+  it("ignores headings inside fenced code blocks", () => {
+    const md = "# Real\n```\n# Not a heading\n```\n";
+    expect(generateToc(md)).toBe("- [Real](#real)");
+  });
+
+  it("slugifies titles GitHub-style", () => {
+    expect(slugify("Hello, World!")).toBe("hello-world");
+  });
+});
diff --git a/src/__tests__/ViewerWidthReflow.test.tsx b/src/__tests__/ViewerWidthReflow.test.tsx
new file mode 100644
index 0000000..012badb
--- /dev/null
+++ b/src/__tests__/ViewerWidthReflow.test.tsx
@@ -0,0 +1,151 @@
+/**
+ * Regression test for "file viewers don't adapt to window width" on WebKitGTK.
+ *
+ * In the main window each pane is absolutely positioned at a JS-MEASURED pixel
+ * width/height (CenterPanel.measure() → groupRects → the `.center-pane` inline
+ * style). The file viewers (markdown/text/PDF) are sized off that pane box, so if
+ * the measurement never re-runs when the OS window shrinks, the pane keeps its
+ * old (wider) width and the text never reflows.
+ *
+ * measure() is wired to a ResizeObserver on the panel, but older WebKitGTK builds
+ * don't deliver ResizeObserver/'resize' for OS-level window resizes. The fix has
+ * AppShell bridge Tauri's reliable onResized into a DOM 'resize' event and has
+ * CenterPanel re-measure on it.
+ *
+ * jsdom has no layout engine and never fires ResizeObserver, so this test models
+ * exactly that environment: it stubs getBoundingClientRect (so measure() yields a
+ * real rect), shrinks the stubbed body, dispatches a `window.resize`, and asserts
+ * the active pane's measured width follows. Without the window-resize listener the
+ * pane stays at its stale width — which is the user-visible bug.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { act, render, cleanup } from "@testing-library/react";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve(undefined)) }));
+
+// CenterPanel installs detached-drag listeners and reads the window origin on
+// mount; none of that is exercised here, so stub the Tauri window/event APIs.
+vi.mock("@tauri-apps/api/event", () => ({
+  listen: vi.fn(() => Promise.resolve(() => {})),
+  emit: vi.fn(() => Promise.resolve()),
+}));
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({
+    scaleFactor: () => Promise.resolve(1),
+    innerPosition: () => Promise.resolve({ toLogical: () => ({ x: 0, y: 0 }) }),
+    onMoved: () => Promise.resolve(() => {}),
+    onResized: () => Promise.resolve(() => {}),
+  }),
+}));
+
+// jsdom lacks ResizeObserver. A NO-OP stub is exactly the scenario under test:
+// it models WebKitGTK never delivering ResizeObserver callbacks for OS resizes,
+// so the window-'resize' listener is the only thing that can re-measure.
+class ResizeObserverStub {
+  observe() {}
+  unobserve() {}
+  disconnect() {}
+}
+(globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = ResizeObserverStub;
+
+// Pane contents are irrelevant here and pull in xterm.js / browser APIs jsdom
+// lacks; stub them with inert markers.
+vi.mock("../components/terminal/TerminalView", () => ({
+  TerminalView: () => <div className="mock-terminal" />,
+}));
+vi.mock("../components/files/FileBrowser", () => ({
+  FileBrowser: () => <div className="mock-files" />,
+}));
+
+import { CenterPanel } from "../components/layout/CenterPanel";
+import { useTabsStore } from "../stores/tabs";
+import { useProjectsStore } from "../stores/projects";
+
+const BAR_H = 28;
+// The stubbed body width is mutable so a "window resize" can shrink it. Height
+// stays fixed; only width matters for the reflow.
+let bodyWidth = 800;
+
+function seedOneGroup() {
+  useProjectsStore.setState({
+    projects: [{ id: "p", name: "P", directory: "/p", local_file: "" } as never],
+    activeId: "p",
+  });
+  useTabsStore.setState({
+    scope: "p",
+    tabsByScope: {},
+    layoutByScope: {},
+    focusedGroupByScope: {},
+    tabs: [],
+    layout: null,
+    focusedGroupId: null,
+    activeKey: null,
+  });
+  useTabsStore.getState().setScope("p");
+  useTabsStore.getState().addTab({ label: "a", cmd: "bash", cwd: "/p", kind: "shell" });
+}
+
+// Dispatch getBoundingClientRect by element class: the panel spans the full
+// width; the measured group body (`.subwindow-pane-slot`) is the current
+// bodyWidth below a tab bar. measure() reads the slot relative to the panel.
+function installGeometry() {
+  vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(function (
+    this: HTMLElement,
+  ) {
+    const rect = (left: number, top: number, width: number, height: number) =>
+      ({ left, top, width, height, right: left + width, bottom: top + height, x: left, y: top, toJSON() {} }) as DOMRect;
+    if (this.classList.contains("center-panel")) return rect(0, 0, bodyWidth, 600);
+    if (this.classList.contains("subwindow-pane-slot")) return rect(0, BAR_H, bodyWidth, 600 - BAR_H);
+    return rect(0, 0, bodyWidth, 600);
+  });
+}
+
+async function flush() {
+  await act(async () => {
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+}
+
+/** The visible pane carries the measured width as an inline style; the hidden
+ *  ones are `display:none` with no width. Return the active pane's width string. */
+function activePaneWidth(container: HTMLElement): string {
+  const panes = Array.from(container.querySelectorAll<HTMLElement>(".center-pane"));
+  const visible = panes.find((p) => p.style.width !== "");
+  return visible?.style.width ?? "";
+}
+
+describe("CenterPanel — panes reflow on OS-window resize (WebKitGTK)", () => {
+  beforeEach(() => {
+    bodyWidth = 800;
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+    cleanup();
+  });
+
+  it("re-measures pane width when a window 'resize' fires (ResizeObserver-less env)", async () => {
+    seedOneGroup();
+    installGeometry();
+    const { container } = render(<CenterPanel />);
+    // Nudge a layout-effect re-run so the first measure() reads the stubbed rects.
+    await act(async () => {
+      useTabsStore.getState().setScope("root");
+      useTabsStore.getState().setScope("p");
+    });
+
+    // Pane starts at the full 800px body.
+    expect(activePaneWidth(container)).toBe("800px");
+
+    // The OS window shrinks: the body is now 400px wide. jsdom fires no
+    // ResizeObserver, so only the bridged 'resize' listener can re-measure.
+    bodyWidth = 400;
+    await act(async () => {
+      window.dispatchEvent(new Event("resize"));
+    });
+    await flush();
+
+    // With the fix the pane follows the narrower window; without it, it stays 800.
+    expect(activePaneWidth(container)).toBe("400px");
+  });
+});
diff --git a/src/__tests__/VpnAlreadyUpSections.test.tsx b/src/__tests__/VpnAlreadyUpSections.test.tsx
new file mode 100644
index 0000000..81204aa
--- /dev/null
+++ b/src/__tests__/VpnAlreadyUpSections.test.tsx
@@ -0,0 +1,140 @@
+/**
+ * One rule for every remote menu that can start a tunnel: **if a tunnel is already
+ * up machine-wide, don't offer another one.**
+ *
+ * A tunnel reroutes the whole computer, so it is not the project's to own twice. The
+ * Connect modal already collapsed its OpenVPN block to a one-line notice in that
+ * state; the section the new-project and extend-to-remote dialogs share still asked
+ * "Connect via OpenVPN" — for routing that was already in place. Both now go through
+ * `useVpnSectionVisible` / `VpnTunnelUpNotice`, and this pins that they agree.
+ *
+ * The exception the gate must preserve: a tunnel *this* dialog brought up keeps its
+ * controls (handshake log, Stop/Disconnect) where the user started it.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn() }));
+// Neither dialog mounts a terminal on the headless path, but the import drags xterm
+// into jsdom — stub it.
+vi.mock("../components/terminal/TerminalView", () => ({ TerminalView: () => null }));
+
+import { ExtendToRemoteDialog } from "../components/projects/ExtendToRemoteDialog";
+import { RemoteConnectDialog } from "../components/projects/RemoteConnectDialog";
+import { useProjectsStore } from "../stores/projects";
+import { useConnectDialogStore } from "../stores/connectDialog";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+import { useSettingsStore } from "../stores/settings";
+import { useVpnStatusStore } from "../stores/vpnStatus";
+import type { ProjectEntry } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+/** The tunnel someone else (the header, another project, connect-on-launch) put up. */
+const OTHER_CONFIG = "/store/office.ovpn";
+
+const LOCAL_PROJECT = {
+  id: "p1",
+  name: "sshtest",
+  directory: "/home/u/eldrun/projects/sshtest",
+  position: 0,
+  status: "active",
+} as unknown as ProjectEntry;
+
+const REMOTE_PROJECT = {
+  ...LOCAL_PROJECT,
+  remote: { user: "alice", host: "host.example", remote_path: "/srv/work" },
+} as unknown as ProjectEntry;
+
+const vpnToggle = () => screen.queryByRole("checkbox", { name: /connect via openvpn/i });
+const upNotice = () => screen.queryByText(/openvpn tunnel already up/i);
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    if (cmd === "remote_has_saved_password" || cmd === "vpn_has_saved_password") {
+      return Promise.resolve(false);
+    }
+    if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+    if (cmd === "ssh_list_addresses" || cmd === "remote_list_paths") return Promise.resolve([]);
+    if (cmd === "ssh_tooling_status") {
+      return Promise.resolve({ password_auth: true, openvpn: true });
+    }
+    if (cmd === "openvpn_auth_needs") {
+      return Promise.resolve({ username: false, keyPassphrase: false });
+    }
+    return Promise.resolve();
+  });
+
+  useSettingsStore.setState({ settings: { connections_headless: true } as never });
+  useProjectsStore.setState({ projects: [REMOTE_PROJECT] } as never);
+  useConnectDialogStore.setState({ projectId: REMOTE_PROJECT.id } as never);
+  useRemoteStatusStore.setState({ byProject: {} } as never);
+  useVpnStatusStore.setState({ byConfig: {}, holders: {} });
+});
+
+describe("extend-to-remote: the OpenVPN block yields to a live tunnel", () => {
+  it("offers the tunnel when none is up", async () => {
+    render(<ExtendToRemoteDialog project={LOCAL_PROJECT} onClose={() => {}} />);
+
+    expect(await screen.findByRole("checkbox", { name: /connect via openvpn/i })).toBeTruthy();
+    expect(upNotice()).toBeNull();
+  });
+
+  it("collapses to the already-up notice when a tunnel is live machine-wide", async () => {
+    useVpnStatusStore.setState({ byConfig: { [OTHER_CONFIG]: "connected" }, holders: {} });
+
+    render(<ExtendToRemoteDialog project={LOCAL_PROJECT} onClose={() => {}} />);
+
+    // The SSH step still renders — it is only the redundant VPN offer that goes.
+    expect(await screen.findByPlaceholderText(/user@host/i)).toBeTruthy();
+    expect(upNotice()).toBeTruthy();
+    expect(vpnToggle()).toBeNull();
+  });
+
+  it("still collapses while a tunnel is only coming up", async () => {
+    useVpnStatusStore.setState({ byConfig: { [OTHER_CONFIG]: "connecting" }, holders: {} });
+
+    render(<ExtendToRemoteDialog project={LOCAL_PROJECT} onClose={() => {}} />);
+
+    expect(await screen.findByText(/openvpn tunnel already up/i)).toBeTruthy();
+    expect(vpnToggle()).toBeNull();
+  });
+});
+
+describe("the Connect modal answers the same question the same way", () => {
+  it("collapses when another config's tunnel is up", async () => {
+    useVpnStatusStore.setState({ byConfig: { [OTHER_CONFIG]: "connected" }, holders: {} });
+
+    render(<RemoteConnectDialog />);
+
+    expect(await screen.findByText(/openvpn tunnel already up/i)).toBeTruthy();
+    expect(vpnToggle()).toBeNull();
+  });
+
+  it("keeps the section when the live tunnel is this project's own", async () => {
+    // Its log and its Disconnect live here — hiding them would strand the tunnel the
+    // user started from this very dialog.
+    useProjectsStore.setState({
+      projects: [
+        {
+          ...REMOTE_PROJECT,
+          remote: { ...REMOTE_PROJECT.remote, openvpn: { config: OTHER_CONFIG } },
+        },
+      ],
+    } as never);
+    useRemoteStatusStore.setState({
+      byProject: { p1: { ssh: "off", vpn: "connected" } },
+    } as never);
+    useVpnStatusStore.setState({ byConfig: { [OTHER_CONFIG]: "connected" }, holders: { [OTHER_CONFIG]: ["p1"] } });
+
+    render(<RemoteConnectDialog />);
+
+    expect(await screen.findByRole("button", { name: /disconnect vpn/i })).toBeTruthy();
+    expect(upNotice()).toBeNull();
+  });
+});
diff --git a/src/__tests__/VpnAutoConnect.test.ts b/src/__tests__/VpnAutoConnect.test.ts
new file mode 100644
index 0000000..03fbc67
--- /dev/null
+++ b/src/__tests__/VpnAutoConnect.test.ts
@@ -0,0 +1,142 @@
+/**
+ * The machine-level VPN auto-connect, and the rule that makes it safe to have.
+ *
+ * A tunnel is not a project's: it reroutes the whole computer for as long as it is
+ * up. So "connect on launch" is armed on the *config*, in the header's VPN menu, and
+ * it carries the same promise the project-side opt-in does — **it never prompts**.
+ * The opt-in is re-checked at launch rather than trusted, so credentials forgotten
+ * since it was ticked leave the tunnel down instead of ambushing the user with a
+ * modal during startup.
+ *
+ * The load-bearing detail is *why the check comes first*. Bringing a tunnel up is
+ * elevated (`pkexec openvpn`), and polkit authenticates the user before OpenVPN has
+ * looked at the config at all — so an attempt that was always going to be rejected
+ * does not fail cheaply, it costs a system password dialog. Trying and falling back
+ * to the modal therefore cost *two* system prompts for one tunnel, which is exactly
+ * what the header's connect did to any `auth-user-pass` config with no project behind
+ * it: the username lived only on a project's spec. Never elevate on a connect that
+ * cannot succeed.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/api/webview", () => ({
+  getCurrentWebview: () => ({ setZoom: () => Promise.resolve() }),
+}));
+
+import type { Settings } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+
+const CONFIG = "/store/office.ovpn";
+
+/** Drive the mocked backend: `silent` is what `vpn_can_connect_silently` answers,
+ *  `active` what `openvpn_active` reports as already up, and `connect` whether an
+ *  actual `openvpn_connect` succeeds. */
+const backend = (opts: { silent?: boolean; active?: string[]; connect?: "ok" | "fail" }) => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    switch (cmd) {
+      case "vpn_can_connect_silently":
+        return Promise.resolve(opts.silent ?? false);
+      case "openvpn_active":
+        return Promise.resolve(opts.active ?? []);
+      case "openvpn_connect":
+        return opts.connect === "fail"
+          ? Promise.reject(new Error("AUTH_FAILED"))
+          : Promise.resolve();
+      default:
+        return Promise.resolve();
+    }
+  });
+};
+
+/**
+ * One launch, in a pristine module graph: `autoConnectVpnOnLaunch` is
+ * once-per-process by design (a re-mount must not re-connect), so each test needs its
+ * own instance of it — and, since the module closes over the stores it imports, its
+ * own instance of *those*. Seeding must therefore happen inside this graph, not
+ * outside it. Returns the store the assertions read.
+ */
+async function launch(seed: Partial<Settings>) {
+  vi.resetModules();
+  const [{ autoConnectVpnOnLaunch }, { useSettingsStore }, { useVpnStatusStore }] =
+    await Promise.all([
+      import("../lib/vpnAutoConnect"),
+      import("../stores/settings"),
+      import("../stores/vpnStatus"),
+    ]);
+  useSettingsStore.setState({ settings: seed as Settings, loaded: true });
+  await autoConnectVpnOnLaunch();
+  return useVpnStatusStore.getState().byConfig;
+}
+
+const calls = (cmd: string) => invokeMock.mock.calls.filter(([c]) => c === cmd);
+
+describe("VPN auto-connect (machine-level)", () => {
+  beforeEach(() => {
+    invokeMock.mockReset();
+  });
+
+  it("does nothing at all when no config is armed", async () => {
+    backend({ silent: true });
+    const byConfig = await launch({});
+    expect(calls("openvpn_connect")).toHaveLength(0);
+    expect(byConfig).toEqual({});
+  });
+
+  it("brings the armed tunnel up silently on launch", async () => {
+    backend({ silent: true });
+    const byConfig = await launch({ vpn_auto_connect: CONFIG });
+
+    expect(calls("openvpn_connect")).toHaveLength(1);
+    // No checkbox behind a silent connect: the keychain must be left as found, or the
+    // connect deletes the very credentials it just authenticated with.
+    expect(calls("openvpn_connect")[0][1]).toMatchObject({
+      config: CONFIG,
+      password: null,
+      remember: null,
+    });
+    expect(byConfig[CONFIG]).toBe("connected");
+  });
+
+  /** The promise: a stale opt-in degrades to staying down — no modal, and (because a
+   *  `pkexec` attempt IS the polkit prompt) no elevation either. */
+  it("stays down, and never elevates, when the credentials no longer allow a silent connect", async () => {
+    backend({ silent: false });
+    const byConfig = await launch({ vpn_auto_connect: CONFIG });
+
+    expect(calls("openvpn_connect")).toHaveLength(0);
+    expect(byConfig[CONFIG]).toBeUndefined();
+  });
+
+  it("leaves a tunnel that outlived the last run alone", async () => {
+    backend({ silent: true, active: [CONFIG] });
+    const byConfig = await launch({ vpn_auto_connect: CONFIG });
+
+    expect(calls("openvpn_connect")).toHaveLength(0);
+    expect(byConfig[CONFIG]).toBe("connected");
+  });
+
+  it("goes dark rather than half-lit when the connect fails", async () => {
+    backend({ silent: true, connect: "fail" });
+    const byConfig = await launch({ vpn_auto_connect: CONFIG });
+
+    // A tunnel that never came up is rerouting nothing; the header must not claim it is.
+    expect(byConfig[CONFIG]).toBeUndefined();
+  });
+
+  /** Non-headless: Eldrun handles no passwords, so "connect on launch" can only mean
+   *  "the connect command is waiting in the root terminal" — never a silent connect. */
+  it("opens the connect command in the root terminal when headless connections are off", async () => {
+    backend({ silent: true });
+    const byConfig = await launch({ vpn_auto_connect: CONFIG, connections_headless: false });
+
+    expect(calls("openvpn_connect")).toHaveLength(0);
+    expect(calls("openvpn_login_command")).toHaveLength(1);
+    expect(byConfig[CONFIG]).toBe("connecting");
+  });
+});
diff --git a/src/__tests__/VpnDropGating.test.ts b/src/__tests__/VpnDropGating.test.ts
new file mode 100644
index 0000000..6b85f52
--- /dev/null
+++ b/src/__tests__/VpnDropGating.test.ts
@@ -0,0 +1,115 @@
+/**
+ * A tunnel that dies on its own must be *noticed*, and noticing it must gate the
+ * SSH/SFTP work belonging to the projects that were riding it.
+ *
+ * This is the failure this exists for: OpenVPN exits (it used to do so
+ * permanently after three failed reconnects — see `openvpn_args`), the machine's
+ * routing is left pointing into a tunnel with nothing behind it, and every
+ * pooled-SSH call a remote project makes now aims at a peer that will never
+ * answer. Those calls are synchronous Tauri commands, and a black-holed socket
+ * yields no error, so each blocks ~45s until ssh's keepalive gives up. The file
+ * tree issues one per visible folder. The app froze.
+ *
+ * `refresh()` is the only thing that reconciles against the backend, so the drop
+ * has to be detected *there* — and it has to be distinguishable from a
+ * deliberate disconnect, which must not be reported as a drop.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+
+import { useVpnStatusStore, markVpnConnected, disconnectVpnTunnel } from "../stores/vpnStatus";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+
+const invokeMock = vi.mocked(invoke);
+const CONFIG = "/store/office.ovpn";
+const PROJECT = "p-remote";
+
+/** What the backend reports as live on the next reconcile. */
+function backendReports(configs: string[]) {
+  invokeMock.mockImplementation((cmd: string) => {
+    if (cmd === "openvpn_active") return Promise.resolve(configs);
+    return Promise.resolve();
+  });
+}
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  useVpnStatusStore.setState({ byConfig: {}, holders: {} });
+  useRemoteStatusStore.setState({ byProject: {}, byHost: {} });
+});
+
+describe("a tunnel that dies unasked", () => {
+  beforeEach(() => {
+    markVpnConnected(PROJECT, CONFIG);
+    useRemoteStatusStore.getState().setSsh(PROJECT, "connected");
+  });
+
+  it("is detected by the reconcile and clears the holder's remote status", async () => {
+    backendReports([]); // the tunnel is simply gone
+    await useVpnStatusStore.getState().refresh();
+
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBeUndefined();
+    // The gate: with the project's status cleared, `useRemoteBlocked` stops the
+    // SFTP/git probes being dispatched at all, rather than each paying ~45s.
+    expect(useRemoteStatusStore.getState().byProject[PROJECT]).toBeUndefined();
+  });
+
+  it("releases the claims, so a later reconnect is not seen as already held", async () => {
+    backendReports([]);
+    await useVpnStatusStore.getState().refresh();
+    expect(useVpnStatusStore.getState().holders[CONFIG]).toBeUndefined();
+  });
+
+  it("leaves a project that never claimed the tunnel alone", async () => {
+    // It reaches its host by some other route; this tunnel is none of its business.
+    useRemoteStatusStore.getState().setSsh("p-other", "connected");
+    backendReports([]);
+    await useVpnStatusStore.getState().refresh();
+    expect(useRemoteStatusStore.getState().byProject["p-other"]?.ssh).toBe("connected");
+  });
+});
+
+describe("everything that is not a drop", () => {
+  it("does not fire for a tunnel that is still up", async () => {
+    markVpnConnected(PROJECT, CONFIG);
+    useRemoteStatusStore.getState().setSsh(PROJECT, "connected");
+    backendReports([CONFIG]);
+    await useVpnStatusStore.getState().refresh();
+    expect(useRemoteStatusStore.getState().byProject[PROJECT]?.ssh).toBe("connected");
+  });
+
+  it("does not fire for a deliberate disconnect", async () => {
+    markVpnConnected(PROJECT, CONFIG);
+    useRemoteStatusStore.getState().setSsh(PROJECT, "connected");
+    // A UI teardown forgets the config first, so the next reconcile sees neither
+    // side and must not mistake it for a death.
+    disconnectVpnTunnel(CONFIG);
+    useRemoteStatusStore.getState().setSsh(PROJECT, "connected");
+    backendReports([]);
+    await useVpnStatusStore.getState().refresh();
+    expect(useRemoteStatusStore.getState().byProject[PROJECT]?.ssh).toBe("connected");
+  });
+
+  it("does not fire for a tunnel still mid-handshake", async () => {
+    useVpnStatusStore.getState().setState(CONFIG, "connecting");
+    useVpnStatusStore.getState().acquire(CONFIG, PROJECT);
+    useRemoteStatusStore.getState().setSsh(PROJECT, "connecting");
+    backendReports([]); // not in the registry yet — that is normal, not a death
+    await useVpnStatusStore.getState().refresh();
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBe("connecting");
+    expect(useRemoteStatusStore.getState().byProject[PROJECT]?.ssh).toBe("connecting");
+  });
+
+  it("does nothing when the backend cannot be reached at all", async () => {
+    markVpnConnected(PROJECT, CONFIG);
+    useRemoteStatusStore.getState().setSsh(PROJECT, "connected");
+    invokeMock.mockImplementation(() => Promise.reject(new Error("backend gone")));
+    await useVpnStatusStore.getState().refresh();
+    // No answer is not evidence the tunnel died — the state must be left alone.
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBe("connected");
+    expect(useRemoteStatusStore.getState().byProject[PROJECT]?.ssh).toBe("connected");
+  });
+});
diff --git a/src/__tests__/VpnMachineScope.test.tsx b/src/__tests__/VpnMachineScope.test.tsx
new file mode 100644
index 0000000..aadebe0
--- /dev/null
+++ b/src/__tests__/VpnMachineScope.test.tsx
@@ -0,0 +1,414 @@
+/**
+ * The OpenVPN tunnel is a machine-level object, not a project's property.
+ *
+ * `pkexec openvpn --config …` runs as root with no routing flags from Eldrun, so a
+ * config that pushes `redirect-gateway` reroutes the *whole computer* — browser and
+ * all — for as long as it is up. Two things follow, and both are locked here:
+ *
+ *  1. **It is shared.** Tunnels are keyed by config path, so two projects on the
+ *     same `.ovpn` ride one tunnel. Logging out of one must not pull it out from
+ *     under the other (and out from under the OS). That was the bug: `logoutRemote`
+ *     and the Connect modal's Disconnect both called `openvpn_disconnect`
+ *     unconditionally.
+ *  2. **It outlives the project view.** A tunnel stays up when you switch away, so
+ *     the header indicator — not the project pill — is where it has to be visible,
+ *     and where it can be brought down.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { invoke } from "@tauri-apps/api/core";
+import { open as openDialog } from "@tauri-apps/plugin-dialog";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/plugin-dialog", () => ({ open: vi.fn(() => Promise.resolve(null)) }));
+
+import { VpnIndicator } from "../components/header/VpnIndicator";
+import { useProjectsStore, logoutRemote } from "../stores/projects";
+import { useRemoteStatusStore } from "../stores/remoteStatus";
+import { markVpnConnected, useVpnStatusStore } from "../stores/vpnStatus";
+import { useVpnPromptStore } from "../stores/vpnPrompt";
+import { useSettingsStore } from "../stores/settings";
+import type { ProjectEntry } from "../types";
+
+const invokeMock = vi.mocked(invoke);
+const openDialogMock = vi.mocked(openDialog);
+
+const CONFIG = "/store/office.ovpn";
+
+const project = (id: string, name: string): ProjectEntry =>
+  ({
+    id,
+    name,
+    directory: `/local/state/${id}`,
+    position: 0,
+    status: "active",
+    remote: {
+      user: "alice",
+      host: "host.example",
+      remote_path: "/srv/work",
+      openvpn: { config: CONFIG },
+    },
+  }) as unknown as ProjectEntry;
+
+const A = project("p1", "alpha");
+const B = project("p2", "beta");
+
+const disconnects = () =>
+  invokeMock.mock.calls.filter(([name]) => name === "openvpn_disconnect");
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  openDialogMock.mockReset();
+  openDialogMock.mockResolvedValue(null);
+  invokeMock.mockImplementation((cmd: string) => {
+    if (cmd === "openvpn_active") return Promise.resolve([]);
+    return Promise.resolve();
+  });
+  useProjectsStore.setState({ projects: [A, B] } as never);
+  useRemoteStatusStore.setState({ byProject: {} } as never);
+  useVpnStatusStore.setState({ byConfig: {}, holders: {} });
+  // The header indicator is off by default (Settings' "Remote features"); these
+  // tests are specifically about that surface, so opt in.
+  useSettingsStore.setState({ settings: { vpn_enabled: true } as never });
+});
+
+describe("a shared tunnel is refcounted by holder", () => {
+  it("survives one holder logging out, and comes down with the last", () => {
+    // Both projects are on the same .ovpn — one tunnel, two holders.
+    markVpnConnected(A.id, CONFIG);
+    markVpnConnected(B.id, CONFIG);
+    expect(useVpnStatusStore.getState().holders[CONFIG]).toEqual([A.id, B.id]);
+
+    // THE BUG: this used to fire openvpn_disconnect unconditionally, killing the
+    // tunnel B is still riding — and the machine's routing with it.
+    logoutRemote(A);
+    expect(disconnects()).toEqual([]);
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBe("connected");
+    expect(useVpnStatusStore.getState().holders[CONFIG]).toEqual([B.id]);
+
+    // Last one out turns off the lights.
+    logoutRemote(B);
+    expect(disconnects()).toEqual([["openvpn_disconnect", { config: CONFIG }]]);
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBeUndefined();
+  });
+
+  it("brings the tunnel down for a lone holder", () => {
+    markVpnConnected(A.id, CONFIG);
+    logoutRemote(A);
+    expect(disconnects()).toEqual([["openvpn_disconnect", { config: CONFIG }]]);
+  });
+});
+
+/** Report the tunnel as live to the backend-reconcile (`refresh`) too, so the
+ *  mount-time reseat doesn't drop a tunnel the test just brought up. */
+const backendReports = (...configs: string[]) =>
+  invokeMock.mockImplementation((cmd: string) => {
+    if (cmd === "openvpn_active") return Promise.resolve(configs);
+    if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+    return Promise.resolve();
+  });
+
+describe("the header indicator is the tunnel's own surface", () => {
+  it("appears whenever a tunnel is up — even with no project holding it", async () => {
+    // The reload/crash case: the tunnel outlived the renderer, so nothing in the
+    // frontend claims it. It is still rerouting the machine, so it is still shown.
+    backendReports(CONFIG);
+    render(<VpnIndicator />);
+
+    const btn = await screen.findByRole("button", { name: /openvpn/i });
+    await userEvent.hover(btn);
+    expect(screen.getByText("office.ovpn")).toBeTruthy();
+    expect(screen.getByText(/held by no project/i)).toBeTruthy();
+  });
+
+  it("names the holders and can bring the tunnel down for all of them", async () => {
+    backendReports(CONFIG);
+    markVpnConnected(A.id, CONFIG);
+    markVpnConnected(B.id, CONFIG);
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    expect(screen.getByText(/for alpha, beta/i)).toBeTruthy();
+
+    await userEvent.click(screen.getByRole("button", { name: /disconnect tunnel/i }));
+    await waitFor(() =>
+      expect(disconnects()).toEqual([["openvpn_disconnect", { config: CONFIG }]]),
+    );
+    // Every claim dropped: the user acted on the tunnel, not on a project.
+    expect(useVpnStatusStore.getState().holders[CONFIG]).toBeUndefined();
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBeUndefined();
+  });
+});
+
+describe("the tunnel state follows the backend", () => {
+  it("reconciles away a tunnel the backend no longer reports", async () => {
+    // The tunnel died (or was killed outside Eldrun). The indicator must not keep
+    // claiming the machine is being rerouted when it isn't.
+    markVpnConnected(A.id, CONFIG);
+    await useVpnStatusStore.getState().refresh();
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBeUndefined();
+  });
+
+  it("keeps an in-flight tunnel the backend cannot see yet", async () => {
+    // Mid-handshake: not in the backend registry until it comes up. Reconciling it
+    // away would blank the indicator while the tunnel is actively being built.
+    useVpnStatusStore.getState().setState(CONFIG, "connecting");
+    await useVpnStatusStore.getState().refresh();
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBe("connecting");
+  });
+});
+
+describe("the header can bring a tunnel up, with no project behind it", () => {
+  // A VPN is something you use, not only a precondition for an SSH project — and
+  // requiring a project just to reach the tunnel was backwards.
+  const STORED = [{ path: CONFIG, name: "office.ovpn" }];
+
+  it("offers each stored config, and connects it from the saved passphrase", async () => {
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve(STORED);
+      if (cmd === "vpn_can_connect_silently") return Promise.resolve(true);
+      return Promise.resolve();
+    });
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^connect$/i }));
+
+    await waitFor(() =>
+      expect(
+        invokeMock.mock.calls.filter(([name]) => name === "openvpn_connect"),
+      ).toHaveLength(1),
+    );
+    // Up, and held by nobody: it was not brought up on any project's behalf.
+    await waitFor(() =>
+      expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBe("connected"),
+    );
+    expect(useVpnStatusStore.getState().holders[CONFIG]).toBeUndefined();
+    // `remember: null` — no checkbox behind this call, so the keychain is untouched.
+    const [, args] = invokeMock.mock.calls.find(([name]) => name === "openvpn_connect")!;
+    expect((args as { remember: unknown }).remember).toBeNull();
+  });
+
+  /**
+   * Elevation is not free, and a rejected login is not cheap.
+   *
+   * `pkexec` authenticates the *user* before OpenVPN so much as reads the config, so a
+   * connect attempt that was always going to be rejected still costs a polkit dialog —
+   * and the modal that then opens to collect what was missing costs a second one. That
+   * is what this menu did to every `auth-user-pass` config with no project behind it:
+   * the username lives on a project's spec, the header had none to give, so each
+   * connect burned two system password prompts. The fix is to ask whether the connect
+   * would be silent *before* making it, and go straight to the modal when it wouldn't.
+   */
+  it("never elevates on a connect it knows cannot succeed — it asks first", async () => {
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve(STORED);
+      // Credentials incomplete (e.g. a username this side has never seen).
+      if (cmd === "vpn_can_connect_silently") return Promise.resolve(false);
+      return Promise.resolve();
+    });
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^connect$/i }));
+
+    // The modal owns the connect from here. Crucially, no `openvpn_connect` was fired
+    // on the way to it: that call *is* the polkit prompt.
+    await waitFor(() => expect(useVpnPromptStore.getState().pending?.config).toBe(CONFIG));
+    expect(invokeMock.mock.calls.filter(([name]) => name === "openvpn_connect")).toHaveLength(0);
+  });
+
+  /**
+   * With nothing stored, the header used to be a dead end: it told you to go add a
+   * config from some project's Connect dialog. A VPN with no project has no such
+   * dialog. So the empty state now carries a Connect button that browses for a
+   * `.ovpn`, stores it, and brings it straight up — no project required.
+   */
+  it("with no config stored, Add config browses for a .ovpn and stores it without dialling", async () => {
+    const PICKED = "/home/alice/Downloads/office.ovpn";
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve([]); // nothing stored yet
+      if (cmd === "openvpn_store_config") return Promise.resolve(CONFIG); // copied into the store
+      if (cmd === "vpn_can_connect_silently") return Promise.resolve(true);
+      return Promise.resolve();
+    });
+    openDialogMock.mockResolvedValue(PICKED);
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^add config…$/i }));
+
+    // The picked file is copied into Eldrun's store…
+    await waitFor(() =>
+      expect(
+        invokeMock.mock.calls.filter(([name]) => name === "openvpn_store_config"),
+      ).toEqual([["openvpn_store_config", { config: PICKED }]]),
+    );
+    // …and then it is only *listed*, never auto-dialled: connecting is a separate,
+    // explicit click on its row (where the password prompt lives).
+    expect(invokeMock.mock.calls.filter(([name]) => name === "openvpn_connect")).toHaveLength(0);
+    await waitFor(() => expect(screen.getByText("office.ovpn")).toBeTruthy());
+    expect(useVpnStatusStore.getState().byConfig[CONFIG]).toBeUndefined();
+  });
+
+  it("cancelling the file browse adds nothing", async () => {
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve([]);
+      return Promise.resolve();
+    });
+    openDialogMock.mockResolvedValue(null); // user hit Cancel
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^add config…$/i }));
+
+    expect(invokeMock.mock.calls.filter(([name]) => name === "openvpn_store_config")).toHaveLength(0);
+    expect(invokeMock.mock.calls.filter(([name]) => name === "openvpn_connect")).toHaveLength(0);
+  });
+
+  /**
+   * A VPN need not belong to a project, so adding another `.ovpn` can't require
+   * opening some project's Connect dialog. Even with configs already listed, an
+   * "Add config…" action stores + lists a new one — connecting stays an explicit
+   * per-row click (with its password prompt), never an auto-dial.
+   */
+  it("with configs stored, Add config adds a different .ovpn without dialling it", async () => {
+    const OTHER_STORED = "/store/other.ovpn";
+    const PICKED = "/home/alice/Downloads/other.ovpn";
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve(STORED); // office.ovpn already stored
+      if (cmd === "openvpn_store_config") return Promise.resolve(OTHER_STORED);
+      if (cmd === "vpn_can_connect_silently") return Promise.resolve(true);
+      return Promise.resolve();
+    });
+    openDialogMock.mockResolvedValue(PICKED);
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^add config…$/i }));
+
+    await waitFor(() =>
+      expect(
+        invokeMock.mock.calls.filter(([name]) => name === "openvpn_store_config"),
+      ).toEqual([["openvpn_store_config", { config: PICKED }]]),
+    );
+    // Added and listed, not connected.
+    expect(invokeMock.mock.calls.filter(([name]) => name === "openvpn_connect")).toHaveLength(0);
+    await waitFor(() => expect(screen.getByText("other.ovpn")).toBeTruthy());
+    expect(useVpnStatusStore.getState().byConfig[OTHER_STORED]).toBeUndefined();
+  });
+
+  it("is present even when nothing is up — that is how you find it", async () => {
+    // It used to render null unless a tunnel was already running, which made the one
+    // control for a machine-wide thing impossible to find until it was too late.
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve(STORED);
+      return Promise.resolve();
+    });
+    const { container } = render(<VpnIndicator />);
+    expect(container.firstChild).not.toBeNull();
+    expect(screen.getByRole("button", { name: /openvpn/i })).toBeTruthy();
+  });
+});
+
+describe("a stored config can be removed, not only connected", () => {
+  // Removal takes the saved credentials with it (they are keyed by the config
+  // path and would otherwise be a stale half in the keychain), and *those* can't
+  // be brought back by re-browsing the file — so it is a two-click action.
+  const STORED = [{ path: CONFIG, name: "office.ovpn" }];
+
+  const removals = () =>
+    invokeMock.mock.calls.filter(([name]) => name === "openvpn_remove_config");
+
+  const withStored = () =>
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve(STORED);
+      return Promise.resolve();
+    });
+
+  it("asks once more, then removes the config and its row", async () => {
+    withStored();
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^remove$/i }));
+
+    // Armed, not done: nothing has been removed yet.
+    expect(removals()).toHaveLength(0);
+    expect(screen.getByText(/forgets its saved credentials/i)).toBeTruthy();
+
+    await userEvent.click(screen.getByRole("button", { name: /^remove config$/i }));
+    await waitFor(() =>
+      expect(removals()).toEqual([["openvpn_remove_config", { config: CONFIG }]]),
+    );
+    // The row is gone without a re-list round-trip.
+    await waitFor(() => expect(screen.queryByText("office.ovpn")).toBeNull());
+  });
+
+  it("Keep cancels the armed removal", async () => {
+    withStored();
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^remove$/i }));
+    await userEvent.click(screen.getByRole("button", { name: /^keep$/i }));
+
+    expect(removals()).toHaveLength(0);
+    expect(screen.getByText("office.ovpn")).toBeTruthy();
+    expect(screen.getByRole("button", { name: /^connect$/i })).toBeTruthy();
+  });
+
+  it("names the projects that use the config before removing it", async () => {
+    // Both fixture projects ride CONFIG — the warning must say so, since their
+    // next connect will have to ask for a config again.
+    withStored();
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^remove$/i }));
+    expect(screen.getByText(/alpha, beta/)).toBeTruthy();
+  });
+
+  it("disarms connect-on-launch when the armed config is removed", async () => {
+    // An armed path with no file behind it would silently fail at every startup.
+    withStored();
+    useSettingsStore.setState({ settings: { vpn_auto_connect: CONFIG, vpn_enabled: true } as never });
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^remove$/i }));
+    await userEvent.click(screen.getByRole("button", { name: /^remove config$/i }));
+
+    await waitFor(() =>
+      expect(useSettingsStore.getState().settings?.vpn_auto_connect).toBeNull(),
+    );
+  });
+
+  it("a refused removal keeps the row and shows the reason", async () => {
+    invokeMock.mockImplementation((cmd: string) => {
+      if (cmd === "openvpn_active") return Promise.resolve([]);
+      if (cmd === "openvpn_list_configs") return Promise.resolve(STORED);
+      if (cmd === "openvpn_remove_config")
+        return Promise.reject(new Error("this tunnel is up — disconnect it first"));
+      return Promise.resolve();
+    });
+    render(<VpnIndicator />);
+
+    await userEvent.hover(screen.getByRole("button", { name: /openvpn/i }));
+    await userEvent.click(await screen.findByRole("button", { name: /^remove$/i }));
+    await userEvent.click(screen.getByRole("button", { name: /^remove config$/i }));
+
+    await waitFor(() => expect(screen.getByText(/disconnect it first/i)).toBeTruthy());
+    expect(screen.getByText("office.ovpn")).toBeTruthy();
+  });
+});
diff --git a/src/__tests__/VpnTerminalHandoff.test.ts b/src/__tests__/VpnTerminalHandoff.test.ts
new file mode 100644
index 0000000..ecf59ac
--- /dev/null
+++ b/src/__tests__/VpnTerminalHandoff.test.ts
@@ -0,0 +1,142 @@
+/**
+ * The escape hatch out of a headless VPN login that cannot work.
+ *
+ * Eldrun's own login models exactly two secrets — an account password and a key
+ * passphrase. A config whose server asks anything else (a challenge/OTP, a prompt of
+ * its own) is unanswerable from the modal, and the symptom is a loop the user cannot
+ * get out of: the saved credentials fail, the prompt opens, the password typed into
+ * it fails too. So the prompt can hand *that one connect* to the non-headless flow —
+ * the connect command goes to a root-terminal tab and OpenVPN asks its own questions
+ * there.
+ *
+ * Two things are load-bearing, and both are asserted here.
+ *
+ *  1. **It is a local switch.** `connections_headless` is the user's statement about
+ *     how Eldrun should behave; a failed handshake does not get to rewrite it.
+ *  2. **The rejection is not a failure.** `request()` rejects (the tunnel is not up,
+ *     so resolving would be a lie), but the attempt is alive — the lamp is amber and
+ *     the poll owns the outcome. A caller reading it as "no tunnel" would paint a
+ *     login the user is still typing red, which is why the sentinel exists.
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+import { invoke } from "@tauri-apps/api/core";
+
+vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn(() => Promise.resolve()) }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn(() => Promise.resolve(() => {})) }));
+vi.mock("@tauri-apps/api/webview", () => ({
+  getCurrentWebview: () => ({ setZoom: () => Promise.resolve() }),
+}));
+
+const invokeMock = vi.mocked(invoke);
+
+const CONFIG = "/store/office.ovpn";
+const COMMAND = "pkexec openvpn --config /store/office.ovpn";
+
+/** A backend that can build the login command (the only call the handoff makes on
+ *  its way to the terminal) — or, with `build: "fail"`, one that cannot. */
+const backend = (opts: { build?: "ok" | "fail" } = {}) => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation((cmd: string) => {
+    switch (cmd) {
+      case "openvpn_login_command":
+        return opts.build === "fail"
+          ? Promise.reject(new Error("no openvpn on PATH"))
+          : Promise.resolve(COMMAND);
+      case "openvpn_status":
+        return Promise.resolve(false);
+      case "openvpn_active":
+        return Promise.resolve([]);
+      default:
+        return Promise.resolve();
+    }
+  });
+};
+
+/** A pristine module graph per test: the stores are module singletons, and the
+ *  handoff writes to three of them (prompt, tunnel state, tabs). */
+async function graph() {
+  vi.resetModules();
+  const [prompt, vpnStatus, tabs, settings] = await Promise.all([
+    import("../stores/vpnPrompt"),
+    import("../stores/vpnStatus"),
+    import("../stores/tabs"),
+    import("../stores/settings"),
+  ]);
+  return { ...prompt, ...vpnStatus, useTabsStore: tabs.useTabsStore, ...settings };
+}
+
+const calls = (cmd: string) => invokeMock.mock.calls.filter(([c]) => c === cmd);
+
+describe("VPN terminal handoff", () => {
+  beforeEach(() => {
+    invokeMock.mockReset();
+  });
+
+  it("opens the login in a root terminal and rejects the caller with the handoff sentinel", async () => {
+    backend();
+    const g = await graph();
+    const store = g.useVpnPromptStore.getState();
+
+    const request = store.request(CONFIG, "office", null);
+    const rejected = request.catch((e) => e);
+    await g.useVpnPromptStore.getState().handoffToTerminal();
+
+    // The command was built (which is also what arms the tunnel backend-side) and
+    // typed into a freshly-spawned root tab.
+    expect(calls("openvpn_login_command")).toHaveLength(1);
+    const rootTabs = g.useTabsStore.getState().tabsByScope.root ?? [];
+    expect(rootTabs[rootTabs.length - 1]).toMatchObject({ kind: "shell", initialInput: COMMAND });
+
+    // The tunnel is coming up, not failed: amber, with the poll behind it.
+    expect(g.useVpnStatusStore.getState().byConfig[CONFIG]).toBe("connecting");
+
+    // The modal is gone and the caller was told *why* — a handoff, not a failure.
+    expect(g.useVpnPromptStore.getState().pending).toBeNull();
+    expect(g.isVpnTerminalHandoff(await rejected)).toBe(true);
+  });
+
+  /** The whole point of "locally": the setting is the user's statement about how
+   *  Eldrun should behave, and one config's broken handshake must not rewrite it. */
+  it("never touches the global connections_headless setting", async () => {
+    backend();
+    const g = await graph();
+    g.useSettingsStore.setState({ settings: { connections_headless: true } as never, loaded: true });
+
+    void g.useVpnPromptStore.getState().request(CONFIG, "office", null).catch(() => {});
+    await g.useVpnPromptStore.getState().handoffToTerminal();
+
+    expect(g.useSettingsStore.getState().settings?.connections_headless).toBe(true);
+    expect(calls("update_settings")).toHaveLength(0);
+  });
+
+  /** A headless attempt in flight would tear the terminal tunnel back down when it
+   *  settles — `submit`'s superseded-guard disconnects *by config*, and both flavours
+   *  register under the same one. So the handoff stands down instead. */
+  it("does nothing while a headless attempt is still in flight", async () => {
+    backend();
+    const g = await graph();
+
+    void g.useVpnPromptStore.getState().request(CONFIG, "office", null).catch(() => {});
+    g.useVpnPromptStore.setState({ status: "connecting" });
+    await g.useVpnPromptStore.getState().handoffToTerminal();
+
+    expect(calls("openvpn_login_command")).toHaveLength(0);
+    expect(g.useVpnPromptStore.getState().pending).not.toBeNull();
+  });
+
+  /** A handoff that could not even be built opened nothing and moved no lamp, so the
+   *  modal must stay exactly where it was — the user still needs somewhere to be. */
+  it("keeps the modal open when the login command can't be built", async () => {
+    backend({ build: "fail" });
+    const g = await graph();
+
+    void g.useVpnPromptStore.getState().request(CONFIG, "office", null).catch(() => {});
+    await g.useVpnPromptStore.getState().handoffToTerminal();
+
+    expect(g.useVpnPromptStore.getState().pending).not.toBeNull();
+    expect(g.useVpnPromptStore.getState().status).toBe("error");
+    expect(g.useVpnStatusStore.getState().byConfig[CONFIG]).toBeUndefined();
+    expect(g.useTabsStore.getState().tabsByScope.root ?? []).toHaveLength(0);
+  });
+});
diff --git a/src/__tests__/WindowControls.test.tsx b/src/__tests__/WindowControls.test.tsx
index 8a7d1e2..d4fb2dc 100644
--- a/src/__tests__/WindowControls.test.tsx
+++ b/src/__tests__/WindowControls.test.tsx
@@ -5,14 +5,23 @@ import { WindowControls } from "../components/header/WindowControls";
 
 const mockMinimize = vi.fn().mockResolvedValue(undefined);
 const mockToggleMaximize = vi.fn().mockResolvedValue(undefined);
+const mockMaximize = vi.fn().mockResolvedValue(undefined);
+const mockUnmaximize = vi.fn().mockResolvedValue(undefined);
+const mockIsMaximized = vi.fn().mockResolvedValue(false);
 const mockClose = vi.fn().mockResolvedValue(undefined);
 
 vi.mock("@tauri-apps/api/window", () => ({
   getCurrentWindow: () => ({
     minimize: mockMinimize,
     toggleMaximize: mockToggleMaximize,
+    maximize: mockMaximize,
+    unmaximize: mockUnmaximize,
+    isMaximized: mockIsMaximized,
     close: mockClose,
   }),
+  currentMonitor: vi.fn().mockResolvedValue(null),
+  LogicalSize: class {},
+  LogicalPosition: class {},
 }));
 
 describe("WindowControls", () => {
@@ -24,10 +33,12 @@ describe("WindowControls", () => {
     expect(mockMinimize).toHaveBeenCalledOnce();
   });
 
-  it("maximize button calls win.toggleMaximize()", async () => {
+  it("maximize button maximizes when the window is not maximized", async () => {
+    mockIsMaximized.mockResolvedValue(false);
     render(<WindowControls />);
     await userEvent.click(screen.getByTitle("Maximize"));
-    expect(mockToggleMaximize).toHaveBeenCalledOnce();
+    expect(mockMaximize).toHaveBeenCalledOnce();
+    expect(mockUnmaximize).not.toHaveBeenCalled();
   });
 
   it("close button calls win.close()", async () => {
diff --git a/src/__tests__/WindowState.test.ts b/src/__tests__/WindowState.test.ts
new file mode 100644
index 0000000..7f33b94
--- /dev/null
+++ b/src/__tests__/WindowState.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { nextWindowState, sameWindowState } from "../lib/windowState";
+import type { WindowState } from "../types";
+
+const floating: WindowState = { x: 2200, y: 100, w: 1400, h: 900, maximized: false };
+
+describe("nextWindowState", () => {
+  it("records a moved window's new rect", () => {
+    expect(nextWindowState(floating, { x: 300, y: 50, w: 1400, h: 900 }, false)).toEqual({
+      x: 300,
+      y: 50,
+      w: 1400,
+      h: 900,
+      maximized: false,
+    });
+  });
+
+  it("skips the write when nothing actually moved", () => {
+    // A drag emits a storm of events that mostly settle back on the same place;
+    // each one would otherwise be a settings.json write.
+    expect(nextWindowState(floating, { x: 2200, y: 100, w: 1400, h: 900 }, false)).toBeNull();
+  });
+
+  it("keeps the last floating rect when the window is maximized", () => {
+    // THE subtle rule. While maximized the outer rect IS the monitor, so storing
+    // it would leave the window with no known "normal" size — un-maximizing after
+    // a restart would then appear to do nothing.
+    const got = nextWindowState(floating, { x: 1920, y: 0, w: 1920, h: 1080 }, true);
+    expect(got).toEqual({ ...floating, maximized: true });
+  });
+
+  it("records the maximized rect on first run, when there is no floating rect yet", () => {
+    // Eldrun opens maximized and the user may never un-maximize it. Storing nothing
+    // would mean never learning which monitor it is on — the whole point of the
+    // feature. The maximized rect is at least a correct monitor hint.
+    const got = nextWindowState(undefined, { x: 1920, y: 0, w: 1920, h: 1080 }, true);
+    expect(got).toEqual({ x: 1920, y: 0, w: 1920, h: 1080, maximized: true });
+  });
+
+  it("self-corrects to a real restore rect the first time the user un-maximizes", () => {
+    const firstRun = nextWindowState(undefined, { x: 1920, y: 0, w: 1920, h: 1080 }, true)!;
+    const restored = nextWindowState(firstRun, { x: 2100, y: 80, w: 1400, h: 900 }, false);
+    expect(restored).toEqual({ x: 2100, y: 80, w: 1400, h: 900, maximized: false });
+  });
+
+  it("still flips the maximized flag even though the rect is held", () => {
+    const got = nextWindowState({ ...floating, maximized: true }, { x: 0, y: 0, w: 1920, h: 1080 }, false);
+    expect(got).toEqual({ x: 0, y: 0, w: 1920, h: 1080, maximized: false });
+  });
+
+  it("refuses a degenerate rect", () => {
+    // Querying mid-map (or a minimized window on some WMs) reports 0x0; persisting
+    // it would produce an invisible window next launch.
+    expect(nextWindowState(undefined, { x: 0, y: 0, w: 0, h: 900 }, false)).toBeNull();
+    expect(nextWindowState(undefined, { x: 0, y: 0, w: 1400, h: 0 }, false)).toBeNull();
+  });
+});
+
+describe("sameWindowState", () => {
+  it("compares every field, maximized included", () => {
+    expect(sameWindowState(floating, { ...floating })).toBe(true);
+    expect(sameWindowState(floating, { ...floating, maximized: true })).toBe(false);
+    expect(sameWindowState(floating, { ...floating, x: 1 })).toBe(false);
+  });
+});
diff --git a/src/__tests__/YamlGrid.test.ts b/src/__tests__/YamlGrid.test.ts
new file mode 100644
index 0000000..c0876f1
--- /dev/null
+++ b/src/__tests__/YamlGrid.test.ts
@@ -0,0 +1,186 @@
+/**
+ * The YAML grid model (#yaml-grid) — the pure detection + layout that turns a
+ * collection of like-shaped records into rows × columns.
+ *
+ * The load-bearing properties pinned here: a grid is only offered for genuinely
+ * tabular data (a flat config map is not a grid); columns are the union of the
+ * records' keys; a missing key is an editable empty cell, not a hidden one; and —
+ * because the grid is a view on the text like the tree — every edit it delegates
+ * to `lib/viewers/yaml` leaves the file's comments and untouched bytes intact.
+ */
+import { describe, it, expect } from "vitest";
+import { parseYaml, setValue, addChild, deleteNode, literalFor } from "../lib/viewers/yaml";
+import {
+  parseGridDoc,
+  gridModelFor,
+  gridCandidates,
+  hasGrid,
+  hasCards,
+  isContainer,
+  cellKind,
+  nestedLabel,
+} from "../lib/viewers/yamlGrid";
+
+const LIST_OF_MAPS = `# services
+- name: web
+  port: 8080
+  enabled: true
+- name: db
+  port: 5432
+- name: cache
+  port: 6379
+  enabled: false
+`;
+
+const MAP_OF_MAPS = `hosts:
+  alpha:
+    ip: 10.0.0.1
+    role: primary
+  beta:
+    ip: 10.0.0.2
+    role: replica
+`;
+
+const FLAT_CONFIG = `name: my-app
+version: 1.2.3
+debug: false
+port: 8080
+`;
+
+describe("grid detection", () => {
+  it("finds a list of mappings and unions its keys as columns", () => {
+    const { candidates } = parseGridDoc(LIST_OF_MAPS);
+    expect(candidates).toHaveLength(1);
+    const model = gridModelFor(candidates[0]);
+    expect(model.shape).toBe("seq");
+    // First-seen order across all rows: name, port, enabled.
+    expect(model.columns).toEqual(["name", "port", "enabled"]);
+    expect(model.rows).toHaveLength(3);
+    expect(model.rows.map((r) => r.header)).toEqual(["0", "1", "2"]);
+  });
+
+  it("aligns cells to columns, leaving a missing key null", () => {
+    const model = gridModelFor(parseGridDoc(LIST_OF_MAPS).candidates[0]);
+    const db = model.rows[1]; // { name: db, port: 5432 } — no `enabled`
+    expect(db.cells[0]?.value).toBe("db");
+    expect(db.cells[1]?.value).toBe("5432");
+    expect(db.cells[2]).toBeNull(); // missing → empty cell
+  });
+
+  it("finds a map of mappings, headed by the outer key", () => {
+    const { candidates } = parseGridDoc(MAP_OF_MAPS);
+    const model = gridModelFor(candidates[0]);
+    expect(model.shape).toBe("map");
+    expect(model.label).toBe("hosts");
+    expect(model.columns).toEqual(["ip", "role"]);
+    expect(model.rows.map((r) => r.header)).toEqual(["alpha", "beta"]);
+  });
+
+  it("does NOT treat a flat config map as a grid", () => {
+    expect(hasGrid(FLAT_CONFIG)).toBe(false);
+    expect(gridCandidates(parseYaml(FLAT_CONFIG))).toHaveLength(0);
+  });
+
+  it("ranks multiple tabular regions largest first", () => {
+    const text = `small:
+  a: {x: 1, y: 2}
+  b: {x: 3, y: 4}
+big:
+  - id: 1
+    a: 1
+    b: 2
+    c: 3
+  - id: 2
+    a: 4
+    b: 5
+    c: 6
+  - id: 3
+    a: 7
+    b: 8
+    c: 9
+`;
+    const cands = gridCandidates(parseYaml(text));
+    expect(cands.length).toBeGreaterThanOrEqual(2);
+    // `big` (3×4) outranks `small` (2×2).
+    expect(gridModelFor(cands[0]).label).toBe("big");
+  });
+
+  it("reports no candidates for an unparseable file", () => {
+    expect(hasGrid("\tbad: indent")).toBe(false);
+  });
+});
+
+describe("card view gate (hasCards)", () => {
+  it("shows cards when a collection nests another", () => {
+    expect(hasCards(LIST_OF_MAPS)).toBe(true); // list of mappings
+    expect(hasCards(MAP_OF_MAPS)).toBe(true); // map of mappings
+    expect(hasCards("root:\n  child:\n    leaf: 1\n")).toBe(true); // deep nesting
+  });
+
+  it("hides cards for a wholly flat file", () => {
+    expect(hasCards(FLAT_CONFIG)).toBe(false); // map of scalars
+    expect(hasCards("- a\n- b\n- c\n")).toBe(false); // list of scalars
+  });
+
+  it("hides cards for an unparseable file", () => {
+    expect(hasCards("\tbad: indent")).toBe(false);
+  });
+
+  it("isContainer distinguishes collections from scalars", () => {
+    const doc = parseYaml(MAP_OF_MAPS);
+    const hosts = doc.docs[0].children[0]; // hosts: {…}
+    expect(isContainer(hosts)).toBe(true);
+    const ip = hosts.children[0].children[0]; // alpha.ip
+    expect(isContainer(ip)).toBe(false);
+  });
+});
+
+describe("cell kinds", () => {
+  it("classifies scalar, empty, nested and locked cells", () => {
+    const text = `- name: web
+  meta: {a: 1}
+- name: db
+`;
+    const model = gridModelFor(parseGridDoc(text).candidates[0]);
+    // columns: name, meta
+    const web = model.rows[0];
+    const db = model.rows[1];
+    expect(cellKind(web.cells[0], web.map)).toBe("scalar"); // name: web
+    expect(cellKind(web.cells[1], web.map)).toBe("nested"); // meta: {a: 1}
+    expect(cellKind(db.cells[1], db.map)).toBe("empty"); // db has no meta
+    expect(nestedLabel(web.cells[1]!)).toBe("{ 1 }");
+  });
+});
+
+describe("grid edits are text splices (view on the text)", () => {
+  it("edits a scalar cell, keeping the file's comment and other bytes", () => {
+    const doc = parseYaml(LIST_OF_MAPS);
+    const model = gridModelFor(gridCandidates(doc)[0]);
+    const portCell = model.rows[0].cells[1]!; // web.port = 8080
+    const next = setValue(LIST_OF_MAPS, doc, portCell, "9090");
+    expect(next).toContain("port: 9090");
+    expect(next).toContain("# services"); // the comment survives
+    expect(next).toContain("name: db"); // untouched rows survive
+    expect(next).not.toContain("port: 8080");
+  });
+
+  it("fills a missing cell by adding the key to that row's mapping", () => {
+    const doc = parseYaml(LIST_OF_MAPS);
+    const model = gridModelFor(gridCandidates(doc)[0]);
+    const db = model.rows[1]; // no `enabled`
+    const next = addChild(LIST_OF_MAPS, doc, db.map!, "key", "enabled", literalFor("text", "true", false));
+    const reparsed = gridModelFor(gridCandidates(parseYaml(next))[0]);
+    expect(reparsed.rows[1].cells[2]?.value).toBe("true");
+    // The other rows are unchanged.
+    expect(reparsed.rows[0].cells[2]?.value).toBe("true");
+    expect(reparsed.rows[2].cells[2]?.value).toBe("false");
+  });
+
+  it("deletes a whole row", () => {
+    const doc = parseYaml(LIST_OF_MAPS);
+    const model = gridModelFor(gridCandidates(doc)[0]);
+    const next = deleteNode(LIST_OF_MAPS, model.rows[1].map!); // drop `db`
+    const reparsed = gridModelFor(gridCandidates(parseYaml(next))[0]);
+    expect(reparsed.rows.map((r) => r.cells[0]?.value)).toEqual(["web", "cache"]);
+  });
+});
diff --git a/src/__tests__/YamlModel.test.ts b/src/__tests__/YamlModel.test.ts
new file mode 100644
index 0000000..22c0ed7
--- /dev/null
+++ b/src/__tests__/YamlModel.test.ts
@@ -0,0 +1,885 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseYaml,
+  setValue as setValueRaw,
+  renameKey as renameKeyRaw,
+  deleteNode,
+  addChild,
+  addRootEntry,
+  duplicateNode,
+  moveNode,
+  moveNodeTo,
+  setComment,
+  commentOf,
+  canComment,
+  canAddChild,
+  canPasteAfter,
+  copyNode,
+  pasteAfter,
+  isEmptyPlaceholder,
+  isFlow,
+  literalFor,
+  scalarType,
+  isYamlPath,
+  isJsonPath,
+  isTreePath,
+  type YamlNode,
+} from "../lib/viewers/yaml";
+
+// The edits take the parsed doc (it carries the dialect and the indent step); in
+// the tests the doc is always the one the node came from, so bind it here.
+const setValue = (text: string, node: YamlNode, next: string, strict = false) =>
+  setValueRaw(text, parseYaml(text, { strict }), node, next);
+const renameKey = (text: string, node: YamlNode, next: string, strict = false) =>
+  renameKeyRaw(text, parseYaml(text, { strict }), node, next);
+
+/** The node at `path` (keys and indices), from the first document. */
+function at(text: string, path: (string | number)[], strict = false): YamlNode {
+  const doc = parseYaml(text, { strict });
+  expect(doc.error).toBeNull();
+  let node = doc.docs[0];
+  for (const step of path) {
+    const next =
+      typeof step === "number"
+        ? node.children[step]
+        : node.children.find((c) => c.key === step);
+    if (!next) throw new Error(`no node at ${path.join("/")} (missing ${String(step)})`);
+    node = next;
+  }
+  return node;
+}
+
+const CONFIG = `# Server configuration
+server:
+  host: 0.0.0.0   # bind address
+  port: 8080
+  tags:
+    - web
+    - prod
+debug: false
+`;
+
+// A sequence whose items are themselves sequences, written on the dash line.
+const MATRIX = `matrix:
+  - - 1
+    - 2
+  - - 3
+`;
+
+describe("parseYaml", () => {
+  it("reads mappings, sequences and scalar types", () => {
+    const doc = parseYaml(CONFIG);
+    expect(doc.error).toBeNull();
+    expect(doc.docs).toHaveLength(1);
+
+    const root = doc.docs[0];
+    expect(root.kind).toBe("map");
+    expect(root.children.map((c) => c.key)).toEqual(["server", "debug"]);
+
+    const server = at(CONFIG, ["server"]);
+    expect(server.kind).toBe("map");
+    expect(server.children.map((c) => c.key)).toEqual(["host", "port", "tags"]);
+
+    expect(at(CONFIG, ["server", "port"]).value).toBe("8080");
+    expect(scalarType(at(CONFIG, ["server", "port"]))).toBe("number");
+    expect(scalarType(at(CONFIG, ["debug"]))).toBe("boolean");
+
+    const tags = at(CONFIG, ["server", "tags"]);
+    expect(tags.kind).toBe("seq");
+    expect(tags.children.map((c) => c.value)).toEqual(["web", "prod"]);
+    expect(tags.children[0].key).toBeNull();
+  });
+
+  it("keeps a trailing comment out of the value", () => {
+    expect(at(CONFIG, ["server", "host"]).value).toBe("0.0.0.0");
+  });
+
+  it("decodes quoted scalars and remembers their style", () => {
+    const text = `a: "hi \\"there\\""\nb: 'it''s fine'\n`;
+    expect(at(text, ["a"]).value).toBe('hi "there"');
+    expect(at(text, ["a"]).style).toBe("double");
+    expect(at(text, ["b"]).value).toBe("it's fine");
+    expect(at(text, ["b"]).style).toBe("single");
+  });
+
+  it("reads a block scalar's body", () => {
+    const text = `script: |\n  echo one\n  echo two\nafter: 1\n`;
+    const script = at(text, ["script"]);
+    expect(script.style).toBe("block");
+    expect(script.value).toBe("echo one\necho two");
+    expect(script.endLine).toBe(2);
+    expect(at(text, ["after"]).value).toBe("1");
+  });
+
+  it("reads a sequence of mappings written on the dash line", () => {
+    const text = `services:\n  - name: api\n    port: 80\n  - name: web\n    port: 443\n`;
+    const services = at(text, ["services"]);
+    expect(services.children).toHaveLength(2);
+    const first = services.children[0];
+    expect(first.kind).toBe("map");
+    expect(first.children.map((c) => c.key)).toEqual(["name", "port"]);
+    expect(first.children[0].value).toBe("api");
+    // The `name` key shares the dash's line — flagged, so every whole-line edit
+    // splices around the dash instead of taking the line.
+    expect(first.children[0].onDash).toBe(true);
+    expect(first.children[0].deletable).toBe(true);
+    expect(first.children[1].onDash).toBeUndefined();
+  });
+
+  it("reads a sequence nested inline on the dash line", () => {
+    const matrix = at(MATRIX, ["matrix"]);
+    expect(matrix.children).toHaveLength(2);
+
+    const row = matrix.children[0];
+    expect(row.kind).toBe("seq");
+    expect(row.children.map((c) => c.value)).toEqual(["1", "2"]);
+    // The first entry shares the outer dash's line — flagged, so every
+    // whole-line edit splices around the dash instead of taking the line.
+    expect(row.children[0].onDash).toBe(true);
+    expect(row.children[0].deletable).toBe(true);
+    expect(row.children[1].onDash).toBeUndefined();
+
+    expect(at(MATRIX, ["matrix", 1]).children.map((c) => c.value)).toEqual(["3"]);
+  });
+
+  it("nests inline sequences to any depth, and mixes them with mappings", () => {
+    const deep = at("- - - x\n", [0, 0]);
+    expect(deep.kind).toBe("seq");
+    expect(deep.children[0].value).toBe("x");
+
+    const mapped = at("- - name: api\n    port: 80\n", [0, 0]);
+    expect(mapped.kind).toBe("map");
+    expect(mapped.children.map((c) => c.key)).toEqual(["name", "port"]);
+  });
+
+  it("reads a block sequence written at its key's own column", () => {
+    // Valid YAML: a sequence needn't indent past its key. The items sit at the
+    // SAME column as `values:`, and the mapping continues (`cutoff:`) after them.
+    const text = `props:\n  values:\n  - 1\n  - 2\n  - 3\n  cutoff: 1\n`;
+    const doc = parseYaml(text);
+    expect(doc.error).toBeNull();
+    const values = at(text, ["props", "values"]);
+    expect(values.kind).toBe("seq");
+    expect(values.children.map((c) => c.value)).toEqual(["1", "2", "3"]);
+    // The mapping resumes after the same-indent sequence.
+    expect(at(text, ["props", "cutoff"]).value).toBe("1");
+  });
+
+  it("reads a same-column sequence of scalars followed by more keys (the ZINC shape)", () => {
+    const text = `labels:\n  label_type:\n  - induced_cycles\n  - primary\n  min_cycle_length: 6\n`;
+    const lt = at(text, ["labels", "label_type"]);
+    expect(lt.kind).toBe("seq");
+    expect(lt.children.map((c) => c.value)).toEqual(["induced_cycles", "primary"]);
+    expect(at(text, ["labels", "min_cycle_length"]).value).toBe("6");
+  });
+
+  it("keeps a top-level same-column list as the key's value, not a second document", () => {
+    // `models:` then a nested list at column 0 is ONE document (a map whose
+    // `models` is a list of lists), not a map plus an orphaned sequence.
+    const text = `models:\n- - a: 1\n  - b: 2\n`;
+    const doc = parseYaml(text);
+    expect(doc.error).toBeNull();
+    expect(doc.docs).toHaveLength(1);
+    const models = at(text, ["models"]);
+    expect(models.kind).toBe("seq");
+    expect(models.children).toHaveLength(1);
+    expect(models.children[0].kind).toBe("seq");
+    expect(models.children[0].children).toHaveLength(2);
+  });
+
+  it("adds an item to a same-column sequence at that same column", () => {
+    const text = `props:\n  values:\n  - 1\n  - 2\n  cutoff: 1\n`;
+    const doc = parseYaml(text);
+    const values = at(text, ["props", "values"]);
+    const next = addChild(text, doc, values, "item", "", "3");
+    expect(next).toBe(`props:\n  values:\n  - 1\n  - 2\n  - 3\n  cutoff: 1\n`);
+  });
+
+  it("splits multiple documents", () => {
+    const doc = parseYaml(`a: 1\n---\nb: 2\n`);
+    expect(doc.docs).toHaveLength(2);
+    expect(doc.docs[0].children[0].key).toBe("a");
+    expect(doc.docs[1].children[0].key).toBe("b");
+  });
+
+  it("renders anchors and merge keys but refuses to rewrite them", () => {
+    const text = `base: &base\n  a: 1\nchild:\n  <<: *base\n  b: 2\n`;
+    const doc = parseYaml(text);
+    expect(doc.error).toBeNull();
+    const merge = at(text, ["child"]).children[0];
+    expect(merge.key).toBe("<<");
+    expect(merge.editable).toBe(false);
+    // The anchored mapping still parses into real children.
+    expect(at(text, ["base"]).children.map((c) => c.key)).toEqual(["a"]);
+  });
+
+  it("refuses a construct it cannot classify instead of guessing", () => {
+    expect(parseYaml("\tkey: 1\n").error?.message).toMatch(/tabs/i);
+    expect(parseYaml("? complex\n: value\n").error).not.toBeNull();
+  });
+
+  it("infers the file's own indent step", () => {
+    expect(parseYaml(CONFIG).indentStep).toBe(2);
+    expect(parseYaml("a:\n    b: 1\n").indentStep).toBe(4);
+  });
+});
+
+describe("setValue", () => {
+  it("rewrites a scalar in place, keeping its comment and the rest of the file", () => {
+    const node = at(CONFIG, ["server", "host"]);
+    const next = setValue(CONFIG, node, "127.0.0.1");
+    expect(next).toContain("  host: 127.0.0.1   # bind address");
+    expect(next).toContain("# Server configuration");
+    expect(next).toContain("    - prod");
+  });
+
+  it("keeps the author's quoting style", () => {
+    const text = `a: "x"\nb: 'y'\nc: z\n`;
+    expect(setValue(text, at(text, ["a"]), "q")).toBe(`a: "q"\nb: 'y'\nc: z\n`);
+    expect(setValue(text, at(text, ["b"]), "q")).toBe(`a: "x"\nb: 'q'\nc: z\n`);
+    expect(setValue(text, at(text, ["c"]), "q")).toBe(`a: "x"\nb: 'y'\nc: q\n`);
+  });
+
+  it("quotes a plain value that would otherwise change the structure", () => {
+    const text = `a: z\n`;
+    expect(setValue(text, at(text, ["a"]), "key: val")).toBe(`a: "key: val"\n`);
+    expect(setValue(text, at(text, ["a"]), "")).toBe(`a: ""\n`);
+    expect(setValue(text, at(text, ["a"]), "# not a comment")).toBe(`a: "# not a comment"\n`);
+  });
+
+  it("writes a first value into an empty key", () => {
+    const text = `a:\nb: 2\n`;
+    expect(setValue(text, at(text, ["a"]), "1")).toBe(`a: 1\nb: 2\n`);
+  });
+
+  it("rewrites a block scalar's body at its own indent", () => {
+    const text = `script: |\n  echo one\n  echo two\nafter: 1\n`;
+    const next = setValue(text, at(text, ["script"]), "echo three\necho four");
+    expect(next).toBe(`script: |\n  echo three\n  echo four\nafter: 1\n`);
+  });
+
+  it("edits a sequence item", () => {
+    const next = setValue(CONFIG, at(CONFIG, ["server", "tags", 0]), "api");
+    expect(next).toContain("    - api\n    - prod");
+  });
+
+  it("does nothing to a node it cannot rewrite", () => {
+    const text = `child:\n  <<: *base\n`;
+    const merge = at(text, ["child"]).children[0];
+    expect(setValue(text, merge, "nope")).toBe(text);
+  });
+
+  it("edits an item of an inline nested sequence, dash line included", () => {
+    expect(setValue(MATRIX, at(MATRIX, ["matrix", 0, 0]), "9")).toBe(
+      "matrix:\n  - - 9\n    - 2\n  - - 3\n",
+    );
+    expect(setValue(MATRIX, at(MATRIX, ["matrix", 0, 1]), "9")).toBe(
+      "matrix:\n  - - 1\n    - 9\n  - - 3\n",
+    );
+  });
+});
+
+describe("renameKey", () => {
+  it("renames in place and leaves the value alone", () => {
+    const next = renameKey(CONFIG, at(CONFIG, ["server", "port"]), "listen_port");
+    expect(next).toContain("  listen_port: 8080");
+    expect(next).toContain("  host: 0.0.0.0   # bind address");
+  });
+
+  it("quotes a key that needs it", () => {
+    const text = `a: 1\n`;
+    expect(renameKey(text, at(text, ["a"]), "we: ird")).toBe(`"we: ird": 1\n`);
+  });
+});
+
+describe("deleteNode", () => {
+  it("removes a key with its whole nested block, and the comment describing it", () => {
+    // The comment above `server` is `server`'s. Left behind, it would come to sit
+    // above `debug` and describe that instead.
+    const next = deleteNode(CONFIG, at(CONFIG, ["server"]));
+    expect(next).toBe("debug: false\n");
+  });
+
+  it("removes one list item", () => {
+    const next = deleteNode(CONFIG, at(CONFIG, ["server", "tags", 0]));
+    expect(next).toContain("  tags:\n    - prod\n");
+  });
+
+  it("deletes a key that shares its list item's line, pulling the next key up", () => {
+    const text = `services:\n  - name: api\n    port: 80\n`;
+    const name = at(text, ["services", 0]).children[0];
+    // The dash is the item's, not the entry's: `port` climbs onto it.
+    expect(deleteNode(text, name)).toBe("services:\n  - port: 80\n");
+    // The item itself deletes fine, block and all.
+    expect(deleteNode(text, at(text, ["services", 0]))).toBe("services:\n");
+  });
+
+  it("leaves a bare dash when the deleted dash-line entry has nothing to pull up", () => {
+    // The only entry: the item stays, empty.
+    expect(deleteNode("- name: a\n", at("- name: a\n", [0]).children[0])).toBe("-\n");
+    // A comment-led sibling keeps its lead run above its own line — pulling the
+    // line up would drag the comment onto the dash.
+    const led = `- name: a\n  # docs\n  port: 1\n`;
+    expect(deleteNode(led, at(led, [0]).children[0])).toBe("-\n  # docs\n  port: 1\n");
+  });
+
+  it("deletes the entry that shares its nested list's dash line", () => {
+    expect(deleteNode(MATRIX, at(MATRIX, ["matrix", 0, 0]))).toBe(
+      "matrix:\n  - - 2\n  - - 3\n",
+    );
+    // Its sibling goes on its own, and the whole row goes with the dash line.
+    expect(deleteNode(MATRIX, at(MATRIX, ["matrix", 0, 1]))).toBe(
+      "matrix:\n  - - 1\n  - - 3\n",
+    );
+    expect(deleteNode(MATRIX, at(MATRIX, ["matrix", 0]))).toBe("matrix:\n  - - 3\n");
+  });
+});
+
+describe("addChild", () => {
+  const add = (text: string, node: YamlNode, kind: "key" | "item", key: string, lit: string) =>
+    addChild(text, parseYaml(text), node, kind, key, lit);
+
+  it("appends a key at the siblings' own indent", () => {
+    const next = add(CONFIG, at(CONFIG, ["server"]), "key", "workers", "4");
+    expect(next).toContain("  tags:\n    - web\n    - prod\n  workers: 4\ndebug: false");
+  });
+
+  it("appends a list item", () => {
+    const next = add(CONFIG, at(CONFIG, ["server", "tags"]), "item", "", '"eu-west"');
+    expect(next).toContain("    - prod\n    - \"eu-west\"\ndebug: false");
+  });
+
+  it("appends to an inline nested sequence at its own items' column", () => {
+    const next = add(MATRIX, at(MATRIX, ["matrix", 0]), "item", "", "3");
+    expect(next).toBe("matrix:\n  - - 1\n    - 2\n    - 3\n  - - 3\n");
+  });
+
+  it("grows the first child of an empty key, replacing the placeholder", () => {
+    const text = `server:\ndebug: false\n`;
+    expect(add(text, at(text, ["server"]), "key", "port", "80"))
+      .toBe("server:\n  port: 80\ndebug: false\n");
+
+    const nullish = `server: null\n`;
+    expect(add(nullish, at(nullish, ["server"]), "key", "port", "80"))
+      .toBe("server:\n  port: 80\n");
+
+    // An empty `[]`/`{}` is a real (flow) collection, not a placeholder: it grows
+    // children in the style it is written in, rather than being rewritten to block.
+    const emptyList = `tags: []\n`;
+    expect(add(emptyList, at(emptyList, ["tags"]), "item", "", "web"))
+      .toBe("tags: [web]\n");
+
+    const emptyMap = `server: {}\n`;
+    expect(add(emptyMap, at(emptyMap, ["server"]), "key", "host", "local"))
+      .toBe("server: {host: local}\n");
+  });
+
+  it("matches the file's indent step", () => {
+    const text = `a:\n    b:\n`;
+    const next = add(text, at(text, ["a", "b"]), "key", "c", "2");
+    expect(next).toBe("a:\n    b:\n        c: 2\n");
+  });
+
+  it("refuses to hang a child off a key that already holds a value", () => {
+    const text = `a: 1\n`;
+    expect(add(text, at(text, ["a"]), "key", "b", "2")).toBe(text);
+  });
+
+  it("only offers the children a node can actually take", () => {
+    expect(canAddChild(at(CONFIG, ["server"]), "key")).toBe(true);
+    expect(canAddChild(at(CONFIG, ["server"]), "item")).toBe(false);
+    expect(canAddChild(at(CONFIG, ["server", "tags"]), "item")).toBe(true);
+    // A key that already holds a value is not a place to hang children.
+    expect(canAddChild(at(CONFIG, ["server", "port"]), "key")).toBe(false);
+    expect(isEmptyPlaceholder(at("a:\n", ["a"]))).toBe(true);
+    expect(isEmptyPlaceholder(at("a: 1\n", ["a"]))).toBe(false);
+  });
+
+  it("grows a placeholder inside flow into a flow collection, in place", () => {
+    // The bug this guards: a flow node has no column (`indent` is -1), so growing it
+    // as a block spliced a line at column -1 into the middle of the brackets and tore
+    // the collection open. Every `null` in a JSON file is one of these.
+    const flowNull = `service: {name: null}\n`;
+    expect(add(flowNull, at(flowNull, ["service", "name"]), "item", "", "x"))
+      .toBe("service: {name: [x]}\n");
+    expect(add(flowNull, at(flowNull, ["service", "name"]), "key", "first", "api"))
+      .toBe("service: {name: {first: api}}\n");
+
+    // An empty value has no token to replace — the collection splices in after the `:`.
+    const flowEmpty = `service: {name: , port: 1}\n`;
+    expect(add(flowEmpty, at(flowEmpty, ["service", "name"]), "item", "", "x"))
+      .toBe("service: {name: [x], port: 1}\n");
+
+    const flowSeq = `hosts: [a, null]\n`;
+    expect(add(flowSeq, at(flowSeq, ["hosts", 1]), "item", "", "x")).toBe("hosts: [a, [x]]\n");
+  });
+
+  it("adds a mapping ITEM when a list is given a key", () => {
+    // A list of mappings is grown by adding a key to the list — not by adding an
+    // empty container and then filling it.
+    const text = `services:\n  - name: api\n    port: 80\n`;
+    expect(add(text, at(text, ["services"]), "key", "name", "web"))
+      .toBe("services:\n  - name: api\n    port: 80\n  - name: web\n");
+    expect(canAddChild(at(text, ["services"]), "key")).toBe(true);
+
+    // In flow, the same thing in the collection's own style.
+    const flow = `services: [{name: api}]\n`;
+    expect(add(flow, at(flow, ["services"]), "key", "name", "web"))
+      .toBe("services: [{name: api}, {name: web}]\n");
+  });
+
+  it("seeds an empty file", () => {
+    expect(addRootEntry("", "key", "name", '"eldrun"')).toBe('name: "eldrun"\n');
+    expect(addRootEntry("# just a comment\n", "item", "", "first")).toBe(
+      "# just a comment\n- first\n",
+    );
+  });
+});
+
+describe("literalFor", () => {
+  it("writes the type the user picked", () => {
+    expect(literalFor("text", "hello")).toBe("hello");
+    // A string that would read back as a number/bool/null gets quoted — that is
+    // what makes "no" the string "no".
+    expect(literalFor("text", "no")).toBe('"no"');
+    expect(literalFor("text", "8080")).toBe('"8080"');
+    expect(literalFor("number", "8080")).toBe("8080");
+    expect(literalFor("boolean", "true")).toBe("true");
+    expect(literalFor("null", "")).toBe("null");
+    expect(literalFor("map", "")).toBe("{}");
+    expect(literalFor("seq", "")).toBe("[]");
+  });
+});
+
+describe("moveNode", () => {
+  it("reorders list items, block and all", () => {
+    const text = `services:\n  - name: api\n    port: 80\n  - name: web\n    port: 443\n`;
+    const services = at(text, ["services"]);
+    const next = moveNode(text, services.children, services.children[1], -1);
+    expect(next).toBe(
+      "services:\n  - name: web\n    port: 443\n  - name: api\n    port: 80\n",
+    );
+  });
+
+  it("reorders mapping keys, and a comment travels with the key it describes", () => {
+    // `# about b` sits directly above `b`, so it is b's — reordering must carry it,
+    // or the two keys would swap descriptions behind the author's back.
+    const text = `# about a\na: 1\n# about b\nb: 2\n`;
+    const root = parseYaml(text).docs[0];
+    expect(moveNode(text, root.children, root.children[0], 1)).toBe(
+      "# about b\nb: 2\n# about a\na: 1\n",
+    );
+  });
+
+  it("moves a node straight to a distant sibling, in one edit", () => {
+    const text = `a: 1\nb: 2\nc: 3\nd: 4\n`;
+    const root = parseYaml(text).docs[0];
+    expect(moveNodeTo(text, root.children, root.children[3], 0)).toBe("d: 4\na: 1\nb: 2\nc: 3\n");
+    expect(moveNodeTo(text, root.children, root.children[0], 2)).toBe("b: 2\nc: 3\na: 1\nd: 4\n");
+    // Dropping a node on itself is not an edit.
+    expect(moveNodeTo(text, root.children, root.children[1], 1)).toBe(text);
+  });
+
+  it("does nothing at the ends", () => {
+    const root = parseYaml(CONFIG).docs[0];
+    expect(moveNode(CONFIG, root.children, root.children[0], -1)).toBe(CONFIG);
+    expect(moveNode(CONFIG, root.children, root.children[1], 1)).toBe(CONFIG);
+  });
+
+  it("hands the dash over when first place changes hands", () => {
+    // In `- name: a`, `name` shares the item's dash line; a reorder into or out
+    // of first place moves the entry and re-homes the `- ` prefix.
+    const text = `- name: a\n  port: 1\n  host: x\n`;
+    const item = at(text, [0]);
+    // `host` (index 2) dropped onto `name` (index 0): host takes the dash.
+    expect(moveNodeTo(text, item.children, item.children[2], 0)).toBe(
+      `- host: x\n  name: a\n  port: 1\n`,
+    );
+    // `name` moved off the dash line: `port` takes the dash.
+    expect(moveNodeTo(text, item.children, item.children[0], 1)).toBe(
+      `- port: 1\n  name: a\n  host: x\n`,
+    );
+    // Dropping onto `port` (index 1) leaves the dash line alone.
+    expect(moveNodeTo(text, item.children, item.children[2], 1)).toBe(
+      `- name: a\n  host: x\n  port: 1\n`,
+    );
+  });
+
+  it("keeps a trailing comment with the dash-line entry it moves, and a lead above the dash", () => {
+    // The moved entry's own `#` travels with it off the dash line…
+    const noted = `- name: a  # who\n  port: 1\n`;
+    expect(moveNodeTo(noted, at(noted, [0]).children, at(noted, [0]).children[0], 1)).toBe(
+      `- port: 1\n  name: a  # who\n`,
+    );
+    // …and an entry moved ONTO the dash line keeps its lead run above it — the
+    // placement an item's prose already uses.
+    const led = `- name: a\n  # p docs\n  port: 1\n`;
+    expect(moveNodeTo(led, at(led, [0]).children, at(led, [0]).children[1], 0)).toBe(
+      `  # p docs\n- port: 1\n  name: a\n`,
+    );
+  });
+
+  it("hands the outer dash over inside a nested sequence", () => {
+    expect(
+      moveNodeTo(MATRIX, at(MATRIX, ["matrix", 0]).children, at(MATRIX, ["matrix", 0, 1]), 0),
+    ).toBe("matrix:\n  - - 2\n    - 1\n  - - 3\n");
+  });
+});
+
+describe("duplicateNode", () => {
+  it("appends a verbatim copy of a block list item", () => {
+    const text = `tags:\n  - web\n  - prod\n`;
+    const last = at(text, ["tags", 1]);
+    expect(duplicateNode(text, last)).toBe(`tags:\n  - web\n  - prod\n  - prod\n`);
+  });
+
+  it("copies a whole mapping item, nested block and all", () => {
+    const text = `items:\n  - name: a\n    port: 1\n  - name: b\n    port: 2\n`;
+    const last = at(text, ["items", 1]);
+    expect(duplicateNode(text, last)).toBe(
+      `items:\n  - name: a\n    port: 1\n  - name: b\n    port: 2\n  - name: b\n    port: 2\n`,
+    );
+  });
+
+  it("duplicates a dash-line entry below it, without the dash", () => {
+    // The `- ` prefix is the item's, not the entry's — the copy gets spaces.
+    expect(duplicateNode("- - a\n", at("- - a\n", [0, 0]))).toBe("- - a\n  - a\n");
+  });
+});
+
+describe("comments", () => {
+  const comment = (text: string, node: YamlNode, next: string, strict = false) =>
+    setComment(text, parseYaml(text, { strict }), node, next);
+
+  it("reads a comment written behind the value, and one written above the key", () => {
+    expect(commentOf(at(CONFIG, ["server", "host"]))).toBe("bind address");
+    expect(commentOf(at(CONFIG, ["server"]))).toBe("Server configuration");
+    expect(commentOf(at(CONFIG, ["debug"]))).toBe("");
+  });
+
+  it("only claims the prose that is unambiguously about it", () => {
+    // A blank line, or a comment at another indent, ends the run — so a key does not
+    // adopt the section header two entries up.
+    const text = `# section\n\na: 1\nb:\n  # about c\n  c: 2\n`;
+    expect(commentOf(at(text, ["a"]))).toBe("");
+    expect(commentOf(at(text, ["b", "c"]))).toBe("about c");
+    // A multi-line run above a key is all of it.
+    const run = `# one\n# two\na: 1\n`;
+    expect(commentOf(at(run, ["a"]))).toBe("one\ntwo");
+  });
+
+  it("writes where the author already wrote, and behind the value when there is none", () => {
+    // Behind stays behind.
+    expect(comment(CONFIG, at(CONFIG, ["server", "host"]), "the address to bind"))
+      .toContain("  host: 0.0.0.0   # the address to bind\n");
+    // Above stays above, at the key's own indent.
+    expect(comment(CONFIG, at(CONFIG, ["server"]), "How the server listens"))
+      .toBe(CONFIG.replace("# Server configuration", "# How the server listens"));
+    // A key with no comment gets one behind — it adds no line, so it disturbs nothing.
+    expect(comment(CONFIG, at(CONFIG, ["debug"]), "verbose logs"))
+      .toContain("debug: false  # verbose logs\n");
+  });
+
+  it("comments a container, a list item and a nested list", () => {
+    expect(comment(CONFIG, at(CONFIG, ["server", "tags"]), "where it runs"))
+      .toContain("  tags:  # where it runs\n");
+    expect(comment(CONFIG, at(CONFIG, ["server", "tags", 0]), "public"))
+      .toContain("    - web  # public\n");
+    expect(comment(MATRIX, at(MATRIX, ["matrix", 0, 1]), "second"))
+      .toBe("matrix:\n  - - 1\n    - 2  # second\n  - - 3\n");
+  });
+
+  it("comments a mapping list item above its dash line, not behind the first key", () => {
+    // `- name: api` — a comment behind the dash line would belong to `name`, so
+    // the whole item is documented on the line above it instead.
+    const text = `services:\n  - name: api\n    port: 80\n  - name: web\n    port: 443\n`;
+    const item = at(text, ["services", 0]);
+    expect(canAddChild(item, "key")).toBe(true); // it's a mapping item
+    const commented = comment(text, item, "the API service");
+    expect(commented).toBe(
+      `services:\n  # the API service\n  - name: api\n    port: 80\n  - name: web\n    port: 443\n`,
+    );
+    // It reads back as the item's own comment, and clears back to the original.
+    const item2 = at(commented, ["services", 0]);
+    expect(commentOf(item2)).toBe("the API service");
+    expect(comment(commented, item2, "")).toBe(text);
+  });
+
+  it("comments a nested-sequence list item above its dash line", () => {
+    // `- - 1` — the outer item is a sequence written on the dash line.
+    const item = at(MATRIX, ["matrix", 0]);
+    expect(comment(MATRIX, item, "first row")).toBe(
+      "matrix:\n  # first row\n  - - 1\n    - 2\n  - - 3\n",
+    );
+  });
+
+  it("clears a comment without leaving the whitespace behind it", () => {
+    expect(comment(CONFIG, at(CONFIG, ["server", "host"]), "")).toContain("  host: 0.0.0.0\n");
+    expect(comment(CONFIG, at(CONFIG, ["server"]), "")).toBe(
+      CONFIG.replace("# Server configuration\n", ""),
+    );
+  });
+
+  it("refuses where a comment cannot go: JSON, and inside a flow collection", () => {
+    const json = `{"a": 1}\n`;
+    const doc = parseYaml(json, { strict: true });
+    expect(canComment(doc, at(json, ["a"], true))).toBe(false);
+    expect(comment(json, at(json, ["a"], true), "nope", true)).toBe(json);
+
+    // A `#` inside `{…}` would swallow the closing bracket and everything up to it.
+    const flow = `service: { name: api }\n`;
+    expect(canComment(parseYaml(flow), at(flow, ["service", "name"]))).toBe(false);
+    expect(comment(flow, at(flow, ["service", "name"]), "nope")).toBe(flow);
+    // The collection itself sits on a block line, so it can take one — behind the `}`.
+    expect(comment(flow, at(flow, ["service"]), "the api")).toBe(
+      "service: { name: api }  # the api\n",
+    );
+  });
+});
+
+describe("round-trip", () => {
+  it("leaves everything it did not touch byte-identical", () => {
+    const text = CONFIG;
+    // An edit deep in the file must not reformat the comment, the blank-line
+    // free layout, the quoting, or the trailing newline.
+    const edited = setValue(text, at(text, ["debug"]), "true");
+    expect(edited).toBe(text.replace("debug: false", "debug: true"));
+  });
+
+  it("preserves CRLF line endings", () => {
+    const text = "a: 1\r\nb: 2\r\n";
+    const next = addChild(text, parseYaml(text), parseYaml(text).docs[0], "key", "c", "3");
+    expect(next).toBe("a: 1\r\nb: 2\r\nc: 3\r\n");
+  });
+
+  it("does not add a trailing newline the file did not have", () => {
+    const text = "a: 1";
+    expect(setValue(text, at(text, ["a"]), "2")).toBe("a: 2");
+  });
+});
+
+describe("paths", () => {
+  it("routes .yaml/.yml/.json to the tree, and nothing else", () => {
+    expect(isYamlPath("/p/config.yaml")).toBe(true);
+    expect(isYamlPath("/p/config.yml")).toBe(true);
+    expect(isYamlPath("/p/config.json")).toBe(false);
+    expect(isJsonPath("/p/config.json")).toBe(true);
+    expect(isTreePath("/p/config.json")).toBe(true);
+    expect(isTreePath("/p/config.yml")).toBe(true);
+    expect(isTreePath("/p/main.rs")).toBe(false);
+    expect(isTreePath("/p/yaml")).toBe(false);
+  });
+});
+
+// ── Flow (JSON) syntax ──────────────────────────────────────────────────────
+// The bug this whole layer exists for: a flow collection used to parse as one
+// opaque scalar, so a JSON-formatted file showed a single row reading "{".
+
+const FLOW = `# app
+service: { name: api, port: 8080 }
+hosts: [a, b]
+`;
+
+const SPREAD = `service: {
+  name: api,
+  port: 8080
+}
+`;
+
+describe("flow collections", () => {
+  it("parses an inline flow map and list as real trees", () => {
+    const svc = at(FLOW, ["service"]);
+    expect(svc.kind).toBe("map");
+    expect(isFlow(svc)).toBe(true);
+    expect(svc.children.map((c) => c.key)).toEqual(["name", "port"]);
+    expect(svc.children[1].value).toBe("8080");
+    expect(scalarType(svc.children[1])).toBe("number");
+
+    const hosts = at(FLOW, ["hosts"]);
+    expect(hosts.kind).toBe("seq");
+    expect(hosts.children.map((c) => c.value)).toEqual(["a", "b"]);
+  });
+
+  it("parses a flow collection that spans lines", () => {
+    const svc = at(SPREAD, ["service"]);
+    expect(svc.children.map((c) => c.key)).toEqual(["name", "port"]);
+    expect(svc.endLine).toBe(3);
+  });
+
+  it("parses nested flow, and flow inside a block list", () => {
+    const text = `items:\n  - {id: 1, tags: [x, y]}\n  - {id: 2, tags: []}\n`;
+    const first = at(text, ["items", 0]);
+    expect(first.children.map((c) => c.key)).toEqual(["id", "tags"]);
+    const tags = first.children[1];
+    expect(tags.kind).toBe("seq");
+    expect(tags.children.map((c) => c.value)).toEqual(["x", "y"]);
+    expect(at(text, ["items", 1]).children[1].children).toHaveLength(0);
+  });
+
+  it("edits a value inside flow without disturbing the collection", () => {
+    const next = setValue(FLOW, at(FLOW, ["service", "port"]), "9090");
+    expect(next).toBe(FLOW.replace("port: 8080", "port: 9090"));
+    expect(next).toContain("# app");
+  });
+
+  it("adds inline when the collection is inline, on its own line when it is not", () => {
+    const inline = addChild(FLOW, parseYaml(FLOW), at(FLOW, ["hosts"]), "item", "", "c");
+    expect(inline).toContain("hosts: [a, b, c]");
+
+    const spread = addChild(SPREAD, parseYaml(SPREAD), at(SPREAD, ["service"]), "key", "tls", "true");
+    expect(spread).toBe("service: {\n  name: api,\n  port: 8080,\n  tls: true\n}\n");
+  });
+
+  it("deletes a flow entry with its comma, not leaving a hole", () => {
+    expect(deleteNode(FLOW, at(FLOW, ["hosts", 0]))).toContain("hosts: [b]");
+    expect(deleteNode(FLOW, at(FLOW, ["hosts", 1]))).toContain("hosts: [a]");
+    expect(deleteNode(FLOW, at(FLOW, ["service", "name"]))).toContain("service: { port: 8080 }");
+  });
+
+  it("deletes a whole flow value with its key, lines and all", () => {
+    expect(deleteNode(SPREAD, at(SPREAD, ["service"]))).toBe("");
+  });
+
+  it("reorders flow entries by swapping their spans", () => {
+    const hosts = at(FLOW, ["hosts"]);
+    expect(moveNode(FLOW, hosts.children, hosts.children[1], -1)).toContain("hosts: [b, a]");
+  });
+
+  it("refuses an unclosed collection rather than showing half a tree", () => {
+    expect(parseYaml("a: {b: 1\n").error?.message).toMatch(/never closed/);
+  });
+});
+
+describe("JSON (strict) files", () => {
+  const PKG = `{
+  "name": "app",
+  "version": "1.0.0",
+  "scripts": {"build": "vite"},
+  "keywords": []
+}
+`;
+
+  it("parses a whole JSON document as the tree", () => {
+    const doc = parseYaml(PKG, { strict: true });
+    expect(doc.error).toBeNull();
+    const root = doc.docs[0];
+    expect(root.kind).toBe("map");
+    expect(root.children.map((c) => c.key)).toEqual(["name", "version", "scripts", "keywords"]);
+    expect(at(PKG, ["scripts", "build"], true).value).toBe("vite");
+  });
+
+  it("writes strings and keys quoted, and bare literals bare", () => {
+    const version = at(PKG, ["version"], true);
+    expect(setValue(PKG, version, "2.0.0", true)).toContain('"version": "2.0.0"');
+
+    const doc = parseYaml(PKG, { strict: true });
+    const next = addChild(PKG, doc, at(PKG, ["keywords"], true), "item", "", literalFor("text", "cli", true));
+    expect(next).toContain('"keywords": ["cli"]');
+
+    const withPort = addChild(PKG, doc, doc.docs[0], "key", "port", literalFor("number", "3000", true));
+    expect(withPort).toContain('"keywords": [],\n  "port": 3000\n}');
+
+    expect(renameKey(PKG, at(PKG, ["name"], true), "title", true)).toContain('"title": "app"');
+  });
+
+  it("seeds an empty JSON file with the collection itself", () => {
+    expect(addRootEntry("", "key", "name", literalFor("text", "app", true), true)).toBe(
+      '{"name": "app"}\n',
+    );
+  });
+});
+
+describe("copy & paste (#yaml copy button + paste cursor)", () => {
+  it("captures a map entry dedented, with its trailing comment", () => {
+    const clip = copyNode(CONFIG, at(CONFIG, ["server", "host"]));
+    expect(clip).not.toBeNull();
+    expect(clip!.text).toBe("host: 0.0.0.0   # bind address");
+    expect(clip!.isMapEntry).toBe(true);
+    expect(clip!.inFlow).toBe(false);
+  });
+
+  it("captures a container with its whole block, dedented to column 0", () => {
+    const clip = copyNode(CONFIG, at(CONFIG, ["server", "tags"]));
+    expect(clip!.lines).toEqual(["tags:", "  - web", "  - prod"]);
+    expect(clip!.text).toBe("tags:\n  - web\n  - prod");
+  });
+
+  it("captures a list item as an item, not a mapping entry", () => {
+    const clip = copyNode(CONFIG, at(CONFIG, ["server", "tags", 0]));
+    expect(clip!.text).toBe("- web");
+    expect(clip!.isMapEntry).toBe(false);
+  });
+
+  it("captures the key that shares its item's dash line, without the dash", () => {
+    const LIST = "list:\n  - name: a\n    port: 1\n";
+    const clip = copyNode(LIST, at(LIST, ["list", 0, "name"]))!;
+    // The `- ` prefix is the item's, not the entry's — the clip starts at the key.
+    expect(clip.text).toBe("name: a");
+    expect(clip.isMapEntry).toBe(true);
+  });
+
+  it("gates the paste to containers the entry fits", () => {
+    const entry = copyNode(CONFIG, at(CONFIG, ["server", "port"]))!; // key: value
+    const item = copyNode(CONFIG, at(CONFIG, ["server", "tags", 0]))!; // - web
+
+    // A mapping entry goes after another mapping entry, never after a list item.
+    expect(canPasteAfter(entry, at(CONFIG, ["debug"]), "map")).toBe(true);
+    expect(canPasteAfter(entry, at(CONFIG, ["server", "tags", 1]), "seq")).toBe(false);
+    // A list item goes after another list item, never into a mapping.
+    expect(canPasteAfter(item, at(CONFIG, ["server", "tags", 1]), "seq")).toBe(true);
+    expect(canPasteAfter(item, at(CONFIG, ["debug"]), "map")).toBe(false);
+
+    // Block and flow never mix: a block entry has no place inside `{...}`.
+    const FLOW = "obj: {a: 1, b: 2}\n";
+    expect(canPasteAfter(entry, at(FLOW, ["obj", "b"]), "map")).toBe(false);
+    const flowEntry = copyNode(FLOW, at(FLOW, ["obj", "a"]))!;
+    expect(canPasteAfter(flowEntry, at(CONFIG, ["debug"]), "map")).toBe(false);
+  });
+
+  it("pastes a map entry after another key, re-indented to its column", () => {
+    // From indent 2 (inside server) to indent 0 (top level): the copy lands at
+    // the anchor's column, and every other line stays byte-identical.
+    const clip = copyNode(CONFIG, at(CONFIG, ["server", "port"]))!;
+    const next = pasteAfter(CONFIG, at(CONFIG, ["debug"]), clip);
+    expect(next).toBe(CONFIG.replace("debug: false\n", "debug: false\nport: 8080\n"));
+    expect(parseYaml(next).error).toBeNull();
+  });
+
+  it("pastes a whole container after a deeper key, indenting its block", () => {
+    const clip = copyNode(CONFIG, at(CONFIG, ["server", "tags"]))!;
+    const next = pasteAfter(CONFIG, at(CONFIG, ["server", "host"]), clip);
+    expect(next).toContain(
+      "  host: 0.0.0.0   # bind address\n  tags:\n    - web\n    - prod\n  port: 8080",
+    );
+    expect(parseYaml(next).error).toBeNull();
+  });
+
+  it("pastes a list item into another list, as the anchor's next sibling", () => {
+    const TWO = "a:\n  - one\nb:\n  - two\n";
+    const clip = copyNode(TWO, at(TWO, ["a", 0]))!;
+    const next = pasteAfter(TWO, at(TWO, ["b", 0]), clip);
+    expect(next).toBe("a:\n  - one\nb:\n  - two\n  - one\n");
+  });
+
+  it("pastes into an inline flow collection between commas", () => {
+    const FLOW = "list: [1, 2]\n";
+    const clip = copyNode(FLOW, at(FLOW, ["list", 0]))!;
+    expect(pasteAfter(FLOW, at(FLOW, ["list", 1]), clip)).toBe("list: [1, 2, 1]\n");
+  });
+
+  it("pastes onto its own line in a spread flow (JSON) collection", () => {
+    const PKG = '{\n  "a": 1,\n  "b": 2\n}\n';
+    const clip = copyNode(PKG, at(PKG, ["a"], true))!;
+    const next = pasteAfter(PKG, at(PKG, ["b"], true), clip);
+    expect(next).toBe('{\n  "a": 1,\n  "b": 2,\n  "a": 1\n}\n');
+    expect(parseYaml(next, { strict: true }).error).toBeNull();
+  });
+
+  it("refuses a cross-style paste outright", () => {
+    const FLOW = "obj: {a: 1}\n";
+    const blockClip = copyNode(CONFIG, at(CONFIG, ["server", "port"]))!;
+    expect(pasteAfter(FLOW, at(FLOW, ["obj", "a"]), blockClip)).toBe(FLOW);
+    const flowClip = copyNode(FLOW, at(FLOW, ["obj", "a"]))!;
+    expect(pasteAfter(CONFIG, at(CONFIG, ["debug"]), flowClip)).toBe(CONFIG);
+  });
+});
diff --git a/src/__tests__/YamlViewer.test.tsx b/src/__tests__/YamlViewer.test.tsx
new file mode 100644
index 0000000..112ba20
--- /dev/null
+++ b/src/__tests__/YamlViewer.test.tsx
@@ -0,0 +1,729 @@
+/**
+ * The YAML viewer (#yaml), driven through the real UI: a `.yaml` file opens in the
+ * structure tree, and every tree action writes back into the SAME draft the Source
+ * tab edits and Ctrl+S saves.
+ *
+ * The load-bearing property these tests pin is that the tree edits the file's text
+ * rather than a model of it: an edit made in the tree leaves the file's comments,
+ * quoting and untouched lines byte-identical, and lands in the editor as an
+ * ordinary (dirty, undoable, saveable) change. A tree that re-serialized a parsed
+ * model would pass none of this.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, act, waitFor, fireEvent } from "@testing-library/react";
+
+const { mockInvoke } = vi.hoisted(() => ({ mockInvoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mockInvoke }));
+vi.mock("@tauri-apps/api/event", () => ({
+  emit: vi.fn(() => Promise.resolve()),
+  listen: vi.fn(() => Promise.resolve(() => {})),
+}));
+vi.mock("../stores/windows", () => ({
+  useWindowsStore: { getState: () => ({ openFile: () => Promise.resolve() }) },
+}));
+const { settingsState } = vi.hoisted(() => ({
+  // Autosave off, so a save is an explicit click the test can point at.
+  settingsState: { settings: { autosave: false, viewer_prefs: {} } as Record<string, unknown> },
+}));
+vi.mock("../stores/settings", () => ({
+  useSettingsStore: Object.assign((sel: (s: unknown) => unknown) => sel(settingsState), {
+    getState: () => settingsState,
+  }),
+}));
+vi.mock("../stores/projects", () => {
+  const state = {
+    projects: [{ id: "proj", directory: "/p", local_file: "/p/project.json" }],
+    activeId: "proj",
+  };
+  const useProjectsStore = Object.assign(
+    (sel?: (s: typeof state) => unknown) => (sel ? sel(state) : state),
+    { getState: () => state },
+  );
+  return { useProjectsStore };
+});
+vi.mock("../stores/tabs", () => {
+  const state = {
+    tabs: [] as Record<string, unknown>[],
+    layout: null,
+    addTabToScope: vi.fn(),
+    addTab: vi.fn(),
+    setActive: vi.fn(),
+    removeTab: vi.fn(),
+    setViewerState: vi.fn(),
+    splitWithNewTab: vi.fn(() => null),
+  };
+  const useTabsStore = Object.assign(
+    (sel?: (s: typeof state) => unknown) => (sel ? sel(state) : state),
+    { getState: () => state },
+  );
+  return { useTabsStore, findGroupOfTab: () => null, getDetachedViewerState: () => undefined };
+});
+
+// `tags` is a scalar-only list → the tree shows it as ONE editable comma line.
+// `mounts` is not (an item carries a comment a comma line couldn't keep) → it
+// stays per-item rows, which is what the item-row tests below drive.
+const CONFIG = `# Server configuration
+server:
+  host: 0.0.0.0   # bind address
+  port: 8080
+  tags:
+    - web
+    - prod
+  mounts:
+    - /data  # scratch
+    - /home
+debug: false
+`;
+
+let onDisk = CONFIG;
+
+function setup() {
+  onDisk = CONFIG;
+  mockInvoke.mockImplementation((cmd: string, args: Record<string, unknown> = {}) => {
+    if (cmd === "read_file_text") return Promise.resolve(onDisk);
+    if (cmd === "file_mtime") return Promise.resolve(1000);
+    if (cmd === "write_file_text") {
+      onDisk = args.content as string;
+      return Promise.resolve(null);
+    }
+    // check_syntax: the file is valid, so no validation banner.
+    return Promise.resolve(null);
+  });
+}
+
+/** YAML opens in the Tree view by default; clicking Tree is a harmless no-op that
+ *  also guards these tests against a future default change. */
+async function toTree() {
+  await act(async () => {
+    fireEvent.click(await screen.findByRole("button", { name: "Tree" }));
+  });
+}
+
+async function renderYaml() {
+  vi.resetModules();
+  const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+  await act(async () => {
+    render(<FileViewerPane viewer="yaml" path="/p/config.yaml" projectId="proj" />);
+  });
+  await toTree();
+  await screen.findByRole("button", { name: "Collapse server" });
+}
+
+/** The row element an entry's key/index button sits in. */
+function rowOf(el: HTMLElement): HTMLElement {
+  const row = el.closest(".yaml-row") as HTMLElement | null;
+  expect(row).not.toBeNull();
+  return row!;
+}
+
+/** Save, and return the text that reached the disk. */
+async function saveAndRead(): Promise<string> {
+  await act(async () => {
+    fireEvent.click(screen.getByLabelText("Save"));
+  });
+  await waitFor(() =>
+    expect(mockInvoke).toHaveBeenCalledWith("write_file_text", expect.anything()),
+  );
+  return onDisk;
+}
+
+describe("yaml tree viewer (#yaml)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  it("opens a .yaml file in the tree, not in the editor", async () => {
+    await renderYaml();
+    // Structure, not source: keys are rows, values are inputs.
+    expect(screen.getByRole("button", { name: "Collapse server" })).toBeTruthy();
+    expect((screen.getByLabelText("Value of port") as HTMLInputElement).value).toBe("8080");
+    expect((screen.getByLabelText("Value of host") as HTMLInputElement).value).toBe("0.0.0.0");
+    // The scalar-only list is one comma line; the commented one renders its
+    // items, indexed.
+    expect((screen.getByLabelText("Value of tags") as HTMLInputElement).value).toBe("web, prod");
+    expect((screen.getByLabelText("Value of item 0") as HTMLInputElement).value).toBe("/data");
+  });
+
+  it("edits a value and saves it, leaving the comments and the rest of the file alone", async () => {
+    await renderYaml();
+    const port = screen.getByLabelText("Value of port") as HTMLInputElement;
+    await act(async () => {
+      fireEvent.change(port, { target: { value: "9090" } });
+      fireEvent.keyDown(port, { key: "Enter" });
+    });
+
+    expect(await saveAndRead()).toBe(CONFIG.replace("port: 8080", "port: 9090"));
+  });
+
+  it("adds a key with the type the user picked", async () => {
+    await renderYaml();
+    // "+ key" on the `server` mapping (the other one is the document's own, at
+    // the foot of the tree).
+    await act(async () => {
+      fireEvent.click(screen.getAllByTitle("Add a key under this entry")[0]);
+    });
+    await act(async () => {
+      fireEvent.change(screen.getByLabelText("New key"), { target: { value: "workers" } });
+      fireEvent.change(screen.getByLabelText("Value type"), { target: { value: "number" } });
+      fireEvent.change(screen.getByLabelText("New value"), { target: { value: "4" } });
+      fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    });
+
+    const saved = await saveAndRead();
+    expect(saved).toContain("    - /home\n  workers: 4\ndebug: false");
+    expect(saved).toContain("# Server configuration");
+  });
+
+  it("adds a list item", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByTitle("Add an item to this list"));
+    });
+    await act(async () => {
+      fireEvent.change(screen.getByLabelText("New value"), { target: { value: "/srv" } });
+      fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    });
+
+    expect(await saveAndRead()).toContain("    - /home\n    - /srv\n");
+  });
+
+  it("adds a copy of the last list item when Copy last is chosen", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByTitle("Add an item to this list"));
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Copy last" }));
+    });
+    // The last mount (`/home`) is duplicated verbatim, at the list's own indent.
+    expect(await saveAndRead()).toContain("    - /data  # scratch\n    - /home\n    - /home\n");
+  });
+
+  it("shows a scalar-only list as one editable comma line, not as item rows", async () => {
+    await renderYaml();
+    const tags = screen.getByLabelText("Value of tags") as HTMLInputElement;
+    expect(tags.value).toBe("web, prod");
+    // The line IS the list: no count on its row, no per-item rows of its own
+    // (the only item rows on screen are `mounts`', which stays rows).
+    expect(tags.closest(".yaml-row")!.querySelector(".yaml-count")).toBeNull();
+    expect(screen.queryByLabelText("Value of item 2")).toBeNull();
+
+    // Editing the line edits the list — items land as ordinary block lines.
+    await act(async () => {
+      fireEvent.change(tags, { target: { value: "web, staging, prod" } });
+      fireEvent.keyDown(tags, { key: "Enter" });
+    });
+    expect(await saveAndRead()).toContain("  tags:\n    - web\n    - staging\n    - prod\n");
+  });
+
+  it("edits a flow list on its comma line, keeping its style and its quoting", async () => {
+    onDisk = 'tags: ["web", prod]  # labels\n';
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/flowlist.yaml" projectId="proj" />);
+    });
+    await toTree();
+
+    const tags = (await screen.findByLabelText("Value of tags")) as HTMLInputElement;
+    expect(tags.value).toBe("web, prod");
+    await act(async () => {
+      fireEvent.change(tags, { target: { value: "prod, web, extra" } });
+      fireEvent.keyDown(tags, { key: "Enter" });
+    });
+
+    // Stays flow; `web` keeps the quotes it was written with, the new value is
+    // written as typed, and the comment behind the bracket survives.
+    expect(await saveAndRead()).toBe('tags: [prod, "web", extra]  # labels\n');
+  });
+
+  it("gives an open list a persistent add row at its end, not just a hover action", async () => {
+    await renderYaml();
+    const addItem = screen.getByTitle("Add an item to this list");
+    // It lives in the always-visible add row at the end of the list's children,
+    // not in the header row's hover-only actions.
+    expect(addItem.closest(".yaml-row-add")).not.toBeNull();
+    expect(addItem.closest(".yaml-actions")).toBeNull();
+  });
+
+  it("renames a key without touching its value or its comment", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: /^host/ }));
+    });
+    const input = screen.getByLabelText("Rename key host") as HTMLInputElement;
+    await act(async () => {
+      fireEvent.change(input, { target: { value: "bind" } });
+      fireEvent.keyDown(input, { key: "Enter" });
+    });
+
+    expect(await saveAndRead()).toContain("  bind: 0.0.0.0   # bind address");
+  });
+
+  it("shows a key's comment on the key, and writes an edited one back", async () => {
+    await renderYaml();
+    // Hovering the key is what surfaces it — on the key itself, both ways round: the
+    // comment behind `host`, and the one written above `server`.
+    expect(screen.getByRole("button", { name: /^host/ }).title).toBe("# bind address");
+    expect(screen.getByRole("button", { name: /^server/ }).title).toBe("# Server configuration");
+    // `port` has none, so it keeps the rename hint.
+    expect(screen.getByRole("button", { name: /^port/ }).title).toBe("Click to rename this key");
+
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Comment on port"));
+    });
+    const input = screen.getByLabelText("Comment on port") as HTMLInputElement;
+    await act(async () => {
+      fireEvent.change(input, { target: { value: "the port to listen on" } });
+      fireEvent.keyDown(input, { key: "Enter" });
+    });
+
+    const saved = await saveAndRead();
+    expect(saved).toContain("  port: 8080  # the port to listen on\n");
+    // Written behind the value, so nothing else on the file moved.
+    expect(saved).toContain("  host: 0.0.0.0   # bind address\n");
+  });
+
+  it("adds a mapping item when a list is given a key", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByTitle("Add an item that is a mapping (- key: value)"));
+    });
+    await act(async () => {
+      fireEvent.change(screen.getByLabelText("New key"), { target: { value: "name" } });
+      fireEvent.change(screen.getByLabelText("New value"), { target: { value: "eu" } });
+      fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    });
+
+    expect(await saveAndRead()).toContain("    - /home\n    - name: eu\ndebug: false");
+  });
+
+  it("reorders siblings by dragging one onto another", async () => {
+    await renderYaml();
+    // Drag `item 0` (/data) down onto `item 1` (/home). The rows report no geometry
+    // in jsdom, so the drop lands on the last row whose top the pointer has passed —
+    // which with every rect at 0 is the last sibling, i.e. exactly this move.
+    const grip = screen.getByLabelText("Reorder item 0");
+    await act(async () => {
+      fireEvent.pointerDown(grip, { pointerId: 1 });
+      fireEvent.pointerMove(grip, { pointerId: 1, clientY: 200 });
+      fireEvent.pointerUp(grip, { pointerId: 1 });
+    });
+
+    // The item's comment travels with it.
+    expect(await saveAndRead()).toContain("  mounts:\n    - /home\n    - /data  # scratch\n");
+  });
+
+  it("deletes an entry with everything under it, comment included", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Delete server"));
+    });
+
+    // "# Server configuration" is `server`'s comment — left behind, it would end up
+    // sitting above `debug` and describing that instead.
+    expect(await saveAndRead()).toBe("debug: false\n");
+  });
+
+  it("reorders list items", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Move item 1 up"));
+    });
+
+    expect(await saveAndRead()).toContain("  mounts:\n    - /home\n    - /data  # scratch\n");
+  });
+
+  it("shows the same text in Source, and a tree edit is an ordinary undo step", async () => {
+    await renderYaml();
+    const port = screen.getByLabelText("Value of port") as HTMLInputElement;
+    await act(async () => {
+      fireEvent.change(port, { target: { value: "9090" } });
+      fireEvent.keyDown(port, { key: "Enter" });
+    });
+
+    // Source shows the tree's edit — one draft, two views.
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Source" }));
+    });
+    const textarea = (await screen.findByRole("textbox")) as HTMLTextAreaElement;
+    expect(textarea.value).toContain("port: 9090");
+
+    // And the edit undoes like a typed one.
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Undo"));
+    });
+    expect((screen.getByRole("textbox") as HTMLTextAreaElement).value).toContain("port: 8080");
+  });
+
+  it("renders a JSON-formatted .yml as a tree, not as one opaque `{` row", async () => {
+    // The regression this whole flow layer exists for: a flow collection spread
+    // over lines used to parse as a single un-editable scalar whose text was the
+    // opening brace.
+    onDisk = "# app\nservice: {\n  name: api,\n  port: 8080\n}\n";
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/flow.yaml" projectId="proj" />);
+    });
+    await toTree();
+
+    const port = (await screen.findByLabelText("Value of port")) as HTMLInputElement;
+    expect(port.value).toBe("8080");
+    await act(async () => {
+      fireEvent.change(port, { target: { value: "9090" } });
+      fireEvent.keyDown(port, { key: "Enter" });
+    });
+
+    // The edit lands inside the flow collection; the layout and comment survive.
+    expect(await saveAndRead()).toBe("# app\nservice: {\n  name: api,\n  port: 9090\n}\n");
+  });
+
+  it("edits a .json file in the same tree, writing the strict dialect", async () => {
+    onDisk = '{\n  "name": "app",\n  "keywords": []\n}\n';
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/package.json" projectId="proj" />);
+    });
+    await toTree();
+
+    // A list item added to a JSON file comes out quoted — JSON has no plain scalars.
+    await act(async () => {
+      fireEvent.click(await screen.findByTitle("Add an item to this list"));
+    });
+    await act(async () => {
+      fireEvent.change(screen.getByLabelText("New value"), { target: { value: "cli" } });
+      fireEvent.click(screen.getByRole("button", { name: "Add" }));
+    });
+
+    expect(await saveAndRead()).toBe('{\n  "name": "app",\n  "keywords": ["cli"]\n}\n');
+  });
+
+  it("marks a container's whole substructure while its row is hovered", async () => {
+    await renderYaml();
+    const serverRow = rowOf(screen.getByRole("button", { name: /^server/ }));
+    await act(async () => {
+      fireEvent.mouseOver(serverRow);
+    });
+    // Every descendant row is marked, to full depth (mounts' items are two down)…
+    expect(rowOf(screen.getByLabelText("Value of port")).className).toContain("yaml-row-marked");
+    expect(rowOf(screen.getByLabelText("Value of item 0")).className).toContain(
+      "yaml-row-marked",
+    );
+    // …and a sibling outside the block is not.
+    expect(rowOf(screen.getByRole("button", { name: /^debug/ })).className).not.toContain(
+      "yaml-row-marked",
+    );
+
+    await act(async () => {
+      fireEvent.mouseOut(serverRow);
+    });
+    expect(rowOf(screen.getByLabelText("Value of port")).className).not.toContain(
+      "yaml-row-marked",
+    );
+  });
+
+  it("tints the substructure in danger while a container's delete is hovered", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.mouseOver(screen.getByLabelText("Delete server"));
+    });
+    // Everything tinted is what the × will take.
+    expect(rowOf(screen.getByLabelText("Value of port")).className).toContain(
+      "yaml-row-marked-del",
+    );
+    expect(rowOf(screen.getByLabelText("Value of item 0")).className).toContain(
+      "yaml-row-marked-del",
+    );
+  });
+
+  it("tints the substructure with the accent while a container's copy is hovered", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.mouseOver(screen.getByLabelText("Copy server"));
+    });
+    // Everything tinted is what the ⧉ will capture — the whole entry, not one row.
+    expect(rowOf(screen.getByLabelText("Value of port")).className).toContain(
+      "yaml-row-marked-act",
+    );
+    expect(rowOf(screen.getByLabelText("Value of item 0")).className).toContain(
+      "yaml-row-marked-act",
+    );
+  });
+
+  it("colors the comma line's entries as their own rows would", async () => {
+    onDisk = 'mix: ["8080", 9090, true, web]\n';
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/mix.yaml" projectId="proj" />);
+    });
+    await toTree();
+
+    const input = (await screen.findByLabelText("Value of mix")) as HTMLInputElement;
+    const mirror = input.closest(".yaml-list-field")!.querySelector(".yaml-list-mirror")!;
+    const tone = (cls: string) =>
+      Array.from(mirror.querySelectorAll(`.yaml-val-${cls}`)).map((s) => s.textContent?.trim());
+    // The quoted "8080" is toned by its NODE — a string, exactly as its row
+    // would show it — while the bare 9090 is a number.
+    expect(tone("string")).toEqual(["8080", "web"]);
+    expect(tone("number")).toEqual(["9090"]);
+    expect(tone("boolean")).toEqual(["true"]);
+
+    // Typing recolors live: a new bare number reads as one.
+    await act(async () => {
+      fireEvent.change(input, { target: { value: "8080, 9090, true, web, 7" } });
+    });
+    expect(tone("number")).toEqual(["9090", "7"]);
+  });
+
+  it("offers chevrons that glide an overflowing comma line while hovered", async () => {
+    await renderYaml();
+    const tags = screen.getByLabelText("Value of tags") as HTMLInputElement;
+    // No overflow, no chevrons.
+    expect(screen.queryByLabelText("Scroll tags right")).toBeNull();
+
+    // jsdom reports no geometry, so give the input some: content wider than the
+    // field. The scroll listener re-measures and the chevrons appear.
+    Object.defineProperty(tags, "scrollWidth", { value: 400, configurable: true });
+    Object.defineProperty(tags, "clientWidth", { value: 100, configurable: true });
+    await act(async () => {
+      fireEvent.scroll(tags);
+    });
+
+    // At the left edge only the right chevron is live.
+    expect((screen.getByLabelText("Scroll tags left") as HTMLButtonElement).disabled).toBe(true);
+    const right = screen.getByLabelText("Scroll tags right") as HTMLButtonElement;
+    expect(right.disabled).toBe(false);
+
+    // Hovering it glides the content; leaving stops the glide.
+    await act(async () => {
+      fireEvent.mouseOver(right);
+      await new Promise((r) => setTimeout(r, 120));
+      fireEvent.mouseOut(right);
+    });
+    const moved = tags.scrollLeft;
+    expect(moved).toBeGreaterThan(0);
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 60));
+    });
+    expect(tags.scrollLeft).toBe(moved);
+  });
+
+  it("keeps a construct it cannot rewrite out of reach instead of offering a bad edit", async () => {
+    onDisk = "base: &base\n  a: 1\nchild:\n  <<: *base\n";
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/anchors.yaml" projectId="proj" />);
+    });
+    await toTree();
+
+    // The anchored mapping and the merge key both render, but as text with no
+    // input behind them.
+    expect(await screen.findAllByText("source only")).toHaveLength(2);
+    expect(screen.queryByLabelText("Value of <<")).toBeNull();
+  });
+});
+
+describe("copy & paste cursor (#yaml)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  it("copies an entry to the buffer and the system clipboard, and says so", async () => {
+    const writeText = vi.fn(() => Promise.resolve());
+    Object.defineProperty(navigator, "clipboard", { value: { writeText }, configurable: true });
+    await renderYaml();
+
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Copy port"));
+    });
+
+    // The buffer drives the banner; the clipboard gets the entry as text.
+    expect(screen.getByText(/Copied/)).toBeTruthy();
+    expect(writeText).toHaveBeenCalledWith("port: 8080");
+  });
+
+  it("places the cursor on a compatible row and pastes there", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Copy port"));
+    });
+
+    // Click the `debug` row itself (not one of its controls): the cursor line and
+    // its paste button appear right after it.
+    await act(async () => {
+      fireEvent.click(rowOf(screen.getByRole("button", { name: /^debug/ })));
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "paste port here" }));
+    });
+
+    // Pasted as `debug`'s next sibling at its column; nothing else moved.
+    expect(await saveAndRead()).toBe(CONFIG.replace("debug: false\n", "debug: false\nport: 8080\n"));
+  });
+
+  it("pastes a copied list item after another list item", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Copy item 0"));
+    });
+    await act(async () => {
+      fireEvent.click(rowOf(screen.getByLabelText("Value of item 1")));
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "paste item 0 here" }));
+    });
+
+    expect(await saveAndRead()).toContain(
+      "    - /data  # scratch\n    - /home\n    - /data  # scratch\n",
+    );
+  });
+
+  it("refuses the cursor where the entry does not fit", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Copy port")); // a `key: value` entry
+    });
+
+    // A list item's row can't take a mapping entry: no cursor, no paste button.
+    const itemRow = rowOf(screen.getByLabelText("Value of item 0"));
+    expect(itemRow.className).not.toContain("yaml-row-pastable");
+    await act(async () => {
+      fireEvent.click(itemRow);
+    });
+    expect(screen.queryByRole("button", { name: /^paste/ })).toBeNull();
+  });
+
+  it("Escape clears the cursor and then the buffer", async () => {
+    await renderYaml();
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText("Copy port"));
+    });
+    await act(async () => {
+      fireEvent.click(rowOf(screen.getByRole("button", { name: /^debug/ })));
+    });
+    expect(screen.getByRole("button", { name: "paste port here" })).toBeTruthy();
+
+    await act(async () => {
+      fireEvent.keyDown(window, { key: "Escape" });
+    });
+    expect(screen.queryByRole("button", { name: "paste port here" })).toBeNull();
+    expect(screen.queryByText(/Copied/)).toBeNull();
+  });
+});
+
+describe("card view (#yaml-grid)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setup();
+  });
+
+  async function renderCards() {
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/config.yaml" projectId="proj" />);
+    });
+    // YAML opens in Tree now — switch to Cards first. The grid is a drill
+    // navigation, not a recursive nest: the overview shows only the root
+    // "document" card. Open it to reach `server`'s own level, which renders
+    // `server`'s scalar fields (host, port) inline.
+    await act(async () => {
+      fireEvent.click(await screen.findByRole("button", { name: "Cards" }));
+    });
+    await act(async () => {
+      fireEvent.click(await screen.findByRole("button", { name: "Open document" }));
+    });
+    await screen.findByLabelText("Value of port");
+  }
+
+  it("opens a structured .yaml file in the tree view by default", async () => {
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/config.yaml" projectId="proj" />);
+    });
+    // Tree is the default: tree rows render, no cards, and the Cards toggle is
+    // present (the file nests something to card) but not active.
+    await screen.findByRole("button", { name: "Collapse server" });
+    expect((screen.getByRole("button", { name: "Tree" }) as HTMLButtonElement).getAttribute("aria-pressed")).toBe("true");
+    expect((screen.getByRole("button", { name: "Cards" }) as HTMLButtonElement).getAttribute("aria-pressed")).toBe("false");
+    expect(document.querySelector(".yaml-row")).not.toBeNull();
+    expect(document.querySelector(".yaml-card")).toBeNull();
+  });
+
+  it("switches to the card view, drilling into records", async () => {
+    await renderCards();
+    // The Cards toggle is now active, and cards (not tree rows) render.
+    expect((screen.getByRole("button", { name: "Cards" }) as HTMLButtonElement).getAttribute("aria-pressed")).toBe("true");
+    expect(document.querySelector(".yaml-card")).not.toBeNull();
+    expect(document.querySelector(".yaml-row")).toBeNull();
+    // A nested collection is a subcard, a scalar is an editable field.
+    expect(screen.getByRole("button", { name: "Open server" })).toBeTruthy();
+    expect((screen.getByLabelText("Value of port") as HTMLInputElement).value).toBe("8080");
+  });
+
+  it("edits a card field back into the file, comments intact", async () => {
+    await renderCards();
+    const port = screen.getByLabelText("Value of port") as HTMLInputElement;
+    await act(async () => {
+      fireEvent.change(port, { target: { value: "9090" } });
+      fireEvent.keyDown(port, { key: "Enter" });
+    });
+    const saved = await saveAndRead();
+    expect(saved).toContain("port: 9090");
+    expect(saved).toContain("# Server configuration");
+  });
+
+  it("reorders sibling cards by dragging one onto another", async () => {
+    await renderCards();
+    // `server` holds subcards `tags` then `mounts` — drill into `server` to reach
+    // them as its own level. Drag `mounts` onto `tags`: with every rect at 0 in
+    // jsdom the pointer lands on the first sibling, so mounts moves up before tags.
+    await act(async () => {
+      fireEvent.click(screen.getByRole("button", { name: "Open server" }));
+    });
+    const grip = await screen.findByLabelText("Reorder mounts");
+    await act(async () => {
+      fireEvent.pointerDown(grip, { pointerId: 1 });
+      fireEvent.pointerMove(grip, { pointerId: 1, clientX: 0, clientY: 0 });
+      fireEvent.pointerUp(grip, { pointerId: 1 });
+    });
+    // mounts (with its item comment) now precedes tags; nothing else moved.
+    expect(await saveAndRead()).toContain(
+      "  port: 8080\n  mounts:\n    - /data  # scratch\n    - /home\n  tags:\n    - web\n    - prod\n",
+    );
+  });
+
+  it("names a list item card by its name-ish field, not #0", async () => {
+    // Root is a map (one key, `services`), so reaching the two service items
+    // means drilling document → services.
+    onDisk = "services:\n  - name: web\n    port: 8080\n  - name: db\n    port: 5432\n";
+    vi.resetModules();
+    const { FileViewerPane } = await import("../components/embed/FileViewerPane");
+    await act(async () => {
+      render(<FileViewerPane viewer="yaml" path="/p/svc.yaml" projectId="proj" />);
+    });
+    // YAML opens in Tree — switch to Cards first.
+    await act(async () => {
+      fireEvent.click(await screen.findByRole("button", { name: "Cards" }));
+    });
+    await act(async () => {
+      fireEvent.click(await screen.findByRole("button", { name: "Open document" }));
+    });
+    await act(async () => {
+      fireEvent.click(await screen.findByRole("button", { name: "Open services" }));
+    });
+    // Cards titled by their `name` field, not `Item N`/`#0`. Neither item has a
+    // nested collection, so its title is static text, not a drill button.
+    expect(await screen.findByText("web")).toBeTruthy();
+    expect(screen.getByText("db")).toBeTruthy();
+    expect(screen.queryByText("Item 1")).toBeNull();
+    expect(screen.queryByText("#0")).toBeNull();
+  });
+});
diff --git a/src/__tests__/agentPrompt.test.ts b/src/__tests__/agentPrompt.test.ts
new file mode 100644
index 0000000..0cdb57b
--- /dev/null
+++ b/src/__tests__/agentPrompt.test.ts
@@ -0,0 +1,89 @@
+/**
+ * Tests for looksLikeDecisionPrompt: classifying a quiet agent tab as blocked on
+ * a decision (a selection menu in its output) vs simply finished — including off
+ * the raw PTY stream, escape codes and all, which is the only view of the screen
+ * available for a tab whose pane has never been opened.
+ */
+import { describe, it, expect } from "vitest";
+import { looksLikeDecisionPrompt, stripAnsi } from "../lib/agentPrompt";
+
+describe("looksLikeDecisionPrompt", () => {
+  it("detects a pointer + numbered choice (Claude/Codex approval menu)", () => {
+    const screen = [
+      "Do you want to make this edit to activity.ts?",
+      "❯ 1. Yes",
+      "  2. No, and tell Claude what to do differently",
+    ].join("\n");
+    expect(looksLikeDecisionPrompt(screen)).toBe(true);
+  });
+
+  it("detects a yes/no numbered menu without the pointer glyph", () => {
+    const screen = ["Allow this command?", "1. Yes  2. No"].join("\n");
+    expect(looksLikeDecisionPrompt(screen)).toBe(true);
+  });
+
+  it("treats a finished turn (no prompt) as not-a-decision", () => {
+    const screen = [
+      "Done. I updated the activity store and the tests pass.",
+      "",
+      "> ",
+    ].join("\n");
+    expect(looksLikeDecisionPrompt(screen)).toBe(false);
+  });
+
+  it("does not fire on ordinary numbered prose", () => {
+    const screen = [
+      "Here are the steps:",
+      "1. Read the file",
+      "2. Edit it",
+      "3. Run the tests",
+    ].join("\n");
+    expect(looksLikeDecisionPrompt(screen)).toBe(false);
+  });
+
+  it("is false for empty text", () => {
+    expect(looksLikeDecisionPrompt("")).toBe(false);
+  });
+
+  it("sees through the escape codes of a raw PTY chunk", () => {
+    // What a colour-coded approval menu actually looks like on the wire: cursor
+    // moves, SGR colour runs, and an OSC title update wrapped around the text.
+    const raw =
+      "\x1b]0;claude\x07\x1b[2J\x1b[H\x1b[1mDo you want to make this edit?\x1b[0m\r\n" +
+      "\x1b[32m❯ \x1b[1m1.\x1b[0m\x1b[32m Yes\x1b[0m\r\n" +
+      "\x1b[2m  2. No, and tell Claude what to do differently\x1b[0m\r\n";
+    expect(looksLikeDecisionPrompt(raw)).toBe(true);
+  });
+
+  it("does not mistake a colour-coded finished turn for a prompt", () => {
+    const raw = "\x1b[32m✔\x1b[0m Done — \x1b[1m12 tests\x1b[0m pass.\r\n\x1b[2m❯ \x1b[0m";
+    expect(looksLikeDecisionPrompt(raw)).toBe(false);
+  });
+
+  it("detects a bare pointer + word binary confirmation (no numbering)", () => {
+    const screen = ["Allow this command?", "❯ Yes", "  No"].join("\n");
+    expect(looksLikeDecisionPrompt(screen)).toBe(true);
+  });
+
+  it("sees through escape codes on a bare pointer + word prompt", () => {
+    const raw =
+      "\x1b[2J\x1b[H\x1b[1mAllow this command?\x1b[0m\r\n" +
+      "\x1b[32m❯ Yes\x1b[0m\r\n\x1b[2m  No\x1b[0m\r\n";
+    expect(looksLikeDecisionPrompt(raw)).toBe(true);
+  });
+
+  it("does not fire on a bare idle input-line cursor", () => {
+    expect(looksLikeDecisionPrompt("❯ ")).toBe(false);
+  });
+});
+
+describe("stripAnsi", () => {
+  it("removes SGR, cursor and OSC sequences but keeps the text", () => {
+    const raw = "\x1b]0;title\x07\x1b[2J\x1b[1;1H\x1b[31mhello\x1b[0m world\x1b(B";
+    expect(stripAnsi(raw)).toBe("hello world");
+  });
+
+  it("leaves plain text untouched", () => {
+    expect(stripAnsi("❯ 1. Yes\n  2. No")).toBe("❯ 1. Yes\n  2. No");
+  });
+});
diff --git a/src/__tests__/agentTask.test.ts b/src/__tests__/agentTask.test.ts
new file mode 100644
index 0000000..b07e2f9
--- /dev/null
+++ b/src/__tests__/agentTask.test.ts
@@ -0,0 +1,50 @@
+/**
+ * Tests for the agentTask store: capturing a per-tab terminal title (the agent
+ * task summary) from a composed `<scope>:<key>` PTY id.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { useAgentTaskStore } from "../stores/agentTask";
+
+describe("useAgentTaskStore", () => {
+  beforeEach(() => {
+    useAgentTaskStore.setState({ titleByTab: {} });
+  });
+
+  it("stores a title under the bare tab key from a composed pty id", () => {
+    useAgentTaskStore.getState().setTabTitle("proj-1:t7", "Refactoring the parser");
+    expect(useAgentTaskStore.getState().titleByTab).toEqual({
+      t7: "Refactoring the parser",
+    });
+  });
+
+  it("splits only on the first colon (keys may themselves contain colons)", () => {
+    useAgentTaskStore.getState().setTabTitle("root:a:b", "hi");
+    expect(useAgentTaskStore.getState().titleByTab["a:b"]).toBe("hi");
+  });
+
+  it("ignores a bare (colon-less) id", () => {
+    useAgentTaskStore.getState().setTabTitle("nope", "x");
+    expect(useAgentTaskStore.getState().titleByTab).toEqual({});
+  });
+
+  it("trims and ignores an empty/whitespace title", () => {
+    useAgentTaskStore.getState().setTabTitle("s:t", "   spaced   ");
+    useAgentTaskStore.getState().setTabTitle("s:u", "   ");
+    expect(useAgentTaskStore.getState().titleByTab).toEqual({ t: "spaced" });
+  });
+
+  it("does not churn state when the title is unchanged", () => {
+    const store = useAgentTaskStore.getState();
+    store.setTabTitle("s:t", "same");
+    const before = useAgentTaskStore.getState().titleByTab;
+    store.setTabTitle("s:t", "same");
+    expect(useAgentTaskStore.getState().titleByTab).toBe(before);
+  });
+
+  it("clears a tab's title", () => {
+    const store = useAgentTaskStore.getState();
+    store.setTabTitle("s:t", "gone soon");
+    store.clearTabTitle("t");
+    expect(useAgentTaskStore.getState().titleByTab).toEqual({});
+  });
+});
diff --git a/src/__tests__/diff.test.ts b/src/__tests__/diff.test.ts
new file mode 100644
index 0000000..4968d02
--- /dev/null
+++ b/src/__tests__/diff.test.ts
@@ -0,0 +1,156 @@
+import { describe, it, expect } from "vitest";
+import { parseUnifiedDiff } from "../lib/viewers/diff";
+
+describe("parseUnifiedDiff", () => {
+  it("parses a two-file git diff with adds/dels/context", () => {
+    const diff = [
+      "diff --git a/foo.txt b/foo.txt",
+      "index 111..222 100644",
+      "--- a/foo.txt",
+      "+++ b/foo.txt",
+      "@@ -1,3 +1,3 @@",
+      " line one",
+      "-old two",
+      "+new two",
+      " line three",
+      "diff --git a/bar.txt b/bar.txt",
+      "index 333..444 100644",
+      "--- a/bar.txt",
+      "+++ b/bar.txt",
+      "@@ -10,2 +10,3 @@",
+      " keep",
+      "+added",
+      " tail",
+      "",
+    ].join("\n");
+
+    const files = parseUnifiedDiff(diff);
+    expect(files).toHaveLength(2);
+
+    expect(files[0].oldPath).toBe("foo.txt");
+    expect(files[0].newPath).toBe("foo.txt");
+    expect(files[0].hunks).toHaveLength(1);
+    expect(files[1].oldPath).toBe("bar.txt");
+    expect(files[1].newPath).toBe("bar.txt");
+    expect(files[1].hunks).toHaveLength(1);
+
+    const body0 = files[0].hunks[0].lines.filter((l) => l.type !== "hunk");
+    expect(body0.map((l) => l.type)).toEqual(["context", "del", "add", "context"]);
+  });
+
+  it("tracks old/new line numbering across a hunk", () => {
+    const diff = [
+      "--- a/x",
+      "+++ b/x",
+      "@@ -1,3 +1,3 @@",
+      " ctx1",
+      "-removed",
+      "+inserted",
+      " ctx2",
+      "",
+    ].join("\n");
+
+    const file = parseUnifiedDiff(diff)[0];
+    const lines = file.hunks[0].lines;
+
+    // hunk header line
+    expect(lines[0].type).toBe("hunk");
+    expect(lines[0].oldNo).toBeNull();
+    expect(lines[0].newNo).toBeNull();
+
+    // " ctx1" → old 1, new 1
+    expect(lines[1]).toMatchObject({ type: "context", oldNo: 1, newNo: 1 });
+    // "-removed" → old 2, new null
+    expect(lines[2]).toMatchObject({ type: "del", oldNo: 2, newNo: null });
+    // "+inserted" → old null, new 2
+    expect(lines[3]).toMatchObject({ type: "add", oldNo: null, newNo: 2 });
+    // " ctx2" → old 3, new 3
+    expect(lines[4]).toMatchObject({ type: "context", oldNo: 3, newNo: 3 });
+
+    // text has the leading marker stripped
+    expect(lines[2].text).toBe("removed");
+    expect(lines[3].text).toBe("inserted");
+    expect(lines[1].text).toBe("ctx1");
+  });
+
+  it("recognises the \\ No newline at end of file marker", () => {
+    const diff = [
+      "--- a/y",
+      "+++ b/y",
+      "@@ -1 +1 @@",
+      "-old",
+      "\\ No newline at end of file",
+      "+new",
+      "\\ No newline at end of file",
+      "",
+    ].join("\n");
+
+    const lines = parseUnifiedDiff(diff)[0].hunks[0].lines;
+    const noNewline = lines.filter((l) => l.type === "nonewline");
+    expect(noNewline).toHaveLength(2);
+    expect(noNewline[0].text).toContain("No newline");
+    expect(noNewline[0].oldNo).toBeNull();
+    expect(noNewline[0].newNo).toBeNull();
+  });
+
+  it("parses a headerless diff (no diff --git) into one file", () => {
+    const diff = [
+      "--- a/only.txt",
+      "+++ b/only.txt",
+      "@@ -1,2 +1,2 @@",
+      " same",
+      "-was",
+      "+is",
+      "",
+    ].join("\n");
+
+    const files = parseUnifiedDiff(diff);
+    expect(files).toHaveLength(1);
+    expect(files[0].oldPath).toBe("only.txt");
+    expect(files[0].newPath).toBe("only.txt");
+    expect(files[0].hunks).toHaveLength(1);
+  });
+
+  it("parses /dev/null paths for added files", () => {
+    const diff = [
+      "diff --git a/new.txt b/new.txt",
+      "new file mode 100644",
+      "--- /dev/null",
+      "+++ b/new.txt",
+      "@@ -0,0 +1,2 @@",
+      "+first",
+      "+second",
+      "",
+    ].join("\n");
+
+    const file = parseUnifiedDiff(diff)[0];
+    expect(file.oldPath).toBe("/dev/null");
+    expect(file.newPath).toBe("new.txt");
+    const adds = file.hunks[0].lines.filter((l) => l.type === "add");
+    expect(adds.map((l) => l.newNo)).toEqual([1, 2]);
+  });
+
+  it("handles multiple hunks in one file", () => {
+    const diff = [
+      "--- a/multi",
+      "+++ b/multi",
+      "@@ -1,2 +1,2 @@",
+      " a",
+      "-b",
+      "+B",
+      "@@ -10,2 +10,2 @@",
+      " x",
+      "-y",
+      "+Y",
+      "",
+    ].join("\n");
+
+    const file = parseUnifiedDiff(diff)[0];
+    expect(file.hunks).toHaveLength(2);
+    // second hunk re-seeds the line counters at 10
+    const second = file.hunks[1].lines;
+    expect(second[1]).toMatchObject({ type: "context", oldNo: 10, newNo: 10 });
+    expect(second[2]).toMatchObject({ type: "del", oldNo: 11 });
+    expect(second[3]).toMatchObject({ type: "add", newNo: 11 });
+  });
+});
diff --git a/src/__tests__/fuzzy.test.ts b/src/__tests__/fuzzy.test.ts
new file mode 100644
index 0000000..e919cdb
--- /dev/null
+++ b/src/__tests__/fuzzy.test.ts
@@ -0,0 +1,78 @@
+import { describe, it, expect } from "vitest";
+import { fuzzyMatch, fuzzyRank } from "../lib/fuzzy";
+
+describe("fuzzyMatch — subsequence", () => {
+  it("matches an in-order subsequence", () => {
+    const m = fuzzyMatch("ab", "xaxb");
+    expect(m).not.toBeNull();
+    expect(m!.positions).toEqual([1, 3]);
+  });
+
+  it("rejects out-of-order characters", () => {
+    expect(fuzzyMatch("ba", "xaxb")).toBeNull();
+  });
+
+  it("is case-insensitive", () => {
+    expect(fuzzyMatch("AB", "xaxb")).not.toBeNull();
+    expect(fuzzyMatch("ab", "XAXB")).not.toBeNull();
+  });
+
+  it("rejects when a query char is absent", () => {
+    expect(fuzzyMatch("abc", "ab")).toBeNull();
+  });
+
+  it("matches an empty query trivially", () => {
+    const m = fuzzyMatch("", "anything");
+    expect(m).toEqual({ score: 0, positions: [] });
+  });
+
+  it("scores a consecutive run higher than a scattered match", () => {
+    const tight = fuzzyMatch("abc", "abcxxxx");
+    const loose = fuzzyMatch("abc", "axbxcxx");
+    expect(tight).not.toBeNull();
+    expect(loose).not.toBeNull();
+    expect(tight!.score).toBeGreaterThan(loose!.score);
+  });
+});
+
+describe("fuzzyRank", () => {
+  it("ranks an exact basename above a scattered path match", () => {
+    const items = [
+      "src/components/scattered/m_a_i_n.ts", // 'main' scattered across the path
+      "src/main.ts", // exact basename "main"
+    ];
+    const ranked = fuzzyRank("main", items, (s) => s);
+    expect(ranked[0]).toBe("src/main.ts");
+  });
+
+  it("ranks a consecutive-run match above a spread-out one", () => {
+    const items = ["a_x_b_x_c.txt", "abc.txt"];
+    const ranked = fuzzyRank("abc", items, (s) => s);
+    expect(ranked[0]).toBe("abc.txt");
+  });
+
+  it("filters out non-matches", () => {
+    const items = ["alpha.ts", "beta.ts", "gamma.ts"];
+    const ranked = fuzzyRank("eta", items, (s) => s);
+    expect(ranked).toEqual(["beta.ts"]);
+  });
+
+  it("is a no-op for an empty query", () => {
+    const items = ["c.ts", "a.ts", "b.ts"];
+    const ranked = fuzzyRank("", items, (s) => s);
+    expect(ranked).toBe(items);
+    expect(ranked).toEqual(["c.ts", "a.ts", "b.ts"]);
+  });
+
+  it("is a no-op for a whitespace-only query", () => {
+    const items = ["c.ts", "a.ts"];
+    expect(fuzzyRank("   ", items, (s) => s)).toBe(items);
+  });
+
+  it("tie-breaks equal scores by shorter text then localeCompare", () => {
+    // Both are exact-prefix basename matches; the shorter one should win.
+    const items = ["xyz.ts", "xy.ts"];
+    const ranked = fuzzyRank("xy", items, (s) => s);
+    expect(ranked[0]).toBe("xy.ts");
+  });
+});
diff --git a/src/__tests__/gpu.test.ts b/src/__tests__/gpu.test.ts
new file mode 100644
index 0000000..0d8527c
--- /dev/null
+++ b/src/__tests__/gpu.test.ts
@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import {
+  formatBytes,
+  formatFan,
+  formatMhz,
+  formatTempC,
+  formatWatts,
+  gpuAdapterTooltip,
+  gpuBusy,
+  gpuLinkLabel,
+  gpuPercent,
+  gpuTone,
+  gpuTooltip,
+  gpuTotals,
+  type GpuSample,
+} from "../lib/gpu";
+
+/** The machine this was built on: a Strix APU — a 512 MB carve-out + a 61 GB GTT pool. */
+const apu: GpuSample = {
+  name: "Strix [Radeon 880M / 890M]",
+  driver: "amdgpu",
+  vram_used: 440_770_560,
+  vram_total: 536_870_912,
+  shared_used: 18_052_190_208,
+  shared_total: 65_855_619_072,
+  busy_percent: 95,
+};
+
+/** A discrete card: all its memory is its own, and there is no shared pool. */
+const dgpu: GpuSample = {
+  name: "NVIDIA GeForce RTX 4090",
+  driver: "nvidia",
+  vram_used: 8 * 1024 ** 3,
+  vram_total: 24 * 1024 ** 3,
+  shared_used: 0,
+  shared_total: 0,
+  busy_percent: 37,
+};
+
+describe("gpuTotals", () => {
+  it("sums both pools, which is the only figure an APU can answer 'will it fit?' with", () => {
+    const { used, total } = gpuTotals([apu]);
+    expect(used).toBe(apu.vram_used + apu.shared_used);
+    expect(total).toBe(apu.vram_total + apu.shared_total);
+    // The dedicated pool alone would read 82% full and never move.
+    expect(gpuPercent(apu.vram_used, apu.vram_total)).toBeGreaterThan(80);
+    expect(gpuPercent(used, total)).toBeLessThan(30);
+  });
+
+  it("collapses to plain device VRAM on a discrete card", () => {
+    expect(gpuTotals([dgpu])).toEqual({ used: 8 * 1024 ** 3, total: 24 * 1024 ** 3 });
+  });
+
+  it("sums across adapters, and is zero for none", () => {
+    expect(gpuTotals([apu, dgpu]).total).toBe(
+      apu.vram_total + apu.shared_total + dgpu.vram_total,
+    );
+    expect(gpuTotals([])).toEqual({ used: 0, total: 0 });
+  });
+});
+
+describe("gpuTone", () => {
+  it("tones by ratio, so a big-but-empty GPU is not 'hot'", () => {
+    // 8 GB in use — the old absolute thresholds (hot at 2 GB) called this high.
+    expect(gpuTone(8 * 1024 ** 3, 24 * 1024 ** 3)).toBe("low");
+    expect(gpuTone(15 * 1024 ** 3, 24 * 1024 ** 3)).toBe("medium");
+    expect(gpuTone(23 * 1024 ** 3, 24 * 1024 ** 3)).toBe("high");
+  });
+
+  it("does not divide by a total it does not have", () => {
+    expect(gpuTone(0, 0)).toBe("low");
+    expect(gpuPercent(1024, 0)).toBe(0);
+  });
+});
+
+describe("gpuBusy", () => {
+  it("takes the busiest adapter, and distinguishes unknown from idle", () => {
+    expect(gpuBusy([apu, dgpu])).toBe(95);
+    expect(gpuBusy([{ ...dgpu, busy_percent: null }])).toBeNull();
+    expect(gpuBusy([{ ...dgpu, busy_percent: 0 }])).toBe(0);
+    expect(gpuBusy([])).toBeNull();
+  });
+});
+
+describe("gpuTooltip", () => {
+  it("keeps the pools apart and names Ollama's share", () => {
+    const tip = gpuTooltip([apu], 3 * 1024 ** 3);
+    expect(tip).toContain("Strix [Radeon 880M / 890M] — 95% busy");
+    expect(tip).toContain("VRAM    420 MB / 512 MB");
+    expect(tip).toContain("Shared  16.8 GB / 61.3 GB");
+    expect(tip).toContain("Ollama models: 3.0 GB");
+  });
+
+  it("omits the shared line for a card that has no shared pool", () => {
+    expect(gpuTooltip([dgpu], 0)).not.toContain("Shared");
+  });
+});
+
+describe("formatBytes", () => {
+  it("reads MB below a GiB and GB above it", () => {
+    expect(formatBytes(0)).toBe("0 B");
+    expect(formatBytes(536_870_912)).toBe("512 MB");
+    expect(formatBytes(18_052_190_208)).toBe("16.8 GB");
+  });
+});
+
+describe("sensor formatters", () => {
+  it("returns null for an unknown reading rather than a fake zero", () => {
+    expect(formatTempC(null)).toBeNull();
+    expect(formatTempC(undefined)).toBeNull();
+    expect(formatWatts(null)).toBeNull();
+    expect(formatMhz(null)).toBeNull();
+    expect(formatFan(undefined)).toBeNull();
+    // A real zero is a value, not "unknown".
+    expect(formatFan(0)).toBe("0%");
+    expect(formatTempC(0)).toBe("0 °C");
+  });
+
+  it("formats each unit, and power against its cap when known", () => {
+    expect(formatTempC(58.4)).toBe("58 °C");
+    expect(formatWatts(210.5)).toBe("211 W");
+    expect(formatWatts(210.5, 450)).toBe("211 / 450 W");
+    expect(formatMhz(2520)).toBe("2.52 GHz");
+    expect(formatMhz(96)).toBe("96 MHz");
+    expect(formatFan(41)).toBe("41%");
+  });
+});
+
+describe("gpuLinkLabel", () => {
+  it("joins gen and width, and drops whichever half is unknown", () => {
+    expect(gpuLinkLabel({ ...dgpu, pcie_gen: 4, pcie_width: 16 })).toBe("PCIe 4.0 ×16");
+    expect(gpuLinkLabel({ ...dgpu, pcie_gen: 3, pcie_width: null })).toBe("PCIe 3.0");
+    expect(gpuLinkLabel({ ...dgpu, pcie_gen: null, pcie_width: 8 })).toBe("×8");
+    expect(gpuLinkLabel(dgpu)).toBeNull();
+  });
+});
+
+describe("gpuAdapterTooltip sensors", () => {
+  it("appends only the sensors the driver reported", () => {
+    const tip = gpuAdapterTooltip({
+      ...dgpu,
+      temp_c: 61,
+      power_w: 210,
+      power_cap_w: 450,
+      sclk_mhz: 2520,
+      mclk_mhz: 10501,
+      pcie_gen: 4,
+      pcie_width: 16,
+    });
+    expect(tip).toContain("Temp    61 °C");
+    expect(tip).toContain("Power   210 / 450 W");
+    expect(tip).toContain("Clocks  2.52 GHz / 10.50 GHz");
+    expect(tip).toContain("Link    PCIe 4.0 ×16");
+  });
+
+  it("reads exactly as before for a card that exposes no sensors", () => {
+    // The APU/dGPU fixtures carry no sensor fields — the tooltip must not sprout
+    // empty sensor rows.
+    expect(gpuAdapterTooltip(dgpu)).not.toContain("Temp");
+    expect(gpuAdapterTooltip(dgpu)).not.toContain("Link");
+  });
+});
diff --git a/src/__tests__/i18n.test.ts b/src/__tests__/i18n.test.ts
new file mode 100644
index 0000000..73bb696
--- /dev/null
+++ b/src/__tests__/i18n.test.ts
@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { translate, normalizeLang, LANGUAGES } from "../lib/i18n";
+
+describe("i18n", () => {
+  it("translates a known key per language", () => {
+    expect(translate("en", "settings.title")).toBe("Settings");
+    expect(translate("de", "settings.title")).toBe("Einstellungen");
+    expect(translate("es", "settings.title")).toBe("Configuración");
+    expect(translate("fr", "settings.title")).toBe("Paramètres");
+    expect(translate("it", "settings.title")).toBe("Impostazioni");
+  });
+
+  it("falls back to English when a language lacks a key", () => {
+    // `translate` with a made-up key returns the raw key (last-resort fallback),
+    // and every real key present in `en` resolves in every language via fallback.
+    // Spot-check the fallback path by asking a language for the base value: even
+    // if a future key is added to `en` only, non-English still renders English,
+    // never a blank.
+    const enTitle = translate("en", "settings.title");
+    for (const { value } of LANGUAGES) {
+      expect(translate(value, "settings.title").length).toBeGreaterThan(0);
+    }
+    expect(enTitle).toBe("Settings");
+  });
+
+  it("substitutes {name} placeholders", () => {
+    // No parameterized keys ship yet, but the substitution contract is public.
+    expect(
+      translate("en", "settings.title", { unused: "x" }),
+    ).toBe("Settings");
+  });
+
+  it("normalizes unknown/empty language codes to English", () => {
+    expect(normalizeLang("de")).toBe("de");
+    expect(normalizeLang("xx")).toBe("en");
+    expect(normalizeLang("")).toBe("en");
+    expect(normalizeLang(null)).toBe("en");
+    expect(normalizeLang(undefined)).toBe("en");
+  });
+
+  it("offers exactly the five supported languages", () => {
+    expect(LANGUAGES.map((l) => l.value)).toEqual(["en", "de", "es", "fr", "it"]);
+  });
+});
diff --git a/src/__tests__/markdownMath.test.ts b/src/__tests__/markdownMath.test.ts
new file mode 100644
index 0000000..f701147
--- /dev/null
+++ b/src/__tests__/markdownMath.test.ts
@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { renderMarkdown } from "../lib/viewers/markdown";
+
+/**
+ * Dev A: math placeholder emission from the pure markdown renderer. The actual
+ * KaTeX/mermaid DOM rendering happens in `enrichMarkdownDom` (a post-render DOM
+ * pass), so here we only assert that renderMarkdown emits the right placeholders.
+ */
+describe("renderMarkdown — math + mermaid placeholders", () => {
+  it("emits an inline math span for $…$", () => {
+    const html = renderMarkdown("$x^2$");
+    expect(html).toContain('class="md-math"');
+    expect(html).toContain('data-display="false"');
+    // TeX is HTML-escaped (escape-first invariant); `^` survives verbatim.
+    expect(html).toContain("x^2");
+  });
+
+  it("emits a block math span for $$…$$", () => {
+    const html = renderMarkdown("$$a$$");
+    expect(html).toContain('class="md-math"');
+    expect(html).toContain('data-display="true"');
+  });
+
+  it("does NOT treat prose dollar amounts as math", () => {
+    const html = renderMarkdown("It cost $5 today");
+    expect(html).not.toContain("md-math");
+  });
+
+  it("does NOT treat a $ with adjacent spaces as math", () => {
+    const html = renderMarkdown("a $ b $ c");
+    expect(html).not.toContain("md-math");
+  });
+
+  it("HTML-escapes the TeX inside the math span", () => {
+    const html = renderMarkdown("$a<b$");
+    expect(html).toContain('class="md-math"');
+    expect(html).toContain("a&lt;b");
+    expect(html).not.toContain("a<b");
+  });
+
+  it("leaves inline code spans untouched (no math extraction inside)", () => {
+    const html = renderMarkdown("`$x$`");
+    expect(html).toContain("<code>$x$</code>");
+    expect(html).not.toContain("md-math");
+  });
+
+  it("renders ```mermaid fences as a mermaid code block for the enrich pass", () => {
+    const html = renderMarkdown("```mermaid\ngraph TD; A-->B;\n```");
+    expect(html).toContain('data-lang="mermaid"');
+    expect(html).toContain('class="language-mermaid"');
+    // Source is escaped and present so enrichMarkdownDom can read textContent.
+    expect(html).toContain("A--&gt;B;");
+  });
+});
diff --git a/src/__tests__/notebook.test.ts b/src/__tests__/notebook.test.ts
new file mode 100644
index 0000000..8e2a01e
--- /dev/null
+++ b/src/__tests__/notebook.test.ts
@@ -0,0 +1,121 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseNotebook,
+  outputToBlocks,
+  stripAnsi,
+  type NbCell,
+} from "../lib/viewers/notebook";
+
+// A small nbformat v4 fixture: a markdown cell, then a code cell with a stream
+// output, an image/png output, an error traceback, and a text/html output that
+// MUST be skipped.
+const fixture = {
+  cells: [
+    {
+      cell_type: "markdown",
+      source: ["# Title\n", "\n", "Some *text*.\n"],
+    },
+    {
+      cell_type: "code",
+      source: ["import numpy as np\n", "print('hi')\n"],
+      outputs: [
+        { output_type: "stream", name: "stdout", text: ["hi\n", "there\n"] },
+        {
+          output_type: "display_data",
+          data: { "image/png": "iVBORw0KGgoAAAANS", "text/plain": ["<Figure>"] },
+        },
+        {
+          output_type: "execute_result",
+          data: { "text/html": "<b>danger</b>", "text/plain": "42" },
+        },
+        {
+          output_type: "error",
+          ename: "ValueError",
+          evalue: "boom",
+          traceback: ["\x1b[0;31mValueError\x1b[0m: boom"],
+        },
+      ],
+    },
+    { cell_type: "raw", source: "raw body" },
+  ],
+  metadata: {
+    kernelspec: { name: "python3", language: "python" },
+    language_info: { name: "python" },
+  },
+  nbformat: 4,
+  nbformat_minor: 5,
+};
+
+describe("parseNotebook", () => {
+  it("reads language, cell types, and joined source", () => {
+    const nb = parseNotebook(fixture);
+    expect(nb.language).toBe("python");
+    // markdown, code, raw(->markdown)
+    expect(nb.cells.map((c) => c.type)).toEqual(["markdown", "code", "markdown"]);
+    expect(nb.cells[0].source).toBe("# Title\n\nSome *text*.\n");
+    expect(nb.cells[1].source).toBe("import numpy as np\nprint('hi')\n");
+    expect(nb.cells[2].source).toBe("raw body");
+  });
+
+  it("accepts a JSON string as well as an object", () => {
+    const nb = parseNotebook(JSON.stringify(fixture));
+    expect(nb.language).toBe("python");
+    expect(nb.cells).toHaveLength(3);
+  });
+
+  it("falls back to python and empty cells on bad input", () => {
+    expect(parseNotebook("{not json")).toEqual({ language: "python", cells: [] });
+    expect(parseNotebook({} as object)).toEqual({ language: "python", cells: [] });
+  });
+
+  it("uses language_info.name when kernelspec lacks language", () => {
+    const nb = parseNotebook({
+      cells: [],
+      metadata: { language_info: { name: "julia" } },
+    });
+    expect(nb.language).toBe("julia");
+  });
+
+  it("classifies code-cell outputs and SKIPS text/html", () => {
+    const nb = parseNotebook(fixture);
+    const code = nb.cells[1] as NbCell;
+    expect(code.outputs).toBeDefined();
+    const outs = code.outputs!;
+    // stream(text) + image(png) + execute_result(text/plain, html skipped) + error(text)
+    expect(outs).toHaveLength(4);
+    expect(outs[0]).toEqual({ kind: "text", text: "hi\nthere\n" });
+    expect(outs[1]).toEqual({ kind: "image", pngBase64: "iVBORw0KGgoAAAANS" });
+    // The execute_result has both text/html and text/plain — html is dropped,
+    // plain is kept; no block carries any HTML.
+    expect(outs[2]).toEqual({ kind: "text", text: "42" });
+    expect(outs[3]).toEqual({ kind: "text", text: "ValueError: boom" });
+    expect(outs.some((o) => typeof o.text === "string" && o.text.includes("<b>"))).toBe(false);
+  });
+});
+
+describe("outputToBlocks", () => {
+  it("skips an output that only has text/html", () => {
+    expect(
+      outputToBlocks({ output_type: "display_data", data: { "text/html": "<b>x</b>" } }),
+    ).toEqual([]);
+  });
+
+  it("joins split base64 png line arrays", () => {
+    expect(
+      outputToBlocks({ output_type: "display_data", data: { "image/png": ["AAA", "BBB"] } }),
+    ).toEqual([{ kind: "image", pngBase64: "AAABBB" }]);
+  });
+
+  it("returns no blocks for unknown output types or junk", () => {
+    expect(outputToBlocks({ output_type: "weird" })).toEqual([]);
+    expect(outputToBlocks(null)).toEqual([]);
+    expect(outputToBlocks("nope")).toEqual([]);
+  });
+});
+
+describe("stripAnsi", () => {
+  it("removes SGR colour escape codes", () => {
+    expect(stripAnsi("\x1b[0;31mred\x1b[0m text")).toBe("red text");
+    expect(stripAnsi("plain")).toBe("plain");
+  });
+});
diff --git a/src/__tests__/odt.test.ts b/src/__tests__/odt.test.ts
new file mode 100644
index 0000000..be58197
--- /dev/null
+++ b/src/__tests__/odt.test.ts
@@ -0,0 +1,150 @@
+import { describe, it, expect } from "vitest";
+import { extractOdt, renderOdtDocument } from "../lib/viewers/odt";
+
+/** Wrap a body (and optional automatic-styles) in a minimal but namespace-correct
+ *  ODF `content.xml`, so DOMParser accepts the prefixes the renderer reads. */
+function odt(body: string, autoStyles = ""): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<office:document-content
+  xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
+  xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
+  xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"
+  xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0"
+  xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"
+  xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"
+  xmlns:xlink="http://www.w3.org/1999/xlink">
+  <office:automatic-styles>${autoStyles}</office:automatic-styles>
+  <office:body><office:text>${body}</office:text></office:body>
+</office:document-content>`;
+}
+
+describe("renderOdtDocument — structure", () => {
+  it("renders headings at their outline level and paragraphs", () => {
+    const html = renderOdtDocument(
+      odt(
+        `<text:h text:outline-level="2">Title</text:h>` +
+          `<text:p>Hello world</text:p>`,
+      ),
+    );
+    expect(html).toBe(`<h2>Title</h2><p>Hello world</p>`);
+  });
+
+  it("clamps an out-of-range outline level into h1..h6", () => {
+    const html = renderOdtDocument(odt(`<text:h text:outline-level="9">Deep</text:h>`));
+    expect(html).toBe(`<h6>Deep</h6>`);
+  });
+
+  it("renders bullet and numbered lists from their list style", () => {
+    const styles =
+      `<text:list-style style:name="L1"><text:list-level-style-bullet text:level="1"/></text:list-style>` +
+      `<text:list-style style:name="L2"><text:list-level-style-number text:level="1"/></text:list-style>`;
+    const bullet = renderOdtDocument(
+      odt(
+        `<text:list text:style-name="L1"><text:list-item><text:p>a</text:p></text:list-item>` +
+          `<text:list-item><text:p>b</text:p></text:list-item></text:list>`,
+        styles,
+      ),
+    );
+    expect(bullet).toBe(`<ul><li>a</li><li>b</li></ul>`);
+
+    const numbered = renderOdtDocument(
+      odt(
+        `<text:list text:style-name="L2"><text:list-item><text:p>a</text:p></text:list-item></text:list>`,
+        styles,
+      ),
+    );
+    expect(numbered).toBe(`<ol><li>a</li></ol>`);
+  });
+
+  it("renders a table as rows of cells", () => {
+    const html = renderOdtDocument(
+      odt(
+        `<table:table><table:table-row>` +
+          `<table:table-cell><text:p>a</text:p></table:table-cell>` +
+          `<table:table-cell><text:p>b</text:p></table:table-cell>` +
+          `</table:table-row></table:table>`,
+      ),
+    );
+    expect(html).toBe(
+      `<table class="odt-table"><tbody><tr><td><p>a</p></td><td><p>b</p></td></tr></tbody></table>`,
+    );
+  });
+});
+
+describe("renderOdtDocument — inline formatting", () => {
+  it("applies bold/italic/underline from automatic text styles", () => {
+    const styles =
+      `<style:style style:name="T1" style:family="text"><style:text-properties fo:font-weight="bold"/></style:style>` +
+      `<style:style style:name="T2" style:family="text"><style:text-properties fo:font-style="italic" style:text-underline-style="solid"/></style:style>`;
+    const html = renderOdtDocument(
+      odt(
+        `<text:p><text:span text:style-name="T1">b</text:span>` +
+          `<text:span text:style-name="T2">iu</text:span></text:p>`,
+        styles,
+      ),
+    );
+    expect(html).toBe(`<p><strong>b</strong><em><u>iu</u></em></p>`);
+  });
+
+  it("keeps safe hyperlinks and drops dangerous schemes", () => {
+    const safe = renderOdtDocument(
+      odt(`<text:p><text:a xlink:href="https://example.com">site</text:a></text:p>`),
+    );
+    expect(safe).toBe(
+      `<p><a href="https://example.com" target="_blank" rel="noreferrer noopener">site</a></p>`,
+    );
+    const unsafe = renderOdtDocument(
+      odt(`<text:p><text:a xlink:href="javascript:alert(1)">x</text:a></text:p>`),
+    );
+    // No anchor emitted for a javascript: URL — only the inner text survives.
+    expect(unsafe).toBe(`<p>x</p>`);
+  });
+
+  it("expands explicit spaces and line breaks", () => {
+    const html = renderOdtDocument(
+      odt(`<text:p>a<text:s text:c="3"/>b<text:line-break/>c</text:p>`),
+    );
+    expect(html).toBe(`<p>a   b<br/>c</p>`);
+  });
+
+  it("renders an embedded image from the supplied data-URL map", () => {
+    const images = new Map([["Pictures/1.png", "data:image/png;base64,AAAA"]]);
+    const html = renderOdtDocument(
+      odt(`<text:p><draw:frame><draw:image xlink:href="Pictures/1.png"/></draw:frame></text:p>`),
+      { images },
+    );
+    expect(html).toBe(`<p><img class="odt-image" src="data:image/png;base64,AAAA" alt="" /></p>`);
+  });
+});
+
+describe("renderOdtDocument — security & errors", () => {
+  it("HTML-escapes document text so markup can't be injected", () => {
+    const html = renderOdtDocument(odt(`<text:p>&lt;script&gt;alert(1)&lt;/script&gt;</text:p>`));
+    expect(html).toBe(`<p>&lt;script&gt;alert(1)&lt;/script&gt;</p>`);
+    expect(html).not.toContain("<script>");
+  });
+
+  it("throws on XML without an ODF document body", () => {
+    expect(() => renderOdtDocument("<root></root>")).toThrow();
+  });
+});
+
+describe("extractOdt", () => {
+  const enc = (s: string) => new TextEncoder().encode(s);
+
+  it("decodes content.xml and maps Pictures/* to data URLs", () => {
+    const { contentXml, images } = extractOdt({
+      "content.xml": enc("<x/>"),
+      "Pictures/img.png": new Uint8Array([1, 2, 3]),
+      "styles.xml": enc("<y/>"),
+    });
+    expect(contentXml).toBe("<x/>");
+    expect(images.get("Pictures/img.png")).toMatch(/^data:image\/png;base64,/);
+    // Non-picture archive members are not exposed as images.
+    expect(images.size).toBe(1);
+  });
+
+  it("throws when the archive has no content.xml", () => {
+    expect(() => extractOdt({ "styles.xml": enc("<y/>") })).toThrow(/content\.xml/);
+  });
+});
diff --git a/src/__tests__/table.test.ts b/src/__tests__/table.test.ts
new file mode 100644
index 0000000..ded2cde
--- /dev/null
+++ b/src/__tests__/table.test.ts
@@ -0,0 +1,456 @@
+import { describe, it, expect } from "vitest";
+import {
+  parseDelimited,
+  parseTable,
+  sortRows,
+  sortRefs,
+  sortRefsByIndex,
+  bodyRefs,
+  filterRefs,
+  delimiterForPath,
+  sniffDelimiter,
+  resolveDelimiter,
+  encodeCell,
+  replaceCell,
+  insertRowAfter,
+  deleteRow,
+  columnWidths,
+} from "../lib/viewers/table";
+
+describe("parseDelimited — basics", () => {
+  it("parses a simple comma-separated grid", () => {
+    expect(parseDelimited("a,b,c\n1,2,3", ",")).toEqual([
+      ["a", "b", "c"],
+      ["1", "2", "3"],
+    ]);
+  });
+
+  it("parses tab-separated values", () => {
+    expect(parseDelimited("a\tb\n1\t2", "\t")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+    ]);
+  });
+
+  it("returns no rows for empty input", () => {
+    expect(parseDelimited("", ",")).toEqual([]);
+  });
+
+  it("preserves empty fields", () => {
+    expect(parseDelimited("a,,c", ",")).toEqual([["a", "", "c"]]);
+  });
+});
+
+describe("parseDelimited — RFC 4180 quoting", () => {
+  it("keeps a delimiter embedded inside a quoted field", () => {
+    expect(parseDelimited('"a,b",c', ",")).toEqual([["a,b", "c"]]);
+  });
+
+  it("keeps a newline embedded inside a quoted field", () => {
+    expect(parseDelimited('"line1\nline2",x', ",")).toEqual([["line1\nline2", "x"]]);
+  });
+
+  it("keeps a CRLF embedded inside a quoted field", () => {
+    expect(parseDelimited('"line1\r\nline2",x', ",")).toEqual([["line1\r\nline2", "x"]]);
+  });
+
+  it("treats \"\" as a single literal quote", () => {
+    expect(parseDelimited('"she said ""hi""",end', ",")).toEqual([
+      ['she said "hi"', "end"],
+    ]);
+  });
+
+  it("handles a fully-quoted row with quoted empty field", () => {
+    expect(parseDelimited('"a","","c"', ",")).toEqual([["a", "", "c"]]);
+  });
+});
+
+describe("parseDelimited — line endings, BOM, trailing newline", () => {
+  it("handles CRLF line endings", () => {
+    expect(parseDelimited("a,b\r\n1,2\r\n", ",")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+    ]);
+  });
+
+  it("handles bare LF line endings", () => {
+    expect(parseDelimited("a,b\n1,2", ",")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+    ]);
+  });
+
+  it("strips a leading BOM", () => {
+    expect(parseDelimited("a,b\n1,2", ",")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+    ]);
+  });
+
+  it("ignores a single trailing newline (no trailing empty row)", () => {
+    expect(parseDelimited("a,b\n1,2\n", ",")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+    ]);
+  });
+
+  it("keeps a blank row created by a double trailing newline", () => {
+    expect(parseDelimited("a,b\n1,2\n\n", ",")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+      [""],
+    ]);
+  });
+});
+
+describe("parseDelimited — ragged rows", () => {
+  it("preserves rows of differing widths", () => {
+    expect(parseDelimited("a,b,c\n1,2\n9,8,7,6", ",")).toEqual([
+      ["a", "b", "c"],
+      ["1", "2"],
+      ["9", "8", "7", "6"],
+    ]);
+  });
+});
+
+describe("delimiterForPath", () => {
+  it("picks tab for .tsv and comma otherwise", () => {
+    expect(delimiterForPath("/x/data.tsv")).toBe("\t");
+    expect(delimiterForPath("/x/data.TSV")).toBe("\t");
+    expect(delimiterForPath("/x/data.csv")).toBe(",");
+    expect(delimiterForPath("/x/data.txt")).toBe(",");
+  });
+});
+
+describe("sortRows", () => {
+  const rows = [
+    ["10", "banana"],
+    ["2", "apple"],
+    ["1", "cherry"],
+  ];
+
+  it("sorts numerically when every cell is a finite number (asc)", () => {
+    expect(sortRows(rows, 0, "asc").map((r) => r[0])).toEqual(["1", "2", "10"]);
+  });
+
+  it("sorts numerically descending", () => {
+    expect(sortRows(rows, 0, "desc").map((r) => r[0])).toEqual(["10", "2", "1"]);
+  });
+
+  it("falls back to localeCompare for non-numeric columns (asc)", () => {
+    expect(sortRows(rows, 1, "asc").map((r) => r[1])).toEqual([
+      "apple",
+      "banana",
+      "cherry",
+    ]);
+  });
+
+  it("sorts lexically descending", () => {
+    expect(sortRows(rows, 1, "desc").map((r) => r[1])).toEqual([
+      "cherry",
+      "banana",
+      "apple",
+    ]);
+  });
+
+  it("treats a column with a blank cell as non-numeric (lexical)", () => {
+    const mixed = [["3"], ["1"], [""]];
+    // "" is non-numeric, so the whole column sorts lexically: "" < "1" < "3".
+    expect(sortRows(mixed, 0, "asc").map((r) => r[0])).toEqual(["", "1", "3"]);
+  });
+
+  it("does not mutate the input array or its rows", () => {
+    const input = [["3"], ["1"], ["2"]];
+    const snapshot = JSON.stringify(input);
+    const out = sortRows(input, 0, "asc");
+    expect(JSON.stringify(input)).toBe(snapshot);
+    expect(out).not.toBe(input);
+  });
+
+  it("treats missing cells in ragged rows as empty strings", () => {
+    const ragged = [["b", "2"], ["a"], ["c", "1"]];
+    // Column 1 has a missing cell (non-numeric due to ""), sorts lexically.
+    expect(sortRows(ragged, 1, "asc").map((r) => r[1] ?? "")).toEqual(["", "1", "2"]);
+  });
+
+  it("is stable for equal keys", () => {
+    const dup = [
+      ["1", "first"],
+      ["1", "second"],
+      ["1", "third"],
+    ];
+    expect(sortRows(dup, 0, "asc").map((r) => r[1])).toEqual([
+      "first",
+      "second",
+      "third",
+    ]);
+  });
+});
+
+describe("sniffDelimiter", () => {
+  it("finds the semicolon in a European-style CSV", () => {
+    expect(sniffDelimiter("name;age;city\nada;36;london\nalan;41;wilmslow")).toBe(";");
+  });
+
+  it("finds the pipe in a pipe-delimited dump", () => {
+    expect(sniffDelimiter("a|b|c\n1|2|3\n4|5|6")).toBe("|");
+  });
+
+  it("finds the tab in a TSV", () => {
+    expect(sniffDelimiter("a\tb\n1\t2\n3\t4")).toBe("\t");
+  });
+
+  it("still finds the comma in an ordinary CSV", () => {
+    expect(sniffDelimiter("a,b,c\n1,2,3")).toBe(",");
+  });
+
+  it("is not fooled by a comma inside a quoted semicolon-delimited field", () => {
+    const text = 'name;note\nada;"london, england"\nalan;"wilmslow, cheshire"';
+    expect(sniffDelimiter(text)).toBe(";");
+  });
+
+  it("prefers the delimiter that yields consistent row widths", () => {
+    // Commas appear, but only inside the prose of one column; the ; is the grid.
+    const text = "id;title\n1;a, b, c\n2;d, e\n3;f";
+    expect(sniffDelimiter(text)).toBe(";");
+  });
+
+  it("falls back when nothing splits the file (a single column)", () => {
+    expect(sniffDelimiter("alpha\nbeta\ngamma", ",")).toBe(",");
+    expect(sniffDelimiter("alpha\nbeta\ngamma", "\t")).toBe("\t");
+  });
+
+  it("falls back on an empty file", () => {
+    expect(sniffDelimiter("", ";")).toBe(";");
+  });
+});
+
+describe("resolveDelimiter", () => {
+  it("prefers the sniffed separator over the extension's guess", () => {
+    // A .csv that is really semicolon-delimited — the case that rendered as one column.
+    expect(resolveDelimiter("/x/data.csv", "a;b\n1;2")).toBe(";");
+  });
+
+  it("falls back to the extension when the content is inconclusive", () => {
+    expect(resolveDelimiter("/x/data.tsv", "onlyonecolumn\nvalue")).toBe("\t");
+    expect(resolveDelimiter("/x/data.csv", "onlyonecolumn\nvalue")).toBe(",");
+  });
+});
+
+describe("parseTable — spans", () => {
+  it("spans address each field's raw source text", () => {
+    const text = "a,b\n1,2";
+    const t = parseTable(text, ",");
+    const raw = (r: number, c: number) =>
+      text.slice(t.cells[r][c].start, t.cells[r][c].end);
+    expect(raw(0, 0)).toBe("a");
+    expect(raw(0, 1)).toBe("b");
+    expect(raw(1, 0)).toBe("1");
+    expect(raw(1, 1)).toBe("2");
+  });
+
+  it("a quoted field's span includes its quotes", () => {
+    const text = 'x,"a,b"';
+    const t = parseTable(text, ",");
+    expect(text.slice(t.cells[0][1].start, t.cells[0][1].end)).toBe('"a,b"');
+    expect(t.rows[0][1]).toBe("a,b");
+  });
+
+  it("keeps offsets absolute across a BOM, so a span splices back correctly", () => {
+    const text = "a,b";
+    const t = parseTable(text, ",");
+    expect(text.slice(t.cells[0][0].start, t.cells[0][0].end)).toBe("a");
+    expect(t.rows[0]).toEqual(["a", "b"]);
+  });
+
+  it("row spans exclude the terminator but `next` steps over it", () => {
+    const text = "a,b\r\n1,2\n";
+    const t = parseTable(text, ",");
+    expect(text.slice(t.rowSpans[0].start, t.rowSpans[0].end)).toBe("a,b");
+    expect(t.rowSpans[0].next).toBe(5); // past the CRLF
+    expect(text.slice(t.rowSpans[1].start, t.rowSpans[1].end)).toBe("1,2");
+  });
+
+  it("marks an unterminated final row by `next === end`", () => {
+    const t = parseTable("a,b\n1,2", ",");
+    expect(t.rowSpans[0].next).toBeGreaterThan(t.rowSpans[0].end); // terminated
+    expect(t.rowSpans[1].next).toBe(t.rowSpans[1].end); // ends with the file
+  });
+
+  it("reports the file's dominant newline", () => {
+    expect(parseTable("a\r\nb", ",").newline).toBe("\r\n");
+    expect(parseTable("a\nb", ",").newline).toBe("\n");
+  });
+});
+
+describe("encodeCell", () => {
+  it("leaves an unambiguous value bare", () => {
+    expect(encodeCell("plain", ",")).toBe("plain");
+  });
+
+  it("quotes a value containing the delimiter", () => {
+    expect(encodeCell("a,b", ",")).toBe('"a,b"');
+    expect(encodeCell("a,b", ";")).toBe("a,b"); // not the delimiter here
+    expect(encodeCell("a;b", ";")).toBe('"a;b"');
+  });
+
+  it("doubles embedded quotes", () => {
+    expect(encodeCell('say "hi"', ",")).toBe('"say ""hi"""');
+  });
+
+  it("quotes newlines and edge whitespace, which a reader could otherwise trim", () => {
+    expect(encodeCell("a\nb", ",")).toBe('"a\nb"');
+    expect(encodeCell(" pad ", ",")).toBe('" pad "');
+  });
+});
+
+describe("replaceCell", () => {
+  const edit = (text: string, r: number, c: number, v: string, d = ",") =>
+    replaceCell(text, parseTable(text, d), r, c, v, d);
+
+  it("rewrites only the target field's bytes", () => {
+    expect(edit("a,b\n1,2", 1, 0, "9")).toBe("a,b\n9,2");
+  });
+
+  it("leaves every other cell's quoting style untouched", () => {
+    // "b" is quoted although it needn't be; editing `a` must not re-serialise it.
+    expect(edit('a,"b"\n1,2', 0, 0, "z")).toBe('z,"b"\n1,2');
+  });
+
+  it("quotes the new value only when it needs it", () => {
+    expect(edit("a,b\n1,2", 1, 1, "x,y")).toBe('a,b\n1,"x,y"');
+  });
+
+  it("preserves CRLF line endings around the edit", () => {
+    expect(edit("a,b\r\n1,2\r\n", 1, 1, "9")).toBe("a,b\r\n1,9\r\n");
+  });
+
+  it("edits through a non-comma delimiter", () => {
+    expect(edit("a;b\n1;2", 1, 1, "9", ";")).toBe("a;b\n1;9");
+  });
+
+  it("pads a ragged row out to the column being typed into", () => {
+    // Row 1 has one field; the viewer shows it padded to 3 columns, so writing
+    // into the third must land in the third — not append to the first.
+    expect(edit("a,b,c\nx", 1, 2, "z")).toBe("a,b,c\nx,,z");
+  });
+
+  it("is a no-op for a row that does not exist", () => {
+    expect(edit("a,b", 9, 0, "z")).toBe("a,b");
+  });
+});
+
+describe("insertRowAfter / deleteRow", () => {
+  it("inserts a blank row after a terminated row", () => {
+    const text = "a,b\n1,2\n";
+    expect(insertRowAfter(text, parseTable(text, ","), 0, 2, ",")).toBe("a,b\n,\n1,2\n");
+  });
+
+  it("appends after an unterminated final row without adding a trailing blank", () => {
+    const text = "a,b\n1,2";
+    const out = insertRowAfter(text, parseTable(text, ","), 1, 2, ",");
+    expect(out).toBe("a,b\n1,2\n,");
+    // The appended row is real, and no phantom row follows it.
+    expect(parseDelimited(out, ",")).toEqual([
+      ["a", "b"],
+      ["1", "2"],
+      ["", ""],
+    ]);
+  });
+
+  it("uses the file's own newline", () => {
+    const text = "a,b\r\n1,2\r\n";
+    expect(insertRowAfter(text, parseTable(text, ","), 1, 2, ",")).toBe(
+      "a,b\r\n1,2\r\n,\r\n",
+    );
+  });
+
+  it("deletes a row with its terminator", () => {
+    const text = "a,b\n1,2\n3,4\n";
+    expect(deleteRow(text, parseTable(text, ","), 1)).toBe("a,b\n3,4\n");
+  });
+
+  it("deleting an unterminated final row takes the preceding newline instead", () => {
+    const text = "a,b\n1,2";
+    const out = deleteRow(text, parseTable(text, ","), 1);
+    expect(out).toBe("a,b");
+    expect(parseDelimited(out, ",")).toEqual([["a", "b"]]);
+  });
+});
+
+describe("filterRefs", () => {
+  const refs = bodyRefs([
+    ["name", "city"],
+    ["ada", "London"],
+    ["alan", "Wilmslow"],
+  ]);
+
+  it("keeps each row's source index, so an edit still lands on the right row", () => {
+    expect(refs.map((r) => r.index)).toEqual([1, 2]);
+    expect(filterRefs(refs, "alan")[0].index).toBe(2);
+  });
+
+  it("matches any cell, case-insensitively", () => {
+    expect(filterRefs(refs, "london").map((r) => r.cells[0])).toEqual(["ada"]);
+  });
+
+  it("a blank query matches everything", () => {
+    expect(filterRefs(refs, "   ")).toHaveLength(2);
+  });
+
+  it("returns nothing when nothing matches", () => {
+    expect(filterRefs(refs, "zzz")).toEqual([]);
+  });
+
+  it("searches only the given columns, so a hidden one cannot match", () => {
+    // Column 1 (city) is hidden: "london" must no longer pull ada's row in, or the
+    // row would appear with nothing visible on it explaining the match.
+    expect(filterRefs(refs, "london", [0])).toEqual([]);
+    expect(filterRefs(refs, "ada", [0]).map((r) => r.index)).toEqual([1]);
+  });
+
+  it("still matches on a visible column when others are hidden", () => {
+    expect(filterRefs(refs, "wilmslow", [1]).map((r) => r.index)).toEqual([2]);
+  });
+});
+
+describe("sortRefs", () => {
+  it("carries the source index through the sort", () => {
+    const refs = bodyRefs([
+      ["n"],
+      ["10"],
+      ["2"],
+    ]);
+    expect(sortRefs(refs, 0, "asc").map((r) => r.index)).toEqual([2, 1]);
+  });
+});
+
+describe("sortRefsByIndex", () => {
+  it("asc restores the file's row order after a column sort reordered it", () => {
+    const refs = bodyRefs([["n"], ["10"], ["2"], ["7"]]);
+    const byValue = sortRefs(refs, 0, "asc"); // 2, 7, 10 → indices [2, 3, 1]
+    expect(byValue.map((r) => r.index)).toEqual([2, 3, 1]);
+    expect(sortRefsByIndex(byValue, "asc").map((r) => r.index)).toEqual([1, 2, 3]);
+  });
+
+  it("desc reverses the file's row order", () => {
+    const refs = bodyRefs([["n"], ["a"], ["b"], ["c"]]);
+    expect(sortRefsByIndex(refs, "desc").map((r) => r.index)).toEqual([3, 2, 1]);
+  });
+
+  it("does not mutate its input", () => {
+    const refs = bodyRefs([["n"], ["a"], ["b"]]);
+    sortRefsByIndex(refs, "desc");
+    expect(refs.map((r) => r.index)).toEqual([1, 2]);
+  });
+});
+
+describe("columnWidths", () => {
+  it("sizes each column to its widest cell, header included", () => {
+    expect(columnWidths([["id", "description"], ["1", "short"]], 2)).toEqual([4, 11]);
+  });
+
+  it("clamps a very wide column so one essay cell can't run the table off screen", () => {
+    expect(columnWidths([["x"], ["y".repeat(500)]], 1)).toEqual([48]);
+  });
+});
diff --git a/src/assets/logo-white.svg b/src/assets/logo-white.svg
new file mode 100644
index 0000000..5fb1a0e
--- /dev/null
+++ b/src/assets/logo-white.svg
@@ -0,0 +1,36 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="128" height="128" fill="none" role="img" aria-label="Eldrun">
+  <title>Eldrun</title>
+  <!--
+    Eldrun logo (white variant for dark backgrounds) — a circuit "tree of life"
+    inside a ring, crowned by a gold spark. Same geometry as logo.svg; the
+    dark-green traces are recolored to white so the mark reads on dark chrome.
+  -->
+  <g stroke="#FFFFFF" stroke-linecap="round" stroke-linejoin="round" fill="none">
+    <!-- Ring, with a small opening at the bottom where the trunk passes through. -->
+    <path d="M 214 491 A 239 239 0 1 1 298 491" stroke-width="10" />
+
+    <!-- Central trunk stem. -->
+    <path d="M 256 161 L 256 499" stroke-width="10" />
+
+    <!-- Left-side branches + descending leg (authored), then mirrored. -->
+    <g id="eldrun-branches">
+      <!-- L1: node → vertical → 45° diagonal → leg → splayed foot. -->
+      <path d="M 165 176 L 165 238 L 233 306 L 233 440 L 222 483" stroke-width="10" />
+      <!-- L2 → vertical → diagonal → L3 (trace stops short of the pad on both sides) → 45° diagonal down into the leg. -->
+      <path d="M 98 235 L 98 289 L 129.9 320.9 M 159.7 347.4 L 233 405" stroke-width="10" />
+      <!-- Node terminals (thinner stroke than the traces). -->
+      <circle cx="165" cy="162" r="14" stroke-width="8" />
+      <circle cx="98"  cy="221" r="14" stroke-width="8" />
+      <circle cx="144" cy="335" r="14" stroke-width="8" />
+    </g>
+    <use href="#eldrun-branches" transform="translate(512,0) scale(-1,1)" />
+  </g>
+
+  <!-- Gold four-point spark above the trunk. -->
+  <path d="M 256 61
+           C 261 92 268 96 292 101
+           C 268 106 261 110 256 142
+           C 251 110 244 106 220 101
+           C 244 96 251 92 256 61 Z"
+        fill="#C79A45" />
+</svg>
diff --git a/src/assets/logo.svg b/src/assets/logo.svg
index 5f25832..22c95a3 100644
--- a/src/assets/logo.svg
+++ b/src/assets/logo.svg
@@ -17,8 +17,8 @@
     <g id="eldrun-branches">
       <!-- L1: node → vertical → 45° diagonal → leg → splayed foot. -->
       <path d="M 165 176 L 165 238 L 233 306 L 233 440 L 222 483" stroke-width="10" />
-      <!-- L2 → vertical → diagonal → L3 → 45° diagonal down into the leg. -->
-      <path d="M 98 235 L 98 289 L 144 335 L 233 405" stroke-width="10" />
+      <!-- L2 → vertical → diagonal → L3 (trace stops short of the pad on both sides) → 45° diagonal down into the leg. -->
+      <path d="M 98 235 L 98 289 L 129.9 320.9 M 159.7 347.4 L 233 405" stroke-width="10" />
       <!-- Node terminals (thinner stroke than the traces). -->
       <circle cx="165" cy="162" r="14" stroke-width="8" />
       <circle cx="98"  cy="221" r="14" stroke-width="8" />
diff --git a/src/components/calendar/AgendaView.tsx b/src/components/calendar/AgendaView.tsx
new file mode 100644
index 0000000..ffd95b9
--- /dev/null
+++ b/src/components/calendar/AgendaView.tsx
@@ -0,0 +1,89 @@
+import { useMemo } from "react";
+import type { Calendar, Occurrence } from "../../types";
+import { datePart, formatLongDate, formatTime, spanDates, todayStr } from "../../lib/calendarTime";
+import { eventColor } from "../../lib/calendarCategories";
+import { calendarColor } from "../../stores/calendar";
+
+interface Props {
+  occurrences: Occurrence[];
+  calendars: Calendar[];
+  use24h: boolean;
+  onOpen: (occurrence: Occurrence) => void;
+  /** What the list is showing, for the empty state (e.g. a search with no hits). */
+  emptyLabel?: string;
+}
+
+/**
+ * A flat, chronological list of everything in the window, grouped by day.
+ *
+ * This is also the view a search falls back to: filtering in a month grid hides
+ * the matches among empty cells, whereas a list shows exactly the hits.
+ */
+export function AgendaView({ occurrences, calendars, use24h, onOpen, emptyLabel }: Props) {
+  const today = todayStr();
+
+  /**
+   * Group by day. A multi-day event appears under each day it covers — the same
+   * event listed on each of its days is what a reader scanning "what's on
+   * Thursday" actually wants, even if it started on Tuesday.
+   */
+  const days = useMemo(() => {
+    const map = new Map<string, Occurrence[]>();
+    for (const occ of occurrences) {
+      for (const date of spanDates({ start: occ.start, end: occ.end, allDay: occ.allDay })) {
+        const list = map.get(date);
+        if (list) list.push(occ);
+        else map.set(date, [occ]);
+      }
+    }
+    return [...map.entries()].sort(([a], [b]) => a.localeCompare(b));
+  }, [occurrences]);
+
+  if (days.length === 0) {
+    return <div className="cal-empty">{emptyLabel ?? "Nothing scheduled."}</div>;
+  }
+
+  return (
+    <div className="cal-agenda">
+      {days.map(([date, list]) => (
+        <div key={date} className="cal-agenda-day">
+          <div
+            className={`cal-agenda-date${date === today ? " cal-agenda-date-today" : ""}`}
+          >
+            {formatLongDate(date)}
+            {date === today ? <span className="cal-agenda-today-tag">Today</span> : null}
+          </div>
+
+          {list.map((occ) => {
+            const color = eventColor(occ.category, calendarColor(calendars, occ.calendarId));
+            // A multi-day event shows "all day" on the days it merely passes through.
+            const startsHere = datePart(occ.start) === date;
+            return (
+              <div
+                key={`${occ.eventId}:${occ.occurrenceStart}:${date}`}
+                className={
+                  "cal-agenda-row" +
+                  (occ.status === "cancelled" ? " cal-block-cancelled" : "")
+                }
+                onDoubleClick={() => onOpen(occ)}
+              >
+                <span className="cal-agenda-swatch" style={{ color }}>●</span>
+                <span className="cal-agenda-time">
+                  {occ.allDay
+                    ? "All day"
+                    : startsHere
+                      ? formatTime(occ.start.split("T")[1] ?? "", use24h)
+                      : "continues"}
+                </span>
+                <span className="cal-agenda-title">{occ.title || "(untitled)"}</span>
+                {occ.location ? (
+                  <span className="cal-agenda-location">{occ.location}</span>
+                ) : null}
+              </div>
+            );
+          })}
+        </div>
+      ))}
+    </div>
+  );
+}
diff --git a/src/components/calendar/AlarmPopup.tsx b/src/components/calendar/AlarmPopup.tsx
new file mode 100644
index 0000000..605c6dc
--- /dev/null
+++ b/src/components/calendar/AlarmPopup.tsx
@@ -0,0 +1,99 @@
+import { useEffect } from "react";
+import { createPortal } from "react-dom";
+import { useAlarmStore } from "../../stores/alarms";
+import { useCalendarStore } from "../../stores/calendar";
+import { describeLead } from "../../lib/alarms";
+import { formatLongDate, formatStampTime } from "../../lib/calendarTime";
+
+/** The snooze offsets the buttons offer. */
+const SNOOZES: { label: string; minutes: number }[] = [
+  { label: "5 min", minutes: 5 },
+  { label: "15 min", minutes: 15 },
+  { label: "1 hour", minutes: 60 },
+  { label: "Tomorrow", minutes: 24 * 60 },
+];
+
+/**
+ * The in-app reminder popup — Thunderbird's alarm dialog.
+ *
+ * Mounted once at the app shell, not inside the calendar pane, so a reminder
+ * reaches the user whatever they are looking at: there is no point firing an
+ * alarm that only shows on the tab they are not on. It pairs with the OS
+ * notification the alarm store sends; this is the half that can be snoozed.
+ *
+ * It renders nothing at all when no reminder is due, so it costs nothing to have
+ * always mounted.
+ */
+export function AlarmPopup() {
+  const active = useAlarmStore((s) => s.active);
+  const dismiss = useAlarmStore((s) => s.dismiss);
+  const dismissAll = useAlarmStore((s) => s.dismissAll);
+  const snooze = useAlarmStore((s) => s.snooze);
+  const start = useAlarmStore((s) => s.start);
+
+  const loaded = useCalendarStore((s) => s.loaded);
+  const load = useCalendarStore((s) => s.load);
+
+  // Reminders must fire whether or not a calendar tab was ever opened, so the
+  // shell — not the pane — is what guarantees the calendar is loaded and the
+  // ticker running.
+  useEffect(() => {
+    if (!loaded) void load();
+  }, [loaded, load]);
+
+  useEffect(() => {
+    if (loaded) start();
+  }, [loaded, start]);
+
+  if (active.length === 0) return null;
+
+  return createPortal(
+    <div className="cal-alarm-popup">
+      <div className="cal-alarm-head">
+        <span className="cal-alarm-title">
+          {active.length === 1 ? "Reminder" : `${active.length} reminders`}
+        </span>
+        {active.length > 1 ? (
+          <button className="cal-link-btn" onClick={dismissAll}>Dismiss all</button>
+        ) : null}
+      </div>
+
+      <div className="cal-alarm-list">
+        {active.map((alarm) => (
+          <div key={alarm.key} className="cal-alarm-row">
+            <div className="cal-alarm-main">
+              <div className="cal-alarm-event">{alarm.title || "(untitled)"}</div>
+              <div className="cal-alarm-when">
+                {alarm.allDay
+                  ? formatLongDate(alarm.start.split("T")[0])
+                  : `${formatStampTime(alarm.start, true)} · ${describeLead(alarm.minutesBefore)}`}
+                {alarm.location ? ` · ${alarm.location}` : ""}
+              </div>
+            </div>
+
+            <div className="cal-alarm-actions">
+              <span className="cal-alarm-snooze-label">Snooze</span>
+              {SNOOZES.map((s) => (
+                <button
+                  key={s.minutes}
+                  className="cal-chip"
+                  onClick={() => snooze(alarm.key, s.minutes)}
+                  title={`Remind me again in ${s.label}`}
+                >
+                  {s.label}
+                </button>
+              ))}
+              <button
+                className="cal-btn cal-btn-primary"
+                onClick={() => dismiss(alarm.key)}
+              >
+                Dismiss
+              </button>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/calendar/CalendarPane.tsx b/src/components/calendar/CalendarPane.tsx
new file mode 100644
index 0000000..3dc9d76
--- /dev/null
+++ b/src/components/calendar/CalendarPane.tsx
@@ -0,0 +1,654 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { open as openDialog, save as saveDialog } from "@tauri-apps/plugin-dialog";
+import { useCalendarStore, visibleCalendarIds } from "../../stores/calendar";
+import { useSettingsStore } from "../../stores/settings";
+import type {
+  CalendarEvent,
+  CalendarViewKind,
+  Occurrence,
+} from "../../types";
+import {
+  addDays,
+  addMonths,
+  datePart,
+  dateRange,
+  formatLongDate,
+  minutesBetween,
+  monthGrid,
+  startOfWeek,
+  todayStr,
+  weekDates,
+} from "../../lib/calendarTime";
+import { expandEvents } from "../../lib/recurrence";
+import { parseIcs, serializeIcs } from "../../lib/ics";
+import { MonthView } from "./MonthView";
+import { TimeGrid } from "./TimeGrid";
+import { AgendaView } from "./AgendaView";
+import { TasksView } from "./TasksView";
+import { CalendarSidebar } from "./CalendarSidebar";
+import { EventDialog, type EditScope, type EventDialogTarget } from "./EventDialog";
+
+interface Props {
+  /** Whether this pane's tab is the visible one in its group. */
+  visible?: boolean;
+}
+
+const MONTHS = [
+  "January", "February", "March", "April", "May", "June",
+  "July", "August", "September", "October", "November", "December",
+];
+
+/** Weeks the multiweek view shows. */
+const MULTIWEEK_WEEKS = 4;
+
+const VIEWS: { kind: CalendarViewKind; label: string; key: string }[] = [
+  { kind: "day", label: "Day", key: "1" },
+  { kind: "week", label: "Week", key: "2" },
+  { kind: "multiweek", label: "Multiweek", key: "3" },
+  { kind: "month", label: "Month", key: "4" },
+  { kind: "agenda", label: "Agenda", key: "5" },
+  { kind: "tasks", label: "Tasks", key: "6" },
+];
+
+/**
+ * The native calendar tab.
+ *
+ * A shell around the views: a toolbar (view switcher, navigation, search,
+ * import/export), the sidebar (mini-month + calendar list), and whichever view is
+ * active. The event store is global — every calendar tab, in any project scope,
+ * shows the same events and sees the others' edits live.
+ *
+ * Views never read raw events. They consume *occurrences* — the result of
+ * expanding recurrence over the visible window (`expandEvents`) — so a repeating
+ * event is just many occurrences and no view has to know about rules.
+ */
+export function CalendarPane({ visible }: Props) {
+  const calendars = useCalendarStore((s) => s.calendars);
+  const events = useCalendarStore((s) => s.events);
+  const tasks = useCalendarStore((s) => s.tasks);
+  const loaded = useCalendarStore((s) => s.loaded);
+  const load = useCalendarStore((s) => s.load);
+  const createEvent = useCalendarStore((s) => s.createEvent);
+  const updateEvent = useCalendarStore((s) => s.updateEvent);
+  const deleteEvent = useCalendarStore((s) => s.deleteEvent);
+  const deleteOccurrence = useCalendarStore((s) => s.deleteOccurrence);
+  const updateOccurrence = useCalendarStore((s) => s.updateOccurrence);
+  const createTask = useCalendarStore((s) => s.createTask);
+  const updateTask = useCalendarStore((s) => s.updateTask);
+  const deleteTask = useCalendarStore((s) => s.deleteTask);
+  const createCalendar = useCalendarStore((s) => s.createCalendar);
+  const updateCalendar = useCalendarStore((s) => s.updateCalendar);
+  const deleteCalendar = useCalendarStore((s) => s.deleteCalendar);
+  const toggleCalendarVisible = useCalendarStore((s) => s.toggleCalendarVisible);
+
+  const settings = useSettingsStore((s) => s.settings);
+
+  const weekStart = (settings?.calendar_week_start ?? 0) as 0 | 1;
+  const use24h = settings?.calendar_time_format_24h ?? false;
+  const dayStartHour = settings?.calendar_day_start_hour ?? 8;
+  const defaultReminder = settings?.calendar_default_reminder_minutes ?? 0;
+
+  // Null until the user picks a view, so the configured default still applies when
+  // settings load *after* this pane mounts (a calendar tab restored at startup
+  // does exactly that). Snapshotting it into useState would silently ignore it.
+  const [picked, setPicked] = useState<CalendarViewKind | null>(null);
+  const view = picked ?? settings?.calendar_default_view ?? "month";
+  const setView = setPicked;
+
+  const [anchor, setAnchor] = useState(() => todayStr());
+  const [search, setSearch] = useState("");
+  const [dialog, setDialog] = useState<EventDialogTarget | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!loaded) void load();
+  }, [loaded, load]);
+
+  const visibleIds = useMemo(() => visibleCalendarIds(calendars), [calendars]);
+  const defaultCalendarId = calendars[0]?.id ?? "default";
+
+  // ── The visible window ────────────────────────────────────────────────────
+
+  /** The dates the active view covers — and thus the expansion window. */
+  const windowDates = useMemo((): string[] => {
+    switch (view) {
+      case "day":
+        return [datePart(anchor)];
+      case "week":
+        return weekDates(anchor, weekStart);
+      case "multiweek":
+        return dateRange(startOfWeek(anchor, weekStart), MULTIWEEK_WEEKS * 7);
+      case "month":
+        return monthGrid(
+          Number(anchor.slice(0, 4)),
+          Number(anchor.slice(5, 7)),
+          weekStart,
+          6,
+        ).flat();
+      case "agenda":
+        // The agenda looks forward a month from the anchor, like a "what's next" list.
+        return dateRange(datePart(anchor), 31);
+      case "tasks":
+        return [];
+    }
+  }, [view, anchor, weekStart]);
+
+  const windowStart = windowDates[0] ?? todayStr();
+  const windowEnd = windowDates.length
+    ? addDays(windowDates[windowDates.length - 1], 1)
+    : addDays(windowStart, 1);
+
+  /** Everything visible in the window, with recurrence expanded. */
+  const occurrences = useMemo(
+    () => expandEvents(events, windowStart, windowEnd, visibleIds),
+    [events, windowStart, windowEnd, visibleIds],
+  );
+
+  /** Search filters what the views draw, across title, location and notes. */
+  const shown = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    if (!q) return occurrences;
+    return occurrences.filter((o) =>
+      `${o.title} ${o.location} ${o.notes}`.toLowerCase().includes(q),
+    );
+  }, [occurrences, search]);
+
+  // ── Navigation ────────────────────────────────────────────────────────────
+
+  const shift = useCallback(
+    (dir: -1 | 1) => {
+      setAnchor((a) => {
+        switch (view) {
+          case "day":
+            return addDays(a, dir);
+          case "week":
+            return addDays(a, 7 * dir);
+          case "multiweek":
+            return addDays(a, MULTIWEEK_WEEKS * 7 * dir);
+          case "month":
+            return addMonths(a, dir);
+          case "agenda":
+            return addDays(a, 31 * dir);
+          case "tasks":
+            return a;
+        }
+      });
+    },
+    [view],
+  );
+
+  /** The heading over the grid — what range you are looking at. */
+  const title = useMemo(() => {
+    if (view === "tasks") return "Tasks";
+    if (view === "day") return formatLongDate(datePart(anchor));
+    if (view === "month") {
+      return `${MONTHS[Number(anchor.slice(5, 7)) - 1]} ${anchor.slice(0, 4)}`;
+    }
+    const first = windowDates[0];
+    const last = windowDates[windowDates.length - 1];
+    if (!first || !last) return "";
+    return `${formatLongDate(first)} – ${formatLongDate(last)}`;
+  }, [view, anchor, windowDates]);
+
+  // Arrow keys and view digits, scoped to the pane (it must not steal keys from
+  // a terminal in another tab, so the handler lives on the pane, not the window).
+  const onKeyDown = (e: React.KeyboardEvent) => {
+    if (dialog) return;
+    if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
+
+    if (e.key === "ArrowLeft") {
+      shift(-1);
+    } else if (e.key === "ArrowRight") {
+      shift(1);
+    } else if (e.key === "t" || e.key === "T") {
+      setAnchor(todayStr());
+    } else if (e.key === "n" || e.key === "N") {
+      openCreate(datePart(anchor));
+    } else {
+      const match = VIEWS.find((v) => v.key === e.key);
+      if (match) setView(match.kind);
+      else return;
+    }
+    e.preventDefault();
+  };
+
+  // ── Event editing ─────────────────────────────────────────────────────────
+
+  /**
+   * Open the editor on a new event. A new event is always *timed* (09:00-10:00 by
+   * default, or whatever span a grid drag produced) — "All day" is a checkbox the
+   * user ticks. The draft must stay internally consistent: an all-day draft
+   * carries bare dates and an exclusive end, so handing one a timed end would make
+   * the dialog step it back a day and land the end before the start.
+   */
+  function openCreate(date: string, start?: string, end?: string) {
+    setDialog({
+      event: null,
+      occurrence: null,
+      draftStart: start ?? `${datePart(date)}T09:00`,
+      draftEnd: end ?? `${datePart(date)}T10:00`,
+      draftAllDay: false,
+    });
+  }
+
+  function openOccurrence(occ: Occurrence) {
+    const event = events.find((e) => e.id === occ.eventId);
+    if (!event) return;
+    setDialog({ event, occurrence: occ });
+  }
+
+  async function saveFromDialog(event: CalendarEvent, scope: EditScope) {
+    const target = dialog;
+    setDialog(null);
+
+    // Creating.
+    if (!target?.event) {
+      const { id: _id, ...draft } = event;
+      await createEvent(draft);
+      return;
+    }
+
+    // Editing one occurrence of a series → store an override, leave the rest.
+    if (scope === "this" && target.occurrence) {
+      await updateOccurrence(target.event.id, target.occurrence.occurrenceStart, {
+        start: event.start,
+        end: event.end,
+        title: event.title,
+        location: event.location ?? "",
+        notes: event.notes ?? "",
+      });
+      return;
+    }
+
+    // Editing the series (or a plain event).
+    //
+    // When the user edited an *occurrence* and chose "all", the times they see are
+    // that occurrence's, not the master's — writing them straight onto the master
+    // would drag the whole series onto that one occurrence's date. So only the
+    // duration and the time-of-day carry over; the master keeps its own start date.
+    let next = event;
+    if (target.occurrence && target.occurrence.occurrenceStart !== target.event.start) {
+      const masterDate = datePart(target.event.start);
+      const durationMin = minutesBetween(event.start, event.end);
+      const startTime = event.start.split("T")[1];
+      const start = event.all_day ? masterDate : `${masterDate}T${startTime}`;
+      const end = event.all_day
+        ? addDays(masterDate, Math.max(1, Math.round(minutesBetween(event.start, event.end) / 1440)))
+        : shiftBy(start, durationMin);
+      next = { ...event, start, end };
+    }
+    await updateEvent(next);
+  }
+
+  async function deleteFromDialog(event: CalendarEvent, scope: EditScope) {
+    const target = dialog;
+    setDialog(null);
+    if (scope === "this" && target?.occurrence) {
+      await deleteOccurrence(event.id, target.occurrence.occurrenceStart);
+      return;
+    }
+    await deleteEvent(event.id);
+  }
+
+  /** A drag in the time grid created a span. */
+  const onCreateSpan = useCallback((start: string, end: string) => {
+    setDialog({
+      event: null,
+      occurrence: null,
+      draftStart: start,
+      draftEnd: end,
+      draftAllDay: false,
+    });
+  }, []);
+
+  /**
+   * A block was dragged to a new time. A single occurrence of a series moves as
+   * an override; a plain event moves outright. Either way the duration is kept.
+   */
+  const onMove = useCallback(
+    async (occ: Occurrence, newStart: string) => {
+      const event = events.find((e) => e.id === occ.eventId);
+      if (!event) return;
+      const durationMin = minutesBetween(occ.start, occ.end);
+      const newEnd = shiftBy(newStart, durationMin);
+
+      if (occ.recurring) {
+        await updateOccurrence(occ.eventId, occ.occurrenceStart, {
+          start: newStart,
+          end: newEnd,
+        });
+        return;
+      }
+      await updateEvent({ ...event, start: newStart, end: newEnd });
+    },
+    [events, updateEvent, updateOccurrence],
+  );
+
+  /** A block's bottom edge was dragged. */
+  const onResize = useCallback(
+    async (occ: Occurrence, newEnd: string) => {
+      const event = events.find((e) => e.id === occ.eventId);
+      if (!event) return;
+      if (occ.recurring) {
+        await updateOccurrence(occ.eventId, occ.occurrenceStart, {
+          start: occ.start,
+          end: newEnd,
+        });
+        return;
+      }
+      await updateEvent({ ...event, end: newEnd });
+    },
+    [events, updateEvent, updateOccurrence],
+  );
+
+  // ── ICS ───────────────────────────────────────────────────────────────────
+
+  async function importIcs() {
+    const path = await openDialog({
+      multiple: false,
+      filters: [{ name: "iCalendar", extensions: ["ics", "ical", "ifb"] }],
+    });
+    if (typeof path !== "string") return;
+
+    try {
+      // A dedicated, extension-guarded command — the general file-read command is
+      // confined to the current project and would refuse a path in ~/Downloads.
+      const text = await invoke<string>("calendar_read_ics", { path });
+      const parsed = parseIcs(text);
+
+      // Imported items land in their own calendar, so an import is easy to undo by
+      // deleting that one calendar — and can never silently mix into "Personal".
+      const name = fileStem(path);
+      const target = await createCalendar({
+        name: name || "Imported",
+        color: "#8d8fd6",
+        visible: true,
+        readonly: false,
+      });
+
+      for (const e of parsed.events) {
+        await createEvent({ ...e, calendar_id: target.id });
+      }
+      for (const t of parsed.tasks) {
+        await createTask({ ...t, calendar_id: target.id });
+      }
+
+      setNotice(
+        `Imported ${parsed.events.length} event(s)` +
+          (parsed.tasks.length ? ` and ${parsed.tasks.length} task(s)` : "") +
+          ` into “${target.name}”` +
+          (parsed.skipped ? ` — skipped ${parsed.skipped} unsupported item(s).` : "."),
+      );
+    } catch (err) {
+      setNotice(`Import failed: ${String(err)}`);
+    }
+  }
+
+  async function exportIcs() {
+    const path = await saveDialog({
+      defaultPath: "eldrun-calendar.ics",
+      filters: [{ name: "iCalendar", extensions: ["ics"] }],
+    });
+    if (typeof path !== "string") return;
+
+    try {
+      // Export what is checked in the sidebar — the same set the views show, so
+      // what you see is what you get.
+      const text = serializeIcs(
+        events.filter((e) => visibleIds.has(e.calendar_id)),
+        tasks.filter((t) => visibleIds.has(t.calendar_id)),
+      );
+      await invoke<void>("calendar_write_ics", { path, content: text });
+      setNotice(`Exported to ${path}`);
+    } catch (err) {
+      setNotice(`Export failed: ${String(err)}`);
+    }
+  }
+
+  // ── Render ────────────────────────────────────────────────────────────────
+
+  const gridPrefs = { use24h, dayStartHour };
+
+  return (
+    <div
+      className="cal-pane"
+      style={{ display: visible === false ? "none" : undefined }}
+      tabIndex={0}
+      onKeyDown={onKeyDown}
+    >
+      <div className="cal-toolbar">
+        <div className="cal-toolbar-nav">
+          <button className="cal-nav-btn" onClick={() => shift(-1)} title="Previous (←)">‹</button>
+          <button className="cal-btn" onClick={() => setAnchor(todayStr())} title="Today (T)">
+            Today
+          </button>
+          <button className="cal-nav-btn" onClick={() => shift(1)} title="Next (→)">›</button>
+        </div>
+
+        <div className="cal-toolbar-title">{title}</div>
+
+        <div className="cal-toolbar-views">
+          {VIEWS.map((v) => (
+            <button
+              key={v.kind}
+              className={`cal-chip${view === v.kind ? " cal-chip-on" : ""}`}
+              onClick={() => setView(v.kind)}
+              title={`${v.label} (${v.key})`}
+            >
+              {v.label}
+            </button>
+          ))}
+        </div>
+
+        <input
+          className="cal-input cal-search"
+          type="search"
+          placeholder="Search events…"
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+        />
+
+        <div className="cal-toolbar-actions">
+          <button
+            className="cal-btn cal-btn-primary"
+            onClick={() => openCreate(datePart(anchor))}
+            title="New event (N)"
+          >
+            + Event
+          </button>
+          <button className="cal-btn" onClick={() => void importIcs()} title="Import an .ics file">
+            Import
+          </button>
+          <button className="cal-btn" onClick={() => void exportIcs()} title="Export to an .ics file">
+            Export
+          </button>
+        </div>
+      </div>
+
+      {notice ? (
+        <div className="cal-notice" onClick={() => setNotice(null)} title="Click to dismiss">
+          {notice}
+        </div>
+      ) : null}
+
+      <div className="cal-body">
+        <CalendarSidebar
+          calendars={calendars}
+          selected={anchor}
+          onSelect={(date) => setAnchor(date)}
+          onToggleVisible={(id) => void toggleCalendarVisible(id)}
+          onCreateCalendar={(name, color) =>
+            void createCalendar({ name, color, visible: true, readonly: false })
+          }
+          onUpdateCalendar={(cal) => void updateCalendar(cal)}
+          onDeleteCalendar={(id) => void deleteCalendar(id)}
+          weekStart={weekStart}
+        />
+
+        <div className="cal-view">
+          {view === "tasks" ? (
+            <TasksView
+              tasks={tasks}
+              calendars={calendars}
+              visibleCalendars={visibleIds}
+              search={search}
+              onCreate={createTask}
+              onUpdate={updateTask}
+              onDelete={deleteTask}
+              defaultCalendarId={defaultCalendarId}
+            />
+          ) : view === "agenda" ? (
+            <AgendaView
+              occurrences={shown}
+              calendars={calendars}
+              use24h={use24h}
+              onOpen={openOccurrence}
+              emptyLabel={
+                search.trim() ? `No events match “${search.trim()}”.` : "Nothing scheduled."
+              }
+            />
+          ) : view === "month" || view === "multiweek" ? (
+            <MonthView
+              weeks={chunk(windowDates, 7)}
+              month={view === "month" ? Number(anchor.slice(5, 7)) : null}
+              occurrences={shown}
+              calendars={calendars}
+              use24h={use24h}
+              selected={datePart(anchor)}
+              onSelect={(date) => setAnchor(date)}
+              onCreateOn={(date) => openCreate(date)}
+              onOpen={openOccurrence}
+              weekStart={weekStart}
+            />
+          ) : (
+            <div className="cal-timeview">
+              <AllDayBar
+                dates={windowDates}
+                occurrences={shown}
+                onOpen={openOccurrence}
+                selected={datePart(anchor)}
+                onSelect={(date) => setAnchor(date)}
+              />
+              <TimeGrid
+                dates={windowDates}
+                occurrences={shown}
+                calendars={calendars}
+                prefs={gridPrefs}
+                onOpen={openOccurrence}
+                onCreate={onCreateSpan}
+                onMove={(occ, start) => void onMove(occ, start)}
+                onResize={(occ, end) => void onResize(occ, end)}
+              />
+            </div>
+          )}
+        </div>
+      </div>
+
+      {dialog ? (
+        <EventDialog
+          target={dialog}
+          calendars={calendars}
+          defaultCalendarId={defaultCalendarId}
+          defaultReminderMinutes={defaultReminder}
+          onClose={() => setDialog(null)}
+          onSave={saveFromDialog}
+          onDelete={deleteFromDialog}
+        />
+      ) : null}
+    </div>
+  );
+}
+
+/**
+ * The strip above the day/week grid: the date headers, plus the all-day events,
+ * which have no place on an hour grid.
+ */
+function AllDayBar({
+  dates,
+  occurrences,
+  onOpen,
+  selected,
+  onSelect,
+}: {
+  dates: string[];
+  occurrences: Occurrence[];
+  onOpen: (o: Occurrence) => void;
+  selected: string;
+  onSelect: (date: string) => void;
+}) {
+  const today = todayStr();
+  const allDay = occurrences.filter((o) => o.allDay);
+
+  return (
+    <div className="cal-allday">
+      <div className="cal-allday-gutter">all-day</div>
+      <div className="cal-allday-cols">
+        {dates.map((date) => {
+          const here = allDay.filter((o) =>
+            dateWithin(o, date),
+          );
+          const d = new Date(`${date}T12:00`);
+          return (
+            <div
+              key={date}
+              className={
+                "cal-allday-col" +
+                (date === today ? " cal-allday-col-today" : "") +
+                (date === selected ? " cal-allday-col-selected" : "")
+              }
+              onClick={() => onSelect(date)}
+            >
+              <div className="cal-allday-head">
+                <span className="cal-allday-dow">
+                  {d.toLocaleDateString("en", { weekday: "short" })}
+                </span>
+                <span className="cal-allday-num">{Number(date.slice(8, 10))}</span>
+              </div>
+              {here.map((o) => (
+                <div
+                  key={`${o.eventId}:${o.occurrenceStart}`}
+                  className="cal-allday-chip"
+                  onDoubleClick={(e) => {
+                    e.stopPropagation();
+                    onOpen(o);
+                  }}
+                  title={o.title}
+                >
+                  {o.title || "(untitled)"}
+                </div>
+              ))}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
+function dateWithin(o: Occurrence, date: string): boolean {
+  return datePart(o.start) <= date && date < datePart(o.end);
+}
+
+/** Split a flat date list into rows of `n`. */
+function chunk(dates: string[], n: number): string[][] {
+  const out: string[][] = [];
+  for (let i = 0; i < dates.length; i += n) out.push(dates.slice(i, i + n));
+  return out;
+}
+
+/** A stamp plus a duration in minutes. */
+function shiftBy(start: string, minutes: number): string {
+  const total = Math.max(15, minutes);
+  const [date, time] = start.split("T");
+  const [h, m] = (time ?? "00:00").split(":").map(Number);
+  const end = h * 60 + m + total;
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${addDays(date, Math.floor(end / 1440))}T${p(Math.floor((end % 1440) / 60))}:${p(end % 60)}`;
+}
+
+/** The bare filename, for naming an imported calendar. */
+function fileStem(path: string): string {
+  const base = path.split(/[\\/]/).pop() ?? "";
+  return base.replace(/\.(ics|ical|ifb)$/i, "");
+}
diff --git a/src/components/calendar/CalendarSidebar.tsx b/src/components/calendar/CalendarSidebar.tsx
new file mode 100644
index 0000000..2ac8783
--- /dev/null
+++ b/src/components/calendar/CalendarSidebar.tsx
@@ -0,0 +1,213 @@
+import { useMemo, useState } from "react";
+import type { Calendar } from "../../types";
+import { addMonths, datePart, monthGrid, todayStr } from "../../lib/calendarTime";
+
+const MONTHS = [
+  "January", "February", "March", "April", "May", "June",
+  "July", "August", "September", "October", "November", "December",
+];
+const WEEKDAY_INITIALS = ["S", "M", "T", "W", "T", "F", "S"];
+
+/** The palette a new calendar picks from. */
+const CALENDAR_COLORS = [
+  "#4aa3df", "#e8663d", "#59b96a", "#c164d6",
+  "#e2b93b", "#d9556b", "#4fc3c3", "#8d8fd6",
+];
+
+interface Props {
+  calendars: Calendar[];
+  /** The date the mini-month highlights and navigates from. */
+  selected: string;
+  onSelect: (date: string) => void;
+  onToggleVisible: (id: string) => void;
+  onCreateCalendar: (name: string, color: string) => void;
+  onUpdateCalendar: (calendar: Calendar) => void;
+  onDeleteCalendar: (id: string) => void;
+  weekStart: 0 | 1;
+}
+
+/**
+ * The left rail: a mini-month for jumping around, and the calendar list.
+ *
+ * Unchecking a calendar hides its events everywhere (the checkbox writes through
+ * to `visible` on disk, so the choice survives a restart — same as Thunderbird).
+ */
+export function CalendarSidebar({
+  calendars,
+  selected,
+  onSelect,
+  onToggleVisible,
+  onCreateCalendar,
+  onUpdateCalendar,
+  onDeleteCalendar,
+  weekStart,
+}: Props) {
+  // The mini-month browses independently of the main view's anchor, so you can
+  // look ahead without moving what you are working on until you click a day.
+  const [browse, setBrowse] = useState(() => datePart(selected));
+  const [adding, setAdding] = useState(false);
+  const [newName, setNewName] = useState("");
+  const [editing, setEditing] = useState<string | null>(null);
+
+  const today = todayStr();
+  const year = Number(browse.slice(0, 4));
+  const month = Number(browse.slice(5, 7));
+
+  const weeks = useMemo(
+    () => monthGrid(year, month, weekStart, 6),
+    [year, month, weekStart],
+  );
+
+  const labels = useMemo(
+    () => [...WEEKDAY_INITIALS.slice(weekStart), ...WEEKDAY_INITIALS.slice(0, weekStart)],
+    [weekStart],
+  );
+
+  function submitNew() {
+    const name = newName.trim();
+    if (!name) return;
+    // Cycle the palette so a fresh calendar never collides with the last one.
+    onCreateCalendar(name, CALENDAR_COLORS[calendars.length % CALENDAR_COLORS.length]);
+    setNewName("");
+    setAdding(false);
+  }
+
+  return (
+    <div className="cal-sidebar">
+      <div className="cal-mini">
+        <div className="cal-mini-head">
+          <button
+            className="cal-nav-btn"
+            onClick={() => setBrowse(addMonths(browse, -1))}
+            title="Previous month"
+          >
+            ‹
+          </button>
+          <span className="cal-mini-title">{MONTHS[month - 1]} {year}</span>
+          <button
+            className="cal-nav-btn"
+            onClick={() => setBrowse(addMonths(browse, 1))}
+            title="Next month"
+          >
+            ›
+          </button>
+        </div>
+
+        <div className="cal-mini-weekdays">
+          {labels.map((w, i) => (
+            <span key={i} className="cal-mini-weekday">{w}</span>
+          ))}
+        </div>
+
+        {weeks.map((week, wi) => (
+          <div key={wi} className="cal-mini-week">
+            {week.map((date) => {
+              const inMonth = Number(date.slice(5, 7)) === month;
+              const classes = ["cal-mini-day"];
+              if (!inMonth) classes.push("cal-mini-day-out");
+              if (date === today) classes.push("cal-mini-day-today");
+              if (date === datePart(selected)) classes.push("cal-mini-day-selected");
+              return (
+                <button
+                  key={date}
+                  className={classes.join(" ")}
+                  onClick={() => onSelect(date)}
+                >
+                  {Number(date.slice(8, 10))}
+                </button>
+              );
+            })}
+          </div>
+        ))}
+      </div>
+
+      <div className="cal-list">
+        <div className="cal-list-head">
+          <span className="cal-list-title">Calendars</span>
+          <button className="cal-link-btn" onClick={() => setAdding((a) => !a)}>
+            + New
+          </button>
+        </div>
+
+        {adding ? (
+          <div className="cal-list-add">
+            <input
+              className="cal-input"
+              type="text"
+              placeholder="Calendar name"
+              autoFocus
+              value={newName}
+              onChange={(e) => setNewName(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") submitNew();
+                if (e.key === "Escape") {
+                  setAdding(false);
+                  setNewName("");
+                }
+              }}
+            />
+            <button className="cal-btn cal-btn-primary" disabled={!newName.trim()} onClick={submitNew}>
+              Add
+            </button>
+          </div>
+        ) : null}
+
+        {calendars.map((cal) => (
+          <div key={cal.id} className="cal-list-row">
+            <input
+              type="checkbox"
+              checked={cal.visible}
+              onChange={() => onToggleVisible(cal.id)}
+              title={cal.visible ? "Hide this calendar" : "Show this calendar"}
+            />
+
+            <input
+              type="color"
+              className="cal-color-dot"
+              value={cal.color}
+              title="Calendar color"
+              onChange={(e) => onUpdateCalendar({ ...cal, color: e.target.value })}
+            />
+
+            {editing === cal.id ? (
+              <input
+                className="cal-input cal-list-rename"
+                type="text"
+                autoFocus
+                defaultValue={cal.name}
+                onBlur={(e) => {
+                  const name = e.target.value.trim();
+                  if (name && name !== cal.name) onUpdateCalendar({ ...cal, name });
+                  setEditing(null);
+                }}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") (e.target as HTMLInputElement).blur();
+                  if (e.key === "Escape") setEditing(null);
+                }}
+              />
+            ) : (
+              <span
+                className={`cal-list-name${cal.visible ? "" : " cal-list-name-off"}`}
+                onDoubleClick={() => setEditing(cal.id)}
+                title="Double-click to rename"
+              >
+                {cal.name}
+              </span>
+            )}
+
+            {/* The last calendar cannot be deleted — the store always keeps one. */}
+            {calendars.length > 1 ? (
+              <button
+                className="cal-link-btn cal-link-danger cal-list-del"
+                title="Delete this calendar and everything on it"
+                onClick={() => onDeleteCalendar(cal.id)}
+              >
+                ×
+              </button>
+            ) : null}
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/calendar/EventDialog.tsx b/src/components/calendar/EventDialog.tsx
new file mode 100644
index 0000000..5b9f2d6
--- /dev/null
+++ b/src/components/calendar/EventDialog.tsx
@@ -0,0 +1,601 @@
+import { useEffect, useMemo, useState } from "react";
+import { createPortal } from "react-dom";
+import type {
+  Alarm,
+  Calendar,
+  CalendarEvent,
+  EventStatus,
+  Freq,
+  Occurrence,
+  Rrule,
+} from "../../types";
+import { CATEGORIES } from "../../lib/calendarCategories";
+import {
+  allDayEndToLastDay,
+  datePart,
+  lastDayToAllDayEnd,
+  minutesBetween,
+  timePart,
+} from "../../lib/calendarTime";
+import { describeRrule } from "../../lib/recurrence";
+
+/** The reminder offsets the dropdown offers, in minutes before the start. */
+const REMINDER_CHOICES: { label: string; minutes: number }[] = [
+  { label: "At the time of the event", minutes: 0 },
+  { label: "5 minutes before", minutes: 5 },
+  { label: "15 minutes before", minutes: 15 },
+  { label: "30 minutes before", minutes: 30 },
+  { label: "1 hour before", minutes: 60 },
+  { label: "1 day before", minutes: 1440 },
+];
+
+const WEEKDAY_INITIALS = ["S", "M", "T", "W", "T", "F", "S"];
+
+/** What the dialog was opened on. */
+export interface EventDialogTarget {
+  /** The stored event, or null when creating. */
+  event: CalendarEvent | null;
+  /** The occurrence clicked, when editing one instance of a series. */
+  occurrence: Occurrence | null;
+  /** Prefilled span for a new event (from a drag or a day double-click). */
+  draftStart?: string;
+  draftEnd?: string;
+  draftAllDay?: boolean;
+}
+
+/** How an edit to a recurring event should apply. */
+export type EditScope = "this" | "all";
+
+interface Props {
+  target: EventDialogTarget;
+  calendars: Calendar[];
+  defaultCalendarId: string;
+  defaultReminderMinutes: number;
+  onClose: () => void;
+  /** Save. `scope` is meaningful only for a recurring event. */
+  onSave: (event: CalendarEvent, scope: EditScope) => Promise<void> | void;
+  onDelete: (event: CalendarEvent, scope: EditScope) => Promise<void> | void;
+}
+
+/** The dialog's editable form state. */
+interface Form {
+  calendarId: string;
+  title: string;
+  location: string;
+  notes: string;
+  category: string;
+  status: EventStatus;
+  allDay: boolean;
+  startDate: string;
+  startTime: string;
+  endDate: string;
+  endTime: string;
+  repeats: boolean;
+  freq: Freq;
+  interval: number;
+  byweekday: number[];
+  /** `""` = forever, `"count"`, or `"until"`. */
+  endMode: "" | "count" | "until";
+  count: number;
+  until: string;
+  alarms: Alarm[];
+}
+
+/** Seed the form from the event/occurrence being edited, or from a new draft. */
+function initialForm(
+  target: EventDialogTarget,
+  defaultCalendarId: string,
+  defaultReminderMinutes: number,
+): Form {
+  const { event, occurrence } = target;
+
+  // When editing one occurrence of a series, the form shows THAT occurrence's
+  // times — not the master's — since that is what the user clicked on.
+  const start = occurrence?.start ?? event?.start ?? target.draftStart ?? "";
+  const end = occurrence?.end ?? event?.end ?? target.draftEnd ?? "";
+  const allDay = occurrence?.allDay ?? event?.all_day ?? target.draftAllDay ?? false;
+  const rrule = event?.rrule ?? null;
+
+  return {
+    calendarId: event?.calendar_id ?? defaultCalendarId,
+    title: occurrence?.title ?? event?.title ?? "",
+    location: occurrence?.location ?? event?.location ?? "",
+    notes: occurrence?.notes ?? event?.notes ?? "",
+    category: event?.category ?? "",
+    status: (event?.status || "confirmed") as EventStatus,
+    allDay,
+    startDate: datePart(start),
+    startTime: timePart(start) || "09:00",
+    // An all-day event's end is exclusive on disk; the picker shows the LAST day,
+    // which is what a user means by "ends on".
+    endDate: allDay ? allDayEndToLastDay(end) : datePart(end),
+    endTime: timePart(end) || "10:00",
+    repeats: !!rrule,
+    freq: rrule?.freq ?? "weekly",
+    interval: rrule?.interval ?? 1,
+    byweekday: rrule?.byweekday ?? [],
+    endMode: rrule?.count ? "count" : rrule?.until ? "until" : "",
+    count: rrule?.count ?? 10,
+    until: rrule?.until ?? "",
+    alarms:
+      event?.alarms ??
+      (defaultReminderMinutes > 0 && !event
+        ? [{ minutes_before: defaultReminderMinutes }]
+        : []),
+  };
+}
+
+/**
+ * The event editor.
+ *
+ * Reuses the app's canonical dialog shell (`.modal-backdrop` > `.settings-dialog`
+ * with an accent `.settings-title-row` header and divider), so it reads
+ * identically to every other modal. Being portaled, it sets its text color
+ * explicitly — `body` carries none, so an inherited color would render black.
+ *
+ * Editing an occurrence of a recurring event asks the "this one / the whole
+ * series" question on save, exactly once, rather than up front — most edits are
+ * to a single occurrence and the prompt would otherwise be pure friction.
+ */
+export function EventDialog({
+  target,
+  calendars,
+  defaultCalendarId,
+  defaultReminderMinutes,
+  onClose,
+  onSave,
+  onDelete,
+}: Props) {
+  const [form, setForm] = useState<Form>(() =>
+    initialForm(target, defaultCalendarId, defaultReminderMinutes),
+  );
+  /** Set when a recurring event needs its scope confirmed; holds the pending act. */
+  const [scopeAsk, setScopeAsk] = useState<"save" | "delete" | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const creating = target.event === null;
+  const recurring = !!target.event?.rrule;
+
+  useEffect(() => {
+    setForm(initialForm(target, defaultCalendarId, defaultReminderMinutes));
+    setScopeAsk(null);
+    setError(null);
+  }, [target, defaultCalendarId, defaultReminderMinutes]);
+
+  const patch = (p: Partial<Form>) => setForm((f) => ({ ...f, ...p }));
+
+  const ruleSummary = useMemo(
+    () => (form.repeats ? describeRrule(buildRrule(form)) : "Does not repeat"),
+    [form],
+  );
+
+  /** The form, back as a stored event. */
+  function toEvent(): CalendarEvent | null {
+    const title = form.title.trim();
+    if (!title) {
+      setError("A title is required.");
+      return null;
+    }
+    if (!form.startDate) {
+      setError("A start date is required.");
+      return null;
+    }
+
+    const start = form.allDay ? form.startDate : `${form.startDate}T${form.startTime}`;
+    const endDay = form.endDate || form.startDate;
+    const end = form.allDay
+      ? lastDayToAllDayEnd(endDay)
+      : `${endDay}T${form.endTime}`;
+
+    if (!form.allDay && minutesBetween(start, end) <= 0) {
+      setError("The event must end after it starts.");
+      return null;
+    }
+    if (form.allDay && lastDayToAllDayEnd(endDay) <= form.startDate) {
+      setError("The event must end on or after the day it starts.");
+      return null;
+    }
+
+    const base = target.event;
+    return {
+      id: base?.id ?? "",
+      calendar_id: form.calendarId,
+      start,
+      end,
+      all_day: form.allDay,
+      title,
+      location: form.location.trim(),
+      notes: form.notes.trim(),
+      category: form.category,
+      status: form.status,
+      rrule: form.repeats ? buildRrule(form) : null,
+      // Exdates/overrides belong to the series and must survive an edit to it.
+      exdates: base?.exdates ?? [],
+      overrides: base?.overrides ?? [],
+      alarms: form.alarms,
+    };
+  }
+
+  function attemptSave() {
+    setError(null);
+    const event = toEvent();
+    if (!event) return;
+    // Editing one occurrence of a series → ask which it applies to.
+    if (recurring && target.occurrence) {
+      setScopeAsk("save");
+      return;
+    }
+    void onSave(event, "all");
+  }
+
+  function attemptDelete() {
+    if (!target.event) return;
+    if (recurring && target.occurrence) {
+      setScopeAsk("delete");
+      return;
+    }
+    void onDelete(target.event, "all");
+  }
+
+  function resolveScope(scope: EditScope) {
+    const pending = scopeAsk;
+    setScopeAsk(null);
+    if (pending === "delete") {
+      if (target.event) void onDelete(target.event, scope);
+      return;
+    }
+    const event = toEvent();
+    if (event) void onSave(event, scope);
+  }
+
+  const toggleWeekday = (d: number) =>
+    patch({
+      byweekday: form.byweekday.includes(d)
+        ? form.byweekday.filter((x) => x !== d)
+        : [...form.byweekday, d].sort((a, b) => a - b),
+    });
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="settings-dialog cal-event-dialog"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{creating ? "New event" : "Edit event"}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+        {scopeAsk ? (
+          /* The this-one-or-all question. It replaces the form rather than
+             stacking a second modal on top of it — one decision, in place. */
+          <div className="cal-scope-ask">
+            <p className="settings-help">
+              <strong>{form.title || "This event"}</strong> repeats.{" "}
+              {scopeAsk === "delete"
+                ? "Delete only the occurrence you clicked, or the whole series?"
+                : "Apply your changes to only the occurrence you clicked, or to the whole series?"}
+            </p>
+            <div className="cal-form-actions">
+              <button className="cal-btn cal-btn-primary" onClick={() => resolveScope("this")}>
+                {scopeAsk === "delete" ? "Delete this occurrence" : "This occurrence only"}
+              </button>
+              <button className="cal-btn" onClick={() => resolveScope("all")}>
+                {scopeAsk === "delete" ? "Delete the whole series" : "All occurrences"}
+              </button>
+              <button className="cal-link-btn" onClick={() => setScopeAsk(null)}>
+                Cancel
+              </button>
+            </div>
+          </div>
+        ) : (
+          <div className="cal-event-form">
+            <label className="cal-field">
+              <span className="cal-field-label">Title</span>
+              <input
+                className="cal-input"
+                type="text"
+                autoFocus
+                value={form.title}
+                onChange={(e) => patch({ title: e.target.value })}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") attemptSave();
+                }}
+              />
+            </label>
+
+            <label className="cal-field">
+              <span className="cal-field-label">Location</span>
+              <input
+                className="cal-input"
+                type="text"
+                value={form.location}
+                onChange={(e) => patch({ location: e.target.value })}
+              />
+            </label>
+
+            <label className="cal-check-row">
+              <input
+                type="checkbox"
+                checked={form.allDay}
+                onChange={(e) => patch({ allDay: e.target.checked })}
+              />
+              <span>All day</span>
+            </label>
+
+            <div className="cal-field-row">
+              <label className="cal-field">
+                <span className="cal-field-label">Starts</span>
+                <div className="cal-datetime">
+                  <input
+                    className="cal-input"
+                    type="date"
+                    value={form.startDate}
+                    onChange={(e) => patch({ startDate: e.target.value })}
+                  />
+                  {!form.allDay ? (
+                    <input
+                      className="cal-input"
+                      type="time"
+                      value={form.startTime}
+                      onChange={(e) => patch({ startTime: e.target.value })}
+                    />
+                  ) : null}
+                </div>
+              </label>
+
+              <label className="cal-field">
+                <span className="cal-field-label">Ends</span>
+                <div className="cal-datetime">
+                  <input
+                    className="cal-input"
+                    type="date"
+                    value={form.endDate}
+                    onChange={(e) => patch({ endDate: e.target.value })}
+                  />
+                  {!form.allDay ? (
+                    <input
+                      className="cal-input"
+                      type="time"
+                      value={form.endTime}
+                      onChange={(e) => patch({ endTime: e.target.value })}
+                    />
+                  ) : null}
+                </div>
+              </label>
+            </div>
+
+            <div className="cal-field-row">
+              <label className="cal-field">
+                <span className="cal-field-label">Calendar</span>
+                <select
+                  className="cal-input"
+                  value={form.calendarId}
+                  onChange={(e) => patch({ calendarId: e.target.value })}
+                >
+                  {calendars.map((c) => (
+                    <option key={c.id} value={c.id}>{c.name}</option>
+                  ))}
+                </select>
+              </label>
+
+              <label className="cal-field">
+                <span className="cal-field-label">Category</span>
+                <select
+                  className="cal-input"
+                  value={form.category}
+                  onChange={(e) => patch({ category: e.target.value })}
+                >
+                  <option value="">None</option>
+                  {CATEGORIES.map((c) => (
+                    <option key={c.key} value={c.key}>{c.label}</option>
+                  ))}
+                </select>
+              </label>
+
+              <label className="cal-field">
+                <span className="cal-field-label">Status</span>
+                <select
+                  className="cal-input"
+                  value={form.status}
+                  onChange={(e) => patch({ status: e.target.value as EventStatus })}
+                >
+                  <option value="confirmed">Confirmed</option>
+                  <option value="tentative">Tentative</option>
+                  <option value="cancelled">Cancelled</option>
+                </select>
+              </label>
+            </div>
+
+            {/* ── Repeat ─────────────────────────────────────────────────── */}
+            <div className="cal-section">
+              <label className="cal-check-row">
+                <input
+                  type="checkbox"
+                  checked={form.repeats}
+                  onChange={(e) => patch({ repeats: e.target.checked })}
+                />
+                <span>Repeat</span>
+                <span className="cal-rule-summary">{ruleSummary}</span>
+              </label>
+
+              {form.repeats ? (
+                <div className="cal-repeat">
+                  <div className="cal-field-row">
+                    <label className="cal-field">
+                      <span className="cal-field-label">Every</span>
+                      <input
+                        className="cal-input cal-input-num"
+                        type="number"
+                        min={1}
+                        value={form.interval}
+                        onChange={(e) =>
+                          patch({ interval: Math.max(1, Number(e.target.value) || 1) })
+                        }
+                      />
+                    </label>
+                    <label className="cal-field">
+                      <span className="cal-field-label">&nbsp;</span>
+                      <select
+                        className="cal-input"
+                        value={form.freq}
+                        onChange={(e) => patch({ freq: e.target.value as Freq })}
+                      >
+                        <option value="daily">day(s)</option>
+                        <option value="weekly">week(s)</option>
+                        <option value="monthly">month(s)</option>
+                        <option value="yearly">year(s)</option>
+                      </select>
+                    </label>
+                  </div>
+
+                  {form.freq === "weekly" ? (
+                    <div className="cal-weekdays">
+                      {WEEKDAY_INITIALS.map((w, d) => (
+                        <button
+                          key={d}
+                          type="button"
+                          className={`cal-weekday-btn${form.byweekday.includes(d) ? " cal-weekday-on" : ""}`}
+                          onClick={() => toggleWeekday(d)}
+                          title={
+                            ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][d]
+                          }
+                        >
+                          {w}
+                        </button>
+                      ))}
+                    </div>
+                  ) : null}
+
+                  <div className="cal-field-row">
+                    <label className="cal-field">
+                      <span className="cal-field-label">Ends</span>
+                      <select
+                        className="cal-input"
+                        value={form.endMode}
+                        onChange={(e) =>
+                          patch({ endMode: e.target.value as Form["endMode"] })
+                        }
+                      >
+                        <option value="">Never</option>
+                        <option value="count">After N times</option>
+                        <option value="until">On a date</option>
+                      </select>
+                    </label>
+
+                    {form.endMode === "count" ? (
+                      <label className="cal-field">
+                        <span className="cal-field-label">Times</span>
+                        <input
+                          className="cal-input cal-input-num"
+                          type="number"
+                          min={1}
+                          value={form.count}
+                          onChange={(e) =>
+                            patch({ count: Math.max(1, Number(e.target.value) || 1) })
+                          }
+                        />
+                      </label>
+                    ) : null}
+
+                    {form.endMode === "until" ? (
+                      <label className="cal-field">
+                        <span className="cal-field-label">Until</span>
+                        <input
+                          className="cal-input"
+                          type="date"
+                          value={form.until}
+                          onChange={(e) => patch({ until: e.target.value })}
+                        />
+                      </label>
+                    ) : null}
+                  </div>
+                </div>
+              ) : null}
+            </div>
+
+            {/* ── Reminders ──────────────────────────────────────────────── */}
+            <div className="cal-section">
+              <div className="cal-section-head">
+                <span className="cal-field-label">Reminders</span>
+                <button
+                  type="button"
+                  className="cal-link-btn"
+                  onClick={() => patch({ alarms: [...form.alarms, { minutes_before: 15 }] })}
+                >
+                  + Add reminder
+                </button>
+              </div>
+
+              {form.alarms.length === 0 ? (
+                <div className="cal-hint">No reminders.</div>
+              ) : (
+                form.alarms.map((alarm, i) => (
+                  <div key={i} className="cal-alarm-row">
+                    <select
+                      className="cal-input"
+                      value={alarm.minutes_before}
+                      onChange={(e) => {
+                        const alarms = [...form.alarms];
+                        alarms[i] = { minutes_before: Number(e.target.value) };
+                        patch({ alarms });
+                      }}
+                    >
+                      {REMINDER_CHOICES.map((c) => (
+                        <option key={c.minutes} value={c.minutes}>{c.label}</option>
+                      ))}
+                    </select>
+                    <button
+                      type="button"
+                      className="cal-link-btn cal-link-danger"
+                      onClick={() => patch({ alarms: form.alarms.filter((_, j) => j !== i) })}
+                    >
+                      Remove
+                    </button>
+                  </div>
+                ))
+              )}
+            </div>
+
+            <label className="cal-field">
+              <span className="cal-field-label">Notes</span>
+              <textarea
+                className="cal-input cal-textarea"
+                value={form.notes}
+                onChange={(e) => patch({ notes: e.target.value })}
+              />
+            </label>
+
+            {error ? <div className="cal-error">{error}</div> : null}
+
+            <div className="cal-form-actions">
+              <button className="cal-btn cal-btn-primary" onClick={attemptSave}>
+                Save
+              </button>
+              {!creating ? (
+                <button className="cal-btn cal-btn-danger" onClick={attemptDelete}>
+                  Delete
+                </button>
+              ) : null}
+              <button className="cal-link-btn" onClick={onClose}>Cancel</button>
+            </div>
+          </div>
+        )}
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** The form's repeat fields, as a stored rule. */
+function buildRrule(form: Form): Rrule {
+  return {
+    freq: form.freq,
+    interval: Math.max(1, form.interval),
+    byweekday: form.freq === "weekly" ? form.byweekday : [],
+    bymonthday: null,
+    until: form.endMode === "until" && form.until ? form.until : null,
+    count: form.endMode === "count" ? Math.max(1, form.count) : null,
+  };
+}
diff --git a/src/components/calendar/MonthView.tsx b/src/components/calendar/MonthView.tsx
new file mode 100644
index 0000000..7447940
--- /dev/null
+++ b/src/components/calendar/MonthView.tsx
@@ -0,0 +1,269 @@
+import { useMemo } from "react";
+import type { Calendar, Occurrence } from "../../types";
+import {
+  addDays,
+  datePart,
+  formatTime,
+  spanCoversDate,
+  todayStr,
+} from "../../lib/calendarTime";
+import { eventColor } from "../../lib/calendarCategories";
+import { calendarColor } from "../../stores/calendar";
+
+/** Rows of chips a cell shows before collapsing the rest into "+N more". */
+const MAX_ROWS = 4;
+
+const WEEKDAY_LABELS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+interface Props {
+  /** The weeks to draw, as rows of 7 dates (`monthGrid`). */
+  weeks: string[][];
+  /** The month the grid is "about" (1-12); days outside it are dimmed. Null in
+   *  the multiweek view, where no month is privileged. */
+  month: number | null;
+  occurrences: Occurrence[];
+  calendars: Calendar[];
+  use24h: boolean;
+  selected: string;
+  onSelect: (date: string) => void;
+  /** Double-click a day → create an all-day event on it. */
+  onCreateOn: (date: string) => void;
+  onOpen: (occurrence: Occurrence) => void;
+  weekStart: 0 | 1;
+}
+
+/**
+ * One laid-out chip in a week row. A multi-day event occupies a single bar
+ * spanning its columns, rather than one chip per day — which is what makes a
+ * conference read as one block instead of five unrelated entries.
+ */
+interface Bar {
+  occ: Occurrence;
+  /** Column index within the week row, 0-6. */
+  col: number;
+  /** How many columns it spans in THIS row. */
+  span: number;
+  /** Row (lane) within the cell stack. */
+  lane: number;
+  /** True when the event began before this week row (draw a left "continues" edge). */
+  clippedStart: boolean;
+  /** True when it continues past this row. */
+  clippedEnd: boolean;
+}
+
+/**
+ * Pack a week's occurrences into lanes.
+ *
+ * Multi-day and all-day events are laid out first, as bars, because they must
+ * keep a stable lane across the days they cover — otherwise the bar would jog up
+ * and down mid-span. Single-day timed events then fill the lanes left free on
+ * their own day.
+ */
+function layoutWeek(week: string[], occurrences: Occurrence[]): Bar[] {
+  const bars: Bar[] = [];
+  // lanes[lane][col] — is that cell of the lane already taken?
+  const lanes: boolean[][] = [];
+
+  const takeLane = (col: number, span: number): number => {
+    for (let lane = 0; ; lane++) {
+      if (!lanes[lane]) lanes[lane] = new Array(7).fill(false);
+      let free = true;
+      for (let c = col; c < col + span; c++) {
+        if (lanes[lane][c]) {
+          free = false;
+          break;
+        }
+      }
+      if (free) {
+        for (let c = col; c < col + span; c++) lanes[lane][c] = true;
+        return lane;
+      }
+    }
+  };
+
+  const spanning = occurrences.filter(
+    (o) => o.allDay || datePart(o.start) !== datePart(o.end),
+  );
+  const single = occurrences.filter(
+    (o) => !o.allDay && datePart(o.start) === datePart(o.end),
+  );
+
+  // Longest-first, so the big bars claim the top lanes and read as the backdrop.
+  const ordered = [...spanning].sort((a, b) => {
+    const len = (o: Occurrence) => week.filter((d) => covers(o, d)).length;
+    const d = len(b) - len(a);
+    return d !== 0 ? d : a.start.localeCompare(b.start);
+  });
+
+  for (const occ of ordered) {
+    const cols = week.map((d, i) => (covers(occ, d) ? i : -1)).filter((i) => i >= 0);
+    if (cols.length === 0) continue;
+    const col = cols[0];
+    const span = cols[cols.length - 1] - col + 1;
+    bars.push({
+      occ,
+      col,
+      span,
+      lane: takeLane(col, span),
+      // It began before this row / runs past it → draw a "continues" edge.
+      clippedStart: covers(occ, addDays(week[0], -1)),
+      clippedEnd: covers(occ, addDays(week[6], 1)),
+    });
+  }
+
+  for (const occ of single) {
+    const col = week.findIndex((d) => covers(occ, d));
+    if (col < 0) continue;
+    bars.push({
+      occ,
+      col,
+      span: 1,
+      lane: takeLane(col, 1),
+      clippedStart: false,
+      clippedEnd: false,
+    });
+  }
+
+  return bars;
+}
+
+function covers(occ: Occurrence, date: string): boolean {
+  return spanCoversDate({ start: occ.start, end: occ.end, allDay: occ.allDay }, date);
+}
+
+/**
+ * The month grid — and, with a different week count, the multiweek view.
+ *
+ * Days outside `month` are dimmed but still live: clicking one selects it and
+ * double-clicking creates there, so the leading/trailing week is not dead space.
+ */
+export function MonthView({
+  weeks,
+  month,
+  occurrences,
+  calendars,
+  use24h,
+  selected,
+  onSelect,
+  onCreateOn,
+  onOpen,
+  weekStart,
+}: Props) {
+  const today = todayStr();
+
+  const labels = useMemo(
+    () => [...WEEKDAY_LABELS.slice(weekStart), ...WEEKDAY_LABELS.slice(0, weekStart)],
+    [weekStart],
+  );
+
+  const laidOut = useMemo(
+    () => weeks.map((week) => layoutWeek(week, occurrences)),
+    [weeks, occurrences],
+  );
+
+  return (
+    <div className="cal-month">
+      <div className="cal-month-weekdays">
+        {labels.map((w) => (
+          <div key={w} className="cal-month-weekday">{w}</div>
+        ))}
+      </div>
+
+      <div className="cal-month-weeks">
+        {weeks.map((week, wi) => {
+          const bars = laidOut[wi];
+          const overflow = new Map<number, number>(); // col → hidden count
+          for (const bar of bars) {
+            if (bar.lane >= MAX_ROWS) {
+              for (let c = bar.col; c < bar.col + bar.span; c++) {
+                overflow.set(c, (overflow.get(c) ?? 0) + 1);
+              }
+            }
+          }
+
+          return (
+            <div key={wi} className="cal-month-week">
+              {/* The day cells: background, number, click targets. */}
+              {week.map((date, ci) => {
+                const inMonth = month === null || Number(date.slice(5, 7)) === month;
+                const classes = ["cal-month-day"];
+                if (!inMonth) classes.push("cal-month-day-out");
+                if (date === today) classes.push("cal-month-day-today");
+                if (date === selected) classes.push("cal-month-day-selected");
+                return (
+                  <div
+                    key={date}
+                    className={classes.join(" ")}
+                    style={{ left: `${(ci / 7) * 100}%`, width: `${100 / 7}%` }}
+                    onClick={() => onSelect(date)}
+                    onDoubleClick={() => onCreateOn(date)}
+                  >
+                    <span className="cal-month-daynum">{Number(date.slice(8, 10))}</span>
+                    {overflow.has(ci) ? (
+                      <span
+                        className="cal-month-more"
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          onSelect(date);
+                        }}
+                      >
+                        +{overflow.get(ci)} more
+                      </span>
+                    ) : null}
+                  </div>
+                );
+              })}
+
+              {/* The event bars, above the cells so a span can cross day borders. */}
+              {bars
+                .filter((b) => b.lane < MAX_ROWS)
+                .map((bar) => {
+                  const { occ } = bar;
+                  const color = eventColor(
+                    occ.category,
+                    calendarColor(calendars, occ.calendarId),
+                  );
+                  const spanning = occ.allDay || bar.span > 1;
+                  return (
+                    <div
+                      key={`${occ.eventId}:${occ.occurrenceStart}:${bar.col}`}
+                      className={
+                        "cal-month-bar" +
+                        (spanning ? " cal-month-bar-solid" : "") +
+                        (bar.clippedStart ? " cal-month-bar-clip-start" : "") +
+                        (bar.clippedEnd ? " cal-month-bar-clip-end" : "") +
+                        (occ.status === "cancelled" ? " cal-block-cancelled" : "")
+                      }
+                      style={{
+                        left: `calc(${(bar.col / 7) * 100}% + 3px)`,
+                        width: `calc(${(bar.span / 7) * 100}% - 6px)`,
+                        top: `calc(var(--cal-daynum-h) + ${bar.lane} * var(--cal-bar-h))`,
+                        color,
+                      }}
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        onSelect(datePart(occ.start));
+                      }}
+                      onDoubleClick={(e) => {
+                        e.stopPropagation();
+                        onOpen(occ);
+                      }}
+                      title={`${occ.title}${occ.location ? ` — ${occ.location}` : ""}`}
+                    >
+                      {!spanning ? <span className="cal-month-bar-dot">●</span> : null}
+                      {!occ.allDay ? (
+                        <span className="cal-month-bar-time">
+                          {formatTime(occ.start.split("T")[1] ?? "", use24h)}
+                        </span>
+                      ) : null}
+                      <span className="cal-month-bar-title">{occ.title || "(untitled)"}</span>
+                    </div>
+                  );
+                })}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/calendar/TasksView.tsx b/src/components/calendar/TasksView.tsx
new file mode 100644
index 0000000..4971cf9
--- /dev/null
+++ b/src/components/calendar/TasksView.tsx
@@ -0,0 +1,232 @@
+import { useMemo, useState } from "react";
+import type { Calendar, CalendarTask } from "../../types";
+import { datePart, formatLongDate, todayStr, toStamp } from "../../lib/calendarTime";
+import { calendarColor } from "../../stores/calendar";
+
+interface Props {
+  tasks: CalendarTask[];
+  calendars: Calendar[];
+  /** Only tasks on these calendars are listed. */
+  visibleCalendars: Set<string>;
+  search: string;
+  onCreate: (task: Omit<CalendarTask, "id">) => Promise<unknown>;
+  onUpdate: (task: CalendarTask) => Promise<unknown>;
+  onDelete: (id: string) => Promise<unknown>;
+  /** The calendar a new task is filed under. */
+  defaultCalendarId: string;
+}
+
+type Filter = "open" | "all" | "done";
+
+/** iCalendar priority: 1-4 high, 5 normal, 6-9 low, 0 unset. */
+function priorityLabel(p: number): string {
+  if (p === 0) return "";
+  if (p <= 4) return "High";
+  if (p === 5) return "Normal";
+  return "Low";
+}
+
+function priorityClass(p: number): string {
+  if (p === 0) return "";
+  if (p <= 4) return " cal-task-prio-high";
+  if (p === 5) return " cal-task-prio-normal";
+  return " cal-task-prio-low";
+}
+
+/** A task is overdue when it has a due date in the past and is not complete. */
+function isOverdue(task: CalendarTask, today: string): boolean {
+  if (!task.due || task.percent >= 100) return false;
+  return datePart(task.due) < today;
+}
+
+/**
+ * The to-do list — Thunderbird's Tasks tab.
+ *
+ * Tasks are VTODOs: a title, an optional due date, a priority and a completion
+ * percentage. Ticking the checkbox sets `percent` to 100 and stamps `completed`,
+ * which is what makes a task "done" (the completion stamp, not a separate flag,
+ * so it survives an ICS round-trip).
+ */
+export function TasksView({
+  tasks,
+  calendars,
+  visibleCalendars,
+  search,
+  onCreate,
+  onUpdate,
+  onDelete,
+  defaultCalendarId,
+}: Props) {
+  const [filter, setFilter] = useState<Filter>("open");
+  const [title, setTitle] = useState("");
+  const [due, setDue] = useState("");
+  const today = todayStr();
+
+  const shown = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    return tasks
+      .filter((t) => visibleCalendars.has(t.calendar_id))
+      .filter((t) => {
+        const done = t.percent >= 100;
+        if (filter === "open") return !done;
+        if (filter === "done") return done;
+        return true;
+      })
+      .filter((t) =>
+        q ? `${t.title} ${t.notes ?? ""}`.toLowerCase().includes(q) : true,
+      )
+      .sort((a, b) => {
+        // Overdue first, then by due date (undated last), then by priority.
+        const ao = isOverdue(a, today) ? 0 : 1;
+        const bo = isOverdue(b, today) ? 0 : 1;
+        if (ao !== bo) return ao - bo;
+        const ad = a.due ?? "9999";
+        const bd = b.due ?? "9999";
+        if (ad !== bd) return ad.localeCompare(bd);
+        const ap = a.priority || 10;
+        const bp = b.priority || 10;
+        return ap - bp;
+      });
+  }, [tasks, visibleCalendars, filter, search, today]);
+
+  async function addTask() {
+    const t = title.trim();
+    if (!t) return;
+    await onCreate({
+      calendar_id: defaultCalendarId,
+      title: t,
+      due: due || null,
+      priority: 0,
+      percent: 0,
+    });
+    setTitle("");
+    setDue("");
+  }
+
+  /** Tick/untick: completion is the `completed` stamp plus percent 100. */
+  async function toggleDone(task: CalendarTask) {
+    const done = task.percent >= 100;
+    await onUpdate({
+      ...task,
+      percent: done ? 0 : 100,
+      completed: done ? null : toStamp(new Date()),
+    });
+  }
+
+  return (
+    <div className="cal-tasks">
+      <div className="cal-tasks-add">
+        <input
+          className="cal-input cal-tasks-add-title"
+          type="text"
+          placeholder="Add a task…"
+          value={title}
+          onChange={(e) => setTitle(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") void addTask();
+          }}
+        />
+        <input
+          className="cal-input cal-tasks-add-due"
+          type="date"
+          title="Due date"
+          value={due}
+          onChange={(e) => setDue(e.target.value)}
+        />
+        <button className="cal-btn cal-btn-primary" disabled={!title.trim()} onClick={() => void addTask()}>
+          Add
+        </button>
+      </div>
+
+      <div className="cal-tasks-filters">
+        {(["open", "all", "done"] as Filter[]).map((f) => (
+          <button
+            key={f}
+            className={`cal-chip${filter === f ? " cal-chip-on" : ""}`}
+            onClick={() => setFilter(f)}
+          >
+            {f === "open" ? "Open" : f === "all" ? "All" : "Completed"}
+          </button>
+        ))}
+      </div>
+
+      {shown.length === 0 ? (
+        <div className="cal-empty">
+          {filter === "done" ? "Nothing completed yet." : "No tasks. Add one above."}
+        </div>
+      ) : (
+        <div className="cal-tasks-list">
+          {shown.map((task) => {
+            const done = task.percent >= 100;
+            const overdue = isOverdue(task, today);
+            return (
+              <div
+                key={task.id}
+                className={
+                  "cal-task-row" +
+                  (done ? " cal-task-done" : "") +
+                  (overdue ? " cal-task-overdue" : "")
+                }
+              >
+                <input
+                  type="checkbox"
+                  className="cal-task-check"
+                  checked={done}
+                  onChange={() => void toggleDone(task)}
+                  title={done ? "Mark as not done" : "Mark as done"}
+                />
+
+                <span
+                  className="cal-task-swatch"
+                  style={{ color: calendarColor(calendars, task.calendar_id) }}
+                >
+                  ●
+                </span>
+
+                <span className="cal-task-title">{task.title}</span>
+
+                {task.priority ? (
+                  <span className={`cal-task-prio${priorityClass(task.priority)}`}>
+                    {priorityLabel(task.priority)}
+                  </span>
+                ) : null}
+
+                {!done && task.percent > 0 ? (
+                  <span className="cal-task-percent" title={`${task.percent}% complete`}>
+                    <span className="cal-task-percent-fill" style={{ width: `${task.percent}%` }} />
+                  </span>
+                ) : null}
+
+                {task.due ? (
+                  <span className="cal-task-due" title={formatLongDate(datePart(task.due))}>
+                    {overdue ? "Overdue · " : ""}
+                    {datePart(task.due)}
+                  </span>
+                ) : null}
+
+                <select
+                  className="cal-task-prio-select"
+                  value={task.priority}
+                  title="Priority"
+                  onChange={(e) => void onUpdate({ ...task, priority: Number(e.target.value) })}
+                >
+                  <option value={0}>—</option>
+                  <option value={1}>High</option>
+                  <option value={5}>Normal</option>
+                  <option value={9}>Low</option>
+                </select>
+
+                <button
+                  className="cal-link-btn cal-link-danger"
+                  onClick={() => void onDelete(task.id)}
+                >
+                  Delete
+                </button>
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/calendar/TimeGrid.tsx b/src/components/calendar/TimeGrid.tsx
new file mode 100644
index 0000000..994aa4b
--- /dev/null
+++ b/src/components/calendar/TimeGrid.tsx
@@ -0,0 +1,338 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import type { Calendar, Occurrence } from "../../types";
+import {
+  MINUTES_PER_DAY,
+  addMinutes,
+  datePart,
+  daySlice,
+  formatTime,
+  layoutOverlaps,
+  minutesBetween,
+  minutesIntoDay,
+  todayStr,
+  toStamp,
+} from "../../lib/calendarTime";
+import { eventColor } from "../../lib/calendarCategories";
+import { calendarColor } from "../../stores/calendar";
+
+/** Pixel height of one hour row. The whole grid's geometry derives from this. */
+const HOUR_PX = 44;
+/** Everything drag-related snaps to this many minutes. */
+const SNAP_MIN = 15;
+/** Below this many minutes a block is too short to show its time legibly. */
+const COMPACT_MIN = 45;
+
+export interface TimeGridPrefs {
+  use24h: boolean;
+  /** Hour the grid scrolls to on open. */
+  dayStartHour: number;
+}
+
+interface Props {
+  /** The day columns to draw — 1 for the day view, 7 for the week view. */
+  dates: string[];
+  occurrences: Occurrence[];
+  calendars: Calendar[];
+  prefs: TimeGridPrefs;
+  onOpen: (occurrence: Occurrence) => void;
+  /** Drag on empty space finished — create an event over this range. */
+  onCreate: (start: string, end: string) => void;
+  /** A block was dragged to a new start (its duration is preserved). */
+  onMove: (occurrence: Occurrence, newStart: string) => void;
+  /** A block's bottom edge was dragged — same start, new end. */
+  onResize: (occurrence: Occurrence, newEnd: string) => void;
+}
+
+/** Snap a minute offset to the grid, clamped into the day. */
+function snap(minutes: number): number {
+  const s = Math.round(minutes / SNAP_MIN) * SNAP_MIN;
+  return Math.max(0, Math.min(MINUTES_PER_DAY, s));
+}
+
+/** A live drag. `create` draws a ghost; `move`/`resize` preview on the block. */
+type Drag =
+  | { kind: "create"; date: string; fromMin: number; toMin: number }
+  | { kind: "move"; occ: Occurrence; date: string; startMin: number; durationMin: number }
+  | { kind: "resize"; occ: Occurrence; date: string; endMin: number };
+
+/**
+ * The hour-row grid behind the day and week views.
+ *
+ * One column per date; timed occurrences are positioned by their minute offsets
+ * and overlapping ones are split into columns (`layoutOverlaps`). All-day
+ * occurrences are not drawn here — they belong to the all-day bar the parent view
+ * renders above the grid.
+ *
+ * Dragging is pointer-based, not HTML5 drag-and-drop: WebKitGTK does not deliver
+ * a usable HTML5 drag here (the same reason the tab strip is pointer-based).
+ * Pointer capture on the scroll container means a drag that leaves the column —
+ * or the window — still resolves.
+ */
+export function TimeGrid({
+  dates,
+  occurrences,
+  calendars,
+  prefs,
+  onOpen,
+  onCreate,
+  onMove,
+  onResize,
+}: Props) {
+  const scrollRef = useRef<HTMLDivElement | null>(null);
+  const bodyRef = useRef<HTMLDivElement | null>(null);
+  const [drag, setDrag] = useState<Drag | null>(null);
+  const [nowMin, setNowMin] = useState(() => minutesIntoDay(toStamp(new Date())));
+
+  const today = todayStr();
+
+  // Scroll the working day into view on open, so 09:00 is not below the fold.
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (el) el.scrollTop = prefs.dayStartHour * HOUR_PX;
+  }, [prefs.dayStartHour]);
+
+  // Creep the now-line down. A minute's resolution is all the line shows.
+  useEffect(() => {
+    const id = setInterval(() => setNowMin(minutesIntoDay(toStamp(new Date()))), 60_000);
+    return () => clearInterval(id);
+  }, []);
+
+  /** Pointer Y → minutes into the day, snapped. */
+  function minutesAt(clientY: number): number {
+    const body = bodyRef.current;
+    if (!body) return 0;
+    const rect = body.getBoundingClientRect();
+    const ratio = (clientY - rect.top) / rect.height;
+    return snap(ratio * MINUTES_PER_DAY);
+  }
+
+  /** Timed blocks per column, with their overlap placement resolved. */
+  const columns = useMemo(() => {
+    return dates.map((date) => {
+      const items = occurrences
+        .filter((o) => !o.allDay)
+        .map((o) => {
+          const slice = daySlice({ start: o.start, end: o.end, allDay: false }, date);
+          return slice ? { occ: o, ...slice } : null;
+        })
+        .filter((x): x is { occ: Occurrence; startMin: number; endMin: number } => x !== null);
+
+      const placements = layoutOverlaps(items);
+      return items.map((item, i) => ({ ...item, place: placements[i] }));
+    });
+  }, [dates, occurrences]);
+
+  // ── Drag lifecycle ────────────────────────────────────────────────────────
+
+  function beginCreate(e: React.PointerEvent, date: string) {
+    // Only a plain left-press on the empty column starts a create-drag.
+    if (e.button !== 0) return;
+    const at = minutesAt(e.clientY);
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    setDrag({ kind: "create", date, fromMin: at, toMin: at + SNAP_MIN });
+  }
+
+  function beginMove(e: React.PointerEvent, occ: Occurrence, date: string) {
+    if (e.button !== 0) return;
+    e.stopPropagation(); // don't also start a create-drag underneath
+    const slice = daySlice({ start: occ.start, end: occ.end, allDay: false }, date);
+    if (!slice) return;
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    setDrag({
+      kind: "move",
+      occ,
+      date,
+      startMin: slice.startMin,
+      // The true duration, which may exceed the day slice for an overnight event.
+      durationMin: Math.max(SNAP_MIN, minutesBetween(occ.start, occ.end)),
+    });
+  }
+
+  function beginResize(e: React.PointerEvent, occ: Occurrence, date: string) {
+    if (e.button !== 0) return;
+    e.stopPropagation();
+    const slice = daySlice({ start: occ.start, end: occ.end, allDay: false }, date);
+    if (!slice) return;
+    (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+    setDrag({ kind: "resize", occ, date, endMin: slice.endMin });
+  }
+
+  function onPointerMove(e: React.PointerEvent) {
+    if (!drag) return;
+    const at = minutesAt(e.clientY);
+    if (drag.kind === "create") {
+      setDrag({ ...drag, toMin: at });
+    } else if (drag.kind === "move") {
+      setDrag({ ...drag, startMin: at });
+    } else {
+      // Never let the bottom edge cross the top.
+      const startMin =
+        daySlice({ start: drag.occ.start, end: drag.occ.end, allDay: false }, drag.date)
+          ?.startMin ?? 0;
+      setDrag({ ...drag, endMin: Math.max(startMin + SNAP_MIN, at) });
+    }
+  }
+
+  function onPointerUp() {
+    if (!drag) return;
+    const d = drag;
+    setDrag(null);
+
+    if (d.kind === "create") {
+      const from = Math.min(d.fromMin, d.toMin);
+      const to = Math.max(d.fromMin, d.toMin);
+      // A click (no movement) means "new event here", given a default length.
+      const end = to - from < SNAP_MIN ? from + 60 : to;
+      onCreate(stampAt(d.date, from), stampAt(d.date, end));
+      return;
+    }
+
+    if (d.kind === "move") {
+      const newStart = stampAt(d.date, d.startMin);
+      if (newStart !== d.occ.start) onMove(d.occ, newStart);
+      return;
+    }
+
+    const newEnd = stampAt(d.date, d.endMin);
+    if (newEnd !== d.occ.end) onResize(d.occ, newEnd);
+  }
+
+  const hours = Array.from({ length: 24 }, (_, h) => h);
+
+  return (
+    <div className="cal-timegrid" ref={scrollRef}>
+      <div className="cal-timegrid-inner" style={{ height: 24 * HOUR_PX }}>
+        <div className="cal-timegrid-gutter">
+          {hours.map((h) => (
+            <div key={h} className="cal-timegrid-hour-label" style={{ height: HOUR_PX }}>
+              {h === 0 ? "" : formatTime(`${String(h).padStart(2, "0")}:00`, prefs.use24h)}
+            </div>
+          ))}
+        </div>
+
+        <div
+          className="cal-timegrid-body"
+          ref={bodyRef}
+          onPointerMove={onPointerMove}
+          onPointerUp={onPointerUp}
+          onPointerCancel={onPointerUp}
+        >
+          {hours.map((h) => (
+            <div key={h} className="cal-timegrid-line" style={{ top: h * HOUR_PX }} />
+          ))}
+
+          {dates.map((date, ci) => {
+            const isToday = date === today;
+            return (
+              <div
+                key={date}
+                className={`cal-timegrid-col${isToday ? " cal-timegrid-col-today" : ""}`}
+                style={{ left: `${(ci / dates.length) * 100}%`, width: `${100 / dates.length}%` }}
+                onPointerDown={(e) => beginCreate(e, date)}
+              >
+                {isToday ? (
+                  <div
+                    className="cal-now-line"
+                    style={{ top: (nowMin / MINUTES_PER_DAY) * (24 * HOUR_PX) }}
+                  />
+                ) : null}
+
+                {columns[ci].map(({ occ, startMin, endMin, place }) => {
+                  const dragging =
+                    drag && drag.kind !== "create" && drag.occ.eventId === occ.eventId &&
+                    drag.occ.occurrenceStart === occ.occurrenceStart && drag.date === date;
+
+                  let top = startMin;
+                  let bottom = endMin;
+                  if (dragging && drag.kind === "move") {
+                    top = drag.startMin;
+                    bottom = Math.min(MINUTES_PER_DAY, drag.startMin + drag.durationMin);
+                  } else if (dragging && drag.kind === "resize") {
+                    bottom = drag.endMin;
+                  }
+
+                  const height = Math.max(SNAP_MIN, bottom - top);
+                  const color = eventColor(occ.category, calendarColor(calendars, occ.calendarId));
+                  const compact = height < COMPACT_MIN;
+
+                  return (
+                    <div
+                      key={`${occ.eventId}:${occ.occurrenceStart}`}
+                      className={
+                        "cal-block" +
+                        (occ.status === "cancelled" ? " cal-block-cancelled" : "") +
+                        (occ.status === "tentative" ? " cal-block-tentative" : "") +
+                        (dragging ? " cal-block-dragging" : "") +
+                        (compact ? " cal-block-compact" : "")
+                      }
+                      style={{
+                        top: (top / MINUTES_PER_DAY) * (24 * HOUR_PX),
+                        height: (height / MINUTES_PER_DAY) * (24 * HOUR_PX),
+                        left: `calc(${place.left * 100}% + 2px)`,
+                        width: `calc(${place.width * 100}% - 4px)`,
+                        // The accent tints the border/background via currentColor.
+                        color,
+                      }}
+                      onPointerDown={(e) => beginMove(e, occ, date)}
+                      onDoubleClick={() => onOpen(occ)}
+                      title={`${occ.title}${occ.location ? ` — ${occ.location}` : ""}`}
+                    >
+                      <div className="cal-block-title">{occ.title || "(untitled)"}</div>
+                      {!compact ? (
+                        <div className="cal-block-time">
+                          {formatTime(timeOf(occ.start), prefs.use24h)}
+                          {occ.location ? ` · ${occ.location}` : ""}
+                        </div>
+                      ) : null}
+                      <div
+                        className="cal-block-resize"
+                        onPointerDown={(e) => beginResize(e, occ, date)}
+                      />
+                    </div>
+                  );
+                })}
+
+                {drag?.kind === "create" && drag.date === date ? (
+                  <div
+                    className="cal-block cal-block-ghost"
+                    style={{
+                      top: (Math.min(drag.fromMin, drag.toMin) / MINUTES_PER_DAY) * (24 * HOUR_PX),
+                      height:
+                        (Math.max(SNAP_MIN, Math.abs(drag.toMin - drag.fromMin)) / MINUTES_PER_DAY) *
+                        (24 * HOUR_PX),
+                      left: 2,
+                      right: 2,
+                    }}
+                  >
+                    <div className="cal-block-time">
+                      {formatTime(hhmm(Math.min(drag.fromMin, drag.toMin)), prefs.use24h)}
+                    </div>
+                  </div>
+                ) : null}
+              </div>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/** Minutes into a day → `"HH:MM"`. */
+function hhmm(min: number): string {
+  const m = Math.max(0, Math.min(MINUTES_PER_DAY - 1, min));
+  return `${String(Math.floor(m / 60)).padStart(2, "0")}:${String(m % 60).padStart(2, "0")}`;
+}
+
+/**
+ * A date plus minutes into it → a stamp. Minute 1440 (a drag to the very bottom)
+ * is midnight of the *next* day, which `addMinutes` rolls over correctly.
+ */
+function stampAt(date: string, minutes: number): string {
+  return addMinutes(`${datePart(date)}T00:00`, minutes);
+}
+
+/** The clock part of a stamp. */
+function timeOf(stamp: string): string {
+  return stamp.split("T")[1] ?? "00:00";
+}
diff --git a/src/components/common/ConnLamp.tsx b/src/components/common/ConnLamp.tsx
new file mode 100644
index 0000000..1ac7a1a
--- /dev/null
+++ b/src/components/common/ConnLamp.tsx
@@ -0,0 +1,40 @@
+import type { ConnState } from "../../stores/remoteStatus";
+
+/**
+ * A small red/orange/green status lamp for a remote connection channel.
+ *  - off        → dim grey
+ *  - connecting → orange, pulsing
+ *  - connected  → green
+ *  - error      → red
+ * Used both in the project dialog (next to the SSH / OpenVPN controls) and in
+ * the header (the active remote project's live SSH / VPN state).
+ *
+ * `busy` is a second, **orthogonal** axis, not a fifth state: a connected host
+ * with live work on it (≥1 tmux session — see `stores/hostBusy`) pulses its
+ * green rather than sitting steady. It exists because with a fleet held open all
+ * day "connected" is the resting state and stops distinguishing anything; the
+ * pulse restores the at-a-glance answer to "where am I actually running
+ * something?". It is only honoured for `connected` — a pulsing red or orange
+ * would read as a state of the *connection*, which is what the colour already
+ * says, and `connecting` has its own (orange) pulse to stay distinct from it.
+ */
+export function ConnLamp({
+  status,
+  label,
+  busy,
+}: {
+  status: ConnState;
+  label: string;
+  busy?: boolean;
+}) {
+  const isBusy = busy && status === "connected";
+  const title = isBusy ? `${label}: connected, working` : `${label}: ${status}`;
+  return (
+    <span
+      className={`conn-lamp conn-lamp-${status}${isBusy ? " conn-lamp-busy" : ""}`}
+      role="img"
+      aria-label={title}
+      title={title}
+    />
+  );
+}
diff --git a/src/components/common/ConnectionLog.tsx b/src/components/common/ConnectionLog.tsx
new file mode 100644
index 0000000..a1a7c46
--- /dev/null
+++ b/src/components/common/ConnectionLog.tsx
@@ -0,0 +1,39 @@
+import { useEffect, useRef } from "react";
+import { useT } from "../../lib/i18n";
+
+/**
+ * One log line plus a stable, monotonically-increasing id minted at the push
+ * site. The id (never the array index) is the React key, so when the caller caps
+ * the list with `.slice(-500)` only the trimmed head's nodes drop — the surviving
+ * lines keep their ids and React reuses their nodes instead of re-creating all.
+ */
+export type LogLine = { id: number; text: string };
+
+/**
+ * Read-only live log of a headless OpenVPN handshake. Eldrun feeds the password
+ * itself (no typing), so this is purely a progress view: it renders the lines
+ * the backend forwards (`openvpn-progress`) and auto-scrolls to the newest so a
+ * connect reads as live work rather than an opaque spinner. Shared by the
+ * project dialog and the activation-time VPN password prompt.
+ */
+export function ConnectionLog({ lines, busy }: { lines: LogLine[]; busy: boolean }) {
+  const t = useT();
+  const endRef = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    endRef.current?.scrollIntoView({ block: "end" });
+  }, [lines.length]);
+  return (
+    <div className="connection-log" role="log" aria-label={t("connLog.ariaLabel")}>
+      {lines.length === 0 && busy ? (
+        <div className="connection-log-line connection-log-waiting">{t("connLog.startingVpn")}</div>
+      ) : (
+        lines.map((line) => (
+          <div key={line.id} className="connection-log-line">
+            {line.text}
+          </div>
+        ))
+      )}
+      <div ref={endRef} />
+    </div>
+  );
+}
diff --git a/src/components/common/FolderPickerDialog.tsx b/src/components/common/FolderPickerDialog.tsx
new file mode 100644
index 0000000..3eebcb9
--- /dev/null
+++ b/src/components/common/FolderPickerDialog.tsx
@@ -0,0 +1,162 @@
+import { useCallback, useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { sanitizeName } from "../projects/scaffold";
+import { useT } from "../../lib/i18n";
+
+/** One subdirectory row, mirroring the Rust `DirEntry` (commands::fs). */
+interface DirEntry {
+  name: string;
+  path: string;
+}
+
+/** The listing returned by the `list_dirs` command (Rust `DirListing`). */
+interface DirListing {
+  path: string;
+  parent: string | null;
+  entries: DirEntry[];
+}
+
+interface Props {
+  /** Directory to open the browser at (defaults to home when empty/omitted). */
+  initialPath?: string;
+  title: string;
+  /** Label for the confirm button (e.g. "Move here"). */
+  confirmLabel: string;
+  /**
+   * When set, render a labeled text input for a folder name (its sanitized form
+   * is previewed live). The entered value is passed as the second `onConfirm`
+   * arg. Omit to keep the picker a pure directory chooser.
+   */
+  nameLabel?: string;
+  /** Initial value for the optional name field. */
+  nameInitial?: string;
+  /**
+   * Called with the currently-browsed directory when the user confirms. When a
+   * name field is shown (`nameLabel`), the entered folder name is passed too.
+   */
+  onConfirm: (dir: string, name?: string) => void;
+  onClose: () => void;
+}
+
+/**
+ * An in-app ("native to Eldrun") folder-browser popup — an alternative to the OS
+ * folder-chooser dialog. Browses the local filesystem via the unconfined
+ * `list_dirs` command: click a folder to descend, ⬆ to go up, then confirm to
+ * return the current directory. Follows the app modal convention (portal +
+ * `.modal-backdrop` + a settings-style dialog).
+ */
+export function FolderPickerDialog({ initialPath, title, confirmLabel, nameLabel, nameInitial, onConfirm, onClose }: Props) {
+  const t = useT();
+  const [listing, setListing] = useState<DirListing | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [name, setName] = useState(nameInitial ?? "");
+
+  const load = useCallback((path: string) => {
+    setLoading(true);
+    setError(null);
+    invoke<DirListing>("list_dirs", { path })
+      .then((res) => setListing(res))
+      .catch((e) => setError(String(e)))
+      .finally(() => setLoading(false));
+  }, []);
+
+  useEffect(() => {
+    load(initialPath?.trim() || "");
+  }, [load, initialPath]);
+
+  useEffect(() => {
+    setName(nameInitial ?? "");
+  }, [nameInitial]);
+
+  // Escape closes, mirroring the app's other modals.
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, [onClose]);
+
+  const cur = listing?.path ?? initialPath ?? "";
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="settings-dialog folder-picker-dialog"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{title}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+
+        <div className="folder-picker-nav">
+          <button
+            type="button"
+            disabled={!listing?.parent}
+            onClick={() => listing?.parent && load(listing.parent)}
+            title={t("folderPicker.upOneFolder")}
+          >
+            ⬆ {t("folderPicker.up")}
+          </button>
+          <span className="folder-picker-cur" title={cur}>{cur || "…"}</span>
+        </div>
+
+        <div className="folder-picker-list">
+          {error ? (
+            <p className="settings-help folder-picker-error">{error}</p>
+          ) : loading && !listing ? (
+            <p className="settings-help">{t("common.loading")}</p>
+          ) : listing && listing.entries.length === 0 ? (
+            <p className="settings-help">{t("folderPicker.noSubfolders")}</p>
+          ) : (
+            listing?.entries.map((entry) => (
+              <button
+                key={entry.path}
+                type="button"
+                className="folder-picker-item"
+                onClick={() => load(entry.path)}
+                title={entry.path}
+              >
+                <span className="folder-picker-icon">📁</span>
+                <span className="folder-picker-name">{entry.name}</span>
+              </button>
+            ))
+          )}
+        </div>
+
+        {nameLabel !== undefined && (
+          <div className="folder-picker-name-row">
+            <label className="folder-picker-name-label">
+              <span>{nameLabel}</span>
+              <input
+                type="text"
+                value={name}
+                onChange={(e) => setName(e.target.value)}
+                spellCheck={false}
+              />
+            </label>
+            <span className="settings-help folder-picker-name-preview">
+              {t("folderPicker.folderPrefix")} {sanitizeName(name) || "…"}
+            </span>
+          </div>
+        )}
+
+        <div className="settings-actions folder-picker-actions">
+          <button type="button" onClick={onClose}>{t("common.cancel")}</button>
+          <button
+            type="button"
+            className="primary"
+            disabled={!cur}
+            onClick={() => onConfirm(cur, nameLabel !== undefined ? name : undefined)}
+          >
+            {confirmLabel}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/common/HintBubble.tsx b/src/components/common/HintBubble.tsx
new file mode 100644
index 0000000..da54ffc
--- /dev/null
+++ b/src/components/common/HintBubble.tsx
@@ -0,0 +1,87 @@
+import { createPortal } from "react-dom";
+import { useT } from "../../lib/i18n";
+
+/**
+ * A small floating coachmark anchored above/below a UI element, or a centered
+ * top banner when `rect` is null. Portaled to `document.body` so it escapes the
+ * right panel's `transform`/`overflow` stacking context (generalizes the
+ * `LinkOpenHint` primitive in FileViewerPane, but interactive — it has buttons,
+ * so no `pointer-events: none`). Positioning is computed by the caller (HintHost)
+ * and passed in as `rect`; this component only paints.
+ */
+export function HintBubble({
+  rect,
+  placement,
+  title,
+  body,
+  action,
+  onDismiss,
+  onDisableAll,
+}: {
+  rect: DOMRect | null;
+  placement: "top" | "bottom";
+  title: string;
+  body: string;
+  /** Optional button that carries out what the hint describes. Running it also
+   *  dismisses the hint — the user has acted on it. */
+  action?: { label: string; run: () => void };
+  onDismiss: () => void;
+  onDisableAll: () => void;
+}) {
+  const t = useT();
+  const BUBBLE_W = 280;
+  let style: React.CSSProperties;
+  let banner = false;
+  if (rect) {
+    // Clamp horizontally so an edge-anchored hint never overflows off-screen.
+    const left = Math.max(8, Math.min(rect.left, window.innerWidth - BUBBLE_W - 8));
+    style =
+      placement === "top"
+        ? { left, top: rect.top - 8, transform: "translateY(-100%)" }
+        : { left, top: rect.bottom + 8 };
+  } else {
+    banner = true;
+    style = {};
+  }
+
+  return createPortal(
+    <div
+      className={`hint-bubble${banner ? " hint-bubble--banner" : ""}`}
+      role="dialog"
+      aria-label={title}
+      style={{ ...style, width: banner ? undefined : BUBBLE_W }}
+    >
+      <button
+        type="button"
+        className="hint-bubble-close"
+        aria-label={t("hint.dismissAria")}
+        onClick={onDismiss}
+      >
+        ×
+      </button>
+      <div className="hint-bubble-title">{title}</div>
+      <div className="hint-bubble-body">{body}</div>
+      <div className="hint-bubble-actions">
+        <button type="button" className="hint-bubble-link" onClick={onDisableAll}>
+          {t("hint.dontShowHints")}
+        </button>
+        {action && (
+          <button
+            type="button"
+            className="hint-bubble-got-it"
+            onClick={() => {
+              action.run();
+              onDismiss();
+            }}
+          >
+            {action.label}
+          </button>
+        )}
+        <button type="button" className="hint-bubble-got-it" onClick={onDismiss}>
+          {action ? t("hint.notNow") : t("howToStart.gotIt")}
+        </button>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/common/HostKeyConfirmDialog.tsx b/src/components/common/HostKeyConfirmDialog.tsx
new file mode 100644
index 0000000..39ea7bf
--- /dev/null
+++ b/src/components/common/HostKeyConfirmDialog.tsx
@@ -0,0 +1,86 @@
+import { useHostKeyPromptStore } from "../../stores/hostKeyPrompt";
+import { UntestedTag } from "./UntestedTag";
+import { useT } from "../../lib/i18n";
+
+/**
+ * First-contact host-key confirmation. Mounted once at the shell, like the VPN
+ * password prompt.
+ *
+ * This is the moment `StrictHostKeyChecking=accept-new` otherwise passes over in
+ * silence: a host nobody here has ever spoken to, about to be handed a password.
+ * OpenSSH's own prompt at least shows the fingerprint; headless connects have no
+ * terminal to show it in, so it is shown here instead.
+ *
+ * Accepting writes the shown keys to `~/.ssh/known_hosts` — the same thing
+ * `accept-new` would have done, done deliberately — after which the connect that
+ * raised this retries. Declining leaves the connect failed.
+ */
+export function HostKeyConfirmDialog() {
+  const t = useT();
+  const pending = useHostKeyPromptStore((s) => s.pending);
+  const status = useHostKeyPromptStore((s) => s.status);
+  const error = useHostKeyPromptStore((s) => s.error);
+  const keys = useHostKeyPromptStore((s) => s.keys);
+  const accept = useHostKeyPromptStore((s) => s.accept);
+  const cancel = useHostKeyPromptStore((s) => s.cancel);
+
+  if (!pending) return null;
+  const canAccept = status === "ready" && keys.length > 0;
+
+  return (
+    // No backdrop dismiss: the answer decides whether a password leaves this
+    // machine, so it must be given, not clicked past.
+    <div className="modal-backdrop">
+      <div className="project-dialog host-key-dialog">
+        <h2 className="host-key-title">
+          {t("hostKey.title")} <UntestedTag />
+        </h2>
+        <p className="host-key-lede">
+          {t("hostKey.ledePre")} <strong>{pending.target}</strong> {t("hostKey.ledePost")}
+        </p>
+
+        {status === "loading" && <div className="host-key-status">{t("hostKey.readingKey")}</div>}
+
+        {status === "error" && (
+          <div className="host-key-status host-key-status-error">
+            {t("hostKey.errorHeading")}
+            <div className="host-key-error-detail">{error}</div>
+          </div>
+        )}
+
+        {keys.length > 0 && (
+          <ul className="host-key-list">
+            {keys.map((k) => (
+              <li key={k.fingerprint} className="host-key-row">
+                <span className="host-key-type">
+                  {k.keyType} {k.bits}
+                </span>
+                <code className="host-key-fp">{k.fingerprint}</code>
+              </li>
+            ))}
+          </ul>
+        )}
+
+        {canAccept && (
+          <p className="host-key-note">
+            {t("hostKey.acceptNotePre")} <code>~/.ssh/known_hosts</code>{t("hostKey.acceptNotePost")}
+          </p>
+        )}
+
+        <div className="project-dialog-actions">
+          <button type="button" onClick={cancel}>
+            {t("common.cancel")}
+          </button>
+          <button
+            type="button"
+            className="primary"
+            disabled={!canAccept}
+            onClick={() => void accept()}
+          >
+            {status === "trusting" ? t("hostKey.accepting") : t("hostKey.acceptAndConnect")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/common/HpcGuardDialog.tsx b/src/components/common/HpcGuardDialog.tsx
new file mode 100644
index 0000000..d8a0779
--- /dev/null
+++ b/src/components/common/HpcGuardDialog.tsx
@@ -0,0 +1,74 @@
+import { useHpcGuardStore, type HpcGuardKind } from "../../stores/hpcGuardPrompt";
+import { UntestedTag } from "./UntestedTag";
+
+/**
+ * The HPC tag's confirmation, mounted once at the shell like the host-key prompt.
+ *
+ * It exists for the two gated things that can't just be switched off — a
+ * disk-usage scan of the cluster tree, and running something in a login-node
+ * shell — where the honest answer is "you may, but not by accident". It states
+ * what the act costs the machine and what the compliant route is, and then gets
+ * out of the way: proceeding is the user's call, and this never remembers the
+ * answer.
+ */
+
+/** What each refusal is about, in the terms the site's rules put it. */
+const COPY: Record<HpcGuardKind, { title: string; body: string; go: string }> = {
+  "du-scan": {
+    title: "Scan the whole tree on a cluster?",
+    body:
+      "This walks every file under the project root to add up sizes. On a cluster that root normally lives on the parallel filesystem, where a recursive walk means one metadata request per file against a server the whole site shares — the read filesystem guides ask you not to do casually. It is one scan, not a loop, so it is yours to run if you want it.",
+    go: "Scan anyway",
+  },
+  census: {
+    title: "Measure the host's folders on a cluster?",
+    body:
+      "The giant-folder census runs `du` over the whole host tree to find what is too big to sync. Same metadata cost as a full scan, and this one normally runs by itself on connect — which is why it stays off here unless you ask.",
+    go: "Measure anyway",
+  },
+  "login-node-run": {
+    title: "Run this on the login node?",
+    body:
+      "This would run on the cluster's login node, which is shared with everyone logged in right now. Sites ask you to keep CPU-intensive work off it and reserve the right to kill processes that load it for long. The compliant route for the same work is an interactive job — the Jobs view's srun shell — or a batch script with sbatch.",
+    go: "Run here anyway",
+  },
+};
+
+export function HpcGuardDialog() {
+  const pending = useHpcGuardStore((s) => s.pending);
+  const proceed = useHpcGuardStore((s) => s.proceed);
+  const cancel = useHpcGuardStore((s) => s.cancel);
+
+  if (!pending) return null;
+  const copy = COPY[pending.kind] ?? COPY["login-node-run"];
+
+  return (
+    // Backdrop-dismissable, unlike the host-key prompt: nothing here is a
+    // security decision, and "I didn't mean to" is a legitimate answer that
+    // should cost one click.
+    <div className="modal-backdrop" onClick={cancel}>
+      <div className="project-dialog hpc-guard-dialog" onClick={(e) => e.stopPropagation()}>
+        <h2 className="hpc-guard-title">
+          {copy.title} <UntestedTag />
+        </h2>
+        <div className="hpc-guard-target">
+          <span className="hpc-guard-badge">HPC</span>
+          <code>{pending.target}</code>
+        </div>
+        <p className="hpc-guard-body">{copy.body}</p>
+        <p className="hpc-guard-note">
+          You tagged this machine as a cluster login node. Untag it in the Machines menu if that
+          was wrong — nothing here is remembered, so this asks again next time.
+        </p>
+        <div className="project-dialog-actions">
+          <button type="button" onClick={cancel}>
+            Cancel
+          </button>
+          <button type="button" onClick={proceed}>
+            {copy.go}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/common/LocalLossDialog.tsx b/src/components/common/LocalLossDialog.tsx
new file mode 100644
index 0000000..592a1bd
--- /dev/null
+++ b/src/components/common/LocalLossDialog.tsx
@@ -0,0 +1,142 @@
+import { useEffect } from "react";
+import { listen } from "@tauri-apps/api/event";
+import { useProjectsStore } from "../../stores/projects";
+import { useLocalLossStore, type LocalLoss } from "../../stores/localLoss";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+/**
+ * Warns that something on the LOCAL side was destroyed by git lockstep or by sync
+ * (#28q). Mounted once at the shell, like the alarm popup: a mirror file can be deleted
+ * by a background reconcile pass while the user is in a terminal three tabs away, and
+ * they must hear about it wherever they are — the panel it happened in may not even be
+ * open.
+ *
+ * Reads `stores/localLoss`, which reads the backend's on-disk log rather than an event,
+ * so a deletion during a background pass (or while the app was closed) still surfaces.
+ * Refreshed whenever a lockstep or sync pass reports in — those are exactly the passes
+ * that can have recorded something.
+ *
+ * It reports, it does not confirm: by the time this renders the write has happened. The
+ * gates that *prevent* a destructive write live upstream (`pairing_conflict`, the
+ * blocked-fast-forward refusal, `push_decision`), and this exists precisely for what
+ * they deliberately let through.
+ */
+
+const KIND_LABEL_KEY: Record<LocalLoss["kind"], TranslationKey> = {
+  deleted: "localLoss.kindDeleted",
+  overwritten: "localLoss.kindOverwritten",
+};
+
+const SOURCE_LABEL_KEY: Record<LocalLoss["source"], TranslationKey> = {
+  git: "localLoss.sourceGit",
+  sync: "localLoss.sourceSync",
+};
+
+function timeLabel(ts: number): string {
+  return new Date(ts * 1000).toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+function LossEntry({ loss }: { loss: LocalLoss }) {
+  const t = useT();
+  const hidden = loss.total - loss.paths.length;
+  return (
+    <div className="local-loss-entry">
+      <div className="local-loss-entry-head">
+        <span className={`local-loss-badge local-loss-badge-${loss.kind}`}>
+          {t(loss.total === 1 ? "localLoss.entryCountOne" : "localLoss.entryCountMany", {
+            count: loss.total,
+            kind: t(KIND_LABEL_KEY[loss.kind]),
+          })}
+        </span>
+        <span className="local-loss-when">
+          {t(SOURCE_LABEL_KEY[loss.source])} · {timeLabel(loss.ts)}
+        </span>
+      </div>
+      <div className="local-loss-op">{loss.op}</div>
+      <ul className="local-loss-paths">
+        {loss.paths.map((p) => (
+          <li key={p}>{p}</li>
+        ))}
+        {hidden > 0 && <li className="local-loss-more">{t("localLoss.moreCount", { count: hidden })}</li>}
+      </ul>
+      <div className={`local-loss-recovery${loss.recovery ? "" : " local-loss-gone"}`}>
+        {loss.recovery ?? t("localLoss.unrecoverable")}
+      </div>
+    </div>
+  );
+}
+
+export function LocalLossDialog() {
+  const t = useT();
+  const activeId = useProjectsStore((s) => s.activeId);
+  const entries = useLocalLossStore((s) => s.entries);
+  const loadedFor = useLocalLossStore((s) => s.projectId);
+  const refresh = useLocalLossStore((s) => s.refresh);
+  const ack = useLocalLossStore((s) => s.ack);
+
+  // Re-read the log on project switch and after every lockstep/sync pass — the only
+  // moments at which the backend can have appended to it.
+  useEffect(() => {
+    if (!activeId) return;
+    void refresh(activeId);
+    const uns: Array<() => void> = [];
+    let cancelled = false;
+    const on = (event: string) => {
+      void listen(event, () => {
+        void refresh(activeId);
+      }).then((u) => (cancelled ? u() : uns.push(u)));
+    };
+    on("git-peer-status");
+    on("sync-progress");
+    on("auto-sync");
+    return () => {
+      cancelled = true;
+      uns.forEach((u) => u());
+    };
+  }, [activeId, refresh]);
+
+  // Only ever speak for the project on screen: a log fetched for a project the user has
+  // since switched away from is not this project's news.
+  const mine = loadedFor === activeId ? entries : [];
+  const unseen = mine.filter((e) => !e.acked);
+  if (!activeId || unseen.length === 0) return null;
+
+  const files = unseen.reduce((n, e) => n + e.total, 0);
+
+  return (
+    // No click-outside dismiss and no Esc, unlike every other modal here: this one is
+    // only ever shown because something was already destroyed, and acknowledging it is
+    // permanent. A stray click on the backdrop must not be able to make it go away.
+    <div className="modal-backdrop">
+      <div className="project-dialog local-loss-dialog">
+        <h2 className="local-loss-title">{t("localLoss.title")}</h2>
+        <p className="local-loss-lede">
+          {t("localLoss.ledePre")}{" "}
+          <strong>
+            {t(files === 1 ? "localLoss.filesCountOne" : "localLoss.filesCountMany", { count: files })}
+          </strong>{" "}
+          {t("localLoss.ledeMid")}{" "}
+          {t(unseen.length === 1 ? "localLoss.opsCountOne" : "localLoss.opsCountMany", { count: unseen.length })}
+          {t("localLoss.ledePost")}
+        </p>
+        <div className="local-loss-list">
+          {/* Two ops in the same second share a `ts` (a fast-forward and the clean that
+              cleared its way, say), so the index is part of the key. */}
+          {unseen.map((e, i) => (
+            <LossEntry key={`${e.ts}-${i}`} loss={e} />
+          ))}
+        </div>
+        <div className="project-dialog-actions">
+          <button type="button" onClick={() => void ack(activeId)}>
+            {t("howToStart.gotIt")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/common/PageStrip.tsx b/src/components/common/PageStrip.tsx
new file mode 100644
index 0000000..85c419e
--- /dev/null
+++ b/src/components/common/PageStrip.tsx
@@ -0,0 +1,560 @@
+/**
+ * The page-arrangement strip: a row (or column) of page thumbnails you can
+ * shift-select, drag to reorder, turn and delete.
+ *
+ * ONE widget, two homes — the print preview's horizontal strip and the PDF viewer's
+ * vertical page rail — so reordering behaves identically in both. It edits the
+ * shared `lib/viewers/pageModel` arrangement and reports each edit through
+ * `onChange`; it owns no arrangement state of its own, only the transient selection
+ * and drag.
+ *
+ * The drag is pointer-based, not HTML5 DnD, which is broken under WebKitGTK (the
+ * same reason the tab strip is pointer-driven). Terminal events go through
+ * `bindDragRelease` so the per-engine pointercancel/capture/blur divergence comes
+ * from the one vetted policy rather than being re-derived here.
+ *
+ * Reordering is applied LIVE as the pointer crosses a neighbour, so the print
+ * preview reflows under the cursor exactly as it did before. Escape puts the
+ * arrangement back the way it was when the drag began.
+ */
+import { Fragment, useCallback, useEffect, useRef, useState, type ReactNode } from "react";
+import { createPortal } from "react-dom";
+import {
+  movePages,
+  deletePages,
+  rotatePages,
+  duplicatePages,
+  type PageList,
+  type PageRef,
+} from "../../lib/viewers/pageModel";
+import { nextSelection } from "../../lib/viewers/fileUtils";
+import { bindDragRelease, dragPlatform } from "../../lib/dragPlatform";
+import { useClampToViewport } from "../../hooks/useClampToViewport";
+import {
+  registerPageStrip,
+  resolveDropTarget,
+  paintCaret,
+  importInto,
+  emitPdfDragStart,
+  emitPdfDragMove,
+  emitPdfDragEnd,
+  awaitDropAck,
+  currentWindowLabel,
+  listenForeignPageDrags,
+  type PageTransfer,
+  type DropTarget,
+} from "../../stores/pdfDrag";
+import {
+  snapshotFrame,
+  startCursorPoll,
+  pointInOuter,
+  physToClient,
+  type PhysPoint,
+  type WindowFrame,
+} from "../../lib/coords";
+import { useT } from "../../lib/i18n";
+
+/** Below this many px of pointer travel a press is a click, not a drag. */
+const DRAG_THRESHOLD_PX = 5;
+
+/** A card's box, paired with the arrangement index it sits at. */
+export interface CardBox {
+  index: number;
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+
+/**
+ * Where a drag would insert, given the boxes of the cards NOT being dragged (in
+ * arrangement order) and the pointer. The result counts only those cards — which is
+ * exactly `movePages`' index convention — so it can be handed straight to it.
+ *
+ * The pointer lands *before* the first card whose midpoint it has not yet passed,
+ * along the strip's own axis; past them all, it appends.
+ */
+export function insertionIndexAt(
+  others: readonly CardBox[],
+  x: number,
+  y: number,
+  orientation: "row" | "column",
+): number {
+  for (let i = 0; i < others.length; i++) {
+    const b = others[i];
+    const mid =
+      orientation === "row" ? (b.left + b.right) / 2 : (b.top + b.bottom) / 2;
+    const along = orientation === "row" ? x : y;
+    if (along < mid) return i;
+  }
+  return others.length;
+}
+
+interface ContextMenuState {
+  x: number;
+  y: number;
+  /** The sheets the menu acts on (the selection, or the right-clicked sheet). */
+  ids: string[];
+}
+
+export interface PageStripProps {
+  /** The arrangement to show. */
+  pages: PageList;
+  /** Apply an edit (reorder / delete / rotate / duplicate). */
+  onChange: (next: PageList) => void;
+  /** Lay the cards out along the x axis (print strip) or the y axis (PDF rail). */
+  orientation?: "row" | "column";
+  /** The thumbnail for one sheet. The strip supplies the card, box and rotation. */
+  renderThumb: (ref: PageRef, index: number) => ReactNode;
+  /** The card's corner badge — the print position, or the page number in the rail. */
+  badgeFor?: (ref: PageRef, index: number) => string;
+  /** Dim a sheet (the print preview dims pages its selection excludes). */
+  isExcluded?: (ref: PageRef, index: number) => boolean;
+  /** The card's tooltip. */
+  titleFor?: (ref: PageRef, index: number) => string;
+  /** Told the selection whenever it changes, so the host can act on it (copy/cut). */
+  onSelectionChange?: (ids: Set<string>) => void;
+  className?: string;
+
+  // ── Cross-viewer / cross-window page transfer (optional) ───────────────────
+  // Supplying these three turns the strip into a drag SOURCE and a drop TARGET for
+  // other strips — in this window and in other Eldrun windows. The print preview
+  // omits them, so its strip only ever reorders within itself.
+
+  /** Stable id identifying this strip among all mounted ones. Required for transfer. */
+  stripId?: string;
+  /** Extract `ids` into a transferable PDF parked in the backend page clipboard. */
+  onExport?: (ids: string[]) => Promise<PageTransfer | null>;
+  /** Splice pages transferred from another strip in at `index`. */
+  onImport?: (transfer: PageTransfer, index: number) => void;
+  /** The pages were MOVED out (Shift), and the drop was acknowledged: drop them. */
+  onMovedOut?: (ids: string[]) => void;
+}
+
+/** Reference-counted, so the foreign-drag listener exists exactly while at least one
+ *  droppable strip is mounted in this window. */
+let foreignListeners = 0;
+let stopForeign: Promise<() => void> | null = null;
+
+export function PageStrip({
+  pages,
+  onChange,
+  orientation = "row",
+  renderThumb,
+  badgeFor,
+  isExcluded,
+  titleFor,
+  onSelectionChange,
+  className,
+  stripId,
+  onExport,
+  onImport,
+  onMovedOut,
+}: PageStripProps) {
+  const t = useT();
+  const stripRef = useRef<HTMLDivElement>(null);
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+  const anchorRef = useRef<string | null>(null);
+  const [draggingIds, setDraggingIds] = useState<Set<string> | null>(null);
+  const [menu, setMenu] = useState<ContextMenuState | null>(null);
+  const menuRef = useRef<HTMLDivElement>(null);
+  useClampToViewport(menuRef, menu, setMenu);
+  /** Where a foreign drag would land (an insertion caret), or null. */
+  const [caret, setCaret] = useState<number | null>(null);
+
+  /** True when this strip can send pages to, and receive them from, other strips. */
+  const transferable = Boolean(stripId && onExport && onImport);
+
+  /** Insertion index for a point in this window's client px — the geometry a foreign
+   *  drag needs from us, computed against our own live card rects. */
+  const indexAt = useCallback(
+    (p: { x: number; y: number }) => {
+      const strip = stripRef.current;
+      if (!strip) return 0;
+      const boxes: CardBox[] = [];
+      strip.querySelectorAll<HTMLElement>("[data-page-id]").forEach((el, i) => {
+        const b = el.getBoundingClientRect();
+        boxes.push({ index: i, left: b.left, top: b.top, right: b.right, bottom: b.bottom });
+      });
+      return insertionIndexAt(boxes, p.x, p.y, orientation);
+    },
+    [orientation],
+  );
+
+  // Publish this strip so a drag from another strip — or another window — can find it,
+  // and keep the window's foreign-drag listener alive while any such strip exists.
+  const importRef = useRef(onImport);
+  importRef.current = onImport;
+  useEffect(() => {
+    const el = stripRef.current;
+    if (!transferable || !stripId || !el) return;
+    const unregister = registerPageStrip(stripId, {
+      el,
+      indexAt,
+      onImport: (t, index) => importRef.current?.(t, index),
+      setCaret,
+    });
+    foreignListeners += 1;
+    if (foreignListeners === 1) stopForeign = listenForeignPageDrags();
+    return () => {
+      unregister();
+      foreignListeners -= 1;
+      if (foreignListeners === 0 && stopForeign) {
+        const pending = stopForeign;
+        stopForeign = null;
+        void pending.then((f) => f());
+      }
+    };
+  }, [transferable, stripId, indexAt]);
+
+  // `pages` changes under the drag's feet (it reorders live), so the handlers read
+  // it from a ref rather than closing over the render's snapshot.
+  const pagesRef = useRef(pages);
+  pagesRef.current = pages;
+
+  const select = useCallback(
+    (ids: Set<string>) => {
+      setSelected(ids);
+      onSelectionChange?.(ids);
+    },
+    [onSelectionChange],
+  );
+
+  // Drop ids that no longer exist (a delete, or a fresh document).
+  useEffect(() => {
+    const live = new Set(pages.map((r) => r.id));
+    setSelected((cur) => {
+      if ([...cur].every((id) => live.has(id))) return cur;
+      const pruned = new Set([...cur].filter((id) => live.has(id)));
+      onSelectionChange?.(pruned);
+      return pruned;
+    });
+  }, [pages, onSelectionChange]);
+
+  useEffect(() => {
+    if (!menu) return;
+    const close = () => setMenu(null);
+    window.addEventListener("pointerdown", close);
+    return () => window.removeEventListener("pointerdown", close);
+  }, [menu]);
+
+  /** The sheets an action applies to: the selection when the sheet is in it, else
+   *  just that sheet (right-clicking outside a selection acts on what you clicked). */
+  const targetIds = useCallback(
+    (id: string): string[] => (selected.has(id) ? [...selected] : [id]),
+    [selected],
+  );
+
+  const onCardPointerDown = useCallback(
+    (e: React.PointerEvent, id: string) => {
+      if (e.button !== 0) return;
+      // WebKitGTK's native selection gesture would otherwise claim the pointer
+      // stream and end it in `pointercancel`.
+      e.preventDefault();
+      setMenu(null);
+
+      const startX = e.clientX;
+      const startY = e.clientY;
+      const mods = { shift: e.shiftKey, toggle: e.ctrlKey || e.metaKey };
+      // Pressing an unselected card selects it right away, so a drag that starts
+      // immediately drags what's under the cursor. Pressing one that is ALREADY
+      // selected defers to the release, so dragging a multi-selection keeps it.
+      if (!selected.has(id) && !mods.shift && !mods.toggle) {
+        select(new Set([id]));
+        anchorRef.current = id;
+      }
+
+      // The arrangement as it stood before the drag, so Escape — or the pages leaving
+      // the strip entirely — can put it back.
+      const listAtStart = pagesRef.current;
+      let dragging = false;
+      let lastTarget = -1;
+
+      // Which sheets travel: the whole selection if the pressed card is part of it,
+      // else just the pressed one.
+      const moving =
+        selected.has(id) && !mods.toggle ? new Set(selected) : new Set([id]);
+      const movingIds = [...moving];
+
+      // ── Cross-strip / cross-window state ────────────────────────────────────
+      // `leaving` flips once the pointer exits this strip: the pages are no longer
+      // being *reordered* here, they are being taken somewhere else.
+      let leaving = false;
+      let transfer: PageTransfer | null = null;
+      let exporting: Promise<PageTransfer | null> | null = null;
+      let stopPoll: (() => void) | null = null;
+      let frame: WindowFrame | null = null;
+      let lastPhys: PhysPoint | null = null;
+      const label = currentWindowLabel();
+
+      /** The pages are leaving: undo the live reorder, park them, and start streaming
+       *  the OS cursor so other windows can see the drag. */
+      const beginLeaving = () => {
+        leaving = true;
+        lastTarget = -1;
+        onChange(listAtStart); // they are not staying here — put the strip back
+        emitPdfDragStart(label, movingIds.length);
+        exporting = onExport!(movingIds).then((t) => {
+          transfer = t;
+          return t;
+        });
+        void snapshotFrame()
+          .then((f) => {
+            frame = f;
+          })
+          .catch(() => {});
+        // DOM pointer events stop at the window edge on WebKitGTK, so from here the
+        // position comes from the OS cursor — the only source that crosses windows.
+        stopPoll = startCursorPoll((p) => {
+          lastPhys = p;
+          emitPdfDragMove(label, p);
+        });
+      };
+
+      /** Back inside the strip: the pages are staying, so resume a plain reorder. */
+      const cancelLeaving = () => {
+        leaving = false;
+        lastTarget = -1;
+        stopPoll?.();
+        stopPoll = null;
+        paintCaret(null);
+      };
+
+      const onMove = (ev: PointerEvent) => {
+        if (!dragging) {
+          if (
+            Math.abs(ev.clientX - startX) < DRAG_THRESHOLD_PX &&
+            Math.abs(ev.clientY - startY) < DRAG_THRESHOLD_PX
+          ) {
+            return;
+          }
+          dragging = true;
+          setDraggingIds(moving);
+        }
+
+        const strip = stripRef.current;
+        if (!strip) return;
+        const r = strip.getBoundingClientRect();
+        const inside =
+          ev.clientX >= r.left &&
+          ev.clientX <= r.right &&
+          ev.clientY >= r.top &&
+          ev.clientY <= r.bottom;
+
+        if (transferable && !inside) {
+          if (!leaving) beginLeaving();
+          // Another strip in THIS window is resolved straight from the DOM; a strip in
+          // another window is driven by the streamed cursor (see `listenForeignPageDrags`).
+          paintCaret(resolveDropTarget({ x: ev.clientX, y: ev.clientY }, stripId));
+          return;
+        }
+        if (leaving) cancelLeaving();
+
+        const others: CardBox[] = [];
+        pagesRef.current.forEach((ref, index) => {
+          if (moving.has(ref.id)) return;
+          const el = strip.querySelector<HTMLElement>(`[data-page-id="${ref.id}"]`);
+          if (!el) return;
+          const b = el.getBoundingClientRect();
+          others.push({
+            index,
+            left: b.left,
+            top: b.top,
+            right: b.right,
+            bottom: b.bottom,
+          });
+        });
+
+        const target = insertionIndexAt(others, ev.clientX, ev.clientY, orientation);
+        if (target === lastTarget) return;
+        lastTarget = target;
+        onChange(movePages(pagesRef.current, movingIds, target));
+      };
+
+      window.addEventListener("pointermove", onMove);
+      if (dragPlatform.needsPointerCapture) {
+        (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+      }
+
+      /** Hand the pages to a strip elsewhere. Returns once the fate of a Shift-move
+       *  (delete from here, or not) is known. */
+      const dropElsewhere = async (shift: boolean) => {
+        const t = (await exporting) ?? transfer;
+        if (!t) return; // the export failed — nothing was parked, so nothing moves
+
+        // Where is the cursor REALLY? On WebKitGTK the DOM release fires in this
+        // window even when the cursor is over another one, so the polled desktop
+        // position decides — never the event's coordinates.
+        const overMe = frame && lastPhys ? pointInOuter(frame, lastPhys) : true;
+        if (overMe) {
+          const c =
+            frame && lastPhys ? physToClient(frame, lastPhys) : { x: startX, y: startY };
+          const target: DropTarget | null = resolveDropTarget(c, stripId);
+          if (target && importInto(target, t) && shift) onMovedOut?.(movingIds);
+          return;
+        }
+
+        // The drop is in some other window. Broadcast it, and only remove the pages
+        // from here once a window actually acknowledges taking them — a Shift-drag
+        // released over empty desktop must not destroy them.
+        emitPdfDragEnd({
+          originLabel: label,
+          token: t.token,
+          count: t.count,
+          physX: lastPhys?.x ?? 0,
+          physY: lastPhys?.y ?? 0,
+          shift,
+          cancelled: false,
+        });
+        if (!shift) return;
+        if (await awaitDropAck(t.token)) onMovedOut?.(movingIds);
+      };
+
+      const finish = (restore: boolean, shift = false) => {
+        window.removeEventListener("pointermove", onMove);
+        setDraggingIds(null);
+        stopPoll?.();
+        stopPoll = null;
+        paintCaret(null);
+
+        if (restore) {
+          if (leaving) {
+            // Tell the other windows to drop their carets; nothing is being handed over.
+            emitPdfDragEnd({
+              originLabel: label,
+              token: transfer?.token ?? "",
+              count: movingIds.length,
+              physX: lastPhys?.x ?? 0,
+              physY: lastPhys?.y ?? 0,
+              shift: false,
+              cancelled: true,
+            });
+          }
+          onChange(listAtStart);
+          return;
+        }
+        if (leaving) {
+          void dropElsewhere(shift);
+          return;
+        }
+        // A press that never became a drag is a click: apply the modifiers.
+        if (!dragging) {
+          const ordered = pagesRef.current.map((r) => r.id);
+          const next = nextSelection(selected, ordered, anchorRef.current, id, mods);
+          anchorRef.current = next.anchor;
+          select(next.selected);
+        }
+      };
+
+      bindDragRelease({
+        onCommit: (shift) => finish(false, shift),
+        onAbort: () => finish(true),
+      });
+    },
+    [onChange, orientation, select, selected, transferable, stripId, onExport, onMovedOut],
+  );
+
+  const act = useCallback(
+    (next: PageList) => {
+      setMenu(null);
+      onChange(next);
+    },
+    [onChange],
+  );
+
+  if (pages.length === 0) return null;
+
+  return (
+    <>
+      <div
+        ref={stripRef}
+        className={`page-strip page-strip-${orientation}${className ? ` ${className}` : ""}`}
+        role="list"
+        aria-label={t("pageStrip.ariaLabel")}
+      >
+        {pages.map((ref, index) => {
+          const excluded = isExcluded?.(ref, index) ?? false;
+          const badge = badgeFor?.(ref, index);
+          const quarter = ref.rot === 90 || ref.rot === 270;
+          return (
+            <Fragment key={ref.id}>
+              {caret === index && <div className="page-strip-caret" aria-hidden="true" />}
+            <div
+              data-page-id={ref.id}
+              role="listitem"
+              className={
+                "page-strip-card" +
+                (excluded ? " is-excluded" : "") +
+                (quarter ? " is-quarter-turned" : "") +
+                (selected.has(ref.id) ? " is-selected" : "") +
+                (draggingIds?.has(ref.id) ? " is-dragging" : "")
+              }
+              style={{ ["--page-thumb-rot" as string]: `${ref.rot}deg` }}
+              title={titleFor?.(ref, index)}
+              onPointerDown={(e) => onCardPointerDown(e, ref.id)}
+              onContextMenu={(e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                if (!selected.has(ref.id)) {
+                  select(new Set([ref.id]));
+                  anchorRef.current = ref.id;
+                }
+                setMenu({ x: e.clientX, y: e.clientY, ids: targetIds(ref.id) });
+              }}
+            >
+              {renderThumb(ref, index)}
+              {badge !== undefined && <span className="page-strip-num">{badge}</span>}
+              <button
+                className="page-strip-rotate"
+                type="button"
+                title={t("pageStrip.turnClockwiseTitle")}
+                aria-label={t("pageStrip.turnClockwiseAria")}
+                onPointerDown={(e) => e.stopPropagation()} // not a drag
+                onClick={() => act(rotatePages(pages, targetIds(ref.id)))}
+              >
+                ⟳
+              </button>
+              <button
+                className="page-strip-del"
+                type="button"
+                title={t("pageStrip.removePageTitle")}
+                aria-label={t("pageStrip.removePageAria")}
+                onPointerDown={(e) => e.stopPropagation()} // not a drag
+                onClick={() => act(deletePages(pages, targetIds(ref.id)))}
+              >
+                ✕
+              </button>
+            </div>
+            </Fragment>
+          );
+        })}
+        {caret === pages.length && <div className="page-strip-caret" aria-hidden="true" />}
+      </div>
+
+      {menu &&
+        createPortal(
+          <div
+            ref={menuRef}
+            className="context-menu page-strip-context-menu"
+            style={{ left: menu.x, top: menu.y }}
+            onPointerDown={(e) => e.stopPropagation()}
+          >
+            <button onClick={() => act(rotatePages(pages, menu.ids, 90))}>
+              {t("pageStrip.turnRight")}
+            </button>
+            <button onClick={() => act(rotatePages(pages, menu.ids, -90))}>
+              {t("pageStrip.turnLeft")}
+            </button>
+            <button onClick={() => act(duplicatePages(pages, menu.ids))}>
+              {t("pageStrip.duplicate")}
+            </button>
+            <hr />
+            <button onClick={() => act(deletePages(pages, menu.ids))}>
+              {menu.ids.length > 1 ? t("pageStrip.deleteMany", { count: menu.ids.length }) : t("pageStrip.deleteOne")}
+            </button>
+          </div>,
+          document.body,
+        )}
+    </>
+  );
+}
diff --git a/src/components/common/PasswordInput.tsx b/src/components/common/PasswordInput.tsx
new file mode 100644
index 0000000..093f548
--- /dev/null
+++ b/src/components/common/PasswordInput.tsx
@@ -0,0 +1,76 @@
+import { forwardRef, useState, type InputHTMLAttributes } from "react";
+
+/**
+ * Masked text input with a built-in show/hide toggle — a drop-in replacement for
+ * `<input type="password" />`. Every input prop (and the ref) is forwarded to the
+ * underlying `<input>`, and `className` is applied to it too, so existing
+ * per-call-site styling (e.g. `ssh-password-input`) keeps working. An eye button
+ * overlaid at the trailing edge flips the field between masked and plain text.
+ *
+ * The toggle stays enabled even when the input is `disabled` (e.g. while a connect
+ * is in flight) so the typed secret can still be checked; it never changes the
+ * value and is skipped in the tab order.
+ */
+export const PasswordInput = forwardRef<
+  HTMLInputElement,
+  Omit<InputHTMLAttributes<HTMLInputElement>, "type">
+>(function PasswordInput({ className, ...rest }, ref) {
+  const [shown, setShown] = useState(false);
+  return (
+    <span className="password-input-wrap">
+      <input
+        {...rest}
+        ref={ref}
+        type={shown ? "text" : "password"}
+        className={className}
+      />
+      <button
+        type="button"
+        className="password-reveal-btn"
+        tabIndex={-1}
+        aria-label={shown ? "Hide password" : "Show password"}
+        title={shown ? "Hide password" : "Show password"}
+        onClick={() => setShown((s) => !s)}
+      >
+        {shown ? <EyeOffIcon /> : <EyeIcon />}
+      </button>
+    </span>
+  );
+});
+
+function EyeIcon() {
+  return (
+    <svg width="16" height="16" viewBox="0 0 16 16" fill="none" aria-hidden="true">
+      <path
+        d="M1 8s2.5-4.5 7-4.5S15 8 15 8s-2.5 4.5-7 4.5S1 8 1 8Z"
+        stroke="currentColor"
+        strokeWidth="1.3"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <circle cx="8" cy="8" r="1.9" stroke="currentColor" strokeWidth="1.3" />
+    </svg>
+  );
+}
+
+function EyeOffIcon() {
+  return (
+    <svg width="16" height="16" viewBox="0 0 16 16" fill="none" aria-hidden="true">
+      <path
+        d="M6.3 3.7A6.7 6.7 0 0 1 8 3.5c4.5 0 7 4.5 7 4.5a12.6 12.6 0 0 1-2.2 2.7M4 4.6A12.2 12.2 0 0 0 1 8s2.5 4.5 7 4.5a6.9 6.9 0 0 0 2.6-.5"
+        stroke="currentColor"
+        strokeWidth="1.3"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <path
+        d="M6.6 6.6a2 2 0 0 0 2.8 2.8"
+        stroke="currentColor"
+        strokeWidth="1.3"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+      />
+      <line x1="2" y1="2" x2="14" y2="14" stroke="currentColor" strokeWidth="1.3" strokeLinecap="round" />
+    </svg>
+  );
+}
diff --git a/src/components/common/ProjectBlobPane.tsx b/src/components/common/ProjectBlobPane.tsx
new file mode 100644
index 0000000..ad61d69
--- /dev/null
+++ b/src/components/common/ProjectBlobPane.tsx
@@ -0,0 +1,1009 @@
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "../../stores/projects";
+import { useBoxesStore } from "../../stores/boxes";
+import { useWindowsStore } from "../../stores/windows";
+import { resolveProjectDirectory, type ProjectBox, type ProjectEntry } from "../../types";
+import { ActivityCalendar } from "../projects/ActivityCalendar";
+import { CategoryEditor } from "../projects/CategoryEditor";
+import { categoryColor, primaryCategoryColor, projectCategories } from "../../lib/categoryColor";
+import { energySaverActive } from "../../stores/power";
+import {
+  type FileEntry,
+  fileIcon,
+  folderIcon,
+  fmtSize,
+  fmtModified,
+} from "../../lib/viewers/fileUtils";
+import { useT } from "../../lib/i18n";
+
+/**
+ * A node in the 3D cloud. In the project cloud it's a project or a box; once a
+ * project is focused (the spherical file viewer) it's the centered project plus
+ * one node per file/folder in the current directory.
+ */
+type BlobNode =
+  | { id: string; kind: "project"; project: ProjectEntry }
+  | { id: string; kind: "box"; box: ProjectBox }
+  | { id: string; kind: "center"; project: ProjectEntry; label: string; rel: string }
+  | { id: string; kind: "file"; entry: FileEntry };
+
+/** A 3D coordinate (already scaled by the node's cloud radius at layout time). */
+interface Vec3 {
+  x: number;
+  y: number;
+  z: number;
+}
+
+/** The focused project + the directory currently shown around it. */
+interface FocusState {
+  project: ProjectEntry;
+  dir: string; // absolute project root
+  rel: string; // current directory relative to the root ("" = root)
+}
+
+/**
+ * Distribute `n` points evenly over a sphere of `radius` using the Fibonacci
+ * lattice — deterministic and visually uniform without clustering at the poles.
+ */
+function fibonacciSphere(n: number, radius: number): Vec3[] {
+  if (n <= 0) return [];
+  if (n === 1) return [{ x: 0, y: 0, z: radius }];
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  const out: Vec3[] = [];
+  for (let i = 0; i < n; i++) {
+    const y = 1 - (i / (n - 1)) * 2; // 1 → -1
+    const r = Math.sqrt(Math.max(0, 1 - y * y));
+    const theta = golden * i;
+    out.push({ x: Math.cos(theta) * r * radius, y: y * radius, z: Math.sin(theta) * r * radius });
+  }
+  return out;
+}
+
+/** A point on a circle of `r` at angle `a` (radians), centered at (cx, cy). */
+function polar(cx: number, cy: number, r: number, a: number): [number, number] {
+  return [cx + r * Math.cos(a), cy + r * Math.sin(a)];
+}
+
+/**
+ * SVG path for a donut segment between angles `a0`→`a1` (radians, clockwise),
+ * with outer/inner radii `rO`/`rI`. A near-full sweep (the single-project case)
+ * is drawn as a complete ring via an even-odd circle pair, since a normal arc
+ * whose endpoints coincide renders nothing.
+ */
+function donutSlicePath(cx: number, cy: number, rO: number, rI: number, a0: number, a1: number): string {
+  if (a1 - a0 >= Math.PI * 2 - 1e-3) {
+    const ring = (r: number) =>
+      `M ${cx - r} ${cy} a ${r} ${r} 0 1 0 ${2 * r} 0 a ${r} ${r} 0 1 0 ${-2 * r} 0 Z`;
+    return `${ring(rO)} ${ring(rI)}`;
+  }
+  const large = a1 - a0 > Math.PI ? 1 : 0;
+  const [x0, y0] = polar(cx, cy, rO, a0);
+  const [x1, y1] = polar(cx, cy, rO, a1);
+  const [x2, y2] = polar(cx, cy, rI, a1);
+  const [x3, y3] = polar(cx, cy, rI, a0);
+  return `M ${x0} ${y0} A ${rO} ${rO} 0 ${large} 1 ${x1} ${y1} L ${x2} ${y2} A ${rI} ${rI} 0 ${large} 0 ${x3} ${y3} Z`;
+}
+
+const ROT_SENSITIVITY = 0.3; // deg per px dragged
+const AUTO_SPIN = 0.06; // deg per frame when idle
+const MIN_DOLLY = -360;
+const PERSPECTIVE = 1100; // px; the perspective the CSS scene used to delegate
+// Zoom (dolly) can now push the camera all the way through the cloud rather than
+// stopping at the front shell. At dz = PERSPECTIVE the camera plane sits at the
+// cloud centre; a little beyond lets you fly out the far side. Capped so the
+// fly-through ends in mostly-empty space instead of an unbounded void.
+const MAX_DOLLY = PERSPECTIVE + 360;
+// Nodes whose projected depth falls within this of the camera are treated as
+// flown-past: hidden and click-through. NEAR_FADE is the runway over which a
+// node dissolves as it approaches that plane, so passing through one is a soft
+// fade rather than a pop (and it never blows up to an infinite scale).
+const NEAR_PLANE = 60;
+const NEAR_FADE = 240;
+const DBL_CLICK_MS = 260; // window to detect a double-click before the single fires
+
+/** Human-readable total time tracked on a project. */
+function fmtWorked(secs?: number): string {
+  if (!secs || secs <= 0) return "untracked";
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor((secs % 3600) / 60);
+  return h > 0 ? `${h}h ${m}m worked` : `${m}m worked`;
+}
+
+/** Where the right-click menu is anchored, plus the project it targets. */
+interface BlobMenu {
+  x: number;
+  y: number;
+  project: ProjectEntry;
+}
+
+/**
+ * The "Projects" tab body: a navigable 3D cloud of every project and box, plus
+ * a spherical file viewer. Drag to orbit, scroll to zoom (dolly).
+ *
+ * Two modes:
+ *  - **Cloud** (default): every project + box floats around the center. A
+ *    project's *distance* from the center grows with the time tracked on it, so
+ *    the most-worked projects sit furthest out. Single-click a project to focus
+ *    it (open the file viewer); double-click to open it as the current scope.
+ *  - **File viewer** (a project is focused): that project is pinned at the
+ *    center and its files/folders orbit around it. Click a folder to descend,
+ *    a file to open it, the center (or Esc) to go back up / exit.
+ *
+ * Rendered without WebGL: the rAF loop rotates each node's point and does the
+ * perspective divide itself, then writes a plain 2D transform to the DOM. It
+ * deliberately does NOT lean on CSS `perspective`/`preserve-3d` to project the
+ * Z — WebKitGTK (Linux) drops nested-3D Z, which flattened the sphere to a disc,
+ * while Chromium/WebView2 (Windows) honored it. Keeping the orbit/zoom state in
+ * refs means a slow spin and a 60fps drag never thrash React. Each node is also
+ * depth-shaded (front bright, back dim) so the cloud reads as a solid sphere.
+ */
+export function ProjectBlobPane() {
+  const t = useT();
+  const projects = useProjectsStore((s) => s.projects);
+  const activeId = useProjectsStore((s) => s.activeId);
+  const setActive = useProjectsStore((s) => s.setActive);
+  const activateProject = useProjectsStore((s) => s.activateProject);
+  const deactivateProject = useProjectsStore((s) => s.deactivateProject);
+  const boxes = useBoxesStore((s) => s.boxes);
+  const openBox = useBoxesStore((s) => s.openBox);
+  const openFile = useWindowsStore((s) => s.openFile);
+
+  const [menu, setMenu] = useState<BlobMenu | null>(null);
+  // The project whose category editor is open (null = closed).
+  const [catProject, setCatProject] = useState<ProjectEntry | null>(null);
+  // The node currently hovered, plus where to anchor its info card. Cleared on
+  // leave, on an orbit drag, and whenever the context menu opens.
+  const [hover, setHover] = useState<{ x: number; y: number; node: BlobNode } | null>(null);
+  // Per-project activity history (date → seconds). Drives both the hover card's
+  // GitHub-style heatmap and the time-based cloud radius, so it's fetched for
+  // every project (not just on hover) and cached.
+  const [activity, setActivity] = useState<Record<string, Record<string, number>>>({});
+  // The focused project + directory (null = project cloud).
+  const [focus, setFocus] = useState<FocusState | null>(null);
+  // Files/folders of the focused directory.
+  const [entries, setEntries] = useState<FileEntry[]>([]);
+  const [entriesLoading, setEntriesLoading] = useState(false);
+  // Which visualization the project cloud renders: the 3D "sphere" (default) or
+  // a 2D "pie" donut of time tracked per project. The file viewer (focus) is
+  // sphere-only, so the toggle is hidden — and switching to pie exits focus.
+  const [viewMode, setViewMode] = useState<"sphere" | "pie">("sphere");
+
+  // Fetch activity for any project we don't have yet (the guard makes this a
+  // one-shot per project, not a refetch loop).
+  useEffect(() => {
+    const missing = projects.filter((p) => !(p.id in activity)).map((p) => p.id);
+    if (missing.length === 0) return;
+    let cancelled = false;
+    Promise.all(
+      missing.map((id) =>
+        invoke<Record<string, number>>("get_project_activity", { projectId: id })
+          .then((d) => [id, d] as const)
+          .catch(() => [id, {}] as const),
+      ),
+    ).then((pairs) => {
+      if (!cancelled) setActivity((m) => ({ ...m, ...Object.fromEntries(pairs) }));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [projects, activity]);
+
+  // Total seconds tracked per project, and the busiest project, for the radius.
+  const totals = useMemo(() => {
+    const out: Record<string, number> = {};
+    for (const [id, d] of Object.entries(activity)) {
+      out[id] = Object.values(d).reduce((a, b) => a + b, 0);
+    }
+    return out;
+  }, [activity]);
+  const maxTotal = useMemo(() => {
+    let m = 1;
+    for (const v of Object.values(totals)) if (v > m) m = v;
+    return m;
+  }, [totals]);
+
+  // Pie slices: one per project, the sweep proportional to time tracked. A flat
+  // floor is added to every weight so untracked projects still get a visible,
+  // clickable wedge (and all-untracked clouds split evenly). Slices start at the
+  // top (−90°) and run clockwise.
+  const pieSlices = useMemo(() => {
+    const items = [...projects].sort((a, b) => a.position - b.position);
+    if (items.length === 0) return [];
+    const secs = items.map((p) => totals[p.id] ?? 0);
+    const floor = maxTotal * 0.08;
+    const adj = secs.map((s) => s + floor);
+    const sum = adj.reduce((a, b) => a + b, 0) || 1;
+    let acc = -Math.PI / 2;
+    return items.map((project, i) => {
+      const frac = adj[i] / sum;
+      const a0 = acc;
+      const a1 = acc + frac * Math.PI * 2;
+      acc = a1;
+      const cat = primaryCategoryColor(projectCategories(project));
+      const color = cat ?? (project.status === "inactive" ? "var(--text-muted)" : "var(--accent)");
+      return { project, a0, a1, frac, secs: secs[i], color, single: items.length === 1 };
+    });
+  }, [projects, totals, maxTotal]);
+
+  // Load the focused directory's listing whenever the focus/path changes.
+  useEffect(() => {
+    if (!focus) {
+      setEntries([]);
+      return;
+    }
+    let cancelled = false;
+    setEntriesLoading(true);
+    invoke<FileEntry[]>("list_dir", { projectDir: focus.dir, relPath: focus.rel })
+      .then((r) => {
+        if (!cancelled) setEntries(r);
+      })
+      .catch(() => {
+        if (!cancelled) setEntries([]);
+      })
+      .finally(() => {
+        if (!cancelled) setEntriesLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [focus]);
+
+  const nodes = useMemo<BlobNode[]>(() => {
+    if (focus) {
+      const label = focus.rel === "" ? focus.project.name : focus.rel.split("/").pop()!;
+      const center: BlobNode = { id: "center", kind: "center", project: focus.project, label, rel: focus.rel };
+      const fileNodes: BlobNode[] = entries.map((entry) => ({ id: `f:${entry.path}`, kind: "file", entry }));
+      return [center, ...fileNodes];
+    }
+    const projectNodes: BlobNode[] = [...projects]
+      .sort((a, b) => a.position - b.position)
+      .map((project) => ({ id: `p:${project.id}`, kind: "project", project }));
+    const boxNodes: BlobNode[] = [...boxes]
+      .sort((a, b) => a.position - b.position)
+      .map((box) => ({ id: `b:${box.id}`, kind: "box", box }));
+    return [...projectNodes, ...boxNodes];
+  }, [focus, entries, projects, boxes]);
+
+  // Cloud radius grows with population so dense clouds don't overlap.
+  const radius = useMemo(() => Math.min(560, 220 + nodes.length * 16), [nodes.length]);
+
+  // Each ring node gets an even direction from the Fibonacci lattice, then a
+  // per-node distance: projects push out with time worked (more time → further
+  // from center), boxes sit at a neutral mid-radius, files are uniform, and the
+  // focused project is pinned at the very center.
+  const positions = useMemo(() => {
+    const ring = nodes.filter((n) => n.kind !== "center");
+    const dirs = fibonacciSphere(ring.length, 1);
+    const dirById = new Map<string, Vec3>();
+    ring.forEach((n, i) => dirById.set(n.id, dirs[i] ?? { x: 0, y: 0, z: 1 }));
+    return nodes.map((n) => {
+      if (n.kind === "center") return { x: 0, y: 0, z: 0 };
+      const d = dirById.get(n.id) ?? { x: 0, y: 0, z: 1 };
+      let s: number;
+      if (n.kind === "project") {
+        const tot = totals[n.project.id];
+        s = tot === undefined ? 0.72 : 0.5 + 0.5 * (tot / maxTotal);
+      } else if (n.kind === "box") {
+        s = 0.72;
+      } else {
+        s = 1; // files: uniform shell around the focused project
+      }
+      const r = radius * s;
+      return { x: d.x * r, y: d.y * r, z: d.z * r };
+    });
+  }, [nodes, radius, totals, maxTotal]);
+
+  const viewportRef = useRef<HTMLDivElement>(null);
+  const sceneRef = useRef<HTMLDivElement>(null);
+  const nodeEls = useRef<Map<string, HTMLDivElement>>(new Map());
+  // The hover card follows its node as the sphere spins, so the rAF loop pins it
+  // each frame. It reads the hovered id (not React state, which the once-mounted
+  // loop can't see) and writes straight to the card element.
+  const hoverCardRef = useRef<HTMLDivElement>(null);
+  const hoverIdRef = useRef<string | null>(null);
+  // Mirror the outer radius into a ref so the rAF loop (mounted once) can
+  // normalize each node's rotated depth without re-binding on population change.
+  const radiusRef = useRef(radius);
+  radiusRef.current = radius;
+  // Mirror the hovered node id (suppressed while the menu is open) for the loop.
+  hoverIdRef.current = hover && !menu ? hover.node.id : null;
+  // Mirror the view mode so the (once-bound) orbit handler can ignore drags
+  // while the flat pie is showing.
+  const viewModeRef = useRef(viewMode);
+  viewModeRef.current = viewMode;
+  // Pending single-click timer, so a double-click can cancel the single action.
+  const clickTimer = useRef<number | null>(null);
+
+  // Live orbit/zoom state — held in refs (not React state) so the rAF loop can
+  // mutate them without re-rendering. rotY orbits horizontally, rotX vertically.
+  const rotX = useRef(-12);
+  const rotY = useRef(0);
+  const dolly = useRef(0); // translateZ of the whole scene (zoom)
+  const dragging = useRef(false);
+  // Set true once a press becomes a real orbit drag, so the click that the
+  // browser fires on pointerup is ignored by the node handlers. Reset at the
+  // start of every gesture (in onPointerDown) so it can never leak into a later,
+  // genuine click — the failure mode of the old one-shot window swallow.
+  const suppressClick = useRef(false);
+  // Bloom animation: on every layout change (enter/leave focus, change folder)
+  // the nodes fly out from the center. Progress runs 0→1 over ~380ms; the rAF
+  // loop scales each node's radius by it. lastTs carries the frame timestamp.
+  const animProgress = useRef(1);
+  const lastTs = useRef(0);
+  // Phase-1 "fly to center" when focusing a project: the chosen node id, its
+  // 0→1 progress, and the focus to commit (phase 2: the files bloom out) once it
+  // lands. Driven by the rAF loop so it can't fight React re-renders.
+  const convergeId = useRef<string | null>(null);
+  const convergeProgress = useRef(0);
+  const pendingFocus = useRef<FocusState | null>(null);
+  // Restart the bloom whenever the rendered layout (mode/project/folder) changes.
+  const layoutKey = focus ? `f:${focus.project.id}:${focus.rel}` : "cloud";
+  useEffect(() => {
+    animProgress.current = 0;
+  }, [layoutKey]);
+
+  const registerNode = useCallback(
+    (id: string) => (el: HTMLDivElement | null) => {
+      if (el) nodeEls.current.set(id, el);
+      else nodeEls.current.delete(id);
+    },
+    [],
+  );
+
+  // rAF loop: rotate + project every node and pin the hover card. Auto-spins
+  // gently while the user isn't dragging.
+  useEffect(() => {
+    let raf = 0;
+    const frame = (ts: number) => {
+      // Panes stay mounted across scope switches; skip all work (and the spin)
+      // while this one is hidden (display:none → no offsetParent).
+      if (!viewportRef.current?.offsetParent) {
+        lastTs.current = ts;
+        raf = requestAnimationFrame(frame);
+        return;
+      }
+      // Advance the bloom: ease the radius out, fade opacity in a touch faster.
+      const dt = lastTs.current ? ts - lastTs.current : 16;
+      lastTs.current = ts;
+      if (animProgress.current < 1) animProgress.current = Math.min(1, animProgress.current + dt / 380);
+      const grow = 1 - Math.pow(1 - animProgress.current, 3); // easeOutCubic radius
+      const fadeIn = Math.min(1, animProgress.current * 1.6);
+      // Phase-1 converge: pull the chosen node to center, fade the rest out.
+      let convAmt = 0;
+      if (convergeId.current) {
+        convergeProgress.current = Math.min(1, convergeProgress.current + dt / 240);
+        convAmt = 1 - Math.pow(1 - convergeProgress.current, 2);
+      }
+      // Energy Saver freezes the idle auto-spin: a static scene re-projects to
+      // identical positions, so the per-frame trig stops mattering. Drag/hover
+      // still work (they mutate rotY/convergeId directly).
+      if (!dragging.current && !energySaverActive()) rotY.current += AUTO_SPIN;
+      const rx = rotX.current;
+      const ry = rotY.current;
+      const scene = sceneRef.current;
+      // The scene stays untransformed and only anchors the cloud's center. We
+      // project every node to 2D ourselves (below) instead of handing the scene
+      // a rotate/translateZ and letting the browser project it: this WebKitGTK
+      // build doesn't reliably honor nested `preserve-3d`, so each node's Z was
+      // dropped and the sphere collapsed to a flat disc (WebView2 honored it, so
+      // Windows looked correct).
+      if (scene) scene.style.transform = "none";
+      // Scene rotation Rx·Ry (matching the original CSS transform order). We
+      // rotate each point here and project it with a manual perspective divide
+      // so the result is identical on every webview.
+      const rxr = (rx * Math.PI) / 180;
+      const ryr = (ry * Math.PI) / 180;
+      const cx = Math.cos(rxr);
+      const sx = Math.sin(rxr);
+      const cy = Math.cos(ryr);
+      const sy = Math.sin(ryr);
+      const radius = radiusRef.current || 1;
+      const dz = dolly.current; // zoom, applied as a Z offset before projection
+      const hoverId = hoverIdRef.current;
+      for (const [id, el] of nodeEls.current.entries()) {
+        // Per-node radius/opacity factors. Default = the bloom intro; during a
+        // converge the chosen node is pulled to center (the rest fade + drift).
+        let nodeGrow = grow;
+        let nodeFade = fadeIn;
+        if (convergeId.current) {
+          if (id === convergeId.current) {
+            nodeGrow = 1 - convAmt;
+            nodeFade = 1;
+          } else {
+            nodeGrow = 1 + convAmt * 0.5;
+            nodeFade = 1 - convAmt;
+          }
+        }
+        // Scale by the factor so nodes fly out from / into the center; the
+        // focused project sits at the origin and so stays put while files spread.
+        const x = (Number(el.dataset.x) || 0) * nodeGrow;
+        const y = (Number(el.dataset.y) || 0) * nodeGrow;
+        const z = (Number(el.dataset.z) || 0) * nodeGrow;
+        // Apply Ry then Rx to the point. worldZ grows toward the viewer.
+        const x1 = x * cy + z * sy;
+        const z1 = -x * sy + z * cy;
+        const screenY = y * cx - z1 * sx;
+        const worldZ = y * sx + z1 * cx;
+        // Perspective divide: nearer nodes (high worldZ) magnify and spread out,
+        // farther ones shrink toward the center — the cue that turns a flat ring
+        // of cards into a readable sphere. `denom` shrinks as the camera dollies
+        // toward a node; once it reaches the near plane the node is at/behind the
+        // camera (we've flown past it), so hide it and let clicks fall through.
+        const denom = PERSPECTIVE - (worldZ + dz);
+        if (denom <= NEAR_PLANE) {
+          el.style.opacity = "0";
+          el.style.pointerEvents = "none";
+          el.style.zIndex = "-1";
+          continue;
+        }
+        const f = PERSPECTIVE / denom;
+        const tx = x1 * f;
+        const ty = screenY * f;
+        // Depth-shade opacity (0 far … 1 near) on top of the size foreshortening;
+        // zIndex keeps front cards above back ones.
+        const t = Math.max(0, Math.min(1, (worldZ / radius + 1) / 2));
+        // Dissolve the node over the near runway so flying through it fades out
+        // smoothly instead of popping at full (huge) scale.
+        const nearFade = Math.min(1, (denom - NEAR_PLANE) / NEAR_FADE);
+        el.style.pointerEvents = "";
+        el.style.transform = `translate(${tx.toFixed(1)}px, ${ty.toFixed(1)}px) scale(${f.toFixed(3)})`;
+        el.style.opacity = ((0.28 + t * 0.72) * nodeFade * nearFade).toFixed(3);
+        el.style.zIndex = String(Math.round(worldZ));
+        // Pin the hover card just off the node so it tracks the spin. The scene
+        // is anchored at the viewport center, so the node's screen point is that
+        // center plus its projected offset.
+        if (id === hoverId && hoverCardRef.current && viewportRef.current) {
+          const vp = viewportRef.current.getBoundingClientRect();
+          const card = hoverCardRef.current;
+          const cw = card.offsetWidth;
+          const ch = card.offsetHeight;
+          const px = vp.left + vp.width / 2 + tx + 70 * f + 14;
+          const py = vp.top + vp.height / 2 + ty - 14;
+          card.style.left = `${Math.min(Math.max(8, px), window.innerWidth - cw - 8)}px`;
+          card.style.top = `${Math.min(Math.max(8, py), window.innerHeight - ch - 8)}px`;
+        }
+      }
+      // Converge landed: commit the focus. The layout-key effect then resets the
+      // bloom so the focused project's files fly out from the center.
+      if (convergeId.current && convergeProgress.current >= 1) {
+        const pf = pendingFocus.current;
+        convergeId.current = null;
+        pendingFocus.current = null;
+        dolly.current = 0;
+        setFocus(pf);
+      }
+      raf = requestAnimationFrame(frame);
+    };
+    raf = requestAnimationFrame(frame);
+    return () => cancelAnimationFrame(raf);
+  }, []);
+
+  // Pointer-drag to orbit. Movement beyond a small threshold marks the gesture a
+  // drag (so the pointerup isn't treated as a node click).
+  const onPointerDown = useCallback((e: React.PointerEvent) => {
+    if (e.button !== 0) return;
+    if (viewModeRef.current === "pie") return; // pie is a flat chart — no orbit
+
+    const startX = e.clientX;
+    const startY = e.clientY;
+    const baseRotX = rotX.current;
+    const baseRotY = rotY.current;
+    const target = e.currentTarget as HTMLElement;
+    const pointerId = e.pointerId;
+    // Fresh gesture: clear any stale suppression so a press that turns out to be
+    // a plain click always reaches the node handlers.
+    suppressClick.current = false;
+    let moved = false;
+    let captured = false;
+
+    const onMove = (ev: PointerEvent) => {
+      const dx = ev.clientX - startX;
+      const dy = ev.clientY - startY;
+      // Only treat this as an orbit drag once the pointer clears the threshold.
+      // Capturing the pointer eagerly on press makes WebKitGTK route the
+      // pointerup to the viewport, so the node never receives its click and both
+      // single- and double-click die. Capturing lazily keeps a stationary click
+      // a normal click.
+      if (!moved) {
+        if (Math.hypot(dx, dy) <= 4) return;
+        moved = true;
+        dragging.current = true;
+        suppressClick.current = true;
+        setHover(null);
+        captured = true;
+        target.setPointerCapture?.(pointerId);
+      }
+      rotY.current = baseRotY + dx * ROT_SENSITIVITY;
+      // Clamp vertical orbit so the cloud never flips fully upside-down.
+      rotX.current = Math.max(-85, Math.min(85, baseRotX - dy * ROT_SENSITIVITY));
+    };
+    const onUp = (ev: PointerEvent) => {
+      dragging.current = false;
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+      if (captured) target.releasePointerCapture?.(ev.pointerId);
+      // suppressClick stays set for the click the browser fires on this
+      // pointerup (if any); the next pointerdown resets it, so it never leaks.
+    };
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+  }, []);
+
+  const onWheel = useCallback((e: React.WheelEvent) => {
+    dolly.current = Math.max(MIN_DOLLY, Math.min(MAX_DOLLY, dolly.current - e.deltaY * 0.6));
+  }, []);
+
+  const clearClickTimer = useCallback(() => {
+    if (clickTimer.current !== null) {
+      window.clearTimeout(clickTimer.current);
+      clickTimer.current = null;
+    }
+  }, []);
+
+  // Focus a project: pin it at center and open the spherical file viewer at its
+  // root. Resets the zoom so the new shell is framed.
+  const enterFocus = useCallback((project: ProjectEntry) => {
+    const dir = resolveProjectDirectory(project);
+    if (!dir) return;
+    setHover(null);
+    // Phase 1: the clicked project flies to center while the rest of the cloud
+    // fades; the rAF loop commits the focus when the converge lands.
+    pendingFocus.current = { project, dir, rel: "" };
+    convergeProgress.current = 0;
+    convergeId.current = `p:${project.id}`;
+  }, []);
+
+  // Jump straight to a directory (breadcrumb click); "" is the project root.
+  const jumpTo = useCallback((rel: string) => {
+    setHover(null);
+    setFocus((f) => (f ? { ...f, rel } : f));
+  }, []);
+
+  // Leave the file viewer entirely, back to the project cloud.
+  const exitToCloud = useCallback(() => {
+    setHover(null);
+    dolly.current = 0;
+    setFocus(null);
+  }, []);
+
+  // Switch the cloud visualization. Leaving for the pie drops any open file
+  // viewer (pie is a project-only view) and clears the hover card.
+  const selectView = useCallback((mode: "sphere" | "pie") => {
+    setHover(null);
+    if (mode === "pie") {
+      dolly.current = 0;
+      setFocus(null);
+    }
+    setViewMode(mode);
+  }, []);
+
+  // Go up one level in the file viewer; exit to the project cloud from the root.
+  const ascend = useCallback(() => {
+    setHover(null);
+    setFocus((f) => {
+      if (!f) return null;
+      if (f.rel === "") {
+        dolly.current = 0;
+        return null;
+      }
+      const parent = f.rel.includes("/") ? f.rel.slice(0, f.rel.lastIndexOf("/")) : "";
+      return { ...f, rel: parent };
+    });
+  }, []);
+
+  // Open = make a project the current scope (switches view) / open a box.
+  const openNode = useCallback(
+    (node: BlobNode) => {
+      if (node.kind === "project" || node.kind === "center") void setActive(node.project.id);
+      else if (node.kind === "box") void openBox(node.box.id);
+    },
+    [setActive, openBox],
+  );
+
+  // Single click. In the cloud a project focuses (deferred so a double-click can
+  // promote it to "open scope"); a box opens. In the file viewer a folder
+  // descends, a file opens, and the center steps back up.
+  const onNodeClick = useCallback(
+    (node: BlobNode) => {
+      // Swallow the click the browser fires at the end of an orbit drag so the
+      // node the pointer happened to release over isn't activated.
+      if (suppressClick.current) {
+        suppressClick.current = false;
+        return;
+      }
+      clearClickTimer();
+      if (node.kind === "center") {
+        ascend();
+        return;
+      }
+      if (node.kind === "file") {
+        if (node.entry.is_dir) {
+          setHover(null);
+          setFocus((f) => (f ? { ...f, rel: f.rel ? `${f.rel}/${node.entry.name}` : node.entry.name } : f));
+        } else {
+          void openFile(node.entry.path, undefined, focus?.project.id ?? null, "blob_file_viewer");
+        }
+        return;
+      }
+      if (node.kind === "box") {
+        openNode(node);
+        return;
+      }
+      const { project } = node;
+      clickTimer.current = window.setTimeout(() => {
+        clickTimer.current = null;
+        enterFocus(project);
+      }, DBL_CLICK_MS);
+    },
+    [clearClickTimer, ascend, openFile, focus, openNode, enterFocus],
+  );
+
+  const onNodeDoubleClick = useCallback(
+    (node: BlobNode) => {
+      clearClickTimer();
+      if (node.kind === "project" || node.kind === "box" || node.kind === "center") openNode(node);
+    },
+    [openNode, clearClickTimer],
+  );
+
+  const onNodeContextMenu = useCallback(
+    (e: React.MouseEvent, node: BlobNode) => {
+      const project = node.kind === "project" || node.kind === "center" ? node.project : null;
+      if (!project) return;
+      e.preventDefault();
+      e.stopPropagation();
+      clearClickTimer();
+      setHover(null);
+      setMenu({ x: e.clientX, y: e.clientY, project });
+    },
+    [clearClickTimer],
+  );
+
+  // Dismiss the context menu on any outside pointer (incl. an orbit drag start).
+  useEffect(() => {
+    if (!menu) return;
+    const dismiss = () => setMenu(null);
+    window.addEventListener("pointerdown", dismiss);
+    return () => window.removeEventListener("pointerdown", dismiss);
+  }, [menu]);
+
+  // Esc steps back up / exits the file viewer.
+  useEffect(() => {
+    if (!focus) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") ascend();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [focus, ascend]);
+
+  // Drop the pending single-click timer if the pane unmounts.
+  useEffect(() => () => clearClickTimer(), [clearClickTimer]);
+
+  const isPie = viewMode === "pie" && !focus;
+
+  if (nodes.length === 0 && !focus) {
+    return (
+      <div className="blob-viewport blob-empty">
+        <div className="blob-empty-card">{t("blob.noProjectsYet")}</div>
+      </div>
+    );
+  }
+
+  return (
+    <div
+      ref={viewportRef}
+      className={`blob-viewport${isPie ? " blob-viewport-pie" : ""}`}
+      onPointerDown={onPointerDown}
+      onWheel={onWheel}
+    >
+      {focus && (
+        <div className="blob-breadcrumb" onPointerDown={(e) => e.stopPropagation()}>
+          <button className="blob-crumb blob-crumb-exit" title={t("blob.backToProjects")} onClick={exitToCloud}>
+            ✕
+          </button>
+          <button className="blob-crumb" onClick={() => jumpTo("")}>
+            {focus.project.name}
+          </button>
+          {focus.rel
+            ? focus.rel.split("/").map((seg, idx, arr) => (
+                <Fragment key={idx}>
+                  <span className="blob-crumb-sep">/</span>
+                  <button className="blob-crumb" onClick={() => jumpTo(arr.slice(0, idx + 1).join("/"))}>
+                    {seg}
+                  </button>
+                </Fragment>
+              ))
+            : null}
+          {entriesLoading && <span className="blob-crumb-loading">{t("blob.loadingLower")}</span>}
+        </div>
+      )}
+      {!focus && (
+        <div className="blob-view-toggle" onPointerDown={(e) => e.stopPropagation()}>
+          <button
+            className={viewMode === "sphere" ? "is-active" : ""}
+            onClick={() => selectView("sphere")}
+            title={t("blob.sphereViewTitle")}
+          >
+            {t("blob.sphereView")}
+          </button>
+          <button
+            className={viewMode === "pie" ? "is-active" : ""}
+            onClick={() => selectView("pie")}
+            title={t("blob.pieViewTitle")}
+          >
+            {t("blob.pieView")}
+          </button>
+        </div>
+      )}
+      <div className="blob-hint">
+        {focus
+          ? t("blob.hintFocused")
+          : isPie
+            ? t("blob.hintPie")
+            : t("blob.hintCloud")}
+      </div>
+      {isPie ? (
+        pieSlices.length === 0 ? (
+          <div className="blob-pie-empty">{t("blob.noProjectsToChart")}</div>
+        ) : (
+          <div className="blob-pie-stage">
+            <svg className="blob-pie-svg" viewBox="0 0 320 320" preserveAspectRatio="xMidYMid meet">
+              {pieSlices.map((sl) => {
+                const node: BlobNode = { id: `p:${sl.project.id}`, kind: "project", project: sl.project };
+                const isAct = sl.project.id === activeId;
+                const mid = (sl.a0 + sl.a1) / 2;
+                const [lx, ly] = polar(160, 160, 116, mid);
+                return (
+                  <g key={sl.project.id} className={`blob-pie-slice${isAct ? " is-active" : ""}`}>
+                    <path
+                      d={donutSlicePath(160, 160, 150, 78, sl.a0, sl.a1)}
+                      fill={sl.color}
+                      fillRule={sl.single ? "evenodd" : "nonzero"}
+                      onPointerEnter={(e) => setHover({ x: e.clientX, y: e.clientY, node })}
+                      onPointerLeave={() => setHover((h) => (h?.node.id === node.id ? null : h))}
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        void setActive(sl.project.id);
+                      }}
+                      onContextMenu={(e) => onNodeContextMenu(e, node)}
+                    />
+                    {sl.frac > 0.055 && (
+                      <text
+                        className="blob-pie-label"
+                        x={lx}
+                        y={ly}
+                        textAnchor="middle"
+                        dominantBaseline="middle"
+                      >
+                        {sl.project.name}
+                      </text>
+                    )}
+                  </g>
+                );
+              })}
+              <text className="blob-pie-center" x="160" y="153" textAnchor="middle">
+                {t(projects.length === 1 ? "blob.projectCountOne" : "blob.projectCountMany", { count: projects.length })}
+              </text>
+              <text className="blob-pie-center-sub" x="160" y="173" textAnchor="middle">
+                {fmtWorked(pieSlices.reduce((a, s) => a + s.secs, 0))}
+              </text>
+            </svg>
+          </div>
+        )
+      ) : (
+      <div className="blob-stage">
+        <div ref={sceneRef} className="blob-scene">
+          {nodes.map((node, i) => {
+            const pos = positions[i] ?? { x: 0, y: 0, z: 0 };
+            const base = `translate3d(${pos.x.toFixed(1)}px, ${pos.y.toFixed(1)}px, ${pos.z.toFixed(1)}px)`;
+
+            let cls = "blob-node";
+            let icon = "●";
+            let label = "";
+            let sub: number | null = null;
+            let isActive = false;
+            let catColor: string | null = null;
+            if (node.kind === "project") {
+              const status = node.project.status;
+              cls += ` blob-node-project blob-status-${status}`;
+              icon = status === "inactive" ? "○" : "●";
+              label = node.project.name;
+              isActive = node.project.id === activeId;
+              catColor = primaryCategoryColor(projectCategories(node.project));
+              if (catColor) cls += " blob-node-categorized";
+            } else if (node.kind === "box") {
+              cls += " blob-node-box blob-status-box";
+              icon = "▦";
+              label = node.box.name;
+              sub = node.box.member_ids.length;
+            } else if (node.kind === "center") {
+              cls += " blob-node-center";
+              icon = node.rel === "" ? "◉" : "↑";
+              label = node.label;
+            } else {
+              cls += node.entry.is_dir ? " blob-node-file blob-file-dir" : " blob-node-file blob-file-doc";
+              icon = node.entry.is_dir ? folderIcon() : fileIcon(node.entry.extension ?? null);
+              label = node.entry.name;
+            }
+            if (isActive) cls += " blob-node-active";
+
+            return (
+              <div
+                key={node.id}
+                ref={registerNode(node.id)}
+                data-x={pos.x.toFixed(1)}
+                data-y={pos.y.toFixed(1)}
+                data-z={pos.z.toFixed(1)}
+                style={
+                  catColor
+                    ? ({ transform: base, "--cat-color": catColor } as React.CSSProperties)
+                    : { transform: base }
+                }
+                className={cls}
+                onPointerEnter={(e) => setHover({ x: e.clientX, y: e.clientY, node })}
+                onPointerLeave={() => setHover((h) => (h?.node.id === node.id ? null : h))}
+                onClick={(e) => {
+                  e.stopPropagation();
+                  onNodeClick(node);
+                }}
+                onDoubleClick={(e) => {
+                  e.stopPropagation();
+                  onNodeDoubleClick(node);
+                }}
+                onContextMenu={(e) => onNodeContextMenu(e, node)}
+              >
+                <span className="blob-node-icon" aria-hidden>
+                  {icon}
+                </span>
+                <span className="blob-node-label">{label}</span>
+                {sub !== null && <span className="blob-node-sub">{sub}</span>}
+              </div>
+            );
+          })}
+        </div>
+      </div>
+      )}
+
+      {/* Category-tag editor (opened from a project node's right-click menu). */}
+      {catProject && (
+        <CategoryEditor project={catProject} onClose={() => setCatProject(null)} />
+      )}
+
+      {/* Right-click menu for a project node. */}
+      {menu && createPortal(
+        <div
+          className="context-menu blob-context-menu"
+          style={{ left: menu.x, top: menu.y }}
+          onPointerDown={(e) => e.stopPropagation()}
+        >
+          <button
+            onClick={() => {
+              setMenu(null);
+              void setActive(menu.project.id);
+            }}
+          >
+            {t("blob.open")}
+          </button>
+          <button
+            onClick={() => {
+              const p = menu.project;
+              setMenu(null);
+              setCatProject(p);
+            }}
+          >
+            {t("blob.categoriesEllipsis")}
+          </button>
+          {menu.project.status === "inactive" ? (
+            <button
+              onClick={() => {
+                setMenu(null);
+                void activateProject(menu.project.id);
+              }}
+            >
+              {t("blob.activate")}
+            </button>
+          ) : (
+            <button
+              onClick={() => {
+                setMenu(null);
+                void deactivateProject(menu.project.id);
+              }}
+            >
+              {t("blob.inactivate")}
+            </button>
+          )}
+        </div>,
+        document.body,
+      )}
+
+      {/* Hover info card, anchored to the node (pinned each frame by the rAF
+          loop). Suppressed while the context menu is open. */}
+      {hover && !menu && createPortal(
+        <div
+          ref={hoverCardRef}
+          className="blob-hover-card"
+          style={{
+            left: Math.min(hover.x + 16, window.innerWidth - 320),
+            top: Math.min(hover.y + 16, window.innerHeight - 200),
+          }}
+        >
+          {(hover.node.kind === "project" || hover.node.kind === "center") && (
+            <>
+              <div className="blob-hover-title">{hover.node.project.name}</div>
+              <div className="blob-hover-meta">
+                {hover.node.kind === "center"
+                  ? hover.node.rel
+                    ? `/${hover.node.rel}`
+                    : t("blob.projectRoot")
+                  : `${hover.node.project.status} · ${fmtWorked(totals[hover.node.project.id])}`}
+              </div>
+              {hover.node.kind === "project" && (
+                <div className="blob-hover-desc">
+                  {hover.node.project.description?.trim() || t("blob.noDescriptionYet")}
+                </div>
+              )}
+              {hover.node.kind === "project" && projectCategories(hover.node.project).length > 0 && (
+                <div className="blob-hover-categories">
+                  {projectCategories(hover.node.project).map((cat) => (
+                    <span
+                      key={cat.toLowerCase()}
+                      className="blob-hover-category"
+                      style={{ "--cat-color": categoryColor(cat) } as React.CSSProperties}
+                    >
+                      <span className="blob-hover-category-dot" />
+                      {cat}
+                    </span>
+                  ))}
+                </div>
+              )}
+              {activity[hover.node.project.id] && (
+                <div className="blob-hover-activity">
+                  <ActivityCalendar data={activity[hover.node.project.id]} />
+                </div>
+              )}
+              <div className="blob-hover-hint">
+                {hover.node.kind === "center"
+                  ? t("blob.hintCenterUp")
+                  : t("blob.hintExploreOpen")}
+              </div>
+            </>
+          )}
+          {hover.node.kind === "box" && (
+            <>
+              <div className="blob-hover-title">{hover.node.box.name}</div>
+              <div className="blob-hover-meta">
+                {t(
+                  hover.node.box.member_ids.length === 1 ? "blob.boxMetaOne" : "blob.boxMetaMany",
+                  { count: hover.node.box.member_ids.length },
+                )}
+              </div>
+              <div className="blob-hover-hint">{t("blob.doubleClickToOpen")}</div>
+            </>
+          )}
+          {hover.node.kind === "file" && (
+            <>
+              <div className="blob-hover-title">{hover.node.entry.name}</div>
+              <div className="blob-hover-meta">
+                {hover.node.entry.is_dir
+                  ? t("blob.folder")
+                  : `${
+                      hover.node.entry.extension
+                        ? t("blob.extFile", { ext: hover.node.entry.extension.replace(/^\./, "").toUpperCase() })
+                        : t("blob.file")
+                    } · ${fmtSize(hover.node.entry.size)}`}
+              </div>
+              <div className="blob-hover-hint">
+                {hover.node.entry.is_dir ? t("blob.clickToEnterFolder") : t("blob.clickToOpen")} ·{" "}
+                {fmtModified(hover.node.entry.modified_secs)}
+              </div>
+            </>
+          )}
+        </div>,
+        document.body,
+      )}
+    </div>
+  );
+}
diff --git a/src/components/common/RemoteUsageWarningDialog.tsx b/src/components/common/RemoteUsageWarningDialog.tsx
new file mode 100644
index 0000000..503f91f
--- /dev/null
+++ b/src/components/common/RemoteUsageWarningDialog.tsx
@@ -0,0 +1,527 @@
+import { useEffect, useMemo, useState, type ReactNode } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { useProjectsStore } from "../../stores/projects";
+import { useGlobalMachinesStore } from "../../stores/globalMachines";
+import {
+  machineKey,
+  projectHostKey,
+  useRemoteUsageStore,
+  type RemoteUsageReport,
+  type UsageTarget,
+} from "../../stores/remoteUsage";
+import { hostsForProject } from "../../lib/remoteHosts";
+import { sameTarget } from "../../lib/machineSync";
+import { PRIMARY_HOST, sshOf, useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useSettingsStore } from "../../stores/settings";
+import { isHpcHost } from "../../lib/hpcHost";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+/**
+ * Host usage — CPU/load, memory, GPU, logged-in sessions and top processes (see
+ * `services::remote_usage` for the probe). It is **not** a verdict:
+ * `report.busy`/`report.reasons` are surfaced as extra context (a "may be in
+ * use" hint) but never gate anything. Note the one known false positive the hint
+ * carries: an Eldrun terminal tab already open to the same host shows up in
+ * `who` exactly like a human login.
+ *
+ * **On demand only.** It used to pop up by itself after every connect, which
+ * put a modal in front of a user who had just asked for something else. Now the
+ * *only* thing that opens it is the header Machines menu's "Remote host usage…"
+ * button (`useRemoteUsageStore.open`), and opening it rechecks every host it may
+ * so what's on screen is current rather than however stale the last connect's
+ * report had become.
+ *
+ * **"Every host it may" is the whole of the second gate.** Each probe is real
+ * work on the machine — a global machine's is a fresh SSH login, a project
+ * host's opens the pool — so a dialog that swept the entire list dialled every
+ * machine anyone had ever added, every time it was opened. The sweep now covers
+ * only hosts with a session actually open, and **never** a host tagged HPC
+ * whatever its lamp says. Everything else renders from cache and carries its own
+ * read button: that press is a gesture, which is the one thing a tagged cluster
+ * login node answers to (and the only caller that may say `background: false`).
+ *
+ * **Its subject is the machine list, not a project.** It opens from the Machines
+ * menu, so it shows a section for **every global machine, in that menu's exact
+ * order** (`stores/globalMachines`), then the active project's own hosts — the
+ * primary and any `compute_hosts` worker — that aren't already in the list. The
+ * two are matched by SSH target (`lib/machineSync`'s `sameTarget`), never by id:
+ * dropping a machine onto a project copies it by value, so `user@host:port` is
+ * the only bridge, and without that dedupe one machine would appear twice.
+ *
+ * Mounted once at the shell, like `LocalLossDialog`. Advisory, not a record of
+ * something already destroyed, so a backdrop click closes it same as any
+ * ordinary modal.
+ *
+ * The connect-time probe still runs (the backend emits a `remote-usage-report`
+ * event per project host after `remote_connect`) and this still listens for it
+ * globally, so a just-connected project's report is already cached when the
+ * button is pressed — but receiving one no longer shows anything.
+ */
+
+interface UsageReportEvent {
+  projectId: string;
+  hostId: string;
+  report: RemoteUsageReport;
+}
+
+function fmtPct(used: number, total: number): string {
+  if (total <= 0) return "?";
+  return `${Math.round((used / total) * 100)}%`;
+}
+
+/**
+ * Traffic-light tone for a CPU/GPU utilization percentage: green when the host
+ * is effectively idle (≤5%), orange up to 40%, red above — so a glance at the
+ * connect report says whether the machine is free to work on.
+ */
+type UsageTone = "green" | "orange" | "red";
+function usageTone(pct: number): UsageTone {
+  if (pct <= 5) return "green";
+  if (pct <= 40) return "orange";
+  return "red";
+}
+
+interface UserGroup {
+  user: string;
+  sessions: RemoteUsageReport["users"];
+  /** Sum of this user's `ps` `%CPU`/`%MEM` across the top-processes sample — a
+   *  login count says nothing about load (one idle `bash` vs. one `python`
+   *  pinning a core both read as "1 session"), so this is compute, not session
+   *  share. */
+  cpuPct: number;
+  memPct: number;
+}
+
+/** Collapse `who`'s per-session rows into one row per user, each carrying its
+ *  summed CPU%/MEM% from `report.topProcs` instead of a session tally. Sorted
+ *  by CPU%, busiest first — the point of the panel is spotting who's loading
+ *  the host, not roll-call order. Only the top-N processes are sampled (same
+ *  data the "Top processes" section shows), so a user's true total can be
+ *  higher than what's attributed here if their load falls outside that
+ *  sample. */
+function groupSessionsByUser(report: RemoteUsageReport): UserGroup[] {
+  const order: string[] = [];
+  const byUser = new Map<string, RemoteUsageReport["users"]>();
+  for (const s of report.users) {
+    if (!byUser.has(s.user)) {
+      order.push(s.user);
+      byUser.set(s.user, []);
+    }
+    byUser.get(s.user)!.push(s);
+  }
+  const cpuByUser = new Map<string, number>();
+  const memByUser = new Map<string, number>();
+  for (const p of report.topProcs) {
+    cpuByUser.set(p.user, (cpuByUser.get(p.user) ?? 0) + p.cpuPct);
+    memByUser.set(p.user, (memByUser.get(p.user) ?? 0) + p.memPct);
+  }
+  return order
+    .map((user) => ({
+      user,
+      sessions: byUser.get(user)!,
+      cpuPct: cpuByUser.get(user) ?? 0,
+      memPct: memByUser.get(user) ?? 0,
+    }))
+    .sort((a, b) => b.cpuPct - a.cpuPct);
+}
+
+const TONE_KEY: Record<UsageTone, TranslationKey> = {
+  green: "usage.toneGreen",
+  orange: "usage.toneOrange",
+  red: "usage.toneRed",
+};
+
+function UsageLight({ pct }: { pct: number }) {
+  const t = useT();
+  const tone = usageTone(pct);
+  return (
+    <span
+      className={`remote-usage-light is-${tone}`}
+      aria-label={t("usage.utilizationAria", { tone: t(TONE_KEY[tone]) })}
+    />
+  );
+}
+
+/** One host's usage: reasons, CPU/load/memory/GPU stats, the per-user "Logged
+ *  in" table, and top processes — repeated per connected host in the combined
+ *  dialog (it used to be the dialog's whole body, back when only the primary
+ *  was ever probed). */
+function HostUsageSection({
+  label,
+  report,
+  action,
+}: {
+  label: string;
+  report: RemoteUsageReport;
+  /** The row's own "read it now" control, for a host the automatic sweep skips
+   *  (see [`RemoteUsageWarningDialog`]). Absent for a host the sweep covers. */
+  action?: ReactNode;
+}) {
+  const t = useT();
+  return (
+    <div className="remote-usage-host">
+      <div className="remote-usage-host-title">
+        {label}
+        {action}
+      </div>
+      {/* Said before the numbers, because on a cluster the short session list and
+          own-processes-only table are a deliberate limit, not a quiet machine. */}
+      {report.careful && <div className="remote-usage-careful">{t("usage.carefulNote")}</div>}
+      {report.reasons.length > 0 && (
+        <ul className="remote-usage-reasons">
+          {report.reasons.map((r) => (
+            <li key={r}>{r}</li>
+          ))}
+        </ul>
+      )}
+      <div className="remote-usage-stats">
+        <div className="remote-usage-stat">
+          <span className="remote-usage-stat-label">{t("usage.cpu")}</span>
+          <span className="remote-usage-stat-value">
+            <UsageLight pct={report.cpuPct} />
+            {report.cpuPct.toFixed(0)}%{" "}
+            <span className="remote-usage-stat-sub">
+              {t(report.cpuCount === 1 ? "usage.coresOne" : "usage.coresMany", { count: report.cpuCount })}
+            </span>
+          </span>
+        </div>
+        <div className="remote-usage-stat">
+          <span className="remote-usage-stat-label">{t("usage.loadAverage")}</span>
+          <span className="remote-usage-stat-value">
+            {report.load1.toFixed(2)}, {report.load5.toFixed(2)}, {report.load15.toFixed(2)}
+          </span>
+        </div>
+        <div className="remote-usage-stat">
+          <span className="remote-usage-stat-label">{t("usage.memory")}</span>
+          <span className="remote-usage-stat-value">
+            {report.memUsedMb} / {report.memTotalMb} MB{" "}
+            <span className="remote-usage-stat-sub">
+              ({fmtPct(report.memUsedMb, report.memTotalMb)})
+            </span>
+          </span>
+        </div>
+        {report.gpus.map((g, i) => (
+          <div className="remote-usage-stat" key={`${g.name}-${i}`}>
+            <span className="remote-usage-stat-label">GPU{report.gpus.length > 1 ? ` ${i}` : ""}</span>
+            <span className="remote-usage-stat-value">
+              <UsageLight pct={g.utilPct} />
+              {g.utilPct.toFixed(0)}%{" "}
+              <span className="remote-usage-stat-sub">
+                ({g.memUsedMb} / {g.memTotalMb} MB · {g.name})
+              </span>
+            </span>
+          </div>
+        ))}
+      </div>
+      {/* Shown for **every** host, even with no sessions: `who` on a host reached
+          only over the pooled (non-PTY) master has no utmp entry of its own, so a
+          compute node with no interactive login is legitimately empty. The empty
+          note makes that explicit rather than dropping the section, which read as
+          "only the primary host reports logins". */}
+      <div className="remote-usage-section">
+        <div className="remote-usage-section-title">
+          {t("usage.loggedIn")}{" "}
+          <span className="remote-usage-stat-sub">
+            {t(report.users.length === 1 ? "usage.sessionsOne" : "usage.sessionsMany", { count: report.users.length })}
+          </span>
+        </div>
+        {report.users.length > 0 ? (
+          <ul className="remote-usage-users">
+            <li className="remote-usage-users-head" aria-hidden="true">
+              <span>{t("usage.userCol")}</span>
+              <span>{t("usage.cpu")}</span>
+              <span>{t("usage.sessionsCol")}</span>
+              <span>{t("usage.memCol")}</span>
+            </li>
+            {groupSessionsByUser(report).map((g) => (
+              <li key={g.user}>
+                <span className="remote-usage-user">{g.user}</span>
+                <span className="remote-usage-user-cpu">
+                  <UsageLight pct={g.cpuPct} />
+                  {g.cpuPct.toFixed(0)}%
+                </span>
+                <span className="remote-usage-user-sessions">{g.sessions.length}</span>
+                <span className="remote-usage-user-mem">{g.memPct.toFixed(0)}%</span>
+              </li>
+            ))}
+          </ul>
+        ) : (
+          <div className="remote-usage-empty">{t("usage.noInteractiveLogins")}</div>
+        )}
+      </div>
+      {report.topProcs.length > 0 && (
+        <div className="remote-usage-section">
+          <div className="remote-usage-section-title">{t("usage.topProcesses")}</div>
+          <ul className="remote-usage-procs">
+            {report.topProcs.map((p, i) => (
+              <li key={`${p.pid}-${i}`}>
+                <span className="remote-usage-proc-cmd">{p.command}</span>
+                <span className="remote-usage-proc-user">{p.user}</span>
+                <span className="remote-usage-proc-pct">{p.cpuPct.toFixed(1)}% {t("usage.cpuSuffix")}</span>
+                <span className="remote-usage-proc-pct">{p.memPct.toFixed(1)}% {t("usage.memSuffix")}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+    </div>
+  );
+}
+
+/** One section of the dialog: the host it reads, plus the two facts that decide
+ *  whether it may be read *unasked* — is a session open on it, and is it tagged. */
+interface UsageRow {
+  target: UsageTarget;
+  /** A session this app opened (a machine's lamp / the project host's pool). */
+  connected: boolean;
+  /** Tagged as a shared cluster login node (`lib/hpcHost.ts`). */
+  hpc: boolean;
+  /** Whether the open-the-dialog sweep may read it. */
+  autoRead: boolean;
+}
+
+export function RemoteUsageWarningDialog() {
+  const t = useT();
+  const activeId = useProjectsStore((s) => s.activeId);
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === activeId));
+  const machines = useGlobalMachinesStore((s) => s.machines);
+  const machineStatus = useGlobalMachinesStore((s) => s.status);
+  const byProject = useRemoteStatusStore((s) => s.byProject);
+  const byHost = useRemoteStatusStore((s) => s.byHost);
+  const settings = useSettingsStore((s) => s.settings);
+  const setReport = useRemoteUsageStore((s) => s.setReport);
+  const close = useRemoteUsageStore((s) => s.close);
+  const recheck = useRemoteUsageStore((s) => s.recheck);
+  const reports = useRemoteUsageStore((s) => s.reports);
+  const isOpen = useRemoteUsageStore((s) => s.isOpen);
+  const [rechecking, setRechecking] = useState(false);
+  /** Per-row in-flight state for the explicit reads (the sweep has `rechecking`). */
+  const [reading, setReading] = useState<Record<string, boolean>>({});
+
+  useEffect(() => {
+    let cancelled = false;
+    let unlisten: (() => void) | undefined;
+    void listen<UsageReportEvent>("remote-usage-report", (event) => {
+      setReport(
+        projectHostKey(event.payload.projectId, event.payload.hostId),
+        event.payload.report,
+      );
+    }).then((u) => (cancelled ? u() : (unlisten = u)));
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, [setReport]);
+
+  // Every global machine first, in the Machines menu's own order — this dialog
+  // opens from that menu, so its list must be that list. Then the active
+  // project's own hosts (primary, then `compute_hosts` in project order, the
+  // same order the System Monitor's host picker uses), minus any whose SSH
+  // target is already a machine above: the two lists are related by
+  // `user@host:port` and nothing else, since attaching a machine to a project
+  // copies it by value rather than linking ids.
+  //
+  // Each row also carries what licenses an *unasked* read of it. Both probes
+  // behind `recheck` are real work on the host — `global_machine_usage_check` is
+  // a fresh `run_ssh_auth`, `remote_usage_check` opens the pool — so opening this
+  // dialog used to dial every machine anyone had ever added, connected or not,
+  // tagged or not. Two facts narrow that:
+  //
+  //  * **the lamp** — a machine with no session is not read by the sweep. Its
+  //    section renders from cache with a button, so nothing is lost but the
+  //    login nobody asked for.
+  //  * **the tag** — a shared login node is never in an automatic sweep at all,
+  //    whatever its lamp says. `isHpcHost` on the target, the same key the rest
+  //    of the tag uses, so tagging a machine once covers it here too.
+  const rows = useMemo<UsageRow[]>(() => {
+    const build = (target: UsageTarget, connected: boolean, hpc: boolean): UsageRow => ({
+      target,
+      connected,
+      hpc,
+      autoRead: connected && !hpc,
+    });
+    const list: UsageRow[] = machines.map((m) =>
+      build(
+        {
+          kind: "machine",
+          key: machineKey(m.id),
+          label: m.label || m.host,
+          user: m.user,
+          host: m.host,
+          port: m.port,
+        },
+        machineStatus[m.id] === "connected",
+        isHpcHost(settings, { user: m.user, host: m.host, port: m.port }),
+      ),
+    );
+    if (project?.remote) {
+      const hostLabels = hostsForProject(project);
+      const specs = [
+        { id: PRIMARY_HOST, spec: project.remote },
+        ...(project.compute_hosts ?? []).map((w) => ({ id: w.id, spec: w })),
+      ];
+      for (const { id, spec } of specs) {
+        if (machines.some((m) => sameTarget(m, spec))) continue;
+        const label = hostLabels.find((h) => h.id === id)?.label ?? spec.host;
+        list.push(
+          build(
+            {
+              kind: "projectHost",
+              key: projectHostKey(project.id, id),
+              label: `${label} — ${project.name}`,
+              projectId: project.id,
+              hostId: id,
+            },
+            sshOf({ byProject, byHost }, project.id, id) === "connected",
+            isHpcHost(settings, {
+              user: spec.user || undefined,
+              host: spec.host,
+              port: spec.port ?? undefined,
+            }),
+          ),
+        );
+      }
+    }
+    return list;
+  }, [machines, machineStatus, project, byProject, byHost, settings]);
+
+  // Opening is itself the request for a reading: whatever the last connect left
+  // cached is however old the session is, so every host the sweep may touch is
+  // rechecked as the dialog appears (its sections fill in as the probes land).
+  // The rest keep their cached reading and a button.
+  const sweep = useMemo(() => rows.filter((r) => r.autoRead).map((r) => r.target), [rows]);
+  const sweepKey = sweep.map((r) => r.key).join("|");
+  const runRecheck = useMemo(
+    () => () => {
+      if (sweep.length === 0) return;
+      setRechecking(true);
+      // No `background` flag: this IS the background path, and a command that
+      // gates on one must see it omitted rather than talked out of.
+      void Promise.all(sweep.map((r) => recheck(r))).finally(() => setRechecking(false));
+    },
+    // `sweepKey` stands in for `sweep` (a fresh array each render).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [sweepKey, recheck],
+  );
+  useEffect(() => {
+    if (isOpen) runRecheck();
+  }, [isOpen, runRecheck]);
+
+  /**
+   * Read ONE host because the user pressed its button. Deliberately not
+   * `recheck`: that is the sweep's call and omits `background`, which is what
+   * makes a tagged host refuse it. A press is a gesture, so this one says
+   * `background: false` — the only spelling that reaches a tagged machine, and
+   * one no timer can produce.
+   */
+  const readNow = async (row: UsageRow) => {
+    const key = row.target.key;
+    setReading((m) => ({ ...m, [key]: true }));
+    try {
+      const report =
+        row.target.kind === "machine"
+          ? await invoke<RemoteUsageReport>("global_machine_usage_check", {
+              user: row.target.user,
+              host: row.target.host,
+              port: row.target.port,
+              background: false,
+            })
+          : await invoke<RemoteUsageReport>("remote_usage_check", {
+              projectId: row.target.projectId,
+              hostId: row.target.hostId,
+              background: false,
+            });
+      setReport(key, report);
+    } catch {
+      // Best-effort, exactly as the sweep is: a host that can't be reached keeps
+      // whatever was cached instead of tearing the dialog down.
+    } finally {
+      setReading((m) => ({ ...m, [key]: false }));
+    }
+  };
+
+  /** Why a section has no fresh reading — stated, because "no reading" alone
+   *  reads as a broken probe when it is in fact a machine waiting to be asked. */
+  const rowNote = (row: UsageRow): string => {
+    if (reading[row.target.key] || (rechecking && row.autoRead)) return t("usage.checkingEllipsis");
+    if (row.hpc) return "Not read — tagged HPC, so nothing reads it unasked.";
+    if (!row.connected) return "Not read — no session open on this machine.";
+    return t("usage.noReading");
+  };
+
+  /** The per-row read control, for the hosts the sweep skips. */
+  const rowAction = (row: UsageRow): ReactNode =>
+    row.autoRead ? null : (
+      <>
+        {" "}
+        <button
+          type="button"
+          className="inline-link-btn"
+          onClick={() => void readNow(row)}
+          disabled={!!reading[row.target.key]}
+          title={
+            row.hpc
+              ? "Read this machine once, now. It is tagged HPC, so nothing reads it on its own."
+              : "Read this machine once, now."
+          }
+        >
+          {reading[row.target.key] ? t("usage.checkingEllipsis") : t("usage.recheck")}
+        </button>
+      </>
+    );
+
+  if (!isOpen) return null;
+
+  return (
+    <div className="modal-backdrop" onMouseDown={close}>
+      <div
+        className="project-dialog dialog-framed remote-usage-dialog"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{t("usage.title")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={close}>×</button>
+        </div>
+        <div className="dialog-scroll">
+          <p className="remote-usage-lede">
+            {rows.length === 0
+              ? t("usage.noMachines")
+              : t("usage.lede", {
+                  hosts: rows.length === 1 ? t("usage.hostSingular") : t("usage.hostsPlural", { count: rows.length }),
+                  reading: rechecking ? t("usage.beingReadNow") : t("usage.asLastRead"),
+                })}
+          </p>
+          {rows.map((row) =>
+            reports[row.target.key] ? (
+              <HostUsageSection
+                key={row.target.key}
+                label={row.target.label}
+                report={reports[row.target.key]}
+                action={rowAction(row)}
+              />
+            ) : (
+              <div className="remote-usage-host" key={row.target.key}>
+                <div className="remote-usage-host-title">
+                  {row.target.label}
+                  {rowAction(row)}
+                </div>
+                <div className="remote-usage-empty">{rowNote(row)}</div>
+              </div>
+            ),
+          )}
+          <div className="project-dialog-actions">
+            {/* Rechecks only what the sweep may touch; a skipped host keeps its
+                own button, which is the only thing that reads it. */}
+            <button type="button" onClick={runRecheck} disabled={rechecking || sweep.length === 0}>
+              {rechecking ? t("usage.rechecking") : t("usage.recheck")}
+            </button>
+            <button type="button" onClick={close}>
+              {t("howToStart.gotIt")}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/common/Toggle.tsx b/src/components/common/Toggle.tsx
new file mode 100644
index 0000000..c2bf394
--- /dev/null
+++ b/src/components/common/Toggle.tsx
@@ -0,0 +1,38 @@
+import type { ChangeEventHandler } from "react";
+
+/**
+ * The app's sliding on/off switch — the visual replacement for a bare native
+ * checkbox for boolean settings/options. Renders the `.eld-switch` pill (see
+ * themes.css): a real, focusable checkbox layered transparently over the track,
+ * whose `::after` pseudo is the moving knob. Pass `size="sm"` in compact inline
+ * toolbars / filter rows so the switch doesn't dominate the row.
+ */
+export function Toggle({
+  checked,
+  onChange,
+  disabled,
+  size,
+  title,
+  "aria-label": ariaLabel,
+}: {
+  checked: boolean;
+  onChange: ChangeEventHandler<HTMLInputElement>;
+  disabled?: boolean;
+  size?: "sm";
+  title?: string;
+  "aria-label"?: string;
+}) {
+  return (
+    <span className={`eld-switch${size === "sm" ? " eld-switch-sm" : ""}`}>
+      <input
+        type="checkbox"
+        checked={checked}
+        disabled={disabled}
+        onChange={onChange}
+        title={title}
+        aria-label={ariaLabel}
+      />
+      <span className="eld-switch-track" aria-hidden="true" />
+    </span>
+  );
+}
diff --git a/src/components/common/TourCoachmark.tsx b/src/components/common/TourCoachmark.tsx
new file mode 100644
index 0000000..6eb9b5d
--- /dev/null
+++ b/src/components/common/TourCoachmark.tsx
@@ -0,0 +1,122 @@
+import { createPortal } from "react-dom";
+import type { TourPlacement } from "../../lib/tour";
+import { useT } from "../../lib/i18n";
+
+const BUBBLE_W = 300;
+/** Padding around the spotlight cutout so the highlighted control isn't flush
+ *  against the dim edge. */
+const SPOT_PAD = 8;
+/** Gap between the cutout and the bubble. */
+const GAP = 12;
+
+/** Bubble position for an anchored step, clamped to stay on-screen. The dim is
+ *  produced by the spotlight element's huge box-shadow, so this only places the
+ *  text bubble relative to the (already-padded) target rect. */
+function bubbleStyle(rect: DOMRect, placement: TourPlacement): React.CSSProperties {
+  const vw = window.innerWidth;
+  const clampX = (x: number) => Math.max(8, Math.min(x, vw - BUBBLE_W - 8));
+  switch (placement) {
+    case "top":
+      return { left: clampX(rect.left), top: rect.top - SPOT_PAD - GAP, transform: "translateY(-100%)" };
+    case "left":
+      return { left: Math.max(8, rect.left - SPOT_PAD - GAP), top: rect.top, transform: "translateX(-100%)" };
+    case "right":
+      return { left: clampX(rect.right + SPOT_PAD + GAP), top: rect.top };
+    case "bottom":
+    default:
+      return { left: clampX(rect.left), top: rect.bottom + SPOT_PAD + GAP };
+  }
+}
+
+/**
+ * The guided-tour overlay for a single step: a full-screen click-blocker, a
+ * spotlight cutout around the target (its box-shadow dims everything else), and
+ * a navigation bubble with Back / Next / Skip. Narrated, not interactive — the
+ * blocker swallows clicks so the user advances with Next, never by operating the
+ * real control (which would open dialogs over the coachmark). Portaled to
+ * `document.body` to escape the right panel's transform/overflow stacking, the
+ * same trick `HintBubble` uses. When `rect` is null (target absent / intro), it
+ * renders as a centered card over a plain dim instead.
+ */
+export function TourCoachmark({
+  rect,
+  placement,
+  title,
+  body,
+  stepNumber,
+  stepTotal,
+  isFirst,
+  isLast,
+  onBack,
+  onNext,
+  onSkip,
+}: {
+  rect: DOMRect | null;
+  placement: TourPlacement;
+  title: string;
+  body: string;
+  stepNumber: number;
+  stepTotal: number;
+  isFirst: boolean;
+  isLast: boolean;
+  onBack: () => void;
+  onNext: () => void;
+  onSkip: () => void;
+}) {
+  const t = useT();
+  const banner = !rect;
+  const bubble = rect ? bubbleStyle(rect, placement) : {};
+
+  return createPortal(
+    <div className="tour-overlay">
+      {/* Click-blocker: transparent, captures every pointer event so the tour is
+          can't-get-lost. The spotlight/bubble sit above it and stay live. */}
+      <div
+        className="tour-blocker"
+        onMouseDown={(e) => e.preventDefault()}
+        onContextMenu={(e) => e.preventDefault()}
+      />
+      {rect && (
+        <div
+          className="tour-spotlight"
+          style={{
+            left: rect.left - SPOT_PAD,
+            top: rect.top - SPOT_PAD,
+            width: rect.width + SPOT_PAD * 2,
+            height: rect.height + SPOT_PAD * 2,
+          }}
+        />
+      )}
+      <div
+        className={`tour-bubble${banner ? " tour-bubble--banner" : ""}`}
+        role="dialog"
+        aria-modal="true"
+        aria-label={title}
+        style={{ ...bubble, width: banner ? undefined : BUBBLE_W }}
+      >
+        <div className="tour-bubble-title">{title}</div>
+        <div className="tour-bubble-body">{body}</div>
+        <div className="tour-bubble-footer">
+          <span className="tour-bubble-count">
+            {stepNumber} / {stepTotal}
+          </span>
+          <button type="button" className="tour-bubble-skip" onClick={onSkip}>
+            {t("tour.skip")}
+          </button>
+          <button
+            type="button"
+            className="tour-bubble-back"
+            onClick={onBack}
+            disabled={isFirst}
+          >
+            {t("tour.back")}
+          </button>
+          <button type="button" className="tour-bubble-next" onClick={onNext}>
+            {isLast ? t("tour.done") : t("tour.next")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/common/UntestedTag.tsx b/src/components/common/UntestedTag.tsx
new file mode 100644
index 0000000..3bc7d63
--- /dev/null
+++ b/src/components/common/UntestedTag.tsx
@@ -0,0 +1,23 @@
+/**
+ * A small "untested" tag for menu items and controls whose feature has been
+ * built but not yet live-verified in the running app. It is deliberately loud
+ * (warning-tinted) and stays put until that specific feature is confirmed
+ * working — a tag is removed per-item only when the user explicitly says that
+ * feature has been tested. Add it to every new, unverified feature.
+ *
+ * Inside a `.context-menu` button, also put `className="untested"` on the
+ * button so the label and the tag lay out in a row (the tag floats right).
+ */
+import { useT } from "../../lib/i18n";
+
+export function UntestedTag() {
+  const t = useT();
+  return (
+    <span
+      className="untested-tag"
+      title={t("untested.title")}
+    >
+      {t("untested.label")}
+    </span>
+  );
+}
diff --git a/src/components/common/VpnTunnelUpNotice.tsx b/src/components/common/VpnTunnelUpNotice.tsx
new file mode 100644
index 0000000..8728f73
--- /dev/null
+++ b/src/components/common/VpnTunnelUpNotice.tsx
@@ -0,0 +1,22 @@
+import { ConnLamp } from "./ConnLamp";
+import { useT } from "../../lib/i18n";
+
+/**
+ * What a remote dialog shows in place of its "Connect via OpenVPN" section once a
+ * tunnel is already up machine-wide (the gate is `useVpnSectionVisible`): a
+ * project-scoped VPN control has nothing left to do — the computer is already
+ * routing through a tunnel — and the header's `VpnIndicator` is where a
+ * machine-wide tunnel is managed.
+ */
+export function VpnTunnelUpNotice() {
+  const t = useT();
+  return (
+    <div className="vpn-up-card" role="group" aria-label={t("vpnNotice.ariaLabel")}>
+      <span className="toggle-card-title">
+        <ConnLamp status="connected" label="OpenVPN" />
+        {t("vpnNotice.alreadyUp")}
+      </span>
+      <span className="toggle-card-desc">{t("vpnNotice.desc")}</span>
+    </div>
+  );
+}
diff --git a/src/components/common/mountPageStrip.tsx b/src/components/common/mountPageStrip.tsx
new file mode 100644
index 0000000..d858c3d
--- /dev/null
+++ b/src/components/common/mountPageStrip.tsx
@@ -0,0 +1,36 @@
+/**
+ * Mount a {@link PageStrip} into a plain DOM element.
+ *
+ * The print preview (`lib/viewers/print`) is an imperative DOM modal — an iframe, an
+ * options row and a stylesheet injected into the previewed document — and it is
+ * heavily tuned around WebKitGTK's missing `@page` margin box. Rewriting it in React
+ * to share the strip would risk all of that for no benefit, so instead it keeps its
+ * chrome and hands this adapter the one box the strip lives in.
+ *
+ * The result: the print strip and the PDF viewer's page rail are the same component,
+ * over the same arrangement model, with no React rewrite of the print modal.
+ */
+import { createRoot, type Root } from "react-dom/client";
+import { PageStrip, type PageStripProps } from "./PageStrip";
+
+export interface MountedPageStrip {
+  /** Re-render with new props (a fresh arrangement, new badges…). */
+  update: (props: PageStripProps) => void;
+  /** Unmount and release the React root. */
+  destroy: () => void;
+}
+
+export function mountPageStrip(
+  container: HTMLElement,
+  props: PageStripProps,
+): MountedPageStrip {
+  const root: Root = createRoot(container);
+  root.render(<PageStrip {...props} />);
+  return {
+    update: (next) => root.render(<PageStrip {...next} />),
+    // Unmounting synchronously from inside a React lifecycle would warn; the print
+    // modal tears down from a DOM event, never mid-render, so a microtask is enough
+    // to stay clear of any in-flight render.
+    destroy: () => queueMicrotask(() => root.unmount()),
+  };
+}
diff --git a/src/components/embed/CompareView.tsx b/src/components/embed/CompareView.tsx
new file mode 100644
index 0000000..04d70dd
--- /dev/null
+++ b/src/components/embed/CompareView.tsx
@@ -0,0 +1,664 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { Dropdown } from "../common/Dropdown";
+import { UntestedTag } from "../common/UntestedTag";
+import { useProjectsStore } from "../../stores/projects";
+import { resolveProjectDirectory } from "../../types";
+import { isPathWithin } from "../../lib/paths";
+import { relFromAbs } from "../../lib/viewers/fileUtils";
+import { highlight, languageForPath } from "../../lib/viewers/highlight";
+import {
+  diffLines,
+  groupChanges,
+  buildMerged,
+  applyBlockToggle,
+  canToggle,
+  locateBlock,
+  type AlignRow,
+  type ChangeBlock,
+  type Decision,
+} from "../../lib/viewers/linediff";
+
+/** Mirrors the Rust `GitCommit` (serde default snake→camel via serde? no — the
+ *  struct is plain, so fields arrive as declared: hash/short/subject/… ). */
+interface GitCommit {
+  hash: string;
+  short: string;
+  subject: string;
+  author: string;
+  date: string;
+  refs: string;
+  is_head: boolean;
+  parents: string[];
+}
+
+// Reuse the diff viewer's low-alpha add/del tints so it reads in both themes.
+const ADD_BG = "rgba(63, 185, 80, 0.15)";
+const DEL_BG = "rgba(248, 81, 73, 0.15)";
+// Sync-merge tints: the two sides are local (green) vs remote (amber), so the
+// changed lines take the locality-tag colors instead of add/del red-green.
+const LOCAL_BG = "color-mix(in srgb, var(--success) 15%, transparent)";
+const REMOTE_BG = "color-mix(in srgb, var(--warning) 15%, transparent)";
+
+/** Resolve the owning project directory for `path` exactly like `useBlame`:
+ *  the longest project dir that contains the path, else the active project. */
+function projectDirFor(path: string): string {
+  const { projects, activeId } = useProjectsStore.getState();
+  let best = "";
+  for (const p of projects) {
+    const dir = resolveProjectDirectory(p);
+    if (dir && isPathWithin(path, dir) && dir.length > best.length) best = dir;
+  }
+  if (!best) {
+    const active = projects.find((p) => p.id === activeId);
+    best = active ? resolveProjectDirectory(active) : "";
+  }
+  return best;
+}
+
+/** A read-only column (old or new) rendered line-by-line with per-line tinting
+ *  and reused syntax highlighting. Only lines present on that side are shown.
+ *
+ *  When merge props are supplied it also draws a per-change **take arrow** at the
+ *  first line of every change block: on the left column a "→" that pulls the left
+ *  side into the result (decision `reject`), on the right column a "←" that pulls
+ *  the right side in (decision `accept`). The arrow lights up when its side is the
+ *  one currently chosen, so each hunk shows which way it resolved at a glance. */
+function SideColumn({
+  title,
+  rows,
+  side,
+  path,
+  scrollRef,
+  onScroll,
+  blocks,
+  isActive,
+  onTake,
+  enabledOf,
+  onJump,
+  syncMode,
+}: {
+  title: string;
+  rows: AlignRow[];
+  side: "left" | "right";
+  path: string;
+  scrollRef: React.RefObject<HTMLDivElement>;
+  onScroll: (e: React.UIEvent<HTMLDivElement>) => void;
+  /** Change blocks to anchor take-arrows against; omit to draw a plain column. */
+  blocks?: ChangeBlock[];
+  /** Sync merge: tint changed lines by locality (green local / amber remote). */
+  syncMode?: boolean;
+  /** Whether this side is the block's currently-chosen decision. */
+  isActive?: (b: ChangeBlock) => boolean;
+  /** Resolve this block to this side. */
+  onTake?: (b: ChangeBlock) => void;
+  /** Whether the block can still be (re)assigned (false once hand-edited off-anchor). */
+  enabledOf?: (b: ChangeBlock) => boolean;
+  /** Snap all panes to a block (from a ruler-bar click). */
+  onJump?: (b: ChangeBlock) => void;
+}) {
+  const lang = useMemo(() => languageForPath(path), [path]);
+  const lines = useMemo(() => {
+    const out: { text: string; tint: string | undefined; no: number; ri: number }[] = [];
+    let no = 0;
+    rows.forEach((r, ri) => {
+      const text = side === "left" ? r.left : r.right;
+      if (text == null) return; // absent on this side
+      no++;
+      const changed =
+        r.kind === "change" ||
+        (r.kind === "del" && side === "left") ||
+        (r.kind === "add" && side === "right");
+      const tint = !changed
+        ? undefined
+        : syncMode
+          ? side === "left"
+            ? LOCAL_BG
+            : REMOTE_BG
+          : side === "left"
+            ? DEL_BG
+            : ADD_BG;
+      out.push({ text, tint, no, ri });
+    });
+    return out;
+  }, [rows, side, syncMode]);
+
+  // Anchor each block's take-arrow to the first rendered line at/after its start
+  // row (clamped to the last line when this side has no line inside the block —
+  // e.g. a pure addition on the other side), keyed by line index for O(1) lookup.
+  const anchors = useMemo(() => {
+    const m = new Map<number, ChangeBlock>();
+    if (!blocks) return m;
+    for (const b of blocks) {
+      let k = lines.findIndex((l) => l.ri >= b.startRow);
+      if (k < 0) k = lines.length - 1;
+      if (k >= 0 && !m.has(k)) m.set(k, b);
+    }
+    return m;
+  }, [blocks, lines]);
+
+  // Take-arrows live in an overlay layer positioned in pixels and synced to the
+  // body's vertical scroll — NOT inline in each line, which would let a long
+  // (horizontally scrolling) line carry the arrow off-screen. LINE_H mirrors the
+  // CSS (font-size 12 × line-height 1.5). The overlay is scrolled by translating
+  // an inner layer via a ref in the scroll handler — NOT by React state, which
+  // would re-render every line on every scroll frame and make scrolling stutter.
+  const LINE_H = 18;
+  const takeScrollRef = useRef<HTMLDivElement>(null);
+  const label = side === "left" ? "Take ▶" : "◀ Take";
+
+  return (
+    <div className="file-viewer-compare-col">
+      <div className="file-viewer-compare-col-head">{title}</div>
+      <div className="file-viewer-compare-col-body-wrap">
+        <DiffRuler blocks={blocks} totalRows={rows.length} side={side} onJump={onJump} />
+        <div
+          className="file-viewer-compare-col-body"
+          ref={scrollRef}
+          onScroll={(e) => {
+            if (takeScrollRef.current) {
+              takeScrollRef.current.style.transform = `translateY(${-e.currentTarget.scrollTop}px)`;
+            }
+            onScroll(e);
+          }}
+        >
+          {lines.map((l, i) => {
+            const html = highlight(l.text, lang);
+            const blockStart = anchors.has(i);
+            return (
+              <div
+                className={`file-viewer-compare-line${blockStart ? " is-block-start" : ""}`}
+                style={{ background: l.tint }}
+                key={i}
+              >
+                <span className="file-viewer-compare-lno">{l.no}</span>
+                {html != null ? (
+                  <span className="file-viewer-compare-code" dangerouslySetInnerHTML={{ __html: html }} />
+                ) : (
+                  <span className="file-viewer-compare-code">{l.text}</span>
+                )}
+              </div>
+            );
+          })}
+        </div>
+        {onTake && anchors.size > 0 && (
+          <div className={`file-viewer-compare-take-layer ${side}`}>
+            <div className="file-viewer-compare-take-scroll" ref={takeScrollRef}>
+              {[...anchors.entries()].map(([i, b]) => {
+                const enabled = enabledOf ? enabledOf(b) : true;
+                const active = !!isActive?.(b);
+                return (
+                  <button
+                    className={`file-viewer-compare-take ${side}${active ? " active" : ""}${enabled ? "" : " disabled"}`}
+                    key={b.id}
+                    style={{ top: i * LINE_H }}
+                    title={
+                      enabled
+                        ? side === "left"
+                          ? "Take this change from the left"
+                          : "Take this change from the right"
+                        : "Edited manually — can no longer be reassigned"
+                    }
+                    onClick={() => enabled && onTake(b)}
+                  >
+                    {label}
+                  </button>
+                );
+              })}
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/** An overview ruler painted over a column's scrollbar edge: one bar per change
+ *  block, positioned by its fractional row span so the diffs are visible at a
+ *  glance across the whole file, not just the scrolled-in slice. Row-fraction
+ *  (not pixel) placement keeps the bars aligned across the three columns. Each
+ *  bar is clickable — it snaps all three panes to that resolve position. */
+function DiffRuler({
+  blocks,
+  totalRows,
+  side,
+  onJump,
+}: {
+  blocks?: ChangeBlock[];
+  totalRows: number;
+  side: "left" | "right" | "mid";
+  onJump?: (b: ChangeBlock) => void;
+}) {
+  if (!blocks || blocks.length === 0 || totalRows === 0) return null;
+  return (
+    <div className="file-viewer-compare-ruler">
+      {blocks.map((b) => (
+        <div
+          className={`file-viewer-compare-ruler-mark ${side}${onJump ? " clickable" : ""}`}
+          key={b.id}
+          title={onJump ? "Jump to this change" : undefined}
+          onClick={onJump ? () => onJump(b) : undefined}
+          style={{
+            top: `${(b.startRow / totalRows) * 100}%`,
+            height: `${Math.max(((b.endRow - b.startRow) / totalRows) * 100, 0.8)}%`,
+          }}
+        />
+      ))}
+    </div>
+  );
+}
+
+/**
+ * Three-column compare/merge view for the in-app text editors. Left is the file
+ * at a chosen commit (its own history, via `git_file_log`), right is the live
+ * editor content, and the middle is an editable merged result. Each change block
+ * can be accepted (keep the new/right lines) or rejected (restore the old/left
+ * lines); the middle buffer stays freely editable and toggles splice into it by
+ * context anchor. "Apply to file" feeds the merged text back into the editor's
+ * normal draft/save flow.
+ */
+export function CompareView({
+  path,
+  rightText,
+  onApply,
+  onClose,
+  left,
+  rightTitle,
+  applyLabel,
+}: {
+  path: string;
+  /** The live editor content (the "new" side). */
+  rightText: string;
+  onApply: (merged: string) => void;
+  onClose: () => void;
+  /** When provided, the left ("old") side is a fixed text rather than a commit
+   *  picked from this file's git history — this is the "sync merge" mode where
+   *  the left side is the local mirror. In that mode the commit dropdown is
+   *  hidden and no git history is fetched. Absent → the git-compare behaviour. */
+  left?: { text: string; title: string };
+  /** Header for the right column. Defaults to "Current (editor)". */
+  rightTitle?: string;
+  /** Label for the apply button. Defaults to "Apply to file". */
+  applyLabel?: string;
+}) {
+  const syncMode = left != null;
+  const projectDir = useMemo(() => projectDirFor(path), [path]);
+  const relPath = useMemo(() => relFromAbs(projectDir, path), [projectDir, path]);
+
+  const [history, setHistory] = useState<GitCommit[]>([]);
+  const [rev, setRev] = useState<string>("");
+  const [gitOldText, setGitOldText] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  // Load this file's commit history and default to its most recent commit (the
+  // "previous version" relative to the working copy). Skipped in sync mode —
+  // there the left side is a caller-supplied fixed text, not a git revision.
+  useEffect(() => {
+    if (syncMode) return;
+    let cancelled = false;
+    setError(null);
+    invoke<GitCommit[]>("git_file_log", { projectDir, relPath, limit: 100 })
+      .then((commits) => {
+        if (cancelled) return;
+        setHistory(commits);
+        setRev((cur) => cur || (commits[0]?.hash ?? ""));
+      })
+      .catch((e) => {
+        if (!cancelled) setError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [syncMode, projectDir, relPath]);
+
+  // Fetch the file at the selected revision (the "old" side). Skipped in sync
+  // mode (the left text is provided directly).
+  useEffect(() => {
+    if (syncMode || !rev) {
+      setGitOldText(null);
+      return;
+    }
+    let cancelled = false;
+    setGitOldText(null);
+    invoke<string>("git_file_at_rev", { projectDir, relPath, rev })
+      .then((text) => {
+        if (!cancelled) setGitOldText(text);
+      })
+      .catch((e) => {
+        if (!cancelled) setError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [syncMode, projectDir, relPath, rev]);
+
+  // The left/"old" side: the caller's fixed text in sync mode, else the fetched
+  // git revision.
+  const oldText = syncMode ? left!.text : gitOldText;
+
+  const rows = useMemo(() => diffLines(oldText ?? "", rightText), [oldText, rightText]);
+  const blocks = useMemo(() => groupChanges(rows), [rows]);
+
+  // Merge state: a decision per block plus the authoritative editable buffer.
+  // `manual` flips once the user hand-edits, switching toggles from a wholesale
+  // recompute to a context-anchored splice that preserves those edits.
+  const [decisions, setDecisions] = useState<Record<number, Decision>>({});
+  const [resultText, setResultText] = useState<string>("");
+  const [manual, setManual] = useState(false);
+
+  // Re-seed the merge whenever the compared versions change: default every block
+  // to "accept", so the result starts equal to the live editor content.
+  useEffect(() => {
+    setDecisions({});
+    setManual(false);
+    setResultText(oldText == null ? rightText : buildMerged(rows, blocks, {}));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [oldText, rightText]);
+
+  const decisionOf = (b: ChangeBlock): Decision => decisions[b.id] ?? "accept";
+
+  const toggle = (b: ChangeBlock) => {
+    const cur = decisionOf(b);
+    if (!manual) {
+      const next = { ...decisions, [b.id]: cur === "accept" ? ("reject" as Decision) : ("accept" as Decision) };
+      setDecisions(next);
+      setResultText(buildMerged(rows, blocks, next));
+      return;
+    }
+    const res = applyBlockToggle(resultText, b, cur);
+    if (!res) return; // unanchored — button is disabled anyway
+    setResultText(res.text);
+    setDecisions({ ...decisions, [b.id]: res.decision });
+  };
+
+  const setAll = (d: Decision) => {
+    const next: Record<number, Decision> = {};
+    for (const b of blocks) next[b.id] = d;
+    setDecisions(next);
+    setManual(false);
+    setResultText(buildMerged(rows, blocks, next));
+  };
+
+  // Force a block to a specific side (used by the per-hunk take arrows). Since a
+  // decision is binary, forcing the value it isn't already at is exactly a toggle;
+  // when it already holds `d` this is a no-op, so re-clicking the lit arrow does
+  // nothing rather than flipping the hunk back.
+  const setDecision = (b: ChangeBlock, d: Decision) => {
+    if (decisionOf(b) !== d) toggle(b);
+  };
+
+  const toggleEnabled = (b: ChangeBlock): boolean =>
+    !manual || canToggle(resultText, b, decisionOf(b));
+
+  // Syntax-highlight the editable result so the middle column reads like the two
+  // side columns instead of flat monochrome text. The highlighted lines paint a
+  // backdrop that the transparent-text textarea sits on top of (its caret and
+  // selection stay live); scroll is mirrored from the textarea in its onScroll.
+  const lang = useMemo(() => languageForPath(path), [path]);
+  const resultLines = useMemo(() => resultText.split("\n"), [resultText]);
+
+  // Which result lines currently belong to a change block — used to tint the
+  // changed regions in the middle backdrop (the same blue as the mid ruler bars).
+  // Located by context against the live buffer so it survives hand-edits and the
+  // per-hunk toggles; a block that can't be uniquely located just isn't marked.
+  const changedLines = useMemo(() => {
+    const s = new Set<number>();
+    for (const b of blocks) {
+      const loc = locateBlock(resultLines, b, decisionOf(b));
+      if (loc) for (let k = 0; k < loc.len; k++) s.add(loc.start + k);
+    }
+    return s;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [blocks, resultLines, decisions]);
+
+  // Proportional scroll-sync across the three panes (content heights differ, so
+  // this is by ratio, not line-for-line). Feedback is suppressed by *echo
+  // matching*, not a time-based guard: assigning `scrollTop` fires the target's
+  // own `scroll` event on a LATER frame, so an rAF-cleared "syncing" flag has
+  // usually already reset by the time that echo lands — and if the echo hits a
+  // short pane sitting near its top, its ratio reads ~0 and slams every pane back
+  // to the top (the "jumps to top" bug). Instead we remember the exact scrollTop
+  // we drove each pane to; when that pane reports a scroll matching it (±1px for
+  // the browser's integer rounding), we know it's our own echo and ignore it.
+  const leftRef = useRef<HTMLDivElement>(null);
+  const rightRef = useRef<HTMLDivElement>(null);
+  const midRef = useRef<HTMLTextAreaElement>(null);
+  const midHlRef = useRef<HTMLDivElement>(null);
+  const echo = useRef(new Map<HTMLElement, number>());
+  const syncFrom = (src: HTMLElement) => {
+    const expected = echo.current.get(src);
+    if (expected != null && Math.abs(src.scrollTop - expected) <= 1) {
+      // Our own programmatic scroll bouncing back — consume it, drive nothing.
+      echo.current.delete(src);
+      return;
+    }
+    const denom = src.scrollHeight - src.clientHeight;
+    const ratio = denom > 0 ? src.scrollTop / denom : 0;
+    for (const el of [leftRef.current, rightRef.current, midRef.current]) {
+      if (!el || el === src) continue;
+      const max = el.scrollHeight - el.clientHeight;
+      if (max <= 0) continue;
+      const target = ratio * max;
+      echo.current.set(el, target);
+      el.scrollTop = target;
+    }
+  };
+
+  // Snap every pane to a change block: place its start row a few lines below the
+  // top so there is a little leading context. Row-fraction based, matching the
+  // ruler and the proportional scroll-sync, and driven instantly (echo-matched)
+  // so it doesn't fight the sync loop.
+  const scrollToBlock = (b: ChangeBlock) => {
+    const total = rows.length || 1;
+    const ratio = Math.max(0, b.startRow - 2) / total;
+    for (const el of [leftRef.current, rightRef.current, midRef.current]) {
+      if (!el) continue;
+      const max = el.scrollHeight - el.clientHeight;
+      if (max <= 0) continue;
+      const target = ratio * max;
+      echo.current.set(el, target);
+      el.scrollTop = target;
+    }
+    if (midHlRef.current && midRef.current) {
+      midHlRef.current.scrollTop = midRef.current.scrollTop;
+    }
+  };
+
+  const revLabel = (c: GitCommit) => `${c.short}${c.is_head ? " (HEAD)" : ""} · ${c.subject}`;
+  const options =
+    history.length > 0
+      ? history.map((c) => ({ value: c.hash, label: revLabel(c) }))
+      : [{ value: "", label: "No history for this file" }];
+  const selected = history.find((c) => c.hash === rev);
+  const loading = rev !== "" && oldText == null && error == null;
+
+  return (
+    <div className={`file-viewer-compare${syncMode ? " sync" : ""}`}>
+      <div className="file-viewer-compare-bar">
+        {syncMode ? (
+          // Sync merge: left/right are fixed (local mirror vs remote host), so
+          // there is no commit to pick — just name the two sides.
+          <span className="file-viewer-compare-label">
+            {left!.title} ⇄ {rightTitle ?? "Current"}
+          </span>
+        ) : (
+          <>
+            <span className="file-viewer-compare-label">Compare against</span>
+            <Dropdown
+              value={rev}
+              options={options}
+              onChange={setRev}
+              className="file-viewer-compare-rev"
+              title="Pick a commit from this file's history"
+              placeholder="Select a commit"
+            />
+            {selected && <span className="file-viewer-compare-date">{selected.date}</span>}
+          </>
+        )}
+        {syncMode && <UntestedTag />}
+        <div className="file-viewer-compare-bar-gap" />
+        {syncMode ? (
+          // Sync merge: name the two sides by what they are (local mirror vs
+          // remote host), and order the buttons left→right to match the columns
+          // — left column (Local) first, right column (Remote) second.
+          <>
+            <button
+              className="file-viewer-format-btn file-viewer-compare-take-all local"
+              onClick={() => setAll("reject")}
+              disabled={blocks.length === 0}
+              title="Take the local (mirror) side for every change"
+            >
+              Take all local
+            </button>
+            <button
+              className="file-viewer-format-btn file-viewer-compare-take-all remote"
+              onClick={() => setAll("accept")}
+              disabled={blocks.length === 0}
+              title="Take the remote (host) side for every change"
+            >
+              Take all remote
+            </button>
+          </>
+        ) : (
+          <>
+            <button
+              className="file-viewer-format-btn"
+              onClick={() => setAll("accept")}
+              disabled={blocks.length === 0}
+              title="Keep the current (new) version for every change"
+            >
+              Accept all
+            </button>
+            <button
+              className="file-viewer-format-btn"
+              onClick={() => setAll("reject")}
+              disabled={blocks.length === 0}
+              title="Revert every change to the old version"
+            >
+              Reject all
+            </button>
+          </>
+        )}
+        <button
+          className="file-viewer-format-btn file-viewer-compare-apply"
+          onClick={() => onApply(resultText)}
+          title={syncMode ? "Save the merged result to both sides" : "Write the merged result into the editor"}
+        >
+          {applyLabel ?? "Apply to file"}
+        </button>
+        <button className="file-viewer-format-btn" onClick={onClose} title="Close compare">
+          Close
+        </button>
+      </div>
+
+      {error != null ? (
+        <div className="file-viewer-error">{error}</div>
+      ) : loading ? (
+        <div className="file-viewer-loading">Loading version…</div>
+      ) : (
+        <div className="file-viewer-compare-cols">
+          <SideColumn
+            title={syncMode ? left!.title : selected ? `Old — ${selected.short}` : "Old"}
+            rows={rows}
+            side="left"
+            path={path}
+            scrollRef={leftRef}
+            onScroll={(e) => syncFrom(e.currentTarget)}
+            blocks={blocks}
+            isActive={(b) => decisionOf(b) === "reject"}
+            onTake={(b) => setDecision(b, "reject")}
+            enabledOf={toggleEnabled}
+            onJump={scrollToBlock}
+            syncMode={syncMode}
+          />
+
+          <div className="file-viewer-compare-col file-viewer-compare-col-mid">
+            <div className="file-viewer-compare-col-head">
+              <span>Result</span>
+              {blocks.length > 0 && (
+                <div className="file-viewer-compare-chips">
+                  {blocks.map((b, i) => {
+                    const dec = decisionOf(b);
+                    const enabled = toggleEnabled(b);
+                    return (
+                      <span
+                        className={`file-viewer-compare-chip ${dec === "accept" ? "accept" : "reject"}${enabled ? "" : " disabled"}`}
+                        key={b.id}
+                        title={
+                          enabled
+                            ? dec === "accept"
+                              ? "Change kept (new). Click to revert to old."
+                              : "Change reverted (old). Click to keep new."
+                            : "Edited manually — toggle unavailable"
+                        }
+                        onClick={() => {
+                          scrollToBlock(b);
+                          if (enabled) toggle(b);
+                        }}
+                      >
+                        {dec === "accept" ? "✓" : "↩"} {i + 1}
+                      </span>
+                    );
+                  })}
+                </div>
+              )}
+            </div>
+            <div className="file-viewer-compare-result-wrap">
+              <DiffRuler blocks={blocks} totalRows={rows.length} side="mid" onJump={scrollToBlock} />
+              <div className="file-viewer-compare-result-hl" ref={midHlRef} aria-hidden="true">
+                {resultLines.map((line, i) => {
+                  const html = highlight(line, lang);
+                  const cls = `file-viewer-compare-hl-line${changedLines.has(i) ? " changed" : ""}`;
+                  return html != null ? (
+                    <div
+                      className={cls}
+                      key={i}
+                      dangerouslySetInnerHTML={{ __html: html || "​" }}
+                    />
+                  ) : (
+                    <div className={cls} key={i}>
+                      {line || "​"}
+                    </div>
+                  );
+                })}
+              </div>
+              <textarea
+                ref={midRef}
+                className="file-viewer-compare-result"
+                value={resultText}
+                spellCheck={false}
+                onChange={(e) => {
+                  setResultText(e.target.value);
+                  setManual(true);
+                }}
+                onScroll={(e) => {
+                  const ta = e.currentTarget;
+                  if (midHlRef.current) {
+                    midHlRef.current.scrollTop = ta.scrollTop;
+                    midHlRef.current.scrollLeft = ta.scrollLeft;
+                  }
+                  syncFrom(ta);
+                }}
+              />
+            </div>
+          </div>
+
+          <SideColumn
+            title={rightTitle ?? "Current (editor)"}
+            rows={rows}
+            side="right"
+            path={path}
+            scrollRef={rightRef}
+            onScroll={(e) => syncFrom(e.currentTarget)}
+            blocks={blocks}
+            isActive={(b) => decisionOf(b) === "accept"}
+            onTake={(b) => setDecision(b, "accept")}
+            enabledOf={toggleEnabled}
+            onJump={scrollToBlock}
+            syncMode={syncMode}
+          />
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/embed/ContextFilePicker.tsx b/src/components/embed/ContextFilePicker.tsx
new file mode 100644
index 0000000..0e4693d
--- /dev/null
+++ b/src/components/embed/ContextFilePicker.tsx
@@ -0,0 +1,193 @@
+/**
+ * QuickOpen-style file picker for attaching reference files as local-autocomplete
+ * context (#45 context files). Modelled on `QuickOpen` but used as a controlled
+ * modal (mounted while open) instead of a global Ctrl/Cmd+P singleton: it lists
+ * the editor's project files via `list_project_paths`, fuzzy-ranks them with the
+ * shared `src/lib/fuzzy.ts`, and calls `onPick(rel)` for the chosen file. Files
+ * already attached are shown ticked and are picked-through to a no-op by the
+ * caller. Reuses the `.qo-*` styles from QuickOpen.css.
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { fuzzyMatch, fuzzyRank } from "../../lib/fuzzy";
+import "../files/QuickOpen.css";
+
+interface PathEntry {
+  path: string;
+  is_dir: boolean;
+}
+
+const MAX_RESULTS = 50;
+
+/** Render the rel path with the fuzzy-matched characters emphasised. */
+function HighlightedPath({ text, query }: { text: string; query: string }) {
+  const positions = useMemo(() => {
+    if (!query) return null;
+    const m = fuzzyMatch(query, text);
+    return m ? new Set(m.positions) : null;
+  }, [text, query]);
+
+  if (!positions || positions.size === 0) return <>{text}</>;
+  const out: React.ReactNode[] = [];
+  for (let i = 0; i < text.length; i++) {
+    out.push(
+      positions.has(i) ? (
+        <span key={i} className="qo-hl">
+          {text[i]}
+        </span>
+      ) : (
+        text[i]
+      ),
+    );
+  }
+  return <>{out}</>;
+}
+
+export function ContextFilePicker({
+  projectDir,
+  attached,
+  onPick,
+  onClose,
+}: {
+  /** Project root whose files are offered (empty → "No project"). */
+  projectDir: string;
+  /** Relative paths already attached, shown ticked. */
+  attached: string[];
+  /** Add the picked file (project-relative path). The picker stays open so
+   *  several files can be added in one session; Esc / backdrop closes it. */
+  onPick: (rel: string) => void;
+  onClose: () => void;
+}) {
+  const [loading, setLoading] = useState(true);
+  const [files, setFiles] = useState<string[]>([]);
+  const [query, setQuery] = useState("");
+  const [selected, setSelected] = useState(0);
+
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const listRef = useRef<HTMLDivElement | null>(null);
+  const attachedSet = useMemo(() => new Set(attached), [attached]);
+
+  useEffect(() => {
+    let alive = true;
+    setLoading(true);
+    if (!projectDir) {
+      setFiles([]);
+      setLoading(false);
+      return;
+    }
+    invoke<PathEntry[]>("list_project_paths", { projectDir })
+      .then((entries) => {
+        if (!alive) return;
+        setFiles(entries.filter((e) => !e.is_dir).map((e) => e.path));
+      })
+      .catch(() => alive && setFiles([]))
+      .finally(() => alive && setLoading(false));
+    return () => {
+      alive = false;
+    };
+  }, [projectDir]);
+
+  useEffect(() => {
+    inputRef.current?.focus();
+  }, []);
+
+  const results = useMemo(
+    () => fuzzyRank(query, files, (f) => f).slice(0, MAX_RESULTS),
+    [query, files],
+  );
+
+  useEffect(() => {
+    setSelected((s) => (results.length === 0 ? 0 : Math.min(s, results.length - 1)));
+  }, [results]);
+
+  useEffect(() => {
+    const el = listRef.current?.querySelector<HTMLElement>(`[data-idx="${selected}"]`);
+    el?.scrollIntoView?.({ block: "nearest" });
+  }, [selected, results]);
+
+  const onInputKey = useCallback(
+    (e: React.KeyboardEvent<HTMLInputElement>) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        onClose();
+      } else if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setSelected((s) => (results.length === 0 ? 0 : (s + 1) % results.length));
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setSelected((s) => (results.length === 0 ? 0 : (s - 1 + results.length) % results.length));
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        const pick = results[selected];
+        if (pick) onPick(pick);
+      }
+    },
+    [results, selected, onClose, onPick],
+  );
+
+  // Portal out of the editor: the picker is mounted deep inside `.pane-layer`
+  // (a `position:absolute; z-index:2` stacking context), so a `position:fixed`
+  // backdrop rendered in place has its z-index resolved *within* that context and
+  // paints under the rest of the UI (invisible). Portal it up to the app's root
+  // element so `z-index` reaches the top of the page.
+  //
+  // Target `#root` (the React app surface, painted in BOTH the main and detached
+  // windows) rather than `document.body`: a body-level portal can fail to paint
+  // in the detached pop-out webview, so the overlay went missing there. `#root`
+  // is still outside `.pane-layer`, so it escapes the trap just the same. Falls
+  // back to `document.body` if `#root` isn't present (e.g. in tests).
+  const portalTarget =
+    (typeof document !== "undefined" && document.getElementById("root")) ||
+    (typeof document !== "undefined" ? document.body : null);
+  if (!portalTarget) return null;
+  return createPortal(
+    <div className="qo-backdrop qo-context-backdrop" onMouseDown={onClose}>
+      <div className="qo-panel qo-context-panel" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="qo-context-header">Autocomplete context files</div>
+        <input
+          ref={inputRef}
+          className="qo-input"
+          type="text"
+          placeholder="Add file as autocomplete context…"
+          value={query}
+          spellCheck={false}
+          autoComplete="off"
+          onChange={(e) => {
+            setQuery(e.target.value);
+            setSelected(0);
+          }}
+          onKeyDown={onInputKey}
+        />
+        <div className="qo-list" ref={listRef}>
+          {loading ? (
+            <div className="qo-empty">Loading…</div>
+          ) : results.length === 0 ? (
+            <div className="qo-empty">
+              {!projectDir ? "No project" : files.length === 0 ? "No files" : "No matches"}
+            </div>
+          ) : (
+            results.map((rel, idx) => (
+              <div
+                key={rel}
+                data-idx={idx}
+                className={"qo-row" + (idx === selected ? " qo-row-sel" : "")}
+                onMouseDown={(e) => {
+                  e.preventDefault();
+                  onPick(rel);
+                }}
+                onMouseEnter={() => setSelected(idx)}
+              >
+                <span>
+                  {attachedSet.has(rel) ? "✓ " : ""}
+                  <HighlightedPath text={rel} query={query} />
+                </span>
+              </div>
+            ))
+          )}
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/embed/DiffView.tsx b/src/components/embed/DiffView.tsx
new file mode 100644
index 0000000..2c3e389
--- /dev/null
+++ b/src/components/embed/DiffView.tsx
@@ -0,0 +1,203 @@
+import { useEffect, useMemo, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { ViewerHeader, useReadonlyFile } from "./FileViewerPane";
+import { useProjectsStore } from "../../stores/projects";
+import { resolveProjectDirectory } from "../../types";
+import { relFromAbs } from "../../lib/viewers/fileUtils";
+import { parseUnifiedDiff, type DiffLine } from "../../lib/viewers/diff";
+
+/** True when `path` is a literal diff/patch file (read its raw content) rather
+ *  than a source path (compute the diff via the backend). */
+function isPatchFile(path: string): boolean {
+  const lower = path.toLowerCase();
+  return lower.endsWith(".diff") || lower.endsWith(".patch");
+}
+
+// Low-alpha line backgrounds, keyed off the GitHub-ish add/del greens & reds so
+// they read in both light and dark themes (the text colour stays the app's).
+const ADD_BG = "rgba(63, 185, 80, 0.15)"; // #3fb950
+const DEL_BG = "rgba(248, 81, 73, 0.15)"; // #f85149
+
+function lineBackground(type: DiffLine["type"]): string | undefined {
+  if (type === "add") return ADD_BG;
+  if (type === "del") return DEL_BG;
+  return undefined;
+}
+
+/** A single rendered diff line: two line-number gutter columns then the text.
+ *  Text is rendered as React children, which auto-escapes — no raw HTML. */
+function DiffLineRow({ line }: { line: DiffLine }) {
+  const muted = line.type === "hunk" || line.type === "meta" || line.type === "nonewline";
+  const marker =
+    line.type === "add" ? "+" : line.type === "del" ? "-" : line.type === "context" ? " " : "";
+  return (
+    <div
+      className="diff-line"
+      style={{
+        display: "flex",
+        background: lineBackground(line.type),
+        color: muted ? "var(--text-secondary, #8b949e)" : "var(--text-primary)",
+        whiteSpace: "pre",
+      }}
+    >
+      <span
+        className="diff-gutter"
+        style={{
+          flex: "0 0 auto",
+          width: "3.5em",
+          textAlign: "right",
+          paddingRight: "0.5em",
+          color: "var(--text-secondary, #8b949e)",
+          opacity: 0.7,
+          userSelect: "none",
+        }}
+      >
+        {line.oldNo ?? ""}
+      </span>
+      <span
+        className="diff-gutter"
+        style={{
+          flex: "0 0 auto",
+          width: "3.5em",
+          textAlign: "right",
+          paddingRight: "0.5em",
+          borderRight: "1px solid var(--border-color)",
+          color: "var(--text-secondary, #8b949e)",
+          opacity: 0.7,
+          userSelect: "none",
+        }}
+      >
+        {line.newNo ?? ""}
+      </span>
+      <span className="diff-text" style={{ flex: "1 1 auto", paddingLeft: "0.5em" }}>
+        {line.type === "hunk" || line.type === "nonewline" ? line.text : marker + line.text}
+      </span>
+    </div>
+  );
+}
+
+/**
+ * In-app unified-diff viewer (Dev 3 / TODO Group K). Renders a `.diff`/`.patch`
+ * file's content, or — when `path` is a real source file — the working-tree diff
+ * for that file fetched from the backend (`git_diff_file`). The diff is parsed
+ * with `parseUnifiedDiff` and rendered with a two-column (old/new) line-number
+ * gutter and add/del/context colouring. All line text is rendered as React
+ * children (auto-escaped) — never as raw HTML.
+ */
+export function DiffView({
+  path,
+  projectId,
+  mode = "git",
+  onOpenExternally,
+  tabKey: _tabKey,
+}: {
+  path: string;
+  projectId: string | null;
+  /** `"git"` (default) diffs the working tree via `git_diff_file`; `"sync"`
+   *  diffs the local mirror against the current host over `sync_diff` (SSH
+   *  projects). Patch/diff files always render their own raw content regardless. */
+  mode?: "git" | "sync";
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  const patchMode = isPatchFile(path);
+
+  // Hooks must run unconditionally. In patch mode we use this file's content; in
+  // source mode we ignore it (and fetch the diff via the backend instead).
+  const fileState = useReadonlyFile(path);
+
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const projectDir = resolveProjectDirectory(project);
+  const relPath = relFromAbs(projectDir, path);
+
+  // Source-mode: fetch the diff on mount (and whenever the target changes) — the
+  // working-tree diff via `git_diff_file`, or the host-vs-mirror diff via
+  // `sync_diff` when this pane is a sync diff.
+  const [gitText, setGitText] = useState<string | null>(null);
+  const [gitError, setGitError] = useState<string | null>(null);
+  useEffect(() => {
+    if (patchMode) return;
+    let cancelled = false;
+    setGitText(null);
+    setGitError(null);
+    const req =
+      mode === "sync"
+        ? invoke<string>("sync_diff", { projectId, relPath })
+        : invoke<string>("git_diff_file", { projectDir, relPath });
+    req
+      .then((text) => {
+        if (!cancelled) setGitText(text);
+      })
+      .catch((e) => {
+        if (!cancelled) setGitError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [patchMode, mode, projectId, projectDir, relPath]);
+
+  const text = patchMode ? fileState.content : gitText;
+  const error = patchMode ? fileState.error : gitError;
+  const loaded = text != null;
+
+  const files = useMemo(() => (text != null ? parseUnifiedDiff(text) : []), [text]);
+
+  return (
+    <ViewerHeader onOpenExternally={onOpenExternally}>
+      <div
+        className="diff-viewer"
+        style={{
+          position: "absolute",
+          inset: 0,
+          top: "var(--file-viewer-header-h, 36px)",
+          overflow: "auto",
+          background: "var(--bg-panel)",
+          color: "var(--text-primary)",
+          fontFamily: "var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace)",
+          fontSize: "12px",
+          lineHeight: "1.5",
+        }}
+      >
+        {error != null ? (
+          <div className="diff-error" style={{ padding: "1rem", color: "#f85149" }}>
+            {error}
+          </div>
+        ) : !loaded ? (
+          <div className="diff-loading" style={{ padding: "1rem", color: "var(--text-secondary, #8b949e)" }}>
+            Loading diff…
+          </div>
+        ) : files.length === 0 ? (
+          <div className="diff-empty" style={{ padding: "1rem", color: "var(--text-secondary, #8b949e)" }}>
+            No changes.
+          </div>
+        ) : (
+          files.map((file, fi) => (
+            <div className="diff-file" key={`${file.newPath}:${fi}`}>
+              <div
+                className="diff-file-header"
+                style={{
+                  padding: "0.4em 0.75em",
+                  background: "var(--bg-elevated, rgba(255,255,255,0.04))",
+                  borderTop: fi > 0 ? "1px solid var(--border-color)" : undefined,
+                  borderBottom: "1px solid var(--border-color)",
+                  fontWeight: 600,
+                  position: "sticky",
+                  top: 0,
+                }}
+              >
+                {file.newPath && file.newPath !== "/dev/null" ? file.newPath : file.oldPath}
+              </div>
+              {file.hunks.map((hunk, hi) => (
+                <div className="diff-hunk" key={hi}>
+                  {hunk.lines.map((line, li) => (
+                    <DiffLineRow line={line} key={li} />
+                  ))}
+                </div>
+              ))}
+            </div>
+          ))
+        )}
+      </div>
+    </ViewerHeader>
+  );
+}
diff --git a/src/components/embed/EmbedPane.tsx b/src/components/embed/EmbedPane.tsx
index e5533f5..50a11a6 100644
--- a/src/components/embed/EmbedPane.tsx
+++ b/src/components/embed/EmbedPane.tsx
@@ -1,5 +1,6 @@
 import { useEffect, useRef } from "react";
 import { useWindowsStore } from "../../stores/windows";
+import { basename } from "../../lib/paths";
 
 interface Props {
   /** Absolute path of the embedded file. */
@@ -33,7 +34,7 @@ export function EmbedPane({ path, exec, projectId, visible }: Props) {
       .catch((e) => console.error(e));
   }, [path, exec, projectId]);
 
-  const fileName = path.split("/").filter(Boolean).pop() ?? path;
+  const fileName = basename(path) || path;
   return (
     <div
       className="embed-pane center-placeholder"
diff --git a/src/components/embed/FileViewerPane.tsx b/src/components/embed/FileViewerPane.tsx
index 401d2ee..ff7e434 100644
--- a/src/components/embed/FileViewerPane.tsx
+++ b/src/components/embed/FileViewerPane.tsx
@@ -1,12 +1,19 @@
-import { useCallback, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
+import { createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
 import { emit, listen } from "@tauri-apps/api/event";
-import * as pdfjs from "pdfjs-dist";
-import type { PDFDocumentProxy } from "pdfjs-dist";
-import pdfWorkerUrl from "pdfjs-dist/build/pdf.worker.min.mjs?url";
 import { useWindowsStore } from "../../stores/windows";
-import { findGroupOfTab, useTabsStore, type ViewerState } from "../../stores/tabs";
+import {
+  findGroupOfTab,
+  getDetachedViewerState,
+  useTabsStore,
+  type ViewerState,
+} from "../../stores/tabs";
 import { useSettingsStore } from "../../stores/settings";
+import { useExperimental } from "../../lib/experimental";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { RemotePaneHold } from "../projects/RemotePaneHold";
 import { useLinkRoutingStore } from "../../stores/linkRouting";
 import {
   useEditorJumpStore,
@@ -15,18 +22,112 @@ import {
   unregisterEditor,
 } from "../../stores/editorJump";
 import { usePdfSyncStore } from "../../stores/pdfSync";
+import { useScrollSync } from "../../stores/scrollSync";
 import { parseDetachedParam } from "../../stores/detached";
 import { Dropdown } from "../common/Dropdown";
+import { CompareView } from "./CompareView";
+import { PresentationOverlay } from "./PresentationOverlay";
 import { renderMarkdown } from "../../lib/viewers/markdown";
-import { highlight, languageForPath } from "../../lib/viewers/highlight";
-import { internalViewerFor, type InternalViewer, type FileEntry } from "../../lib/viewers/fileUtils";
+import { enrichMarkdownDom } from "../../lib/viewers/markdownEnrich";
+import { highlight, languageForPath, escapeHtml } from "../../lib/viewers/highlight";
+import { useOllamaStatus } from "../../lib/ollamaStatus";
+import {
+  printDocument,
+  printHtmlBody,
+  MARKDOWN_PRINT_CSS,
+  TEXT_PRINT_CSS,
+  IMAGE_PRINT_CSS,
+} from "../../lib/viewers/print";
+import {
+  formatJsonText,
+  isInProcessJson,
+  formatLangForPath,
+  validationLangForPath,
+  previewKindForPath,
+  buildPreviewDoc,
+  type PreviewKind,
+} from "../../lib/viewers/format";
+import {
+  toggleInline,
+  cycleHeading,
+  toggleLinePrefix,
+  makeLink,
+  generateToc,
+  type EditResult,
+} from "../../lib/viewers/markdownEdit";
+import { internalViewerFor, disabledViewers, relFromAbs, type InternalViewer, type FileEntry } from "../../lib/viewers/fileUtils";
+import {
+  isPythonPath,
+  isPythonMainScript,
+  pythonLinkRanges,
+  remapBreakpoints,
+  resolvePythonDefinition,
+  snapBreakpointLine,
+} from "../../lib/viewers/python";
+import { debugPythonFile, runCwd, runPythonFile, placeForFocused } from "../../lib/pythonRun";
+import { RunHostPicker } from "../tabs/TabLocalityBadges";
+import {
+  isSlurmScript,
+  parseSbatchDirectives,
+  directiveValue,
+  spliceDirective,
+  slurmAvailable,
+  submitSlurmJob,
+  openInteractiveJob,
+  COMMON_SBATCH_KEYS,
+  type SlurmInfo,
+  type InteractiveResources,
+} from "../../lib/slurm";
+import { FileDropContext } from "../files/fileDropContext";
+import { UntestedTag } from "../common/UntestedTag";
+import { FileSourceSwitch } from "../files/ProjectFilesPane";
+import {
+  basename,
+  dirname,
+  fromFileUri,
+  isPathWithin,
+  normalizePath,
+  resolvePath,
+  toFileUri,
+} from "../../lib/paths";
+import { IS_MAC, IS_WINDOWS } from "../../lib/platform";
+import { runInstallInTab } from "../../lib/installCommand";
+import {
+  resolveProjectDirectory,
+  resolveLocalMirror,
+  type AutocompleteMode,
+  type GrammarIssue,
+} from "../../types";
+import { useSyncStore } from "../../stores/sync";
+import { ContextFilePicker } from "./ContextFilePicker";
+import { useFileSourcesStore } from "../../stores/fileSources";
+import {
+  FileScopeContext,
+  useFileScope,
+  fileSource,
+  type FileSource,
+  readFileText,
+  readFileBytes,
+  writeFileText,
+  fileMtime,
+  describeFileError,
+} from "./fileAccess";
+import { TableView } from "./TableView";
+import { NotebookView } from "./NotebookView";
+import { DiffView } from "./DiffView";
+import { SyncMergeView } from "./SyncMergeView";
+import { OdtView } from "./OdtView";
+import { MediaView } from "./MediaView";
+import { GifView } from "./GifView";
+import { SqliteView } from "./SqliteView";
+import { ImageAnnotator } from "./ImageAnnotator";
 import {
   type TexCapability,
   type TexCompileResult,
-  type SyncRect,
   type TexCompletions,
   type TexComplContext,
   getTexCapability,
+  refreshTexCapability,
   lastLogLine,
   type TexError,
   parseTexErrors,
@@ -37,20 +138,20 @@ import {
   gatherTexCompletions,
   resolveTexRefAsync,
   texRefRanges,
-  synctexEdit,
   synctexViewBest,
   pickSyncRect,
   sourceColumnFraction,
   resolveTexRoot,
-  pdfPointToBigPoints,
-  bigPointsToCssRect,
   lineStartOffset,
   offsetToLineCol,
   phraseAt,
-  refineToWord,
-  type TextItemBox,
-  type CaretPhrase,
 } from "../../lib/viewers/tex";
+import { PdfView } from "./pdf/PdfViewer";
+import { DeckView } from "./deck/DeckView";
+import { YamlTree } from "./YamlTree";
+import { YamlGrid } from "./YamlGrid";
+import { isTreePath, isJsonPath } from "../../lib/viewers/yaml";
+import { hasCards } from "../../lib/viewers/yamlGrid";
 
 /**
  * Persisted reader-position plumbing for an in-app viewer. Snapshots the tab's
@@ -60,12 +161,24 @@ import {
  * project.json by CenterPanel's debounced saveLayout, so the position survives an
  * Eldrun restart. A no-op when `tabKey` is absent (e.g. tests).
  */
-function useViewerState(tabKey: string | undefined) {
-  const [initial] = useState<ViewerState | undefined>(() =>
-    tabKey
-      ? useTabsStore.getState().tabs.find((t) => t.key === tabKey)?.viewerState
-      : undefined,
+/**
+ * A tab's persisted `ViewerState` seed, read once. Normally from `useTabsStore`
+ * (the main window owns the layout store); in a DETACHED window that store has
+ * no entry for the tab — its tabs render from a Tauri seed into local React
+ * state, not the store — so fall back to the detached seed registry. Without
+ * this fallback a detached editor loses per-tab scroll/zoom and the #45
+ * autocomplete/grammar toggles, silently reverting to the per-type defaults.
+ */
+function seedViewerState(tabKey: string | undefined): ViewerState | undefined {
+  if (!tabKey) return undefined;
+  return (
+    useTabsStore.getState().tabs.find((t) => t.key === tabKey)?.viewerState ??
+    getDetachedViewerState(tabKey)
   );
+}
+
+export function useViewerState(tabKey: string | undefined) {
+  const [initial] = useState<ViewerState | undefined>(() => seedViewerState(tabKey));
   const persist = useCallback(
     (patch: ViewerState) => {
       if (tabKey) useTabsStore.getState().setViewerState(tabKey, patch);
@@ -79,11 +192,7 @@ function useViewerState(tabKey: string | undefined) {
 
 // The modifier that opens a recognised file link (Ctrl/Cmd+Click). Shown verbatim
 // in the hover hint, so it must read as the key the user actually presses.
-const OPEN_MODIFIER = /Mac|iPhone|iPad/i.test(
-  (typeof navigator !== "undefined" && (navigator.platform || navigator.userAgent)) || "",
-)
-  ? "⌘"
-  : "Ctrl";
+const OPEN_MODIFIER = IS_MAC ? "⌘" : "Ctrl";
 const OPEN_LINK_HINT = `${OPEN_MODIFIER}+Click to open`;
 
 /** A small floating "{Ctrl}+Click to open" hint, anchored just above a hovered
@@ -116,7 +225,7 @@ export function zoomOffset(
 /** A URI-list / DownloadURL dataTransfer payload for dragging a file out of the
  *  app as an OS-level drop source (#53). Mirrors FileTree's `file://` encoding. */
 function pathToFileUri(path: string): string {
-  return `file://${path.split("/").map(encodeURIComponent).join("/")}`;
+  return toFileUri(path);
 }
 
 /**
@@ -135,7 +244,7 @@ export function onImageDragStart(
   const dt = e.dataTransfer;
   if (!dt) return;
   const uri = pathToFileUri(path);
-  const name = path.slice(path.lastIndexOf("/") + 1);
+  const name = basename(path);
   dt.setData("text/uri-list", uri);
   dt.setData("text/plain", uri);
   // DownloadURL = "<mime>:<filename>:<absolute url>". An empty mime lets the OS
@@ -144,10 +253,6 @@ export function onImageDragStart(
   dt.effectAllowed = "copy";
 }
 
-// pdf.js renders pages on a worker; point it at the bundled worker asset. Vite
-// emits a hashed URL that resolves in both dev and the packaged Tauri build.
-pdfjs.GlobalWorkerOptions.workerSrc = pdfWorkerUrl;
-
 interface Props {
   /** Which built-in viewer to render with. */
   viewer: InternalViewer;
@@ -162,6 +267,10 @@ interface Props {
    *  parent `.center-pane` already hides inactive panes via display:none — but
    *  accepted for call-site parity with the other pane components. */
   visible?: boolean;
+  /** The subwindow (group) id hosting this pane, for proportional scroll-linking
+   *  between two side-by-side viewer subwindows (see stores/scrollSync). Null/
+   *  absent when the pane isn't in a syncable group; the sync hooks then no-op. */
+  groupId?: string | null;
 }
 
 /**
@@ -174,6 +283,12 @@ interface Props {
  *                  to disk (Python, Rust, JSON, config files, …).
  *   - "markdown" → rendered HTML via renderMarkdown, with an Edit/Preview toggle
  *                  that lets you edit the source and save it back to disk.
+ *   - "yaml"     → YAML **and JSON** (which is YAML's flow syntax): the same
+ *                  editor with a Tree/Source toggle, where the tree is an editable
+ *                  structure view (rename a key, retype a value, add a key or a
+ *                  list item, reorder, delete). It splices the file's own text, so
+ *                  comments and layout survive, each collection keeps the style it
+ *                  is written in (block or flow), and both modes share one draft.
  *   - "image"    → the bytes wrapped in a Blob URL, shown in a zoomable/pannable
  *                  <img> (wheel to zoom at cursor, drag to pan, Fit / 1:1).
  *   - "pdf"      → rendered with pdf.js into a scrolling stack of page canvases
@@ -185,29 +300,344 @@ interface Props {
  *                  PATH; it degrades to exactly the "text" editor otherwise.
  * An "Open externally" button is always offered as a fallback.
  */
-export function FileViewerPane({ viewer, path, projectId, tabKey }: Props) {
-  const fileName = path.split("/").filter(Boolean).pop() ?? path;
+export function FileViewerPane({ viewer, path, projectId, tabKey, groupId }: Props) {
+  const fileName = basename(path) || path;
+
+  // The native presenter is experimental; with the flag off a deck opens as the
+  // JSON it physically is. Read up here because the dispatch below sits after an
+  // early return, and a hook cannot.
+  const deckOn = useExperimental("deck_presenter");
+
+  // Resolve whether these bytes are remote-native (host SFTP) or the local
+  // mirror, and publish it to the tab strip so the Remote/Local badge rides on
+  // this tab itself instead of costing a whole viewer header row (see the
+  // fileSources store). Only remote (SSH) projects yield anything but "none";
+  // the query is cheap (no file read) and re-runs when the path/scope changes.
+  // The published entry is dropped when the viewer unmounts (tab closed).
+  // `null` = not resolved yet; used by the disconnected-gate below to hold
+  // rather than flash a red read error before we know the source.
+  const [source, setSource] = useState<FileSource | null>(null);
+  useEffect(() => {
+    let cancelled = false;
+    fileSource(path, projectId)
+      .then((s) => {
+        if (cancelled) return;
+        setSource(s);
+      })
+      .catch(() => {
+        if (cancelled) return;
+        setSource("none");
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path, projectId]);
+
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+
+  // A viewer tab is opened against one fixed absolute path (mirror OR host). For
+  // a remote project this manual override lets the SAME tab show the other side
+  // instead — same rel path, root swapped — without touching the tab's
+  // persisted path. Session-only: resets to "no override" when the tab is
+  // retargeted to a different file, so `effectiveSource` falls back to the file's
+  // OWN resolved side (`source`, from `fileSource(path)`) — i.e. the side the
+  // path already points at. That is the load-bearing default: `openFileEntry`
+  // hands the viewer a *host* path when the tree that opened it was on Remote and
+  // a *mirror* path when it was on Local, so trusting the path is what makes
+  // "opened from a Remote listing ⇒ shown over SFTP" hold. Seeding instead from a
+  // shared per-project pref (the old behaviour) let a stale/other-surface value
+  // silently rewrite a host path back to the mirror — the Files-tab / subwindow
+  // sidebar use an *independent* source that never writes that pref, so a file
+  // opened there on Remote was read locally. `null` = follow the path.
+  const [sideOverride, setSideOverride] = useState<"local" | "remote" | null>(null);
+  useEffect(() => {
+    setSideOverride(null);
+  }, [path, projectId]);
+  const rel = useMemo(() => autoSyncRel(project, path), [project, path]);
+  const mirrorRoot = useMemo(() => localMirrorRootFor(project), [project]);
+  const effectiveSource: FileSource = sideOverride ?? source ?? "none";
+  const effectivePath = useMemo(() => {
+    if (!project?.remote || !rel) return path;
+    if (effectiveSource === "remote") return resolvePath(project.remote.remote_path, rel);
+    if (effectiveSource === "local" && mirrorRoot) return resolvePath(mirrorRoot, rel);
+    return path;
+  }, [project, rel, effectiveSource, mirrorRoot, path]);
+
+  useEffect(() => {
+    if (tabKey) useFileSourcesStore.getState().setSource(tabKey, effectiveSource);
+    return () => {
+      if (tabKey) useFileSourcesStore.getState().clearSource(tabKey);
+    };
+  }, [tabKey, effectiveSource]);
+
+  // Disconnected remote project: reading a remote-native (SFTP) file would block
+  // on the dead pool and each nested viewer would flash its own red read error.
+  // Instead show the SAME "Not connected" placeholder the remote shell uses, so
+  // the message is unified across terminal and file tabs. Local-mirror files
+  // (source "local") and local projects ("none") work offline and render as
+  // usual; while the source is still unknown on a disconnected remote we hold.
+  // Gated on the EFFECTIVE side, not the tab's opened side, so flipping the
+  // switch to Remote while offline surfaces the same Connect prompt a
+  // remote-native tab would — the toggle itself stays put (matches
+  // ProjectFilesPane's `useFileSource`).
+  const sshState = useRemoteStatusStore((s) => (projectId ? s.byProject[projectId]?.ssh : undefined));
+  const openRemoteMachines = useRemoteMachinesStore((s) => s.open);
+  const remoteDisconnected = !!project?.remote && sshState !== "connected";
+
+  // Does this file exist on the host? A local-only file (never synced) has no
+  // host counterpart, so flipping the Local/Remote switch to Remote would only
+  // strand the viewer on an SFTP read error — disable that segment instead. Only
+  // knowable on a live pool; disconnected / not-yet-probed leaves it enabled (the
+  // disconnected gate above owns that case). One cheap SFTP stat per remote tab.
+  const [remoteMissing, setRemoteMissing] = useState(false);
+  const remoteRoot = project?.remote?.remote_path;
+  useEffect(() => {
+    setRemoteMissing(false);
+    if (!remoteRoot || !rel || sshState !== "connected") return;
+    let cancelled = false;
+    fileMtime(resolvePath(remoteRoot, rel), projectId)
+      .then(() => { if (!cancelled) setRemoteMissing(false); })
+      .catch(() => { if (!cancelled) setRemoteMissing(true); });
+    return () => { cancelled = true; };
+  }, [remoteRoot, rel, sshState, projectId]);
+  // Mirror the Local/Remote switch out to the tab strip so its file-source badge
+  // is a clickable toggle (not just a glyph): switching applies only when this
+  // remote project's file has a counterpart on the other side (`rel`). Cleared
+  // when it doesn't, and on unmount. Owns no state — `setSideOverride` stays here.
+  useEffect(() => {
+    if (!tabKey) return;
+    const store = useFileSourcesStore.getState();
+    if (project?.remote && rel) {
+      store.setControls(tabKey, {
+        current: effectiveSource === "remote" ? "remote" : "local",
+        set: setSideOverride,
+        remoteDisabled: remoteMissing,
+      });
+    } else {
+      store.clearControls(tabKey);
+    }
+    return () => {
+      if (tabKey) useFileSourcesStore.getState().clearControls(tabKey);
+    };
+  }, [tabKey, project?.remote, rel, effectiveSource, remoteMissing]);
+
+  if (remoteDisconnected && effectiveSource !== "local" && effectiveSource !== "none") {
+    return (
+      <RemotePaneHold
+        host={project?.remote?.host ?? ""}
+        onConnect={() => { if (projectId) openRemoteMachines(projectId); }}
+      />
+    );
+  }
 
   const openExternally = () => {
     useWindowsStore
       .getState()
-      .openFile(path, undefined, projectId, "right_file_tree")
+      .openFile(effectivePath, undefined, projectId, "right_file_tree")
       .catch((e) => console.error(e));
   };
 
-  if (viewer === "image") {
-    return <ImageView path={path} fileName={fileName} onOpenExternally={openExternally} tabKey={tabKey} />;
-  }
-  if (viewer === "pdf") {
-    return <PdfView path={path} onOpenExternally={openExternally} tabKey={tabKey} />;
-  }
-  if (viewer === "markdown") {
-    return <MarkdownView path={path} onOpenExternally={openExternally} tabKey={tabKey} />;
+  // Pick the concrete viewer, then publish this pane's owning project as the file
+  // scope so every nested viewer/hook confines its file commands to this project
+  // (and its box siblings) regardless of which project is globally current.
+  // Every viewer below reads `effectivePath` — the tab's own opened path unless
+  // the Local/Remote switch has retargeted it to the same rel path's other root
+  // — EXCEPT "diff"/"syncdiff", which already compare both sides directly and
+  // whose single `path` prop means something else in that mode.
+  let view: React.ReactNode;
+  if (viewer === "gif") {
+    // Animated GIFs get the frame-transport viewer (#gifviewer); the plain
+    // image viewer remains its opt-out fallback (VIEWER_FALLBACK).
+    view = <GifView path={effectivePath} fileName={fileName} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "image") {
+    view = <ImageView path={effectivePath} fileName={fileName} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "pdf") {
+    view = <PdfView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} groupId={groupId} />;
+  } else if (viewer === "markdown") {
+    view = <MarkdownView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} groupId={groupId} />;
+  } else if (viewer === "tex") {
+    view = <TexView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "table") {
+    view = <TableView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "notebook") {
+    view = <NotebookView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "diff") {
+    view = <DiffView path={path} projectId={projectId} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "syncdiff") {
+    view = <DiffView path={path} projectId={projectId} mode="sync" onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "syncmerge") {
+    view = <SyncMergeView path={path} projectId={projectId} tabKey={tabKey} />;
+  } else if (viewer === "odt") {
+    view = <OdtView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "media") {
+    view = <MediaView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "html") {
+    // HTML is now the editable base editor with a sandboxed live preview, keyed
+    // to its own per-type prefs.
+    view = <TextView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} type="html" groupId={groupId} />;
+  } else if (viewer === "eldeck") {
+    // The presenter is experimental. Gated HERE rather than in `naturalViewerFor`
+    // so a deck still resolves to a viewer for drag-to-tab and the hover card; with
+    // the flag off it opens as what it physically is — JSON — in the structure tree.
+    view = deckOn ? (
+      <DeckView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} groupId={groupId} />
+    ) : (
+      <TextView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} type="yaml" groupId={groupId} />
+    );
+  } else if (viewer === "sqlite") {
+    view = <SqliteView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} />;
+  } else if (viewer === "yaml") {
+    // YAML is the same base editor, with the structure tree as its "preview" half
+    // (#yaml) and its own per-type prefs.
+    view = <TextView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} type="yaml" groupId={groupId} />;
+  } else {
+    view = <TextView path={effectivePath} onOpenExternally={openExternally} tabKey={tabKey} groupId={groupId} />;
   }
-  if (viewer === "tex") {
-    return <TexView path={path} onOpenExternally={openExternally} tabKey={tabKey} />;
+  const sourceSwitch =
+    project?.remote && rel
+      ? {
+          current: (effectiveSource === "remote" ? "remote" : "local") as "local" | "remote",
+          onChange: setSideOverride,
+          remoteDisabled: remoteMissing,
+        }
+      : null;
+  return (
+    <FileScopeContext.Provider value={projectId}>
+      <ViewerHeaderInfoContext.Provider value={{ path: effectivePath, projectId, sourceSwitch }}>
+        {/* A single relative host so the marker/laser presentation overlay can
+            sit over ANY viewer without each one wiring it in (see
+            PresentationOverlay). `.presentation-host` is height:100% so the
+            existing `.file-viewer` (also 100%) fills it unchanged. */}
+        <div className="presentation-host">
+          {view}
+          <PresentationOverlay />
+        </div>
+      </ViewerHeaderInfoContext.Provider>
+    </FileScopeContext.Provider>
+  );
+}
+
+/** The file identity a `ViewerHeader` needs to offer file-scoped actions (the
+ *  auto-sync toggle, the Local/Remote source switch) without every sub-viewer
+ *  threading these props through. Set by `FileViewerPane`; `null` outside a
+ *  viewer pane. `sourceSwitch` is `null` unless the open file resolves to a rel
+ *  path under a remote project's mirror or host root (i.e. the other side could
+ *  exist too). */
+const ViewerHeaderInfoContext = createContext<{
+  path: string;
+  projectId: string | null;
+  sourceSwitch?: {
+    current: "local" | "remote";
+    onChange: (s: "local" | "remote") => void;
+    remoteDisabled?: boolean;
+  } | null;
+} | null>(null);
+
+/** A remote project's local-mirror root, or `null` for a local project / one
+ *  with no resolvable mirror. Shared by `autoSyncRel` and the Local/Remote
+ *  switch's path-building — both need the exact same root. */
+function localMirrorRootFor(
+  project: ReturnType<typeof useProjectsStore.getState>["projects"][number] | undefined,
+): string | null {
+  if (!project?.remote) return null;
+  const projectDir = resolveProjectDirectory(project);
+  return resolveLocalMirror(project) ?? (projectDir ? `${projectDir}/mirror` : null);
+}
+
+/**
+ * Resolve `absPath` to the project-relative path the sync backend keys on, for a
+ * REMOTE project only (auto-sync doesn't apply to local projects). Handles both a
+ * local-mirror file (under the mirror root) and a remote-native file (under the
+ * host `remote_path`). Returns `null` when the project isn't remote or the path
+ * lies outside both roots (so the toggle simply hides).
+ */
+function autoSyncRel(
+  project: ReturnType<typeof useProjectsStore.getState>["projects"][number] | undefined,
+  absPath: string,
+): string | null {
+  if (!project?.remote) return null;
+  const mirrorRoot = localMirrorRootFor(project);
+  if (mirrorRoot) {
+    const r = relFromAbs(mirrorRoot, absPath);
+    if (r) return r;
   }
-  return <TextView path={path} onOpenExternally={openExternally} tabKey={tabKey} />;
+  const r2 = relFromAbs(project.remote.remote_path, absPath);
+  return r2 || null;
+}
+
+/**
+ * Auto-sync indicator + toggle for the viewer header. Shown only for a file that
+ * belongs to a remote project (either its mirror copy or its host copy). Reflects
+ * and flips `SyncEntry::auto_sync` via the sync store; disabled while the remote is
+ * disconnected (the backend engine can't act until reconnected).
+ */
+function AutoSyncHeaderToggle({ path, projectId }: { path: string; projectId: string | null }) {
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const rel = useMemo(() => autoSyncRel(project, path), [project, path]);
+  const auto = useSyncStore((s) =>
+    projectId && rel ? !!s.byProject[projectId]?.[rel]?.auto : false,
+  );
+  const setAuto = useSyncStore((s) => s.setAuto);
+  const sshState = useRemoteStatusStore((s) => (projectId ? s.byProject[projectId]?.ssh : undefined));
+  if (!project?.remote || !rel || !projectId) return null;
+  const connected = sshState === "connected";
+  return (
+    <button
+      type="button"
+      className={`file-viewer-autosync${auto ? " on" : ""}`}
+      title={
+        !connected
+          ? "Auto-sync (connect the remote to change)"
+          : auto
+            ? "Auto-syncing — click to stop"
+            : "Auto-sync this file"
+      }
+      aria-label={auto ? "Stop auto-syncing this file" : "Auto-sync this file"}
+      aria-pressed={auto}
+      disabled={!connected}
+      onClick={() => void setAuto(projectId, [rel], !auto, false)}
+    >
+      ⟳
+    </button>
+  );
+}
+
+/**
+ * "Resolve divergence" button for the viewer header, shown only when the open
+ * file is currently **diverged (amber)** for a remote project. Opens the exact
+ * same three-way merge resolver (`syncmerge` → `SyncMergeView`/`CompareView`) the
+ * orange list opens, so the user can reconcile local mirror ⇄ host from the file
+ * they are already looking at instead of hunting it down in the Orange view.
+ *
+ * The resolver keys on the **mirror-side** path (`mirrorRoot/rel`), exactly as the
+ * orange list builds it, regardless of which side this viewer is currently showing.
+ */
+function SyncResolveHeaderButton({ path, projectId }: { path: string; projectId: string | null }) {
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const rel = useMemo(() => autoSyncRel(project, path), [project, path]);
+  const mirrorRoot = useMemo(() => localMirrorRootFor(project), [project]);
+  const amber = useSyncStore((s) =>
+    projectId && rel ? s.byProject[projectId]?.[rel]?.state === "amber" : false,
+  );
+  if (!project?.remote || !rel || !projectId || !mirrorRoot || !amber) return null;
+  const mirrorPath = resolvePath(mirrorRoot, rel);
+  return (
+    <button
+      type="button"
+      className="file-viewer-resolve"
+      title="This file diverged (local ⇄ host) — open the three-way resolver"
+      aria-label="Resolve divergence"
+      onClick={() =>
+        openLinkedFile(undefined, dirname(mirrorPath), {
+          path: mirrorPath,
+          viewer: "syncmerge",
+          label: basename(mirrorPath),
+        })
+      }
+    >
+      ±
+    </button>
+  );
 }
 
 /**
@@ -265,28 +695,47 @@ export function openLinkedFile(
 }
 
 /** Resolve a markdown local-file href (relative/absolute/`file:`) to an absolute
- *  POSIX path, against the directory of the markdown file `mdPath`. Drops any
- *  `?query`/`#fragment` and percent-decoding, and normalises `.`/`..` segments.
- *  Returns null for an empty target. */
+ *  path against the directory of the markdown file `mdPath`. Drops any
+ *  `?query`/`#fragment`, percent-decodes, and normalises `.`/`..` segments. The
+ *  result keeps `mdPath`'s separator style, so it is correct on Windows (native
+ *  backslashes + drive letter) as well as Unix. Returns null for an empty target. */
 function resolveLocalHref(mdPath: string, href: string): string | null {
-  let h = href.trim().replace(/^file:\/\//i, "").replace(/[?#].*$/, "");
+  let h = href.trim().replace(/[?#].*$/, "");
   if (!h) return null;
+  if (/^file:\/\//i.test(h)) {
+    const decoded = fromFileUri(h);
+    return decoded ? normalizePath(decoded) : null;
+  }
   try { h = decodeURIComponent(h); } catch { /* keep the raw href */ }
-  const dir = mdPath.slice(0, mdPath.lastIndexOf("/"));
-  const combined = h.startsWith("/") ? h : `${dir}/${h}`;
-  const stack: string[] = [];
-  for (const part of combined.split("/")) {
-    if (part === "" || part === ".") continue;
-    if (part === "..") stack.pop();
-    else stack.push(part);
+  return resolvePath(dirname(mdPath), h);
+}
+
+/** MIME type for inlining a local image into the markdown preview as a Blob URL.
+ *  Raster formats render even from a typeless blob (the webview content-sniffs
+ *  the magic bytes), but SVG is XML text the browser will NOT sniff as an image —
+ *  an `<img>` only renders it when the blob is explicitly `image/svg+xml`. That's
+ *  why an SVG in a doc (e.g. README's "At a glance" map) showed blank. We set the
+ *  type for every known extension so all inlined images carry a correct MIME. */
+function imageMimeForPath(p: string): string {
+  const ext = p.slice(p.lastIndexOf(".")).toLowerCase();
+  switch (ext) {
+    case ".svg": return "image/svg+xml";
+    case ".png": return "image/png";
+    case ".jpg":
+    case ".jpeg": return "image/jpeg";
+    case ".gif": return "image/gif";
+    case ".webp": return "image/webp";
+    case ".avif": return "image/avif";
+    case ".bmp": return "image/bmp";
+    case ".ico": return "image/x-icon";
+    default: return "";
   }
-  return "/" + stack.join("/");
 }
 
 /** The built-in viewer for a bare path (no FileEntry handy), used to route a
  *  SyncTeX source target. Defaults to the plain text editor (e.g. `.sty`). */
-function viewerForPath(path: string): InternalViewer {
-  const name = path.slice(path.lastIndexOf("/") + 1);
+export function viewerForPath(path: string): InternalViewer {
+  const name = basename(path);
   const dot = name.lastIndexOf(".");
   const ext = dot >= 0 ? name.slice(dot).toLowerCase() : null;
   const entry: FileEntry = {
@@ -323,8 +772,8 @@ function isMainWindow(): boolean {
 /** Open/re-activate the source tab in THIS window and post the editor jump to its
  *  local editorJump store. The local half of {@link jumpToSource}. */
 function applySourceJump(input: string, line: number, column: number) {
-  const dir = input.slice(0, input.lastIndexOf("/")) || "/";
-  const label = input.slice(input.lastIndexOf("/") + 1);
+  const dir = dirname(input) || "/";
+  const label = basename(input);
   openLinkedFile(undefined, dir, { path: input, viewer: viewerForPath(input), label });
   useEditorJumpStore.getState().requestJump(input, line, column);
 }
@@ -389,7 +838,7 @@ export async function listenSourceJump(): Promise<() => void> {
   }
 }
 
-function ViewerHeader({
+export function ViewerHeader({
   onOpenExternally,
   children,
 }: {
@@ -397,11 +846,25 @@ function ViewerHeader({
   children?: React.ReactNode;
 }) {
   // No filename label: the tab already shows it. The spacer keeps the controls
-  // and the open-externally icon pushed to the trailing edge as before.
+  // and the open-externally icon pushed to the trailing edge. The remote/local
+  // source badge no longer lives here — it rides on the tab itself (see
+  // TabBar's tab-source badge), so it costs no header row. The auto-sync toggle
+  // and the Local/Remote source switch (both remote projects only) ride in from
+  // context so no sub-viewer has to pass them.
+  const info = useContext(ViewerHeaderInfoContext);
   return (
     <div className="file-viewer-header">
       <div className="file-viewer-header-spacer" aria-hidden="true" />
       {children}
+      {info?.sourceSwitch && (
+        <FileSourceSwitch
+          source={info.sourceSwitch.current}
+          onChange={info.sourceSwitch.onChange}
+          remoteDisabled={info.sourceSwitch.remoteDisabled}
+        />
+      )}
+      {info && <SyncResolveHeaderButton path={info.path} projectId={info.projectId} />}
+      {info && <AutoSyncHeaderToggle path={info.path} projectId={info.projectId} />}
       <button
         className="file-viewer-open-external"
         onClick={onOpenExternally}
@@ -418,6 +881,15 @@ function ViewerHeader({
 
 /** Edit-history state: a stack of past values, the present value, and a redo
  *  stack of future values. Pure so it can be unit-tested without React. */
+/** Imperative editing surface exposed by {@link CodeEditor} via `editorApiRef`,
+ *  letting a toolbar transform the live value+selection. */
+export interface EditorApi {
+  /** Run `fn` over the current value and selection `[start, end)`, commit the
+   *  result through the editor's normal edit path, and restore the returned
+   *  selection. */
+  applyEdit: (fn: (value: string, start: number, end: number) => EditResult) => void;
+}
+
 export interface EditHistory {
   past: string[];
   present: string;
@@ -479,6 +951,30 @@ export function editHistoryReducer(state: EditHistory, action: EditAction): Edit
 // Coalesce keystrokes within this window into a single undo step.
 const COALESCE_MS = 400;
 
+// #45 automatic autocomplete: idle time after the last keystroke before a
+// suggestion is requested for the focused editor. Long enough not to fire on
+// every keystroke, short enough to feel responsive.
+const AUTO_AC_DEBOUNCE_MS = 600;
+
+// #45 follow-up grammar check: idle time after the last keystroke before the
+// whole draft is re-checked. Longer than the autocomplete debounce — a full-
+// document check is heavier, and grammar marks needn't track every keystroke.
+const GRAMMAR_DEBOUNCE_MS = 2500;
+
+// #45 completion-length modes. Cycle order for the live Shift+Tab toggle (while
+// a ghost suggestion is showing) and human labels for the status line / settings
+// dropdown. Kept in sync with the Rust `CompletionMode`.
+const AC_MODES: AutocompleteMode[] = ["sentence", "block", "scope"];
+const AC_MODE_LABELS: Record<AutocompleteMode, string> = {
+  sentence: "Sentence",
+  block: "Block",
+  scope: "Scope",
+};
+/** Next mode in the cycle (wraps), for the live Shift+Tab toggle. */
+function nextAcMode(m: AutocompleteMode): AutocompleteMode {
+  return AC_MODES[(AC_MODES.indexOf(m) + 1) % AC_MODES.length];
+}
+
 /** React wrapper over `editHistoryReducer` exposing `value`, a coalescing
  *  `setValue`, `undo`/`redo` (+ availability), and `reset`. */
 function useEditHistory(initial: string) {
@@ -513,27 +1009,28 @@ function useEditHistory(initial: string) {
   };
 }
 
-// Poll interval for the diff-aware auto-reload (#43) and the autosave debounce
-// (#47), both ~1.5s.
+// Poll interval for the diff-aware auto-reload (#43), ~1.5s.
 const RELOAD_POLL_MS = 1500;
-const AUTOSAVE_DEBOUNCE_MS = 1500;
 
 /**
- * Editable-file state shared by the code and markdown editors: loads `path`,
- * keeps a `draft` against the last-known-on-disk `baseline` (so "dirty" is just
- * draft !== baseline), and writes the draft back via write_file_text — re-seeding
- * the baseline on success so the dirty flag clears without re-reading the file.
+ * Editable-file state shared by the editable viewers — the code and markdown
+ * editors, and the table viewer, whose cell edits are splices into this same
+ * text draft (see `lib/viewers/table.ts`): loads `path`, keeps a `draft` against
+ * the last-known-on-disk `baseline` (so "dirty" is just draft !== baseline), and
+ * writes the draft back via write_file_text — re-seeding the baseline on success
+ * so the dirty flag clears without re-reading the file.
  *
  * Adds (Group M):
  *  - #46 undo/redo: the draft is backed by `useEditHistory`; `undo`/`redo` are
  *    surfaced for keybindings + toolbar buttons.
- *  - #47 autosave: when `settings.autosave` is on, a dirty buffer is saved after
- *    a debounce.
+ *  - #47 autosave: when `settings.autosave` is on, a dirty buffer is saved on
+ *    every change (each keystroke).
  *  - #43 diff-aware reload: polls `file_mtime`; when the file changes on disk it
  *    silently re-reads into a clean buffer, or surfaces a non-destructive banner
  *    when the buffer is dirty (Reload / Keep mine) — never clobbering edits.
  */
-function useEditableFile(path: string) {
+export function useEditableFile(path: string) {
+  const scope = useFileScope();
   const [content, setContent] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [baseline, setBaseline] = useState<string | null>(null);
@@ -577,17 +1074,17 @@ function useEditableFile(path: string) {
     setBaseline(null);
     setExternalChange(false);
     lastMtime.current = null;
-    invoke<string>("read_file_text", { path })
+    readFileText(path, scope)
       .then((text) => {
         if (cancelled) return;
         seedFromDisk(text);
       })
-      .catch((e) => { if (!cancelled) setError(String(e)); });
-    invoke<number>("file_mtime", { path })
+      .catch((e) => { if (!cancelled) setError(describeFileError(e)); });
+    fileMtime(path, scope)
       .then((m) => { if (!cancelled) lastMtime.current = m; })
       .catch(() => {});
     return () => { cancelled = true; };
-  }, [path, seedFromDisk]);
+  }, [path, scope, seedFromDisk]);
 
   const loaded = content != null;
   const isDirty = loaded && baseline != null && draft !== baseline;
@@ -600,13 +1097,13 @@ function useEditableFile(path: string) {
     setSaveError(null);
     try {
       const toSave = draftRef.current;
-      await invoke("write_file_text", { path, content: toSave });
+      await writeFileText(path, toSave, scope);
       setBaseline(toSave);
       setExternalChange(false);
       // Our own write advances mtime; refresh so the poller doesn't see it as an
       // external change.
       try {
-        lastMtime.current = await invoke<number>("file_mtime", { path });
+        lastMtime.current = await fileMtime(path, scope);
       } catch {
         /* mtime refresh is best-effort */
       }
@@ -615,13 +1112,13 @@ function useEditableFile(path: string) {
     } finally {
       setSaving(false);
     }
-  }, [saving, path]);
+  }, [saving, path, scope]);
 
-  // #47 autosave: debounce-save a dirty buffer when the setting is on.
+  // #47 autosave: when the setting is on, write the buffer to disk on every
+  // change — each keystroke as well as the moment autosave is toggled on with
+  // unsaved edits. `save()` no-ops when the buffer is clean or already saving.
   useEffect(() => {
-    if (!autosave || !isDirty) return;
-    const id = setTimeout(() => { void save(); }, AUTOSAVE_DEBOUNCE_MS);
-    return () => clearTimeout(id);
+    if (autosave && isDirty) void save();
   }, [autosave, isDirty, draft, save]);
 
   // #43 diff-aware reload: poll mtime; on an external advance, re-read into a
@@ -630,7 +1127,7 @@ function useEditableFile(path: string) {
     if (!loaded) return;
     let cancelled = false;
     const id = setInterval(() => {
-      invoke<number>("file_mtime", { path })
+      fileMtime(path, scope)
         .then((m) => {
           if (cancelled || lastMtime.current == null) return;
           if (m <= lastMtime.current) return;
@@ -641,22 +1138,22 @@ function useEditableFile(path: string) {
             return;
           }
           // Clean buffer → silently re-read + reseed baseline/draft.
-          invoke<string>("read_file_text", { path })
+          readFileText(path, scope)
             .then((text) => { if (!cancelled) seedFromDisk(text); })
             .catch(() => {});
         })
         .catch(() => {});
     }, RELOAD_POLL_MS);
     return () => { cancelled = true; clearInterval(id); };
-  }, [path, loaded, seedFromDisk]);
+  }, [path, scope, loaded, seedFromDisk]);
 
   // Banner actions (#43): take the disk version, or keep mine (dismiss banner +
   // adopt current mtime so the next external change re-triggers).
   const reloadFromDisk = useCallback(() => {
-    invoke<string>("read_file_text", { path })
+    readFileText(path, scope)
       .then((text) => seedFromDisk(text))
       .catch((e) => setSaveError(String(e)));
-  }, [path, seedFromDisk]);
+  }, [path, scope, seedFromDisk]);
   const keepMine = useCallback(() => setExternalChange(false), []);
 
   return {
@@ -667,7 +1164,7 @@ function useEditableFile(path: string) {
 }
 
 /** The non-destructive external-change banner (#43). */
-function ExternalChangeBanner({
+export function ExternalChangeBanner({
   onReload,
   onKeep,
 }: {
@@ -687,7 +1184,7 @@ const INDENT = "    "; // 4 spaces — what Tab inserts and Shift+Tab strips.
 
 /** Apply Tab / Shift+Tab indentation to a code textarea, preserving selection.
  *  Returns the next value + selection, or null to let the key fall through. */
-function applyIndent(
+export function applyIndent(
   el: HTMLTextAreaElement,
   outdent: boolean,
 ): { value: string; selStart: number; selEnd: number } | null {
@@ -744,13 +1241,61 @@ function applyIndent(
  * so the indent/scroll/save behaviour stays identical between them. Renders the
  * load/error states itself; the caller wires it to a `useEditableFile` instance.
  */
-function escapeHtmlText(s: string): string {
+export function escapeHtmlText(s: string): string {
   return s
     .replace(/&/g, "&amp;")
     .replace(/</g, "&lt;")
     .replace(/>/g, "&gt;");
 }
 
+/**
+ * Read-only sibling of `useEditableFile` for the table/notebook/diff viewers
+ * (none of which edit on disk). Loads the file once via `read_file_text` and
+ * polls `file_mtime`, silently re-reading when the file changes underneath — the
+ * same load/refresh path `useEditableFile` uses, minus all the draft/undo/save
+ * machinery. Returns the raw text (or null while loading) and an error string.
+ */
+export function useReadonlyFile(path: string) {
+  const scope = useFileScope();
+  const [content, setContent] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const lastMtime = useRef<number | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    setContent(null);
+    setError(null);
+    lastMtime.current = null;
+    readFileText(path, scope)
+      .then((text) => { if (!cancelled) setContent(text); })
+      .catch((e) => { if (!cancelled) setError(describeFileError(e)); });
+    fileMtime(path, scope)
+      .then((m) => { if (!cancelled) lastMtime.current = m; })
+      .catch(() => {});
+    return () => { cancelled = true; };
+  }, [path, scope]);
+
+  // Diff-aware reload: poll mtime and silently re-read on an external advance.
+  useEffect(() => {
+    if (content == null) return;
+    let cancelled = false;
+    const id = setInterval(() => {
+      fileMtime(path, scope)
+        .then((m) => {
+          if (cancelled || lastMtime.current == null || m <= lastMtime.current) return;
+          lastMtime.current = m;
+          readFileText(path, scope)
+            .then((text) => { if (!cancelled) setContent(text); })
+            .catch(() => {});
+        })
+        .catch(() => {});
+    }, RELOAD_POLL_MS);
+    return () => { cancelled = true; clearInterval(id); };
+  }, [path, scope, content]);
+
+  return { content, error, loaded: content != null };
+}
+
 /**
  * Build a transparent decoration layer (#49) where the `ranges` are wrapped in
  * `<span class="file-link">` so they read as clickable (dotted underline). The
@@ -831,6 +1376,23 @@ export function decorateSearchRanges(
  * zero-width in `next`, so there is nothing to paint).
  */
 export function diffRange(prev: string, next: string): { start: number; end: number } | null {
+  const span = editSpan(prev, next);
+  return span && span.endNext > span.start ? { start: span.start, end: span.endNext } : null;
+}
+
+/**
+ * The full span of an edit between `prev` and `next`: `start` is the common
+ * prefix length, `endPrev`/`endNext` are where the differing run ends in each
+ * string (so `prev.slice(start, endPrev)` was replaced by `next.slice(start,
+ * endNext)`). Unlike `diffRange` this is reported for deletions too (where
+ * `endNext === start`), since the change-tint trail must still re-map older
+ * ranges through a deletion. Returns `null` only for equal strings. Pure —
+ * exported for tests.
+ */
+export function editSpan(
+  prev: string,
+  next: string,
+): { start: number; endPrev: number; endNext: number } | null {
   if (prev === next) return null;
   const max = Math.min(prev.length, next.length);
   let start = 0;
@@ -841,27 +1403,225 @@ export function diffRange(prev: string, next: string): { start: number; end: num
     endPrev--;
     endNext--;
   }
-  return endNext > start ? { start, end: endNext } : null;
+  return { start, endPrev, endNext };
+}
+
+/** How many recent edit runs the change-tint trail keeps (and how many colour
+ *  tiers `themes.css` defines, `.tier-0` … `.tier-(N-1)`). */
+export const CHANGE_TIERS = 18;
+/** Idle delay before the trail retires its oldest run, in ms — once typing stops
+ *  the trail fades a tier at a time over CHANGE_TIERS × this. */
+const CHANGE_DECAY_MS = 1800;
+
+/** How long a red strike-through ghost of just-deleted text lingers before it
+ *  fades out and is dropped, in ms. Must match the `fv-delete-fade` animation
+ *  duration in `themes.css` — the CSS drives the visual fade, this drives the
+ *  state cleanup, and they retire the ghost together. */
+export const DELETE_GHOST_MS = 2600;
+
+/** A run of text that was just removed from the draft, kept around briefly so it
+ *  can be shown struck-through in red at the spot it vanished from before fading
+ *  out. `pos` is the anchor in *current* draft coordinates (re-mapped through
+ *  later edits like a change range); `text` is the removed characters; `born` is
+ *  the `Date.now()` clock the fade animation is offset against so it keeps
+ *  elapsing correctly even as the overlay is rebuilt on each keystroke. */
+export interface DeleteGhost {
+  id: number;
+  pos: number;
+  text: string;
+  born: number;
 }
 
 /**
- * Build the transparent last-change overlay: the single `{start, end}` range is
- * wrapped in `<span class="file-viewer-change-mark">` so only it paints a tint,
- * the rest emitted plain. SECURITY: every run is HTML-escaped — mirrors
- * `decorateSearchRanges`.
+ * Build the transparent deletion overlay: the removed text of each ghost is
+ * *injected* back into the source at its anchor, wrapped in
+ * `<span class="file-viewer-delete-mark">`, so it paints a red strike-through
+ * (over an opaque background that masks the live text it now overlays) right
+ * where it was deleted. The surrounding source is emitted plain/transparent —
+ * like the autocomplete ghost, this layer intentionally reflows: only the
+ * injected marks are meant to show. Each mark's `animation-delay` is set to the
+ * negative elapsed time so its fade resumes at the right point across rebuilds.
+ * SECURITY: every run (source and injected text) is HTML-escaped.
  */
-export function decorateChangeRange(
+export function decorateDeleteRanges(
   source: string,
+  ghosts: DeleteGhost[],
+  now: number,
+): string {
+  const sorted = ghosts
+    .map((g) => ({ ...g, pos: Math.max(0, Math.min(g.pos, source.length)) }))
+    .sort((a, b) => a.pos - b.pos || a.born - b.born);
+  let out = "";
+  let pos = 0;
+  for (const g of sorted) {
+    out += escapeHtmlText(source.slice(pos, g.pos));
+    pos = g.pos;
+    const elapsed = Math.max(0, now - g.born);
+    out += `<span class="file-viewer-delete-mark" style="animation-delay:-${elapsed}ms">${escapeHtmlText(
+      g.text,
+    )}</span>`;
+  }
+  out += escapeHtmlText(source.slice(pos));
+  return out;
+}
+
+/** The text a deletion ghost should strike through for a removed run: the run
+ *  with surrounding whitespace trimmed off, or null when it was whitespace-only
+ *  (nothing visible to cross out — a lingering space-only strike would just read
+ *  as invisible text). Pure — exported for tests. */
+export function deletionGhostText(removed: string): string | null {
+  const trimmed = removed.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+/** One run of recently typed text in the change-tint trail. `tier` is its age:
+ *  0 is the newest edit, higher tiers are progressively older (and fainter). */
+export interface ChangeRange {
+  start: number;
+  end: number;
+  tier: number;
+}
+
+/**
+ * Re-map an existing change range through a new edit so it keeps pointing at the
+ * same characters: untouched if it sits entirely before the edit, shifted by the
+ * length delta if entirely after, and dropped (returns `null`) if it overlaps the
+ * edited region (its text was overwritten). Pure — exported for tests.
+ */
+export function remapChangeRange(
   range: { start: number; end: number },
+  span: { start: number; endPrev: number; endNext: number },
+): { start: number; end: number } | null {
+  const delta = span.endNext - span.endPrev;
+  if (range.end <= span.start) return range;
+  if (range.start >= span.endPrev) {
+    return { start: range.start + delta, end: range.end + delta };
+  }
+  return null;
+}
+
+/**
+ * Build the transparent change-tint overlay: each recent edit range is wrapped in
+ * `<span class="file-viewer-change-mark tier-N">` so it paints its age-graded
+ * tint (tier 0 newest), the rest emitted plain. Ranges must be non-overlapping;
+ * they are sorted left-to-right here. SECURITY: every run is HTML-escaped —
+ * mirrors `decorateSearchRanges`.
+ */
+export function decorateChangeRanges(
+  source: string,
+  ranges: ChangeRange[],
 ): string {
-  const start = Math.max(0, Math.min(range.start, source.length));
-  const end = Math.max(start, Math.min(range.end, source.length));
-  if (end <= start) return escapeHtmlText(source);
-  return (
-    escapeHtmlText(source.slice(0, start)) +
-    `<span class="file-viewer-change-mark">${escapeHtmlText(source.slice(start, end))}</span>` +
-    escapeHtmlText(source.slice(end))
-  );
+  const clamped = ranges
+    .map((r) => ({
+      start: Math.max(0, Math.min(r.start, source.length)),
+      end: Math.max(0, Math.min(r.end, source.length)),
+      tier: r.tier,
+    }))
+    .filter((r) => r.end > r.start)
+    .sort((a, b) => a.start - b.start);
+  if (clamped.length === 0) return escapeHtmlText(source);
+  let out = "";
+  let pos = 0;
+  for (const r of clamped) {
+    if (r.start < pos) continue; // defensive: skip any residual overlap
+    out += escapeHtmlText(source.slice(pos, r.start));
+    out += `<span class="file-viewer-change-mark tier-${r.tier}">${escapeHtmlText(
+      source.slice(r.start, r.end),
+    )}</span>`;
+    pos = r.end;
+  }
+  out += escapeHtmlText(source.slice(pos));
+  return out;
+}
+
+/** A grammar issue resolved to a concrete `{start, end}` character range in the
+ *  current draft, carrying its originating issue for the tooltip / apply-fix. */
+export interface GrammarRange {
+  start: number;
+  end: number;
+  issue: GrammarIssue;
+}
+
+/**
+ * Resolve each model-reported grammar issue to a character range in `text`. The
+ * model reports the offending substring `bad` plus its 1-based `line`; we search
+ * that line first (so duplicates of a word map to the right occurrence), then
+ * fall back to the whole document, so a small edit since the check doesn't drop
+ * every mark. Issues resolve in order with a per-line cursor, so several errors
+ * on one line each map to their own occurrence. Unlocatable issues are skipped;
+ * the result is sorted by start with overlaps pruned so the decorator's
+ * left-to-right walk stays clean. Pure — exported for tests.
+ */
+export function resolveGrammarRanges(text: string, issues: GrammarIssue[]): GrammarRange[] {
+  if (issues.length === 0) return [];
+  // 0-based offset where each 1-based line begins (lineStarts[n-1] = line n).
+  const lineStarts: number[] = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "\n") lineStarts.push(i + 1);
+  }
+  // Per-line search cursor so repeated errors on a line advance past each other.
+  const lineCursor = new Map<number, number>();
+  const out: GrammarRange[] = [];
+  for (const issue of issues) {
+    const bad = issue.bad;
+    if (!bad) continue;
+    let start = -1;
+    const li = issue.line - 1;
+    if (li >= 0 && li < lineStarts.length) {
+      const lineStart = lineStarts[li];
+      const lineEnd = li + 1 < lineStarts.length ? lineStarts[li + 1] : text.length;
+      const from = Math.max(lineStart, lineCursor.get(li) ?? lineStart);
+      const idx = text.indexOf(bad, from);
+      if (idx >= 0 && idx < lineEnd) {
+        start = idx;
+        lineCursor.set(li, idx + bad.length);
+      }
+    }
+    if (start < 0) {
+      // The reported line drifted since the check — locate it anywhere.
+      const idx = text.indexOf(bad);
+      if (idx >= 0) start = idx;
+    }
+    if (start < 0) continue;
+    out.push({ start, end: start + bad.length, issue });
+  }
+  out.sort((a, b) => a.start - b.start);
+  const pruned: GrammarRange[] = [];
+  let lastEnd = -1;
+  for (const r of out) {
+    if (r.start < lastEnd) continue; // drop overlaps
+    pruned.push(r);
+    lastEnd = r.end;
+  }
+  return pruned;
+}
+
+/**
+ * Build the transparent grammar overlay: each range is wrapped in a
+ * `<span class="file-viewer-grammar-mark cat-<category>" data-gi="<i>">` so it
+ * paints a coloured wavy underline (colour by category) while the surrounding
+ * text stays plain/transparent. The `data-gi` index ties a span back to its
+ * `ranges` entry for hover hit-testing. SECURITY: every run of source text is
+ * HTML-escaped before output — mirrors `decorateSearchRanges`.
+ */
+export function decorateGrammarRanges(source: string, ranges: GrammarRange[]): string {
+  if (ranges.length === 0) return escapeHtmlText(source);
+  let out = "";
+  let pos = 0;
+  ranges.forEach((r, i) => {
+    if (r.start < pos || r.start >= r.end) return; // skip overlaps / empties
+    out += escapeHtmlText(source.slice(pos, r.start));
+    const cat =
+      r.issue.category === "spelling" || r.issue.category === "style"
+        ? r.issue.category
+        : "grammar";
+    out += `<span class="file-viewer-grammar-mark cat-${cat}" data-gi="${i}">${escapeHtmlText(
+      source.slice(r.start, r.end),
+    )}</span>`;
+    pos = r.end;
+  });
+  out += escapeHtmlText(source.slice(pos));
+  return out;
 }
 
 /**
@@ -919,7 +1679,7 @@ function useDevicePixelRatio(): number {
  * grid, so the per-line advance is identical and nothing accumulates. A no-op at
  * an integer dpr (e.g. 1.0 or 2.0), where the drift never appeared.
  */
-function snapToDevicePx(cssPx: number, dpr: number): number {
+export function snapToDevicePx(cssPx: number, dpr: number): number {
   return Math.round(cssPx * dpr) / dpr;
 }
 
@@ -1005,6 +1765,7 @@ function CodeEditor({
   undo,
   redo,
   autocomplete,
+  grammarCheck,
   texCompletions,
   fontSize,
   lineHeight,
@@ -1016,8 +1777,14 @@ function CodeEditor({
   onGotoApplied,
   onCaretChange,
   caretApiRef,
+  editorApiRef,
+  showBlame,
+  blame,
+  breakpoints,
+  onToggleBreakpoint,
   initialScrollTop,
   onScrollPersist,
+  groupId,
 }: {
   error: string | null;
   draft: string;
@@ -1044,14 +1811,27 @@ function CodeEditor({
    *  no caret event fired this session — `onCaretChange`/its snapshot can be a
    *  stale 0 (e.g. the editor was never focused, or a WebKitGTK blur reset it). */
   caretApiRef?: React.MutableRefObject<(() => number | null) | null>;
+  /** When set, receives an imperative editing API so a toolbar (the Markdown
+   *  viewer's bold/italic/heading/… controls) can transform the current
+   *  value+selection; edits commit through the normal path so undo/redo and the
+   *  syntax overlay stay consistent. Cleared on unmount. */
+  editorApiRef?: React.MutableRefObject<EditorApi | null>;
   /** When set, returns the source ranges to decorate as clickable file links
    *  (#49). Currently the LaTeX viewer's `\input{…}`/`\includegraphics{…}` args. */
   linkRanges?: (source: string) => { start: number; end: number }[];
   /** Undo/redo handlers (#46) — wired to Ctrl+Z / Ctrl+Shift+Z / Ctrl+Y. */
   undo?: () => void;
   redo?: () => void;
-  /** Opt-in local autocomplete config (#45). Disabled when undefined/off. */
-  autocomplete?: { enabled: boolean; model: string };
+  /** Opt-in local autocomplete config (#45). Disabled when undefined/off.
+   *  `preferred` is the user's active local model (🧠 menu); the completion runs
+   *  against whichever model is *currently loaded* in Ollama memory at trigger
+   *  time, preferring `preferred` when it is among the loaded set. */
+  autocomplete?: { enabled: boolean; preferred?: string; mode?: AutocompleteMode };
+  /** Opt-in local grammar/spelling check (#45 follow-up). When enabled, the whole
+   *  draft is checked against the currently-loaded local model after an idle
+   *  pause; issues are underlined (colour by category) with a hover tooltip and
+   *  one-click fix. `preferred` is the user's active local model (🧠 menu). */
+  grammarCheck?: { enabled: boolean; preferred?: string };
   /** Opt-in `\ref`/`\cite` key completion (LaTeX viewer only). When supplied, a
    *  dropdown of `\label` keys (refs) or `.bib` entry keys (cites) appears while
    *  typing inside a recognised command's braces; Enter/Tab accepts. */
@@ -1067,6 +1847,19 @@ function CodeEditor({
    *  (used by the LaTeX viewer, whose prose lines run wide). The highlight/link/
    *  ghost overlays wrap in lockstep via the `is-wrapped` class. */
   wrap?: boolean;
+  /** Git-blame overlay (#blame). When `showBlame` is set, a per-line blame column
+   *  is painted in the gutter (scroll-locked with the line numbers) and the
+   *  caret's line gets a faint inline attribution; hovering a blame cell shows a
+   *  hovercard. `blame` maps 1-based line numbers to their attribution. */
+  showBlame?: boolean;
+  blame?: Map<number, BlameLine>;
+  /** Debug breakpoints (#py), as 1-based line numbers. When `onToggleBreakpoint`
+   *  is wired the gutter becomes interactive: each line number is a click target
+   *  that toggles a breakpoint, and a breakpointed line paints a red dot. Only the
+   *  Python editor supplies these; every other file type gets the inert,
+   *  aria-hidden gutter it had before. */
+  breakpoints?: ReadonlySet<number>;
+  onToggleBreakpoint?: (line: number) => void;
   /** Persisted vertical scroll (px) to restore once the file loads, so reopening
    *  it (or an Eldrun restart) lands the reader where they left off (#viewerpos).
    *  Applied once on first load; user scrolling thereafter reports via
@@ -1075,13 +1868,23 @@ function CodeEditor({
   /** Called (throttled) with the textarea's `scrollTop` as the reader scrolls, so
    *  the position can be persisted. */
   onScrollPersist?: (scrollTop: number) => void;
+  /** When set, the subwindow (group) id hosting this editor, so its scroll is
+   *  proportionally linked to a side-by-side viewer subwindow (scrollSync). */
+  groupId?: string | null;
 }) {
   const textareaRef = useRef<HTMLTextAreaElement>(null);
+  // Proportional scroll-link to a paired subwindow (no-op unless linked).
+  const reportScrollSync = useScrollSync(groupId, textareaRef);
   const gutterInnerRef = useRef<HTMLDivElement>(null);
+  const blameInnerRef = useRef<HTMLDivElement>(null);
+  const blameInlineRef = useRef<HTMLDivElement>(null);
   const highlightRef = useRef<HTMLPreElement>(null);
   const linkLayerRef = useRef<HTMLPreElement>(null);
   const searchLayerRef = useRef<HTMLPreElement>(null);
   const changeLayerRef = useRef<HTMLPreElement>(null);
+  const deleteLayerRef = useRef<HTMLPreElement>(null);
+  const grammarLayerRef = useRef<HTMLPreElement>(null);
+  const ghostRef = useRef<HTMLPreElement>(null);
   const measureRef = useRef<HTMLPreElement>(null);
   const findInputRef = useRef<HTMLInputElement>(null);
   // Link affordances over a recognised link (#49), only when `onFollowLink` is
@@ -1096,6 +1899,10 @@ function CodeEditor({
   // hovering a link (no mouse move) can still update the cursor.
   const lastMouse = useRef<{ x: number; y: number } | null>(null);
 
+  // Ctrl/Cmd+wheel resizes the font. Bound non-passively (see useNonPassiveWheel)
+  // so it never falls through to native scrolling.
+  const wheelRef = useNonPassiveWheel((e) => onCtrlWheelFont(e, incFont, decFont));
+
   // Resolve the link affordances for the screen point `x,y`. The link layer is
   // scroll-synced to sit exactly over the textarea text, so its `.file-link` span
   // rects are the on-screen link hit boxes — no glyph metrics needed.
@@ -1123,7 +1930,75 @@ function CodeEditor({
 
   // #45 autocomplete: a pending ghost-text suggestion + the caret it applies at.
   const [suggestion, setSuggestion] = useState<{ text: string; at: number } | null>(null);
+  // A short status shown to the user when a completion is in flight, returns
+  // nothing, or can't run (e.g. no local model loaded) — otherwise the feature
+  // fails silently and reads as broken. A trailing "…" marks a transient
+  // in-flight message; final messages auto-dismiss (see the effect below).
+  const [acStatus, setAcStatus] = useState<string | null>(null);
   const acAbort = useRef<AbortController | null>(null);
+  // #45 live completion-length mode: starts from the per-type default and is
+  // cycled in-editor with Shift+Tab while a suggestion is showing. Re-seeded if
+  // the per-type default changes (e.g. the user picks a new default in settings).
+  const [acMode, setAcMode] = useState<AutocompleteMode>(autocomplete?.mode ?? "sentence");
+  useEffect(() => {
+    setAcMode(autocomplete?.mode ?? "sentence");
+  }, [autocomplete?.mode]);
+
+  // Auto-dismiss a finished autocomplete status after a few seconds; keep the
+  // in-flight "…" message until the request resolves.
+  useEffect(() => {
+    if (!acStatus || acStatus.endsWith("…")) return;
+    const id = window.setTimeout(() => setAcStatus(null), 4000);
+    return () => window.clearTimeout(id);
+  }, [acStatus]);
+
+  // #45 context files: extra project files the user attaches as read-only context
+  // for completion. Per-editor (not persisted); each entry caches the file's text
+  // at attach time so requests don't re-read disk on every keystroke. `acPicker`
+  // toggles the QuickOpen-style file picker.
+  const [contextFiles, setContextFiles] = useState<
+    { rel: string; path: string; content: string }[]
+  >([]);
+  const [acPicker, setAcPicker] = useState(false);
+  const scope = useFileScope();
+
+  // Resolve the project the edited file belongs to (the longest project directory
+  // that is a prefix of `path`), falling back to the active project — so the
+  // context-file picker lists the right project even in a detached window.
+  const acProjectDir = useMemo(() => {
+    const { projects, activeId } = useProjectsStore.getState();
+    let best = "";
+    for (const p of projects) {
+      const dir = resolveProjectDirectory(p);
+      if (dir && isPathWithin(path, dir) && dir.length > best.length) {
+        best = dir;
+      }
+    }
+    if (best) return best;
+    const active = projects.find((p) => p.id === activeId);
+    return active ? resolveProjectDirectory(active) : "";
+  }, [path]);
+
+  const addContextFile = useCallback(
+    async (rel: string) => {
+      if (!acProjectDir) return;
+      const abs = `${acProjectDir}/${rel}`;
+      if (contextFiles.some((f) => f.path === abs)) return; // already attached
+      try {
+        const content = await readFileText(abs, scope);
+        setContextFiles((prev) =>
+          prev.some((f) => f.path === abs) ? prev : [...prev, { rel, path: abs, content }],
+        );
+      } catch {
+        /* unreadable file: silently skip */
+      }
+    },
+    [acProjectDir, contextFiles, scope],
+  );
+
+  const removeContextFile = useCallback((abs: string) => {
+    setContextFiles((prev) => prev.filter((f) => f.path !== abs));
+  }, []);
 
   // \ref/\cite key completion (LaTeX viewer): the open dropdown's context, the
   // filtered items, the highlighted index, and the screen anchor. A caret tick
@@ -1171,6 +2046,15 @@ function CodeEditor({
   // appears — and the caret drifts from the coloured glyphs over wrapped lines.
   // Constraining the overlays to this width makes every layer wrap identically.
   const [wrapWidth, setWrapWidth] = useState<number | null>(null);
+  // Last `clientWidth` the textarea was re-broken at. A vertical scrollbar
+  // appearing/disappearing as the document grows past the editor height changes
+  // clientWidth WITHOUT changing the border box, so the ResizeObserver below
+  // never fires and the textarea keeps its stale wrapping (WebKitGTK won't
+  // re-break on its own — see the nudge there). The overlay <pre>s, sized to the
+  // fresh clientWidth each keystroke, then wrap at a different width, so the
+  // coloured glyphs and the last-change tint drift down a row. Tracking the
+  // width here lets the wrap layout effect nudge a re-break when it shifts.
+  const prevClientWidth = useRef<number | null>(null);
 
   // Syntax-highlighted HTML rendered in a <pre> layer behind a transparent
   // textarea, so the file colours by type while staying fully editable. `null`
@@ -1208,10 +2092,32 @@ function CodeEditor({
     if (gutterInnerRef.current) {
       gutterInnerRef.current.style.transform = `translateY(${-scrollTop}px)`;
     }
+    // Blame column + current-line inline hint scroll-lock vertically with the
+    // numbers (they never shift horizontally, so translateY only).
+    if (blameInnerRef.current) {
+      blameInnerRef.current.style.transform = `translateY(${-scrollTop}px)`;
+    }
+    if (blameInlineRef.current) {
+      blameInlineRef.current.style.transform = `translateY(${-scrollTop}px)`;
+    }
     const transform = `translate(${-scrollLeft}px, ${-scrollTop}px)`;
-    for (const ref of [highlightRef, linkLayerRef, searchLayerRef, changeLayerRef]) {
+    for (const ref of [
+      highlightRef,
+      linkLayerRef,
+      searchLayerRef,
+      changeLayerRef,
+      deleteLayerRef,
+      grammarLayerRef,
+    ]) {
       if (ref.current) ref.current.style.transform = transform;
     }
+    // The ghost layer keeps the inset/overflow:hidden model (it masks the layers
+    // beneath with an opaque background, so it can't be sized to its own content
+    // like the transform-synced layers); scroll it programmatically instead.
+    if (ghostRef.current) {
+      ghostRef.current.scrollTop = scrollTop;
+      ghostRef.current.scrollLeft = scrollLeft;
+    }
   }, []);
 
   // #viewerpos: restore the saved scroll once the file has loaded (and the
@@ -1235,6 +2141,7 @@ function CodeEditor({
   const persistTimer = useRef<number | null>(null);
   const onScroll = () => {
     syncScroll();
+    reportScrollSync();
     if (!onScrollPersist || !restoredScroll.current) return;
     const ta = textareaRef.current;
     if (!ta) return;
@@ -1284,6 +2191,58 @@ function CodeEditor({
     return m ? offsetToLineCol(draft, m.start).line : 0;
   }, [matches, current, draft]);
 
+  // ── Git blame overlay (#blame) ─────────────────────────────────────────────
+  // When `showBlame` is set, the gutter grows a per-line blame column (its own
+  // inner, scroll-synced with the numbers), the caret's line gets a faint inline
+  // attribution, and hovering a blame cell shows a hovercard. All read-only —
+  // nothing here touches the editable textarea/highlight/save path.
+  const [caretLine, setCaretLine] = useState(1);
+  const [blameTip, setBlameTip] = useState<{ left: number; top: number; line: number } | null>(null);
+  const effectiveLineHeight = lineHeight ?? Math.round((fontSize ?? 12) * 1.5);
+
+  // Top offset (px, before scroll) of a 1-based line's first row. Mirrors the
+  // gutter/editor 10px top padding and the wrap-mode measured `lineHeights`.
+  const lineTop = useCallback(
+    (line: number) => {
+      let top = 10; // `.file-viewer-highlight/-editor` padding-top
+      const idx = Math.max(0, line - 1);
+      if (wrap && lineHeights.length) {
+        for (let i = 0; i < idx && i < lineHeights.length; i++) top += lineHeights[i];
+      } else {
+        top += idx * effectiveLineHeight;
+      }
+      return top;
+    },
+    [wrap, lineHeights, effectiveLineHeight],
+  );
+
+  const caretBlame = showBlame ? blame?.get(caretLine) : undefined;
+
+  // Age-tint a blame cell: newer commits are more saturated, decaying with age
+  // so the column reads as a heat-map of recent activity. No tint for
+  // uncommitted/unknown lines.
+  const blameTint = useCallback((b: BlameLine | undefined): string | undefined => {
+    if (!b || isUncommitted(b) || !b.author_time) return undefined;
+    const ageDays = Math.max(0, (Date.now() / 1000 - b.author_time) / 86400);
+    const a = 0.16 * Math.exp(-ageDays / 180);
+    if (a < 0.01) return undefined;
+    return `rgba(120, 150, 220, ${a.toFixed(3)})`;
+  }, []);
+
+  const onBlameMove = useCallback(
+    (e: React.MouseEvent) => {
+      const cell = (e.target as HTMLElement).closest<HTMLElement>(".file-viewer-blame-line");
+      const line = cell ? Number(cell.dataset.line) : 0;
+      const b = line ? blame?.get(line) : undefined;
+      if (!cell || !b || isUncommitted(b)) {
+        setBlameTip(null);
+        return;
+      }
+      setBlameTip({ left: e.clientX, top: e.clientY, line });
+    },
+    [blame],
+  );
+
   // Keep the current index in range as the draft (and so the match set) changes.
   useEffect(() => {
     if (current > 0 && current >= matches.length) {
@@ -1346,65 +2305,324 @@ function CodeEditor({
   const draftRef = useRef(draft);
   draftRef.current = draft;
 
-  // Last-change marker: tint the run of text most recently inserted/edited. Every
-  // edit flows through `edit`, which diffs old→new and records the range;
-  // `lastEditRef` holds the value we set so the effect can tell our own edits from
-  // a draft change by another path (disk reload, undo/redo) and drop a now-stale
-  // range. Reloads go through the parent's `reset`, never `edit`, so they never
-  // light the marker.
-  const [lastChange, setLastChange] = useState<{ start: number; end: number } | null>(null);
+  // Change-tint trail: tint recently typed runs with a sequential new→old colour
+  // gradient that fades as typing continues. Every edit flows through `edit`,
+  // which diffs old→new: the new run becomes tier 0 (newest), existing runs are
+  // re-mapped through the edit so they keep tracking their characters and are
+  // pushed one tier older; anything past CHANGE_TIERS or overwritten by the edit
+  // drops off. `lastEditRef` lets the effect tell our own edits from a draft
+  // change by another path (disk reload, undo/redo) and clear a now-stale trail.
+  // Reloads go through the parent's `reset`, never `edit`, so they never light the
+  // trail. A short idle decay retires the oldest run on a timer so the trail
+  // fades away after typing stops. The whole feature is gated on the (default-ON)
+  // `change_tint` setting.
+  const changeTint = useSettingsStore((s) => s.settings?.change_tint !== false);
+  const changeTintRef = useRef(changeTint);
+  changeTintRef.current = changeTint;
+  const [changes, setChanges] = useState<ChangeRange[]>([]);
+  // Red strike-through ghosts of just-deleted text (mirrors the green change
+  // trail on the removal side). Each is retired on its own timer after
+  // DELETE_GHOST_MS; `deleteIdRef` mints ids and `deleteTimersRef` tracks the
+  // pending timeouts so they can be cleared on unmount / trail reset.
+  const [deletes, setDeletes] = useState<DeleteGhost[]>([]);
+  const deleteIdRef = useRef(0);
+  const deleteTimersRef = useRef<number[]>([]);
+  const clearDeleteTimers = useCallback(() => {
+    deleteTimersRef.current.forEach((t) => window.clearTimeout(t));
+    deleteTimersRef.current = [];
+  }, []);
+  const scheduleDeleteRemoval = useCallback((id: number) => {
+    const t = window.setTimeout(() => {
+      setDeletes((prev) => prev.filter((g) => g.id !== id));
+    }, DELETE_GHOST_MS);
+    deleteTimersRef.current.push(t);
+  }, []);
+  useEffect(() => () => clearDeleteTimers(), [clearDeleteTimers]);
   const lastEditRef = useRef<string | null>(null);
   const edit = useCallback(
     (next: string) => {
       if (next !== draftRef.current) {
-        setLastChange(diffRange(draftRef.current, next));
+        if (changeTintRef.current) {
+          const span = editSpan(draftRef.current, next);
+          if (span) {
+            setChanges((prev) => {
+              const remapped = prev
+                .map((r) => remapChangeRange(r, span))
+                .filter((r): r is { start: number; end: number } => r != null);
+              const merged =
+                span.endNext > span.start
+                  ? [{ start: span.start, end: span.endNext }, ...remapped]
+                  : remapped;
+              // newest-first → re-index so tier === age (0 = newest).
+              return merged.slice(0, CHANGE_TIERS).map((r, i) => ({ ...r, tier: i }));
+            });
+            // Removed text (if any) becomes a red strike-through ghost anchored
+            // where it vanished; existing ghosts are re-mapped through this edit
+            // (dropped if their anchor sat inside the edited run) so they keep
+            // pointing at the right spot.
+            const removed = deletionGhostText(draftRef.current.slice(span.start, span.endPrev));
+            const ghost: DeleteGhost | null =
+              removed !== null
+                ? { id: deleteIdRef.current++, pos: span.endNext, text: removed, born: Date.now() }
+                : null;
+            if (ghost) scheduleDeleteRemoval(ghost.id);
+            setDeletes((prev) => {
+              const remapped = prev
+                .map((g) => {
+                  const r = remapChangeRange({ start: g.pos, end: g.pos }, span);
+                  return r ? { ...g, pos: r.start } : null;
+                })
+                .filter((g): g is DeleteGhost => g != null);
+              return ghost ? [...remapped, ghost] : remapped;
+            });
+          }
+        }
         lastEditRef.current = next;
       }
       setDraft(next);
     },
-    [setDraft],
+    [setDraft, scheduleDeleteRemoval],
   );
+  // Drop a stale trail when the draft changes by some path other than our own
+  // `edit` (disk reload, undo/redo), and clear it when the feature is turned off.
   useEffect(() => {
     if (lastEditRef.current !== null && draft !== lastEditRef.current) {
-      setLastChange(null);
+      setChanges([]);
+      setDeletes([]);
+      clearDeleteTimers();
       lastEditRef.current = null;
     }
-  }, [draft]);
+  }, [draft, clearDeleteTimers]);
+  useEffect(() => {
+    if (!changeTint) {
+      setChanges([]);
+      setDeletes([]);
+      clearDeleteTimers();
+    }
+  }, [changeTint, clearDeleteTimers]);
+  // Idle decay: each keystroke resets this timer (re-runs on every `changes`
+  // update), so while typing the trail stays; once typing stops it retires the
+  // oldest run every CHANGE_DECAY_MS until the trail is gone.
+  useEffect(() => {
+    if (changes.length === 0) return;
+    const id = window.setTimeout(() => {
+      setChanges((prev) => prev.slice(0, -1).map((r, i) => ({ ...r, tier: i })));
+    }, CHANGE_DECAY_MS);
+    return () => window.clearTimeout(id);
+  }, [changes]);
   const changeHtml = useMemo(
-    () => (loaded && lastChange ? decorateChangeRange(draft, lastChange) : null),
-    [loaded, draft, lastChange],
+    () => (loaded && changeTint && changes.length ? decorateChangeRanges(draft, changes) : null),
+    [loaded, draft, changes, changeTint],
+  );
+  // Companion overlay for the red deletion ghosts. `Date.now()` here stamps each
+  // mark's fade offset; it re-evaluates on every draft/deletes change (i.e. every
+  // keystroke), which is exactly when the layer is rebuilt.
+  const deleteHtml = useMemo(
+    () => (loaded && changeTint && deletes.length ? decorateDeleteRanges(draft, deletes, Date.now()) : null),
+    [loaded, draft, deletes, changeTint],
   );
 
-  // Replace the current match (#67). We re-place the textarea selection on the
-  // match first so the change history records a single, intelligible edit, then
-  // splice `replaceWith` in via setDraft. The match set recomputes on the new
-  // draft; the live `current` clamp keeps the index in range, leaving the next
-  // occurrence selected so repeated Replace walks through them.
-  const replaceCurrent = useCallback(() => {
-    const m = matches[current];
-    if (!m) return;
-    edit(applyReplacements(draft, [m], replaceWith));
-    // Put the caret just after the inserted text so a follow-up reveal lands here.
-    requestAnimationFrame(() => {
-      const el = textareaRef.current;
-      if (el) el.selectionStart = el.selectionEnd = m.start + replaceWith.length;
-    });
-  }, [matches, current, draft, replaceWith, edit]);
-
-  const replaceAll = useCallback(() => {
-    if (matches.length === 0) return;
-    edit(applyReplacements(draft, matches, replaceWith));
-  }, [matches, draft, replaceWith, edit]);
+  // ── #45 follow-up: local-model grammar/spelling check ──────────────────────
+  // The whole draft is checked against the currently-loaded local model after an
+  // idle pause; the returned issues are resolved to ranges against the live draft
+  // (so they self-heal across small edits) and underlined, colour by category. A
+  // short status mirrors the autocomplete one. Disabled unless `grammarCheck`.
+  const [grammarIssues, setGrammarIssues] = useState<GrammarIssue[]>([]);
+  const [grammarStatus, setGrammarStatus] = useState<string | null>(null);
+  const [grammarTip, setGrammarTip] = useState<
+    { left: number; top: number; range: GrammarRange } | null
+  >(null);
+  const grammarAbort = useRef<AbortController | null>(null);
+  // The exact draft text last submitted, so an idle re-check is skipped when the
+  // document hasn't changed since the previous check.
+  const lastCheckedText = useRef<string | null>(null);
+  // Close the hover tooltip on a short delay, so the pointer can travel from the
+  // underlined mark up into the tooltip (to click Apply) without it vanishing.
+  const grammarTipTimer = useRef<number | null>(null);
+  const cancelGrammarTipClose = useCallback(() => {
+    if (grammarTipTimer.current != null) {
+      window.clearTimeout(grammarTipTimer.current);
+      grammarTipTimer.current = null;
+    }
+  }, []);
+  const scheduleGrammarTipClose = useCallback(() => {
+    cancelGrammarTipClose();
+    grammarTipTimer.current = window.setTimeout(() => setGrammarTip(null), 250);
+  }, [cancelGrammarTipClose]);
+  useEffect(() => () => cancelGrammarTipClose(), [cancelGrammarTipClose]);
+
+  const grammarRanges = useMemo(
+    () => (loaded && grammarIssues.length ? resolveGrammarRanges(draft, grammarIssues) : []),
+    [loaded, draft, grammarIssues],
+  );
+  const grammarHtml = useMemo(
+    () => (grammarRanges.length ? decorateGrammarRanges(draft, grammarRanges) : null),
+    [draft, grammarRanges],
+  );
 
-  // Reset to the first match whenever the query/case changes or the bar opens, so
-  // typing jumps to the first hit. Reveal is deferred a frame so the recomputed
-  // `matches` and the just-mounted overlay are in place.
+  // Re-apply the scroll transform whenever an overlay layer's presence changes.
+  // syncScroll only runs on scroll events and the one-shot restore, but the
+  // change/delete trails (and the search layer) mount lazily — only once there's
+  // an edit or an active find. A layer that first mounts while the textarea is
+  // already scrolled starts at translate(0,0), i.e. `scrollTop` px too low, and
+  // stays out of register until the next scroll. Syncing on mount pins it to the
+  // current offset immediately. useLayoutEffect so it lands before paint.
+  useLayoutEffect(() => {
+    syncScroll();
+  }, [
+    loaded,
+    highlighted,
+    linkHtml,
+    searchHtml,
+    changeHtml,
+    deleteHtml,
+    grammarHtml,
+    syncScroll,
+  ]);
+
+  // Auto-dismiss a finished grammar status; keep an in-flight "…" message.
   useEffect(() => {
-    if (!findOpen) return;
-    setCurrent(0);
-    const id = requestAnimationFrame(() => revealMatch(0));
-    return () => cancelAnimationFrame(id);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
+    if (!grammarStatus || grammarStatus.endsWith("…")) return;
+    const id = window.setTimeout(() => setGrammarStatus(null), 4000);
+    return () => window.clearTimeout(id);
+  }, [grammarStatus]);
+
+  const runGrammarCheck = useCallback(async () => {
+    if (!grammarCheck?.enabled) return;
+    const text = draftRef.current;
+    if (!text.trim()) {
+      setGrammarIssues([]);
+      return;
+    }
+    lastCheckedText.current = text;
+    grammarAbort.current?.abort();
+    const ctl = new AbortController();
+    grammarAbort.current = ctl;
+    setGrammarStatus("Checking grammar…");
+    try {
+      // Resolve the currently-loaded model the same way autocomplete does, so the
+      // check runs against whatever is resident in Ollama at trigger time.
+      const detailed = await invoke<{ name: string; running: boolean }[]>(
+        "list_ollama_models_detailed",
+      );
+      if (ctl.signal.aborted) return;
+      const running = detailed.filter((m) => m.running).map((m) => m.name);
+      const model =
+        grammarCheck.preferred && running.includes(grammarCheck.preferred)
+          ? grammarCheck.preferred
+          : running[0] ?? "";
+      if (!model) {
+        setGrammarStatus("Grammar check unavailable — load a local model (🧠 menu) to enable it.");
+        return;
+      }
+      const issues = await invoke<GrammarIssue[]>("check_grammar", {
+        text,
+        model,
+        language: lang === "plain" ? "" : lang,
+      });
+      if (ctl.signal.aborted) return;
+      setGrammarIssues(issues);
+      setGrammarStatus(issues.length ? `${issues.length} issue${issues.length === 1 ? "" : "s"}` : "No issues");
+    } catch (e) {
+      if (ctl.signal.aborted) return;
+      setGrammarStatus(
+        String(e).includes("not_running")
+          ? "Grammar check unavailable — load a local model (🧠 menu) to enable it."
+          : "Grammar check failed — see the local model.",
+      );
+    }
+    // Primitive deps (the config object's identity changes every render) so the
+    // idle-check timer isn't reset by unrelated re-renders.
+  }, [grammarCheck?.enabled, grammarCheck?.preferred, lang]);
+
+  // Idle re-check: when enabled, run a short while after the user stops typing,
+  // skipping when the draft is unchanged from the last check. Clears stale marks
+  // immediately when the feature is turned off.
+  useEffect(() => {
+    if (!grammarCheck?.enabled || !loaded) {
+      setGrammarIssues([]);
+      setGrammarTip(null);
+      lastCheckedText.current = null;
+      return;
+    }
+    if (draft === lastCheckedText.current) return;
+    const id = window.setTimeout(() => void runGrammarCheck(), GRAMMAR_DEBOUNCE_MS);
+    return () => window.clearTimeout(id);
+  }, [grammarCheck?.enabled, loaded, draft, runGrammarCheck]);
+
+  // Keep the grammar overlay aligned after it mounts/changes.
+  useEffect(() => {
+    if (grammarHtml) syncScroll();
+  }, [grammarHtml, syncScroll]);
+
+  // Apply a single issue's suggested fix: replace its resolved range with the
+  // suggestion and drop the issue so its mark clears (the rest re-resolve against
+  // the new draft). Leaves the caret after the inserted text.
+  const applyGrammarFix = useCallback(
+    (range: GrammarRange) => {
+      const repl = range.issue.suggestion;
+      edit(applyReplacements(draftRef.current, [{ start: range.start, end: range.end }], repl));
+      setGrammarIssues((prev) => prev.filter((i) => i !== range.issue));
+      setGrammarTip(null);
+      const caret = range.start + repl.length;
+      requestAnimationFrame(() => {
+        const el = textareaRef.current;
+        if (el) el.selectionStart = el.selectionEnd = caret;
+      });
+    },
+    [edit],
+  );
+
+  // Hit-test the grammar overlay at a screen point, returning the range under the
+  // cursor (its span carries `data-gi`, an index into `grammarRanges`). Mirrors
+  // the link-layer hit-test: the layer is scroll-synced over the textarea text, so
+  // its span rects are the on-screen marks.
+  const grammarHitAt = useCallback(
+    (x: number, y: number): GrammarRange | null => {
+      const layer = grammarLayerRef.current;
+      if (!layer) return null;
+      for (const span of layer.querySelectorAll<HTMLElement>(".file-viewer-grammar-mark")) {
+        const r = span.getBoundingClientRect();
+        if (x >= r.left && x <= r.right && y >= r.top && y <= r.bottom) {
+          const gi = Number(span.dataset.gi);
+          return grammarRanges[gi] ?? null;
+        }
+      }
+      return null;
+    },
+    [grammarRanges],
+  );
+
+  // Replace the current match (#67). We re-place the textarea selection on the
+  // match first so the change history records a single, intelligible edit, then
+  // splice `replaceWith` in via setDraft. The match set recomputes on the new
+  // draft; the live `current` clamp keeps the index in range, leaving the next
+  // occurrence selected so repeated Replace walks through them.
+  const replaceCurrent = useCallback(() => {
+    const m = matches[current];
+    if (!m) return;
+    edit(applyReplacements(draft, [m], replaceWith));
+    // Put the caret just after the inserted text so a follow-up reveal lands here.
+    requestAnimationFrame(() => {
+      const el = textareaRef.current;
+      if (el) el.selectionStart = el.selectionEnd = m.start + replaceWith.length;
+    });
+  }, [matches, current, draft, replaceWith, edit]);
+
+  const replaceAll = useCallback(() => {
+    if (matches.length === 0) return;
+    edit(applyReplacements(draft, matches, replaceWith));
+  }, [matches, draft, replaceWith, edit]);
+
+  // Reset to the first match whenever the query/case changes or the bar opens, so
+  // typing jumps to the first hit. Reveal is deferred a frame so the recomputed
+  // `matches` and the just-mounted overlay are in place.
+  useEffect(() => {
+    if (!findOpen) return;
+    setCurrent(0);
+    const id = requestAnimationFrame(() => revealMatch(0));
+    return () => cancelAnimationFrame(id);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [query, caseSensitive, findOpen]);
 
   const onFindKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
@@ -1456,12 +2674,23 @@ function CodeEditor({
     const ta = textareaRef.current;
     if (!ta || typeof ResizeObserver === "undefined") return;
     const ro = new ResizeObserver(() => {
+      // WebKitGTK quirk: a soft-wrap textarea re-breaks its lines when its box
+      // shrinks but NOT when it grows, so after the editor widens the text stays
+      // wrapped at the old, narrower width and leaves blank space on the right.
+      // Nudge it to re-lay-out at the new width by toggling its wrap off→on within
+      // a single synchronous reflow (no paint between, so no flicker; the value —
+      // and thus caret/selection — is untouched).
+      if (wrap) {
+        ta.style.whiteSpace = "pre";
+        void ta.offsetWidth;
+        ta.style.whiteSpace = "";
+      }
       syncScroll();
       bumpMeasure();
     });
     ro.observe(ta);
     return () => ro.disconnect();
-  }, [syncScroll, loaded]);
+  }, [syncScroll, loaded, wrap]);
 
   // Measure each logical line's wrapped height (wrap mode only) so the gutter
   // cells line up with the editor. Runs before paint to avoid a flash of
@@ -1470,13 +2699,27 @@ function CodeEditor({
   useLayoutEffect(() => {
     if (!wrap || !loaded) {
       setWrapWidth(null);
+      prevClientWidth.current = null;
       return;
     }
     const measure = measureRef.current;
     const ta = textareaRef.current;
     if (!measure || !ta) return;
-    setWrapWidth(ta.clientWidth);
-    measure.style.width = `${ta.clientWidth}px`;
+    const cw = ta.clientWidth;
+    // If the content width changed since the last measure — most often a vertical
+    // scrollbar toggling as the doc crosses the editor height, which the
+    // ResizeObserver can't see — force the textarea to re-break to the new width
+    // with the same whiteSpace nudge used on resize (synchronous, pre-paint, so
+    // no flicker and the value/caret are untouched). Keeps its wrapping in lockstep
+    // with the overlay layers pinned to `cw`, so the last-change tint stays put.
+    if (prevClientWidth.current !== cw) {
+      prevClientWidth.current = cw;
+      ta.style.whiteSpace = "pre";
+      void ta.offsetWidth;
+      ta.style.whiteSpace = "";
+    }
+    setWrapWidth(cw);
+    measure.style.width = `${cw}px`;
     const next = Array.from(
       measure.children,
       (c) => (c as HTMLElement).offsetHeight,
@@ -1500,12 +2743,22 @@ function CodeEditor({
   // the textarea is actually focused so a blur-time reset is ignored.
   const emitCaret = useCallback(() => {
     const el = textareaRef.current;
-    if (el && document.activeElement === el && onCaretChange) {
-      onCaretChange(el.selectionStart);
+    if (el) {
+      if (document.activeElement === el && onCaretChange) onCaretChange(el.selectionStart);
+      // Track the caret's line for the blame inline hint (cheap; only read).
+      setCaretLine(offsetToLineCol(el.value, el.selectionStart).line);
     }
     bumpCaret();
   }, [onCaretChange, bumpCaret]);
 
+  // Re-apply the scroll transform to the blame layers whenever they (re)mount or
+  // the caret line changes: a freshly-mounted node starts at translateY(0), so
+  // without this the column/inline hint would sit un-scrolled until the next
+  // scroll event. syncScroll reads the live textarea scrollTop.
+  useEffect(() => {
+    if (showBlame) syncScroll();
+  }, [showBlame, caretLine, blame, syncScroll]);
+
   // Publish a live caret getter so the viewer can read the *current* cursor at
   // compile time rather than relying on the last-reported snapshot. The Compile
   // button keeps focus (its onMouseDown preventDefault), so at the moment compile
@@ -1520,6 +2773,38 @@ function CodeEditor({
     };
   }, [caretApiRef]);
 
+  // Imperative editing API for a toolbar (the Markdown viewer). `applyEdit` runs
+  // a pure transform on the current value+selection and commits it through
+  // `edit`; the requested selection is stashed and restored by the layout effect
+  // below once React has re-rendered the textarea with the new value.
+  const pendingSelRef = useRef<{ start: number; end: number } | null>(null);
+  useEffect(() => {
+    if (!editorApiRef) return;
+    editorApiRef.current = {
+      applyEdit: (fn) => {
+        const el = textareaRef.current;
+        const start = el?.selectionStart ?? draftRef.current.length;
+        const end = el?.selectionEnd ?? start;
+        const res = fn(draftRef.current, start, end);
+        pendingSelRef.current = { start: res.selStart, end: res.selEnd };
+        el?.focus();
+        edit(res.value);
+      },
+    };
+    return () => {
+      editorApiRef.current = null;
+    };
+  }, [editorApiRef, edit]);
+  useLayoutEffect(() => {
+    const sel = pendingSelRef.current;
+    if (!sel) return;
+    pendingSelRef.current = null;
+    const el = textareaRef.current;
+    if (!el) return;
+    el.selectionStart = sel.start;
+    el.selectionEnd = sel.end;
+  }, [draft]);
+
   // SyncTeX reverse search: on a new `gotoLine` nonce, place the caret at the
   // target line/column and scroll it to roughly the middle of the view. SyncTeX
   // reports a column (0 when it has none); we offset into the line by it, clamped
@@ -1550,35 +2835,110 @@ function CodeEditor({
     acAbort.current?.abort();
     acAbort.current = null;
     setSuggestion(null);
+    setAcStatus(null);
   }, []);
 
   // #45: request a completion at the caret. Privacy-gated by the caller (only
-  // wired when the per-type setting is on); also ensures Ollama is up first and
-  // fails silently otherwise.
-  const requestCompletion = useCallback(async () => {
+  // wired when the per-type setting is on). Completion runs against whichever
+  // local model is CURRENTLY LOADED in Ollama memory (the running set from
+  // /api/ps), preferring the user's active model when it is loaded.
+  //
+  // Two modes:
+  //  - manual (Ctrl+Space): surfaces a message when nothing is loaded / it fails,
+  //    so the user gets feedback rather than silence.
+  //  - auto (debounced as you type): only runs for the focused editor with a
+  //    collapsed caret and enough context, and stays SILENT on the unavailable/
+  //    error paths so typing isn't spammed with toasts. There is no remote
+  //    fallback either way (local-only by design, DECISION A).
+  const requestCompletion = useCallback(async (opts?: { auto?: boolean; mode?: AutocompleteMode }) => {
+    const auto = opts?.auto === true;
+    // Explicit override (from the live cycle key) wins over the current mode,
+    // since setState hasn't flushed yet when the key handler calls through.
+    const mode = opts?.mode ?? acMode;
     const el = textareaRef.current;
-    if (!el || !autocomplete?.enabled || !autocomplete.model) return;
+    if (!el || !autocomplete?.enabled) return;
+    // Auto mode: only the focused editor, only at a collapsed caret, and only
+    // with a little context to complete from — otherwise skip the round trip.
+    if (auto) {
+      if (document.activeElement !== el) return;
+      if (el.selectionStart !== el.selectionEnd) return;
+    }
     const caret = el.selectionStart;
     const prefix = draft.slice(0, caret);
     const suffix = draft.slice(caret);
+    if (auto && prefix.replace(/\s+/g, "").length < 3) return;
     acAbort.current?.abort();
     const ctl = new AbortController();
     acAbort.current = ctl;
+    setSuggestion(null);
+    setAcStatus(`Autocomplete · ${AC_MODE_LABELS[mode]}…`);
     try {
-      await invoke("ensure_ollama_running");
+      // Resolve the currently-loaded model at trigger time (it may have been
+      // unloaded since the editor mounted). `list_ollama_models_detailed`
+      // doubles as the running-check; "not_running" means Ollama is down.
+      const detailed = await invoke<{ name: string; running: boolean }[]>(
+        "list_ollama_models_detailed",
+      );
       if (ctl.signal.aborted) return;
+      const loaded = detailed.filter((m) => m.running).map((m) => m.name);
+      const model =
+        autocomplete.preferred && loaded.includes(autocomplete.preferred)
+          ? autocomplete.preferred
+          : loaded[0] ?? "";
+      if (!model) {
+        setAcStatus(
+          auto ? null : "Autocomplete unavailable — load a local model (🧠 menu) to enable it.",
+        );
+        return;
+      }
       const text = await invoke<string>("complete_text", {
         prefix,
         suffix,
-        model: autocomplete.model,
+        model,
         language: lang === "plain" ? "" : lang,
+        mode,
+        context: contextFiles.length
+          ? contextFiles.map((f) => ({ name: f.rel, content: f.content }))
+          : undefined,
       });
       if (ctl.signal.aborted) return;
-      if (text) setSuggestion({ text, at: caret });
-    } catch {
-      // Ollama not running / errored → fail silently (no remote fallback).
+      if (text) {
+        setSuggestion({ text, at: caret });
+        setAcStatus(null);
+      } else {
+        setAcStatus(auto ? null : "No suggestion");
+      }
+    } catch (e) {
+      if (ctl.signal.aborted) return;
+      if (auto) {
+        setAcStatus(null);
+        return;
+      }
+      setAcStatus(
+        String(e).includes("not_running")
+          ? "Autocomplete unavailable — load a local model (🧠 menu) to enable it."
+          : "Autocomplete failed — see the local model.",
+      );
     }
-  }, [autocomplete, draft, lang]);
+  }, [autocomplete, draft, lang, acMode, contextFiles]);
+
+  // #45 automatic suggestions: when the per-type toggle is on, request a
+  // completion a short while after the user stops typing. Re-runs on each draft
+  // change; the cleanup clears the prior timer, so only an idle pause fires it.
+  // Skipped while a suggestion is already showing or the \ref/\cite dropdown is
+  // open. The focus/caret/context guards live in `requestCompletion`.
+  useEffect(() => {
+    if (!autocomplete?.enabled || !loaded) return;
+    if (suggestion || compl) return;
+    const id = window.setTimeout(() => void requestCompletion({ auto: true }), AUTO_AC_DEBOUNCE_MS);
+    return () => window.clearTimeout(id);
+  }, [autocomplete?.enabled, loaded, draft, suggestion, compl, requestCompletion]);
+
+  // The ghost mounts fresh (scrollTop 0) each time a suggestion appears; align it
+  // to the editor's current scroll so the inserted preview lands at the caret.
+  useEffect(() => {
+    if (suggestion) syncScroll();
+  }, [suggestion, syncScroll]);
 
   const acceptSuggestion = useCallback(() => {
     const el = textareaRef.current;
@@ -1593,6 +2953,28 @@ function CodeEditor({
     });
   }, [suggestion, draft, edit]);
 
+  // #45 partial accept (→ Right arrow): insert only the next "word" of the pending
+  // suggestion and keep the remainder ghosted, so the user can walk a long
+  // suggestion in word-sized steps. A word = any leading whitespace (including a
+  // newline + indentation) plus the following run of non-space characters.
+  const acceptWord = useCallback(() => {
+    const el = textareaRef.current;
+    if (!el || !suggestion) return;
+    const { text, at } = suggestion;
+    const m = text.match(/^\s*\S+/);
+    const take = m ? m[0].length : text.length;
+    const chunk = text.slice(0, take);
+    const rest = text.slice(take);
+    const next = draft.slice(0, at) + chunk + draft.slice(at);
+    edit(next);
+    const caret = at + chunk.length;
+    // Keep the rest ghosted at the new caret; clear once it's fully consumed.
+    setSuggestion(rest ? { text: rest, at: caret } : null);
+    requestAnimationFrame(() => {
+      el.selectionStart = el.selectionEnd = caret;
+    });
+  }, [suggestion, draft, edit]);
+
   // \ref/\cite completion: cap the dropdown so a huge .bib can't render
   // thousands of rows; the prefix filter usually narrows it well below this.
   const COMPL_LIMIT = 80;
@@ -1757,7 +3139,12 @@ function CodeEditor({
       }
     }
 
-    // #45: Ctrl+Space requests a suggestion; Tab accepts; Esc dismisses.
+    // #45: Ctrl+Space requests a suggestion. While a ghost suggestion is showing:
+    //  - Tab accepts the whole suggestion,
+    //  - Shift+Tab toggles the completion-length mode (Sentence → Block → Scope)
+    //    and re-requests in it,
+    //  - → (Right) accepts only the next word (repeat to walk word-by-word),
+    //  - Esc dismisses.
     if ((e.ctrlKey || e.metaKey) && e.key === " ") {
       e.preventDefault();
       void requestCompletion();
@@ -1766,7 +3153,22 @@ function CodeEditor({
     if (suggestion) {
       if (e.key === "Tab") {
         e.preventDefault();
-        acceptSuggestion();
+        if (e.shiftKey) {
+          // Toggle to the next mode and re-request, so the ghost switches to that
+          // mode's completion in place.
+          const m = nextAcMode(acMode);
+          setAcMode(m);
+          void requestCompletion({ mode: m });
+        } else {
+          acceptSuggestion();
+        }
+        return;
+      }
+      // Plain Right arrow accepts the next word; modified Right (select/word-move)
+      // falls through and dismisses so native navigation still works.
+      if (e.key === "ArrowRight" && !e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey) {
+        e.preventDefault();
+        acceptWord();
         return;
       }
       if (e.key === "Escape") {
@@ -1840,17 +3242,28 @@ function CodeEditor({
   const onMouseMove = (e: React.MouseEvent<HTMLTextAreaElement>) => {
     lastMouse.current = { x: e.clientX, y: e.clientY };
     updateLinkHover(e.clientX, e.clientY, e.ctrlKey || e.metaKey);
+    // Grammar tooltip: open it over a hovered mark, else schedule a close so the
+    // pointer can still reach the open tooltip's Apply button.
+    if (grammarRanges.length) {
+      const hit = grammarHitAt(e.clientX, e.clientY);
+      if (hit) {
+        cancelGrammarTipClose();
+        setGrammarTip({ left: e.clientX, top: e.clientY, range: hit });
+      } else if (grammarTip) {
+        scheduleGrammarTipClose();
+      }
+    }
   };
 
   if (error != null) return <div className="file-viewer-error">{error}</div>;
   if (!loaded) return <div className="file-viewer-loading">Loading…</div>;
 
-  // Ghost text: render the draft up to the caret (transparent) then the
-  // suggestion (dimmed) so it sits inline where it would be inserted.
-  const ghost =
-    suggestion != null
-      ? draft.slice(0, suggestion.at) + suggestion.text
-      : null;
+  // Ghost text: while a suggestion is pending, render the WHOLE projected
+  // document — prefix + suggestion + the existing suffix shifted past it — over
+  // an opaque background that masks the real layers beneath. This pushes the
+  // text after the caret aside (horizontally and, for multi-line suggestions,
+  // downward) instead of painting the proposal on top of it.
+  const hasGhost = suggestion != null;
 
   // In wrap mode, pin every overlay <pre> to the textarea's content width so
   // they wrap line-for-line with it (see wrapWidth). A no-op otherwise.
@@ -1860,7 +3273,7 @@ function CodeEditor({
   return (
     <div
       className="file-viewer-code"
-      onWheel={(e) => onCtrlWheelFont(e, incFont, decFont)}
+      ref={wheelRef}
       onKeyDown={onContainerKeyDown}
       style={
         fontSize
@@ -1874,25 +3287,98 @@ function CodeEditor({
           : undefined
       }
     >
+      {/* Git-blame column (#blame). Sits left of the numbers, shares their cell
+          heights (incl. wrap-mode `lineHeights`) and is scroll-locked via its own
+          inner transform. Each cell shows the last author + relative date;
+          uncommitted/unknown lines get a muted dot. Age-tinted like a heat-map. */}
+      {showBlame && (
+        <div
+          className="file-viewer-blame-gutter"
+          aria-hidden="true"
+          onMouseMove={onBlameMove}
+          onMouseLeave={() => setBlameTip(null)}
+        >
+          <div className="file-viewer-blame-inner" ref={blameInnerRef}>
+            {Array.from({ length: lineCount }, (_, i) => {
+              const b = blame?.get(i + 1);
+              const h = wrap ? lineHeights[i] : undefined;
+              const known = b != null && !isUncommitted(b);
+              const style: React.CSSProperties = {};
+              if (h != null) style.height = h;
+              const tint = blameTint(b);
+              if (tint) style.background = tint;
+              return (
+                <div
+                  key={i}
+                  className={`file-viewer-blame-line${known ? "" : " uncommitted"}${
+                    i + 1 === caretLine ? " current" : ""
+                  }`}
+                  data-line={i + 1}
+                  style={style}
+                >
+                  {known ? (
+                    <>
+                      <span className="fv-blame-author">{authorAbbrev(b!.author)}</span>
+                      <span className="fv-blame-date">{blameRelDate(b!.author_time)}</span>
+                    </>
+                  ) : (
+                    <span className="fv-blame-none">·</span>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+        </div>
+      )}
       {/* Line-number gutter. Fixed-height rows normally; in wrap mode (the LaTeX
           viewer) a logical line can span several visual rows, so each cell is
           sized to its measured wrapped height (`lineHeights`). Lines holding a
-          search match are marked, the current match brightest (#67). */}
-      <div className="file-viewer-gutter" aria-hidden="true">
+          search match are marked, the current match brightest (#67).
+
+          When `onToggleBreakpoint` is wired (the Python editor, #py) the cells
+          become real buttons that set/clear a debug breakpoint, so the gutter
+          stops being decoration and the whole column drops its `aria-hidden` —
+          hiding a control from the accessibility tree would make the feature
+          unreachable without a mouse. */}
+      <div className="file-viewer-gutter" aria-hidden={onToggleBreakpoint ? undefined : "true"}>
         <div className="file-viewer-gutter-inner" ref={gutterInnerRef}>
           {Array.from({ length: lineCount }, (_, i) => {
             const n = i + 1;
             const h = wrap ? lineHeights[i] : undefined;
+            const broken = breakpoints?.has(n) ?? false;
             const cls =
-              n === currentMatchLine
+              (n === currentMatchLine
                 ? "file-viewer-gutter-line current-match"
                 : matchLineSet.has(n)
                   ? "file-viewer-gutter-line has-match"
-                  : "file-viewer-gutter-line";
+                  : "file-viewer-gutter-line") +
+              (onToggleBreakpoint ? " is-breakable" : "") +
+              (broken ? " has-breakpoint" : "");
+            const style = h != null ? { height: h } : undefined;
+
+            if (!onToggleBreakpoint) {
+              return (
+                <div key={i} className={cls} style={style}>
+                  {n}
+                </div>
+              );
+            }
             return (
-              <div key={i} className={cls} style={h != null ? { height: h } : undefined}>
+              <button
+                key={i}
+                type="button"
+                className={cls}
+                style={style}
+                // Keep the caret where it is: clicking the gutter sets a
+                // breakpoint, it does not move the cursor or steal focus.
+                onMouseDown={(e) => e.preventDefault()}
+                onClick={() => onToggleBreakpoint(n)}
+                title={broken ? `Remove breakpoint on line ${n}` : `Break on line ${n}`}
+                aria-pressed={broken}
+                aria-label={broken ? `Remove breakpoint on line ${n}` : `Break on line ${n}`}
+              >
                 {n}
-              </div>
+              </button>
             );
           })}
         </div>
@@ -1900,7 +3386,7 @@ function CodeEditor({
       <div
         className={`file-viewer-code-area${highlighted != null ? " highlighted" : ""}${
           linkHover ? " link-hover" : ""
-        }${wrap ? " is-wrapped" : ""}`}
+        }${wrap ? " is-wrapped" : ""}${hasGhost ? " has-suggestion" : ""}`}
       >
         {/* Hidden full-width mirror used only to measure each logical line's
             wrapped height for the gutter (wrap mode). Sized to the textarea's
@@ -1939,6 +3425,15 @@ function CodeEditor({
             dangerouslySetInnerHTML={{ __html: searchHtml + "\n" }}
           />
         )}
+        {grammarHtml != null && (
+          <pre
+            ref={grammarLayerRef}
+            className="file-viewer-grammar-layer"
+            aria-hidden="true"
+            style={overlayWidthStyle}
+            dangerouslySetInnerHTML={{ __html: grammarHtml + "\n" }}
+          />
+        )}
         {linkHtml != null && (
           <pre
             ref={linkLayerRef}
@@ -1948,10 +3443,25 @@ function CodeEditor({
             dangerouslySetInnerHTML={{ __html: linkHtml + "\n" }}
           />
         )}
-        {ghost != null && (
-          <pre className="file-viewer-ghost" aria-hidden="true" style={overlayWidthStyle}>
-            <span className="file-viewer-ghost-hidden">{draft.slice(0, suggestion!.at)}</span>
+        {deleteHtml != null && (
+          <pre
+            ref={deleteLayerRef}
+            className="file-viewer-delete-layer"
+            aria-hidden="true"
+            style={overlayWidthStyle}
+            dangerouslySetInnerHTML={{ __html: deleteHtml + "\n" }}
+          />
+        )}
+        {hasGhost && (
+          <pre
+            ref={ghostRef}
+            className="file-viewer-ghost"
+            aria-hidden="true"
+            style={overlayWidthStyle}
+          >
+            {draft.slice(0, suggestion!.at)}
             <span className="file-viewer-ghost-text">{suggestion!.text}</span>
+            {draft.slice(suggestion!.at)}
           </pre>
         )}
         <textarea
@@ -1965,13 +3475,120 @@ function CodeEditor({
           onKeyUp={(e) => { if (!(e.ctrlKey || e.metaKey)) setLinkHover(false); emitCaret(); }}
           onBlur={() => { setLinkHover(false); setLinkTip(null); dismissSuggestion(); setCompl(null); }}
           onMouseMove={onMouseMove}
-          onMouseLeave={() => { setLinkHover(false); setLinkTip(null); }}
+          onMouseLeave={() => { setLinkHover(false); setLinkTip(null); scheduleGrammarTipClose(); }}
           onClick={onClick}
           onSelect={emitCaret}
           onScroll={onScroll}
         />
+        {/* Current-line blame hint (#blame): a faint, right-aligned annotation on
+            the caret's line. Absolutely positioned at the line's top offset and
+            scroll-locked with the blame column. */}
+        {showBlame && caretBlame && !isUncommitted(caretBlame) && (
+          <div
+            ref={blameInlineRef}
+            className="file-viewer-blame-inline"
+            aria-hidden="true"
+            style={{ top: lineTop(caretLine), lineHeight: `${effectiveLineHeight}px` }}
+          >
+            {caretBlame.author} · {blameRelDate(caretBlame.author_time)} · {caretBlame.summary}
+          </div>
+        )}
       </div>
       {onFollowLink && <LinkOpenHint at={linkTip} />}
+      {acStatus && (
+        <div className="file-viewer-ac-status" role="status">
+          {/* A trailing "…" marks an in-flight request — show a spinner. */}
+          {acStatus.endsWith("…") && (
+            <span className="file-viewer-ac-spinner" aria-hidden="true" />
+          )}
+          {acStatus}
+        </div>
+      )}
+      {grammarStatus && (
+        <div className="file-viewer-grammar-status" role="status">
+          {grammarStatus.endsWith("…") && (
+            <span className="file-viewer-ac-spinner" aria-hidden="true" />
+          )}
+          {grammarStatus}
+        </div>
+      )}
+      {grammarTip && (
+        <div
+          className={`file-viewer-grammar-tip cat-${grammarTip.range.issue.category}`}
+          style={{ left: grammarTip.left, top: grammarTip.top }}
+          role="tooltip"
+          onMouseEnter={cancelGrammarTipClose}
+          onMouseLeave={scheduleGrammarTipClose}
+        >
+          <div className="file-viewer-grammar-tip-cat">{grammarTip.range.issue.category}</div>
+          {grammarTip.range.issue.message && (
+            <div className="file-viewer-grammar-tip-msg">{grammarTip.range.issue.message}</div>
+          )}
+          {grammarTip.range.issue.suggestion && (
+            <button
+              type="button"
+              className="file-viewer-grammar-tip-fix"
+              // mousedown keeps the textarea from stealing focus before the click.
+              onMouseDown={(e) => { e.preventDefault(); applyGrammarFix(grammarTip.range); }}
+            >
+              Fix → <span className="file-viewer-grammar-tip-sugg">{grammarTip.range.issue.suggestion}</span>
+            </button>
+          )}
+        </div>
+      )}
+      {/* Blame hovercard (#blame): full attribution for the hovered gutter cell. */}
+      {blameTip && (() => {
+        const b = blame?.get(blameTip.line);
+        if (!b || isUncommitted(b)) return null;
+        return (
+          <div
+            className="file-viewer-blame-tip"
+            style={{ left: blameTip.left, top: blameTip.top }}
+            role="tooltip"
+          >
+            <div className="file-viewer-blame-tip-head">
+              <span className="file-viewer-blame-tip-hash">{b.short}</span>
+              <span className="file-viewer-blame-tip-author">{b.author}</span>
+            </div>
+            <div className="file-viewer-blame-tip-date">{blameRelDate(b.author_time)} ago</div>
+            <div className="file-viewer-blame-tip-summary">{b.summary}</div>
+          </div>
+        );
+      })()}
+      {/* #45 context files: a button to attach project files plus chips for the
+          attached ones, shown only when autocomplete is enabled for this type. */}
+      {autocomplete?.enabled && (
+        <div className="file-viewer-ac-context">
+          <button
+            type="button"
+            className="file-viewer-ac-context-add"
+            onClick={() => setAcPicker(true)}
+            title="Add a project file as autocomplete context"
+          >
+            + Context{contextFiles.length ? ` (${contextFiles.length})` : ""}
+          </button>
+          {contextFiles.map((f) => (
+            <span key={f.path} className="file-viewer-ac-context-chip" title={f.rel}>
+              {f.rel.split("/").pop()}
+              <button
+                type="button"
+                aria-label={`Remove ${f.rel} from context`}
+                onClick={() => removeContextFile(f.path)}
+              >
+                ×
+              </button>
+            </span>
+          ))}
+        </div>
+      )}
+      {acPicker && (
+        <ContextFilePicker
+          projectDir={acProjectDir}
+          attached={contextFiles.map((f) => f.rel)}
+          onPick={(rel) => void addContextFile(rel)}
+          onClose={() => setAcPicker(false)}
+        />
+      )}
       {compl && (
         <ul
           className={`file-viewer-tex-compl${compl.ctx.kind === "cite" ? " is-cite" : ""}`}
@@ -2103,7 +3720,7 @@ function CodeEditor({
  * than text: a spinner while saving, a filled disk with a dot when there are
  * unsaved edits, and a check when clean. `aria-label="Save"` keeps it findable.
  */
-function SaveButton({
+export function SaveButton({
   isDirty,
   saving,
   save,
@@ -2132,8 +3749,34 @@ function SaveButton({
   );
 }
 
+/** Print button shared by every content viewer. Renders the viewer's content to
+ *  a clean paginated document and hands it to the platform print dialog (which
+ *  offers "Save as PDF") — see `lib/viewers/print`. `busy` covers async sources
+ *  like the PDF viewer, which rasterises its pages before printing. */
+function PrintButton({
+  onPrint,
+  busy = false,
+  disabled = false,
+}: {
+  onPrint: () => void;
+  busy?: boolean;
+  disabled?: boolean;
+}) {
+  return (
+    <button
+      className={`file-viewer-print${busy ? " is-busy" : ""}`}
+      onClick={onPrint}
+      disabled={disabled || busy}
+      title={busy ? "Preparing…" : "Print"}
+      aria-label="Print"
+    >
+      {busy ? <span className="file-viewer-save-spinner" aria-hidden="true" /> : "🖨"}
+    </button>
+  );
+}
+
 /** Undo/redo toolbar buttons shared by the editable viewers (#46). */
-function UndoRedoButtons({
+export function UndoRedoButtons({
   undo,
   redo,
   canUndo,
@@ -2168,99 +3811,537 @@ function UndoRedoButtons({
   );
 }
 
-/** Resolve the per-type viewer prefs for an InternalViewer from settings (#48). */
-function useViewerPref(type: InternalViewer) {
-  return useSettingsStore((s) => s.settings?.viewer_prefs?.[type]);
-}
-
-/** The model used for local autocomplete (#45). Reuses the global agent command
- *  when it is an Ollama model name; falls back to a small coder model. We don't
- *  add a separate setting — the per-type `autocomplete` toggle is the gate. */
-function useAutocompleteConfig(type: InternalViewer): { enabled: boolean; model: string } {
-  const pref = useViewerPref(type);
-  const model = useSettingsStore(
-    (s) => (s.settings?.autocomplete_model as string | undefined) ?? "qwen2.5-coder:1.5b",
-  );
-  return { enabled: pref?.autocomplete === true, model };
-}
-
-// Code-editor font sizing. The default matches the .file-viewer-code CSS metrics
-// (12px / 18px); the line-height tracks the font at a fixed 1.5 ratio so the
-// gutter and overlay layers stay aligned at any size.
-export const EDITOR_FONT_DEFAULT = 12;
-export const EDITOR_FONT_MIN = 8;
-export const EDITOR_FONT_MAX = 32;
-const EDITOR_LINE_RATIO = 1.5;
-export const clampFontSize = (n: number) =>
-  Math.min(EDITOR_FONT_MAX, Math.max(EDITOR_FONT_MIN, Math.round(n)));
-
-/** Shared Ctrl/Cmd+wheel handler for the text viewers (code + markdown): scroll
- *  up grows, down shrinks the font, mirroring the browser zoom gesture and the
- *  Ctrl +/− keyboard shortcuts. A plain wheel (no modifier) falls through to
- *  native scrolling. */
-function onCtrlWheelFont(
-  e: React.WheelEvent,
-  inc?: () => void,
-  dec?: () => void,
-) {
-  if (!(e.ctrlKey || e.metaKey)) return;
-  e.preventDefault();
-  if (e.deltaY < 0) inc?.();
-  else if (e.deltaY > 0) dec?.();
-}
+// ── Per-format extras: format, validation, preview, markup toolbar ───────────
 
 /**
- * Per-type editor font size (text-size +/− control). Reads the persisted
- * `viewer_prefs[type].font_size`, clamps it, and exposes inc/dec/reset that write
- * the new size back through `updateSettings` — merging the whole viewer_prefs map
- * the same way the settings panel does, so it round-trips to settings.json.
+ * "Format document" support for the editable text viewers. JSON is prettified
+ * in-process; every other recognised type shells out to an external formatter
+ * (prettier/black/rustfmt/gofmt) via the backend, which is probed once per path
+ * so the button can disable itself when no tool is installed. A formatted result
+ * is written back through `setDraft`, so it lands as one undo step.
  */
-function useEditorFontSize(type: InternalViewer) {
-  const pref = useViewerPref(type);
-  const fontSize = clampFontSize(pref?.font_size ?? EDITOR_FONT_DEFAULT);
+function useFormatter(path: string, draft: string, setDraft: (v: string) => void) {
+  const lang = useMemo(() => formatLangForPath(path), [path]);
+  const inProcess = useMemo(() => isInProcessJson(path), [path]);
+  const enabled = inProcess || lang != null;
+  // JSON (in-process) is always available; an external formatter is probed.
+  const [available, setAvailable] = useState(inProcess);
+  const [busy, setBusy] = useState(false);
+  const [status, setStatus] = useState<string | null>(null);
+  const draftRef = useRef(draft);
+  draftRef.current = draft;
 
-  const setFontSize = useCallback(
-    (next: number) => {
-      const size = clampFontSize(next);
-      const all = useSettingsStore.getState().settings?.viewer_prefs ?? {};
-      const cur = all[type] ?? {};
-      if (cur.font_size === size) return;
-      void useSettingsStore.getState().updateSettings({
-        viewer_prefs: { ...all, [type]: { ...cur, font_size: size } },
-      });
-    },
-    [type],
-  );
+  useEffect(() => {
+    if (!lang) {
+      setAvailable(inProcess);
+      return;
+    }
+    let cancelled = false;
+    invoke<boolean>("formatter_available", { lang, path })
+      .then((ok) => { if (!cancelled) setAvailable(inProcess || ok); })
+      .catch(() => { if (!cancelled) setAvailable(inProcess); });
+    return () => { cancelled = true; };
+  }, [lang, path, inProcess]);
 
-  return {
-    fontSize,
-    lineHeight: Math.round(fontSize * EDITOR_LINE_RATIO),
-    // True once the user has set a size — lets surfaces with their own default
-    // (the markdown preview) leave it alone until then.
-    isCustom: pref?.font_size != null,
-    inc: useCallback(() => setFontSize(fontSize + 1), [setFontSize, fontSize]),
-    dec: useCallback(() => setFontSize(fontSize - 1), [setFontSize, fontSize]),
-    reset: useCallback(() => setFontSize(EDITOR_FONT_DEFAULT), [setFontSize]),
-  };
+  // Auto-dismiss a finished status after a few seconds.
+  useEffect(() => {
+    if (!status) return;
+    const id = window.setTimeout(() => setStatus(null), 6000);
+    return () => window.clearTimeout(id);
+  }, [status]);
+
+  const run = useCallback(async () => {
+    if (busy) return;
+    const text = draftRef.current;
+    setStatus(null);
+    if (inProcess) {
+      const res = formatJsonText(text);
+      if (res.ok) {
+        if (res.text !== text) setDraft(res.text);
+      } else {
+        setStatus(`Can't format: ${res.error}`);
+      }
+      return;
+    }
+    if (!lang) return;
+    setBusy(true);
+    try {
+      const out = await invoke<string>("format_source", { text, lang, path });
+      if (out !== text) setDraft(out);
+    } catch (e) {
+      const msg = String(e);
+      if (msg.startsWith("formatter-unavailable")) {
+        setAvailable(false);
+        setStatus("No formatter installed for this file type");
+      } else {
+        setStatus(msg.length > 240 ? `${msg.slice(0, 240)}…` : msg);
+      }
+    } finally {
+      setBusy(false);
+    }
+  }, [busy, inProcess, lang, path, setDraft]);
+
+  return { enabled, available, busy, status, run };
 }
 
-/** A−/A+ text-size control for the code editors, mirroring the image/PDF zoom
- *  group. Reuses the `.file-viewer-zoom-btn` styling. */
-function FontSizeControls({
-  fontSize,
-  inc,
-  dec,
-  reset,
+/** "Format" toolbar button; disabled when no formatter is available or while a
+ *  format is in flight. Keeps editor focus so the document stays the target. */
+function FormatButton({
+  available,
+  busy,
+  run,
 }: {
-  fontSize: number;
-  inc: () => void;
-  dec: () => void;
-  reset: () => void;
+  available: boolean;
+  busy: boolean;
+  run: () => void;
 }) {
   return (
-    <div className="file-viewer-zoom file-viewer-fontsize" role="group" aria-label="Text size">
-      <button
-        className="file-viewer-zoom-btn"
+    <button
+      className="file-viewer-format-btn"
+      onMouseDown={(e) => e.preventDefault()}
+      onClick={run}
+      disabled={!available || busy}
+      title={available ? "Format document" : "No formatter found for this file type"}
+      aria-label="Format document"
+    >
+      {busy ? <span className="file-viewer-save-spinner" aria-hidden="true" /> : "Format"}
+    </button>
+  );
+}
+
+interface SyntaxIssue {
+  line: number;
+  column: number;
+  message: string;
+}
+
+/** Debounced backend syntax check for JSON/YAML; returns the first parse error
+ *  (or null when valid / not a checked type). Re-runs as the draft changes. */
+function useSyntaxCheck(path: string, draft: string, loaded: boolean): SyntaxIssue | null {
+  const lang = useMemo(() => validationLangForPath(path), [path]);
+  const [issue, setIssue] = useState<SyntaxIssue | null>(null);
+  useEffect(() => {
+    if (!lang || !loaded) {
+      setIssue(null);
+      return;
+    }
+    let cancelled = false;
+    const id = window.setTimeout(() => {
+      invoke<SyntaxIssue | null>("check_syntax", { text: draft, lang })
+        .then((r) => { if (!cancelled) setIssue(r ?? null); })
+        .catch(() => { if (!cancelled) setIssue(null); });
+    }, 500);
+    return () => { cancelled = true; window.clearTimeout(id); };
+  }, [lang, draft, loaded]);
+  return lang ? issue : null;
+}
+
+/** Inline parse-error banner for JSON/YAML, with a jump to the offending line. */
+function ValidationBanner({
+  issue,
+  onJump,
+}: {
+  issue: SyntaxIssue | null;
+  onJump: (line: number, column: number) => void;
+}) {
+  if (!issue) return null;
+  const where = issue.line
+    ? ` (line ${issue.line}${issue.column ? `, col ${issue.column}` : ""})`
+    : "";
+  return (
+    <div className="file-viewer-validation" role="alert">
+      <span className="file-viewer-validation-dot" aria-hidden="true" />
+      <span className="file-viewer-validation-msg">
+        {issue.message}
+        {where}
+      </span>
+      {issue.line > 0 && (
+        <button
+          className="file-viewer-validation-jump"
+          onClick={() => onJump(issue.line, issue.column)}
+        >
+          Go to line
+        </button>
+      )}
+    </div>
+  );
+}
+
+/** Reusable Preview/Edit (Source) segmented toggle, styled like the existing
+ *  markdown mode buttons. */
+function ModeToggle<T extends string>({
+  value,
+  onChange,
+  options,
+}: {
+  value: T;
+  onChange: (v: T) => void;
+  options: { value: T; label: string }[];
+}) {
+  return (
+    <div className="file-viewer-modes">
+      {options.map((o) => (
+        <button
+          key={o.value}
+          className={`file-viewer-mode${value === o.value ? " active" : ""}`}
+          aria-pressed={value === o.value}
+          onClick={() => onChange(o.value)}
+        >
+          {o.label}
+        </button>
+      ))}
+    </div>
+  );
+}
+
+/** Rendered-preview pane for HTML/SVG/CSS — a fully sandboxed (`sandbox=""`,
+ *  no scripts) iframe so even a hostile file is inert. CSS is applied to a small
+ *  sample document; HTML/SVG render their own source. */
+function RenderedPreview({
+  kind,
+  content,
+  fileName,
+}: {
+  kind: PreviewKind;
+  content: string;
+  fileName: string;
+}) {
+  const doc = useMemo(() => buildPreviewDoc(kind, content), [kind, content]);
+  return (
+    <iframe
+      // sandbox="" is intentional and load-bearing: the most restrictive
+      // sandbox, so no script in the file can run.
+      sandbox=""
+      srcDoc={doc}
+      title={`Preview of ${fileName}`}
+      className="file-viewer-html-frame"
+      style={{ width: "100%", height: "100%", border: "none", background: "#fff" }}
+    />
+  );
+}
+
+/** Markdown editing toolbar (#md-toolbar): inline/structural formatting plus a
+ *  generated table of contents, applied through the editor's imperative API so
+ *  each action is one undo step. Buttons `preventDefault` on mousedown so the
+ *  editor keeps its selection as the action's target. */
+function MarkdownToolbar({ api }: { api: React.MutableRefObject<EditorApi | null> }) {
+  const act = (fn: (v: string, s: number, e: number) => EditResult) => () =>
+    api.current?.applyEdit(fn);
+  const btn = (label: React.ReactNode, title: string, fn: (v: string, s: number, e: number) => EditResult) => (
+    <button
+      className="file-viewer-md-btn"
+      title={title}
+      aria-label={title}
+      onMouseDown={(e) => e.preventDefault()}
+      onClick={act(fn)}
+    >
+      {label}
+    </button>
+  );
+  return (
+    <div className="file-viewer-md-toolbar" role="group" aria-label="Formatting">
+      {btn(<b>B</b>, "Bold", (v, s, e) => toggleInline(v, s, e, "**"))}
+      {btn(<i>I</i>, "Italic", (v, s, e) => toggleInline(v, s, e, "_"))}
+      {btn(<span style={{ fontFamily: "var(--font-mono, monospace)" }}>{"<>"}</span>, "Inline code", (v, s, e) => toggleInline(v, s, e, "`"))}
+      {btn("H", "Cycle heading", (v, s) => cycleHeading(v, s))}
+      {btn("🔗", "Link", (v, s, e) => makeLink(v, s, e))}
+      {btn("•", "Bulleted list", (v, s, e) => toggleLinePrefix(v, s, e, "- "))}
+      {btn("TOC", "Insert table of contents", (v, s, e) => {
+        const toc = generateToc(v);
+        const ins = toc ? `${toc}\n` : "";
+        return { value: v.slice(0, s) + ins + v.slice(e), selStart: s, selEnd: s + ins.length };
+      })}
+    </div>
+  );
+}
+
+/** Resolve the per-type viewer prefs for an InternalViewer from settings (#48). */
+function useViewerPref(type: InternalViewer) {
+  return useSettingsStore((s) => s.settings?.viewer_prefs?.[type]);
+}
+
+/** What {@link useTabAiPrefs} returns: the effective autocomplete/grammar config
+ *  for the editor, plus the current control state + setters for the in-tab UI. */
+export interface TabAiPrefs {
+  ac: { enabled: boolean; preferred?: string; mode: AutocompleteMode };
+  gc: { enabled: boolean; preferred?: string };
+  autocomplete: boolean;
+  grammar: boolean;
+  mode: AutocompleteMode;
+  toggleAutocomplete: () => void;
+  toggleGrammar: () => void;
+  setMode: (m: AutocompleteMode) => void;
+}
+
+/**
+ * Tab-local AI-assist prefs (#45). Each editor tab gets its OWN autocomplete
+ * on/off, completion-length mode, and grammar on/off, overriding the per-type
+ * `viewer_prefs` default for that tab only. The override is seeded once from the
+ * tab's persisted `viewerState` and written back there (like scroll/zoom), so it
+ * survives reopening the file and an Eldrun restart. Until the user touches a
+ * control, the value tracks the per-type setting reactively; once toggled, that
+ * tab pins its own value. The `preferred` model for each task is its 🧠-menu tag
+ * (`ollama_roles.autocomplete` / `.grammar`), falling back to `ollama_model`.
+ */
+function useTabAiPrefs(tabKey: string | undefined, type: InternalViewer): TabAiPrefs {
+  const pref = useViewerPref(type);
+  // Per-task model preference (🧠 menu role chips): autocomplete and grammar can
+  // each pin a different loaded model, falling back to the default `ollama_model`
+  // when that task has no explicit assignment. Resolved against the resident set
+  // at trigger time (see the request paths above).
+  const defaultModel = useSettingsStore((s) => s.settings?.ollama_model as string | undefined);
+  const acRole = useSettingsStore((s) => s.settings?.ollama_roles?.autocomplete as string | undefined);
+  const gcRole = useSettingsStore((s) => s.settings?.ollama_roles?.grammar as string | undefined);
+  const acPreferred = acRole ?? defaultModel;
+  const gcPreferred = gcRole ?? defaultModel;
+  const defAutocomplete = pref?.autocomplete === true;
+  const defGrammar = pref?.grammar_check === true;
+  const defMode: AutocompleteMode = AC_MODES.includes(pref?.autocomplete_mode as AutocompleteMode)
+    ? (pref!.autocomplete_mode as AutocompleteMode)
+    : "sentence";
+
+  // Seed the tab-local override once from the persisted viewerState. `undefined`
+  // for a field means "no override yet" → fall through to the per-type default.
+  const [override, setOverride] = useState<{
+    autocomplete?: boolean;
+    grammar?: boolean;
+    mode?: AutocompleteMode;
+  }>(() => {
+    const vs = seedViewerState(tabKey);
+    return { autocomplete: vs?.autocomplete, grammar: vs?.grammarCheck, mode: vs?.autocompleteMode };
+  });
+
+  const persist = useCallback(
+    (patch: ViewerState) => {
+      if (tabKey) useTabsStore.getState().setViewerState(tabKey, patch);
+    },
+    [tabKey],
+  );
+
+  const autocomplete = override.autocomplete ?? defAutocomplete;
+  const grammar = override.grammar ?? defGrammar;
+  const mode = override.mode ?? defMode;
+
+  const toggleAutocomplete = useCallback(() => {
+    setOverride((o) => {
+      const next = !(o.autocomplete ?? defAutocomplete);
+      persist({ autocomplete: next });
+      return { ...o, autocomplete: next };
+    });
+  }, [persist, defAutocomplete]);
+  const toggleGrammar = useCallback(() => {
+    setOverride((o) => {
+      const next = !(o.grammar ?? defGrammar);
+      persist({ grammarCheck: next });
+      return { ...o, grammar: next };
+    });
+  }, [persist, defGrammar]);
+  const setMode = useCallback(
+    (m: AutocompleteMode) => {
+      persist({ autocompleteMode: m });
+      setOverride((o) => ({ ...o, mode: m }));
+    },
+    [persist],
+  );
+
+  return {
+    ac: { enabled: autocomplete, preferred: acPreferred, mode },
+    gc: { enabled: grammar, preferred: gcPreferred },
+    autocomplete,
+    grammar,
+    mode,
+    toggleAutocomplete,
+    toggleGrammar,
+    setMode,
+  };
+}
+
+/**
+ * Whether at least one local (Ollama) model is currently loaded into memory.
+ * Both AI-assist features the controls expose (autocomplete + grammar) run only
+ * against a resident model, so the controls hide themselves entirely when none
+ * is loaded. Mirrors the lamp logic in `LocalModelMenu`: `ollama_status` is
+ * `"loaded"` iff `/api/ps` reports a resident model.
+ *
+ * Rides the app-wide shared poller (`lib/ollamaStatus`) rather than owning a
+ * timer. This hook runs **per editable viewer tab**, so a private 5s interval
+ * made the `/api/ps` request rate a function of how many tabs happened to be
+ * open — asking the same machine-wide question N times over. One timer now
+ * serves every surface, and they all flip on the same observation.
+ */
+function useLocalModelLoaded(): boolean {
+  return useOllamaStatus() === "loaded";
+}
+
+/**
+ * In-tab AI-assist controls for the editable viewers (#45): an Autocomplete
+ * on/off toggle with a length-mode picker (Sentence/Block/Scope), and a Grammar
+ * on/off toggle. Both are local-only (Ollama). The state is tab-local (see
+ * {@link useTabAiPrefs}) — toggling here affects only this tab. Rendered in the
+ * viewer header next to the font/undo/save controls. Hidden entirely while no
+ * local model is loaded into memory, since neither feature can run then.
+ */
+function EditorAiControls({ ai }: { ai: TabAiPrefs }) {
+  const modelLoaded = useLocalModelLoaded();
+  if (!modelLoaded) return null;
+  return (
+    <div className="file-viewer-ai-controls" role="group" aria-label="AI assist">
+      <button
+        type="button"
+        className={`file-viewer-ai-btn${ai.autocomplete ? " active" : ""}`}
+        onClick={ai.toggleAutocomplete}
+        aria-pressed={ai.autocomplete}
+        title={
+          ai.autocomplete
+            ? "Local autocomplete is on (Ctrl+Space) — click to disable"
+            : "Local autocomplete is off — click to enable (needs a loaded local model)"
+        }
+      >
+        Autocomplete
+      </button>
+      {ai.autocomplete && (
+        <Dropdown
+          className="file-viewer-ai-mode"
+          value={ai.mode}
+          title="Completion length (Shift+Tab cycles it while a suggestion is showing)"
+          onChange={(v) => ai.setMode(v as AutocompleteMode)}
+          options={[
+            { value: "sentence", label: "Sentence" },
+            { value: "block", label: "Block" },
+            { value: "scope", label: "Scope" },
+          ]}
+        />
+      )}
+      <button
+        type="button"
+        className={`file-viewer-ai-btn${ai.grammar ? " active" : ""}`}
+        onClick={ai.toggleGrammar}
+        aria-pressed={ai.grammar}
+        title={
+          ai.grammar
+            ? "Local grammar check is on — click to disable"
+            : "Local grammar check is off — click to enable (needs a loaded local model)"
+        }
+      >
+        Grammar
+      </button>
+    </div>
+  );
+}
+
+// Code-editor font sizing. The default matches the .file-viewer-code CSS metrics
+// (12px / 18px); the line-height tracks the font at a fixed 1.5 ratio so the
+// gutter and overlay layers stay aligned at any size.
+export const EDITOR_FONT_DEFAULT = 12;
+export const EDITOR_FONT_MIN = 8;
+export const EDITOR_FONT_MAX = 32;
+const EDITOR_LINE_RATIO = 1.5;
+export const clampFontSize = (n: number) =>
+  Math.min(EDITOR_FONT_MAX, Math.max(EDITOR_FONT_MIN, Math.round(n)));
+
+/** Shared Ctrl/Cmd+wheel handler for the text viewers (code + markdown): scroll
+ *  up grows, down shrinks the font, mirroring the browser zoom gesture and the
+ *  Ctrl +/− keyboard shortcuts. A plain wheel (no modifier) falls through to
+ *  native scrolling. Typed structurally so both native and synthetic wheel
+ *  events satisfy it. */
+function onCtrlWheelFont(
+  e: Pick<WheelEvent, "ctrlKey" | "metaKey" | "deltaY"> & {
+    preventDefault(): void;
+  },
+  inc?: () => void,
+  dec?: () => void,
+) {
+  if (!(e.ctrlKey || e.metaKey)) return;
+  e.preventDefault();
+  if (e.deltaY < 0) inc?.();
+  else if (e.deltaY > 0) dec?.();
+}
+
+/** Bind `handler` as a NON-passive `wheel` listener through the returned callback
+ *  ref. React registers its synthetic `onWheel` passively at the document root,
+ *  so `preventDefault()` inside a React `onWheel` is ignored: a Ctrl+wheel zoom
+ *  can't stop the element from scrolling, so it scrolls to its limit and only
+ *  then does the zoom visibly "take". Attaching the listener ourselves with
+ *  `{ passive: false }` lets `preventDefault()` cancel the scroll, so Ctrl+wheel
+ *  zooms immediately and never scrolls. The callback ref re-binds cleanly across
+ *  mount/unmount (e.g. conditionally-rendered viewports). */
+export function useNonPassiveWheel(handler: (e: WheelEvent) => void) {
+  const cb = useRef(handler);
+  cb.current = handler;
+  const detach = useRef<(() => void) | null>(null);
+  return useCallback((el: HTMLElement | null) => {
+    detach.current?.();
+    detach.current = null;
+    if (el) {
+      const listener = (e: WheelEvent) => cb.current(e);
+      el.addEventListener("wheel", listener, { passive: false });
+      detach.current = () => el.removeEventListener("wheel", listener);
+    }
+  }, []);
+}
+
+/**
+ * Per-TAB editor font size (text-size +/− control, #48). The zoom is tab-local:
+ * changing it resizes only this viewer tab, not every other tab of the same
+ * type. The size is seeded once from the tab's persisted `viewerState.fontSize`
+ * and written back there (like scroll/zoom), so it survives reopening the file
+ * and an Eldrun restart. Until the user zooms this tab it tracks the per-type
+ * `viewer_prefs[type].font_size` default reactively; once zoomed, the tab pins
+ * its own size. `reset` clears the override, dropping back to that default.
+ */
+function useEditorFontSize(tabKey: string | undefined, type: InternalViewer) {
+  const pref = useViewerPref(type);
+  const typeDefault = clampFontSize(pref?.font_size ?? EDITOR_FONT_DEFAULT);
+
+  // Tab-local override, seeded once from the persisted viewerState. `undefined`
+  // means "no override yet" → fall through to the per-type default above.
+  const [override, setOverride] = useState<number | undefined>(
+    () => seedViewerState(tabKey)?.fontSize,
+  );
+  const fontSize = clampFontSize(override ?? typeDefault);
+
+  const persist = useCallback(
+    (size: number | undefined) => {
+      setOverride(size);
+      if (tabKey) useTabsStore.getState().setViewerState(tabKey, { fontSize: size });
+    },
+    [tabKey],
+  );
+  const setFontSize = useCallback(
+    (next: number) => persist(clampFontSize(next)),
+    [persist],
+  );
+
+  return {
+    fontSize,
+    lineHeight: Math.round(fontSize * EDITOR_LINE_RATIO),
+    // True once this tab has set its own size — lets surfaces with their own
+    // default (the markdown preview) leave it alone until then.
+    isCustom: override != null,
+    inc: useCallback(() => setFontSize(fontSize + 1), [setFontSize, fontSize]),
+    dec: useCallback(() => setFontSize(fontSize - 1), [setFontSize, fontSize]),
+    // Clear the tab override so it falls back to the per-type default.
+    reset: useCallback(() => persist(undefined), [persist]),
+  };
+}
+
+/** A−/A+ text-size control for the code editors, mirroring the image/PDF zoom
+ *  group. Reuses the `.file-viewer-zoom-btn` styling. */
+function FontSizeControls({
+  fontSize,
+  inc,
+  dec,
+  reset,
+}: {
+  fontSize: number;
+  inc: () => void;
+  dec: () => void;
+  reset: () => void;
+}) {
+  return (
+    <div className="file-viewer-zoom file-viewer-fontsize" role="group" aria-label="Text size">
+      <button
+        className="file-viewer-zoom-btn"
         onClick={dec}
         disabled={fontSize <= EDITOR_FONT_MIN}
         title="Decrease text size (Ctrl+−)"
@@ -2313,58 +4394,1005 @@ function useEditorJump(path: string) {
   };
 }
 
+/** One source line's git-blame attribution; mirrors the Rust `GitBlameLine`
+ *  (snake_case, read verbatim). */
+interface BlameLine {
+  line_no: number;
+  hash: string;
+  short: string;
+  author: string;
+  author_time: number;
+  summary: string;
+}
+
+/** True for git's working-tree "Not Committed Yet" pseudo-commit (all-zeros or
+ *  empty sha) — those lines get no attribution / hovercard. */
+function isUncommitted(b: BlameLine): boolean {
+  return b.hash === "" || /^0+$/.test(b.hash);
+}
+
+/** Compact relative age ("now", "3d", "2mo", "5y") from a unix epoch (seconds). */
+function blameRelDate(epochSecs: number): string {
+  if (!epochSecs) return "";
+  const secs = Math.max(0, Date.now() / 1000 - epochSecs);
+  const day = 86400;
+  if (secs < 60) return "now";
+  if (secs < 3600) return `${Math.floor(secs / 60)}m`;
+  if (secs < day) return `${Math.floor(secs / 3600)}h`;
+  if (secs < day * 30) return `${Math.floor(secs / day)}d`;
+  if (secs < day * 365) return `${Math.floor(secs / (day * 30))}mo`;
+  return `${Math.floor(secs / (day * 365))}y`;
+}
+
+/** Shorten an author for the narrow gutter ("Ada Lovelace" → "A. Lovelace"). */
+function authorAbbrev(name: string): string {
+  const parts = name.trim().split(/\s+/);
+  if (parts.length < 2 || !parts[0]) return name;
+  return `${parts[0][0]}. ${parts[parts.length - 1]}`;
+}
+
+/** Fetches per-line git blame for `path` when `enabled`, keyed by 1-based line
+ *  number. Resolves the owning project directory exactly like the autocomplete
+ *  path (longest project dir that prefixes `path`, falling back to the active
+ *  project) and calls the backend `git_blame` — which dispatches local vs remote
+ *  (SSH) transparently. A non-repo dir, a disconnected remote, or any error
+ *  yields an empty map (blame just shows nothing); it never throws. */
+function useBlame(path: string, enabled: boolean): Map<number, BlameLine> {
+  const [byLine, setByLine] = useState<Map<number, BlameLine>>(() => new Map());
+  useEffect(() => {
+    if (!enabled) {
+      setByLine(new Map());
+      return;
+    }
+    const { projects, activeId } = useProjectsStore.getState();
+    let projectDir = "";
+    for (const p of projects) {
+      const dir = resolveProjectDirectory(p);
+      if (dir && isPathWithin(path, dir) && dir.length > projectDir.length) projectDir = dir;
+    }
+    if (!projectDir) {
+      const active = projects.find((p) => p.id === activeId);
+      projectDir = active ? resolveProjectDirectory(active) : "";
+    }
+    if (!projectDir) {
+      setByLine(new Map());
+      return;
+    }
+    const relPath = relFromAbs(projectDir, path);
+    let cancelled = false;
+    invoke<BlameLine[]>("git_blame", { projectDir, relPath })
+      .then((lines) => {
+        if (cancelled) return;
+        const map = new Map<number, BlameLine>();
+        for (const l of lines) map.set(l.line_no, l);
+        setByLine(map);
+      })
+      .catch(() => {
+        if (!cancelled) setByLine(new Map());
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path, enabled]);
+  return byLine;
+}
+
+/** "Blame" toolbar toggle. When active the code editor paints a per-line blame
+ *  column in the gutter plus a faint current-line inline annotation. */
+function BlameButton({ active, toggle }: { active: boolean; toggle: () => void }) {
+  return (
+    <button
+      className={`file-viewer-format-btn file-viewer-blame-btn${active ? " active" : ""}`}
+      onMouseDown={(e) => e.preventDefault()}
+      onClick={toggle}
+      title={active ? "Hide git blame" : "Show git blame"}
+      aria-label="Toggle git blame"
+      aria-pressed={active}
+    >
+      Blame
+    </button>
+  );
+}
+
+/**
+ * The editor's debug breakpoints (#py) — the gutter's red dots.
+ *
+ * Two things make this more than a `Set<number>`:
+ *
+ *  - **They must survive edits.** A breakpoint names a line, so typing a new
+ *    import at the top of the file silently re-points every dot below it at the
+ *    wrong statement. Each draft change is therefore diffed against the previous
+ *    one and the lines are remapped (`remapBreakpoints`).
+ *  - **They must be settable only where pdb can break.** Clicking a blank line or
+ *    a comment snaps down to the next executable line rather than setting a
+ *    breakpoint pdb would reject at startup (`snapBreakpointLine`).
+ *
+ * They persist in the tab's `ViewerState`, so they survive closing the file and
+ * an Eldrun restart — the same plumbing (and the same `project.json` write) as the
+ * reader's scroll position.
+ */
+function useBreakpoints(
+  enabled: boolean,
+  draft: string,
+  loaded: boolean,
+  viewPos: ReturnType<typeof useViewerState>,
+) {
+  const [lines, setLines] = useState<number[]>(() =>
+    enabled ? (viewPos.initial?.breakpoints ?? []) : [],
+  );
+  const draftRef = useRef(draft);
+  draftRef.current = draft;
+
+  // The draft the current lines were resolved against. Seeded on first load: the
+  // editor's ""→content transition is not an edit, and diffing across it would
+  // look like "every line was replaced" and drop every restored breakpoint.
+  const prevDraft = useRef<string | null>(null);
+  useEffect(() => {
+    if (!enabled || !loaded) return;
+    const before = prevDraft.current;
+    prevDraft.current = draft;
+    if (before === null || before === draft) return;
+    setLines((cur) => {
+      if (cur.length === 0) return cur;
+      const next = remapBreakpoints(before, draft, cur);
+      // Keep the identity stable when nothing moved, so the gutter doesn't
+      // re-render on every keystroke.
+      return next.length === cur.length && next.every((l, i) => l === cur[i]) ? cur : next;
+    });
+  }, [enabled, loaded, draft]);
+
+  // Persist on change only — never on mount, which would rewrite the tab with the
+  // value we just read out of it.
+  const persistedKey = useRef<string | null>(null);
+  useEffect(() => {
+    if (!enabled) return;
+    const key = lines.join(",");
+    if (persistedKey.current === null) {
+      persistedKey.current = key;
+      return;
+    }
+    if (persistedKey.current === key) return;
+    persistedKey.current = key;
+    viewPos.persist({ breakpoints: lines });
+  }, [enabled, lines, viewPos]);
+
+  const toggle = useCallback((line: number) => {
+    setLines((cur) => {
+      if (cur.includes(line)) return cur.filter((l) => l !== line);
+      const snapped = snapBreakpointLine(draftRef.current, line);
+      if (snapped == null) return cur; // nothing executable below — no-op
+      if (cur.includes(snapped)) return cur.filter((l) => l !== snapped);
+      return [...cur, snapped].sort((a, b) => a - b);
+    });
+  }, []);
+
+  const set = useMemo(() => new Set(lines), [lines]);
+  return { lines, set, toggle };
+}
+
+/** Run / Debug (#py). Run executes the file in a fresh terminal tab; Debug does
+ *  the same under `pdb`, pre-loaded with the gutter's breakpoints.
+ *
+ *  Right-clicking Run opens a small popover to type **arguments** (`sys.argv`) —
+ *  appended to the command line and reused by every subsequent Run/Debug, so a
+ *  plain left-click re-runs with them (the tooltip shows what they are). */
+function RunDebugButtons({
+  breakpointCount,
+  busy,
+  showDebug,
+  args,
+  setArgs,
+  onRun,
+  onDebug,
+}: {
+  breakpointCount: number;
+  busy: boolean;
+  /** Debug (pdb + breakpoint gutter) is behind the experimental gate; Run isn't. */
+  showDebug: boolean;
+  /** The current argument string, and its setter (right-click popover edits it). */
+  args: string;
+  setArgs: (v: string) => void;
+  onRun: () => void;
+  onDebug: () => void;
+}) {
+  const [argsOpen, setArgsOpen] = useState(false);
+  // Hovering the Run/Debug buttons shows the saved args in an in-DOM popover — the
+  // native `title` tooltip is unreliable under WebKitGTK, so it can't be the only
+  // place the args are shown.
+  const [hovering, setHovering] = useState(false);
+  // Local draft so typing doesn't rebuild the run command on every keystroke; it
+  // is committed to the shared `args` on Run or when the popover closes.
+  const [draft, setDraft] = useState(args);
+  const wrapRef = useRef<HTMLDivElement>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const open = useCallback(() => {
+    setDraft(args);
+    setArgsOpen(true);
+  }, [args]);
+  const commit = useCallback(() => {
+    setArgs(draft.trim());
+    setArgsOpen(false);
+  }, [draft, setArgs]);
+
+  // Focus the field when the popover opens, and close it on an outside click or Esc.
+  useEffect(() => {
+    if (!argsOpen) return;
+    inputRef.current?.focus();
+    inputRef.current?.select();
+    const onDown = (e: MouseEvent) => {
+      if (wrapRef.current && !wrapRef.current.contains(e.target as Node)) commit();
+    };
+    document.addEventListener("mousedown", onDown, true);
+    return () => document.removeEventListener("mousedown", onDown, true);
+  }, [argsOpen, commit]);
+
+  return (
+    <div
+      className="file-viewer-run-controls"
+      ref={wrapRef}
+      onMouseEnter={() => setHovering(true)}
+      onMouseLeave={() => setHovering(false)}
+    >
+      <button
+        className="file-viewer-format-btn"
+        // Right-click opens the args popover. We act on mousedown, not the
+        // contextmenu event: preventing the button's default focus-steal (needed
+        // to keep the editor caret) suppresses `contextmenu` under WebKitGTK, so
+        // that event never arrives. Left-click still runs via onClick.
+        onMouseDown={(e) => {
+          e.preventDefault();
+          if (e.button === 2) open();
+        }}
+        onClick={onRun}
+        onContextMenu={(e) => e.preventDefault()}
+        disabled={busy}
+        title="Run this file in a terminal tab\nRight-click to set arguments"
+        aria-label="Run file"
+      >
+        ▶ Run{args ? " *" : ""}
+      </button>
+      {showDebug && (
+      <button
+        className="file-viewer-format-btn"
+        onMouseDown={(e) => {
+          e.preventDefault();
+          if (e.button === 2) open();
+        }}
+        onClick={onDebug}
+        onContextMenu={(e) => e.preventDefault()}
+        disabled={busy}
+        title={
+          (breakpointCount > 0
+            ? `Debug under pdb, breaking on ${breakpointCount} line${
+                breakpointCount === 1 ? "" : "s"
+              } (click the gutter to set more)`
+            : "Debug under pdb — stops at the first line. Click a line number to set a breakpoint.") +
+          "\nRight-click to set arguments"
+        }
+        aria-label="Debug file"
+      >
+        🐞 Debug
+      </button>
+      )}
+      {/* Saved-args hover hint. Shown only while hovering, only when args are set,
+          and never over the editor popover (which shows them already). */}
+      {hovering && args && !argsOpen && (
+        <div className="file-viewer-run-argshint" role="tooltip">
+          <span className="file-viewer-run-argshint-label">args:</span>
+          <span className="file-viewer-run-argshint-val">{args}</span>
+        </div>
+      )}
+      {argsOpen && (
+        <div className="file-viewer-run-args" role="dialog" aria-label="Run arguments">
+          <label className="file-viewer-run-args-label">Arguments (sys.argv)</label>
+          <input
+            ref={inputRef}
+            className="file-viewer-run-args-input"
+            value={draft}
+            spellCheck={false}
+            placeholder="--epochs 5 data.csv"
+            onChange={(e) => setDraft(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                setArgs(draft.trim());
+                setArgsOpen(false);
+                onRun();
+              } else if (e.key === "Escape") {
+                e.preventDefault();
+                setArgsOpen(false);
+              }
+            }}
+          />
+          <div className="file-viewer-run-args-row">
+            <button
+              type="button"
+              className="file-viewer-format-btn"
+              onMouseDown={(e) => e.preventDefault()}
+              onClick={() => {
+                setArgs(draft.trim());
+                setArgsOpen(false);
+                onRun();
+              }}
+            >
+              ▶ Run
+            </button>
+            <button
+              type="button"
+              className="file-viewer-format-btn"
+              onMouseDown={(e) => e.preventDefault()}
+              onClick={() => {
+                setDraft("");
+                setArgs("");
+              }}
+              disabled={!draft}
+              title="Clear arguments"
+            >
+              Clear
+            </button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+/** Human labels for the `#SBATCH` keys the directive form surfaces. */
+const SBATCH_FIELD_LABELS: Record<string, string> = {
+  "job-name": "Job name",
+  account: "Account",
+  partition: "Partition",
+  time: "Time",
+  nodes: "Nodes",
+  ntasks: "Tasks",
+  "cpus-per-task": "CPUs/task",
+  mem: "Memory",
+  gres: "GRES",
+  output: "Output",
+};
+
+/** Placeholder hints per key, so an empty field still teaches the format. */
+const SBATCH_FIELD_HINTS: Record<string, string> = {
+  "job-name": "myjob",
+  account: "your-group",
+  partition: "gpu",
+  time: "01:00:00",
+  nodes: "1",
+  ntasks: "1",
+  "cpus-per-task": "4",
+  mem: "8G",
+  gres: "gpu:1",
+  output: "slurm-%j.out",
+};
+
+/**
+ * The SLURM control bar (HPC), shown beside the Python Run bar for a `#SBATCH`
+ * script on a host that has SLURM. **Submit job** submits it and opens a log tab;
+ * **Variables** toggles the `#SBATCH` directive form (render rows, edit text — each
+ * edit splices the draft, an ordinary undoable change); **Interactive session…**
+ * opens a resource mini-form that launches an `srun --pty` shell on a compute node.
+ * Carries an `UntestedTag` until QA'd on a real cluster.
+ */
+function SlurmBar({
+  busy,
+  fields,
+  onField,
+  onSubmit,
+  onInteractive,
+}: {
+  busy: boolean;
+  fields: { key: string; value: string }[];
+  onField: (key: string, value: string) => void;
+  onSubmit: () => void;
+  onInteractive: (res: InteractiveResources) => void;
+}) {
+  const [varsOpen, setVarsOpen] = useState(false);
+  const [interOpen, setInterOpen] = useState(false);
+  // Per-field typed drafts, so a splice (and its undo step) happens on commit
+  // (blur/Enter), not on every keystroke.
+  const [edits, setEdits] = useState<Record<string, string>>({});
+  const [inter, setInter] = useState<InteractiveResources>({
+    time: "01:00:00",
+    cpus: "4",
+    mem: "8G",
+    gpus: "",
+    partition: "",
+    account: "",
+  });
+
+  const valueFor = (key: string) =>
+    edits[key] ?? directiveValue(fields, key);
+  const commit = (key: string) => {
+    const v = edits[key];
+    if (v === undefined) return;
+    onField(key, v);
+  };
+
+  return (
+    <div className="file-viewer-run-controls">
+      <button
+        className="file-viewer-format-btn"
+        onMouseDown={(e) => e.preventDefault()}
+        onClick={onSubmit}
+        disabled={busy}
+        title="Submit this job to SLURM (sbatch) and open a log tab"
+        aria-label="Submit SLURM job"
+      >
+        ⏫ Submit job
+      </button>
+      <button
+        className={`file-viewer-format-btn${varsOpen ? " active" : ""}`}
+        onMouseDown={(e) => e.preventDefault()}
+        onClick={() => { setVarsOpen((v) => !v); setInterOpen(false); }}
+        title="Edit #SBATCH directives (resources)"
+        aria-pressed={varsOpen}
+      >
+        Variables
+      </button>
+      <button
+        className={`file-viewer-format-btn${interOpen ? " active" : ""}`}
+        onMouseDown={(e) => e.preventDefault()}
+        onClick={() => { setInterOpen((v) => !v); setVarsOpen(false); }}
+        title="Open an interactive shell on a compute node (srun --pty)"
+        aria-pressed={interOpen}
+      >
+        ⚡ Interactive session…
+      </button>
+      <UntestedTag />
+
+      {varsOpen && (
+        <div className="file-viewer-run-args" role="dialog" aria-label="SBATCH variables">
+          <label className="file-viewer-run-args-label">#SBATCH directives</label>
+          <div className="slurm-directive-grid">
+            {COMMON_SBATCH_KEYS.map((key) => (
+              <label key={key} className="slurm-directive-field">
+                <span className="slurm-directive-key">{SBATCH_FIELD_LABELS[key] ?? key}</span>
+                <input
+                  className="file-viewer-run-args-input"
+                  value={valueFor(key)}
+                  spellCheck={false}
+                  placeholder={SBATCH_FIELD_HINTS[key] ?? ""}
+                  onChange={(e) => setEdits((m) => ({ ...m, [key]: e.target.value }))}
+                  onBlur={() => commit(key)}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") {
+                      e.preventDefault();
+                      commit(key);
+                    }
+                  }}
+                />
+              </label>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {interOpen && (
+        <div className="file-viewer-run-args" role="dialog" aria-label="Interactive session">
+          <label className="file-viewer-run-args-label">Interactive session (srun --pty)</label>
+          <div className="slurm-directive-grid">
+            {([
+              ["account", "Account", "your-group"],
+              ["partition", "Partition", "gpu"],
+              ["time", "Time", "01:00:00"],
+              ["cpus", "CPUs/task", "4"],
+              ["mem", "Memory", "8G"],
+              ["gpus", "GPUs", "1"],
+            ] as const).map(([k, label, hint]) => (
+              <label key={k} className="slurm-directive-field">
+                <span className="slurm-directive-key">{label}</span>
+                <input
+                  className="file-viewer-run-args-input"
+                  value={inter[k] ?? ""}
+                  spellCheck={false}
+                  placeholder={hint}
+                  onChange={(e) => setInter((s) => ({ ...s, [k]: e.target.value }))}
+                />
+              </label>
+            ))}
+          </div>
+          <div className="file-viewer-run-args-row">
+            <button
+              type="button"
+              className="file-viewer-format-btn"
+              onMouseDown={(e) => e.preventDefault()}
+              onClick={() => { setInterOpen(false); onInteractive(inter); }}
+            >
+              ⚡ Start
+            </button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+/** "Compare" toolbar toggle. When active the editor body is replaced by the
+ *  three-column compare/merge view (old commit ⇄ live content ⇄ editable result). */
+function CompareButton({ active, toggle }: { active: boolean; toggle: () => void }) {
+  return (
+    <button
+      className={`file-viewer-format-btn file-viewer-compare-btn${active ? " active" : ""}`}
+      onMouseDown={(e) => e.preventDefault()}
+      onClick={toggle}
+      title={active ? "Close compare view" : "Compare with a previous version"}
+      aria-label="Toggle compare view"
+      aria-pressed={active}
+    >
+      Compare
+    </button>
+  );
+}
+
+/**
+ * The capability-driven base editor for every text/source file. Beyond the
+ * shared code editor (highlight, line numbers, Tab indent, undo/redo, save,
+ * autocomplete) it derives per-format extras from the path:
+ *   - a "Format" button for prettifiable types (JSON in-process; CSS/HTML/JS/
+ *     YAML/Python/Rust/Go via a backend formatter when the tool is installed),
+ *   - an inline JSON/YAML validation banner with jump-to-line,
+ *   - a Preview ⇄ Edit toggle with a sandboxed rendered preview for HTML, SVG,
+ *     and CSS (CSS applied to a sample document).
+ * `type` keys the per-type prefs (font size / autocomplete); it is "text" for
+ * the generic editor and "html" for HTML files so their settings stay distinct.
+ */
 function TextView({
   path,
   onOpenExternally,
   tabKey,
+  type = "text",
+  groupId,
 }: {
   path: string;
   onOpenExternally: () => void;
   tabKey?: string;
+  type?: InternalViewer;
+  groupId?: string | null;
 }) {
   const {
     error, draft, setDraft, loaded, isDirty, saving, saveError, save,
     undo, redo, canUndo, canRedo, externalChange, reloadFromDisk, keepMine,
   } = useEditableFile(path);
-  const ac = useAutocompleteConfig("text");
-  const font = useEditorFontSize("text");
+  const ai = useTabAiPrefs(tabKey, type);
+  const ac = ai.ac;
+  const gc = ai.gc;
+  const font = useEditorFontSize(tabKey, type);
   const jump = useEditorJump(path);
+  const [showBlame, setShowBlame] = useState(false);
+  const blame = useBlame(path, showBlame);
+  const [compareOpen, setCompareOpen] = useState(false);
   const viewPos = useViewerState(tabKey);
+  // Live scroll offsets for the two views this pane toggles between: the Source
+  // code editor (`scrollTop`) and the YAML Tree (`yamlScrollTop`). Held in refs,
+  // not only persisted, because the pane stays mounted across the Tree↔Source
+  // toggle but each inner view REMOUNTS — and would otherwise seed from
+  // `viewPos.initial` (the stale open-time snapshot) and jump there. The ref
+  // carries the live position so a switch back lands where the view was left.
+  const srcScroll = useRef(viewPos.initial?.scrollTop ?? 0);
+  const yamlScroll = useRef(viewPos.initial?.yamlScrollTop ?? 0);
   const persistScroll = useCallback(
-    (scrollTop: number) => viewPos.persist({ scrollTop }),
+    (scrollTop: number) => {
+      srcScroll.current = scrollTop;
+      viewPos.persist({ scrollTop });
+    },
     [viewPos],
   );
 
+  // ── Python (#py): run/debug + breakpoints + go-to-definition ──────────────
+  // Run is available only for a "main" script — one with a module-level
+  // `if __name__ == "__main__":` guard — not for every importable .py module,
+  // which has nothing useful to execute. Debug (pdb) and the breakpoint gutter
+  // that only exists to feed it sit behind the experimental `python_run_debug`
+  // flag — off by default, on in debug mode (`lib/experimental.ts`).
+  // Go-to-definition is deliberately NOT gated: it reads, it never runs anything.
+  const isPy = useMemo(() => isPythonPath(path), [path]);
+  const pyDebugEnabled = useExperimental("python_run_debug");
+  const isMainScript = useMemo(
+    () => isPy && loaded && isPythonMainScript(draft),
+    [isPy, loaded, draft],
+  );
+  const pyRun = isMainScript;
+  const pyDebug = isMainScript && pyDebugEnabled;
+  const projectId = useFileScope();
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const projectDir = project ? resolveProjectDirectory(project) : "";
+  const bp = useBreakpoints(pyDebug, draft, loaded, viewPos);
+  const [launching, setLaunching] = useState(false);
+  // Arguments typed into the Run button's right-click popover, appended to the
+  // command line (see pythonRun.buildRunCommand). Kept PER FILE (keyed by absolute
+  // path in global settings), not per tab, so every viewer of the same script
+  // shares one set of args — edit them in one tab and the others follow live,
+  // because both read this same store selector — and so they survive closing the
+  // viewer and an Eldrun restart, and show in the Run button's hover tooltip.
+  const pyArgs = useSettingsStore((s) => s.settings?.python_run_args?.[path] ?? "");
+  const setPyArgs = useCallback(
+    (v: string) => {
+      void useSettingsStore.getState().setPythonRunArgs(path, v);
+    },
+    [path],
+  );
+  // Non-null inside a detached popout → the run terminal must stream into THIS
+  // window, not the main tab store (see placeForFocused).
+  const fileDrop = useContext(FileDropContext);
+
+  // The tab runs in the project's own scope, not whichever project happens to be
+  // active — a viewer keeps working after you switch projects (see FileScopeContext),
+  // and its Run button must not fire a terminal into a different project's layout.
+  const scope = projectId ?? "root";
+  const cwd = runCwd(projectDir, path);
+
+  const launch = useCallback(
+    async (go: () => Promise<void>) => {
+      setLaunching(true);
+      try {
+        await go();
+      } finally {
+        setLaunching(false);
+      }
+    },
+    [],
+  );
+
+  // Open the run/debug terminal in the focused subwindow of this project — where
+  // the user is looking — rather than beside this tab's group.
+  const onRun = useCallback(
+    () =>
+      void launch(() =>
+        runPythonFile({
+          file: path,
+          projectDir: cwd,
+          scope,
+          projectId,
+          args: pyArgs,
+          place: placeForFocused(fileDrop),
+        }),
+      ),
+    [launch, path, cwd, scope, projectId, pyArgs, fileDrop],
+  );
+  const onDebug = useCallback(
+    () =>
+      void launch(() =>
+        debugPythonFile({
+          file: path,
+          projectDir: cwd,
+          scope,
+          projectId,
+          breakpoints: bp.lines,
+          args: pyArgs,
+          place: placeForFocused(fileDrop),
+        }),
+      ),
+    [launch, path, cwd, scope, projectId, bp.lines, pyArgs, fileDrop],
+  );
+
+  // ── SLURM (HPC): submit / interactive on a batch script ───────────────────
+  // A `.slurm`-style file (one carrying a `#SBATCH` directive) gets a submit bar
+  // beside the Python one — but only when the project's host actually has SLURM
+  // (`slurm_available`), so the affordance never appears off-HPC. Everything here
+  // rides the same terminal-tab machinery Run uses (`lib/slurm.ts`).
+  const isSlurm = useMemo(() => loaded && isSlurmScript(draft), [loaded, draft]);
+  const [slurmInfo, setSlurmInfo] = useState<SlurmInfo | null>(null);
+  useEffect(() => {
+    if (!isSlurm || !projectDir) {
+      setSlurmInfo(null);
+      return;
+    }
+    let cancelled = false;
+    slurmAvailable(projectDir)
+      .then((info) => { if (!cancelled) setSlurmInfo(info); })
+      .catch(() => { if (!cancelled) setSlurmInfo(null); });
+    return () => { cancelled = true; };
+  }, [isSlurm, projectDir]);
+  const showSlurm = isSlurm && !!slurmInfo?.available;
+  const isRemoteProject = !!project?.remote;
+
+  const onSlurmSubmit = useCallback(
+    () =>
+      void launch(async () => {
+        if (!projectId) return;
+        await submitSlurmJob({
+          file: path,
+          projectDir,
+          cwd,
+          projectId,
+          scope,
+          isRemote: isRemoteProject,
+          place: placeForFocused(fileDrop),
+        });
+      }),
+    [launch, path, projectDir, cwd, projectId, scope, isRemoteProject, fileDrop],
+  );
+  const onSlurmInteractive = useCallback(
+    (res: InteractiveResources) => {
+      openInteractiveJob({
+        scope,
+        cwd,
+        res,
+        hostId: "primary",
+        isRemote: isRemoteProject,
+        place: placeForFocused(fileDrop),
+      });
+    },
+    [scope, cwd, isRemoteProject, fileDrop],
+  );
+
+  // Ctrl/Cmd+Click a name to open its `def`/`class` — in this file or in the
+  // module it was imported from. `jumpToSource` handles both: it re-uses an open
+  // editor when there is one (including the same file, and across a detached
+  // window) and otherwise opens the target in this tab's subwindow.
+  const followPython = useCallback(
+    async (caret: number) => {
+      const loc = await resolvePythonDefinition(draft, caret, path, projectDir, async (p) => {
+        try {
+          return await readFileText(p, projectId);
+        } catch {
+          return null; // doesn't exist / unreadable — just not this candidate
+        }
+      });
+      if (loc) jumpToSource(loc.path, loc.line, loc.column);
+    },
+    [draft, path, projectDir, projectId],
+  );
+
+  const fmt = useFormatter(path, draft, setDraft);
+  const issue = useSyntaxCheck(path, draft, loaded);
+  const previewKind = useMemo(() => previewKindForPath(path), [path]);
+  // #yaml: for YAML and JSON the "preview" is an editable structure tree rather
+  // than a rendered document — it writes back into this very draft (see YamlTree),
+  // which is what lets Tree and Source be two views on one text and keeps
+  // save/undo/format/validation working across both without either mode knowing
+  // about the other. JSON is YAML's flow syntax, so it is the same tree, written
+  // back in the stricter dialect (`strict`).
+  const isYaml = useMemo(() => isTreePath(path), [path]);
+  const jsonStrict = useMemo(() => isJsonPath(path), [path]);
+  // #yaml-grid: the CARD view for structured YAML/JSON — a recursive grid of nested
+  // cards, editing the same draft by splice (see YamlGrid). Offered only when the
+  // file actually nests a collection worth carding, so the Cards toggle appears
+  // exactly where it does something (the tree's honesty rule).
+  const gridAvailable = useMemo(
+    () => (isYaml && loaded ? hasCards(draft, jsonStrict) : false),
+    [isYaml, loaded, draft, jsonStrict],
+  );
+  // YAML/JSON opens in the TREE view by default ("preview"); HTML/SVG in preview; CSS
+  // in the editor. The card view stays available (via the toggle, when the file nests
+  // something to card) but is no longer the default — it still needs work.
+  const [mode, setMode] = useState<"preview" | "grid" | "edit">(
+    isYaml ? "preview" : previewKind === "html" || previewKind === "svg" ? "preview" : "edit",
+  );
+  // A flat file (or a card edit that removes all nesting) has no card view — retire
+  // the mode rather than strand it on a toggle with no button, dropping to the tree.
+  useEffect(() => {
+    if (mode === "grid" && !gridAvailable && loaded) setMode("preview");
+  }, [mode, gridAvailable, loaded]);
+  const fileName = basename(path);
+  const jumpToLine = useCallback(
+    (line: number, column: number) =>
+      useEditorJumpStore.getState().requestJump(path, line, column),
+    [path],
+  );
+
+  const showEditor = (!previewKind && !isYaml) || mode === "edit";
+  const wheelRef = useNonPassiveWheel((e) => {
+    onCtrlWheelFont(e, font.inc, font.dec);
+  });
+
+  // The Tree (and preview) scrolls `.file-viewer-body` itself; the Source editor
+  // scrolls its own inner viewport instead (see CodeEditor). Keep a ref to the
+  // body alongside the wheel-font ref so the tree's scroll can be persisted and
+  // restored on the switch back from Source.
+  const bodyEl = useRef<HTMLDivElement | null>(null);
+  const bodyRef = useCallback(
+    (el: HTMLDivElement | null) => {
+      bodyEl.current = el;
+      wheelRef(el);
+    },
+    [wheelRef],
+  );
+  // Only the TREE persists/restores the body's scroll (the grid scrolls its own
+  // inner table container, the editor its own viewport).
+  const treeScrolls = isYaml && mode === "preview";
+  const showGrid = isYaml && mode === "grid" && gridAvailable;
+  const scrollRaf = useRef<number | null>(null);
+  const onBodyScroll = useCallback(() => {
+    if (!treeScrolls) return;
+    const el = bodyEl.current;
+    if (!el) return;
+    yamlScroll.current = el.scrollTop;
+    // Coalesce the store write to one per frame — a flick of the wheel must not
+    // churn the tabs array (and its debounced disk save) every scroll event.
+    if (scrollRaf.current == null) {
+      scrollRaf.current = requestAnimationFrame(() => {
+        scrollRaf.current = null;
+        viewPos.persist({ yamlScrollTop: yamlScroll.current });
+      });
+    }
+  }, [treeScrolls, viewPos]);
+  useEffect(
+    () => () => {
+      if (scrollRaf.current != null) cancelAnimationFrame(scrollRaf.current);
+    },
+    [],
+  );
+  // Restore the tree's scroll when it (re)mounts — on load, and on switching back
+  // from Source. Layout effect so it lands before paint, with no visible jump.
+  useLayoutEffect(() => {
+    if (treeScrolls && loaded && bodyEl.current) {
+      bodyEl.current.scrollTop = yamlScroll.current;
+    }
+  }, [treeScrolls, loaded]);
+
+  // Print: HTML/SVG/CSS print their rendered preview document; plain text and
+  // source print as a wrapped monospace block.
+  const handlePrint = useCallback(() => {
+    if (previewKind) {
+      void printDocument(buildPreviewDoc(previewKind, draft));
+      return;
+    }
+    void printHtmlBody(
+      `<pre class="print-pre">${escapeHtml(draft)}</pre>`,
+      TEXT_PRINT_CSS,
+      fileName,
+    );
+  }, [previewKind, draft, fileName]);
+
   return (
     <div className="file-viewer">
       <ViewerHeader onOpenExternally={onOpenExternally}>
+        {(previewKind || isYaml) && (
+          <ModeToggle
+            value={mode}
+            onChange={setMode}
+            options={[
+              { value: "preview", label: isYaml ? "Tree" : "Preview" },
+              // The card view leads no longer — Tree is the default. It is still
+              // offered, but only for a file with nesting to card (the tree's
+              // honesty rule).
+              ...(gridAvailable ? [{ value: "grid" as const, label: "Cards" }] : []),
+              {
+                value: "edit",
+                label: isYaml || previewKind === "svg" ? "Source" : "Edit",
+              },
+            ]}
+          />
+        )}
         <FontSizeControls fontSize={font.fontSize} inc={font.inc} dec={font.dec} reset={font.reset} />
-        <UndoRedoButtons undo={undo} redo={redo} canUndo={canUndo} canRedo={canRedo} />
+        {/* Which machine a Run/Debug lands on — shown right next to the Run button
+            so the choice is co-located with running, and keyed by THIS viewer's
+            `projectId`, the exact scope `onRun` reads the preference back under (a
+            picker in the file panel is keyed by the *active* project, which can
+            differ from the viewed file's project → the choice would be dropped and
+            the run would fall back to the primary). Only for a remote project with
+            extra worker machines; a lone-primary project has no machine to pick. */}
+        {showEditor && pyRun && isRemoteProject && projectId &&
+          (project?.compute_hosts?.length ?? 0) > 0 && (
+            <RunHostPicker
+              projectId={projectId}
+              primaryHost={project?.remote?.label || project?.remote?.host}
+              computeHosts={project?.compute_hosts}
+            />
+          )}
+        {showEditor && pyRun && (
+          <RunDebugButtons
+            breakpointCount={bp.lines.length}
+            busy={launching}
+            showDebug={pyDebug}
+            args={pyArgs}
+            setArgs={setPyArgs}
+            onRun={onRun}
+            onDebug={onDebug}
+          />
+        )}
+        {showEditor && showSlurm && (
+          <SlurmBar
+            busy={launching}
+            fields={parseSbatchDirectives(draft)}
+            onField={(key, value) => setDraft(spliceDirective(draft, key, value))}
+            onSubmit={onSlurmSubmit}
+            onInteractive={onSlurmInteractive}
+          />
+        )}
+        {showEditor && <EditorAiControls ai={ai} />}
+        {showEditor && fmt.enabled && (
+          <FormatButton available={fmt.available} busy={fmt.busy} run={() => void fmt.run()} />
+        )}
+        {showEditor && (
+          <BlameButton active={showBlame} toggle={() => setShowBlame((v) => !v)} />
+        )}
+        {showEditor && (
+          <CompareButton active={compareOpen} toggle={() => setCompareOpen((v) => !v)} />
+        )}
+        {/* The YAML tree edits the text, so its edits are ordinary undo steps —
+            the buttons stay live in Tree mode, unlike a read-only preview. */}
+        {(showEditor || isYaml) && (
+          <UndoRedoButtons undo={undo} redo={redo} canUndo={canUndo} canRedo={canRedo} />
+        )}
+        <PrintButton onPrint={handlePrint} disabled={!loaded} />
         <SaveButton isDirty={isDirty} saving={saving} save={() => void save()} />
       </ViewerHeader>
       {externalChange && <ExternalChangeBanner onReload={reloadFromDisk} onKeep={keepMine} />}
       {saveError && <div className="file-viewer-error">{saveError}</div>}
-      <div className="file-viewer-body file-viewer-code-body">
-        <CodeEditor
-          path={path}
-          error={error}
-          draft={draft}
-          setDraft={setDraft}
-          loaded={loaded}
-          save={() => void save()}
-          undo={undo}
-          redo={redo}
-          autocomplete={ac}
-          fontSize={font.fontSize}
-          lineHeight={font.lineHeight}
-          incFont={font.inc}
-          decFont={font.dec}
-          resetFont={font.reset}
-          gotoLine={jump.gotoLine}
-          onGotoApplied={jump.onGotoApplied}
-          initialScrollTop={viewPos.initial?.scrollTop}
-          onScrollPersist={persistScroll}
-        />
+      {fmt.status && <div className="file-viewer-status-line">{fmt.status}</div>}
+      {(showEditor || isYaml) && <ValidationBanner issue={issue} onJump={jumpToLine} />}
+      <div
+        className={`file-viewer-body${showEditor ? " file-viewer-code-body" : ""}`}
+        ref={bodyRef}
+        onScroll={onBodyScroll}
+      >
+        {!showEditor && (previewKind || isYaml) ? (
+          error != null ? (
+            <div className="file-viewer-error">{error}</div>
+          ) : !loaded ? (
+            <div className="file-viewer-loading">Loading…</div>
+          ) : showGrid ? (
+            // The grid edits the same draft by splice, just like the tree — a cell
+            // edit is dirty, undoable and saveable exactly like a typed one.
+            <YamlGrid
+              text={draft}
+              onChange={setDraft}
+              tabKey={tabKey}
+              fontSize={font.isCustom ? font.fontSize : undefined}
+              strict={jsonStrict}
+            />
+          ) : isYaml ? (
+            // The tree edits the draft in place — the same draft Source shows and
+            // Ctrl+S writes, so an edit made here is dirty, undoable and saveable
+            // exactly like a typed one.
+            <YamlTree
+              text={draft}
+              onChange={setDraft}
+              tabKey={tabKey}
+              fontSize={font.isCustom ? font.fontSize : undefined}
+              strict={jsonStrict}
+            />
+          ) : (
+            // Preview reflects the live draft, so it tracks unsaved edits.
+            <RenderedPreview kind={previewKind!} content={draft} fileName={fileName} />
+          )
+        ) : compareOpen ? (
+          <CompareView
+            path={path}
+            rightText={draft}
+            onApply={(merged) => {
+              setDraft(merged);
+              setCompareOpen(false);
+            }}
+            onClose={() => setCompareOpen(false)}
+          />
+        ) : (
+          <CodeEditor
+            path={path}
+            error={error}
+            draft={draft}
+            setDraft={setDraft}
+            loaded={loaded}
+            save={() => void save()}
+            undo={undo}
+            redo={redo}
+            autocomplete={ac}
+            grammarCheck={gc}
+            fontSize={font.fontSize}
+            lineHeight={font.lineHeight}
+            incFont={font.inc}
+            decFont={font.dec}
+            resetFont={font.reset}
+            wrap
+            gotoLine={jump.gotoLine}
+            onGotoApplied={jump.onGotoApplied}
+            showBlame={showBlame}
+            blame={blame}
+            breakpoints={pyDebug ? bp.set : undefined}
+            onToggleBreakpoint={pyDebug ? bp.toggle : undefined}
+            onFollowLink={isPy ? followPython : undefined}
+            linkRanges={isPy ? pythonLinkRanges : undefined}
+            // The LIVE offset (not `viewPos.initial`), so re-showing Source after
+            // a trip through Tree restores where the editor was, not the stale
+            // open-time snapshot.
+            initialScrollTop={srcScroll.current}
+            onScrollPersist={persistScroll}
+            groupId={groupId}
+          />
+        )}
       </div>
     </div>
   );
@@ -2374,25 +5402,114 @@ function MarkdownView({
   path,
   onOpenExternally,
   tabKey,
+  groupId,
 }: {
   path: string;
   onOpenExternally: () => void;
   tabKey?: string;
+  groupId?: string | null;
 }) {
   const {
     error, draft, setDraft, loaded, isDirty, saving, saveError, save,
     undo, redo, canUndo, canRedo, externalChange, reloadFromDisk, keepMine,
   } = useEditableFile(path);
+  const scope = useFileScope();
   const [mode, setMode] = useState<"preview" | "edit">("preview");
-  const font = useEditorFontSize("markdown");
+  const [compareOpen, setCompareOpen] = useState(false);
+  const font = useEditorFontSize(tabKey, "markdown");
+  const wheelRef = useNonPassiveWheel((e) => onCtrlWheelFont(e, font.inc, font.dec));
+  // Proportional scroll-link (preview mode only — edit mode links via CodeEditor's
+  // textarea). `.file-viewer-body` is the overflow:auto scroller for the preview.
+  const bodyScrollRef = useRef<HTMLDivElement | null>(null);
+  const setBodyRef = useCallback(
+    (el: HTMLDivElement | null) => {
+      wheelRef(el);
+      bodyScrollRef.current = el;
+    },
+    [wheelRef],
+  );
+  const ai = useTabAiPrefs(tabKey, "markdown");
+  const ac = ai.ac;
+  const gc = ai.gc;
+  const fmt = useFormatter(path, draft, setDraft);
+  // Imperative editor handle the formatting toolbar drives (bold/italic/TOC/…).
+  const editorApi = useRef<EditorApi | null>(null);
+  const viewPos = useViewerState(tabKey);
+  const persistScroll = useCallback(
+    (scrollTop: number) => viewPos.persist({ scrollTop }),
+    [viewPos],
+  );
   // Preview always reflects the live draft, so toggling shows unsaved edits.
   const html = useMemo(() => (loaded ? renderMarkdown(draft) : ""), [loaded, draft]);
+  // Register the preview scroller only while in preview mode, so it never fights
+  // CodeEditor for the same group id (edit mode links via the textarea instead).
+  const reportPreviewSync = useScrollSync(mode === "preview" ? groupId : null, bodyScrollRef);
+
+  // After the preview HTML is committed to the DOM, run the mermaid/KaTeX
+  // enrichment pass (Dev A): it finds the mermaid code blocks and math
+  // placeholders renderMarkdown emitted and renders them in place. Re-runs
+  // whenever the rendered HTML changes or we switch back to preview mode.
+  const previewRef = useRef<HTMLDivElement | null>(null);
+  useEffect(() => {
+    if (mode !== "preview") return;
+    const el = previewRef.current;
+    if (!el) return;
+    void enrichMarkdownDom(el);
+  }, [html, mode]);
 
   // #49/#50: local-file links in the rendered preview open in-app on
   // Ctrl/Cmd+Click (matching the LaTeX editor). A hover hint advertises the
   // shortcut. `linkTip` anchors that hint above the hovered link.
   const [linkTip, setLinkTip] = useState<{ left: number; top: number } | null>(null);
 
+  // #50: inline local images in the preview. The renderer tags relative/absolute
+  // image paths as <img.md-img-local data-md-src="…"> (no `src`, since the webview
+  // can't load them from the app origin); resolve each against the markdown file's
+  // directory, read the bytes, and swap in a Blob URL. URLs are revoked when the
+  // rendered html changes or on unmount. Shares `previewRef` with the enrichment
+  // pass above — both target the same rendered-preview container.
+  useEffect(() => {
+    if (mode !== "preview") return;
+    const root = previewRef.current;
+    if (!root) return;
+    const imgs = Array.from(
+      root.querySelectorAll<HTMLImageElement>("img.md-img-local[data-md-src]"),
+    );
+    if (!imgs.length) return;
+    let cancelled = false;
+    const urls: string[] = [];
+    for (const img of imgs) {
+      const target = resolveLocalHref(path, img.getAttribute("data-md-src") ?? "");
+      if (!target) continue;
+      readFileBytes(target, scope)
+        .then((bytes) => {
+          if (cancelled) return;
+          const objectUrl = URL.createObjectURL(
+            new Blob([new Uint8Array(bytes)], { type: imageMimeForPath(target) }),
+          );
+          urls.push(objectUrl);
+          img.src = objectUrl;
+        })
+        .catch(() => { /* missing/unreadable file: leave the alt text showing */ });
+    }
+    return () => {
+      cancelled = true;
+      for (const u of urls) URL.revokeObjectURL(u);
+    };
+  }, [html, mode, path, scope]);
+
+  // Print the rendered Markdown. Prefer the live preview DOM (it carries the
+  // enriched mermaid/KaTeX output and inlined local images); fall back to a fresh
+  // render of the current draft when Edit mode has the preview unmounted.
+  const handlePrint = useCallback(() => {
+    const inner = previewRef.current?.innerHTML || html || renderMarkdown(draft);
+    void printHtmlBody(
+      `<div class="markdown-body">${inner}</div>`,
+      MARKDOWN_PRINT_CSS,
+      basename(path),
+    );
+  }, [html, draft, path]);
+
   const onPreviewMove = useCallback((e: React.MouseEvent<HTMLDivElement>) => {
     const a = (e.target as HTMLElement).closest?.("a.file-link") as HTMLElement | null;
     if (!a) {
@@ -2413,48 +5530,15 @@ function MarkdownView({
       if (!(e.ctrlKey || e.metaKey)) return;
       const target = resolveLocalHref(path, a.getAttribute("href") ?? "");
       if (!target) return;
-      openLinkedFile(tabKey, path.slice(0, path.lastIndexOf("/")), {
+      openLinkedFile(tabKey, dirname(path), {
         path: target,
         viewer: viewerForPath(target),
-        label: target.slice(target.lastIndexOf("/") + 1),
+        label: basename(target),
       });
     },
     [path, tabKey],
   );
 
-  const onKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-    if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "s") {
-      e.preventDefault();
-      void save();
-      return;
-    }
-    // #46 undo/redo for the plain markdown editor textarea.
-    if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "z") {
-      e.preventDefault();
-      if (e.shiftKey) redo();
-      else undo();
-      return;
-    }
-    if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "y") {
-      e.preventDefault();
-      redo();
-      return;
-    }
-    // Text size: Ctrl/Cmd with "+"/"=" grows, "-" shrinks, "0" resets.
-    if (e.ctrlKey || e.metaKey) {
-      if (e.key === "+" || e.key === "=") {
-        e.preventDefault();
-        font.inc();
-      } else if (e.key === "-" || e.key === "_") {
-        e.preventDefault();
-        font.dec();
-      } else if (e.key === "0") {
-        e.preventDefault();
-        font.reset();
-      }
-    }
-  };
-
   return (
     <div className="file-viewer">
       <ViewerHeader onOpenExternally={onOpenExternally}>
@@ -2474,419 +5558,151 @@ function MarkdownView({
             Edit
           </button>
         </div>
+        {mode === "edit" && <MarkdownToolbar api={editorApi} />}
         <FontSizeControls fontSize={font.fontSize} inc={font.inc} dec={font.dec} reset={font.reset} />
+        {mode === "edit" && <EditorAiControls ai={ai} />}
+        {mode === "edit" && fmt.enabled && (
+          <FormatButton available={fmt.available} busy={fmt.busy} run={() => void fmt.run()} />
+        )}
+        {mode === "edit" && (
+          <CompareButton active={compareOpen} toggle={() => setCompareOpen((v) => !v)} />
+        )}
         {mode === "edit" && (
           <UndoRedoButtons undo={undo} redo={redo} canUndo={canUndo} canRedo={canRedo} />
         )}
+        <PrintButton onPrint={handlePrint} disabled={!loaded} />
         <SaveButton isDirty={isDirty} saving={saving} save={() => void save()} />
       </ViewerHeader>
       {externalChange && <ExternalChangeBanner onReload={reloadFromDisk} onKeep={keepMine} />}
       {saveError && <div className="file-viewer-error">{saveError}</div>}
+      {mode === "edit" && fmt.status && (
+        <div className="file-viewer-status-line">{fmt.status}</div>
+      )}
       <div
-        className="file-viewer-body"
-        onWheel={(e) => onCtrlWheelFont(e, font.inc, font.dec)}
+        className={`file-viewer-body${mode === "edit" ? " file-viewer-code-body" : ""}`}
+        ref={setBodyRef}
+        onScroll={reportPreviewSync}
       >
-        {error != null ? (
+        {mode === "edit" && compareOpen ? (
+          <CompareView
+            path={path}
+            rightText={draft}
+            onApply={(merged) => {
+              setDraft(merged);
+              setCompareOpen(false);
+            }}
+            onClose={() => setCompareOpen(false)}
+          />
+        ) : mode === "edit" ? (
+          // The shared code editor gives markdown the same Tab/undo/save behaviour
+          // as the text/tex viewers — and local autocomplete (#45). `wrap` so prose
+          // soft-wraps. It renders its own load/error states.
+          <CodeEditor
+            path={path}
+            error={error}
+            draft={draft}
+            setDraft={setDraft}
+            loaded={loaded}
+            save={() => void save()}
+            undo={undo}
+            redo={redo}
+            autocomplete={ac}
+            grammarCheck={gc}
+            fontSize={font.fontSize}
+            lineHeight={font.lineHeight}
+            incFont={font.inc}
+            decFont={font.dec}
+            resetFont={font.reset}
+            wrap
+            editorApiRef={editorApi}
+            initialScrollTop={viewPos.initial?.scrollTop}
+            onScrollPersist={persistScroll}
+            groupId={groupId}
+          />
+        ) : error != null ? (
           <div className="file-viewer-error">{error}</div>
         ) : !loaded ? (
           <div className="file-viewer-loading">Loading…</div>
-        ) : mode === "edit" ? (
-          <textarea
-            className="file-viewer-editor"
-            value={draft}
-            spellCheck={false}
-            style={{ fontSize: `${font.fontSize}px`, lineHeight: `${font.lineHeight}px` }}
-            onChange={(e) => setDraft(e.target.value)}
-            onKeyDown={onKeyDown}
-          />
         ) : (
           <div
+            ref={previewRef}
             className="markdown-body"
-            // Leave the preview at its CSS default until the user sets a size,
-            // then drive the base font-size so headings (em-based) scale with it.
-            style={font.isCustom ? { fontSize: `${font.fontSize}px` } : undefined}
-            onMouseMove={onPreviewMove}
-            onMouseLeave={() => setLinkTip(null)}
-            onClick={onPreviewClick}
-            dangerouslySetInnerHTML={{ __html: html }}
-          />
-        )}
-      </div>
-      {mode === "preview" && <LinkOpenHint at={linkTip} />}
-    </div>
-  );
-}
-
-/** Load a file's bytes and expose them as a Blob object URL, used by the image
- *  viewer (<img> sniffs the type). Like the editors/PDF (#43), it polls
- *  `file_mtime` and re-reads the bytes when the file changes on disk, so an image
- *  regenerated by an external tool updates in place. A same-path reload swaps the
- *  URL only once the new bytes are ready (no flash to a loading state); the old
- *  URL is revoked then, and the last URL is revoked on unmount. */
-function useBlobUrl(path: string, type: string) {
-  const [url, setUrl] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const urlRef = useRef<string | null>(null);
-  const lastMtime = useRef<number | null>(null);
-  // Bumped whenever the file's mtime advances on disk, forcing a byte reload.
-  const [diskVersion, setDiskVersion] = useState(0);
-
-  // Reset to the loading state when the path itself changes (a genuine file
-  // switch). A same-path reload (a diskVersion bump) keeps the current image up
-  // until the fresh bytes arrive, so the view doesn't flash.
-  useEffect(() => {
-    setUrl(null);
-    setError(null);
-    lastMtime.current = null;
-  }, [path]);
-
-  // Load on mount, path switch, or on-disk change; revoke the previous URL only
-  // once its replacement is ready.
-  useEffect(() => {
-    let cancelled = false;
-    invoke<number[]>("read_file_bytes", { path })
-      .then((bytes) => {
-        if (cancelled) return;
-        const blob = new Blob([new Uint8Array(bytes)], type ? { type } : undefined);
-        const objectUrl = URL.createObjectURL(blob);
-        const prev = urlRef.current;
-        urlRef.current = objectUrl;
-        setUrl(objectUrl);
-        if (prev) URL.revokeObjectURL(prev);
-      })
-      .catch((e) => { if (!cancelled) setError(String(e)); });
-    return () => { cancelled = true; };
-  }, [path, type, diskVersion]);
-
-  // Revoke the last live URL on unmount.
-  useEffect(
-    () => () => {
-      if (urlRef.current) {
-        URL.revokeObjectURL(urlRef.current);
-        urlRef.current = null;
-      }
-    },
-    [],
-  );
-
-  // Poll mtime; on an external advance, bump diskVersion to re-read fresh bytes.
-  useEffect(() => {
-    let cancelled = false;
-    invoke<number>("file_mtime", { path })
-      .then((m) => { if (!cancelled) lastMtime.current = m; })
-      .catch(() => {});
-    const id = setInterval(() => {
-      invoke<number>("file_mtime", { path })
-        .then((m) => {
-          if (cancelled || lastMtime.current == null || m <= lastMtime.current) return;
-          lastMtime.current = m;
-          setDiskVersion((v) => v + 1);
-        })
-        .catch(() => {});
-    }, RELOAD_POLL_MS);
-    return () => { cancelled = true; clearInterval(id); };
-  }, [path]);
-
-  return { url, error };
-}
-
-const PDF_MIN_SCALE = 0.1;
-const PDF_MAX_SCALE = 8;
-const PDF_ZOOM_STEP = 1.2;
-const clampPdfScale = (s: number) => Math.min(PDF_MAX_SCALE, Math.max(PDF_MIN_SCALE, s));
-
-/** One PDF page rendered to a canvas at `scale` (× devicePixelRatio for
- *  crispness). Re-renders when the page or scale changes; cancels an in-flight
- *  render on cleanup so rapid zooming doesn't paint stale frames. */
-function PdfPageCanvas({
-  doc,
-  pageNumber,
-  scale,
-  cssSize,
-  onSyncClick,
-  syncArmed,
-  highlight,
-}: {
-  doc: PDFDocumentProxy;
-  pageNumber: number;
-  scale: number;
-  /** This page's intrinsic (scale-1) CSS dimensions, if known. Used to RESERVE
-   *  the canvas's on-screen size immediately — before its async render fills
-   *  pixels — so the page stack reaches its true scroll height right away. Without
-   *  this the canvas defaults to ~150px until rendered, so the container height
-   *  grows page-by-page and a deep restored scroll position is unreachable until
-   *  every page above it has rendered (#viewerpos PDF restore). */
-  cssSize?: { w: number; h: number };
-  /** SyncTeX reverse search: a click maps to big points on this page. */
-  onSyncClick?: (page: number, xBp: number, yBp: number) => void;
-  /** True while Ctrl/⌘ is held, so the page shows the reverse-search cursor. */
-  syncArmed?: boolean;
-  /** SyncTeX forward search: when this page is the target, the box (big points)
-   *  to scroll into view and flash. `nonce` re-triggers a repeat reveal.
-   *  `phrase`, when set, narrows the box to the clicked word via the page's text
-   *  content (using the surrounding words to disambiguate). */
-  highlight?: { rect: SyncRect; nonce: number; phrase?: CaretPhrase } | null;
-}) {
-  const canvasRef = useRef<HTMLCanvasElement>(null);
-  const wrapRef = useRef<HTMLDivElement>(null);
-  const boxRef = useRef<HTMLDivElement>(null);
-  // A SyncTeX box narrowed to the clicked word (when `highlight.phrase` is set and
-  // found in this page's text), else null → the original line box is used.
-  const [refined, setRefined] = useState<SyncRect | null>(null);
-  // A transient marker at the point the user reverse-search-clicked (CSS px within
-  // the page wrapper), giving the jump visible feedback on the PDF side; it
-  // auto-clears after ~2s. `nonce` re-triggers the fade for a repeat click on the
-  // same spot. See `onClick`.
-  const [clickMark, setClickMark] = useState<{ left: number; top: number; nonce: number } | null>(null);
-  const clickTimer = useRef<number | null>(null);
-  useEffect(() => () => { if (clickTimer.current != null) window.clearTimeout(clickTimer.current); }, []);
-
-  useEffect(() => {
-    let cancelled = false;
-    let task: { cancel: () => void; promise: Promise<void> } | null = null;
-    (async () => {
-      const page = await doc.getPage(pageNumber);
-      if (cancelled) return;
-      const dpr = window.devicePixelRatio || 1;
-      const viewport = page.getViewport({ scale: scale * dpr });
-      const canvas = canvasRef.current;
-      const ctx = canvas?.getContext("2d");
-      if (!canvas || !ctx) return;
-      canvas.width = Math.floor(viewport.width);
-      canvas.height = Math.floor(viewport.height);
-      canvas.style.width = `${viewport.width / dpr}px`;
-      canvas.style.height = `${viewport.height / dpr}px`;
-      task = page.render({ canvasContext: ctx, viewport });
-      try {
-        await task.promise;
-      } catch {
-        /* render cancelled by a newer scale — ignore */
-      }
-    })();
-    return () => {
-      cancelled = true;
-      task?.cancel();
-    };
-  }, [doc, pageNumber, scale]);
-
-  // Narrow the SyncTeX line box to the clicked word: pull this page's text runs
-  // (big points, top-left origin, at viewport scale 1) and find the word nearest
-  // the line box. Best-effort — on no match (or no word) the original box stands.
-  useEffect(() => {
-    setRefined(null);
-    const phrase = highlight?.phrase;
-    if (!highlight || !phrase) return;
-    let cancelled = false;
-    (async () => {
-      try {
-        const page = await doc.getPage(pageNumber);
-        const viewport = page.getViewport({ scale: 1 });
-        const content = await page.getTextContent();
-        if (cancelled) return;
-        const items: TextItemBox[] = [];
-        for (const it of content.items) {
-          // Skip marked-content markers (no `str`/`transform`).
-          if (!("str" in it) || typeof it.str !== "string" || !it.str) continue;
-          const tx = pdfjs.Util.transform(viewport.transform, it.transform);
-          const em = Math.hypot(tx[2], tx[3]); // scaled font size (em) in big points
-          // `tx[5]` is the text baseline. A full-em box above it rides high over
-          // the glyphs and clips descenders; box the ascender→descender band
-          // instead (≈0.8 em up, ≈0.2 em down) so the marker hugs the word.
-          const ascent = em * 0.8;
-          const descent = em * 0.2;
-          items.push({ str: it.str, x: tx[4], y: tx[5] - ascent, w: it.width, h: ascent + descent });
-        }
-        const r = refineToWord(highlight.rect, phrase, items);
-        if (!cancelled && r) setRefined(r);
-      } catch {
-        /* fall back to the synctex box */
-      }
-    })();
-    return () => { cancelled = true; };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [highlight?.nonce]);
-
-  // Scroll a forward-search target into view on a new nonce. Center the
-  // highlight *box*, not the whole page — on a tall page the target line can sit
-  // far from page-center, which is what made the jump feel imprecise.
-  useEffect(() => {
-    if (!highlight) return;
-    (boxRef.current ?? wrapRef.current)?.scrollIntoView({ block: "center", inline: "nearest" });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [highlight?.nonce]);
-
-  const onClick = (e: React.MouseEvent<HTMLCanvasElement>) => {
-    // Reverse search is a Ctrl/⌘-click affordance; plain clicks stay free for
-    // text selection in the PDF.
-    if (!onSyncClick || !(e.ctrlKey || e.metaKey)) return;
-    const rect = e.currentTarget.getBoundingClientRect();
-    const { x, y } = pdfPointToBigPoints(rect, e.clientX, e.clientY, scale);
-    // Mark the clicked point so the source-jump has feedback on the PDF side; the
-    // canvas sits flush at the wrapper's top-left, so canvas-local offsets are
-    // wrapper-local. Clear any prior marker's timer and fade out after ~2s.
-    setClickMark((m) => ({
-      left: e.clientX - rect.left,
-      top: e.clientY - rect.top,
-      nonce: (m?.nonce ?? 0) + 1,
-    }));
-    if (clickTimer.current != null) window.clearTimeout(clickTimer.current);
-    clickTimer.current = window.setTimeout(() => setClickMark(null), 2000);
-    onSyncClick(pageNumber, x, y);
-  };
-
-  const box = highlight ? bigPointsToCssRect(refined ?? highlight.rect, scale) : null;
-
-  return (
-    <div className="file-viewer-pdf-page-wrap" ref={wrapRef}>
-      <canvas
-        ref={canvasRef}
-        className={`file-viewer-pdf-page${onSyncClick && syncArmed ? " is-syncable" : ""}`}
-        // Reserve the page's true size up-front (the async render sets the same
-        // values once pixels are ready), so the stack's scroll height is correct
-        // immediately and a restored scroll position is reachable on the first
-        // ResizeObserver tick rather than only after every page has rendered.
-        style={cssSize ? { width: cssSize.w * scale, height: cssSize.h * scale } : undefined}
-        onClick={onClick}
-      />
-      {box && (
-        <div
-          key={highlight!.nonce}
-          ref={boxRef}
-          className="file-viewer-pdf-sync-highlight"
-          style={{ left: box.left, top: box.top, width: box.width, height: box.height }}
-        />
-      )}
-      {clickMark && (
-        <div
-          key={`click-${clickMark.nonce}`}
-          className="file-viewer-pdf-click-mark"
-          style={{ left: clickMark.left, top: clickMark.top }}
-        />
-      )}
+            // Leave the preview at its CSS default until the user sets a size,
+            // then drive the base font-size so headings (em-based) scale with it.
+            style={font.isCustom ? { fontSize: `${font.fontSize}px` } : undefined}
+            onMouseMove={onPreviewMove}
+            onMouseLeave={() => setLinkTip(null)}
+            onClick={onPreviewClick}
+            dangerouslySetInnerHTML={{ __html: html }}
+          />
+        )}
+      </div>
+      {mode === "preview" && <LinkOpenHint at={linkTip} />}
     </div>
   );
 }
 
-/**
- * Reusable pdf.js-backed PDF view: a zoom toolbar over a scrolling stack of page
- * canvases. Unlike the old native `<iframe>`, every surface here is ours, so the
- * surround and (via the global scrollbar rules) the scrollbar follow the app
- * theme — giving a dark viewer in dark themes while the pages stay as authored.
- *
- * The bytes at `path` can change under us — e.g. the LaTeX viewer recompiles the
- * PDF this tab is showing — so we poll `file_mtime` and reload when it advances,
- * the PDF counterpart to the editors' diff-aware reload (#43).
- */
-function PdfCanvas({
-  path,
-  onOpenExternally,
-  tabKey,
-}: {
-  path: string;
-  /** When set, an "Open externally" button is shown at the end of the toolbar.
-   *  Used by the standalone PDF tab, which has no separate header row. */
-  onOpenExternally?: () => void;
-  /** This viewer tab's key, for #viewerpos scroll/zoom persistence. */
-  tabKey?: string;
-}) {
-  const viewPos = useViewerState(tabKey);
-  const [doc, setDoc] = useState<PDFDocumentProxy | null>(null);
+/** Load a file's bytes and expose them as a Blob object URL, used by the image
+ *  viewer (<img> sniffs the type). Like the editors/PDF (#43), it polls
+ *  `file_mtime` and re-reads the bytes when the file changes on disk, so an image
+ *  regenerated by an external tool updates in place. A same-path reload swaps the
+ *  URL only once the new bytes are ready (no flash to a loading state); the old
+ *  URL is revoked then, and the last URL is revoked on unmount. */
+function useBlobUrl(path: string, type: string) {
+  const scope = useFileScope();
+  const [url, setUrl] = useState<string | null>(null);
   const [error, setError] = useState<string | null>(null);
-  // Restore the saved zoom if there is one; otherwise the load effect fits the
-  // page width. `1.2` is only the pre-load placeholder.
-  const [scale, setScale] = useState(viewPos.initial?.scale ?? 1.2);
-  const scrollRef = useRef<HTMLDivElement>(null);
-  const contentRef = useRef<HTMLDivElement>(null);
-  // True once the first document load has run, so only that load restores the
-  // session-persisted scroll/zoom (#viewerpos); later reloads behave as before.
-  const didInitialLoad = useRef(false);
-  // After a Ctrl+wheel zoom changes `scale`, the page canvases re-render to the
-  // new size asynchronously. We stash the scroll target that keeps the cursor's
-  // document point fixed and apply it once the content has actually resized.
-  const pendingScroll = useRef<{ top: number; left: number } | null>(null);
+  const urlRef = useRef<string | null>(null);
+  const lastMtime = useRef<number | null>(null);
   // Bumped whenever the file's mtime advances on disk, forcing a byte reload.
   const [diskVersion, setDiskVersion] = useState(0);
-  const lastMtime = useRef<number | null>(null);
-  // The path the currently-loaded document came from. A reload that keeps the
-  // same path (a recompile bumped `diskVersion`) should preserve the reader's
-  // scroll position; switching to a different file should not.
-  const loadedPath = useRef<string | null>(null);
-  // Scroll target to restore after a same-path reload (a recompile). The page
-  // canvases re-render asynchronously, so the content grows over several frames;
-  // the ResizeObserver below re-applies this until the position is reachable.
-  const restoreScroll = useRef<{ top: number; left: number } | null>(null);
-  // True when the document about to load is a same-path reload (a recompile
-  // rewrote this PDF). The fit effect reads it to keep the reader's current zoom
-  // instead of snapping back to fit-width. Set at load-start so it reflects the
-  // load that produced the current `doc`, regardless of effect timing.
-  const reloadKeepZoom = useRef(false);
-  // True when a `.synctex(.gz)` sits beside the PDF, enabling reverse search.
-  const [syncable, setSyncable] = useState(false);
-  // True while Ctrl/⌘ is held: reverse-search clicks fire and pages show the
-  // crosshair cursor only then, leaving plain clicks free for text selection.
-  const [syncArmed, setSyncArmed] = useState(false);
-  useEffect(() => {
-    if (!syncable) return;
-    const sync = (e: KeyboardEvent | MouseEvent) =>
-      setSyncArmed(e.ctrlKey || e.metaKey);
-    const clear = () => setSyncArmed(false);
-    window.addEventListener("keydown", sync);
-    window.addEventListener("keyup", sync);
-    window.addEventListener("mousemove", sync);
-    window.addEventListener("blur", clear);
-    return () => {
-      window.removeEventListener("keydown", sync);
-      window.removeEventListener("keyup", sync);
-      window.removeEventListener("mousemove", sync);
-      window.removeEventListener("blur", clear);
-    };
-  }, [syncable]);
-
-  // SyncTeX forward search: a pending reveal/highlight request for this PDF.
-  // Copied into local state so we can consume the store request immediately
-  // (avoiding a re-fire) while keeping the highlight mounted to animate.
-  const reveal = usePdfSyncStore((s) => s.byPath[path] ?? null);
-  const consumeReveal = usePdfSyncStore((s) => s.consume);
-  const [highlight, setHighlight] = useState<{ rect: SyncRect; nonce: number; phrase?: CaretPhrase } | null>(null);
+
+  // Reset to the loading state when the path itself changes (a genuine file
+  // switch). A same-path reload (a diskVersion bump) keeps the current image up
+  // until the fresh bytes arrive, so the view doesn't flash.
   useEffect(() => {
-    if (!reveal) return;
-    setHighlight({ rect: reveal.rect, nonce: reveal.nonce, phrase: reveal.phrase });
-    consumeReveal(path);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [reveal?.nonce]);
+    setUrl(null);
+    setError(null);
+    lastMtime.current = null;
+  }, [path]);
 
-  // Probe for SyncTeX data beside the PDF; re-checked after each disk change
-  // (a recompile may have just written it).
+  // Load on mount, path switch, or on-disk change; revoke the previous URL only
+  // once its replacement is ready.
   useEffect(() => {
     let cancelled = false;
-    const base = path.replace(/\.pdf$/i, "");
-    const exists = (p: string) =>
-      invoke<number>("file_mtime", { path: p }).then(() => true).catch(() => false);
-    void Promise.all([exists(`${base}.synctex.gz`), exists(`${base}.synctex`)]).then(
-      ([gz, raw]) => { if (!cancelled) setSyncable(gz || raw); },
-    );
+    readFileBytes(path, scope)
+      .then((bytes) => {
+        if (cancelled) return;
+        const blob = new Blob([new Uint8Array(bytes)], type ? { type } : undefined);
+        const objectUrl = URL.createObjectURL(blob);
+        const prev = urlRef.current;
+        urlRef.current = objectUrl;
+        setUrl(objectUrl);
+        if (prev) URL.revokeObjectURL(prev);
+      })
+      .catch((e) => { if (!cancelled) setError(describeFileError(e)); });
     return () => { cancelled = true; };
-  }, [path, diskVersion]);
+  }, [path, type, diskVersion, scope]);
 
-  // Reverse search: a click on a page → which source line produced it → jump.
-  const onSyncClick = useCallback(
-    async (page: number, x: number, y: number) => {
-      const src = await synctexEdit(path, page, x, y);
-      if (src) jumpToSource(src.input, src.line, src.column);
+  // Revoke the last live URL on unmount.
+  useEffect(
+    () => () => {
+      if (urlRef.current) {
+        URL.revokeObjectURL(urlRef.current);
+        urlRef.current = null;
+      }
     },
-    [path],
+    [],
   );
 
-  // Poll mtime; on an advance (e.g. a recompile wrote a new PDF), bump
-  // diskVersion so the load effect re-reads the fresh bytes (#43-style).
+  // Poll mtime; on an external advance, bump diskVersion to re-read fresh bytes.
   useEffect(() => {
-    lastMtime.current = null;
     let cancelled = false;
-    invoke<number>("file_mtime", { path })
+    fileMtime(path, scope)
       .then((m) => { if (!cancelled) lastMtime.current = m; })
       .catch(() => {});
     const id = setInterval(() => {
-      invoke<number>("file_mtime", { path })
+      fileMtime(path, scope)
         .then((m) => {
           if (cancelled || lastMtime.current == null || m <= lastMtime.current) return;
           lastMtime.current = m;
@@ -2895,302 +5711,11 @@ function PdfCanvas({
         .catch(() => {});
     }, RELOAD_POLL_MS);
     return () => { cancelled = true; clearInterval(id); };
-  }, [path]);
-
-  // Load (and reload on path / disk change) the document. pdf.js detaches the
-  // backing buffer, so each load gets a fresh Uint8Array; the prior document is
-  // destroyed on cleanup to free worker memory.
-  useEffect(() => {
-    let cancelled = false;
-    let loaded: PDFDocumentProxy | null = null;
-    // Same-path reload (a recompile): remember where the reader was so we can
-    // restore it once the fresh pages have laid out, instead of jumping to the
-    // top. A genuine file switch starts fresh. On the FIRST load, instead restore
-    // the position persisted from a prior session (#viewerpos) so an Eldrun
-    // restart reopens the PDF where the reader left it.
-    const el = scrollRef.current;
-    let firstRestore: { top: number; left: number } | null = null;
-    if (!didInitialLoad.current) {
-      didInitialLoad.current = true;
-      const init = viewPos.initial;
-      if (init && ((init.scrollTop ?? 0) > 0 || (init.scrollLeft ?? 0) > 0)) {
-        firstRestore = { top: init.scrollTop ?? 0, left: init.scrollLeft ?? 0 };
-      }
-    }
-    const samePathReload = loadedPath.current === path;
-    restoreScroll.current =
-      firstRestore ??
-      (samePathReload && el
-        ? { top: el.scrollTop, left: el.scrollLeft }
-        : null);
-    reloadKeepZoom.current = samePathReload;
-    loadedPath.current = path;
-    setDoc(null);
-    setError(null);
-    (async () => {
-      try {
-        const bytes = await invoke<number[]>("read_file_bytes", { path });
-        if (cancelled) return;
-        loaded = await pdfjs.getDocument({ data: new Uint8Array(bytes) }).promise;
-        if (cancelled) {
-          loaded.destroy();
-          loaded = null;
-          return;
-        }
-        setDoc(loaded);
-      } catch (e) {
-        if (!cancelled) setError(String(e));
-      }
-    })();
-    // Safety net: stop trying to restore after the pages have had time to lay
-    // out, so a target the reloaded PDF can't reach never re-applies later
-    // (e.g. fighting a subsequent zoom).
-    const restoreDeadline = restoreScroll.current
-      ? setTimeout(() => { restoreScroll.current = null; }, 2000)
-      : null;
-    return () => {
-      cancelled = true;
-      loaded?.destroy();
-      if (restoreDeadline) clearTimeout(restoreDeadline);
-    };
-  }, [path, diskVersion]);
-
-  // Intrinsic (scale-1) CSS dimensions of every page, computed once per document
-  // load. Lets each PdfPageCanvas reserve its true size before rendering so the
-  // page stack reaches its full scroll height immediately — without it the
-  // restored scroll position (#viewerpos) is unreachable until every page above
-  // it has finished rendering, which on a slow startup loses the position to the
-  // restore deadline. getPage()/getViewport() read only page metadata (no
-  // rasterisation), so this is cheap relative to actually rendering the pages.
-  const [pageSizes, setPageSizes] = useState<{ w: number; h: number }[] | null>(null);
-  useEffect(() => {
-    if (!doc) {
-      setPageSizes(null);
-      return;
-    }
-    let cancelled = false;
-    void (async () => {
-      try {
-        const sizes = await Promise.all(
-          Array.from({ length: doc.numPages }, async (_, i) => {
-            const page = await doc.getPage(i + 1);
-            const vp = page.getViewport({ scale: 1 });
-            return { w: vp.width, h: vp.height };
-          }),
-        );
-        if (!cancelled) setPageSizes(sizes);
-      } catch {
-        /* leave heights unreserved — restore falls back to the old behaviour */
-      }
-    })();
-    return () => { cancelled = true; };
-  }, [doc]);
-
-  // Fit the first page to the viewport width when a document loads.
-  const fitWidth = useCallback(async (d: PDFDocumentProxy) => {
-    const el = scrollRef.current;
-    if (!el) return;
-    const page = await d.getPage(1);
-    const vp = page.getViewport({ scale: 1 });
-    const avail = el.clientWidth - 24; // leave room for page margins
-    if (avail > 0 && vp.width > 0) setScale(clampPdfScale(avail / vp.width));
-  }, []);
+  }, [path, scope]);
 
-  // Fit to width when a document loads — UNLESS this is the first load and a zoom
-  // was persisted from a prior session, in which case honour the saved scale
-  // (already seeded into `scale`). A same-path reload (a recompile rewrote this
-  // PDF) keeps the reader's current zoom rather than snapping back to fit-width;
-  // only a genuine switch to a different file refits.
-  const didInitialFit = useRef(false);
-  useEffect(() => {
-    if (!doc) return;
-    if (!didInitialFit.current) {
-      didInitialFit.current = true;
-      if (viewPos.initial?.scale != null) return;
-    } else if (reloadKeepZoom.current) {
-      return;
-    }
-    void fitWidth(doc);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [doc, fitWidth]);
-
-  // #viewerpos: persist the zoom whenever it changes (only once a document is up,
-  // so the pre-load placeholder scale is never written). setViewerState dedups,
-  // so re-persisting an unchanged scale is a no-op.
-  useEffect(() => {
-    if (doc) viewPos.persist({ scale });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [scale, doc]);
-
-  // #viewerpos: persist the scroll position as the reader scrolls (throttled,
-  // trailing-edge). Ignored while a programmatic restore is still settling so we
-  // don't overwrite the saved target with an intermediate frame.
-  const scrollPersistTimer = useRef<number | null>(null);
-  const onScrollPersist = useCallback(() => {
-    const el = scrollRef.current;
-    if (!el || restoreScroll.current) return;
-    const top = el.scrollTop;
-    const left = el.scrollLeft;
-    if (scrollPersistTimer.current != null) window.clearTimeout(scrollPersistTimer.current);
-    scrollPersistTimer.current = window.setTimeout(
-      () => viewPos.persist({ scrollTop: top, scrollLeft: left }),
-      200,
-    );
-  }, [viewPos]);
-  useEffect(
-    () => () => {
-      if (scrollPersistTimer.current != null) window.clearTimeout(scrollPersistTimer.current);
-    },
-    [],
-  );
-
-  // Ctrl/Cmd+wheel zooms the page stack toward the cursor (a plain wheel keeps
-  // native scrolling). Because the canvases resize asynchronously, we only
-  // compute the cursor-anchored scroll target here and let the ResizeObserver
-  // below apply it once the content has grown/shrunk.
-  const onWheel = useCallback((e: React.WheelEvent<HTMLDivElement>) => {
-    if (!(e.ctrlKey || e.metaKey)) return;
-    e.preventDefault();
-    const el = scrollRef.current;
-    if (!el) return;
-    // A user zoom takes over; abandon any in-flight recompile scroll restore.
-    restoreScroll.current = null;
-    const rect = el.getBoundingClientRect();
-    const cursorX = e.clientX - rect.left;
-    const cursorY = e.clientY - rect.top;
-    setScale((prev) => {
-      const factor = e.deltaY < 0 ? PDF_ZOOM_STEP : 1 / PDF_ZOOM_STEP;
-      const next = clampPdfScale(prev * factor);
-      if (next === prev) return prev;
-      const eff = next / prev;
-      pendingScroll.current = {
-        top: (el.scrollTop + cursorY) * eff - cursorY,
-        left: (el.scrollLeft + cursorX) * eff - cursorX,
-      };
-      return next;
-    });
-  }, []);
-
-  // Apply a pending cursor-anchored scroll target once the page content has
-  // resized after a zoom (the observer fires when the canvases repaint).
-  useEffect(() => {
-    const content = contentRef.current;
-    const el = scrollRef.current;
-    if (!content || !el || typeof ResizeObserver === "undefined") return;
-    const ro = new ResizeObserver(() => {
-      // Cursor-anchored zoom target: apply once, the moment the canvases resize.
-      const target = pendingScroll.current;
-      if (target) {
-        pendingScroll.current = null;
-        el.scrollTop = target.top;
-        el.scrollLeft = target.left;
-      }
-      // Recompile reload: the page stack grows over several frames as canvases
-      // render, so keep re-applying the saved position until it's reached, then
-      // stop. A target the new (shorter) document can't hold is dropped by the
-      // bounded fallback timer in the load effect.
-      const restore = restoreScroll.current;
-      if (restore) {
-        el.scrollTop = restore.top;
-        el.scrollLeft = restore.left;
-        if (el.scrollTop >= restore.top - 1) restoreScroll.current = null;
-      }
-    });
-    ro.observe(content);
-    return () => ro.disconnect();
-  }, [doc]);
-
-  return (
-    <div className="file-viewer-pdf-host">
-      <div className="file-viewer-pdf-toolbar" role="group" aria-label="PDF zoom controls">
-        <button
-          className="file-viewer-zoom-btn"
-          onClick={() => setScale((s) => clampPdfScale(s / PDF_ZOOM_STEP))}
-          disabled={!doc || scale <= PDF_MIN_SCALE}
-          title="Zoom out"
-          aria-label="Zoom out"
-        >
-          −
-        </button>
-        <span className="file-viewer-zoom-level">{Math.round(scale * 100)}%</span>
-        <button
-          className="file-viewer-zoom-btn"
-          onClick={() => setScale((s) => clampPdfScale(s * PDF_ZOOM_STEP))}
-          disabled={!doc || scale >= PDF_MAX_SCALE}
-          title="Zoom in"
-          aria-label="Zoom in"
-        >
-          +
-        </button>
-        <button
-          className="file-viewer-zoom-btn file-viewer-zoom-text"
-          onClick={() => doc && void fitWidth(doc)}
-          disabled={!doc}
-          title="Fit page width"
-        >
-          Fit width
-        </button>
-        {onOpenExternally && (
-          <button
-            className="file-viewer-open-external file-viewer-pdf-external"
-            onClick={onOpenExternally}
-            title="Open in external app"
-            aria-label="Open in external app"
-          >
-            ↗
-          </button>
-        )}
-      </div>
-      <div
-        className="file-viewer-pdf-scroll"
-        ref={scrollRef}
-        onWheel={onWheel}
-        onScroll={onScrollPersist}
-      >
-        {error != null ? (
-          <div className="file-viewer-error">{error}</div>
-        ) : !doc ? (
-          <div className="file-viewer-loading">Loading…</div>
-        ) : (
-          <div className="file-viewer-pdf-pages" ref={contentRef}>
-            {Array.from({ length: doc.numPages }, (_, i) => (
-              <PdfPageCanvas
-                key={i}
-                doc={doc}
-                pageNumber={i + 1}
-                scale={scale}
-                cssSize={pageSizes?.[i]}
-                onSyncClick={syncable ? onSyncClick : undefined}
-                syncArmed={syncArmed}
-                highlight={highlight && highlight.rect.page === i + 1 ? highlight : null}
-              />
-            ))}
-          </div>
-        )}
-      </div>
-    </div>
-  );
+  return { url, error };
 }
 
-function PdfView({
-  path,
-  onOpenExternally,
-  tabKey,
-}: {
-  path: string;
-  onOpenExternally: () => void;
-  tabKey?: string;
-}) {
-  // No ViewerHeader: the tab already shows the file name, so a filename row would
-  // be redundant. The "Open externally" action lives in the PdfCanvas toolbar.
-  return (
-    <div className="file-viewer">
-      <div className="file-viewer-body">
-        <PdfCanvas path={path} onOpenExternally={onOpenExternally} tabKey={tabKey} />
-      </div>
-    </div>
-  );
-}
 
 /**
  * The in-tab LaTeX viewer. It always offers the same editable code editor as the
@@ -3209,6 +5734,18 @@ function PdfView({
  *   - The engine selector only appears when more than one engine is on PATH;
  *     otherwise the backend default is used (`engine: null`).
  */
+
+/** OS-appropriate command to install a LaTeX/TeX distribution, used by the
+ *  one-click "Install LaTeX" prompt shown when no TeX engine is on PATH. These
+ *  are best-effort defaults the user can edit in the spawned terminal: MiKTeX on
+ *  Windows, MacTeX on macOS (Homebrew), TeX Live on Linux (Debian/Ubuntu apt). */
+const TEX_INSTALL_CMD = IS_WINDOWS
+  ? "winget install --id MiKTeX.MiKTeX -e"
+  : IS_MAC
+    ? "brew install --cask mactex-no-gui"
+    : "sudo apt-get install -y texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended latexmk";
+const TEX_INSTALL_LABEL = IS_WINDOWS ? "Install MiKTeX" : "Install LaTeX";
+
 function TexView({
   path,
   onOpenExternally,
@@ -3223,14 +5760,28 @@ function TexView({
     error, draft, setDraft, loaded, isDirty, saving, saveError, save,
     undo, redo, canUndo, canRedo, externalChange, reloadFromDisk, keepMine,
   } = useEditableFile(path);
-  const ac = useAutocompleteConfig("tex");
-  const font = useEditorFontSize("tex");
+  const scope = useFileScope();
+  const ai = useTabAiPrefs(tabKey, "tex");
+  const ac = ai.ac;
+  const gc = ai.gc;
+  const [compareOpen, setCompareOpen] = useState(false);
+  const font = useEditorFontSize(tabKey, "tex");
   const viewPos = useViewerState(tabKey);
   const persistScroll = useCallback(
     (scrollTop: number) => viewPos.persist({ scrollTop }),
     [viewPos],
   );
 
+  // Print the .tex source as a wrapped monospace block. (The compiled PDF, once
+  // built, opens in the PDF viewer and prints from there.)
+  const handlePrint = useCallback(() => {
+    void printHtmlBody(
+      `<pre class="print-pre">${escapeHtml(draft)}</pre>`,
+      TEXT_PRINT_CSS,
+      basename(path),
+    );
+  }, [draft, path]);
+
   // null while still probing; the editor renders regardless so there is no flash.
   const [cap, setCap] = useState<TexCapability | null>(null);
   useEffect(() => {
@@ -3247,9 +5798,12 @@ function TexView({
     async (caret: number): Promise<boolean> => {
       const target = findTexRefAt(draft, caret);
       if (!target) return false;
-      const resolved = await resolveTexRefAsync(path, target);
+      const disabled = disabledViewers(
+        useSettingsStore.getState().settings?.viewer_prefs,
+      );
+      const resolved = await resolveTexRefAsync(path, target, disabled);
       if (!resolved) return false;
-      const dir = path.slice(0, path.lastIndexOf("/")) || "/";
+      const dir = dirname(path) || "/";
       openLinkedFile(tabKey, dir, resolved);
       return true;
     },
@@ -3290,11 +5844,11 @@ function TexView({
   const [gathered, setGathered] = useState<TexCompletions>({ labels: [], cites: [] });
   useEffect(() => {
     let cancelled = false;
-    gatherTexCompletions(path)
+    gatherTexCompletions(path, scope)
       .then((c) => { if (!cancelled) setGathered(c); })
       .catch(() => {});
     return () => { cancelled = true; };
-  }, [path, pdfVersion]);
+  }, [path, scope, pdfVersion]);
   const completions = useMemo<TexCompletions>(
     () => ({
       labels: Array.from(new Set([...parseTexLabels(draft), ...gathered.labels])),
@@ -3332,9 +5886,9 @@ function TexView({
     return () => { cancelled = true; };
   }, [path]);
   const isChild = root !== path;
-  const rootName = root.slice(root.lastIndexOf("/") + 1);
+  const rootName = basename(root);
   // Directory the build runs in — error paths in the log are relative to it.
-  const rootDir = root.slice(0, root.lastIndexOf("/")) || "/";
+  const rootDir = dirname(root) || "/";
 
   // Open the compiled PDF as its own tab (it is a real file), reusing the embed
   // viewer. openLinkedFile dedupes against an already-open PDF tab for the same
@@ -3342,8 +5896,8 @@ function TexView({
   // so a reused tab reloads the freshly compiled bytes on its own.
   const openPdf = useCallback(
     (pdf: string) => {
-      const name = pdf.slice(pdf.lastIndexOf("/") + 1);
-      const dir = path.slice(0, path.lastIndexOf("/")) || "/";
+      const name = basename(pdf);
+      const dir = dirname(path) || "/";
       openLinkedFile(tabKey, dir, { path: pdf, viewer: "pdf", label: name });
     },
     [path, tabKey],
@@ -3467,38 +6021,80 @@ function TexView({
       <div className="file-viewer">
         <ViewerHeader onOpenExternally={onOpenExternally}>
           <FontSizeControls fontSize={font.fontSize} inc={font.inc} dec={font.dec} reset={font.reset} />
+          <EditorAiControls ai={ai} />
+          <CompareButton active={compareOpen} toggle={() => setCompareOpen((v) => !v)} />
           <UndoRedoButtons undo={undo} redo={redo} canUndo={canUndo} canRedo={canRedo} />
+          <PrintButton onPrint={handlePrint} disabled={!loaded} />
           <SaveButton isDirty={isDirty} saving={saving} save={() => void save()} />
         </ViewerHeader>
         {externalChange && <ExternalChangeBanner onReload={reloadFromDisk} onKeep={keepMine} />}
         {saveError && <div className="file-viewer-error">{saveError}</div>}
+        {cap && !cap.available && (
+          <div className="tex-install-banner" role="note">
+            <span className="tex-install-banner-text">
+              No LaTeX engine found — install one to compile this document to a PDF.
+            </span>
+            <code className="ollama-install-cmd">{TEX_INSTALL_CMD}</code>
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              title="Run this command in a new terminal tab"
+              onClick={() =>
+                runInstallInTab(TEX_INSTALL_LABEL, TEX_INSTALL_CMD, IS_WINDOWS ? "default" : "bash")
+              }
+            >
+              Run in terminal
+            </button>
+            <button
+              type="button"
+              className="ollama-action-btn"
+              title="Re-check after installing"
+              onClick={() => void refreshTexCapability().then(setCap)}
+            >
+              Recheck
+            </button>
+          </div>
+        )}
         <div className="file-viewer-body file-viewer-code-body">
-          <CodeEditor
-            path={path}
-            error={error}
-            draft={draft}
-            setDraft={setDraft}
-            loaded={loaded}
-            save={() => void save()}
-            onFollowLink={onEditorFollow}
-            linkRanges={linkRanges}
-            undo={undo}
-            redo={redo}
-            autocomplete={ac}
-            texCompletions={completions}
-            fontSize={font.fontSize}
-            lineHeight={font.lineHeight}
-            incFont={font.inc}
-            decFont={font.dec}
-            resetFont={font.reset}
-            gotoLine={jump.gotoLine}
-            onGotoApplied={jump.onGotoApplied}
-            onCaretChange={onCaret}
-            caretApiRef={caretApiRef}
-            initialScrollTop={viewPos.initial?.scrollTop}
-            onScrollPersist={persistScroll}
-            wrap
-          />
+          {compareOpen ? (
+            <CompareView
+              path={path}
+              rightText={draft}
+              onApply={(merged) => {
+                setDraft(merged);
+                setCompareOpen(false);
+              }}
+              onClose={() => setCompareOpen(false)}
+            />
+          ) : (
+            <CodeEditor
+              path={path}
+              error={error}
+              draft={draft}
+              setDraft={setDraft}
+              loaded={loaded}
+              save={() => void save()}
+              onFollowLink={onEditorFollow}
+              linkRanges={linkRanges}
+              undo={undo}
+              redo={redo}
+              autocomplete={ac}
+              grammarCheck={gc}
+              texCompletions={completions}
+              fontSize={font.fontSize}
+              lineHeight={font.lineHeight}
+              incFont={font.inc}
+              decFont={font.dec}
+              resetFont={font.reset}
+              gotoLine={jump.gotoLine}
+              onGotoApplied={jump.onGotoApplied}
+              onCaretChange={onCaret}
+              caretApiRef={caretApiRef}
+              initialScrollTop={viewPos.initial?.scrollTop}
+              onScrollPersist={persistScroll}
+              wrap
+            />
+          )}
         </div>
       </div>
     );
@@ -3559,7 +6155,10 @@ function TexView({
           </button>
         )}
         <FontSizeControls fontSize={font.fontSize} inc={font.inc} dec={font.dec} reset={font.reset} />
+        <EditorAiControls ai={ai} />
+        <CompareButton active={compareOpen} toggle={() => setCompareOpen((v) => !v)} />
         <UndoRedoButtons undo={undo} redo={redo} canUndo={canUndo} canRedo={canRedo} />
+        <PrintButton onPrint={handlePrint} disabled={!loaded} />
         <SaveButton isDirty={isDirty} saving={saving} save={() => void save()} />
       </ViewerHeader>
       {compiling && (
@@ -3648,44 +6247,59 @@ function TexView({
         </div>
       )}
       <div className="file-viewer-body file-viewer-code-body">
-        <CodeEditor
-          path={path}
-          error={error}
-          draft={draft}
-          setDraft={setDraft}
-          loaded={loaded}
-          // Ctrl+S in the LaTeX viewer saves and recompiles (compile() persists
-          // pending edits first), so the PDF preview tracks the source.
-          save={() => void compile()}
-          onFollowLink={onEditorFollow}
-          linkRanges={linkRanges}
-          undo={undo}
-          redo={redo}
-          autocomplete={ac}
-          texCompletions={completions}
-          fontSize={font.fontSize}
-          lineHeight={font.lineHeight}
-          incFont={font.inc}
-          decFont={font.dec}
-          resetFont={font.reset}
-          gotoLine={jump.gotoLine}
-          onGotoApplied={jump.onGotoApplied}
-          onCaretChange={onCaret}
-          caretApiRef={caretApiRef}
-          initialScrollTop={viewPos.initial?.scrollTop}
-          onScrollPersist={persistScroll}
-          wrap
-        />
+        {compareOpen ? (
+          <CompareView
+            path={path}
+            rightText={draft}
+            onApply={(merged) => {
+              setDraft(merged);
+              setCompareOpen(false);
+            }}
+            onClose={() => setCompareOpen(false)}
+          />
+        ) : (
+          <CodeEditor
+            path={path}
+            error={error}
+            draft={draft}
+            setDraft={setDraft}
+            loaded={loaded}
+            // Ctrl+S in the LaTeX viewer saves and recompiles (compile() persists
+            // pending edits first), so the PDF preview tracks the source.
+            save={() => void compile()}
+            onFollowLink={onEditorFollow}
+            linkRanges={linkRanges}
+            undo={undo}
+            redo={redo}
+            autocomplete={ac}
+            grammarCheck={gc}
+            texCompletions={completions}
+            fontSize={font.fontSize}
+            lineHeight={font.lineHeight}
+            incFont={font.inc}
+            decFont={font.dec}
+            resetFont={font.reset}
+            gotoLine={jump.gotoLine}
+            onGotoApplied={jump.onGotoApplied}
+            onCaretChange={onCaret}
+            caretApiRef={caretApiRef}
+            initialScrollTop={viewPos.initial?.scrollTop}
+            onScrollPersist={persistScroll}
+            wrap
+          />
+        )}
       </div>
     </div>
   );
 }
 
-const MIN_SCALE = 0.05;
-const MAX_SCALE = 40;
-const ZOOM_STEP = 1.2;
+// Exported so GifView shares the exact zoom behavior (steps, bounds) with the
+// image viewer.
+export const MIN_SCALE = 0.05;
+export const MAX_SCALE = 40;
+export const ZOOM_STEP = 1.2;
 
-const clampScale = (s: number) => Math.min(MAX_SCALE, Math.max(MIN_SCALE, s));
+export const clampScale = (s: number) => Math.min(MAX_SCALE, Math.max(MIN_SCALE, s));
 
 /**
  * Zoomable/pannable image viewer. The image is drawn at its natural pixel size
@@ -3713,6 +6327,20 @@ function ImageView({
 }) {
   const viewPos = useViewerState(tabKey);
   const { url, error } = useBlobUrl(path, "");
+  // Print the image, fit to the page. The blob URL resolves in the print iframe
+  // because a srcdoc iframe shares this document's origin.
+  const handlePrint = useCallback(() => {
+    if (!url) return;
+    void printHtmlBody(
+      `<div class="print-page"><img src="${url}" alt="${escapeHtml(fileName)}"></div>`,
+      IMAGE_PRINT_CSS,
+      fileName,
+    );
+  }, [url, fileName]);
+  // #annotate (Dev F): when true, an editing overlay covers the viewer letting the
+  // user draw on the image and save the result. Gated to raster images we can
+  // re-encode to PNG.
+  const [annotating, setAnnotating] = useState(false);
   const viewportRef = useRef<HTMLDivElement | null>(null);
   // Natural (intrinsic) image size in pixels, set on load. The ref mirrors it so
   // an on-disk reload (#68) can tell a same-size content update from a new image.
@@ -3819,14 +6447,26 @@ function ImageView({
     return () => ro.disconnect();
   }, [fit]);
 
-  const onWheel = (e: React.WheelEvent<HTMLDivElement>) => {
+  // Wheel zooms toward the cursor. Bound non-passively (see useNonPassiveWheel)
+  // so `preventDefault()` cancels the native scroll instead of the viewport
+  // scrolling to its limit before the zoom takes.
+  const wheelRef = useNonPassiveWheel((e) => {
     if (!natural) return;
     e.preventDefault();
     const rect = viewportRef.current?.getBoundingClientRect();
     const anchor = rect ? { x: e.clientX - rect.left, y: e.clientY - rect.top } : undefined;
     const factor = e.deltaY < 0 ? ZOOM_STEP : 1 / ZOOM_STEP;
     zoomTo(scale * factor, anchor);
-  };
+  });
+  // Feed the same node to both the object ref (used for measuring/panning) and
+  // the non-passive wheel binding.
+  const setViewport = useCallback(
+    (el: HTMLDivElement | null) => {
+      viewportRef.current = el;
+      wheelRef(el);
+    },
+    [wheelRef],
+  );
 
   // Pointer-drag panning.
   const dragRef = useRef<{ id: number; startX: number; startY: number; ox: number; oy: number } | null>(null);
@@ -3904,18 +6544,34 @@ function ImageView({
           >
             1:1
           </button>
+          <button
+            className="file-viewer-zoom-btn file-viewer-zoom-text"
+            onClick={() => setAnnotating(true)}
+            disabled={!url}
+            title="Annotate / mark up this image"
+          >
+            ✎ Annotate
+          </button>
         </div>
+        <PrintButton onPrint={handlePrint} disabled={!url} />
       </ViewerHeader>
       <div className="file-viewer-body file-viewer-image-body">
+        {annotating && url != null && (
+          <ImageAnnotator
+            src={url}
+            path={path}
+            fileName={fileName}
+            onClose={() => setAnnotating(false)}
+          />
+        )}
         {error != null ? (
           <div className="file-viewer-error">{error}</div>
         ) : url == null ? (
           <div className="file-viewer-loading">Loading…</div>
         ) : (
           <div
-            ref={viewportRef}
+            ref={setViewport}
             className={`file-viewer-image-viewport${dragging ? " dragging" : ""}`}
-            onWheel={onWheel}
             onPointerDown={onPointerDown}
             onPointerMove={onPointerMove}
             onPointerUp={endDrag}
diff --git a/src/components/embed/GifView.tsx b/src/components/embed/GifView.tsx
new file mode 100644
index 0000000..fe598f1
--- /dev/null
+++ b/src/components/embed/GifView.tsx
@@ -0,0 +1,619 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  ViewerHeader,
+  useViewerState,
+  useNonPassiveWheel,
+  zoomOffset,
+  clampScale,
+  MIN_SCALE,
+  MAX_SCALE,
+  ZOOM_STEP,
+} from "./FileViewerPane";
+import { useFileScope, readFileBytes, fileMtime } from "./fileAccess";
+import { openGif, effectiveDelayMs } from "../../lib/viewers/gif";
+import { Dropdown } from "../common/Dropdown";
+
+/**
+ * Animated-GIF viewer with frame-level transport (#gifviewer). The plain image
+ * viewer already *animates* a GIF — the webview animates <img> natively — but
+ * offers no control over the animation. This viewer decodes the frames itself
+ * (`lib/viewers/gif.ts`; WebKitGTK has no ImageDecoder API) and plays them on a
+ * <canvas>, which is what makes pause, frame stepping, scrubbing, speed and
+ * loop control possible at all.
+ *
+ * Playback honors each frame's own delay through a timestamp accumulator (a
+ * fixed-interval timer would drift and ignore per-frame timing); authored
+ * sub-20ms delays play at the 100ms browser convention (`effectiveDelayMs`).
+ * Zoom/pan mirrors the image viewer exactly, sharing its exported pure pieces
+ * (`zoomOffset`/`clampScale`/`useNonPassiveWheel`) and persisting the view per
+ * tab the same way.
+ *
+ * Decoding runs on the main thread but yields to the event loop every few
+ * frames — no Web Worker: typical GIFs decode in single-digit ms, and shipping
+ * hundreds of MB of frame buffers through structured clone would cost more
+ * than it saves. A GIF the decoder can't handle degrades to the plain <img>
+ * (which still animates natively) rather than a wall — a decoder gap must
+ * never render worse than before this viewer existed.
+ *
+ * No Annotate button: the annotator flattens to a single PNG, which would
+ * silently destroy the animation on save. (A possible future affordance is
+ * "annotate the CURRENT frame → PNG copy".)
+ */
+
+/** Mirrors FileViewerPane's RELOAD_POLL_MS (#68 auto-reload). */
+const RELOAD_POLL_MS = 1500;
+
+/** Bound the accumulator so a long-hidden tab (rAF suspended) fast-forwards at
+ *  most this much wall-clock time instead of spinning the advance loop. */
+const MAX_CARRY_MS = 60_000;
+
+const SPEED_OPTIONS = [0.25, 0.5, 1, 1.5, 2, 4].map((s) => ({
+  value: String(s),
+  label: `${s}×`,
+}));
+
+/**
+ * Load `path`'s raw bytes (the decoder wants bytes, not a blob URL) and re-read
+ * them when the file changes on disk — the byte-level twin of FileViewerPane's
+ * `useBlobUrl`. A same-path reload keeps the current bytes up until the fresh
+ * ones arrive, so the animation doesn't flash to a loading state.
+ */
+function useGifBytes(path: string) {
+  const scope = useFileScope();
+  const [bytes, setBytes] = useState<Uint8Array<ArrayBuffer> | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const lastMtime = useRef<number | null>(null);
+  // Bumped whenever the file's mtime advances on disk, forcing a byte reload.
+  const [diskVersion, setDiskVersion] = useState(0);
+
+  // Reset to the loading state only on a genuine file switch.
+  useEffect(() => {
+    setBytes(null);
+    setError(null);
+    lastMtime.current = null;
+  }, [path]);
+
+  useEffect(() => {
+    let cancelled = false;
+    readFileBytes(path, scope)
+      .then((b) => {
+        if (!cancelled) setBytes(Uint8Array.from(b));
+      })
+      .catch((e) => {
+        if (!cancelled) setError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path, scope, diskVersion]);
+
+  // Poll mtime; on an external advance, bump diskVersion to re-read fresh bytes.
+  useEffect(() => {
+    let cancelled = false;
+    fileMtime(path, scope)
+      .then((m) => {
+        if (!cancelled) lastMtime.current = m;
+      })
+      .catch(() => {});
+    const id = setInterval(() => {
+      fileMtime(path, scope)
+        .then((m) => {
+          if (cancelled || lastMtime.current == null || m <= lastMtime.current) return;
+          lastMtime.current = m;
+          setDiskVersion((v) => v + 1);
+        })
+        .catch(() => {});
+    }, RELOAD_POLL_MS);
+    return () => {
+      cancelled = true;
+      clearInterval(id);
+    };
+  }, [path, scope]);
+
+  return { bytes, error };
+}
+
+/** Decoded frames with their ImageData built once (zero-copy wrap of the
+ *  decoder's RGBA buffers), so drawing a frame is a single putImageData. */
+interface DecodedGif {
+  width: number;
+  height: number;
+  frames: { image: ImageData; delayMs: number }[];
+  truncated: boolean;
+}
+
+export function GifView({
+  path,
+  fileName,
+  onOpenExternally,
+  tabKey,
+}: {
+  path: string;
+  fileName: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  const viewPos = useViewerState(tabKey);
+  const { bytes, error } = useGifBytes(path);
+
+  // ── Decode ──────────────────────────────────────────────────────────────────
+  const [decoded, setDecoded] = useState<DecodedGif | null>(null);
+  const [decodeError, setDecodeError] = useState<string | null>(null);
+
+  // A genuine file switch drops the previous animation; a same-path disk reload
+  // (bytes swap) keeps it up until the fresh decode lands.
+  useEffect(() => {
+    setDecoded(null);
+    setDecodeError(null);
+  }, [path]);
+
+  useEffect(() => {
+    if (!bytes) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const stream = openGif(bytes);
+        const frames: DecodedGif["frames"] = [];
+        for (let f = stream.nextFrame(); f !== null; f = stream.nextFrame()) {
+          frames.push({
+            image: new ImageData(f.pixels, stream.width, stream.height),
+            delayMs: f.delayMs,
+          });
+          // Yield to the event loop every few frames so a huge GIF can't jank
+          // the whole window while it decodes.
+          if (frames.length % 10 === 0) {
+            await new Promise((r) => setTimeout(r));
+            if (cancelled) return;
+          }
+        }
+        if (frames.length === 0) throw new Error("GIF contains no image frames");
+        if (!cancelled) {
+          setDecoded({
+            width: stream.width,
+            height: stream.height,
+            frames,
+            truncated: stream.truncated,
+          });
+          setDecodeError(null);
+        }
+      } catch (e) {
+        if (!cancelled) setDecodeError(String(e));
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [bytes]);
+
+  const frameCount = decoded?.frames.length ?? 0;
+
+  // ── Transport state ─────────────────────────────────────────────────────────
+  // Autoplay by default: that's exactly what the old <img> rendering did.
+  const [playing, setPlaying] = useState(true);
+  const [frameIndex, setFrameIndex] = useState(0);
+  const [speed, setSpeed] = useState(1);
+  const [loop, setLoop] = useState(true);
+  // Mirrors frameIndex for the playback loop, which advances between renders.
+  const frameIndexRef = useRef(0);
+  frameIndexRef.current = frameIndex;
+
+  // Reset the transport on a file switch (not on a same-path reload — but if a
+  // reload shrank the file, clamp so the index stays addressable).
+  useEffect(() => {
+    setPlaying(true);
+    setFrameIndex(0);
+    frameIndexRef.current = 0;
+  }, [path]);
+  useEffect(() => {
+    if (decoded && frameIndexRef.current >= decoded.frames.length) {
+      setFrameIndex(decoded.frames.length - 1);
+    }
+  }, [decoded]);
+
+  // The playback loop: a rAF-driven timestamp accumulator. Each tick banks the
+  // elapsed wall-clock time (× speed) and advances as many frames as it pays
+  // for — possibly several per tick at high speed — so playback never drifts
+  // and per-frame delays are honored exactly.
+  useEffect(() => {
+    if (!playing || !decoded || decoded.frames.length < 2) return;
+    let raf = 0;
+    let lastTs: number | null = null;
+    let carry = 0;
+    const tick = (ts: number) => {
+      if (lastTs != null) {
+        carry = Math.min(carry + (ts - lastTs) * speed, MAX_CARRY_MS);
+        let i = frameIndexRef.current;
+        let advanced = false;
+        let ended = false;
+        let delay = effectiveDelayMs(decoded.frames[i].delayMs);
+        while (carry >= delay) {
+          carry -= delay;
+          if (i === decoded.frames.length - 1) {
+            if (!loop) {
+              ended = true;
+              break;
+            }
+            i = 0;
+          } else {
+            i++;
+          }
+          advanced = true;
+          delay = effectiveDelayMs(decoded.frames[i].delayMs);
+        }
+        if (advanced) {
+          frameIndexRef.current = i;
+          setFrameIndex(i);
+        }
+        if (ended) {
+          setPlaying(false);
+          return; // effect teardown cancels; don't schedule another tick
+        }
+      }
+      lastTs = ts;
+      raf = requestAnimationFrame(tick);
+    };
+    raf = requestAnimationFrame(tick);
+    return () => cancelAnimationFrame(raf);
+  }, [playing, decoded, speed, loop]);
+
+  // ── Canvas ──────────────────────────────────────────────────────────────────
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  useEffect(() => {
+    if (!decoded) return;
+    const ctx = canvasRef.current?.getContext("2d");
+    if (!ctx) return;
+    const frame = decoded.frames[Math.min(frameIndex, decoded.frames.length - 1)];
+    ctx.putImageData(frame.image, 0, 0);
+  }, [decoded, frameIndex]);
+
+  // ── Zoom / pan (mirrors ImageView) ──────────────────────────────────────────
+  const viewportRef = useRef<HTMLDivElement | null>(null);
+  const [scale, setScale] = useState(1);
+  const [offset, setOffset] = useState({ x: 0, y: 0 });
+  const fittedRef = useRef(true);
+  const dimsRef = useRef<{ w: number; h: number } | null>(null);
+
+  const viewportSize = () => {
+    const el = viewportRef.current;
+    return el ? { w: el.clientWidth, h: el.clientHeight } : { w: 0, h: 0 };
+  };
+
+  // Fit scale — never upscales past 1:1, so small GIFs stay crisp.
+  const fitScaleFor = useCallback((nat: { w: number; h: number }, vp: { w: number; h: number }) => {
+    if (nat.w === 0 || nat.h === 0 || vp.w === 0 || vp.h === 0) return 1;
+    return Math.min(vp.w / nat.w, vp.h / nat.h, 1);
+  }, []);
+
+  const fit = useCallback(() => {
+    const nat = dimsRef.current;
+    if (!nat) return;
+    const vp = viewportSize();
+    const s = fitScaleFor(nat, vp);
+    setScale(s);
+    setOffset({ x: (vp.w - nat.w * s) / 2, y: (vp.h - nat.h * s) / 2 });
+    fittedRef.current = true;
+  }, [fitScaleFor]);
+
+  const zoomTo = useCallback((target: number, anchor?: { x: number; y: number }) => {
+    const vp = viewportSize();
+    const a = anchor ?? { x: vp.w / 2, y: vp.h / 2 };
+    setScale((prev) => {
+      const next = clampScale(target);
+      setOffset((o) => zoomOffset(prev, next, o, a));
+      return next;
+    });
+    fittedRef.current = false;
+  }, []);
+
+  // First decode: restore the session-persisted zoom/pan (#viewerpos) or fit.
+  // A re-decode with different dimensions (file replaced on disk) re-fits; a
+  // same-size content update keeps the user's view.
+  useEffect(() => {
+    if (!decoded) return;
+    const nat = { w: decoded.width, h: decoded.height };
+    const prev = dimsRef.current;
+    dimsRef.current = nat;
+    if (!prev) {
+      const init = viewPos.initial;
+      if (init?.scale != null) {
+        setScale(init.scale);
+        setOffset({ x: init.offsetX ?? 0, y: init.offsetY ?? 0 });
+        fittedRef.current = false;
+        return;
+      }
+      fit();
+      return;
+    }
+    if (prev.w !== nat.w || prev.h !== nat.h) fit();
+  }, [decoded, fit, viewPos]);
+  useEffect(() => {
+    dimsRef.current = null; // a file switch re-fits from scratch
+  }, [path]);
+
+  // #viewerpos: persist zoom + pan (throttled, trailing-edge).
+  const persistTimer = useRef<number | null>(null);
+  useEffect(() => {
+    if (!decoded) return;
+    const s = scale;
+    const ox = offset.x;
+    const oy = offset.y;
+    if (persistTimer.current != null) window.clearTimeout(persistTimer.current);
+    persistTimer.current = window.setTimeout(
+      () => viewPos.persist({ scale: s, offsetX: ox, offsetY: oy }),
+      200,
+    );
+    return () => {
+      if (persistTimer.current != null) window.clearTimeout(persistTimer.current);
+    };
+  }, [scale, offset, decoded, viewPos]);
+
+  // Re-fit on viewport resize while still in the fitted baseline state.
+  useEffect(() => {
+    const el = viewportRef.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => {
+      if (fittedRef.current) fit();
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [fit, decoded]);
+
+  const wheelRef = useNonPassiveWheel((e) => {
+    if (!decoded) return;
+    e.preventDefault();
+    const rect = viewportRef.current?.getBoundingClientRect();
+    const anchor = rect ? { x: e.clientX - rect.left, y: e.clientY - rect.top } : undefined;
+    const factor = e.deltaY < 0 ? ZOOM_STEP : 1 / ZOOM_STEP;
+    zoomTo(scale * factor, anchor);
+  });
+  const setViewport = useCallback(
+    (el: HTMLDivElement | null) => {
+      viewportRef.current = el;
+      wheelRef(el);
+    },
+    [wheelRef],
+  );
+
+  // Pointer-drag panning.
+  const dragRef = useRef<{ id: number; startX: number; startY: number; ox: number; oy: number } | null>(null);
+  const [dragging, setDragging] = useState(false);
+  const onPointerDown = (e: React.PointerEvent<HTMLDivElement>) => {
+    if (!decoded || e.button !== 0) return;
+    e.currentTarget.setPointerCapture(e.pointerId);
+    dragRef.current = { id: e.pointerId, startX: e.clientX, startY: e.clientY, ox: offset.x, oy: offset.y };
+    setDragging(true);
+  };
+  const onPointerMove = (e: React.PointerEvent<HTMLDivElement>) => {
+    const d = dragRef.current;
+    if (!d || d.id !== e.pointerId) return;
+    setOffset({ x: d.ox + (e.clientX - d.startX), y: d.oy + (e.clientY - d.startY) });
+    fittedRef.current = false;
+  };
+  const endDrag = (e: React.PointerEvent<HTMLDivElement>) => {
+    const d = dragRef.current;
+    if (!d || d.id !== e.pointerId) return;
+    dragRef.current = null;
+    setDragging(false);
+  };
+  const onDoubleClick = (e: React.MouseEvent<HTMLDivElement>) => {
+    const nat = dimsRef.current;
+    if (!nat) return;
+    const atFit = Math.abs(scale - fitScaleFor(nat, viewportSize())) < 0.001;
+    if (atFit) {
+      const rect = viewportRef.current?.getBoundingClientRect();
+      const anchor = rect ? { x: e.clientX - rect.left, y: e.clientY - rect.top } : undefined;
+      zoomTo(1, anchor);
+    } else {
+      fit();
+    }
+  };
+
+  // ── Transport handlers ──────────────────────────────────────────────────────
+  // Stepping/scrubbing pauses: you asked for a specific frame, hold it.
+  const stepTo = (i: number) => {
+    setPlaying(false);
+    setFrameIndex(i);
+  };
+  const prevFrame = () => stepTo(frameIndex === 0 ? frameCount - 1 : frameIndex - 1);
+  const nextFrame = () => stepTo((frameIndex + 1) % frameCount);
+  // The scrubber pauses while dragging and resumes only if it was playing.
+  const scrubWasPlaying = useRef(false);
+  const onScrubDown = () => {
+    scrubWasPlaying.current = playing;
+    setPlaying(false);
+  };
+  const onScrubUp = () => {
+    if (scrubWasPlaying.current) setPlaying(true);
+    scrubWasPlaying.current = false;
+  };
+
+  // Decode failure → degrade to the webview's native <img> animation.
+  const fallbackUrl = useMemo(() => {
+    if (decodeError == null || bytes == null) return null;
+    return URL.createObjectURL(new Blob([bytes]));
+  }, [decodeError, bytes]);
+  useEffect(
+    () => () => {
+      if (fallbackUrl) URL.revokeObjectURL(fallbackUrl);
+    },
+    [fallbackUrl],
+  );
+
+  const percent = Math.round(scale * 100);
+  const currentDelay = decoded ? decoded.frames[Math.min(frameIndex, frameCount - 1)].delayMs : 0;
+  const shownDelay = effectiveDelayMs(currentDelay);
+
+  return (
+    <div className="file-viewer">
+      <ViewerHeader onOpenExternally={onOpenExternally}>
+        {decoded != null && (
+          <div className="file-viewer-zoom gif-transport" role="group" aria-label="Playback controls">
+            <button
+              className="file-viewer-zoom-btn"
+              onClick={prevFrame}
+              disabled={frameCount < 2}
+              title="Previous frame"
+              aria-label="Previous frame"
+            >
+              ⏮
+            </button>
+            <button
+              className="file-viewer-zoom-btn"
+              onClick={() => setPlaying((p) => !p)}
+              disabled={frameCount < 2}
+              title={playing ? "Pause" : "Play"}
+              aria-label={playing ? "Pause" : "Play"}
+            >
+              {playing ? "⏸" : "▶"}
+            </button>
+            <button
+              className="file-viewer-zoom-btn"
+              onClick={nextFrame}
+              disabled={frameCount < 2}
+              title="Next frame"
+              aria-label="Next frame"
+            >
+              ⏭
+            </button>
+            <input
+              type="range"
+              className="gif-scrubber"
+              min={0}
+              max={Math.max(frameCount - 1, 0)}
+              value={Math.min(frameIndex, frameCount - 1)}
+              disabled={frameCount < 2}
+              onPointerDown={onScrubDown}
+              onPointerUp={onScrubUp}
+              onChange={(e) => setFrameIndex(Number(e.target.value))}
+              title="Scrub frames"
+              aria-label="Frame scrubber"
+            />
+            <Dropdown
+              className="gif-speed"
+              value={String(speed)}
+              options={SPEED_OPTIONS}
+              onChange={(v) => setSpeed(Number(v))}
+              title="Playback speed"
+            />
+            <button
+              className="file-viewer-zoom-btn"
+              onClick={() => setLoop((l) => !l)}
+              title={loop ? "Looping — click to play once" : "Play once — click to loop"}
+              aria-label="Loop"
+              aria-pressed={loop}
+              style={loop ? undefined : { opacity: 0.45 }}
+            >
+              🔁
+            </button>
+            <span
+              className="file-viewer-zoom-level"
+              // The readout shows the delay the frame PLAYS at; when the authored
+              // value was bumped by the 100ms convention, the tooltip says so.
+              title={
+                shownDelay !== currentDelay
+                  ? `Authored ${currentDelay} ms; played at the ${shownDelay} ms browser convention`
+                  : "Frame / total · frame delay"
+              }
+            >
+              {Math.min(frameIndex + 1, frameCount)} / {frameCount} · {shownDelay} ms
+            </span>
+          </div>
+        )}
+        <div className="file-viewer-zoom" role="group" aria-label="Zoom controls">
+          <button
+            className="file-viewer-zoom-btn"
+            onClick={() => zoomTo(scale / ZOOM_STEP)}
+            disabled={!decoded || scale <= MIN_SCALE}
+            title="Zoom out"
+            aria-label="Zoom out"
+          >
+            −
+          </button>
+          <span className="file-viewer-zoom-level" title="Current zoom">{percent}%</span>
+          <button
+            className="file-viewer-zoom-btn"
+            onClick={() => zoomTo(scale * ZOOM_STEP)}
+            disabled={!decoded || scale >= MAX_SCALE}
+            title="Zoom in"
+            aria-label="Zoom in"
+          >
+            +
+          </button>
+          <button
+            className="file-viewer-zoom-btn file-viewer-zoom-text"
+            onClick={() => fit()}
+            disabled={!decoded}
+            title="Fit to window"
+          >
+            Fit
+          </button>
+          <button
+            className="file-viewer-zoom-btn file-viewer-zoom-text"
+            onClick={() => zoomTo(1)}
+            disabled={!decoded}
+            title="Actual size (100%)"
+          >
+            1:1
+          </button>
+        </div>
+      </ViewerHeader>
+      <div className="file-viewer-body file-viewer-image-body">
+        {error != null ? (
+          <div className="file-viewer-error">{error}</div>
+        ) : decodeError != null ? (
+          // Degrade, don't wall: the webview still animates the <img> natively,
+          // so a decoder gap only loses the transport, never the picture.
+          <div className="gif-fallback" style={{ display: "flex", flexDirection: "column", width: "100%", height: "100%" }}>
+            <div className="file-viewer-loading" style={{ padding: "4px 8px" }}>
+              Couldn't decode this GIF for frame control — showing native playback.
+              Try opening it externally if it looks wrong.
+            </div>
+            {fallbackUrl != null && (
+              <div style={{ flex: 1, minHeight: 0, display: "flex", alignItems: "center", justifyContent: "center", overflow: "hidden" }}>
+                <img
+                  src={fallbackUrl}
+                  alt={fileName}
+                  style={{ maxWidth: "100%", maxHeight: "100%", objectFit: "contain" }}
+                />
+              </div>
+            )}
+          </div>
+        ) : decoded == null ? (
+          <div className="file-viewer-loading">{bytes == null ? "Loading…" : "Decoding…"}</div>
+        ) : (
+          <div style={{ display: "flex", flexDirection: "column", width: "100%", height: "100%" }}>
+            {decoded.truncated && (
+              <div className="file-viewer-loading" style={{ padding: "4px 8px" }}>
+                Showing the first {frameCount} frame{frameCount === 1 ? "" : "s"} — the file is
+                truncated or exceeds the decode memory cap.
+              </div>
+            )}
+            <div
+              ref={setViewport}
+              className={`file-viewer-image-viewport${dragging ? " dragging" : ""}`}
+              style={{ flex: 1, minHeight: 0 }}
+              onPointerDown={onPointerDown}
+              onPointerMove={onPointerMove}
+              onPointerUp={endDrag}
+              onPointerCancel={endDrag}
+              onDoubleClick={onDoubleClick}
+            >
+              <canvas
+                ref={canvasRef}
+                className="file-viewer-image"
+                width={decoded.width}
+                height={decoded.height}
+                aria-label={fileName}
+                style={{
+                  transform: `translate(${offset.x}px, ${offset.y}px) scale(${scale})`,
+                  transformOrigin: "0 0",
+                  imageRendering: scale > 2 ? "pixelated" : "auto",
+                }}
+              />
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/ImageAnnotator.css b/src/components/embed/ImageAnnotator.css
new file mode 100644
index 0000000..78ccc45
--- /dev/null
+++ b/src/components/embed/ImageAnnotator.css
@@ -0,0 +1,185 @@
+/* Image annotation overlay (Dev F). Self-contained; no global selectors. */
+
+.image-annotator {
+  position: absolute;
+  inset: 0;
+  z-index: 5;
+  display: flex;
+  flex-direction: column;
+  background: var(--bg-panel, #1c1c1e);
+  color: var(--text-primary, #f2f2f7);
+}
+
+.image-annotator__toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 10px;
+  background: var(--bg-panel, #1c1c1e);
+  border-bottom: 1px solid var(--border-color, #3a3a3c);
+}
+
+.image-annotator__title {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-secondary, #a8a8ad);
+  max-width: 240px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.image-annotator__group {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding-left: 8px;
+  border-left: 1px solid var(--border-color, #3a3a3c);
+}
+
+.image-annotator__group:first-of-type {
+  border-left: none;
+  padding-left: 0;
+}
+
+.image-annotator__group--right {
+  margin-left: auto;
+  border-left: none;
+}
+
+.image-annotator__btn {
+  appearance: none;
+  border: 1px solid var(--border-color, #3a3a3c);
+  background: transparent;
+  color: var(--text-primary, #f2f2f7);
+  border-radius: var(--radius);
+  padding: 4px 8px;
+  min-width: 28px;
+  height: 28px;
+  font-size: 13px;
+  line-height: 1;
+  cursor: pointer;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.image-annotator__btn:hover:not(:disabled) {
+  background: var(--bg-hover, rgba(255, 255, 255, 0.08));
+}
+
+.image-annotator__btn:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+
+.image-annotator__btn.is-active {
+  background: var(--accent, #0a84ff);
+  border-color: var(--accent, #0a84ff);
+  color: #fff;
+}
+
+.image-annotator__btn--primary {
+  background: var(--accent, #0a84ff);
+  border-color: var(--accent, #0a84ff);
+  color: #fff;
+  font-weight: 600;
+}
+
+.image-annotator__btn--primary:hover:not(:disabled) {
+  filter: brightness(1.1);
+}
+
+.image-annotator__swatch {
+  width: 22px;
+  height: 22px;
+  border-radius: 50%;
+  border: 2px solid var(--border-color, #3a3a3c);
+  padding: 0;
+  cursor: pointer;
+}
+
+.image-annotator__swatch.is-active {
+  border-color: var(--text-primary, #f2f2f7);
+  box-shadow: 0 0 0 1px var(--bg-panel, #1c1c1e);
+}
+
+.image-annotator__color-input {
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  border: 1px solid var(--border-color, #3a3a3c);
+  border-radius: var(--radius);
+  background: transparent;
+  cursor: pointer;
+}
+
+.image-annotator__width-dot {
+  display: inline-block;
+  border-radius: 50%;
+  background: currentColor;
+}
+
+.image-annotator__error {
+  padding: 6px 10px;
+  font-size: 12px;
+  color: #fff;
+  background: var(--danger, #ff453a);
+}
+
+.image-annotator__stage {
+  flex: 1;
+  min-height: 0;
+  overflow: auto;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 16px;
+  background:
+    repeating-conic-gradient(
+      rgba(255, 255, 255, 0.04) 0% 25%,
+      transparent 0% 50%
+    )
+    50% / 24px 24px;
+}
+
+.image-annotator__canvas-wrap {
+  position: relative;
+  max-width: 100%;
+  max-height: 100%;
+  line-height: 0;
+  box-shadow: var(--shadow-3);
+}
+
+.image-annotator__canvas {
+  display: block;
+  max-width: 100%;
+  max-height: 100%;
+  width: auto;
+  height: auto;
+}
+
+.image-annotator__canvas--base {
+  position: relative;
+}
+
+.image-annotator__canvas--overlay {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  cursor: crosshair;
+  touch-action: none;
+}
+
+.image-annotator__loading {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 13px;
+  color: var(--text-secondary, #a8a8ad);
+  line-height: normal;
+}
diff --git a/src/components/embed/ImageAnnotator.tsx b/src/components/embed/ImageAnnotator.tsx
new file mode 100644
index 0000000..d7575c4
--- /dev/null
+++ b/src/components/embed/ImageAnnotator.tsx
@@ -0,0 +1,463 @@
+/**
+ * Image annotation / markup overlay (Dev F). Mounts over the image viewer when
+ * the user clicks "Annotate". Draws the source image onto a base <canvas> sized
+ * to the image's natural pixels, with a transparent overlay <canvas> on top for
+ * live drawing. Tools: freehand pen, rectangle, arrow, text. Colour + stroke
+ * width controls, Clear + Undo. On save it flattens base + annotations and
+ * writes a PNG via `write_file_bytes` ("Save a copy" → "…-annotated.png", or
+ * "Overwrite" when the source is already a .png), then closes the overlay.
+ *
+ * Props are the lead-fixed contract; do not change without updating the ImageView
+ * call site in FileViewerPane.tsx.
+ */
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useFileScope, writeFileBytes } from "./fileAccess";
+import "./ImageAnnotator.css";
+
+type Tool = "pen" | "rect" | "arrow" | "text";
+
+const PRESET_COLORS = ["#ff3b30", "#ff9500", "#ffcc00", "#34c759", "#0a84ff", "#ffffff", "#000000"];
+const STROKE_WIDTHS = [2, 4, 8, 16];
+
+/** Insert `-annotated` before the extension; force `.png` extension. */
+function annotatedCopyPath(srcPath: string): string {
+  const slash = Math.max(srcPath.lastIndexOf("/"), srcPath.lastIndexOf("\\"));
+  const dir = srcPath.slice(0, slash + 1);
+  const base = srcPath.slice(slash + 1);
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  return `${dir}${stem}-annotated.png`;
+}
+
+function isPng(srcPath: string): boolean {
+  return /\.png$/i.test(srcPath);
+}
+
+export function ImageAnnotator({
+  src,
+  path,
+  fileName,
+  onClose,
+}: {
+  /** Object URL of the image being annotated (already loaded by ImageView). */
+  src: string;
+  /** Absolute path of the source image, for the default save target. */
+  path: string;
+  /** Bare file name, for the save dialog / window title. */
+  fileName: string;
+  /** Close the overlay and return to the plain image viewer. */
+  onClose: () => void;
+}) {
+  const scope = useFileScope();
+  const baseRef = useRef<HTMLCanvasElement | null>(null);
+  const overlayRef = useRef<HTMLCanvasElement | null>(null);
+  const imageRef = useRef<HTMLImageElement | null>(null);
+
+  // Annotation strokes are kept as a committed-pixels stack for undo. Each entry
+  // is a full snapshot of the overlay canvas BEFORE the corresponding op was
+  // drawn, so undo = pop and restore.
+  const undoStackRef = useRef<ImageData[]>([]);
+
+  // Live-gesture state.
+  const drawingRef = useRef(false);
+  const startRef = useRef<{ x: number; y: number } | null>(null);
+  // Snapshot of the overlay at gesture start, used to redraw shapes live.
+  const gestureBaseRef = useRef<ImageData | null>(null);
+
+  const [tool, setTool] = useState<Tool>("pen");
+  const [color, setColor] = useState<string>(PRESET_COLORS[0]);
+  const [width, setWidth] = useState<number>(STROKE_WIDTHS[1]);
+  const [loaded, setLoaded] = useState(false);
+  const [dims, setDims] = useState<{ w: number; h: number } | null>(null);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Keep refs of mutable tool state for use inside stable pointer handlers.
+  const toolRef = useRef(tool);
+  const colorRef = useRef(color);
+  const widthRef = useRef(width);
+  toolRef.current = tool;
+  colorRef.current = color;
+  widthRef.current = width;
+
+  // Load the image and size both canvases to natural pixels.
+  useEffect(() => {
+    let cancelled = false;
+    const img = new Image();
+    img.onload = () => {
+      if (cancelled) return;
+      const w = img.naturalWidth || img.width;
+      const h = img.naturalHeight || img.height;
+      imageRef.current = img;
+      const base = baseRef.current;
+      const overlay = overlayRef.current;
+      if (base) {
+        base.width = w;
+        base.height = h;
+        const ctx = base.getContext("2d");
+        if (ctx) ctx.drawImage(img, 0, 0, w, h);
+      }
+      if (overlay) {
+        overlay.width = w;
+        overlay.height = h;
+      }
+      undoStackRef.current = [];
+      setDims({ w, h });
+      setLoaded(true);
+    };
+    img.onerror = () => {
+      if (!cancelled) setError("Could not load the image for annotation.");
+    };
+    img.src = src;
+    return () => {
+      cancelled = true;
+    };
+  }, [src]);
+
+  const overlayCtx = useCallback((): CanvasRenderingContext2D | null => {
+    return overlayRef.current?.getContext("2d") ?? null;
+  }, []);
+
+  // Map a pointer event (CSS space) to overlay canvas (natural pixel) coords.
+  const toCanvas = useCallback((e: React.PointerEvent<HTMLCanvasElement>) => {
+    const c = overlayRef.current;
+    if (!c) return { x: 0, y: 0 };
+    const rect = c.getBoundingClientRect();
+    const sx = c.width / rect.width;
+    const sy = c.height / rect.height;
+    return {
+      x: (e.clientX - rect.left) * sx,
+      y: (e.clientY - rect.top) * sy,
+    };
+  }, []);
+
+  const pushUndoSnapshot = useCallback(() => {
+    const ctx = overlayCtx();
+    const c = overlayRef.current;
+    if (!ctx || !c) return null;
+    const snap = ctx.getImageData(0, 0, c.width, c.height);
+    undoStackRef.current.push(snap);
+    // Cap the stack to keep memory bounded on large images.
+    if (undoStackRef.current.length > 40) undoStackRef.current.shift();
+    return snap;
+  }, [overlayCtx]);
+
+  const drawArrow = useCallback(
+    (ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number, lw: number) => {
+      ctx.beginPath();
+      ctx.moveTo(x1, y1);
+      ctx.lineTo(x2, y2);
+      ctx.stroke();
+      const angle = Math.atan2(y2 - y1, x2 - x1);
+      const head = Math.max(12, lw * 4);
+      ctx.beginPath();
+      ctx.moveTo(x2, y2);
+      ctx.lineTo(
+        x2 - head * Math.cos(angle - Math.PI / 6),
+        y2 - head * Math.sin(angle - Math.PI / 6),
+      );
+      ctx.moveTo(x2, y2);
+      ctx.lineTo(
+        x2 - head * Math.cos(angle + Math.PI / 6),
+        y2 - head * Math.sin(angle + Math.PI / 6),
+      );
+      ctx.stroke();
+    },
+    [],
+  );
+
+  const applyStroke = useCallback((ctx: CanvasRenderingContext2D) => {
+    ctx.strokeStyle = colorRef.current;
+    ctx.fillStyle = colorRef.current;
+    ctx.lineWidth = widthRef.current;
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+  }, []);
+
+  const onPointerDown = useCallback(
+    (e: React.PointerEvent<HTMLCanvasElement>) => {
+      if (!loaded || saving) return;
+      const ctx = overlayCtx();
+      if (!ctx) return;
+      const pt = toCanvas(e);
+
+      if (toolRef.current === "text") {
+        const text = window.prompt("Annotation text:");
+        if (text && text.trim().length > 0) {
+          pushUndoSnapshot();
+          applyStroke(ctx);
+          const fontPx = Math.max(14, widthRef.current * 6);
+          ctx.font = `${fontPx}px sans-serif`;
+          ctx.textBaseline = "top";
+          ctx.fillText(text, pt.x, pt.y);
+        }
+        return;
+      }
+
+      e.currentTarget.setPointerCapture(e.pointerId);
+      drawingRef.current = true;
+      startRef.current = pt;
+      pushUndoSnapshot();
+      // Stash the post-snapshot pixels so shape previews can redraw cleanly.
+      gestureBaseRef.current = ctx.getImageData(0, 0, ctx.canvas.width, ctx.canvas.height);
+
+      if (toolRef.current === "pen") {
+        applyStroke(ctx);
+        ctx.beginPath();
+        ctx.moveTo(pt.x, pt.y);
+      }
+    },
+    [loaded, saving, overlayCtx, toCanvas, pushUndoSnapshot, applyStroke],
+  );
+
+  const onPointerMove = useCallback(
+    (e: React.PointerEvent<HTMLCanvasElement>) => {
+      if (!drawingRef.current) return;
+      const ctx = overlayCtx();
+      const start = startRef.current;
+      if (!ctx || !start) return;
+      const pt = toCanvas(e);
+      const t = toolRef.current;
+
+      if (t === "pen") {
+        applyStroke(ctx);
+        ctx.lineTo(pt.x, pt.y);
+        ctx.stroke();
+        return;
+      }
+
+      // Shape tools: restore the pre-gesture pixels then draw the live preview.
+      const baseSnap = gestureBaseRef.current;
+      if (baseSnap) ctx.putImageData(baseSnap, 0, 0);
+      applyStroke(ctx);
+      if (t === "rect") {
+        ctx.strokeRect(start.x, start.y, pt.x - start.x, pt.y - start.y);
+      } else if (t === "arrow") {
+        drawArrow(ctx, start.x, start.y, pt.x, pt.y, widthRef.current);
+      }
+    },
+    [overlayCtx, toCanvas, applyStroke, drawArrow],
+  );
+
+  const endGesture = useCallback(
+    (e: React.PointerEvent<HTMLCanvasElement>) => {
+      if (!drawingRef.current) return;
+      drawingRef.current = false;
+      startRef.current = null;
+      gestureBaseRef.current = null;
+      try {
+        e.currentTarget.releasePointerCapture(e.pointerId);
+      } catch {
+        /* capture may already be gone */
+      }
+    },
+    [],
+  );
+
+  const undo = useCallback(() => {
+    const ctx = overlayCtx();
+    const snap = undoStackRef.current.pop();
+    if (!ctx) return;
+    if (snap) {
+      ctx.putImageData(snap, 0, 0);
+    } else {
+      ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+    }
+  }, [overlayCtx]);
+
+  const clear = useCallback(() => {
+    const ctx = overlayCtx();
+    if (!ctx) return;
+    pushUndoSnapshot();
+    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+  }, [overlayCtx, pushUndoSnapshot]);
+
+  // Flatten base image + overlay annotations into a single PNG blob.
+  const flatten = useCallback((): Promise<Blob | null> => {
+    return new Promise((resolve) => {
+      const base = baseRef.current;
+      const overlay = overlayRef.current;
+      if (!base || !overlay) {
+        resolve(null);
+        return;
+      }
+      const out = document.createElement("canvas");
+      out.width = base.width;
+      out.height = base.height;
+      const ctx = out.getContext("2d");
+      if (!ctx) {
+        resolve(null);
+        return;
+      }
+      ctx.drawImage(base, 0, 0);
+      ctx.drawImage(overlay, 0, 0);
+      out.toBlob((blob) => resolve(blob), "image/png");
+    });
+  }, []);
+
+  const save = useCallback(
+    async (targetPath: string) => {
+      if (saving) return;
+      setError(null);
+      setSaving(true);
+      try {
+        const blob = await flatten();
+        if (!blob) {
+          setError("Could not render the annotated image.");
+          setSaving(false);
+          return;
+        }
+        const buf = await blob.arrayBuffer();
+        await writeFileBytes(targetPath, new Uint8Array(buf), scope);
+        onClose();
+      } catch (err) {
+        setError(`Save failed: ${err instanceof Error ? err.message : String(err)}`);
+        setSaving(false);
+      }
+    },
+    [saving, flatten, onClose, scope],
+  );
+
+  // Esc cancels.
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        onClose();
+      }
+    };
+    window.addEventListener("keydown", onKey, true);
+    return () => window.removeEventListener("keydown", onKey, true);
+  }, [onClose]);
+
+  const sourceIsPng = isPng(path);
+  const copyTarget = annotatedCopyPath(path);
+
+  return (
+    <div className="image-annotator" role="dialog" aria-label={`Annotate ${fileName}`}>
+      <div className="image-annotator__toolbar">
+        <span className="image-annotator__title" title={path}>
+          ✎ {fileName}
+        </span>
+
+        <div className="image-annotator__group" role="group" aria-label="Tools">
+          {(["pen", "rect", "arrow", "text"] as Tool[]).map((t) => (
+            <button
+              key={t}
+              className={`image-annotator__btn${tool === t ? " is-active" : ""}`}
+              onClick={() => setTool(t)}
+              title={
+                t === "pen"
+                  ? "Freehand pen"
+                  : t === "rect"
+                    ? "Rectangle"
+                    : t === "arrow"
+                      ? "Arrow"
+                      : "Text"
+              }
+            >
+              {t === "pen" ? "✏︎" : t === "rect" ? "▢" : t === "arrow" ? "↗" : "T"}
+            </button>
+          ))}
+        </div>
+
+        <div className="image-annotator__group" role="group" aria-label="Colour">
+          {PRESET_COLORS.map((c) => (
+            <button
+              key={c}
+              className={`image-annotator__swatch${color === c ? " is-active" : ""}`}
+              style={{ background: c }}
+              onClick={() => setColor(c)}
+              title={c}
+              aria-label={`Colour ${c}`}
+            />
+          ))}
+          <input
+            type="color"
+            className="image-annotator__color-input"
+            value={/^#[0-9a-f]{6}$/i.test(color) ? color : "#ff3b30"}
+            onChange={(e) => setColor(e.target.value)}
+            title="Custom colour"
+            aria-label="Custom colour"
+          />
+        </div>
+
+        <div className="image-annotator__group" role="group" aria-label="Stroke width">
+          {STROKE_WIDTHS.map((w) => (
+            <button
+              key={w}
+              className={`image-annotator__btn image-annotator__width${width === w ? " is-active" : ""}`}
+              onClick={() => setWidth(w)}
+              title={`${w}px`}
+            >
+              <span
+                className="image-annotator__width-dot"
+                style={{ width: Math.min(w + 2, 18), height: Math.min(w + 2, 18) }}
+              />
+            </button>
+          ))}
+        </div>
+
+        <div className="image-annotator__group">
+          <button className="image-annotator__btn" onClick={undo} title="Undo last mark">
+            ⤺ undo
+          </button>
+          <button className="image-annotator__btn" onClick={clear} title="Clear all marks">
+            clear
+          </button>
+        </div>
+
+        <div className="image-annotator__group image-annotator__group--right">
+          <button
+            className="image-annotator__btn image-annotator__btn--primary"
+            onClick={() => save(copyTarget)}
+            disabled={!loaded || saving}
+            title={`Save a copy to ${copyTarget}`}
+          >
+            {saving ? "Saving…" : "Save a copy"}
+          </button>
+          {sourceIsPng && (
+            <button
+              className="image-annotator__btn"
+              onClick={() => save(path)}
+              disabled={!loaded || saving}
+              title={`Overwrite ${path}`}
+            >
+              Overwrite
+            </button>
+          )}
+          <button
+            className="image-annotator__btn"
+            onClick={onClose}
+            disabled={saving}
+            title="Discard and close"
+          >
+            Cancel
+          </button>
+        </div>
+      </div>
+
+      {error != null && <div className="image-annotator__error">{error}</div>}
+
+      <div className="image-annotator__stage">
+        <div
+          className="image-annotator__canvas-wrap"
+          style={dims ? { aspectRatio: `${dims.w} / ${dims.h}` } : undefined}
+        >
+          <canvas ref={baseRef} className="image-annotator__canvas image-annotator__canvas--base" />
+          <canvas
+            ref={overlayRef}
+            className="image-annotator__canvas image-annotator__canvas--overlay"
+            onPointerDown={onPointerDown}
+            onPointerMove={onPointerMove}
+            onPointerUp={endGesture}
+            onPointerCancel={endGesture}
+          />
+          {!loaded && error == null && (
+            <div className="image-annotator__loading">Loading image…</div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/MediaView.tsx b/src/components/embed/MediaView.tsx
new file mode 100644
index 0000000..64470cb
--- /dev/null
+++ b/src/components/embed/MediaView.tsx
@@ -0,0 +1,169 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { ViewerHeader } from "./FileViewerPane";
+import { useFileScope, readFileBytes } from "./fileAccess";
+import { basename } from "../../lib/paths";
+
+/**
+ * Audio/video player viewer (Dev D). Plays `.mp3`/`.mp4`/`.webm`/… in-tab via
+ * the webview's native <audio>/<video>, sourcing the bytes through a Blob URL
+ * (reuse `read_file_bytes`, picking the MIME from the extension). Read-only.
+ *
+ * Controls are enabled; nothing autoplays. `preload="metadata"` fetches just
+ * enough of the blob to populate duration/dimensions without buffering the whole
+ * file up front. Mirrors the image viewer's blob-URL lifecycle: a new object URL
+ * is minted per path and the previous one revoked when the path changes / on
+ * unmount, so the blobs don't leak.
+ */
+
+/** Lowercased extension → MIME type. Anything not listed is treated as audio
+ *  with an empty type (let the webview sniff). The keys here are also the set of
+ *  extensions FileViewerPane routes to the "media" viewer. */
+const MIME_BY_EXT: Record<string, string> = {
+  // audio
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  opus: "audio/ogg",
+  flac: "audio/flac",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  // video
+  mp4: "video/mp4",
+  m4v: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  mkv: "video/x-matroska",
+  ogv: "video/ogg",
+};
+
+/** Extensions that should render in a <video> element; everything else routed
+ *  here plays as <audio>. */
+const VIDEO_EXTS = new Set(["mp4", "m4v", "webm", "mov", "mkv", "ogv"]);
+
+/** Lowercased extension (no dot) of a path, or "" when it has none. */
+function extOf(path: string): string {
+  const name = basename(path);
+  const dot = name.lastIndexOf(".");
+  return dot >= 0 ? name.slice(dot + 1).toLowerCase() : "";
+}
+
+/**
+ * Load `path`'s bytes once and expose them as a typed Blob object URL, revoking
+ * the previous URL when the path changes and on unmount. `type` picks the Blob
+ * MIME so the webview decodes the right codec. A read failure (missing file, or
+ * the backend's large-file rejection) surfaces as `error`.
+ */
+function useMediaBlobUrl(path: string, type: string) {
+  const scope = useFileScope();
+  const [url, setUrl] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const urlRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    setUrl(null);
+    setError(null);
+    readFileBytes(path, scope)
+      .then((bytes) => {
+        if (cancelled) return;
+        const blob = new Blob([new Uint8Array(bytes)], type ? { type } : undefined);
+        const objectUrl = URL.createObjectURL(blob);
+        const prev = urlRef.current;
+        urlRef.current = objectUrl;
+        setUrl(objectUrl);
+        if (prev) URL.revokeObjectURL(prev);
+      })
+      .catch((e) => {
+        if (!cancelled) setError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path, type, scope]);
+
+  // Revoke the last live URL on unmount.
+  useEffect(
+    () => () => {
+      if (urlRef.current) {
+        URL.revokeObjectURL(urlRef.current);
+        urlRef.current = null;
+      }
+    },
+    [],
+  );
+
+  return { url, error };
+}
+
+export function MediaView({
+  path,
+  onOpenExternally,
+  tabKey: _tabKey,
+}: {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  const ext = useMemo(() => extOf(path), [path]);
+  const mime = MIME_BY_EXT[ext] ?? "";
+  const isVideo = VIDEO_EXTS.has(ext);
+  const { url, error } = useMediaBlobUrl(path, mime);
+
+  // A media element that fails to decode (unsupported codec/container in the
+  // webview) surfaces an onError; show it instead of a frozen player.
+  const [playbackError, setPlaybackError] = useState<string | null>(null);
+  useEffect(() => {
+    setPlaybackError(null);
+  }, [url]);
+
+  return (
+    <div className="file-viewer">
+      <ViewerHeader onOpenExternally={onOpenExternally} />
+      <div
+        className="file-viewer-body"
+        style={{
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          overflow: "hidden",
+          padding: 12,
+        }}
+      >
+        {error != null ? (
+          <div className="file-viewer-error">{error}</div>
+        ) : playbackError != null ? (
+          <div className="file-viewer-error">{playbackError}</div>
+        ) : url == null ? (
+          <div className="file-viewer-loading">Loading…</div>
+        ) : isVideo ? (
+          <video
+            key={url}
+            src={url}
+            controls
+            preload="metadata"
+            onError={() =>
+              setPlaybackError("This media couldn't be played in-app. Try opening it externally.")
+            }
+            style={{
+              maxWidth: "100%",
+              maxHeight: "100%",
+              objectFit: "contain",
+            }}
+          />
+        ) : (
+          <audio
+            key={url}
+            src={url}
+            controls
+            preload="metadata"
+            onError={() =>
+              setPlaybackError("This media couldn't be played in-app. Try opening it externally.")
+            }
+            style={{ width: "100%", maxWidth: 640 }}
+          />
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/NotebookView.tsx b/src/components/embed/NotebookView.tsx
new file mode 100644
index 0000000..9ca30a8
--- /dev/null
+++ b/src/components/embed/NotebookView.tsx
@@ -0,0 +1,118 @@
+import { useMemo } from "react";
+import {
+  ViewerHeader,
+  useViewerState,
+  useReadonlyFile,
+  escapeHtmlText,
+} from "./FileViewerPane";
+import { renderMarkdown } from "../../lib/viewers/markdown";
+import { highlight } from "../../lib/viewers/highlight";
+import { parseNotebook, type NbOutput, type ParsedNotebook } from "../../lib/viewers/notebook";
+
+/**
+ * Read-only in-app viewer for Jupyter `.ipynb` notebooks (TODO Group K #40, new
+ * viewers). Loads the raw notebook JSON via `useReadonlyFile`, parses it with the
+ * pure `parseNotebook` (nbformat v4 subset), and renders the cells top-to-bottom:
+ *   - markdown cells via `renderMarkdown` (the sanitizer for this repo — no
+ *     DOMPurify), and
+ *   - code cells as Python-highlighted blocks followed by their classified
+ *     outputs (stream/result text, error tracebacks, and PNG images).
+ *
+ * SECURITY: every HTML string we set with dangerouslySetInnerHTML comes from
+ * `renderMarkdown`, `highlight`, or `escapeHtmlText`, all of which escape-first.
+ * A notebook's `text/html` outputs are never rendered (the parser drops them),
+ * and image outputs are limited to base64 PNG data URLs.
+ */
+export function NotebookView({
+  path,
+  onOpenExternally,
+  tabKey,
+}: {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  // tabKey accepted for call-site parity with the other viewers; the notebook
+  // viewer has no persisted reader position to restore yet.
+  useViewerState(tabKey);
+
+  const { content, error, loaded } = useReadonlyFile(path);
+
+  // Parse once per content load; guard a malformed notebook so a parse failure
+  // shows an error state rather than crashing the pane. `parseNotebook` is itself
+  // tolerant (returns an empty notebook on bad JSON), so we additionally flag the
+  // "parsed but no cells AND non-empty source" case as a likely bad file.
+  const parsed = useMemo<{ nb: ParsedNotebook | null; parseError: string | null }>(() => {
+    if (content == null) return { nb: null, parseError: null };
+    try {
+      const nb = parseNotebook(content);
+      if (nb.cells.length === 0 && content.trim().length > 0) {
+        return { nb, parseError: "This notebook has no readable cells." };
+      }
+      return { nb, parseError: null };
+    } catch (e) {
+      return { nb: null, parseError: String(e) };
+    }
+  }, [content]);
+
+  return (
+    <div className="file-viewer notebook-viewer">
+      <ViewerHeader onOpenExternally={onOpenExternally} />
+      <div className="notebook-viewer-body">
+        {error != null ? (
+          <div className="file-viewer-error">Failed to load notebook: {error}</div>
+        ) : !loaded ? (
+          <div className="file-viewer-loading">Loading…</div>
+        ) : parsed.parseError ? (
+          <div className="file-viewer-error">{parsed.parseError}</div>
+        ) : parsed.nb ? (
+          parsed.nb.cells.map((cell, idx) =>
+            cell.type === "markdown" ? (
+              <div
+                key={idx}
+                className="notebook-cell notebook-cell-md"
+                dangerouslySetInnerHTML={{ __html: renderMarkdown(cell.source) }}
+              />
+            ) : (
+              <CodeCell key={idx} source={cell.source} outputs={cell.outputs ?? []} />
+            ),
+          )
+        ) : null}
+      </div>
+    </div>
+  );
+}
+
+/** A single code cell: the Python-highlighted source followed by its outputs. */
+function CodeCell({ source, outputs }: { source: string; outputs: NbOutput[] }) {
+  // highlight() returns safe HTML, or null when it declines (too large); fall
+  // back to escaped plain text in that case. Both branches are escape-first.
+  const codeHtml = useMemo(() => highlight(source, "python"), [source]);
+  return (
+    <div className="notebook-cell notebook-cell-code">
+      <pre className="notebook-code">
+        {codeHtml != null ? (
+          <code dangerouslySetInnerHTML={{ __html: codeHtml }} />
+        ) : (
+          <code dangerouslySetInnerHTML={{ __html: escapeHtmlText(source) }} />
+        )}
+      </pre>
+      {outputs.map((out, i) =>
+        out.kind === "image" ? (
+          <img
+            key={i}
+            className="notebook-output notebook-output-image"
+            src={`data:image/png;base64,${out.pngBase64 ?? ""}`}
+            alt="cell output"
+          />
+        ) : (
+          <pre
+            key={i}
+            className="notebook-output notebook-output-text"
+            dangerouslySetInnerHTML={{ __html: escapeHtmlText(out.text ?? "") }}
+          />
+        ),
+      )}
+    </div>
+  );
+}
diff --git a/src/components/embed/OdtView.tsx b/src/components/embed/OdtView.tsx
new file mode 100644
index 0000000..da9b761
--- /dev/null
+++ b/src/components/embed/OdtView.tsx
@@ -0,0 +1,95 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { unzipSync } from "fflate";
+import { ViewerHeader, useViewerState } from "./FileViewerPane";
+import { useFileScope, readFileBytes, fileMtime } from "./fileAccess";
+import { extractOdt, renderOdtDocument } from "../../lib/viewers/odt";
+
+// Re-read the file this long after an external change is detected (mirrors the
+// other viewers' diff-aware reload cadence).
+const RELOAD_POLL_MS = 1500;
+
+/**
+ * Read-only in-app viewer for OpenDocument Text (`.odt`) files (#51, lightweight
+ * approach). An `.odt` is a ZIP, so it's loaded as raw bytes via `read_file_bytes`
+ * (not `read_file_text`), unzipped in-process with fflate, and rendered to safe
+ * HTML by the pure `renderOdtDocument`. Like the table/notebook viewers it polls
+ * `file_mtime` and silently re-renders when the document changes on disk.
+ *
+ * SECURITY: the injected HTML comes solely from `renderOdtDocument`, which builds
+ * it tag-by-tag from a whitelist and escapes all text/attributes (no DOMPurify) —
+ * see the module header. The faithful path remains "Open externally".
+ */
+export function OdtView({
+  path,
+  onOpenExternally,
+  tabKey,
+}: {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  // tabKey accepted for call-site parity; no persisted reader position yet.
+  useViewerState(tabKey);
+  const scope = useFileScope();
+
+  const [html, setHtml] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const lastMtime = useRef<number | null>(null);
+
+  const load = useCallback(async () => {
+    try {
+      const bytes = await readFileBytes(path, scope);
+      const entries = unzipSync(new Uint8Array(bytes));
+      const { contentXml, images } = extractOdt(entries);
+      setHtml(renderOdtDocument(contentXml, { images }));
+      setError(null);
+    } catch (e) {
+      setError(String(e));
+    }
+  }, [path, scope]);
+
+  // Initial load + mtime baseline.
+  useEffect(() => {
+    setHtml(null);
+    setError(null);
+    lastMtime.current = null;
+    void load();
+    fileMtime(path, scope)
+      .then((m) => { lastMtime.current = m; })
+      .catch(() => {});
+  }, [path, scope, load]);
+
+  // Diff-aware reload: poll mtime; re-render on an external advance.
+  useEffect(() => {
+    if (html == null) return;
+    let cancelled = false;
+    const id = setInterval(() => {
+      fileMtime(path, scope)
+        .then((m) => {
+          if (cancelled || lastMtime.current == null || m <= lastMtime.current) return;
+          lastMtime.current = m;
+          void load();
+        })
+        .catch(() => {});
+    }, RELOAD_POLL_MS);
+    return () => { cancelled = true; clearInterval(id); };
+  }, [path, scope, html, load]);
+
+  const loaded = html != null;
+  return (
+    <div className="file-viewer odt-viewer">
+      <ViewerHeader onOpenExternally={onOpenExternally} />
+      <div className="odt-viewer-body">
+        {error != null ? (
+          <div className="file-viewer-error">Failed to render document: {error}</div>
+        ) : !loaded ? (
+          <div className="file-viewer-loading">Loading…</div>
+        ) : html.trim().length === 0 ? (
+          <div className="file-viewer-loading">This document is empty.</div>
+        ) : (
+          <div className="odt-document" dangerouslySetInnerHTML={{ __html: html }} />
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/PresentationOverlay.tsx b/src/components/embed/PresentationOverlay.tsx
new file mode 100644
index 0000000..5f77b98
--- /dev/null
+++ b/src/components/embed/PresentationOverlay.tsx
@@ -0,0 +1,540 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { UntestedTag } from "../common/UntestedTag";
+
+/**
+ * A presentation / walkthrough aid layered over EVERY native viewer (image,
+ * PDF, markdown, code, table, …). It gives two ephemeral, non-persisted tools:
+ *
+ *  - **Marker** — a highlighter pen. Drag to lay down a translucent colored
+ *    stroke (six highlighter colors); undo the last stroke or clear them all.
+ *    Strokes live on a `<canvas>` in NORMALIZED (0..1) pane coordinates, so they
+ *    rescale when the pane is resized rather than drifting off the content.
+ *  - **Laser** — a glowing dot that follows the cursor with a short fading
+ *    trail, drawn on its own transient canvas driven by rAF. Nothing it draws
+ *    is kept; it exists only while the pointer moves.
+ *
+ * It is mounted ONCE by `FileViewerPane` over the chosen viewer, so no
+ * per-viewer wiring is needed. When no tool is active the whole overlay is
+ * `pointer-events: none` and every click falls straight through to the viewer;
+ * only the small floating toolbar keeps pointer events so it can be reopened.
+ * Marker strokes are session-only (component state) — a presentation aid, not a
+ * saved annotation — and reset when the viewer tab closes.
+ */
+
+type Tool = "off" | "marker" | "laser";
+
+/** One completed marker stroke: it carries the color, width and opacity it was
+ *  drawn WITH, so changing the menu never restyles marks already on the page. */
+interface Stroke {
+  color: string;
+  /** Stroke width in CSS px at device-pixel-ratio 1. */
+  width: number;
+  /** Ink opacity, 0..1. */
+  alpha: number;
+  /** Points as [x,y] fractions of the pane's width/height (0..1). */
+  pts: Array<[number, number]>;
+}
+
+/** Highlighter palette — translucent, so overlapping strokes read as ink. */
+const PALETTE: Array<{ name: string; value: string }> = [
+  { name: "Yellow", value: "#ffe14d" },
+  { name: "Green", value: "#7cf06a" },
+  { name: "Pink", value: "#ff6ec7" },
+  { name: "Blue", value: "#5cc8ff" },
+  { name: "Orange", value: "#ffa63d" },
+  { name: "Red", value: "#ff5252" },
+];
+
+/** Default highlighter stroke width, in CSS px, at device-pixel-ratio 1. */
+const MARKER_WIDTH = 16;
+const MIN_WIDTH = 4;
+const MAX_WIDTH = 48;
+/** Default ink opacity (0..1) and its adjustable range. */
+const MARKER_ALPHA = 0.38;
+const MIN_ALPHA = 0.1;
+const MAX_ALPHA = 1;
+/** How long a laser trail point lives, in ms. */
+const LASER_LIFETIME = 420;
+
+export function PresentationOverlay() {
+  const [tool, setTool] = useState<Tool>("off");
+  const [open, setOpen] = useState(false);
+  const [color, setColor] = useState(PALETTE[0].value);
+  const [width, setWidth] = useState(MARKER_WIDTH);
+  const [alpha, setAlpha] = useState(MARKER_ALPHA);
+  const [settingsOpen, setSettingsOpen] = useState(false);
+  const [strokes, setStrokes] = useState<Stroke[]>([]);
+
+  const rootRef = useRef<HTMLDivElement | null>(null);
+  const markerRef = useRef<HTMLCanvasElement | null>(null);
+  const laserRef = useRef<HTMLCanvasElement | null>(null);
+  const captureRef = useRef<HTMLDivElement | null>(null);
+
+  // The in-progress marker stroke (mutated during a drag; committed on release).
+  const drawing = useRef<Stroke | null>(null);
+  // Transient laser trail: recent pointer samples with a birth timestamp.
+  const trail = useRef<Array<{ x: number; y: number; t: number }>>([]);
+  // The laser's current resting position (pane-local px). Kept separate from the
+  // fading trail so the dot stays lit while the pointer is STILL; null once the
+  // cursor leaves the pane.
+  const laserPos = useRef<{ x: number; y: number } | null>(null);
+  const rafRef = useRef<number | null>(null);
+  // Latest tool/strokes/color/width/alpha for callbacks that close over stale state.
+  const toolRef = useRef(tool);
+  toolRef.current = tool;
+  const strokesRef = useRef(strokes);
+  strokesRef.current = strokes;
+  const colorRef = useRef(color);
+  colorRef.current = color;
+  const widthRef = useRef(width);
+  widthRef.current = width;
+  const alphaRef = useRef(alpha);
+  alphaRef.current = alpha;
+
+  const active = tool !== "off";
+
+  // ── Canvas sizing ─────────────────────────────────────────────────────────
+  // Keep both canvases matched to the pane's pixel size (× DPR for crispness);
+  // redraw the marker layer whenever the box changes so normalized strokes
+  // re-lay out at the new size.
+  const sizeCanvases = useCallback(() => {
+    const root = rootRef.current;
+    if (!root) return;
+    const w = root.clientWidth;
+    const h = root.clientHeight;
+    const dpr = window.devicePixelRatio || 1;
+    for (const c of [markerRef.current, laserRef.current]) {
+      if (!c) continue;
+      const pw = Math.max(1, Math.round(w * dpr));
+      const ph = Math.max(1, Math.round(h * dpr));
+      if (c.width !== pw || c.height !== ph) {
+        c.width = pw;
+        c.height = ph;
+      }
+    }
+  }, []);
+
+  const drawMarker = useCallback(() => {
+    const c = markerRef.current;
+    if (!c) return;
+    const ctx = c.getContext("2d");
+    if (!ctx) return;
+    const dpr = window.devicePixelRatio || 1;
+    ctx.clearRect(0, 0, c.width, c.height);
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    const paint = (s: Stroke) => {
+      if (s.pts.length === 0) return;
+      ctx.strokeStyle = s.color;
+      ctx.globalAlpha = s.alpha;
+      ctx.lineWidth = s.width * dpr;
+      ctx.beginPath();
+      const [x0, y0] = s.pts[0];
+      ctx.moveTo(x0 * c.width, y0 * c.height);
+      if (s.pts.length === 1) {
+        // A tap: draw a dot so a single click still marks something.
+        ctx.lineTo(x0 * c.width + 0.01, y0 * c.height);
+      }
+      for (let i = 1; i < s.pts.length; i++) {
+        ctx.lineTo(s.pts[i][0] * c.width, s.pts[i][1] * c.height);
+      }
+      ctx.stroke();
+    };
+    for (const s of strokesRef.current) paint(s);
+    if (drawing.current) paint(drawing.current);
+    ctx.globalAlpha = 1;
+  }, []);
+
+  useLayoutEffect(() => {
+    sizeCanvases();
+    drawMarker();
+    const root = rootRef.current;
+    if (!root || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => {
+      sizeCanvases();
+      drawMarker();
+    });
+    ro.observe(root);
+    return () => ro.disconnect();
+  }, [sizeCanvases, drawMarker]);
+
+  // Redraw the committed strokes whenever they change.
+  useEffect(() => {
+    drawMarker();
+  }, [strokes, drawMarker]);
+
+  // ── Laser animation ───────────────────────────────────────────────────────
+  useEffect(() => {
+    if (tool !== "laser") {
+      trail.current = [];
+      laserPos.current = null;
+      if (rafRef.current != null) {
+        cancelAnimationFrame(rafRef.current);
+        rafRef.current = null;
+      }
+      const c = laserRef.current;
+      const ctx = c?.getContext("2d");
+      if (c && ctx) ctx.clearRect(0, 0, c.width, c.height);
+      return;
+    }
+    const tick = () => {
+      const c = laserRef.current;
+      const ctx = c?.getContext("2d");
+      if (c && ctx) {
+        const dpr = window.devicePixelRatio || 1;
+        const now = performance.now();
+        trail.current = trail.current.filter((p) => now - p.t < LASER_LIFETIME);
+        ctx.clearRect(0, 0, c.width, c.height);
+        ctx.save();
+        for (const p of trail.current) {
+          const age = (now - p.t) / LASER_LIFETIME; // 0 fresh → 1 gone
+          const a = 1 - age;
+          const r = (4 + 6 * a) * dpr;
+          ctx.globalAlpha = a * 0.5;
+          ctx.fillStyle = colorRef.current;
+          ctx.beginPath();
+          ctx.arc(p.x * dpr, p.y * dpr, r, 0, Math.PI * 2);
+          ctx.fill();
+        }
+        // The dot rests at the last known position, not the newest trail point,
+        // so it stays lit while the pointer is motionless (the trail fades out
+        // behind it but the head does not vanish).
+        const head = laserPos.current ?? trail.current[trail.current.length - 1];
+        if (head) {
+          // Bright glowing core.
+          ctx.globalAlpha = 1;
+          ctx.shadowColor = colorRef.current;
+          ctx.shadowBlur = 18 * dpr;
+          ctx.fillStyle = colorRef.current;
+          ctx.beginPath();
+          ctx.arc(head.x * dpr, head.y * dpr, 7 * dpr, 0, Math.PI * 2);
+          ctx.fill();
+          ctx.shadowBlur = 0;
+          ctx.fillStyle = "#ffffff";
+          ctx.globalAlpha = 0.9;
+          ctx.beginPath();
+          ctx.arc(head.x * dpr, head.y * dpr, 2.5 * dpr, 0, Math.PI * 2);
+          ctx.fill();
+        }
+        ctx.restore();
+      }
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (rafRef.current != null) cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    };
+  }, [tool]);
+
+  // ── Pointer handling on the capture surface ───────────────────────────────
+  const relPoint = (e: React.PointerEvent): [number, number] => {
+    const root = rootRef.current;
+    if (!root) return [0, 0];
+    const r = root.getBoundingClientRect();
+    return [(e.clientX - r.left) / r.width, (e.clientY - r.top) / r.height];
+  };
+
+  const pushLaser = (e: React.PointerEvent) => {
+    const r = rootRef.current!.getBoundingClientRect();
+    const p = { x: e.clientX - r.left, y: e.clientY - r.top };
+    laserPos.current = p;
+    trail.current.push({ ...p, t: performance.now() });
+  };
+
+  const onPointerDown = (e: React.PointerEvent) => {
+    if (toolRef.current === "off") return;
+    (e.target as HTMLElement).setPointerCapture?.(e.pointerId);
+    if (toolRef.current === "marker") {
+      drawing.current = {
+        color: colorRef.current,
+        width: widthRef.current,
+        alpha: alphaRef.current,
+        pts: [relPoint(e)],
+      };
+      drawMarker();
+    } else if (toolRef.current === "laser") {
+      pushLaser(e);
+    }
+  };
+
+  const onPointerMove = (e: React.PointerEvent) => {
+    if (toolRef.current === "marker") {
+      if (!drawing.current) return;
+      drawing.current.pts.push(relPoint(e));
+      drawMarker();
+    } else if (toolRef.current === "laser") {
+      pushLaser(e);
+    }
+  };
+
+  const onPointerUp = () => {
+    if (toolRef.current === "marker" && drawing.current) {
+      const s = drawing.current;
+      drawing.current = null;
+      if (s.pts.length > 0) setStrokes((prev) => [...prev, s]);
+    }
+  };
+
+  // Cursor left the pane: drop the resting laser dot so it doesn't hover over
+  // whatever the mouse moved on to.
+  const onPointerLeave = () => {
+    laserPos.current = null;
+  };
+
+  // The capture surface sits over the whole pane to receive marker/laser drags,
+  // but that same `pointer-events: auto` swallows the wheel — so a viewer no
+  // longer scrolls while a tool is armed. Forward the wheel through to whatever
+  // scrollable element is under the cursor: momentarily make the surface
+  // transparent to hit-testing, find the element beneath, scroll its nearest
+  // scrollable ancestor ourselves. Native + non-passive so `preventDefault`
+  // takes. (Marker strokes stay screen-anchored, which is expected for a
+  // presentation aid — you scroll to new content, then keep marking.)
+  useEffect(() => {
+    const cap = captureRef.current;
+    if (!cap || !active) return;
+    const onWheel = (e: WheelEvent) => {
+      const prev = cap.style.pointerEvents;
+      cap.style.pointerEvents = "none";
+      const under = document.elementFromPoint(e.clientX, e.clientY);
+      cap.style.pointerEvents = prev;
+      const scroller = findScrollable(under, e.deltaX, e.deltaY);
+      if (scroller) {
+        scroller.scrollBy({ left: e.deltaX, top: e.deltaY });
+        e.preventDefault();
+      }
+    };
+    cap.addEventListener("wheel", onWheel, { passive: false });
+    return () => cap.removeEventListener("wheel", onWheel);
+  }, [active]);
+
+  // Esc leaves the active tool (back to click-through) without closing the bar.
+  useEffect(() => {
+    if (!active) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setTool("off");
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [active]);
+
+  const undo = () => setStrokes((prev) => prev.slice(0, -1));
+  const clear = () => setStrokes([]);
+
+  const showSwatches = open && (tool === "marker" || tool === "laser");
+
+  return (
+    <div
+      ref={rootRef}
+      className={`presentation-overlay${active ? " active" : ""}`}
+      // The whole layer is inert unless a tool is active; only the toolbar
+      // (which re-enables pointer events on itself) stays clickable.
+      style={{ pointerEvents: "none" }}
+    >
+      <canvas ref={markerRef} className="presentation-canvas" />
+      <canvas ref={laserRef} className="presentation-canvas" />
+      {active && (
+        <div
+          ref={captureRef}
+          className="presentation-capture"
+          onPointerDown={onPointerDown}
+          onPointerMove={onPointerMove}
+          onPointerUp={onPointerUp}
+          onPointerCancel={onPointerUp}
+          onPointerLeave={onPointerLeave}
+          style={{ cursor: tool === "laser" ? "none" : "crosshair" }}
+        />
+      )}
+
+      <div className="presentation-toolbar" style={{ pointerEvents: "auto" }}>
+        {!open ? (
+          <button
+            className="presentation-fab"
+            title="Presentation tools (marker & laser)"
+            aria-label="Presentation tools"
+            onClick={() => setOpen(true)}
+          >
+            <PenIcon />
+          </button>
+        ) : (
+          <div className="presentation-tools" role="toolbar" aria-label="Presentation tools">
+            <button
+              className={`presentation-tool${tool === "marker" ? " on" : ""}`}
+              title="Marker (highlight)"
+              aria-pressed={tool === "marker"}
+              onClick={() => setTool((t) => (t === "marker" ? "off" : "marker"))}
+            >
+              <MarkerIcon />
+            </button>
+            <button
+              className={`presentation-tool${tool === "laser" ? " on" : ""}`}
+              title="Laser pointer"
+              aria-pressed={tool === "laser"}
+              onClick={() => setTool((t) => (t === "laser" ? "off" : "laser"))}
+            >
+              <LaserIcon />
+            </button>
+
+            {showSwatches && (
+              <div className="presentation-swatches">
+                {PALETTE.map((c) => (
+                  <button
+                    key={c.value}
+                    className={`presentation-swatch${color === c.value ? " on" : ""}`}
+                    style={{ background: c.value }}
+                    title={c.name}
+                    aria-label={c.name}
+                    aria-pressed={color === c.value}
+                    onClick={() => setColor(c.value)}
+                  />
+                ))}
+              </div>
+            )}
+
+            {tool === "marker" && (
+              <div className="presentation-settings-wrap">
+                <button
+                  className={`presentation-tool${settingsOpen ? " on" : ""}`}
+                  title="Thickness & opacity"
+                  aria-label="Thickness & opacity"
+                  aria-pressed={settingsOpen}
+                  onClick={() => setSettingsOpen((o) => !o)}
+                >
+                  <SlidersIcon />
+                </button>
+                {settingsOpen && (
+                  <div className="presentation-settings" role="group" aria-label="Marker settings">
+                    <label className="presentation-slider">
+                      <span className="presentation-slider-label">
+                        Thickness <b>{width}px</b>
+                      </span>
+                      <input
+                        type="range"
+                        min={MIN_WIDTH}
+                        max={MAX_WIDTH}
+                        step={1}
+                        value={width}
+                        onChange={(e) => setWidth(Number(e.target.value))}
+                      />
+                    </label>
+                    <label className="presentation-slider">
+                      <span className="presentation-slider-label">
+                        Opacity <b>{Math.round(alpha * 100)}%</b>
+                      </span>
+                      <input
+                        type="range"
+                        min={Math.round(MIN_ALPHA * 100)}
+                        max={Math.round(MAX_ALPHA * 100)}
+                        step={5}
+                        value={Math.round(alpha * 100)}
+                        onChange={(e) => setAlpha(Number(e.target.value) / 100)}
+                      />
+                    </label>
+                    <div
+                      className="presentation-preview"
+                      style={{ background: color, opacity: alpha, height: `${Math.max(4, Math.min(width, MAX_WIDTH))}px` }}
+                      aria-hidden="true"
+                    />
+                  </div>
+                )}
+              </div>
+            )}
+
+            <span className="presentation-sep" aria-hidden="true" />
+            <button
+              className="presentation-tool"
+              title="Undo last mark"
+              aria-label="Undo last mark"
+              disabled={strokes.length === 0}
+              onClick={undo}
+            >
+              ↶
+            </button>
+            <button
+              className="presentation-tool"
+              title="Clear all marks"
+              aria-label="Clear all marks"
+              disabled={strokes.length === 0}
+              onClick={clear}
+            >
+              🗑
+            </button>
+            <button
+              className="presentation-tool"
+              title="Close presentation tools"
+              aria-label="Close presentation tools"
+              onClick={() => {
+                setTool("off");
+                setOpen(false);
+              }}
+            >
+              ✕
+            </button>
+            <UntestedTag />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+/** Nearest ancestor of `el` that can actually scroll in the wheel's direction,
+ *  so a wheel forwarded through the capture surface moves the right container. */
+function findScrollable(el: Element | null, dx: number, dy: number): Element | null {
+  let node: Element | null = el;
+  while (node && node !== document.body && node !== document.documentElement) {
+    const st = getComputedStyle(node);
+    const scrollableY =
+      (st.overflowY === "auto" || st.overflowY === "scroll" || st.overflowY === "overlay") &&
+      node.scrollHeight > node.clientHeight;
+    const scrollableX =
+      (st.overflowX === "auto" || st.overflowX === "scroll" || st.overflowX === "overlay") &&
+      node.scrollWidth > node.clientWidth;
+    if ((dy !== 0 && scrollableY) || (dx !== 0 && scrollableX)) return node;
+    node = node.parentElement;
+  }
+  return null;
+}
+
+// ── Icons (inline SVG so no icon dependency is pulled in) ─────────────────────
+
+function PenIcon() {
+  return (
+    <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <path d="M12 19l7-7 3 3-7 7-3-3z" />
+      <path d="M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z" />
+      <path d="M2 2l7.586 7.586" />
+      <circle cx="11" cy="11" r="2" />
+    </svg>
+  );
+}
+
+function MarkerIcon() {
+  return (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <path d="M9 11l-6 6v3h3l6-6" />
+      <path d="M12 8l3 3" />
+      <path d="M17 3l4 4-8 8-4-4z" />
+    </svg>
+  );
+}
+
+function SlidersIcon() {
+  return (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <path d="M4 6h10M18 6h2M4 12h4M12 12h8M4 18h12M20 18h0" />
+      <circle cx="15" cy="6" r="2" fill="currentColor" />
+      <circle cx="9" cy="12" r="2" fill="currentColor" />
+      <circle cx="17" cy="18" r="2" fill="currentColor" />
+    </svg>
+  );
+}
+
+function LaserIcon() {
+  return (
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+      <circle cx="12" cy="12" r="3" fill="currentColor" stroke="none" />
+      <path d="M12 2v3M12 19v3M2 12h3M19 12h3M4.9 4.9l2.1 2.1M17 17l2.1 2.1M19.1 4.9L17 7M7 17l-2.1 2.1" />
+    </svg>
+  );
+}
diff --git a/src/components/embed/SqliteView.tsx b/src/components/embed/SqliteView.tsx
new file mode 100644
index 0000000..0887a4a
--- /dev/null
+++ b/src/components/embed/SqliteView.tsx
@@ -0,0 +1,317 @@
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { ViewerHeader } from "./FileViewerPane";
+
+/** One page of a table, mirroring the backend `SqlitePage` struct. */
+type SqlitePage = {
+  columns: string[];
+  rows: string[][];
+  total: number;
+};
+
+/** Page size for the row grid. */
+const PAGE_SIZE = 100;
+
+/**
+ * Read-only SQLite database browser (Dev C, frontend half). Lists the
+ * database's tables/views in a left rail and renders the selected table's rows
+ * in a paged, scrollable grid. Backend: `sqlite_tables(path)` and
+ * `sqlite_page(path, table, limit, offset)` in `src-tauri/src/commands/
+ * sqlite.rs`. All cells are React children (auto-escaped) — never raw HTML.
+ */
+export function SqliteView({
+  path,
+  onOpenExternally,
+  tabKey: _tabKey,
+}: {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  const [tables, setTables] = useState<string[] | null>(null);
+  const [tablesError, setTablesError] = useState<string | null>(null);
+  const [selected, setSelected] = useState<string | null>(null);
+  const [offset, setOffset] = useState(0);
+
+  const [page, setPage] = useState<SqlitePage | null>(null);
+  const [pageError, setPageError] = useState<string | null>(null);
+
+  // Load the table list on mount (and whenever the file changes); pick the
+  // first table by default.
+  useEffect(() => {
+    let cancelled = false;
+    setTables(null);
+    setTablesError(null);
+    setSelected(null);
+    setOffset(0);
+    invoke<string[]>("sqlite_tables", { path })
+      .then((names) => {
+        if (cancelled) return;
+        setTables(names);
+        setSelected(names.length > 0 ? names[0] : null);
+      })
+      .catch((e) => {
+        if (!cancelled) setTablesError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path]);
+
+  // Load the selected table's page whenever the table or offset changes.
+  useEffect(() => {
+    if (selected == null) {
+      setPage(null);
+      setPageError(null);
+      return;
+    }
+    let cancelled = false;
+    setPage(null);
+    setPageError(null);
+    invoke<SqlitePage>("sqlite_page", {
+      path,
+      table: selected,
+      limit: PAGE_SIZE,
+      offset,
+    })
+      .then((p) => {
+        if (!cancelled) setPage(p);
+      })
+      .catch((e) => {
+        if (!cancelled) setPageError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path, selected, offset]);
+
+  function selectTable(name: string) {
+    setSelected(name);
+    setOffset(0); // reset paging when switching tables
+  }
+
+  const total = page?.total ?? 0;
+  const rowCount = page?.rows.length ?? 0;
+  const firstRow = total === 0 ? 0 : offset + 1;
+  const lastRow = offset + rowCount;
+  const canPrev = offset > 0;
+  const canNext = offset + PAGE_SIZE < total;
+
+  return (
+    <div className="file-viewer">
+      <ViewerHeader onOpenExternally={onOpenExternally} />
+      <div
+        className="file-viewer-body"
+        style={{ display: "flex", overflow: "hidden", minHeight: 0 }}
+      >
+        {tablesError != null ? (
+          <div className="file-viewer-error" style={{ padding: "1rem", color: "#f85149" }}>
+            {tablesError}
+          </div>
+        ) : tables == null ? (
+          <div
+            className="file-viewer-loading"
+            style={{ padding: "1rem", color: "var(--text-secondary, #8b949e)" }}
+          >
+            Loading database…
+          </div>
+        ) : tables.length === 0 ? (
+          <div
+            className="file-viewer-empty"
+            style={{ padding: "1rem", color: "var(--text-secondary, #8b949e)" }}
+          >
+            No tables in this database.
+          </div>
+        ) : (
+          <>
+            {/* Left rail: table/view list. */}
+            <div
+              className="sqlite-rail"
+              style={{
+                flex: "0 0 auto",
+                width: "12em",
+                overflow: "auto",
+                borderRight: "1px solid var(--border-color)",
+                background: "var(--bg-panel)",
+              }}
+            >
+              {tables.map((name) => {
+                const active = name === selected;
+                return (
+                  <button
+                    key={name}
+                    className="sqlite-table-item"
+                    onClick={() => selectTable(name)}
+                    title={name}
+                    style={{
+                      display: "block",
+                      width: "100%",
+                      textAlign: "left",
+                      padding: "0.4em 0.75em",
+                      border: "none",
+                      cursor: "pointer",
+                      fontFamily: "var(--font-mono, ui-monospace, Menlo, Consolas, monospace)",
+                      fontSize: "12px",
+                      whiteSpace: "nowrap",
+                      overflow: "hidden",
+                      textOverflow: "ellipsis",
+                      background: active
+                        ? "var(--bg-elevated, rgba(255,255,255,0.08))"
+                        : "transparent",
+                      color: active
+                        ? "var(--text-primary)"
+                        : "var(--text-secondary, #8b949e)",
+                      fontWeight: active ? 600 : 400,
+                    }}
+                  >
+                    {name}
+                  </button>
+                );
+              })}
+            </div>
+
+            {/* Right: paged grid for the selected table. */}
+            <div
+              className="sqlite-grid-pane"
+              style={{
+                flex: "1 1 auto",
+                display: "flex",
+                flexDirection: "column",
+                minWidth: 0,
+                minHeight: 0,
+                background: "var(--bg-panel)",
+                color: "var(--text-primary)",
+              }}
+            >
+              {pageError != null ? (
+                <div
+                  className="sqlite-error"
+                  style={{ padding: "1rem", color: "#f85149" }}
+                >
+                  {pageError}
+                </div>
+              ) : page == null ? (
+                <div
+                  className="sqlite-loading"
+                  style={{ padding: "1rem", color: "var(--text-secondary, #8b949e)" }}
+                >
+                  Loading rows…
+                </div>
+              ) : (
+                <>
+                  {/* Scrollable grid. */}
+                  <div
+                    className="sqlite-grid"
+                    style={{
+                      flex: "1 1 auto",
+                      overflow: "auto",
+                      minHeight: 0,
+                      fontFamily:
+                        "var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace)",
+                      fontSize: "12px",
+                    }}
+                  >
+                    <table
+                      style={{
+                        borderCollapse: "collapse",
+                        width: "max-content",
+                        minWidth: "100%",
+                      }}
+                    >
+                      <thead>
+                        <tr>
+                          {page.columns.map((col, ci) => (
+                            <th
+                              key={ci}
+                              style={{
+                                position: "sticky",
+                                top: 0,
+                                textAlign: "left",
+                                padding: "0.35em 0.6em",
+                                background: "var(--bg-elevated, rgba(255,255,255,0.06))",
+                                borderBottom: "1px solid var(--border-color)",
+                                borderRight: "1px solid var(--border-color)",
+                                fontWeight: 600,
+                                whiteSpace: "nowrap",
+                              }}
+                            >
+                              {col}
+                            </th>
+                          ))}
+                        </tr>
+                      </thead>
+                      <tbody>
+                        {page.rows.map((row, ri) => (
+                          <tr key={ri}>
+                            {row.map((cell, ci) => (
+                              <td
+                                key={ci}
+                                style={{
+                                  padding: "0.3em 0.6em",
+                                  borderBottom: "1px solid var(--border-color)",
+                                  borderRight: "1px solid var(--border-color)",
+                                  whiteSpace: "pre",
+                                  verticalAlign: "top",
+                                }}
+                              >
+                                {cell}
+                              </td>
+                            ))}
+                          </tr>
+                        ))}
+                      </tbody>
+                    </table>
+                  </div>
+
+                  {/* Pager footer. */}
+                  <div
+                    className="sqlite-pager"
+                    style={{
+                      flex: "0 0 auto",
+                      display: "flex",
+                      alignItems: "center",
+                      gap: "0.75em",
+                      padding: "0.4em 0.75em",
+                      borderTop: "1px solid var(--border-color)",
+                      fontSize: "12px",
+                      color: "var(--text-secondary, #8b949e)",
+                    }}
+                  >
+                    <span>
+                      {total === 0
+                        ? "0 rows"
+                        : `rows ${firstRow}–${lastRow} of ${total}`}
+                    </span>
+                    <span style={{ flex: "1 1 auto" }} />
+                    <button
+                      onClick={() => setOffset((o) => Math.max(0, o - PAGE_SIZE))}
+                      disabled={!canPrev}
+                      style={{
+                        cursor: canPrev ? "pointer" : "default",
+                        opacity: canPrev ? 1 : 0.4,
+                      }}
+                    >
+                      ‹ Prev
+                    </button>
+                    <button
+                      onClick={() =>
+                        setOffset((o) => (o + PAGE_SIZE < total ? o + PAGE_SIZE : o))
+                      }
+                      disabled={!canNext}
+                      style={{
+                        cursor: canNext ? "pointer" : "default",
+                        opacity: canNext ? 1 : 0.4,
+                      }}
+                    >
+                      Next ›
+                    </button>
+                  </div>
+                </>
+              )}
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/SyncMergeView.tsx b/src/components/embed/SyncMergeView.tsx
new file mode 100644
index 0000000..b492e5c
--- /dev/null
+++ b/src/components/embed/SyncMergeView.tsx
@@ -0,0 +1,196 @@
+import { useEffect, useMemo, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { CompareView } from "./CompareView";
+import { useProjectsStore } from "../../stores/projects";
+import { useSyncStore } from "../../stores/sync";
+import { useTabsStore } from "../../stores/tabs";
+import { resolveProjectDirectory, resolveLocalMirror } from "../../types";
+import { relFromAbs } from "../../lib/viewers/fileUtils";
+
+/** Join a remote directory and a project-relative path with a single `/`
+ *  (POSIX — the host is always Unix here), tolerating a trailing slash on the
+ *  root and a leading one on the rel. */
+function joinRemote(root: string, rel: string): string {
+  return `${root.replace(/\/+$/, "")}/${rel.replace(/^\/+/, "")}`;
+}
+
+/**
+ * Three-way merge for a diverged (amber) file of a remote project — the PyCharm-
+ * style resolve view opened from the orange list. The left column is the local
+ * mirror copy, the right column is the current host copy, and the editable
+ * middle is the merged result with per-block take-left/right. "Resolve" writes
+ * the merged text to the mirror and force-pushes it to the host, so both sides
+ * converge and the file clears amber → green.
+ *
+ * `path` is the mirror-side absolute path (`mirrorRoot/rel`), exactly as the
+ * orange list builds it; the host path is derived from the project's
+ * `remote_path` and the same rel.
+ */
+export function SyncMergeView({
+  path,
+  projectId,
+  tabKey,
+}: {
+  path: string;
+  projectId: string | null;
+  tabKey?: string;
+}) {
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+
+  // Resolve the mirror root the same way FileViewerPane does, so `rel` keys the
+  // sync backend exactly like the orange list's own pull/push calls.
+  const { rel, hostPath } = useMemo(() => {
+    const projectDir = resolveProjectDirectory(project);
+    const mirrorRoot = resolveLocalMirror(project) ?? (projectDir ? `${projectDir}/mirror` : null);
+    const r = mirrorRoot ? relFromAbs(mirrorRoot, path) : null;
+    const remotePath = project?.remote?.remote_path;
+    return {
+      rel: r,
+      hostPath: r && remotePath ? joinRemote(remotePath, r) : null,
+    };
+  }, [project, path]);
+
+  const [localText, setLocalText] = useState<string | null>(null);
+  const [hostText, setHostText] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [applying, setApplying] = useState(false);
+  // Set when the on-open byte-for-byte test proved the two sides identical and
+  // self-resolved the divergence (re-recorded the base, cleared amber → green).
+  // The merge UI has nothing to merge in that case — we say so instead.
+  const [autoResolved, setAutoResolved] = useState(false);
+
+  // On open, run a byte-for-byte test on the backend (where the bytes live): an
+  // amber verdict is size+mtime-based, so a re-save with the same content or a
+  // bare `touch` flags a file whose bytes never diverged. `sync_resolve_if_identical`
+  // reads both sides, and if they match it re-records the base (no transfer) and
+  // returns true — the file clears amber → green with no user action. Only when it
+  // returns false (a genuine divergence) do we fall through to the three-way merge.
+  useEffect(() => {
+    if (!projectId || !rel) return;
+    let cancelled = false;
+    invoke<boolean>("sync_resolve_if_identical", { projectId, relPath: rel })
+      .then((resolved) => {
+        if (cancelled || !resolved) return;
+        setAutoResolved(true);
+        void useSyncStore.getState().refreshStatus(projectId);
+      })
+      .catch(() => {
+        // Best-effort: a cold pool / read error just leaves the merge viewer to
+        // handle the divergence the ordinary way.
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [projectId, rel]);
+
+  // Load both sides: the mirror over the local fs, the host over SFTP (both via
+  // `read_file_text`, which routes by whether the path is under the mirror).
+  useEffect(() => {
+    if (!hostPath) {
+      setError("This file is not part of a remote project's mirror.");
+      return;
+    }
+    let cancelled = false;
+    setError(null);
+    setLocalText(null);
+    setHostText(null);
+    Promise.all([
+      invoke<string>("read_file_text", { path, projectId }).catch(() => ""),
+      invoke<string>("read_file_text", { path: hostPath, projectId }),
+    ])
+      .then(([local, host]) => {
+        if (cancelled) return;
+        setLocalText(local);
+        setHostText(host);
+      })
+      .catch((e) => {
+        if (!cancelled) setError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [path, hostPath, projectId]);
+
+  const closeTab = () => {
+    if (tabKey) useTabsStore.getState().removeTab(tabKey);
+  };
+
+  const apply = (merged: string) => {
+    if (!projectId || !rel || applying) return;
+    setApplying(true);
+    setError(null);
+    // Write the merged result to the mirror, then force-push it to the host so
+    // both sides converge (the file clears amber). `push` refreshes sync status.
+    (async () => {
+      await invoke("write_file_text", { path, content: merged, projectId });
+      await useSyncStore.getState().push(projectId, rel, true);
+    })()
+      .then(() => closeTab())
+      .catch((e) => {
+        setError(String(e));
+        setApplying(false);
+      });
+  };
+
+  const loaded = localText != null && hostText != null;
+  // Divergence is judged on size+mtime vs the recorded base, never content, so an
+  // amber file can hold byte-identical sides (re-saved same content, touched, or a
+  // stale base). The authoritative signal is `autoResolved` — the backend's
+  // byte-for-byte test, which already cleared the amber marker. `identical` (a text
+  // compare) is the fallback for display before that test returns or if the pool is
+  // cold; either way, say so explicitly, else the empty diff reads as a broken viewer.
+  const identical = autoResolved || (loaded && localText === hostText);
+
+  if (error != null && !loaded) {
+    return (
+      <div style={{ position: "absolute", inset: 0 }}>
+        <div className="file-viewer-error" style={{ padding: "1rem" }}>{error}</div>
+      </div>
+    );
+  }
+  if (!loaded) {
+    return (
+      <div style={{ position: "absolute", inset: 0 }}>
+        <div className="file-viewer-loading" style={{ padding: "1rem" }}>Loading both sides…</div>
+      </div>
+    );
+  }
+
+  return (
+    <div style={{ position: "absolute", inset: 0, display: "flex", flexDirection: "column" }}>
+      {error != null && (
+        <div className="file-viewer-error" style={{ padding: "4px 8px", flex: "0 0 auto" }}>{error}</div>
+      )}
+      {identical && (
+        <div
+          className="file-viewer-loading"
+          style={{
+            flex: "0 0 auto",
+            padding: "6px 10px",
+            fontSize: "11px",
+            borderBottom: "1px solid var(--border-color)",
+            background: "var(--bg-elevated, rgba(255,255,255,0.04))",
+          }}
+        >
+          The mirror and host bytes are <strong>identical</strong> — this file was
+          flagged diverged only because its size/modified-time drifted from the
+          recorded sync base, not its content.{" "}
+          {autoResolved
+            ? "The divergence has been resolved automatically (the base was re-recorded and the amber marker cleared)."
+            : "“Resolve” just re-records the base and clears the amber marker."}
+        </div>
+      )}
+      <div style={{ flex: "1 1 auto", minHeight: 0, position: "relative" }}>
+        <CompareView
+          path={path}
+          left={{ text: localText, title: "Local (mirror)" }}
+          rightText={hostText}
+          rightTitle="Remote (host)"
+          applyLabel={applying ? "Resolving…" : "Resolve"}
+          onApply={apply}
+          onClose={closeTab}
+        />
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/TableView.tsx b/src/components/embed/TableView.tsx
new file mode 100644
index 0000000..a855f2d
--- /dev/null
+++ b/src/components/embed/TableView.tsx
@@ -0,0 +1,1218 @@
+import { useMemo, useState, useRef, useEffect, useCallback } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import {
+  ViewerHeader,
+  useViewerState,
+  useEditableFile,
+  SaveButton,
+  UndoRedoButtons,
+  ExternalChangeBanner,
+} from "./FileViewerPane";
+import { Dropdown } from "../common/Dropdown";
+import {
+  parseTable,
+  resolveDelimiter,
+  bodyRefs,
+  filterRefs,
+  sortRefs,
+  sortRefsByIndex,
+  replaceCell,
+  insertRowAfter,
+  deleteRow,
+  columnWidths,
+  DELIMITER_CANDIDATES,
+  type ParsedTable,
+} from "../../lib/viewers/table";
+
+/** Backend `read_spreadsheet` result (Dev G). Mirrors the Rust `SheetData`. */
+interface SheetData {
+  sheet_names: string[];
+  active_sheet: string;
+  rows: string[][];
+}
+
+/** Spreadsheet workbooks (xlsx/xls/xlsm) load via the backend `calamine` reader
+ *  instead of the CSV text path — and are read-only: they arrive already parsed,
+ *  with no source text for an edit to splice itself back into. */
+const SHEET_RE = /\.(xlsx|xls|xlsm)$/i;
+
+/** Fallback row height, in px, until a rendered row is measured (see `rowH`). */
+const DEFAULT_ROW_H = 26;
+/** Rows rendered beyond the viewport on each side, so a fast scroll stays fed. */
+const OVERSCAN = 8;
+/** Width of the row-number gutter, in px. */
+const GUTTER_W = 56;
+/** Horizontal padding of a body cell, in px — part of each column's box. */
+const CELL_PAD_X = 20;
+/** Smallest a column can be dragged to, in px — narrow enough to tuck a column
+ *  away, wide enough to keep its resize handle grabbable. */
+const MIN_COL_W = 32;
+/** The zebra tint for odd body rows: the panel's own text mixed a hair into the
+ *  panel, so it darkens on a light theme and lightens on a dark one, and stays
+ *  opaque (the sticky gutter must not let body cells bleed through — and an opaque
+ *  mix sidesteps the WebKitGTK translucent-color-mix caveat). */
+const STRIPE_BG = "color-mix(in srgb, var(--text-primary) 5%, var(--bg-panel))";
+/** The row-number gutter's own tint — a heavier mix than the zebra stripe so the
+ *  sticky column reads as chrome, distinct from the body cells that scroll under
+ *  it. Opaque, for the same sticky-bleed reason `STRIPE_BG` is. Paired with a
+ *  2px right border (`GUTTER_BORDER`) that stays visible during a horizontal
+ *  scroll. */
+const GUTTER_BG = "color-mix(in srgb, var(--text-primary) 12%, var(--bg-panel))";
+/** The gutter's right edge and the header's bottom edge: a heavier rule than the
+ *  1px cell grid, so the sticky chrome stays legible against the scrolling body. */
+const GUTTER_BORDER = "2px solid var(--border-color)";
+/** The header row's own background. It is the SOLID header tone, never the raw
+ *  `--bg-header` — that is a *gradient* in the fancy themes, so every `<th>`
+ *  would repaint the whole 3-stop ramp across its own width (a striped header),
+ *  and the sorted column's `color-mix` over it would be an invalid value, i.e.
+ *  a fully transparent header the scrolling body shows through. Sticky chrome
+ *  must be opaque. */
+const HEADER_BG = "var(--bg-header-solid, var(--bg-panel))";
+/** The active sort column reads as a distinct vertical band, not just a tinted
+ *  header — a strong accent header, an accent-tinted column body (kept light
+ *  enough that the zebra stripe still shows through it, so the two tints stack),
+ *  and 2px accent edge-lines drawn with an inset box-shadow so the band gains no
+ *  width and header/body stay column-aligned. Matches the system monitor's table
+ *  (`.sysmon-table th.sorted` / `td.sorted`). */
+const SORTED_HEADER_BG = "color-mix(in srgb, var(--accent) 30%, var(--bg-header-solid))";
+const SORTED_CELL_BG = "color-mix(in srgb, var(--accent) 8%, var(--bg-panel))";
+const SORTED_CELL_BG_STRIPE = "color-mix(in srgb, var(--accent) 15%, var(--bg-panel))";
+/** The accent edge-lines bracketing the sorted column, as an inset shadow so they
+ *  cost no layout width (a real border would desync the measured column widths). */
+const SORTED_EDGE = "inset 2px 0 0 var(--accent), inset -2px 0 0 var(--accent)";
+/** Sentinel `SortSpec.col` for the row-number gutter: it sorts on each row's
+ *  source index, not a cell value, so it needs a column id no real column has. */
+const GUTTER_SORT_COL = -1;
+
+/** The separator names offered in the header, keyed by the character itself. */
+const DELIMITER_LABELS: Record<string, string> = {
+  ",": "Comma",
+  ";": "Semicolon",
+  "\t": "Tab",
+  "|": "Pipe",
+};
+
+const KNOWN_DELIMITERS = new Set<string>(DELIMITER_CANDIDATES);
+
+/** How a separator reads in a menu — a tab has no glyph, so it needs a name. */
+function delimiterLabel(ch: string): string {
+  return DELIMITER_LABELS[ch] ?? `"${ch}"`;
+}
+
+interface SortSpec {
+  col: number;
+  dir: "asc" | "desc";
+}
+
+interface EditSpec {
+  /** Index into the parsed rows — `0` is the header row. */
+  row: number;
+  col: number;
+}
+
+const EMPTY_TABLE: ParsedTable = { rows: [], cells: [], rowSpans: [], newline: "\n" };
+
+/**
+ * In-app table viewer for delimited text (#40), and read-only for spreadsheet
+ * workbooks. Three things shape it:
+ *
+ *  - **The separator is a guess the reader can overrule.** `.csv` does not say
+ *    which character separates the columns, so it is sniffed from the content
+ *    (`resolveDelimiter`) and offered in the header — where a semicolon or pipe
+ *    file the sniffer misread gets corrected. An explicit choice is persisted per
+ *    tab; "Auto" is not, leaving the sniffer free to do better on the next open.
+ *
+ *  - **An edit is a splice, not a re-write.** Cell edits go through
+ *    `replaceCell`/`insertRowAfter`/`deleteRow` into the *text* draft that
+ *    `useEditableFile` already owns — the same draft the code editor would show.
+ *    So a table edit is an ordinary dirty/undoable/autosaved/Ctrl+S change, and
+ *    the cells nobody touched keep their bytes exactly (see `lib/viewers/table.ts`).
+ *    It is also why sorting and filtering carry each row's *source* index: what a
+ *    splice must address is the row a cell really came from, not the row it
+ *    happens to occupy on screen.
+ *
+ *  - **Only the visible rows are rendered.** A million-row CSV would otherwise
+ *    freeze the webview, so the body is windowed against the scroll position —
+ *    which is in turn why the column widths are measured over the whole file up
+ *    front: sizing them to what is on screen would resize every column as the
+ *    reader scrolled.
+ */
+export function TableView({
+  path,
+  onOpenExternally,
+  tabKey,
+}: {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+}) {
+  const isSheet = useMemo(() => SHEET_RE.test(path), [path]);
+
+  // The text draft behind a CSV/TSV. For a spreadsheet we don't edit the file at
+  // all; the hook still runs (hooks can't be conditional) but its content is
+  // ignored in favour of the backend's parsed rows.
+  const file = useEditableFile(path);
+  const {
+    content,
+    draft,
+    setDraft,
+    save,
+    isDirty,
+    saving,
+    saveError,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    externalChange,
+    reloadFromDisk,
+    keepMine,
+  } = file;
+
+  const viewPos = useViewerState(tabKey);
+
+  // ── Spreadsheet path: rows arrive pre-parsed from the backend ──────────────
+  const [sheetData, setSheetData] = useState<SheetData | null>(null);
+  const [sheetError, setSheetError] = useState<string | null>(null);
+  const [sheetLoaded, setSheetLoaded] = useState(false);
+  const [selectedSheet, setSelectedSheet] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!isSheet) return;
+    let cancelled = false;
+    setSheetLoaded(false);
+    setSheetError(null);
+    invoke<SheetData>("read_spreadsheet", { path, sheet: selectedSheet ?? undefined })
+      .then((data) => {
+        if (cancelled) return;
+        setSheetData(data);
+        // Adopt the sheet the backend actually returned (covers the default-pick).
+        setSelectedSheet((cur) => cur ?? data.active_sheet);
+        setSheetLoaded(true);
+      })
+      .catch((e) => {
+        if (cancelled) return;
+        setSheetError(String(e));
+        setSheetLoaded(true);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [isSheet, path, selectedSheet]);
+
+  const error = isSheet ? sheetError : file.error;
+  const loaded = isSheet ? sheetLoaded : file.loaded;
+  /** Spreadsheets have no source text to splice into, so they stay read-only. */
+  const editable = !isSheet && loaded && error == null;
+
+  // ── The separator ─────────────────────────────────────────────────────────
+  // Sniffed from what is on disk, not from the draft: re-sniffing mid-edit could
+  // change the delimiter under the reader as they type (blanking a row can flip
+  // the modal column count), and re-cut every column with it.
+  const sniffed = useMemo(
+    () => (content == null ? "," : resolveDelimiter(path, content)),
+    [path, content],
+  );
+
+  // `null` = auto. An override is seeded from the tab's persisted state, so the
+  // correction a reader made to a mis-sniffed file survives reopen and restart.
+  const [override, setOverride] = useState<string | null>(
+    () => viewPos.initial?.delimiter ?? null,
+  );
+  // Held apart from `override` so that a custom character which happens to be one
+  // of the offered ones doesn't silently snap the menu back off "Custom…".
+  const [customMode, setCustomMode] = useState<boolean>(() => {
+    const seed = viewPos.initial?.delimiter;
+    return seed != null && !KNOWN_DELIMITERS.has(seed);
+  });
+
+  const delimiter = override ?? sniffed;
+
+  // Persist the override, and only the override — "Auto" writes nothing, so the
+  // sniffer stays free to read the file better next time.
+  useEffect(() => {
+    viewPos.persist({ delimiter: override ?? undefined });
+  }, [override, viewPos]);
+
+  const onPickDelimiter = (choice: string) => {
+    if (choice === "auto") {
+      setCustomMode(false);
+      setOverride(null);
+    } else if (choice === "custom") {
+      setCustomMode(true);
+      setOverride(delimiter); // start from whatever is in force, so nothing jumps
+    } else {
+      setCustomMode(false);
+      setOverride(choice);
+    }
+  };
+
+  // ── The table ─────────────────────────────────────────────────────────────
+  const table = useMemo(
+    () => (isSheet ? EMPTY_TABLE : parseTable(draft, delimiter)),
+    [isSheet, draft, delimiter],
+  );
+  const rows = isSheet ? (sheetData?.rows ?? []) : table.rows;
+
+  const header = rows.length > 0 ? rows[0] : [];
+  // Width is the widest row, so ragged rows pad rather than truncate.
+  const width = useMemo(() => rows.reduce((m, r) => Math.max(m, r.length), 0), [rows]);
+  const widths = useMemo(() => columnWidths(rows, width), [rows, width]);
+
+  const [query, setQuery] = useState("");
+  const [sort, setSort] = useState<SortSpec | null>(null);
+
+  // ── Hidden columns ────────────────────────────────────────────────────────
+  const [hidden, setHidden] = useState<Set<number>>(
+    () => new Set(viewPos.initial?.hiddenColumns ?? []),
+  );
+
+  useEffect(() => {
+    viewPos.persist({
+      hiddenColumns: hidden.size > 0 ? [...hidden].sort((a, b) => a - b) : undefined,
+    });
+  }, [hidden, viewPos]);
+
+  // A hidden column is an *index*, and only the separator that produced it gives
+  // that index a meaning. Re-cut the row with a different one and index 3 is a
+  // different column — so a delimiter change drops the hiding rather than
+  // silently hiding whatever now lands there. The first delimiter seen after the
+  // file loads is not a change: it is the sniffer arriving, and it must not wipe
+  // the set the tab was restored with.
+  const settledDelimiter = useRef<string | null>(null);
+  useEffect(() => {
+    if (!loaded) return;
+    if (settledDelimiter.current == null) {
+      settledDelimiter.current = delimiter;
+      return;
+    }
+    if (settledDelimiter.current === delimiter) return;
+    settledDelimiter.current = delimiter;
+    setHidden(new Set());
+    setColWidths({});
+  }, [loaded, delimiter]);
+
+  const toggleColumn = (col: number) => {
+    setHidden((cur) => {
+      const next = new Set(cur);
+      if (next.has(col)) next.delete(col);
+      else next.add(col);
+      return next;
+    });
+  };
+
+  // ── Drag-resized column widths ──────────────────────────────────────────────
+  // A per-column pixel override, keyed by parsed-column index. Absent ⇒ the
+  // column keeps its measured `ch` width. Persisted per tab (like the hidden set)
+  // and, for the same reason, dropped when the delimiter changes below: the index
+  // means a different column once the row is cut with a different separator.
+  const [colWidths, setColWidths] = useState<Record<number, number>>(
+    () => viewPos.initial?.columnWidths ?? {},
+  );
+
+  useEffect(() => {
+    const has = Object.keys(colWidths).length > 0;
+    viewPos.persist({ columnWidths: has ? colWidths : undefined });
+  }, [colWidths, viewPos]);
+
+  // The live drag: which column, where the pointer started, and the width the
+  // column had then — measured off the real `<th>` so a first drag of an
+  // un-overridden (ch-sized) column starts from its rendered pixel width.
+  const resizing = useRef<{ col: number; startX: number; startW: number } | null>(null);
+
+  const startResize = (e: React.PointerEvent, col: number) => {
+    e.preventDefault();
+    e.stopPropagation(); // don't let the header read this as a sort click
+    const handle = e.currentTarget as HTMLElement;
+    const th = handle.parentElement as HTMLElement | null;
+    const startW = th?.offsetWidth ?? colWidths[col] ?? MIN_COL_W;
+    resizing.current = { col, startX: e.clientX, startW };
+    handle.setPointerCapture(e.pointerId);
+  };
+
+  const onResizeMove = (e: React.PointerEvent) => {
+    const r = resizing.current;
+    if (!r) return;
+    const next = Math.max(MIN_COL_W, Math.round(r.startW + (e.clientX - r.startX)));
+    setColWidths((cur) => (cur[r.col] === next ? cur : { ...cur, [r.col]: next }));
+  };
+
+  const endResize = (e: React.PointerEvent) => {
+    if (!resizing.current) return;
+    resizing.current = null;
+    try {
+      (e.currentTarget as HTMLElement).releasePointerCapture(e.pointerId);
+    } catch {
+      /* pointer already released */
+    }
+  };
+
+  // Double-click the handle to drop the override and return the column to its
+  // measured (auto-fit) width.
+  const resetWidth = (col: number) => {
+    setColWidths((cur) => {
+      if (cur[col] == null) return cur;
+      const next = { ...cur };
+      delete next[col];
+      return next;
+    });
+  };
+
+  /** The columns actually rendered, as indices into the *parsed* row — never
+   *  re-numbered, so an edit still addresses the column the cell came from. */
+  const cols = useMemo(
+    () => Array.from({ length: width }, (_, i) => i).filter((c) => !hidden.has(c)),
+    [width, hidden],
+  );
+
+  // ── Flash rows gained on a disk reload ──────────────────────────────────────
+  // `content` changes only on a (re)load from disk, never on an in-app keystroke
+  // (edits move `draft`, not `content`) — so a CSV appended to underneath the
+  // viewer re-reads here, and we briefly highlight whichever body rows weren't
+  // there before. The comparison keys on `content` alone: sorting, filtering and
+  // delimiter changes all leave it untouched, so none of them flash. The first
+  // load (and every path switch, when `content` resets to null) only seeds the
+  // baseline. Rows are matched by value as a multiset, so an unchanged row that
+  // merely slid down when an earlier row was inserted is not counted as new.
+  const [flashRows, setFlashRows] = useState<Set<number>>(new Set());
+  const prevSigsRef = useRef<Map<string, number> | null>(null);
+  const flashTimers = useRef<number[]>([]);
+  const rowsRef = useRef(rows);
+  rowsRef.current = rows;
+
+  useEffect(() => {
+    if (isSheet) return;
+    if (content == null) {
+      prevSigsRef.current = null;
+      return;
+    }
+    const bodyRows = rowsRef.current.slice(1);
+    const counts = new Map<string, number>();
+    for (const cells of bodyRows) {
+      const sig = JSON.stringify(cells);
+      counts.set(sig, (counts.get(sig) ?? 0) + 1);
+    }
+    const prev = prevSigsRef.current;
+    prevSigsRef.current = counts;
+    if (prev == null) return; // first settled content: seed only, don't flash
+
+    const remaining = new Map(prev);
+    const added = new Set<number>();
+    bodyRows.forEach((cells, i) => {
+      const sig = JSON.stringify(cells);
+      const left = remaining.get(sig) ?? 0;
+      if (left > 0) remaining.set(sig, left - 1);
+      else added.add(i + 1); // +1: source index, past the header at 0
+    });
+    if (added.size === 0) return;
+
+    setFlashRows((cur) => new Set([...cur, ...added]));
+    const timer = window.setTimeout(() => {
+      setFlashRows((cur) => {
+        const next = new Set(cur);
+        for (const idx of added) next.delete(idx);
+        return next;
+      });
+    }, 3000);
+    flashTimers.current.push(timer);
+  }, [content, isSheet]);
+
+  useEffect(() => () => flashTimers.current.forEach((t) => clearTimeout(t)), []);
+
+  const body = useMemo(() => bodyRefs(rows), [rows]);
+  // Filtering follows the eye: a row matched on a hidden column would show up with
+  // nothing on it to explain why.
+  const filtered = useMemo(() => filterRefs(body, query, cols), [body, query, cols]);
+  const visible = useMemo(() => {
+    if (!sort) return filtered;
+    if (sort.col === GUTTER_SORT_COL) return sortRefsByIndex(filtered, sort.dir);
+    return sortRefs(filtered, sort.col, sort.dir);
+  }, [filtered, sort]);
+
+  // ── Windowing ─────────────────────────────────────────────────────────────
+  const scrollRef = useRef<HTMLDivElement | null>(null);
+  const [scrollTop, setScrollTop] = useState(0);
+  const [viewportH, setViewportH] = useState(600);
+  const [rowH, setRowH] = useState(DEFAULT_ROW_H);
+  const restored = useRef(false);
+  const persistTimer = useRef<number | null>(null);
+  const scrollFrame = useRef<number | null>(null);
+
+  // Measure a rendered row rather than trusting the CSS to add up: the window's
+  // arithmetic is only right if this height is the one actually on screen.
+  const measureRow = useCallback(
+    (el: HTMLTableRowElement | null) => {
+      if (!el) return;
+      const h = el.offsetHeight;
+      if (h > 0 && h !== rowH) setRowH(h);
+    },
+    [rowH],
+  );
+
+  const total = visible.length;
+  const firstRow = Math.max(0, Math.floor(scrollTop / rowH) - OVERSCAN);
+  const lastRow = Math.min(total, Math.ceil((scrollTop + viewportH) / rowH) + OVERSCAN);
+  const rendered = visible.slice(firstRow, lastRow);
+  const padTop = firstRow * rowH;
+  const padBottom = Math.max(0, (total - lastRow) * rowH);
+
+  const onScroll = () => {
+    const el = scrollRef.current;
+    if (!el) return;
+    const top = el.scrollTop;
+    // Coalesce to a frame: scroll fires far faster than we can usefully re-window.
+    if (scrollFrame.current == null) {
+      scrollFrame.current = requestAnimationFrame(() => {
+        scrollFrame.current = null;
+        setScrollTop(scrollRef.current?.scrollTop ?? top);
+      });
+    }
+    if (!restored.current) return;
+    if (persistTimer.current != null) clearTimeout(persistTimer.current);
+    persistTimer.current = window.setTimeout(() => viewPos.persist({ scrollTop: top }), 200);
+  };
+
+  const onScrollRef = (el: HTMLDivElement | null) => {
+    scrollRef.current = el;
+    if (!el) return;
+    if (!restored.current && loaded) {
+      restored.current = true;
+      const top = viewPos.initial?.scrollTop;
+      if (top && top > 0) {
+        el.scrollTop = top;
+        setScrollTop(top);
+      }
+    }
+  };
+
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => setViewportH(el.clientHeight));
+    ro.observe(el);
+    setViewportH(el.clientHeight);
+    return () => ro.disconnect();
+  }, [loaded]);
+
+  useEffect(
+    () => () => {
+      if (scrollFrame.current != null) cancelAnimationFrame(scrollFrame.current);
+      if (persistTimer.current != null) clearTimeout(persistTimer.current);
+    },
+    [],
+  );
+
+  // ── Editing ───────────────────────────────────────────────────────────────
+  const [editing, setEditing] = useState<EditSpec | null>(null);
+  const [editValue, setEditValue] = useState("");
+
+  const beginEdit = (row: number, col: number) => {
+    if (!editable) return;
+    setEditing({ row, col });
+    setEditValue(rows[row]?.[col] ?? "");
+  };
+
+  const commitEdit = (next?: "right") => {
+    if (!editing) return;
+    const { row, col } = editing;
+    if (editValue !== (rows[row]?.[col] ?? "")) {
+      setDraft(replaceCell(draft, table, row, col, editValue, delimiter));
+    }
+    // Tab walks to the next *visible* column — a hidden one has no cell on screen
+    // to put the cursor in. Its value is untouched by the splice just made, so it
+    // can be read from the current parse without waiting for the re-parse.
+    if (next === "right") {
+      const right = cols[cols.indexOf(col) + 1];
+      if (right != null) {
+        setEditing({ row, col: right });
+        setEditValue(rows[row]?.[right] ?? "");
+        return;
+      }
+    }
+    setEditing(null);
+  };
+
+  const onEditKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      commitEdit();
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      setEditing(null);
+    } else if (e.key === "Tab") {
+      e.preventDefault();
+      commitEdit("right");
+    }
+  };
+
+  const addRow = () => {
+    if (!editable || rows.length === 0) return;
+    setDraft(insertRowAfter(draft, table, rows.length - 1, width, delimiter));
+  };
+
+  const removeRow = (row: number) => {
+    if (!editable) return;
+    setEditing(null);
+    setDraft(deleteRow(draft, table, row));
+  };
+
+  // A single click on a header sorts, a double click renames it — so when the file
+  // is editable the sort waits long enough to find out which it was. A read-only
+  // sheet has no second meaning to disambiguate, so it sorts immediately.
+  const sortClick = useRef<number | null>(null);
+
+  // asc → desc → default: the third click clears the sort, which is the only
+  // way back to the file's own row order once a column has been sorted.
+  const toggleSort = (col: number) => {
+    setSort((cur) => {
+      if (!cur || cur.col !== col) return { col, dir: "asc" };
+      if (cur.dir === "asc") return { col, dir: "desc" };
+      return null;
+    });
+  };
+
+  // The gutter has no second meaning to disambiguate (no rename, no double-click),
+  // so it sorts immediately — asc restores the file's row order, desc reverses it.
+  const onGutterClick = () => toggleSort(GUTTER_SORT_COL);
+
+  const onHeaderClick = (col: number) => {
+    if (!editable) {
+      toggleSort(col);
+      return;
+    }
+    if (sortClick.current != null) return;
+    sortClick.current = window.setTimeout(() => {
+      sortClick.current = null;
+      toggleSort(col);
+    }, 200);
+  };
+
+  const onHeaderDoubleClick = (col: number) => {
+    if (sortClick.current != null) {
+      clearTimeout(sortClick.current);
+      sortClick.current = null;
+    }
+    beginEdit(0, col);
+  };
+
+  const onKeyDown = (e: React.KeyboardEvent) => {
+    if (!editable) return;
+    const mod = e.ctrlKey || e.metaKey;
+    if (!mod) return;
+    const key = e.key.toLowerCase();
+    if (key === "s") {
+      e.preventDefault();
+      void save();
+    } else if (editing == null && key === "z") {
+      // While a cell input is open, ctrl+z belongs to that input's own text.
+      e.preventDefault();
+      if (e.shiftKey) redo();
+      else undo();
+    } else if (editing == null && key === "y") {
+      e.preventDefault();
+      redo();
+    }
+  };
+
+  const gutterSorted = sort?.col === GUTTER_SORT_COL;
+
+  // A column's CSS width: its drag override in px when it has one, else its
+  // measured `ch` count plus the cell padding.
+  const colWidthStyle = (c: number) =>
+    colWidths[c] != null ? `${colWidths[c]}px` : `calc(${widths[c]}ch + ${CELL_PAD_X}px)`;
+
+  // The table's total width mixes the two unit systems: sum the overridden
+  // columns' px straight, and the rest as `ch` + their padding.
+  const naturalCh = cols.reduce((sum, c) => (colWidths[c] != null ? sum : sum + widths[c]), 0);
+  const overridePx = cols.reduce(
+    (sum, c) => sum + (colWidths[c] != null ? colWidths[c] : CELL_PAD_X),
+    GUTTER_W,
+  );
+  const tableWidth = `calc(${naturalCh}ch + ${overridePx}px)`;
+
+  /** The names shown in the columns menu — a column with a blank header still
+   *  needs something to click on. */
+  const columnNames = useMemo(
+    () =>
+      Array.from({ length: width }, (_, c) => {
+        const name = header[c] ?? "";
+        return name.trim() === "" ? `Column ${c + 1}` : name;
+      }),
+    [width, header],
+  );
+
+  const countLabel =
+    query.trim() !== ""
+      ? `${visible.length} of ${body.length} rows`
+      : `${body.length} ${body.length === 1 ? "row" : "rows"}`;
+
+  return (
+    <div
+      className="file-viewer"
+      style={{ display: "flex", flexDirection: "column", height: "100%" }}
+      onKeyDown={onKeyDown}
+    >
+      <ViewerHeader onOpenExternally={onOpenExternally}>
+        {isSheet && sheetData && sheetData.sheet_names.length > 1 && (
+          <Dropdown
+            value={selectedSheet ?? sheetData.active_sheet}
+            onChange={setSelectedSheet}
+            title="Select sheet"
+            options={sheetData.sheet_names.map((name) => ({ value: name, label: name }))}
+          />
+        )}
+        {!isSheet && loaded && !error && (
+          <>
+            <Dropdown
+              value={customMode ? "custom" : (override ?? "auto")}
+              onChange={onPickDelimiter}
+              title="Column separator"
+              options={[
+                { value: "auto", label: `Auto (${delimiterLabel(sniffed)})` },
+                ...DELIMITER_CANDIDATES.map((d) => ({ value: d, label: delimiterLabel(d) })),
+                { value: "custom", label: "Custom…" },
+              ]}
+            />
+            {customMode && (
+              <input
+                value={override ?? ""}
+                onChange={(e) => {
+                  // Take the last character typed, so typing over a filled box
+                  // swaps the separator instead of being swallowed.
+                  const ch = e.target.value.slice(-1);
+                  if (ch) setOverride(ch);
+                }}
+                title="Separator character"
+                aria-label="Separator character"
+                style={{
+                  width: 28,
+                  textAlign: "center",
+                  padding: "2px 4px",
+                  background: "var(--bg-input, var(--bg-panel))",
+                  color: "var(--text-primary)",
+                  border: "1px solid var(--border-color)",
+                  borderRadius: "var(--radius-sm)",
+                  fontFamily: "var(--font-mono, monospace)",
+                }}
+              />
+            )}
+          </>
+        )}
+        {loaded && !error && width > 0 && (
+          <ColumnsMenu
+            names={columnNames}
+            hidden={hidden}
+            onToggle={toggleColumn}
+            onShowAll={() => setHidden(new Set())}
+            onHideAll={() => setHidden(new Set(Array.from({ length: width }, (_, i) => i)))}
+          />
+        )}
+        {loaded && !error && (
+          <input
+            value={query}
+            onChange={(e) => setQuery(e.target.value)}
+            placeholder="Filter rows…"
+            aria-label="Filter rows"
+            style={{
+              width: 140,
+              padding: "2px 6px",
+              background: "var(--bg-input, var(--bg-panel))",
+              color: "var(--text-primary)",
+              border: "1px solid var(--border-color)",
+              borderRadius: "var(--radius-sm)",
+            }}
+          />
+        )}
+        {loaded && !error && (
+          <span
+            style={{
+              fontSize: 12,
+              color: "var(--text-secondary, var(--text-primary))",
+              opacity: 0.7,
+              alignSelf: "center",
+              whiteSpace: "nowrap",
+            }}
+          >
+            {countLabel}
+          </span>
+        )}
+        {editable && (
+          <button
+            onClick={addRow}
+            title="Append a row"
+            style={{
+              all: "unset",
+              cursor: "pointer",
+              padding: "2px 8px",
+              borderRadius: "var(--radius-sm)",
+              fontSize: 12,
+              color: "var(--text-primary)",
+              border: "1px solid var(--border-color)",
+            }}
+          >
+            + Row
+          </button>
+        )}
+        {editable && (
+          <UndoRedoButtons undo={undo} redo={redo} canUndo={canUndo} canRedo={canRedo} />
+        )}
+        {editable && <SaveButton isDirty={isDirty} saving={saving} save={() => void save()} />}
+      </ViewerHeader>
+      {!isSheet && externalChange && (
+        <ExternalChangeBanner onReload={reloadFromDisk} onKeep={keepMine} />
+      )}
+      {!isSheet && saveError && <div className="file-viewer-error">{saveError}</div>}
+      {error != null ? (
+        <div className="file-viewer-error">{error}</div>
+      ) : !loaded ? (
+        <div className="file-viewer-loading">Loading…</div>
+      ) : header.length === 0 ? (
+        <div className="file-viewer-loading">Empty file</div>
+      ) : (
+        <div
+          ref={onScrollRef}
+          onScroll={onScroll}
+          tabIndex={0}
+          style={{
+            flex: 1,
+            minHeight: 0,
+            overflow: "auto",
+            outline: "none",
+            background: "var(--bg-panel)",
+            color: "var(--text-primary)",
+          }}
+        >
+          <table
+            style={{
+              borderCollapse: "collapse",
+              tableLayout: "fixed",
+              fontSize: 13,
+              fontFamily: "var(--font-mono, monospace)",
+              width: tableWidth,
+              minWidth: "100%",
+            }}
+          >
+            <colgroup>
+              <col style={{ width: GUTTER_W }} />
+              {cols.map((c) => (
+                <col key={c} style={{ width: colWidthStyle(c) }} />
+              ))}
+            </colgroup>
+            <thead>
+              <tr>
+                {/* The gutter's header holds the corner while both the header row
+                    and the gutter column are stuck to their edges — and it sorts
+                    by row order: click to restore the file's order, again to
+                    reverse it. */}
+                <th
+                  style={{
+                    position: "sticky",
+                    top: 0,
+                    left: 0,
+                    zIndex: 2,
+                    background: gutterSorted ? SORTED_HEADER_BG : HEADER_BG,
+                    borderBottom: "1px solid var(--border-color)",
+                    borderRight: GUTTER_BORDER,
+                    padding: 0,
+                  }}
+                >
+                  <button
+                    onClick={onGutterClick}
+                    title={
+                      gutterSorted
+                        ? "Row order — click to reverse, again to clear"
+                        : "Sort by row order (restore the file's order)"
+                    }
+                    aria-label="Sort by row order"
+                    style={{
+                      all: "unset",
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "center",
+                      gap: 3,
+                      width: "100%",
+                      boxSizing: "border-box",
+                      padding: "5px 6px",
+                      cursor: "pointer",
+                      userSelect: "none",
+                      fontSize: 11,
+                      fontWeight: gutterSorted ? 700 : 600,
+                      color: gutterSorted ? "var(--text-primary)" : "var(--text-secondary)",
+                    }}
+                  >
+                    <span aria-hidden="true">#</span>
+                    {gutterSorted && (
+                      <span style={{ color: "var(--accent)", fontWeight: 700 }}>
+                        {sort!.dir === "asc" ? "▲" : "▼"}
+                      </span>
+                    )}
+                  </button>
+                </th>
+                {cols.map((c) => {
+                  const active = sort?.col === c;
+                  const isEditing = editing?.row === 0 && editing.col === c;
+                  return (
+                    <th
+                      key={c}
+                      style={{
+                        position: "sticky",
+                        top: 0,
+                        zIndex: 1,
+                        background: active ? SORTED_HEADER_BG : HEADER_BG,
+                        boxShadow: active ? SORTED_EDGE : undefined,
+                        borderBottom: "1px solid var(--border-color)",
+                        borderRight: "1px solid var(--border-color)",
+                        padding: 0,
+                        textAlign: "left",
+                        whiteSpace: "nowrap",
+                      }}
+                    >
+                      {isEditing ? (
+                        <CellInput
+                          value={editValue}
+                          onChange={setEditValue}
+                          onKeyDown={onEditKeyDown}
+                          onBlur={() => commitEdit()}
+                        />
+                      ) : (
+                        <button
+                          onClick={() => onHeaderClick(c)}
+                          onDoubleClick={() => onHeaderDoubleClick(c)}
+                          title={
+                            editable
+                              ? "Sort by this column — double-click to rename"
+                              : "Sort by this column"
+                          }
+                          style={{
+                            all: "unset",
+                            display: "flex",
+                            alignItems: "center",
+                            gap: 4,
+                            width: "100%",
+                            boxSizing: "border-box",
+                            padding: "5px 10px",
+                            cursor: "pointer",
+                            userSelect: "none",
+                            fontWeight: active ? 700 : 600,
+                            color: active ? "var(--text-primary)" : "var(--text-secondary)",
+                          }}
+                        >
+                          <span
+                            style={{
+                              overflow: "hidden",
+                              textOverflow: "ellipsis",
+                              whiteSpace: "nowrap",
+                            }}
+                          >
+                            {header[c] ?? ""}
+                            {active && (
+                              <span style={{ color: "var(--accent)", fontWeight: 700 }}>
+                                {sort!.dir === "asc" ? " ▲" : " ▼"}
+                              </span>
+                            )}
+                          </span>
+                        </button>
+                      )}
+                      {/* The drag-to-resize grip on the column's right edge. It sits
+                          over the sort button (which is why its pointer handlers
+                          stop propagation), captures the pointer so the drag keeps
+                          tracking past the thin grip, and double-clicks back to the
+                          measured width. */}
+                      <div
+                        onPointerDown={(e) => startResize(e, c)}
+                        onPointerMove={onResizeMove}
+                        onPointerUp={endResize}
+                        onDoubleClick={(e) => {
+                          e.stopPropagation();
+                          resetWidth(c);
+                        }}
+                        title="Drag to resize · double-click to auto-fit"
+                        aria-hidden="true"
+                        style={{
+                          position: "absolute",
+                          top: 0,
+                          right: 0,
+                          width: 7,
+                          height: "100%",
+                          cursor: "col-resize",
+                          zIndex: 3,
+                          touchAction: "none",
+                          userSelect: "none",
+                        }}
+                      />
+                    </th>
+                  );
+                })}
+              </tr>
+            </thead>
+            <tbody>
+              {padTop > 0 && (
+                <tr style={{ height: padTop }} aria-hidden="true">
+                  <td colSpan={cols.length + 1} style={{ padding: 0, border: "none" }} />
+                </tr>
+              )}
+              {rendered.map((row, i) => {
+                // Zebra stripe by on-screen position (not source index), so rows
+                // stay alternating after a sort or filter reorders them.
+                const stripeBg = (firstRow + i) % 2 === 1 ? STRIPE_BG : undefined;
+                return (
+                <tr
+                  key={row.index}
+                  ref={i === 0 ? measureRow : undefined}
+                  className={flashRows.has(row.index) ? "csv-row-flash" : undefined}
+                  style={{ height: rowH }}
+                >
+                  <td
+                    style={{
+                      position: "sticky",
+                      left: 0,
+                      zIndex: 1,
+                      // Its own chrome tint, not the zebra stripe, so the sticky
+                      // column stays distinct from the body scrolling under it.
+                      background: GUTTER_BG,
+                      borderBottom: "1px solid var(--border-color)",
+                      borderRight: GUTTER_BORDER,
+                      padding: "4px 8px",
+                      textAlign: "right",
+                      whiteSpace: "nowrap",
+                      fontSize: 11,
+                      // Opacity dims only the number, not the cell — a translucent
+                      // sticky gutter would let the scrolling body cells bleed
+                      // through it. The background stays solid.
+                      color: "var(--text-secondary, var(--text-primary))",
+                    }}
+                  >
+                    {/* The source row number, not the position on screen: it is the
+                        row a sort or filter came from, and the row an edit lands in. */}
+                    {editable ? (
+                      <span style={{ display: "flex", gap: 6, justifyContent: "flex-end" }}>
+                        <span>{row.index}</span>
+                        <button
+                          onClick={() => removeRow(row.index)}
+                          title={`Delete row ${row.index}`}
+                          aria-label={`Delete row ${row.index}`}
+                          style={{
+                            all: "unset",
+                            cursor: "pointer",
+                            padding: "0 2px",
+                            color: "var(--text-primary)",
+                          }}
+                        >
+                          ×
+                        </button>
+                      </span>
+                    ) : (
+                      row.index
+                    )}
+                  </td>
+                  {cols.map((c) => {
+                    const isEditing = editing?.row === row.index && editing.col === c;
+                    const value = row.cells[c] ?? "";
+                    // The sorted column carries its own accent tint (stacked over
+                    // the zebra stripe) and the accent edge-lines, so it reads as
+                    // one continuous band down the table, not just a tinted header.
+                    const sortedCol = sort?.col === c;
+                    const cellBg = sortedCol
+                      ? stripeBg
+                        ? SORTED_CELL_BG_STRIPE
+                        : SORTED_CELL_BG
+                      : stripeBg;
+                    return (
+                      <td
+                        key={c}
+                        onDoubleClick={() => beginEdit(row.index, c)}
+                        // A column clips at its measured width, so the full value
+                        // has to stay reachable somewhere.
+                        title={isEditing ? undefined : value}
+                        style={{
+                          background: cellBg,
+                          boxShadow: sortedCol ? SORTED_EDGE : undefined,
+                          borderBottom: "1px solid var(--border-color)",
+                          borderRight: "1px solid var(--border-color)",
+                          padding: isEditing ? 0 : "4px 10px",
+                          // `pre`, not `nowrap`: a padded field's spaces are part
+                          // of its value. It still clips-with-ellipsis, since that
+                          // only needs overflow hidden and no wrapping.
+                          whiteSpace: "pre",
+                          overflow: "hidden",
+                          textOverflow: "ellipsis",
+                          verticalAlign: "middle",
+                          cursor: editable ? "text" : "default",
+                        }}
+                      >
+                        {isEditing ? (
+                          <CellInput
+                            value={editValue}
+                            onChange={setEditValue}
+                            onKeyDown={onEditKeyDown}
+                            onBlur={() => commitEdit()}
+                          />
+                        ) : (
+                          value
+                        )}
+                      </td>
+                    );
+                  })}
+                </tr>
+                );
+              })}
+              {padBottom > 0 && (
+                <tr style={{ height: padBottom }} aria-hidden="true">
+                  <td colSpan={cols.length + 1} style={{ padding: 0, border: "none" }} />
+                </tr>
+              )}
+            </tbody>
+          </table>
+          {total === 0 && body.length > 0 && (
+            <div style={{ padding: "8px 10px", fontSize: 12, opacity: 0.7 }}>
+              No rows match “{query}”.
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/**
+ * The column list: every column by name, click to hide, click again to show.
+ *
+ * Built on the same chrome as {@link Dropdown} (whose native `<select>` WebKitGTK
+ * refuses to theme) but it is a *multi*-select, so it does NOT close on a click —
+ * hiding six of twenty columns is one visit to the menu, not six. A hidden column
+ * stays listed, struck through: the list is the only way back, so a column that
+ * vanished from it would be a column you could not get back.
+ */
+function ColumnsMenu({
+  names,
+  hidden,
+  onToggle,
+  onShowAll,
+  onHideAll,
+}: {
+  names: string[];
+  hidden: Set<number>;
+  onToggle: (col: number) => void;
+  onShowAll: () => void;
+  onHideAll: () => void;
+}) {
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    const onDocPointer = (e: PointerEvent) => {
+      if (ref.current && !ref.current.contains(e.target as Node)) setOpen(false);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setOpen(false);
+    };
+    document.addEventListener("pointerdown", onDocPointer);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("pointerdown", onDocPointer);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+
+  const shown = names.length - hidden.size;
+
+  return (
+    <div className="dropdown" ref={ref} onMouseDown={(e) => e.stopPropagation()}>
+      <button
+        type="button"
+        className="dropdown-trigger"
+        onClick={() => setOpen((v) => !v)}
+        title="Show or hide columns"
+        aria-haspopup="listbox"
+        aria-expanded={open}
+      >
+        {hidden.size > 0 ? `Columns ${shown}/${names.length}` : "Columns"}
+        <span className="dropdown-caret">▾</span>
+      </button>
+      {open && (
+        <div className="context-menu dropdown-menu" role="listbox" aria-multiselectable>
+          {/* Whole-set toggle: with all columns shown it deselects everything —
+              picking three of twenty is "deselect all, click three", not
+              seventeen hides — and once anything is hidden it selects all. */}
+          <button
+            type="button"
+            onClick={hidden.size > 0 ? onShowAll : onHideAll}
+            style={{ borderBottom: "1px solid var(--border-color)" }}
+          >
+            <span aria-hidden="true" style={{ display: "inline-block", width: 16, opacity: 0.9 }}>
+              {hidden.size > 0 ? "✓" : "–"}
+            </span>
+            {hidden.size > 0 ? "Select all" : "Deselect all"}
+          </button>
+          {names.map((name, c) => {
+            const isHidden = hidden.has(c);
+            return (
+              <button
+                key={c}
+                type="button"
+                role="option"
+                aria-selected={!isHidden}
+                onClick={() => onToggle(c)}
+                title={isHidden ? "Click to show this column" : "Click to hide this column"}
+              >
+                <span
+                  aria-hidden="true"
+                  style={{
+                    display: "inline-block",
+                    width: 16,
+                    opacity: isHidden ? 0.45 : 0.9,
+                  }}
+                >
+                  {isHidden ? "–" : "✓"}
+                </span>
+                <span
+                  style={{
+                    textDecoration: isHidden ? "line-through" : "none",
+                    opacity: isHidden ? 0.55 : 1,
+                  }}
+                >
+                  {name}
+                </span>
+              </button>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/** The in-cell editor: one input, sized to the cell it stands in for. */
+function CellInput({
+  value,
+  onChange,
+  onKeyDown,
+  onBlur,
+}: {
+  value: string;
+  onChange: (v: string) => void;
+  onKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+  onBlur: () => void;
+}) {
+  return (
+    <input
+      autoFocus
+      value={value}
+      onChange={(e) => onChange(e.target.value)}
+      onKeyDown={onKeyDown}
+      onBlur={onBlur}
+      style={{
+        width: "100%",
+        boxSizing: "border-box",
+        padding: "4px 10px",
+        border: "none",
+        outline: "2px solid var(--accent-color, #6ab)",
+        outlineOffset: -2,
+        background: "var(--bg-input, var(--bg-panel))",
+        color: "var(--text-primary)",
+        font: "inherit",
+      }}
+    />
+  );
+}
diff --git a/src/components/embed/YamlGrid.tsx b/src/components/embed/YamlGrid.tsx
new file mode 100644
index 0000000..2b18920
--- /dev/null
+++ b/src/components/embed/YamlGrid.tsx
@@ -0,0 +1,780 @@
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+  type CSSProperties,
+} from "react";
+import { useViewerState } from "./FileViewerPane";
+import { UntestedTag } from "../common/UntestedTag";
+import {
+  addChild,
+  deleteNode,
+  duplicateNode,
+  isFlow,
+  literalFor,
+  moveNodeTo,
+  parseYaml,
+  scalarType,
+  setValue,
+  type YamlDoc,
+  type YamlNode,
+} from "../../lib/viewers/yaml";
+import { cellKind, isContainer } from "../../lib/viewers/yamlGrid";
+
+/**
+ * The YAML/JSON **card grid** (#yaml-grid) — the third view on the file, beside the
+ * tree and Source, for reading structured data as cards.
+ *
+ * It is a **drill navigation**, not an infinite nest. At any moment one card is the
+ * "main" one, and the grid shows:
+ *   - a **breadcrumb** of the path from the document down to it,
+ *   - the main card's **level** — a grid of its siblings, the main one highlighted —
+ *     so you can step sideways between records without going up first,
+ *   - the main card's **children** as the next level below, to drill deeper.
+ * Clicking any card opens it as the new main; clicking a breadcrumb crumb (or the
+ * ⌂ overview) walks back up. With nothing focused the grid is the top overview: the
+ * document's own top-level cards.
+ *
+ * A card shows only its **scalar fields**; its nested collections are the next
+ * level, reached by clicking — so a card never grows unbounded. Every card in one
+ * level is given the SAME height (measured to the tallest, capped), and a card with
+ * more fields than fit **scrolls inside itself** rather than stretching the row.
+ *
+ * Cards **reorder by dragging** among their siblings (pointer-based from a grip, as
+ * WebKitGTK drops HTML5 DnD), one `moveNodeTo` splice per move. Like the tree, the
+ * cards EDIT THE FILE TEXT: every action splices `text` via `lib/viewers/yaml`'s ops
+ * (`setValue`/`addChild`/`deleteNode`/`duplicateNode`/`moveNodeTo`), so a card edit
+ * is an ordinary dirty/undoable/saveable change on the draft the tree and Source
+ * share, and comments/quoting/untouched bytes survive it. A value it can't safely
+ * rewrite is shown, not offered (`source only`) — the tree's honesty rule.
+ */
+export function YamlGrid({
+  text,
+  onChange,
+  tabKey,
+  fontSize,
+  strict,
+}: {
+  text: string;
+  onChange: (next: string) => void;
+  tabKey?: string;
+  fontSize?: number;
+  /** JSON dialect (a `.json` file): keys/strings added here are quoted. */
+  strict?: boolean;
+}) {
+  const doc = useMemo(() => parseYaml(text, { strict }), [text, strict]);
+
+  // The focused ("main") card rides with the tab, like the tree's collapse — the
+  // drill position stays across a reopen and a restart. A stale id (the file
+  // changed shape) is simply not found, and the grid falls back to the overview.
+  const viewPos = useViewerState(tabKey);
+  const [focusId, setFocusIdState] = useState<string | null>(() => viewPos.initial?.gridFocus ?? null);
+  const setFocus = useCallback(
+    (id: string | null) => {
+      setFocusIdState(id);
+      viewPos.persist({ gridFocus: id ?? undefined });
+    },
+    [viewPos],
+  );
+
+  // id → {node, parent}, so a focused card's ancestors and siblings are one lookup
+  // away without threading parents through the render.
+  const index = useMemo(() => buildIndex(doc), [doc]);
+
+  const ctx: Ctx = useMemo(
+    () => ({ doc, text, onChange, strict: !!strict }),
+    [doc, text, onChange, strict],
+  );
+
+  if (doc.error) {
+    return (
+      <div className="yaml-tree-notice">
+        <p>
+          The cards can't read this file: {doc.error.message} (line {doc.error.line})
+        </p>
+        <p className="yaml-tree-notice-hint">
+          Switch to <strong>Source</strong> to edit it as text — nothing here has been changed.
+        </p>
+      </div>
+    );
+  }
+
+  const top = topCards(doc);
+  if (!top.length) {
+    return (
+      <div className="yaml-cards">
+        <div className="yaml-cards-bar">
+          <span className="yaml-cards-bar-spacer" />
+          <UntestedTag />
+        </div>
+        <div className="yaml-tree-notice">
+          <p>This file has no entries yet.</p>
+        </div>
+      </div>
+    );
+  }
+
+  // The single root seq is the top level's parent (so its cards reorder); a single
+  // root map has no reorderable siblings at the top (its ONE card is `document`).
+  const topParent = doc.docs.length === 1 && doc.docs[0].kind === "seq" ? doc.docs[0] : null;
+  const focused = focusId && index.has(focusId) ? focusId : null;
+  const levels = buildLevels(top, topParent, focused, index);
+  const crumbs = levels.map((l) => l.selectedId).filter((x): x is string => !!x).map((id) => index.get(id)!.node);
+
+  return (
+    <div className="yaml-cards" style={fontSize ? { fontSize: `${fontSize}px` } : undefined}>
+      <div className="yaml-cards-bar">
+        <nav className="yaml-grid-breadcrumb" aria-label="Card path">
+          <button
+            className={`yaml-crumb${crumbs.length === 0 ? " on" : ""}`}
+            onClick={() => setFocus(null)}
+            title="Back to the top overview"
+          >
+            ⌂ overview
+          </button>
+          {crumbs.map((node, i) => (
+            <span key={node.id} className="yaml-crumb-wrap">
+              <span className="yaml-crumb-sep" aria-hidden="true">
+                ›
+              </span>
+              <button
+                className={`yaml-crumb${i === crumbs.length - 1 ? " on" : ""}`}
+                onClick={() => setFocus(node.id)}
+                title={crumbTitle(node, index)}
+              >
+                {crumbTitle(node, index)}
+              </button>
+            </span>
+          ))}
+        </nav>
+        <span className="yaml-cards-bar-spacer" />
+        <UntestedTag />
+      </div>
+
+      {levels.map((level, i) => (
+        <LevelGrid
+          key={level.parent ? level.parent.id : `top-${i}`}
+          level={level}
+          text={text}
+          ctx={ctx}
+          onFocus={setFocus}
+        />
+      ))}
+    </div>
+  );
+}
+
+/** The bundle every card needs, passed once instead of threaded field by field. */
+interface Ctx {
+  doc: YamlDoc;
+  text: string;
+  onChange: (next: string) => void;
+  strict: boolean;
+}
+
+/** One rendered level: the cards shown, their common parent (whose child list a
+ *  reorder addresses; `null` = not reorderable, e.g. a lone root map), and which
+ *  card is on the path to the focus (highlighted as the "main" card). */
+interface Level {
+  cards: YamlNode[];
+  parent: YamlNode | null;
+  selectedId: string | null;
+}
+
+/** Keys that name a record, tried in order to title a list item's card. */
+const TITLE_KEYS = ["name", "id", "title", "label", "key", "host", "type", "kind"];
+
+/** A friendly title for a list member. A mapping is named by its first name-ish
+ *  field's value; anything else falls back to a 1-based `Item N`. Never `#0`. */
+function itemTitle(node: YamlNode, index: number): string {
+  if (node.kind === "map") {
+    for (const k of TITLE_KEYS) {
+      const field = node.children.find(
+        (c) => c.key === k && c.kind === "scalar" && c.value.trim() !== "",
+      );
+      if (field) return field.value;
+    }
+  }
+  return `Item ${index + 1}`;
+}
+
+/** The document's top-level cards: a root map is one `document` card; a root list
+ *  is a card per item; multiple documents flatten into one top row. */
+function topCards(doc: YamlDoc): YamlNode[] {
+  return doc.docs.flatMap((root) => (root.kind === "seq" ? root.children : [root]));
+}
+
+/** A card's children that are themselves cards — its nested collections. Scalars
+ *  are fields shown ON the card, not cards in the next level. */
+function subcardsOf(node: YamlNode): YamlNode[] {
+  return node.children.filter(isContainer);
+}
+
+/** id → {node, parent} for the whole document, so ancestors/siblings are a lookup. */
+function buildIndex(doc: YamlDoc): Map<string, { node: YamlNode; parent: YamlNode | null }> {
+  const m = new Map<string, { node: YamlNode; parent: YamlNode | null }>();
+  const walk = (node: YamlNode, parent: YamlNode | null) => {
+    m.set(node.id, { node, parent });
+    for (const c of node.children) walk(c, node);
+  };
+  for (const r of doc.docs) walk(r, null);
+  return m;
+}
+
+/** Whether `ancestorId` is a (strict) ancestor of `targetId` in the doc tree. */
+function isAncestorOf(
+  ancestorId: string,
+  targetId: string,
+  index: Map<string, { node: YamlNode; parent: YamlNode | null }>,
+): boolean {
+  let cur = index.get(targetId)?.parent ?? null;
+  while (cur) {
+    if (cur.id === ancestorId) return true;
+    cur = index.get(cur.id)?.parent ?? null;
+  }
+  return false;
+}
+
+/** Walk the drill from the top row down to the focused card, one level per step:
+ *  each level highlights the card on the path, and the next level is that card's
+ *  children — ending with the focused card's own children (nothing highlighted). */
+function buildLevels(
+  top: YamlNode[],
+  topParent: YamlNode | null,
+  focusId: string | null,
+  index: Map<string, { node: YamlNode; parent: YamlNode | null }>,
+): Level[] {
+  const levels: Level[] = [];
+  let cards = top;
+  let parent = topParent;
+  // Guard against a pathological cycle (ids are unique, but be safe).
+  for (let guard = 0; guard < 64; guard++) {
+    const selected = focusId
+      ? cards.find((c) => c.id === focusId || isAncestorOf(c.id, focusId, index)) ?? null
+      : null;
+    levels.push({ cards, parent, selectedId: selected?.id ?? null });
+    if (!selected) break;
+    const kids = subcardsOf(selected);
+    if (selected.id === focusId) {
+      if (kids.length) levels.push({ cards: kids, parent: selected, selectedId: null });
+      break;
+    }
+    if (!kids.length) break;
+    cards = kids;
+    parent = selected;
+  }
+  return levels;
+}
+
+/** A card's display title, given its parent (a mapping keeps its key; a list member
+ *  gets its name-ish field, else `Item N`; a lone root map is `document`). */
+function titleFor(
+  node: YamlNode,
+  parent: YamlNode | null,
+  indexInParent: number,
+): string {
+  if (!parent) return node.path.length === 0 && node.kind === "map" ? "document" : itemTitle(node, indexInParent);
+  if (parent.kind === "map") return node.key ?? itemTitle(node, indexInParent);
+  return itemTitle(node, indexInParent);
+}
+
+/** A breadcrumb crumb's short label — the same title the card wears in its level. */
+function crumbTitle(
+  node: YamlNode,
+  index: Map<string, { node: YamlNode; parent: YamlNode | null }>,
+): string {
+  const parent = index.get(node.id)?.parent ?? null;
+  const i = parent ? parent.children.indexOf(node) : 0;
+  return titleFor(node, parent, i);
+}
+
+/** How tall a level's cards may grow before their fields scroll inside them. */
+const LEVEL_MAX_HEIGHT = 320;
+
+/**
+ * One level of the drill: a grid of sibling cards, all forced to the SAME height
+ * (measured to the tallest, capped at {@link LEVEL_MAX_HEIGHT}; a card with more
+ * fields scrolls inside itself). Owns the pointer-drag reorder among its cards —
+ * `siblings` is the parent's full child list (what `moveNodeTo` addresses); a drop
+ * maps a card's grid position back to its real index there.
+ */
+function LevelGrid({
+  level,
+  text,
+  ctx,
+  onFocus,
+}: {
+  level: Level;
+  text: string;
+  ctx: Ctx;
+  onFocus: (id: string | null) => void;
+}) {
+  const { cards, parent, selectedId } = level;
+  const siblings = parent?.children ?? cards;
+
+  // One ref array, shared by the drag hit-test and the equal-height measurement.
+  const els = useRef<(HTMLDivElement | null)[]>([]);
+  const live = useRef<{ from: number; to: number } | null>(null);
+  const [drag, setDrag] = useState<{ from: number; to: number } | null>(null);
+
+  // ── Equal height ──────────────────────────────────────────────────────────
+  // Re-measure whenever the level's shape or the file text changes (an edit can
+  // add/remove a field). `null` renders the cards at natural height so the tallest
+  // can be read; the effect then pins every card to it.
+  const [height, setHeight] = useState<number | null>(null);
+  const sig = useMemo(() => cards.map((c) => c.id).join("|") + "#" + text.length, [cards, text]);
+  useLayoutEffect(() => {
+    setHeight(null);
+  }, [sig]);
+  useLayoutEffect(() => {
+    if (height !== null) return;
+    let max = 0;
+    for (const el of els.current) if (el) max = Math.max(max, el.offsetHeight);
+    if (max > 0) setHeight(Math.min(max, LEVEL_MAX_HEIGHT));
+  });
+
+  // ── Drag reorder ──────────────────────────────────────────────────────────
+  const indexAt = (x: number, y: number): number => {
+    let best = live.current?.from ?? 0;
+    let bestDist = Infinity;
+    for (let i = 0; i < cards.length; i++) {
+      const el = els.current[i];
+      if (!el) continue;
+      const r = el.getBoundingClientRect();
+      if (x >= r.left && x <= r.right && y >= r.top && y <= r.bottom) return i;
+      const cx = r.left + r.width / 2;
+      const cy = r.top + r.height / 2;
+      const d = (x - cx) ** 2 + (y - cy) ** 2;
+      if (d < bestDist) {
+        bestDist = d;
+        best = i;
+      }
+    }
+    return best;
+  };
+  const start = (i: number) => {
+    live.current = { from: i, to: i };
+    setDrag(live.current);
+  };
+  const over = (x: number, y: number) => {
+    const d = live.current;
+    if (!d) return;
+    const to = indexAt(x, y);
+    if (to !== d.to) {
+      live.current = { from: d.from, to };
+      setDrag(live.current);
+    }
+  };
+  const drop = () => {
+    const d = live.current;
+    live.current = null;
+    setDrag(null);
+    if (!d || d.to === d.from) return;
+    const node = cards[d.from];
+    const target = cards[d.to];
+    if (!node.deletable || !target.deletable) return;
+    const to = siblings.findIndex((s) => s.id === target.id);
+    if (to >= 0) ctx.onChange(moveNodeTo(ctx.text, siblings, node, to));
+  };
+
+  return (
+    <div className="yaml-level">
+      <div className="yaml-level-grid">
+        {cards.map((node, i) => {
+          const movable = !!parent && node.deletable && cards.length > 1;
+          const cardDrag: CardDrag = {
+            rowRef: (el) => {
+              els.current[i] = el;
+            },
+            dragging: drag?.from === i,
+            dropTarget: drag != null && drag.to === i && drag.to !== drag.from,
+            blocked: drag != null && !node.deletable,
+            grip: movable
+              ? {
+                  onPointerDown: (e) => {
+                    e.preventDefault();
+                    e.currentTarget.setPointerCapture?.(e.pointerId);
+                    start(i);
+                  },
+                  onPointerMove: (e) => over(e.clientX, e.clientY),
+                  onPointerUp: (e) => {
+                    e.currentTarget.releasePointerCapture?.(e.pointerId);
+                    drop();
+                  },
+                  onPointerCancel: drop,
+                }
+              : null,
+          };
+          return (
+            <LevelCard
+              key={node.id}
+              node={node}
+              title={titleFor(node, parent, siblings.indexOf(node))}
+              selected={node.id === selectedId}
+              height={height}
+              onFocus={onFocus}
+              ctx={ctx}
+              drag={cardDrag}
+            />
+          );
+        })}
+      </div>
+      {parent && <AddBar node={parent} ctx={ctx} />}
+    </div>
+  );
+}
+
+/** A card's slot in its level's drag — the grip handlers, its live drag flags, and
+ *  the ref the level measures + hit-tests it by. `null` grip = not draggable. */
+interface CardDrag {
+  rowRef: (el: HTMLDivElement | null) => void;
+  dragging: boolean;
+  dropTarget: boolean;
+  blocked: boolean;
+  grip: {
+    onPointerDown: (e: React.PointerEvent) => void;
+    onPointerMove: (e: React.PointerEvent) => void;
+    onPointerUp: (e: React.PointerEvent) => void;
+    onPointerCancel: () => void;
+  } | null;
+}
+
+/** The classes a card wears while a drag is in flight — shared by every card. */
+function cardDragClass(drag: CardDrag | null): string {
+  if (!drag) return "";
+  return [
+    drag.dragging ? "yaml-card-dragging" : "",
+    drag.dropTarget ? "yaml-card-drop" : "",
+    drag.blocked ? "yaml-card-blocked" : "",
+  ]
+    .filter(Boolean)
+    .join(" ");
+}
+
+function CardGrip({ drag, title }: { drag: CardDrag | null; title: string }) {
+  if (!drag?.grip) return null;
+  return (
+    <button
+      className="yaml-grip yaml-card-grip"
+      title="Drag to reorder"
+      aria-label={`Reorder ${title}`}
+      {...drag.grip}
+    >
+      ⠿
+    </button>
+  );
+}
+
+/**
+ * One card in a level: its scalar children are editable fields (scrolling inside
+ * the fixed card height when there are many); its nested collections are NOT shown
+ * inline — a "N groups" footer (and the title) opens the card as the new main,
+ * revealing them as the next level. A bare scalar list item is a value-only card.
+ */
+function LevelCard({
+  node,
+  title,
+  selected,
+  height,
+  onFocus,
+  ctx,
+  drag,
+}: {
+  node: YamlNode;
+  title: string;
+  selected: boolean;
+  height: number | null;
+  onFocus: (id: string | null) => void;
+  ctx: Ctx;
+  drag: CardDrag | null;
+}) {
+  const scalar = !isContainer(node);
+  const entries = node.children.map((child, i) => ({ child, i }));
+  const scalars = entries.filter((e) => e.child.kind === "scalar");
+  const subs = scalar ? [] : subcardsOf(node);
+  const n = node.children.length;
+  const badge = scalar
+    ? ""
+    : node.kind === "seq"
+      ? `${n} item${n === 1 ? "" : "s"}`
+      : `${n} key${n === 1 ? "" : "s"}`;
+  const canDrill = subs.length > 0;
+  const style: CSSProperties | undefined = height != null ? { height: `${height}px` } : undefined;
+
+  return (
+    <div
+      className={`yaml-card yaml-level-card${selected ? " yaml-card-main" : ""} ${cardDragClass(drag)}`.trimEnd()}
+      style={style}
+      ref={drag?.rowRef}
+    >
+      <div className="yaml-card-head">
+        <CardGrip drag={drag} title={title} />
+        {canDrill ? (
+          <button
+            className="yaml-card-toggle"
+            onClick={() => onFocus(node.id)}
+            title={`Open ${title}`}
+            aria-label={`Open ${title}`}
+          >
+            <span className="yaml-card-title">{title}</span>
+          </button>
+        ) : (
+          <span className="yaml-card-title yaml-card-title-static">{title}</span>
+        )}
+        {!scalar && isFlow(node) && (
+          <span className="yaml-flow-tag" title="Written in flow (JSON) style">
+            {node.kind === "seq" ? "[ ]" : "{ }"}
+          </span>
+        )}
+        {badge && <span className="yaml-card-badge">{badge}</span>}
+        {node.deletable && (
+          <button
+            className="yaml-act yaml-act-del yaml-card-del"
+            title="Delete this card"
+            aria-label={`Delete ${title}`}
+            onClick={() => {
+              // Deleting the main card (or an ancestor of it) drops the focus back
+              // to safety — the level rebuilds and a stale focus would vanish.
+              if (selected) onFocus(null);
+              ctx.onChange(deleteNode(ctx.text, node));
+            }}
+          >
+            ×
+          </button>
+        )}
+      </div>
+
+      <div className="yaml-card-scroll">
+        {scalar ? (
+          <div className="yaml-card-field yaml-card-field-scalar">
+            {cellKind(node, null) === "scalar" ? (
+              <CommitInput
+                className={`yaml-value-input yaml-val-${scalarType(node)}`}
+                initial={node.value}
+                ariaLabel={`Value of ${title}`}
+                onCommit={(next) => ctx.onChange(setValue(ctx.text, ctx.doc, node, next))}
+              />
+            ) : (
+              <span className="yaml-value-locked" title={node.raw}>
+                {node.raw || node.value}
+              </span>
+            )}
+          </div>
+        ) : scalars.length > 0 ? (
+          <div className="yaml-card-fields">
+            {scalars.map(({ child, i }) => (
+              <FieldRow key={child.id} entry={child} parentKind={node.kind} index={i} ctx={ctx} />
+            ))}
+          </div>
+        ) : (
+          <div className="yaml-card-empty">no fields</div>
+        )}
+      </div>
+
+      {!scalar && <AddBar node={node} ctx={ctx} />}
+      {canDrill && (
+        <button
+          className="yaml-card-drill"
+          onClick={() => onFocus(node.id)}
+          title={`Open ${subs.length} nested group${subs.length === 1 ? "" : "s"}`}
+        >
+          {subs.length} group{subs.length === 1 ? "" : "s"} <span aria-hidden="true">▸</span>
+        </button>
+      )}
+    </div>
+  );
+}
+
+/** One scalar field inside a card: a label (key, or list index) and its value —
+ *  edit-in-place when the tree can rewrite it, read-only (`source only`) when not. */
+function FieldRow({
+  entry,
+  parentKind,
+  index,
+  ctx,
+}: {
+  entry: YamlNode;
+  parentKind: string;
+  index: number;
+  ctx: Ctx;
+}) {
+  const inSeq = parentKind === "seq";
+  const label = inSeq ? "–" : entry.key ?? "";
+  const kind = cellKind(entry, null);
+
+  return (
+    <div className="yaml-card-field">
+      <span
+        className={`yaml-card-key${inSeq ? " yaml-card-bullet" : ""}`}
+        title={inSeq ? `item ${index + 1}` : label}
+      >
+        {label}
+      </span>
+      {kind === "scalar" ? (
+        <CommitInput
+          className={`yaml-value-input yaml-val-${scalarType(entry)}`}
+          initial={entry.value}
+          ariaLabel={`Value of ${label}`}
+          placeholder={entry.style === "empty" ? "null" : undefined}
+          onCommit={(next) => ctx.onChange(setValue(ctx.text, ctx.doc, entry, next))}
+        />
+      ) : (
+        <span
+          className="yaml-value-locked"
+          title={entry.raw || "The tree can't rewrite this — edit it in Source."}
+        >
+          {entry.raw || entry.value}
+        </span>
+      )}
+      {entry.deletable && (
+        <button
+          className="yaml-act yaml-act-del yaml-card-field-del"
+          title="Delete this field"
+          aria-label={`Delete ${label}`}
+          onClick={() => ctx.onChange(deleteNode(ctx.text, entry))}
+        >
+          ×
+        </button>
+      )}
+    </div>
+  );
+}
+
+/** The add affordances at the foot of a card: a mapping grows a field, a sequence a
+ *  card or a value (and can copy its last item — fastest for like-shaped records). */
+function AddBar({ node, ctx }: { node: YamlNode; ctx: Ctx }) {
+  const [adding, setAdding] = useState(false);
+  if (node.kind !== "map" && node.kind !== "seq") return null;
+  const lastChild = node.children[node.children.length - 1];
+  const canCopy = node.kind === "seq" && lastChild && lastChild.deletable;
+
+  if (node.kind === "map") {
+    return (
+      <div className="yaml-card-add">
+        {adding ? (
+          <CommitInput
+            className="yaml-key-input"
+            initial=""
+            placeholder="new field"
+            ariaLabel="New field key"
+            autoFocus
+            onCommit={(next) => {
+              setAdding(false);
+              const key = next.trim();
+              if (key) {
+                ctx.onChange(
+                  addChild(ctx.text, ctx.doc, node, "key", key, literalFor("text", "", ctx.strict)),
+                );
+              }
+            }}
+            onCancel={() => setAdding(false)}
+          />
+        ) : (
+          <button className="yaml-add" onClick={() => setAdding(true)}>
+            + field
+          </button>
+        )}
+      </div>
+    );
+  }
+
+  return (
+    <div className="yaml-card-add">
+      <button
+        className="yaml-add"
+        title="Add a card (an empty mapping item)"
+        onClick={() => ctx.onChange(addChild(ctx.text, ctx.doc, node, "item", "", "{}"))}
+      >
+        + card
+      </button>
+      <button
+        className="yaml-add"
+        title="Add a plain value item"
+        onClick={() =>
+          ctx.onChange(
+            addChild(ctx.text, ctx.doc, node, "item", "", literalFor("text", "", ctx.strict)),
+          )
+        }
+      >
+        + value
+      </button>
+      {canCopy && (
+        <button
+          className="yaml-add"
+          title="Add a copy of the last item, to edit in place"
+          onClick={() => ctx.onChange(duplicateNode(ctx.text, lastChild))}
+        >
+          Copy last
+        </button>
+      )}
+    </div>
+  );
+}
+
+/**
+ * A single-line input that commits on Enter/blur and reverts on Escape. It holds
+ * its own buffer rather than driving `onChange` per keystroke: a commit re-encodes
+ * the value into the file (quoting when it must), and doing that per keypress would
+ * rewrite the text under the caret.
+ */
+function CommitInput({
+  initial,
+  className,
+  ariaLabel,
+  placeholder,
+  autoFocus,
+  onCommit,
+  onCancel,
+}: {
+  initial: string;
+  className: string;
+  ariaLabel: string;
+  placeholder?: string;
+  autoFocus?: boolean;
+  onCommit: (next: string) => void;
+  onCancel?: () => void;
+}) {
+  const [buf, setBuf] = useState(initial);
+  const dirty = useRef(false);
+  useEffect(() => {
+    if (!dirty.current) setBuf(initial);
+  }, [initial]);
+
+  return (
+    <input
+      className={className}
+      value={buf}
+      placeholder={placeholder}
+      aria-label={ariaLabel}
+      autoFocus={autoFocus}
+      style={fullWidth}
+      onChange={(e) => {
+        dirty.current = true;
+        setBuf(e.target.value);
+      }}
+      onBlur={() => {
+        dirty.current = false;
+        if (buf !== initial) onCommit(buf);
+        else onCancel?.();
+      }}
+      onKeyDown={(e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          dirty.current = false;
+          if (buf !== initial) onCommit(buf);
+          else onCancel?.();
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          dirty.current = false;
+          setBuf(initial);
+          onCancel?.();
+        }
+      }}
+    />
+  );
+}
+
+const fullWidth: CSSProperties = { width: "100%" };
diff --git a/src/components/embed/YamlTree.tsx b/src/components/embed/YamlTree.tsx
new file mode 100644
index 0000000..b498238
--- /dev/null
+++ b/src/components/embed/YamlTree.tsx
@@ -0,0 +1,1474 @@
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  type CSSProperties,
+} from "react";
+import { useViewerState } from "./FileViewerPane";
+import {
+  parseYaml,
+  setValue,
+  renameKey,
+  deleteNode,
+  addChild,
+  addRootEntry,
+  duplicateNode,
+  moveNode,
+  moveNodeTo,
+  canAddChild,
+  canComment,
+  canPasteAfter,
+  commentOf,
+  copyNode,
+  inlineListValues,
+  setListItems,
+  pasteAfter,
+  setComment,
+  isFlow,
+  literalFor,
+  scalarType,
+  type YamlClip,
+  type YamlDoc,
+  type YamlNode,
+  type YamlValueType,
+} from "../../lib/viewers/yaml";
+
+/**
+ * The YAML/JSON tree editor (#yaml) — the structured half of the viewer, the way
+ * the rendered preview is the structured half of the markdown viewer.
+ *
+ * It edits the FILE TEXT, not a model of it: every action here is a splice back
+ * into `text` (see `lib/viewers/yaml`), and the result goes straight to the same
+ * draft the Source tab shows. That is the whole design — the two modes never
+ * convert between representations, so comments and formatting survive an edit,
+ * and Ctrl+S / undo / redo / format / validation all keep working on the text
+ * underneath without knowing the tree exists.
+ *
+ * Both syntaxes render as one tree, and each keeps its own: a block collection
+ * grows by lines, a flow one (`{a: 1}` — i.e. JSON) grows inside its brackets.
+ * `strict` is set for a `.json` file, where every key and string is quoted.
+ *
+ * What the tree offers, it can do: a node the parser cannot rewrite safely (an
+ * anchor, an alias, a merge key, a plain scalar continued across lines) renders
+ * with its edit affordances withheld rather than a control that would corrupt the
+ * file.
+ */
+
+// ── The copy buffer ─────────────────────────────────────────────────────────
+// Module-level, not component state: copying in one tab and pasting in another
+// (or after the viewer remounts) is the point of a clipboard. The system
+// clipboard receives the same text, but the paste cursor works from THIS one —
+// it carries the structure (block/flow, mapping entry/item) a raw string no
+// longer has, which is what lets the cursor refuse a spot the paste would tear.
+let clipCurrent: YamlClip | null = null;
+const clipSubs = new Set<() => void>();
+
+function setClip(next: YamlClip | null) {
+  clipCurrent = next;
+  for (const fn of clipSubs) fn();
+}
+
+function useClip(): YamlClip | null {
+  return useSyncExternalStore(
+    (cb) => {
+      clipSubs.add(cb);
+      return () => clipSubs.delete(cb);
+    },
+    () => clipCurrent,
+  );
+}
+
+export function YamlTree({
+  text,
+  onChange,
+  tabKey,
+  fontSize,
+  strict,
+}: {
+  text: string;
+  onChange: (next: string) => void;
+  tabKey?: string;
+  fontSize?: number;
+  /** JSON dialect (a `.json` file): keys and strings are always quoted. */
+  strict?: boolean;
+}) {
+  const doc = useMemo(() => parseYaml(text, { strict }), [text, strict]);
+
+  // Collapse state rides with the tab (like the reader's scroll position), so
+  // folding a big config stays folded across a reopen and a restart.
+  const viewPos = useViewerState(tabKey);
+  const [collapsed, setCollapsed] = useState<Set<string>>(
+    () => new Set(viewPos.initial?.yamlCollapsed ?? []),
+  );
+  const toggle = useCallback(
+    (id: string) => {
+      setCollapsed((cur) => {
+        const next = new Set(cur);
+        if (next.has(id)) next.delete(id);
+        else next.add(id);
+        viewPos.persist({ yamlCollapsed: [...next] });
+        return next;
+      });
+    },
+    [viewPos],
+  );
+
+  // The row currently showing its "add entry" form, as `${parentId}:${kind}`.
+  const [adding, setAdding] = useState<string | null>(null);
+
+  // Copy → paste: the app-wide buffer, and where THIS tree's paste cursor sits
+  // (the id of the entry the paste would follow). The buffer is shared so a copy
+  // travels between tabs; the cursor is per tree — two views of two files must
+  // not fight over one insertion point.
+  const clip = useClip();
+  const [cursorId, setCursorId] = useState<string | null>(null);
+
+  // Esc cancels the whole paste mode — cursor and buffer both — but never while
+  // typing in one of the tree's inputs, whose own Escape means "revert this
+  // field". A buffer cleared elsewhere (another tab's Esc, the banner's ×) takes
+  // this tree's cursor with it.
+  useEffect(() => {
+    if (!clip) {
+      setCursorId(null);
+      return;
+    }
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== "Escape") return;
+      const t = e.target as HTMLElement | null;
+      if (t && /^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName)) return;
+      setCursorId(null);
+      setClip(null);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [clip]);
+
+  if (doc.error) {
+    return (
+      <div className="yaml-tree-notice">
+        <p>
+          The tree can't read this file: {doc.error.message} (line {doc.error.line})
+        </p>
+        <p className="yaml-tree-notice-hint">
+          Switch to <strong>Source</strong> to edit it as text — nothing here has been changed.
+        </p>
+      </div>
+    );
+  }
+
+  if (!doc.docs.length) {
+    return (
+      <div className="yaml-tree" style={fontSize ? { fontSize: `${fontSize}px` } : undefined}>
+        <div className="yaml-tree-notice">
+          <p>This file has no entries yet.</p>
+        </div>
+        {adding ? (
+          <AddRow
+            depth={0}
+            kind={adding === "root:item" ? "item" : "key"}
+            onCancel={() => setAdding(null)}
+            onAdd={(kind, key, type, value) => {
+              onChange(
+                addRootEntry(text, kind, key, literalFor(type, value, doc.strict), doc.strict),
+              );
+              setAdding(null);
+            }}
+          />
+        ) : (
+          <div className="yaml-row yaml-row-add">
+            <button className="yaml-add" onClick={() => setAdding("root:key")}>
+              + key
+            </button>
+            <button className="yaml-add" onClick={() => setAdding("root:item")}>
+              + item
+            </button>
+          </div>
+        )}
+      </div>
+    );
+  }
+
+  return (
+    <div className="yaml-tree" style={fontSize ? { fontSize: `${fontSize}px` } : undefined}>
+      {/* What the copy button captured, and how to use or drop it — the banner is
+          also the one cancel affordance a mouse-only user has. */}
+      {clip && (
+        <div className="yaml-clip-banner">
+          <span>
+            Copied <strong>{clip.label}</strong> — click an entry to place the paste cursor after
+            it
+          </span>
+          <button
+            className="yaml-act"
+            onClick={() => {
+              setCursorId(null);
+              setClip(null);
+            }}
+            title="Forget the copied entry (Esc)"
+            aria-label="Forget the copied entry"
+          >
+            ×
+          </button>
+        </div>
+      )}
+      {doc.docs.map((root, i) => (
+        <div className="yaml-doc" key={root.id}>
+          {doc.docs.length > 1 && <div className="yaml-doc-sep">document {i + 1}</div>}
+          <YamlRows
+            nodes={root.children}
+            parent={root}
+            depth={0}
+            text={text}
+            doc={doc}
+            onChange={onChange}
+            collapsed={collapsed}
+            toggle={toggle}
+            adding={adding}
+            setAdding={setAdding}
+            cursorId={cursorId}
+            setCursor={setCursorId}
+          />
+          {adding?.startsWith(`${root.id}:`) ? (
+            <AddRow
+              depth={0}
+              kind={adding.endsWith(":item") ? "item" : "key"}
+              onCancel={() => setAdding(null)}
+              onAdd={(kind, key, type, value) => {
+                onChange(
+                  addChild(text, doc, root, kind, key, literalFor(type, value, doc.strict)),
+                );
+                setAdding(null);
+              }}
+              onCopyLast={copyLastAction(root, text, onChange, () => setAdding(null))}
+            />
+          ) : (
+            <AddControls node={root} adding={adding} setAdding={setAdding} />
+          )}
+        </div>
+      ))}
+    </div>
+  );
+}
+
+/**
+ * One level of siblings. Split out so a row's children re-render on their own — and
+ * because it is the natural home for the drag: a node can only be reordered AMONG
+ * ITS SIBLINGS (there is no such thing as dragging a key into a different mapping —
+ * that is a re-parent, not a reorder), so the list that owns them owns the gesture.
+ *
+ * The drag is pointer-based, not HTML5 drag-and-drop, which does not work under
+ * WebKitGTK; and every pointer handler is bound to the grip up front rather than
+ * added to the window mid-gesture, because listeners registered once a gesture is
+ * already under way are the ones WebKitGTK drops.
+ */
+/** How an ancestor's hover marks the rows beneath it: the plain substructure
+ *  highlight, the accent tint of a hovered whole-entry action (copy, move,
+ *  comment), the accent-plus-pull of the drag grip (the block shifts a few px
+ *  out, showing it is what the handle moves), or the danger tint of a hovered
+ *  delete. */
+type SubtreeMark = "row" | "act" | "grab" | "del" | null;
+
+/** The row class a mark paints. Shared by the entry rows AND the add/form rows
+ *  inside a container's block, so a marked area colors contiguously instead of
+ *  leaving its `+ key` / `+ item` rows white holes. */
+const markClass = (m: SubtreeMark): string =>
+  m === "del"
+    ? "yaml-row-marked-del"
+    : m === "grab"
+      ? "yaml-row-marked-act yaml-row-pulled"
+      : m === "act"
+        ? "yaml-row-marked-act"
+        : m
+          ? "yaml-row-marked"
+          : "";
+
+/** Width of the fixed action gutter every row reserves on its LEFT, where the
+ *  entry's hover buttons (⠿ # ⧉ ↑ ↓ ×) live — a stable column in front of the
+ *  tree, instead of a target that drifts right with the panel's width. Sized to
+ *  the full slot set; mirrored by `.yaml-gutter` in themes.css. */
+const GUTTER = 130;
+
+/** How many per-level guide colors themes.css defines (`--yaml-guide-N`). */
+const GUIDE_COLORS = 4;
+
+/** Every row's left padding — the action gutter, then the tree indent — plus
+ *  one vertical guide line per ancestor level (colors cycling by depth), so the
+ *  tree's structure reads at a glance. The guides are a background IMAGE, which
+ *  is what lets them coexist with the hover/marked background COLORS: those are
+ *  stylesheet shorthands, and the inline image wins the image slot alone. */
+const rowPad = (depth: number): CSSProperties => {
+  const style: CSSProperties = { paddingLeft: `${GUTTER + depth * 14 + 4}px` };
+  if (depth > 0) {
+    const stops = Array.from({ length: depth }, (_, k) => {
+      // Under each ancestor level's caret column.
+      const x = GUTTER + 4 + k * 14 + 5;
+      const c = `var(--yaml-guide-${k % GUIDE_COLORS})`;
+      return `transparent ${x}px, ${c} ${x}px, ${c} ${x + 1}px, transparent ${x + 1}px`;
+    }).join(", ");
+    style.backgroundImage = `linear-gradient(to right, ${stops})`;
+  }
+  return style;
+};
+
+function YamlRows({
+  nodes,
+  parent,
+  depth,
+  text,
+  doc,
+  onChange,
+  collapsed,
+  toggle,
+  adding,
+  setAdding,
+  cursorId,
+  setCursor,
+  marked = null,
+}: {
+  nodes: YamlNode[];
+  parent: YamlNode;
+  depth: number;
+  text: string;
+  doc: YamlDoc;
+  onChange: (next: string) => void;
+  collapsed: Set<string>;
+  toggle: (id: string) => void;
+  adding: string | null;
+  setAdding: (v: string | null) => void;
+  cursorId: string | null;
+  setCursor: (v: string | null) => void;
+  /** A hovered ancestor marks every row under it (see {@link SubtreeMark}). */
+  marked?: SubtreeMark;
+}) {
+  const rows = useRef<(HTMLDivElement | null)[]>([]);
+  // The live gesture is a ref (the pointer handlers read it without re-binding) and
+  // state (the drop line has to render).
+  const live = useRef<{ from: number; to: number } | null>(null);
+  const [drag, setDrag] = useState<{ from: number; to: number } | null>(null);
+
+  // Several keys at one level pad to one column, so their values start on a
+  // shared left edge (the tree is monospace, so `ch` is exact). The widest key
+  // sets the column — capped, so one novella of a key can't shove every sibling's
+  // value off screen. A lone key needs no column.
+  const keyWidth = useMemo(() => {
+    const keyed = nodes.filter((n) => n.key != null);
+    if (keyed.length < 2) return null;
+    return Math.min(40, Math.max(...keyed.map((n) => n.key!.length)));
+  }, [nodes]);
+
+  // Which sibling the pointer is over. A sibling's band runs from its own row down
+  // to the next sibling's — so pointing anywhere inside a container's subtree lands
+  // on the container, which is the only thing at this depth that the pointer could
+  // mean.
+  const indexAt = (y: number) => {
+    let k = 0;
+    for (let i = 0; i < nodes.length; i++) {
+      const el = rows.current[i];
+      if (el && y >= el.getBoundingClientRect().top) k = i;
+    }
+    return k;
+  };
+
+  const start = (i: number) => {
+    live.current = { from: i, to: i };
+    setDrag(live.current);
+  };
+  const over = (y: number) => {
+    const d = live.current;
+    if (!d) return;
+    const to = indexAt(y);
+    if (to !== d.to) {
+      live.current = { from: d.from, to };
+      setDrag(live.current);
+    }
+  };
+  const drop = () => {
+    const d = live.current;
+    live.current = null;
+    setDrag(null);
+    // Only commit onto a removable target (moveNodeTo also guards this, but
+    // checking here keeps a drop onto such a slot from firing a no-op onChange).
+    // A dash-line entry IS a real target: moveNodeTo hands the item's `- ` to
+    // whichever entry ends up first.
+    if (d && d.to !== d.from && nodes[d.to]?.deletable) {
+      onChange(moveNodeTo(text, nodes, nodes[d.from], d.to));
+    }
+  };
+
+  return (
+    <>
+      {nodes.map((node, i) => (
+        <YamlRow
+          key={node.id}
+          node={node}
+          index={i}
+          siblings={nodes}
+          parentKind={parent.kind}
+          depth={depth}
+          text={text}
+          doc={doc}
+          onChange={onChange}
+          collapsed={collapsed}
+          toggle={toggle}
+          adding={adding}
+          setAdding={setAdding}
+          cursorId={cursorId}
+          setCursor={setCursor}
+          marked={marked}
+          keyWidth={keyWidth}
+          rowRef={(el) => {
+            rows.current[i] = el;
+          }}
+          dragging={drag?.from === i}
+          // The drop line goes on the row the node would land at, on the side it
+          // would come to rest — so the gesture shows where the text will end up.
+          // Only a removable row gets a line; an unremovable one is blended out
+          // instead (see `blocked`).
+          dropSide={
+            drag && drag.to === i && drag.to !== drag.from && node.deletable
+              ? drag.to < drag.from
+                ? "before"
+                : "after"
+              : null
+          }
+          // While a drag is in flight, an entry that can't be a drop target is
+          // dimmed to show the reorder won't land there.
+          blocked={drag != null && !node.deletable}
+          onDragStart={start}
+          onDragOver={over}
+          onDragEnd={drop}
+        />
+      ))}
+    </>
+  );
+}
+
+function YamlRow({
+  node,
+  index,
+  siblings,
+  parentKind,
+  depth,
+  text,
+  doc,
+  onChange,
+  collapsed,
+  toggle,
+  adding,
+  setAdding,
+  cursorId,
+  setCursor,
+  marked,
+  keyWidth,
+  rowRef,
+  dragging,
+  dropSide,
+  blocked,
+  onDragStart,
+  onDragOver,
+  onDragEnd,
+}: {
+  node: YamlNode;
+  index: number;
+  siblings: YamlNode[];
+  parentKind: string;
+  depth: number;
+  text: string;
+  doc: YamlDoc;
+  onChange: (next: string) => void;
+  collapsed: Set<string>;
+  toggle: (id: string) => void;
+  adding: string | null;
+  setAdding: (v: string | null) => void;
+  cursorId: string | null;
+  setCursor: (v: string | null) => void;
+  marked: SubtreeMark;
+  /** The sibling group's key column, in ch — null when this key stands alone. */
+  keyWidth: number | null;
+  rowRef: (el: HTMLDivElement | null) => void;
+  dragging: boolean;
+  dropSide: "before" | "after" | null;
+  blocked: boolean;
+  onDragStart: (index: number) => void;
+  onDragOver: (clientY: number) => void;
+  onDragEnd: () => void;
+}) {
+  const [renaming, setRenaming] = useState(false);
+  const [noting, setNoting] = useState(false);
+  // This row's own hover, handed down to its children: a container's row names
+  // the whole block beneath it, so pointing at the row marks the block — and
+  // pointing at its delete marks the block in danger, since that is what the ×
+  // will take.
+  const [mark, setMark] = useState<SubtreeMark>(null);
+  const isContainer = node.kind !== "scalar";
+  const isOpen = !collapsed.has(node.id);
+  const inSeq = parentKind === "seq";
+
+  // While the copy buffer holds an entry, a row the paste FITS after (a mapping
+  // entry after a mapping entry, an item after an item — see canPasteAfter) is a
+  // click target for the paste cursor; every other row stays an ordinary row.
+  const clip = useClip();
+  const pastable = clip != null && canPasteAfter(clip, node, parentKind);
+  // Hovering a pastable row previews the landing point (see the preview row).
+  const [pasteHover, setPasteHover] = useState(false);
+
+  // What this row is called in an action's label. A list item has no key, and
+  // "Delete item" would name every sibling equally — to a screen reader and to a
+  // test alike — so it is named by its index.
+  const label = inSeq ? `item ${index}` : (node.key ?? "");
+  // A list of plain values reads — and edits — better as the values themselves:
+  // `web, prod` in one input, where typing a comma adds an item and deleting one
+  // removes it. Such a list renders as this ONE line, no item rows: the line IS
+  // the list. Only when every item can ride a comma line (see inlineListValues) —
+  // a list of mappings, or an item carrying its own comment, stays rows.
+  const inlineList = node.kind === "seq" ? inlineListValues(node) : null;
+  const count = isContainer
+    ? node.kind === "seq"
+      ? `${node.children.length} item${node.children.length === 1 ? "" : "s"}`
+      : `${node.children.length} key${node.children.length === 1 ? "" : "s"}`
+    : null;
+
+  const movable = node.deletable && siblings.length > 1;
+  // Whether hovering this row has a substructure to mark: an open container with
+  // visible child rows (an inline comma list has none — the line is the list).
+  const marksSubtree = isContainer && isOpen && !inlineList && node.children.length > 0;
+  // A whole-entry action (grip, copy, move, comment) hands the accent tint down
+  // the substructure the same way the × hands down danger: everything tinted is
+  // what the button will act on — the entry is its block, not its one line.
+  const actMark = marksSubtree
+    ? { onMouseEnter: () => setMark("act"), onMouseLeave: () => setMark("row") }
+    : {};
+  // The grip's own mark: the same accent, plus the block "pulling out" a few px —
+  // the affordance that this handle is what moves it.
+  const grabMark = marksSubtree
+    ? { onMouseEnter: () => setMark("grab"), onMouseLeave: () => setMark("row") }
+    : {};
+  // What this row's block content (child rows, its add/form rows) is marked
+  // with. A row being DRAGGED keeps the grab mark for the whole gesture — the
+  // grip's hover mark would die the moment the pointer moves off it.
+  const childMark: SubtreeMark = dragging ? "grab" : (mark ?? marked);
+  const note = commentOf(node);
+  // What the key says about itself on hover: its comment if it has one, since that
+  // is the only place a YAML file documents a key.
+  const keyTitle = note ? `# ${note}` : "Click to rename this key";
+
+  return (
+    <>
+      <div
+        ref={rowRef}
+        className={[
+          "yaml-row",
+          dragging ? "yaml-row-dragging" : "",
+          dropSide ? `yaml-row-drop-${dropSide}` : "",
+          blocked ? "yaml-row-blocked" : "",
+          pastable ? "yaml-row-pastable" : "",
+          markClass(marked),
+        ]
+          .filter(Boolean)
+          .join(" ")}
+        style={rowPad(depth)}
+        onMouseEnter={() => {
+          if (marksSubtree) setMark("row");
+          if (pastable) setPasteHover(true);
+        }}
+        onMouseLeave={() => {
+          if (marksSubtree) setMark(null);
+          setPasteHover(false);
+        }}
+        // Placing the paste cursor is a click on the row itself — its background
+        // and gaps — never on one of its controls, which keep their own meaning
+        // (rename, edit, collapse) while a copy is held.
+        onClick={
+          pastable
+            ? (e) => {
+                const t = e.target as HTMLElement;
+                if (t.closest("button, input, textarea, select")) return;
+                setCursor(cursorId === node.id ? null : node.id);
+              }
+            : undefined
+        }
+      >
+        {/* The entry's own actions, in the fixed gutter on the row's LEFT — one
+            stable column for every row, whatever its depth. Shown on the row's
+            hover, like the old right-edge cluster. */}
+        {/* SIX FIXED SLOTS (⠿ # ⧉ ↑ ↓ ×), an action the row doesn't offer
+            rendered as an empty slot — so every button keeps its column on
+            every row, and the pointer never has to chase a shifting target. */}
+        <span className="yaml-actions yaml-gutter">
+          {movable ? (
+            <button
+              className="yaml-grip"
+              title="Drag to reorder"
+              aria-label={`Reorder ${label}`}
+              {...grabMark}
+              onPointerDown={(e) => {
+                // Pointer capture keeps every later event on the grip, so the gesture
+                // survives the pointer leaving the row (which is the whole point of it).
+                // Optional because it is the one part of this not every environment
+                // implements — jsdom has no pointer capture, and the drag is still the
+                // drag without it.
+                e.preventDefault();
+                e.currentTarget.setPointerCapture?.(e.pointerId);
+                onDragStart(index);
+              }}
+              onPointerMove={(e) => onDragOver(e.clientY)}
+              onPointerUp={(e) => {
+                e.currentTarget.releasePointerCapture?.(e.pointerId);
+                onDragEnd();
+              }}
+              onPointerCancel={onDragEnd}
+            >
+              ⠿
+            </button>
+          ) : (
+            <span className="yaml-slot yaml-slot-grip" aria-hidden="true" />
+          )}
+          {!note && !noting && canComment(doc, node) ? (
+            <button
+              className="yaml-act"
+              onClick={() => setNoting(true)}
+              title="Add a comment"
+              aria-label={`Comment on ${label}`}
+              {...actMark}
+            >
+              #
+            </button>
+          ) : (
+            <span className="yaml-slot" aria-hidden="true" />
+          )}
+          {/* Copy the entry into the paste buffer (and, as text, onto the system
+              clipboard). */}
+          {node.deletable ? (
+            <button
+              className="yaml-act"
+              onClick={() => {
+                const c = copyNode(text, node, label);
+                if (!c) return;
+                setClip(c);
+                navigator.clipboard?.writeText(c.text).catch(() => {});
+              }}
+              title="Copy this entry — then click an entry to paste after it"
+              aria-label={`Copy ${label}`}
+              {...actMark}
+            >
+              ⧉
+            </button>
+          ) : (
+            <span className="yaml-slot" aria-hidden="true" />
+          )}
+          {movable ? (
+            <>
+              <button
+                className="yaml-act"
+                disabled={index === 0}
+                onClick={() => onChange(moveNode(text, siblings, node, -1))}
+                title="Move up"
+                aria-label={`Move ${label} up`}
+                {...actMark}
+              >
+                ↑
+              </button>
+              <button
+                className="yaml-act"
+                disabled={index === siblings.length - 1}
+                onClick={() => onChange(moveNode(text, siblings, node, 1))}
+                title="Move down"
+                aria-label={`Move ${label} down`}
+                {...actMark}
+              >
+                ↓
+              </button>
+            </>
+          ) : (
+            <>
+              <span className="yaml-slot" aria-hidden="true" />
+              <span className="yaml-slot" aria-hidden="true" />
+            </>
+          )}
+          {node.deletable ? (
+            <button
+              className="yaml-act yaml-act-del"
+              onClick={() => onChange(deleteNode(text, node))}
+              // Hovering a container's × tints its whole substructure in danger:
+              // everything marked is what the click will take.
+              onMouseEnter={marksSubtree ? () => setMark("del") : undefined}
+              onMouseLeave={marksSubtree ? () => setMark("row") : undefined}
+              title={isContainer ? "Delete this entry and everything under it" : "Delete this entry"}
+              aria-label={`Delete ${label}`}
+            >
+              ×
+            </button>
+          ) : (
+            <span className="yaml-slot" aria-hidden="true" />
+          )}
+        </span>
+
+        {isContainer && node.children.length > 0 && !inlineList ? (
+          <button
+            className="yaml-caret"
+            onClick={() => toggle(node.id)}
+            aria-expanded={isOpen}
+            aria-label={isOpen ? `Collapse ${label}` : `Expand ${label}`}
+          >
+            {isOpen ? "▾" : "▸"}
+          </button>
+        ) : (
+          <span className="yaml-caret yaml-caret-empty" aria-hidden="true" />
+        )}
+
+        {inSeq ? (
+          <span className="yaml-index" title={note ? `# ${note}` : undefined}>
+            {index}
+          </span>
+        ) : renaming ? (
+          <TextCommit
+            initial={node.key ?? ""}
+            className="yaml-key-input"
+            ariaLabel={`Rename key ${node.key ?? ""}`}
+            onCommit={(next) => {
+              setRenaming(false);
+              if (next && next !== node.key) onChange(renameKey(text, doc, node, next));
+            }}
+            onCancel={() => setRenaming(false)}
+          />
+        ) : (
+          <button
+            className="yaml-key"
+            // +1 for the colon the button also holds; the padding is uniform
+            // across siblings, so the values land on one left edge.
+            style={keyWidth != null ? { minWidth: `${keyWidth + 1}ch` } : undefined}
+            onClick={() => setRenaming(true)}
+            title={keyTitle}
+          >
+            {node.key}
+            <span className="yaml-colon">:</span>
+          </button>
+        )}
+
+        {node.kind === "scalar" ? (
+          <ValueCell
+            node={node}
+            label={label}
+            onCommit={(next) => onChange(setValue(text, doc, node, next))}
+          />
+        ) : inlineList ? (
+          <>
+            {isFlow(node) && (
+              <span className="yaml-count">
+                <span className="yaml-flow-tag" title="Written in flow (JSON) style">
+                  [ ]
+                </span>
+              </span>
+            )}
+            <InlineListCell
+              node={node}
+              values={inlineList}
+              label={label}
+              onCommit={(vals) => onChange(setListItems(text, doc, node, vals))}
+            />
+          </>
+        ) : (
+          <span className="yaml-count">
+            {/* Flow (JSON) style is visible, because it is what the row's edits
+                will keep: adding here splices into the brackets, not new lines. */}
+            {isFlow(node) && (
+              <span className="yaml-flow-tag" title="Written in flow (JSON) style">
+                {node.kind === "seq" ? "[ ]" : "{ }"}
+              </span>
+            )}
+            {count}
+          </span>
+        )}
+
+        {/* The comment editor takes the row while it is open, since it is prose about
+            the whole entry rather than one more field on it. */}
+        {noting && (
+          <TextCommit
+            initial={note}
+            className="yaml-comment-input"
+            ariaLabel={`Comment on ${label}`}
+            placeholder="comment"
+            onCommit={(next) => {
+              setNoting(false);
+              if (next !== note) onChange(setComment(text, doc, node, next));
+            }}
+            onCancel={() => setNoting(false)}
+          />
+        )}
+
+        {/* A row that HAS a comment says so without being hovered — a config file's
+            comments are the half of it worth reading, and hiding them behind a hover
+            would be hiding the documentation. The text itself stays on the hover. */}
+        {note && !noting && canComment(doc, node) && (
+          <button
+            className="yaml-note"
+            title={`# ${note}`}
+            aria-label={`Comment on ${label}`}
+            onClick={() => setNoting(true)}
+            {...actMark}
+          >
+            #
+          </button>
+        )}
+
+        {/* An empty key (`key:`, `key: null`, `key: []`) offers both — its first
+            child is what decides whether it becomes a mapping or a list. A LIST
+            offers both too: "+ key" on it adds an item that IS a mapping.
+            An OPEN container shows its add affordance as the persistent row at
+            the end of its children instead, so the inline hover buttons here are
+            only for a collapsed container (whose children aren't shown) or an
+            empty placeholder (which has no child rows to host the add row).
+            They stay IN the row, next to what they grow — the gutter is for
+            actions on the entry itself. */}
+        {!(isContainer && isOpen) &&
+          !inlineList &&
+          (canAddChild(node, "key") || canAddChild(node, "item")) && (
+            <span className="yaml-actions yaml-actions-row">
+              <AddControls node={node} adding={adding} setAdding={setAdding} inline />
+            </span>
+          )}
+        {!node.editable && (
+          <span
+            className="yaml-locked"
+            title="The tree can't rewrite this safely (an anchor, a merge key, or a multi-line value) — edit it in Source."
+          >
+            source only
+          </span>
+        )}
+      </div>
+
+      {isContainer && isOpen && !inlineList && (
+        <YamlRows
+          nodes={node.children}
+          parent={node}
+          depth={depth + 1}
+          text={text}
+          doc={doc}
+          onChange={onChange}
+          collapsed={collapsed}
+          toggle={toggle}
+          adding={adding}
+          setAdding={setAdding}
+          cursorId={cursorId}
+          setCursor={setCursor}
+          // This row's own hover outranks an ancestor's: the innermost pointed-at
+          // container is the one whose block the pointer means.
+          marked={childMark}
+        />
+      )}
+
+      {/* The add form opens as the last child of the row it belongs to; when it
+          isn't open, an OPEN container shows a persistent add row in its place, so
+          every list / mapping carries a visible "+ item" / "+ key" at the point a
+          new entry lands — not only the hover buttons on its (often far-off)
+          header row. A collapsed container keeps just the header's hover buttons
+          (the form still opens from them, below the hidden children). */}
+      {adding?.startsWith(`${node.id}:`) ? (
+        <AddRow
+          depth={depth + 1}
+          kind={adding.endsWith(":item") ? "item" : "key"}
+          marked={childMark}
+          onCancel={() => setAdding(null)}
+          onAdd={(kind, key, type, value) => {
+            onChange(addChild(text, doc, node, kind, key, literalFor(type, value, doc.strict)));
+            setAdding(null);
+          }}
+          onCopyLast={copyLastAction(node, text, onChange, () => setAdding(null))}
+        />
+      ) : (
+        isContainer &&
+        isOpen &&
+        !inlineList && (
+          <AddControls
+            node={node}
+            depth={depth + 1}
+            adding={adding}
+            setAdding={setAdding}
+            // The add row is part of this block: it carries the block's mark, so
+            // a marked area colors contiguously instead of leaving it a white gap.
+            marked={childMark}
+          />
+        )
+      )}
+
+      {/* While a copy is held, HOVERING a row it can follow previews the landing
+          point: the same accent line the placed cursor row draws, right after
+          this entry's whole block — so the click's outcome is visible before
+          the click. Zero-height, so nothing below it shifts. */}
+      {pastable && pasteHover && cursorId !== node.id && clip && (
+        <div className="yaml-row yaml-paste-preview" style={rowPad(depth)} aria-hidden="true">
+          <span className="yaml-paste-preview-line" />
+        </div>
+      )}
+
+      {/* The paste cursor: a horizontal line at the very point the copied entry
+          would land — right AFTER this entry's whole block, as its next sibling
+          (the same spot duplicateNode inserts at) — with the button that lands
+          it. The buffer survives the paste, so one copy can be put down more
+          than once. */}
+      {pastable && cursorId === node.id && clip && (
+        <div className="yaml-row yaml-cursor-row" style={rowPad(depth)}>
+          <span className="yaml-caret yaml-caret-empty" aria-hidden="true" />
+          <button
+            className="yaml-add yaml-paste-here"
+            onClick={() => {
+              onChange(pasteAfter(text, node, clip));
+              setCursor(null);
+            }}
+          >
+            paste {clip.label} here
+          </button>
+          <button
+            className="yaml-act"
+            onClick={() => setCursor(null)}
+            title="Remove the paste cursor"
+            aria-label="Remove the paste cursor"
+          >
+            ×
+          </button>
+        </div>
+      )}
+    </>
+  );
+}
+
+/** The `+ key` / `+ item` buttons a node offers, given what it can actually take.
+ *  `inline` renders them into a row's hover actions; otherwise it is a standalone,
+ *  always-visible add row indented to `depth` (the children's level). */
+function AddControls({
+  node,
+  adding,
+  setAdding,
+  inline,
+  depth = 0,
+  marked = null,
+}: {
+  node: YamlNode;
+  adding: string | null;
+  setAdding: (v: string | null) => void;
+  inline?: boolean;
+  depth?: number;
+  /** The surrounding block's mark — the add row is part of the block. */
+  marked?: SubtreeMark;
+}) {
+  const open = adding?.startsWith(`${node.id}:`);
+  return (
+    <span
+      className={
+        inline
+          ? "yaml-add-inline"
+          : ["yaml-row", "yaml-row-add", markClass(marked)].filter(Boolean).join(" ")
+      }
+      style={inline ? undefined : rowPad(depth)}
+    >
+      {/* Stand in for the grip + caret columns every entry row leads with, so the
+          add buttons line up under the existing keys/items, not 32px to their
+          left. Inline (hover-action) controls need no alignment. */}
+      {!inline && (
+        <>
+          <span className="yaml-caret yaml-caret-empty" aria-hidden="true" />
+        </>
+      )}
+      {canAddChild(node, "key") && (
+        <button
+          className="yaml-add"
+          onClick={() => setAdding(open ? null : `${node.id}:key`)}
+          // On a list a key is not a key but an item that is a mapping — the shape a
+          // list of mappings is actually grown by (`- name: api`).
+          title={
+            node.kind === "seq"
+              ? "Add an item that is a mapping (- key: value)"
+              : "Add a key under this entry"
+          }
+        >
+          + key
+        </button>
+      )}
+      {canAddChild(node, "item") && (
+        <button
+          className="yaml-add"
+          onClick={() => setAdding(open ? null : `${node.id}:item`)}
+          title="Add an item to this list"
+        >
+          + item
+        </button>
+      )}
+    </span>
+  );
+}
+
+/** The tone a comma-line token would carry as its own row. An existing item is
+ *  toned by its NODE (so a quoted "8080" stays a string, exactly as its row
+ *  would show it); a token the file doesn't hold yet — mid-edit — is toned by
+ *  its text, which is what it will parse as when committed plain. */
+type ValTone = "string" | "number" | "boolean" | "null";
+
+function tokenTone(t: string, known: Map<string, ValTone>): ValTone {
+  const k = known.get(t);
+  if (k) return k;
+  if (t === "" || t === "null" || t === "~") return "null";
+  if (/^-?(\d+|\d*\.\d+)([eE][+-]?\d+)?$/.test(t) || /^0[xob][0-9a-fA-F_]+$/.test(t)) {
+    return "number";
+  }
+  if (/^(true|false|yes|no|on|off)$/i.test(t)) return "boolean";
+  return "string";
+}
+
+/**
+ * The comma-line editor for a scalar-only list, with overflow chevrons: when the
+ * joined values outgrow the field, ‹ › appear beside it and HOVERING one glides
+ * the content that way — the whole list is reachable without grabbing the caret
+ * or a scrollbar an input doesn't have. The glide stops on leave, and at the
+ * edge (whose chevron then reads disabled).
+ *
+ * The entries keep the value colors their own rows would give them. An input
+ * cannot color parts of itself, so the input's text is transparent (caret kept)
+ * and a pointer-blind MIRROR on top renders the same buffer token by token,
+ * scroll-synced — the classic highlighted-input overlay.
+ */
+function InlineListCell({
+  node,
+  values,
+  label,
+  onCommit,
+}: {
+  node: YamlNode;
+  values: string[];
+  label: string;
+  onCommit: (vals: string[]) => void;
+}) {
+  const ref = useRef<HTMLInputElement | null>(null);
+  const mirrorRef = useRef<HTMLSpanElement | null>(null);
+  const raf = useRef<number | null>(null);
+  const [can, setCan] = useState({ left: false, right: false });
+
+  // The draft buffer, exactly TextCommit's contract: commit on Enter/blur,
+  // revert on Escape — owned here because the mirror has to color it live.
+  const initial = values.join(", ");
+  const [buf, setBuf] = useState(initial);
+  const dirty = useRef(false);
+  useEffect(() => {
+    if (!dirty.current) setBuf(initial);
+  }, [initial]);
+  const commit = () => {
+    dirty.current = false;
+    if (buf !== initial) {
+      onCommit(buf.split(",").map((v) => v.trim()).filter((v) => v !== ""));
+    }
+  };
+
+  // Each existing item's tone, by its node — the same call its row would make.
+  const known = useMemo(() => {
+    const m = new Map<string, ValTone>();
+    for (const c of node.children) if (!m.has(c.value)) m.set(c.value, scalarType(c));
+    return m;
+  }, [node]);
+
+  const measure = useCallback(() => {
+    const el = ref.current;
+    if (!el) return;
+    // The mirror rides the input's scroll, or the colors would drift off the text.
+    if (mirrorRef.current) mirrorRef.current.scrollLeft = el.scrollLeft;
+    const max = el.scrollWidth - el.clientWidth;
+    const next = { left: el.scrollLeft > 0, right: el.scrollLeft < max - 1 };
+    setCan((cur) => (cur.left === next.left && cur.right === next.right ? cur : next));
+  }, []);
+
+  // Re-measure on everything that can move the overflow: typing (the buffer),
+  // a re-parse changing the values, scrolling, and the pane resizing.
+  useEffect(measure, [buf, measure]);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.addEventListener("scroll", measure);
+    const ro = typeof ResizeObserver !== "undefined" ? new ResizeObserver(measure) : null;
+    ro?.observe(el);
+    return () => {
+      el.removeEventListener("scroll", measure);
+      ro?.disconnect();
+    };
+  }, [measure]);
+
+  const stop = useCallback(() => {
+    if (raf.current != null) cancelAnimationFrame(raf.current);
+    raf.current = null;
+  }, []);
+  useEffect(() => stop, [stop]);
+
+  const glide = (dir: -1 | 1) => {
+    stop();
+    const step = () => {
+      const el = ref.current;
+      if (!el) return;
+      const before = el.scrollLeft;
+      el.scrollLeft = before + dir * 4;
+      measure();
+      // The edge: a disabled chevron swallows the mouseleave that would end the
+      // glide, so the glide ends itself when the scroll stops moving.
+      if (el.scrollLeft === before) return;
+      raf.current = requestAnimationFrame(step);
+    };
+    raf.current = requestAnimationFrame(step);
+  };
+
+  // The buffer, cut into pieces the mirror renders 1:1 — values keep their own
+  // spacing (the mirror must match the input to the character), commas stay
+  // muted like the tree's other punctuation.
+  const pieces = buf.match(/[^,]+|,/g) ?? [];
+
+  const shown = can.left || can.right;
+  return (
+    <span className="yaml-list-wrap">
+      {shown && (
+        <button
+          className="yaml-list-chevron"
+          disabled={!can.left}
+          onMouseEnter={() => glide(-1)}
+          onMouseLeave={stop}
+          tabIndex={-1}
+          aria-label={`Scroll ${label} left`}
+        >
+          ‹
+        </button>
+      )}
+      <span className="yaml-list-field">
+        <input
+          ref={ref}
+          className="yaml-value-input yaml-list-input"
+          value={buf}
+          aria-label={`Value of ${label}`}
+          onChange={(e) => {
+            dirty.current = true;
+            setBuf(e.target.value);
+          }}
+          onBlur={commit}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              commit();
+            } else if (e.key === "Escape") {
+              e.preventDefault();
+              dirty.current = false;
+              setBuf(initial);
+            }
+          }}
+        />
+        <span className="yaml-list-mirror" aria-hidden="true" ref={mirrorRef}>
+          {pieces.map((p, i) =>
+            p === "," ? (
+              <span key={i} className="yaml-colon">
+                ,
+              </span>
+            ) : (
+              <span key={i} className={`yaml-val-${tokenTone(p.trim(), known)}`}>
+                {p}
+              </span>
+            ),
+          )}
+        </span>
+      </span>
+      {shown && (
+        <button
+          className="yaml-list-chevron"
+          disabled={!can.right}
+          onMouseEnter={() => glide(1)}
+          onMouseLeave={stop}
+          tabIndex={-1}
+          aria-label={`Scroll ${label} right`}
+        >
+          ›
+        </button>
+      )}
+    </span>
+  );
+}
+
+/** The "copy the last item" action for a container, or undefined when there's
+ *  nothing to copy (not a list, empty, or the last entry owns a shared dash line
+ *  and so can't be duplicated on its own). */
+function copyLastAction(
+  container: YamlNode,
+  text: string,
+  onChange: (next: string) => void,
+  done: () => void,
+): (() => void) | undefined {
+  if (container.kind !== "seq") return undefined;
+  const last = container.children[container.children.length - 1];
+  if (!last || !last.deletable) return undefined;
+  return () => {
+    onChange(duplicateNode(text, last));
+    done();
+  };
+}
+
+/** The inline form a new entry is composed in: key (mappings only), type, value.
+ *  When adding an item to a non-empty list, `onCopyLast` offers the alternative of
+ *  duplicating the last entry (handy for a list of like-shaped mappings). */
+function AddRow({
+  depth,
+  kind,
+  onAdd,
+  onCancel,
+  onCopyLast,
+  marked = null,
+}: {
+  depth: number;
+  kind: "key" | "item";
+  onAdd: (kind: "key" | "item", key: string, type: YamlValueType, value: string) => void;
+  onCancel: () => void;
+  onCopyLast?: () => void;
+  /** The surrounding block's mark — the form row is part of the block. */
+  marked?: SubtreeMark;
+}) {
+  const [key, setKey] = useState("");
+  const [type, setType] = useState<YamlValueType>("text");
+  const [value, setValue] = useState("");
+  const first = useRef<HTMLInputElement | null>(null);
+  useEffect(() => {
+    first.current?.focus();
+  }, []);
+
+  // A container's value is its children, and null has no value to type.
+  const valueless = type === "map" || type === "seq" || type === "null";
+  const canAdd = kind === "item" || key.trim() !== "";
+  const submit = () => {
+    if (canAdd) onAdd(kind, key.trim(), type, value);
+  };
+
+  return (
+    <div
+      className={["yaml-row", "yaml-row-form", markClass(marked)].filter(Boolean).join(" ")}
+      style={rowPad(depth)}
+      onKeyDown={(e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          submit();
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          onCancel();
+        }
+      }}
+    >
+      <span className="yaml-caret yaml-caret-empty" aria-hidden="true" />
+      {/* Adding to a non-empty list: offer copying the last entry as the other
+          way to add one — for a list of like-shaped items (e.g. per-head configs)
+          it's far quicker to duplicate and tweak than to rebuild from scratch. */}
+      {kind === "item" && onCopyLast && (
+        <button
+          className="yaml-add yaml-add-copy"
+          onClick={onCopyLast}
+          title="Add a copy of the last item, to edit in place"
+        >
+          Copy last
+        </button>
+      )}
+      {kind === "key" ? (
+        <input
+          ref={first}
+          className="yaml-key-input"
+          value={key}
+          placeholder="key"
+          aria-label="New key"
+          onChange={(e) => setKey(e.target.value)}
+        />
+      ) : (
+        <span className="yaml-index">–</span>
+      )}
+      <select
+        className="yaml-type"
+        value={type}
+        aria-label="Value type"
+        onChange={(e) => setType(e.target.value as YamlValueType)}
+      >
+        <option value="text">text</option>
+        <option value="number">number</option>
+        <option value="boolean">boolean</option>
+        <option value="null">null</option>
+        <option value="map">map</option>
+        <option value="seq">list</option>
+      </select>
+      {type === "boolean" ? (
+        <select
+          className="yaml-type"
+          value={value || "true"}
+          aria-label="New value"
+          onChange={(e) => setValue(e.target.value)}
+        >
+          <option value="true">true</option>
+          <option value="false">false</option>
+        </select>
+      ) : (
+        !valueless && (
+          <input
+            ref={kind === "item" ? first : undefined}
+            className="yaml-value-input"
+            value={value}
+            placeholder="value"
+            aria-label="New value"
+            onChange={(e) => setValue(e.target.value)}
+          />
+        )
+      )}
+      <button className="yaml-add" onClick={submit} disabled={!canAdd}>
+        Add
+      </button>
+      <button className="yaml-act" onClick={onCancel} aria-label="Cancel">
+        ×
+      </button>
+    </div>
+  );
+}
+
+/** A scalar's value: an input (a textarea for a block scalar) that commits on
+ *  Enter/blur, or plain text when the node is one the tree won't rewrite. */
+function ValueCell({
+  node,
+  label,
+  onCommit,
+}: {
+  node: YamlNode;
+  label: string;
+  onCommit: (next: string) => void;
+}) {
+  if (!node.editable) {
+    return (
+      <span className="yaml-value yaml-value-locked" title={node.raw}>
+        {node.raw || node.value}
+      </span>
+    );
+  }
+  if (node.style === "block") {
+    return (
+      <BlockCell
+        key={node.id}
+        initial={node.value}
+        tag={node.raw}
+        ariaLabel={`Value of ${label}`}
+        onCommit={onCommit}
+      />
+    );
+  }
+  return (
+    <TextCommit
+      initial={node.value}
+      className={`yaml-value-input yaml-val-${scalarType(node)}`}
+      ariaLabel={`Value of ${label}`}
+      placeholder={node.style === "empty" ? "null" : undefined}
+      onCommit={onCommit}
+    />
+  );
+}
+
+/** A multi-line block scalar (`|`/`>`): committed on blur or Ctrl+Enter, since
+ *  plain Enter has to keep inserting newlines. */
+function BlockCell({
+  initial,
+  tag,
+  ariaLabel,
+  onCommit,
+}: {
+  initial: string;
+  /** The block header as written (`|`, `>-`, …), shown so the style is visible. */
+  tag: string;
+  ariaLabel: string;
+  onCommit: (next: string) => void;
+}) {
+  const [buf, setBuf] = useState(initial);
+  const dirty = useRef(false);
+  useEffect(() => {
+    if (!dirty.current) setBuf(initial);
+  }, [initial]);
+
+  return (
+    <span className="yaml-block">
+      <span className="yaml-block-tag">{tag}</span>
+      <textarea
+        className="yaml-block-input"
+        value={buf}
+        rows={Math.min(12, Math.max(2, buf.split("\n").length))}
+        aria-label={ariaLabel}
+        onChange={(e) => {
+          dirty.current = true;
+          setBuf(e.target.value);
+        }}
+        onBlur={() => {
+          dirty.current = false;
+          if (buf !== initial) onCommit(buf);
+        }}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
+            e.preventDefault();
+            e.currentTarget.blur();
+          } else if (e.key === "Escape") {
+            e.preventDefault();
+            dirty.current = false;
+            setBuf(initial);
+          }
+        }}
+      />
+    </span>
+  );
+}
+
+/**
+ * A single-line input that commits on Enter/blur and reverts on Escape. It holds
+ * its own buffer rather than driving `onChange` per keystroke: every commit
+ * re-encodes the value into the file (quoting it when it must), and doing that on
+ * each keypress would rewrite the text — and move the caret — under the typist.
+ */
+function TextCommit({
+  initial,
+  className,
+  ariaLabel,
+  placeholder,
+  onCommit,
+  onCancel,
+}: {
+  initial: string;
+  className: string;
+  ariaLabel: string;
+  placeholder?: string;
+  onCommit: (next: string) => void;
+  onCancel?: () => void;
+}) {
+  const [buf, setBuf] = useState(initial);
+  const dirty = useRef(false);
+  useEffect(() => {
+    if (!dirty.current) setBuf(initial);
+  }, [initial]);
+
+  return (
+    <input
+      className={className}
+      value={buf}
+      placeholder={placeholder}
+      aria-label={ariaLabel}
+      autoFocus={!!onCancel}
+      onChange={(e) => {
+        dirty.current = true;
+        setBuf(e.target.value);
+      }}
+      onBlur={() => {
+        dirty.current = false;
+        if (buf !== initial) onCommit(buf);
+        else onCancel?.();
+      }}
+      onKeyDown={(e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          dirty.current = false;
+          if (buf !== initial) onCommit(buf);
+          else onCancel?.();
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          dirty.current = false;
+          setBuf(initial);
+          onCancel?.();
+        }
+      }}
+    />
+  );
+}
diff --git a/src/components/embed/deck/DeckAnimate.tsx b/src/components/embed/deck/DeckAnimate.tsx
new file mode 100644
index 0000000..838b8e4
--- /dev/null
+++ b/src/components/embed/deck/DeckAnimate.tsx
@@ -0,0 +1,302 @@
+/**
+ * Animate mode — deliberately a *separate* mode from design, as the feature was
+ * specified: the design canvas never touches animation, and this panel never
+ * moves anything.
+ *
+ * Two orthogonal axes live here, and the distinction is worth keeping straight:
+ *
+ * **Builds** reveal objects *within* a slide. Each object gets a step (0 =
+ * visible on entry) and an effect. `Stagger` assigns consecutive steps to the
+ * selection in paint order, which is the one-click "reveal this list a line at a
+ * time" the list-style model exists to make cheap.
+ *
+ * **Interstitials** are the headline: a GIF that plays *between* this slide and
+ * the next, occupying its own stop in the presentation. A TeX-generated PDF
+ * cannot carry animation at all, so without this the author has to leave the deck
+ * and alt-tab to a video player mid-talk. It is not a transition effect and not
+ * an object — it never composites onto a page.
+ *
+ * **Transitions** are the third, cosmetic axis: how one page replaces another.
+ */
+
+import { open } from "@tauri-apps/plugin-dialog";
+import {
+  type BuildEffect,
+  type ObjectList,
+  type Slide,
+  type Transition,
+  maxBuildStep,
+  newInterstitialId,
+  stagger,
+  updateObjects,
+} from "../../../lib/viewers/deck/model";
+
+export interface DeckAnimateProps {
+  slide: Slide;
+  selection: ReadonlySet<string>;
+  onObjectsChange: (objects: ObjectList) => void;
+  onSlideChange: (patch: (s: Slide) => Slide) => void;
+  /** Build step being previewed on the stage. */
+  previewStep: number;
+  onPreviewStep: (step: number) => void;
+  /** Turns an absolute path into one relative to the deck, for storage. */
+  toDeckRelative: (absolute: string) => string;
+}
+
+const EFFECTS: Array<{ id: BuildEffect; label: string }> = [
+  { id: "none", label: "Appear" },
+  { id: "fade", label: "Fade in" },
+  { id: "rise", label: "Rise" },
+  { id: "scale", label: "Scale" },
+  { id: "wipe", label: "Wipe" },
+  { id: "draw", label: "Draw" },
+];
+
+export function DeckAnimate({
+  slide,
+  selection,
+  onObjectsChange,
+  onSlideChange,
+  previewStep,
+  onPreviewStep,
+  toDeckRelative,
+}: DeckAnimateProps) {
+  const ids = [...selection];
+  const sel = slide.objects.filter((o) => selection.has(o.id));
+  const steps = maxBuildStep(slide);
+  const after = slide.after;
+
+  const pickGif = async () => {
+    const chosen = await open({
+      multiple: false,
+      filters: [{ name: "Animated GIF", extensions: ["gif"] }],
+    });
+    if (typeof chosen !== "string") return;
+    onSlideChange((s) => ({
+      ...s,
+      after: {
+        id: s.after?.id ?? newInterstitialId(),
+        src: toDeckRelative(chosen),
+        fit: s.after?.fit ?? "contain",
+        background: s.after?.background ?? "#000000",
+        advance: s.after?.advance ?? { on: "manual" },
+        poster: s.after?.poster ?? 0,
+      },
+    }));
+  };
+
+  return (
+    <div className="deck-inspector deck-animate">
+      {/* --- build steps --- */}
+      <div className="deck-inspector-head">Builds</div>
+
+      {sel.length === 0 ? (
+        <p className="deck-inspector-empty">
+          Select objects to give them a build step. Step 0 is visible when the slide
+          opens.
+        </p>
+      ) : (
+        <>
+          <div className="deck-field-row">
+            <label className="deck-field deck-field-narrow">
+              <span>Step</span>
+              <input
+                type="number"
+                min={0}
+                value={sel[0].build?.step ?? 0}
+                onChange={(e) => {
+                  const step = Math.max(0, Math.round(Number(e.target.value)));
+                  if (!Number.isFinite(step)) return;
+                  onObjectsChange(
+                    updateObjects(slide.objects, ids, (o) => ({
+                      ...o,
+                      build: { step, effect: o.build?.effect ?? "fade" },
+                    })),
+                  );
+                }}
+              />
+            </label>
+            <label className="deck-field">
+              <span>Effect</span>
+              <select
+                value={sel[0].build?.effect ?? "fade"}
+                onChange={(e) =>
+                  onObjectsChange(
+                    updateObjects(slide.objects, ids, (o) => ({
+                      ...o,
+                      build: { step: o.build?.step ?? 0, effect: e.target.value as BuildEffect },
+                    })),
+                  )
+                }
+              >
+                {EFFECTS.map((f) => (
+                  <option key={f.id} value={f.id}>
+                    {f.label}
+                  </option>
+                ))}
+              </select>
+            </label>
+          </div>
+
+          <div className="deck-field-row">
+            <button
+              className="deck-inspector-btn"
+              onClick={() => onObjectsChange(stagger(slide.objects, ids, 1))}
+              title="Give each selected object its own step, in paint order"
+            >
+              Stagger
+            </button>
+            <button
+              className="deck-inspector-btn"
+              onClick={() =>
+                onObjectsChange(
+                  updateObjects(slide.objects, ids, (o) => ({ ...o, build: undefined })),
+                )
+              }
+              title="Show these from the start"
+            >
+              Clear
+            </button>
+          </div>
+        </>
+      )}
+
+      {/* --- preview --- */}
+      <div className="deck-field">
+        <span>
+          Preview step {previewStep} of {steps}
+        </span>
+        <input
+          type="range"
+          min={0}
+          max={Math.max(0, steps)}
+          value={Math.min(previewStep, steps)}
+          onChange={(e) => onPreviewStep(Number(e.target.value))}
+        />
+      </div>
+
+      {/* --- transition --- */}
+      <div className="deck-inspector-head">Transition</div>
+      <label className="deck-field">
+        <span>Leaving this slide</span>
+        <select
+          value={slide.transition}
+          onChange={(e) =>
+            onSlideChange((s) => ({ ...s, transition: e.target.value as Transition }))
+          }
+        >
+          <option value="none">None</option>
+          <option value="fade">Fade</option>
+          <option value="push">Push</option>
+          <option value="wipe">Wipe</option>
+        </select>
+      </label>
+
+      {/* --- interstitial --- */}
+      <div className="deck-inspector-head">Animation after this slide</div>
+      <p className="deck-inspector-empty">
+        A GIF that plays between this slide and the next, as its own step. A PDF
+        cannot hold animation, so this is where it lives.
+      </p>
+
+      {!after ? (
+        <button className="deck-inspector-btn" onClick={() => void pickGif()}>
+          Add a GIF…
+        </button>
+      ) : (
+        <>
+          <div className="deck-animate-file" title={after.src}>
+            {after.src.split("/").pop()}
+          </div>
+          <div className="deck-field-row">
+            <label className="deck-field">
+              <span>Fit</span>
+              <select
+                value={after.fit}
+                onChange={(e) =>
+                  onSlideChange((s) => ({
+                    ...s,
+                    after: s.after && { ...s.after, fit: e.target.value as "contain" | "cover" },
+                  }))
+                }
+              >
+                <option value="contain">Fit (letterbox)</option>
+                <option value="cover">Fill (crop)</option>
+              </select>
+            </label>
+            <label className="deck-field deck-field-color">
+              <span>Back</span>
+              <input
+                type="color"
+                value={after.background}
+                onChange={(e) =>
+                  onSlideChange((s) => ({
+                    ...s,
+                    after: s.after && { ...s.after, background: e.target.value },
+                  }))
+                }
+              />
+            </label>
+          </div>
+          <label className="deck-field">
+            <span>Then</span>
+            <select
+              value={after.advance.on}
+              onChange={(e) => {
+                const on = e.target.value as "manual" | "end" | "end-after";
+                onSlideChange((s) => ({
+                  ...s,
+                  after:
+                    s.after &&
+                    { ...s.after, advance: on === "end-after" ? { on, loops: 2 } : { on } },
+                }));
+              }}
+            >
+              <option value="manual">Loop until I advance</option>
+              <option value="end">Play once, then continue</option>
+              <option value="end-after">Play N times, then continue</option>
+            </select>
+          </label>
+          {after.advance.on === "end-after" && (
+            <label className="deck-field deck-field-narrow">
+              <span>Times</span>
+              <input
+                type="number"
+                min={1}
+                value={after.advance.loops}
+                onChange={(e) => {
+                  const loops = Math.max(1, Math.round(Number(e.target.value)));
+                  if (!Number.isFinite(loops)) return;
+                  onSlideChange((s) => ({
+                    ...s,
+                    after: s.after && { ...s.after, advance: { on: "end-after", loops } },
+                  }));
+                }}
+              />
+            </label>
+          )}
+          <label className="deck-field deck-field-narrow">
+            <span>Poster frame</span>
+            <input
+              type="number"
+              min={0}
+              value={after.poster}
+              title="The frame the PDF export writes in place of the animation"
+              onChange={(e) => {
+                const poster = Math.max(0, Math.round(Number(e.target.value)));
+                if (!Number.isFinite(poster)) return;
+                onSlideChange((s) => ({ ...s, after: s.after && { ...s.after, poster } }));
+              }}
+            />
+          </label>
+          <button
+            className="deck-inspector-btn"
+            onClick={() => onSlideChange((s) => ({ ...s, after: undefined }))}
+          >
+            Remove animation
+          </button>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/DeckAudienceApp.tsx b/src/components/embed/deck/DeckAudienceApp.tsx
new file mode 100644
index 0000000..72d12c7
--- /dev/null
+++ b/src/components/embed/deck/DeckAudienceApp.tsx
@@ -0,0 +1,300 @@
+/**
+ * The **audience** window of the dual-window presenter: the OS window that goes
+ * on the projector while the speaker keeps the notes/timer view on the laptop.
+ *
+ * It is deliberately the *dumb* half. It owns no navigation state — the stop and
+ * the blank screen arrive from the presenter window and are rendered as given —
+ * because two indices for one talk is exactly how the two displays end up a
+ * slide apart in front of a room. Keys pressed here (the speaker may well have
+ * focus on this window, or be using a clicker bound to it) are forwarded as
+ * *requests* and come back as state.
+ *
+ * It loads its own heavy assets — base PDF, images, GIF frames — from the deck's
+ * path over the ordinary confined file commands, so nothing large ever crosses
+ * as an event payload. The deck itself does arrive as its serialized sidecar,
+ * because the presenter window may hold edits not yet autosaved.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { emit, listen } from "@tauri-apps/api/event";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import {
+  useSettingsStore,
+  applyTheme,
+  THEME_CHANGED_EVENT,
+} from "../../../stores/settings";
+import {
+  type NavAction,
+  type PresentSeed,
+  type PresentState,
+  PRESENT_CLOSED,
+  PRESENT_NAV,
+  PRESENT_READY,
+  keyToAction,
+  presentSeedEvent,
+  presentStateEvent,
+} from "../../../lib/viewers/deck/present";
+import { type Deck, type Slide, type Stop, sequence } from "../../../lib/viewers/deck/model";
+import { parseDeck, pdfPathForDeck } from "../../../lib/viewers/deck/sidecar";
+import { type TextMetrics, loadMetrics } from "../../../lib/viewers/deck/fonts";
+import { loadBase } from "./deckBase";
+import { dirOf, interstitialsOf, resolveRel, useDeckGifs, useDeckImages } from "./deckAssets";
+import { InterstitialView, PresentedSlide } from "./DeckSlideView";
+
+/** How often to re-announce readiness until a seed lands. The presenter window
+ *  may still be mounting its listener when this window first asks. */
+const READY_RETRY_MS = 400;
+
+export interface DeckAudienceAppProps {
+  /** This window's Tauri label, from `?present=` — the seed/state channels' namespace. */
+  label: string;
+}
+
+export function DeckAudienceApp({ label }: DeckAudienceAppProps) {
+  const loadSettings = useSettingsStore((s) => s.load);
+
+  const [seed, setSeed] = useState<PresentSeed | null>(null);
+  const [state, setState] = useState<PresentState>({ index: 0, blank: null });
+  const [deck, setDeck] = useState<Deck | null>(null);
+  const [doc, setDoc] = useState<PDFDocumentProxy | null>(null);
+  const [metrics, setMetrics] = useState<TextMetrics | null>(null);
+
+  // Theme: this window is its own JS runtime with its own settings store, so it
+  // loads them itself and follows the main window's live theme broadcast — the
+  // same bargain `DetachedApp` strikes. Zoom is deliberately NOT applied: a
+  // projector surface is sized by the slide, not by the editor's zoom.
+  useEffect(() => {
+    void loadSettings({ skipZoom: true });
+  }, [loadSettings]);
+
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    listen<string>(THEME_CHANGED_EVENT, (e) => applyTheme(e.payload))
+      .then((fn) => {
+        if (cancelled) fn();
+        else unlisten = fn;
+      })
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, []);
+
+  useEffect(() => {
+    let live = true;
+    void loadMetrics().then((m) => {
+      if (live) setMetrics(m);
+    });
+    return () => {
+      live = false;
+    };
+  }, []);
+
+  // --- the link ------------------------------------------------------------
+
+  const seededRef = useRef(false);
+
+  useEffect(() => {
+    let unlistenSeed: (() => void) | undefined;
+    let unlistenState: (() => void) | undefined;
+    let cancelled = false;
+
+    void listen<PresentSeed>(presentSeedEvent(label), (e) => {
+      seededRef.current = true;
+      setSeed(e.payload);
+      setState({ index: e.payload.index, blank: e.payload.blank });
+    }).then((fn) => {
+      if (cancelled) fn();
+      else unlistenSeed = fn;
+    });
+
+    void listen<PresentState>(presentStateEvent(label), (e) => setState(e.payload)).then((fn) => {
+      if (cancelled) fn();
+      else unlistenState = fn;
+    });
+
+    // Ask, and keep asking until answered: this window and the presenter's
+    // listener race on open, and a dropped first request would leave a black
+    // projector with no way back.
+    void emit(PRESENT_READY, { label });
+    const t = setInterval(() => {
+      if (seededRef.current) return;
+      void emit(PRESENT_READY, { label });
+    }, READY_RETRY_MS);
+
+    return () => {
+      cancelled = true;
+      clearInterval(t);
+      unlistenSeed?.();
+      unlistenState?.();
+    };
+  }, [label]);
+
+  // Tell the presenter window when this one is closed from the WM, so it drops
+  // back to the single-display presenter instead of streaming at a dead window.
+  // (A close driven from the presenter side `destroy()`s, which bypasses this —
+  // it already knows.)
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    void getCurrentWindow()
+      .onCloseRequested(() => {
+        void emit(PRESENT_CLOSED, { label });
+      })
+      .then((fn) => {
+        if (cancelled) fn();
+        else unlisten = fn;
+      });
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, [label]);
+
+  const send = useCallback(
+    (action: NavAction) => {
+      void emit(PRESENT_NAV, { label, action });
+    },
+    [label],
+  );
+
+  // --- deck + base plate ---------------------------------------------------
+
+  useEffect(() => {
+    if (!seed) return;
+    const parsed = parseDeck(seed.deck);
+    if (parsed.error) return;
+    setDeck(parsed.deck);
+  }, [seed]);
+
+  useEffect(() => {
+    if (!seed || !deck) return;
+    let cancelled = false;
+    let opened: PDFDocumentProxy | null = null;
+    const dir = dirOf(seed.path);
+    const basePath = resolveRel(dir, deck.base ?? pdfPathForDeck(seed.path));
+    void (async () => {
+      try {
+        const base = await loadBase(basePath, seed.scope);
+        opened = base.doc;
+      } catch {
+        // No plate: the layers still present. The presenter window shows the
+        // same deck and reports the problem there; a talk in progress should
+        // not gain an error banner on the projector.
+        return;
+      }
+      if (cancelled) {
+        opened.destroy();
+        return;
+      }
+      setDoc(opened);
+    })();
+    return () => {
+      cancelled = true;
+      opened?.destroy();
+      setDoc(null);
+    };
+    // Re-anchoring is the presenter window's job; this one only needs the pages.
+    // Keyed on the resolved base path so a re-seed with the same plate does not
+    // tear down and re-open the document mid-talk.
+  }, [seed?.path, seed?.scope, deck?.base]);
+
+  const interstitials = useMemo(() => interstitialsOf(deck), [deck]);
+  const { assets } = useDeckImages(deck, seed?.path ?? "", seed?.scope ?? null);
+  const gifs = useDeckGifs(interstitials, seed?.path ?? "", seed?.scope ?? null);
+
+  // --- keys ----------------------------------------------------------------
+
+  const gotoRef = useRef("");
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Enter") {
+        if (gotoRef.current) {
+          send({ kind: "goto", slide: Number(gotoRef.current) - 1 });
+          gotoRef.current = "";
+        }
+        return;
+      }
+      const action = keyToAction(e.key);
+      if (!action) {
+        gotoRef.current = "";
+        return;
+      }
+      if (action.kind === "digit") {
+        gotoRef.current = (gotoRef.current + action.digit).slice(-4);
+        return;
+      }
+      e.preventDefault();
+      send(action);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [send]);
+
+  // --- render --------------------------------------------------------------
+
+  const stops = useMemo(() => (deck ? sequence(deck) : []), [deck]);
+  const stop: Stop | undefined = stops[state.index];
+  const slide: Slide | undefined = stop ? deck?.slides[stop.slide] : undefined;
+
+  // The transition belongs to the slide being LEFT, and must be known during the
+  // render that first shows the new one — a state write would land a frame late,
+  // which is one frame of un-transitioned slide.
+  const prevSlideRef = useRef<number | null>(null);
+  const transitionRef = useRef<string>("none");
+  if (deck && stop && prevSlideRef.current !== stop.slide) {
+    const from = prevSlideRef.current;
+    transitionRef.current =
+      from != null && deck.slides[from] ? deck.slides[from].transition : "none";
+    prevSlideRef.current = stop.slide;
+  }
+
+  if (!deck || !stop) {
+    return (
+      <div className="deck-presenter deck-audience">
+        <div className="deck-presenter-main">
+          <div className="deck-presenter-fit deck-presenter-loading">
+            Waiting for the presentation…
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="deck-presenter deck-audience">
+      <div className="deck-presenter-main">
+        <div className="presentation-host deck-presenter-stage">
+          {stop.kind === "interstitial" && slide?.after ? (
+            <InterstitialView
+              gif={gifs.get(slide.after.id)}
+              fit={slide.after.fit}
+              background={slide.after.background}
+              advance={slide.after.advance}
+              onEnded={() => send({ kind: "next" })}
+            />
+          ) : (
+            slide && (
+              <PresentedSlide
+                key={slide.id}
+                slide={slide}
+                step={stop.kind === "slide" ? stop.step : 0}
+                doc={doc}
+                pageWidth={deck.pageWidth}
+                pageHeight={deck.pageHeight}
+                metrics={metrics}
+                assets={assets}
+                transition={transitionRef.current}
+              />
+            )
+          )}
+        </div>
+        {state.blank && <div className={`deck-presenter-blank is-${state.blank}`} />}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/DeckInspector.tsx b/src/components/embed/deck/DeckInspector.tsx
new file mode 100644
index 0000000..33d4742
--- /dev/null
+++ b/src/components/embed/deck/DeckInspector.tsx
@@ -0,0 +1,441 @@
+/**
+ * The property panel for the current selection.
+ *
+ * It edits through the same pure `updateObjects` op the stage's gestures use, so
+ * there is one mutation path and one history entry per change however the change
+ * was made. Fields are shown per *kind*: a mixed selection gets only the
+ * properties every member actually has, rather than a form whose controls
+ * silently apply to some objects and not others.
+ */
+
+import type {
+  DeckObject,
+  FontFamily,
+  ImageObject,
+  ListKind,
+  ObjectList,
+  ShapeKind,
+  TextAlign,
+} from "../../../lib/viewers/deck/model";
+import { updateObjects } from "../../../lib/viewers/deck/model";
+
+export interface DeckInspectorProps {
+  objects: ObjectList;
+  selection: ReadonlySet<string>;
+  onChange: (next: ObjectList) => void;
+  /** Opens the icon picker to replace the selected icon. */
+  onPickIcon: () => void;
+  /** Opens a TeX-figure image's `.tex` source as its own tab. */
+  onEditTex?: (obj: ImageObject) => void;
+  /** Recompiles a TeX-figure image's source and re-rasterizes it onto the slide. */
+  onRecompileTex?: (obj: ImageObject) => void;
+  /** Ids of objects currently (re)compiling. */
+  texBusyIds?: ReadonlySet<string>;
+}
+
+/**
+ * The value every selected object agrees on, or `undefined` if they differ —
+ * which is also what a control renders as "(differs)" rather than silently
+ * showing the first object's value and applying it to all of them on focus.
+ *
+ * Generic over the element type so it can take an already-narrowed array
+ * (`texts`, `shapes`) without the getter widening back to `DeckObject`.
+ */
+function shared<O, T>(objs: readonly O[], get: (o: O) => T): T | undefined {
+  if (objs.length === 0) return undefined;
+  const first = get(objs[0]);
+  return objs.every((o) => get(o) === first) ? first : undefined;
+}
+
+export function DeckInspector({
+  objects,
+  selection,
+  onChange,
+  onPickIcon,
+  onEditTex,
+  onRecompileTex,
+  texBusyIds,
+}: DeckInspectorProps) {
+  const sel = objects.filter((o) => selection.has(o.id));
+  if (sel.length === 0) {
+    return (
+      <div className="deck-inspector">
+        <p className="deck-inspector-empty">Select something to edit its properties.</p>
+      </div>
+    );
+  }
+
+  const ids = sel.map((o) => o.id);
+  const patch = (fn: (o: DeckObject) => DeckObject) => onChange(updateObjects(objects, ids, fn));
+
+  const texts = sel.filter((o): o is Extract<DeckObject, { kind: "text" }> => o.kind === "text");
+  const shapes = sel.filter((o): o is Extract<DeckObject, { kind: "shape" }> => o.kind === "shape");
+  const icons = sel.filter((o): o is Extract<DeckObject, { kind: "icon" }> => o.kind === "icon");
+  const images = sel.filter((o): o is Extract<DeckObject, { kind: "image" }> => o.kind === "image");
+  const allText = texts.length === sel.length;
+  const allShape = shapes.length === sel.length;
+  const allIcon = icons.length === sel.length;
+  const allImage = images.length === sel.length;
+
+  return (
+    <div className="deck-inspector">
+      <div className="deck-inspector-head">
+        {sel.length === 1 ? sel[0].kind : `${sel.length} objects`}
+      </div>
+
+      {/* --- text --- */}
+      {allText && (
+        <>
+          <label className="deck-field deck-field-wide">
+            <span>Text</span>
+            <textarea
+              rows={3}
+              value={shared(texts, (o) => (o as typeof texts[number]).text) ?? ""}
+              placeholder={sel.length > 1 ? "(differs)" : ""}
+              onChange={(e) =>
+                patch((o) => (o.kind === "text" ? { ...o, text: e.target.value } : o))
+              }
+            />
+          </label>
+
+          <div className="deck-field-row">
+            <label className="deck-field">
+              <span>Font</span>
+              <select
+                value={shared(texts, (o) => o.style.family) ?? ""}
+                onChange={(e) =>
+                  patch((o) =>
+                    o.kind === "text"
+                      ? { ...o, style: { ...o.style, family: e.target.value as FontFamily } }
+                      : o,
+                  )
+                }
+              >
+                <option value="sans">Helvetica</option>
+                <option value="serif">Times</option>
+                <option value="mono">Courier</option>
+              </select>
+            </label>
+            <label className="deck-field deck-field-narrow">
+              <span>Size</span>
+              <input
+                type="number"
+                min={1}
+                max={400}
+                value={shared(texts, (o) => o.style.size) ?? ""}
+                onChange={(e) => {
+                  const size = Number(e.target.value);
+                  if (!Number.isFinite(size) || size <= 0) return;
+                  patch((o) => (o.kind === "text" ? { ...o, style: { ...o.style, size } } : o));
+                }}
+              />
+            </label>
+          </div>
+
+          <div className="deck-field-row">
+            <button
+              className={`deck-toggle${shared(texts, (o) => o.style.bold) ? " active" : ""}`}
+              onClick={() =>
+                patch((o) =>
+                  o.kind === "text" ? { ...o, style: { ...o.style, bold: !o.style.bold } } : o,
+                )
+              }
+              title="Bold"
+            >
+              <b>B</b>
+            </button>
+            <button
+              className={`deck-toggle${shared(texts, (o) => o.style.italic) ? " active" : ""}`}
+              onClick={() =>
+                patch((o) =>
+                  o.kind === "text" ? { ...o, style: { ...o.style, italic: !o.style.italic } } : o,
+                )
+              }
+              title="Italic"
+            >
+              <i>I</i>
+            </button>
+            {(["left", "center", "right"] as TextAlign[]).map((a) => (
+              <button
+                key={a}
+                className={`deck-toggle${shared(texts, (o) => o.style.align) === a ? " active" : ""}`}
+                onClick={() =>
+                  patch((o) => (o.kind === "text" ? { ...o, style: { ...o.style, align: a } } : o))
+                }
+                title={`Align ${a}`}
+              >
+                {a === "left" ? "⬅" : a === "center" ? "↔" : "➡"}
+              </button>
+            ))}
+            <label className="deck-field deck-field-color">
+              <input
+                type="color"
+                value={shared(texts, (o) => o.style.color) ?? "#111111"}
+                onChange={(e) =>
+                  patch((o) =>
+                    o.kind === "text" ? { ...o, style: { ...o.style, color: e.target.value } } : o,
+                  )
+                }
+                title="Text colour"
+              />
+            </label>
+          </div>
+
+          <div className="deck-field-row">
+            <label className="deck-field">
+              <span>List</span>
+              <select
+                value={shared(texts, (o) => o.list?.kind ?? "none") ?? "none"}
+                onChange={(e) => {
+                  const v = e.target.value;
+                  patch((o) =>
+                    o.kind === "text"
+                      ? v === "none"
+                        ? { ...o, list: undefined }
+                        : { ...o, list: { kind: v as ListKind, start: o.list?.start ?? 1 } }
+                      : o,
+                  );
+                }}
+              >
+                <option value="none">None</option>
+                <option value="bullet">Bullets</option>
+                <option value="number">1. 2. 3.</option>
+                <option value="alpha">a. b. c.</option>
+                <option value="roman">i. ii. iii.</option>
+              </select>
+            </label>
+          </div>
+        </>
+      )}
+
+      {/* --- shape --- */}
+      {allShape && (
+        <>
+          <label className="deck-field">
+            <span>Shape</span>
+            <select
+              value={shared(shapes, (o) => o.shape) ?? ""}
+              onChange={(e) =>
+                patch((o) =>
+                  o.kind === "shape" ? { ...o, shape: e.target.value as ShapeKind } : o,
+                )
+              }
+            >
+              <option value="rect">Rectangle</option>
+              <option value="roundrect">Rounded rectangle</option>
+              <option value="ellipse">Ellipse</option>
+              <option value="line">Line</option>
+              <option value="arrow">Arrow</option>
+              <option value="callout">Callout</option>
+            </select>
+          </label>
+          <div className="deck-field-row">
+            <label className="deck-field deck-field-color">
+              <span>Fill</span>
+              <input
+                type="color"
+                value={shared(shapes, (o) => o.fill ?? "#ffffff") ?? "#ffffff"}
+                onChange={(e) =>
+                  patch((o) => (o.kind === "shape" ? { ...o, fill: e.target.value } : o))
+                }
+              />
+            </label>
+            <button
+              className="deck-toggle"
+              onClick={() => patch((o) => (o.kind === "shape" ? { ...o, fill: undefined } : o))}
+              title="No fill"
+            >
+              ⃠
+            </button>
+            <label className="deck-field deck-field-color">
+              <span>Line</span>
+              <input
+                type="color"
+                value={shared(shapes, (o) => o.stroke) ?? "#111111"}
+                onChange={(e) =>
+                  patch((o) => (o.kind === "shape" ? { ...o, stroke: e.target.value } : o))
+                }
+              />
+            </label>
+            <label className="deck-field deck-field-narrow">
+              <span>Width</span>
+              <input
+                type="number"
+                min={0}
+                step={0.5}
+                value={shared(shapes, (o) => o.strokeWidth) ?? ""}
+                onChange={(e) => {
+                  const strokeWidth = Number(e.target.value);
+                  if (!Number.isFinite(strokeWidth) || strokeWidth < 0) return;
+                  patch((o) => (o.kind === "shape" ? { ...o, strokeWidth } : o));
+                }}
+              />
+            </label>
+          </div>
+          {shapes.some((o) => o.shape === "line" || o.shape === "arrow") && (
+            <div className="deck-field-row">
+              <label className="deck-field">
+                <span>Start</span>
+                <select
+                  value={shared(shapes, (o) => o.tail ?? "none") ?? "none"}
+                  onChange={(e) =>
+                    patch((o) =>
+                      o.kind === "shape"
+                        ? { ...o, tail: e.target.value as typeof o.tail }
+                        : o,
+                    )
+                  }
+                >
+                  <option value="none">None</option>
+                  <option value="arrow">Arrow</option>
+                  <option value="dot">Dot</option>
+                  <option value="bar">Bar</option>
+                </select>
+              </label>
+              <label className="deck-field">
+                <span>End</span>
+                <select
+                  value={shared(shapes, (o) => o.head ?? "none") ?? "none"}
+                  onChange={(e) =>
+                    patch((o) =>
+                      o.kind === "shape"
+                        ? { ...o, head: e.target.value as typeof o.head }
+                        : o,
+                    )
+                  }
+                >
+                  <option value="none">None</option>
+                  <option value="arrow">Arrow</option>
+                  <option value="dot">Dot</option>
+                  <option value="bar">Bar</option>
+                </select>
+              </label>
+            </div>
+          )}
+        </>
+      )}
+
+      {/* --- icon --- */}
+      {allIcon && (
+        <div className="deck-field-row">
+          <button className="deck-inspector-btn" onClick={onPickIcon}>
+            Change icon…
+          </button>
+          <label className="deck-field deck-field-color">
+            <span>Colour</span>
+            <input
+              type="color"
+              value={shared(icons, (o) => o.color) ?? "#111111"}
+              onChange={(e) =>
+                patch((o) => (o.kind === "icon" ? { ...o, color: e.target.value } : o))
+              }
+            />
+          </label>
+          <label className="deck-field deck-field-narrow">
+            <span>Weight</span>
+            <input
+              type="number"
+              min={0}
+              step={0.5}
+              value={shared(icons, (o) => o.strokeWidth) ?? ""}
+              onChange={(e) => {
+                const strokeWidth = Number(e.target.value);
+                if (!Number.isFinite(strokeWidth) || strokeWidth < 0) return;
+                patch((o) => (o.kind === "icon" ? { ...o, strokeWidth } : o));
+              }}
+            />
+          </label>
+        </div>
+      )}
+
+      {/* --- image --- */}
+      {allImage && (
+        <label className="deck-field">
+          <span>Fit</span>
+          <select
+            value={shared(images, (o) => o.fit) ?? ""}
+            onChange={(e) =>
+              patch((o) =>
+                o.kind === "image" ? { ...o, fit: e.target.value as typeof o.fit } : o,
+              )
+            }
+          >
+            <option value="contain">Contain</option>
+            <option value="cover">Cover</option>
+            <option value="stretch">Stretch</option>
+          </select>
+        </label>
+      )}
+
+      {/* --- TeX figure: only meaningful for a single selected object, since
+          "edit" and "recompile" are inherently a one-object action. --- */}
+      {sel.length === 1 && sel[0].kind === "image" && sel[0].texSrc && (
+        <div className="deck-field deck-field-wide deck-tex-field">
+          <span>TeX figure</span>
+          <div className="deck-field-row">
+            <button
+              className="deck-inspector-btn"
+              disabled={texBusyIds?.has(sel[0].id)}
+              onClick={() => onEditTex?.(sel[0] as ImageObject)}
+              title={sel[0].texSrc}
+            >
+              Edit source
+            </button>
+            <button
+              className="deck-inspector-btn"
+              disabled={texBusyIds?.has(sel[0].id)}
+              onClick={() => onRecompileTex?.(sel[0] as ImageObject)}
+            >
+              {texBusyIds?.has(sel[0].id) ? "Compiling…" : "Recompile"}
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* --- common --- */}
+      <div className="deck-field-row">
+        <label className="deck-field deck-field-narrow">
+          <span>Opacity</span>
+          <input
+            type="range"
+            min={0}
+            max={1}
+            step={0.05}
+            value={shared(sel, (o) => o.opacity) ?? 1}
+            onChange={(e) => patch((o) => ({ ...o, opacity: Number(e.target.value) }))}
+          />
+        </label>
+        <label className="deck-field deck-field-narrow">
+          <span>Rotation</span>
+          <input
+            type="number"
+            step={1}
+            value={shared(sel, (o) => o.rot) ?? 0}
+            onChange={(e) => {
+              const rot = Number(e.target.value);
+              if (!Number.isFinite(rot)) return;
+              patch((o) => ({ ...o, rot }));
+            }}
+          />
+        </label>
+        <button
+          className={`deck-toggle${shared(sel, (o) => o.locked === true) ? " active" : ""}`}
+          onClick={() => {
+            // Locked objects are skipped by `updateObjects` by design, so
+            // UNLOCKING cannot go through it — it would filter out exactly the
+            // objects it is meant to change.
+            const locking = !shared(sel, (o) => o.locked === true);
+            onChange(
+              objects.map((o) =>
+                selection.has(o.id) ? { ...o, locked: locking ? true : undefined } : o,
+              ),
+            );
+          }}
+          title="Lock: keep this object out of the way of edits"
+        >
+          🔒
+        </button>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/DeckNotes.tsx b/src/components/embed/deck/DeckNotes.tsx
new file mode 100644
index 0000000..8b035fc
--- /dev/null
+++ b/src/components/embed/deck/DeckNotes.tsx
@@ -0,0 +1,33 @@
+/**
+ * Speaker-notes editor — the authoring half of `Slide.notes`.
+ *
+ * Until this existed, notes were write-only: the presenter's speaker-notes panel
+ * (`DeckPresenter.tsx`) reads `slide.notes`, but nothing in the editor ever set
+ * it. A dedicated mode (alongside Design/Animate) keeps the same "swap the right
+ * panel, leave the stage" shape those two already use, rather than inventing a
+ * separate surface for one textarea.
+ */
+
+import type { Slide } from "../../../lib/viewers/deck/model";
+
+export interface DeckNotesProps {
+  slide: Slide;
+  onSlideChange: (patch: (s: Slide) => Slide) => void;
+}
+
+export function DeckNotes({ slide, onSlideChange }: DeckNotesProps) {
+  return (
+    <div className="deck-inspector deck-notes">
+      <div className="deck-inspector-head">Speaker notes</div>
+      <textarea
+        className="deck-notes-textarea"
+        value={slide.notes}
+        placeholder="Notes for this slide — shown only in the presenter view."
+        onChange={(e) => {
+          const notes = e.target.value;
+          onSlideChange((s) => ({ ...s, notes }));
+        }}
+      />
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/DeckObjectView.tsx b/src/components/embed/deck/DeckObjectView.tsx
new file mode 100644
index 0000000..a1d94ae
--- /dev/null
+++ b/src/components/embed/deck/DeckObjectView.tsx
@@ -0,0 +1,311 @@
+/**
+ * Rendering one deck object.
+ *
+ * Objects render as **DOM/SVG over the page canvas**, not into it. That is the
+ * decision this file encodes, and it is what separates an editor from an
+ * annotator: hit-testing, selection outlines and z-order all come free from the
+ * browser, whereas the repo's one canvas-drawing precedent (`ImageAnnotator`) is
+ * pixel-destructive and cannot select anything it has drawn.
+ *
+ * Geometry arrives normalized (0..1 of the page) and converts to CSS pixels
+ * exactly once, here, by the page's rendered size. Type size is the exception: it
+ * is stored in PDF points and converts by `pointScale`. Mixing the two up is the
+ * bug that makes text resize when you change monitor.
+ *
+ * **Text is laid out with PDF metrics, not the browser's.** Each visual line is
+ * positioned absolutely from `deck/fonts.ts`'s wrap, rather than left to CSS —
+ * because the exporter breaks lines with those same metrics, and a paragraph that
+ * wraps one way on screen and another in the PDF is the single most corrosive bug
+ * this feature could ship. Before the metrics finish loading it falls back to CSS
+ * wrapping, which is approximately right and never blank.
+ */
+
+import type { CSSProperties } from "react";
+import type { DeckObject } from "../../../lib/viewers/deck/model";
+import {
+  type TextMetrics,
+  lineOffset,
+  listMarker,
+  wrapText,
+} from "../../../lib/viewers/deck/fonts";
+import { iconByKey, ICON_VIEWBOX } from "../../../lib/viewers/deck/icons";
+import {
+  arrowHeadPath,
+  isClosedShape,
+  lineAngle,
+  shapePath,
+} from "../../../lib/viewers/deck/shapes";
+
+/** The metric-compatible stacks the three standard-14 families resolve to. */
+export const FONT_STACKS: Record<string, string> = {
+  sans: 'Helvetica, "Liberation Sans", "Nimbus Sans", Arial, sans-serif',
+  serif: 'Times, "Liberation Serif", "Nimbus Roman", "Times New Roman", serif',
+  mono: 'Courier, "Liberation Mono", "Nimbus Mono PS", "Courier New", monospace',
+};
+
+export interface ObjectViewProps {
+  obj: DeckObject;
+  /** Rendered page size in CSS px. */
+  pageW: number;
+  pageH: number;
+  /** CSS px per PDF point — for font sizes and stroke widths. */
+  pointScale: number;
+  /** Resolved `src` → displayable URL, for images. Absent while loading. */
+  assetUrl?: string;
+  /** PDF text metrics; null until they finish loading. */
+  metrics: TextMetrics | null;
+  selected: boolean;
+}
+
+export function DeckObjectView({
+  obj,
+  pageW,
+  pageH,
+  pointScale,
+  assetUrl,
+  metrics,
+  selected,
+}: ObjectViewProps) {
+  const w = obj.w * pageW;
+  const h = obj.h * pageH;
+
+  const frame: CSSProperties = {
+    position: "absolute",
+    left: obj.x * pageW,
+    top: obj.y * pageH,
+    width: w,
+    height: h,
+    opacity: obj.opacity,
+    // Rotate about the centre, which is what a rotation handle implies.
+    transform: obj.rot ? `rotate(${obj.rot}deg)` : undefined,
+    transformOrigin: "50% 50%",
+  };
+
+  return (
+    <div
+      className={`deck-object${selected ? " selected" : ""}${obj.locked ? " locked" : ""}`}
+      style={frame}
+      data-object-id={obj.id}
+    >
+      {body(obj, w, h, pointScale, metrics, assetUrl)}
+    </div>
+  );
+}
+
+function body(
+  obj: DeckObject,
+  w: number,
+  h: number,
+  pointScale: number,
+  metrics: TextMetrics | null,
+  assetUrl?: string,
+) {
+  switch (obj.kind) {
+    case "text":
+      return <TextBody obj={obj} w={w} h={h} pointScale={pointScale} metrics={metrics} />;
+
+    case "image":
+      return assetUrl ? (
+        <img
+          src={assetUrl}
+          alt=""
+          draggable={false}
+          style={{
+            width: "100%",
+            height: "100%",
+            objectFit: obj.fit === "stretch" ? "fill" : obj.fit,
+            display: "block",
+          }}
+        />
+      ) : (
+        <div className="deck-object-missing" title={obj.src}>
+          {obj.src.split("/").pop()}
+        </div>
+      );
+
+    case "shape": {
+      const sw = obj.strokeWidth * pointScale;
+      // Inset by half the stroke so a stroked edge sits INSIDE the box. Without
+      // it a snapped edge is visually half a stroke off from the guide it
+      // snapped to — the kind of small lie that makes alignment feel unreliable.
+      const iw = Math.max(0, w - sw);
+      const ih = Math.max(0, h - sw);
+      const angle = lineAngle(iw, ih);
+      const heads = [
+        obj.head && obj.head !== "none" ? arrowHeadPath(obj.head, iw, ih, angle, sw) : "",
+        obj.tail && obj.tail !== "none" ? arrowHeadPath(obj.tail, 0, 0, angle + Math.PI, sw) : "",
+      ].filter(Boolean);
+      return (
+        <svg width={w} height={h} style={{ display: "block", overflow: "visible" }}>
+          <g transform={`translate(${sw / 2} ${sw / 2})`}>
+            <path
+              d={shapePath(obj.shape, iw, ih, obj.radius ?? 0.12)}
+              fill={isClosedShape(obj.shape) ? (obj.fill ?? "none") : "none"}
+              stroke={obj.stroke}
+              strokeWidth={sw}
+              strokeLinejoin="round"
+              strokeLinecap="round"
+            />
+            {heads.map((hd, i) => (
+              <path key={i} d={hd} fill={obj.stroke} stroke={obj.stroke} strokeWidth={sw} />
+            ))}
+          </g>
+        </svg>
+      );
+    }
+
+    case "icon": {
+      const def = iconByKey(obj.icon);
+      if (!def) {
+        // A deck written by a later build can name an icon this one lacks.
+        // Showing where it was beats silently leaving a hole in the slide.
+        return (
+          <div className="deck-object-missing" title={obj.icon}>
+            {obj.icon}
+          </div>
+        );
+      }
+      // Icons are authored in a 24-unit box that is scaled to fit the object, so
+      // the stroke — stored in points like every other width in the deck — has to
+      // be converted INTO viewBox units, or a small icon draws a hairline and a
+      // large one draws a slab.
+      const unitPx = Math.min(w, h) / ICON_VIEWBOX;
+      const strokeUnits = unitPx > 0 ? (obj.strokeWidth * pointScale) / unitPx : 1;
+      return (
+        <svg
+          width={w}
+          height={h}
+          viewBox={`0 0 ${ICON_VIEWBOX} ${ICON_VIEWBOX}`}
+          preserveAspectRatio="xMidYMid meet"
+          style={{ display: "block", overflow: "visible" }}
+        >
+          <g
+            transform={
+              def.rotate ? `rotate(${def.rotate} ${ICON_VIEWBOX / 2} ${ICON_VIEWBOX / 2})` : undefined
+            }
+          >
+            {def.paths.map((d, i) => (
+              <path
+                key={i}
+                d={d}
+                fill={def.filled ? obj.color : "none"}
+                stroke={def.filled ? "none" : obj.color}
+                strokeWidth={def.filled ? undefined : strokeUnits}
+                strokeLinecap="round"
+                strokeLinejoin="round"
+              />
+            ))}
+          </g>
+        </svg>
+      );
+    }
+  }
+}
+
+/** Text, laid out line by line from the PDF metrics. See the module note. */
+function TextBody({
+  obj,
+  w,
+  h,
+  pointScale,
+  metrics,
+}: {
+  obj: Extract<DeckObject, { kind: "text" }>;
+  w: number;
+  h: number;
+  pointScale: number;
+  metrics: TextMetrics | null;
+}) {
+  const s = obj.style;
+  const pad = obj.padding * pointScale;
+
+  const boxStyle: CSSProperties = {
+    position: "absolute",
+    inset: 0,
+    boxSizing: "border-box",
+    background: obj.fill ?? "transparent",
+    border: obj.stroke ? `${(obj.strokeWidth ?? 1) * pointScale}px solid ${obj.stroke}` : undefined,
+    overflow: "hidden",
+  };
+
+  const textStyle: CSSProperties = {
+    fontFamily: FONT_STACKS[s.family] ?? FONT_STACKS.sans,
+    fontSize: s.size * pointScale,
+    fontWeight: s.bold ? 700 : 400,
+    fontStyle: s.italic ? "italic" : "normal",
+    color: s.color,
+    lineHeight: s.lineHeight,
+    whiteSpace: "pre",
+  };
+
+  // Fallback until the metrics load: CSS wrapping. Approximately right, never
+  // blank, and replaced within a frame or two.
+  if (!metrics) {
+    return (
+      <div style={boxStyle}>
+        <div
+          style={{
+            ...textStyle,
+            position: "absolute",
+            inset: pad,
+            whiteSpace: "pre-wrap",
+            textAlign: s.align,
+          }}
+        >
+          {obj.list
+            ? obj.text
+                .split("\n")
+                .map((l, i) => `${listMarker(obj.list!.kind, i, obj.list!.start)} ${l}`)
+                .join("\n")
+            : obj.text}
+        </div>
+      </div>
+    );
+  }
+
+  const innerPt = Math.max(1, (w - pad * 2) / pointScale);
+  const lines = wrapText(metrics, obj.text, s, innerPt, obj.list);
+  const lineH = s.size * s.lineHeight * pointScale;
+
+  return (
+    <div style={boxStyle}>
+      {lines.map((line, i) => (
+        <div
+          key={i}
+          style={{
+            ...textStyle,
+            position: "absolute",
+            left: pad,
+            top: pad + i * lineH,
+            width: w - pad * 2,
+            height: lineH,
+            lineHeight: `${lineH}px`,
+          }}
+        >
+          {line.marker && (
+            <span
+              style={{
+                position: "absolute",
+                left: 0,
+                width: line.indent * pointScale,
+              }}
+            >
+              {line.marker}
+            </span>
+          )}
+          <span
+            style={{
+              position: "absolute",
+              left: lineOffset(line, s, innerPt) * pointScale,
+            }}
+          >
+            {line.text}
+          </span>
+        </div>
+      ))}
+      {/* A box too short for its text is a real authoring mistake, not a render
+          bug — say so rather than silently clipping the last line away. */}
+      {lines.length * lineH > h - pad * 2 && <span className="deck-text-overflow" title="Text is taller than its box" />}
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/DeckPresenter.tsx b/src/components/embed/deck/DeckPresenter.tsx
new file mode 100644
index 0000000..154b10c
--- /dev/null
+++ b/src/components/embed/deck/DeckPresenter.tsx
@@ -0,0 +1,538 @@
+/**
+ * The presenter.
+ *
+ * Navigation runs off `model.sequence(deck)`, which flattens the deck into an
+ * ordered list of *stops* — a slide at a build step, or an interstitial. Doing
+ * that up front is what makes the awkward cases correct by construction: `←`
+ * steps a build backwards instead of jumping a slide (losing the slide to the
+ * first audience question is the single most common presenter-software failure),
+ * and a GIF that plays between two slides is simply one more stop.
+ *
+ * **One presenter, one or two screens.** With no second display this is the
+ * fullscreen presenter with an optional notes/timer panel (`N`). Press `D` (or
+ * the ⧉ button) and Eldrun opens an **audience window** — a separate OS window,
+ * placed fullscreen on another monitor when there is one — and this window
+ * becomes the *presenter view*: current slide, next slide, notes, timer, build
+ * indicator. This window keeps owning the stop; the audience window renders what
+ * it is told and forwards its own keys back (see `deck/present.ts`). Two heaps,
+ * one index — the two displays cannot drift apart.
+ *
+ * The laser and marker are `PresentationOverlay`, mounted verbatim — it is
+ * self-contained, stores nothing, and already solves normalized coordinates and
+ * device-pixel sizing. It only needs a `position: relative` host. Known limit of
+ * the dual-window mode: those strokes are drawn on *this* window and are not
+ * mirrored to the audience one.
+ *
+ * Rendered through a portal into `#root` rather than `document.body`: a
+ * body-level portal can fail to paint in a detached popout webview (documented at
+ * `ContextFilePicker.tsx`).
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { emit, listen } from "@tauri-apps/api/event";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import { PresentationOverlay } from "../PresentationOverlay";
+import {
+  type Deck,
+  type Slide,
+  type Stop,
+  sequence,
+} from "../../../lib/viewers/deck/model";
+import { serializeDeck } from "../../../lib/viewers/deck/sidecar";
+import {
+  type Blank,
+  type PresentNav,
+  type PresentReady,
+  type PresentSeed,
+  PRESENT_CLOSED,
+  PRESENT_NAV,
+  PRESENT_READY,
+  applyNav,
+  clampStop,
+  keyToAction,
+  presentSeedEvent,
+  presentStateEvent,
+  presenterLabel,
+  slideStopIndex,
+} from "../../../lib/viewers/deck/present";
+import type { TextMetrics } from "../../../lib/viewers/deck/fonts";
+import { type DecodedGif, disposeGif } from "./gifPlayback";
+import { InterstitialView, PresentedSlide } from "./DeckSlideView";
+
+export interface DeckPresenterProps {
+  deck: Deck;
+  doc: PDFDocumentProxy | null;
+  metrics: TextMetrics | null;
+  assets: ReadonlyMap<string, string>;
+  /** Interstitial id → decoded clip, or `undefined` while it loads. */
+  gifs: ReadonlyMap<string, DecodedGif>;
+  /** The deck's sidecar path — names the audience window and locates its assets. */
+  path: string;
+  /** File scope the audience window reads its own bytes under. */
+  scope: string | null;
+  /** Stop to open on. */
+  startAt?: number;
+  onClose: () => void;
+}
+
+export function DeckPresenter({
+  deck,
+  doc,
+  metrics,
+  assets,
+  gifs,
+  path,
+  scope,
+  startAt = 0,
+  onClose,
+}: DeckPresenterProps) {
+  const stops = useMemo(() => sequence(deck), [deck]);
+  const [index, setIndex] = useState(() => Math.min(startAt, Math.max(0, stops.length - 1)));
+  const [blank, setBlank] = useState<Blank>(null);
+  const [grid, setGrid] = useState(false);
+  const [notesOpen, setNotesOpen] = useState(false);
+  const [goto, setGoto] = useState("");
+  const [started] = useState(() => Date.now());
+  const [now, setNow] = useState(() => Date.now());
+  /** The audience window's label while it is open, else null. */
+  const [audience, setAudience] = useState<string | null>(null);
+  const [linkError, setLinkError] = useState<string | null>(null);
+  const rootRef = useRef<HTMLDivElement | null>(null);
+
+  const stop: Stop | undefined = stops[index];
+  const slide: Slide | undefined = stop ? deck.slides[stop.slide] : undefined;
+
+  // The transition is a property of the slide being LEFT ("leaving this slide"
+  // in the animate panel), so it is read off the previous stop, not the new one.
+  // Held in a ref rather than state: it must be known during the render that
+  // first shows the new slide, and a state write would land one frame late —
+  // which is exactly one frame of un-transitioned slide.
+  const prevSlideRef = useRef<number | null>(null);
+  const transitionRef = useRef<string>("none");
+  if (stop && prevSlideRef.current !== stop.slide) {
+    const from = prevSlideRef.current;
+    transitionRef.current =
+      from != null && deck.slides[from] ? deck.slides[from].transition : "none";
+    prevSlideRef.current = stop.slide;
+  }
+
+  // A one-second tick for the elapsed clock. Cheap, and the presenter is the one
+  // place a wall clock genuinely earns its re-render.
+  useEffect(() => {
+    const t = setInterval(() => setNow(Date.now()), 1000);
+    return () => clearInterval(t);
+  }, []);
+
+  const next = useCallback(() => setIndex((i) => clampStop(stops, i + 1)), [stops]);
+  const prev = useCallback(() => setIndex((i) => clampStop(stops, i - 1)), [stops]);
+
+  const jumpToSlide = useCallback(
+    (n: number) => {
+      const found = slideStopIndex(stops, n);
+      if (found >= 0) setIndex(found);
+      setGrid(false);
+    },
+    [stops],
+  );
+
+  // --- the audience window -------------------------------------------------
+
+  const label = useMemo(() => presenterLabel(path), [path]);
+
+  const openAudience = useCallback(async () => {
+    setLinkError(null);
+    try {
+      await invoke("open_presenter_window", { label });
+      setAudience(label);
+    } catch (e) {
+      setLinkError(
+        `The second display could not be opened (${e instanceof Error ? e.message : String(e)}).`,
+      );
+    }
+  }, [label]);
+
+  const closeAudience = useCallback(() => {
+    setAudience(null);
+    void invoke("close_presenter_window", { label }).catch(() => {
+      // A window already gone is the state we wanted.
+    });
+  }, [label]);
+
+  // Closing the talk takes the audience window with it — a slide left glowing on
+  // a projector after the speaker has sat down is worse than no second display.
+  const closeAll = useCallback(() => {
+    if (audience) closeAudience();
+    onClose();
+  }, [audience, closeAudience, onClose]);
+
+  // Where we are, for a seed. Read through refs so seeding does NOT depend on
+  // the index: it does, of course, carry it, but a dependency would re-serialize
+  // the whole deck on every keypress of the talk.
+  const whereRef = useRef({ index, blank });
+  whereRef.current = { index, blank };
+
+  const seed = useCallback(() => {
+    if (!audience) return;
+    const payload: PresentSeed = {
+      path,
+      scope,
+      // Serialized, not the live object: the audience window parses the sidecar
+      // form, which is the only shape both halves agree on — and this window may
+      // hold edits the 800 ms autosave has not written yet.
+      deck: serializeDeck(deck),
+      index: whereRef.current.index,
+      blank: whereRef.current.blank,
+    };
+    void emit(presentSeedEvent(audience), payload);
+  }, [audience, deck, path, scope]);
+
+  // Seed on request (the audience window asks until answered) and whenever the
+  // deck itself changes under an open window.
+  useEffect(() => {
+    if (!audience) return;
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    void listen<PresentReady>(PRESENT_READY, (e) => {
+      if (e.payload.label === audience) seed();
+    }).then((fn) => {
+      if (cancelled) fn();
+      else unlisten = fn;
+    });
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, [audience, seed]);
+
+  useEffect(() => {
+    seed();
+  }, [seed]);
+
+  // Stream the stop/blank. Small and frequent — the seed carries the deck, this
+  // carries only where we are in it.
+  useEffect(() => {
+    if (!audience) return;
+    void emit(presentStateEvent(audience), { index, blank });
+  }, [audience, index, blank]);
+
+  // Keys pressed on the audience window arrive as requests; this window remains
+  // the only place the index actually moves.
+  useEffect(() => {
+    if (!audience) return;
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    void listen<PresentNav>(PRESENT_NAV, (e) => {
+      if (e.payload.label !== audience) return;
+      const action = e.payload.action;
+      if (action.kind === "close") {
+        closeAll();
+        return;
+      }
+      if (action.kind === "blank") {
+        setBlank((v) => (v === action.mode ? null : action.mode));
+        return;
+      }
+      setIndex((i) => applyNav(stops, i, action));
+    }).then((fn) => {
+      if (cancelled) fn();
+      else unlisten = fn;
+    });
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, [audience, stops, closeAll]);
+
+  // The audience window was closed from the WM: drop back to one screen rather
+  // than streaming at a window that is not there.
+  useEffect(() => {
+    if (!audience) return;
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    void listen<{ label: string }>(PRESENT_CLOSED, (e) => {
+      if (e.payload.label === audience) setAudience(null);
+    }).then((fn) => {
+      if (cancelled) fn();
+      else unlisten = fn;
+    });
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, [audience]);
+
+  // Unmount (the tab closed, the deck reloaded) must not leave an orphaned
+  // window on the projector. Read through a ref so this fires exactly once, at
+  // teardown, instead of on every toggle.
+  const audienceRef = useRef<string | null>(null);
+  audienceRef.current = audience;
+  useEffect(
+    () => () => {
+      if (audienceRef.current) {
+        void invoke("close_presenter_window", { label: audienceRef.current }).catch(() => {});
+      }
+    },
+    [],
+  );
+
+  // --- keys ----------------------------------------------------------------
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      // Keys this window owns alone: the overlays and the second display are
+      // the speaker's, not the audience's.
+      switch (e.key) {
+        case "Enter":
+          if (goto) {
+            jumpToSlide(Number(goto) - 1);
+            setGoto("");
+          }
+          return;
+        case "g":
+        case "G":
+          setGrid((v) => !v);
+          return;
+        case "n":
+        case "N":
+          setNotesOpen((v) => !v);
+          return;
+        case "d":
+        case "D":
+          if (audience) closeAudience();
+          else void openAudience();
+          return;
+        case "Escape":
+          // Escape peels one layer at a time rather than dumping you out of the
+          // talk from whatever overlay happens to be open.
+          if (grid) setGrid(false);
+          else if (blank) setBlank(null);
+          else closeAll();
+          return;
+        default:
+          break;
+      }
+
+      // Everything else goes through the SAME mapping the audience window uses,
+      // so whichever display has focus, a key means the same thing.
+      const action = keyToAction(e.key);
+      if (!action) {
+        setGoto("");
+        return;
+      }
+      if (action.kind === "digit") {
+        setGoto((g) => (g + action.digit).slice(-4));
+        return;
+      }
+      if (action.kind === "close") {
+        closeAll();
+        return;
+      }
+      if (action.kind === "blank") {
+        setBlank((v) => (v === action.mode ? null : action.mode));
+        return;
+      }
+      e.preventDefault();
+      // A blanked screen swallows the first advance: the key that wakes the
+      // screen should not also move the talk on.
+      if (blank && (action.kind === "next" || action.kind === "prev")) {
+        setBlank(null);
+        return;
+      }
+      setIndex((i) => applyNav(stops, i, action));
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [
+    stops,
+    blank,
+    grid,
+    goto,
+    jumpToSlide,
+    closeAll,
+    audience,
+    openAudience,
+    closeAudience,
+  ]);
+
+  useEffect(() => {
+    rootRef.current?.focus();
+  }, []);
+
+  const root = typeof document !== "undefined" ? document.getElementById("root") : null;
+  if (!root || !stop) return null;
+
+  const elapsed = Math.floor((now - started) / 1000);
+  const mm = String(Math.floor(elapsed / 60)).padStart(2, "0");
+  const ss = String(elapsed % 60).padStart(2, "0");
+  const wall = new Date(now).toLocaleTimeString(undefined, {
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+
+  const nextSlideIndex = stops.slice(index + 1).find((s) => s.kind === "slide")?.slide;
+  const nextSlide = nextSlideIndex !== undefined ? deck.slides[nextSlideIndex] : undefined;
+  // With the audience on its own screen this window IS the presenter view, so
+  // the notes column stops being optional — hiding it would leave the speaker
+  // looking at a second copy of what the room already sees.
+  const showNotes = notesOpen || audience !== null;
+  const builds = stop.kind === "slide" ? stop.step : 0;
+
+  return createPortal(
+    <div
+      className={`deck-presenter${audience ? " is-dual" : ""}`}
+      ref={rootRef}
+      tabIndex={-1}
+    >
+      <div className="deck-presenter-main">
+        {/* PresentationOverlay needs a position:relative host; giving it the
+            slide area (not the whole window) keeps marker strokes anchored to
+            the slide rather than to the chrome around it. */}
+        <div className="presentation-host deck-presenter-stage">
+          {stop.kind === "interstitial" && slide?.after ? (
+            <InterstitialView
+              gif={gifs.get(slide.after.id)}
+              fit={slide.after.fit}
+              background={slide.after.background}
+              advance={slide.after.advance}
+              onEnded={next}
+            />
+          ) : (
+            slide && (
+              <PresentedSlide
+                // Re-keying on the slide is what makes the entrance transition
+                // replay: a CSS animation on a persistent element only runs once.
+                key={slide.id}
+                slide={slide}
+                step={stop.kind === "slide" ? stop.step : 0}
+                doc={doc}
+                pageWidth={deck.pageWidth}
+                pageHeight={deck.pageHeight}
+                metrics={metrics}
+                assets={assets}
+                transition={transitionRef.current}
+              />
+            )
+          )}
+          <PresentationOverlay />
+        </div>
+
+        {blank && <div className={`deck-presenter-blank is-${blank}`} />}
+
+        {grid && (
+          <div className="deck-presenter-grid" role="listbox" aria-label="All slides">
+            {deck.slides.map((s, i) => (
+              <button
+                key={s.id}
+                className={`deck-presenter-grid-cell${i === stop.slide ? " active" : ""}`}
+                onClick={() => jumpToSlide(i)}
+              >
+                <span className="deck-presenter-grid-num">{i + 1}</span>
+                {s.notes.trim() && <span className="deck-presenter-grid-note" title={s.notes} />}
+              </button>
+            ))}
+          </div>
+        )}
+
+        {goto && <div className="deck-presenter-goto">Go to slide {goto}…</div>}
+      </div>
+
+      {showNotes && (
+        <aside className="deck-presenter-notes">
+          <div className="deck-presenter-notes-head">
+            <span>
+              Slide {stop.slide + 1} / {deck.slides.length}
+              {stop.kind === "slide" && stop.step > 0 && ` · build ${builds}`}
+              {stop.kind === "interstitial" && " · animation"}
+            </span>
+            <span className="deck-presenter-timer" title={`Started at ${new Date(started).toLocaleTimeString()}`}>
+              {mm}:{ss}
+            </span>
+          </div>
+
+          {audience && (
+            <div className="deck-presenter-audience-note">
+              Audience view is on the second display. <kbd>D</kbd> closes it.
+            </div>
+          )}
+          {linkError && <div className="deck-presenter-audience-note is-error">{linkError}</div>}
+
+          {/* The next slide, still: a preview that re-ran its build entrances
+              every time the speaker stepped one on the CURRENT slide would be a
+              flicker in the corner of their eye for the whole talk. */}
+          {nextSlide && (
+            <div className="deck-presenter-next-preview">
+              <span className="deck-presenter-next-label">Next · slide {(nextSlideIndex ?? 0) + 1}</span>
+              <div className="deck-presenter-next-frame">
+                <PresentedSlide
+                  key={`next-${nextSlide.id}`}
+                  slide={nextSlide}
+                  step={Number.MAX_SAFE_INTEGER}
+                  doc={doc}
+                  pageWidth={deck.pageWidth}
+                  pageHeight={deck.pageHeight}
+                  metrics={metrics}
+                  assets={assets}
+                  transition="none"
+                  still
+                />
+              </div>
+            </div>
+          )}
+
+          <div className="deck-presenter-notes-body">
+            {slide?.notes.trim() ? slide.notes : <em>No notes for this slide.</em>}
+          </div>
+
+          <div className="deck-presenter-next">
+            {nextSlideIndex !== undefined ? (
+              <>
+                Next: slide {nextSlideIndex + 1}
+                {deck.slides[nextSlideIndex]?.after && " (animation follows)"}
+              </>
+            ) : (
+              "Last slide."
+            )}
+            <span className="deck-presenter-wall">{wall}</span>
+          </div>
+        </aside>
+      )}
+
+      <div className="deck-presenter-bar">
+        <button onClick={prev} title="Previous (←)" aria-label="Previous">
+          ‹
+        </button>
+        <span className="deck-presenter-pos">
+          {stop.slide + 1} / {deck.slides.length}
+        </span>
+        <button onClick={next} title="Next (Space / →)" aria-label="Next">
+          ›
+        </button>
+        <button
+          className={notesOpen ? "active" : ""}
+          onClick={() => setNotesOpen((v) => !v)}
+          title="Speaker notes (N)"
+        >
+          ☰
+        </button>
+        <button className={grid ? "active" : ""} onClick={() => setGrid((v) => !v)} title="Overview (G)">
+          ⊞
+        </button>
+        <button
+          className={audience ? "active" : ""}
+          onClick={() => (audience ? closeAudience() : void openAudience())}
+          title="Audience view on a second display (D)"
+          aria-label="Second display"
+        >
+          ⧉
+        </button>
+        <button onClick={closeAll} title="Exit (Esc)" aria-label="Exit">
+          ✕
+        </button>
+      </div>
+    </div>,
+    root,
+  );
+}
+
+export { disposeGif };
diff --git a/src/components/embed/deck/DeckSlideView.tsx b/src/components/embed/deck/DeckSlideView.tsx
new file mode 100644
index 0000000..decfa87
--- /dev/null
+++ b/src/components/embed/deck/DeckSlideView.tsx
@@ -0,0 +1,159 @@
+/**
+ * The two things a *presented* deck paints: a slide letterboxed to its host, and
+ * the GIF that plays between two slides.
+ *
+ * They live here rather than inside `DeckPresenter` because the dual-window
+ * presenter renders them in **two** webviews — the audience window on the
+ * projector and the presenter window's own preview — and the one thing the
+ * audience must never see is the two displays disagreeing about what a slide
+ * looks like. One component, rendered twice, cannot drift.
+ */
+
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import { type Slide, visibleAt } from "../../../lib/viewers/deck/model";
+import type { TextMetrics } from "../../../lib/viewers/deck/fonts";
+import { DeckObjectView } from "./DeckObjectView";
+import { renderPage } from "./deckBase";
+import { type DecodedGif, playGif } from "./gifPlayback";
+
+export interface PresentedSlideProps {
+  slide: Slide;
+  step: number;
+  doc: PDFDocumentProxy | null;
+  pageWidth: number;
+  pageHeight: number;
+  metrics: TextMetrics | null;
+  assets: ReadonlyMap<string, string>;
+  transition: string;
+  /** Suppresses build entrances — a *preview* of the next slide should not
+   *  animate every time the speaker steps a build on the current one. */
+  still?: boolean;
+}
+
+/** One slide, letterboxed to its host, with only the objects built so far. */
+export function PresentedSlide({
+  slide,
+  step,
+  doc,
+  pageWidth,
+  pageHeight,
+  metrics,
+  assets,
+  transition,
+  still = false,
+}: PresentedSlideProps) {
+  const hostRef = useRef<HTMLDivElement | null>(null);
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const [size, setSize] = useState({ w: 0, h: 0 });
+
+  useLayoutEffect(() => {
+    const host = hostRef.current;
+    if (!host) return;
+    const fit = () => {
+      const aspect = pageWidth / pageHeight;
+      let w = host.clientWidth;
+      let h = w / aspect;
+      if (h > host.clientHeight) {
+        h = host.clientHeight;
+        w = h * aspect;
+      }
+      setSize((p) => (Math.abs(p.w - w) < 0.5 && Math.abs(p.h - h) < 0.5 ? p : { w, h }));
+    };
+    fit();
+    const ro = new ResizeObserver(fit);
+    ro.observe(host);
+    return () => ro.disconnect();
+  }, [pageWidth, pageHeight]);
+
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !doc || size.w <= 0) return;
+    return renderPage(doc, slide.anchor.page, canvas, size.w, size.h);
+  }, [doc, slide.anchor.page, size.w, size.h]);
+
+  const pointScale = size.w > 0 && pageWidth > 0 ? size.w / pageWidth : 1;
+
+  return (
+    <div className="deck-presenter-fit" ref={hostRef}>
+      <div
+        className={`deck-presenter-page${
+          !still && transition && transition !== "none" ? ` deck-trans-${transition}` : ""
+        }`}
+        style={{ width: size.w, height: size.h }}
+      >
+        <canvas className="deck-stage-canvas" ref={canvasRef} />
+        {slide.objects.filter((o) => visibleAt(o, step)).map((o) => (
+          <div
+            key={o.id}
+            // Re-keying on the step is what makes the entrance animation replay
+            // when an object is revealed, rather than only on first mount.
+            className={
+              !still && o.build && o.build.step === step && o.build.effect !== "none"
+                ? `deck-build deck-build-${o.build.effect}`
+                : undefined
+            }
+          >
+            <DeckObjectView
+              obj={o}
+              pageW={size.w}
+              pageH={size.h}
+              pointScale={pointScale}
+              assetUrl={o.kind === "image" ? assets.get(o.src) : undefined}
+              metrics={metrics}
+              selected={false}
+            />
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+export interface InterstitialViewProps {
+  gif: DecodedGif | undefined;
+  fit: "contain" | "cover";
+  background: string;
+  advance: { on: "manual" } | { on: "end" } | { on: "end-after"; loops: number };
+  onEnded: () => void;
+}
+
+/** The GIF that plays between two slides. */
+export function InterstitialView({
+  gif,
+  fit,
+  background,
+  advance,
+  onEnded,
+}: InterstitialViewProps) {
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+  const endedRef = useRef(onEnded);
+  endedRef.current = onEnded;
+
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !gif) return;
+    // `manual` loops until the speaker advances — the right default for a clip
+    // you talk over. The others stop themselves and hand the stop on.
+    const loops = advance.on === "end" ? 1 : advance.on === "end-after" ? advance.loops : Infinity;
+    let seen = 0;
+    return playGif(canvas, gif, {
+      fit,
+      background,
+      loop: loops > 1,
+      onEnded: () => {
+        seen += 1;
+        if (seen >= loops) endedRef.current();
+      },
+    });
+  }, [gif, fit, background, advance]);
+
+  if (!gif) {
+    return (
+      <div className="deck-presenter-fit deck-presenter-loading" style={{ background }}>
+        Loading animation…
+      </div>
+    );
+  }
+  return <canvas className="deck-presenter-gif" ref={canvasRef} />;
+}
diff --git a/src/components/embed/deck/DeckStage.tsx b/src/components/embed/deck/DeckStage.tsx
new file mode 100644
index 0000000..a5f8892
--- /dev/null
+++ b/src/components/embed/deck/DeckStage.tsx
@@ -0,0 +1,536 @@
+/**
+ * The deck editing surface: the base page, the object layer over it, selection
+ * handles, and every pointer gesture that moves or resizes something.
+ *
+ * Three decisions are worth knowing before changing anything here.
+ *
+ * **Every gesture is pointer-based, with pointer capture, and every handler is
+ * bound in the JSX.** HTML5 drag-and-drop does not work under WebKitGTK (see
+ * `stores/pdfDrag.ts` and `YamlTree`, which both learned this), and listeners
+ * *added mid-gesture* can be skipped entirely — so the move/up handlers are on
+ * the stage from the first render and `setPointerCapture` keeps them fed even
+ * when the pointer leaves the element.
+ *
+ * **A gesture edits local state and commits once, on pointerup.** The deck
+ * autosaves (there is no save button and no close prompt anywhere in Eldrun), and
+ * `useEditableFile` writes on *every* change — so committing per `pointermove`
+ * would issue a disk write per frame of a drag. `pending` holds the live object
+ * list; `onObjectsChange` fires exactly once when the pointer goes up.
+ *
+ * **Guides are painted from what the snapper returned**, never recomputed here.
+ * If a snap fires for the wrong reason it is then visible immediately, which is
+ * the only practical defence against a sign error in `deck/snap.ts`.
+ */
+
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import {
+  type Box,
+  type DeckObject,
+  type ObjectList,
+  type Slide,
+  boundingBox,
+  moveObjects,
+  updateObjects,
+  visibleAt,
+} from "../../../lib/viewers/deck/model";
+import {
+  type Guide,
+  type ResizeHandle,
+  axisLock,
+  snapMove,
+  snapResize,
+  thresholdFor,
+} from "../../../lib/viewers/deck/snap";
+import type { TextMetrics } from "../../../lib/viewers/deck/fonts";
+import { DeckObjectView } from "./DeckObjectView";
+import { renderPage } from "./deckBase";
+
+/** Snap radius in CSS pixels. Generous enough to catch, tight enough that a
+ *  deliberate 3px offset is still reachable (Alt suspends it entirely). */
+const SNAP_PX = 7;
+
+/** Below this drag distance a gesture is a click, not a move — otherwise
+ *  selecting an object nudges it by a pixel. */
+const DRAG_SLOP_PX = 3;
+
+const HANDLES: ResizeHandle[] = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+
+export interface DeckStageProps {
+  slide: Slide;
+  /** The base document, or null when the deck has no plate yet. */
+  doc: PDFDocumentProxy | null;
+  /** Page box in points — sets the stage's aspect ratio. */
+  pageWidth: number;
+  pageHeight: number;
+  /** Safe-area inset, a snapping target and a painted frame. */
+  margin: number;
+  selection: ReadonlySet<string>;
+  onSelectionChange: (ids: Set<string>) => void;
+  onObjectsChange: (objects: ObjectList) => void;
+  /** Build step being previewed; objects above it are dimmed, not hidden, so
+   *  they stay selectable while you are arranging them. */
+  previewStep?: number;
+  /** `src` → object URL for image objects. */
+  assets?: ReadonlyMap<string, string>;
+  /** PDF text metrics; null until loaded. See `deck/fonts.ts`. */
+  metrics: TextMetrics | null;
+  /** Show each object's build step as a numbered badge — animate mode only.
+   *  Animation whose structure you cannot see cannot be reasoned about. */
+  showBuildBadges?: boolean;
+  /** Double-click on an object — the "enter/edit" gesture, distinct from the
+   *  single click that selects it. Used for a TeX-figure image's source. */
+  onEditObject?: (obj: DeckObject) => void;
+}
+
+type Gesture =
+  | { mode: "move"; startX: number; startY: number; base: ObjectList; moved: boolean }
+  | {
+      mode: "resize";
+      handle: ResizeHandle;
+      startX: number;
+      startY: number;
+      base: ObjectList;
+      id: string;
+      moved: boolean;
+    }
+  | { mode: "rotate"; cx: number; cy: number; base: ObjectList; id: string; moved: boolean }
+  | { mode: "marquee"; startX: number; startY: number; additive: boolean };
+
+export function DeckStage({
+  slide,
+  doc,
+  pageWidth,
+  pageHeight,
+  margin,
+  selection,
+  onSelectionChange,
+  onObjectsChange,
+  previewStep,
+  assets,
+  metrics,
+  showBuildBadges,
+  onEditObject,
+}: DeckStageProps) {
+  const hostRef = useRef<HTMLDivElement | null>(null);
+  const pageRef = useRef<HTMLDivElement | null>(null);
+  const canvasRef = useRef<HTMLCanvasElement | null>(null);
+
+  /** Rendered page size in CSS px, measured — the stage fits the pane. */
+  const [size, setSize] = useState({ w: 0, h: 0 });
+  /**
+   * Live objects during a gesture; null when idle (the slide's own list wins).
+   *
+   * Mirrored into a ref because the commit happens on pointerup, and a pointerup
+   * arriving in the same frame as the last pointermove would otherwise read a
+   * `pending` React has not re-rendered yet — silently dropping the final frame
+   * of every fast drag, which reads as "it doesn't quite go where I put it".
+   */
+  const [pending, setPendingState] = useState<ObjectList | null>(null);
+  const pendingRef = useRef<ObjectList | null>(null);
+  const setPending = useCallback((list: ObjectList | null) => {
+    pendingRef.current = list;
+    setPendingState(list);
+  }, []);
+  const [guides, setGuides] = useState<Guide[]>([]);
+  const [marquee, setMarquee] = useState<Box | null>(null);
+  const gestureRef = useRef<Gesture | null>(null);
+
+  const objects = pending ?? slide.objects;
+
+  // --- layout ------------------------------------------------------------
+  // Fit the page into the host, preserving aspect. Re-measured on resize so the
+  // normalized geometry keeps its promise of surviving a pane resize.
+  useLayoutEffect(() => {
+    const host = hostRef.current;
+    if (!host) return;
+    const fit = () => {
+      const availW = host.clientWidth - 32;
+      const availH = host.clientHeight - 32;
+      if (availW <= 0 || availH <= 0) return;
+      const aspect = pageWidth / pageHeight;
+      let w = availW;
+      let h = w / aspect;
+      if (h > availH) {
+        h = availH;
+        w = h * aspect;
+      }
+      setSize((prev) =>
+        Math.abs(prev.w - w) < 0.5 && Math.abs(prev.h - h) < 0.5 ? prev : { w, h },
+      );
+    };
+    fit();
+    const ro = new ResizeObserver(fit);
+    ro.observe(host);
+    return () => ro.disconnect();
+  }, [pageWidth, pageHeight]);
+
+  // --- base page ---------------------------------------------------------
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas || !doc || size.w <= 0) return;
+    return renderPage(doc, slide.anchor.page, canvas, size.w, size.h);
+  }, [doc, slide.anchor.page, size.w, size.h]);
+
+  // --- geometry helpers --------------------------------------------------
+
+  /** Pointer → normalized page coordinates. */
+  const toPage = useCallback(
+    (clientX: number, clientY: number) => {
+      const rect = pageRef.current?.getBoundingClientRect();
+      if (!rect || rect.width === 0 || rect.height === 0) return { x: 0, y: 0 };
+      return {
+        x: (clientX - rect.left) / rect.width,
+        y: (clientY - rect.top) / rect.height,
+      };
+    },
+    [],
+  );
+
+  const threshold = thresholdFor(SNAP_PX, size.w, size.h);
+
+  /** Boxes to snap against: everything not being dragged. */
+  const othersFor = useCallback(
+    (list: ObjectList, moving: ReadonlySet<string>): Box[] =>
+      list.filter((o) => !moving.has(o.id) && !o.hidden).map((o) => ({ x: o.x, y: o.y, w: o.w, h: o.h })),
+    [],
+  );
+
+  // --- gestures ----------------------------------------------------------
+
+  const onPointerDown = useCallback(
+    (e: React.PointerEvent) => {
+      if (e.button !== 0) return;
+      const target = e.target as HTMLElement;
+      const handleEl = target.closest<HTMLElement>("[data-handle]");
+      const rotateEl = target.closest<HTMLElement>("[data-rotate]");
+      const objEl = target.closest<HTMLElement>("[data-object-id]");
+      const p = toPage(e.clientX, e.clientY);
+
+      (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId);
+
+      if (rotateEl) {
+        const sel = objects.filter((o) => selection.has(o.id));
+        if (sel.length !== 1) return;
+        const b = boundingBox(sel);
+        gestureRef.current = {
+          mode: "rotate",
+          cx: b.x + b.w / 2,
+          cy: b.y + b.h / 2,
+          base: objects,
+          id: sel[0].id,
+          moved: false,
+        };
+        return;
+      }
+
+      if (handleEl) {
+        const handle = handleEl.dataset.handle as ResizeHandle;
+        const sel = objects.filter((o) => selection.has(o.id) && !o.locked);
+        if (sel.length !== 1) return;
+        gestureRef.current = {
+          mode: "resize",
+          handle,
+          startX: p.x,
+          startY: p.y,
+          base: objects,
+          id: sel[0].id,
+          moved: false,
+        };
+        return;
+      }
+
+      if (objEl) {
+        const id = objEl.dataset.objectId!;
+        if (e.shiftKey) {
+          const next = new Set(selection);
+          if (next.has(id)) next.delete(id);
+          else next.add(id);
+          onSelectionChange(next);
+        } else if (!selection.has(id)) {
+          onSelectionChange(new Set([id]));
+        }
+        gestureRef.current = {
+          mode: "move",
+          startX: p.x,
+          startY: p.y,
+          base: objects,
+          moved: false,
+        };
+        return;
+      }
+
+      // Empty space: marquee-select. Shift adds to the existing selection.
+      if (!e.shiftKey) onSelectionChange(new Set());
+      gestureRef.current = {
+        mode: "marquee",
+        startX: p.x,
+        startY: p.y,
+        additive: e.shiftKey,
+      };
+      setMarquee({ x: p.x, y: p.y, w: 0, h: 0 });
+    },
+    [objects, selection, onSelectionChange, toPage],
+  );
+
+  const onPointerMove = useCallback(
+    (e: React.PointerEvent) => {
+      const g = gestureRef.current;
+      if (!g) return;
+      const p = toPage(e.clientX, e.clientY);
+      const slopX = DRAG_SLOP_PX / Math.max(size.w, 1);
+      const slopY = DRAG_SLOP_PX / Math.max(size.h, 1);
+
+      if (g.mode === "marquee") {
+        const box: Box = {
+          x: Math.min(g.startX, p.x),
+          y: Math.min(g.startY, p.y),
+          w: Math.abs(p.x - g.startX),
+          h: Math.abs(p.y - g.startY),
+        };
+        setMarquee(box);
+        const hits = objects
+          .filter(
+            (o) =>
+              o.x < box.x + box.w && o.x + o.w > box.x && o.y < box.y + box.h && o.y + o.h > box.y,
+          )
+          .map((o) => o.id);
+        onSelectionChange(new Set(g.additive ? [...selection, ...hits] : hits));
+        return;
+      }
+
+      if (g.mode === "move") {
+        let dx = p.x - g.startX;
+        let dy = p.y - g.startY;
+        if (!g.moved && Math.abs(dx) < slopX && Math.abs(dy) < slopY) return;
+        g.moved = true;
+        if (e.shiftKey) ({ dx, dy } = axisLock(dx, dy));
+
+        const moved = moveObjects(g.base, [...selection], dx, dy);
+        const sel = moved.filter((o) => selection.has(o.id));
+        if (sel.length === 0) return;
+        // Snap the selection's bounding box, then apply that one correction to
+        // every member — snapping each object independently would tear a
+        // multi-selection apart.
+        const bb = boundingBox(sel);
+        const r = snapMove(bb, {
+          others: othersFor(g.base, selection),
+          margin,
+          threshold,
+          enabled: !e.altKey,
+        });
+        const cx = r.x - bb.x;
+        const cy = r.y - bb.y;
+        setPending(cx || cy ? moveObjects(moved, [...selection], cx, cy) : moved);
+        setGuides(r.guides);
+        return;
+      }
+
+      if (g.mode === "resize") {
+        const dx = p.x - g.startX;
+        const dy = p.y - g.startY;
+        if (!g.moved && Math.abs(dx) < slopX && Math.abs(dy) < slopY) return;
+        g.moved = true;
+        const src = g.base.find((o) => o.id === g.id);
+        if (!src) return;
+        const raw = applyHandle({ x: src.x, y: src.y, w: src.w, h: src.h }, g.handle, dx, dy);
+        const r = snapResize(raw, g.handle, {
+          others: othersFor(g.base, new Set([g.id])),
+          margin,
+          threshold,
+          enabled: !e.altKey,
+        });
+        setPending(
+          updateObjects(g.base, [g.id], (o) => ({ ...o, ...r.box })),
+        );
+        setGuides(r.guides);
+        return;
+      }
+
+      if (g.mode === "rotate") {
+        const rect = pageRef.current?.getBoundingClientRect();
+        if (!rect) return;
+        const cx = rect.left + g.cx * rect.width;
+        const cy = rect.top + g.cy * rect.height;
+        let deg = (Math.atan2(e.clientY - cy, e.clientX - cx) * 180) / Math.PI + 90;
+        // Shift snaps rotation to 15° steps — the equivalent of axis lock.
+        if (e.shiftKey) deg = Math.round(deg / 15) * 15;
+        g.moved = true;
+        setPending(updateObjects(g.base, [g.id], (o) => ({ ...o, rot: Math.round(deg) })));
+        return;
+      }
+    },
+    [objects, selection, onSelectionChange, toPage, othersFor, margin, threshold, size],
+  );
+
+  const endGesture = useCallback(() => {
+    const g = gestureRef.current;
+    gestureRef.current = null;
+    setGuides([]);
+    setMarquee(null);
+    // The one commit. See the module note on why it is not per-move.
+    const final = pendingRef.current;
+    if (g && g.mode !== "marquee" && g.moved && final) onObjectsChange(final);
+    setPending(null);
+  }, [onObjectsChange, setPending]);
+
+  // A capture-losing event (another window stealing focus, a touch cancel) has
+  // to end the gesture too, or `pending` outlives it and the stage freezes on a
+  // half-finished drag.
+  const onPointerUp = useCallback(() => endGesture(), [endGesture]);
+
+  // Double-click is a separate native event from the pointer gestures above, so
+  // it needs no coordination with the drag/resize/rotate state machine — a
+  // double-click that lands mid-drag never happens because a drag's second
+  // pointerdown is on a different frame than its first.
+  const onDoubleClick = useCallback(
+    (e: React.MouseEvent) => {
+      if (!onEditObject) return;
+      const objEl = (e.target as HTMLElement).closest<HTMLElement>("[data-object-id]");
+      if (!objEl) return;
+      const obj = objects.find((o) => o.id === objEl.dataset.objectId);
+      if (obj) onEditObject(obj);
+    },
+    [objects, onEditObject],
+  );
+
+  // --- render ------------------------------------------------------------
+
+  const pointScale = size.w > 0 && pageWidth > 0 ? size.w / pageWidth : 1;
+  const selected = objects.filter((o) => selection.has(o.id));
+  const selBox = selected.length > 0 ? boundingBox(selected) : null;
+  const singleSelection = selected.length === 1 && !selected[0].locked;
+
+  return (
+    <div className="deck-stage" ref={hostRef}>
+      <div
+        className="deck-stage-page"
+        ref={pageRef}
+        style={{ width: size.w, height: size.h }}
+        onPointerDown={onPointerDown}
+        onPointerMove={onPointerMove}
+        onPointerUp={onPointerUp}
+        onPointerCancel={onPointerUp}
+        onLostPointerCapture={onPointerUp}
+        onDoubleClick={onDoubleClick}
+      >
+        <canvas className="deck-stage-canvas" ref={canvasRef} />
+
+        {margin > 0 && (
+          <div
+            className="deck-stage-margin"
+            style={{ inset: `${margin * 100}% ${margin * 100}%` }}
+            aria-hidden
+          />
+        )}
+
+        {objects.map((o) => (
+          <DeckObjectView
+            key={o.id}
+            obj={dimmed(o, previewStep)}
+            pageW={size.w}
+            pageH={size.h}
+            pointScale={pointScale}
+            assetUrl={o.kind === "image" ? assets?.get(o.src) : undefined}
+            metrics={metrics}
+            selected={selection.has(o.id)}
+          />
+        ))}
+
+        {showBuildBadges &&
+          objects
+            .filter((o) => (o.build?.step ?? 0) > 0)
+            .map((o) => (
+              <span
+                key={`b-${o.id}`}
+                className="deck-build-badge"
+                style={{ left: o.x * size.w, top: o.y * size.h }}
+                title={`Appears at build step ${o.build!.step} (${o.build!.effect})`}
+              >
+                {o.build!.step}
+              </span>
+            ))}
+
+        {selBox && (
+          <div
+            className="deck-selection"
+            style={{
+              left: selBox.x * size.w,
+              top: selBox.y * size.h,
+              width: selBox.w * size.w,
+              height: selBox.h * size.h,
+            }}
+          >
+            {singleSelection && (
+              <>
+                {HANDLES.map((h) => (
+                  <span key={h} className={`deck-handle deck-handle-${h}`} data-handle={h} />
+                ))}
+                <span className="deck-rotate" data-rotate="1" />
+              </>
+            )}
+          </div>
+        )}
+
+        {marquee && (
+          <div
+            className="deck-marquee"
+            style={{
+              left: marquee.x * size.w,
+              top: marquee.y * size.h,
+              width: marquee.w * size.w,
+              height: marquee.h * size.h,
+            }}
+          />
+        )}
+
+        <svg className="deck-guides" width={size.w} height={size.h} aria-hidden>
+          {guides.map((g, i) =>
+            g.axis === "x" ? (
+              <line
+                key={i}
+                className={`deck-guide deck-guide-${g.kind}`}
+                x1={g.at * size.w}
+                x2={g.at * size.w}
+                y1={g.from * size.h}
+                y2={g.to * size.h}
+              />
+            ) : (
+              <line
+                key={i}
+                className={`deck-guide deck-guide-${g.kind}`}
+                x1={g.from * size.w}
+                x2={g.to * size.w}
+                y1={g.at * size.h}
+                y2={g.at * size.h}
+              />
+            ),
+          )}
+        </svg>
+      </div>
+    </div>
+  );
+}
+
+/** Objects past the previewed build step are dimmed rather than hidden, so they
+ *  stay selectable while their steps are being arranged. */
+function dimmed(o: DeckObject, step?: number): DeckObject {
+  if (step === undefined || visibleAt(o, step)) return o;
+  return { ...o, opacity: o.opacity * 0.25 };
+}
+
+/** Apply a resize-handle drag to a box, before snapping. */
+export function applyHandle(box: Box, handle: ResizeHandle, dx: number, dy: number): Box {
+  let { x, y, w, h } = box;
+  if (handle.includes("w")) {
+    x += dx;
+    w -= dx;
+  }
+  if (handle.includes("e")) w += dx;
+  if (handle.includes("n")) {
+    y += dy;
+    h -= dy;
+  }
+  if (handle.includes("s")) h += dy;
+  return { x, y, w, h };
+}
diff --git a/src/components/embed/deck/DeckTexPanel.tsx b/src/components/embed/deck/DeckTexPanel.tsx
new file mode 100644
index 0000000..02e680e
--- /dev/null
+++ b/src/components/embed/deck/DeckTexPanel.tsx
@@ -0,0 +1,82 @@
+/**
+ * The deck-wide index of TeX figures — every image object with a `texSrc`,
+ * across every slide, in one clickable list.
+ *
+ * Exists because double-clicking a figure on the stage only reaches whichever
+ * one is on the CURRENT slide. A talk with a dozen formulas scattered across
+ * a dozen slides otherwise has no way to find "the TeX behind slide 7's second
+ * figure" without hunting for it first — this mode is that hunt, done once.
+ */
+
+import type { Deck, ImageObject } from "../../../lib/viewers/deck/model";
+
+export interface TexFigureEntry {
+  slideIndex: number;
+  obj: ImageObject & { texSrc: string };
+}
+
+/** Every TeX-figure object in the deck, in slide order. */
+export function texFigures(deck: Deck): TexFigureEntry[] {
+  const out: TexFigureEntry[] = [];
+  deck.slides.forEach((s, slideIndex) => {
+    for (const o of s.objects) {
+      if (o.kind === "image" && o.texSrc) out.push({ slideIndex, obj: o as ImageObject & { texSrc: string } });
+    }
+  });
+  return out;
+}
+
+export interface DeckTexPanelProps {
+  deck: Deck;
+  /** Select this slide + object on the stage, without leaving TeX mode. */
+  onJump: (slideIndex: number, objectId: string) => void;
+  onEditTex: (obj: ImageObject) => void;
+  onRecompileTex: (obj: ImageObject) => void;
+  texBusyIds?: ReadonlySet<string>;
+}
+
+export function DeckTexPanel({ deck, onJump, onEditTex, onRecompileTex, texBusyIds }: DeckTexPanelProps) {
+  const entries = texFigures(deck);
+
+  return (
+    <div className="deck-inspector deck-tex-panel">
+      <div className="deck-inspector-head">TeX figures</div>
+      {entries.length === 0 ? (
+        <p className="deck-inspector-empty">
+          No TeX figures yet — use the toolbar's TeX button to add one to a slide.
+        </p>
+      ) : (
+        <ul className="deck-tex-list">
+          {entries.map(({ slideIndex, obj }) => (
+            <li key={obj.id} className="deck-tex-list-item">
+              <button
+                className="deck-tex-list-jump"
+                onClick={() => onJump(slideIndex, obj.id)}
+                title={obj.texSrc}
+              >
+                <span className="deck-tex-list-slide">Slide {slideIndex + 1}</span>
+                <span className="deck-tex-list-name">{obj.texSrc.split("/").pop()}</span>
+              </button>
+              <div className="deck-tex-list-actions">
+                <button
+                  className="deck-inspector-btn"
+                  disabled={texBusyIds?.has(obj.id)}
+                  onClick={() => onEditTex(obj)}
+                >
+                  Edit
+                </button>
+                <button
+                  className="deck-inspector-btn"
+                  disabled={texBusyIds?.has(obj.id)}
+                  onClick={() => onRecompileTex(obj)}
+                >
+                  {texBusyIds?.has(obj.id) ? "Compiling…" : "Recompile"}
+                </button>
+              </div>
+            </li>
+          ))}
+        </ul>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/DeckView.tsx b/src/components/embed/deck/DeckView.tsx
new file mode 100644
index 0000000..55f35bc
--- /dev/null
+++ b/src/components/embed/deck/DeckView.tsx
@@ -0,0 +1,1379 @@
+/**
+ * The deck editor's shell: load the sidecar and its base PDF, re-anchor, host the
+ * rail and the stage, and autosave.
+ *
+ * **Why this owns its own I/O instead of using `useEditableFile`.** That hook is
+ * string-typed end to end and writes on *every* change while dirty — correct for
+ * a text editor, wrong for a document mutated by dragging, where it would issue a
+ * disk write per pointer frame. It also cannot create a file, and `write_file_text`
+ * refuses a path that does not exist. So the deck debounces its own writes and
+ * goes through `writeFileBytes`, which may create.
+ *
+ * **Why there is no save button.** Eldrun has no unsaved-work prompt anywhere —
+ * `closeTabWithConfirm` is literally `removeTab` — so a deck must never *hold*
+ * unsaved state. It is small, it is text, and it is under git, which is where the
+ * durable undo belongs. Ctrl+Z is the in-session undo; git is the real one.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { open } from "@tauri-apps/plugin-dialog";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import { UntestedTag } from "../../common/UntestedTag";
+import {
+  describeFileError,
+  fileMtime,
+  readFileBytes,
+  readFileText,
+  useFileScope,
+  writeFileBytes,
+} from "../fileAccess";
+import { openLinkedFile, useViewerState } from "../FileViewerPane";
+import {
+  type Deck,
+  type DeckObject,
+  type ImageObject,
+  type ObjectList,
+  type Slide,
+  DUPLICATE_OFFSET,
+  alignObjects,
+  duplicateObjects,
+  insertSlide,
+  lowerObjects,
+  moveObjects,
+  moveSlides,
+  newInterstitialId,
+  newObjectId,
+  newSlideId,
+  raiseObjects,
+  removeObjects,
+  toBack,
+  toFront,
+  updateSlide,
+} from "../../../lib/viewers/deck/model";
+import {
+  type BasePage,
+  parseDeck,
+  pdfPathForDeck,
+  serializeDeck,
+  reattach,
+  reconcile,
+} from "../../../lib/viewers/deck/sidecar";
+import { type TextMetrics, loadMetrics } from "../../../lib/viewers/deck/fonts";
+import type { IconDef } from "../../../lib/viewers/deck/icons";
+import { exportDeck, exportPathFor } from "../../../lib/viewers/deck/export";
+import {
+  starterTex,
+  starterTexFigure,
+  texPathForDeck,
+  titleFromPath,
+} from "../../../lib/viewers/deck/template";
+import { getTexCapability, type TexCompileResult } from "../../../lib/viewers/tex";
+import { loadBase, renderPage, renderPdfPageToPng } from "./deckBase";
+import {
+  dirOf,
+  interstitialsOf,
+  resolveRel,
+  useDeckGifs,
+  useDeckImages,
+} from "./deckAssets";
+import { DeckStage } from "./DeckStage";
+import { DeckInspector } from "./DeckInspector";
+import { DeckAnimate } from "./DeckAnimate";
+import { DeckNotes } from "./DeckNotes";
+import { DeckTexPanel } from "./DeckTexPanel";
+import { DeckPresenter } from "./DeckPresenter";
+import { IconPicker } from "./IconPicker";
+import { posterPng } from "./gifPlayback";
+
+/** Bounds for the rail's user-resizable width (px). Wide enough at the max that
+ *  a thumbnail is actually legible, narrow enough at the min to stay a rail. */
+export const DECK_RAIL_MIN_WIDTH = 84;
+export const DECK_RAIL_MAX_WIDTH = 260;
+export const DECK_RAIL_DEFAULT_WIDTH = 112;
+
+export function clampRailWidth(w: number): number {
+  return Math.min(DECK_RAIL_MAX_WIDTH, Math.max(DECK_RAIL_MIN_WIDTH, Math.round(w)));
+}
+
+/** How often a TeX-figure's compiled PDF is checked for a newer mtime — i.e. a
+ *  recompile the author ran from the source tab this view opened. Matches the
+ *  PDF viewer's own external-change poll (`PdfViewer.RELOAD_POLL_MS`); there is
+ *  no reason for a deck's figures to notice a recompile any slower. */
+const TEX_FIGURE_POLL_MS = 1500;
+
+/** The per-deck folder a TeX-figure object's source/PDF/PNG live in, beside the
+ *  sidecar — kept out of the main `.tex`'s own directory so a figure's build
+ *  artifacts (`.aux`/`.log`) never clutter the deck's own folder listing. */
+function texFigureDir(deckPath: string): string {
+  return `${deckPath.replace(/\.eldeck\.json$/i, "")}.tex-figures`;
+}
+
+/** One slide's thumbnail in the rail — its own small component so each row
+ *  renders its canvas independently as `doc`/page/size change, the same
+ *  "render into a ref'd canvas via an effect" shape `DeckStage` uses for the
+ *  full-size page. */
+function DeckRailThumb({
+  doc,
+  page,
+  width,
+  height,
+}: {
+  doc: PDFDocumentProxy | null;
+  page: number;
+  width: number;
+  height: number;
+}) {
+  const ref = useRef<HTMLCanvasElement | null>(null);
+  useEffect(() => {
+    const canvas = ref.current;
+    if (!canvas || !doc || width <= 0 || height <= 0) return;
+    return renderPage(doc, page, canvas, width, height);
+  }, [doc, page, width, height]);
+  return <canvas className="deck-rail-thumb" ref={ref} />;
+}
+
+/** How long after the last edit the sidecar is written. Long enough that a
+ *  gesture-heavy minute is a handful of writes, short enough that closing the tab
+ *  right after an edit still catches it. */
+const AUTOSAVE_MS = 800;
+
+/** Arrow-key nudge, as a fraction of the page. Shift multiplies it. */
+const NUDGE = 0.002;
+
+export interface DeckViewProps {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+  groupId?: string | null;
+}
+
+export function DeckView({ path, onOpenExternally, tabKey, groupId }: DeckViewProps) {
+  const scope = useFileScope();
+
+  const [deck, setDeck] = useState<Deck | null>(null);
+  const [doc, setDoc] = useState<PDFDocumentProxy | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [slideIndex, setSlideIndex] = useState(0);
+  const [selection, setSelection] = useState<Set<string>>(new Set());
+  const [saving, setSaving] = useState(false);
+  const [metrics, setMetrics] = useState<TextMetrics | null>(null);
+  const [picking, setPicking] = useState<null | "new" | "replace">(null);
+  const [mode, setMode] = useState<"design" | "animate" | "notes" | "tex">("design");
+  const [previewStep, setPreviewStep] = useState(0);
+  const [presenting, setPresenting] = useState(false);
+  const [exporting, setExporting] = useState(false);
+  const [generating, setGenerating] = useState(false);
+  /** Bumped to force a reload after the base plate is (re)generated. */
+  const [reloadNonce, setReloadNonce] = useState(0);
+  const [texAvailable, setTexAvailable] = useState(false);
+  /** Ids of TeX-figure objects currently (re)compiling — the FAB, an explicit
+   *  Recompile, and the external-change poll can all be in flight at once, each
+   *  for a different object, so this is a set rather than a single flag. */
+  const [texBusyIds, setTexBusyIds] = useState<ReadonlySet<string>>(new Set());
+
+  const railState = useViewerState(tabKey);
+  const [railWidth, setRailWidth] = useState(() =>
+    clampRailWidth(railState.initial?.deckRailWidth ?? DECK_RAIL_DEFAULT_WIDTH),
+  );
+  /** Live width during a drag; committed (and persisted) only on release — see
+   *  `SubwindowFilesSidebar`, whose resize handle this mirrors. */
+  const [liveRailWidth, setLiveRailWidth] = useState<number | null>(null);
+
+  const past = useRef<Deck[]>([]);
+  const future = useRef<Deck[]>([]);
+  /** Suppresses the autosave that would otherwise fire for the initial load. */
+  const loadedRef = useRef(false);
+  /** Last-seen mtime of each TeX-figure's compiled PDF (by absolute path), so
+   *  the poll below can tell "a recompile just happened" from "nothing changed"
+   *  without re-rasterizing on every tick. Seeded by every write this view makes
+   *  itself, so its own compiles never look like an external change. */
+  const mtimesRef = useRef<Map<string, number>>(new Map());
+
+  // The standard-14 metrics the stage lays text out with. Loaded once per app
+  // run (the module memoizes), and rendering degrades to CSS wrapping until it
+  // resolves rather than showing nothing.
+  useEffect(() => {
+    let live = true;
+    void loadMetrics().then((m) => {
+      if (live) setMetrics(m);
+    });
+    return () => {
+      live = false;
+    };
+  }, []);
+
+  // --- load --------------------------------------------------------------
+  useEffect(() => {
+    let cancelled = false;
+    let opened: PDFDocumentProxy | null = null;
+    loadedRef.current = false;
+    setError(null);
+    setNotice(null);
+
+    void (async () => {
+      let parsed: ReturnType<typeof parseDeck>;
+      try {
+        const text = await readFileText(path, scope);
+        parsed = parseDeck(text);
+      } catch (e) {
+        if (!cancelled) setError(describeFileError(e));
+        return;
+      }
+      if (cancelled) return;
+      if (parsed.error) {
+        setError(`This deck could not be read: ${parsed.error}`);
+        return;
+      }
+
+      const dir = dirOf(path);
+      const basePath = resolveRel(dir, parsed.deck.base ?? pdfPathForDeck(path));
+
+      let pages: BasePage[] = [];
+      try {
+        const base = await loadBase(basePath, scope);
+        opened = base.doc;
+        pages = base.pages;
+      } catch (e) {
+        // A missing base plate is not a broken deck — the layers are still
+        // intact and worth showing. Say so rather than failing the whole view.
+        if (!cancelled) setNotice(`Base PDF could not be opened (${describeFileError(e)}).`);
+      }
+      if (cancelled) {
+        opened?.destroy();
+        return;
+      }
+
+      const r = reconcile(parsed.deck, pages);
+      setDoc(opened);
+      setDeck(r.deck);
+      setSlideIndex((i) => Math.min(i, Math.max(0, r.deck.slides.length - 1)));
+
+      const notes: string[] = [];
+      if (parsed.repaired) notes.push(`Repaired on load: ${parsed.repaired}.`);
+      if (r.detached > 0) {
+        notes.push(
+          `${r.detached} layer${r.detached === 1 ? "" : "s"} no longer match a page and ` +
+            `${r.detached === 1 ? "was" : "were"} set aside rather than deleted.`,
+        );
+      }
+      if (r.moved > 0) notes.push(`Re-anchored ${r.moved} slide${r.moved === 1 ? "" : "s"}.`);
+      if (notes.length) setNotice(notes.join(" "));
+
+      // Anchors just changed; let the first autosave persist them.
+      loadedRef.current = true;
+    })();
+
+    return () => {
+      cancelled = true;
+      opened?.destroy();
+      setDoc(null);
+    };
+  }, [path, scope, reloadNonce]);
+
+  useEffect(() => {
+    void getTexCapability().then((c) => setTexAvailable(c.available));
+  }, []);
+
+  // --- autosave ----------------------------------------------------------
+  useEffect(() => {
+    if (!deck || !loadedRef.current) return;
+    const t = setTimeout(() => {
+      setSaving(true);
+      void writeFileBytes(path, new TextEncoder().encode(serializeDeck(deck)), scope)
+        .catch((e) => setError(describeFileError(e)))
+        .finally(() => setSaving(false));
+    }, AUTOSAVE_MS);
+    return () => clearTimeout(t);
+  }, [deck, path, scope]);
+
+  // --- editing -----------------------------------------------------------
+
+  /** Every mutation goes through here, so history is impossible to forget. */
+  const commit = useCallback((next: (d: Deck) => Deck) => {
+    setDeck((cur) => {
+      if (!cur) return cur;
+      const out = next(cur);
+      if (out === cur) return cur;
+      past.current = [...past.current.slice(-99), cur];
+      future.current = [];
+      return out;
+    });
+  }, []);
+
+  const setObjects = useCallback(
+    (objects: ObjectList) => {
+      commit((d) => ({
+        ...d,
+        slides: updateSlide(d.slides, slideIndex, (s) => ({ ...s, objects })),
+      }));
+    },
+    [commit, slideIndex],
+  );
+
+  /** Apply a pure object-list op to the current slide. */
+  const withObjects = useCallback(
+    (op: (list: ObjectList, ids: string[]) => ObjectList) => {
+      setDeck((cur) => {
+        if (!cur) return cur;
+        const slide = cur.slides[slideIndex];
+        if (!slide) return cur;
+        const objects = op(slide.objects, [...selection]);
+        if (objects === slide.objects) return cur;
+        past.current = [...past.current.slice(-99), cur];
+        future.current = [];
+        return {
+          ...cur,
+          slides: updateSlide(cur.slides, slideIndex, (s) => ({ ...s, objects })),
+        };
+      });
+    },
+    [slideIndex, selection],
+  );
+
+  const undo = useCallback(() => {
+    setDeck((cur) => {
+      const prev = past.current.pop();
+      if (!cur || !prev) return cur;
+      future.current = [...future.current, cur];
+      return prev;
+    });
+  }, []);
+
+  const redo = useCallback(() => {
+    setDeck((cur) => {
+      const next = future.current.pop();
+      if (!cur || !next) return cur;
+      past.current = [...past.current, cur];
+      return next;
+    });
+  }, []);
+
+  // --- copy / duplicate ----------------------------------------------------
+  // An in-memory object clipboard, not the OS one: a deck object is a structured
+  // value, and serializing it through the system clipboard (text or an image of
+  // its render) would lose exactly what makes it editable. Paste lands on the
+  // *current* slide, so it doubles as "copy this to another slide".
+  const clipboard = useRef<DeckObject[]>([]);
+
+  const copySelection = useCallback(() => {
+    if (!deck || selection.size === 0) return;
+    const slide = deck.slides[slideIndex];
+    if (!slide) return;
+    clipboard.current = slide.objects.filter((o) => selection.has(o.id)).map((o) => ({ ...o }));
+  }, [deck, selection, slideIndex]);
+
+  /** Add clones of `objs` to the current slide, offset and freshly-ided, and
+   *  select them — the shared tail of paste and cross-slide copy. */
+  const addClones = useCallback(
+    (objs: readonly DeckObject[]) => {
+      if (objs.length === 0) return;
+      const fresh: string[] = [];
+      const clones = objs.map((o) => {
+        const id = newObjectId();
+        fresh.push(id);
+        return { ...o, id, x: o.x + DUPLICATE_OFFSET, y: o.y + DUPLICATE_OFFSET };
+      });
+      commit((d) => ({
+        ...d,
+        slides: updateSlide(d.slides, slideIndex, (s) => ({ ...s, objects: [...s.objects, ...clones] })),
+      }));
+      setSelection(new Set(fresh));
+    },
+    [commit, slideIndex],
+  );
+
+  const pasteClipboard = useCallback(() => addClones(clipboard.current), [addClones]);
+
+  const duplicateSelection = useCallback(() => {
+    if (!deck || selection.size === 0) return;
+    const slide = deck.slides[slideIndex];
+    if (!slide) return;
+    const { list, ids } = duplicateObjects(slide.objects, [...selection]);
+    if (list === slide.objects) return;
+    commit((d) => ({
+      ...d,
+      slides: updateSlide(d.slides, slideIndex, (s) => ({ ...s, objects: list })),
+    }));
+    setSelection(new Set(ids));
+  }, [deck, selection, slideIndex, commit]);
+
+  // --- slide reorder -------------------------------------------------------
+  // The presentation sequence is the deck's own slide order (reconcile preserves
+  // it across a reload), so moving a slide earlier/later is a durable edit — it
+  // does not touch which base page each slide backs.
+  const moveSlide = useCallback(
+    (from: number, dir: -1 | 1) => {
+      const to = from + dir;
+      commit((d) => {
+        if (to < 0 || to >= d.slides.length) return d;
+        return { ...d, slides: moveSlides(d.slides, [d.slides[from].id], to) };
+      });
+      // An adjacent move is a swap of `from` and `to`; keep the viewer on whatever
+      // slide it was showing.
+      setSlideIndex((i) => (i === from ? to : i === to ? from : i));
+    },
+    [commit],
+  );
+
+  // Copy a slide: a fresh-ided clone (its own objects, its own interstitial) that
+  // backs the SAME base page as the original — durable now that reconcile lets two
+  // slides share a page. Lands right after the original.
+  const duplicateSlide = useCallback(
+    (index: number) => {
+      commit((d) => {
+        const src = d.slides[index];
+        if (!src) return d;
+        const copy: Slide = {
+          ...src,
+          id: newSlideId(),
+          objects: src.objects.map((o) => ({ ...o, id: newObjectId() })),
+          ...(src.after ? { after: { ...src.after, id: newInterstitialId() } } : {}),
+        };
+        return { ...d, slides: insertSlide(d.slides, copy, index + 1) };
+      });
+      setSlideIndex(index + 1);
+      setSelection(new Set());
+    },
+    [commit],
+  );
+
+  const addRect = useCallback(() => {
+    if (!deck) return;
+    const id = newObjectId();
+    withObjects((list) => [
+      ...list,
+      {
+        id,
+        kind: "shape",
+        shape: "rect",
+        fill: deck.theme.shapeFill,
+        stroke: deck.theme.shapeStroke,
+        strokeWidth: deck.theme.shapeStrokeWidth,
+        x: 0.35,
+        y: 0.4,
+        w: 0.3,
+        h: 0.2,
+        rot: 0,
+        opacity: 1,
+      },
+    ]);
+    setSelection(new Set([id]));
+  }, [deck, withObjects]);
+
+  const addText = useCallback(() => {
+    if (!deck) return;
+    const id = newObjectId();
+    withObjects((list) => [
+      ...list,
+      {
+        id,
+        kind: "text",
+        text: "Text",
+        style: { ...deck.theme.text },
+        padding: 2,
+        x: 0.3,
+        y: 0.45,
+        w: 0.4,
+        h: 0.1,
+        rot: 0,
+        opacity: 1,
+      },
+    ]);
+    setSelection(new Set([id]));
+  }, [deck, withObjects]);
+
+  // --- assets --------------------------------------------------------------
+  // Images and interstitial clips are loaded by the shared hooks the audience
+  // window also uses, so the projector and the editor can never resolve a
+  // deck-relative path two different ways.
+  const { assets, refresh: refreshImage } = useDeckImages(deck, path, scope);
+  const interstitials = useMemo(() => interstitialsOf(deck), [deck]);
+  const gifs = useDeckGifs(interstitials, path, scope);
+
+  const addIcon = useCallback(
+    (def: IconDef) => {
+      if (!deck) return;
+      if (picking === "replace") {
+        withObjects((list, ids) =>
+          list.map((o) => (ids.includes(o.id) && o.kind === "icon" ? { ...o, icon: def.key } : o)),
+        );
+        setPicking(null);
+        return;
+      }
+      const id = newObjectId();
+      // Square by default: an icon stretched to a random box reads as a mistake,
+      // and the aspect is measured against the page, not the box.
+      const side = 0.12;
+      withObjects((list) => [
+        ...list,
+        {
+          id,
+          kind: "icon",
+          icon: def.key,
+          color: deck.theme.iconColor,
+          strokeWidth: deck.theme.iconStrokeWidth,
+          x: 0.44,
+          y: 0.44,
+          w: side,
+          h: (side * deck.pageWidth) / deck.pageHeight,
+          rot: 0,
+          opacity: 1,
+        },
+      ]);
+      setSelection(new Set([id]));
+      setPicking(null);
+    },
+    [deck, picking, withObjects],
+  );
+
+  // --- export -------------------------------------------------------------
+  const doExport = useCallback(async () => {
+    if (!deck || !metrics) return;
+    setExporting(true);
+    setNotice(null);
+    try {
+      const dir = dirOf(path);
+      const basePath = resolveRel(dir, deck.base ?? pdfPathForDeck(path));
+      let baseBytes: Uint8Array | null = null;
+      try {
+        baseBytes = new Uint8Array(await readFileBytes(basePath, scope));
+      } catch {
+        // Exporting a deck whose plate has gone is still worth doing — the
+        // layers are the part the author made.
+      }
+
+      const images = new Map<string, Uint8Array>();
+      for (const slide of deck.slides) {
+        for (const o of slide.objects) {
+          if (o.kind !== "image" || images.has(o.src)) continue;
+          try {
+            images.set(o.src, new Uint8Array(await readFileBytes(resolveRel(dir, o.src), scope)));
+          } catch {
+            // Reported as a warning by the exporter, which knows the context.
+          }
+        }
+      }
+
+      // A GIF cannot be a PDF page, so each interstitial contributes its poster
+      // frame. Encoding needs a canvas, which is why it happens here and not in
+      // the (deliberately DOM-free, testable) exporter.
+      const posters = new Map<string, Uint8Array>();
+      for (const a of interstitials) {
+        const g = gifs.get(a.id);
+        if (!g) continue;
+        const png = await posterPng(g, a.poster);
+        if (png) posters.set(a.id, png);
+      }
+
+      const out = await exportDeck({ deck, baseBytes, images, posters, metrics });
+      const target = exportPathFor(path);
+      await writeFileBytes(target, out.bytes, scope);
+      setNotice(
+        `Exported ${out.pages} page${out.pages === 1 ? "" : "s"} to ${target.split("/").pop()}.` +
+          (out.warnings.length ? ` ${out.warnings.join(" ")}` : ""),
+      );
+    } catch (e) {
+      setError(describeFileError(e));
+    } finally {
+      setExporting(false);
+    }
+  }, [deck, metrics, path, scope, interstitials, gifs]);
+
+  const toDeckRelative = useCallback(
+    (absolute: string) => {
+      const dir = dirOf(path);
+      return dir && absolute.startsWith(`${dir}/`) ? absolute.slice(dir.length + 1) : absolute;
+    },
+    [path],
+  );
+
+  const patchSlide = useCallback(
+    (patch: (s: import("../../../lib/viewers/deck/model").Slide) => import("../../../lib/viewers/deck/model").Slide) => {
+      commit((d) => ({ ...d, slides: updateSlide(d.slides, slideIndex, patch) }));
+    },
+    [commit, slideIndex],
+  );
+
+  // --- generate a base plate ----------------------------------------------
+  /**
+   * The "from blank" path: write a starter Beamer `.tex` and compile it into the
+   * base plate this deck is missing.
+   *
+   * Deliberately never overwrites an existing `.tex` — the author owns that file
+   * from the moment it is created, and Eldrun writing over a source they have
+   * been editing is exactly the trust this feature cannot afford to lose.
+   */
+  const generateBase = useCallback(async () => {
+    setGenerating(true);
+    setError(null);
+    try {
+      const texPath = texPathForDeck(path);
+      let hasTex = true;
+      try {
+        await readFileText(texPath, scope);
+      } catch {
+        hasTex = false;
+      }
+      if (!hasTex) {
+        await writeFileBytes(
+          texPath,
+          new TextEncoder().encode(starterTex({ title: titleFromPath(path) })),
+          scope,
+        );
+      }
+      const res = await invoke<TexCompileResult>("compile_tex", { path: texPath });
+      if (!res.success) {
+        setNotice(
+          `The starter LaTeX did not compile. ${res.log.trim().split("\n").slice(-3).join(" ")}`,
+        );
+        return;
+      }
+      setNotice(hasTex ? "Recompiled the base PDF." : "Created a starter LaTeX file and compiled it.");
+      setReloadNonce((n) => n + 1);
+    } catch (e) {
+      setError(describeFileError(e));
+    } finally {
+      setGenerating(false);
+    }
+  }, [path, scope]);
+
+  /**
+   * Place an image. Stored **deck-relative** when the file is under the deck's
+   * own folder, so moving or syncing the project does not break it; an absolute
+   * path is kept only for a file genuinely outside the tree, where there is no
+   * relative form to record.
+   */
+  const addImage = useCallback(async () => {
+    const chosen = await open({
+      multiple: false,
+      filters: [{ name: "Image", extensions: ["png", "jpg", "jpeg"] }],
+    });
+    if (typeof chosen !== "string") return;
+    const id = newObjectId();
+    withObjects((list) => [
+      ...list,
+      {
+        id,
+        kind: "image",
+        src: toDeckRelative(chosen),
+        fit: "contain",
+        x: 0.3,
+        y: 0.3,
+        w: 0.4,
+        h: 0.4,
+        rot: 0,
+        opacity: 1,
+      },
+    ]);
+    setSelection(new Set([id]));
+  }, [withObjects, toDeckRelative]);
+
+  // --- TeX figures ---------------------------------------------------------
+  // A TeX figure is an ordinary `image` object whose `src` PNG is generated by
+  // compiling and rasterizing a `.tex` the object also remembers (`texSrc`).
+  // Three entry points converge on one low-level step (`rasterizeInto`): the
+  // toolbar FAB creates the pair from scratch, "Recompile" reruns an existing
+  // one, and the poll below reacts when the author recompiles from the source
+  // tab directly rather than from here.
+
+  const markTexBusy = useCallback((id: string, busy: boolean) => {
+    setTexBusyIds((cur) => {
+      const next = new Set(cur);
+      if (busy) next.add(id);
+      else next.delete(id);
+      return next;
+    });
+  }, []);
+
+  /** Read `pdfAbs`, rasterize its first page, and write the PNG to `pngAbs`.
+   *  Records the PDF's new mtime so the poll never re-processes a write this
+   *  view just made itself. Returns the raster's pixel size, or null on
+   *  failure (reported by the caller, which knows the right wording). */
+  const rasterizeInto = useCallback(
+    async (pdfAbs: string, pngAbs: string) => {
+      const pdfBytes = new Uint8Array(await readFileBytes(pdfAbs, scope));
+      const rendered = await renderPdfPageToPng(pdfBytes);
+      if (!rendered) return null;
+      await writeFileBytes(pngAbs, rendered.png, scope);
+      const mt = await fileMtime(pdfAbs, scope).catch(() => null);
+      if (mt != null) mtimesRef.current.set(pdfAbs, mt);
+      return rendered;
+    },
+    [scope],
+  );
+
+  const addTexFigure = useCallback(async () => {
+    if (!deck) return;
+    const dir = texFigureDir(path);
+    const id = newObjectId();
+    const texAbs = `${dir}/${id}.tex`;
+    const pngAbs = `${dir}/${id}.png`;
+    markTexBusy(id, true);
+    setError(null);
+    try {
+      await writeFileBytes(texAbs, new TextEncoder().encode(starterTexFigure()), scope);
+      const res = await invoke<TexCompileResult>("compile_tex", { path: texAbs });
+      if (!res.success || !res.pdf_path) {
+        setNotice(
+          `The TeX figure did not compile. ${res.log.trim().split("\n").slice(-3).join(" ")}`,
+        );
+        return;
+      }
+      const rendered = await rasterizeInto(res.pdf_path, pngAbs);
+      if (!rendered) {
+        setNotice("The TeX figure compiled, but Eldrun could not rasterize the result.");
+        return;
+      }
+      // Preserve the figure's own aspect ratio rather than forcing it into a
+      // square — a wide equation squashed into a box is illegible.
+      const w = 0.3;
+      const h = w * (deck.pageWidth / deck.pageHeight) * (rendered.height / rendered.width);
+      withObjects((list) => [
+        ...list,
+        {
+          id,
+          kind: "image",
+          src: toDeckRelative(pngAbs),
+          texSrc: toDeckRelative(texAbs),
+          fit: "contain",
+          x: 0.35,
+          y: 0.35,
+          w,
+          h,
+          rot: 0,
+          opacity: 1,
+        },
+      ]);
+      setSelection(new Set([id]));
+    } catch (e) {
+      setError(describeFileError(e));
+    } finally {
+      markTexBusy(id, false);
+    }
+  }, [deck, path, scope, withObjects, toDeckRelative, rasterizeInto, markTexBusy]);
+
+  /** Open a TeX-figure's source as its own tab — Eldrun's full TeX editor, with
+   *  its own Compile button and SyncTeX. The poll below is what notices when
+   *  that tab's own recompile finishes and updates the slide. */
+  const editTexObject = useCallback(
+    (obj: ImageObject) => {
+      if (!obj.texSrc) return;
+      const dir = dirOf(path);
+      openLinkedFile(tabKey, dir, {
+        path: resolveRel(dir, obj.texSrc),
+        viewer: "tex",
+        label: obj.texSrc.split("/").pop() ?? obj.texSrc,
+      });
+    },
+    [path, tabKey],
+  );
+
+  const recompileTexObject = useCallback(
+    async (obj: ImageObject) => {
+      if (!obj.texSrc) return;
+      const dir = dirOf(path);
+      const texAbs = resolveRel(dir, obj.texSrc);
+      const pngAbs = resolveRel(dir, obj.src);
+      markTexBusy(obj.id, true);
+      setError(null);
+      try {
+        const res = await invoke<TexCompileResult>("compile_tex", { path: texAbs });
+        if (!res.success || !res.pdf_path) {
+          setNotice(`Recompile failed. ${res.log.trim().split("\n").slice(-3).join(" ")}`);
+          return;
+        }
+        const rendered = await rasterizeInto(res.pdf_path, pngAbs);
+        if (!rendered) {
+          setNotice("Recompiled, but Eldrun could not rasterize the result.");
+          return;
+        }
+        refreshImage(obj.src);
+      } catch (e) {
+        setError(describeFileError(e));
+      } finally {
+        markTexBusy(obj.id, false);
+      }
+    },
+    [path, rasterizeInto, refreshImage, markTexBusy],
+  );
+
+  /** Jump to a TeX figure from the deck-wide list (`DeckTexPanel`): select its
+   *  slide and the object itself, without leaving TeX mode. */
+  const jumpToTexFigure = useCallback((slideIdx: number, objectId: string) => {
+    setSlideIndex(slideIdx);
+    setSelection(new Set([objectId]));
+  }, []);
+
+  // Notice an external recompile — the author hit Compile in the `.tex` tab
+  // this view opened, rather than using the Recompile button here — by polling
+  // every TeX figure's compiled PDF for an mtime this view did not itself just
+  // record. Mirrors the PDF viewer's own external-change poll (same interval);
+  // deliberately skips any object already mid-compile, so a manual Recompile
+  // and this poll can never race to rasterize the same PDF twice.
+  useEffect(() => {
+    if (!deck) return;
+    const figures = deck.slides.flatMap((s) =>
+      s.objects.filter(
+        (o): o is ImageObject & { texSrc: string } => o.kind === "image" && !!o.texSrc,
+      ),
+    );
+    if (figures.length === 0) return;
+    const dir = dirOf(path);
+    let cancelled = false;
+    const id = setInterval(() => {
+      void (async () => {
+        for (const obj of figures) {
+          if (cancelled || texBusyIds.has(obj.id)) continue;
+          const texAbs = resolveRel(dir, obj.texSrc);
+          const pdfAbs = texAbs.replace(/\.tex$/i, ".pdf");
+          let mt: number;
+          try {
+            mt = await fileMtime(pdfAbs, scope);
+          } catch {
+            continue; // Not compiled yet, or the PDF moved — nothing to raster.
+          }
+          if (cancelled) return;
+          const known = mtimesRef.current.get(pdfAbs);
+          if (known === mt) continue;
+          if (known == null) {
+            // First observation of this PDF this session — its PNG is presumed
+            // already in sync (either this view just wrote it, or it was saved
+            // that way in an earlier session), so this establishes the baseline
+            // rather than re-rastering something that has not actually changed.
+            mtimesRef.current.set(pdfAbs, mt);
+            continue;
+          }
+          const pngAbs = resolveRel(dir, obj.src);
+          markTexBusy(obj.id, true);
+          try {
+            const rendered = await rasterizeInto(pdfAbs, pngAbs);
+            if (rendered && !cancelled) refreshImage(obj.src);
+          } catch {
+            // A transient read failure (mid-write) — the next tick retries.
+          } finally {
+            if (!cancelled) markTexBusy(obj.id, false);
+          }
+        }
+      })();
+    }, TEX_FIGURE_POLL_MS);
+    return () => {
+      cancelled = true;
+      clearInterval(id);
+    };
+  }, [deck, path, scope, texBusyIds, rasterizeInto, refreshImage, markTexBusy]);
+
+  // --- keyboard ----------------------------------------------------------
+  const onKeyDown = useCallback(
+    (e: React.KeyboardEvent) => {
+      // A keystroke aimed at a form control (the inspector's text/number fields)
+      // is that control's — never a canvas shortcut. Without this, typing a space
+      // or hitting Backspace while editing text would nudge or delete the object.
+      const t = e.target as HTMLElement | null;
+      if (
+        t &&
+        (t.isContentEditable ||
+          t.tagName === "INPUT" ||
+          t.tagName === "TEXTAREA" ||
+          t.tagName === "SELECT")
+      ) {
+        return;
+      }
+      const mod = e.ctrlKey || e.metaKey;
+      if (mod && e.key.toLowerCase() === "z" && !e.shiftKey) {
+        e.preventDefault();
+        undo();
+        return;
+      }
+      if (mod && (e.key.toLowerCase() === "y" || (e.key.toLowerCase() === "z" && e.shiftKey))) {
+        e.preventDefault();
+        redo();
+        return;
+      }
+      if (mod && e.key.toLowerCase() === "a") {
+        e.preventDefault();
+        setSelection(new Set((deck?.slides[slideIndex]?.objects ?? []).map((o) => o.id)));
+        return;
+      }
+      if (mod && e.key.toLowerCase() === "c") {
+        copySelection();
+        return;
+      }
+      if (mod && e.key.toLowerCase() === "x") {
+        if (selection.size === 0) return;
+        e.preventDefault();
+        copySelection();
+        withObjects((list, ids) => removeObjects(list, ids));
+        setSelection(new Set());
+        return;
+      }
+      if (mod && e.key.toLowerCase() === "v") {
+        e.preventDefault();
+        pasteClipboard();
+        return;
+      }
+      if (mod && e.key.toLowerCase() === "d") {
+        e.preventDefault();
+        duplicateSelection();
+        return;
+      }
+      if (e.key === "Delete" || e.key === "Backspace") {
+        if (selection.size === 0) return;
+        e.preventDefault();
+        withObjects((list, ids) => removeObjects(list, ids));
+        setSelection(new Set());
+        return;
+      }
+      if (e.key === "Escape") {
+        setSelection(new Set());
+        return;
+      }
+      const step = e.shiftKey ? NUDGE * 10 : NUDGE;
+      const nudge: Record<string, [number, number]> = {
+        ArrowLeft: [-step, 0],
+        ArrowRight: [step, 0],
+        ArrowUp: [0, -step],
+        ArrowDown: [0, step],
+      };
+      const d = nudge[e.key];
+      if (d && selection.size > 0) {
+        e.preventDefault();
+        withObjects((list, ids) => moveObjects(list, ids, d[0], d[1]));
+      }
+    },
+    [
+      deck,
+      slideIndex,
+      selection,
+      withObjects,
+      undo,
+      redo,
+      copySelection,
+      pasteClipboard,
+      duplicateSelection,
+    ],
+  );
+
+  // --- rail resize ---------------------------------------------------------
+  // Pointer-based, live-local during the drag, committed (and persisted) once
+  // on release — the same shape `SubwindowFilesSidebar`'s resize handle uses,
+  // for the same reason: a store write per pointermove is the easiest way to
+  // make a resize feel broken.
+  const startRailResize = useCallback(
+    (e: React.PointerEvent) => {
+      e.preventDefault();
+      (e.target as HTMLElement).setPointerCapture?.(e.pointerId);
+      const startX = e.clientX;
+      const startW = railWidth;
+      let last = startW;
+      const onMove = (ev: PointerEvent) => {
+        last = clampRailWidth(startW + (ev.clientX - startX));
+        setLiveRailWidth(last);
+      };
+      const onUp = () => {
+        window.removeEventListener("pointermove", onMove);
+        window.removeEventListener("pointerup", onUp);
+        setLiveRailWidth(null);
+        if (last !== startW) {
+          setRailWidth(last);
+          railState.persist({ deckRailWidth: last });
+        }
+      };
+      window.addEventListener("pointermove", onMove);
+      window.addEventListener("pointerup", onUp);
+    },
+    [railWidth, railState],
+  );
+
+  // --- render ------------------------------------------------------------
+
+  const slide = deck?.slides[slideIndex];
+  const hasSel = selection.size > 0;
+
+  if (error) {
+    return (
+      <div className="file-viewer">
+        <div className="file-viewer-error">{error}</div>
+      </div>
+    );
+  }
+  if (!deck) {
+    return (
+      <div className="file-viewer">
+        <div className="file-viewer-loading">Opening presentation…</div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="file-viewer deck-view" tabIndex={0} onKeyDown={onKeyDown}>
+      <div className="file-viewer-pdf-toolbar" role="group" aria-label="Presentation tools">
+        <span className="deck-toolbar-title">
+          Presentation <UntestedTag />
+        </span>
+        <span className="file-viewer-pdf-toolbar-sep" />
+        <button className="file-viewer-zoom-btn" onClick={addText} title="Add a text box">
+          T
+        </button>
+        <button className="file-viewer-zoom-btn" onClick={addRect} title="Add a rectangle">
+          ▭
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={() => setPicking("new")}
+          title="Add an icon"
+        >
+          ☆
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={() => void addImage()}
+          title="Add an image (PNG or JPEG)"
+        >
+          ▣
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={() => void addTexFigure()}
+          disabled={!texAvailable || texBusyIds.size > 0}
+          title="Add a TeX figure: opens a blank, ready-to-compile .tex and places its compiled PDF as an image"
+        >
+          𝒯+
+        </button>
+        <span className="file-viewer-pdf-toolbar-sep" />
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={duplicateSelection}
+          title="Duplicate selection (Ctrl+D)"
+        >
+          ⧉
+        </button>
+        <span className="file-viewer-pdf-toolbar-sep" />
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => alignObjects(l, ids, "left"))}
+          title="Align left"
+        >
+          ⇤
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => alignObjects(l, ids, "hcenter"))}
+          title="Centre horizontally"
+        >
+          ⇔
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => alignObjects(l, ids, "right"))}
+          title="Align right"
+        >
+          ⇥
+        </button>
+        <span className="file-viewer-pdf-toolbar-sep" />
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => toFront(l, ids))}
+          title="Bring to front"
+        >
+          ⤒
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => raiseObjects(l, ids))}
+          title="Raise"
+        >
+          ↑
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => lowerObjects(l, ids))}
+          title="Lower"
+        >
+          ↓
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          disabled={!hasSel}
+          onClick={() => withObjects((l, ids) => toBack(l, ids))}
+          title="Send to back"
+        >
+          ⤓
+        </button>
+        <span className="file-viewer-pdf-toolbar-sep" />
+        <button
+          className={`file-viewer-zoom-text${mode === "design" ? " active" : ""}`}
+          onClick={() => setMode("design")}
+          title="Arrange objects on the slide"
+        >
+          Design
+        </button>
+        <button
+          className={`file-viewer-zoom-text${mode === "animate" ? " active" : ""}`}
+          onClick={() => setMode("animate")}
+          title="Build steps, transitions, and GIF animations between slides"
+        >
+          Animate
+        </button>
+        <button
+          className={`file-viewer-zoom-text${mode === "notes" ? " active" : ""}`}
+          onClick={() => setMode("notes")}
+          title="Speaker notes for the current slide (shown only in the presenter view)"
+        >
+          Notes
+        </button>
+        <button
+          className={`file-viewer-zoom-text${mode === "tex" ? " active" : ""}`}
+          onClick={() => setMode("tex")}
+          title="Every TeX figure in this deck, across all slides"
+        >
+          TeX
+        </button>
+        <span className="file-viewer-pdf-toolbar-sep" />
+        <button
+          className="file-viewer-zoom-text"
+          onClick={() => setPresenting(true)}
+          disabled={deck.slides.length === 0}
+          title="Present fullscreen (Esc to exit)"
+        >
+          ▶ Present
+        </button>
+        <button
+          className="file-viewer-zoom-text"
+          onClick={() => void doExport()}
+          disabled={exporting || !metrics}
+          title="Flatten the layers into a PDF beside this deck"
+        >
+          {exporting ? "Exporting…" : "Export PDF"}
+        </button>
+        <span className="file-viewer-header-spacer" />
+        <span className="deck-save-state" aria-live="polite">
+          {saving ? "Saving…" : "Saved"}
+        </span>
+        <button className="file-viewer-zoom-btn" onClick={onOpenExternally} title="Open externally">
+          ↗
+        </button>
+      </div>
+
+      {notice && <div className="file-viewer-banner">{notice}</div>}
+
+      <div className="deck-body">
+        <div
+          className="deck-rail"
+          role="listbox"
+          aria-label="Slides"
+          style={{ width: liveRailWidth ?? railWidth }}
+        >
+          <div className="deck-rail-head">Slides</div>
+          {deck.slides.map((s, i) => (
+            <div
+              key={s.id}
+              className={`deck-rail-item${i === slideIndex ? " active" : ""}`}
+              role="option"
+              aria-selected={i === slideIndex}
+              tabIndex={0}
+              style={{ aspectRatio: `${deck.pageWidth} / ${deck.pageHeight}` }}
+              onClick={() => {
+                setSlideIndex(i);
+                setSelection(new Set());
+              }}
+              onKeyDown={(e) => {
+                if (e.key === "Enter" || e.key === " ") {
+                  setSlideIndex(i);
+                  setSelection(new Set());
+                }
+              }}
+            >
+              <DeckRailThumb
+                doc={doc}
+                page={s.anchor.page}
+                width={Math.max(1, (liveRailWidth ?? railWidth) - 12)}
+                height={Math.max(1, ((liveRailWidth ?? railWidth) - 12) * (deck.pageHeight / deck.pageWidth))}
+              />
+              <span className="deck-rail-num">{i + 1}</span>
+              {s.objects.length > 0 && (
+                <span className="deck-rail-badge" title={`${s.objects.length} layer objects`}>
+                  {s.objects.length}
+                </span>
+              )}
+              {s.after && (
+                <span className="deck-rail-gif" title="A GIF plays after this slide">
+                  ▶
+                </span>
+              )}
+              {/* Reorder and copy are both durable — reorder moves this slide in the
+                  presentation sequence, copy adds a clone that backs the same base
+                  page; neither changes the base PDF. */}
+              <span className="deck-rail-actions">
+                <button
+                  className="deck-rail-act-btn"
+                  disabled={i === 0}
+                  title="Move slide earlier"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    moveSlide(i, -1);
+                  }}
+                >
+                  ▲
+                </button>
+                <button
+                  className="deck-rail-act-btn"
+                  disabled={i === deck.slides.length - 1}
+                  title="Move slide later"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    moveSlide(i, 1);
+                  }}
+                >
+                  ▼
+                </button>
+                <button
+                  className="deck-rail-act-btn"
+                  title="Duplicate slide"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    duplicateSlide(i);
+                  }}
+                >
+                  ⧉
+                </button>
+              </span>
+            </div>
+          ))}
+        </div>
+
+        <div
+          className="deck-rail-resize"
+          title="Drag to resize the slide overview"
+          onPointerDown={startRailResize}
+        />
+
+        {slide ? (
+          <DeckStage
+            slide={slide}
+            doc={doc}
+            pageWidth={deck.pageWidth}
+            pageHeight={deck.pageHeight}
+            margin={deck.theme.margin}
+            selection={selection}
+            onSelectionChange={setSelection}
+            onObjectsChange={setObjects}
+            assets={assets}
+            metrics={metrics}
+            previewStep={mode === "animate" ? previewStep : undefined}
+            showBuildBadges={mode === "animate"}
+            onEditObject={(obj) => {
+              if (obj.kind === "image" && obj.texSrc) editTexObject(obj);
+            }}
+          />
+        ) : (
+          <div className="deck-stage deck-stage-empty">
+            <p>This presentation has no base PDF yet.</p>
+            {texAvailable ? (
+              <>
+                <p>
+                  Eldrun can write a starter LaTeX file beside it and compile it. The
+                  file is yours afterwards — recompiling keeps whatever layers you add,
+                  which re-anchor to the slides they were placed on.
+                </p>
+                <button
+                  className="deck-inspector-btn"
+                  onClick={() => void generateBase()}
+                  disabled={generating}
+                >
+                  {generating ? "Compiling…" : "Create a starter presentation"}
+                </button>
+              </>
+            ) : (
+              <p>
+                No LaTeX engine was found on PATH, so a base PDF cannot be generated
+                here. Point this deck at an existing PDF instead, or install a TeX
+                distribution.
+              </p>
+            )}
+          </div>
+        )}
+
+        {mode === "tex" ? (
+          <DeckTexPanel
+            deck={deck}
+            onJump={jumpToTexFigure}
+            onEditTex={editTexObject}
+            onRecompileTex={(obj) => void recompileTexObject(obj)}
+            texBusyIds={texBusyIds}
+          />
+        ) : mode === "notes" && slide ? (
+          <DeckNotes slide={slide} onSlideChange={patchSlide} />
+        ) : mode === "animate" && slide ? (
+          <DeckAnimate
+            slide={slide}
+            selection={selection}
+            onObjectsChange={setObjects}
+            onSlideChange={patchSlide}
+            previewStep={previewStep}
+            onPreviewStep={setPreviewStep}
+            toDeckRelative={toDeckRelative}
+          />
+        ) : (
+          <DeckInspector
+            objects={slide?.objects ?? []}
+            selection={selection}
+            onChange={setObjects}
+            onPickIcon={() => setPicking("replace")}
+            onEditTex={editTexObject}
+            onRecompileTex={(obj) => void recompileTexObject(obj)}
+            texBusyIds={texBusyIds}
+          />
+        )}
+      </div>
+
+      {picking && <IconPicker onPick={addIcon} onClose={() => setPicking(null)} />}
+
+      {presenting && (
+        <DeckPresenter
+          deck={deck}
+          doc={doc}
+          metrics={metrics}
+          assets={assets}
+          gifs={gifs}
+          path={path}
+          scope={scope}
+          startAt={0}
+          onClose={() => setPresenting(false)}
+        />
+      )}
+
+      {deck.detached.length > 0 && (
+        <div className="file-viewer-banner deck-detached-banner">
+          <span>
+            {deck.detached.length} layer{deck.detached.length === 1 ? "" : "s"} lost
+            {deck.detached.length === 1 ? " its" : " their"} slide when the base PDF
+            changed. Nothing was deleted — pick one to put back on the slide you are
+            viewing.
+          </span>
+          {deck.detached.map((d, i) => (
+            <button
+              key={i}
+              className="deck-inspector-btn"
+              title={`${d.objects.length} object(s), last seen on page ${d.from.page}`}
+              onClick={() => commit((cur) => reattach(cur, i, slideIndex))}
+            >
+              Page {d.from.page} ({d.objects.length}) → slide {slideIndex + 1}
+            </button>
+          ))}
+        </div>
+      )}
+      {/* `tabKey`/`groupId` are threaded for the presenter and per-tab state that
+          Phases 6–7 add; referenced here so the props are not silently dropped. */}
+      <span hidden data-tab-key={tabKey ?? ""} data-group-id={groupId ?? ""} />
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/IconPicker.tsx b/src/components/embed/deck/IconPicker.tsx
new file mode 100644
index 0000000..12135d7
--- /dev/null
+++ b/src/components/embed/deck/IconPicker.tsx
@@ -0,0 +1,113 @@
+/**
+ * The icon picker: a searchable grid over the bundled library
+ * (`lib/viewers/deck/icons.ts`).
+ *
+ * Renders each icon from the same path data the stage and the PDF exporter use,
+ * so what you pick is exactly what lands on the slide and exactly what exports —
+ * there is no separate preview asset that could drift.
+ */
+
+import { useMemo, useState } from "react";
+import {
+  type IconCategory,
+  type IconDef,
+  ICON_CATEGORIES,
+  ICON_VIEWBOX,
+  searchIcons,
+} from "../../../lib/viewers/deck/icons";
+
+export interface IconPickerProps {
+  onPick: (icon: IconDef) => void;
+  onClose: () => void;
+}
+
+export function IconPicker({ onPick, onClose }: IconPickerProps) {
+  const [query, setQuery] = useState("");
+  const [category, setCategory] = useState<IconCategory | null>(null);
+
+  // A query searches the WHOLE library: filtering by a category you happen to
+  // have open, while typing a name, reads as "the icon isn't there".
+  const results = useMemo(
+    () => searchIcons(query, query.trim() ? undefined : (category ?? undefined)),
+    [query, category],
+  );
+
+  return (
+    <div className="modal-backdrop" onClick={onClose}>
+      <div
+        className="project-dialog deck-icon-picker"
+        onClick={(e) => e.stopPropagation()}
+        role="dialog"
+        aria-label="Choose an icon"
+      >
+        <div className="settings-title-row">
+          <h3>Icons</h3>
+          <button className="dialog-close-btn" onClick={onClose} aria-label="Close">
+            ×
+          </button>
+        </div>
+
+        <input
+          className="deck-icon-search"
+          autoFocus
+          placeholder="Search icons…"
+          value={query}
+          onChange={(e) => setQuery(e.target.value)}
+        />
+
+        <div className="deck-icon-cats">
+          <button
+            className={`deck-icon-cat${category === null ? " active" : ""}`}
+            onClick={() => setCategory(null)}
+          >
+            All
+          </button>
+          {ICON_CATEGORIES.map((c) => (
+            <button
+              key={c.id}
+              className={`deck-icon-cat${category === c.id ? " active" : ""}`}
+              onClick={() => setCategory(c.id)}
+            >
+              {c.label}
+            </button>
+          ))}
+        </div>
+
+        <div className="deck-icon-grid">
+          {results.map((def) => (
+            <button
+              key={def.key}
+              className="deck-icon-cell"
+              title={def.label}
+              onClick={() => onPick(def)}
+            >
+              <svg viewBox={`0 0 ${ICON_VIEWBOX} ${ICON_VIEWBOX}`} width={26} height={26}>
+                <g
+                  transform={
+                    def.rotate
+                      ? `rotate(${def.rotate} ${ICON_VIEWBOX / 2} ${ICON_VIEWBOX / 2})`
+                      : undefined
+                  }
+                >
+                  {def.paths.map((d, i) => (
+                    <path
+                      key={i}
+                      d={d}
+                      fill={def.filled ? "currentColor" : "none"}
+                      stroke={def.filled ? "none" : "currentColor"}
+                      strokeWidth={def.filled ? undefined : 1.7}
+                      strokeLinecap="round"
+                      strokeLinejoin="round"
+                    />
+                  ))}
+                </g>
+              </svg>
+              <span className="deck-icon-label">{def.label}</span>
+            </button>
+          ))}
+          {results.length === 0 && <div className="deck-icon-empty">No icon matches that.</div>}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/deck/deckAssets.ts b/src/components/embed/deck/deckAssets.ts
new file mode 100644
index 0000000..f0527ac
--- /dev/null
+++ b/src/components/embed/deck/deckAssets.ts
@@ -0,0 +1,178 @@
+/**
+ * Loading a deck's *heavy* parts — placed images and interstitial GIFs.
+ *
+ * Extracted from `DeckView` when the dual-window presenter landed: the audience
+ * window is a separate webview with its own heap, so it cannot be handed the
+ * editor's blob URLs or decoded frames — it must load them itself. Two copies of
+ * this would be two chances to leak, since both halves own resources the GC
+ * cannot reclaim (an object URL and an `ImageBitmap`), so there is one.
+ *
+ * Both hooks own their resources for the lifetime of the mount and release what
+ * leaves the deck as it leaves, plus everything at unmount.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { readFileBytes } from "../fileAccess";
+import type { Deck, Interstitial } from "../../../lib/viewers/deck/model";
+import { type DecodedGif, decodeInterstitial, disposeGif } from "./gifPlayback";
+
+/** The directory part of a path, `""` for a bare filename. */
+export function dirOf(p: string): string {
+  const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+  return i >= 0 ? p.slice(0, i) : "";
+}
+
+/** Resolve a deck-relative asset path against the sidecar's own directory. */
+export function resolveRel(dir: string, rel: string): string {
+  if (/^([a-zA-Z]:[\\/]|\/)/.test(rel)) return rel;
+  return dir ? `${dir}/${rel}` : rel;
+}
+
+/** Every interstitial in the deck, in slide order. */
+export function interstitialsOf(deck: Deck | null): Interstitial[] {
+  return (deck?.slides ?? [])
+    .map((s) => s.after)
+    .filter((a): a is Interstitial => a != null);
+}
+
+/**
+ * Blob URLs for every image object's bytes, keyed by the deck-relative `src`.
+ *
+ * A missing image resolves to no entry — `DeckObjectView` draws its own
+ * placeholder, which is more useful mid-talk than an error banner over an
+ * otherwise fine slide.
+ *
+ * Returns a `refresh(src)` alongside the map: a TeX-figure object's PNG is
+ * overwritten **at the same path** every time its source recompiles, so the
+ * ordinary "fetch only what's missing" effect below would never notice the new
+ * bytes. The editor calls `refresh` right after it rewrites such a file to evict
+ * the stale blob URL and force a re-fetch.
+ */
+export function useDeckImages(deck: Deck | null, path: string, scope: string | null) {
+  const [assets, setAssets] = useState<Map<string, string>>(new Map());
+
+  const refresh = useCallback((src: string) => {
+    setAssets((cur) => {
+      const url = cur.get(src);
+      if (!url) return cur;
+      URL.revokeObjectURL(url);
+      const next = new Map(cur);
+      next.delete(src);
+      return next;
+    });
+  }, []);
+
+  const wantedSrcs = useMemo(() => {
+    const out = new Set<string>();
+    for (const s of deck?.slides ?? []) {
+      for (const o of s.objects) if (o.kind === "image") out.add(o.src);
+    }
+    return out;
+  }, [deck]);
+
+  useEffect(() => {
+    let live = true;
+    const dir = dirOf(path);
+    const missing = [...wantedSrcs].filter((s) => !assets.has(s));
+    if (missing.length === 0) return;
+    void (async () => {
+      const added = new Map<string, string>();
+      for (const rel of missing) {
+        try {
+          const bytes = await readFileBytes(resolveRel(dir, rel), scope);
+          added.set(rel, URL.createObjectURL(new Blob([new Uint8Array(bytes)])));
+        } catch {
+          /* placeholder, see above */
+        }
+      }
+      if (!live) {
+        added.forEach((url) => URL.revokeObjectURL(url));
+        return;
+      }
+      if (added.size) setAssets((cur) => new Map([...cur, ...added]));
+    })();
+    return () => {
+      live = false;
+    };
+  }, [wantedSrcs, assets, path, scope]);
+
+  useEffect(() => {
+    // Drop URLs for images no longer anywhere in the deck.
+    const stale = [...assets.keys()].filter((k) => !wantedSrcs.has(k));
+    if (stale.length === 0) return;
+    setAssets((cur) => {
+      const next = new Map(cur);
+      for (const k of stale) {
+        URL.revokeObjectURL(next.get(k)!);
+        next.delete(k);
+      }
+      return next;
+    });
+  }, [wantedSrcs, assets]);
+
+  // Unmount: revoke whatever is left. Its own effect with an empty dep list so it
+  // fires once, at teardown, rather than on every asset change.
+  const assetsRef = useRef(assets);
+  assetsRef.current = assets;
+  useEffect(
+    () => () => {
+      assetsRef.current.forEach((url) => URL.revokeObjectURL(url));
+    },
+    [],
+  );
+
+  return { assets, refresh };
+}
+
+/**
+ * Decoded interstitial clips, keyed by interstitial id.
+ *
+ * Decoded lazily and kept for the session: a clip costs real memory (every GIF
+ * frame is a full-canvas RGBA copy), so `gifPlayback` caps each one, and the
+ * bitmaps are explicitly closed when they leave the deck.
+ */
+export function useDeckGifs(
+  interstitials: readonly Interstitial[],
+  path: string,
+  scope: string | null,
+) {
+  const [gifs, setGifs] = useState<Map<string, DecodedGif>>(new Map());
+
+  useEffect(() => {
+    let live = true;
+    const dir = dirOf(path);
+    const missing = interstitials.filter((a) => !gifs.has(a.id));
+    if (missing.length === 0) return;
+    void (async () => {
+      const added = new Map<string, DecodedGif>();
+      for (const a of missing) {
+        try {
+          const bytes = await readFileBytes(resolveRel(dir, a.src), scope);
+          added.set(a.id, await decodeInterstitial(new Uint8Array(bytes)));
+        } catch {
+          // A clip that will not decode shows as "Loading animation…" in the
+          // presenter rather than taking the talk down.
+        }
+      }
+      if (!live) {
+        added.forEach((g) => disposeGif(g));
+        return;
+      }
+      if (added.size) setGifs((cur) => new Map([...cur, ...added]));
+    })();
+    return () => {
+      live = false;
+    };
+  }, [interstitials, gifs, path, scope]);
+
+  const gifsRef = useRef(gifs);
+  gifsRef.current = gifs;
+  useEffect(
+    () => () => {
+      gifsRef.current.forEach((g) => disposeGif(g));
+    },
+    [],
+  );
+
+  return gifs;
+}
diff --git a/src/components/embed/deck/deckBase.ts b/src/components/embed/deck/deckBase.ts
new file mode 100644
index 0000000..914cfee
--- /dev/null
+++ b/src/components/embed/deck/deckBase.ts
@@ -0,0 +1,159 @@
+/**
+ * Loading a deck's **base plate** — the PDF the layers sit on.
+ *
+ * Kept apart from `DeckView` because it is the one piece with an awkward
+ * lifetime: a `PDFDocumentProxy` owns a worker and must be destroyed, and pdf.js
+ * *detaches* the ArrayBuffer it is handed, so the bytes cannot be reused
+ * afterwards (the same trap `pdf/pdfDoc.ts` documents). Both facts are easy to
+ * get wrong in a component body and invisible when you do — the symptom is a
+ * leaked worker per reload, which only shows up after an hour of editing.
+ */
+
+import * as pdfjs from "pdfjs-dist";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import pdfWorkerUrl from "pdfjs-dist/build/pdf.worker.min.mjs?url";
+import { readFileBytes } from "../fileAccess";
+import type { BasePage } from "../../../lib/viewers/deck/sidecar";
+
+// Idempotent: the PDF viewer sets the same value, and a deck can be opened
+// without that module ever having loaded.
+pdfjs.GlobalWorkerOptions.workerSrc = pdfWorkerUrl;
+
+/** How much page text the fingerprint needs. Reading more costs time per page
+ *  for nothing — see `sidecar.FINGERPRINT_CHARS`. */
+const TEXT_BUDGET = 400;
+
+export interface LoadedBase {
+  doc: PDFDocumentProxy;
+  pages: BasePage[];
+}
+
+/**
+ * Open `path` and describe every page: its box in points, and enough text to
+ * fingerprint it.
+ *
+ * The caller owns the returned `doc` and **must** `destroy()` it.
+ */
+export async function loadBase(path: string, scope: string | null): Promise<LoadedBase> {
+  const bytes = await readFileBytes(path, scope);
+  const doc = await pdfjs.getDocument({ data: new Uint8Array(bytes) }).promise;
+
+  const pages: BasePage[] = [];
+  for (let n = 1; n <= doc.numPages; n += 1) {
+    const page = await doc.getPage(n);
+    const vp = page.getViewport({ scale: 1 });
+    let text = "";
+    try {
+      const content = await page.getTextContent();
+      for (const item of content.items) {
+        const s = (item as { str?: string }).str;
+        if (!s) continue;
+        text += `${s} `;
+        if (text.length >= TEXT_BUDGET) break;
+      }
+    } catch {
+      // A page whose text layer will not extract still has a valid box, and a
+      // fingerprint over an empty string is stable. Anchoring falls back to
+      // SyncTeX or to order, which is exactly what it is there for.
+    }
+    pages.push({ page: n, width: vp.width, height: vp.height, text: text.trim() });
+  }
+  return { doc, pages };
+}
+
+/**
+ * Render 1-based `pageNumber` into `canvas` at `cssW × cssH`.
+ *
+ * The canvas contract is the PDF viewer's, deliberately: backing store in
+ * **device** pixels (`css × dpr`), CSS size in **CSS** pixels. Getting this wrong
+ * is what makes a slide look soft on a HiDPI screen and, worse, look fine on the
+ * laptop and soft on the projector.
+ *
+ * Returns a cancel function; pdf.js render tasks must be cancelled when the
+ * component re-renders under them, or two tasks race for one canvas.
+ */
+export function renderPage(
+  doc: PDFDocumentProxy,
+  pageNumber: number,
+  canvas: HTMLCanvasElement,
+  cssW: number,
+  cssH: number,
+): () => void {
+  let cancelled = false;
+  let task: { cancel: () => void } | null = null;
+
+  void (async () => {
+    try {
+      const page = await doc.getPage(pageNumber);
+      if (cancelled) return;
+      const dpr = window.devicePixelRatio || 1;
+      const base = page.getViewport({ scale: 1 });
+      // Fit the page box to the requested CSS size. They agree in aspect for a
+      // normal deck, but a mixed-size PDF must not stretch.
+      const scale = Math.min(cssW / base.width, cssH / base.height);
+      const viewport = page.getViewport({ scale: scale * dpr });
+      canvas.width = Math.max(1, Math.floor(viewport.width));
+      canvas.height = Math.max(1, Math.floor(viewport.height));
+      canvas.style.width = `${viewport.width / dpr}px`;
+      canvas.style.height = `${viewport.height / dpr}px`;
+      const ctx = canvas.getContext("2d");
+      if (!ctx || cancelled) return;
+      task = page.render({ canvasContext: ctx, viewport });
+      await (task as unknown as { promise: Promise<void> }).promise;
+    } catch {
+      // A cancelled render rejects; so does a page that disappeared under a
+      // reload. Neither is worth surfacing — the next render replaces it.
+    }
+  })();
+
+  return () => {
+    cancelled = true;
+    try {
+      task?.cancel();
+    } catch {
+      /* already finished */
+    }
+  };
+}
+
+/** Raster resolution for a TeX figure, as a multiple of the PDF's own point
+ *  size. Higher than the base plate's on-screen render because a figure is
+ *  often placed small and then enlarged — a blurry formula is worse than a
+ *  slightly larger PNG. */
+const TEX_FIGURE_SCALE = 3;
+
+export interface RasterizedFigure {
+  png: Uint8Array;
+  /** Pixel size of the PNG — callers use the ratio to size the deck object so a
+   *  wide formula doesn't get squashed into a square placeholder box. */
+  width: number;
+  height: number;
+}
+
+/**
+ * Compile a standalone TeX figure's PDF into a PNG of its (cropped) first page.
+ *
+ * Used for the deck's TeX-figure objects: `standalone` crops the PDF to its
+ * content, so page 1 at a fixed scale is the whole figure with no page
+ * furniture to trim. Opens its own throwaway `PDFDocumentProxy` — this PDF is
+ * never the base plate, so it has none of `loadBase`'s multi-page/lifetime
+ * concerns — and destroys it before returning.
+ */
+export async function renderPdfPageToPng(bytes: Uint8Array): Promise<RasterizedFigure | null> {
+  const doc = await pdfjs.getDocument({ data: bytes }).promise;
+  try {
+    const page = await doc.getPage(1);
+    const viewport = page.getViewport({ scale: TEX_FIGURE_SCALE });
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.max(1, Math.ceil(viewport.width));
+    canvas.height = Math.max(1, Math.ceil(viewport.height));
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    await page.render({ canvasContext: ctx, viewport }).promise;
+    const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, "image/png"));
+    if (!blob) return null;
+    return { png: new Uint8Array(await blob.arrayBuffer()), width: canvas.width, height: canvas.height };
+  } finally {
+    await doc.destroy();
+  }
+}
diff --git a/src/components/embed/deck/gifPlayback.ts b/src/components/embed/deck/gifPlayback.ts
new file mode 100644
index 0000000..bacd111
--- /dev/null
+++ b/src/components/embed/deck/gifPlayback.ts
@@ -0,0 +1,176 @@
+/**
+ * Playing a GIF interstitial — the clip that runs *between* two slides, which is
+ * the only way a TeX-generated PDF can carry animation at all.
+ *
+ * It reuses the repo's existing pure decoder (`lib/viewers/gif.ts`), so it adds
+ * no dependency and inherits that module's delay conventions. Two facts from the
+ * decoder shape everything here:
+ *
+ * **Every frame is a full-canvas RGBA copy.** A 1920×1080 GIF costs ~8.3 MB *per
+ * frame*, so a 30-frame clip reaches the decoder's 256 MB default cap. A slide
+ * deck can hold several interstitials, so this module passes a much smaller
+ * explicit budget and pre-bakes frames to `ImageBitmap` — `putImageData` ignores
+ * transforms and so cannot scale, whereas `drawImage` of a bitmap can.
+ *
+ * **Delays are authored, played by convention.** `effectiveDelayMs` maps the
+ * sub-20 ms delays real files contain onto the 100 ms browsers actually use.
+ *
+ * The playback clock is `GifView`'s accumulator, lifted deliberately rather than
+ * rewritten: it banks elapsed wall-clock, may advance several frames in one tick,
+ * never drifts, and clamps the backlog so a presenter window that was occluded
+ * does not spin through a thousand frames when it comes back.
+ */
+
+import { effectiveDelayMs, openGif } from "../../../lib/viewers/gif";
+
+/** Per-interstitial decode budget. Well under the decoder's default: a deck may
+ *  hold several clips, and a presenter that OOMs mid-talk is unforgivable. */
+export const INTERSTITIAL_PIXEL_BUDGET = 48 * 1024 * 1024;
+
+/** The most elapsed time one tick may bank, so an occluded window catches up
+ *  rather than replaying minutes of animation. */
+const MAX_CARRY_MS = 2000;
+
+export interface DecodedGif {
+  width: number;
+  height: number;
+  frames: Array<{ bitmap: ImageBitmap; delayMs: number }>;
+  loopCount: number;
+  truncated: boolean;
+}
+
+/** Decode `bytes` and pre-bake every frame to an `ImageBitmap`. */
+export async function decodeInterstitial(bytes: Uint8Array): Promise<DecodedGif> {
+  const stream = openGif(bytes, { maxPixelBytes: INTERSTITIAL_PIXEL_BUDGET });
+  const frames: DecodedGif["frames"] = [];
+  for (let f = stream.nextFrame(); f; f = stream.nextFrame()) {
+    const image = new ImageData(f.pixels, stream.width, stream.height);
+    frames.push({
+      bitmap: await createImageBitmap(image),
+      delayMs: effectiveDelayMs(f.delayMs),
+    });
+  }
+  return {
+    width: stream.width,
+    height: stream.height,
+    frames,
+    loopCount: stream.loopCount,
+    truncated: stream.truncated,
+  };
+}
+
+/** Release the bitmaps. They are GPU-side; letting them fall out of scope is not
+ *  enough on a long-lived presenter. */
+export function disposeGif(gif: DecodedGif | null): void {
+  gif?.frames.forEach((f) => f.bitmap.close());
+}
+
+export interface PlayOptions {
+  /** Letterbox (`contain`) or fill and crop (`cover`). */
+  fit: "contain" | "cover";
+  /** Colour behind a letterboxed clip. */
+  background: string;
+  /** Loop forever, or stop on the last frame. */
+  loop: boolean;
+  /** Called after the clip's final pass — drives auto-advance. */
+  onEnded?: () => void;
+}
+
+/**
+ * Drive `gif` onto `canvas` until the returned function is called.
+ *
+ * Returns a stop function; it is safe to call more than once.
+ */
+export function playGif(
+  canvas: HTMLCanvasElement,
+  gif: DecodedGif,
+  opts: PlayOptions,
+): () => void {
+  const ctx = canvas.getContext("2d");
+  if (!ctx || gif.frames.length === 0) return () => {};
+
+  let raf = 0;
+  let stopped = false;
+  let index = 0;
+  let carry = 0;
+  let last = 0;
+  let ended = false;
+
+  const paint = () => {
+    const dpr = window.devicePixelRatio || 1;
+    const cssW = canvas.clientWidth;
+    const cssH = canvas.clientHeight;
+    if (cssW <= 0 || cssH <= 0) return;
+    const bw = Math.floor(cssW * dpr);
+    const bh = Math.floor(cssH * dpr);
+    if (canvas.width !== bw || canvas.height !== bh) {
+      canvas.width = bw;
+      canvas.height = bh;
+    }
+    ctx.fillStyle = opts.background;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+    const scale =
+      opts.fit === "cover"
+        ? Math.max(canvas.width / gif.width, canvas.height / gif.height)
+        : Math.min(canvas.width / gif.width, canvas.height / gif.height);
+    const w = gif.width * scale;
+    const h = gif.height * scale;
+    ctx.drawImage(gif.frames[index].bitmap, (canvas.width - w) / 2, (canvas.height - h) / 2, w, h);
+  };
+
+  const tick = (ts: number) => {
+    if (stopped) return;
+    if (last === 0) last = ts;
+    if (!ended) {
+      carry = Math.min(carry + (ts - last), MAX_CARRY_MS);
+      let delay = gif.frames[index].delayMs;
+      while (carry >= delay) {
+        carry -= delay;
+        if (index === gif.frames.length - 1) {
+          if (!opts.loop) {
+            ended = true;
+            opts.onEnded?.();
+            break;
+          }
+          index = 0;
+        } else {
+          index += 1;
+        }
+        delay = gif.frames[index].delayMs;
+      }
+    }
+    last = ts;
+    paint();
+    raf = requestAnimationFrame(tick);
+  };
+
+  paint();
+  raf = requestAnimationFrame(tick);
+
+  return () => {
+    stopped = true;
+    cancelAnimationFrame(raf);
+  };
+}
+
+/**
+ * Encode one frame as PNG bytes — the poster the PDF export writes in place of
+ * the animation, since a GIF cannot be a PDF page.
+ *
+ * Lives here rather than in `deck/export.ts` because it needs a canvas, and
+ * keeping the exporter DOM-free is what makes it testable.
+ */
+export async function posterPng(gif: DecodedGif, frame: number): Promise<Uint8Array | null> {
+  const f = gif.frames[Math.min(Math.max(frame, 0), gif.frames.length - 1)];
+  if (!f) return null;
+  const canvas = document.createElement("canvas");
+  canvas.width = gif.width;
+  canvas.height = gif.height;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return null;
+  ctx.drawImage(f.bitmap, 0, 0);
+  const blob = await new Promise<Blob | null>((resolve) => canvas.toBlob(resolve, "image/png"));
+  if (!blob) return null;
+  return new Uint8Array(await blob.arrayBuffer());
+}
diff --git a/src/components/embed/fileAccess.ts b/src/components/embed/fileAccess.ts
new file mode 100644
index 0000000..1575bb1
--- /dev/null
+++ b/src/components/embed/fileAccess.ts
@@ -0,0 +1,117 @@
+import { createContext, useContext } from "react";
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * The project scope that absolute-path file commands are confined to.
+ *
+ * Backend confinement (`src-tauri/src/commands/fs.rs`, Security #1) isolates each
+ * project's filesystem from the others: a file read/write/poll is allowed only
+ * inside the *scope* project's tree (plus any box sibling's tree). The scope is
+ * the project that OWNS the calling viewer — NOT whichever project is globally
+ * "current" — so a viewer keeps working after you switch projects, are restored
+ * on relaunch, or live in a detached window, instead of failing with a spurious
+ * "path is not in the current project" error.
+ *
+ * `FileViewerPane` publishes its owning `projectId` here; every nested viewer and
+ * hook reads it via {@link useFileScope} and threads it into the wrappers below.
+ * `null` is the root scope (the backend then falls back to the current project).
+ */
+export const FileScopeContext = createContext<string | null>(null);
+
+/** The owning project id of the surrounding viewer (null in the root scope). */
+export function useFileScope(): string | null {
+  return useContext(FileScopeContext);
+}
+
+/**
+ * Where a viewer's bytes come from, for its remote/local source notice:
+ *  - `"remote"` — a remote (SSH) project file served straight from the host over
+ *                 SFTP (remote-native, no local copy).
+ *  - `"local"`  — a remote project file under the local mirror, read on the local
+ *                 fs (the paired working copy synced from the host).
+ *  - `"none"`   — a local project: no remote/local distinction, so no badge.
+ * Resolved by the `file_source` backend command, which mirrors the exact routing
+ * the read commands use so the badge can never disagree with the bytes shown.
+ */
+export type FileSource = "remote" | "local" | "none";
+
+/** The resolved source of the surrounding viewer's file (`"none"` = no badge). */
+export const FileSourceContext = createContext<FileSource>("none");
+
+/** The remote/local source classification published by the enclosing viewer. */
+export function useFileSource(): FileSource {
+  return useContext(FileSourceContext);
+}
+
+/** Classify a path's bytes as remote-native / local-mirror / not-applicable. */
+export function fileSource(path: string, projectId: string | null): Promise<FileSource> {
+  return invoke<FileSource>("file_source", { path, projectId });
+}
+
+// Thin wrappers over the confined file commands. They exist so the `project_id`
+// scope argument is attached uniformly and can't be forgotten at a call site.
+
+export function readFileText(path: string, projectId: string | null): Promise<string> {
+  return invoke<string>("read_file_text", { path, projectId });
+}
+
+export function readFileBytes(path: string, projectId: string | null): Promise<number[]> {
+  return invoke<number[]>("read_file_bytes", { path, projectId });
+}
+
+export function writeFileText(
+  path: string,
+  content: string,
+  projectId: string | null,
+): Promise<void> {
+  return invoke("write_file_text", { path, content, projectId });
+}
+
+export function writeFileBytes(
+  path: string,
+  content: number[] | Uint8Array,
+  projectId: string | null,
+): Promise<void> {
+  return invoke("write_file_bytes", { path, content: Array.from(content), projectId });
+}
+
+export function fileMtime(path: string, projectId: string | null): Promise<number> {
+  return invoke<number>("file_mtime", { path, projectId });
+}
+
+export function detectMime(path: string, projectId: string | null): Promise<string> {
+  return invoke<string>("detect_mime", { path, projectId });
+}
+
+/**
+ * Turn a raw file-read/stat failure into a sentence a user can act on.
+ *
+ * The backend surfaces low-level text — `sftp metadata failed: …`,
+ * `sftp read failed: …`, an OS `No such file or directory` — which means nothing
+ * to someone who just clicked a file. The single most common cause on a remote
+ * project is opening a file that only exists in the local mirror while the viewer
+ * is reading the host over SFTP (never synced): say that, and point at the fix.
+ * Falls back to a plain "couldn't open" rather than dumping the raw string.
+ */
+export function describeFileError(e: unknown): string {
+  const raw = String(e);
+  const remote = /sftp/i.test(raw);
+  if (/permission|denied|eacces/i.test(raw)) {
+    return "Permission denied — you don't have access to this file.";
+  }
+  // A remote stat/metadata failure means the host doesn't have this path — on a
+  // remote project that's overwhelmingly a local-only file (never synced), which
+  // is the actionable thing to say. An explicit "no such file" says the same.
+  if (
+    /no such file|not found|does not exist|enoent/i.test(raw) ||
+    (remote && /metadata|stat/i.test(raw))
+  ) {
+    return remote
+      ? "This file isn't on the remote host — it may be local-only (never synced). Switch the viewer to Local to open it."
+      : "This file no longer exists.";
+  }
+  if (remote) {
+    return "Couldn't read this file from the remote host. Check the connection and try again.";
+  }
+  return "Couldn't open this file.";
+}
diff --git a/src/components/embed/pdf/PdfViewer.tsx b/src/components/embed/pdf/PdfViewer.tsx
new file mode 100644
index 0000000..38afd25
--- /dev/null
+++ b/src/components/embed/pdf/PdfViewer.tsx
@@ -0,0 +1,2081 @@
+/**
+ * The in-app PDF viewer: a pdf.js canvas stack with a zoom/fit toolbar, Ctrl+F
+ * find (#71), print, and bidirectional SyncTeX (#66).
+ *
+ * Lifted verbatim out of `FileViewerPane` (which had grown past 6.6k lines) to give
+ * the page-arrangement work a home of its own. Behaviour is unchanged.
+ *
+ * Like the sibling viewers (`TableView`, `OdtView`, `NotebookView`), this imports
+ * shared viewer plumbing back from `FileViewerPane`; the resulting import cycle is
+ * the established pattern here and is safe because every use is at call time.
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import * as pdfjs from "pdfjs-dist";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import pdfWorkerUrl from "pdfjs-dist/build/pdf.worker.min.mjs?url";
+import { usePdfSyncStore } from "../../../stores/pdfSync";
+import { useScrollSync } from "../../../stores/scrollSync";
+import {
+  useFileScope,
+  readFileBytes,
+  readFileText,
+  writeFileBytes,
+  fileMtime,
+  describeFileError,
+} from "../fileAccess";
+import { useExperimental } from "../../../lib/experimental";
+import { emptyDeck } from "../../../lib/viewers/deck/model";
+import { deckPathForPdf, serializeDeck } from "../../../lib/viewers/deck/sidecar";
+import { jumpToSource, useViewerState } from "../FileViewerPane";
+import {
+  renderPdfPagesToImages,
+  printHtmlBody,
+  PDF_PRINT_CSS,
+} from "../../../lib/viewers/print";
+import {
+  SELF,
+  initialPages,
+  insertPages,
+  deletePages,
+  pagesOf,
+  isPristine,
+  type PageList,
+} from "../../../lib/viewers/pageModel";
+import { openSource, newSourceId, buildPdf, type PdfSources } from "./pdfDoc";
+import {
+  loadOutline,
+  detectHeadings,
+  flattenOutline,
+  type OutlineNode,
+  type HeadingRun,
+} from "./outline";
+import { PageStrip } from "../../common/PageStrip";
+import { UntestedTag } from "../../common/UntestedTag";
+import type { PageTransfer } from "../../../stores/pdfDrag";
+import { ContextFilePicker } from "../ContextFilePicker";
+import { useProjectsStore } from "../../../stores/projects";
+import { resolveProjectDirectory } from "../../../types";
+import { basename, dirname, isPathWithin } from "../../../lib/paths";
+import {
+  pdfPageMatches,
+  pdfPointToBigPoints,
+  bigPointsToCssRect,
+  synctexEdit,
+  refineToWord,
+  type SyncRect,
+  type TextItemBox,
+  type CaretPhrase,
+} from "../../../lib/viewers/tex";
+
+// pdf.js renders pages on a worker; point it at the bundled worker asset. Vite
+// emits a hashed URL that resolves in both dev and the packaged Tauri build.
+pdfjs.GlobalWorkerOptions.workerSrc = pdfWorkerUrl;
+
+/** How often the open PDF re-checks its file's mtime for an on-disk change (a
+ *  LaTeX recompile rewrites the very bytes this tab is showing). Mirrors the
+ *  other viewers' poll interval. */
+const RELOAD_POLL_MS = 1500;
+
+const PDF_MIN_SCALE = 0.1;
+const PDF_MAX_SCALE = 8;
+const PDF_ZOOM_STEP = 1.2;
+const clampPdfScale = (s: number) => Math.min(PDF_MAX_SCALE, Math.max(PDF_MIN_SCALE, s));
+
+/**
+ * Extract a PDF page's positioned text runs as {@link TextItemBox}es in big
+ * points (scale-1 viewport, top-left origin). Each box hugs the glyph band
+ * (ascender→descender, ≈0.8 em up / 0.2 em down of the baseline) so an overlay
+ * sits on the text rather than riding high over it. Shared by SyncTeX word
+ * refinement and Ctrl+F search so both box the text identically.
+ *
+ * `rot` is the turn the viewer has applied to this sheet. The boxes are measured in
+ * the SAME rotated space the canvas is painted in, so a search hit still lands on its
+ * word after the page has been turned.
+ */
+async function pageTextItemBoxes(
+  doc: PDFDocumentProxy,
+  pageNumber: number,
+  rot = 0,
+): Promise<TextItemBox[]> {
+  const page = await doc.getPage(pageNumber);
+  const viewport = page.getViewport({
+    scale: 1,
+    rotation: (((page.rotate + rot) % 360) + 360) % 360,
+  });
+  const content = await page.getTextContent();
+  const items: TextItemBox[] = [];
+  for (const it of content.items) {
+    // Skip marked-content markers (no `str`/`transform`).
+    if (!("str" in it) || typeof it.str !== "string" || !it.str) continue;
+    const tx = pdfjs.Util.transform(viewport.transform, it.transform);
+    const em = Math.hypot(tx[2], tx[3]); // scaled font size (em) in big points
+    const ascent = em * 0.8;
+    const descent = em * 0.2;
+    items.push({ str: it.str, x: tx[4], y: tx[5] - ascent, w: it.width, h: ascent + descent });
+  }
+  return items;
+}
+
+/** Height in CSS px of a page rail thumbnail. The width follows the page's aspect. */
+const RAIL_THUMB_H = 96;
+
+// Distinguishes two viewers showing the SAME file (a split view), which would
+// otherwise collide on a tabKey/path-derived strip id.
+let stripSeq = 0;
+const nextStripId = () => ++stripSeq;
+
+/**
+ * One page rail thumbnail.
+ *
+ * Rendered LAZILY: a rail over a 500-page document would otherwise rasterise 500
+ * pages the moment it opens. An IntersectionObserver paints each thumbnail only once
+ * it is near the visible part of the rail, and the card reserves its box beforehand
+ * so the rail's scroll height is right from the start.
+ */
+function PdfThumb({
+  doc,
+  page,
+  rot,
+}: {
+  doc?: PDFDocumentProxy;
+  page: number;
+  rot: number;
+}) {
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const [near, setNear] = useState(false);
+
+  useEffect(() => {
+    const el = canvasRef.current;
+    if (!el || typeof IntersectionObserver === "undefined") {
+      setNear(true); // no observer (tests/jsdom): just render
+      return;
+    }
+    const io = new IntersectionObserver(
+      (entries) => {
+        if (entries.some((e) => e.isIntersecting)) setNear(true);
+      },
+      { root: null, rootMargin: "200px" },
+    );
+    io.observe(el);
+    return () => io.disconnect();
+  }, []);
+
+  useEffect(() => {
+    if (!near || !doc) return;
+    let cancelled = false;
+    let task: { cancel: () => void; promise: Promise<void> } | null = null;
+    void (async () => {
+      const p = await doc.getPage(page);
+      if (cancelled) return;
+      const rotation = (((p.rotate + rot) % 360) + 360) % 360;
+      const base = p.getViewport({ scale: 1, rotation });
+      const viewport = p.getViewport({
+        scale: RAIL_THUMB_H / (base.height || 1),
+        rotation,
+      });
+      const canvas = canvasRef.current;
+      const ctx = canvas?.getContext("2d");
+      if (!canvas || !ctx) return;
+      canvas.width = Math.max(1, Math.floor(viewport.width));
+      canvas.height = Math.max(1, Math.floor(viewport.height));
+      task = p.render({ canvasContext: ctx, viewport });
+      try {
+        await task.promise;
+      } catch {
+        /* superseded by a newer render — ignore */
+      }
+    })();
+    return () => {
+      cancelled = true;
+      task?.cancel();
+    };
+  }, [near, doc, page, rot]);
+
+  // pdf.js has ALREADY painted this canvas at the sheet's rotation, so the card must
+  // not turn it again in CSS — that is why the strip's rotate transform is scoped to
+  // `img` (which the print strip needs, its thumbnails being flat page images).
+  return <canvas ref={canvasRef} className="page-strip-canvas" />;
+}
+
+/** One PDF page rendered to a canvas at `scale` (× devicePixelRatio for
+ *  crispness). Re-renders when the page or scale changes; cancels an in-flight
+ *  render on cleanup so rapid zooming doesn't paint stale frames. */
+function PdfPageCanvas({
+  doc,
+  pageNumber,
+  rot = 0,
+  scale,
+  cssSize,
+  onSyncClick,
+  syncArmed,
+  highlight,
+  searchMatches,
+  searchScrollNonce,
+}: {
+  doc: PDFDocumentProxy;
+  pageNumber: number;
+  /** The turn the viewer has applied to this sheet, on top of the page's own
+   *  `/Rotate`. pdf.js takes the TOTAL rotation, so the two are added. */
+  rot?: number;
+  scale: number;
+  /** This page's intrinsic (scale-1) CSS dimensions, if known. Used to RESERVE
+   *  the canvas's on-screen size immediately — before its async render fills
+   *  pixels — so the page stack reaches its true scroll height right away. Without
+   *  this the canvas defaults to ~150px until rendered, so the container height
+   *  grows page-by-page and a deep restored scroll position is unreachable until
+   *  every page above it has rendered (#viewerpos PDF restore). */
+  cssSize?: { w: number; h: number };
+  /** SyncTeX reverse search: a click maps to big points on this page. */
+  onSyncClick?: (page: number, xBp: number, yBp: number) => void;
+  /** True while Ctrl/⌘ is held, so the page shows the reverse-search cursor. */
+  syncArmed?: boolean;
+  /** SyncTeX forward search: when this page is the target, the box (big points)
+   *  to scroll into view and flash. `nonce` re-triggers a repeat reveal.
+   *  `phrase`, when set, narrows the box to the clicked word via the page's text
+   *  content (using the surrounding words to disambiguate). */
+  highlight?: { rect: SyncRect; nonce: number; phrase?: CaretPhrase } | null;
+  /** Ctrl+F search hits on THIS page: each match is its constituent boxes (big
+   *  points), and `current` marks the one the find bar is parked on (#71).
+   *  Painted as translucent overlays over the canvas. */
+  searchMatches?: { rects: SyncRect[]; current: boolean }[];
+  /** Bumped when the current search match lands on this page, so the current
+   *  match's box scrolls into view (mirrors the SyncTeX reveal). */
+  searchScrollNonce?: number;
+}) {
+  const canvasRef = useRef<HTMLCanvasElement>(null);
+  const wrapRef = useRef<HTMLDivElement>(null);
+  const boxRef = useRef<HTMLDivElement>(null);
+  const searchCurrentRef = useRef<HTMLDivElement>(null);
+  // A SyncTeX box narrowed to the clicked word (when `highlight.phrase` is set and
+  // found in this page's text), else null → the original line box is used.
+  const [refined, setRefined] = useState<SyncRect | null>(null);
+  // A transient marker at the point the user reverse-search-clicked (CSS px within
+  // the page wrapper), giving the jump visible feedback on the PDF side; it
+  // auto-clears after ~2s. `nonce` re-triggers the fade for a repeat click on the
+  // same spot. See `onClick`.
+  const [clickMark, setClickMark] = useState<{ left: number; top: number; nonce: number } | null>(null);
+  const clickTimer = useRef<number | null>(null);
+  useEffect(() => () => { if (clickTimer.current != null) window.clearTimeout(clickTimer.current); }, []);
+
+  useEffect(() => {
+    let cancelled = false;
+    let task: { cancel: () => void; promise: Promise<void> } | null = null;
+    (async () => {
+      const page = await doc.getPage(pageNumber);
+      if (cancelled) return;
+      const dpr = window.devicePixelRatio || 1;
+      const viewport = page.getViewport({
+        scale: scale * dpr,
+        rotation: (((page.rotate + rot) % 360) + 360) % 360,
+      });
+      const canvas = canvasRef.current;
+      const ctx = canvas?.getContext("2d");
+      if (!canvas || !ctx) return;
+      canvas.width = Math.floor(viewport.width);
+      canvas.height = Math.floor(viewport.height);
+      canvas.style.width = `${viewport.width / dpr}px`;
+      canvas.style.height = `${viewport.height / dpr}px`;
+      task = page.render({ canvasContext: ctx, viewport });
+      try {
+        await task.promise;
+      } catch {
+        /* render cancelled by a newer scale — ignore */
+      }
+    })();
+    return () => {
+      cancelled = true;
+      task?.cancel();
+    };
+  }, [doc, pageNumber, rot, scale]);
+
+  // Narrow the SyncTeX line box to the clicked word: pull this page's text runs
+  // (big points, top-left origin, at viewport scale 1) and find the word nearest
+  // the line box. Best-effort — on no match (or no word) the original box stands.
+  useEffect(() => {
+    setRefined(null);
+    const phrase = highlight?.phrase;
+    if (!highlight || !phrase) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const items = await pageTextItemBoxes(doc, pageNumber);
+        if (cancelled) return;
+        const r = refineToWord(highlight.rect, phrase, items);
+        if (!cancelled && r) setRefined(r);
+      } catch {
+        /* fall back to the synctex box */
+      }
+    })();
+    return () => { cancelled = true; };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [highlight?.nonce]);
+
+  // Scroll a forward-search target into view on a new nonce. Center the
+  // highlight *box*, not the whole page — on a tall page the target line can sit
+  // far from page-center, which is what made the jump feel imprecise.
+  useEffect(() => {
+    if (!highlight) return;
+    (boxRef.current ?? wrapRef.current)?.scrollIntoView({ block: "center", inline: "nearest" });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [highlight?.nonce]);
+
+  // Ctrl+F: scroll the current match into view when the find bar parks it on this
+  // page (`searchScrollNonce` bumps). All pages are mounted, so the target page's
+  // box is always present to scroll to.
+  useEffect(() => {
+    if (!searchScrollNonce) return;
+    searchCurrentRef.current?.scrollIntoView({ block: "center", inline: "nearest" });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [searchScrollNonce]);
+
+  const onClick = (e: React.MouseEvent<HTMLCanvasElement>) => {
+    // Reverse search is a Ctrl/⌘-click affordance; plain clicks stay free for
+    // text selection in the PDF.
+    if (!onSyncClick || !(e.ctrlKey || e.metaKey)) return;
+    const rect = e.currentTarget.getBoundingClientRect();
+    const { x, y } = pdfPointToBigPoints(rect, e.clientX, e.clientY, scale);
+    // Mark the clicked point so the source-jump has feedback on the PDF side; the
+    // canvas sits flush at the wrapper's top-left, so canvas-local offsets are
+    // wrapper-local. Clear any prior marker's timer and fade out after ~2s.
+    setClickMark((m) => ({
+      left: e.clientX - rect.left,
+      top: e.clientY - rect.top,
+      nonce: (m?.nonce ?? 0) + 1,
+    }));
+    if (clickTimer.current != null) window.clearTimeout(clickTimer.current);
+    clickTimer.current = window.setTimeout(() => setClickMark(null), 2000);
+    onSyncClick(pageNumber, x, y);
+  };
+
+  const box = highlight ? bigPointsToCssRect(refined ?? highlight.rect, scale) : null;
+
+  return (
+    <div className="file-viewer-pdf-page-wrap" ref={wrapRef}>
+      <canvas
+        ref={canvasRef}
+        className={`file-viewer-pdf-page${onSyncClick && syncArmed ? " is-syncable" : ""}`}
+        // Reserve the page's true size up-front (the async render sets the same
+        // values once pixels are ready), so the stack's scroll height is correct
+        // immediately and a restored scroll position is reachable on the first
+        // ResizeObserver tick rather than only after every page has rendered.
+        style={cssSize ? { width: cssSize.w * scale, height: cssSize.h * scale } : undefined}
+        onClick={onClick}
+      />
+      {searchMatches?.map((m, mi) =>
+        m.rects.map((r, ri) => {
+          const css = bigPointsToCssRect(r, scale);
+          // Anchor the scroll ref on the first box of the current match.
+          const ref = m.current && ri === 0 ? searchCurrentRef : undefined;
+          return (
+            <div
+              key={`s-${mi}-${ri}`}
+              ref={ref}
+              className={`file-viewer-pdf-search-hit${m.current ? " current" : ""}`}
+              style={{ left: css.left, top: css.top, width: css.width, height: css.height }}
+            />
+          );
+        }),
+      )}
+      {box && (
+        <div
+          key={highlight!.nonce}
+          ref={boxRef}
+          className="file-viewer-pdf-sync-highlight"
+          style={{ left: box.left, top: box.top, width: box.width, height: box.height }}
+        />
+      )}
+      {clickMark && (
+        <div
+          key={`click-${clickMark.nonce}`}
+          className="file-viewer-pdf-click-mark"
+          style={{ left: clickMark.left, top: clickMark.top }}
+        />
+      )}
+      <div className="file-viewer-pdf-page-gap" aria-hidden="true">
+        {pageNumber} / {doc.numPages}
+      </div>
+    </div>
+  );
+}
+
+/**
+ * One row of the contents sidebar, plus its children. A node with a resolved page
+ * is a jump button; one without (an unresolvable destination) is inert text. A
+ * node with children carries a ▸/▾ disclosure that toggles its subtree.
+ */
+/** The leading sign for a leaf row, one per level: a dot for the top tiers, a
+ *  dash deeper down — the disclosure caret (a triangle) stands in for it on a row
+ *  that has children, so a branch reads as ▸/▾, a mid leaf as •, a deep leaf as –. */
+const leafSign = (depth: number) => (depth >= 2 ? "–" : "•");
+
+function OutlineRow({
+  node,
+  depth,
+  collapsed,
+  currentId,
+  onToggle,
+  onJump,
+  onHover,
+}: {
+  node: OutlineNode;
+  depth: number;
+  collapsed: Set<string>;
+  currentId: string | null;
+  onToggle: (id: string) => void;
+  onJump: (page: number) => void;
+  onHover: (page: number | null, rect: DOMRect | null) => void;
+}) {
+  const hasKids = node.children.length > 0;
+  const isCollapsed = collapsed.has(node.id);
+  return (
+    <>
+      <div
+        className={`file-viewer-pdf-outline-row${node.id === currentId ? " current" : ""}${node.page == null ? " inert" : ""}`}
+        style={{ paddingLeft: 6 + depth * 14 }}
+      >
+        {hasKids ? (
+          <button
+            className="file-viewer-pdf-outline-caret"
+            onClick={() => onToggle(node.id)}
+            aria-label={isCollapsed ? "Expand" : "Collapse"}
+            title={isCollapsed ? "Expand" : "Collapse"}
+          >
+            {isCollapsed ? "▸" : "▾"}
+          </button>
+        ) : (
+          <span className="file-viewer-pdf-outline-caret is-sign" aria-hidden="true">
+            {leafSign(depth)}
+          </span>
+        )}
+        <button
+          className={`file-viewer-pdf-outline-title depth-${Math.min(depth, 3)}`}
+          onClick={() => node.page != null && onJump(node.page)}
+          onMouseEnter={(e) =>
+            node.page != null && onHover(node.page, e.currentTarget.getBoundingClientRect())
+          }
+          onMouseLeave={() => onHover(null, null)}
+          disabled={node.page == null}
+          title={node.page != null ? `${node.title} — page ${node.page}` : node.title}
+        >
+          {node.title}
+        </button>
+      </div>
+      {hasKids &&
+        !isCollapsed &&
+        node.children.map((c) => (
+          <OutlineRow
+            key={c.id}
+            node={c}
+            depth={depth + 1}
+            collapsed={collapsed}
+            currentId={currentId}
+            onToggle={onToggle}
+            onJump={onJump}
+            onHover={onHover}
+          />
+        ))}
+    </>
+  );
+}
+
+/** Preview card width in CSS px; the thumbnail's height follows the page aspect. */
+const OUTLINE_PREVIEW_W = 220;
+
+/**
+ * A floating thumbnail of a contents entry's page, shown while its row is
+ * hovered. Renders the page once at preview width and memoises it in the shared
+ * `cache` (keyed by file page), so re-hovering the same chapter is instant and a
+ * long document only rasterises the pages actually pointed at.
+ */
+function OutlinePreview({
+  doc,
+  page,
+  top,
+  left,
+  cache,
+}: {
+  doc: PDFDocumentProxy;
+  page: number;
+  top: number;
+  left: number;
+  cache: Map<number, string>;
+}) {
+  const [url, setUrl] = useState<string | null>(() => cache.get(page) ?? null);
+  useEffect(() => {
+    const hit = cache.get(page);
+    if (hit) {
+      setUrl(hit);
+      return;
+    }
+    setUrl(null);
+    let cancelled = false;
+    void (async () => {
+      try {
+        const p = await doc.getPage(page);
+        if (cancelled) return;
+        const base = p.getViewport({ scale: 1, rotation: p.rotate });
+        const dpr = window.devicePixelRatio || 1;
+        const scale = (OUTLINE_PREVIEW_W / (base.width || 1)) * dpr;
+        const viewport = p.getViewport({ scale, rotation: p.rotate });
+        const canvas = document.createElement("canvas");
+        canvas.width = Math.max(1, Math.floor(viewport.width));
+        canvas.height = Math.max(1, Math.floor(viewport.height));
+        const ctx = canvas.getContext("2d");
+        if (!ctx) return;
+        await p.render({ canvasContext: ctx, viewport }).promise;
+        if (cancelled) return;
+        const data = canvas.toDataURL("image/png");
+        cache.set(page, data);
+        setUrl(data);
+      } catch {
+        /* leave the card in its loading state on a render failure */
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [doc, page, cache]);
+
+  return (
+    <div className="file-viewer-pdf-outline-preview" style={{ top, left, width: OUTLINE_PREVIEW_W }}>
+      {url ? (
+        <img src={url} alt="" draggable={false} />
+      ) : (
+        <div className="file-viewer-pdf-outline-preview-loading">Rendering page {page}…</div>
+      )}
+      <div className="file-viewer-pdf-outline-preview-cap">Page {page}</div>
+    </div>
+  );
+}
+
+/**
+ * The contents sidebar: the PDF's embedded outline (chapters/sections) as a
+ * collapsible tree. Clicking an entry jumps the reader to its page; the entry
+ * whose page is currently in view is highlighted; hovering an entry shows a
+ * thumbnail of its page. A PDF with no outline shows a short notice.
+ */
+function OutlinePane({
+  doc,
+  nodes,
+  placeholder,
+  derived,
+  currentId,
+  onJump,
+}: {
+  /** The file's own document, for rendering hover previews (null while loading). */
+  doc: PDFDocumentProxy | null;
+  /** The chapters to show, or null while they're still being loaded/scanned. */
+  nodes: OutlineNode[] | null;
+  /** The message to show when there is nothing to render (loading or empty). */
+  placeholder: string | null;
+  /** True when `nodes` came from the font-size fallback, not an embedded outline. */
+  derived: boolean;
+  currentId: string | null;
+  onJump: (page: number) => void;
+}) {
+  const [collapsed, setCollapsed] = useState<Set<string>>(() => new Set());
+  const toggle = useCallback((id: string) => {
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }, []);
+
+  // Hover preview: a small debounce keeps a quick pass down the list from
+  // rasterising every page it crosses; the card is placed just right of the pane
+  // at the hovered row's height (clamped to stay on screen).
+  const paneRef = useRef<HTMLDivElement>(null);
+  const previewCache = useRef<Map<number, string>>(new Map());
+  const [preview, setPreview] = useState<{ page: number; top: number; left: number } | null>(null);
+  const hoverTimer = useRef<number | null>(null);
+  const onHover = useCallback((page: number | null, rect: DOMRect | null) => {
+    if (hoverTimer.current != null) window.clearTimeout(hoverTimer.current);
+    if (page == null || !rect) {
+      setPreview(null);
+      return;
+    }
+    hoverTimer.current = window.setTimeout(() => {
+      const pane = paneRef.current?.getBoundingClientRect();
+      const left = (pane?.right ?? rect.right) + 8;
+      // Keep the card on screen: assume up to ~320px tall and nudge up if the row
+      // sits near the bottom edge.
+      const top = Math.max(8, Math.min(rect.top, window.innerHeight - 328));
+      setPreview({ page, top, left });
+    }, 140);
+  }, []);
+  useEffect(
+    () => () => { if (hoverTimer.current != null) window.clearTimeout(hoverTimer.current); },
+    [],
+  );
+
+  return (
+    <div className="file-viewer-pdf-outline" ref={paneRef}>
+      <div className="file-viewer-pdf-outline-head">
+        <span>Contents</span>
+        <UntestedTag />
+      </div>
+      {derived && nodes && nodes.length > 0 && (
+        <div className="file-viewer-pdf-outline-note" title="This document has no embedded table of contents; these headings were inferred from the text's font sizes.">
+          Inferred from text
+        </div>
+      )}
+      <div
+        className="file-viewer-pdf-outline-body"
+        // A stale row rect after a scroll would misplace the card, so drop it.
+        onScroll={() => setPreview(null)}
+      >
+        {placeholder != null ? (
+          <div className="file-viewer-pdf-outline-empty">{placeholder}</div>
+        ) : (
+          nodes!.map((n) => (
+            <OutlineRow
+              key={n.id}
+              node={n}
+              depth={0}
+              collapsed={collapsed}
+              currentId={currentId}
+              onToggle={toggle}
+              onJump={onJump}
+              onHover={onHover}
+            />
+          ))
+        )}
+      </div>
+      {preview && doc && (
+        <OutlinePreview
+          doc={doc}
+          page={preview.page}
+          top={preview.top}
+          left={preview.left}
+          cache={previewCache.current}
+        />
+      )}
+    </div>
+  );
+}
+
+/**
+ * Reusable pdf.js-backed PDF view: a zoom toolbar over a scrolling stack of page
+ * canvases. Unlike the old native `<iframe>`, every surface here is ours, so the
+ * surround and (via the global scrollbar rules) the scrollbar follow the app
+ * theme — giving a dark viewer in dark themes while the pages stay as authored.
+ *
+ * The bytes at `path` can change under us — e.g. the LaTeX viewer recompiles the
+ * PDF this tab is showing — so we poll `file_mtime` and reload when it advances,
+ * the PDF counterpart to the editors' diff-aware reload (#43).
+ */
+function PdfCanvas({
+  path,
+  onOpenExternally,
+  tabKey,
+  groupId,
+}: {
+  path: string;
+  /** When set, an "Open externally" button is shown at the end of the toolbar.
+   *  Used by the standalone PDF tab, which has no separate header row. */
+  onOpenExternally?: () => void;
+  /** This viewer tab's key, for #viewerpos scroll/zoom persistence. */
+  tabKey?: string;
+  /** Hosting subwindow (group) id, for proportional scroll-linking (scrollSync). */
+  groupId?: string | null;
+}) {
+  const scope = useFileScope();
+
+  // "Present": turn this PDF into a deck — a sidecar of editable layers beside
+  // it, plus the fullscreen presenter. Experimental, so the button is absent
+  // unless the flag is on. Creating the sidecar is deliberately non-destructive:
+  // the PDF is untouched, and an existing deck is opened rather than replaced.
+  const deckEnabled = useExperimental("deck_presenter");
+  const [makingDeck, setMakingDeck] = useState(false);
+  const openAsDeck = useCallback(async () => {
+    setMakingDeck(true);
+    try {
+      const deckPath = deckPathForPdf(path);
+      let exists = true;
+      try {
+        await readFileText(deckPath, scope);
+      } catch {
+        exists = false;
+      }
+      if (!exists) {
+        const deck = emptyDeck(basename(path));
+        await writeFileBytes(
+          deckPath,
+          new TextEncoder().encode(serializeDeck(deck)),
+          scope,
+        );
+      }
+      // Imported lazily: `FileViewerPane` already imports this module, so a
+      // static import would close a cycle. The call happens in a callback, long
+      // after both modules have initialised, so deferring it costs nothing and
+      // keeps the dependency one-way on paper — the same reason
+      // `openProjectFilesTab` lives beside its tab rather than in the view.
+      const { openLinkedFile } = await import("../FileViewerPane");
+      openLinkedFile(tabKey, dirname(path) || "/", {
+        path: deckPath,
+        viewer: "eldeck",
+        label: basename(deckPath),
+      });
+    } catch (e) {
+      setError(describeFileError(e));
+    } finally {
+      setMakingDeck(false);
+    }
+  }, [path, scope, tabKey]);
+  const viewPos = useViewerState(tabKey);
+  const [doc, setDoc] = useState<PDFDocumentProxy | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  // ── The working arrangement (#page-arrange) ──────────────────────────────
+  // The sheets this viewer shows, and the documents they are drawn from. The
+  // reader below renders straight off `pages`, so reordering/deleting/turning a
+  // page is an array operation — nothing is re-parsed and nothing touches disk
+  // until Save, which is the only place pdf-lib runs (`buildPdf`).
+  const [sources, setSources] = useState<PdfSources>(() => new Map());
+  // The authoritative live map. State mirrors it for rendering, but the ref is what
+  // the load effect's cleanup frees from — correct even if teardown beats a re-render.
+  const sourcesRef = useRef<PdfSources>(new Map());
+  const [pages, setPages] = useState<PageList>([]);
+  // A drag's callbacks outlive the render they were created in (an import can land
+  // seconds later, from another window), so they read the arrangement from here
+  // rather than closing over a stale snapshot.
+  const pagesRef = useRef<PageList>([]);
+  pagesRef.current = pages;
+  // "Page X / N" toolbar readout: the page occupying the viewport. Declared here
+  // (rather than beside `updateVisiblePage` below) so the go-to-page control,
+  // which seeds its input from the current value, can read it too.
+  const [visiblePage, setVisiblePage] = useState(1);
+  // Undo/redo: the arrangement is a small immutable list, so history is just a
+  // stack of them.
+  const [past, setPast] = useState<PageList[]>([]);
+  const [future, setFuture] = useState<PageList[]>([]);
+  const [saving, setSaving] = useState(false);
+  const [editError, setEditError] = useState<string | null>(null);
+  /** The page rail (the thumbnail strip you arrange pages in) is showing. */
+  const [railOpen, setRailOpen] = useState(false);
+  /** The contents sidebar (the PDF's chapters/outline) is showing. */
+  const [outlineOpen, setOutlineOpen] = useState(false);
+  /** The document's resolved outline: null = not loaded yet, [] = none. */
+  const [outline, setOutline] = useState<OutlineNode[] | null>(null);
+  /** The font-size heading fallback, used only when `outline` is empty: null =
+   *  not scanned yet, [] = none found. */
+  const [headings, setHeadings] = useState<OutlineNode[] | null>(null);
+  /** The rail's current selection, so an insert lands where the reader is looking. */
+  const [selection, setSelection] = useState<Set<string>>(new Set());
+  /** The "Insert PDF…" picker is open. */
+  const [pickerOpen, setPickerOpen] = useState(false);
+  // Identifies this viewer's rail among every strip mounted in this window, so a drag
+  // from another rail can target it. Stable for the life of the viewer.
+  const [stripId] = useState(() => `pdfrail:${tabKey ?? path}:${nextStripId()}`);
+  // The file changed on disk while we hold unsaved edits — reloading would throw
+  // them away, so ask instead of silently clobbering either side.
+  const [staleOnDisk, setStaleOnDisk] = useState(false);
+
+  /** Unsaved edits: the arrangement no longer describes the file on disk. */
+  const dirty = doc != null && pages.length > 0 && !isPristine(pages, doc.numPages);
+  // The mtime poll runs on an interval that closes over its own scope; it needs
+  // the LIVE dirty flag to decide whether an on-disk change may auto-reload.
+  const dirtyRef = useRef(false);
+  dirtyRef.current = dirty;
+
+  /** Record an arrangement edit, making it undoable. */
+  const applyEdit = useCallback((next: PageList) => {
+    setPages((cur) => {
+      setPast((p) => [...p, cur]);
+      setFuture([]);
+      return next;
+    });
+  }, []);
+
+  const undo = useCallback(() => {
+    setPast((p) => {
+      if (p.length === 0) return p;
+      const prev = p[p.length - 1];
+      setPages((cur) => {
+        setFuture((f) => [cur, ...f]);
+        return prev;
+      });
+      return p.slice(0, -1);
+    });
+  }, []);
+
+  const redo = useCallback(() => {
+    setFuture((f) => {
+      if (f.length === 0) return f;
+      const next = f[0];
+      setPages((cur) => {
+        setPast((p) => [...p, cur]);
+        return next;
+      });
+      return f.slice(1);
+    });
+  }, []);
+  // Restore the saved zoom if there is one; otherwise the load effect fits the
+  // page width. `1.2` is only the pre-load placeholder.
+  const [scale, setScale] = useState(viewPos.initial?.scale ?? 1.2);
+  // True while the PDF is at the fit-to-width baseline, so a pane/tab resize
+  // re-fits. A manual zoom (buttons / Ctrl+wheel) clears it; the "Fit width"
+  // button and the initial fit restore it. Mirrors ImageViewer's `fittedRef`.
+  const fittedRef = useRef(viewPos.initial?.scale == null);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  // Proportional scroll-link to a paired subwindow (no-op unless linked).
+  const reportScrollSync = useScrollSync(groupId, scrollRef);
+  const contentRef = useRef<HTMLDivElement>(null);
+  // True once the first document load has run, so only that load restores the
+  // session-persisted scroll/zoom (#viewerpos); later reloads behave as before.
+  const didInitialLoad = useRef(false);
+  // After a Ctrl+wheel zoom changes `scale`, the page canvases re-render to the
+  // new size asynchronously. We stash the scroll target that keeps the cursor's
+  // document point fixed and apply it once the content has actually resized.
+  const pendingScroll = useRef<{ top: number; left: number } | null>(null);
+  // Bumped whenever the file's mtime advances on disk, forcing a byte reload.
+  const [diskVersion, setDiskVersion] = useState(0);
+  const lastMtime = useRef<number | null>(null);
+  // The path the currently-loaded document came from. A reload that keeps the
+  // same path (a recompile bumped `diskVersion`) should preserve the reader's
+  // scroll position; switching to a different file should not.
+  const loadedPath = useRef<string | null>(null);
+  // Scroll target to restore after a same-path reload (a recompile). The page
+  // canvases re-render asynchronously, so the content grows over several frames;
+  // the ResizeObserver below re-applies this until the position is reachable.
+  const restoreScroll = useRef<{ top: number; left: number } | null>(null);
+  // True when the document about to load is a same-path reload (a recompile
+  // rewrote this PDF). The fit effect reads it to keep the reader's current zoom
+  // instead of snapping back to fit-width. Set at load-start so it reflects the
+  // load that produced the current `doc`, regardless of effect timing.
+  const reloadKeepZoom = useRef(false);
+  // True when a `.synctex(.gz)` sits beside the PDF, enabling reverse search.
+  const [syncable, setSyncable] = useState(false);
+  // True while Ctrl/⌘ is held: reverse-search clicks fire and pages show the
+  // crosshair cursor only then, leaving plain clicks free for text selection.
+  const [syncArmed, setSyncArmed] = useState(false);
+  useEffect(() => {
+    if (!syncable) return;
+    const sync = (e: KeyboardEvent | MouseEvent) =>
+      setSyncArmed(e.ctrlKey || e.metaKey);
+    const clear = () => setSyncArmed(false);
+    window.addEventListener("keydown", sync);
+    window.addEventListener("keyup", sync);
+    window.addEventListener("mousemove", sync);
+    window.addEventListener("blur", clear);
+    return () => {
+      window.removeEventListener("keydown", sync);
+      window.removeEventListener("keyup", sync);
+      window.removeEventListener("mousemove", sync);
+      window.removeEventListener("blur", clear);
+    };
+  }, [syncable]);
+
+  // SyncTeX forward search: a pending reveal/highlight request for this PDF.
+  // Copied into local state so we can consume the store request immediately
+  // (avoiding a re-fire) while keeping the highlight mounted to animate.
+  const reveal = usePdfSyncStore((s) => s.byPath[path] ?? null);
+  const consumeReveal = usePdfSyncStore((s) => s.consume);
+  const [highlight, setHighlight] = useState<{ rect: SyncRect; nonce: number; phrase?: CaretPhrase } | null>(null);
+  useEffect(() => {
+    if (!reveal) return;
+    setHighlight({ rect: reveal.rect, nonce: reveal.nonce, phrase: reveal.phrase });
+    consumeReveal(path);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [reveal?.nonce]);
+
+  // A SyncTeX reveal names a page of the FILE, but the reader shows an arrangement —
+  // that page may have been moved, or dropped. Resolve it to the sheet currently
+  // showing it (-1 = not on screen any more, so no highlight).
+  const syncSheetIndex = useMemo(
+    () =>
+      highlight
+        ? pages.findIndex((r) => r.src === SELF && r.page === highlight.rect.page)
+        : -1,
+    [highlight, pages],
+  );
+
+  // ── Ctrl+F text search (#71) ───────────────────────────────────────
+  // A floating find bar over the page stack with next/previous navigation, a
+  // live match count, and a case toggle. Matches are found in each page's
+  // extracted text (`getTextContent`) and painted as translucent boxes over the
+  // canvases (`pdfPageMatches` → per-page rects), the current one brighter and
+  // scrolled into view — the PDF counterpart to the editors' in-text search.
+  const [findOpen, setFindOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const [caseSensitive, setCaseSensitive] = useState(false);
+  const [current, setCurrent] = useState(0);
+  const findInputRef = useRef<HTMLInputElement>(null);
+  // Print: the webview can't print a PDF directly, so rasterise the already-open
+  // pages to images and print those through the shared pipeline. `printing`
+  // disables the button while the (async) render runs.
+  const [printing, setPrinting] = useState(false);
+  const handlePrint = useCallback(async () => {
+    if (!doc || printing || pages.length === 0) return;
+    setPrinting(true);
+    try {
+      // Rasterise the ARRANGEMENT, not the file: printing an edited PDF prints what
+      // is on screen, without having to save it first.
+      const images = await renderPdfPagesToImages(pages, (id) => sources.get(id)?.doc);
+      const body = images
+        .map((src) => `<div class="print-page"><img src="${src}" alt=""></div>`)
+        .join("");
+      await printHtmlBody(body, PDF_PRINT_CSS);
+    } finally {
+      setPrinting(false);
+    }
+  }, [doc, printing, pages, sources]);
+
+  /**
+   * Write the arrangement back to the file. The ONLY place a PDF is written.
+   *
+   * After a successful save the reader must be showing exactly what is now on disk,
+   * so rather than trying to reconcile the arrangement in place we bump `diskVersion`
+   * and let the load effect re-read the file — which resets the arrangement to the
+   * identity, clears the history and frees any merged-in sources. `lastMtime` is
+   * advanced first so our OWN write can't also trip the external-change poll.
+   */
+  const handleSave = useCallback(async () => {
+    if (!dirty || saving) return;
+    setSaving(true);
+    setEditError(null);
+    try {
+      const bytes = await buildPdf(pages, sources);
+      await writeFileBytes(path, bytes, scope);
+      const m = await fileMtime(path, scope).catch(() => null);
+      if (m != null) lastMtime.current = m;
+      setStaleOnDisk(false);
+      setDiskVersion((v) => v + 1);
+    } catch (e) {
+      setEditError(e instanceof Error ? e.message : String(e));
+    } finally {
+      setSaving(false);
+    }
+  }, [dirty, saving, pages, sources, path, scope]);
+
+  // ── Merge: splice another PDF's pages into this arrangement ──────────────
+  // The project the viewed file belongs to (the longest project directory that is a
+  // prefix of `path`), so the picker lists the right tree even in a detached window.
+  // It must stay project-scoped: the backend confines every read to the scope's tree,
+  // so an arbitrary path from an OS file dialog would simply be refused.
+  const pdfProjectDir = useMemo(() => {
+    const { projects } = useProjectsStore.getState();
+    let best = "";
+    for (const p of projects) {
+      const dir = resolveProjectDirectory(p);
+      if (dir && isPathWithin(path, dir) && dir.length > best.length) best = dir;
+    }
+    return best;
+  }, [path]);
+
+  /** Where an insert lands: after the last selected sheet, else at the end. */
+  const insertAt = useCallback(() => {
+    if (selection.size === 0) return pages.length;
+    let last = -1;
+    pages.forEach((r, i) => {
+      if (selection.has(r.id)) last = i;
+    });
+    return last < 0 ? pages.length : last + 1;
+  }, [pages, selection]);
+
+  /** Open a PDF's bytes as a new source and splice all of its pages in at `at`. */
+  const spliceIn = useCallback(
+    async (bytes: Uint8Array, at: number) => {
+      const src = await openSource(bytes);
+      const id = newSourceId();
+      // The ref is authoritative (the load effect's cleanup frees from it), so it
+      // and the state map are updated together.
+      sourcesRef.current = new Map(sourcesRef.current).set(id, src);
+      setSources(sourcesRef.current);
+      applyEdit(insertPages(pagesRef.current, pagesOf(id, src.doc.numPages), at));
+    },
+    [applyEdit],
+  );
+
+  /** Read a PDF from the project and splice all of its pages in. */
+  const mergePdf = useCallback(
+    async (abs: string) => {
+      setEditError(null);
+      try {
+        const bytes = await readFileBytes(abs, scope);
+        await spliceIn(new Uint8Array(bytes), insertAt());
+      } catch (e) {
+        setEditError(
+          `Could not insert ${basename(abs)}: ${e instanceof Error ? e.message : String(e)}`,
+        );
+      }
+    },
+    [scope, spliceIn, insertAt],
+  );
+
+  // ── Dragging pages to another PDF viewer, in this window or another ──────
+  // The bytes cannot ride a JS object across a window boundary (separate WebViews,
+  // separate heaps), so the dragged pages are built into a small PDF and parked in the
+  // backend page clipboard; the drag carries only its token. See `stores/pdfDrag`.
+
+  /** Build the dragged pages into a standalone PDF and park it for the drop. */
+  const exportPages = useCallback(
+    async (ids: string[]): Promise<PageTransfer | null> => {
+      const picked = pagesRef.current.filter((r) => ids.includes(r.id));
+      if (picked.length === 0) return null;
+      try {
+        const bytes = await buildPdf(picked, sourcesRef.current);
+        const token = await invoke<string>("pdf_clip_set", { bytes: Array.from(bytes) });
+        return { token, count: picked.length };
+      } catch (e) {
+        setEditError(
+          `Could not copy those pages: ${e instanceof Error ? e.message : String(e)}`,
+        );
+        return null;
+      }
+    },
+    [],
+  );
+
+  /** Take pages dragged out of another viewer and splice them in at `index`. */
+  const importPages = useCallback(
+    (transfer: PageTransfer, index: number) => {
+      void (async () => {
+        try {
+          const bytes = await invoke<number[]>("pdf_clip_get", { token: transfer.token });
+          await spliceIn(new Uint8Array(bytes), index);
+        } catch (e) {
+          setEditError(
+            `Could not insert those pages: ${e instanceof Error ? e.message : String(e)}`,
+          );
+        }
+      })();
+    },
+    [spliceIn],
+  );
+
+  /** The dragged pages were MOVED (Shift) and the drop was acknowledged: drop them. */
+  const dropMovedPages = useCallback(
+    (ids: string[]) => {
+      applyEdit(deletePages(pagesRef.current, ids));
+    },
+    [applyEdit],
+  );
+  // Per-SHEET text runs, extracted lazily the first time the find bar is used and
+  // cached until the arrangement changes. Indexed by position in the arrangement —
+  // not by page number in the file — so a search hit points at the sheet you are
+  // actually looking at once pages have been moved, deleted or merged in. Each
+  // sheet is read from its own source document, at its own rotation.
+  const [pageText, setPageText] = useState<TextItemBox[][] | null>(null);
+  useEffect(() => { setPageText(null); }, [pages]);
+  useEffect(() => {
+    if (!findOpen || pageText || pages.length === 0) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const texts = await Promise.all(
+          pages.map((ref) => {
+            const d = sources.get(ref.src)?.doc;
+            return d ? pageTextItemBoxes(d, ref.page, ref.rot) : Promise.resolve([]);
+          }),
+        );
+        if (!cancelled) setPageText(texts);
+      } catch {
+        if (!cancelled) setPageText([]); // give up gracefully — search finds nothing
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [pages, sources, findOpen, pageText]);
+
+  // Flat list of matches across all pages, in document order; each carries its
+  // 1-based page and the big-point boxes covering it.
+  const matches = useMemo(() => {
+    if (!findOpen || !query || !pageText) return [];
+    const out: { page: number; rects: SyncRect[] }[] = [];
+    pageText.forEach((items, i) => {
+      for (const rects of pdfPageMatches(items, i + 1, query, caseSensitive)) {
+        out.push({ page: i + 1, rects });
+      }
+    });
+    return out;
+  }, [findOpen, query, caseSensitive, pageText]);
+
+  // Bumped to ask the page holding the current match to scroll it into view.
+  const [searchScrollNonce, setSearchScrollNonce] = useState(0);
+
+  // Per-page search overlays passed to each PdfPageCanvas: its matches (with the
+  // current one flagged) plus a scroll nonce that only advances for the page the
+  // current match sits on.
+  const searchByPage = useMemo(() => {
+    const map = new Map<number, { rects: SyncRect[]; current: boolean }[]>();
+    matches.forEach((m, i) => {
+      const list = map.get(m.page) ?? [];
+      list.push({ rects: m.rects, current: i === current });
+      map.set(m.page, list);
+    });
+    return map;
+  }, [matches, current]);
+  const currentPage = matches[current]?.page ?? 0;
+
+  // #71 scrollbar markers: one tick per match positioned over the native
+  // scrollbar track at the match's fractional position through the document, so
+  // hits scrolled off-screen are still locatable at a glance. Each tick's `top`
+  // is px within the track (= the scroll area's visible height); the current
+  // match's tick is flagged. Derived from live geometry — the page wraps'
+  // on-screen rects plus the match box's y within its page — so it stays correct
+  // across zoom and resize (recomputed by the effect below).
+  const [markerTops, setMarkerTops] = useState<{ top: number; current: boolean }[]>([]);
+  const recomputeMarkers = useCallback(() => {
+    const scroll = scrollRef.current;
+    const content = contentRef.current;
+    if (!findOpen || !scroll || !content || matches.length === 0) {
+      setMarkerTops((prev) => (prev.length === 0 ? prev : []));
+      return;
+    }
+    const wraps = content.children; // page wraps, in page order
+    const scrollTop0 = scroll.getBoundingClientRect().top;
+    const track = scroll.clientHeight; // scrollbar track height = visible height
+    const total = scroll.scrollHeight;
+    if (total <= 0) return;
+    const tops: { top: number; current: boolean }[] = [];
+    matches.forEach((m, i) => {
+      const wrap = wraps[m.page - 1] as HTMLElement | undefined;
+      if (!wrap) return;
+      // The page's top in scroll-content coordinates (independent of the current
+      // scroll offset), plus the match box's y within the page.
+      const pageTop = wrap.getBoundingClientRect().top - scrollTop0 + scroll.scrollTop;
+      const matchTop = pageTop + (m.rects[0]?.y ?? 0) * scale;
+      tops.push({ top: (matchTop / total) * track, current: i === current });
+    });
+    setMarkerTops(tops);
+  }, [findOpen, matches, current, scale]);
+
+  // Recompute markers when the match set / zoom / find-bar visibility changes,
+  // and whenever the scroll area or page stack resizes (canvases render lazily,
+  // growing the stack over several frames; a window/pane resize changes the
+  // track height).
+  useEffect(() => {
+    recomputeMarkers();
+    const scroll = scrollRef.current;
+    const content = contentRef.current;
+    if (!scroll || !content || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => recomputeMarkers());
+    ro.observe(scroll);
+    ro.observe(content);
+    return () => ro.disconnect();
+  }, [recomputeMarkers]);
+
+  // Clamp the current index when the match set shrinks (query/case change).
+  useEffect(() => {
+    if (current > 0 && current >= matches.length) {
+      setCurrent(matches.length > 0 ? matches.length - 1 : 0);
+    }
+  }, [matches.length, current]);
+
+  // Jump to the first match whenever the query/case changes, the bar opens, or
+  // the page text finishes extracting (so a query typed before extraction
+  // completed still scrolls to its first hit).
+  useEffect(() => {
+    if (!findOpen) return;
+    setCurrent(0);
+    setSearchScrollNonce((n) => n + 1);
+  }, [query, caseSensitive, findOpen, pageText]);
+
+  const goToMatch = useCallback(
+    (dir: 1 | -1) => {
+      if (matches.length === 0) return;
+      setCurrent((c) => (c + dir + matches.length) % matches.length);
+      setSearchScrollNonce((n) => n + 1);
+    },
+    [matches.length],
+  );
+
+  const openFind = useCallback(() => {
+    setFindOpen(true);
+    requestAnimationFrame(() => {
+      findInputRef.current?.focus();
+      findInputRef.current?.select();
+    });
+  }, []);
+  const closeFind = useCallback(() => {
+    setFindOpen(false);
+    scrollRef.current?.focus();
+  }, []);
+
+  // ── Go to page (Ctrl+G) ───────────────────────────────────────────────────
+  // Jumps by ARRANGEMENT position — the same "X / N" the toolbar readout and
+  // `visiblePage` already count in — so it lands right even after pages have
+  // been reordered/merged/deleted, without having to resolve a file page first.
+  const [pageJumpOpen, setPageJumpOpen] = useState(false);
+  const [pageJumpValue, setPageJumpValue] = useState("");
+  const pageJumpInputRef = useRef<HTMLInputElement>(null);
+  const jumpToArrangementIndex = useCallback((pos: number) => {
+    const count = pagesRef.current.length;
+    if (count === 0) return;
+    const idx = Math.min(Math.max(Math.trunc(pos), 1), count) - 1;
+    const wrap = contentRef.current?.children[idx] as HTMLElement | undefined;
+    wrap?.scrollIntoView({ block: "start", inline: "nearest" });
+  }, []);
+  const openPageJump = useCallback(() => {
+    if (pages.length === 0) return;
+    setPageJumpValue(String(visiblePage));
+    setPageJumpOpen(true);
+    requestAnimationFrame(() => {
+      pageJumpInputRef.current?.focus();
+      pageJumpInputRef.current?.select();
+    });
+  }, [pages.length, visiblePage]);
+  const closePageJump = useCallback(() => {
+    setPageJumpOpen(false);
+    scrollRef.current?.focus();
+  }, []);
+  const commitPageJump = useCallback(() => {
+    const n = parseInt(pageJumpValue, 10);
+    if (Number.isFinite(n)) jumpToArrangementIndex(n);
+    closePageJump();
+  }, [pageJumpValue, jumpToArrangementIndex, closePageJump]);
+
+  // Ctrl/Cmd+F opens the find bar, Ctrl/Cmd+G opens go-to-page; Esc closes
+  // whichever is open. Bound on the host so it fires wherever focus sits within
+  // the PDF pane (the scroll area is focusable).
+  const onHostKeyDown = useCallback(
+    (e: React.KeyboardEvent<HTMLDivElement>) => {
+      const mod = e.ctrlKey || e.metaKey;
+      const key = e.key.toLowerCase();
+      if (mod && key === "f") {
+        e.preventDefault();
+        openFind();
+      } else if (mod && key === "g") {
+        e.preventDefault();
+        openPageJump();
+      } else if (mod && key === "s") {
+        e.preventDefault();
+        void handleSave();
+      } else if (mod && key === "z" && !e.shiftKey) {
+        e.preventDefault();
+        undo();
+      } else if (mod && (key === "y" || (key === "z" && e.shiftKey))) {
+        e.preventDefault();
+        redo();
+      } else if (e.key === "Escape" && pageJumpOpen) {
+        e.preventDefault();
+        closePageJump();
+      } else if (e.key === "Escape" && findOpen) {
+        e.preventDefault();
+        closeFind();
+      }
+    },
+    [openFind, closeFind, findOpen, openPageJump, closePageJump, pageJumpOpen, handleSave, undo, redo],
+  );
+  const onFindKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      goToMatch(e.shiftKey ? -1 : 1);
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      closeFind();
+    }
+  };
+
+  // Probe for SyncTeX data beside the PDF; re-checked after each disk change
+  // (a recompile may have just written it).
+  useEffect(() => {
+    let cancelled = false;
+    const base = path.replace(/\.pdf$/i, "");
+    const exists = (p: string) =>
+      fileMtime(p, scope).then(() => true).catch(() => false);
+    void Promise.all([exists(`${base}.synctex.gz`), exists(`${base}.synctex`)]).then(
+      ([gz, raw]) => { if (!cancelled) setSyncable(gz || raw); },
+    );
+    return () => { cancelled = true; };
+  }, [path, scope, diskVersion]);
+
+  // Reverse search: a click on a page → which source line produced it → jump.
+  const onSyncClick = useCallback(
+    async (page: number, x: number, y: number) => {
+      const src = await synctexEdit(path, page, x, y);
+      if (src) jumpToSource(src.input, src.line, src.column);
+    },
+    [path],
+  );
+
+  // Poll mtime; on an advance (e.g. a recompile wrote a new PDF), bump
+  // diskVersion so the load effect re-reads the fresh bytes (#43-style).
+  useEffect(() => {
+    lastMtime.current = null;
+    let cancelled = false;
+    fileMtime(path, scope)
+      .then((m) => { if (!cancelled) lastMtime.current = m; })
+      .catch(() => {});
+    const id = setInterval(() => {
+      fileMtime(path, scope)
+        .then((m) => {
+          if (cancelled || lastMtime.current == null || m <= lastMtime.current) return;
+          lastMtime.current = m;
+          // A reload REPLACES the arrangement, so it would silently throw away any
+          // unsaved page edits. With edits pending we raise a banner and let the
+          // reader choose; without them the old auto-reload stands (a LaTeX
+          // recompile must still refresh the PDF on its own).
+          if (dirtyRef.current) setStaleOnDisk(true);
+          else setDiskVersion((v) => v + 1);
+        })
+        .catch(() => {});
+    }, RELOAD_POLL_MS);
+    return () => { cancelled = true; clearInterval(id); };
+  }, [path, scope]);
+
+  // Load (and reload on path / disk change) the document. pdf.js detaches the
+  // backing buffer, so each load gets a fresh Uint8Array; the prior documents are
+  // destroyed on cleanup to free worker memory.
+  useEffect(() => {
+    let cancelled = false;
+    // Same-path reload (a recompile): remember where the reader was so we can
+    // restore it once the fresh pages have laid out, instead of jumping to the
+    // top. A genuine file switch starts fresh. On the FIRST load, instead restore
+    // the position persisted from a prior session (#viewerpos) so an Eldrun
+    // restart reopens the PDF where the reader left it.
+    const el = scrollRef.current;
+    let firstRestore: { top: number; left: number } | null = null;
+    if (!didInitialLoad.current) {
+      didInitialLoad.current = true;
+      const init = viewPos.initial;
+      if (init && ((init.scrollTop ?? 0) > 0 || (init.scrollLeft ?? 0) > 0)) {
+        firstRestore = { top: init.scrollTop ?? 0, left: init.scrollLeft ?? 0 };
+      }
+    }
+    const samePathReload = loadedPath.current === path;
+    restoreScroll.current =
+      firstRestore ??
+      (samePathReload && el
+        ? { top: el.scrollTop, left: el.scrollLeft }
+        : null);
+    reloadKeepZoom.current = samePathReload;
+    loadedPath.current = path;
+    setDoc(null);
+    setError(null);
+    (async () => {
+      try {
+        const bytes = await readFileBytes(path, scope);
+        if (cancelled) return;
+        // `openSource` keeps a pristine copy of the bytes for pdf-lib: pdf.js
+        // DETACHES the buffer it is handed, so a save could not reuse them.
+        const src = await openSource(new Uint8Array(bytes));
+        if (cancelled) {
+          src.doc.destroy();
+          return;
+        }
+        // A load is a fresh start: one source, the identity arrangement, no history.
+        // The ref is the authoritative map (the cleanup below frees from it, and it
+        // is correct even if a teardown beats React's re-render).
+        sourcesRef.current = new Map([[SELF, src]]);
+        setSources(sourcesRef.current);
+        setPages(initialPages(src.doc.numPages));
+        setPast([]);
+        setFuture([]);
+        setStaleOnDisk(false);
+        setEditError(null);
+        setDoc(src.doc);
+      } catch (e) {
+        if (!cancelled) setError(String(e));
+      }
+    })();
+    // Safety net: stop trying to restore after the pages have had time to lay
+    // out, so a target the reloaded PDF can't reach never re-applies later
+    // (e.g. fighting a subsequent zoom).
+    const restoreDeadline = restoreScroll.current
+      ? setTimeout(() => { restoreScroll.current = null; }, 2000)
+      : null;
+    return () => {
+      cancelled = true;
+      // Release every document the outgoing arrangement drew from — the file itself
+      // AND any merged-in PDFs — not just the one this effect opened.
+      for (const s of sourcesRef.current.values()) s.doc.destroy();
+      sourcesRef.current = new Map();
+      if (restoreDeadline) clearTimeout(restoreDeadline);
+    };
+  }, [path, scope, diskVersion]);
+
+  // Intrinsic (scale-1) CSS dimensions of every page, computed once per document
+  // load. Lets each PdfPageCanvas reserve its true size before rendering so the
+  // page stack reaches its full scroll height immediately — without it the
+  // restored scroll position (#viewerpos) is unreachable until every page above
+  // it has finished rendering, which on a slow startup loses the position to the
+  // restore deadline. getPage()/getViewport() read only page metadata (no
+  // rasterisation), so this is cheap relative to actually rendering the pages.
+  const [pageSizes, setPageSizes] = useState<{ w: number; h: number }[] | null>(null);
+  useEffect(() => {
+    if (pages.length === 0) {
+      setPageSizes(null);
+      return;
+    }
+    let cancelled = false;
+    void (async () => {
+      try {
+        const sizes = await Promise.all(
+          pages.map(async (ref) => {
+            const d = sources.get(ref.src)?.doc;
+            if (!d) return { w: 0, h: 0 };
+            const page = await d.getPage(ref.page);
+            // A quarter turn swaps the sheet's box; asking for the rotated viewport
+            // means the reserved height is right for turned pages too.
+            const vp = page.getViewport({
+              scale: 1,
+              rotation: (((page.rotate + ref.rot) % 360) + 360) % 360,
+            });
+            return { w: vp.width, h: vp.height };
+          }),
+        );
+        if (!cancelled) setPageSizes(sizes);
+      } catch {
+        /* leave heights unreserved — restore falls back to the old behaviour */
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [pages, sources]);
+
+  // Fit the first page to the viewport width when a document loads.
+  const fitWidth = useCallback(async (d: PDFDocumentProxy) => {
+    const el = scrollRef.current;
+    if (!el) return;
+    const page = await d.getPage(1);
+    const vp = page.getViewport({ scale: 1 });
+    const avail = el.clientWidth - 24; // leave room for page margins
+    if (avail > 0 && vp.width > 0) {
+      setScale(clampPdfScale(avail / vp.width));
+      fittedRef.current = true;
+    }
+  }, []);
+
+  // Fit to width when a document loads — UNLESS this is the first load and a zoom
+  // was persisted from a prior session, in which case honour the saved scale
+  // (already seeded into `scale`). A same-path reload (a recompile rewrote this
+  // PDF) keeps the reader's current zoom rather than snapping back to fit-width;
+  // only a genuine switch to a different file refits.
+  const didInitialFit = useRef(false);
+  useEffect(() => {
+    if (!doc) return;
+    if (!didInitialFit.current) {
+      didInitialFit.current = true;
+      if (viewPos.initial?.scale != null) return;
+    } else if (reloadKeepZoom.current) {
+      return;
+    }
+    void fitWidth(doc);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [doc, fitWidth]);
+
+  // Re-fit to width when the pane/tab resizes, but only while at the fit
+  // baseline — a manual zoom opts out. Same contract as ImageViewer's resize
+  // re-fit. `fitWidth` reads scrollRef.clientWidth, so the pane width alone
+  // drives it; a scale change doesn't alter the pane width, so no feedback loop.
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (!doc || !el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => {
+      if (fittedRef.current) void fitWidth(doc);
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [doc, fitWidth]);
+
+  // #viewerpos: persist the zoom whenever it changes (only once a document is up,
+  // so the pre-load placeholder scale is never written). setViewerState dedups,
+  // so re-persisting an unchanged scale is a no-op.
+  useEffect(() => {
+    if (doc) viewPos.persist({ scale });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [scale, doc]);
+
+  // "Page X / N" toolbar readout: the page occupying the viewport. The anchor
+  // is a third of the way down the viewport (typical PDF-viewer feel); the page
+  // wraps are always all mounted, so a linear scan over their live rects stays
+  // correct across zoom, resize, and mixed page heights.
+  const updateVisiblePage = useCallback(() => {
+    const el = scrollRef.current;
+    const content = contentRef.current;
+    if (!el || !content) return;
+    const anchor = el.getBoundingClientRect().top + el.clientHeight / 3;
+    const pages = content.children;
+    for (let i = 0; i < pages.length; i++) {
+      if (pages[i].getBoundingClientRect().bottom >= anchor) {
+        setVisiblePage(i + 1);
+        return;
+      }
+    }
+    if (pages.length > 0) setVisiblePage(pages.length);
+  }, []);
+  useEffect(() => {
+    setVisiblePage(1);
+    if (doc) updateVisiblePage();
+  }, [doc, updateVisiblePage]);
+
+  // ── Contents / outline (#pdf-outline) ────────────────────────────────────
+  // Load the PDF's embedded outline (its chapters) when a document loads. Reset
+  // to "not loaded" first so a file switch never shows the prior file's chapters.
+  useEffect(() => {
+    setOutline(null);
+    setHeadings(null);
+    if (!doc) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const nodes = await loadOutline(doc);
+        if (!cancelled) setOutline(nodes);
+      } catch {
+        if (!cancelled) setOutline([]); // treat an unreadable outline as none
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [doc]);
+
+  // Font-size heading fallback: when the PDF ships NO embedded outline, infer
+  // chapters from the text's typography (`detectHeadings`). Run it lazily — only
+  // once the contents pane is opened on an outline-less document — because it
+  // reads every page's text content, which is far heavier than `getOutline`.
+  useEffect(() => {
+    if (!outlineOpen || !doc) return;
+    if (outline == null || outline.length > 0) return; // embedded outline present/pending
+    if (headings != null) return; // already scanned
+    let cancelled = false;
+    void (async () => {
+      const runs: HeadingRun[] = [];
+      // Sequential (not Promise.all): a 500-page document would otherwise fire
+      // 500 concurrent text extractions at the pdf.js worker at once.
+      for (let p = 1; p <= doc.numPages; p++) {
+        if (cancelled) return;
+        try {
+          const page = await doc.getPage(p);
+          const viewport = page.getViewport({ scale: 1 });
+          const content = await page.getTextContent();
+          for (const it of content.items) {
+            if (!("str" in it) || typeof it.str !== "string" || !it.str.trim()) continue;
+            const tx = pdfjs.Util.transform(viewport.transform, it.transform);
+            const size = Math.hypot(tx[2], tx[3]);
+            runs.push({ str: it.str, size, page: p, x: tx[4], y: tx[5] - size });
+          }
+        } catch {
+          /* skip an unreadable page */
+        }
+      }
+      if (!cancelled) setHeadings(detectHeadings(runs));
+    })();
+    return () => { cancelled = true; };
+  }, [outlineOpen, doc, outline, headings]);
+
+  // The chapters actually shown: the embedded outline if the PDF has one, else
+  // the inferred headings. `activeOutline` is null while its source is still
+  // loading/scanning; `outlineDerived` says the fallback is in use.
+  const outlineDerived = outline != null && outline.length === 0;
+  const activeOutline: OutlineNode[] | null =
+    outline == null ? null : outline.length > 0 ? outline : headings;
+  const outlinePlaceholder =
+    activeOutline && activeOutline.length > 0
+      ? null
+      : outline == null
+        ? "Reading outline…"
+        : outlineDerived && headings == null
+          ? "Scanning for headings…"
+          : "No chapters in this document.";
+
+  // Jump the reader to a 1-based FILE page from the contents sidebar. The reader
+  // shows an arrangement, so resolve the file page to whichever sheet is showing
+  // it now (a moved/merged page still lands right; a deleted one is a no-op).
+  const jumpToPage = useCallback((filePage: number) => {
+    const idx = pagesRef.current.findIndex((r) => r.src === SELF && r.page === filePage);
+    if (idx < 0) return;
+    const wrap = contentRef.current?.children[idx] as HTMLElement | undefined;
+    wrap?.scrollIntoView({ block: "start", inline: "nearest" });
+  }, []);
+
+  // The outline entry to highlight: the last chapter (in document order) whose
+  // page is at or before the page currently in view. Recomputed from the flat
+  // outline as the reader scrolls (`visiblePage`) — but keyed off the *file* page
+  // the visible SHEET shows, so it stays right after pages are rearranged.
+  const currentOutlineId = useMemo(() => {
+    if (!activeOutline || activeOutline.length === 0) return null;
+    const sheet = pages[visiblePage - 1];
+    const filePage = sheet && sheet.src === SELF ? sheet.page : visiblePage;
+    let best: string | null = null;
+    for (const { node } of flattenOutline(activeOutline)) {
+      if (node.page != null && node.page <= filePage) best = node.id;
+    }
+    return best;
+  }, [activeOutline, visiblePage, pages]);
+
+  // #viewerpos: persist the scroll position as the reader scrolls (throttled,
+  // trailing-edge). Ignored while a programmatic restore is still settling so we
+  // don't overwrite the saved target with an intermediate frame.
+  const scrollPersistTimer = useRef<number | null>(null);
+  const onScrollPersist = useCallback(() => {
+    const el = scrollRef.current;
+    updateVisiblePage();
+    if (!el || restoreScroll.current) return;
+    reportScrollSync();
+    const top = el.scrollTop;
+    const left = el.scrollLeft;
+    if (scrollPersistTimer.current != null) window.clearTimeout(scrollPersistTimer.current);
+    scrollPersistTimer.current = window.setTimeout(
+      () => viewPos.persist({ scrollTop: top, scrollLeft: left }),
+      200,
+    );
+  }, [viewPos, reportScrollSync, updateVisiblePage]);
+  useEffect(
+    () => () => {
+      if (scrollPersistTimer.current != null) window.clearTimeout(scrollPersistTimer.current);
+    },
+    [],
+  );
+
+  // Ctrl/Cmd+wheel zooms the page stack toward the cursor (a plain wheel keeps
+  // native scrolling). Because the canvases resize asynchronously, we only
+  // compute the cursor-anchored scroll target here and let the ResizeObserver
+  // below apply it once the content has grown/shrunk.
+  const onWheel = useCallback((e: WheelEvent) => {
+    if (!(e.ctrlKey || e.metaKey)) return;
+    e.preventDefault();
+    const el = scrollRef.current;
+    if (!el) return;
+    // A user zoom takes over; abandon any in-flight recompile scroll restore.
+    restoreScroll.current = null;
+    const rect = el.getBoundingClientRect();
+    const cursorX = e.clientX - rect.left;
+    const cursorY = e.clientY - rect.top;
+    setScale((prev) => {
+      const factor = e.deltaY < 0 ? PDF_ZOOM_STEP : 1 / PDF_ZOOM_STEP;
+      const next = clampPdfScale(prev * factor);
+      if (next === prev) return prev;
+      fittedRef.current = false; // manual zoom opts out of resize re-fit
+      const eff = next / prev;
+      pendingScroll.current = {
+        top: (el.scrollTop + cursorY) * eff - cursorY,
+        left: (el.scrollLeft + cursorX) * eff - cursorX,
+      };
+      return next;
+    });
+  }, []);
+
+  // Bind the zoom wheel non-passively so `preventDefault()` above actually
+  // cancels the native scroll — a React `onWheel` is passive, so Ctrl+wheel
+  // would otherwise scroll the page to its limit before the zoom took hold.
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    el.addEventListener("wheel", onWheel, { passive: false });
+    return () => el.removeEventListener("wheel", onWheel);
+  }, [onWheel]);
+
+  // Apply a pending cursor-anchored scroll target once the page content has
+  // resized after a zoom (the observer fires when the canvases repaint).
+  useEffect(() => {
+    const content = contentRef.current;
+    const el = scrollRef.current;
+    if (!content || !el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => {
+      // Cursor-anchored zoom target: apply once, the moment the canvases resize.
+      const target = pendingScroll.current;
+      if (target) {
+        pendingScroll.current = null;
+        el.scrollTop = target.top;
+        el.scrollLeft = target.left;
+      }
+      // Recompile reload: the page stack grows over several frames as canvases
+      // render, so keep re-applying the saved position until it's reached, then
+      // stop. A target the new (shorter) document can't hold is dropped by the
+      // bounded fallback timer in the load effect.
+      const restore = restoreScroll.current;
+      if (restore) {
+        el.scrollTop = restore.top;
+        el.scrollLeft = restore.left;
+        if (el.scrollTop >= restore.top - 1) restoreScroll.current = null;
+      }
+      // A layout-height change (zoom re-render, pages appearing) moves which
+      // page sits under the anchor even without a scroll event.
+      updateVisiblePage();
+    });
+    ro.observe(content);
+    return () => ro.disconnect();
+  }, [doc, updateVisiblePage]);
+
+  return (
+    <div className="file-viewer-pdf-host" onKeyDown={onHostKeyDown}>
+      <div className="file-viewer-pdf-toolbar" role="group" aria-label="PDF zoom controls">
+        {/* Contents (chapters) sits at the far left — it opens the navigation
+            column on the same side, so the button lines up over it. */}
+        <button
+          className={`file-viewer-zoom-btn${outlineOpen ? " active" : ""}`}
+          onClick={() => setOutlineOpen((v) => !v)}
+          disabled={!doc}
+          title="Contents (chapters)"
+          aria-label="Contents"
+          aria-pressed={outlineOpen}
+        >
+          ☰
+        </button>
+        <span className="file-viewer-pdf-toolbar-sep" aria-hidden="true" />
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={() => {
+            fittedRef.current = false;
+            setScale((s) => clampPdfScale(s / PDF_ZOOM_STEP));
+          }}
+          disabled={!doc || scale <= PDF_MIN_SCALE}
+          title="Zoom out"
+          aria-label="Zoom out"
+        >
+          −
+        </button>
+        <span className="file-viewer-zoom-level">{Math.round(scale * 100)}%</span>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={() => {
+            fittedRef.current = false;
+            setScale((s) => clampPdfScale(s * PDF_ZOOM_STEP));
+          }}
+          disabled={!doc || scale >= PDF_MAX_SCALE}
+          title="Zoom in"
+          aria-label="Zoom in"
+        >
+          +
+        </button>
+        <button
+          className="file-viewer-zoom-btn file-viewer-zoom-text"
+          onClick={() => doc && void fitWidth(doc)}
+          disabled={!doc}
+          title="Fit page width"
+        >
+          Fit width
+        </button>
+        {doc && (
+          pageJumpOpen ? (
+            <input
+              ref={pageJumpInputRef}
+              className="file-viewer-pdf-pagejump-input"
+              type="number"
+              min={1}
+              max={pages.length}
+              value={pageJumpValue}
+              aria-label="Go to page"
+              onChange={(e) => setPageJumpValue(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") {
+                  e.preventDefault();
+                  commitPageJump();
+                } else if (e.key === "Escape") {
+                  e.preventDefault();
+                  closePageJump();
+                }
+              }}
+              onBlur={closePageJump}
+            />
+          ) : (
+            <button
+              className="file-viewer-zoom-btn file-viewer-pdf-pagenum"
+              onClick={openPageJump}
+              title="Go to page (Ctrl+G)"
+              aria-label="Go to page"
+            >
+              {visiblePage} / {pages.length}
+            </button>
+          )
+        )}
+        <button
+          className={`file-viewer-zoom-btn${findOpen ? " active" : ""}`}
+          onClick={() => (findOpen ? closeFind() : openFind())}
+          disabled={!doc}
+          title="Find (Ctrl+F)"
+          aria-label="Find"
+          aria-pressed={findOpen}
+        >
+          🔍
+        </button>
+        {/* ── Page arranging (#page-arrange) ────────────────────────────────
+            Edits live in memory until Save, so a stray delete is always one Ctrl+Z
+            away and never touches the file. */}
+        <button
+          className={`file-viewer-zoom-btn${railOpen ? " active" : ""}`}
+          onClick={() => setRailOpen((v) => !v)}
+          disabled={!doc}
+          title="Arrange pages"
+          aria-label="Arrange pages"
+          aria-pressed={railOpen}
+        >
+          ▤
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={() => setPickerOpen(true)}
+          disabled={!doc || !pdfProjectDir}
+          title={
+            pdfProjectDir
+              ? "Insert the pages of another PDF from this project"
+              : "Insert PDF: no project tree to pick from"
+          }
+          aria-label="Insert PDF"
+        >
+          ⊕
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={undo}
+          disabled={past.length === 0}
+          title="Undo (Ctrl+Z)"
+          aria-label="Undo"
+        >
+          ↶
+        </button>
+        <button
+          className="file-viewer-zoom-btn"
+          onClick={redo}
+          disabled={future.length === 0}
+          title="Redo (Ctrl+Shift+Z)"
+          aria-label="Redo"
+        >
+          ↷
+        </button>
+        <button
+          className={`file-viewer-zoom-btn file-viewer-zoom-text${dirty ? " is-dirty" : ""}`}
+          onClick={() => void handleSave()}
+          disabled={!dirty || saving}
+          title={dirty ? "Save the rearranged PDF (Ctrl+S)" : "No page changes to save"}
+        >
+          {saving ? (
+            <span className="file-viewer-save-spinner" aria-hidden="true" />
+          ) : (
+            `Save${dirty ? " •" : ""}`
+          )}
+        </button>
+        <button
+          className={`file-viewer-print file-viewer-pdf-print${printing ? " is-busy" : ""}`}
+          onClick={() => void handlePrint()}
+          disabled={!doc || printing}
+          title={printing ? "Preparing…" : "Print"}
+          aria-label="Print"
+        >
+          {printing ? <span className="file-viewer-save-spinner" aria-hidden="true" /> : "🖨"}
+        </button>
+        {deckEnabled && (
+          <button
+            className="file-viewer-zoom-text"
+            onClick={() => void openAsDeck()}
+            disabled={!doc || makingDeck}
+            title="Open this PDF as a presentation: editable layers on top, and a fullscreen presenter"
+          >
+            {makingDeck ? "…" : "Present"}
+          </button>
+        )}
+        {onOpenExternally && (
+          <button
+            className="file-viewer-open-external file-viewer-pdf-external"
+            onClick={onOpenExternally}
+            title="Open in external app"
+            aria-label="Open in external app"
+          >
+            ↗
+          </button>
+        )}
+      </div>
+      {findOpen && (
+        <div className="file-viewer-find file-viewer-find-pdf" role="search">
+          <div className="file-viewer-find-row">
+            <input
+              ref={findInputRef}
+              className="file-viewer-find-input"
+              type="text"
+              value={query}
+              placeholder="Find in document"
+              aria-label="Find"
+              spellCheck={false}
+              onChange={(e) => setQuery(e.target.value)}
+              onKeyDown={onFindKeyDown}
+            />
+            <span className="file-viewer-find-count" aria-live="polite">
+              {matches.length > 0 ? `${current + 1}/${matches.length}` : query ? "0/0" : ""}
+            </span>
+            <button
+              className={`file-viewer-find-btn${caseSensitive ? " active" : ""}`}
+              onClick={() => setCaseSensitive((v) => !v)}
+              aria-pressed={caseSensitive}
+              title="Match case"
+              aria-label="Match case"
+            >
+              Aa
+            </button>
+            <button
+              className="file-viewer-find-btn"
+              onClick={() => goToMatch(-1)}
+              disabled={matches.length === 0}
+              title="Previous match (Shift+Enter)"
+              aria-label="Previous match"
+            >
+              ↑
+            </button>
+            <button
+              className="file-viewer-find-btn"
+              onClick={() => goToMatch(1)}
+              disabled={matches.length === 0}
+              title="Next match (Enter)"
+              aria-label="Next match"
+            >
+              ↓
+            </button>
+            <button
+              className="file-viewer-find-btn"
+              onClick={closeFind}
+              title="Close (Esc)"
+              aria-label="Close find"
+            >
+              ✕
+            </button>
+          </div>
+        </div>
+      )}
+      {staleOnDisk && (
+        // The file changed underneath our unsaved edits. Reloading would throw them
+        // away and saving would overwrite the newer file, so neither happens on its
+        // own — the reader picks.
+        <div className="file-viewer-banner" role="alert">
+          <span>This PDF changed on disk, and you have unsaved page changes.</span>
+          <button
+            onClick={() => {
+              setStaleOnDisk(false);
+              setDiskVersion((v) => v + 1);
+            }}
+          >
+            Reload &amp; discard my changes
+          </button>
+          <button onClick={() => setStaleOnDisk(false)}>Keep my changes</button>
+        </div>
+      )}
+      {editError && (
+        <div className="file-viewer-banner is-error" role="alert">
+          <span>{editError}</span>
+          <button onClick={() => setEditError(null)}>Dismiss</button>
+        </div>
+      )}
+      <div className="file-viewer-pdf-scroll-wrap">
+        {outlineOpen && doc && (
+          <OutlinePane
+            doc={doc}
+            nodes={activeOutline}
+            placeholder={outlinePlaceholder}
+            derived={outlineDerived}
+            currentId={currentOutlineId}
+            onJump={jumpToPage}
+          />
+        )}
+        {railOpen && doc && (
+          // The page rail: the SAME <PageStrip> the print preview uses, stood on its
+          // side. Drag to reorder, shift-click for a range, right-click for the rest.
+          <div className="file-viewer-pdf-rail">
+            <PageStrip
+              pages={pages}
+              onChange={applyEdit}
+              orientation="column"
+              onSelectionChange={setSelection}
+              // Drag pages out of this rail and into another PDF viewer's — in this
+              // window or in a detached one. Copy by default; Shift moves them.
+              stripId={stripId}
+              onExport={exportPages}
+              onImport={importPages}
+              onMovedOut={dropMovedPages}
+              renderThumb={(ref) => (
+                <PdfThumb doc={sources.get(ref.src)?.doc} page={ref.page} rot={ref.rot} />
+              )}
+              badgeFor={(_ref, i) => String(i + 1)}
+              titleFor={(ref) =>
+                (ref.src === SELF
+                  ? `Page ${ref.page}`
+                  : `Page ${ref.page} of a merged document`) +
+                (ref.rot ? ` · turned ${ref.rot}°` : "")
+              }
+            />
+          </div>
+        )}
+        <div
+          className="file-viewer-pdf-scroll"
+          ref={scrollRef}
+          tabIndex={0}
+          onScroll={onScrollPersist}
+        >
+          {error != null ? (
+            <div className="file-viewer-error">{error}</div>
+          ) : !doc ? (
+            <div className="file-viewer-loading">Loading…</div>
+          ) : (
+            <div className="file-viewer-pdf-pages" ref={contentRef}>
+              {/* The reader renders the ARRANGEMENT, sheet by sheet — each pulled
+                  from its own source document — so an edit shows up immediately with
+                  nothing re-parsed. An unedited PDF is the identity arrangement over
+                  its own pages, i.e. exactly what it always was. Keyed by entry id so
+                  a reorder MOVES the canvas rather than repainting it. */}
+              {pages.map((ref, i) => {
+                const srcDoc = sources.get(ref.src)?.doc;
+                if (!srcDoc) return null;
+                return (
+                  <PdfPageCanvas
+                    key={ref.id}
+                    doc={srcDoc}
+                    pageNumber={ref.page}
+                    rot={ref.rot}
+                    scale={scale}
+                    cssSize={pageSizes?.[i]}
+                    // SyncTeX only means anything for pages of the file itself: a
+                    // page merged in from another PDF has no line in this source.
+                    onSyncClick={syncable && ref.src === SELF ? onSyncClick : undefined}
+                    syncArmed={syncArmed}
+                    highlight={highlight && i === syncSheetIndex ? highlight : null}
+                    searchMatches={searchByPage.get(i + 1)}
+                    searchScrollNonce={currentPage === i + 1 ? searchScrollNonce : 0}
+                  />
+                );
+              })}
+            </div>
+          )}
+        </div>
+        {findOpen && markerTops.length > 0 && (
+          <div className="file-viewer-pdf-search-rail" aria-hidden="true">
+            {markerTops.map((m, i) => (
+              <div
+                key={i}
+                className={`file-viewer-pdf-search-tick${m.current ? " current" : ""}`}
+                style={{ top: m.top }}
+              />
+            ))}
+          </div>
+        )}
+      </div>
+      {pickerOpen && (
+        // Deliberately the project-scoped picker rather than an OS file dialog: the
+        // backend confines every read to the scope's tree, so a path from outside it
+        // would be refused anyway — better to only offer what can actually be read.
+        <ContextFilePicker
+          projectDir={pdfProjectDir}
+          attached={[]}
+          onPick={(rel) => {
+            const abs = `${pdfProjectDir}/${rel}`;
+            if (!/\.pdf$/i.test(abs)) {
+              setEditError(`${basename(abs)} is not a PDF.`);
+              return;
+            }
+            setPickerOpen(false);
+            void mergePdf(abs);
+          }}
+          onClose={() => setPickerOpen(false)}
+        />
+      )}
+    </div>
+  );
+}
+
+export function PdfView({
+  path,
+  onOpenExternally,
+  tabKey,
+  groupId,
+}: {
+  path: string;
+  onOpenExternally: () => void;
+  tabKey?: string;
+  groupId?: string | null;
+}) {
+  // No ViewerHeader: the tab already shows the file name, so a filename row would
+  // be redundant. The "Open externally" action lives in the PdfCanvas toolbar.
+  return (
+    <div className="file-viewer">
+      <div className="file-viewer-body">
+        <PdfCanvas path={path} onOpenExternally={onOpenExternally} tabKey={tabKey} groupId={groupId} />
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/embed/pdf/outline.ts b/src/components/embed/pdf/outline.ts
new file mode 100644
index 0000000..0ea2c73
--- /dev/null
+++ b/src/components/embed/pdf/outline.ts
@@ -0,0 +1,240 @@
+/**
+ * The PDF's embedded outline (its bookmarks / table of contents) resolved to a
+ * jump-ready tree — the "chapters" the contents sidebar renders.
+ *
+ * A PDF author ships the outline as a tree of items, each pointing at a
+ * *destination* rather than a plain page number: a named string, or an explicit
+ * array whose first element is a page reference. `loadOutline` walks that tree
+ * and resolves every destination to a 1-based **file** page (the same numbering
+ * `PageRef.page` uses), so the viewer can map it to whichever sheet is currently
+ * showing that page — even after pages are reordered, deleted or merged.
+ *
+ * Pure and best-effort: an item whose destination can't be resolved keeps a
+ * `page` of `null` (rendered but not clickable) rather than failing the load, and
+ * a document with no outline simply yields an empty list.
+ */
+import type { PDFDocumentProxy } from "pdfjs-dist";
+
+/** One resolved outline entry (a chapter/section/subsection). */
+export interface OutlineNode {
+  /** Stable id for React keys and collapse state (its path through the tree). */
+  id: string;
+  title: string;
+  /** 1-based file page this entry jumps to, or null if it couldn't resolve. */
+  page: number | null;
+  children: OutlineNode[];
+}
+
+/** The raw shape pdf.js hands back from `getOutline()` (the fields we use). */
+interface RawOutlineItem {
+  title: string;
+  dest: string | unknown[] | null;
+  items?: RawOutlineItem[];
+}
+
+/**
+ * Resolve one outline destination to a 1-based page number.
+ *
+ * A named destination (a string) is looked up first; an explicit array carries
+ * the page reference in slot 0 — usually a `{num, gen}` ref (resolved via
+ * `getPageIndex`), occasionally already a 0-based page index.
+ */
+async function destToPage(
+  doc: PDFDocumentProxy,
+  dest: string | unknown[] | null,
+): Promise<number | null> {
+  let explicit: unknown = dest;
+  if (typeof dest === "string") {
+    explicit = await doc.getDestination(dest);
+  }
+  if (!Array.isArray(explicit) || explicit.length === 0) return null;
+  const ref = explicit[0];
+  if (typeof ref === "number") return ref + 1; // already a 0-based page index
+  try {
+    const idx = await doc.getPageIndex(ref as Parameters<PDFDocumentProxy["getPageIndex"]>[0]);
+    return idx + 1;
+  } catch {
+    return null;
+  }
+}
+
+/** Resolve one raw item and its descendants into an {@link OutlineNode}. */
+async function resolveItem(
+  doc: PDFDocumentProxy,
+  raw: RawOutlineItem,
+  id: string,
+): Promise<OutlineNode> {
+  const [page, children] = await Promise.all([
+    destToPage(doc, raw.dest ?? null),
+    resolveItems(doc, raw.items ?? [], id),
+  ]);
+  return { id, title: raw.title || "Untitled", page, children };
+}
+
+/** Resolve a sibling list, giving each child a path-derived id. */
+async function resolveItems(
+  doc: PDFDocumentProxy,
+  items: RawOutlineItem[],
+  parentId: string,
+): Promise<OutlineNode[]> {
+  return Promise.all(
+    items.map((it, i) => resolveItem(doc, it, parentId ? `${parentId}.${i}` : String(i))),
+  );
+}
+
+/**
+ * Load the document's outline as a resolved, jump-ready tree. Returns `[]` when
+ * the PDF carries no outline (many scanned or exported PDFs don't).
+ */
+export async function loadOutline(doc: PDFDocumentProxy): Promise<OutlineNode[]> {
+  const raw = (await doc.getOutline()) as RawOutlineItem[] | null;
+  if (!raw || raw.length === 0) return [];
+  return resolveItems(doc, raw, "");
+}
+
+/**
+ * One positioned text run pulled from a page, for the heading fallback. `size` is
+ * the run's font size (em) in big points; `y` is its top in a top-left viewport,
+ * so smaller `y` is higher on the page (reading order). Page is 1-based.
+ */
+export interface HeadingRun {
+  str: string;
+  size: number;
+  page: number;
+  x: number;
+  y: number;
+}
+
+/** Round a font size to the nearest 0.5 so float jitter doesn't split a size. */
+const roundSize = (n: number) => Math.round(n * 2) / 2;
+
+/**
+ * Best-effort "chapters" for a PDF that ships **no** embedded outline: infer a
+ * heading tree from the text's own typography.
+ *
+ * The idea is that a heading is set distinctly larger than body text. So: find
+ * the **body** size (the size covering the most characters), group runs into
+ * lines, keep the lines set clearly larger than body, drop **running headers**
+ * (the same text repeated across many pages), and nest what's left by size
+ * (largest size = top level). It is a heuristic, not the author's intent — so it
+ * is only ever used when {@link loadOutline} came back empty, and the sidebar
+ * labels it as derived.
+ */
+export function detectHeadings(runs: HeadingRun[]): OutlineNode[] {
+  const clean = runs.filter((r) => r.str && r.str.trim().length > 0);
+  if (clean.length === 0) return [];
+
+  // Body size = the size covering the most characters (a char-weighted mode).
+  const charBySize = new Map<number, number>();
+  for (const r of clean) {
+    const s = roundSize(r.size);
+    charBySize.set(s, (charBySize.get(s) ?? 0) + r.str.trim().length);
+  }
+  let body = 0;
+  let bodyChars = -1;
+  for (const [s, c] of charBySize) {
+    if (c > bodyChars) {
+      bodyChars = c;
+      body = s;
+    }
+  }
+  if (body <= 0) return [];
+
+  // Group runs into lines (same page, near-equal baseline) in reading order.
+  const sorted = [...clean].sort((a, b) => a.page - b.page || a.y - b.y || a.x - b.x);
+  interface Line {
+    page: number;
+    y: number;
+    text: string;
+    size: number;
+  }
+  const lines: Line[] = [];
+  let cur: { page: number; y: number; parts: HeadingRun[] } | null = null;
+  const flush = () => {
+    if (!cur) return;
+    const parts = [...cur.parts].sort((a, b) => a.x - b.x);
+    const text = parts
+      .map((p) => p.str)
+      .join("")
+      .replace(/\s+/g, " ")
+      .trim();
+    // Dominant size on the line = the size covering the most of its characters.
+    const bySize = new Map<number, number>();
+    for (const p of parts) {
+      const s = roundSize(p.size);
+      bySize.set(s, (bySize.get(s) ?? 0) + p.str.trim().length);
+    }
+    let size = body;
+    let best = -1;
+    for (const [s, c] of bySize) {
+      if (c > best) {
+        best = c;
+        size = s;
+      }
+    }
+    if (text) lines.push({ page: cur.page, y: cur.y, text, size });
+    cur = null;
+  };
+  for (const r of sorted) {
+    const tol = Math.max(2, roundSize(r.size) * 0.4);
+    if (cur && r.page === cur.page && Math.abs(r.y - cur.y) <= tol) {
+      cur.parts.push(r);
+    } else {
+      flush();
+      cur = { page: r.page, y: r.y, parts: [r] };
+    }
+  }
+  flush();
+
+  // Candidates: distinctly larger than body, real letters, not a whole paragraph.
+  const threshold = body * 1.2;
+  const candidates = lines.filter(
+    (l) => l.size >= threshold && l.text.length >= 2 && l.text.length <= 160 && /\p{L}/u.test(l.text),
+  );
+  if (candidates.length === 0) return [];
+
+  // Drop running headers/footers: the same heading text on more than 3 pages is
+  // page furniture (a chapter title repeated in the header), not a chapter mark.
+  const norm = (t: string) => t.toLowerCase().replace(/\s+/g, " ").trim();
+  const pagesByText = new Map<string, Set<number>>();
+  for (const l of candidates) {
+    const k = norm(l.text);
+    let set = pagesByText.get(k);
+    if (!set) pagesByText.set(k, (set = new Set()));
+    set.add(l.page);
+  }
+  const headings = candidates.filter((l) => (pagesByText.get(norm(l.text))?.size ?? 0) <= 3);
+  if (headings.length === 0) return [];
+
+  // Level by size: the largest distinct heading size is the top level.
+  const sizes = [...new Set(headings.map((h) => h.size))].sort((a, b) => b - a);
+  const levelOf = (s: number) => sizes.indexOf(s);
+
+  // Nest by level with a stack, in document order.
+  const roots: OutlineNode[] = [];
+  const stack: { node: OutlineNode; level: number }[] = [];
+  let seq = 0;
+  for (const h of headings) {
+    const node: OutlineNode = { id: `h${seq++}`, title: h.text, page: h.page, children: [] };
+    const level = levelOf(h.size);
+    while (stack.length && stack[stack.length - 1].level >= level) stack.pop();
+    if (stack.length) stack[stack.length - 1].node.children.push(node);
+    else roots.push(node);
+    stack.push({ node, level });
+  }
+  return roots;
+}
+
+/**
+ * Flatten a resolved outline into visit order, tagging each node with its depth
+ * — used to decide which entry is "current" (the deepest one whose page is at or
+ * before the page in view). Nodes with no resolved page are skipped.
+ */
+export function flattenOutline(nodes: OutlineNode[], depth = 0): { node: OutlineNode; depth: number }[] {
+  const out: { node: OutlineNode; depth: number }[] = [];
+  for (const node of nodes) {
+    out.push({ node, depth });
+    if (node.children.length) out.push(...flattenOutline(node.children, depth + 1));
+  }
+  return out;
+}
diff --git a/src/components/embed/pdf/pdfDoc.ts b/src/components/embed/pdf/pdfDoc.ts
new file mode 100644
index 0000000..1ba9416
--- /dev/null
+++ b/src/components/embed/pdf/pdfDoc.ts
@@ -0,0 +1,98 @@
+/**
+ * The PDF viewer's document plumbing: the open source documents an arrangement
+ * draws from, and the one place a PDF is actually *written*.
+ *
+ * The viewer never rebuilds the file while you edit it. Reordering, deleting,
+ * turning and merging pages only rewrite the `PageList` (see `lib/viewers/pageModel`),
+ * and both the reader and the rail render straight off that list by resolving each
+ * entry's source here — so an edit is an array operation, not a re-parse. pdf-lib is
+ * pulled in exactly once, on save, by {@link buildPdf}.
+ */
+import { PDFDocument, degrees } from "pdf-lib";
+import * as pdfjs from "pdfjs-dist";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import type { PageList, SourceId } from "../../../lib/viewers/pageModel";
+
+/**
+ * One document an arrangement can draw pages from: the file being viewed (`SELF`)
+ * or a PDF merged into it.
+ *
+ * `bytes` is a PRISTINE copy. pdf.js *detaches* the ArrayBuffer it is handed, so the
+ * bytes given to `getDocument` are unusable afterwards — and pdf-lib needs them again
+ * at save time. Every loader here therefore keeps its own copy.
+ */
+export interface PdfSource {
+  bytes: Uint8Array;
+  doc: PDFDocumentProxy;
+}
+
+export type PdfSources = Map<SourceId, PdfSource>;
+
+/** Open a PDF for rendering, keeping the bytes intact for a later save. */
+export async function openSource(bytes: Uint8Array): Promise<PdfSource> {
+  // One copy for pdf.js to detach, one to keep.
+  const pristine = bytes.slice();
+  const doc = await pdfjs.getDocument({ data: bytes }).promise;
+  return { bytes: pristine, doc };
+}
+
+/** Mint a source id for a merged-in document. */
+let nextSourceId = 0;
+export function newSourceId(): SourceId {
+  nextSourceId += 1;
+  return `src${nextSourceId}`;
+}
+
+/** The pdf.js document an entry renders from, if it is loaded. */
+export function docFor(sources: PdfSources, src: SourceId): PDFDocumentProxy | undefined {
+  return sources.get(src)?.doc;
+}
+
+/**
+ * Build the arrangement into a real PDF.
+ *
+ * Pages are copied out of each source with `copyPages`, which brings the page's
+ * content and resources across. A DUPLICATED entry gets its own copy — the same page
+ * object cannot be added to a document twice — which is why the copy is driven by the
+ * entry list rather than by a set of page numbers.
+ *
+ * `rot` is the turn the *viewer* applied, on top of whatever the page already carried
+ * in its `/Rotate`, so the two are added rather than the latter overwritten.
+ *
+ * Throws when the arrangement is empty (a PDF must have at least one page) or when a
+ * source it references is not loaded.
+ */
+export async function buildPdf(list: PageList, sources: PdfSources): Promise<Uint8Array> {
+  if (list.length === 0) {
+    throw new Error("A PDF must have at least one page.");
+  }
+
+  const out = await PDFDocument.create();
+
+  // Copy from each source in ONE `copyPages` call, so shared resources (fonts,
+  // images) are brought over once per source rather than once per page.
+  const copies = new Map<string, Awaited<ReturnType<PDFDocument["copyPages"]>>[number]>();
+  for (const src of new Set(list.map((r) => r.src))) {
+    const bytes = sources.get(src)?.bytes;
+    if (!bytes) throw new Error(`The source document for some pages is no longer open.`);
+    const from = await PDFDocument.load(bytes, { ignoreEncryption: true });
+    const refs = list.filter((r) => r.src === src);
+    const copied = await out.copyPages(
+      from,
+      refs.map((r) => r.page - 1),
+    );
+    refs.forEach((r, i) => copies.set(r.id, copied[i]));
+  }
+
+  for (const ref of list) {
+    const page = copies.get(ref.id);
+    if (!page) continue;
+    if (ref.rot) {
+      const base = page.getRotation().angle;
+      page.setRotation(degrees((((base + ref.rot) % 360) + 360) % 360));
+    }
+    out.addPage(page);
+  }
+
+  return out.save();
+}
diff --git a/src/components/files/DownloadsSection.tsx b/src/components/files/DownloadsSection.tsx
new file mode 100644
index 0000000..c2acbce
Binary files /dev/null and b/src/components/files/DownloadsSection.tsx differ
diff --git a/src/components/files/FileBrowser.tsx b/src/components/files/FileBrowser.tsx
index 6fb1a46..7f162b2 100644
--- a/src/components/files/FileBrowser.tsx
+++ b/src/components/files/FileBrowser.tsx
@@ -1,12 +1,15 @@
 import { useEffect, useMemo, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
+import { Toggle } from "../common/Toggle";
 import { useWindowsStore } from "../../stores/windows";
 import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
 import { Dropdown } from "../common/Dropdown";
 import {
   type FileEntry,
   type SortKey,
   STANDARD_PROJECT_FILES,
+  disabledViewers,
   fileIcon,
   folderIcon,
   fmtModified,
@@ -16,6 +19,9 @@ import {
   relFromAbs,
   visibleEntries,
 } from "../../lib/viewers/fileUtils";
+import { basename, dirname, isAbsolute } from "../../lib/paths";
+import { closeTabsForDeletedPath, retargetTabsForRenamedPath } from "./fileTabSync";
+import { openFileEntry } from "./openFileEntry";
 
 type ProjectJson = Record<string, unknown>;
 
@@ -46,6 +52,8 @@ interface Props {
 export function FileBrowser({ projectDir, projectId, active }: Props) {
   const { openFile } = useWindowsStore();
   const projects = useProjectsStore((s) => s.projects);
+  const viewerPrefs = useSettingsStore((s) => s.settings?.viewer_prefs);
+  const disabledViewerSet = useMemo(() => disabledViewers(viewerPrefs), [viewerPrefs]);
   const [relPath, setRelPath] = useState("");
   const [entries, setEntries] = useState<FileEntry[]>([]);
   const [selected, setSelected] = useState<Set<string>>(new Set());
@@ -162,14 +170,23 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
     load(next, { replace: true });
   }
 
-  function activate(entry: FileEntry) {
+  // Open on double-click. A folder navigates in; a file with a native in-app
+  // viewer opens in the project's focused subwindow, while a type with no native
+  // viewer — or a Shift+double-click — opens in the OS default app. The single
+  // open-a-file policy shared with the FileTree (see `openFileEntry`).
+  function activate(entry: FileEntry, ev?: React.MouseEvent) {
     if (entry.is_dir) {
       load(joinRel(relPath, entry.name));
-    } else {
-      openFile(entry.path, undefined, projectId, "middle_file_browser").catch((e) =>
-        setError(String(e)),
-      );
+      return;
     }
+    openFileEntry({
+      entry,
+      projectDir,
+      projectId,
+      origin: "middle_file_browser",
+      external: ev?.shiftKey ?? false,
+      disabled: disabledViewerSet,
+    });
   }
 
   function toggleSelected(entry: FileEntry, additive: boolean) {
@@ -217,6 +234,11 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
         oldRel: relFromAbs(projectDir, target.path),
         newName: nextName.trim(),
       });
+      // Retarget any open viewer tab of this file (main + detached) to the new
+      // path — swap the basename on the entry's own absolute path (== embedPath).
+      const oldAbs = target.path;
+      const newAbs = `${oldAbs.slice(0, oldAbs.lastIndexOf("/") + 1)}${nextName.trim()}`;
+      retargetTabsForRenamedPath(oldAbs, newAbs);
       await load(relPath, { replace: true });
     } catch (e) {
       setError(String(e));
@@ -234,6 +256,8 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
           projectDir,
           relPath: relFromAbs(projectDir, target.path),
         });
+        // Close any open viewer tab for the deleted file/folder (main + detached).
+        closeTabsForDeletedPath(target.path);
       }
       await load(relPath, { replace: true });
     } catch (e) {
@@ -250,7 +274,7 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
   function revealSelected() {
     const target = firstSelectedEntry();
     if (!target) return;
-    const path = target.is_dir ? target.path : target.path.slice(0, target.path.lastIndexOf("/"));
+    const path = target.is_dir ? target.path : dirname(target.path);
     openFile(path, undefined, projectId, "middle_file_browser").catch((e) =>
       setError(String(e)),
     );
@@ -294,8 +318,7 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
   function submitPath(event: React.FormEvent) {
     event.preventDefault();
     const raw = pathEntry.trim();
-    const root = projectDir.replace(/\/+$/, "");
-    const nextRel = raw.startsWith("/") ? relFromAbs(root, raw) : raw.replace(/^\/+/, "");
+    const nextRel = isAbsolute(raw) ? relFromAbs(projectDir, raw) : raw.replace(/^\/+/, "");
     load(nextRel);
   }
 
@@ -305,15 +328,28 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
 
   const canMutate = selected.size > 0;
 
+  // Delete key removes the current selection — the keyboard twin of the Delete
+  // button / context-menu action. Ignored while a text field (path/search/rename
+  // prompt) has focus so it never eats a keystroke there.
+  function handleKeyDown(ev: React.KeyboardEvent) {
+    if (ev.key !== "Delete" || selected.size === 0) return;
+    const target = ev.target as HTMLElement | null;
+    if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable)) {
+      return;
+    }
+    ev.preventDefault();
+    void deleteSelected();
+  }
+
   return (
-    <section className={`file-browser ${active ? "active" : ""}`}>
+    <section className={`file-browser ${active ? "active" : ""}`} tabIndex={0} onKeyDown={handleKeyDown}>
       <div className="file-browser-toolbar">
         <button onClick={goBack} disabled={history.length === 0} title="Back">‹</button>
         <button onClick={goForward} disabled={future.length === 0} title="Forward">›</button>
         <button onClick={() => load(parentRel(relPath))} disabled={!relPath} title="Up">↑</button>
         <button onClick={() => load(relPath, { replace: true })} title="Refresh">↻</button>
         <form className="file-browser-path" onSubmit={submitPath}>
-          <span>{projectDir.split("/").pop() || projectDir}</span>
+          <span>{basename(projectDir) || projectDir}</span>
           <input value={pathEntry} onChange={(e) => setPathEntry(e.target.value)} placeholder="/" />
         </form>
         <input
@@ -333,10 +369,10 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
         <button onClick={deleteSelected} disabled={!canMutate}>Delete</button>
         <button onClick={copySelectedPaths} disabled={!canMutate}>Copy Path</button>
         <button onClick={revealSelected} disabled={!canMutate}>Reveal</button>
-        <label><input type="checkbox" checked={showHidden} onChange={(e) => setShowHidden(e.target.checked)} /> Hidden</label>
-        <label><input type="checkbox" checked={showStandardFiles} onChange={(e) => setShowStandardFiles(e.target.checked)} /> Scaffold</label>
-        <label><input type="checkbox" checked={separateScaffold} onChange={(e) => setSeparateScaffold(e.target.checked)} /> Separate scaffold</label>
-        <label><input type="checkbox" checked={showUserHidden} onChange={(e) => setShowUserHidden(e.target.checked)} /> User hidden</label>
+        <label><Toggle size="sm" checked={showHidden} onChange={(e) => setShowHidden(e.target.checked)} /> Hidden</label>
+        <label><Toggle size="sm" checked={showStandardFiles} onChange={(e) => setShowStandardFiles(e.target.checked)} /> Scaffold</label>
+        <label><Toggle size="sm" checked={separateScaffold} onChange={(e) => setSeparateScaffold(e.target.checked)} /> Separate scaffold</label>
+        <label><Toggle size="sm" checked={showUserHidden} onChange={(e) => setShowUserHidden(e.target.checked)} /> User hidden</label>
         <Dropdown
           title="Sort by"
           value={sortKey}
@@ -373,7 +409,7 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
                   key={entry.path}
                   className={`file-browser-row${selected.has(entry.path) ? " selected" : ""}${isScaffold ? " scaffold" : ""}`}
                   onClick={(e) => toggleSelected(entry, e.ctrlKey || e.metaKey)}
-                  onDoubleClick={() => activate(entry)}
+                  onDoubleClick={(e) => activate(entry, e)}
                   onContextMenu={(e) => showEntryContextMenu(e, entry)}
                 >
                   <span><b>{entry.is_dir ? folderIcon() : fileIcon(entry.extension)}</b>{entry.name}</span>
@@ -390,7 +426,7 @@ export function FileBrowser({ projectDir, projectId, active }: Props) {
                   key={entry.path}
                   className={`file-browser-tile${selected.has(entry.path) ? " selected" : ""}${isScaffold ? " scaffold" : ""}`}
                   onClick={(e) => toggleSelected(entry, e.ctrlKey || e.metaKey)}
-                  onDoubleClick={() => activate(entry)}
+                  onDoubleClick={(e) => activate(entry, e)}
                   onContextMenu={(e) => showEntryContextMenu(e, entry)}
                 >
                   <span>{entry.is_dir ? folderIcon() : fileIcon(entry.extension)}</span>
diff --git a/src/components/files/FileTree.tsx b/src/components/files/FileTree.tsx
index 1d47347..5b501a4 100644
--- a/src/components/files/FileTree.tsx
+++ b/src/components/files/FileTree.tsx
@@ -1,22 +1,77 @@
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
+import { Toggle } from "../common/Toggle";
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
-import { useWindowsStore } from "../../stores/windows";
+import { startDrag } from "@crabnebula/tauri-plugin-drag";
 import { useTabsStore } from "../../stores/tabs";
-import { useDragStore, type EmbedCap } from "../../stores/drag";
-import { commitFileDrop } from "../tabs/commitFileDrop";
+import { useDragStore, type EmbedCap, type FileDragItem } from "../../stores/drag";
+import { commitFileDrop, fileDropGoesToNewWindow } from "../tabs/commitFileDrop";
+import { startDetachedDropSession } from "../tabs/detachedDropTargets";
+import { FileDropContext } from "./fileDropContext";
+import { openFileEntry } from "./openFileEntry";
+import { closeTabsForDeletedPath, retargetTabsForRenamedPath } from "./fileTabSync";
+import {
+  startCursorPoll,
+  desktopCursor,
+  snapshotFrame,
+  physToClient,
+  type PhysPoint,
+  type WindowFrame,
+} from "../../lib/coords";
+import { bindDragRelease, dragPlatform, PLATFORM } from "../../lib/dragPlatform";
 import { useSettingsStore } from "../../stores/settings";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useSyncStore, isPathExcluded, type SyncFileState } from "../../stores/sync";
 import { useActivityStore } from "../../stores/activity";
 import { useFileClipboardStore } from "../../stores/fileClipboard";
-import { type FileEntry, type InternalViewer, type SortKey, fileIcon, folderIcon, fmtSize, fmtModified, relFromAbs, visibleEntries, hiddenEntries, internalViewerFor, fileEntriesEqual, stringMapsEqual, STANDARD_PROJECT_FILES } from "../../lib/viewers/fileUtils";
+import { type FileEntry, type InternalViewer, type SortKey, fileIcon, folderIcon, fmtSize, fmtModified, visibleEntries, internalViewerFor, disabledViewers, fileEntriesEqual, stringMapsEqual, nextSelection, STANDARD_PROJECT_FILES } from "../../lib/viewers/fileUtils";
 import { type TexCapability, type TexCompileResult, getTexCapability, lastLogLine } from "../../lib/viewers/tex";
+import { basename, dirname, relativePathWithin, resolvePath } from "../../lib/paths";
+import { resolveLocalMirror, resolveProjectDirectory } from "../../types";
+import { DirSizeUnavailable, guardedDirSize, isHostTimeout } from "../../lib/dirSizeGuard";
+import { isPythonPath, isPythonMainScript } from "../../lib/viewers/python";
+import { runPythonFile, runCwd, placeForFocused } from "../../lib/pythonRun";
+import {
+  shellRunnerFor,
+  shellScriptRunPlan,
+  type ScriptShell,
+} from "../../lib/shellScriptRun";
+import { guardLoginNodeRun } from "../../lib/hpcGuard";
+import { projectIsOnHpc } from "../../lib/hpcHost";
+import { useRunHostPrefStore } from "../../stores/runHostPref";
+import { readFileText } from "../embed/fileAccess";
 import { SetDefaultAppDialog } from "./SetDefaultAppDialog";
+import { normalizeScanPath } from "./ProjectFilesSettings";
+import { FileTreeSearch } from "./FileTreeSearch";
+import { useClampToViewport } from "../../hooks/useClampToViewport";
+import { UntestedTag } from "../common/UntestedTag";
 
-// Persist whether the collapsed "hidden" files section is expanded, so the
+// Persist whether the collapsed "gitignored" files section is expanded, so the
 // choice survives right-panel hide/show and remounts (FileTree remounts each
 // time the panel reopens). Mirrors GitHistory's localStorage view pref.
-const HIDDEN_EXPANDED_KEY = "eldrun.fileTree.hiddenExpanded";
+const GITIGNORED_EXPANDED_KEY = "eldrun.fileTree.gitignoredExpanded";
+
+// How many rows the tree renders at once, and how many more each click of the
+// "show more" footer adds. The rows are not virtualized, so this is the bound on
+// how much DOM one listing can build — see `rowCap` for why an unbounded listing
+// is what makes a big folder freeze the window rather than merely load slowly.
+// A page still overfills the tallest panel, so the cap is invisible in every
+// ordinary folder and only engages where it is the difference between usable
+// and not.
+const ROW_CAP_STEP = 100;
+
+// A stable empty-object fallback for the `python_run_args` selector below — a
+// fresh `{}` literal on every render would change the snapshot's reference
+// identity each time, which `useSyncExternalStore` (what the store hook is
+// built on) reads as "changed" and re-renders forever.
+const EMPTY_PY_ARGS: Record<string, string> = {};
+
+/// How long the pointer must rest on a row before its tooltip opens. Long enough
+/// that sweeping the tree never opens (or measures) anything — see
+/// `handleEntryMouseEnter` for why entry-triggered tooltips were expensive.
+const TOOLTIP_DWELL_MS = 400;
 
 function sizeCategory(bytes: number): string {
   if (bytes < 10 * 1024) return "size-small";
@@ -25,28 +80,72 @@ function sizeCategory(bytes: number): string {
   return "size-huge";
 }
 
+/** Hover title for a non-ignored size figure: the total + ignored split when
+ *  there's ignored content to split out, else the plain fallback wording. */
+function sizeTitle(shown: number, ignored: number, fallback: string): string {
+  return ignored > 0 ? `${fmtSize(shown + ignored)} total — ${fmtSize(ignored)} git-ignored` : fallback;
+}
+
 interface Props {
   projectDir: string;
   projectId: string | null;
   /** Path to the project's project.json; enables the project-scoped default app. */
   localFile?: string | null;
-  showHidden?: boolean;
   sortKey?: SortKey;
   descending?: boolean;
   hiddenEndings?: string[];
   hiddenPaths?: string[];
   shownPaths?: string[];
+  /** Folders excluded from every recursive scan (`scan_excluded_paths` in
+   *  project.json). They still LIST — only their size walk is skipped — so the
+   *  exclusion stays visible and reversible on the row it applies to. */
+  scanExcluded?: string[];
+  /** When given, folder rows offer "Exclude from scans" / "Include in scans". */
+  onToggleScanExcluded?: (relPath: string, excluded: boolean) => void;
   initialRelPath?: string | null;
   onRelPathChange?: (relPath: string) => void;
+  /** When given, the context menu offers "Open in a new tab" — on a folder, and
+   *  on the background for the folder currently browsed. The host decides what
+   *  that tab is (a Files (Project) tab) and which scope it lands in; a tree with
+   *  no way to own a tab (a box root, a detached window) simply omits this. */
+  onOpenFolderTab?: (relPath: string) => void;
+  /** SSH-sync Phase 1: which side of a remote project this tree shows. `"remote"`
+   *  = the host source with the sync overlay + select-to-sync affordance; `"local"`
+   *  = the local mirror (browsed/watched as a plain local tree). Absent = a normal
+   *  local/remote project tree (no sync UI). */
+  syncSource?: "remote" | "local";
+  /** For a remote project's LOCAL-mirror view: the project's remote state dir
+   *  (the one `list_dir` resolves to the host over SFTP — i.e. the pane's own
+   *  `projectDir`, the parent of `mirror/`). Lets the mirror tree cheaply readdir
+   *  the host for the browsed folder and flag which local-only child folders don't
+   *  exist on the remote yet. Absent for a local project / the remote-source view. */
+  remoteProbeDir?: string | null;
 }
 
 type GitStatusMap = Record<string, string>;
-type EntryContextMenu = { x: number; y: number; entry: FileEntry | null } | null;
-type DeleteConfirm = { entry: FileEntry; relPath: string } | null;
+/** `rowRect` is the right-clicked row's bounding box, captured at open time, so
+ *  a glowing frame can float onto it and show which entry the menu targets. */
+type EntryContextMenu = {
+  x: number;
+  y: number;
+  entry: FileEntry | null;
+  rowRect: { left: number; top: number; width: number; height: number } | null;
+} | null;
+type DeleteConfirm = { entries: FileEntry[] } | null;
 /** Open paste-rename window: `kind` is whether the source is the in-app file
  *  clipboard or a system-clipboard image (screenshot); `name` is the name being
  *  chosen for the pasted result in the current folder. */
 type PastePrompt = { kind: "file" | "image"; name: string; error: string | null };
+/** A folder whose auto-sync toggle would pull enough from the host to be worth
+ *  confirming first (`AUTO_SYNC_WARN_*`), with what it priced. */
+type AutoConfirm = { entry: FileEntry; files: number; bytes: number } | null;
+
+/** Auto-syncing a host folder bigger than either of these asks first. They are
+ *  "would you notice this landing on your disk?" thresholds, not limits — the
+ *  point is that byte-sync ignores `.gitignore`, so a folder full of experiment
+ *  output looks exactly like a folder full of code to it. */
+const AUTO_SYNC_WARN_FILES = 200;
+const AUTO_SYNC_WARN_BYTES = 100 * 1024 * 1024;
 
 export const STATUS_COLOR: Record<string, string> = {
   modified:  "#f85149", // red – tracked, unstaged working-tree change
@@ -65,8 +164,8 @@ const STATUS_TITLE: Record<string, string> = {
 };
 
 /** Marker shown to the left of a tree entry for its git status.
- *  Ignored → gray ✕ glyph; unpushed → green ↑ glyph; everything else → a
- *  colored dot (red unstaged/untracked, orange staged); clean → empty slot. */
+ *  Ignored → gray ✕ glyph; everything else → a colored dot (red unstaged/
+ *  untracked, orange staged, green committed-not-pushed); clean → empty slot. */
 function GitMarker({ status }: { status: string | undefined }) {
   const slot: React.CSSProperties = {
     width: 11,
@@ -78,10 +177,10 @@ function GitMarker({ status }: { status: string | undefined }) {
     fontSize: 11,
     lineHeight: 1,
   };
-  if (status === "ignored" || status === "unpushed") {
+  if (status === "ignored") {
     return (
       <span style={{ ...slot, color: STATUS_COLOR[status] }} title={STATUS_TITLE[status]}>
-        {status === "ignored" ? "✕" : "↑"}
+        ✕
       </span>
     );
   }
@@ -93,80 +192,395 @@ function GitMarker({ status }: { status: string | undefined }) {
   );
 }
 
-function pathToFileUri(path: string): string {
-  return `file://${path.split("/").map(encodeURIComponent).join("/")}`;
+
+// Native drag-out (tauri-plugin-drag) needs the OS drag-preview icon as a base64
+// PNG data URL (its icon field rejects a bare path), read synchronously inside
+// the `dragstart` gesture. The backend returns that data URL; cache it
+// process-wide so every file row shares one warm-up (kicked off at mount) and
+// reads it without awaiting.
+let dragIconDataUrl = "";
+let dragIconPromise: Promise<string> | null = null;
+function warmDragIcon(): Promise<string> {
+  if (!dragIconPromise) {
+    dragIconPromise = invoke<string>("drag_preview_icon")
+      .then((p) => (dragIconDataUrl = p))
+      .catch(() => "");
+  }
+  return dragIconPromise;
 }
 
-function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
+// TEMPORARY (Windows drag QA — remove together with every dragDbg call): mirror
+// the drag/selection gesture lifecycle into crash.log via report_frontend_error
+// so a failing gesture can be read back without devtools open.
+function dragDbg(message: string) {
+  try {
+    void invoke("report_frontend_error", { kind: "drag-debug", message, stack: null }).catch(() => {});
+  } catch {
+    /* diagnostics must never affect the gesture */
+  }
+}
+
+/** Turn a raw `list_dir` failure into a sentence a user can act on. The common
+ *  case, by far, is switching a remote project's file view to "Remote" while
+ *  sitting in a folder that only exists in the local mirror (never synced to the
+ *  host): the backend's SFTP `open_dir` fails deep in ssh2 with text like
+ *  "sftp open_dir failed: …", which means nothing to a user. Say what actually
+ *  happened and what to do about it instead. */
+function describeListError(e: unknown, remoteSource: boolean): string {
+  const raw = String(e);
+  if (remoteSource) {
+    // A missing/denied directory on the host. ssh2/libssh surface this as
+    // "no such file", "No such file", "failure", or a bare open_dir error.
+    if (/open_dir|read_dir|no such file|not found|failure|permission/i.test(raw)) {
+      return "This folder isn't on the remote host — it may be local-only (never synced). Switch to Local to view it.";
+    }
+    return "Couldn't list this folder on the remote host. Check the connection and try again.";
+  }
+  return "Couldn't open this folder.";
 }
 
 export function FileTree({
   projectDir,
   projectId,
   localFile = null,
-  showHidden = false,
   sortKey = "name",
   descending = false,
   hiddenEndings = [],
   hiddenPaths = [],
+  scanExcluded,
+  onToggleScanExcluded,
   shownPaths = [],
   initialRelPath = "",
   onRelPathChange,
+  onOpenFolderTab,
+  syncSource,
+  remoteProbeDir,
 }: Props) {
+  // Non-null inside a detached popout: replaces the main window's CenterPanel
+  // drop authority (which this window can't reach) for a file dragged onto a
+  // pane. See fileDropContext.
+  const fileDrop = useContext(FileDropContext);
   const [rawEntries, setRawEntries] = useState<FileEntry[]>([]);
+  // Recursive folder sizes (bytes), keyed by absolute folder path. Filled in
+  // lazily by a per-folder backend call so a big subtree never blocks the
+  // listing — the tree renders immediately and each folder's size appears
+  // once it resolves. `requestedSizes` guards against re-dispatching the same
+  // folder while it's in flight (or after it failed), so fs-watch churn doesn't
+  // trigger a request storm; both reset in `load()` (navigation / refresh) so a
+  // re-listed folder recomputes. Shared between the two size-fetch effects
+  // below (plain `dir_size` for the gitignored section, `dir_size_breakdown`
+  // for everything else) so the same folder is never fetched by both — besides
+  // being wasted work, two independent walks of the same folder can disagree
+  // if it's being actively written to, which would make the ignored split
+  // exceed the total from the other call.
+  const [dirSizes, setDirSizes] = useState<Record<string, number>>({});
+  const requestedSizes = useRef<Set<string>>(new Set());
+  // Which listing the in-flight size calls belong to. Bumped by `load()`, the
+  // only thing that invalidates the cache — so a result is stale ONLY if the
+  // folder was re-listed under it, never merely because the tree re-rendered.
+  // This is load-bearing: the effects below key on `sections`, whose identity
+  // changes on any re-render (`load()` itself sets rawEntries and THEN, a
+  // round-trip later, gitStatuses), and cancelling on that would drop every
+  // size call still in flight — permanently, since `requestedSizes` keeps it
+  // from being re-dispatched. Small folders resolved inside the gap and showed
+  // a size; a big one (the whole point of the feature) never did.
+  const sizeGeneration = useRef(0);
+  // Scan exclusions, normalised once per change into the one spelling the backend
+  // matches on. `scanExcludedList` is what the walk commands receive (it prunes
+  // excluded subtrees *nested inside* a folder being sized); `isScanExcluded`
+  // additionally stops us dispatching a walk for an excluded folder at all.
+  const scanExcludedList = useMemo(
+    () => (scanExcluded ?? []).map(normalizeScanPath).filter(Boolean),
+    [scanExcluded],
+  );
+  const scanExcludedSet = useMemo(() => new Set(scanExcludedList), [scanExcludedList]);
+  const isScanExcluded = useCallback(
+    (rel: string) => scanExcludedSet.has(normalizeScanPath(rel)),
+    [scanExcludedSet],
+  );
+  // The rel path of the most recent `load` call — lets the async remote-boundary
+  // probe bail if navigation has moved on since the listing it was probing failed.
+  const loadTargetRef = useRef<string>("");
+  // Bytes of a folder's recursive size that are git-ignored, for folders that
+  // are NOT themselves ignored (they sit in the regular/standard section) but
+  // contain ignored content — e.g. a source folder with a build output dir
+  // inside. Filled from the same `dir_size_breakdown` call that fills
+  // `dirSizes` for these folders (one walk, both numbers), so the split can
+  // never exceed the total it was measured against. A folder with no ignored
+  // content is simply absent from this map (nothing to annotate).
+  const [dirIgnoredBytes, setDirIgnoredBytes] = useState<Record<string, number>>({});
   // Which files can be embedded as a frameless in-tab app (Group K #40). Keyed
   // by extension (default-app resolution is per-mime/extension), so we only
   // query the backend once per distinct extension. Only embeddable files get the
   // drag-to-tab affordance (3D hover + pointer drag); the rest open on dblclick.
   const [embedByExt, setEmbedByExt] = useState<Record<string, boolean>>({});
-  const [relPath, setRelPath] = useState("");
+  // Seed from the saved folder (`initialRelPath`) rather than "" so a (re)mount
+  // renders that folder immediately. Starting at "" made every remount paint the
+  // ROOT for one frame — then the mount effect's async `load(initialRelPath)`
+  // would snap back to the saved folder, so a remounting tree visibly flickered
+  // "root ↔ current folder". Reading the prop lazily fixes that for all remount
+  // causes; the mount effect below still runs and just fetches this folder's
+  // listing (relPath is already correct, so there is no root frame).
+  const [relPath, setRelPath] = useState(() => initialRelPath ?? "");
+  // Multi-selection: a set of entry ABSOLUTE paths (`e.path`, the row key), plus
+  // the range anchor. Click selects; shift-click extends a contiguous range;
+  // ctrl/cmd-click toggles a row. Backs bulk delete/move/copy, drag-all, and
+  // open-all. Cleared on folder navigation (in `load`) and pruned when the
+  // listing changes (fs-watch removes a selected file).
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+  const anchorRef = useRef<string | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  // When a remote listing fails because the folder isn't on the host, this holds
+  // the crumb index (into the path segments) of the FIRST segment that doesn't
+  // exist on the host — everything from here on is local-only. null when the
+  // whole path exists (the normal case) or the source is local. The breadcrumb
+  // tints the on-host prefix and strikes through the local-only tail from it.
+  const [missingCrumbDepth, setMissingCrumbDepth] = useState<number | null>(null);
   const [gitStatuses, setGitStatuses] = useState<GitStatusMap>({});
   const [isDragOver, setIsDragOver] = useState(false);
   const [separateScaffold, setSeparateScaffold] = useState(true);
-  const [hiddenExpanded, setHiddenExpanded] = useState<boolean>(() => {
+  const [gitignoredExpanded, setGitignoredExpanded] = useState<boolean>(() => {
     try {
-      return localStorage.getItem(HIDDEN_EXPANDED_KEY) === "1";
+      return localStorage.getItem(GITIGNORED_EXPANDED_KEY) === "1";
     } catch {
       return false;
     }
   });
   const [scaffoldExpanded, setScaffoldExpanded] = useState(false);
-  // Whether the Alt key is currently held. While held, file rows arm NATIVE
-  // HTML5 drag-and-drop (export the file to an embedded browser / external
-  // target) instead of the pointer-based drag-to-tab. The two can't both be
-  // armed on the same drag (native DnD fires pointercancel on WebKitGTK and
-  // breaks the pointer drag — see onEntryPointerDown's R6 note), so Alt is the
-  // explicit switch. Tracked as state so `draggable` re-evaluates per row when
-  // Alt is pressed/released.
-  const [altHeld, setAltHeld] = useState(false);
+  // Whether the Ctrl key is currently held. While held, file rows arm NATIVE
+  // HTML5 drag-and-drop (export/copy the file to an embedded browser / external
+  // target like Signal) instead of the pointer-based drag-to-tab. The two can't
+  // both be armed on the same drag (native DnD fires pointercancel on WebKitGTK
+  // and breaks the pointer drag — see onEntryPointerDown's R6 note), so Ctrl is
+  // the explicit switch. Tracked as state so `draggable` re-evaluates per row
+  // when Ctrl is pressed/released.
+  const [ctrlHeld, setCtrlHeld] = useState(false);
   const [tooltip, setTooltip] = useState<{ rect: DOMRect; entry: FileEntry } | null>(null);
+  const tooltipRef = useRef<HTMLDivElement | null>(null);
+  // Vertical-only correction: a row near the bottom of a short docked viewer
+  // (the right panel, a subwindow's file sidebar) still measures its anchor
+  // against the WHOLE app window, so an unclamped `top: tooltip.rect.top`
+  // could push the tooltip's body past the window's bottom edge. Horizontal
+  // placement already picks a side with room (see the style below), so only
+  // this axis needs correcting. Measured off `offsetHeight`, not the element's
+  // current on-screen rect, so a stale shift from a previous tooltip can't
+  // pollute the new measurement.
+  const [tooltipShift, setTooltipShift] = useState(0);
+  useLayoutEffect(() => {
+    if (!tooltip) {
+      setTooltipShift(0);
+      return;
+    }
+    const el = tooltipRef.current;
+    if (!el) {
+      setTooltipShift(0);
+      return;
+    }
+    const overflow = tooltip.rect.top + el.offsetHeight - (window.innerHeight - 8);
+    setTooltipShift(overflow > 0 ? overflow : 0);
+  }, [tooltip]);
+  // Drop a pending dwell timer if the tree unmounts mid-hover, so it can't fire
+  // a setState against a gone component.
+  useEffect(() => () => cancelTooltipTimer(), []);
+  // In-tree search: while `search` is non-empty the tree body is replaced by a
+  // flat result list (FileTreeSearch). `searchMode` picks filename vs. content
+  // search; `searchCase` only applies to content search (name search is fuzzy).
+  // Both backends walk the canonical LOCAL path, so the search box is only shown
+  // for a non-remote-source tree (see `remoteListing` below).
+  // Right-click on the breadcrumb turns the path into an editable field (holding
+  // the current folder's absolute path) so a path can be typed/pasted to jump —
+  // and copies that absolute path to the clipboard. `null` = not editing.
+  const [pathEdit, setPathEdit] = useState<string | null>(null);
+  const pathEditRef = useRef<HTMLInputElement | null>(null);
+  const [search, setSearch] = useState("");
+  const [searchMode, setSearchMode] = useState<"name" | "content">("name");
+  const [searchCase, setSearchCase] = useState(false);
+  // Search scope: false (default) confines the search to the browsed folder
+  // (`relPath`); true searches from the project root. Only meaningful in a
+  // subfolder — at the root the two are identical.
+  const [searchRoot, setSearchRoot] = useState(false);
+  // A pending "reveal in tree" (jump-to-path) request from a search result: the
+  // parent folder to navigate to and the entry name to select once it lists.
+  const [pendingReveal, setPendingReveal] = useState<{ parent: string; name: string } | null>(null);
+  // Drag-to-move: the rel path of the folder / breadcrumb under the cursor while
+  // a file is being dragged (null = none). The ref carries the live value into
+  // the drag's window-bound release handler (which captured an earlier closure);
+  // the state drives the drop-target highlight and only changes when the hovered
+  // target changes (not every pointermove), so the tree re-renders rarely.
+  const moveTargetRef = useRef<string | null>(null);
+  const [moveTargetRel, setMoveTargetRel] = useState<string | null>(null);
   const [contextMenu, setContextMenu] = useState<EntryContextMenu>(null);
+  const contextMenuRef = useRef<HTMLDivElement | null>(null);
+  // The focusable tree root. File rows preventDefault on pointerdown to arm the
+  // drag, which suppresses the browser's default focus-the-ancestor — so we move
+  // focus here explicitly on selection, or the tree's key handlers (Enter/Delete/
+  // Escape) would only fire after a manual Tab-in (notably in the docked sidebar).
+  const treeRootRef = useRef<HTMLDivElement | null>(null);
+  useClampToViewport(contextMenuRef, contextMenu, setContextMenu);
+  // Close on any click outside the menu, not just inside this tree: the tree's
+  // own `onMouseDown={() => setContextMenu(null)}` only fires for a click that
+  // bubbles through the `.file-tree` root, so a click in the terminal, another
+  // tab, or anywhere else in the window left a stale menu floating (it's
+  // portaled to document.body, so it stays visually on top regardless).
+  useEffect(() => {
+    if (!contextMenu) return;
+    const onDocMouseDown = (ev: MouseEvent) => {
+      if (contextMenuRef.current && !contextMenuRef.current.contains(ev.target as Node)) {
+        setContextMenu(null);
+      }
+    };
+    document.addEventListener("mousedown", onDocMouseDown);
+    return () => document.removeEventListener("mousedown", onDocMouseDown);
+  }, [contextMenu]);
   const [deleteConfirm, setDeleteConfirm] = useState<DeleteConfirm>(null);
+  const [autoConfirm, setAutoConfirm] = useState<AutoConfirm>(null);
   const [defaultAppFor, setDefaultAppFor] = useState<FileEntry | null>(null);
   const [pastePrompt, setPastePrompt] = useState<PastePrompt | null>(null);
   const [pasteBusy, setPasteBusy] = useState(false);
+  // SSH-sync Phase 2: project-relative paths whose push was blocked by a stale
+  // host base, awaiting the user's keep-local / take-host / skip choice. The
+  // first is shown in the conflict modal; resolving advances the queue.
+  const [pushConflicts, setPushConflicts] = useState<string[]>([]);
+  const [pushBusy, setPushBusy] = useState(false);
   // Whether the system clipboard holds an image when the context menu opened
   // (probed async on right-click), gating the "Paste screenshot" option.
   const [clipboardImage, setClipboardImage] = useState(false);
-  const clipboard = useFileClipboardStore((s) => s.entry);
-  const setClipboard = useFileClipboardStore((s) => s.setEntry);
+  const clipboardEntries = useFileClipboardStore((s) => s.entries);
+  const setClipboardEntries = useFileClipboardStore((s) => s.setEntries);
   const clearClipboard = useFileClipboardStore((s) => s.clear);
+  // The primary clipboard item — backs the single-file paste-rename prompt and
+  // its labels. Multi-item pastes read the full `clipboardEntries` array.
+  const clipboard = clipboardEntries[0] ?? null;
   // TeX toolchain presence (null until probed); absolute paths of .tex files
   // currently compiling, for the inline build spinner.
   const [texCap, setTexCap] = useState<TexCapability | null>(null);
   const [compiling, setCompiling] = useState<Set<string>>(new Set());
-  const { openFile } = useWindowsStore();
-  const addTab = useTabsStore((s) => s.addTab);
+  // Per-file arguments for the ▶ Run button, remembered so a re-run reuses them.
+  // Set via the right-click popover (`argsPopover`, positioned at the cursor).
+  // Same shared, persisted map the open-editor's Run/Debug toolbar reads/writes
+  // (`FileViewerPane.tsx`'s `pyArgs`/`setPyArgs`) — keyed by absolute path in
+  // global settings, not local component state, so it survives this tree
+  // unmounting (right-panel hide/close) and an Eldrun restart.
+  const pyArgsByPath = useSettingsStore((s) => s.settings?.python_run_args ?? EMPTY_PY_ARGS);
+  const setPyArgs = useCallback((path: string, v: string) => {
+    void useSettingsStore.getState().setPythonRunArgs(path, v);
+  }, []);
+  const [argsPopover, setArgsPopover] = useState<{
+    entry: FileEntry;
+    x: number;
+    y: number;
+    draft: string;
+  } | null>(null);
+  const argsPopoverRef = useRef<HTMLDivElement | null>(null);
+  const argsInputRef = useRef<HTMLInputElement | null>(null);
+  useClampToViewport(argsPopoverRef, argsPopover, setArgsPopover);
+  useEffect(() => {
+    if (!argsPopover) return;
+    argsInputRef.current?.focus();
+    argsInputRef.current?.select();
+  }, [argsPopover?.entry.path]);
   const runInBackground = useSettingsStore((s) => s.settings?.run_scripts_in_background ?? true);
+  const viewerPrefs = useSettingsStore((s) => s.settings?.viewer_prefs);
+  const disabledViewerSet = useMemo(() => disabledViewers(viewerPrefs), [viewerPrefs]);
   const runningScripts = useActivityStore((s) => s.runningScripts);
+  const runningRunFiles = useActivityStore((s) => s.runningRunFiles);
   const runScript = useActivityStore((s) => s.runScript);
+  // Mount-free remote (Phase 2): a remote project lists over SFTP and has no
+  // local inotify watcher, so we skip the fs-watch wiring and offer a manual
+  // refresh control instead. Local projects keep live watch-driven updates.
+  const isRemote = useProjectsStore(
+    (s) => !!s.projects.find((p) => p.id === projectId)?.remote,
+  );
+  // The local mirror root for a remote project, resolved the same way
+  // `ProjectFilesPane`/`ProjectFilesView` do (persisted override, else the default
+  // `<state_dir>/mirror`). Used to build the mirror-side absolute path the
+  // three-way merge viewer (`SyncMergeView`) opens a diverged file at — the ± diff
+  // button below routes through it. Null for a local (non-remote) project.
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const mirrorRoot = useMemo(() => {
+    if (!project?.remote) return null;
+    return (
+      resolveLocalMirror(project) ??
+      `${resolveProjectDirectory(project).replace(/[/\\]+$/, "")}/mirror`
+    );
+  }, [project]);
+  // SSH-sync Phase 1: the local mirror source (`syncSource === "local"`) is a
+  // plain LOCAL tree even though its project is remote — it lists/​watches the
+  // local mirror dir and is never gated on the SSH pool. Only a remote-SOURCE
+  // tree dispatches its listing over SFTP. `remoteListing` is the flag the
+  // watch/refresh-bar/pool-gate logic below keys on.
+  const treatLocal = syncSource === "local";
+  const remoteListing = isRemote && !treatLocal;
+  // SSH-sync overlay state for the remote source: per-path green/amber/none + the
+  // in-flight transfer progress. Only consulted in the remote-source view.
+  const syncStatus = useSyncStore((s) => (projectId ? s.byProject[projectId] : undefined));
+  // Aggregated sync state for FOLDERS that have no manifest entry of their own.
+  // The manifest tracks files (a directory only gets an entry when it is
+  // explicitly folder-selected / folder-auto-synced); files pulled individually
+  // leave every ancestor folder absent, so a folder row's own-path lookup
+  // defaults to "none" and paints a red "push to host" button even when every
+  // file inside it is green/in-sync. This rolls each tracked file's state up onto
+  // all of its ancestor directories: `any` = the folder contains a tracked file,
+  // `allGreen` = they are all green. A folder with its own entry still uses that
+  // (handled at the lookup site); this only rescues the entry-less ones. Keyed by
+  // project-relative directory path.
+  const dirSyncAgg = useMemo(() => {
+    const agg: Record<string, { any: boolean; allGreen: boolean }> = {};
+    if (!syncStatus) return agg;
+    for (const [p, s] of Object.entries(syncStatus)) {
+      if (s.isDir) continue; // dir entries are authoritative on their own row
+      const parts = p.split("/");
+      for (let i = 1; i < parts.length; i++) {
+        const dir = parts.slice(0, i).join("/");
+        const cur = agg[dir] ?? { any: false, allGreen: true };
+        cur.any = true;
+        if (s.state !== "green") cur.allGreen = false;
+        agg[dir] = cur;
+      }
+    }
+    return agg;
+  }, [syncStatus]);
+  const syncProgress = useSyncStore((s) => (projectId ? s.progressByProject[projectId] : undefined));
+  const refreshSyncStatus = useSyncStore((s) => s.refreshStatus);
+  const syncPull = useSyncStore((s) => s.pull);
+  const syncPush = useSyncStore((s) => s.push);
+  const syncMarkSelected = useSyncStore((s) => s.markSelected);
+  const syncSetAuto = useSyncStore((s) => s.setAuto);
+  const syncAutoPreview = useSyncStore((s) => s.autoPreview);
+  const syncSetExcluded = useSyncStore((s) => s.setExcluded);
+  // A remote project's `list_dir`/`git_file_statuses` dispatch over SSH/SFTP on
+  // the backend. Those are SYNCHRONOUS Tauri commands (they run on the main
+  // thread), so calling them while the pooled connection is down blocks on the
+  // dead SSH session and FREEZES the whole window. Gate every listing on the pool
+  // being "connected": until then the tree shows a disconnected note instead of
+  // issuing any remote call. Reconnect (header lamp / center placeholder) brings
+  // the pool up, flips this true, and the load effect re-runs.
+  const remoteSshState = useRemoteStatusStore((s) =>
+    projectId ? s.byProject[projectId]?.ssh : undefined,
+  );
+  const remoteBlocked = remoteListing && remoteSshState !== "connected";
+  // Whether this project's PRIMARY host is a tagged cluster login node — the host
+  // that owns the files, and so the one every stat loop below walks. Gates the
+  // periodic re-stat, not the explicit one: see the sync-status effect.
+  const settingsForHpc = useSettingsStore((s) => s.settings);
+  const primaryIsHpc = projectIsOnHpc(settingsForHpc, project);
+  // Local-mirror view of a remote project: the NAMES of the browsed folder's
+  // immediate children that exist on the host, from one SFTP readdir per
+  // navigation (only while the pool is live — a host readdir is a main-thread
+  // command that would freeze on a dead session, like every other remote call).
+  // A local child folder absent from this set is local-only — it has never
+  // reached the host — and the tree flags it so "Local" mode doesn't quietly
+  // imply the whole mirror is on the remote. `null` = unknown (not this view, or
+  // disconnected): flag nothing rather than guess.
+  const [hostChildNames, setHostChildNames] = useState<Set<string> | null>(null);
 
+  // Dotfiles always render inline here — there's no separate "hidden" section;
+  // any that are actually gitignored get pulled into the gitignored section
+  // below instead (see the render below).
   const entries = useMemo(
     () => visibleEntries(rawEntries, {
-      showHidden,
+      showHidden: true,
       showStandardFiles: true,
       sortKey,
       descending,
@@ -175,24 +589,169 @@ export function FileTree({
       hiddenPaths,
       shownPaths,
     }),
-    [rawEntries, showHidden, sortKey, descending, hiddenEndings, relPath, hiddenPaths, shownPaths],
+    [rawEntries, sortKey, descending, hiddenEndings, relPath, hiddenPaths, shownPaths],
   );
 
-  // Dotfiles hidden from the inline tree, surfaced in a collapsed section so they
-  // stay discoverable without flooding the tree (TODO group N #29). Shown
-  // independently of the scaffold split — see the render below.
-  const hidden = useMemo(
-    () => hiddenEntries(rawEntries, {
-      showHidden,
-      sortKey,
-      descending,
-      hiddenEndings,
-      relPath,
-      hiddenPaths,
-      shownPaths,
-    }),
-    [rawEntries, showHidden, sortKey, descending, hiddenEndings, relPath, hiddenPaths, shownPaths],
-  );
+  // Whether a visible Python file is a "main" script (has a module-level
+  // `if __name__ == "__main__":` guard) — the Run ▶ button only shows for
+  // those, not for every importable module. Resolved lazily per file since it
+  // needs the file's content, which the tree listing doesn't carry. Keyed by
+  // path + size + mtime so an on-disk edit (picked up by the fs watcher's
+  // `entries` change) gets rechecked instead of trusting a stale verdict.
+  const [pyMainByPath, setPyMainByPath] = useState<Record<string, boolean>>({});
+  const pyMainChecked = useRef<Set<string>>(new Set());
+  useEffect(() => {
+    // A remote-source listing's `readFileText` is an SFTP round trip — doing
+    // one per visible .py file just to place the Run button would visibly
+    // stall the tree. Remote falls back to the old any-.py-file behavior
+    // instead (see `canPyRun` below).
+    if (remoteListing) return;
+    const pending = entries.filter(
+      (e) => !e.is_dir && isPythonPath(e.path)
+        && !pyMainChecked.current.has(`${e.path}#${e.size}#${e.modified_secs ?? 0}`),
+    );
+    if (pending.length === 0) return;
+    pending.forEach((e) => pyMainChecked.current.add(`${e.path}#${e.size}#${e.modified_secs ?? 0}`));
+    let cancelled = false;
+    (async () => {
+      for (const e of pending) {
+        const text = await readFileText(e.path, projectId).catch(() => null);
+        if (cancelled) return;
+        setPyMainByPath((m) => ({ ...m, [e.path]: text != null && isPythonMainScript(text) }));
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [entries, remoteListing, projectId]);
+
+  // Per-entry git status resolving the "whole directory is ignored" sentinel the
+  // backend emits under the reserved key "." (git's porcelain never lists an empty
+  // ignored subdir, so those children arrive absent from `gitStatuses`; without
+  // this they'd fall out of the gitignored section — see git.rs `git_file_statuses`).
+  // When the current folder is wholly ignored, every listed child defaults to
+  // "ignored" unless it already carries an explicit status (a force-added tracked
+  // file). Every consumer reads this, never the raw `gitStatuses`, so the tree, the
+  // section split, and the hover card stay consistent.
+  const displayStatuses = useMemo(() => {
+    if (gitStatuses["."] !== "ignored") return gitStatuses;
+    const m: GitStatusMap = {};
+    for (const e of entries) m[e.name] = gitStatuses[e.name] ?? "ignored";
+    return m;
+  }, [gitStatuses, entries]);
+
+  // The three on-screen sections in render order (regular, then the collapsible
+  // scaffold + gitignored groups). Shared by the renderer and the selection
+  // click handler so a shift-range spans exactly what the user sees. Mirrors the
+  // split the render body applies below.
+  const sections = useMemo(() => {
+    const isRoot = !relPath && separateScaffold;
+    const nonStandard = isRoot ? entries.filter((e) => !STANDARD_PROJECT_FILES.has(e.name)) : entries;
+    const standard = isRoot ? entries.filter((e) => STANDARD_PROJECT_FILES.has(e.name)) : [];
+    // The size breakdown is an independent ignored-path scan. If it establishes
+    // that every byte in a folder is ignored, keep that folder out of the normal
+    // section even when the status request was incomplete (for example an older
+    // backend, or Git configured with status.showUntrackedFiles=no). Otherwise
+    // the normal-row size subtracts the ignored bytes and misleadingly shows 0 B.
+    const isIgnored = (e: FileEntry) =>
+      displayStatuses[e.name] === "ignored" ||
+      (e.is_dir &&
+        (dirIgnoredBytes[e.path] ?? 0) > 0 &&
+        dirSizes[e.path] !== undefined &&
+        (dirIgnoredBytes[e.path] ?? 0) >= dirSizes[e.path]);
+    const regular = nonStandard.filter((e) => !isIgnored(e));
+    const gitignored = nonStandard.filter(isIgnored);
+    return { regular, standard, gitignored };
+  }, [entries, relPath, separateScaffold, displayStatuses, dirSizes, dirIgnoredBytes]);
+
+  // How many rows the tree will actually render, raised a page at a time by the
+  // "show more" footer. Rows are NOT virtualized, and each one is ~16 elements
+  // with ~11 handlers rebuilt on every render of this component — so a folder
+  // holding thousands of files (an ML sweep's `results/` routinely does: one run
+  // per config × per step) builds six figures of DOM and re-reconciles the lot
+  // every time a size lands, a sync status refreshes, or the pointer moves. That
+  // is enough to make the whole window unusable while the CPU still looks idle,
+  // because the cost is layout/paint in a software-rendered webview, not compute.
+  // Capping keeps the cost proportional to what is on screen; the folder is still
+  // fully reachable, one page at a time.
+  const [rowCap, setRowCap] = useState(ROW_CAP_STEP);
+  // A new folder (or a new project) starts back at one page — the cap is about
+  // this listing, not a preference to carry around the tree.
+  useEffect(() => {
+    setRowCap(ROW_CAP_STEP);
+  }, [relPath, projectId]);
+
+  // The rows actually rendered, in on-screen order, clipped to `rowCap` across
+  // the sections as a whole (the budget is spent top-down, so raising the cap
+  // extends the list rather than reshuffling it). Collapsed sections spend
+  // nothing — they render no rows. Section *labels* keep counting the full
+  // `sections` lists, so "gitignored (8316)" still tells the truth about the
+  // folder while only a page of it is on screen.
+  const rowWindow = useMemo(() => {
+    let budget = rowCap;
+    const clip = (list: FileEntry[]) => {
+      const out = budget >= list.length ? list : list.slice(0, Math.max(0, budget));
+      budget -= out.length;
+      return out;
+    };
+    const regular = clip(sections.regular);
+    const standard = scaffoldExpanded ? clip(sections.standard) : [];
+    const gitignored = gitignoredExpanded ? clip(sections.gitignored) : [];
+    const total =
+      sections.regular.length +
+      (scaffoldExpanded ? sections.standard.length : 0) +
+      (gitignoredExpanded ? sections.gitignored.length : 0);
+    const shown = regular.length + standard.length + gitignored.length;
+    return { regular, standard, gitignored, hidden: total - shown };
+  }, [sections, rowCap, scaffoldExpanded, gitignoredExpanded]);
+
+  // Flat list of visible row paths in on-screen order — the axis a shift-range
+  // spans. Collapsed sections contribute no rows (they aren't rendered), and
+  // neither do rows beyond the cap: a range must span exactly what the user can
+  // see, or shift-click would silently select rows that aren't on screen.
+  const orderedVisible = useMemo(() => {
+    const paths = rowWindow.regular.map((e) => e.path);
+    paths.push(...rowWindow.standard.map((e) => e.path));
+    paths.push(...rowWindow.gitignored.map((e) => e.path));
+    return paths;
+  }, [rowWindow]);
+
+  // Prune selected paths that vanished from the listing (fs-watch removed a
+  // file, a folder was deleted, etc.) so stale entries never linger in bulk ops.
+  useEffect(() => {
+    setSelected((prev) => {
+      if (prev.size === 0) return prev;
+      const live = new Set(entries.map((e) => e.path));
+      let changed = false;
+      const next = new Set<string>();
+      for (const p of prev) {
+        if (live.has(p)) next.add(p);
+        else changed = true;
+      }
+      return changed ? next : prev;
+    });
+  }, [entries]);
+
+  function clearSelection() {
+    anchorRef.current = null;
+    setSelected((prev) => (prev.size === 0 ? prev : new Set()));
+  }
+
+  // Apply a click on a row to the selection, honouring shift (range) and
+  // ctrl/cmd (toggle) via the pure `nextSelection` helper.
+  function selectFromClick(entry: FileEntry, ev: { shiftKey: boolean; ctrlKey: boolean; metaKey: boolean }) {
+    setSelected((prev) => {
+      const { selected: next, anchor } = nextSelection(
+        prev,
+        orderedVisible,
+        anchorRef.current,
+        entry.path,
+        { shift: ev.shiftKey, toggle: ev.ctrlKey || ev.metaKey },
+      );
+      anchorRef.current = anchor;
+      return next;
+    });
+  }
 
   // Resolve embed capability for any not-yet-known file extension in view. One
   // backend call per distinct extension; results cached in embedByExt.
@@ -225,6 +784,127 @@ export function FileTree({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [entries]);
 
+  // Lazily compute the recursive size of each visible gitignored-section
+  // folder. Fires one backend call per not-yet-requested folder (concurrently
+  // — they're independent) and fills `dirSizes` as each resolves. A failed
+  // call is left unresolved; the `requestedSizes` guard keeps it (and
+  // steady-state re-renders / fs-watch reloads) from re-dispatching. Plain
+  // `dir_size` is enough here — the whole folder is ignored by definition, so
+  // there's no split to compute, unlike the regular/standard effect below.
+  //
+  // Scoped to the RENDERED rows (`rowWindow`), not the whole section: pricing a
+  // folder costs a recursive walk — a `du` over SSH for a remote project — so a
+  // listing holding thousands of subfolders would dispatch thousands of them for
+  // rows that aren't even on screen. `requestedSizes` dedupes, so raising the
+  // render cap prices the newly revealed folders and only those.
+  useEffect(() => {
+    const pending = rowWindow.gitignored.filter(
+      (e) => e.is_dir && !requestedSizes.current.has(e.path) && !isScanExcluded(relForEntry(e)),
+    );
+    if (pending.length === 0) return;
+    pending.forEach((e) => requestedSizes.current.add(e.path));
+    const gen = sizeGeneration.current;
+    for (const e of pending) {
+      guardedDirSize(projectDir, () =>
+        invoke<number>("dir_size", {
+          projectDir,
+          relPath: relForEntry(e),
+          excluded: scanExcludedList,
+        }),
+      )
+        .then((bytes) => {
+          if (sizeGeneration.current === gen) setDirSizes((m) => ({ ...m, [e.path]: bytes }));
+        })
+        .catch(() => {
+          /* best-effort display aid — leave unresolved on failure */
+        });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [rowWindow.gitignored]);
+
+  // Lazily compute the recursive size of each visible regular/standard-section
+  // folder, split into ignored vs. non-ignored bytes in the SAME backend walk
+  // that produces the total — so a folder with e.g. a build output dir mixed
+  // in with source can show that split, and the ignored figure can never
+  // exceed the total it was measured against (two independent walks of the
+  // same folder can disagree if it's being actively written to, which is
+  // exactly the kind of folder — build/output dirs — this feature targets).
+  // Fills both `dirSizes` and `dirIgnoredBytes` from one response, sharing
+  // `requestedSizes` with the effect above so no folder is fetched twice.
+  // Scoped to the rendered rows for the same reason that effect is — see there.
+  useEffect(() => {
+    const candidates = [...rowWindow.regular, ...rowWindow.standard];
+    const pending = candidates.filter(
+      (e) => e.is_dir && !requestedSizes.current.has(e.path) && !isScanExcluded(relForEntry(e)),
+    );
+    if (pending.length === 0) return;
+    pending.forEach((e) => requestedSizes.current.add(e.path));
+    const gen = sizeGeneration.current;
+    for (const e of pending) {
+      guardedDirSize(projectDir, () =>
+        invoke<{ total: number; ignored: number }>("dir_size_breakdown", {
+          projectDir,
+          relPath: relForEntry(e),
+          excluded: scanExcludedList,
+        }),
+      )
+        .then(({ total, ignored }) => {
+          if (sizeGeneration.current !== gen) return;
+          setDirSizes((m) => ({ ...m, [e.path]: total }));
+          if (ignored > 0) setDirIgnoredBytes((m) => ({ ...m, [e.path]: ignored }));
+        })
+        .catch((err) => {
+          // The fallback is for a `dir_size_breakdown` that failed for a reason
+          // `dir_size` wouldn't (a backend that hasn't picked up this newer
+          // command, no `git` on PATH) — there, a folder's size matters more than
+          // its ignored split. It is NOT for a host that stopped answering: a
+          // timed-out or breaker-refused call says nothing about the *command*,
+          // so retrying with the other one would just queue a second doomed call
+          // per folder — twice the pile-up the guard exists to prevent.
+          if (err instanceof DirSizeUnavailable || isHostTimeout(err)) return;
+          guardedDirSize(projectDir, () =>
+            invoke<number>("dir_size", {
+              projectDir,
+              relPath: relForEntry(e),
+              excluded: scanExcludedList,
+            }),
+          )
+            .then((bytes) => {
+              if (sizeGeneration.current === gen) setDirSizes((m) => ({ ...m, [e.path]: bytes }));
+            })
+            .catch(() => {
+              /* best-effort display aid — leave unresolved on failure */
+            });
+        });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [rowWindow.regular, rowWindow.standard]);
+
+  // Total bytes contained in each section, kept separate rather than merged
+  // into one figure — the point of splitting scaffold/gitignored out visually
+  // is that their weight (e.g. a huge gitignored build dir) shouldn't hide
+  // inside the "real" content total. Sums whatever `dirSizes`/`e.size` already
+  // know; unresolved subfolder sizes count as 0 until their `dir_size` call
+  // lands, same best-effort as the per-row display above. `regular`/`standard`
+  // are non-ignored-only (mirroring the per-row headline number), with the
+  // ignored portion pulled out separately so callers can put it on hover —
+  // `gitignored` needs no such split, it's ignored content in its entirety.
+  const groupSizes = useMemo(() => {
+    const total = (list: FileEntry[]) =>
+      list.reduce((sum, e) => sum + (e.is_dir ? (dirSizes[e.path] ?? 0) : e.size), 0);
+    const ignored = (list: FileEntry[]) =>
+      list.reduce((sum, e) => sum + (e.is_dir ? (dirIgnoredBytes[e.path] ?? 0) : 0), 0);
+    const regularIgnored = ignored(sections.regular);
+    const standardIgnored = ignored(sections.standard);
+    return {
+      regular: total(sections.regular) - regularIgnored,
+      regularIgnored,
+      standard: total(sections.standard) - standardIgnored,
+      standardIgnored,
+      gitignored: total(sections.gitignored),
+    };
+  }, [sections, dirSizes, dirIgnoredBytes]);
+
   const isEmbeddable = (e: FileEntry): boolean =>
     !e.is_dir && embedByExt[e.extension ?? ""] === true;
 
@@ -234,7 +914,7 @@ export function FileTree({
   // apply, so PDFs/text/markdown never depend on the configured external app.
   const draggableToTab = (e: FileEntry): InternalViewer | "embed" | null => {
     if (e.is_dir) return null;
-    const viewer = internalViewerFor(e);
+    const viewer = internalViewerFor(e, disabledViewerSet);
     if (viewer) return viewer;
     return isEmbeddable(e) ? "embed" : null;
   };
@@ -245,12 +925,24 @@ export function FileTree({
     return () => { cancelled = true; };
   }, []);
 
-  // Track Alt so file rows can switch to native DnD (export to browser) while
-  // it's held. Also clear on blur/visibility loss so a release that happens
-  // while another window has focus doesn't leave rows stuck in native-drag mode.
+  // Track Ctrl so file rows can switch to native DnD (export/copy to browser or
+  // an external app) while it's held. Also clear on blur/visibility loss so a
+  // release that happens while another window has focus doesn't leave rows stuck
+  // in native-drag mode.
   useEffect(() => {
-    const sync = (e: KeyboardEvent) => setAltHeld(e.altKey);
-    const clear = () => setAltHeld(false);
+    // Warm the native drag-out preview icon so its path is ready (sync-readable)
+    // by the time the user starts a Ctrl-drag. Only the plugin path (Win/mac)
+    // needs it — the Linux `start_file_drag` embeds the icon backend-side.
+    if (PLATFORM !== "linux") void warmDragIcon();
+    let lastCtrl = false; // TEMPORARY drag QA: log transitions only, not every repeat
+    const sync = (e: KeyboardEvent) => {
+      if (e.ctrlKey !== lastCtrl) {
+        lastCtrl = e.ctrlKey;
+        dragDbg(`ctrlHeld=${e.ctrlKey} (${e.type})`);
+      }
+      setCtrlHeld(e.ctrlKey);
+    };
+    const clear = () => setCtrlHeld(false);
     window.addEventListener("keydown", sync);
     window.addEventListener("keyup", sync);
     window.addEventListener("blur", clear);
@@ -263,15 +955,95 @@ export function FileTree({
 
   useEffect(() => {
     if (!projectDir) return;
+    // Don't list a disconnected remote project's tree — the sync list_dir/
+    // git_file_statuses commands would block the main thread on the dead SSH pool
+    // and freeze the app. Re-runs once the pool connects (remoteBlocked flips).
+    if (remoteBlocked) return;
     load(initialRelPath ?? "");
-  }, [projectDir]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projectDir, remoteBlocked]);
+
+  // SSH-sync Phase 1: keep the sync overlay fresh — re-stat selected files
+  // whenever the tree (re)lists. Runs for both the remote-source tree and the
+  // local-mirror tree (the marker is symmetric); `remoteBlocked` only ever gates
+  // the remote-source case; the mirror tree keeps working offline off the last-
+  // known manifest state (the backend falls back gracefully when the pool is
+  // down — see `sync_status`).
+  useEffect(() => {
+    if (isRemote && projectId && !remoteBlocked) {
+      void refreshSyncStatus(projectId);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isRemote, projectId, remoteBlocked, relPath]);
+
+  // SSH-sync: the host tree has no change watcher (inotify can't see the SFTP
+  // tree), so a remote-side edit wouldn't flip a file to amber until the user
+  // re-lists — and the local-mirror view has no re-list button at all. Re-stat
+  // the SELECTED files (cheap metadata over the pooled ControlMaster — NOT a
+  // tree re-list) whenever Eldrun regains focus and on a light interval, so a
+  // remote-only divergence surfaces on its own shortly after it happens instead
+  // of silently going stale. Gated on a live pool so a cold connection never
+  // re-stats (which would report stale green); runs for both the remote-source
+  // and local-mirror views (the amber marker is symmetric).
+  useEffect(() => {
+    if (!isRemote || !projectId || remoteSshState !== "connected") return;
+    const refresh = () => { void refreshSyncStatus(projectId); };
+    window.addEventListener("focus", refresh);
+    // The 15 s tick is the third periodic walk of a host tree, after the 25 s
+    // byte-sync pass and the 12 s lockstep poll — both of which the HPC tag
+    // already stops for exactly the reason `lib/hpcHost.ts` gives ("the same walk,
+    // unasked for, forever"). A tagged login node gets no timer here either: an
+    // open file tree is not a standing request to stat a cluster every quarter
+    // minute. What survives is the focus listener and every explicit re-list —
+    // both are gestures, and the amber marker still refreshes on each of them.
+    const id = primaryIsHpc
+      ? undefined
+      : window.setInterval(() => {
+          // Only tick while Eldrun is focused: a backgrounded window doesn't need
+          // to keep re-stat'ing the host every 15 s (the `focus` listener re-stats
+          // on return anyway), which keeps an idle remote project off the wire.
+          if (document.hasFocus()) refresh();
+        }, 15000);
+    return () => {
+      window.removeEventListener("focus", refresh);
+      if (id !== undefined) window.clearInterval(id);
+    };
+  }, [isRemote, projectId, remoteSshState, refreshSyncStatus, primaryIsHpc]);
+
+  // Local-mirror view: readdir the HOST for the browsed folder so folders that
+  // live only in the local mirror can be flagged (see `hostChildNames`). One
+  // cheap SFTP readdir per navigation, gated on a live pool. If the folder ITSELF
+  // isn't on the host (readdir fails), every local child here is off-host too, so
+  // an empty set is the right answer — it flags them all.
+  useEffect(() => {
+    if (!treatLocal || !isRemote || !remoteProbeDir || remoteSshState !== "connected") {
+      setHostChildNames(null);
+      return;
+    }
+    let cancelled = false;
+    const target = relPath;
+    invoke<FileEntry[]>("list_dir", { projectDir: remoteProbeDir, relPath: target })
+      .then((entries) => {
+        if (!cancelled) setHostChildNames(new Set(entries.map((x) => x.name)));
+      })
+      .catch(() => {
+        if (!cancelled) setHostChildNames(new Set());
+      });
+    return () => {
+      cancelled = true;
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [treatLocal, isRemote, remoteProbeDir, remoteSshState, relPath]);
 
   // Live updates: watch the currently-displayed directory on the backend and
   // re-fetch when it changes, so files created/removed by terminals, agents, or
   // other processes appear without manual navigation. Re-points to the new
   // directory whenever relPath changes; tears down on unmount/panel close.
   useEffect(() => {
-    if (!projectDir) return;
+    // Remote projects have no local fs watcher (inotify can't see the SFTP tree);
+    // they refresh manually via the toolbar button. Skip the watch wiring. The
+    // local mirror source IS a real local dir, so it keeps live watch updates.
+    if (!projectDir || remoteListing) return;
     const absDir = relPath ? `${projectDir}/${relPath}` : projectDir;
     let unlisten: (() => void) | null = null;
     let timer: ReturnType<typeof setTimeout> | null = null;
@@ -294,11 +1066,29 @@ export function FileTree({
       invoke("unwatch_dir").catch(() => {});
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [projectDir, relPath]);
+  }, [projectDir, relPath, remoteListing]);
 
   async function load(rel: string) {
+    // Never issue the (synchronous, main-thread) remote listing commands while the
+    // pool is down — they would freeze the window. See `remoteBlocked`.
+    if (remoteBlocked) return;
+    loadTargetRef.current = rel;
     setLoading(true);
     setError(null);
+    setMissingCrumbDepth(null);
+    // Navigating into a different folder abandons the current selection (its
+    // paths aren't on screen anymore). The quiet fs-watch `refresh()` deliberately
+    // does NOT clear — a background re-list must not wipe an in-progress selection.
+    clearSelection();
+    // Re-listing (navigation or an explicit refresh) recomputes folder sizes:
+    // drop the cache + in-flight guard so the effect re-requests them fresh, and
+    // bump the generation so a call still walking the OLD folder can't land its
+    // bytes on the new listing. The quiet fs-watch `refresh()` deliberately does
+    // NOT do this — folder sizes stay put through watch churn.
+    sizeGeneration.current += 1;
+    requestedSizes.current.clear();
+    setDirSizes({});
+    setDirIgnoredBytes({});
     try {
       const result = await invoke<FileEntry[]>("list_dir", {
         projectDir,
@@ -313,17 +1103,82 @@ export function FileTree({
       }).catch(() => ({}));
       setGitStatuses(statuses);
     } catch (e) {
-      setError(String(e));
+      // The listing failed — most often because "Remote" was selected in a
+      // folder that only exists in the local mirror. Drop the previous listing
+      // (which would otherwise leave the LOCAL files on screen under a Remote
+      // header, falsely implying they're on the host) and show a readable
+      // reason. Keep `relPath` so the breadcrumb / Local switch still work.
+      setRawEntries([]);
+      setGitStatuses({});
+      setRelPath(rel);
+      onRelPathChange?.(rel);
+      setError(describeListError(e, remoteListing));
+      // Remote source: find where the path stops existing on the host so the
+      // breadcrumb can show the boundary (on-host prefix vs local-only tail).
+      // Only on a remote failure, walking up from the deepest ancestor — a
+      // handful of cheap SFTP stats over the already-live pool.
+      if (remoteListing) void probeRemoteBoundary(rel);
     } finally {
       setLoading(false);
     }
   }
 
+  // Walk up the failed path to the deepest ancestor that DOES list on the host,
+  // and mark the first segment past it as the start of the local-only tail. Root
+  // ("") is assumed present, so a path whose very first segment is absent marks
+  // depth 0. Best-effort and self-cancelling: a newer `load` clears the state.
+  async function probeRemoteBoundary(rel: string) {
+    const parts = rel.split("/").filter(Boolean);
+    if (parts.length === 0) return;
+    let depth = 0; // default: first segment already missing
+    for (let k = parts.length - 1; k >= 1; k--) {
+      const prefix = parts.slice(0, k).join("/");
+      try {
+        await invoke<FileEntry[]>("list_dir", { projectDir, relPath: prefix });
+        depth = k;
+        break;
+      } catch {
+        // keep walking up
+      }
+    }
+    // Guard against a race: only apply if we're still on the same failed path.
+    if (loadTargetRef.current === rel) setMissingCrumbDepth(depth);
+  }
+
+  // Right-click the breadcrumb: copy the current folder's absolute path to the
+  // clipboard and open the inline path editor pre-filled with it.
+  function startPathEdit() {
+    const abs = resolvePath(projectDir, relPath);
+    navigator.clipboard?.writeText(abs).catch(() => {});
+    setPathEdit(abs);
+  }
+
+  // Commit the edited path: accept either an absolute path or a project-relative
+  // one, resolve it against the project root, and navigate there when it stays
+  // inside the project. A path outside the project is rejected (the tree is
+  // project-scoped) — the field just closes without navigating.
+  function commitPathEdit() {
+    const raw = pathEdit?.trim() ?? "";
+    setPathEdit(null);
+    if (!raw) return;
+    const abs = resolvePath(projectDir, raw);
+    const rel = relativePathWithin(projectDir, abs);
+    if (rel === null) return;
+    if (rel !== relPath) void load(rel);
+  }
+
+  // Focus + select the path field when it opens so the copied path can be
+  // replaced or edited immediately.
+  useEffect(() => {
+    if (pathEdit !== null) pathEditRef.current?.select();
+  }, [pathEdit !== null]); // eslint-disable-line react-hooks/exhaustive-deps
+
   // Quiet reload for the fs watcher: re-fetch the current directory without the
   // loading flash, and only swap state in when the result actually changed.
   // Replacing rawEntries/gitStatuses on every event (a single write emits a
   // burst) is what caused the tree to flicker, so we diff before committing.
   async function refresh(rel: string) {
+    if (remoteBlocked) return;
     let result: FileEntry[];
     try {
       result = await invoke<FileEntry[]>("list_dir", { projectDir, relPath: rel });
@@ -338,12 +1193,167 @@ export function FileTree({
     setGitStatuses((prev) => (stringMapsEqual(prev, statuses) ? prev : statuses));
   }
 
+  // Jump-to-path: reveal a project-relative path in the tree. A folder navigates
+  // into it; a file navigates to its parent folder and selects+scrolls it. Leaves
+  // search mode so the tree (with the target selected) is what's shown. Used by
+  // every search result (both name and content hits).
+  function revealPath(rel: string, isDir: boolean) {
+    setSearch("");
+    if (isDir) {
+      load(rel);
+      return;
+    }
+    const parts = rel.split("/").filter(Boolean);
+    const name = parts[parts.length - 1] ?? "";
+    const parent = parts.slice(0, -1).join("/");
+    // Expand the collapsible sections so the row is rendered wherever it lives
+    // (a scaffold or gitignored file would otherwise be hidden). The subsequent
+    // effect selects and scrolls once the folder has listed.
+    setScaffoldExpanded(true);
+    setGitignoredExpanded(true);
+    setPendingReveal({ parent, name });
+    if (parent !== relPath) load(parent);
+  }
+
+  // Resolve a pending reveal once the target folder is listed: select the entry
+  // and scroll its row into view, then clear the request. Gives up (clears) if
+  // the entry isn't in the listing — e.g. hidden by a filter.
+  useEffect(() => {
+    if (!pendingReveal) return;
+    if (pendingReveal.parent !== relPath) return; // still navigating
+    const entry = entries.find((e) => e.name === pendingReveal.name);
+    if (!entry) {
+      setPendingReveal(null);
+      return;
+    }
+    anchorRef.current = entry.path;
+    setSelected(new Set([entry.path]));
+    const path = entry.path;
+    requestAnimationFrame(() => {
+      try {
+        document
+          .querySelector(`[data-entry-path="${CSS.escape(path)}"]`)
+          ?.scrollIntoView({ block: "center" });
+      } catch {
+        /* best-effort scroll */
+      }
+    });
+    setPendingReveal(null);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [entries, pendingReveal, relPath]);
+
   function handleClick(entry: FileEntry) {
     if (entry.is_dir) {
       const rel = relPath ? `${relPath}/${entry.name}` : entry.name;
       load(rel);
+    } else if (entry.extension === ".zip") {
+      // A zip "opens" by extracting in place into a sibling folder, then
+      // navigating into it — rather than handing the archive to an external app.
+      void extractArchive(entry);
     } else {
-      openFile(entry.path, undefined, projectId, "right_file_tree").catch(console.error);
+      openEntry(entry, false);
+    }
+  }
+
+  // Open one file entry: a native-viewer type lands as an embed tab in the
+  // project's focused subwindow (or streams into a popout via `fileDrop`); a
+  // type with no native viewer, or an explicit external open (Shift), opens in
+  // the OS default app. The single open-a-file policy — see `openFileEntry`.
+  function openEntry(entry: FileEntry, external: boolean) {
+    openFileEntry({
+      entry,
+      projectDir,
+      projectId,
+      origin: "right_file_tree",
+      external,
+      disabled: disabledViewerSet,
+      // In a detached popout, stream the viewer tab into that window rather than
+      // writing the popout's non-authoritative local tab store.
+      placeTab: fileDrop ? fileDrop.openTab : undefined,
+    });
+  }
+
+  // Single-click routing. A plain click on a folder navigates into it (and
+  // drops any selection); every other click — a file, or a modifier-click on a
+  // folder — drives the multi-selection instead (shift = range, ctrl/cmd =
+  // toggle). Opening a file stays a double-click (onDoubleClick → handleOpen).
+  function handleRowClick(ev: React.MouseEvent, entry: FileEntry) {
+    dragDbg(`rowClick ${entry.name} shift=${ev.shiftKey} ctrl=${ev.ctrlKey}`); // TEMPORARY drag QA
+    const hasMod = ev.shiftKey || ev.ctrlKey || ev.metaKey;
+    if (entry.is_dir && !hasMod) {
+      clearSelection();
+      handleClick(entry);
+      return;
+    }
+    selectFromClick(entry, ev);
+    // Take keyboard focus so Delete/Enter/Escape act on this selection without a
+    // manual Tab-in (the row's pointerdown preventDefault suppresses auto-focus).
+    treeRootRef.current?.focus({ preventScroll: true });
+  }
+
+  // Open a file on double-click. A native-viewer type opens in the focused
+  // subwindow; a type with no native viewer — or a Shift+double-click — opens in
+  // the OS default app (see `openEntry`). If the entry belongs to a
+  // multi-selection, open EVERY selected file this way; otherwise just this one.
+  // Folders keep navigating via handleClick.
+  function handleOpen(entry: FileEntry, ev?: React.MouseEvent) {
+    if (entry.is_dir) {
+      handleClick(entry);
+      return;
+    }
+    const external = ev?.shiftKey ?? false;
+    const targets =
+      selected.has(entry.path) && selected.size > 1
+        ? entries.filter((e) => !e.is_dir && selected.has(e.path))
+        : [entry];
+    for (const t of targets) {
+      if (t.extension === ".zip") void extractArchive(t);
+      else openEntry(t, external);
+    }
+  }
+
+  // Keyboard on the focused tree: Enter opens every selected file, Escape drops
+  // the selection, Delete removes it (the right-click Delete's keyboard twin).
+  // Only acts while something is selected so it never steals keys from the rest
+  // of the panel.
+  function handleTreeKeyDown(ev: React.KeyboardEvent) {
+    if (selected.size === 0) return;
+    // Never hijack Delete/Enter from the in-tree search box or a rename field.
+    const target = ev.target as HTMLElement | null;
+    if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable)) {
+      return;
+    }
+    if (ev.key === "Escape") {
+      ev.stopPropagation();
+      clearSelection();
+    } else if (ev.key === "Enter") {
+      ev.preventDefault();
+      // Enter mirrors a double-click; Shift+Enter forces the external app.
+      for (const t of entries.filter((e) => !e.is_dir && selected.has(e.path))) {
+        if (t.extension === ".zip") void extractArchive(t);
+        else openEntry(t, ev.shiftKey);
+      }
+    } else if (ev.key === "Delete") {
+      ev.preventDefault();
+      // Mirror the context menu's bulk target set (files and folders alike).
+      promptDelete(entries.filter((e) => selected.has(e.path)));
+    }
+  }
+
+  /** Extract a .zip into a new sibling folder and navigate into it. */
+  async function extractArchive(entry: FileEntry) {
+    setContextMenu(null);
+    setLoading(true);
+    setError(null);
+    try {
+      const folderRel = await invoke<string>("extract_archive", {
+        projectDir,
+        relPath: relForEntry(entry),
+      });
+      await load(folderRel);
+    } catch (err) {
+      setError(String(err));
+      setLoading(false);
     }
   }
 
@@ -353,23 +1363,89 @@ export function FileTree({
     load(parts.join("/"));
   }
 
-  function handleEntryMouseEnter(e: React.MouseEvent<HTMLDivElement>, entry: FileEntry) {
-    if (entry.modified_secs || entry.created_secs) {
-      setTooltip({ rect: e.currentTarget.getBoundingClientRect(), entry });
+  // A tooltip opens on DWELL, never on mere entry. `tooltip` is state on THIS
+  // component and the rows are not memoized, so each open/close re-renders the
+  // whole listing — and `getBoundingClientRect()` forces a synchronous reflow on
+  // top. Setting it from `onMouseEnter` therefore made a mouse merely *crossing*
+  // the tree cost two full re-renders plus two reflows per row, which is what
+  // made moving over the tree stutter (worst under the software renderer, since
+  // `WEBKIT_DISABLE_DMABUF_RENDERER=1` puts every repaint on the CPU). Deferring
+  // makes a pass-over free: only a genuine pause measures and opens anything.
+  const tooltipTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  function cancelTooltipTimer() {
+    if (tooltipTimer.current !== null) {
+      clearTimeout(tooltipTimer.current);
+      tooltipTimer.current = null;
     }
   }
 
-  function handleEntryDragStart(e: React.DragEvent<HTMLDivElement>, entry: FileEntry) {
-    const fileUri = pathToFileUri(entry.path);
-    e.dataTransfer.effectAllowed = "copy";
-    e.dataTransfer.setData("text/uri-list", fileUri);
-    e.dataTransfer.setData("text/plain", entry.path);
-    if (!entry.is_dir) {
-      e.dataTransfer.setData(
-        "DownloadURL",
-        `${entry.mime || "application/octet-stream"}:${entry.name}:${fileUri}`,
+  function handleEntryMouseEnter(e: React.MouseEvent<HTMLDivElement>, entry: FileEntry) {
+    // `currentTarget` is nulled once the handler returns, so capture the row now
+    // rather than inside the timeout.
+    const row = e.currentTarget;
+    cancelTooltipTimer();
+    tooltipTimer.current = setTimeout(() => {
+      tooltipTimer.current = null;
+      // Always shows the name (the row can truncate it); Created/Modified/Ignored
+      // lines below are conditional on the entry actually having that data.
+      setTooltip({ rect: row.getBoundingClientRect(), entry });
+    }, TOOLTIP_DWELL_MS);
+  }
+
+  function handleEntryMouseLeave() {
+    cancelTooltipTimer();
+    // Costs no render when nothing is open: React bails out on an unchanged
+    // value, so a sweep across rows that never dwelt stays free.
+    setTooltip(null);
+  }
+
+  // Start the native OS drag-out (EXPORT/COPY to another app: a browser, Signal,
+  // a file manager, the desktop). Real OLE/NSDragging/GTK drag with an
+  // OS-rendered icon; copy semantics, so files are never MOVED out of the
+  // project. Reached two ways: a dir's HTML5 dragstart (handleEntryDragStart),
+  // and the mid-drag Ctrl handoff inside onEntryPointerDown.
+  function beginNativeFileDrag(paths: string[]) {
+    // Linux uses our own GTK drag (`start_file_drag`): tauri-plugin-drag's GTK
+    // backend hands external targets an EMPTY payload — it tears down its
+    // drag-data-get handler at drop-performed, before the target requests the
+    // text/uri-list data — so a drop into a browser silently did nothing (it
+    // also ships unencoded file:// URIs, which strict consumers discard).
+    if (PLATFORM === "linux") {
+      void invoke("start_file_drag", { paths }).catch((err) =>
+        // Surfaces the most common failure: the backend wasn't rebuilt, so the
+        // command doesn't exist yet — the drag silently no-ops otherwise.
+        console.error("[eldrun] native file drag-out failed:", err),
       );
+      return;
     }
+    const begin = (icon: string) =>
+      startDrag({ item: paths, icon, mode: "copy" })
+        .then(() => dragDbg("startDrag resolved")) // TEMPORARY drag QA
+        .catch((err) => {
+          dragDbg(`startDrag FAILED: ${String(err)}`); // TEMPORARY drag QA
+          // Same visibility for the plugin path (`plugin:drag|start_drag` and
+          // `drag_preview_icon` only exist after a backend rebuild).
+          console.error("[eldrun] native file drag-out failed:", err);
+        });
+    // The icon data URL is normally warm by drag time; if not, resolve first.
+    if (dragIconDataUrl) void begin(dragIconDataUrl);
+    else void warmDragIcon().then(begin);
+  }
+
+  function handleEntryDragStart(e: React.DragEvent<HTMLDivElement>, entry: FileEntry) {
+    // WebKitGTK's HTML5 drag-out renders no drag image outside the window and
+    // doesn't reliably export the file to other apps, so suppress it and hand
+    // off to the native OS drag.
+    e.preventDefault();
+    dragDbg(`dragstart fired ${entry.name} iconWarm=${!!dragIconDataUrl}`); // TEMPORARY drag QA
+    // Dragging a row that belongs to a >1 selection exports the whole
+    // selection, mirroring the pointer drag-to-tab's multi-drag.
+    const paths =
+      selected.has(entry.path) && selected.size > 1
+        ? entries.filter((en) => selected.has(en.path)).map((en) => en.path)
+        : [entry.path];
+    beginNativeFileDrag(paths);
   }
 
   // Start a pointer-based drag from a file row, mirroring TabBar.onTabPointerDown.
@@ -387,33 +1463,138 @@ export function FileTree({
   function onEntryPointerDown(
     e: React.PointerEvent,
     entry: FileEntry,
-    viewer: InternalViewer | null,
+    dragTarget: InternalViewer | "embed" | null,
   ) {
     if (e.button !== 0 || entry.is_dir) return;
-    // Alt held → the user wants to EXPORT this file (drag it into an embedded
-    // browser / external target) via native HTML5 DnD, which the row arms while
-    // `altHeld` (see renderEntry's `draggable`/`onDragStart`). Bail out without
-    // preventDefault so native DnD takes over instead of the pointer drag-to-tab.
-    if (e.altKey) return;
+    // TEMPORARY drag QA
+    dragDbg(`pdown ${entry.name} ctrl=${e.ctrlKey} shift=${e.shiftKey} target=${dragTarget ?? "none"}`);
+    // A built-in viewer drives the in-app drop; "embed" means an external
+    // handler, so no viewer. `canTab` is whether this file can land on a tab bar
+    // / new window at all — only such files take the commitFileDrop path on
+    // release. Files without a tab target are still draggable, but ONLY to move
+    // them into a folder (drag-to-move); released anywhere else they do nothing.
+    const viewer = dragTarget === "embed" ? null : dragTarget;
+    const canTab = dragTarget != null;
+    // Multi-selection drag: if the pressed row belongs to a >1 selection, the
+    // whole selection is dragged; otherwise just this row. `dragEntries` (files
+    // + folders) drives drag-to-move; `dragFiles` (file members only, with their
+    // built-in viewer resolved) is the tab/window drop payload — folders can move
+    // but never become tabs. A release over a tab bar / split / new window
+    // creates tabs when `canDrop`: for a single drag only a viewer/embed file
+    // qualifies (unchanged); for a multi drag any file member becomes an embed
+    // tab.
+    const isMultiDrag = selected.has(entry.path) && selected.size > 1;
+    const dragEntries = isMultiDrag ? entries.filter((en) => selected.has(en.path)) : [entry];
+    const dragFiles: FileDragItem[] = dragEntries
+      .filter((en) => !en.is_dir)
+      .map((en) => ({ path: en.path, name: en.name, viewer: internalViewerFor(en, disabledViewerSet) ?? undefined }));
+    const canDrop = isMultiDrag ? dragFiles.length > 0 : canTab;
+    // Ctrl held → the user wants to EXPORT/COPY this file out to another app
+    // (Signal, a browser, a file manager). The row arms HTML5 `draggable` while
+    // `ctrlHeld` (see renderEntry); its onDragStart suppresses the broken
+    // WebKitGTK drag and hands off to the native OS drag (handleEntryDragStart).
+    // Bail out here without preventDefault so that gesture takes over instead of
+    // the pointer drag-to-tab.
+    if (e.ctrlKey) {
+      dragDbg("pdown: ctrl bail → native dnd expected (a 'dragstart fired' line should follow)"); // TEMPORARY drag QA
+      return;
+    }
     // Let the inline run (▶) button own its own clicks — don't seed a drag or
     // swallow the click when the press lands on it.
     if ((e.target as HTMLElement).closest(".file-run-btn")) return;
     e.preventDefault();
     const startX = e.clientX;
     const startY = e.clientY;
+    const pointerId = e.pointerId;
+    const captureEl = e.currentTarget as HTMLElement;
     let dragging = false;
+    // #42: an open popout of the current scope is a valid drop target — releasing
+    // the file over one docks it there as an embed tab instead of spawning a new
+    // window. SAME shared session the tab drag (TabBar) uses, so a file dragged
+    // over a popout behaves exactly like one dragged over the main window.
+    const detached = startDetachedDropSession();
+
+    // Latest in-window client coords ("outside this window" test) and the latest
+    // physical desktop cursor (cross-window hit-test, poll-driven — see lib/coords;
+    // DOM screenX/Y units diverge across WebKitGTK/WebView2/WKWebView).
+    let lastClient = { x: startX, y: startY };
+    let lastPhys: PhysPoint | null = null;
+    let stopPoll: (() => void) | null = null;
+
+    // Mid-drag Ctrl → arms the native OS EXPORT drag (copy the file(s) out to
+    // whatever app the cursor ends up over). Ctrl *before* the press is the
+    // multi-select toggle, so export is armed by pressing Ctrl AFTER the drag
+    // is underway — symmetric with Shift, which modifies the drop while
+    // already dragging (see DragGhost's modifier highlight). Mirrors that:
+    // holding Ctrl only MARKS the ghost's "copy out" option; the in-app hover
+    // (ghost, folder highlight, popout hover) keeps running unchanged.
+    //
+    // The gesture then switches between two modes at the WINDOW BOUNDARY, and
+    // can switch back and forth as often as the user likes:
+    //  - leaving the window with Ctrl held → the OS drag takes over the still-
+    //    held button (GTK can only BEGIN a drag while the button is physically
+    //    down, so the crossing is the last moment this is possible), and a
+    //    release out there drops into the external app.
+    //  - coming back INTO the window → the OS drag is cancelled and the in-app
+    //    ghost/hover resumes, so re-entering never leaves the user staring at
+    //    an OS drag icon over Eldrun's own window.
+    // While the OS owns the drag the webview sees no pointer events at all, so
+    // the boundary test runs off the OS-cursor poll (physical px → this
+    // window's client px via the frame snapshot), which keeps ticking
+    // regardless of who holds the pointer grab.
+    let nativeActive = false;
+    let frame: WindowFrame | null = null;
+    // The `eldrun:file-drag-ended` subscription (registered below, once the
+    // gesture is real) and whether the gesture has already ended — `listen` is
+    // async, so it can resolve after cleanup and must then unsubscribe at once.
+    let unlistenEnded: (() => void) | null = null;
+    let gestureOver = false;
+    const inWindow = (c: { x: number; y: number }) =>
+      c.x >= 0 && c.y >= 0 && c.x < window.innerWidth && c.y < window.innerHeight;
+    const toNativeDrag = () => {
+      if (!dragging || nativeActive) return;
+      nativeActive = true;
+      // The in-app drop targets are meaningless while the OS owns the drag.
+      setMoveTarget(null);
+      detached.hover(null, { x: 0, y: 0 }, entry.name);
+      beginNativeFileDrag(dragEntries.map((en) => en.path));
+    };
+    const backToInAppDrag = () => {
+      if (!nativeActive) return;
+      nativeActive = false;
+      void invoke("cancel_file_drag").catch(() => {});
+    };
+    // Ctrl, tracked as gesture state rather than read off each pointer event.
+    // Cancelling the GTK drag hands the pointer back, but NOT the implicit grab
+    // the original pointerdown had: the webview then sees plain mousemove while
+    // the cursor is over the window and NOTHING once it leaves. So after one
+    // handoff, `PointerEvent.ctrlKey` stops arriving exactly where the next
+    // handoff would need it — hence a flag the key events maintain, plus the
+    // cursor poll below as the position source. (The keydown arm also covers
+    // Ctrl pressed while the cursor already sits outside the window.)
+    let ctrlDown = false;
+    const onKeyDown = (ev: KeyboardEvent) => {
+      if (ev.key !== "Control") return;
+      ctrlDown = true;
+      if (dragging && !inWindow(lastClient)) toNativeDrag();
+    };
+    const onKeyUp = (ev: KeyboardEvent) => {
+      if (ev.key === "Control") ctrlDown = false;
+    };
 
     const onMove = (ev: PointerEvent) => {
       if (!dragging) {
         if (Math.hypot(ev.clientX - startX, ev.clientY - startY) < 5) return;
         dragging = true;
+        dragDbg(`drag engaged ${entry.name}`); // TEMPORARY drag QA
         useDragStore.getState().startFileDrag({
-          label: entry.name,
+          label: isMultiDrag ? `${dragEntries.length} items` : entry.name,
           pointerX: ev.clientX,
           pointerY: ev.clientY,
           filePath: entry.path,
           fileName: entry.name,
           viewer: viewer ?? undefined,
+          files: isMultiDrag ? dragFiles : undefined,
         });
         // Built-in viewers render in-app and need no external handler, so skip
         // the embed-capability probe for them. For other embeddable files,
@@ -423,67 +1604,503 @@ export function FileTree({
             .then((cap) => useDragStore.getState().setEmbedCap(cap))
             .catch(() => useDragStore.getState().setEmbedCap(null));
         }
+        // Begin resolving popout drop targets now that a real drag is underway.
+        void detached.resolve();
+        // Capture the terminal pointer event on engines that don't keep delivering
+        // it past the source window's HWND (Win/mac); WebKitGTK keeps the implicit
+        // grab, so the flag leaves capture off there.
+        if (dragPlatform.needsPointerCapture) {
+          try {
+            captureEl.setPointerCapture(pointerId);
+            dragDbg("pointer capture ok"); // TEMPORARY drag QA
+          } catch (err) {
+            dragDbg(`pointer capture FAILED: ${String(err)}`); // TEMPORARY drag QA
+            /* capture is best-effort; the OS-cursor poll does not depend on it */
+          }
+        }
+        // This window's geometry, for mapping the polled OS cursor back into
+        // client px while the OS drag owns the pointer (see `nativeActive`).
+        void snapshotFrame()
+          .then((f) => {
+            frame = f;
+          })
+          .catch(() => {});
+        // Poll the OS cursor (physical desktop px) to drive the popout hover past
+        // the main viewport — DOM pointermove may not cross the OS window boundary.
+        stopPoll = startCursorPoll((p) => {
+          lastPhys = p;
+          // The poll is the SOLE arbiter of the window boundary, in BOTH
+          // directions. DOM pointer events can't be: once the OS drag has run
+          // even once, the implicit grab is gone, so they stop at the window
+          // edge — exactly where the crossing has to be detected.
+          const c = frame ? physToClient(frame, p) : null;
+          if (nativeActive) {
+            if (!c) return;
+            // The OS owns the pointer: this poll is also the only position
+            // source, so keep the ghost tracking the cursor for the moment it
+            // comes back in — whereupon the OS drag is cancelled and the
+            // in-app hover takes over again.
+            lastClient = c;
+            useDragStore.getState().move(c.x, c.y);
+            if (inWindow(c)) backToInAppDrag();
+            return;
+          }
+          if (c && ctrlDown && !inWindow(c)) {
+            toNativeDrag();
+            return;
+          }
+          detached.hover(detached.at(p), p, entry.name);
+        });
       }
+      // While the OS drag owns the pointer, a stray DOM move must not fight the
+      // poll for the ghost position or revive the in-app drop targets.
+      if (nativeActive) return;
+      ctrlDown = ev.ctrlKey;
+      lastClient = { x: ev.clientX, y: ev.clientY };
       useDragStore.getState().move(ev.clientX, ev.clientY);
+      // Drag-to-move: highlight the folder row / breadcrumb / up button under the
+      // cursor as the destination. The drag ghost is pointer-events:none, so
+      // elementFromPoint reaches the rows beneath it. A target whose rel matches
+      // the file's current folder is a no-op and is ignored.
+      const overEl = document.elementFromPoint(ev.clientX, ev.clientY) as HTMLElement | null;
+      const moveEl = overEl?.closest<HTMLElement>("[data-move-rel]") ?? null;
+      const moveRel = moveEl?.getAttribute("data-move-rel") ?? null;
+      setMoveTarget(moveRel != null && moveRel !== relPath ? moveRel : null);
+      // Inside a detached popout, CenterPanel's window-wide drop authority isn't
+      // there to resolve the pane under the cursor — do it here so the popout's
+      // split/merge preview lights up and the release has a target to commit to.
+      // (In the main window CenterPanel owns this; `fileDrop` is null there.)
+      if (fileDrop) fileDrop.resolveTarget(ev.clientX, ev.clientY);
     };
-    const onUp = (ev: PointerEvent) => {
+
+    // Tear down the move listener, poll, popout highlight, and pointer capture —
+    // however the gesture resolves.
+    const cleanup = () => {
+      gestureOver = true;
       window.removeEventListener("pointermove", onMove);
-      window.removeEventListener("pointerup", onUp);
+      window.removeEventListener("keydown", onKeyDown);
+      window.removeEventListener("keyup", onKeyUp);
+      setMoveTarget(null);
+      stopPoll?.();
+      unlistenEnded?.();
+      unlistenEnded = null;
+      // Clear the popout highlight + tear down the panes listener. `targetAt`
+      // still hit-tests the cached pane geometry for the commit below.
+      detached.dispose();
+      if (dragPlatform.needsPointerCapture) {
+        try {
+          captureEl.releasePointerCapture(pointerId);
+        } catch {
+          /* ignore */
+        }
+      }
+    };
+
+    const commitRelease = async (shiftKey: boolean) => {
+      // The OS owns the drag: it is dropping into an external app, and the
+      // in-app drop targets don't apply. `eldrun:file-drag-ended` ends the
+      // gesture instead (a stray pointerup here must not ALSO spawn a tab or a
+      // window on top of the export).
+      if (nativeActive) return;
+      // Read the drop-target folder BEFORE cleanup() runs — cleanup calls
+      // setMoveTarget(null), which nulls moveTargetRef.current, so reading it
+      // afterwards always saw null and silently dropped every drag-to-move (the
+      // file just stayed put). See git dfcb6e0, which introduced the read below
+      // the cleanup() call.
+      const moveRel = moveTargetRef.current;
+      // TEMPORARY drag QA
+      dragDbg(`commit shift=${shiftKey} dragging=${dragging} moveRel=${moveRel ?? "null"} canDrop=${canDrop}`);
+      cleanup();
       if (!dragging) {
         // Never moved → a plain click does NOT open. Opening a file is a
         // double-click (onDoubleClick → handleClick); dragging it onto a tab bar
         // is the other gesture. So a single click is a no-op here.
         return;
       }
+      // Drag-to-move takes precedence: released over a folder / breadcrumb in the
+      // tree → relocate the file(s) there. This is the one gesture available to
+      // ALL files (even those with no tab/viewer target). When a multi-selection
+      // is being dragged, every selected file moves.
+      if (moveRel != null) {
+        useDragStore.getState().end();
+        for (const de of dragEntries) {
+          await moveEntryToFolder(relForEntry(de), de.name, moveRel, de.path);
+        }
+        return;
+      }
       const d = useDragStore.getState().drag;
-      if (d != null) {
-        // Released OUTSIDE the main window (e.g. dragged onto another monitor):
-        // open the file in its own standalone detached window at the cursor. The
-        // pointer's implicit capture keeps delivering coords past the viewport,
-        // so client coords outside [0,inner) is the outside-the-window signal.
-        const outside =
-          ev.clientX < 0 ||
-          ev.clientY < 0 ||
-          ev.clientX >= window.innerWidth ||
-          ev.clientY >= window.innerHeight;
-        const detachBounds = outside
+      if (d == null) return;
+      // A file with no tab/viewer/embed target can only be moved (handled above);
+      // released anywhere else it does nothing — never leak it out as an external
+      // open or an empty embed tab. (Multi drags qualify when any file member can
+      // become a tab — see `canDrop`.)
+      if (!canDrop) {
+        useDragStore.getState().end();
+        return;
+      }
+      // Inside a detached popout: commit against the pane resolved above by the
+      // injected controller (a new embed tab into that pane, streamed to the main
+      // window as an `add` edit). The main window's cross-window branches below —
+      // dock into ANOTHER popout, spawn a new standalone window — don't apply
+      // here (a popout can't own the main tab store), so this is the whole commit.
+      if (fileDrop) {
+        fileDrop.commit(d, projectDir);
+        useDragStore.getState().end();
+        return;
+      }
+      // Final physical cursor at release (a fresh read; falls back to the last
+      // poll reading if the IPC fails). This is the canonical cross-window space.
+      const phys = (await desktopCursor().catch(() => null)) ?? lastPhys;
+      // Released over an open popout → dock the file into it as an embed tab,
+      // landing in the SPECIFIC pane the popout resolved under the cursor (mirrors
+      // a tab dragged onto a popout). BUT only if the popout is actually the front
+      // window at the drop point: its bounds can geometrically contain the cursor
+      // while it sits BEHIND the main window (the press raised the main window) or
+      // another app. Docking into a popout the user can't see is wrong — treat an
+      // occluded popout like a release into empty space so a NEW window opens.
+      // Shift forces a brand-new standalone window even when released over a
+      // front popout — the explicit "don't dock here, give me a fresh window"
+      // override the user asked for.
+      const overDetached = phys ? detached.at(phys) : null;
+      const overFrontDetached =
+        !shiftKey &&
+        overDetached &&
+        (await invoke<boolean>("detached_window_frontmost", {
+          registryId: overDetached.label,
+        }).catch(() => true));
+      if (overDetached && overFrontDetached && phys) {
+        commitFileDrop(d, projectId, projectDir, null, {
+          scope: overDetached.scope,
+          groupId: overDetached.groupId,
+          target: detached.targetAt(overDetached, phys),
+        });
+        useDragStore.getState().end();
+        return;
+      }
+      // Released OUTSIDE the main window (e.g. dragged onto another monitor):
+      // open the file in its own standalone detached window at the cursor. Client
+      // coords outside [0,inner) is the signal. The new window's bounds feed Rust
+      // `.position(x,y)`, which is PHYSICAL → use the physical cursor, not DOM
+      // screen coords.
+      //
+      // A popout under the cursor is NOT treated as "outside" here: a FRONT popout
+      // was already docked into above; an OCCLUDED popout (behind the main window)
+      // means the main window is what's actually under the cursor, so the release
+      // must fall through to the in-window split — spawning a new window the user
+      // can't see they're aiming at is exactly the bug this avoids.
+      //
+      // Shift forces a new window even when released INSIDE the main window: the
+      // split/dock preview was suppressed during the drag (see CenterPanel's
+      // pointer-move handler), so the only sensible commit is a fresh window.
+      const outside = fileDropGoesToNewWindow({
+        shiftKey,
+        lastClient,
+        viewport: { w: window.innerWidth, h: window.innerHeight },
+      });
+      const detachBounds =
+        outside && phys
           ? {
-              x: Math.round(ev.screenX - 80),
-              y: Math.round(ev.screenY - 8),
+              x: Math.round(phys.x - 80),
+              y: Math.round(phys.y - 8),
               w: 900,
               h: 640,
             }
           : null;
-        commitFileDrop(d, projectId, projectDir, detachBounds);
-        useDragStore.getState().end();
+      // TEMPORARY drag QA
+      dragDbg(
+        `commitFileDrop outside=${outside} reorder=${d.reorderGroup ?? "-"}@${d.reorderIndex ?? "-"} over=${d.overGroup ?? "-"} edge=${d.edge ?? "-"}`,
+      );
+      commitFileDrop(d, projectId, projectDir, detachBounds);
+      useDragStore.getState().end();
+    };
+
+    // Escape / blur / a genuine pointercancel (Win/mac) aborts: tear down and drop
+    // any in-flight drag without committing.
+    const onAbort = () => {
+      dragDbg(`file drag abort (dragging=${dragging})`); // TEMPORARY drag QA
+      cleanup();
+      if (dragging) useDragStore.getState().end();
+    };
+
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("keydown", onKeyDown);
+    window.addEventListener("keyup", onKeyUp);
+    const unbindRelease = bindDragRelease({
+      onCommit: (shiftKey) => void commitRelease(shiftKey),
+      onAbort,
+    });
+    // Once the OS drag owns the pointer, the webview never sees the release, so
+    // the backend reports the drop (or the user's abort) that ends the whole
+    // gesture. NOT fired by the cancel we ourselves issue on re-entry — that
+    // hands control back to the in-app drag, which is still very much alive.
+    void listen("eldrun:file-drag-ended", () => {
+      unbindRelease();
+      onAbort();
+    }).then((un) => {
+      // `listen` is async: the gesture can already be over when it resolves.
+      if (gestureOver) un();
+      else unlistenEnded = un;
+    });
+  }
+
+  function relForEntry(entry: FileEntry): string {
+    return relPath ? `${relPath}/${entry.name}` : entry.name;
+  }
+
+  // Set the current drag-to-move drop target (a folder rel path, "" = project
+  // root, null = none). Keeps the ref (read by the release handler) and the
+  // highlight state in sync; the setter is a no-op when unchanged so dragging
+  // over the same folder doesn't churn renders.
+  function setMoveTarget(rel: string | null) {
+    moveTargetRef.current = rel;
+    setMoveTargetRel((prev) => (prev === rel ? prev : rel));
+  }
+
+  // Relocate a dragged file into a folder shown in the tree (drag-to-move). The
+  // backend `move_path` works the same for local and remote (SFTP) projects. A
+  // name collision in the destination aborts with an error rather than silently
+  // clobbering — moving is meant to be safe.
+  async function moveEntryToFolder(sourceRel: string, name: string, destFolderRel: string, sourceAbs: string) {
+    const destRel = destFolderRel ? `${destFolderRel}/${name}` : name;
+    setLoading(true);
+    setError(null);
+    try {
+      const exists = await invoke<boolean>("project_path_exists", {
+        projectDir,
+        relPath: destRel,
+      }).catch(() => false);
+      if (exists) {
+        setError(`"${name}" already exists in ${destFolderRel || "the project root"}`);
+        setLoading(false);
+        return;
+      }
+      await invoke("move_path", {
+        srcProjectDir: projectDir,
+        srcRel: sourceRel,
+        destProjectDir: projectDir,
+        destRel,
+      });
+      // Retarget any open viewer tab of the moved file/folder (main + detached).
+      // `sourceAbs` ends with `sourceRel`, so swapping that tail for `destRel`
+      // yields the new absolute path without rebuilding it from `projectDir`.
+      const newAbs = `${sourceAbs.slice(0, sourceAbs.length - sourceRel.length)}${destRel}`;
+      retargetTabsForRenamedPath(sourceAbs, newAbs);
+      await load(relPath);
+    } catch (err) {
+      setError(String(err));
+      setLoading(false);
+    }
+  }
+
+  function showEntryContextMenu(e: React.MouseEvent<HTMLDivElement>, entry: FileEntry) {
+    e.preventDefault();
+    e.stopPropagation();
+    cancelTooltipTimer();
+    setTooltip(null);
+    // Right-clicking a row that ISN'T part of the current selection resets the
+    // selection to just it (standard file-manager behavior); right-clicking one
+    // that IS keeps the whole multi-selection so the menu can act on all of it.
+    if (!selected.has(entry.path)) {
+      setSelected(new Set([entry.path]));
+      anchorRef.current = entry.path;
+    }
+    const row = e.currentTarget.getBoundingClientRect();
+    setContextMenu({
+      x: e.clientX,
+      y: e.clientY,
+      entry,
+      rowRect: { left: row.left, top: row.top, width: row.width, height: row.height },
+    });
+    probeClipboardImage();
+  }
+
+  async function stageEntry(entry: FileEntry) {
+    setContextMenu(null);
+    setLoading(true);
+    setError(null);
+    try {
+      await invoke("git_add_path", { projectDir, relPath: relForEntry(entry) });
+      await load(relPath);
+    } catch (err) {
+      setError(String(err));
+      setLoading(false);
+    }
+  }
+
+  /** Open the in-app diff viewer for a file. The DiffView viewer resolves the
+   *  absolute source path and asks the backend (`git_diff_file`) for the diff,
+   *  so we just hand it the path. Re-opening drops any prior diff tab for the
+   *  same path (mirrors openPdfTab) so the diff refreshes. */
+  function showDiff(entry: FileEntry) {
+    setContextMenu(null);
+    const store = useTabsStore.getState();
+    const prior = store.tabs.find(
+      (t) => t.kind === "embed" && t.viewer === "diff" && t.embedPath === entry.path,
+    );
+    if (prior) store.removeTab(prior.key);
+    store.addTab({
+      label: entry.name,
+      cmd: "",
+      cwd: projectDir,
+      kind: "embed",
+      embedPath: entry.path,
+      viewer: "diff",
+    });
+  }
+
+  /** SSH-sync: open a diverged (amber) file in the three-way merge viewer — the
+   *  same PyCharm-style resolve view the orange list opens (local mirror ⇄ merged
+   *  ⇄ remote host, per-block take-left/right) — instead of the old
+   *  take-local/take-host popup. On open the viewer runs a byte-for-byte test and
+   *  self-resolves a metadata-only divergence (identical bytes).
+   *
+   *  `SyncMergeView` keys off the mirror-side absolute path (`mirrorRoot/rel`), so
+   *  build that here from `relForEntry` regardless of which side the tree is
+   *  currently listing (the host path is not under the mirror). */
+  function openSyncMerge(entry: FileEntry) {
+    setContextMenu(null);
+    if (!projectId || !mirrorRoot) return;
+    const rel = relForEntry(entry);
+    const abs = `${mirrorRoot.replace(/[/\\]+$/, "")}/${rel}`;
+    const tab = {
+      label: basename(abs) || entry.name,
+      cmd: "",
+      cwd: dirname(abs),
+      kind: "embed" as const,
+      embedPath: abs,
+      viewer: "syncmerge" as const,
+    };
+    // In a detached popout, stream the tab into that window (its store is
+    // authoritative); otherwise reuse an already-open merge tab for this exact
+    // file, else add a fresh one to the focused subwindow.
+    if (fileDrop) {
+      fileDrop.openTab(tab);
+      return;
+    }
+    const store = useTabsStore.getState();
+    const prior = store.tabs.find(
+      (t) => t.kind === "embed" && t.viewer === "syncmerge" && t.embedPath === abs,
+    );
+    if (prior) store.setActive(prior.key);
+    else store.setActive(store.addTab(tab).key);
+  }
+
+  // SSH-sync Phase 1: pull this file/folder into the local mirror (and mark it
+  // selected), or stop tracking it. Remote source view only.
+  async function syncEntryToLocal(entry: FileEntry) {
+    setContextMenu(null);
+    if (!projectId) return;
+    try {
+      await syncPull(projectId, relForEntry(entry));
+    } catch (err) {
+      setError(String(err));
+    }
+  }
+
+  async function stopSyncingEntry(entry: FileEntry) {
+    setContextMenu(null);
+    if (!projectId) return;
+    try {
+      await syncMarkSelected(projectId, [relForEntry(entry)], false, entry.is_dir);
+    } catch (err) {
+      setError(String(err));
+    }
+  }
+
+  // Auto-sync: toggle background bidirectional sync for a file or (recursively) a
+  // folder. Turning it on implies tracking; the backend engine reconciles it on
+  // its next pass, skipping anything diverged (orange).
+  //
+  // Turning it ON over a FOLDER is the one click in the app that can start hauling
+  // a host tree down in bulk, and byte-sync does not read `.gitignore` — so a
+  // deliberately host-side directory (experiment output, checkpoints) is not
+  // protected by being gitignored the way it is from lockstep. Price it first and
+  // make the user confirm when the answer is big; small folders just proceed.
+  // Exclude a folder from byte-sync outright — the durable form of "leave this
+  // on the host / leave this on my machine". Unlike auto-off it is honoured by
+  // the whole-project pull and push too; it is the same marker the large-folder
+  // setup prompt (`BigFolderExcludeDialog`) writes, so a folder answered for
+  // there reads back correctly here (and can be undone here).
+  async function toggleSyncExcluded(entry: FileEntry, excluded: boolean) {
+    setContextMenu(null);
+    if (!projectId) return;
+    try {
+      await syncSetExcluded(projectId, [relForEntry(entry)], excluded);
+    } catch (err) {
+      setError(String(err));
+    }
+  }
+
+  async function toggleAutoSyncEntry(entry: FileEntry, on: boolean) {
+    setContextMenu(null);
+    if (!projectId) return;
+    if (on && entry.is_dir && isRemote) {
+      try {
+        const preview = await syncAutoPreview(projectId, relForEntry(entry));
+        if (preview.files > AUTO_SYNC_WARN_FILES || preview.bytes > AUTO_SYNC_WARN_BYTES) {
+          setAutoConfirm({ entry, ...preview });
+          return;
+        }
+      } catch {
+        // Preview is advisory (a cold pool, an unreadable dir). Failing to price
+        // the pull must not block the toggle the user explicitly asked for.
       }
-    };
-    window.addEventListener("pointermove", onMove);
-    window.addEventListener("pointerup", onUp);
+    }
+    await applyAutoSync(entry, on);
   }
 
-  function relForEntry(entry: FileEntry): string {
-    return relPath ? `${relPath}/${entry.name}` : entry.name;
+  // The write half of the toggle, shared by the direct path and the confirm modal.
+  async function applyAutoSync(entry: FileEntry, on: boolean) {
+    if (!projectId) return;
+    setAutoConfirm(null);
+    try {
+      await syncSetAuto(projectId, [relForEntry(entry)], on, entry.is_dir);
+    } catch (err) {
+      setError(String(err));
+    }
   }
 
-  function showEntryContextMenu(e: React.MouseEvent<HTMLDivElement>, entry: FileEntry) {
-    e.preventDefault();
-    e.stopPropagation();
-    setTooltip(null);
-    setContextMenu({ x: e.clientX, y: e.clientY, entry });
-    probeClipboardImage();
+  // SSH-sync Phase 2: push a local mirror file/folder up to the host. A push that
+  // a host change would clobber is blocked and queued for per-file resolution.
+  async function pushEntryToHost(entry: FileEntry) {
+    setContextMenu(null);
+    if (!projectId) return;
+    try {
+      const { conflicts } = await syncPush(projectId, relForEntry(entry), false);
+      if (conflicts.length > 0) setPushConflicts(conflicts);
+    } catch (err) {
+      setError(String(err));
+    }
   }
 
-  async function stageEntry(entry: FileEntry) {
+  // Push the whole local mirror up to the host (root context menu, local source).
+  async function pushAllToHost() {
     setContextMenu(null);
-    setLoading(true);
-    setError(null);
+    if (!projectId) return;
     try {
-      await invoke("git_add_path", { projectDir, relPath: relForEntry(entry) });
-      await load(relPath);
+      const { conflicts } = await syncPush(projectId, "", false);
+      if (conflicts.length > 0) setPushConflicts(conflicts);
     } catch (err) {
       setError(String(err));
-      setLoading(false);
+    }
+  }
+
+  // Resolve the first queued push conflict: keep-local force-pushes, take-host
+  // pulls the host copy back, skip drops it. Each advances the queue.
+  async function resolvePushConflict(action: "keep" | "host" | "skip") {
+    const rel = pushConflicts[0];
+    if (!rel || !projectId) return;
+    setPushBusy(true);
+    try {
+      if (action === "keep") await syncPush(projectId, rel, true);
+      else if (action === "host") await syncPull(projectId, rel);
+      // "skip" leaves both sides as-is.
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setPushBusy(false);
+      setPushConflicts((q) => q.slice(1));
+      await load(relPath);
     }
   }
 
@@ -505,9 +2122,9 @@ export function FileTree({
     }
   }
 
-  function promptDelete(entry: FileEntry) {
+  function promptDelete(targets: FileEntry[]) {
     setContextMenu(null);
-    setDeleteConfirm({ entry, relPath: relForEntry(entry) });
+    if (targets.length > 0) setDeleteConfirm({ entries: targets });
   }
 
   async function renameEntry(entry: FileEntry) {
@@ -522,6 +2139,12 @@ export function FileTree({
         oldRel: relForEntry(entry),
         newName: nextName.trim(),
       });
+      // Retarget any open viewer tab of this file (main + detached) to the new
+      // path. Derive the new absolute path by swapping the basename on the entry's
+      // own absolute path (== embedPath), so it holds for local and remote alike.
+      const oldAbs = entry.path;
+      const newAbs = `${oldAbs.slice(0, oldAbs.lastIndexOf("/") + 1)}${nextName.trim()}`;
+      retargetTabsForRenamedPath(oldAbs, newAbs);
       await load(relPath);
     } catch (err) {
       setError(String(err));
@@ -550,21 +2173,28 @@ export function FileTree({
     }
   }
 
-  function copyEntry(entry: FileEntry, op: "copy" | "cut") {
+  function copyEntries(targets: FileEntry[], op: "copy" | "cut") {
     setContextMenu(null);
-    setClipboard({
-      projectDir,
-      relPath: relForEntry(entry),
-      name: entry.name,
-      isDir: entry.is_dir,
-      op,
-    });
+    if (targets.length === 0) return;
+    setClipboardEntries(
+      targets.map((entry) => ({
+        projectDir,
+        relPath: relForEntry(entry),
+        path: entry.path,
+        name: entry.name,
+        isDir: entry.is_dir,
+        op,
+      })),
+    );
   }
 
   /** Suggest a name not already present in the current folder, appending
-   *  " copy"/" copy N" (before the extension) until it is free. */
-  function suggestPasteName(name: string): string {
+   *  " copy"/" copy N" (before the extension) until it is free. `extraTaken`
+   *  adds names already claimed earlier in a bulk paste (which hasn't re-listed
+   *  yet) so two pasted items can't collide with each other. */
+  function suggestPasteName(name: string, extraTaken?: ReadonlySet<string>): string {
     const taken = new Set(rawEntries.map((e) => e.name));
+    if (extraTaken) for (const n of extraTaken) taken.add(n);
     if (!taken.has(name)) return name;
     const dot = name.lastIndexOf(".");
     const stem = dot > 0 ? name.slice(0, dot) : name;
@@ -586,6 +2216,57 @@ export function FileTree({
     setPastePrompt({ kind: "image", name: suggestPasteName("screenshot.png"), error: null });
   }
 
+  // The context-menu Paste entry. A single clipboard item keeps its rename
+  // prompt (openPastePrompt); a multi-item clipboard pastes in bulk (pasteAll).
+  function renderPasteButton() {
+    if (clipboardEntries.length === 0) return null;
+    const multi = clipboardEntries.length > 1;
+    const move = clipboard?.op === "cut" ? " (move)" : "";
+    return (
+      <button onClick={() => (multi ? void pasteAll() : openPastePrompt())}>
+        {multi
+          ? `Paste ${clipboardEntries.length} items${move}`
+          : `Paste${move} “${clipboard?.name}”`}
+      </button>
+    );
+  }
+
+  // Paste a multi-item clipboard into the current folder in one go — no per-file
+  // rename prompt; each collision is auto-resolved with " copy". The single-item
+  // paste keeps its rename prompt (openPastePrompt / confirmPaste).
+  async function pasteAll() {
+    setContextMenu(null);
+    if (clipboardEntries.length === 0) return;
+    setLoading(true);
+    setError(null);
+    const claimed = new Set<string>();
+    try {
+      for (const cb of clipboardEntries) {
+        const newName = suggestPasteName(cb.name, claimed);
+        claimed.add(newName);
+        const destRel = relPath ? `${relPath}/${newName}` : newName;
+        await invoke(cb.op === "cut" ? "move_path" : "copy_path", {
+          srcProjectDir: cb.projectDir,
+          srcRel: cb.relPath,
+          destProjectDir: projectDir,
+          destRel,
+        });
+        // Same-project cut relocates within this tree → retarget any open viewer
+        // tab of the moved file (mirrors confirmPaste's single-item handling).
+        if (cb.op === "cut" && cb.projectDir === projectDir) {
+          const oldAbs = cb.path;
+          const newAbs = `${oldAbs.slice(0, oldAbs.length - cb.relPath.length)}${destRel}`;
+          retargetTabsForRenamedPath(oldAbs, newAbs);
+        }
+      }
+      if (clipboardEntries.some((c) => c.op === "cut")) clearClipboard();
+      await load(relPath);
+    } catch (err) {
+      setError(String(err));
+      setLoading(false);
+    }
+  }
+
   async function confirmPaste() {
     if (!pastePrompt) return;
     const newName = pastePrompt.name.trim();
@@ -606,7 +2287,18 @@ export function FileTree({
           destProjectDir: projectDir,
           destRel,
         });
-        if (clipboard.op === "cut") clearClipboard();
+        if (clipboard.op === "cut") {
+          // A same-project cut relocates within this scope's tree, so retarget any
+          // open viewer tab of the moved file (main + detached). A cross-project
+          // cut lands in a different scope than the source tab, which this
+          // current-scope helper doesn't own, so leave it (reopen to refresh).
+          if (clipboard.projectDir === projectDir) {
+            const oldAbs = clipboard.path;
+            const newAbs = `${oldAbs.slice(0, oldAbs.length - clipboard.relPath.length)}${destRel}`;
+            retargetTabsForRenamedPath(oldAbs, newAbs);
+          }
+          clearClipboard();
+        }
       }
       setPastePrompt(null);
       await load(relPath);
@@ -619,8 +2311,9 @@ export function FileTree({
 
   function showRootContextMenu(e: React.MouseEvent<HTMLDivElement>) {
     e.preventDefault();
+    cancelTooltipTimer();
     setTooltip(null);
-    setContextMenu({ x: e.clientX, y: e.clientY, entry: null });
+    setContextMenu({ x: e.clientX, y: e.clientY, entry: null, rowRect: null });
     probeClipboardImage();
   }
 
@@ -635,15 +2328,20 @@ export function FileTree({
 
   async function confirmDelete() {
     if (!deleteConfirm) return;
-    const target = deleteConfirm;
+    const targets = deleteConfirm.entries;
     setDeleteConfirm(null);
     setLoading(true);
     setError(null);
     try {
-      await invoke(target.entry.is_dir ? "delete_dir" : "delete_file", {
-        projectDir,
-        relPath: target.relPath,
-      });
+      for (const entry of targets) {
+        await invoke(entry.is_dir ? "delete_dir" : "delete_file", {
+          projectDir,
+          relPath: relForEntry(entry),
+        });
+        // Close any open viewer tab for the deleted file/folder (main + detached).
+        closeTabsForDeletedPath(entry.path);
+      }
+      clearSelection();
       await load(relPath);
     } catch (err) {
       setError(String(err));
@@ -654,23 +2352,84 @@ export function FileTree({
   function runShellScript(event: React.MouseEvent<HTMLButtonElement>, entry: FileEntry) {
     event.preventDefault();
     event.stopPropagation();
-    if (runInBackground) {
+    const remoteForegroundOnly = remoteListing;
+    if (runInBackground && !remoteForegroundOnly) {
       // Detached spawn: no tab, no captured output. The activity store tracks
       // the run (and the app-lifetime `script-finished` listener clears it) so
       // the spinner survives right-panel hide/show — see TODO group R #34.
       runScript(entry.path, projectDir);
       return;
     }
-    const scriptRel = relFromAbs(projectDir, entry.path);
-    addTab({
-      label: entry.name,
-      cmd: "bash",
-      cwd: projectDir,
-      kind: "shell",
-      initialInput: `bash ${shellQuote(scriptRel)}`,
+    const interp = shellRunnerFor(entry.extension, PLATFORM) as ScriptShell | null;
+    if (!interp) return; // not a shell type we know how to run
+    const plan = shellScriptRunPlan({
+      project,
+      treeRoot: projectDir,
+      syncSource,
+      scriptPath: entry.path,
+      interp,
+      // Run on the machine chosen in the RunHostPicker (the same preference the
+      // Python Run honours), so "pick machine X ⇒ all shells run on X".
+      runHostPref: projectId
+        ? useRunHostPrefStore.getState().byProject[projectId]
+        : undefined,
+    });
+    if (!plan) {
+      setError(`Run failed: ${entry.path} is outside the current project tree`);
+      return;
+    }
+    const tab = {
+      label: `▶ ${entry.name}`,
+      cmd: interp,
+      cwd: plan.cwd,
+      kind: "shell" as const,
+      initialInput: plan.initialInput,
+      runFile: entry.path,
+      location: plan.location,
+    };
+    // Same placement policy as the Python Run: stream into a detached popout when
+    // we're in one, else the focused subwindow of this project. Preceded by the
+    // same login-node gate the Python Run has: if `plan.location` resolves to a
+    // machine tagged HPC, running a script there is asked about first
+    // (`lib/hpcGuard.ts`) — a script is the likeliest thing on this menu to be
+    // actual compute.
+    void guardLoginNodeRun({
+      projectId,
+      location: plan.location,
+      kind: "login-node-run",
+    }).then((ok) => {
+      if (!ok) return;
+      if (fileDrop) fileDrop.openTab(tab);
+      else useTabsStore.getState().addTabToScope(projectId ?? "root", tab);
     });
   }
 
+  /** Run a Python file: open a terminal tab in the project's scope running the
+   *  project's interpreter on it. Same mechanism as the viewer's Run button
+   *  (`lib/pythonRun`), so it inherits remote-host/container locality and picks
+   *  up the project's pinned/auto-detected interpreter. */
+  function runPythonScript(event: React.MouseEvent<HTMLButtonElement>, entry: FileEntry) {
+    event.preventDefault();
+    event.stopPropagation();
+    launchPython(entry, pyArgsByPath[entry.path]);
+  }
+
+  /** Open a run terminal for `entry`, appending `args` to the command line (see
+   *  `lib/pythonRun`). Same placement as the viewer's Run; failures surface into
+   *  the tree's error banner. */
+  function launchPython(entry: FileEntry, args?: string) {
+    runPythonFile({
+      file: entry.path,
+      projectDir: runCwd(projectDir, entry.path),
+      scope: projectId ?? "root",
+      projectId,
+      args,
+      // In a detached popout `fileDrop` is set → the tab streams into that window;
+      // in the main window it lands in the project's focused subwindow.
+      place: placeForFocused(fileDrop),
+    }).catch((err) => setError(`Run failed: ${String(err)}`));
+  }
+
   /** Open (or refresh) the in-app PDF viewer tab for a freshly compiled PDF.
    *  The viewer reads the bytes once on mount, so on a recompile we drop any
    *  existing tab for this path and add a fresh one to pick up the new output. */
@@ -681,7 +2440,7 @@ export function FileTree({
     );
     if (prior) store.removeTab(prior.key);
     store.addTab({
-      label: pdfPath.split("/").filter(Boolean).pop() ?? pdfPath,
+      label: basename(pdfPath) || pdfPath,
       cmd: "",
       cwd: projectDir,
       kind: "embed",
@@ -765,94 +2524,499 @@ export function FileTree({
     );
   }
 
+  // Disconnected remote project: the tree can't be listed without freezing the
+  // app (sync remote commands on the main thread). Show a note and let the user
+  // reconnect from the header lamp; the tree re-lists once the pool is up.
+  if (remoteBlocked) {
+    return (
+      <div className="file-tree-empty">
+        {remoteSshState === "connecting"
+          ? "Connecting to the remote host…"
+          : "Disconnected — reconnect (header lamp) to browse files."}
+      </div>
+    );
+  }
+
+  // Whether the search results replace the browsed listing. The search box is
+  // only offered on a local-source tree (its backends walk the local path).
+  const canSearch = !remoteListing;
+  const searching = canSearch && search.trim().length > 0;
+  // Folder the search is confined to: the browsed folder by default, the whole
+  // project when "root" is chosen (or when already at the root).
+  const searchScope = searchRoot ? "" : relPath;
+  const scopeLabel = relPath ? basename(relPath) || relPath : "";
+
   return (
     <div
+      ref={treeRootRef}
       className={`file-tree${isDragOver ? " drag-over" : ""}`}
+      tabIndex={0}
       onDragOver={handleDragOver}
       onDragLeave={handleDragLeave}
       onDrop={handleDrop}
+      onKeyDown={handleTreeKeyDown}
       onMouseDown={() => setContextMenu(null)}
       onContextMenu={showRootContextMenu}
     >
-      {relPath && (
-        <div className="file-tree-breadcrumb">
-          <button className="file-tree-up" onClick={goUp} title="Go up">↑</button>
-          <button className="file-tree-crumb" onClick={() => load("")} title="Project root">⌂</button>
+      {/* Sticky header: the remote/refresh bar, the in-tree search box and the
+          breadcrumb path line stay pinned while the tree body scrolls (the sort
+          row lives above the scroll container and is already fixed). They share
+          ONE sticky wrapper so they stack instead of each pinning to top:0 and
+          colliding — which is what hid the path line behind the search box.
+          Shared by the right panel and the Files (Project) tab (both render
+          FileTree), so both get the fixed path line. */}
+      <div className="file-tree-head">
+      {remoteListing && (
+        <div className="file-tree-remote-bar" title="Remote project — live updates are off; refresh to re-list">
+          <button
+            className="file-tree-up file-tree-refresh"
+            onClick={() => { load(relPath); if (projectId) void refreshSyncStatus(projectId); }}
+            disabled={loading}
+            title="Refresh (re-list over SFTP)"
+            aria-label="Refresh"
+          >
+            ↻
+          </button>
+          <span className="file-tree-remote-label">remote</span>
+          {syncProgress && (
+            <span className="file-tree-sync-progress" title={`Syncing ${syncProgress.rel || "…"}`}>
+              ⟳ {syncProgress.done}/{syncProgress.total}
+            </span>
+          )}
+        </div>
+      )}
+      {canSearch && (
+        <div className="file-tree-search">
+          <div className="file-tree-search-row">
+            <input
+              type="text"
+              className="file-tree-search-input"
+              value={search}
+              placeholder={
+                searchMode === "name"
+                  ? searchScope
+                    ? `Find files in ${scopeLabel}…`
+                    : "Find files…"
+                  : searchScope
+                    ? `Search in ${scopeLabel}…`
+                    : "Search in files…"
+              }
+              spellCheck={false}
+              autoComplete="off"
+              onChange={(e) => setSearch(e.target.value)}
+              onKeyDown={(e) => {
+                // Keep the tree's Enter/Escape handler out of the input.
+                e.stopPropagation();
+                if (e.key === "Escape") setSearch("");
+              }}
+            />
+            {search && (
+              <button
+                type="button"
+                className="file-tree-search-clear"
+                title="Clear search"
+                aria-label="Clear search"
+                onClick={() => setSearch("")}
+              >
+                ×
+              </button>
+            )}
+          </div>
+          <div className="file-tree-search-modes">
+            <button
+              type="button"
+              className={`file-tree-search-mode${searchMode === "name" ? " active" : ""}`}
+              aria-pressed={searchMode === "name"}
+              onClick={() => setSearchMode("name")}
+              title="Search file and folder names"
+            >
+              Name
+            </button>
+            <button
+              type="button"
+              className={`file-tree-search-mode${searchMode === "content" ? " active" : ""}`}
+              aria-pressed={searchMode === "content"}
+              onClick={() => setSearchMode("content")}
+              title="Search inside file contents"
+            >
+              Content
+            </button>
+            {searchMode === "content" && (
+              <button
+                type="button"
+                className={`file-tree-search-mode${searchCase ? " active" : ""}`}
+                aria-pressed={searchCase}
+                onClick={() => setSearchCase((v) => !v)}
+                title="Case sensitive"
+              >
+                Aa
+              </button>
+            )}
+            {/* Scope: search under the browsed folder (default) or the whole
+                project. Only shown in a subfolder — at the root they're the same. */}
+            {relPath && (
+              <span className="file-tree-search-scope">
+                <button
+                  type="button"
+                  className={`file-tree-search-mode file-tree-search-scope-folder${!searchRoot ? " active" : ""}`}
+                  aria-pressed={!searchRoot}
+                  onClick={() => setSearchRoot(false)}
+                  title={`Search under ${relPath}`}
+                >
+                  {scopeLabel}
+                </button>
+                <button
+                  type="button"
+                  className={`file-tree-search-mode${searchRoot ? " active" : ""}`}
+                  aria-pressed={searchRoot}
+                  onClick={() => setSearchRoot(true)}
+                  title="Search the whole project"
+                >
+                  root
+                </button>
+              </span>
+            )}
+          </div>
+        </div>
+      )}
+      {!searching && pathEdit !== null && (
+        <div className="file-tree-breadcrumb file-tree-path-edit">
+          <input
+            ref={pathEditRef}
+            className="file-tree-path-input"
+            value={pathEdit}
+            spellCheck={false}
+            onChange={(e) => setPathEdit(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                commitPathEdit();
+              } else if (e.key === "Escape") {
+                e.preventDefault();
+                setPathEdit(null);
+              }
+            }}
+            onBlur={() => setPathEdit(null)}
+          />
+        </div>
+      )}
+      {!searching && pathEdit === null && relPath && (() => {
+        // Parent of the current folder — the up button doubles as a drag-to-move
+        // target ("move into the parent dir"). The breadcrumb crumbs cover the
+        // other ancestors (and ⌂ the project root).
+        const parentRel = relPath.split("/").filter(Boolean).slice(0, -1).join("/");
+        return (
+        <div
+          className="file-tree-breadcrumb"
+          onContextMenu={(e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            startPathEdit();
+          }}
+        >
+          <button
+            className={`file-tree-up${moveTargetRel === parentRel ? " move-drop-target" : ""}`}
+            data-move-rel={parentRel}
+            onClick={goUp}
+            title="Go up"
+          >
+            ↑
+          </button>
+          <button
+            className={`file-tree-crumb${moveTargetRel === "" ? " move-drop-target" : ""}`}
+            data-move-rel=""
+            onClick={() => load("")}
+            title="Project root"
+          >
+            ⌂
+          </button>
           {relPath.split("/").filter(Boolean).map((seg, i, arr) => {
             const target = arr.slice(0, i + 1).join("/");
             const isLast = i === arr.length - 1;
+            // When a remote listing failed, `missingCrumbDepth` marks where the
+            // path leaves the host tree: segments before it exist on the host
+            // (on-host), segments from it on are local-only (missing). The cue is
+            // shape first — strike-through + a ⊘ badge for missing — with a colour
+            // tint only as reinforcement, so it reads without relying on colour.
+            const missing = missingCrumbDepth !== null && i >= missingCrumbDepth;
+            const onHost = missingCrumbDepth !== null && i < missingCrumbDepth;
             return (
               <React.Fragment key={target}>
                 <span className="file-tree-crumb-sep">/</span>
                 <button
-                  className={`file-tree-crumb${isLast ? " current" : ""}`}
+                  className={`file-tree-crumb${isLast ? " current" : ""}${moveTargetRel === target ? " move-drop-target" : ""}${missing ? " crumb-missing" : ""}${onHost ? " crumb-on-host" : ""}`}
+                  data-move-rel={target}
                   onClick={() => { if (!isLast) load(target); }}
-                  title={target}
+                  title={missing ? `${target}\nNot on the remote host — local-only` : onHost ? `${target}\nOn the remote host` : target}
                 >
                   {seg}
                 </button>
               </React.Fragment>
             );
           })}
+          <span
+            className="file-tree-path-total"
+            title={sizeTitle(groupSizes.regular, groupSizes.regularIgnored, "Total size of the files shown here")}
+          >
+            {fmtSize(groupSizes.regular)}
+          </span>
         </div>
-      )}
+        );
+      })()}
+      </div>
       {loading && <div className="file-tree-loading">Loading…</div>}
       {error && <div className="file-tree-error">{error}</div>}
-      {!relPath && (
-        <label className="file-tree-scaffold-toggle">
-          <input type="checkbox" checked={separateScaffold} onChange={(e) => setSeparateScaffold(e.target.checked)} />
+      {!searching && pathEdit === null && !relPath && (
+        <label
+          className="file-tree-scaffold-toggle"
+          onContextMenu={(e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            startPathEdit();
+          }}
+        >
+          <Toggle size="sm" checked={separateScaffold} onChange={(e) => setSeparateScaffold(e.target.checked)} />
           Separate scaffold
+          <span
+            className="file-tree-path-total"
+            title={sizeTitle(groupSizes.regular, groupSizes.regularIgnored, "Total size of the files shown here")}
+          >
+            {fmtSize(groupSizes.regular)}
+          </span>
         </label>
       )}
-      {(() => {
-        const isRoot = !relPath && separateScaffold;
-        const regular = isRoot ? entries.filter((e) => !STANDARD_PROJECT_FILES.has(e.name)) : entries;
-        const standard = isRoot ? entries.filter((e) => STANDARD_PROJECT_FILES.has(e.name)) : [];
+      {searching && (
+        <FileTreeSearch
+          projectDir={projectDir}
+          projectId={projectId}
+          query={search}
+          mode={searchMode}
+          caseSensitive={searchCase}
+          scopeRel={searchScope}
+          onReveal={revealPath}
+        />
+      )}
+      {!searching && (() => {
+        // Sections (regular / collapsible scaffold / collapsible gitignored) are
+        // computed once in the `sections` memo above and shared with the
+        // selection click handler so a shift-range spans exactly these rows.
+        // `sections` carries the FULL lists — the section headers count them, and
+        // a header that counted only the rendered page would misreport the folder.
+        // `rowWindow` carries the capped lists that are actually rendered.
+        // Only the two collapsible sections read their full list here (their
+        // headers count it); the regular section has no header, so it is read
+        // from `rows` alone.
+        const { standard, gitignored } = sections;
+        const rows = rowWindow;
 
-        function renderEntry(e: FileEntry, isScaffold = false) {
-          const status = gitStatuses[e.name];
+        function renderEntry(e: FileEntry, isScaffold = false, isGitignored = false) {
+          const status = isGitignored ? undefined : displayStatuses[e.name];
           const sizeClass = !e.is_dir ? sizeCategory(e.size) : "";
-          const canRun = !e.is_dir && e.extension === ".sh";
-          const isRunning = runningScripts.has(e.path);
+          // A folder's headline number is its non-ignored weight — the part
+          // that's actually "yours" — with the full total + ignored split
+          // available on hover; the gitignored section shows a folder's whole
+          // size plainly since there nothing but ignored content is left.
+          // A folder in the gitignored section never subtracts: it may still
+          // carry a `dirIgnoredBytes` entry (the breakdown is dispatched from
+          // the first render, when `git_file_statuses` hasn't landed yet and
+          // every folder still looks regular), and there the ignored figure is
+          // the folder's WHOLE size — subtracting it would show a plain 0 B.
+          const dirTotal = e.is_dir ? dirSizes[e.path] : undefined;
+          const dirIgnored = e.is_dir && !isGitignored ? dirIgnoredBytes[e.path] : undefined;
+          const dirShown = dirTotal !== undefined ? dirTotal - (dirIgnored ?? 0) : undefined;
+          const canShRun = !e.is_dir && shellRunnerFor(e.extension, PLATFORM) !== null;
+          // Run only for a Python "main" script (see the `pyMainByPath` effect
+          // above) — a remote-source listing can't cheaply check content, so it
+          // keeps the old any-.py-file behavior instead of hiding Run entirely.
+          const canPyRun = !e.is_dir && isPythonPath(e.path)
+            && (remoteListing || (pyMainByPath[e.path] ?? false));
+          const canRun = canShRun || canPyRun;
+          // "Running" drives the green pulse + title/aria and unions both run
+          // paths: a detached `.sh` tracked by real process liveness
+          // (`runningScripts`), and a tab-backed run (Python / foreground shell)
+          // whose tab is producing output (`runningRunFiles`, busy-gated).
+          const isRunning = runningScripts.has(e.path) || runningRunFiles.has(e.path);
+          // But only the detached path LOCKS the button: it has no tab to watch
+          // and a second click would double-spawn. A tab-backed run stays
+          // clickable so a re-run can replace the tab mid-session.
+          const runLocked = runningScripts.has(e.path);
           const isCompiling = compiling.has(e.path);
           const dragTarget = draggableToTab(e);
-          const viewer = dragTarget === "embed" ? null : dragTarget;
+          const isMoveTarget = e.is_dir && moveTargetRel === relForEntry(e);
+          // SSH-sync Phase 1: per-path mirror state, symmetric across the
+          // remote-source and local-mirror trees. Each non-resting state gets a
+          // colored action button left of the icon: red for `none` (not synced)
+          // — pull/push it; orange for `amber` (host diverged from our mirror) —
+          // view the diff. `green` (in sync) is the resting state and shows
+          // nothing.
+          const syncTracked = remoteListing || treatLocal;
+          const rel = syncTracked ? relForEntry(e) : "";
+          // A folder with no manifest entry of its own falls back to the rolled-up
+          // state of its tracked descendants (`dirSyncAgg`): green when it contains
+          // tracked files and they are all green (so no misleading red push button),
+          // else `none`. Files, and folders that DO have an own entry, keep the
+          // direct lookup. `none` remains the default when nothing is known.
+          const syncState: SyncFileState = !syncTracked
+            ? "none"
+            : syncStatus?.[rel]?.state ??
+              (e.is_dir && dirSyncAgg[rel]?.any
+                ? dirSyncAgg[rel].allGreen
+                  ? "green"
+                  : "none"
+                : "none");
+          // Auto-sync glyph: shown on both the remote and local trees when this
+          // path (or an ancestor auto folder) is set to auto-sync. Coexists with
+          // the amber ± button — an auto path that went orange is exactly what the
+          // user must resolve manually.
+          const autoSync = syncTracked ? !!syncStatus?.[rel]?.auto : false;
+          // Effective (own-or-inherited) byte-sync exclusion: takes over the
+          // whole sync slot (file or folder) with a grey X, ahead of the
+          // red/orange/auto icons — an excluded path has none of those states
+          // to act on. A folder shows this too (not just its excluded
+          // descendants): it's the row the user actually right-clicked
+          // "Exclude from sync" on, so it must visibly reflect that.
+          const pathExcluded = syncTracked ? isPathExcluded(syncStatus, rel) : false;
+          // Local-mirror view only: a folder that exists in the mirror but not on
+          // the host (its name is absent from the host readdir, `hostChildNames`).
+          // Dimmed + tagged so "Local" mode never implies the whole tree is on the
+          // remote. `hostChildNames === null` (unknown / disconnected) flags nothing.
+          const notOnRemote =
+            e.is_dir &&
+            treatLocal &&
+            hostChildNames !== null &&
+            !hostChildNames.has(e.name);
           return (
             <div
               key={e.path}
-              className={`file-entry ${e.is_dir ? "dir" : "file"}${dragTarget ? " embeddable" : ""}${isScaffold ? " scaffold" : ""}`}
+              className={`file-entry ${e.is_dir ? "dir" : "file"}${dragTarget ? " embeddable" : ""}${isScaffold || isGitignored ? " scaffold" : ""}${isMoveTarget ? " move-drop-target" : ""}${selected.has(e.path) ? " selected" : ""}${notOnRemote ? " not-on-remote" : ""}`}
+              // Row key for jump-to-path reveal scroll (search results).
+              data-entry-path={e.path}
+              // Folders are drag-to-move destinations: dropping a dragged file
+              // here relocates it (hit-tested by data-move-rel in the drag).
+              data-move-rel={e.is_dir ? relForEntry(e) : undefined}
               // Dirs: single-click navigates + native DnD (file export).
               // Files, plain drag: pointer-based drag onto a tab bar for
               // drag-to-tab files (built-in viewer OR embeddable handler); R6 —
               // native DnD disabled then so it can't hijack the pointer. Opened
               // by double-click.
-              // Files, ALT held: arm native HTML5 DnD so any file can be dragged
-              // out into an embedded browser / external target (the pointer
-              // drag-to-tab bails on Alt, see onEntryPointerDown).
-              onClick={e.is_dir ? () => handleClick(e) : undefined}
-              onDoubleClick={e.is_dir ? undefined : () => handleClick(e)}
+              // Files, CTRL held: arm native HTML5 DnD so any file can be dragged
+              // out into an embedded browser / external target like Signal (the
+              // pointer drag-to-tab bails on Ctrl, see onEntryPointerDown).
+              onClick={(ev) => handleRowClick(ev, e)}
+              onDoubleClick={e.is_dir ? undefined : (ev) => handleOpen(e, ev)}
               onContextMenu={(ev) => showEntryContextMenu(ev, e)}
-              draggable={e.is_dir || altHeld}
+              draggable={e.is_dir || ctrlHeld}
               onDragStart={
-                e.is_dir || altHeld
+                e.is_dir || ctrlHeld
                   ? (ev) => handleEntryDragStart(ev, e)
                   : (ev) => ev.preventDefault()
               }
-              onPointerDown={dragTarget ? (ev) => onEntryPointerDown(ev, e, viewer) : undefined}
+              // Every file arms the pointer drag — files with a tab/viewer target
+              // can drop onto a tab bar, and ALL files can be dragged into a
+              // folder to move them. Folders aren't dragged (they navigate).
+              onPointerDown={!e.is_dir ? (ev) => onEntryPointerDown(ev, e, dragTarget) : undefined}
               onMouseEnter={(ev) => handleEntryMouseEnter(ev, e)}
-              onMouseLeave={() => setTooltip(null)}
+              onMouseLeave={handleEntryMouseLeave}
             >
               <GitMarker status={status} />
+              {/* Fixed-width sync slot: always reserved on a sync-tracked tree so
+                  file/folder names stay left-aligned whether or not the row has an
+                  action button. `none` → red sync/push button; `amber` → orange
+                  diff button; `green` → empty (in sync). */}
+              {syncTracked && (
+                <span className="file-sync-slot">
+                  {pathExcluded ? (
+                    <span
+                      className="file-sync-excluded"
+                      title="Excluded from byte-sync"
+                      aria-label="Excluded from byte-sync"
+                    >
+                      ✕
+                    </span>
+                  ) : (
+                    <>
+                      {syncState === "none" && (() => {
+                        const anyBusy = !!syncProgress;
+                        const thisBusy = syncProgress?.rel === rel;
+                        return (
+                          <button
+                            type="button"
+                            className={`file-sync-btn${thisBusy ? " busy" : ""}`}
+                            title={remoteListing ? "Sync to local" : "Push to host"}
+                            aria-label={remoteListing ? "Sync to local" : "Push to host"}
+                            disabled={anyBusy}
+                            onClick={(ev) => {
+                              ev.preventDefault();
+                              ev.stopPropagation();
+                              void (remoteListing ? syncEntryToLocal(e) : pushEntryToHost(e));
+                            }}
+                          >
+                            {thisBusy ? <span className="file-run-spinner" /> : "⇄"}
+                          </button>
+                        );
+                      })()}
+                      {syncState === "amber" && !e.is_dir && (
+                        <button
+                          type="button"
+                          className="file-diff-btn"
+                          title="Host and local differ — compare and resolve"
+                          aria-label="Compare host vs local and resolve"
+                          onClick={(ev) => {
+                            ev.preventDefault();
+                            ev.stopPropagation();
+                            openSyncMerge(e);
+                          }}
+                        >
+                          ±
+                        </button>
+                      )}
+                      {/* Auto-sync indicator (non-interactive): only when the slot
+                          has no action button, so it never crowds out the
+                          red/orange controls. Amber auto paths still show ±
+                          (needs resolving). */}
+                      {autoSync && syncState === "green" && (
+                        <span
+                          className="file-autosync-icon"
+                          title="Auto-syncing"
+                          aria-label="Auto-syncing"
+                        >
+                          ⟳
+                        </span>
+                      )}
+                    </>
+                  )}
+                </span>
+              )}
               {canRun && (
                 <button
                   type="button"
                   className={`file-run-btn${isRunning ? " running" : ""}`}
-                  title={isRunning ? `Running ${e.name}…` : `Run ${e.name}`}
+                  // No native `title` here on purpose: hovering this button sits
+                  // inside the row, which already has the row's own portaled
+                  // tooltip open (below) — a browser title tooltip on top of it
+                  // would be a second, uncontrolled hover. Everything it would
+                  // have said (run/args/right-click hint) lives in that tooltip
+                  // instead.
                   aria-label={isRunning ? `Running ${e.name}` : `Run ${e.name}`}
-                  onClick={(ev) => runShellScript(ev, e)}
-                  disabled={isRunning}
+                  onClick={(ev) => (canPyRun ? runPythonScript(ev, e) : runShellScript(ev, e))}
+                  // Right-click a Python Run button → set arguments (sys.argv). For a
+                  // shell script there's nothing to offer, so just swallow it so it
+                  // doesn't fall through to the row's file context menu.
+                  onContextMenu={(ev) => {
+                    ev.preventDefault();
+                    ev.stopPropagation();
+                    if (canPyRun) {
+                      setArgsPopover({
+                        entry: e,
+                        x: ev.clientX,
+                        y: ev.clientY,
+                        draft: pyArgsByPath[e.path] ?? "",
+                      });
+                    }
+                  }}
+                  disabled={runLocked}
                 >
-                  {isRunning ? <span className="file-run-spinner" /> : "▶"}
+                  ▶
                 </button>
               )}
               {isCompiling && (
@@ -865,8 +3029,32 @@ export function FileTree({
                 </span>
               )}
               <span className="file-icon">{e.is_dir ? folderIcon() : fileIcon(e.extension)}</span>
-              <span className="file-name" title={e.name}>{e.name}</span>
-              {!e.is_dir && (
+              <span className="file-name">{e.name}</span>
+              {notOnRemote && (
+                <span
+                  className="file-offhost-tag"
+                  title="This folder exists only in the local mirror — it isn't on the remote host yet."
+                  aria-label="Local only — not on the remote host"
+                >
+                  local only
+                </span>
+              )}
+              {e.is_dir && isScanExcluded(relForEntry(e)) ? (
+                // Stands in for the size rather than sitting beside it: there is no
+                // size to show, and saying why is more use than an empty column.
+                <span
+                  className="file-size file-size-excluded"
+                  title="Excluded from scans — its size isn't computed and its file activity isn't counted. Right-click to include it again."
+                >
+                  not scanned
+                </span>
+              ) : e.is_dir ? (
+                dirShown !== undefined && (
+                  <span className={`file-size ${sizeCategory(dirShown)}`}>
+                    {fmtSize(dirShown)}
+                  </span>
+                )
+              ) : (
                 <span className={`file-size ${sizeClass}`}>{fmtSize(e.size)}</span>
               )}
             </div>
@@ -875,7 +3063,7 @@ export function FileTree({
 
         return (
           <>
-            {regular.map((e) => renderEntry(e, false))}
+            {rows.regular.map((e) => renderEntry(e, false))}
             {standard.length > 0 && (
               <>
                 <button
@@ -887,52 +3075,172 @@ export function FileTree({
                 >
                   <span className="file-tree-hidden-caret">{scaffoldExpanded ? "▾" : "▸"}</span>
                   scaffold ({standard.length})
+                  <span
+                    className="file-tree-path-total"
+                    title={sizeTitle(groupSizes.standard, groupSizes.standardIgnored, "Total size of the scaffold group")}
+                  >
+                    {fmtSize(groupSizes.standard)}
+                  </span>
                 </button>
-                {scaffoldExpanded && standard.map((e) => renderEntry(e, true))}
+                {scaffoldExpanded && rows.standard.map((e) => renderEntry(e, true))}
               </>
             )}
-            {hidden.length > 0 && (
+            {gitignored.length > 0 && (
               <>
                 <button
                   type="button"
                   className="file-tree-section-divider file-tree-hidden-toggle"
-                  aria-expanded={hiddenExpanded}
-                  onClick={() => setHiddenExpanded((v) => {
+                  aria-expanded={gitignoredExpanded}
+                  onClick={() => setGitignoredExpanded((v) => {
                     const next = !v;
-                    try { localStorage.setItem(HIDDEN_EXPANDED_KEY, next ? "1" : "0"); } catch { /* ignore storage failures */ }
+                    try { localStorage.setItem(GITIGNORED_EXPANDED_KEY, next ? "1" : "0"); } catch { /* ignore storage failures */ }
                     return next;
                   })}
-                  title={hiddenExpanded ? "Collapse hidden files" : "Expand hidden files"}
+                  title={gitignoredExpanded ? "Collapse gitignored files" : "Expand gitignored files"}
                 >
-                  <span className="file-tree-hidden-caret">{hiddenExpanded ? "▾" : "▸"}</span>
-                  hidden ({hidden.length})
+                  <span className="file-tree-hidden-caret">{gitignoredExpanded ? "▾" : "▸"}</span>
+                  gitignored ({gitignored.length})
+                  <span className="file-tree-path-total" title="Total size of the gitignored group">
+                    {fmtSize(groupSizes.gitignored)}
+                  </span>
                 </button>
-                {hiddenExpanded && hidden.map((e) => renderEntry(e, true))}
+                {gitignoredExpanded && rows.gitignored.map((e) => renderEntry(e, false, true))}
               </>
             )}
+            {rows.hidden > 0 && (
+              // The escape hatch for the render cap. Says how many rows are held
+              // back so the number is never a mystery, and reveals a page at a
+              // time rather than the whole folder — the point is to keep the DOM
+              // bounded, and a "show all" would hand back the freeze it prevents.
+              <button
+                type="button"
+                className="file-tree-section-divider file-tree-more"
+                onClick={() => setRowCap((n) => n + ROW_CAP_STEP)}
+                title={`Only the first ${orderedVisible.length} entries are rendered — showing every file at once in a folder this size would stall the window. Click to render ${Math.min(rows.hidden, ROW_CAP_STEP)} more.`}
+              >
+                show {Math.min(rows.hidden, ROW_CAP_STEP)} more ({rows.hidden} not shown)
+              </button>
+            )}
           </>
         );
       })()}
+      {contextMenu?.rowRect && createPortal(
+        <div
+          key={contextMenu.entry?.path ?? "root"}
+          className="file-entry-highlight"
+          style={{
+            left: contextMenu.rowRect.left,
+            top: contextMenu.rowRect.top,
+            width: contextMenu.rowRect.width,
+            height: contextMenu.rowRect.height,
+          }}
+        />,
+        document.body,
+      )}
+      {argsPopover &&
+        createPortal(
+          <div className="file-run-args-backdrop" onMouseDown={() => setArgsPopover(null)}>
+            <div
+              ref={argsPopoverRef}
+              className="file-run-args"
+              style={{ left: argsPopover.x, top: argsPopover.y }}
+              onMouseDown={(ev) => ev.stopPropagation()}
+              role="dialog"
+              aria-label={`Run arguments for ${argsPopover.entry.name}`}
+            >
+              <label className="file-run-args-label">
+                Arguments (sys.argv) — {argsPopover.entry.name}
+              </label>
+              <input
+                ref={argsInputRef}
+                className="file-run-args-input"
+                value={argsPopover.draft}
+                spellCheck={false}
+                placeholder="--epochs 5 data.csv"
+                onChange={(ev) =>
+                  setArgsPopover((p) => (p ? { ...p, draft: ev.target.value } : p))
+                }
+                onKeyDown={(ev) => {
+                  if (ev.key === "Enter") {
+                    ev.preventDefault();
+                    const a = argsPopover.draft.trim();
+                    setPyArgs(argsPopover.entry.path, a);
+                    launchPython(argsPopover.entry, a);
+                    setArgsPopover(null);
+                  } else if (ev.key === "Escape") {
+                    ev.preventDefault();
+                    setArgsPopover(null);
+                  }
+                }}
+              />
+              <div className="file-run-args-row">
+                <button
+                  type="button"
+                  className="file-run-args-btn"
+                  onClick={() => {
+                    const a = argsPopover.draft.trim();
+                    setPyArgs(argsPopover.entry.path, a);
+                    launchPython(argsPopover.entry, a);
+                    setArgsPopover(null);
+                  }}
+                >
+                  ▶ Run
+                </button>
+                <button
+                  type="button"
+                  className="file-run-args-btn"
+                  onClick={() => {
+                    const a = argsPopover.draft.trim();
+                    setPyArgs(argsPopover.entry.path, a);
+                    setArgsPopover(null);
+                  }}
+                  title="Remember these arguments without running now"
+                >
+                  Save
+                </button>
+              </div>
+            </div>
+          </div>,
+          document.body,
+        )}
       {contextMenu && createPortal(
         <div
+          ref={contextMenuRef}
           className="context-menu file-browser-context-menu"
           style={{ left: contextMenu.x, top: contextMenu.y }}
           onMouseDown={(e) => e.stopPropagation()}
         >
           {!contextMenu.entry && (
             <>
+              {onOpenFolderTab && (
+                <>
+                  <button
+                    onClick={() => {
+                      setContextMenu(null);
+                      onOpenFolderTab(relPath);
+                    }}
+                  >
+                    Open this view in a new tab
+                  </button>
+                  <hr />
+                </>
+              )}
               <button onClick={() => createEntry("file")}>
                 New File
               </button>
               <button onClick={() => createEntry("dir")}>
                 New Folder
               </button>
-              {(clipboard || clipboardImage) && <hr />}
-              {clipboard && (
-                <button onClick={openPastePrompt}>
-                  Paste{clipboard.op === "cut" ? " (move)" : ""} “{clipboard.name}”
-                </button>
+              {treatLocal && (
+                <>
+                  <hr />
+                  <button onClick={() => pushAllToHost()}>
+                    Push all to host
+                  </button>
+                </>
               )}
+              {(clipboard || clipboardImage) && <hr />}
+              {renderPasteButton()}
               {clipboardImage && (
                 <button onClick={openScreenshotPrompt}>
                   Paste screenshot
@@ -942,10 +3250,153 @@ export function FileTree({
           )}
           {contextMenu.entry && (() => {
             const entry = contextMenu.entry;
-            const status = gitStatuses[entry.name];
+            // When the right-clicked row is part of a >1 selection, the menu acts
+            // on the whole selection (bulk Copy/Cut/Delete only — the per-file
+            // actions like Rename / Stage / Set-default-app don't generalise).
+            const menuEntries =
+              selected.has(entry.path) && selected.size > 1
+                ? entries.filter((en) => selected.has(en.path))
+                : [entry];
+            if (menuEntries.length > 1) {
+              const n = menuEntries.length;
+              return (
+                <>
+                  <button onClick={() => copyEntries(menuEntries, "copy")}>Copy {n} items</button>
+                  <button onClick={() => copyEntries(menuEntries, "cut")}>Cut {n} items</button>
+                  {renderPasteButton()}
+                  <hr />
+                  <button className="danger" onClick={() => promptDelete(menuEntries)}>
+                    Delete {n} items
+                  </button>
+                </>
+              );
+            }
+            const status = displayStatuses[entry.name];
             const isTex = !entry.is_dir && entry.extension === ".tex";
+            const isZip = !entry.is_dir && entry.extension === ".zip";
+            const entryRel = relForEntry(entry);
+            const syncSel = remoteListing ? syncStatus?.[entryRel]?.selected : false;
+            // Auto-sync is symmetric across the remote/local trees (both are
+            // sync-tracked); read the effective flag either way.
+            const syncTracked = remoteListing || treatLocal;
+            const autoOn = syncTracked ? !!syncStatus?.[entryRel]?.auto : false;
+            // Own marker only: an inherited exclusion is the transfer paths'
+            // business, but the label here must describe THIS row's answer.
+            const syncExcluded = syncTracked
+              ? !!syncStatus?.[entryRel]?.excluded
+              : false;
             return (
               <>
+                {onOpenFolderTab && entry.is_dir && (
+                  <>
+                    <button
+                      onClick={() => {
+                        setContextMenu(null);
+                        onOpenFolderTab(entryRel);
+                      }}
+                    >
+                      Open in a new tab
+                    </button>
+                    <hr />
+                  </>
+                )}
+                {/* Local trees only: the exclusion governs the LOCAL walks (the
+                    size walk and the churn watcher). A remote folder's size comes
+                    from `du` on the host, which this list has no say over. */}
+                {onToggleScanExcluded && entry.is_dir && !remoteListing && (
+                  <>
+                    <button
+                      onClick={() => {
+                        setContextMenu(null);
+                        const now = isScanExcluded(entryRel);
+                        onToggleScanExcluded(entryRel, !now);
+                        // Drop any size already shown for the folder: leaving the
+                        // old number up would claim a figure we've stopped keeping
+                        // current. Re-including re-requests it via `requestedSizes`.
+                        requestedSizes.current.delete(entry.path);
+                        setDirSizes((m) => {
+                          const next = { ...m };
+                          delete next[entry.path];
+                          return next;
+                        });
+                        setDirIgnoredBytes((m) => {
+                          const next = { ...m };
+                          delete next[entry.path];
+                          return next;
+                        });
+                      }}
+                      title={
+                        isScanExcluded(entryRel)
+                          ? "Resume computing this folder's size and counting its file activity"
+                          : "Never walk this folder: no size calculation, no file-activity counting"
+                      }
+                    >
+                      {isScanExcluded(entryRel) ? "Include in scans" : "Exclude from scans"}
+                    </button>
+                    <hr />
+                  </>
+                )}
+                {remoteListing && (
+                  <>
+                    <button onClick={() => syncEntryToLocal(entry)}>
+                      {entry.is_dir ? "Sync folder to local" : "Sync to local"}
+                    </button>
+                    {syncSel && (
+                      <button onClick={() => stopSyncingEntry(entry)}>
+                        Stop syncing
+                      </button>
+                    )}
+                    <hr />
+                  </>
+                )}
+                {treatLocal && (
+                  <>
+                    <button onClick={() => pushEntryToHost(entry)}>
+                      {entry.is_dir ? "Push folder to host" : "Push to host"}
+                    </button>
+                    <hr />
+                  </>
+                )}
+                {syncTracked && (
+                  <>
+                    <button onClick={() => toggleAutoSyncEntry(entry, !autoOn)}>
+                      {autoOn
+                        ? entry.is_dir
+                          ? "Stop auto-syncing folder"
+                          : "Stop auto-syncing"
+                        : entry.is_dir
+                          ? "Auto-sync this folder"
+                          : "Auto-sync this file"}
+                    </button>
+                    {/* Stronger than "stop auto-syncing": an exclusion is also
+                        honoured by the whole-project Sync all / push, which is
+                        what a giant data or build folder needs. Same marker the
+                        large-folder setup prompt writes, so the two agree. */}
+                    {entry.is_dir && (
+                      <button
+                        className="untested"
+                        onClick={() => toggleSyncExcluded(entry, !syncExcluded)}
+                        title={
+                          syncExcluded
+                            ? "Let this folder take part in syncing again"
+                            : "Never sync this folder: skipped by auto-sync AND by Sync all / Push all (nothing is deleted)"
+                        }
+                      >
+                        {syncExcluded ? "Include in sync" : "Exclude from sync"}
+                        <UntestedTag />
+                      </button>
+                    )}
+                    <hr />
+                  </>
+                )}
+                {isZip && (
+                  <>
+                    <button onClick={() => extractArchive(entry)}>
+                      Extract here
+                    </button>
+                    <hr />
+                  </>
+                )}
                 {isTex && texCap?.available && (
                   <>
                     <button
@@ -968,6 +3419,11 @@ export function FileTree({
                     Stage (git add)
                   </button>
                 )}
+                {status && !entry.is_dir && (
+                  <button onClick={() => showDiff(entry)}>
+                    Show diff
+                  </button>
+                )}
                 <button onClick={() => updateGitignore(entry, "ignore")}>
                   Add to .gitignore
                 </button>
@@ -983,17 +3439,13 @@ export function FileTree({
                   </>
                 )}
                 <hr />
-                <button onClick={() => copyEntry(entry, "copy")}>
+                <button onClick={() => copyEntries([entry], "copy")}>
                   Copy
                 </button>
-                <button onClick={() => copyEntry(entry, "cut")}>
+                <button onClick={() => copyEntries([entry], "cut")}>
                   Cut
                 </button>
-                {clipboard && (
-                  <button onClick={openPastePrompt}>
-                    Paste{clipboard.op === "cut" ? " (move)" : ""} “{clipboard.name}”
-                  </button>
-                )}
+                {renderPasteButton()}
                 {clipboardImage && (
                   <button onClick={openScreenshotPrompt}>
                     Paste screenshot
@@ -1003,7 +3455,7 @@ export function FileTree({
                 <button onClick={() => renameEntry(entry)}>
                   Rename
                 </button>
-                <button className="danger" onClick={() => promptDelete(entry)}>
+                <button className="danger" onClick={() => promptDelete([entry])}>
                   Delete
                 </button>
               </>
@@ -1016,11 +3468,25 @@ export function FileTree({
       {deleteConfirm && createPortal(
         <div className="modal-backdrop" onMouseDown={() => setDeleteConfirm(null)}>
           <div className="file-delete-dialog" onMouseDown={(e) => e.stopPropagation()}>
-            <h2>Delete {deleteConfirm.entry.is_dir ? "Folder" : "File"}</h2>
-            <p>
-              Delete <strong>{deleteConfirm.entry.name}</strong>? This permanently removes it from the project.
-            </p>
-            <div className="file-delete-path">{deleteConfirm.relPath}</div>
+            {deleteConfirm.entries.length === 1 ? (
+              <>
+                <h2>Delete {deleteConfirm.entries[0].is_dir ? "Folder" : "File"}</h2>
+                <p>
+                  Delete <strong>{deleteConfirm.entries[0].name}</strong>? This permanently removes it from the project.
+                </p>
+                <div className="file-delete-path">{relForEntry(deleteConfirm.entries[0])}</div>
+              </>
+            ) : (
+              <>
+                <h2>Delete {deleteConfirm.entries.length} items</h2>
+                <p>
+                  Delete these <strong>{deleteConfirm.entries.length}</strong> items? This permanently removes them from the project.
+                </p>
+                <div className="file-delete-path">
+                  {deleteConfirm.entries.map((e) => e.name).join(", ")}
+                </div>
+              </>
+            )}
             <div className="file-delete-actions">
               <button type="button" onClick={() => setDeleteConfirm(null)}>Cancel</button>
               <button type="button" className="danger" onClick={confirmDelete}>Delete</button>
@@ -1029,6 +3495,65 @@ export function FileTree({
         </div>,
         document.body,
       )}
+      {autoConfirm && createPortal(
+        <div className="modal-backdrop" onMouseDown={() => setAutoConfirm(null)}>
+          <div className="file-delete-dialog" onMouseDown={(e) => e.stopPropagation()}>
+            <h2>Auto-sync this folder?</h2>
+            <p>
+              Auto-syncing <strong>{autoConfirm.entry.name}</strong> will pull{" "}
+              <strong>{autoConfirm.files.toLocaleString()} files</strong> (
+              {fmtSize(autoConfirm.bytes)}) from the host into the local mirror, and
+              keep pulling as it changes.
+            </p>
+            <p>
+              Auto-sync copies bytes and <strong>does not read .gitignore</strong>, so
+              files kept on the host on purpose — experiment output, checkpoints, data
+              — are synced like any other.
+            </p>
+            <div className="file-delete-path">{relForEntry(autoConfirm.entry)}</div>
+            <div className="file-delete-actions">
+              <button type="button" onClick={() => setAutoConfirm(null)}>Cancel</button>
+              <button
+                type="button"
+                onClick={() => applyAutoSync(autoConfirm.entry, true)}
+              >
+                Auto-sync anyway
+              </button>
+            </div>
+          </div>
+        </div>,
+        document.body,
+      )}
+      {pushConflicts.length > 0 && createPortal(
+        <div className="modal-backdrop" onMouseDown={() => !pushBusy && resolvePushConflict("skip")}>
+          <div className="file-delete-dialog" onMouseDown={(e) => e.stopPropagation()}>
+            <h2>Host changed since last sync</h2>
+            <p>
+              <strong>{basename(pushConflicts[0]) || pushConflicts[0]}</strong> was
+              modified on the host since you last synced it. Pushing your local copy
+              would overwrite that change.
+            </p>
+            <div className="file-delete-path">{pushConflicts[0]}</div>
+            {pushConflicts.length > 1 && (
+              <p style={{ fontSize: 11, color: "var(--text-muted)" }}>
+                {pushConflicts.length - 1} more conflict{pushConflicts.length - 1 > 1 ? "s" : ""} after this.
+              </p>
+            )}
+            <div className="file-delete-actions">
+              <button type="button" disabled={pushBusy} onClick={() => resolvePushConflict("skip")}>
+                Skip
+              </button>
+              <button type="button" disabled={pushBusy} onClick={() => resolvePushConflict("host")}>
+                Take host
+              </button>
+              <button type="button" className="danger" disabled={pushBusy} onClick={() => resolvePushConflict("keep")}>
+                Keep local
+              </button>
+            </div>
+          </div>
+        </div>,
+        document.body,
+      )}
       {pastePrompt && createPortal(
         <div className="modal-backdrop" onMouseDown={() => !pasteBusy && setPastePrompt(null)}>
           <div className="file-delete-dialog" onMouseDown={(e) => e.stopPropagation()}>
@@ -1045,7 +3570,7 @@ export function FileTree({
                   {clipboard?.op === "cut" ? "Move" : "Copy"} <strong>{clipboard?.name}</strong>
                 </>
               )}{" "}
-              into <strong>{relPath || projectDir.split("/").pop() || "project root"}</strong> as:
+              into <strong>{relPath || basename(projectDir) || "project root"}</strong> as:
             </p>
             <input
               className="file-paste-name"
@@ -1065,7 +3590,7 @@ export function FileTree({
                 background: "var(--bg-panel)",
                 color: "var(--text-primary)",
                 border: "1px solid var(--border-color)",
-                borderRadius: 3,
+                borderRadius: "var(--radius-sm)",
                 padding: "4px 6px",
                 fontFamily: "inherit",
               }}
@@ -1095,15 +3620,62 @@ export function FileTree({
       )}
       {tooltip && createPortal(
         <div
+          ref={tooltipRef}
           className="file-tooltip"
-          style={{ right: window.innerWidth - tooltip.rect.left + 8, top: tooltip.rect.top }}
+          // Anchor on whichever side of the row has more room, so the tooltip pops
+          // *away* from the panel edge: docked right → opens left (the default),
+          // docked left → the row sits near x:0 and it opens right instead. Keyed
+          // off the row's own rect, so it does the right thing in a centred tab too.
+          // `tooltipShift` pulls it back up when it would otherwise overflow the
+          // window's bottom edge (a row near the bottom of a short docked viewer).
+          style={
+            window.innerWidth - tooltip.rect.right > tooltip.rect.left
+              ? { left: tooltip.rect.right + 8, top: tooltip.rect.top - tooltipShift }
+              : { right: window.innerWidth - tooltip.rect.left + 8, top: tooltip.rect.top - tooltipShift }
+          }
         >
+          <div className="file-tooltip-name">{tooltip.entry.name}</div>
+          {(remoteListing || treatLocal) && isPathExcluded(syncStatus, relForEntry(tooltip.entry)) && (
+            <div className="file-tooltip-excluded">Excluded from byte-sync</div>
+          )}
           {tooltip.entry.created_secs && (
             <div><span className="file-tooltip-label">Created </span>{fmtModified(tooltip.entry.created_secs)}</div>
           )}
           {tooltip.entry.modified_secs && (
             <div><span className="file-tooltip-label">Modified</span>{fmtModified(tooltip.entry.modified_secs)}</div>
           )}
+          {/* Same rule as the row: no ignored/total split for a folder that is
+              itself ignored — "412 MB of 412 MB ignored" says nothing. */}
+          {tooltip.entry.is_dir
+            && displayStatuses[tooltip.entry.name] !== "ignored"
+            && dirIgnoredBytes[tooltip.entry.path] !== undefined && (
+            <div>
+              <span className="file-tooltip-label">Ignored </span>
+              {fmtSize(dirIgnoredBytes[tooltip.entry.path])}
+              {dirSizes[tooltip.entry.path] !== undefined && ` of ${fmtSize(dirSizes[tooltip.entry.path])} total`}
+            </div>
+          )}
+          {!tooltip.entry.is_dir && isPythonPath(tooltip.entry.path) && (
+            (remoteListing || pyMainByPath[tooltip.entry.path] || pyArgsByPath[tooltip.entry.path])
+          ) && (
+            <>
+              {(remoteListing || pyMainByPath[tooltip.entry.path]) && (
+                <div>
+                  <span className="file-tooltip-label">Run </span>
+                  Right-click ▶ to set arguments
+                </div>
+              )}
+              {/* Nested under Run, not a top-level "Run args" row — and shown
+                  even when the file above lost its Run button (no `__main__`
+                  guard), so args set earlier don't just look lost. */}
+              {pyArgsByPath[tooltip.entry.path] && (
+                <div className="file-tooltip-sub">
+                  <span className="file-tooltip-label">args </span>
+                  {pyArgsByPath[tooltip.entry.path]}
+                </div>
+              )}
+            </>
+          )}
         </div>,
         document.body
       )}
diff --git a/src/components/files/FileTreeSearch.tsx b/src/components/files/FileTreeSearch.tsx
new file mode 100644
index 0000000..663ee29
--- /dev/null
+++ b/src/components/files/FileTreeSearch.tsx
@@ -0,0 +1,373 @@
+/**
+ * In-tree search results for `FileTree` — the flat result list shown in place of
+ * the browsed listing whenever the tree's search box holds a query. Two modes,
+ * both local-only (their backends walk the canonical local path, so `FileTree`
+ * only mounts this for a non-remote-source tree):
+ *
+ *  - **name**: fuzzy filename/path search over the whole project tree
+ *    (`list_project_paths`, ranked by the shared `fuzzy.ts`). Fetched lazily on
+ *    the first keystroke and cached per project dir.
+ *  - **content**: literal line search inside files (`project_search`, the same
+ *    backend the right panel's Search view uses), debounced.
+ *
+ * Every result offers BOTH of the actions the feature asks for: **jump to this
+ * path** (reveal + select the entry in the tree, via `onReveal`) and **open**
+ * the file in a viewer tab (content hits open at the matched line). Which one is
+ * the row's primary click depends on the mode — a filename hit reveals, a
+ * content hit opens at its line — and the other is a trailing button.
+ */
+import { useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { useEditorJumpStore } from "../../stores/editorJump";
+import { useSettingsStore } from "../../stores/settings";
+import { basename, resolvePath } from "../../lib/paths";
+import { disabledViewers, fileIcon, folderIcon, type FileEntry } from "../../lib/viewers/fileUtils";
+import { openFileEntry } from "./openFileEntry";
+
+/** The `.ext` (lowercased, dot-included) of a path's basename, matching the
+ *  shape `fileIcon` and `FileEntry.extension` use; "" when there is none. */
+function extensionOf(path: string): string {
+  const name = basename(path);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot).toLowerCase() : "";
+}
+
+interface PathEntry {
+  path: string;
+  is_dir: boolean;
+}
+
+/** Mirror of the Rust `SearchMatch` struct from `commands::search`. */
+interface SearchMatch {
+  path: string;
+  rel: string;
+  line: number;
+  col: number;
+  text: string;
+}
+
+const MAX_NAME_RESULTS = 200;
+const MAX_CONTENT_RESULTS = 500;
+const MIN_CONTENT_LEN = 2;
+const DEBOUNCE_MS = 220;
+
+/** Highlight the literal (case-insensitive) substring match in a path. */
+function HighlightedPath({ text, query }: { text: string; query: string }) {
+  const parts = contentParts(text, query, false);
+  if (!parts) return <>{text}</>;
+  return (
+    <>
+      {parts.before}
+      <mark className="file-search-hl">{parts.hit}</mark>
+      {parts.after}
+    </>
+  );
+}
+
+/** Split a content line around the literal match so the hit can be marked. */
+function contentParts(
+  text: string,
+  query: string,
+  caseSensitive: boolean,
+): { before: string; hit: string; after: string } | null {
+  if (!query) return null;
+  const hay = caseSensitive ? text : text.toLowerCase();
+  const needle = caseSensitive ? query : query.toLowerCase();
+  const idx = hay.indexOf(needle);
+  if (idx < 0) return null;
+  return { before: text.slice(0, idx), hit: text.slice(idx, idx + query.length), after: text.slice(idx + query.length) };
+}
+
+export function FileTreeSearch({
+  projectDir,
+  projectId,
+  query,
+  mode,
+  caseSensitive,
+  scopeRel,
+  onReveal,
+}: {
+  projectDir: string;
+  projectId: string | null;
+  query: string;
+  mode: "name" | "content";
+  caseSensitive: boolean;
+  /** Project-relative folder to confine the search to ("" = whole project).
+   *  Filenames are filtered to this subtree; content search walks only it. */
+  scopeRel: string;
+  onReveal: (rel: string, isDir: boolean) => void;
+}) {
+  const viewerPrefs = useSettingsStore((s) => s.settings?.viewer_prefs);
+  const disabledViewerSet = useMemo(() => disabledViewers(viewerPrefs), [viewerPrefs]);
+
+  // The absolute directory the search is confined to (content search walks it;
+  // name results are filtered to it). Rel-path bookkeeping stays project-rooted:
+  // a content hit's project-relative path is `scopeRel` + the backend's `rel`.
+  const scopeDir = scopeRel ? resolvePath(projectDir, scopeRel) : projectDir;
+
+  // Name-mode source: the whole project path list, fetched lazily on first use
+  // and cached for this projectDir (cleared when the dir changes).
+  const [paths, setPaths] = useState<PathEntry[]>([]);
+  const [namesLoaded, setNamesLoaded] = useState(false);
+  const pathsFor = useRef<string | null>(null);
+
+  const [content, setContent] = useState<SearchMatch[]>([]);
+  const [contentSearched, setContentSearched] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const reqId = useRef(0);
+
+  const trimmed = query.trim();
+
+  // Fetch the project path list once per projectDir, only when name search is
+  // actually used (a query in name mode). The fetch is keyed to the *directory*,
+  // not the query — every keystroke re-runs this effect (via `trimmed`), so it
+  // must NOT abort the in-flight fetch on a query change: the once-per-dir guard
+  // (`pathsFor.current === projectDir`) would then skip re-fetching and the
+  // results would never load ("Searching…" forever). Instead we tag the request
+  // with the dir it was for and drop only results whose dir is no longer current
+  // — so a second keystroke can never strand the first (and only) fetch.
+  useEffect(() => {
+    if (mode !== "name" || !projectDir || !trimmed) return;
+    if (pathsFor.current === projectDir) return; // already fetched/fetching this dir
+    pathsFor.current = projectDir;
+    setNamesLoaded(false);
+    setPaths([]);
+    const forDir = projectDir;
+    invoke<PathEntry[]>("list_project_paths", { projectDir })
+      .then((entries) => {
+        if (pathsFor.current !== forDir) return; // dir changed since; stale result
+        setPaths(entries);
+        setNamesLoaded(true);
+      })
+      .catch(() => {
+        if (pathsFor.current !== forDir) return;
+        pathsFor.current = null; // let a retry re-fetch
+        setPaths([]);
+        setNamesLoaded(true);
+      });
+  }, [mode, projectDir, trimmed]);
+
+  // A dir change needs no separate reset effect: the fetch above already keys on
+  // `projectDir`, so a genuine switch re-runs it (`pathsFor.current !== new dir`)
+  // and it clears + re-fetches for the new dir. With an empty query the stale
+  // `paths` are never shown either — `nameResults` guards on `!trimmed`. A second
+  // effect resetting `pathsFor` here would only race and strand that fetch.
+
+  const nameResults = useMemo(() => {
+    if (mode !== "name" || !trimmed) return [];
+    // Literal (case-insensitive) substring match on the path — NOT a fuzzy
+    // subsequence, which for a whole project matches almost everything. Rank a
+    // hit in the basename above one only in an ancestor folder, then a basename
+    // prefix highest, then shorter paths.
+    const q = trimmed.toLowerCase();
+    const scoped = scopeRel ? paths.filter((e) => e.path.startsWith(`${scopeRel}/`)) : paths;
+    const matched: { e: PathEntry; rank: number }[] = [];
+    for (const e of scoped) {
+      if (!e.path.toLowerCase().includes(q)) continue;
+      const base = basename(e.path).toLowerCase();
+      const rank = base.startsWith(q) ? 0 : base.includes(q) ? 1 : 2;
+      matched.push({ e, rank });
+    }
+    matched.sort((a, b) =>
+      a.rank !== b.rank
+        ? a.rank - b.rank
+        : a.e.path.length !== b.e.path.length
+          ? a.e.path.length - b.e.path.length
+          : a.e.path.localeCompare(b.e.path),
+    );
+    return matched.slice(0, MAX_NAME_RESULTS).map((m) => m.e);
+  }, [mode, trimmed, paths, scopeRel]);
+
+  // Content search: debounced call into the shared literal search backend,
+  // confined to `scopeDir`.
+  useEffect(() => {
+    if (mode !== "content" || !scopeDir) return;
+    if (trimmed.length < MIN_CONTENT_LEN) {
+      setContent([]);
+      setContentSearched(false);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    const id = ++reqId.current;
+    setLoading(true);
+    const timer = setTimeout(() => {
+      invoke<SearchMatch[]>("project_search", {
+        projectDir: scopeDir,
+        query: trimmed,
+        caseSensitive,
+        maxResults: MAX_CONTENT_RESULTS,
+      })
+        .then((matches) => {
+          if (reqId.current !== id) return;
+          setContent(matches);
+          setContentSearched(true);
+          setError(null);
+          setLoading(false);
+        })
+        .catch((e) => {
+          if (reqId.current !== id) return;
+          setContent([]);
+          setContentSearched(true);
+          setError(String(e));
+          setLoading(false);
+        });
+    }, DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [mode, scopeDir, trimmed, caseSensitive]);
+
+  // Opens through the same shared policy `FileTree`/`FileBrowser` use (native
+  // viewer in the focused subwindow, reusing an already-open tab for that exact
+  // file instead of stacking a duplicate) rather than always launching the OS
+  // default app — a name-mode result can be any file in the project, and a
+  // content-mode hit needs its tab open before `requestJump` can scroll it.
+  function openEntry(rel: string, isDir: boolean, line?: number, col?: number) {
+    if (isDir) {
+      onReveal(rel, true);
+      return;
+    }
+    const abs = resolvePath(projectDir, rel);
+    const entry: FileEntry = {
+      name: basename(abs),
+      path: abs,
+      is_dir: false,
+      size: 0,
+      extension: extensionOf(abs) || null,
+      mime: null,
+    };
+    openFileEntry({
+      entry,
+      projectDir,
+      projectId,
+      origin: "right_file_tree",
+      external: false,
+      disabled: disabledViewerSet,
+    });
+    if (line != null) useEditorJumpStore.getState().requestJump(abs, line, col ?? 0);
+  }
+
+  if (mode === "content" && trimmed.length > 0 && trimmed.length < MIN_CONTENT_LEN) {
+    return <div className="file-tree-empty">Type at least {MIN_CONTENT_LEN} characters</div>;
+  }
+
+  if (mode === "name") {
+    if (!namesLoaded && paths.length === 0) {
+      return <div className="file-tree-empty">Searching…</div>;
+    }
+    if (nameResults.length === 0) {
+      return <div className="file-tree-empty">No matching files</div>;
+    }
+    return (
+      <div className="file-search-results">
+        <div className="file-search-count">
+          {nameResults.length}
+          {nameResults.length >= MAX_NAME_RESULTS ? "+" : ""} file
+          {nameResults.length === 1 ? "" : "s"}
+        </div>
+        {nameResults.map((e) => {
+          // Display the path relative to the browsed scope; reveal/open stay
+          // project-rooted (`e.path`).
+          const displayPath = scopeRel ? e.path.slice(scopeRel.length + 1) : e.path;
+          return (
+          <div
+            key={e.path}
+            className={`file-entry file-search-row ${e.is_dir ? "dir" : "file"}`}
+            title={`${e.path} — click to reveal in tree`}
+            onClick={() => onReveal(e.path, e.is_dir)}
+            onDoubleClick={() => openEntry(e.path, e.is_dir)}
+          >
+            <span className="file-icon">{e.is_dir ? folderIcon() : fileIcon(extensionOf(e.path))}</span>
+            <span className="file-name file-search-path">
+              <HighlightedPath text={displayPath} query={trimmed} />
+            </span>
+            {!e.is_dir && (
+              <button
+                type="button"
+                className="file-search-act"
+                title="Open in a viewer tab"
+                aria-label="Open file"
+                onClick={(ev) => {
+                  ev.stopPropagation();
+                  openEntry(e.path, false);
+                }}
+              >
+                ↗
+              </button>
+            )}
+          </div>
+          );
+        })}
+      </div>
+    );
+  }
+
+  // content mode
+  if (error) {
+    return (
+      <div className="file-tree-error" style={{ padding: "6px 8px", wordBreak: "break-all" }}>
+        {error}
+      </div>
+    );
+  }
+  if (loading && content.length === 0) {
+    return <div className="file-tree-empty">Searching…</div>;
+  }
+  if (contentSearched && content.length === 0) {
+    return <div className="file-tree-empty">No results</div>;
+  }
+  return (
+    <div className="file-search-results">
+      {content.length > 0 && (
+        <div className="file-search-count">
+          {content.length}
+          {content.length >= MAX_CONTENT_RESULTS ? "+" : ""} match
+          {content.length === 1 ? "" : "es"}
+        </div>
+      )}
+      {content.map((m, i) => {
+        const parts = contentParts(m.text, trimmed, caseSensitive);
+        // The backend's `rel` is relative to `scopeDir`; re-root it at the
+        // project so reveal/open address the same path the tree uses.
+        const projectRel = scopeRel ? `${scopeRel}/${m.rel}` : m.rel;
+        return (
+          <div
+            key={`${projectRel}:${m.line}:${m.col}:${i}`}
+            className="file-entry file-search-row file-search-content"
+            title={`${projectRel}:${m.line} — click to open`}
+            onClick={() => openEntry(projectRel, false, m.line, m.col)}
+          >
+            <div className="file-search-content-body">
+              <span className="file-search-loc">
+                {m.rel}:{m.line}
+              </span>
+              <span className="file-search-line">
+                {parts ? (
+                  <>
+                    {parts.before}
+                    <mark className="file-search-hl">{parts.hit}</mark>
+                    {parts.after}
+                  </>
+                ) : (
+                  m.text
+                )}
+              </span>
+            </div>
+            <button
+              type="button"
+              className="file-search-act"
+              title="Reveal in tree"
+              aria-label="Reveal in tree"
+              onClick={(ev) => {
+                ev.stopPropagation();
+                onReveal(projectRel, false);
+              }}
+            >
+              ◎
+            </button>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
diff --git a/src/components/files/GitChangeTree.tsx b/src/components/files/GitChangeTree.tsx
new file mode 100644
index 0000000..3b4a0ab
--- /dev/null
+++ b/src/components/files/GitChangeTree.tsx
@@ -0,0 +1,217 @@
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+
+export interface FileChange {
+  path: string;
+  added: number;
+  deleted: number;
+  binary: boolean;
+}
+
+export type ChangeScope = "unstaged" | "staged" | "unpushed";
+
+export interface TreeNode {
+  name: string;
+  path: string;
+  isDir: boolean;
+  added: number;
+  deleted: number;
+  binary: boolean;
+  children: TreeNode[];
+}
+
+/**
+ * Folds the flat `path → stats` list from `git_change_stats` into a directory
+ * tree. Directory rows aggregate the line stats of everything beneath them; a
+ * dir is binary only if every changed file under it is binary. Children are
+ * sorted folders-first, then alphabetically — the order a file tree reads in.
+ */
+export function buildTree(changes: FileChange[]): TreeNode {
+  const root: TreeNode = { name: "", path: "", isDir: true, added: 0, deleted: 0, binary: true, children: [] };
+
+  for (const change of changes) {
+    const parts = change.path.split("/").filter(Boolean);
+    let node = root;
+    let acc = "";
+    parts.forEach((part, i) => {
+      acc = acc ? `${acc}/${part}` : part;
+      const last = i === parts.length - 1;
+      let child = node.children.find((c) => c.name === part);
+      if (!child) {
+        child = {
+          name: part,
+          path: acc,
+          isDir: !last,
+          added: 0,
+          deleted: 0,
+          binary: true,
+          children: [],
+        };
+        node.children.push(child);
+      }
+      if (last) {
+        child.isDir = false;
+        child.added = change.added;
+        child.deleted = change.deleted;
+        child.binary = change.binary;
+      }
+      node = child;
+    });
+  }
+
+  const fold = (n: TreeNode) => {
+    if (!n.isDir) return;
+    let added = 0;
+    let deleted = 0;
+    let allBinary = n.children.length > 0;
+    for (const c of n.children) {
+      fold(c);
+      added += c.added;
+      deleted += c.deleted;
+      if (!c.binary) allBinary = false;
+    }
+    n.added = added;
+    n.deleted = deleted;
+    n.binary = allBinary;
+    n.children.sort((a, b) =>
+      a.isDir !== b.isDir ? (a.isDir ? -1 : 1) : a.name.localeCompare(b.name),
+    );
+  };
+  fold(root);
+  return root;
+}
+
+function Stat({ added, deleted, binary }: { added: number; deleted: number; binary: boolean }) {
+  if (binary) return <span className="git-change-stat git-change-stat--bin">bin</span>;
+  return (
+    <span className="git-change-stat">
+      {added > 0 && <span className="git-change-add">+{added}</span>}
+      {deleted > 0 && <span className="git-change-del">-{deleted}</span>}
+      {added === 0 && deleted === 0 && <span className="git-change-zero">0</span>}
+    </span>
+  );
+}
+
+function Row({
+  node,
+  depth,
+  collapsed,
+  toggle,
+}: {
+  node: TreeNode;
+  depth: number;
+  collapsed: Set<string>;
+  toggle: (path: string) => void;
+}) {
+  const isCollapsed = collapsed.has(node.path);
+  return (
+    <>
+      <div
+        className={`git-change-row${node.isDir ? " is-dir" : ""}`}
+        style={{ paddingLeft: 6 + depth * 13 }}
+        onClick={node.isDir ? () => toggle(node.path) : undefined}
+        role={node.isDir ? "button" : undefined}
+        title={node.path}
+      >
+        <span className="git-change-caret">{node.isDir ? (isCollapsed ? "▸" : "▾") : ""}</span>
+        <span className="git-change-name">
+          {node.isDir ? "📁 " : ""}
+          {node.name}
+        </span>
+        <Stat added={node.added} deleted={node.deleted} binary={node.binary} />
+      </div>
+      {node.isDir &&
+        !isCollapsed &&
+        node.children.map((c) => (
+          <Row key={c.path} node={c} depth={depth + 1} collapsed={collapsed} toggle={toggle} />
+        ))}
+    </>
+  );
+}
+
+interface Props {
+  projectDir: string;
+  scope: ChangeScope;
+}
+
+/**
+ * Click-opened, navigable folder tree of the files behind an Add/Commit/Push
+ * action, each row annotated with its `+added / -deleted` line stats. Folders
+ * collapse/expand on click; the parent owns open/close (Escape, outside-click).
+ */
+export function GitChangeTree({ projectDir, scope }: Props) {
+  const [changes, setChanges] = useState<FileChange[] | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [collapsed, setCollapsed] = useState<Set<string>>(new Set());
+  // The flyout is CSS-anchored to the action bar's right edge and grows left, so
+  // when the file viewer is docked on the LEFT of the window it runs off the left
+  // screen border. Measure the rendered box and shift it back on-screen (either
+  // edge). We measure the box with its own shift cleared, so the correction is a
+  // fixed reference and converges in one pass instead of chasing its transform.
+  const treeRef = useRef<HTMLDivElement>(null);
+  const [shiftX, setShiftX] = useState(0);
+
+  useEffect(() => {
+    let live = true;
+    setChanges(null);
+    setError(null);
+    invoke<FileChange[]>("git_change_stats", { projectDir, scope })
+      .then((c) => live && setChanges(c))
+      .catch((e) => live && setError(String(e)));
+    return () => {
+      live = false;
+    };
+  }, [projectDir, scope]);
+
+  const tree = useMemo(() => (changes ? buildTree(changes) : null), [changes]);
+
+  useLayoutEffect(() => {
+    const el = treeRef.current;
+    if (!el) return;
+    // Measure the NATURAL box with any prior shift removed, so the correction is
+    // computed from a fixed reference and can't chase its own transform. (A real
+    // browser folds the applied translateX into rect.left, so `rect − shiftX`
+    // would also converge — but an env that does NOT reflect the transform into
+    // layout, e.g. jsdom under test, makes that subtraction drift by `margin`
+    // every render into an infinite loop. Clearing the transform first is stable
+    // in both.)
+    const prev = el.style.transform;
+    el.style.transform = "none";
+    const rect = el.getBoundingClientRect();
+    el.style.transform = prev;
+    const margin = 8;
+    let dx = 0;
+    if (rect.left < margin) dx = margin - rect.left; // clips left → push right
+    else if (rect.right > window.innerWidth - margin)
+      dx = window.innerWidth - margin - rect.right; // clips right → push left
+    if (dx !== shiftX) setShiftX(dx);
+  }, [tree, error, shiftX]);
+
+  const toggle = (path: string) =>
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      next.has(path) ? next.delete(path) : next.add(path);
+      return next;
+    });
+
+  return (
+    <div
+      ref={treeRef}
+      className="git-change-tree"
+      data-testid="git-change-tree"
+      style={shiftX ? { transform: `translateX(${shiftX}px)` } : undefined}
+      onClick={(e) => e.stopPropagation()}
+    >
+      {error && <div className="git-change-empty">{error}</div>}
+      {!error && !tree && <div className="git-change-empty">Loading…</div>}
+      {tree && tree.children.length === 0 && <div className="git-change-empty">No changes</div>}
+      {tree && tree.children.length > 0 && (
+        <div className="git-change-rows">
+          {tree.children.map((c) => (
+            <Row key={c.path} node={c} depth={0} collapsed={collapsed} toggle={toggle} />
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/files/GitHistory.tsx b/src/components/files/GitHistory.tsx
index 3824da8..c19db13 100644
--- a/src/components/files/GitHistory.tsx
+++ b/src/components/files/GitHistory.tsx
@@ -1,6 +1,10 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { createPortal } from "react-dom";
+import { Toggle } from "../common/Toggle";
 import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { Dropdown } from "../common/Dropdown";
+import { useTabsStore } from "../../stores/tabs";
 
 interface GitCommit {
   hash: string;
@@ -19,12 +23,83 @@ interface GitBranch {
   is_remote: boolean;
 }
 
+interface Worktree {
+  path: string;
+  branch: string;
+  head: string;
+  is_main: boolean;
+  is_locked: boolean;
+  is_bare: boolean;
+}
+
+/** A peer's HEAD as reported by the git-lockstep backend (#28n). */
+type HeadRef =
+  | { kind: "branch"; name: string; sha: string }
+  | { kind: "detached"; sha: string }
+  | { kind: "unborn" };
+
+type LockstepStatus =
+  | "synchronized"
+  | "syncing"
+  | "desynchronized"
+  /** #28p D4: the SSH pool is cold, so nothing is known about the host — and, crucially,
+   *  nothing is claimed. This used to render as a green "synchronized". */
+  | "disconnected";
+
+/** The files an initial pairing refused to overwrite (#28p D3). */
+interface PairingConflict {
+  /** True when the repo side is the local mirror, i.e. the files at risk are the host's. */
+  sourceIsLocal: boolean;
+  paths: string[];
+}
+
+/** One `refs/eldrun/backup/*` safety ref (#28p D6). */
+interface BackupRef {
+  peer: "local" | "remote";
+  refname: string;
+  ts: number;
+  branch: string;
+  sha: string;
+  subject: string;
+}
+
+/** Mirrors `services::git_peer::GitPeerState` (camelCase). */
+interface GitPeerState {
+  enabled: boolean;
+  status: LockstepStatus;
+  detail: string | null;
+  localHead: HeadRef | null;
+  remoteHead: HeadRef | null;
+  lastSyncTs: number | null;
+  localSubject: string | null;
+  remoteSubject: string | null;
+  pairingConflict: PairingConflict | null;
+}
+
+/** `<short sha> subject` for a peer's HEAD — shown so a Use-local/Use-remote choice is
+ *  informed rather than blind (#28p D8). */
+function headLabel(head: HeadRef | null, subject: string | null): string {
+  if (!head || head.kind === "unborn") return "—";
+  const sha = head.sha.slice(0, 7);
+  const name = head.kind === "branch" ? head.name : "(detached)";
+  return subject ? `${name} ${sha} · ${subject}` : `${name} ${sha}`;
+}
+
 interface Props {
   projectDir: string;
+  /** Project id — only supplied for SSH remote projects, enabling git lockstep (#28n). */
+  projectId?: string;
+  /** True for SSH remote projects (gates the lockstep UI). */
+  remote?: boolean;
   /** Called after a checkout/reword so the parent can refresh git status. */
   onChanged?: () => void;
 }
 
+function basename(p: string): string {
+  const parts = p.split(/[/\\]/).filter(Boolean);
+  return parts[parts.length - 1] ?? p;
+}
+
 function parseRefs(refs: string): string[] {
   return refs
     .split(",")
@@ -124,7 +199,19 @@ const LANE_W = 14;
 const GRAPH_ROW_H = 22;
 const cx = (col: number) => col * LANE_W + LANE_W / 2;
 
-function CommitGraphCell({ row, height, lanes, head }: { row: RowLayout; height: number; lanes: number; head: boolean }) {
+function CommitGraphCell({
+  row,
+  height,
+  lanes,
+  head,
+  tip,
+}: {
+  row: RowLayout;
+  height: number;
+  lanes: number;
+  head: boolean;
+  tip: boolean;
+}) {
   const mid = height / 2;
   const width = lanes * LANE_W;
   const x = (c: number) => cx(c);
@@ -159,6 +246,11 @@ function CommitGraphCell({ row, height, lanes, head }: { row: RowLayout; height:
           strokeWidth={1.5}
         />
       ))}
+      {/* Branch tips get a hollow ring in their lane color so the heads stand
+          out from ordinary commits along the same lane. */}
+      {tip && (
+        <circle cx={dotX} cy={mid} r={head ? 7 : 6} fill="none" stroke={laneColor(row.col)} strokeWidth={1.5} />
+      )}
       <circle cx={dotX} cy={mid} r={head ? 4.5 : 3.5} fill={laneColor(row.col)} stroke="var(--bg-panel)" strokeWidth={head ? 1.5 : 1} />
     </svg>
   );
@@ -166,9 +258,17 @@ function CommitGraphCell({ row, height, lanes, head }: { row: RowLayout; height:
 
 const GRAPH_MODE_KEY = "eldrun.gitHistoryGraph";
 
-export function GitHistory({ projectDir, onChanged }: Props) {
+export function GitHistory({ projectDir, projectId, remote, onChanged }: Props) {
   const [commits, setCommits] = useState<GitCommit[]>([]);
   const [branches, setBranches] = useState<GitBranch[]>([]);
+  const [worktrees, setWorktrees] = useState<Worktree[]>([]);
+  // Git lockstep (#28n): only meaningful for SSH remote projects.
+  const lockstepEligible = !!(remote && projectId);
+  const [lockstep, setLockstep] = useState<GitPeerState | null>(null);
+  const [lockstepBusy, setLockstepBusy] = useState(false);
+  // #28p D6: null = the Backups list is closed.
+  const [backups, setBackups] = useState<BackupRef[] | null>(null);
+  const [wtForm, setWtForm] = useState<{ path: string; branch: string; newBranch: boolean } | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [selected, setSelected] = useState<GitCommit | null>(null);
@@ -197,12 +297,14 @@ export function GitHistory({ projectDir, onChanged }: Props) {
     setLoading(true);
     setError(null);
     try {
-      const [log, br] = await Promise.all([
+      const [log, br, wt] = await Promise.all([
         invoke<GitCommit[]>("git_log", { projectDir, limit: 100 }),
         invoke<GitBranch[]>("git_branches", { projectDir }),
+        invoke<Worktree[]>("git_worktree_list", { projectDir }),
       ]);
       setCommits(log);
       setBranches(br);
+      setWorktrees(wt ?? []);
     } catch (e) {
       setError(String(e));
     } finally {
@@ -214,11 +316,213 @@ export function GitHistory({ projectDir, onChanged }: Props) {
     load();
   }, [load]);
 
+  // Load git-lockstep status + subscribe to backend status pushes (#28n).
+  useEffect(() => {
+    if (!lockstepEligible || !projectId) {
+      setLockstep(null);
+      return;
+    }
+    let alive = true;
+    invoke<GitPeerState>("git_peer_status", { projectId })
+      .then((s) => alive && setLockstep(s))
+      .catch(() => {});
+    const un = listen<{ projectId: string; state: GitPeerState }>("git-peer-status", (e) => {
+      if (alive && e.payload.projectId === projectId) setLockstep(e.payload.state);
+    });
+    return () => {
+      alive = false;
+      un.then((f) => f());
+    };
+  }, [lockstepEligible, projectId]);
+
+  const toggleLockstep = useCallback(async () => {
+    if (!projectId) return;
+    setLockstepBusy(true);
+    setError(null);
+    try {
+      const s = await invoke<GitPeerState>("git_peer_set_enabled", {
+        projectId,
+        enabled: !(lockstep?.enabled ?? false),
+      });
+      setLockstep(s);
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setLockstepBusy(false);
+    }
+  }, [projectId, lockstep?.enabled]);
+
+  const lockstepSyncNow = useCallback(async () => {
+    if (!projectId) return;
+    setLockstepBusy(true);
+    setError(null);
+    try {
+      const s = await invoke<GitPeerState>("git_peer_sync_now", { projectId });
+      setLockstep(s);
+      await load();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setLockstepBusy(false);
+    }
+  }, [projectId, load]);
+
+  // Use-local / Use-remote divergence resolution (#28n Phase 2): the chosen side
+  // becomes authoritative and the loser's overwritten tips are backed up to
+  // refs/eldrun/backup/* before it is reset. Confirm first — it discards commits
+  // on the losing side (recoverable only via those backup refs).
+  const lockstepResolve = useCallback(
+    async (authority: "local" | "remote") => {
+      if (!projectId) return;
+      const other = authority === "local" ? "remote host" : "local mirror";
+      if (
+        !window.confirm(
+          `Use ${authority} as the source of truth?\n\nThe ${other}'s diverging commits will be reset to match ${authority} (backed up to refs/eldrun/backup/* first).`,
+        )
+      )
+        return;
+      setLockstepBusy(true);
+      setError(null);
+      try {
+        const s = await invoke<GitPeerState>("git_peer_resolve", {
+          projectId,
+          authority,
+        });
+        setLockstep(s);
+        await load();
+        onChanged?.();
+      } catch (e) {
+        setError(String(e));
+      } finally {
+        setLockstepBusy(false);
+      }
+    },
+    [projectId, load, onChanged],
+  );
+
+  // #28p D3: pairing refused because the empty side holds files that differ from what
+  // it would be reset to. `reset --hard` destroys those silently, so the overwrite only
+  // happens on an explicit confirmation that has *named* them.
+  const lockstepPairConfirm = useCallback(async () => {
+    const conflict = lockstep?.pairingConflict;
+    if (!projectId || !conflict) return;
+    const side = conflict.sourceIsLocal ? "remote host" : "local mirror";
+    const list = conflict.paths.slice(0, 10).join("\n  ");
+    const more = conflict.paths.length > 10 ? `\n  …and ${conflict.paths.length - 10} more` : "";
+    if (
+      !window.confirm(
+        `Overwrite ${conflict.paths.length} file(s) on the ${side}?\n\n  ${list}${more}\n\n` +
+          `These differ from the version being paired in and are NOT in git — they will be lost.`,
+      )
+    )
+      return;
+    setLockstepBusy(true);
+    setError(null);
+    try {
+      const s = await invoke<GitPeerState>("git_peer_pair_confirm", { projectId });
+      setLockstep(s);
+      await load();
+      onChanged?.();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setLockstepBusy(false);
+    }
+  }, [projectId, lockstep?.pairingConflict, load, onChanged]);
+
+  // #28p D6: the backup refs every resolve/restore creates were write-only — they
+  // pinned objects forever and nothing could list or restore them, which also hollowed
+  // out the "it's recoverable" promise of Use-local/Use-remote.
+  const loadBackups = useCallback(async () => {
+    if (!projectId) return;
+    setLockstepBusy(true);
+    setError(null);
+    try {
+      const list = await invoke<BackupRef[]>("git_peer_backups", { projectId });
+      setBackups(list);
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setLockstepBusy(false);
+    }
+  }, [projectId]);
+
+  const restoreBackup = useCallback(
+    async (b: BackupRef) => {
+      if (!projectId) return;
+      if (
+        !window.confirm(
+          `Restore ${b.peer} branch '${b.branch}' to ${b.sha.slice(0, 7)} (${b.subject || "no subject"})?\n\n` +
+            `Its current tip is backed up first, so this is itself undoable. The peers will then differ — resolve that with Use local / Use remote.`,
+        )
+      )
+        return;
+      setLockstepBusy(true);
+      setError(null);
+      try {
+        const s = await invoke<GitPeerState>("git_peer_restore_backup", {
+          projectId,
+          peer: b.peer,
+          refname: b.refname,
+        });
+        setLockstep(s);
+        await loadBackups();
+        await load();
+        onChanged?.();
+      } catch (e) {
+        setError(String(e));
+      } finally {
+        setLockstepBusy(false);
+      }
+    },
+    [projectId, load, loadBackups, onChanged],
+  );
+
+  // #28p D8: a genuine two-sided divergence used to offer only "pick a winner". Open a
+  // local shell in the mirror instead — the peer's tip is already parked at
+  // refs/eldrun/peer/<branch> by the reconcile that detected the divergence, so the user
+  // can merge or rebase with plain git and the next pass fast-forwards the host normally.
+  const resolveInTerminal = useCallback(async () => {
+    if (!projectId) return;
+    setError(null);
+    try {
+      const mirror = await invoke<string>("git_peer_mirror_dir", { projectId });
+      const branch =
+        lockstep?.localHead?.kind === "branch" ? lockstep.localHead.name : undefined;
+      useTabsStore.getState().addTab({
+        label: "resolve",
+        cmd: "",
+        cwd: mirror,
+        kind: "shell",
+        // The mirror is a LOCAL working copy; a remote-located shell would cd into the
+        // host tree, where the peer ref isn't.
+        location: "local",
+        initialInput: branch
+          ? `git log --oneline --graph HEAD refs/eldrun/peer/${branch}`
+          : undefined,
+      });
+    } catch (e) {
+      setError(String(e));
+    }
+  }, [projectId, lockstep?.localHead]);
+
   async function checkout(target: string) {
     setLoading(true);
     setError(null);
     try {
-      await invoke("git_checkout", { projectDir, target });
+      // With git lockstep enabled, route through the coordinator so the paired
+      // local mirror + remote host tree switch together (#28n). The Git UI here
+      // reflects the host tree, so the host initiates.
+      if (lockstepEligible && projectId && lockstep?.enabled) {
+        const s = await invoke<GitPeerState>("git_peer_checkout", {
+          projectId,
+          target,
+          initiatingSide: "remote",
+        });
+        setLockstep(s);
+      } else {
+        await invoke("git_checkout", { projectDir, target });
+      }
       setSelected(null);
       await load();
       onChanged?.();
@@ -228,12 +532,66 @@ export function GitHistory({ projectDir, onChanged }: Props) {
     }
   }
 
-  const graph = useMemo(() => (graphMode ? computeGraph(commits) : []), [graphMode, commits]);
+  async function createWorktree() {
+    if (!wtForm) return;
+    setLoading(true);
+    setError(null);
+    try {
+      await invoke("git_worktree_add", {
+        projectDir,
+        path: wtForm.path,
+        branch: wtForm.branch,
+        newBranch: wtForm.newBranch,
+      });
+      setWtForm(null);
+      await load();
+      onChanged?.();
+    } catch (e) {
+      setError(String(e));
+      setLoading(false);
+    }
+  }
+
+  async function removeWorktree(path: string, force = false) {
+    setLoading(true);
+    setError(null);
+    try {
+      await invoke("git_worktree_remove", { projectDir, path, force });
+      await load();
+      onChanged?.();
+    } catch (e) {
+      setError(String(e));
+      setLoading(false);
+    }
+  }
+
+  // The graph layout is computed regardless of view mode so the per-lane colors
+  // can also tint the branch selector and the ref labels in list view; only the
+  // SVG cell itself is gated on graphMode below.
+  const graph = useMemo(() => computeGraph(commits), [commits]);
   const graphLanes = useMemo(
     () => graph.reduce((max, r) => Math.max(max, r.laneCount), 1),
     [graph],
   );
 
+  // Map each ref (branch tip / remote / tag) to the color of the lane its commit
+  // occupies in the graph, so a branch wears one consistent color everywhere it
+  // appears: the selector pill, its ref label, and its lane in the graph. Tag
+  // refs ("tag: …") are skipped — only branch heads get a color. First write wins
+  // when several refs share a commit (they share the lane anyway).
+  const branchColor = useMemo(() => {
+    const m = new Map<string, string>();
+    commits.forEach((c, i) => {
+      const col = graph[i]?.col;
+      if (col == null) return;
+      for (const r of parseRefs(c.refs)) {
+        if (r.startsWith("tag: ") || m.has(r)) continue;
+        m.set(r, laneColor(col));
+      }
+    });
+    return m;
+  }, [commits, graph]);
+
   const current = branches.find((b) => b.is_current)?.name;
   const localBranches = branches.filter((b) => !b.is_remote);
   const remoteBranches = branches.filter((b) => b.is_remote);
@@ -261,6 +619,144 @@ export function GitHistory({ projectDir, onChanged }: Props) {
         </button>
       </div>
 
+      {lockstepEligible && (
+        <div className="git-lockstep-bar" style={{ display: "flex", alignItems: "center", gap: 6, padding: "3px 6px", borderBottom: "1px solid var(--border-color)", fontSize: 10 }}>
+          <button
+            className={`tab-add-btn${lockstep?.enabled ? " active" : ""}`}
+            onClick={toggleLockstep}
+            disabled={lockstepBusy}
+            aria-pressed={!!lockstep?.enabled}
+            title={lockstep?.enabled ? "Git lockstep on — click to disable" : "Keep the local mirror and remote host repo on the same branch/commit"}
+          >
+            ⇄ Lockstep {lockstep?.enabled ? "on" : "off"}
+          </button>
+          {lockstep?.enabled && (
+            <>
+              <span
+                title={lockstep.detail ?? undefined}
+                style={{
+                  padding: "1px 6px",
+                  borderRadius: "var(--radius)",
+                  color: "#fff",
+                  background:
+                    lockstep.status === "synchronized"
+                      ? "var(--success, #3fb950)"
+                      : lockstep.status === "syncing"
+                        ? "var(--warning, #e3b341)"
+                        : lockstep.status === "disconnected"
+                          ? "var(--text-muted, #8b949e)"
+                          : "var(--danger, #f85149)",
+                }}
+              >
+                {lockstep.status}
+              </span>
+              <button
+                className="tab-add-btn"
+                onClick={lockstepSyncNow}
+                // Nothing to sync against without a connection — the button would only
+                // produce another "disconnected" (#28p D4).
+                disabled={lockstepBusy || lockstep.status === "disconnected"}
+                title={
+                  lockstep.status === "disconnected"
+                    ? "Connect to the remote host first"
+                    : "Reconcile git state now (retry after resolving a divergence)"
+                }
+              >
+                {lockstep.status === "desynchronized" ? "Retry" : "Sync now"}
+              </button>
+              {lockstep.status === "desynchronized" && lockstep.pairingConflict ? (
+                // Pairing was refused: the ONLY action offered is the one that names what
+                // it would destroy (#28p D3) — Use-local/Use-remote would be meaningless
+                // here (there is nothing paired yet to pick a winner between).
+                <button
+                  className="tab-add-btn"
+                  onClick={lockstepPairConfirm}
+                  disabled={lockstepBusy}
+                  title={`Overwrite the differing files on the ${lockstep.pairingConflict.sourceIsLocal ? "host" : "mirror"} and pair (they are not in git and cannot be recovered)`}
+                >
+                  Overwrite {lockstep.pairingConflict.paths.length} file(s) &amp; pair
+                </button>
+              ) : (
+                lockstep.status === "desynchronized" && (
+                  <>
+                    <button
+                      className="tab-add-btn"
+                      onClick={() => lockstepResolve("local")}
+                      disabled={lockstepBusy}
+                      title="Resolve the divergence with the local mirror as the source of truth (backs up the remote's overwritten tips first)"
+                    >
+                      Use local
+                    </button>
+                    <button
+                      className="tab-add-btn"
+                      onClick={() => lockstepResolve("remote")}
+                      disabled={lockstepBusy}
+                      title="Resolve the divergence with the remote host as the source of truth (backs up the mirror's overwritten tips first)"
+                    >
+                      Use remote
+                    </button>
+                    <button
+                      className="tab-add-btn"
+                      onClick={resolveInTerminal}
+                      disabled={lockstepBusy}
+                      title="Open a shell in the local mirror to merge or rebase by hand — the peer's tip is already at refs/eldrun/peer/<branch>"
+                    >
+                      Resolve in terminal
+                    </button>
+                  </>
+                )
+              )}
+              <button
+                className="tab-add-btn"
+                onClick={() => (backups ? setBackups(null) : loadBackups())}
+                disabled={lockstepBusy || lockstep.status === "disconnected"}
+                aria-pressed={!!backups}
+                title="List the refs/eldrun/backup/* safety refs a resolve saved, and restore one"
+              >
+                Backups
+              </button>
+              {lockstep.status === "desynchronized" && lockstep.detail && (
+                <span style={{ color: "var(--danger, #f85149)", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }} title={lockstep.detail}>
+                  {lockstep.detail}
+                </span>
+              )}
+              {/* Both heads, so a Use-local/Use-remote choice is informed (#28p D8). */}
+              {lockstep.status === "desynchronized" && !lockstep.pairingConflict && (
+                <span style={{ marginLeft: "auto", color: "var(--text-muted)", whiteSpace: "nowrap" }}>
+                  local: {headLabel(lockstep.localHead, lockstep.localSubject)} · remote:{" "}
+                  {headLabel(lockstep.remoteHead, lockstep.remoteSubject)}
+                </span>
+              )}
+            </>
+          )}
+        </div>
+      )}
+
+      {lockstepEligible && backups && (
+        <div className="git-lockstep-backups" style={{ borderBottom: "1px solid var(--border-color)", padding: "3px 6px", fontSize: 10, maxHeight: 140, overflowY: "auto" }}>
+          {backups.length === 0 ? (
+            <div style={{ color: "var(--text-muted)" }}>No backup refs — nothing has been overwritten.</div>
+          ) : (
+            backups.map((b) => (
+              <div key={`${b.peer}:${b.refname}`} style={{ display: "flex", alignItems: "center", gap: 6, padding: "1px 0" }}>
+                <span style={{ color: "var(--text-muted)" }}>{b.peer}</span>
+                <span>{b.branch}</span>
+                <span style={{ color: "var(--text-muted)" }}>{b.sha.slice(0, 7)}</span>
+                <span style={{ overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", flex: 1 }} title={b.subject}>
+                  {b.subject}
+                </span>
+                <span style={{ color: "var(--text-muted)" }}>
+                  {new Date(b.ts * 1000).toLocaleString()}
+                </span>
+                <button className="tab-add-btn" onClick={() => restoreBackup(b)} disabled={lockstepBusy} title={`Move ${b.peer} '${b.branch}' back to this commit (its current tip is backed up first)`}>
+                  Restore
+                </button>
+              </div>
+            ))
+          )}
+        </div>
+      )}
+
       {(localBranches.length > 0 || remoteBranches.length > 0) && (
         <div className="git-branch-list">
           {localBranches.map((b) => (
@@ -271,6 +767,9 @@ export function GitHistory({ projectDir, onChanged }: Props) {
               disabled={loading || b.is_current}
               title={b.is_current ? `On ${b.name}` : `Checkout ${b.name}`}
             >
+              {branchColor.has(b.name) && (
+                <span className="git-branch-dot" style={{ background: branchColor.get(b.name) }} aria-hidden />
+              )}
               {b.name}
             </button>
           ))}
@@ -282,12 +781,93 @@ export function GitHistory({ projectDir, onChanged }: Props) {
               disabled={loading}
               title={`Checkout ${b.name}`}
             >
+              {branchColor.has(b.name) && (
+                <span className="git-branch-dot" style={{ background: branchColor.get(b.name) }} aria-hidden />
+              )}
               {b.name}
             </button>
           ))}
         </div>
       )}
 
+      <div className="git-worktree-section">
+        <div className="git-worktree-header">
+          <span className="git-worktree-title">Worktrees</span>
+          <button
+            className="tab-add-btn"
+            onClick={() =>
+              setWtForm((f) =>
+                f ? null : { path: "", branch: localBranches[0]?.name ?? "", newBranch: false },
+              )
+            }
+            disabled={loading}
+            title="Add a worktree"
+          >
+            {wtForm ? "Cancel" : "+ Worktree"}
+          </button>
+        </div>
+        {worktrees.length > 0 && (
+          <div className="git-branch-list git-worktree-list">
+            {worktrees.map((wt) => {
+              const label = wt.branch || wt.head.slice(0, 7) || basename(wt.path);
+              return (
+                <span
+                  key={wt.path}
+                  className={`git-branch-pill${wt.is_main ? " current" : ""}`}
+                  title={wt.path}
+                >
+                  {wt.is_locked && <span aria-label="locked">🔒 </span>}
+                  {label}
+                  {!wt.is_main && (
+                    <button
+                      className="git-worktree-remove"
+                      onClick={() => removeWorktree(wt.path)}
+                      disabled={loading}
+                      aria-label={`Remove worktree ${wt.path}`}
+                      title={`Remove worktree ${wt.path}`}
+                    >
+                      ×
+                    </button>
+                  )}
+                </span>
+              );
+            })}
+          </div>
+        )}
+        {wtForm && (
+          <div className="git-worktree-form">
+            <Dropdown
+              value={wtForm.branch}
+              title="Branch"
+              onChange={(v) => setWtForm({ ...wtForm, branch: v })}
+              options={localBranches.map((b) => ({ value: b.name, label: b.name }))}
+            />
+            <input
+              type="text"
+              placeholder="Worktree path"
+              value={wtForm.path}
+              onChange={(e) => setWtForm({ ...wtForm, path: e.target.value })}
+              aria-label="Worktree path"
+            />
+            <label className="git-worktree-newbranch">
+              <Toggle
+                size="sm"
+                checked={wtForm.newBranch}
+                onChange={(e) => setWtForm({ ...wtForm, newBranch: e.target.checked })}
+              />
+              new branch
+            </label>
+            <button
+              className="tab-add-btn"
+              onClick={createWorktree}
+              disabled={loading || !wtForm.path.trim() || !wtForm.branch.trim()}
+            >
+              Create
+            </button>
+          </div>
+        )}
+      </div>
+
       {error && <div className="file-tree-error">{error}</div>}
       {loading && commits.length === 0 && <div className="file-tree-loading">Loading…</div>}
       {!loading && commits.length === 0 && !error && (
@@ -297,6 +877,8 @@ export function GitHistory({ projectDir, onChanged }: Props) {
       <div className={`git-commit-list${graphMode ? " graph" : ""}`}>
         {commits.map((c, i) => {
           const refs = parseRefs(c.refs);
+          // A branch tip carries at least one non-tag ref; mark it in the graph.
+          const isTip = refs.some((r) => !r.startsWith("tag: "));
           return (
             <button
               key={c.hash}
@@ -305,13 +887,28 @@ export function GitHistory({ projectDir, onChanged }: Props) {
               title={c.subject}
             >
               {graphMode && (
-                <CommitGraphCell row={graph[i]} height={GRAPH_ROW_H} lanes={graphLanes} head={c.is_head} />
+                <CommitGraphCell
+                  row={graph[i]}
+                  height={GRAPH_ROW_H}
+                  lanes={graphLanes}
+                  head={c.is_head}
+                  tip={isTip}
+                />
               )}
               <span className="git-commit-hash">{c.short}</span>
               <span className="git-commit-subject">{c.subject}</span>
-              {refs.map((r) => (
-                <span key={r} className="git-commit-ref">{r}</span>
-              ))}
+              {refs.map((r) => {
+                const color = branchColor.get(r);
+                return (
+                  <span
+                    key={r}
+                    className="git-commit-ref"
+                    style={color ? { background: color } : undefined}
+                  >
+                    {r}
+                  </span>
+                );
+              })}
               <span className="git-commit-date">{c.date}</span>
             </button>
           );
diff --git a/src/components/files/ProjectFilesPane.tsx b/src/components/files/ProjectFilesPane.tsx
new file mode 100644
index 0000000..82eaf72
--- /dev/null
+++ b/src/components/files/ProjectFilesPane.tsx
@@ -0,0 +1,485 @@
+import { useEffect, useMemo, useState } from "react";
+import { FileTree } from "./FileTree";
+import { DownloadsSection } from "./DownloadsSection";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useSyncStore } from "../../stores/sync";
+import { useBigFoldersStore } from "../../stores/bigFolders";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { useFileSourcePrefStore } from "../../stores/fileSourcePref";
+import { BOX_SCOPE_PREFIX, boxScopeId, useBoxesStore } from "../../stores/boxes";
+import { resolveLocalMirror, resolveProjectDirectory } from "../../types";
+import type { ProjectBox, ProjectEntry } from "../../types";
+import type { SortKey } from "../../lib/viewers/fileUtils";
+
+/**
+ * THE project file view — the tree, its sort row, the remote sync row and the
+ * Downloads section. Rendered twice: by the right panel, and by the "Files
+ * (Project)" tab (`ProjectFilesTab`). One component, so the two can never drift
+ * into two different file views of the same project.
+ *
+ * What each host still owns is what must differ between them: the browsed
+ * folder (two views of one project must not yank each other around), the
+ * remote/local source switch's placement, and the chrome around the tree.
+ */
+
+/** Whether a remote project's SSH pool is down. Git/endings/SFTP probes are
+ *  SYNCHRONOUS Tauri commands (main thread), so dispatching one at a dead
+ *  session freezes the window — every caller gates on this. Local projects are
+ *  never blocked. */
+export function useRemoteBlocked(projectId: string | null, isRemote: boolean) {
+  const remoteSshState = useRemoteStatusStore((s) =>
+    projectId ? s.byProject[projectId]?.ssh : undefined,
+  );
+  return { remoteSshState, remoteBlocked: isRemote && remoteSshState !== "connected" };
+}
+
+/**
+ * Which side of a remote project a file view shows. Defaults to whichever side
+ * is actually usable when the project changes: connected → Remote (the host
+ * tree), disconnected → Local (the mirror, so the view doesn't open on a Connect
+ * prompt). Only resets on a project switch — it never fights a mid-session
+ * manual toggle (flip to Remote, then lose the connection: the Connect
+ * placeholder takes over, but the toggle stays put).
+ *
+ * Backed by `useFileSourcePrefStore` (keyed by project id), not local state, so
+ * a freshly opened subwindow file viewer (`FileViewerPane`) can default to
+ * whichever side this tree is CURRENTLY showing for the project.
+ */
+export function useFileSource(projectId: string | null, isRemote: boolean) {
+  const stored = useFileSourcePrefStore((s) => (projectId ? s.byProject[projectId] : undefined));
+  const { remoteSshState } = useRemoteBlocked(projectId, isRemote);
+  // `isRemote` (not just `projectId`) in the deps: a project can flip local → remote
+  // ("Extend to remote") while this view is already mounted on the same id, and
+  // without re-seeding here it keeps whatever the store already held — typically
+  // nothing for a project that was never remote, which falls through to the
+  // "remote" default below and points every file op at an SFTP host that may not
+  // have finished its first lockstep sync yet. `isRemote` itself only moves on an
+  // extend/detach, never on a mere connect/disconnect, so this can't fight a
+  // mid-session manual toggle the way resetting on `remoteSshState` would.
+  useEffect(() => {
+    if (projectId && isRemote) {
+      useFileSourcePrefStore.getState().set(projectId, remoteSshState === "connected" ? "remote" : "local");
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projectId, isRemote]);
+  const setSource = (s: "remote" | "local") => {
+    if (projectId) useFileSourcePrefStore.getState().set(projectId, s);
+  };
+  return [stored ?? "remote", setSource] as const;
+}
+
+/**
+ * Like `useFileSource`, but for a viewer that must NOT keep mirroring the
+ * shared per-project preference forever — only take it as a starting point.
+ * Every `ProjectFilesTab` instance (the standalone Files (Project) tab, and
+ * every per-subwindow ◫ sidebar) used to share `useFileSourcePrefStore`
+ * with the right panel, so flipping Local/Remote *anywhere* flipped it
+ * *everywhere* for that project — one shared toggle wearing many faces
+ * instead of each viewer owning its own. This seeds from the right panel's
+ * current value on mount (and again if the underlying project's identity or
+ * remote-ness changes, matching `useFileSource`'s own reseed), then keeps the
+ * choice in plain component state: this viewer's later toggles never write
+ * back to the shared store, and the shared store's later changes never read
+ * back into this viewer.
+ */
+export function useIndependentFileSource(projectId: string | null, isRemote: boolean) {
+  const { remoteSshState } = useRemoteBlocked(projectId, isRemote);
+  const [source, setSource] = useState<"remote" | "local">("remote");
+  useEffect(() => {
+    if (!projectId || !isRemote) return;
+    const shared = useFileSourcePrefStore.getState().byProject[projectId];
+    setSource(shared ?? (remoteSshState === "connected" ? "remote" : "local"));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projectId, isRemote]);
+  return [source, setSource] as const;
+}
+
+/** The Remote/Local file-source switch (remote SSH projects only). A live
+ *  segmented control — NOT a tag — that flips the tree between the host tree
+ *  over SFTP ("Remote") and the synced mirror ("Local"). */
+export function FileSourceSwitch({
+  source,
+  onChange,
+  remoteDisabled = false,
+  remoteDisabledTitle,
+}: {
+  source: "remote" | "local";
+  onChange: (s: "remote" | "local") => void;
+  /** Disable the Remote segment — used when the open file has no counterpart on
+   *  the host (a local-only file), so the switch can't strand the viewer on a
+   *  read error. Ignored while the Remote side is the active one. */
+  remoteDisabled?: boolean;
+  remoteDisabledTitle?: string;
+}) {
+  // Never disable the segment that's currently active — that would leave the
+  // switch with no lit button. (A remote-native tab whose file is missing shows
+  // its own read error; the escape hatch there is switching TO Local.)
+  const disableRemote = remoteDisabled && source !== "remote";
+  return (
+    <span className="right-panel-source-switch" role="group" aria-label="File source">
+      <button
+        type="button"
+        className={`source-seg${source === "local" ? " active" : ""}`}
+        aria-pressed={source === "local"}
+        onClick={() => onChange("local")}
+        title="Show the local synced mirror copy."
+      >
+        Local
+      </button>
+      <button
+        type="button"
+        className={`source-seg${source === "remote" ? " active" : ""}`}
+        aria-pressed={source === "remote"}
+        disabled={disableRemote}
+        onClick={() => onChange("remote")}
+        title={
+          disableRemote
+            ? remoteDisabledTitle ?? "This file isn't on the remote host (local-only)."
+            : "Show the host tree over SFTP (remote)."
+        }
+      >
+        Remote
+      </button>
+    </span>
+  );
+}
+
+export interface BoxRoot {
+  rootId: string;
+  label: string;
+  icon: string;
+  dir: string;
+  localFile?: string;
+  variant: "box" | "member";
+}
+
+/** A box scope has no single root: the file view shows the box folder plus every
+ *  member project's root. Resolved from the scope id, not the active project. */
+export function useBoxRoots(scope: string): { activeBox: ProjectBox | null; boxRoots: BoxRoot[] } {
+  const projects = useProjectsStore((s) => s.projects);
+  const boxes = useBoxesStore((s) => s.boxes);
+  const activeBox = useMemo(
+    () =>
+      scope.startsWith(BOX_SCOPE_PREFIX)
+        ? boxes.find((b) => boxScopeId(b.id) === scope) ?? null
+        : null,
+    [scope, boxes],
+  );
+  const boxRoots = useMemo(() => {
+    if (!activeBox) return [];
+    const roots: BoxRoot[] = [];
+    if (activeBox.folder) {
+      roots.push({ rootId: scope, label: activeBox.name, icon: "▣", dir: activeBox.folder, variant: "box" });
+    }
+    for (const id of activeBox.member_ids) {
+      const p = projects.find((m) => m.id === id);
+      if (!p) continue;
+      const dir = resolveProjectDirectory(p);
+      if (!dir) continue;
+      roots.push({ rootId: p.id, label: p.name, icon: "📁", dir, localFile: p.local_file, variant: "member" });
+    }
+    return roots;
+  }, [activeBox, projects, scope]);
+  return { activeBox, boxRoots };
+}
+
+/** One collapsible root inside the box multi-root file view. Reuses `FileTree`
+ *  as-is for a single directory; per-root navigation persists via the projects
+ *  store's `rightPanelFolderByProject` map keyed by the root's id. */
+function BoxRootSection({
+  rootId,
+  label,
+  icon,
+  dir,
+  localFile,
+  variant,
+  sortKey,
+  descending,
+}: BoxRoot & { sortKey: SortKey; descending: boolean }) {
+  const [collapsed, setCollapsed] = useState(false);
+  const rel = useProjectsStore((s) => s.rightPanelFolderByProject[rootId] ?? "");
+  const setRightPanelFolder = useProjectsStore((s) => s.setRightPanelFolder);
+  return (
+    <div className={`file-root file-root--${variant}${collapsed ? " is-collapsed" : ""}`}>
+      <button
+        type="button"
+        className="file-root-header"
+        onClick={() => setCollapsed((c) => !c)}
+        title={dir}
+      >
+        <span className="file-root-caret" aria-hidden>
+          {collapsed ? "▸" : "▾"}
+        </span>
+        <span className="file-root-icon" aria-hidden>
+          {icon}
+        </span>
+        <span className="file-root-name">{label}</span>
+        <span className="file-root-kind">{variant === "box" ? "box" : "project"}</span>
+      </button>
+      {!collapsed && (
+        <div className="file-root-body">
+          <FileTree
+            projectDir={dir}
+            projectId={rootId}
+            localFile={localFile}
+            sortKey={sortKey}
+            descending={descending}
+            hiddenEndings={[]}
+            hiddenPaths={[]}
+            shownPaths={[]}
+            initialRelPath={rel}
+            onRelPathChange={(folder) => setRightPanelFolder(rootId, folder)}
+          />
+        </div>
+      )}
+    </div>
+  );
+}
+
+interface Props {
+  /** Tab scope this view belongs to: a project id, a `box:<id>` scope, or "root". */
+  scope: string;
+  /** The project the tree shows, or null in the root scope / a box scope. */
+  project: ProjectEntry | null;
+  /** The tree's root directory (the project dir, or the tab's cwd at root). */
+  projectDir: string;
+  /** Project-relative folder currently browsed, owned by the host. */
+  folder: string;
+  onFolderChange: (folder: string) => void;
+  /** Which side of a remote project to show (see useFileSource). */
+  source: "remote" | "local";
+  hiddenEndings: string[];
+  hiddenPaths: string[];
+  shownPaths: string[];
+  /** Folders excluded from recursive scans, and the toggle that maintains the
+   *  list. Omitted by hosts with no project.json to write to (a box's multi-root
+   *  view), which simply don't offer the action. */
+  scanExcluded?: string[];
+  onToggleScanExcluded?: (relPath: string, excluded: boolean) => void;
+  /** Sort is the host's, not the pane's: the right panel unmounts this pane when
+   *  it shows Git/Search, and a sort order that reset itself on the way back
+   *  would be a worse view than the one the user chose. */
+  sortKey: SortKey;
+  descending: boolean;
+  onSortChange: (sortKey: SortKey, descending: boolean) => void;
+  showDownloads: boolean;
+  onCloseDownloads: () => void;
+  /** Offers the tree's "Open in a new tab" action (see FileTree). Omitted where
+   *  the host can't own a tab — a box's multi-root view, a detached window. */
+  onOpenFolderTab?: (relPath: string) => void;
+  /** False keeps the tree unmounted (the right panel does this while closed, so
+   *  a hidden panel costs no fs-watch). */
+  mountTree?: boolean;
+  /** Compact (docked subwindow) mode: hide the remote-sync row and the sort row
+   *  so the tree's find-files search box is the topmost element. */
+  compact?: boolean;
+}
+
+export function ProjectFilesPane({
+  scope,
+  project,
+  projectDir,
+  folder,
+  onFolderChange,
+  source,
+  hiddenEndings,
+  hiddenPaths,
+  shownPaths,
+  scanExcluded,
+  onToggleScanExcluded,
+  sortKey,
+  descending,
+  onSortChange,
+  showDownloads,
+  onCloseDownloads,
+  onOpenFolderTab,
+  mountTree = true,
+  compact,
+}: Props) {
+  const { activeBox, boxRoots } = useBoxRoots(scope);
+  const projectId = project?.id ?? null;
+  const isRemoteProject = !!project?.remote;
+  const { remoteSshState, remoteBlocked } = useRemoteBlocked(projectId, isRemoteProject);
+  const syncMap = useSyncStore((s) => (projectId ? s.byProject[projectId] : undefined));
+
+  return (
+    <>
+      {/* The whole-tree sync action for the active source: Remote → pull the host
+          tree into the mirror; Local → push the mirror back to the host (skipping
+          host-diverged/orange files). Both need a live connection, so the row is
+          gated on !remoteBlocked. */}
+      {!compact && !activeBox && isRemoteProject && projectId && !remoteBlocked && (
+        <div className="right-panel-source">
+          {/* Project-wide auto-sync toggle: the root "" marker. When on, the
+              whole tree bidirectionally auto-syncs; individual files/folders
+              can still be carved out (or opted in) from their own context
+              menu, which overrides this. */}
+          {(() => {
+            const autoAll = !!syncMap?.[""]?.auto;
+            return (
+              <button
+                className="tab-add-btn"
+                style={{
+                  fontSize: 10,
+                  padding: "1px 6px",
+                  height: 20,
+                  ...(autoAll
+                    ? { color: "var(--accent)", borderColor: "var(--accent)" }
+                    : {}),
+                }}
+                onClick={() =>
+                  void useSyncStore.getState().setAuto(projectId, [""], !autoAll, true)
+                }
+                title={
+                  autoAll
+                    ? "Auto-syncing the whole project (⟳). Click to stop. Individual files/folders can still be excluded or included from their right-click menu."
+                    : "Auto-sync the whole project bidirectionally (host ⇄ local mirror). Diverged files are left for manual resolution; per-file/folder toggles override this."
+                }
+              >
+                {autoAll ? "⟳ Auto-sync: all" : "Auto-sync all"}
+              </button>
+            );
+          })()}
+          {/* The whole-project version of the file tree's per-folder auto-sync
+              price check: which folders are too big to sync, on both sides. It
+              opens itself once when a project is first paired with a host; this
+              is how it is re-opened (e.g. once the project is finally connected,
+              so the host column can be filled in). */}
+          <button
+            className="tab-add-btn"
+            style={{ fontSize: 10, padding: "1px 6px", height: 20 }}
+            onClick={() => useBigFoldersStore.getState().open(projectId)}
+            title="Find the folders too big to sync (on this machine and on the host) and choose which to exclude"
+          >
+            Large folders…
+          </button>
+          {source === "remote" ? (
+            <button
+              className="tab-add-btn"
+              style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: "auto" }}
+              onClick={() => void useSyncStore.getState().syncWholeProject(projectId)}
+              title="Sync the whole project tree into the local mirror (remote → local)"
+            >
+              Sync all
+            </button>
+          ) : (
+            <button
+              className="tab-add-btn"
+              style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: "auto" }}
+              onClick={() => void useSyncStore.getState().pushWholeProject(projectId)}
+              title="Push the whole local mirror to the host (local → remote). Files that diverged on the host (orange) are skipped, never overwritten."
+            >
+              Sync all
+            </button>
+          )}
+        </div>
+      )}
+      {!compact && (
+      <div className="right-panel-sort">
+        {(["name", "size", "type", "created", "modified"] as SortKey[]).map((key) => (
+          <button
+            key={key}
+            className={`sort-key-btn${sortKey === key ? " active" : ""}`}
+            onClick={() =>
+              sortKey === key
+                ? onSortChange(key, !descending)
+                : onSortChange(key, descending)
+            }
+            title={sortKey === key ? (descending ? "Descending — click to reverse" : "Ascending — click to reverse") : `Sort by ${key}`}
+          >
+            {key}{sortKey === key ? (descending ? " ↓" : " ↑") : ""}
+          </button>
+        ))}
+      </div>
+      )}
+      <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto" }}>
+        {mountTree && activeBox ? (
+          boxRoots.length === 0 ? (
+            <div className="file-tree-empty">No member project folders</div>
+          ) : (
+            boxRoots.map((r) => (
+              <BoxRootSection
+                key={r.rootId}
+                {...r}
+                sortKey={sortKey}
+                descending={descending}
+              />
+            ))
+          )
+        ) : (
+          mountTree && (() => {
+            // A remote project's "Local" source points the tree at the local
+            // mirror dir (browsed as a plain local tree); "Remote" keeps the host
+            // (SFTP) tree with the sync overlay. A local project ignores it.
+            //
+            // Disconnected remote source: don't mount the SFTP-backed tree (its
+            // main-thread list_dir would freeze the window). Keep the view looking
+            // the same — the Remote/Local switch stays up — but show a Connect
+            // prompt in the tree area. Selecting "Local" still browses the offline
+            // mirror.
+            if (isRemoteProject && source === "remote" && remoteBlocked) {
+              return (
+                <div className="file-tree-empty" style={{ display: "flex", flexDirection: "column", alignItems: "center", gap: 8 }}>
+                  <div>
+                    {remoteSshState === "connecting"
+                      ? "Connecting to the remote host…"
+                      : "Disconnected — connect to browse the remote tree."}
+                  </div>
+                  {remoteSshState !== "connecting" && projectId && (
+                    <button
+                      type="button"
+                      className="dialog-connect-btn"
+                      onClick={() => useRemoteMachinesStore.getState().open(projectId)}
+                    >
+                      Connect
+                    </button>
+                  )}
+                </div>
+              );
+            }
+            // The relocatable mirror override (projects.json `extra["mirror"]`,
+            // updated by `move_remote_mirror`) is authoritative; fall back to the
+            // default `<state_dir>/mirror` only for legacy projects that never
+            // persisted one. Computing `${projectDir}/mirror` unconditionally
+            // pointed the Local tree at the pre-move location after a relocate.
+            const mirrorDir =
+              resolveLocalMirror(project) ??
+              (projectDir
+                ? `${projectDir.replace(/[/\\]+$/, "")}/mirror`
+                : projectDir);
+            const treeDir = isRemoteProject && source === "local" ? mirrorDir : projectDir;
+            return (
+              <FileTree
+                projectDir={treeDir}
+                projectId={projectId}
+                localFile={project?.local_file}
+                sortKey={sortKey}
+                descending={descending}
+                hiddenEndings={hiddenEndings}
+                hiddenPaths={hiddenPaths}
+                shownPaths={shownPaths}
+                scanExcluded={scanExcluded}
+                onToggleScanExcluded={onToggleScanExcluded}
+                initialRelPath={folder}
+                onRelPathChange={onFolderChange}
+                onOpenFolderTab={onOpenFolderTab}
+                syncSource={isRemoteProject ? source : undefined}
+                remoteProbeDir={isRemoteProject ? projectDir : undefined}
+              />
+            );
+          })()
+        )}
+      </div>
+      {showDownloads && !activeBox && projectDir && (
+        <DownloadsSection
+          projectDir={projectDir}
+          projectId={projectId}
+          targetFolder={folder}
+          isRemote={isRemoteProject}
+          onClose={onCloseDownloads}
+        />
+      )}
+    </>
+  );
+}
diff --git a/src/components/files/ProjectFilesSettings.tsx b/src/components/files/ProjectFilesSettings.tsx
new file mode 100644
index 0000000..9ec88e2
--- /dev/null
+++ b/src/components/files/ProjectFilesSettings.tsx
@@ -0,0 +1,392 @@
+import { useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { Toggle } from "../common/Toggle";
+import { Dropdown } from "../common/Dropdown";
+import { useSettingsStore } from "../../stores/settings";
+import { VIEWER_PREF_TYPES } from "../../lib/viewers/fileUtils";
+import { PythonInterpreterWindow } from "../projects/PythonInterpreterWindow";
+import type { ProjectEntry, ViewerPref } from "../../types";
+
+/**
+ * The file-view filters (which endings/paths a project's tree hides) and the
+ * Project Settings dialog that edits them. Shared by the right panel and the
+ * "Files (Project)" tab so the two views hide the same files: the lists live in
+ * the project's own `project.json`, not in either host's state.
+ */
+
+type ProjectJson = Record<string, unknown>;
+
+const PANEL_HIDDEN_ENDINGS_KEY = "panel_hidden_endings";
+const PANEL_HIDDEN_PATHS_KEY = "panel_hidden_paths";
+const PANEL_SHOWN_PATHS_KEY = "panel_shown_paths";
+/** Folders excluded from every recursive scan. Read by the backend too — keep the
+ *  spelling in step with `commands::fs::excluded_rel_set`. */
+const SCAN_EXCLUDED_PATHS_KEY = "scan_excluded_paths";
+
+/** The one spelling of a scan-exclusion path: project-relative, forward slashes,
+ *  no leading/trailing separator. Mirrors the backend's `excluded_rel_set`, so a
+ *  path written here matches the one the walk builds as it descends. */
+export function normalizeScanPath(rel: string): string {
+  return rel.replace(/\\/g, "/").trim().replace(/^\.\//, "").replace(/^\/+|\/+$/g, "");
+}
+
+/** File endings that mark a project as holding Python — gates the interpreter
+ *  picker, mirroring the pill's `PYTHON_ENDINGS`. */
+const PYTHON_ENDINGS = new Set([".py", ".pyw", ".pyi"]);
+
+function readStringList(project: ProjectJson | null, key: string): string[] {
+  const raw = project?.[key];
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((item): item is string => typeof item === "string");
+}
+
+function mergeEndings(...groups: string[][]): string[] {
+  const endings = new Map<string, string>();
+  for (const group of groups) {
+    for (const ending of group) {
+      const trimmed = ending.trim();
+      if (!trimmed) continue;
+      endings.set(trimmed.toLowerCase(), trimmed);
+    }
+  }
+  return [...endings.values()].sort((a, b) => a.localeCompare(b));
+}
+
+export interface ProjectFileFilters {
+  hiddenEndings: string[];
+  hiddenPaths: string[];
+  shownPaths: string[];
+  availableEndings: string[];
+  /** Folders the user excluded from recursive scans (see `toggleScanExcluded`). */
+  scanExcluded: string[];
+  error: string | null;
+  toggleHiddenEnding: (ending: string, checked: boolean) => void;
+  /**
+   * Exclude/include a folder from every recursive scan: the size walk
+   * (`dir_size`/`dir_size_breakdown`) and the file-churn watcher
+   * (`services::usage_stats`), which both read this same list.
+   *
+   * Deliberately NOT the same list as `hiddenPaths`. "I don't want to look at
+   * this" and "never traverse this" are different intents — a folder can be
+   * hidden but still worth weighing, and one that is excluded stays visible so
+   * the exclusion is discoverable and reversible from the row it applies to.
+   */
+  toggleScanExcluded: (relPath: string, excluded: boolean) => void;
+}
+
+/**
+ * Load a project's tree-hiding lists from its `project.json`, and save endings
+ * back to it. `remoteBlocked` suppresses the ending SCAN only: it walks the
+ * project dir over SFTP for a remote project and would freeze the main thread
+ * while the pool is down — `load_project` reads the local file and is always safe.
+ */
+export function useProjectFileFilters(opts: {
+  localFile?: string;
+  projectDir: string;
+  remoteBlocked: boolean;
+}): ProjectFileFilters {
+  const { localFile, projectDir, remoteBlocked } = opts;
+  const [project, setProject] = useState<ProjectJson | null>(null);
+  const [hiddenEndings, setHiddenEndings] = useState<string[]>([]);
+  const [availableEndings, setAvailableEndings] = useState<string[]>([]);
+  const [hiddenPaths, setHiddenPaths] = useState<string[]>([]);
+  const [shownPaths, setShownPaths] = useState<string[]>([]);
+  const [scanExcluded, setScanExcluded] = useState<string[]>([]);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    setError(null);
+    if (!localFile || !projectDir) {
+      setProject(null);
+      setHiddenEndings([]);
+      setAvailableEndings([]);
+      setHiddenPaths([]);
+      setShownPaths([]);
+      setScanExcluded([]);
+      return;
+    }
+    Promise.all([
+      invoke<ProjectJson>("load_project", { localFile }),
+      remoteBlocked
+        ? Promise.resolve<string[]>([])
+        : invoke<string[]>("list_project_endings", { projectDir }).catch(() => []),
+    ])
+      .then(([loaded, endings]) => {
+        const savedHiddenEndings = readStringList(loaded, PANEL_HIDDEN_ENDINGS_KEY);
+        setProject(loaded);
+        setHiddenEndings(savedHiddenEndings);
+        setAvailableEndings(mergeEndings(endings, savedHiddenEndings));
+        setHiddenPaths(readStringList(loaded, PANEL_HIDDEN_PATHS_KEY));
+        setShownPaths(readStringList(loaded, PANEL_SHOWN_PATHS_KEY));
+        setScanExcluded(readStringList(loaded, SCAN_EXCLUDED_PATHS_KEY).map(normalizeScanPath).filter(Boolean));
+      })
+      .catch((e) => {
+        setProject(null);
+        setHiddenEndings([]);
+        setAvailableEndings([]);
+        setHiddenPaths([]);
+        setShownPaths([]);
+        setScanExcluded([]);
+        setError(String(e));
+      });
+  }, [localFile, projectDir, remoteBlocked]);
+
+  const saveHiddenEndings = async (nextEndings: string[]) => {
+    if (!localFile || !project) return;
+    const nextProject = {
+      ...project,
+      [PANEL_HIDDEN_ENDINGS_KEY]: nextEndings,
+      [PANEL_HIDDEN_PATHS_KEY]: hiddenPaths,
+      [PANEL_SHOWN_PATHS_KEY]: shownPaths,
+    };
+    setHiddenEndings(nextEndings);
+    setProject(nextProject);
+    setError(null);
+    try {
+      await invoke("save_project", { localFile, project: nextProject });
+    } catch (e) {
+      setError(String(e));
+    }
+  };
+
+  const toggleHiddenEnding = (ending: string, checked: boolean) => {
+    const existing = new Set(hiddenEndings.map((item) => item.toLowerCase()));
+    const nextEndings = checked
+      ? existing.has(ending.toLowerCase())
+        ? hiddenEndings
+        : [...hiddenEndings, ending]
+      : hiddenEndings.filter((item) => item.toLowerCase() !== ending.toLowerCase());
+    void saveHiddenEndings(nextEndings);
+  };
+
+  const toggleScanExcluded = (relPath: string, excluded: boolean) => {
+    const rel = normalizeScanPath(relPath);
+    if (!rel || !localFile || !project) return;
+    const next = excluded
+      ? scanExcluded.includes(rel)
+        ? scanExcluded
+        : [...scanExcluded, rel]
+      : scanExcluded.filter((item) => normalizeScanPath(item) !== rel);
+    // Optimistic: the tree re-requests sizes off this list, and a failed write
+    // surfaces in `error` — the alternative (await, then update) leaves the row
+    // showing a size the user just asked us to stop computing.
+    setScanExcluded(next);
+    const nextProject = { ...project, [SCAN_EXCLUDED_PATHS_KEY]: next };
+    setProject(nextProject);
+    setError(null);
+    invoke("save_project", { localFile, project: nextProject }).catch((e) => setError(String(e)));
+  };
+
+  return {
+    hiddenEndings,
+    hiddenPaths,
+    shownPaths,
+    availableEndings,
+    scanExcluded,
+    error,
+    toggleHiddenEnding,
+    toggleScanExcluded,
+  };
+}
+
+/** Project Settings: which file endings the tree hides, plus the (global)
+ *  native-viewer preferences. Portaled, so it opens the same from the panel's
+ *  gear and the Files (Project) tab's. */
+export function ProjectFilesSettingsDialog({
+  localFile,
+  project,
+  filters,
+  onClose,
+}: {
+  localFile: string;
+  /** The project this gear belongs to — used to offer the Python interpreter
+   *  picker (the same one the project pill opens). Null in root/box scope. */
+  project: ProjectEntry | null;
+  filters: ProjectFileFilters;
+  onClose: () => void;
+}) {
+  const settings = useSettingsStore((s) => s.settings);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+  const { availableEndings, hiddenEndings, error, toggleHiddenEnding } = filters;
+  const [showPython, setShowPython] = useState(false);
+
+  // Offer the Python interpreter picker on the same terms the pill does: the
+  // project holds Python files (a probed ending), or it's remote (probed on the
+  // host, which may hold Python the local mirror doesn't).
+  const hasPython =
+    !!project &&
+    (!!project.remote ||
+      availableEndings.some((e) => PYTHON_ENDINGS.has(e.toLowerCase())));
+
+  return createPortal(
+    <div className="modal-backdrop how-to-start-backdrop" onMouseDown={onClose}>
+      <div className="settings-dialog project-settings-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>Project Settings</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+
+        <div className="settings-section-title">File Hiding</div>
+        <p className="settings-help">
+          Click an ending to hide matching files in the project file views. Dimmed endings are hidden.
+        </p>
+        {availableEndings.length === 0 ? (
+          <div className="settings-empty">No file endings found in this project.</div>
+        ) : (
+          <div className="settings-list project-ending-list">
+            {availableEndings.map((ending) => {
+              const checked = hiddenEndings.some((item) => item.toLowerCase() === ending.toLowerCase());
+              return (
+                <button
+                  type="button"
+                  className={`project-ending-toggle${checked ? " is-hidden" : ""}`}
+                  key={ending}
+                  aria-pressed={checked}
+                  onClick={() => toggleHiddenEnding(ending, !checked)}
+                  title={checked ? `Show ${ending} files` : `Hide ${ending} files`}
+                >
+                  {ending}
+                </button>
+              );
+            })}
+          </div>
+        )}
+        {error && <div className="settings-error">{error}</div>}
+
+        {hasPython && project && (
+          <>
+            <div className="settings-section-title">Python</div>
+            <p className="settings-help">
+              Which interpreter the code viewer's Run and Debug buttons use.
+              Auto-detect by default; pin a venv or other environment when
+              Eldrun can't infer it.
+            </p>
+            <button
+              className="tab-add-btn"
+              style={{ fontSize: 11, padding: "2px 8px" }}
+              onClick={() => setShowPython(true)}
+            >
+              {project.python_interpreter ? "✓ " : ""}Python interpreter…
+            </button>
+          </>
+        )}
+
+        {/* #48 per-file-type native-viewer settings (global, not per-project).
+            Toggles opt-in local autocomplete (#45) per type, plus the global
+            autosave (#47). */}
+        <div className="settings-section-title">Native Viewers</div>
+        <p className="settings-help">
+          Eldrun renders these file types in-app. Disable a type to open its
+          files in your external default app instead. Autocomplete is
+          local-only (Ollama) and opt-in.
+        </p>
+        <label className="viewer-pref-toggle" style={{ marginBottom: 6 }}>
+          <Toggle
+            size="sm"
+            checked={settings?.autosave !== false}
+            onChange={(e) => void updateSettings({ autosave: e.target.checked })}
+          />
+          <span>Autosave edits</span>
+        </label>
+        <label className="viewer-pref-toggle" style={{ marginBottom: 6 }}>
+          <Toggle
+            size="sm"
+            checked={settings?.change_tint !== false}
+            onChange={(e) => void updateSettings({ change_tint: e.target.checked })}
+          />
+          <span>Highlight recent edits (new→old colour trail)</span>
+        </label>
+        <div className="viewer-prefs-list">
+          {VIEWER_PREF_TYPES.map((t) => {
+            const pref: ViewerPref = settings?.viewer_prefs?.[t.id] ?? {};
+            const enabled = pref.enabled !== false;
+            const patch = (next: ViewerPref) =>
+              void updateSettings({
+                viewer_prefs: {
+                  ...(settings?.viewer_prefs ?? {}),
+                  [t.id]: { ...pref, ...next },
+                },
+              });
+            return (
+              <div className="viewer-pref-row" key={t.id}>
+                <span className="viewer-pref-name">{t.label}</span>
+                <span className="viewer-pref-exts">{t.extensions.join(" ")}</span>
+                <label className="viewer-pref-toggle">
+                  <Toggle
+                    size="sm"
+                    checked={enabled}
+                    onChange={(e) => patch({ enabled: e.target.checked })}
+                  />
+                  <span>Enabled</span>
+                </label>
+                {t.autocomplete && (
+                  <>
+                    <label className="viewer-pref-toggle">
+                      <Toggle
+                        size="sm"
+                        checked={pref.autocomplete === true}
+                        disabled={!enabled}
+                        onChange={(e) => patch({ autocomplete: e.target.checked })}
+                      />
+                      <span>Autocomplete</span>
+                    </label>
+                    {/* #45 default completion-length mode; toggled live
+                        in-editor with Shift+Tab while a suggestion shows. */}
+                    <Dropdown
+                      className="viewer-pref-mode"
+                      value={pref.autocomplete_mode ?? "sentence"}
+                      disabled={!enabled || pref.autocomplete !== true}
+                      title="Default completion length (toggle live with Shift+Tab)"
+                      onChange={(v) =>
+                        patch({ autocomplete_mode: v as ViewerPref["autocomplete_mode"] })
+                      }
+                      options={[
+                        { value: "sentence", label: "Sentence" },
+                        { value: "block", label: "Block" },
+                        { value: "scope", label: "Scope" },
+                      ]}
+                    />
+                    {/* Local-model grammar/spelling check — underlines typos
+                        (red), grammar (blue), style (green) in the editor. */}
+                    <label className="viewer-pref-toggle">
+                      <Toggle
+                        size="sm"
+                        checked={pref.grammar_check === true}
+                        disabled={!enabled}
+                        onChange={(e) => patch({ grammar_check: e.target.checked })}
+                      />
+                      <span>Grammar</span>
+                    </label>
+                  </>
+                )}
+              </div>
+            );
+          })}
+        </div>
+
+        {settings?.debug && (
+          <>
+            <div className="settings-section-title">Debug</div>
+            <button
+              className="tab-add-btn"
+              style={{ fontSize: 11, padding: "2px 8px", width: "100%", color: "var(--danger, #f85149)" }}
+              onClick={() => {
+                invoke("clear_project_session", { localFile }).then(() => {
+                  window.location.reload();
+                }).catch(console.error);
+              }}
+            >
+              Clear session storage
+            </button>
+          </>
+        )}
+      </div>
+
+      {showPython && project && (
+        <PythonInterpreterWindow project={project} onClose={() => setShowPython(false)} />
+      )}
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/files/ProjectFilesTab.tsx b/src/components/files/ProjectFilesTab.tsx
new file mode 100644
index 0000000..78f1c20
--- /dev/null
+++ b/src/components/files/ProjectFilesTab.tsx
@@ -0,0 +1,122 @@
+import { useEffect, useState } from "react";
+import { ProjectFilesView } from "./ProjectFilesView";
+import { useIndependentFileSource } from "./ProjectFilesPane";
+import { useProjectsStore } from "../../stores/projects";
+import { PROJECT_FILES_TAB_CMD, useTabsStore } from "../../stores/tabs";
+import { resolveProjectDirectory } from "../../types";
+
+/**
+ * Open a Files (Project) tab on a folder — what the file tree's "Open in a new
+ * tab" does, from the right panel and from another Files (Project) tab alike.
+ * The tab lands in the store's current scope, i.e. the project the tree belongs
+ * to. Always labelled "Files (Project)" so it reads as this tab kind (not the
+ * plain "Files" explorer) at a glance; the browsed folder shows in the tab's
+ * own header instead (see `ProjectFilesView`'s header).
+ */
+export function openProjectFilesTab(cwd: string, folder: string) {
+  useTabsStore.getState().addTab({
+    label: "Files (Project)",
+    cmd: PROJECT_FILES_TAB_CMD,
+    args: [],
+    env: {},
+    cwd,
+    kind: "projectfiles",
+    folder,
+  });
+}
+
+/**
+ * The "Files (Project)" tab: the right panel's file viewer, hosted in a tab.
+ * Everything visible — the view switcher, git bar + history, search, apps,
+ * orange list, tree, drag-and-drop, sync overlay, type tags, source switch and
+ * settings — comes from the shared `ProjectFilesView`, the same component
+ * `RightPanel` renders, so the tab can never drift from the panel. This host
+ * owns only what must differ: it resolves the project from its own `scope`
+ * (rather than the active project) and keeps the browsed folder on the *tab*
+ * (`TabEntry.folder`, persisted), which is what makes "Open in a new tab" on a
+ * folder mean anything after a restart. It passes none of the panel-only window
+ * chrome (pin, resize border, hidden-subwindows) — a tab has none.
+ */
+interface Props {
+  /** The tab's scope: a project id, a `box:<id>` scope, or "root". */
+  scope: string;
+  /** The tab's cwd — the tree root when the scope has no project (root scope). */
+  cwd: string;
+  /** This tab's key, so its browsed folder persists onto the tab. */
+  tabKey?: string;
+  /** The folder the tab was opened on / last left at. */
+  folder?: string;
+  /** Override where a folder change is persisted. The docked subwindow viewer
+   *  passes this to route the browsed folder onto its group NODE
+   *  (`GroupNode.filesFolder`) instead of a tab; when omitted, a folder change
+   *  persists onto `tabKey`'s `TabEntry.folder` as before. */
+  persistFolder?: (folder: string) => void;
+  /** Whether this window owns the tab store (the main window does; a popout runs
+   *  on a streamed copy). Gates the tree's "Open in a new tab" action. */
+  canOpenTabs?: boolean;
+  /** Whether this tab is the visible one in its group. Gates the git/windows
+   *  probes so a background tab doesn't churn — its tree stays mounted regardless. */
+  visible?: boolean;
+  /** Compact mode: strip the header + view-switcher toolbar + sync/sort rows so
+   *  the find-files search is topmost. Set by the docked subwindow viewer only. */
+  compact?: boolean;
+}
+
+export function ProjectFilesTab({
+  scope,
+  cwd,
+  tabKey,
+  folder: initialFolder,
+  canOpenTabs,
+  visible,
+  compact,
+  persistFolder,
+}: Props) {
+  const projects = useProjectsStore((s) => s.projects);
+  const project = projects.find((p) => p.id === scope) ?? null;
+  const projectDir = project ? resolveProjectDirectory(project) : cwd;
+
+  const [folder, setFolder] = useState(initialFolder ?? "");
+  const [source, setSource] = useIndependentFileSource(project?.id ?? null, !!project?.remote);
+
+  // Re-seed when the persisted folder changes out from under us — a restart
+  // restore or a popout's streamed `files` edit hands a new browsed folder that
+  // must win over local state. In steady state the persisted value tracks
+  // `folder`, so this is a no-op except on those external updates.
+  useEffect(() => {
+    setFolder(initialFolder ?? "");
+  }, [initialFolder]);
+
+  const onFolderChange = (next: string) => {
+    setFolder(next);
+    // Persist so it reopens where it was left (debounced by the store's own
+    // saveLayout): the docked viewer routes onto its group node (persistFolder),
+    // a tab onto its own TabEntry.folder.
+    if (persistFolder) persistFolder(next);
+    else if (tabKey) useTabsStore.getState().setTabFolder(tabKey, next);
+  };
+
+  if (!projectDir) {
+    return <div className="file-tree-empty">No project selected</div>;
+  }
+
+  return (
+    <ProjectFilesView
+      scope={scope}
+      projectId={project?.id ?? null}
+      project={project}
+      projectDir={projectDir}
+      folder={folder}
+      onFolderChange={onFolderChange}
+      source={source}
+      setSource={setSource}
+      // The tab keeps its tree (and fs-watch) mounted even in the background, but
+      // must not run git/windows probes off-screen.
+      active={visible ?? true}
+      mountTree
+      onOpenFolderTab={canOpenTabs ? (rel) => openProjectFilesTab(projectDir, rel) : undefined}
+      containerClassName="project-files-tab"
+      compact={compact}
+    />
+  );
+}
diff --git a/src/components/files/ProjectFilesView.tsx b/src/components/files/ProjectFilesView.tsx
new file mode 100644
index 0000000..52e9443
--- /dev/null
+++ b/src/components/files/ProjectFilesView.tsx
@@ -0,0 +1,1970 @@
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { GitHistory } from "./GitHistory";
+import { GitChangeTree, type ChangeScope } from "./GitChangeTree";
+import { SearchPanel } from "./SearchPanel";
+import {
+  FileSourceSwitch,
+  ProjectFilesPane,
+  useBoxRoots,
+  useRemoteBlocked,
+} from "./ProjectFilesPane";
+import { RunHostPicker } from "../tabs/TabLocalityBadges";
+import { ProjectFilesSettingsDialog, useProjectFileFilters } from "./ProjectFilesSettings";
+import { useImportDrop } from "./importDrop";
+import { logoutRemote, useProjectsStore } from "../../stores/projects";
+import { useSyncStore, amberPaths } from "../../stores/sync";
+import { openLinkedFile } from "../embed/FileViewerPane";
+import { useWindowsStore } from "../../stores/windows";
+import { useGitDirtyStore, gitDirtyState } from "../../stores/gitDirty";
+import { resolveLocalMirror, type ProjectEntry } from "../../types";
+import { fmtModified, type SortKey } from "../../lib/viewers/fileUtils";
+import { basename, dirname } from "../../lib/paths";
+import { projectTypeTags } from "../projects/projectTypeTags";
+import { ProjectHoverCard, useProjectHoverCard } from "../projects/ProjectHoverCard";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { UntestedTag } from "../common/UntestedTag";
+import { useTabsStore, type TabEntry } from "../../stores/tabs";
+import { persistentSessionOf } from "../../lib/closeRemoteTab";
+import { useRemoteStatusStore, sshOf } from "../../stores/remoteStatus";
+import {
+  slurmAvailable,
+  slurmQueue,
+  slurmCancel,
+  slurmJobOut,
+  openLogTab,
+  type SlurmJob,
+} from "../../lib/slurm";
+import { useHpcJobsStore } from "../../stores/hpcJobs";
+import {
+  wsAvailable,
+  wsList,
+  wsExtend,
+  wsAnchor,
+  wsTargetForProject,
+  setProjectHpc,
+  pullLogs,
+  moveProjectRoot,
+  projectPathIn,
+  findProjectWorkspace,
+  shouldWarnExpiry,
+  remainingLabel,
+  expiryTone,
+  type HpcWorkspace,
+} from "../../lib/hpcWorkspace";
+
+/** How long the pointer must rest on a session row before its stats card opens
+ *  (TODO #85) — same value and rationale as `FileTree`'s `TOOLTIP_DWELL_MS`:
+ *  long enough that a mouse merely passing over the list never triggers it. */
+const TOOLTIP_DWELL_MS = 400;
+
+/** One host tmux session (TODO #85), mirroring the backend `TmuxSession`. */
+interface TmuxSession {
+  name: string;
+  windows: number;
+  /** Creation time, seconds since the Unix epoch (host clock). */
+  created: number;
+  attached: boolean;
+  /** Last activity time, seconds since the Unix epoch (host clock). */
+  activity: number;
+  /** The active pane's current foreground command (e.g. `python`, or a shell
+   *  name when idling at the prompt). */
+  currentCommand: string;
+  /** False when the active pane is sitting at a bare shell prompt. */
+  working: boolean;
+  /** The active pane's working directory on the host (empty when the host's
+   *  `tmux ls` did not report it). What attributes a session whose *name* has no
+   *  project id — every pre-scoping and hand-started one — to a project. */
+  currentPath: string;
+}
+
+/** The row's own name button shows a short, stable label rather than the raw
+ *  `eldrun-<uuid>` — meaningless to read at a glance and mostly there to keep
+ *  the name unique. The full id lives in the session-stats popup instead
+ *  (`SessionStatsMenu` below), alongside the rest of the row's detail. A
+ *  hand-started/foreign session's name is usually short and meaningful
+ *  (`train`), so it's shown as-is. */
+function sessionDisplayName(name: string): string {
+  return name.startsWith("eldrun-") ? "Session" : name;
+}
+
+/** Absolute local-time readout for a host-clock epoch timestamp, for the
+ *  session-stats popup (the row itself only ever shows relative age). */
+function absoluteTime(epochSecs: number): string {
+  return new Date(epochSecs * 1000).toLocaleString();
+}
+
+/** "How long has this session existed" / "how long has it sat idle", as a
+ *  compact duration (not the `relativeAge` "N ago" phrasing, which reads
+ *  wrong as a label next to "Uptime"/"Idle for"). */
+function relativeDuration(epochSecs: number): string {
+  const secs = Math.max(0, Math.floor(Date.now() / 1000) - epochSecs);
+  if (secs < 60) return `${secs}s`;
+  const mins = Math.floor(secs / 60);
+  if (mins < 60) return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ${mins % 60}m`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d ${hrs % 24}h`;
+}
+
+/** A session row in the (multi-host) Sessions view: the session plus which host
+ *  it runs on (the primary or a worker). */
+interface SessionRow {
+  hostId: string;
+  hostLabel: string;
+  session: TmuxSession;
+}
+
+/** Anchor for the per-row session-stats hover card (TODO #85) — the same
+ *  dwell-triggered tooltip pattern `FileTree` uses for a file/folder row
+ *  (`handleEntryMouseEnter`/`.file-tooltip`), applied to a session row. Carries
+ *  only the (host, name) identity, not a snapshot of the session — the card
+ *  looks the live row up from `sessionRows` on every render, so its stats keep
+ *  advancing with the Sessions view's own 7s poll while it's open, rather than
+ *  freezing at whatever "working"/uptime the session had when the dwell fired. */
+interface SessionTooltip {
+  rect: DOMRect;
+  hostId: string;
+  name: string;
+}
+
+interface MtimeCue {
+  text: string;
+  tone: "remote" | "local" | "neutral";
+  title: string;
+}
+
+/** Which copy has the later recorded mtime, as a small badge. Remote (host)
+ *  and local clocks may differ, so this is intentionally a timestamp cue,
+ *  never an automatic resolution — the full "modified when" detail lives in
+ *  the tooltip rather than the badge itself. Tone always names the side the
+ *  text is about: remote = --warning (orange), local = --success (green),
+ *  matching the take-remote/keep-local icon buttons below.
+ *
+ *  A row only reaches this list once the manifest has recorded a synced base
+ *  for it (`amberPaths` reads `state === "amber"`, which `compute_state`
+ *  never sets for an untracked path) — so a null mtime here is never "this
+ *  file was never synced," it's "this file WAS synced and one side's copy
+ *  has since been deleted." The tooltip says so explicitly, since the badge
+ *  text alone ("Remote only") reads ambiguously otherwise. */
+function mtimeDivergenceCue(
+  hostMtime: number | null | undefined,
+  localMtime: number | null | undefined,
+): MtimeCue | null {
+  if (hostMtime == null && localMtime == null) return null;
+  const hostLabel = hostMtime != null ? `Remote modified ${fmtModified(hostMtime)}` : "Remote: deleted since the last sync";
+  const localLabel = localMtime != null ? `Local modified ${fmtModified(localMtime)}` : "Local: deleted since the last sync";
+  const title = `${hostLabel}\n${localLabel}`;
+  if (hostMtime == null) return { text: "Local only", tone: "local", title };
+  if (localMtime == null) return { text: "Remote only", tone: "remote", title };
+  if (hostMtime > localMtime) return { text: "Remote newer", tone: "remote", title };
+  if (localMtime > hostMtime) return { text: "Local newer", tone: "local", title };
+  return { text: "Same time", tone: "neutral", title };
+}
+
+interface GitStatus {
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  has_remote: boolean;
+  is_repo: boolean;
+}
+
+type View = "files" | "windows" | "git" | "search" | "orange" | "sessions" | "jobs";
+
+// A single shared empty array for scopes with no registered tabs. Must be a
+// stable reference — a Zustand selector that returned a fresh `[]` here would
+// make `useSyncExternalStore` see a new snapshot every render and loop forever.
+const EMPTY_SCOPE_TABS: TabEntry[] = [];
+
+/**
+ * The shared file view rendered by BOTH the right panel (`RightPanel`) and the
+ * Files (Project) tab (`ProjectFilesTab`) — the view switcher (Files / Git /
+ * Search / Apps / Orange), the inline git action bar, the git history, search,
+ * the tracked-windows list, the diverged (orange) list, the type tags, hover
+ * card and SSH logout, plus the settings dialog. One component, so the panel and
+ * the tab can never drift into two different file *viewers* of the same project
+ * — exactly as `ProjectFilesPane` already unifies the tree itself.
+ *
+ * What each host still owns is what must differ: identity (the panel keys off the
+ * active project, a tab off its own scope), the browsed folder (the panel's lives
+ * in the projects store, a tab's on its `TabEntry`), where the Remote/Local
+ * switch's `useFileSource` hook lives, and the panel-only window chrome (pin,
+ * resize border, the "Hidden subwindows" list) which comes in through the
+ * `resizeHandle` / `pin` / `hidden` ReactNode slots — meaningless in a tab, so a
+ * tab simply passes none.
+ */
+export interface ProjectFilesViewProps {
+  /** The scope: a project id, a `box:<id>` scope, or "root". */
+  scope: string;
+  /** The project's id (was `activeId` in the panel); null in root scope. */
+  projectId: string | null;
+  /** The project (was `activeProject`); null in root/box scope. */
+  project: ProjectEntry | null;
+  /** The tree root. */
+  projectDir: string;
+
+  /** The browsed folder (host-owned so two views of one project don't yank each
+   *  other around). */
+  folder: string;
+  onFolderChange: (folder: string) => void;
+
+  /** Which side of a remote project the files view shows — the host over SFTP
+   *  ("Remote") or the synced mirror ("Local"). The host owns `useFileSource`. */
+  source: "remote" | "local";
+  setSource: (s: "remote" | "local") => void;
+
+  /** Whether this view is live/visible. Gates git + windows probes and the pill
+   *  dirty-dot write, so a closed panel / background tab never churns them. */
+  active: boolean;
+  /** Whether the tree (and its fs-watch) is mounted. Forwarded to
+   *  `ProjectFilesPane`. */
+  mountTree: boolean;
+
+  /** Compact mode: strip only the project-name/tags/source-switch/git-bar header
+   *  row — the view-switcher toolbar (Files/Git/Search/Apps/±/sessions/jobs/
+   *  import/etc.) and every view it switches to render identically to the full
+   *  chrome. The sync + sort rows (`ProjectFilesPane`) are still stripped, so the
+   *  tree's find-files search stays topmost there. Set only by the docked
+   *  subwindow viewer (`SubwindowFilesSidebar`); the right panel and the Files
+   *  (Project) tab leave it unset and keep the full chrome. */
+  compact?: boolean;
+
+  /** Host callback for the tree's "Open in a new tab"; omitted where a tab can't
+   *  be owned (a box root, a popout on a streamed tab copy). */
+  onOpenFolderTab?: (relPath: string) => void;
+
+  /** The host controls the outer container's own identity (slide-in panel vs.
+   *  flex tab, width, resize transitions, hover-reveal handlers); this component
+   *  appends the drop classes and spreads the import-drop handlers onto it. */
+  containerClassName: string;
+  containerStyle?: React.CSSProperties;
+  containerProps?: React.HTMLAttributes<HTMLDivElement>;
+
+  /** Panel-only fragments interleaved with the shared DOM (undefined in a tab). */
+  resizeHandle?: React.ReactNode;
+  pin?: React.ReactNode;
+  hidden?: React.ReactNode;
+}
+
+export function ProjectFilesView({
+  scope,
+  projectId,
+  project,
+  projectDir,
+  folder,
+  onFolderChange,
+  source,
+  setSource,
+  active,
+  mountTree,
+  onOpenFolderTab,
+  containerClassName,
+  containerStyle,
+  containerProps,
+  resizeHandle,
+  pin,
+  hidden,
+  compact,
+}: ProjectFilesViewProps) {
+  const { windows, refresh, untrack } = useWindowsStore();
+  const [view, setView] = useState<View>("files");
+  const [showSettings, setShowSettings] = useState(false);
+  // Toggles the Downloads section stacked below the file tree (fast-copy of
+  // recent downloads into the project). Toolbar ⬇⬇ button; files view only.
+  const [showDownloads, setShowDownloads] = useState(false);
+  // Kept here (not in the pane): the pane unmounts while the view shows Git or
+  // Search, and the chosen sort must survive the trip back to Files.
+  const [sortKey, setSortKey] = useState<SortKey>("name");
+  const [descending, setDescending] = useState(false);
+
+  const [gitStatus, setGitStatus] = useState<GitStatus | null>(null);
+  const [unpushedCommits, setUnpushedCommits] = useState<string[]>([]);
+  const [openTree, setOpenTree] = useState<"add" | "commit" | "push" | null>(null);
+  const [commitMsg, setCommitMsg] = useState<string | null>(null);
+  const [gitBusy, setGitBusy] = useState(false);
+  const [gitError, setGitError] = useState<string | null>(null);
+  // Whether the project is missing scaffold files — drives the "no scaffold"
+  // type tag shown beside its name, mirroring ProjectPill's hover tags.
+  const [scaffoldMissing, setScaffoldMissing] = useState(false);
+  // Nested-repo detection: when the browsed folder lives in a git repo distinct
+  // from the project's own repo, `nestedRoot` holds that repo's root and the git
+  // section re-roots at it. `preferProjectRepo` is the manual toggle override
+  // back to the project repo.
+  const [nestedRoot, setNestedRoot] = useState<string | null>(null);
+  const [preferProjectRepo, setPreferProjectRepo] = useState(false);
+  const commitRef = useRef<HTMLTextAreaElement>(null);
+  const actionBarRef = useRef<HTMLDivElement>(null);
+  const refreshGitTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const localFile = project?.local_file;
+  // Remote git/endings probes dispatch over SSH/SFTP via SYNCHRONOUS Tauri
+  // commands (run on the main thread). Calling them while the pool is down blocks
+  // on the dead session and freezes the window, so suppress them until the remote
+  // project is connected. Local projects are never blocked.
+  const { remoteSshState, remoteBlocked } = useRemoteBlocked(projectId, !!project?.remote);
+  // Which endings/paths the tree hides, from the project's own project.json —
+  // shared with the right panel, so both views hide the same files.
+  const filters = useProjectFileFilters({ localFile, projectDir, remoteBlocked });
+
+  // Run both git probes concurrently (Eff #9): they hit independent
+  // subprocesses, so `Promise.all` collapses two serially-awaited chains into
+  // one round of parallel work. Each result still applies independently.
+  const runRefreshGit = (dir: string) => {
+    void Promise.all([
+      invoke<GitStatus>("git_status", { projectDir: dir }).catch(() => null),
+      invoke<string[]>("git_unpushed_commits", { projectDir: dir }).catch(() => [] as string[]),
+    ]).then(([status, unpushed]) => {
+      setGitStatus(status);
+      setUnpushedCommits(unpushed);
+      // Keep the project's pill dot in sync from the data we just fetched (no
+      // extra git subprocesses), so edits/commits/pushes reflect immediately
+      // instead of waiting for the switcher's periodic poll.
+      // Don't let a nested repo's status pollute the project pill's dirty dot —
+      // that dot tracks the project repo (the switcher's poll recomputes it).
+      // Gate on `active` so a background tab never churns the shared store.
+      if (active && projectId && status && !onNestedRepo) {
+        useGitDirtyStore.getState().set(projectId, gitDirtyState(status, unpushed.length));
+      }
+    });
+  };
+
+  // Debounced entry point (Eff #9): bursts of git-affecting actions (add →
+  // commit → push, or rapid fs changes) coalesce into a single refresh instead
+  // of spawning a fresh trio of subprocesses per call.
+  const refreshGit = (dir: string) => {
+    if (refreshGitTimer.current) clearTimeout(refreshGitTimer.current);
+    refreshGitTimer.current = setTimeout(() => {
+      refreshGitTimer.current = null;
+      runRefreshGit(dir);
+    }, 120);
+  };
+
+  useEffect(() => {
+    return () => {
+      if (refreshGitTimer.current) clearTimeout(refreshGitTimer.current);
+    };
+  }, []);
+
+  // The change tree is click-opened and persistent; close it on Escape or a
+  // click anywhere outside the action bar (which contains both the toggles and
+  // the tree itself).
+  useEffect(() => {
+    if (!openTree) return;
+    const onDown = (e: MouseEvent) => {
+      if (!actionBarRef.current?.contains(e.target as Node)) setOpenTree(null);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setOpenTree(null);
+    };
+    document.addEventListener("mousedown", onDown);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onDown);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [openTree]);
+
+  const treeScope: ChangeScope | null =
+    openTree === "add" ? "unstaged" : openTree === "commit" ? "staged" : openTree === "push" ? "unpushed" : null;
+
+  // Detect a nested git repo: if the folder currently browsed in the file tree
+  // lives inside a git repo distinct from the project's own repo, re-root the
+  // git section at it (auto-switch). Local projects only — the backend returns
+  // null for remote ones, so `nestedRoot` stays null and behavior is unchanged.
+  useEffect(() => {
+    if (!projectDir || project?.remote) {
+      setNestedRoot(null);
+      return;
+    }
+    let cancelled = false;
+    void Promise.all([
+      invoke<string | null>("git_repo_root", { projectDir, relPath: "" }).catch(() => null),
+      invoke<string | null>("git_repo_root", { projectDir, relPath: folder }).catch(() => null),
+    ]).then(([projRoot, folderRoot]) => {
+      if (cancelled) return;
+      const norm = (p: string | null) => (p ? p.replace(/[/\\]+$/, "") : null);
+      const pr = norm(projRoot);
+      const fr = norm(folderRoot);
+      setNestedRoot(fr && fr !== pr ? fr : null);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [projectDir, folder, project?.remote]);
+
+  // Default to auto-switch: reset the manual override on a project switch or
+  // whenever we leave the nested repo, so entering one always shows it first.
+  useEffect(() => {
+    setPreferProjectRepo(false);
+  }, [projectId]);
+  useEffect(() => {
+    if (!nestedRoot) setPreferProjectRepo(false);
+  }, [nestedRoot]);
+
+  // The repo root the whole git section (status, commit, push, history) operates
+  // on: the nested repo when detected and not overridden, else the project repo.
+  const effectiveGitRoot = nestedRoot && !preferProjectRepo ? nestedRoot : projectDir;
+  const onNestedRepo = !!nestedRoot && effectiveGitRoot !== projectDir;
+
+  // Diverged (amber/orange) files for a remote project, from the cached sync
+  // status — backs the toolbar count badge and the "Orange" list view. These are
+  // exactly the files auto-sync refuses to touch (both sides changed), so they
+  // need a human to pick a side.
+  const syncMap = useSyncStore((s) => (projectId ? s.byProject[projectId] : undefined));
+  const orangeFiles = useMemo(() => amberPaths(syncMap), [syncMap]);
+  // The local mirror root, to open an amber file's mirror copy for inspection.
+  const mirrorRoot = resolveLocalMirror(project) ?? (projectDir ? `${projectDir}/mirror` : null);
+
+  // Persistent (tmux) sessions on the project's hosts (TODO #85): a session
+  // outlives the tab that started it, so a host can hold runs no open tab points at
+  // (a crashed/relaunched Eldrun, another machine, a hand-started `tmux`). This list
+  // makes them discoverable and reattachable — the primary UI surface for the
+  // feature. **Multi-host**: aggregated across the primary AND every connected
+  // worker, each row tagged with its host; polled while this view is active (rides
+  // each host's pooled ControlMaster). An absent tmux / no server yields nothing.
+  const sessionHosts = useMemo(() => {
+    if (!project?.remote) return [] as { id: string; label: string }[];
+    const list = [{ id: "primary", label: project.remote.host }];
+    for (const w of project.compute_hosts ?? [])
+      list.push({ id: w.id, label: w.label || w.host || w.id });
+    return list;
+  }, [project?.remote, project?.compute_hosts]);
+  // A connectivity signature so the poll re-runs the moment a host connects.
+  const connSig = useRemoteStatusStore((s) =>
+    sessionHosts.map((h) => `${h.id}:${sshOf(s, projectId ?? "", h.id)}`).join("|"),
+  );
+  const [sessionRows, setSessionRows] = useState<SessionRow[]>([]);
+  // The Sessions list is scoped to THIS project by default (the backend filters
+  // by session name, falling back to the session's working directory for the
+  // pre-scoping and hand-started ones a name cannot attribute). This is the
+  // escape hatch: a host's full listing, so a session running outside any
+  // project tree — an orphaned run whose tab is long gone — is still reachable
+  // to attach to or kill.
+  const [showAllSessions, setShowAllSessions] = useState(false);
+  useEffect(() => {
+    if (!active || !projectId || !project?.remote) {
+      setSessionRows([]);
+      return;
+    }
+    let cancelled = false;
+    const poll = async () => {
+      const st = useRemoteStatusStore.getState();
+      const connected = sessionHosts.filter((h) => sshOf(st, projectId, h.id) === "connected");
+      if (connected.length === 0) {
+        if (!cancelled) setSessionRows([]);
+        return;
+      }
+      const lists = await Promise.all(
+        connected.map((h) =>
+          invoke<TmuxSession[]>("remote_tmux_list", {
+            projectId,
+            hostId: h.id,
+            includeAll: showAllSessions,
+          })
+            .then((ss) => ss.map((session) => ({ hostId: h.id, hostLabel: h.label, session })))
+            .catch(() => [] as SessionRow[]),
+        ),
+      );
+      if (!cancelled) setSessionRows(lists.flat());
+    };
+    void poll();
+    const iv = setInterval(() => void poll(), 7000);
+    return () => {
+      cancelled = true;
+      clearInterval(iv);
+    };
+  }, [active, projectId, project?.remote, connSig, sessionHosts, showAllSessions]);
+
+  // Per-row session-stats hover card (TODO #85): the exact dwell-tooltip
+  // mechanism `FileTree` uses for a file/folder row — open on a genuine pause,
+  // not mere mouse-in (a bare `onMouseEnter` measurement would reflow on every
+  // pass over the list), close immediately on leave.
+  const [sessionTooltip, setSessionTooltip] = useState<SessionTooltip | null>(null);
+  const sessionTooltipRef = useRef<HTMLDivElement | null>(null);
+  const sessionTooltipTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  function cancelSessionTooltipTimer() {
+    if (sessionTooltipTimer.current !== null) {
+      clearTimeout(sessionTooltipTimer.current);
+      sessionTooltipTimer.current = null;
+    }
+  }
+  useEffect(() => () => cancelSessionTooltipTimer(), []);
+  function handleSessionRowMouseEnter(e: React.MouseEvent<HTMLDivElement>, hostId: string, name: string) {
+    const row = e.currentTarget;
+    cancelSessionTooltipTimer();
+    sessionTooltipTimer.current = setTimeout(() => {
+      sessionTooltipTimer.current = null;
+      setSessionTooltip({ rect: row.getBoundingClientRect(), hostId, name });
+    }, TOOLTIP_DWELL_MS);
+  }
+  function handleSessionRowMouseLeave() {
+    cancelSessionTooltipTimer();
+    setSessionTooltip(null);
+  }
+  // Vertical-only overflow correction, same as `FileTree`'s `tooltipShift`: a
+  // row near the bottom of a short docked viewer still measures its anchor
+  // against the whole app window, so an unclamped `top` could push the card
+  // past the window's bottom edge. Horizontal side is picked in the render
+  // below (whichever side of the row has more room).
+  const [sessionTooltipShift, setSessionTooltipShift] = useState(0);
+  useLayoutEffect(() => {
+    if (!sessionTooltip) {
+      setSessionTooltipShift(0);
+      return;
+    }
+    const el = sessionTooltipRef.current;
+    if (!el) {
+      setSessionTooltipShift(0);
+      return;
+    }
+    const overflow = sessionTooltip.rect.top + el.offsetHeight - (window.innerHeight - 8);
+    setSessionTooltipShift(overflow > 0 ? overflow : 0);
+  }, [sessionTooltip]);
+  // Closing a session (kill/rename) drops it from `sessionRows`; the card has
+  // no session left to look up, so it self-closes rather than showing
+  // stale/blank stats.
+  useEffect(() => {
+    if (!sessionTooltip) return;
+    const stillThere = sessionRows.some(
+      (r) => r.hostId === sessionTooltip.hostId && r.session.name === sessionTooltip.name,
+    );
+    if (!stillThere) setSessionTooltip(null);
+  }, [sessionRows, sessionTooltip]);
+
+  // Keep the Sessions view grouped in the configured machine order. A fallback
+  // group preserves a row if a machine was renamed or removed while its list
+  // request was still in flight.
+  const sessionGroups = useMemo(() => {
+    const groups = new Map<string, { hostId: string; hostLabel: string; rows: SessionRow[] }>();
+    for (const host of sessionHosts)
+      groups.set(host.id, { hostId: host.id, hostLabel: host.label, rows: [] });
+    for (const row of sessionRows) {
+      const group = groups.get(row.hostId);
+      if (group) group.rows.push(row);
+      else groups.set(row.hostId, { hostId: row.hostId, hostLabel: row.hostLabel, rows: [row] });
+    }
+    return [...groups.values()].filter((group) => group.rows.length > 0);
+  }, [sessionHosts, sessionRows]);
+
+  // The (host, session) each open shell tab of this scope owns, so a Sessions row
+  // can reveal the tab that runs it instead of opening a second attach.
+  // Coalesce to the shared empty array OUTSIDE the selector: a selector that
+  // returns a fresh `[]` when this scope has no tabs yields a new snapshot on
+  // every render, which makes `useSyncExternalStore` loop forever ("getSnapshot
+  // should be cached" → Maximum update depth). Returning the stored array (stable)
+  // or `undefined` (stable) from the selector, then defaulting here, is loop-safe.
+  const scopeTabs = useTabsStore((s) => s.tabsByScope[scope]) ?? EMPTY_SCOPE_TABS;
+  const sessionOwners = useMemo(() => {
+    const m = new Map<string, string>(); // `${hostId}\0${name}` → owning tab key
+    for (const t of scopeTabs) {
+      const info = persistentSessionOf(scope, t);
+      if (info) m.set(`${info.hostId} ${info.session}`, t.key);
+    }
+    return m;
+  }, [scopeTabs, scope]);
+
+  // Open a host session in a tab: reveal the owning tab if one exists, else add a
+  // shell tab on THAT host that ATTACHES to the named session (idempotent; `-D`
+  // detaches any other client). The tab carries the name so it reattaches across a
+  // restart, and its locality is the row's host.
+  const openSession = (hostId: string, name: string) => {
+    if (!projectId) return;
+    const ownerKey = sessionOwners.get(`${hostId} ${name}`);
+    if (ownerKey) {
+      useTabsStore.getState().setActive(ownerKey);
+      return;
+    }
+    useTabsStore.getState().addTabToScope(projectId, {
+      label: name.startsWith("eldrun-") ? "session" : name,
+      cmd: "",
+      args: [],
+      cwd: projectDir,
+      kind: "shell",
+      location: hostId === "primary" ? "remote" : `host:${hostId}`,
+      tmuxAttach: name,
+    });
+  };
+
+  // Kill a host session (per-row, confirmed). Drops the row optimistically; the
+  // poll reconciles. Unlike a tab close (which merely detaches), a kill terminates
+  // the session, so the tab that owns it — now attached to a dead session — is
+  // closed too rather than left showing a defunct terminal.
+  const killSession = (hostId: string, name: string) => {
+    if (!projectId) return;
+    if (
+      !window.confirm(
+        `Kill the session “${name}” and any process running in it (e.g. a training run)?`,
+      )
+    )
+      return;
+    const ownerKey = sessionOwners.get(`${hostId} ${name}`);
+    invoke("remote_tmux_kill", { projectId, hostId, session: name })
+      .then(() => {
+        setSessionRows((rs) => rs.filter((r) => !(r.hostId === hostId && r.session.name === name)));
+        if (ownerKey) useTabsStore.getState().removeTab(ownerKey);
+      })
+      .catch(() => {});
+  };
+
+  // Rename a host session (per-row). The name must be tmux-safe; on success the
+  // owning tab's persisted name is updated too, so it reattaches to the renamed
+  // session after a restart (the live client stays attached — rename never drops it).
+  const renameSession = (hostId: string, oldName: string) => {
+    if (!projectId) return;
+    const proposed = window.prompt("Rename session to:", oldName);
+    if (proposed === null) return;
+    const next = proposed.trim();
+    if (!next || next === oldName) return;
+    if (!/^[A-Za-z0-9_-]+$/.test(next)) {
+      window.alert("A session name may only contain letters, digits, '-' and '_'.");
+      return;
+    }
+    invoke("remote_tmux_rename", { projectId, hostId, session: oldName, newName: next })
+      .then(() => {
+        const ownerKey = sessionOwners.get(`${hostId} ${oldName}`);
+        if (ownerKey) useTabsStore.getState().setTabTmuxName(scope, ownerKey, next);
+        setSessionRows((rs) =>
+          rs.map((r) =>
+            r.hostId === hostId && r.session.name === oldName
+              ? { ...r, session: { ...r.session, name: next } }
+              : r,
+          ),
+        );
+      })
+      .catch((e) => window.alert(`Rename failed: ${e}`));
+  };
+
+  // ── SLURM jobs (HPC) ──────────────────────────────────────────────────────
+  // A Jobs view, primary-only to start: whether the primary host has SLURM, and
+  // this user's live queue on it. Rides the primary's pooled ControlMaster; polled
+  // only while the view is active (like Sessions). A local project with SLURM (a
+  // login node) also gets it. The session store carries just-submitted jobs so a
+  // Watch can resolve their log path without a fresh scontrol.
+  const [slurmSupported, setSlurmSupported] = useState(false);
+  const [jobRows, setJobRows] = useState<SlurmJob[]>([]);
+  const sessionJobs = useHpcJobsStore((s) =>
+    projectId ? s.byProject[projectId] : undefined,
+  );
+  // Primary connectivity, so probes/polls re-run the moment it connects.
+  const primaryConn = useRemoteStatusStore((s) => sshOf(s, projectId ?? "", "primary"));
+  const primaryReady = !project?.remote || primaryConn === "connected";
+  useEffect(() => {
+    if (!active || !projectDir || !primaryReady) {
+      setSlurmSupported(false);
+      return;
+    }
+    let cancelled = false;
+    slurmAvailable(projectDir)
+      .then((info) => { if (!cancelled) setSlurmSupported(info.available); })
+      .catch(() => { if (!cancelled) setSlurmSupported(false); });
+    return () => { cancelled = true; };
+  }, [active, projectDir, primaryReady]);
+  useEffect(() => {
+    if (!active || view !== "jobs" || !slurmSupported || !projectDir) return;
+    let cancelled = false;
+    const poll = async () => {
+      try {
+        const jobs = await slurmQueue(projectDir);
+        if (!cancelled) setJobRows(jobs);
+      } catch {
+        if (!cancelled) setJobRows([]);
+      }
+    };
+    void poll();
+    const iv = setInterval(() => void poll(), 7000);
+    return () => { cancelled = true; clearInterval(iv); };
+  }, [active, view, slurmSupported, projectDir]);
+
+  // Watch a job: open a log tab tailing its stdout. Use the session store's path
+  // if we submitted it this session, else resolve via scontrol.
+  const watchJob = async (jobId: string, name: string) => {
+    if (!projectDir) return;
+    try {
+      const known = sessionJobs?.find((j) => j.jobId === jobId);
+      const outFile =
+        known?.outFile ??
+        (await slurmJobOut(projectDir, jobId, undefined, project?.hpc?.logs_dir));
+      openLogTab({
+        scope,
+        projectDir,
+        outFile,
+        jobLabel: `${jobId} ${name}`,
+        hostId: "primary",
+        isRemote: !!project?.remote,
+      });
+    } catch (e) {
+      window.alert(`Could not resolve the log file for job ${jobId}: ${e}`);
+    }
+  };
+
+  // ── HPC workspaces (Phase C) ──────────────────────────────────────────────
+  // A workspace is the piece of the cluster's parallel filesystem this project's
+  // data lives on — and it is DELETED when it expires. The wizard is where one is
+  // allocated; this is where an already-running project *sees the clock* and
+  // spends an extension before the deadline. Read once when the Jobs view opens
+  // (never polled: `ws_list` is a full SSH round trip and the number moves in
+  // days, not seconds).
+  const [wsRows, setWsRows] = useState<HpcWorkspace[]>([]);
+  const [wsBusy, setWsBusy] = useState(false);
+  // The read runs for the Jobs view AND — when the project records a workspace —
+  // as soon as its host is reachable, because the expiry banner has to appear
+  // without the user first opening a view they have no reason to visit.
+  const wantWorkspaces = view === "jobs" || Boolean(project?.hpc?.workspace_id);
+  useEffect(() => {
+    if (!active || !wantWorkspaces || !projectDir || !primaryReady) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const info = await wsAvailable(wsTargetForProject(projectDir));
+        if (cancelled || !info.available) {
+          if (!cancelled) setWsRows([]);
+          return;
+        }
+        const list = await wsList(wsTargetForProject(projectDir));
+        if (!cancelled) setWsRows(list);
+      } catch {
+        if (!cancelled) setWsRows([]);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [active, wantWorkspaces, projectDir, primaryReady]);
+
+  // The workspace this project's tree actually lives in — the one whose expiry
+  // deletes the host copy of the project, not merely "some data".
+  const projectWs = useMemo(
+    () => findProjectWorkspace(wsRows, project?.hpc, project?.remote?.remote_path),
+    [wsRows, project?.hpc, project?.remote?.remote_path],
+  );
+  const [expiryDismissed, setExpiryDismissed] = useState("");
+  const warnExpiry =
+    shouldWarnExpiry(projectWs) && expiryDismissed !== `${projectWs?.id}:${projectWs?.remaining_days}`;
+
+  // Spend one of a workspace's extensions. The filesystem it was allocated on has
+  // to be repeated, so the row's own value is passed straight back.
+  const extendWs = async (ws: HpcWorkspace) => {
+    if (!projectDir) return;
+    const answer = window.prompt(`Extend workspace '${ws.id}' by how many days?`, "30");
+    if (!answer) return;
+    const days = Number(answer.trim());
+    if (!Number.isFinite(days) || days < 1) return;
+    try {
+      const next = await wsExtend(wsTargetForProject(projectDir), ws.id, days, ws.filesystem);
+      setWsRows((rs) => rs.map((r) => (r.id === ws.id ? { ...r, ...next } : r)));
+    } catch (e) {
+      window.alert(`Extending '${ws.id}' failed: ${e}`);
+    }
+  };
+
+  // Move the project's host tree into another workspace — the escape hatch an
+  // expiry makes inevitable (a primary's remote_path is otherwise fixed at
+  // creation). Nothing is copied host-side: the new root starts empty and is
+  // re-seeded from the LOCAL MIRROR, which is the durable copy. Whatever the old
+  // workspace still holds stays there until it expires, so this must be said
+  // before it happens, not after.
+  const moveProjectTo = async (ws: HpcWorkspace) => {
+    if (!projectId || !project?.remote) return;
+    const folder = basename(project.remote.remote_path.replace(/\/+$/, "")) || projectId;
+    const dest = projectPathIn(ws, folder);
+    const ok = window.confirm(
+      `Move this project's host tree to:\n${dest}\n\n` +
+        `The new folder starts EMPTY and is re-seeded from your local mirror ` +
+        `(git lockstep). Files that only exist in the old workspace — job outputs, ` +
+        `anything never synced — are NOT moved and stay there until it expires.\n\n` +
+        `Continue?`,
+    );
+    if (!ok) return;
+    setWsBusy(true);
+    try {
+      // The pool caches the spec, so the connection has to be dropped around the
+      // rewrite and re-opened against the new root.
+      await invoke("remote_disconnect", { projectId }).catch(() => {});
+      const updated = await moveProjectRoot(projectId, dest);
+      useProjectsStore.setState((s) => ({
+        projects: s.projects.map((p) => (p.id === projectId ? { ...p, ...updated } : p)),
+      }));
+      // Reconnect BEFORE re-anchoring: the anchor script rides the project's SSH
+      // path, and between the disconnect above and this there is no session for
+      // it to ride (on a password host it would have nothing to authenticate
+      // with, and no prompt could be answered from here).
+      // `viaLogin`: credential-less by necessity (there is no prompt to answer from
+      // here), so it can only ride an existing master — never evidence of key auth.
+      // `background: false`: this is the middle of a move the user clicked, and the
+      // host it runs against is a cluster by construction — the dial policy's default
+      // would refuse it on exactly the machines this flow exists for.
+      await invoke("remote_connect", { projectId, viaLogin: true, background: false }).catch(
+        () => {},
+      );
+
+      // Re-anchor: the record file gains a line naming the new workspace, and the
+      // `workspace` symlink re-points. This is exactly the history the record
+      // exists for — a project passes through several workspaces in a year.
+      let logsDir = project.hpc?.logs_dir;
+      const anchorRel = project.hpc?.anchor_rel;
+      if (anchorRel) {
+        try {
+          const made = await wsAnchor(wsTargetForProject(projectDir), {
+            anchorRel,
+            workspacePath: ws.path,
+            workspaceId: ws.id,
+            projectName: project.name,
+            makeLogs: true,
+          });
+          logsDir = made.logs_dir ?? logsDir;
+        } catch {
+          /* the move already succeeded; the anchor is a convenience */
+        }
+      }
+      await setProjectHpc(projectId, {
+        workspace_id: ws.id,
+        workspace_path: ws.path,
+        filesystem: ws.filesystem,
+        anchor_dir: project.hpc?.anchor_dir,
+        anchor_rel: anchorRel,
+        logs_dir: logsDir,
+      }).catch(() => {});
+    } catch (e) {
+      window.alert(`Moving the project failed: ${e}`);
+    } finally {
+      setWsBusy(false);
+    }
+  };
+
+  // Copy the home anchor's logs into the local mirror — the provenance record on
+  // the machine the user actually reads logs on.
+  const pullProjectLogs = async () => {
+    const dir = project?.hpc?.logs_dir;
+    if (!projectId || !dir) return;
+    try {
+      const n = await pullLogs(projectId, dir);
+      window.alert(n > 0 ? `Copied ${n} log file${n === 1 ? "" : "s"} into logs/.` : "No logs yet.");
+    } catch (e) {
+      window.alert(`Could not copy the logs: ${e}`);
+    }
+  };
+
+  // Cancel a job (confirmed). Drops the row optimistically; the poll reconciles.
+  const cancelJob = (jobId: string, name: string) => {
+    if (!projectDir) return;
+    if (!window.confirm(`Cancel job ${jobId}${name ? ` (${name})` : ""}?`)) return;
+    slurmCancel(projectDir, jobId)
+      .then(() => {
+        setJobRows((rs) => rs.filter((r) => r.id !== jobId));
+        if (projectId) useHpcJobsStore.getState().remove(projectId, jobId, "primary");
+      })
+      .catch((e) => window.alert(`Cancel failed: ${e}`));
+  };
+
+  // Resolve the scaffold-missing flag whenever the project changes. Failures
+  // fall back to "present" so a probe error doesn't flash the tag.
+  useEffect(() => {
+    if (!projectId) {
+      setScaffoldMissing(false);
+      return;
+    }
+    let cancelled = false;
+    invoke<boolean>("project_scaffold_missing", { projectId })
+      .then((v) => { if (!cancelled) setScaffoldMissing(v); })
+      .catch(() => { if (!cancelled) setScaffoldMissing(false); });
+    return () => { cancelled = true; };
+  }, [projectId]);
+
+  const typeTags = project ? projectTypeTags(project, scaffoldMissing) : [];
+
+  // Right-click menu on the SSH (remote) tag: open the one unified "Remote machines"
+  // hub, which connects/manages every host and adds workers
+  // (docs/multi_host_remote_plan.md).
+  const openRemoteMachines = useRemoteMachinesStore((s) => s.open);
+  const [sshTagMenu, setSshTagMenu] = useState<{ x: number; y: number } | null>(null);
+
+  // Import button's Files.../Folder... menu — same portal+backdrop pattern as
+  // the SSH tag's context menu above.
+  const [importMenu, setImportMenu] = useState<{ x: number; y: number } | null>(null);
+
+  // Same hover card as the project pill, shown when hovering the project name
+  // here — minus the type tags, which already sit beside the name below.
+  const nameHover = useProjectHoverCard(project ?? undefined);
+
+  // A box scope shows a multi-root file view (the box folder + every member
+  // project's root) instead of one project tree; the pane renders it.
+  const { activeBox } = useBoxRoots(scope);
+
+  const openInOsBrowser = () => {
+    if (!projectDir) return;
+    const sub = folder.replace(/^\/+|\/+$/g, "");
+    const path = sub ? `${projectDir.replace(/\/+$/, "")}/${sub}` : projectDir;
+    invoke("open_in_file_manager", { path }).catch((e) => console.error("open_in_file_manager", e));
+  };
+
+  // OS file drop → copy into the project, prompting on collisions. Confined to a
+  // single project (a box scope has no single destination root). The whole
+  // container is the drop zone, so a drop outside the files view lands at the
+  // project root; inside it, on the browsed folder.
+  const importDrop = useImportDrop({
+    projectDir,
+    enabled: !activeBox,
+    destRel: view === "files" ? folder : "",
+    // The tree auto-reloads via its fs-watch; refresh git so new untracked files
+    // show in the status counts immediately.
+    onImported: () => refreshGit(effectiveGitRoot),
+  });
+
+  useEffect(() => {
+    if (active && projectId) {
+      refresh(projectId);
+    }
+  }, [active, projectId]);
+
+  useEffect(() => {
+    if (active && effectiveGitRoot && !remoteBlocked) {
+      refreshGit(effectiveGitRoot);
+    } else {
+      setGitStatus(null);
+    }
+  }, [active, effectiveGitRoot, remoteBlocked]);
+
+  // The gear dialog belongs to the project it was opened on; a project switch
+  // reloads the filters under it, so close it rather than let it re-target.
+  useEffect(() => {
+    setShowSettings(false);
+  }, [localFile, projectDir]);
+
+  const handleAdd = async () => {
+    if (!effectiveGitRoot) return;
+    setGitBusy(true);
+    setGitError(null);
+    try {
+      await invoke("git_add_all", { projectDir: effectiveGitRoot });
+      refreshGit(effectiveGitRoot);
+    } catch (e) {
+      setGitError(String(e));
+    } finally {
+      setGitBusy(false);
+    }
+  };
+
+  const handleCommitOpen = async () => {
+    if (!effectiveGitRoot) return;
+    setGitBusy(true);
+    setGitError(null);
+    try {
+      const msg = await invoke<string>("git_generate_commit_message", { projectDir: effectiveGitRoot });
+      setCommitMsg(msg);
+      setTimeout(() => commitRef.current?.focus(), 50);
+    } catch (e) {
+      setGitError(String(e));
+    } finally {
+      setGitBusy(false);
+    }
+  };
+
+  const handleCommitConfirm = async () => {
+    if (!effectiveGitRoot || commitMsg === null) return;
+    setGitBusy(true);
+    setGitError(null);
+    try {
+      await invoke("git_commit", { projectDir: effectiveGitRoot, message: commitMsg });
+      setCommitMsg(null);
+      refreshGit(effectiveGitRoot);
+    } catch (e) {
+      setGitError(String(e));
+    } finally {
+      setGitBusy(false);
+    }
+  };
+
+  const handlePush = async () => {
+    if (!effectiveGitRoot) return;
+    setGitBusy(true);
+    setGitError(null);
+    try {
+      // On a nested repo, push to its own configured remote (no project id →
+      // plain `git push`), not the project's GitHub/GitLab provider flow.
+      await invoke("git_push", {
+        projectDir: effectiveGitRoot,
+        projectId: onNestedRepo ? null : projectId ?? null,
+      });
+      refreshGit(effectiveGitRoot);
+    } catch (e) {
+      setGitError(String(e));
+    } finally {
+      setGitBusy(false);
+    }
+  };
+
+  return (
+    <div
+      className={`${containerClassName}${importDrop.dropActive ? " drop-active" : ""}${importDrop.dropFlash ? " drop-flash" : ""}`}
+      style={containerStyle}
+      {...containerProps}
+      {...importDrop.handlers}
+    >
+      {resizeHandle}
+      {importDrop.conflictModal}
+      {/* Compact (docked subwindow) viewer: only the project-name/tags/source-
+          switch/git-bar header is stripped — the tree's find-files search stays
+          topmost. The Files/Git/Search/Apps toolbar (± diverged, sessions, jobs,
+          import, open-in-OS, downloads, settings) renders in both modes, so a
+          subwindow file viewer behaves identically to the right panel / Files
+          (Project) tab except for that header row. */}
+      {!compact && (
+      <div className="right-panel-header">
+        {pin}
+        <span
+          style={{
+            flexShrink: 1,
+            minWidth: 0,
+            overflow: "hidden",
+            textOverflow: "ellipsis",
+            whiteSpace: "nowrap",
+            cursor: !activeBox && project ? "default" : undefined,
+          }}
+          onMouseEnter={
+            !activeBox && project
+              ? (e) => void nameHover.open(e.currentTarget.getBoundingClientRect())
+              : undefined
+          }
+          onMouseLeave={!activeBox && project ? () => nameHover.close() : undefined}
+        >
+          {activeBox ? `▣ ${activeBox.name}` : project ? project.name : "Files"}
+        </span>
+        {!activeBox && project && (
+          <ProjectHoverCard project={project} state={nameHover} showTags={false} />
+        )}
+        {/* Static project type tags (git / provider / SSH / scaffold). These are
+            labels only — no interactivity — so they deliberately look nothing
+            like the source switch below. */}
+        {!activeBox && typeTags.length > 0 && (
+          <span className="right-panel-type-tags">
+            {typeTags.map((t) => {
+              // The SSH tag carries a right-click menu (connect / manage · remote
+              // machines); the rest stay pure labels.
+              const isSsh = t.key === "ssh" && !!project?.remote && !!projectId;
+              return (
+                <span
+                  key={t.key}
+                  className="pill-popup-tag"
+                  title={isSsh ? `${t.title}\nRight-click for connection / machines` : t.title}
+                  style={{
+                    color: t.color,
+                    borderColor: t.color,
+                    background: `${t.color}22`,
+                    cursor: isSsh ? "context-menu" : undefined,
+                  }}
+                  onContextMenu={
+                    isSsh
+                      ? (e) => {
+                          e.preventDefault();
+                          e.stopPropagation();
+                          setSshTagMenu({ x: e.clientX, y: e.clientY });
+                        }
+                      : undefined
+                  }
+                >
+                  {t.label}
+                </span>
+              );
+            })}
+          </span>
+        )}
+        {sshTagMenu && projectId && createPortal(
+          <>
+            <div
+              style={{ position: "fixed", inset: 0, zIndex: 200 }}
+              onPointerDown={() => setSshTagMenu(null)}
+              onContextMenu={(e) => {
+                e.preventDefault();
+                setSshTagMenu(null);
+              }}
+            />
+            <div
+              className="context-menu"
+              style={{ left: sshTagMenu.x, top: sshTagMenu.y, zIndex: 201 }}
+              onPointerDown={(e) => e.stopPropagation()}
+            >
+              <div className="context-menu-group">
+                <div className="context-menu-group-label">{project?.remote?.host ?? "Remote"}</div>
+                {/* One unified hub: connect/manage every host (primary + workers)
+                    and add a machine, all from "Remote machines…". */}
+                <button
+                  className="untested"
+                  onClick={() => {
+                    openRemoteMachines(projectId);
+                    setSshTagMenu(null);
+                  }}
+                >
+                  Remote machines…
+                  <UntestedTag />
+                </button>
+              </div>
+            </div>
+          </>,
+          document.body,
+        )}
+        {/* Remote/Local file-source switch (remote SSH projects only). A live
+            segmented control — NOT a tag — that flips the files view between the
+            host tree over SFTP ("Remote") and the synced mirror ("Local"). It's
+            right-aligned and styled as a switch so it never reads as one of the
+            static tags above. */}
+        {!activeBox && project?.remote && projectId && (
+          <>
+          {/* Breaker: drop the switch onto its own row so it left-aligns with the
+              pin/name (header padding edge) instead of trailing the tags. */}
+          <span style={{ flexBasis: "100%", width: 0, height: 0 }} />
+          <FileSourceSwitch source={source} onChange={setSource} />
+          {/* Run-host picker — which machine scripts/shells launched from this
+              project run on (primary or a worker), distinct from the source
+              switch's read side. Shown whenever the switch is on Remote (no machine
+              axis on Local), including a multi-machine project with a synced-code
+              worker: a Python Run opens a fresh tab, so this project-wide picker is
+              the only control that can send that run to a worker. */}
+          {source === "remote" && (
+            <RunHostPicker
+              projectId={projectId}
+              primaryHost={project.remote.label || project.remote.host}
+              computeHosts={project.compute_hosts}
+            />
+          )}
+          {/* One-click SSH logout, shown while connected. Lives here (not on the
+              project pill) so the pill stays status-only; the danger tint only
+              appears on hover. */}
+          {remoteSshState === "connected" && (
+            <button
+              type="button"
+              className="right-panel-conn-logout"
+              aria-label={`Log out of ${project.remote.host} — disconnect this remote project`}
+              title={`Log out of ${project.remote.host}\nDrops the SSH connection${project.remote.openvpn ? " and the VPN tunnel" : ""}. Open tabs stay, their sessions go dead until you reconnect.`}
+              onClick={() => logoutRemote(project)}
+            >
+              <span aria-hidden="true">⏻</span> Logout
+            </button>
+          )}
+          </>
+        )}
+        {/* Git status/action buttons drop to their own row below the project name
+            (forced by the flex-basis breaker) instead of crowding it. Only
+            rendered when there's something to do (or we're mid-commit) — an
+            empty strip with no actions just wastes space. */}
+        {!activeBox && gitStatus?.is_repo &&
+          (commitMsg !== null ||
+            gitStatus.unstaged + gitStatus.untracked > 0 ||
+            gitStatus.staged > 0 ||
+            unpushedCommits.length > 0) && (
+          <>
+            <span style={{ flexBasis: "100%", width: 0, height: 0 }} />
+            <div ref={actionBarRef} className="git-action-bar git-action-bar--inline" style={{ position: "relative" }}>
+            {commitMsg !== null ? (
+              <>
+                <button
+                  className="git-action-btn git-action-btn--commit"
+                  disabled={gitBusy}
+                  onClick={handleCommitConfirm}
+                  title="Confirm commit"
+                >
+                  <span data-testid="commit-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#e3b341" }} />
+                  <span>↵</span>
+                  <span className="git-btn-label">Confirm</span>
+                </button>
+                <button
+                  className="git-action-btn git-action-btn--back"
+                  disabled={gitBusy}
+                  onClick={() => setCommitMsg(null)}
+                  title="Go back"
+                >
+                  <span>←</span>
+                  <span className="git-btn-label">Back</span>
+                </button>
+              </>
+            ) : (
+              <>
+                {/* Each action only appears when it has work to do: Add when there
+                    are unstaged/untracked changes, Commit when something is staged,
+                    Push when commits are ahead of the remote. A clean, pushed repo
+                    shows no buttons. The caret beside each action opens a
+                    navigable folder tree of the files it touches, with line
+                    stats. */}
+                {gitStatus.unstaged + gitStatus.untracked > 0 && (
+                  <div className="git-action git-action--add">
+                    <button
+                      className="git-action-btn git-action-btn--add"
+                      disabled={gitBusy}
+                      onClick={handleAdd}
+                      title={`Stage all changes (${gitStatus.unstaged + gitStatus.untracked} unstaged)`}
+                    >
+                      <span data-testid="add-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#f85149" }} />
+                      <span>⊕</span>
+                      <span className="git-btn-label">Add ({gitStatus.unstaged + gitStatus.untracked})</span>
+                    </button>
+                    <button
+                      className="git-action-toggle"
+                      disabled={gitBusy}
+                      aria-label="Show changed files"
+                      aria-expanded={openTree === "add"}
+                      title="Show changed files"
+                      onClick={() => setOpenTree((t) => (t === "add" ? null : "add"))}
+                    >
+                      {openTree === "add" ? "▴" : "▾"}
+                    </button>
+                  </div>
+                )}
+                {gitStatus.staged > 0 && (
+                  <div className="git-action git-action--commit">
+                    <button
+                      className="git-action-btn git-action-btn--commit"
+                      disabled={gitBusy}
+                      onClick={handleCommitOpen}
+                      title={`Commit ${gitStatus.staged} staged`}
+                    >
+                      <span data-testid="commit-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#e3b341" }} />
+                      <span>✔</span>
+                      <span className="git-btn-label">Commit ({gitStatus.staged})</span>
+                    </button>
+                    <button
+                      className="git-action-toggle"
+                      disabled={gitBusy}
+                      aria-label="Show staged files"
+                      aria-expanded={openTree === "commit"}
+                      title="Show staged files"
+                      onClick={() => setOpenTree((t) => (t === "commit" ? null : "commit"))}
+                    >
+                      {openTree === "commit" ? "▴" : "▾"}
+                    </button>
+                  </div>
+                )}
+                {unpushedCommits.length > 0 && (
+                  <div className="git-action git-action--push">
+                    <button
+                      className="git-action-btn git-action-btn--push"
+                      disabled={gitBusy}
+                      onClick={handlePush}
+                      title={`Push ${unpushedCommits.length} commit${unpushedCommits.length === 1 ? "" : "s"} to remote`}
+                    >
+                      <span data-testid="push-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#3fb950" }} />
+                      <span>⬆</span>
+                      <span className="git-btn-label">Push ({unpushedCommits.length})</span>
+                    </button>
+                    <button
+                      className="git-action-toggle"
+                      disabled={gitBusy}
+                      aria-label="Show files in unpushed commits"
+                      aria-expanded={openTree === "push"}
+                      title="Show files in unpushed commits"
+                      onClick={() => setOpenTree((t) => (t === "push" ? null : "push"))}
+                    >
+                      {openTree === "push" ? "▴" : "▾"}
+                    </button>
+                  </div>
+                )}
+                {treeScope && projectDir && (
+                  <GitChangeTree projectDir={projectDir} scope={treeScope} />
+                )}
+              </>
+            )}
+          </div>
+          </>
+          )}
+      </div>
+      )}
+
+      {hidden}
+
+      {/* Compact (docked subwindow) viewer strips the whole header above, which
+          is where the Remote/Local source switch normally lives — but a remote
+          project still needs it here to flip the tree between host and mirror.
+          It gets its own row in the header's place: ABOVE the Files/Git/Search/
+          Apps toolbar, so the compact viewer stacks source-switch → view row →
+          content in the same order the right panel does. Deliberately NOT gated
+          on the files view — the right panel's switch is always up, and a row
+          that appeared only under "Files" would shove the toolbar up and down on
+          every view change. */}
+      {compact && !activeBox && project?.remote && projectId && (
+        <div className="right-panel-source right-panel-source--compact">
+          <FileSourceSwitch source={source} onChange={setSource} />
+          {source === "remote" && (
+            <RunHostPicker
+              projectId={projectId}
+              primaryHost={project.remote.label || project.remote.host}
+              computeHosts={project.compute_hosts}
+            />
+          )}
+        </div>
+      )}
+
+      <div className="right-panel-toolbar">
+        {(["files", "git", "search", "windows"] as View[]).map((v) => (
+          <button
+            key={v}
+            className={`tab-add-btn${view === v ? " active" : ""}`}
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: v === "files" ? 0 : 2 }}
+            aria-pressed={view === v}
+            onClick={() => setView(v)}
+          >
+            {v === "files" ? "Files" : v === "git" ? "Git" : v === "search" ? "Search" : "Apps"}
+          </button>
+        ))}
+        {/* Orange (diverged) files: a dedicated toggle for remote projects,
+            badged with the count so conflicts are visible at a glance. Auto-sync
+            never touches these, so this is where they get resolved. */}
+        {!activeBox && project?.remote && projectId && (
+          <button
+            className={`tab-add-btn right-panel-orange-btn${view === "orange" ? " active" : ""}`}
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            aria-pressed={view === "orange"}
+            onClick={() => setView((v) => (v === "orange" ? "files" : "orange"))}
+            title={`Diverged (orange) files: ${orangeFiles.length}`}
+          >
+            ± {orangeFiles.length > 0 && <span className="right-panel-orange-count">{orangeFiles.length}</span>}
+          </button>
+        )}
+        {/* Persistent (tmux) sessions on the host (TODO #85): remote-only, badged
+            with the live session count, so a run left alive on the host is one
+            click from being reattached. */}
+        {!activeBox && project?.remote && projectId && (
+          <button
+            className={`tab-add-btn right-panel-orange-btn${view === "sessions" ? " active" : ""}`}
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            aria-pressed={view === "sessions"}
+            onClick={() => setView((v) => (v === "sessions" ? "files" : "sessions"))}
+            title={`Persistent host sessions (tmux): ${sessionRows.length}`}
+          >
+            ☰ {sessionRows.length > 0 && <span className="right-panel-orange-count">{sessionRows.length}</span>}
+          </button>
+        )}
+        {/* SLURM jobs (HPC): shown only when the host actually has SLURM, so the
+            toggle never appears off-cluster. Badged with the live queue count. */}
+        {!activeBox && slurmSupported && projectId && (
+          <button
+            className={`tab-add-btn right-panel-orange-btn${view === "jobs" ? " active" : ""}`}
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            aria-pressed={view === "jobs"}
+            onClick={() => setView((v) => (v === "jobs" ? "files" : "jobs"))}
+            title={`SLURM jobs: ${jobRows.length}`}
+          >
+            ⚙ {jobRows.length > 0 && <span className="right-panel-orange-count">{jobRows.length}</span>}
+          </button>
+        )}
+        {importDrop.canImport && (
+          <button
+            className="tab-add-btn"
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            onClick={(e) => {
+              const r = e.currentTarget.getBoundingClientRect();
+              setImportMenu({ x: r.left, y: r.bottom + 2 });
+            }}
+            title="Import files or a folder into this project"
+          >
+            ⬇
+          </button>
+        )}
+        {importMenu && createPortal(
+          <>
+            <div
+              style={{ position: "fixed", inset: 0, zIndex: 200 }}
+              onPointerDown={() => setImportMenu(null)}
+            />
+            <div
+              className="context-menu"
+              style={{ left: importMenu.x, top: importMenu.y, zIndex: 201 }}
+              onPointerDown={(e) => e.stopPropagation()}
+            >
+              <button
+                onClick={() => {
+                  setImportMenu(null);
+                  void importDrop.importViaDialog();
+                }}
+              >
+                Import files…
+              </button>
+              <button
+                onClick={() => {
+                  setImportMenu(null);
+                  void importDrop.importFolderViaDialog();
+                }}
+              >
+                Import folder (copy)…
+              </button>
+            </div>
+          </>,
+          document.body,
+        )}
+        {projectDir && (
+          <button
+            className="tab-add-btn"
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            onClick={openInOsBrowser}
+            title="Open folder in file manager"
+          >
+            ⧉
+          </button>
+        )}
+        {!activeBox && projectDir && (
+          <button
+            className={`tab-add-btn${showDownloads ? " active" : ""}`}
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            aria-pressed={showDownloads}
+            onClick={() => {
+              setShowDownloads((v) => !v);
+              // The section lives in the files view; jump there when revealing it.
+              if (!showDownloads) setView("files");
+            }}
+            title="Show recent downloads (copy into this project)"
+          >
+            📥
+          </button>
+        )}
+        {projectId && (
+          <button
+            className="tab-add-btn"
+            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
+            onClick={() => setShowSettings(true)}
+            title="Project settings"
+          >
+            ⚙
+          </button>
+        )}
+      </div>
+
+      {/* The workspace clock. A workspace expiry does not merely delete "some
+          data" — for a project whose root lives in one it deletes the host tree,
+          repo included. So the warning is raised wherever the user is (every
+          view, not just Jobs), states the two actions that answer it, and is
+          dismissible only until the number changes. */}
+      {warnExpiry && projectWs && (
+        <div className={`hpc-expiry-banner tone-${expiryTone(projectWs)}`}>
+          <span>
+            Workspace <strong>{projectWs.id}</strong> — {remainingLabel(projectWs)}. Its
+            files, including this project's host copy, are deleted at expiry.
+          </span>
+          <div className="hpc-expiry-actions">
+            <button type="button" onClick={() => void extendWs(projectWs)}>
+              Extend…
+            </button>
+            <button type="button" onClick={() => setView("jobs")}>
+              Workspaces
+            </button>
+            <button
+              type="button"
+              title="Dismiss until the remaining time changes"
+              onClick={() => setExpiryDismissed(`${projectWs.id}:${projectWs.remaining_days}`)}
+            >
+              ×
+            </button>
+          </div>
+        </div>
+      )}
+
+      {!compact && !activeBox && gitStatus?.is_repo && (
+        <>
+          {commitMsg !== null && (
+            <div style={{ padding: "4px 6px", borderBottom: "1px solid var(--border-color)" }}>
+              <textarea
+                ref={commitRef}
+                value={commitMsg}
+                onChange={(e) => setCommitMsg(e.target.value)}
+                rows={3}
+                style={{
+                  width: "100%",
+                  fontSize: 11,
+                  background: "var(--bg-panel)",
+                  color: "var(--text-primary)",
+                  border: "1px solid var(--border-color)",
+                  borderRadius: "var(--radius-sm)",
+                  padding: "3px 5px",
+                  resize: "vertical",
+                  boxSizing: "border-box",
+                  fontFamily: "inherit",
+                }}
+              />
+            </div>
+          )}
+          {gitError && (
+            <div style={{ fontSize: 10, color: "var(--danger, #f85149)", wordBreak: "break-all", padding: "2px 6px 4px", borderBottom: "1px solid var(--border-color)" }}>
+              {gitError}
+            </div>
+          )}
+        </>
+      )}
+
+      {view === "git" && (
+        <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto" }}>
+          {nestedRoot && (
+            <div className="nested-repo-toggle" role="group" aria-label="Git repository">
+              <button
+                type="button"
+                className={`nested-repo-pill${!onNestedRepo ? " active" : ""}`}
+                title={projectDir}
+                onClick={() => setPreferProjectRepo(true)}
+              >
+                {project?.name || "Project"}
+              </button>
+              <button
+                type="button"
+                className={`nested-repo-pill${onNestedRepo ? " active" : ""}`}
+                title={nestedRoot}
+                onClick={() => setPreferProjectRepo(false)}
+              >
+                {basename(nestedRoot) || nestedRoot}
+              </button>
+            </div>
+          )}
+          <GitHistory
+            projectDir={effectiveGitRoot}
+            projectId={onNestedRepo ? undefined : project?.remote ? projectId ?? undefined : undefined}
+            remote={!onNestedRepo && !!project?.remote}
+            onChanged={() => effectiveGitRoot && refreshGit(effectiveGitRoot)}
+          />
+        </div>
+      )}
+
+      {view === "search" && (
+        <SearchPanel projectDir={projectDir} linkingTabKey={undefined} />
+      )}
+
+      {view === "orange" && (
+        <div className="right-panel-scroll right-panel-orange" style={{ flex: 1, overflowY: "auto" }}>
+          {orangeFiles.length === 0 ? (
+            <div className="right-panel-orange-empty">No diverged files</div>
+          ) : (
+            <>
+              {/* Bulk "…for all" resolution: take one side for every diverged
+                  file at once. Both are destructive to the losing side, so each
+                  confirms first (with the file count). Header + icon buttons
+                  (not a text button per row) so the bar stays compact. */}
+              <div className="orange-bulk-bar">
+                <span className="orange-bulk-count">
+                  {orangeFiles.length} diverged
+                </span>
+                <div className="orange-file-actions">
+                  <button
+                    type="button"
+                    className="orange-file-act orange-file-act--icon orange-file-act--remote"
+                    aria-label="Take the remote copy for all"
+                    title="Take the remote copy for every diverged file (overwrite the local mirror)"
+                    disabled={remoteBlocked}
+                    onClick={() => {
+                      if (!projectId) return;
+                      if (
+                        !window.confirm(
+                          `Take the remote copy for all ${orangeFiles.length} diverged files? This overwrites your local mirror edits.`,
+                        )
+                      )
+                        return;
+                      void useSyncStore
+                        .getState()
+                        .resolveAll(projectId, orangeFiles, "host");
+                    }}
+                  >
+                    ⬇
+                  </button>
+                  <button
+                    type="button"
+                    className="orange-file-act orange-file-act--icon orange-file-act--local"
+                    aria-label="Keep the local copy for all"
+                    title="Keep the local copy for every diverged file (force-push over the host)"
+                    disabled={remoteBlocked}
+                    onClick={() => {
+                      if (!projectId) return;
+                      if (
+                        !window.confirm(
+                          `Keep the local copy for all ${orangeFiles.length} diverged files? This overwrites the host copies.`,
+                        )
+                      )
+                        return;
+                      void useSyncStore
+                        .getState()
+                        .resolveAll(projectId, orangeFiles, "local");
+                    }}
+                  >
+                    ⬆
+                  </button>
+                </div>
+              </div>
+              {orangeFiles.map((rel) => {
+                const rowHostMtime = syncMap?.[rel]?.hostMtime;
+                const rowLocalMtime = syncMap?.[rel]?.localMtime;
+                const mtimeCue = mtimeDivergenceCue(rowHostMtime, rowLocalMtime);
+                // "Remote only" / "Local only": the other side has no file at
+                // all, so the action that would act on it is a no-op — disable
+                // it rather than leave a button that errors when clicked.
+                const noHostFile = rowHostMtime == null;
+                const noLocalFile = rowLocalMtime == null;
+                return (
+                  <div key={rel} className="orange-file-row" title={rel}>
+                <button
+                  type="button"
+                  className="orange-file-name"
+                  disabled={!mirrorRoot}
+                  title={mirrorRoot ? `Open ${rel}` : rel}
+                  onClick={() => {
+                    if (!mirrorRoot) return;
+                    const abs = `${mirrorRoot}/${rel}`;
+                    // Open the diverged file in the three-way merge viewer
+                    // (local mirror ⇄ merged ⇄ remote host, PyCharm-style), so
+                    // the user can take changes from either side per block and
+                    // resolve the divergence in one place.
+                    openLinkedFile(undefined, dirname(abs), {
+                      path: abs,
+                      viewer: "syncmerge",
+                      label: basename(abs),
+                    });
+                  }}
+                >
+                  <span className="orange-file-dot" aria-hidden="true">±</span>
+                  {rel}
+                </button>
+                {mtimeCue && (
+                  <span
+                    className={`orange-mtime-badge orange-mtime-badge--${mtimeCue.tone}`}
+                    title={mtimeCue.title}
+                  >
+                    {mtimeCue.text}
+                  </span>
+                )}
+                <div className="orange-file-actions">
+                  <button
+                    type="button"
+                    className="orange-file-act orange-file-act--icon orange-file-act--remote"
+                    aria-label="Take the remote copy"
+                    title={noHostFile ? "No remote copy to take" : "Take the remote copy (overwrite the local mirror)"}
+                    disabled={remoteBlocked || noHostFile}
+                    onClick={() => projectId && void useSyncStore.getState().pull(projectId, rel)}
+                  >
+                    ⬇
+                  </button>
+                  <button
+                    type="button"
+                    className="orange-file-act orange-file-act--icon orange-file-act--local"
+                    aria-label="Keep the local copy"
+                    title={noLocalFile ? "No local copy to keep" : "Keep the local copy (force-push over the host)"}
+                    disabled={remoteBlocked || noLocalFile}
+                    onClick={() => projectId && void useSyncStore.getState().push(projectId, rel, true)}
+                  >
+                    ⬆
+                  </button>
+                </div>
+                  </div>
+                );
+              })}
+            </>
+          )}
+        </div>
+      )}
+
+      {view === "sessions" && (
+        <div className="right-panel-scroll right-panel-orange" style={{ flex: 1, overflowY: "auto" }}>
+          {!remoteBlocked && (
+            <label
+              className="tmux-scope-toggle"
+              title={
+                "Off: only this project's sessions — matched by name, or (for a session " +
+                "started before names carried a project, or by hand) by whether it is " +
+                "running inside this project's folder.\n" +
+                "On: every session on the host, including other projects' and ones " +
+                "running outside any project."
+              }
+            >
+              <input
+                type="checkbox"
+                checked={showAllSessions}
+                onChange={(e) => setShowAllSessions(e.target.checked)}
+              />
+              All host sessions
+            </label>
+          )}
+          {sessionRows.length === 0 ? (
+            <div className="right-panel-orange-empty">
+              {remoteBlocked
+                ? "Connect to list host sessions"
+                : showAllSessions
+                  ? "No persistent sessions on the host(s)"
+                  : "No sessions for this project on the host(s)"}
+            </div>
+          ) : (
+            sessionGroups.map(({ hostId, hostLabel, rows }) => (
+              <section className="tmux-machine-group" key={hostId} aria-label={`Persistent sessions on ${hostLabel}`}>
+                <div className="tmux-machine-group-title">{hostLabel}</div>
+                {rows.map(({ session: s }) => {
+                  const owned = sessionOwners.has(`${hostId} ${s.name}`);
+                  return (
+                    <div
+                      key={`${hostId} ${s.name}`}
+                      className="orange-file-row"
+                      onMouseEnter={(e) => handleSessionRowMouseEnter(e, hostId, s.name)}
+                      onMouseLeave={handleSessionRowMouseLeave}
+                    >
+                      <button
+                        type="button"
+                        className="orange-file-name"
+                        title={owned ? `Reveal the tab running “${s.name}”` : `Attach to “${s.name}”`}
+                        onClick={() => openSession(hostId, s.name)}
+                      >
+                        <span className="orange-file-dot" aria-hidden="true">
+                          {s.attached ? "●" : "○"}
+                        </span>
+                        {s.working && (
+                          <span className="tmux-work-dot" aria-hidden="true" title="Working" />
+                        )}
+                        <span className="tmux-session-label">{sessionDisplayName(s.name)}</span>
+                        {owned && <span className="tmux-session-meta">open</span>}
+                      </button>
+                      <div className="orange-file-actions">
+                        <button
+                          type="button"
+                          className="orange-file-act"
+                          title="Rename this session"
+                          onClick={() => renameSession(hostId, s.name)}
+                        >
+                          Rename
+                        </button>
+                        <button
+                          type="button"
+                          className="orange-file-act"
+                          title="Kill this session and everything running in it"
+                          aria-label={`Kill session ${s.name}`}
+                          onClick={() => killSession(hostId, s.name)}
+                        >
+                          ×
+                        </button>
+                      </div>
+                    </div>
+                  );
+                })}
+              </section>
+            ))
+          )}
+        </div>
+      )}
+      {sessionTooltip && (() => {
+        const statsRow = sessionRows.find(
+          (r) => r.hostId === sessionTooltip.hostId && r.session.name === sessionTooltip.name,
+        );
+        if (!statsRow) return null;
+        const s = statsRow.session;
+        const owned = sessionOwners.has(`${statsRow.hostId} ${s.name}`);
+        // Same side-picking + vertical-shift positioning as FileTree's `.file-tooltip`:
+        // opens toward whichever side of the row has more room, and is pulled up if
+        // it would otherwise overflow the window's bottom edge.
+        const style: React.CSSProperties =
+          window.innerWidth - sessionTooltip.rect.right > sessionTooltip.rect.left
+            ? { left: sessionTooltip.rect.right + 8, top: sessionTooltip.rect.top - sessionTooltipShift }
+            : { right: window.innerWidth - sessionTooltip.rect.left + 8, top: sessionTooltip.rect.top - sessionTooltipShift };
+        return createPortal(
+          <div ref={sessionTooltipRef} className="file-tooltip" style={style}>
+            <div className="file-tooltip-name">
+              {s.name}
+              <UntestedTag />
+            </div>
+            <div>
+              <span className="file-tooltip-label">Host</span>
+              {statsRow.hostLabel}
+            </div>
+            <div>
+              <span className="file-tooltip-label">Status</span>
+              {s.working ? `Working — ${s.currentCommand}` : "Idle"}
+            </div>
+            <div>
+              <span className="file-tooltip-label">Uptime</span>
+              {relativeDuration(s.created)} (since {absoluteTime(s.created)})
+            </div>
+            <div>
+              <span className="file-tooltip-label">{s.working ? "Active" : "Idle for"}</span>
+              {s.working ? "now" : relativeDuration(s.activity)}
+            </div>
+            <div>
+              <span className="file-tooltip-label">Windows</span>
+              {s.windows}
+            </div>
+            <div>
+              <span className="file-tooltip-label">Attached</span>
+              {s.attached ? "Yes" : "No"}
+            </div>
+            <div>
+              <span className="file-tooltip-label">Open in a tab</span>
+              {owned ? "Yes" : "No"}
+            </div>
+          </div>,
+          document.body,
+        );
+      })()}
+
+      {view === "jobs" && (
+        <div className="right-panel-scroll right-panel-orange" style={{ flex: 1, overflowY: "auto" }}>
+          <div className="right-panel-jobs-head">
+            <UntestedTag />
+          </div>
+          {wsRows.length > 0 && (
+            <>
+              <div className="right-panel-orange-note">
+                Workspaces — data here is deleted at expiry
+                {project?.hpc?.logs_dir && (
+                  <button
+                    type="button"
+                    className="orange-file-act"
+                    title={`Copy the job logs from ${project.hpc.logs_dir} into the mirror's logs/`}
+                    onClick={() => void pullProjectLogs()}
+                  >
+                    Pull logs
+                  </button>
+                )}
+              </div>
+              {wsRows.map((ws) => {
+                const here = projectWs?.id === ws.id && projectWs?.path === ws.path;
+                return (
+                  <div key={`${ws.filesystem ?? ""}/${ws.id}`} className="orange-file-row" title={ws.path}>
+                    <span className="orange-file-name" style={{ cursor: "default" }}>
+                      <span className="orange-file-dot" aria-hidden="true">{here ? "●" : "○"}</span>
+                      {ws.id}
+                      <span className={`tmux-session-meta hpc-ws-remaining tone-${expiryTone(ws)}`}>
+                        {[
+                          here ? "this project" : "",
+                          ws.filesystem ?? "",
+                          remainingLabel(ws),
+                        ]
+                          .filter(Boolean)
+                          .join(" · ")}
+                      </span>
+                    </span>
+                    <div className="orange-file-actions">
+                      <button
+                        type="button"
+                        className="orange-file-act"
+                        title="Extend this workspace (spends one of its extensions)"
+                        onClick={() => void extendWs(ws)}
+                      >
+                        Extend
+                      </button>
+                      {!here && project?.remote && (
+                        <button
+                          type="button"
+                          className="orange-file-act"
+                          disabled={wsBusy}
+                          title="Move this project's host tree into this workspace (re-seeded from your local mirror)"
+                          onClick={() => void moveProjectTo(ws)}
+                        >
+                          Move here
+                        </button>
+                      )}
+                    </div>
+                  </div>
+                );
+              })}
+            </>
+          )}
+          {jobRows.length === 0 ? (
+            <div className="right-panel-orange-empty">
+              {remoteBlocked
+                ? "Connect to list SLURM jobs"
+                : "No queued or running jobs (squeue)"}
+            </div>
+          ) : (
+            jobRows.map((j) => (
+              <div key={j.id} className="orange-file-row" title={`${j.id} ${j.name}`}>
+                <button
+                  type="button"
+                  className="orange-file-name"
+                  title={`Watch job ${j.id} — tail its output log`}
+                  onClick={() => void watchJob(j.id, j.name)}
+                >
+                  <span className="orange-file-dot" aria-hidden="true">
+                    {j.state === "RUNNING" ? "●" : "○"}
+                  </span>
+                  {j.name || j.id}
+                  <span className="tmux-session-meta">
+                    {j.id} · {j.state}
+                    {j.time ? ` · ${j.time}` : ""}
+                    {j.nodes ? ` · ${j.nodes} node${j.nodes === "1" ? "" : "s"}` : ""}
+                    {j.reason && j.reason !== "(None)" ? ` · ${j.reason}` : ""}
+                  </span>
+                </button>
+                <div className="orange-file-actions">
+                  <button
+                    type="button"
+                    className="orange-file-act"
+                    title="Watch this job's output log"
+                    onClick={() => void watchJob(j.id, j.name)}
+                  >
+                    Watch
+                  </button>
+                  <button
+                    type="button"
+                    className="orange-file-act"
+                    title="Cancel this job (scancel)"
+                    aria-label={`Cancel job ${j.id}`}
+                    onClick={() => cancelJob(j.id, j.name)}
+                  >
+                    ×
+                  </button>
+                </div>
+              </div>
+            ))
+          )}
+        </div>
+      )}
+
+      {view === "files" && (
+        <ProjectFilesPane
+          scope={scope}
+          project={project}
+          projectDir={projectDir}
+          folder={folder}
+          onFolderChange={onFolderChange}
+          source={source}
+          hiddenEndings={filters.hiddenEndings}
+          hiddenPaths={filters.hiddenPaths}
+          shownPaths={filters.shownPaths}
+          scanExcluded={filters.scanExcluded}
+          onToggleScanExcluded={filters.toggleScanExcluded}
+          sortKey={sortKey}
+          descending={descending}
+          onSortChange={(key, desc) => {
+            setSortKey(key);
+            setDescending(desc);
+          }}
+          showDownloads={showDownloads}
+          onCloseDownloads={() => setShowDownloads(false)}
+          // Right-click → "Open in a new tab": the same file view, on that
+          // folder, as a Files (Project) tab in this project's scope.
+          onOpenFolderTab={onOpenFolderTab}
+          // A closed panel keeps no tree mounted (and so no fs-watch).
+          mountTree={mountTree}
+          compact={compact}
+        />
+      )}
+
+      {view === "windows" && (
+        <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto", padding: 4 }}>
+          {windows.length === 0 ? (
+            <div className="file-tree-empty">No opened windows</div>
+          ) : (
+            windows.map((w) => (
+              <div key={w.id} className="file-entry">
+                <span className="file-icon">🪟</span>
+                <span className="file-name" title={w.exec}>
+                  {basename(w.exec) || w.exec}
+                  {w.file && <span style={{ color: "var(--text-muted)" }}> {basename(w.file)}</span>}
+                </span>
+                <button
+                  className="tab-close"
+                  onClick={() => untrack(w.id)}
+                  title="Untrack"
+                >
+                  ×
+                </button>
+              </div>
+            ))
+          )}
+        </div>
+      )}
+      {showSettings && project && localFile && (
+        <ProjectFilesSettingsDialog
+          localFile={localFile}
+          project={project}
+          filters={filters}
+          onClose={() => setShowSettings(false)}
+        />
+      )}
+    </div>
+  );
+}
diff --git a/src/components/files/QuickOpen.css b/src/components/files/QuickOpen.css
new file mode 100644
index 0000000..a68a277
--- /dev/null
+++ b/src/components/files/QuickOpen.css
@@ -0,0 +1,133 @@
+/* Quick-open (Ctrl/Cmd+P) palette — component-scoped styles (Dev B). */
+
+.qo-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 9000;
+  display: flex;
+  justify-content: center;
+  align-items: flex-start;
+  padding-top: 12vh;
+  background: rgba(0, 0, 0, 0.35);
+}
+
+.qo-panel {
+  width: min(620px, 90vw);
+  max-height: 60vh;
+  display: flex;
+  flex-direction: column;
+  /* Use the app's theme tokens (with neutral fallbacks) so the palette follows
+     the active theme rather than rendering as a hardcoded dark box. */
+  background: var(--bg-panel, #1e1e1e);
+  color: var(--text-primary, #e6e6e6);
+  border: 1px solid var(--border-color, rgba(255, 255, 255, 0.12));
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-3);
+  overflow: hidden;
+}
+
+.qo-input {
+  flex: 0 0 auto;
+  box-sizing: border-box;
+  width: 100%;
+  padding: 10px 12px;
+  font-size: 14px;
+  /* Explicit (not `inherit`) so the field text stays readable wherever the
+     palette is portaled. */
+  color: var(--text-primary, #e6e6e6);
+  background: transparent;
+  border: none;
+  border-bottom: 1px solid var(--border-color, rgba(255, 255, 255, 0.12));
+  outline: none;
+}
+
+.qo-list {
+  flex: 1 1 auto;
+  overflow-y: auto;
+  padding: 4px 0;
+}
+
+.qo-row {
+  padding: 5px 12px;
+  font-size: 13px;
+  font-family: var(--mono-font, ui-monospace, SFMono-Regular, Menlo, monospace);
+  /* Explicit row text color so paths read clearly on the panel (the default
+     inherited color was the source of the low-contrast "blue on dark" rows). */
+  color: var(--text-primary, #e6e6e6);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  cursor: pointer;
+  direction: rtl; /* keep the basename visible when the path overflows */
+  text-align: left;
+}
+
+.qo-row > * {
+  direction: ltr;
+  unicode-bidi: plaintext;
+}
+
+.qo-row-sel {
+  /* A plain translucent fill — color-mix doesn't render reliably on this
+     WebKitGTK build, so don't tint from --accent at runtime. */
+  background: rgba(120, 160, 255, 0.22);
+}
+
+.qo-hl {
+  /* Emphasised accent (higher contrast than the base --accent on both light and
+     dark panels) plus bold, so matched characters read clearly rather than as
+     dim "blue on dark". */
+  color: var(--accent-hover, var(--accent, #79b8ff));
+  font-weight: 700;
+}
+
+.qo-empty {
+  padding: 12px;
+  font-size: 13px;
+  color: var(--text-muted, #9aa6bf);
+}
+
+/* ── Context-files picker variant ──────────────────────────────────────────
+   A more prominent, accent-coloured take on the palette (it's invoked from deep
+   in the editor, so it should read unmistakably as an overlay). Scoped to the
+   ContextFilePicker via `qo-context-*` so the plain Ctrl/Cmd+P palette is
+   unchanged. --accent is used solid (no color-mix — unreliable on this WebKitGTK
+   build) for the frame and header. */
+.qo-context-backdrop {
+  background: rgba(0, 0, 0, 0.5);
+}
+
+.qo-context-panel {
+  border: 1px solid var(--accent, #79b8ff);
+  /* Bold accent cap along the top edge. */
+  border-top: 4px solid var(--accent, #79b8ff);
+  box-shadow: var(--shadow-3);
+}
+
+/* Solid accent header strip with contrasting text — the "coloured" part. */
+.qo-context-header {
+  flex: 0 0 auto;
+  padding: 7px 12px;
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+  color: #fff;
+  /* Same blue as the autocomplete suggestion text (--accent, see
+     .file-viewer-ghost-text) so the overlay reads as part of the same feature. */
+  background: var(--accent, #79b8ff);
+}
+
+/* Accent underline under the search field to tie it to the header. */
+.qo-context-panel .qo-input {
+  border-bottom: 2px solid var(--accent, #79b8ff);
+}
+
+/* Match highlights in the same --accent blue as the autocomplete text. */
+.qo-context-panel .qo-hl {
+  color: var(--accent, #4493f8);
+}
+
+/* Stronger, accent-aligned selection fill so the active row stands out. */
+.qo-context-panel .qo-row-sel {
+  background: rgba(54, 197, 240, 0.28);
+}
diff --git a/src/components/files/QuickOpen.tsx b/src/components/files/QuickOpen.tsx
new file mode 100644
index 0000000..411a5e9
--- /dev/null
+++ b/src/components/files/QuickOpen.tsx
@@ -0,0 +1,219 @@
+/**
+ * Quick-open / fuzzy file finder (Dev B), à la VS Code's Ctrl/Cmd+P.
+ *
+ * Mounted once in AppShell with no props. Registers a global Ctrl/Cmd+P key
+ * handler that opens a centered modal palette: a query input + a fuzzy-ranked
+ * list of the active project's files (from `list_project_paths`). Arrow keys /
+ * Enter / Esc navigate; picking a file opens it in an in-app viewer tab via
+ * `openLinkedFile` + `viewerForPath` (the same channel markdown link-following
+ * uses). Fuzzy match + scoring live in the pure, unit-tested `src/lib/fuzzy.ts`.
+ *
+ * Reads the active project from `useProjectsStore` directly.
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "../../stores/projects";
+import { resolveProjectDirectory } from "../../types";
+import { fuzzyMatch, fuzzyRank } from "../../lib/fuzzy";
+import { basename, resolvePath } from "../../lib/paths";
+import { IS_MAC } from "../../lib/platform";
+import { openLinkedFile, viewerForPath } from "../embed/FileViewerPane";
+import "./QuickOpen.css";
+
+interface PathEntry {
+  path: string;
+  is_dir: boolean;
+}
+
+const MAX_RESULTS = 50;
+
+/** Render the rel path with the fuzzy-matched characters emphasised. */
+function HighlightedPath({ text, query }: { text: string; query: string }) {
+  const positions = useMemo(() => {
+    if (!query) return null;
+    const m = fuzzyMatch(query, text);
+    return m ? new Set(m.positions) : null;
+  }, [text, query]);
+
+  if (!positions || positions.size === 0) return <>{text}</>;
+
+  const out: React.ReactNode[] = [];
+  for (let i = 0; i < text.length; i++) {
+    if (positions.has(i)) {
+      out.push(
+        <span key={i} className="qo-hl">
+          {text[i]}
+        </span>,
+      );
+    } else {
+      out.push(text[i]);
+    }
+  }
+  return <>{out}</>;
+}
+
+export function QuickOpen() {
+  const [open, setOpen] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [files, setFiles] = useState<string[]>([]);
+  const [query, setQuery] = useState("");
+  const [selected, setSelected] = useState(0);
+
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const listRef = useRef<HTMLDivElement | null>(null);
+  // Guards against a stale fetch landing after the palette re-opened.
+  const fetchToken = useRef(0);
+
+  const activeProjectDir = useCallback((): string => {
+    const { projects, activeId } = useProjectsStore.getState();
+    const project = projects.find((p) => p.id === activeId);
+    return project ? resolveProjectDirectory(project) : "";
+  }, []);
+
+  const close = useCallback(() => {
+    setOpen(false);
+    setQuery("");
+    setSelected(0);
+  }, []);
+
+  const loadFiles = useCallback(
+    async (projectDir: string) => {
+      const token = ++fetchToken.current;
+      setLoading(true);
+      setFiles([]);
+      try {
+        const entries = await invoke<PathEntry[]>("list_project_paths", { projectDir });
+        if (token !== fetchToken.current) return; // superseded by a newer open
+        setFiles(entries.filter((e) => !e.is_dir).map((e) => e.path));
+      } catch {
+        if (token !== fetchToken.current) return;
+        setFiles([]);
+      } finally {
+        if (token === fetchToken.current) setLoading(false);
+      }
+    },
+    [],
+  );
+
+  // Global Ctrl/Cmd+P toggle.
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      const mod = IS_MAC ? e.metaKey : e.ctrlKey;
+      if (mod && !e.altKey && !e.shiftKey && (e.key === "p" || e.key === "P")) {
+        const dir = activeProjectDir();
+        if (!dir) return; // no active project → leave the event alone
+        e.preventDefault();
+        e.stopPropagation();
+        setQuery("");
+        setSelected(0);
+        setOpen(true);
+        void loadFiles(dir);
+      }
+    };
+    window.addEventListener("keydown", onKey, true);
+    return () => window.removeEventListener("keydown", onKey, true);
+  }, [activeProjectDir, loadFiles]);
+
+  // Autofocus the input whenever the palette opens.
+  useEffect(() => {
+    if (open) inputRef.current?.focus();
+  }, [open]);
+
+  const results = useMemo(
+    () => fuzzyRank(query, files, (f) => f).slice(0, MAX_RESULTS),
+    [query, files],
+  );
+
+  // Keep the selection in range as results change.
+  useEffect(() => {
+    setSelected((s) => (results.length === 0 ? 0 : Math.min(s, results.length - 1)));
+  }, [results]);
+
+  // Keep the selected row scrolled into view.
+  useEffect(() => {
+    const el = listRef.current?.querySelector<HTMLElement>(`[data-idx="${selected}"]`);
+    el?.scrollIntoView({ block: "nearest" });
+  }, [selected, results]);
+
+  const openFile = useCallback(
+    (rel: string) => {
+      const projectDir = activeProjectDir();
+      if (!projectDir) return;
+      const absPath = resolvePath(projectDir, rel);
+      openLinkedFile(undefined, projectDir, {
+        path: absPath,
+        viewer: viewerForPath(absPath),
+        label: basename(absPath),
+      });
+      close();
+    },
+    [activeProjectDir, close],
+  );
+
+  const onInputKey = useCallback(
+    (e: React.KeyboardEvent<HTMLInputElement>) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        close();
+      } else if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setSelected((s) => (results.length === 0 ? 0 : (s + 1) % results.length));
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setSelected((s) =>
+          results.length === 0 ? 0 : (s - 1 + results.length) % results.length,
+        );
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        const pick = results[selected];
+        if (pick) openFile(pick);
+      }
+    },
+    [results, selected, close, openFile],
+  );
+
+  if (!open) return null;
+
+  return (
+    <div className="qo-backdrop" onMouseDown={close}>
+      <div className="qo-panel" onMouseDown={(e) => e.stopPropagation()}>
+        <input
+          ref={inputRef}
+          className="qo-input"
+          type="text"
+          placeholder="Go to file…"
+          value={query}
+          spellCheck={false}
+          autoComplete="off"
+          onChange={(e) => {
+            setQuery(e.target.value);
+            setSelected(0);
+          }}
+          onKeyDown={onInputKey}
+        />
+        <div className="qo-list" ref={listRef}>
+          {loading ? (
+            <div className="qo-empty">Loading…</div>
+          ) : results.length === 0 ? (
+            <div className="qo-empty">{files.length === 0 ? "No files" : "No matches"}</div>
+          ) : (
+            results.map((rel, idx) => (
+              <div
+                key={rel}
+                data-idx={idx}
+                className={"qo-row" + (idx === selected ? " qo-row-sel" : "")}
+                onMouseDown={(e) => {
+                  e.preventDefault();
+                  openFile(rel);
+                }}
+                onMouseEnter={() => setSelected(idx)}
+              >
+                <HighlightedPath text={rel} query={query} />
+              </div>
+            ))
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/files/SearchPanel.tsx b/src/components/files/SearchPanel.tsx
new file mode 100644
index 0000000..d053b2b
--- /dev/null
+++ b/src/components/files/SearchPanel.tsx
@@ -0,0 +1,251 @@
+import { useEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { Toggle } from "../common/Toggle";
+import { openLinkedFile } from "../embed/FileViewerPane";
+import { useEditorJumpStore } from "../../stores/editorJump";
+
+/** Mirror of the Rust `SearchMatch` struct from `commands::search`. */
+interface SearchMatch {
+  path: string;
+  rel: string;
+  line: number;
+  col: number;
+  text: string;
+}
+
+const MIN_QUERY_LEN = 2;
+const DEBOUNCE_MS = 250;
+const MAX_RESULTS = 500;
+
+/** Split `text` around the (1-based char column) match of `query` so the hit can
+ *  be highlighted. Falls back to the plain line when no match is locatable. */
+function highlightParts(
+  text: string,
+  query: string,
+  caseSensitive: boolean,
+): { before: string; hit: string; after: string } | null {
+  if (!query) return null;
+  const hay = caseSensitive ? text : text.toLowerCase();
+  const needle = caseSensitive ? query : query.toLowerCase();
+  const idx = hay.indexOf(needle);
+  if (idx < 0) return null;
+  return {
+    before: text.slice(0, idx),
+    hit: text.slice(idx, idx + query.length),
+    after: text.slice(idx + query.length),
+  };
+}
+
+export function SearchPanel({
+  projectDir,
+  linkingTabKey,
+}: {
+  projectDir: string;
+  linkingTabKey?: string;
+}) {
+  const [query, setQuery] = useState("");
+  const [caseSensitive, setCaseSensitive] = useState(false);
+  const [results, setResults] = useState<SearchMatch[]>([]);
+  const [error, setError] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [searched, setSearched] = useState(false);
+  const reqId = useRef(0);
+
+  useEffect(() => {
+    if (!projectDir) return;
+    const trimmed = query.trim();
+    if (trimmed.length < MIN_QUERY_LEN) {
+      setResults([]);
+      setError(null);
+      setSearched(false);
+      setLoading(false);
+      return;
+    }
+    const id = ++reqId.current;
+    setLoading(true);
+    const timer = setTimeout(() => {
+      invoke<SearchMatch[]>("project_search", {
+        projectDir,
+        query: trimmed,
+        caseSensitive,
+        maxResults: MAX_RESULTS,
+      })
+        .then((matches) => {
+          if (reqId.current !== id) return; // a newer query superseded this one
+          setResults(matches);
+          setError(null);
+          setSearched(true);
+          setLoading(false);
+        })
+        .catch((e) => {
+          if (reqId.current !== id) return;
+          setResults([]);
+          setError(String(e));
+          setSearched(true);
+          setLoading(false);
+        });
+    }, DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [query, caseSensitive, projectDir]);
+
+  function openResult(m: SearchMatch) {
+    openLinkedFile(linkingTabKey, projectDir, {
+      path: m.path,
+      viewer: "text",
+      label: m.rel.split("/").pop() ?? m.rel,
+    });
+    useEditorJumpStore.getState().requestJump(m.path, m.line, m.col);
+  }
+
+  if (!projectDir) {
+    return (
+      <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto", padding: 8 }}>
+        <div className="file-tree-empty">Open a project to search</div>
+      </div>
+    );
+  }
+
+  const trimmed = query.trim();
+  const tooShort = trimmed.length > 0 && trimmed.length < MIN_QUERY_LEN;
+
+  return (
+    <div style={{ flex: 1, display: "flex", flexDirection: "column", minHeight: 0 }}>
+      <div
+        style={{
+          padding: "6px",
+          borderBottom: "1px solid var(--border-color)",
+          display: "flex",
+          flexDirection: "column",
+          gap: 5,
+        }}
+      >
+        <input
+          type="text"
+          value={query}
+          autoFocus
+          placeholder="Search project files…"
+          onChange={(e) => setQuery(e.target.value)}
+          style={{
+            width: "100%",
+            fontSize: 12,
+            background: "var(--bg-panel)",
+            color: "var(--text-primary)",
+            border: "1px solid var(--border-color)",
+            borderRadius: "var(--radius-sm)",
+            padding: "4px 6px",
+            boxSizing: "border-box",
+          }}
+        />
+        <label
+          style={{
+            display: "flex",
+            alignItems: "center",
+            gap: 5,
+            fontSize: 11,
+            color: "var(--text-muted)",
+            cursor: "pointer",
+          }}
+        >
+          <Toggle
+            size="sm"
+            checked={caseSensitive}
+            onChange={(e) => setCaseSensitive(e.target.checked)}
+          />
+          <span>Case sensitive</span>
+        </label>
+      </div>
+
+      <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto" }}>
+        {error ? (
+          <div
+            style={{
+              fontSize: 11,
+              color: "var(--danger, #f85149)",
+              wordBreak: "break-all",
+              padding: "6px 8px",
+            }}
+          >
+            {error}
+          </div>
+        ) : tooShort ? (
+          <div className="file-tree-empty">Type at least {MIN_QUERY_LEN} characters</div>
+        ) : loading && results.length === 0 ? (
+          <div className="file-tree-empty">Searching…</div>
+        ) : searched && results.length === 0 ? (
+          <div className="file-tree-empty">No results</div>
+        ) : (
+          <>
+            {results.length > 0 && (
+              <div
+                style={{
+                  fontSize: 10,
+                  color: "var(--text-muted)",
+                  padding: "4px 8px",
+                }}
+              >
+                {results.length}
+                {results.length >= MAX_RESULTS ? "+" : ""} match
+                {results.length === 1 ? "" : "es"}
+              </div>
+            )}
+            {results.map((m, i) => {
+              const parts = highlightParts(m.text, trimmed, caseSensitive);
+              return (
+                <button
+                  key={`${m.path}:${m.line}:${m.col}:${i}`}
+                  type="button"
+                  className="file-entry"
+                  onClick={() => openResult(m)}
+                  title={`${m.rel}:${m.line}`}
+                  style={{
+                    width: "100%",
+                    textAlign: "left",
+                    background: "transparent",
+                    border: "none",
+                    cursor: "pointer",
+                    display: "flex",
+                    flexDirection: "column",
+                    alignItems: "flex-start",
+                    gap: 1,
+                    padding: "3px 8px",
+                  }}
+                >
+                  <span style={{ fontSize: 10, color: "var(--text-muted)" }}>
+                    {m.rel}:{m.line}
+                  </span>
+                  <span
+                    style={{
+                      fontSize: 11,
+                      color: "var(--text-primary)",
+                      fontFamily: "monospace",
+                      whiteSpace: "pre-wrap",
+                      wordBreak: "break-word",
+                    }}
+                  >
+                    {parts ? (
+                      <>
+                        {parts.before}
+                        <mark
+                          style={{
+                            background: "var(--accent, #e3b341)",
+                            color: "var(--bg-panel, #000)",
+                            borderRadius: 2,
+                          }}
+                        >
+                          {parts.hit}
+                        </mark>
+                        {parts.after}
+                      </>
+                    ) : (
+                      m.text
+                    )}
+                  </span>
+                </button>
+              );
+            })}
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/files/SetDefaultAppDialog.tsx b/src/components/files/SetDefaultAppDialog.tsx
index 2cf3c2d..812720d 100644
--- a/src/components/files/SetDefaultAppDialog.tsx
+++ b/src/components/files/SetDefaultAppDialog.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { invoke } from "@tauri-apps/api/core";
 import { open } from "@tauri-apps/plugin-dialog";
@@ -22,6 +22,21 @@ interface Props {
   onClose: () => void;
 }
 
+/**
+ * Whether an installed-app row corresponds to the current exec: true when the
+ * exec is exactly the app's command, or that command followed by extra args — a
+ * multi-word invocation such as a sharun AppImage's binary selector
+ * (`/opt/…AppImage kicad <file>`) or a Flatpak launcher line. Keeps such a
+ * working exec highlighted, and lets a re-select preserve its trailing args
+ * instead of stripping them back to the bare `.desktop` value.
+ */
+export function execMatchesApp(exec: string, appExec: string): boolean {
+  const e = exec.trim().split(/\s+/).filter(Boolean);
+  const a = appExec.trim().split(/\s+/).filter(Boolean);
+  if (a.length === 0 || a.length > e.length) return false;
+  return a.every((token, i) => token === e[i]);
+}
+
 function readDefaultApps(project: ProjectJson | null): Record<string, string> {
   const raw = project?.default_apps;
   if (!raw || typeof raw !== "object") return {};
@@ -42,6 +57,7 @@ function readDefaultApps(project: ProjectJson | null): Record<string, string> {
 export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props) {
   const [scope, setScope] = useState<Scope>(localFile ? "project" : "global");
   const [apps, setApps] = useState<InstalledApp[]>([]);
+  const [iconDataUrls, setIconDataUrls] = useState<Record<string, string | null>>({});
   const [query, setQuery] = useState("");
   const [exec, setExec] = useState("");
   const [globalApps, setGlobalApps] = useState<Record<string, string>>({});
@@ -49,6 +65,8 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
   const [projectJson, setProjectJson] = useState<ProjectJson | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [busy, setBusy] = useState(false);
+  // Once the user picks a scope radio themselves, stop auto-selecting it.
+  const userPickedScope = useRef(false);
 
   useEffect(() => {
     invoke<InstalledApp[]>("list_installed_apps")
@@ -70,6 +88,17 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
     }
   }, [localFile]);
 
+  // Open in whichever scope already maps this extension, so reopening the dialog
+  // surfaces the saved value instead of an empty project-scope field (a mapping
+  // saved Global would otherwise be invisible while the default scope is
+  // "project"). Project wins over global, matching the resolution precedence.
+  // Deferred to the maps loading, and disabled once the user picks a scope.
+  useEffect(() => {
+    if (userPickedScope.current) return;
+    if (localFile && projectApps[ext]) setScope("project");
+    else if (globalApps[ext]) setScope("global");
+  }, [ext, localFile, projectApps, globalApps]);
+
   // Seed the exec field with whatever the chosen scope currently maps this
   // extension to, so the dialog opens showing the present value.
   useEffect(() => {
@@ -85,6 +114,32 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
     );
   }, [apps, query]);
 
+  // Resolve icons lazily for the apps currently shown. The backend caches per
+  // exec, so re-filtering as the user types only resolves newly-revealed apps.
+  // Works on both platforms: on Windows `list_installed_apps` returns icon=null
+  // and the resolver extracts the shell icon; on Linux it resolves the theme name.
+  useEffect(() => {
+    let cancelled = false;
+    const execs = filtered
+      .map((a) => a.exec)
+      .filter((exec) => exec && !(exec in iconDataUrls));
+    if (execs.length === 0) return;
+    Promise.all(
+      [...new Set(execs)].map(async (exec) => {
+        try {
+          return [exec, await invoke<string | null>("resolve_app_icon", { exec })] as const;
+        } catch {
+          return [exec, null] as const;
+        }
+      }),
+    ).then((entries) => {
+      if (!cancelled) setIconDataUrls((prev) => ({ ...prev, ...Object.fromEntries(entries) }));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [filtered, iconDataUrls]);
+
   const otherScopeValue = scope === "project" ? globalApps[ext] : undefined;
 
   const chooseExecutable = async () => {
@@ -92,6 +147,13 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
     if (typeof picked === "string") setExec(picked);
   };
 
+  // Select an installed app. Preserve a working multi-word exec when the user
+  // re-selects the same app it already resolves to — clicking KiCad must not
+  // strip the `kicad` binary selector its sharun AppImage needs to open a file.
+  const pickApp = (appExec: string) => {
+    setExec((prev) => (execMatchesApp(prev, appExec) ? prev : appExec));
+  };
+
   const save = async (nextExec: string | null) => {
     setBusy(true);
     setError(null);
@@ -137,7 +199,10 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
               name="default-app-scope"
               checked={scope === "project"}
               disabled={!localFile}
-              onChange={() => setScope("project")}
+              onChange={() => {
+                userPickedScope.current = true;
+                setScope("project");
+              }}
             />
             This project only
           </label>
@@ -146,7 +211,10 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
               type="radio"
               name="default-app-scope"
               checked={scope === "global"}
-              onChange={() => setScope("global")}
+              onChange={() => {
+                userPickedScope.current = true;
+                setScope("global");
+              }}
             />
             Global (all projects)
           </label>
@@ -172,12 +240,19 @@ export function SetDefaultAppDialog({ ext, fileName, localFile, onClose }: Props
               <button
                 type="button"
                 key={`${a.exec}:${a.name}`}
-                className={`set-default-app-row${exec === a.exec ? " selected" : ""}`}
-                onClick={() => setExec(a.exec)}
+                className={`set-default-app-row${execMatchesApp(exec, a.exec) ? " selected" : ""}`}
+                onClick={() => pickApp(a.exec)}
                 title={a.exec}
               >
-                <span className="set-default-app-name">{a.name}</span>
-                <span className="set-default-app-exec">{a.exec}</span>
+                {iconDataUrls[a.exec] ? (
+                  <img className="set-default-app-icon" src={iconDataUrls[a.exec]!} alt="" />
+                ) : (
+                  <span className="set-default-app-icon set-default-app-icon-placeholder" />
+                )}
+                <span className="set-default-app-text">
+                  <span className="set-default-app-name">{a.name}</span>
+                  <span className="set-default-app-exec">{a.exec}</span>
+                </span>
               </button>
             ))
           )}
diff --git a/src/components/files/SubwindowFilesSidebar.tsx b/src/components/files/SubwindowFilesSidebar.tsx
new file mode 100644
index 0000000..f2f0697
--- /dev/null
+++ b/src/components/files/SubwindowFilesSidebar.tsx
@@ -0,0 +1,107 @@
+import { useEffect, useState } from "react";
+import { ProjectFilesTab } from "./ProjectFilesTab";
+
+/** Default/clamp bounds for the per-subwindow file-viewer column (px). */
+export const DEFAULT_GROUP_FILES_WIDTH = 300;
+export const MIN_GROUP_FILES_WIDTH = 200;
+export const MAX_GROUP_FILES_WIDTH = 640;
+
+export function clampFilesWidth(w: number): number {
+  return Math.min(MAX_GROUP_FILES_WIDTH, Math.max(MIN_GROUP_FILES_WIDTH, Math.round(w)));
+}
+
+interface Props {
+  /** The owning scope (project id / "box:<id>" / "root") — identity for the viewer. */
+  scope: string;
+  /** Fallback tree root when the scope has no project (root scope / popout). */
+  cwd: string;
+  /** Persisted column width; unset → DEFAULT_GROUP_FILES_WIDTH. */
+  width?: number;
+  /** Commit a width after a resize drag ends (persisted onto the group node). */
+  onWidthChange: (width: number) => void;
+  /** The folder the viewer last browsed to, persisted on the group node. */
+  folder?: string;
+  /** Persist a folder change onto the group node (main) / stream it (popout). */
+  onFolderChange?: (folder: string) => void;
+  /** Whether this window owns the tab store (main window). Gates "Open in a new tab". */
+  canOpenTabs?: boolean;
+  /** Hide the docked viewer (double-click the resize edge). Same close path the
+   *  ◫ tab-bar button uses. */
+  onHide?: () => void;
+}
+
+/**
+ * The per-subwindow right file viewer (a docked column on a subwindow's right
+ * edge), toggled by the ◫ button in the subwindow's tab bar. The viewer itself
+ * is the SAME `ProjectFilesTab` host the Files (Project) tab renders — and
+ * therefore the same `ProjectFilesView` the right panel renders — so all three
+ * surfaces can never drift apart. This wrapper owns only what a docked column
+ * adds: the fixed width, and the left-edge resize handle.
+ *
+ * Width is LIVE-local during the drag (no store churn per pointer move) and
+ * committed once on release via `onWidthChange` — the main window persists it
+ * onto the group node; a popout streams a `files` edit back to the main window.
+ */
+export function SubwindowFilesSidebar({
+  scope,
+  cwd,
+  width,
+  onWidthChange,
+  folder,
+  onFolderChange,
+  canOpenTabs,
+  onHide,
+}: Props) {
+  const committed = clampFilesWidth(width ?? DEFAULT_GROUP_FILES_WIDTH);
+  // Live width during a resize drag; null when idle (render the committed one).
+  const [liveWidth, setLiveWidth] = useState<number | null>(null);
+
+  // A width persisted elsewhere (another window, restore) wins when idle.
+  useEffect(() => {
+    setLiveWidth(null);
+  }, [committed]);
+
+  const startResize = (e: React.PointerEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    (e.target as HTMLElement).setPointerCapture?.(e.pointerId);
+    const startX = e.clientX;
+    const startW = committed;
+    let last = startW;
+    const onMove = (ev: PointerEvent) => {
+      // The handle sits on the column's LEFT edge: dragging left grows it.
+      last = clampFilesWidth(startW + (startX - ev.clientX));
+      setLiveWidth(last);
+    };
+    const onUp = () => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+      setLiveWidth(null);
+      if (last !== startW) onWidthChange(last);
+    };
+    window.addEventListener("pointermove", onMove);
+    window.addEventListener("pointerup", onUp);
+  };
+
+  return (
+    <div className="subwindow-files" style={{ width: liveWidth ?? committed }}>
+      <div
+        className="subwindow-files-resize"
+        title="Drag to resize · double-click to hide"
+        onPointerDown={startResize}
+        onDoubleClick={onHide}
+      />
+      {/* Compact: the docked column strips the header + view-switcher toolbar +
+          sync/sort rows so the tree's find-files search box sits at the top. */}
+      <ProjectFilesTab
+        scope={scope}
+        cwd={cwd}
+        canOpenTabs={canOpenTabs}
+        folder={folder}
+        persistFolder={onFolderChange}
+        visible
+        compact
+      />
+    </div>
+  );
+}
diff --git a/src/components/files/fileDropContext.ts b/src/components/files/fileDropContext.ts
new file mode 100644
index 0000000..5eb726f
--- /dev/null
+++ b/src/components/files/fileDropContext.ts
@@ -0,0 +1,34 @@
+import { createContext } from "react";
+import type { TabDrag } from "../../stores/drag";
+import type { TabEntry } from "../../stores/tabs";
+
+/**
+ * How a file dragged out of the file tree is resolved and committed — the seam
+ * that lets the SAME `FileTree` gesture work in the main window and inside a
+ * detached popout.
+ *
+ * In the main window this is absent (null): `CenterPanel` owns a window-wide
+ * pointer-drag authority that resolves the pane target and `FileTree` commits
+ * through `commitFileDrop` into the main tab store. A detached window has
+ * neither — it can't reach that authority (its panes are in another webview) nor
+ * mutate the store (the main window owns tab creation + the PTY) — so
+ * `DetachedCenterPanel` provides this controller: `resolveTarget` writes the
+ * hovered pane into the popout's own drag store (so the split/merge preview
+ * lights up), and `commit` streams the drop to the main window as a detached
+ * `add` edit instead of a local store write.
+ */
+export interface FileDropController {
+  /** Resolve the pane under the cursor into the drag store (overGroup/edge or
+   *  reorderGroup/reorderIndex), driving the live split/merge preview. Called on
+   *  every pointer move of a file drag. */
+  resolveTarget: (clientX: number, clientY: number) => void;
+  /** Commit a released file drag against the last resolved target. */
+  commit: (d: TabDrag, projectCwd: string) => void;
+  /** Open a tab INSIDE this popout (its focused group), streamed to the main
+   *  window like the "+" button and file drops. Used by the Python ▶ Run so the
+   *  terminal appears in the detached window, not the main window's tab store. */
+  openTab: (tab: Omit<TabEntry, "key">) => void;
+}
+
+/** Non-null only inside a detached window. See {@link FileDropController}. */
+export const FileDropContext = createContext<FileDropController | null>(null);
diff --git a/src/components/files/fileTabSync.ts b/src/components/files/fileTabSync.ts
new file mode 100644
index 0000000..c1dc7c5
--- /dev/null
+++ b/src/components/files/fileTabSync.ts
@@ -0,0 +1,95 @@
+import { reseedDetached } from "../tabs/detachedDropTargets";
+import { orderedTabKeys, useTabsStore, type TabEntry } from "../../stores/tabs";
+
+/**
+ * Reconcile open file-viewer tabs when a file is deleted, renamed, or moved from
+ * the file tree/browser. A viewer tab (`kind: "embed"`) carries the file's
+ * absolute path in `embedPath`, set once at open time and otherwise never
+ * touched — so without this a delete strands the tab on a gone path and a rename
+ * leaves it (and any subsequent save) pointing at the old name.
+ *
+ * Affected tabs always live in the CURRENT scope: the tree only shows the active
+ * project, so a file being edited belongs to that scope — its in-window layout
+ * and/or its detached popout windows. Popouts are separate JS heaps that render a
+ * streamed seed, so they are updated by re-seeding (or closing) rather than by a
+ * shared store write.
+ */
+
+/**
+ * Keys of every `kind:"embed"` tab (in-app viewer OR external-app embed) whose
+ * file was the target: an exact match, or — for a directory op — a child under
+ * `target + "/"`.
+ */
+function matchedKeys(tabs: TabEntry[], target: string): string[] {
+  return tabs
+    .filter(
+      (t) =>
+        t.kind === "embed" &&
+        !!t.embedPath &&
+        (t.embedPath === target || t.embedPath.startsWith(`${target}/`)),
+    )
+    .map((t) => t.key);
+}
+
+/**
+ * Close every open embed tab whose file — or containing directory — was just
+ * deleted, in the main window AND any detached popout of the current scope.
+ */
+export function closeTabsForDeletedPath(absPath: string): void {
+  const store = useTabsStore.getState();
+  const scope = store.scope;
+  const affected = new Set(matchedKeys(store.tabsByScope[scope] ?? [], absPath));
+  if (affected.size === 0) return;
+
+  const detached = store.detachedGroupsByScope[scope] ?? [];
+
+  // 1. Detached popouts: a group whose ENTIRE tab set is deleted is torn down
+  //    (its OS window closes); otherwise drop the matched tabs and re-seed the
+  //    popout so it re-renders without them.
+  for (const g of detached) {
+    const groupKeys = orderedTabKeys(g.subtree);
+    const doomed = groupKeys.filter((k) => affected.has(k));
+    if (doomed.length === 0) continue;
+    if (doomed.length === groupKeys.length) {
+      store.closeDetachedGroup(scope, g.id);
+    } else {
+      for (const key of doomed) {
+        store.applyDetachedEdit(scope, g.id, { kind: "close", key });
+      }
+      reseedDetached(scope, g.id);
+    }
+  }
+
+  // 2. Live-layout tabs: removeTab collapses emptied groups/splits and kills any
+  //    PTY. Detached keys were handled above, so skip them here — removeTab would
+  //    drop the payload without repairing the detached subtree.
+  const detachedKeys = new Set(detached.flatMap((g) => orderedTabKeys(g.subtree)));
+  for (const key of affected) {
+    if (detachedKeys.has(key)) continue;
+    store.removeTab(key);
+  }
+}
+
+/**
+ * Retarget every open embed tab whose file — or containing directory — was just
+ * renamed/moved from `oldAbs` to `newAbs`, in the main window AND any detached
+ * popout of the current scope.
+ */
+export function retargetTabsForRenamedPath(oldAbs: string, newAbs: string): void {
+  const store = useTabsStore.getState();
+  const scope = store.scope;
+  const affected = new Set(matchedKeys(store.tabsByScope[scope] ?? [], oldAbs));
+  if (affected.size === 0) return;
+
+  // Rewrite the payloads (embedPath + label) in the store: this re-renders the
+  // main window's panes and updates what a re-seed ships to popouts.
+  store.retargetTabs(oldAbs, newAbs);
+
+  // Re-seed any detached popout rendering a retargeted tab so it picks up the new
+  // embedPath (its subtree keys are unchanged, so only the payload moved).
+  for (const g of store.detachedGroupsByScope[scope] ?? []) {
+    if (orderedTabKeys(g.subtree).some((k) => affected.has(k))) {
+      reseedDetached(scope, g.id);
+    }
+  }
+}
diff --git a/src/components/files/importDrop.tsx b/src/components/files/importDrop.tsx
new file mode 100644
index 0000000..53351b5
--- /dev/null
+++ b/src/components/files/importDrop.tsx
@@ -0,0 +1,255 @@
+import { useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { open as openDialog } from "@tauri-apps/plugin-dialog";
+import { Toggle } from "../common/Toggle";
+import { basename, fromFileUri } from "../../lib/paths";
+
+/**
+ * Importing OS files into a project by dropping them onto a file view — shared
+ * by the right panel and the "Files (Project)" tab, which must import
+ * identically (same collision prompt, same destination folder rule).
+ */
+
+type ConflictChoice = "replace" | "rename" | "skip";
+
+/** Heuristic: is this drag an external OS file drag (vs. an internal pill/text
+ *  drag)? `dragDropEnabled` stays false so HTML5 DnD keeps working for the
+ *  app's pointer/HTML drags; an OS file drag advertises Files/uri-list/html
+ *  (WebKitGTK uses text/html here). During dragover WebKit may hide the type
+ *  list, so an empty list is treated as a file drag too. */
+export function isExternalFileDrag(dt: DataTransfer): boolean {
+  const types = Array.from(dt.types ?? []);
+  if (types.length === 0) return true;
+  return (
+    types.includes("Files") ||
+    types.includes("text/uri-list") ||
+    types.includes("text/html")
+  );
+}
+
+/** Extract absolute local paths from an OS HTML5 file drop. WebKitGTK withholds
+ *  `Files`/`text/uri-list` data here but leaks the `file://` URL inside
+ *  `text/html`, so scan every text payload for `file://` URIs and dedupe.
+ *  NOTE: this drag path is best-effort — some file managers only expose ONE
+ *  file this way. Use the Import button for reliable multi-file selection. */
+export function parseDroppedFilePaths(dataTransfer: DataTransfer): string[] {
+  const sources = [
+    dataTransfer.getData("text/uri-list"),
+    dataTransfer.getData("text/plain"),
+    dataTransfer.getData("text/html"),
+  ];
+  const FILE_URI = /file:\/\/[^\s"'<>]+/g;
+  const seen = new Set<string>();
+  const paths: string[] = [];
+  for (const raw of sources) {
+    if (!raw) continue;
+    for (const match of raw.match(FILE_URI) ?? []) {
+      const p = fromFileUri(match);
+      if (p && !seen.has(p)) {
+        seen.add(p);
+        paths.push(p);
+      }
+    }
+  }
+  return paths;
+}
+
+interface Options {
+  /** Destination project root. Empty disables the drop. */
+  projectDir: string;
+  /** False for a box scope: several roots, so no single destination. */
+  enabled: boolean;
+  /** Project-relative folder the files land in, read at drop time. */
+  destRel: string;
+  /** Fired once the whole batch has been copied (e.g. to refresh git). */
+  onImported?: () => void;
+}
+
+/**
+ * OS file drop → copy into the project, prompting on name collisions. Returns
+ * the drag handlers to spread onto the drop zone, the classes that paint it,
+ * the conflict modal to render, and the file-picker fallback (WebKitGTK only
+ * leaks one path per drag, so the picker is the reliable multi-file route).
+ */
+export function useImportDrop({ projectDir, enabled, destRel, onImported }: Options) {
+  const [dropActive, setDropActive] = useState(false);
+  const [dropFlash, setDropFlash] = useState(false);
+  const [conflict, setConflict] = useState<
+    { name: string; remaining: number; resolve: (r: { choice: ConflictChoice; all: boolean }) => void } | null
+  >(null);
+  const [conflictAll, setConflictAll] = useState(false);
+  const dropFlashTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const canImport = enabled && !!projectDir;
+
+  // The import runs asynchronously across a batch, so read the destination and
+  // the completion callback from refs — a folder change mid-import must not
+  // strand the loop on a stale closure.
+  const destRelRef = useRef(destRel);
+  destRelRef.current = destRel;
+  const onImportedRef = useRef(onImported);
+  onImportedRef.current = onImported;
+
+  useEffect(() => {
+    return () => {
+      if (dropFlashTimer.current) clearTimeout(dropFlashTimer.current);
+    };
+  }, []);
+
+  const flashDrop = () => {
+    if (dropFlashTimer.current) clearTimeout(dropFlashTimer.current);
+    setDropFlash(false);
+    requestAnimationFrame(() => setDropFlash(true));
+    dropFlashTimer.current = setTimeout(() => setDropFlash(false), 500);
+  };
+
+  // Ask the user how to resolve a name collision; resolves via the modal's
+  // buttons. Returns the choice plus whether to apply it to all remaining.
+  const askConflict = (name: string, remaining: number) =>
+    new Promise<{ choice: ConflictChoice; all: boolean }>((resolve) => {
+      setConflictAll(false);
+      setConflict({ name, remaining, resolve });
+    });
+
+  // Copy each absolute source path into the project, prompting on collisions.
+  const importPaths = (paths: string[]) => {
+    if (!canImport || !projectDir || paths.length === 0) return;
+    flashDrop();
+    const destRelAtDrop = destRelRef.current;
+    void (async () => {
+      let blanket: ConflictChoice | null = null;
+      for (let i = 0; i < paths.length; i++) {
+        const sourcePath = paths[i];
+        const name = basename(sourcePath) || sourcePath;
+        const rel = destRelAtDrop ? `${destRelAtDrop}/${name}` : name;
+        let choice: ConflictChoice = "rename";
+        const exists = await invoke<boolean>("project_path_exists", { projectDir, relPath: rel }).catch(() => false);
+        if (exists) {
+          if (blanket) {
+            choice = blanket;
+          } else {
+            const res = await askConflict(name, paths.length - 1 - i);
+            setConflict(null);
+            choice = res.choice;
+            if (res.all) blanket = res.choice;
+          }
+        }
+        if (choice === "skip") continue;
+        try {
+          await invoke("import_external_file", {
+            projectDir,
+            sourcePath,
+            destRel: destRelAtDrop,
+            replace: choice === "replace",
+          });
+        } catch (err) {
+          console.error("import_external_file", sourcePath, err);
+        }
+      }
+      // The tree auto-reloads via its fs-watch; the host may still want to
+      // refresh anything derived from the files (e.g. git status counts).
+      onImportedRef.current?.();
+    })();
+  };
+
+  // HTML5 drag-and-drop (dragDropEnabled stays false so pointer drags — tabs,
+  // splits, pills — keep working). Best-effort: WebKitGTK only leaks file paths
+  // via text/html and sometimes just one; the Import button is the reliable
+  // multi-file path.
+  const onDragOver = (e: React.DragEvent) => {
+    if (!canImport || !isExternalFileDrag(e.dataTransfer)) return;
+    e.preventDefault();
+    e.dataTransfer.dropEffect = "copy";
+    if (!dropActive) setDropActive(true);
+  };
+
+  const onDragLeave = (e: React.DragEvent) => {
+    if (e.currentTarget.contains(e.relatedTarget as Node)) return;
+    setDropActive(false);
+  };
+
+  const onDrop = (e: React.DragEvent) => {
+    setDropActive(false);
+    if (!canImport || !isExternalFileDrag(e.dataTransfer)) return;
+    e.preventDefault();
+    importPaths(parseDroppedFilePaths(e.dataTransfer));
+  };
+
+  // Reliable multi-file import: native OS file picker → same copy+conflict flow.
+  const importViaDialog = async () => {
+    if (!canImport) return;
+    const picked = await openDialog({ multiple: true, directory: false }).catch(() => null);
+    if (!picked) return;
+    importPaths(Array.isArray(picked) ? picked : [picked]);
+  };
+
+  // Same flow, but for whole folders: the backend's copy already recurses
+  // (`import_external_file` → `copy_recursive`), so this is just a directory
+  // picker feeding the same importPaths pipeline.
+  const importFolderViaDialog = async () => {
+    if (!canImport) return;
+    const picked = await openDialog({ multiple: true, directory: true }).catch(() => null);
+    if (!picked) return;
+    importPaths(Array.isArray(picked) ? picked : [picked]);
+  };
+
+  const conflictModal = conflict
+    ? createPortal(
+        <div
+          className="modal-backdrop"
+          onMouseDown={() => conflict.resolve({ choice: "skip", all: conflictAll })}
+        >
+          <div className="settings-dialog" style={{ maxWidth: 380 }} onMouseDown={(e) => e.stopPropagation()}>
+            <div className="settings-title-row">
+              <h2>File already exists</h2>
+            </div>
+            <p className="settings-help" style={{ wordBreak: "break-all" }}>
+              <code>{conflict.name}</code> already exists in this folder. Replace it, or keep both (the new copy is renamed)?
+            </p>
+            {conflict.remaining > 0 && (
+              <label className="viewer-pref-toggle" style={{ marginBottom: 8 }}>
+                <Toggle
+                  size="sm"
+                  checked={conflictAll}
+                  onChange={(e) => setConflictAll(e.target.checked)}
+                />
+                <span>Apply to the {conflict.remaining} remaining file{conflict.remaining > 1 ? "s" : ""}</span>
+              </label>
+            )}
+            <div style={{ display: "flex", gap: 6, justifyContent: "flex-end" }}>
+              <button className="tab-add-btn" onClick={() => conflict.resolve({ choice: "skip", all: conflictAll })}>
+                Skip
+              </button>
+              <button className="tab-add-btn" onClick={() => conflict.resolve({ choice: "rename", all: conflictAll })}>
+                Keep both
+              </button>
+              <button
+                className="tab-add-btn"
+                style={{ color: "var(--danger, #f85149)" }}
+                onClick={() => conflict.resolve({ choice: "replace", all: conflictAll })}
+              >
+                Replace
+              </button>
+            </div>
+          </div>
+        </div>,
+        document.body,
+      )
+    : null;
+
+  return {
+    canImport,
+    dropActive,
+    dropFlash,
+    importViaDialog,
+    importFolderViaDialog,
+    conflictModal,
+    handlers: {
+      onDragEnter: onDragOver,
+      onDragOver,
+      onDragLeave,
+      onDrop,
+    },
+  };
+}
diff --git a/src/components/files/openFileEntry.ts b/src/components/files/openFileEntry.ts
new file mode 100644
index 0000000..de18d7a
--- /dev/null
+++ b/src/components/files/openFileEntry.ts
@@ -0,0 +1,75 @@
+import {
+  internalViewerFor,
+  type FileEntry,
+  type InternalViewer,
+} from "../../lib/viewers/fileUtils";
+import { useTabsStore, type TabEntry } from "../../stores/tabs";
+import { useWindowsStore } from "../../stores/windows";
+
+/**
+ * The single open-a-file policy shared by every file listing (the FileTree in
+ * the right panel / subwindow sidebar / Files tab, and the FileBrowser). It is
+ * the seam that makes a double-click mean the same thing everywhere:
+ *
+ *  - A file with a **native in-app viewer** (`internalViewerFor`) opens as an
+ *    embed tab in the project's **focused subwindow** — reusing an already-open
+ *    viewer tab for that exact file rather than stacking duplicates. In a
+ *    detached popout the caller passes `placeTab` so the tab streams into that
+ *    window (like the Python ▶ Run) instead of the main window's tab store.
+ *  - A file with **no native viewer**, or an explicit `external` open
+ *    (Shift+double-click), opens in the OS default app via `open_file`.
+ *
+ * `disabled` honours the per-type viewer opt-out (#48); omit it to treat every
+ * viewer as enabled.
+ */
+export function openFileEntry(opts: {
+  entry: FileEntry;
+  /** Project root, used as the embed tab's cwd. */
+  projectDir: string;
+  /** Owning project id, forwarded to `open_file` for window tracking. */
+  projectId: string | null;
+  /** Telemetry origin passed to `open_file` (e.g. "right_file_tree"). */
+  origin: string;
+  /** Force the OS-default-app path regardless of any native viewer (Shift). */
+  external: boolean;
+  /** Native viewers the user opted out of (#48); omit = all enabled. */
+  disabled?: ReadonlySet<InternalViewer>;
+  /** Detached-popout placement override: stream the tab into that window
+   *  instead of writing the (non-authoritative) local tab store. */
+  placeTab?: (tab: Omit<TabEntry, "key">) => void;
+}): void {
+  const { entry, projectDir, projectId, origin, external, disabled, placeTab } = opts;
+  if (entry.is_dir) return;
+
+  const viewer = internalViewerFor(entry, disabled);
+  if (external || !viewer) {
+    useWindowsStore
+      .getState()
+      .openFile(entry.path, undefined, projectId, origin)
+      .catch((e) => console.error(e));
+    return;
+  }
+
+  const tab: Omit<TabEntry, "key"> = {
+    label: entry.name,
+    cmd: "",
+    cwd: projectDir,
+    kind: "embed",
+    embedPath: entry.path,
+    viewer,
+  };
+
+  if (placeTab) {
+    placeTab(tab);
+    return;
+  }
+
+  // Main window: focus an existing viewer tab for this exact file if one is
+  // open (same path + viewer), else add a fresh one to the focused subwindow.
+  const store = useTabsStore.getState();
+  const prior = store.tabs.find(
+    (t) => t.kind === "embed" && t.viewer === viewer && t.embedPath === entry.path,
+  );
+  if (prior) store.setActive(prior.key);
+  else store.addTab(tab);
+}
diff --git a/src/components/header/AppResourceDisplay.tsx b/src/components/header/AppResourceDisplay.tsx
index 3e02dad..6ee6d8d 100644
--- a/src/components/header/AppResourceDisplay.tsx
+++ b/src/components/header/AppResourceDisplay.tsx
@@ -1,21 +1,30 @@
 import { useEffect, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
 import { useSettingsStore } from "../../stores/settings";
+import { useEnergySaver, saverInterval } from "../../stores/power";
+import {
+  formatBytes,
+  gpuBusy,
+  gpuTone,
+  gpuTooltip,
+  gpuTotals,
+  type GpuSample,
+} from "../../lib/gpu";
+import { useT } from "../../lib/i18n";
 
 interface AppResourceUsage {
   cpu_percent: number;
   rss_bytes: number;
   process_count: number;
-}
-
-function formatBytes(bytes: number): string {
-  if (!Number.isFinite(bytes) || bytes <= 0) return "0 MB";
-  const mib = bytes / 1024 / 1024;
-  if (mib < 1024) return `${Math.round(mib)} MB`;
-  return `${(mib / 1024).toFixed(1)} GB`;
+  /** Ollama's *share* of the GPU: 0 when no model is resident. */
+  vram_bytes: number;
+  /** Every GPU in the machine; empty when none can be read (see `lib/gpu`). */
+  gpus: GpuSample[];
 }
 
 function usageTone(kind: "cpu" | "ram", value: number): "low" | "medium" | "high" {
+  // CPU is a percentage; RAM is a byte count with its own thresholds. The GPU
+  // row tones by ratio instead (`gpuTone`) — its figure is the whole device's.
   const warn = kind === "cpu" ? 35 : 1024 * 1024 * 1024;
   const hot = kind === "cpu" ? 75 : 2 * 1024 * 1024 * 1024;
   if (value >= hot) return "high";
@@ -24,11 +33,17 @@ function usageTone(kind: "cpu" | "ram", value: number): "low" | "medium" | "high
 }
 
 export function AppResourceDisplay() {
-  const debug = useSettingsStore((s) => s.settings?.debug ?? false);
+  const t = useT();
+  // Each row defaults ON (undefined → shown) and is independent of debug mode.
+  const showCpu = useSettingsStore((s) => s.settings?.show_cpu_usage ?? true);
+  const showRam = useSettingsStore((s) => s.settings?.show_ram_usage ?? true);
+  const showGpu = useSettingsStore((s) => s.settings?.show_gpu_usage ?? true);
+  const anyShown = showCpu || showRam || showGpu;
   const [usage, setUsage] = useState<AppResourceUsage | null>(null);
+  const energySaver = useEnergySaver();
 
   useEffect(() => {
-    if (!import.meta.env.DEV || !debug) {
+    if (!anyShown) {
       setUsage(null);
       return;
     }
@@ -45,25 +60,75 @@ export function AppResourceDisplay() {
     };
 
     poll();
-    const id = window.setInterval(poll, 2_500);
+    const id = window.setInterval(poll, saverInterval(2_500, energySaver));
     return () => {
       cancelled = true;
       window.clearInterval(id);
     };
-  }, [debug]);
+  }, [anyShown, energySaver]);
 
-  if (!import.meta.env.DEV || !debug || !usage) return null;
+  if (!anyShown || !usage) return null;
 
   return (
-    <div className="app-resource-display" title={`${usage.process_count} Eldrun/dev processes`}>
-      <span className={`app-resource-row ${usageTone("cpu", usage.cpu_percent)}`} title="CPU">
-        <span className="app-resource-symbol" aria-hidden>CPU</span>
-        <span>{usage.cpu_percent.toFixed(1)}%</span>
+    <div
+      className="app-resource-display"
+      title={t(
+        usage.process_count === 1 ? "appResource.processCountOne" : "appResource.processCountMany",
+        { count: usage.process_count },
+      )}
+    >
+      {showCpu && (
+        <span className={`app-resource-row ${usageTone("cpu", usage.cpu_percent)}`} title="CPU">
+          <span className="app-resource-symbol" aria-hidden>CPU</span>
+          <span>{usage.cpu_percent.toFixed(1)}%</span>
+        </span>
+      )}
+      {showRam && (
+        <span className={`app-resource-row ${usageTone("ram", usage.rss_bytes)}`} title="RAM">
+          <span className="app-resource-symbol" aria-hidden>RAM</span>
+          <span>{formatBytes(usage.rss_bytes)}</span>
+        </span>
+      )}
+      {showGpu && <GpuRow gpus={usage.gpus} ollamaBytes={usage.vram_bytes} />}
+    </div>
+  );
+}
+
+/**
+ * The whole device's memory (both pools, every adapter) plus its utilization —
+ * not just what Ollama holds, which is what this row used to show and now shows
+ * as one line of its tooltip.
+ */
+function GpuRow({ gpus, ollamaBytes }: { gpus: GpuSample[]; ollamaBytes: number }) {
+  const t = useT();
+  // No GPU we can read (macOS, an Intel-only box, no `nvidia-smi`): fall back to
+  // exactly what this row did before — Ollama's models, and "—" when none are
+  // loaded. Better a narrow reading than a zero pretending to be a measurement.
+  if (gpus.length === 0) {
+    return (
+      <span
+        className={`app-resource-row ${usageTone("ram", ollamaBytes)}`}
+        title={t("appResource.gpuNoDeviceTitle")}
+      >
+        <span className="app-resource-symbol" aria-hidden>GPU</span>
+        <span>{ollamaBytes > 0 ? formatBytes(ollamaBytes) : "—"}</span>
       </span>
-      <span className={`app-resource-row ${usageTone("ram", usage.rss_bytes)}`} title="RAM">
-        <span className="app-resource-symbol" aria-hidden>RAM</span>
-        <span>{formatBytes(usage.rss_bytes)}</span>
+    );
+  }
+
+  const { used, total } = gpuTotals(gpus);
+  const busy = gpuBusy(gpus);
+
+  return (
+    <span
+      className={`app-resource-row ${gpuTone(used, total)}`}
+      title={gpuTooltip(gpus, ollamaBytes)}
+    >
+      <span className="app-resource-symbol" aria-hidden>GPU</span>
+      <span>
+        {busy != null ? `${Math.round(busy)}% · ` : ""}
+        {formatBytes(used)} / {formatBytes(total)}
       </span>
-    </div>
+    </span>
   );
 }
diff --git a/src/components/header/AppTimerDisplay.tsx b/src/components/header/AppTimerDisplay.tsx
index c87267c..93ddddc 100644
--- a/src/components/header/AppTimerDisplay.tsx
+++ b/src/components/header/AppTimerDisplay.tsx
@@ -2,10 +2,12 @@ import { useEffect, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
 import { createPortal } from "react-dom";
 import { useTimerStore } from "../../stores/timer";
+import { useEnergySaver, saverInterval } from "../../stores/power";
 import { ActivityCalendar } from "../projects/ActivityCalendar";
+import { useT, type TranslationKey } from "../../lib/i18n";
 
-function formatTime(secs: number): string {
-  if (secs < 60) return "< 1m";
+function formatTime(t: (key: TranslationKey) => string, secs: number): string {
+  if (secs < 60) return t("projectHoverCard.timeUnderMinute");
   const h = Math.floor(secs / 3600);
   const m = Math.floor((secs % 3600) / 60);
   if (h > 0) return `${h}h ${m}m`;
@@ -13,6 +15,7 @@ function formatTime(secs: number): string {
 }
 
 function GlobalActivityWindow({ onClose }: { onClose: () => void }) {
+  const t = useT();
   const [data, setData] = useState<Record<string, number>>({});
   const [loading, setLoading] = useState(true);
 
@@ -27,12 +30,12 @@ function GlobalActivityWindow({ onClose }: { onClose: () => void }) {
     <div className="modal-backdrop" onMouseDown={onClose}>
       <div className="activity-window" onMouseDown={(e) => e.stopPropagation()}>
         <div className="activity-window-header">
-          <span className="activity-window-title">Global Activity</span>
+          <span className="activity-window-title">{t("appTimer.globalActivityTitle")}</span>
           <button className="dialog-close-btn" onClick={onClose}>×</button>
         </div>
         <div className="activity-window-body">
           {loading ? (
-            <div className="activity-loading">Loading…</div>
+            <div className="activity-loading">{t("common.loading")}</div>
           ) : (
             <ActivityCalendar data={data} />
           )}
@@ -44,26 +47,28 @@ function GlobalActivityWindow({ onClose }: { onClose: () => void }) {
 }
 
 export function AppTimerDisplay() {
+  const t = useT();
   const paused = useTimerStore((s) => s.paused);
   const toggle = useTimerStore((s) => s.toggle);
-  const [displayText, setDisplayText] = useState("< 1m");
+  const [displayText, setDisplayText] = useState(t("projectHoverCard.timeUnderMinute"));
   const [showActivity, setShowActivity] = useState(false);
+  const energySaver = useEnergySaver();
 
   useEffect(() => {
     const update = () => {
-      setDisplayText(formatTime(useTimerStore.getState().getAppSecs()));
+      setDisplayText(formatTime(t, useTimerStore.getState().getAppSecs()));
     };
     update();
     if (paused) return;
-    const id = setInterval(update, 1000);
+    const id = setInterval(update, saverInterval(1000, energySaver));
     return () => clearInterval(id);
-  }, [paused]);
+  }, [paused, energySaver, t]);
 
   return (
     <>
       <button
         className={`app-timer-btn${paused ? " paused" : ""}`}
-        title={`Today: ${displayText}${paused ? "\nPaused — click to resume" : "\nClick to pause • Right-click for activity"}`}
+        title={`${t("projectHoverCard.todayPrefix")} ${displayText}\n${paused ? t("appTimer.pausedResumeHint") : t("appTimer.clickPauseHint")}`}
         onClick={() => void toggle()}
         onContextMenu={(e) => {
           e.preventDefault();
diff --git a/src/components/header/Clock.tsx b/src/components/header/Clock.tsx
index 6b1b9bc..39bd354 100644
--- a/src/components/header/Clock.tsx
+++ b/src/components/header/Clock.tsx
@@ -1,4 +1,6 @@
 import { useEffect, useState } from "react";
+import { useEnergySaver, saverInterval } from "../../stores/power";
+import { useSettingsStore } from "../../stores/settings";
 
 function fmt(n: number) {
   return String(n).padStart(2, "0");
@@ -6,15 +8,17 @@ function fmt(n: number) {
 
 export function Clock() {
   const [time, setTime] = useState(() => new Date());
+  const energySaver = useEnergySaver();
+  const showSeconds = useSettingsStore((s) => s.settings?.show_clock_seconds ?? false);
 
   useEffect(() => {
-    const id = setInterval(() => setTime(new Date()), 1000);
+    const id = setInterval(() => setTime(new Date()), saverInterval(1000, energySaver));
     return () => clearInterval(id);
-  }, []);
+  }, [energySaver]);
 
   const h = fmt(time.getHours());
   const m = fmt(time.getMinutes());
   const s = fmt(time.getSeconds());
 
-  return <span className="header-clock">{h}:{m}:{s}</span>;
+  return <span className="header-clock">{h}:{m}{showSeconds ? `:${s}` : ""}</span>;
 }
diff --git a/src/components/header/ConnTypeIcon.tsx b/src/components/header/ConnTypeIcon.tsx
index 923be76..53ce490 100644
--- a/src/components/header/ConnTypeIcon.tsx
+++ b/src/components/header/ConnTypeIcon.tsx
@@ -1,17 +1,31 @@
+import { useT } from "../../lib/i18n";
+
 interface Props {
   type: "lan" | "wlan";
+  online: boolean;
 }
 
-export function ConnTypeIcon({ type }: Props) {
+export function ConnTypeIcon({ type, online }: Props) {
+  const t = useT();
+  const label = `${type === "wlan" ? "WiFi" : "Ethernet"}${online ? "" : t("connTypeIcon.offlineSuffix")}`;
+  // When offline, draw a diagonal slash over the connection symbol.
+  const slash = !online && (
+    <>
+      <line x1="2.5" y1="2.5" x2="13.5" y2="13.5" stroke="var(--bg)" strokeWidth="2.6" strokeLinecap="round" />
+      <line x1="2.5" y1="2.5" x2="13.5" y2="13.5" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />
+    </>
+  );
+
   if (type === "wlan") {
     return (
       <svg
-        className="conn-type-icon"
+        className={`conn-type-icon${online ? "" : " conn-offline"}`}
         viewBox="0 0 16 16"
         fill="none"
         xmlns="http://www.w3.org/2000/svg"
-        aria-label="WiFi"
+        aria-label={label}
       >
+        <title>{label}</title>
         {/* outer arc */}
         <path d="M1.5 6.5 C3.5 4 6.5 2.5 8 2.5 C9.5 2.5 12.5 4 14.5 6.5" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" fill="none"/>
         {/* middle arc */}
@@ -20,18 +34,20 @@ export function ConnTypeIcon({ type }: Props) {
         <path d="M5.5 10.5 C6.5 9.5 7.2 9 8 9 C8.8 9 9.5 9.5 10.5 10.5" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" fill="none"/>
         {/* dot */}
         <circle cx="8" cy="13" r="1" fill="currentColor"/>
+        {slash}
       </svg>
     );
   }
 
   return (
     <svg
-      className="conn-type-icon"
+      className={`conn-type-icon${online ? "" : " conn-offline"}`}
       viewBox="0 0 16 16"
       fill="none"
       xmlns="http://www.w3.org/2000/svg"
-      aria-label="Ethernet"
+      aria-label={label}
     >
+      <title>{label}</title>
       {/* plug body */}
       <rect x="5" y="2" width="6" height="5" rx="1" stroke="currentColor" strokeWidth="1.3" fill="none"/>
       {/* pins */}
@@ -45,6 +61,7 @@ export function ConnTypeIcon({ type }: Props) {
       <line x1="5.5" y1="10" x2="5.5" y2="13" stroke="currentColor" strokeWidth="1.3" strokeLinecap="round"/>
       <line x1="8" y1="10" x2="8" y2="13" stroke="currentColor" strokeWidth="1.3" strokeLinecap="round"/>
       <line x1="10.5" y1="10" x2="10.5" y2="13" stroke="currentColor" strokeWidth="1.3" strokeLinecap="round"/>
+      {slash}
     </svg>
   );
 }
diff --git a/src/components/header/MachinesIndicator.tsx b/src/components/header/MachinesIndicator.tsx
new file mode 100644
index 0000000..92db823
--- /dev/null
+++ b/src/components/header/MachinesIndicator.tsx
@@ -0,0 +1,2103 @@
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { open as openDialog, save as saveDialog } from "@tauri-apps/plugin-dialog";
+import { ConnLamp } from "../common/ConnLamp";
+import { Toggle } from "../common/Toggle";
+import { PasswordInput } from "../common/PasswordInput";
+import { UntestedTag } from "../common/UntestedTag";
+import { useGlobalMachinesStore, type ImportResult } from "../../stores/globalMachines";
+import { useGlobalMachineMonitorStore } from "../../stores/globalMachineMonitor";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { useRemoteUsageStore } from "../../stores/remoteUsage";
+import { useHostBusyStore, busyReading, busyLabel } from "../../stores/hostBusy";
+import { parseSshAddress } from "../projects/scaffold";
+import { TerminalSignInToggle } from "../projects/TerminalSignInToggle";
+import { openConnectionInRoot } from "../../lib/remoteConnect";
+import { isHpcHost, mayAutoTouch, setHpcPatch, targetOfSpec } from "../../lib/hpcHost";
+import { hpcGuardRefusal } from "../../lib/hpcGuard";
+import { useT, type TranslationKey } from "../../lib/i18n";
+import type { ConnState } from "../../stores/remoteStatus";
+import type { GlobalMachine, MachineImportEntry, ProjectEntry } from "../../types";
+
+/**
+ * **What a row actually knows**, from the two maps that used to be one.
+ *
+ * `status` means "a session THIS app opened" and nothing else; `reachable` is the
+ * last probe's answer, and a probe is not a session (see `stores/globalMachines`).
+ * Folding them together is what painted a merely-reachable host green — and, the
+ * dangerous direction, what would now leave a machine whose session died sitting
+ * on a green lamp forever, because no sweep writes `status` any more. So a row
+ * reads both, and says which of the two it is looking at.
+ */
+type RowState =
+  /** A session is open and the last probe (if any) agrees. */
+  | "connected"
+  /** A session is open but the host did not answer the last probe — the one case
+   *  nothing else in the app will catch, and the reason this type exists. */
+  | "stale"
+  | "connecting"
+  /** The last *connect* attempt failed (`errors[id]` says how). */
+  | "error"
+  /** No session, but the host answered — deliberately NOT green: "you could
+   *  connect", not "you are connected". */
+  | "reachable"
+  | "unreachable"
+  /** Never probed — a fresh machine, or one tagged HPC, which no sweep touches. */
+  | "unknown";
+
+/** The honest read of one machine. `reachable === undefined` means "nobody has
+ *  asked", which is a third answer, not a quiet "no". */
+export function rowStateOf(status: ConnState, reachable: boolean | undefined): RowState {
+  if (status === "connecting") return "connecting";
+  if (status === "connected") return reachable === false ? "stale" : "connected";
+  if (status === "error") return "error";
+  return reachable === true ? "reachable" : reachable === false ? "unreachable" : "unknown";
+}
+
+/** Which of `ConnLamp`'s four colours a row state paints. Three states share the
+ *  grey dot — none of them is a session, which is the only thing green may mean —
+ *  and the badge beside it (`STATE_BADGE`) is what tells them apart. */
+const STATE_LAMP: Record<RowState, ConnState> = {
+  connected: "connected",
+  stale: "error",
+  connecting: "connecting",
+  error: "error",
+  reachable: "off",
+  unreachable: "off",
+  unknown: "off",
+};
+
+/** The aggregate strip stays a fixed, tiny budget of dots: one per *colour*
+ *  present, not one per state, so a seven-state model can't grow the header of a
+ *  seventeen-machine fleet into a dashboard. The breakdown lives in the tooltip,
+ *  where a count per state costs nothing. Most-relevant colour first, as before. */
+const LAMP_BUCKETS: { lamp: ConnState; states: RowState[] }[] = [
+  { lamp: "error", states: ["error", "stale"] },
+  { lamp: "connecting", states: ["connecting"] },
+  { lamp: "connected", states: ["connected"] },
+  { lamp: "off", states: ["reachable", "unreachable", "unknown"] },
+];
+
+/** The states `ConnLamp`'s own tooltip already spells out — it prints
+ *  "<label>: <colour>", which is only the whole truth when the colour and the
+ *  state are the same word. The other four put the word in the label instead. */
+const LAMP_SAYS_IT = new Set<RowState>(["connected", "connecting", "error"]);
+
+/** One word per state, for the aggregate tooltip's "3 connected — a, b, c". */
+const STATE_WORD: Record<RowState, TranslationKey> = {
+  connected: "machines.state.connected",
+  stale: "machines.state.stale",
+  connecting: "machines.state.connecting",
+  error: "machines.state.error",
+  reachable: "machines.state.reachable",
+  unreachable: "machines.state.unreachable",
+  unknown: "machines.state.unknown",
+};
+
+/** The terse pill on the row. Only for states the lamp cannot say by itself —
+ *  a green lamp already means "connected", so that row carries no pill and a
+ *  long list stays scannable. */
+const STATE_BADGE: Partial<Record<RowState, TranslationKey>> = {
+  stale: "machines.badge.stale",
+  reachable: "machines.badge.reachable",
+  unreachable: "machines.badge.unreachable",
+  unknown: "machines.badge.unknown",
+};
+
+/** The sentence behind each state, on the row's hover. */
+const STATE_TIP: Record<RowState, TranslationKey> = {
+  connected: "machines.tip.connected",
+  stale: "machines.tip.stale",
+  connecting: "machines.tip.connecting",
+  error: "machines.tip.error",
+  reachable: "machines.tip.reachable",
+  unreachable: "machines.tip.unreachable",
+  unknown: "machines.tip.unknown",
+};
+
+/** How long a probe answer is worth reusing. The sweep runs when this menu
+ *  opens, and opening a menu twice in a minute is a glance, not a question —
+ *  `ssh_probe` is a full authenticated login per host, so a fleet of seventeen
+ *  would otherwise pay seventeen logins for each of them. */
+const PROBE_MIN_INTERVAL_MS = 60_000;
+
+export function targetLabel(m: { user?: string; host: string; port?: number }): string {
+  return `${m.user ? `${m.user}@` : ""}${m.host}${m.port ? `:${m.port}` : ""}`;
+}
+
+/**
+ * Global worker machines, in the header — the VPN indicator's pattern applied
+ * to SSH hosts a project doesn't own. Authenticated once via the ordinary
+ * login mechanism, with no project/path attached, then handed to a project from
+ * a row's "add to a project" picker: a remote project gains a `shared_fs`
+ * compute host, a local one is offered "Extend to remote" with that machine as
+ * its primary — deliberately a menu, not a drag: a machine's target lives
+ * outside this list, and no drag can reach it (see below). Rows DO reorder by
+ * dragging their grip, but on POINTER events, which is the difference that
+ * makes it work — a native HTML5 drag out of a pop-up menu is unworkable under
+ * WebKitGTK (the menu closes or hangs mid-drag, and a drop that misses its
+ * target never fires, stranding the row in its dimmed drag state).
+ * Detaching a machine from a project never touches this list — see
+ * `stores/globalMachines.ts` / `commands::global_machines`.
+ *
+ * **It opens on a click, and it is not a hover menu.** Opening it sweeps the
+ * fleet, and `ssh_probe` is a full authenticated SSH login per host, not a ping —
+ * on hover, a pointer crossing the header on its way elsewhere logged Eldrun into
+ * every machine in the list, a login node included. The sweep is now behind a
+ * deliberate open, an in-flight guard and a per-machine minimum interval, and it
+ * never touches a machine tagged HPC at all (`lib/hpcHost`'s `mayAutoTouch`) —
+ * such a row carries its own Check (◎) and login buttons instead, the only things
+ * that ever reach it.
+ *
+ * **A row reads two maps, not one** (see `RowState`): `status` is a session THIS
+ * app opened, `reachable` is the last probe's answer. Green means the first;
+ * "up" means only the second; and a session on a host that has stopped answering
+ * is drawn as *stale*, which is the one state nothing else in the app can catch,
+ * since no sweep writes `status` any more.
+ */
+export function MachinesIndicator() {
+  const t = useT();
+  // Off by default (Settings' "Remote features") — most projects are local-only,
+  // so this fleet-wide SSH list stays out of the header until asked for.
+  const enabled = useSettingsStore((s) => s.settings?.machines_enabled ?? false);
+  const headless = useSettingsStore((s) => s.settings?.connections_headless ?? true);
+  // The whole settings object (not one flag) because the HPC tag is a map keyed
+  // by SSH target: the row reads its own machine's entry, and writing one has to
+  // merge into the rest rather than replace them.
+  const settings = useSettingsStore((s) => s.settings);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+  const machines = useGlobalMachinesStore((s) => s.machines);
+  const status = useGlobalMachinesStore((s) => s.status);
+  // The other half of a row's truth: the last probe answer, kept apart from
+  // `status` on purpose (see `RowState`). Absent = never probed.
+  const reachable = useGlobalMachinesStore((s) => s.reachable);
+  const errors = useGlobalMachinesStore((s) => s.errors);
+  const load = useGlobalMachinesStore((s) => s.load);
+  const probeAll = useGlobalMachinesStore((s) => s.probeAll);
+  const connect = useGlobalMachinesStore((s) => s.connect);
+  const disconnect = useGlobalMachinesStore((s) => s.disconnect);
+  const retryAll = useGlobalMachinesStore((s) => s.retryAll);
+  // Busy readings are keyed by SSH target, so this one subscription lights both
+  // the aggregate strip and every row.
+  const readings = useHostBusyStore((s) => s.readings);
+  const disconnectAll = useGlobalMachinesStore((s) => s.disconnectAll);
+  const remove = useGlobalMachinesStore((s) => s.remove);
+  // Persist-without-authenticating: the terminal sign-in has already logged in,
+  // so `add`'s `ssh_connect` would be a second login (and a password prompt this
+  // mode exists to avoid).
+  const register = useGlobalMachinesStore((s) => s.register);
+  const add = useGlobalMachinesStore((s) => s.add);
+  const update = useGlobalMachinesStore((s) => s.update);
+  const setAutoConnect = useGlobalMachinesStore((s) => s.setAutoConnect);
+  const reorder = useGlobalMachinesStore((s) => s.reorder);
+  const exportMachines = useGlobalMachinesStore((s) => s.exportMachines);
+  const importMachines = useGlobalMachinesStore((s) => s.importMachines);
+  const openMonitor = useGlobalMachineMonitorStore((s) => s.open);
+  // The projects a machine can be added to: the ACTIVE ones only — exactly the
+  // set `ProjectSwitcher` renders as pills (`status !== "inactive"`), which is
+  // both what the old drag gesture could reach and what the handoff needs, since
+  // `requestExtend` is picked up by the target's mounted `ProjectPill`.
+  const projects = useProjectsStore((s) => s.projects).filter((p) => p.status !== "inactive");
+  const openUsage = useRemoteUsageStore((s) => s.open);
+  const openRemoteMachines = useRemoteMachinesStore((s) => s.open);
+  const requestExtend = useRemoteMachinesStore((s) => s.requestExtend);
+
+  /** Hand this machine to a project: a remote project gets it as a (shared-fs)
+   *  compute host via the Remote machines window; a local-only one gets it as
+   *  its primary host via the extend-to-remote flow. The same two branches the
+   *  pill's drop target used to pick between. */
+  const attachToProject = (p: ProjectEntry, m: { id: string; host: string; user?: string; port?: number; label?: string }) => {
+    const machine = { id: m.id, host: m.host, user: m.user, port: m.port, label: m.label };
+    if (p.remote) openRemoteMachines(p.id, machine);
+    else requestExtend(p.id, machine);
+  };
+
+  // Opened by CLICK, never by hover. Opening this menu sweeps the fleet, and
+  // `ssh_probe` is a full authenticated SSH login on each host rather than a
+  // ping — on hover, a pointer crossing the header on its way somewhere else
+  // logged Eldrun into every machine in the list. A menu that dials has to be
+  // asked for.
+  const [open, setOpen] = useState(false);
+  const anchorRef = useRef<HTMLDivElement | null>(null);
+  // While an import/export panel is up — or a native file dialog is open, which
+  // takes the focus and the pointer away from the menu — it must NOT close under
+  // the user mid-flow. A ref (read synchronously by the dismiss handlers) rather
+  // than state, so the guard is live the instant a dialog opens, before any
+  // re-render.
+  const keepOpenRef = useRef(false);
+  // ── The open-sweep's two brakes ─────────────────────────────────────────────
+  // In flight: a second open while the first sweep is still running must not
+  // stack a second round trip per host (`stores/hostBusy`'s `inFlight` makes the
+  // same promise for the busy probe; the store's `probeAll` makes none).
+  const probeInFlight = useRef(false);
+  // And a minimum interval, stamped per machine: reopening the menu is a glance,
+  // not a new question. `probeAll` is all-or-nothing (it owns which machines it
+  // may touch), so the sweep runs only when at least one eligible machine's
+  // answer has aged out, and stamps every eligible machine when it returns.
+  const lastProbeAt = useRef<Map<string, number>>(new Map());
+  // When the last sweep landed, as state rather than a ref, because a row's
+  // reachability has to re-render when it changes: a per-row Check (below) is
+  // preferred over the sweep's answer only while it is the newer of the two.
+  const [sweepAt, setSweepAt] = useState(0);
+  // Per-row manual checks — the only reachability a tagged HPC machine ever has,
+  // since every sweep skips it by design. Local to the menu on purpose: the
+  // store's `reachable` is the sweep's map, and a hand probe must not be filed
+  // as one (nor may it touch `status`, which means "a session we opened").
+  const [checked, setChecked] = useState<Record<string, { ok: boolean; at: number; error?: string }>>({});
+  const [checking, setChecking] = useState<Set<string>>(new Set());
+  // Failures of the two calls this component makes itself (the hand Check, the
+  // explicit HPC login) — the store's `errors` map is written by the store's own
+  // actions, and a row shows both.
+  const [localErrors, setLocalErrors] = useState<Record<string, string>>({});
+  // Per-row DOM nodes (keyed by machine id) + their last-measured positions,
+  // for the FLIP slide animation when the list reorders.
+  const rowRefs = useRef<Map<string, HTMLDivElement>>(new Map());
+  const prevRects = useRef<Map<string, number>>(new Map());
+  // Which row's "Add to a project" picker is open, if any. This is the ONLY way
+  // a global machine reaches a project — the drag-onto-a-pill gesture it
+  // replaced could not be made to work (see the component doc), and a picker
+  // says which of the two ways the machine would join, which a drop could only
+  // imply.
+  const [attachId, setAttachId] = useState<string | null>(null);
+
+  // Reorder-by-drag, on POINTER events — not HTML5 DnD, which is what broke the
+  // first attempt (a native drag out of a hover-menu hangs under WebKitGTK, and
+  // a drop outside a target never fires, stranding the row mid-drag). Same
+  // choice `tabs/TabBar` and `embed/YamlTree` already made. The gesture starts
+  // on the row's grip only, so the row's buttons stay clickable; the grip takes
+  // a pointer capture, so `pointerup`/`pointercancel` are guaranteed to arrive
+  // there and end the drag — there is no state a missed event can strand.
+  //
+  // `to` is the slot the dragged row would land in, as an index into the list
+  // WITHOUT it. The other rows part to open that slot — but they part by
+  // `transform` only, which changes no layout, so the rects measured at
+  // pointerdown stay true for the whole gesture. Re-measuring a moved row
+  // against the cursor that moved it is the feedback loop this avoids.
+  const [reorderDrag, setReorderDrag] = useState<
+    { id: string; dy: number; to: number } | null
+  >(null);
+  const dragRects = useRef<{ id: string; top: number; height: number }[]>([]);
+  const dragStartY = useRef(0);
+  const reorderDragRef = useRef(false);
+
+  /** Where the dragged row would land, from the pointer's Y: the number of OTHER
+   *  rows whose midpoint the cursor has passed — i.e. an index into the list
+   *  without the dragged row, which is exactly what `commitMove` splices at. */
+  const dropSlot = (id: string, clientY: number) => {
+    const rest = dragRects.current.filter((r) => r.id !== id);
+    return rest.filter((r) => clientY > r.top + r.height / 2).length;
+  };
+
+  const [removeArm, setRemoveArm] = useState<string | null>(null);
+  const [disconnectArm, setDisconnectArm] = useState<string | null>(null);
+  // Fleet-wide actions (retry all / disconnect all). `disconnectAllArm` gates the
+  // destructive one behind a confirm, exactly as the per-row `disconnectArm` does.
+  const [retryAllBusy, setRetryAllBusy] = useState(false);
+  const [disconnectAllArm, setDisconnectAllArm] = useState(false);
+  const [retryId, setRetryId] = useState<string | null>(null);
+  // Prefilled from the machine's stored username in `startRetry` — a retry is a
+  // re-authenticate of the SAME target, so the login it should default to is the
+  // one already on file, not a blank field the user has to remember to refill.
+  // Editing it here and reconnecting persists the correction (`submitEdit`'s
+  // `update` path), since a login that was wrong is wrong for next time too.
+  const [retryUser, setRetryUser] = useState("");
+  const [retryPassword, setRetryPassword] = useState("");
+  // Only for a `global_machine_update` validation failure (e.g. the edited
+  // username collides with another row's target) — an auth failure instead
+  // lands in the store's `errors` map and is shown from there, alongside the
+  // aggregate lamp state.
+  const [retryError, setRetryError] = useState("");
+  // Rows render compact by default (lamp + label + actions only) — target
+  // address, usage meters and the auto-connect toggle are behind a per-row
+  // expand so a long machine list stays scannable.
+  const [expandedIds, setExpandedIds] = useState<Set<string>>(new Set());
+  const toggleExpanded = (id: string) => {
+    setExpandedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  };
+
+  const [adding, setAdding] = useState(false);
+  const [address, setAddress] = useState("");
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [label, setLabel] = useState("");
+  const [savePassword, setSavePassword] = useState(false);
+  // Arm the new machine for the launch / VPN-up sweep straight from the add form,
+  // so a machine you connect once can silently reconnect on relaunch without
+  // opening its row to flip the per-row toggle. Off by default: arming is opt-in
+  // (matches a fresh machine's `auto_connect`), and safe either way — the sweep
+  // probes first, so an armed host that can't connect silently just stays dark.
+  const [addAuto, setAddAuto] = useState(false);
+  // "This is a cluster login node", ticked on the login form. Written to
+  // `settings.hpc_hosts` the moment the machine exists (both add paths), so the
+  // very first connect already has every background behaviour gated off.
+  const [addHpc, setAddHpc] = useState(false);
+  const [addError, setAddError] = useState("");
+  const [addBusy, setAddBusy] = useState(false);
+  // ── "Sign in in a terminal" (see `TerminalSignInToggle`) ─────────────────────
+  // Same escape hatch as the connect dialogs', for the same reason: this form has
+  // one password field, so a host that asks anything else — a challenge code, a
+  // one-time code, an expired-password change — cannot be added from it at all.
+  // Default **on** in non-headless mode, where a password field was never supposed
+  // to be. Unlike the dialogs, the login goes to the **root terminal** rather than
+  // an embedded one: this is a header menu, dismissed by a click anywhere else or
+  // by Escape, which is no place to keep a live PTY — and it is exactly what the
+  // VPN indicator beside it already does in that mode.
+  const [addViaTerminal, setAddViaTerminal] = useState(!headless);
+  // A login is open in the root terminal and we are waiting to be able to
+  // authenticate the host (see `pollAddLogin` — this cannot observe the master
+  // itself, and no longer claims to).
+  const [addWaiting, setAddWaiting] = useState(false);
+  const addPoll = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Live mirrors of the two fields the poll writes onto the machine (see
+  // `finishTerminalAdd`), which outlives the render that scheduled it.
+  const labelRef = useRef(label);
+  const addAutoRef = useRef(addAuto);
+  const addHpcRef = useRef(addHpc);
+  useEffect(() => {
+    labelRef.current = label;
+    addAutoRef.current = addAuto;
+    addHpcRef.current = addHpc;
+  }, [label, addAuto, addHpc]);
+
+  // Per-row inline edit of an existing machine's connection identity. `editId`
+  // is the row being edited; the fields are prefilled from it in `startEdit`.
+  // The password field is blank ("keep the saved credential") unless the user
+  // wants to change it — see `submitEdit`.
+  const [editId, setEditId] = useState<string | null>(null);
+  const [editAddress, setEditAddress] = useState("");
+  const [editUser, setEditUser] = useState("");
+  const [editPassword, setEditPassword] = useState("");
+  const [editLabel, setEditLabel] = useState("");
+  const [editSave, setEditSave] = useState(false);
+  const [editError, setEditError] = useState("");
+  const [editBusy, setEditBusy] = useState(false);
+
+  // Import / export sub-flows. `ioMode` picks which panel replaces the normal
+  // machine list + add-form; both are one-off modal flows within the menu.
+  const [ioMode, setIoMode] = useState<"idle" | "export" | "import">("idle");
+  // Export: which machines (by id) go into the file — all ticked by default.
+  const [exportSel, setExportSel] = useState<Set<string>>(new Set());
+  const [ioBusy, setIoBusy] = useState(false);
+  const [ioError, setIoError] = useState("");
+  // Import: the entries read from the picked file, plus the ONE shared
+  // credential the whole batch connects with (a file carries no username/
+  // password by design). `importResult` holds the per-host outcome once the run
+  // finishes, so the panel switches from form to summary.
+  const [importEntries, setImportEntries] = useState<MachineImportEntry[]>([]);
+  const [importUser, setImportUser] = useState("");
+  const [importPassword, setImportPassword] = useState("");
+  const [importSave, setImportSave] = useState(false);
+  // Arm every imported machine for the launch / VPN-up sweep. Default ON: an
+  // imported fleet is one the user wants available, and arming can't misfire —
+  // `autoConnect` probes before it connects, so a row that can't come up
+  // silently stays dark rather than prompting. Untick to import them inert.
+  const [importAuto, setImportAuto] = useState(true);
+  const [importResult, setImportResult] = useState<ImportResult[] | null>(null);
+
+  const closeIo = () => {
+    keepOpenRef.current = false;
+    setIoMode("idle");
+    setIoBusy(false);
+    setIoError("");
+    setImportEntries([]);
+    setImportUser("");
+    setImportPassword("");
+    setImportSave(false);
+    setImportResult(null);
+  };
+
+  /** May Eldrun touch this machine with nobody asking? The same authority the
+   *  store's sweeps consult, so the row's stated reason for "not checked" and
+   *  the sweep's decision to skip it can never disagree. */
+  const autoTouchable = (m: GlobalMachine) => mayAutoTouch(settings, targetOfSpec(m));
+
+  /** The reachability a row should believe: a hand Check wins while it is the
+   *  newer of the two, otherwise the sweep's answer — and `undefined` (nobody
+   *  asked) stays `undefined` rather than collapsing into "no". */
+  const reachOf = (id: string): boolean | undefined => {
+    const local = checked[id];
+    if (local && local.at >= sweepAt) return local.ok;
+    return reachable[id];
+  };
+  const stateOf = (m: GlobalMachine): RowState =>
+    rowStateOf(status[m.id] ?? "off", reachOf(m.id));
+
+  /** **Check** — one probe, because the user asked for one. `background: false`
+   *  is what makes it legal on a machine tagged HPC, and that is the whole point:
+   *  no sweep will ever touch such a row, so this button is its only reachability.
+   *  The answer stays local (see `checked`) — the store's `reachable` is the
+   *  sweep's map, and `status` means a session, which a probe is not. */
+  const runCheck = async (m: GlobalMachine) => {
+    setChecking((prev) => new Set(prev).add(m.id));
+    const r = await invoke<{ ok: boolean; error: string }>("ssh_probe", {
+      user: m.user,
+      host: m.host,
+      port: m.port,
+      background: false,
+    })
+      .then((res) => ({ ok: res.ok, error: res.error || undefined }))
+      // A guard refusal is not an error to print — it means the call was read as
+      // background after all, and the row's honest answer is still "not checked".
+      .catch((e) => ({ ok: false, error: hpcGuardRefusal(e) ? undefined : String(e) }));
+    setChecked((prev) => ({ ...prev, [m.id]: { ...r, at: Date.now() } }));
+    setChecking((prev) => {
+      const next = new Set(prev);
+      next.delete(m.id);
+      return next;
+    });
+  };
+
+  /** The **explicit** login for a tagged cluster. It exists only because the
+   *  store's `connect` is a background-defaulted call: the backend refuses one
+   *  against a tagged host, which is right for every sweep and wrong for the one
+   *  button that IS the gesture. So this row's connect says so (`background:
+   *  false`) and writes the same lamp the store would — `setStatus` is what
+   *  `lib/machineSync`'s subscription propagates, so a project holding this host
+   *  still follows. Untagged machines keep the store's path untouched. */
+  const explicitConnect = async (m: GlobalMachine) => {
+    setLocalErrors((prev) => {
+      const next = { ...prev };
+      delete next[m.id];
+      return next;
+    });
+    // The store owns the connect itself — including the host-key confirm, the
+    // `remember: null` rule and the lamp writes `lib/machineSync`'s subscription
+    // propagates. It defaults to the *gesture* spelling, which is what makes this
+    // path work on a tagged host at all; only the launch sweep says `background`.
+    await connect(m.id);
+    // A connect that authenticated is also the freshest possible reachability
+    // answer, so it stands in for a probe — a row the user just logged into must
+    // not still read "not checked".
+    if (useGlobalMachinesStore.getState().status[m.id] === "connected") {
+      setChecked((prev) => ({ ...prev, [m.id]: { ok: true, at: Date.now() } }));
+    }
+  };
+
+  useEffect(() => {
+    if (!enabled) return;
+    void load();
+  }, [load, enabled]);
+
+  useEffect(() => {
+    if (!open) {
+      // A genuinely-closed menu (keepOpenRef already gates a mid-flow close)
+      // drops any half-finished import/export so it can't reappear on reopen.
+      closeIo();
+      return;
+    }
+    setRemoveArm(null);
+    setDisconnectArm(null);
+    setDisconnectAllArm(false);
+    setEditId(null);
+    setAttachId(null);
+    // Reachability first, then the busy sweep over whatever we hold a SESSION on
+    // — a probe answer is not a session, and asking a host we never logged into
+    // what it is running costs a second doomed login. On-open only: the busy
+    // reading is never polled (see `stores/hostBusy`).
+    //
+    // Both brakes are on before any of it. Nothing sweeps while a sweep is in
+    // flight, and nothing sweeps at all unless some eligible machine's answer has
+    // aged past `PROBE_MIN_INTERVAL_MS` — opening this menu three times in a
+    // minute is one login per host, not three. The sweep itself stays a
+    // *background* call (no `background: false` anywhere below): the backend
+    // refuses it on a tagged host, which is the redundancy that survives a
+    // frontend guard someone forgets.
+    if (probeInFlight.current) return;
+    const eligible = machines.filter(autoTouchable);
+    const now = Date.now();
+    const due = eligible.filter(
+      (m) => now - (lastProbeAt.current.get(m.id) ?? 0) >= PROBE_MIN_INTERVAL_MS,
+    );
+    if (due.length === 0) return;
+    probeInFlight.current = true;
+    void probeAll()
+      .then(() => {
+        const at = Date.now();
+        for (const m of eligible) lastProbeAt.current.set(m.id, at);
+        setSweepAt(at);
+        const gm = useGlobalMachinesStore.getState();
+        const probeBusy = useHostBusyStore.getState().probeGlobal;
+        for (const m of gm.machines) {
+          if ((gm.status[m.id] ?? "off") === "connected") void probeBusy(m);
+        }
+      })
+      // A rejected sweep must still release the in-flight brake, or the menu
+      // would never probe again for the rest of the session.
+      .catch(() => {})
+      .finally(() => {
+        probeInFlight.current = false;
+      });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [open, probeAll]);
+
+  const orderKey = machines.map((m) => m.id).join("|");
+
+  /** Commit a reorder: pull `id` out of the list and splice it back in at `to`
+   *  (an index into the list WITHOUT it). The FLIP pass below animates the
+   *  result, so both the drop and the keyboard nudge read as movement. */
+  const commitMove = (id: string, to: number) => {
+    const ids = machines.map((m) => m.id);
+    const from = ids.indexOf(id);
+    if (from < 0 || to < 0 || to > ids.length - 1) return;
+    if (to === from) return;
+    ids.splice(from, 1);
+    ids.splice(to, 0, id);
+    void reorder(ids);
+  };
+
+  // Keyboard equivalent of the drag, on the focused grip: a reorder must not be
+  // pointer-only.
+  const nudgeMachine = (id: string, delta: number) =>
+    commitMove(id, machines.findIndex((m) => m.id === id) + delta);
+
+  const startReorderDrag = (id: string, e: React.PointerEvent<HTMLElement>) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    e.stopPropagation();
+    e.currentTarget.setPointerCapture(e.pointerId);
+    dragStartY.current = e.clientY;
+    // Measure every row ONCE, up front: the DOM order is frozen for the duration
+    // of the drag precisely so these stay true.
+    dragRects.current = machines.map((mm) => {
+      const rect = rowRefs.current.get(mm.id)?.getBoundingClientRect();
+      return { id: mm.id, top: rect?.top ?? 0, height: rect?.height ?? 0 };
+    });
+    reorderDragRef.current = true;
+    setReorderDrag({ id, dy: 0, to: dropSlot(id, e.clientY) });
+  };
+
+  const moveReorderDrag = (e: React.PointerEvent<HTMLElement>) => {
+    if (!reorderDrag) return;
+    const dy = e.clientY - dragStartY.current;
+    const to = dropSlot(reorderDrag.id, e.clientY);
+    if (dy !== reorderDrag.dy || to !== reorderDrag.to) setReorderDrag({ ...reorderDrag, dy, to });
+  };
+
+  const endReorderDrag = (e: React.PointerEvent<HTMLElement>, commit: boolean) => {
+    if (!reorderDrag) return;
+    const { id } = reorderDrag;
+    reorderDragRef.current = false;
+    setReorderDrag(null);
+    if (commit) commitMove(id, dropSlot(id, e.clientY));
+  };
+
+  // FLIP: after the reordered rows paint, translate each card from where it was
+  // to where it now is (0ms), then release the transform on the next frame so it
+  // slides into place. WebKitGTK animates `transform` cheaply, and comparing top
+  // offsets tolerates the rows' variable height (an expanded row is taller).
+  useLayoutEffect(() => {
+    const next = new Map<string, number>();
+    rowRefs.current.forEach((el, id) => {
+      const top = el.getBoundingClientRect().top;
+      next.set(id, top);
+      const prev = prevRects.current.get(id);
+      if (prev !== undefined) {
+        const dy = prev - top;
+        if (Math.abs(dy) > 0.5) {
+          el.style.transition = "none";
+          el.style.transform = `translateY(${dy}px)`;
+          // Force a reflow so the pre-slide transform is committed before release.
+          void el.offsetHeight;
+          requestAnimationFrame(() => {
+            el.style.transition = "transform 160ms ease";
+            el.style.transform = "";
+          });
+        }
+      }
+    });
+    prevRects.current = next;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [orderKey]);
+
+  // Dismissal, now that hover neither opens nor closes this menu: a click
+  // outside it, or Escape. The old 250ms mouse-leave close was the twin of the
+  // hover open; with a deliberate open it would pull half-typed forms out from
+  // under the pointer on its way to them. `keepOpenRef` still wins (a native
+  // file dialog's clicks land outside every element of ours), and a reorder drag
+  // that carried the pointer off the menu must not unmount the rows mid-gesture
+  // — read from the ref, not `reorderDrag`, so the guard is live in the same
+  // tick the gesture starts.
+  useEffect(() => {
+    if (!open) return;
+    const onPointerDown = (e: PointerEvent) => {
+      if (keepOpenRef.current || reorderDragRef.current) return;
+      const el = anchorRef.current;
+      if (el && e.target instanceof Node && el.contains(e.target)) return;
+      setOpen(false);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== "Escape" || keepOpenRef.current) return;
+      setOpen(false);
+    };
+    document.addEventListener("pointerdown", onPointerDown, true);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("pointerdown", onPointerDown, true);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [open]);
+
+  // Group the machines by COLOUR so each lamp is drawn once, with a count —
+  // exactly like a project pill's `RemoteConnMenu` aggregates its hosts. No
+  // machines at all still shows one grey "off" lamp so the indicator is never
+  // blank.
+  //
+  // The grouping is by lamp bucket rather than by row state (`LAMP_BUCKETS`):
+  // seven states would be seven dots in a header that has room for four, and
+  // three of them are the same "no session here" grey anyway. The breakdown —
+  // "3 up, 2 no answer, 1 not checked" — rides the tooltip, which costs no width.
+  //
+  // Busy is folded into the EXISTING green lamp — it never adds one. Splitting
+  // "connected" into working/idle would grow the strip exactly when the fleet is
+  // most active. So the one green lamp pulses when ANY connected machine is
+  // working, and its tooltip carries the count and the names. The per-machine
+  // answer belongs one level down, on the rows, where each lamp is its own host.
+  const lampGroups = (() => {
+    const byState = new Map<RowState, GlobalMachine[]>();
+    for (const m of machines) {
+      const st = stateOf(m);
+      const list = byState.get(st);
+      if (list) list.push(m);
+      else byState.set(st, [m]);
+    }
+    const grouped = LAMP_BUCKETS.map((bucket) => {
+      const parts = bucket.states
+        .map((st) => ({ st, machines: byState.get(st) ?? [] }))
+        .filter((p) => p.machines.length > 0);
+      const all = parts.flatMap((p) => p.machines);
+      // Only a machine we hold a session on can be "working": a reading taken
+      // before it dropped says nothing about it now.
+      const working =
+        bucket.lamp === "connected"
+          ? all.filter((m) => busyReading({ readings }, m) !== null)
+          : [];
+      return { lamp: bucket.lamp, parts, machines: all, working };
+    }).filter((g) => g.machines.length > 0);
+    return grouped.length > 0
+      ? grouped
+      : [
+          {
+            lamp: "off" as ConnState,
+            parts: [] as { st: RowState; machines: GlobalMachine[] }[],
+            machines: [] as GlobalMachine[],
+            working: [] as GlobalMachine[],
+          },
+        ];
+  })();
+
+  const startRetry = (id: string) => {
+    const m = machines.find((mm) => mm.id === id);
+    setRetryId(id);
+    setRetryUser(m?.user ?? "");
+    setRetryPassword("");
+    setRetryError("");
+  };
+  const submitRetry = async (id: string) => {
+    const m = machines.find((mm) => mm.id === id);
+    const user = retryUser.trim() || undefined;
+    setRetryError("");
+    try {
+      // A username edited here is a correction to the stored login, not a
+      // one-shot override — route through `update` (which also reconnects) so
+      // it sticks for next time; leave the plain `connect` path alone when it
+      // is unchanged, to avoid an extra `global_machine_update` round trip on
+      // the common case.
+      if (m && user !== (m.user ?? undefined)) {
+        await update(id, { user, host: m.host, port: m.port, label: m.label }, {
+          password: retryPassword || undefined,
+          connect: true,
+        });
+      } else {
+        await connect(id, retryPassword || undefined);
+      }
+      setRetryId(null);
+      setRetryPassword("");
+    } catch (e) {
+      setRetryError(String(e));
+    }
+  };
+
+  const connectedCount = machines.filter((m) => (status[m.id] ?? "off") === "connected").length;
+  const runRetryAll = async () => {
+    setRetryAllBusy(true);
+    try {
+      await retryAll();
+    } finally {
+      setRetryAllBusy(false);
+    }
+  };
+
+  // ── Terminal sign-in: log in in the root terminal, then adopt that session ───
+  // Eldrun sees no password here: the user logs in in the root terminal, and the
+  // machine is then `register`ed — the store action that deliberately does *not*
+  // re-authenticate, precisely because the caller already did.
+  //
+  // What the poll below can and cannot tell you. It was written as "the login's
+  // ControlMaster is the only signal, so a credential-less `ssh_connect` can only
+  // succeed by riding it" — which is false: `ssh_connect` falls back to key/agent
+  // auth and to the saved keychain credential, so on a host with either it
+  // succeeds on the FIRST poll, the terminal login unfinished and irrelevant. The
+  // 3s×40 cadence that premise justified was therefore, on a host that never
+  // answers, forty authentication attempts against an unattended machine. There
+  // is no frontend command for `ssh -O check` against the shared `cm-%C` socket
+  // (the backend has one internally — `services::ssh_exec` — but exposes none),
+  // so the master cannot be observed directly from here. Until it can, this is
+  // honestly a **readiness** poll — "can Eldrun authenticate this host yet" —
+  // backed off and capped hard (below) so a wrong answer is cheap. Adopting a
+  // session Eldrun could have opened by itself is harmless; the terminal path
+  // still exists for the host where it is the only way in.
+  const clearAddPoll = () => {
+    if (addPoll.current) {
+      clearTimeout(addPoll.current);
+      addPoll.current = null;
+    }
+  };
+
+  const finishTerminalAdd = async (target: {
+    user: string | null;
+    host: string;
+    port: number | null;
+  }) => {
+    const machine = await register({
+      user: target.user ?? undefined,
+      host: target.host,
+      port: target.port ?? undefined,
+      // Through refs: the poll re-schedules itself through the closure of the
+      // render that started it, so reading these directly would freeze them at the
+      // click — and a label typed while the login is still open (which is exactly
+      // when there is time to type one) would be dropped.
+      label: labelRef.current.trim() || undefined,
+    });
+    if (!machine) {
+      setAddError(t("machines.err.saveFailed"));
+      return;
+    }
+    // Same order as the headless path: tag first, and never arm a silent
+    // launch-time connect for a machine the user just called a cluster.
+    if (addHpcRef.current) {
+      await updateSettings(
+        setHpcPatch(
+          useSettingsStore.getState().settings,
+          { user: machine.user, host: machine.host, port: machine.port },
+          true,
+        ),
+      );
+    }
+    if (addAutoRef.current && !addHpcRef.current) await setAutoConnect(machine.id, true);
+    setAddress("");
+    setUsername("");
+    setPassword("");
+    setLabel("");
+    setSavePassword(false);
+    setAddAuto(false);
+    setAddHpc(false);
+    setAdding(false);
+  };
+
+  /** Eight attempts, backing off 3s → 30s (~2½ min in all) instead of forty at a
+   *  flat 3s. Each one is a real authentication attempt against a host nobody is
+   *  watching, and the thing being waited for is a human finishing a login — a
+   *  question that gets no truer for being asked twenty times a minute. */
+  const POLL_MAX_ATTEMPTS = 8;
+  const pollDelayMs = (attempt: number) => Math.min(3000 * 2 ** attempt, 30_000);
+
+  const pollAddLogin = (
+    target: { user: string | null; host: string; port: number | null },
+    attempt = 0,
+  ) => {
+    void invoke<void>("ssh_connect", {
+      user: target.user,
+      host: target.host,
+      port: target.port,
+      password: null,
+      // Part of a gesture — the user has just been sent to a terminal to log in.
+      // Without this a tagged cluster (the likeliest host to need a terminal
+      // login in the first place, since it is the one that asks for a challenge
+      // code) could not be added this way at all.
+      background: false,
+    })
+      .then(async () => {
+        clearAddPoll();
+        setAddWaiting(false);
+        await finishTerminalAdd(target).catch((e) => setAddError(String(e)));
+      })
+      .catch(() => {
+        if (attempt + 1 >= POLL_MAX_ATTEMPTS) {
+          clearAddPoll();
+          setAddWaiting(false);
+          setAddError(t("machines.err.noLoginYet"));
+          return;
+        }
+        addPoll.current = setTimeout(() => pollAddLogin(target, attempt + 1), pollDelayMs(attempt));
+      });
+  };
+
+  const startTerminalAdd = async () => {
+    const parsed = parseSshAddress(address);
+    if (!parsed) {
+      setAddError(t("machines.err.address"));
+      return;
+    }
+    const target = {
+      user: parsed.user ?? (username.trim() || null),
+      host: parsed.host,
+      port: parsed.port ?? null,
+    };
+    setAddError("");
+    try {
+      const command = await invoke<string>("remote_login_command", {
+        user: target.user,
+        host: target.host,
+        port: target.port,
+      });
+      const tabLabel = `ssh · ${target.user ? `${target.user}@` : ""}${target.host}`;
+      openConnectionInRoot({
+        label: tabLabel,
+        command,
+        dedupeKey: `ssh:${target.user ? `${target.user}@` : ""}${target.host}:${target.port ?? ""}`,
+      });
+      setAddWaiting(true);
+      clearAddPoll();
+      pollAddLogin(target);
+    } catch (e) {
+      setAddError(String(e));
+    }
+  };
+
+  /** Re-arm the poll — for a login finished after the bound ran out. */
+  const retryTerminalAdd = () => {
+    const parsed = parseSshAddress(address);
+    if (!parsed) return;
+    setAddError("");
+    setAddWaiting(true);
+    clearAddPoll();
+    pollAddLogin({
+      user: parsed.user ?? (username.trim() || null),
+      host: parsed.host,
+      port: parsed.port ?? null,
+    });
+  };
+
+  // The menu unmounts on close; a timer firing into it afterwards is nobody's.
+  // The root-terminal tab is deliberately left alone — it is the user's login.
+  useEffect(() => clearAddPoll, []);
+
+  const submitAdd = async () => {
+    const parsed = parseSshAddress(address);
+    if (!parsed) {
+      setAddError(t("machines.err.address"));
+      return;
+    }
+    setAddBusy(true);
+    setAddError("");
+    try {
+      const machine = await add({
+        user: parsed.user ?? (username.trim() || undefined),
+        host: parsed.host,
+        port: parsed.port ?? undefined,
+        label: label.trim() || undefined,
+        password: password || undefined,
+        remember: savePassword,
+      });
+      // The tag is written first: everything else keyed off it (the monitor's
+      // reading, the census, auto-connect) should already see it by the time this
+      // machine is anything but a row.
+      if (addHpc) {
+        await updateSettings(
+          setHpcPatch(useSettingsStore.getState().settings, { user: machine.user, host: machine.host, port: machine.port }, true),
+        );
+      }
+      // Arm the launch/VPN-up sweep in the same step if the user asked — the add
+      // already connected it now; this only persists the future intent. Never for
+      // a tagged cluster: silent connects are one of the things the tag is for.
+      if (addAuto && !addHpc) await setAutoConnect(machine.id, true);
+      setAddress("");
+      setUsername("");
+      setPassword("");
+      setLabel("");
+      setSavePassword(false);
+      setAddAuto(false);
+      setAddHpc(false);
+      setAdding(false);
+    } catch (e) {
+      setAddError(String(e));
+    } finally {
+      setAddBusy(false);
+    }
+  };
+
+  const startEdit = (m: (typeof machines)[number]) => {
+    setEditId(m.id);
+    setEditAddress(`${m.host}${m.port ? `:${m.port}` : ""}`);
+    setEditUser(m.user ?? "");
+    setEditPassword("");
+    setEditLabel(m.label ?? "");
+    setEditSave(false);
+    setEditError("");
+  };
+  const submitEdit = async (id: string) => {
+    const orig = machines.find((m) => m.id === id);
+    const parsed = parseSshAddress(editAddress);
+    if (!parsed) {
+      setEditError(t("machines.err.address"));
+      return;
+    }
+    const user = parsed.user ?? (editUser.trim() || undefined);
+    const port = parsed.port ?? undefined;
+    // Reconnect only when a connection-relevant field changed, or the user typed
+    // a new password / asked to (re)save it — a label-only edit must not force an
+    // SSH round trip (which could prompt or be slow).
+    const targetChanged =
+      user !== (orig?.user ?? undefined) ||
+      parsed.host !== orig?.host ||
+      port !== (orig?.port ?? undefined);
+    const doConnect = targetChanged || !!editPassword || editSave;
+    setEditBusy(true);
+    setEditError("");
+    try {
+      await update(
+        id,
+        { user, host: parsed.host, port, label: editLabel.trim() || undefined },
+        { password: editPassword || undefined, remember: editSave, connect: doConnect },
+      );
+      setEditId(null);
+      setEditPassword("");
+    } catch (e) {
+      setEditError(String(e));
+    } finally {
+      setEditBusy(false);
+    }
+  };
+
+  const startExport = () => {
+    setAdding(false);
+    setIoError("");
+    setExportSel(new Set(machines.map((m) => m.id))); // all ticked by default
+    keepOpenRef.current = true;
+    setIoMode("export");
+  };
+  const toggleExportSel = (id: string) => {
+    setExportSel((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  };
+  // Select-all/none for the export list: one toggle instead of N unticks when
+  // the user wants to share a single machine out of a large fleet. "All ticked"
+  // is the checked state, so the first click always *clears* — which is the
+  // direction that's tedious by hand, since opening the panel ticks everything.
+  const allExportSelected = machines.length > 0 && exportSel.size === machines.length;
+  const toggleExportSelAll = () => {
+    setExportSel(allExportSelected ? new Set() : new Set(machines.map((m) => m.id)));
+  };
+  const doExport = async () => {
+    const ids = machines.map((m) => m.id).filter((id) => exportSel.has(id));
+    if (ids.length === 0) return;
+    setIoBusy(true);
+    setIoError("");
+    try {
+      // The dialog moves the pointer off the menu; `keepOpenRef` (already set)
+      // keeps it from closing while the native picker is up.
+      const path = await saveDialog({
+        title: t("machines.exportDialogTitle"),
+        defaultPath: "eldrun-machines.json",
+        filters: [{ name: t("machines.jsonFilter"), extensions: ["json"] }],
+      });
+      if (!path) {
+        setIoBusy(false);
+        return; // cancelled — stay on the export panel
+      }
+      await exportMachines(ids, path);
+      closeIo();
+    } catch (e) {
+      setIoError(String(e));
+      setIoBusy(false);
+    }
+  };
+
+  const startImport = async () => {
+    setAdding(false);
+    setIoError("");
+    keepOpenRef.current = true;
+    setIoMode("import");
+    setIoBusy(true);
+    try {
+      const picked = await openDialog({
+        title: t("machines.importDialogTitle"),
+        multiple: false,
+        directory: false,
+        filters: [{ name: t("machines.jsonFilter"), extensions: ["json"] }],
+      });
+      const path = Array.isArray(picked) ? picked[0] : picked;
+      if (!path) {
+        closeIo(); // nothing picked — leave the menu as it was
+        return;
+      }
+      const entries = await invoke<MachineImportEntry[]>("global_machines_import_read", {
+        path,
+      });
+      setImportEntries(entries);
+      setImportResult(null);
+    } catch (e) {
+      setIoError(String(e));
+    } finally {
+      setIoBusy(false);
+    }
+  };
+  const doImport = async () => {
+    if (importEntries.length === 0) return;
+    setIoBusy(true);
+    setIoError("");
+    try {
+      const result = await importMachines(importEntries, {
+        user: importUser.trim() || undefined,
+        password: importPassword || undefined,
+        remember: importSave,
+        autoConnect: importAuto,
+      });
+      setImportResult(result);
+    } catch (e) {
+      setIoError(String(e));
+    } finally {
+      setIoBusy(false);
+    }
+  };
+
+  if (!enabled) return null;
+
+  /** One line per state inside a colour's bucket, so the grey dot can say which
+   *  kind of "no session here" its count is made of. */
+  const lampLabel = (g: (typeof lampGroups)[number]) => {
+    if (g.machines.length === 0) return t("machines.label");
+    const lines = g.parts.map((p) =>
+      t("machines.lampGroup", {
+        count: p.machines.length,
+        word: t(STATE_WORD[p.st]),
+        names: p.machines.map((m) => m.label || m.host).join(", "),
+      }),
+    );
+    if (g.working.length > 0)
+      lines.push(
+        t("machines.lampWorking", {
+          count: g.working.length,
+          names: g.working.map((m) => m.label || m.host).join(", "),
+        }),
+      );
+    return lines.join("\n");
+  };
+
+  return (
+    <div ref={anchorRef} className="global-apps-menu header-status-menu-anchor no-drag">
+      <button
+        type="button"
+        className="global-apps-menu-btn machines-indicator-btn"
+        aria-label={t("machines.ariaLabel")}
+        aria-haspopup="menu"
+        aria-expanded={open}
+        title={t("machines.triggerTitle")}
+        // Click, not hover, and not focus either: both used to open the menu,
+        // and opening it sweeps every machine with a real SSH login.
+        onClick={() => setOpen((v) => !v)}
+      >
+        <span className="header-conn-lamps">
+          {lampGroups.map((g) => (
+            <span key={g.lamp} className="conn-lamp-count">
+              <ConnLamp status={g.lamp} busy={g.working.length > 0} label={lampLabel(g)} />
+              {g.machines.length > 1 && (
+                <span className="conn-lamp-count-num">{g.machines.length}</span>
+              )}
+            </span>
+          ))}
+        </span>
+        <span className="vpn-indicator-label">{t("machines.label")}</span>
+      </button>
+      {open && (
+        <div className="tab-new-menu vpn-indicator-menu machines-indicator-menu" role="menu">
+          {/* Pinned title: stays put while the region below it scrolls, so the
+              scrollbar starts beneath the header (unified `.menu-scroll-region`
+              shape). Keeping it OUT of the scroller also spares the accent rail /
+              rounded top from the native scrollbar running over them. */}
+          <div className="tab-new-menu-group-label">{t("machines.groupLabel")}</div>
+          <div className="menu-scroll-region">
+          {ioMode === "export" ? (
+            <div className="vpn-indicator-row menu-form machines-io-panel">
+              <div className="vpn-indicator-note">
+                {t("machines.exportNote")}
+                <UntestedTag />
+              </div>
+              {machines.length === 0 ? (
+                <div className="vpn-indicator-empty">{t("machines.nothingToExport")}</div>
+              ) : (
+                <>
+                <label
+                  className="vpn-indicator-auto machines-io-pick machines-io-pick-all"
+                  title={t(allExportSelected ? "machines.deselectAllTitle" : "machines.selectAllTitle")}
+                >
+                  <Toggle checked={allExportSelected} onChange={toggleExportSelAll} size="sm" />
+                  <span>{t(allExportSelected ? "machines.deselectAll" : "machines.selectAll")}</span>
+                </label>
+                {machines.map((m) => (
+                  <label
+                    key={m.id}
+                    className="vpn-indicator-auto machines-io-pick"
+                    title={targetLabel(m)}
+                  >
+                    <Toggle
+                      checked={exportSel.has(m.id)}
+                      onChange={() => toggleExportSel(m.id)}
+                      size="sm"
+                    />
+                    <span>
+                      {m.label || m.host}
+                      <span className="machines-io-addr">
+                        {`${m.host}${m.port ? `:${m.port}` : ""}`}
+                      </span>
+                    </span>
+                  </label>
+                ))}
+                </>
+              )}
+              {ioError && <div className="vpn-indicator-error">{ioError}</div>}
+              <div className="vpn-indicator-actions">
+                <button
+                  type="button"
+                  className="vpn-indicator-connect"
+                  disabled={ioBusy || exportSel.size === 0}
+                  onClick={() => void doExport()}
+                >
+                  {ioBusy ? t("machines.saving") : t("machines.exportN", { count: exportSel.size })}
+                </button>
+                <button type="button" className="vpn-indicator-remove" onClick={closeIo}>
+                  {t("common.cancel")}
+                </button>
+              </div>
+            </div>
+          ) : ioMode === "import" ? (
+            <div className="vpn-indicator-row menu-form machines-io-panel">
+              {importResult ? (
+                <>
+                  <div className="vpn-indicator-note">
+                    {t(
+                      importResult.length === 1 ? "machines.importedOne" : "machines.importedMany",
+                      { count: importResult.length },
+                    )}{" "}
+                    {t("machines.importedOutcome", {
+                      ok: importResult.filter((r) => r.ok).length,
+                      bad: importResult.filter((r) => !r.ok).length,
+                    })}
+                  </div>
+                  <div className="machines-io-results">
+                    {importResult.map((r, i) => (
+                      <div key={`${r.host}-${i}`} className="machines-io-result-row">
+                        <ConnLamp status={r.ok ? "connected" : "error"} label={r.host} />
+                        <span>{r.label || r.host}</span>
+                      </div>
+                    ))}
+                  </div>
+                  <div className="vpn-indicator-actions">
+                    <button type="button" className="vpn-indicator-connect" onClick={closeIo}>
+                      {t("machines.done")}
+                    </button>
+                  </div>
+                </>
+              ) : (
+                <>
+                  <div className="vpn-indicator-note">
+                    {ioBusy && importEntries.length === 0
+                      ? t("machines.readingFile")
+                      : t(
+                          importEntries.length === 1
+                            ? "machines.importCountOne"
+                            : "machines.importCountMany",
+                          { count: importEntries.length },
+                        )}
+                    <UntestedTag />
+                  </div>
+                  {importEntries.length > 0 && (
+                    <div className="machines-io-preview">
+                      {importEntries.map((e, i) => (
+                        <div key={`${e.host}-${i}`} className="machines-io-addr">
+                          {`${e.user ? `${e.user}@` : ""}${e.host}${e.port ? `:${e.port}` : ""}`}
+                          {e.label ? ` — ${e.label}` : ""}
+                        </div>
+                      ))}
+                    </div>
+                  )}
+                  <label>
+                    {t("machines.username")}
+                    <input
+                      placeholder={t("machines.importUserPlaceholder")}
+                      value={importUser}
+                      onChange={(e) => setImportUser(e.target.value)}
+                      autoComplete="off"
+                      spellCheck={false}
+                    />
+                  </label>
+                  <label>
+                    {t("machines.password")}
+                    <PasswordInput
+                      placeholder={t("machines.importPasswordPlaceholder")}
+                      value={importPassword}
+                      autoComplete="off"
+                      onChange={(e) => setImportPassword(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter") void doImport();
+                      }}
+                    />
+                  </label>
+                  <label className="vpn-indicator-auto">
+                    <Toggle
+                      checked={importSave}
+                      onChange={(e) => setImportSave(e.target.checked)}
+                      size="sm"
+                    />
+                    <span>
+                      {t("machines.savePassword")}
+                      <UntestedTag />
+                    </span>
+                  </label>
+                  <label
+                    className="vpn-indicator-auto"
+                    title={t("machines.importAutoTitle")}
+                  >
+                    <Toggle
+                      checked={importAuto}
+                      onChange={(e) => setImportAuto(e.target.checked)}
+                      size="sm"
+                    />
+                    <span>
+                      {t("machines.autoConnectLabel")}
+                      <UntestedTag />
+                    </span>
+                  </label>
+                  {ioError && <div className="vpn-indicator-error">{ioError}</div>}
+                  <div className="vpn-indicator-actions">
+                    <button
+                      type="button"
+                      className="vpn-indicator-connect"
+                      disabled={ioBusy || importEntries.length === 0}
+                      onClick={() => void doImport()}
+                    >
+                      {ioBusy ? t("machines.connecting") : t("machines.connectAndImport")}
+                    </button>
+                    <button type="button" className="vpn-indicator-remove" onClick={closeIo}>
+                      {t("common.cancel")}
+                    </button>
+                  </div>
+                </>
+              )}
+            </div>
+          ) : (
+            <>
+          {/* The drag this used to describe does not exist: attaching is the
+              row's ⇥ picker (see the component doc), and the only drag left is a
+              row's grip, which reorders. */}
+          <div className="vpn-indicator-note">
+            <strong>{t("machines.note.strong")}</strong> {t("machines.note.rest")}
+            <UntestedTag />
+          </div>
+
+          {machines.length > 0 && disconnectAllArm ? (
+            <div className="vpn-indicator-row machines-fleet-actions">
+              <div className="vpn-indicator-hint">
+                {t("machines.disconnectAllHint.pre")} <strong>{t("machines.tmuxJobs")}</strong>{" "}
+                {t("machines.disconnectAllHint.post")}
+                <UntestedTag />
+              </div>
+              <div className="vpn-indicator-actions">
+                <button
+                  type="button"
+                  className="vpn-indicator-remove"
+                  onClick={() => {
+                    setDisconnectAllArm(false);
+                    void disconnectAll();
+                  }}
+                >
+                  {t("machines.disconnectAllConfirm")}
+                </button>
+                <button
+                  type="button"
+                  className="vpn-indicator-connect"
+                  onClick={() => setDisconnectAllArm(false)}
+                >
+                  {t("machines.keep")}
+                </button>
+              </div>
+            </div>
+          ) : (
+            /* One icon bar for every fleet-wide action, in the same glyph
+               vocabulary a machine row uses for the same verbs (↻ retry, ⏻
+               disconnect) — so "all machines" reads as the row action applied
+               to the list, not as a different feature with its own wording.
+               The usage report joins it (▥, the system-monitor glyph): it used
+               to open itself after every remote connect, putting a modal in
+               front of someone who had asked for something else. It is on
+               demand now, and this is the only thing that opens it. Its subject
+               is THIS list — a section per machine, in this menu's order — plus
+               the active project's own hosts that aren't in it
+               (`RemoteUsageWarningDialog`); each is read afresh as the dialog
+               appears. */
+            <div className="vpn-indicator-row vpn-indicator-actions machines-fleet-actions machines-fleet-icons">
+              {machines.length > 0 && (
+                <button
+                  type="button"
+                  className="machines-row-action is-accent"
+                  disabled={retryAllBusy}
+                  aria-label={t("machines.retryAllAria")}
+                  title={t("machines.retryAllTitle")}
+                  onClick={() => void runRetryAll()}
+                >
+                  {retryAllBusy ? "⋯" : "↻"}
+                </button>
+              )}
+              {machines.length > 0 && connectedCount > 0 && (
+                <button
+                  type="button"
+                  className="machines-row-action is-danger"
+                  aria-label={t("machines.disconnectAllAria")}
+                  title={t("machines.disconnectAllTitle")}
+                  onClick={() => setDisconnectAllArm(true)}
+                >
+                  ⏻
+                </button>
+              )}
+              <button
+                type="button"
+                className="machines-row-action"
+                aria-label={t("machines.usageAria")}
+                title={t("machines.usageTitle")}
+                onClick={() => {
+                  setOpen(false);
+                  openUsage();
+                }}
+              >
+                ▥
+              </button>
+              <UntestedTag />
+            </div>
+          )}
+
+          {machines.length === 0 && (
+            <div className="vpn-indicator-row">
+              <div className="vpn-indicator-empty">{t("machines.empty")}</div>
+            </div>
+          )}
+          {/* While a row is dragged, the others PART to open its landing slot: a
+              row the dragged one has passed slides back by exactly the dragged
+              row's height (removing it from above lifts them; inserting it above
+              drops them — the same distance either way, whatever their own
+              heights). It is a `transform`, so no layout moves and the rects
+              measured at pointerdown stay valid. */}
+          {machines.map((m, idx) => {
+            const st = status[m.id] ?? "off";
+            const hpc = isHpcHost(settings, targetOfSpec(m));
+            // The row's actual state, from BOTH maps — see `RowState`. This is
+            // the only place a stale green (a session we opened, on a host that
+            // no longer answers) can be caught: nothing downgrades `status` any
+            // more, because nothing but an explicit action writes it.
+            const state = stateOf(m);
+            const badge = STATE_BADGE[state];
+            // "Not checked" has two different reasons and the row must say which:
+            // a tagged cluster is never in any sweep, so its answer will stay
+            // unknown until the Check button is pressed.
+            const stateTip =
+              state === "unknown" && hpc ? t("machines.tip.unknownHpc") : t(STATE_TIP[state]);
+            // Only a machine we hold a LIVE session on pulses: a reading taken
+            // before it dropped says nothing about it now — and a stale row is by
+            // definition one whose session may already be gone.
+            const busy = state === "connected" ? busyReading({ readings }, m) : null;
+            const name = m.label || m.host;
+            // `ConnLamp`'s own tooltip is "<label>: <colour>", and most states
+            // share their colour with another (red covers error and stale, grey
+            // covers all three sessionless ones) — for those the label carries
+            // the word the colour cannot.
+            const lampText = LAMP_SAYS_IT.has(state) ? name : `${name} — ${t(STATE_WORD[state])}`;
+            // Both error channels on one line, freshest first: this component's
+            // (the explicit HPC login), then a Check newer than the last sweep,
+            // then the store's — a failed connect, a failed probe, and now also
+            // `setAutoConnect`'s "auto-connect not saved: …".
+            const check = checked[m.id];
+            const rowError =
+              localErrors[m.id] ??
+              (check && check.at >= sweepAt ? check.error : undefined) ??
+              errors[m.id];
+            const dragH = reorderDrag
+              ? (dragRects.current.find((r) => r.id === reorderDrag.id)?.height ?? 0)
+              : 0;
+            const dragFrom = reorderDrag ? machines.findIndex((mm) => mm.id === reorderDrag.id) : -1;
+            const shift =
+              !reorderDrag || idx === dragFrom
+                ? 0
+                : idx > dragFrom && idx <= reorderDrag.to
+                  ? -dragH
+                  : idx < dragFrom && idx >= reorderDrag.to
+                    ? dragH
+                    : 0;
+            // A row shows its icon actions only while nothing has taken the row
+            // over: an armed confirm (remove/disconnect), the retry password
+            // field, or the edit form each replace them with worded buttons.
+            const rowFormOpen =
+              retryId === m.id ||
+              removeArm === m.id ||
+              disconnectArm === m.id ||
+              editId === m.id ||
+              attachId === m.id;
+            return (
+              <div
+                key={m.id}
+                ref={(el) => {
+                  if (el) rowRefs.current.set(m.id, el);
+                  else rowRefs.current.delete(m.id);
+                }}
+                className={`vpn-indicator-row machines-indicator-row${
+                  reorderDrag?.id === m.id ? " reorder-dragging" : reorderDrag ? " reorder-parting" : ""
+                }`}
+                style={
+                  reorderDrag?.id === m.id
+                    ? { transform: `translateY(${reorderDrag.dy}px)` }
+                    : shift
+                      ? { transform: `translateY(${shift}px)` }
+                      : undefined
+                }
+              >
+                <div className="vpn-indicator-head">
+                  <button
+                    type="button"
+                    className="machines-row-grip"
+                    aria-label={t("machines.gripAria")}
+                    title={t("machines.gripTitle")}
+                    onPointerDown={(e) => startReorderDrag(m.id, e)}
+                    onPointerMove={moveReorderDrag}
+                    onPointerUp={(e) => endReorderDrag(e, true)}
+                    onPointerCancel={(e) => endReorderDrag(e, false)}
+                    onKeyDown={(e) => {
+                      if (e.key !== "ArrowUp" && e.key !== "ArrowDown") return;
+                      e.preventDefault();
+                      nudgeMachine(m.id, e.key === "ArrowUp" ? -1 : 1);
+                    }}
+                  >
+                    ⠿
+                  </button>
+                  <ConnLamp
+                    status={STATE_LAMP[state]}
+                    busy={busy !== null}
+                    label={busy ? `${lampText} — ${busyLabel(busy)}` : lampText}
+                  />
+                  <span className="vpn-indicator-config" title={`${targetLabel(m)}\n${stateTip}`}>
+                    {name}
+                  </span>
+                  {/* The HPC tag, on the row itself — the whole point of a tag
+                      that switches off background work is being able to see, at a
+                      glance over the machine list, which machines it is off for. */}
+                  {hpc && (
+                    <span className="hpc-badge" title={t("machines.hpcBadgeTitle")}>
+                      HPC
+                    </span>
+                  )}
+                  {/* The word the grey dot can't say. Only for the states a lamp
+                      colour leaves ambiguous, so a connected row stays clean and
+                      a long list stays scannable. Wearing `.hpc-badge`'s pill
+                      shape deliberately: this change owns no CSS, and the extra
+                      `machines-state-badge is-<state>` classes are the seam a
+                      per-state tint can be hung on later. */}
+                  {badge && (
+                    <span
+                      className={`hpc-badge machines-state-badge is-${state}`}
+                      title={stateTip}
+                    >
+                      {t(badge)}
+                    </span>
+                  )}
+                  {!rowFormOpen && (
+                    <div className="machines-row-actions">
+                      {/* The connect, and — for a tagged cluster — the ONLY way it
+                          ever gets connected or probed from here at all. Every
+                          sweep skips it by design, so its row has to carry the
+                          gestures the fleet actions no longer make on its behalf:
+                          this button and the Check beside it. */}
+                      <button
+                        type="button"
+                        className="machines-row-action is-accent"
+                        aria-label={t(
+                          state === "error"
+                            ? "machines.retryAria"
+                            : hpc
+                              ? "machines.hpcLoginAria"
+                              : st === "connected"
+                                ? "machines.reconnectAria"
+                                : "machines.connectAria",
+                        )}
+                        title={t(
+                          state === "error"
+                            ? "machines.retryTitle"
+                            : hpc
+                              ? "machines.hpcLoginTitle"
+                              : state === "stale"
+                                ? "machines.reconnectStaleTitle"
+                                : st === "connected"
+                                  ? "machines.reconnectTitle"
+                                  : "machines.connectTitle",
+                        )}
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          if (state === "error") startRetry(m.id);
+                          // A tagged machine goes through this component's own
+                          // connect, which marks itself a gesture (`background:
+                          // false`) — the store's is a background-defaulted call
+                          // the backend is right to refuse on a login node.
+                          else if (hpc) void explicitConnect(m);
+                          else void connect(m.id);
+                        }}
+                        disabled={st === "connecting"}
+                      >
+                        {st === "connected" || state === "error" ? "↻" : "▷"}
+                      </button>
+                      {/* Ask this one host whether it answers, because the user
+                          asked. It is the only reachability a tagged machine has
+                          (no sweep will ever probe one), and on any other machine
+                          it re-asks a question the 60s sweep interval is holding. */}
+                      <button
+                        type="button"
+                        className="machines-row-action"
+                        aria-label={t("machines.checkAria")}
+                        title={t(hpc ? "machines.checkTitleHpc" : "machines.checkTitle")}
+                        disabled={checking.has(m.id)}
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          void runCheck(m);
+                        }}
+                      >
+                        {checking.has(m.id) ? "⋯" : "◎"}
+                      </button>
+                      {st === "connected" && (
+                        <button
+                          type="button"
+                          className="machines-row-action is-danger"
+                          aria-label={t("machines.disconnectAria")}
+                          title={t("machines.disconnectTitle")}
+                          onClick={(e) => {
+                            e.stopPropagation();
+                            setDisconnectArm(m.id);
+                          }}
+                        >
+                          ⏻
+                        </button>
+                      )}
+                      <button
+                        type="button"
+                        className="machines-row-action"
+                        aria-label={t("machines.attachAria")}
+                        title={t("machines.attachTitle")}
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setAttachId(m.id);
+                        }}
+                      >
+                        ⇥
+                      </button>
+                      <button
+                        type="button"
+                        className="machines-row-action"
+                        aria-label={t("machines.editAria")}
+                        title={t("machines.editTitle")}
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          startEdit(m);
+                        }}
+                      >
+                        ✎
+                      </button>
+                      <button
+                        type="button"
+                        className="machines-row-action is-danger"
+                        aria-label={t("machines.removeAria")}
+                        title={t("machines.removeTitle")}
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setRemoveArm(m.id);
+                        }}
+                      >
+                        ✕
+                      </button>
+                    </div>
+                  )}
+                  <button
+                    type="button"
+                    className="machines-row-expand-btn"
+                    aria-label={t(expandedIds.has(m.id) ? "machines.hideDetailsAria" : "machines.showDetailsAria")}
+                    aria-expanded={expandedIds.has(m.id)}
+                    title={t(expandedIds.has(m.id) ? "machines.hideDetailsTitle" : "machines.showDetailsTitle")}
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      toggleExpanded(m.id);
+                    }}
+                  >
+                    {expandedIds.has(m.id) ? "▾" : "▸"}
+                  </button>
+                </div>
+                {/* Why the row says what it says — shown as soon as anything
+                    fails, not only once the user opens Retry. This is what tells
+                    apart a stale saved password from an unknown host key from the
+                    host simply being off the network, none of which a colour says
+                    on its own (see `stores/globalMachines`' `errors`). No longer
+                    gated on `error`: the same map now also carries a failed
+                    *probe*'s reason (an unreachable row that can explain itself)
+                    and `setAutoConnect`'s "auto-connect not saved: …", which used
+                    to be nothing but a toggle springing silently back. Also still
+                    the only place an auto-connect failure at launch explains
+                    itself — `autoConnect` never opens a modal. */}
+                {rowError && !rowFormOpen && (
+                  <div className="vpn-indicator-error machines-row-error">{rowError}</div>
+                )}
+                {expandedIds.has(m.id) && (
+                  <>
+                    <div className="vpn-indicator-holders">{targetLabel(m)}</div>
+                    <button
+                      type="button"
+                      className="vpn-indicator-connect machines-monitor-btn"
+                      title={t("machines.systemMonitorTitle")}
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        openMonitor({ id: m.id, user: m.user, host: m.host, port: m.port, label: m.label });
+                      }}
+                    >
+                      {t("machines.systemMonitor")}
+                    </button>
+                    <label className="vpn-indicator-auto" title={t("machines.autoConnectTitle")}>
+                      <Toggle
+                        // The EFFECTIVE value, not the stored flag. A tagged
+                        // machine is never in the launch/VPN-up sweep whatever
+                        // `auto_connect` says (`stores/globalMachines`'
+                        // `autoConnect` filters it out), so rendering a stored
+                        // `true` showed it armed-and-frozen: a promise the app
+                        // does not keep, on a control disabled from clearing it.
+                        checked={m.auto_connect === true && !hpc}
+                        onChange={(e) => void setAutoConnect(m.id, e.target.checked)}
+                        size="sm"
+                        disabled={hpc}
+                      />
+                      <span>
+                        {t("machines.autoConnectLabel")}
+                        {hpc && (
+                          <span className="machines-auto-blocked">
+                            {" "}
+                            {t("machines.autoBlockedHpc")}
+                          </span>
+                        )}
+                        <UntestedTag />
+                      </span>
+                    </label>
+                    {/* Where the tag is set for a machine already in the list. The
+                        login form has the same tick, so a cluster can be tagged as
+                        it is added; this is for one that is already here — and it
+                        is per machine, because that is the only scope at which the
+                        question ("is this a shared cluster?") has an answer. */}
+                    <label className="vpn-indicator-auto" title={t("machines.hpcToggleTitle")}>
+                      <Toggle
+                        checked={hpc}
+                        onChange={(e) => {
+                          const target = targetOfSpec(m);
+                          if (!target) return;
+                          const tagged = e.target.checked;
+                          void (async () => {
+                            await updateSettings(setHpcPatch(settings, target, tagged));
+                            // Tagging DISARMS the machine on disk, so the stored
+                            // state matches what the (now disabled) toggle above
+                            // claims. Otherwise a `true` survives out of reach of
+                            // every UI, for the sweep to keep filtering out — and
+                            // untagging the machine later would silently re-arm a
+                            // launch-time connect nobody asked for twice.
+                            if (tagged && m.auto_connect) await setAutoConnect(m.id, false);
+                          })();
+                        }}
+                        size="sm"
+                      />
+                      <span>
+                        {t("machines.hpcToggleLabel")}
+                        <UntestedTag />
+                      </span>
+                    </label>
+                  </>
+                )}
+                {attachId === m.id ? (
+                  <div className="vpn-indicator-row menu-form machines-attach-form">
+                    <div className="vpn-indicator-hint">
+                      {t("machines.attachQuestionPre")} <strong>{name}</strong>{" "}
+                      {t("machines.attachQuestionPost")}
+                      <UntestedTag />
+                    </div>
+                    {projects.length === 0 && (
+                      <div className="vpn-indicator-empty">{t("machines.noActiveProject")}</div>
+                    )}
+                    {projects.map((p) => (
+                      <button
+                        key={p.id}
+                        type="button"
+                        className="vpn-indicator-connect machines-attach-project"
+                        title={t(
+                          p.remote ? "machines.attachRemoteTitle" : "machines.attachLocalTitle",
+                        )}
+                        onClick={() => {
+                          setAttachId(null);
+                          setOpen(false);
+                          attachToProject(p, m);
+                        }}
+                      >
+                        {p.name}
+                        <span className="machines-attach-kind">
+                          {t(p.remote ? "machines.attachKindCompute" : "machines.attachKindExtend")}
+                        </span>
+                      </button>
+                    ))}
+                    <button type="button" className="vpn-indicator-remove" onClick={() => setAttachId(null)}>
+                      {t("common.cancel")}
+                    </button>
+                  </div>
+                ) : retryId === m.id ? (
+                  <div className="vpn-indicator-row menu-form machines-retry-form">
+                    {errors[m.id] && <div className="vpn-indicator-error">{errors[m.id]}</div>}
+                    <input
+                      placeholder={t("machines.sshUsernamePlaceholder")}
+                      value={retryUser}
+                      onChange={(e) => setRetryUser(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter") void submitRetry(m.id);
+                      }}
+                      autoComplete="off"
+                      spellCheck={false}
+                    />
+                    <PasswordInput
+                      placeholder={t("machines.sshPasswordPlaceholder")}
+                      value={retryPassword}
+                      autoComplete="off"
+                      onChange={(e) => setRetryPassword(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter") void submitRetry(m.id);
+                      }}
+                    />
+                    {retryError && <div className="vpn-indicator-error">{retryError}</div>}
+                    <div className="vpn-indicator-actions">
+                      <button type="button" className="vpn-indicator-connect" onClick={() => void submitRetry(m.id)}>
+                        {t("machines.retry")}
+                      </button>
+                      <button type="button" className="vpn-indicator-remove" onClick={() => setRetryId(null)}>
+                        {t("common.cancel")}
+                      </button>
+                    </div>
+                  </div>
+                ) : removeArm === m.id ? (
+                  <div className="vpn-indicator-actions">
+                    <div className="vpn-indicator-hint">
+                      {st === "connected" || st === "connecting" ? (
+                        <>
+                          {t("machines.removeHintLive.pre")}{" "}
+                          <strong>{t("machines.tmuxJobs")}</strong>{" "}
+                          {t("machines.removeHintLive.post")}
+                          <UntestedTag />
+                        </>
+                      ) : (
+                        t("machines.removeHintIdle")
+                      )}
+                    </div>
+                    <button type="button" className="vpn-indicator-remove" onClick={() => void remove(m.id)}>
+                      {t("common.remove")}
+                    </button>
+                    <button type="button" className="vpn-indicator-connect" onClick={() => setRemoveArm(null)}>
+                      {t("machines.keep")}
+                    </button>
+                  </div>
+                ) : disconnectArm === m.id ? (
+                  <div className="vpn-indicator-actions">
+                    <div className="vpn-indicator-hint">
+                      {t("machines.disconnectHint.pre")} <strong>{t("machines.tmuxJobs")}</strong>{" "}
+                      {t("machines.disconnectHint.post")}
+                      <UntestedTag />
+                    </div>
+                    <button
+                      type="button"
+                      className="vpn-indicator-remove"
+                      onClick={() => {
+                        setDisconnectArm(null);
+                        void disconnect(m.id);
+                      }}
+                    >
+                      {t("machines.disconnectConfirm")}
+                    </button>
+                    <button type="button" className="vpn-indicator-connect" onClick={() => setDisconnectArm(null)}>
+                      {t("machines.keep")}
+                    </button>
+                  </div>
+                ) : editId === m.id ? (
+                  <div className="vpn-indicator-row menu-form machines-edit-form">
+                    <label>
+                      {t("machines.sshAddress")}
+                      <input
+                        placeholder={t("machines.addressPlaceholder")}
+                        value={editAddress}
+                        onChange={(e) => setEditAddress(e.target.value)}
+                        onKeyDown={(e) => {
+                          if (e.key === "Enter") void submitEdit(m.id);
+                        }}
+                        spellCheck={false}
+                        autoFocus
+                      />
+                    </label>
+                    <label>
+                      {t("machines.username")}
+                      <input
+                        placeholder={t("machines.usernamePlaceholder")}
+                        value={editUser}
+                        onChange={(e) => setEditUser(e.target.value)}
+                        autoComplete="off"
+                        spellCheck={false}
+                      />
+                    </label>
+                    <label>
+                      {t("machines.password")}
+                      <PasswordInput
+                        placeholder={t("machines.editPasswordPlaceholder")}
+                        value={editPassword}
+                        autoComplete="off"
+                        onChange={(e) => setEditPassword(e.target.value)}
+                        onKeyDown={(e) => {
+                          if (e.key === "Enter") void submitEdit(m.id);
+                        }}
+                      />
+                    </label>
+                    <label className="vpn-indicator-auto">
+                      <Toggle checked={editSave} onChange={(e) => setEditSave(e.target.checked)} size="sm" />
+                      <span>
+                        {t("machines.savePassword")}
+                        <UntestedTag />
+                      </span>
+                    </label>
+                    <label>
+                      {t("machines.labelOptional")}
+                      <input
+                        placeholder={t("machines.labelPlaceholder")}
+                        value={editLabel}
+                        onChange={(e) => setEditLabel(e.target.value)}
+                        spellCheck={false}
+                      />
+                    </label>
+                    {editError && <div className="vpn-indicator-error">{editError}</div>}
+                    <div className="vpn-indicator-actions">
+                      <button
+                        type="button"
+                        className="vpn-indicator-connect"
+                        disabled={editBusy}
+                        onClick={() => void submitEdit(m.id)}
+                      >
+                        {editBusy ? t("machines.saving") : t("machines.saveChanges")}
+                      </button>
+                      <button type="button" className="vpn-indicator-remove" onClick={() => setEditId(null)}>
+                        {t("common.cancel")}
+                      </button>
+                    </div>
+                  </div>
+                ) : null}
+              </div>
+            );
+          })}
+
+          <div className="tab-new-menu-group-label">{t("machines.addGroupLabel")}</div>
+          {adding ? (
+            <div className="vpn-indicator-row menu-form">
+              <label>
+                {t("machines.sshAddress")}
+                <input
+                  placeholder={t("machines.addressPlaceholder")}
+                  value={address}
+                  onChange={(e) => setAddress(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") void submitAdd();
+                  }}
+                  spellCheck={false}
+                  autoFocus
+                />
+              </label>
+              <label>
+                {t("machines.username")}
+                <input
+                  placeholder={t("machines.usernamePlaceholder")}
+                  value={username}
+                  onChange={(e) => setUsername(e.target.value)}
+                  autoComplete="off"
+                  spellCheck={false}
+                />
+              </label>
+              {!addViaTerminal && (
+                <label>
+                  {t("machines.password")}
+                  <PasswordInput
+                    placeholder={t("machines.addPasswordPlaceholder")}
+                    value={password}
+                    autoComplete="off"
+                    onChange={(e) => setPassword(e.target.value)}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter") void submitAdd();
+                    }}
+                  />
+                </label>
+              )}
+              {/* Kept on screen in the terminal path, and *disabled* rather than
+                  hidden: a saved password belongs to the host, and a row that
+                  vanishes reads as one that was discarded. It has nothing to act on
+                  there — the flag only reaches the keychain through `ssh_connect`'s
+                  `remember`, which a terminal login never calls — so an existing
+                  credential is left exactly as it was found. */}
+              <label
+                className="vpn-indicator-auto"
+                title={t(
+                  addViaTerminal
+                    ? "machines.savePasswordTerminalTitle"
+                    : "machines.savePasswordTitle",
+                )}
+              >
+                <Toggle
+                  checked={savePassword}
+                  disabled={addViaTerminal}
+                  onChange={(e) => setSavePassword(e.target.checked)}
+                  size="sm"
+                />
+                <span>
+                  {t("machines.savePassword")}
+                  <UntestedTag />
+                </span>
+              </label>
+              <label
+                className="vpn-indicator-auto"
+                title={t("machines.autoConnectAddTitle")}
+              >
+                <Toggle
+                  checked={addAuto && !addHpc}
+                  disabled={addHpc}
+                  onChange={(e) => setAddAuto(e.target.checked)}
+                  size="sm"
+                />
+                <span>
+                  {t("machines.autoConnectLabel")}
+                  {addHpc && (
+                    <span className="machines-auto-blocked"> {t("machines.autoBlockedHpcAdd")}</span>
+                  )}
+                  <UntestedTag />
+                </span>
+              </label>
+              {/* The tag, at the moment it is actually known: logging in is when
+                  the user knows what they are logging in to. Everything Eldrun
+                  would otherwise do to this machine on its own is gated behind it
+                  (`lib/hpcHost.ts`), so ticking it here means the very first
+                  connect already behaves — nothing scans, nothing polls, and the
+                  monitor reads it lightly from its first sample. */}
+              <label
+                className="vpn-indicator-auto"
+                title={t("machines.hpcAddTitle")}
+              >
+                <Toggle checked={addHpc} onChange={(e) => setAddHpc(e.target.checked)} size="sm" />
+                <span>
+                  {t("machines.hpcToggleLabel")}
+                  <UntestedTag />
+                </span>
+              </label>
+              <label>
+                {t("machines.labelOptional")}
+                <input
+                  placeholder={t("machines.labelPlaceholder")}
+                  value={label}
+                  onChange={(e) => setLabel(e.target.value)}
+                  spellCheck={false}
+                />
+              </label>
+              <TerminalSignInToggle
+                channel="ssh"
+                checked={addViaTerminal}
+                busy={addWaiting}
+                onChange={setAddViaTerminal}
+              />
+              {/* The login is a root-terminal tab, not something in this menu — which
+                  closes the moment the pointer leaves it — so say where it went. */}
+              {addViaTerminal && addWaiting && (
+                <div className="settings-help" role="status">
+                  {t("machines.terminalLoginHint.pre")}{" "}
+                  <strong>{t("machines.rootTerminal")}</strong>{" "}
+                  {t("machines.terminalLoginHint.post")}
+                </div>
+              )}
+              {addError && <div className="vpn-indicator-error">{addError}</div>}
+              <div className="vpn-indicator-actions">
+                {addViaTerminal ? (
+                  <button
+                    type="button"
+                    className="vpn-indicator-connect"
+                    disabled={addWaiting}
+                    title={t("machines.loginInTerminalTitle")}
+                    onClick={() => void startTerminalAdd()}
+                  >
+                    {addWaiting ? t("machines.waitingForLogin") : t("machines.loginInTerminal")}
+                  </button>
+                ) : (
+                  <button type="button" className="vpn-indicator-connect" disabled={addBusy} onClick={() => void submitAdd()}>
+                    {addBusy ? t("machines.connecting") : t("machines.connectAndAdd")}
+                  </button>
+                )}
+                {/* Only after the poll has given up: a login finished late is still a
+                    login, and re-arming beats retyping the whole form. */}
+                {addViaTerminal && !addWaiting && addError && (
+                  <button type="button" className="vpn-indicator-connect" onClick={retryTerminalAdd}>
+                    {t("machines.loggedInAdd")}
+                  </button>
+                )}
+                <button
+                  type="button"
+                  className="vpn-indicator-remove"
+                  onClick={() => {
+                    clearAddPoll();
+                    setAddWaiting(false);
+                    setAdding(false);
+                  }}
+                >
+                  {t("common.cancel")}
+                </button>
+              </div>
+            </div>
+          ) : (
+            <div className="vpn-indicator-row vpn-indicator-browse machines-io-buttons">
+              <button type="button" className="vpn-indicator-connect" onClick={() => setAdding(true)}>
+                {t("machines.addMachine")}
+              </button>
+              <button
+                type="button"
+                className="vpn-indicator-connect"
+                title={t("machines.importTitle")}
+                onClick={() => void startImport()}
+              >
+                {t("machines.import")}
+              </button>
+              <button
+                type="button"
+                className="vpn-indicator-connect"
+                disabled={machines.length === 0}
+                title={t("machines.exportTitle")}
+                onClick={startExport}
+              >
+                {t("machines.export")}
+              </button>
+            </div>
+          )}
+            </>
+          )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/header/RemoteConnMenu.tsx b/src/components/header/RemoteConnMenu.tsx
new file mode 100644
index 0000000..cb39a4d
--- /dev/null
+++ b/src/components/header/RemoteConnMenu.tsx
@@ -0,0 +1,143 @@
+import { ConnLamp } from "../common/ConnLamp";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { useHostBusyStore, isBusy } from "../../stores/hostBusy";
+import type { ConnState } from "../../stores/remoteStatus";
+import type { ProjectEntry } from "../../types";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+/**
+ * A remote project's live SSH status, rendered on the project's pill.
+ *
+ * A project can reach many hosts (the primary plus extra "worker" machines,
+ * multi-host remote, `docs/multi_host_remote_plan.md`). Rather than one lamp
+ * per host — a long row of near-identical dots once a project has several
+ * machines — the hosts are **aggregated by status**: one lamp per distinct
+ * state (connected / connecting / error / off), each carrying the count of
+ * hosts in that state, and a state with no hosts shows no lamp. So four
+ * connected machines read as a single green lamp badged "4", and a mixed fleet
+ * reads as one lamp per colour that is actually present. The count badge is
+ * shown only when a group holds more than one host, so the common
+ * single-primary project still shows a plain lamp.
+ *
+ * OpenVPN is machine-wide, not project-scoped, so its lamp lives only in the
+ * header's `VpnIndicator` — this menu tracks SSH alone. Clicking opens the one
+ * unified "Remote machines" hub (`RemoteMachinesWindow`), which lists every
+ * host with an entry apiece plus Add-a-machine; the per-host Connect/Manage
+ * there opens the centered Connect detail (`RemoteConnectDialog`). The pill
+ * stays status + open-hub only.
+ *
+ * Remote projects start DISCONNECTED — they are not auto-connected on launch or
+ * switch (that raced the tab restore and hung). Local tabs still restore and
+ * work on the mirror while disconnected; only remote panes wait for the pool,
+ * which the modal brings up.
+ */
+
+/** Lamp order — most-relevant state first, so a fleet with any error/connecting
+ *  host surfaces that colour ahead of the steady-state green/grey. */
+const STATUS_ORDER: ConnState[] = ["error", "connecting", "connected", "off"];
+
+const STATUS_WORD_KEY: Record<ConnState, TranslationKey> = {
+  error: "remoteConnMenu.statusError",
+  connecting: "remoteConnMenu.statusConnecting",
+  connected: "remoteConnMenu.statusConnected",
+  off: "remoteConnMenu.statusOff",
+};
+
+export function RemoteConnMenu({ project, compact }: { project: ProjectEntry; compact?: boolean }) {
+  const t = useT();
+  const STATUS_WORD: Record<ConnState, string> = {
+    error: t(STATUS_WORD_KEY.error),
+    connecting: t(STATUS_WORD_KEY.connecting),
+    connected: t(STATUS_WORD_KEY.connected),
+    off: t(STATUS_WORD_KEY.off),
+  };
+  const status = useRemoteStatusStore((s) => s.byProject[project.id]);
+  const byHost = useRemoteStatusStore((s) => s.byHost[project.id]);
+  const openHub = useRemoteMachinesStore((s) => s.open);
+  const readings = useHostBusyStore((s) => s.readings);
+  const primarySsh = status?.ssh ?? "off";
+  const host = project.remote?.host ?? "";
+  const hostLabel = project.remote?.label || host;
+  const workers = project.compute_hosts ?? [];
+
+  // Every host this project reaches, tagged with its live SSH state and whether
+  // it is **working** (≥1 tmux session, `stores/hostBusy`) — the primary first,
+  // then each worker.
+  //
+  // The busy half is read from the cache and never probed here: these lamps are
+  // always on screen, so probing from them would be a background poll of every
+  // host of every open project — exactly the traffic the busy reading is
+  // designed not to cost. The sweeps live in the surfaces you deliberately open
+  // (the header Machines menu, the Remote-machines hub this button opens), and a
+  // reading goes stale rather than lying.
+  const hosts: { label: string; ssh: ConnState; busy: boolean }[] = [
+    {
+      label: hostLabel,
+      ssh: primarySsh,
+      busy: isBusy({ readings }, project.remote, primarySsh === "connected"),
+    },
+    ...workers.map((w) => {
+      const ssh = byHost?.[w.id]?.ssh ?? ("off" as ConnState);
+      return {
+        label: w.label || w.host || w.id,
+        ssh,
+        busy: isBusy({ readings }, w, ssh === "connected"),
+      };
+    }),
+  ];
+
+  // Group the hosts by state so each colour is drawn once, with a count. Busy
+  // folds into the existing green lamp rather than adding a second one — the
+  // pill's lamp strip is the tightest space in the UI and must not grow with the
+  // fleet. The count of working hosts rides the tooltip; the per-host answer is
+  // in the hub this button opens.
+  const groups = STATUS_ORDER.map((st) => {
+    const inState = hosts.filter((h) => h.ssh === st);
+    return { st, hosts: inState, working: inState.filter((h) => h.busy) };
+  }).filter((g) => g.hosts.length > 0);
+
+  const title = groups
+    .map(
+      (g) =>
+        `${g.hosts.length} ${STATUS_WORD[g.st]}: ${g.hosts.map((h) => h.label).join(", ")}` +
+        (g.working.length > 0
+          ? `\n${g.working.length} ${t("remoteConnMenu.workingWord")}: ${g.working.map((h) => h.label).join(", ")}`
+          : ""),
+    )
+    .join("\n");
+
+  return (
+    <div
+      className={`header-conn-menu${compact ? " header-conn-menu-compact" : ""}`}
+      onPointerDown={(e) => e.stopPropagation()}
+    >
+      <button
+        type="button"
+        className="header-conn-lamps no-drag"
+        aria-label={t("remoteConnMenu.ariaLabel")}
+        title={title}
+        onClick={(e) => {
+          e.stopPropagation();
+          openHub(project.id);
+        }}
+      >
+        {groups.map((g) => (
+          <span key={g.st} className="conn-lamp-count">
+            <ConnLamp
+              status={g.st}
+              busy={g.working.length > 0}
+              label={
+                `${g.hosts.length} ${STATUS_WORD[g.st]} — ${g.hosts.map((h) => h.label).join(", ")}` +
+                (g.working.length > 0 ? ` (${g.working.length} ${t("remoteConnMenu.workingWord")})` : "")
+              }
+            />
+            {g.hosts.length > 1 && (
+              <span className="conn-lamp-count-num">{g.hosts.length}</span>
+            )}
+          </span>
+        ))}
+      </button>
+    </div>
+  );
+}
diff --git a/src/components/header/StatusLamp.tsx b/src/components/header/StatusLamp.tsx
deleted file mode 100644
index cde6c57..0000000
--- a/src/components/header/StatusLamp.tsx
+++ /dev/null
@@ -1,14 +0,0 @@
-interface Props {
-  online: boolean;
-}
-
-export function StatusLamp({ online }: Props) {
-  return (
-    <span
-      className={`status-lamp ${online ? "status-online" : "status-offline"}`}
-      title={online ? "Online" : "Offline"}
-    >
-      ●
-    </span>
-  );
-}
diff --git a/src/components/header/VpnIndicator.tsx b/src/components/header/VpnIndicator.tsx
new file mode 100644
index 0000000..16e0915
--- /dev/null
+++ b/src/components/header/VpnIndicator.tsx
@@ -0,0 +1,801 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { open as openDialog } from "@tauri-apps/plugin-dialog";
+import { ConnLamp } from "../common/ConnLamp";
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { isVpnTerminalHandoff, useVpnPromptStore } from "../../stores/vpnPrompt";
+import { anyVpnLive, disconnectVpnTunnel, useVpnStatusStore } from "../../stores/vpnStatus";
+import { canConnectVpnSilently, connectVpnSilently } from "../../lib/vpnConnect";
+import {
+  fileOf,
+  isVpnCredentialSaved,
+  openVpnLoginInTerminal,
+  setVpnAutoConnect,
+  setVpnCredentialSaved,
+  syncVpnCredentialSaved,
+  vpnUsernameFor,
+} from "../../lib/vpnAutoConnect";
+import { keyringState, unlockKeyring, type KeyringState } from "../../lib/keyring";
+import type { StoredVpnConfig } from "../../types";
+import { useT } from "../../lib/i18n";
+
+/**
+ * Bound a backend call so it can never strand the connect at amber. The silent-connect
+ * probe (`vpn_can_connect_silently`) reads the OS keychain, and a Secret Service
+ * collection that is *locked* makes that read block on an unlock that, headless, never
+ * comes — so the very first `await` in `connect` hangs, the lamp sits "connecting"
+ * forever, and the password modal (which is only reached *after* this probe) is never
+ * shown. On timeout we take `fallback` and move on; here that is "not silent", so the
+ * connect drops straight to the modal instead of waiting on the keyring.
+ */
+function withTimeout<T>(p: Promise<T>, ms: number, fallback: T): Promise<T> {
+  return new Promise<T>((resolve) => {
+    let settled = false;
+    const done = (v: T) => {
+      if (settled) return;
+      settled = true;
+      resolve(v);
+    };
+    const timer = setTimeout(() => done(fallback), ms);
+    p.then(
+      (v) => {
+        clearTimeout(timer);
+        done(v);
+      },
+      () => {
+        clearTimeout(timer);
+        done(fallback);
+      },
+    );
+  });
+}
+
+/** Stable empty list for the `vpn_saved_configs` selector — a fresh `[]` per render
+ *  would make the zustand subscription fire on every store change. */
+const NO_SAVED: string[] = [];
+
+/**
+ * The machine's OpenVPN control, in the header — where a machine-level thing belongs.
+ *
+ * Every other VPN surface in Eldrun hangs off a project: the toggle is in that
+ * project's Connect dialog, the lamp is on its pill, and both vanish the moment you
+ * switch away. The tunnel does not vanish. It runs as root, Eldrun passes it no
+ * routing flags, and a typical `.ovpn` pushes `redirect-gateway` — so while it is
+ * up, *this computer's* traffic goes through it, browser and all, whether or not
+ * the project that asked for it is still on screen.
+ *
+ * So it is always here, whether or not a tunnel is up: dim when nothing is running,
+ * lit when something is. It lists every stored config and can bring one **up** as
+ * well as down — a VPN is a thing you use, not only a precondition for an SSH
+ * project, and requiring one to own a project just to reach the tunnel was backwards.
+ * A tunnel started here has no holder; it is simply up (see `vpnStatus`).
+ */
+export function VpnIndicator() {
+  const t = useT();
+  const byConfig = useVpnStatusStore((s) => s.byConfig);
+  const holders = useVpnStatusStore((s) => s.holders);
+  const refresh = useVpnStatusStore((s) => s.refresh);
+  const setVpnState = useVpnStatusStore((s) => s.setState);
+  const projects = useProjectsStore((s) => s.projects);
+  const requestPassword = useVpnPromptStore((s) => s.request);
+
+  const armed = useSettingsStore((s) => s.settings?.vpn_auto_connect ?? null);
+  // Which configs the user asked us to remember. Read reactively so the save toggle
+  // reflects a click immediately, and from *settings* rather than the keychain for
+  // the reason `isVpnCredentialSaved` documents: a locked keychain would report every
+  // one of them as unsaved. `NO_SAVED` keeps the selector identity-stable.
+  const savedConfigs = useSettingsStore((s) => s.settings?.vpn_saved_configs ?? NO_SAVED);
+  const headless = useSettingsStore((s) => s.settings?.connections_headless ?? true);
+  // Off by default (Settings' "Remote features") — most projects are local-only,
+  // so this machine-wide tunnel control stays out of the header until asked for.
+  const enabled = useSettingsStore((s) => s.settings?.vpn_enabled ?? false);
+
+  const [open, setOpen] = useState(false);
+  const [configs, setConfigs] = useState<StoredVpnConfig[]>([]);
+  const [error, setError] = useState("");
+  // Per config: can it be brought up with no prompt at all? Only then may it be armed
+  // to connect on launch, since auto-connect promises never to prompt. Refreshed each
+  // time the menu opens — the credentials can be saved or forgotten between openings.
+  const [silent, setSilent] = useState<Record<string, boolean>>({});
+  // Whether the OS credential store can be read at all. A **locked** one answers every
+  // "is a password saved?" with "no", so without this the menu would report every
+  // saved credential as missing and quietly go back to prompting — the bug this whole
+  // block exists for. `unlocking` guards the (system-modal) unlock click.
+  const [keyring, setKeyring] = useState<KeyringState>("unlocked");
+  const [unlocking, setUnlocking] = useState(false);
+  // Config path whose Remove is awaiting its second, confirming click. Removal
+  // also forgets the config's saved credentials, and those are not recoverable
+  // by re-browsing the file — hence armed, not single-click.
+  const [removeArm, setRemoveArm] = useState<string | null>(null);
+  const closeTimer = useRef<number | undefined>(undefined);
+  // Configs whose in-flight connect the user has hit Stop on. The connect runs
+  // async across several awaits (a silent attempt blocks up to the backend's 45 s
+  // handshake timeout), and `refresh` preserves a `connecting` entry forever, so a
+  // wedged attempt needs an explicit escape hatch — this flag is it. A connect
+  // checks it after each await and stands down instead of flipping the lamp green.
+  const abortedRef = useRef<Set<string>>(new Set());
+
+  // Seat from the backend on mount, and re-seat when the window regains focus: a
+  // tunnel can outlive the renderer (a reload, a crash, a previous run of the app),
+  // and the routing it owns doesn't care that the UI forgot about it.
+  //
+  // Also re-seat on a timer, because the traffic goes the other way too: a tunnel
+  // can **die** while the window sits focused and untouched, and mount+focus alone
+  // never look again — the indicator stayed green over a tunnel that had been dead
+  // for minutes. That is not just a stale lamp: `refresh` is what detects the drop
+  // and gates the SSH/SFTP probes belonging to the projects riding it (see
+  // `stores/vpnStatus`'s `onTunnelDropped`), so until something reconciles, every
+  // one of those probes blocks ~45 s against a peer that will never answer. This
+  // indicator is always mounted in the header, so it is the one place that poll is
+  // guaranteed to run. It is a local IPC call against an in-memory registry, so a
+  // 10 s cadence is cheap.
+  useEffect(() => {
+    if (!enabled) return;
+    void refresh();
+    const onFocus = () => void refresh();
+    window.addEventListener("focus", onFocus);
+    const id = window.setInterval(() => void refresh(), 10_000);
+    return () => {
+      window.removeEventListener("focus", onFocus);
+      window.clearInterval(id);
+    };
+  }, [refresh, enabled]);
+
+  /**
+   * Re-ask the two credential questions for `list`: is the store readable, and can
+   * each config connect with no prompt at all?
+   *
+   * Both are re-asked together because the second is meaningless without the first —
+   * a locked store makes every `canConnectVpnSilently` answer `false`, and reading
+   * that as "nothing saved" is what the whole locked-keyring path is here to stop. A
+   * reading taken while the store *is* readable is also the only trustworthy input to
+   * `syncVpnCredentialSaved`, so the reconcile happens here and nowhere else.
+   */
+  const probeCredentials = useCallback(async (list: StoredVpnConfig[]) => {
+    const state = await withTimeout(keyringState(), 4000, "locked" as KeyringState);
+    setKeyring(state);
+    const checks = await Promise.all(
+      list.map(
+        async (c) =>
+          [c.path, await canConnectVpnSilently(c.path, vpnUsernameFor(c.path))] as const,
+      ),
+    );
+    setSilent(Object.fromEntries(checks));
+    if (state === "unlocked") {
+      // Only now is a "no" trustworthy: fold it back into the recorded intent so a
+      // credential forgotten elsewhere stops claiming to be saved here.
+      for (const [config, ok] of checks) void syncVpnCredentialSaved(config, ok).catch(() => {});
+    }
+  }, []);
+
+  // The stored `.ovpn` list is only needed once the menu is open — and with it, which
+  // of those configs could connect with no prompt (the gate on arming auto-connect).
+  useEffect(() => {
+    if (!open) return;
+    setRemoveArm(null);
+    let cancelled = false;
+    void invoke<StoredVpnConfig[]>("openvpn_list_configs")
+      .then(async (list) => {
+        const stored = Array.isArray(list) ? list : [];
+        if (cancelled) return;
+        setConfigs(stored);
+        if (!cancelled) await probeCredentials(stored);
+      })
+      .catch(() => {
+        if (!cancelled) setConfigs([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [open, probeCredentials]);
+
+  /**
+   * Unlock the OS credential store, then re-probe.
+   *
+   * This is the one action that turns "it forgot my password" back into "it
+   * remembers": the credential was never gone, only unreadable. The dialog it raises
+   * is the system's own, and it is only ever reached from a click.
+   */
+  const unlock = useCallback(async () => {
+    setUnlocking(true);
+    setError("");
+    const ok = await unlockKeyring();
+    setUnlocking(false);
+    if (!ok) {
+      setError(t("vpnIndicator.keyringStayedLocked"));
+      setKeyring(await withTimeout(keyringState(), 4000, "locked" as KeyringState));
+      return;
+    }
+    await probeCredentials(configs);
+  }, [configs, probeCredentials, t]);
+
+  const reveal = () => {
+    window.clearTimeout(closeTimer.current);
+    setOpen(true);
+  };
+  const scheduleClose = () => {
+    window.clearTimeout(closeTimer.current);
+    closeTimer.current = window.setTimeout(() => setOpen(false), 250);
+  };
+
+  /**
+   * Bring a tunnel up from the header, with no project behind it. Takes the silent
+   * path only when the backend confirms it would *succeed* silently, and otherwise
+   * goes straight to the shared password modal, which owns the retry loop.
+   *
+   * Asking first is the whole point. `pkexec` authenticates the user before OpenVPN
+   * so much as reads the config, so an attempt that was always going to be rejected
+   * still costs a system password dialog — and the modal that opens afterwards to
+   * collect what was missing costs a second one. That is exactly what this menu used
+   * to do to an `auth-user-pass` config with no project behind it: nothing here knew
+   * the username, so every connect burned two polkit prompts. Now the backend keeps
+   * the username beside the saved password, and `canConnectVpnSilently` says whether
+   * the whole set is there — one prompt, one elevation, either way.
+   */
+  const connect = useCallback(
+    async (config: string) => {
+      setError("");
+      abortedRef.current.delete(config);
+      setVpnState(config, "connecting");
+      // A project on this config may already know the (non-secret) auth-user-pass
+      // username — reuse it rather than making the user retype it. Absent that, the
+      // backend falls back to the one saved beside the password.
+      const username = vpnUsernameFor(config);
+      // Why we are about to ask for a password we were supposed to already have. It
+      // travels into the modal, because "it prompted me again anyway" with no reason
+      // given is the failure a saved credential exists to prevent.
+      let reason = "";
+
+      // Ask the credentials themselves first, and only interpret a **lock** if they say
+      // no. A lock is no longer proof that the silent path is dead: the backend keeps a
+      // kernel-keyring cache in front of the Secret Service, so a credential read once
+      // this boot still answers while the collection is locked. Unlocking up front would
+      // therefore put a system password dialog in front of a connect that needed none.
+      //
+      // Bounded (4s): this read sits *before* the modal, and an unbounded await here is
+      // the "amber forever, never asks" trap. If it can't answer in time, treat it as
+      // "not silent" and prompt.
+      let silent = await withTimeout(canConnectVpnSilently(config, username), 4000, false);
+      let store: KeyringState = "unlocked";
+
+      // Only a *failed* check earns the unlock. A locked store is not "nothing saved",
+      // so for a config the user asked us to remember this is the one thing that can
+      // still rescue the connect before it drops to a prompt the user already dealt
+      // with. Only for a remembered config: a system unlock dialog in front of someone
+      // who never saved anything would be a prompt for nothing.
+      if (!silent) {
+        store = await withTimeout(keyringState(), 4000, "locked" as KeyringState);
+        if (store === "locked" && isVpnCredentialSaved(config)) {
+          if (await unlockKeyring()) {
+            store = "unlocked";
+            setKeyring("unlocked");
+            if (abortedRef.current.has(config)) return;
+            silent = await withTimeout(canConnectVpnSilently(config, username), 4000, false);
+          } else {
+            reason = t("vpnIndicator.keyringLockedConnectReason");
+          }
+          if (abortedRef.current.has(config)) return;
+        }
+      }
+      if (silent) {
+        if (abortedRef.current.has(config)) return;
+        try {
+          await connectVpnSilently(config, username);
+          if (abortedRef.current.has(config)) {
+            // Stopped mid-connect, but the silent attempt brought the tunnel up
+            // anyway — bring it back down so the machine isn't left rerouted.
+            void invoke("openvpn_disconnect", { config }).catch(() => {});
+            setVpnState(config, "off");
+            return;
+          }
+          setVpnState(config, "connected");
+          return;
+        } catch (e) {
+          if (abortedRef.current.has(config)) return;
+          // Surface *why* the saved-credential connect failed instead of silently
+          // dropping to a blank password prompt. The backend reason — a rejected
+          // passphrase, a TLS/handshake failure, an unreachable server, an options
+          // error — is exactly what the user needs to see, and swallowing it here is
+          // what made a failed connect look like "nothing happened, still amber".
+          // We still fall through to the prompt (the passphrase may just be stale).
+          reason = t("vpnIndicator.savedCredentialsDidntWork", { error: String(e) });
+          setError(String(e));
+        }
+      } else if (!reason) {
+        reason =
+          store === "unavailable"
+            ? t("vpnIndicator.noCredentialStore")
+            : t("vpnIndicator.noSavedCredentialsYet");
+      }
+
+      // Non-headless: Eldrun handles no passwords in this mode, so a modal is the
+      // wrong ask entirely — the connect command goes to the root terminal and the
+      // user authenticates there. (The saved-credential path above still applies:
+      // credentials the user explicitly handed over via the save toggle are used, and
+      // that is the only way this mode ever connects without a terminal.)
+      if (!headless) {
+        if (abortedRef.current.has(config)) return;
+        try {
+          await openVpnLoginInTerminal(config);
+          if (abortedRef.current.has(config)) return;
+          setError(reason);
+        } catch (e) {
+          setVpnState(config, "off");
+          setError(String(e));
+        }
+        setOpen(false);
+        return;
+      }
+
+      try {
+        await requestPassword(config, fileOf(config), null, username, { reason });
+        // The prompt store marks the tunnel connected on success.
+      } catch (e) {
+        // A Stop already reset the lamp (and cancelled the prompt); don't fight it.
+        if (abortedRef.current.has(config)) return;
+        // The user switched this connect to the terminal instead: the tunnel is coming
+        // up in a root tab with the lamp already amber and a poll behind it, so this
+        // rejection is a handoff, not a failure — clearing the lamp here would blank a
+        // login that is still in progress.
+        if (isVpnTerminalHandoff(e)) {
+          setOpen(false);
+          return;
+        }
+        setVpnState(config, "off");
+        // A cancel is not an error worth shouting about; a failure is.
+        const msg = String(e);
+        if (!/cancel|superseded/i.test(msg)) setError(msg);
+      }
+    },
+    [headless, requestPassword, setVpnState, t],
+  );
+
+  /**
+   * "Save login credentials", per config — the toggle that makes every later connect
+   * silent, and the only place a **non-headless** user can hand Eldrun a VPN secret
+   * at all (that mode has no password fields anywhere else, by design).
+   *
+   * Turning it **on** cannot just flip a flag: there is no secret to save yet, so it
+   * opens the password prompt with the save box pre-ticked — the backend writes the
+   * credential to the keychain only once the tunnel actually comes up, so a wrong
+   * passphrase is never stored. Turning it **off** is an immediate, explicit delete.
+   */
+  const setSaveCredentials = useCallback(
+    async (config: string, save: boolean) => {
+      setError("");
+      if (!save) {
+        await setVpnCredentialSaved(config, false);
+        try {
+          await invoke("vpn_forget_password", { config });
+        } catch (e) {
+          setError(String(e));
+        }
+        setSilent((prev) => ({ ...prev, [config]: false }));
+        // A tunnel that can no longer connect without a prompt must not stay armed to
+        // connect on launch — auto-connect's promise is that it never prompts.
+        if (armed === config && headless) void setVpnAutoConnect(config, false);
+        return;
+      }
+      // Record the intent first: the connect below may be cancelled, but the user has
+      // said what they want, and the record is what survives a locked keyring.
+      await setVpnCredentialSaved(config, true);
+      try {
+        await requestPassword(config, fileOf(config), null, vpnUsernameFor(config), {
+          remember: true,
+          reason: t("vpnIndicator.enterCredentialsOnce"),
+        });
+      } catch (e) {
+        const msg = String(e);
+        // A terminal handoff saves nothing either (Eldrun never sees that password), so
+        // it lands in the same place as a cancel: drop the intent, say nothing.
+        if (!isVpnTerminalHandoff(e) && !/cancel|superseded/i.test(msg)) setError(msg);
+        // Nothing was stored (the backend only saves after a tunnel comes up), so the
+        // intent must not outlive the attempt — it would claim a credential exists.
+        await setVpnCredentialSaved(config, false);
+        return;
+      }
+      await probeCredentials(configs);
+    },
+    [armed, configs, headless, probeCredentials, requestPassword, t],
+  );
+
+  /**
+   * Abort an in-flight connect from the header, restoring normal routing.
+   *
+   * This is the escape hatch a wedged `connecting` lamp never had: the row's only
+   * control used to be "Disconnect tunnel", disabled while connecting, and
+   * `vpnStatus.refresh` keeps a `connecting` entry alive indefinitely — so a connect
+   * that stalled (a dead handshake, a dismissed prompt, a backend that never
+   * answered) parked the lamp amber with no way out. Stop flags the attempt so the
+   * in-flight `connect` won't turn the lamp green when it finally settles, cancels an
+   * open password prompt for this config, tears down any half-open tunnel, and clears
+   * the lamp.
+   */
+  const stopConnect = useCallback(
+    (config: string) => {
+      abortedRef.current.add(config);
+      const prompt = useVpnPromptStore.getState();
+      if (prompt.pending?.config === config) prompt.cancel();
+      void invoke("openvpn_disconnect", { config }).catch(() => {});
+      setVpnState(config, "off");
+      setError("");
+    },
+    [setVpnState],
+  );
+
+  /**
+   * Add a config without connecting: browse for a `.ovpn`, copy it into Eldrun's store
+   * (`openvpn_store_config`, the same import the Connect dialog uses), and list it —
+   * then the user connects it explicitly from its row, which is the path that shows the
+   * password modal. Adding and connecting used to be one button ("Connect…"), which
+   * meant a freshly-picked config went straight into a connect attempt: confusing (the
+   * file browser *is* the connect) and, if that attempt went silent, it never prompted.
+   */
+  const browseAndAdd = useCallback(async () => {
+    setError("");
+    const picked = await openDialog({
+      multiple: false,
+      filters: [{ name: "OpenVPN config", extensions: ["ovpn", "conf"] }],
+    }).catch(() => null);
+    if (typeof picked !== "string") return;
+    let stored: string;
+    try {
+      stored = await invoke<string>("openvpn_store_config", { config: picked });
+    } catch (e) {
+      setError(String(e));
+      return;
+    }
+    setConfigs((prev) =>
+      prev.some((c) => c.path === stored)
+        ? prev
+        : [...prev, { path: stored, name: fileOf(stored) }],
+    );
+  }, []);
+
+  /**
+   * Remove a stored config: delete Eldrun's copy and forget its saved
+   * credentials (the backend does both, in that order — a refused removal
+   * leaves the credentials alone). Only offered on idle rows; a live tunnel's
+   * config can't be removed, only disconnected first. A removed config can't
+   * stay armed to connect on launch — an armed path with no file behind it
+   * would silently fail at every startup.
+   */
+  const remove = useCallback(
+    async (config: string) => {
+      setError("");
+      // Update the UI *first*. `openvpn_remove_config` forgets the saved password and
+      // username too (a `spawn_blocking` keychain write over D-Bus), which can take a
+      // beat — awaiting it before touching the list made the click look dead until the
+      // menu was reopened. Drop the row and disarm now; restore it only if the backend
+      // actually refuses. The backend deletes the config file *and* the credentials.
+      const removed = configs.find((c) => c.path === config);
+      setConfigs((prev) => prev.filter((c) => c.path !== config));
+      setRemoveArm(null);
+      if (armed === config) void setVpnAutoConnect(config, false);
+      // The credentials go with the config (the backend forgets them), so the record
+      // that says they exist has to go too — a leftover would keep claiming a saved
+      // credential for a config that no longer exists, and offer to unlock for it.
+      void setVpnCredentialSaved(config, false);
+      try {
+        await invoke("openvpn_remove_config", { config });
+      } catch (e) {
+        setError(String(e));
+        if (removed) setConfigs((prev) => (prev.some((c) => c.path === config) ? prev : [...prev, removed]));
+      }
+    },
+    [armed, configs],
+  );
+
+  const live = Object.entries(byConfig).filter(
+    ([, state]) => state === "connected" || state === "connecting",
+  );
+  const connecting = live.some(([, state]) => state === "connecting");
+  const lamp: "off" | "connecting" | "connected" = !anyVpnLive(byConfig)
+    ? "off"
+    : connecting
+      ? "connecting"
+      : "connected";
+  const nameOf = (id: string) => projects.find((p) => p.id === id)?.name ?? id;
+  // Configs that are up are listed as tunnels above; don't offer them again below.
+  const idle = configs.filter((c) => !(c.path in byConfig));
+
+  /**
+   * "Connect on launch", per config. Offered only when the promise can be kept — the
+   * connect would raise no prompt (headless: every credential saved) or raises no
+   * *modal* by design (non-headless: it opens in the root terminal, where the user
+   * types the password anyway). An armed-but-no-longer-eligible config can still be
+   * switched off, or a stale opt-in would be unreachable.
+   *
+   * Arming is exclusive by construction: one config is stored, so turning this on for
+   * a second tunnel turns it off for the first. That is not a limitation to work
+   * around — two tunnels would be two claims on one machine's routing.
+   */
+  const autoConnectRow = (config: string) => {
+    const on = armed === config;
+    const saved = savedConfigs.includes(config);
+    // A locked store makes `silent` read false for every config, so without the
+    // recorded intent an armed tunnel would look ineligible and offer to disarm
+    // itself after every restart. The credential is there; it is just unreadable.
+    const promptless = silent[config] === true || (keyring === "locked" && saved);
+    const eligible = !headless || promptless;
+    return (
+      <>
+        <label className="vpn-indicator-auto">
+          <Toggle
+            size="sm"
+            checked={saved}
+            disabled={keyring === "unavailable"}
+            onChange={(e) => void setSaveCredentials(config, e.target.checked)}
+            aria-label={t("vpnIndicator.saveCredentialsAria", { file: fileOf(config) })}
+            title={
+              keyring === "unavailable"
+                ? t("vpnIndicator.saveCredsUnavailableTitle")
+                : saved
+                  ? t("vpnIndicator.saveCredsSavedTitle")
+                  : t("vpnIndicator.saveCredsNotSavedTitle")
+            }
+          />
+          <span>
+            {t("vpnIndicator.saveLoginCredentialsLabel")} <UntestedTag />
+          </span>
+        </label>
+        {saved && keyring === "locked" && (
+          <div className="vpn-indicator-hint">
+            {t("vpnIndicator.savedButLocked")}
+          </div>
+        )}
+        <label className="vpn-indicator-auto">
+          <Toggle
+            size="sm"
+            checked={on}
+            disabled={!eligible && !on}
+            onChange={(e) => void setVpnAutoConnect(config, e.target.checked)}
+            aria-label={t("vpnIndicator.connectOnLaunchAria", { file: fileOf(config) })}
+            title={
+              headless
+                ? t("vpnIndicator.connectOnLaunchHeadlessTitle")
+                : t("vpnIndicator.connectOnLaunchInteractiveTitle")
+            }
+          />
+          <span>{t("vpnIndicator.connectOnLaunchLabel")}</span>
+        </label>
+        {!eligible && !on && (
+          <div className="vpn-indicator-hint">
+            {t("vpnIndicator.needSaveCredsFirstHintPre")} <b>{t("vpnIndicator.saveLoginCredentialsLabel")}</b> {t("vpnIndicator.needSaveCredsFirstHintPost")}
+          </div>
+        )}
+        {on && armed !== null && (
+          <div className="vpn-indicator-hint">
+            {t("vpnIndicator.startsWithEldrun")}{headless ? "" : t("vpnIndicator.waitsInRootTerminal")}.
+          </div>
+        )}
+      </>
+    );
+  };
+
+  if (!enabled) return null;
+
+  return (
+    <div className="global-apps-menu header-status-menu-anchor no-drag" onMouseEnter={reveal} onMouseLeave={scheduleClose}>
+      <button
+        type="button"
+        className="global-apps-menu-btn vpn-indicator-btn"
+        aria-label={t("vpnIndicator.mainAriaLabel")}
+        aria-haspopup="menu"
+        aria-expanded={open}
+        title={
+          lamp === "off"
+            ? t("vpnIndicator.titleOff")
+            : lamp === "connecting"
+              ? t("vpnIndicator.titleConnecting")
+              : t("vpnIndicator.titleConnected")
+        }
+        // Hover-opened, like its sibling header menus (GlobalAppMenu,
+        // LocalModelMenu). Click focuses rather than toggling: a click also fires
+        // mouseenter, so a toggle here would open on enter and immediately shut.
+        onClick={reveal}
+        onFocus={reveal}
+      >
+        <ConnLamp status={lamp} label="OpenVPN" />
+        <span className="vpn-indicator-label">{t("vpnIndicator.vpnLabel")}</span>
+      </button>
+      {open && (
+        <div className="tab-new-menu vpn-indicator-menu" role="menu">
+          {/* Pinned title; the region below it scrolls so the scrollbar starts
+              beneath the header (unified `.menu-scroll-region` shape). The × mirrors
+              the other menus — a hover menu can be surprisingly hard to dismiss on
+              purpose (moving to a control re-reveals it), so an explicit close helps. */}
+          <div className="tab-new-menu-group-label vpn-indicator-title">
+            <span>OpenVPN</span>
+            <button
+              type="button"
+              className="vpn-indicator-close"
+              aria-label={t("common.close")}
+              title={t("common.close")}
+              onClick={() => setOpen(false)}
+            >
+              ×
+            </button>
+          </div>
+          <div className="menu-scroll-region">
+          <div className="vpn-indicator-note">
+            {t("vpnIndicator.note")} <strong>{t("vpnIndicator.noteStrong")}</strong>{" "}
+            {t("vpnIndicator.notePost")}
+          </div>
+
+          {/* The locked-keyring banner. It is the difference between "Eldrun forgot my
+              password" and "your keyring is locked": a locked Secret Service answers
+              every read as though nothing were saved, so without saying so the app
+              silently un-remembers every credential on each restart. Only shown when
+              something is actually behind the lock — otherwise it is noise. */}
+          {keyring === "locked" && savedConfigs.length > 0 && (
+            <div className="vpn-indicator-locked" role="status">
+              <div>
+                {t("vpnIndicator.lockedBannerPre")} <strong>{t("vpnIndicator.lockedBannerStrong")}</strong>
+                {t("vpnIndicator.lockedBannerPost")}
+              </div>
+              <button
+                type="button"
+                className="vpn-indicator-connect"
+                disabled={unlocking}
+                title={t("vpnIndicator.unlockTitle")}
+                onClick={() => void unlock()}
+              >
+                {unlocking ? t("vpnIndicator.unlocking") : t("vpnIndicator.unlockKeyring")} <UntestedTag />
+              </button>
+            </div>
+          )}
+
+          {live.map(([config, state]) => {
+            const held = holders[config] ?? [];
+            return (
+              <div key={config} className="vpn-indicator-row">
+                <div className="vpn-indicator-head">
+                  <ConnLamp status={state} label={`OpenVPN · ${fileOf(config)}`} />
+                  <span className="vpn-indicator-config" title={config}>
+                    {fileOf(config)}
+                  </span>
+                </div>
+                <div className="vpn-indicator-holders">
+                  {held.length > 0 ? `${t("vpnIndicator.heldForPrefix")} ${held.map(nameOf).join(", ")}` : t("vpnIndicator.heldByNoProject")}
+                </div>
+                {state === "connecting" ? (
+                  <button
+                    type="button"
+                    className="vpn-indicator-disconnect"
+                    title={t("vpnIndicator.stopConnectingTitle")}
+                    onClick={() => stopConnect(config)}
+                  >
+                    {t("vpnIndicator.stopConnecting")}
+                  </button>
+                ) : (
+                  <button
+                    type="button"
+                    className="vpn-indicator-disconnect"
+                    title={t("vpnIndicator.disconnectTunnelTitle")}
+                    onClick={() => {
+                      disconnectVpnTunnel(config);
+                      setOpen(false);
+                    }}
+                  >
+                    {t("vpnIndicator.disconnectTunnel")}
+                  </button>
+                )}
+                {autoConnectRow(config)}
+              </div>
+            );
+          })}
+
+          {idle.length > 0 && (
+            <>
+              <div className="tab-new-menu-group-label">{t("vpnIndicator.connectGroupLabel")}</div>
+              {idle.map((c) => {
+                const usedBy = projects
+                  .filter((p) => p.remote?.openvpn?.config === c.path)
+                  .map((p) => p.name);
+                return (
+                  <div key={c.path} className="vpn-indicator-row">
+                    <div className="vpn-indicator-head">
+                      <ConnLamp status="off" label={`OpenVPN · ${c.name}`} />
+                      <span className="vpn-indicator-config" title={c.path}>
+                        {c.name}
+                      </span>
+                    </div>
+                    {removeArm === c.path ? (
+                      // Armed remove: the second click is destructive (the saved
+                      // credentials go with the config and can't be re-browsed
+                      // back), so it is spelled out and separately cancellable.
+                      <>
+                        <div className="vpn-indicator-hint">
+                          {t("vpnIndicator.removeConfigHint")}
+                          {usedBy.length > 0 && (
+                            <>
+                              {" "}
+                              {t("vpnIndicator.usedByPre")} <b>{usedBy.join(", ")}</b>{" "}
+                              {t("vpnIndicator.usedByPost")}
+                            </>
+                          )}
+                        </div>
+                        <div className="vpn-indicator-actions">
+                          <button
+                            type="button"
+                            className="vpn-indicator-remove"
+                            onClick={() => void remove(c.path)}
+                          >
+                            {t("vpnIndicator.removeConfigBtn")}
+                          </button>
+                          <button
+                            type="button"
+                            className="vpn-indicator-connect"
+                            onClick={() => setRemoveArm(null)}
+                          >
+                            {t("vpnIndicator.keepBtn")}
+                          </button>
+                        </div>
+                      </>
+                    ) : (
+                      <div className="vpn-indicator-actions">
+                        <button
+                          type="button"
+                          className="vpn-indicator-connect"
+                          title={t("vpnIndicator.connectTunnelTitle")}
+                          onClick={() => void connect(c.path)}
+                        >
+                          {t("common.connect")}
+                        </button>
+                        <button
+                          type="button"
+                          className="vpn-indicator-remove"
+                          title={t("vpnIndicator.removeConfigTitle")}
+                          onClick={() => setRemoveArm(c.path)}
+                        >
+                          {t("remoteMachines.remove")}
+                        </button>
+                      </div>
+                    )}
+                    {autoConnectRow(c.path)}
+                  </div>
+                );
+              })}
+            </>
+          )}
+
+          {live.length === 0 && idle.length === 0 ? (
+            <div className="vpn-indicator-row">
+              <div className="vpn-indicator-empty">
+                {t("vpnIndicator.emptyStatePre")} <code>.ovpn</code> {t("vpnIndicator.emptyStatePost")}
+              </div>
+              <button
+                type="button"
+                className="vpn-indicator-connect"
+                title={t("vpnIndicator.addFirstConfigTitle")}
+                onClick={() => void browseAndAdd()}
+              >
+                {t("vpnIndicator.addConfigBtn")}
+              </button>
+            </div>
+          ) : (
+            // Configs already exist, but you may want to add another. Adding only
+            // stores it and lists it; connecting (with its password prompt) is an
+            // explicit click on the row. A cancelled browse changes nothing.
+            <div className="vpn-indicator-row vpn-indicator-browse">
+              <button
+                type="button"
+                className="vpn-indicator-connect"
+                title={t("vpnIndicator.addAnotherConfigTitle")}
+                onClick={() => void browseAndAdd()}
+              >
+                {t("vpnIndicator.addConfigBtn")}
+              </button>
+            </div>
+          )}
+          {error && <div className="vpn-indicator-error">{error}</div>}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/header/WindowControls.tsx b/src/components/header/WindowControls.tsx
index de6a4c2..7be4646 100644
--- a/src/components/header/WindowControls.tsx
+++ b/src/components/header/WindowControls.tsx
@@ -1,24 +1,89 @@
-import { getCurrentWindow } from "@tauri-apps/api/window";
+import {
+  getCurrentWindow,
+  currentMonitor,
+  LogicalSize,
+  LogicalPosition,
+} from "@tauri-apps/api/window";
+import { IS_MAC, IS_LINUX } from "../../lib/platform";
+import { useT } from "../../lib/i18n";
 
-export function WindowControls() {
+// Toggle maximize with a clean restore geometry on Linux.
+//
+// The window opens maximized (tauri.conf.json `maximized: true`), so it never had
+// a smaller "normal" size — KWin's saved restore geometry is the full monitor.
+// A plain `unmaximize()` therefore "restores" to the same full size: the window
+// looks unchanged AND it stays in a maximized/tiled internal state, so dragging it
+// to the top edge has nothing to snap (KWin's electric-border snap is suppressed).
+// On restore we assign an explicit centered, default-sized geometry so KWin sees a
+// genuine floating window and re-arms edge-snapping. Windows' Aero Snap handles
+// `toggleMaximize` natively, so it keeps the simple path.
+async function toggleMaximize() {
   const win = getCurrentWindow();
+  if (!IS_LINUX) {
+    await win.toggleMaximize();
+    return;
+  }
+  if (!(await win.isMaximized())) {
+    await win.maximize();
+    return;
+  }
+  await win.unmaximize();
+  const monitor = await currentMonitor();
+  if (!monitor) return;
+  const scale = monitor.scaleFactor || 1;
+  const monW = monitor.size.width / scale;
+  const monH = monitor.size.height / scale;
+  const w = Math.min(1400, Math.round(monW * 0.9));
+  const h = Math.min(900, Math.round(monH * 0.9));
+  const x = Math.round(monitor.position.x / scale + (monW - w) / 2);
+  const y = Math.round(monitor.position.y / scale + (monH - h) / 2);
+  await win.setSize(new LogicalSize(w, h));
+  await win.setPosition(new LogicalPosition(x, y));
+}
+
+export function WindowControls() {
+  const t = useT();
+  // macOS draws native traffic-light buttons (top-left) via the Overlay title-bar
+  // style configured in tauri.macos.conf.json, so Eldrun's own controls would be
+  // redundant — and on the wrong side. Render nothing there.
+  if (IS_MAC) return null;
+
+  // Run a window op and surface failures. On Windows a rejected IPC call (e.g. a
+  // missing `core:window:*` capability) would otherwise leave the button looking
+  // dead with no clue why; log it so it shows up in the webview console.
+  const run = (label: string, op: () => Promise<unknown>) => {
+    op().catch((err) => console.error(`window ${label} failed`, err));
+  };
+
+  // The header runs an `onMouseDown` drag handler (`startDragging`). On WebView2
+  // that native move-loop can swallow the press that should fire the button's
+  // click, so stop the event before it reaches the header — the `closest()` gate
+  // there already excludes us, but isolating the press makes the controls
+  // reliable on Windows regardless.
+  const isolate = (e: React.MouseEvent) => e.stopPropagation();
 
   return (
-    <div className="wm-controls no-drag">
+    <div className="wm-controls no-drag" onMouseDown={isolate}>
       <button
         className="wm-btn wm-minimize"
-        onClick={() => win.minimize()}
-        title="Minimize"
+        onMouseDown={isolate}
+        onClick={() => run("minimize", () => getCurrentWindow().minimize())}
+        title={t("windowControls.minimize")}
+        aria-label={t("windowControls.minimize")}
       />
       <button
         className="wm-btn wm-maximize"
-        onClick={() => win.toggleMaximize()}
-        title="Maximize"
+        onMouseDown={isolate}
+        onClick={() => run("toggle-maximize", toggleMaximize)}
+        title={t("windowControls.maximize")}
+        aria-label={t("windowControls.maximize")}
       />
       <button
         className="wm-btn wm-close"
-        onClick={() => win.close()}
-        title="Close"
+        onMouseDown={isolate}
+        onClick={() => run("close", () => getCurrentWindow().close())}
+        title={t("common.close")}
+        aria-label={t("common.close")}
       />
     </div>
   );
diff --git a/src/components/layout/AppShell.tsx b/src/components/layout/AppShell.tsx
index 3388cdc..14099b4 100644
--- a/src/components/layout/AppShell.tsx
+++ b/src/components/layout/AppShell.tsx
@@ -3,33 +3,126 @@ import {
   useRef,
   useState,
   type MouseEvent as ReactMouseEvent,
+  type PointerEvent as ReactPointerEvent,
   type MutableRefObject,
 } from "react";
 import { getCurrentWindow } from "@tauri-apps/api/window";
+import { message } from "@tauri-apps/plugin-dialog";
+import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
+import { PLATFORM } from "../../lib/dragPlatform";
+import { nextWindowState } from "../../lib/windowState";
 import { notePtyOutput, useActivityStore } from "../../stores/activity";
+import { usePowerStore, useEnergySaver, saverInterval } from "../../stores/power";
 import { CenterPanel } from "./CenterPanel";
 import { HeaderBar } from "./HeaderBar";
 import { RightPanel } from "./RightPanel";
 import { VpnPasswordPrompt } from "./VpnPasswordPrompt";
-import { useProjectsStore, listenProjectRuntimeSwitched } from "../../stores/projects";
+import { AlarmPopup } from "../calendar/AlarmPopup";
+import { RemoteConnectDialog } from "../projects/RemoteConnectDialog";
+import { RemoteMachinesDialogHost } from "../projects/RemoteMachinesWindow";
+import { GlobalMachineMonitorDialogHost } from "../monitoring/GlobalMachineMonitorDialog";
+import { HpcPipelineWizardHost } from "../projects/HpcPipelineWizard";
+import { BigFolderDialogHost } from "../projects/BigFolderExcludeDialog";
+import { LocalLossDialog } from "../common/LocalLossDialog";
+import { HostKeyConfirmDialog } from "../common/HostKeyConfirmDialog";
+import { HpcGuardDialog } from "../common/HpcGuardDialog";
+import { RemoteUsageWarningDialog } from "../common/RemoteUsageWarningDialog";
+import { QuickOpen } from "../files/QuickOpen";
+import { HintHost } from "./HintHost";
+import { TourHost } from "./TourHost";
+import { StatsRecapHost } from "../stats/StatsRecapHost";
+import { HowToStart } from "./HowToStart";
+import { RemoteFeaturesPrompt } from "./RemoteFeaturesPrompt";
+import { LessonsMenu } from "./LessonsMenu";
+import { useHintsStore } from "../../stores/hints";
+import {
+  useProjectsStore,
+  listenProjectRuntimeSwitched,
+  silentReconnectDeadHost,
+} from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { disconnectAllTunnelsOnQuit } from "../../stores/vpnStatus";
 import { listenDetachedHost, shutdownDetachedWindows } from "../../stores/detached";
 import { listenPdfReveal } from "../../stores/pdfSync";
+import { listenSyncProgress } from "../../stores/sync";
+import { autoConnectVpnOnLaunch } from "../../lib/vpnAutoConnect";
+import { initRemoteAutoReconnect } from "../../lib/remoteAutoReconnect";
+import { initMachineSync } from "../../lib/machineSync";
 import { listenEditorJump } from "../../stores/editorJump";
 import { listenSourceJump } from "../embed/FileViewerPane";
 import { BOX_SCOPE_PREFIX, useBoxesStore } from "../../stores/boxes";
 import { useSettingsStore } from "../../stores/settings";
 import { useTabsStore } from "../../stores/tabs";
 import { useTimerStore } from "../../stores/timer";
+import { flushUsage } from "../../stores/usage";
 import { useKeyboard } from "../../hooks/useKeyboard";
+import { useT, useI18nStore, translate } from "../../lib/i18n";
+
+// Width of the right-edge band that reveals the (unpinned) right panel on hover.
+// Kept wide because on Windows/WebView2 the window often isn't true-fullscreen
+// (the Windows platform backend is a stub, so setFullscreen may not take) and
+// the OS resize border swallows mousemove events for the last few edge pixels —
+// a 2px strip there is unreachable, so the panel never opened. A wider band is
+// crossed on the way to the edge, so the reveal fires before the dead-zone.
+const REVEAL_EDGE_PX = 8;
+
+// Right-panel width bounds. The default matches the historical fixed 280px so
+// existing installs (no stored width) look unchanged; the max is capped against
+// the live window so the panel can never swallow the whole workspace.
+const RIGHT_PANEL_MIN = 220;
+const RIGHT_PANEL_DEFAULT = 280;
+function clampRightWidth(px: number): number {
+  const max = Math.max(RIGHT_PANEL_MIN, Math.min(900, window.innerWidth - 240));
+  return Math.round(Math.max(RIGHT_PANEL_MIN, Math.min(max, px)));
+}
+
+/**
+ * Snapshot the main window's geometry and persist it if it actually changed, so
+ * the backend can reopen the window on the same monitor next launch
+ * (`restore_main_window` in lib.rs). What to store — and the subtlety of what to
+ * store while MAXIMIZED — lives in `nextWindowState`.
+ *
+ * Shared by the debounced move/resize listener and the close path: a quit during
+ * the debounce window would otherwise lose the user's last move, which is exactly
+ * the move they care about.
+ */
+async function saveWindowGeometry(): Promise<void> {
+  const win = getCurrentWindow();
+  // A fullscreen window's rect is just the monitor, not a restore geometry. macOS
+  // only — Linux/Windows never enter fullscreen (see the startup effect).
+  if (await win.isFullscreen()) return;
+  const [pos, size, maximized] = await Promise.all([
+    win.outerPosition(),
+    win.outerSize(),
+    win.isMaximized(),
+  ]);
+  // outerPosition/outerSize are already PHYSICAL px, which is what the backend
+  // consumes — nothing is converted anywhere along this path (src/lib/coords.ts).
+  const store = useSettingsStore.getState();
+  const next = nextWindowState(
+    store.settings?.window_state,
+    { x: pos.x, y: pos.y, w: size.width, h: size.height },
+    maximized,
+  );
+  if (next) await store.saveWindowState(next);
+}
 
 export function AppShell() {
+  const t = useT();
   const loadSettings = useSettingsStore((s) => s.load);
   const settingsLoaded = useSettingsStore((s) => s.loaded);
   const pinnedSetting = useSettingsStore((s) => s.settings?.right_panel_pinned ?? false);
+  const widthSetting = useSettingsStore((s) => s.settings?.right_panel_width ?? RIGHT_PANEL_DEFAULT);
+  const panelSide = useSettingsStore((s) => s.settings?.right_panel_side ?? "right");
   const updateSettings = useSettingsStore((s) => s.updateSettings);
   const loadProjects = useProjectsStore((s) => s.load);
   const projectsLoaded = useProjectsStore((s) => s.loaded);
+  const projectCount = useProjectsStore((s) => s.projects.length);
+  const onboardingSeen = useSettingsStore((s) => s.settings?.onboarding_seen ?? false);
+  const remoteFeaturesPrompted = useSettingsStore(
+    (s) => s.settings?.remote_features_prompted ?? false,
+  );
   const loadBoxes = useBoxesStore((s) => s.load);
   const activeId = useProjectsStore((s) => s.activeId);
   const scope = useTabsStore((s) => s.scope);
@@ -38,17 +131,45 @@ export function AppShell() {
   const panelTarget = activeId !== null || scope.startsWith(BOX_SCOPE_PREFIX);
   const switchToast = useProjectsStore((s) => s.switchToast);
   const clearSwitchToast = useProjectsStore((s) => s.clearSwitchToast);
+  const connToast = useProjectsStore((s) => s.connToast);
+  const clearConnToast = useProjectsStore((s) => s.clearConnToast);
   const initTimer = useTimerStore((s) => s.init);
   const flushTimer = useTimerStore((s) => s.flush);
+  const energySaver = useEnergySaver();
   const [panelsHidden, setPanelsHidden] = useState(false);
   const [rightOpen, setRightOpen] = useState(false);
   const [rightPinned, setRightPinned] = useState(false);
+  const [rightWidth, setRightWidth] = useState(RIGHT_PANEL_DEFAULT);
+  const [resizingRight, setResizingRight] = useState(false);
+  const latestRightWidth = useRef(RIGHT_PANEL_DEFAULT);
+  const [showHowToStart, setShowHowToStart] = useState(false);
+  const [showRemoteFeaturesPrompt, setShowRemoteFeaturesPrompt] = useState(false);
+  // Set only on the fresh-install path, where HowToStart takes the screen
+  // first — this defers the remote-features ask until HowToStart closes
+  // instead of stacking two modals on the very first launch.
+  const [pendingRemoteFeaturesPrompt, setPendingRemoteFeaturesPrompt] = useState(false);
+  const [showLessons, setShowLessons] = useState(false);
   const rightCloseTimer = useRef<number | null>(null);
 
   useEffect(() => {
     loadSettings();
     loadProjects();
-    getCurrentWindow().setFullscreen(true).catch(() => {});
+    // Startup window geometry — which monitor, what size, maximized or not — is
+    // owned ENTIRELY by the backend now (`restore_main_window` in lib.rs), which
+    // reapplies the rect saved by the effect below before the window is ever shown.
+    // Nothing may be re-asserted from here: a `maximize()` fired after load would
+    // land on top of a restore onto the secondary monitor and undo it.
+    //
+    // macOS is the exception and stays here: real fullscreen (its own Space) is the
+    // platform-expected behavior, and the system traffic-light controls keep the
+    // window manageable. Linux must never follow suit — a window the WM has put into
+    // fullscreen keeps `_NET_WM_STATE_FULLSCREEN`, which under KWin wins over
+    // MAXIMIZED and makes the window UNMOVABLE (KWin refuses the
+    // `_NET_WM_MOVERESIZE` that `startDragging` sends, so the header title-bar drag
+    // silently no-ops). See the matching note in `restore_main_window`.
+    if (PLATFORM === "macos") {
+      getCurrentWindow().setFullscreen(true).catch(() => {});
+    }
   }, [loadSettings, loadProjects]);
 
   // WebKitGTK doesn't reliably fire DOM 'resize' / ResizeObserver for OS-level
@@ -92,17 +213,131 @@ export function AppShell() {
     };
   }, []);
 
+  // Remember where the user puts the window, so it reopens there. Mirrors the
+  // popout's bounds streaming (DetachedApp.tsx): a drag fires a storm of events,
+  // so debounce and write once it settles. Gated on `settingsLoaded` because the
+  // save diffs against the currently-saved rect to skip no-op writes, and before
+  // load there is nothing to diff against.
+  useEffect(() => {
+    if (!settingsLoaded) return;
+    const win = getCurrentWindow();
+    const unlisteners: Array<() => void> = [];
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const schedule = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = undefined;
+        void saveWindowGeometry().catch(() => {});
+      }, 300);
+    };
+    win.onMoved(schedule).then((fn) => unlisteners.push(fn)).catch(() => {});
+    win.onResized(schedule).then((fn) => unlisteners.push(fn)).catch(() => {});
+    return () => {
+      if (timer) clearTimeout(timer);
+      unlisteners.forEach((fn) => fn());
+    };
+  }, [settingsLoaded]);
+
   // Restore the pinned state once settings finish loading.
   useEffect(() => {
     if (settingsLoaded) setRightPinned(pinnedSetting);
   }, [settingsLoaded, pinnedSetting]);
 
+  // Restore the stored panel width once settings load (clamped to the current
+  // window so a width saved on a wider monitor can't strand the panel off-screen).
+  useEffect(() => {
+    if (settingsLoaded) {
+      const w = clampRightWidth(widthSetting);
+      latestRightWidth.current = w;
+      setRightWidth(w);
+    }
+  }, [settingsLoaded, widthSetting]);
+
+  // First-run "How to start": show once on a genuinely empty install (the
+  // `projects.length === 0` guard keeps upgrading users — who already have
+  // projects but no flag — from seeing it). Mark seen immediately (optimistic)
+  // so a hot-reload or transient re-render can't reopen it.
+  //
+  // The "Using VPN or remote machines?" ask rides the same effect so the two
+  // never stack: on a fresh install it waits behind HowToStart (queued via
+  // `pendingRemoteFeaturesPrompt`, shown from HowToStart's onClose below);
+  // otherwise — including an upgrading install that already has projects and
+  // so skips HowToStart — it shows immediately. Both settings are written in
+  // one `updateSettings` call on the fresh-install branch so a fast second
+  // effect run can't read a stale `current` and drop one of the two flags.
+  useEffect(() => {
+    if (!settingsLoaded || !projectsLoaded) return;
+    if (!onboardingSeen && projectCount === 0) {
+      setShowHowToStart(true);
+      if (!remoteFeaturesPrompted) {
+        setPendingRemoteFeaturesPrompt(true);
+        void updateSettings({ onboarding_seen: true, remote_features_prompted: true });
+      } else {
+        void updateSettings({ onboarding_seen: true });
+      }
+      return;
+    }
+    if (!remoteFeaturesPrompted) {
+      setShowRemoteFeaturesPrompt(true);
+      void updateSettings({ remote_features_prompted: true });
+    }
+  }, [
+    settingsLoaded,
+    projectsLoaded,
+    onboardingSeen,
+    projectCount,
+    remoteFeaturesPrompted,
+    updateSettings,
+  ]);
+
+  // Let the Settings dialog / gear menu re-open the welcome on demand.
+  useEffect(() => {
+    const open = () => setShowHowToStart(true);
+    window.addEventListener("eldrun:open-how-to-start", open);
+    return () => window.removeEventListener("eldrun:open-how-to-start", open);
+  }, []);
+
+  // Open the lessons picker on demand, and let a tour/lesson step force the
+  // (otherwise hover-revealed) file panel open so it has something to spotlight.
+  useEffect(() => {
+    const openLessons = () => setShowLessons(true);
+    const revealPanel = () => {
+      if (rightCloseTimer.current !== null) {
+        window.clearTimeout(rightCloseTimer.current);
+        rightCloseTimer.current = null;
+      }
+      setRightOpen(true);
+    };
+    window.addEventListener("eldrun:open-lessons", openLessons);
+    window.addEventListener("eldrun:reveal-right-panel", revealPanel);
+    return () => {
+      window.removeEventListener("eldrun:open-lessons", openLessons);
+      window.removeEventListener("eldrun:reveal-right-panel", revealPanel);
+    };
+  }, []);
+
   // Load boxes once projects are in memory so deriving each project's box_id
   // (from the authoritative member_ids) runs over the loaded project list.
   useEffect(() => {
     if (projectsLoaded) void loadBoxes();
   }, [projectsLoaded, loadBoxes]);
 
+  // Bring up the tunnel armed as "connect on launch" in the header's VPN menu, if any.
+  // Waits for both stores: the setting says *which* config, and a project's spec may
+  // hold the auth username for it. Self-guarded against a second run, and silent —
+  // it never prompts, so a stale opt-in just leaves the tunnel down.
+  useEffect(() => {
+    if (settingsLoaded && projectsLoaded) void autoConnectVpnOnLaunch();
+  }, [settingsLoaded, projectsLoaded]);
+
+  // Install the tunnel-up → reconnect subscription (and the launch-time global-
+  // machine sweep) once, on first mount — before the VPN launch effect above can
+  // bring a tunnel up, so its `→ connected` transition is already being watched.
+  useEffect(() => {
+    initRemoteAutoReconnect();
+    initMachineSync();
+  }, []);
+
   const togglePin = () => {
     setRightPinned((v) => {
       const next = !v;
@@ -111,6 +346,52 @@ export function AppShell() {
     });
   };
 
+  // Flip the panel to the opposite edge. Persisted only — the layout (docked
+  // inset, slide direction, resize math, reveal edge) reads `panelSide`, so no
+  // local mirror state is needed.
+  const toggleSide = () => {
+    void updateSettings({ right_panel_side: panelSide === "left" ? "right" : "left" });
+  };
+
+  // Drag the panel's left border to resize. The panel is absolutely positioned
+  // at right:0, so its width is just `innerWidth - cursorX`. We update local
+  // state live (driving both the panel width and the docked body inset) and
+  // persist only on release. Pointer capture keeps the gesture alive when the
+  // cursor leaves the thin handle.
+  const onResizeStart = (e: ReactPointerEvent<HTMLDivElement>) => {
+    e.preventDefault();
+    try {
+      e.currentTarget.setPointerCapture(e.pointerId);
+    } catch {
+      /* capture is best-effort */
+    }
+    setResizingRight(true);
+  };
+
+  const onResizeMove = (e: ReactPointerEvent<HTMLDivElement>) => {
+    if (!resizingRight) return;
+    // The grip straddles the panel's inner edge — on the right that's the left
+    // border (width = innerWidth - cursorX); flipped to the left it's the right
+    // border (width = cursorX).
+    const w = clampRightWidth(panelSide === "left" ? e.clientX : window.innerWidth - e.clientX);
+    latestRightWidth.current = w;
+    setRightWidth(w);
+  };
+
+  const onResizeEnd = (e: ReactPointerEvent<HTMLDivElement>) => {
+    if (!resizingRight) return;
+    setResizingRight(false);
+    try {
+      e.currentTarget.releasePointerCapture(e.pointerId);
+    } catch {
+      /* ignore */
+    }
+    void updateSettings({ right_panel_width: latestRightWidth.current });
+    // Terminals and other panes refit off the DOM resize event; the docked body
+    // inset just changed, so nudge them to remeasure at the new width.
+    window.dispatchEvent(new Event("resize"));
+  };
+
   // Apply tab layout / right-panel restores emitted by the backend's
   // project-runtime switch (which runs off the UI thread).
   useEffect(() => {
@@ -121,6 +402,16 @@ export function AppShell() {
     return () => { unlisten?.(); };
   }, []);
 
+  // SSH-sync Phase 1: subscribe to the backend's mirror-sync progress stream so
+  // the remote file view reflects transfers + refreshes status on completion.
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    listenSyncProgress()
+      .then((fn) => { unlisten = fn; })
+      .catch(() => {});
+    return () => { unlisten?.(); };
+  }, []);
+
   // #42: register the MAIN window's host side of the detached-subwindow
   // protocol exactly once. This responds to a popped-out window's seed request
   // (shipping its group's tabs+subtree), applies edits streamed back, and docks
@@ -181,7 +472,42 @@ export function AppShell() {
     const win = getCurrentWindow();
     win.onCloseRequested(async (event) => {
       event.preventDefault();
+      // Tear down any live OpenVPN tunnel *before* anything else and before the window
+      // goes away. The backend also does this in RunEvent::Exit, but that runs only
+      // after destroy(), so its elevated pkexec kill raised the polkit password prompt
+      // against an already-gone window. Awaiting it here keeps Eldrun on screen until
+      // the prompt is answered — asked exactly once: if the user dismisses it, the
+      // backend marks that tunnel declined so RunEvent::Exit won't re-prompt for it
+      // with the window already gone (that used to raise a parentless pkexec dialog
+      // that could stall shutdown). So a "no" here just warns and the quit proceeds —
+      // it does not block the app from closing.
+      const tunnelsDown = await disconnectAllTunnelsOnQuit().catch(() => true);
+      if (!tunnelsDown) {
+        const lang = useI18nStore.getState().lang;
+        await message(translate(lang, "appShell.vpnStillActiveMessage"), {
+          title: translate(lang, "appShell.vpnStillActiveTitle"),
+          kind: "warning",
+        }).catch(() => {});
+      }
       await flushTimer().catch(() => {});
+      // Counters accrued since the last interval flush would otherwise be lost on
+      // quit — including everything done in the final minutes of a session.
+      await flushUsage().catch(() => {});
+      // Capture the window's final geometry before it goes away — a quit inside
+      // the 300ms save debounce would otherwise drop the user's last move.
+      await saveWindowGeometry().catch(() => {});
+      // Flush the active scope's tab layout for the same reason: CenterPanel
+      // debounces its persistScope by 300ms, so a quit right after navigating a
+      // Files (Project) tab into a subfolder (or any tab/split change) would drop
+      // it and the tab would reopen at the project root. The right-panel folder
+      // is saved eagerly and needs no flush; only the tab layout is debounced.
+      const { activeId, projects } = useProjectsStore.getState();
+      const localFile = activeId
+        ? projects.find((p) => p.id === activeId)?.local_file
+        : undefined;
+      if (localFile) {
+        await useTabsStore.getState().saveLayout(localFile).catch(() => {});
+      }
       // Close any popped-out subwindows so they don't strand on screen; they
       // persist + re-open at their saved bounds next launch (see the helper).
       await shutdownDetachedWindows().catch(() => {});
@@ -210,20 +536,113 @@ export function AppShell() {
     return () => clearInterval(id);
   }, [flushTimer]);
 
+  // Periodically commit the usage counters accrued in memory (see stores/usage).
+  // Batched on its own, faster cadence than the timer: the counters are cheap to
+  // accumulate but each flush is a whole-file rewrite, so this is the knob that
+  // keeps a burst of typing from becoming a burst of disk writes.
+  useEffect(() => {
+    const id = setInterval(() => void flushUsage(), 30_000);
+    return () => clearInterval(id);
+  }, []);
+
+  // Reconcile the SSH lamp/Connect-dialog status against the backend's actual
+  // pool, which is the only side that ever notices a pooled connection dying on
+  // its own (network drop, keepalive eviction, a VPN tunnel getting replaced
+  // out from under it, or an HPC job's long queue wait past `ControlPersist`) —
+  // and only lazily, the next time some command happens to touch that
+  // project's pool entry. `useRemoteStatusStore` otherwise only ever moves on
+  // an explicit connect/disconnect result, so without this a project whose
+  // pooled session died keeps showing "connected" (green lamp, the Connect
+  // dialog claiming it's already up) indefinitely, while anything that
+  // actually asks the pool — e.g. the network-traffic pane's own poll —
+  // correctly reports disconnected. A project the store still marks
+  // "connected" that the backend no longer lists is handed to
+  // `silentReconnectDeadHost`, which re-authenticates it with no prompt when
+  // that's possible (headless + key/agent auth or a saved password) and only
+  // falls back to a red "error" lamp when it isn't — so a background HPC watch
+  // tab's host reconnects on its own instead of sitting disconnected until the
+  // user notices and clicks reconnect by hand.
+  useEffect(() => {
+    const id = setInterval(() => {
+      const { byProject, byHost } = useRemoteStatusStore.getState();
+      // Every (project, host) the store believes is connected — the primary
+      // (byProject) plus every worker host (byHost, multi-host remote).
+      const stillConnected: Array<[string, string]> = [];
+      for (const [projectId, s] of Object.entries(byProject)) {
+        if (s.ssh === "connected") stillConnected.push([projectId, "primary"]);
+      }
+      for (const [projectId, hosts] of Object.entries(byHost)) {
+        for (const [hostId, s] of Object.entries(hosts)) {
+          if (s.ssh === "connected") stillConnected.push([projectId, hostId]);
+        }
+      }
+      if (stillConnected.length === 0) return;
+      // Per-host truth from the pool (`remote_connected_targets`); anything the
+      // store marks connected that the backend no longer lists gets a silent
+      // reconnect attempt rather than an immediate red lamp.
+      void invoke<Array<[string, string]>>("remote_connected_targets")
+        .then((targets) => {
+          const live = new Set(targets.map(([p, h]) => `${p}
${h}`));
+          for (const [projectId, hostId] of stillConnected) {
+            if (!live.has(`${projectId}
${hostId}`)) {
+              void silentReconnectDeadHost(projectId, hostId);
+            }
+          }
+        })
+        .catch(() => {});
+    }, 15_000);
+    return () => clearInterval(id);
+  }, []);
+
+  // Point the file-churn watcher at the active project, so the recap's
+  // created/modified/deleted counts follow whatever the user is working on. The
+  // backend resolves which directory that is (a remote project is watched through
+  // its local mirror; one with no mirror is not watchable at all, since inotify
+  // cannot see an SFTP tree, and records no file stats).
+  useEffect(() => {
+    void invoke("usage_watch_project", { projectId: activeId ?? "" }).catch(() => {});
+  }, [activeId]);
+
   // Track per-project terminal activity for the running-task pill indicator.
   // One global listener covers background projects too (their PTYs keep
   // emitting even while their tab views are unmounted).
   useEffect(() => {
     let unlisten: (() => void) | undefined;
-    listen<{ id: string }>("terminal-output", (ev) => {
-      notePtyOutput(ev.payload.id);
+    listen<{ id: string; data: string }>("terminal-output", (ev) => {
+      // The chunk itself rides along: it is the ONLY view of a tab's screen that
+      // exists for a pane the user has never opened (those buffer their output
+      // instead of writing it to an xterm), and the store classifies a quiet
+      // agent tab — finished vs blocked on a prompt — off its tail.
+      notePtyOutput(ev.payload.id, ev.payload.data);
     })
       .then((fn) => { unlisten = fn; })
       .catch(() => {});
-    const id = setInterval(() => useActivityStore.getState().recompute(), 300);
-    return () => { unlisten?.(); clearInterval(id); };
+    return () => { unlisten?.(); };
   }, []);
 
+  // Recompute the running-task indicators on a fixed cadence. Split from the
+  // listener above so re-arming it on an Energy Saver flip doesn't drop the
+  // terminal-output listener. On battery the pill lags a little more but the
+  // 300ms churn stops.
+  useEffect(() => {
+    const id = setInterval(
+      () => useActivityStore.getState().recompute(),
+      saverInterval(300, energySaver),
+    );
+    return () => clearInterval(id);
+  }, [energySaver]);
+
+  // Poll AC/battery state so Energy Saver ("on battery") can react to plug/unplug.
+  useEffect(() => usePowerStore.getState().start(), []);
+
+  // Publish the effective Energy Saver state on the document root so the CSS in
+  // themes.css can collapse continuous idle animations (`[data-energy-saver]`).
+  useEffect(() => {
+    const root = document.documentElement;
+    if (energySaver) root.dataset.energySaver = "on";
+    else delete root.dataset.energySaver;
+  }, [energySaver]);
+
   useEffect(() => {
     if (projectsLoaded) {
       void initTimer(activeId);
@@ -238,6 +657,12 @@ export function AppShell() {
     return () => clearTimeout(t);
   }, [switchToast, clearSwitchToast]);
 
+  useEffect(() => {
+    if (!connToast) return;
+    const t = setTimeout(clearConnToast, 3200);
+    return () => clearTimeout(t);
+  }, [connToast, clearConnToast]);
+
   const reveal = (
     timer: MutableRefObject<number | null>,
     setter: (open: boolean) => void,
@@ -261,13 +686,23 @@ export function AppShell() {
     }, delay);
   };
 
-  useKeyboard({ onTogglePanels: () => setPanelsHidden((v) => !v) });
+  useKeyboard({
+    onTogglePanels: () => {
+      useHintsStore.getState().markSeen("toggle-panels");
+      setPanelsHidden((v) => !v);
+    },
+  });
 
   const revealRight = panelTarget && !panelsHidden && (rightOpen || rightPinned);
 
   const handleBodyMouseMove = (event: ReactMouseEvent<HTMLDivElement>) => {
     if (!panelTarget || panelsHidden || rightOpen) return;
-    if (window.innerWidth - event.clientX <= 2) {
+    const nearEdge =
+      panelSide === "left"
+        ? event.clientX <= REVEAL_EDGE_PX
+        : window.innerWidth - event.clientX <= REVEAL_EDGE_PX;
+    if (nearEdge) {
+      useHintsStore.getState().markSeen("file-tree");
       reveal(rightCloseTimer, setRightOpen);
     }
   };
@@ -276,10 +711,23 @@ export function AppShell() {
     <div className="app-shell">
       <HeaderBar />
       {switchToast != null && (
-        <div key={switchToast} className="project-switch-toast">{switchToast}</div>
+        <div
+          key={switchToast}
+          className={`project-switch-toast${switchToast.includes("\n") ? " multiline" : ""}`}
+        >{switchToast}</div>
+      )}
+      {connToast != null && (
+        <div key={connToast} className="project-switch-toast conn-toast">{connToast}</div>
       )}
       <div
-        className={`app-body${revealRight && rightPinned ? " right-docked" : ""}`}
+        className={`app-body${revealRight && rightPinned ? (panelSide === "left" ? " left-docked" : " right-docked") : ""}${resizingRight ? " resizing" : ""}`}
+        style={
+          revealRight && rightPinned
+            ? panelSide === "left"
+              ? { paddingLeft: rightWidth }
+              : { paddingRight: rightWidth }
+            : undefined
+        }
         onMouseMove={handleBodyMouseMove}
       >
         <CenterPanel />
@@ -287,13 +735,103 @@ export function AppShell() {
           <RightPanel
             open={revealRight}
             pinned={rightPinned}
+            side={panelSide}
+            width={rightWidth}
+            resizing={resizingRight}
+            onResizeStart={onResizeStart}
+            onResizeMove={onResizeMove}
+            onResizeEnd={onResizeEnd}
             onTogglePin={togglePin}
+            onToggleSide={toggleSide}
             onMouseEnter={() => reveal(rightCloseTimer, setRightOpen)}
             onMouseLeave={() => !rightPinned && scheduleClose(rightCloseTimer, setRightOpen)}
           />
         )}
+        {/* Invisible marker at the reveal band so the guided tour has a stable
+            element to spotlight for the "find your files" step. Follows the panel
+            to whichever edge it docks against. */}
+        {panelTarget && !panelsHidden && (
+          <div
+            className={`tour-edge-marker${panelSide === "left" ? " left" : ""}`}
+            data-hint-anchor="file-tree-edge"
+            aria-hidden
+          />
+        )}
+        {/* Always-visible CLICK affordance to open the (closed, unpinned) file
+            panel. The hover-only right-edge reveal (handleBodyMouseMove) depends
+            on WebView2 delivering mousemove in the last few edge pixels — which it
+            does NOT do reliably in the packaged Windows window, where the OS resize
+            border swallows them. That left no way to open the panel at all, and so
+            no way to reach the pin that lives inside it. A click is delivered even
+            where the mousemove stream isn't, so this is the reliable path; it
+            unmounts the moment the panel is open (revealRight). */}
+        {panelTarget && !panelsHidden && !revealRight && (
+          <button
+            type="button"
+            className={`right-panel-reveal-handle${panelSide === "left" ? " left" : ""}`}
+            aria-label={t("appShell.showFilesPanel")}
+            title={t("appShell.showFilesPanel")}
+            onClick={() => reveal(rightCloseTimer, setRightOpen)}
+            onMouseEnter={() => reveal(rightCloseTimer, setRightOpen)}
+          >
+            <span aria-hidden="true">{panelSide === "left" ? "›" : "‹"}</span>
+          </button>
+        )}
       </div>
       <VpnPasswordPrompt />
+      {/* "Is this the right machine?" — shown before a password is sent to a host
+          whose SSH key has never been accepted here. At the shell because it can be
+          raised by any connect surface (the Connect modal, a create/extend dialog,
+          the Machines menu), and each of them must not carry its own copy. */}
+      <HostKeyConfirmDialog />
+      {/* The HPC tag's per-act confirmation (disk scan, login-node run). Mounted
+          here for the same reason the host-key prompt is: the caller is a lib
+          function with no component of its own to render into. */}
+      <HpcGuardDialog />
+      <RemoteConnectDialog />
+      {/* Multi-host remote: the "Remote machines" manager, opened from a pill's
+          Runtime menu or a right-click on its remote lamp. */}
+      <RemoteMachinesDialogHost />
+      {/* The header Machines menu's "System monitor…" button, per global machine. */}
+      <GlobalMachineMonitorDialogHost />
+      {/* The guided HPC/SLURM pipeline wizard (login → create → load → run → watch),
+          launched from the project-switcher + menu (docs/quirky-knitting-umbrella). */}
+      <HpcPipelineWizardHost />
+      {/* "These folders are giant — sync them?", asked once when a project is first
+          paired with a host. Lives at the shell for the same reason the manager
+          above does: the project that asked may not be the active one by the time
+          its census (local walk + one host `du`) comes back. */}
+      <BigFolderDialogHost />
+      {/* Same reason as the alarm below: lockstep/sync can delete a file from the local
+          mirror during a background pass, and the user must hear about it wherever they
+          are — including when the file panel it happened in is closed (#28q). */}
+      <LocalLossDialog />
+      {/* Fires once per connect (manual or silent auto-connect): warns that the
+          host's load/memory/logged-in sessions suggest it's already in use. */}
+      <RemoteUsageWarningDialog />
+      {/* Calendar reminders live at the shell, not in the calendar pane: an alarm
+          must reach the user whatever tab they are on — and even if they have
+          never opened a calendar tab this session. */}
+      <AlarmPopup />
+      <QuickOpen />
+      <HintHost />
+      <TourHost />
+      <StatsRecapHost />
+      {showHowToStart && (
+        <HowToStart
+          onClose={() => {
+            setShowHowToStart(false);
+            if (pendingRemoteFeaturesPrompt) {
+              setPendingRemoteFeaturesPrompt(false);
+              setShowRemoteFeaturesPrompt(true);
+            }
+          }}
+        />
+      )}
+      {showRemoteFeaturesPrompt && (
+        <RemoteFeaturesPrompt onClose={() => setShowRemoteFeaturesPrompt(false)} />
+      )}
+      {showLessons && <LessonsMenu onClose={() => setShowLessons(false)} />}
     </div>
   );
 }
diff --git a/src/components/layout/CenterPanel.tsx b/src/components/layout/CenterPanel.tsx
index 0a747d1..ee4aac2 100644
--- a/src/components/layout/CenterPanel.tsx
+++ b/src/components/layout/CenterPanel.tsx
@@ -1,31 +1,36 @@
 import { Fragment, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { invoke } from "@tauri-apps/api/core";
-import { emit, listen } from "@tauri-apps/api/event";
+import { listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
 import {
   DETACHED_DRAG_END,
   DETACHED_DRAG_MOVE,
   DETACHED_DRAG_START,
-  buildSeed,
-  detachedSeedEvent,
+  decideDetachedGroupDrop,
+  decideDetachedPaneDrop,
+  decideDetachedTabDrop,
   type DetachedDragEnd,
   type DetachedDragMove,
   type DetachedDragStart,
 } from "../../stores/detached";
-import { TerminalView } from "../terminal/TerminalView";
-import { FileBrowser } from "../files/FileBrowser";
-import { EmbedPane } from "../embed/EmbedPane";
-import { FileViewerPane } from "../embed/FileViewerPane";
+import { TabPane } from "../tabs/TabPane";
 import { Subwindow } from "../tabs/Subwindow";
 import { pickEdge, previewInset } from "../tabs/dragGeometry";
+import { dragPreviewLayout } from "../tabs/dragPreview";
 import {
+  BLOB_TAB_CMD,
   DEFAULT_MIN_SUBWINDOW_PX,
   EMPTY_GROUP_ID,
   FILES_TAB_CMD,
   allGroups,
   cmdToKind,
+  effectiveTabLocation,
+  findGroup,
   isRestorableTab,
+  isPtyTabKind,
+  localTabCwd,
+  remoteHostIdOf,
   useTabsStore,
   type LayoutNode,
   type SavedLayoutTree,
@@ -33,10 +38,32 @@ import {
 } from "../../stores/tabs";
 import { useSettingsStore } from "../../stores/settings";
 import { useDragStore } from "../../stores/drag";
+import { useSubwindowNavStore } from "../../stores/subwindowNav";
+import { useWindowFocused } from "../../hooks/useWindowFocused";
+import { useScrollSyncStore } from "../../stores/scrollSync";
+import { useWindowMoveStore } from "../../stores/windowMove";
 import { useDetachAnimStore } from "../../stores/detachAnim";
+import { useTabLandStore } from "../../stores/tabLand";
+import { TAB_ACCENT } from "../tabs/newTabItems";
 import { commitDrop } from "../tabs/commitDrop";
+import {
+  startDetachedDropSession,
+  reseedDetached,
+} from "../tabs/detachedDropTargets";
+import {
+  snapshotFrame,
+  physToClient,
+  type PhysPoint,
+  type WindowFrame,
+} from "../../lib/coords";
+import { dragPlatform } from "../../lib/dragPlatform";
+import { shouldPersistTab, shouldPersistLocalTab } from "../../lib/tmuxSession";
+import { IS_WINDOWS } from "../../lib/platform";
 import { useProjectsStore } from "../../stores/projects";
-import { resolveProjectDirectory } from "../../types";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { resolveLocalMirror, resolveProjectDirectory } from "../../types";
+import { useT } from "../../lib/i18n";
 
 /** Pixel coordinates of a group's pane region, relative to the center panel. */
 interface Rect {
@@ -46,48 +73,8 @@ interface Rect {
   height: number;
 }
 
-/**
- * #57: open `README.md` in an in-app markdown viewer tab as the default for a
- * freshly-visited project that has no tabs to restore. Checks existence via the
- * existing `list_dir` command (no new backend command), then seeds a single
- * `viewer: "markdown"` embed tab — a restorable embed, so it persists and
- * re-restores naturally. No-ops if the file is absent or the scope was populated
- * (by a concurrent switch_project_runtime) while we were checking.
- */
-export async function openReadmeDefaultTab(projectCwd: string, scope: string): Promise<void> {
-  if (!projectCwd) return;
-  let entries: { name: string; is_dir: boolean }[];
-  try {
-    entries = await invoke<{ name: string; is_dir: boolean }[]>("list_dir", {
-      projectDir: projectCwd,
-      relPath: "",
-    });
-  } catch {
-    return;
-  }
-  const hasReadme = entries.some((e) => !e.is_dir && e.name === "README.md");
-  if (!hasReadme) return;
-  // Re-check the guard: a concurrent switch may have populated the scope while
-  // list_dir was in flight. Never clobber existing tabs.
-  if (scope in useTabsStore.getState().tabsByScope) return;
-  useTabsStore.getState().loadFromLayout(
-    [
-      {
-        key: "readme-default",
-        label: "README.md",
-        cmd: "",
-        cwd: projectCwd,
-        kind: "embed",
-        embedPath: `${projectCwd}/README.md`,
-        viewer: "markdown",
-      },
-    ],
-    projectCwd,
-    scope,
-  );
-}
-
 export function CenterPanel() {
+  const t = useT();
   const tabsByScope = useTabsStore((s) => s.tabsByScope);
   const scope = useTabsStore((s) => s.scope);
   const layout = useTabsStore((s) => s.layout);
@@ -95,13 +82,19 @@ export function CenterPanel() {
   const setScope = useTabsStore((s) => s.setScope);
   const loadFromLayout = useTabsStore((s) => s.loadFromLayout);
   const resizeSplit = useTabsStore((s) => s.resizeSplit);
+  const mergeGroups = useTabsStore((s) => s.mergeGroups);
   const tabs = useTabsStore((s) => s.tabs);
   // #42: the current scope's detached popouts. Subscribed here so the debounced
   // save below re-fires when a popout is moved/resized (setDetachedBounds swaps
   // this array's identity) — otherwise bounds drags wouldn't reach project.json
   // until the next tab/layout change or app quit.
   const detachedGroups = useTabsStore((s) => s.detachedGroupsByScope[s.scope]);
-  const saveLayout = useTabsStore((s) => s.saveLayout);
+  // `persistScope`, not `saveLayout`: the latter persists the tab store's CURRENT
+  // scope into whatever `localFile` it is handed, and those are two independently
+  // tracked values. `activeId` and `localFile` both come from `activeProject` here,
+  // so passing the scope explicitly makes it impossible to write one project's tabs
+  // (or, worse, an empty layout standing in for them) into another project's file.
+  const persistScope = useTabsStore((s) => s.persistScope);
   const updateTabEnv = useTabsStore((s) => s.updateTabEnv);
   // #42: popouts to re-open for the current scope (restored docked, then detached).
   const pendingRespawn = useTabsStore((s) => s.pendingRespawnByScope[s.scope]);
@@ -111,6 +104,10 @@ export function CenterPanel() {
   // sized to the whole panel — panes stay MOUNTED (we reposition, never unmount,
   // so PTYs survive). The frame layer (tab bars/splits) keeps rendering beneath.
   const fullscreenGroupId = useTabsStore((s) => s.fullscreenGroupId);
+  // True while the whole window is being moved by a native title-bar drag
+  // (Windows). Drives `.center-panel.moving`, which hides the heavy pane layer so
+  // WebView2 can keep the frame aligned with the cursor during the OS move loop.
+  const windowMoving = useWindowMoveStore((s) => s.moving);
 
   const { projects, activeId } = useProjectsStore();
 
@@ -119,11 +116,21 @@ export function CenterPanel() {
   // re-render — and tear down/re-add its window listeners — each frame. Live
   // drag state is read via useDragStore.getState() inside the handlers.
   const dragging = useDragStore((s) => s.drag != null);
+  // The dragged tab's identity (stable for the whole gesture — start() sets it
+  // once; the per-frame move/setTarget only swap coords/target). Subscribed as
+  // scalars so they don't re-render the panel on every pointermove, only on
+  // drag start/end. They drive the live source-subwindow collapse below.
+  const dragKind = useDragStore((s) => s.drag?.kind ?? null);
+  const dragKey = useDragStore((s) => s.drag?.key ?? null);
+  const dragFromGroup = useDragStore((s) => s.drag?.fromGroup ?? null);
 
   // Measured pane regions per group id (current scope only). The flat pane
   // layer positions each active pane over its group's body so PTYs never
   // unmount on scope switch / re-tile.
   const [groupRects, setGroupRects] = useState<Record<string, Rect>>({});
+  // Whole-subwindow rects (tab bar + body), used by the focus frame so it wraps
+  // the current subwindow's tab header too — not just its pane region.
+  const [groupFrameRects, setGroupFrameRects] = useState<Record<string, Rect>>({});
   const panelRef = useRef<HTMLDivElement>(null);
   const groupBodyRefs = useRef<Map<string, HTMLDivElement>>(new Map());
 
@@ -131,12 +138,80 @@ export function CenterPanel() {
   const localFile = activeProject?.local_file as string | undefined;
   const projectCwd = resolveProjectDirectory(activeProject);
 
+  // Mount-free remote: a remote project starts DISCONNECTED but its LOCAL tabs
+  // (local agents / local_agent / local-toggled shells — all running in the
+  // mirror via a local PTY) and the file browser (which falls back to the mirror
+  // while disconnected) work offline, so the saved tabs are ALWAYS restored. Only
+  // genuinely-remote panes (`ssh -tt` shells, remote-toggled agents, the SFTP
+  // file tree) would block on the dead pool, so those are held per-pane below
+  // until that pane's project reaches "connected" (see the pane render). Keyed
+  // by the PANE's own scope — panes stay mounted across scope switches, so
+  // holding must not track only the active project's state.
+  const remoteSshByProject = useRemoteStatusStore((s) => s.byProject);
+  // Worker-host lamps (multi-host remote): a pane on a worker holds iff THAT
+  // worker is down, independent of the primary (plan §4.5).
+  const remoteSshByHost = useRemoteStatusStore((s) => s.byHost);
+  // Persistent LOCAL (tmux) sessions (TODO #85): default ON on Unix (no tmux on
+  // Windows). Folded here so the per-pane decision below is a cheap boolean AND.
+  const localPersistEnabled = useSettingsStore(
+    (s) => !IS_WINDOWS && s.settings?.persist_local_sessions !== false,
+  );
+  // Stable per-scope connect handler. TabPane is memoized, so the pane layer only
+  // stays cheap to re-render (e.g. every frame of a divider drag) if its props are
+  // referentially stable — a fresh `() => openRemoteMachines(scopeKey)` arrow every
+  // render would break the memo for every pane. Cached by scope; reads the store
+  // action lazily so the cache never needs invalidating. Opens the unified "Remote
+  // machines" hub (scopeKey is the project id), matching the pill and file view.
+  const connectHandlers = useRef<Map<string, () => void>>(new Map());
+  const getConnect = useCallback((scopeKey: string) => {
+    let h = connectHandlers.current.get(scopeKey);
+    if (!h) {
+      h = () => useRemoteMachinesStore.getState().open(scopeKey);
+      connectHandlers.current.set(scopeKey, h);
+    }
+    return h;
+  }, []);
+
+  // The layout to RENDER: normally the store layout, but while dragging a
+  // subwindow's lone tab it's that layout with the (about-to-empty) source
+  // subwindow pruned — so it collapses live and the siblings reflow to fill,
+  // rather than lingering until the drop. Render-only; the store is untouched
+  // (an aborted drag restores instantly), and the dragged tab's pane stays
+  // mounted in the flat pane layer below (its PTY survives). All measurement and
+  // drop-target resolution keys off THIS tree so the previewed layout is what
+  // the pointer hit-tests against.
+  const renderLayout = useMemo(
+    () => dragPreviewLayout(layout, dragKind, dragKey, dragFromGroup, fullscreenGroupId != null),
+    [layout, dragKind, dragKey, dragFromGroup, fullscreenGroupId],
+  );
+
   useEffect(() => {
     const nextScope = activeId ?? "root";
     setScope(nextScope);
 
     if (!activeId || !localFile) {
-      // Root context: never auto-spawn; leave empty until the user opens a tab.
+      // Root context: the 3D project-blob is the default tab. Seed it the first
+      // time the root scope is entered this session, but only when projects
+      // exist (an empty cloud has nothing to show) and the scope hasn't been
+      // initialized yet — so an intentionally-closed/emptied root stays empty
+      // and we never clobber existing root tabs.
+      if (
+        !activeId &&
+        useProjectsStore.getState().projects.length > 0 &&
+        !("root" in useTabsStore.getState().tabsByScope)
+      ) {
+        useTabsStore.getState().addTab(
+          {
+            label: "Projects",
+            cmd: BLOB_TAB_CMD,
+            cwd: "",
+            kind: "projects3d",
+          },
+          // Eldrun opened this, not the user — it must not show up in the usage
+          // recap as a tab they opened.
+          { seeded: true },
+        );
+      }
       return;
     }
 
@@ -152,7 +227,7 @@ export function CenterPanel() {
     invoke<Record<string, unknown>>("load_project", { localFile })
       .then((proj) => {
         const raw = (proj.tab_layout as LayoutEntry[] | undefined) ?? [];
-        // Keep shell/files tabs, resumable agent tabs (Claude with a sessionId,
+        // Keep shell/files/network tabs, resumable agent tabs (Claude with a sessionId,
         // resumed via --resume), and in-app file-viewer embeds; other agent/embed
         // tabs (including external-app embeds) are dropped. Derive kind from the
         // saved entry or its command. The saved groups tree self-heals
@@ -167,15 +242,9 @@ export function CenterPanel() {
         );
         // Guard: don't overwrite tabs that switch_project_runtime already loaded.
         if (scopeForLoad in useTabsStore.getState().tabsByScope) return;
-        if (restorable.length === 0) {
-          // #57: a freshly-visited project with NO restorable tabs opens its
-          // README.md in an in-app markdown viewer tab by default (never the root
-          // scope; only on first visit, so an intentionally-emptied scope — which
-          // is already "initialized" in tabsByScope, caught by the guard above —
-          // is never re-seeded).
-          void openReadmeDefaultTab(projectCwd, scopeForLoad);
-          return;
-        }
+        // A freshly-visited project with NO restorable tabs stays empty (shows the
+        // empty Subwindow with a "+"); we no longer seed a default README.md tab.
+        if (restorable.length === 0) return;
         // `tab_groups` carries the saved split/group tree (absent → single group).
         const groups = proj.tab_groups as SavedLayoutTree | undefined;
         loadFromLayout(restorable, projectCwd, scopeForLoad, groups ?? undefined);
@@ -183,12 +252,18 @@ export function CenterPanel() {
       .catch(() => {});
   }, [activeId, projectCwd, localFile, setScope, loadFromLayout]);
 
-  // Re-hydrate local_agent tabs that were saved without VIBE_HOME/VIBE_ACTIVE_MODEL.
+  // Re-hydrate vibe local_agent tabs that were saved without VIBE_HOME/
+  // VIBE_ACTIVE_MODEL. Only vibe needs this: `ollama launch`/fallback driver tabs
+  // (cmd "ollama"/"codex"/…) carry everything in cmd+args and have no env to
+  // restore, so they must be skipped — `prepare_local_agent` only knows vibe.
   useEffect(() => {
     if (!activeId) return;
     const { tabs: currentTabs } = useTabsStore.getState();
     const needsEnv = currentTabs.filter(
-      (t) => t.kind === "local_agent" && Object.keys(t.env ?? {}).length === 0,
+      (t) =>
+        t.kind === "local_agent" &&
+        t.cmd === "vibe" &&
+        Object.keys(t.env ?? {}).length === 0,
     );
     for (const tab of needsEnv) {
       invoke<{ vibe_home: string; alias: string }>("prepare_local_agent", { model: tab.label })
@@ -202,10 +277,10 @@ export function CenterPanel() {
   useEffect(() => {
     if (!activeId || !localFile) return;
     const timer = window.setTimeout(() => {
-      saveLayout(localFile).catch(() => {});
+      persistScope(activeId, localFile).catch(() => {});
     }, 300);
     return () => window.clearTimeout(timer);
-  }, [activeId, localFile, tabs, layout, detachedGroups, saveLayout]);
+  }, [activeId, localFile, tabs, layout, detachedGroups, persistScope]);
 
   // #42: re-open popouts that were detached when this scope was last saved. The
   // groups were restored DOCKED (above) so their panes mount and spawn their
@@ -219,7 +294,7 @@ export function CenterPanel() {
       // allowLastGroup: a restored popout may be the scope's only group (its
       // in-window siblings held only non-restorable tabs and were dropped); it
       // must still re-detach into its own window rather than stay docked.
-      detachGroup(t.id, { bounds: t.bounds, allowLastGroup: true });
+      detachGroup(t.id, { bounds: t.bounds, zoom: t.zoom, allowLastGroup: true });
     }
   }, [scope, pendingRespawn, consumePendingRespawn, detachGroup]);
 
@@ -232,6 +307,7 @@ export function CenterPanel() {
     if (!panel) return;
     const base = panel.getBoundingClientRect();
     const next: Record<string, Rect> = {};
+    const frames: Record<string, Rect> = {};
     for (const [id, el] of groupBodyRefs.current) {
       if (!el.isConnected) continue;
       const r = el.getBoundingClientRect();
@@ -241,30 +317,46 @@ export function CenterPanel() {
         width: r.width,
         height: r.height,
       };
+      // The enclosing subwindow box spans the tab header bar + body, so the
+      // focus frame drawn from it wraps the current tab strip too. Clamp the
+      // right edge to the pane region's right (`r`) so a docked files sidebar —
+      // which lives in the same body, to the right of the pane — is excluded.
+      const sub = el.closest(".subwindow");
+      if (sub) {
+        const sr = sub.getBoundingClientRect();
+        frames[id] = {
+          left: sr.left - base.left,
+          top: sr.top - base.top,
+          width: r.right - sr.left,
+          height: sr.height,
+        };
+      }
     }
-    setGroupRects((prev) => {
-      // Avoid pointless state churn (which would re-render every pane).
-      const keys = Object.keys(next);
-      if (keys.length === Object.keys(prev).length) {
-        let same = true;
-        for (const k of keys) {
-          const a = next[k];
-          const b = prev[k];
-          if (!b || a.left !== b.left || a.top !== b.top || a.width !== b.width || a.height !== b.height) {
-            same = false;
-            break;
-          }
+    // Skip state writes when a map is unchanged (a write re-renders every pane).
+    const sameRects = (
+      a: Record<string, Rect>,
+      b: Record<string, Rect>,
+    ): boolean => {
+      const keys = Object.keys(a);
+      if (keys.length !== Object.keys(b).length) return false;
+      for (const k of keys) {
+        const x = a[k];
+        const y = b[k];
+        if (!y || x.left !== y.left || x.top !== y.top || x.width !== y.width || x.height !== y.height) {
+          return false;
         }
-        if (same) return prev;
       }
-      return next;
-    });
+      return true;
+    };
+    setGroupRects((prev) => (sameRects(next, prev) ? prev : next));
+    setGroupFrameRects((prev) => (sameRects(frames, prev) ? prev : frames));
   }, []);
 
-  // Re-measure when the current scope's layout tree changes.
+  // Re-measure when the rendered layout tree changes — including the live drag
+  // collapse/restore, so siblings' reflowed rects are picked up immediately.
   useLayoutEffect(() => {
     measure();
-  }, [measure, layout, scope]);
+  }, [measure, renderLayout, scope]);
 
   // Re-measure on panel resize (split drags resize children without remount).
   useEffect(() => {
@@ -274,7 +366,21 @@ export function CenterPanel() {
     ro.observe(panel);
     for (const el of groupBodyRefs.current.values()) ro.observe(el);
     return () => ro.disconnect();
-  }, [measure, layout, scope]);
+  }, [measure, renderLayout, scope]);
+
+  // Re-measure on OS-window resize. The ResizeObserver above misses OS-level
+  // resizes on older WebKitGTK builds (it fires for split drags but not for the
+  // window growing/shrinking), so panes — positioned at a JS-measured pixel
+  // width/height — would keep their stale size and the file viewers
+  // (markdown/text/PDF, sized off the pane box) never reflow to the new window
+  // width. AppShell bridges Tauri's reliable onResized/onScaleChanged into a DOM
+  // 'resize' event; listening for it here re-runs the measurement. (The detached
+  // window sidesteps this entirely by sizing its single pane with CSS insets.)
+  useEffect(() => {
+    const onResize = () => measure();
+    window.addEventListener("resize", onResize);
+    return () => window.removeEventListener("resize", onResize);
+  }, [measure]);
 
   const registerGroupBody = useCallback(
     (id: string) => (el: HTMLDivElement | null) => {
@@ -349,6 +455,29 @@ export function CenterPanel() {
     const move = useDragStore.getState().move;
 
     const onMove = (e: PointerEvent) => {
+      const d = useDragStore.getState().drag;
+      // Shift during a file drag = "force a new window on release" (see
+      // FileTree's commitRelease). Suppress the in-window split/dock preview so
+      // the animation stops and it's clear nothing will dock here. Clear once
+      // (only when a target is actually set) to avoid per-move store churn;
+      // releasing Shift falls back to resolveTarget and the preview returns.
+      if (e.shiftKey && d?.kind === "file") {
+        if (
+          d.overGroup != null ||
+          d.edge != null ||
+          d.reorderGroup != null ||
+          d.reorderIndex != null
+        ) {
+          useDragStore.getState().setTarget({
+            overGroup: null,
+            edge: null,
+            reorderGroup: null,
+            reorderIndex: null,
+          });
+        }
+        move(e.clientX, e.clientY);
+        return;
+      }
       resolveTarget(e.clientX, e.clientY);
       move(e.clientX, e.clientY);
     };
@@ -381,11 +510,13 @@ export function CenterPanel() {
     const onMouseUp = () => finish();
     // WebKitGTK frequently fires `pointercancel` INSTEAD of `pointerup` to end a
     // mouse drag (its native gesture/selection heuristic claims the stream after
-    // pointermove). Treating cancel as an abort therefore silently swallowed
-    // every drop. So a pointercancel commits the drop too — only an explicit
-    // Escape (aborted) ends without committing.
+    // pointermove), so on Linux a cancel commits the drop (else every drop is
+    // swallowed). On Chromium/WKWebView (Win/mac) a real `pointerup` fires and a
+    // `pointercancel` is a genuine capture loss → abort, not commit. The
+    // `dragPlatform.cancelCommits` flag encodes exactly this split. An explicit
+    // Escape (aborted) always ends without committing.
     const onCancel = () => {
-      if (aborted) { useDragStore.getState().end(); return; }
+      if (aborted || !dragPlatform.cancelCommits) { useDragStore.getState().end(); return; }
       finish();
     };
     const onKeyDown = (e: KeyboardEvent) => {
@@ -409,38 +540,60 @@ export function CenterPanel() {
   }, [dragging, resolveTarget]);
 
   // ── Cross-window drag-to-dock (#42) ───────────────────────────────────────
-  // A popped-out window dragged with Ctrl held streams its pointer (screen CSS
-  // px) to this main window. We map those to our client space, drive the SAME
-  // drop preview as an in-window tab drag (via `resolveTarget` + the drag
-  // store), and dock the group on release. `resolveTarget` is read through a ref
-  // so this listener — mounted once — always hit-tests against current group
-  // rects. Setting the detached drag in the store flips `.center-panel.dragging`
-  // on, which makes panes pointer-events:none so elementFromPoint can reach the
-  // tab bars/bodies. The popout owns the pointer (implicit grab), so the main
-  // window never sees real pointer events during the gesture and the in-window
-  // drag effect above stays inert (its handlers also guard `kind === "detached"`).
+  // A popped-out window dragged back streams its OS cursor (PHYSICAL desktop px —
+  // the canonical cross-window space, see lib/coords) to this main window. We map
+  // it into OUR client px via our own frame (innerPhys/scale — the only DPI-correct
+  // conversion), drive the SAME drop preview as an in-window tab drag (via
+  // `resolveTarget` + the drag store), and dock the group on release.
+  // `resolveTarget` is read through a ref so this listener — mounted once — always
+  // hit-tests against current group rects. Setting the detached drag in the store
+  // flips `.center-panel.dragging` on, which makes panes pointer-events:none so
+  // elementFromPoint can reach the tab bars/bodies. The popout owns the pointer, so
+  // the main window never sees real pointer events during the gesture and the
+  // in-window drag effect above stays inert (its handlers also guard `kind ===
+  // "detached"`).
   const resolveTargetRef = useRef(resolveTarget);
   resolveTargetRef.current = resolveTarget;
   useEffect(() => {
     const win = getCurrentWindow();
-    // The main window's content-area origin in screen CSS px. Streamed screen
-    // coords minus this origin give client coords. Refreshed at each drag start
-    // (the main window doesn't move mid-gesture).
-    let origin = { x: 0, y: 0 };
-    const refreshOrigin = async () => {
+    // Our own window frame (physical px). Streamed physical cursor → our client px
+    // via `physToClient` (innerPhys/scale). Snapshotted at each drag start (the
+    // main window doesn't move mid-gesture).
+    let frame: WindowFrame | null = null;
+    const refreshFrame = async () => {
       try {
-        const scale = await win.scaleFactor();
-        const pos = await win.innerPosition();
-        const logical = pos.toLogical(scale);
-        origin = { x: logical.x, y: logical.y };
+        frame = await snapshotFrame(win);
       } catch {
-        origin = { x: 0, y: 0 };
+        frame = null;
       }
     };
-    const toClient = (screenX: number, screenY: number) => ({
-      x: screenX - origin.x,
-      y: screenY - origin.y,
-    });
+    const toClient = (cursorPhysX: number, cursorPhysY: number) =>
+      frame
+        ? physToClient(frame, { x: cursorPhysX, y: cursorPhysY })
+        : { x: cursorPhysX, y: cursorPhysY };
+
+    // #42: the SAME popout hit-test `TabBar` uses for main→popout drags, now also
+    // driving popout-ORIGINATED drags — so a tab dragged out of popout A lights up
+    // and docks into popout B exactly like a main→popout drag (the unification).
+    // Created per gesture on START, disposed on END. `dragSrcGroupId` is the source
+    // popout's record id, excluded from sibling hit-tests (a release over the source
+    // is handled inside it and arrives here as `cancelled:true`).
+    let session: ReturnType<typeof startDetachedDropSession> | null = null;
+    let dragSrcGroupId: string | null = null;
+    let dragLabel: string | undefined;
+    const endSession = () => {
+      session?.dispose();
+      session = null;
+      dragSrcGroupId = null;
+      dragLabel = undefined;
+    };
+    // The sibling popout under the physical cursor, or null (none, or it's the
+    // source popout — a self-drop is handled locally in the popout).
+    const siblingAt = (phys: PhysPoint | null) => {
+      if (!phys || !session) return null;
+      const pop = session.at(phys);
+      return pop && pop.groupId !== dragSrcGroupId ? pop : null;
+    };
 
     const unsubs: Array<() => void> = [];
     let cancelled = false;
@@ -454,12 +607,21 @@ export function CenterPanel() {
 
     reg(
       listen<DetachedDragStart>(DETACHED_DRAG_START, (ev) => {
-        const { scope: dScope, groupId, label, screenX, screenY, tabKey } = ev.payload;
+        const { scope: dScope, groupId, label, cursorPhysX, cursorPhysY, tabKey, paneId } =
+          ev.payload;
+        // Open a popout drop session for THIS gesture so sibling popouts of the
+        // scope become live drop targets (highlight on MOVE, dock on END) — the
+        // same machinery `TabBar` uses for main→popout drags.
+        endSession();
+        session = startDetachedDropSession();
+        dragSrcGroupId = groupId;
+        dragLabel = label;
+        void session.resolve();
         // Start the drag synchronously so the high-frequency MOVE poll that
         // follows isn't dropped by its `kind !== "detached"` guard while we await
-        // the origin. Seed with the current (stale) origin; refreshOrigin() then
-        // corrects it and we re-resolve. The main window doesn't move mid-gesture.
-        const seed = toClient(screenX, screenY);
+        // the frame. Seed with the current (stale/identity) frame; refreshFrame()
+        // then corrects it and we re-resolve. The main window doesn't move mid-gesture.
+        const seed = toClient(cursorPhysX, cursorPhysY);
         useDragStore.getState().startDetachedDrag({
           label,
           pointerX: seed.x,
@@ -467,11 +629,12 @@ export function CenterPanel() {
           detachedScope: dScope,
           detachedGroupId: groupId,
           detachedTabKey: tabKey,
+          detachedPaneId: paneId,
         });
         resolveTargetRef.current(seed.x, seed.y);
-        void refreshOrigin().then(() => {
+        void refreshFrame().then(() => {
           if (useDragStore.getState().drag?.kind !== "detached") return;
-          const { x, y } = toClient(screenX, screenY);
+          const { x, y } = toClient(cursorPhysX, cursorPhysY);
           useDragStore.getState().move(x, y);
           resolveTargetRef.current(x, y);
         });
@@ -481,121 +644,214 @@ export function CenterPanel() {
     reg(
       listen<DetachedDragMove>(DETACHED_DRAG_MOVE, (ev) => {
         if (useDragStore.getState().drag?.kind !== "detached") return;
-        const { x, y } = toClient(ev.payload.screenX, ev.payload.screenY);
+        const phys: PhysPoint = {
+          x: ev.payload.cursorPhysX,
+          y: ev.payload.cursorPhysY,
+        };
+        const { x, y } = toClient(phys.x, phys.y);
         useDragStore.getState().move(x, y);
         resolveTargetRef.current(x, y);
+        // Light up a SIBLING popout under the cursor (never the source), so a
+        // popout→popout drag previews its drop just like a main→popout drag.
+        if (session) session.hover(siblingAt(phys), phys, dragLabel);
       }),
     );
 
     reg(
       listen<DetachedDragEnd>(DETACHED_DRAG_END, (ev) => {
         const d = useDragStore.getState().drag;
-        if (d?.kind !== "detached") return;
-        // END carries the LAST OS-cursor position (the DOM release event fires
-        // inside the popout on WebKitGTK, so we cannot trust `d.pointerX/Y` here).
-        // Re-map it to client coords and re-resolve the drop target so `inMain`
-        // and the target reflect where the cursor actually is on release.
+        if (d?.kind !== "detached") {
+          endSession();
+          return;
+        }
+        // END carries the LAST OS-cursor position in PHYSICAL desktop px (the DOM
+        // release fires inside the popout on WebKitGTK, so `d.pointerX/Y` is stale).
+        // Re-map it + re-resolve so `inMain`, the sibling hit-test, and the main-
+        // side target all reflect where the cursor actually ended.
+        const phys: PhysPoint | null =
+          ev.payload.cursorPhysX != null && ev.payload.cursorPhysY != null
+            ? { x: ev.payload.cursorPhysX, y: ev.payload.cursorPhysY }
+            : null;
         let px = d.pointerX;
         let py = d.pointerY;
-        if (ev.payload.screenX != null && ev.payload.screenY != null) {
-          const c = toClient(ev.payload.screenX, ev.payload.screenY);
+        if (phys) {
+          const c = toClient(phys.x, phys.y);
           px = c.x;
           py = c.y;
           useDragStore.getState().move(px, py);
           resolveTargetRef.current(px, py);
         }
-        // Re-read the drag after the final resolve so over/reorder targets are
-        // the ones the cursor ended over.
         const f = useDragStore.getState().drag;
-        // Dock only when released over THIS window's content and not cancelled;
-        // dropping outside the main window (or Escape) leaves the popout floating.
         const inMain =
-          px >= 0 &&
-          py >= 0 &&
-          px <= window.innerWidth &&
-          py <= window.innerHeight;
-        if (
-          !ev.payload.cancelled &&
-          inMain &&
-          f?.kind === "detached" &&
-          f.detachedGroupId &&
-          f.detachedScope &&
-          f.detachedTabKey
-        ) {
-          // Single-tab dock-back: dock just the dragged tab into its OWN scope's
-          // layout at the resolved target (a tab bar → merge; a body edge →
-          // split; otherwise default placement), then re-seed the popout so it
-          // drops the docked tab (or, if that emptied it, the popout has already
-          // closed). The resolved targets are the active scope's groups, so they
-          // only apply when the popout's scope IS the active one; cross-scope
-          // falls through to default placement inside its stored layout.
-          const store = useTabsStore.getState();
-          const sameScope = store.scope === f.detachedScope;
-          const target =
-            sameScope && f.reorderGroup
-              ? { targetGroupId: f.reorderGroup, edge: "center" as const }
-              : sameScope && f.overGroup && f.edge
-                ? { targetGroupId: f.overGroup, edge: f.edge }
-                : undefined;
-          store.attachDetachedTab(
-            f.detachedScope,
-            f.detachedGroupId,
-            f.detachedTabKey,
-            target,
-          );
-          const entry = useTabsStore
-            .getState()
-            .detachedGroupsByScope[f.detachedScope]?.find(
-              (d) => d.id === f.detachedGroupId,
-            );
-          if (entry) {
-            const seed = buildSeed(
-              f.detachedScope,
-              f.detachedGroupId,
-              useTabsStore.getState().tabsByScope[f.detachedScope] ?? [],
-              entry.subtree,
-            );
-            void emit(detachedSeedEvent(entry.label), seed);
-          }
+          px >= 0 && py >= 0 && px <= window.innerWidth && py <= window.innerHeight;
+        // The sibling popout under the final cursor (null if none / it's the source).
+        const sibling = siblingAt(phys);
+        const overPopoutId = sibling?.groupId ?? null;
+        const store = useTabsStore.getState();
+        const done = () => {
+          endSession();
           useDragStore.getState().end();
+        };
+
+        // ── Single dragged tab: unified {newWindow | dockDetached | dockMain} ────
+        if (f?.kind === "detached" && f.detachedScope && f.detachedGroupId && f.detachedTabKey) {
+          const scope = f.detachedScope;
+          const srcGroup = f.detachedGroupId;
+          const tabKey = f.detachedTabKey;
+          const decision = decideDetachedTabDrop({
+            cancelled: ev.payload.cancelled,
+            shift: ev.payload.shift ?? false,
+            inMain,
+            overPopoutId,
+            srcGroupId: srcGroup,
+          });
+          switch (decision.kind) {
+            case "dockDetached": {
+              // Move the tab from its source popout INTO the sibling popout under
+              // the cursor, at the pane the cursor resolves to. Re-seed BOTH windows
+              // (the destination plays the drop-in landing on the moved tab).
+              const target = phys && sibling ? session!.targetAt(sibling, phys) : undefined;
+              store.moveTabBetweenDetached(scope, srcGroup, decision.toGroupId, tabKey, target);
+              reseedDetached(scope, decision.toGroupId, tabKey);
+              reseedDetached(scope, srcGroup);
+              break;
+            }
+            case "dockMain": {
+              // Dock just the dragged tab into its OWN scope's in-window layout at
+              // the resolved target (bar → merge; body edge → split; else default).
+              // Targets only apply when the popout's scope IS the active one.
+              const sameScope = store.scope === scope;
+              const target =
+                sameScope && f.reorderGroup
+                  ? { targetGroupId: f.reorderGroup, edge: "center" as const }
+                  : sameScope && f.overGroup && f.edge
+                    ? { targetGroupId: f.overGroup, edge: f.edge }
+                    : undefined;
+              store.attachDetachedTab(scope, srcGroup, tabKey, target);
+              if (sameScope) useTabLandStore.getState().markLanded(tabKey);
+              reseedDetached(scope, srcGroup);
+              break;
+            }
+            case "newWindow": {
+              // Shift, or a free-space release: pop the tab into its OWN new popout
+              // at the PHYSICAL cursor (Rust `.position()` is physical). A lone-tab
+              // source is refused downstream (null) → clean no-op, never a hang.
+              if (phys) {
+                const bounds = {
+                  x: Math.round(phys.x - 80),
+                  y: Math.round(phys.y - 8),
+                  w: 900,
+                  h: 640,
+                };
+                const newLabel = store.detachTabToNewWindow(scope, srcGroup, tabKey, bounds);
+                if (newLabel) reseedDetached(scope, srcGroup);
+              }
+              break;
+            }
+            case "local":
+            case "none":
+              // The source popout already committed a within-popout drop (or the
+              // gesture was cancelled) — nothing for the host to do.
+              break;
+          }
+          done();
+          return;
+        }
+
+        // ── One pane of a multi-pane popout: dock JUST that pane, or pop it into
+        // its own window — NEVER the whole popout (a pane drop must not haul its
+        // sibling panes into the main window). ────────────────────────────────
+        if (f?.kind === "detached" && f.detachedScope && f.detachedGroupId && f.detachedPaneId) {
+          const scope = f.detachedScope;
+          const srcGroup = f.detachedGroupId;
+          const paneId = f.detachedPaneId;
+          const decision = decideDetachedPaneDrop({
+            cancelled: ev.payload.cancelled,
+            shift: ev.payload.shift ?? false,
+            inMain,
+            overPopoutId,
+            srcGroupId: srcGroup,
+          });
+          switch (decision.kind) {
+            case "dockMain": {
+              // Dock only the dragged pane at the resolved target (bar → merge;
+              // body edge → split; else its own pane). Targets only apply when
+              // the popout's scope IS the active one.
+              const sameScope = store.scope === scope;
+              const target =
+                sameScope && f.reorderGroup
+                  ? { targetGroupId: f.reorderGroup, edge: "center" as const }
+                  : sameScope && f.overGroup && f.edge
+                    ? { targetGroupId: f.overGroup, edge: f.edge }
+                    : undefined;
+              store.attachDetachedPane(scope, srcGroup, paneId, target);
+              reseedDetached(scope, srcGroup);
+              break;
+            }
+            case "newWindow": {
+              // Shift, or a free-space release: the pane becomes its own popout
+              // at the physical cursor. A lone-pane source is refused downstream
+              // (null) → clean no-op.
+              if (phys) {
+                const bounds = {
+                  x: Math.round(phys.x - 80),
+                  y: Math.round(phys.y - 8),
+                  w: 900,
+                  h: 640,
+                };
+                const newLabel = store.detachPaneToNewWindow(scope, srcGroup, paneId, bounds);
+                if (newLabel) reseedDetached(scope, srcGroup);
+              }
+              break;
+            }
+            case "none":
+              // Cancelled / released over the source or a sibling popout — stay put.
+              break;
+          }
+          done();
           return;
         }
-        if (!ev.payload.cancelled && inMain && f?.kind === "detached" && f.detachedGroupId) {
-          const store = useTabsStore.getState();
-          // Mirror the button-path branch in `listenDetachedHost` (detached.ts):
-          // `attachGroup` re-injects only into the ACTIVE scope's live layout, so
-          // it can only dock a group whose scope is currently active. When the
-          // popout's scope is NOT the active one, re-inject into that scope's
-          // STORED layout via `dropDetachedGroup` instead — otherwise attachGroup
-          // silently no-ops and the drop is swallowed.
-          if (f.detachedScope && store.scope === f.detachedScope) {
-            if (f.reorderGroup) {
-              // Released over a tab bar → merge into that group.
-              store.attachGroup(f.detachedGroupId, {
-                targetGroupId: f.reorderGroup,
-                edge: "center",
-              });
-            } else if (f.overGroup && f.edge) {
-              store.attachGroup(f.detachedGroupId, {
-                targetGroupId: f.overGroup,
-                edge: f.edge,
-              });
+
+        // ── Whole group: dock into main, or stay floating ───────────────────────
+        if (f?.kind === "detached" && f.detachedGroupId && f.detachedScope) {
+          const decision = decideDetachedGroupDrop({
+            cancelled: ev.payload.cancelled,
+            shift: ev.payload.shift ?? false,
+            inMain,
+            overPopoutId,
+            srcGroupId: f.detachedGroupId,
+          });
+          if (decision.kind === "dockMain") {
+            // Mirror listenDetachedHost: attachGroup re-injects only into the ACTIVE
+            // scope's live layout; a non-active scope re-injects into its STORED
+            // layout via dropDetachedGroup (else attachGroup silently no-ops).
+            if (store.scope === f.detachedScope) {
+              if (f.reorderGroup) {
+                store.attachGroup(f.detachedGroupId, {
+                  targetGroupId: f.reorderGroup,
+                  edge: "center",
+                });
+              } else if (f.overGroup && f.edge) {
+                store.attachGroup(f.detachedGroupId, {
+                  targetGroupId: f.overGroup,
+                  edge: f.edge,
+                });
+              } else {
+                store.attachGroup(f.detachedGroupId);
+              }
             } else {
-              // Over the panel but no resolved target → default placement.
-              store.attachGroup(f.detachedGroupId);
+              store.dropDetachedGroup(f.detachedScope, f.detachedGroupId);
             }
-          } else if (f.detachedScope) {
-            // Cross-scope drop: re-inject into the popout's stored layout (target
-            // edges don't apply to a layout that isn't currently rendered).
-            store.dropDetachedGroup(f.detachedScope, f.detachedGroupId);
           }
+          // `float` (Shift / free space / over a sibling popout) → leave it be.
         }
-        useDragStore.getState().end();
+        done();
       }),
     );
 
     return () => {
       cancelled = true;
+      endSession();
       for (const fn of unsubs) fn();
     };
   }, []);
@@ -624,6 +880,28 @@ export function CenterPanel() {
     }
     return { activeKeyOfGroup, groupOfKey };
   }, [layoutByScope, scope]);
+  // Groups whose active tab is a scroll-syncable viewer (text/code, markdown, or
+  // PDF). Only these can host the divider scroll-link button, and only these are
+  // considered valid link endpoints. Rebuilt when the layout or tabs change.
+  const syncableGroups = useMemo(() => {
+    const byKey = new Map(tabs.map((t) => [t.key, t]));
+    const set = new Set<string>();
+    for (const g of allGroups(layoutByScope[scope] ?? null)) {
+      const t = g.activeKey ? byKey.get(g.activeKey) : undefined;
+      if (
+        t?.kind === "embed" &&
+        (t.viewer === "text" || t.viewer === "markdown" || t.viewer === "pdf")
+      ) {
+        set.add(g.id);
+      }
+    }
+    return set;
+  }, [layoutByScope, scope, tabs]);
+  // Drop any scroll-link whose endpoints are no longer both syncable viewers
+  // (a subwindow's active tab changed to a shell/image, or the group vanished).
+  useEffect(() => {
+    useScrollSyncStore.getState().prune(syncableGroups);
+  }, [syncableGroups]);
   // #62: fullscreen is active only when the stored group actually exists in the
   // current scope (a stale id from another scope is ignored). When active, the
   // fullscreened group's pane is sized to the whole panel and all others hidden.
@@ -636,19 +914,21 @@ export function CenterPanel() {
   return (
     <div
       ref={panelRef}
-      className={`center-panel${dragging ? " dragging" : ""}${fsActive ? " fullscreen" : ""}`}
+      className={`center-panel${dragging ? " dragging" : ""}${fsActive ? " fullscreen" : ""}${windowMoving ? " moving" : ""}`}
     >
       {/* Subwindow frame layer: the recursive layout tree for the current scope.
           Each group body is an empty measured slot; panes are positioned over
           it by the flat layer below. */}
-      {layout ? (
+      {renderLayout ? (
         <LayoutTree
-          node={layout}
+          node={renderLayout}
           projectCwd={projectCwd}
           resizeSplit={resizeSplit}
+          mergeGroups={mergeGroups}
           panelRef={panelRef}
           registerGroupBody={registerGroupBody}
           onResized={measure}
+          syncableGroups={syncableGroups}
         />
       ) : (
         // No tabs yet: render an empty subwindow so its tab bar's "+" is always
@@ -664,7 +944,13 @@ export function CenterPanel() {
             className="center-placeholder"
             style={{ height: "100%" }}
           >
-            No tabs open — use + to create one
+            <div className="center-placeholder-card">
+              <div className="center-placeholder-title">{t("centerPanel.noTabsOpen")}</div>
+              <div className="center-placeholder-hint">
+                {t("centerPanel.noTabsHintPre")} <span className="center-placeholder-key">+</span>{" "}
+                {t("centerPanel.noTabsHintPost")}
+              </div>
+            </div>
           </div>
         </Subwindow>
       )}
@@ -701,6 +987,97 @@ export function CenterPanel() {
                 ...(fsActive && groupId === fullscreenGroupId ? { zIndex: 5 } : {}),
               }
             : { display: "none" };
+          // Mount-free remote, per-pane gating. A remote project's LOCAL panes
+          // run on the mirror and work offline; only remote-I/O panes must wait
+          // for the pool. Keyed by THIS pane's scope (not the active project) so
+          // a disconnected remote project switched away from never un-holds.
+          const paneProject = projects.find((p) => p.id === scopeKey);
+          const paneRemoteProj = !!paneProject?.remote;
+          const paneDisconnected =
+            paneRemoteProj && remoteSshByProject[scopeKey]?.ssh !== "connected";
+          // A terminal pane runs on a remote host when its effective locality
+          // resolves to one (primary or a worker). Held while THAT host's pool is
+          // down: spawning `ssh -tt` now would block on the dead pool. Multi-host:
+          // a pane on gpu-2 holds iff gpu-2 is down, independent of the primary
+          // (plan §4.5).
+          const rawHostId = remoteHostIdOf(effectiveTabLocation(tab));
+          // A tab naming a worker that no longer exists (machine removed) falls
+          // back to the primary — matching the backend's wrap_pty_options (plan §8).
+          const paneHostId =
+            rawHostId && rawHostId !== "primary" &&
+            !paneProject?.compute_hosts?.some((h) => h.id === rawHostId)
+              ? "primary"
+              : rawHostId;
+          const paneHostSsh =
+            paneHostId === "primary"
+              ? remoteSshByProject[scopeKey]?.ssh
+              : paneHostId
+                ? remoteSshByHost[scopeKey]?.[paneHostId]?.ssh
+                : undefined;
+          const holdRemoteTerminal =
+            paneRemoteProj &&
+            isPtyTabKind(tab.kind) &&
+            paneHostId !== null &&
+            paneHostSsh !== "connected";
+          // The label of the host this pane runs on (primary host, or the worker's
+          // label), for the hold placeholder + hover card.
+          const paneHostLabel =
+            paneHostId === "primary" || paneHostId === null
+              ? (paneProject?.remote?.host ?? "")
+              : (() => {
+                  const w = paneProject?.compute_hosts?.find((h) => h.id === paneHostId);
+                  return w?.label || w?.host || paneHostId;
+                })();
+          // The Files-tab browse dir: while a remote project is disconnected the
+          // SFTP tree can't be listed (it would freeze the main thread), so browse
+          // the local mirror instead — the same synced working copy the local tabs
+          // use. FileBrowser re-lists on `projectDir` change, so it swaps back to
+          // the remote tree once the pool connects. (Resolved here, not inside
+          // TabPane, because the popout has no projects store to resolve it.)
+          const filesProjectDir = paneDisconnected
+            ? localTabCwd(
+                { kind: "files" },
+                {
+                  isRemoteProject: true,
+                  projectDirectory: resolveProjectDirectory(paneProject),
+                  mirror: resolveLocalMirror(paneProject),
+                  fallback: tab.cwd,
+                },
+              )
+            : tab.cwd;
+          // SSH-sync Phase 0: a local-on-remote tab runs in the project's local
+          // mirror (state dir), not the remote tree it can't reach.
+          const terminalCwd = localTabCwd(tab, {
+            isRemoteProject: !!paneProject?.remote,
+            projectDirectory: resolveProjectDirectory(paneProject),
+            mirror: resolveLocalMirror(paneProject),
+            fallback: tab.cwd,
+          });
+          // Run this tab inside the project's session container when the toggle is
+          // on: every PTY tab except `local_agent` (host-bound) execs into the one
+          // shared container. Local projects only. Derived here so restored tabs
+          // are covered too. NOTE: this flag is in TerminalView's spawn deps —
+          // flipping the toggle respawns every live tab (ProjectPill confirms when
+          // that would destroy a non-resumable agent conversation).
+          const sandbox =
+            (tab.kind === "agent" || tab.kind === "shell") &&
+            scopeKey !== "root" &&
+            !!paneProject?.sandbox?.enabled &&
+            !paneProject?.remote;
+          // Persistent sessions (TODO #85): the stable, persisted session name to
+          // wrap a shell/script tab in a tmux session, so a long run survives — for a
+          // REMOTE tab an SSH drop / relaunch (default ON per project, opt out via
+          // the pill toggle), for a LOCAL tab an Eldrun crash (default ON on Unix via
+          // `persist_local_sessions`). Shell tabs only (Python runs open a shell tab),
+          // never agents; never the root scope. In TerminalView's spawn deps, so
+          // toggling respawns the tab. Undefined ⇒ no tmux wrap.
+          const localRunning =
+            !paneProject?.remote || effectiveTabLocation(tab) === "local";
+          const tmuxSession =
+            shouldPersistTab(tab.kind, paneHostId, paneProject?.remote, tab.ephemeral) ||
+            shouldPersistLocalTab(tab.kind, scopeKey, localRunning, localPersistEnabled)
+              ? tab.tmuxSession
+              : undefined;
           return (
             <div
               key={`${scopeKey}/${tab.key}`}
@@ -709,47 +1086,37 @@ export function CenterPanel() {
               // thumbnail into the drag ghost (see DragGhost / startTabDrag).
               data-scope-key={scopeKey}
               data-tab-key={tab.key}
+              // Clicking anywhere in a pane focuses its subwindow. The panes sit
+              // in this layer ABOVE the .subwindow frame, so Subwindow's own
+              // mousedown-capture only sees clicks on its tab bar — the body
+              // clicks land here. Capture-phase + no preventDefault so the
+              // terminal/viewer still receives the click for focus/selection.
+              onMouseDownCapture={() => {
+                if (!groupId) return;
+                const t = useTabsStore.getState();
+                if (t.focusedGroupId !== groupId) t.focusGroup(groupId);
+              }}
               style={style}
             >
-              {tab.kind === "files" ? (
-                <FileBrowser
-                  projectDir={tab.cwd}
-                  projectId={scopeKey === "root" ? null : scopeKey}
-                  active={visible}
-                />
-              ) : tab.kind === "embed" ? (
-                tab.viewer ? (
-                  <FileViewerPane
-                    viewer={tab.viewer}
-                    path={tab.embedPath ?? ""}
-                    projectId={scopeKey === "root" ? null : scopeKey}
-                    tabKey={tab.key}
-                    visible={visible}
-                  />
-                ) : (
-                  <EmbedPane
-                    path={tab.embedPath ?? ""}
-                    exec={tab.embedExec}
-                    projectId={scopeKey === "root" ? null : scopeKey}
-                    visible={visible}
-                  />
-                )
-              ) : (
-                <TerminalView
-                  // PTY ids must include the scope: tab keys alone can collide
-                  // across projects (restored layouts), which would attach two
-                  // projects' terminals to the same PTY stream.
-                  id={`${scopeKey}:${tab.key}`}
-                  cmd={tab.cmd}
-                  args={tab.args ?? []}
-                  env={tab.env ?? {}}
-                  initialInput={tab.initialInput}
-                  cwd={tab.cwd}
-                  localOnly={tab.kind === "local_agent"}
-                  visible={visible}
-                  focused={visible}
-                />
-              )}
+              {/* The shared per-tab render switch (`components/tabs/TabPane`), the
+                  SAME one every detached popout renders. The main window owns the
+                  tab store (`ownsTabs`) and the projects store, so it resolves the
+                  mirror/sandbox/hold props the popout can't. New pane kinds/props
+                  go in TabPane so they reach both windows at once. */}
+              <TabPane
+                tab={tab}
+                scope={scopeKey}
+                visible={visible}
+                groupId={groupId}
+                ownsTabs
+                onConnect={getConnect(scopeKey)}
+                holdRemoteTerminal={holdRemoteTerminal}
+                remoteHost={paneHostLabel}
+                filesProjectDir={filesProjectDir}
+                terminalCwd={terminalCwd}
+                sandbox={sandbox}
+                tmuxSession={tmuxSession}
+              />
             </div>
           );
         })}
@@ -761,6 +1128,15 @@ export function CenterPanel() {
           a subwindow body. Coordinates come from the same measured group rects. */}
       <SplitPreviewOverlay groupRects={groupRects} />
 
+      {/* Focus frame (always) + Shift+↑/↓ subwindow numbering (transient), drawn
+          above the pane layer for the same reason as the split preview — the
+          opaque panes (z-index:2) would otherwise cover an in-body frame. */}
+      <FocusFrameOverlay
+        groupRects={groupRects}
+        frameRects={groupFrameRects}
+        orderedIds={allGroups(layoutByScope[scope] ?? null).map((g) => g.id)}
+      />
+
       {/* Floating ghost following the pointer during a drag. */}
       <DragGhost />
 
@@ -829,6 +1205,90 @@ export function SplitPreviewOverlay({ groupRects }: { groupRects: Record<string,
   return <div className="split-preview" style={{ left, top, width, height }} />;
 }
 
+/**
+ * The focused-subwindow marker, drawn above the pane layer (see the render site
+ * for why). Two roles:
+ *  - Always: a light accent frame around the focused subwindow's pane rect.
+ *  - While Shift+↑/↓ subwindow-nav is active: the frame follows the previewed
+ *    group and every subwindow shows a numbered badge — the committed focus is
+ *    0, others numbered in document order (wrapping) so ↑/↓ read as relative
+ *    steps. Focus commits (moving the frame's committed home) on Shift release.
+ * `pointer-events: none`, panel-relative coords from the same measured rects.
+ */
+export function FocusFrameOverlay({
+  groupRects,
+  frameRects,
+  orderedIds,
+}: {
+  groupRects: Record<string, Rect>;
+  frameRects: Record<string, Rect>;
+  orderedIds: string[];
+}) {
+  const focusedGroupId = useTabsStore((s) => s.focusedGroupId);
+  const navActive = useSubwindowNavStore((s) => s.active);
+  const previewGroupId = useSubwindowNavStore((s) => s.previewGroupId);
+  // Only the OS-focused window draws its focus frame, so a blurred main window
+  // doesn't show an active subwindow alongside a focused popout (#42).
+  const windowFocused = useWindowFocused();
+
+  const frameId = navActive && previewGroupId ? previewGroupId : focusedGroupId;
+  // Prefer the whole-subwindow rect (tab bar + body); fall back to the pane
+  // region if a subwindow box wasn't measured (e.g. the empty-scope slot).
+  const frameRect = frameId
+    ? (frameRects[frameId] ?? groupRects[frameId])
+    : undefined;
+  const n = orderedIds.length;
+  const f = frameId ? orderedIds.indexOf(frameId) : -1;
+
+  // Colour the focus frame with the focused subwindow's active-tab group colour
+  // (the same TAB_ACCENT that paints that tab's stripe), so the frame and the
+  // current tab read as one continuous accent. Falls back to the CSS default
+  // (var(--accent)) when the kind can't be resolved.
+  const layout = useTabsStore((s) => s.layoutByScope[s.scope] ?? null);
+  const tabEntries = useTabsStore((s) => s.tabsByScope[s.scope]);
+  const activeTabKey = frameId ? findGroup(layout, frameId)?.activeKey : null;
+  const activeKind = activeTabKey
+    ? tabEntries?.find((t) => t.key === activeTabKey)?.kind
+    : undefined;
+  const frameColor = activeKind ? TAB_ACCENT[activeKind] : undefined;
+
+  return (
+    <>
+      {windowFocused && frameRect && (
+        <div
+          className="focus-frame"
+          style={{
+            left: frameRect.left,
+            top: frameRect.top,
+            width: frameRect.width,
+            height: frameRect.height,
+            outlineColor: frameColor,
+          }}
+        />
+      )}
+      {navActive &&
+        f >= 0 &&
+        orderedIds.map((id, p) => {
+          const r = groupRects[id];
+          if (!r) return null;
+          const down = (p - f + n) % n;
+          const up = (n - down) % n;
+          const label =
+            down === 0 ? "0" : down <= up ? `${down}↓` : `${up}↑`;
+          return (
+            <div
+              key={id}
+              className="subwindow-number"
+              style={{ left: r.left + 6, top: r.top + 6 }}
+            >
+              {label}
+            </div>
+          );
+        })}
+    </>
+  );
+}
+
 /**
  * The dragged tab floating at the pointer: its label plus, for tab drags, a
  * scaled thumbnail of the tab's live CONTENT (a clone captured at drag start)
@@ -849,14 +1309,37 @@ export function DragGhost() {
   const pointerX = useDragStore((s) => s.drag?.pointerX ?? 0);
   const pointerY = useDragStore((s) => s.drag?.pointerY ?? 0);
   const label = useDragStore((s) => s.drag?.label ?? "");
-  // During a file drag (pointer-based drag-to-tab), remind the user that holding
-  // Alt switches to a native drag that can be dropped into an embedded browser.
+  // During a file drag (pointer-based drag-to-tab) the ghost lists the available
+  // drop options so the user can see what each release will do.
   const isFileDrag = useDragStore((s) => s.drag?.kind === "file");
   const node = useDragStore((s) => s.drag?.previewNode ?? null);
   const srcW = useDragStore((s) => s.drag?.previewW ?? 0);
   const srcH = useDragStore((s) => s.drag?.previewH ?? 0);
   const thumbRef = useRef<HTMLDivElement>(null);
 
+  // Track Shift/Ctrl live so the options legend can highlight "force new
+  // window" / "copy out to another app" while the file drag is in flight (a
+  // modifier can toggle without a pointer move, which wouldn't otherwise
+  // re-render the ghost). Ctrl only marks the option here — FileTree's own
+  // drag gesture decides when to actually hand off to the native OS drag.
+  const [shiftHeld, setShiftHeld] = useState(false);
+  const [ctrlHeld, setCtrlHeld] = useState(false);
+  useEffect(() => {
+    if (!isFileDrag) return;
+    const sync = (e: KeyboardEvent) => {
+      setShiftHeld(e.shiftKey);
+      setCtrlHeld(e.ctrlKey);
+    };
+    window.addEventListener("keydown", sync);
+    window.addEventListener("keyup", sync);
+    return () => {
+      window.removeEventListener("keydown", sync);
+      window.removeEventListener("keyup", sync);
+      setShiftHeld(false);
+      setCtrlHeld(false);
+    };
+  }, [isFileDrag]);
+
   // Mount the cloned pane once per drag and scale it to fit GHOST_THUMB_W. Done
   // in an effect (not inline) so the heavy clone isn't re-appended on every
   // pointermove re-render — only the ghost's left/top change then.
@@ -878,7 +1361,23 @@ export function DragGhost() {
     <div className="tab-drag-ghost" style={{ left: pointerX, top: pointerY }}>
       <div className="tab-drag-ghost-label">{label}</div>
       {isFileDrag ? (
-        <div className="tab-drag-ghost-hint">Hold ⌥ Alt to drop into browser</div>
+        <div className="tab-drag-ghost-opts">
+          {/* Exactly ONE option is marked at a time — it is what THIS release
+              would do. Ctrl (copy out) wins over Shift (force a new window),
+              matching the drag itself: once the cursor leaves the window with
+              Ctrl held, the OS drag owns the drop and the in-app targets are
+              out of the picture. */}
+          <div className="tab-drag-ghost-opt">Drop on a folder → move file there</div>
+          <div className={`tab-drag-ghost-opt${!shiftHeld && !ctrlHeld ? " active" : ""}`}>
+            Drop → open in new window / dock into popout
+          </div>
+          <div className={`tab-drag-ghost-opt${shiftHeld && !ctrlHeld ? " active" : ""}`}>
+            ⇧ Shift → force a new window
+          </div>
+          <div className={`tab-drag-ghost-opt${ctrlHeld ? " active" : ""}`}>
+            ⌃ Ctrl → copy out to another app
+          </div>
+        </div>
       ) : null}
       {node ? (
         <div
@@ -892,15 +1391,61 @@ export function DragGhost() {
   );
 }
 
+/**
+ * The scroll-link toggle that sits on the divider between two side-by-side
+ * viewer subwindows. When enabled, scrolling one subwindow proportionally
+ * scrolls the other (see stores/scrollSync). Subscribes narrowly to its own
+ * linked state so unrelated link changes don't re-render it. Stops pointer/click
+ * propagation so toggling never starts a divider resize drag.
+ */
+function ScrollLinkButton({ a, b }: { a: string; b: string }) {
+  const linked = useScrollSyncStore((s) => s.links[a] === b);
+  const toggleLink = useScrollSyncStore((s) => s.toggleLink);
+  return (
+    <button
+      type="button"
+      className={`split-scroll-link-btn${linked ? " linked" : ""}`}
+      title={linked ? "Unlink scrolling" : "Link scrolling of these subwindows"}
+      aria-pressed={linked}
+      onPointerDown={(e) => e.stopPropagation()}
+      onClick={(e) => {
+        e.stopPropagation();
+        toggleLink(a, b);
+      }}
+    >
+      <svg
+        width="13"
+        height="13"
+        viewBox="0 0 24 24"
+        fill="none"
+        stroke="currentColor"
+        strokeWidth="2"
+        strokeLinecap="round"
+        strokeLinejoin="round"
+        aria-hidden="true"
+      >
+        <path d="M10 13a5 5 0 0 0 7 0l3-3a5 5 0 0 0-7-7l-1 1" />
+        <path d="M14 11a5 5 0 0 0-7 0l-3 3a5 5 0 0 0 7 7l1-1" />
+      </svg>
+    </button>
+  );
+}
+
 // ── Recursive layout renderer ────────────────────────────────────────────────
 
 interface TreeProps {
   node: LayoutNode;
   projectCwd: string;
   resizeSplit: (splitId: string, dividerIndex: number, fraction: number) => void;
+  /** Merge the two groups adjacent to a divider (double-click). Wired only when
+   *  both sides are leaf groups — see the divider's `onDoubleClick`. */
+  mergeGroups: (targetGroupId: string, sourceGroupId: string) => void;
   panelRef: React.RefObject<HTMLDivElement>;
   registerGroupBody: (id: string) => (el: HTMLDivElement | null) => void;
   onResized: () => void;
+  /** Group ids whose active tab is a scroll-syncable viewer — the divider
+   *  scroll-link button only appears between two such groups. */
+  syncableGroups: Set<string>;
 }
 
 function LayoutTree(props: TreeProps) {
@@ -919,6 +1464,25 @@ function LayoutTree(props: TreeProps) {
 function SplitView(props: TreeProps & { node: Extract<LayoutNode, { type: "split" }> }) {
   const { node } = props;
   const containerRef = useRef<HTMLDivElement>(null);
+  // Live DOM handles to each `.split-child`, so a divider drag can resize its two
+  // neighbours by writing `flex` directly — no store write per frame.
+  const childRefs = useRef<Map<number, HTMLDivElement>>(new Map());
+  // While a divider is dragging, the in-progress per-child flex sizes. Held in a
+  // ref (not state) so the drag never re-renders this subtree; applied to the DOM
+  // imperatively. Re-applied after every render (the layout effect below) so a
+  // re-render triggered by pane re-measurement (setGroupRects) can't clobber the
+  // drag back to the committed store sizes. `null` when no drag is in flight.
+  const dragSizesRef = useRef<number[] | null>(null);
+  const applyDragSizes = () => {
+    const sizes = dragSizesRef.current;
+    if (!sizes) return;
+    for (const [i, el] of childRefs.current) {
+      if (sizes[i] != null) el.style.flex = `${sizes[i]} 1 0`;
+    }
+  };
+  // Runs after every render: if a drag is live, re-assert its sizes over whatever
+  // flex React just wrote from the (still-stale) store `node.sizes`.
+  useLayoutEffect(applyDragSizes);
   // Minimum subwindow size (px) a divider drag may shrink a pane to, per axis,
   // from global settings (falling back to the built-in default).
   const minWidth = useSettingsStore((s) => s.settings?.min_subwindow_width) ?? DEFAULT_MIN_SUBWINDOW_PX;
@@ -953,13 +1517,29 @@ function SplitView(props: TreeProps & { node: Extract<LayoutNode, { type: "split
       const minPx = isRow ? minWidth : minHeight;
       const minFrac = Math.min(minPx / total, pair / 2);
       const clamped = Math.min(Math.max(leftSize, minFrac), pair - minFrac);
-      props.resizeSplit(node.id, dividerIndex, clamped);
+      // Resize the two neighbours on the DOM (mirrors applyResize: only these two
+      // change, the pair sum is preserved) instead of writing the store every
+      // frame — the store write rebuilt the whole layout tree and re-rendered the
+      // entire pane layer on each move. The store is committed once on release.
+      const sizes = [...node.sizes];
+      sizes[dividerIndex] = clamped;
+      sizes[dividerIndex + 1] = pair - clamped;
+      dragSizesRef.current = sizes;
+      applyDragSizes();
+      // Panes live in CenterPanel's flat overlay, sized to measured rects — they
+      // don't reflow with the flex box, so re-measure to reposition them.
       props.onResized();
     };
     const onUp = (ev: PointerEvent) => {
       (e.target as HTMLElement).releasePointerCapture?.(ev.pointerId);
       window.removeEventListener("pointermove", onMove);
       window.removeEventListener("pointerup", onUp);
+      // Commit the final position to the store ONCE. The next render writes these
+      // same sizes via `node.sizes`, matching the DOM, so there's no visual jump;
+      // clear the override first so the layout effect stops re-asserting it.
+      const sizes = dragSizesRef.current;
+      dragSizesRef.current = null;
+      if (sizes) props.resizeSplit(node.id, dividerIndex, sizes[dividerIndex]);
       props.onResized();
     };
     window.addEventListener("pointermove", onMove);
@@ -976,6 +1556,12 @@ function SplitView(props: TreeProps & { node: Extract<LayoutNode, { type: "split
         <Fragment key={child.id}>
           <div
             className="split-child"
+            // Registered so a divider drag can resize this child's flex directly
+            // on the DOM (see startDrag); the map self-heals on unmount.
+            ref={(el) => {
+              if (el) childRefs.current.set(i, el);
+              else childRefs.current.delete(i);
+            }}
             // flex-basis carries the size fraction; grow/shrink let dividers
             // claim their fixed pixels without distorting the ratio noticeably.
             style={{ flex: `${node.sizes[i] ?? 1} 1 0` }}
@@ -986,7 +1572,31 @@ function SplitView(props: TreeProps & { node: Extract<LayoutNode, { type: "split
             <div
               className={`split-divider split-divider-${node.dir}`}
               onPointerDown={startDrag(i)}
-            />
+              // Double-click merges the two adjacent subwindows into one — but
+              // only when both sides are leaf groups (mirroring the ScrollLink
+              // guard below); next to a nested split it's a no-op. Survivor is
+              // the left/top child; the divider drag uses onPointerDown, so the
+              // two gestures don't collide.
+              onDoubleClick={() => {
+                const a = node.children[i];
+                const b = node.children[i + 1];
+                if (a.type === "group" && b.type === "group") {
+                  props.mergeGroups(a.id, b.id);
+                }
+              }}
+            >
+              {/* Scroll-link toggle: only between two adjacent leaf subwindows
+                  whose active tabs are both syncable viewers (text/markdown/PDF). */}
+              {node.children[i].type === "group" &&
+                node.children[i + 1].type === "group" &&
+                props.syncableGroups.has(node.children[i].id) &&
+                props.syncableGroups.has(node.children[i + 1].id) && (
+                  <ScrollLinkButton
+                    a={node.children[i].id}
+                    b={node.children[i + 1].id}
+                  />
+                )}
+            </div>
           )}
         </Fragment>
       ))}
diff --git a/src/components/layout/DetachedApp.tsx b/src/components/layout/DetachedApp.tsx
index cc79e00..4aa0e7f 100644
--- a/src/components/layout/DetachedApp.tsx
+++ b/src/components/layout/DetachedApp.tsx
@@ -1,20 +1,40 @@
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { emit, listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
-import { useSettingsStore } from "../../stores/settings";
+import {
+  useSettingsStore,
+  applyTheme,
+  applyZoom,
+  clampZoom,
+  stepZoom,
+  THEME_CHANGED_EVENT,
+  LANGUAGE_CHANGED_EVENT,
+} from "../../stores/settings";
+import { applyLanguage, useT } from "../../lib/i18n";
 import {
   DETACHED_BOUNDS,
   DETACHED_CLOSE,
+  DETACHED_HIDE,
   DETACHED_EDIT,
   DETACHED_REQUEST_SEED,
+  DETACHED_ZOOM,
   applyEditToSubtree,
   applyRenameToTabs,
+  applyLocationToTabs,
   detachedSeedEvent,
   type DetachedEdit,
   type DetachedParam,
+  type DetachedRemoteInfo,
   type DetachedSeed,
 } from "../../stores/detached";
-import type { GroupNode, TabEntry } from "../../stores/tabs";
+import {
+  allGroups,
+  orderedTabKeys,
+  setDetachedViewerState,
+  type LayoutNode,
+  type TabEntry,
+} from "../../stores/tabs";
+import { useTabLandStore } from "../../stores/tabLand";
 import { listenPdfReveal } from "../../stores/pdfSync";
 import { listenEditorJump } from "../../stores/editorJump";
 import { DetachedCenterPanel } from "./DetachedCenterPanel";
@@ -43,17 +63,94 @@ const SEED_TIMEOUT_MS = 8000;
  * between desktops on project switch; its renderer stays still.
  */
 export function DetachedApp({ param }: Props) {
+  const t = useT();
   const loadSettings = useSettingsStore((s) => s.load);
   const label = getCurrentWindow().label;
 
-  const [group, setGroup] = useState<GroupNode | null>(null);
+  // The popout's content tree. Usually a single group; can become a SplitNode
+  // once split-in-popout (multi-pane) lands in the renderer (Phase 2).
+  const [group, setGroup] = useState<LayoutNode | null>(null);
   const [tabs, setTabs] = useState<TabEntry[]>([]);
+  // The owning project's remoteness, streamed in the seed (this window is inert to
+  // the projects store). Drives the tab strip's locality badge/menu + machine
+  // names; undefined for a local project (no locality axis).
+  const [remoteInfo, setRemoteInfo] = useState<DetachedRemoteInfo | undefined>(undefined);
+
+  // This popout's OWN per-window zoom. Restored from the first seed (persisted on
+  // the main window's detached entry), then owned locally — Ctrl +/- adjusts it
+  // and streams the change back for persistence. Held in a ref so the keydown
+  // listener binds once. `zoomSeeded` guards apply-on-seed to the FIRST seed, so a
+  // later re-seed (an edit, a tab docked in) can't revert the live zoom.
+  const zoomRef = useRef(1);
+  const zoomSeeded = useRef(false);
 
   // Theme injection (same as the main shell), but nothing project-switch-aware.
+  // `skipZoom` so we DON'T inherit the main window's `ui_zoom` — a popout owns its
+  // own zoom (applied from its seed below), which is what makes zoom per-window.
   useEffect(() => {
-    void loadSettings();
+    void loadSettings({ skipZoom: true });
   }, [loadSettings]);
 
+  // Per-window zoom via Ctrl +/- / Ctrl+0, handled before any editable-target
+  // guard (like F11) so it works from a focused terminal too — the browser-zoom
+  // convention. Scales THIS window's webview only and streams the new value back
+  // to the main window so it persists on this popout's detached entry.
+  useEffect(() => {
+    const applyAndPersist = (z: number) => {
+      const next = clampZoom(z);
+      zoomRef.current = next;
+      applyZoom(next);
+      void emit(DETACHED_ZOOM, { scope: param.scope, groupId: param.groupId, zoom: next });
+    };
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (!(e.ctrlKey || e.metaKey) || e.shiftKey || e.altKey) return;
+      // Agent panes consume Ctrl +/- for their own font zoom and stopPropagation,
+      // so those never reach here — this only fires for the rest of the window.
+      if (e.code === "Equal") {
+        e.preventDefault();
+        applyAndPersist(stepZoom(zoomRef.current, 1));
+      } else if (e.code === "Minus") {
+        e.preventDefault();
+        applyAndPersist(stepZoom(zoomRef.current, -1));
+      } else if (e.code === "Digit0") {
+        e.preventDefault();
+        applyAndPersist(1);
+      }
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [param.scope, param.groupId]);
+
+  // This window is its own JS runtime with its own `document` and its own copy
+  // of the settings store — a theme change made in the main window's Settings
+  // dialog only ever touches ITS document, so without this a popout keeps
+  // whatever theme it had at open time. Re-apply live via the cross-window
+  // broadcast (see THEME_CHANGED_EVENT in stores/settings).
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    listen<string>(THEME_CHANGED_EVENT, (e) => {
+      applyTheme(e.payload);
+    })
+      .then((fn) => { if (cancelled) fn(); else unlisten = fn; })
+      .catch(() => {});
+    return () => { cancelled = true; unlisten?.(); };
+  }, []);
+
+  // Same story for the UI language: this popout holds its own i18n store, so a
+  // language switch in the main window's Settings only re-renders that window
+  // without the cross-window broadcast. Re-apply live (see LANGUAGE_CHANGED_EVENT).
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    listen<string>(LANGUAGE_CHANGED_EVENT, (e) => {
+      applyLanguage(e.payload);
+    })
+      .then((fn) => { if (cancelled) fn(); else unlisten = fn; })
+      .catch(() => {});
+    return () => { cancelled = true; unlisten?.(); };
+  }, []);
+
   // #42: when a PDF tab is popped out into THIS window, a SyncTeX forward search
   // from a TeX editor in the main (or another) window reaches us only over a
   // cross-window broadcast. Register the listener so the PDF here reveals/flashes
@@ -179,8 +276,32 @@ export function DetachedApp({ param }: Props) {
     listen<DetachedSeed>(detachedSeedEvent(label), (ev) => {
       seeded = true;
       if (timer) clearTimeout(timer);
+      // Restore this popout's own zoom on the FIRST seed only (later re-seeds must
+      // not clobber a live zoom the user has since changed). A popout that has its
+      // OWN persisted zoom uses it; a brand-new popout with none inherits the main
+      // window's current `ui_zoom` at birth (so a 4K user's popouts aren't tiny)
+      // and then diverges the moment it's adjusted. Undefined on both ⇒ 100%.
+      if (!zoomSeeded.current) {
+        zoomSeeded.current = true;
+        const mainZoom = useSettingsStore.getState().settings?.ui_zoom;
+        zoomRef.current = clampZoom(ev.payload.zoom ?? mainZoom);
+        applyZoom(zoomRef.current);
+      }
+      // Register each seeded tab's viewerState BEFORE rendering, so a viewer pane
+      // mounting this frame recovers its per-tab scroll/zoom + #45 autocomplete/
+      // grammar overrides (our tabs never enter `useTabsStore`, where the viewer
+      // hooks normally read them). Must precede setGroup/setTabs.
+      for (const t of ev.payload.tabs) setDetachedViewerState(t.key, t.viewerState);
       setGroup(ev.payload.subtree);
       setTabs(ev.payload.tabs);
+      setRemoteInfo(ev.payload.remote);
+      // A tab docked INTO this popout from another window arrives on a seed
+      // tagged with its key — play the same drop-in landing as an in-popout
+      // merge as it mounts in its destination bar (batched with the state sets
+      // above, so the freshly-mounted tab renders with the landing class).
+      if (ev.payload.landedKey) {
+        useTabLandStore.getState().markLanded(ev.payload.landedKey);
+      }
     })
       .then((fn) => {
         if (cancelled) {
@@ -223,10 +344,41 @@ export function DetachedApp({ param }: Props) {
     setGroup((g) => (g ? applyEditToSubtree(g, edit) : g));
     if (edit.kind === "rename") {
       setTabs((ts) => applyRenameToTabs(ts, edit.key, edit.label));
+    } else if (edit.kind === "setLocation") {
+      // Optimistic: flip the badge now; the main window respawns the pane on the
+      // new host and re-derives the same payload.
+      setTabs((ts) => applyLocationToTabs(ts, edit.key, edit.location));
     }
     void emit(DETACHED_EDIT, { scope: param.scope, groupId: param.groupId, edit });
   };
 
+  // Closing the LAST tab closes the whole popout window — an empty detached
+  // window has nothing to render (it would strand on "Loading subwindow…").
+  // Route it through the same teardown as a WM/title-bar close (DETACHED_CLOSE):
+  // the main window kills the remaining tab's PTY, drops the group, and persists.
+  // We then destroy this OS window directly (destroy() bypasses our own
+  // onCloseRequested, so it won't re-emit DETACHED_CLOSE).
+  const handleClose = (key: string) => {
+    const isLastTab = !group || orderedTabKeys(group).length <= 1;
+    if (isLastTab) {
+      void emit(DETACHED_CLOSE, { scope: param.scope, groupId: param.groupId });
+      void getCurrentWindow().destroy();
+      return;
+    }
+    pushEdit({ kind: "close", key });
+  };
+
+  // Hide the WHOLE popout into the main window's right-panel "Hidden subwindows"
+  // list. Like handleClose it closes THIS OS window, but the main window PARKS the
+  // group (tabs stay mounted, PTYs alive) instead of discarding it — restorable
+  // from the panel. Hides the whole window (every pane of a multi-pane popout) as
+  // one hidden entry; destroy() bypasses our onCloseRequested so it won't also
+  // emit DETACHED_CLOSE (which would drop the tabs).
+  const handleHideWindow = () => {
+    void emit(DETACHED_HIDE, { scope: param.scope, groupId: param.groupId });
+    void getCurrentWindow().destroy();
+  };
+
   // Close-on-close: closing this OS window via the WM/title-bar CLOSES the
   // group's tabs for good — they are not docked back and do not restore on next
   // launch (dock-back is done by Ctrl+dragging the tab bar onto the main window,
@@ -258,18 +410,35 @@ export function DetachedApp({ param }: Props) {
     };
   }, [param.scope, param.groupId]);
 
-  if (!group) {
-    return <div className="detached-loading">Loading subwindow…</div>;
+  if (!group || allGroups(group).length === 0) {
+    return <div className="detached-loading">{t("detached.loadingSubwindow")}</div>;
   }
 
   return (
     <DetachedCenterPanel
       scope={param.scope}
-      group={group}
+      popoutId={param.groupId}
+      tree={group}
       tabs={tabs}
+      remoteInfo={remoteInfo}
       onActivate={(key) => pushEdit({ kind: "activate", key })}
-      onClose={(key) => pushEdit({ kind: "close", key })}
+      onClose={handleClose}
+      onHideWindow={handleHideWindow}
+      onSetLocation={(key, location) => pushEdit({ kind: "setLocation", key, location })}
       onReorder={(tabKeys) => pushEdit({ kind: "reorder", tabKeys })}
+      onSplit={(key, targetGroupId, edge) =>
+        pushEdit({ kind: "split", key, targetGroupId, edge })
+      }
+      onResize={(splitId, dividerIndex, fraction) =>
+        pushEdit({ kind: "resize", splitId, dividerIndex, fraction })
+      }
+      onMove={(key, targetGroupId, index) =>
+        pushEdit({ kind: "move", key, targetGroupId, index })
+      }
+      onAddTab={(tab, targetGroupId, edge) =>
+        pushEdit({ kind: "add", tab, targetGroupId, edge })
+      }
+      onFiles={(groupId, patch) => pushEdit({ kind: "files", groupId, ...patch })}
     />
   );
 }
diff --git a/src/components/layout/DetachedCenterPanel.tsx b/src/components/layout/DetachedCenterPanel.tsx
index 82ba060..850cbbe 100644
--- a/src/components/layout/DetachedCenterPanel.tsx
+++ b/src/components/layout/DetachedCenterPanel.tsx
@@ -1,183 +1,768 @@
-import { useEffect, useRef, useState } from "react";
-import { emit } from "@tauri-apps/api/event";
+import { Fragment, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { emit, listen } from "@tauri-apps/api/event";
 import { cursorPosition, getCurrentWindow } from "@tauri-apps/api/window";
 import { PhysicalPosition } from "@tauri-apps/api/dpi";
+import {
+  snapshotFrame,
+  physToClient,
+  clientToPhys,
+  desktopCursor,
+  type PhysPoint,
+  type WindowFrame,
+} from "../../lib/coords";
+import { bindDragRelease, dragPlatform, PLATFORM } from "../../lib/dragPlatform";
 import {
   DETACHED_DRAG_END,
   DETACHED_DRAG_MOVE,
   DETACHED_DRAG_START,
+  DETACHED_PANES,
+  DETACHED_PANES_REQUEST,
+  detachedDropPreviewEvent,
   type DetachedDragEnd,
   type DetachedDragMove,
   type DetachedDragStart,
+  type DetachedDropPreview,
+  type DetachedPanes,
+  type DetachedPanesRequest,
+  type PaneRect,
 } from "../../stores/detached";
-import { TerminalView } from "../terminal/TerminalView";
-import { FileBrowser } from "../files/FileBrowser";
-import { EmbedPane } from "../embed/EmbedPane";
-import { FileViewerPane } from "../embed/FileViewerPane";
+import { FileDropContext, type FileDropController } from "../files/fileDropContext";
+import { fileDropPayloads } from "../tabs/commitFileDrop";
+import { TabPane } from "../tabs/TabPane";
+import {
+  clampFilesWidth,
+  DEFAULT_GROUP_FILES_WIDTH,
+  SubwindowFilesSidebar,
+} from "../files/SubwindowFilesSidebar";
+import { useWindowFocused } from "../../hooks/useWindowFocused";
+import { TabHoverCard } from "../tabs/TabHoverCard";
 import { WindowControls } from "../header/WindowControls";
-import { DragGhost } from "./CenterPanel";
+import { DragGhost, SplitPreviewOverlay } from "./CenterPanel";
+import { TabDropPlaceholder } from "../tabs/TabDropPlaceholder";
+import { NewTabMenu } from "../tabs/NewTabMenu";
+import { CustomAgentDialog } from "../tabs/CustomAgentDialog";
+import { pickEdge } from "../tabs/dragGeometry";
+import {
+  chordMatches,
+  resolveChord,
+  type ShortcutAction,
+  type ShortcutMap,
+} from "../../lib/shortcuts";
+import { isEditableTarget } from "../../hooks/useKeyboard";
 import { useDragStore } from "../../stores/drag";
-import type { GroupNode, TabEntry } from "../../stores/tabs";
+import { useTabLandStore } from "../../stores/tabLand";
+import { useSettingsStore } from "../../stores/settings";
+import {
+  DEFAULT_MIN_SUBWINDOW_PX,
+  allGroups,
+  findGroup,
+  type DropEdge,
+  type GroupNode,
+  type LayoutNode,
+  type SplitNode,
+  type TabEntry,
+  type TabLocation,
+} from "../../stores/tabs";
+import type { DetachedRemoteInfo } from "../../stores/detached";
+import {
+  TabSourceBadge,
+  TabLocalityBadge,
+  LocalityMenu,
+  tabLocation,
+  type LocalityMenuState,
+} from "../tabs/TabLocalityBadges";
+import { useT } from "../../lib/i18n";
+
+/** Pixel coordinates of a group body, relative to the detached center panel. */
+interface Rect {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * The horizontally-scrolling tab strip + flanking chevrons — the SAME overflow
+ * behaviour as the main window's `TabBar` (click-scroll, continuous hover-scroll,
+ * wheel-to-horizontal, chevrons that appear only on overflow). Extracted as its
+ * own component so each group's bar in a (possibly multi-pane) popout gets its
+ * own strip ref + scroll state, exactly as each main-window `TabBar` instance
+ * does. The bar div, its detach-drag handler, and the per-group `barRefs`
+ * registration stay in `renderGroup`; this only owns the scroll chrome.
+ */
+function DetachedTabStrip({
+  children,
+  revision,
+}: {
+  children: React.ReactNode;
+  /** Changes whenever the group's tab set (or its drop placeholder) changes, so
+   *  overflow is re-evaluated — adding/removing tabs alters the strip's
+   *  scrollWidth without resizing its own box, which the ResizeObserver misses. */
+  revision: string;
+}) {
+  const t = useT();
+  const stripRef = useRef<HTMLDivElement>(null);
+  const [canScrollLeft, setCanScrollLeft] = useState(false);
+  const [canScrollRight, setCanScrollRight] = useState(false);
+
+  const updateScrollState = useCallback(() => {
+    const el = stripRef.current;
+    if (!el) {
+      setCanScrollLeft(false);
+      setCanScrollRight(false);
+      return;
+    }
+    setCanScrollLeft(el.scrollLeft > 1);
+    setCanScrollRight(el.scrollLeft + el.clientWidth < el.scrollWidth - 1);
+  }, []);
+
+  // Track overflow so the chevrons toggle with the strip's size/content (mirrors
+  // the main-window `TabBar`): Resize catches the strip shrinking, the revision
+  // effect below catches scrollWidth changes from adding/removing tabs.
+  useEffect(() => {
+    const el = stripRef.current;
+    if (!el) return;
+    updateScrollState();
+    const onScroll = () => updateScrollState();
+    el.addEventListener("scroll", onScroll, { passive: true });
+    const ro = new ResizeObserver(() => updateScrollState());
+    ro.observe(el);
+    return () => {
+      el.removeEventListener("scroll", onScroll);
+      ro.disconnect();
+    };
+  }, [updateScrollState]);
+  useEffect(() => {
+    updateScrollState();
+  }, [revision, updateScrollState]);
 
-// Fixed width of the gap that opens within the bar to receive a reordered tab.
-// Mirrors TabBar's constant so the popout's within-bar reorder looks identical.
-const REORDER_GAP = 80;
+  // Scroll one chevron-press worth (most of the visible width) toward `dir`.
+  const scrollStrip = useCallback((dir: number) => {
+    const el = stripRef.current;
+    if (!el) return;
+    el.scrollBy({ left: dir * Math.max(120, el.clientWidth * 0.7), behavior: "smooth" });
+  }, []);
+
+  // Continuous scroll while a chevron is hovered: rAF loop nudges the strip each
+  // frame until the pointer leaves (mirrors the main window's chevrons).
+  const hoverScrollRef = useRef<number | null>(null);
+  const stopHoverScroll = useCallback(() => {
+    if (hoverScrollRef.current !== null) {
+      cancelAnimationFrame(hoverScrollRef.current);
+      hoverScrollRef.current = null;
+    }
+  }, []);
+  const startHoverScroll = useCallback((dir: number) => {
+    stopHoverScroll();
+    const step = () => {
+      const el = stripRef.current;
+      if (!el) return;
+      el.scrollLeft += dir * 6;
+      // The chevrons unmount at the edges (canScroll*), so onMouseLeave may never
+      // fire — stop once we can't scroll further in `dir` rather than spin forever.
+      const atEdge =
+        dir < 0
+          ? el.scrollLeft <= 0
+          : el.scrollLeft + el.clientWidth >= el.scrollWidth - 1;
+      if (atEdge) {
+        hoverScrollRef.current = null;
+        return;
+      }
+      hoverScrollRef.current = requestAnimationFrame(step);
+    };
+    hoverScrollRef.current = requestAnimationFrame(step);
+  }, [stopHoverScroll]);
+  useEffect(() => stopHoverScroll, [stopHoverScroll]);
+
+  // Translate a vertical wheel into horizontal strip scrolling so the tabs can be
+  // panned while hovering anywhere over them, not just via the (hidden) scrollbar.
+  const onStripWheel = useCallback((e: React.WheelEvent) => {
+    const el = stripRef.current;
+    if (!el || el.scrollWidth <= el.clientWidth) return;
+    const delta = e.deltaY !== 0 ? e.deltaY : e.deltaX;
+    if (delta === 0) return;
+    el.scrollLeft += delta;
+  }, []);
+
+  return (
+    <>
+      {canScrollLeft && (
+        <button
+          className="tab-scroll-btn left"
+          title={t("detachedTabs.scrollLeft")}
+          // Keep the chevron out of the bar's window-move/dock drag flow.
+          onPointerDown={(e) => e.stopPropagation()}
+          onMouseEnter={() => startHoverScroll(-1)}
+          onMouseLeave={stopHoverScroll}
+          onClick={() => scrollStrip(-1)}
+        >
+          ‹
+        </button>
+      )}
+      <div className="tab-strip" ref={stripRef} onWheel={onStripWheel}>
+        {children}
+      </div>
+      {canScrollRight && (
+        <button
+          className="tab-scroll-btn right"
+          title={t("detachedTabs.scrollRight")}
+          onPointerDown={(e) => e.stopPropagation()}
+          onMouseEnter={() => startHoverScroll(1)}
+          onMouseLeave={stopHoverScroll}
+          onClick={() => scrollStrip(1)}
+        >
+          ›
+        </button>
+      )}
+    </>
+  );
+}
 
 interface Props {
   scope: string;
-  /** The single group this detached window renders. */
-  group: GroupNode;
-  /** The group's tab payloads (already filtered to this group). */
+  /** The detached popout's identity (the main store's detached record id). Used
+   *  for the cross-window drag protocol — NOT the inner group ids. */
+  popoutId: string;
+  /** The popout's content layout. A single group, or a split tree once the user
+   *  splits panes inside the popout (multi-pane popouts). */
+  tree: LayoutNode;
+  /** All of the popout's tab payloads (across every group in the tree). */
   tabs: TabEntry[];
+  /** The owning project's remoteness (machines + primary host name), streamed in
+   *  the seed. Drives the per-tab locality badge/menu; undefined = local project
+   *  (no locality axis, no badge — parity with a local main-window strip). */
+  remoteInfo?: DetachedRemoteInfo;
   onActivate: (key: string) => void;
   onClose: (key: string) => void;
-  /** Reorder this group's tabs (a tab dragged + dropped back onto its own bar). */
+  /** Hide the WHOLE popout into the main window's right-panel "Hidden subwindows"
+   *  list (the detached twin of a main-window subwindow's "–" hide). Closes this
+   *  OS window; the group is parked with its tabs mounted and restored from there.
+   *  Undefined ⇒ no hide affordance. */
+  onHideWindow?: () => void;
+  /** Multi-host: change where a locatable tab runs (streamed to the main window,
+   *  which owns the PTY and respawns the pane on the chosen host). */
+  onSetLocation: (key: string, location: TabLocation) => void;
+  /** Reorder a bar's tabs (a tab dragged + dropped back onto its own bar). The
+   *  main store resolves WHICH group from the key set. */
   onReorder: (tabKeys: string[]) => void;
+  /** Split `key` into a new pane at `edge` of `targetGroupId`, inside the popout
+   *  (a tab dragged onto a group BODY's edge). */
+  onSplit: (key: string, targetGroupId: string, edge: DropEdge) => void;
+  /** Resize the divider between children `dividerIndex`/`dividerIndex+1` of
+   *  `splitId` inside the popout (a split divider drag). */
+  onResize: (splitId: string, dividerIndex: number, fraction: number) => void;
+  /** Merge `key` into `targetGroupId` (at `index`, else append) — a tab dragged
+   *  onto ANOTHER group's bar (or body center) inside a split popout. */
+  onMove: (key: string, targetGroupId: string, index?: number) => void;
+  /** Create a new tab in `targetGroupId` — the popout's own "+" menu, or a file
+   *  dropped onto a pane inside the popout. The detached window can't mint the
+   *  key/own the PTY, so it streams the resolved payload to the main window, which
+   *  creates the tab and re-seeds. A side `edge` carves a NEW pane at that edge (a
+   *  file dropped on a body edge); omitted/"center" appends to the group. */
+  onAddTab: (tab: Omit<TabEntry, "key">, targetGroupId: string, edge?: DropEdge) => void;
+  /** Toggle/resize a group's docked file-viewer column (the per-subwindow right
+   *  file viewer): applied optimistically popout-side and streamed to the main
+   *  window so the flag persists (and survives a dock-back). */
+  onFiles: (groupId: string, patch: { open?: boolean; width?: number; folder?: string }) => void;
 }
 
 /**
- * #42: the detached window's single-group center surface. A stripped CenterPanel
- * that renders ONLY this one group's tab bar + pane layer — no project switcher,
- * no right panel, no LayoutTree, and crucially no project-switch effects. Its
- * terminals run ATTACH-ONLY (the PTY is owned by the main window's pane), so they
- * never spawn or kill a PTY. The pane layer keeps every tab mounted; only the
- * active one is shown.
+ * #42 / multi-pane: the detached window's center surface. A stripped CenterPanel
+ * that renders the popout's layout TREE — each group as a tab bar + pane layer,
+ * splits as flex rows/columns — with no project switcher, right panel, or
+ * project-switch effects. Terminals run ATTACH-ONLY (the PTY is owned by the main
+ * window's pane), so they never spawn or kill a PTY. Each group keeps every tab
+ * mounted; only the active one shows.
  */
 export function DetachedCenterPanel({
   scope,
-  group,
+  popoutId,
+  tree,
   tabs,
+  remoteInfo,
   onActivate,
   onClose,
+  onHideWindow,
+  onSetLocation,
   onReorder,
+  onSplit,
+  onResize,
+  onMove,
+  onAddTab,
+  onFiles,
 }: Props) {
-  const bodyRef = useRef<HTMLDivElement>(null);
-  const barRef = useRef<HTMLDivElement>(null);
-  const [rect, setRect] = useState<{ w: number; h: number }>({ w: 0, h: 0 });
+  // The popout's "+" add-tab menu: which group opened it + where to anchor it.
+  const t = useT();
+  const [addMenu, setAddMenu] = useState<{ groupId: string; x: number; y: number } | null>(null);
+  const [agentDialogOpen, setAgentDialogOpen] = useState(false);
+  // Tab hover card anchor (the hovered tab's bottom-centre), mirroring the main
+  // window's TabBar — the popout has its own tab strip, so it renders its own.
+  const [hoverTab, setHoverTab] = useState<{ key: string; x: number; y: number } | null>(null);
+  // Multi-host locality menu (shared with TabBar). Machine names + the primary
+  // host come from the streamed `remoteInfo`; undefined ⇒ local project, no badge.
+  const [localityMenu, setLocalityMenu] = useState<LocalityMenuState | null>(null);
+  const isRemote = !!remoteInfo;
+  const primaryHost = remoteInfo?.primaryHost;
+  const computeHosts = remoteInfo?.computeHosts;
+  // One bar element per group, so a per-tab drag can hit-test the bar it's over.
+  const barRefs = useRef<Map<string, HTMLDivElement>>(new Map());
+  // One body element per group, for resolving an edge-split drop target.
+  const bodyRefs = useRef<Map<string, HTMLDivElement>>(new Map());
+  // The panel element, the coordinate origin for the split-preview overlay.
+  const panelRef = useRef<HTMLDivElement>(null);
+  // Measured group-body rects (panel-relative px) feeding the split-preview
+  // overlay, which must paint ABOVE the per-group panes (opaque terminals) — so,
+  // like the main window, it lives at the panel level rather than in a body.
+  const [groupRects, setGroupRects] = useState<Record<string, Rect>>({});
+  // Whole-subwindow rects (tab bar + pane region, sidebar excluded), used by the
+  // focus frame so it wraps the current subwindow's tab header too — mirrors the
+  // main window's `groupFrameRects`.
+  const [groupFrameRects, setGroupFrameRects] = useState<Record<string, Rect>>({});
+  // Minimum subwindow size (px) a divider drag may shrink a pane to, per axis.
+  const minWidth = useSettingsStore((s) => s.settings?.min_subwindow_width) ?? DEFAULT_MIN_SUBWINDOW_PX;
+  const minHeight = useSettingsStore((s) => s.settings?.min_subwindow_height) ?? DEFAULT_MIN_SUBWINDOW_PX;
+  // #42 (main → detached): true while a tab dragged out of the MAIN window hovers
+  // over THIS popout, so we paint a drop-target highlight. The main window streams
+  // the toggle on our label-namespaced channel and commits the dock itself (it
+  // owns the layout); we only render the cue. See `detachedDropPreviewEvent`.
+  const [dropActive, setDropActive] = useState(false);
+  // #42 (Windows): true while the popout is being moved by a NATIVE title-bar drag.
+  // It swaps the heavy pane content (terminal canvases) for a cheap placeholder so
+  // WebView2 has a trivial surface to composite during the OS modal move loop and
+  // can keep up with the frame — the panes would otherwise visibly lag/swim behind
+  // the moving frame. Set on the first `onMoved`, cleared on release (or when the
+  // window stops moving), so a plain title-bar click never flashes the placeholder.
+  const [windowDragging, setWindowDragging] = useState(false);
   // Within-bar reorder visuals, driven by THIS popout's own drag store (a
   // separate JS heap from the main window). While a tab is dragged, the dragged
-  // tab collapses and a gap slides open at the live drop slot — mirroring the
-  // main window's TabBar (#42 drag parity).
+  // tab collapses and a gap slides open at the live drop slot.
   const dragKey = useDragStore((s) => (s.drag ? s.drag.key : null));
-  const reorderIndex = useDragStore((s) =>
-    s.drag && s.drag.reorderGroup === group.id ? s.drag.reorderIndex : null,
-  );
+  const reorderGroupId = useDragStore((s) => (s.drag ? s.drag.reorderGroup : null));
+  const reorderIndex = useDragStore((s) => (s.drag ? s.drag.reorderIndex : null));
+  // Label of the dragged tab, shown in the drop placeholder so the target bar
+  // previews WHICH tab will land there — mirrors the main-window `TabBar`.
+  const dragLabel = useDragStore((s) => (s.drag ? s.drag.label : ""));
+  // One-shot "landing" flourish, driven by THIS popout's own tabLand store (a
+  // separate JS heap from the main window). A tab merged/split/moved into a bar
+  // inside the popout plays the same drop-in as the main window. `markLanded` is
+  // fired from `handleLocalTabRelease` on the same cross-group rules `commitDrop`
+  // uses (never on a same-group reorder).
+  const landedKey = useTabLandStore((s) => s.landed?.key ?? null);
+  const landedNonce = useTabLandStore((s) => s.landed?.nonce ?? 0);
+  const clearLanded = useTabLandStore((s) => s.clear);
   const byKey = new Map(tabs.map((t) => [t.key, t] as const));
-  const orderedTabs = group.tabKeys
-    .map((k) => byKey.get(k))
-    .filter((t): t is TabEntry => t != null);
+  // Which group inside this popout is "current". A split popout otherwise
+  // rendered every pane as `.focused` with no active-pane marker; mirror the main
+  // window, where `focusedGroupId` drives the `.focus-frame` accent outline. The
+  // detached window is inert to the main tabs store (separate JS heap, layout
+  // streamed via props), so focus is tracked locally here.
+  const [focusedGroupId, setFocusedGroupId] = useState<string | null>(null);
+  // Only paint this popout's active subwindow while the popout itself owns OS
+  // focus, so it and the main window never both highlight one at once (#42).
+  const windowFocused = useWindowFocused();
+  // Keep focus on a group that still exists as the tree changes (split added /
+  // removed / docked back); default to the first group.
+  useEffect(() => {
+    const ids = allGroups(tree).map((g) => g.id);
+    setFocusedGroupId((cur) => (cur && ids.includes(cur) ? cur : (ids[0] ?? null)));
+  }, [tree]);
 
+  // ── Keyboard shortcuts (parity with the main window) ──────────────────────
+  // The popout is a separate JS heap, inert to the tabs store, so the main
+  // window's `useKeyboard` (which drives `useTabsStore`) can't run here. Instead
+  // we handle the WINDOW-LOCAL chords against THIS popout's own layout + edit
+  // protocol, resolving each chord through the SAME `shortcuts.ts` map (incl. the
+  // user's overrides) so a rebound key behaves identically in both windows.
+  //
+  // Only the actions with a popout equivalent are wired: close tab, prev/next/
+  // cycle tab, cycle subwindow focus, and F11 OS-fullscreen. The rest are
+  // deliberately absent because the popout has no matching concept:
+  // app-internal fullscreen, hide/close-subwindow (no such edit), and
+  // cycle-project (a popout owns no project switcher). Live values are read
+  // through a ref so the window listener binds once and never churns on the
+  // per-render identity of the edit callbacks.
+  const kbRef = useRef({ tree, focusedGroupId, onActivate, onClose, onFiles });
+  kbRef.current = { tree, focusedGroupId, onActivate, onClose, onFiles };
   useEffect(() => {
-    const el = bodyRef.current;
-    if (!el || typeof ResizeObserver === "undefined") return;
-    const measure = () =>
-      setRect({ w: el.clientWidth, h: el.clientHeight });
+    const win = getCurrentWindow();
+    const onKeyDown = async (e: KeyboardEvent) => {
+      // F11 — OS fullscreen (Windows: maximize toggle, matching the main window,
+      // since real fullscreen strips the styles native dragging relies on).
+      // Handled before the editable-target guard so it works from a terminal too.
+      if (e.key === "F11") {
+        e.preventDefault();
+        if (PLATFORM === "windows") {
+          if (await win.isMaximized()) void win.unmaximize();
+          else void win.maximize();
+        } else {
+          const isFs = await win.isFullscreen();
+          void win.setFullscreen(!isFs);
+        }
+        return;
+      }
+      // Never steal keys from a focused text field / xterm textarea (same rule
+      // the main window applies) — otherwise typing in a terminal would trip the
+      // nav chords.
+      if (isEditableTarget(e.target)) return;
+
+      const overrides = useSettingsStore.getState().settings
+        ?.keyboard_shortcuts as ShortcutMap | undefined;
+      const is = (action: ShortcutAction) =>
+        chordMatches(resolveChord(action, overrides), e);
+      const {
+        tree: t,
+        focusedGroupId: fid,
+        onActivate: activate,
+        onClose: close,
+        onFiles: files,
+      } = kbRef.current;
+      const focused = (fid && findGroup(t, fid)) || allGroups(t)[0] || null;
+
+      // Toggle the focused subwindow's docked file viewer (streams a files edit
+      // back to the main window, same as the ◫ button / resize-edge double-click).
+      if (is("toggleSubwindowFiles")) {
+        if (focused) {
+          e.preventDefault();
+          files(focused.id, { open: !focused.filesOpen });
+        }
+        return;
+      }
+
+      // Close the active tab of the focused subwindow. DetachedApp's handleClose
+      // closes the whole window when it was the last tab.
+      if (is("closeTab")) {
+        if (focused?.activeKey) {
+          e.preventDefault();
+          close(focused.activeKey);
+        }
+        return;
+      }
+
+      // Previous / next / cycle tab within the focused subwindow.
+      const prev = is("prevTab");
+      if (prev || is("nextTab") || is("cycleTabs")) {
+        if (focused && focused.tabKeys.length > 1) {
+          e.preventDefault();
+          const len = focused.tabKeys.length;
+          const cur = focused.activeKey ? focused.tabKeys.indexOf(focused.activeKey) : 0;
+          const next = focused.tabKeys[(cur + (prev ? -1 : 1) + len) % len];
+          activate(next);
+        }
+        return;
+      }
+
+      // Cycle which subwindow is focused (only meaningful once the popout is
+      // split into several panes). A direct move — the popout has a focus frame
+      // but not the main window's numbered Shift-preview nav.
+      const down = is("subwindowDown");
+      if (down || is("subwindowUp")) {
+        const ids = allGroups(t).map((g) => g.id);
+        if (ids.length >= 2) {
+          e.preventDefault();
+          const from = fid ? ids.indexOf(fid) : -1;
+          const base = from >= 0 ? from : 0;
+          setFocusedGroupId(ids[(base + (down ? 1 : -1) + ids.length) % ids.length]);
+        }
+        return;
+      }
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+    // Bind once: live state is read via kbRef; the resolver reads settings live.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // ── Pane-region measurement (for the split-preview overlay) ───────────────
+  // Recompute every group body's rect (relative to the panel) so the overlay can
+  // paint the half/whole a split drop would carve out. Mirrors CenterPanel.measure.
+  const measure = useCallback(() => {
+    const panel = panelRef.current;
+    if (!panel) return;
+    const base = panel.getBoundingClientRect();
+    const next: Record<string, Rect> = {};
+    const frames: Record<string, Rect> = {};
+    for (const [id, el] of bodyRefs.current) {
+      if (!el.isConnected) continue;
+      const r = el.getBoundingClientRect();
+      next[id] = { left: r.left - base.left, top: r.top - base.top, width: r.width, height: r.height };
+      // The enclosing subwindow box spans the tab header bar + body; clamp the
+      // right edge to the pane region's right (`r`, the measured element here)
+      // so a docked files sidebar in the same body is excluded from the frame.
+      const sub = el.closest(".subwindow");
+      if (sub) {
+        const sr = sub.getBoundingClientRect();
+        frames[id] = {
+          left: sr.left - base.left,
+          top: sr.top - base.top,
+          width: r.right - sr.left,
+          height: sr.height,
+        };
+      }
+    }
+    const sameRects = (
+      a: Record<string, Rect>,
+      b: Record<string, Rect>,
+    ): boolean => {
+      const keys = Object.keys(a);
+      if (keys.length !== Object.keys(b).length) return false;
+      for (const k of keys) {
+        const x = a[k];
+        const y = b[k];
+        if (!y || x.left !== y.left || x.top !== y.top || x.width !== y.width || x.height !== y.height) {
+          return false;
+        }
+      }
+      return true;
+    };
+    setGroupRects((prev) => (sameRects(next, prev) ? prev : next));
+    setGroupFrameRects((prev) => (sameRects(frames, prev) ? prev : frames));
+  }, []);
+
+  // Re-measure when the popout's tree changes (split added/removed/resized).
+  useLayoutEffect(() => {
     measure();
-    const ro = new ResizeObserver(measure);
-    ro.observe(el);
+  }, [measure, tree]);
+
+  // Re-measure on panel/body resize and OS-window resize (WebKitGTK sometimes
+  // misses the latter via ResizeObserver — DetachedApp bridges it to 'resize').
+  useEffect(() => {
+    const panel = panelRef.current;
+    if (!panel || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => measure());
+    ro.observe(panel);
+    for (const el of bodyRefs.current.values()) ro.observe(el);
     return () => ro.disconnect();
-  }, []);
+  }, [measure, tree]);
+  useEffect(() => {
+    const onResize = () => measure();
+    window.addEventListener("resize", onResize);
+    return () => window.removeEventListener("resize", onResize);
+  }, [measure]);
 
-  // #42: grab the popout's top frame (the empty tab-bar area) to move/dock the
-  // WHOLE group. The popout follows the cursor and, while the cursor is over the
-  // main window, the main window shows the same split/merge drop preview as an
-  // in-window tab drag and docks the group on release (`beginDockDrag` with
-  // moveWindow). Released anywhere else, the popout simply stays where it was
-  // dragged. We drive the move ourselves (no `startDragging`), so we trade away
-  // KWin's native edge-snap/maximize-on-drag for cross-window docking. Dragging a
-  // single TAB (not the bar) is handled per-tab by `onTabPointerDown`.
-  const onTabBarPointerDown = (e: React.PointerEvent) => {
-    if (e.button !== 0) return;
-    const target = e.target as HTMLElement;
-    // Only the empty bar area is a drag handle — not the tabs or the controls.
-    if (target.closest(".tab, .detached-titlebar-controls, button")) return;
-    e.preventDefault();
-    // The whole popout follows the cursor and docks the WHOLE group.
-    beginDockDrag({
-      pointerId: e.pointerId,
-      screenX: e.screenX,
-      screenY: e.screenY,
-      captureEl: e.currentTarget as HTMLElement,
-      label:
-        orderedTabs.find((t) => t.key === group.activeKey)?.label ?? "Subwindow",
-      moveWindow: true,
-    });
-  };
+  // A split divider drag inside the popout. Mirrors CenterPanel's SplitView: the
+  // new fraction is the pointer position within the split container, clamped so
+  // neither side of the dragged pair shrinks below the min subwindow size. The
+  // resize streams back to the main window via `onResize` (a "resize" edit), so
+  // the host's `detachedGroupsByScope` record stays the source of truth.
+  const onDividerPointerDown =
+    (node: SplitNode, dividerIndex: number) => (e: React.PointerEvent) => {
+      if (e.button !== 0) return;
+      e.preventDefault();
+      e.stopPropagation();
+      const container = (e.currentTarget as HTMLElement).parentElement;
+      if (!container) return;
+      const captureEl = e.target as HTMLElement;
+      captureEl.setPointerCapture?.(e.pointerId);
+      const onMove = (ev: PointerEvent) => {
+        const rect = container.getBoundingClientRect();
+        const isRow = node.dir === "row";
+        const total = isRow ? rect.width : rect.height;
+        if (total <= 0) return;
+        const pos = isRow ? ev.clientX - rect.left : ev.clientY - rect.top;
+        const wholeFraction = Math.min(Math.max(pos / total, 0), 1);
+        let before = 0;
+        for (let i = 0; i < dividerIndex; i++) before += node.sizes[i];
+        const pair = node.sizes[dividerIndex] + node.sizes[dividerIndex + 1];
+        const leftSize = wholeFraction - before;
+        const minPx = isRow ? minWidth : minHeight;
+        const minFrac = Math.min(minPx / total, pair / 2);
+        const clamped = Math.min(Math.max(leftSize, minFrac), pair - minFrac);
+        onResize(node.id, dividerIndex, clamped);
+      };
+      const onUp = (ev: PointerEvent) => {
+        captureEl.releasePointerCapture?.(ev.pointerId);
+        window.removeEventListener("pointermove", onMove);
+        window.removeEventListener("pointerup", onUp);
+      };
+      window.addEventListener("pointermove", onMove);
+      window.addEventListener("pointerup", onUp);
+    };
 
-  // #42: dragging a SINGLE tab. Activate on press, then once the pointer crosses
-  // a small threshold start a per-tab dock drag (mirrors the main window's
-  // TabBar): the cursor streams to the main window, which previews + docks just
-  // this tab on release over it. Released back over THIS popout's own tab bar it
-  // reorders locally; released over the popout body it stays put. The popout
-  // itself does NOT move (moveWindow:false) — only the dragged tab travels.
-  const onTabPointerDown = (e: React.PointerEvent, tab: TabEntry) => {
-    if (e.button !== 0) return;
-    e.stopPropagation(); // don't also start the whole-group bar drag.
-    onActivate(tab.key);
-    const startX = e.screenX;
-    const startY = e.screenY;
-    let armed = false;
-    const onMove = (ev: PointerEvent) => {
-      if (armed) return;
-      if (Math.hypot(ev.screenX - startX, ev.screenY - startY) < 5) return;
-      armed = true;
-      window.removeEventListener("pointermove", onMove);
-      window.removeEventListener("pointerup", onUp);
-      beginDockDrag({
-        pointerId: ev.pointerId,
-        screenX: ev.screenX,
-        screenY: ev.screenY,
-        // Client coords seed the local ghost so it appears under the cursor
-        // before the async window-origin resolves (the poll corrects it after).
-        clientX: ev.clientX,
-        clientY: ev.clientY,
-        captureEl: null,
-        tabKey: tab.key,
-        label: tab.label,
-        moveWindow: false,
-      });
+  // #42: a tab/file dragged out of the MAIN window over this popout. We (1) answer
+  // the host's panes request with our per-pane client geometry, so the host
+  // hit-tests the cursor SYNCHRONOUSLY (no release race), and (2) render the
+  // per-pane split/merge preview for the target the host streams back — via a
+  // synthetic local drag so the SAME SplitPreviewOverlay + ghost light up as an
+  // in-popout drag. The dock itself is the host's store mutation + re-seed.
+  useEffect(() => {
+    const unlisteners: Array<() => void> = [];
+    let cancelled = false;
+    const win = getCurrentWindow();
+    const label = win.label;
+    let active = false;
+    // Our window frame (physical px), used to map the streamed physical cursor into
+    // our own client px for the ghost position; snapshotted lazily on the first
+    // hover (the popout doesn't move/rescale mid-gesture).
+    let frame: WindowFrame | null = null;
+    const refreshFrame = async () => {
+      try {
+        frame = await snapshotFrame(win);
+      } catch {
+        frame = null;
+      }
     };
-    const onUp = () => {
-      window.removeEventListener("pointermove", onMove);
-      window.removeEventListener("pointerup", onUp);
+    const reg = (p: Promise<() => void>) =>
+      p.then((fn) => (cancelled ? fn() : unlisteners.push(fn))).catch(() => {});
+
+    // Render the host-resolved target as our split-preview, and follow the ghost.
+    const apply = (p: DetachedDropPreview) => {
+      if (p.cursorPhysX != null && p.cursorPhysY != null && frame) {
+        // physical desktop px → our own client px (via innerPhys/scale, the only
+        // DPI-correct conversion); valid even though the cursor is outside us.
+        const c = physToClient(frame, { x: p.cursorPhysX, y: p.cursorPhysY });
+        useDragStore.getState().move(c.x, c.y);
+      }
+      const t = p.target;
+      useDragStore.getState().setTarget(
+        t
+          ? { overGroup: t.groupId, edge: t.edge, reorderGroup: null, reorderIndex: null }
+          : { overGroup: null, edge: null, reorderGroup: null, reorderIndex: null },
+      );
     };
-    window.addEventListener("pointermove", onMove);
-    window.addEventListener("pointerup", onUp);
-  };
 
-  // Resolve the within-bar reorder slot under a popout-client point and write it
-  // to this popout's drag store, driving the live gap (and clearing it when the
-  // cursor is off the bar — e.g. over the body or out over the main window).
-  // Mirrors CenterPanel.resolveTarget's tab-bar branch.
-  const resolveLocalReorder = (clientX: number, clientY: number) => {
+    // (1) Report our pane geometry (client px) when the host asks at drag start.
+    reg(
+      listen<DetachedPanesRequest>(DETACHED_PANES_REQUEST, (ev) => {
+        if (ev.payload.label !== label) return;
+        const panes: PaneRect[] = [];
+        for (const [gid, bar] of barRefs.current) {
+          const body = bodyRefs.current.get(gid);
+          if (!body) continue;
+          const br = bar.getBoundingClientRect();
+          const bo = body.getBoundingClientRect();
+          panes.push({
+            groupId: gid,
+            bar: { left: br.left, top: br.top, right: br.right, bottom: br.bottom },
+            body: { left: bo.left, top: bo.top, right: bo.right, bottom: bo.bottom },
+          });
+        }
+        void emit(DETACHED_PANES, { label, panes } satisfies DetachedPanes);
+      }),
+    );
+
+    // (2) Render the preview for the streamed target.
+    reg(
+      listen<DetachedDropPreview>(detachedDropPreviewEvent(label), (ev) => {
+        const p = ev.payload;
+        if (!p.active) {
+          if (active) {
+            active = false;
+            useDragStore.getState().end();
+          }
+          setDropActive(false);
+          return;
+        }
+        setDropActive(true);
+        if (!active) {
+          active = true;
+          useDragStore.getState().start({
+            key: "",
+            fromGroup: "",
+            label: p.label ?? "",
+            pointerX: 0,
+            pointerY: 0,
+            previewNode: null,
+            previewW: 0,
+            previewH: 0,
+          });
+          void refreshFrame().then(() => apply(p));
+          return;
+        }
+        apply(p);
+      }),
+    );
+
+    return () => {
+      cancelled = true;
+      for (const fn of unlisteners) fn();
+      if (active) useDragStore.getState().end();
+    };
+    // Mount once: the listeners key off our (stable) window label.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Resolve the within-popout drop target under a popout-client point and write
+  // it to this popout's drag store: a tab BAR → within-bar reorder slot; a group
+  // BODY → edge split of that group. Mirrors CenterPanel.resolveTarget, but scans
+  // this popout's own per-group bar/body refs (it may have several once split).
+  const resolveLocalTarget = useCallback((clientX: number, clientY: number) => {
     const setTarget = useDragStore.getState().setTarget;
     const clear = () =>
       setTarget({ overGroup: null, edge: null, reorderGroup: null, reorderIndex: null });
-    const bar = barRef.current;
-    if (!bar) return clear();
-    const br = bar.getBoundingClientRect();
-    const overBar =
-      clientX >= br.left &&
-      clientX <= br.right &&
-      clientY >= br.top &&
-      clientY <= br.bottom;
-    if (!overBar) return clear();
-    const tabEls = Array.from(bar.querySelectorAll<HTMLElement>(".tab"));
-    let slot = tabEls.length;
-    for (let i = 0; i < tabEls.length; i++) {
-      const r = tabEls[i].getBoundingClientRect();
-      if (clientX < r.left + r.width / 2) {
-        slot = i;
-        break;
+    const inside = (r: DOMRect) =>
+      clientX >= r.left && clientX <= r.right && clientY >= r.top && clientY <= r.bottom;
+
+    for (const [gid, bar] of barRefs.current) {
+      const br = bar.getBoundingClientRect();
+      if (!inside(br)) continue;
+      const tabEls = Array.from(bar.querySelectorAll<HTMLElement>(".tab"));
+      let slot = tabEls.length;
+      for (let i = 0; i < tabEls.length; i++) {
+        const r = tabEls[i].getBoundingClientRect();
+        if (clientX < r.left + r.width / 2) {
+          slot = i;
+          break;
+        }
       }
+      setTarget({ overGroup: null, edge: null, reorderGroup: gid, reorderIndex: slot });
+      return;
     }
-    setTarget({ overGroup: null, edge: null, reorderGroup: group.id, reorderIndex: slot });
-  };
+    for (const [gid, body] of bodyRefs.current) {
+      const r = body.getBoundingClientRect();
+      if (!inside(r)) continue;
+      const edge = pickEdge(
+        { left: r.left, top: r.top, width: r.width, height: r.height },
+        clientX,
+        clientY,
+      );
+      setTarget({ overGroup: gid, edge, reorderGroup: null, reorderIndex: null });
+      return;
+    }
+    clear();
+  }, []);
+
+  // #42: a FILE dragged out of the file tree (a Files (Project) tab) onto a pane
+  // inside THIS popout. The main window's `commitFileDrop` can't run here (the
+  // popout doesn't own the tab store), so commit the resolved target as a
+  // detached `add` edit: a bar / pane-centre → append; a body side edge → carve a
+  // new pane. Provided to the tree via `FileDropContext`, with `resolveLocalTarget`
+  // as its per-move target resolver so the split/merge preview lights up.
+  const fileDrop = useMemo<FileDropController>(
+    () => ({
+      resolveTarget: resolveLocalTarget,
+      commit: (d, projectCwd) => {
+        const drag = useDragStore.getState().drag;
+        if (!drag) return;
+        const payloads = fileDropPayloads(d, projectCwd);
+        if (payloads.length === 0) return;
+        // Body side edge → the first file carves a new pane at that edge; any
+        // further files (a multi-selection) append to the target group, since the
+        // popout can't reference the pane the main window is about to mint.
+        if (drag.overGroup && drag.edge && drag.edge !== "center") {
+          onAddTab(payloads[0], drag.overGroup, drag.edge);
+          for (const p of payloads.slice(1)) onAddTab(p, drag.overGroup);
+          return;
+        }
+        // A pane centre/body, or a tab bar → append to that group. No pane under
+        // the cursor (released over empty space) → nothing (never leak a file out).
+        const target = drag.overGroup ?? drag.reorderGroup;
+        if (!target) return;
+        for (const p of payloads) onAddTab(p, target);
+      },
+      // No drag involved (a button click): drop the tab into the popout's focused
+      // group, else its first group, streamed to the main window via onAddTab.
+      openTab: (tab) => {
+        const target = focusedGroupId ?? allGroups(tree)[0]?.id;
+        if (target) onAddTab(tab, target);
+      },
+    }),
+    [resolveLocalTarget, onAddTab, focusedGroupId, tree],
+  );
 
-  // If a per-tab drag ends back over THIS popout's own tab bar, reorder locally
-  // (client coords are the cursor minus the popout's content origin, both in CSS
-  // px). A drop over the body is a no-op. Returns true if the release was over
-  // this popout at all (so the host must NOT also dock it into the main window).
+  // A per-tab drag released over THIS popout: commit the LAST resolved target
+  // (set by resolveLocalTarget during the drag) — a bar slot reorders, a body
+  // edge splits. Returns true if the release was over this popout at all (so the
+  // host must NOT also dock it into the main window).
   const handleLocalTabRelease = (
     tabKey: string,
     clientX: number,
@@ -189,122 +774,113 @@ export function DetachedCenterPanel({
       clientX <= window.innerWidth &&
       clientY <= window.innerHeight;
     if (!overPopout) return false;
-    const bar = barRef.current;
-    if (bar) {
-      const br = bar.getBoundingClientRect();
-      const overBar =
-        clientX >= br.left &&
-        clientX <= br.right &&
-        clientY >= br.top &&
-        clientY <= br.bottom;
-      if (overBar) {
-        const tabEls = Array.from(bar.querySelectorAll<HTMLElement>(".tab"));
-        let idx = tabEls.length;
-        for (let i = 0; i < tabEls.length; i++) {
-          const r = tabEls[i].getBoundingClientRect();
-          if (clientX < r.left + r.width / 2) {
-            idx = i;
-            break;
-          }
-        }
-        const cur = group.tabKeys;
-        const from = cur.indexOf(tabKey);
-        if (from >= 0) {
-          let to = idx;
-          if (from < to) to -= 1; // account for the source's own removal.
-          if (to !== from) {
-            const next = [...cur];
-            next.splice(from, 1);
-            next.splice(to, 0, tabKey);
-            onReorder(next);
+    const drag = useDragStore.getState().drag;
+    if (!drag) return true;
+    // Body edge → split this group inside the popout. A non-center edge splits
+    // off a new pane; "center" over a DIFFERENT group merges into it (over the
+    // source group it's a no-op, matching the main window's commitDrop). Both
+    // land the tab in a new bar, so play the drop-in landing (as commitDrop does).
+    if (drag.overGroup && drag.edge) {
+      if (drag.edge !== "center") {
+        onSplit(tabKey, drag.overGroup, drag.edge);
+        useTabLandStore.getState().markLanded(tabKey);
+      } else if (drag.overGroup !== drag.fromGroup) {
+        onMove(tabKey, drag.overGroup);
+        useTabLandStore.getState().markLanded(tabKey);
+      }
+      return true;
+    }
+    // Bar slot → reorder within the same group, or merge into another group's bar.
+    if (drag.reorderGroup && drag.reorderIndex != null) {
+      if (drag.reorderGroup === drag.fromGroup) {
+        const group = findGroup(tree, drag.reorderGroup);
+        if (group) {
+          const cur = group.tabKeys;
+          const from = cur.indexOf(tabKey);
+          if (from >= 0) {
+            let to = drag.reorderIndex;
+            if (from < to) to -= 1; // account for the source's own removal.
+            if (to !== from) {
+              const next = [...cur];
+              next.splice(from, 1);
+              next.splice(to, 0, tabKey);
+              onReorder(next);
+            }
           }
         }
+      } else {
+        // Dropped onto another group's bar → move the tab there at the slot.
+        // The slot indexes the target's tabs (which don't contain the key), so
+        // it needs no source-removal adjustment. A cross-group move lands the
+        // tab in a new bar → play the drop-in landing (as commitDrop does).
+        onMove(tabKey, drag.reorderGroup, drag.reorderIndex);
+        useTabLandStore.getState().markLanded(tabKey);
       }
     }
     return true;
   };
 
-  // #42: drag-to-dock. We stream the gesture's OS-LEVEL CURSOR position to the
-  // main window, which maps it into its client space, renders the dock preview,
-  // and docks the group on release. We do NOT rely on DOM pointer events crossing
-  // into the main window: on WebKitGTK (especially Wayland) DOM pointermove/up do
-  // not cross the OS window boundary, so the stream would die at the popout's edge
-  // and the drop would commit at stale in-popout coords (never docking). Instead
-  // we POLL `cursorPosition()` on a timer; that is a desktop-global PHYSICAL
-  // position, so we (a) divide by our scale factor to emit logical/CSS px for the
-  // main window (which subtracts its logical origin in the same unit) and (b) use
-  // the raw physical position to move our OWN window so it follows the cursor like
-  // a dragged tab. Release is detected via DOM pointerup/pointercancel (which fire
-  // in the popout when released over it; an X11 implicit grab also delivers them
-  // when released over the main window). END carries the LAST polled cursor
-  // position so the drop resolves where the cursor truly is. Only Escape cancels;
-  // pointercancel commits (WebKitGTK fires it in place of pointerup).
+  // #42: drag-to-dock. We stream the gesture's OS-LEVEL CURSOR position (PHYSICAL
+  // desktop px — the canonical cross-window space, see lib/coords) to the main
+  // window, which maps it into its own client space and renders the dock preview /
+  // docks on release. We do NOT rely on DOM pointer events crossing into the main
+  // window: on WebKitGTK (esp. Wayland) DOM pointermove/up don't cross the OS
+  // window boundary, and DOM `screenX/Y` units diverge across engines under DPI
+  // scaling. Instead we POLL `cursorPosition()` (already physical, cross-engine):
+  // (a) emit it verbatim for the main window, and (b) on Linux only — see
+  // `followWindowOnDockDrag` — use it to move our OWN window so it follows the
+  // cursor (on Win/mac `setPosition` under a held button can drop pointer capture).
+  // Release is centralized through `bindDragRelease`, which applies the
+  // engine-correct cancel-vs-commit policy; END carries the last polled cursor.
   const beginDockDrag = (args: {
     pointerId: number;
-    screenX: number;
-    screenY: number;
     clientX?: number;
     clientY?: number;
     captureEl: HTMLElement | null;
     label: string;
     moveWindow: boolean;
+    // The source group of a per-tab drag (for local ghost/reorder visuals).
+    sourceGroup?: GroupNode;
     tabKey?: string;
+    // ONE pane (inner group) of a multi-pane popout dragged by its bar grip: the
+    // host docks just this group (attachDetachedPane) — never the whole popout.
+    paneGroupId?: string;
   }) => {
-    const { pointerId, captureEl, label: dragLabel, moveWindow, tabKey } = args;
-    try {
-      captureEl?.setPointerCapture(pointerId);
-    } catch {
-      /* capture is best-effort; the OS-cursor poll does not depend on it */
+    const { pointerId, captureEl, label: dragLabel, moveWindow, tabKey, sourceGroup, paneGroupId } =
+      args;
+    // Per-tab drags pass `captureEl: null` (no stable element under the pointer);
+    // on engines that need capture to deliver the terminal event, fall back to a
+    // stable element (the panel root, else document.body). Without this, dragging a
+    // SINGLE tab out of a popout never receives its release on Win/mac and never
+    // docks. WebKitGTK keeps the implicit grab, so it needs no capture at all.
+    const capEl =
+      captureEl ??
+      (dragPlatform.needsPointerCapture ? (panelRef.current ?? document.body) : null);
+    // Capture whenever a real element is present (preserves the old unconditional
+    // Linux capture for whole-window/group/titlebar drags); the `capEl` fallback
+    // ADDS capture only on engines that need it (Win/mac) for the per-tab case.
+    if (capEl) {
+      try {
+        capEl.setPointerCapture(pointerId);
+      } catch {
+        /* capture is best-effort; the OS-cursor poll does not depend on it */
+      }
     }
 
     const win = getCurrentWindow();
-    // Latest OS cursor position in logical/CSS px (updated by the poll). Seeded
-    // from the pointerdown's screen coords (WebKitGTK reports these in CSS px).
-    let last = { x: args.screenX, y: args.screenY };
-    let scale = 1;
+    // `last` tracks the physical desktop cursor (the canonical cross-window space).
+    let last: PhysPoint = { x: 0, y: 0 };
     let done = false;
-    // Physical offset from the window's top-left to the cursor at grab time, so
-    // the window can follow the cursor without jumping (whole-group drag only).
     let grab: { x: number; y: number } | null = null;
-    let moving = false; // in-flight guard so 60 Hz polls don't queue setPosition.
-    // This popout's content origin in screen CSS px, so a per-tab release can be
-    // mapped to client coords for the local-bar hit-test. Resolved async.
-    let origin = { x: 0, y: 0 };
-
-    void win
-      .scaleFactor()
-      .then(async (s) => {
-        scale = s || 1;
-        if (tabKey != null) {
-          const ip = await win.innerPosition();
-          const lg = ip.toLogical(scale);
-          origin = { x: lg.x, y: lg.y };
-        }
-      })
-      .catch(() => {});
-    if (moveWindow) {
-      void Promise.all([win.outerPosition(), cursorPosition()])
-        .then(([pos, cur]) => {
-          grab = { x: cur.x - pos.x, y: cur.y - pos.y };
-        })
-        .catch(() => {});
-    }
+    let moving = false;
+    // Our own window frame (physical px), for mapping the physical cursor back into
+    // our client px for the local per-tab hit-test. Snapshotted up front.
+    let popoutFrame: WindowFrame | null = null;
+    let pollId: number | null = null;
+    let unbindRelease: (() => void) | null = null;
 
-    void emit(DETACHED_DRAG_START, {
-      scope,
-      groupId: group.id,
-      label: dragLabel,
-      screenX: last.x,
-      screenY: last.y,
-      tabKey,
-    } satisfies DetachedDragStart);
-
-    // Per-tab drag: drive THIS popout's own drag store so the bar shows the same
-    // live feedback as the main window — the dragged tab collapses, a content
-    // thumbnail follows the cursor (DragGhost), and a gap opens at the drop slot.
-    // The visuals are local to the popout; cross-window docking is still driven by
-    // the streamed DETACHED_DRAG_* events above. Clone the active pane for the
-    // ghost thumbnail, picking the VISIBLE pane (hidden duplicates measure zero).
+    // Per-tab drags show a local ghost immediately (no frame needed): clone the
+    // dragged pane and seed the popout's own drag store synchronously on press.
     if (tabKey != null) {
       const pane =
         Array.from(
@@ -329,7 +905,7 @@ export function DetachedCenterPanel({
       }
       useDragStore.getState().start({
         key: tabKey,
-        fromGroup: group.id,
+        fromGroup: sourceGroup?.id ?? popoutId,
         label: dragLabel,
         pointerX: args.clientX ?? 0,
         pointerY: args.clientY ?? 0,
@@ -339,222 +915,738 @@ export function DetachedCenterPanel({
       });
     }
 
-    // Poll the OS cursor (~60 Hz). This is what survives the cursor leaving the
-    // popout window — DOM pointermove does not on WebKitGTK.
-    const poll = window.setInterval(() => {
-      void cursorPosition()
-        .then((p) => {
-          if (done) return;
-          last = { x: p.x / scale, y: p.y / scale };
-          void emit(DETACHED_DRAG_MOVE, {
-            screenX: last.x,
-            screenY: last.y,
-          } satisfies DetachedDragMove);
-          // Move our own window to follow the cursor (physical px; whole-group
-          // drag only). Skip while a previous move is still in flight to avoid an
-          // IPC backlog.
-          if (moveWindow && grab && !moving) {
-            moving = true;
-            void win
-              .setPosition(
-                new PhysicalPosition(
-                  Math.round(p.x - grab.x),
-                  Math.round(p.y - grab.y),
-                ),
-              )
-              .catch(() => {})
-              .finally(() => {
-                moving = false;
-              });
-          }
-          // Per-tab drag: update the local ghost + reorder gap. Map the OS cursor
-          // to popout-client coords (same `last - origin` as the release
-          // hit-test). While the cursor is over the popout, the ghost follows and
-          // the gap tracks the bar slot; once it leaves (over the main window) we
-          // freeze the ghost and clear the gap — the main window then shows its
-          // own preview from the streamed events.
-          if (tabKey != null) {
-            const cx = last.x - origin.x;
-            const cy = last.y - origin.y;
-            const overPopout =
-              cx >= 0 &&
-              cy >= 0 &&
-              cx <= window.innerWidth &&
-              cy <= window.innerHeight;
-            if (overPopout) {
-              useDragStore.getState().move(cx, cy);
-              resolveLocalReorder(cx, cy);
-            } else if (useDragStore.getState().drag?.reorderGroup) {
-              useDragStore.getState().setTarget({
-                overGroup: null,
-                edge: null,
-                reorderGroup: null,
-                reorderIndex: null,
-              });
+    const startPoll = () => {
+      pollId = window.setInterval(() => {
+        void cursorPosition()
+          .then((p) => {
+            if (done) return;
+            last = { x: p.x, y: p.y };
+            void emit(DETACHED_DRAG_MOVE, {
+              cursorPhysX: p.x,
+              cursorPhysY: p.y,
+            } satisfies DetachedDragMove);
+            // Linux-only cosmetic window-follow (Win/mac: the main window already
+            // paints the preview + ghost; setPosition would fight the OS).
+            if (moveWindow && dragPlatform.followWindowOnDockDrag && grab && !moving) {
+              moving = true;
+              void win
+                .setPosition(
+                  new PhysicalPosition(
+                    Math.round(p.x - grab.x),
+                    Math.round(p.y - grab.y),
+                  ),
+                )
+                .catch(() => {})
+                .finally(() => {
+                  moving = false;
+                });
+            }
+            if (tabKey != null && sourceGroup && popoutFrame) {
+              // physical desktop px → our own client px (innerPhys/scale), the only
+              // DPI-correct conversion — never outerPosition.
+              const c = physToClient(popoutFrame, { x: p.x, y: p.y });
+              const overPopout =
+                c.x >= 0 && c.y >= 0 && c.x <= window.innerWidth && c.y <= window.innerHeight;
+              if (overPopout) {
+                useDragStore.getState().move(c.x, c.y);
+                resolveLocalTarget(c.x, c.y);
+              } else if (
+                useDragStore.getState().drag?.reorderGroup ||
+                useDragStore.getState().drag?.overGroup
+              ) {
+                useDragStore.getState().setTarget({
+                  overGroup: null,
+                  edge: null,
+                  reorderGroup: null,
+                  reorderIndex: null,
+                });
+              }
             }
+          })
+          .catch(() => {});
+      }, 16);
+    };
+
+    // Snapshot our frame, seed the gesture's initial physical cursor, emit START,
+    // THEN start the poll — so a MOVE never reaches the main window before START
+    // (the main's MOVE/END handlers guard on the in-flight detached drag).
+    void snapshotFrame(win)
+      .then(async (f) => {
+        if (done) return;
+        popoutFrame = f;
+        // Seed: for a per-tab drag, derive from the press's client coords (exact
+        // origin of the gesture); otherwise read the OS cursor (physical).
+        const seed: PhysPoint =
+          tabKey != null && args.clientX != null && args.clientY != null
+            ? clientToPhys(f, { x: args.clientX, y: args.clientY })
+            : await desktopCursor().catch(() => ({ x: f.innerPhys.x, y: f.innerPhys.y }));
+        if (done) return;
+        last = seed;
+        if (moveWindow) {
+          // Grab offset = cursor − window origin, both physical, so the window
+          // tracks the cursor without jumping. Computed for BOTH window-follow
+          // modes: on Linux the poll uses it per-tick to follow the cursor; on
+          // Win/mac (`!followWindowOnDockDrag`) the poll skips the follow, but
+          // `finish` uses this same offset for ONE final `setPosition` so a
+          // free-space release lands the popout where it was dropped instead of
+          // leaving it frozen at its start position (the Windows regression).
+          try {
+            const cur = await cursorPosition();
+            grab = { x: cur.x - f.outerPhys.x, y: cur.y - f.outerPhys.y };
+          } catch {
+            grab = null;
           }
-        })
-        .catch(() => {});
-    }, 16);
+        }
+        void emit(DETACHED_DRAG_START, {
+          scope,
+          // Cross-window protocol identifies the popout RECORD, not the inner group.
+          groupId: popoutId,
+          label: dragLabel,
+          cursorPhysX: seed.x,
+          cursorPhysY: seed.y,
+          tabKey,
+          paneId: paneGroupId,
+        } satisfies DetachedDragStart);
+        startPoll();
+      })
+      .catch(() => {});
 
-    const finish = (cancelled: boolean) => {
+    const finish = (cancelled: boolean, shift = false) => {
       if (done) return;
       done = true;
-      window.clearInterval(poll);
-      window.removeEventListener("pointerup", onUp);
-      window.removeEventListener("pointercancel", onCancel);
-      window.removeEventListener("keydown", onKey);
+      if (pollId != null) window.clearInterval(pollId);
+      unbindRelease?.();
       try {
-        captureEl?.releasePointerCapture(pointerId);
+        capEl?.releasePointerCapture(pointerId);
       } catch {
         /* ignore */
       }
-      // Clear this popout's local drag visuals (ghost + gap); the actual reorder,
-      // if any, is applied by `release` via handleLocalTabRelease.
       if (tabKey != null) useDragStore.getState().end();
+      // Win/mac whole-window free-space release: the per-tick window-follow is
+      // disabled there (`!followWindowOnDockDrag`), so the popout never moved
+      // during the gesture and the main window's END no-ops on a free-space
+      // (inMain=false) drop — leaving the popout frozen at its origin. Move it
+      // ONCE here to where it was dropped, using the same grab offset the Linux
+      // follow uses. Skipped on cancel (Escape leaves it put). Harmless vs a
+      // dock-back: if released over the main window, attach_subwindow destroys
+      // this window an instant later, so a stray setPosition has no effect.
+      if (!cancelled && moveWindow && !dragPlatform.followWindowOnDockDrag && grab) {
+        void win
+          .setPosition(
+            new PhysicalPosition(
+              Math.round(last.x - grab.x),
+              Math.round(last.y - grab.y),
+            ),
+          )
+          .catch(() => {});
+      }
       void emit(DETACHED_DRAG_END, {
         cancelled,
-        screenX: last.x,
-        screenY: last.y,
+        cursorPhysX: last.x,
+        cursorPhysY: last.y,
+        shift,
       } satisfies DetachedDragEnd);
     };
-    // A per-tab release over THIS popout reorders locally (or no-ops over the
-    // body) and tells the host to cancel its dock; only a release clear of the
-    // popout falls through to the main window's dock. The whole-group drag always
-    // commits (the host decides via its own in-window check).
-    const release = () => {
-      if (tabKey != null) {
-        const handledLocally = handleLocalTabRelease(
-          tabKey,
-          last.x - origin.x,
-          last.y - origin.y,
-        );
-        finish(handledLocally);
+    const release = (shift = false) => {
+      // Shift ALWAYS means "pop into its own window" (unified with the main-window
+      // tab rule), so DON'T commit a within-popout drop under Shift — hand the
+      // gesture to the main host UNcancelled and let its unified ladder run the
+      // new-window branch (`decideDetachedTabDrop` → `detachTabToNewWindow`). For a
+      // lone-tab popout the host refuses (it's already its own window) → a clean
+      // no-op, never the previous local-split + Shift-bail hang. Without Shift, a
+      // release over THIS popout is still committed locally (reorder/split).
+      if (!shift && tabKey != null && sourceGroup && popoutFrame) {
+        const c = physToClient(popoutFrame, last);
+        const handledLocally = handleLocalTabRelease(tabKey, c.x, c.y);
+        finish(handledLocally, shift);
         return;
       }
-      finish(false);
+      // A PANE drag released over its own popout stays put: the window doesn't
+      // follow the cursor (moveWindow=false), and the popout usually floats
+      // ABOVE the main window — the host's inMain test alone would read a
+      // release-in-place as "dock into main". Cancel so the host no-ops.
+      if (!shift && paneGroupId != null && popoutFrame) {
+        const c = physToClient(popoutFrame, last);
+        const overSelf =
+          c.x >= 0 && c.y >= 0 && c.x <= window.innerWidth && c.y <= window.innerHeight;
+        if (overSelf) {
+          finish(true, shift);
+          return;
+        }
+      }
+      finish(false, shift);
+    };
+    // bindDragRelease applies the engine-correct policy (WebKitGTK: pointercancel
+    // commits; Win/mac: pointercancel aborts) + a blur backstop. Bound synchronously
+    // so the terminal event is captured from the start of the gesture.
+    unbindRelease = bindDragRelease({
+      onCommit: (shift) => release(shift),
+      onAbort: () => finish(true),
+    });
+  };
+
+  // Grab a group's bar grip → MOVE the whole popout window natively (option B:
+  // move-only). This replaces the old streamed move+dock gesture (`beginDockDrag`)
+  // whose cross-window protocol is what painted a dock/split preview in the main
+  // window while you were merely repositioning a popout. A popout no longer docks
+  // back — nor separates a pane — by dragging; those are part of a re-docking
+  // redesign still to come. Only the explicit `.tab-drag-grip` starts the move;
+  // grabbing empty bar space does not.
+  const onGroupBarPointerDown = (e: React.PointerEvent, _group: GroupNode) => {
+    if (e.button !== 0) return;
+    const target = e.target as HTMLElement;
+    if (!target.closest(".tab-drag-grip")) return;
+    e.preventDefault();
+    beginNativeWindowMove();
+  };
+
+  // #42 (Windows): show the cheap move placeholder for the duration of a NATIVE
+  // title-bar drag (`startDragging`), so WebView2 isn't repainting the terminal
+  // canvases during the OS modal move loop (which it can't do fast enough → the
+  // content lags the frame). End detection is deliberately belt-and-suspenders
+  // because the native move loop can swallow the terminal `pointerup`:
+  //   • show on the FIRST `onMoved` (so a non-drag click never flashes it),
+  //   • hide on `pointerup`/`pointercancel` (the normal release, cursor over us),
+  //   • hide once the window has stopped moving for a beat (release over ANOTHER
+  //     monitor, where our webview never sees the pointerup), and
+  //   • a hard timeout so the placeholder can never get stuck on.
+  const beginWindowMove = () => {
+    const win = getCurrentWindow();
+    let idle: ReturnType<typeof setTimeout> | undefined;
+    let unMoved: (() => void) | undefined;
+    let shown = false;
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      if (idle) clearTimeout(idle);
+      clearTimeout(hardStop);
+      unMoved?.();
+      window.removeEventListener("pointerup", finish);
+      window.removeEventListener("pointercancel", finish);
+      if (shown) setWindowDragging(false);
+    };
+    const onMoved = () => {
+      if (!shown) {
+        shown = true;
+        setWindowDragging(true);
+      }
+      if (idle) clearTimeout(idle);
+      idle = setTimeout(finish, 250);
+    };
+    const hardStop = setTimeout(finish, 10000);
+    window.addEventListener("pointerup", finish);
+    window.addEventListener("pointercancel", finish);
+    win
+      .onMoved(onMoved)
+      .then((fn) => (done ? fn() : (unMoved = fn)))
+      .catch(() => {});
+  };
+
+  // Move-only, most-native window reposition. Hands the drag straight to the OS
+  // (`startDragging`) instead of the streamed poll+setPosition dock gesture
+  // (`beginDockDrag`) — so it emits NO cross-window dock protocol and therefore
+  // no other window ever paints a dock/split preview for it. This is the whole-
+  // subwindow behaviour: a popout's grip and titlebar only REPOSITION the window;
+  // re-docking back into another window by dragging is deliberately gone (a
+  // separate re-docking design is planned). On Windows the move placeholder keeps
+  // the frame aligned during the OS modal move loop (WebView2 can't repaint the
+  // terminals fast enough); other engines don't need it.
+  const beginNativeWindowMove = () => {
+    if (PLATFORM === "windows") beginWindowMove();
+    void getCurrentWindow().startDragging().catch(() => {});
+  };
+
+  // #42: grab the popout's outer title bar to move/dock the WHOLE window. Mirrors
+  // the group-bar handle, but anchored to the always-full-width title strip so it
+  // works the same whether or not the content is split. The window controls carry
+  // `no-drag`, so a click on min/max/close never starts a drag.
+  const onTitlebarPointerDown = (e: React.PointerEvent) => {
+    if (e.button !== 0) return;
+    const target = e.target as HTMLElement;
+    if (target.closest(".detached-titlebar-controls, button, .no-drag")) return;
+    e.preventDefault();
+    // Move the whole popout window natively on every platform (see
+    // `beginNativeWindowMove`) — no streamed dock gesture, so dragging the
+    // titlebar never makes another window flash a dock/split preview.
+    beginNativeWindowMove();
+  };
+
+  // #42: dragging a SINGLE tab out of `group`. Activate on press, then once the
+  // pointer crosses a threshold start a per-tab dock drag. The threshold uses DOM
+  // `clientX/Y` (reliable in-window CSS px on every engine); cross-window position
+  // is poll-driven inside beginDockDrag. The press's client coords seed the gesture.
+  const onTabPointerDown = (e: React.PointerEvent, group: GroupNode, tab: TabEntry) => {
+    if (e.button !== 0) return;
+    e.stopPropagation();
+    onActivate(tab.key);
+    const startX = e.clientX;
+    const startY = e.clientY;
+    let armed = false;
+    const onMove = (ev: PointerEvent) => {
+      if (armed) return;
+      if (Math.hypot(ev.clientX - startX, ev.clientY - startY) < 5) return;
+      armed = true;
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
+      beginDockDrag({
+        pointerId: ev.pointerId,
+        clientX: ev.clientX,
+        clientY: ev.clientY,
+        captureEl: null,
+        sourceGroup: group,
+        tabKey: tab.key,
+        label: tab.label,
+        moveWindow: false,
+      });
     };
-    const onUp = () => release();
-    const onCancel = () => release();
-    const onKey = (ev: KeyboardEvent) => {
-      if (ev.key === "Escape") finish(true);
+    const onUp = () => {
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerup", onUp);
     };
+    window.addEventListener("pointermove", onMove);
     window.addEventListener("pointerup", onUp);
-    window.addEventListener("pointercancel", onCancel);
-    window.addEventListener("keydown", onKey);
   };
 
-  return (
-    <div className="detached-center center-panel">
-      <div className="subwindow focused">
+  // Render one group: its tab bar + a pane layer holding every tab (active shown).
+  // For a single-group popout this is the whole content; inside a split each group
+  // renders into its flex cell. The min/max/close window controls live in the
+  // popout's dedicated outer title bar (not here), so they stay pinned top-right
+  // regardless of how the content is split.
+  const renderGroup = (group: GroupNode) => {
+    const orderedTabs = group.tabKeys
+      .map((k) => byKey.get(k))
+      .filter((t): t is TabEntry => t != null);
+    // This bar is the live drop target of an in-flight drag: light up the whole
+    // bar and render a placeholder slot at the insertion point — identical to the
+    // main-window `TabBar` (shared `.drop-target` wash + `TabDropPlaceholder`),
+    // replacing the old fixed-margin gap so the merge/reorder preview matches.
+    const localReorder = reorderGroupId === group.id ? reorderIndex : null;
+    const isDropTarget = localReorder != null;
+    const dropPlaceholder = <TabDropPlaceholder label={dragLabel} />;
+    const isFocused = windowFocused && group.id === focusedGroupId;
+    return (
+      <div
+        className={`subwindow${isFocused ? " focused" : ""}`}
+        // Clicking anywhere in the group (bar or body) makes it the current one.
+        // Capture-phase so it wins before a tab/divider pointerdown stops
+        // propagation — mirrors the main window's `Subwindow`.
+        onMouseDownCapture={() => {
+          if (!isFocused) setFocusedGroupId(group.id);
+        }}
+      >
         <div
-          ref={barRef}
-          className="tab-bar detached-drag-handle"
+          ref={(el) => {
+            if (el) barRefs.current.set(group.id, el);
+            else barRefs.current.delete(group.id);
+          }}
+          className={`tab-bar detached-drag-handle${isDropTarget ? " drop-target" : ""}`}
           data-group-id={group.id}
-          onPointerDown={onTabBarPointerDown}
+          onPointerDown={(e) => onGroupBarPointerDown(e, group)}
         >
+          {/* Move grip — the sole tab-bar handle for moving/docking this popout
+              (the titlebar still moves it too). Always pinned at the far left so
+              it stays grabbable however many tabs fill the bar. A plain
+              (non-button) element, so its pointerdown bubbles to
+              `onGroupBarPointerDown`, which now fires only when the grip is the
+              target. */}
+          <div
+            className="tab-drag-grip"
+            title={t("detachedTabs.dragToMove")}
+            aria-hidden="true"
+          >
+            ⠿
+          </div>
+          {/* The tabs live in their own horizontally-scrolling strip; chevrons
+              flank it and appear only on overflow — the same behaviour as the
+              main-window `TabBar`. `revision` re-checks overflow when the tab set
+              (or its drop placeholder) changes. */}
+          <DetachedTabStrip
+            revision={`${orderedTabs.map((t) => t.key).join(",")}|${isDropTarget}|${localReorder}`}
+          >
+          {/* Empty bar that's a drop target: the placeholder is the only slot. */}
+          {isDropTarget && orderedTabs.length === 0 && (
+            <Fragment key="drop-marker">{dropPlaceholder}</Fragment>
+          )}
           {orderedTabs.map((tab, index) => {
             const isActive = tab.key === group.activeKey;
             const isDragging = dragKey === tab.key;
-            const isLast = index === orderedTabs.length - 1;
-            // Open the gap by sliding the neighbouring tab away from the slot; the
-            // dragged tab is collapsed (via `.tab.dragging`) so it carries no gap.
-            const style: React.CSSProperties = {};
-            if (!isDragging && reorderIndex != null) {
-              if (reorderIndex === index) style.marginLeft = REORDER_GAP;
-              if (isLast && reorderIndex === orderedTabs.length)
-                style.marginRight = REORDER_GAP;
-            }
+            // The placeholder slot previewing where the dragged tab will land —
+            // shown immediately before the tab at the resolved insertion index.
+            const showMarkerBefore = isDropTarget && localReorder === index;
+            // A tab freshly dropped into this bar plays the drop-in landing once.
+            const landing = !isDragging && landedKey === tab.key;
             return (
-              <div
-                key={tab.key}
-                className={`tab ${isActive ? "active" : ""}${isDragging ? " dragging" : ""}`}
-                style={style}
-                onPointerDown={(e) => onTabPointerDown(e, tab)}
-              >
-                <span className="tab-label">{tab.label}</span>
-                <button
-                  className="tab-close"
-                  onClick={(e) => {
-                    e.stopPropagation();
-                    onClose(tab.key);
+              <Fragment key={tab.key}>
+                {showMarkerBefore && dropPlaceholder}
+                <div
+                  className={`tab ${isActive ? "active" : ""}${isDragging ? " dragging" : ""}${landing ? " landing" : ""}`}
+                  onPointerDown={(e) => onTabPointerDown(e, group, tab)}
+                  // Styled hover card (same one the main window's TabBar shows —
+                  // this strip is bespoke, so it anchors the shared card itself).
+                  onMouseEnter={(e) => {
+                    const r = e.currentTarget.getBoundingClientRect();
+                    setHoverTab({ key: tab.key, x: r.left + r.width / 2, y: r.bottom });
                   }}
-                  title="Close tab"
+                  onMouseLeave={() =>
+                    setHoverTab((h) => (h?.key === tab.key ? null : h))
+                  }
+                  // Clear the landing once it finishes so the class doesn't linger
+                  // (guard on currentTarget so a child's animationend never clears
+                  // it early). Mirrors the main-window `TabBar`.
+                  onAnimationEnd={
+                    landing
+                      ? (e) => {
+                          if (e.target === e.currentTarget) clearLanded(landedNonce);
+                        }
+                      : undefined
+                  }
                 >
-                  ×
-                </button>
-              </div>
+                  <span className="tab-label">{tab.label}</span>
+                  {/* Local/remote badges — parity with the main-window TabBar,
+                      via the shared TabLocalityBadges. The source badge reads THIS
+                      window's fileSources store; the locality badge/menu use the
+                      streamed host list and route changes through onSetLocation. */}
+                  <TabSourceBadge tabKey={tab.key} />
+                  {isRemote && (
+                    <TabLocalityBadge
+                      tab={tab}
+                      primaryHost={primaryHost}
+                      computeHosts={computeHosts}
+                      onOpen={(r, startOnMachines) =>
+                        setLocalityMenu({
+                          key: tab.key,
+                          x: r.left,
+                          y: r.bottom + 2,
+                          view: startOnMachines ? "machines" : "root",
+                        })
+                      }
+                    />
+                  )}
+                  <button
+                    className="tab-close"
+                    onClick={(e) => {
+                      e.stopPropagation();
+                      onClose(tab.key);
+                    }}
+                    title={t("detachedTabs.closeTab")}
+                  >
+                    ×
+                  </button>
+                </div>
+              </Fragment>
             );
           })}
-          {/* Right-aligned title-bar cluster: native window controls. `no-drag`
-              so clicks here never start a window drag. Dock-back is done by
-              Ctrl+dragging the tab bar onto the main window (#42). */}
-          <div className="detached-titlebar-controls no-drag">
-            <WindowControls />
+          {/* Insertion at the end of the bar (slot === tab count). */}
+          {isDropTarget && localReorder === orderedTabs.length && orderedTabs.length > 0 && (
+            <Fragment key="drop-marker-end">{dropPlaceholder}</Fragment>
+          )}
+          {/* #42: the popout's own "+" — the detached window had no way to add
+              tabs. Streams an "add" edit to the main window (which owns tab
+              creation + the PTY) via onAddTab. */}
+          <div className="tab-new-wrap">
+            <button
+              className="tab-new-btn"
+              title={t("detachedTabs.newTab")}
+              // The bar's pointerdown starts a window-move/dock drag; keep the
+              // button's press out of it (it also excludes buttons, but be explicit).
+              onPointerDown={(e) => e.stopPropagation()}
+              onClick={(e) => {
+                e.stopPropagation();
+                const r = (e.currentTarget as HTMLElement).getBoundingClientRect();
+                setAddMenu((cur) =>
+                  cur && cur.groupId === group.id
+                    ? null
+                    : { groupId: group.id, x: r.left, y: r.bottom + 4 },
+                );
+              }}
+            >
+              +
+            </button>
+          </div>
+          </DetachedTabStrip>
+          {/* Per-subwindow right file viewer, same ◫ toggle as the main window's
+              TabBar. Applied optimistically + streamed to the main window. When
+              the viewer is docked below, the control reserves its width (like
+              the main window's `.tab-controls`) so it stays pinned above the
+              viewer and the strip stops at the pane edge. */}
+          <div
+            className="tab-controls"
+            style={
+              group.filesOpen
+                ? { width: clampFilesWidth(group.filesWidth ?? DEFAULT_GROUP_FILES_WIDTH) }
+                : undefined
+            }
+          >
+            <button
+              className={`subwindow-files-toggle${group.filesOpen ? " open" : ""}`}
+              title={
+                group.filesOpen
+                  ? "Close this subwindow's file viewer"
+                  : "Open a file viewer in this subwindow"
+              }
+              onPointerDown={(e) => e.stopPropagation()}
+              onClick={(e) => {
+                e.stopPropagation();
+                onFiles(group.id, { open: !group.filesOpen });
+              }}
+            >
+              ◫
+            </button>
+            {/* Hide the WHOLE popout into the main window's right-panel Hidden
+                list — the detached twin of the main-window bar's "–". Rendered
+                per bar (like ◫); for a multi-pane popout every bar's "–" hides
+                the whole window as one hidden entry. stopPropagation keeps the
+                press off the bar's window-move/dock drag. */}
+            {onHideWindow && (
+              <button
+                className="subwindow-hide"
+                title={t("detachedTabs.hideWindow")}
+                onPointerDown={(e) => e.stopPropagation()}
+                onClick={(e) => {
+                  e.stopPropagation();
+                  onHideWindow();
+                }}
+              >
+                –
+              </button>
+            )}
           </div>
         </div>
-        <div className="subwindow-body" ref={bodyRef}>
+        <div className="subwindow-body">
+          {/* The measured/drop-target body is the PANE REGION, not the whole
+              flex row — so edge-split drops and the split preview never target
+              the file-viewer column. */}
+          <div
+            className="subwindow-pane-region"
+            ref={(el) => {
+              if (el) bodyRefs.current.set(group.id, el);
+              else bodyRefs.current.delete(group.id);
+            }}
+          >
           <div className="pane-layer">
             {orderedTabs.map((tab) => {
               const visible = tab.key === group.activeKey;
               const style: React.CSSProperties = visible
-                ? { display: "flex", left: 0, top: 0, width: rect.w, height: rect.h }
+                ? { display: "flex", left: 0, top: 0, right: 0, bottom: 0 }
                 : { display: "none" };
               return (
-                <div
-                  key={tab.key}
-                  className="center-pane"
-                  data-tab-key={tab.key}
-                  style={style}
-                >
-                  {tab.kind === "files" ? (
-                    <FileBrowser
-                      projectDir={tab.cwd}
-                      projectId={scope === "root" ? null : scope}
-                      active={visible}
-                    />
-                  ) : tab.kind === "embed" ? (
-                    tab.viewer ? (
-                      <FileViewerPane
-                        viewer={tab.viewer}
-                        path={tab.embedPath ?? ""}
-                        projectId={scope === "root" ? null : scope}
-                        tabKey={tab.key}
-                        visible={visible}
-                      />
-                    ) : (
-                      <EmbedPane
-                        path={tab.embedPath ?? ""}
-                        exec={tab.embedExec}
-                        projectId={scope === "root" ? null : scope}
-                        visible={visible}
-                      />
-                    )
-                  ) : (
-                    <TerminalView
-                      // SAME id as the main window's pane so this re-attaches to
-                      // the existing PTY (output is broadcast). attachOnly => no
-                      // spawn, no kill-on-unmount.
-                      id={`${scope}:${tab.key}`}
-                      cmd={tab.cmd}
-                      args={tab.args ?? []}
-                      env={tab.env ?? {}}
-                      cwd={tab.cwd}
-                      localOnly={tab.kind === "local_agent"}
-                      visible={visible}
-                      focused={visible}
-                      attachOnly
-                    />
-                  )}
+                <div key={tab.key} className="center-pane" data-tab-key={tab.key} style={style}>
+                  {/* The shared per-tab render switch (`components/tabs/TabPane`),
+                      the SAME one the main window uses. A popout is attach-only (the
+                      main window owns the PTY) and doesn't own the tab store, so it
+                      passes no `ownsTabs`/`onConnect`/mirror props — the cwd is just
+                      the tab's, since the projects store the mirror-swap needs isn't
+                      here. See TabPane for why each prop differs between windows. */}
+                  <TabPane
+                    tab={tab}
+                    scope={scope}
+                    visible={visible}
+                    attachOnly
+                    filesProjectDir={tab.cwd}
+                    terminalCwd={tab.cwd}
+                  />
                 </div>
               );
             })}
           </div>
+          </div>
+          {/* Per-subwindow right file viewer. The popout has no projects store,
+              so the viewer resolves its root from the group's tab cwd (same
+              fallback a Files (Project) tab uses here); no open-in-new-tab (a
+              popout can't own tabs). Width edits stream back like the toggle. */}
+          {group.filesOpen && (
+            <SubwindowFilesSidebar
+              scope={scope}
+              cwd={
+                byKey.get(group.activeKey ?? group.tabKeys[0] ?? "")?.cwd ??
+                group.tabKeys.map((k) => byKey.get(k)?.cwd).find(Boolean) ??
+                ""
+              }
+              width={group.filesWidth}
+              onWidthChange={(w) => onFiles(group.id, { width: w })}
+              folder={group.filesFolder}
+              onFolderChange={(f) => onFiles(group.id, { folder: f })}
+              onHide={() => onFiles(group.id, { open: false })}
+            />
+          )}
         </div>
       </div>
-      {/* Floating ghost following the cursor during a per-tab drag (content
-          thumbnail + label), mirroring the main window. */}
+    );
+  };
+
+  // Recursively render the popout's layout tree. Splits become flex rows/columns
+  // sized by their fractions; groups render their bar + panes.
+  const renderNode = (node: LayoutNode): React.ReactNode => {
+    if (node.type === "group") {
+      return renderGroup(node);
+    }
+    return (
+      <div
+        className={`split split-${node.dir}`}
+        style={{
+          display: "flex",
+          flex: 1,
+          minWidth: 0,
+          minHeight: 0,
+          flexDirection: node.dir === "row" ? "row" : "column",
+        }}
+      >
+        {node.children.map((child, i) => (
+          <Fragment key={child.id}>
+            <div
+              className="split-child"
+              style={{
+                flex: `${node.sizes[i] ?? 1 / node.children.length} 1 0`,
+                display: "flex",
+                minWidth: 0,
+                minHeight: 0,
+              }}
+            >
+              {renderNode(child)}
+            </div>
+            {i < node.children.length - 1 && (
+              <div
+                className={`split-divider split-divider-${node.dir}`}
+                onPointerDown={onDividerPointerDown(node, i)}
+                // Double-click merges the two adjacent subwindows (both must be
+                // leaf groups). No `merge` edit exists, so replay it as one
+                // `move` per source tab into the left/top survivor — the main
+                // window applies each via moveKeyInTree (which collapses the
+                // emptied source) and streams the result back.
+                onDoubleClick={() => {
+                  const a = node.children[i];
+                  const b = node.children[i + 1];
+                  if (a.type === "group" && b.type === "group") {
+                    for (const key of b.tabKeys) onMove(key, a.id);
+                  }
+                }}
+              />
+            )}
+          </Fragment>
+        ))}
+      </div>
+    );
+  };
+
+  // Label shown on the move placeholder: the first group's active tab, else a
+  // generic fallback. Cheap to compute; only painted while `windowDragging`.
+  const firstGroup = allGroups(tree)[0];
+  const moveLabel =
+    (firstGroup ? tabs.find((t) => t.key === firstGroup.activeKey)?.label : undefined) ??
+    "Subwindow";
+
+  return (
+    <FileDropContext.Provider value={fileDrop}>
+    <div className={`detached-center center-panel${windowDragging ? " moving" : ""}`}>
+      {/* #42: the popout's own title bar — a full-width strip ABOVE the tab layout
+          that always hosts the min/max/close controls top-right. They used to live
+          in the root group's tab bar, which slid left (with the root group) once
+          the popout was split; an outer frame keeps them pinned. The empty strip
+          is a drag handle for moving / docking the whole window. */}
+      <div className="detached-titlebar detached-drag-handle" onPointerDown={onTitlebarPointerDown}>
+        {PLATFORM !== "macos" && (
+          <div className="detached-titlebar-controls no-drag">
+            <WindowControls />
+          </div>
+        )}
+      </div>
+      {/* The layout tree (below the title bar) is the positioning context for the
+          absolutely-inset split/subwindow nodes and the split-preview overlay. */}
+      <div ref={panelRef} className="detached-body">
+        {renderNode(tree)}
+        {/* Split preview: the translucent half/whole a split drop would carve out,
+            drawn above the per-group panes (mirrors the main window). */}
+        <SplitPreviewOverlay groupRects={groupRects} />
+        {/* Focus frame: the accent outline around the current subwindow (tab bar
+            + pane region, sidebar excluded), drawn here (above the opaque panes)
+            for the same reason as the split preview — an in-body frame would be
+            hidden. Mirrors the main window's `FocusFrameOverlay` (minus Shift+↑/↓
+            nav, which isn't wired here). Falls back to the pane rect if the
+            whole-subwindow box wasn't measured. */}
+        {windowFocused &&
+          focusedGroupId &&
+          (groupFrameRects[focusedGroupId] ?? groupRects[focusedGroupId]) && (
+            <div
+              className="focus-frame"
+              style={
+                groupFrameRects[focusedGroupId] ?? groupRects[focusedGroupId]
+              }
+            />
+          )}
+        {/* #42 (Windows): the move placeholder. While shown, `.detached-center.moving`
+            hides the heavy pane content so this trivial surface is all WebView2 has to
+            composite during the native drag — keeping the content aligned with the
+            frame instead of lagging behind it. */}
+        {windowDragging && (
+          <div className="detached-move-overlay">
+            <span>{moveLabel}</span>
+          </div>
+        )}
+      </div>
+      {dropActive && <div className="detached-drop-target" />}
+      {/* #42: the "+" add-tab menu for the group that opened it. cwd comes from a
+          tab already in that group (the popout's project directory). */}
+      {addMenu &&
+        (() => {
+          const g = findGroup(tree, addMenu.groupId);
+          if (!g) return null;
+          const cwd =
+            byKey.get(g.activeKey ?? g.tabKeys[0] ?? "")?.cwd ??
+            g.tabKeys.map((k) => byKey.get(k)?.cwd).find(Boolean) ??
+            "";
+          return (
+            <NewTabMenu
+              scope={scope}
+              projectCwd={cwd}
+              // The detached window is inert to the projects store, so there's no
+              // project name to auto-name an agent session with — skip it.
+              projectName=""
+              anchor={{ x: addMenu.x, y: addMenu.y }}
+              onPick={(tab) => onAddTab(tab, addMenu.groupId)}
+              onClose={() => setAddMenu(null)}
+              onManageAgents={() => setAgentDialogOpen(true)}
+            />
+          );
+        })()}
+      {agentDialogOpen && (
+        <CustomAgentDialog onClose={() => setAgentDialogOpen(false)} />
+      )}
+      {/* Multi-host locality menu — parity with the main-window TabBar, routed
+          through onSetLocation (the main window owns the PTY + respawns it). */}
+      {localityMenu && (
+        <LocalityMenu
+          menu={localityMenu}
+          current={tabLocation(byKey.get(localityMenu.key))}
+          primaryHost={primaryHost}
+          computeHosts={computeHosts}
+          onClose={() => setLocalityMenu(null)}
+          onChangeView={(view) => setLocalityMenu((m) => (m ? { ...m, view } : m))}
+          onChoose={(key, loc) => onSetLocation(key, loc)}
+        />
+      )}
+      {/* Styled tab hover card — parity with the main window's TabBar.
+          Suppressed mid-drag (local or streamed-in: both set the drag store)
+          and while the "+" menu is open so it never overlaps them. The card
+          reads THIS window's stores; the machine names come from the streamed
+          `remoteInfo` (the projects store is absent here). */}
+      {hoverTab && dragKey === null && !addMenu && (() => {
+        const tab = byKey.get(hoverTab.key);
+        if (!tab) return null;
+        return (
+          <TabHoverCard
+            tab={tab}
+            scope={scope}
+            isRemote={isRemote}
+            primaryHost={primaryHost}
+            computeHosts={computeHosts}
+            anchorX={hoverTab.x}
+            anchorY={hoverTab.y}
+          />
+        );
+      })()}
       <DragGhost />
     </div>
+    </FileDropContext.Provider>
   );
 }
diff --git a/src/components/layout/GlobalAppBar.tsx b/src/components/layout/GlobalAppBar.tsx
index 385d45b..46a0a96 100644
--- a/src/components/layout/GlobalAppBar.tsx
+++ b/src/components/layout/GlobalAppBar.tsx
@@ -6,21 +6,29 @@ import { useSettingsStore } from "../../stores/settings";
 import { FILES_TAB_CMD, useTabsStore } from "../../stores/tabs";
 import type { GlobalAppEntry } from "../../types";
 import { resolveProjectDirectory } from "../../types";
-
-export const GLOBAL_APP_ROLES: Array<{ key: string; label: string; fallback: string }> = [
-  { key: "browser", label: "Browser", fallback: "🌐" },
-  { key: "mail", label: "Mail", fallback: "✉" },
-  { key: "calendar", label: "Calendar", fallback: "◷" },
-  { key: "print_manager", label: "Print Manager", fallback: "⎙" },
-  { key: "file_manager", label: "File Manager", fallback: "📁" },
-  { key: "password_manager", label: "Password Manager", fallback: "⚿" },
-  { key: "video_conf", label: "Video Conf.", fallback: "▣" },
-  { key: "media_player", label: "Media Player", fallback: "▶" },
-  { key: "system_monitor", label: "System Monitor", fallback: "▥" },
-  { key: "notes", label: "Notes", fallback: "☰" },
-  { key: "screenshot", label: "Screenshot", fallback: "▤" },
-  { key: "screen_recorder", label: "Screen Recorder", fallback: "●" },
-  { key: "chat", label: "Chat", fallback: "☏" },
+import { basename, IS_WINDOWS } from "../../lib/paths";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+// A platform-appropriate example path for the executable-picker placeholder
+// (a Windows .exe vs a Unix bin path).
+const EXEC_PLACEHOLDER = IS_WINDOWS
+  ? "Command path, e.g. C:\\Program Files\\Mozilla Firefox\\firefox.exe"
+  : "Command path, e.g. /usr/bin/firefox";
+
+export const GLOBAL_APP_ROLES: Array<{ key: string; labelKey: TranslationKey; fallback: string }> = [
+  { key: "browser", labelKey: "globalApp.role.browser", fallback: "🌐" },
+  { key: "mail", labelKey: "globalApp.role.mail", fallback: "✉" },
+  { key: "calendar", labelKey: "globalApp.role.calendar", fallback: "◷" },
+  { key: "print_manager", labelKey: "globalApp.role.print_manager", fallback: "⎙" },
+  { key: "file_manager", labelKey: "globalApp.role.file_manager", fallback: "📁" },
+  { key: "password_manager", labelKey: "globalApp.role.password_manager", fallback: "⚿" },
+  { key: "video_conf", labelKey: "globalApp.role.video_conf", fallback: "▣" },
+  { key: "media_player", labelKey: "globalApp.role.media_player", fallback: "▶" },
+  { key: "system_monitor", labelKey: "globalApp.role.system_monitor", fallback: "▥" },
+  { key: "notes", labelKey: "globalApp.role.notes", fallback: "☰" },
+  { key: "screenshot", labelKey: "globalApp.role.screenshot", fallback: "▤" },
+  { key: "screen_recorder", labelKey: "globalApp.role.screen_recorder", fallback: "●" },
+  { key: "chat", labelKey: "globalApp.role.chat", fallback: "☏" },
 ];
 
 const ROLE_BY_KEY = Object.fromEntries(GLOBAL_APP_ROLES.map((role) => [role.key, role]));
@@ -34,6 +42,7 @@ type EditState = {
 };
 
 export function GlobalAppBar() {
+  const t = useT();
   const { settings, updateSettings } = useSettingsStore();
   const { projects, activeId } = useProjectsStore();
   const { ensureTab } = useTabsStore();
@@ -141,28 +150,30 @@ export function GlobalAppBar() {
   };
 
   return (
-    <div className="global-apps-toolbar" onClick={(e) => e.stopPropagation()}>
+    <div className="tab-new-menu" onClick={(e) => e.stopPropagation()}>
       {apps.map(([role, app]) => {
-        const meta = ROLE_BY_KEY[role] ?? { key: role, label: role, fallback: "●" };
+        const meta = ROLE_BY_KEY[role];
+        const label = meta ? t(meta.labelKey) : role;
         const iconDataUrl = app.exec ? iconDataUrls[app.exec] : null;
         return (
           <button
             key={role}
-            className="global-app-btn"
-            title={`${meta.label}${app.exec ? `: ${app.exec}` : ""} · Right-click to configure`}
+            className="tab-new-menu-item global-app-menu-row"
+            title={`${label}${app.exec ? `: ${app.exec}` : ""} · ${t("globalApp.rightClickConfigure")}`}
             aria-disabled={role !== "file_manager" && role !== "screenshot" && !app.exec}
             onClick={() => launch(role, app.exec)}
             onContextMenu={(event) => {
               event.preventDefault();
               event.stopPropagation();
-              setEdit({ role, label: meta.label, exec: app.exec, x: event.clientX, y: event.clientY });
+              setEdit({ role, label, exec: app.exec, x: event.clientX, y: event.clientY });
             }}
           >
             {iconDataUrl ? (
               <img className="global-app-icon" src={iconDataUrl} aria-hidden />
             ) : (
-              <span className="global-app-fallback-icon" aria-hidden>{meta.fallback}</span>
+              <span className="global-app-fallback-icon" aria-hidden>{meta?.fallback ?? "●"}</span>
             )}
+            {label}
           </button>
         );
       })}
@@ -174,11 +185,11 @@ export function GlobalAppBar() {
           onClick={(event) => event.stopPropagation()}
         >
           <div className="global-app-edit-title">{edit.label}</div>
-          <div className="global-app-edit-current">{basename(edit.exec) || "No command configured"}</div>
+          <div className="global-app-edit-current">{basename(edit.exec) || t("globalApp.noCommandConfigured")}</div>
           <div className="global-app-edit-row">
             <input
               value={edit.exec}
-              placeholder="Command path, e.g. /usr/bin/firefox"
+              placeholder={EXEC_PLACEHOLDER}
               onChange={(event) => setEdit({ ...edit, exec: event.target.value })}
               onKeyDown={(event) => {
                 if (event.key === "Enter") saveEdit();
@@ -188,8 +199,8 @@ export function GlobalAppBar() {
             <button type="button" onClick={() => void browseExecutable()}>...</button>
           </div>
           <div className="global-app-edit-actions">
-            <button type="button" onClick={clearEdit}>Clear</button>
-            <button type="button" className="suggested-action" onClick={saveEdit}>Set</button>
+            <button type="button" onClick={clearEdit}>{t("globalApp.clear")}</button>
+            <button type="button" className="suggested-action" onClick={saveEdit}>{t("globalApp.set")}</button>
           </div>
         </div>
       )}
@@ -210,10 +221,6 @@ function orderedGlobalApps(apps: Record<string, GlobalAppEntry>): Array<[string,
   ];
 }
 
-function basename(path: string): string {
-  return path.split("/").filter(Boolean).pop() ?? "";
-}
-
 // Flags that make a screenshot tool begin interactive rectangular-region
 // selection immediately on launch, keyed by the executable's basename. Tools we
 // don't recognize fall through to launching with no extra arguments.
@@ -226,6 +233,9 @@ const SCREENSHOT_REGION_ARGS: Record<string, string[]> = {
   "xfce4-screenshooter": ["--region"],
   ksnip: ["--rectarea"],
   shutter: ["--select"],
+  // macOS built-in: `screencapture -i <outfile>` starts interactive selection,
+  // letting the user drag a rectangular region (or spacebar to grab a window).
+  screencapture: ["-i"],
 };
 
 function screenshotRegionArgs(exec: string): string[] {
diff --git a/src/components/layout/GlobalAppMenu.tsx b/src/components/layout/GlobalAppMenu.tsx
index 9cfaa1e..b46285c 100644
--- a/src/components/layout/GlobalAppMenu.tsx
+++ b/src/components/layout/GlobalAppMenu.tsx
@@ -1,5 +1,6 @@
 import { useRef, useState } from "react";
 import { GlobalAppBar } from "./GlobalAppBar";
+import { useT } from "../../lib/i18n";
 
 /**
  * Header button that reveals the global-app launcher as a hover dropdown.
@@ -7,6 +8,7 @@ import { GlobalAppBar } from "./GlobalAppBar";
  * top-edge reveal strip.
  */
 export function GlobalAppMenu() {
+  const t = useT();
   const [open, setOpen] = useState(false);
   const closeTimer = useRef<number | null>(null);
 
@@ -35,18 +37,14 @@ export function GlobalAppMenu() {
       <button
         type="button"
         className="global-apps-menu-btn"
-        title="Global apps"
-        aria-label="Global apps"
+        title={t("globalAppMenu.title")}
+        aria-label={t("globalAppMenu.title")}
         aria-haspopup="menu"
         aria-expanded={open}
       >
         ▦
       </button>
-      {open && (
-        <div className="global-apps-menu-dropdown">
-          <GlobalAppBar />
-        </div>
-      )}
+      {open && <GlobalAppBar />}
     </div>
   );
 }
diff --git a/src/components/layout/HeaderBar.tsx b/src/components/layout/HeaderBar.tsx
index f3072a7..f6d7af3 100644
--- a/src/components/layout/HeaderBar.tsx
+++ b/src/components/layout/HeaderBar.tsx
@@ -2,16 +2,27 @@ import { useEffect, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
+import { PLATFORM } from "../../lib/dragPlatform";
+import { IS_MAC } from "../../lib/platform";
+import { trackWindowMove } from "../../stores/windowMove";
 import { AppTimerDisplay } from "../header/AppTimerDisplay";
 import { AppResourceDisplay } from "../header/AppResourceDisplay";
 import { Clock } from "../header/Clock";
+import { useEnergySaver, saverInterval } from "../../stores/power";
 import { ConnTypeIcon } from "../header/ConnTypeIcon";
-import { StatusLamp } from "../header/StatusLamp";
+import { VpnIndicator } from "../header/VpnIndicator";
+import { MachinesIndicator } from "../header/MachinesIndicator";
 import { WindowControls } from "../header/WindowControls";
 import { ProjectSwitcher } from "./ProjectSwitcher";
 import { GlobalAppMenu } from "./GlobalAppMenu";
+import { LocalModelMenu } from "./LocalModelMenu";
 import { LogoIcon } from "./LogoIcon";
 import { useProjectsStore } from "../../stores/projects";
+import { useT } from "../../lib/i18n";
+// Single source of truth for the displayed version: read package.json (kept in
+// lockstep with src-tauri/Cargo.toml + tauri.conf.json on every bump) so the
+// header never drifts behind a release.
+import { version as APP_VERSION } from "../../../package.json";
 
 interface WorkspaceInfo {
   label: string;
@@ -19,8 +30,6 @@ interface WorkspaceInfo {
   desktop_count: number | null;
 }
 
-const APP_VERSION = "0.1.0";
-
 const NON_DRAG_SELECTOR = [
   "button",
   "a",
@@ -34,18 +43,30 @@ const NON_DRAG_SELECTOR = [
 ].join(",");
 
 function handleDrag(e: React.MouseEvent) {
-  if (e.buttons !== 1) return;
+  // Gate on `button` (singular: 0 = left) not `buttons` (the held-button bitmask).
+  // WebKitGTK reports `buttons === 0` during the mousedown that begins a press —
+  // the bit isn't set until the next event — so `buttons !== 1` swallowed every
+  // drag on Linux (no grab ever started). `button === 0` is reliable on mousedown
+  // across WebKitGTK/Chromium/WKWebView and also ignores middle/right clicks.
+  if (e.button !== 0) return;
   const target = e.target as HTMLElement;
   if (!target.closest(NON_DRAG_SELECTOR)) {
+    // Windows: hide the heavy terminal panes for the duration of the OS move loop
+    // so WebView2 only composites the cheap frame and keeps up with the cursor
+    // (otherwise the canvases lag/swim behind the dragged window). Other engines
+    // drag the live content smoothly, so they skip the hide.
+    if (PLATFORM === "windows") trackWindowMove();
     getCurrentWindow().startDragging().catch(() => {});
   }
 }
 
 export function HeaderBar() {
+  const t = useT();
   const [online, setOnline] = useState(navigator.onLine);
   const [connType, setConnType] = useState<string | null>(null);
   const activeId = useProjectsStore((s) => s.activeId);
   const setActive = useProjectsStore((s) => s.setActive);
+  const energySaver = useEnergySaver();
 
   useEffect(() => {
     invoke<WorkspaceInfo>("workspace_info").catch(() => {});
@@ -69,39 +90,58 @@ export function HeaderBar() {
         .then(setConnType)
         .catch(() => {});
     poll();
-    const id = setInterval(poll, 10_000);
+    const id = setInterval(poll, saverInterval(10_000, energySaver));
     return () => clearInterval(id);
-  }, []);
+  }, [energySaver]);
 
   const isDev = import.meta.env.DEV;
   const connKind =
     connType === "lan" ? "lan" : connType === "wlan" ? "wlan" : null;
 
   return (
-    <header className="app-header" onMouseDown={handleDrag}>
+    <header
+      className={`app-header${IS_MAC ? " is-mac" : ""}`}
+      onMouseDown={handleDrag}
+    >
       <div className="header-left" data-tauri-drag-region>
+        {/* Explicit window-move grip. The whole header is already a drag region
+            (`handleDrag`), but a crowded header can leave nothing obvious to grab —
+            this grip is an always-present handle. A plain (non-button) element in a
+            drag-eligible area, so its mousedown bubbles to `handleDrag` (it doesn't
+            match NON_DRAG_SELECTOR), driving the same `startDragging()`. */}
+        <span
+          className="app-drag-grip"
+          title={t("header.dragToMove")}
+          aria-hidden="true"
+        >
+          ⠿
+        </span>
         <button
           type="button"
           className={`root-logo-btn no-drag ${activeId === null ? "active" : ""}`}
-          title="Root terminal"
-          aria-label="Root terminal"
+          title={t("header.rootTerminal")}
+          aria-label={t("header.rootTerminal")}
           onClick={() => void setActive(null)}
         >
           <LogoIcon className="app-logo" />
         </button>
-        <StatusLamp online={online} />
         <div className="app-version-stack">
           {isDev && <span className="debug-badge">DEBUG</span>}
           <span className="app-version-label">v{APP_VERSION}</span>
         </div>
-        {connKind && <ConnTypeIcon type={connKind} />}
+        {(connKind || !online) && (
+          <ConnTypeIcon type={connKind ?? "wlan"} online={online} />
+        )}
       </div>
 
       <div className="header-center no-drag">
+        <LocalModelMenu />
         <GlobalAppMenu />
         <ProjectSwitcher open />
       </div>
       <div className="header-right no-drag">
+        <VpnIndicator />
+        <MachinesIndicator />
         <AppResourceDisplay />
         <AppTimerDisplay />
         <Clock />
diff --git a/src/components/layout/HintHost.tsx b/src/components/layout/HintHost.tsx
new file mode 100644
index 0000000..532a65a
--- /dev/null
+++ b/src/components/layout/HintHost.tsx
@@ -0,0 +1,192 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { useHintsStore } from "../../stores/hints";
+import { useTabsStore } from "../../stores/tabs";
+import { useTourStore } from "../../stores/tour";
+import { HINTS, pickHint, type HintActionId, type HintCtx, type HintId } from "../../lib/hints";
+import {
+  codexHookNeedsTrust,
+  openCodexHooksTab,
+  type CodexHookState,
+} from "../../lib/codexHooks";
+import { HintBubble } from "../common/HintBubble";
+
+/** Handlers for hints that carry a one-click action (`HintDef.action`). */
+const HINT_ACTIONS: Record<HintActionId, () => void> = {
+  "codex-hooks": openCodexHooksTab,
+};
+
+// Don't surface anything until the app has settled (project load, the startup
+// fullscreen/resize churn), then space proactive hints out so they never feel
+// like a popup storm — one at a time, with a gap after each dismissal.
+const GRACE_MS = 3_000;
+const GAP_MS = 12_000;
+
+/**
+ * The contextual-hint engine: watches app state, picks the next eligible hint
+ * (pure `pickHint`), and renders it as a single anchored `HintBubble`. Mounted
+ * once in `AppShell`. Selection/ordering/persistence live in `lib/hints.ts` and
+ * `stores/hints.ts`; this component owns timing, anchor measurement, and Esc.
+ */
+export function HintHost() {
+  const projectCount = useProjectsStore((s) => s.projects.length);
+  const activeId = useProjectsStore((s) => s.activeId);
+  const settingsLoaded = useSettingsStore((s) => s.loaded);
+  const projectsLoaded = useProjectsStore((s) => s.loaded);
+  const seenList = useSettingsStore((s) => s.settings?.hints_seen);
+  const hintsEnabled = useSettingsStore((s) => s.settings?.hints_enabled ?? true);
+  const active = useHintsStore((s) => s.active);
+  const show = useHintsStore((s) => s.show);
+  const dismiss = useHintsStore((s) => s.dismiss);
+  const disableAll = useHintsStore((s) => s.disableAll);
+  // The guided tour is a fuller-screen overlay; suppress contextual hints while
+  // it runs so the two onboarding surfaces never paint at once.
+  const tourActive = useTourStore((s) => s.active);
+
+  // Codex hook trust. Only probed once a Codex tab actually exists, so users who
+  // never touch Codex are never nagged about it. Re-probed on window focus, which
+  // is when the user comes back from having (maybe) enabled it in Codex's /hooks
+  // list — and once it reports enabled, the hint is retired for good.
+  const tabsByScope = useTabsStore((s) => s.tabsByScope);
+  const hasCodexTab = useMemo(
+    () => Object.values(tabsByScope).some((tabs) => tabs.some((t) => t.cmd === "codex")),
+    [tabsByScope],
+  );
+  const [codexHook, setCodexHook] = useState<CodexHookState | null>(null);
+  const markSeen = useHintsStore((s) => s.markSeen);
+
+  useEffect(() => {
+    if (!hasCodexTab) return;
+    let cancelled = false;
+    const probe = () => {
+      invoke<CodexHookState>("codex_hook_status")
+        .then((state) => {
+          if (cancelled) return;
+          setCodexHook(state);
+          if (state === "enabled") markSeen("codex-hook-trust");
+        })
+        .catch(() => {});
+    };
+    probe();
+    window.addEventListener("focus", probe);
+    return () => {
+      cancelled = true;
+      window.removeEventListener("focus", probe);
+    };
+  }, [hasCodexTab, markSeen]);
+
+  const mountedAt = useRef(Date.now());
+  const lastClearedAt = useRef(0);
+  const [rect, setRect] = useState<DOMRect | null>(null);
+
+  const def = active ? HINTS.find((h) => h.id === active) ?? null : null;
+
+  // Decide whether/when to surface the next hint. Re-runs whenever the context,
+  // the seen-set, or the active hint changes.
+  useEffect(() => {
+    if (active) return; // one at a time
+    if (tourActive) return; // never surface a hint over the guided tour
+    if (!settingsLoaded || !projectsLoaded || !hintsEnabled) return;
+    const seen = new Set<string>(Array.isArray(seenList) ? (seenList as string[]) : []);
+    const ctx: HintCtx = {
+      projectCount,
+      activeId,
+      codexHookNeedsTrust: hasCodexTab && codexHookNeedsTrust(codexHook),
+    };
+    const candidate = pickHint(ctx, seen, hintsEnabled);
+    if (!candidate) return;
+    const earliest = Math.max(mountedAt.current + GRACE_MS, lastClearedAt.current + GAP_MS);
+    const delay = Math.max(0, earliest - Date.now());
+    const t = window.setTimeout(() => {
+      // Re-check on fire: nothing surfaced meanwhile and it's still eligible.
+      if (useHintsStore.getState().active) return;
+      const seenNow = new Set<string>(
+        (useSettingsStore.getState().settings?.hints_seen as string[] | undefined) ?? [],
+      );
+      const stillOn = pickHint(ctx, seenNow, hintsEnabled);
+      if (stillOn === candidate) show(candidate as HintId);
+    }, delay);
+    return () => window.clearTimeout(t);
+  }, [
+    active,
+    tourActive,
+    settingsLoaded,
+    projectsLoaded,
+    hintsEnabled,
+    seenList,
+    projectCount,
+    activeId,
+    hasCodexTab,
+    codexHook,
+    show,
+  ]);
+
+  // Measure the active hint's anchor and keep it positioned as the window/layout
+  // shifts. Banners (no anchor) stay centered via CSS, so rect stays null.
+  useEffect(() => {
+    if (!def) {
+      setRect(null);
+      return;
+    }
+    if (!def.anchor) {
+      setRect(null);
+      return;
+    }
+    const measure = () => {
+      const el = document.querySelector(def.anchor as string);
+      setRect(el ? el.getBoundingClientRect() : null);
+    };
+    measure();
+    window.addEventListener("resize", measure, true);
+    window.addEventListener("scroll", measure, true);
+    return () => {
+      window.removeEventListener("resize", measure, true);
+      window.removeEventListener("scroll", measure, true);
+    };
+  }, [def]);
+
+  // While an anchored hint is on screen, pulse the element it points at so the
+  // eye lands on the thing to click. Re-resolved per active hint; cleaned up on
+  // dismissal/change so the class never lingers on stale chrome.
+  useEffect(() => {
+    if (!def?.anchor) return;
+    const el = document.querySelector(def.anchor);
+    if (!el) return;
+    el.classList.add("hint-target");
+    return () => el.classList.remove("hint-target");
+  }, [def]);
+
+  // Esc dismisses the active hint while one is shown.
+  useEffect(() => {
+    if (!active) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") dismiss(active);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [active, dismiss]);
+
+  if (!def) return null;
+  // An anchored hint whose target isn't currently in the DOM: hold (don't paint
+  // a stray floating box). Banners (no anchor) always render.
+  if (def.anchor && !rect) return null;
+
+  return (
+    <HintBubble
+      rect={rect}
+      placement={def.placement}
+      title={def.title}
+      body={def.body}
+      action={
+        def.action && { label: def.action.label, run: HINT_ACTIONS[def.action.id] }
+      }
+      onDismiss={() => {
+        lastClearedAt.current = Date.now();
+        dismiss(def.id);
+      }}
+      onDisableAll={disableAll}
+    />
+  );
+}
diff --git a/src/components/layout/HowToStart.tsx b/src/components/layout/HowToStart.tsx
new file mode 100644
index 0000000..fd502ab
--- /dev/null
+++ b/src/components/layout/HowToStart.tsx
@@ -0,0 +1,84 @@
+import { useEffect } from "react";
+import { HOW_TO_START_STEPS } from "../../lib/hints";
+import { useT } from "../../lib/i18n";
+
+/**
+ * The first-run "How to start" instruction: a single scannable modal shown once
+ * on the first launch of an empty install, and re-openable from Settings / the
+ * gear menu. Reuses the `.modal-backdrop` + `.settings-dialog` skeleton from
+ * `SettingsDialog` (and, unlike it, brings its own Esc handler). Content comes
+ * from `HOW_TO_START_STEPS` so it stays in lockstep with the Feature Guide.
+ */
+export function HowToStart({ onClose }: { onClose: () => void }) {
+  const t = useT();
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") onClose();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [onClose]);
+
+  return (
+    <div className="modal-backdrop how-to-start-backdrop" onMouseDown={onClose}>
+      <div
+        className="settings-dialog how-to-start-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-label={t("howToStart.title")}
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{t("howToStart.title")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <p className="settings-help">{t("howToStart.intro")}</p>
+
+        <ol className="how-to-start-steps">
+          {HOW_TO_START_STEPS.map((step, i) => (
+            <li key={step.title} className="how-to-start-step">
+              <span className="how-to-start-num">{i + 1}</span>
+              <div>
+                <div className="how-to-start-step-title">{step.title}</div>
+                <div className="settings-help">{step.body}</div>
+              </div>
+            </li>
+          ))}
+        </ol>
+
+        <div className="settings-link-row">
+          <button
+            type="button"
+            onClick={() => {
+              window.dispatchEvent(new CustomEvent("eldrun:open-settings", { detail: "help" }));
+              onClose();
+            }}
+          >
+            {t("howToStart.openFeatureGuide")}
+          </button>
+          <button
+            type="button"
+            onClick={() => {
+              onClose();
+              window.dispatchEvent(new Event("eldrun:start-tour"));
+            }}
+          >
+            {t("howToStart.takeTour")}
+          </button>
+          <button
+            type="button"
+            onClick={() => {
+              onClose();
+              window.dispatchEvent(new Event("eldrun:open-lessons"));
+            }}
+          >
+            {t("howToStart.lessons")}
+          </button>
+          <button type="button" className="how-to-start-got-it" onClick={onClose}>
+            {t("howToStart.gotIt")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/layout/LessonsMenu.tsx b/src/components/layout/LessonsMenu.tsx
new file mode 100644
index 0000000..4cee07d
--- /dev/null
+++ b/src/components/layout/LessonsMenu.tsx
@@ -0,0 +1,69 @@
+import { Fragment, useEffect } from "react";
+import { LESSONS } from "../../lib/lessons";
+import { useTourStore } from "../../stores/tour";
+import { useT } from "../../lib/i18n";
+
+/**
+ * The lesson picker: a small modal listing the task "lessons" (add a project,
+ * install an agent, use a local model, …). Picking one closes the dialog and
+ * starts that lesson through the shared tour engine
+ * (`useTourStore.startLesson`). Re-openable any time from the gear menu /
+ * Settings; reuses the `.modal-backdrop` + `.settings-dialog` skeleton (and,
+ * like `HowToStart`, brings its own Esc handler).
+ */
+export function LessonsMenu({ onClose }: { onClose: () => void }) {
+  const t = useT();
+  const startLesson = useTourStore((s) => s.startLesson);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") onClose();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [onClose]);
+
+  return (
+    <div className="modal-backdrop how-to-start-backdrop" onMouseDown={onClose}>
+      <div
+        className="settings-dialog how-to-start-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-label={t("lessons.title")}
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{t("lessons.title")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <p className="settings-help">{t("lessons.intro")}</p>
+
+        <div className="lessons-list">
+          {LESSONS.map((lesson, i) => {
+            // LESSONS is sorted by category (easy → hard), so a header is shown
+            // whenever the tier changes from the previous lesson.
+            const newSection = i === 0 || LESSONS[i - 1].category !== lesson.category;
+            return (
+              <Fragment key={lesson.id}>
+                {newSection && (
+                  <h3 className="lessons-section-title">{lesson.category}</h3>
+                )}
+                <button
+                  type="button"
+                  className="lesson-item"
+                  onClick={() => {
+                    onClose();
+                    startLesson(lesson.steps);
+                  }}
+                >
+                  <span className="lesson-item-title">{lesson.title}</span>
+                  <span className="lesson-item-blurb">{lesson.blurb}</span>
+                </button>
+              </Fragment>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/layout/LocalModelMenu.tsx b/src/components/layout/LocalModelMenu.tsx
new file mode 100644
index 0000000..7458ff5
--- /dev/null
+++ b/src/components/layout/LocalModelMenu.tsx
@@ -0,0 +1,595 @@
+import { useEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { useSettingsStore } from "../../stores/settings";
+import { useEnergySaver, saverInterval } from "../../stores/power";
+import { useOllamaStatus } from "../../lib/ollamaStatus";
+import {
+  formatBytes,
+  gpuAdapterTooltip,
+  gpuTone,
+  gpuTotals,
+  type GpuSample,
+} from "../../lib/gpu";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+/** Subset of the backend `OllamaModelInfo` the menu needs (installed models). */
+interface LocalModelInfo {
+  name: string;
+  parameter_size: string | null;
+  quantization: string | null;
+  running: boolean;
+  /** VRAM bytes in use; non-zero → running on GPU. */
+  size_vram: number;
+}
+
+/** Subset of the backend `AgentInfo` the menu lists (installed agent CLIs). */
+interface AgentInfo {
+  id: string;
+  label: string;
+  installed: boolean;
+}
+
+/**
+ * The tasks a loaded model can be tagged for. Each maps to a key under
+ * `settings.ollama_roles`; a model wearing a tag is the one used for that task
+ * (autocomplete + grammar in the editor, "Local Model" agent tabs), so several
+ * resident models can each own a different job. A task with no tag falls back to
+ * the default `ollama_model`. Mirrors the consumers in `FileViewerPane`/`TabBar`.
+ */
+const MODEL_ROLES: Array<{ key: string; labelKey: TranslationKey }> = [
+  { key: "autocomplete", labelKey: "localModel.role.autocomplete" },
+  { key: "grammar", labelKey: "localModel.role.grammar" },
+  { key: "tabs", labelKey: "localModel.role.tabs" },
+];
+
+
+/**
+ * Header button (left of the global-apps button) for the local (Ollama) models.
+ * Hovering reveals the models currently loaded in memory (the running set from
+ * `list_ollama_models_detailed`), each shown with a green "loaded" lamp. Clicking
+ * a model's name makes it the default (`settings.ollama_model`); its task tags
+ * (Autocomplete / Grammar / Tabs → `settings.ollama_roles`) pin individual jobs
+ * to specific loaded models, so several can run different tasks in parallel. A
+ * task with no tag falls back to the default model. Always shown: when Ollama
+ * isn't installed (or no
+ * models are present yet) the menu offers an "Install models…" entry that opens
+ * the Ollama Settings panel, where Ollama itself and any model can be installed.
+ */
+export function LocalModelMenu() {
+  const t = useT();
+  const { settings, updateSettings } = useSettingsStore();
+  const activeModel = settings?.ollama_model;
+  const energySaver = useEnergySaver();
+  const [installed, setInstalled] = useState(false);
+  // Three-state Ollama health for the status lamp: "stopped" (server down, red),
+  // "idle" (server up, no model in memory, yellow), "loaded" (a model is loaded
+  // in memory, green).
+  // Once Ollama is installed, the server's health is polled so the button shows a
+  // live lamp without the user opening the menu. The poll itself is the app-wide
+  // shared one (`lib/ollamaStatus`) — it is a machine-wide fact, and the file
+  // viewer asks the same question per open tab, so a timer here as well meant the
+  // same `/api/ps` round trip several times over.
+  const status = useOllamaStatus(installed, saverInterval(5000, energySaver));
+  const [open, setOpen] = useState(false);
+  // Every installed model (from list_ollama_models_detailed). Resident ones are
+  // selectable as the active local model; the rest can be loaded into memory.
+  const [models, setModels] = useState<LocalModelInfo[]>([]);
+  /** The machine's GPUs; empty when none can be read, and then no headroom line. */
+  const [gpus, setGpus] = useState<GpuSample[]>([]);
+  // Installed agent CLIs (from list_agents), shown in the Agents section so the
+  // ones already available are visible without opening "Manage agents".
+  const [agents, setAgents] = useState<AgentInfo[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  // Models currently being loaded into memory, keyed by name (from the global
+  // `ollama-load-progress` events emitted by `load_ollama_model`, so a load
+  // started anywhere — here or the settings panel — shows here too). Ollama
+  // streams no load percentage, so this is an indeterminate state, not a pct.
+  const [loads, setLoads] = useState<Record<string, "loading" | "error">>({});
+  // Live pull progress per model ref (from the global `ollama-pull-progress`
+  // events emitted by `pull_ollama_model`), so downloads started anywhere show
+  // here too. `pct` is null during the manifest/verify phases (no byte totals).
+  const [downloads, setDownloads] = useState<Record<string, { pct: number | null }>>({});
+  // Models whose download the user paused this session — each offers Resume/Delete.
+  const [paused, setPaused] = useState<Set<string>>(new Set());
+  // Resident models being unloaded from memory (stop_ollama_model in flight), so
+  // the row can show "Unloading…" and disable the control until it settles.
+  const [unloading, setUnloading] = useState<Set<string>>(new Set());
+  const closeTimer = useRef<number | null>(null);
+
+  // Detect whether Ollama is installed. Poll while it's still missing so that
+  // installing Ollama mid-session is picked up without restarting Eldrun; stop
+  // once detected (it won't be uninstalled live, and `ollama_status` polling
+  // takes over from here — see below).
+  useEffect(() => {
+    if (installed) return;
+    let cancelled = false;
+    const check = () =>
+      invoke<boolean>("ollama_is_installed")
+        .then((ok) => {
+          if (!cancelled) setInstalled(ok);
+        })
+        .catch(() => {});
+    void check();
+    const id = window.setInterval(check, saverInterval(5000, energySaver));
+    return () => {
+      cancelled = true;
+      window.clearInterval(id);
+    };
+  }, [installed, energySaver]);
+
+  // Track in-flight downloads regardless of which surface started them.
+  useEffect(() => {
+    const un = listen<{ model: string; status: string; completed: number; total: number }>(
+      "ollama-pull-progress",
+      (e) => {
+        const { model, status, completed, total } = e.payload;
+        if (status === "paused") {
+          setDownloads((d) => {
+            const { [model]: _drop, ...rest } = d;
+            return rest;
+          });
+          setPaused((p) => new Set(p).add(model));
+          return;
+        }
+        setDownloads((d) => {
+          if (status === "success") {
+            const { [model]: _done, ...rest } = d;
+            return rest;
+          }
+          return {
+            ...d,
+            [model]: { pct: total > 0 ? Math.min(100, Math.floor((completed / total) * 100)) : null },
+          };
+        });
+      },
+    );
+    return () => {
+      void un.then((f) => f());
+    };
+  }, []);
+
+  // Track in-flight loads-into-memory regardless of which surface started them.
+  useEffect(() => {
+    const un = listen<{ model: string; status: string }>("ollama-load-progress", (e) => {
+      const { model, status } = e.payload;
+      setLoads((d) => {
+        if (status === "success") {
+          const { [model]: _done, ...rest } = d;
+          return rest;
+        }
+        return { ...d, [model]: status === "error" ? "error" : "loading" };
+      });
+      // Once a model becomes resident, re-read the list so it moves into the
+      // selectable (loaded) section.
+      if (status === "success") void fetchModels();
+    });
+    return () => {
+      void un.then((f) => f());
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+
+  // The GPU's own memory, polled only while the menu is open: the question this
+  // menu raises is "will the next model fit?", which each model's `size_vram`
+  // (its own share) cannot answer — only the free headroom on the device can.
+  useEffect(() => {
+    if (!open) return;
+    let cancelled = false;
+    const check = () =>
+      invoke<GpuSample[]>("gpu_memory_snapshot")
+        .then((g) => {
+          if (!cancelled) setGpus(g);
+        })
+        .catch(() => {});
+    void check();
+    const id = window.setInterval(check, saverInterval(2000, energySaver));
+    return () => {
+      cancelled = true;
+      window.clearInterval(id);
+    };
+  }, [open, energySaver]);
+
+  // Read the full installed-model list (resident + on-disk). Used on hover and
+  // re-run after a load completes so a freshly-resident model moves up.
+  const fetchModels = () => {
+    setLoading(true);
+    setError(null);
+    return invoke<LocalModelInfo[]>("list_ollama_models_detailed")
+      .then((all) => setModels(all))
+      .catch((e: string) => {
+        setModels([]);
+        setError(e === "not_running" ? t("localModel.notRunning") : t("localModel.failedToLoadModels"));
+      })
+      .finally(() => setLoading(false));
+  };
+
+  // Probe the installed agent CLIs (cheap PATH lookups in the backend) so the
+  // Agents section can list the ones already available.
+  const fetchAgents = () => {
+    invoke<AgentInfo[]>("list_agents")
+      .then((all) => setAgents(all.filter((a) => a.installed)))
+      .catch(() => {});
+  };
+
+  const reveal = () => {
+    if (closeTimer.current !== null) {
+      window.clearTimeout(closeTimer.current);
+      closeTimer.current = null;
+    }
+    setOpen(true);
+    fetchAgents();
+    if (!installed) return; // nothing to list yet — only the install entry shows
+    void fetchModels();
+  };
+
+  // Warm a model into memory and keep it resident. The button reflects progress
+  // via the `loads` map (driven by `ollama-load-progress`); we also optimistically
+  // mark it loading immediately so the bar shows without waiting for the event.
+  const loadIntoMemory = (model: string) => {
+    setLoads((d) => ({ ...d, [model]: "loading" }));
+    setError(null);
+    invoke("load_ollama_model", { model })
+      .then(() => fetchModels())
+      .catch((e: string) => {
+        setLoads((d) => ({ ...d, [model]: "error" }));
+        setError(typeof e === "string" && e === "not_running" ? t("localModel.notRunning") : t("localModel.failedToLoadModel"));
+      });
+  };
+
+  // Evict a resident model from memory (keep_alive=0) without deleting it from
+  // disk. Re-reads the model list afterwards so the row drops out of the resident
+  // section; the auto-assign effect then re-points tasks if a single model is left.
+  const unloadFromMemory = (model: string) => {
+    setUnloading((s) => new Set(s).add(model));
+    setError(null);
+    invoke("stop_ollama_model", { model })
+      .then(() => fetchModels())
+      .catch((e: string) =>
+        setError(typeof e === "string" && e === "not_running" ? t("localModel.notRunning") : t("localModel.failedToUnloadModel")),
+      )
+      .finally(() =>
+        setUnloading((s) => {
+          const n = new Set(s);
+          n.delete(model);
+          return n;
+        }),
+      );
+  };
+
+  // Pause an in-flight download; the backend keeps the partial blobs and emits a
+  // "paused" event that flips the row to Resume / Delete.
+  const pausePull = (model: string) => {
+    void invoke("pause_ollama_pull", { model });
+  };
+
+  // Resume a paused download — Ollama continues from the partial blobs.
+  const resumePull = (model: string) => {
+    setPaused((p) => {
+      const n = new Set(p);
+      n.delete(model);
+      return n;
+    });
+    invoke("pull_ollama_model", { model }).catch(() => {});
+  };
+
+  // Delete a paused download's partial data.
+  const deletePausedPull = (model: string) => {
+    setPaused((p) => {
+      const n = new Set(p);
+      n.delete(model);
+      return n;
+    });
+    void invoke("delete_ollama_pull", { model }).catch(() => {});
+  };
+
+  // Open the Ollama Settings panel (owned by ProjectSwitcher) to install Ollama
+  // and/or browse the installable-models catalog.
+  const openInstall = () => {
+    setOpen(false);
+    window.dispatchEvent(new CustomEvent("eldrun:open-settings", { detail: "ollama" }));
+  };
+
+  // Open the "Manage Agents" panel to install AI coding-agent CLIs (Claude,
+  // Codex, Gemini, Mistral, Aider, OpenCode, Cursor, Copilot, Grok, Qwen) that
+  // Eldrun can then launch as agent tabs.
+  const openAgents = () => {
+    setOpen(false);
+    window.dispatchEvent(new CustomEvent("eldrun:open-settings", { detail: "agents" }));
+  };
+
+  const scheduleClose = () => {
+    if (closeTimer.current !== null) window.clearTimeout(closeTimer.current);
+    closeTimer.current = window.setTimeout(() => {
+      setOpen(false);
+      closeTimer.current = null;
+    }, 250);
+  };
+
+  const select = (model: string | undefined) => {
+    void updateSettings({ ollama_model: model });
+    setOpen(false);
+  };
+
+  // When exactly one model is resident in memory, make it the model for
+  // everything — the default plus every task tag (autocomplete/grammar/tabs) —
+  // so loading a single model "just works" without wiring each task by hand.
+  // Tracked per resident model via a ref so we auto-apply once per newly-loaded
+  // sole model: manual reassignments the user makes afterwards (while that model
+  // stays the only resident one) are preserved. Dropping to zero or rising to
+  // two+ resident models re-arms it, so the next single-model load re-applies.
+  const autoAppliedFor = useRef<string | null>(null);
+  useEffect(() => {
+    if (!settings) return;
+    const resident = models.filter((m) => m.running);
+    if (resident.length !== 1) {
+      autoAppliedFor.current = null;
+      return;
+    }
+    const only = resident[0].name;
+    if (autoAppliedFor.current === only) return;
+    autoAppliedFor.current = only;
+    const current = settings.ollama_roles ?? {};
+    const already =
+      settings.ollama_model === only && MODEL_ROLES.every((r) => current[r.key] === only);
+    if (already) return;
+    const allRoles: Record<string, string> = {};
+    for (const r of MODEL_ROLES) allRoles[r.key] = only;
+    void updateSettings({ ollama_model: only, ollama_roles: allRoles });
+  }, [models, settings, updateSettings]);
+
+  // Per-task model tags. Each task maps to exactly one model; tagging a model for
+  // a task it already owns clears the tag (toggle). Kept open so several tags can
+  // be assigned in one pass. Unassigned tasks fall back to the default model.
+  const roles = settings?.ollama_roles ?? {};
+  const toggleRole = (role: string, model: string) => {
+    const next = { ...roles };
+    if (next[role] === model) delete next[role];
+    else next[role] = model;
+    void updateSettings({ ollama_roles: next });
+  };
+
+  // Resident models are selectable; the rest are offered as "load into memory".
+  const running = models.filter((m) => m.running);
+  const available = models.filter((m) => !m.running);
+  const { used: gpuUsed, total: gpuTotal } = gpuTotals(gpus);
+
+  return (
+    <div className="global-apps-menu no-drag" onMouseEnter={reveal} onMouseLeave={scheduleClose}>
+      <button
+        type="button"
+        className="global-apps-menu-btn local-model-btn"
+        title={
+          !installed
+            ? t("localModel.installTitle")
+            : `${t(
+                status === "loaded"
+                  ? "localModel.runningLoaded"
+                  : status === "idle"
+                    ? "localModel.running"
+                    : "localModel.stopped",
+              )}${activeModel ? t("localModel.modelSuffix", { name: activeModel }) : t("localModel.noModelSelected")}`
+        }
+        aria-label={t("localModel.ariaLabel")}
+        aria-haspopup="menu"
+        aria-expanded={open}
+        style={{ color: "var(--warning)" }}
+      >
+        🧠
+        {installed && (
+          <span
+            className={`local-model-status-dot ${status}`}
+            aria-hidden="true"
+          />
+        )}
+      </button>
+      {open && (
+        <div className="tab-new-menu">
+          <div className="tab-new-menu-group-label">{t("localModel.agentsGroup")}</div>
+          {agents.map((a) => (
+            <div key={a.id} className="local-model-agent-row" title={t("localModel.agentInstalled", { label: a.label })}>
+              {/* Green lamp mirrors a loaded model: this agent CLI is installed. */}
+              <span className="local-model-lamp" aria-hidden="true" />
+              <span className="local-model-loaded-name">{a.label}</span>
+            </div>
+          ))}
+          <button className="tab-new-menu-item" onClick={openAgents}>
+            <span className="tab-new-menu-dot" style={{ color: "transparent" }}>
+              ●
+            </span>
+            {t("localModel.manageAgents")}
+          </button>
+          <div className="tab-new-menu-group-label">{t("localModel.localModelsGroup")}</div>
+          {installed && (Object.keys(downloads).length > 0 || paused.size > 0) && (
+            <div className="local-model-downloads">
+              {Object.entries(downloads).map(([model, d]) => (
+                <div key={model} className="local-model-download-row" title={t("localModel.downloadingTitle")}>
+                  <div className="local-model-download-head">
+                    <span className="local-model-loaded-name">{model}</span>
+                    <span className="local-model-download-pct">
+                      {d.pct != null ? `${d.pct}%` : "…"}
+                    </span>
+                    <button
+                      type="button"
+                      className="local-model-download-action"
+                      title={t("localModel.pauseDownloadTitle")}
+                      onClick={() => pausePull(model)}
+                    >
+                      {t("ollama.pause")}
+                    </button>
+                  </div>
+                  <div className="ollama-download-bar">
+                    <div
+                      className={`ollama-download-bar-fill${d.pct == null ? " indeterminate" : ""}`}
+                      style={d.pct != null ? { width: `${d.pct}%` } : undefined}
+                    />
+                  </div>
+                </div>
+              ))}
+              {[...paused].map((model) => (
+                <div key={`paused:${model}`} className="local-model-download-row" title={t("localModel.pausedTitle")}>
+                  <div className="local-model-download-head">
+                    <span className="local-model-loaded-name">{model}</span>
+                    <span className="local-model-download-pct">{t("ollama.pausedBadge")}</span>
+                    <button
+                      type="button"
+                      className="local-model-download-action"
+                      title={t("localModel.resumeDownloadTitle")}
+                      onClick={() => resumePull(model)}
+                    >
+                      {t("ollama.resume")}
+                    </button>
+                    <button
+                      type="button"
+                      className="local-model-download-action danger"
+                      title={t("localModel.deletePartialDownloadTitle")}
+                      onClick={() => deletePausedPull(model)}
+                    >
+                      {t("ollama.delete")}
+                    </button>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+          {/* The device's memory, not any model's share of it: what is free here
+              is what the next model has to fit into. Absent when no GPU can be
+              read (macOS, an Intel-only box) — a zero would read as "no room". */}
+          {gpus.length > 0 && (
+            <div
+              className={`tab-new-menu-hint local-model-gpu ${gpuTone(gpuUsed, gpuTotal)}`}
+              title={gpus.map(gpuAdapterTooltip).join("\n")}
+            >
+              <span>{t("localModel.gpuUsedTotal", { used: formatBytes(gpuUsed), total: formatBytes(gpuTotal) })}</span>
+              <span>{t("localModel.gpuFree", { free: formatBytes(Math.max(0, gpuTotal - gpuUsed)) })}</span>
+            </div>
+          )}
+          {!installed ? (
+            <div className="tab-new-menu-hint">{t("localModel.notInstalled")}</div>
+          ) : loading && models.length === 0 ? (
+            <div className="tab-new-menu-hint">{t("common.loading")}</div>
+          ) : error ? (
+            <div className="tab-new-menu-hint">{error}</div>
+          ) : models.length === 0 ? (
+            <div className="tab-new-menu-hint">
+              {status === "stopped" ? t("localModel.serverStopped") : t("localModel.noModelsInstalled")}
+            </div>
+          ) : (
+            <>
+              {/* Resident models — selectable as the active local model. */}
+              {running.length === 0 ? (
+                <div className="tab-new-menu-hint">{t("ollama.noModelLoaded")}</div>
+              ) : (
+                running.map((m) => (
+                  <div key={m.name} className="local-model-row">
+                    <button
+                      className="tab-new-menu-item local-model-pick"
+                      title={t(
+                        activeModel === m.name
+                          ? "localModel.defaultLoadedTitle"
+                          : "localModel.loadedClickDefaultTitle",
+                      )}
+                      onClick={() => select(m.name)}
+                    >
+                      {/* Green lamp: this model is resident in Ollama's memory. */}
+                      <span className="local-model-lamp" aria-hidden="true" />
+                      <span className="local-model-loaded-name">{m.name}</span>
+                      {activeModel === m.name && (
+                        <span className="local-model-default-tag">{t("localModel.defaultTag")}</span>
+                      )}
+                      <span className="local-model-loaded-badges">
+                        {m.parameter_size && <span>{m.parameter_size}</span>}
+                        {m.quantization && <span>{m.quantization}</span>}
+                        <span className={m.size_vram > 0 ? "gpu" : "cpu"}>
+                          {m.size_vram > 0 ? `GPU ${formatBytes(m.size_vram)}` : "CPU"}
+                        </span>
+                      </span>
+                    </button>
+                    {/* Task tags: pin this model to a job (autocomplete/grammar/
+                        tabs). Several loaded models can each own a different one. */}
+                    <div className="local-model-roles">
+                      {MODEL_ROLES.map((r) => {
+                        const on = roles[r.key] === m.name;
+                        const roleLabel = t(r.labelKey);
+                        return (
+                          <button
+                            key={r.key}
+                            type="button"
+                            className={`local-model-role-chip${on ? " on" : ""}`}
+                            title={t(on ? "localModel.usedForRole" : "localModel.useForRole", {
+                              role: roleLabel.toLowerCase(),
+                              name: m.name,
+                            })}
+                            onClick={() => toggleRole(r.key, m.name)}
+                          >
+                            {roleLabel}
+                          </button>
+                        );
+                      })}
+                      {/* Evict this model from memory (keeps it on disk). */}
+                      <button
+                        type="button"
+                        className="local-model-role-chip local-model-unload"
+                        disabled={unloading.has(m.name)}
+                        title={t("localModel.unloadFromMemoryTitle", { name: m.name })}
+                        onClick={() => unloadFromMemory(m.name)}
+                      >
+                        {unloading.has(m.name) ? t("localModel.unloading") : t("ollama.unload")}
+                      </button>
+                    </div>
+                  </div>
+                ))
+              )}
+              {/* Installed-but-not-resident models — click to load into memory. */}
+              {available.length > 0 && (
+                <>
+                  <div className="tab-new-menu-group-label">{t("localModel.loadIntoMemoryGroup")}</div>
+                  {available.map((m) => {
+                    const st = loads[m.name];
+                    return (
+                      <div key={m.name} className="local-model-load-row">
+                        <div className="local-model-load-line">
+                          <span className="tab-new-menu-dot" style={{ color: "transparent" }}>
+                            ●
+                          </span>
+                          <span className="local-model-loaded-name">{m.name}</span>
+                          {m.parameter_size && (
+                            <span className="local-model-loaded-badges">
+                              <span>{m.parameter_size}</span>
+                            </span>
+                          )}
+                          <button
+                            type="button"
+                            className="local-model-role-chip local-model-load-action"
+                            disabled={st === "loading"}
+                            title={t(st === "error" ? "localModel.failedRetryTitle" : "localModel.loadIntoMemoryTitle")}
+                            onClick={() => loadIntoMemory(m.name)}
+                          >
+                            {st === "loading" ? t("common.loading") : st === "error" ? t("localModel.failed") : t("ollama.load")}
+                          </button>
+                        </div>
+                        {st === "loading" && (
+                          <div className="ollama-download-bar local-model-load-bar">
+                            <div className="ollama-download-bar-fill indeterminate" />
+                          </div>
+                        )}
+                      </div>
+                    );
+                  })}
+                </>
+              )}
+            </>
+          )}
+          <button className="tab-new-menu-item" onClick={openInstall}>
+            <span className="tab-new-menu-dot" style={{ color: "transparent" }}>
+              ●
+            </span>
+            {installed ? t("localModel.manageLocalModels") : t("localModel.installOllamaEllipsis")}
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/layout/LogoIcon.tsx b/src/components/layout/LogoIcon.tsx
index 6a618f5..ab03cc4 100644
--- a/src/components/layout/LogoIcon.tsx
+++ b/src/components/layout/LogoIcon.tsx
@@ -37,7 +37,7 @@ export function LogoIcon({ className }: LogoIconProps) {
             strokeWidth="10"
           />
           <path
-            d="M 98 235 L 98 289 L 144 335 L 233 405"
+            d="M 98 235 L 98 289 L 134.1 325.1 M 155 343.7 L 233 405"
             strokeWidth="10"
           />
           <circle cx="165" cy="162" r="14" strokeWidth="8" />
diff --git a/src/components/layout/ProjectSwitcher.tsx b/src/components/layout/ProjectSwitcher.tsx
index 518a926..9fa6306 100644
--- a/src/components/layout/ProjectSwitcher.tsx
+++ b/src/components/layout/ProjectSwitcher.tsx
@@ -1,15 +1,22 @@
 import { useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
-import { invoke } from "@tauri-apps/api/core";
-import { ProjectPill, PILL_DRAG_TYPE } from "../projects/ProjectPill";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { ProjectPill } from "../projects/ProjectPill";
 import { BoxPill } from "../projects/BoxPill";
+import { usePillDragStore } from "../../stores/pillDrag";
 import { ProjectSearch } from "../projects/ProjectSearch";
 import { ProjectDialog } from "../projects/ProjectDialog";
 import { SettingsDialog, type SettingsPanelKind } from "./SettingsPanel";
+import { UntestedTag } from "../common/UntestedTag";
+import { useHpcPipelineStore } from "../../stores/hpcPipeline";
+import { useBigFoldersStore } from "../../stores/bigFolders";
 import { useProjectsStore } from "../../stores/projects";
 import { useBoxesStore } from "../../stores/boxes";
 import { useTabsStore } from "../../stores/tabs";
-import type { ProjectBox, ProjectEntry } from "../../types";
+import { useGitDirtyStore } from "../../stores/gitDirty";
+import { useEnergySaver, saverInterval } from "../../stores/power";
+import { resolveProjectDirectory, type ProjectBox, type ProjectEntry } from "../../types";
+import { useT } from "../../lib/i18n";
 
 // Re-exported for tests and any external callers that imported these scaffold
 // helpers from ProjectSwitcher before the dialog was extracted (the public
@@ -22,6 +29,7 @@ export {
 } from "../projects/scaffold";
 
 export function ProjectSwitcher({ open = true }: { open?: boolean }) {
+  const t = useT();
   const { projects, setActive, addProject, deactivateProject, reorderProjects } = useProjectsStore();
   const boxes = useBoxesStore((s) => s.boxes);
   const createBox = useBoxesStore((s) => s.createBox);
@@ -29,6 +37,7 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
   const deleteBox = useBoxesStore((s) => s.deleteBox);
   const assignToBox = useBoxesStore((s) => s.assignToBox);
   const openBox = useBoxesStore((s) => s.openBox);
+  const openHpcWizard = useHpcPipelineStore((s) => s.openWizard);
   // The currently-displayed scope is the single source of truth for which pill
   // is highlighted (BoxPill keys off it too). Opening a box moves the scope but
   // not `activeId`, so highlighting on `activeId` would leave the previously
@@ -37,9 +46,39 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
   const [showSettings, setShowSettings] = useState(false);
   const [showSettingsMenu, setShowSettingsMenu] = useState(false);
   const [settingsPanel, setSettingsPanel] = useState<SettingsPanelKind>("main");
-  const [ollamaInstalled, setOllamaInstalled] = useState(false);
   const [showAddMenu, setShowAddMenu] = useState(false);
-  const [dialog, setDialog] = useState<"new" | "import" | null>(null);
+  // "clone" is the import dialog opened straight onto its GitHub/GitLab source —
+  // the same dialog, so the source can still be switched back inside it.
+  const [dialog, setDialog] = useState<"new" | "import" | "clone" | null>(null);
+  const settingsMenuRef = useRef<HTMLDivElement>(null);
+  const addMenuRef = useRef<HTMLDivElement>(null);
+  // Hover-opened, like the header's sibling menus (GlobalAppMenu, LocalModelMenu,
+  // VpnIndicator): a short close delay on mouseleave so crossing the gap between
+  // the button and its dropdown doesn't flicker-close it.
+  const settingsCloseTimer = useRef<number | undefined>(undefined);
+  const addCloseTimer = useRef<number | undefined>(undefined);
+
+  const revealSettingsMenu = () => {
+    window.clearTimeout(addCloseTimer.current);
+    setShowAddMenu(false);
+    window.clearTimeout(settingsCloseTimer.current);
+    setShowSettingsMenu(true);
+  };
+  const scheduleCloseSettingsMenu = () => {
+    window.clearTimeout(settingsCloseTimer.current);
+    settingsCloseTimer.current = window.setTimeout(() => setShowSettingsMenu(false), 180);
+  };
+  const revealAddMenu = () => {
+    setShowSettings(false);
+    window.clearTimeout(settingsCloseTimer.current);
+    setShowSettingsMenu(false);
+    window.clearTimeout(addCloseTimer.current);
+    setShowAddMenu(true);
+  };
+  const scheduleCloseAddMenu = () => {
+    window.clearTimeout(addCloseTimer.current);
+    addCloseTimer.current = window.setTimeout(() => setShowAddMenu(false), 180);
+  };
 
   useEffect(() => {
     if (!open) {
@@ -49,11 +88,45 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
       setDialog(null);
     }
   }, [open]);
+
+  // Dismiss the ⚙/+ dropdowns on any pointer press outside their wrap (the
+  // wraps stopPropagation, so the in-bar onClick alone never catches a click
+  // elsewhere in the app) or on Escape. Mirrors common/Dropdown.tsx.
+  useEffect(() => {
+    if (!showSettingsMenu && !showAddMenu) return;
+    const onDocPointer = (e: PointerEvent) => {
+      const target = e.target as Node;
+      if (settingsMenuRef.current?.contains(target)) return;
+      if (addMenuRef.current?.contains(target)) return;
+      setShowSettingsMenu(false);
+      setShowAddMenu(false);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") {
+        setShowSettingsMenu(false);
+        setShowAddMenu(false);
+      }
+    };
+    document.addEventListener("pointerdown", onDocPointer);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("pointerdown", onDocPointer);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [showSettingsMenu, showAddMenu]);
   const pillsScrollRef = useRef<HTMLDivElement>(null);
   const [pillOverflow, setPillOverflow] = useState({ left: false, right: false });
 
+  // Allow other components (e.g. the header's Local Model button) to open the
+  // settings dialog on a specific panel via a window event.
   useEffect(() => {
-    invoke<boolean>("ollama_is_installed").then(setOllamaInstalled).catch(() => {});
+    const onOpenSettings = (e: Event) => {
+      const panel = (e as CustomEvent).detail as SettingsPanelKind | undefined;
+      setSettingsPanel(panel ?? "main");
+      setShowSettings(true);
+    };
+    window.addEventListener("eldrun:open-settings", onOpenSettings);
+    return () => window.removeEventListener("eldrun:open-settings", onOpenSettings);
   }, []);
 
   // Project projection that drives the pill strip. Reduced to just the fields
@@ -65,7 +138,21 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
     () =>
       projects
         .filter((p) => p.status !== "inactive")
-        .map((p) => `${p.id}:${p.position}:${typeof p.box_id === "string" ? p.box_id : ""}`)
+        .map(
+          (p) =>
+            // Include the git-provider axis (explicit `git_provider` and the
+            // async-sniffed `detected_provider`) so a pill's type tags refresh
+            // when `detect_git_providers` fills them in after load — otherwise
+            // the memo pins a stale project object and the hover shows only the
+            // base "git" tag while the right panel (which reads the live store)
+            // shows git + GitHub. Both feed the same `projectTypeTags`; keep
+            // their inputs in sync.
+            `${p.id}:${p.position}:${typeof p.box_id === "string" ? p.box_id : ""}:${
+              typeof p.git_type === "string" ? p.git_type : ""
+            }:${typeof p.git_provider === "string" ? p.git_provider : ""}:${
+              typeof p.detected_provider === "string" ? p.detected_provider : ""
+            }`,
+        )
         .sort()
         .join("|"),
     [projects],
@@ -78,6 +165,34 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [activeProjectsSignature]);
 
+  // Per-pill git "dirty" dots: poll every active local project's git state on a
+  // shared interval (one loop for all pills, deduped by project id) and store
+  // the result in the gitDirty store, where each ProjectPill subscribes to its
+  // own entry. Remote (sshfs) projects are skipped — running git over the mount
+  // is slow. RightPanel also live-updates the active project's dot on edits.
+  const gitDotTargets = useMemo(
+    () =>
+      activeProjects
+        .filter((p) => !p.remote)
+        .map((p) => ({ id: p.id, dir: resolveProjectDirectory(p) }))
+        .filter((t) => !!t.dir),
+    [activeProjects],
+  );
+  const gitDotSignature = useMemo(
+    () => gitDotTargets.map((t) => `${t.id}:${t.dir}`).join("|"),
+    [gitDotTargets],
+  );
+  const energySaver = useEnergySaver();
+  useEffect(() => {
+    if (gitDotTargets.length === 0) return;
+    const refresh = useGitDirtyStore.getState().refresh;
+    const run = () => gitDotTargets.forEach((t) => void refresh(t.id, t.dir));
+    run();
+    const id = window.setInterval(run, saverInterval(12000, energySaver));
+    return () => window.clearInterval(id);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [gitDotSignature, energySaver]);
+
   // Bucket the active pills into boxes (by `box_id`) + an ungrouped remainder,
   // interleaved by switcher position. A pill whose `box_id` points at a missing
   // box (e.g. after a delete the sweep didn't reach) falls back to ungrouped (S1).
@@ -117,6 +232,43 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
     return items.sort((a, b) => a.position - b.position);
   }, [activeProjects, boxes, boxesById]);
 
+  // Pointer-driven pill reorder (stores/pillDrag): every OTHER visible project
+  // pill "parts" to open the dragged one's landing slot — a `shiftPx` per id,
+  // computed here (not in each pill) since it needs the FULL rendered order.
+  // Mirrors MachinesIndicator's row-parting FLIP math, generalized to width:
+  // removing an item of the dragged pill's own width from the strip and
+  // reinserting it elsewhere shifts every OTHER pill between the old and new
+  // slot by exactly that width, regardless of their own widths — so idx
+  // (this pill's index in the full project-only list) vs. fromIdx (the
+  // dragged pill's) and overIndex (the without-self landing index the drag
+  // gesture computed) alone decide the shift; a box-assign or Alt-group
+  // target suppresses it entirely (nothing will actually move).
+  const pillDrag = usePillDragStore((s) => s.drag);
+  const projectItems = useMemo(
+    () =>
+      switcherItems.filter(
+        (it): it is Extract<SwitcherItem, { kind: "project" }> => it.kind === "project",
+      ),
+    [switcherItems],
+  );
+  const pillShifts = useMemo(() => {
+    const shifts = new Map<string, number>();
+    if (!pillDrag || pillDrag.overBoxId || pillDrag.groupTargetId) return shifts;
+    const fromIdx = projectItems.findIndex((it) => it.project.id === pillDrag.id);
+    if (fromIdx < 0) return shifts;
+    projectItems.forEach((it, idx) => {
+      if (idx === fromIdx) return;
+      const shift =
+        idx > fromIdx && idx <= pillDrag.overIndex
+          ? -pillDrag.width
+          : idx < fromIdx && idx >= pillDrag.overIndex
+            ? pillDrag.width
+            : 0;
+      if (shift) shifts.set(it.project.id, shift);
+    });
+    return shifts;
+  }, [pillDrag, projectItems]);
+
   // Signature of the bucketing so the overflow/edge-fade effect re-runs when
   // membership moves between a box and ungrouped (not just on count change) (S3).
   const bucketSignature = useMemo(
@@ -177,11 +329,24 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
   // dragged pill, so both land in the new box; the user renames it via the chip.
   const groupProjects = async (fromId: string, toId: string) => {
     if (fromId === toId) return;
-    const box = await createBox("New Box");
+    const box = await createBox(t("projectSwitcher.newBox"));
     await assignToBox(toId, box.id);
     await assignToBox(fromId, box.id);
   };
 
+  // Empty pill-strip space doubles as a window-drag handle: pressing the bare
+  // strip (where no project pills are) starts a native window move, so the
+  // project bar behaves like titlebar dead-space. Pills/boxes are nested
+  // children, so a press on one lands on it (target !== currentTarget) and is
+  // left alone. Bypasses the header's `.no-drag` by dragging directly. (#dnd)
+  const startWindowDrag = (e: React.MouseEvent) => {
+    // `button` (singular, 0 = left), not `buttons`: WebKitGTK reports
+    // `buttons === 0` on the opening mousedown, which swallowed the drag on Linux.
+    if (e.button !== 0) return;
+    if (e.target !== e.currentTarget) return;
+    getCurrentWindow().startDragging().catch(() => {});
+  };
+
   const scrollPills = (dir: -1 | 1) => {
     const el = pillsScrollRef.current;
     if (!el) return;
@@ -209,6 +374,19 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
   };
   useEffect(() => stopHoverScroll, []);
 
+  /**
+   * Add a just-created/imported project and, for a **remote** one, ask about its
+   * giant folders once. An import in particular can register a folder holding a
+   * `.venv`, a `node_modules` or a data drop, and byte-sync does not read
+   * `.gitignore` — so without this the first sync pass is the moment the user
+   * finds out. The prompt handles the not-yet-connected case itself (it walks
+   * the local side and fills in the host column when the pool comes up).
+   */
+  const addAndAudit = async (project: ProjectEntry) => {
+    await addProject(project);
+    if (project.remote) useBigFoldersStore.getState().openOnce(project.id);
+  };
+
   return (
     <>
       {showSettings && createPortal(
@@ -220,15 +398,16 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
         <ProjectDialog
           kind="new"
           onClose={() => setDialog(null)}
-          onProject={(project) => addProject(project)}
+          onProject={(project) => void addAndAudit(project)}
         />,
         document.body,
       )}
-      {dialog === "import" && createPortal(
+      {(dialog === "import" || dialog === "clone") && createPortal(
         <ProjectDialog
           kind="import"
+          initialImportSource={dialog === "clone" ? "git" : "folder"}
           onClose={() => setDialog(null)}
-          onProject={(project) => addProject(project)}
+          onProject={(project) => void addAndAudit(project)}
         />,
         document.body,
       )}
@@ -244,6 +423,48 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
         // right-click only ever surfaces our own pill context menu.
         onContextMenu={(e) => e.preventDefault()}
       >
+        <div
+          className="project-switcher-add-wrap"
+          ref={settingsMenuRef}
+          onClick={(e) => e.stopPropagation()}
+          onMouseEnter={revealSettingsMenu}
+          onMouseLeave={scheduleCloseSettingsMenu}
+        >
+          <button
+            className="project-switcher-action-btn"
+            data-hint-anchor="settings"
+            title={t("settings.title")}
+            // Hover-opened, like its sibling header menus (GlobalAppMenu,
+            // LocalModelMenu, VpnIndicator). Click reveals rather than toggling: a
+            // click also fires mouseenter, so a toggle here would open on enter and
+            // immediately shut.
+            onClick={revealSettingsMenu}
+            onFocus={revealSettingsMenu}
+          >
+            ⚙
+          </button>
+          {showSettingsMenu && (
+            <div className="project-switcher-add-menu">
+              <button onClick={() => { setShowSettingsMenu(false); setSettingsPanel("main"); setShowSettings(true); }}>
+                {t("settings.title")}
+              </button>
+              <button onClick={() => { setShowSettingsMenu(false); setSettingsPanel("help"); setShowSettings(true); }}>
+                {t("nav.help.title")}
+              </button>
+              <button onClick={() => { setShowSettingsMenu(false); window.dispatchEvent(new Event("eldrun:open-how-to-start")); }}>
+                {t("projectSwitcher.howToStartMenu")}
+              </button>
+              <button onClick={() => { setShowSettingsMenu(false); window.dispatchEvent(new Event("eldrun:start-tour")); }}>
+                {t("settings.takeTour")}
+              </button>
+              <button onClick={() => { setShowSettingsMenu(false); window.dispatchEvent(new Event("eldrun:open-lessons")); }}>
+                {t("settings.lessons")}
+              </button>
+            </div>
+          )}
+        </div>
+        <div className="project-switcher-separator" />
+
         <ProjectSearch
           projects={projects}
           boxes={boxes}
@@ -261,7 +482,7 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
             type="button"
             className="pills-scroll-btn left"
             tabIndex={-1}
-            aria-label="Scroll projects left"
+            aria-label={t("projectSwitcher.scrollLeft")}
             onMouseEnter={() => startHoverScroll(-1)}
             onMouseLeave={stopHoverScroll}
             onClick={(e) => {
@@ -274,20 +495,9 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
           <div
             className="project-pills-scroll"
             ref={pillsScrollRef}
-            // Ungrouped drop zone (S4): dropping a pill on the bare strip (not on
-            // a pill or a BoxPill, both of which stopPropagation) ungroups it.
-            onDragOver={(e) => {
-              if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-              e.preventDefault();
-              e.dataTransfer.dropEffect = "move";
-            }}
-            onDrop={(e) => {
-              if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-              const fromId = e.dataTransfer.getData(PILL_DRAG_TYPE);
-              if (!fromId) return;
-              e.preventDefault();
-              void assignToBox(fromId, null);
-            }}
+            // Pressing the bare strip (no pill under the cursor) drags the
+            // window; pills/boxes are nested so their press is left untouched.
+            onMouseDown={startWindowDrag}
           >
             {switcherItems.map((item) =>
               item.kind === "box" ? (
@@ -296,11 +506,11 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
                   box={item.box}
                   members={item.members}
                   onOpen={() => void openBox(item.box.id)}
-                  onAssign={(projectId) => void assignToBox(projectId, item.box.id)}
                   onSelectMember={(projectId) => void setActive(projectId)}
                   onRemoveMember={(projectId) => void assignToBox(projectId, null)}
                   onRename={(name) => void renameBox(item.box.id, name)}
                   onDelete={() => void deleteBox(item.box.id)}
+                  forcedDragOver={pillDrag?.overBoxId === item.box.id}
                 />
               ) : (
                 <ProjectPill
@@ -311,6 +521,11 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
                   onClose={() => deactivateProject(item.project.id)}
                   onReorder={(fromId, toId) => void reorderProjects(fromId, toId)}
                   onGroup={(fromId, toId) => void groupProjects(fromId, toId)}
+                  onAssignToBox={(boxId) => void assignToBox(item.project.id, boxId)}
+                  isDragged={pillDrag?.id === item.project.id}
+                  dragDx={pillDrag?.id === item.project.id ? pillDrag.dx : undefined}
+                  shiftPx={pillShifts.get(item.project.id)}
+                  groupHintActive={pillDrag?.groupTargetId === item.project.id}
                 />
               ),
             )}
@@ -319,7 +534,7 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
             type="button"
             className="pills-scroll-btn right"
             tabIndex={-1}
-            aria-label="Scroll projects right"
+            aria-label={t("projectSwitcher.scrollRight")}
             onMouseEnter={() => startHoverScroll(1)}
             onMouseLeave={stopHoverScroll}
             onClick={(e) => {
@@ -332,61 +547,54 @@ export function ProjectSwitcher({ open = true }: { open?: boolean }) {
         </div>
         <div className="project-switcher-separator" />
 
-        <div className="project-switcher-add-wrap" onClick={(e) => e.stopPropagation()}>
-          <button
-            className="project-switcher-action-btn"
-            title="Settings"
-            onClick={() => {
-              setShowAddMenu(false);
-              setShowSettingsMenu((v) => !v);
-            }}
-          >
-            ⚙
-          </button>
-          {showSettingsMenu && (
-            <div className="project-switcher-add-menu">
-              <button onClick={() => { setShowSettingsMenu(false); setSettingsPanel("main"); setShowSettings(true); }}>
-                Settings
-              </button>
-              {ollamaInstalled && (
-                <button onClick={() => { setShowSettingsMenu(false); setSettingsPanel("ollama"); setShowSettings(true); }}>
-                  Ollama Models
-                </button>
-              )}
-              <button onClick={() => { setShowSettingsMenu(false); setSettingsPanel("help"); setShowSettings(true); }}>
-                Feature Guide
-              </button>
-            </div>
-          )}
-        </div>
-
-
-        <div className="project-switcher-add-wrap" onClick={(e) => e.stopPropagation()}>
+        <div
+          className="project-switcher-add-wrap"
+          ref={addMenuRef}
+          onClick={(e) => e.stopPropagation()}
+          onMouseEnter={revealAddMenu}
+          onMouseLeave={scheduleCloseAddMenu}
+        >
           <button
             className="project-switcher-add-btn"
-            title="Add or import project"
-            onClick={() => {
-              setShowSettings(false);
-              setShowAddMenu((v) => !v);
-            }}
+            data-hint-anchor="add-project"
+            title={t("projectSwitcher.addOrImport")}
+            // Hover-opened, like its sibling header menus (GlobalAppMenu,
+            // LocalModelMenu, VpnIndicator). Click reveals rather than toggling: a
+            // click also fires mouseenter, so a toggle here would open on enter and
+            // immediately shut.
+            onClick={revealAddMenu}
+            onFocus={revealAddMenu}
           >
             +
           </button>
           {showAddMenu && (
             <div className="project-switcher-add-menu">
               <button onClick={() => { setShowAddMenu(false); setDialog("new"); }}>
-                New Project
+                {t("projectSwitcher.newProject")}
               </button>
               <button onClick={() => { setShowAddMenu(false); setDialog("import"); }}>
-                Import Project
+                {t("projectSwitcher.importProject")}
+              </button>
+              <button
+                className="untested"
+                onClick={() => { setShowAddMenu(false); setDialog("clone"); }}
+              >
+                {t("projectSwitcher.importFromGitHub")} <UntestedTag />
+              </button>
+              <button
+                className="untested"
+                onClick={() => { setShowAddMenu(false); openHpcWizard(); }}
+              >
+                {t("projectSwitcher.hpcPipeline")} <UntestedTag />
               </button>
               <button
+                className="untested"
                 onClick={() => {
                   setShowAddMenu(false);
-                  void createBox("New Box");
+                  void createBox(t("projectSwitcher.newBox"));
                 }}
               >
-                New Box
+                {t("projectSwitcher.newBox")} <UntestedTag />
               </button>
             </div>
           )}
diff --git a/src/components/layout/RemoteFeaturesPrompt.tsx b/src/components/layout/RemoteFeaturesPrompt.tsx
new file mode 100644
index 0000000..dfa007a
--- /dev/null
+++ b/src/components/layout/RemoteFeaturesPrompt.tsx
@@ -0,0 +1,70 @@
+import { useEffect, useState } from "react";
+import { Toggle } from "../common/Toggle";
+import { useSettingsStore } from "../../stores/settings";
+import { useT } from "../../lib/i18n";
+
+/**
+ * First-run ask for the two machine-wide remote surfaces that live in the
+ * header — OpenVPN tunnel control and the global SSH machines list. Both
+ * default OFF (most projects are local-only), so this is what lets someone
+ * who *does* use them opt in once instead of discovering the toggles buried
+ * in Settings. Shown once (`Settings.remote_features_prompted`, marked seen
+ * by the caller before this ever mounts); re-toggleable any time from
+ * Settings' main panel. Reuses the `.modal-backdrop` + `.settings-dialog`
+ * chrome, like `HowToStart`.
+ */
+export function RemoteFeaturesPrompt({ onClose }: { onClose: () => void }) {
+  const t = useT();
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+  const [vpn, setVpn] = useState(false);
+  const [machines, setMachines] = useState(false);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") finish();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const finish = () => {
+    void updateSettings({ vpn_enabled: vpn, machines_enabled: machines });
+    onClose();
+  };
+
+  return (
+    <div className="modal-backdrop" onMouseDown={finish}>
+      <div
+        className="settings-dialog remote-features-prompt-dialog"
+        role="dialog"
+        aria-modal="true"
+        aria-label={t("settings.remoteFeatures")}
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{t("remoteFeatures.title")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={finish}>×</button>
+        </div>
+        <p className="settings-help">{t("remoteFeatures.help")}</p>
+
+        <div className="settings-toggle-card">
+          <label className="settings-toggle-card-row">
+            <span>{t("settings.vpnEnabled")}</span>
+            <Toggle checked={vpn} onChange={(e) => setVpn(e.target.checked)} />
+          </label>
+          <label className="settings-toggle-card-row">
+            <span>{t("settings.machinesEnabled")}</span>
+            <Toggle checked={machines} onChange={(e) => setMachines(e.target.checked)} />
+          </label>
+        </div>
+
+        <div className="settings-link-row">
+          <button type="button" className="how-to-start-got-it" onClick={finish}>
+            {t("remoteFeatures.continue")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/layout/RightPanel.tsx b/src/components/layout/RightPanel.tsx
index fb1e2b3..a67983a 100644
--- a/src/components/layout/RightPanel.tsx
+++ b/src/components/layout/RightPanel.tsx
@@ -1,727 +1,278 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { createPortal } from "react-dom";
-import { invoke } from "@tauri-apps/api/core";
-import { FileTree } from "../files/FileTree";
-import { GitHistory } from "../files/GitHistory";
+import { useMemo, useState } from "react";
+import { ProjectFilesView } from "../files/ProjectFilesView";
+import { useFileSource } from "../files/ProjectFilesPane";
+import { openProjectFilesTab } from "../files/ProjectFilesTab";
 import { useProjectsStore } from "../../stores/projects";
-import { useWindowsStore } from "../../stores/windows";
-import { useSettingsStore } from "../../stores/settings";
-import { useTabsStore } from "../../stores/tabs";
-import { BOX_SCOPE_PREFIX, boxScopeId, useBoxesStore } from "../../stores/boxes";
+import { useTabsStore, orderedTabKeys, isPtyTabKind, type TabEntry } from "../../stores/tabs";
+import { useActivityStore, type AttentionKind } from "../../stores/activity";
 import { resolveProjectDirectory } from "../../types";
-import { type SortKey, VIEWER_PREF_TYPES } from "../../lib/viewers/fileUtils";
-import type { ViewerPref } from "../../types";
-
-interface GitStatus {
-  staged: number;
-  unstaged: number;
-  untracked: number;
-  has_remote: boolean;
-  is_repo: boolean;
-}
+import { useT } from "../../lib/i18n";
 
 interface Props {
   open: boolean;
   pinned?: boolean;
+  /** Which edge the panel docks against; drives the mirrored slide/border/resize
+   *  layout via the `.left` class. Defaults to "right". */
+  side?: "left" | "right";
+  /** Current panel width in px (driven by the left-border resize drag). */
+  width?: number;
+  /** True while a resize drag is in progress — suppresses width/transform
+   *  transitions so the panel tracks the cursor instead of lagging behind. */
+  resizing?: boolean;
+  onResizeStart?: (e: React.PointerEvent<HTMLDivElement>) => void;
+  onResizeMove?: (e: React.PointerEvent<HTMLDivElement>) => void;
+  onResizeEnd?: (e: React.PointerEvent<HTMLDivElement>) => void;
   onTogglePin?: () => void;
+  onToggleSide?: () => void;
   onMouseEnter?: () => void;
   onMouseLeave?: () => void;
 }
 
-type View = "files" | "windows" | "git";
-type ProjectJson = Record<string, unknown>;
-
-const PANEL_HIDDEN_ENDINGS_KEY = "panel_hidden_endings";
-const PANEL_HIDDEN_PATHS_KEY = "panel_hidden_paths";
-const PANEL_SHOWN_PATHS_KEY = "panel_shown_paths";
-
-function readHiddenEndings(project: ProjectJson | null): string[] {
-  return readStringList(project, PANEL_HIDDEN_ENDINGS_KEY);
-}
-
-function readHiddenPaths(project: ProjectJson | null): string[] {
-  return readStringList(project, PANEL_HIDDEN_PATHS_KEY);
-}
-
-function readShownPaths(project: ProjectJson | null): string[] {
-  return readStringList(project, PANEL_SHOWN_PATHS_KEY);
-}
-
-function readStringList(project: ProjectJson | null, key: string): string[] {
-  const raw = project?.[key];
-  if (!Array.isArray(raw)) return [];
-  return raw.filter((item): item is string => typeof item === "string");
-}
-
-function mergeEndings(...groups: string[][]): string[] {
-  const endings = new Map<string, string>();
-  for (const group of groups) {
-    for (const ending of group) {
-      const trimmed = ending.trim();
-      if (!trimmed) continue;
-      endings.set(trimmed.toLowerCase(), trimmed);
-    }
+/** A hidden subwindow's tab is invisible to the tab bar, so it can't paint its
+ *  own glow — this is the same working/needs-decision/finished precedence
+ *  `TabBar` uses for the live tab glow, applied here to a hidden group's tab
+ *  chips (and rolled up for the group's row) so a hidden pane doesn't go dark
+ *  just because it's parked. */
+function hiddenTabStatus(
+  kind: TabEntry["kind"] | undefined,
+  ptyId: string,
+  busyByTab: Record<string, boolean>,
+  attentionByTab: Record<string, AttentionKind>,
+): "working" | "needs-decision" | "finished" | null {
+  if (!kind) return null;
+  if (isPtyTabKind(kind) && busyByTab[ptyId]) return "working";
+  if (kind === "agent" || kind === "local_agent") {
+    const attn = attentionByTab[ptyId];
+    if (attn === "decision") return "needs-decision";
+    if (attn === "done") return "finished";
   }
-  return [...endings.values()].sort((a, b) => a.localeCompare(b));
+  return null;
 }
 
-/** One collapsible root inside the box multi-root file view. Reuses `FileTree`
- *  as-is for a single directory; per-root navigation persists via the projects
- *  store's `rightPanelFolderByProject` map keyed by the root's id. */
-function BoxRootSection({
-  rootId,
-  label,
-  icon,
-  dir,
-  localFile,
-  variant,
-  sortKey,
-  descending,
-}: {
-  rootId: string;
-  label: string;
-  icon: string;
-  dir: string;
-  localFile?: string;
-  variant: "box" | "member";
-  sortKey: SortKey;
-  descending: boolean;
-}) {
-  const [collapsed, setCollapsed] = useState(false);
-  const rel = useProjectsStore((s) => s.rightPanelFolderByProject[rootId] ?? "");
-  const setRightPanelFolder = useProjectsStore((s) => s.setRightPanelFolder);
-  return (
-    <div className={`file-root file-root--${variant}${collapsed ? " is-collapsed" : ""}`}>
-      <button
-        type="button"
-        className="file-root-header"
-        onClick={() => setCollapsed((c) => !c)}
-        title={dir}
-      >
-        <span className="file-root-caret" aria-hidden>
-          {collapsed ? "▸" : "▾"}
-        </span>
-        <span className="file-root-icon" aria-hidden>
-          {icon}
-        </span>
-        <span className="file-root-name">{label}</span>
-        <span className="file-root-kind">{variant === "box" ? "box" : "project"}</span>
-      </button>
-      {!collapsed && (
-        <div className="file-root-body">
-          <FileTree
-            projectDir={dir}
-            projectId={rootId}
-            localFile={localFile}
-            sortKey={sortKey}
-            descending={descending}
-            hiddenEndings={[]}
-            hiddenPaths={[]}
-            shownPaths={[]}
-            initialRelPath={rel}
-            onRelPathChange={(folder) => setRightPanelFolder(rootId, folder)}
-          />
-        </div>
-      )}
-    </div>
-  );
+/** Roll several tab statuses up into one, most urgent first — a decision still
+ *  waiting on the user outranks a tab merely working, which outranks one that's
+ *  just finished unseen. Mirrors `attentionByScope`'s decision-over-done
+ *  precedence, extended with `working` for the row-level dot. */
+function rollUpStatus(
+  statuses: Array<"working" | "needs-decision" | "finished" | null>,
+): "working" | "needs-decision" | "finished" | null {
+  if (statuses.includes("needs-decision")) return "needs-decision";
+  if (statuses.includes("working")) return "working";
+  if (statuses.includes("finished")) return "finished";
+  return null;
 }
 
-export function RightPanel({ open, pinned, onTogglePin, onMouseEnter, onMouseLeave }: Props) {
+/**
+ * The file-tree overlay panel. Its file *viewer* — the view switcher, git bar +
+ * history, search, apps, orange list, type tags, source switch and settings — is
+ * the shared `ProjectFilesView`, the same component the Files (Project) tab
+ * renders, so the two can never drift. This host owns only what is panel-specific:
+ * the active-project identity it forwards, the browsed-folder in the projects
+ * store, and the three window-chrome fragments (pin, resize border, the "Hidden
+ * subwindows" list) it injects as slots — none of which a tab has.
+ */
+export function RightPanel({
+  open,
+  pinned,
+  side = "right",
+  width,
+  resizing,
+  onResizeStart,
+  onResizeMove,
+  onResizeEnd,
+  onTogglePin,
+  onToggleSide,
+  onMouseEnter,
+  onMouseLeave,
+}: Props) {
+  const t = useT();
   const { projects, activeId } = useProjectsStore();
   const rightPanelFolderByProject = useProjectsStore((s) => s.rightPanelFolderByProject);
   const setRightPanelFolder = useProjectsStore((s) => s.setRightPanelFolder);
-  const { windows, refresh, untrack } = useWindowsStore();
-  const settings = useSettingsStore((s) => s.settings);
-  const updateSettings = useSettingsStore((s) => s.updateSettings);
-  const [view, setView] = useState<View>("files");
-  const [showSettings, setShowSettings] = useState(false);
-  const [sortKey, setSortKey] = useState<SortKey>("name");
-  const [descending, setDescending] = useState(false);
-  const [localProjectSettings, setLocalProjectSettings] = useState<ProjectJson | null>(null);
-  const [hiddenEndings, setHiddenEndings] = useState<string[]>([]);
-  const [availableEndings, setAvailableEndings] = useState<string[]>([]);
-  const [hiddenPaths, setHiddenPaths] = useState<string[]>([]);
-  const [shownPaths, setShownPaths] = useState<string[]>([]);
-  const [settingsError, setSettingsError] = useState<string | null>(null);
-
-  const [gitStatus, setGitStatus] = useState<GitStatus | null>(null);
-  const [gitFileList, setGitFileList] = useState<Record<string, string>>({});
-  const [unpushedCommits, setUnpushedCommits] = useState<string[]>([]);
-  const [hoveredBtn, setHoveredBtn] = useState<"add" | "commit" | "push" | null>(null);
-  const [commitMsg, setCommitMsg] = useState<string | null>(null);
-  const [gitBusy, setGitBusy] = useState(false);
-  const [gitError, setGitError] = useState<string | null>(null);
-  const commitRef = useRef<HTMLTextAreaElement>(null);
-  const refreshGitTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-  // Run all three git probes concurrently (Eff #9): they hit independent
-  // subprocesses, so `Promise.all` collapses three serially-awaited chains into
-  // one round of parallel work. Each result still applies independently.
-  const runRefreshGit = (dir: string) => {
-    void Promise.all([
-      invoke<GitStatus>("git_status", { projectDir: dir })
-        .then(setGitStatus)
-        .catch(() => setGitStatus(null)),
-      invoke<Record<string, string>>("git_file_statuses", { projectDir: dir, relPath: "" })
-        .then(setGitFileList)
-        .catch(() => setGitFileList({})),
-      invoke<string[]>("git_unpushed_commits", { projectDir: dir })
-        .then(setUnpushedCommits)
-        .catch(() => setUnpushedCommits([])),
-    ]);
-  };
-
-  // Debounced entry point (Eff #9): bursts of git-affecting actions (add →
-  // commit → push, or rapid fs changes) coalesce into a single refresh instead
-  // of spawning a fresh trio of subprocesses per call.
-  const refreshGit = (dir: string) => {
-    if (refreshGitTimer.current) clearTimeout(refreshGitTimer.current);
-    refreshGitTimer.current = setTimeout(() => {
-      refreshGitTimer.current = null;
-      runRefreshGit(dir);
-    }, 120);
-  };
 
-  useEffect(() => {
-    return () => {
-      if (refreshGitTimer.current) clearTimeout(refreshGitTimer.current);
-    };
-  }, []);
-
-  const hoverItems: string[] =
-    hoveredBtn === "add"
-      ? Object.entries(gitFileList).filter(([, s]) => s === "untracked" || s === "modified").map(([f]) => f)
-      : hoveredBtn === "commit"
-      ? Object.entries(gitFileList).filter(([, s]) => s === "staged").map(([f]) => f)
-      : hoveredBtn === "push"
-      ? unpushedCommits
-      : [];
-
-  const activeProject = projects.find((p) => p.id === activeId);
+  const activeProject = projects.find((p) => p.id === activeId) ?? null;
   const projectDir = resolveProjectDirectory(activeProject);
-  const localFile = activeProject?.local_file;
+  // SSH-sync Phase 1: which side of a remote project the files view shows — the
+  // host (remote, SFTP-listed, with the sync overlay) or the local mirror.
+  const [fileSource, setFileSource] = useFileSource(activeId, !!activeProject?.remote);
   const rightPanelFolder = activeId ? rightPanelFolderByProject[activeId] ?? "" : "";
 
-  // When a box scope is open, the panel shows a multi-root file view: the box
-  // folder plus every member project's root. Detected from the current tab scope
-  // (disjoint `box:<id>` prefix) rather than the project store's activeId.
+  // When a box scope is open, the shared view shows a multi-root file view. It
+  // derives that from the current tab scope, which the panel forwards.
   const scope = useTabsStore((s) => s.scope);
-  const boxes = useBoxesStore((s) => s.boxes);
-  const activeBox = useMemo(
-    () =>
-      scope.startsWith(BOX_SCOPE_PREFIX)
-        ? boxes.find((b) => boxScopeId(b.id) === scope) ?? null
-        : null,
-    [scope, boxes],
-  );
-  const boxRoots = useMemo(() => {
-    if (!activeBox) return [];
-    const roots: {
-      rootId: string;
-      label: string;
-      icon: string;
-      dir: string;
-      localFile?: string;
-      variant: "box" | "member";
-    }[] = [];
-    if (activeBox.folder) {
-      roots.push({ rootId: scope, label: activeBox.name, icon: "▣", dir: activeBox.folder, variant: "box" });
-    }
-    for (const id of activeBox.member_ids) {
-      const p = projects.find((m) => m.id === id);
-      if (!p) continue;
-      const dir = resolveProjectDirectory(p);
-      if (!dir) continue;
-      roots.push({ rootId: p.id, label: p.name, icon: "📁", dir, localFile: p.local_file, variant: "member" });
-    }
-    return roots;
-  }, [activeBox, projects, scope]);
-
-  const openInOsBrowser = () => {
-    if (!projectDir) return;
-    const sub = rightPanelFolder.replace(/^\/+|\/+$/g, "");
-    const path = sub ? `${projectDir.replace(/\/+$/, "")}/${sub}` : projectDir;
-    invoke("open_in_file_manager", { path }).catch((e) => console.error("open_in_file_manager", e));
-  };
-
-  useEffect(() => {
-    if (open && activeId) {
-      refresh(activeId);
-    }
-  }, [open, activeId]);
-
-  useEffect(() => {
-    if (open && projectDir) {
-      refreshGit(projectDir);
-    } else {
-      setGitStatus(null);
-    }
-  }, [open, projectDir]);
-
-  useEffect(() => {
-    setShowSettings(false);
-    setSettingsError(null);
-    if (!localFile || !projectDir) {
-      setLocalProjectSettings(null);
-      setHiddenEndings([]);
-      setAvailableEndings([]);
-      setHiddenPaths([]);
-      setShownPaths([]);
-      return;
-    }
-    Promise.all([
-      invoke<ProjectJson>("load_project", { localFile }),
-      invoke<string[]>("list_project_endings", { projectDir }).catch(() => []),
-    ])
-      .then(([project, endings]) => {
-        const savedHiddenEndings = readHiddenEndings(project);
-        const savedHiddenPaths = readHiddenPaths(project);
-        const savedShownPaths = readShownPaths(project);
-        const allEndings = mergeEndings(endings, savedHiddenEndings);
-        setLocalProjectSettings(project);
-        setHiddenEndings(savedHiddenEndings);
-        setAvailableEndings(allEndings);
-        setHiddenPaths(savedHiddenPaths);
-        setShownPaths(savedShownPaths);
-      })
-      .catch((error) => {
-        setLocalProjectSettings(null);
-        setHiddenEndings([]);
-        setAvailableEndings([]);
-        setHiddenPaths([]);
-        setShownPaths([]);
-        setSettingsError(String(error));
-      });
-  }, [localFile, projectDir]);
-
-  const handleAdd = async () => {
-    if (!projectDir) return;
-    setGitBusy(true);
-    setGitError(null);
-    try {
-      await invoke("git_add_all", { projectDir });
-      refreshGit(projectDir);
-    } catch (e) {
-      setGitError(String(e));
-    } finally {
-      setGitBusy(false);
-    }
-  };
-
-  const handleCommitOpen = async () => {
-    if (!projectDir) return;
-    setGitBusy(true);
-    setGitError(null);
-    try {
-      const msg = await invoke<string>("git_generate_commit_message", { projectDir });
-      setCommitMsg(msg);
-      setTimeout(() => commitRef.current?.focus(), 50);
-    } catch (e) {
-      setGitError(String(e));
-    } finally {
-      setGitBusy(false);
-    }
-  };
-
-  const handleCommitConfirm = async () => {
-    if (!projectDir || commitMsg === null) return;
-    setGitBusy(true);
-    setGitError(null);
-    try {
-      await invoke("git_commit", { projectDir, message: commitMsg });
-      setCommitMsg(null);
-      refreshGit(projectDir);
-    } catch (e) {
-      setGitError(String(e));
-    } finally {
-      setGitBusy(false);
-    }
-  };
-
-  const handlePush = async () => {
-    if (!projectDir) return;
-    setGitBusy(true);
-    setGitError(null);
-    try {
-      await invoke("git_push", { projectDir });
-      refreshGit(projectDir);
-    } catch (e) {
-      setGitError(String(e));
-    } finally {
-      setGitBusy(false);
-    }
-  };
-
-  const saveHiddenEndings = async (nextEndings: string[]) => {
-    if (!localFile || !localProjectSettings) return;
-    const nextProject = {
-      ...localProjectSettings,
-      [PANEL_HIDDEN_ENDINGS_KEY]: nextEndings,
-      [PANEL_HIDDEN_PATHS_KEY]: hiddenPaths,
-      [PANEL_SHOWN_PATHS_KEY]: shownPaths,
-    };
-    setHiddenEndings(nextEndings);
-    setLocalProjectSettings(nextProject);
-    setSettingsError(null);
-    try {
-      await invoke("save_project", { localFile, project: nextProject });
-    } catch (e) {
-      setSettingsError(String(e));
-    }
-  };
-
-  const toggleHiddenEnding = (ending: string, checked: boolean) => {
-    const existing = new Set(hiddenEndings.map((item) => item.toLowerCase()));
-    const nextEndings = checked
-      ? existing.has(ending.toLowerCase())
-        ? hiddenEndings
-        : [...hiddenEndings, ending]
-      : hiddenEndings.filter((item) => item.toLowerCase() !== ending.toLowerCase());
-    void saveHiddenEndings(nextEndings);
-  };
-
-  return (
+  // Subwindows the user has hidden in the current scope, surfaced as an
+  // auto-pinned section above the toolbar. Their tabs still live in
+  // `tabsByScope[scope]` (PTYs mounted, hidden), so the chips resolve labels
+  // from there. `unhideGroup`/`closeHiddenGroup` restore or discard them.
+  const hiddenGroups = useTabsStore((s) => s.hiddenGroupsByScope[s.scope]);
+  const scopeTabs = useTabsStore((s) => s.tabsByScope[s.scope]);
+  // Same working/decision/finished glow the tab bar draws for a live tab — a
+  // hidden subwindow's tabs are still running underneath the pane, so they keep
+  // reporting status even while parked.
+  const busyByTab = useActivityStore((s) => s.busyByTab);
+  const attentionByTab = useActivityStore((s) => s.attentionByTab);
+  // One status per hidden group's tab, rolled up per group and overall, so the
+  // Hidden section still says "something's running in there" without needing
+  // the group unhidden and its tab bar drawn.
+  const hiddenStatus = useMemo(() => {
+    const rows = (hiddenGroups ?? []).map((h) => {
+      const tabStatuses = orderedTabKeys(h.subtree).map((k) =>
+        hiddenTabStatus(
+          scopeTabs?.find((t) => t.key === k)?.kind,
+          `${scope}:${k}`,
+          busyByTab,
+          attentionByTab,
+        ),
+      );
+      return { id: h.id, status: rollUpStatus(tabStatuses), tabStatuses };
+    });
+    return { rows, overall: rollUpStatus(rows.map((r) => r.status)) };
+  }, [hiddenGroups, scopeTabs, scope, busyByTab, attentionByTab]);
+  const unhideGroup = useTabsStore((s) => s.unhideGroup);
+  const closeHiddenGroup = useTabsStore((s) => s.closeHiddenGroup);
+  const [hiddenCollapsed, setHiddenCollapsed] = useState(false);
+
+  // Drag the left border to resize the panel; width persists in settings.
+  // Pointer capture (set in onResizeStart) keeps the drag alive once the cursor
+  // leaves this thin strip.
+  const resizeHandle = onResizeStart ? (
     <div
-      className={`right-panel ${open ? "open" : ""}`}
-      onMouseEnter={onMouseEnter}
-      onMouseLeave={onMouseLeave}
-    >
-      <div className="right-panel-header">
+      className="right-panel-resize"
+      onPointerDown={onResizeStart}
+      onPointerMove={onResizeMove}
+      onPointerUp={onResizeEnd}
+      title={t("rightPanel.resizeTitle")}
+      aria-hidden
+    />
+  ) : null;
+
+  // The panel header's left-edge chrome: a side-flip toggle and the pin. Both ride
+  // the single `pin` slot ProjectFilesView exposes (a tab passes neither), so no
+  // extra slot is threaded through the shared viewer.
+  const chrome =
+    onTogglePin || onToggleSide ? (
+      <>
+        {onToggleSide && (
+          <button
+            className="right-panel-pin right-panel-flip"
+            onClick={onToggleSide}
+            title={t(side === "left" ? "rightPanel.moveRight" : "rightPanel.moveLeft")}
+            aria-label={t(side === "left" ? "rightPanel.moveRight" : "rightPanel.moveLeft")}
+          >
+            ⇄
+          </button>
+        )}
         {onTogglePin && (
           <button
             className={`right-panel-pin${pinned ? " pinned" : ""}`}
             aria-pressed={pinned}
             onClick={onTogglePin}
-            title={pinned ? "Unpin panel (allow auto-hide)" : "Pin panel open"}
+            title={t(pinned ? "rightPanel.unpinTitle" : "rightPanel.pinTitle")}
           >
             📌
           </button>
         )}
-        <span style={{ flex: 1 }}>
-          {activeBox ? `▣ ${activeBox.name}` : activeProject ? activeProject.name : "Files"}
-        </span>
-        {(["files", "git", "windows"] as View[]).map((v) => (
-          <button
-            key={v}
-            className={`tab-add-btn${view === v ? " active" : ""}`}
-            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: v === "files" ? 0 : 2 }}
-            aria-pressed={view === v}
-            onClick={() => setView(v)}
-          >
-            {v === "files" ? "Files" : v === "git" ? "Git" : "Apps"}
-          </button>
-        ))}
-        {projectDir && (
-          <button
-            className="tab-add-btn"
-            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
-            onClick={openInOsBrowser}
-            title="Open folder in file manager"
-          >
-            ⧉
-          </button>
-        )}
-        {activeId && (
-          <button
-            className="tab-add-btn"
-            style={{ fontSize: 10, padding: "1px 6px", height: 20, marginLeft: 2 }}
-            onClick={() => setShowSettings(true)}
-            title="Project settings"
-          >
-            ⚙
-          </button>
-        )}
-      </div>
-
-      {!activeBox && gitStatus?.is_repo && view === "files" && (
-        <>
-          <div className="git-action-bar" style={{ position: "relative" }} onMouseLeave={() => setHoveredBtn(null)}>
-            {commitMsg !== null ? (
-              <>
-                <button
-                  className="git-action-btn"
-                  disabled={gitBusy}
-                  onClick={handleCommitConfirm}
-                  title="Confirm commit"
-                  onMouseEnter={() => setHoveredBtn("commit")}
-                >
-                  <span data-testid="commit-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#e3b341" }} />
-                  <span>↵</span>
-                  <span className="git-btn-label">Confirm</span>
-                </button>
-                <button
-                  className="git-action-btn"
-                  disabled={gitBusy}
-                  onClick={() => setCommitMsg(null)}
-                  title="Go back"
-                >
-                  <span>←</span>
-                  <span className="git-btn-label">Back</span>
-                </button>
-              </>
-            ) : (
-              <>
-                <button
-                  className="git-action-btn"
-                  disabled={gitBusy}
-                  onClick={handleAdd}
-                  title={`Stage all changes (${gitStatus.unstaged + gitStatus.untracked} unstaged)`}
-                  onMouseEnter={() => setHoveredBtn("add")}
-                >
-                  <span data-testid="add-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#f85149" }} />
-                  <span>⊕</span>
-                  <span className="git-btn-label">Add{gitStatus.unstaged + gitStatus.untracked > 0 ? ` (${gitStatus.unstaged + gitStatus.untracked})` : ""}</span>
-                </button>
-                <button
-                  className="git-action-btn"
-                  disabled={gitBusy || gitStatus.staged === 0}
-                  onClick={handleCommitOpen}
-                  title={gitStatus.staged === 0 ? "No staged changes" : `Commit ${gitStatus.staged} staged`}
-                  onMouseEnter={() => setHoveredBtn("commit")}
-                >
-                  <span data-testid="commit-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#e3b341" }} />
-                  <span>✔</span>
-                  <span className="git-btn-label">Commit{gitStatus.staged > 0 ? ` (${gitStatus.staged})` : ""}</span>
-                </button>
-                {gitStatus.has_remote && (
+      </>
+    ) : null;
+
+  const hidden =
+    hiddenGroups && hiddenGroups.length > 0 ? (
+      <div className="hidden-subwindows">
+        <button
+          type="button"
+          className="hidden-sw-header"
+          onClick={() => setHiddenCollapsed((c) => !c)}
+          title={t(hiddenCollapsed ? "rightPanel.showHidden" : "rightPanel.collapse")}
+        >
+          <span className="hidden-sw-caret">{hiddenCollapsed ? "▸" : "▾"}</span>
+          {t("rightPanel.hiddenCount", { count: hiddenGroups.length })}
+          {hiddenStatus.overall && (
+            <span
+              className={`hidden-sw-status-dot ${hiddenStatus.overall}`}
+              title={t(
+                hiddenStatus.overall === "needs-decision"
+                  ? "rightPanel.hiddenWaiting"
+                  : hiddenStatus.overall === "working"
+                    ? "rightPanel.hiddenWorking"
+                    : "rightPanel.hiddenFinished",
+              )}
+            />
+          )}
+        </button>
+        {!hiddenCollapsed && (
+          <div className="hidden-sw-list">
+            {hiddenGroups.map((h, hi) => {
+              const keys = orderedTabKeys(h.subtree);
+              const { status: rowStatus, tabStatuses } = hiddenStatus.rows[hi];
+              return (
+                <div key={h.id} className="hidden-sw-row">
+                  <span className={`hidden-sw-icon${rowStatus ? ` ${rowStatus}` : ""}`}>⊞</span>
+                  <div className="hidden-sw-chips">
+                    {keys.map((k, ki) => {
+                      const label = scopeTabs?.find((t) => t.key === k)?.label ?? k;
+                      const status = tabStatuses[ki];
+                      return (
+                        <button
+                          key={k}
+                          type="button"
+                          className={`hidden-sw-chip${status ? ` ${status}` : ""}`}
+                          title={t("rightPanel.restoreFocusedOn", { label })}
+                          onClick={() => unhideGroup(h.id, { activeKey: k })}
+                        >
+                          {label}
+                        </button>
+                      );
+                    })}
+                  </div>
                   <button
-                    className="git-action-btn"
-                    disabled={gitBusy}
-                    onClick={handlePush}
-                    title="Push to remote"
-                    onMouseEnter={() => setHoveredBtn("push")}
+                    type="button"
+                    className="hidden-sw-btn"
+                    title={t("rightPanel.restoreSubwindow")}
+                    onClick={() => unhideGroup(h.id)}
                   >
-                    <span data-testid="push-bar" style={{ width: 7, height: 7, borderRadius: "50%", marginRight: 5, flexShrink: 0, background: "#3fb950" }} />
-                    <span>⬆</span>
-                    <span className="git-btn-label">Push</span>
+                    ↩
                   </button>
-                )}
-                {hoveredBtn && hoverItems.length > 0 && (
-                  <div className="git-hover-list" data-testid="git-hover-list">
-                    {hoverItems.map((item, i) => (
-                      <div key={i} className="git-hover-item">{item}</div>
-                    ))}
-                  </div>
-                )}
-              </>
-            )}
-          </div>
-          {commitMsg !== null && (
-            <div style={{ padding: "4px 6px", borderBottom: "1px solid var(--border-color)" }}>
-              <textarea
-                ref={commitRef}
-                value={commitMsg}
-                onChange={(e) => setCommitMsg(e.target.value)}
-                rows={3}
-                style={{
-                  width: "100%",
-                  fontSize: 11,
-                  background: "var(--bg-panel)",
-                  color: "var(--text-primary)",
-                  border: "1px solid var(--border-color)",
-                  borderRadius: 3,
-                  padding: "3px 5px",
-                  resize: "vertical",
-                  boxSizing: "border-box",
-                  fontFamily: "inherit",
-                }}
-              />
-            </div>
-          )}
-          {gitError && (
-            <div style={{ fontSize: 10, color: "var(--danger, #f85149)", wordBreak: "break-all", padding: "2px 6px 4px", borderBottom: "1px solid var(--border-color)" }}>
-              {gitError}
-            </div>
-          )}
-        </>
-      )}
-
-      {view === "git" && (
-        <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto" }}>
-          <GitHistory projectDir={projectDir} onChanged={() => projectDir && refreshGit(projectDir)} />
-        </div>
-      )}
-
-      {view === "files" && (
-        <>
-          <div className="right-panel-sort">
-            {(["name", "size", "type", "created", "modified"] as SortKey[]).map((key) => (
-              <button
-                key={key}
-                className={`sort-key-btn${sortKey === key ? " active" : ""}`}
-                onClick={() => sortKey === key ? setDescending((d) => !d) : setSortKey(key)}
-                title={sortKey === key ? (descending ? "Descending — click to reverse" : "Ascending — click to reverse") : `Sort by ${key}`}
-              >
-                {key}{sortKey === key ? (descending ? " ↓" : " ↑") : ""}
-              </button>
-            ))}
-          </div>
-          <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto" }}>
-            {open && activeBox ? (
-              boxRoots.length === 0 ? (
-                <div className="file-tree-empty">No member project folders</div>
-              ) : (
-                boxRoots.map((r) => (
-                  <BoxRootSection
-                    key={r.rootId}
-                    rootId={r.rootId}
-                    label={r.label}
-                    icon={r.icon}
-                    dir={r.dir}
-                    localFile={r.localFile}
-                    variant={r.variant}
-                    sortKey={sortKey}
-                    descending={descending}
-                  />
-                ))
-              )
-            ) : (
-              open && (
-                <FileTree
-                  projectDir={projectDir}
-                  projectId={activeId}
-                  localFile={localFile}
-                  sortKey={sortKey}
-                  descending={descending}
-                  hiddenEndings={hiddenEndings}
-                  hiddenPaths={hiddenPaths}
-                  shownPaths={shownPaths}
-                  initialRelPath={rightPanelFolder}
-                  onRelPathChange={(folder) => {
-                    if (activeId) setRightPanelFolder(activeId, folder);
-                  }}
-                />
-              )
-            )}
+                  <button
+                    type="button"
+                    className="hidden-sw-btn hidden-sw-close"
+                    title={t("rightPanel.closeSubwindow")}
+                    onClick={() => closeHiddenGroup(h.id)}
+                  >
+                    ×
+                  </button>
+                </div>
+              );
+            })}
           </div>
-        </>
-      )}
-
-      {view === "windows" && (
-        <div className="right-panel-scroll" style={{ flex: 1, overflowY: "auto", padding: 4 }}>
-          {windows.length === 0 ? (
-            <div className="file-tree-empty">No opened windows</div>
-          ) : (
-            windows.map((w) => (
-              <div key={w.id} className="file-entry">
-                <span className="file-icon">🪟</span>
-                <span className="file-name" title={w.exec}>
-                  {w.exec.split("/").pop() ?? w.exec}
-                  {w.file && <span style={{ color: "var(--text-muted)" }}> {w.file.split("/").pop()}</span>}
-                </span>
-                <button
-                  className="tab-close"
-                  onClick={() => untrack(w.id)}
-                  title="Untrack"
-                >
-                  ×
-                </button>
-              </div>
-            ))
-          )}
-        </div>
-      )}
-      {showSettings && activeProject && localFile && createPortal(
-        <div className="modal-backdrop settings-backdrop" onMouseDown={() => setShowSettings(false)}>
-          <div className="settings-dialog project-settings-dialog" onMouseDown={(e) => e.stopPropagation()}>
-            <div className="settings-title-row">
-              <h2>Project Settings</h2>
-              <button type="button" className="dialog-close-btn" onClick={() => setShowSettings(false)}>×</button>
-            </div>
-
-            <div className="settings-section-title">Panel File Hiding</div>
-            <p className="settings-help">
-              Click an ending to hide matching files in the right panel. Dimmed endings are hidden.
-            </p>
-            {availableEndings.length === 0 ? (
-              <div className="settings-empty">No file endings found in this project.</div>
-            ) : (
-              <div className="settings-list project-ending-list">
-                {availableEndings.map((ending) => {
-                  const checked = hiddenEndings.some((item) => item.toLowerCase() === ending.toLowerCase());
-                  return (
-                    <button
-                      type="button"
-                      className={`project-ending-toggle${checked ? " is-hidden" : ""}`}
-                      key={ending}
-                      aria-pressed={checked}
-                      onClick={() => toggleHiddenEnding(ending, !checked)}
-                      title={checked ? `Show ${ending} files` : `Hide ${ending} files`}
-                    >
-                      {ending}
-                    </button>
-                  );
-                })}
-              </div>
-            )}
-            {settingsError && <div className="settings-error">{settingsError}</div>}
-
-            {/* #48 per-file-type native-viewer settings (global, not per-project).
-                Toggles opt-in local autocomplete (#45) per type, plus the global
-                autosave (#47). */}
-            <div className="settings-section-title">Native Viewers</div>
-            <p className="settings-help">
-              Eldrun renders these file types in-app. Configure their behaviour
-              below. Autocomplete is local-only (Ollama) and opt-in.
-            </p>
-            <label className="viewer-pref-toggle" style={{ marginBottom: 6 }}>
-              <input
-                type="checkbox"
-                checked={settings?.autosave !== false}
-                onChange={(e) => void updateSettings({ autosave: e.target.checked })}
-              />
-              <span>Autosave edits</span>
-            </label>
-            <div className="viewer-prefs-list">
-              {VIEWER_PREF_TYPES.filter((t) => t.autocomplete).map((t) => {
-                const pref: ViewerPref = settings?.viewer_prefs?.[t.id] ?? {};
-                const patch = (next: ViewerPref) =>
-                  void updateSettings({
-                    viewer_prefs: {
-                      ...(settings?.viewer_prefs ?? {}),
-                      [t.id]: { ...pref, ...next },
-                    },
-                  });
-                return (
-                  <div className="viewer-pref-row" key={t.id}>
-                    <span className="viewer-pref-name">{t.label}</span>
-                    <span className="viewer-pref-exts">{t.extensions.join(" ")}</span>
-                    {t.autocomplete && (
-                      <label className="viewer-pref-toggle">
-                        <input
-                          type="checkbox"
-                          checked={pref.autocomplete === true}
-                          onChange={(e) => patch({ autocomplete: e.target.checked })}
-                        />
-                        <span>Autocomplete</span>
-                      </label>
-                    )}
-                  </div>
-                );
-              })}
-            </div>
+        )}
+      </div>
+    ) : null;
 
-            {settings?.debug && (
-              <>
-                <div className="settings-section-title">Debug</div>
-                <button
-                  className="tab-add-btn"
-                  style={{ fontSize: 11, padding: "2px 8px", width: "100%", color: "var(--danger, #f85149)" }}
-                  onClick={() => {
-                    invoke("clear_project_session", { localFile }).then(() => {
-                      window.location.reload();
-                    }).catch(console.error);
-                  }}
-                >
-                  Clear session storage
-                </button>
-              </>
-            )}
-          </div>
-        </div>,
-        document.body,
-      )}
-    </div>
+  return (
+    <ProjectFilesView
+      scope={scope}
+      projectId={activeId ?? null}
+      project={activeProject}
+      projectDir={projectDir}
+      folder={rightPanelFolder}
+      onFolderChange={(folder) => {
+        if (activeId) setRightPanelFolder(activeId, folder);
+      }}
+      source={fileSource}
+      setSource={setFileSource}
+      // A closed panel runs no probes and keeps no tree mounted (and so no
+      // fs-watch).
+      active={open}
+      mountTree={open}
+      // Right-click → "Open in a new tab": the same file view, on that folder,
+      // as a Files (Project) tab in this project's scope.
+      onOpenFolderTab={(rel) => openProjectFilesTab(projectDir, rel)}
+      containerClassName={`right-panel${side === "left" ? " left" : ""} ${open ? "open" : ""}${resizing ? " resizing" : ""}`}
+      containerStyle={width ? { width } : undefined}
+      containerProps={{ onMouseEnter, onMouseLeave }}
+      resizeHandle={resizeHandle}
+      pin={chrome}
+      hidden={hidden}
+    />
   );
 }
diff --git a/src/components/layout/SettingsPanel.tsx b/src/components/layout/SettingsPanel.tsx
index df00892..0aaa283 100644
--- a/src/components/layout/SettingsPanel.tsx
+++ b/src/components/layout/SettingsPanel.tsx
@@ -1,10 +1,30 @@
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState, type ChangeEventHandler, type ReactNode } from "react";
 import { invoke } from "@tauri-apps/api/core";
-import { useSettingsStore } from "../../stores/settings";
+import { open as openDialog } from "@tauri-apps/plugin-dialog";
+import {
+  useSettingsStore,
+  clampZoom,
+  MIN_UI_ZOOM,
+  MAX_UI_ZOOM,
+  ZOOM_STEPS,
+} from "../../stores/settings";
+import { UntestedTag } from "../common/UntestedTag";
+import { experimentalEnabled } from "../../lib/experimental";
+import { usePowerStore, useEnergySaver } from "../../stores/power";
+import { useProjectsStore } from "../../stores/projects";
 import { DEFAULT_MIN_SUBWINDOW_PX } from "../../stores/tabs";
-import type { KeyboardChord, Theme } from "../../types";
+import type {
+  ArchivedProject,
+  CalendarViewKind,
+  KeyboardChord,
+  ProjectEntry,
+  Theme,
+  UnsyncedReport,
+} from "../../types";
 import { THEMES } from "../../types";
-import { TERMINAL_OPTIONS } from "../projects/scaffold";
+import { summarizeScaffoldRepair, type ProjectScaffoldRepair } from "../projects/scaffold";
+import { Toggle } from "../common/Toggle";
+import { OPEN_STATS_EVENT } from "../stats/StatsRecapHost";
 import {
   SHORTCUT_DEFS,
   chordFromEvent,
@@ -13,53 +33,101 @@ import {
   type ShortcutAction,
   type ShortcutMap,
 } from "../../lib/shortcuts";
-import { FileTypeSettings, GlobalAppsSettings, OllamaPanel } from "./SettingsSubPanels";
+import {
+  AgentsPanel,
+  FileTypeSettings,
+  GlobalAppsSettings,
+  OllamaPanel,
+  RemoteHostsSettings,
+} from "./SettingsSubPanels";
+import { Dropdown } from "../common/Dropdown";
+import { PasswordInput } from "../common/PasswordInput";
+import { useT, LANGUAGES, type Language, type TranslationKey } from "../../lib/i18n";
+import { IS_MAC, IS_WINDOWS } from "../../lib/platform";
+import { useHintsStore } from "../../stores/hints";
+import { canConnectVpnSilently } from "../../lib/vpnConnect";
+import { setVpnAutoConnect, vpnUsernameFor } from "../../lib/vpnAutoConnect";
+import type { StoredVpnConfig } from "../../types";
+
+// The workspace-layout help text. On Linux a lone Super toggles the panels; on
+// Windows it's F9 (the lone Win key is OS-reserved — Start opens on release, see
+// useKeyboard); on macOS the Meta key is reserved for Cmd shortcuts, so the
+// lone-key toggle is disabled — there the panels stay reachable via the
+// cursor-to-edge reveal. Keep the copy honest per OS.
+function workspaceLayoutIntro(t: ReturnType<typeof useT>): string {
+  return IS_MAC
+    ? t("help.workspaceLayout.introMac")
+    : t("help.workspaceLayout.introOther", { key: IS_WINDOWS ? "F9" : "Super" });
+}
+
+/** A toggle with an explanatory paragraph, as one card (matches .settings-nav-item
+ *  / .lesson-item) instead of a bare switch-row bleeding into a trailing paragraph. */
+function ToggleCard({
+  label,
+  checked,
+  onChange,
+  help,
+}: {
+  label: string;
+  checked: boolean;
+  onChange: ChangeEventHandler<HTMLInputElement>;
+  help?: ReactNode;
+}) {
+  return (
+    <div className="settings-toggle-card">
+      <label className="settings-toggle-card-row">
+        <span>{label}</span>
+        <Toggle checked={checked} onChange={onChange} />
+      </label>
+      {help && <p className="settings-help">{help}</p>}
+    </div>
+  );
+}
 
 interface HelpItem {
-  term: string;
-  desc: string;
+  termKey: TranslationKey;
+  descKey: TranslationKey;
 }
 
 interface HelpSection {
-  title: string;
-  intro?: string;
+  titleKey: TranslationKey;
+  hasIntro?: boolean;
   items: HelpItem[];
 }
 
 const HELP_SECTIONS: HelpSection[] = [
   {
-    title: "Workspace layout",
-    intro:
-      "Eldrun keeps your AI-assisted development in a single window. Press Super while Eldrun is focused to toggle the panels, and F11 for fullscreen.",
+    titleKey: "help.workspaceLayout.title",
+    hasIntro: true,
     items: [
-      { term: "Root terminal (▣)", desc: "The control terminal that always lives at ~/eldrun/root/, independent of any project." },
-      { term: "Project pills", desc: "One pill per active project in the project switcher. Click to switch; each project keeps its own terminal and tabs. Drag pills to reorder them." },
-      { term: "Center panel & tabs", desc: "The active project's terminals. Right-click the tab bar to add a Claude/Codex/Gemini agent or a plain shell, rename, or close tabs. Drag tabs to reorder." },
-      { term: "Right file panel", desc: "A file-tree overlay for the active project. Open files, rename, and toggle hidden file types. The panel remembers the last folder per project." },
+      { termKey: "help.workspaceLayout.item1.term", descKey: "help.workspaceLayout.item1.desc" },
+      { termKey: "help.workspaceLayout.item2.term", descKey: "help.workspaceLayout.item2.desc" },
+      { termKey: "help.workspaceLayout.item3.term", descKey: "help.workspaceLayout.item3.desc" },
+      { termKey: "help.workspaceLayout.item4.term", descKey: "help.workspaceLayout.item4.desc" },
     ],
   },
   {
-    title: "Projects",
+    titleKey: "help.projects.title",
     items: [
-      { term: "Add (+)", desc: "Create a New Project (scaffolds files and a git repo under ~/eldrun/projects/) or Import an existing folder without touching its contents." },
-      { term: "Search inactive", desc: "The search box finds projects that aren't currently open; pick one to activate its pill and terminal." },
-      { term: "Remote (SSH) projects", desc: "Projects on a remote host are sshfs-mounted locally and behave like any other project. Requires sshfs/FUSE installed." },
-      { term: "Tasks", desc: "Right-click a tab to set, complete, or clear an agent task. Tasks persist in the project's project.json and can seed a new agent's prompt." },
+      { termKey: "help.projects.item1.term", descKey: "help.projects.item1.desc" },
+      { termKey: "help.projects.item2.term", descKey: "help.projects.item2.desc" },
+      { termKey: "help.projects.item3.term", descKey: "help.projects.item3.desc" },
+      { termKey: "help.projects.item4.term", descKey: "help.projects.item4.desc" },
     ],
   },
   {
-    title: "AI & terminals",
+    titleKey: "help.aiTerminals.title",
     items: [
-      { term: "Default agent", desc: "Choose the default terminal command (claude, codex, gemini, vibe) in Settings. Missing commands fall back to a shell; closed agents respawn." },
-      { term: "Ollama models", desc: "When Ollama is installed, the gear menu shows local models. Ctrl+K opens the local-model prompt dialog for the active context." },
+      { termKey: "help.aiTerminals.item1.term", descKey: "help.aiTerminals.item1.desc" },
+      { termKey: "help.aiTerminals.item2.term", descKey: "help.aiTerminals.item2.desc" },
     ],
   },
   {
-    title: "Settings & extras",
+    titleKey: "help.settingsExtras.title",
     items: [
-      { term: "Settings (⚙)", desc: "Theme, default agent, Git hosting profile/token, workspace management, background scripts, and debug mode." },
-      { term: "Workspace integration", desc: "Optional KDE/X11 virtual-desktop isolation per project when workspace management is enabled." },
-      { term: "Time tracking", desc: "Eldrun records active session time so you can see how long you spend per project." },
+      { termKey: "help.settingsExtras.item1.term", descKey: "help.settingsExtras.item1.desc" },
+      { termKey: "help.settingsExtras.item2.term", descKey: "help.settingsExtras.item2.desc" },
+      { termKey: "help.settingsExtras.item3.term", descKey: "help.settingsExtras.item3.desc" },
     ],
   },
 ];
@@ -71,6 +139,7 @@ const HELP_SECTIONS: HelpSection[] = [
  * clears an override back to its built-in default.
  */
 function ShortcutsSettings({ onBack }: { onBack: () => void }) {
+  const t = useT();
   const { settings, updateSettings } = useSettingsStore();
   const overrides = (settings?.keyboard_shortcuts ?? {}) as ShortcutMap;
   const [capturing, setCapturing] = useState<ShortcutAction | null>(null);
@@ -115,13 +184,10 @@ function ShortcutsSettings({ onBack }: { onBack: () => void }) {
   return (
     <>
       <div className="settings-title-row">
-        <h2>Keyboard Shortcuts</h2>
-        <button type="button" onClick={onBack}>Back</button>
+        <h2>{t("nav.shortcuts.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
       </div>
-      <p className="settings-help">
-        Click a shortcut, then press the new key combination. F11 (OS fullscreen)
-        and Escape (exit fullscreen) are fixed and cannot be rebound.
-      </p>
+      <p className="settings-help">{t("shortcuts.help")}</p>
       <div className="settings-list">
         {SHORTCUT_DEFS.map((def) => {
           const active = capturing === def.action;
@@ -134,18 +200,18 @@ function ShortcutsSettings({ onBack }: { onBack: () => void }) {
                 type="button"
                 className={`shortcut-capture-btn${active ? " capturing" : ""}`}
                 onClick={() => setCapturing(active ? null : def.action)}
-                title="Click, then press a key combination"
+                title={t("shortcuts.captureTitle")}
               >
-                {active ? "Press keys…" : chordLabel(effective)}
+                {active ? t("shortcuts.pressKeys") : chordLabel(effective)}
               </button>
               <button
                 type="button"
                 className="settings-back-btn"
                 disabled={!isCustom}
                 onClick={() => reset(def.action)}
-                title="Reset to default"
+                title={t("shortcuts.resetTitle")}
               >
-                Reset
+                {t("common.reset")}
               </button>
             </div>
           );
@@ -155,27 +221,430 @@ function ShortcutsSettings({ onBack }: { onBack: () => void }) {
   );
 }
 
+/**
+ * Git hosting profile + access token, broken out of the main settings panel
+ * into its own sub-menu. Manages its own draft state (mirroring the saved
+ * settings) and persists on blur / Enter, same as it did inline.
+ */
+function GitHostingSettings({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const { settings, updateSettings } = useSettingsStore();
+  const [gitProfileUrl, setGitProfileUrl] = useState(settings?.git_profile_url ?? "");
+  const [gitToken, setGitToken] = useState(settings?.git_token ?? "");
+
+  useEffect(() => {
+    setGitProfileUrl(settings?.git_profile_url ?? "");
+    setGitToken(settings?.git_token ?? "");
+  }, [settings?.git_profile_url, settings?.git_token]);
+
+  const saveGitProfileUrl = () => {
+    void updateSettings({ git_profile_url: gitProfileUrl.trim() });
+  };
+
+  const saveGitToken = () => {
+    void updateSettings({ git_token: gitToken.trim() });
+  };
+
+  return (
+    <>
+      <div className="settings-title-row">
+        <h2>{t("nav.git.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+      </div>
+      <p className="settings-help">{t("git.help")}</p>
+      <label className="settings-field">
+        {t("git.profileUrl")}
+        <input
+          value={gitProfileUrl}
+          placeholder={t("git.profileUrlPlaceholder")}
+          onChange={(e) => setGitProfileUrl(e.target.value)}
+          onBlur={saveGitProfileUrl}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") saveGitProfileUrl();
+          }}
+        />
+      </label>
+      <label className="settings-field">
+        {t("git.accessToken")}
+        <PasswordInput
+          value={gitToken}
+          placeholder={t("git.tokenPlaceholder")}
+          onChange={(e) => setGitToken(e.target.value)}
+          onBlur={saveGitToken}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") saveGitToken();
+          }}
+        />
+      </label>
+    </>
+  );
+}
+
+/**
+ * Same setting the header's VPN menu arms per config (`settings.vpn_auto_connect`,
+ * see `lib/vpnAutoConnect.ts`) — surfaced here too since the header menu only shows
+ * up once a tunnel exists, which makes this opt-in easy to miss.
+ */
+function VpnAutoConnectSettings({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const { settings } = useSettingsStore();
+  const armed = settings?.vpn_auto_connect ?? null;
+  const headless = settings?.connections_headless ?? true;
+  const [configs, setConfigs] = useState<StoredVpnConfig[] | null>(null);
+  const [silent, setSilent] = useState<Record<string, boolean>>({});
+
+  useEffect(() => {
+    let cancelled = false;
+    void invoke<StoredVpnConfig[]>("openvpn_list_configs")
+      .then(async (list) => {
+        const stored = Array.isArray(list) ? list : [];
+        if (cancelled) return;
+        setConfigs(stored);
+        const checks = await Promise.all(
+          stored.map(async (c) => [c.path, await canConnectVpnSilently(c.path, vpnUsernameFor(c.path))] as const),
+        );
+        if (!cancelled) setSilent(Object.fromEntries(checks));
+      })
+      .catch(() => {
+        if (!cancelled) setConfigs([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  return (
+    <>
+      <div className="settings-title-row">
+        <h2>{t("nav.vpn.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+      </div>
+      <p className="settings-help">{t("vpn.autoConnectHelp")}</p>
+      {configs === null ? (
+        <p className="settings-help">{t("common.loading")}</p>
+      ) : configs.length === 0 ? (
+        <div className="settings-empty">{t("vpn.noConfig")}</div>
+      ) : (
+        <div className="settings-list">
+          {configs.map((c) => {
+            const on = armed === c.path;
+            const eligible = !headless || silent[c.path] === true;
+            return (
+              <div key={c.path} className="settings-toggle-card">
+                <label className="settings-toggle-card-row">
+                  <span title={c.path}>{c.name}</span>
+                  <Toggle
+                    checked={on}
+                    disabled={!eligible && !on}
+                    onChange={(e) => void setVpnAutoConnect(c.path, e.target.checked)}
+                  />
+                </label>
+                {!eligible && !on && (
+                  <p className="settings-help">
+                    {t("vpn.needsSavedPre")} <b>{t("vpn.needsSavedBold")}</b>{" "}
+                    {t("vpn.needsSavedPost")}
+                  </p>
+                )}
+                {on && (
+                  <p className="settings-help">
+                    {t("vpn.startsWithEldrun")}
+                    {headless ? "" : ` ${t("vpn.waitsInRootTerminal")}`}.
+                  </p>
+                )}
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </>
+  );
+}
+
+function ArchivedProjectsPanel({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const [items, setItems] = useState<ArchivedProject[] | null>(null);
+  const [busyId, setBusyId] = useState<string | null>(null);
+  const [error, setError] = useState("");
+  // id of the row armed for permanent deletion + the name typed to confirm it.
+  const [confirmId, setConfirmId] = useState<string | null>(null);
+  // Mirrors confirmId for stale-guarding the async unsynced check below.
+  const confirmIdRef = useRef<string | null>(null);
+  const [typed, setTyped] = useState("");
+  // Unsynced-mirror check for the armed row (remote projects only): null while
+  // loading/not-yet-fetched, else the offline report on local-only commits.
+  const [unsynced, setUnsynced] = useState<UnsyncedReport | null>(null);
+  // Typed guard for the "Clear archive" bulk action.
+  const [clearing, setClearing] = useState(false);
+  const [clearTyped, setClearTyped] = useState("");
+
+  const refresh = () => {
+    invoke<ArchivedProject[]>("list_archived_projects")
+      .then(setItems)
+      .catch((e) => {
+        setError(String(e));
+        setItems([]);
+      });
+  };
+
+  useEffect(refresh, []);
+
+  const resetConfirm = () => {
+    setConfirmId(null);
+    confirmIdRef.current = null;
+    setTyped("");
+    setUnsynced(null);
+  };
+
+  // Arm a row for permanent deletion; for remote projects, run the offline
+  // unsynced-mirror check so the confirm step can warn about local-only commits.
+  const armDelete = (a: ArchivedProject) => {
+    setConfirmId(a.id);
+    confirmIdRef.current = a.id;
+    setTyped("");
+    setUnsynced(null);
+    if (a.remote) {
+      invoke<UnsyncedReport>("archived_mirror_unsynced", { projectId: a.id })
+        // Drop a late result if the user moved to a different row; ignore failures
+        // (the type-to-confirm guard still stands without the hint).
+        .then((r) => confirmIdRef.current === a.id && setUnsynced(r))
+        .catch(() => {});
+    }
+  };
+
+  const restore = async (a: ArchivedProject) => {
+    setBusyId(a.id);
+    setError("");
+    try {
+      const restored = await invoke<ProjectEntry>("restore_archived_project", { projectId: a.id });
+      // Splice the restored (inactive) entry back into the live list without a
+      // full reload, so box grouping / active project are left undisturbed.
+      useProjectsStore.setState((s) => ({
+        projects: [...s.projects.filter((p) => p.id !== restored.id), restored],
+      }));
+      refresh();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setBusyId(null);
+    }
+  };
+
+  const deleteForever = async (a: ArchivedProject) => {
+    setBusyId(a.id);
+    setError("");
+    try {
+      await invoke("delete_archived_project", { projectId: a.id });
+      resetConfirm();
+      refresh();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setBusyId(null);
+    }
+  };
+
+  const clearAll = async () => {
+    setBusyId("__all__");
+    setError("");
+    try {
+      await invoke("clear_archive");
+      setClearing(false);
+      setClearTyped("");
+      refresh();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setBusyId(null);
+    }
+  };
+
+  return (
+    <>
+      <div className="settings-title-row">
+        <h2>{t("nav.archive.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+      </div>
+      <p className="settings-help">{t("archive.help")}</p>
+      {error && <div className="project-dialog-error">{error}</div>}
+      {items === null ? (
+        <p className="settings-help">{t("common.loading")}</p>
+      ) : items.length === 0 ? (
+        <p className="settings-help">{t("archive.empty")}</p>
+      ) : (
+        <ul className="archived-projects-list">
+          {items.map((a) => {
+            const armed = confirmId === a.id;
+            const rowBusy = busyId === a.id;
+            return (
+              <li key={a.id} className="archived-project-row">
+                <div className="archived-project-info">
+                  <span className="archived-project-name">{a.name}</span>
+                  {a.remote && <span className="archived-project-tag">{t("archive.remoteTag")}</span>}
+                  <span className="archived-project-date">{a.archived_at.slice(0, 10)}</span>
+                </div>
+                {armed ? (
+                  <div className="archived-project-confirm-group">
+                    {unsynced && unsynced.total > 0 && (
+                      <p className="archived-project-warn">
+                        ⚠ {unsynced.verified
+                          ? t(unsynced.total === 1 ? "archive.unsyncedVerifiedOne" : "archive.unsyncedVerifiedMany", {
+                              count: unsynced.total,
+                              branches: unsynced.branches.map((b) => b.name).join(", "),
+                            })
+                          : t(unsynced.total === 1 ? "archive.unsyncedUnverifiedOne" : "archive.unsyncedUnverifiedMany", {
+                              count: unsynced.total,
+                            })}
+                      </p>
+                    )}
+                  <div className="archived-project-confirm">
+                    <input
+                      type="text"
+                      autoFocus
+                      placeholder={t("archive.typeToDelete", { name: a.name })}
+                      value={typed}
+                      onChange={(e) => setTyped(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Escape") resetConfirm();
+                      }}
+                    />
+                    <button type="button" onClick={resetConfirm} disabled={rowBusy}>{t("common.cancel")}</button>
+                    <button
+                      type="button"
+                      className="danger"
+                      disabled={rowBusy || typed.trim() !== a.name.trim()}
+                      onClick={() => void deleteForever(a)}
+                    >
+                      {rowBusy ? t("archive.deleting") : t("archive.deleteForever")}
+                    </button>
+                  </div>
+                  </div>
+                ) : (
+                  <div className="archived-project-actions">
+                    <button type="button" disabled={rowBusy} onClick={() => void restore(a)}>
+                      {rowBusy ? t("archive.restoring") : t("archive.restore")}
+                    </button>
+                    <button
+                      type="button"
+                      className="danger"
+                      disabled={rowBusy}
+                      onClick={() => armDelete(a)}
+                    >
+                      {t("archive.deletePermanently")}
+                    </button>
+                  </div>
+                )}
+              </li>
+            );
+          })}
+        </ul>
+      )}
+      {items && items.length > 0 && (
+        clearing ? (
+          <div className="archived-project-confirm">
+            <input
+              type="text"
+              autoFocus
+              placeholder={t("archive.typeDeleteAll")}
+              value={clearTyped}
+              onChange={(e) => setClearTyped(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Escape") { setClearing(false); setClearTyped(""); }
+              }}
+            />
+            <button type="button" onClick={() => { setClearing(false); setClearTyped(""); }}>{t("common.cancel")}</button>
+            <button
+              type="button"
+              className="danger"
+              disabled={busyId === "__all__" || clearTyped.trim().toLowerCase() !== "delete"}
+              onClick={() => void clearAll()}
+            >
+              {busyId === "__all__" ? t("archive.clearing") : t("archive.clearArchive")}
+            </button>
+          </div>
+        ) : (
+          <div className="settings-link-row">
+            <button type="button" className="danger" onClick={() => setClearing(true)}>
+              {t("archive.clearArchiveEllipsis")}
+            </button>
+          </div>
+        )
+      )}
+    </>
+  );
+}
+
+function ScaffoldRepairPanel({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const [results, setResults] = useState<ProjectScaffoldRepair[] | null>(null);
+
+  const run = async () => {
+    setBusy(true);
+    setError("");
+    try {
+      const repaired = await invoke<ProjectScaffoldRepair[]>("repair_all_project_scaffolds");
+      setResults(repaired);
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <>
+      <div className="settings-title-row">
+        <h2>{t("nav.scaffoldRepair.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+      </div>
+      <p className="settings-help">{t("scaffoldRepair.help")}</p>
+      {error && <div className="project-dialog-error">{error}</div>}
+      <div className="settings-link-row">
+        <button type="button" disabled={busy} onClick={() => void run()}>
+          {busy ? t("scaffoldRepair.running") : t("scaffoldRepair.runNow")}
+        </button>
+      </div>
+      {results !== null && (
+        results.length === 0 ? (
+          <p className="settings-help">{t("scaffoldRepair.upToDate")}</p>
+        ) : (
+          <ul className="archived-projects-list">
+            {results.map((r) => (
+              <li key={r.projectId} className="archived-project-row">
+                <div className="archived-project-info">
+                  <span className="archived-project-name">{r.name}</span>
+                  <span className="archived-project-date">{summarizeScaffoldRepair(r.report)}</span>
+                </div>
+              </li>
+            ))}
+          </ul>
+        )
+      )}
+    </>
+  );
+}
+
 function HelpPanel({ onBack }: { onBack: () => void }) {
+  const t = useT();
   return (
     <>
       <div className="settings-title-row">
-        <h2>Eldrun Help</h2>
-        <button type="button" onClick={onBack}>Back</button>
+        <h2>{t("help.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
       </div>
 
-      <p className="settings-help">
-        A quick guide to what each part of Eldrun does. Hover the toolbar buttons for shortcuts too.
-      </p>
+      <p className="settings-help">{t("help.intro")}</p>
 
       {HELP_SECTIONS.map((section) => (
-        <div key={section.title} className="help-section">
-          <div className="settings-section-title">{section.title}</div>
-          {section.intro && <p className="settings-help">{section.intro}</p>}
+        <div key={section.titleKey} className="help-section">
+          <div className="settings-section-title">{t(section.titleKey)}</div>
+          {section.hasIntro && <p className="settings-help">{workspaceLayoutIntro(t)}</p>}
           <dl className="help-list">
             {section.items.map((item) => (
-              <div key={item.term} className="help-row">
-                <dt>{item.term}</dt>
-                <dd>{item.desc}</dd>
+              <div key={item.termKey} className="help-row">
+                <dt>{t(item.termKey)}</dt>
+                <dd>{t(item.descKey)}</dd>
               </div>
             ))}
           </dl>
@@ -185,7 +654,23 @@ function HelpPanel({ onBack }: { onBack: () => void }) {
   );
 }
 
-export type SettingsPanelKind = "main" | "global" | "filetypes" | "ollama" | "shortcuts" | "help";
+export type SettingsPanelKind = "main" | "global" | "filetypes" | "ollama" | "agents" | "shortcuts" | "git" | "vpn" | "remoteHosts" | "archive" | "scaffoldRepair" | "help";
+
+/** Sub-panel navigation shown as a card menu at the foot of the main settings
+ *  panel (styled like the Lessons / How-to-start menus). Titles/blurbs are
+ *  resolved at render via i18n (`nav.<panel>.title` / `.blurb`). */
+const SETTINGS_NAV: Exclude<SettingsPanelKind, "main" | "ollama">[] = [
+  "git",
+  "vpn",
+  "remoteHosts",
+  "global",
+  "filetypes",
+  "agents",
+  "shortcuts",
+  "archive",
+  "scaffoldRepair",
+  "help",
+];
 
 export function SettingsDialog({
   onClose,
@@ -194,102 +679,329 @@ export function SettingsDialog({
   onClose: () => void;
   initialPanel?: SettingsPanelKind;
 }) {
-  const { settings, setTheme, updateSettings } = useSettingsStore();
+  const { settings, setTheme, setLanguage, updateSettings } = useSettingsStore();
   const [panel, setPanel] = useState<SettingsPanelKind>(initialPanel);
-  const [gitProfileUrl, setGitProfileUrl] = useState(settings?.git_profile_url ?? "");
-  const [gitToken, setGitToken] = useState(settings?.git_token ?? "");
-  const [ollamaInstalled, setOllamaInstalled] = useState(false);
+  const t = useT();
 
-  useEffect(() => {
-    invoke<boolean>("ollama_is_installed").then(setOllamaInstalled).catch(() => {});
-  }, []);
-
-  useEffect(() => {
-    setGitProfileUrl(settings?.git_profile_url ?? "");
-    setGitToken(settings?.git_token ?? "");
-  }, [settings?.git_profile_url, settings?.git_token]);
-
-  const terminal = settings?.terminal_command ?? "claude";
   const currentTheme = (settings?.color_scheme ?? "fancy_dark") as Theme;
+  const currentLang = (settings?.language ?? "en") as Language;
 
-  const saveGitProfileUrl = () => {
-    void updateSettings({ git_profile_url: gitProfileUrl.trim() });
-  };
-
-  const saveGitToken = () => {
-    void updateSettings({ git_token: gitToken.trim() });
-  };
+  // Live power state for the Energy Saver help line.
+  const energyMode = settings?.energy_saver ?? "battery";
+  const energyActive = useEnergySaver();
+  const powerReady = usePowerStore((s) => s.ready);
+  const powerSupported = usePowerStore((s) => s.supported);
+  const energyStatus = (() => {
+    if (energyMode === "battery" && powerReady && !powerSupported) {
+      return t("settings.energyUnavailable");
+    }
+    if (energyActive) {
+      return energyMode === "always"
+        ? t("settings.energyActiveAlways")
+        : t("settings.energyActiveBattery");
+    }
+    return energyMode === "off" ? t("settings.energyOff") : t("settings.energyInactive");
+  })();
 
   return (
-    <div className="modal-backdrop settings-backdrop" onMouseDown={onClose}>
+    <div className="modal-backdrop how-to-start-backdrop" onMouseDown={onClose}>
       <div className="settings-dialog" onMouseDown={(e) => e.stopPropagation()}>
+       <div className="dialog-scroll">
         {panel === "main" && (
           <>
             <div className="settings-title-row">
-              <h2>Settings</h2>
+              <h2>{t("settings.title")}</h2>
               <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
             </div>
 
             <div className="settings-row">
-              <label htmlFor="terminal-command">Terminal</label>
-              <select
-                id="terminal-command"
-                value={terminal}
-                onChange={(e) => void updateSettings({ terminal_command: e.target.value })}
-              >
-                {TERMINAL_OPTIONS.map((cmd) => (
-                  <option key={cmd} value={cmd}>{cmd}</option>
-                ))}
-              </select>
+              <label>{t("settings.theme")}</label>
+              <Dropdown
+                value={currentTheme}
+                onChange={(v) => void setTheme(v as Theme)}
+                options={THEMES.map((theme) => ({ value: theme.value, label: theme.label }))}
+              />
             </div>
 
             <div className="settings-row">
-              <label htmlFor="color-scheme">Theme</label>
-              <select
-                id="color-scheme"
-                value={currentTheme}
-                onChange={(e) => void setTheme(e.target.value as Theme)}
-              >
-                {THEMES.map((theme) => (
-                  <option key={theme.value} value={theme.value}>{theme.label}</option>
-                ))}
-              </select>
+              <label>
+                {t("settings.language")} <UntestedTag />
+              </label>
+              <Dropdown
+                value={currentLang}
+                onChange={(v) => void setLanguage(v as Language)}
+                options={LANGUAGES.map((l) => ({ value: l.value, label: l.label }))}
+              />
             </div>
+            <p className="settings-help">{t("settings.language.help")}</p>
 
-            <label className="settings-switch-row">
-              <span>Manage workspaces</span>
-              <input
-                type="checkbox"
-                checked={settings?.workspace_management ?? false}
-                onChange={(e) => void updateSettings({ workspace_management: e.target.checked })}
+            <ToggleCard
+              label={t("settings.runScriptsBg")}
+              checked={settings?.run_scripts_in_background ?? true}
+              onChange={(e) => void updateSettings({ run_scripts_in_background: e.target.checked })}
+            />
+
+            <ToggleCard
+              label={t("settings.headlessRemote")}
+              checked={settings?.connections_headless ?? true}
+              onChange={(e) => void updateSettings({ connections_headless: e.target.checked })}
+              help={t("settings.headlessRemoteHelp")}
+            />
+
+            {!IS_WINDOWS && (
+              <ToggleCard
+                label={t("settings.persistLocal")}
+                checked={settings?.persist_local_sessions ?? true}
+                onChange={(e) => void updateSettings({ persist_local_sessions: e.target.checked })}
+                help={
+                  <>
+                    {t("settings.persistLocalHelp1")} <code>tmux</code>
+                    {t("settings.persistLocalHelp2")}
+                  </>
+                }
               />
-            </label>
+            )}
 
-            <label className="settings-switch-row">
-              <span>Run scripts in background</span>
-              <input
-                type="checkbox"
-                checked={settings?.run_scripts_in_background ?? true}
-                onChange={(e) => void updateSettings({ run_scripts_in_background: e.target.checked })}
+            <div className="settings-section-title">{t("settings.remoteFeatures")}</div>
+            <div className="settings-toggle-card">
+              <label className="settings-toggle-card-row">
+                <span>{t("settings.vpnEnabled")}</span>
+                <Toggle
+                  checked={settings?.vpn_enabled ?? false}
+                  onChange={(e) => void updateSettings({ vpn_enabled: e.target.checked })}
+                />
+              </label>
+              <label className="settings-toggle-card-row">
+                <span>{t("settings.machinesEnabled")}</span>
+                <Toggle
+                  checked={settings?.machines_enabled ?? false}
+                  onChange={(e) => void updateSettings({ machines_enabled: e.target.checked })}
+                />
+              </label>
+              <p className="settings-help">{t("settings.remoteFeaturesHelp")}</p>
+            </div>
+
+            <div className="settings-row">
+              <label>{t("settings.energySaver")}</label>
+              <Dropdown
+                value={energyMode}
+                onChange={(v) => void updateSettings({ energy_saver: v as "off" | "battery" | "always" })}
+                options={[
+                  { value: "off", label: t("energy.off") },
+                  { value: "battery", label: t("energy.battery") },
+                  { value: "always", label: t("energy.always") },
+                ]}
               />
-            </label>
+            </div>
+            <p className="settings-help">
+              {t("settings.energyHelp")}
+              {" "}{energyStatus}
+            </p>
 
-            <label className="settings-switch-row">
-              <span>Debug mode</span>
-              <input
-                type="checkbox"
-                checked={settings?.debug ?? false}
-                onChange={(e) => void updateSettings({ debug: e.target.checked })}
+            <ToggleCard
+              label={t("settings.debug")}
+              checked={settings?.debug ?? false}
+              onChange={(e) => void updateSettings({ debug: e.target.checked })}
+            />
+
+            <div className="settings-section-title">{t("settings.experimental")}</div>
+            <p className="settings-help">
+              {t("settings.experimentalHelp1")}{" "}
+              <b>{t("settings.experimentalHelpBold")}</b> {t("settings.experimentalHelp2")}
+            </p>
+
+            <ToggleCard
+              label={t("settings.agentModeToggle")}
+              checked={experimentalEnabled(settings, "agent_mode_toggle")}
+              onChange={(e) => void updateSettings({ agent_mode_toggle: e.target.checked })}
+              help={
+                <>
+                  {t("settings.agentModeHelp1")} <b>Plan</b> {t("settings.agentModeHelp2")}{" "}
+                  <b>Auto</b> {t("settings.agentModeHelp3")}
+                </>
+              }
+            />
+
+            <ToggleCard
+              label={t("settings.pythonRunDebug")}
+              checked={experimentalEnabled(settings, "python_run_debug")}
+              onChange={(e) => void updateSettings({ python_run_debug: e.target.checked })}
+              help={
+                <>
+                  {t("settings.pythonRunHelp1")} <code>.py</code> {t("settings.pythonRunHelp2")}{" "}
+                  <b>▶ Run</b> {t("settings.pythonRunHelp3")} <b>🐞 Debug</b>{" "}
+                  {t("settings.pythonRunHelp4")} <code>pdb</code>
+                  {t("settings.pythonRunHelp5")}
+                </>
+              }
+            />
+
+            <div className="settings-section-title">{t("settings.resourceMonitor")}</div>
+            <div className="settings-toggle-card">
+              <label className="settings-toggle-card-row">
+                <span>{t("settings.showCpu")}</span>
+                <Toggle
+                  checked={settings?.show_cpu_usage ?? true}
+                  onChange={(e) => void updateSettings({ show_cpu_usage: e.target.checked })}
+                />
+              </label>
+              <label className="settings-toggle-card-row">
+                <span>{t("settings.showRam")}</span>
+                <Toggle
+                  checked={settings?.show_ram_usage ?? true}
+                  onChange={(e) => void updateSettings({ show_ram_usage: e.target.checked })}
+                />
+              </label>
+              <label className="settings-toggle-card-row">
+                <span>{t("settings.showGpu")}</span>
+                <Toggle
+                  checked={settings?.show_gpu_usage ?? true}
+                  onChange={(e) => void updateSettings({ show_gpu_usage: e.target.checked })}
+                />
+              </label>
+              <p className="settings-help">{t("settings.resourceMonitorHelp")}</p>
+              <label className="settings-toggle-card-row">
+                <span>{t("settings.showClockSeconds")}</span>
+                <Toggle
+                  checked={settings?.show_clock_seconds ?? false}
+                  onChange={(e) => void updateSettings({ show_clock_seconds: e.target.checked })}
+                />
+              </label>
+            </div>
+
+            <div className="settings-section-title">{t("settings.calendar")}</div>
+            <div className="settings-row">
+              <label>{t("settings.weekStartsOn")}</label>
+              <Dropdown
+                value={String(settings?.calendar_week_start ?? 0)}
+                onChange={(v) =>
+                  void updateSettings({ calendar_week_start: Number(v) === 1 ? 1 : 0 })
+                }
+                options={[
+                  { value: "0", label: t("day.sunday") },
+                  { value: "1", label: t("day.monday") },
+                ]}
+              />
+            </div>
+            <div className="settings-row">
+              <label>{t("settings.defaultView")}</label>
+              <Dropdown
+                value={settings?.calendar_default_view ?? "month"}
+                onChange={(v) =>
+                  void updateSettings({ calendar_default_view: v as CalendarViewKind })
+                }
+                options={[
+                  { value: "day", label: t("view.day") },
+                  { value: "week", label: t("view.week") },
+                  { value: "multiweek", label: t("view.multiweek") },
+                  { value: "month", label: t("view.month") },
+                  { value: "agenda", label: t("view.agenda") },
+                  { value: "tasks", label: t("view.tasks") },
+                ]}
+              />
+            </div>
+            <ToggleCard
+              label={t("settings.clock24")}
+              checked={settings?.calendar_time_format_24h ?? false}
+              onChange={(e) => void updateSettings({ calendar_time_format_24h: e.target.checked })}
+            />
+            <div className="settings-row">
+              <label>{t("settings.dayGridStart")}</label>
+              <Dropdown
+                value={String(settings?.calendar_day_start_hour ?? 8)}
+                onChange={(v) => void updateSettings({ calendar_day_start_hour: Number(v) })}
+                options={Array.from({ length: 24 }, (_, h) => ({
+                  value: String(h),
+                  label: `${String(h).padStart(2, "0")}:00`,
+                }))}
               />
-            </label>
+            </div>
+            <div className="settings-row">
+              <label>{t("settings.defaultReminder")}</label>
+              <Dropdown
+                value={String(settings?.calendar_default_reminder_minutes ?? 0)}
+                onChange={(v) =>
+                  void updateSettings({ calendar_default_reminder_minutes: Number(v) })
+                }
+                options={[
+                  { value: "0", label: t("reminder.none") },
+                  { value: "5", label: t("reminder.5") },
+                  { value: "15", label: t("reminder.15") },
+                  { value: "30", label: t("reminder.30") },
+                  { value: "60", label: t("reminder.60") },
+                  { value: "1440", label: t("reminder.1440") },
+                ]}
+              />
+            </div>
+            <p className="settings-help">{t("settings.reminderHelp")}</p>
+
+            <div className="settings-section-title">{t("settings.hintsOnboarding")}</div>
+            <ToggleCard
+              label={t("settings.showHints")}
+              checked={settings?.hints_enabled ?? true}
+              onChange={(e) => void updateSettings({ hints_enabled: e.target.checked })}
+            />
+            <div className="settings-link-row">
+              <button
+                type="button"
+                onClick={() => {
+                  onClose();
+                  window.dispatchEvent(new Event("eldrun:open-how-to-start"));
+                }}
+              >
+                {t("settings.howToStart")}
+              </button>
+              <button
+                type="button"
+                onClick={() => {
+                  onClose();
+                  window.dispatchEvent(new Event("eldrun:start-tour"));
+                }}
+              >
+                {t("settings.takeTour")}
+              </button>
+              <button
+                type="button"
+                onClick={() => {
+                  onClose();
+                  window.dispatchEvent(new Event("eldrun:open-lessons"));
+                }}
+              >
+                {t("settings.lessons")}
+              </button>
+              <button type="button" onClick={() => useHintsStore.getState().reset()}>
+                {t("settings.resetHints")}
+              </button>
+            </div>
 
-            <div className="settings-section-title">Layout</div>
+            <div className="settings-section-title">{t("settings.layout")}</div>
             <p className="settings-help">
-              Smallest a subwindow may be made by dragging a split divider.
-              Defaults to {DEFAULT_MIN_SUBWINDOW_PX}px when left blank.
+              {t("settings.zoomHelp1")} <strong>{t("settings.zoomHelpBold")}</strong>
+              {t("settings.zoomHelp2")} <UntestedTag />
             </p>
             <div className="settings-row">
-              <label htmlFor="min-subwindow-width">Min subwindow width (px)</label>
+              <label>{t("settings.windowZoom")}</label>
+              <Dropdown
+                value={String(clampZoom(settings?.ui_zoom))}
+                onChange={(v) => {
+                  const z = parseFloat(v);
+                  void updateSettings({
+                    ui_zoom: z === 1 ? undefined : clampZoom(z),
+                  });
+                }}
+                options={ZOOM_STEPS.filter(
+                  (z) => z >= MIN_UI_ZOOM && z <= MAX_UI_ZOOM,
+                ).map((z) => ({
+                  value: String(z),
+                  label: `${Math.round(z * 100)}%${z === 1 ? ` (${t("common.default")})` : ""}`,
+                }))}
+              />
+            </div>
+            <p className="settings-help">
+              {t("settings.minSubwindowHelp", { px: DEFAULT_MIN_SUBWINDOW_PX })}
+            </p>
+            <div className="settings-row">
+              <label htmlFor="min-subwindow-width">{t("settings.minSubWidth")}</label>
               <input
                 id="min-subwindow-width"
                 type="number"
@@ -306,7 +1018,7 @@ export function SettingsDialog({
               />
             </div>
             <div className="settings-row">
-              <label htmlFor="min-subwindow-height">Min subwindow height (px)</label>
+              <label htmlFor="min-subwindow-height">{t("settings.minSubHeight")}</label>
               <input
                 id="min-subwindow-height"
                 type="number"
@@ -323,49 +1035,115 @@ export function SettingsDialog({
               />
             </div>
 
-            <div className="settings-section-title">Git Hosting</div>
-            <label className="settings-field">
-              Profile URL
-              <input
-                value={gitProfileUrl}
-                placeholder="https://github.com/username"
-                onChange={(e) => setGitProfileUrl(e.target.value)}
-                onBlur={saveGitProfileUrl}
-                onKeyDown={(e) => {
-                  if (e.key === "Enter") saveGitProfileUrl();
-                }}
-              />
-            </label>
-            <label className="settings-field">
-              Access token
-              <input
-                type="password"
-                value={gitToken}
-                placeholder="ghp_... / glpat-..."
-                onChange={(e) => setGitToken(e.target.value)}
-                onBlur={saveGitToken}
-                onKeyDown={(e) => {
-                  if (e.key === "Enter") saveGitToken();
+            <div className="settings-section-title">{t("settings.downloads")}</div>
+            <p className="settings-help">{t("settings.downloadsHelp")}</p>
+            <div className="settings-list">
+              {(settings?.download_sources ?? []).length === 0 ? (
+                <div className="settings-empty">
+                  {t("settings.noDownloadFolders")}
+                </div>
+              ) : (
+                (settings?.download_sources ?? []).map((dir) => (
+                  <div key={dir} className="settings-row" style={{ gap: 6 }}>
+                    <span
+                      style={{
+                        flex: 1,
+                        overflow: "hidden",
+                        textOverflow: "ellipsis",
+                        whiteSpace: "nowrap",
+                        fontSize: 12,
+                      }}
+                      title={dir}
+                    >
+                      {dir}
+                    </span>
+                    <button
+                      type="button"
+                      onClick={() =>
+                        void updateSettings({
+                          download_sources: (settings?.download_sources ?? []).filter(
+                            (d) => d !== dir,
+                          ),
+                        })
+                      }
+                      title={t("settings.removeFolderTitle")}
+                    >
+                      {t("common.remove")}
+                    </button>
+                  </div>
+                ))
+              )}
+            </div>
+            <div className="settings-link-row">
+              <button
+                type="button"
+                onClick={() => {
+                  void (async () => {
+                    const picked = await openDialog({
+                      directory: true,
+                      multiple: false,
+                    }).catch(() => null);
+                    if (!picked || Array.isArray(picked)) return;
+                    const current = settings?.download_sources ?? [];
+                    if (current.includes(picked)) return;
+                    void updateSettings({ download_sources: [...current, picked] });
+                  })();
                 }}
-              />
-            </label>
+              >
+                {t("settings.addDownloadFolder")}
+              </button>
+            </div>
 
-            <div className="settings-link-row">
-              <button type="button" onClick={() => setPanel("global")}>Global Apps...</button>
-              <button type="button" onClick={() => setPanel("filetypes")}>File Type Apps...</button>
-              {ollamaInstalled && (
-                <button type="button" onClick={() => setPanel("ollama")}>Ollama...</button>
-              )}
-              <button type="button" onClick={() => setPanel("shortcuts")}>Keyboard Shortcuts...</button>
-              <button type="button" onClick={() => setPanel("help")}>Feature Guide...</button>
+            <div className="settings-section-title">{t("settings.usageStats")}</div>
+            <ToggleCard
+              label={t("settings.dailyRecap")}
+              checked={settings?.daily_stats_recap ?? true}
+              onChange={(e) => void updateSettings({ daily_stats_recap: e.target.checked })}
+              help={t("settings.dailyRecapHelp")}
+            />
+            <button
+              type="button"
+              className="btn-primary btn-block"
+              onClick={() => {
+                onClose();
+                window.dispatchEvent(new CustomEvent(OPEN_STATS_EVENT));
+              }}
+            >
+              {t("settings.openUsageStats")}
+            </button>
+
+            <div className="settings-section-title">{t("settings.moreSettings")}</div>
+            <div className="settings-nav-list">
+              {SETTINGS_NAV.map((panelKind) => (
+                <button
+                  key={panelKind}
+                  type="button"
+                  className="settings-nav-item"
+                  onClick={() => setPanel(panelKind)}
+                >
+                  <span className="settings-nav-item-title">
+                    {t(`nav.${panelKind}.title` as TranslationKey)}
+                  </span>
+                  <span className="settings-nav-item-blurb">
+                    {t(`nav.${panelKind}.blurb` as TranslationKey)}
+                  </span>
+                </button>
+              ))}
             </div>
           </>
         )}
         {panel === "global" && <GlobalAppsSettings onBack={() => setPanel("main")} />}
         {panel === "filetypes" && <FileTypeSettings onBack={() => setPanel("main")} />}
         {panel === "ollama" && <OllamaPanel onBack={() => setPanel("main")} />}
+        {panel === "agents" && <AgentsPanel onBack={() => setPanel("main")} />}
         {panel === "shortcuts" && <ShortcutsSettings onBack={() => setPanel("main")} />}
+        {panel === "git" && <GitHostingSettings onBack={() => setPanel("main")} />}
+        {panel === "vpn" && <VpnAutoConnectSettings onBack={() => setPanel("main")} />}
+        {panel === "remoteHosts" && <RemoteHostsSettings onBack={() => setPanel("main")} />}
+        {panel === "archive" && <ArchivedProjectsPanel onBack={() => setPanel("main")} />}
+        {panel === "scaffoldRepair" && <ScaffoldRepairPanel onBack={() => setPanel("main")} />}
         {panel === "help" && <HelpPanel onBack={() => setPanel("main")} />}
+       </div>
       </div>
     </div>
   );
diff --git a/src/components/layout/SettingsSubPanels.tsx b/src/components/layout/SettingsSubPanels.tsx
index 7545b88..1caf622 100644
--- a/src/components/layout/SettingsSubPanels.tsx
+++ b/src/components/layout/SettingsSubPanels.tsx
@@ -1,9 +1,22 @@
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
+import { Toggle } from "../common/Toggle";
+import { listen } from "@tauri-apps/api/event";
 import { open } from "@tauri-apps/plugin-dialog";
 import { GLOBAL_APP_ROLES } from "./GlobalAppBar";
+import { Dropdown } from "../common/Dropdown";
 import { useSettingsStore } from "../../stores/settings";
+import { PLATFORM } from "../../lib/platform";
+import { runInstallInTab, type InstallShellKind } from "../../lib/installCommand";
+import {
+  codexHookNeedsTrust,
+  openCodexHooksTab,
+  type CodexHookState,
+} from "../../lib/codexHooks";
 import type { GlobalAppEntry } from "../../types";
+import { parseSshAddress } from "../projects/scaffold";
+import { useProjectsStore } from "../../stores/projects";
+import { useT, type TranslationKey } from "../../lib/i18n";
 
 interface OllamaModelInfo {
   name: string;
@@ -15,14 +28,68 @@ interface OllamaModelInfo {
   size_vram: number;
 }
 
-interface CatalogEntry {
+/** One row from the live Ollama registry search (mirrors backend RegistryModel). */
+interface RegistryModel {
   name: string;
   description: string;
-  tags: string[];
-  size_hint: string;
+  capabilities: string[];
+  sizes: string[];
+  pulls: string;
+  updated: string;
+}
+
+/** Capability filters, mapped to Ollama's `c=` search param. */
+const REGISTRY_TYPES = ["tools", "vision", "thinking", "embedding", "audio"] as const;
+
+/** Parameter-size buckets (billions) for client-side filtering of results. */
+const SIZE_BUCKETS: { key: string; label: string; lo: number; hi: number }[] = [
+  { key: "xs", label: "<1B", lo: 0, hi: 1 },
+  { key: "sm", label: "1–4B", lo: 1, hi: 4 },
+  { key: "md", label: "4–9B", lo: 4, hi: 9 },
+  { key: "lg", label: "9–32B", lo: 9, hi: 32 },
+  { key: "xl", label: "32B+", lo: 32, hi: Infinity },
+];
+
+/** Largest parsable parameter size (billions) among a model's tags, for sorting. */
+function modelMaxParamsB(sizes: string[]): number {
+  const ps = sizes.map(tagParamsB).filter((n): n is number => n !== null);
+  return ps.length ? Math.max(...ps) : 0;
+}
+
+/** Parse a human pull count ("65.8K", "30M", "1,203") into a number for sorting. */
+function parsePulls(s: string): number {
+  const m = /^([\d.,]+)\s*([kmbg]?)/i.exec(s.trim());
+  if (!m) return 0;
+  const n = parseFloat(m[1].replace(/,/g, ""));
+  if (!isFinite(n)) return 0;
+  const mult: Record<string, number> = { k: 1e3, m: 1e6, b: 1e9, g: 1e9 };
+  return n * (mult[m[2].toLowerCase()] ?? 1);
+}
+
+/** Sort options for the registry browser. "popular"/"newest" map to Ollama's
+ *  server-side `o=` param; the rest reorder the loaded rows client-side. */
+const SORT_OPTIONS = [
+  { key: "popular", labelKey: "ollama.sort.popular" },
+  { key: "newest", labelKey: "ollama.sort.newest" },
+  { key: "pulls", labelKey: "ollama.sort.pulls" },
+  { key: "name", labelKey: "ollama.sort.name" },
+  { key: "params-asc", labelKey: "ollama.sort.sizeAsc" },
+  { key: "params-desc", labelKey: "ollama.sort.sizeDesc" },
+] as const satisfies { key: string; labelKey: TranslationKey }[];
+type SortKey = (typeof SORT_OPTIONS)[number]["key"];
+
+/** True if any of a model's size tags falls into any selected bucket. */
+function matchesSizeBuckets(sizes: string[], selected: Set<string>): boolean {
+  if (selected.size === 0) return true;
+  const buckets = SIZE_BUCKETS.filter((b) => selected.has(b.key));
+  return sizes.some((s) => {
+    const p = tagParamsB(s);
+    return p !== null && buckets.some((b) => p >= b.lo && p < b.hi);
+  });
 }
 
 export function GlobalAppsSettings({ onBack }: { onBack: () => void }) {
+  const t = useT();
   const { settings, updateSettings } = useSettingsStore();
   const [apps, setApps] = useState<Record<string, GlobalAppEntry>>(settings?.global_apps ?? {});
 
@@ -50,26 +117,27 @@ export function GlobalAppsSettings({ onBack }: { onBack: () => void }) {
   return (
     <>
       <div className="settings-title-row">
-        <h2>Global Apps</h2>
-        <button type="button" onClick={onBack}>Back</button>
+        <h2>{t("globalApps.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
       </div>
-      <p className="settings-help">Apps that stay visible across workspaces. Checked apps appear in the top toolbar.</p>
+      <p className="settings-help">{t("globalApps.help")}</p>
       <div className="settings-list">
         {GLOBAL_APP_ROLES.map((role) => {
           const entry = apps[role.key] ?? { exec: "", visible: true };
+          const roleLabel = t(role.labelKey);
           return (
             <div className="global-app-settings-row" key={role.key}>
-              <input
-                type="checkbox"
+              <Toggle
+                size="sm"
                 checked={entry.visible !== false}
                 onChange={(e) => updateRole(role.key, { visible: e.target.checked })}
-                title={`Show ${role.label}`}
+                title={t("globalApps.showRole", { role: roleLabel })}
               />
               <span className="settings-role-icon" aria-hidden>{role.fallback}</span>
-              <span className="settings-role-label">{role.label}</span>
+              <span className="settings-role-label">{roleLabel}</span>
               <input
                 value={entry.exec}
-                placeholder="not found"
+                placeholder={t("globalApps.notFoundPlaceholder")}
                 onChange={(e) => setApps({ ...apps, [role.key]: { ...entry, exec: e.target.value } })}
                 onBlur={(e) => updateRole(role.key, { exec: e.target.value.trim() })}
                 onKeyDown={(e) => {
@@ -86,6 +154,7 @@ export function GlobalAppsSettings({ onBack }: { onBack: () => void }) {
 }
 
 export function FileTypeSettings({ onBack }: { onBack: () => void }) {
+  const t = useT();
   const [apps, setApps] = useState<Record<string, string>>({});
   const [draft, setDraft] = useState({ ext: "", app: "" });
   const [error, setError] = useState("");
@@ -125,10 +194,10 @@ export function FileTypeSettings({ onBack }: { onBack: () => void }) {
   return (
     <>
       <div className="settings-title-row">
-        <h2>File Type Apps</h2>
-        <button type="button" onClick={onBack}>Back</button>
+        <h2>{t("filetypes.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
       </div>
-      <p className="settings-help">Double-clicking a project file opens it with the app below.</p>
+      <p className="settings-help">{t("filetypes.help")}</p>
       {error && <div className="project-dialog-error">{error}</div>}
       <div className="settings-list">
         {Object.entries(apps).sort(([a], [b]) => a.localeCompare(b)).map(([ext, app]) => (
@@ -156,7 +225,7 @@ export function FileTypeSettings({ onBack }: { onBack: () => void }) {
                 const { [ext]: _removed, ...rest } = apps;
                 saveApps(rest);
               }}
-              title="Remove"
+              title={t("common.remove")}
             >
               ×
             </button>
@@ -165,19 +234,148 @@ export function FileTypeSettings({ onBack }: { onBack: () => void }) {
         <div className="filetype-settings-row">
           <input
             value={draft.ext}
-            placeholder=".ext"
+            placeholder={t("filetypes.extPlaceholder")}
             onChange={(e) => setDraft({ ...draft, ext: e.target.value })}
           />
           <input
             value={draft.app}
-            placeholder="app command"
+            placeholder={t("filetypes.appPlaceholder")}
             onChange={(e) => setDraft({ ...draft, app: e.target.value })}
             onKeyDown={(e) => {
               if (e.key === "Enter") addEntry();
             }}
           />
-          <button type="button" onClick={addEntry}>Add</button>
+          <button type="button" onClick={addEntry}>{t("common.add")}</button>
+        </div>
+      </div>
+    </>
+  );
+}
+
+/**
+ * "Remote Connections" settings panel: a standard/default remote path per SSH
+ * host, set once here instead of re-browsing it every time. Consulted by
+ * `useRemoteSession`'s `resolveStartDir` whenever a connect/browse flow would
+ * otherwise fall back to the SSH-reported home directory — so a host with a
+ * preferred working directory (e.g. a projects folder that isn't `$HOME`)
+ * opens there every time, for both new remote projects and reconnects.
+ *
+ * Distinct from the auto-remembered "recently used paths" dropdown in the New
+ * Project dialog (`remote_paths.json`): that list grows on its own from every
+ * folder you browse to, while this is one explicit choice per host, edited
+ * only here.
+ */
+export function RemoteHostsSettings({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const [defaults, setDefaults] = useState<Record<string, string> | null>(null);
+  const [draftHost, setDraftHost] = useState("");
+  const [draftPath, setDraftPath] = useState("");
+  const [error, setError] = useState("");
+
+  const refresh = () => {
+    invoke<Record<string, string>>("remote_list_default_paths")
+      .then(setDefaults)
+      .catch((e) => setError(String(e)));
+  };
+  useEffect(refresh, []);
+
+  // Hosts seen before (recent SSH addresses + any active remote project),
+  // offered as suggestions when adding a new entry — typing the exact host is
+  // still required (paths are host-specific and a typo would silently do
+  // nothing), this just saves re-typing one you've already connected to.
+  const knownHosts = useProjectsStore((s) => s.projects);
+  const [hostSuggestions, setHostSuggestions] = useState<string[]>([]);
+  useEffect(() => {
+    invoke<string[]>("ssh_list_addresses")
+      .then((addrs) => {
+        const fromAddrs = addrs.map((a) => parseSshAddress(a)?.host).filter((h): h is string => !!h);
+        const fromProjects = knownHosts.map((p) => p.remote?.host).filter((h): h is string => !!h);
+        const seen = new Set<string>();
+        const out: string[] = [];
+        for (const h of [...fromAddrs, ...fromProjects]) {
+          const key = h.toLowerCase();
+          if (seen.has(key)) continue;
+          seen.add(key);
+          out.push(h);
+        }
+        setHostSuggestions(out);
+      })
+      .catch(() => setHostSuggestions([]));
+  }, [knownHosts]);
+
+  const savePath = (host: string, path: string) => {
+    setError("");
+    invoke<void>("remote_set_default_path", { host, path })
+      .then(refresh)
+      .catch((e) => setError(String(e)));
+  };
+
+  const removeHost = (host: string) => savePath(host, "");
+
+  const addEntry = () => {
+    const host = draftHost.trim();
+    const path = draftPath.trim();
+    if (!host || !path) return;
+    savePath(host, path);
+    setDraftHost("");
+    setDraftPath("");
+  };
+
+  const entries = defaults ? Object.entries(defaults).sort(([a], [b]) => a.localeCompare(b)) : [];
+
+  return (
+    <>
+      <div className="settings-title-row">
+        <h2>{t("nav.remoteHosts.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+      </div>
+      <p className="settings-help">{t("remoteHosts.help")}</p>
+      {error && <div className="project-dialog-error">{error}</div>}
+      {defaults === null ? (
+        <p className="settings-help">{t("common.loading")}</p>
+      ) : entries.length === 0 ? (
+        <div className="settings-empty">{t("remoteHosts.empty")}</div>
+      ) : (
+        <div className="settings-list">
+          {entries.map(([host, path]) => (
+            <div className="remote-host-settings-row" key={host}>
+              <span className="settings-role-label" title={host}>{host}</span>
+              <input
+                value={path}
+                onChange={(e) => setDefaults((d) => (d ? { ...d, [host]: e.target.value } : d))}
+                onBlur={(e) => savePath(host, e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") savePath(host, e.currentTarget.value);
+                }}
+              />
+              <button type="button" onClick={() => removeHost(host)} title={t("common.remove")}>
+                ×
+              </button>
+            </div>
+          ))}
         </div>
+      )}
+      <div className="remote-host-settings-row remote-host-settings-add">
+        <input
+          list="remote-host-suggestions"
+          value={draftHost}
+          placeholder={t("remoteHosts.hostPlaceholder")}
+          onChange={(e) => setDraftHost(e.target.value)}
+        />
+        <datalist id="remote-host-suggestions">
+          {hostSuggestions.map((h) => (
+            <option key={h} value={h} />
+          ))}
+        </datalist>
+        <input
+          value={draftPath}
+          placeholder={t("remoteHosts.pathPlaceholder")}
+          onChange={(e) => setDraftPath(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") addEntry();
+          }}
+        />
+        <button type="button" onClick={addEntry}>{t("common.add")}</button>
       </div>
     </>
   );
@@ -189,13 +387,596 @@ function fmtBytes(n: number): string {
   return (n / (1024 * 1024 * 1024)).toFixed(1) + " GB";
 }
 
+/**
+ * Parameter count (in billions) parsed from a catalog tag like "1b", "0.5b",
+ * "135m", "405b". Non-parameter tags (quantization labels such as "q4_K_M",
+ * "latest") yield null so they don't affect size sorting.
+ */
+function tagParamsB(tag: string): number | null {
+  const m = /^(\d+(?:\.\d+)?)\s*([bm])$/i.exec(tag.trim());
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  return m[2].toLowerCase() === "m" ? n / 1000 : n;
+}
+
+/** Official, distro-agnostic install command — kept in sync with the backend. */
+/** One agent CLI + its install status (mirrors backend `AgentInfo`). */
+interface AgentInfo {
+  id: string;
+  label: string;
+  bin: string;
+  /** Install command for the host OS; empty when no one-line installer exists. */
+  install_cmd: string;
+  /** Shell the command runs in: "bash", "PowerShell", or "PowerShell or Command Prompt". */
+  shell: string;
+  /** Machine-readable shell selection; display labels are not executable policy. */
+  shell_kind: InstallShellKind;
+  /** `npm uninstall -g <pkg>` for an npm-installed agent; empty otherwise. */
+  uninstall_cmd: string;
+  docs: string;
+  installed: boolean;
+}
+
+/**
+ * Per-OS command that installs Node.js (and with it `npm`). Most agent CLIs
+ * install via `npm install -g …`, so when `npm` is missing the Manage Agents
+ * panel offers this first. nvm installs Node without administrator rights and
+ * works identically on Linux and macOS; Windows uses winget (present on Windows
+ * 10/11) and runs in either PowerShell or Command Prompt.
+ */
+const NODE_INSTALL: Record<
+  "windows" | "macos" | "linux",
+  { command: string; shell: string; shellKind: InstallShellKind }
+> = {
+  linux: {
+    command:
+      'curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash && export NVM_DIR="$HOME/.nvm" && . "$NVM_DIR/nvm.sh" && nvm install --lts',
+    shell: "bash",
+    shellKind: "bash",
+  },
+  macos: {
+    command:
+      'curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash && export NVM_DIR="$HOME/.nvm" && . "$NVM_DIR/nvm.sh" && nvm install --lts',
+    shell: "bash",
+    shellKind: "bash",
+  },
+  windows: {
+    command: "winget install OpenJS.NodeJS.LTS",
+    shell: "PowerShell or Command Prompt",
+    shellKind: "default",
+  },
+};
+const NODE_DOWNLOAD_URL = "https://nodejs.org/en/download";
+
+/**
+ * "Codex won't run our session hook" notice for the Manage Agents panel.
+ *
+ * Codex gates user-level hooks behind a one-time trust approval, and an
+ * untrusted one silently never fires — which is why Codex tabs used to restore
+ * into a blank conversation. Eldrun resumes them anyway now (it reconstructs the
+ * session from Codex's rollout logs), but that is a heuristic: it can mix up two
+ * Codex tabs open in the same directory. Enabling the hook makes it exact.
+ *
+ * The contextual hint says the same thing, but it is dismissible for good and is
+ * suppressed outright when hints are off — so this is where a user who waved it
+ * away can still find the fix.
+ *
+ * Rendered nested inside the Codex row of Manage Agents (not as a free-floating
+ * top-of-panel notice) — the hook is Codex-specific, so it belongs with the
+ * agent it's about, same as the Remove/Reinstall actions.
+ */
+function CodexHookNotice() {
+  const t = useT();
+  // null = still probing.
+  const [state, setState] = useState<CodexHookState | null>(null);
+  const recheck = () =>
+    invoke<CodexHookState>("codex_hook_status").then(setState).catch(() => setState(null));
+  useEffect(() => void recheck(), []);
+
+  // Healthy, absent, or still probing → nothing to say.
+  if (!codexHookNeedsTrust(state)) return null;
+
+  return (
+    <div className="agent-codex-hook">
+      <div className="settings-section-title">
+        {t("agents.codexHookLabel")}{" "}
+        <span className="ollama-status-text">
+          {state === "disabled" ? t("agents.codexHookDisabled") : t("agents.codexHookNotTrusted")}
+        </span>
+      </div>
+      <p className="settings-help">
+        {t("agents.codexHookHelpPre")} <strong>eldrun_session_start</strong>{" "}
+        {t("agents.codexHookHelpPost")}{" "}
+        <code>/hooks</code> {t("agents.codexHookHelpPost2")}
+      </p>
+      <div className="ollama-install-cmd-row">
+        <code className="ollama-install-cmd">/hooks</code>
+        <button
+          type="button"
+          className="ollama-action-btn primary"
+          onClick={openCodexHooksTab}
+        >
+          {t("agents.openInCodex")}
+        </button>
+        <button type="button" className="ollama-action-btn" onClick={() => void recheck()}>
+          {t("common.recheck")}
+        </button>
+      </div>
+    </div>
+  );
+}
+
+/**
+ * Claude's `--remote-control` toggle, moved here from the main Settings panel
+ * (Group: nav "Manage Agents") since the flag only affects `claude` agent
+ * tabs — it belongs with the agent it's about, same reasoning as
+ * `CodexHookNotice`. Rendered nested inside the Claude row.
+ */
+function ClaudeRemoteControlNotice() {
+  const t = useT();
+  const { settings, updateSettings } = useSettingsStore();
+  return (
+    <div className="settings-toggle-card agent-claude-remote-control">
+      <label className="settings-toggle-card-row">
+        <span>{t("settings.claudeRemote")}</span>
+        <Toggle
+          checked={settings?.agent_remote_control ?? true}
+          onChange={(e) => void updateSettings({ agent_remote_control: e.target.checked })}
+        />
+      </label>
+      <p className="settings-help">
+        {t("settings.claudeRemoteHelp1")} <code>--remote-control</code>{" "}
+        {t("settings.claudeRemoteHelp2")}
+      </p>
+    </div>
+  );
+}
+
+/**
+ * "Install Node/npm first" helper for the Manage Agents panel. Most agent CLIs
+ * install through `npm`, so when `npm` isn't on the host's PATH this points the
+ * user at the one-click, no-admin Node install for their OS (and stays hidden
+ * once npm is detected). Follows Eldrun's install-via-terminal-tab policy.
+ */
+function NodeRuntimeNotice() {
+  const t = useT();
+  // null = still probing; true/false = npm present or not.
+  const [hasNpm, setHasNpm] = useState<boolean | null>(null);
+  const recheck = () =>
+    invoke<boolean>("npm_is_installed").then(setHasNpm).catch(() => setHasNpm(true));
+  useEffect(() => void recheck(), []);
+
+  // While probing, or once npm is present, there is nothing to nudge about.
+  if (hasNpm !== false) return null;
+
+  const { command, shell, shellKind } = NODE_INSTALL[PLATFORM];
+  return (
+    <div className="ollama-vibe-section agent-list-entry">
+      <div className="settings-section-title">
+        Node.js / npm{" "}
+        <span className="ollama-status-text">{t("agents.nodeNotDetected")}</span>
+      </div>
+      <p className="settings-help">
+        {t("agents.nodeHelpPre")} <code>npm</code> {t("agents.nodeHelpMid")}{" "}
+        <strong>{shell}</strong> {t("agents.nodeHelpPost")}
+      </p>
+      <div className="ollama-install-cmd-row">
+        <code className="ollama-install-cmd">{command}</code>
+        <button
+          type="button"
+          className="ollama-action-btn primary"
+          onClick={() => runInstallInTab("Install Node.js (npm)", command, shellKind)}
+        >
+          {t("agents.runInTerminal")}
+        </button>
+        <button type="button" className="ollama-action-btn" onClick={() => void recheck()}>
+          {t("common.recheck")}
+        </button>
+      </div>
+      <p className="settings-help">
+        {t("agents.nodeManualPre")}{" "}
+        <a href={NODE_DOWNLOAD_URL} target="_blank" rel="noreferrer">
+          {t("agents.nodeDownloads")}
+        </a>
+        .
+      </p>
+    </div>
+  );
+}
+
+/**
+ * "Manage Agents" panel: detect and one-click-install the AI coding-agent CLIs
+ * Eldrun can launch as agent tabs (Claude, Codex, Gemini, Mistral/vibe, Aider,
+ * OpenCode, Cursor, Copilot, Grok, Qwen, OpenClaw). The
+ * registry lives in the backend (`commands::agents`); this just renders each
+ * entry with an install button, a live install log, and a manual fallback.
+ */
+export function AgentsPanel({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const { settings, updateSettings } = useSettingsStore();
+  const disabledAgents = settings?.disabled_agents ?? [];
+  const setAgentDisabled = (id: string, disabled: boolean) => {
+    const next = disabled
+      ? [...disabledAgents, id]
+      : disabledAgents.filter((a) => a !== id);
+    void updateSettings({ disabled_agents: next });
+  };
+  const [agents, setAgents] = useState<AgentInfo[] | null>(null);
+  // The agent id whose installer is currently running (only one at a time).
+  const [installing, setInstalling] = useState<string | null>(null);
+  // The agent id currently being removed (Remove, or the first half of
+  // Reinstall) — disjoint from `installing` so the two actions never overlap.
+  const [removing, setRemoving] = useState<string | null>(null);
+  // Per-agent live install log, keyed by agent id.
+  const [logs, setLogs] = useState<Record<string, string>>({});
+  const [errors, setErrors] = useState<Record<string, string>>({});
+  const logRef = useRef<HTMLPreElement>(null);
+
+  const refresh = () => {
+    invoke<AgentInfo[]>("list_agents").then(setAgents).catch(() => setAgents([]));
+  };
+  useEffect(refresh, []);
+
+  // Keep the live install log pinned to its latest line.
+  useEffect(() => {
+    const el = logRef.current;
+    if (el) el.scrollTop = el.scrollHeight;
+  }, [logs, installing]);
+
+  const installAgent = async (id: string) => {
+    setInstalling(id);
+    setErrors(({ [id]: _drop, ...rest }) => rest);
+    setLogs((l) => ({ ...l, [id]: "" }));
+    // Stream the installer's output, filtering to this agent's events.
+    const unlisten = await listen<{ id: string; line: string }>(
+      "agent-install-progress",
+      (e) => {
+        if (e.payload.id !== id) return;
+        setLogs((l) => ({
+          ...l,
+          [id]: l[id] ? `${l[id]}\n${e.payload.line}` : e.payload.line,
+        }));
+      },
+    );
+    try {
+      await invoke<string>("install_agent", { id });
+      refresh();
+    } catch (err) {
+      setErrors((e) => ({ ...e, [id]: String(err) }));
+    } finally {
+      unlisten();
+      setInstalling(null);
+    }
+  };
+
+  // Removes the detected binary (an npm-based agent goes through `npm
+  // uninstall -g` instead, so the package doesn't linger — see `uninstall_agent`).
+  // Returns whether it succeeded, so `reinstallAgent` knows whether to proceed.
+  const removeAgent = async (id: string): Promise<boolean> => {
+    setRemoving(id);
+    setErrors(({ [id]: _drop, ...rest }) => rest);
+    try {
+      await invoke<string>("uninstall_agent", { id });
+      refresh();
+      return true;
+    } catch (err) {
+      setErrors((e) => ({ ...e, [id]: String(err) }));
+      return false;
+    } finally {
+      setRemoving(null);
+    }
+  };
+
+  // Remove then immediately re-run the official installer — the one-click fix
+  // for an install that half-succeeded (binary present but broken) or that
+  // Eldrun's stale detection missed (see paths.rs's Windows install-dir list).
+  const reinstallAgent = async (id: string) => {
+    if (await removeAgent(id)) await installAgent(id);
+  };
+
+  const recheck = (id: string) => {
+    void invoke<boolean>("agent_is_installed", { id })
+      .then((ok) => {
+        setAgents((prev) =>
+          prev?.map((a) => (a.id === id ? { ...a, installed: ok } : a)) ?? prev,
+        );
+        if (!ok) {
+          setErrors((e) => ({
+            ...e,
+            [id]: t("agents.stillNotDetected"),
+          }));
+        }
+      })
+      .catch(() => {});
+  };
+
+  return (
+    <>
+      <div className="settings-title-row">
+        <h2>{t("nav.agents.title")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+      </div>
+      <p className="settings-help">
+        {t("agents.help1")} <strong>+</strong> {t("agents.help2")} <code>npm</code>{" "}
+        {t("agents.help3")} <code>PATH</code> {t("agents.help4")}
+      </p>
+      <NodeRuntimeNotice />
+      {agents === null ? (
+        <p className="settings-help">{t("agents.checkingInstalled")}</p>
+      ) : (
+        <div className="settings-list">
+          {[...agents]
+            .sort((a, b) => Number(b.installed) - Number(a.installed))
+            .map((a) => (
+            <div key={a.id} className="ollama-vibe-section agent-list-entry">
+              <div className="agent-list-entry-head">
+                <div className="settings-section-title">
+                  {a.label}{" "}
+                  {a.installed ? (
+                    <span className="ollama-status-text">
+                      <span className="ollama-status-dot running" /> {t("agents.installed")}
+                    </span>
+                  ) : (
+                    <span className="ollama-status-text">{t("agents.notInstalled")}</span>
+                  )}
+                </div>
+                {a.installed && (
+                  <label
+                    className="agent-disable-toggle"
+                    title={t("agents.disableToggleTitle")}
+                  >
+                    <Toggle
+                      checked={!disabledAgents.includes(a.id)}
+                      onChange={(e) => setAgentDisabled(a.id, !e.target.checked)}
+                      size="sm"
+                      aria-label={t(
+                        disabledAgents.includes(a.id) ? "agents.disableAriaEnable" : "agents.disableAriaDisable",
+                        { label: a.label },
+                      )}
+                    />
+                    {disabledAgents.includes(a.id) ? t("agents.disabled") : t("agents.enabled")}
+                  </label>
+                )}
+              </div>
+              {a.installed && (
+                <>
+                  <div className="ollama-install-cmd-row">
+                    <button
+                      type="button"
+                      className="ollama-action-btn"
+                      disabled={installing !== null || removing !== null}
+                      title={t("agents.removeTitle")}
+                      onClick={() => void removeAgent(a.id)}
+                    >
+                      {removing === a.id ? t("agents.removing") : t("agents.remove")}
+                    </button>
+                    <button
+                      type="button"
+                      className="ollama-action-btn"
+                      disabled={installing !== null || removing !== null}
+                      title={t("agents.reinstallTitle")}
+                      onClick={() => void reinstallAgent(a.id)}
+                    >
+                      {removing === a.id || installing === a.id ? t("agents.reinstalling") : t("agents.reinstall")}
+                    </button>
+                  </div>
+                  {errors[a.id] && (
+                    <div className="project-dialog-error">{errors[a.id]}</div>
+                  )}
+                  {/* npm-installed agents only (uninstall_cmd empty otherwise):
+                      npm's global dir is root-owned on a system-wide Linux
+                      Node install, so Remove can fail with EACCES — the same
+                      run-in-a-terminal escape hatch the install flow offers,
+                      so the user can prefix `sudo` themselves. */}
+                  {a.uninstall_cmd !== "" && (
+                    <>
+                      <p className="settings-help">
+                        {t("agents.permissionHelpPre")}{" "}
+                        <strong>{a.shell}</strong> {t("agents.permissionHelpPost")}{" "}
+                        <code>sudo</code> {t("agents.permissionHelpPost2")}
+                      </p>
+                      <div className="ollama-install-cmd-row">
+                        <code className="ollama-install-cmd">{a.uninstall_cmd}</code>
+                        <button
+                          type="button"
+                          className="ollama-action-btn"
+                          onClick={() =>
+                            runInstallInTab(`Remove ${a.label}`, a.uninstall_cmd, a.shell_kind)
+                          }
+                        >
+                          {t("agents.runInTerminal")}
+                        </button>
+                      </div>
+                    </>
+                  )}
+                </>
+              )}
+              {!a.installed && (
+                <>
+                  {/* Auto-install runs the official installer via `sh` on
+                      Linux/macOS and via PowerShell/cmd on Windows. It is only
+                      hidden when this platform has no one-line installer at all
+                      (install_cmd empty — Windows-only case, see AgentInfo);
+                      the docs-link fallback below covers that. */}
+                  {a.install_cmd !== "" && (
+                    <>
+                      <div className="ollama-install-cmd-row">
+                        <button
+                          type="button"
+                          className="ollama-action-btn primary"
+                          disabled={installing !== null}
+                          onClick={() => void installAgent(a.id)}
+                        >
+                          {installing === a.id ? t("agents.installing") : t("agents.installLabel", { label: a.label })}
+                        </button>
+                        {installing === a.id && (
+                          <span className="ollama-status-text">{t("agents.runningInstaller")}</span>
+                        )}
+                      </div>
+                      {logs[a.id] && (
+                        <pre
+                          className="ollama-install-log"
+                          ref={installing === a.id ? logRef : undefined}
+                        >
+                          {logs[a.id]}
+                        </pre>
+                      )}
+                      {errors[a.id] && (
+                        <div className="project-dialog-error">{errors[a.id]}</div>
+                      )}
+                    </>
+                  )}
+                  {a.install_cmd ? (
+                    <>
+                      {/* Whenever install_cmd is non-empty the one-click button
+                          above is also shown, so this is always the "or". */}
+                      <p className="settings-help">
+                        {t("agents.orInstallInShellPre")} <strong>{a.shell}</strong>{" "}
+                        {t("agents.orInstallInShellPost")}
+                      </p>
+                      <div className="ollama-install-cmd-row">
+                        <code className="ollama-install-cmd">{a.install_cmd}</code>
+                        <button
+                          type="button"
+                          className="ollama-action-btn primary"
+                          onClick={() =>
+                            runInstallInTab(`Install ${a.label}`, a.install_cmd, a.shell_kind)
+                          }
+                        >
+                          {t("agents.runInTerminal")}
+                        </button>
+                        <button
+                          type="button"
+                          className="ollama-action-btn"
+                          disabled={installing !== null}
+                          onClick={() => recheck(a.id)}
+                        >
+                          {t("common.recheck")}
+                        </button>
+                      </div>
+                    </>
+                  ) : (
+                    <p className="settings-help">
+                      {t("agents.noWindowsInstallerPre")}{" "}
+                      <a href={a.docs} target="_blank" rel="noreferrer">
+                        {t("agents.installDocs")}
+                      </a>
+                      {t("agents.noWindowsInstallerPost")}{" "}
+                      <button
+                        type="button"
+                        className="ollama-action-btn"
+                        disabled={installing !== null}
+                        onClick={() => recheck(a.id)}
+                      >
+                        {t("common.recheck")}
+                      </button>
+                      .
+                    </p>
+                  )}
+                </>
+              )}
+              {a.id === "codex" && <CodexHookNotice />}
+              {a.id === "claude" && <ClaudeRemoteControlNotice />}
+            </div>
+          ))}
+        </div>
+      )}
+    </>
+  );
+}
+
+// Fallback install command shown before the OS-specific strategy loads from the
+// backend. The real command comes from `ollama_install_strategy` (winget on
+// Windows, the install script on Linux/macOS).
+const OLLAMA_INSTALL_CMD_FALLBACK = "curl -fsSL https://ollama.com/install.sh | sh";
+const OLLAMA_DOWNLOAD_URL = "https://ollama.com/download";
+// Fallback Vibe install command shown before the OS-specific strategy loads from
+// the backend. The real command comes from `vibe_install_strategy` (a uv-based
+// PowerShell command on Windows, the install script on Linux/macOS).
+const VIBE_INSTALL_CMD = "curl -LsSf https://mistral.ai/vibe/install.sh | bash";
+
+/** OS-dependent Vibe install guidance (mirrors backend `VibeInstallStrategy`). */
+interface VibeInstallStrategy {
+  os: string; // "windows" | "macos" | "linux" | "unknown"
+  command: string;
+  auto: boolean;
+  docs: string;
+}
+
+/** OS-dependent Ollama install guidance (mirrors backend `OllamaInstallStrategy`). */
+interface OllamaInstallStrategy {
+  os: string; // "windows" | "macos" | "linux" | "unknown"
+  command: string;
+  auto: boolean;
+  download_url: string;
+}
+
 export function OllamaPanel({ onBack }: { onBack: () => void }) {
+  const t = useT();
+  const [installed, setInstalled] = useState<boolean | null>(null);
+  const [installing, setInstalling] = useState(false);
+  const [installLog, setInstallLog] = useState<string | null>(null);
+  // OS-dependent install strategy (command + whether one-click install works).
+  const [strategy, setStrategy] = useState<OllamaInstallStrategy | null>(null);
+  const installLogRef = useRef<HTMLPreElement>(null);
+  // Vibe (local-model agent runtime) — required to launch Local Model tabs.
+  const [vibeInstalled, setVibeInstalled] = useState<boolean | null>(null);
+  // OS-dependent Vibe install command (uv/PowerShell on Windows, script elsewhere).
+  const [vibeStrategy, setVibeStrategy] = useState<VibeInstallStrategy | null>(null);
+  const [vibeInstalling, setVibeInstalling] = useState(false);
+  const [vibeInstallLog, setVibeInstallLog] = useState<string | null>(null);
+  const vibeInstallLogRef = useRef<HTMLPreElement>(null);
   const [models, setModels] = useState<OllamaModelInfo[]>([]);
-  const [catalog, setCatalog] = useState<CatalogEntry[]>([]);
   const [serverRunning, setServerRunning] = useState<boolean | null>(null);
   const [loading, setLoading] = useState(true);
   const [busy, setBusy] = useState<Record<string, boolean>>({});
   const [error, setError] = useState<string | null>(null);
+  // Models currently being loaded into memory, keyed by name. Driven by the
+  // global `ollama-load-progress` events so a load started from the brain menu
+  // shows here too; Ollama streams no load percentage, so it's indeterminate.
+  const [loadingMem, setLoadingMem] = useState<Record<string, boolean>>({});
+  // Per-tag download size from the registry, fetched lazily on hover and cached.
+  const [tagSizes, setTagSizes] = useState<Record<string, number | "loading" | "error">>({});
+  // Free-text "pull any model" field — accepts any registry ref the catalog omits.
+  const [pullName, setPullName] = useState("");
+  // Live download progress per model ref, keyed by the exact ref passed to
+  // `pull_ollama_model`. `pct` is null during non-download phases (manifest,
+  // verify, write) where Ollama reports no byte totals.
+  const [pullProgress, setPullProgress] = useState<
+    Record<string, { pct: number | null; status: string }>
+  >({});
+  // Model refs whose download was interrupted by a previous Eldrun exit/crash,
+  // persisted by the backend. Each can be resumed ("Continue") since Ollama
+  // picks up a partially-fetched model where it left off.
+  const [interrupted, setInterrupted] = useState<string[]>([]);
+  // Model refs the user paused mid-download this session. A paused pull keeps its
+  // partial blobs (so it can be resumed) and offers Resume / Delete.
+  const [paused, setPaused] = useState<Set<string>>(new Set());
+  // Orphaned partial layers in Ollama's blob cache with no recoverable model
+  // name — surfaced only so the user can delete them to reclaim space.
+  const [orphans, setOrphans] = useState<{ digest: string; size: number; path: string }[]>([]);
+  // Live registry browser (ollama.com/search): query, filters, lazy-loaded pages.
+  const [regQuery, setRegQuery] = useState("");
+  const [regQueryLive, setRegQueryLive] = useState(""); // debounced
+  const [regTypes, setRegTypes] = useState<Set<string>>(new Set()); // empty = any
+  const [sortBy, setSortBy] = useState<SortKey>("popular");
+  const [regSizes, setRegSizes] = useState<Set<string>>(new Set());
+  const [regModels, setRegModels] = useState<RegistryModel[]>([]);
+  const [regPage, setRegPage] = useState(0);
+  const [regLoading, setRegLoading] = useState(false);
+  const [regDone, setRegDone] = useState(false);
+  const [regError, setRegError] = useState<string | null>(null);
+  const sentinelRef = useRef<HTMLDivElement | null>(null);
+  const loadMoreRef = useRef<() => void>(() => {});
+
+  // Fetch a tag's registry size once, when the user first hovers it.
+  const fetchTagSize = (fullName: string) => {
+    if (fullName in tagSizes) return;
+    setTagSizes((p) => ({ ...p, [fullName]: "loading" }));
+    invoke<number>("ollama_registry_size", { model: fullName })
+      .then((bytes) => setTagSizes((p) => ({ ...p, [fullName]: bytes })))
+      .catch(() => setTagSizes((p) => ({ ...p, [fullName]: "error" })));
+  };
 
   const refresh = async () => {
     setLoading(true);
@@ -216,11 +997,216 @@ export function OllamaPanel({ onBack }: { onBack: () => void }) {
     }
   };
 
-  useEffect(() => {
-    invoke<CatalogEntry[]>("list_installable_models").then(setCatalog).catch(() => {});
+  // Load installed/running models once Ollama itself is present. When it is
+  // missing we show the install flow instead. The registry browser below loads
+  // independently (it queries ollama.com, not the local server).
+  const loadAfterInstall = () => {
     void refresh();
+  };
+
+  useEffect(() => {
+    void (async () => {
+      const ok = await invoke<boolean>("ollama_is_installed").catch(() => false);
+      setInstalled(ok);
+      if (ok) loadAfterInstall();
+      else setLoading(false);
+    })();
+    // OS-dependent install command/wording for the install panel below.
+    invoke<OllamaInstallStrategy>("ollama_install_strategy").then(setStrategy).catch(() => {});
+    // Vibe is independent of Ollama; check it regardless so its status shows in
+    // both the install-Ollama and main panels.
+    invoke<boolean>("vibe_is_installed").then(setVibeInstalled).catch(() => setVibeInstalled(false));
+    invoke<VibeInstallStrategy>("vibe_install_strategy").then(setVibeStrategy).catch(() => {});
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  // Track live download progress emitted by `pull_ollama_model`.
+  useEffect(() => {
+    const un = listen<{ model: string; status: string; completed: number; total: number }>(
+      "ollama-pull-progress",
+      (e) => {
+        const { model, status, completed, total } = e.payload;
+        // A paused pull stops streaming here — move it out of the live-progress
+        // map and into the paused set so its row offers Resume / Delete.
+        if (status === "paused") {
+          setPullProgress((p) => {
+            const { [model]: _drop, ...rest } = p;
+            return rest;
+          });
+          setPaused((p) => new Set(p).add(model));
+          return;
+        }
+        setPullProgress((p) => ({
+          ...p,
+          [model]: {
+            pct: total > 0 ? Math.min(100, Math.floor((completed / total) * 100)) : null,
+            status,
+          },
+        }));
+      },
+    );
+    return () => {
+      void un.then((f) => f());
+    };
+  }, []);
+
+  // Track in-flight loads-into-memory (from any surface). On success, re-read the
+  // model list so the row flips to its resident state.
+  useEffect(() => {
+    const un = listen<{ model: string; status: string }>("ollama-load-progress", (e) => {
+      const { model, status } = e.payload;
+      setLoadingMem((p) => {
+        if (status === "loading") return { ...p, [model]: true };
+        const { [model]: _drop, ...rest } = p;
+        return rest;
+      });
+      if (status === "success") void refresh();
+    });
+    return () => {
+      void un.then((f) => f());
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Drop a model's progress once its pull settles (success or error).
+  const clearPullProgress = (model: string) =>
+    setPullProgress((p) => {
+      if (!(model in p)) return p;
+      const { [model]: _drop, ...rest } = p;
+      return rest;
+    });
+
+  // Live button label for an in-flight pull: a percentage when Ollama is
+  // streaming byte totals, otherwise the caller's fallback (e.g. "Pulling…").
+  const pullText = (model: string, busyFallback: string) => {
+    const pct = pullProgress[model]?.pct;
+    return pct != null ? `${pct}%` : busyFallback;
+  };
+
+  // Load the persisted interrupted-pull list + orphaned partial blobs once
+  // Ollama is present.
+  useEffect(() => {
+    if (installed !== true) return;
+    invoke<string[]>("list_pending_ollama_pulls").then(setInterrupted).catch(() => {});
+    invoke<{ digest: string; size: number; path: string }[]>("list_orphan_partial_blobs")
+      .then(setOrphans)
+      .catch(() => {});
+  }, [installed]);
+
+  // Delete an orphaned partial layer to reclaim its disk space.
+  const deleteOrphan = (path: string) => {
+    setOrphans((p) => p.filter((o) => o.path !== path));
+    void invoke("delete_partial_blob", { path }).catch((e) => setError(String(e)));
+  };
+
+  // Reconcile interrupted entries against what's actually installed: any model
+  // that completed before the crash (or has since finished) is dropped and its
+  // stale record cleared on the backend.
+  useEffect(() => {
+    if (interrupted.length === 0) return;
+    const names = new Set(models.map((m) => m.name));
+    const done = interrupted.filter(
+      (ref) => names.has(ref) || (!ref.includes(":") && names.has(`${ref}:latest`)),
+    );
+    if (done.length === 0) return;
+    setInterrupted((p) => p.filter((m) => !done.includes(m)));
+    done.forEach((m) => void invoke("clear_pending_ollama_pull", { model: m }));
+  }, [models, interrupted]);
+
+  // Resume an interrupted download — Ollama continues from the partial blobs.
+  const continuePull = (model: string) => {
+    setInterrupted((p) => p.filter((m) => m !== model));
+    void withBusy(`${model}:pull`, () => invoke("pull_ollama_model", { model }));
+  };
+
+  // Forget an interrupted download without resuming it.
+  const dismissPull = (model: string) => {
+    setInterrupted((p) => p.filter((m) => m !== model));
+    void invoke("clear_pending_ollama_pull", { model });
+  };
+
+  // Pause an in-flight download. The backend stops the stream at the next chunk,
+  // keeps the partial blobs, and emits a "paused" progress event that flips the
+  // row into the paused state (Resume / Delete).
+  const pausePull = (model: string) => {
+    void invoke("pause_ollama_pull", { model });
+  };
+
+  // Resume a paused download — re-pull, which Ollama continues from the partials.
+  const resumePull = (model: string) => {
+    setPaused((p) => {
+      const n = new Set(p);
+      n.delete(model);
+      return n;
+    });
+    void withBusy(`${model}:pull`, () => invoke("pull_ollama_model", { model }));
+  };
+
+  // Delete a paused download: drop its partial blobs and clear its pending record.
+  const deletePausedPull = (model: string) => {
+    setPaused((p) => {
+      const n = new Set(p);
+      n.delete(model);
+      return n;
+    });
+    setInterrupted((p) => p.filter((m) => m !== model));
+    void invoke("delete_ollama_pull", { model })
+      .then(() => refresh())
+      .catch((e) => setError(String(e)));
+  };
+
+  const installVibe = async () => {
+    setVibeInstalling(true);
+    setVibeInstallLog("");
+    const unlisten = await listen<{ line: string }>("vibe-install-progress", (e) => {
+      setVibeInstallLog((prev) => (prev ? `${prev}\n${e.payload.line}` : e.payload.line));
+    });
+    try {
+      await invoke<string>("install_vibe");
+      setVibeInstalled(true);
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      unlisten();
+      setVibeInstalling(false);
+    }
+  };
+
+  // Keep the live Vibe install log pinned to the latest line.
+  useEffect(() => {
+    const el = vibeInstallLogRef.current;
+    if (el) el.scrollTop = el.scrollHeight;
+  }, [vibeInstallLog]);
+
+  const installOllama = async () => {
+    setInstalling(true);
+    setError(null);
+    setInstallLog("");
+    // Stream the installer's output line-by-line so the user sees live progress.
+    const unlisten = await listen<{ line: string }>("ollama-install-progress", (e) => {
+      setInstallLog((prev) => (prev ? `${prev}\n${e.payload.line}` : e.payload.line));
+    });
+    try {
+      await invoke<string>("install_ollama");
+      setInstalled(true);
+      // Start the server and load the model catalog so the user can immediately
+      // pick what to install next.
+      loadAfterInstall();
+      await startServer();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      unlisten();
+      setInstalling(false);
+    }
+  };
+
+  // Keep the live install log pinned to the latest line.
+  useEffect(() => {
+    const el = installLogRef.current;
+    if (el) el.scrollTop = el.scrollHeight;
+  }, [installLog]);
+
   const startServer = async () => {
     setError(null);
     try {
@@ -241,37 +1227,332 @@ export function OllamaPanel({ onBack }: { onBack: () => void }) {
       setError(String(e));
     } finally {
       setBusy((prev) => ({ ...prev, [key]: false }));
+      if (key.endsWith(":pull")) clearPullProgress(key.slice(0, -":pull".length));
+    }
+  };
+
+  // Pull an arbitrary model ref typed into the free-text field. Reuses the same
+  // pull command as the catalog, so it accepts anything on the registry
+  // (`name`, `name:tag`, `namespace/name:tag`) — not just the curated catalog.
+  const pullTyped = async () => {
+    const model = pullName.trim();
+    if (!model) return;
+    const key = `${model}:pull`;
+    setBusy((prev) => ({ ...prev, [key]: true }));
+    setError(null);
+    try {
+      await invoke("pull_ollama_model", { model });
+      setPullName(""); // clear only on success; errors keep the typed ref
+      await refresh();
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setBusy((prev) => ({ ...prev, [key]: false }));
+      clearPullProgress(model);
     }
   };
 
   const installedNames = useMemo(() => new Set(models.map((m) => m.name)), [models]);
+
+  // ── Live registry browser ────────────────────────────────────────────────
+  // Only "popular"/"newest" are server-side (Ollama's `o=`); the name/size/pulls
+  // sorts reorder loaded rows client-side, so they fetch in popular order.
+  const serverSort = sortBy === "newest" ? "newest" : "popular";
+
+  // Fetch one page of ollama.com/search results. `reset` replaces the list
+  // (new query/sort); otherwise it appends, de-duping by name across pages.
+  const loadRegistryPage = async (page: number, reset: boolean) => {
+    setRegLoading(true);
+    setRegError(null);
+    try {
+      const rows = await invoke<RegistryModel[]>("search_ollama_registry", {
+        query: regQueryLive.trim(),
+        capability: "", // type filter is multi-select + client-side (see shownRegistry)
+        sort: serverSort,
+        page,
+      });
+      setRegPage(page);
+      setRegDone(rows.length === 0);
+      setRegModels((prev) => {
+        if (reset) return rows;
+        const seen = new Set(prev.map((m) => m.name));
+        return [...prev, ...rows.filter((m) => !seen.has(m.name))];
+      });
+    } catch (e) {
+      setRegError(String(e));
+      setRegDone(true);
+    } finally {
+      setRegLoading(false);
+    }
+  };
+
+  // Debounce the query box so we don't hit ollama.com on every keystroke.
+  useEffect(() => {
+    const id = window.setTimeout(() => setRegQueryLive(regQuery), 350);
+    return () => window.clearTimeout(id);
+  }, [regQuery]);
+
+  // (Re)load page 1 whenever the query or the server-side sort changes. Type and
+  // size filters and client sorts don't refetch — they reshape loaded rows.
+  useEffect(() => {
+    if (installed !== true) return;
+    void loadRegistryPage(1, true);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [regQueryLive, serverSort, installed]);
+
+  // Keep the observer callback pointing at the latest state without re-observing.
+  loadMoreRef.current = () => {
+    if (!regLoading && !regDone) void loadRegistryPage(regPage + 1, false);
+  };
+  useEffect(() => {
+    const el = sentinelRef.current;
+    if (!el) return;
+    const io = new IntersectionObserver(
+      (entries) => {
+        if (entries[0]?.isIntersecting) loadMoreRef.current();
+      },
+      { rootMargin: "240px" },
+    );
+    io.observe(el);
+    return () => io.disconnect();
+  }, []);
+
+  // Toggle a value in a Set-valued filter (used by both Type and Params chips).
+  const toggleInSet =
+    (setter: (updater: (prev: Set<string>) => Set<string>) => void) => (key: string) =>
+      setter((prev) => {
+        const next = new Set(prev);
+        if (next.has(key)) next.delete(key);
+        else next.add(key);
+        return next;
+      });
+  const toggleType = toggleInSet(setRegTypes);
+  const toggleSizeBucket = toggleInSet(setRegSizes);
+
+  // Client-side filtering + sorting over the loaded rows. Type (any-of selected
+  // capability) and size buckets narrow; the chosen sort then reorders. Ollama
+  // offers no type/size/pulls query params, so this reshapes what's fetched.
+  const shownRegistry = useMemo(() => {
+    const out = regModels.filter(
+      (m) =>
+        (regTypes.size === 0 || m.capabilities.some((c) => regTypes.has(c))) &&
+        matchesSizeBuckets(m.sizes, regSizes),
+    );
+    if (sortBy === "name") {
+      out.sort((a, b) => a.name.localeCompare(b.name));
+    } else if (sortBy === "params-asc" || sortBy === "params-desc") {
+      const dir = sortBy === "params-asc" ? 1 : -1;
+      out.sort(
+        (a, b) =>
+          dir * (modelMaxParamsB(a.sizes) - modelMaxParamsB(b.sizes)) ||
+          a.name.localeCompare(b.name),
+      );
+    } else if (sortBy === "pulls") {
+      out.sort((a, b) => parsePulls(b.pulls) - parsePulls(a.pulls));
+    }
+    // "popular"/"newest": keep the server's fetch order.
+    return out;
+  }, [regModels, regTypes, regSizes, sortBy]);
+
   const runningModels = models.filter((m) => m.running);
   const loadedLabel =
     runningModels.length === 0
       ? serverRunning
-        ? "No model loaded"
-        : "No loaded model"
-      : `Loaded: ${runningModels.map((m) => m.name).join(", ")}`;
+        ? t("ollama.noModelLoaded")
+        : t("ollama.noLoadedModel")
+      : t("ollama.loadedModels", { names: runningModels.map((m) => m.name).join(", ") });
+
+  // Vibe runtime section — required to launch Local Model tabs. Shown in both
+  // the install-Ollama and main panels; collapses to a one-line "ready" note
+  // once Vibe is detected, and expands to an installer when it is missing.
+  const vibeSection = (
+    <div className="ollama-vibe-section">
+      <div className="settings-section-title">{t("ollama.vibeTitle")}</div>
+      {vibeInstalled === null ? (
+        <p className="settings-help">{t("ollama.vibeChecking")}</p>
+      ) : vibeInstalled ? (
+        <p className="settings-help">
+          <span className="ollama-status-dot running" /> {t("ollama.vibeInstalled")}
+        </p>
+      ) : (
+        <>
+          <p className="settings-help">
+            {t("ollama.vibeMissing1")} <code>vibe</code> {t("ollama.vibeMissing2")}
+          </p>
+          <div className="ollama-install-cmd-row">
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              disabled={vibeInstalling}
+              onClick={() => void installVibe()}
+            >
+              {vibeInstalling ? t("ollama.installingEllipsis") : t("ollama.installVibe")}
+            </button>
+            {vibeInstalling && <span className="ollama-status-text">{t("ollama.runningInstaller")}</span>}
+          </div>
+          {vibeInstallLog !== null && (
+            <pre className="ollama-install-log" ref={vibeInstallLogRef}>
+              {vibeInstallLog || t("ollama.startingEllipsis")}
+            </pre>
+          )}
+          <p className="settings-help">
+            {t("ollama.orInstallInShellPre")} {vibeStrategy?.os === "windows" ? "PowerShell" : "terminal"}{" "}
+            {t("ollama.orInstallInShellPost")}
+          </p>
+          <div className="ollama-install-cmd-row">
+            <code className="ollama-install-cmd">{vibeStrategy?.command ?? VIBE_INSTALL_CMD}</code>
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              onClick={() =>
+                runInstallInTab(
+                  "Install Vibe",
+                  vibeStrategy?.command ?? VIBE_INSTALL_CMD,
+                  vibeStrategy?.os === "windows" ? "powershell" : "bash",
+                )
+              }
+            >
+              {t("ollama.runInTerminal")}
+            </button>
+            <button
+              type="button"
+              className="ollama-action-btn"
+              disabled={vibeInstalling}
+              onClick={() =>
+                void invoke<boolean>("vibe_is_installed")
+                  .then((ok) => {
+                    setVibeInstalled(ok);
+                    if (!ok)
+                      setError(
+                        vibeStrategy?.os === "windows"
+                          ? t("ollama.vibeStillNotDetectedWindows")
+                          : t("ollama.vibeStillNotDetectedOther"),
+                      );
+                  })
+                  .catch(() => {})
+              }
+            >
+              {t("common.recheck")}
+            </button>
+          </div>
+        </>
+      )}
+    </div>
+  );
+
+  // ── Not installed: show the (semi-)automated installer + manual steps ──────
+  if (installed === false) {
+    // OS-dependent install guidance from the backend (winget on Windows, the
+    // install script on Linux/macOS); fall back to the script until it loads.
+    const installCmd = strategy?.command ?? OLLAMA_INSTALL_CMD_FALLBACK;
+    const downloadUrl = strategy?.download_url ?? OLLAMA_DOWNLOAD_URL;
+    const isWindows = strategy?.os === "windows";
+    return (
+      <>
+        <div className="settings-title-row">
+          <h2>{t("ollama.installTitle")}</h2>
+          <button type="button" onClick={onBack}>{t("common.back")}</button>
+        </div>
+
+        <p className="settings-help">{t("ollama.notInstalledHelp")}</p>
+
+        <div className="settings-section-title">{t("ollama.automaticInstall")}</div>
+        <p className="settings-help">
+          {isWindows ? t("ollama.autoInstallHelpWindows") : t("ollama.autoInstallHelpOther")}
+        </p>
+        <div className="ollama-install-cmd-row">
+          <button
+            type="button"
+            className="ollama-action-btn primary"
+            disabled={installing}
+            onClick={() => void installOllama()}
+          >
+            {installing ? t("ollama.installingEllipsis") : t("ollama.installBtn")}
+          </button>
+          {installing && <span className="ollama-status-text">{t("ollama.runningInstaller")}</span>}
+        </div>
+
+        {error && <div className="project-dialog-error">{error}</div>}
+        {installLog !== null && (
+          <pre className="ollama-install-log" ref={installLogRef}>
+            {installLog || t("ollama.startingEllipsis")}
+          </pre>
+        )}
+
+        <div className="settings-section-title">{t("ollama.installInTerminalTitle")}</div>
+        <ol className="ollama-install-steps">
+          <li>
+            {t("ollama.runInstallerNewPre")}{" "}
+            {isWindows ? "PowerShell" : "terminal"} {t("ollama.runInstallerNewPost")}
+            <div className="ollama-install-cmd-row">
+              <code className="ollama-install-cmd">{installCmd}</code>
+              <button
+                type="button"
+                className="ollama-action-btn primary"
+                onClick={() =>
+                  runInstallInTab("Install Ollama", installCmd, isWindows ? "default" : "bash")
+                }
+              >
+                {t("ollama.runInTerminal")}
+              </button>
+            </div>
+            <span className="settings-help">
+              {t("ollama.alsoDownloadFrom")}{" "}
+              <code>{downloadUrl}</code>.
+            </span>
+          </li>
+          <li>
+            {isWindows ? t("ollama.approveUacPrompt") : t("ollama.enterPasswordSudo")}
+          </li>
+          <li>
+            {t("ollama.onceFinishedClickPre")} <strong>{t("common.recheck")}</strong>{" "}
+            {t("ollama.onceFinishedClickPost")}
+          </li>
+        </ol>
+        <button
+          type="button"
+          className="ollama-action-btn"
+          disabled={installing}
+          onClick={() =>
+            void (async () => {
+              const ok = await invoke<boolean>("ollama_is_installed").catch(() => false);
+              setInstalled(ok);
+              if (ok) {
+                loadAfterInstall();
+                await startServer();
+              } else {
+                setError(t("ollama.stillNotDetected"));
+              }
+            })()
+          }
+        >
+          {t("common.recheck")}
+        </button>
+
+        {vibeSection}
+      </>
+    );
+  }
 
   return (
     <>
       <div className="settings-title-row">
-        <h2>Ollama Models</h2>
-        <button type="button" onClick={onBack}>Back</button>
+        <h2>{t("ollama.modelsTitle")}</h2>
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
       </div>
 
       <div className="ollama-status-bar">
-        <span className={`ollama-status-dot ${runningModels.length > 0 ? "running" : "stopped"}`} />
+        <span className={`ollama-status-dot ${serverRunning ? "running" : "stopped"}`} />
         <span className="ollama-status-text">
           {serverRunning === null
-            ? "Checking..."
+            ? t("ollama.checkingEllipsis")
             : serverRunning
-              ? loadedLabel
-              : "Server not running"}
+              ? t("ollama.serverRunningLabel", { label: loadedLabel })
+              : t("ollama.serverNotRunning")}
         </span>
         {serverRunning === false && (
           <button type="button" className="ollama-action-btn" onClick={() => void startServer()}>
-            Start
+            {t("ollama.start")}
           </button>
         )}
         {serverRunning === true && (
@@ -281,18 +1562,145 @@ export function OllamaPanel({ onBack }: { onBack: () => void }) {
             disabled={loading}
             onClick={() => void refresh()}
           >
-            {loading ? "..." : "Refresh"}
+            {loading ? "..." : t("ollama.refresh")}
           </button>
         )}
       </div>
 
       {error && <div className="project-dialog-error">{error}</div>}
 
-      <div className="settings-section-title">Installed Models</div>
+      {vibeSection}
+
+      {(() => {
+        // Interrupted entries not currently being (re)pulled — these get a
+        // "Continue" action; live pulls show their streaming progress bar.
+        const resumable = interrupted.filter((m) => !(m in pullProgress) && !paused.has(m));
+        if (
+          Object.keys(pullProgress).length === 0 &&
+          resumable.length === 0 &&
+          paused.size === 0 &&
+          orphans.length === 0
+        )
+          return null;
+        return (
+          <>
+            <div className="settings-section-title">{t("ollama.downloadingTitle")}</div>
+            <div className="settings-list">
+              {Object.entries(pullProgress).map(([model, pr]) => (
+                <div className="ollama-model-row" key={model}>
+                  <div className="ollama-model-header">
+                    <span className="ollama-model-name">{model}</span>
+                    <span className="ollama-model-size">
+                      {pr.pct != null ? `${pr.pct}%` : "…"}
+                    </span>
+                  </div>
+                  <div className="ollama-download-bar">
+                    <div
+                      className={`ollama-download-bar-fill${pr.pct == null ? " indeterminate" : ""}`}
+                      style={pr.pct != null ? { width: `${pr.pct}%` } : undefined}
+                    />
+                  </div>
+                  {pr.status && <div className="ollama-download-status">{pr.status}</div>}
+                  <div className="ollama-model-actions">
+                    <button
+                      type="button"
+                      className="ollama-action-btn"
+                      title={t("ollama.pauseTitle")}
+                      onClick={() => pausePull(model)}
+                    >
+                      {t("ollama.pause")}
+                    </button>
+                  </div>
+                </div>
+              ))}
+              {[...paused].map((model) => (
+                <div className="ollama-model-row" key={`paused:${model}`}>
+                  <div className="ollama-model-header">
+                    <span className="ollama-model-name">{model}</span>
+                    <span className="ollama-model-size">{t("ollama.pausedBadge")}</span>
+                  </div>
+                  <div className="ollama-download-status">{t("ollama.downloadPaused")}</div>
+                  <div className="ollama-model-actions">
+                    <button
+                      type="button"
+                      className="ollama-action-btn"
+                      onClick={() => resumePull(model)}
+                    >
+                      {t("ollama.resume")}
+                    </button>
+                    <button
+                      type="button"
+                      className="ollama-action-btn danger"
+                      title={t("ollama.deletePartialTitle")}
+                      onClick={() => deletePausedPull(model)}
+                    >
+                      {t("ollama.delete")}
+                    </button>
+                  </div>
+                </div>
+              ))}
+              {resumable.map((model) => (
+                <div className="ollama-model-row" key={`int:${model}`}>
+                  <div className="ollama-model-header">
+                    <span className="ollama-model-name">{model}</span>
+                    <span className="ollama-model-size">{t("ollama.interruptedBadge")}</span>
+                  </div>
+                  <div className="ollama-download-status">{t("ollama.downloadInterrupted")}</div>
+                  <div className="ollama-model-actions">
+                    <button
+                      type="button"
+                      className="ollama-action-btn"
+                      onClick={() => continuePull(model)}
+                    >
+                      {t("ollama.continueDownload")}
+                    </button>
+                    <button
+                      type="button"
+                      className="ollama-action-btn"
+                      title={t("ollama.dismissTitle")}
+                      onClick={() => dismissPull(model)}
+                    >
+                      {t("ollama.dismiss")}
+                    </button>
+                  </div>
+                </div>
+              ))}
+              {orphans.length > 0 && (
+                <div className="ollama-download-status">
+                  {t(orphans.length === 1 ? "ollama.orphansSummaryOne" : "ollama.orphansSummaryMany", {
+                    count: orphans.length,
+                    size: fmtBytes(orphans.reduce((sum, o) => sum + o.size, 0)),
+                  })}
+                </div>
+              )}
+              {orphans.map((o) => (
+                <div className="ollama-model-row" key={o.path}>
+                  <div className="ollama-model-header">
+                    <span className="ollama-model-name">{t("ollama.orphanLayer", { digest: o.digest })}</span>
+                    <span className="ollama-model-size">{fmtBytes(o.size)}</span>
+                  </div>
+                  <div className="ollama-model-actions">
+                    <button
+                      type="button"
+                      className="ollama-action-btn danger"
+                      title={t("ollama.deleteLayerTitle")}
+                      onClick={() => deleteOrphan(o.path)}
+                    >
+                      {t("ollama.delete")}
+                    </button>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </>
+        );
+      })()}
+
+      <div className="settings-section-title">{t("ollama.downloadedModelsTitle")}</div>
       {loading ? (
-        <div className="ollama-empty">Loading...</div>
+        <div className="ollama-empty">{t("common.loading")}</div>
       ) : models.length === 0 ? (
-        <div className="ollama-empty">No models installed</div>
+        <div className="ollama-empty">{t("ollama.noModelsDownloaded")}</div>
       ) : (
         <div className="settings-list">
           {models.map((m) => (
@@ -312,97 +1720,285 @@ export function OllamaPanel({ onBack }: { onBack: () => void }) {
                 )}
               </div>
               <div className="ollama-model-actions">
-                {m.running && (
+                {m.running ? (
                   <button
                     type="button"
                     className="ollama-action-btn"
                     disabled={busy[`${m.name}:stop`]}
-                    title="Unload from memory"
+                    title={t("ollama.unloadTitle")}
                     onClick={() =>
                       void withBusy(`${m.name}:stop`, () =>
                         invoke("stop_ollama_model", { model: m.name }),
                       )
                     }
                   >
-                    {busy[`${m.name}:stop`] ? "..." : "Unload"}
+                    {busy[`${m.name}:stop`] ? "..." : t("ollama.unload")}
+                  </button>
+                ) : (
+                  <button
+                    type="button"
+                    className="ollama-action-btn"
+                    disabled={busy[`${m.name}:load`] || loadingMem[m.name]}
+                    title={t("ollama.loadTitle")}
+                    onClick={() =>
+                      void withBusy(`${m.name}:load`, () =>
+                        invoke("load_ollama_model", { model: m.name }),
+                      )
+                    }
+                  >
+                    {busy[`${m.name}:load`] || loadingMem[m.name] ? t("ollama.loading") : t("ollama.load")}
                   </button>
                 )}
                 <button
                   type="button"
                   className="ollama-action-btn"
                   disabled={busy[`${m.name}:pull`]}
-                  title="Check for update and download latest"
+                  title={t("ollama.updateTitle")}
                   onClick={() =>
                     void withBusy(`${m.name}:pull`, () =>
                       invoke("pull_ollama_model", { model: m.name }),
                     )
                   }
                 >
-                  {busy[`${m.name}:pull`] ? "Updating..." : "Update"}
+                  {busy[`${m.name}:pull`] ? pullText(m.name, t("ollama.updating")) : t("ollama.update")}
                 </button>
                 <button
                   type="button"
                   className="ollama-action-btn danger"
                   disabled={busy[`${m.name}:del`]}
-                  title="Delete this model"
+                  title={t("ollama.deleteModelTitle")}
                   onClick={() =>
                     void withBusy(`${m.name}:del`, () =>
                       invoke("delete_ollama_model", { model: m.name }),
                     )
                   }
                 >
-                  {busy[`${m.name}:del`] ? "..." : "Delete"}
+                  {busy[`${m.name}:del`] ? "..." : t("ollama.delete")}
                 </button>
               </div>
+              {(busy[`${m.name}:load`] || loadingMem[m.name]) && (
+                <div className="ollama-load-progress" title={t("ollama.loadingIntoMemoryTitle")}>
+                  <div className="ollama-download-bar">
+                    <div className="ollama-download-bar-fill indeterminate" />
+                  </div>
+                  <span className="ollama-download-status">{t("ollama.loadingIntoMemory")}</span>
+                </div>
+              )}
             </div>
           ))}
         </div>
       )}
 
       <div className="settings-section-title ollama-section-title-row">
-        <span>Available to Install</span>
+        <span>{t("ollama.browseRegistry")}</span>
         <button
           type="button"
           className="ollama-action-btn"
-          disabled={loading}
-          onClick={() => void refresh()}
+          disabled={regLoading}
+          onClick={() => void loadRegistryPage(1, true)}
         >
-          {loading ? "..." : "Refresh"}
+          {regLoading ? "..." : t("ollama.refresh")}
         </button>
       </div>
+
+      <p className="settings-help">
+        {t("ollama.pullHelp1")}{" "}
+        <code>llama3.1:8b</code> {t("ollama.pullHelp2")} <code>namespace/model:tag</code>.
+      </p>
+      <div className="ollama-install-cmd-row">
+        <input
+          type="text"
+          className="ollama-pull-input"
+          placeholder={t("ollama.pullPlaceholder")}
+          value={pullName}
+          spellCheck={false}
+          autoCapitalize="off"
+          autoCorrect="off"
+          disabled={!!busy[`${pullName.trim()}:pull`]}
+          onChange={(e) => setPullName(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") void pullTyped();
+          }}
+        />
+        <button
+          type="button"
+          className="ollama-action-btn"
+          disabled={!pullName.trim() || !!busy[`${pullName.trim()}:pull`]}
+          onClick={() => void pullTyped()}
+        >
+          {busy[`${pullName.trim()}:pull`] ? pullText(pullName.trim(), t("ollama.pulling")) : t("ollama.pull")}
+        </button>
+      </div>
+
+      <div className="ollama-catalog-controls">
+        <input
+          type="text"
+          className="ollama-pull-input"
+          placeholder={t("ollama.searchPlaceholder")}
+          value={regQuery}
+          spellCheck={false}
+          autoCapitalize="off"
+          autoCorrect="off"
+          onChange={(e) => setRegQuery(e.target.value)}
+        />
+        <label className="ollama-sort-label" title={t("ollama.sortBy")}>
+          {t("ollama.sortBy")}
+          <Dropdown
+            className="ollama-catalog-sort"
+            value={sortBy}
+            onChange={(v) => setSortBy(v as SortKey)}
+            options={SORT_OPTIONS.map((o) => ({ value: o.key, label: t(o.labelKey) }))}
+          />
+        </label>
+      </div>
+
+      <div className="ollama-filter-row">
+        <span className="ollama-filter-label">{t("ollama.filterType")}</span>
+        <button
+          type="button"
+          className={`ollama-chip${regTypes.size === 0 ? " active" : ""}`}
+          onClick={() => setRegTypes(new Set())}
+        >
+          {t("ollama.any")}
+        </button>
+        {REGISTRY_TYPES.map((cap) => (
+          <button
+            key={cap}
+            type="button"
+            className={`ollama-chip${regTypes.has(cap) ? " active" : ""}`}
+            onClick={() => toggleType(cap)}
+          >
+            {t(`ollama.cap.${cap}` as TranslationKey)}
+          </button>
+        ))}
+      </div>
+
+      <div className="ollama-filter-row">
+        <span className="ollama-filter-label">{t("ollama.filterParams")}</span>
+        <button
+          type="button"
+          className={`ollama-chip${regSizes.size === 0 ? " active" : ""}`}
+          onClick={() => setRegSizes(new Set())}
+        >
+          {t("ollama.any")}
+        </button>
+        {SIZE_BUCKETS.map((b) => (
+          <button
+            key={b.key}
+            type="button"
+            className={`ollama-chip${regSizes.has(b.key) ? " active" : ""}`}
+            onClick={() => toggleSizeBucket(b.key)}
+          >
+            {b.label}
+          </button>
+        ))}
+      </div>
+
+      {regError && <div className="project-dialog-error">{regError}</div>}
+
       <div className="settings-list">
-        {catalog.map((entry) => (
-          <div className="ollama-catalog-row" key={entry.name}>
+        {shownRegistry.map((m) => (
+          <div className="ollama-catalog-row" key={m.name}>
             <div className="ollama-catalog-header">
-              <span className="ollama-model-name">{entry.name}</span>
-              <span className="ollama-catalog-hint">{entry.size_hint}</span>
+              <span className="ollama-model-name">{m.name}</span>
+              <span className="ollama-catalog-hint">
+                {m.pulls && t("ollama.pullsSuffix", { pulls: m.pulls })}
+                {m.pulls && m.updated ? " · " : ""}
+                {m.updated}
+              </span>
             </div>
-            <div className="ollama-catalog-desc">{entry.description}</div>
+            {m.description && <div className="ollama-catalog-desc">{m.description}</div>}
+            {m.capabilities.length > 0 && (
+              <div className="ollama-model-details">
+                {m.capabilities.map((c) => (
+                  <span className="ollama-badge" key={c}>
+                    {c}
+                  </span>
+                ))}
+              </div>
+            )}
             <div className="ollama-catalog-tags">
-              {entry.tags.map((tag) => {
-                const fullName = `${entry.name}:${tag}`;
-                const isInstalled = installedNames.has(fullName);
-                const isBusy = busy[`${fullName}:pull`];
-                return (
-                  <button
-                    key={tag}
-                    type="button"
-                    className={`ollama-tag-btn${isInstalled ? " installed" : ""}`}
-                    disabled={!!isBusy}
-                    title={isInstalled ? `Update ${fullName}` : `Install ${fullName}`}
-                    onClick={() =>
-                      void withBusy(`${fullName}:pull`, () =>
-                        invoke("pull_ollama_model", { model: fullName }),
-                      )
-                    }
-                  >
-                    {isBusy ? "..." : tag}
-                  </button>
-                );
-              })}
+              {m.sizes.length === 0 ? (
+                (() => {
+                  const isInstalled = installedNames.has(`${m.name}:latest`);
+                  const sz = tagSizes[m.name];
+                  const sizeLabel =
+                    sz === undefined
+                      ? ""
+                      : sz === "loading"
+                        ? t("ollama.sizeLoadingSuffix")
+                        : sz === "error"
+                          ? ""
+                          : ` — ${fmtBytes(sz)}`;
+                  return (
+                    <button
+                      type="button"
+                      className={`ollama-tag-btn${isInstalled ? " installed" : ""}`}
+                      disabled={!!busy[`${m.name}:pull`]}
+                      title={t(isInstalled ? "ollama.tagUpdateTitle" : "ollama.tagDownloadTitle", { name: m.name, size: sizeLabel })}
+                      onMouseEnter={() => fetchTagSize(m.name)}
+                      onFocus={() => fetchTagSize(m.name)}
+                      onClick={() =>
+                        void withBusy(`${m.name}:pull`, () =>
+                          invoke("pull_ollama_model", { model: m.name }),
+                        )
+                      }
+                    >
+                      {busy[`${m.name}:pull`] ? pullText(m.name, "…") : t("ollama.pullLower")}
+                    </button>
+                  );
+                })()
+              ) : (
+                m.sizes.map((tag) => {
+                  const fullName = `${m.name}:${tag}`;
+                  const isInstalled = installedNames.has(fullName);
+                  const isBusy = busy[`${fullName}:pull`];
+                  const sz = tagSizes[fullName];
+                  const sizeLabel =
+                    sz === undefined
+                      ? ""
+                      : sz === "loading"
+                        ? t("ollama.sizeLoadingSuffix")
+                        : sz === "error"
+                          ? ""
+                          : ` — ${fmtBytes(sz)}`;
+                  return (
+                    <button
+                      key={tag}
+                      type="button"
+                      className={`ollama-tag-btn${isInstalled ? " installed" : ""}`}
+                      disabled={!!isBusy}
+                      title={t(isInstalled ? "ollama.tagUpdateTitle" : "ollama.tagDownloadTitle", { name: fullName, size: sizeLabel })}
+                      onMouseEnter={() => fetchTagSize(fullName)}
+                      onFocus={() => fetchTagSize(fullName)}
+                      onClick={() =>
+                        void withBusy(`${fullName}:pull`, () =>
+                          invoke("pull_ollama_model", { model: fullName }),
+                        )
+                      }
+                    >
+                      {isBusy ? pullText(fullName, "…") : tag}
+                    </button>
+                  );
+                })
+              )}
             </div>
           </div>
         ))}
+
+        {/* Lazy-load sentinel + status line. */}
+        {regLoading && <div className="ollama-empty">{t("common.loading")}</div>}
+        {!regLoading && shownRegistry.length === 0 && (
+          <div className="ollama-empty">
+            {regModels.length === 0
+              ? t("ollama.noModelsFound")
+              : t("ollama.noMatchSizeFilter")}
+          </div>
+        )}
+        <div ref={sentinelRef} aria-hidden="true" />
+        {regDone && regModels.length > 0 && (
+          <div className="ollama-empty">{t("ollama.endOfResults")}</div>
+        )}
       </div>
     </>
   );
diff --git a/src/components/layout/TourHost.tsx b/src/components/layout/TourHost.tsx
new file mode 100644
index 0000000..9abaf02
--- /dev/null
+++ b/src/components/layout/TourHost.tsx
@@ -0,0 +1,152 @@
+import { useEffect, useRef, useState } from "react";
+import { useTourStore } from "../../stores/tour";
+import { useProjectsStore } from "../../stores/projects";
+import { nextEligibleIndex } from "../../lib/tour";
+import { TourCoachmark } from "../common/TourCoachmark";
+
+// How long to wait for a step's anchor to appear before falling back to a
+// centered card. Tour targets are persistent header/chrome that mount well
+// before the tour can start, so this only guards genuinely-missing anchors and
+// must never deadlock the walkthrough.
+const ANCHOR_WAIT_MS = 600;
+
+/**
+ * Drives the guided "Take a tour" walkthrough: listens for the
+ * `eldrun:start-tour` event, measures the active step's anchor (re-measuring as
+ * the layout shifts), pulses the highlighted element, owns the keyboard
+ * navigation, and renders the `TourCoachmark` overlay. Mounted once in
+ * `AppShell` beside `HintHost` (never in detached windows). Selection/ordering
+ * live in `lib/tour.ts`; persistence in `stores/tour.ts` — this component owns
+ * only the impure DOM/timing concerns, mirroring `HintHost`.
+ */
+export function TourHost() {
+  const active = useTourStore((s) => s.active);
+  const index = useTourStore((s) => s.index);
+  const steps = useTourStore((s) => s.steps);
+  const start = useTourStore((s) => s.start);
+  const next = useTourStore((s) => s.next);
+  const prev = useTourStore((s) => s.prev);
+  const skip = useTourStore((s) => s.skip);
+  // Layout-affecting context: re-measure the anchor when these change.
+  const projectCount = useProjectsStore((s) => s.projects.length);
+  const activeId = useProjectsStore((s) => s.activeId);
+
+  const [rect, setRect] = useState<DOMRect | null>(null);
+  const gaveUp = useRef(false);
+
+  const step = active ? steps[index] : null;
+
+  // Entry point: the gear menu / Settings / HowToStart all dispatch this.
+  useEffect(() => {
+    const onStart = () => start();
+    window.addEventListener("eldrun:start-tour", onStart);
+    return () => window.removeEventListener("eldrun:start-tour", onStart);
+  }, [start]);
+
+  // Run a step's optional prepare side-effect (e.g. reveal the file panel so
+  // the step has an anchor to spotlight) when it becomes active.
+  useEffect(() => {
+    step?.prepare?.();
+  }, [step]);
+
+  // Measure the active step's anchor and keep it positioned as the window/layout
+  // shifts. A missing anchor falls back (after a bounded wait) to the centered
+  // card so the tour can't stall on chrome that never appears.
+  useEffect(() => {
+    if (!step) {
+      setRect(null);
+      return;
+    }
+    if (!step.anchor) {
+      setRect(null);
+      return;
+    }
+    gaveUp.current = false;
+    const selector = step.anchor;
+    let waitTimer = 0;
+    const measure = () => {
+      const el = document.querySelector(selector);
+      if (el) {
+        setRect(el.getBoundingClientRect());
+      } else if (!gaveUp.current) {
+        setRect(null);
+      }
+    };
+    measure();
+    // If the anchor isn't there yet, retry briefly, then give up to a banner.
+    if (!document.querySelector(selector)) {
+      waitTimer = window.setTimeout(() => {
+        gaveUp.current = true;
+        measure();
+      }, ANCHOR_WAIT_MS);
+    }
+    const ro = new ResizeObserver(measure);
+    const el = document.querySelector(selector);
+    if (el) ro.observe(el);
+    window.addEventListener("resize", measure, true);
+    window.addEventListener("scroll", measure, true);
+    return () => {
+      window.clearTimeout(waitTimer);
+      ro.disconnect();
+      window.removeEventListener("resize", measure, true);
+      window.removeEventListener("scroll", measure, true);
+    };
+    // projectCount/activeId are deps so the anchor re-resolves after a layout
+    // shift (e.g. a project opening adds the tab bar the step points at).
+  }, [step, projectCount, activeId]);
+
+  // Pulse the highlighted element while its step is on screen (reuses the
+  // contextual-hint `.hint-target` glow), cleaned up on step change/teardown.
+  useEffect(() => {
+    if (!step?.anchor) return;
+    const el = document.querySelector(step.anchor);
+    if (!el) return;
+    el.classList.add("hint-target");
+    return () => el.classList.remove("hint-target");
+  }, [step, projectCount, activeId]);
+
+  // Keyboard navigation while the tour runs: Esc skips, ←/→ and Enter step.
+  useEffect(() => {
+    if (!active) return;
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        skip();
+      } else if (e.key === "ArrowRight" || e.key === "Enter") {
+        e.preventDefault();
+        next();
+      } else if (e.key === "ArrowLeft") {
+        e.preventDefault();
+        prev();
+      }
+    };
+    window.addEventListener("keydown", onKey, true);
+    return () => window.removeEventListener("keydown", onKey, true);
+  }, [active, skip, next, prev]);
+
+  if (!step) return null;
+
+  const ctx = { projectCount, activeId };
+  const isLast = nextEligibleIndex(steps, ctx, index + 1) >= steps.length;
+  // Human-readable position: count eligible steps up to and including this one.
+  const eligible = steps.filter((s) => (s.when ? s.when(ctx) : true));
+  const stepTotal = eligible.length;
+  const stepNumber = eligible.findIndex((s) => s.id === step.id) + 1;
+  const isFirst = stepNumber <= 1;
+
+  return (
+    <TourCoachmark
+      rect={rect}
+      placement={step.placement}
+      title={step.title}
+      body={step.body}
+      stepNumber={stepNumber}
+      stepTotal={stepTotal}
+      isFirst={isFirst}
+      isLast={isLast}
+      onBack={prev}
+      onNext={next}
+      onSkip={skip}
+    />
+  );
+}
diff --git a/src/components/layout/VpnPasswordPrompt.tsx b/src/components/layout/VpnPasswordPrompt.tsx
index efd23a2..d9b942b 100644
--- a/src/components/layout/VpnPasswordPrompt.tsx
+++ b/src/components/layout/VpnPasswordPrompt.tsx
@@ -1,64 +1,323 @@
 import { useEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
+import { listen } from "@tauri-apps/api/event";
 import { useVpnPromptStore } from "../../stores/vpnPrompt";
+import { useVpnStatusStore } from "../../stores/vpnStatus";
+import { ConnectionLog, type LogLine } from "../common/ConnectionLog";
+import { PasswordInput } from "../common/PasswordInput";
+import { needsSeparateKeyPassphrase, type VpnAuthNeeds } from "../../types";
+import { useT } from "../../lib/i18n";
 
 /**
  * Activation-time OpenVPN password prompt. Rendered once at the app root; shows
  * a modal whenever a VPN-gated project is being activated and needs its (never
- * persisted) password. Resolves the pending `vpnPrompt` request.
+ * persisted) password. The store owns the connect, so this modal stays open
+ * while the tunnel comes up and surfaces any failure inline (with a retry)
+ * rather than letting it fail silently in the background.
  */
 export function VpnPasswordPrompt() {
+  const t = useT();
   const pending = useVpnPromptStore((s) => s.pending);
+  const status = useVpnPromptStore((s) => s.status);
+  const error = useVpnPromptStore((s) => s.error);
   const submit = useVpnPromptStore((s) => s.submit);
   const cancel = useVpnPromptStore((s) => s.cancel);
+  const handoffToTerminal = useVpnPromptStore((s) => s.handoffToTerminal);
+  const close = useVpnPromptStore((s) => s.close);
+  const markConnected = useVpnPromptStore((s) => s.markConnected);
+  // The machine-level lamp for *this* config. It is reconciled every 10 s by
+  // `VpnIndicator` against the backend's real tunnel set, which makes it the one
+  // observer that can notice a tunnel coming up when our own connect call doesn't.
+  const machineState = useVpnStatusStore((s) => (pending ? s.byConfig[pending.config] : undefined));
   const [password, setPassword] = useState("");
+  // Auth username for `auth-user-pass` configs. `needs` (queried per prompt)
+  // decides which fields are shown; the username is seeded from the pending
+  // prompt's stored spec.
+  const [username, setUsername] = useState("");
+  const [needs, setNeeds] = useState<VpnAuthNeeds>({ username: false, keyPassphrase: false });
+  // A config with an encrypted key *and* an account has two secrets — OpenVPN
+  // prompts for them separately. Without an account, `password` already is the
+  // key passphrase, so this field stays hidden rather than asking twice.
+  const [keyPassphrase, setKeyPassphrase] = useState("");
+  const needsKeyPassphrase = needsSeparateKeyPassphrase(needs);
+  // Opt-in "Save passphrase" (default off). Pre-checked when a credential is
+  // already saved for this config, so the box mirrors the true keychain state.
+  const [remember, setRemember] = useState(false);
+  // Live OpenVPN handshake output streamed from the backend, shown read-only so
+  // the connect isn't an opaque spinner. Reset per prompt and per attempt.
+  const [log, setLog] = useState<LogLine[]>([]);
+  // Monotonic id source for `log` lines: a dedicated counter (never reset on
+  // slice) gives each line a stable React key so the `.slice(-500)` cap trims
+  // only the head without re-creating the surviving line nodes.
+  const logSeq = useRef(0);
   const inputRef = useRef<HTMLInputElement>(null);
 
-  // Reset + focus whenever a new prompt opens.
+  // Reset + focus whenever a new prompt opens (keyed on config so a superseding
+  // prompt re-focuses, but a connect attempt on the same prompt doesn't wipe the
+  // typed passphrase).
   useEffect(() => {
     if (pending) {
       setPassword("");
+      setKeyPassphrase("");
+      setUsername(pending.username ?? "");
+      setLog([]);
       inputRef.current?.focus();
+      const config = pending.config;
+      let cancelled = false;
+      // The caller's seed wins where it has one: a prompt opened *as* the save action
+      // ("Save login credentials" in the VPN menu) has nothing saved yet, so asking
+      // the keychain would tick the box off and quietly not save what was asked for.
+      const seeded = pending.remember;
+      if (seeded !== undefined) setRemember(seeded);
+      else
+        void invoke<boolean>("vpn_has_saved_password", { config })
+          .then((v) => !cancelled && setRemember(v))
+          .catch(() => {});
+      void invoke<VpnAuthNeeds>("openvpn_auth_needs", { config })
+        .then((v) => !cancelled && setNeeds(v))
+        .catch(() => {});
+      return () => {
+        cancelled = true;
+      };
     }
-  }, [pending]);
+  }, [pending?.config]);
+
+  // Stream the live handshake for this prompt's config into the log.
+  useEffect(() => {
+    const config = pending?.config;
+    if (!config) return;
+    let cancelled = false;
+    let un: (() => void) | undefined;
+    void listen<{ config: string; line: string }>("openvpn-progress", (ev) => {
+      if (ev.payload.config !== config) return;
+      setLog((prev) => [...prev, { id: logSeq.current++, text: ev.payload.line }].slice(-500));
+    }).then((u) => {
+      if (cancelled) u();
+      else un = u;
+    });
+    return () => {
+      cancelled = true;
+      un?.();
+    };
+  }, [pending?.config]);
+
+  // Watchdog for the "it connected but the modal didn't notice" case that `submit`'s
+  // own `openvpn_status` re-check cannot cover: that one only runs when the connect
+  // *rejects*. A connect that neither resolves nor rejects — the handshake completed
+  // but the marker line never arrived — left `status` pinned at "connecting" forever,
+  // so the button read "Connecting…" over a live tunnel. The header's reconcile does
+  // see it, so adopt its verdict here.
+  useEffect(() => {
+    if (status === "connecting" && machineState === "connected") markConnected();
+  }, [status, machineState, markConnected]);
 
   if (!pending) return null;
 
-  const onSubmit = () => submit(password);
+  const connecting = status === "connecting";
+  const connected = status === "connected";
+  const onSubmit = () => {
+    if (!connecting && !connected) {
+      setLog([]);
+      void submit(password, remember, username, keyPassphrase);
+    }
+  };
+  // Enter submits from any field (once connected it closes); Escape aborts/closes.
+  const onFieldKey = (e: React.KeyboardEvent) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      if (connected) close();
+      else onSubmit();
+    }
+    // Escape works even while connecting: it *aborts* the in-flight attempt (the
+    // store tears down any half-open tunnel), so a wedged handshake is never a trap.
+    // Once connected it is a plain dismissal (the tunnel stays up).
+    if (e.key === "Escape") {
+      e.preventDefault();
+      if (connected) close();
+      else cancel();
+    }
+  };
 
   return (
-    <div className="modal-backdrop" onMouseDown={cancel}>
+    <div
+      className="modal-backdrop"
+      onMouseDown={connecting ? undefined : connected ? close : cancel}
+    >
       <div className="project-dialog vpn-prompt-dialog" onMouseDown={(e) => e.stopPropagation()}>
-        <h2>VPN password</h2>
+        {/* Title row with an explicit ×. The backdrop click is deliberately inert
+            while connecting, and the only other way out was the action row — so a
+            corner close is the dismissal users reach for and it must be present in
+            every state. It mirrors Escape: a plain dismissal once connected, an
+            abort (which tears down any half-open tunnel) before that. */}
+        <div className="vpn-prompt-header">
+          <h2>{connected ? t("vpnPrompt.titleConnected") : t("vpnPrompt.titlePassword")}</h2>
+          <button
+            type="button"
+            className="vpn-prompt-close"
+            aria-label={t("vpnPrompt.close")}
+            title={t(
+              connected
+                ? "vpnPrompt.closeTitleConnected"
+                : connecting
+                  ? "vpnPrompt.closeTitleConnecting"
+                  : "vpnPrompt.closeTitleDefault",
+            )}
+            onClick={connected ? close : cancel}
+          >
+            ×
+          </button>
+        </div>
         <p className="vpn-prompt-text">
-          Connecting OpenVPN for <strong>{pending.projectName}</strong>.
+          {connected ? (
+            <>
+              {t("vpnPrompt.upFor")} <strong className="vpn-prompt-name">{pending.projectName}</strong>.
+            </>
+          ) : (
+            <>
+              {t("vpnPrompt.connectingFor")}{" "}
+              <strong className="vpn-prompt-name">{pending.projectName}</strong>.
+            </>
+          )}
+          <br />
+          <span className="vpn-prompt-scope">{t("vpnPrompt.trafficScope")}</span>
         </p>
+        {/* Why this modal is on screen when the connect was supposed to be silent.
+            Without it, a rejected or unreadable saved credential looks identical to
+            never having saved one — the user ticked a box, and the box appears to
+            have done nothing. */}
+        {!connected && pending.reason && (
+          <div className="vpn-prompt-reason" role="status">
+            {pending.reason}
+          </div>
+        )}
+        {needs.username && (
+          <label>
+            {t("vpnPrompt.username")}
+            <input
+              type="text"
+              value={username}
+              autoComplete="off"
+              placeholder={t("vpnPrompt.usernamePlaceholder")}
+              disabled={connecting}
+              onChange={(e) => setUsername(e.target.value)}
+              onKeyDown={onFieldKey}
+            />
+          </label>
+        )}
         <label>
-          Password
-          <input
+          {needs.username ? t("vpnPrompt.password") : t("vpnPrompt.passphrase")}{" "}
+          <span className="ssh-optional-hint">
+            {t(remember ? "vpnPrompt.savedInKeychain" : "vpnPrompt.notStored")}
+          </span>
+          <PasswordInput
             ref={inputRef}
-            type="password"
             value={password}
             autoFocus
+            disabled={connecting}
             onChange={(e) => setPassword(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === "Enter") {
-                e.preventDefault();
-                onSubmit();
-              }
-              if (e.key === "Escape") {
-                e.preventDefault();
-                cancel();
-              }
-            }}
+            onKeyDown={onFieldKey}
+          />
+        </label>
+        {needsKeyPassphrase && (
+          <label>
+            {t("vpnPrompt.keyPassphraseLabel")}
+            <PasswordInput
+              value={keyPassphrase}
+              autoComplete="off"
+              placeholder={t("vpnPrompt.keyPassphrasePlaceholder")}
+              disabled={connecting}
+              onChange={(e) => setKeyPassphrase(e.target.value)}
+              onKeyDown={onFieldKey}
+            />
+            <span className="ssh-optional-hint">{t("vpnPrompt.keyPassphraseHint")}</span>
+          </label>
+        )}
+        <label className="remote-connect-remember">
+          <Toggle
+            size="sm"
+            checked={remember}
+            disabled={connecting}
+            onChange={(e) => setRemember(e.target.checked)}
           />
+          {t(needsKeyPassphrase ? "vpnPrompt.saveVpnCredentials" : "vpnPrompt.savePassphrase")}
+          <span className="ssh-optional-hint">{t("vpnPrompt.storedSecurely")}</span>
         </label>
+        {(connecting || log.length > 0) && <ConnectionLog lines={log} busy={connecting} />}
+        {connected && (
+          <div className="vpn-prompt-connected" role="status">
+            <span className="vpn-connected-check" aria-hidden="true">✓</span> {t("vpnPrompt.tunnelUp")}
+          </div>
+        )}
+        {status === "error" && error && (
+          <div className="project-dialog-error vpn-prompt-error">{error}</div>
+        )}
+        {/* Said out loud only once an attempt has actually failed. The action itself
+            (below) is always there, but a *failed* login is the moment the reason for
+            it stops being hypothetical: this config may be asking something these two
+            fields cannot answer — a challenge/OTP, or a second prompt — and no amount
+            of retyping will fix that. */}
+        {status === "error" && (
+          <div className="vpn-prompt-reason vpn-prompt-terminal-hint" role="status">
+            {t("vpnPrompt.challengeHintPre")} <strong>{t("vpnPrompt.logInTerminal")}</strong>{" "}
+            {t("vpnPrompt.challengeHintPost")}
+          </div>
+        )}
         <div className="vpn-prompt-actions">
-          <button type="button" onClick={cancel}>
-            Cancel
-          </button>
-          <button type="button" className="primary" onClick={onSubmit}>
-            Connect
-          </button>
+          {connected ? (
+            // The tunnel is up and the connect already resolved — this is a plain
+            // dismissal, so a single Close, no teardown.
+            <button
+              type="button"
+              className="primary vpn-connect-btn"
+              onClick={close}
+              autoFocus
+              title={t("vpnPrompt.closeStaysUpTitle")}
+            >
+              {t("vpnPrompt.close")}
+            </button>
+          ) : (
+            <>
+              {/* Switch this one connect to the non-headless flow: the connect command
+                  goes to a root-terminal tab and OpenVPN asks its own questions there.
+                  Disabled while an attempt is in flight — that attempt would tear the
+                  terminal tunnel back down when it settles (same config), so the user
+                  Stops first. The global headless setting is never touched. */}
+              <button
+                type="button"
+                className="vpn-prompt-terminal-btn"
+                onClick={() => void handoffToTerminal()}
+                disabled={connecting}
+                title={t(connecting ? "vpnPrompt.terminalBtnStopFirst" : "vpnPrompt.terminalBtnHandoff")}
+              >
+                {t("vpnPrompt.logInTerminal")} <UntestedTag />
+              </button>
+              <button
+                type="button"
+                onClick={cancel}
+                title={t(connecting ? "vpnPrompt.cancelTitleConnecting" : "vpnPrompt.closeTitleDefault")}
+              >
+                {t(connecting ? "vpnPrompt.stop" : "common.cancel")}
+              </button>
+              <button
+                type="button"
+                className="primary vpn-connect-btn"
+                onClick={onSubmit}
+                disabled={connecting}
+                title={t(
+                  connecting
+                    ? "vpnPrompt.connectTitleConnecting"
+                    : status === "error"
+                      ? "vpnPrompt.connectTitleError"
+                      : "vpnPrompt.connectTitleDefault",
+                )}
+              >
+                {connecting && <span className="vpn-spinner" aria-hidden="true" />}
+                {t(connecting ? "vpnPrompt.connecting" : status === "error" ? "vpnPrompt.retry" : "vpnPrompt.connect")}
+              </button>
+            </>
+          )}
         </div>
       </div>
     </div>
diff --git a/src/components/monitoring/DiskUsagePane.tsx b/src/components/monitoring/DiskUsagePane.tsx
new file mode 100644
index 0000000..651919e
--- /dev/null
+++ b/src/components/monitoring/DiskUsagePane.tsx
@@ -0,0 +1,645 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { withHpcConfirm } from "../../lib/hpcGuard";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { open } from "@tauri-apps/plugin-dialog";
+
+import {
+  arcColor,
+  flattenRows,
+  formatBytes,
+  layoutRings,
+  ringPath,
+  sharePercent,
+  squarify,
+  OTHERS_COLOR,
+  type DuDevice,
+  type DuNode,
+  type DuProgress,
+  type DuScan,
+} from "../../lib/diskUsage";
+import { FILES_TAB_CMD, useTabsStore } from "../../stores/tabs";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { OrbitSpinner } from "../common/OrbitSpinner";
+
+interface Props {
+  /** Owning project, or `null` in the root scope. */
+  projectId: string | null;
+  /** The project's directory — the "This project" scan shortcut. */
+  projectCwd: string;
+  /**
+   * This pane's tab, so starting a scan can retitle the tab after the folder it is
+   * measuring — several Disk Usage tabs can be open at once, and "Disk Usage" three
+   * times over tells the user nothing. Omitted in a detached pop-out, which runs on
+   * a streamed copy of the tab payloads with no rename channel back to the main
+   * window; the pane then simply keeps its label.
+   */
+  tabKey?: string;
+  visible: boolean;
+}
+
+type Chart = "rings" | "treemap";
+
+/** Rings drawn outside the centre disc. Past this the slices are hairlines. */
+const RING_DEPTH = 6;
+/** Row height of the treeview, in px. Must match `.du-row` in themes.css. */
+const ROW_H = 22;
+/** Rows rendered beyond the viewport on each side, to hide scroll tearing. */
+const OVERSCAN = 8;
+
+// ── Small pure helpers (the interesting maths lives in lib/diskUsage.ts) ───────
+
+function findNode(node: DuNode, path: string): DuNode | null {
+  if (node.path === path) return node;
+  for (const child of node.children) {
+    const hit = findNode(child, path);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+/** The chain from the scan root down to `path`, for the zoom breadcrumb. */
+function trail(root: DuNode, path: string): DuNode[] {
+  if (root.path === path) return [root];
+  for (const child of root.children) {
+    const rest = trail(child, path);
+    if (rest.length) return [root, ...rest];
+  }
+  return [];
+}
+
+function parentDir(path: string): string {
+  const i = path.lastIndexOf("/");
+  return i > 0 ? path.slice(0, i) : "/";
+}
+
+// ── Pane ──────────────────────────────────────────────────────────────────────
+
+export function DiskUsagePane({ projectId, projectCwd, tabKey, visible }: Props) {
+  const [devices, setDevices] = useState<DuDevice[]>([]);
+  const [scan, setScan] = useState<DuScan | null>(null);
+  const [progress, setProgress] = useState<DuProgress | null>(null);
+  const [scanningRoot, setScanningRoot] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const [chart, setChart] = useState<Chart>("rings");
+  const [zoomPath, setZoomPath] = useState<string | null>(null);
+  const [expanded, setExpanded] = useState<ReadonlySet<string>>(new Set());
+  const [hover, setHover] = useState<{ node: DuNode | null; x: number; y: number } | null>(null);
+  const [menu, setMenu] = useState<{ node: DuNode; x: number; y: number } | null>(null);
+
+  /** Id of the scan in flight, so its progress events can be told from a stale one. */
+  const scanIdRef = useRef<string | null>(null);
+
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const sshState = useRemoteStatusStore((s) => (projectId ? s.byProject[projectId]?.ssh : undefined));
+  const addTab = useTabsStore((s) => s.addTab);
+  const renameTab = useTabsStore((s) => s.renameTab);
+
+  const isRemoteProject = !!project?.remote;
+  const hostConnected = isRemoteProject && sshState === "connected";
+  /** A remote project's tree lives on the host; its local `directory` is state. */
+  const projectScanRoot = isRemoteProject ? (project?.remote?.remote_path ?? "") : projectCwd;
+
+  // ── Devices + progress wiring ───────────────────────────────────────────────
+
+  useEffect(() => {
+    if (!visible || devices.length) return;
+    void invoke<DuDevice[]>("disk_usage_devices")
+      .then(setDevices)
+      .catch((e) => setError(String(e)));
+  }, [visible, devices.length]);
+
+  useEffect(() => {
+    const unlisten = listen<DuProgress>("disk-scan-progress", (ev) => {
+      if (ev.payload.scan_id !== scanIdRef.current) return; // another pane's scan
+      if (ev.payload.phase !== "done") setProgress(ev.payload);
+    });
+    return () => {
+      void unlisten.then((off) => off());
+    };
+  }, []);
+
+  const startScan = useCallback(
+    async (root: string, onHost: boolean, label: string) => {
+      // Retitle the tab after what it is measuring, so several open Disk Usage tabs
+      // stay tellable apart. Done HERE, at scan start, and not on completion:
+      // `renameTab` writes to the *current* scope, and panes stay mounted across
+      // project switches — so a long scan finishing after the user has moved on
+      // would retitle a tab in whatever project they switched to. Starting a scan is
+      // a click inside a visible pane, so at this instant the pane's scope IS the
+      // active scope.
+      if (tabKey) renameTab(tabKey, `Disk: ${label}`);
+
+      const scanId = `${projectId ?? "root"}-${crypto.randomUUID()}`;
+      scanIdRef.current = scanId;
+      setScanningRoot(root);
+      setProgress(null);
+      setError(null);
+      setScan(null);
+      try {
+        // On a host tagged HPC the backend refuses this until the user confirms
+        // *this* scan: it stats every file under the root, and on a cluster that
+        // root is normally on the parallel filesystem, where that is a metadata
+        // storm against a shared server (`lib/hpcGuard.ts`). Untagged hosts and
+        // local roots never see the dialog — the refusal never happens for them.
+        const result = await withHpcConfirm((confirmed) =>
+          invoke<DuScan>("disk_usage_scan", {
+            scanId,
+            root,
+            projectId: onHost ? projectId : null,
+            confirmed,
+          }),
+        );
+        // A scan the user cancelled and replaced must not overwrite the new one.
+        if (scanIdRef.current !== scanId) return;
+        setScan(result);
+        setZoomPath(null);
+        setExpanded(new Set([result.root.path]));
+      } catch (e) {
+        if (scanIdRef.current === scanId) setError(String(e));
+      } finally {
+        if (scanIdRef.current === scanId) {
+          scanIdRef.current = null;
+          setScanningRoot(null);
+        }
+      }
+    },
+    [projectId, renameTab, tabKey],
+  );
+
+  function cancelScan() {
+    const id = scanIdRef.current;
+    if (id) void invoke("disk_usage_cancel", { scanId: id }).catch(() => {});
+  }
+
+  async function pickFolder() {
+    const picked = await open({ directory: true, multiple: false, title: "Scan a folder" });
+    if (typeof picked === "string") {
+      void startScan(picked, false, picked.slice(picked.lastIndexOf("/") + 1) || picked);
+    }
+  }
+
+  function backToHome() {
+    setScan(null);
+    setError(null);
+    setHover(null);
+  }
+
+  // ── Derived view state ──────────────────────────────────────────────────────
+
+  const chartRoot = useMemo(() => {
+    if (!scan) return null;
+    return (zoomPath && findNode(scan.root, zoomPath)) || scan.root;
+  }, [scan, zoomPath]);
+
+  const crumbs = useMemo(
+    () => (scan && chartRoot ? trail(scan.root, chartRoot.path) : []),
+    [scan, chartRoot],
+  );
+
+  const rows = useMemo(() => (scan ? flattenRows(scan.root, expanded) : []), [scan, expanded]);
+
+  function toggleExpand(path: string) {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(path)) next.delete(path);
+      else next.add(path);
+      return next;
+    });
+  }
+
+  /** Zoom the chart into a directory, and open the path to it in the treeview. */
+  function zoomTo(node: DuNode) {
+    if (!node.is_dir || !scan) return;
+    setZoomPath(node.path);
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      for (const crumb of trail(scan.root, node.path)) next.add(crumb.path);
+      return next;
+    });
+  }
+
+  // ── Row actions ─────────────────────────────────────────────────────────────
+
+  function openExternally(node: DuNode) {
+    setMenu(null);
+    void invoke("open_file", { path: node.path, projectId }).catch((e) => setError(String(e)));
+  }
+
+  function revealInFiles(node: DuNode) {
+    setMenu(null);
+    addTab({
+      label: node.is_dir ? node.name : "Files",
+      cmd: FILES_TAB_CMD,
+      cwd: node.is_dir ? node.path : parentDir(node.path),
+      kind: "files",
+    });
+  }
+
+  function copyPath(node: DuNode) {
+    setMenu(null);
+    navigator.clipboard?.writeText(node.path).catch(() => {});
+  }
+
+  // ── Render ──────────────────────────────────────────────────────────────────
+
+  if (scanningRoot !== null) {
+    return (
+      <div className="du-root du-centered">
+        <OrbitSpinner />
+        <div className="du-scanning-title">Scanning {scanningRoot}</div>
+        <div className="du-scanning-stats">
+          {progress
+            ? `${progress.dirs.toLocaleString()} folders · ${progress.files.toLocaleString()} files · ${formatBytes(progress.bytes)}`
+            : "Starting…"}
+        </div>
+        <div className="du-scanning-path">{progress?.path ?? ""}</div>
+        <button className="du-btn" onClick={cancelScan}>
+          Cancel
+        </button>
+      </div>
+    );
+  }
+
+  if (!scan) {
+    return (
+      <div className="du-root du-home">
+        <h2 className="du-home-title">Disk Usage Analyzer</h2>
+        {error && <div className="du-error">{error}</div>}
+
+        <div className="du-targets">
+          {devices.map((dev) => (
+            <button
+              key={dev.path}
+              className="du-target"
+              onClick={() => void startScan(dev.path, false, dev.label)}
+            >
+              <span className="du-target-label">{dev.label}</span>
+              <span className="du-target-path">{dev.path}</span>
+              {dev.total_bytes != null && dev.free_bytes != null && (
+                <>
+                  <span className="du-capacity">
+                    <span
+                      className="du-capacity-fill"
+                      style={{
+                        width: `${sharePercent(dev.total_bytes - dev.free_bytes, dev.total_bytes)}%`,
+                      }}
+                    />
+                  </span>
+                  <span className="du-target-caption">
+                    {formatBytes(dev.total_bytes - dev.free_bytes)} of {formatBytes(dev.total_bytes)}{" "}
+                    used
+                  </span>
+                </>
+              )}
+            </button>
+          ))}
+
+          {projectId && projectScanRoot && (
+            <button
+              className="du-target"
+              disabled={isRemoteProject && !hostConnected}
+              onClick={() =>
+                void startScan(projectScanRoot, isRemoteProject, project?.name ?? "project")
+              }
+            >
+              <span className="du-target-label">This project</span>
+              <span className="du-target-path">{projectScanRoot}</span>
+              <span className="du-target-caption">
+                {!isRemoteProject
+                  ? "Local"
+                  : hostConnected
+                    ? `On ${project?.remote?.host}`
+                    : "Connect the project to scan its host"}
+              </span>
+            </button>
+          )}
+
+          <button className="du-target" onClick={() => void pickFolder()}>
+            <span className="du-target-label">Scan a folder…</span>
+            <span className="du-target-caption">Pick any folder on this machine</span>
+          </button>
+        </div>
+      </div>
+    );
+  }
+
+  const total = scan.root.size;
+
+  return (
+    <div className="du-root" onMouseDown={() => setMenu(null)}>
+      <div className="du-toolbar">
+        <button className="du-btn" onClick={backToHome} title="Scan something else">
+          ‹ Scans
+        </button>
+        <div className="du-crumbs">
+          {crumbs.map((crumb, i) => (
+            <span key={crumb.path}>
+              {i > 0 && <span className="du-crumb-sep">/</span>}
+              <button
+                className="du-crumb"
+                disabled={i === crumbs.length - 1}
+                onClick={() => setZoomPath(i === 0 ? null : crumb.path)}
+              >
+                {crumb.name}
+              </button>
+            </span>
+          ))}
+        </div>
+        <span className="du-total">{formatBytes(chartRoot?.size ?? total)}</span>
+        <span className="du-stats">
+          {scan.dirs.toLocaleString()} folders · {scan.files.toLocaleString()} files
+          {scan.errors > 0 && ` · ${scan.errors.toLocaleString()} unreadable`}
+          {scan.cancelled && " · cancelled (partial)"}
+        </span>
+        <span className="du-chart-toggle">
+          <button
+            className={chart === "rings" ? "du-btn active" : "du-btn"}
+            onClick={() => setChart("rings")}
+            title="Rings"
+          >
+            ◍
+          </button>
+          <button
+            className={chart === "treemap" ? "du-btn active" : "du-btn"}
+            onClick={() => setChart("treemap")}
+            title="Treemap"
+          >
+            ▦
+          </button>
+        </span>
+      </div>
+
+      <div className="du-body">
+        <TreeView
+          rows={rows}
+          expanded={expanded}
+          onToggle={toggleExpand}
+          onZoom={zoomTo}
+          onMenu={(node, x, y) => setMenu({ node, x, y })}
+        />
+        <div className="du-chart">
+          {chartRoot && chart === "rings" ? (
+            <Rings
+              root={chartRoot}
+              onZoom={zoomTo}
+              onUp={() =>
+                setZoomPath(crumbs.length > 1 ? (crumbs[crumbs.length - 2].path ?? null) : null)
+              }
+              canGoUp={crumbs.length > 1}
+              onHover={setHover}
+              onMenu={(node, x, y) => setMenu({ node, x, y })}
+            />
+          ) : chartRoot ? (
+            <Treemap
+              root={chartRoot}
+              onZoom={zoomTo}
+              onHover={setHover}
+              onMenu={(node, x, y) => setMenu({ node, x, y })}
+            />
+          ) : null}
+        </div>
+      </div>
+
+      {hover?.node &&
+        createPortal(
+          <div
+            className="activity-tooltip du-tooltip"
+            style={{
+              position: "fixed",
+              left: hover.x,
+              top: hover.y - 8,
+              transform: "translate(-50%, -100%)",
+              pointerEvents: "none",
+              zIndex: 10000,
+            }}
+          >
+            <strong>{hover.node.name}</strong>
+            <br />
+            {formatBytes(hover.node.size)}
+            {chartRoot && chartRoot.size > 0 && (
+              <> · {sharePercent(hover.node.size, chartRoot.size).toFixed(1)}%</>
+            )}
+          </div>,
+          document.body,
+        )}
+
+      {menu &&
+        createPortal(
+          <div
+            className="context-menu du-context-menu"
+            style={{ left: menu.x, top: menu.y }}
+            onMouseDown={(e) => e.stopPropagation()}
+          >
+            <button onClick={() => openExternally(menu.node)}>Open</button>
+            <button onClick={() => revealInFiles(menu.node)}>Reveal in Files tab</button>
+            <button onClick={() => copyPath(menu.node)}>Copy path</button>
+          </div>,
+          document.body,
+        )}
+    </div>
+  );
+}
+
+// ── Treeview ──────────────────────────────────────────────────────────────────
+
+interface TreeViewProps {
+  rows: ReturnType<typeof flattenRows>;
+  expanded: ReadonlySet<string>;
+  onToggle: (path: string) => void;
+  onZoom: (node: DuNode) => void;
+  onMenu: (node: DuNode, x: number, y: number) => void;
+}
+
+/**
+ * Windowed size treeview. A whole-home scan yields far more rows than the DOM
+ * should hold, so only the visible slice is rendered inside a full-height spacer.
+ */
+function TreeView({ rows, expanded, onToggle, onZoom, onMenu }: TreeViewProps) {
+  const [scrollTop, setScrollTop] = useState(0);
+  const [height, setHeight] = useState(600);
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => setHeight(el.clientHeight));
+    ro.observe(el);
+    setHeight(el.clientHeight);
+    return () => ro.disconnect();
+  }, []);
+
+  const first = Math.max(0, Math.floor(scrollTop / ROW_H) - OVERSCAN);
+  const last = Math.min(rows.length, Math.ceil((scrollTop + height) / ROW_H) + OVERSCAN);
+  const slice = rows.slice(first, last);
+
+  return (
+    <div className="du-tree" ref={ref} onScroll={(e) => setScrollTop(e.currentTarget.scrollTop)}>
+      <div style={{ height: rows.length * ROW_H, position: "relative" }}>
+        <div style={{ position: "absolute", top: first * ROW_H, left: 0, right: 0 }}>
+          {slice.map(({ node, depth, parentSize, expandable }) => (
+            <div
+              key={node.path}
+              className={`du-row ${node.is_dir ? "dir" : "file"}`}
+              style={{ height: ROW_H, paddingLeft: 6 + depth * 13 }}
+              onClick={() => (expandable ? onToggle(node.path) : undefined)}
+              onDoubleClick={() => onZoom(node)}
+              onContextMenu={(e) => {
+                e.preventDefault();
+                onMenu(node, e.clientX, e.clientY);
+              }}
+            >
+              <span className="du-row-caret">
+                {expandable ? (expanded.has(node.path) ? "▾" : "▸") : ""}
+              </span>
+              <span className="du-row-name" title={node.path}>
+                {node.name}
+              </span>
+              <span className="du-row-bar">
+                <span
+                  className="du-row-bar-fill"
+                  style={{ width: `${sharePercent(node.size, parentSize)}%` }}
+                />
+              </span>
+              <span className="du-row-size">{formatBytes(node.size)}</span>
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+// ── Charts ────────────────────────────────────────────────────────────────────
+
+/** Measure a chart container, re-measuring when it is revealed (a hidden pane is 0×0). */
+function useChartSize() {
+  const ref = useRef<HTMLDivElement>(null);
+  const [size, setSize] = useState({ w: 0, h: 0 });
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => setSize({ w: el.clientWidth, h: el.clientHeight }));
+    ro.observe(el);
+    setSize({ w: el.clientWidth, h: el.clientHeight });
+    return () => ro.disconnect();
+  }, []);
+  return [ref, size] as const;
+}
+
+interface ChartProps {
+  root: DuNode;
+  onZoom: (node: DuNode) => void;
+  onHover: (h: { node: DuNode | null; x: number; y: number } | null) => void;
+  onMenu: (node: DuNode, x: number, y: number) => void;
+}
+
+function Rings({
+  root,
+  onZoom,
+  onUp,
+  canGoUp,
+  onHover,
+  onMenu,
+}: ChartProps & { onUp: () => void; canGoUp: boolean }) {
+  const [ref, { w, h }] = useChartSize();
+  const arcs = useMemo(() => layoutRings(root, RING_DEPTH), [root]);
+
+  const side = Math.min(w, h);
+  const cx = w / 2;
+  const cy = h / 2;
+  const outer = Math.max(0, side / 2 - 10);
+  const centre = outer * 0.24;
+  const ringW = (outer - centre) / RING_DEPTH;
+
+  return (
+    <div className="du-svg-wrap" ref={ref}>
+      {side > 40 && (
+        <svg width={w} height={h} role="img" aria-label={`Disk usage of ${root.name}`}>
+          {arcs.map((arc) => {
+            const r0 = centre + (arc.depth - 1) * ringW;
+            const node = arc.node;
+            return (
+              <path
+                key={arc.key}
+                className="du-arc"
+                d={ringPath(cx, cy, r0, r0 + ringW, arc.a0, arc.a1)}
+                fill={node ? arcColor(arc.colorIndex, arc.depth) : OTHERS_COLOR}
+                onClick={() => node && onZoom(node)}
+                onMouseMove={(e) => onHover({ node, x: e.clientX, y: e.clientY })}
+                onMouseLeave={() => onHover(null)}
+                onContextMenu={(e) => {
+                  if (!node) return;
+                  e.preventDefault();
+                  onMenu(node, e.clientX, e.clientY);
+                }}
+              />
+            );
+          })}
+          <circle
+            className={canGoUp ? "du-centre up" : "du-centre"}
+            cx={cx}
+            cy={cy}
+            r={centre}
+            onClick={() => canGoUp && onUp()}
+          />
+          <text className="du-centre-name" x={cx} y={cy - 3} textAnchor="middle">
+            {root.name}
+          </text>
+          <text className="du-centre-size" x={cx} y={cy + 12} textAnchor="middle">
+            {formatBytes(root.size)}
+          </text>
+        </svg>
+      )}
+    </div>
+  );
+}
+
+function Treemap({ root, onZoom, onHover, onMenu }: ChartProps) {
+  const [ref, { w, h }] = useChartSize();
+  const cells = useMemo(
+    () => squarify(root, { x: 0, y: 0, w: Math.max(0, w - 2), h: Math.max(0, h - 2) }),
+    [root, w, h],
+  );
+
+  return (
+    <div className="du-svg-wrap" ref={ref}>
+      {w > 20 && h > 20 && (
+        <svg width={w} height={h} role="img" aria-label={`Disk usage of ${root.name}`}>
+          {cells.map((cell) => {
+            const node = cell.node;
+            const label = cell.w > 56 && cell.h > 24;
+            return (
+              <g key={cell.key}>
+                <rect
+                  className="du-cell"
+                  x={cell.x + 1}
+                  y={cell.y + 1}
+                  width={cell.w}
+                  height={cell.h}
+                  fill={node ? arcColor(cell.colorIndex, 1) : OTHERS_COLOR}
+                  onClick={() => node && onZoom(node)}
+                  onMouseMove={(e) => onHover({ node, x: e.clientX, y: e.clientY })}
+                  onMouseLeave={() => onHover(null)}
+                  onContextMenu={(e) => {
+                    if (!node) return;
+                    e.preventDefault();
+                    onMenu(node, e.clientX, e.clientY);
+                  }}
+                />
+                {label && (
+                  <text className="du-cell-label" x={cell.x + 7} y={cell.y + 16}>
+                    {node ? node.name : `${root.hidden_children} more`}
+                  </text>
+                )}
+              </g>
+            );
+          })}
+        </svg>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/monitoring/GlobalMachineMonitorDialog.tsx b/src/components/monitoring/GlobalMachineMonitorDialog.tsx
new file mode 100644
index 0000000..b393f77
--- /dev/null
+++ b/src/components/monitoring/GlobalMachineMonitorDialog.tsx
@@ -0,0 +1,50 @@
+import { createPortal } from "react-dom";
+import { useGlobalMachineMonitorStore } from "../../stores/globalMachineMonitor";
+import { SystemMonitorPane } from "./SystemMonitorPane";
+
+/**
+ * Mounted once (AppShell). Renders the full system-monitor dialog for whichever
+ * global machine `useGlobalMachineMonitorStore` points at — opened from the
+ * header's Machines menu (`MachinesIndicator`), replacing the old inline small
+ * CPU/GPU usage bars with the same htop-like view a project's "System Monitor"
+ * tab shows, via `SystemMonitorPane`'s ad-hoc `globalMachine` mode. Mirrors
+ * `RemoteMachinesDialogHost`'s mount-once/store-driven pattern.
+ */
+export function GlobalMachineMonitorDialogHost() {
+  const machine = useGlobalMachineMonitorStore((s) => s.machine);
+  const close = useGlobalMachineMonitorStore((s) => s.close);
+  if (!machine) return null;
+  return <GlobalMachineMonitorDialog key={machine.id} machine={machine} onClose={close} />;
+}
+
+function GlobalMachineMonitorDialog({
+  machine,
+  onClose,
+}: {
+  machine: { id: string; user?: string; host: string; port?: number; label?: string };
+  onClose: () => void;
+}) {
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="project-dialog dialog-framed sysmon-dialog"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>System monitor — {machine.label || machine.host}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>
+            ×
+          </button>
+        </div>
+        <div className="sysmon-dialog-body">
+          <SystemMonitorPane
+            projectId={null}
+            visible
+            globalMachine={{ user: machine.user, host: machine.host, port: machine.port }}
+          />
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/monitoring/NetworkTrafficPane.tsx b/src/components/monitoring/NetworkTrafficPane.tsx
new file mode 100644
index 0000000..3003b30
--- /dev/null
+++ b/src/components/monitoring/NetworkTrafficPane.tsx
@@ -0,0 +1,697 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { Dropdown } from "../common/Dropdown";
+import { isoWeekKeys, summarizeBuckets } from "../../lib/usageRollup";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useSettingsStore } from "../../stores/settings";
+import { isCarefulHost, primaryTargetOf } from "../../lib/carefulHost";
+import { isHpcHost } from "../../lib/hpcHost";
+
+export interface NetworkInterfaceSnapshot {
+  name: string;
+  rxBytes: number;
+  txBytes: number;
+  up: boolean;
+  loopback: boolean;
+}
+
+export interface NetworkConnectionSnapshot {
+  protocol: string;
+  state: string;
+  localAddress: string;
+  localPort: string;
+  remoteAddress: string;
+  remotePort: string;
+  pid?: number;
+  process?: string;
+}
+
+export interface NetworkHostSnapshot {
+  supported: boolean;
+  remote: boolean;
+  connected: boolean;
+  sampledAtMs: number;
+  hostLabel: string;
+  interfaces: NetworkInterfaceSnapshot[];
+  connections?: NetworkConnectionSnapshot[];
+  warning?: string;
+}
+
+export interface SshLinkSnapshot {
+  supported: boolean;
+  connected: boolean;
+  sampledAtMs: number;
+  connectionId?: string;
+  rxBytes: number;
+  txBytes: number;
+  localEndpoint?: string;
+  remoteEndpoint?: string;
+  warning?: string;
+}
+
+export interface TrafficPoint {
+  at: number;
+  rxRate: number;
+  txRate: number;
+}
+
+interface Props {
+  projectId: string;
+  visible: boolean;
+  onConnect?: () => void;
+}
+
+interface CounterSample {
+  id: string;
+  at: number;
+  rx: number;
+  tx: number;
+}
+
+const HISTORY_POINTS = 300;
+const CONNECTION_POLL_EVERY = 5;
+/** The live cadence, for a local read and for an ordinary remote box. */
+const LIVE_POLL_MS = 1000;
+/** …and the cadence on a **careful** or HPC-tagged host, matching
+ *  `SystemMonitorPane`'s `CAREFUL_POLL_MS` exactly — the same machine must not be
+ *  read gently by one pane and hammered by another. On a remote project the host
+ *  snapshot is a *shell exec on the host* (`commands::network`), so the old fixed
+ *  1 s tick was one command per second against a login node for as long as the
+ *  tab stayed open: precisely the "process causing load over a longer period" a
+ *  cluster's rules reserve the right to kill. */
+const CAREFUL_POLL_MS = 12_000;
+
+export function rateFromSamples(
+  previous: CounterSample | null,
+  next: CounterSample,
+): { rxRate: number; txRate: number; rxDelta: number; txDelta: number } {
+  if (
+    !previous ||
+    previous.id !== next.id ||
+    next.at <= previous.at ||
+    next.rx < previous.rx ||
+    next.tx < previous.tx
+  ) {
+    return { rxRate: 0, txRate: 0, rxDelta: 0, txDelta: 0 };
+  }
+  const seconds = (next.at - previous.at) / 1000;
+  const rxDelta = next.rx - previous.rx;
+  const txDelta = next.tx - previous.tx;
+  return {
+    rxRate: rxDelta / seconds,
+    txRate: txDelta / seconds,
+    rxDelta,
+    txDelta,
+  };
+}
+
+export function aggregateInterfaceCounters(
+  interfaces: NetworkInterfaceSnapshot[],
+  selected: string,
+): { id: string; rx: number; tx: number } {
+  const chosen =
+    selected === "aggregate"
+      ? interfaces.filter((iface) => iface.up && !iface.loopback)
+      : interfaces.filter((iface) => iface.name === selected);
+  return {
+    id: selected,
+    rx: chosen.reduce((sum, iface) => sum + iface.rxBytes, 0),
+    tx: chosen.reduce((sum, iface) => sum + iface.txBytes, 0),
+  };
+}
+
+export interface ByteCounts {
+  rx: number;
+  tx: number;
+}
+
+/** Bucket key ("YYYY-MM-DD" or "YYYY-MM-DDTHH", UTC) → bytes moved in it. */
+export type ByteCountsByBucket = Record<string, ByteCounts>;
+
+/** How many discrete files were downloaded/uploaded by the sync engine. */
+export interface FileCounts {
+  down: number;
+  up: number;
+}
+
+/** Bucket key ("YYYY-MM-DD" or "YYYY-MM-DDTHH", UTC) → files synced in it. */
+export type FileCountsByBucket = Record<string, FileCounts>;
+
+/** Persisted per-project SSH-link usage, at the two granularities stored. */
+export interface NetUsageReport {
+  /** UTC hours ("YYYY-MM-DDTHH"); only the retained window (14 days). */
+  hours: ByteCountsByBucket;
+  /** UTC dates ("YYYY-MM-DD"); full history. */
+  days: ByteCountsByBucket;
+  /** UTC hours ("YYYY-MM-DDTHH"); files transferred, retained window. */
+  fileHours?: FileCountsByBucket;
+  /** UTC dates ("YYYY-MM-DD"); files transferred, full history. */
+  fileDays?: FileCountsByBucket;
+}
+
+export interface NetUsageTotals {
+  hour: ByteCounts;
+  today: ByteCounts;
+  week: ByteCounts;
+  month: ByteCounts;
+  overall: ByteCounts;
+}
+
+export interface NetUsageFileTotals {
+  hour: FileCounts;
+  today: FileCounts;
+  week: FileCounts;
+  month: FileCounts;
+  overall: FileCounts;
+}
+
+// The bucket → calendar-window folding is shared with the usage recap, which
+// reads a store of the same shape (`usage_stats.json`): same UTC keys, same
+// ISO-week alignment, different payload. One implementation, in lib/usageRollup;
+// re-exported here because this pane is where it has always been imported from.
+export { isoWeekKeys };
+
+/**
+ * Fold the persisted usage maps into this-hour / today / this-week / this-month
+ * / overall totals — [`summarizeBuckets`] specialised to byte counts.
+ */
+export function summarizeNetUsage(report: NetUsageReport, nowMs: number): NetUsageTotals {
+  return summarizeBuckets<ByteCounts>(
+    report,
+    nowMs,
+    () => ({ rx: 0, tx: 0 }),
+    (into, counts) => {
+      into.rx += counts?.rx ?? 0;
+      into.tx += counts?.tx ?? 0;
+    },
+  );
+}
+
+/**
+ * Fold the persisted file-count maps into this-hour / today / this-week /
+ * this-month / overall totals — [`summarizeBuckets`] specialised to how many
+ * files the sync engine downloaded/uploaded, mirroring [`summarizeNetUsage`].
+ */
+export function summarizeNetFileUsage(report: NetUsageReport, nowMs: number): NetUsageFileTotals {
+  return summarizeBuckets<FileCounts>(
+    { hours: report.fileHours, days: report.fileDays },
+    nowMs,
+    () => ({ down: 0, up: 0 }),
+    (into, counts) => {
+      into.down += counts?.down ?? 0;
+      into.up += counts?.up ?? 0;
+    },
+  );
+}
+
+export function formatFileCount(value: number): string {
+  return value.toLocaleString();
+}
+
+export function formatBytes(value: number): string {
+  if (!Number.isFinite(value) || value <= 0) return "0 B";
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  const index = Math.min(Math.floor(Math.log(value) / Math.log(1024)), units.length - 1);
+  const scaled = value / 1024 ** index;
+  return `${scaled >= 100 || index === 0 ? scaled.toFixed(0) : scaled.toFixed(1)} ${units[index]}`;
+}
+
+function formatRate(value: number): string {
+  return `${formatBytes(value)}/s`;
+}
+
+function endpoint(address: string, port: string): string {
+  if (!port) return address;
+  const host = address.includes(":") && !address.startsWith("[") ? `[${address}]` : address;
+  return `${host}:${port}`;
+}
+
+function TrafficGraph({ points, pollMs }: { points: TrafficPoint[]; pollMs: number }) {
+  const width = 600;
+  const height = 150;
+  // How far back the graph actually reaches: a fixed point count at a cadence
+  // that is no longer fixed. Stating "5 min" while a gently-polled host shows an
+  // hour would be the kind of quiet mislabel a slower poll is easy to introduce.
+  const spanMin = Math.max(1, Math.round((HISTORY_POINTS * pollMs) / 60000));
+  const max = Math.max(1, ...points.flatMap((point) => [point.rxRate, point.txRate]));
+  const path = (field: "rxRate" | "txRate") =>
+    points
+      .map((point, index) => {
+        const x = points.length <= 1 ? width : (index / (HISTORY_POINTS - 1)) * width;
+        const y = height - (point[field] / max) * (height - 12);
+        return `${index === 0 ? "M" : "L"}${x.toFixed(1)},${y.toFixed(1)}`;
+      })
+      .join(" ");
+
+  return (
+    <div className="network-graph-wrap">
+      <div className="network-graph-scale">peak {formatRate(max)}</div>
+      <svg
+        className="network-graph"
+        viewBox={`0 0 ${width} ${height}`}
+        preserveAspectRatio="none"
+        role="img"
+        aria-label={`${spanMin}-minute receive and transmit rate history`}
+      >
+        <line x1="0" y1={height - 1} x2={width} y2={height - 1} className="network-grid-line" />
+        {points.length > 1 && (
+          <>
+            <path d={path("rxRate")} className="network-line receive" />
+            <path d={path("txRate")} className="network-line transmit" />
+          </>
+        )}
+      </svg>
+      <div className="network-graph-legend">
+        <span className="receive">● Download</span>
+        <span className="transmit">● Upload</span>
+        <span className="network-history-label">rolling {spanMin} min</span>
+      </div>
+    </div>
+  );
+}
+
+function StatusPanel({
+  title,
+  message,
+  reconnect,
+}: {
+  title: string;
+  message: string;
+  reconnect?: () => void;
+}) {
+  return (
+    <div className="network-status-panel">
+      <div className="network-status-title">{title}</div>
+      <div className="network-status-message">{message}</div>
+      {reconnect && (
+        <button className="btn-primary" onClick={reconnect}>
+          Connect
+        </button>
+      )}
+    </div>
+  );
+}
+
+export function NetworkTrafficPane({ projectId, visible, onConnect }: Props) {
+  const [view, setView] = useState<"host" | "link">("host");
+  const [host, setHost] = useState<NetworkHostSnapshot | null>(null);
+  const [link, setLink] = useState<SshLinkSnapshot | null>(null);
+  const [connections, setConnections] = useState<NetworkConnectionSnapshot[]>([]);
+  const [selectedInterface, setSelectedInterface] = useState("aggregate");
+  const [history, setHistory] = useState<TrafficPoint[]>([]);
+  const [sessionRx, setSessionRx] = useState(0);
+  const [sessionTx, setSessionTx] = useState(0);
+  const [query, setQuery] = useState("");
+  const [protocol, setProtocol] = useState<"ALL" | "TCP" | "UDP">("ALL");
+  const [error, setError] = useState<string | null>(null);
+  const [usage, setUsage] = useState<NetUsageReport>({
+    hours: {},
+    days: {},
+    fileHours: {},
+    fileDays: {},
+  });
+  const previous = useRef<CounterSample | null>(null);
+
+  // Whose network this is, and whether it may be read unasked. Two gates, both
+  // about the same fact: on a remote project `network_host_snapshot` runs a
+  // shell command *on the host*.
+  //
+  //  * **The lamp, read here.** The only connectivity check used to be
+  //    `result.connected` — the answer to a request already made, so a project
+  //    whose pool was down still dialled once a second to be told "not
+  //    connected". The SSH state is known before the call; ask it first.
+  //  * **The careful/HPC cadence.** Same constant, same reasoning as the system
+  //    monitor: a shared login node is not to carry a sustained background load,
+  //    and a network tab left open all afternoon at 1 s is exactly that.
+  //
+  // A local project keeps both as they were — there is no host to be careful of,
+  // and the snapshot is a `/proc` read of this machine.
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const settings = useSettingsStore((s) => s.settings);
+  const sshState = useRemoteStatusStore((s) => s.byProject[projectId]?.ssh);
+  const isRemoteProject = !!project?.remote;
+  const sshDown = isRemoteProject && sshState !== "connected";
+  // The HPC tag outranks the Light/Detailed answer, exactly as `SystemMonitorPane`
+  // has it: a machine the user called a cluster login node is read gently whatever
+  // else is stored for it.
+  const carefulHost =
+    isRemoteProject &&
+    (isHpcHost(settings, primaryTargetOf(project)) ||
+      isCarefulHost(settings, primaryTargetOf(project)));
+  // Only the **host** view costs the host anything. The SSH-link view is a local
+  // `ss` read of this machine's own socket (`commands::network`'s
+  // `linux_ssh_link`), so it keeps the live cadence on any machine.
+  const pollMs = carefulHost && view === "host" ? CAREFUL_POLL_MS : LIVE_POLL_MS;
+
+  useEffect(() => {
+    previous.current = null;
+    setHistory([]);
+    setSessionRx(0);
+    setSessionTx(0);
+  }, [view, selectedInterface, projectId]);
+
+  useEffect(() => {
+    // A disconnected remote project samples nothing at all — see `sshDown`.
+    if (!visible || !projectId || sshDown) return;
+    // A hidden tab does not sample. Start with a fresh baseline when it becomes
+    // visible again so bytes transferred while hidden are not folded into the
+    // first visible rate/session-total point.
+    previous.current = null;
+    let cancelled = false;
+    let inFlight = false;
+    let tick = 0;
+
+    const poll = async () => {
+      if (inFlight || cancelled) return;
+      inFlight = true;
+      try {
+        let counterSample: CounterSample | null = null;
+        if (view === "link") {
+          const result = await invoke<SshLinkSnapshot>("network_ssh_link_snapshot", {
+            projectId,
+          });
+          if (cancelled) return;
+          setLink(result);
+          if (result.supported && result.connected) {
+            counterSample = {
+              id: result.connectionId ?? "connected",
+              at: result.sampledAtMs,
+              rx: result.rxBytes,
+              tx: result.txBytes,
+            };
+          } else {
+            previous.current = null;
+          }
+        } else {
+          const includeConnections = tick % CONNECTION_POLL_EVERY === 0;
+          tick += 1;
+          const result = await invoke<NetworkHostSnapshot>("network_host_snapshot", {
+            projectId,
+            includeConnections,
+          });
+          if (cancelled) return;
+          setHost(result);
+          if (result.connections) setConnections(result.connections);
+          if (result.supported && result.connected) {
+            const counters = aggregateInterfaceCounters(result.interfaces, selectedInterface);
+            counterSample = {
+              id: counters.id,
+              at: result.sampledAtMs,
+              rx: counters.rx,
+              tx: counters.tx,
+            };
+          } else {
+            previous.current = null;
+          }
+        }
+        setError(null);
+        if (counterSample) {
+          const rate = rateFromSamples(previous.current, counterSample);
+          previous.current = counterSample;
+          setHistory((current) => [
+            ...current.slice(-(HISTORY_POINTS - 1)),
+            { at: counterSample.at, rxRate: rate.rxRate, txRate: rate.txRate },
+          ]);
+          setSessionRx((value) => value + rate.rxDelta);
+          setSessionTx((value) => value + rate.txDelta);
+        }
+      } catch (reason) {
+        previous.current = null;
+        if (!cancelled) setError(String(reason));
+      } finally {
+        inFlight = false;
+      }
+    };
+
+    void poll();
+    const timer = window.setInterval(() => void poll(), pollMs);
+    return () => {
+      cancelled = true;
+      window.clearInterval(timer);
+    };
+  }, [projectId, selectedInterface, view, visible, sshDown, pollMs]);
+
+  // Persisted per-project SSH-link usage (accrued in the background by
+  // `services::net_usage`), refreshed slowly since it changes at most every
+  // ~30 s. Independent of the 1 s live poll and of the host/link view.
+  useEffect(() => {
+    if (!visible || !projectId) return;
+    let cancelled = false;
+    const load = async () => {
+      try {
+        const data = await invoke<NetUsageReport>("get_net_usage", { projectId });
+        if (!cancelled) {
+          setUsage({
+            hours: data?.hours ?? {},
+            days: data?.days ?? {},
+            fileHours: data?.fileHours ?? {},
+            fileDays: data?.fileDays ?? {},
+          });
+        }
+      } catch {
+        // Leave the last-known totals in place on a transient failure.
+      }
+    };
+    void load();
+    const timer = window.setInterval(() => void load(), 15000);
+    return () => {
+      cancelled = true;
+      window.clearInterval(timer);
+    };
+  }, [projectId, visible]);
+
+  const current = history[history.length - 1] ?? { rxRate: 0, txRate: 0 };
+  // The project's own record, not the last snapshot's: with the poll gated on the
+  // lamp a disconnected remote project has no snapshot to read remoteness from,
+  // and it must still offer its Remote-host / SSH-link tabs.
+  const remote = isRemoteProject || (host?.remote ?? false);
+  const usageTotals = useMemo(() => summarizeNetUsage(usage, Date.now()), [usage]);
+  const fileTotals = useMemo(() => summarizeNetFileUsage(usage, Date.now()), [usage]);
+  const warning = view === "link" ? link?.warning : host?.warning;
+  // "Disconnected" is now something the pane knows rather than something it is
+  // told: nothing was polled, so neither snapshot can report it.
+  const available = sshDown
+    ? false
+    : view === "link"
+      ? link?.supported !== false && link?.connected !== false
+      : host?.supported !== false && host?.connected !== false;
+
+  const filteredConnections = useMemo(() => {
+    const needle = query.trim().toLowerCase();
+    return connections.filter((connection) => {
+      if (protocol !== "ALL" && connection.protocol !== protocol) return false;
+      if (!needle) return true;
+      return [
+        connection.protocol,
+        connection.state,
+        connection.localAddress,
+        connection.localPort,
+        connection.remoteAddress,
+        connection.remotePort,
+        connection.process ?? "",
+        connection.pid?.toString() ?? "",
+      ].some((value) => value.toLowerCase().includes(needle));
+    });
+  }, [connections, protocol, query]);
+
+  if (error && !host && !link) {
+    return <StatusPanel title="Network monitor unavailable" message={error} />;
+  }
+
+  if (!available) {
+    const connected = sshDown ? false : view === "link" ? link?.connected : host?.connected;
+    return (
+      <div className="network-pane">
+        {remote && (
+          <div className="network-view-tabs">
+            <button className={view === "host" ? "active" : ""} onClick={() => setView("host")}>
+              Remote Host
+            </button>
+            <button className={view === "link" ? "active" : ""} onClick={() => setView("link")}>
+              SSH Link
+            </button>
+          </div>
+        )}
+        <StatusPanel
+          title={connected === false ? "SSH project disconnected" : "Collector unsupported"}
+          message={warning ?? error ?? "Network data is unavailable on this platform."}
+          reconnect={connected === false ? onConnect : undefined}
+        />
+      </div>
+    );
+  }
+
+  return (
+    <div className="network-pane">
+      <div className="network-toolbar">
+        <div>
+          <div className="network-heading">Network Traffic</div>
+          <div className="network-subheading">
+            {view === "link"
+              ? `${link?.localEndpoint ?? "local"} ↔ ${link?.remoteEndpoint ?? host?.hostLabel ?? "SSH host"}`
+              : host?.hostLabel ?? "Local host"}
+          </div>
+        </div>
+        {remote && (
+          <div className="network-view-tabs">
+            <button className={view === "host" ? "active" : ""} onClick={() => setView("host")}>
+              Remote Host
+            </button>
+            <button className={view === "link" ? "active" : ""} onClick={() => setView("link")}>
+              SSH Link
+            </button>
+          </div>
+        )}
+        {view === "host" && (
+          <label className="network-interface-select">
+            Interface
+            <Dropdown
+              value={selectedInterface}
+              onChange={setSelectedInterface}
+              options={[
+                { value: "aggregate", label: "Active non-loopback" },
+                ...(host?.interfaces ?? []).map((iface) => ({
+                  value: iface.name,
+                  label: `${iface.name}${!iface.up ? " (down)" : ""}`,
+                })),
+              ]}
+            />
+          </label>
+        )}
+      </div>
+
+      <div className="network-metrics">
+        <div className="network-metric receive">
+          <span>Download</span>
+          <strong>{formatRate(current.rxRate)}</strong>
+          <small>{formatBytes(sessionRx)} this view</small>
+        </div>
+        <div className="network-metric transmit">
+          <span>Upload</span>
+          <strong>{formatRate(current.txRate)}</strong>
+          <small>{formatBytes(sessionTx)} this view</small>
+        </div>
+      </div>
+
+      {remote && (
+        <div className="network-usage-totals">
+          <span className="network-usage-label">SSH-link usage</span>
+          {(
+            [
+              ["This hour", usageTotals.hour],
+              ["Today", usageTotals.today],
+              ["This week", usageTotals.week],
+              ["This month", usageTotals.month],
+              ["Overall", usageTotals.overall],
+            ] as const
+          ).map(([label, counts]) => (
+            <span key={label} className="network-usage-stat">
+              {label} <span className="rx">↓ {formatBytes(counts.rx)}</span>{" "}
+              <span className="tx">↑ {formatBytes(counts.tx)}</span>
+            </span>
+          ))}
+        </div>
+      )}
+
+      {remote && (
+        <div className="network-usage-totals">
+          <span className="network-usage-label">Files synced</span>
+          {(
+            [
+              ["This hour", fileTotals.hour],
+              ["Today", fileTotals.today],
+              ["This week", fileTotals.week],
+              ["This month", fileTotals.month],
+              ["Overall", fileTotals.overall],
+            ] as const
+          ).map(([label, counts]) => (
+            <span key={label} className="network-usage-stat">
+              {label} <span className="rx">↓ {formatFileCount(counts.down)}</span>{" "}
+              <span className="tx">↑ {formatFileCount(counts.up)}</span>
+            </span>
+          ))}
+        </div>
+      )}
+
+      <TrafficGraph points={history} pollMs={pollMs} />
+
+      {warning && <div className="network-warning">{warning}</div>}
+      {error && <div className="network-warning">{error}</div>}
+
+      {view === "host" && (
+        <section className="network-connections">
+          <div className="network-connections-head">
+            <div>
+              <h3>Connections</h3>
+              <span>{filteredConnections.length} visible</span>
+            </div>
+            <div className="network-connection-filters">
+              <input
+                value={query}
+                onChange={(event) => setQuery(event.target.value)}
+                placeholder="Search endpoint, process, PID…"
+                aria-label="Search network connections"
+              />
+              <Dropdown
+                value={protocol}
+                title="Filter connection protocol"
+                onChange={(v) => setProtocol(v as "ALL" | "TCP" | "UDP")}
+                options={[
+                  { value: "ALL", label: "TCP + UDP" },
+                  { value: "TCP", label: "TCP" },
+                  { value: "UDP", label: "UDP" },
+                ]}
+              />
+            </div>
+          </div>
+          <div className="network-table-wrap">
+            <table>
+              <thead>
+                <tr>
+                  <th>Protocol</th>
+                  <th>State</th>
+                  <th>Local</th>
+                  <th>Remote</th>
+                  <th>Process</th>
+                </tr>
+              </thead>
+              <tbody>
+                {filteredConnections.map((connection, index) => (
+                  <tr
+                    key={`${connection.protocol}/${connection.localAddress}/${connection.localPort}/${connection.remoteAddress}/${connection.remotePort}/${connection.pid ?? "x"}/${index}`}
+                  >
+                    <td>{connection.protocol}</td>
+                    <td>{connection.state}</td>
+                    <td>{endpoint(connection.localAddress, connection.localPort)}</td>
+                    <td>{endpoint(connection.remoteAddress, connection.remotePort)}</td>
+                    <td>
+                      {connection.process ?? "—"}
+                      {connection.pid != null ? ` · ${connection.pid}` : ""}
+                    </td>
+                  </tr>
+                ))}
+                {filteredConnections.length === 0 && (
+                  <tr>
+                    <td colSpan={5} className="network-empty-row">
+                      No matching connections
+                    </td>
+                  </tr>
+                )}
+              </tbody>
+            </table>
+          </div>
+          <div className="network-table-note">
+            Host-wide view. Process names are limited to sockets visible to the current user.
+          </div>
+        </section>
+      )}
+      {view === "link" && (
+        <div className="network-link-note">
+          Counts the shared SSH transport. Terminals, SFTP, sync, git, and any projects using
+          the same ControlMaster contribute to these totals.
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/components/monitoring/SystemMonitorPane.tsx b/src/components/monitoring/SystemMonitorPane.tsx
new file mode 100644
index 0000000..142b8f5
--- /dev/null
+++ b/src/components/monitoring/SystemMonitorPane.tsx
@@ -0,0 +1,1750 @@
+import { useEffect, useMemo, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import {
+  formatBytes,
+  formatFan,
+  formatMhz,
+  formatTempC,
+  formatWatts,
+  gpuAdapterTooltip,
+  gpuLinkLabel,
+  gpuPercent,
+  gpuTotals,
+  type GpuProc,
+  type GpuSample,
+} from "../../lib/gpu";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import {
+  carefulIsExplicit,
+  isCarefulHost,
+  setCarefulPatch,
+  targetOfSpec,
+} from "../../lib/carefulHost";
+import { isHpcHost } from "../../lib/hpcHost";
+import { hpcGuardRefusal } from "../../lib/hpcGuard";
+import { useGlobalMachinesStore } from "../../stores/globalMachines";
+import { sameTarget } from "../../lib/machineSync";
+import { ConnLamp } from "../common/ConnLamp";
+import { UntestedTag } from "../common/UntestedTag";
+import { hostsForProject } from "../../lib/remoteHosts";
+import { PRIMARY_HOST, sshOf, useRemoteStatusStore } from "../../stores/remoteStatus";
+
+// ── Backend snapshot shape (mirrors sysstat::SystemSnapshot, snake_case) ──────
+
+export interface CpuTimes {
+  busy: number;
+  total: number;
+}
+
+export interface ProcSample {
+  pid: number;
+  ppid: number;
+  comm: string;
+  cmdline: string;
+  state: string;
+  rss_kib: number;
+  cpu_jiffies: number;
+  threads: number;
+  /** Owning user's name (resolved on the sampled machine's passwd db). Empty when
+   *  the backend can't resolve an owner (Windows/macOS) — the per-user section is
+   *  hidden then. An unmapped uid reads as `#<uid>`. */
+  user: string;
+}
+
+/** One interactive login session on the sampled host (a `who` row). Populated
+ *  only on the **remote** path — the local pane never shows the "Logged in"
+ *  panel, since local sampling is always just this user. */
+export interface LoginSession {
+  user: string;
+  tty: string;
+  /** The rest of the `who` line verbatim — login time and `(origin)`. */
+  detail: string;
+  /** This session belongs to the account Eldrun is connected as. The backend also
+   *  *synthesizes* such a row when `who` has none: utmp only records a session that
+   *  got a pty, and the monitor's own probe rides the pooled (non-pty) master — so
+   *  without it the panel listed every logged-in user except the one reading it. */
+  is_self?: boolean;
+}
+
+export interface SystemSnapshot {
+  supported: boolean;
+  clk_tck: number;
+  num_cores: number;
+  cpu: CpuTimes;
+  per_core: CpuTimes[];
+  mem_total_kib: number;
+  mem_available_kib: number;
+  swap_total_kib: number;
+  swap_free_kib: number;
+  load_avg: [number, number, number];
+  uptime_secs: number;
+  processes: ProcSample[];
+  /** Every GPU whose memory the machine reports; empty when none (see `lib/gpu`). */
+  gpus: GpuSample[];
+  /** Per-process GPU memory — populated only on the remote path (sampled on the
+   *  host); locally the pane fetches `gpu_process_snapshot` instead. */
+  gpu_procs?: GpuProc[];
+  /** Whole-package CPU temperature in °C, or null/undefined when no CPU hwmon
+   *  sensor is present (or on Windows/macOS, which don't read one). */
+  cpu_temp_c?: number | null;
+  /** Hottest DIMM temperature in °C, or null/undefined when the board exposes no
+   *  on-module sensor (`jc42`/`spd5118`) — most desktops don't wire one. */
+  mem_temp_c?: number | null;
+  /** Interactive login sessions on the host (from `who`), backing the "Logged in"
+   *  panel — the same per-user session view the connect-time remote-usage dialog
+   *  shows. Populated only on the remote path; empty locally. */
+  sessions?: LoginSession[];
+  /** Whether the **host** reported itself an HPC node (SLURM on its `PATH`) and
+   *  therefore sampled itself carefully: no other user's account name, command
+   *  line, GPU process or login session is in this snapshot — everyone else's
+   *  processes arrive bucketed under one `other users` label. A cluster login
+   *  node's usage rules don't allow collecting more, and its operators don't want
+   *  a 3-second poll either, so the pane also slows down when this is set
+   *  (`docs/context/hpc_careful_mode.md`). Never set for a local sample. */
+  careful?: boolean;
+}
+
+interface Props {
+  /** Owning project, or `null` in the root scope. A remote (SSH) project unlocks
+   *  a source toggle so the pane can sample the **host** instead of this machine.
+   *  Ignored when `globalMachine` is set. */
+  projectId: string | null;
+  visible: boolean;
+  /** When set, the pane skips the project/host machinery entirely and samples
+   *  this ad-hoc global machine (`stores/globalMachines.ts` — no project, no
+   *  pooled ControlMaster) via `global_machine_monitor_snapshot`, opened by
+   *  `GlobalMachineMonitorDialog` from the header's Machines menu in place of
+   *  its old small inline usage bars. Always treated as a remote source (no
+   *  "This machine" toggle — there is only the one machine to show). */
+  globalMachine?: { user?: string; host: string; port?: number };
+}
+
+/** Which machine the pane samples: this one, or a connected remote project's host.
+ *  A hostId of `PRIMARY_HOST` selects the project's own remote; any other id
+ *  selects a `compute_hosts` worker (`docs/multi_host_remote_plan.md`). */
+type Source = "local" | { hostId: string };
+
+const POLL_MS = 1500;
+/** The host sample is one SSH round-trip reading its whole `/proc`, so it polls
+ *  more gently than the local `/proc` read to keep host load and traffic down. */
+const REMOTE_POLL_MS = 3000;
+/** …and more gently still on an **HPC host** (one that reported `careful`): a
+ *  shared login node is explicitly not to carry a sustained background load, and
+ *  a pane left open all afternoon at 3 s is exactly the "process causing load
+ *  over a longer period" its rules reserve the right to kill. 12 s still tracks a
+ *  job starting; nothing here needs sub-second news. Paired with the unfocused
+ *  pause below — an HPC sample the user isn't looking at costs the cluster for
+ *  nothing. Both apply ONLY to a careful host; an ordinary remote box keeps the
+ *  responsive cadence it always had. */
+const CAREFUL_POLL_MS = 12_000;
+/** What the pane says when a **tagged** host refuses an unattended read. Not an
+ *  error: the backend and this pane agree about it (`lib/hpcGuard.ts`), and a
+ *  machine that is merely waiting to be asked must not read as a broken pane. */
+const HPC_NOT_READ =
+  "Not read — this machine is tagged HPC. Press Refresh above to read it once.";
+
+// ── Pure delta helpers (unit-tested in SystemMonitorSampling.test.ts) ─────────
+
+/**
+ * CPU utilisation of one core (or the aggregate) as a 0–100 percentage, from two
+ * successive cumulative [`CpuTimes`] samples: `(busyΔ / totalΔ) * 100`. Returns 0
+ * with no previous sample, a non-positive total delta, or a negative busy delta
+ * (a counter reset / first frame), and clamps to 100.
+ */
+export function coreUsagePercent(
+  prev: CpuTimes | undefined,
+  next: CpuTimes,
+): number {
+  if (!prev) return 0;
+  const totalDelta = next.total - prev.total;
+  const busyDelta = next.busy - prev.busy;
+  if (totalDelta <= 0 || busyDelta < 0) return 0;
+  return Math.min(100, (busyDelta / totalDelta) * 100);
+}
+
+/**
+ * Per-process CPU% in top's convention (% of a single core, so a fully busy
+ * N-thread process can report up to N*100). Derived from the process's jiffy
+ * delta over the machine's total-CPU-jiffy delta, scaled by core count. Returns
+ * 0 on the first frame (no previous jiffies), a non-positive total delta, or a
+ * negative process delta (pid reuse / exit-respawn).
+ */
+export function procCpuPercent(
+  prevJiffies: number | undefined,
+  nextJiffies: number,
+  totalDelta: number,
+  numCores: number,
+): number {
+  if (prevJiffies === undefined || totalDelta <= 0) return 0;
+  const delta = nextJiffies - prevJiffies;
+  if (delta < 0) return 0;
+  return (delta / totalDelta) * numCores * 100;
+}
+
+/** Resident memory as a 0–100 percentage of total RAM. */
+export function memPercent(rssKib: number, memTotalKib: number): number {
+  if (memTotalKib <= 0) return 0;
+  return (rssKib / memTotalKib) * 100;
+}
+
+// ── Formatting ────────────────────────────────────────────────────────────────
+
+/** Human-readable size from KiB (KiB → MiB → GiB → TiB). */
+function formatKib(kib: number): string {
+  if (kib < 1024) return `${kib} K`;
+  const mib = kib / 1024;
+  if (mib < 1024) return `${mib.toFixed(mib < 10 ? 1 : 0)} M`;
+  const gib = mib / 1024;
+  if (gib < 1024) return `${gib.toFixed(gib < 10 ? 2 : 1)} G`;
+  return `${(gib / 1024).toFixed(2)} T`;
+}
+
+/** Seconds → `Dd HH:MM:SS` / `HH:MM:SS` uptime string. */
+function formatUptime(secs: number): string {
+  const s = Math.floor(secs);
+  const days = Math.floor(s / 86400);
+  const h = Math.floor((s % 86400) / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const hms = `${pad(h)}:${pad(m)}:${pad(sec)}`;
+  return days > 0 ? `${days}d ${hms}` : hms;
+}
+
+/** Green → amber → red tone for a 0–100 load ratio. */
+function toneFor(pct: number): string {
+  if (pct >= 90) return "var(--danger)";
+  if (pct >= 60) return "var(--warning)";
+  return "var(--success)";
+}
+
+/** Traffic-light tone for a utilization percentage, matching the remote-usage
+ *  connect dialog exactly: green when effectively idle (≤5%), orange up to 40%,
+ *  red above — so the per-user "By user" panel reads identically to the session
+ *  stats there. */
+type UsageTone = "green" | "orange" | "red";
+function usageTone(pct: number): UsageTone {
+  if (pct <= 5) return "green";
+  if (pct <= 40) return "orange";
+  return "red";
+}
+
+/** The same green/orange/red dot the remote-usage dialog puts next to a user's
+ *  CPU share (`.remote-usage-light`), reused here so the two panels match. */
+function UsageLight({ pct }: { pct: number }) {
+  const tone = usageTone(pct);
+  return (
+    <span className={`remote-usage-light is-${tone}`} aria-label={`utilization ${tone}`} />
+  );
+}
+
+// ── Derived rows ──────────────────────────────────────────────────────────────
+
+interface ProcRow extends ProcSample {
+  cpu: number;
+  mem: number;
+}
+
+type SortKey = "cpu" | "mem" | "rss_kib" | "pid" | "threads" | "comm";
+
+function buildRows(snap: SystemSnapshot, prev: SystemSnapshot | null): ProcRow[] {
+  const totalDelta = prev ? snap.cpu.total - prev.cpu.total : 0;
+  const prevJiff = new Map<number, number>(
+    prev ? prev.processes.map((p) => [p.pid, p.cpu_jiffies]) : [],
+  );
+  return snap.processes.map((p) => ({
+    ...p,
+    cpu: procCpuPercent(prevJiff.get(p.pid), p.cpu_jiffies, totalDelta, snap.num_cores),
+    mem: memPercent(p.rss_kib, snap.mem_total_kib),
+  }));
+}
+
+function sortRows(rows: ProcRow[], key: SortKey, asc: boolean): ProcRow[] {
+  const dir = asc ? 1 : -1;
+  return [...rows].sort((a, b) => {
+    if (key === "comm") return dir * a.comm.localeCompare(b.comm);
+    return dir * ((a[key] as number) - (b[key] as number));
+  });
+}
+
+/** One user's share of the machine: their summed CPU%/MEM% across every process
+ *  they own, and how many processes that is. This is the same "who's loading the
+ *  host" statistic the connect-time usage dialog shows, but derived from the full
+ *  process table rather than a top-N `ps` sample — so it's exact, not a sample. */
+interface UserRow {
+  user: string;
+  cpu: number;
+  mem: number;
+  count: number;
+}
+
+/** Collapse the process rows into one row per owning user, summing CPU%/MEM% and
+ *  counting processes. Sorted by CPU%, busiest first — the point is spotting who's
+ *  loading the machine. Processes with no resolved owner are ignored (the section
+ *  itself is hidden when *no* process reports one). */
+function groupByUser(rows: ProcRow[]): UserRow[] {
+  const byUser = new Map<string, UserRow>();
+  for (const r of rows) {
+    if (!r.user) continue;
+    const cur = byUser.get(r.user) ?? { user: r.user, cpu: 0, mem: 0, count: 0 };
+    cur.cpu += r.cpu;
+    cur.mem += r.mem;
+    cur.count += 1;
+    byUser.set(r.user, cur);
+  }
+  return [...byUser.values()].sort((a, b) => b.cpu - a.cpu);
+}
+
+/** One logged-in user: how many interactive sessions they hold, plus their summed
+ *  CPU%/MEM% from the full process table. Same look as the connect-time
+ *  remote-usage dialog's "Logged in" row. */
+interface SessionRow {
+  user: string;
+  sessions: number;
+  cpu: number;
+  mem: number;
+  /** The row is the connected account's own — marked "you" and pinned to the top. */
+  isSelf: boolean;
+}
+
+/** Collapse `who`'s login sessions into one row per user — a session count plus
+ *  that user's CPU%/MEM% looked up from the full-table `byUser` breakdown, so the
+ *  compute figures are exact rather than a `ps` sample (which is what the connect
+ *  dialog has to settle for). Sorted by CPU%, busiest first. Unlike "By user"
+ *  (every process owner, including system daemons), this lists only users with an
+ *  actual interactive login — the "who else is on this shared machine?" view. The
+ *  connected account is always among them (the backend synthesizes its row when
+ *  utmp has no record of it, see `LoginSession.is_self`) and is pinned to the top:
+ *  sorting purely by CPU buried the one row the reader is looking for, and on an
+ *  idle-but-shared host it landed at the bottom under everyone else. */
+function groupLoginSessions(
+  sessions: LoginSession[],
+  byUser: Map<string, UserRow>,
+): SessionRow[] {
+  const counts = new Map<string, number>();
+  const order: string[] = [];
+  const selves = new Set<string>();
+  for (const s of sessions) {
+    if (!counts.has(s.user)) order.push(s.user);
+    counts.set(s.user, (counts.get(s.user) ?? 0) + 1);
+    if (s.is_self) selves.add(s.user);
+  }
+  return order
+    .map((user) => {
+      const u = byUser.get(user);
+      return {
+        user,
+        sessions: counts.get(user) ?? 0,
+        cpu: u?.cpu ?? 0,
+        mem: u?.mem ?? 0,
+        isSelf: selves.has(user),
+      };
+    })
+    .sort((a, b) => Number(b.isSelf) - Number(a.isSelf) || b.cpu - a.cpu);
+}
+
+// ── Small presentational bits ─────────────────────────────────────────────────
+
+function Meter({
+  label,
+  pct,
+  caption,
+  title,
+}: {
+  label: string;
+  pct: number;
+  caption?: string;
+  /** Hover detail — the GPU meters use it to name the adapter and split its pools. */
+  title?: string;
+}) {
+  return (
+    <div className="sysmon-meter" title={title}>
+      <span className="sysmon-meter-label">{label}</span>
+      <span className="sysmon-meter-bar">
+        <span
+          className="sysmon-meter-fill"
+          style={{ width: `${Math.min(100, Math.max(0, pct))}%`, background: toneFor(pct) }}
+        />
+      </span>
+      <span className="sysmon-meter-caption">{caption ?? `${pct.toFixed(0)}%`}</span>
+    </div>
+  );
+}
+
+/** One GPU's detail card: identity, memory + utilization meters, live sensors. */
+function GpuSection({ gpu }: { gpu: GpuSample }) {
+  const { used, total } = gpuTotals([gpu]);
+  const link = gpuLinkLabel(gpu);
+  const tip = gpuAdapterTooltip(gpu);
+
+  // A fixed set of sensor slots in a fixed order, always rendered from the first
+  // frame on. A driver that momentarily (or never) answers a sensor shows `n/a`
+  // in its slot rather than dropping the chip — a disappearing chip reflows every
+  // chip to its right, which is the flicker (an idle NVIDIA card blanks
+  // `power.draw` as `[N/A]`). Keeping the slots stable trades a permanent `n/a`
+  // for a sensor a card lacks against a strip that never jumps.
+  const sensors = [
+    { label: "temp", value: formatTempC(gpu.temp_c) },
+    { label: "power", value: formatWatts(gpu.power_w, gpu.power_cap_w) },
+    { label: "core", value: formatMhz(gpu.sclk_mhz) },
+    { label: "mem", value: formatMhz(gpu.mclk_mhz) },
+    { label: "fan", value: formatFan(gpu.fan_percent) },
+  ].map((s) => ({ label: s.label, value: s.value ?? "n/a", present: s.value != null }));
+
+  return (
+    <div className="sysmon-gpu">
+      <div className="sysmon-gpu-head">
+        <span className="sysmon-gpu-name" title={tip}>
+          {gpu.name}
+        </span>
+        <span className="sysmon-gpu-meta">
+          {gpu.driver}
+          {gpu.driver_version ? ` ${gpu.driver_version}` : ""}
+          {link ? ` · ${link}` : ""}
+        </span>
+      </div>
+      <div className="sysmon-gpu-meters">
+        {/* Both memory pools summed — on an APU the dedicated carve-out alone is
+            just the framebuffer (see lib/gpu). */}
+        <Meter
+          label="VRAM"
+          pct={gpuPercent(used, total)}
+          caption={`${formatBytes(used)} / ${formatBytes(total)}`}
+          title={tip}
+        />
+        {/* `busy_percent` is null when the driver won't report it — omit the meter
+            rather than show a misleading 0%. */}
+        {gpu.busy_percent != null && <Meter label="Util" pct={gpu.busy_percent} />}
+      </div>
+      {sensors.length > 0 && (
+        <div className="sysmon-stats sysmon-gpu-sensors">
+          {sensors.map((s) => (
+            <span key={s.label}>
+              {s.label}{" "}
+              <b className={s.present ? undefined : "sysmon-sensor-na"}>{s.value}</b>
+            </span>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/** Top processes by GPU memory. Empty (renders nothing) when the driver reports
+ *  no per-process data — best-effort, so its absence is silent, not an error. */
+function GpuProcList({ procs }: { procs: GpuProc[] }) {
+  const top = procs.filter((p) => p.mem_bytes > 0).slice(0, 8);
+  if (top.length === 0) return null;
+  return (
+    <div className="sysmon-gpu-procs">
+      <div className="sysmon-gpu-procs-head">GPU memory by process</div>
+      {top.map((p) => (
+        <div className="sysmon-gpu-proc" key={p.pid}>
+          <span className="sysmon-gpu-proc-mem">{formatBytes(p.mem_bytes)}</span>
+          <span className="sysmon-gpu-proc-pid">{p.pid}</span>
+          <span className="sysmon-gpu-proc-name" title={p.name}>
+            {p.name || "?"}
+          </span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+export function SystemMonitorPane({ projectId, visible, globalMachine }: Props) {
+  const [pair, setPair] = useState<{ snap: SystemSnapshot; prev: SystemSnapshot | null } | null>(
+    null,
+  );
+  const [error, setError] = useState<string | null>(null);
+  // Per-process GPU memory, local machine only (the remote /proc script doesn't
+  // sample it). Its own command, so the always-visible header never pays for it.
+  const [gpuProcs, setGpuProcs] = useState<GpuProc[]>([]);
+  const [sortKey, setSortKey] = useState<SortKey>("cpu");
+  const [asc, setAsc] = useState(false);
+  const [filter, setFilter] = useState("");
+  // The detailed process table is collapsible so the CPU/GPU vitals can own the
+  // pane; expanded by default (the monitor's main content).
+  const [procOpen, setProcOpen] = useState(true);
+  // The per-user breakdown is collapsible too, expanded by default when present.
+  const [usersOpen, setUsersOpen] = useState(true);
+  // The logged-in-sessions panel (remote hosts only), likewise collapsible.
+  const [sessionsOpen, setSessionsOpen] = useState(true);
+  const prevRef = useRef<SystemSnapshot | null>(null);
+  // Whether this sample is being taken carefully. Seeded from the machine's
+  // stored mode (below) and only ever raised by a snapshot that came back
+  // careful anyway — a host is free to insist, nothing may talk it down. Kept in
+  // a ref *and* state: the poll loop reads the ref (it must not restart to learn
+  // the new cadence), the notice below renders off the state.
+  const carefulRef = useRef(false);
+  const [careful, setCareful] = useState(false);
+  // The live loop's own `poll`, published for the Refresh button below. A tagged
+  // host is sampled once on open and then only when asked, so the button needs to
+  // reach INTO the running effect: re-running the effect to trigger a sample would
+  // drop `prevRef`, the previous sample every CPU% is a delta against.
+  const pollNowRef = useRef<(() => void) | null>(null);
+
+  // A remote (SSH) project can sample its primary host, and — multi-host
+  // (`docs/multi_host_remote_plan.md`) — any connected `compute_hosts` worker
+  // too. Same store reads the Disk Usage pane uses to reach a host over the
+  // shared pool.
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const settings = useSettingsStore((s) => s.settings);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+  const byProject = useRemoteStatusStore((s) => s.byProject);
+  const byHostAll = useRemoteStatusStore((s) => s.byHost);
+  const isRemoteProject = !!project?.remote;
+
+  const hosts = useMemo(() => hostsForProject(project), [project]);
+
+  function connState(hostId: string) {
+    if (!projectId) return "off" as const;
+    return sshOf({ byProject, byHost: byHostAll }, projectId, hostId);
+  }
+  const primaryConnected = isRemoteProject && connState(PRIMARY_HOST) === "connected";
+
+  const [source, setSource] = useState<Source>("local");
+  // Auto-follow the primary host: point at it once it is connected, "local"
+  // otherwise — until the user picks a side explicitly (any host or "local"),
+  // which pins the choice.
+  const pinnedRef = useRef(false);
+  useEffect(() => {
+    if (!pinnedRef.current) setSource(primaryConnected ? { hostId: PRIMARY_HOST } : "local");
+  }, [primaryConnected]);
+  function pickSource(next: Source) {
+    pinnedRef.current = true;
+    setSource(next);
+  }
+
+  // A global machine has no project/host machinery at all — it is always
+  // treated as "on a remote host" (the sessions/by-user panels, the remote poll
+  // cadence) but skips the source toggle and the pooled-connection gate: it
+  // authenticates ad-hoc on every poll, same as the dialog's old small usage bar.
+  const onHost = !!globalMachine || source !== "local";
+  const selectedHostId = !globalMachine && onHost ? (source as { hostId: string }).hostId : null;
+  // A global machine's lamp, from the machines store — not `true`. Every poll of
+  // `global_machine_monitor_snapshot` is a FRESH SSH login (a global machine pools
+  // nothing), so assuming "connected" kept a whole login sequence running per tick
+  // against a machine whose lamp was off, red, or never lit.
+  //
+  // `status`, deliberately, and never `reachable`: the first means "a session this
+  // app opened", the second only "a probe once got an answer"
+  // (`stores/globalMachines`). Sampling is a session's worth of work, so it is the
+  // first that licenses it. The machine is matched by SSH target rather than by id
+  // because this pane is handed a `{user, host, port}` and nothing else.
+  const machines = useGlobalMachinesStore((s) => s.machines);
+  const machineStatus = useGlobalMachinesStore((s) => s.status);
+  const globalMachineConnected =
+    !!globalMachine &&
+    machineStatus[machines.find((m) => sameTarget(m, globalMachine))?.id ?? ""] === "connected";
+  const hostConnected = globalMachine
+    ? globalMachineConnected
+    : onHost && selectedHostId != null && connState(selectedHostId) === "connected";
+  const selectedHost = hosts.find((h) => h.id === selectedHostId) ?? null;
+  const remoteHost = onHost
+    ? (globalMachine ? "this machine" : (selectedHost?.label ?? "the host"))
+    : "the host";
+  // Whether the pane is actually sampling (and so the table/meters below apply).
+  const sampling = visible && !(onHost && !hostConnected);
+
+  // ── Careful vs. normal, per machine ────────────────────────────────────────
+  // The SSH target of whatever this pane is pointed at — a global machine, the
+  // project's primary, or a worker. That target (not the host id) is what the
+  // careful flag is keyed by, so one physical login node reads the same here, in
+  // the Machines menu and in the remote hub (`lib/carefulHost.ts`).
+  const carefulTarget = globalMachine ? targetOfSpec(globalMachine) : (selectedHost?.target ?? null);
+  // The mode asked for: careful for every remote machine until the user says
+  // this one is theirs. A local sample is never careful — Eldrun is not a guest
+  // on the machine it runs on.
+  // The HPC tag (`lib/hpcHost.ts`) outranks that answer in one direction: a
+  // machine the user called a cluster login node is read lightly even if its
+  // careful answer says "this one is mine". The two say different things — how
+  // much may Eldrun look at, and is this a shared cluster — and there is no
+  // reading of the second that permits the first's full collection. The backend
+  // enforces the same precedence, so this is the UI agreeing with it, not the
+  // place it is decided.
+  const hpcTagged = isHpcHost(settings, carefulTarget);
+  const carefulMode = onHost && (hpcTagged || isCarefulHost(settings, carefulTarget));
+  const carefulExplicit = carefulIsExplicit(settings, carefulTarget);
+  // Named, not "this machine": the switch is per *machine*, and its answer is
+  // shared with every other project and surface pointing at the same host.
+  const carefulMachineName = globalMachine
+    ? globalMachine.host
+    : (selectedHost?.label ?? carefulTarget?.host ?? "");
+
+  // Poll only while visible and (for the host) while it is connected; the pane
+  // stays mounted across scope switches, so pausing here stops a hidden monitor
+  // from sampling in the background (mirrors AppResourceDisplay /
+  // NetworkTrafficPane). CPU/MEM percentages are diffs of successive samples, so
+  // switching machine drops the stale previous sample — a delta across two
+  // different machines is meaningless.
+  useEffect(() => {
+    prevRef.current = null;
+    setPair(null);
+    setError(null);
+    setGpuProcs([]);
+    carefulRef.current = carefulMode;
+    setCareful(carefulMode);
+    if (!sampling) return;
+    let cancelled = false;
+    let inFlight = false;
+    let timer: number | undefined;
+    // Self-rescheduling rather than a fixed `setInterval`: the cadence depends on
+    // what the FIRST sample says the host is (careful ⇒ HPC ⇒ gentle), and
+    // re-running this effect to change an interval would throw away `prevRef` —
+    // the previous sample every CPU% is a delta against.
+    function schedule() {
+      if (cancelled) return;
+      // A **tagged** host gets no timer at all. 12 s is gentler than 3 s, not
+      // absent, and what the tag promises is that nothing reaches a shared login
+      // node without a gesture — so it is sampled once when the pane opens (that
+      // opening IS the gesture) and thereafter only when Refresh is pressed. The
+      // backend enforces the same rule from its side via `background`.
+      if (hpcTagged) return;
+      const delay = carefulRef.current ? CAREFUL_POLL_MS : onHost ? REMOTE_POLL_MS : POLL_MS;
+      timer = window.setTimeout(() => void poll(false), delay);
+    }
+    /** `gesture` = the user asked for this one (the pane opening, or Refresh).
+     *  It is what the backend's `background: false` means, and it also excuses the
+     *  unfocused pause below — a click is not a background poll. */
+    async function poll(gesture: boolean) {
+      // An HPC host is not polled while the user is looking at something else:
+      // the sample costs a shared login node real work, and a pane nobody is
+      // reading has nothing to show for it. Only careful hosts — a local read or
+      // an ordinary remote box keeps sampling in the background as before.
+      if (carefulRef.current && !gesture && !document.hasFocus()) {
+        schedule();
+        return;
+      }
+      // Two Refresh clicks must not become two logins in flight.
+      if (inFlight) return;
+      inFlight = true;
+      try {
+        // `careful` is the machine's stored mode, and it is authoritative in
+        // BOTH directions — careful by default, normal only where the user said
+        // this machine is theirs. Passing it on every poll (rather than letting
+        // the host decide) is what makes the switch below take effect on the
+        // very first sample instead of after a probe has classified the host.
+        const next = globalMachine
+          ? await invoke<SystemSnapshot>("global_machine_monitor_snapshot", {
+              user: globalMachine.user,
+              host: globalMachine.host,
+              port: globalMachine.port,
+              careful: carefulMode,
+              // Omitted ⇒ background ⇒ refused on a tagged host. Only a sample the
+              // user asked for says otherwise, so a timer can never spell itself
+              // as a gesture: the flag is the *caller's* claim, and a claim that
+              // defaults to "unattended" can only fail closed.
+              background: !gesture,
+            })
+          : await invoke<SystemSnapshot>("system_monitor_snapshot", {
+              projectId: onHost ? projectId : null,
+              hostId: onHost ? selectedHostId : null,
+              careful: onHost ? carefulMode : null,
+            });
+        if (cancelled) return;
+        if (next.careful && !carefulRef.current) {
+          carefulRef.current = true;
+          setCareful(true);
+        }
+        const prev = prevRef.current;
+        prevRef.current = next;
+        setPair({ snap: next, prev });
+        setError(null);
+        // The host samples its own per-process GPU memory into the snapshot; the
+        // local machine has a dedicated command for it (kept off the shared,
+        // always-polled snapshot). Best-effort either way — an empty list means
+        // "no per-process data", not an error.
+        if (onHost) {
+          if (!cancelled) setGpuProcs(next.gpu_procs ?? []);
+        } else {
+          try {
+            const procs = await invoke<GpuProc[]>("gpu_process_snapshot");
+            if (!cancelled) setGpuProcs(procs);
+          } catch {
+            if (!cancelled) setGpuProcs([]);
+          }
+        }
+      } catch (e) {
+        // A tagged host refusing an unattended read is the tag working, not a
+        // failure — say so, rather than printing the raw sentinel.
+        if (!cancelled) setError(hpcGuardRefusal(e) ? HPC_NOT_READ : String(e));
+      } finally {
+        inFlight = false;
+        schedule();
+      }
+    }
+    // The pane opening is itself a request for one reading — the only sample a
+    // tagged host takes until Refresh is pressed.
+    pollNowRef.current = () => void poll(true);
+    void poll(true);
+    return () => {
+      cancelled = true;
+      pollNowRef.current = null;
+      if (timer !== undefined) window.clearTimeout(timer);
+    };
+  }, [
+    sampling,
+    onHost,
+    // A tag flip changes the whole loop shape (timer vs. on-demand), and it can
+    // move without `carefulMode` doing so — untagging a machine the user had also
+    // marked careful leaves it careful.
+    hpcTagged,
+    // Flipping the machine's mode restarts the loop on purpose: the two modes
+    // collect different things, so a delta across the switch would be a delta
+    // between two different readings of the machine.
+    carefulMode,
+    projectId,
+    selectedHostId,
+    globalMachine?.user,
+    globalMachine?.host,
+    globalMachine?.port,
+  ]);
+
+  // Every process, before the table's text filter — the per-user breakdown sums
+  // over the whole machine, not just what the filter happens to show.
+  const allRows = useMemo(() => (pair ? buildRows(pair.snap, pair.prev) : []), [pair]);
+
+  const rows = useMemo(() => {
+    const q = filter.trim().toLowerCase();
+    const filtered = q
+      ? allRows.filter(
+          (r) =>
+            r.comm.toLowerCase().includes(q) ||
+            r.cmdline.toLowerCase().includes(q) ||
+            String(r.pid) === q,
+        )
+      : allRows;
+    return sortRows(filtered, sortKey, asc);
+  }, [allRows, filter, sortKey, asc]);
+
+  const userRows = useMemo(() => groupByUser(allRows), [allRows]);
+  const hasUserData = userRows.length > 0;
+
+  // Logged-in sessions (from the host's `who`), attributed CPU/MEM from the
+  // full-table per-user sums. Remote-only — a local snapshot carries no sessions.
+  const sessionRows = useMemo(() => {
+    const sessions = pair?.snap.sessions;
+    if (!sessions || sessions.length === 0) return [];
+    const byUser = new Map(userRows.map((u) => [u.user, u]));
+    return groupLoginSessions(sessions, byUser);
+  }, [pair, userRows]);
+  const hasSessions = sessionRows.length > 0;
+
+  function toggleSort(key: SortKey) {
+    if (key === sortKey) {
+      setAsc((a) => !a);
+    } else {
+      setSortKey(key);
+      // Text sorts ascending by default; numeric metrics descending (biggest first).
+      setAsc(key === "comm");
+    }
+  }
+
+  const snap = pair?.snap;
+  const coreUsages = useMemo(
+    () => (snap ? snap.per_core.map((c, i) => coreUsagePercent(pair?.prev?.per_core[i], c)) : []),
+    [snap, pair],
+  );
+  // Fallback when a backend can't enumerate per-core times (e.g. the Windows
+  // ntdll per-core query fails, or any OS returning an empty `per_core`): the
+  // aggregate `cpu` field is always populated, so show one machine-wide bar
+  // rather than an empty CPU section.
+  const aggregateUsage = useMemo(
+    () => (snap ? coreUsagePercent(pair?.prev?.cpu, snap.cpu) : 0),
+    [snap, pair],
+  );
+
+  const arrow = (key: SortKey) => (key === sortKey ? (asc ? " ▲" : " ▼") : "");
+  /** Marks the active sort column's header AND its body cells (`.sysmon-table
+   *  th.sorted` / `td.sorted`) so the whole column reads as one accent band. */
+  const sortedCls = (key: SortKey) => (key === sortKey ? "sorted" : undefined);
+
+  return (
+    <div className="sysmon-root">
+      <style>{SYSMON_CSS}</style>
+
+      {/* One row: which machine on the left, how it is read on the right. The
+          row survives on its own for a global machine (no source tabs — there is
+          only the one machine), so the mode switch is in the same place in the
+          tab and in the Machines-menu dialog. */}
+      {(isRemoteProject || (onHost && carefulTarget)) && (
+        <div className="sysmon-source">
+          {isRemoteProject && (
+            <div className="sysmon-source-tabs" role="tablist" aria-label="Monitor source">
+              <button
+                className={source === "local" ? "sysmon-source-btn active" : "sysmon-source-btn"}
+                onClick={() => pickSource("local")}
+                role="tab"
+                aria-selected={source === "local"}
+              >
+                This machine
+              </button>
+              {/* One button per connected machine — the primary and every multi-host
+                  `compute_hosts` worker — each carrying its own live SSH traffic light
+                  (the same `ConnLamp` the Remote machines window shows per row), so a
+                  worker's status is visible right where its usage would be sampled. */}
+              {hosts.map((h) => {
+                const state = connState(h.id);
+                const connected = state === "connected";
+                const active = onHost && selectedHostId === h.id;
+                return (
+                  <button
+                    key={h.id}
+                    className={active ? "sysmon-source-btn active" : "sysmon-source-btn"}
+                    onClick={() => pickSource({ hostId: h.id })}
+                    role="tab"
+                    aria-selected={active}
+                    title={connected ? `System monitor on ${h.label}` : `${h.label}: ${state}`}
+                  >
+                    <ConnLamp status={state} label={h.label} />
+                    {h.label}
+                  </button>
+                );
+              })}
+            </div>
+          )}
+
+          {/* How the selected machine is read. Light is the default for every
+              remote machine — Eldrun has no way to tell whose machine it is, and
+              the wrong guess in the other direction is a policy violation on
+              someone else's cluster rather than a thinner table. Switching to
+              Detailed is a statement about that machine ("this one is mine"),
+              so it is stored per SSH target and holds for every surface that
+              reads the flag, not just this pane. Local sampling has no switch:
+              it is always the full reading.
+
+              Compact by design: it sits beside the machine tabs, and the question
+              it answers ("how much of this host am I reading?") is one you ask
+              rarely — an always-visible pair of word buttons would compete with
+              the machine you are actually picking. So the *selected* mode is
+              named and lit, and the alternative is a greyed icon that gives up
+              its label on hover. */}
+          {onHost && carefulTarget && (
+            <>
+              <span className="sysmon-mode-tag">
+                <UntestedTag />
+              </span>
+              <div
+                className="sysmon-mode"
+                role="radiogroup"
+                aria-label={`Reading${carefulMachineName ? ` for ${carefulMachineName}` : ""}`}
+              >
+                <button
+                  className={carefulMode ? "sysmon-mode-btn active" : "sysmon-mode-btn"}
+                  onClick={() => void updateSettings(setCarefulPatch(settings, carefulTarget, true))}
+                  role="radio"
+                  aria-checked={carefulMode}
+                  title={`Light reading of ${carefulMachineName || "this machine"}${
+                    carefulMode && !carefulExplicit ? " (the default for a remote machine)" : ""
+                  }: only your own processes in full, everyone else counted anonymously, and a slow poll that pauses while Eldrun is in the background. For a login node or any machine you share.`}
+                >
+                  <span className="sysmon-mode-icon" aria-hidden="true">
+                    🪶
+                  </span>
+                  <span className="sysmon-mode-txt">Light</span>
+                </button>
+                <button
+                  className={
+                    !carefulMode
+                      ? "sysmon-mode-btn active"
+                      : hpcTagged
+                        ? "sysmon-mode-btn sysmon-mode-btn-locked"
+                        : "sysmon-mode-btn"
+                  }
+                  onClick={() =>
+                    void updateSettings(setCarefulPatch(settings, carefulTarget, false))
+                  }
+                  // Not merely styled as unavailable — actually unavailable. A tag
+                  // the user could click past on the machine it protects would
+                  // only ever be clicked past on the machine that needed it.
+                  disabled={hpcTagged}
+                  role="radio"
+                  aria-checked={!carefulMode}
+                  title={
+                    hpcTagged
+                      ? `${carefulMachineName || "This machine"} is tagged HPC, so it is always read lightly. Untag it in the Machines menu if it is not a shared cluster login node.`
+                      : `Detailed reading of ${carefulMachineName || "this machine"}: every process with its owner and command line, at the ordinary remote cadence — the same reading this machine gets. Remembered for this host. For a machine that is yours.`
+                  }
+                >
+                  <span className="sysmon-mode-icon" aria-hidden="true">
+                    🔬
+                  </span>
+                  <span className="sysmon-mode-txt">Detailed</span>
+                </button>
+              </div>
+              {/* The only thing that reads a tagged machine after the pane's first
+                  sample. It is a plain button rather than a cadence control on
+                  purpose: the choice the tag takes away is "how often", and what
+                  is left is "now". Borrows the machine tabs' style — it belongs to
+                  the same row and needs no look of its own. */}
+              {hpcTagged && (
+                <button
+                  type="button"
+                  className="sysmon-source-btn"
+                  onClick={() => pollNowRef.current?.()}
+                  disabled={!sampling}
+                  title={`Read ${carefulMachineName || "this machine"} once. It is tagged HPC, so nothing samples it on a timer — a shared login node is not to carry a background load nobody asked for.`}
+                >
+                  ↻ Refresh
+                </button>
+              )}
+            </>
+          )}
+        </div>
+      )}
+
+      {onHost && !hostConnected ? (
+        <div className="sysmon-placeholder">
+          {/* A global machine has no project to connect — it is connected from the
+              Machines menu the pane was opened out of, so the placeholder points
+              there rather than at a project that doesn't exist. */}
+          {globalMachine
+            ? `Connect ${carefulMachineName || "this machine"} in the Machines menu to view its system monitor.`
+            : `Connect this project to view ${remoteHost}’s system monitor.`}
+        </div>
+      ) : snap && !snap.supported ? (
+        <div className="sysmon-placeholder">
+          The system monitor is currently available on Linux only.
+        </div>
+      ) : !snap ? (
+        <div className="sysmon-placeholder">{error ?? "Sampling…"}</div>
+      ) : (
+        // One scroll region for the whole body (a single scrollbar): the vitals and
+        // the process table scroll together, the table's sticky thead pinning to this
+        // scroller.
+        <div className="sysmon-scroll">
+          {/* Why this host's table looks thinner than a normal one. Said plainly,
+              because a silently reduced reading is worse than no reading: a login
+              node full of unnamed rows would otherwise read as a bug. */}
+          {careful && (
+            <div className="sysmon-careful-note">
+              <b>Light reading.</b> Only your own processes are shown in full — everyone
+              else&rsquo;s are counted as <i>other users</i> without names or commands, and
+              this host is{" "}
+              {hpcTagged ? (
+                <>
+                  sampled <b>once</b>, then only when you press <b>Refresh</b> above — it
+                  is tagged HPC, and a timer against a shared login node is the
+                  unattended load the tag exists to stop
+                </>
+              ) : (
+                <>
+                  sampled every {Math.round(CAREFUL_POLL_MS / 1000)}s (and not at all
+                  while Eldrun is in the background)
+                </>
+              )}
+              . It is how every remote machine is
+              sampled until you say otherwise: a shared cluster&rsquo;s usage rules don&rsquo;t
+              allow collecting other people&rsquo;s account names or command lines, and a
+              login node shouldn&rsquo;t carry a constant poll. Switch this machine to{" "}
+              <b>Detailed</b> above if it is yours.
+            </div>
+          )}
+          {/* Hardware vitals as two columns: CPU over Memory on the left, the GPU
+              cards on the right (when the machine has one) — separated by a divider —
+              so the GPU's VRAM + Util meters and sensor strip sit beside the CPU. */}
+          <div className="sysmon-vitals">
+            <div className="sysmon-vitals-left">
+              <div className="sysmon-cpu-group">
+                <div className="sysmon-group-title">
+                  CPU
+                  <span className="sysmon-group-sub">{snap.num_cores} cores</span>
+                </div>
+                <div className="sysmon-cores">
+                  {coreUsages.length > 0 ? (
+                    coreUsages.map((pct, i) => <Meter key={i} label={`${i}`} pct={pct} />)
+                  ) : (
+                    <Meter label="all" pct={aggregateUsage} />
+                  )}
+                </div>
+                {/* System-load stats belong with the CPU: load average, task count,
+                    uptime, and CPU package temperature (when a hwmon sensor exposes
+                    one — omitted rather than shown as a fake zero). */}
+                <div className="sysmon-stats">
+                  <span>
+                    load <b>{snap.load_avg.map((n) => n.toFixed(2)).join(" ")}</b>
+                  </span>
+                  <span>
+                    tasks <b>{snap.processes.length}</b>
+                  </span>
+                  <span>
+                    up <b>{formatUptime(snap.uptime_secs)}</b>
+                  </span>
+                  {snap.cpu_temp_c != null && (
+                    <span>
+                      cpu temp <b>{formatTempC(snap.cpu_temp_c)}</b>
+                    </span>
+                  )}
+                </div>
+              </div>
+              <div className="sysmon-mem-group">
+                <div className="sysmon-group-title">Memory</div>
+                <Meter
+                  label="Mem"
+                  pct={memPercent(snap.mem_total_kib - snap.mem_available_kib, snap.mem_total_kib)}
+                  caption={`${formatKib(snap.mem_total_kib - snap.mem_available_kib)} / ${formatKib(
+                    snap.mem_total_kib,
+                  )}`}
+                />
+                <Meter
+                  label="Swp"
+                  pct={
+                    snap.swap_total_kib > 0
+                      ? memPercent(snap.swap_total_kib - snap.swap_free_kib, snap.swap_total_kib)
+                      : 0
+                  }
+                  caption={
+                    snap.swap_total_kib > 0
+                      ? `${formatKib(snap.swap_total_kib - snap.swap_free_kib)} / ${formatKib(
+                          snap.swap_total_kib,
+                        )}`
+                      : "none"
+                  }
+                />
+                <div className="sysmon-stats">
+                  <span>
+                    avail <b>{formatKib(snap.mem_available_kib)}</b>
+                  </span>
+                  <span>
+                    used{" "}
+                    <b>
+                      {memPercent(
+                        snap.mem_total_kib - snap.mem_available_kib,
+                        snap.mem_total_kib,
+                      ).toFixed(0)}
+                      %
+                    </b>
+                  </span>
+                  {snap.swap_total_kib > 0 && (
+                    <span>
+                      swap free <b>{formatKib(snap.swap_free_kib)}</b>
+                    </span>
+                  )}
+                  {/* Hottest DIMM temperature, when the board wires an on-module
+                      sensor (jc42/spd5118); omitted otherwise — most desktops have none. */}
+                  {snap.mem_temp_c != null && (
+                    <span>
+                      mem temp <b>{formatTempC(snap.mem_temp_c)}</b>
+                    </span>
+                  )}
+                </div>
+              </div>
+            </div>
+
+            {/* The GPU detail column: one card per adapter — VRAM + utilization
+                meters and its live sensors — then (local only) the processes using
+                GPU memory, listed once since the sources don't attribute them per
+                card. Rendered only when the machine reports a GPU. */}
+            {(snap.gpus ?? []).length > 0 && (
+              <div className="sysmon-vitals-right">
+                <div className="sysmon-group-title">
+                  GPU
+                  <span className="sysmon-group-sub">
+                    {(snap.gpus ?? []).length}{" "}
+                    {(snap.gpus ?? []).length === 1 ? "adapter" : "adapters"}
+                  </span>
+                </div>
+                {(snap.gpus ?? []).map((gpu, i) => (
+                  <GpuSection key={`${gpu.name}-${i}`} gpu={gpu} />
+                ))}
+                <GpuProcList procs={gpuProcs} />
+              </div>
+            )}
+          </div>
+
+          {/* Logged-in sessions: who is actually logged in on this shared host
+              right now (from `who`), grouped by user with a session count — the
+              same "Logged in" panel the connect-time remote-usage dialog shows,
+              rendered in its exact look. Remote-host only (a local snapshot carries
+              no sessions), and distinct from "By user" below: this lists only users
+              with an interactive login, that one every process owner. **You are
+              always in it** — `who` reads utmp, which records a session only when
+              sshd allocated a pty, and the monitor's own probe rides the pooled
+              (non-PTY) master, so a host with no terminal tab open on it used to
+              list every logged-in person *except* the reader; the backend now
+              synthesizes that row (`LoginSession.is_self`) and it is pinned to the
+              top with a "you" chip. The section is still shown when the list is
+              empty — a host that couldn't even name the account has nothing to
+              synthesize from — rather than silently dropped (which read as "only
+              the primary has this panel"). */}
+          {onHost && (
+            <>
+              <div className="sysmon-proc-head">
+                <button
+                  type="button"
+                  className="sysmon-proc-toggle"
+                  onClick={() => setSessionsOpen((v) => !v)}
+                  aria-expanded={sessionsOpen}
+                  title={sessionsOpen ? "Collapse logged-in sessions" : "Expand logged-in sessions"}
+                >
+                  <span className="sysmon-proc-caret">{sessionsOpen ? "▾" : "▸"}</span>
+                  <span className="sysmon-group-title">Logged in</span>
+                  <UntestedTag />
+                </button>
+                <span className="sysmon-count">
+                  {sessionRows.length} {sessionRows.length === 1 ? "user" : "users"}
+                </span>
+              </div>
+              {sessionsOpen &&
+                (hasSessions ? (
+                  <div className="sysmon-users">
+                    <ul className="remote-usage-users">
+                      <li className="remote-usage-users-head" aria-hidden="true">
+                        <span>User</span>
+                        <span>CPU</span>
+                        <span>Sessions</span>
+                        <span>Mem</span>
+                      </li>
+                      {sessionRows.map((s) => (
+                        <li key={s.user}>
+                          <span className="remote-usage-user">
+                            {s.user}
+                            {s.isSelf && (
+                              <span
+                                className="remote-usage-user-you"
+                                title="The account Eldrun is connected as"
+                              >
+                                you
+                              </span>
+                            )}
+                          </span>
+                          <span className="remote-usage-user-cpu">
+                            <UsageLight pct={s.cpu} />
+                            {s.cpu.toFixed(0)}%
+                          </span>
+                          <span className="remote-usage-user-sessions">{s.sessions}</span>
+                          <span className="remote-usage-user-mem">{s.mem.toFixed(0)}%</span>
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
+                ) : (
+                  <div className="sysmon-users sysmon-users-empty">
+                    No interactive logins on this host.
+                  </div>
+                ))}
+            </>
+          )}
+
+          {/* Per-user breakdown: who is loading the machine, summed over the whole
+              process table. Shown for a **remote host only** — it exists to answer
+              "who else is on this shared machine?", the same question the
+              connect-time usage dialog's session stats answer, and it is rendered
+              in that dialog's exact look (the `.remote-usage-users` grid + its
+              traffic-light dot). Local sampling is always just this user, so the
+              panel would be a single trivial row — hidden there. Still gated on the
+              host resolving process owners (Linux only; never Windows/macOS). */}
+          {onHost && hasUserData && (
+            <>
+              <div className="sysmon-proc-head">
+                <button
+                  type="button"
+                  className="sysmon-proc-toggle"
+                  onClick={() => setUsersOpen((v) => !v)}
+                  aria-expanded={usersOpen}
+                  title={usersOpen ? "Collapse per-user usage" : "Expand per-user usage"}
+                >
+                  <span className="sysmon-proc-caret">{usersOpen ? "▾" : "▸"}</span>
+                  <span className="sysmon-group-title">By user</span>
+                  <UntestedTag />
+                </button>
+                <span className="sysmon-count">
+                  {userRows.length} {userRows.length === 1 ? "user" : "users"}
+                </span>
+              </div>
+              {usersOpen && (
+                <div className="sysmon-users">
+                  <ul className="remote-usage-users">
+                    <li className="remote-usage-users-head" aria-hidden="true">
+                      <span>User</span>
+                      <span>CPU</span>
+                      <span>Procs</span>
+                      <span>Mem</span>
+                    </li>
+                    {userRows.map((u) => (
+                      <li key={u.user}>
+                        <span className="remote-usage-user">{u.user}</span>
+                        <span className="remote-usage-user-cpu">
+                          <UsageLight pct={u.cpu} />
+                          {u.cpu.toFixed(0)}%
+                        </span>
+                        <span className="remote-usage-user-sessions">{u.count}</span>
+                        <span className="remote-usage-user-mem">{u.mem.toFixed(0)}%</span>
+                      </li>
+                    ))}
+                  </ul>
+                </div>
+              )}
+            </>
+          )}
+
+          {/* The Processes group: its own titled header, collapsible via the caret
+              so the vitals above can own the pane when the table isn't needed. */}
+          <div className="sysmon-proc-head">
+            <button
+              type="button"
+              className="sysmon-proc-toggle"
+              onClick={() => setProcOpen((v) => !v)}
+              aria-expanded={procOpen}
+              title={procOpen ? "Collapse process list" : "Expand process list"}
+            >
+              <span className="sysmon-proc-caret">{procOpen ? "▾" : "▸"}</span>
+              <span className="sysmon-group-title">Processes</span>
+            </button>
+            <span className="sysmon-count">
+              {rows.length} {rows.length === 1 ? "process" : "processes"}
+            </span>
+          </div>
+
+          {procOpen && (
+            <>
+          <div className="sysmon-toolbar">
+            <input
+              className="sysmon-filter"
+              placeholder="Filter by name, command, or PID…"
+              value={filter}
+              onChange={(e) => setFilter(e.target.value)}
+              spellCheck={false}
+            />
+          </div>
+
+          <div className="sysmon-table-wrap">
+            <table className="sysmon-table">
+              <thead>
+                <tr>
+                  <th className={`num ${sortedCls("pid") ?? ""}`} onClick={() => toggleSort("pid")}>
+                    PID{arrow("pid")}
+                  </th>
+                  <th className={`num ${sortedCls("cpu") ?? ""}`} onClick={() => toggleSort("cpu")}>
+                    CPU%{arrow("cpu")}
+                  </th>
+                  <th className={`num ${sortedCls("mem") ?? ""}`} onClick={() => toggleSort("mem")}>
+                    MEM%{arrow("mem")}
+                  </th>
+                  <th
+                    className={`num ${sortedCls("rss_kib") ?? ""}`}
+                    onClick={() => toggleSort("rss_kib")}
+                  >
+                    RSS{arrow("rss_kib")}
+                  </th>
+                  <th
+                    className={`num ${sortedCls("threads") ?? ""}`}
+                    onClick={() => toggleSort("threads")}
+                  >
+                    THR{arrow("threads")}
+                  </th>
+                  <th className="st">S</th>
+                  <th className={`cmd ${sortedCls("comm") ?? ""}`} onClick={() => toggleSort("comm")}>
+                    Command{arrow("comm")}
+                  </th>
+                </tr>
+              </thead>
+              <tbody>
+                {rows.map((r) => (
+                  <tr key={r.pid}>
+                    <td className={`num ${sortedCls("pid") ?? ""}`}>{r.pid}</td>
+                    <td
+                      className={`num ${sortedCls("cpu") ?? ""}`}
+                      style={{ color: toneFor(Math.min(100, r.cpu)) }}
+                    >
+                      {r.cpu.toFixed(1)}
+                    </td>
+                    <td
+                      className={`num ${sortedCls("mem") ?? ""}`}
+                      style={{ color: toneFor(r.mem) }}
+                    >
+                      {r.mem.toFixed(1)}
+                    </td>
+                    <td className={`num ${sortedCls("rss_kib") ?? ""}`}>{formatKib(r.rss_kib)}</td>
+                    <td className={`num ${sortedCls("threads") ?? ""}`}>{r.threads}</td>
+                    <td className="st">{r.state}</td>
+                    <td className={`cmd ${sortedCls("comm") ?? ""}`} title={r.cmdline}>
+                      {r.cmdline}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+            </>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
+
+const SYSMON_CSS = `
+.sysmon-root {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  font-size: 12px;
+  overflow: hidden;
+}
+.sysmon-placeholder {
+  margin: auto;
+  color: var(--text-muted);
+  padding: 24px;
+  text-align: center;
+}
+.sysmon-source {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 12px;
+  border-bottom: 1px solid var(--border-color);
+  flex: 0 0 auto;
+}
+/* The machine tabs wrap among themselves; the mode switch stays pinned to the
+   right edge of the row rather than wrapping into the middle of them. */
+.sysmon-source-tabs {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+  min-width: 0;
+}
+.sysmon-source-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius, 4px);
+  color: var(--text-secondary);
+  padding: 3px 12px;
+  font-size: 12px;
+  cursor: pointer;
+  max-width: 320px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.sysmon-source-btn:hover {
+  background: var(--control-hover-bg);
+}
+.sysmon-source-btn.active {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--accent-contrast, #fff);
+}
+/* The light/detailed switch, at the right end of the machine row.
+   Deliberately NOT the machine buttons' style: those are square, accent-filled
+   tabs answering "which machine am I looking at", and a second set of the same
+   thing beside them would read as three more machines. This is one recessed pill
+   track with the live half raised out of it — a switch, not a tab strip — and it
+   carries no accent fill at all, so the accent in this row always means "the
+   machine you are looking at". */
+/* The "untested" pill rides just outside the switch — inside the pill track it
+   would read as a third segment. The auto margin lives here so the tag and the
+   switch are pushed to the row's right edge together. */
+.sysmon-mode-tag {
+  margin-left: auto;
+  display: inline-flex;
+  align-items: center;
+}
+.sysmon-mode {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  padding: 2px;
+  border-radius: 999px;
+  background: var(--bg-subtle, rgba(127, 127, 127, 0.1));
+  border: 1px solid var(--control-border);
+}
+.sysmon-mode-btn {
+  display: inline-flex;
+  align-items: center;
+  background: transparent;
+  border: none;
+  border-radius: 999px;
+  color: var(--text-muted);
+  padding: 2px 8px;
+  font-size: 12px;
+  line-height: 1.4;
+  cursor: pointer;
+  white-space: nowrap;
+}
+.sysmon-mode-btn:hover {
+  color: var(--text-primary);
+}
+/* The selected half, marked three ways at once because the icons are small and
+   the labels are hidden until hover: it is raised out of the track, ringed in
+   the accent, and its icon is the only one in colour. */
+.sysmon-mode-btn.active {
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  box-shadow:
+    0 0 0 1px var(--accent),
+    0 1px 2px rgba(0, 0, 0, 0.25);
+}
+/* An unselected icon is greyed and dimmed, so at a glance exactly one of the two
+   is lit — the "which of these am I in?" question answered without reading. */
+.sysmon-mode-icon {
+  filter: grayscale(1);
+  opacity: 0.45;
+  transition:
+    filter 0.14s ease,
+    opacity 0.14s ease;
+}
+.sysmon-mode-btn:hover .sysmon-mode-icon {
+  opacity: 0.8;
+}
+.sysmon-mode-btn.active .sysmon-mode-icon {
+  filter: none;
+  opacity: 1;
+}
+/* The selected half keeps its label; the other reveals one on hover (or while it
+   holds focus, so the keyboard path can read what it is about to choose).
+   Width, not display: the row must not jump between two layouts as the pointer
+   crosses it — the hidden label grows in place. */
+.sysmon-mode-txt {
+  display: inline-block;
+  max-width: 0;
+  opacity: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  transition:
+    max-width 0.14s ease,
+    opacity 0.14s ease,
+    margin-left 0.14s ease;
+}
+.sysmon-mode-btn.active .sysmon-mode-txt,
+.sysmon-mode:hover .sysmon-mode-txt,
+.sysmon-mode:focus-within .sysmon-mode-txt {
+  max-width: 80px;
+  opacity: 1;
+  margin-left: 5px;
+}
+/* The single scroll region: the vitals and the process table scroll together under
+   ONE scrollbar. The table's sticky thead pins to this scroller. */
+.sysmon-scroll {
+  flex: 1;
+  min-height: 0;
+  overflow: auto;
+}
+/* The HPC-host notice, above the vitals: an explanation, not a warning — the
+   pane is working exactly as it should, it is simply collecting less. Toned like
+   the app's other informational strips (accent-tinted left edge, muted text). */
+.sysmon-careful-note {
+  margin: 10px 12px 0;
+  padding: 8px 10px;
+  border-left: 3px solid var(--accent);
+  border-radius: 4px;
+  background: var(--bg-subtle, rgba(127, 127, 127, 0.08));
+  color: var(--text-secondary, inherit);
+  font-size: 11px;
+  line-height: 1.5;
+}
+.sysmon-careful-note b {
+  color: var(--text-primary, inherit);
+}
+/* The vitals region: a left column (CPU over Memory) and a right column (GPU),
+   sitting above the process table. */
+.sysmon-vitals {
+  display: flex;
+  gap: 18px;
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--border-color);
+  flex-wrap: wrap;
+  align-items: flex-start;
+}
+.sysmon-vitals-left {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  flex: 1 1 340px;
+  min-width: 240px;
+}
+/* The GPU column, divided from the CPU/Memory column. The border reads as a
+   horizontal rule between them when the pane is narrow enough to wrap the GPU
+   below, and as a leading edge beside them when they sit side by side. */
+.sysmon-vitals-right {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  flex: 1 1 300px;
+  min-width: 260px;
+  border-top: 1px solid var(--border-color);
+  padding-top: 10px;
+}
+/* CPU, Memory, and GPU each read as a titled block so the domains are never
+   mistaken for one undifferentiated wall of meters. */
+.sysmon-group-title {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-secondary);
+}
+.sysmon-group-sub {
+  font-size: 10px;
+  font-weight: 400;
+  letter-spacing: 0;
+  text-transform: none;
+  color: var(--text-muted);
+}
+/* CPU + Memory stack vertically inside the left column, so neither carries a
+   horizontal flex basis — they take the column's full width. */
+.sysmon-cpu-group,
+.sysmon-mem-group {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.sysmon-cores {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
+  gap: 2px 12px;
+}
+.sysmon-meter {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-variant-numeric: tabular-nums;
+}
+.sysmon-meter-label {
+  color: var(--text-muted);
+  min-width: 28px;
+  text-align: right;
+}
+.sysmon-meter-bar {
+  flex: 1;
+  height: 8px;
+  background: var(--control-bg);
+  border: 1px solid var(--border-subtle);
+  border-radius: 3px;
+  overflow: hidden;
+}
+.sysmon-meter-fill {
+  display: block;
+  height: 100%;
+  transition: width 0.3s linear;
+}
+.sysmon-meter-caption {
+  color: var(--text-secondary);
+  min-width: 44px;
+  text-align: right;
+}
+.sysmon-stats {
+  display: flex;
+  gap: 14px;
+  flex-wrap: wrap;
+  margin-top: 2px;
+  color: var(--text-muted);
+}
+.sysmon-stats b {
+  color: var(--text-primary);
+  font-weight: 600;
+}
+/* One card per adapter, stacked full-width down the right column. */
+.sysmon-gpu {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  flex: 0 0 auto;
+  padding: 8px 10px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius, 4px);
+  background: color-mix(in srgb, var(--text-primary) 3%, transparent);
+}
+.sysmon-gpu-head {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+.sysmon-gpu-name {
+  font-weight: 600;
+  color: var(--text-primary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.sysmon-gpu-meta {
+  color: var(--text-muted);
+  font-size: 11px;
+}
+.sysmon-gpu-meters {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.sysmon-gpu-sensors {
+  margin-top: 0;
+  gap: 12px;
+}
+.sysmon-sensor-na {
+  color: var(--text-muted);
+  font-weight: 400;
+}
+.sysmon-gpu-procs {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  flex: 0 0 auto;
+  padding: 8px 10px;
+}
+.sysmon-gpu-procs-head {
+  color: var(--text-secondary);
+  font-weight: 600;
+  margin-bottom: 3px;
+}
+.sysmon-gpu-proc {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  font-variant-numeric: tabular-nums;
+}
+.sysmon-gpu-proc-mem {
+  min-width: 62px;
+  text-align: right;
+  color: var(--text-primary);
+  font-weight: 600;
+}
+.sysmon-gpu-proc-pid {
+  min-width: 52px;
+  text-align: right;
+  color: var(--text-muted);
+}
+.sysmon-gpu-proc-name {
+  color: var(--text-secondary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+/* The Processes group header: caret toggle + title on the left, count on the right. */
+.sysmon-proc-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  padding: 8px 12px;
+}
+.sysmon-proc-toggle {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  background: none;
+  border: none;
+  padding: 0;
+  cursor: pointer;
+  color: inherit;
+}
+.sysmon-proc-caret {
+  color: var(--text-muted);
+  font-size: 10px;
+  width: 12px;
+  text-align: center;
+}
+.sysmon-proc-toggle:hover .sysmon-group-title,
+.sysmon-proc-toggle:hover .sysmon-proc-caret {
+  color: var(--text-primary);
+}
+.sysmon-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 0 12px 6px;
+  flex: 0 0 auto;
+}
+.sysmon-filter {
+  flex: 1;
+  max-width: 340px;
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius, 4px);
+  color: var(--text-primary);
+  padding: 4px 8px;
+  font-size: 12px;
+  outline: none;
+}
+.sysmon-filter:focus {
+  border-color: var(--accent);
+}
+.sysmon-count {
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+.sysmon-table-wrap {
+  /* Natural height — the whole body scrolls in the shared .sysmon-scroll region,
+     and the table's sticky thead pins to that scroller. */
+}
+.sysmon-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-variant-numeric: tabular-nums;
+}
+.sysmon-table thead th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  /* The SOLID header tone, not --bg-header: that is a gradient in the fancy
+     themes, so each th would repaint the whole ramp and the .sorted color-mix
+     below would be invalid — i.e. a transparent sticky header. */
+  background: var(--bg-header-solid, var(--bg-panel));
+  color: var(--text-secondary);
+  text-align: left;
+  font-weight: 600;
+  padding: 5px 10px;
+  cursor: pointer;
+  white-space: nowrap;
+  border-bottom: 1px solid var(--border-color);
+  user-select: none;
+}
+/* The active sort column reads as a distinct vertical band, not just a tinted
+   header: a strong accent header and an accent-tinted column body, both bracketed
+   by 2px accent edge-lines drawn with an inset box-shadow (so the band gains no
+   width and the columns stay aligned). */
+.sysmon-table th.sorted {
+  background: color-mix(in srgb, var(--accent) 30%, var(--bg-header-solid));
+  color: var(--text-primary);
+  font-weight: 700;
+  box-shadow: inset 2px 0 0 var(--accent), inset -2px 0 0 var(--accent);
+}
+.sysmon-table td.sorted {
+  background: color-mix(in srgb, var(--accent) 9%, var(--bg-panel));
+  box-shadow: inset 2px 0 0 var(--accent), inset -2px 0 0 var(--accent);
+}
+.sysmon-table th.num,
+.sysmon-table td.num {
+  text-align: right;
+}
+.sysmon-table th.st,
+.sysmon-table td.st {
+  text-align: center;
+  color: var(--text-muted);
+}
+.sysmon-table td {
+  padding: 3px 10px;
+  white-space: nowrap;
+}
+.sysmon-table td.cmd {
+  max-width: 640px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  color: var(--text-secondary);
+}
+.sysmon-table tbody tr:nth-child(even) {
+  background: color-mix(in srgb, var(--text-primary) 4%, transparent);
+}
+.sysmon-table tbody tr:hover {
+  background: var(--control-hover-bg);
+}
+/* The per-user breakdown borrows the remote-usage dialog's .remote-usage-users
+   grid wholesale (defined in themes.css), so this only positions that panel —
+   an indented block below the vitals, not the full-width process scroller. */
+.sysmon-users {
+  padding: 0 12px 8px;
+}
+.sysmon-users-empty {
+  color: var(--text-muted);
+  font-style: italic;
+}
+`;
diff --git a/src/components/projects/ActivityCalendar.tsx b/src/components/projects/ActivityCalendar.tsx
index fcaac68..332b6d1 100644
--- a/src/components/projects/ActivityCalendar.tsx
+++ b/src/components/projects/ActivityCalendar.tsx
@@ -1,12 +1,13 @@
 import { useMemo, useState } from "react";
 import { createPortal } from "react-dom";
+import { useT, useI18nStore, type TranslationKey } from "../../lib/i18n";
 
 interface Props {
   data: Record<string, number>; // "YYYY-MM-DD" -> seconds (full history, all years)
 }
 
-function formatTime(secs: number): string {
-  if (secs <= 0) return "No activity";
+function formatTime(secs: number, t: (key: TranslationKey) => string): string {
+  if (secs <= 0) return t("activityCal.noActivity");
   if (secs < 60) return `${Math.round(secs)}s`;
   const h = Math.floor(secs / 3600);
   const m = Math.floor((secs % 3600) / 60);
@@ -40,7 +41,15 @@ const GAP = 2;
 const STEP = CELL + GAP;
 const LABEL_H = 16;
 const DAY_LABEL_W = 28;
-const DAY_LABELS = ["", "Mon", "", "Wed", "", "Fri", ""];
+const DAY_LABEL_KEYS: (TranslationKey | null)[] = [
+  null,
+  "activityCal.dayMon",
+  null,
+  "activityCal.dayWed",
+  null,
+  "activityCal.dayFri",
+  null,
+];
 
 function buildWeeks(year: number, data: Record<string, number>): Cell[][] {
   const today = new Date();
@@ -74,6 +83,8 @@ function buildWeeks(year: number, data: Record<string, number>): Cell[][] {
 }
 
 export function ActivityCalendar({ data }: Props) {
+  const t = useT();
+  const lang = useI18nStore((s) => s.lang);
   const currentYear = new Date().getFullYear();
 
   const availableYears = useMemo(() => {
@@ -104,13 +115,13 @@ export function ActivityCalendar({ data }: Props) {
       const first = week.find((c) => !c.future && c.date);
       if (!first) return;
       const d = new Date(first.date);
-      const label = d.toLocaleString("en", { month: "short" });
+      const label = d.toLocaleString(lang, { month: "short" });
       if (!labels.length || labels[labels.length - 1].label !== label) {
         labels.push({ label, col: ci });
       }
     });
     return labels;
-  }, [weeks]);
+  }, [weeks, lang]);
 
   return (
     <div className="activity-calendar">
@@ -132,7 +143,7 @@ export function ActivityCalendar({ data }: Props) {
       <div style={{ display: "flex" }}>
         {/* Day-of-week labels */}
         <div style={{ width: DAY_LABEL_W, paddingTop: LABEL_H, flexShrink: 0 }}>
-          {DAY_LABELS.map((label, i) => (
+          {DAY_LABEL_KEYS.map((key, i) => (
             <div
               key={i}
               style={{
@@ -146,7 +157,7 @@ export function ActivityCalendar({ data }: Props) {
                 userSelect: "none",
               }}
             >
-              {label}
+              {key ? t(key) : ""}
             </div>
           ))}
         </div>
@@ -213,13 +224,13 @@ export function ActivityCalendar({ data }: Props) {
 
       {/* Legend */}
       <div className="activity-legend">
-        <span>Less</span>
+        <span>{t("activityCal.less")}</span>
         {([0, 1, 2, 3, 4] as const).map((l) => (
           <svg key={l} width={CELL} height={CELL} style={{ flexShrink: 0 }}>
             <rect width={CELL} height={CELL} rx={2} className={`activity-cell activity-cell-${l}`} />
           </svg>
         ))}
-        <span>More</span>
+        <span>{t("activityCal.more")}</span>
       </div>
 
       {tooltip &&
@@ -235,7 +246,7 @@ export function ActivityCalendar({ data }: Props) {
               zIndex: 10000,
             }}
           >
-            <strong>{tooltip.date}</strong>: {formatTime(tooltip.secs)}
+            <strong>{tooltip.date}</strong>: {formatTime(tooltip.secs, t)}
           </div>,
           document.body,
         )}
diff --git a/src/components/projects/BigFolderExcludeDialog.tsx b/src/components/projects/BigFolderExcludeDialog.tsx
new file mode 100644
index 0000000..6f6ea37
--- /dev/null
+++ b/src/components/projects/BigFolderExcludeDialog.tsx
@@ -0,0 +1,263 @@
+import { useCallback, useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+
+import { useBigFoldersStore } from "../../stores/bigFolders";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useSettingsStore } from "../../stores/settings";
+import { useSyncStore, type BigFolderRow } from "../../stores/sync";
+import { isCarefulHost, primaryTargetOf } from "../../lib/carefulHost";
+import { isHpcHost } from "../../lib/hpcHost";
+import { confirmOnHpcHost } from "../../lib/hpcGuard";
+import { fmtSize } from "../../lib/viewers/fileUtils";
+import { UntestedTag } from "../common/UntestedTag";
+import { useT } from "../../lib/i18n";
+
+/**
+ * "These folders are giant — sync them?", asked once, at setup.
+ *
+ * Byte-sync's scope is an opt-in manifest that does **not** read `.gitignore`,
+ * so nothing else in Eldrun would ever mention that a `node_modules/`, `data/`
+ * or `checkpoints/` is about to cross. The file tree already prices ONE folder
+ * on the click that would sync it (`sync_auto_preview`); this asks the same
+ * question for the whole project at the only moment the answer is cheap — before
+ * the first pass has moved anything.
+ *
+ * It reports **both sides**, because at setup they mean different things: bytes
+ * on the host are usually the experiment output that should stay there, bytes in
+ * the local folder are usually the build/venv that should never have gone up.
+ * A folder that exists on one side only shows a dash for the other, which is the
+ * distinction stated rather than inferred.
+ *
+ * The default answer is **exclude** — every box starts ticked. The prompt only
+ * ever lists folders past the giant threshold, and the cost of wrongly excluding
+ * one is a click in the file tree, while the cost of wrongly syncing one is the
+ * multi-GB transfer this dialog exists to prevent.
+ */
+export function BigFolderExcludeDialog({ projectId }: { projectId: string }) {
+  const t = useT();
+  const close = useBigFoldersStore((s) => s.close);
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === projectId));
+  const bigFolders = useSyncStore((s) => s.bigFolders);
+  const setExcluded = useSyncStore((s) => s.setExcluded);
+  // The host half of the census needs a live pool; re-run when one appears so a
+  // project that was still connecting when this opened fills in its host column.
+  const ssh = useRemoteStatusStore((s) => s.byProject[projectId]?.ssh ?? "off");
+  const sshConnected = ssh === "connected";
+
+  // A **careful** host does not get the host half by itself: it is a recursive
+  // `du -ak -x`, and on a cluster the project root usually sits on the parallel
+  // filesystem, where stat-ing a whole tree is a metadata storm against a shared
+  // server. The local walk still runs — it is this machine's own disk — so the
+  // prompt is still useful, just half-filled until the user asks for the rest.
+  //
+  // **Tagged is stronger than careful, and the gate has to name both.** The
+  // backend refuses the host half for a tagged host unconditionally
+  // (`commands::sync`), so a frontend that only knew about `careful_hosts` offered
+  // a Measure-host button on the one machine where pressing it could never do
+  // anything — the census came back `hostScanned: false` and the row simply stayed
+  // a dash, which reads as a bug rather than as a policy.
+  const settings = useSettingsStore((s) => s.settings);
+  const target = primaryTargetOf(project);
+  const hpcTagged = isHpcHost(settings, target);
+  const careful = hpcTagged || isCarefulHost(settings, target);
+  const targetLabel = target ? `${target.user ? `${target.user}@` : ""}${target.host}` : "";
+
+  const [rows, setRows] = useState<BigFolderRow[] | null>(null);
+  const [hostScanned, setHostScanned] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [checked, setChecked] = useState<Set<string>>(new Set());
+  const [busy, setBusy] = useState(false);
+  const [scanningHost, setScanningHost] = useState(false);
+  // Whether the user has explicitly asked for the host half at least once. Only
+  // used to tell "not measured yet" apart from "asked for, and still not
+  // measured" — see the tagged-host note below.
+  const [hostAsked, setHostAsked] = useState(false);
+
+  const scan = useCallback(
+    async (scanHost: boolean) => {
+      try {
+        const result = await bigFolders(projectId, scanHost);
+        setRows(result.folders);
+        setHostScanned(result.hostScanned);
+        setError(result.hostError);
+        // Ticked by default (see the component doc); a standing exclusion stays
+        // ticked, so re-opening the prompt shows the answer already on file.
+        setChecked(new Set(result.folders.map((f) => f.rel)));
+      } catch (e) {
+        setRows([]);
+        setError(String(e));
+      }
+    },
+    [bigFolders, projectId],
+  );
+
+  // The automatic pass — on open, and again when a pool appears so a project that
+  // was still connecting fills in its host column. On a careful host this stays
+  // local-only however often it re-runs; only the explicit button below crosses.
+  useEffect(() => {
+    void scan(!careful);
+    // A named boolean, not the expression: a dep array holding `ssh === "connected"`
+    // says nothing about what changed when it fires.
+  }, [scan, careful, sshConnected]);
+
+  const measureHost = async () => {
+    // On a tagged host the walk is asked about first, per act and never
+    // remembered (`lib/hpcGuard.ts`) — this is one of the two things the tag
+    // refuses rather than switches off, because people do legitimately want it.
+    // Backing out here leaves the host column exactly as it was.
+    if (hpcTagged && !(await confirmOnHpcHost("census", targetLabel))) return;
+    setHostAsked(true);
+    setScanningHost(true);
+    try {
+      await scan(true);
+    } finally {
+      setScanningHost(false);
+    }
+  };
+
+  const apply = async () => {
+    if (!rows) return;
+    setBusy(true);
+    try {
+      const exclude = rows.filter((r) => checked.has(r.rel)).map((r) => r.rel);
+      const include = rows.filter((r) => !checked.has(r.rel)).map((r) => r.rel);
+      if (exclude.length) await setExcluded(projectId, exclude, true);
+      // Un-ticking a row that already carried an exclusion must LIFT it, or the
+      // dialog would be a one-way door.
+      if (include.length) await setExcluded(projectId, include, false);
+      close();
+    } catch (e) {
+      setError(String(e));
+      setBusy(false);
+    }
+  };
+
+  const toggle = (rel: string) =>
+    setChecked((prev) => {
+      const next = new Set(prev);
+      if (next.has(rel)) next.delete(rel);
+      else next.add(rel);
+      return next;
+    });
+
+  const side = (files: number, bytes: number) =>
+    files === 0 && bytes === 0 ? (
+      <span className="big-folder-absent">—</span>
+    ) : (
+      <>
+        {fmtSize(bytes)} <span className="big-folder-files">({files.toLocaleString()} files)</span>
+      </>
+    );
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={close}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <h2>
+          {t("bigFolder.titlePre")} {project?.name ?? t("bigFolder.thisProject")} <UntestedTag />
+        </h2>
+        <p className="big-folder-intro">
+          {t("bigFolder.introPre")} <strong>{t("bigFolder.doesNotReadGitignore")}</strong>{t("bigFolder.introPost")}
+        </p>
+
+        {rows === null && <p className="big-folder-intro">{t("bigFolder.measuring")}</p>}
+
+        {rows !== null && rows.length === 0 && (
+          <p className="big-folder-intro">
+            {hostScanned ? t("bigFolder.nothingOversizedFull") : t("bigFolder.nothingOversizedLocalOnly")}
+          </p>
+        )}
+
+        {rows !== null && rows.length > 0 && (
+          <>
+            <div className="big-folder-head">
+              <span />
+              <span>{t("bigFolder.colFolder")}</span>
+              <span>{t("bigFolder.colThisMachine")}</span>
+              <span>{t("bigFolder.colHost")}</span>
+            </div>
+            <div className="big-folder-list">
+              {rows.map((r) => (
+                <label key={r.rel} className="big-folder-row">
+                  <input
+                    type="checkbox"
+                    checked={checked.has(r.rel)}
+                    onChange={() => toggle(r.rel)}
+                  />
+                  <span className="big-folder-path" title={r.rel}>
+                    {r.rel}
+                  </span>
+                  <span>{side(r.localFiles, r.localBytes)}</span>
+                  <span>{side(r.hostFiles, r.hostBytes)}</span>
+                </label>
+              ))}
+            </div>
+            <p className="big-folder-note">
+              {t("bigFolder.notePre")} <strong>{t("bigFolder.excludedFromSync")}</strong>{t("bigFolder.notePost")}
+            </p>
+          </>
+        )}
+
+        {/* Two different reasons the host column is empty, said apart. "Not
+            connected" is a state that will fix itself; "marked careful" is a
+            decision, and the only thing that lifts it is the button beside it. */}
+        {!hostScanned && rows !== null && careful && (
+          <p className="big-folder-note">
+            {t("bigFolder.hostSkippedCareful")}
+            {error ? ` (${error})` : ""}{" "}
+            <button
+              type="button"
+              className="link-button"
+              onClick={() => void measureHost()}
+              disabled={scanningHost || !sshConnected}
+            >
+              {scanningHost ? t("bigFolder.measuringHost") : t("bigFolder.measureHost")}
+            </button>
+          </p>
+        )}
+
+        {/* Said only after the walk was actually asked for and still didn't
+            happen. `commands::sync` refuses a tagged machine's `du` with no way
+            for the caller to confirm *this* one yet, so the honest thing is to
+            state that the answer was no — a silently unchanged dash is the exact
+            failure this dialog's host column already had. */}
+        {hpcTagged && hostAsked && !hostScanned && !scanningHost && (
+          <p className="big-folder-note">
+            The host measurement was refused: {targetLabel || "this machine"} is tagged
+            HPC, and a recursive <code>du</code> over a cluster filesystem is not run
+            there. Untag it in the Machines menu if it is not a shared login node.
+          </p>
+        )}
+
+        {!hostScanned && rows !== null && !careful && (
+          <p className="big-folder-note">
+            {t("bigFolder.hostNotMeasuredPre")}{error ? ` (${error})` : ` — ${t("bigFolder.hostNotConnected")}`}
+            {t("bigFolder.hostNotMeasuredPost")}
+          </p>
+        )}
+
+        <div className="project-dialog-actions">
+          <button type="button" onClick={close} disabled={busy}>
+            {t("bigFolder.notNow")}
+          </button>
+          <button
+            type="button"
+            className="primary"
+            onClick={() => void apply()}
+            disabled={busy || rows === null}
+          >
+            {rows && rows.length === 0 ? t("bigFolder.close") : t("bigFolder.apply")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** Mounted once (AppShell); renders the prompt for whichever project asked. */
+export function BigFolderDialogHost() {
+  const projectId = useBigFoldersStore((s) => s.projectId);
+  if (!projectId) return null;
+  return <BigFolderExcludeDialog projectId={projectId} />;
+}
diff --git a/src/components/projects/BoxPill.tsx b/src/components/projects/BoxPill.tsx
index a9ab027..a776390 100644
--- a/src/components/projects/BoxPill.tsx
+++ b/src/components/projects/BoxPill.tsx
@@ -3,7 +3,7 @@ import { createPortal } from "react-dom";
 import type { ProjectBox, ProjectEntry } from "../../types";
 import { useTabsStore } from "../../stores/tabs";
 import { boxScopeId } from "../../stores/boxes";
-import { PILL_DRAG_TYPE } from "./ProjectPill";
+import { useT } from "../../lib/i18n";
 
 interface ContextMenuPos {
   x: number;
@@ -16,14 +16,17 @@ interface Props {
   members: ProjectEntry[];
   /** Click the pill → open the box scope (like opening a project). */
   onOpen: () => void;
-  /** A project pill was dropped on the box → assign it to this box. */
-  onAssign: (projectId: string) => void;
   /** Click a member in the dropdown → switch to that project. */
   onSelectMember: (projectId: string) => void;
   /** Remove a member from the box (ungroup it). */
   onRemoveMember: (projectId: string) => void;
   onRename: (name: string) => void;
   onDelete: () => void;
+  /** A project pill's pointer-drag (see ProjectPill/stores/pillDrag) is
+   *  currently hovering this box — the same highlight the old native
+   *  `dragOver` gave, just driven by the shared drag state instead of a
+   *  native `dragover` event. */
+  forcedDragOver?: boolean;
 }
 
 /**
@@ -32,20 +35,21 @@ interface Props {
  * `ProjectPill` but differs in its hover affordance — instead of an info popup it
  * opens a dropdown LISTING the member projects (click one to switch to it).
  * Clicking the pill opens the box scope; dropping a project pill on it assigns
- * that project to the box (same `PILL_DRAG_TYPE` as pill reorder). Right-click
- * exposes Open / Rename / Delete.
+ * that project to the box (pointer-driven, see ProjectPill's `startPillDrag`,
+ * hit-tested against this pill's `data-box-id`). Right-click exposes Open /
+ * Rename / Delete.
  */
 export function BoxPill({
   box,
   members,
   onOpen,
-  onAssign,
   onSelectMember,
   onRemoveMember,
   onRename,
   onDelete,
+  forcedDragOver,
 }: Props) {
-  const [dragOver, setDragOver] = useState(false);
+  const t = useT();
   const [menuOpen, setMenuOpen] = useState(false);
   const [contextMenu, setContextMenu] = useState<ContextMenuPos | null>(null);
   const [renaming, setRenaming] = useState(false);
@@ -126,28 +130,11 @@ export function BoxPill({
     <>
       <div
         ref={pillRef}
-        className={`project-pill is-box${active ? " active" : ""}${dragOver ? " drag-over" : ""}`}
+        data-box-id={box.id}
+        className={`project-pill is-box${active ? " active" : ""}${forcedDragOver ? " drag-over" : ""}`}
         onMouseEnter={openMenu}
         onMouseLeave={scheduleClose}
         onContextMenu={handleContextMenu}
-        onDragOver={(e) => {
-          if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-          // Claim the drop so the underlying pills-row handler (ungroup) never
-          // fires for a drop on the box pill.
-          e.preventDefault();
-          e.stopPropagation();
-          e.dataTransfer.dropEffect = "move";
-          if (!dragOver) setDragOver(true);
-        }}
-        onDragLeave={() => setDragOver(false)}
-        onDrop={(e) => {
-          if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-          e.preventDefault();
-          e.stopPropagation();
-          setDragOver(false);
-          const fromId = e.dataTransfer.getData(PILL_DRAG_TYPE);
-          if (fromId) onAssign(fromId);
-        }}
       >
         {renaming ? (
           <input
@@ -165,12 +152,15 @@ export function BoxPill({
             }}
           />
         ) : (
-          <button className="pill-main" onClick={onOpen} title={`${box.name} (box) — click to open`}>
+          <button className="pill-main" onClick={onOpen} title={t("boxPill.clickToOpenTitle", { name: box.name })}>
             <span className="pill-folder-icon" aria-hidden>
               ▣
             </span>
             <span className="project-pill-label">{box.name}</span>
-            <span className="project-box-member-count" title={`${members.length} member(s)`}>
+            <span
+              className="project-box-member-count"
+              title={t(members.length === 1 ? "boxPill.memberCountOne" : "boxPill.memberCountMany", { count: members.length })}
+            >
               {members.length}
             </span>
           </button>
@@ -188,22 +178,9 @@ export function BoxPill({
             onMouseEnter={openMenu}
             onMouseLeave={scheduleClose}
             onContextMenu={(e) => e.stopPropagation()}
-            onDragOver={(e) => {
-              if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-              e.preventDefault();
-              e.stopPropagation();
-              e.dataTransfer.dropEffect = "move";
-            }}
-            onDrop={(e) => {
-              if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-              e.preventDefault();
-              e.stopPropagation();
-              const fromId = e.dataTransfer.getData(PILL_DRAG_TYPE);
-              if (fromId) onAssign(fromId);
-            }}
           >
             {members.length === 0 ? (
-              <div className="project-box-dropdown-hint">No members</div>
+              <div className="project-box-dropdown-hint">{t("boxPill.noMembers")}</div>
             ) : (
               members.map((m) => (
                 <div className="project-box-member-row" key={m.id}>
@@ -214,7 +191,7 @@ export function BoxPill({
                       setMenuOpen(false);
                       onSelectMember(m.id);
                     }}
-                    title={`Switch to ${m.name}`}
+                    title={t("boxPill.switchToTitle", { name: m.name })}
                   >
                     <span className="pill-folder-icon" aria-hidden>
                       📁
@@ -225,7 +202,7 @@ export function BoxPill({
                     type="button"
                     className="project-box-member-remove"
                     onClick={() => onRemoveMember(m.id)}
-                    title="Remove from box"
+                    title={t("boxPill.removeFromBox")}
                   >
                     ×
                   </button>
@@ -249,7 +226,7 @@ export function BoxPill({
                 onOpen();
               }}
             >
-              Open box
+              {t("boxPill.openBox")}
             </button>
             <button
               onClick={() => {
@@ -258,7 +235,7 @@ export function BoxPill({
                 setRenaming(true);
               }}
             >
-              Rename
+              {t("common.rename")}
             </button>
             <button
               className="danger"
@@ -267,7 +244,7 @@ export function BoxPill({
                 onDelete();
               }}
             >
-              Delete box
+              {t("boxPill.deleteBox")}
             </button>
           </div>,
           document.body,
diff --git a/src/components/projects/CarefulHostToggle.tsx b/src/components/projects/CarefulHostToggle.tsx
new file mode 100644
index 0000000..a8a7614
--- /dev/null
+++ b/src/components/projects/CarefulHostToggle.tsx
@@ -0,0 +1,83 @@
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
+import {
+  carefulIsExplicit,
+  isCarefulHost,
+  setCarefulPatch,
+  type Target,
+} from "../../lib/carefulHost";
+import { isHpcHost } from "../../lib/hpcHost";
+import { useSettingsStore } from "../../stores/settings";
+import { useT } from "../../lib/i18n";
+
+/**
+ * "Go easy on this machine" — the per-host **careful** switch.
+ *
+ * It exists because Eldrun's background work is priced for a machine you own. On
+ * a host you merely have an account on — an HPC login node above all — three of
+ * those habits are things the site actively watches: CPU on the login node, a
+ * recursive `du` over a tree that usually lives on a *parallel* filesystem (a
+ * metadata storm against a shared server), and repeated account lookups against a
+ * shared directory service. None of them are expensive for Eldrun; all of them
+ * are rude at a cadence, and one of them is the kind of thing a usage policy
+ * names by hand.
+ *
+ * The switch is **per host, keyed by SSH target**, not per project — see
+ * `lib/carefulHost.ts` for why that is the only identity that works when one
+ * login node is a primary `remote`, a worker and a global machine at once. This
+ * component is deliberately the single rendering of it, so the remote hub, the
+ * header's Machines menu and the system monitor can never grow three switches
+ * that disagree.
+ *
+ * **It is on by default and there is no detection behind it.** Every remote host
+ * starts careful, because Eldrun cannot tell whose machine it is and guessing
+ * only ever guesses wrong expensively. Flipping it off is a statement about *this*
+ * machine — "this one is mine" — recorded per SSH target and kept from then on,
+ * which is why it has to be stored rather than re-derived.
+ */
+export function CarefulHostToggle({
+  target,
+  disabled,
+}: {
+  /** The host this governs. Null (a local project) renders nothing. */
+  target: Target | null | undefined;
+  disabled?: boolean;
+}) {
+  const t = useT();
+  const settings = useSettingsStore((s) => s.settings);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+
+  if (!target?.host) return null;
+
+  // A machine tagged HPC is read carefully whatever this says, so the switch
+  // shows that rather than offering a choice it doesn't have. Same precedence the
+  // backend applies (`services::hpc_mode::is_careful_host`) and the monitor pane's
+  // Light/Detailed pair shows — three surfaces, one rule.
+  const tagged = isHpcHost(settings, target);
+  const careful = tagged || isCarefulHost(settings, target);
+  const explicit = carefulIsExplicit(settings, target);
+
+  return (
+    <label
+      className="remote-connect-remember careful-host-toggle"
+      title={t("carefulHost.title")}
+    >
+      <Toggle
+        size="sm"
+        checked={careful}
+        disabled={disabled || tagged}
+        onChange={(e) => void updateSettings(setCarefulPatch(settings, target, e.target.checked))}
+      />
+      {t("carefulHost.label")} <UntestedTag />
+      <span className="ssh-optional-hint">
+        {tagged
+          ? t("carefulHost.hintHpcTagged")
+          : !explicit
+          ? t("carefulHost.hintOnByDefault")
+          : careful
+            ? t("carefulHost.hintDefault")
+            : t("carefulHost.hintNotCareful")}
+      </span>
+    </label>
+  );
+}
diff --git a/src/components/projects/CategoryEditor.tsx b/src/components/projects/CategoryEditor.tsx
new file mode 100644
index 0000000..f41f6d9
--- /dev/null
+++ b/src/components/projects/CategoryEditor.tsx
@@ -0,0 +1,142 @@
+import { useMemo, useState } from "react";
+import { createPortal } from "react-dom";
+import type { ProjectEntry } from "../../types";
+import { useProjectsStore } from "../../stores/projects";
+import {
+  categoryColor,
+  cleanCategories,
+  normalizeCategory,
+  projectCategories,
+} from "../../lib/categoryColor";
+import { useT } from "../../lib/i18n";
+
+/**
+ * Modal to manage a project's category tags. Categories color/group a project in
+ * both the 3D project cloud and the pill bar (see `categoryColor`). Existing
+ * categories across all projects are offered as toggle chips so tagging is a
+ * click, and a free-text field adds new ones. Reused by the pill and the
+ * blob-node right-click menus.
+ */
+export function CategoryEditor({
+  project,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const projects = useProjectsStore((s) => s.projects);
+  const setProjectCategories = useProjectsStore((s) => s.setProjectCategories);
+
+  const [selected, setSelected] = useState<string[]>(() => projectCategories(project));
+  const [input, setInput] = useState("");
+  const [saving, setSaving] = useState(false);
+
+  // Every category in use across all projects, plus any the user just added,
+  // so previously-used tags are one click to reapply.
+  const known = useMemo(() => {
+    const all = projects.flatMap((p) => projectCategories(p));
+    return cleanCategories([...all, ...selected]);
+  }, [projects, selected]);
+
+  const selectedKeys = useMemo(
+    () => new Set(selected.map((c) => c.toLowerCase())),
+    [selected],
+  );
+
+  const toggle = (cat: string) => {
+    const key = cat.toLowerCase();
+    setSelected((prev) =>
+      prev.some((c) => c.toLowerCase() === key)
+        ? prev.filter((c) => c.toLowerCase() !== key)
+        : [...prev, cat],
+    );
+  };
+
+  const addNew = () => {
+    const c = normalizeCategory(input);
+    if (!c) return;
+    if (!selected.some((s) => s.toLowerCase() === c.toLowerCase())) {
+      setSelected((prev) => [...prev, c]);
+    }
+    setInput("");
+  };
+
+  const save = async () => {
+    setSaving(true);
+    try {
+      await setProjectCategories(project.id, cleanCategories(selected));
+      onClose();
+    } catch {
+      setSaving(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="project-dialog dialog-framed category-editor"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{project.name} — {t("categoryEditor.titleSuffix")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+        <div className="project-dialog-path">{t("categoryEditor.desc")}</div>
+
+        {known.length > 0 && (
+          <div className="category-chip-row">
+            {known.map((cat) => {
+              const on = selectedKeys.has(cat.toLowerCase());
+              return (
+                <button
+                  type="button"
+                  key={cat.toLowerCase()}
+                  className={`category-chip${on ? " on" : ""}`}
+                  style={{ "--cat-color": categoryColor(cat) } as React.CSSProperties}
+                  onClick={() => toggle(cat)}
+                  title={t(on ? "categoryEditor.removeCategory" : "categoryEditor.addCategory")}
+                >
+                  <span className="category-chip-dot" />
+                  {cat}
+                  {on && <span className="category-chip-x" aria-hidden>×</span>}
+                </button>
+              );
+            })}
+          </div>
+        )}
+
+        <label>
+          {t("categoryEditor.addLabel")}
+          <div className="category-add-row">
+            <input
+              type="text"
+              value={input}
+              autoFocus
+              placeholder={t("categoryEditor.placeholder")}
+              onChange={(e) => setInput(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") {
+                  e.preventDefault();
+                  addNew();
+                }
+                if (e.key === "Escape") onClose();
+              }}
+            />
+            <button type="button" onClick={addNew} disabled={!input.trim()}>{t("common.add")}</button>
+          </div>
+        </label>
+
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={saving}>{t("common.cancel")}</button>
+          <button type="button" onClick={() => void save()} disabled={saving}>
+            {saving ? t("categoryEditor.saving") : t("categoryEditor.save")}
+          </button>
+        </div>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/projects/CredentialPasteBar.tsx b/src/components/projects/CredentialPasteBar.tsx
new file mode 100644
index 0000000..de62dae
--- /dev/null
+++ b/src/components/projects/CredentialPasteBar.tsx
@@ -0,0 +1,218 @@
+import { useEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { UntestedTag } from "../common/UntestedTag";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+/**
+ * "Paste it for me" for a **login terminal** — the row of buttons above the embedded
+ * terminal that types a *known* login name, and a *saved* password, at the cursor.
+ *
+ * It exists because the non-headless login and a saved credential are not the
+ * contradiction they look like. Non-headless means Eldrun does not *handle* the
+ * password — the host asks its own questions in a terminal the user is watching, and
+ * the answers go straight to it. It has never meant the keychain is empty: a user who
+ * saved an SSH password from a headless connect, or a VPN password from the header
+ * menu, and then works in this mode (or flips "Sign in in a terminal" for one host
+ * that wants a challenge code) has the credential sitting there, unreachable, and
+ * retypes it into every login.
+ *
+ * The secret does **not** travel through the frontend to get there. A password button
+ * calls `credential_paste_to_pty`, which reads the keychain and writes the bytes into
+ * the PTY inside the backend — no field, no component state, no event payload. Only
+ * the non-secrets (an SSH login name, a VPN auth username the dialog already shows in
+ * a plain text input) are pasted from here, via the ordinary `pty_write` any keystroke
+ * uses.
+ *
+ * Nothing is submitted: the credential lands at the cursor and the user presses Enter.
+ * A paste is not a login, and a wrong one should be correctable on the line rather than
+ * committed on the user's behalf — the same reason the login command itself is typed
+ * into a visible terminal instead of run behind it.
+ */
+
+/** A saved credential, named by *what it is* — the keychain account spelling stays
+ *  the backend's (see `commands::credentials::PasteCredential`). */
+export type PasteCredentialRef =
+  | { kind: "ssh-password"; user?: string | null; host: string; port?: number | null }
+  | { kind: "vpn-password"; config: string }
+  | { kind: "vpn-key-passphrase"; config: string }
+  | { kind: "vpn-username"; config: string };
+
+export type PasteEntry = {
+  /** Button label, e.g. `"Paste password"`. */
+  label: string;
+  title: string;
+  /** A plain, non-secret value the caller already has on screen. */
+  text?: string;
+  /** A secret only the backend may read. Ignored when `text` is given. */
+  credential?: PasteCredentialRef;
+};
+
+const ENCODER = new TextEncoder();
+
+export function CredentialPasteBar({
+  ptyId,
+  entries,
+}: {
+  ptyId: string;
+  /** Entries with neither a non-empty `text` nor a `credential` are dropped, so a
+   *  caller can list every field it *might* have and let this decide. */
+  entries: PasteEntry[];
+}) {
+  const t = useT();
+  const [note, setNote] = useState("");
+  const noteTimer = useRef<number | null>(null);
+  useEffect(
+    () => () => {
+      if (noteTimer.current !== null) window.clearTimeout(noteTimer.current);
+    },
+    [],
+  );
+  const flash = (msg: string) => {
+    setNote(msg);
+    if (noteTimer.current !== null) window.clearTimeout(noteTimer.current);
+    noteTimer.current = window.setTimeout(() => setNote(""), 4000);
+  };
+
+  const usable = entries.filter((e) => (e.text ?? "").trim() !== "" || e.credential);
+  if (!ptyId || usable.length === 0) return null;
+
+  const paste = async (entry: PasteEntry) => {
+    try {
+      if (entry.text) {
+        await invoke("pty_write", { id: ptyId, data: ENCODER.encode(entry.text) });
+        flash(t("credentialPasteBar.pastedFlash"));
+        return;
+      }
+      const pasted = await invoke<boolean>("credential_paste_to_pty", {
+        pty: ptyId,
+        target: entry.credential,
+      });
+      // `false` is the keychain answering "nothing here" — which on Linux is also how
+      // a *locked* collection answers, hence the second half of the message rather
+      // than a flat "nothing saved" the user knows to be untrue.
+      flash(pasted ? t("credentialPasteBar.pastedFlash") : t("credentialPasteBar.nothingSavedFlash"));
+    } catch (e) {
+      flash(String(e));
+    }
+  };
+
+  return (
+    <div className="credential-paste-bar">
+      <span className="ssh-optional-hint">{t("credentialPasteBar.typeItForMe")}</span>
+      {usable.map((entry) => (
+        <button
+          key={entry.label}
+          type="button"
+          className="credential-paste-btn"
+          title={entry.title}
+          // Never take the focus: the terminal below is where the next keystroke —
+          // the Enter this deliberately does not send — has to land, and a button
+          // that steals it turns one click into three (paste, click back, Enter).
+          // `focused` is a static prop on these embedded terminals, so nothing would
+          // hand the focus back on its own.
+          onMouseDown={(e) => e.preventDefault()}
+          onClick={() => void paste(entry)}
+        >
+          {entry.label}
+        </button>
+      ))}
+      <UntestedTag />
+      {note && <span className="ssh-optional-hint credential-paste-note">{note}</span>}
+    </div>
+  );
+}
+
+/**
+ * What an **SSH** login terminal offers to paste, built once for every dialog that
+ * has one — so the Connect modal, the new/extend-project dialog and the add-machine
+ * form can't drift into three different sets of buttons for one login.
+ *
+ * The password target carries the login name **being typed into the terminal**, not
+ * whichever one is persisted: the keychain is keyed per login, so that is the account
+ * this paste has to match. A name with nothing saved under it reports "nothing saved
+ * for this login" — the truth a `saved` flag asked about a *different* name cannot
+ * tell on its own.
+ */
+export function sshPasteEntries(
+  t: (key: TranslationKey, params?: Record<string, string | number>) => string,
+  opts: {
+    user?: string | null;
+    host?: string;
+    port?: number | null;
+    /** A password is known to be in the keychain for this target. */
+    saved: boolean;
+  },
+): PasteEntry[] {
+  const user = (opts.user ?? "").trim();
+  return [
+    {
+      label: t("credentialPasteBar.pasteUsername"),
+      title: t("credentialPasteBar.pasteUsernameTitle", { user }),
+      text: user,
+    },
+    ...(opts.saved && opts.host
+      ? [
+          {
+            label: t("credentialPasteBar.pastePassword"),
+            title: t("credentialPasteBar.pastePasswordTitle"),
+            credential: {
+              kind: "ssh-password" as const,
+              user: user || null,
+              host: opts.host,
+              port: opts.port ?? null,
+            },
+          },
+        ]
+      : []),
+  ];
+}
+
+/** The OpenVPN twin of [`sshPasteEntries`]. A config with an `auth-user-pass`
+ *  account *and* an encrypted key has two independent secrets, and OpenVPN prompts
+ *  for them separately — so they get a button each, in the order it asks. */
+export function vpnPasteEntries(
+  t: (key: TranslationKey, params?: Record<string, string | number>) => string,
+  opts: {
+    config: string;
+    username?: string;
+    saved: boolean;
+    needsUsername: boolean;
+    needsKeyPassphrase: boolean;
+  },
+): PasteEntry[] {
+  const { config, saved, needsKeyPassphrase } = opts;
+  const username = (opts.username ?? "").trim();
+  if (!config) return [];
+  return [
+    // The username is offered even when this dialog has none on screen: for a tunnel
+    // with no project behind it the saved one is the only copy there is.
+    ...(opts.needsUsername && (username || saved)
+      ? [
+          {
+            label: t("credentialPasteBar.pasteUsername"),
+            title: t("credentialPasteBar.pasteVpnUsernameTitle"),
+            text: username,
+            credential: { kind: "vpn-username" as const, config },
+          },
+        ]
+      : []),
+    ...(saved
+      ? [
+          {
+            label: needsKeyPassphrase ? t("credentialPasteBar.pastePassword") : t("credentialPasteBar.pastePassphrase"),
+            title: t("credentialPasteBar.pasteVpnSecretTitle"),
+            credential: { kind: "vpn-password" as const, config },
+          },
+        ]
+      : []),
+    ...(saved && needsKeyPassphrase
+      ? [
+          {
+            label: t("credentialPasteBar.pasteKeyPassphrase"),
+            title: t("credentialPasteBar.pasteKeyPassphraseTitle"),
+            credential: { kind: "vpn-key-passphrase" as const, config },
+          },
+        ]
+      : []),
+  ];
+}
diff --git a/src/components/projects/ExtendToRemoteDialog.tsx b/src/components/projects/ExtendToRemoteDialog.tsx
new file mode 100644
index 0000000..bcd31d4
--- /dev/null
+++ b/src/components/projects/ExtendToRemoteDialog.tsx
@@ -0,0 +1,256 @@
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { resolveProjectDirectory, type ProjectEntry } from "../../types";
+import { useProjectsStore } from "../../stores/projects";
+import { useRemoteStatusStore } from "../../stores/remoteStatus";
+import { useBigFoldersStore } from "../../stores/bigFolders";
+import { joinRemotePath, sanitizeName } from "./scaffold";
+import { useRemoteSession, type RemoteStep } from "./useRemoteSession";
+import { RemoteProjectSection } from "./RemoteProjectSection";
+import { targetLabel } from "../header/MachinesIndicator";
+import { hostKeyConfirmOnce } from "../../lib/hostKeyOnce";
+import type { DroppedGlobalMachine } from "../../stores/remoteMachines";
+import { useT } from "../../lib/i18n";
+
+/**
+ * "Extend to remote…" modal for an existing **local** project. It attaches a
+ * remote SSH spec without uploading any data: the empty remote root is created
+ * on the host (as when creating a remote project directly) and the project's
+ * current local directory becomes its local mirror in place. The user pushes
+ * files up later via the normal manual-sync UI.
+ *
+ * The whole connect → browse flow is the same machinery the new-project dialog
+ * uses — `useRemoteSession` (state/effects) + `RemoteProjectSection` (the SSH /
+ * OpenVPN / folder-browser UI) — so there's no duplicated remote logic here. The
+ * project name is fixed, so the "details" step is just a confirm summary.
+ *
+ * `initialMachine` seeds the SSH address from a global machine
+ * (`MachinesIndicator`) dropped onto this (local-only) project's pill — this
+ * dialog becomes the "make this machine the project's primary" flow. It only
+ * prefills the address field; the user still authenticates here (the global
+ * machine's own connection is a separate pooled session keyed by its own id,
+ * not by this project), though a saved password for that host target is
+ * picked up automatically since the keychain is keyed by host, not project.
+ */
+export function ExtendToRemoteDialog({
+  project,
+  initialMachine,
+  onClose,
+}: {
+  project: ProjectEntry;
+  initialMachine?: DroppedGlobalMachine;
+  onClose: () => void;
+}) {
+  const t = useT();
+  // The remote path leaf and local-mirror-relative name both use the project's
+  // sanitized name, matching direct remote creation (kind "new").
+  const safeName = sanitizeName(project.name);
+  const extendProjectToRemote = useProjectsStore((s) => s.extendProjectToRemote);
+
+  const remote = useRemoteSession({ kind: "new" });
+  const {
+    isRemoteProject,
+    toggleRemoteProject,
+    winManual,
+    isRemote,
+    step,
+    setStep,
+    remoteBrowsePath,
+    setRemoteChosenPath,
+    remoteChosenPath,
+    remoteReady,
+    remotePassword,
+    onSshAddressChange,
+    buildRemoteSpec,
+  } = remote;
+
+  const [error, setError] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  // Footer step machine, borrowed verbatim from the new-project dialog so the
+  // extend flow gets the same Back/Next navigation (the details step must be
+  // able to step back to re-pick the remote folder). Windows non-headless skips
+  // the browse step (it types the path in connect).
+  const remoteSteps: RemoteStep[] = winManual
+    ? ["connect", "details"]
+    : ["connect", "browse", "details"];
+  const stepIdx = remoteSteps.indexOf(step);
+  const goBack = () => setStep(remoteSteps[Math.max(0, stepIdx - 1)]);
+  const goNext = () => setStep(remoteSteps[Math.min(remoteSteps.length - 1, stepIdx + 1)]);
+  const canNext =
+    step === "connect"
+      ? winManual
+        ? remoteChosenPath.trim() !== ""
+        : isRemote
+      : step === "browse"
+        ? remoteChosenPath.trim() !== ""
+        : false;
+
+  // This dialog is always remote — enable remote mode on mount so the tooling
+  // probe + recent addresses/configs load and RemoteProjectSection renders.
+  // Dropped from a global machine: also seed the address field so the user
+  // only has to authenticate, not re-type the host.
+  useEffect(() => {
+    if (!isRemoteProject) toggleRemoteProject(true);
+    if (initialMachine) onSshAddressChange(targetLabel(initialMachine));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Commit the browsed folder as the parent and advance to the confirm step
+  // (mirrors ProjectDialog's useThisRemoteFolder; name is fixed so no form).
+  const useThisRemoteFolder = () => {
+    setRemoteChosenPath(remoteBrowsePath || "/");
+    setStep("details");
+  };
+
+  const submit = async () => {
+    const spec = buildRemoteSpec(safeName);
+    if (!spec) {
+      setError(t("extendRemote.connectFirstError"));
+      return;
+    }
+    setBusy(true);
+    setError("");
+    try {
+      await extendProjectToRemote(project.id, spec);
+      // Reaching this step required a live, authenticated SSH session (the flow
+      // browsed/created the remote folder over it). Carry that straight over to the
+      // now-remote project rather than dropping it to a "Connect" prompt: open its
+      // pooled SSH/SFTP channel and light the SSH lamp green. Fire-and-forget — the
+      // lamp reflects connecting → connected as it resolves.
+      //
+      // Hand it the credential the dialog authenticated with (empty for a key-auth
+      // host). Riding the still-live ControlMaster password-less would connect too,
+      // but the backend reads a password-less connect with nothing in the keychain as
+      // *key* auth and records `key_auth: true` — on a password host that is a lie the
+      // project keeps, and auto-connect later believes.
+      // A single attempt right after `remote_mkdir_p` can lose to a host session
+      // that hasn't finished settling yet — mirrors `ensureRemotePool`'s retry
+      // cadence (used on ordinary project activation) instead of parking the lamp
+      // on "error" forever after one transient hiccup, with the live ControlMaster
+      // underneath never actually going away.
+      const status = useRemoteStatusStore.getState();
+      status.setSsh(project.id, "connecting");
+      const connectPassword = remotePassword || null;
+      let connectAttempts = 0;
+      const maxConnectAttempts = 6;
+      // First contact: this loop dialled a host whose key may never have been
+      // accepted here, six times, four seconds apart — silently. Wrapped now, but
+      // with the **ask-once** variant (`hostKeyConfirmOnce`): the plain wrapper
+      // would raise six identical fingerprint dialogs, and re-ask five more times
+      // after a decline, which is not a decline at all.
+      const confirmHostKey = hostKeyConfirmOnce();
+      const tryConnect = () => {
+        void confirmHostKey(() =>
+          invoke("remote_connect", {
+            projectId: project.id,
+            password: connectPassword,
+            // With no password to hand over (non-headless, or a key host), this can only
+            // be riding the master the dialog's login left up — say so, so the backend
+            // doesn't record the very `key_auth: true` lie the comment above describes.
+            viaLogin: !connectPassword,
+            // The user clicked "Extend to remote" and is watching this lamp;
+            // `remote_connect` defaults to background, which a tagged HPC host refuses.
+            background: false,
+          }),
+        )
+          .then(() => useRemoteStatusStore.getState().setSsh(project.id, "connected"))
+          .catch((err) => {
+            if (++connectAttempts >= maxConnectAttempts) {
+              console.warn("remote_connect after extend failed", err);
+              useRemoteStatusStore.getState().setSsh(project.id, "error");
+              return;
+            }
+            setTimeout(tryConnect, 4000);
+          });
+      };
+      tryConnect();
+      // The existing local folder is about to become a synced working copy, so
+      // this is the last cheap moment to ask which of its giant folders (a
+      // `.venv`, a build dir, a data drop) should never cross. The prompt walks
+      // the local side straight away and fills in the host column when the
+      // connect above lands.
+      useBigFoldersStore.getState().openOnce(project.id);
+      onClose();
+    } catch (e) {
+      setError(String(e));
+      setBusy(false);
+    }
+  };
+
+  const remotePath = joinRemotePath(remoteChosenPath || "/", safeName || project.name);
+  // The local files stay in place, so the mirror is the project's current dir.
+  const localPath = resolveProjectDirectory(project);
+
+  return (
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog dialog-framed" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("extendRemote.title", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+        <p className="ssh-optional-hint">
+          {initialMachine ? (
+            <>
+              {t("extendRemote.attachPre")} <strong>{initialMachine.label || initialMachine.host}</strong>{" "}
+              {t("extendRemote.attachMid")}
+            </>
+          ) : (
+            t("extendRemote.attachGeneric")
+          )}
+        </p>
+
+        <RemoteProjectSection
+          kind="new"
+          safeName={safeName}
+          onClose={onClose}
+          onUseThisFolder={useThisRemoteFolder}
+          remote={remote}
+        />
+
+        {step === "details" && (
+          <div className="project-dialog-path extend-summary">
+            <span>{t("extendRemote.summaryLede")}</span>
+            <div className="extend-path-row">
+              <span className="extend-path-label">{t("extendRemote.local")}</span>
+              <code className="extend-remote-path">{localPath}</code>
+            </div>
+            <div className="extend-path-row">
+              <span className="extend-path-label">{t("extendRemote.remote")}</span>
+              <code className="extend-remote-path">{remotePath}</code>
+            </div>
+          </div>
+        )}
+
+        {error && <div className="project-dialog-error">{error}</div>}
+
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>
+            {t("common.cancel")}
+          </button>
+          {stepIdx > 0 && (
+            <button type="button" disabled={busy} onClick={goBack}>
+              {t("common.back")}
+            </button>
+          )}
+          {step !== "details" ? (
+            <button type="button" disabled={!canNext || busy} onClick={goNext}>
+              {t("common.next")}
+            </button>
+          ) : (
+            <button
+              type="button"
+              onClick={() => void submit()}
+              disabled={busy || !remoteReady}
+              title={t(remoteReady ? "extendRemote.readyTitle" : "extendRemote.notReadyTitle")}
+            >
+              {busy ? t("extendRemote.extending") : t("extendRemote.extendToRemote")}
+            </button>
+          )}
+        </div>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/projects/HpcHostToggle.tsx b/src/components/projects/HpcHostToggle.tsx
new file mode 100644
index 0000000..867e34d
--- /dev/null
+++ b/src/components/projects/HpcHostToggle.tsx
@@ -0,0 +1,55 @@
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
+import { isHpcHost, setHpcPatch, type Target } from "../../lib/hpcHost";
+import { useSettingsStore } from "../../stores/settings";
+import { useT } from "../../lib/i18n";
+
+/**
+ * The **HPC tag**, wherever a host is logged in to — the connect dialog's twin of
+ * the tick on the Machines menu's add-a-machine form.
+ *
+ * It sits beside `CarefulHostToggle` and says a strictly stronger thing. Careful
+ * is about *reading* (how much of this machine may Eldrun look at) and has a safe
+ * default. This is about *doing*: on a tagged machine Eldrun runs no disk-usage
+ * scan or folder census, no background sync or lockstep poll, never connects at
+ * launch by itself, and asks before a run lands on the login node
+ * (`lib/hpcHost.ts`, `docs/context/hpc_careful_mode.md`). None of that can be
+ * defaulted on — it would break the features for every ordinary remote box — and
+ * none of it can be inferred from the host, since a scheduler on `PATH` says the
+ * machine *has* SLURM, not that its operators mind. So it is asked, once, of the
+ * only party who knows.
+ *
+ * Stored per SSH target, so tagging a login node here also tags it as a global
+ * machine and as any other project's worker: one physical machine, one answer.
+ */
+export function HpcHostToggle({
+  target,
+  disabled,
+}: {
+  /** The host this governs. Null (a local project) renders nothing. */
+  target: Target | null | undefined;
+  disabled?: boolean;
+}) {
+  const t = useT();
+  const settings = useSettingsStore((s) => s.settings);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+
+  if (!target?.host) return null;
+
+  const tagged = isHpcHost(settings, target);
+
+  return (
+    <label className="remote-connect-remember careful-host-toggle" title={t("hpcHost.title")}>
+      <Toggle
+        size="sm"
+        checked={tagged}
+        disabled={disabled}
+        onChange={(e) => void updateSettings(setHpcPatch(settings, target, e.target.checked))}
+      />
+      {t("hpcHost.label")} <UntestedTag />
+      <span className="ssh-optional-hint">
+        {tagged ? t("hpcHost.hintOn") : t("hpcHost.hintOff")}
+      </span>
+    </label>
+  );
+}
diff --git a/src/components/projects/HpcPipelineWizard.tsx b/src/components/projects/HpcPipelineWizard.tsx
new file mode 100644
index 0000000..53acc1b
--- /dev/null
+++ b/src/components/projects/HpcPipelineWizard.tsx
@@ -0,0 +1,1126 @@
+/**
+ * The guided **HPC pipeline wizard** (`docs/quirky-knitting-umbrella` plan
+ * Phases B + C).
+ *
+ * A newcomer to a SLURM cluster has to log in, get a piece of the parallel
+ * filesystem to work in, create a project there, get their data across, write a
+ * batch script, submit it, and tail the log — a lot of steps, each easy to get
+ * subtly wrong. This stepper walks the whole path **by composing the existing
+ * flows** rather than reimplementing them:
+ *
+ *  1. **Login** — `RemoteProjectSection` + `useRemoteSession` (SSH connect + optional
+ *     OpenVPN + the live remote folder browser).
+ *  2. **Project** — a name + local-mirror location.
+ *  3. **Workspace** (Phase C, skipped on a host without the tooling) — allocate or
+ *     pick an `hpc-workspace` (`lib/hpcWorkspace`), **then** create the project.
+ *     This step exists because `$HOME` on a cluster is a small, quota'd, code-only
+ *     filesystem: bulk data belongs in a time-limited workspace on the parallel
+ *     filesystem. It has to come *before* the project is created and before a
+ *     single byte is uploaded, because the whole integration is that the chosen
+ *     workspace becomes the project's **remote root** — every existing transport
+ *     (SFTP upload, byte-sync, git lockstep, run tabs) then lands there instead of
+ *     `$HOME` with no change of its own.
+ *  4. **Load data** (skippable) — pick local files → stream them to the host over
+ *     the pooled SFTP (`remote_upload_file`) — i.e. into the workspace.
+ *  5. **Run job** — edit a starter `.slurm`'s `#SBATCH` directives (the Phase-A
+ *     splice helpers), write it to the host, and **Submit** it (Phase-A
+ *     `submitSlurmJob`, which opens a log tab).
+ *  6. **Watch** — the log tab is already tailing; point at the Jobs view (⚙) and
+ *     finish.
+ *
+ * Everything new is `untested` until QA'd on a real cluster.
+ */
+
+import { useEffect, useMemo, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { open } from "@tauri-apps/plugin-dialog";
+import { RemoteProjectSection } from "./RemoteProjectSection";
+import { useRemoteSession } from "./useRemoteSession";
+import { useHpcPipelineStore } from "../../stores/hpcPipeline";
+import { useProjectsStore, stashRemotePassword, stashRemoteViaLogin } from "../../stores/projects";
+import { useGlobalMachinesStore } from "../../stores/globalMachines";
+import { resolveProjectDirectory, resolveLocalMirror, type ProjectEntry } from "../../types";
+import { basename } from "../../lib/paths";
+import { writeFileText } from "../embed/fileAccess";
+import { UntestedTag } from "../common/UntestedTag";
+import {
+  parseSbatchDirectives,
+  directiveValue,
+  spliceDirective,
+  submitSlurmJob,
+  COMMON_SBATCH_KEYS,
+} from "../../lib/slurm";
+import {
+  wsAvailable,
+  wsList,
+  wsAllocate,
+  wsLink,
+  wsAnchor,
+  setProjectHpc,
+  wsTargetForHost,
+  defaultFilesystem,
+  defaultAnchorRel,
+  logOutputPattern,
+  scratchCandidates,
+  freeSpaceLabel,
+  remainingLabel,
+  expiryTone,
+  linkedWorkspaceCaveat,
+  type HpcWorkspace,
+  type HpcWsInfo,
+  type HpcAnchor,
+  type ScratchCandidate,
+} from "../../lib/hpcWorkspace";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+type Step = "login" | "project" | "workspace" | "data" | "run" | "watch";
+
+/** Where the project's tree lives on the host once a workspace is chosen.
+ *  `in-workspace` (the default) makes the workspace the project's remote root, so
+ *  everything Eldrun already syncs lands on the parallel filesystem; `link` keeps
+ *  the project in the browsed folder (usually `$HOME`) and symlinks the workspace
+ *  in for the host's own tools — see `linkedWorkspaceCaveat`. */
+type WsLayout = "in-workspace" | "link";
+
+/** Human labels for the `#SBATCH` keys the run step surfaces, keyed to translation keys. */
+const SBATCH_LABEL_KEYS: Record<string, TranslationKey> = {
+  "job-name": "hpcWizard.sbatchJobName",
+  partition: "hpcWizard.sbatchPartition",
+  time: "hpcWizard.sbatchTime",
+  nodes: "hpcWizard.sbatchNodes",
+  ntasks: "hpcWizard.sbatchTasks",
+  "cpus-per-task": "hpcWizard.sbatchCpusPerTask",
+  mem: "hpcWizard.sbatchMemory",
+  gres: "hpcWizard.sbatchGres",
+  output: "hpcWizard.sbatchOutput",
+};
+
+/** A sensible starter batch script. Edit the `#SBATCH` directives to match your
+ *  cluster's partitions/limits and your job's needs. */
+const STARTER_SLURM = `#!/bin/bash
+#SBATCH --job-name=myjob
+#SBATCH --account=<account>
+#SBATCH --partition=<partition>
+#SBATCH --time=01:00:00
+#SBATCH --nodes=1
+#SBATCH --ntasks=1
+#SBATCH --cpus-per-task=4
+#SBATCH --mem=8G
+#SBATCH --output=slurm-%j.out
+
+# Runs on a compute node via SLURM — never the login node.
+# Set --account to your working group's allocation: many clusters reject a job
+# with no account. Match --partition and the module name below to
+# your cluster; check its usage policy (e.g. any acknowledgement it asks for).
+
+module load Python
+python --version
+echo "Replace this with your job."
+`;
+
+const STARTER_NAME = "job.slurm";
+
+/** Mounted once in AppShell; renders the wizard when the store says it's open. */
+export function HpcPipelineWizardHost() {
+  const open = useHpcPipelineStore((s) => s.open);
+  const close = useHpcPipelineStore((s) => s.close);
+  if (!open) return null;
+  return <HpcPipelineWizard onClose={close} />;
+}
+
+function HpcPipelineWizard({ onClose }: { onClose: () => void }) {
+  const t = useT();
+  const addProject = useProjectsStore((s) => s.addProject);
+  const registerGlobalMachine = useGlobalMachinesStore((s) => s.register);
+  const remote = useRemoteSession({ kind: "new" });
+  const {
+    isRemoteProject,
+    isRemote,
+    remoteConn,
+    toggleRemoteProject,
+    remoteBrowsePath,
+    remoteChosenPath,
+    setRemoteChosenPath,
+    rememberChosenPath,
+    remotePassword,
+    buildRemoteSpec,
+  } = remote;
+
+  // Once the cluster login goes live, surface that host in the header's global
+  // machines list too — it's now a project-free, already-authenticated
+  // connection the user can reuse across projects (or drag onto one as a
+  // compute host). Registration is idempotent by target and best-effort, so it
+  // never blocks the wizard.
+  useEffect(() => {
+    if (!isRemote || !remoteConn) return;
+    void registerGlobalMachine({
+      user: remoteConn.user ?? undefined,
+      host: remoteConn.host,
+      port: remoteConn.port ?? undefined,
+    });
+  }, [isRemote, remoteConn, registerGlobalMachine]);
+
+  const [step, setStep] = useState<Step>("login");
+  const [projectsRoot, setProjectsRoot] = useState("");
+  const [mirrorParent, setMirrorParent] = useState("");
+  const [name, setName] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const [created, setCreated] = useState<ProjectEntry | null>(null);
+
+  // ── Workspace step (Phase C) ───────────────────────────────────────────────
+  // The folder the login step browsed to — kept so the "keep the project in
+  // $HOME and link the workspace in" layout can put it back as the remote root
+  // after the workspace layout has pointed it elsewhere.
+  const [browsedPath, setBrowsedPath] = useState("");
+  const [wsInfo, setWsInfo] = useState<HpcWsInfo | null>(null);
+  const [workspace, setWorkspace] = useState<HpcWorkspace | null>(null);
+  const [layout, setLayout] = useState<WsLayout>("in-workspace");
+  const [linkName, setLinkName] = useState("data");
+  const [linkedAt, setLinkedAt] = useState("");
+  // The home anchor: the small folder in the cluster `$HOME` that outlives the
+  // workspace (logs + a `cd`-able link + the record naming it).
+  const [anchorOn, setAnchorOn] = useState(true);
+  const [anchorRel, setAnchorRel] = useState("");
+  const [anchor, setAnchor] = useState<HpcAnchor | null>(null);
+  // A cluster with no workspace tooling still has a big filesystem; this is the
+  // one the host nominated and the user picked (null = the browsed folder).
+  const [scratchRoot, setScratchRoot] = useState<ScratchCandidate | null>(null);
+
+  // Force remote on for the whole wizard — an HPC project is remote by definition.
+  useEffect(() => {
+    if (!isRemoteProject) toggleRemoteProject(true);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Seed the local roots from the backend defaults (mirror of ProjectDialog).
+  useEffect(() => {
+    invoke<string>("projects_root_dir").then(setProjectsRoot).catch(() => {});
+    invoke<string>("remote_mirror_root_dir")
+      .then((dir) => setMirrorParent((cur) => cur || dir.replace(/\/+$/, "")))
+      .catch(() => {});
+  }, []);
+
+  const safeName = useMemo(
+    () => name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, ""),
+    [name],
+  );
+
+  // Commit the browsed remote folder and advance — mirrors ProjectDialog's
+  // `useThisRemoteFolder`.
+  const useThisFolder = () => {
+    const chosen = remoteBrowsePath || "/";
+    setRemoteChosenPath(chosen);
+    setBrowsedPath(chosen);
+    rememberChosenPath(chosen);
+    setStep("project");
+  };
+
+  // The workspace layout decides the project's REMOTE ROOT — that single
+  // assignment is the whole integration, because `buildRemoteSpec` derives the
+  // host path from `remoteChosenPath` and every transport follows it from there.
+  useEffect(() => {
+    if (created) return; // the spec is already fixed once the project exists
+    const root =
+      layout === "in-workspace" && workspace
+        ? workspace.path.replace(/\/+$/, "")
+        : (scratchRoot?.path.replace(/\/+$/, "") ?? browsedPath);
+    if (root) setRemoteChosenPath(root);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [layout, workspace, scratchRoot, browsedPath, created]);
+
+  // Probe the host for workspace tooling as soon as the login is live: the
+  // Workspace step needs to know whether it has anything to offer *before* the
+  // user gets there, and a cluster-less host skips it entirely.
+  useEffect(() => {
+    if (!isRemote || !remoteConn) return;
+    let cancelled = false;
+    void wsAvailable(wsTargetForHost(remoteConn, remotePassword))
+      .then((info) => {
+        if (!cancelled) setWsInfo(info);
+      })
+      .catch(() => {
+        if (!cancelled) setWsInfo({ available: false, filesystems: [] });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [isRemote, remoteConn, remotePassword]);
+
+  const chooseMirror = async () => {
+    const picked = await open({ directory: true, multiple: false, defaultPath: mirrorParent || undefined });
+    if (typeof picked === "string") setMirrorParent(picked.replace(/\/+$/, ""));
+  };
+
+  const canCreate = Boolean(name.trim() && safeName && remoteChosenPath && mirrorParent.trim());
+
+  const createProject = async () => {
+    setError("");
+    setBusy(true);
+    try {
+      const remoteSpec = buildRemoteSpec(safeName);
+      const targetDir = projectsRoot ? `${projectsRoot}/${safeName}` : "";
+      const project = await invoke<ProjectEntry>("create_project", {
+        req: {
+          name,
+          directory: targetDir,
+          description: "",
+          gitType: "local",
+          skipScaffold: false,
+          remote: remoteSpec,
+          mirrorParent,
+        },
+      });
+      // Hand the just-authenticated credential to the project's first pooled
+      // connect (single-use, never persisted — see stashRemotePassword).
+      if (remotePassword) stashRemotePassword(project.id, remotePassword);
+      // A login typed into the embedded terminal leaves no credential to stash, and
+      // headless mode alone doesn't say so — mark it, or the credential-less first
+      // connect is recorded as key auth on a password host.
+      if (remote.sshTerm) stashRemoteViaLogin(project.id);
+      rememberChosenPath();
+      await addProject(project); // adds + activates (which connects)
+      setCreated(project);
+      // The "keep it in $HOME" layout still wants the workspace reachable from
+      // the project — a symlink the host's own tools (job scripts, `cd`) follow.
+      // Best-effort: a failed link must not undo a created project, so it only
+      // reports.
+      if (layout === "link" && workspace) {
+        try {
+          const at = await wsLink(resolveProjectDirectory(project), workspace.path, linkName);
+          setLinkedAt(at);
+        } catch (err) {
+          setError(`Project created, but linking the workspace failed: ${String(err)}`);
+        }
+      }
+
+      // The home anchor + the project's own record of its workspace. Both are
+      // best-effort — neither can undo a created project — but the *record* is
+      // what makes an expiry survivable at all (`ws_restore` is keyed by the
+      // workspace name), so it is written even when the anchor is off.
+      let made: HpcAnchor | null = null;
+      const rel = anchorRel || defaultAnchorRel(safeName);
+      if (anchorOn && remoteConn) {
+        try {
+          made = await wsAnchor(wsTargetForHost(remoteConn, remotePassword), {
+            anchorRel: rel,
+            // At a site with no workspace tooling the link points at the big
+            // filesystem the host nominated instead — same purpose: a short,
+            // memorable way back to where the data actually is.
+            workspacePath: workspace?.path ?? scratchRoot?.path,
+            workspaceId: workspace?.id,
+            projectName: name.trim(),
+            // The record names the machine+folder holding the durable copy, so
+            // ask the created project rather than re-deriving the mirror path.
+            mirrorPath: resolveLocalMirror(project) ?? undefined,
+            makeLogs: true,
+          });
+          setAnchor(made);
+        } catch (err) {
+          setError(`Project created, but the home folder could not be set up: ${String(err)}`);
+        }
+      }
+      if (workspace || scratchRoot || made) {
+        const hpc = {
+          // A site filesystem has no workspace *id* — recording one would send
+          // Extend/expiry looking for an allocation that does not exist.
+          workspace_id: workspace?.id,
+          workspace_path: workspace?.path ?? scratchRoot?.path,
+          filesystem: workspace?.filesystem,
+          anchor_dir: made?.dir,
+          anchor_rel: made ? rel : undefined,
+          logs_dir: made?.logs_dir,
+        };
+        await setProjectHpc(project.id, hpc).catch(() => {});
+        // Mirror it into the live entry too: the store was populated by
+        // `addProject` before this record existed, and without this the expiry
+        // banner and the log-dir fallback would only start working after a
+        // relaunch re-read projects.json.
+        useProjectsStore.setState((s) => ({
+          projects: s.projects.map((p) => (p.id === project.id ? { ...p, hpc } : p)),
+        }));
+      }
+      setStep("data");
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog dialog-framed hpc-wizard" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>
+            {t("hpcWizard.title")} <UntestedTag />
+          </h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+        <StepTrail step={step} />
+        {error && <div className="project-dialog-error">{error}</div>}
+
+        {step === "login" && (
+          <>
+            <p className="ssh-optional-hint">
+              {t("hpcWizard.loginHint")}
+            </p>
+            <RemoteProjectSection
+              kind="new"
+              safeName={safeName}
+              onClose={onClose}
+              onUseThisFolder={useThisFolder}
+              remote={remote}
+            />
+          </>
+        )}
+
+        {step === "project" && (
+          <>
+            <label>
+              {t("hpcWizard.projectNameLabel")}
+              <input
+                autoFocus
+                value={name}
+                onChange={(e) => setName(e.target.value)}
+                placeholder="my-experiment"
+              />
+            </label>
+            <label>
+              {t("hpcWizard.mirrorLabel")}
+              <div className="folder-picker-row">
+                <span title={mirrorParent}>{mirrorParent || t("hpcWizard.noFolderSelected")}</span>
+                <button type="button" onClick={chooseMirror}>{t("hpcWizard.browseBtn")}</button>
+              </div>
+              <span className="ssh-optional-hint">
+                {t("hpcWizard.hostPathHintPre")} {browsedPath}/{safeName || "<name>"} {t("hpcWizard.hostPathHintPost")}
+              </span>
+            </label>
+            <div className="project-dialog-actions">
+              <button type="button" onClick={() => setStep("login")}>{t("common.back")}</button>
+              <button
+                type="button"
+                disabled={!name.trim() || !safeName || !mirrorParent.trim()}
+                onClick={() => setStep("workspace")}
+              >
+                {t("common.next")}
+              </button>
+            </div>
+          </>
+        )}
+
+        {step === "workspace" && (
+          <WorkspaceStep
+            info={wsInfo}
+            conn={remoteConn}
+            password={remotePassword}
+            safeName={safeName}
+            browsedPath={browsedPath}
+            workspace={workspace}
+            setWorkspace={setWorkspace}
+            layout={layout}
+            setLayout={setLayout}
+            linkName={linkName}
+            setLinkName={setLinkName}
+            anchorOn={anchorOn}
+            setAnchorOn={setAnchorOn}
+            anchorRel={anchorRel}
+            setAnchorRel={setAnchorRel}
+            scratchRoot={scratchRoot}
+            setScratchRoot={setScratchRoot}
+            busy={busy}
+            canCreate={canCreate}
+            onBack={() => setStep("project")}
+            onCreate={() => void createProject()}
+          />
+        )}
+
+        {step === "data" && created && (
+          <DataStep
+            project={created}
+            workspace={workspace}
+            layout={layout}
+            linkName={linkName}
+            linkedAt={linkedAt}
+            onBack={() => setStep("workspace")}
+            onNext={() => setStep("run")}
+          />
+        )}
+
+        {step === "run" && created && (
+          <RunStep
+            project={created}
+            logsDir={anchor?.logs_dir ?? ""}
+            dataHint={
+              workspace
+                ? layout === "in-workspace"
+                  ? `# This project lives in workspace '${workspace.id}' (${workspace.path}) —\n# its data is on the cluster's parallel filesystem, not in your home quota.`
+                  : `# Bulk data: ./${linkName} → workspace '${workspace.id}' (${workspace.path}).`
+                : ""
+            }
+            onBack={() => setStep("data")}
+            onSubmitted={() => setStep("watch")}
+          />
+        )}
+
+        {step === "watch" && (
+          <>
+            <p>
+              {t("hpcWizard.watchPre")} <strong>⚙</strong> {t("hpcWizard.watchMid")}{" "}
+              <em>{t("hpcWizard.watchWatchWord")}</em> {t("hpcWizard.watchAnd")}{" "}
+              <em>{t("hpcWizard.watchCancelWord")}</em>.
+            </p>
+            <div className="project-dialog-actions">
+              <button type="button" onClick={onClose}>{t("hpcWizard.done")}</button>
+            </div>
+          </>
+        )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/** The step breadcrumb across the top of the wizard. */
+function StepTrail({ step }: { step: Step }) {
+  const t = useT();
+  const steps: { id: Step; label: string }[] = [
+    { id: "login", label: t("hpcWizard.stepLogin") },
+    { id: "project", label: t("hpcWizard.stepProject") },
+    { id: "workspace", label: t("hpcWizard.stepWorkspace") },
+    { id: "data", label: t("hpcWizard.stepData") },
+    { id: "run", label: t("hpcWizard.stepRun") },
+    { id: "watch", label: t("hpcWizard.stepWatch") },
+  ];
+  const idx = steps.findIndex((s) => s.id === step);
+  return (
+    <div className="hpc-wizard-trail">
+      {steps.map((s, i) => (
+        <span
+          key={s.id}
+          className={`hpc-wizard-trail-step${i === idx ? " active" : ""}${i < idx ? " done" : ""}`}
+        >
+          {i + 1}. {s.label}
+        </span>
+      ))}
+    </div>
+  );
+}
+
+/**
+ * Step 3 (Phase C): get a **workspace** before anything is created or uploaded.
+ *
+ * `$HOME` on a cluster is a small, quota'd, backed-up filesystem for code; the
+ * data of a computation belongs on the parallel filesystem, which is handed out as
+ * a time-limited workspace (`ws_allocate <name> <days>`). This step allocates one
+ * (or adopts an existing one) and then decides where the project's tree goes:
+ *
+ *  - **in the workspace** (default) — the workspace path becomes the project's
+ *    remote root, so uploads, byte-sync, git lockstep and every run tab already
+ *    land on the parallel filesystem. Nothing else in Eldrun changes.
+ *  - **linked** — the project stays in the browsed folder and the workspace is
+ *    symlinked in as `./<name>` for the host's own tools, with the caveat that
+ *    Eldrun's sync does not follow a symlink.
+ *
+ * The project is created *here*, at the end, because its remote root is what this
+ * step decides. A host without the tooling shows a one-line note and the same
+ * Create button, so there is exactly one creation path.
+ */
+function WorkspaceStep({
+  info,
+  conn,
+  password,
+  safeName,
+  browsedPath,
+  workspace,
+  setWorkspace,
+  layout,
+  setLayout,
+  linkName,
+  setLinkName,
+  anchorOn,
+  setAnchorOn,
+  anchorRel,
+  setAnchorRel,
+  scratchRoot,
+  setScratchRoot,
+  busy,
+  canCreate,
+  onBack,
+  onCreate,
+}: {
+  info: HpcWsInfo | null;
+  conn: { user?: string | null; host: string; port?: number | null } | null;
+  password: string;
+  safeName: string;
+  browsedPath: string;
+  workspace: HpcWorkspace | null;
+  setWorkspace: (ws: HpcWorkspace | null) => void;
+  layout: WsLayout;
+  setLayout: (l: WsLayout) => void;
+  linkName: string;
+  setLinkName: (n: string) => void;
+  anchorOn: boolean;
+  setAnchorOn: (on: boolean) => void;
+  anchorRel: string;
+  setAnchorRel: (rel: string) => void;
+  scratchRoot: ScratchCandidate | null;
+  setScratchRoot: (c: ScratchCandidate | null) => void;
+  busy: boolean;
+  canCreate: boolean;
+  onBack: () => void;
+  onCreate: () => void;
+}) {
+  const t = useT();
+  const [existing, setExisting] = useState<HpcWorkspace[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [wsError, setWsError] = useState("");
+  const [allocating, setAllocating] = useState(false);
+  const [wsName, setWsName] = useState(safeName);
+  const [days, setDays] = useState("30");
+  const [filesystem, setFilesystem] = useState("");
+  const [mail, setMail] = useState("");
+  const [reminder, setReminder] = useState("7");
+  const [scratch, setScratch] = useState<ScratchCandidate[]>([]);
+
+  const target = useMemo(
+    () => (conn ? wsTargetForHost(conn, password) : null),
+    [conn, password],
+  );
+
+  // A cluster with no workspace tooling still has a big filesystem — ask it where
+  // (only then: at a workspace site the workspace *is* the answer).
+  useEffect(() => {
+    if (!target || info?.available !== false) return;
+    let cancelled = false;
+    void scratchCandidates(target)
+      .then((list) => {
+        if (!cancelled) setScratch(list);
+      })
+      .catch(() => {
+        if (!cancelled) setScratch([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [target, info?.available]);
+
+  // Where the project's tree will end up, in every branch below: the workspace
+  // (when one is chosen and hosts the project), a site filesystem the host
+  // nominated, or the browsed folder.
+  const rootPath = workspace && layout === "in-workspace" ? workspace.path : scratchRoot?.path ?? browsedPath;
+  const projectPath = `${rootPath.replace(/\/+$/, "")}/${safeName || "<name>"}`;
+
+  // Default the workspace name to the project name, and the filesystem to
+  // whichever one the site itself marked default (so the field states what
+  // leaving `-F` out would do, rather than pretending there is no choice).
+  useEffect(() => {
+    setWsName((n) => n || safeName);
+  }, [safeName]);
+  useEffect(() => {
+    setFilesystem((f) => f || defaultFilesystem(info) || "");
+  }, [info]);
+
+  // The user's existing workspaces — one may already be the right home for this
+  // project (allocating a second one for the same data is the common mistake).
+  useEffect(() => {
+    if (!info?.available || !target) return;
+    let cancelled = false;
+    setLoading(true);
+    void wsList(target)
+      .then((list) => {
+        if (!cancelled) setExisting(list);
+      })
+      .catch((err) => {
+        if (!cancelled) setWsError(String(err));
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [info, target]);
+
+  const allocate = async () => {
+    if (!target) return;
+    setWsError("");
+    setAllocating(true);
+    try {
+      const ws = await wsAllocate(target, {
+        id: wsName.trim(),
+        days: Number(days) || 0,
+        filesystem: filesystem.trim() || undefined,
+        mail: mail.trim() || undefined,
+        reminderDays: Number(reminder) || undefined,
+      });
+      setWorkspace(ws);
+      setExisting((list) => [ws, ...list.filter((w) => w.id !== ws.id)]);
+    } catch (err) {
+      setWsError(String(err));
+    } finally {
+      setAllocating(false);
+    }
+  };
+
+  // No workspace tooling on this host — which is the ordinary answer at any host
+  // that isn't a cluster, AND at a cluster that simply uses a different
+  // convention. The step still has to be answered in the second case: dropping
+  // the project into the browsed folder means `$HOME`, the exact thing this step
+  // exists to prevent. So ask the site where its big filesystem is
+  // (`$SCRATCH`/`$WORK`/… as its own profile exports them) and offer those.
+  if (info && !info.available) {
+    return (
+      <>
+        <p className="ssh-optional-hint">
+          {t("hpcWizard.noToolingPre")}<code>ws_allocate</code>{t("hpcWizard.noToolingPost")}
+          {scratch.length > 0 ? (
+            <>
+              {" "}
+              {t("hpcWizard.noToolingScratchHint")}
+            </>
+          ) : (
+            <>
+              {" "}
+              {t("hpcWizard.noToolingNoScratchPre")}{" "}
+              <code>
+                {browsedPath}/{safeName || "<name>"}
+              </code>
+              .
+            </>
+          )}
+        </p>
+        {scratch.length > 0 && (
+          <div className="hpc-ws-list">
+            <label className="hpc-ws-row">
+              <input
+                type="radio"
+                name="hpc-scratch"
+                checked={!scratchRoot}
+                onChange={() => setScratchRoot(null)}
+              />
+              <span className="hpc-ws-id">{t("hpcWizard.homeRadioLabel")}</span>
+              <span className="hpc-ws-path" title={browsedPath}>{browsedPath}</span>
+            </label>
+            {scratch.map((c) => (
+              <label key={c.path} className="hpc-ws-row">
+                <input
+                  type="radio"
+                  name="hpc-scratch"
+                  disabled={!c.writable}
+                  checked={scratchRoot?.path === c.path}
+                  onChange={() => setScratchRoot(c)}
+                />
+                <span className="hpc-ws-id">{c.label}</span>
+                <span className="hpc-ws-path" title={c.path}>{c.path}</span>
+                <span className="hpc-ws-remaining tone-ok">
+                  {[c.writable ? "" : t("hpcWizard.readOnly"), freeSpaceLabel(c.free_kb)]
+                    .filter(Boolean)
+                    .join(" · ")}
+                </span>
+              </label>
+            ))}
+          </div>
+        )}
+        <span className="ssh-optional-hint">
+          {t("hpcWizard.projectOnHostLabel")} <code>{projectPath}</code>
+        </span>
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onBack}>{t("common.back")}</button>
+          <button type="button" disabled={!canCreate || busy} onClick={onCreate}>
+            {busy ? t("hpcWizard.creating") : t("hpcWizard.createProject")}
+          </button>
+        </div>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <p className="ssh-optional-hint">
+        {t("hpcWizard.introPre")} <strong>{t("hpcWizard.introStrongWorkspace")}</strong>{" "}
+        {t("hpcWizard.introMid")}{" "}
+        <strong>{t("hpcWizard.introStrongDeleted")}</strong>
+        {t("hpcWizard.introPost")}
+      </p>
+      {!info && <p className="ssh-optional-hint">{t("hpcWizard.checkingTooling")}</p>}
+      {wsError && <div className="project-dialog-error">{wsError}</div>}
+
+      {info?.available && (
+        <>
+          <div className="hpc-ws-form">
+            <label className="slurm-directive-field">
+              <span className="slurm-directive-key">{t("hpcWizard.workspaceNameLabel")}</span>
+              <input
+                className="file-viewer-run-args-input"
+                value={wsName}
+                spellCheck={false}
+                onChange={(e) => setWsName(e.target.value)}
+              />
+            </label>
+            <label className="slurm-directive-field">
+              <span className="slurm-directive-key">{t("hpcWizard.daysLabel")}</span>
+              <input
+                className="file-viewer-run-args-input"
+                value={days}
+                inputMode="numeric"
+                onChange={(e) => setDays(e.target.value.replace(/[^0-9]/g, ""))}
+              />
+            </label>
+            <label className="slurm-directive-field">
+              <span className="slurm-directive-key">{t("hpcWizard.filesystemLabel")}</span>
+              {info.filesystems.length > 0 ? (
+                <select value={filesystem} onChange={(e) => setFilesystem(e.target.value)}>
+                  <option value="">{t("hpcWizard.siteDefault")}</option>
+                  {info.filesystems.map((f) => (
+                    <option key={f.name} value={f.name}>
+                      {f.name}
+                      {f.default ? t("hpcWizard.defaultSuffix") : ""}
+                    </option>
+                  ))}
+                </select>
+              ) : (
+                <input
+                  className="file-viewer-run-args-input"
+                  value={filesystem}
+                  spellCheck={false}
+                  placeholder={t("hpcWizard.siteDefault")}
+                  onChange={(e) => setFilesystem(e.target.value)}
+                />
+              )}
+            </label>
+            <label className="slurm-directive-field">
+              <span className="slurm-directive-key">{t("hpcWizard.reminderEmailLabel")}</span>
+              <input
+                className="file-viewer-run-args-input"
+                value={mail}
+                spellCheck={false}
+                placeholder={t("hpcWizard.optionalPlaceholder")}
+                onChange={(e) => setMail(e.target.value)}
+              />
+            </label>
+            <label className="slurm-directive-field">
+              <span className="slurm-directive-key">{t("hpcWizard.remindDaysLabel")}</span>
+              <input
+                className="file-viewer-run-args-input"
+                value={reminder}
+                inputMode="numeric"
+                onChange={(e) => setReminder(e.target.value.replace(/[^0-9]/g, ""))}
+              />
+            </label>
+          </div>
+          <span className="ssh-optional-hint">
+            {t("hpcWizard.reminderHint")}
+          </span>
+          <div className="folder-picker-row">
+            <button
+              type="button"
+              disabled={allocating || !wsName.trim() || !days}
+              onClick={() => void allocate()}
+            >
+              {allocating ? t("hpcWizard.allocating") : t("hpcWizard.allocateWorkspace")}
+            </button>
+          </div>
+
+          {loading && <p className="ssh-optional-hint">{t("hpcWizard.readingWorkspaces")}</p>}
+          {existing.length > 0 && (
+            <div className="hpc-ws-list">
+              <div className="slurm-directive-key">{t("hpcWizard.yourWorkspaces")}</div>
+              {existing.map((ws) => {
+                const tone = expiryTone(ws);
+                return (
+                  <label key={`${ws.filesystem ?? ""}/${ws.id}`} className="hpc-ws-row">
+                    <input
+                      type="radio"
+                      name="hpc-ws-pick"
+                      checked={workspace?.id === ws.id && workspace?.path === ws.path}
+                      onChange={() => setWorkspace(ws)}
+                    />
+                    <span className="hpc-ws-id">{ws.id}</span>
+                    <span className="hpc-ws-path" title={ws.path}>{ws.path}</span>
+                    {remainingLabel(ws) && (
+                      <span className={`hpc-ws-remaining tone-${tone}`}>{remainingLabel(ws)}</span>
+                    )}
+                  </label>
+                );
+              })}
+            </div>
+          )}
+
+          {workspace && (
+            <div className="hpc-ws-layout">
+              <div className="slurm-directive-key">{t("hpcWizard.whereProjectGoes")}</div>
+              <label className="hpc-ws-row">
+                <input
+                  type="radio"
+                  name="hpc-ws-layout"
+                  checked={layout === "in-workspace"}
+                  onChange={() => setLayout("in-workspace")}
+                />
+                <span>
+                  <strong>{t("hpcWizard.inWorkspaceStrong")}</strong> {t("hpcWizard.inWorkspaceDesc")}
+                </span>
+              </label>
+              <label className="hpc-ws-row">
+                <input
+                  type="radio"
+                  name="hpc-ws-layout"
+                  checked={layout === "link"}
+                  onChange={() => setLayout("link")}
+                />
+                <span>
+                  <strong>{t("hpcWizard.inBrowsedStrong")}</strong>{t("hpcWizard.inBrowsedDesc")}{" "}
+                  <code>./{linkName || "data"}</code>. {linkedWorkspaceCaveat}
+                </span>
+              </label>
+              {layout === "link" && (
+                <label className="slurm-directive-field">
+                  <span className="slurm-directive-key">{t("hpcWizard.linkNameLabel")}</span>
+                  <input
+                    className="file-viewer-run-args-input"
+                    value={linkName}
+                    spellCheck={false}
+                    onChange={(e) => setLinkName(e.target.value.replace(/[^A-Za-z0-9._-]/g, ""))}
+                  />
+                </label>
+              )}
+            </div>
+          )}
+        </>
+      )}
+
+      {/* The home anchor. Offered whether or not a workspace was chosen, because
+          the *record* it appends is what makes an expiry recoverable — the
+          tooling's restore path is keyed by the workspace name, and by then the
+          directory that carried it is gone. */}
+      <div className="hpc-ws-layout">
+        <label className="hpc-ws-row">
+          <input
+            type="checkbox"
+            checked={anchorOn}
+            onChange={(e) => setAnchorOn(e.target.checked)}
+          />
+          <span>
+            {t("hpcWizard.anchorPre")}{" "}
+            <code>logs/</code>{t("hpcWizard.anchorMid")} <code>workspace</code>{" "}
+            {t("hpcWizard.anchorPost")}
+          </span>
+        </label>
+        {anchorOn && (
+          <label className="slurm-directive-field">
+            <span className="slurm-directive-key">{t("hpcWizard.anchorFolderLabel")}</span>
+            <input
+              className="file-viewer-run-args-input"
+              value={anchorRel || defaultAnchorRel(safeName)}
+              spellCheck={false}
+              onChange={(e) => setAnchorRel(e.target.value.replace(/[^A-Za-z0-9._/-]/g, ""))}
+            />
+          </label>
+        )}
+      </div>
+
+      <span className="ssh-optional-hint">
+        {t("hpcWizard.projectOnHostLabel")} <code>{projectPath}</code>
+      </span>
+      <div className="project-dialog-actions">
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+        <button type="button" disabled={!canCreate || busy} onClick={onCreate}>
+          {busy ? t("hpcWizard.creating") : workspace ? t("hpcWizard.createProject") : t("hpcWizard.createWithoutWorkspace")}
+        </button>
+      </div>
+    </>
+  );
+}
+
+/** Step 4: upload local files to the host over the pooled SFTP. Skippable.
+ *  Uploads land in the project's remote root — which, after the Workspace step,
+ *  is the workspace itself — or through the workspace symlink in the linked
+ *  layout, so a "Load data" click never fills the user's home quota. */
+function DataStep({
+  project,
+  workspace,
+  layout,
+  linkName,
+  linkedAt,
+  onBack,
+  onNext,
+}: {
+  project: ProjectEntry;
+  workspace: HpcWorkspace | null;
+  layout: WsLayout;
+  linkName: string;
+  linkedAt: string;
+  onBack: () => void;
+  onNext: () => void;
+}) {
+  const t = useT();
+  const [uploaded, setUploaded] = useState<string[]>([]);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  // Where an uploaded file lands. In the linked layout the workspace is reachable
+  // only *through* the symlink, so the destination is prefixed with it — SFTP
+  // follows the link on the host, which is the whole point of having made it.
+  const destPrefix = workspace && layout === "link" && linkedAt ? `${linkName}/` : "";
+  const destLabel = workspace
+    ? layout === "in-workspace"
+      ? workspace.path
+      : linkedAt || `${linkName}${t("hpcWizard.linkNotCreatedSuffix")}`
+    : (project.remote?.remote_path ?? t("hpcWizard.theProjectFolder"));
+
+  const addFiles = async () => {
+    setError("");
+    const picked = await open({ multiple: true, directory: false });
+    const paths = Array.isArray(picked) ? picked : picked ? [picked] : [];
+    if (paths.length === 0) return;
+    setBusy(true);
+    try {
+      for (const p of paths) {
+        const name = basename(p);
+        await invoke("remote_upload_file", {
+          projectId: project.id,
+          localPath: p,
+          destRel: `${destPrefix}${name}`,
+        });
+        setUploaded((u) => [...u, `${destPrefix}${name}`]);
+      }
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <>
+      <p className="ssh-optional-hint">
+        {t("hpcWizard.dataHintPre")} <code>{destLabel}</code>
+        {workspace ? ` ${t("hpcWizard.dataHintWorkspaceSuffix")}` : t("hpcWizard.dataHintPlainSuffix")}{" "}
+        {t("hpcWizard.dataHintPost")}
+      </p>
+      {error && <div className="project-dialog-error">{error}</div>}
+      <div className="folder-picker-row">
+        <button type="button" disabled={busy} onClick={() => void addFiles()}>
+          {busy ? t("hpcWizard.uploading") : t("hpcWizard.addFiles")}
+        </button>
+      </div>
+      {uploaded.length > 0 && (
+        <ul className="hpc-wizard-uploaded">
+          {uploaded.map((f) => (
+            <li key={f}>✓ {f}</li>
+          ))}
+        </ul>
+      )}
+      <div className="project-dialog-actions">
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+        <button type="button" onClick={onNext}>
+          {uploaded.length ? t("common.next") : t("hpcWizard.skip")}
+        </button>
+      </div>
+    </>
+  );
+}
+
+/** Step 5: edit a starter `.slurm`'s directives, write it to the host, submit.
+ *  `dataHint` is a comment naming the workspace the data lives in — the job
+ *  script is where the user will look for it next. */
+function RunStep({
+  project,
+  logsDir,
+  dataHint,
+  onBack,
+  onSubmitted,
+}: {
+  project: ProjectEntry;
+  logsDir: string;
+  dataHint: string;
+  onBack: () => void;
+  onSubmitted: () => void;
+}) {
+  const t = useT();
+  // Two edits to the starter, both made once at mount: the workspace comment, and
+  // — when a home anchor exists — `--output` routed into it, so the log outlives
+  // the workspace the job ran in. The `--output` edit goes through
+  // `spliceDirective` for the same reason every other directive edit does: it
+  // rewrites that one line and leaves the rest of the script byte-identical.
+  const [script, setScript] = useState(() => {
+    let s = dataHint
+      ? STARTER_SLURM.replace("\n# Runs on a compute node", `\n${dataHint}\n# Runs on a compute node`)
+      : STARTER_SLURM;
+    if (logsDir) s = spliceDirective(s, "output", logOutputPattern(logsDir));
+    return s;
+  });
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const fields = useMemo(() => parseSbatchDirectives(script), [script]);
+  const [edits, setEdits] = useState<Record<string, string>>({});
+
+  const remoteRoot = project.remote?.remote_path ?? "";
+  const scriptPath = `${remoteRoot.replace(/\/+$/, "")}/${STARTER_NAME}`;
+  const projectDir = resolveProjectDirectory(project);
+
+  const valueFor = (key: string) => edits[key] ?? directiveValue(fields, key);
+  const commit = (key: string) => {
+    const v = edits[key];
+    if (v === undefined) return;
+    setScript((s) => spliceDirective(s, key, v));
+  };
+
+  const submit = async () => {
+    setError("");
+    setBusy(true);
+    try {
+      // Write the (possibly edited) script to the host, then submit it.
+      await writeFileText(scriptPath, script, project.id);
+      await submitSlurmJob({
+        file: scriptPath,
+        projectDir,
+        cwd: projectDir,
+        projectId: project.id,
+        scope: project.id,
+        isRemote: true,
+      });
+      onSubmitted();
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <>
+      <p className="ssh-optional-hint">
+        {t("hpcWizard.scriptHintPre")}<code>{STARTER_NAME}</code>{t("hpcWizard.scriptHintPost")}
+      </p>
+      {error && <div className="project-dialog-error">{error}</div>}
+      <div className="slurm-directive-grid">
+        {COMMON_SBATCH_KEYS.map((key) => (
+          <label key={key} className="slurm-directive-field">
+            <span className="slurm-directive-key">{SBATCH_LABEL_KEYS[key] ? t(SBATCH_LABEL_KEYS[key]) : key}</span>
+            <input
+              className="file-viewer-run-args-input"
+              value={valueFor(key)}
+              spellCheck={false}
+              onChange={(e) => setEdits((m) => ({ ...m, [key]: e.target.value }))}
+              onBlur={() => commit(key)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") {
+                  e.preventDefault();
+                  commit(key);
+                }
+              }}
+            />
+          </label>
+        ))}
+      </div>
+      <div className="project-dialog-actions">
+        <button type="button" onClick={onBack}>{t("common.back")}</button>
+        <button type="button" disabled={busy} onClick={() => void submit()}>
+          {busy ? t("hpcWizard.submitting") : t("hpcWizard.submitJob")}
+        </button>
+      </div>
+    </>
+  );
+}
diff --git a/src/components/projects/ProjectDialog.tsx b/src/components/projects/ProjectDialog.tsx
index 76479a1..2ed27c4 100644
--- a/src/components/projects/ProjectDialog.tsx
+++ b/src/components/projects/ProjectDialog.tsx
@@ -1,8 +1,10 @@
 import { useEffect, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
+import { Toggle } from "../common/Toggle";
 import { open } from "@tauri-apps/plugin-dialog";
 import type { ProjectEntry } from "../../types";
 import { resolveProjectDirectory } from "../../types";
+import { basename } from "../../lib/paths";
 import { cmdToKind, useTabsStore } from "../../stores/tabs";
 import { useSettingsStore } from "../../stores/settings";
 import {
@@ -13,24 +15,62 @@ import {
   buildDescriptionFillPrompt,
   buildScaffoldFillPrompt,
   collectScaffoldAgentFills,
+  isCloneUrl,
   joinRemotePath,
+  providerFromCloneUrl,
+  repoNameFromCloneUrl,
   sanitizeName,
   type ScaffoldPreviewItem,
 } from "./scaffold";
-import { useRemoteSession } from "./useRemoteSession";
+import { useRemoteSession, type RemoteStep } from "./useRemoteSession";
 import { RemoteProjectSection } from "./RemoteProjectSection";
+import { stashRemotePassword, stashRemoteViaLogin } from "../../stores/projects";
+import { Dropdown } from "../common/Dropdown";
+import { runInstallInTab, PROVIDER_CLI_INSTALL } from "../../lib/installCommand";
+import { UntestedTag } from "../common/UntestedTag";
+import { IS_WINDOWS, IS_MAC } from "../../lib/platform";
+import { useT } from "../../lib/i18n";
+
+/** OS-appropriate command to install git, used by the one-click "Install git"
+ *  prompt shown when creating/importing a git-backed project on a machine with
+ *  no `git` on PATH (`scaffold_project`'s `git init` would otherwise silently
+ *  no-op, registering a git-typed project with no repo). */
+const GIT_INSTALL_CMD = IS_WINDOWS
+  ? "winget install --id Git.Git -e --source winget"
+  : IS_MAC
+    ? "brew install git"
+    : "sudo apt-get install -y git";
+
+/** Where an import's files come from: a folder already on this machine, a
+ *  repository cloned from GitHub/GitLab (any git URL), or a *fork* of one —
+ *  the same clone, preceded by creating the user's own copy of the repository
+ *  on the host so there is something to push to. */
+export type ImportSource = "folder" | "git" | "fork";
 
 export function ProjectDialog({
   kind,
+  initialImportSource = "folder",
   onClose,
   onProject,
 }: {
   kind: "new" | "import";
+  initialImportSource?: ImportSource;
   onClose: () => void;
   onProject: (project: ProjectEntry) => void | Promise<void>;
 }) {
+  const t = useT();
   const defaultAgentCmd = useSettingsStore((s) => s.settings?.default_agent_cmd ?? "claude");
+  // A GitHub/GitLab "connection through Eldrun" = a global access token saved in
+  // Settings → Git Hosting (the credential publishing actually uses). Used to
+  // decide whether picking a "Push to GitHub/GitLab" git type can proceed or
+  // should first send the user to set the connection up.
+  const gitToken = useSettingsStore((s) => s.settings?.git_token ?? "");
   const [projectsRoot, setProjectsRoot] = useState("");
+  // Remote (SSH) projects only: the chosen parent dir for the LOCAL mirror (the
+  // synced working copy). The mirror lands at `<mirrorParent>/<name>`. Seeded
+  // from the backend default (`projects-ssh` root) so it matches
+  // `default_remote_mirror`; editable via the "Local location" picker.
+  const [mirrorParent, setMirrorParent] = useState("");
   const [name, setName] = useState("");
   const [description, setDescription] = useState("");
   const [descriptionFillMode, setDescriptionFillMode] = useState("manual");
@@ -38,30 +78,161 @@ export function ProjectDialog({
   const [mode, setMode] = useState("keep");
   const [skipScaffold, setSkipScaffold] = useState(false);
   const [sourceDir, setSourceDir] = useState("");
+  // Import source: an existing local folder, or a clone from GitHub/GitLab.
+  const [importSource, setImportSource] = useState<ImportSource>(initialImportSource);
+  const [repoUrl, setRepoUrl] = useState("");
+  // Fork source only: which hosting provider drives the fork. "" = read it off
+  // the URL's host, which is what a github.com/gitlab.com URL says on its own;
+  // a self-hosted instance names neither, so it can also be picked explicitly.
+  const [forkProvider, setForkProvider] = useState("");
+  // Whether that provider's CLI (`gh`/`glab`) is on PATH. `null` while probing,
+  // so a pending probe never blocks submit or flashes the install banner.
+  const [forkCliAvailable, setForkCliAvailable] = useState<boolean | null>(null);
+  const [cloning, setCloning] = useState(false);
   const [scaffoldPreview, setScaffoldPreview] = useState<ScaffoldPreviewItem[]>([]);
   const [scaffoldFillModes, setScaffoldFillModes] = useState<Record<string, string>>({});
   const [scaffoldError, setScaffoldError] = useState("");
   const [manualValidationConfirmed, setManualValidationConfirmed] = useState(false);
   const [error, setError] = useState("");
   const [busy, setBusy] = useState(false);
+  // Whether `git` is on PATH on this machine. `null` while still probing (never
+  // block submit or show the install banner on that transient state); checked
+  // once per dialog open since installing git mid-dialog is rare enough not to
+  // warrant polling — the banner just won't self-clear without a reopen.
+  const [gitAvailable, setGitAvailable] = useState<boolean | null>(null);
   // Optional SSH + OpenVPN + remote-browser lifecycle (see useRemoteSession).
   const remote = useRemoteSession({ kind });
   const {
     isRemoteProject,
     isRemote,
+    winManual,
+    step,
+    setStep,
+    remoteReady,
     remoteBrowsePath,
     remoteChosenPath,
     setRemoteChosenPath,
+    rememberChosenPath,
+    remotePassword,
     toggleRemoteProject,
     buildRemoteSpec,
   } = remote;
+  // Remote projects walk a stepped flow (connect → browse → details); the
+  // name/git/description body only appears on the final "details" step. Local
+  // projects ignore steps and show their single form.
+  const showDetails = !isRemoteProject || step === "details";
+  // Step order for the footer's Back/Next; Windows non-headless has no browse
+  // step (it types the path in the connect step instead).
+  const remoteSteps: RemoteStep[] = winManual
+    ? ["connect", "details"]
+    : ["connect", "browse", "details"];
+  const stepIdx = remoteSteps.indexOf(step);
+  const goBack = () => setStep(remoteSteps[Math.max(0, stepIdx - 1)]);
+  const goNext = () => setStep(remoteSteps[Math.min(remoteSteps.length - 1, stepIdx + 1)]);
+  const canNext =
+    step === "connect"
+      ? winManual
+        ? remoteChosenPath.trim() !== ""
+        : isRemote
+      : step === "browse"
+        ? remoteChosenPath.trim() !== ""
+        : false;
   const safeName = sanitizeName(name);
   const targetDir = safeName && projectsRoot ? `${projectsRoot}/${safeName}` : "";
+  // Cloning from a hosting service. A remote (SSH) project's tree lives on the
+  // host and is never cloned locally, so the two are mutually exclusive. A fork
+  // import *is* a clone import — same URL field, same destination, same "keep"
+  // registration — with the fork created first, so it shares every branch below
+  // and only adds the provider row.
+  const isForkImport = kind === "import" && !isRemoteProject && importSource === "fork";
+  const isCloneImport =
+    (kind === "import" && !isRemoteProject && importSource === "git") || isForkImport;
+  // Which provider a fork goes through: the explicit pick, else what the URL's
+  // host says. "" means "can't tell" — the user has to choose before submitting.
+  const forkProviderResolved = (forkProvider || providerFromCloneUrl(repoUrl)) as
+    | "github"
+    | "gitlab"
+    | "";
+  const forkCli = forkProviderResolved ? PROVIDER_CLI_INSTALL[forkProviderResolved] : null;
+  // Same shape as the git-install banner: only claim the CLI is missing once the
+  // probe has actually answered.
+  const needsForkCliInstall = isForkImport && forkCliAvailable === false && forkCli !== null;
+  // "Push to GitHub/GitLab" was chosen, but no Eldrun connection is set up yet.
+  // Here "remote" is the git push target (a hosting service), distinct from the
+  // SSH host the files may live on — see the git-hosting hint below.
+  const wantsRemoteGit = gitType === "remote-private" || gitType === "remote-public";
+  const gitConnected = gitToken.trim() !== "";
+  // A clone is exempt: the gate exists because publishing a *new* repo needs a
+  // token, and a cloned repo is already hosted — it has an origin to push back
+  // to. (The clone itself only needs the token when the repo is private, which
+  // the URL field's own hint covers.)
+  const needsGitConnection = wantsRemoteGit && !gitConnected && !isCloneImport;
+  // A git repo is created LOCALLY even for a remote (SSH) project — the local
+  // mirror scaffolds with `git init` the same way a local project does — so this
+  // gates on the chosen git type alone, not on isRemoteProject. A clone import
+  // needs `git` too (`git_clone` shells out to it) regardless of gitType.
+  const needsGitInstall = gitAvailable === false && (gitType !== "none" || isCloneImport);
+
+  // Switching the import source resets the git-hosting default to the one that
+  // fits it: a clone comes from a host, a plain folder does not. Both remain
+  // freely overridable in the dropdown below.
+  const changeImportSource = (next: ImportSource) => {
+    setImportSource(next);
+    setGitType(next === "folder" ? "local" : "remote-private");
+  };
+
+  const setRepoUrlAndName = (url: string) => {
+    setRepoUrl(url);
+    // Pre-fill the project name from the repo's own name, but only while the
+    // user hasn't typed one of their own (and only while it still matches what
+    // the previous URL suggested, so backspacing the URL keeps updating it).
+    const suggested = repoNameFromCloneUrl(url);
+    setName((cur) => (cur === "" || cur === repoNameFromCloneUrl(repoUrl) ? suggested : cur));
+  };
+
+  // Send the user to Settings → Git Hosting to establish the GitHub/GitLab
+  // connection. The project dialog stays open (so the half-filled form isn't
+  // lost); once a token is saved the `needsGitConnection` notice clears live.
+  // Git Hosting is its own settings sub-panel, so open it directly.
+  const openGitHostingSettings = () => {
+    window.dispatchEvent(new CustomEvent("eldrun:open-settings", { detail: "git" }));
+  };
 
   useEffect(() => {
     invoke<string>("projects_root_dir").then(setProjectsRoot).catch(() => {});
   }, []);
 
+  useEffect(() => {
+    invoke<boolean>("git_available").then(setGitAvailable).catch(() => setGitAvailable(false));
+  }, []);
+
+  // Probe the fork provider's CLI whenever the resolved provider changes (it
+  // moves as the URL is typed). Reset to `null` first so the banner never shows
+  // a previous provider's answer while the new one is still being asked.
+  useEffect(() => {
+    if (!isForkImport || !forkProviderResolved) {
+      setForkCliAvailable(null);
+      return;
+    }
+    let cancelled = false;
+    setForkCliAvailable(null);
+    invoke<boolean>("provider_cli_available", { provider: forkProviderResolved })
+      .then((ok) => !cancelled && setForkCliAvailable(ok))
+      .catch(() => !cancelled && setForkCliAvailable(false));
+    return () => {
+      cancelled = true;
+    };
+  }, [isForkImport, forkProviderResolved]);
+
+  // Seed the remote local-mirror parent from the backend default (the
+  // `projects-ssh` root) so the picker's default agrees with the backend
+  // fallback. Only fills an empty value, so a user edit isn't clobbered.
+  useEffect(() => {
+    invoke<string>("remote_mirror_root_dir")
+      .then((dir) => setMirrorParent((cur) => cur || dir.replace(/\/+$/, "")))
+      .catch(() => {});
+  }, []);
+
   useEffect(() => {
     if (kind !== "import" || !sourceDir) {
       setScaffoldPreview([]);
@@ -101,7 +272,7 @@ export function ProjectDialog({
     if (typeof picked === "string") {
       setSourceDir(picked);
       if (!name.trim()) {
-        setName(picked.split("/").filter(Boolean).pop() ?? "");
+        setName(basename(picked));
       }
     }
   };
@@ -113,14 +284,34 @@ export function ProjectDialog({
     }
   };
 
+  // Pick the LOCAL mirror parent for a remote (SSH) project (mirror of
+  // `chooseLocation`, but for the synced working copy rather than a local project).
+  const chooseLocalMirrorLocation = async () => {
+    const picked = await open({
+      directory: true,
+      multiple: false,
+      defaultPath: mirrorParent || projectsRoot || undefined,
+    });
+    if (typeof picked === "string") {
+      setMirrorParent(picked.replace(/\/+$/, ""));
+    }
+  };
+
   // Commit the currently-browsed remote folder. On import with an empty name,
   // default the name to the chosen folder's last segment.
   const useThisRemoteFolder = () => {
-    setRemoteChosenPath(remoteBrowsePath || "/");
+    const chosen = remoteBrowsePath || "/";
+    setRemoteChosenPath(chosen);
     if (kind === "import" && !name.trim()) {
-      const segs = (remoteBrowsePath || "").split("/").filter(Boolean);
+      const segs = chosen.split("/").filter(Boolean);
       if (segs.length) setName(segs[segs.length - 1]);
     }
+    // Persist the committed folder against this host now (not only at submit),
+    // so it's offered in the "Recently used…" lists for the next SSH project on
+    // the same remote — even if this dialog is later cancelled.
+    rememberChosenPath(chosen);
+    // Committing the folder is the natural end of the browse step.
+    setStep("details");
   };
 
   const selectedScaffoldAgentFills = () => {
@@ -190,31 +381,87 @@ export function ProjectDialog({
       // Remote scaffold filling runs over the local mount; for v1 we skip the
       // local-disk-only scaffold-fill agent tabs on import when remote.
       const scaffoldAgentFills =
-        kind === "import" && !isRemote && !skipScaffold
+        kind === "import" && !isRemoteProject && !skipScaffold
           ? selectedScaffoldAgentFills()
           : new Map<string, string[]>();
       const descriptionAgent = selectedDescriptionAgent();
       const remoteSpec = buildRemoteSpec(safeName);
+      // Clone first, then import the resulting directory in place: the clone owns
+      // getting the files onto the disk, `import_project` owns registering them.
+      // A failed clone throws here, so nothing is registered for a tree that
+      // isn't there.
+      let clonedDir = "";
+      if (isCloneImport) {
+        setCloning(true);
+        try {
+          clonedDir = isForkImport
+            ? // The fork is created first, then *it* is cloned — so the project
+              // ends up on a repository the user can push to, with the original
+              // wired as `upstream` by the backend.
+              (
+                await invoke<{ dir: string }>("git_fork_clone", {
+                  url: repoUrl.trim(),
+                  dest: targetDir,
+                  provider: forkProvider || null,
+                })
+              ).dir
+            : await invoke<string>("git_clone", {
+                url: repoUrl.trim(),
+                dest: targetDir,
+              });
+        } finally {
+          setCloning(false);
+        }
+      }
       const project =
         kind === "new"
           ? await invoke<ProjectEntry>("create_project", {
-              req: { name, directory: targetDir, description, gitType, remote: remoteSpec },
+              req: {
+                name,
+                directory: targetDir,
+                description,
+                gitType,
+                skipScaffold,
+                remote: remoteSpec,
+                // Remote only: chosen local mirror parent (ignored for local).
+                mirrorParent: isRemoteProject ? mirrorParent : undefined,
+              },
             })
           : await invoke<ProjectEntry>("import_project", {
               req: {
                 // Backend ignores sourceDir for remote but the field is required;
-                // pass the browsed remote path as a stand-in.
-                sourceDir: isRemote ? remoteChosenPath : sourceDir,
+                // pass the (browsed or typed) remote path as a stand-in. A clone
+                // registers the directory it just landed in.
+                sourceDir: isRemoteProject
+                  ? remoteChosenPath
+                  : isCloneImport
+                    ? clonedDir
+                    : sourceDir,
                 name,
                 description,
                 gitType,
-                mode: isRemote ? "keep" : mode,
+                mode: isRemoteProject || isCloneImport ? "keep" : mode,
                 scaffoldFillModes,
                 manualValidationConfirmed,
                 skipScaffold,
                 remote: remoteSpec,
+                // Remote only: chosen local mirror parent (ignored for local).
+                mirrorParent: isRemoteProject ? mirrorParent : undefined,
               },
             });
+      if (isRemoteProject) {
+        rememberChosenPath();
+        // The new project's pooled connect happens on activation, inside `onProject`
+        // below — hand it the credential this dialog authenticated with, so that leg
+        // doesn't have to ride the master we happen to have left up (and so a
+        // password host isn't recorded as key-auth). Single-use; not persisted —
+        // persisting is what the "Save password" toggle is for.
+        stashRemotePassword(project.id, remotePassword);
+        // A login the user typed into the embedded terminal leaves no password to
+        // stash, and in headless mode the mode alone doesn't say so — mark it, or the
+        // credential-less first connect is recorded as key auth on a password host.
+        if (remote.sshTerm) stashRemoteViaLogin(project.id);
+      }
       await onProject(project);
       await openScaffoldAgentTabs(project, scaffoldAgentFills);
       await openDescriptionAgentTab(project, descriptionAgent);
@@ -226,21 +473,37 @@ export function ProjectDialog({
     }
   };
 
-  const canSubmit = isRemoteProject
-    ? // Remote mode: must be connected and have a chosen remote folder.
-      !isRemote
-      ? false
+  const canSubmit =
+    // "Push to GitHub/GitLab" requires an Eldrun connection first — block submit
+    // until a token is saved (the notice above links to Settings → Git Hosting).
+    !needsGitConnection &&
+    // git must be installed before a git-backed project (or a clone import) is
+    // created — otherwise `git init`/`git clone` would silently fail underneath.
+    !needsGitInstall &&
+    // A fork is made by the provider's CLI, so it must be installed, and we must
+    // know *which* provider (a self-hosted host names neither).
+    !needsForkCliInstall &&
+    (!isForkImport || forkProviderResolved !== "") &&
+    (isRemoteProject
+      ? // Remote mode: ready (live session when headless, typed path otherwise)
+        // and has a remote folder.
+        !remoteReady
+        ? false
+        : kind === "new"
+          ? Boolean(name.trim() && safeName && remoteChosenPath && mirrorParent.trim())
+          : Boolean(name.trim() && remoteChosenPath && mirrorParent.trim())
       : kind === "new"
-        ? Boolean(name.trim() && safeName && remoteChosenPath)
-        : Boolean(name.trim() && remoteChosenPath)
-    : kind === "new"
-      ? Boolean(name.trim() && targetDir && safeName)
-      : Boolean(
-          name.trim() &&
-          sourceDir &&
-          (mode === "keep" || safeName) &&
-          (mode === "keep" || manualValidationConfirmed),
-        );
+        ? Boolean(name.trim() && targetDir && safeName)
+        : isCloneImport
+          ? // A clone needs a plausible URL and somewhere to land; it has no
+            // source folder and no copy/move decision to validate.
+            Boolean(name.trim() && safeName && targetDir && isCloneUrl(repoUrl))
+          : Boolean(
+              name.trim() &&
+              sourceDir &&
+              (mode === "keep" || safeName) &&
+              (mode === "keep" || manualValidationConfirmed),
+            ));
 
   const missingFillableScaffoldCount = scaffoldPreview.filter((item) => !item.exists && item.kind === "file").length;
 
@@ -259,20 +522,106 @@ export function ProjectDialog({
     return item.exists ? "Already there, will be kept" : "Missing, will be added";
   };
 
+  // The shared project name + description fields. They live in the always-visible
+  // remote-basics block for a remote project (so name/description are editable
+  // from the moment SSH is toggled on), and inside the details section for a local
+  // project. Extracted so the markup isn't duplicated between the two placements.
+  const nameField = (
+    <label>
+      {t("projectDialog.projectNameLabel")}
+      <input
+        // A clone starts at the URL field (which pre-fills this one), so the
+        // focus belongs there — two autoFocus inputs would fight over it.
+        autoFocus={!isCloneImport}
+        value={name}
+        placeholder="my-project"
+        onChange={(e) => setName(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && canSubmit && !busy) void submit();
+          if (e.key === "Escape") onClose();
+        }}
+      />
+    </label>
+  );
+
+  const descriptionField = (
+    <label className="project-description-field">
+      <div className="project-description-header">
+        <span>{t("projectDialog.descriptionLabel")}</span>
+        <Dropdown
+          title={t("projectDialog.descFillModeTitle")}
+          value={descriptionFillMode}
+          onChange={setDescriptionFillMode}
+          options={[
+            { value: "manual", label: t("projectDialog.fillModeManual") },
+            { value: "agent_choice", label: t("projectDialog.fillModeAgentChoice") },
+            { value: "claude", label: "Claude" },
+            { value: "codex", label: "Codex" },
+            { value: "gemini", label: "Gemini" },
+            { value: "vibe", label: "Mistral" },
+          ]}
+        />
+      </div>
+      <textarea
+        value={description}
+        placeholder={t("projectDialog.descriptionPlaceholder")}
+        rows={3}
+        onChange={(e) => setDescription(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Escape") onClose();
+        }}
+      />
+    </label>
+  );
+
   return (
     <div className="modal-backdrop" onMouseDown={onClose}>
-      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
-        <h2>{kind === "new" ? "New Project" : "Import Project"}</h2>
-
-        <label className="remote-project-toggle">
-          <input
-            type="checkbox"
-            checked={isRemoteProject}
-            onChange={(e) => toggleRemoteProject(e.target.checked)}
-          />
-          Remote (SSH) project
+      <div className="project-dialog dialog-framed" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{kind === "new" ? t("projectDialog.titleNew") : t("projectDialog.titleImport")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+
+        <label className={`toggle-card${isRemoteProject ? " is-on" : ""}`}>
+          <span className="toggle-card-body">
+            <span className="toggle-card-title">{t("projectDialog.remoteToggleTitle")}</span>
+            <span className="toggle-card-desc">
+              {t("projectDialog.remoteToggleDesc")}
+            </span>
+          </span>
+          <span className="eld-switch">
+            <input
+              type="checkbox"
+              checked={isRemoteProject}
+              onChange={(e) => toggleRemoteProject(e.target.checked)}
+            />
+            <span className="eld-switch-track" aria-hidden="true" />
+          </span>
         </label>
 
+        {/* Remote basics: a remote (SSH) project also needs a LOCAL location (its
+            synced mirror). Show it plus the shared name/description up front — from
+            the moment SSH is toggled on — while the remote location is chosen later
+            in the connect → browse flow below. The project name is shared: it's the
+            leaf of both `<local location>/<name>` and `<remote path>/<name>`. */}
+        {isRemoteProject && (
+          <>
+            <label>
+              {t("projectDialog.localLocationLabel")}
+              <div className="folder-picker-row">
+                <span title={mirrorParent}>{mirrorParent || t("projectDialog.noFolderSelected")}</span>
+                <button type="button" onClick={chooseLocalMirrorLocation}>{t("projectDialog.browseBtn")}</button>
+              </div>
+              <span className="ssh-optional-hint">
+                {t("projectDialog.localMirrorHint", { name: safeName || "<name>" })}
+              </span>
+            </label>
+            {nameField}
+            {descriptionField}
+          </>
+        )}
+
         <RemoteProjectSection
           kind={kind}
           safeName={safeName}
@@ -281,145 +630,259 @@ export function ProjectDialog({
           remote={remote}
         />
 
+        {showDetails && (
+        <>
         {kind === "import" && !isRemoteProject && (
           <label>
-            Source folder
+            {t("projectDialog.importFromLabel")}
+            <Dropdown
+              className="dropdown-block"
+              value={importSource}
+              onChange={(v) => changeImportSource(v as ImportSource)}
+              options={[
+                { value: "folder", label: t("projectDialog.importFolderOpt") },
+                { value: "git", label: t("projectDialog.importGitOpt") },
+                { value: "fork", label: t("projectDialog.importForkOpt") },
+              ]}
+            />
+          </label>
+        )}
+
+        {kind === "import" && !isRemoteProject && importSource === "folder" && (
+          <label>
+            {t("projectDialog.sourceFolderLabel")}
             <div className="folder-picker-row">
-              <span title={sourceDir}>{sourceDir || "No folder selected"}</span>
-              <button type="button" onClick={chooseFolder}>Browse...</button>
+              <span title={sourceDir}>{sourceDir || t("projectDialog.noFolderSelected")}</span>
+              <button type="button" onClick={chooseFolder}>{t("projectDialog.browseBtn")}</button>
             </div>
           </label>
         )}
 
-        {kind === "new" && !isRemoteProject && (
+        {isCloneImport && (
+          <label>
+            {isForkImport ? t("projectDialog.repoToForkLabel") : t("projectDialog.repoUrlLabel")}
+            <input
+              autoFocus
+              value={repoUrl}
+              placeholder="https://github.com/owner/repo.git"
+              onChange={(e) => setRepoUrlAndName(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && canSubmit && !busy) void submit();
+                if (e.key === "Escape") onClose();
+              }}
+            />
+            <span className="ssh-optional-hint">
+              {isForkImport ? (
+                <>
+                  {t("projectDialog.forkHintPre")}{" "}
+                  <code>upstream</code> {t("projectDialog.forkHintMid")}{forkCli?.bin ?? "gh / glab"}{t("projectDialog.forkHintPost")}{" "}
+                  <UntestedTag />
+                </>
+              ) : gitConnected ? (
+                t("projectDialog.cloneHintPrivateConnected")
+              ) : (
+                t("projectDialog.cloneHintPublicOnly")
+              )}
+            </span>
+          </label>
+        )}
+
+        {isForkImport && (
+          <label>
+            {t("projectDialog.hostTypeLabel")}
+            <Dropdown
+              className="dropdown-block"
+              value={forkProvider}
+              onChange={setForkProvider}
+              options={[
+                {
+                  value: "",
+                  label: forkProviderResolved
+                    ? t("projectDialog.detectFromUrlWithProvider", { provider: forkProviderResolved === "github" ? "GitHub" : "GitLab" })
+                    : t("projectDialog.detectFromUrl"),
+                },
+                { value: "github", label: "GitHub" },
+                { value: "gitlab", label: "GitLab" },
+              ]}
+            />
+            {!forkProviderResolved && (
+              <span className="ssh-optional-hint">
+                {t("projectDialog.hostTypeHint")}
+              </span>
+            )}
+          </label>
+        )}
+
+        {needsForkCliInstall && forkCli && (
+          <div className="tex-install-banner" role="status">
+            <span className="tex-install-banner-text">
+              {t("projectDialog.forkCliMissingPre")} <code>{forkCli.bin}</code> {t("projectDialog.forkCliMissingMid1")}{" "}
+              <code>{forkCli.bin} auth login</code>{t("projectDialog.forkCliMissingPost")}{" "}
+              {forkProviderResolved === "github" ? "GitHub" : "GitLab"}.
+            </span>
+            <code className="ollama-install-cmd">{forkCli.cmd}</code>
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              title={t("projectDialog.runInTerminalTitle")}
+              onClick={() =>
+                runInstallInTab(
+                  t("projectDialog.installBinLabel", { bin: forkCli.bin }),
+                  forkCli.cmd,
+                  IS_WINDOWS ? "default" : "bash",
+                )
+              }
+            >
+              {t("projectDialog.runInTerminalBtn")}
+            </button>
+          </div>
+        )}
+
+        {(kind === "new" || isCloneImport) && !isRemoteProject && (
           <label>
-            Location
+            {t("projectDialog.locationLabel")}
             <div className="folder-picker-row">
-              <span title={projectsRoot}>{projectsRoot || "No folder selected"}</span>
-              <button type="button" onClick={chooseLocation}>Browse...</button>
+              <span title={projectsRoot}>{projectsRoot || t("projectDialog.noFolderSelected")}</span>
+              <button type="button" onClick={chooseLocation}>{t("projectDialog.browseBtn")}</button>
             </div>
+            {isCloneImport && (
+              <span className="ssh-optional-hint">
+                {isForkImport ? t("projectDialog.cloneDestYourFork") : t("projectDialog.cloneDestTheRepo")} {t("projectDialog.cloneDestMid")}{" "}
+                {safeName || "<name>"} {t("projectDialog.cloneDestPost")}
+              </span>
+            )}
           </label>
         )}
 
+        {/* For a remote project these live in the always-visible remote-basics
+            block above; here they render only for a local project. */}
+        {!isRemoteProject && nameField}
+        {!isRemoteProject && descriptionField}
+
         <label>
-          Project name
-          <input
-            autoFocus
-            value={name}
-            placeholder="my-project"
-            onChange={(e) => setName(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === "Enter" && canSubmit && !busy) void submit();
-              if (e.key === "Escape") onClose();
-            }}
+          Git hosting
+          <Dropdown
+            className="dropdown-block"
+            value={gitType}
+            onChange={setGitType}
+            options={[
+              { value: "none", label: t("projectDialog.gitNoneOpt") },
+              { value: "local", label: t("projectDialog.gitLocalOpt") },
+              { value: "remote-private", label: t("projectDialog.gitRemotePrivateOpt") },
+              { value: "remote-public", label: t("projectDialog.gitRemotePublicOpt") },
+            ]}
           />
+          <span className="ssh-optional-hint">
+            {t("projectDialog.gitHostingHintPre")}
+            {isRemoteProject
+              ? ` ${t("projectDialog.gitHostingHintRemoteSuffix")}`
+              : "."}
+          </span>
         </label>
 
-        <label className="project-description-field">
-          <div className="project-description-header">
-            <span>Project description</span>
-            <select
-              aria-label="Project description fill mode"
-              value={descriptionFillMode}
-              onChange={(e) => setDescriptionFillMode(e.target.value)}
-            >
-              <option value="manual">Manual</option>
-              <option value="agent_choice">Agent choice</option>
-              <option value="claude">Claude</option>
-              <option value="codex">Codex</option>
-              <option value="gemini">Gemini</option>
-              <option value="vibe">Mistral</option>
-            </select>
+        {needsGitConnection && (
+          <div className="git-connect-notice" role="status">
+            <span>
+              {t("projectDialog.needsGitConnectionText")}
+            </span>
+            <button type="button" onClick={openGitHostingSettings}>
+              {t("projectDialog.setUpGitHostingBtn")}
+            </button>
           </div>
-          <textarea
-            value={description}
-            placeholder="What this project is for"
-            rows={3}
-            onChange={(e) => setDescription(e.target.value)}
-            onKeyDown={(e) => {
-              if (e.key === "Escape") onClose();
-            }}
-          />
-        </label>
+        )}
 
-        <label>
-          Git push target
-          <select value={gitType} onChange={(e) => setGitType(e.target.value)}>
-            <option value="local">Local only (no remote)</option>
-            <option value="remote-private">Remote · private</option>
-            <option value="remote-public">Remote · public</option>
-          </select>
-        </label>
+        {needsGitInstall && (
+          <div className="tex-install-banner" role="status">
+            <span className="tex-install-banner-text">
+              {t("projectDialog.needsGitInstallTextPre")}{isCloneImport ? t("projectDialog.needsGitInstallOrClone") : ""}.
+            </span>
+            <code className="ollama-install-cmd">{GIT_INSTALL_CMD}</code>
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              title={t("projectDialog.runInTerminalTitle")}
+              onClick={() =>
+                runInstallInTab(t("projectDialog.installGitLabel"), GIT_INSTALL_CMD, IS_WINDOWS ? "default" : "bash")
+              }
+            >
+              {t("projectDialog.runInTerminalBtn")}
+            </button>
+          </div>
+        )}
 
-        {kind === "import" && !isRemoteProject && (
+        {kind === "import" && !isRemoteProject && importSource === "folder" && (
           <label>
-            Import mode
-            <select value={mode} onChange={(e) => setMode(e.target.value)}>
-              <option value="keep">Keep location (register in place)</option>
-              <option value="copy">Copy to ~/eldrun/projects/</option>
-              <option value="move">Move to ~/eldrun/projects/</option>
-            </select>
+            {t("projectDialog.importModeLabel")}
+            <Dropdown
+              className="dropdown-block"
+              value={mode}
+              onChange={setMode}
+              options={[
+                { value: "keep", label: t("projectDialog.modeKeepOpt") },
+                { value: "copy", label: t("projectDialog.modeCopyOpt") },
+                { value: "move", label: t("projectDialog.modeMoveOpt") },
+              ]}
+            />
           </label>
         )}
 
         {kind === "import" && isRemoteProject && (
           <div className="project-dialog-path">
-            Remote import keeps the folder in place on the remote host.
+            {t("projectDialog.remoteImportKeepsFolder")}
           </div>
         )}
 
-        {kind === "import" && (
-          <label className="skip-scaffold-row">
-            <input
-              type="checkbox"
-              checked={skipScaffold}
-              onChange={(e) => setSkipScaffold(e.target.checked)}
-            />
-            Skip scaffolding (do not generate any scaffold files)
-          </label>
-        )}
+        <label className="skip-scaffold-row">
+          <Toggle
+            size="sm"
+            checked={skipScaffold}
+            onChange={(e) => setSkipScaffold(e.target.checked)}
+          />
+          {t("projectDialog.skipScaffoldLabel")}
+        </label>
 
-        {kind === "import" && !isRemoteProject && !skipScaffold && (
-          <div className="scaffold-popover" role="group" aria-label="Import scaffold guidance">
-            <div className="scaffold-popover-title">Import guidance</div>
+        {/* The scaffold preview reads the source folder off the disk, so it only
+            applies to a folder import — a clone's tree doesn't exist yet. Missing
+            scaffold files are still written after the clone (unless skipped);
+            they just can't be previewed or agent-filled from here. */}
+        {kind === "import" && !isRemoteProject && importSource === "folder" && !skipScaffold && (
+          <div className="scaffold-popover" role="group" aria-label={t("projectDialog.scaffoldGuidanceAria")}>
+            <div className="scaffold-popover-title">{t("projectDialog.importGuidanceTitle")}</div>
             <ol className="scaffold-steps">
-              <li>Select the source folder and project metadata.</li>
+              <li>{t("projectDialog.stepSelectSource")}</li>
               <li>
                 {mode === "keep"
-                  ? "Register the project in its current location."
+                  ? t("projectDialog.stepRegisterKeep")
                   : mode === "copy"
-                    ? "Copy the project to the Eldrun projects folder after manual validation."
-                    : "Move the project to the Eldrun projects folder after manual validation."}
+                    ? t("projectDialog.stepCopyValidate")
+                    : t("projectDialog.stepMoveValidate")}
               </li>
-              <li>Create missing scaffold files and acknowledge files already there.</li>
-              <li>Write project.json and add the project to the switcher.</li>
+              <li>{t("projectDialog.stepCreateScaffold")}</li>
+              <li>{t("projectDialog.stepWriteProjectJson")}</li>
             </ol>
 
             {mode !== "keep" && (
               <label className="manual-validation-row">
-                <input
-                  type="checkbox"
+                <Toggle
+                  size="sm"
                   checked={manualValidationConfirmed}
                   onChange={(e) => setManualValidationConfirmed(e.target.checked)}
                 />
-                I manually validated the {mode} destination and source folder.
+                {mode === "copy" ? t("projectDialog.manualValidationCopy") : t("projectDialog.manualValidationMove")}
               </label>
             )}
 
             <label className="scaffold-fill-all-row">
-              <span>Fill all</span>
-              <select
+              <span>{t("projectDialog.fillAllLabel")}</span>
+              <Dropdown
                 value=""
+                placeholder={missingFillableScaffoldCount === 0 ? t("projectDialog.noMissingFiles") : t("projectDialog.chooseFillMode")}
                 disabled={missingFillableScaffoldCount === 0}
-                onChange={(e) => applyScaffoldFillAll(e.target.value)}
-              >
-                <option value="" disabled>
-                  {missingFillableScaffoldCount === 0 ? "No missing files" : "Choose fill mode..."}
-                </option>
-                {SCAFFOLD_FILL_OPTIONS.map((option) => (
-                  <option value={option.value} key={option.value}>{option.label}</option>
-                ))}
-              </select>
+                onChange={(v) => {
+                  if (v) applyScaffoldFillAll(v);
+                }}
+                options={SCAFFOLD_FILL_OPTIONS}
+              />
             </label>
 
             <div className="scaffold-list">
@@ -430,25 +893,22 @@ export function ProjectDialog({
                     <small>{scaffoldStatusText(item)}</small>
                   </div>
                   {item.kind === "file" ? (
-                    <select
+                    <Dropdown
                       value={item.exists ? "none" : scaffoldFillModes[item.path] ?? "none"}
                       disabled={item.exists}
-                      onChange={(e) =>
-                        setScaffoldFillModes((current) => ({ ...current, [item.path]: e.target.value }))
+                      onChange={(v) =>
+                        setScaffoldFillModes((current) => ({ ...current, [item.path]: v }))
                       }
-                    >
-                      {SCAFFOLD_FILL_OPTIONS.map((option) => (
-                        <option value={option.value} key={option.value}>{option.label}</option>
-                      ))}
-                    </select>
+                      options={SCAFFOLD_FILL_OPTIONS}
+                    />
                   ) : (
-                    <span className="scaffold-row-status">Status only</span>
+                    <span className="scaffold-row-status">{t("projectDialog.statusOnly")}</span>
                   )}
                 </div>
               ))}
-              {!sourceDir && <div className="scaffold-empty">Choose a source folder to preview scaffold files.</div>}
+              {!sourceDir && <div className="scaffold-empty">{t("projectDialog.chooseSourceToPreview")}</div>}
               {sourceDir && !scaffoldPreview.length && !scaffoldError && (
-                <div className="scaffold-empty">Loading scaffold preview...</div>
+                <div className="scaffold-empty">{t("projectDialog.loadingScaffoldPreview")}</div>
               )}
               {scaffoldError && <div className="project-dialog-error">{scaffoldError}</div>}
             </div>
@@ -456,27 +916,76 @@ export function ProjectDialog({
         )}
 
         <div className="project-dialog-path">
-          {isRemote
-            ? remoteChosenPath
-              ? kind === "new"
-                ? `Remote destination: ${joinRemotePath(remoteChosenPath, safeName || "<name>")}`
-                : `Remote location: ${remoteChosenPath}`
-              : ""
-            : kind === "new" || mode !== "keep"
-              ? targetDir
-                ? `Destination: ${targetDir}`
-                : ""
-              : sourceDir
-                ? `Location: ${sourceDir}`
-                : ""}
+          {isRemoteProject ? (
+            remoteChosenPath ? (
+              <span className="remote-chosen-summary">
+                <span className="remote-chosen-text">
+                  {kind === "new"
+                    ? t("projectDialog.remoteDestinationLabel", { path: joinRemotePath(remoteChosenPath, safeName || "<name>") })
+                    : t("projectDialog.remoteLocationLabel", { path: remoteChosenPath })}
+                </span>
+                {/* Wrong folder committed at the browse step? Jump straight back
+                    to it (the browser keeps its place) to pick another — without
+                    hunting for the footer's generic Back button. Windows manual
+                    has no browse step, so Back lands on the connect path field. */}
+                <button
+                  type="button"
+                  className="remote-change-folder-btn"
+                  disabled={busy}
+                  onClick={goBack}
+                  title={
+                    winManual
+                      ? t("projectDialog.changeFolderTitleWinManual")
+                      : t("projectDialog.changeFolderTitleBrowse")
+                  }
+                >
+                  {t("projectDialog.changeFolderBtn")}
+                </button>
+              </span>
+            ) : (
+              ""
+            )
+          ) : kind === "new" || isCloneImport || mode !== "keep" ? (
+            targetDir ? t("projectDialog.destinationLabel", { path: targetDir }) : ""
+          ) : sourceDir ? (
+            t("projectDialog.locationColonLabel", { path: sourceDir })
+          ) : (
+            ""
+          )}
         </div>
         {error && <div className="project-dialog-error">{error}</div>}
+        </>
+        )}
 
         <div className="project-dialog-actions">
-          <button type="button" onClick={onClose}>Cancel</button>
-          <button type="button" disabled={!canSubmit || busy} onClick={() => void submit()}>
-            {busy ? "Working..." : kind === "new" ? "Create" : "Import"}
-          </button>
+          <button type="button" onClick={onClose}>{t("common.cancel")}</button>
+          {isRemoteProject && stepIdx > 0 && (
+            <button type="button" disabled={busy} onClick={goBack}>
+              {t("common.back")}
+            </button>
+          )}
+          {isRemoteProject && step !== "details" ? (
+            <button type="button" disabled={!canNext || busy} onClick={goNext}>
+              {t("common.next")}
+            </button>
+          ) : (
+            <button type="button" disabled={!canSubmit || busy} onClick={() => void submit()}>
+              {cloning
+                ? isForkImport
+                  ? t("projectDialog.forking")
+                  : t("projectDialog.cloningEllipsis")
+                : busy
+                  ? t("projectDialog.working")
+                  : kind === "new"
+                    ? t("projectDialog.create")
+                    : isForkImport
+                      ? t("projectDialog.forkAndImport")
+                      : isCloneImport
+                        ? t("projectDialog.cloneAndImport")
+                        : t("projectDialog.import")}
+            </button>
+          )}
+        </div>
         </div>
       </div>
     </div>
diff --git a/src/components/projects/ProjectHoverCard.tsx b/src/components/projects/ProjectHoverCard.tsx
new file mode 100644
index 0000000..7d4a573
--- /dev/null
+++ b/src/components/projects/ProjectHoverCard.tsx
@@ -0,0 +1,226 @@
+import { useCallback, useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import {
+  resolveProjectDirectory,
+  resolveLocalMirror,
+  formatRemoteTarget,
+  type ProjectEntry,
+} from "../../types";
+import { useTimerStore } from "../../stores/timer";
+import { useTabsStore } from "../../stores/tabs";
+import { projectTypeTags } from "./projectTypeTags";
+import { OrbitSpinner } from "../common/OrbitSpinner";
+import { useT, type TranslationKey } from "../../lib/i18n";
+
+type Translator = (key: TranslationKey, params?: Record<string, string | number>) => string;
+
+export function statusLabel(t: Translator, status: string): string {
+  if (status === "current") return t("projectHoverCard.statusCurrent");
+  if (status === "active") return t("projectHoverCard.statusActive");
+  return t("projectHoverCard.statusInactive");
+}
+
+export function formatTime(t: Translator, secs: number): string {
+  if (secs < 60) return t("projectHoverCard.timeUnderMinute");
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor((secs % 3600) / 60);
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+export function formatCpu(t: Translator, pct: number): string {
+  return pct < 0.1 ? t("projectHoverCard.cpuIdle") : `${pct.toFixed(1)}%`;
+}
+
+export function projectDescription(project: ProjectEntry): string {
+  return typeof project.description === "string" ? project.description.trim() : "";
+}
+
+/** Turn a raw `origin` URL into a compact, host-first address for display.
+ *  Handles HTTPS (`https://github.com/owner/repo.git`), scp-style SSH
+ *  (`git@github.com:owner/repo.git`) and `ssh://` forms → `github.com/owner/repo`.
+ *  Returns null when there's no URL to show. */
+export function formatGitRemote(url?: string): string | null {
+  if (!url) return null;
+  let s = url.trim();
+  if (!s) return null;
+  s = s.replace(/\.git$/i, ""); // drop trailing .git
+  s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//i, ""); // drop scheme (https://, ssh://)
+  s = s.replace(/^[^@/]+@/, ""); // drop user@ (scp + ssh forms)
+  s = s.replace(/:(?=[^/])/, "/"); // scp `host:owner` → `host/owner`
+  return s.replace(/\/+$/, "");
+}
+
+/** Live per-hover state for a project: the popup anchor position, today's tracked
+ *  time, CPU%, and the scaffold-missing flag. Shared by the pill and the right
+ *  file-viewer so both surface the identical hover card. `open`/`close` drive it
+ *  from the hovering element's bounding rect. */
+export function useProjectHoverCard(project: ProjectEntry | undefined) {
+  const projectId = project?.id;
+  const [popupPos, setPopupPos] = useState<{ x: number; y: number } | null>(null);
+  const [timeToday, setTimeToday] = useState<number | null>(null);
+  const [cpu, setCpu] = useState<number | null>(null);
+  // Resolved once per hover (cheap local-FS stat, no SFTP).
+  const [scaffoldMissing, setScaffoldMissing] = useState(false);
+  const timerPaused = useTimerStore((s) => s.paused);
+  const timerActiveId = useTimerStore((s) => s.activeProjectId);
+  const getProjectSecs = useTimerStore((s) => s.getProjectSecs);
+  const isLiveProject = !!projectId && timerActiveId === projectId;
+
+  // Live per-project CPU%: polled only while the hover popup is open. Keyed on
+  // the project's PTY ids (the backend resolves them to child PIDs + descendants).
+  const fetchCpu = useCallback(async () => {
+    if (!projectId) {
+      setCpu(null);
+      return;
+    }
+    const tabs = useTabsStore.getState().tabsByScope[projectId] ?? [];
+    const ptyIds = tabs.map((t) => t.key);
+    if (ptyIds.length === 0) {
+      setCpu(null);
+      return;
+    }
+    try {
+      setCpu(await invoke<number>("project_cpu_percent", { ptyIds }));
+    } catch {
+      setCpu(null);
+    }
+  }, [projectId]);
+
+  useEffect(() => {
+    if (!popupPos) return;
+    let cancelled = false;
+    const run = () => {
+      if (!cancelled) void fetchCpu();
+    };
+    run();
+    const id = window.setInterval(run, 1500);
+    return () => {
+      cancelled = true;
+      window.clearInterval(id);
+    };
+  }, [popupPos, fetchCpu]);
+
+  // Resolve the scaffold-missing flag when the hover opens (once — scaffold
+  // presence doesn't change under the cursor). Failures fall back to "present".
+  useEffect(() => {
+    if (!popupPos || !projectId) return;
+    let cancelled = false;
+    invoke<boolean>("project_scaffold_missing", { projectId })
+      .then((v) => {
+        if (!cancelled) setScaffoldMissing(v);
+      })
+      .catch(() => {
+        if (!cancelled) setScaffoldMissing(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [popupPos, projectId]);
+
+  const open = useCallback(
+    async (rect: DOMRect) => {
+      if (!projectId) return;
+      setPopupPos({ x: rect.left + rect.width / 2, y: rect.bottom });
+      try {
+        if (isLiveProject) {
+          setTimeToday(getProjectSecs());
+        } else {
+          setTimeToday(await invoke<number>("get_time_today", { projectId }));
+        }
+      } catch {
+        setTimeToday(null);
+      }
+    },
+    [isLiveProject, getProjectSecs, projectId],
+  );
+
+  const close = useCallback(() => {
+    setPopupPos(null);
+    setTimeToday(null);
+    setCpu(null);
+  }, []);
+
+  return { popupPos, timeToday, cpu, scaffoldMissing, isLiveProject, timerPaused, open, close };
+}
+
+export type ProjectHoverState = ReturnType<typeof useProjectHoverCard>;
+
+/** The hover popup shown for a project — description, type tags (optional),
+ *  paths, git address, status, today's time and CPU. Rendered into a portal at
+ *  `state.popupPos`; returns null while closed. `showTags` is off in the right
+ *  file-viewer, where the type tags already sit beside the project name. */
+export function ProjectHoverCard({
+  project,
+  state,
+  showTags = true,
+}: {
+  project: ProjectEntry;
+  state: ProjectHoverState;
+  showTags?: boolean;
+}) {
+  const t = useT();
+  const { popupPos, timeToday, cpu, scaffoldMissing, isLiveProject, timerPaused } = state;
+  if (!popupPos) return null;
+
+  const description = projectDescription(project);
+  const dir = resolveProjectDirectory(project);
+  const localMirror = resolveLocalMirror(project);
+  const gitRemote = formatGitRemote(project.git_origin_url);
+  const typeTags = showTags ? projectTypeTags(project, scaffoldMissing) : [];
+
+  return createPortal(
+    <div className="project-pill-popup" style={{ left: popupPos.x, top: popupPos.y }}>
+      {description && <span className="pill-popup-description">{description}</span>}
+      {typeTags.length > 0 && (
+        <span className="pill-popup-tags">
+          {typeTags.map((t) => (
+            <span
+              key={t.key}
+              className="pill-popup-tag"
+              title={t.title}
+              style={{ color: t.color, borderColor: t.color, background: `${t.color}22` }}
+            >
+              {t.label}
+            </span>
+          ))}
+        </span>
+      )}
+      {project.remote ? (
+        <>
+          <span className="pill-popup-path-row">
+            <span className="pill-popup-path-label">{t("projectHoverCard.remoteLabel")}</span>
+            <span className="pill-popup-path">{formatRemoteTarget(project.remote)}</span>
+          </span>
+          {localMirror && (
+            <span className="pill-popup-path-row">
+              <span className="pill-popup-path-label">{t("projectHoverCard.localLabel")}</span>
+              <span className="pill-popup-path">{localMirror}</span>
+            </span>
+          )}
+        </>
+      ) : (
+        dir && <span className="pill-popup-path">{dir}</span>
+      )}
+      {gitRemote && (
+        <span className="pill-popup-path-row">
+          <span className="pill-popup-path-label">{t("projectHoverCard.originLabel")}</span>
+          <span className="pill-popup-path">{gitRemote}</span>
+        </span>
+      )}
+      <span className={`pill-popup-status ${project.status === "inactive" ? "inactive" : "active"}`}>
+        {statusLabel(t, project.status)}
+      </span>
+      {timeToday !== null && (
+        <span className="pill-popup-time">
+          {t("projectHoverCard.todayPrefix")} {formatTime(t, timeToday)}
+          {isLiveProject && timerPaused && ` ${t("projectHoverCard.pausedSuffix")}`}
+          {isLiveProject && !timerPaused && <OrbitSpinner />}
+        </span>
+      )}
+      {cpu !== null && <span className="pill-popup-cpu">{t("projectHoverCard.cpuPrefix")} {formatCpu(t, cpu)}</span>}
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/projects/ProjectPill.tsx b/src/components/projects/ProjectPill.tsx
index 617dfa4..68c718e 100644
--- a/src/components/projects/ProjectPill.tsx
+++ b/src/components/projects/ProjectPill.tsx
@@ -1,13 +1,43 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { createPortal } from "react-dom";
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
 import { invoke } from "@tauri-apps/api/core";
-import { resolveProjectDirectory, type ProjectEntry } from "../../types";
+import { confirm, open } from "@tauri-apps/plugin-dialog";
+import {
+  resolveProjectDirectory,
+  type GitHostingInfo,
+  type GitProvider,
+  type ProjectEntry,
+  type PublishFrom,
+  type SandboxSpec,
+} from "../../types";
 import { useTimerStore } from "../../stores/timer";
-import { useActivityStore } from "../../stores/activity";
+import { useActivityStore, type TabStatusCounts } from "../../stores/activity";
 import { useProjectsStore } from "../../stores/projects";
-import { useTabsStore } from "../../stores/tabs";
+import { useSettingsStore } from "../../stores/settings";
+import { isResumableAgentTab, useTabsStore } from "../../stores/tabs";
+import { IS_WINDOWS } from "../../lib/platform";
+import { runInstallInTab, PROVIDER_CLI_INSTALL, providerAuthLoginCmd } from "../../lib/installCommand";
+import { PythonInterpreterWindow } from "./PythonInterpreterWindow";
+import { useGitDirtyStore, type GitDirtyState } from "../../stores/gitDirty";
+import { providerName, gitTypeLabel } from "./projectTypeTags";
+import { ProjectHoverCard, projectDescription, useProjectHoverCard } from "./ProjectHoverCard";
 import { ActivityCalendar } from "./ActivityCalendar";
-import { OrbitSpinner } from "../common/OrbitSpinner";
+import { CategoryEditor } from "./CategoryEditor";
+import { ExtendToRemoteDialog } from "./ExtendToRemoteDialog";
+import { autoConnectEligibility } from "./autoConnectEligibility";
+import { useSavedCredential } from "./useSavedCredential";
+import { isHpcHost, targetOfSpec } from "../../lib/hpcHost";
+import { useRemoteMachinesStore, type DroppedGlobalMachine } from "../../stores/remoteMachines";
+import { Dropdown } from "../common/Dropdown";
+import { PasswordInput } from "../common/PasswordInput";
+import { FolderPickerDialog } from "../common/FolderPickerDialog";
+import { RemoteConnMenu } from "../header/RemoteConnMenu";
+import { categoryColor, primaryCategoryColor, projectCategories } from "../../lib/categoryColor";
+import { usePillDragStore } from "../../stores/pillDrag";
+import { bindDragRelease, dragPlatform } from "../../lib/dragPlatform";
+import { useT, type TranslationKey } from "../../lib/i18n";
 
 interface Props {
   project: ProjectEntry;
@@ -17,72 +47,980 @@ interface Props {
   onReorder: (fromId: string, toId: string) => void;
   /** Alt-drop one pill onto another: box the two projects together. */
   onGroup?: (fromId: string, toId: string) => void;
-  /** Set when this pill is a member of a box (id of that box). */
-  boxId?: string;
-  /** Dragging the pill out of its box and releasing over empty space removes it. */
-  onLeaveBox?: (projectId: string) => void;
+  /** Drop onto a box pill: assign this project to that box instead of reordering. */
+  onAssignToBox?: (boxId: string) => void;
+  /** True while THIS pill is the one being pointer-dragged. ProjectSwitcher owns
+   *  the shared gesture state (`stores/pillDrag`) so every sibling can react to
+   *  one gesture without prop-drilling the raw drag object through each pill. */
+  isDragged?: boolean;
+  /** Live pointer-follow offset (px) while `isDragged`. */
+  dragDx?: number;
+  /** Parting offset (px) while a SIBLING pill is being dragged past this one —
+   *  the "nicely apart" slide that opens its landing slot. */
+  shiftPx?: number;
+  /** An Alt-drag is hovering THIS pill as a group (new-box) target. */
+  groupHintActive?: boolean;
 }
 
-export const PILL_DRAG_TYPE = "application/x-eldrun-project";
+/** File endings that mark a project as holding Python — the "Python interpreter…"
+ *  menu entry is offered only when one is present. Matched against
+ *  `list_project_endings` (lowercased). */
+const PYTHON_ENDINGS = new Set([".py", ".pyw", ".pyi"]);
 
-function statusLabel(status: string): string {
-  if (status === "current") return "Current";
-  if (status === "active") return "Active";
-  return "Inactive";
+/** Folder-icon title/color per git state — mirrors the file-tree markers'
+ *  priority (red ▸ orange ▸ green), plus a neutral "clean" default. */
+const GIT_ICON_TITLE_KEY: Record<GitDirtyState, TranslationKey> = {
+  clean: "pill.gitClean",
+  dirty: "pill.gitDirty",
+  staged: "pill.gitStaged",
+  unpushed: "pill.gitUnpushed",
+};
+
+/** Most status bars the pill will draw. A project with more busy tabs than this
+ *  would overflow a narrow pill, so the strip stops here and the tooltip carries
+ *  the true tally. */
+const MAX_STATUS_BARS = 6;
+
+/** The strip's bars, most urgent state first, one per tab. */
+function statusBarKinds(c: TabStatusCounts): string[] {
+  const kinds = [
+    ...Array<string>(c.working).fill("working"),
+    ...Array<string>(c.decision).fill("needs-decision"),
+    ...Array<string>(c.done).fill("finished"),
+  ];
+  return kinds.slice(0, MAX_STATUS_BARS);
+}
+
+/** Tooltip spelling out the tally the bars stand for (never truncated). */
+function statusBarTitle(c: TabStatusCounts, t: (key: TranslationKey, params?: Record<string, string | number>) => string): string {
+  const parts: string[] = [];
+  if (c.working) parts.push(t("pill.statusWorking", { count: c.working }));
+  if (c.decision) parts.push(t("pill.statusWaiting", { count: c.decision }));
+  if (c.done) parts.push(t("pill.statusFinished", { count: c.done }));
+  return parts.join(" · ");
 }
 
-function formatTime(secs: number): string {
-  if (secs < 60) return "< 1m";
-  const h = Math.floor(secs / 3600);
-  const m = Math.floor((secs % 3600) / 60);
-  if (h > 0) return `${h}h ${m}m`;
-  return `${m}m`;
+interface ContextMenuPos { x: number; y: number }
+
+function ActivityWindow({
+  project,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [data, setData] = useState<Record<string, number>>({});
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    setLoading(true);
+    invoke<Record<string, number>>("get_project_activity", { projectId: project.id })
+      .then(setData)
+      .catch(() => setData({}))
+      .finally(() => setLoading(false));
+  }, [project.id]);
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="activity-window"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="activity-window-header">
+          <span className="activity-window-title">{t("pill.activityTitle", { name: project.name })}</span>
+          <button className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="activity-window-body">
+          {loading ? (
+            <div className="activity-loading">{t("common.loading")}</div>
+          ) : (
+            <ActivityCalendar data={data} />
+          )}
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
 }
 
-function projectDescription(project: ProjectEntry): string {
-  return typeof project.description === "string" ? project.description.trim() : "";
+function EditDescriptionWindow({
+  project,
+  onSave,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onSave: (description: string) => Promise<void>;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [value, setValue] = useState(projectDescription(project));
+  const [saving, setSaving] = useState(false);
+
+  const save = async () => {
+    setSaving(true);
+    try {
+      await onSave(value);
+      onClose();
+    } catch {
+      setSaving(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="project-dialog edit-description-window"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{t("pill.descTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <textarea
+          value={value}
+          autoFocus
+          placeholder={t("pill.descPlaceholder")}
+          onChange={(e) => setValue(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) void save();
+            if (e.key === "Escape") onClose();
+          }}
+        />
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={saving}>{t("common.cancel")}</button>
+          <button type="button" onClick={() => void save()} disabled={saving}>
+            {saving ? t("common.saving") : t("common.save")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
 }
 
-function formatCpu(pct: number): string {
-  return pct < 0.1 ? "idle" : `${pct.toFixed(1)}%`;
+function RenameWindow({
+  project,
+  onSave,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onSave: (name: string) => Promise<void>;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [value, setValue] = useState(project.name);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState("");
+
+  const save = async () => {
+    if (!value.trim()) {
+      setError(t("pill.nameEmpty"));
+      return;
+    }
+    setSaving(true);
+    setError("");
+    try {
+      await onSave(value);
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setSaving(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="project-dialog edit-description-window"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>{t("pill.renameTitle")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <input
+          type="text"
+          value={value}
+          autoFocus
+          placeholder={t("pill.namePlaceholder")}
+          onChange={(e) => setValue(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") void save();
+            if (e.key === "Escape") onClose();
+          }}
+        />
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={saving}>{t("common.cancel")}</button>
+          <button type="button" onClick={() => void save()} disabled={saving}>
+            {saving ? t("common.saving") : t("common.save")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** Best-effort guess at the provider for a not-yet-published project: an
+ *  explicit prior provider wins, else sniff the profile URL host, else GitHub. */
+function guessProvider(project: ProjectEntry): GitProvider {
+  if (project.git_provider === "github" || project.git_provider === "gitlab") {
+    return project.git_provider;
+  }
+  if (project.git_profile_url?.toLowerCase().includes("gitlab")) return "gitlab";
+  return "github";
+}
+
+/** The provider's own "create a personal access token" page. Reads the host
+ *  off a configured profile URL so a self-hosted GitLab/GitHub Enterprise
+ *  instance gets its own token page rather than the public one. */
+function tokenPageUrl(provider: GitProvider, profileUrl: string): string {
+  let host = provider === "gitlab" ? "gitlab.com" : "github.com";
+  try {
+    const parsed = new URL(profileUrl);
+    if (parsed.host) host = parsed.host;
+  } catch {
+    // No usable profile URL yet — fall back to the public host.
+  }
+  return provider === "gitlab"
+    ? `https://${host}/-/user_settings/personal_access_tokens`
+    : `https://${host}/settings/tokens`;
+}
+
+function PublishWindow({
+  project,
+  onPublish,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onPublish: (
+    provider: GitProvider,
+    visibility: "public" | "private",
+    publishFrom: PublishFrom,
+  ) => Promise<string>;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [provider, setProvider] = useState<GitProvider>(() => guessProvider(project));
+  const [visibility, setVisibility] = useState<"public" | "private">(
+    project.git_type === "remote-public" ? "public" : "private",
+  );
+  // Which side runs the CLI. Defaults to this machine (for a remote project, its
+  // lockstep mirror): the provider login lives here, not on the work remote.
+  const [publishFrom, setPublishFrom] = useState<PublishFrom>("local");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const [result, setResult] = useState("");
+  const isRemoteWork = Boolean(project.remote);
+  // True when the CLI will run on this machine — always for a local project, and
+  // for a remote one unless the host was explicitly chosen.
+  const runsLocally = !isRemoteWork || publishFrom === "local";
+  // The CLI the chosen provider drives, surfaced in the command preview/help.
+  const cli = provider === "gitlab" ? "glab" : "gh";
+  const createPreview =
+    provider === "gitlab"
+      ? `glab repo create ${project.name} --${visibility} --remoteName origin && git push`
+      : `gh repo create ${project.name} --${visibility} --source=. --push`;
+  const cliInstall = PROVIDER_CLI_INSTALL[provider];
+  // Whether `cli` is on PATH here. Meaningful whenever the publish runs on this
+  // machine — which now includes a work-remote project publishing from its
+  // mirror. Only the explicit "work-remote host" choice runs somewhere this
+  // probe (a local `<cli> --version`) can't see. `null` while probing/unknown,
+  // so a pending answer never claims the CLI is missing.
+  const [cliAvailable, setCliAvailable] = useState<boolean | null>(null);
+  // The saved global token (⚙ Settings → Git hosting) — a project-specific
+  // override is possible too (`GitHostingWindow`) but rare enough that this
+  // approximation (skip the sign-in nudge when a token is set at all) is fine.
+  const gitToken = useSettingsStore((s) => s.settings?.git_token ?? "");
+
+  useEffect(() => {
+    if (!runsLocally) {
+      setCliAvailable(null);
+      return;
+    }
+    let cancelled = false;
+    setCliAvailable(null);
+    invoke<boolean>("provider_cli_available", { provider })
+      .then((ok) => !cancelled && setCliAvailable(ok))
+      .catch(() => !cancelled && setCliAvailable(false));
+    return () => {
+      cancelled = true;
+    };
+  }, [runsLocally, provider]);
+
+  const publish = async () => {
+    setBusy(true);
+    setError("");
+    try {
+      const output = await onPublish(provider, visibility, publishFrom);
+      setResult(output || t("pill.published"));
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.publishTitle", { name: project.name, provider: providerName(provider) })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="project-dialog-path">
+          {t("pill.currentPrefix")} {gitTypeLabel(project.git_type, project.git_provider)}
+          {isRemoteWork && !runsLocally && ` ${t("pill.runsOnWorkRemote")}`}
+        </div>
+        <label>
+          {t("pill.hostingProvider")}
+          <Dropdown
+            className="dropdown-block"
+            value={provider}
+            disabled={busy || Boolean(result)}
+            onChange={(v) => setProvider(v as GitProvider)}
+            options={[
+              { value: "github", label: "GitHub" },
+              { value: "gitlab", label: "GitLab" },
+            ]}
+          />
+        </label>
+        {/* A work-remote project has the same history on both sides, so which one
+            creates the repo is a real choice — and only this machine holds the
+            provider login, which is why it is the default. */}
+        {isRemoteWork && (
+          <label>
+            {t("pill.publishFrom")} <UntestedTag />
+            <Dropdown
+              className="dropdown-block"
+              value={publishFrom}
+              disabled={busy || Boolean(result)}
+              onChange={(v) => setPublishFrom(v as PublishFrom)}
+              options={[
+                { value: "local", label: t("pill.publishFromLocal") },
+                { value: "remote", label: t("pill.publishFromRemote") },
+              ]}
+            />
+          </label>
+        )}
+        <label>
+          {t("pill.repoVisibility")}
+          <Dropdown
+            className="dropdown-block"
+            value={visibility}
+            disabled={busy || Boolean(result)}
+            onChange={(v) => setVisibility(v as "public" | "private")}
+            options={[
+              { value: "private", label: t("pill.visPrivate") },
+              { value: "public", label: t("pill.visPublic") },
+            ]}
+          />
+        </label>
+        <div className="project-dialog-path">
+          {t("pill.publishRunsPre")} <code>{createPreview}</code>. {t("pill.publishRunsMid")} <code>{cli}</code>{" "}
+          {t("pill.publishRunsPost")}
+        </div>
+
+        {isRemoteWork && (
+          <div className="project-dialog-path">
+            {runsLocally
+              ? t("pill.publishFromLocalHint", { cli })
+              : t("pill.publishRemoteCliHint", { cli })}
+          </div>
+        )}
+
+        {!runsLocally ? null : cliAvailable === false ? (
+          <div className="tex-install-banner" role="status">
+            <span className="tex-install-banner-text">
+              {t("pill.publishCliMissingPre")} <code>{cliInstall.bin}</code>{" "}
+              {t("pill.publishCliMissingMid")} <code>{cliInstall.bin} auth login</code>
+              {t("pill.publishCliMissingPost")}
+            </span>
+            <code className="ollama-install-cmd">{cliInstall.cmd}</code>
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              title={t("projectDialog.runInTerminalTitle")}
+              onClick={() =>
+                runInstallInTab(
+                  t("projectDialog.installBinLabel", { bin: cliInstall.bin }),
+                  cliInstall.cmd,
+                  IS_WINDOWS ? "default" : "bash",
+                )
+              }
+            >
+              {t("projectDialog.runInTerminalBtn")}
+            </button>
+          </div>
+        ) : cliAvailable === true && !gitToken.trim() ? (
+          <div className="tex-install-banner" role="status">
+            <span className="tex-install-banner-text">{t("pill.publishSignInHint", { cli })}</span>
+            <button
+              type="button"
+              className="ollama-action-btn primary"
+              title={t("pill.publishSignInTitle", { cmd: providerAuthLoginCmd(provider) })}
+              onClick={() =>
+                runInstallInTab(
+                  t("pill.publishSignInBtn", { cli }),
+                  providerAuthLoginCmd(provider),
+                  IS_WINDOWS ? "default" : "bash",
+                )
+              }
+            >
+              {t("pill.publishSignInBtn", { cli })}
+            </button>
+          </div>
+        ) : null}
+
+        {error && <div className="project-dialog-error">{error}</div>}
+        {result && <div className="scaffold-empty">{result}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose}>{result ? t("common.close") : t("common.cancel")}</button>
+          {!result && (
+            <button type="button" disabled={busy} onClick={() => void publish()}>
+              {busy ? t("pill.publishing") : t("pill.publish")}
+            </button>
+          )}
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+function GitHostingWindow({
+  project,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const getProjectGitHosting = useProjectsStore((s) => s.getProjectGitHosting);
+  const setProjectGitHosting = useProjectsStore((s) => s.setProjectGitHosting);
+  const [info, setInfo] = useState<GitHostingInfo | null>(null);
+  const [profileUrl, setProfileUrl] = useState("");
+  const [newToken, setNewToken] = useState("");
+  const [clearToken, setClearToken] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let cancelled = false;
+    void getProjectGitHosting(project.id)
+      .then((i) => {
+        if (cancelled) return;
+        setInfo(i);
+        setProfileUrl(i.profile_url ?? "");
+      })
+      .catch((e) => !cancelled && setError(String(e)));
+    return () => {
+      cancelled = true;
+    };
+  }, [project.id, getProjectGitHosting]);
+
+  // A typed token always wins over a "remove" request, so clearing only applies
+  // when the user hasn't also entered a replacement.
+  const effectiveClear = clearToken && !newToken.trim();
+
+  const tokenStatus = (() => {
+    if (newToken.trim()) return t("pill.tokenStatusWillSet");
+    if (effectiveClear) return t("pill.tokenStatusWillRemove");
+    if (info?.has_token) return t("pill.tokenStatusHasToken");
+    if (info?.has_global_token) return t("pill.tokenStatusInherits");
+    return t("pill.tokenStatusNone");
+  })();
+
+  const save = async () => {
+    setSaving(true);
+    setError("");
+    try {
+      await setProjectGitHosting(project.id, {
+        profileUrl: profileUrl.trim() || null,
+        token: newToken.trim() || null,
+        clearToken: effectiveClear,
+      });
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setSaving(false);
+    }
+  };
+
+  const globalUrl = info?.global_profile_url ?? "";
+  // Which provider's token page to link to: the URL field being edited (live,
+  // so it updates as the user types) wins, else the field it inherits, else
+  // the project's own best guess.
+  const tokenProvider: GitProvider = (profileUrl || globalUrl).toLowerCase().includes("gitlab")
+    ? "gitlab"
+    : guessProvider(project);
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.gitHostingTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="project-dialog-path">{t("pill.gitHostingDesc")}</div>
+
+        <label>
+          {t("git.profileUrl")}
+          <input
+            type="text"
+            value={profileUrl}
+            placeholder={
+              globalUrl ? t("pill.inheritsGlobal", { url: globalUrl }) : t("git.profileUrlPlaceholder")
+            }
+            onChange={(e) => setProfileUrl(e.target.value)}
+          />
+        </label>
+
+        <label>
+          {info?.has_token ? t("pill.replaceToken") : t("git.accessToken")}
+          <PasswordInput
+            value={newToken}
+            placeholder={info?.has_token ? t("pill.enterNewToken") : t("git.tokenPlaceholder")}
+            onChange={(e) => {
+              setNewToken(e.target.value);
+              if (e.target.value) setClearToken(false);
+            }}
+          />
+        </label>
+        <span className="ssh-optional-hint">
+          {t("pill.getTokenHint")}{" "}
+          <button
+            type="button"
+            className="inline-link-btn"
+            onClick={() =>
+              void invoke("open_external_url", {
+                url: tokenPageUrl(tokenProvider, profileUrl || globalUrl),
+              })
+            }
+          >
+            {t("pill.getTokenCta", { provider: providerName(tokenProvider) })}
+          </button>
+        </span>
+        <div className="project-dialog-path">{tokenStatus}</div>
+        {info?.has_token && !newToken.trim() && (
+          <label className="settings-switch-row">
+            <span>{t("pill.removeProjectToken")}</span>
+            <Toggle
+              checked={clearToken}
+              onChange={(e) => setClearToken(e.target.checked)}
+            />
+          </label>
+        )}
+
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={saving}>{t("common.cancel")}</button>
+          <button type="button" onClick={() => void save()} disabled={saving || !info}>
+            {saving ? t("common.saving") : t("common.save")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+function DisableGitWindow({
+  project,
+  onConfirm,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onConfirm: () => Promise<void>;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [typed, setTyped] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  // Require the exact project name to arm the destructive button.
+  const armed = typed.trim() === project.name.trim() && !busy;
+
+  const run = async () => {
+    if (!armed) return;
+    setBusy(true);
+    setError("");
+    try {
+      await onConfirm();
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setBusy(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.disableGitTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="project-dialog-error">
+          {t("pill.disableGitWarn1")} <code>.git</code> {t("pill.disableGitWarn2")}{" "}
+          <strong>{t("pill.cannotBeUndone")}</strong>
+          {" "}{t("pill.disableGitWarn3")}
+        </div>
+        <label>
+          {t("pill.typeNameConfirmPre")} <code>{project.name}</code> {t("pill.typeNameConfirmPost")}
+          <input
+            type="text"
+            value={typed}
+            autoFocus
+            placeholder={project.name}
+            onChange={(e) => setTyped(e.target.value)}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") void run();
+              if (e.key === "Escape") onClose();
+            }}
+          />
+        </label>
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>{t("common.cancel")}</button>
+          <button
+            type="button"
+            className="danger"
+            onClick={() => void run()}
+            disabled={!armed}
+          >
+            {busy ? t("pill.removing") : t("pill.deleteGitHistory")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** Simple (reversible) confirm for deleting a project to the archive. Permanent
+ *  deletion lives behind a typed-confirm in Settings → Archived projects. */
+function ArchiveConfirmWindow({
+  project,
+  onConfirm,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onConfirm: () => Promise<void>;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  const run = async () => {
+    if (busy) return;
+    setBusy(true);
+    setError("");
+    try {
+      await onConfirm();
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setBusy(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.deleteProjectTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <p className="settings-help">
+          {t("pill.archiveDescPre")} <strong>{project.name}</strong> {t("pill.archiveDescMid")}{" "}
+          <em>{t("pill.archiveSettingsLink")}</em>.
+          {project.remote && (
+            <> {t("pill.archiveRemoteNotTouchedPre")} <strong>{t("pill.notWord")}</strong> {t("pill.archiveRemoteNotTouchedPost")}</>
+          )}
+        </p>
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>{t("common.cancel")}</button>
+          <button
+            type="button"
+            className="danger"
+            autoFocus
+            onClick={() => void run()}
+            disabled={busy}
+          >
+            {busy ? t("pill.deleting") : t("pill.deleteToArchive")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** Confirm for detaching a remote (SSH) project back to local. The host's files are never
+ *  touched — only the local mirror is promoted back in place.
+ *
+ *  Lives in the pill's **danger zone** despite destroying nothing on either side, because
+ *  what it drops is not a file but a *pairing*: `clear_host_bound_state` discards the
+ *  byte-sync manifest (every auto-sync marker the user set up for this host, and every
+ *  size/mtime base behind the file tree's green) along with the lockstep state. That purge
+ *  is mandatory — those records describe ONE host, and a project that keeps its id can be
+ *  re-extended to a different one — but it is not undoable, and re-attaching the very same
+ *  host means choosing the auto-sync scope again from scratch. Say so before, not after. */
+function DetachRemoteWindow({
+  project,
+  onConfirm,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onConfirm: () => Promise<void>;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  const run = async () => {
+    if (busy) return;
+    setBusy(true);
+    setError("");
+    try {
+      await onConfirm();
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setBusy(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.detachTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <p className="settings-help">
+          {t("pill.detachDesc1Pre")} <strong>{project.name}</strong> {t("pill.detachDesc1Mid")}
+          {" "}<strong>{t("pill.notWord")}</strong> {t("pill.detachDesc1Post")}
+        </p>
+        <p className="settings-help">
+          {t("pill.detachDesc2Pre")} <strong>{t("pill.pairingWord")}</strong>{t("pill.detachDesc2Post")}
+        </p>
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>{t("common.cancel")}</button>
+          <button type="button" autoFocus onClick={() => void run()} disabled={busy}>
+            {busy ? t("pill.detaching") : t("pill.detachToLocal")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** Simple confirm for unpublishing (forgetting the push target). Non-destructive:
+ *  the hosted repo and local history are both kept. */
+/**
+ * Edit a project's container spec — image/Dockerfile source, network, resource
+ * caps, read-only rootfs (#38). The knobs existed in `SandboxSpec` before but
+ * were hand-edit-only; the spec-preserving toggle is what makes exposing them
+ * safe. Saving only stores the spec: the container itself is replaced lazily —
+ * the spec fingerprint changes, so the next `up` (project activation or tab
+ * spawn) recreates it. The `enabled` flag is owned by the menu toggle and
+ * passed through unchanged.
+ */
+function ContainerSettingsWindow({
+  project,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const setProjectSandboxSpec = useProjectsStore((s) => s.setProjectSandboxSpec);
+  const spec = project.sandbox;
+  const [dockerfile, setDockerfile] = useState(spec?.dockerfile ?? "");
+  const [image, setImage] = useState(spec?.image ?? "");
+  const [network, setNetwork] = useState(spec?.network ?? "");
+  const [memory, setMemory] = useState(spec?.memory ?? "");
+  const [cpus, setCpus] = useState(spec?.cpus ?? "");
+  const [pids, setPids] = useState(spec?.pids_limit ? String(spec.pids_limit) : "");
+  const [readonly, setReadonly] = useState(spec?.readonly_rootfs ?? false);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  const save = async () => {
+    if (busy) return;
+    const pidsNum = pids.trim() ? Number(pids.trim()) : undefined;
+    if (pidsNum !== undefined && (!Number.isInteger(pidsNum) || pidsNum <= 0)) {
+      setError(t("pill.processLimitError"));
+      return;
+    }
+    setBusy(true);
+    setError("");
+    const next: SandboxSpec = {
+      enabled: spec?.enabled ?? false,
+      dockerfile: dockerfile.trim() || undefined,
+      image: image.trim() || undefined,
+      network: network.trim() || undefined,
+      memory: memory.trim() || undefined,
+      cpus: cpus.trim() || undefined,
+      pids_limit: pidsNum,
+      readonly_rootfs: readonly,
+    };
+    try {
+      await setProjectSandboxSpec(project.id, next);
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setBusy(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.containerSettingsTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <p className="settings-help">{t("pill.containerAppliedNote")}</p>
+        <label>
+          {t("pill.buildFromDockerfile")}
+          <input
+            type="text"
+            value={dockerfile}
+            placeholder={t("pill.dockerfilePlaceholder")}
+            onChange={(e) => setDockerfile(e.target.value)}
+            spellCheck={false}
+          />
+        </label>
+        <label>
+          {t("pill.image")}
+          <input
+            type="text"
+            value={image}
+            placeholder={t("pill.imagePlaceholder")}
+            onChange={(e) => setImage(e.target.value)}
+            spellCheck={false}
+            disabled={Boolean(dockerfile.trim())}
+          />
+        </label>
+        <label>
+          {t("pill.network")}
+          <input
+            type="text"
+            value={network}
+            placeholder={t("pill.networkPlaceholder")}
+            onChange={(e) => setNetwork(e.target.value)}
+            spellCheck={false}
+          />
+        </label>
+        <p className="settings-help">
+          {t("pill.networkNotePre")}
+          <code> none</code> {t("pill.networkNotePost")}
+        </p>
+        <label>
+          {t("pill.memoryCap")}
+          <input
+            type="text"
+            value={memory}
+            placeholder={t("pill.memoryPlaceholder")}
+            onChange={(e) => setMemory(e.target.value)}
+            spellCheck={false}
+          />
+        </label>
+        <label>
+          {t("pill.cpuCap")}
+          <input
+            type="text"
+            value={cpus}
+            placeholder={t("pill.cpuPlaceholder")}
+            onChange={(e) => setCpus(e.target.value)}
+            spellCheck={false}
+          />
+        </label>
+        <label>
+          {t("pill.processLimit")}
+          <input
+            type="text"
+            value={pids}
+            placeholder={t("pill.processLimitPlaceholder")}
+            onChange={(e) => setPids(e.target.value)}
+            spellCheck={false}
+          />
+        </label>
+        <label className="container-settings-toggle">
+          <span>{t("pill.readonlyRootfs")}</span>
+          <Toggle
+            checked={readonly}
+            onChange={(e) => setReadonly(e.target.checked)}
+            size="sm"
+          />
+        </label>
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>{t("common.cancel")}</button>
+          <button type="button" onClick={() => void save()} disabled={busy}>
+            {busy ? t("common.saving") : t("common.save")}
+          </button>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
 }
 
-interface ContextMenuPos { x: number; y: number }
-
-function ActivityWindow({
+function UnpublishWindow({
   project,
+  onConfirm,
   onClose,
 }: {
   project: ProjectEntry;
+  onConfirm: () => Promise<void>;
   onClose: () => void;
 }) {
-  const [data, setData] = useState<Record<string, number>>({});
-  const [loading, setLoading] = useState(true);
+  const t = useT();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
 
-  useEffect(() => {
-    setLoading(true);
-    invoke<Record<string, number>>("get_project_activity", { projectId: project.id })
-      .then(setData)
-      .catch(() => setData({}))
-      .finally(() => setLoading(false));
-  }, [project.id]);
+  const run = async () => {
+    if (busy) return;
+    setBusy(true);
+    setError("");
+    try {
+      await onConfirm();
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setBusy(false);
+    }
+  };
 
   return createPortal(
     <div className="modal-backdrop" onMouseDown={onClose}>
-      <div
-        className="activity-window"
-        onMouseDown={(e) => e.stopPropagation()}
-      >
-        <div className="activity-window-header">
-          <span className="activity-window-title">{project.name} — Activity</span>
-          <button className="dialog-close-btn" onClick={onClose}>×</button>
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("pill.unpublishTitle", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
         </div>
-        <div className="activity-window-body">
-          {loading ? (
-            <div className="activity-loading">Loading…</div>
-          ) : (
-            <ActivityCalendar data={data} />
-          )}
+        <p className="settings-help">
+          {t("pill.unpublishDesc1")} <code>origin</code> {t("pill.unpublishDesc2")}
+          {" "}{providerName(project.git_provider)} {t("pill.unpublishDesc3")} <strong>{t("pill.notWord")}</strong>{" "}
+          {t("pill.unpublishDesc4")}
+        </p>
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>{t("common.cancel")}</button>
+          <button type="button" autoFocus onClick={() => void run()} disabled={busy}>
+            {busy ? t("pill.unpublishing") : t("pill.unpublishKeepRepo")}
+          </button>
         </div>
       </div>
     </div>,
@@ -90,53 +1028,63 @@ function ActivityWindow({
   );
 }
 
-function EditDescriptionWindow({
+/** Flip a published project's visibility (public ↔ private) in place. */
+function VisibilityWindow({
   project,
-  onSave,
+  onApply,
   onClose,
 }: {
   project: ProjectEntry;
-  onSave: (description: string) => Promise<void>;
+  onApply: (visibility: "public" | "private") => Promise<string>;
   onClose: () => void;
 }) {
-  const [value, setValue] = useState(projectDescription(project));
-  const [saving, setSaving] = useState(false);
+  const t = useT();
+  const current: "public" | "private" =
+    project.git_type === "remote-public" ? "public" : "private";
+  const target: "public" | "private" = current === "public" ? "private" : "public";
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+  const [result, setResult] = useState("");
+  const isRemoteWork = Boolean(project.remote);
+  const cli = project.git_provider === "gitlab" ? "glab" : "gh";
 
-  const save = async () => {
-    setSaving(true);
+  const apply = async () => {
+    setBusy(true);
+    setError("");
     try {
-      await onSave(value);
-      onClose();
-    } catch {
-      setSaving(false);
+      const out = await onApply(target);
+      setResult(out || t("pill.nowVisibility", { target: t(target === "public" ? "pill.visPublic" : "pill.visPrivate") }));
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setBusy(false);
     }
   };
 
   return createPortal(
     <div className="modal-backdrop" onMouseDown={onClose}>
-      <div
-        className="project-dialog edit-description-window"
-        onMouseDown={(e) => e.stopPropagation()}
-      >
+      <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
         <div className="settings-title-row">
-          <h2>{project.name} — Description</h2>
+          <h2>{t("pill.changeVisibilityTitle", { name: project.name })}</h2>
           <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
         </div>
-        <textarea
-          value={value}
-          autoFocus
-          placeholder="Short description for this project…"
-          onChange={(e) => setValue(e.target.value)}
-          onKeyDown={(e) => {
-            if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) void save();
-            if (e.key === "Escape") onClose();
-          }}
-        />
+        <div className="project-dialog-path">
+          {t("pill.currentPrefix")} {providerName(project.git_provider)} · {t(current === "public" ? "pill.visPublic" : "pill.visPrivate")}
+          {isRemoteWork && ` ${t("pill.runsOnWorkRemote")}`}
+        </div>
+        <p className="settings-help">
+          {t("pill.flipVisibility1")} <strong>{t(current === "public" ? "pill.visPublic" : "pill.visPrivate")}</strong> {t("pill.flipVisibility2")}{" "}
+          <strong>{t(target === "public" ? "pill.visPublic" : "pill.visPrivate")}</strong> {t("pill.flipVisibility3")} <code>{cli} repo edit</code>. {t("pill.flipVisibility4")}
+        </p>
+        {error && <div className="project-dialog-error">{error}</div>}
+        {result && <div className="scaffold-empty">{result}</div>}
         <div className="project-dialog-actions">
-          <button type="button" onClick={onClose} disabled={saving}>Cancel</button>
-          <button type="button" onClick={() => void save()} disabled={saving}>
-            {saving ? "Saving…" : "Save"}
-          </button>
+          <button type="button" onClick={onClose}>{result ? t("common.close") : t("common.cancel")}</button>
+          {!result && (
+            <button type="button" disabled={busy} onClick={() => void apply()}>
+              {busy ? t("pill.applying") : t("pill.makeVisibility", { target: t(target === "public" ? "pill.visPublic" : "pill.visPrivate") })}
+            </button>
+          )}
         </div>
       </div>
     </div>,
@@ -144,40 +1092,43 @@ function EditDescriptionWindow({
   );
 }
 
-function gitTypeLabel(gitType: unknown): string {
-  switch (gitType) {
-    case "remote-public":
-      return "Remote · public";
-    case "remote-private":
-      return "Remote · private";
-    default:
-      return "Local only (no remote)";
-  }
-}
-
-function PublishWindow({
+/** Migrate a published project to the other hosting provider (old repo kept). */
+function MigrateProviderWindow({
   project,
-  onPublish,
+  onMigrate,
   onClose,
 }: {
   project: ProjectEntry;
-  onPublish: (visibility: "public" | "private") => Promise<string>;
+  onMigrate: (
+    provider: GitProvider,
+    visibility: "public" | "private",
+    publishFrom: PublishFrom,
+  ) => Promise<string>;
   onClose: () => void;
 }) {
+  const t = useT();
+  const currentProvider: GitProvider = project.git_provider === "gitlab" ? "gitlab" : "github";
+  const [provider, setProvider] = useState<GitProvider>(
+    currentProvider === "github" ? "gitlab" : "github",
+  );
   const [visibility, setVisibility] = useState<"public" | "private">(
     project.git_type === "remote-public" ? "public" : "private",
   );
+  // A migration ends in a publish, so it takes the same side choice (the old
+  // origin is always moved aside wherever it actually is).
+  const [publishFrom, setPublishFrom] = useState<PublishFrom>("local");
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState("");
   const [result, setResult] = useState("");
   const isRemoteWork = Boolean(project.remote);
+  const runsLocally = !isRemoteWork || publishFrom === "local";
 
-  const publish = async () => {
+  const migrate = async () => {
     setBusy(true);
     setError("");
     try {
-      const output = await onPublish(visibility);
-      setResult(output || "Published.");
+      const out = await onMigrate(provider, visibility, publishFrom);
+      setResult(out || t("pill.migrated"));
     } catch (err) {
       setError(String(err));
     } finally {
@@ -189,35 +1140,67 @@ function PublishWindow({
     <div className="modal-backdrop" onMouseDown={onClose}>
       <div className="project-dialog" onMouseDown={(e) => e.stopPropagation()}>
         <div className="settings-title-row">
-          <h2>{project.name} — Publish to GitHub</h2>
+          <h2>{t("pill.moveToProviderTitle", { name: project.name })}</h2>
           <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
         </div>
         <div className="project-dialog-path">
-          Current: {gitTypeLabel(project.git_type)}
-          {isRemoteWork && " · runs on the work-remote host"}
+          {t("pill.currentPrefix")} {gitTypeLabel(project.git_type, project.git_provider)}
+          {isRemoteWork && !runsLocally && ` ${t("pill.runsOnWorkRemote")}`}
         </div>
         <label>
-          Repository visibility
-          <select
+          {t("pill.newProvider")}
+          <Dropdown
+            className="dropdown-block"
+            value={provider}
+            disabled={busy || Boolean(result)}
+            onChange={(v) => setProvider(v as GitProvider)}
+            options={[
+              { value: "github", label: "GitHub" },
+              { value: "gitlab", label: "GitLab" },
+            ]}
+          />
+        </label>
+        {isRemoteWork && (
+          <label>
+            {t("pill.publishFrom")} <UntestedTag />
+            <Dropdown
+              className="dropdown-block"
+              value={publishFrom}
+              disabled={busy || Boolean(result)}
+              onChange={(v) => setPublishFrom(v as PublishFrom)}
+              options={[
+                { value: "local", label: t("pill.publishFromLocal") },
+                { value: "remote", label: t("pill.publishFromRemote") },
+              ]}
+            />
+          </label>
+        )}
+        <label>
+          {t("pill.repoVisibility")}
+          <Dropdown
+            className="dropdown-block"
             value={visibility}
             disabled={busy || Boolean(result)}
-            onChange={(e) => setVisibility(e.target.value as "public" | "private")}
-          >
-            <option value="private">private</option>
-            <option value="public">public</option>
-          </select>
+            onChange={(v) => setVisibility(v as "public" | "private")}
+            options={[
+              { value: "private", label: t("pill.visPrivate") },
+              { value: "public", label: t("pill.visPublic") },
+            ]}
+          />
         </label>
-        <div className="project-dialog-path">
-          Runs <code>gh repo create {project.name} --{visibility} --source=. --push</code>.
-          Requires <code>gh</code> installed and authenticated.
-        </div>
+        <p className="settings-help">
+          {t("pill.migrateDesc1")} {providerName(provider)}{t("pill.migrateDesc2")}{" "}
+          <code>origin</code>{t("pill.migrateDesc3")}{" "}
+          {providerName(project.git_provider)} {t("pill.migrateDesc4")}{" "}
+          <strong>{t("pill.leftIntact")}</strong> {t("pill.migrateDesc5")} <code>origin-old</code>{t("pill.migrateDesc6")}
+        </p>
         {error && <div className="project-dialog-error">{error}</div>}
         {result && <div className="scaffold-empty">{result}</div>}
         <div className="project-dialog-actions">
-          <button type="button" onClick={onClose}>{result ? "Close" : "Cancel"}</button>
+          <button type="button" onClick={onClose}>{result ? t("common.close") : t("common.cancel")}</button>
           {!result && (
-            <button type="button" disabled={busy} onClick={() => void publish()}>
-              {busy ? "Publishing…" : "Publish"}
+            <button type="button" disabled={busy} onClick={() => void migrate()}>
+              {busy ? t("pill.migrating") : t("pill.moveToProvider", { provider: providerName(provider) })}
             </button>
           )}
         </div>
@@ -227,55 +1210,251 @@ function PublishWindow({
   );
 }
 
-export function ProjectPill({ project, active, onClick, onClose, onReorder, onGroup, boxId, onLeaveBox }: Props) {
-  const [popupPos, setPopupPos] = useState<{ x: number; y: number } | null>(null);
-  const [timeToday, setTimeToday] = useState<number | null>(null);
-  const [cpu, setCpu] = useState<number | null>(null);
+export function ProjectPill({
+  project,
+  active,
+  onClick,
+  onClose,
+  onReorder,
+  onGroup,
+  onAssignToBox,
+  isDragged,
+  dragDx,
+  shiftPx,
+  groupHintActive,
+}: Props) {
+  const t = useT();
+  // Shared hover card (identical popup in the right file-viewer). Owns the
+  // popup position, today's time, CPU% and the scaffold-missing flag.
+  const hover = useProjectHoverCard(project);
   const [contextMenu, setContextMenu] = useState<ContextMenuPos | null>(null);
+  // With `connections_headless` off Eldrun handles no passwords at all, so neither
+  // key auth nor a saved password can ever be the answer — auto-connect there means
+  // the login opens in the root terminal instead (see `autoConnectInteractive` in
+  // stores/projects). One of the inputs to `autoConnectEligibility` below; the
+  // saved-password half is `useSavedCredential`, read only while this menu is open.
+  const connHeadless = useSettingsStore((s) => s.settings?.connections_headless ?? true);
   const [showActivity, setShowActivity] = useState(false);
   const [editDescription, setEditDescription] = useState(false);
+  const [renaming, setRenaming] = useState(false);
   const [showPublish, setShowPublish] = useState(false);
-  const [dragOver, setDragOver] = useState(false);
-  // True while an Alt-drag hovers this pill: the drop will box the two
-  // projects together rather than reorder. Drives the distinct hover affordance.
-  const [groupHint, setGroupHint] = useState(false);
-  const [dragging, setDragging] = useState(false);
+  const [showGitHosting, setShowGitHosting] = useState(false);
+  const [showDisableGit, setShowDisableGit] = useState(false);
+  const [showDetach, setShowDetach] = useState(false);
+  const [showUnpublish, setShowUnpublish] = useState(false);
+  const [showVisibility, setShowVisibility] = useState(false);
+  const [showMigrate, setShowMigrate] = useState(false);
+  const [showArchive, setShowArchive] = useState(false);
+  const [editCategories, setEditCategories] = useState(false);
+  const [extendRemote, setExtendRemote] = useState(false);
+  // Set instead of `extendRemote` alone when a global machine was handed to this
+  // (local-only) project from the header's Machines menu — seeds the "Extend to
+  // remote" dialog's SSH address with that machine, so the pick becomes "make
+  // this the project's primary".
+  const [extendRemoteMachine, setExtendRemoteMachine] = useState<DroppedGlobalMachine | null>(
+    null,
+  );
+  // When set, the in-app "Move project…" folder browser is open, seeded at this
+  // parent directory. `null` = closed.
+  const [movePickerInitial, setMovePickerInitial] = useState<string | null>(null);
   const pillRef = useRef<HTMLDivElement>(null);
   const dir = resolveProjectDirectory(project);
-  const description = projectDescription(project);
+  const categories = projectCategories(project);
+  const catColor = primaryCategoryColor(categories);
 
   const timerPaused = useTimerStore((s) => s.paused);
-  const timerActiveId = useTimerStore((s) => s.activeProjectId);
-  const getProjectSecs = useTimerStore((s) => s.getProjectSecs);
-  const isLiveProject = timerActiveId === project.id;
-  const busy = useActivityStore((s) => s.busyByScope[project.id] ?? false);
+  // One little bar per non-idle tab along the bottom edge of the pill, so a
+  // glance at the switcher says how many tabs of each project are working
+  // (green, pulsing), waiting on a decision (orange, pulsing) or finished unseen
+  // (green, steady). This replaced a whole-pill tint that could only ever show
+  // one state and said nothing about how many tabs were in it.
+  // The SELECTED project keeps its bars: the strip is a tally of what the project
+  // is doing, not a list of what still needs a glance, and the project you are in
+  // is the one whose agents you most need to see running. Only "finished unseen"
+  // is inherently about unread output, and it can't arise for a tab on screen.
+  const statusCounts = useActivityStore((s) => s.statusCountsByScope[project.id]);
+  const gitDirty = useGitDirtyStore((s) => s.byId[project.id]);
   const updateProjectDescription = useProjectsStore((s) => s.updateProjectDescription);
-  const publishProject = useProjectsStore((s) => s.publishProject);
+  const renameProject = useProjectsStore((s) => s.renameProject);
+  const moveRemoteMirror = useProjectsStore((s) => s.moveRemoteMirror);
+  const setProjectSandbox = useProjectsStore((s) => s.setProjectSandbox);
+  const [showContainerSettings, setShowContainerSettings] = useState(false);
+  const openRemoteMachines = useRemoteMachinesStore((s) => s.open);
+  // A global machine picked for THIS (local) project in the header's Machines
+  // menu: that menu can't own the extend dialog, so it parks the request here
+  // and the target's pill opens it. Cleared on pickup so it fires once.
+  const extendTarget = useRemoteMachinesStore((s) => s.extendTarget);
+  const clearExtend = useRemoteMachinesStore((s) => s.clearExtend);
+  useEffect(() => {
+    if (extendTarget?.projectId !== project.id) return;
+    setExtendRemoteMachine(extendTarget.machine);
+    setExtendRemote(true);
+    clearExtend();
+  }, [extendTarget, project.id, clearExtend]);
+  const [showPythonSettings, setShowPythonSettings] = useState(false);
+  // Whether this project actually contains Python files — the interpreter/venv
+  // setting is only worth offering then. Probed lazily when the context menu
+  // opens (see handleContextMenu), like the saved-password lookup, so no pill
+  // scans on render. `null` = not yet probed. A remote project's `directory` is
+  // its local state dir, not the host tree, so the local ending scan can't see
+  // its files: offer the setting for any remote project rather than hide it
+  // wrongly (the dialog probes the host for that project anyway).
+  const [hasPythonFiles, setHasPythonFiles] = useState<boolean | null>(null);
+  const showPython = project.remote ? true : hasPythonFiles === true;
 
-  // Live per-project CPU%: polled only while the hover popup is open. Keyed on
-  // the project's PTY ids (the backend resolves them to child PIDs + descendants).
-  const fetchCpu = useCallback(async () => {
+  // Flip the project-container toggle. The flag is in every TerminalView's
+  // spawn deps, so flipping respawns each live tab of this project —
+  // Claude/Codex resume across the respawn, but a live NON-resumable agent
+  // (Gemini/Vibe/…) would lose its conversation: confirm before destroying it
+  // (the same hazard class tabs/agentModes.ts exists for). On enable, run the
+  // docker preflight right away so a missing image becomes a one-click build
+  // running in a fresh terminal tab (house convention — never a
+  // copy-it-yourself message) instead of an error at the next tab spawn.
+  const toggleContainer = useCallback(async () => {
+    const enabling = !project.sandbox?.enabled;
     const tabs = useTabsStore.getState().tabsByScope[project.id] ?? [];
-    const ptyIds = tabs.map((t) => t.key);
-    if (ptyIds.length === 0) {
-      setCpu(null);
-      return;
+    const doomed = tabs.filter((t) => t.kind === "agent" && !isResumableAgentTab(t));
+    if (doomed.length > 0) {
+      const names = [...new Set(doomed.map((t) => t.cmd))].join(", ");
+      const ok = await confirm(
+        `Turning the container ${enabling ? "on" : "off"} restarts every tab of this project. ` +
+          `${doomed.length} agent tab${doomed.length > 1 ? "s" : ""} (${names}) cannot resume ` +
+          `and will lose the conversation. Continue?`,
+        { title: "Restart this project's tabs?", kind: "warning" },
+      );
+      if (!ok) return;
     }
+    await setProjectSandbox(project.id, enabling);
+    if (!enabling) return;
     try {
-      setCpu(await invoke<number>("project_cpu_percent", { ptyIds }));
+      const pf = await invoke<{ status: string; image: string; build_command: string | null }>(
+        "sandbox_preflight",
+        { projectId: project.id },
+      );
+      if (pf.status === "image_missing" && pf.build_command) {
+        runInstallInTab(`container image ${pf.image}`, pf.build_command, "bash");
+      } else if (pf.status === "daemon_down") {
+        useProjectsStore.setState({
+          switchToast: "Docker isn't running — start it before opening tabs in this project",
+        });
+      } else if (pf.status === "no_docker") {
+        useProjectsStore.setState({
+          switchToast: "Docker isn't installed — the container toggle needs it",
+        });
+      }
     } catch {
-      setCpu(null);
+      // Preflight is advisory; a real problem still surfaces in the next tab spawn.
     }
-  }, [project.id]);
+  }, [project.id, project.sandbox?.enabled, setProjectSandbox]);
 
-  useEffect(() => {
-    if (!popupPos) return;
-    let cancelled = false;
-    const run = () => { if (!cancelled) void fetchCpu(); };
-    run();
-    const id = window.setInterval(run, 1500);
-    return () => { cancelled = true; window.clearInterval(id); };
-  }, [popupPos, fetchCpu]);
+  const setProjectAutoConnect = useProjectsStore((s) => s.setProjectAutoConnect);
+  const setProjectPersistSessions = useProjectsStore((s) => s.setProjectPersistSessions);
+  // Auto-connect is only offered when the connect can complete with no *modal*: a
+  // key/agent-auth host (recorded by the backend on its last successful connect) or
+  // a password in the keychain (looked up when the menu opens) — or, in non-headless
+  // mode, always: there is no keychain to qualify against there, and the connect is
+  // by definition a login waiting in the root terminal. Same substitution the
+  // header's "Connect on launch" makes for a tunnel (`VpnIndicator`).
+  //
+  // One shared formula now (`autoConnectEligibility`), which also brings the **HPC
+  // tag** here: `stores/projects` refuses to dial a tagged host unattended, so this
+  // item was tickable and guaranteed to do nothing — the Machines menu has said so
+  // all along, this one didn't.
+  const remoteTarget = targetOfSpec(project.remote);
+  const remoteIsHpc = useSettingsStore((s) => isHpcHost(s.settings, remoteTarget));
+  const sshCredential = useSavedCredential(remoteTarget, {
+    enabled: contextMenu !== null && project.remote?.key_auth !== true,
+  });
+  const autoConnectState = autoConnectEligibility({
+    headless: connHeadless,
+    keyAuth: project.remote?.key_auth === true,
+    savedPassword: sshCredential.saved,
+    hpc: remoteIsHpc,
+  });
+  const autoConnectEligible = autoConnectState.eligible;
+  const setProjectGitDisabled = useProjectsStore((s) => s.setProjectGitDisabled);
+  const repairProjectScaffold = useProjectsStore((s) => s.repairProjectScaffold);
+  const publishProject = useProjectsStore((s) => s.publishProject);
+  const detachProjectFromRemote = useProjectsStore((s) => s.detachProjectFromRemote);
+  const unpublishProject = useProjectsStore((s) => s.unpublishProject);
+  const setProjectVisibility = useProjectsStore((s) => s.setProjectVisibility);
+  const switchProjectProvider = useProjectsStore((s) => s.switchProjectProvider);
+  const archiveProject = useProjectsStore((s) => s.archiveProject);
+
+  // Reveal the project on disk. Local projects open their working directory; a
+  // remote (SSH) project has no local tree, so we open its local mirror — the
+  // paired connected working copy. If that mirror folder was deleted, let the
+  // user freely pick a new location (defaulting to an ssh/<name> subfolder of the
+  // projects root), which the backend re-creates and persists.
+  const revealOnDisk = useCallback(async () => {
+    try {
+      let path: string | undefined = dir;
+      if (project.remote) {
+        const status = await invoke<{ path: string; exists: boolean; suggested: string }>(
+          "remote_mirror_status",
+          { projectId: project.id, name: project.name },
+        );
+        path = status.path;
+        if (!status.exists) {
+          const chosen = await open({
+            directory: true,
+            defaultPath: status.suggested,
+            title: `${project.name} — choose a local mirror folder`,
+          });
+          if (typeof chosen !== "string") return; // cancelled
+          path = await invoke<string>("set_remote_mirror_dir", {
+            projectId: project.id,
+            path: chosen,
+          });
+        }
+      }
+      if (!path) return;
+      await invoke("open_in_file_manager", { path });
+    } catch (e) {
+      console.error("show on disk", e);
+    }
+  }, [project.remote, project.id, project.name, dir]);
+
+  // Relocate a remote project's local mirror folder. Opens the in-app folder
+  // browser (not the OS chooser) seeded at the current mirror's parent; the user
+  // browses to a *parent* directory and the backend moves the mirror (and its
+  // bytes) to `<parent>/<name>`, re-pointing the pointer. The confirm handler
+  // (below, on the dialog) runs the move.
+  const moveMirror = useCallback(async () => {
+    if (!project.remote) return;
+    try {
+      const status = await invoke<{ path: string; exists: boolean; suggested: string }>(
+        "remote_mirror_status",
+        { projectId: project.id, name: project.name },
+      );
+      const parentOf = (p: string): string => {
+        const trimmed = p.replace(/[/\\]+$/, "");
+        const idx = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+        return idx > 0 ? trimmed.slice(0, idx) : trimmed;
+      };
+      setMovePickerInitial(parentOf(status.exists ? status.path : status.suggested));
+    } catch (e) {
+      console.error("move mirror", e);
+      // Fall back to opening the picker at the home default (empty path).
+      setMovePickerInitial("");
+    }
+  }, [project.remote, project.id, project.name]);
+
+  // Confirm handler for the in-app move picker: relocate the mirror into the
+  // chosen parent, patch in-memory state (moveRemoteMirror), and close.
+  const confirmMove = useCallback(
+    async (parent: string, name?: string) => {
+      setMovePickerInitial(null);
+      try {
+        // The chosen name defines the new local mirror folder (backend
+        // sanitizes it); fall back to the display name when left blank.
+        await moveRemoteMirror(project.id, name?.trim() || project.name, parent);
+      } catch (e) {
+        console.error("move mirror", e);
+      }
+    },
+    [project.id, project.name, moveRemoteMirror],
+  );
 
   // Close context menu on outside click
   useEffect(() => {
@@ -285,60 +1464,203 @@ export function ProjectPill({ project, active, onClick, onClose, onReorder, onGr
     return () => window.removeEventListener("pointerdown", dismiss);
   }, [contextMenu]);
 
-  const handleMouseEnter = async () => {
+  const handleMouseEnter = () => {
     if (contextMenu) return;
     if (!pillRef.current) return;
-    const r = pillRef.current.getBoundingClientRect();
-    setPopupPos({ x: r.left + r.width / 2, y: r.bottom });
-    try {
-      if (isLiveProject) {
-        setTimeToday(getProjectSecs());
+    void hover.open(pillRef.current.getBoundingClientRect());
+  };
+
+  const handleContextMenu = (e: React.MouseEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    hover.close();
+    // The saved-password lookup that used to sit here is now `useSavedCredential`
+    // above, gated on this very menu being open — same "only when asked" cost, but
+    // it can report an *unreadable* keychain instead of an empty one.
+    // Does this project hold any Python files? Gates the "Python interpreter…"
+    // entry below. A cheap local ending scan (already the file tree's "hide these
+    // endings" source), skipped for remote projects whose files live on the host
+    // (showPython shows those regardless — see hasPythonFiles).
+    if (!project.remote) {
+      const dir = resolveProjectDirectory(project);
+      if (dir) {
+        void invoke<string[]>("list_project_endings", { projectDir: dir })
+          .then((endings) =>
+            setHasPythonFiles(
+              endings.some((e) => PYTHON_ENDINGS.has(e.toLowerCase())),
+            ),
+          )
+          .catch(() => setHasPythonFiles(false));
       } else {
-        const secs = await invoke<number>("get_time_today", { projectId: project.id });
-        setTimeToday(secs);
+        setHasPythonFiles(false);
       }
-    } catch {
-      setTimeToday(null);
     }
+    // Anchor to the pill's bottom-left corner so the menu opens downward, below
+    // the bar, with its left edge flush to the pill's left border.
+    const rect = pillRef.current?.getBoundingClientRect();
+    setContextMenu({
+      x: rect ? rect.left : e.clientX,
+      y: rect ? rect.bottom : e.clientY,
+    });
   };
 
-  const handleContextMenu = (e: React.MouseEvent) => {
+  /**
+   * Pointer-driven drag: reorder / Alt-group / drop-on-box, replacing native
+   * HTML5 DnD (the same move TabBar/YamlTree/MachinesIndicator already made —
+   * a native drag out of a webview gesture can hang or drop mid-drag under
+   * WebKitGTK). The whole pill is the drag catchment, exactly as `draggable`
+   * used to be, EXCEPT the close button and the remote-connection lamps, which
+   * stay their own plain controls.
+   *
+   * Sibling rects are measured ONCE, at the moment the drag threshold is
+   * crossed — the DOM order is frozen for the gesture (only `transform`
+   * changes, via `shiftPx`/`groupHintActive`/BoxPill's forced hover, all read
+   * from `usePillDragStore` by ProjectSwitcher), so the rects stay valid for
+   * its whole duration. `onClick` is never wired natively on `pill-main` for
+   * the mouse path — `e.preventDefault()` below suppresses the compatibility
+   * click a plain press+release would otherwise fire, and a genuine (non-drag)
+   * release calls it here instead; a keyboard Enter/Space still reaches
+   * `pill-main`'s own onClick untouched, since it never goes through a pointer
+   * event at all.
+   */
+  const startPillDrag = (e: React.PointerEvent) => {
+    if (e.button !== 0) return;
+    const pressed = e.target as HTMLElement;
+    if (pressed.closest(".pill-close-btn, .header-conn-lamps")) return;
     e.preventDefault();
-    e.stopPropagation();
-    setPopupPos(null);
-    // Anchor to the bottom of the pill so the menu opens downward, below the bar
-    const y = pillRef.current
-      ? pillRef.current.getBoundingClientRect().bottom
-      : e.clientY;
-    setContextMenu({ x: e.clientX, y });
+    const startX = e.clientX;
+    const pointerId = e.pointerId;
+    const captureEl = document.documentElement;
+    let dragging = false;
+    let projectRects: { id: string; left: number; width: number }[] = [];
+    let boxRects: { id: string; left: number; top: number; right: number; bottom: number }[] = [];
+    // This pill's index among the OTHER (frozen) rects — i.e. how many of them
+    // sat to its left at drag-start. `onReorder(fromId, toId)` always lands the
+    // dragged pill immediately BEFORE toId when toId was originally to its
+    // left, and immediately AFTER when toId was to its right (see the commit
+    // math below) — so which of those two rules applies, and hence which
+    // neighbor to target, depends on this frozen index.
+    let fromIdx = 0;
+
+    const dropSlot = (clientX: number) =>
+      projectRects.filter((r) => clientX > r.left + r.width / 2).length;
+
+    const onMove = (ev: PointerEvent) => {
+      if (!dragging) {
+        if (Math.abs(ev.clientX - startX) < 5) return;
+        dragging = true;
+        hover.close();
+        const container = pillRef.current?.closest(".project-pills-scroll");
+        const selfRect = pillRef.current?.getBoundingClientRect();
+        const width = selfRect?.width ?? 0;
+        const selfLeft = selfRect?.left ?? 0;
+        projectRects = container
+          ? Array.from(container.querySelectorAll<HTMLElement>("[data-pill-id]"))
+              .filter((el) => el.dataset.pillId !== project.id)
+              .map((el) => {
+                const r = el.getBoundingClientRect();
+                return { id: el.dataset.pillId!, left: r.left, width: r.width };
+              })
+          : [];
+        fromIdx = projectRects.filter((r) => r.left < selfLeft).length;
+        boxRects = container
+          ? Array.from(container.querySelectorAll<HTMLElement>("[data-box-id]")).map((el) => {
+              const r = el.getBoundingClientRect();
+              return {
+                id: el.dataset.boxId!,
+                left: r.left,
+                top: r.top,
+                right: r.right,
+                bottom: r.bottom,
+              };
+            })
+          : [];
+        if (dragPlatform.needsPointerCapture) {
+          try {
+            captureEl.setPointerCapture(pointerId);
+          } catch {
+            /* best-effort */
+          }
+        }
+        usePillDragStore.getState().start(project.id, width, dropSlot(ev.clientX));
+      }
+      const overBoxId =
+        boxRects.find(
+          (r) =>
+            ev.clientX >= r.left &&
+            ev.clientX <= r.right &&
+            ev.clientY >= r.top &&
+            ev.clientY <= r.bottom,
+        )?.id ?? null;
+      // Alt-group targets whichever pill's own rect (not just its midpoint) the
+      // cursor sits over — matches the old alt-drop-onto-a-pill gesture.
+      const groupTargetId =
+        !overBoxId && ev.altKey
+          ? (projectRects.find((r) => ev.clientX >= r.left && ev.clientX <= r.left + r.width)
+              ?.id ?? null)
+          : null;
+      usePillDragStore.getState().move(ev.clientX - startX);
+      usePillDragStore.getState().setTarget({
+        overIndex: dropSlot(ev.clientX),
+        overBoxId,
+        groupTargetId,
+      });
+    };
+
+    const cleanup = () => {
+      window.removeEventListener("pointermove", onMove);
+      if (dragPlatform.needsPointerCapture) {
+        try {
+          captureEl.releasePointerCapture(pointerId);
+        } catch {
+          /* ignore */
+        }
+      }
+    };
+
+    const finish = (commit: boolean) => {
+      cleanup();
+      const drag = usePillDragStore.getState().drag;
+      usePillDragStore.getState().end();
+      if (!dragging) {
+        // Never dragged → this was a click (pill-main's own onClick already
+        // covers the keyboard path; this covers the mouse one, since its
+        // native click was suppressed above).
+        if (commit) onClick();
+        return;
+      }
+      if (!commit || !drag) return;
+      if (drag.overBoxId) {
+        onAssignToBox?.(drag.overBoxId);
+      } else if (drag.groupTargetId && onGroup) {
+        onGroup(project.id, drag.groupTargetId);
+      } else {
+        // Resolve the landing slot (`overIndex`, an index into the OTHER
+        // pills without this one) back to a `toId` for `onReorder`. This is
+        // NOT simply `projectRects[overIndex]`: `reorderProjects` always
+        // drops the dragged pill immediately BEFORE toId when toId sat to its
+        // left at drag-start, and immediately AFTER it when toId sat to its
+        // right — landing "before OTHERS[k]" therefore means targeting
+        // OTHERS[k] itself when k is on the left (< fromIdx), but targeting
+        // OTHERS[k-1] (and relying on the "after" rule) when k is on the
+        // right (> fromIdx). Using OTHERS[k] unconditionally landed the pill
+        // one slot further right than its shown gap whenever the drop was on
+        // the right side of the original position.
+        const k = Math.max(0, Math.min(drag.overIndex, projectRects.length));
+        if (k === fromIdx) return; // already there — no real move
+        const toId = k < fromIdx ? projectRects[k]?.id : projectRects[k - 1]?.id;
+        if (toId) onReorder(project.id, toId);
+      }
+    };
+
+    window.addEventListener("pointermove", onMove);
+    bindDragRelease({ onCommit: () => finish(true), onAbort: () => finish(false) });
   };
 
   return (
     <>
-      {/* Hover popup — hidden while context menu is open */}
-      {popupPos && !contextMenu && createPortal(
-        <div
-          className="project-pill-popup"
-          style={{ left: popupPos.x, top: popupPos.y }}
-        >
-          {description && <span className="pill-popup-description">{description}</span>}
-          {dir && <span className="pill-popup-path">{dir}</span>}
-          <span className={`pill-popup-status ${project.status === "inactive" ? "inactive" : "active"}`}>
-            {statusLabel(project.status)}
-          </span>
-          {timeToday !== null && (
-            <span className="pill-popup-time">
-              Today: {formatTime(timeToday)}
-              {isLiveProject && timerPaused && " (paused)"}
-              {isLiveProject && !timerPaused && <OrbitSpinner />}
-            </span>
-          )}
-          {cpu !== null && (
-            <span className="pill-popup-cpu">CPU: {formatCpu(cpu)}</span>
-          )}
-        </div>,
-        document.body,
-      )}
+      {/* Hover popup — hidden while context menu is open (which calls hover.close). */}
+      {!contextMenu && <ProjectHoverCard project={project} state={hover} />}
 
       {/* Right-click context menu */}
       {contextMenu && createPortal(
@@ -347,49 +1669,347 @@ export function ProjectPill({ project, active, onClick, onClose, onReorder, onGr
           style={{ left: contextMenu.x, top: contextMenu.y }}
           onPointerDown={(e) => e.stopPropagation()}
         >
-          <button
-            onClick={() => {
-              setContextMenu(null);
-              setShowActivity(true);
-            }}
-          >
-            Show Activity
-          </button>
-          <button
-            onClick={() => {
-              setContextMenu(null);
-              setEditDescription(true);
-            }}
-          >
-            Edit description
-          </button>
-          <button
-            onClick={() => {
-              setContextMenu(null);
-              setShowPublish(true);
-            }}
-          >
-            Publish to GitHub…
-          </button>
-          <button
-            onClick={() => {
-              setContextMenu(null);
-              // Clear this project's tabs in memory. For the ACTIVE project the
-              // debounced saveLayout effect persists the empty layout; for a
-              // non-active project nothing else writes it, so persist explicitly.
-              useTabsStore.getState().closeAllTabs(project.id);
-              if (project.local_file) {
-                void invoke("save_tab_layout", {
-                  localFile: project.local_file,
-                  tabs: [],
-                  groups: null,
-                  sessions: [],
-                }).catch(() => {});
-              }
-            }}
-          >
-            Close all tabs
-          </button>
+          {/* View / inspect */}
+          <div className="context-menu-group">
+            <div className="context-menu-group-label">{t("pill.viewGroup")}</div>
+            <button
+              onClick={() => {
+                setContextMenu(null);
+                setShowActivity(true);
+              }}
+            >
+              {t("pill.showActivity")}
+            </button>
+            <button
+              onClick={() => {
+                setContextMenu(null);
+                void revealOnDisk();
+              }}
+              title={t(project.remote ? "pill.showOnDiskRemoteTitle" : "pill.showOnDiskLocalTitle")}
+            >
+              {t("pill.showOnDisk")}
+            </button>
+          </div>
+
+          {/* Edit metadata */}
+          <div className="context-menu-group">
+            <div className="context-menu-group-label">{t("pill.editGroup")}</div>
+            <button
+              onClick={() => {
+                setContextMenu(null);
+                setRenaming(true);
+              }}
+            >
+              {t("pill.renameEllipsis")}
+            </button>
+            {project.remote && (
+              <button
+                className="untested"
+                onClick={() => {
+                  setContextMenu(null);
+                  void moveMirror();
+                }}
+                title={t("pill.movePillTitle")}
+              >
+                {t("pill.moveProjectEllipsis")}
+                <UntestedTag />
+              </button>
+            )}
+            <button
+              onClick={() => {
+                setContextMenu(null);
+                setEditDescription(true);
+              }}
+            >
+              {t("pill.editDescription")}
+            </button>
+            <button
+              className="untested"
+              onClick={() => {
+                setContextMenu(null);
+                setEditCategories(true);
+              }}
+              title={t("pill.categoriesMenuTitle")}
+            >
+              {t("blob.categoriesEllipsis")}
+              <UntestedTag />
+            </button>
+            <button
+              className="untested"
+              onClick={() => {
+                setContextMenu(null);
+                void repairProjectScaffold(project.id);
+              }}
+              title={t("pill.repairScaffoldTitle")}
+            >
+              {t("pill.repairScaffold")}
+              <UntestedTag />
+            </button>
+            {!project.remote && (
+              <button
+                onClick={() => {
+                  setContextMenu(null);
+                  setExtendRemoteMachine(null);
+                  setExtendRemote(true);
+                }}
+                title={t("pill.extendToRemoteMenuTitle")}
+              >
+                {t("pill.extendToRemoteEllipsis")}
+              </button>
+            )}
+          </div>
+
+          {/* Git */}
+          <div className="context-menu-group">
+            <div className="context-menu-group-label">{t("pill.gitGroup")}</div>
+            {project.git_type === "none" ? (
+              !project.remote && (
+                <button
+                  className="untested"
+                  onClick={() => {
+                    setContextMenu(null);
+                    void setProjectGitDisabled(project.id, false);
+                  }}
+                  title={t("pill.gitInitTitle")}
+                >
+                  {t("pill.enableGit")}
+                  <UntestedTag />
+                </button>
+              )
+            ) : typeof project.git_type === "string" && project.git_type.startsWith("remote") ? (
+              // Already published — offer in-place management, not another publish.
+              <>
+                <button
+                  className="untested"
+                  onClick={() => {
+                    setContextMenu(null);
+                    setShowVisibility(true);
+                  }}
+                  title={t("pill.makePrivateTitle")}
+                >
+                  {project.git_type === "remote-public" ? t("pill.makePrivate") : t("pill.makePublic")}
+                  <UntestedTag />
+                </button>
+                <button
+                  className="untested"
+                  onClick={() => {
+                    setContextMenu(null);
+                    setShowMigrate(true);
+                  }}
+                  title={t("pill.moveProviderMenuTitle")}
+                >
+                  {project.git_provider === "gitlab" ? t("pill.moveToGithub") : t("pill.moveToGitlab")}
+                  <UntestedTag />
+                </button>
+                <button
+                  className="untested"
+                  onClick={() => {
+                    setContextMenu(null);
+                    setShowUnpublish(true);
+                  }}
+                  title={t("pill.unpublishMenuTitle")}
+                >
+                  {t("pill.unpublishKeepRepoEllipsis")}
+                  <UntestedTag />
+                </button>
+                <button
+                  className="untested"
+                  onClick={() => {
+                    setContextMenu(null);
+                    setShowGitHosting(true);
+                  }}
+                  title={t("pill.gitHostingMenuTitle")}
+                >
+                  {t("pill.gitHostingEllipsis")}
+                  <UntestedTag />
+                </button>
+              </>
+            ) : (
+              // Local git repo, not yet pushed anywhere.
+              <button
+                className="untested"
+                onClick={() => {
+                  setContextMenu(null);
+                  setShowPublish(true);
+                }}
+              >
+                {t("pill.publishEllipsis")}
+                <UntestedTag />
+              </button>
+            )}
+          </div>
+
+          {/* Runtime */}
+          <div className="context-menu-group">
+            <div className="context-menu-group-label">{t("pill.runtimeGroup")}</div>
+            {/* Project container (#38): local projects only (a remote project's
+                tabs already run on its host), hidden on Windows (the backend
+                refuses — host paths mean nothing inside a Linux container). */}
+            {!project.remote && !IS_WINDOWS && (
+              <>
+                <button
+                  onClick={() => {
+                    setContextMenu(null);
+                    void toggleContainer();
+                  }}
+                  title={t("pill.containerRunTitle")}
+                >
+                  {project.sandbox?.enabled ? "✓ " : ""}{t("pill.runInContainer")}
+                </button>
+                <button
+                  onClick={() => {
+                    setContextMenu(null);
+                    setShowContainerSettings(true);
+                  }}
+                  title={t("pill.containerSettingsMenuTitle")}
+                >
+                  {t("pill.containerSettingsEllipsis")}
+                </button>
+              </>
+            )}
+            {showPython && (
+              <button
+                onClick={() => {
+                  setContextMenu(null);
+                  setShowPythonSettings(true);
+                }}
+                title={t("pill.pythonInterpMenuTitle")}
+              >
+                {project.python_interpreter ? "✓ " : ""}{t("pill.pythonInterpreterEllipsis")}
+              </button>
+            )}
+            {project.remote && (
+              <button
+                disabled={!autoConnectEligible}
+                onClick={() => {
+                  setContextMenu(null);
+                  void setProjectAutoConnect(project.id, !project.remote?.auto_connect);
+                }}
+                title={t(
+                  autoConnectState.reason === "hpc"
+                    ? "autoConnect.hpcTitle"
+                    : !connHeadless
+                      ? "pill.autoConnectTitleNonHeadless"
+                      : autoConnectEligible
+                        ? "pill.autoConnectTitleEligible"
+                        : "pill.autoConnectTitleNotEligible"
+                )}
+              >
+                {project.remote.auto_connect && autoConnectEligible ? "✓ " : ""}
+                {t("pill.autoConnectOnLaunch")}
+                {/* Named, not just greyed: a tagged host is never dialled by Eldrun
+                    itself, and the remedy (untag the machine) is nothing like the
+                    other one (save a password). Matches the Machines menu. */}
+                {autoConnectState.reason === "hpc" && (
+                  <span className="machines-auto-blocked"> {t("autoConnect.offWhileHpc")}</span>
+                )}
+              </button>
+            )}
+            {/* Persistent remote sessions (TODO #85): shell/script tabs run inside a
+                tmux session on the host, so a long run survives an SSH drop, a
+                laptop sleep, or Eldrun quitting. Default ON — this opts out. */}
+            {project.remote && (
+              <button
+                onClick={() => {
+                  setContextMenu(null);
+                  void setProjectPersistSessions(
+                    project.id,
+                    project.remote?.persist_sessions === false,
+                  );
+                }}
+                title={t("pill.persistSessionsMenuTitle")}
+              >
+                {project.remote.persist_sessions !== false ? "✓ " : ""}{t("pill.persistentSessionsTmux")}
+              </button>
+            )}
+            {/* Multi-host remote (docs/multi_host_remote_plan.md): manage the extra
+                "worker" machines this project runs experiments on. Remote only. */}
+            {project.remote && (
+              <button
+                className="untested"
+                onClick={() => {
+                  setContextMenu(null);
+                  openRemoteMachines(project.id);
+                }}
+                title={t("pill.remoteMachinesMenuTitle")}
+              >
+                {project.compute_hosts?.length
+                  ? t("pill.remoteMachinesCount", { count: project.compute_hosts.length })
+                  : t("pill.remoteMachinesEllipsis")}
+                <UntestedTag />
+              </button>
+            )}
+            <button
+              onClick={() => {
+                setContextMenu(null);
+                const tabsStore = useTabsStore.getState();
+                // Tear down every detached popout for this project first: each
+                // one kills its tabs' PTYs and closes its OS window (in-window
+                // closeAllTabs below never touches detached groups).
+                for (const g of tabsStore.detachedGroupsByScope[project.id] ?? []) {
+                  tabsStore.closeDetachedGroup(project.id, g.id);
+                }
+                // Clear this project's in-window tabs. For the ACTIVE project the
+                // debounced persist effect writes the empty layout; for a non-active
+                // project nothing else writes it, so persist explicitly.
+                tabsStore.closeAllTabs(project.id);
+                if (project.local_file) {
+                  void invoke("save_tab_layout", {
+                    localFile: project.local_file,
+                    tabs: [],
+                    groups: null,
+                    sessions: [],
+                    // This is THE close-all: the one empty save that is meant, by a user
+                    // who clicked a button that says so. Everywhere else an empty layout
+                    // is refused, because it far more often means "the caller had nothing
+                    // loaded" than "erase four tabs and their agent conversations".
+                    allowClear: true,
+                  }).catch(() => {});
+                }
+              }}
+            >
+              {t("pill.closeAllTabs")}
+            </button>
+          </div>
+
+          {/* Danger zone — irreversible / destructive actions, fenced off */}
+          <div className="context-menu-danger-zone">
+            <div className="context-menu-group-label">{t("pill.dangerZone")}</div>
+            {project.remote && (
+              <button
+                className="danger"
+                onClick={() => {
+                  setContextMenu(null);
+                  setShowDetach(true);
+                }}
+                title={t("pill.detachSshMenuTitle")}
+              >
+                {t("pill.detachSshEllipsis")}
+              </button>
+            )}
+            {!project.remote && project.git_type !== "none" && (
+              <button
+                className="danger"
+                onClick={() => {
+                  setContextMenu(null);
+                  setShowDisableGit(true);
+                }}
+                title={t("pill.removeGitMenuTitle")}
+              >
+                {t("pill.removeGitHistoryEllipsis")}
+              </button>
+            )}
+            <button
+              className="danger"
+              onClick={() => {
+                setContextMenu(null);
+                setShowArchive(true);
+              }}
+              title={t("pill.deleteProjectMenuTitle")}
+            >
+              {t("pill.deleteProjectEllipsis")}
+            </button>
+          </div>
         </div>,
         document.body,
       )}
@@ -399,6 +2019,15 @@ export function ProjectPill({ project, active, onClick, onClose, onReorder, onGr
         <ActivityWindow project={project} onClose={() => setShowActivity(false)} />
       )}
 
+      {/* Rename window */}
+      {renaming && (
+        <RenameWindow
+          project={project}
+          onSave={(name) => renameProject(project.id, name)}
+          onClose={() => setRenaming(false)}
+        />
+      )}
+
       {/* Edit description window */}
       {editDescription && (
         <EditDescriptionWindow
@@ -408,80 +2037,188 @@ export function ProjectPill({ project, active, onClick, onClose, onReorder, onGr
         />
       )}
 
-      {/* Publish-to-GitHub window */}
+      {/* Publish-to-GitHub/GitLab window */}
       {showPublish && (
         <PublishWindow
           project={project}
-          onPublish={(visibility) => publishProject(project.id, visibility)}
+          onPublish={(provider, visibility, publishFrom) =>
+            publishProject(project.id, provider, visibility, publishFrom)
+          }
           onClose={() => setShowPublish(false)}
         />
       )}
 
+      {/* Per-project git-hosting override window */}
+      {showGitHosting && (
+        <GitHostingWindow project={project} onClose={() => setShowGitHosting(false)} />
+      )}
+
+      {/* Category-tag editor */}
+      {editCategories && (
+        <CategoryEditor project={project} onClose={() => setEditCategories(false)} />
+      )}
+
+      {/* Project-container spec knobs (image, network, resource caps) */}
+      {showContainerSettings && (
+        <ContainerSettingsWindow
+          project={project}
+          onClose={() => setShowContainerSettings(false)}
+        />
+      )}
+
+
+      {/* Which Python the viewer's Run/Debug buttons use (#87) */}
+      {showPythonSettings && (
+        <PythonInterpreterWindow
+          project={project}
+          onClose={() => setShowPythonSettings(false)}
+        />
+      )}
+
+      {/* Extend a local project to remote (attach an SSH host) — either from
+          the context menu, or a global machine dropped onto this pill. */}
+      {extendRemote && (
+        <ExtendToRemoteDialog
+          project={project}
+          initialMachine={extendRemoteMachine ?? undefined}
+          onClose={() => {
+            setExtendRemote(false);
+            setExtendRemoteMachine(null);
+          }}
+        />
+      )}
+
+      {/* Detach a remote project back to local */}
+      {showDetach && (
+        <DetachRemoteWindow
+          project={project}
+          onConfirm={() => detachProjectFromRemote(project.id)}
+          onClose={() => setShowDetach(false)}
+        />
+      )}
+
+      {/* Unpublish (forget the push target, keep repo + history) */}
+      {showUnpublish && (
+        <UnpublishWindow
+          project={project}
+          onConfirm={() => unpublishProject(project.id)}
+          onClose={() => setShowUnpublish(false)}
+        />
+      )}
+
+      {/* Flip repository visibility (public ↔ private) in place */}
+      {showVisibility && (
+        <VisibilityWindow
+          project={project}
+          onApply={(visibility) => setProjectVisibility(project.id, visibility)}
+          onClose={() => setShowVisibility(false)}
+        />
+      )}
+
+      {/* Migrate to the other hosting provider */}
+      {showMigrate && (
+        <MigrateProviderWindow
+          project={project}
+          onMigrate={(provider, visibility, publishFrom) =>
+            switchProjectProvider(project.id, provider, visibility, publishFrom)
+          }
+          onClose={() => setShowMigrate(false)}
+        />
+      )}
+
+      {/* In-app folder browser for "Move project…" (replaces the OS chooser) */}
+      {movePickerInitial !== null && (
+        <FolderPickerDialog
+          initialPath={movePickerInitial}
+          title={`${project.name} — move mirror folder to…`}
+          confirmLabel="Move here"
+          nameLabel="Local folder name"
+          nameInitial={project.name}
+          onConfirm={confirmMove}
+          onClose={() => setMovePickerInitial(null)}
+        />
+      )}
+
+      {/* Destructive: delete .git + history (typed-confirm) */}
+      {showDisableGit && (
+        <DisableGitWindow
+          project={project}
+          onConfirm={() => setProjectGitDisabled(project.id, true)}
+          onClose={() => setShowDisableGit(false)}
+        />
+      )}
+
+      {/* Delete → archive (reversible; simple confirm) */}
+      {showArchive && (
+        <ArchiveConfirmWindow
+          project={project}
+          onConfirm={() => archiveProject(project.id)}
+          onClose={() => setShowArchive(false)}
+        />
+      )}
+
       <div
         ref={pillRef}
-        className={`project-pill${active ? " active" : ""}${timerPaused ? " timer-paused" : ""}${dragOver ? " drag-over" : ""}${groupHint ? " drag-group" : ""}${dragging ? " dragging" : ""}`}
-        draggable
+        data-pill-id={project.id}
+        className={`project-pill${active ? " active" : ""}${timerPaused ? " timer-paused" : ""}${groupHintActive ? " drag-group" : ""}${isDragged ? " dragging" : ""}${!isDragged && shiftPx ? " reorder-parting" : ""}${catColor ? " has-category" : ""}`}
+        style={{
+          ...(catColor ? { "--cat-color": catColor } : {}),
+          ...(isDragged
+            ? { transform: `translateX(${dragDx ?? 0}px) scale(0.94)` }
+            : shiftPx
+              ? { transform: `translateX(${shiftPx}px)` }
+              : {}),
+        } as React.CSSProperties}
         onMouseEnter={handleMouseEnter}
-        onMouseLeave={() => { setPopupPos(null); setTimeToday(null); setCpu(null); }}
+        onMouseLeave={() => hover.close()}
         onContextMenu={handleContextMenu}
-        onDragStart={(e) => {
-          // Hide the hover popup so it doesn't linger as a drag ghost.
-          setPopupPos(null);
-          setDragging(true);
-          e.dataTransfer.setData(PILL_DRAG_TYPE, project.id);
-          e.dataTransfer.effectAllowed = "move";
-        }}
-        onDragOver={(e) => {
-          if (!e.dataTransfer.types.includes(PILL_DRAG_TYPE)) return;
-          e.preventDefault();
-          e.dataTransfer.dropEffect = "move";
-          if (!dragOver) setDragOver(true);
-          // Alt toggles the gesture to "box these two together" (see onDrop).
-          const wantGroup = e.altKey && !!onGroup;
-          if (wantGroup !== groupHint) setGroupHint(wantGroup);
-        }}
-        onDragLeave={() => { setDragOver(false); setGroupHint(false); }}
-        onDrop={(e) => {
-          setDragOver(false);
-          setGroupHint(false);
-          const fromId = e.dataTransfer.getData(PILL_DRAG_TYPE);
-          if (!fromId || fromId === project.id) return;
-          e.preventDefault();
-          // Consume the drop so it does NOT also bubble to an enclosing BoxChip
-          // (→ assign-to-box) or the ungrouped pills strip (→ assign-to-null).
-          e.stopPropagation();
-          // Alt-drop boxes the two projects together; a plain drop reorders.
-          if (e.altKey && onGroup) {
-            onGroup(fromId, project.id);
-          } else {
-            onReorder(fromId, project.id);
-          }
-        }}
-        onDragEnd={(e) => {
-          setDragOver(false);
-          setGroupHint(false);
-          setDragging(false);
-          // Released over no drop target (dropEffect "none") while this pill is a
-          // box member → drag-out: remove it from the box. Drops that landed on a
-          // real target (strip, another box, a reorder) set "move" and are handled
-          // there, so they don't also trigger a leave here.
-          if (boxId && onLeaveBox && e.dataTransfer.dropEffect === "none") {
-            onLeaveBox(project.id);
-          }
-        }}
+        onPointerDown={startPillDrag}
       >
         <button className="pill-main" onClick={onClick}>
-          <span className="pill-folder-icon" aria-hidden>{timerPaused ? "⏸" : "📁"}</span>
+          <span
+            className={`pill-folder-icon git-${gitDirty ?? "clean"}`}
+            title={t(GIT_ICON_TITLE_KEY[gitDirty ?? "clean"])}
+            aria-hidden
+          >
+            {/* The folder + its git color are shown ALWAYS — the git dirty state
+                must never be hidden by an unrelated concern. A paused time-tracking
+                timer is signalled non-destructively: a small ⏸ overlay badge (plus
+                the pill's own `.timer-paused` dimming), never by swapping the icon
+                out, which used to erase every pill's git colour the moment you
+                paused the timer. */}
+            <svg viewBox="0 0 16 16" width="14" height="14" fill="currentColor">
+              <path d="M1.75 1A1.75 1.75 0 0 0 0 2.75v10.5C0 14.216.784 15 1.75 15h12.5A1.75 1.75 0 0 0 16 13.25v-8.5A1.75 1.75 0 0 0 14.25 3H7.5a.25.25 0 0 1-.2-.1l-.9-1.2C6.07 1.26 5.55 1 5 1H1.75Z" />
+            </svg>
+            {timerPaused && <span className="pill-folder-pause">⏸</span>}
+          </span>
           <span className="project-pill-label">{project.name}</span>
-          {busy && <OrbitSpinner className="pill-running-spinner" />}
         </button>
+        {categories.length > 0 && (
+          <span className="pill-category-dots" title={t("pill.categoriesLabel", { list: categories.join(", ") })}>
+            {categories.map((cat) => (
+              <span
+                key={cat.toLowerCase()}
+                className="pill-category-dot"
+                style={{ background: categoryColor(cat) }}
+              />
+            ))}
+          </span>
+        )}
+        {project.remote && <RemoteConnMenu project={project} compact />}
         <button
           className="pill-close-btn"
-          title="Close project"
+          title={t("pill.closeProject")}
           onClick={(e) => { e.stopPropagation(); onClose(); }}
         >
           ×
         </button>
+        {statusCounts && (
+          <span className="pill-status-bars" title={statusBarTitle(statusCounts, t)}>
+            {statusBarKinds(statusCounts).map((kind, i) => (
+              <span key={i} className={`pill-status-bar ${kind}`} />
+            ))}
+          </span>
+        )}
       </div>
     </>
   );
diff --git a/src/components/projects/ProjectSearch.tsx b/src/components/projects/ProjectSearch.tsx
index bd262e9..8c35903 100644
--- a/src/components/projects/ProjectSearch.tsx
+++ b/src/components/projects/ProjectSearch.tsx
@@ -1,11 +1,29 @@
 import { useEffect, useMemo, useRef, useState } from "react";
 import type { ProjectBox, ProjectEntry } from "../../types";
+import { formatRemoteTarget, resolveLocalMirror } from "../../types";
 import { projectDirectory } from "./scaffold";
+import { useT } from "../../lib/i18n";
 
 type SearchRow =
   | { kind: "project"; project: ProjectEntry }
   | { kind: "box"; box: ProjectBox };
 
+/** Location line(s) shown under a project's name — and the text the query is
+ *  matched against. A remote (SSH) project lives in two places at once, so both
+ *  its host target and its paired local mirror are listed; its `directory` is
+ *  only an internal state dir and is never shown. */
+function searchPaths(project: ProjectEntry): { label?: string; path: string }[] {
+  if (project.remote) {
+    const mirror = resolveLocalMirror(project);
+    return [
+      { label: "remote", path: formatRemoteTarget(project.remote) },
+      ...(mirror ? [{ label: "local", path: mirror }] : []),
+    ];
+  }
+  const dir = projectDirectory(project);
+  return dir ? [{ path: dir }] : [];
+}
+
 /**
  * The inactive-project / box search box and its results popover. Owns its own
  * query state and click-outside dismissal; activation is delegated to the
@@ -22,6 +40,7 @@ export function ProjectSearch({
   onActivateProject: (projectId: string) => void;
   onOpenBox: (boxId: string) => void;
 }) {
+  const t = useT();
   const [query, setQuery] = useState("");
   const searchRef = useRef<HTMLDivElement>(null);
 
@@ -36,7 +55,11 @@ export function ProjectSearch({
       .map((box) => ({ kind: "box", box }));
     const projectRows: SearchRow[] = projects
       .filter((p) => p.status === "inactive")
-      .filter((p) => p.name.toLowerCase().includes(q) || projectDirectory(p).toLowerCase().includes(q))
+      .filter(
+        (p) =>
+          p.name.toLowerCase().includes(q) ||
+          searchPaths(p).some((loc) => loc.path.toLowerCase().includes(q)),
+      )
       .sort((a, b) => a.position - b.position)
       .map((project) => ({ kind: "project", project }));
     return [...boxRows, ...projectRows];
@@ -66,7 +89,7 @@ export function ProjectSearch({
       <input
         className="project-search-entry"
         type="search"
-        placeholder="Search inactive..."
+        placeholder={t("projectSearch.placeholder")}
         value={query}
         onChange={(e) => setQuery(e.target.value)}
         onKeyDown={(e) => {
@@ -82,7 +105,7 @@ export function ProjectSearch({
       {query.trim() && (
         <div className="project-search-popover">
           {results.length === 0 ? (
-            <div className="project-search-empty">No projects</div>
+            <div className="project-search-empty">{t("projectSearch.noProjects")}</div>
           ) : (
             results.map((row) =>
               row.kind === "box" ? (
@@ -95,8 +118,9 @@ export function ProjectSearch({
                     <span className="project-box-badge" aria-hidden>▣</span> {row.box.name}
                   </span>
                   <small>
-                    Box · {row.box.member_ids.length} member
-                    {row.box.member_ids.length === 1 ? "" : "s"}
+                    {t(row.box.member_ids.length === 1 ? "projectSearch.boxMemberOne" : "projectSearch.boxMemberMany", {
+                      count: row.box.member_ids.length,
+                    })}
                   </small>
                 </button>
               ) : (
@@ -106,9 +130,14 @@ export function ProjectSearch({
                   onClick={() => activateSearchResult(row)}
                 >
                   <span>{row.project.name}</span>
-                  {projectDirectory(row.project) && (
-                    <small>{projectDirectory(row.project)}</small>
-                  )}
+                  {searchPaths(row.project).map((loc) => (
+                    <small key={loc.label ?? "dir"} title={loc.path}>
+                      {loc.label && (
+                        <span className="project-search-path-label">{loc.label}</span>
+                      )}
+                      <span className="project-search-path">{loc.path}</span>
+                    </small>
+                  ))}
                 </button>
               ),
             )
diff --git a/src/components/projects/PythonInterpreterWindow.tsx b/src/components/projects/PythonInterpreterWindow.tsx
new file mode 100644
index 0000000..2f69f89
--- /dev/null
+++ b/src/components/projects/PythonInterpreterWindow.tsx
@@ -0,0 +1,155 @@
+import { useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { resolveProjectDirectory, type ProjectEntry } from "../../types";
+import { useProjectsStore } from "../../stores/projects";
+import { listInterpreters, type PyInterpreter } from "../../lib/pythonRun";
+import { useT } from "../../lib/i18n";
+
+/**
+ * Which Python the code viewer's Run/Debug buttons use for this project (#87).
+ *
+ * The default — and what almost every project should stay on — is **auto-detect**,
+ * so the dialog leads with it and *shows what it currently resolves to* rather than
+ * making the user trust an invisible decision. Pinning exists for the environments
+ * auto-detect cannot pick on the user's behalf: one of N unrelated conda envs, an
+ * interpreter outside the project tree, a second venv.
+ *
+ * The list is probed live (`python_interpreters`) — on a **remote** project that
+ * probe runs on the *host*, which is the machine the run tab will actually run on,
+ * so the paths offered here are the paths that will exist when Run is pressed.
+ *
+ * Shared: opened from the project pill's context menu and from the file viewer's
+ * gear (Project Settings), so both surfaces edit the one pinned interpreter.
+ */
+export function PythonInterpreterWindow({
+  project,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const setProjectPython = useProjectsStore((s) => s.setProjectPython);
+  const dir = resolveProjectDirectory(project);
+  const AUTO = "";
+  const CUSTOM = "__custom__";
+
+  const [found, setFound] = useState<PyInterpreter[] | null>(null);
+  const [probeError, setProbeError] = useState("");
+  const pinned = project.python_interpreter ?? "";
+  // A pinned path that isn't in the probed list is still legitimate (a hand-typed
+  // one, or an env that has since gone away) — it opens as "Custom".
+  const [choice, setChoice] = useState<string>(pinned || AUTO);
+  const [custom, setCustom] = useState(pinned);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let cancelled = false;
+    listInterpreters(dir)
+      .then((list) => {
+        if (cancelled) return;
+        setFound(list);
+        // Re-home a pinned value that the probe did find, so it selects its own row.
+        if (pinned && !list.some((i) => i.path === pinned)) setChoice(CUSTOM);
+      })
+      .catch((e) => {
+        if (cancelled) return;
+        setFound([]);
+        setProbeError(String(e));
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [dir, pinned]);
+
+  // What auto-detect would pick right now: the first entry the backend ranked as
+  // auto-selectable. Named conda envs are offered but never auto-picked.
+  const autoPick = found?.find((i) => i.kind !== "conda");
+
+  const save = async () => {
+    if (busy) return;
+    const value =
+      choice === AUTO ? null : choice === CUSTOM ? custom.trim() || null : choice;
+    setBusy(true);
+    setError("");
+    try {
+      await setProjectPython(project.id, value);
+      onClose();
+    } catch (err) {
+      setError(String(err));
+      setBusy(false);
+    }
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog dialog-framed" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{project.name} — {t("pythonInterp.titleSuffix")}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+        <p className="settings-help">
+          {t("pythonInterp.desc")}
+          {project.remote && ` ${t("pythonInterp.remoteSuffix")}`}
+        </p>
+
+        {found === null ? (
+          <div className="file-viewer-loading">{t("pythonInterp.looking")}</div>
+        ) : (
+          <>
+            <label>
+              {t("pythonInterp.interpreterLabel")}
+              <select
+                value={choice}
+                onChange={(e) => setChoice(e.target.value)}
+                disabled={busy}
+              >
+                <option value={AUTO}>
+                  {autoPick
+                    ? t("pythonInterp.autoDetectWith", { path: autoPick.path })
+                    : t("pythonInterp.autoDetect")}
+                </option>
+                {found.map((i) => (
+                  <option key={i.path} value={i.path}>
+                    {i.label} — {i.path}
+                  </option>
+                ))}
+                <option value={CUSTOM}>{t("pythonInterp.customPath")}</option>
+              </select>
+            </label>
+            {choice === CUSTOM && (
+              <label>
+                {t("pythonInterp.pathLabel")}
+                <input
+                  type="text"
+                  value={custom}
+                  placeholder={t("pythonInterp.pathPlaceholder")}
+                  onChange={(e) => setCustom(e.target.value)}
+                  spellCheck={false}
+                  disabled={busy}
+                />
+              </label>
+            )}
+            {probeError && (
+              <p className="settings-help">
+                {t("pythonInterp.probeErrorPre")}{probeError}{t("pythonInterp.probeErrorPost")}
+              </p>
+            )}
+          </>
+        )}
+
+        {error && <div className="project-dialog-error">{error}</div>}
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose} disabled={busy}>{t("common.cancel")}</button>
+          <button type="button" onClick={() => void save()} disabled={busy || found === null}>
+            {busy ? t("pythonInterp.saving") : t("pythonInterp.save")}
+          </button>
+        </div>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/projects/RemoteConnectDialog.tsx b/src/components/projects/RemoteConnectDialog.tsx
new file mode 100644
index 0000000..e55a0b2
--- /dev/null
+++ b/src/components/projects/RemoteConnectDialog.tsx
@@ -0,0 +1,994 @@
+import { useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { TerminalView } from "../terminal/TerminalView";
+import { Toggle } from "../common/Toggle";
+import { ConnLamp } from "../common/ConnLamp";
+import { ConnectionLog } from "../common/ConnectionLog";
+import { Dropdown } from "../common/Dropdown";
+import { PasswordInput } from "../common/PasswordInput";
+import { UntestedTag } from "../common/UntestedTag";
+import { TerminalSignInToggle } from "./TerminalSignInToggle";
+import { SavePasswordRow } from "./SavePasswordRow";
+import { rememberArg } from "./useSavedCredential";
+import { CarefulHostToggle } from "./CarefulHostToggle";
+import { HpcHostToggle } from "./HpcHostToggle";
+import { primaryTargetOf, targetOfSpec } from "../../lib/carefulHost";
+import { CredentialPasteBar, sshPasteEntries, vpnPasteEntries } from "./CredentialPasteBar";
+import { useRemoteReconnect } from "./useRemoteReconnect";
+import { useConnectDialogStore } from "../../stores/connectDialog";
+import { useProjectsStore, disconnectRemote } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { useVpnSectionVisible } from "../../stores/vpnStatus";
+import { VpnTunnelUpNotice } from "../common/VpnTunnelUpNotice";
+import { formatRemoteTarget, resolveLocalMirror, type ProjectEntry } from "../../types";
+import { useT } from "../../lib/i18n";
+
+/**
+ * Centered "Connect" modal for an existing remote (SSH) project — the single
+ * entry point the per-pill status lamp and the disconnected-pane placeholder
+ * open. It is the connect-only sibling of the new-project dialog's SSH section:
+ * no address entry, no folder browse, no project creation — the target is the
+ * project's known `remote` spec.
+ *
+ * Two paths, matching the `connections_headless` setting (default ON):
+ *  - headless → Eldrun feeds the password to the backend (SSH password + VPN
+ *    passphrase fields, a live handshake log for VPN), and
+ *  - non-headless → embedded login terminals where the user types the secret
+ *    directly and Eldrun never handles it.
+ * Both drive `useRemoteReconnect`, so the shared SSH/VPN lamp state (and the
+ * pooled `remote_connect`) is identical to the header lamps. The modal
+ * auto-closes once SSH reaches "connected".
+ */
+export function RemoteConnectDialog() {
+  const projectId = useConnectDialogStore((s) => s.projectId);
+  const hostId = useConnectDialogStore((s) => s.hostId);
+  const project = useProjectsStore((s) =>
+    projectId ? s.projects.find((p) => p.id === projectId) : undefined,
+  );
+  if (!projectId || !project?.remote) return null;
+  // Multi-host remote: the modal targets the primary or a worker host. Resolve the
+  // selected worker (if any) so its own spec drives the connect + lamp.
+  const worker =
+    hostId && hostId !== "primary"
+      ? project.compute_hosts?.find((h) => h.id === hostId)
+      : undefined;
+  return (
+    <RemoteConnectDialogInner key={`${project.id}:${hostId ?? "primary"}`} project={project} host={worker} />
+  );
+}
+
+function RemoteConnectDialogInner({
+  project,
+  host,
+}: {
+  project: ProjectEntry;
+  host?: import("../../types").ComputeHost;
+}) {
+  const t = useT();
+  const close = useConnectDialogStore((s) => s.close);
+  const headless = useSettingsStore((s) => s.settings?.connections_headless ?? true);
+  // Which machine the careful switch below governs: the worker this dialog was
+  // opened for, or the project's primary when it was opened for that. A worker is
+  // a `ComputeHost extends RemoteSpec`, so both spellings carry user/host/port.
+  const carefulTarget = host ? targetOfSpec(host) : primaryTargetOf(project);
+  const {
+    sshStatus,
+    vpnStatus,
+    sshUser,
+    setSshUser,
+    commitSshUser,
+    vpnConfig,
+    vpnConfigs,
+    vpnUsername,
+    setVpnUsername,
+    vpnNeeds,
+    vpnNeedsKeyPassphrase,
+    selectVpnConfig,
+    browseVpnConfig,
+    winManual,
+    vpnTerm,
+    sshTerm,
+    startVpnTerm,
+    stopVpn,
+    startSshTerm,
+    stopSsh,
+    tryConnectNow,
+    sshError,
+    vpnError,
+    vpnLog,
+    sshSaved,
+    sshCredential,
+    vpnSaved,
+    autoConnect,
+    autoConnectEligible,
+    autoConnectBlock,
+    setAutoConnect,
+    setWorkerLabel,
+    connectVpnHeadless,
+    connectSshHeadless,
+    forgetPasswords,
+    forgetSshPassword,
+    forgetVpnPassword,
+  } = useRemoteReconnect(project, host);
+
+  // Editable name: for a worker its `label`, for the primary the project name.
+  // Seeded from the current value and re-synced when the store's copy changes (a
+  // rename commits into the store); committed on blur / Enter so a write fires once,
+  // not per keystroke. The two differ on blank: a worker label may be cleared (it
+  // then falls back to the host), but a project name may not — the backend rejects
+  // it, so we restore the field instead.
+  const currentName = host ? host.label ?? "" : project.name;
+  const [nameDraft, setNameDraft] = useState(currentName);
+  useEffect(() => setNameDraft(currentName), [currentName]);
+  const commitName = () => {
+    const next = nameDraft.trim();
+    if (next === currentName) return;
+    if (host) {
+      setWorkerLabel(next);
+    } else if (next) {
+      void useProjectsStore.getState().renameProject(project.id, next).catch(() => {});
+    } else {
+      setNameDraft(currentName); // project name can't be blank — undo the edit
+    }
+  };
+
+  // The primary's own machine name (`remote.label`) — distinct from the project
+  // name above: a project can be renamed without touching which name identifies
+  // its primary host across the multi-host surfaces (System Monitor's source
+  // picker, the pill's connection lamps). Worker-only equivalent is `host.label`,
+  // already covered by the "Name" field above since a worker has no project name
+  // of its own to conflict with it.
+  const currentMachineLabel = host ? "" : project.remote?.label ?? "";
+  const [machineDraft, setMachineDraft] = useState(currentMachineLabel);
+
+  // "Disconnect & end jobs" retains its explicit confirmation, although every
+  // disconnect now ends this host's tmux sessions before dropping the pool.
+  // Target is the worker's own spec or the primary's `remote`.
+  const [killArm, setKillArm] = useState(false);
+  const killTarget = host
+    ? { user: host.user, host: host.host, port: host.port }
+    : {
+        user: project.remote?.user,
+        host: project.remote?.host ?? "",
+        port: project.remote?.port,
+      };
+  useEffect(() => setMachineDraft(currentMachineLabel), [currentMachineLabel]);
+  const commitMachineLabel = () => {
+    const next = machineDraft.trim();
+    if (next === currentMachineLabel) return;
+    setWorkerLabel(next);
+  };
+
+  const [sshPassword, setSshPassword] = useState("");
+  const [vpnPassword, setVpnPassword] = useState("");
+  // Per-connect "sign in in a terminal" (see `TerminalSignInToggle`): pure view state
+  // — which half of the login section is on screen — so it lives here rather than in
+  // `useRemoteReconnect`, and it resets with the dialog, as a per-connect switch
+  // should. Default off: headless is the mode, this is the escape hatch from it.
+  const [sshViaTerminal, setSshViaTerminal] = useState(false);
+  const [vpnViaTerminal, setVpnViaTerminal] = useState(false);
+  // Only a separate secret when the config has BOTH an `auth-user-pass` account and
+  // an encrypted key — OpenVPN prompts for the two independently. For a key-only
+  // config `vpnPassword` already is the key passphrase, and this field stays hidden.
+  const [vpnKeyPassphrase, setVpnKeyPassphrase] = useState("");
+  // "Connect via OpenVPN" opt-in, default OFF: this project is VPN-gated, but on
+  // the right network the tunnel is unnecessary and SSH connects directly. The
+  // VPN fields stay collapsed until the user turns this on — *unless* a tunnel is
+  // already up (or coming up) for this project, in which case the section opens
+  // itself. A live tunnel must never hide behind a collapsed section: that is
+  // exactly the state where the user needs it, to bring the tunnel back down.
+  const [vpnEnabled, setVpnEnabled] = useState(vpnStatus !== "off");
+  useEffect(() => {
+    if (vpnStatus === "connecting" || vpnStatus === "connected") setVpnEnabled(true);
+  }, [vpnStatus]);
+  // "Save password" opt-in (default off). Pre-checked when a credential is
+  // *known* to be saved for this target — the tri-state's point: an unresolved or
+  // unreadable keychain leaves the box unticked, and an unticked box now sends
+  // `remember: null` ("leave it alone"), never the `false` that used to delete
+  // the credential the connect had just authenticated with.
+  const [sshRemember, setSshRemember] = useState(false);
+  const [vpnRemember, setVpnRemember] = useState(false);
+  useEffect(() => setSshRemember(sshSaved), [sshSaved]);
+  useEffect(() => setVpnRemember(vpnSaved), [vpnSaved]);
+  const localMirror = resolveLocalMirror(project);
+
+  // Re-open the config picker for a project that already has one ("Change…").
+  // The stored config is remembered, but it must stay swappable: a host can move
+  // behind a different VPN, or the first pick can simply have been the wrong file.
+  const [changingVpnConfig, setChangingVpnConfig] = useState(false);
+  const showVpnPicker = vpnEnabled && (!vpnConfig || changingVpnConfig);
+  // Prefer the recents-list name (the stored copy's file name); fall back to the
+  // path's own basename for a config that isn't in the list yet.
+  const vpnConfigName = vpnConfig
+    ? vpnConfigs.find((c) => c.path === vpnConfig)?.name ??
+      vpnConfig.split(/[\\/]/).pop() ??
+      vpnConfig
+    : "";
+
+  // Auto-close only on a *fresh* connect made from within this dialog — the held
+  // panes mount and the work surface takes over, so the modal has nothing left
+  // to do. If it was already connected when opened (the user clicked the pill to
+  // manage/disconnect an up connection), keep it open so the Disconnect action
+  // stays reachable — clicking the lamps of a connected project must show the
+  // same menu as when disconnected.
+  const prevSshStatus = useRef(sshStatus);
+  useEffect(() => {
+    const prev = prevSshStatus.current;
+    prevSshStatus.current = sshStatus;
+    if (sshStatus === "connected" && prev !== "connected") close();
+  }, [sshStatus, close]);
+
+  const connected = sshStatus === "connected";
+  const connecting = sshStatus === "connecting";
+  // The tunnel is up or on its way — every VPN field/button is locked while so.
+  const vpnBusy = vpnStatus === "connecting" || vpnStatus === "connected";
+  // A tunnel is machine-wide, so once *any* config is live there's nothing left for
+  // this project's OpenVPN section to offer — except when it's THIS project's own
+  // attempt that made it live, in which case its controls (log, Stop/Disconnect)
+  // must stay reachable here. `vpnBusy` already mirrors that via the machine store.
+  const showVpnSection = useVpnSectionVisible(vpnBusy);
+
+  // The two "save the secret" rows, defined once and rendered from **both** halves of
+  // the login section. They belong to the *host*, not to how you happen to be signing
+  // in this time: switching to the terminal login must not make a saved password look
+  // discarded (and must certainly never delete it — only unticking does that, and only
+  // by the user's own click). A terminal login is one Eldrun never sees, so nothing
+  // *new* is stored from it; the saved credential is simply kept for the connects that
+  // can use it, which the hint says out loud rather than leaving to be guessed.
+  // The shared row (`SavePasswordRow`), which also carries the locked-keyring
+  // banner: a keychain that can't be read used to render here as a confident
+  // "nothing saved", which is the state that invited an untick — and, before the
+  // `remember: false` fix, a delete.
+  const sshSaveRow = (
+    <SavePasswordRow
+      credential={sshCredential}
+      checked={sshRemember}
+      disabled={connecting || connected}
+      viaTerminal={sshViaTerminal}
+      onChange={(on) => {
+        setSshRemember(on);
+        // Untick = delete it now. Waiting for the next connect to clear it
+        // leaves the password in the keychain the user just asked to drop —
+        // and the connect no longer clears anything, by design.
+        if (!on && sshSaved) void forgetSshPassword();
+      }}
+    />
+  );
+  const vpnSaveRow = (
+    <label className="remote-connect-remember">
+      <Toggle
+        size="sm"
+        checked={vpnRemember}
+        disabled={vpnBusy}
+        onChange={(e) => {
+          setVpnRemember(e.target.checked);
+          // Unticking is a request to *not* have the secret stored —
+          // honour it now, not at the next connect (which may never come).
+          if (!e.target.checked && vpnSaved) void forgetVpnPassword();
+        }}
+      />
+      {vpnNeedsKeyPassphrase ? t("vpnPrompt.saveVpnCredentials") : t("vpnPrompt.savePassphrase")}
+      <span className="ssh-optional-hint">
+        {vpnSaved
+          ? vpnViaTerminal
+            ? t("remoteConnect.saveHintKeptTerminal")
+            : t("remoteConnect.saveHintSaved")
+          : vpnViaTerminal
+            ? t("remoteConnect.saveHintNothingTerminal")
+            : t("vpnPrompt.storedSecurely")}
+      </span>
+    </label>
+  );
+  // One submit for the whole VPN form: the fields are separate prompts OpenVPN
+  // raises, but they're answered in a single connect.
+  const submitVpn = () => void connectVpnHeadless(vpnPassword, vpnKeyPassphrase, rememberArg(vpnRemember));
+
+  // What the "Paste …" row above each login terminal offers (see `CredentialPasteBar`).
+  // A terminal login is one Eldrun never sees — but a credential the user saved from a
+  // headless connect is still sitting in the keychain, and retyping it into every
+  // terminal login is exactly the friction the keychain exists to remove. The login
+  // *name* is pasted from here (it is on screen already, in a plain text field); the
+  // secret is only ever named — the backend reads it and types it.
+  const sshPaste = sshPasteEntries(t, {
+    user: sshUser,
+    host: host ? host.host : project.remote?.host,
+    port: host ? host.port : project.remote?.port,
+    saved: sshSaved,
+  });
+  const vpnPaste = vpnPasteEntries(t, {
+    config: vpnConfig,
+    username: vpnUsername,
+    saved: vpnSaved,
+    needsUsername: vpnNeeds.username,
+    needsKeyPassphrase: vpnNeedsKeyPassphrase,
+  });
+
+  return createPortal(
+    <div className="modal-backdrop modal-backdrop-elevated" onMouseDown={close}>
+      <div
+        className="project-dialog dialog-framed remote-connect-dialog"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>
+            {host
+              ? t("remoteConnect.titleWorker", { host: host.label || host.host })
+              : t("remoteConnect.titleProject")}
+          </h2>
+          <button type="button" className="dialog-close-btn" onClick={close}>×</button>
+        </div>
+
+        <div className="dialog-scroll">
+        <div className="remote-connect-target">
+          <div className="remote-connect-location">
+            <span className="remote-connect-location-label">{t("remoteConnect.remoteLabel")}</span>
+            <span
+              className="remote-connect-location-path"
+              title={host ? formatRemoteTarget(host) : project.remote ? formatRemoteTarget(project.remote) : undefined}
+            >
+              {host ? formatRemoteTarget(host) : project.remote && formatRemoteTarget(project.remote)}
+            </span>
+          </div>
+          {/* A worker is code-read-only (one-way sync, outputs stay on it) — it
+              has no local mirror to show; only the primary does. */}
+          {!host && localMirror && (
+            <div className="remote-connect-location">
+              <span className="remote-connect-location-label">{t("remoteConnect.localLabel")}</span>
+              <span className="remote-connect-location-path" title={localMirror}>{localMirror}</span>
+            </div>
+          )}
+        </div>
+
+        {/* Rename here — a worker's name was only settable once (at add time), and the
+            primary's project name was only editable elsewhere. Blank clears a worker
+            label (it falls back to the host); a project name can't be blank. */}
+        <label className="remote-connect-field remote-worker-name">
+          <span className="remote-machine-add-label">
+            {t("remoteConnect.nameLabel")}
+            <UntestedTag />
+          </span>
+          <input
+            type="text"
+            value={nameDraft}
+            placeholder={host ? host.host : t("remoteConnect.namePlaceholder")}
+            spellCheck={false}
+            autoComplete="off"
+            onChange={(e) => setNameDraft(e.target.value)}
+            onBlur={commitName}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") (e.target as HTMLInputElement).blur();
+            }}
+          />
+          <span className="ssh-optional-hint">
+            {host
+              ? t("remoteConnect.nameHintWorker")
+              : t("remoteConnect.nameHintProject")}
+          </span>
+        </label>
+
+        {/* The primary's own machine name — worker rows already get this via the
+            "Name" field above (a worker has no project name to conflict with it);
+            the primary needs a second field since its "Name" above is the project
+            name. Optional: blank falls back to the bare host everywhere hosts are
+            listed side by side (System Monitor, pill lamps, "Remote machines"). */}
+        {!host && (
+          <label className="remote-connect-field remote-worker-name">
+            <span className="remote-machine-add-label">
+              {t("remoteConnect.machineNameLabel")}
+              <UntestedTag />
+            </span>
+            <input
+              type="text"
+              value={machineDraft}
+              placeholder={project.remote?.host ?? ""}
+              spellCheck={false}
+              autoComplete="off"
+              onChange={(e) => setMachineDraft(e.target.value)}
+              onBlur={commitMachineLabel}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") (e.target as HTMLInputElement).blur();
+              }}
+            />
+            <span className="ssh-optional-hint">
+              {t("remoteConnect.machineNameHint")}
+            </span>
+          </label>
+        )}
+
+        {/* ── OpenVPN (always offered; opt-in, default off) ─────────────────────
+            Shown for every remote project, not only ones that stored a config at
+            create time: a project made on a no-VPN network may need a tunnel when
+            reconnected from a VPN-gated one. With no config yet, enabling the
+            toggle reveals a picker; the choice is persisted to the project.
+            But once *any* tunnel is already up machine-wide, this whole section is
+            redundant — the routing this project needs is already there — so it
+            collapses to a one-line status and the dialog goes straight to SSH. */}
+        {!showVpnSection && (
+          <div className="remote-reconnect-section">
+            <VpnTunnelUpNotice />
+          </div>
+        )}
+        {showVpnSection && (
+        <div className="remote-reconnect-section" role="group" aria-label={t("remoteConnect.vpnSectionAria")}>
+          <label className={`toggle-card${vpnEnabled ? " is-on" : ""}`}>
+            <span className="toggle-card-body">
+              <span className="toggle-card-title">
+                <ConnLamp status={vpnStatus} label="OpenVPN" />
+                {t("remoteConnect.vpnToggleTitle")}
+              </span>
+              <span className="toggle-card-desc">
+                {t("remoteConnect.vpnDescLine1")}
+                <br />
+                {t("remoteConnect.vpnDescLine2Pre")}{" "}
+                <strong>{t("remoteConnect.vpnDescLine2Strong")}</strong>
+                {t("remoteConnect.vpnDescLine2Post")}
+              </span>
+            </span>
+            <span className="eld-switch">
+              <input
+                type="checkbox"
+                checked={vpnEnabled}
+                disabled={vpnStatus === "connecting" || vpnStatus === "connected"}
+                onChange={(e) => setVpnEnabled(e.target.checked)}
+              />
+              <span className="eld-switch-track" aria-hidden="true" />
+            </span>
+          </label>
+          {/* The config in use, always visible once one is stored — with the way
+              back to the picker. Chosen once, remembered, but never locked in. */}
+          {vpnEnabled && vpnConfig && (
+            <div className="vpn-config-current">
+              <span className="remote-connect-location-label">{t("remoteConnect.configLabel")}</span>
+              <span className="vpn-config-current-name" title={vpnConfig}>{vpnConfigName}</span>
+              <button
+                type="button"
+                className="vpn-config-change-btn"
+                disabled={vpnBusy || changingVpnConfig}
+                title={t("remoteConnect.changeConfigTitle")}
+                onClick={() => setChangingVpnConfig(true)}
+              >
+                {t("remoteConnect.changeConfig")}
+              </button>
+            </div>
+          )}
+          {showVpnPicker && (
+            <div className="vpn-config-pick">
+              <span className="ssh-optional-hint">
+                {vpnConfig
+                  ? t("remoteConnect.pickConfigHintChange")
+                  : t("remoteConnect.pickConfigHintNew")}
+              </span>
+              {vpnConfigs.length > 0 && (
+                <div className="folder-picker-row">
+                  <Dropdown
+                    className="dropdown-block vpn-config-recent"
+                    value=""
+                    placeholder={t("remoteConnect.recentConfigsPlaceholder")}
+                    title={t("remoteConnect.recentConfigsTitle")}
+                    onChange={(v) => {
+                      if (!v) return;
+                      selectVpnConfig(v);
+                      setChangingVpnConfig(false);
+                    }}
+                    options={vpnConfigs.map((c) => ({ value: c.path, label: c.name }))}
+                  />
+                </div>
+              )}
+              <div className="folder-picker-row">
+                <button
+                  type="button"
+                  className="dialog-connect-btn"
+                  onClick={async () => {
+                    await browseVpnConfig();
+                    setChangingVpnConfig(false);
+                  }}
+                >
+                  {t("remoteConnect.chooseConfigBtn")}
+                </button>
+                {/* Only an escape hatch when there is a config to fall back to. */}
+                {vpnConfig && (
+                  <button type="button" onClick={() => setChangingVpnConfig(false)}>
+                    {t("common.cancel")}
+                  </button>
+                )}
+              </div>
+              {vpnStatus === "error" && vpnError && (
+                <div className="project-dialog-error">{vpnError}</div>
+              )}
+            </div>
+          )}
+          {/* `!vpnTerm` is what makes the headless→terminal escape hatch below work:
+              once a login terminal has been opened for this config, *that* is where
+              the tunnel is being authenticated, whichever mode the app is in — so the
+              password fields step aside for it rather than sitting there inert. */}
+          {vpnEnabled && vpnConfig && !changingVpnConfig && (headless && !vpnTerm && !vpnViaTerminal ? (
+              <>
+                {vpnNeeds.username && (
+                  <label className="remote-connect-field">
+                    {t("remoteConnect.vpnUsernameLabel")}
+                    <input
+                      type="text"
+                      value={vpnUsername}
+                      autoComplete="off"
+                      placeholder={t("vpnPrompt.usernamePlaceholder")}
+                      disabled={vpnBusy}
+                      onChange={(e) => setVpnUsername(e.target.value)}
+                    />
+                  </label>
+                )}
+                <label className="remote-connect-field">
+                  {vpnNeeds.username ? t("remoteConnect.vpnPasswordLabel") : t("remoteConnect.vpnPassphraseLabel")}
+                  <PasswordInput
+                    value={vpnPassword}
+                    autoComplete="off"
+                    // A saved secret can't be pre-filled — it never leaves the
+                    // backend — so say so: blank means "use the saved one".
+                    placeholder={
+                      vpnSaved
+                        ? t("remoteConnect.vpnSavedPlaceholder")
+                        : vpnNeeds.username
+                          ? t("remoteConnect.vpnAccountPasswordPlaceholder")
+                          : t("remoteConnect.vpnPassphrasePlaceholder")
+                    }
+                    disabled={vpnBusy}
+                    onChange={(e) => setVpnPassword(e.target.value)}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter") submitVpn();
+                    }}
+                  />
+                </label>
+                {vpnNeedsKeyPassphrase && (
+                  <label className="remote-connect-field">
+                    {t("vpnPrompt.keyPassphraseLabel")}
+                    <PasswordInput
+                      value={vpnKeyPassphrase}
+                      autoComplete="off"
+                      placeholder={
+                        vpnSaved
+                          ? t("remoteConnect.vpnSavedPlaceholder")
+                          : t("vpnPrompt.keyPassphrasePlaceholder")
+                      }
+                      disabled={vpnBusy}
+                      onChange={(e) => setVpnKeyPassphrase(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter") submitVpn();
+                      }}
+                    />
+                    <span className="ssh-optional-hint">
+                      {t("vpnPrompt.keyPassphraseHint")}
+                    </span>
+                  </label>
+                )}
+                <div className="remote-connect-field">
+                  {!vpnBusy && (
+                    <button
+                      type="button"
+                      className="dialog-connect-btn"
+                      onClick={submitVpn}
+                    >
+                      {vpnStatus === "error" ? t("remoteConnect.retryVpn") : t("remoteConnect.connectVpn")}
+                    </button>
+                  )}
+                  {/* The tunnel's own teardown, independent of SSH: a VPN that came
+                      up while SSH still fails has to be droppable on its own (retry
+                      on another network, swap the config, or just get off the VPN). */}
+                  {vpnBusy && (
+                    <button
+                      type="button"
+                      className="vpn-disconnect-btn"
+                      title={
+                        vpnStatus === "connected"
+                          ? t("remoteConnect.vpnStopTitleConnected")
+                          : t("remoteConnect.vpnStopTitleConnecting")
+                      }
+                      onClick={stopVpn}
+                    >
+                      {vpnStatus === "connected" ? t("remoteConnect.disconnectVpn") : t("vpnPrompt.stop")}
+                    </button>
+                  )}
+                </div>
+                {vpnSaveRow}
+                {(vpnStatus === "connecting" || vpnLog.length > 0) && (
+                  <ConnectionLog lines={vpnLog} busy={vpnStatus === "connecting"} />
+                )}
+                {vpnStatus === "error" && vpnError && (
+                  <div className="project-dialog-error">{vpnError}</div>
+                )}
+              </>
+            ) : (
+              <div className="dialog-connect">
+                <button
+                  type="button"
+                  className="dialog-connect-btn"
+                  disabled={!!vpnTerm}
+                  title={t("remoteConnect.vpnTermBtnTitle")}
+                  onClick={() => void startVpnTerm()}
+                >
+                  <span className="dialog-connect-btn-icon" aria-hidden="true">▶_</span>
+                  {vpnTerm ? t("remoteConnect.vpnTermOpenBelow") : t("remoteConnect.vpnTermOpenBtn")}
+                </button>
+                {vpnTerm && (
+                  <div className="dialog-connect-terminal">
+                    <div className="dialog-connect-terminal-bar">
+                      <span className="ssh-optional-hint">
+                        {t("remoteConnect.vpnTermHint")}
+                      </span>
+                      <button type="button" className="vpn-disconnect-btn" onClick={stopVpn}>
+                        {t("remoteConnect.disconnect")}
+                      </button>
+                    </div>
+                    <CredentialPasteBar ptyId={vpnTerm.id} entries={vpnPaste} />
+                    <div className="dialog-connect-terminal-host">
+                      {/* A re-adopted terminal (tunnel still running from an earlier
+                          open of this dialog) attaches to its live PTY instead of
+                          spawning a second one — and so must not re-type the command. */}
+                      <TerminalView
+                        id={vpnTerm.id}
+                        cmd=""
+                        cwd=""
+                        initialInput={vpnTerm.adopted ? undefined : vpnTerm.command}
+                        attachOnly={vpnTerm.adopted}
+                        visible
+                        focused
+                        persistOnUnmount
+                      />
+                    </div>
+                  </div>
+                )}
+              </div>
+            ))}
+            {/* Outside the branch above, so it is reachable from *both* states: it is
+                what switches into the terminal login, and the only way back out of it
+                once the terminal has been disconnected. Only where there is a tunnel
+                to sign in to — with the section collapsed or no config picked, there
+                is nothing for it to switch. */}
+            {headless && (vpnViaTerminal || !!vpnTerm) && vpnEnabled && vpnConfig && !changingVpnConfig && vpnSaveRow}
+            {headless && vpnEnabled && vpnConfig && !changingVpnConfig && (
+              <TerminalSignInToggle
+                channel="vpn"
+                checked={vpnViaTerminal}
+                busy={!!vpnTerm}
+                failed={vpnStatus === "error"}
+                onChange={setVpnViaTerminal}
+              />
+            )}
+        </div>
+        )}
+
+        {/* ── SSH ───────────────────────────────────────────────────────────── */}
+        <div className="remote-reconnect-section" role="group" aria-label={t("remoteConnect.sshSectionAria")}>
+          <div className="remote-field-label">
+            <ConnLamp status={sshStatus} label="SSH" />
+            {t("remoteConnect.sshSectionLabel")}
+          </div>
+          {/* The login name — the other half of the credential, and deliberately
+              OUTSIDE the headless/non-headless split, because it is not a password:
+              it is part of the address in both modes. Headless sends it to
+              `ssh_connect`/`remote_connect`; non-headless types it into the login
+              terminal *and* uses it to find the ControlMaster that login leaves
+              behind (the socket is hashed over user+host+port, so the two disagreeing
+              is a red lamp behind a login that visibly worked). The project's address
+              is fixed at creation, so without this a project created with no user —
+              which authenticates as your *local* account name — or with the wrong one
+              could not be corrected at all. Committed on blur/Enter; connecting
+              commits it first, so it counts even without leaving the field. */}
+          <label className="remote-connect-field">
+            <span className="remote-machine-add-label">
+              {t("remoteConnect.usernameLabel")}
+              <UntestedTag />
+            </span>
+            <input
+              type="text"
+              value={sshUser}
+              spellCheck={false}
+              autoComplete="off"
+              placeholder={t("remoteConnect.usernamePlaceholder")}
+              disabled={connecting || connected}
+              onChange={(e) => setSshUser(e.target.value)}
+              onBlur={() => void commitSshUser()}
+              onKeyDown={(e) => {
+                if (e.key === "Enter") (e.target as HTMLInputElement).blur();
+              }}
+            />
+            <span className="ssh-optional-hint">
+              {t("remoteConnect.usernameHint", { host: host ? host.host : (project.remote?.host ?? "") })}
+            </span>
+          </label>
+          {/* `!sshTerm` keeps a started terminal login on screen even if the switch
+              below is flipped back: the session it is authenticating is real, and the
+              password fields would orphan it. */}
+          {headless && !sshViaTerminal && !sshTerm ? (
+            <>
+              <label className="remote-connect-field">
+                {t("remoteConnect.sshPasswordLabel")}
+                <PasswordInput
+                  value={sshPassword}
+                  autoFocus
+                  autoComplete="off"
+                  // The saved password stays in the keychain (the backend never hands
+                  // it back), so the field can't be pre-filled. Blank + Connect uses it.
+                  placeholder={
+                    sshSaved
+                      ? t("remoteConnect.sshSavedPlaceholder")
+                      : t("remoteConnect.sshPasswordPlaceholder")
+                  }
+                  disabled={connecting || connected}
+                  onChange={(e) => setSshPassword(e.target.value)}
+                  onKeyDown={(e) => {
+                    if (e.key === "Enter") void connectSshHeadless(sshPassword, rememberArg(sshRemember));
+                  }}
+                />
+                <button
+                  type="button"
+                  className="dialog-connect-btn"
+                  disabled={connecting || connected}
+                  onClick={() => void connectSshHeadless(sshPassword, rememberArg(sshRemember))}
+                >
+                  {connected ? t("remoteConnect.connectedState") : connecting ? t("vpnPrompt.connecting") : t("common.connect")}
+                </button>
+                {connecting && (
+                  <button
+                    type="button"
+                    className="vpn-disconnect-btn"
+                    title={t("remoteConnect.sshStopTitle")}
+                    onClick={stopSsh}
+                  >
+                    {t("vpnPrompt.stop")}
+                  </button>
+                )}
+              </label>
+              {sshSaveRow}
+              {/* Eligibility is the ONE shared formula (`autoConnectEligibility`),
+                  which is what finally brings the **HPC tag** here: a tagged host is
+                  one `stores/projects` refuses to dial unattended, so this switch
+                  was armable and guaranteed to do nothing. It now reads like the
+                  Machines menu's — disabled, and saying which wall it hit. */}
+              <label
+                className="remote-connect-remember"
+                title={
+                  autoConnectBlock === "hpc"
+                    ? t("autoConnect.hpcTitle")
+                    : autoConnectEligible
+                      ? t("remoteConnect.autoConnectTitleEligible")
+                      : t("remoteConnect.autoConnectTitleNotEligible")
+                }
+              >
+                <Toggle
+                  size="sm"
+                  checked={autoConnect && autoConnectEligible}
+                  disabled={!autoConnectEligible}
+                  onChange={(e) => setAutoConnect(e.target.checked)}
+                />
+                {t("remoteConnect.autoConnectLabel")}
+                {autoConnectBlock === "hpc" && (
+                  <span className="machines-auto-blocked"> {t("autoConnect.offWhileHpc")}</span>
+                )}
+                <span className="ssh-optional-hint">
+                  {autoConnectEligible
+                    ? t("remoteConnect.autoConnectHintEligible")
+                    : autoConnectBlock === "hpc"
+                      ? t("autoConnect.hpcTitle")
+                      : t("remoteConnect.autoConnectHintNotEligible")}
+                </span>
+              </label>
+              {/* Auto-connect never prompts — so if it can reach for the VPN, this
+                  line is the user's only chance to know that launching Eldrun may
+                  reroute their machine before they've clicked anything. */}
+              {autoConnectEligible && autoConnect && vpnEnabled && (
+                <div className="remote-connect-vpn-warning">
+                  {t("remoteConnect.autoConnectVpnWarningPre")}{" "}
+                  <strong>{t("remoteConnect.autoConnectVpnWarningStrong")}</strong>{" "}
+                  {t("remoteConnect.autoConnectVpnWarningPost")}
+                </div>
+              )}
+              {sshStatus === "error" && sshError && (
+                <div className="project-dialog-error">{sshError}</div>
+              )}
+            </>
+          ) : winManual ? (
+            // Windows has no ControlMaster socket to ride an interactive login,
+            // so fall back to the headless-style key-auth connect.
+            <div className="dialog-connect">
+              <button
+                type="button"
+                className="dialog-connect-btn"
+                disabled={connecting || connected}
+                onClick={() => void connectSshHeadless("")}
+              >
+                {connected ? t("remoteConnect.connectedState") : connecting ? t("vpnPrompt.connecting") : t("common.connect")}
+              </button>
+              {connecting && (
+                <button
+                  type="button"
+                  className="vpn-disconnect-btn"
+                  title={t("remoteConnect.sshStopTitle")}
+                  onClick={stopSsh}
+                >
+                  {t("vpnPrompt.stop")}
+                </button>
+              )}
+              {sshStatus === "error" && sshError && (
+                <div className="project-dialog-error">{sshError}</div>
+              )}
+            </div>
+          ) : (
+            <div className="dialog-connect">
+              <button
+                type="button"
+                className="dialog-connect-btn"
+                disabled={!!sshTerm}
+                title={t("remoteConnect.sshTermBtnTitle")}
+                onClick={() => void startSshTerm()}
+              >
+                <span className="dialog-connect-btn-icon" aria-hidden="true">▶_</span>
+                {sshTerm ? t("remoteConnect.sshTermOpenBelow") : t("remoteConnect.sshTermOpenBtn")}
+              </button>
+              {sshTerm && !connected && (
+                <button
+                  type="button"
+                  className="dialog-connect-btn"
+                  title={t("remoteConnect.tryConnectTitle")}
+                  onClick={tryConnectNow}
+                >
+                  {t("remoteConnect.tryConnectBtn")}
+                </button>
+              )}
+              {sshTerm && (
+                <div className="dialog-connect-terminal">
+                  <div className="dialog-connect-terminal-bar">
+                    <span className="ssh-optional-hint">
+                      {t("remoteConnect.sshTermHint")}
+                    </span>
+                    <button type="button" className="vpn-disconnect-btn" onClick={stopSsh}>
+                      {t("remoteConnect.disconnect")}
+                    </button>
+                  </div>
+                  <CredentialPasteBar ptyId={sshTerm.id} entries={sshPaste} />
+                  <div className="dialog-connect-terminal-host">
+                    <TerminalView
+                      id={sshTerm.id}
+                      cmd=""
+                      cwd=""
+                      initialInput={sshTerm.adopted ? undefined : sshTerm.command}
+                      attachOnly={sshTerm.adopted}
+                      visible
+                      focused
+                      persistOnUnmount
+                    />
+                  </div>
+                </div>
+              )}
+              {/* Auto-connect, non-headless flavour. It is offered here with no
+                  eligibility gate because there is nothing to be eligible against:
+                  Eldrun holds no passwords in this mode, so "connect on launch" means
+                  this same login opens in the root terminal for you to authenticate —
+                  the substitution `autoConnectInteractive` (stores/projects) makes,
+                  and the one the header's "Connect on launch" already makes for a
+                  tunnel. */}
+              {/* Ungated *except* for the HPC tag, which is not a credential
+                  question: a tagged host is never dialled unattended at all, so
+                  even the "the login opens in the root terminal for you" flavour
+                  of auto-connect has nothing to open. */}
+              <label
+                className="remote-connect-remember"
+                title={
+                  autoConnectBlock === "hpc"
+                    ? t("autoConnect.hpcTitle")
+                    : t("remoteConnect.autoConnectInteractiveTitle")
+                }
+              >
+                <Toggle
+                  size="sm"
+                  checked={autoConnect && autoConnectEligible}
+                  disabled={!autoConnectEligible}
+                  onChange={(e) => setAutoConnect(e.target.checked)}
+                />
+                {t("remoteConnect.autoConnectLabel")}
+                {autoConnectBlock === "hpc" && (
+                  <span className="machines-auto-blocked"> {t("autoConnect.offWhileHpc")}</span>
+                )}
+                <UntestedTag />
+                <span className="ssh-optional-hint">
+                  {autoConnectBlock === "hpc"
+                    ? t("autoConnect.hpcTitle")
+                    : t("remoteConnect.autoConnectInteractiveHint")}
+                </span>
+              </label>
+            </div>
+          )}
+          {/* Outside the branch above, for the same reason the VPN one is: it is both
+              the way into the terminal login and the only way back out once that
+              terminal has been disconnected. */}
+          {headless && (sshViaTerminal || !!sshTerm) && sshSaveRow}
+          {headless && !winManual && (
+            <TerminalSignInToggle
+              channel="ssh"
+              checked={sshViaTerminal}
+              busy={!!sshTerm}
+              failed={sshStatus === "error"}
+              onChange={setSshViaTerminal}
+            />
+          )}
+          {/* Outside the headless/non-headless branches, like the two rows above:
+              how gently to treat a machine is a property of the machine, not of how
+              you happen to log into it. Whichever host this dialog is showing —
+              the project's primary or one of its workers — gets its own answer,
+              because a login node and the compute node behind it are not the same
+              kind of machine even when they belong to the same cluster. */}
+          <CarefulHostToggle target={carefulTarget} />
+          {/* The stronger statement about the same machine: careful is how much
+              Eldrun reads, this is what it is allowed to do (`lib/hpcHost.ts`). */}
+          <HpcHostToggle target={carefulTarget} />
+        </div>
+
+        <div className="project-dialog-actions">
+          {/* Shown whenever *either* channel is up or coming up — a tunnel that came
+              up while SSH stayed down still has to be teardownable, and gating this
+              on SSH alone left exactly that state with no way out. */}
+          {(sshStatus !== "off" || vpnStatus !== "off") && (
+            <button
+              type="button"
+              onClick={() => {
+                // Cancellation-aware teardown of both channels (abandons an
+                // in-flight connect too, not just a live pool), then mirror it into
+                // the projects store so a switch-away can't resurrect the pool.
+                stopSsh();
+                if (vpnConfig) stopVpn();
+                disconnectRemote(project.id);
+                close();
+              }}
+            >
+              {t("remoteConnect.disconnect")}
+            </button>
+          )}
+          {/* Explicitly confirmed teardown. A plain Disconnect also ends tmux
+              sessions; this variant retains the extra confirmation affordance. */}
+          {sshStatus === "connected" &&
+            (killArm ? (
+              <button
+                type="button"
+                className="vpn-disconnect-btn"
+                title={t("remoteConnect.killConfirmTitle")}
+                onClick={() => {
+                  setKillArm(false);
+                  void invoke("remote_kill_all_jobs", killTarget).catch(() => {});
+                  stopSsh();
+                  if (vpnConfig) stopVpn();
+                  disconnectRemote(project.id);
+                  close();
+                }}
+              >
+                {t("remoteConnect.killConfirmBtn")}
+              </button>
+            ) : (
+              <button
+                type="button"
+                title={t("remoteConnect.killArmTitle")}
+                onClick={() => setKillArm(true)}
+              >
+                {t("remoteConnect.killArmBtn")}
+                <UntestedTag />
+              </button>
+            ))}
+          {/* Only offered when there is something to forget — the keychain state
+              (queried on mount) is the source of truth, not the toggles. Stays
+              open afterwards so the emptied "Save password" toggles are visible
+              and the user can reconnect with a fresh password right here. */}
+          {(sshSaved || vpnSaved) && (
+            <button
+              type="button"
+              title={t("remoteConnect.forgetPasswordTitle")}
+              onClick={() => void forgetPasswords()}
+            >
+              {t("remoteConnect.forgetPasswordBtn")}
+            </button>
+          )}
+          <button type="button" onClick={close}>{t("common.close")}</button>
+        </div>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/projects/RemoteFolderBrowser.tsx b/src/components/projects/RemoteFolderBrowser.tsx
new file mode 100644
index 0000000..8636806
--- /dev/null
+++ b/src/components/projects/RemoteFolderBrowser.tsx
@@ -0,0 +1,144 @@
+import { useState, type ReactNode } from "react";
+import { Dropdown } from "../common/Dropdown";
+import { fileIcon, folderIcon } from "../../lib/viewers/fileUtils";
+import type { RemoteEntry } from "../../types";
+import { useT } from "../../lib/i18n";
+
+/** Extension (".py", ".md", …) of a remote listing entry, for picking its
+ *  file-type icon the same way the right-hand file tree does. A leading-dot
+ *  name (e.g. ".gitignore") has no extension, so it falls back to the generic
+ *  file icon. Shared by every remote folder picker. */
+export function remoteEntryExt(name: string): string | null {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot) : null;
+}
+
+/**
+ * The live remote folder picker (`.remote-browser` chrome): a breadcrumb + go-up
+ * + recently-used jump, an inline "new folder" entry, the directory listing, and
+ * a footer. It owns only the new-folder input's transient text; every other bit
+ * of state (path, entries, busy/error) is the caller's, so the SAME browser
+ * serves the new/extend project flow (`RemoteProjectSection`, over
+ * `useRemoteSession`) and the add-worker-machine flow (`RemoteMachinesWindow`,
+ * over one-shot SFTP) with no duplicated markup.
+ */
+export function RemoteFolderBrowser({
+  path,
+  entries,
+  busy,
+  error,
+  recentPaths,
+  onGoUp,
+  onJumpPath,
+  onEnterFolder,
+  onUseFolder,
+  onCreateFolder,
+  footer,
+  useFolderLabel,
+}: {
+  path: string;
+  entries: RemoteEntry[];
+  busy: boolean;
+  error: string;
+  recentPaths: string[];
+  onGoUp: () => void;
+  onJumpPath: (p: string) => void;
+  onEnterFolder: (entry: RemoteEntry) => void;
+  onUseFolder: () => void;
+  onCreateFolder: (name: string) => void;
+  /** The `.remote-chosen` footer line — a "Will create: …" summary in the
+   *  project flow, a plain hint in the add-machine flow. */
+  footer: ReactNode;
+  useFolderLabel?: string;
+}) {
+  const t = useT();
+  const [newFolderName, setNewFolderName] = useState("");
+  const submitNewFolder = () => {
+    const name = newFolderName.trim();
+    if (!name) return;
+    onCreateFolder(name);
+    setNewFolderName("");
+  };
+
+  return (
+    <div className="remote-browser" role="group" aria-label={t("remoteBrowser.ariaLabel")}>
+      <div className="remote-browser-header">
+        <button type="button" className="remote-up-btn" onClick={onGoUp} title={t("remoteBrowser.goUp")}>
+          ..
+        </button>
+        <span className="remote-breadcrumb" title={path}>
+          {path || "/"}
+        </span>
+        {recentPaths.length > 0 && (
+          <Dropdown
+            className="vpn-config-recent"
+            value=""
+            placeholder={t("remoteBrowser.recentlyUsed")}
+            title={t("remoteBrowser.jumpTitle")}
+            onChange={(v) => {
+              if (v) onJumpPath(v);
+            }}
+            options={recentPaths.map((p) => ({ value: p, label: p }))}
+          />
+        )}
+        <button type="button" onClick={onUseFolder}>
+          {useFolderLabel ?? t("remoteBrowser.useThisFolder")}
+        </button>
+      </div>
+      <div className="remote-newfolder">
+        <input
+          type="text"
+          className="remote-newfolder-input"
+          placeholder={t("remoteBrowser.newFolderPlaceholder")}
+          value={newFolderName}
+          onChange={(e) => setNewFolderName(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              submitNewFolder();
+            }
+          }}
+          disabled={busy}
+        />
+        <button
+          type="button"
+          onClick={submitNewFolder}
+          disabled={busy || !newFolderName.trim()}
+          title={t("remoteBrowser.addFolderTitle")}
+        >
+          {t("remoteBrowser.addFolder")}
+        </button>
+      </div>
+      <div className="remote-list">
+        {busy && <div className="scaffold-empty">{t("remoteBrowser.listing")}</div>}
+        {!busy && error && <div className="project-dialog-error">{error}</div>}
+        {!busy && !error && entries.length === 0 && (
+          <div className="scaffold-empty">{t("remoteBrowser.emptyFolder")}</div>
+        )}
+        {!busy &&
+          !error &&
+          entries.map((entry) => (
+            <div
+              key={entry.name}
+              className={`remote-entry ${entry.is_dir ? "is-dir" : "is-file"}`}
+              role={entry.is_dir ? "button" : undefined}
+              tabIndex={entry.is_dir ? 0 : undefined}
+              onClick={() => onEnterFolder(entry)}
+              onKeyDown={(e) => {
+                if (entry.is_dir && (e.key === "Enter" || e.key === " ")) {
+                  e.preventDefault();
+                  onEnterFolder(entry);
+                }
+              }}
+            >
+              <span className="remote-entry-icon file-icon">
+                {entry.is_dir ? folderIcon() : fileIcon(remoteEntryExt(entry.name))}
+              </span>
+              <span className="remote-entry-name">{entry.name}</span>
+            </div>
+          ))}
+      </div>
+      <div className="remote-chosen">{footer}</div>
+    </div>
+  );
+}
diff --git a/src/components/projects/RemoteMachinesWindow.tsx b/src/components/projects/RemoteMachinesWindow.tsx
new file mode 100644
index 0000000..fd1368f
--- /dev/null
+++ b/src/components/projects/RemoteMachinesWindow.tsx
@@ -0,0 +1,1184 @@
+import { useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { parseSshAddress, type ParsedSshAddress } from "./scaffold";
+import { RemoteFolderBrowser } from "./RemoteFolderBrowser";
+import { useRemoteBrowse } from "./useRemoteBrowse";
+import { TerminalSignInToggle } from "./TerminalSignInToggle";
+import { SavePasswordRow } from "./SavePasswordRow";
+import { rememberArg, useSavedCredential } from "./useSavedCredential";
+import { CredentialPasteBar, sshPasteEntries } from "./CredentialPasteBar";
+import { TerminalView } from "../terminal/TerminalView";
+import { forgetConnection, markConnectionOpened, resolveRemoteStartDir } from "../../lib/remoteConnect";
+import { withHostKeyConfirm } from "../../lib/hostKey";
+import { sameTarget } from "../../lib/machineSync";
+import { useConnectDialogStore } from "../../stores/connectDialog";
+import { useGlobalMachinesStore } from "../../stores/globalMachines";
+import { useRemoteStatusStore, PRIMARY_HOST, type ConnState } from "../../stores/remoteStatus";
+import { useRemoteMachinesStore } from "../../stores/remoteMachines";
+import { useHostBusyStore, busyReading, busyLabel } from "../../stores/hostBusy";
+import { ConnLamp } from "../common/ConnLamp";
+import { Toggle } from "../common/Toggle";
+import { PasswordInput } from "../common/PasswordInput";
+import { UntestedTag } from "../common/UntestedTag";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { formatRemoteTarget, resolveLocalMirror } from "../../types";
+import type { ComputeHost, GlobalMachine, ProjectEntry } from "../../types";
+import { useT } from "../../lib/i18n";
+
+/** Distinct PTY id per login terminal opened here — the id is the handle
+ *  `pty_kill` and the output stream use, so it must never be reused. */
+let machineTermSeq = 0;
+const nextMachineTermId = () => `machines-ssh-${++machineTermSeq}`;
+
+/**
+ * Mounted once (AppShell). Renders the "Remote machines" manager for whichever
+ * remote project the `useRemoteMachinesStore` points at — opened from the pill's
+ * Runtime menu item and from a right-click on the pill's remote lamp. Keyed by
+ * project id so it re-seeds when the target changes.
+ */
+export function RemoteMachinesDialogHost() {
+  const projectId = useRemoteMachinesStore((s) => s.projectId);
+  const close = useRemoteMachinesStore((s) => s.close);
+  const project = useProjectsStore((s) =>
+    projectId ? s.projects.find((p) => p.id === projectId) : undefined,
+  );
+  if (!projectId || !project?.remote) return null;
+  return <RemoteMachinesWindow key={project.id} project={project} onClose={close} />;
+}
+
+/** The `worker-sync-report` event the backend emits after a code fan-out. */
+interface WorkerSyncReport {
+  project_id: string;
+  host_id: string;
+  head?: string;
+  ok: boolean;
+  skipped: boolean;
+  error?: string;
+}
+
+/**
+ * The pill's "Remote machines…" manager (`docs/multi_host_remote_plan.md` §4.4):
+ * list the project's extra worker hosts, add a new one, connect each, push code,
+ * pull outputs, and toggle per-worker settings. The primary remote stays the
+ * project's own `remote` — this manages ONLY the workers, which are one-way,
+ * read-only experiment machines.
+ *
+ * A remote project only. Rendered as a centered modal like ContainerSettings.
+ */
+export function RemoteMachinesWindow({
+  project,
+  onClose,
+}: {
+  project: ProjectEntry;
+  onClose: () => void;
+}) {
+  const t = useT();
+  const workers = project.compute_hosts ?? [];
+  const openConnect = useConnectDialogStore((s) => s.open);
+  const byHost = useRemoteStatusStore((s) => s.byHost[project.id]);
+  // The primary host's live SSH state (multi-host remote keeps the primary in
+  // `byProject`, workers in `byHost`) — drives the primary entry's lamp/action.
+  const primary = useRemoteStatusStore((s) => s.byProject[project.id]);
+  const readings = useHostBusyStore((s) => s.readings);
+
+  // Sweep every CONNECTED host for live tmux sessions when this hub opens, so
+  // each card's lamp says whether that machine is merely reachable or actually
+  // working (`stores/hostBusy`). On-open only, never polled — one SSH round trip
+  // per connected host, riding the pool that is already up. A disconnected host
+  // is skipped: it has nothing to ask, and asking would dial it just to fail.
+  const primarySsh = primary?.ssh ?? "off";
+  const connectedKey = [
+    primarySsh === "connected" ? "primary" : "",
+    ...workers.filter((w) => (byHost?.[w.id]?.ssh ?? "off") === "connected").map((w) => w.id),
+  ]
+    .filter(Boolean)
+    .join("|");
+  useEffect(() => {
+    const probe = useHostBusyStore.getState().probeProjectHost;
+    if (primarySsh === "connected" && project.remote) {
+      void probe(project.id, PRIMARY_HOST, project.remote);
+    }
+    for (const w of workers) {
+      if ((byHost?.[w.id]?.ssh ?? "off") === "connected") void probe(project.id, w.id, w);
+    }
+    // Re-sweeps when the set of connected hosts changes (one just connected), not
+    // on every unrelated re-render of this dialog.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [project.id, connectedKey]);
+
+  // Patch the project's `compute_hosts` in the store from a CRUD command's return
+  // value — cheaper and side-effect-free vs a full project reload.
+  const applyHosts = (hosts: ComputeHost[]) => {
+    useProjectsStore.setState((s) => ({
+      projects: s.projects.map((p) =>
+        p.id === project.id ? { ...p, compute_hosts: hosts } : p,
+      ),
+    }));
+  };
+
+  // ── Global machine handed to this project (from MachinesIndicator) ────────
+  // The header's Machines menu picked this project in its "add to a project"
+  // list, which opened this window pre-seeded with the machine. Only the shared
+  // path is asked — everything else came with the machine — and the result is
+  // always a shared-filesystem worker (no copy, no git), added and connected
+  // exactly like the manual "Add a machine" flow.
+  const pendingDrop = useRemoteMachinesStore((s) => s.pendingDrop);
+  const setPendingDrop = useRemoteMachinesStore((s) => s.setPendingDrop);
+  const [dropPath, setDropPath] = useState(project.remote?.remote_path ?? "");
+  const [dropBusy, setDropBusy] = useState(false);
+  const [dropError, setDropError] = useState("");
+  // The dropped machine's lamp used to be hardcoded `connected` — it is a global
+  // machine, so it *usually* is, but "usually" is not a status. Before the add it
+  // reads the machine's real state from the global list; during/after the add it
+  // reads this dialog's own attempt, which is the thing the user is watching.
+  const dropMachineId = pendingDrop?.id;
+  const globalStatus = useGlobalMachinesStore((s) =>
+    dropMachineId ? s.status[dropMachineId] : undefined,
+  );
+  const [dropConn, setDropConn] = useState<ConnState | null>(null);
+  // The panel is rendered above the worker list, so a machine picked from the
+  // list *inside* the add-form below would otherwise land off screen.
+  const dropPanelRef = useRef<HTMLDivElement | null>(null);
+  useEffect(() => {
+    if (dropMachineId) dropPanelRef.current?.scrollIntoView({ block: "nearest" });
+  }, [dropMachineId]);
+
+  // ── The global machines list, as a fast path into "Add a machine" ────────────
+  // The header's Machines menu could already hand one of these to a project, but
+  // only from the *other* end — standing in this dialog, a machine that is already
+  // set up and authenticated still had to be retyped and logged into by hand. So
+  // the same list is offered here: pick a machine, confirm its path, done.
+  const globalMachines = useGlobalMachinesStore((s) => s.machines);
+  const globalStatuses = useGlobalMachinesStore((s) => s.status);
+  const globalsLoaded = useGlobalMachinesStore((s) => s.loaded);
+  useEffect(() => {
+    // This window can be the first thing that needs the list (the header menu may
+    // never have been opened this session), and `load` only reads the JSON file.
+    if (!globalsLoaded) void useGlobalMachinesStore.getState().load();
+  }, [globalsLoaded]);
+
+  const addDroppedMachine = async () => {
+    if (!pendingDrop) return;
+    const path = dropPath.trim();
+    if (!path.startsWith("/")) {
+      setDropError(t("remoteMachines.enterAbsolutePath"));
+      return;
+    }
+    setDropBusy(true);
+    setDropError("");
+    const beforeIds = new Set(workers.map((w) => w.id));
+    const host: ComputeHost = {
+      id: "",
+      label: pendingDrop.label,
+      user: pendingDrop.user,
+      host: pendingDrop.host,
+      port: pendingDrop.port,
+      remote_path: path,
+      shared_fs: true,
+      sync_code: false,
+      pull_outputs: false,
+    };
+    try {
+      const hosts = await invoke<ComputeHost[]>("add_compute_host", {
+        projectId: project.id,
+        host,
+      });
+      applyHosts(hosts);
+      const added = hosts.find((h) => !beforeIds.has(h.id));
+      // The global machine is already authenticated, so this rides the same saved
+      // keychain credential (or key/agent auth) with no prompt.
+      // `viaLogin`: riding *that* master is exactly why it needs no credential, so
+      // the success must not be recorded as key auth (`record_key_auth`, backend).
+      // `background: false`: the user clicked Add, and `remote_connect` now defaults
+      // to background — which a host tagged HPC refuses outright.
+      //
+      // No longer `.catch(() => {})`. Swallowing this left a card whose lamp said
+      // connected while nothing was pooled behind it, and the "the card's own
+      // Connect still works" excuse only holds if the user is told to use it.
+      if (added) {
+        setDropConn("connecting");
+        void withHostKeyConfirm(() =>
+          invoke("remote_connect", {
+            projectId: project.id,
+            hostId: added.id,
+            viaLogin: true,
+            background: false,
+          }),
+        )
+          .then(() => {
+            setDropConn(null);
+            useRemoteStatusStore.getState().setSsh(project.id, "connected", added.id);
+            // Only now is the panel done: the machine is added *and* live, and its
+            // own worker card below takes over the lamp.
+            setPendingDrop(null);
+          })
+          .catch((e) => {
+            setDropConn("error");
+            useRemoteStatusStore.getState().setSsh(project.id, "error", added.id);
+            setDropError(t("remoteMachines.dropConnectFailed", { error: String(e) }));
+          });
+      } else {
+        setPendingDrop(null);
+      }
+      setDropPath(project.remote?.remote_path ?? "");
+    } catch (e) {
+      setDropError(String(e));
+    } finally {
+      setDropBusy(false);
+    }
+  };
+
+  // Add-machine form. A new machine defaults to a SHARED-FILESYSTEM host (no copy,
+  // shells run in the primary's shared folder); tick "Sync a copy" to make it the
+  // synced-copy worker instead. The path defaults to the primary's own remote path,
+  // since on a shared filesystem the folder is usually at the same place.
+  const [address, setAddress] = useState("");
+  const [username, setUsername] = useState("");
+  const [remotePath, setRemotePath] = useState(project.remote?.remote_path ?? "");
+  const [label, setLabel] = useState("");
+  const [syncCopy, setSyncCopy] = useState(false);
+  const [addError, setAddError] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  // ── Connect-then-browse folder picker (same machinery as extend-to-remote) ──
+  // Rather than typing the path blind, the user can connect to the machine and
+  // browse its filesystem to the target folder — for a shared-fs worker that is
+  // the existing primary folder; for a synced copy it's where the copy should go
+  // (and can be created here). Uses the one-shot SFTP commands (`ssh_connect` to
+  // validate + warm the ControlMaster, then `ssh_list_dir`/`ssh_mkdir`), so it
+  // needs no pooled worker connection first. The password is transient — used
+  // only for this browse, never persisted (the worker's real connect, and its
+  // "Save password", live in the shared Connect modal opened later).
+  const [browsePassword, setBrowsePassword] = useState("");
+  // "Save password" opt-in (default off, matching the no-storage-by-default
+  // policy). When on, the login below persists the SSH password to the OS
+  // keychain via `ssh_connect`'s `remember` flag — keyed by host target, so the
+  // machine's own Connect modal (RemoteConnectDialog) finds it and never asks.
+  // `savedPw` reflects the keychain and pre-ticks the box so an untick is a
+  // deliberate delete, never an accidental clear of another menu's credential.
+  const [savePassword, setSavePassword] = useState(false);
+  // The connect + browse mechanism is the SHARED one (`useRemoteBrowse`), the same
+  // the primary machine's new/extend flow uses — this dialog only wraps its own
+  // fields around it. `browsing` is a view flag on top (whether the folder panel is
+  // expanded), distinct from `browse.conn` (whether a live session exists).
+  const browse = useRemoteBrowse();
+  const [browsing, setBrowsing] = useState(false);
+  // ── "Sign in in a terminal" (see `TerminalSignInToggle`) ─────────────────────
+  // This form only ever had the password field, in *both* modes — so a host that
+  // asks anything else (a challenge code, a one-time code, a second prompt) could
+  // not be added at all, and a `connections_headless: false` user was asked for a
+  // password their mode says Eldrun should never handle. The terminal login fixes
+  // both, which is why the switch **defaults to on in non-headless mode**: there it
+  // is the mode, and only here was it missing.
+  const headless = useSettingsStore((s) => s.settings?.connections_headless ?? true);
+  const [viaTerminal, setViaTerminal] = useState(!headless);
+  const [loginTerm, setLoginTerm] = useState<{ id: string; command: string; key: string } | null>(
+    null,
+  );
+  const loginPoll = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const [browseConnecting, setBrowseConnecting] = useState(false);
+  const [browsePaths, setBrowsePaths] = useState<string[]>([]);
+
+  // Editing the address after opening the browser invalidates the frozen
+  // connection it lists over — close it so a stale listing can't be trusted.
+  const onAddressChange = (v: string) => {
+    setAddress(v);
+    if (browsing) setBrowsing(false);
+    browse.reset();
+    // A login terminal is bound to the target it was opened for; keeping it across
+    // an address edit would leave the next browse riding the wrong host's master.
+    stopLoginTerm();
+  };
+
+  // The login target: parse the address, then take the username from the
+  // dedicated field when the address didn't inline a `user@` (the inline form
+  // still wins, so a full `me@box` address keeps working).
+  const parseTarget = (): ParsedSshAddress | null => {
+    const parsed = parseSshAddress(address);
+    if (!parsed) return null;
+    return { ...parsed, user: parsed.user ?? (username.trim() || null) };
+  };
+
+  // Reflect the keychain: when the typed target already has a saved password,
+  // say so and pre-tick "Save password" (so the box mirrors reality and an
+  // untick reads as a deliberate delete). The credential is keyed by host
+  // target and shared across every remote menu.
+  //
+  // The shared tri-state hook, not a boolean — a locked keychain answers a lookup
+  // exactly like an empty one, so `.catch(() => false)` here reported "nothing
+  // saved" for a credential that was sitting right there (`useSavedCredential`).
+  const parsedTarget = parseTarget();
+  const credential = useSavedCredential(
+    parsedTarget
+      ? { user: parsedTarget.user, host: parsedTarget.host, port: parsedTarget.port }
+      : null,
+  );
+  const savedPw = credential.saved;
+  useEffect(() => setSavePassword(savedPw), [savedPw]);
+
+  const startBrowse = async () => {
+    const parsed = parseTarget();
+    if (!parsed) {
+      setAddError(t("remoteMachines.enterHostBeforeBrowsing"));
+      return;
+    }
+    setAddError("");
+    browse.setError("");
+    setBrowseConnecting(true);
+    const password = browsePassword ? browsePassword : null;
+    try {
+      // The shared connect: validate the credential + warm the ControlMaster (a
+      // key-auth host connects with a null password), remember the working password
+      // only on success (keyed by host target, so the machine's own Connect finds
+      // it), then open the start dir. Seed the browse at the current path field —
+      // which defaults to the primary machine's project path — so the picker opens
+      // there *on the new machine* (usually the same shared folder) rather than at
+      // this host's home; a synced-copy worker whose folder doesn't exist yet can
+      // navigate up from it. The listing refreshes itself.
+      const outcome = await browse.connect({
+        target: parsed,
+        password,
+        // `true` or `null` — never `false`, which would *clear* the credential this
+        // very connect may have authenticated with (`rememberArg`).
+        remember: rememberArg(savePassword),
+        startPath: remotePath.trim() || null,
+      });
+      // What the backend actually did, not what the box asked for.
+      credential.applyOutcome(outcome);
+      setBrowsing(true);
+      invoke<string[]>("remote_list_paths", { host: parsed.host })
+        .then(setBrowsePaths)
+        .catch(() => setBrowsePaths([]));
+    } catch (e) {
+      browse.setError(String(e));
+    } finally {
+      setBrowseConnecting(false);
+    }
+  };
+
+  // ── The terminal login, and the poll that turns it into a browsable session ──
+  // Eldrun sees no password here: the user authenticates in the terminal below, and
+  // the only signal is that the login's **ControlMaster** has come up — at which
+  // point a credential-less `ssh_connect` starts succeeding and rides it. That is
+  // exactly what `browse.openSession` is for: freeze the session somebody else
+  // authenticated, no second login. Bounded (~2 min), because a login the user never
+  // completes must stop polling rather than spin for the life of the window.
+  const clearLoginPoll = () => {
+    if (loginPoll.current) {
+      clearTimeout(loginPoll.current);
+      loginPoll.current = null;
+    }
+  };
+  const pollLoginReady = (parsed: ParsedSshAddress, attempt = 0) => {
+    const maxAttempts = 40; // ~2 min at 3s cadence
+    void invoke<void>("ssh_connect", {
+      user: parsed.user,
+      host: parsed.host,
+      port: parsed.port,
+      password: null,
+      // Credential-less, so the dial policy can't distinguish this from a sweep —
+      // but it is waiting on a master the user just authenticated in the terminal
+      // below. Unsaid, a host tagged HPC refuses every attempt.
+      background: false,
+    })
+      .then(async () => {
+        clearLoginPoll();
+        setBrowseConnecting(false);
+        // Same seed the password path uses: the primary's project path *on this
+        // machine* (usually the same shared folder), else the host's default.
+        const startDir =
+          remotePath.trim() ||
+          (await resolveRemoteStartDir(parsed.user, parsed.host, parsed.port, null));
+        browse.openSession(parsed, "", startDir);
+        setBrowsing(true);
+        invoke<string[]>("remote_list_paths", { host: parsed.host })
+          .then(setBrowsePaths)
+          .catch(() => setBrowsePaths([]));
+      })
+      .catch(() => {
+        if (attempt + 1 >= maxAttempts) {
+          clearLoginPoll();
+          setBrowseConnecting(false);
+          // Say so. Running out silently left the button back on "I've logged in —
+          // browse" with nothing explaining why the first two minutes produced
+          // nothing, which reads as the app having simply stopped.
+          setAddError(t("remoteLogin.pollGaveUp"));
+          return;
+        }
+        loginPoll.current = setTimeout(() => pollLoginReady(parsed, attempt + 1), 3000);
+      });
+  };
+
+  const startLoginTerm = async () => {
+    if (loginTerm) return;
+    const parsed = parseTarget();
+    if (!parsed) {
+      setAddError(t("remoteMachines.enterHostBeforeLogin"));
+      return;
+    }
+    setAddError("");
+    browse.setError("");
+    try {
+      const command = await invoke<string>("remote_login_command", {
+        user: parsed.user,
+        host: parsed.host,
+        port: parsed.port,
+      });
+      // Pre-mark the activation dedupe key this login satisfies, so the project's
+      // own root-terminal login isn't opened a second time for the same target.
+      const target = `${parsed.user ? `${parsed.user}@` : ""}${parsed.host}`;
+      const key = `ssh:${target}:${parsed.port ?? ""}`;
+      markConnectionOpened(key);
+      setLoginTerm({ id: nextMachineTermId(), command, key });
+      setBrowseConnecting(true);
+      pollLoginReady(parsed);
+    } catch (e) {
+      setAddError(String(e));
+    }
+  };
+
+  /** Re-arm the readiness poll — for a login finished after the bound ran out. */
+  const retryLoginBrowse = () => {
+    const parsed = parseTarget();
+    if (!parsed) return;
+    clearLoginPoll();
+    setBrowseConnecting(true);
+    pollLoginReady(parsed);
+  };
+
+  // Killing the login drops the ControlMaster every browse here rides, so this
+  // returns the form to its logged-out state rather than leaving a listing that
+  // nothing is behind.
+  const stopLoginTerm = () => {
+    clearLoginPoll();
+    setBrowseConnecting(false);
+    if (!loginTerm) return;
+    void invoke("pty_kill", { id: loginTerm.id }).catch(() => {});
+    forgetConnection(loginTerm.key);
+    setLoginTerm(null);
+  };
+
+  // The window can be closed (or re-keyed to another project) mid-poll; the PTY is
+  // deliberately left running — the ControlMaster it holds is the machine's — but a
+  // timer firing into an unmounted component is nobody's.
+  useEffect(() => clearLoginPoll, []);
+
+  const useBrowsedFolder = () => {
+    setRemotePath(browse.path || "/");
+    setBrowsing(false);
+  };
+
+  // ── The two ways a global machine enters this project ────────────────────────
+  // Both start from the same row in the list below the "Add a machine" title.
+  //
+  // `quickAddGlobal` is the fast one: a global machine is already a working login
+  // (it was authenticated when it was added, and the credential is keyed by SSH
+  // target), so the only thing this project still needs from it is *where* the
+  // shared folder is — which is exactly the panel the header menu's handoff
+  // seeds. Reusing `pendingDrop` means the add + connect is the one already-proven
+  // path, not a second copy of it.
+  //
+  // `fillFromGlobal` is the full one: the machine's address goes into the form, so
+  // the folder can be browsed and "Sync a copy" chosen — everything the fast path
+  // deliberately fixes at "shared filesystem, path you confirm".
+  const quickAddGlobal = (m: GlobalMachine) => {
+    setDropError("");
+    // A lamp left red by a previous attempt is not this machine's status.
+    setDropConn(null);
+    setDropPath(project.remote?.remote_path ?? "");
+    setPendingDrop({ id: m.id, host: m.host, user: m.user, port: m.port, label: m.label });
+  };
+
+  const fillFromGlobal = (m: GlobalMachine) => {
+    // Via `onAddressChange`, so a browse/login already open for another host is
+    // dropped rather than left listing the wrong machine.
+    onAddressChange(m.port ? `${m.host}:${m.port}` : m.host);
+    setUsername(m.user ?? "");
+    setLabel(m.label ?? "");
+    setAddError("");
+  };
+
+  /** Already this project's primary or one of its workers — matched by SSH
+   *  target, never by id (a project host is a copy by value; `lib/machineSync`).
+   *  Such a row offers no action: adding the same machine twice would give it two
+   *  cards, two lamps and two sync paths for one host. */
+  const alreadyAHost = (m: GlobalMachine) =>
+    (project.remote ? sameTarget(project.remote, m) : false) ||
+    workers.some((w) => sameTarget(w, m));
+
+  // "Change…" after a successful login — drop the frozen connection so the
+  // address/password step comes back and a fresh login can be made.
+  const logout = () => {
+    setBrowsing(false);
+    browse.reset();
+    stopLoginTerm();
+    setRemotePath(project.remote?.remote_path ?? "");
+  };
+
+  // Last sync report per host (for the "last synced" line).
+  const [reports, setReports] = useState<Record<string, WorkerSyncReport>>({});
+  useEffect(() => {
+    let un: (() => void) | undefined;
+    let cancelled = false;
+    void listen<WorkerSyncReport>("worker-sync-report", (ev) => {
+      if (ev.payload.project_id !== project.id) return;
+      setReports((prev) => ({ ...prev, [ev.payload.host_id]: ev.payload }));
+    }).then((u) => {
+      if (cancelled) u();
+      else un = u;
+    });
+    return () => {
+      cancelled = true;
+      un?.();
+    };
+  }, [project.id]);
+
+  const addMachine = async () => {
+    const parsed = parseTarget();
+    if (!parsed) {
+      setAddError(t("remoteMachines.enterHost"));
+      return;
+    }
+    const path = remotePath.trim();
+    if (!path.startsWith("/")) {
+      setAddError(t("remoteMachines.enterAbsolutePath"));
+      return;
+    }
+    setBusy(true);
+    setAddError("");
+    const host: ComputeHost = {
+      id: "", // backend mints one
+      label: label.trim() || undefined,
+      user: parsed.user ?? undefined,
+      host: parsed.host,
+      port: parsed.port ?? undefined,
+      remote_path: path,
+      // Default: shared filesystem (no copy). "Sync a copy" opts into a synced
+      // worker that keeps its own tracked tree at the primary's HEAD.
+      shared_fs: !syncCopy,
+      sync_code: syncCopy,
+      pull_outputs: false,
+    };
+    try {
+      const hosts = await invoke<ComputeHost[]>("add_compute_host", {
+        projectId: project.id,
+        host,
+      });
+      applyHosts(hosts);
+      setAddress("");
+      setUsername("");
+      setRemotePath(project.remote?.remote_path ?? "");
+      setLabel("");
+      setSyncCopy(false);
+      setBrowsePassword("");
+      setBrowsing(false);
+      browse.reset();
+    } catch (e) {
+      setAddError(String(e));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const removeMachine = async (hostId: string) => {
+    // Disconnect it first (best effort), then drop it.
+    await invoke("remote_disconnect", { projectId: project.id, hostId }).catch(() => {});
+    useRemoteStatusStore.getState().clearHost(project.id, hostId);
+    const hosts = await invoke<ComputeHost[]>("remove_compute_host", {
+      projectId: project.id,
+      hostId,
+    }).catch(() => null);
+    if (hosts) applyHosts(hosts);
+  };
+
+  const patch = async (hostId: string, fields: Record<string, unknown>) => {
+    const hosts = await invoke<ComputeHost[]>("patch_compute_host", {
+      projectId: project.id,
+      hostId,
+      ...fields,
+    }).catch(() => null);
+    if (hosts) applyHosts(hosts);
+  };
+
+  // Pull outputs: preview the size first (a checkpoint dir can be huge), confirm,
+  // then fetch into a local outputs/<label>/ folder. The only worker→local path.
+  const [pulling, setPulling] = useState<string | null>(null);
+  const [pullNote, setPullNote] = useState<Record<string, string>>({});
+  const pullOutputs = async (hostId: string) => {
+    setPulling(hostId);
+    setPullNote((p) => ({ ...p, [hostId]: "" }));
+    try {
+      const preview = await invoke<{ files: number; bytes: number }>("worker_outputs_preview", {
+        projectId: project.id,
+        hostId,
+      });
+      if (preview.files === 0) {
+        setPullNote((p) => ({ ...p, [hostId]: t("remoteMachines.noOutputFiles") }));
+        return;
+      }
+      const ok = window.confirm(
+        t("remoteMachines.pullConfirm", { files: preview.files, bytes: formatBytes(preview.bytes) }),
+      );
+      if (!ok) return;
+      const rep = await invoke<{ pulled: number; bytes: number; dest: string; errors: string[] }>(
+        "worker_pull_outputs",
+        { projectId: project.id, hostId },
+      );
+      const errs = rep.errors.length ? t("remoteMachines.pullErrorsSuffix", { count: rep.errors.length }) : "";
+      setPullNote((p) => ({
+        ...p,
+        [hostId]: t("remoteMachines.pulledResult", { pulled: rep.pulled, dest: rep.dest, errs }),
+      }));
+    } catch (e) {
+      setPullNote((p) => ({ ...p, [hostId]: t("remoteMachines.pullFailed", { error: String(e) }) }));
+    } finally {
+      setPulling(null);
+    }
+  };
+
+  const syncNow = async (hostId: string) => {
+    setReports((prev) => ({
+      ...prev,
+      [hostId]: { project_id: project.id, host_id: hostId, ok: false, skipped: false },
+    }));
+    const rep = await invoke<WorkerSyncReport>("worker_sync_now", {
+      projectId: project.id,
+      hostId,
+    }).catch((e) => ({
+      project_id: project.id,
+      host_id: hostId,
+      ok: false,
+      skipped: false,
+      error: String(e),
+    }));
+    setReports((prev) => ({ ...prev, [hostId]: rep }));
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="project-dialog dialog-framed remote-machines-dialog" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>{t("remoteMachines.title", { name: project.name })}</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+
+        <div className="dialog-scroll">
+        <p className="settings-help">
+          {t("remoteMachines.introPre")} <strong>{t("remoteMachines.introStrongPrimary")}</strong>{" "}
+          {t("remoteMachines.introMid1")}{" "}
+          <strong>{t("remoteMachines.introStrongSameCode")}</strong>
+          {t("remoteMachines.introMid2")} <strong>{t("remoteMachines.introStrongSyncCopy")}</strong>{" "}
+          {t("remoteMachines.introPost")}
+        </p>
+
+        {/* ── Primary host ────────────────────────────────────────────────────
+            The project's own `remote` — it owns files, git, and the local mirror,
+            with full two-way sync. Listed first so the one menu covers connecting
+            the primary too, not only the workers; its Connect/Manage opens the same
+            per-host detail (`RemoteConnectDialog`) a worker's does, targeting
+            `"primary"`. No sync/pull/remove: those are worker-only concepts. */}
+        {(() => {
+          const ssh = primary?.ssh ?? "off";
+          const pLabel = project.remote?.label || project.remote?.host || project.name;
+          const mirror = resolveLocalMirror(project);
+          const busy = ssh === "connected" ? busyReading({ readings }, project.remote) : null;
+          return (
+            <div className="remote-machine-card">
+              <div className="remote-machine-head">
+                <ConnLamp
+                  status={ssh}
+                  busy={busy !== null}
+                  label={busy ? `${pLabel} — ${busyLabel(busy)}` : pLabel}
+                />
+                <span className="remote-machine-name">{pLabel}</span>
+                <span
+                  className="remote-machine-tag"
+                  title={t("remoteMachines.primaryTagTitle")}
+                >
+                  {t("remoteMachines.primaryTag")}
+                </span>
+                <UntestedTag />
+                <span className="remote-machine-target">
+                  {project.remote && formatRemoteTarget(project.remote)}
+                </span>
+              </div>
+              <div className="remote-machine-status">
+                {ssh === "connected" ? t("remoteMachines.connectedDot") : t("remoteMachines.notConnectedDot")}
+                {mirror ? ` ${t("remoteMachines.localMirrorLabel")} ${mirror}` : ""}
+              </div>
+              <div className="remote-machine-actions">
+                <button onClick={() => openConnect(project.id, "primary")}>
+                  {ssh === "connected" ? t("remoteMachines.manage") : t("remoteMachines.connectEllipsis")}
+                </button>
+              </div>
+            </div>
+          );
+        })()}
+
+        {/* A global machine picked for this project — either in the header's
+            Machines menu, or from this dialog's own list under "Add a machine" —
+            confirm just the shared path, then add + connect it like any other
+            worker. */}
+        {pendingDrop && (
+          <div className="remote-machine-card remote-machine-drop-panel" ref={dropPanelRef}>
+            <div className="remote-machine-head">
+              {/* Was hardcoded `connected`. A dropped machine is *usually* live —
+                  that is why it is droppable — but "usually" is not a status, and
+                  once this panel's own connect is in flight (or has failed) the
+                  attempt the user is watching is the only honest thing to show. */}
+              <ConnLamp
+                status={dropConn ?? globalStatus ?? "off"}
+                label={pendingDrop.label || pendingDrop.host}
+              />
+              <span className="remote-machine-name">
+                {pendingDrop.label || pendingDrop.host}
+              </span>
+              <span className="remote-machine-tag">{t("remoteMachines.sharedFsTag")}</span>
+              <span className="remote-machine-target">
+                {pendingDrop.user ? `${pendingDrop.user}@` : ""}
+                {pendingDrop.host}
+                {pendingDrop.port ? `:${pendingDrop.port}` : ""}
+              </span>
+            </div>
+            <p className="settings-help">
+              {t("remoteMachines.dropIntro")}
+            </p>
+            <label>
+              <span className="remote-machine-add-label">{t("remoteMachines.pathOnMachine")}</span>
+              <input
+                placeholder={t("remoteMachines.absolutePathPlaceholder")}
+                value={dropPath}
+                onChange={(e) => setDropPath(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === "Enter") void addDroppedMachine();
+                }}
+                spellCheck={false}
+                autoFocus
+              />
+            </label>
+            {dropError && <div className="project-dialog-error">{dropError}</div>}
+            <div className="project-dialog-actions">
+              <button type="button" onClick={() => setPendingDrop(null)}>
+                {t("common.cancel")}
+              </button>
+              <button type="button" disabled={dropBusy} onClick={() => void addDroppedMachine()}>
+                {dropBusy ? t("remoteMachines.adding") : t("remoteMachines.addMachineBtn")}
+              </button>
+            </div>
+          </div>
+        )}
+
+        {/* Existing workers */}
+        <div className="remote-machine-worker-list">
+        {workers.length === 0 && (
+          <p className="settings-help">{t("remoteMachines.noWorkers")}</p>
+        )}
+        {workers.map((w) => {
+          const ssh = byHost?.[w.id]?.ssh ?? "off";
+          const rep = reports[w.id];
+          const wLabel = w.label || w.host;
+          const wBusy = ssh === "connected" ? busyReading({ readings }, w) : null;
+          const shared = w.shared_fs === true;
+          const statusText = shared
+            ? t("remoteMachines.sharedStatus")
+            : rep?.error
+              ? `${t("remoteMachines.syncFailedLabel")} ${rep.error}`
+              : rep?.head
+                ? `${t("remoteMachines.lastSyncedLabel")} ${rep.head}${rep.skipped ? ` ${t("remoteMachines.alreadyCurrent")}` : ""}`
+                : rep && !rep.ok
+                  ? t("remoteMachines.syncingEllipsis")
+                  : t("remoteMachines.notSyncedYet");
+          return (
+            <div key={w.id} className="remote-machine-card">
+              <div className="remote-machine-head">
+                <ConnLamp
+                  status={ssh}
+                  busy={wBusy !== null}
+                  label={wBusy ? `${wLabel} — ${busyLabel(wBusy)}` : wLabel}
+                />
+                <span className="remote-machine-name">{wLabel}</span>
+                <span
+                  className="remote-machine-tag"
+                  title={
+                    shared
+                      ? t("remoteMachines.sharedTagTitle")
+                      : t("remoteMachines.syncedTagTitle")
+                  }
+                >
+                  {shared ? t("remoteMachines.sharedFsTag") : t("remoteMachines.syncedCopyTag")}
+                </span>
+                <span className="remote-machine-target">
+                  {w.user ? `${w.user}@` : ""}{w.host}{w.port ? `:${w.port}` : ""}:{w.remote_path}
+                </span>
+              </div>
+              <div className={`remote-machine-status${rep?.error && !shared ? " error" : ""}`}>
+                {statusText}
+              </div>
+              <div className="remote-machine-actions">
+                <button onClick={() => openConnect(project.id, w.id)}>
+                  {ssh === "connected" ? t("remoteMachines.manage") : t("remoteMachines.connectEllipsis")}
+                </button>
+                {!shared && (
+                  <>
+                    <button disabled={ssh !== "connected"} onClick={() => void syncNow(w.id)}>
+                      {t("remoteMachines.syncCodeNow")}
+                    </button>
+                    <button
+                      disabled={ssh !== "connected" || pulling === w.id}
+                      onClick={() => void pullOutputs(w.id)}
+                      title={t("remoteMachines.pullOutputsTitle")}
+                    >
+                      {pulling === w.id ? t("remoteMachines.pulling") : t("remoteMachines.pullOutputsBtn")}
+                    </button>
+                  </>
+                )}
+                <button
+                  className="danger"
+                  onClick={() => void removeMachine(w.id)}
+                  title={t("remoteMachines.removeTitle")}
+                >
+                  {t("remoteMachines.remove")}
+                </button>
+              </div>
+              <label className="remote-machine-toggle" title={t("remoteMachines.syncCopyToggleTitle")}>
+                <span>{t("remoteMachines.syncCopyLabel")}</span>
+                <Toggle
+                  checked={!shared}
+                  onChange={(e) =>
+                    void patch(
+                      w.id,
+                      e.target.checked ? { sharedFs: false, syncCode: true } : { sharedFs: true },
+                    )
+                  }
+                  size="sm"
+                />
+              </label>
+              {!shared && (
+                <label className="remote-machine-toggle" title={t("remoteMachines.autoSyncTitle")}>
+                  <span>{t("remoteMachines.autoSyncLabel")}</span>
+                  <Toggle
+                    checked={w.sync_code !== false}
+                    onChange={(e) => void patch(w.id, { syncCode: e.target.checked })}
+                    size="sm"
+                  />
+                </label>
+              )}
+              {pullNote[w.id] && <div className="settings-help">{pullNote[w.id]}</div>}
+            </div>
+          );
+        })}
+        </div>
+
+        {/* Add machine — two steps: log in first, then choose the folder. */}
+        <div className="remote-machine-add">
+          <div className="remote-machine-add-title">{t("remoteMachines.addMachineTitle")}</div>
+
+          {!browse.conn ? (
+            /* ── Step 1: log in ────────────────────────────────────────── */
+            <>
+              {/* ── The machines you already have ───────────────────────────
+                  A global machine is a host that is already set up and already
+                  authenticated, so typing its address and logging into it again
+                  here is work the app can do itself. One click seeds the
+                  confirm-path panel above (add + connect); "Use in the form"
+                  falls through to the ordinary flow when the folder needs
+                  browsing or a synced copy is wanted. */}
+              {globalMachines.length > 0 && (
+                <div className="remote-machine-global">
+                  <div className="remote-machine-add-label">
+                    <span className="remote-machine-global-title">
+                      {t("remoteMachines.globalListTitle")}
+                    </span>
+                    <UntestedTag />
+                  </div>
+                  <p className="settings-help">{t("remoteMachines.globalListHelp")}</p>
+                  <div className="remote-machine-global-list">
+                    {globalMachines.map((m) => {
+                      const target = `${m.user ? `${m.user}@` : ""}${m.host}${m.port ? `:${m.port}` : ""}`;
+                      const taken = alreadyAHost(m);
+                      return (
+                        <div key={m.id} className="remote-machine-global-row">
+                          {/* The machine's own status — a session this app opened,
+                              never a probe (`stores/globalMachines`). */}
+                          <ConnLamp status={globalStatuses[m.id] ?? "off"} label={target} />
+                          <span className="remote-machine-name">{m.label || m.host}</span>
+                          <span className="remote-machine-target">{target}</span>
+                          {taken ? (
+                            <span
+                              className="remote-machine-tag"
+                              title={t("remoteMachines.globalAlreadyAddedTitle")}
+                            >
+                              {t("remoteMachines.globalAlreadyAdded")}
+                            </span>
+                          ) : (
+                            <>
+                              <button
+                                type="button"
+                                title={t("remoteMachines.globalFillTitle")}
+                                onClick={() => fillFromGlobal(m)}
+                              >
+                                {t("remoteMachines.globalFill")}
+                              </button>
+                              <button
+                                type="button"
+                                title={t("remoteMachines.globalQuickAddTitle")}
+                                onClick={() => quickAddGlobal(m)}
+                              >
+                                {t("remoteMachines.globalQuickAdd")}
+                              </button>
+                            </>
+                          )}
+                        </div>
+                      );
+                    })}
+                  </div>
+                </div>
+              )}
+              <label>
+                {t("remoteMachines.sshAddressLabel")}
+                <input
+                  placeholder={t("remoteMachines.sshAddressPlaceholder")}
+                  value={address}
+                  onChange={(e) => onAddressChange(e.target.value)}
+                  onKeyDown={(e) => {
+                    // Enter means "get me logged in", which is a different call in
+                    // each path — the password connect, or opening the terminal.
+                    if (e.key === "Enter") void (viaTerminal ? startLoginTerm() : startBrowse());
+                  }}
+                  spellCheck={false}
+                />
+              </label>
+              <label>
+                <span className="remote-machine-add-label">
+                  {t("remoteConnect.usernameLabel")}
+                  <UntestedTag />
+                </span>
+                <input
+                  placeholder={t("remoteMachines.usernamePlaceholder")}
+                  value={username}
+                  onChange={(e) => setUsername(e.target.value)}
+                  onKeyDown={(e) => {
+                    // Enter means "get me logged in", which is a different call in
+                    // each path — the password connect, or opening the terminal.
+                    if (e.key === "Enter") void (viaTerminal ? startLoginTerm() : startBrowse());
+                  }}
+                  autoComplete="off"
+                  spellCheck={false}
+                />
+              </label>
+              {!viaTerminal && (
+                <label>
+                  {t("remoteConnect.sshPasswordLabel")}
+                  <PasswordInput
+                    placeholder={
+                      savedPw
+                        ? t("remoteMachines.sshPasswordSavedPlaceholder")
+                        : t("remoteMachines.sshPasswordPlaceholder")
+                    }
+                    value={browsePassword}
+                    autoComplete="off"
+                    onChange={(e) => setBrowsePassword(e.target.value)}
+                    onKeyDown={(e) => {
+                      if (e.key === "Enter") void startBrowse();
+                    }}
+                  />
+                </label>
+              )}
+              {/* The shared row (`SavePasswordRow`). This form's disabled-in-terminal
+                  policy is the one all four surfaces now follow — it was right here
+                  and wrong in the two project dialogs, where a live toggle promised
+                  a save that `ssh_connect`'s `remember` was never called to make. */}
+              <SavePasswordRow
+                credential={credential}
+                checked={savePassword}
+                viaTerminal={viaTerminal}
+                className="container-settings-toggle"
+                trailingToggle
+                onChange={setSavePassword}
+              />
+              {viaTerminal && loginTerm && (
+                <div className="dialog-connect-terminal">
+                  <div className="dialog-connect-terminal-bar">
+                    <span className="ssh-optional-hint">
+                      {t("remoteMachines.loginTermHint")}
+                    </span>
+                    <button type="button" className="vpn-disconnect-btn" onClick={stopLoginTerm}>
+                      {t("remoteConnect.disconnect")}
+                    </button>
+                  </div>
+                  {/* The password this form asks for is normally transient — but the
+                      keychain may hold one for this host from the machine's own
+                      Connect modal, or from the project that already uses it, and a
+                      terminal login has no field to reach it. */}
+                  <CredentialPasteBar
+                    ptyId={loginTerm.id}
+                    entries={sshPasteEntries(t, {
+                      user: parseTarget()?.user,
+                      host: parseTarget()?.host,
+                      port: parseTarget()?.port,
+                      saved: savedPw,
+                    })}
+                  />
+                  <div className="dialog-connect-terminal-host">
+                    <TerminalView
+                      id={loginTerm.id}
+                      cmd=""
+                      cwd=""
+                      initialInput={loginTerm.command}
+                      visible
+                      focused
+                      persistOnUnmount
+                    />
+                  </div>
+                </div>
+              )}
+              <TerminalSignInToggle
+                channel="ssh"
+                checked={viaTerminal}
+                busy={!!loginTerm}
+                onChange={setViaTerminal}
+              />
+              {browse.error && <div className="project-dialog-error">{browse.error}</div>}
+              {addError && <div className="project-dialog-error">{addError}</div>}
+              <div className="project-dialog-actions">
+                <button type="button" onClick={onClose}>{t("common.close")}</button>
+                {/* One action, three meanings — the step the form is actually on:
+                    open the login, re-check a login that outlasted the poll, or the
+                    ordinary password connect. */}
+                {viaTerminal ? (
+                  loginTerm ? (
+                    <button
+                      type="button"
+                      title={t("remoteMachines.retryBrowseTitle")}
+                      onClick={retryLoginBrowse}
+                    >
+                      {browseConnecting ? t("remoteMachines.waitingForLogin") : t("remoteMachines.loggedInBrowse")}
+                    </button>
+                  ) : (
+                    <button type="button" onClick={() => void startLoginTerm()}>
+                      {t("remoteMachines.openLoginTerminal")}
+                    </button>
+                  )
+                ) : (
+                  <button
+                    type="button"
+                    disabled={browseConnecting}
+                    onClick={() => void startBrowse()}
+                  >
+                    {browseConnecting ? t("remoteMachines.loggingIn") : t("remoteMachines.logIn")}
+                  </button>
+                )}
+              </div>
+            </>
+          ) : (
+            /* ── Step 2: logged in — choose the folder ─────────────────── */
+            <>
+              {(() => {
+                const loggedInAs = `${browse.conn!.user ? `${browse.conn!.user}@` : ""}${browse.conn!.host}${browse.conn!.port ? `:${browse.conn!.port}` : ""}`;
+                return (
+                  <div className="remote-machine-loggedin">
+                    {/* Was hardcoded `connected`. A frozen session says a login once
+                        succeeded, not that it still works — the listing is the live
+                        evidence, so a failing `ssh_list_dir` (the master died, the
+                        tunnel dropped) must redden this rather than leave a green
+                        lamp over an error message. */}
+                    <ConnLamp
+                      status={browse.error ? "error" : browse.busy ? "connecting" : "connected"}
+                      label={loggedInAs}
+                    />
+                    <span>
+                      {t("remoteMachines.loggedInToPre")} <strong>{loggedInAs}</strong>
+                    </span>
+                    <button type="button" onClick={logout}>{t("remoteConnect.changeConfig")}</button>
+                  </div>
+                );
+              })()}
+
+              <label className="container-settings-toggle" title={t("remoteMachines.sharedFsToggleTitleStep2")}>
+                <span>{t("remoteMachines.syncCopyLabel")}</span>
+                <Toggle checked={syncCopy} onChange={(e) => setSyncCopy(e.target.checked)} size="sm" />
+              </label>
+              <p className="settings-help">
+                {syncCopy
+                  ? t("remoteMachines.syncCopyDescOn")
+                  : t("remoteMachines.syncCopyDescOff")}
+              </p>
+
+              <label>
+                <span className="remote-machine-add-label">
+                  {syncCopy ? t("remoteMachines.remotePathForCopy") : t("remoteMachines.pathToProject")}
+                  <UntestedTag />
+                </span>
+                <div className="folder-picker-row">
+                  <input
+                    placeholder={t("remoteMachines.absolutePathPlaceholder")}
+                    value={remotePath}
+                    onChange={(e) => setRemotePath(e.target.value)}
+                    spellCheck={false}
+                  />
+                  <button
+                    type="button"
+                    disabled={browseConnecting}
+                    onClick={() => void startBrowse()}
+                  >
+                    {browseConnecting ? t("vpnPrompt.connecting") : browsing ? t("remoteMachines.reconnect") : t("remoteMachines.browseEllipsis")}
+                  </button>
+                </div>
+              </label>
+
+              {browsing && browse.conn && (
+                <RemoteFolderBrowser
+                  path={browse.path}
+                  entries={browse.entries}
+                  busy={browse.busy}
+                  error={browse.error}
+                  recentPaths={browsePaths}
+                  onGoUp={browse.goUp}
+                  onJumpPath={browse.jump}
+                  onEnterFolder={browse.enter}
+                  onUseFolder={useBrowsedFolder}
+                  onCreateFolder={browse.mkdir}
+                  footer={t("remoteMachines.browserFooter")}
+                />
+              )}
+
+              <label>
+                {t("remoteMachines.labelOptional")}
+                <input
+                  placeholder={t("remoteMachines.labelPlaceholder")}
+                  value={label}
+                  onChange={(e) => setLabel(e.target.value)}
+                  spellCheck={false}
+                />
+              </label>
+              {addError && <div className="project-dialog-error">{addError}</div>}
+              <div className="project-dialog-actions">
+                <button type="button" onClick={onClose}>{t("common.close")}</button>
+                <button type="button" disabled={busy} onClick={() => void addMachine()}>
+                  {busy ? t("remoteMachines.adding") : t("remoteMachines.addMachineBtn")}
+                </button>
+              </div>
+            </>
+          )}
+        </div>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+function formatBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(1)} ${units[i]}`;
+}
diff --git a/src/components/projects/RemotePaneHold.tsx b/src/components/projects/RemotePaneHold.tsx
new file mode 100644
index 0000000..db10f48
--- /dev/null
+++ b/src/components/projects/RemotePaneHold.tsx
@@ -0,0 +1,32 @@
+/**
+ * Placeholder shown in a remote (SSH) project's REMOTE pane while its pooled
+ * connection is down. Mounting the real terminal/SFTP view here would spawn
+ * `ssh -tt` against a dead pool and freeze the window, so the pane is held until
+ * the project connects (then it re-renders and the live view takes over). Local
+ * panes and the file browser are NOT held — they work on the mirror offline.
+ *
+ * Shared by both the remote terminal pane (CenterPanel) and the remote file
+ * viewer (FileViewerPane, for a remote-native file), so a disconnected remote
+ * shows ONE unified "Not connected" card instead of each viewer flashing its own
+ * red read error.
+ */
+import { useT } from "../../lib/i18n";
+
+export function RemotePaneHold({ host, onConnect }: { host: string; onConnect: () => void }) {
+  const t = useT();
+  return (
+    <div className="center-placeholder" style={{ height: "100%" }}>
+      <div className="center-placeholder-card">
+        <div className="center-placeholder-title">{t("remotePane.notConnected")}</div>
+        <div className="center-placeholder-hint">
+          {t("remotePane.hintPre")} {host || t("remotePane.theRemoteHost")}. {t("remotePane.hintPost")}
+        </div>
+        <div className="project-dialog-actions" style={{ justifyContent: "center" }}>
+          <button type="button" className="btn-primary" onClick={onConnect}>
+            {t("common.connect")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/projects/RemoteProjectSection.tsx b/src/components/projects/RemoteProjectSection.tsx
index 540c531..7cb7553 100644
--- a/src/components/projects/RemoteProjectSection.tsx
+++ b/src/components/projects/RemoteProjectSection.tsx
@@ -1,12 +1,63 @@
-import { joinRemotePath } from "./scaffold";
+import { joinRemotePath, parseSshAddress } from "./scaffold";
+import { RemoteFolderBrowser } from "./RemoteFolderBrowser";
+import { TerminalSignInToggle } from "./TerminalSignInToggle";
+import { SavePasswordRow } from "./SavePasswordRow";
+import { CredentialPasteBar, sshPasteEntries, vpnPasteEntries } from "./CredentialPasteBar";
+import { TerminalView } from "../terminal/TerminalView";
+import { ConnectionLog } from "../common/ConnectionLog";
+import { ConnLamp } from "../common/ConnLamp";
+import { Dropdown } from "../common/Dropdown";
+import { PasswordInput } from "../common/PasswordInput";
+import { Toggle } from "../common/Toggle";
+import { VpnTunnelUpNotice } from "../common/VpnTunnelUpNotice";
+import { useVpnSectionVisible } from "../../stores/vpnStatus";
+import type { ConnState } from "../../stores/remoteStatus";
 import type { useRemoteSession } from "./useRemoteSession";
+import { useT, type TranslationKey } from "../../lib/i18n";
+import { HpcHostToggle } from "./HpcHostToggle";
 
 type RemoteSession = ReturnType<typeof useRemoteSession>;
 
+/** Map the dialog's connection status (`idle|connecting|connected|error`) to a
+ *  lamp state (`off|connecting|connected|error`). */
+function lampOf(status: RemoteSession["sshStatus"]): ConnState {
+  return status === "idle" ? "off" : status;
+}
+
+/** Human-readable status shown when hovering the "Connect VPN" button, so the
+ *  current tunnel state (and any failure reason) is reported without taking up
+ *  permanent space in the dialog. */
+function vpnStatusHint(
+  t: (key: TranslationKey, params?: Record<string, string | number>) => string,
+  status: RemoteSession["vpnStatus"],
+  error: string,
+  config: string,
+): string {
+  switch (status) {
+    case "connecting":
+      return t("vpnPrompt.connectTitleConnecting");
+    case "connected":
+      return t("remoteProjectSection.vpnUpClickToReconnect");
+    case "error":
+      return error
+        ? t("remoteProjectSection.vpnFailedWithError", { error })
+        : t("remoteProjectSection.vpnFailedClickRetry");
+    default:
+      return config
+        ? t("remoteProjectSection.vpnBringUpHint")
+        : t("remoteProjectSection.vpnSelectConfigFirst");
+  }
+}
+
 /**
  * Presentational SSH + OpenVPN + remote-browser section of the project dialog.
  * All state and effects live in `useRemoteSession`; this component only renders
  * it and forwards events. `onClose` lets Escape in the fields dismiss the dialog.
+ *
+ * The remote flow is stepped: step "connect" (SSH + OpenVPN, each with a lamp)
+ * → step "browse" (the live remote folder picker) → step "details" (handled by
+ * the dialog body). Windows non-headless has no ControlMaster to browse over, so
+ * it skips "browse" and types the remote path in the connect step instead.
  */
 export function RemoteProjectSection({
   kind,
@@ -21,28 +72,63 @@ export function RemoteProjectSection({
   onUseThisFolder: () => void;
   remote: RemoteSession;
 }) {
+  const t = useT();
   const {
     isRemoteProject,
-    isRemote,
+    headless,
+    winManual,
+    sshViaTerminal,
+    setSshViaTerminal,
+    vpnViaTerminal,
+    setVpnViaTerminal,
+    step,
+    tryBrowseNow,
     sshTooling,
     sshAddress,
+    sshAddresses,
     sshPassword,
     sshStatus,
     sshError,
+    sshRemember,
+    setSshRemember,
+    sshSaved,
+    sshCredential,
+    forgetSshPassword,
     remoteBrowsePath,
     remoteEntries,
     remoteListBusy,
     remoteListError,
     remoteChosenPath,
+    setRemoteChosenPath,
+    remotePaths,
+    jumpToRemotePath,
     vpnEnabled,
     setVpnEnabled,
     vpnConfig,
+    vpnConfigs,
+    vpnUsername,
+    setVpnUsername,
+    vpnNeeds,
+    vpnNeedsKeyPassphrase,
+    selectVpnConfig,
     vpnPassword,
     setVpnPassword,
+    vpnKeyPassphrase,
+    setVpnKeyPassphrase,
     vpnStatus,
     setVpnStatus,
     vpnError,
-    setVpnError,
+    vpnRemember,
+    setVpnRemember,
+    vpnSaved,
+    forgetVpnPassword,
+    vpnLog,
+    vpnTerm,
+    startVpnTerm,
+    stopVpnTerm,
+    sshTerm,
+    startSshTerm,
+    stopSshTerm,
     browseVpnConfig,
     connectVpn,
     onSshAddressChange,
@@ -50,129 +136,428 @@ export function RemoteProjectSection({
     connectSsh,
     enterRemoteFolder,
     remoteGoUp,
+    createRemoteFolder,
   } = remote;
 
+  // Same gate as the Connect modal: a tunnel is machine-wide, so once one is up
+  // (from the header, another project, or connect-on-launch) this dialog has no
+  // tunnel left to offer and collapses its OpenVPN block to a one-line notice —
+  // unless the live tunnel is the one *this* dialog just brought up, whose log and
+  // state belong here. The project simply stores no config in that case; the
+  // Connect modal can still attach one later.
+  const vpnBusy = vpnStatus === "connecting" || vpnStatus === "connected";
+  const showVpnSection = useVpnSectionVisible(vpnBusy);
+
+  if (!isRemoteProject) return null;
+
+  // "Paste username/password" above each login terminal (see `CredentialPasteBar`).
+  // The host here is the *typed* address rather than a stored spec — this dialog is
+  // where the project is still being created — so the paste target is parsed from the
+  // same string `sshSaved` was asked about, and a saved credential from an earlier
+  // project on the same host is reachable without retyping it.
+  const sshTarget = parseSshAddress(sshAddress);
+  const sshPaste = sshPasteEntries(t, {
+    user: sshTarget?.user,
+    host: sshTarget?.host,
+    port: sshTarget?.port,
+    saved: sshSaved,
+  });
+  const vpnPaste = vpnPasteEntries(t, {
+    config: vpnConfig,
+    username: vpnUsername,
+    saved: vpnSaved,
+    needsUsername: vpnNeeds.username,
+    needsKeyPassphrase: vpnNeedsKeyPassphrase,
+  });
+
+  // Rendered beside whichever credential field comes last, so the button always
+  // sits at the end of the VPN form rather than mid-way through it.
+  const vpnConnectButton = (
+    <button
+      type="button"
+      className={`vpn-connect-btn vpn-status-${vpnStatus}`}
+      disabled={!vpnConfig || vpnStatus === "connecting"}
+      title={vpnStatusHint(t, vpnStatus, vpnError, vpnConfig)}
+      onClick={() => void connectVpn()}
+    >
+      {vpnStatus === "connecting" && <span className="vpn-spinner" aria-hidden="true" />}
+      {vpnStatus === "connecting"
+        ? t("vpnPrompt.connecting")
+        : vpnStatus === "connected"
+          ? t("remoteConnect.connectedState")
+          : vpnStatus === "error"
+            ? t("remoteConnect.retryVpn")
+            : t("remoteConnect.connectVpn")}
+    </button>
+  );
+
+  // The two "save the secret" rows, defined once and rendered from **both** halves of
+  // the login section. They belong to the *host*, not to how you happen to be signing
+  // in this time: switching to the terminal login must not make a saved credential
+  // look discarded (and must certainly never delete it — only unticking does that,
+  // and only by the user's own click). A terminal login is one Eldrun never sees, so
+  // nothing *new* is stored from it; the saved credential is simply kept for the
+  // connects that can use it, which the hint says rather than leaving it to be
+  // guessed.
+  const vpnSaveRow = (
+    <label className="remote-connect-remember">
+      <Toggle
+        size="sm"
+        checked={vpnRemember}
+        onChange={(e) => {
+          setVpnRemember(e.target.checked);
+          if (!e.target.checked && vpnSaved) void forgetVpnPassword();
+        }}
+      />
+      {vpnNeedsKeyPassphrase ? t("vpnPrompt.saveVpnCredentials") : t("vpnPrompt.savePassphrase")}
+      <span className="ssh-optional-hint">
+        {vpnSaved
+          ? vpnViaTerminal
+            ? t("remoteConnect.saveHintKeptTerminal")
+            : t("remoteConnect.saveHintSaved")
+          : vpnViaTerminal
+            ? t("remoteConnect.saveHintNothingTerminal")
+            : t("vpnPrompt.storedSecurely")}
+      </span>
+    </label>
+  );
+  // The keychain is keyed by host target, not by project — so the password saved here
+  // is the one this project's later reconnects (and auto-connect) use, and a host
+  // already saved by another project shows up pre-ticked rather than being silently
+  // cleared.
+  // The HPC tag, on the form where a *new* project's host is logged in to. Same
+  // target the save row is keyed by — the typed address, since the project does
+  // not exist yet — so ticking it here is the same fact as ticking it on the
+  // Machines menu's add form, and the very first connect already behaves
+  // (`lib/hpcHost.ts`).
+  const hpcRow = sshTarget?.host ? (
+    <HpcHostToggle
+      target={{
+        // `parseSshAddress` spells "absent" as null; the tag's target key spells
+        // it as undefined, and the two must agree or a tag written here would be
+        // keyed differently from the same host tagged anywhere else.
+        user: sshTarget.user ?? undefined,
+        host: sshTarget.host,
+        port: sshTarget.port ?? undefined,
+      }}
+    />
+  ) : null;
+  // The shared row (`SavePasswordRow`) — same component the Connect modal and the
+  // add-a-machine form render, so the toggle is *disabled* during a terminal
+  // sign-in here too. It was live before, which meant the user could tick "Save
+  // password" on a login that never calls `ssh_connect` and therefore never
+  // carries `remember`: nothing was ever saved, and nothing said so. The row also
+  // brings the locked-keyring banner, so "we can't read your keychain" stops
+  // rendering as a confident "nothing saved".
+  const sshSaveRow = (
+    <SavePasswordRow
+      credential={sshCredential}
+      checked={sshRemember}
+      viaTerminal={sshViaTerminal}
+      onChange={(on) => {
+        setSshRemember(on);
+        // Untick = delete it now, not at a next connect that may never come — and
+        // the connect itself no longer deletes anything, by design.
+        if (!on && sshSaved) void forgetSshPassword();
+      }}
+    />
+  );
+
+  // The non-headless login authenticates in a terminal, so its lamp tracks the
+  // readiness poll (connecting while the master comes up, green once browsable).
+  const sshLamp: ConnState = winManual ? "off" : lampOf(sshStatus);
+
   return (
     <>
-      {isRemoteProject && sshTooling && (() => {
-        const warnings: string[] = [];
-        if (!sshTooling.sshfs) {
-          warnings.push(
-            "sshfs not found — remote projects can't be mounted. Install sshfs/FUSE.",
-          );
-        }
-        if (sshPassword && !sshTooling.sshpass) {
-          warnings.push(
-            "sshpass not found — password auth won't work. Install sshpass, or use SSH keys (leave the password blank).",
-          );
-        }
-        if (vpnEnabled && !sshTooling.openvpn) {
-          warnings.push(
-            "openvpn/pkexec not found — VPN-gated hosts can't connect. Install openvpn and polkit.",
-          );
-        }
-        if (warnings.length === 0) return null;
-        return (
-          <div className="ssh-tooling-warning" role="alert">
-            {warnings.map((w) => (
-              <div key={w}>⚠ {w}</div>
-            ))}
-          </div>
-        );
-      })()}
+      <div className="remote-steps" role="list" aria-label={t("remoteProjectSection.remoteStepsAria")}>
+        <span className={`remote-step${step === "connect" ? " is-active" : ""}`} role="listitem">
+          1 {t("remoteProjectSection.stepConnectLabel")}
+        </span>
+        {!winManual && (
+          <span className={`remote-step${step === "browse" ? " is-active" : ""}`} role="listitem">
+            2 {t("remoteProjectSection.stepBrowseLabel")}
+          </span>
+        )}
+        <span className={`remote-step${step === "details" ? " is-active" : ""}`} role="listitem">
+          {winManual ? "2" : "3"} {t("remoteProjectSection.stepDetailsLabel")}
+        </span>
+      </div>
 
-      {isRemoteProject && (
-        <div className="ssh-connect-fields" role="group" aria-label="OpenVPN tunnel">
-          <label className="remote-project-toggle vpn-toggle">
-            <input
-              type="checkbox"
-              checked={vpnEnabled}
-              onChange={(e) => {
-                setVpnEnabled(e.target.checked);
-                if (!e.target.checked) {
-                  setVpnPassword("");
-                  setVpnStatus("idle");
-                  setVpnError("");
-                }
-              }}
-            />
-            Connect via OpenVPN
-          </label>
-          {vpnEnabled && (
-            <>
-              <label>
-                OpenVPN config{" "}
-                <span className="ssh-optional-hint">(copied into Eldrun on selection)</span>
-                <div className="folder-picker-row">
-                  <input
-                    className="ssh-address-input"
-                    readOnly
-                    value={vpnConfig}
-                    placeholder="No .ovpn selected"
-                    title={vpnConfig}
-                  />
-                  <button type="button" onClick={() => void browseVpnConfig()}>
-                    Browse…
-                  </button>
+      {step === "connect" && (
+        <>
+          {sshTooling &&
+            (() => {
+              // Mount-free remote: no sshfs/FUSE needed. Only password auth and
+              // VPN-gated (openvpn/pkexec) hosts depend on extra tooling. Password
+              // auth rides OpenSSH's own SSH_ASKPASS everywhere; on Windows that
+              // needs OpenSSH ≥ 8.4, with sshpass as the legacy fallback — the
+              // warning fires only when neither is available. The VPN warning fires
+              // only once a config is selected, since OpenVPN is optional.
+              const warnings: string[] = [];
+              if (sshPassword && !sshTooling.password_auth) {
+                warnings.push(t("remoteProjectSection.passwordAuthWarning"));
+              }
+              if (showVpnSection && vpnEnabled && vpnConfig && !sshTooling.openvpn) {
+                warnings.push(t("remoteProjectSection.opensslMissingWarning"));
+              }
+              if (warnings.length === 0) return null;
+              return (
+                <div className="ssh-tooling-warning" role="alert">
+                  {warnings.map((w) => (
+                    <div key={w}>⚠ {w}</div>
+                  ))}
                 </div>
-              </label>
-              <label>
-                VPN password{" "}
-                <span className="ssh-optional-hint">(not stored; asked again on activation)</span>
+              );
+            })()}
+
+          <div className="ssh-connect-fields" role="group" aria-label={t("remoteConnect.vpnSectionAria")}>
+            {/* A tunnel that is already up machine-wide leaves this section nothing
+                to do — say so in one line and go straight to SSH. */}
+            {!showVpnSection && <VpnTunnelUpNotice />}
+            {showVpnSection && (
+              <>
+            {/* OpenVPN is opt-in (default off): reaching the host directly needs
+                no tunnel when you're already on the right network. Flip the toggle
+                only for a VPN-gated host; the config + connect UI stays collapsed
+                otherwise, and no VPN config is stored on the project. */}
+            <label className={`toggle-card${vpnEnabled ? " is-on" : ""}`}>
+              <span className="toggle-card-body">
+                <span className="toggle-card-title">
+                  <ConnLamp status={lampOf(vpnStatus)} label="OpenVPN" />
+                  {t("remoteConnect.vpnToggleTitle")}
+                </span>
+                <span className="toggle-card-desc">
+                  {t("remoteProjectSection.vpnToggleDescLine1")}
+                  <br />
+                  {t("remoteConnect.vpnDescLine2Pre")}{" "}
+                  <strong>{t("remoteConnect.vpnDescLine2Strong")}</strong>
+                  {t("remoteConnect.vpnDescLine2Post")}
+                </span>
+              </span>
+              <span className="eld-switch">
+                <input
+                  type="checkbox"
+                  checked={vpnEnabled}
+                  onChange={(e) => setVpnEnabled(e.target.checked)}
+                />
+                <span className="eld-switch-track" aria-hidden="true" />
+              </span>
+            </label>
+            {vpnEnabled && (
+            <div className="vpn-details">
+                <label>
+                  {t("remoteProjectSection.vpnConfigLabel")}{" "}
+                  <span className="ssh-optional-hint">{t("remoteProjectSection.vpnConfigCopiedHint")}</span>
+                  {vpnConfigs.length > 0 && (
+                    <div className="folder-picker-row">
+                      <Dropdown
+                        className="dropdown-block vpn-config-recent"
+                        value={vpnConfigs.some((c) => c.path === vpnConfig) ? vpnConfig : ""}
+                        placeholder={t("remoteConnect.recentConfigsPlaceholder")}
+                        title={t("remoteConnect.recentConfigsTitle")}
+                        onChange={(v) => {
+                          if (v) selectVpnConfig(v);
+                        }}
+                        options={vpnConfigs.map((c) => ({ value: c.path, label: c.name }))}
+                      />
+                    </div>
+                  )}
+                  <div className="folder-picker-row">
+                    <input
+                      className="ssh-address-input"
+                      readOnly
+                      value={vpnConfig}
+                      placeholder={t("remoteProjectSection.noOvpnSelected")}
+                      title={vpnConfig}
+                    />
+                    <button type="button" onClick={() => void browseVpnConfig()}>
+                      {t("remoteProjectSection.browseEllipsis")}
+                    </button>
+                  </div>
+                </label>
+                {/* `!vpnTerm` is what makes the headless→terminal escape hatch below
+                    work: once a login terminal is open for this config, that is where
+                    the tunnel is being authenticated whichever mode the app is in, so
+                    the password fields step aside for it instead of sitting there
+                    inert. */}
+                {headless && !vpnTerm && !vpnViaTerminal ? (
+                  <>
+                    {vpnNeeds.username && (
+                      <label>
+                        {t("remoteConnect.vpnUsernameLabel")}{" "}
+                        <span className="ssh-optional-hint">{t("remoteProjectSection.storedWithProject")}</span>
+                        <input
+                          className="ssh-password-input"
+                          type="text"
+                          value={vpnUsername}
+                          placeholder={t("remoteProjectSection.vpnUsernamePlaceholderNoDots")}
+                          onChange={(e) => {
+                            setVpnUsername(e.target.value);
+                            if (vpnStatus !== "idle") setVpnStatus("idle");
+                          }}
+                        />
+                      </label>
+                    )}
+                    <label>
+                      {vpnNeeds.username ? t("remoteConnect.vpnPasswordLabel") : t("remoteConnect.vpnPassphraseLabel")}{" "}
+                      <span className="ssh-optional-hint">
+                        {vpnSaved
+                          ? t("remoteProjectSection.savedInKeychainYour")
+                          : t("remoteProjectSection.notStoredUnlessSaved")}
+                      </span>
+                      <div className="folder-picker-row">
+                        <PasswordInput
+                          className="ssh-password-input"
+                          value={vpnPassword}
+                          // A saved secret can't be pre-filled — it never leaves the
+                          // backend — so blank means "use the saved one".
+                          placeholder={
+                            vpnSaved
+                              ? t("remoteConnect.vpnSavedPlaceholder")
+                              : vpnNeeds.username
+                                ? t("remoteProjectSection.vpnAccountPasswordNoDots")
+                                : t("remoteConnect.vpnPassphraseLabel")
+                          }
+                          onChange={(e) => {
+                            setVpnPassword(e.target.value);
+                            if (vpnStatus !== "idle") setVpnStatus("idle");
+                          }}
+                        />
+                        {/* The connect button sits with the *last* credential field, so
+                            a config that also needs a key passphrase moves it below. */}
+                        {!vpnNeedsKeyPassphrase && vpnConnectButton}
+                      </div>
+                    </label>
+                    {vpnNeedsKeyPassphrase && (
+                      <label>
+                        {t("vpnPrompt.keyPassphraseLabel")}{" "}
+                        <span className="ssh-optional-hint">
+                          {vpnSaved
+                            ? t("remoteProjectSection.savedInKeychainYour")
+                            : t("remoteProjectSection.notStoredUnlessSaved")}
+                        </span>
+                        <div className="folder-picker-row">
+                          <PasswordInput
+                            className="ssh-password-input"
+                            value={vpnKeyPassphrase}
+                            placeholder={
+                              vpnSaved
+                                ? t("remoteConnect.vpnSavedPlaceholder")
+                                : t("remoteProjectSection.keyPassphrasePlaceholderNoDots")
+                            }
+                            onChange={(e) => {
+                              setVpnKeyPassphrase(e.target.value);
+                              if (vpnStatus !== "idle") setVpnStatus("idle");
+                            }}
+                          />
+                          {vpnConnectButton}
+                        </div>
+                      </label>
+                    )}
+                    {/* Same opt-in as the Connect modal's, writing the same keychain
+                        entry (keyed by config path). Without it, a tunnel set up here
+                        asked for its passphrase again on the very next activation. */}
+                    {vpnSaveRow}
+                    {(vpnStatus === "connecting" || vpnLog.length > 0) && (
+                      <ConnectionLog lines={vpnLog} busy={vpnStatus === "connecting"} />
+                    )}
+                    {vpnStatus === "error" && vpnError && (
+                      <div className="project-dialog-error">{vpnError}</div>
+                    )}
+                  </>
+                ) : (
+                  <div className="dialog-connect">
+                    <button
+                      type="button"
+                      className="dialog-connect-btn"
+                      disabled={!vpnConfig || !!vpnTerm}
+                      title={
+                        vpnConfig
+                          ? t("remoteProjectSection.vpnTermBtnTitleActive")
+                          : t("remoteProjectSection.vpnSelectConfigFirst")
+                      }
+                      onClick={() => void startVpnTerm()}
+                    >
+                      <span className="dialog-connect-btn-icon" aria-hidden="true">▶_</span>
+                      {vpnTerm ? t("remoteConnect.vpnTermOpenBelow") : t("remoteConnect.vpnTermOpenBtn")}
+                    </button>
+                    {!vpnTerm && (
+                      <div className="ssh-optional-hint">
+                        {t("remoteProjectSection.vpnTermHintClosed")}
+                      </div>
+                    )}
+                    {vpnTerm && (
+                      <div className="dialog-connect-terminal">
+                        <div className="dialog-connect-terminal-bar">
+                          <span className="ssh-optional-hint">
+                            {t("remoteProjectSection.vpnTermHintOpen")}
+                          </span>
+                          <button
+                            type="button"
+                            className="vpn-disconnect-btn"
+                            onClick={() => stopVpnTerm()}
+                          >
+                            {t("remoteConnect.disconnect")}
+                          </button>
+                        </div>
+                        <CredentialPasteBar ptyId={vpnTerm.id} entries={vpnPaste} />
+                        <div className="dialog-connect-terminal-host">
+                          <TerminalView
+                            id={vpnTerm.id}
+                            cmd=""
+                            cwd=""
+                            initialInput={vpnTerm.command}
+                            visible
+                            focused
+                            persistOnUnmount
+                          />
+                        </div>
+                      </div>
+                    )}
+                    {vpnError && <div className="project-dialog-error">{vpnError}</div>}
+                  </div>
+                )}
+                {/* Outside the branch above, so it is reachable from *both* states: it
+                    is what switches into the terminal login, and the only way back out
+                    once that terminal has been disconnected. */}
+                {headless && (vpnViaTerminal || !!vpnTerm) && vpnSaveRow}
+                {headless && (
+                  <TerminalSignInToggle
+                    channel="vpn"
+                    checked={vpnViaTerminal}
+                    busy={!!vpnTerm}
+                    failed={vpnStatus === "error"}
+                    onChange={setVpnViaTerminal}
+                  />
+                )}
+              </div>
+            )}
+              </>
+            )}
+            <label>
+              <span className="remote-field-label">
+                <ConnLamp status={sshLamp} label="SSH" />
+                {t("remoteProjectSection.sshAddressLabel")}
+              </span>
+              {sshAddresses.length > 0 && (
                 <div className="folder-picker-row">
-                  <input
-                    className="ssh-password-input"
-                    type="password"
-                    value={vpnPassword}
-                    placeholder="VPN passphrase"
-                    onChange={(e) => {
-                      setVpnPassword(e.target.value);
-                      if (vpnStatus !== "idle") setVpnStatus("idle");
+                  <Dropdown
+                    className="dropdown-block vpn-config-recent"
+                    value={sshAddresses.includes(sshAddress) ? sshAddress : ""}
+                    placeholder={t("remoteConnect.recentConfigsPlaceholder")}
+                    title={t("remoteProjectSection.reuseSshAddressTitle")}
+                    onChange={(v) => {
+                      if (v) onSshAddressChange(v);
                     }}
+                    options={sshAddresses.map((addr) => ({ value: addr, label: addr }))}
                   />
-                  <button
-                    type="button"
-                    disabled={!vpnConfig || vpnStatus === "connecting"}
-                    onClick={() => void connectVpn()}
-                  >
-                    {vpnStatus === "connecting"
-                      ? "Connecting…"
-                      : vpnStatus === "connected"
-                        ? "Connected"
-                        : "Connect VPN"}
-                  </button>
                 </div>
-              </label>
-              {vpnStatus === "error" && vpnError && (
-                <div className="project-dialog-error">{vpnError}</div>
               )}
-            </>
-          )}
-          <label>
-            SSH address
-            <input
-              className="ssh-address-input"
-              value={sshAddress}
-              placeholder="user@host or host:2222"
-              onChange={(e) => onSshAddressChange(e.target.value)}
-              onKeyDown={(e) => {
-                if (e.key === "Enter" && sshAddress.trim() && sshStatus !== "connecting") {
-                  e.preventDefault();
-                  void connectSsh();
-                }
-                if (e.key === "Escape") onClose();
-              }}
-            />
-          </label>
-          <label>
-            Password <span className="ssh-optional-hint">(blank uses SSH key)</span>
-            <div className="folder-picker-row">
               <input
-                className="ssh-password-input"
-                type="password"
-                value={sshPassword}
-                placeholder="leave empty for key/agent auth"
-                onChange={(e) => onSshPasswordChange(e.target.value)}
+                className="ssh-address-input"
+                value={sshAddress}
+                placeholder={t("remoteProjectSection.sshAddressPlaceholder")}
+                onChange={(e) => onSshAddressChange(e.target.value)}
                 onKeyDown={(e) => {
                   if (e.key === "Enter" && sshAddress.trim() && sshStatus !== "connecting") {
                     e.preventDefault();
@@ -181,75 +566,196 @@ export function RemoteProjectSection({
                   if (e.key === "Escape") onClose();
                 }}
               />
-              <button
-                type="button"
-                disabled={!sshAddress.trim() || sshStatus === "connecting"}
-                onClick={() => void connectSsh()}
-              >
-                {sshStatus === "connecting"
-                  ? "Connecting..."
-                  : sshStatus === "connected"
-                    ? "Connected"
-                    : "Connect"}
-              </button>
-            </div>
-          </label>
-          {sshStatus === "error" && sshError && (
-            <div className="project-dialog-error">{sshError}</div>
-          )}
-        </div>
-      )}
-
-      {isRemote && (
-        <div className="remote-browser" role="group" aria-label="Remote folder browser">
-          <div className="remote-browser-header">
-            <button type="button" className="remote-up-btn" onClick={remoteGoUp} title="Go up">
-              ..
-            </button>
-            <span className="remote-breadcrumb" title={remoteBrowsePath}>
-              {remoteBrowsePath || "/"}
-            </span>
-            <button type="button" onClick={onUseThisFolder}>
-              Use this folder
-            </button>
-          </div>
-          <div className="remote-list">
-            {remoteListBusy && <div className="scaffold-empty">Listing...</div>}
-            {!remoteListBusy && remoteListError && (
-              <div className="project-dialog-error">{remoteListError}</div>
+            </label>
+            {/* `!sshTerm` keeps a started terminal login on screen even if the switch
+                below is flipped back: the session it is authenticating is real, and the
+                password field would orphan it. */}
+            {headless && !sshViaTerminal && !sshTerm ? (
+              <>
+                <label>
+                  {t("remoteProjectSection.passwordLabel")}{" "}
+                  <span className="ssh-optional-hint">
+                    {sshSaved
+                      ? t("remoteProjectSection.savedInKeychainYour")
+                      : t("remoteProjectSection.notStoredBlankKey")}
+                  </span>
+                  <div className="folder-picker-row">
+                    <PasswordInput
+                      className="ssh-password-input"
+                      value={sshPassword}
+                      // A saved password never leaves the backend, so it can't be
+                      // pre-filled: blank + Connect authenticates with it.
+                      placeholder={
+                        sshSaved
+                          ? t("remoteProjectSection.sshSavedPlaceholder")
+                          : t("remoteProjectSection.sshPasswordPlaceholderNoDots")
+                      }
+                      onChange={(e) => onSshPasswordChange(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Enter" && sshAddress.trim() && sshStatus !== "connecting") {
+                          e.preventDefault();
+                          void connectSsh();
+                        }
+                        if (e.key === "Escape") onClose();
+                      }}
+                    />
+                    <button
+                      type="button"
+                      disabled={!sshAddress.trim() || sshStatus === "connecting"}
+                      onClick={() => void connectSsh()}
+                    >
+                      {sshStatus === "connecting"
+                        ? t("remoteProjectSection.connectingDotsShort")
+                        : sshStatus === "connected"
+                          ? t("remoteConnect.connectedState")
+                          : t("common.connect")}
+                    </button>
+                  </div>
+                </label>
+                {/* The keychain is keyed by host target, not by project — so the
+                    password saved here is the one this project's later reconnects
+                    (and auto-connect) use, and a host already saved by another
+                    project shows up pre-ticked rather than being silently cleared. */}
+                {sshSaveRow}
+                {hpcRow}
+                {sshStatus === "error" && sshError && (
+                  <div className="project-dialog-error">{sshError}</div>
+                )}
+              </>
+            ) : (
+              <>
+                {winManual && (
+                  <label>
+                    {t("remoteProjectSection.remotePathLabel")}{" "}
+                    <span className="ssh-optional-hint">
+                      {kind === "new"
+                        ? t("remoteProjectSection.remotePathHintNew")
+                        : t("remoteProjectSection.remotePathHintImport")}
+                    </span>
+                    {remotePaths.length > 0 && (
+                      <div className="folder-picker-row">
+                        <Dropdown
+                          className="dropdown-block vpn-config-recent"
+                          value={remotePaths.includes(remoteChosenPath) ? remoteChosenPath : ""}
+                          placeholder={t("remoteConnect.recentConfigsPlaceholder")}
+                          title={t("remoteProjectSection.reuseRemotePathTitle")}
+                          onChange={(v) => {
+                            if (v) setRemoteChosenPath(v);
+                          }}
+                          options={remotePaths.map((p) => ({ value: p, label: p }))}
+                        />
+                      </div>
+                    )}
+                    <input
+                      className="ssh-address-input"
+                      value={remoteChosenPath}
+                      placeholder={t("remoteProjectSection.remotePathPlaceholder")}
+                      onChange={(e) => setRemoteChosenPath(e.target.value)}
+                      onKeyDown={(e) => {
+                        if (e.key === "Escape") onClose();
+                      }}
+                    />
+                  </label>
+                )}
+                <div className="dialog-connect">
+                  <button
+                    type="button"
+                    className="dialog-connect-btn"
+                    disabled={!sshAddress.trim() || !!sshTerm}
+                    title={t("remoteProjectSection.sshTermBtnTitle")}
+                    onClick={() => void startSshTerm()}
+                  >
+                    <span className="dialog-connect-btn-icon" aria-hidden="true">▶_</span>
+                    {sshTerm ? t("remoteConnect.sshTermOpenBelow") : t("remoteConnect.sshTermOpenBtn")}
+                  </button>
+                  {!winManual && sshTerm && sshStatus !== "connected" && (
+                    <button
+                      type="button"
+                      className="dialog-connect-btn"
+                      title={t("remoteProjectSection.tryBrowseTitle")}
+                      onClick={() => tryBrowseNow()}
+                    >
+                      {t("remoteMachines.loggedInBrowse")}
+                    </button>
+                  )}
+                  {!sshTerm && (
+                    <div className="ssh-optional-hint">
+                      {t("remoteProjectSection.sshTermHintClosedPre")}
+                      {!winManual && t("remoteProjectSection.sshTermHintClosedSuffix")}
+                    </div>
+                  )}
+                  {sshTerm && (
+                    <div className="dialog-connect-terminal">
+                      <div className="dialog-connect-terminal-bar">
+                        <span className="ssh-optional-hint">
+                          {t("remoteProjectSection.sshTermHintOpen")}
+                        </span>
+                        <button
+                          type="button"
+                          className="vpn-disconnect-btn"
+                          onClick={() => stopSshTerm()}
+                        >
+                          {t("remoteConnect.disconnect")}
+                        </button>
+                      </div>
+                      <CredentialPasteBar ptyId={sshTerm.id} entries={sshPaste} />
+                      <div className="dialog-connect-terminal-host">
+                        <TerminalView
+                          id={sshTerm.id}
+                          cmd=""
+                          cwd=""
+                          initialInput={sshTerm.command}
+                          visible
+                          focused
+                          persistOnUnmount
+                        />
+                      </div>
+                    </div>
+                  )}
+                  {sshStatus === "error" && sshError && (
+                    <div className="project-dialog-error">{sshError}</div>
+                  )}
+                </div>
+              </>
             )}
-            {!remoteListBusy && !remoteListError && remoteEntries.length === 0 && (
-              <div className="scaffold-empty">Empty folder.</div>
+            {/* Outside the branch above, for the same reason the VPN one is: it is
+                both the way into the terminal login and the only way back out once
+                that terminal has been disconnected. */}
+            {headless && (sshViaTerminal || !!sshTerm) && sshSaveRow}
+            {headless && (sshViaTerminal || !!sshTerm) && hpcRow}
+            {headless && (
+              <TerminalSignInToggle
+                channel="ssh"
+                checked={sshViaTerminal}
+                busy={!!sshTerm}
+                failed={sshStatus === "error"}
+                onChange={setSshViaTerminal}
+              />
             )}
-            {!remoteListBusy &&
-              !remoteListError &&
-              remoteEntries.map((entry) => (
-                <div
-                  key={entry.name}
-                  className={`remote-entry ${entry.is_dir ? "is-dir" : "is-file"}`}
-                  role={entry.is_dir ? "button" : undefined}
-                  tabIndex={entry.is_dir ? 0 : undefined}
-                  onClick={() => enterRemoteFolder(entry)}
-                  onKeyDown={(e) => {
-                    if (entry.is_dir && (e.key === "Enter" || e.key === " ")) {
-                      e.preventDefault();
-                      enterRemoteFolder(entry);
-                    }
-                  }}
-                >
-                  <span className="remote-entry-icon">{entry.is_dir ? "[ ]" : "·"}</span>
-                  <span className="remote-entry-name">{entry.name}</span>
-                </div>
-              ))}
           </div>
-          <div className="remote-chosen">
-            {remoteChosenPath
+        </>
+      )}
+
+      {step === "browse" && !winManual && (
+        <RemoteFolderBrowser
+          path={remoteBrowsePath}
+          entries={remoteEntries}
+          busy={remoteListBusy}
+          error={remoteListError}
+          recentPaths={remotePaths}
+          onGoUp={remoteGoUp}
+          onJumpPath={jumpToRemotePath}
+          onEnterFolder={enterRemoteFolder}
+          onUseFolder={onUseThisFolder}
+          onCreateFolder={(name) => void createRemoteFolder(name)}
+          footer={
+            remoteChosenPath
               ? kind === "new"
-                ? `Will create: ${joinRemotePath(remoteChosenPath, safeName || "<name>")}`
-                : `Selected: ${remoteChosenPath}`
-              : "Browse to a folder, then click “Use this folder”."}
-          </div>
-        </div>
+                ? t("remoteProjectSection.willCreateLabel", { path: joinRemotePath(remoteChosenPath, safeName || "<name>") })
+                : t("remoteProjectSection.selectedLabel", { path: remoteChosenPath })
+              : t("remoteMachines.browserFooter")
+          }
+        />
       )}
     </>
   );
diff --git a/src/components/projects/SavePasswordRow.tsx b/src/components/projects/SavePasswordRow.tsx
new file mode 100644
index 0000000..d781715
--- /dev/null
+++ b/src/components/projects/SavePasswordRow.tsx
@@ -0,0 +1,177 @@
+import { useState } from "react";
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
+import { unlockKeyring } from "../../lib/keyring";
+import { useT } from "../../lib/i18n";
+import type { SavedCredentialHandle } from "./useSavedCredential";
+
+/**
+ * **The one "Save password" row** — the switch, the hint that says what it will
+ * actually do, and the disclosure for the case where it cannot do anything.
+ *
+ * There were three near-identical copies (Connect modal, new/extend-project
+ * section, add-a-machine form) and they had already drifted on the thing that
+ * matters most:
+ *
+ *  - **Disabled during a terminal sign-in.** A terminal login never calls
+ *    `ssh_connect`, so it never carries `remember` — the toggle has nothing to
+ *    act through. Two surfaces disabled it and said so; two left it live, so the
+ *    user ticked Save and nothing was ever saved. It is disabled, not hidden: a
+ *    saved password belongs to the *host*, not to how you signed in this time,
+ *    and a row that vanishes reads as one that was discarded.
+ *  - **"Not saved" vs "we can't tell".** The row renders a `SavedCredential`
+ *    tri-state (`useSavedCredential`), so a locked keyring produces a banner with
+ *    an **Unlock keyring** button — the treatment the VPN modal has had all along
+ *    — instead of a confidently-empty toggle that invites the user to untick a
+ *    credential that is actually there.
+ *  - **What the backend did.** `saveError` is `SshConnectOutcome.save_error`
+ *    verbatim ("the OS keyring is locked, so nothing was saved…"), shown inline,
+ *    because a ticked box with an empty keychain behind it is exactly the state
+ *    that surfaces at the *next* launch as an unexplained password prompt.
+ *
+ * Unticking is handled by the caller (it owns the target and the forget call);
+ * this only reports the state and hands back the new checked value.
+ */
+export function SavePasswordRow({
+  credential,
+  checked,
+  onChange,
+  disabled,
+  viaTerminal,
+  labelText,
+  className,
+  trailingToggle,
+}: {
+  credential: SavedCredentialHandle;
+  checked: boolean;
+  /** The new value of the switch. Deleting a saved credential on untick is the
+   *  caller's business — it is the only act that may remove one. */
+  onChange: (on: boolean) => void;
+  /** The connect is in flight / already up: the row is frozen with it. */
+  disabled?: boolean;
+  /** This connect is signing in in a terminal, where `remember` never runs. */
+  viaTerminal?: boolean;
+  /** Defaults to "Save password"; the VPN variants pass their own wording. */
+  labelText?: string;
+  /** The label's class — surfaces differ in chrome, not in behaviour. */
+  className?: string;
+  /** Machines-window layout: label first, switch at the trailing edge, hint on
+   *  its own line below. */
+  trailingToggle?: boolean;
+}) {
+  const t = useT();
+  const [unlocking, setUnlocking] = useState(false);
+  const label = labelText ?? t("remoteConnect.savePassword");
+
+  // What the row promises, in the state it is actually in. `checking` and
+  // `unreadable` are their own answers — the whole reason the tri-state exists.
+  const hint = viaTerminal
+    ? credential.saved
+      ? t("remoteConnect.saveHintKeptTerminal")
+      : t("remoteConnect.saveHintNothingTerminal")
+    : credential.checking
+      ? t("savePassword.hintChecking")
+      : credential.unreadable
+        ? t("savePassword.hintUnreadable")
+        : credential.saved
+          ? t("remoteConnect.saveHintSaved")
+          : t("vpnPrompt.storedSecurely");
+
+  const doUnlock = async () => {
+    setUnlocking(true);
+    // The OS raises its own dialog; either way re-ask afterwards, since "the user
+    // dismissed it" and "it unlocked" are both answered by re-reading the store.
+    await unlockKeyring();
+    setUnlocking(false);
+    credential.refresh();
+  };
+
+  return (
+    <>
+      <label
+        className={className ?? "remote-connect-remember"}
+        title={viaTerminal ? t("savePassword.titleTerminal") : t("savePassword.titleHeadless")}
+      >
+        {trailingToggle ? (
+          <>
+            <span className="remote-machine-add-label">
+              {label}
+              <UntestedTag />
+            </span>
+            <Toggle
+              size="sm"
+              checked={checked}
+              disabled={disabled || viaTerminal}
+              onChange={(e) => onChange(e.target.checked)}
+            />
+          </>
+        ) : (
+          <>
+            <Toggle
+              size="sm"
+              checked={checked}
+              disabled={disabled || viaTerminal}
+              onChange={(e) => onChange(e.target.checked)}
+            />
+            {label}
+            <span className="ssh-optional-hint">{hint}</span>
+          </>
+        )}
+      </label>
+      {trailingToggle && <div className="settings-help">{hint}</div>}
+      {/* The connect's own report. Never inferred from the request: the box can be
+          ticked and the write still refused. */}
+      {credential.saveError && (
+        <div className="project-dialog-error">
+          {t("savePassword.saveFailedLabel")} {credential.saveError}
+        </div>
+      )}
+      <KeyringNotice credential={credential} unlocking={unlocking} onUnlock={() => void doUnlock()} />
+    </>
+  );
+}
+
+/**
+ * The locked/absent-store disclosure — the SSH twin of the banner
+ * `VpnIndicator` has always shown, and reusing its wording where it fits.
+ *
+ * Only rendered when the store actually got in the way (`unreadable`), because
+ * that is the state the user has no other way of learning about: a locked Secret
+ * Service answers every lookup exactly like an empty one, so without this the
+ * whole surface silently reports "nothing saved" and offers to save again.
+ */
+function KeyringNotice({
+  credential,
+  unlocking,
+  onUnlock,
+}: {
+  credential: SavedCredentialHandle;
+  unlocking: boolean;
+  onUnlock: () => void;
+}) {
+  const t = useT();
+  if (!credential.unreadable) return null;
+  if (credential.keyring === "unavailable") {
+    // Nothing to unlock — this machine has no credential store at all, so the
+    // honest thing is to say saving isn't available rather than offer a button
+    // that can only fail.
+    return <div className="ssh-optional-hint">{t("savePassword.unavailableBanner")}</div>;
+  }
+  return (
+    <div className="vpn-indicator-locked" role="status">
+      <div>
+        {t("vpnIndicator.lockedBannerPre")} <strong>{t("vpnIndicator.lockedBannerStrong")}</strong>
+        {t("savePassword.lockedBannerPost")}
+      </div>
+      <button
+        type="button"
+        className="vpn-indicator-connect"
+        disabled={unlocking}
+        title={t("vpnIndicator.unlockTitle")}
+        onClick={onUnlock}
+      >
+        {unlocking ? t("vpnIndicator.unlocking") : t("vpnIndicator.unlockKeyring")}
+      </button>
+    </div>
+  );
+}
diff --git a/src/components/projects/TerminalSignInToggle.tsx b/src/components/projects/TerminalSignInToggle.tsx
new file mode 100644
index 0000000..1346afa
--- /dev/null
+++ b/src/components/projects/TerminalSignInToggle.tsx
@@ -0,0 +1,72 @@
+import { Toggle } from "../common/Toggle";
+import { UntestedTag } from "../common/UntestedTag";
+import { IS_WINDOWS } from "../../lib/platform";
+import { useT } from "../../lib/i18n";
+
+/**
+ * "Sign in in a terminal" — the **non-headless login, switched on per connect**.
+ *
+ * Headless mode is the default and normally the better one: Eldrun feeds the secret
+ * to the backend and the dialog stays a dialog. But it can only ask what it has
+ * fields for — an SSH password, an OpenVPN password and key passphrase — and a host
+ * or a tunnel is free to ask something else: a keyboard-interactive challenge, a
+ * one-time code, a second prompt, an expired-password change. None of those reach
+ * these fields, so the login cannot succeed however many times it is retried. That is
+ * the loop this exists to end.
+ *
+ * So the toggle is present in **every** headless login section, defaulted **off** —
+ * the ordinary path is untouched, and the escape hatch is one click away instead of
+ * being a settings trip. Flipping it on swaps the password fields for the same
+ * embedded login terminal `connections_headless: false` uses, where the server asks
+ * its own questions and the user answers them directly (Eldrun still never sees the
+ * secret). It is per connect: the global setting is never written, because a mode is
+ * the user's statement about how Eldrun should behave, not something one host's
+ * handshake gets to decide for them.
+ *
+ * Not offered on **Windows**, where it would be a promise Eldrun can't keep: there is
+ * no ssh ControlMaster socket to ride, so a terminal login authenticates a session
+ * nothing else can reuse (the same reason `winManual` exists).
+ *
+ * `failed` turns the hint from an option into a suggestion — after a login has
+ * actually failed, "the password may not be what it is asking for" stops being
+ * hypothetical.
+ */
+export function TerminalSignInToggle({
+  channel,
+  checked,
+  onChange,
+  busy,
+  failed,
+}: {
+  /** Which login this switches — only the wording differs. */
+  channel: "ssh" | "vpn";
+  checked: boolean;
+  onChange: (on: boolean) => void;
+  /** A login terminal is already open: flipping back now would orphan it, so the
+   *  switch waits for its Disconnect. */
+  busy?: boolean;
+  /** The last headless attempt on this channel failed. */
+  failed?: boolean;
+}) {
+  const t = useT();
+  if (IS_WINDOWS) return null;
+  const what = channel === "ssh" ? t("terminalSignIn.sshHostWord") : t("terminalSignIn.vpnTunnelWord");
+  return (
+    <label
+      className="remote-connect-remember terminal-signin-toggle"
+      title={
+        busy
+          ? t("terminalSignIn.busyTitle")
+          : t("terminalSignIn.titleTemplate", { what })
+      }
+    >
+      <Toggle size="sm" checked={checked} disabled={busy} onChange={(e) => onChange(e.target.checked)} />
+      {t("terminalSignIn.label")} <UntestedTag />
+      <span className={`ssh-optional-hint${failed ? " terminal-signin-suggest" : ""}`}>
+        {failed
+          ? t("terminalSignIn.failedHint", { what })
+          : t("terminalSignIn.defaultHint")}
+      </span>
+    </label>
+  );
+}
diff --git a/src/components/projects/autoConnectEligibility.ts b/src/components/projects/autoConnectEligibility.ts
new file mode 100644
index 0000000..e5ca37b
--- /dev/null
+++ b/src/components/projects/autoConnectEligibility.ts
@@ -0,0 +1,53 @@
+/**
+ * **When may "connect on launch" be armed?** — one formula, four surfaces.
+ *
+ * There were four spellings of it (`useRemoteReconnect`, `ProjectPill`, the
+ * Connect modal's non-headless branch, the Machines menu) and they disagreed on
+ * the part that matters: a host tagged **HPC** is one Eldrun promises never to
+ * dial by itself (`lib/hpcHost.ts` — `stores/projects` refuses the connect at the
+ * gate). The Machines menu said so and disabled the switch; the project surfaces
+ * left it live, so the user armed a toggle that was guaranteed to do nothing and
+ * had no way to find out.
+ *
+ * The other half is the older rule, unchanged: auto-connect **never prompts**, so
+ * it is only offered when the connect can complete without one — a saved password
+ * or a host recorded as key/agent auth. With `connections_headless` **off** there
+ * is no keychain to qualify against at all: "auto-connect" there means this same
+ * login opening in the root terminal for the user to answer, which needs no
+ * stored credential (the substitution `autoConnectInteractive` makes, and the one
+ * the header's "Connect on launch" already makes for a tunnel).
+ *
+ * `reason` is what the surface *says*: an ineligible switch must explain which of
+ * the two walls it hit, because they have completely different remedies (save a
+ * password vs. untag the machine).
+ */
+export type AutoConnectBlock = "hpc" | "noCredential";
+
+export interface AutoConnectEligibility {
+  /** The switch may be armed. */
+  eligible: boolean;
+  /** Why not, when it may not. `null` when it may. */
+  reason: AutoConnectBlock | null;
+}
+
+export function autoConnectEligibility(opts: {
+  /** `connections_headless` — off means Eldrun handles no passwords at all. */
+  headless: boolean;
+  /** The backend recorded key/agent auth on this host's last connect. */
+  keyAuth: boolean;
+  /** A password is *known* to be in the keychain. An unreadable store must pass
+   *  `false`: an auto-connect that can't read its credential can't be silent, so
+   *  "we don't know" has to read as "not yet" here — the same direction
+   *  `mayAutoTouch` fails in. */
+  savedPassword: boolean;
+  /** This host is tagged as a shared cluster login node. */
+  hpc: boolean;
+}): AutoConnectEligibility {
+  // The tag outranks everything: it is a statement about the machine, not about
+  // what Eldrun happens to have in its keychain for it.
+  if (opts.hpc) return { eligible: false, reason: "hpc" };
+  if (!opts.headless || opts.keyAuth || opts.savedPassword) {
+    return { eligible: true, reason: null };
+  }
+  return { eligible: false, reason: "noCredential" };
+}
diff --git a/src/components/projects/projectTypeTags.ts b/src/components/projects/projectTypeTags.ts
new file mode 100644
index 0000000..13c6cdc
--- /dev/null
+++ b/src/components/projects/projectTypeTags.ts
@@ -0,0 +1,86 @@
+import { formatRemoteTarget, type ProjectEntry } from "../../types";
+
+/** Display name for a hosting provider. */
+export function providerName(provider: unknown): string {
+  return provider === "gitlab" ? "GitLab" : "GitHub";
+}
+
+export function gitTypeLabel(gitType: unknown, provider?: unknown): string {
+  switch (gitType) {
+    case "remote-public":
+      return `${providerName(provider)} · public`;
+    case "remote-private":
+      return `${providerName(provider)} · private`;
+    case "none":
+      return "No git (no repo)";
+    default:
+      return "Local repo (not pushed)";
+  }
+}
+
+/** One colored tag in the pill hover overlay marking a facet of the project's
+ *  type. Facets are independent axes, so a project can carry several at once
+ *  (e.g. an SSH host published to GitHub → both "GitHub" and "SSH"). */
+export interface ProjectTypeTag {
+  key: string;
+  label: string;
+  /** 6-digit hex; text + border use it solid, background gets an alpha tint. */
+  color: string;
+  title: string;
+}
+
+/** Derive the colored type tags for a project. The git axis contributes exactly
+ *  one tag (no git / local / GitHub / GitLab); the SSH-remote and missing-
+ *  scaffold axes each contribute an independent tag on top. */
+export function projectTypeTags(project: ProjectEntry, scaffoldMissing: boolean): ProjectTypeTag[] {
+  const tags: ProjectTypeTag[] = [];
+  const gitType = typeof project.git_type === "string" ? project.git_type : "local";
+  if (gitType === "none") {
+    tags.push({ key: "git", label: "no git", color: "#8b949e", title: "No git repository" });
+  } else {
+    // The provider badge normally rides on an Eldrun-published `remote-*`
+    // git_type, but a repo pushed to a host *outside* Eldrun carries only a
+    // detected provider (sniffed from `origin`; git_type stays "local"). Either
+    // one lights up the badge; the ·public/·private suffix stays exclusive to
+    // Eldrun-published repos, since visibility can't be sniffed from the URL.
+    const published = gitType.startsWith("remote");
+    const provider = project.git_provider ?? project.detected_provider;
+    // A repo always carries the base "git" tag; when it's published, the hosting
+    // provider rides alongside it as a parallel tag (git + GitHub / git + GitLab).
+    tags.push({
+      key: "git",
+      label: "git",
+      color: "#3fb950",
+      title: published
+        ? gitTypeLabel(gitType, project.git_provider)
+        : provider
+          ? `Local git repo · origin on ${providerName(provider)}`
+          : "Local git repo (not pushed to a remote)",
+    });
+    if (published || provider) {
+      const label = provider === "gitlab" ? "GitLab" : "GitHub";
+      const color = provider === "gitlab" ? "#fc6d26" : "#a371f7";
+      const title = published
+        ? gitTypeLabel(gitType, provider)
+        : `origin on ${providerName(provider)} (detected — not published via Eldrun)`;
+      tags.push({ key: "provider", label, color, title });
+    }
+  }
+  if (project.remote) {
+    tags.push({
+      key: "ssh",
+      label: "SSH",
+      color: "#58a6ff",
+      title: `Remote host · ${formatRemoteTarget(project.remote)}`,
+    });
+  }
+  if (scaffoldMissing) {
+    tags.push({
+      key: "scaffold",
+      label: "no scaffold",
+      color: "#d29922",
+      title: "Missing scaffold files — run “Repair scaffold files”",
+    });
+  }
+  return tags;
+}
diff --git a/src/components/projects/scaffold.ts b/src/components/projects/scaffold.ts
index 426421f..dfc5d8b 100644
--- a/src/components/projects/scaffold.ts
+++ b/src/components/projects/scaffold.ts
@@ -9,6 +9,48 @@ export interface ScaffoldPreviewItem {
   kind: string;
 }
 
+export interface ScaffoldRepairReport {
+  createdFiles: string[];
+  gitignoreLinesAdded: string[];
+  gitInitialized: boolean;
+}
+
+export interface ProjectScaffoldRepair {
+  projectId: string;
+  name: string;
+  targetDir: string;
+  report: ScaffoldRepairReport;
+}
+
+export function scaffoldRepairIsEmpty(report: ScaffoldRepairReport) {
+  return (
+    report.createdFiles.length === 0 &&
+    report.gitignoreLinesAdded.length === 0 &&
+    !report.gitInitialized
+  );
+}
+
+/** Human-readable one-line summary of what a repair report changed. */
+export function summarizeScaffoldRepair(report: ScaffoldRepairReport): string {
+  const parts: string[] = [];
+  if (report.createdFiles.length > 0) {
+    parts.push(`added ${report.createdFiles.join(", ")}`);
+  }
+  if (report.gitignoreLinesAdded.length > 0) {
+    parts.push(`.gitignore +${report.gitignoreLinesAdded.join(", ")}`);
+  }
+  if (report.gitInitialized) {
+    parts.push("git init");
+  }
+  return parts.length > 0 ? parts.join("; ") : "already up to date";
+}
+
+/** Same summary, prefixed with the project name — for a toast/log covering
+ *  multiple projects at once. */
+export function describeScaffoldRepair(repair: ProjectScaffoldRepair): string {
+  return `${repair.name}: ${summarizeScaffoldRepair(repair.report)}`;
+}
+
 export const SCAFFOLD_FILL_OPTIONS = [
   { value: "none", label: "No filling" },
   { value: "manual", label: "Manual" },
@@ -128,6 +170,69 @@ export function parseSshAddress(raw: string): ParsedSshAddress | null {
   return { user, host, port };
 }
 
+/**
+ * Frontend twin of the backend's clone-URL whitelist (`validate_clone_url` in
+ * `commands/git.rs`): https/http, `ssh://`, `git://`, or the scp-like
+ * `[user@]host:path`. It gates the Import button so a typo is caught before a
+ * `git clone` is spawned — the backend re-validates regardless, since that is
+ * where a hostile URL (`ext::<command>` runs the command) would actually bite.
+ */
+export function isCloneUrl(raw: string): boolean {
+  const url = raw.trim();
+  if (!url) return false;
+
+  const schemeEnd = url.toLowerCase().indexOf("://");
+  if (schemeEnd >= 0) {
+    return ["https", "http", "ssh", "git"].includes(url.slice(0, schemeEnd).toLowerCase());
+  }
+
+  const colon = url.indexOf(":");
+  if (colon < 0) return false;
+  const host = url.slice(0, colon);
+  const path = url.slice(colon + 1);
+  return (
+    host !== "" &&
+    !host.includes("/") &&
+    !host.startsWith("-") &&
+    path !== "" &&
+    !path.startsWith(":")
+  );
+}
+
+/**
+ * The repository's own name from a clone URL — last path segment, minus a
+ * trailing `.git`. Used to pre-fill the project name so the common case needs no
+ * typing. Returns "" when nothing name-like can be read out.
+ */
+export function repoNameFromCloneUrl(raw: string): string {
+  const url = raw.trim().replace(/[/]+$/, "");
+  if (!url) return "";
+  const last = url.split(/[/:]/).pop() ?? "";
+  return last.replace(/\.git$/i, "");
+}
+
+/**
+ * The hosting provider a clone URL's host names itself as ("github"/"gitlab"),
+ * or "" when it doesn't — a self-hosted instance usually doesn't, and the fork
+ * import then needs the user to say which it is (forking goes through the
+ * provider's own CLI, so guessing wrong picks the wrong binary and API).
+ * Frontend twin of `provider_from_host` in `commands/git_fork.rs`.
+ */
+export function providerFromCloneUrl(raw: string): "github" | "gitlab" | "" {
+  const url = raw.trim();
+  if (!url) return "";
+  const schemeEnd = url.toLowerCase().indexOf("://");
+  const afterScheme = schemeEnd >= 0 ? url.slice(schemeEnd + 3) : url;
+  // Authority = everything before the first `/` (URL form) or `:` (scp-like),
+  // minus any userinfo and port.
+  const authority = afterScheme.split(/[/:]/)[0] ?? "";
+  const host = (authority.split("@").pop() ?? "").toLowerCase();
+  if (!host) return "";
+  if (host.includes("github")) return "github";
+  if (host.includes("gitlab")) return "gitlab";
+  return "";
+}
+
 /** Join a remote directory path with a child segment using POSIX separators. */
 export function joinRemotePath(base: string, child: string): string {
   if (!base || base === "/") return `/${child}`;
diff --git a/src/components/projects/useRemoteBrowse.ts b/src/components/projects/useRemoteBrowse.ts
new file mode 100644
index 0000000..216abcc
--- /dev/null
+++ b/src/components/projects/useRemoteBrowse.ts
@@ -0,0 +1,199 @@
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { joinRemotePath, type ParsedSshAddress } from "./scaffold";
+import { resolveRemoteStartDir } from "../../lib/remoteConnect";
+import type { RemoteEntry } from "../../types";
+import { withHostKeyConfirm } from "../../lib/hostKey";
+import type { SshConnectOutcome } from "./useSavedCredential";
+
+/**
+ * The shared "log in to a host and browse its filesystem over SFTP" state
+ * machine — the ONE implementation of *how* a remote connect + folder browse
+ * works, so the primary machine and further (worker) machines never carry two
+ * copies of it. Used by the new/extend-project flow (`useRemoteSession`) and the
+ * add-worker-machine flow (`RemoteMachinesWindow`); each dialog keeps its own
+ * field layout ("the content"), this owns the mechanism ("the way to log in").
+ *
+ * A live session is a FROZEN `(conn, password)` pair: once `connect`/`openSession`
+ * commits it, edits to the dialog's address/password fields don't silently change
+ * which host the listing talks to — the caller must `reset` and reconnect. The
+ * listing refreshes automatically whenever the browse path (or the frozen
+ * connection) changes, always reusing the credential the connection was made with.
+ */
+export function useRemoteBrowse() {
+  // The connected host, frozen at connect time (null = no live session).
+  const [conn, setConn] = useState<ParsedSshAddress | null>(null);
+  // The credential the session authenticated with, frozen so every listing/mkdir
+  // reuses it. "" → null → rides the ControlMaster / key auth.
+  const [password, setPassword] = useState("");
+  const [path, setPath] = useState("");
+  const [entries, setEntries] = useState<RemoteEntry[]>([]);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState("");
+
+  // Refresh the listing whenever the browse path (or the frozen connection)
+  // changes. `password` is a dep so a re-`openSession` with a new credential
+  // re-lists, but callers freeze it at connect time so ordinary keystrokes don't.
+  useEffect(() => {
+    if (!conn) {
+      setEntries([]);
+      return;
+    }
+    let cancelled = false;
+    setBusy(true);
+    setError("");
+    invoke<RemoteEntry[]>("ssh_list_dir", {
+      user: conn.user,
+      host: conn.host,
+      port: conn.port,
+      password: password ? password : null,
+      path,
+    })
+      .then((e) => {
+        if (!cancelled) setEntries(e);
+      })
+      .catch((e) => {
+        if (cancelled) return;
+        setEntries([]);
+        setError(String(e));
+      })
+      .finally(() => {
+        if (!cancelled) setBusy(false);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [conn, password, path]);
+
+  // Freeze a session that some OTHER path already authenticated (e.g. a
+  // non-headless login terminal's ControlMaster) — no ssh_connect here. Sets
+  // `conn` last so the listing effect fires once with password + path ready.
+  const openSession = (target: ParsedSshAddress, sessionPassword: string, startPath: string) => {
+    setPassword(sessionPassword);
+    setPath(startPath || "");
+    setConn(target);
+  };
+
+  // Authenticate `target`, then open its start dir. `remember` persists the
+  // working password to the OS keychain (keyed by host target); null/undefined
+  // leaves the keychain untouched. `startPath` overrides where the browse opens
+  // (e.g. the add-machine flow starts at the primary's project path *on the new
+  // machine*, not that host's home); blank/omitted falls back to the configured
+  // default / SSH home. Throws on auth failure — the caller owns the
+  // connecting/error UI. On success the listing opens automatically.
+  //
+  // `remember` is deliberately typed `true | null` and never `false`: `false` is
+  // `Remember::Clear`, and since the backend resolves `typed || saved` before it
+  // writes, a *successful* connect carrying it deletes the password it just
+  // authenticated with. Callers build the value with `rememberArg`.
+  //
+  // Returns what the keychain half actually did (`SshConnectOutcome`), so the
+  // caller sets its "saved" state from the backend rather than from its own
+  // request — a locked keyring refuses the write and says so.
+  const connect = async (opts: {
+    target: ParsedSshAddress;
+    password: string | null;
+    remember?: true | null;
+    startPath?: string | null;
+  }): Promise<SshConnectOutcome> => {
+    const pw = opts.password ? opts.password : null;
+    // First contact: verify the host key's fingerprint before the password is sent.
+    const outcome = await withHostKeyConfirm(() =>
+      invoke<SshConnectOutcome>("ssh_connect", {
+        user: opts.target.user,
+        host: opts.target.host,
+        port: opts.target.port,
+        password: pw,
+        remember: opts.remember ?? null,
+        // A person is at the login form — a tagged HPC host may be dialled by a
+        // gesture, only never by a sweep (`ssh_common`'s dial policy).
+        background: false,
+      }),
+    );
+    const startDir =
+      opts.startPath && opts.startPath.trim()
+        ? opts.startPath.trim()
+        : await resolveRemoteStartDir(
+            opts.target.user,
+            opts.target.host,
+            opts.target.port,
+            pw,
+          );
+    openSession(opts.target, opts.password ?? "", startDir);
+    return outcome;
+  };
+
+  const enter = (entry: RemoteEntry) => {
+    if (entry.is_dir) setPath(joinRemotePath(path, entry.name));
+  };
+
+  // Jump straight to a previously-used path (a recents-dropdown pick) instead of
+  // navigating there entry by entry.
+  const jump = (p: string) => setPath(p);
+
+  const goUp = () => {
+    const p = path.replace(/\/+$/, "");
+    if (!p || p === "/") {
+      setPath("/");
+      return;
+    }
+    const idx = p.lastIndexOf("/");
+    setPath(idx <= 0 ? "/" : p.slice(0, idx));
+  };
+
+  // Create a child folder under the current path, then descend into it (the
+  // listing refreshes off the path). No-op without a live session.
+  const mkdir = async (rawName: string) => {
+    const name = rawName.trim();
+    if (!name || !conn) return;
+    // A single child of the current dir, not an arbitrary deep path.
+    if (name.includes("/")) {
+      setError("Folder name can't contain '/'.");
+      return;
+    }
+    const target = joinRemotePath(path || "/", name);
+    setBusy(true);
+    setError("");
+    try {
+      await invoke("ssh_mkdir", {
+        user: conn.user,
+        host: conn.host,
+        port: conn.port,
+        password: password ? password : null,
+        path: target,
+      });
+      setPath(target);
+    } catch (e) {
+      setError(String(e));
+      setBusy(false);
+    }
+  };
+
+  // Drop back to the disconnected state (a credential edit, an explicit
+  // "Change…", or a torn-down login).
+  const reset = () => {
+    setConn(null);
+    setPassword("");
+    setEntries([]);
+    setPath("");
+    setError("");
+  };
+
+  return {
+    conn,
+    password,
+    path,
+    setPath,
+    entries,
+    busy,
+    error,
+    setError,
+    connect,
+    openSession,
+    enter,
+    jump,
+    goUp,
+    mkdir,
+    reset,
+  };
+}
diff --git a/src/components/projects/useRemoteReconnect.ts b/src/components/projects/useRemoteReconnect.ts
new file mode 100644
index 0000000..089431b
--- /dev/null
+++ b/src/components/projects/useRemoteReconnect.ts
@@ -0,0 +1,877 @@
+import { useEffect, useReducer, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { open } from "@tauri-apps/plugin-dialog";
+import {
+  needsSeparateKeyPassphrase,
+  type ComputeHost,
+  type ProjectEntry,
+  type StoredVpnConfig,
+  type VpnAuthNeeds,
+} from "../../types";
+import { IS_WINDOWS } from "../../lib/platform";
+import { forgetConnection, markConnectionOpened } from "../../lib/remoteConnect";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { useRemoteStatusStore, type ConnState } from "../../stores/remoteStatus";
+import { isHpcHost, targetOfSpec } from "../../lib/hpcHost";
+import { autoConnectEligibility } from "./autoConnectEligibility";
+import { useSavedCredential, type SshConnectOutcome } from "./useSavedCredential";
+import {
+  markVpnConnected,
+  markVpnConnecting,
+  markVpnError,
+  releaseVpn,
+} from "../../stores/vpnStatus";
+import type { LogLine } from "../common/ConnectionLog";
+import { withHostKeyConfirm } from "../../lib/hostKey";
+
+// OpenVPN prints this once the tunnel is fully up (mirrors the backend's
+// READY_MARKER in services/openvpn.rs). The embedded VPN login terminal is
+// watched for it to flip the lamp green — identical to the new-project dialog
+// (see useRemoteSession).
+const VPN_READY_MARKER = "Initialization Sequence Completed";
+
+// Shape of the `terminal-output` event payload (PTY id + raw output chunk).
+interface TerminalOutput {
+  id: string;
+  data: string;
+}
+
+// Monotonic id source for the reconnect-panel embedded terminals. The id has no
+// ":" so it never collides with a tab PTY id (`<scope>:<key>`) or trips the
+// detached-PTY check. Module scope so it survives re-renders, and a distinct
+// "reconnect-" prefix so it never collides with the dialog's "dialog-" ids.
+let reconnectTermSeq = 0;
+const nextReconnectTermId = (kind: string) => `reconnect-${kind}-${++reconnectTermSeq}`;
+
+/** An embedded interactive login terminal: `{ id, command, key }` for a
+ *  `TerminalView` that runs `command`, plus the activation dedupe `key` it
+ *  pre-marked so the matching stop forgets exactly that key. `adopted` marks a
+ *  terminal this hook instance did *not* spawn — it inherited a still-running one
+ *  (see `liveTerms`), so it must re-attach rather than spawn a second PTY. */
+type LoginTerm = { id: string; command: string; key: string; adopted?: boolean };
+
+/**
+ * Login terminals outlive the Connect dialog: their PTYs are spawned
+ * `persistOnUnmount`, so an authenticated tunnel/login keeps running once the
+ * modal closes. Holding them only in refs meant a *reopened* dialog no longer knew
+ * their PTY ids — it could neither show them nor re-attach to them.
+ *
+ * (The VPN tunnel itself no longer depends on this for teardown: interactive tunnels
+ * are armed with a `--writepid` the backend owns, so `openvpn_disconnect` reaches
+ * the root daemon directly. It once didn't, and killing the PTY was the only — and
+ * unreliable — way down.)
+ *
+ * So park them per project here (module scope, surviving the remount) and re-adopt
+ * on mount. Re-adopted terminals render `attachOnly`, which skips `pty_spawn` — a
+ * duplicate spawn on the same id would start a *second* `pkexec openvpn` — and, with
+ * no spawn, no `terminal-ready` fires, so the login command isn't re-typed either.
+ */
+const liveTerms = new Map<string, { vpn?: LoginTerm; ssh?: LoginTerm }>();
+
+const rememberTerm = (projectId: string, kind: "vpn" | "ssh", term: LoginTerm) => {
+  const entry = liveTerms.get(projectId) ?? {};
+  entry[kind] = term;
+  liveTerms.set(projectId, entry);
+};
+
+const dropTerm = (projectId: string, kind: "vpn" | "ssh") => {
+  const entry = liveTerms.get(projectId);
+  if (!entry) return;
+  delete entry[kind];
+  if (!entry.vpn && !entry.ssh) liveTerms.delete(projectId);
+};
+
+/** Re-adopt a parked terminal for a fresh hook instance: same PTY, attach-only. */
+const adoptTerm = (term: LoginTerm | undefined): LoginTerm | null =>
+  term ? { ...term, adopted: true } : null;
+
+/**
+ * Reconnect lifecycle for an *existing* remote project, providing the same
+ * embedded-login parts the new-project dialog has (`useRemoteSession`) but
+ * driven by the project's already-known `remote` spec rather than fresh-entered
+ * address / config + folder browse:
+ *
+ *  - an embedded OpenVPN login terminal (the user types the passphrase there;
+ *    Eldrun never handles it; the VPN lamp flips green on the ready marker), and
+ *  - an embedded SSH login terminal that establishes the ControlMaster; once a
+ *    credential-less `ssh_connect` rides it, the pooled SSH/SFTP connection is
+ *    opened (`remote_connect`) and the SSH lamp goes green — which un-gates the
+ *    CenterPanel tab restore exactly as the headline Reconnect button does.
+ *
+ * Status is published to `useRemoteStatusStore` (keyed by project id) so the
+ * header lamps and the restore gate observe the same state this panel drives.
+ */
+export function useRemoteReconnect(project: ProjectEntry, host?: ComputeHost) {
+  const projectId = project.id;
+  // Multi-host remote (`docs/multi_host_remote_plan.md`): the dialog can target the
+  // primary remote or an extra "worker" host. `hostId` keys the pool + lamp state;
+  // `remote` is the spec to connect (the worker's own, or the primary's). A worker
+  // connect kicks its one-way code fan-out (backend `remote_connect`), never the
+  // primary's git-lockstep / byte-sync.
+  const hostId = host?.id ?? "primary";
+  const remote = host ?? project.remote;
+  // The project's OpenVPN config path. Stateful (not just `remote.openvpn.config`)
+  // because a project may have been created/extended on a no-VPN network with no
+  // config, then need one attached here when reconnecting from a VPN-gated network
+  // (see selectVpnConfig/browseVpnConfig, which also persist it to the project).
+  // Seeded from the stored spec; the dialog is keyed by project id so this resets
+  // per project rather than leaking a picked config across projects.
+  const [vpnConfig, setVpnConfig] = useState(remote?.openvpn?.config ?? "");
+  // Previously-stored `.ovpn` configs (newest first) offered for reuse when the
+  // project carries none yet. Loaded on mount.
+  const [vpnConfigs, setVpnConfigs] = useState<StoredVpnConfig[]>([]);
+  // Auth username for `auth-user-pass` configs (see the backend's
+  // `config_requires_userpass`). Seeded from the stored spec; `vpnNeeds` (queried
+  // when the config changes) says which fields must be shown and filled — leave
+  // one out and OpenVPN prompts for it on stdin, which is closed, so the handshake
+  // hangs until it times out.
+  const [vpnUsername, setVpnUsername] = useState(remote?.openvpn?.username ?? "");
+  const [vpnNeeds, setVpnNeeds] = useState<VpnAuthNeeds>({
+    username: false,
+    keyPassphrase: false,
+  });
+  useEffect(() => {
+    if (!vpnConfig) {
+      setVpnNeeds({ username: false, keyPassphrase: false });
+      return;
+    }
+    let cancelled = false;
+    void invoke<VpnAuthNeeds>("openvpn_auth_needs", { config: vpnConfig })
+      .then((v) => !cancelled && setVpnNeeds(v))
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [vpnConfig]);
+
+  // ── The SSH login name ───────────────────────────────────────────────────────
+  // Editable here, and it has to be: the address is fixed when the project is
+  // created (`user@host` in the new/extend dialog), so a project created with no
+  // user — or the wrong one — had no surface that could correct it. That is not a
+  // headless-only gap, and it fails differently on each side. In **headless** mode
+  // there was simply no field, so Eldrun authenticated as the local account name and
+  // no password could ever be right. In **non-headless** the same wrong name is typed
+  // into the login terminal (`initialInput` submits it on the user's behalf) and the
+  // host rejects it in plain view — and the obvious recovery, retyping
+  // `ssh right@host` by hand in that same terminal, does not help either: the
+  // ControlMaster socket is `cm-%C`, whose hash covers the remote **user** as well as
+  // host and port, so `pollSshReady`'s probe — still built from the *stored* name —
+  // looks for a master that account never opened, finds none, and paints the lamp red
+  // two minutes after a login that visibly succeeded on screen.
+  //
+  // So it is a draft, committed to the spec (blur/Enter, and defensively before
+  // every connect) rather than passed loose: the pooled `remote_connect` and the
+  // backend's tmux/git/sftp legs all re-read the *persisted* spec, so a user that
+  // lived only in this component would connect the probe as one account and
+  // everything after it as another.
+  const [sshUser, setSshUser] = useState(remote?.user ?? "");
+  useEffect(() => setSshUser(remote?.user ?? ""), [remote?.user]);
+  // Mirrored into a ref so an in-flight poll/connect closure reads the current
+  // value instead of the one captured when it started.
+  const sshUserRef = useRef(sshUser);
+  sshUserRef.current = sshUser;
+  /** The login name as ssh should receive it: `null` = "unset, use ssh's default". */
+  const effectiveUser = (): string | null => sshUserRef.current.trim() || null;
+
+  const status = useRemoteStatusStore((s) =>
+    hostId === "primary" ? s.byProject[projectId] : s.byHost[projectId]?.[hostId],
+  );
+  const sshStatus: ConnState = status?.ssh ?? "off";
+  const vpnStatus: ConnState = status?.vpn ?? "off";
+  const setSsh = useRemoteStatusStore((s) => s.setSsh);
+  const setVpn = useRemoteStatusStore((s) => s.setVpn);
+
+  // Deliberately NOT mirroring a machine-wide tunnel that merely matches this
+  // project's stored config path into this project's own vpn status: that used to
+  // "surface it here too" by marking this project connected and acquiring it as a
+  // holder purely off a path match, even when the tunnel was actually brought up
+  // by the header or another project. Two things followed from that, both wrong:
+  // the OpenVPN section rendered its own "connected" card instead of collapsing to
+  // `VpnTunnelUpNotice` like every other remote dialog does for a tunnel that
+  // isn't its own (see `useVpnSectionVisible`) — and logging out of *this* project
+  // then called `releaseVpn` on a holder slot it never earned, which could drop
+  // the tunnel out from under whoever actually started it. `vpnStatus` is now only
+  // ever set by an action this hook itself took (`connectVpnHeadless`,
+  // `startVpnTerm`'s ready-marker watcher), so `showVpnSection`'s `ownTunnelBusy`
+  // means what it says.
+
+  // Windows has no ssh ControlMaster socket, so an interactive login can't be
+  // ridden for the pooled connection — fall back to the headline (key-auth)
+  // Reconnect there rather than offering the SSH login terminal.
+  const winManual = IS_WINDOWS;
+
+  // Headless-path error strings (surfaced under the password fields in the
+  // Connect modal). The lamps carry the coarse state; these carry the reason.
+  const [sshError, setSshError] = useState("");
+  const [vpnError, setVpnError] = useState("");
+  // Live OpenVPN handshake log for the headless connect (fed by the backend's
+  // `openvpn-progress` event, same as the new-project dialog). Capped so a
+  // chatty handshake can't grow unbounded.
+  const [vpnLog, setVpnLog] = useState<LogLine[]>([]);
+  const vpnLogSeq = useRef(0);
+
+  // Whether a password is already saved in the OS keychain for this project's SSH
+  // host, so the Connect modal can pre-check the "Save password" box. The shared
+  // hook, not a local boolean: its answer is a **tri-state**, because a locked
+  // keychain answers a lookup exactly like an empty one and reading that as
+  // "nothing saved" is what unticked the box and let the next connect delete the
+  // credential it had just authenticated with (`useSavedCredential`).
+  const sshCredential = useSavedCredential(
+    remote ? { user: remote.user ?? null, host: remote.host, port: remote.port ?? null } : null,
+  );
+  const sshSaved = sshCredential.saved;
+  // The VPN half has no equivalent state command yet, so it stays a plain
+  // boolean — its untick path is an explicit forget either way.
+  const [vpnSaved, setVpnSaved] = useState(false);
+  useEffect(() => {
+    if (!vpnConfig) return;
+    let cancelled = false;
+    void invoke<boolean>("vpn_has_saved_password", { config: vpnConfig })
+      .then((v) => !cancelled && setVpnSaved(v))
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [vpnConfig]);
+
+  // Auto-connect opt-in: connect this project silently on launch/activation. Only
+  // offerable once the connect needs no input — a saved SSH password, or a host the
+  // backend recorded as key/agent auth (`key_auth`, which is how a passwordless host
+  // proves itself: it has nothing in the keychain to look for). `sshSaved` flips the
+  // moment a "Save password" connect succeeds, so the checkbox comes alive right
+  // there without a reopen.
+  const autoConnect = remote?.auto_connect ?? false;
+  // Key/agent auth (a passwordless connect) also makes auto-connect eligible, but a
+  // passwordless host has nothing in the keychain, so `key_auth` is recorded by the
+  // backend on a successful connect rather than known up front. Seed it from the
+  // stored spec and flip it live the moment a credential-less connect succeeds
+  // (mirroring how `sshSaved` comes alive), so the toggle un-greys right here
+  // without waiting for the project to reload. This is what a worker relied on:
+  // its `key_auth` was never recorded at all (the connect returned early), so its
+  // toggle stayed disabled forever — see `record_worker_key_auth`.
+  //
+  // Only the **headless** connect may set it. A connect that rode an interactive
+  // login's ControlMaster is credential-less for a completely different reason, and
+  // reading that as key auth is what used to mark password hosts auto-connect-
+  // eligible and then fail on every launch (`record_key_auth`, backend). Which is
+  // why this gate is headless-only in the first place: the non-headless branch
+  // renders its own ungated toggle, since there "auto-connect" means the login
+  // opening in the root terminal, not a connect Eldrun completes by itself.
+  const [keyAuth, setKeyAuth] = useState(remote?.key_auth === true);
+  useEffect(() => setKeyAuth(remote?.key_auth === true), [remote?.key_auth]);
+  // One formula for all four surfaces (`autoConnectEligibility`), which is also
+  // what finally brings the **HPC tag** into this dialog: `stores/projects`
+  // refuses to dial a tagged host unattended, so a switch armed here was
+  // guaranteed to do nothing and said nothing about why. `savedPassword` is the
+  // *known*-saved half deliberately — an unreadable keychain can't feed a silent
+  // connect, so it must not qualify one.
+  const settings = useSettingsStore((s) => s.settings);
+  const headless = settings?.connections_headless ?? true;
+  const autoConnectHpc = isHpcHost(settings, targetOfSpec(remote));
+  const autoConnectState = autoConnectEligibility({
+    headless,
+    keyAuth,
+    savedPassword: sshSaved,
+    hpc: autoConnectHpc,
+  });
+  const autoConnectEligible = autoConnectState.eligible;
+  // A worker's toggles/label live on its `compute_hosts` entry (not the project's
+  // primary remote). `patch_compute_host` returns the full updated list — apply it
+  // back to the store so anything derived from `host` (the auto-connect toggle, the
+  // dialog title's name) reflects the change at once; without this the UI wouldn't
+  // visibly stick until a reload.
+  const applyPatchedHosts = (hosts: ComputeHost[]) =>
+    useProjectsStore.setState((s) => ({
+      projects: s.projects.map((p) =>
+        p.id === projectId ? { ...p, compute_hosts: hosts } : p,
+      ),
+    }));
+
+  const setAutoConnect = (enabled: boolean) => {
+    if (host) {
+      void invoke<ComputeHost[]>("patch_compute_host", { projectId, hostId, autoConnect: enabled })
+        .then(applyPatchedHosts)
+        .catch((e) => setSshError(String(e)));
+      return;
+    }
+    void useProjectsStore
+      .getState()
+      .setProjectAutoConnect(projectId, enabled)
+      .catch((e) => setSshError(String(e)));
+  };
+
+  // Rename this host's machine label (worker `label`, or the primary's own
+  // `remote.label`) — distinct from the project name, which is edited elsewhere.
+  // A blank name clears the label, so the display falls back to the bare host
+  // (both backend commands trim and treat empty as "no label").
+  const setWorkerLabel = (label: string) => {
+    if (host) {
+      void invoke<ComputeHost[]>("patch_compute_host", { projectId, hostId, label })
+        .then(applyPatchedHosts)
+        .catch((e) => setSshError(String(e)));
+      return;
+    }
+    void useProjectsStore
+      .getState()
+      .setProjectRemoteLabel(projectId, label)
+      .catch((e) => setSshError(String(e)));
+  };
+
+  /**
+   * Write the edited login name onto this host's spec (the primary's `remote.user`,
+   * or the worker's). Called on blur/Enter *and* at the top of every connect, so a
+   * user who typed a name and hit Connect without leaving the field still connects
+   * as that account rather than the stale one.
+   *
+   * A no-op when unchanged, so an ordinary connect costs no write. Returns the
+   * committed value (`null` = cleared) so the caller can use it directly instead of
+   * waiting for the store round-trip to reach `remote`.
+   */
+  const commitSshUser = async (): Promise<string | null> => {
+    const next = effectiveUser();
+    const current = remote?.user ?? null;
+    if (next === current) return current;
+    try {
+      if (host) {
+        const hosts = await invoke<ComputeHost[]>("patch_compute_host", {
+          projectId,
+          hostId,
+          user: next ?? "",
+        });
+        applyPatchedHosts(hosts);
+      } else {
+        await useProjectsStore.getState().setProjectRemoteUser(projectId, next ?? "");
+      }
+    } catch (e) {
+      setSshError(String(e));
+    }
+    return next;
+  };
+
+  // Load the recently-used OpenVPN configs so a project that carries none yet can
+  // reuse one without re-browsing. Best-effort.
+  const refreshVpnConfigs = () => {
+    invoke<StoredVpnConfig[]>("openvpn_list_configs")
+      .then(setVpnConfigs)
+      .catch(() => setVpnConfigs([]));
+  };
+  useEffect(refreshVpnConfigs, []);
+
+  // Persist the chosen config onto the project's remote spec (best-effort) so a
+  // VPN attached here from a VPN-gated network is remembered for next time. The
+  // opt-in toggle stays default-off, so remembering the config never forces the
+  // tunnel on the networks that don't need it.
+  const persistVpnConfig = (path: string) => {
+    void useProjectsStore
+      .getState()
+      .setProjectOpenvpn(projectId, path, vpnUsername || null)
+      .catch((e) => console.warn("persist openvpn config failed", e));
+  };
+
+  // Select a previously-stored config (its path is already an Eldrun-stored copy).
+  const selectVpnConfig = (path: string) => {
+    setVpnConfig(path);
+    setVpnError("");
+    setVpnLog([]);
+    persistVpnConfig(path);
+  };
+
+  // Pick a `.ovpn` file and copy it into Eldrun's store, then adopt it. Joins the
+  // recents list for future reuse.
+  const browseVpnConfig = async () => {
+    const picked = await open({
+      multiple: false,
+      filters: [{ name: "OpenVPN config", extensions: ["ovpn", "conf"] }],
+    });
+    if (typeof picked !== "string") return;
+    try {
+      const stored = await invoke<string>("openvpn_store_config", { config: picked });
+      setVpnConfig(stored);
+      setVpnError("");
+      setVpnLog([]);
+      persistVpnConfig(stored);
+      refreshVpnConfigs();
+    } catch (e) {
+      setVpnError(String(e));
+    }
+  };
+
+  // Seeded from the parked terminals, so reopening the dialog re-adopts a login /
+  // tunnel that is still running rather than losing its handle (see `liveTerms`).
+  const vpnTermRef = useRef<LoginTerm | null>(adoptTerm(liveTerms.get(projectId)?.vpn));
+  const sshTermRef = useRef<LoginTerm | null>(adoptTerm(liveTerms.get(projectId)?.ssh));
+  // Bump to force a re-render when a ref-held terminal is opened/closed (the
+  // terminals themselves live in refs so the readiness effects can read the
+  // current one without re-subscribing on every status change).
+  const [, force] = useReducer((n: number) => n + 1, 0);
+
+  // Readiness poll timer for the SSH login's ControlMaster (see startSshTerm).
+  const sshPollTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const clearSshPoll = () => {
+    if (sshPollTimer.current) {
+      clearTimeout(sshPollTimer.current);
+      sshPollTimer.current = null;
+    }
+  };
+
+  // Per-channel connect "generation". A connect (headless invoke or ControlMaster
+  // poll) captures the current value and only writes its outcome back if it still
+  // matches — so `stopSsh`/`stopVpn` can bump the counter to *abandon* an in-flight
+  // attempt whose backend call can't itself be cancelled (the ssh probe self-times
+  // out at ConnectTimeout=10s; the OpenVPN handshake at CONNECT_TIMEOUT=45s). This
+  // is what makes the Stop button actually resolve a frozen "connecting…" lamp:
+  // without it the stale invoke would later flip the lamp back to error/connected.
+  const sshGen = useRef(0);
+  const vpnGen = useRef(0);
+
+  // Tear everything down when the panel unmounts (project switch / reconnect
+  // succeeded and the panel is replaced by the restored tabs). The PTYs are NOT
+  // killed here — they `persistOnUnmount`, so an authenticated login/tunnel keeps
+  // running for the now-connected project; only the poll timer is cleared.
+  useEffect(() => clearSshPoll, []);
+
+  // Flip the VPN lamp green once the interactive tunnel comes up. The embedded
+  // login spawns `pkexec openvpn` in its own PTY, so the tunnel is not in the
+  // backend's registry — watch the terminal's own output for the ready marker
+  // (a small rolling buffer in case it straddles two chunks), mirroring the
+  // dialog's watcher.
+  useEffect(() => {
+    const term = vpnTermRef.current;
+    if (!term) return;
+    const termId = term.id;
+    let cancelled = false;
+    let un: (() => void) | undefined;
+    let buf = "";
+    void listen<TerminalOutput>("terminal-output", (ev) => {
+      if (ev.payload.id !== termId) return;
+      buf = (buf + ev.payload.data).slice(-512);
+      // The marker is the fastest signal the tunnel is up (the backend also knows,
+      // via the pidfile its `--writepid` arming recorded — but only once OpenVPN
+      // gets around to writing it).
+      if (buf.includes(VPN_READY_MARKER) && vpnConfig) {
+        markVpnConnected(projectId, vpnConfig);
+      }
+    }).then((u) => {
+      if (cancelled) u();
+      else un = u;
+    });
+    return () => {
+      cancelled = true;
+      un?.();
+    };
+    // vpnTerm is ref-held; re-run when its identity changes via the force tick.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [vpnTermRef.current?.id, projectId, vpnConfig]);
+
+  // Bring the OpenVPN tunnel up in an embedded terminal. The connect command
+  // runs interactively so the user types the passphrase in that visible terminal
+  // — Eldrun never handles it. The PTY persists past this panel so the tunnel
+  // stays up for the reconnected project; we pre-mark the dedupe key so any later
+  // activation root-terminal fallback is suppressed.
+  const startVpnTerm = async () => {
+    if (!vpnConfig || vpnTermRef.current) return;
+    try {
+      const command = await invoke<string>("openvpn_login_command", { config: vpnConfig });
+      const key = `vpn:${vpnConfig}`;
+      markConnectionOpened(key);
+      const term = { id: nextReconnectTermId("vpn"), command, key };
+      vpnTermRef.current = term;
+      rememberTerm(projectId, "vpn", term);
+      markVpnConnecting(projectId, vpnConfig);
+      force();
+    } catch {
+      markVpnError(projectId, vpnConfig);
+    }
+  };
+
+  // Stop the OpenVPN channel: cancel any in-flight connect (headless invoke or the
+  // embedded login terminal) and reset the lamp to off. Bumping the generation
+  // abandons a frozen headless connect; killing the PTY + dropping the dedupe mark
+  // tears down an interactive tunnel; `releaseVpn` drops this project's claim on a
+  // tunnel that had already come up. Used by both the terminal Disconnect and the
+  // headless Stop button.
+  //
+  // *Releases*, not disconnects: this button is scoped to one project, but the
+  // tunnel is machine-wide and shared by config path, so it only actually comes
+  // down if no other project is still holding it — otherwise stopping the VPN here
+  // would pull the routing out from under that project and the rest of the OS. The
+  // header's VPN indicator is where a tunnel is killed outright.
+  const stopVpn = () => {
+    vpnGen.current++;
+    const term = vpnTermRef.current;
+    if (term) {
+      // Close the login terminal. This is no longer the *teardown* — the interactive
+      // tunnel is armed with a `--writepid` the backend owns, so `releaseVpn` below
+      // signals the root daemon properly rather than hoping a dead PTY takes it with
+      // it (it didn't: the daemon is root and outlived the terminal).
+      void invoke("pty_kill", { id: term.id }).catch(() => {});
+      forgetConnection(term.key);
+      vpnTermRef.current = null;
+      dropTerm(projectId, "vpn");
+    }
+    releaseVpn(projectId, vpnConfig);
+    setVpn(projectId, "off", hostId);
+    force();
+  };
+
+  // Poll for the embedded login's ControlMaster to come up: a credential-less
+  // ssh_connect rides the master once it is live (and on key-auth hosts succeeds
+  // immediately). On the first success we open the pooled SSH/SFTP connection
+  // (`remote_connect`) and mark SSH connected — which un-gates the CenterPanel
+  // tab restore. Bounded (~2 min) so a never-authenticated login eventually
+  // stops; never hard-errors while the terminal is up (the login may just not be
+  // authenticated yet).
+  const pollSshReady = (attempt = 0, gen = sshGen.current) => {
+    if (!remote || gen !== sshGen.current) return; // stopped mid-poll
+    const maxAttempts = 40; // ~2 min at 3s cadence
+    void invoke<void>("ssh_connect", {
+      // The *live* login name, not the one captured when the poll started. The
+      // ControlMaster socket is hashed over (user, host, port), so probing as a
+      // different account than the login terminal authenticated as finds no master
+      // and polls out — a red lamp behind a login that visibly succeeded.
+      user: effectiveUser(),
+      host: remote.host,
+      port: remote.port ?? null,
+      password: null,
+      // A credential-less probe is ambiguous to the dial policy — it looks exactly
+      // like a background sweep — but this one is waiting on a master the user
+      // just authenticated in the terminal above. Say so, or a host tagged HPC
+      // refuses every attempt and the poll times out behind a visibly-good login.
+      background: false,
+    })
+      .then(async () => {
+        if (gen !== sshGen.current) return; // stopped while the probe ran
+        clearSshPoll();
+        // Master is up; bring the pool up so every later channel rides it.
+        try {
+          // `viaLogin`: this connect rode the master the login terminal above just
+          // established, so its credential-less success says nothing about how the
+          // host authenticates — the backend must not read it as key auth. It used
+          // to (and this hook used to mirror that reading into `keyAuth`), which
+          // stamped `key_auth: true` onto password hosts and made them advertise a
+          // promptless auto-connect that failed on every launch. In this mode the
+          // toggle needs no such evidence: it is offered unconditionally, because
+          // "auto-connect" here *means* this same login opening by itself.
+          // `background: false` — a person opened this login and is waiting on it;
+          // `remote_connect` now defaults to background, which a tagged HPC host
+          // refuses outright.
+          await invoke("remote_connect", {
+            projectId,
+            hostId,
+            password: null,
+            viaLogin: true,
+            background: false,
+          });
+          if (gen !== sshGen.current) return;
+          setSsh(projectId, "connected", hostId);
+        } catch {
+          if (gen !== sshGen.current) return;
+          setSsh(projectId, "error", hostId);
+        }
+      })
+      .catch(() => {
+        if (gen !== sshGen.current) return; // stopped while the probe ran
+        if (attempt + 1 >= maxAttempts) {
+          clearSshPoll();
+          setSsh(projectId, "error", hostId);
+          return;
+        }
+        sshPollTimer.current = setTimeout(() => pollSshReady(attempt + 1, gen), 3000);
+      });
+  };
+
+  // Open the interactive SSH login in an embedded terminal. It establishes the
+  // ControlMaster the pooled connection then rides, so reconnect completes
+  // without Eldrun ever handling the password. Persisted past the panel; the
+  // dedupe mark suppresses any activation root-terminal login.
+  const startSshTerm = async () => {
+    if (!remote || sshTermRef.current || winManual) return;
+    try {
+      // Commit the edited login name FIRST: it is what the command types, what the
+      // readiness probe rides the resulting master with, and what the pooled
+      // `remote_connect` re-reads from the spec. All three must agree.
+      const user = await commitSshUser();
+      const command = await invoke<string>("remote_login_command", {
+        user,
+        host: remote.host,
+        port: remote.port ?? null,
+      });
+      const target = `${user ? `${user}@` : ""}${remote.host}`;
+      const key = `ssh:${target}:${remote.port ?? ""}`;
+      markConnectionOpened(key);
+      const term = { id: nextReconnectTermId("ssh"), command, key };
+      sshTermRef.current = term;
+      rememberTerm(projectId, "ssh", term);
+      const gen = ++sshGen.current;
+      setSsh(projectId, "connecting", hostId);
+      force();
+      pollSshReady(0, gen);
+    } catch {
+      setSsh(projectId, "error", hostId);
+    }
+  };
+
+  // Manual re-arm of the readiness poll ("I've logged in — connect"), for when
+  // the user authenticates after the auto-poll gave up, or wants to retry sooner.
+  const tryConnectNow = () => {
+    if (!sshTermRef.current) return;
+    clearSshPoll();
+    const gen = ++sshGen.current;
+    setSsh(projectId, "connecting", hostId);
+    pollSshReady(0, gen);
+  };
+
+  // ── Headless connect path (Connect modal, `connections_headless` ON) ─────────
+  // Eldrun feeds the password to the backend itself (no visible login terminal);
+  // the OpenVPN handshake streams into `vpnLog` as a read-only progress view.
+
+  // Stream the live OpenVPN handshake into `vpnLog` (only lines for this
+  // project's config; the backend tags each line with its config path).
+  useEffect(() => {
+    if (!vpnConfig) return;
+    let cancelled = false;
+    let un: (() => void) | undefined;
+    void listen<{ config: string; line: string }>("openvpn-progress", (ev) => {
+      if (ev.payload.config !== vpnConfig) return;
+      setVpnLog((prev) => [...prev, { id: vpnLogSeq.current++, text: ev.payload.line }].slice(-500));
+    }).then((u) => {
+      if (cancelled) u();
+      else un = u;
+    });
+    return () => {
+      cancelled = true;
+      un?.();
+    };
+  }, [vpnConfig]);
+
+  // Bring the OpenVPN tunnel up with the supplied secrets. `keyPassphrase` is only
+  // a distinct secret for a config that has an encrypted key *and* an
+  // `auth-user-pass` account (see `needsSeparateKeyPassphrase`); otherwise
+  // `password` already is the key passphrase and this is empty. Blocks until the
+  // backend reports the tunnel ready (or fails). Mirrors `useRemoteSession`'s
+  // headless `connectVpn`.
+  //
+  // `remember` follows the same `true | null`, never-`false` rule the SSH connect
+  // does, and for the identical reason: `openvpn_connect` also resolves
+  // `typed || saved` before calling `remember_secret`, so a `false` on a
+  // *successful* connect clears the passphrase (and username, and key passphrase)
+  // it just authenticated with. Unticking deletes via `forgetVpnPassword`.
+  const connectVpnHeadless = async (
+    password: string,
+    keyPassphrase = "",
+    remember: true | null = null,
+  ) => {
+    if (!vpnConfig) return;
+    const gen = ++vpnGen.current;
+    markVpnConnecting(projectId, vpnConfig);
+    setVpnError("");
+    setVpnLog([]);
+    try {
+      await invoke("openvpn_connect", {
+        config: vpnConfig,
+        username: vpnUsername || null,
+        // Blank means "use the saved passphrase", never "authenticate with the empty
+        // string" — send null so the backend falls back to the keychain.
+        password: password || null,
+        keyPassphrase: keyPassphrase || null,
+        remember,
+      });
+      if (gen !== vpnGen.current) {
+        // Stopped mid-connect — but the tunnel came up anyway: `stopVpn`'s teardown
+        // raced ahead of the handshake it was trying to cancel. Leaving it would
+        // strand the machine's routing on a tunnel nobody asked for and nothing in
+        // the UI claims. Release again now that it's real (a no-op if some *other*
+        // project is holding this config).
+        releaseVpn(projectId, vpnConfig);
+        return;
+      }
+      // Persist the (non-secret) username so a later silent activation can reuse
+      // it from the keychained password with no prompt.
+      if (vpnNeeds.username && vpnUsername) persistVpnConfig(vpnConfig);
+      setVpnSaved(remember === true);
+      markVpnConnected(projectId, vpnConfig);
+    } catch (e) {
+      if (gen !== vpnGen.current) return; // stopped — ignore the stale failure
+      markVpnError(projectId, vpnConfig);
+      setVpnError(String(e));
+    }
+  };
+
+  // Open the pooled SSH/SFTP connection with the supplied password. On success
+  // the pool is up and the SSH lamp goes green — which lets the CenterPanel's
+  // held remote panes mount and spawn. Mirrors `pollSshReady`'s success branch
+  // but with a user-typed password rather than riding an existing ControlMaster.
+  //
+  // `remember` is `true` ("save it") or `null`/`undefined` ("leave the keychain
+  // alone") and **never** `false`: `false` is `Remember::Clear`, and since
+  // `ssh_connect` resolves `typed || saved` before it writes, a successful connect
+  // carrying it deletes the very password it authenticated with. Callers build the
+  // value with `rememberArg`; deleting is the explicit forget's job alone.
+  const connectSshHeadless = async (password: string, remember?: true | null) => {
+    if (!remote) return;
+    const gen = ++sshGen.current;
+    setSsh(projectId, "connecting", hostId);
+    setSshError("");
+    // A blank field means "use what's saved" (the secret itself never comes back to
+    // the UI, so a saved password can't be pre-filled — the user just leaves it
+    // empty). Send null, not "": both legs read null as "nothing given" and fall
+    // back to the keychain, where `""` would be taken as the password itself.
+    const secret = password || null;
+    try {
+      // Commit the edited login name before either leg runs: `remote_connect` reads
+      // the *persisted* spec, so a name that lived only in this component would
+      // authenticate the probe as one account and the pool as another.
+      const user = await commitSshUser();
+      // First contact: if this host's key has never been accepted here, show its
+      // fingerprint before the password goes anywhere, and retry once if accepted.
+      const outcome = await withHostKeyConfirm(() =>
+        invoke<SshConnectOutcome>("ssh_connect", {
+        user,
+        host: remote.host,
+        port: remote.port ?? null,
+        password: secret,
+        // The checkbox, or `null` when there isn't one (the Windows key-auth
+        // Connect button): `false` means "the user unticked it" and clears the
+        // saved password — never say that on the user's behalf.
+        remember: remember ?? null,
+        // A typed password already reads as a gesture backend-side, but a blank
+        // field riding a saved credential does not — and this is a Connect click
+        // either way.
+        background: false,
+        }),
+      );
+      if (gen !== sshGen.current) return; // stopped mid-connect
+      // The password must be handed to `remote_connect` too, not just the probe.
+      // `ssh_connect` authenticates a throwaway process with `ControlMaster=no`
+      // (reuse-only — it never *creates* a master), so a successful probe leaves
+      // nothing behind for the pool to ride. `remote_connect` is what opens the
+      // master-owning pooled session, and with a null password it drops to
+      // key/agent auth — which a password-auth host rejects. It falls back to a
+      // *saved* password, so this only ever worked with "Save password" ticked.
+      await withHostKeyConfirm(() =>
+        invoke("remote_connect", { projectId, hostId, password: secret, background: false }),
+      );
+      if (gen !== sshGen.current) return;
+      // What is saved is what the backend **did**, not what the request asked for:
+      // a locked keyring refuses the write and reports why, and a ticked box over
+      // an empty keychain is exactly the state that resurfaces at the next launch
+      // as an unexplained password prompt.
+      sshCredential.applyOutcome(outcome);
+      // No password given, none saved, and the connect still succeeded → the host
+      // authenticated via key/agent auth (the backend records the same). Flip the
+      // eligibility flag so the Auto-connect toggle comes alive here, no reload.
+      if (secret === null && !sshSaved && !remember) setKeyAuth(true);
+      setSsh(projectId, "connected", hostId);
+    } catch (e) {
+      if (gen !== sshGen.current) return; // stopped — ignore the stale failure
+      setSsh(projectId, "error", hostId);
+      setSshError(String(e));
+    }
+  };
+
+  // Delete this project's saved SSH password from the OS keychain. Used by both
+  // "Forget saved password" and by unticking "Save password" — unticking is a
+  // request to not have the secret stored, and deferring that to the next connect
+  // would leave it sitting in the keychain for a session that may never reconnect.
+  // The live connection is untouched: forgetting a credential and dropping the pool
+  // are separate acts; the caller pairs them for a full log-out.
+  const forgetSshPassword = async () => {
+    if (!remote) return;
+    try {
+      await sshCredential.forget();
+      // Auto-connect leaned on that password: with it gone (and no key auth to fall
+      // back on) the opt-in can no longer fire, so clear it rather than leave a
+      // ticked toggle that silently does nothing. `autoConnectRemote` re-checks
+      // eligibility anyway — this just keeps the UI honest.
+      if (remote.auto_connect && remote.key_auth !== true) setAutoConnect(false);
+    } catch (e) {
+      setSshError(String(e));
+    }
+  };
+
+  // Same for the VPN passphrase (and, for a config with both, its key passphrase —
+  // `vpn_forget_password` clears both accounts).
+  const forgetVpnPassword = async () => {
+    if (!vpnConfig) return;
+    try {
+      await invoke("vpn_forget_password", { config: vpnConfig });
+      setVpnSaved(false);
+    } catch (e) {
+      setVpnError(String(e));
+    }
+  };
+
+  // "Forget saved password": drop every credential this project has stored.
+  const forgetPasswords = async () => {
+    await forgetSshPassword();
+    await forgetVpnPassword();
+  };
+
+  // Stop the SSH channel: cancel any in-flight connect (headless invoke or the
+  // ControlMaster poll), tear down an embedded login terminal, best-effort drop a
+  // half-open pool, and reset the lamp to off. Mirror of `stopVpn`; used by both
+  // the terminal Disconnect and the headless Stop button.
+  const stopSsh = () => {
+    sshGen.current++;
+    clearSshPoll();
+    const term = sshTermRef.current;
+    if (term) {
+      void invoke("pty_kill", { id: term.id }).catch(() => {});
+      forgetConnection(term.key);
+      sshTermRef.current = null;
+      dropTerm(projectId, "ssh");
+    }
+    void invoke("remote_disconnect", { projectId, hostId }).catch(() => {});
+    setSsh(projectId, "off", hostId);
+    force();
+  };
+
+  return {
+    sshStatus,
+    vpnStatus,
+    // The SSH login name, editable in both modes (see `commitSshUser`).
+    sshUser,
+    setSshUser,
+    commitSshUser,
+    vpnConfig,
+    vpnConfigs,
+    vpnUsername,
+    setVpnUsername,
+    vpnNeeds,
+    // A second field is only warranted when the key passphrase is a *different*
+    // secret from the password — see `needsSeparateKeyPassphrase`.
+    vpnNeedsKeyPassphrase: needsSeparateKeyPassphrase(vpnNeeds),
+    selectVpnConfig,
+    browseVpnConfig,
+    winManual,
+    vpnTerm: vpnTermRef.current,
+    sshTerm: sshTermRef.current,
+    startVpnTerm,
+    stopVpn,
+    startSshTerm,
+    stopSsh,
+    tryConnectNow,
+    // Headless connect path
+    sshError,
+    vpnError,
+    vpnLog,
+    sshSaved,
+    // The tri-state behind `sshSaved`, for the shared "Save password" row: it is
+    // what lets a locked keychain say so instead of proposing a delete.
+    sshCredential,
+    vpnSaved,
+    autoConnect,
+    autoConnectEligible,
+    // Which wall an ineligible switch hit — the two have different remedies.
+    autoConnectBlock: autoConnectState.reason,
+    setAutoConnect,
+    setWorkerLabel,
+    connectVpnHeadless,
+    connectSshHeadless,
+    forgetPasswords,
+    forgetSshPassword,
+    forgetVpnPassword,
+  };
+}
diff --git a/src/components/projects/useRemoteSession.ts b/src/components/projects/useRemoteSession.ts
index e5213c1..28ed775 100644
--- a/src/components/projects/useRemoteSession.ts
+++ b/src/components/projects/useRemoteSession.ts
@@ -1,11 +1,59 @@
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
 import { open } from "@tauri-apps/plugin-dialog";
-import type { RemoteEntry, SshTooling } from "../../types";
+import {
+  needsSeparateKeyPassphrase,
+  type SshTooling,
+  type StoredVpnConfig,
+  type VpnAuthNeeds,
+} from "../../types";
 import { joinRemotePath, parseSshAddress, type ParsedSshAddress } from "./scaffold";
+import { useRemoteBrowse } from "./useRemoteBrowse";
+import { rememberArg, useSavedCredential } from "./useSavedCredential";
+import { useVpnStatusStore } from "../../stores/vpnStatus";
+import { IS_WINDOWS } from "../../lib/platform";
+import {
+  forgetConnection,
+  markConnectionOpened,
+  resolveRemoteStartDir,
+} from "../../lib/remoteConnect";
+import { useSettingsStore } from "../../stores/settings";
+import type { LogLine } from "../common/ConnectionLog";
 
 type ConnStatus = "idle" | "connecting" | "connected" | "error";
 
+// OpenVPN prints this once the tunnel is fully up (mirrors the backend's
+// READY_MARKER in services/openvpn.rs). The embedded VPN login terminal is
+// watched for it to flip the lamp green (see the readiness watcher below).
+const VPN_READY_MARKER = "Initialization Sequence Completed";
+
+// What the bounded ControlMaster poll says when it runs out. A give-up has to be
+// *stated*: the lamp is the only thing the user can see, and an amber one that
+// never resolves is indistinguishable from one still trying. (Raw English, as the
+// rest of this hook's error strings are — the i18n boundary here is
+// `RemoteProjectSection`, which renders them.)
+const POLL_GAVE_UP =
+  "No login detected after two minutes. Finish signing in in the terminal, then press “I've logged in — browse”.";
+
+// Shape of the `terminal-output` event payload (PTY id + a raw output chunk),
+// matching the backend emit and TerminalView's own listener.
+interface TerminalOutput {
+  id: string;
+  data: string;
+}
+
+/** Steps of the remote-project flow: connect (SSH + VPN) → browse a remote
+ *  folder → fill in name/details. Local projects bypass these entirely. */
+export type RemoteStep = "connect" | "browse" | "details";
+
+// Monotonic id source for the dialog-embedded connection terminals. The id has
+// no ":" so it never collides with a tab PTY id (`<scope>:<key>`) or trips the
+// detached-PTY check. (Module scope so the counter survives re-renders.)
+let dialogTermSeq = 0;
+
+const nextDialogTermId = (kind: string) => `dialog-${kind}-${++dialogTermSeq}`;
+
 /**
  * Owns the optional SSH + OpenVPN connection lifecycle for the new/import
  * project dialog: tooling probe, connect/disconnect, the live remote folder
@@ -13,51 +61,166 @@ type ConnStatus = "idle" | "connecting" | "connected" | "error";
  * stays a single cohesive form component; behavior is unchanged.
  */
 export function useRemoteSession({ kind }: { kind: "new" | "import" }) {
+  // Mirrors the global `connections_headless` setting (default ON): headless →
+  // the password/passphrase is typed into Eldrun's own fields and the backend
+  // connects directly (`connectSsh`/`connectVpn`), same as activation's
+  // `ensureVpnIfNeeded`. Off → the integrated login terminal is used instead, so
+  // the user types the secret into a visible terminal embedded right here and
+  // Eldrun never handles it.
+  const headless = useSettingsStore((s) => s.settings?.connections_headless ?? true);
   // Whether this is a remote (SSH) project. The whole SSH section — address,
   // password, connect, and the remote browser — only appears when this is on.
   const [isRemoteProject, setIsRemoteProject] = useState(false);
-  // Availability of sshfs/sshpass/openvpn, fetched the first time the remote
-  // checkbox is enabled so missing tools are flagged up front rather than only
-  // after a connect/mount fails. `null` until probed.
+  // Availability of password-auth/openvpn tooling, fetched the first time the
+  // remote checkbox is enabled so missing tools are flagged up front rather than
+  // only after a connect fails. `null` until probed.
   const [sshTooling, setSshTooling] = useState<SshTooling | null>(null);
   const [sshAddress, setSshAddress] = useState("");
+  // Previously-used SSH addresses (newest first), offered for reuse so a host
+  // need only be typed once. Loaded when the remote section opens and refreshed
+  // after a successful connect remembers the address (see rememberSshAddress).
+  const [sshAddresses, setSshAddresses] = useState<string[]>([]);
   const [sshPassword, setSshPassword] = useState("");
   const [sshStatus, setSshStatus] = useState<ConnStatus>("idle");
   const [sshError, setSshError] = useState("");
+  // "Save password" opt-in (default OFF), identical in mechanism to the Connect
+  // modal's: the secret goes to the OS keychain **after** a successful auth, keyed
+  // by the *host target* — not by the project, which doesn't exist yet here. That
+  // is what lets the credential typed while creating/extending a project be the one
+  // its later reconnects (and auto-connect) authenticate with, instead of being
+  // thrown away the moment this dialog closes.
+  const [sshRemember, setSshRemember] = useState(false);
+  // The connect-and-browse mechanism (frozen (host, password) session + live SFTP
+  // listing + navigation) is the SHARED one every remote-login dialog uses — see
+  // `useRemoteBrowse`. This flow keeps its own fields/steps/VPN around it; the
+  // browser state below is just re-exposed under the names the rest of this hook
+  // and `RemoteProjectSection` already read.
+  const browse = useRemoteBrowse();
   // The SSH address that was successfully connected (frozen at connect time so
   // edits to the input don't silently change which host we browse/submit to).
-  const [remoteConn, setRemoteConn] = useState<ParsedSshAddress | null>(null);
+  const remoteConn = browse.conn;
   // The password that was used for the successful connect, frozen so the remote
   // listing always reuses the same credential the connection was made with.
-  const [remotePassword, setRemotePassword] = useState("");
-  const [remoteBrowsePath, setRemoteBrowsePath] = useState("");
-  const [remoteEntries, setRemoteEntries] = useState<RemoteEntry[]>([]);
-  const [remoteListBusy, setRemoteListBusy] = useState(false);
-  const [remoteListError, setRemoteListError] = useState("");
+  const remotePassword = browse.password;
+  const remoteBrowsePath = browse.path;
+  const remoteEntries = browse.entries;
+  const remoteListBusy = browse.busy;
+  const remoteListError = browse.error;
   // The remote folder the user committed to via "Use this folder".
   const [remoteChosenPath, setRemoteChosenPath] = useState("");
+  // Previously-used remote paths for the current host (newest first), offered
+  // for reuse so a project location need only be browsed/typed once per host.
+  // Refreshed whenever the resolved host changes; see the effect below.
+  const [remotePaths, setRemotePaths] = useState<string[]>([]);
   // --- Optional OpenVPN tunnel for VPN-gated remote hosts ---
+  // "Connect via OpenVPN" opt-in, default OFF. Most hosts are reached directly
+  // when you're already on the right network, so the VPN section stays collapsed
+  // (and no config is stored on the project) until the user turns this on.
+  const [vpnEnabled, setVpnEnabled] = useState(false);
   // `vpnConfig` holds the Eldrun-stored `.ovpn` path (the picked file is copied
   // into Eldrun on selection). The password is transient — never persisted.
-  const [vpnEnabled, setVpnEnabled] = useState(false);
+  // A tunnel is "used" only when the toggle is on AND a config is selected.
   const [vpnConfig, setVpnConfig] = useState("");
+  // Auth username for `auth-user-pass` configs (server-side username+password
+  // auth). `vpnNeeds` (queried when the config changes) decides which fields are
+  // shown and required; the username is persisted onto the new project's
+  // OpenVpnSpec (it is not a secret). See `config_requires_userpass`.
+  const [vpnUsername, setVpnUsername] = useState("");
+  const [vpnNeeds, setVpnNeeds] = useState<VpnAuthNeeds>({
+    username: false,
+    keyPassphrase: false,
+  });
   const [vpnPassword, setVpnPassword] = useState("");
+  // Second secret, only for a config with an encrypted key *and* an
+  // `auth-user-pass` account — OpenVPN prompts for those independently. Without an
+  // account, `vpnPassword` already is the key passphrase (see
+  // `needsSeparateKeyPassphrase`), so no second field is shown.
+  const [vpnKeyPassphrase, setVpnKeyPassphrase] = useState("");
   const [vpnStatus, setVpnStatus] = useState<ConnStatus>("idle");
   const [vpnError, setVpnError] = useState("");
+  // The VPN twin of `sshRemember`/`sshSaved`, keyed by config path. One toggle for
+  // the whole tunnel (password + key passphrase + username), as in the Connect
+  // modal — the backend saves or clears the set together.
+  const [vpnRemember, setVpnRemember] = useState(false);
+  const [vpnSaved, setVpnSaved] = useState(false);
+  // Live OpenVPN handshake output for the headless connect, streamed from the
+  // backend (`openvpn-progress`) and shown in a read-only log so the connect
+  // isn't an opaque spinner. Reset at the start of each connect attempt.
+  const [vpnLog, setVpnLog] = useState<LogLine[]>([]);
+  // Monotonic id source for `vpnLog` lines. A dedicated counter (never reset on
+  // slice) gives each pushed line a stable React key so the `.slice(-500)` cap
+  // trims only the head without re-creating surviving line nodes.
+  const vpnLogSeq = useRef(0);
+  // Previously-used `.ovpn` configs (newest first), offered for reuse so a
+  // config need only be browsed for once. Refreshed when the VPN section opens
+  // and after a new config is stored.
+  const [vpnConfigs, setVpnConfigs] = useState<StoredVpnConfig[]>([]);
+  // --- Non-headless in-dialog connection terminals ---
+  // In non-headless mode the OpenVPN tunnel and SSH login are interactive: the
+  // user types the passphrase/password into a live terminal. Rather than
+  // deferring those to a root-terminal tab at activation (the old flow), we
+  // embed the live terminal right here in the dialog. Each holds `{ id, command }`
+  // for an embedded `TerminalView` that runs `command` in a shell. The PTY is
+  // spawned with `persistOnUnmount`, so closing the dialog leaves the
+  // tunnel/login up for the new project to use; we also pre-mark the activation
+  // dedupe key (see `markConnectionOpened`) so the root-tab flow is skipped.
+  // Each holds the activation dedupe `key` it pre-marked (see `markConnectionOpened`)
+  // so the matching `stopX` forgets *that* key — not one rebuilt from current
+  // render state, which may have drifted (e.g. the config/address changed while
+  // the terminal was up), leaving a stale mark that suppresses the real connect.
+  const [vpnTerm, setVpnTerm] = useState<{ id: string; command: string; key: string } | null>(
+    null,
+  );
+  const [sshTerm, setSshTerm] = useState<{ id: string; command: string; key: string } | null>(
+    null,
+  );
+
+  // Per-connect "sign in in a terminal" (see `TerminalSignInToggle`): in headless
+  // mode these swap the password fields for the same embedded login terminal the
+  // non-headless mode uses, for this one connect. Default off — headless is the mode;
+  // this is only the escape hatch for a host or tunnel that asks something the fields
+  // cannot answer (a challenge code, a second prompt).
+  const [sshViaTerminal, setSshViaTerminal] = useState(false);
+  const [vpnViaTerminal, setVpnViaTerminal] = useState(false);
 
   const isRemote = sshStatus === "connected" && remoteConn !== null;
 
+  // Windows has no ssh ControlMaster socket, so a non-headless login can't be
+  // ridden for SFTP browsing — that mode falls back to typing the remote path.
+  const winManual = IS_WINDOWS && !headless;
+
+  // Which step of the remote flow we're on. Local projects ignore this (the
+  // dialog renders its single form whenever the project isn't remote).
+  const [step, setStep] = useState<RemoteStep>("connect");
+
+  // Timer for the non-headless browse-readiness poll (see startSshTerm): once the
+  // embedded interactive login authenticates, the shared ControlMaster comes up
+  // and an otherwise-credential-less ssh_connect starts succeeding, at which point
+  // we flip to the same connected/browse state headless reaches via connectSsh.
+  const sshPollTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const clearSshPoll = () => {
+    if (sshPollTimer.current) {
+      clearTimeout(sshPollTimer.current);
+      sshPollTimer.current = null;
+    }
+  };
+  useEffect(() => clearSshPoll, []);
+
+  // Advance to the browser the moment the SSH session goes live (either mode),
+  // so the user sees the lamp turn green and lands on the folder picker.
+  useEffect(() => {
+    if (isRemote) setStep((s) => (s === "connect" ? "browse" : s));
+  }, [isRemote]);
+
   // Drop any live remote session back to the disconnected state. Called when
   // the user edits a credential (address/password) or unchecks "remote".
   const resetSshSession = () => {
+    clearSshPoll();
     setSshStatus("idle");
     setSshError("");
-    setRemoteConn(null);
-    setRemotePassword("");
-    setRemoteEntries([]);
-    setRemoteBrowsePath("");
+    browse.reset();
     setRemoteChosenPath("");
-    setRemoteListError("");
+    setStep("connect");
   };
 
   // Toggle remote mode. Turning it off tears down the SSH session and clears the
@@ -75,16 +238,202 @@ export function useRemoteSession({ kind }: { kind: "new" | "import" }) {
       setSshAddress("");
       setSshPassword("");
       resetSshSession();
-      setVpnEnabled(false);
+      stopSshTerm();
       setVpnConfig("");
       setVpnPassword("");
+      setVpnKeyPassphrase("");
       setVpnStatus("idle");
       setVpnError("");
+      stopVpnTerm();
+    }
+  };
+
+  // Load the list of previously-stored configs (newest first). Best-effort.
+  const refreshVpnConfigs = () => {
+    invoke<StoredVpnConfig[]>("openvpn_list_configs")
+      .then(setVpnConfigs)
+      .catch(() => setVpnConfigs([]));
+  };
+
+  // Load the recently-used SSH addresses (newest first). Best-effort.
+  const refreshSshAddresses = () => {
+    invoke<string[]>("ssh_list_addresses")
+      .then(setSshAddresses)
+      .catch(() => setSshAddresses([]));
+  };
+
+  // Persist `addr` as the most-recently-used SSH address and refresh the local
+  // list so it surfaces immediately in the dropdown. Best-effort — a store
+  // failure must never block the connection that just succeeded.
+  const rememberSshAddress = (addr: string) => {
+    const trimmed = addr.trim();
+    if (!trimmed) return;
+    invoke("ssh_remember_address", { address: trimmed })
+      .then(refreshSshAddresses)
+      .catch(() => {});
+  };
+
+  // Fetch the recent-configs and recent-addresses lists when the remote section
+  // opens so a previously-used config/host can be picked without re-entering it.
+  useEffect(() => {
+    if (isRemoteProject) {
+      refreshVpnConfigs();
+      refreshSshAddresses();
     }
+  }, [isRemoteProject]);
+
+  // ── Saved credentials (OS keychain) ─────────────────────────────────────────
+  // Both toggles mirror the Connect modal exactly, because they write the *same*
+  // entries: the keychain is keyed by host target / config path, so there is one
+  // saved credential per host and per tunnel, whichever menu put it there.
+
+  // Does this host target already have a saved password? Re-asked as the typed
+  // address changes, so the toggle always reflects the target being connected.
+  // The shared tri-state hook, not a boolean: a locked keychain answers a lookup
+  // exactly like an empty one, and taking that as "nothing saved" is what unticked
+  // the box — which, before `remember` stopped being able to carry `false`, made
+  // the next successful connect *delete* the credential it had authenticated with.
+  const sshTarget = isRemoteProject ? parseSshAddress(sshAddress) : null;
+  const sshCredential = useSavedCredential(
+    sshTarget
+      ? { user: sshTarget.user ?? null, host: sshTarget.host, port: sshTarget.port ?? null }
+      : null,
+  );
+  const sshSaved = sshCredential.saved;
+  // Pre-tick only on a *known*-saved credential; "checking"/"unreadable" leave the
+  // box off, and an off box now means "leave the keychain alone", not "clear it".
+  useEffect(() => setSshRemember(sshSaved), [sshSaved]);
+
+  // Same question for the selected `.ovpn` (all of its secrets, so a config that
+  // needs two and has one saved reports "not saved" — a silent connect would fail).
+  useEffect(() => {
+    if (!vpnConfig) {
+      setVpnSaved(false);
+      return;
+    }
+    let cancelled = false;
+    invoke<boolean>("vpn_has_saved_password", { config: vpnConfig })
+      .then((saved) => !cancelled && setVpnSaved(saved))
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [vpnConfig]);
+  useEffect(() => setVpnRemember(vpnSaved), [vpnSaved]);
+
+  // Unticking a *saved* toggle is a request to drop the secret now — not at the
+  // next connect, which may never come (the user may be about to abandon this
+  // dialog). Same semantics as the Connect modal's toggles.
+  const forgetSshPassword = async () => {
+    await sshCredential.forget();
+    setSshRemember(false);
+  };
+
+  const forgetVpnPassword = async () => {
+    if (!vpnConfig) return;
+    await invoke("vpn_forget_password", { config: vpnConfig }).catch(() => {});
+    setVpnSaved(false);
+    setVpnRemember(false);
+  };
+
+  // Load the recently-used remote paths for `host` (newest first). Best-effort;
+  // an empty/unresolved host just clears the list.
+  const refreshRemotePaths = (host: string) => {
+    if (!host) {
+      setRemotePaths([]);
+      return;
+    }
+    invoke<string[]>("remote_list_paths", { host })
+      .then(setRemotePaths)
+      .catch(() => setRemotePaths([]));
+  };
+
+  // Persist `path` as the most-recently-used remote path for `host` and refresh
+  // the local list. Best-effort — a store failure must never block project
+  // creation, which already succeeded by the time this is called.
+  const rememberRemotePath = (host: string, path: string) => {
+    const trimmed = path.trim();
+    if (!host || !trimmed) return;
+    invoke("remote_remember_path", { host, path: trimmed })
+      .then(() => refreshRemotePaths(host))
+      .catch(() => {});
+  };
+
+  // The host path suggestions are scoped to: the live-connected host (browse
+  // mode), or the address as currently typed (Windows manual-path mode, which
+  // never opens a live session before submit).
+  const suggestionHost = remoteConn?.host ?? (winManual ? parseSshAddress(sshAddress)?.host : undefined);
+
+  // Refresh the path suggestions whenever the resolved host changes.
+  useEffect(() => {
+    refreshRemotePaths(suggestionHost ?? "");
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [suggestionHost]);
+
+  // Remember a chosen remote path against the resolved host so it's offered in
+  // the "Recently used…" lists on the next SSH project for the same host. Called
+  // both when a browsed folder is committed ("Use this folder") and right before
+  // a remote project is actually created/imported (see `buildRemoteSpec`'s call
+  // site). `path` defaults to the committed `remoteChosenPath`; the browse commit
+  // passes the just-browsed path explicitly, since the `remoteChosenPath` state
+  // update from the same click isn't visible yet.
+  const rememberChosenPath = (path?: string) => {
+    const target = (path ?? remoteChosenPath).trim();
+    if (!suggestionHost || !target) return;
+    rememberRemotePath(suggestionHost, target);
+  };
+
+  // Stream the live OpenVPN handshake into `vpnLog` while the VPN section is
+  // open. The backend tags each line with the config it belongs to, so we keep
+  // only lines for the config currently selected here (the dialog connects one
+  // tunnel at a time). Capped so a chatty handshake can't grow unbounded.
+  useEffect(() => {
+    if (!vpnConfig) return;
+    let cancelled = false;
+    let un: (() => void) | undefined;
+    void listen<{ config: string; line: string }>("openvpn-progress", (ev) => {
+      if (ev.payload.config !== vpnConfig) return;
+      setVpnLog((prev) => [...prev, { id: vpnLogSeq.current++, text: ev.payload.line }].slice(-500));
+    }).then((u) => {
+      if (cancelled) u();
+      else un = u;
+    });
+    return () => {
+      cancelled = true;
+      un?.();
+    };
+  }, [vpnConfig]);
+
+  // Which secrets does the chosen config need (an `auth-user-pass` account, an
+  // encrypted key's passphrase, or both)? Drives which fields are shown/required —
+  // a field OpenVPN wants but we don't supply becomes an unanswered stdin prompt
+  // and hangs the handshake.
+  useEffect(() => {
+    if (!vpnConfig) {
+      setVpnNeeds({ username: false, keyPassphrase: false });
+      return;
+    }
+    let cancelled = false;
+    void invoke<VpnAuthNeeds>("openvpn_auth_needs", { config: vpnConfig })
+      .then((v) => !cancelled && setVpnNeeds(v))
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [vpnConfig]);
+
+  // Select one of the previously-stored configs (its path is already an
+  // Eldrun-stored copy, so it's used as-is — no re-copy needed).
+  const selectVpnConfig = (path: string) => {
+    setVpnConfig(path);
+    setVpnStatus("idle");
+    setVpnError("");
+    setVpnLog([]); // drop the previous config's handshake output
   };
 
   // Pick a `.ovpn` config and copy it into Eldrun so the project no longer
-  // depends on the original file's location (stored on first use).
+  // depends on the original file's location (stored on first use). The new copy
+  // joins the recent-configs list for future reuse.
   const browseVpnConfig = async () => {
     const picked = await open({
       multiple: false,
@@ -96,29 +445,264 @@ export function useRemoteSession({ kind }: { kind: "new" | "import" }) {
       setVpnConfig(stored);
       setVpnStatus("idle");
       setVpnError("");
+      setVpnLog([]); // drop the previous config's handshake output
+      refreshVpnConfigs();
     } catch (e) {
       setVpnError(String(e));
     }
   };
 
   // Bring the tunnel up now so a VPN-gated host becomes reachable for browsing.
+  //
+  // This is the *creation* dialog, so there is no project id yet and nobody can be
+  // recorded as a holder — the tunnel comes up unclaimed. It is still machine-wide
+  // and still rerouting everything, so it is registered machine-level regardless:
+  // the header indicator shows it (and can bring it down) even if the user abandons
+  // the dialog without ever creating the project.
+  //
+  // **Why not the `markVpn*` helpers.** They do two things: light the *project's*
+  // lamp and keep the machine-level entry (plus the holder refcount `releaseVpn`
+  // depends on) in step. Here the first half has no subject — the project id
+  // genuinely does not exist yet — and inventing one would be worse than skipping
+  // it: a holder nothing can ever call `releaseVpn` for is a tunnel nothing can
+  // ever bring down. So the holder is a **deliberate no-op**, said out loud here so
+  // the next reader doesn't "fix" the asymmetry by minting an id. The machine-level
+  // half below is exactly what the helpers would have written.
   const connectVpn = async () => {
     if (!vpnConfig) return;
     setVpnStatus("connecting");
     setVpnError("");
+    setVpnLog([]);
+    useVpnStatusStore.getState().setState(vpnConfig, "connecting");
     try {
-      await invoke("openvpn_connect", { config: vpnConfig, password: vpnPassword });
+      await invoke("openvpn_connect", {
+        config: vpnConfig,
+        username: vpnUsername || null,
+        // Blank + a saved credential = "use the saved one" (the backend falls back
+        // to the keychain), the same contract the Connect modal's blank field has.
+        password: vpnPassword,
+        keyPassphrase: vpnKeyPassphrase || null,
+        // `true` or `null`, never `false`: `openvpn_connect` resolves
+        // `typed || saved` before it writes, so a `false` on a *successful*
+        // connect clears the passphrase it just authenticated with — the same
+        // shape as the SSH bug. Unticking deletes via `forgetVpnPassword`.
+        remember: rememberArg(vpnRemember),
+      });
       setVpnStatus("connected");
+      setVpnSaved(vpnRemember);
+      useVpnStatusStore.getState().setState(vpnConfig, "connected");
+    } catch (e) {
+      setVpnStatus("error");
+      setVpnError(String(e));
+      // `error`, not `off`. `markVpnError` may forget the machine-level entry
+      // because the project's own red lamp carries the failure — and here there is
+      // no project lamp, so a bare "off" is indistinguishable from never having
+      // tried. The header is the only surface that can report it. `refresh` (every
+      // 10 s, off the backend's live tunnel set) clears it again by itself, and
+      // `anyVpnLive` ignores `error`, so nothing treats it as a live tunnel.
+      useVpnStatusStore.getState().setState(vpnConfig, "error");
+    }
+  };
+
+  // Non-headless: bring the OpenVPN tunnel up in a terminal embedded in the
+  // dialog. The connect command (`pkexec openvpn … --auth-nocache`) runs
+  // interactively so the user types the passphrase in that visible terminal —
+  // Eldrun never handles it. The PTY persists past the dialog so the tunnel
+  // stays up for the new project; we pre-mark the dedupe key so activation's
+  // root-terminal fallback (`ensureVpnIfNeeded`) is suppressed.
+  const startVpnTerm = async () => {
+    if (!vpnConfig || vpnTerm) return;
+    try {
+      const command = await invoke<string>("openvpn_login_command", { config: vpnConfig });
+      const key = `vpn:${vpnConfig}`;
+      markConnectionOpened(key);
+      setVpnTerm({ id: nextDialogTermId("vpn"), command, key });
+      // The handshake is now in flight in the terminal below — light the lamp
+      // orange until the readiness watcher (below) sees the ready marker.
+      setVpnStatus("connecting");
+      setVpnError("");
+      // And tell the MACHINE, not just this dialog. An interactive tunnel reroutes
+      // the whole computer exactly as a headless one does, so the header indicator
+      // has to show it coming up — the headless path above already says so, and
+      // `useRemoteReconnect`'s terminal path does too. Without this the one place
+      // a tunnel could be brought back down stayed dark while it came up.
+      useVpnStatusStore.getState().setState(vpnConfig, "connecting");
     } catch (e) {
       setVpnStatus("error");
       setVpnError(String(e));
+      useVpnStatusStore.getState().setState(vpnConfig, "error");
+    }
+  };
+
+  // Flip the VPN lamp green once the interactive tunnel comes up. The embedded
+  // login spawns `pkexec openvpn` inside its own PTY, so the tunnel is *not* in
+  // the backend's tunnel registry — `openvpn_status` can't see it. Instead we
+  // watch that terminal's own output for OpenVPN's ready marker (the same string
+  // the headless backend waits on). Output arrives in chunks, so we keep a small
+  // rolling buffer in case the marker straddles two `terminal-output` events.
+  useEffect(() => {
+    if (!vpnTerm) return;
+    const termId = vpnTerm.id;
+    let cancelled = false;
+    let un: (() => void) | undefined;
+    let buf = "";
+    void listen<TerminalOutput>("terminal-output", (ev) => {
+      if (ev.payload.id !== termId) return;
+      buf = (buf + ev.payload.data).slice(-512);
+      if (buf.includes(VPN_READY_MARKER)) {
+        setVpnStatus("connected");
+        // Same reason as `startVpnTerm`'s "connecting": the tunnel is up and the
+        // machine is rerouted, so the header must say so.
+        useVpnStatusStore.getState().setState(vpnConfig, "connected");
+      }
+    }).then((u) => {
+      if (cancelled) u();
+      else un = u;
+    });
+    return () => {
+      cancelled = true;
+      un?.();
+    };
+  }, [vpnTerm, vpnConfig]);
+
+  // Tear the embedded VPN terminal down (explicit disconnect / config change /
+  // leaving remote mode). Kills the PTY and drops the dedupe mark so a later
+  // activation can re-open the connection if still needed.
+  const stopVpnTerm = () => {
+    if (!vpnTerm) return;
+    void invoke("pty_kill", { id: vpnTerm.id }).catch(() => {});
+    forgetConnection(vpnTerm.key);
+    setVpnTerm(null);
+    setVpnStatus("idle");
+    // Symmetric with the machine-level state `startVpnTerm` now sets. If the root
+    // daemon actually outlived the PTY, `refresh` re-seats it from the backend's
+    // live tunnel set within 10 s — so this can understate a tunnel briefly, never
+    // claim one that isn't there.
+    if (vpnConfig) useVpnStatusStore.getState().setState(vpnConfig, "off");
+  };
+
+  // Non-headless: open the interactive SSH login in a dialog-embedded terminal.
+  // It establishes the ControlMaster socket the sshfs mount later rides, so the
+  // new project activates without a second prompt. Persisted past the dialog;
+  // the dedupe mark suppresses activation's root-terminal login.
+  // Poll for the embedded login's ControlMaster to come up: a credential-less
+  // ssh_connect rides the master once it's live (and on key-auth hosts succeeds
+  // immediately). On the first success we mirror connectSsh's connected state so
+  // both modes converge on the same `isRemote` browser. Bounded (~2 min) so a
+  // never-authenticated login eventually stops; the user can re-arm it with the
+  // "I've logged in — browse" button (tryBrowseNow). Never hard-errors while the
+  // terminal is up — the login may just not be authenticated yet.
+  //
+  // NOTE: there are **four** copies of this loop (`useRemoteReconnect`,
+  // `RemoteMachinesWindow`, `MachinesIndicator`, and here) — same 40 × 3 s bound,
+  // same credential-less probe, same `openSession`-on-success. Consolidating them
+  // is deliberately out of scope for this pass; what has been fixed is the part
+  // that differed: all of them now *state* their give-up instead of two of them
+  // going quiet and leaving an amber lamp with no way out.
+  const pollSshReady = (parsed: ParsedSshAddress, attempt = 0) => {
+    const maxAttempts = 40; // ~2 min at 3s cadence
+    void invoke<void>("ssh_connect", {
+      user: parsed.user,
+      host: parsed.host,
+      port: parsed.port,
+      password: null,
+      // Credential-less, so the dial policy can't tell this from a background
+      // sweep — but it is waiting on a master the user just authenticated in the
+      // terminal below. Unsaid, a host tagged HPC refuses every attempt and the
+      // poll times out behind a login that visibly worked.
+      background: false,
+    })
+      .then(async () => {
+        clearSshPoll();
+        const startDir = await resolveRemoteStartDir(parsed.user, parsed.host, parsed.port, null);
+        // Freeze the session the login terminal already authenticated — empty
+        // password → null → rides its ControlMaster in the listing effect.
+        browse.openSession(parsed, "", startDir);
+        setSshStatus("connected");
+      })
+      .catch(() => {
+        if (attempt + 1 >= maxAttempts) {
+          clearSshPoll();
+          // Say so. Giving up silently left the lamp amber forever with nothing on
+          // screen to act on — the user is watching a terminal that looks fine and
+          // a dialog that will never advance. `tryBrowseNow` re-arms it.
+          setSshStatus("error");
+          setSshError(POLL_GAVE_UP);
+          return;
+        }
+        sshPollTimer.current = setTimeout(() => pollSshReady(parsed, attempt + 1), 3000);
+      });
+  };
+
+  // Manual re-arm of the readiness poll (the "I've logged in — browse" button),
+  // for when the user authenticates after the auto-poll gave up, or wants to
+  // retry sooner.
+  const tryBrowseNow = () => {
+    const parsed = parseSshAddress(sshAddress);
+    if (!parsed) return;
+    clearSshPoll();
+    setSshStatus("connecting");
+    setSshError("");
+    pollSshReady(parsed);
+  };
+
+  const startSshTerm = async () => {
+    if (sshTerm) return;
+    const parsed = parseSshAddress(sshAddress);
+    if (!parsed) {
+      setSshStatus("error");
+      setSshError("Enter an address like user@host or host:2222");
+      return;
+    }
+    try {
+      const command = await invoke<string>("remote_login_command", {
+        user: parsed.user ?? null,
+        host: parsed.host,
+        port: parsed.port ?? null,
+      });
+      const target = `${parsed.user ? `${parsed.user}@` : ""}${parsed.host}`;
+      const key = `ssh:${target}:${parsed.port ?? ""}`;
+      markConnectionOpened(key);
+      setSshTerm({ id: nextDialogTermId("ssh"), command, key });
+      setSshError("");
+      // The user committed to this host by opening its login — remember it so it
+      // shows up in the recents dropdown next time (covers non-headless + winManual).
+      rememberSshAddress(sshAddress);
+      // Outside Windows, ride the login's ControlMaster to SFTP-browse — no stored
+      // password. (Windows has no control socket, so it keeps the manual path input.)
+      if (!winManual) {
+        setSshStatus("connecting");
+        pollSshReady(parsed);
+      }
+    } catch (e) {
+      setSshStatus("error");
+      setSshError(String(e));
     }
   };
 
+  const stopSshTerm = () => {
+    if (!sshTerm) return;
+    void invoke("pty_kill", { id: sshTerm.id }).catch(() => {});
+    // Drop the dedupe mark (symmetric with stopVpnTerm) so a later activation can
+    // re-open the SSH login; otherwise the key lingers in openedConnections and
+    // ensureRootSshLoginIfNeeded silently skips the real login.
+    forgetConnection(sshTerm.key);
+    setSshTerm(null);
+    // Killing the login drops the ControlMaster the browse rode, so stop the
+    // readiness poll and return to the disconnected state.
+    clearSshPoll();
+    setSshStatus("idle");
+    browse.reset();
+    setStep("connect");
+  };
+
   // Disconnect/reset the remote session when the user edits the SSH address.
   const onSshAddressChange = (value: string) => {
     setSshAddress(value);
     if (sshStatus !== "idle") resetSshSession();
+    // A live login is bound to the old target — drop it so a re-connect uses
+    // the new address.
+    stopSshTerm();
   };
 
   // Editing the password also invalidates a live session — the next connect
@@ -135,121 +719,164 @@ export function useRemoteSession({ kind }: { kind: "new" | "import" }) {
       setSshError("Enter an address like user@host or host:2222");
       return;
     }
-    // Empty password → key/agent auth (Option<String> None on the backend).
+    // Empty password → the backend falls back to a saved one for this host, then to
+    // key/agent auth (Option<String> None). So a blank field is "use what you have",
+    // exactly as in the Connect modal — not "authenticate with nothing".
     const password = sshPassword ? sshPassword : null;
     setSshStatus("connecting");
     setSshError("");
     setRemoteChosenPath("");
     try {
-      await invoke<void>("ssh_connect", {
-        user: parsed.user,
-        host: parsed.host,
-        port: parsed.port,
+      // The shared connect: ssh_connect (remembering the working password only on
+      // success, so a rejected credential is never stored) → freeze the session →
+      // open its start dir. The listing then refreshes itself.
+      const outcome = await browse.connect({
+        target: parsed,
         password,
+        remember: rememberArg(sshRemember),
       });
-      const startDir = await invoke<string>("ssh_default_dir", {
-        user: parsed.user,
-        host: parsed.host,
-        port: parsed.port,
-        password,
-      }).catch(() => "");
-      setRemoteConn(parsed);
-      setRemotePassword(sshPassword);
       setSshStatus("connected");
-      setRemoteBrowsePath(startDir || "");
+      // From what the backend DID, not from the checkbox: a locked keyring refuses
+      // the write and returns `save_error`, and a ticked box over an empty keychain
+      // is exactly what resurfaces at the next launch as an unexplained prompt.
+      sshCredential.applyOutcome(outcome);
+      // Connection succeeded — remember the address for the recents dropdown.
+      rememberSshAddress(sshAddress);
     } catch (err) {
       setSshStatus("error");
       setSshError(String(err));
-      setRemoteConn(null);
+      browse.reset();
     }
   };
 
-  // Refresh the remote folder listing whenever the browse path changes.
-  useEffect(() => {
-    if (sshStatus !== "connected" || !remoteConn) {
-      setRemoteEntries([]);
-      return;
-    }
-    let cancelled = false;
-    setRemoteListBusy(true);
-    setRemoteListError("");
-    invoke<RemoteEntry[]>("ssh_list_dir", {
-      user: remoteConn.user,
-      host: remoteConn.host,
-      port: remoteConn.port,
-      password: remotePassword ? remotePassword : null,
-      path: remoteBrowsePath,
-    })
-      .then((entries) => {
-        if (cancelled) return;
-        setRemoteEntries(entries);
-      })
-      .catch((err) => {
-        if (cancelled) return;
-        setRemoteEntries([]);
-        setRemoteListError(String(err));
-      })
-      .finally(() => {
-        if (!cancelled) setRemoteListBusy(false);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [sshStatus, remoteConn, remotePassword, remoteBrowsePath]);
+  // The live SFTP listing + folder navigation all come from the shared browser;
+  // re-exposed here under the names `RemoteProjectSection` already reads.
+  const enterRemoteFolder = browse.enter;
+  const jumpToRemotePath = browse.jump;
+  const remoteGoUp = browse.goUp;
+  const createRemoteFolder = browse.mkdir;
 
-  const enterRemoteFolder = (entry: RemoteEntry) => {
-    if (!entry.is_dir) return;
-    setRemoteBrowsePath(joinRemotePath(remoteBrowsePath, entry.name));
-  };
-
-  const remoteGoUp = () => {
-    const path = remoteBrowsePath.replace(/\/+$/, "");
-    if (!path || path === "/") {
-      setRemoteBrowsePath("/");
-      return;
+  // Build the `remote` spec for the create/import request, or undefined when this
+  // isn't a usable remote project. NEW: name becomes a subdir under the chosen
+  // path. IMPORT: the chosen path IS the project root.
+  //
+  // Headless: requires a live, browsed SSH session (`isRemote`). Non-headless:
+  // no in-dialog connection is made (the live login happens in the root terminal
+  // at activation), so the spec is built straight from the typed address + the
+  // manually-entered remote path.
+  const buildRemoteSpec = (safeName: string) => {
+    if (!isRemoteProject) return undefined;
+    const openvpn =
+      vpnEnabled && vpnConfig
+        ? { config: vpnConfig, username: vpnUsername.trim() || undefined }
+        : undefined;
+    // Both modes now browse to a real folder over a live session (headless via
+    // connectSsh, non-headless by riding the embedded login's ControlMaster), so a
+    // committed remoteConn + chosen path is the single source of truth.
+    if (remoteConn && remoteChosenPath.trim()) {
+      return {
+        user: remoteConn.user ?? undefined,
+        host: remoteConn.host,
+        port: remoteConn.port ?? undefined,
+        remote_path:
+          kind === "new" ? joinRemotePath(remoteChosenPath, safeName) : remoteChosenPath,
+        openvpn,
+      };
     }
-    const idx = path.lastIndexOf("/");
-    setRemoteBrowsePath(idx <= 0 ? "/" : path.slice(0, idx));
+    // Windows non-headless can't browse (no control socket) — fall back to the
+    // typed address + manually-entered path.
+    if (winManual) {
+      const parsed = parseSshAddress(sshAddress);
+      const path = remoteChosenPath.trim();
+      if (!parsed || !path) return undefined;
+      return {
+        user: parsed.user ?? undefined,
+        host: parsed.host,
+        port: parsed.port ?? undefined,
+        remote_path: kind === "new" ? joinRemotePath(path, safeName) : path,
+        openvpn,
+      };
+    }
+    return undefined;
   };
 
-  // Build the `remote` spec for the create/import request, or undefined when not
-  // a connected remote project. NEW: name becomes a subdir under the chosen
-  // path. IMPORT: the chosen path IS the project root.
-  const buildRemoteSpec = (safeName: string) =>
-    isRemote && remoteConn
-      ? {
-          user: remoteConn.user ?? undefined,
-          host: remoteConn.host,
-          port: remoteConn.port ?? undefined,
-          remote_path:
-            kind === "new" ? joinRemotePath(remoteChosenPath, safeName) : remoteChosenPath,
-          openvpn: vpnEnabled && vpnConfig ? { config: vpnConfig } : undefined,
-        }
-      : undefined;
+  // Ready to submit: a chosen remote folder over a live session, or (Windows
+  // non-headless) a typed path. Drives the dialog's submit gating + step machine.
+  const remoteReady =
+    isRemoteProject &&
+    (winManual ? remoteChosenPath.trim() !== "" : isRemote && remoteChosenPath.trim() !== "");
 
   return {
     isRemoteProject,
     isRemote,
+    // The live-connected host, frozen at connect time (`{ user, host, port }`),
+    // so a caller can register it elsewhere — e.g. the HPC wizard surfacing the
+    // cluster in the header's global-machines list once the login goes live.
+    remoteConn,
+    headless,
+    winManual,
+    sshViaTerminal,
+    setSshViaTerminal,
+    vpnViaTerminal,
+    setVpnViaTerminal,
+    remoteReady,
+    step,
+    setStep,
+    tryBrowseNow,
     sshTooling,
     sshAddress,
+    sshAddresses,
     sshPassword,
     sshStatus,
     sshError,
+    sshRemember,
+    setSshRemember,
+    sshSaved,
+    // The tri-state behind `sshSaved`, for the shared "Save password" row.
+    sshCredential,
+    forgetSshPassword,
+    // The credential the live session actually authenticated with, so the caller can
+    // hand it to the project's first *pooled* connect (`remote_connect`) instead of
+    // letting that leg rely on the ControlMaster this dialog happens to have left up.
+    remotePassword,
     remoteBrowsePath,
     remoteEntries,
     remoteListBusy,
     remoteListError,
     remoteChosenPath,
     setRemoteChosenPath,
+    remotePaths,
+    rememberChosenPath,
     vpnEnabled,
     setVpnEnabled,
     vpnConfig,
+    vpnConfigs,
+    vpnUsername,
+    setVpnUsername,
+    vpnNeeds,
+    // A second field is only warranted when the key passphrase is a *different*
+    // secret from the password — see `needsSeparateKeyPassphrase`.
+    vpnNeedsKeyPassphrase: needsSeparateKeyPassphrase(vpnNeeds),
+    selectVpnConfig,
     vpnPassword,
     setVpnPassword,
+    vpnKeyPassphrase,
+    setVpnKeyPassphrase,
     vpnStatus,
     setVpnStatus,
     vpnError,
     setVpnError,
+    vpnRemember,
+    setVpnRemember,
+    vpnSaved,
+    forgetVpnPassword,
+    vpnLog,
+    vpnTerm,
+    startVpnTerm,
+    stopVpnTerm,
+    sshTerm,
+    startSshTerm,
+    stopSshTerm,
     toggleRemoteProject,
     browseVpnConfig,
     connectVpn,
@@ -257,7 +884,9 @@ export function useRemoteSession({ kind }: { kind: "new" | "import" }) {
     onSshPasswordChange,
     connectSsh,
     enterRemoteFolder,
+    jumpToRemotePath,
     remoteGoUp,
+    createRemoteFolder,
     buildRemoteSpec,
   };
 }
diff --git a/src/components/projects/useSavedCredential.ts b/src/components/projects/useSavedCredential.ts
new file mode 100644
index 0000000..cf2bd5a
--- /dev/null
+++ b/src/components/projects/useSavedCredential.ts
@@ -0,0 +1,214 @@
+import { useCallback, useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import type { KeyringState } from "../../lib/keyring";
+
+/**
+ * **"Is a password saved for this host?" — asked so the answer can be _"we don't
+ * know"_.**
+ *
+ * Five surfaces used to ask this the same wrong way: `remote_has_saved_password`,
+ * `.catch(() => false)`, one boolean. That boolean then drove the "Save password"
+ * pre-tick — and an unticked box is not a neutral state, it is an instruction:
+ * `ssh_connect`'s `remember: false` means *clear the saved credential*. So an
+ * unreadable keychain (locked Secret Service — which answers every lookup exactly
+ * like an empty one) unticked the box, and the next successful connect deleted the
+ * very password it had just authenticated with. That is not hypothetical: it is
+ * how the user's most-used host lost its credential.
+ *
+ * This hook is the one implementation, and it fixes the three things that made
+ * that possible:
+ *
+ *  1. **A tri-state**, not a boolean — `saved` / `notSaved` / `unreadable`, plus
+ *     `checking` while the read is in flight. "Unknown" never masquerades as
+ *     "nothing saved" again, which is what lets the UI say so (and offer the
+ *     unlock) instead of quietly proposing a delete.
+ *  2. **A bounded read.** The backing keychain call is a D-Bus round trip that
+ *     blocks *indefinitely* against a locked collection, so the read is raced
+ *     against a 4 s timer (the pattern `VpnIndicator` established) and a timeout
+ *     lands on `unreadable` — the state with an action behind it — never on a
+ *     confident `notSaved`.
+ *  3. **`applyOutcome`.** What is saved is what the *backend did*
+ *     (`SshConnectOutcome`), never what the request asked for: a locked keyring
+ *     refuses the write and reports why, and the row has to show that rather than
+ *     a ticked box with an empty keychain behind it.
+ *
+ * `forget()` is the only path that deletes. Clearing a credential is an explicit
+ * act by the user, never a side effect of connecting — see `rememberArg`.
+ */
+export type SavedCredential = "checking" | "saved" | "notSaved" | "unreadable";
+
+/** Mirrors `commands::ssh::SavedPasswordState`. Never fails backend-side. */
+export interface SavedPasswordState {
+  saved: boolean;
+  keyring: KeyringState;
+}
+
+/** Mirrors `commands::ssh::SshConnectOutcome` — what `ssh_connect` did to the
+ *  keychain, as distinct from whether it connected. */
+export interface SshConnectOutcome {
+  saved: boolean;
+  save_error: string | null;
+}
+
+/** The host a credential is keyed by (`user@host:port`), in the spelling every
+ *  caller here already has. */
+export interface CredentialTarget {
+  user?: string | null;
+  host: string;
+  port?: number | null;
+}
+
+/** How long a keychain read is allowed to take before it is called unreadable.
+ *  Same bound (and same reason) as `VpnIndicator`'s keyring probes. */
+const READ_TIMEOUT_MS = 4000;
+
+function withTimeout<T>(p: Promise<T>, ms: number, fallback: T): Promise<T> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(fallback), ms);
+    void p.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(fallback);
+      },
+    );
+  });
+}
+
+/**
+ * **The value a connect may send as `remember` — `true` or `null`, never `false`.**
+ *
+ * `false` is not "don't save", it is `Remember::Clear`: the backend deletes the
+ * account. Since `ssh_connect` resolves `typed || saved` *before* it writes, a
+ * successful connect carrying `false` destroys the password it authenticated
+ * with. So an unticked box means **leave the keychain alone** (`null`), and
+ * deleting is left to the explicit forget the untick handler already calls.
+ *
+ * The same rule covers `checking` and `unreadable` for free: the pre-tick is
+ * seeded from the resolved state, so a box that has not been (or cannot be)
+ * resolved is unticked, and an unticked box sends `null`. A box the user ticked
+ * *themselves* still sends `true` even on an unreadable keyring — that is a
+ * request to save, and the backend answers it with `save_error` if it can't.
+ *
+ * The pattern is `stores/globalMachines`' (`opts.remember ? true : null`); this
+ * is that decision named, so no fourth copy has to rediscover it.
+ */
+export function rememberArg(checked: boolean): true | null {
+  return checked ? true : null;
+}
+
+export interface SavedCredentialHandle {
+  /** The tri-state (plus `checking`). */
+  state: SavedCredential;
+  /** The credential store's own condition, for the locked-keyring disclosure. */
+  keyring: KeyringState;
+  /** A password is known to be saved. */
+  saved: boolean;
+  /** The store could not be read, so nothing can be concluded either way. */
+  unreadable: boolean;
+  /** The read is still in flight. */
+  checking: boolean;
+  /** Why the last connect did not save what it was asked to (verbatim from the
+   *  keychain layer), or `""`. */
+  saveError: string;
+  /** Re-ask (after an unlock, or after a connect that may have written). */
+  refresh: () => void;
+  /** Delete the saved password for this target. The only deleting path. */
+  forget: () => Promise<void>;
+  /** Adopt what `ssh_connect` actually did — the source of truth for "saved". */
+  applyOutcome: (outcome: SshConnectOutcome | null | undefined) => void;
+}
+
+/**
+ * Track the saved-password state of `target`. Re-reads whenever the target
+ * changes; `opts.enabled` gates the read entirely for a surface that must not
+ * touch the keychain until the user asks (a pill's context menu — one unbounded
+ * D-Bus trip per project at launch is exactly the cost this avoids).
+ */
+export function useSavedCredential(
+  target: CredentialTarget | null | undefined,
+  opts?: { enabled?: boolean },
+): SavedCredentialHandle {
+  const enabled = opts?.enabled ?? true;
+  // Destructured to primitives so the effect keys off the *identity of the host*,
+  // not off a spec object the store re-creates on every unrelated patch.
+  const user = target?.user ?? null;
+  const host = target?.host ?? "";
+  const port = target?.port ?? null;
+
+  const [state, setState] = useState<SavedCredential>("checking");
+  const [keyring, setKeyring] = useState<KeyringState>("unlocked");
+  const [saveError, setSaveError] = useState("");
+  // Bumped by `refresh`; a dep of the read effect rather than a second code path.
+  const [nonce, setNonce] = useState(0);
+
+  useEffect(() => {
+    if (!host || !enabled) {
+      // No host to ask about (or nobody asking yet) is genuinely "nothing saved" —
+      // there is no store trip to be uncertain about.
+      setState("notSaved");
+      return;
+    }
+    let cancelled = false;
+    setState("checking");
+    setSaveError("");
+    void withTimeout(
+      invoke<SavedPasswordState>("remote_saved_password_state", { user, host, port }).catch(
+        // The command is declared infallible, so a rejection means the bridge
+        // itself is gone — which tells us nothing about the store.
+        () => ({ saved: false, keyring: "unavailable" as KeyringState }),
+      ),
+      READ_TIMEOUT_MS,
+      // A read that never came back is a locked collection until proven otherwise:
+      // "locked" is the state with an unlock behind it.
+      { saved: false, keyring: "locked" as KeyringState },
+    ).then((answer) => {
+      if (cancelled) return;
+      // An answer that arrived but carries nothing gets read as the same
+      // unreadable store a timeout does, rather than destructured blind: this
+      // runs inside an unawaited promise, so a `null` from the bridge would
+      // surface only as an unhandled rejection — the row would sit on
+      // "checking" forever with nothing on screen saying why.
+      const res: SavedPasswordState = answer ?? { saved: false, keyring: "unavailable" };
+      setKeyring(res.keyring);
+      // A `false` from a store we could not read is not evidence of absence — the
+      // whole point of the tri-state. A `true` is still trustworthy either way.
+      setState(res.saved ? "saved" : res.keyring === "unlocked" ? "notSaved" : "unreadable");
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [user, host, port, enabled, nonce]);
+
+  const refresh = useCallback(() => setNonce((n) => n + 1), []);
+
+  const forget = useCallback(async () => {
+    if (!host) return;
+    await invoke("remote_forget_password", { user, host, port }).catch(() => {});
+    setState("notSaved");
+    setSaveError("");
+  }, [user, host, port]);
+
+  const applyOutcome = useCallback((outcome: SshConnectOutcome | null | undefined) => {
+    // No outcome (an older/void call site) leaves the state alone rather than
+    // asserting a keychain fact nobody reported.
+    if (!outcome) return;
+    setState(outcome.saved ? "saved" : "notSaved");
+    setSaveError(outcome.save_error ?? "");
+  }, []);
+
+  return {
+    state,
+    keyring,
+    saved: state === "saved",
+    unreadable: state === "unreadable",
+    checking: state === "checking",
+    saveError,
+    refresh,
+    forget,
+    applyOutcome,
+  };
+}
diff --git a/src/components/stats/StatsRecap.tsx b/src/components/stats/StatsRecap.tsx
new file mode 100644
index 0000000..91b7ac9
--- /dev/null
+++ b/src/components/stats/StatsRecap.tsx
@@ -0,0 +1,382 @@
+import { useEffect, useMemo, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { createPortal } from "react-dom";
+
+import { APP_TIMER_ID } from "../../stores/timer";
+import { ROOT_SCOPE, useUsageStore, type GitStats } from "../../stores/usage";
+import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { METRIC, agentLabel } from "../../lib/usageMetrics";
+import {
+  breakdown,
+  dayKey,
+  periodKeys,
+  totalOf,
+  type Counters,
+  type Period,
+} from "../../lib/usageRollup";
+import { formatBytes, type ByteCounts, type NetUsageReport } from "../monitoring/NetworkTrafficPane";
+import { Toggle } from "../common/Toggle";
+
+/** Human duration, matching the header timer's phrasing. */
+function formatTime(secs: number): string {
+  if (secs < 60) return secs > 0 ? "< 1m" : "0m";
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor((secs % 3600) / 60);
+  return h > 0 ? `${h}h ${m}m` : `${m}m`;
+}
+
+/** `n thing` / `n things` — the recap reads as a sentence, so it must agree. */
+function plural(n: number, one: string, many = `${one}s`): string {
+  return `${n} ${n === 1 ? one : many}`;
+}
+
+const PERIODS: { id: Period; label: string }[] = [
+  { id: "day", label: "Day" },
+  { id: "week", label: "Week" },
+  { id: "month", label: "Month" },
+];
+
+const DAY_MS = 86_400_000;
+
+/** One headline number. */
+function Metric({ label, value, sub }: { label: string; value: string; sub?: string }) {
+  return (
+    <div className="stats-metric">
+      <span>{label}</span>
+      <strong>{value}</strong>
+      {sub && <small>{sub}</small>}
+    </div>
+  );
+}
+
+/** A labelled bar in a breakdown list, sized against the largest row. */
+function Bar({ label, value, max, suffix }: { label: string; value: number; max: number; suffix?: string }) {
+  const pct = max > 0 ? Math.max(2, (value / max) * 100) : 0;
+  return (
+    <div className="stats-bar-row">
+      <span className="stats-bar-label" title={label}>{label}</span>
+      <span className="stats-bar-track">
+        <span className="stats-bar-fill" style={{ width: `${pct}%` }} />
+      </span>
+      <span className="stats-bar-value">{suffix ?? value}</span>
+    </div>
+  );
+}
+
+/**
+ * Per-hour sparkline over a day's 24 UTC hour buckets — hand-rolled SVG, like
+ * every other graph in Eldrun (there is no chart dependency, and this is not the
+ * place to add one). Only meaningful for the Day period.
+ */
+function HourSparkline({ hours, anchorMs }: { hours: Record<string, Counters>; anchorMs: number }) {
+  const date = dayKey(anchorMs);
+  const values = Array.from({ length: 24 }, (_, h) => {
+    const bucket = hours[`${date}T${String(h).padStart(2, "0")}`] ?? {};
+    // "Activity" here is everything the user did that hour, agent and shell alike.
+    return (
+      totalOf(breakdown(bucket, METRIC.AGENT_PROMPT)) + (bucket[METRIC.SHELL_COMMAND] ?? 0)
+    );
+  });
+  const max = Math.max(1, ...values);
+  const busiest = values.indexOf(Math.max(...values));
+  const width = 600;
+  const height = 60;
+  const barW = width / 24;
+
+  if (max <= 1 && values.every((v) => v === 0)) return null;
+
+  return (
+    <div className="stats-spark-wrap">
+      <svg
+        className="stats-spark"
+        viewBox={`0 0 ${width} ${height}`}
+        preserveAspectRatio="none"
+        role="img"
+        aria-label="Activity by hour of day (UTC)"
+      >
+        {values.map((v, h) => (
+          <rect
+            key={h}
+            x={h * barW + 1}
+            y={height - (v / max) * height}
+            width={barW - 2}
+            height={(v / max) * height}
+            className={h === busiest ? "stats-spark-bar busiest" : "stats-spark-bar"}
+          />
+        ))}
+      </svg>
+      <div className="stats-spark-legend">
+        <span>busiest hour {String(busiest).padStart(2, "0")}:00 UTC</span>
+        <span className="stats-spark-scale">peak {max}</span>
+      </div>
+    </div>
+  );
+}
+
+interface Props {
+  onClose: () => void;
+  /** Which day the recap opens on. The startup recap anchors on yesterday — the
+   *  day that actually finished; opened from Settings it anchors on today. */
+  initialAnchorMs: number;
+  /** Shown only when the recap opened by itself, since it is the thing that
+   *  turns that off. */
+  showAutoToggle: boolean;
+}
+
+export function StatsRecap({ onClose, initialAnchorMs, showAutoToggle }: Props) {
+  const [period, setPeriod] = useState<Period>("day");
+  const [anchorMs] = useState(initialAnchorMs);
+  const [timeByDay, setTimeByDay] = useState<Record<string, Record<string, number>>>({});
+  const [net, setNet] = useState<NetUsageReport>({ hours: {}, days: {} });
+  const [git, setGit] = useState<GitStats | null>(null);
+
+  const report = useUsageStore((s) => s.report);
+  const loadUsage = useUsageStore((s) => s.load);
+  const projects = useProjectsStore((s) => s.projects);
+  const autoOn = useSettingsStore((s) => s.settings?.daily_stats_recap ?? true);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+
+  useEffect(() => {
+    void loadUsage();
+    void invoke<Record<string, Record<string, number>>>("get_time_activity_all")
+      .then(setTimeByDay)
+      .catch(() => setTimeByDay({}));
+    void invoke<NetUsageReport>("get_net_usage", { projectId: "" })
+      .then(setNet)
+      .catch(() => setNet({ hours: {}, days: {} }));
+  }, [loadUsage]);
+
+  const keys = useMemo(() => periodKeys(period, anchorMs), [period, anchorMs]);
+
+  // Git is derived on demand (never stored), so it is re-read whenever the window
+  // moves. `since` is the first day of the period; a remote project reports zero
+  // rather than stalling the dialog on an unreachable host.
+  useEffect(() => {
+    const since = keys[0];
+    const dirs = projects.map((p) => p.directory).filter((d): d is string => !!d);
+    let cancelled = false;
+    void Promise.all(
+      dirs.map((dir) =>
+        invoke<GitStats>("usage_git_stats", { projectDir: dir, since }).catch(
+          () => null,
+        ),
+      ),
+    ).then((all) => {
+      if (cancelled) return;
+      setGit(
+        all.filter((g): g is GitStats => !!g).reduce(
+          (acc, g) => ({
+            commits: acc.commits + g.commits,
+            filesChanged: acc.filesChanged + g.filesChanged,
+            linesAdded: acc.linesAdded + g.linesAdded,
+            linesRemoved: acc.linesRemoved + g.linesRemoved,
+          }),
+          { commits: 0, filesChanged: 0, linesAdded: 0, linesRemoved: 0 },
+        ),
+      );
+    });
+    return () => { cancelled = true; };
+  }, [keys, projects]);
+
+  // ── The numbers ─────────────────────────────────────────────────────────
+  const counters: Counters = useMemo(() => {
+    const acc: Counters = {};
+    for (const key of keys) {
+      for (const [metric, n] of Object.entries(report?.days?.[key] ?? {})) {
+        acc[metric] = (acc[metric] ?? 0) + n;
+      }
+    }
+    return acc;
+  }, [report, keys]);
+
+  // `agent.tab` must not swallow `agent.tab.local.*` — a local model is its own
+  // namespace, and folding it here would count every local tab twice.
+  const tabsByAgent = breakdown(counters, METRIC.AGENT_TAB, [METRIC.AGENT_TAB_LOCAL]);
+  const localTabs = breakdown(counters, METRIC.AGENT_TAB_LOCAL);
+  const activeByAgent = breakdown(counters, METRIC.AGENT_ACTIVE);
+  const promptsByAgent = breakdown(counters, METRIC.AGENT_PROMPT);
+
+  const usedTabs = totalOf(activeByAgent);
+  const prompts = totalOf(promptsByAgent);
+  const openedTabs = totalOf(tabsByAgent) + totalOf(localTabs);
+
+  // The per-model view merges cloud agents and local models into one ranking —
+  // "which models did I work with" is one question, not two.
+  const byModel: Record<string, number> = {};
+  for (const [leaf, n] of Object.entries(activeByAgent)) {
+    byModel[agentLabel(leaf)] = (byModel[agentLabel(leaf)] ?? 0) + n;
+  }
+
+  // Time per project, over the same window.
+  const secsByProject: Record<string, number> = {};
+  for (const key of keys) {
+    for (const [pid, secs] of Object.entries(timeByDay[key] ?? {})) {
+      // The app's own total is tracked under a pseudo-project; it is the whole
+      // session, not a project, so it must not appear as one in the ranking.
+      if (pid === APP_TIMER_ID) continue;
+      secsByProject[pid] = (secsByProject[pid] ?? 0) + secs;
+    }
+  }
+  const appSecs = keys.reduce((sum, k) => sum + (timeByDay[k]?.[APP_TIMER_ID] ?? 0), 0);
+  const projectName = (id: string) =>
+    id === ROOT_SCOPE ? "Root terminal" : projects.find((p) => p.id === id)?.name ?? id;
+  const rankedProjects = Object.entries(secsByProject)
+    .filter(([, secs]) => secs > 0)
+    .sort((a, b) => b[1] - a[1]);
+
+  const bytes: ByteCounts = keys.reduce<ByteCounts>(
+    (acc, key) => {
+      const c = net.days?.[key];
+      return { rx: acc.rx + (c?.rx ?? 0), tx: acc.tx + (c?.tx ?? 0) };
+    },
+    { rx: 0, tx: 0 },
+  );
+
+  const created = counters[METRIC.FILE_CREATED] ?? 0;
+  const modified = counters[METRIC.FILE_MODIFIED] ?? 0;
+  const deleted = counters[METRIC.FILE_DELETED] ?? 0;
+  const shellCommands = counters[METRIC.SHELL_COMMAND] ?? 0;
+  const workedS = counters[METRIC.AGENT_WORKED_S] ?? 0;
+  const decisions = counters[METRIC.AGENT_DECISION] ?? 0;
+
+  const label = period === "day" ? dayLabel(anchorMs) : period === "week" ? "This week" : "This month";
+  const empty = openedTabs + prompts + shellCommands + created + modified + deleted === 0;
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div className="stats-dialog dialog-framed" onMouseDown={(e) => e.stopPropagation()}>
+        <div className="settings-title-row">
+          <h2>Your work in Eldrun</h2>
+          <div className="stats-period-switch" role="group" aria-label="Period">
+            {PERIODS.map((p) => (
+              <button
+                key={p.id}
+                type="button"
+                className={period === p.id ? "stats-period-btn active" : "stats-period-btn"}
+                onClick={() => setPeriod(p.id)}
+              >
+                {p.label}
+              </button>
+            ))}
+          </div>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+
+        <div className="dialog-scroll">
+        <p className="settings-help stats-window-label">{label}</p>
+
+        {empty ? (
+          <p className="stats-empty">
+            Nothing recorded for this period yet. Open an agent, run a command, edit a
+            file — it will show up here.
+          </p>
+        ) : (
+          <>
+            {/* ── Agents ───────────────────────────────────────────────── */}
+            <div className="settings-section-title">Agents</div>
+            <p className="stats-headline">
+              You used <strong>{plural(usedTabs, "agent tab")}</strong>, asking them{" "}
+              <strong>{plural(prompts, "thing")}</strong>.
+            </p>
+            {Object.keys(byModel).length > 0 && (
+              <div className="stats-bars">
+                {Object.entries(byModel)
+                  .sort((a, b) => b[1] - a[1])
+                  .map(([model, n]) => (
+                    <Bar key={model} label={model} value={n} max={Math.max(...Object.values(byModel))} />
+                  ))}
+              </div>
+            )}
+            <div className="stats-metrics">
+              <Metric label="Agent tabs opened" value={String(openedTabs)} />
+              <Metric
+                label="Agents working"
+                value={formatTime(workedS)}
+                sub="summed across tabs"
+              />
+              <Metric
+                label="Stopped to ask you"
+                value={String(decisions)}
+                sub={decisions === 1 ? "time" : "times"}
+              />
+            </div>
+
+            {/* ── Work per project ─────────────────────────────────────── */}
+            <div className="settings-section-title">Work</div>
+            {rankedProjects.length > 0 ? (
+              <div className="stats-bars">
+                {rankedProjects.map(([pid, secs]) => (
+                  <Bar
+                    key={pid}
+                    label={projectName(pid)}
+                    value={secs}
+                    max={rankedProjects[0][1]}
+                    suffix={formatTime(secs)}
+                  />
+                ))}
+              </div>
+            ) : (
+              <p className="settings-help">No tracked time in this period.</p>
+            )}
+            <div className="stats-metrics">
+              <Metric label="Eldrun open" value={formatTime(appSecs)} />
+              <Metric label="Commands run" value={String(shellCommands)} sub="in shell tabs" />
+              <Metric label="Network" value={`↓ ${formatBytes(bytes.rx)}`} sub={`↑ ${formatBytes(bytes.tx)}`} />
+            </div>
+
+            {/* ── Files ────────────────────────────────────────────────── */}
+            <div className="settings-section-title">Files</div>
+            <div className="stats-metrics">
+              <Metric label="Created" value={String(created)} />
+              <Metric label="Modified" value={String(modified)} />
+              <Metric label="Deleted" value={String(deleted)} />
+              {git && (
+                <Metric
+                  label="Committed"
+                  value={plural(git.commits, "commit")}
+                  sub={`+${git.linesAdded} −${git.linesRemoved}`}
+                />
+              )}
+            </div>
+            <p className="settings-help">
+              File counts come from watching your project tree, so they cover only local
+              files — a remote project is counted through its local mirror, and one
+              without a mirror records nothing. Commits are counted from git, for commits
+              you authored.
+            </p>
+
+            {/* ── Rhythm ───────────────────────────────────────────────── */}
+            {period === "day" && report?.hours && (
+              <>
+                <div className="settings-section-title">Rhythm</div>
+                <HourSparkline hours={report.hours} anchorMs={anchorMs} />
+              </>
+            )}
+          </>
+        )}
+
+        {showAutoToggle && (
+          <label className="settings-switch-row stats-auto-row">
+            <span>Show this at the start of each day</span>
+            <Toggle
+              checked={autoOn}
+              onChange={(e) => void updateSettings({ daily_stats_recap: e.target.checked })}
+            />
+          </label>
+        )}
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** "Yesterday" / "Today" / the date, for the Day window's caption. */
+function dayLabel(anchorMs: number): string {
+  const today = dayKey(Date.now());
+  const anchor = dayKey(anchorMs);
+  if (anchor === today) return "Today";
+  if (anchor === dayKey(Date.now() - DAY_MS)) return "Yesterday";
+  return anchor;
+}
diff --git a/src/components/stats/StatsRecapHost.tsx b/src/components/stats/StatsRecapHost.tsx
new file mode 100644
index 0000000..78577c7
--- /dev/null
+++ b/src/components/stats/StatsRecapHost.tsx
@@ -0,0 +1,69 @@
+import { useEffect, useState } from "react";
+
+import { useSettingsStore } from "../../stores/settings";
+import { dayKey } from "../../lib/usageRollup";
+import { StatsRecap } from "./StatsRecap";
+
+const DAY_MS = 86_400_000;
+
+/** Any surface can open the recap by dispatching this (the same bus Settings, the
+ *  tour and How-To-Start already use — no global UI store needed). */
+export const OPEN_STATS_EVENT = "eldrun:open-stats";
+
+/**
+ * Owns when the usage recap is on screen.
+ *
+ * Two ways in:
+ *
+ * - **Automatically**, on the first launch of a day (unless turned off). It then
+ *   anchors on **yesterday** — at 9am today there is nothing to report yet, and
+ *   the day that just finished is the one worth looking at.
+ * - **On demand**, via {@link OPEN_STATS_EVENT} from the Settings button. That
+ *   anchors on **today**, because you asked for it now.
+ *
+ * Mounted once, in `AppShell` (main window only — a detached subwindow must not
+ * pop its own copy).
+ */
+export function StatsRecapHost() {
+  const [anchorMs, setAnchorMs] = useState<number | null>(null);
+  const [auto, setAuto] = useState(false);
+
+  const loaded = useSettingsStore((s) => s.loaded);
+  const enabled = useSettingsStore((s) => s.settings?.daily_stats_recap ?? true);
+  const lastShown = useSettingsStore((s) => s.settings?.daily_stats_last_shown);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+
+  // On-demand: the Settings button.
+  useEffect(() => {
+    const open = () => {
+      setAuto(false);
+      setAnchorMs(Date.now());
+    };
+    window.addEventListener(OPEN_STATS_EVENT, open);
+    return () => window.removeEventListener(OPEN_STATS_EVENT, open);
+  }, []);
+
+  // Once a day, on launch. Gated on settings being loaded, or the very first
+  // render (settings still null) would read the default "on" and pop the recap
+  // for someone who turned it off.
+  useEffect(() => {
+    if (!loaded || !enabled) return;
+    // The counters are bucketed in UTC, so the "have I shown this today" gate is
+    // too — otherwise the recap's own idea of "today" and the day it stamps could
+    // disagree either side of local midnight.
+    const today = dayKey(Date.now());
+    if (lastShown === today) return;
+    setAuto(true);
+    setAnchorMs(Date.now() - DAY_MS); // the day that just finished
+    void updateSettings({ daily_stats_last_shown: today });
+  }, [loaded, enabled, lastShown, updateSettings]);
+
+  if (anchorMs === null) return null;
+  return (
+    <StatsRecap
+      onClose={() => setAnchorMs(null)}
+      initialAnchorMs={anchorMs}
+      showAutoToggle={auto}
+    />
+  );
+}
diff --git a/src/components/tabs/AddTabMenuList.tsx b/src/components/tabs/AddTabMenuList.tsx
new file mode 100644
index 0000000..574466a
--- /dev/null
+++ b/src/components/tabs/AddTabMenuList.tsx
@@ -0,0 +1,101 @@
+import { Fragment, useState } from "react";
+
+/** One pickable row in the add-tab menu. */
+export interface AddMenuEntry {
+  /** React key — unique within the entry's group. */
+  key: string;
+  label: string;
+  /** Dot glyph in front of the label (defaults to "●"). */
+  dot?: string;
+  /** Dot color (a TAB_ACCENT value or any CSS color). */
+  color: string;
+  disabled?: boolean;
+  onPick: () => void;
+}
+
+/** One labelled section of the add-tab menu. */
+export interface AddMenuGroup {
+  label: string;
+  entries: AddMenuEntry[];
+  /** Non-pickable explainer rendered when the group has no entries (only while
+   *  the search box is empty — a hint is not a search result). */
+  hint?: string;
+}
+
+/**
+ * The searchable body of the "+" add-tab menu, shared by the main-window
+ * `TabBar` and the detached popout's `NewTabMenu` so both filter identically.
+ * The search box is auto-focused, so "click + and type" filters immediately;
+ * a query narrows entries by label (a group-label match keeps its whole
+ * group, so "files" surfaces both file panes), Enter picks the first
+ * pickable match, and Escape clears the query before it closes the menu.
+ */
+export function AddTabMenuList({ groups }: { groups: AddMenuGroup[] }) {
+  const [query, setQuery] = useState("");
+  const q = query.trim().toLowerCase();
+
+  const visible = q
+    ? groups
+        .map((g) => ({
+          label: g.label,
+          hint: undefined,
+          entries: g.label.toLowerCase().includes(q)
+            ? g.entries
+            : g.entries.filter((e) => e.label.toLowerCase().includes(q)),
+        }))
+        .filter((g) => g.entries.length > 0)
+    : groups;
+
+  // The entry Enter would pick — highlighted so the shortcut is discoverable.
+  // Compared by identity below, so entry keys only need per-group uniqueness.
+  const first = q
+    ? visible.flatMap((g) => g.entries).find((e) => !e.disabled)
+    : undefined;
+
+  return (
+    <>
+      <input
+        className="tab-new-menu-search"
+        type="text"
+        placeholder="Search…"
+        value={query}
+        autoFocus
+        spellCheck={false}
+        onChange={(e) => setQuery(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && first) {
+            e.preventDefault();
+            first.onPick();
+          } else if (e.key === "Escape" && query) {
+            // First Escape clears the query; only an empty-query Escape is
+            // allowed to bubble on to the menu's document-level close handler.
+            e.stopPropagation();
+            setQuery("");
+          }
+        }}
+      />
+      {visible.length === 0 && <div className="tab-new-menu-hint">No matches</div>}
+      {visible.map((g) => (
+        <Fragment key={g.label}>
+          <div className="tab-new-menu-group-label">{g.label}</div>
+          {g.entries.map((e) => (
+            <button
+              key={e.key}
+              className={`tab-new-menu-item${e === first ? " enter-target" : ""}`}
+              disabled={e.disabled}
+              onClick={e.onPick}
+            >
+              <span className="tab-new-menu-dot" style={{ color: e.color }}>
+                {e.dot ?? "●"}
+              </span>
+              {e.label}
+            </button>
+          ))}
+          {g.entries.length === 0 && g.hint && (
+            <div className="tab-new-menu-hint">{g.hint}</div>
+          )}
+        </Fragment>
+      ))}
+    </>
+  );
+}
diff --git a/src/components/tabs/CustomAgentDialog.tsx b/src/components/tabs/CustomAgentDialog.tsx
new file mode 100644
index 0000000..bf30dc2
--- /dev/null
+++ b/src/components/tabs/CustomAgentDialog.tsx
@@ -0,0 +1,258 @@
+import { useEffect, useMemo, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import { useSettingsStore } from "../../stores/settings";
+import { runInstallInTab } from "../../lib/installCommand";
+import type { CustomAgent } from "../../types";
+
+interface Props {
+  onClose: () => void;
+}
+
+/** Split a whitespace-separated arg string into an argv, honoring simple
+ *  single/double quoting so a value with spaces stays one arg. Empty → []. */
+function parseArgs(raw: string): string[] {
+  const out: string[] = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(raw)) !== null) {
+    out.push(m[1] ?? m[2] ?? m[3] ?? "");
+  }
+  return out;
+}
+
+/** A minted id that doesn't depend on crypto being present in every webview. */
+function mintId(): string {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+  return `ca-${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+
+/**
+ * Manage the user's custom agents (Settings.custom_agents): list the existing
+ * ones with a delete button, and an add form (label, command, optional args,
+ * optional "continue last session" resume flag). Persisted globally via
+ * `updateSettings`, so a new agent shows up in every add-tab menu's Agents group.
+ *
+ * A custom agent is only a launch command — Eldrun spawns `cmd` (+ args/env) as
+ * an `agent` tab. The resume flag is the one extra capability: set it and the
+ * tab survives a restart (cwd-continue tier, like Qwen/OpenCode/Gemini); leave it
+ * blank and the tab is launch-only, dropped on restart like Aider.
+ */
+export function CustomAgentDialog({ onClose }: Props) {
+  const settings = useSettingsStore((s) => s.settings);
+  const updateSettings = useSettingsStore((s) => s.updateSettings);
+  const agents = useMemo(() => settings?.custom_agents ?? [], [settings]);
+
+  const [label, setLabel] = useState("");
+  const [cmd, setCmd] = useState("");
+  const [argsText, setArgsText] = useState("");
+  const [resumeText, setResumeText] = useState("");
+  const [installText, setInstallText] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Installed status of each agent's command, so a missing one can offer its
+  // one-click install. `null` until the probe resolves (rows render without a
+  // status hint rather than flashing "not installed").
+  const [installed, setInstalled] = useState<Set<string> | null>(null);
+  useEffect(() => {
+    const cmds = agents.map((a) => a.cmd);
+    if (cmds.length === 0) {
+      setInstalled(new Set());
+      return;
+    }
+    invoke<string[]>("probe_binaries", { bins: cmds })
+      .then((found) => setInstalled(new Set(found)))
+      .catch(() => setInstalled(new Set()));
+  }, [agents]);
+
+  const persist = async (next: CustomAgent[]) => {
+    setBusy(true);
+    setError(null);
+    try {
+      await updateSettings({ custom_agents: next });
+    } catch (e) {
+      setError(String(e));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const add = async () => {
+    const name = label.trim();
+    const command = cmd.trim();
+    if (!name || !command) {
+      setError("A label and a command are both required.");
+      return;
+    }
+    const args = parseArgs(argsText);
+    const resumeArgs = parseArgs(resumeText);
+    const install = installText.trim();
+    const agent: CustomAgent = {
+      id: mintId(),
+      label: name,
+      cmd: command,
+      ...(args.length ? { args } : {}),
+      ...(resumeArgs.length ? { resumeArgs } : {}),
+      ...(install ? { installCmd: install } : {}),
+    };
+    await persist([...agents, agent]);
+    setLabel("");
+    setCmd("");
+    setArgsText("");
+    setResumeText("");
+    setInstallText("");
+  };
+
+  const remove = (id: string) => void persist(agents.filter((a) => a.id !== id));
+
+  // Run an agent's install command in a fresh root terminal tab (Eldrun's
+  // install-via-tab policy). Closes the dialog so the terminal is in view.
+  const install = (a: CustomAgent) => {
+    if (!a.installCmd) return;
+    runInstallInTab(`Install ${a.label}`, a.installCmd, "default");
+    onClose();
+  };
+
+  return createPortal(
+    <div className="modal-backdrop" onMouseDown={onClose}>
+      <div
+        className="settings-dialog custom-agent-dialog"
+        onMouseDown={(e) => e.stopPropagation()}
+      >
+        <div className="settings-title-row">
+          <h2>Custom agents</h2>
+          <button type="button" className="dialog-close-btn" onClick={onClose}>×</button>
+        </div>
+        <div className="dialog-scroll">
+        <p className="settings-help">
+          Add any command-line agent so it appears in the <strong>Agents</strong>{" "}
+          section of the new-tab menu. Eldrun launches the command in the project
+          directory as an agent tab.
+        </p>
+
+        {agents.length > 0 && (
+          <div className="custom-agent-list">
+            {agents.map((a) => {
+              const missing = installed != null && !installed.has(a.cmd);
+              return (
+                <div className="custom-agent-row" key={a.id}>
+                  <span className="custom-agent-row-label">{a.label}</span>
+                  <code className="custom-agent-row-cmd">
+                    {[a.cmd, ...(a.args ?? [])].join(" ")}
+                  </code>
+                  {a.resumeArgs?.length ? (
+                    <span className="custom-agent-row-tag" title="Survives a restart">
+                      resumable
+                    </span>
+                  ) : null}
+                  {missing &&
+                    (a.installCmd ? (
+                      <button
+                        type="button"
+                        className="custom-agent-install"
+                        title={`Run: ${a.installCmd}`}
+                        onClick={() => install(a)}
+                      >
+                        Install
+                      </button>
+                    ) : (
+                      <span
+                        className="custom-agent-row-missing"
+                        title="Command not found on PATH"
+                      >
+                        not found
+                      </span>
+                    ))}
+                  <button
+                    type="button"
+                    className="custom-agent-remove"
+                    title="Remove this agent"
+                    disabled={busy}
+                    onClick={() => remove(a.id)}
+                  >
+                    ×
+                  </button>
+                </div>
+              );
+            })}
+          </div>
+        )}
+
+        <div className="custom-agent-form">
+          <label className="custom-agent-field">
+            <span>Label</span>
+            <input
+              value={label}
+              placeholder="e.g. My Agent"
+              autoFocus
+              onChange={(e) => setLabel(e.target.value)}
+            />
+          </label>
+          <label className="custom-agent-field">
+            <span>Command</span>
+            <input
+              value={cmd}
+              placeholder="e.g. my-agent  (binary name or full path)"
+              spellCheck={false}
+              onChange={(e) => setCmd(e.target.value)}
+            />
+          </label>
+          <label className="custom-agent-field">
+            <span>Arguments <em>(optional)</em></span>
+            <input
+              value={argsText}
+              placeholder="e.g. --model gpt-x"
+              spellCheck={false}
+              onChange={(e) => setArgsText(e.target.value)}
+            />
+          </label>
+          <label className="custom-agent-field">
+            <span>Resume flag <em>(optional)</em></span>
+            <input
+              value={resumeText}
+              placeholder="e.g. --continue  (keeps the tab across a restart)"
+              spellCheck={false}
+              onChange={(e) => setResumeText(e.target.value)}
+            />
+          </label>
+          <label className="custom-agent-field">
+            <span>Install command <em>(optional)</em></span>
+            <input
+              value={installText}
+              placeholder="e.g. npm install -g @scope/my-agent"
+              spellCheck={false}
+              onChange={(e) => setInstallText(e.target.value)}
+            />
+          </label>
+          <p className="settings-help">
+            An install command lets Eldrun install the agent for you: when its
+            binary isn&apos;t found, an <strong>Install</strong> button runs the
+            command in a new root terminal tab. Any one-liner works (npm, pipx,
+            curl&nbsp;| sh, …).
+          </p>
+          <p className="settings-help">
+            A resume flag lets Eldrun relaunch the agent on its most recent session
+            after a restart. Leave it blank if the agent has no such flag — the tab
+            will simply start fresh next time.
+          </p>
+        </div>
+
+        {error && <div className="settings-error">{error}</div>}
+
+        <div className="project-dialog-actions">
+          <button type="button" onClick={onClose}>Done</button>
+          <button
+            type="button"
+            disabled={busy || !label.trim() || !cmd.trim()}
+            onClick={() => void add()}
+          >
+            Add agent
+          </button>
+        </div>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/tabs/NewTabMenu.tsx b/src/components/tabs/NewTabMenu.tsx
new file mode 100644
index 0000000..3bab076
--- /dev/null
+++ b/src/components/tabs/NewTabMenu.tsx
@@ -0,0 +1,315 @@
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { invoke } from "@tauri-apps/api/core";
+import {
+  CALENDAR_TAB_CMD,
+  DISKUSAGE_TAB_CMD,
+  NETWORK_TAB_CMD,
+  type TabEntry,
+} from "../../stores/tabs";
+import { useSettingsStore } from "../../stores/settings";
+import {
+  EMPTY_CUSTOM_AGENTS,
+  SHELL_ITEMS,
+  TAB_ACCENT,
+  agentMenuEntries,
+  buildStaticTabSpec,
+  isFileTabKind,
+  type StaticMenuItem,
+} from "./newTabItems";
+import { AddTabMenuList } from "./AddTabMenuList";
+
+interface Props {
+  /** Scope (project id or "root") the new tab belongs to. Gates the project-only
+   *  sections (Network Traffic, which needs a host/SSH link). */
+  scope: string;
+  /** cwd for the new tab (the popout group's project directory). */
+  projectCwd: string;
+  /** Project name, used to auto-name an agent's session on launch. May be empty
+   *  (the detached window is inert to the projects store) — then session-rename
+   *  is simply skipped. */
+  projectName: string;
+  /** Anchor position (viewport px) — the menu opens at this point and grows
+   *  down/right, clamped back inside the viewport once measured. */
+  anchor: { x: number; y: number };
+  /** Called with the fully-resolved tab payload (minus the store-minted key)
+   *  when the user picks an entry. The caller creates the tab. */
+  onPick: (spec: Omit<TabEntry, "key">) => void;
+  onClose: () => void;
+  /** Open the manage-custom-agents dialog. Hosted by the parent (this menu
+   *  unmounts on `onClose`, so it can't own the dialog itself). */
+  onManageAgents: () => void;
+}
+
+/**
+ * The "+" add-tab menu, factored out of the main-window `TabBar` so the detached
+ * popout (#42) can offer the same choices. It resolves each entry to a full tab
+ * payload via `buildStaticTabSpec` (shared with `TabBar`) and hands it to
+ * `onPick`; the caller decides how to create the tab (the main window calls
+ * `addTab`; the popout streams an "add" edit to the main window).
+ */
+export function NewTabMenu({ scope, projectCwd, projectName, anchor, onPick, onClose, onManageAgents }: Props) {
+  const menuRef = useRef<HTMLDivElement>(null);
+  const [pos, setPos] = useState(anchor);
+
+  const localModel = useSettingsStore(
+    (s) => s.settings?.ollama_roles?.tabs ?? s.settings?.ollama_model,
+  );
+  const customAgents = useSettingsStore(
+    (s) => s.settings?.custom_agents ?? EMPTY_CUSTOM_AGENTS,
+  );
+  // Built-in agents the user turned off in "Manage Agents" (Settings) despite
+  // being installed — hidden from this menu without uninstalling the CLI.
+  const disabledAgents = useSettingsStore((s) => s.settings?.disabled_agents);
+
+  // Installed agent CLIs (id == cmd); only offer ones actually present. `null`
+  // until the probe resolves, so the Agents list renders nothing (not a flash of
+  // all agents) until we know.
+  const [installedAgents, setInstalledAgents] = useState<Set<string> | null>(null);
+  // installedAgents minus disabledAgents — the set every tab-choice consumer
+  // below (Agents group, Mistral/vibe local-model driver) should use.
+  const enabledAgents = useMemo(() => {
+    if (!installedAgents) return null;
+    if (!disabledAgents?.length) return installedAgents;
+    const skip = new Set(disabledAgents);
+    return new Set([...installedAgents].filter((id) => !skip.has(id)));
+  }, [installedAgents, disabledAgents]);
+  // Installed *custom*-agent commands, probed separately (they aren't in the
+  // built-in registry). `null` until resolved — custom agents render enabled
+  // until a probe proves one missing.
+  const [installedCustom, setInstalledCustom] = useState<Set<string> | null>(null);
+  const [localDrivers, setLocalDrivers] = useState<
+    { id: string; label: string; available: boolean }[]
+  >([]);
+  useEffect(() => {
+    invoke<{ id: string; installed: boolean }[]>("list_agents")
+      .then((list) => setInstalledAgents(new Set(list.filter((a) => a.installed).map((a) => a.id))))
+      .catch(() => setInstalledAgents(new Set()));
+    invoke<{ id: string; label: string; available: boolean }[]>("list_local_drivers")
+      .then(setLocalDrivers)
+      .catch(() => {});
+  }, []);
+  // Re-probe custom commands whenever the set changes (adding one in the dialog).
+  useEffect(() => {
+    const cmds = customAgents.map((a) => a.cmd);
+    if (cmds.length === 0) {
+      setInstalledCustom(new Set());
+      return;
+    }
+    invoke<string[]>("probe_binaries", { bins: cmds })
+      .then((found) => setInstalledCustom(new Set(found)))
+      .catch(() => setInstalledCustom(new Set()));
+  }, [customAgents]);
+
+  // Outside-click / Escape closes the menu.
+  useEffect(() => {
+    const onDown = (e: MouseEvent) => {
+      if (menuRef.current?.contains(e.target as Node)) return;
+      onClose();
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("mousedown", onDown);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onDown);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [onClose]);
+
+  // Keep the menu inside the viewport (mirrors TabBar's clamp).
+  useLayoutEffect(() => {
+    const el = menuRef.current;
+    if (!el) return;
+    const rect = el.getBoundingClientRect();
+    const margin = 8;
+    let nx = pos.x;
+    let ny = pos.y;
+    if (rect.right > window.innerWidth - margin) {
+      nx = Math.max(margin, window.innerWidth - margin - rect.width);
+    }
+    if (rect.bottom > window.innerHeight - margin) {
+      ny = Math.max(margin, window.innerHeight - margin - rect.height);
+    }
+    if (nx !== pos.x || ny !== pos.y) setPos({ x: nx, y: ny });
+  }, [pos]);
+
+  const pickStatic = (item: StaticMenuItem) => {
+    onPick(buildStaticTabSpec(item, projectCwd, projectName));
+    onClose();
+  };
+
+  const pickFixed = (spec: Omit<TabEntry, "key">) => {
+    onPick(spec);
+    onClose();
+  };
+
+  // Mistral/vibe drives the local model through its own per-model VIBE_HOME.
+  const pickOllamaModel = async (model: string) => {
+    onClose();
+    try {
+      await invoke("ensure_ollama_running");
+      const { vibe_home, alias } = await invoke<{ vibe_home: string; alias: string }>(
+        "prepare_local_agent",
+        { model },
+      );
+      onPick({
+        label: model,
+        cmd: "vibe",
+        args: [],
+        // ELDRUN_LOCAL_MODEL: which model this tab drives, for the usage recap's
+        // per-model breakdown (VIBE_ACTIVE_MODEL is the resolved alias).
+        env: { VIBE_HOME: vibe_home, VIBE_ACTIVE_MODEL: alias, ELDRUN_LOCAL_MODEL: model },
+        cwd: projectCwd,
+        kind: "local_agent",
+      });
+    } catch {
+      /* ollama down / prep failed — don't create a broken tab */
+    }
+  };
+
+  // Other agents drive the same model via `ollama launch` (or a direct fallback);
+  // the backend resolves the spawn command so the tab carries everything in cmd+args.
+  const pickLocalLaunch = async (agentId: string, label: string, model: string) => {
+    onClose();
+    try {
+      await invoke("ensure_ollama_running");
+      const { cmd, args } = await invoke<{ cmd: string; args: string[] }>(
+        "prepare_local_launch",
+        { agent: agentId, model },
+      );
+      onPick({
+        label: `${model} · ${label}`,
+        cmd,
+        args,
+        // cmd/args are the resolved launcher and name no model — record it here.
+        env: { ELDRUN_LOCAL_MODEL: model },
+        cwd: projectCwd,
+        kind: "local_agent",
+      });
+    } catch {
+      /* ollama launch unavailable / prep failed */
+    }
+  };
+
+  return createPortal(
+    <div
+      className="tab-new-menu"
+      ref={menuRef}
+      style={{ position: "fixed", left: pos.x, top: pos.y }}
+    >
+      <AddTabMenuList
+        groups={[
+          {
+            label: "Agents",
+            entries: agentMenuEntries({
+              installedBuiltins: enabledAgents,
+              installedCmds: installedCustom,
+              customAgents,
+              pick: pickStatic,
+              onAddCustom: () => {
+                onClose();
+                onManageAgents();
+              },
+            }),
+          },
+          {
+            label: localModel ? `Local Model · ${localModel}` : "Local Model",
+            entries: localModel
+              ? [
+                  ...(enabledAgents?.has("vibe")
+                    ? [{
+                        key: "vibe",
+                        label: "Mistral",
+                        color: TAB_ACCENT["local_agent"],
+                        onPick: () => void pickOllamaModel(localModel),
+                      }]
+                    : []),
+                  ...localDrivers.filter((d) => d.available).map((d) => ({
+                    key: d.id,
+                    label: d.label,
+                    color: TAB_ACCENT["local_agent"],
+                    onPick: () => void pickLocalLaunch(d.id, d.label, localModel),
+                  })),
+                ]
+              : [],
+            hint: localModel
+              ? "No local agent installed — install one in the 🧠 menu"
+              : "No local model set — pick one in the app bar",
+          },
+          {
+            label: "Shell",
+            entries: SHELL_ITEMS.filter((i) => i.kind === "shell").map((item) => ({
+              key: item.cmd || "shell",
+              label: item.label,
+              color: TAB_ACCENT[item.kind],
+              onPick: () => pickStatic(item),
+            })),
+          },
+          {
+            label: "Files",
+            entries: SHELL_ITEMS.filter((i) => isFileTabKind(i.kind)).map((item) => ({
+              key: item.cmd,
+              label: item.label,
+              color: TAB_ACCENT[item.kind],
+              disabled: !projectCwd,
+              onPick: () => pickStatic(item),
+            })),
+          },
+          // Disk Usage can scan anywhere, so it is offered in every scope; Network
+          // Traffic is per-project (host/SSH link), so the root scope has none.
+          {
+            label: "Monitoring",
+            entries: [
+              {
+                key: "diskusage",
+                label: "Disk Usage",
+                dot: "◕",
+                color: TAB_ACCENT.diskusage,
+                onPick: () =>
+                  pickFixed({
+                    label: "Disk Usage",
+                    cmd: DISKUSAGE_TAB_CMD,
+                    cwd: projectCwd,
+                    kind: "diskusage",
+                  }),
+              },
+              ...(scope !== "root"
+                ? [{
+                    key: "network",
+                    label: "Network Traffic",
+                    color: TAB_ACCENT.network,
+                    onPick: () =>
+                      pickFixed({
+                        label: "Network Traffic",
+                        cmd: NETWORK_TAB_CMD,
+                        cwd: projectCwd,
+                        kind: "network",
+                      }),
+                  }]
+                : []),
+            ],
+          },
+          {
+            label: "Calendar",
+            entries: [{
+              key: "calendar",
+              label: "Calendar",
+              dot: "◆",
+              color: TAB_ACCENT.calendar,
+              onPick: () =>
+                pickFixed({
+                  label: "Calendar",
+                  cmd: CALENDAR_TAB_CMD,
+                  cwd: projectCwd,
+                  kind: "calendar",
+                }),
+            }],
+          },
+        ]}
+      />
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/tabs/Subwindow.tsx b/src/components/tabs/Subwindow.tsx
index c5b55e2..1d1297f 100644
--- a/src/components/tabs/Subwindow.tsx
+++ b/src/components/tabs/Subwindow.tsx
@@ -1,4 +1,10 @@
-import { allGroups, useTabsStore } from "../../stores/tabs";
+import { useWindowFocused } from "../../hooks/useWindowFocused";
+import { allGroups, useGroup, useTabsStore } from "../../stores/tabs";
+import {
+  clampFilesWidth,
+  DEFAULT_GROUP_FILES_WIDTH,
+  SubwindowFilesSidebar,
+} from "../files/SubwindowFilesSidebar";
 import { TabBar } from "./TabBar";
 
 interface Props {
@@ -14,15 +20,32 @@ interface Props {
  * while a tab is dragged over this group) and the drop itself are both owned by
  * CenterPanel — the preview must paint ABOVE the flat pane layer, which lives in
  * a separate stacking context outside this subtree.
+ *
+ * When the group's `filesOpen` flag is set, a docked file-viewer column
+ * (`SubwindowFilesSidebar`) renders on the body's right edge, NEXT TO the
+ * measured pane slot — the slot shrinks, so CenterPanel's flat pane layer
+ * (positioned over the slot's measured rect) never covers the sidebar. The tab
+ * bar reserves the same width on its right (see `filesWidth` on TabBar) so the
+ * scrolling tab strip stops at the pane's edge instead of running over the
+ * viewer, while the subwindow's close/hide/◫ controls stay pinned far-right.
  */
 export function Subwindow({ groupId, projectCwd, children }: Props) {
   const focusGroup = useTabsStore((s) => s.focusGroup);
   const focusedGroupId = useTabsStore((s) => s.focusedGroupId);
+  const scope = useTabsStore((s) => s.scope);
+  // The per-subwindow file viewer's persisted state lives on the group NODE.
+  const group = useGroup(groupId);
+  const setGroupFilesWidth = useTabsStore((s) => s.setGroupFilesWidth);
+  const setGroupFiles = useTabsStore((s) => s.setGroupFiles);
+  const setGroupFilesFolder = useTabsStore((s) => s.setGroupFilesFolder);
   // The per-subwindow close button only makes sense with >1 subwindow.
   const groupCount = useTabsStore((s) => allGroups(s.layout).length);
   const showClose = groupCount > 1;
 
-  const isFocused = focusedGroupId === groupId;
+  // Only the OS-focused window paints an active subwindow, so a popout and the
+  // main window never both highlight one at once (#42 ergonomics).
+  const windowFocused = useWindowFocused();
+  const isFocused = windowFocused && focusedGroupId === groupId;
 
   return (
     <div
@@ -31,8 +54,31 @@ export function Subwindow({ groupId, projectCwd, children }: Props) {
         if (!isFocused) focusGroup(groupId);
       }}
     >
-      <TabBar groupId={groupId} projectCwd={projectCwd} showGroupClose={showClose} />
-      <div className="subwindow-body">{children}</div>
+      <TabBar
+        groupId={groupId}
+        projectCwd={projectCwd}
+        showGroupClose={showClose}
+        filesReserveWidth={
+          group?.filesOpen
+            ? clampFilesWidth(group.filesWidth ?? DEFAULT_GROUP_FILES_WIDTH)
+            : undefined
+        }
+      />
+      <div className="subwindow-body">
+        <div className="subwindow-pane-region">{children}</div>
+        {group?.filesOpen && (
+          <SubwindowFilesSidebar
+            scope={scope}
+            cwd={projectCwd}
+            width={group.filesWidth}
+            onWidthChange={(w) => setGroupFilesWidth(groupId, w)}
+            folder={group.filesFolder}
+            onFolderChange={(f) => setGroupFilesFolder(groupId, f)}
+            onHide={() => setGroupFiles(groupId, false)}
+            canOpenTabs
+          />
+        )}
+      </div>
     </div>
   );
 }
diff --git a/src/components/tabs/TabBar.tsx b/src/components/tabs/TabBar.tsx
index 4e455f5..2bfa405 100644
--- a/src/components/tabs/TabBar.tsx
+++ b/src/components/tabs/TabBar.tsx
@@ -1,21 +1,52 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { invoke } from "@tauri-apps/api/core";
-import { WebviewWindow } from "@tauri-apps/api/webviewWindow";
 import {
-  FILES_TAB_CMD,
+  BLOB_TAB_CMD,
+  CALENDAR_TAB_CMD,
+  DISKUSAGE_TAB_CMD,
+  NETWORK_TAB_CMD,
+  MONITOR_TAB_CMD,
+  EMPTY_GROUP_ID,
+  isPtyTabKind,
   useTabsStore,
   useGroup,
   useGroupTabs,
-  TabKind,
-  RESUMABLE_AGENTS,
 } from "../../stores/tabs";
 import { useDragStore } from "../../stores/drag";
+import { useTabLandStore } from "../../stores/tabLand";
 import { useDetachAnimStore, flyVector } from "../../stores/detachAnim";
 import { commitDrop } from "./commitDrop";
+import { TabDropPlaceholder } from "./TabDropPlaceholder";
+import {
+  EMPTY_CUSTOM_AGENTS,
+  SHELL_ITEMS,
+  TAB_ACCENT,
+  agentMenuEntries,
+  buildStaticTabSpec,
+  isFileTabKind,
+  type StaticMenuItem,
+} from "./newTabItems";
+import { AddTabMenuList } from "./AddTabMenuList";
+import { CustomAgentDialog } from "./CustomAgentDialog";
+import { type AgentMode, supportsAgentMode } from "./agentModes";
+import { reseedDetached, startDetachedDropSession } from "./detachedDropTargets";
+import { TabHoverCard } from "./TabHoverCard";
+import {
+  TabSourceBadge,
+  TabLocalityBadge,
+  LocalityMenu,
+  tabLocation,
+  type LocalityMenuState,
+} from "./TabLocalityBadges";
+import { useClampToViewport } from "../../hooks/useClampToViewport";
+import { startCursorPoll, desktopCursor, type PhysPoint } from "../../lib/coords";
+import { bindDragRelease, dragPlatform } from "../../lib/dragPlatform";
 import { useProjectsStore } from "../../stores/projects";
+import { useSettingsStore } from "../../stores/settings";
+import { useExperimental } from "../../lib/experimental";
+import { closeTabWithConfirm } from "../../lib/closeRemoteTab";
 import { useActivityStore } from "../../stores/activity";
-import { OrbitSpinner } from "../common/OrbitSpinner";
 
 /** Default fly-out card size when no live pane thumbnail is available (group
  *  detach via the bar drag carries no preview). */
@@ -45,58 +76,22 @@ function playDetachFlyOut(
   });
 }
 
-const TAB_ACCENT: Record<TabKind, string> = {
-  agent: "var(--accent)",
-  local_agent: "var(--warning)",
-  shell: "var(--success)",
-  files: "#888",
-  embed: "var(--info, #4aa3df)",
-};
-
-interface StaticMenuItem {
-  label: string;
-  cmd: string;
-  kind: TabKind;
-  env?: Record<string, string>;
-  // Optional template for a command typed into the agent on launch to name its
-  // own session after the project. Only set for agents with a known
-  // session-rename command; others are skipped to avoid typing junk into them.
-  sessionRename?: (projectName: string) => string;
-  // When set, Eldrun mints a UUID at launch and passes it to the agent so it
-  // owns a deterministic session id (e.g. Claude's `--session-id <uuid>`). The
-  // returned strings are appended to the spawn args. Lets us surface the
-  // session id on hover and later resume the session.
-  sessionIdArgs?: (uuid: string) => string[];
-}
-
-// Only Claude and Gemini accept a caller-supplied session UUID at launch
-// (both via `--session-id <uuid>`), so only those get `sessionIdArgs`. Codex
-// (`codex resume <id>`) and Mistral/vibe (`--resume [id]`) mint their own ids
-// and only accept one when resuming, so there's no deterministic id to capture
-// up front — passing `--session-id` would just error and break the tab.
-const AGENT_ITEMS: StaticMenuItem[] = [
-  { label: "Claude",  cmd: "claude", kind: "agent", sessionRename: (n) => `/rename ${n}`, sessionIdArgs: (id) => ["--session-id", id] },
-  { label: "Codex",   cmd: "codex",  kind: "agent" },
-  { label: "Gemini",  cmd: "gemini", kind: "agent", sessionIdArgs: (id) => ["--session-id", id] },
-  { label: "Mistral", cmd: "vibe",   kind: "agent" },
-];
-
-const SHELL_ITEMS: StaticMenuItem[] = [
-  { label: "Shell", cmd: "bash",          kind: "shell" },
-  { label: "Files", cmd: FILES_TAB_CMD,   kind: "files" },
-];
-
 interface Props {
   groupId: string;
   projectCwd: string;
   /** Show the per-subwindow close (×) button. Only when >1 subwindow exists. */
   showGroupClose: boolean;
+  /**
+   * Width (px) the docked file viewer occupies below this bar, when open. The
+   * bar reserves the same width on its right so the scrolling tab strip stops
+   * at the pane's edge (tabs never run over the viewer, and overflow-scroll
+   * engages there) while the ◫/hide/close controls stay pinned at the far
+   * right, above the viewer. Undefined when no viewer is docked.
+   */
+  filesReserveWidth?: number;
 }
 
-// Fixed width of the gap that opens within the bar to receive a reordered tab.
-const REORDER_GAP = 80;
-
-export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
+export function TabBar({ groupId, projectCwd, showGroupClose, filesReserveWidth }: Props) {
   // Fine-grained subscriptions (Eff #3/#4): this bar tracks ONLY its own group
   // node + that group's resolved tab payloads, so a tab change in another
   // subwindow no longer re-renders every bar, and the per-render Map-of-all-tabs
@@ -107,13 +102,40 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
   // a single boolean rather than the full tab array so it doesn't widen the bar's
   // subscription back out to every tab.
   const hasAnyTabs = useTabsStore((s) => s.tabs.length > 0);
+  // The 3D project-blob tab is a root-scope feature, offered only once at least
+  // one project exists (it has nothing to show otherwise).
+  const scope = useTabsStore((s) => s.scope);
+  const hasProjects = useProjectsStore((s) => s.projects.length > 0);
+  const showBlobItem = scope === "root" && hasProjects;
   const focusGroup = useTabsStore((s) => s.focusGroup);
   const setGroupActive = useTabsStore((s) => s.setGroupActive);
   const renameTab = useTabsStore((s) => s.renameTab);
   const addTab = useTabsStore((s) => s.addTab);
   const ensureTab = useTabsStore((s) => s.ensureTab);
   const removeTab = useTabsStore((s) => s.removeTab);
+  const setTabLocation = useTabsStore((s) => s.setTabLocation);
+  const setAgentMode = useTabsStore((s) => s.setAgentMode);
+  // Experimental — off by default, on in debug mode: the Plan/Auto badge.
+  const agentModeToggle = useExperimental("agent_mode_toggle");
+  // Timestamp of the last mode flip, for the respawn debounce in handleAgentMode.
+  const lastModeToggle = useRef(0);
   const closeGroup = useTabsStore((s) => s.closeGroup);
+  const hideGroup = useTabsStore((s) => s.hideGroup);
+  // Per-subwindow right file viewer: toggle state lives on the group node.
+  const filesOpen = !!group?.filesOpen;
+  const setGroupFiles = useTabsStore((s) => s.setGroupFiles);
+  // SSH-sync Phase 0: the local/remote locality toggle is only meaningful for a
+  // remote (SSH) project's agent/shell tabs. Subscribe to a single boolean so a
+  // project edit elsewhere doesn't re-render every bar.
+  const isRemoteScope = useProjectsStore((s) => !!s.projects.find((p) => p.id === scope)?.remote);
+  // The scope project's primary host + extra worker hosts (multi-host remote),
+  // for the tab locality menu (Local / Primary / each worker). Change rarely, so
+  // subscribing to the references is fine.
+  const primaryHost = useProjectsStore((s) => s.projects.find((p) => p.id === scope)?.remote?.host);
+  const computeHosts = useProjectsStore((s) => s.projects.find((p) => p.id === scope)?.compute_hosts);
+  // Per-tab file source (remote-native vs local mirror), published by the file
+  // viewers. Lets the Remote/Local badge ride on the viewer tab itself rather
+  // than costing a whole viewer header row. Only meaningful on remote projects.
   const closeAllTabs = useTabsStore((s) => s.closeAllTabs);
   const detachGroup = useTabsStore((s) => s.detachGroup);
   const detachTab = useTabsStore((s) => s.detachTab);
@@ -126,21 +148,112 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
   const reorderIndex = useDragStore((s) =>
     s.drag && s.drag.reorderGroup === groupId ? s.drag.reorderIndex : null,
   );
+  // Label of whatever is being dragged, shown in the drop placeholder so the
+  // target bar previews WHICH tab will land there (a tab's label, or a dragged
+  // file's name). Only meaningful while this bar is the active reorder target.
+  const dragLabel = useDragStore((s) =>
+    s.drag && s.drag.reorderGroup === groupId ? s.drag.label : "",
+  );
+  // One-shot "landing" flourish: the tab that was just dropped into THIS bar
+  // (cross-group move / split) plays a drop-in animation as it mounts here.
+  const landedKey = useTabLandStore((s) => s.landed?.key ?? null);
+  const landedNonce = useTabLandStore((s) => s.landed?.nonce ?? 0);
+  const clearLanded = useTabLandStore((s) => s.clear);
   // Per-tab "working" map: a tab whose PTY is actively producing output shows a
-  // spinner so busy agents/terminals are visible even when not the active tab.
+  // green status lamp so busy agents are visible even when not the active tab.
+  // Both maps are keyed by the composed PTY id (`<scope>:<tabKey>`), since tab
+  // keys alone can collide across projects.
   const busyByTab = useActivityStore((s) => s.busyByTab);
+  // Per-tab "needs attention" map: an agent tab that finished its turn, or that
+  // is waiting on a decision, while not being looked at pulses until it's viewed.
+  const attentionByTab = useActivityStore((s) => s.attentionByTab);
+  const clearAttention = useActivityStore((s) => s.clearAttention);
   // Active project's name, used to name an agent's own session on launch.
   const projectName = useProjectsStore(
     (s) => s.projects.find((p) => p.id === s.activeId)?.name ?? "",
   );
 
   const [menuPos, setMenuPos] = useState<{ x: number; y: number } | null>(null);
-  // #56: a right-click on a tab enters inline rename mode for that key (no menu,
-  // no prompt dialog). The label becomes a focused, text-selected <input>.
+  // Tab currently hovered → drives the styled hover card (the tab-bar
+  // counterpart to the project pill's hover popup). Anchored to the tab's
+  // bottom-center; cleared on leave, drag, or when a menu opens.
+  const [hoverTab, setHoverTab] = useState<
+    { key: string; x: number; y: number } | null
+  >(null);
+  // Right-click on a tab opens this context menu (Close / Close others / Close to
+  // the left / Close to the right / Rename). Shift+right-click bypasses it and
+  // goes straight to inline rename (#56). Keyed to the clicked tab + its index so
+  // the left/right-of splits resolve against this group's ordered `tabs`.
+  // Multi-host: the open tab-locality menu, keyed by tab. Two-level — `view`
+  // starts at "root" (Local ↔ Remote) and drills into "machines" (primary +
+  // each worker) when Remote is chosen. Positioned like the tab context menu.
+  const [localityMenu, setLocalityMenu] = useState<LocalityMenuState | null>(null);
+  const [tabMenu, setTabMenu] = useState<
+    { x: number; y: number; key: string; index: number } | null
+  >(null);
+  const tabMenuRef = useRef<HTMLDivElement>(null);
+  // #56: Shift+right-click on a tab enters inline rename mode for that key (no
+  // menu, no prompt dialog). The label becomes a focused, text-selected <input>.
   const [editingKey, setEditingKey] = useState<string | null>(null);
-  const [ollamaModels, setOllamaModels] = useState<string[]>([]);
-  const [ollamaLoading, setOllamaLoading] = useState(false);
-  const [ollamaError, setOllamaError] = useState<string | null>(null);
+  // The local (Ollama) model a "Local Model" tab launches: the model tagged for
+  // the "tabs" task in the 🧠 menu, falling back to the default `ollama_model`.
+  // The add menu offers ONE "Local Model" entry that launches it, rather than
+  // listing every installed model.
+  const localModel = useSettingsStore(
+    (s) => s.settings?.ollama_roles?.tabs ?? s.settings?.ollama_model,
+  );
+  // Coding agents that can drive the active local model besides Mistral/vibe —
+  // Claude Code, Codex, OpenCode, Droid via `ollama launch` (or a direct
+  // fallback). Loaded once; only the currently-available ones are offered.
+  const [localDrivers, setLocalDrivers] = useState<
+    { id: string; label: string; available: boolean }[]
+  >([]);
+  useEffect(() => {
+    invoke<{ id: string; label: string; available: boolean }[]>("list_local_drivers")
+      .then(setLocalDrivers)
+      .catch(() => {});
+  }, []);
+  // Installed agent CLIs (by id == cmd). The add menu only offers agents whose
+  // binary is actually present, so it never lists ones the user can't launch.
+  // `null` until the probe resolves; render nothing until then to avoid a flash
+  // of the full list. Loaded once.
+  const [installedAgents, setInstalledAgents] = useState<Set<string> | null>(null);
+  useEffect(() => {
+    invoke<{ id: string; installed: boolean }[]>("list_agents")
+      .then((list) =>
+        setInstalledAgents(new Set(list.filter((a) => a.installed).map((a) => a.id))),
+      )
+      .catch(() => setInstalledAgents(new Set()));
+  }, []);
+  // Built-in agents the user turned off in "Manage Agents" (Settings) despite
+  // being installed — hidden from this menu without uninstalling the CLI.
+  const disabledAgents = useSettingsStore((s) => s.settings?.disabled_agents);
+  // installedAgents minus disabledAgents — the set every tab-choice consumer
+  // below (Agents group, Mistral/vibe local-model driver) should use.
+  const enabledAgents = useMemo(() => {
+    if (!installedAgents) return null;
+    if (!disabledAgents?.length) return installedAgents;
+    const skip = new Set(disabledAgents);
+    return new Set([...installedAgents].filter((id) => !skip.has(id)));
+  }, [installedAgents, disabledAgents]);
+  // User-defined custom agents (Settings.custom_agents) + the manage-dialog it
+  // opens. Their commands aren't in the built-in registry, so they're probed
+  // separately (`probe_binaries`); `null` until resolved. See agentMenuEntries.
+  const customAgents = useSettingsStore(
+    (s) => s.settings?.custom_agents ?? EMPTY_CUSTOM_AGENTS,
+  );
+  const [installedCustom, setInstalledCustom] = useState<Set<string> | null>(null);
+  const [agentDialogOpen, setAgentDialogOpen] = useState(false);
+  useEffect(() => {
+    const cmds = customAgents.map((a) => a.cmd);
+    if (cmds.length === 0) {
+      setInstalledCustom(new Set());
+      return;
+    }
+    invoke<string[]>("probe_binaries", { bins: cmds })
+      .then((found) => setInstalledCustom(new Set(found)))
+      .catch(() => setInstalledCustom(new Set()));
+  }, [customAgents]);
   const addMenuRef = useRef<HTMLDivElement>(null);
   const addBtnRef = useRef<HTMLButtonElement>(null);
   // The tabs live in their own horizontally-scrolling strip; chevrons flank it
@@ -186,6 +299,38 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
     el.scrollBy({ left: dir * Math.max(120, el.clientWidth * 0.7), behavior: "smooth" });
   }, []);
 
+  // Continuous scroll while a chevron is hovered: rAF loop nudges the strip each
+  // frame until the pointer leaves (mirrors the project switcher's pill chevrons).
+  const hoverScrollRef = useRef<number | null>(null);
+  const stopHoverScroll = useCallback(() => {
+    if (hoverScrollRef.current !== null) {
+      cancelAnimationFrame(hoverScrollRef.current);
+      hoverScrollRef.current = null;
+    }
+  }, []);
+  const startHoverScroll = useCallback((dir: number) => {
+    stopHoverScroll();
+    const step = () => {
+      const el = stripRef.current;
+      if (!el) return;
+      el.scrollLeft += dir * 6;
+      // Unlike the switcher, these chevrons unmount at the edges (canScroll*),
+      // so onMouseLeave may never fire — stop the loop once we can't scroll
+      // further in `dir` rather than spinning forever.
+      const atEdge =
+        dir < 0
+          ? el.scrollLeft <= 0
+          : el.scrollLeft + el.clientWidth >= el.scrollWidth - 1;
+      if (atEdge) {
+        hoverScrollRef.current = null;
+        return;
+      }
+      hoverScrollRef.current = requestAnimationFrame(step);
+    };
+    hoverScrollRef.current = requestAnimationFrame(step);
+  }, [stopHoverScroll]);
+  useEffect(() => stopHoverScroll, [stopHoverScroll]);
+
   // Translate a vertical wheel into horizontal strip scrolling so the tabs can be
   // panned while hovering anywhere over them, not just via the (hidden) scrollbar.
   const onStripWheel = useCallback((e: React.WheelEvent) => {
@@ -198,6 +343,14 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
 
   const activeKey = group?.activeKey ?? null;
 
+  // Looking at a tab clears its "needs attention" flag — activating a tab (click,
+  // keyboard switch, or mounting with it already active) makes it the one on screen.
+  // `recompute` would reach the same conclusion on its next tick; this just spares
+  // the tab you just opened up to an interval's worth of leftover glow.
+  useEffect(() => {
+    if (activeKey) clearAttention(`${scope}:${activeKey}`);
+  }, [scope, activeKey, clearAttention]);
+
   useEffect(() => {
     if (!menuOpen) return;
     const onDown = (e: MouseEvent) => {
@@ -217,6 +370,34 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
     };
   }, [menuOpen]);
 
+  // Keep the add menu inside the viewport: it's positioned at the +'s left/bottom
+  // and grows rightward/downward, so a + near the right (or bottom) edge would push
+  // it past the window border and clip it off-screen.
+  useClampToViewport(addMenuRef, menuPos, setMenuPos);
+
+  // Dismiss the tab context menu on an outside click or Escape (mirrors the add
+  // menu). Clicks inside the menu itself are ignored so its items can fire.
+  useEffect(() => {
+    if (!tabMenu) return;
+    const onDown = (e: MouseEvent) => {
+      if (tabMenuRef.current?.contains(e.target as Node)) return;
+      setTabMenu(null);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key === "Escape") setTabMenu(null);
+    };
+    document.addEventListener("mousedown", onDown);
+    document.addEventListener("keydown", onKey);
+    return () => {
+      document.removeEventListener("mousedown", onDown);
+      document.removeEventListener("keydown", onKey);
+    };
+  }, [tabMenu]);
+
+  // Keep the tab context menu inside the viewport: it opens at the cursor and
+  // grows right/down, so one near the right/bottom edge would clip.
+  useClampToViewport(tabMenuRef, tabMenu, setTabMenu);
+
   // Drop inline-rename mode if the edited tab disappears (closed / moved away).
   useEffect(() => {
     if (editingKey && !tabs.some((t) => t.key === editingKey)) {
@@ -237,50 +418,106 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
     // Adding always targets THIS group, so focus it first.
     focusGroup(groupId);
     setMenuPos({ x: r.left, y: r.bottom + 4 });
-
-    setOllamaLoading(true);
-    setOllamaError(null);
-    invoke<string[]>("list_ollama_models")
-      .then((models) => setOllamaModels(models))
-      .catch((e: string) => {
-        setOllamaModels([]);
-        setOllamaError(e === "not_running" ? "Ollama not running" : "Failed to load models");
-      })
-      .finally(() => setOllamaLoading(false));
   }
 
   function handleAdd(item: StaticMenuItem) {
     // addTab/ensureTab insert into the focused group; focus this one first.
     focusGroup(groupId);
-    if (item.kind === "files") {
+    // Both file panes are one-per-cwd: a second identical view of the same
+    // project is never what the click meant, so re-picking focuses the open one.
+    // A Files (Project) tab opened ON A FOLDER (the tree's "Open in a new tab")
+    // is not that tab, though — it is its own view — so it never absorbs this
+    // click, which would otherwise leave no way to get the project root back.
+    if (isFileTabKind(item.kind)) {
       ensureTab(
         { label: item.label, cmd: item.cmd, cwd: projectCwd, kind: item.kind },
-        (tab) => tab.kind === "files" && tab.cwd === projectCwd,
+        (tab) => tab.kind === item.kind && tab.cwd === projectCwd && !tab.folder,
       );
       setMenuPos(null);
       return;
     }
-    // For agents that support it, type their session-rename command on launch
-    // so the agent's own session is named after the project.
-    const initialInput =
-      item.sessionRename && projectName ? item.sessionRename(projectName) : undefined;
-    // Mint a per-tab UUID for any agent we can resume (`cmd` in RESUMABLE_AGENTS)
-    // or that takes a deterministic launch id (`sessionIdArgs`). It is the tab's
-    // stable key for the whole session-tracking machinery.
-    const tracked = item.cmd in RESUMABLE_AGENTS;
-    const sessionId = tracked || item.sessionIdArgs ? crypto.randomUUID() : undefined;
-    // Launch args: only agents with `sessionIdArgs` (Claude, Gemini) pass the id
-    // at launch (`--session-id`). Codex mints its own id, so it launches bare and
-    // the backend injects `resume <live-id>` on a later restore.
-    const args = sessionId && item.sessionIdArgs ? item.sessionIdArgs(sessionId) : [];
-    // Resumable agents get `ELDRUN_TAB_UID` so the SessionStart hook records their
-    // live session id under this tab's key (see services::agent_session). Persisted
-    // in env, so it round-trips across restart.
-    const env = {
-      ...(item.env ?? {}),
-      ...(tracked && sessionId ? { ELDRUN_TAB_UID: sessionId } : {}),
-    };
-    addTab({ label: item.label, cmd: item.cmd, args, env, cwd: projectCwd, kind: item.kind, initialInput, sessionId });
+    // Build the full launch spec (session-id minting, ELDRUN_TAB_UID, args,
+    // session-rename input) via the shared helper so the main and detached add
+    // menus can never drift.
+    addTab(buildStaticTabSpec(item, projectCwd, projectName));
+    setMenuPos(null);
+  }
+
+  // Flip an agent tab between Plan and Auto. This rewrites the tab's launch args,
+  // which respawns its PTY — the agent resumes onto the same conversation, but a
+  // turn in flight is killed with it, so a busy tab asks first. The debounce keeps
+  // a burst of clicks from tripping the backend's crash-loop guard (which refuses
+  // to respawn a PTY that has spawned too often in 10s) and leaving a dead tab.
+  function handleAgentMode(key: string, ptyId: string, current?: AgentMode) {
+    const now = Date.now();
+    if (now - lastModeToggle.current < 1000) return;
+    if (
+      busyByTab[ptyId] &&
+      !window.confirm(
+        "This agent is working. Switching mode restarts it — the conversation is " +
+          "resumed, but the current turn is lost. Switch anyway?",
+      )
+    ) {
+      return;
+    }
+    lastModeToggle.current = now;
+    // Unset (the agent's own default) resolves to Plan on first click; after that
+    // it is a straight two-way flip.
+    setAgentMode(key, current === "plan" ? "auto" : "plan");
+  }
+
+  function handleAddNetwork() {
+    focusGroup(groupId);
+    addTab({
+      label: "Network Traffic",
+      cmd: NETWORK_TAB_CMD,
+      cwd: projectCwd,
+      kind: "network",
+    });
+    setMenuPos(null);
+  }
+
+  // Open (or focus, if already open) the 3D project-blob tab in this group.
+  function handleAddBlob() {
+    focusGroup(groupId);
+    ensureTab(
+      { label: "Projects", cmd: BLOB_TAB_CMD, cwd: projectCwd, kind: "projects3d" },
+      (tab) => tab.kind === "projects3d",
+    );
+    setMenuPos(null);
+  }
+
+  // Open (or focus, if already open) the htop-like system monitor tab. The view
+  // is whole-machine/global, so one per group is enough — ensureTab focuses an
+  // existing one instead of stacking duplicates.
+  function handleAddMonitor() {
+    focusGroup(groupId);
+    ensureTab(
+      { label: "System Monitor", cmd: MONITOR_TAB_CMD, cwd: projectCwd, kind: "monitor" },
+      (tab) => tab.kind === "monitor",
+    );
+    setMenuPos(null);
+  }
+
+  // Add a disk usage analyzer tab. Unlike the monitor/blob/calendar panes above,
+  // this one is NOT a singleton: each tab holds its own independent scan root, and
+  // comparing two folders side by side is the point — so it stacks (addTab) rather
+  // than focusing an existing one (ensureTab, which matches across the whole scope).
+  function handleAddDiskUsage() {
+    focusGroup(groupId);
+    addTab({ label: "Disk Usage", cmd: DISKUSAGE_TAB_CMD, cwd: projectCwd, kind: "diskusage" });
+    setMenuPos(null);
+  }
+
+  // Open (or focus, if already open) the native calendar tab. The event store is
+  // global, so a calendar tab in any scope shows the same events — one per scope
+  // is enough, hence ensureTab rather than addTab.
+  function handleAddCalendar() {
+    focusGroup(groupId);
+    ensureTab(
+      { label: "Calendar", cmd: CALENDAR_TAB_CMD, cwd: projectCwd, kind: "calendar" },
+      (tab) => tab.kind === "calendar",
+    );
     setMenuPos(null);
   }
 
@@ -297,7 +534,10 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
         label: model,
         cmd: "vibe",
         args: [],
-        env: { VIBE_HOME: vibe_home, VIBE_ACTIVE_MODEL: alias },
+        // ELDRUN_LOCAL_MODEL records WHICH model this tab is driving, so the
+        // usage recap can break local agent tabs down by model. `VIBE_ACTIVE_MODEL`
+        // carries the resolved alias, not necessarily the name the user picked.
+        env: { VIBE_HOME: vibe_home, VIBE_ACTIVE_MODEL: alias, ELDRUN_LOCAL_MODEL: model },
         cwd: projectCwd,
         kind: "local_agent",
       });
@@ -306,11 +546,41 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
     }
   }
 
-  // #56: right-click a tab → immediately enter inline rename mode (no menu).
+  // Drive the active local model through a non-vibe coding agent (Claude Code,
+  // Codex, OpenCode, Droid). The backend resolves the spawn command — `ollama
+  // launch <agent> --model <model>` when available, else a direct fallback — so
+  // everything the tab needs is carried in cmd+args (no env to re-hydrate).
+  async function handleLocalLaunch(agentId: string, label: string, model: string) {
+    setMenuPos(null);
+    try {
+      await invoke("ensure_ollama_running");
+      const { cmd, args } = await invoke<{ cmd: string; args: string[] }>(
+        "prepare_local_launch",
+        { agent: agentId, model },
+      );
+      focusGroup(groupId);
+      addTab({
+        label: `${model} · ${label}`,
+        cmd,
+        args,
+        // Nothing else here names the model — cmd/args are the resolved launcher —
+        // so record it for the usage recap's per-model breakdown.
+        env: { ELDRUN_LOCAL_MODEL: model },
+        cwd: projectCwd,
+        kind: "local_agent",
+      });
+    } catch {
+      // ollama launch unavailable / agent prep failed — don't create a broken tab.
+    }
+  }
+
+  // #56: enter inline rename mode for a tab (no menu). Reached via Shift+right-
+  // click and the context menu's "Rename" item.
   function startInlineRename(event: React.MouseEvent, key: string) {
     event.preventDefault();
     event.stopPropagation();
     setMenuPos(null);
+    setTabMenu(null);
     focusGroup(groupId);
     setEditingKey(key);
   }
@@ -322,15 +592,52 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
     setEditingKey(null);
   }
 
+  // Right-click a tab → context menu; Shift+right-click → straight to rename.
+  function onTabContextMenu(event: React.MouseEvent, key: string, index: number) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (event.shiftKey) {
+      startInlineRename(event, key);
+      return;
+    }
+    setMenuPos(null); // close the add (+) menu if it was open
+    setHoverTab(null); // and the hover card, so it doesn't sit atop the menu
+    focusGroup(groupId);
+    setTabMenu({ x: event.clientX, y: event.clientY, key, index });
+  }
+
+  // Bulk-close helpers built on the tested `removeTab` action over this group's
+  // ordered `tabs`. Each removeTab reads fresh store state and repicks the active
+  // tab / collapses empty groups, so looping over a render-time snapshot is safe.
+  function closeToLeft(index: number) {
+    tabs.slice(0, index).forEach((t) => removeTab(t.key));
+  }
+  function closeToRight(index: number) {
+    tabs.slice(index + 1).forEach((t) => removeTab(t.key));
+  }
+  function closeOthers(key: string) {
+    tabs.filter((t) => t.key !== key).forEach((t) => removeTab(t.key));
+  }
+
   // Start a pointer-based tab drag once the pointer crosses a 5px threshold.
   // HTML5 native DnD is unreliable on WebKitGTK, so we drive the whole drag from
   // plain window listeners. CenterPanel owns the drop authority (its pointerup
   // commits + ends); this handler only seeds the drag and handles the click case.
+  //
+  // Cross-window position is POLL-DRIVEN: `startCursorPoll` reports the OS cursor
+  // in physical desktop px (the only DPI-correct, cross-engine source — DOM
+  // `screenX/Y` units diverge across WebKitGTK/WebView2/WKWebView). The in-window
+  // ghost + the "outside this window" test stay on DOM `clientX/clientY` (reliable
+  // CSS px on every engine). The terminal release is centralized through
+  // `bindDragRelease`, which applies the engine-correct cancel-vs-commit policy.
   function onTabPointerDown(
     e: React.PointerEvent,
     tab: (typeof tabs)[number],
   ) {
     if (e.button !== 0) return;
+    // Dismiss the hover card the moment a click/drag begins so it never lingers
+    // over a drag ghost or the pane below.
+    setHoverTab(null);
     // While this tab is being inline-renamed, the label is an <input>: don't
     // hijack its pointer into a tab drag (lets the caret/selection work).
     if (editingKey === tab.key) return;
@@ -340,8 +647,30 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
     e.preventDefault();
     const startX = e.clientX;
     const startY = e.clientY;
+    const pointerId = e.pointerId;
+    // Capture on the document root, NOT the dragged tab. When this tab is the
+    // lone tab of its subwindow, CenterPanel collapses that subwindow LIVE the
+    // moment the drag starts — which unmounts this tab's DOM node. Removing the
+    // pointer-capture *target* mid-gesture drops the capture (and on Chromium/
+    // WebView2 can fire a spurious pointercancel → abort). The root never
+    // unmounts, so the capture — which on Win/mac is what keeps the terminal
+    // pointerup landing on this window once the cursor leaves it — survives.
+    const captureEl = document.documentElement;
     let dragging = false;
 
+    // #42 (main → detached): an open popout of the current scope is a valid drop
+    // target — releasing the dragged tab over one docks it there instead of
+    // spawning a new window. The shared session resolves each popout's physical-px
+    // frame (async), hit-tests the physical cursor against them, and toggles the
+    // popout's drop-target highlight — the SAME logic the file drag uses (FileTree).
+    const detached = startDetachedDropSession();
+
+    // Latest in-window client coords (ghost + "outside this window" test) and the
+    // latest physical desktop cursor (cross-window hit-test, poll-driven).
+    let lastClient = { x: startX, y: startY };
+    let lastPhys: PhysPoint | null = null;
+    let stopPoll: (() => void) | null = null;
+
     const onMove = (ev: PointerEvent) => {
       if (!dragging) {
         if (Math.hypot(ev.clientX - startX, ev.clientY - startY) < 5) return;
@@ -383,168 +712,408 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
           previewW,
           previewH,
         });
+        // Begin resolving popout drop targets now that a real drag is underway.
+        void detached.resolve();
+        // Capture the terminal pointer event on engines that don't keep delivering
+        // it past the source window's HWND (Win/mac); WebKitGTK keeps the implicit
+        // grab, so capturing there is unnecessary (and the flag leaves it off).
+        if (dragPlatform.needsPointerCapture) {
+          try {
+            captureEl.setPointerCapture(pointerId);
+          } catch {
+            /* capture is best-effort; the OS-cursor poll does not depend on it */
+          }
+        }
+        // Poll the OS cursor (physical desktop px) to drive the popout hover past
+        // the main viewport — DOM pointermove may not cross the OS window boundary.
+        stopPoll = startCursorPoll((p) => {
+          lastPhys = p;
+          detached.hover(detached.at(p), p, tab.label);
+        });
       }
+      lastClient = { x: ev.clientX, y: ev.clientY };
       useDragStore.getState().move(ev.clientX, ev.clientY);
     };
-    const onUp = (ev: PointerEvent) => {
+
+    // Tear down the move listener, poll, popout highlight, and pointer capture —
+    // however the gesture resolves.
+    const cleanup = () => {
       window.removeEventListener("pointermove", onMove);
-      window.removeEventListener("pointerup", onUp);
+      stopPoll?.();
+      // Clear the popout highlight + tear down the panes listener. `targetAt`
+      // still hit-tests the cached pane geometry for the commit below.
+      detached.dispose();
+      if (dragPlatform.needsPointerCapture) {
+        try {
+          captureEl.releasePointerCapture(pointerId);
+        } catch {
+          /* ignore */
+        }
+      }
+    };
+
+    const onCommit = async (shiftKey: boolean) => {
+      cleanup();
       if (!dragging) {
-        // Never dragged → this was a click: activate the tab.
-        setGroupActive(groupId, tab.key);
+        // Never dragged → this was a click. Clicking an inactive tab activates
+        // it; clicking the already-active tab enters inline rename (#56 flow).
+        if (tab.key === activeKey) {
+          focusGroup(groupId);
+          setEditingKey(tab.key);
+        } else {
+          setGroupActive(groupId, tab.key);
+        }
         return;
       }
-      // Released OUTSIDE the main window (e.g. dragged onto another monitor): pop
-      // this single tab into its own standalone OS window at the cursor, mirroring
-      // the bar-drag detach (onBarPointerDown). The pointer's implicit capture
-      // keeps delivering coords beyond the viewport, so client coords falling
-      // outside [0,inner) is the outside-the-window signal. screenX/Y place the
-      // new window under the cursor (offset so the grab point lands on its frame).
-      const outside =
-        ev.clientX < 0 ||
-        ev.clientY < 0 ||
-        ev.clientX >= window.innerWidth ||
-        ev.clientY >= window.innerHeight;
-      if (outside) {
+      // Idempotency: if another committer already finished this drag (CenterPanel's
+      // redundant pointerup path on non-WebKitGTK), the store is cleared — do
+      // nothing rather than re-deciding a stale gesture (which could detach a tab
+      // that was just integrated).
+      const d = useDragStore.getState().drag;
+      if (!d) return;
+      // Claim ownership of the gesture SYNCHRONOUSLY, before the `await` below.
+      // On Chromium/WebView2 (Windows) CenterPanel's window listeners DO see the
+      // terminal pointer event and run their own `finish()` synchronously — which,
+      // if the store were still populated during our await, would commit/end the
+      // drag first and swallow the outside-detach / popout-dock decisions made
+      // here. Emptying the store now makes that racing handler bail (its `d` is
+      // null); we proceed using the local `d` snapshot captured above. (On
+      // WebKitGTK only this handler ever fires, so clearing early is a harmless
+      // no-op there. The later `end()` calls become redundant no-ops.)
+      useDragStore.getState().end();
+      // Final physical cursor at release (a fresh read; falls back to the last poll
+      // reading if the IPC fails). Mirrors FileTree: the last poll tick can be up to
+      // ~16 ms stale — or `null` if released before the first tick — which would
+      // otherwise spawn the new window at the (−80,−8) corner.
+      const phys = (await desktopCursor().catch(() => null)) ?? lastPhys;
+      // Pop the dragged tab into its own standalone OS window at the cursor,
+      // mirroring the bar-drag detach (onBarPointerDown). Reused by the Shift
+      // override and the free-space (outside-the-window) release below. The new
+      // window's bounds feed Rust `.position(x,y)`, which is PHYSICAL — so place it
+      // at the physical cursor (the last poll reading), not DOM screen coords.
+      const popToNewWindow = () => {
         const bounds = {
-          x: Math.round(ev.screenX - 80),
-          y: Math.round(ev.screenY - 8),
+          x: Math.round((phys?.x ?? 0) - 80),
+          y: Math.round((phys?.y ?? 0) - 8),
           w: 900,
           h: 640,
         };
-        // Send-off animation: play a fly-out toward the edge the tab exited
-        // through before the drag state (and its ghost) tears down.
-        const d = useDragStore.getState().drag;
-        playDetachFlyOut(ev.clientX, ev.clientY, tab.label, d?.previewW, d?.previewH);
+        // Send-off animation toward the edge the tab exited through, before the
+        // drag state (and its ghost) tears down.
+        playDetachFlyOut(lastClient.x, lastClient.y, tab.label, d.previewW, d.previewH);
         detachTab(tab.key, bounds);
         useDragStore.getState().end();
+      };
+      // Shift ALWAYS pops a new window — overriding both docking into a popout and
+      // integrating into a background subwindow. (May spawn the new window over a
+      // popout the cursor happens to be on; that's the intended "always new".)
+      if (shiftKey) {
+        popToNewWindow();
         return;
       }
-      // A drag did start: commit the drop HERE. This handler is bound inside the
-      // pointerdown handler — i.e. before the gesture's implicit pointer capture
-      // begins — so on WebKitGTK it is the ONLY release handler that reliably
-      // fires. CenterPanel's window listeners are added mid-gesture (after the
-      // `start()` → React re-render) and, on WebKitGTK, receive pointermove but
-      // never the terminal pointerup, so they cannot be the committer. The
-      // target was already resolved into the drag store by CenterPanel's
-      // pointermove handler during the drag, so commit it verbatim. If
-      // CenterPanel's pointerup DID fire first (other platforms), it already
-      // committed + ended, so we see drag=null and no-op — no double-commit.
-      const d = useDragStore.getState().drag;
-      if (d != null) {
-        commitDrop(d);
+      // #42: released over an existing popout → dock the tab straight into it (no
+      // new window). Hit-tested at the final physical cursor so it reflects exactly
+      // where the cursor ended. The popout's panes attach-only to PTYs the main
+      // keeps mounted, so the tab's terminal survives the move.
+      //
+      // But `detached.at()` is a PURE GEOMETRIC AABB against the popout's OUTER rect —
+      // it matches a popout even when it sits BEHIND the main window at the same screen
+      // coords (the press that started this drag raised the main window). Docking into
+      // a popout the user can't see — while the split preview showed in the visible
+      // main window — is exactly the reported bug. So confirm the popout is actually
+      // FRONTMOST under the cursor before docking; an occluded one falls through to the
+      // in-window integration below, so the visible main window always wins. Mirrors
+      // FileTree's file-drag path (`detached_window_frontmost`).
+      const overDetached = phys ? detached.at(phys) : null;
+      const overFrontDetached =
+        overDetached &&
+        (await invoke<boolean>("detached_window_frontmost", {
+          registryId: overDetached.label,
+        }).catch(() => true));
+      if (overDetached && overFrontDetached && phys) {
+        // Dock into the SPECIFIC pane under the cursor (a body edge splits, a bar
+        // merges) — resolved synchronously at the release coords, so no stale
+        // cross-window cache and never always-the-first-pane.
+        useTabsStore
+          .getState()
+          .dockTabIntoDetached(
+            overDetached.scope,
+            overDetached.groupId,
+            tab.key,
+            detached.targetAt(overDetached, phys),
+          );
+        // Re-seed the popout so it renders the newly-docked tab, tagged so it
+        // plays the drop-in landing for this cross-window merge (mirrors the
+        // dock-BACK re-seed in CenterPanel's DETACHED_DRAG_END handler).
+        reseedDetached(overDetached.scope, overDetached.groupId, tab.key);
+        // Send-off animation toward the edge the tab exited through.
+        playDetachFlyOut(lastClient.x, lastClient.y, tab.label, d.previewW, d.previewH);
         useDragStore.getState().end();
+        return;
+      }
+      // Released in FREE SPACE — outside the main window and not over a FRONT popout,
+      // so no visible Eldrun window is under the cursor (e.g. dragged onto the desktop
+      // or another monitor). Pop this tab into its own standalone OS window. Client
+      // coords outside [0,inner) is the outside-the-window signal (DOM clientX/Y is
+      // reliable CSS px on every engine). An OCCLUDED popout is deliberately NOT
+      // "outside" here: the main window is what's actually under the cursor, so the
+      // release falls through to the in-window integration below.
+      const outside =
+        lastClient.x < 0 ||
+        lastClient.y < 0 ||
+        lastClient.x >= window.innerWidth ||
+        lastClient.y >= window.innerHeight;
+      if (outside) {
+        popToNewWindow();
+        return;
       }
+      // Released over THIS main window without Shift → integrate into the
+      // background subwindow under the cursor. `bindDragRelease` binds the terminal
+      // listeners synchronously at pointerdown — i.e. before the gesture's pointer
+      // capture begins — so on WebKitGTK it is the ONLY release handler that
+      // reliably fires. CenterPanel's window listeners are added mid-gesture (after
+      // the `start()` → React re-render) and, on WebKitGTK, receive pointermove but
+      // never the terminal pointerup, so they cannot be the committer. The target
+      // was already resolved into the drag store by CenterPanel's pointermove
+      // handler during the drag, so commit it verbatim. A null target (chrome /
+      // split divider) is a no-op — the tab stays put. If CenterPanel's pointerup
+      // DID fire first (other platforms), it already committed + ended, so the
+      // top-of-handler guard already returned — no double-commit.
+      commitDrop(d);
+      useDragStore.getState().end();
+    };
+
+    // Escape / blur / a genuine pointercancel (Win/mac) aborts: tear down and drop
+    // any in-flight drag without committing.
+    const onAbort = () => {
+      cleanup();
+      if (dragging) useDragStore.getState().end();
     };
+
     window.addEventListener("pointermove", onMove);
-    window.addEventListener("pointerup", onUp);
+    bindDragRelease({ onCommit: (shiftKey) => void onCommit(shiftKey), onAbort });
   }
 
-  // #42: grab the subwindow's top frame (the empty tab-bar area) and drag it out
-  // to pop the group into its own OS window — replacing the old ⧉ button. Focuses
-  // immediately on press; once the pointer crosses a small threshold the group
-  // detaches at the cursor and the window manager takes over the move
-  // (`startDragging`), so the popout follows the cursor natively until release.
+  // #42: drag the left-edge grip to pop the group into its own OS window. Focuses
+  // on press; once the pointer crosses a small threshold a lightweight follow-ghost
+  // appears (a DOM card — no per-frame IPC, so it tracks the cursor smoothly) and
+  // the real detached OS window is created only on RELEASE, positioned where the
+  // group is dropped. This replaces the old "spawn immediately, then hand the move
+  // to the WM via `startDragging`" path, whose fragile grab after a heavy async
+  // window spawn made the detach lag and often required a SECOND drag to move the
+  // new window. Only the explicit `.tab-drag-grip` triggers this — grabbing empty
+  // bar space can't accidentally pop a subwindow out.
   function onBarPointerDown(e: React.PointerEvent) {
     focusGroup(groupId);
     if (e.button !== 0) return;
-    // Only the empty bar area is a detach handle — not tabs, the +/close
-    // controls, or an inline rename input.
     const target = e.target as HTMLElement;
-    if (target.closest(".tab, .tab-new-wrap, button, .tab-label-edit")) return;
+    if (!target.closest(".tab-drag-grip")) return;
     e.preventDefault();
     const startX = e.clientX;
     const startY = e.clientY;
-    let detaching = false;
+    const pointerId = e.pointerId;
+    const activeLabel = tabs.find((t) => t.key === activeKey)?.label ?? "Subwindow";
+    // Capture on the document root (not this bar): detaching removes the group's
+    // node from the layout, so a capture anchored here would drop mid-gesture.
+    const captureEl = document.documentElement;
+    let dragging = false;
+    let ghost: HTMLElement | null = null;
+    let lastClient = { x: startX, y: startY };
+    let lastPhys: PhysPoint | null = null;
+    let stopPoll: (() => void) | null = null;
+
+    const onMove = (ev: PointerEvent) => {
+      if (!dragging) {
+        if (Math.hypot(ev.clientX - startX, ev.clientY - startY) < 8) return;
+        dragging = true;
+        // Build the follow-ghost (reuses the drag-ghost styling: fixed, z-topped,
+        // pointer-events:none). No OS window yet — it is spawned on release.
+        ghost = document.createElement("div");
+        ghost.className = "tab-drag-ghost";
+        const lbl = document.createElement("div");
+        lbl.className = "tab-drag-ghost-label";
+        lbl.textContent = activeLabel;
+        ghost.appendChild(lbl);
+        ghost.style.left = `${ev.clientX}px`;
+        ghost.style.top = `${ev.clientY}px`;
+        document.body.appendChild(ghost);
+        // Capture the terminal pointer event on engines that stop delivering it
+        // once the cursor leaves the source window (Win/mac); WebKitGTK keeps the
+        // implicit grab, so the flag leaves capture off there.
+        if (dragPlatform.needsPointerCapture) {
+          try {
+            captureEl.setPointerCapture(pointerId);
+          } catch {
+            /* best-effort */
+          }
+        }
+        // Poll the OS cursor (physical px) so the drop position is DPI-correct and
+        // available even after the pointer leaves the main viewport.
+        stopPoll = startCursorPoll((p) => {
+          lastPhys = p;
+        });
+      }
+      lastClient = { x: ev.clientX, y: ev.clientY };
+      if (ghost) {
+        ghost.style.left = `${ev.clientX}px`;
+        ghost.style.top = `${ev.clientY}px`;
+      }
+    };
 
     const cleanup = () => {
       window.removeEventListener("pointermove", onMove);
-      window.removeEventListener("pointerup", onUp);
+      stopPoll?.();
+      if (ghost && ghost.parentNode) ghost.parentNode.removeChild(ghost);
+      ghost = null;
+      if (dragPlatform.needsPointerCapture) {
+        try {
+          captureEl.releasePointerCapture(pointerId);
+        } catch {
+          /* ignore */
+        }
+      }
     };
-    const onMove = (ev: PointerEvent) => {
-      if (detaching) return;
-      if (Math.hypot(ev.clientX - startX, ev.clientY - startY) < 8) return;
-      detaching = true;
+
+    const onCommit = async () => {
       cleanup();
-      // Spawn the popout under the cursor (offset so the grab point lands on its
-      // top frame), then hand the move to the WM via startDragging — the still-
-      // pressed pointer drives a native window move until release.
+      if (!dragging) return; // a click on the grip (no drag) → nothing to detach.
+      // Final physical cursor at release (fresh read; fall back to the last poll
+      // tick). Bounds feed Rust `.position(x,y)` (PHYSICAL) — offset so the grab
+      // point lands on the new window's top frame.
+      const phys = (await desktopCursor().catch(() => null)) ?? lastPhys;
       const bounds = {
-        x: Math.round(ev.screenX - 80),
-        y: Math.round(ev.screenY - 8),
+        x: Math.round((phys?.x ?? 0) - 80),
+        y: Math.round((phys?.y ?? 0) - 8),
         w: 900,
         h: 640,
       };
-      const label = detachGroup(groupId, { bounds });
-      if (!label) return; // lone group can't detach — abort quietly.
-      // Send-off animation at the grab point, flying toward the exit edge.
-      const activeLabel = tabs.find((t) => t.key === activeKey)?.label;
-      playDetachFlyOut(ev.clientX, ev.clientY, activeLabel ?? "Subwindow");
-      WebviewWindow.getByLabel(label)
-        .then((w) => w?.startDragging())
-        .catch(() => {});
+      // Send-off animation at the grab point, then create the OS window at the drop
+      // (no `startDragging`: the window appears already positioned, so there is no
+      // handoff to miss and no second drag needed). `detachGroup` refuses a lone
+      // group (returns null) — a harmless no-op here.
+      playDetachFlyOut(lastClient.x, lastClient.y, activeLabel);
+      detachGroup(groupId, { bounds });
     };
-    const onUp = () => cleanup();
+
+    const onAbort = () => cleanup();
+
     window.addEventListener("pointermove", onMove);
-    window.addEventListener("pointerup", onUp);
+    bindDragRelease({ onCommit: () => void onCommit(), onAbort });
   }
 
+  // This bar is the live drop target of an in-flight drag: light up the whole
+  // bar and render a placeholder slot at the insertion point.
+  const isDropTarget = reorderGroup === groupId && reorderIndex != null;
+  const dropPlaceholder = <TabDropPlaceholder label={dragLabel} />;
+
   return (
-    <div className="tab-bar" data-group-id={groupId} onPointerDown={onBarPointerDown}>
+    <div
+      className={`tab-bar${isDropTarget ? " drop-target" : ""}`}
+      data-group-id={groupId}
+      onPointerDown={onBarPointerDown}
+    >
+      {/* Explicit detach grip — the sole handle for popping this subwindow out.
+          Always pinned at the far left (outside the scrolling strip) so it stays
+          grabbable no matter how many tabs fill the bar. A plain (non-button)
+          element, so its pointerdown bubbles to `onBarPointerDown`, which now
+          fires only when the grip is the target. */}
+      <div
+        className="tab-drag-grip"
+        title="Drag to pop this subwindow into its own window"
+        aria-hidden="true"
+      >
+        ⠿
+      </div>
       {canScrollLeft && (
         <button
           className="tab-scroll-btn left"
           title="Scroll tabs left"
           // Keep the chevron out of the bar's detach-drag and tab pointer flow.
           onPointerDown={(e) => e.stopPropagation()}
+          onMouseEnter={() => startHoverScroll(-1)}
+          onMouseLeave={stopHoverScroll}
           onClick={() => scrollStrip(-1)}
         >
           ‹
         </button>
       )}
       <div className="tab-strip" ref={stripRef} onWheel={onStripWheel}>
+      {/* Empty bar that's a drop target: the placeholder is the only slot. */}
+      {isDropTarget && tabs.length === 0 && (
+        <Fragment key="drop-marker">{dropPlaceholder}</Fragment>
+      )}
       {tabs.map((tab, index) => {
         const isActive = tab.key === activeKey;
         const isDragging = dragKey === tab.key;
-        const isLast = index === tabs.length - 1;
-        // Files tabs have no PTY, so they never register output activity.
-        const working = tab.kind !== "files" && !!busyByTab[tab.key];
-        // Open the gap by sliding the neighbouring tab away from the slot. A
-        // dragging tab is collapsed to nothing, so it never carries a gap.
-        const style: React.CSSProperties = isActive
-          ? { boxShadow: `inset 0 3px 0 ${TAB_ACCENT[tab.kind]}` }
-          : {};
-        if (!isDragging && reorderGroup === groupId) {
-          if (reorderIndex === index) style.marginLeft = REORDER_GAP;
-          if (isLast && reorderIndex === tabs.length) style.marginRight = REORDER_GAP;
-        }
-        // Agent tabs launched with a deterministic session id show it on hover.
-        // This is the launch id (`--session-id <uuid>`): stable and unique per
-        // tab. It does NOT follow a `/clear` (which rolls onto a new id) — that
-        // needs a different mechanism, see TODO #39c.
-        const title = tab.sessionId
-          ? `${tab.label} session\n${tab.sessionId}\ncwd: ${tab.cwd}`
-          : undefined;
+        // The placeholder slot previewing where the dragged tab will land — shown
+        // immediately before the tab occupying the resolved insertion index.
+        const showMarkerBefore = isDropTarget && reorderIndex === index;
+        // Whole-tab status glow (no dot, no width change):
+        //  - working (green pulse): PTY producing sustained output.
+        //  - needs-decision (orange pulse): an agent went quiet with a
+        //    choice/permission prompt on its screen.
+        //  - finished (green steady): an agent you're not looking at went quiet
+        //    with no prompt — its turn is done and its result is unread.
+        // Working wins. Working and finished are about output you HAVEN'T seen, so
+        // they never show on the viewed tab — its screen says it better. A pending
+        // decision is the exception: it's about an agent that is BLOCKED, and it
+        // stays blocked whether or not you're looking at it. The lamp holds until
+        // the prompt is answered, so a tab left on screen mid-prompt while you work
+        // elsewhere in the window still says so.
+        const ptyId = `${scope}:${tab.key}`;
+        const working = isPtyTabKind(tab.kind) && !isActive && !!busyByTab[ptyId];
+        const rawAttn =
+          tab.kind === "agent" || tab.kind === "local_agent"
+            ? attentionByTab[ptyId] ?? null
+            : null;
+        const attn = !isActive || rawAttn === "decision" ? rawAttn : null;
+        const stateClass = working
+          ? " working"
+          : attn === "decision"
+            ? " needs-decision"
+            : attn === "done"
+              ? " finished"
+              : "";
+        // Expose the kind colour to CSS on every tab (not just the active one)
+        // so the top stripe reads as the tab-group colour consistently — plain
+        // themes draw the rail above, fancy themes move it below. Inactive tabs
+        // keep a transparent stripe slot; hover/active tint it with this colour.
+        const style = { "--tab-accent": TAB_ACCENT[tab.kind] } as React.CSSProperties;
         const editing = editingKey === tab.key;
+        // A tab freshly dropped into this bar plays the drop-in landing once.
+        const landing = !isDragging && landedKey === tab.key;
         return (
+          <Fragment key={tab.key}>
+          {showMarkerBefore && dropPlaceholder}
           <div
-            key={tab.key}
-            className={`tab ${isActive ? "active" : ""}${working ? " working" : ""}${isDragging ? " dragging" : ""}${editing ? " editing" : ""}`}
+            className={`tab ${isActive ? "active" : ""}${stateClass}${isDragging ? " dragging" : ""}${editing ? " editing" : ""}${landing ? " landing" : ""}`}
             style={style}
             data-tab-index={index}
-            title={editing ? undefined : title}
-            onContextMenu={(e) => startInlineRename(e, tab.key)}
+            data-kind={tab.kind}
+            onContextMenu={(e) => onTabContextMenu(e, tab.key, index)}
             onPointerDown={(e) => onTabPointerDown(e, tab)}
+            // Styled hover card (mirrors the project pill's popup) anchored to
+            // this tab's bottom-center. Skipped while inline-renaming.
+            onMouseEnter={(e) => {
+              if (editing) return;
+              const r = e.currentTarget.getBoundingClientRect();
+              setHoverTab({ key: tab.key, x: r.left + r.width / 2, y: r.bottom });
+            }}
+            onMouseLeave={() =>
+              setHoverTab((h) => (h?.key === tab.key ? null : h))
+            }
+            // Clear the landing once it finishes so the class doesn't linger
+            // (guard on currentTarget so a child's animationend never clears it
+            // early; the status glow is an infinite ::after animation and emits
+            // no animationend).
+            onAnimationEnd={
+              landing
+                ? (e) => {
+                    if (e.target === e.currentTarget) clearLanded(landedNonce);
+                  }
+                : undefined
+            }
           >
-            {working && (
-              <span
-                className="tab-working"
-                style={{ color: TAB_ACCENT[tab.kind] }}
-                title="Working…"
-              >
-                <OrbitSpinner className="tab-working-spinner" />
-              </span>
-            )}
             {editing ? (
               <input
                 className="tab-label-edit"
@@ -571,130 +1140,376 @@ export function TabBar({ groupId, projectCwd, showGroupClose }: Props) {
             ) : (
               <span className="tab-label">{tab.label}</span>
             )}
+            {/* Viewer file-source badge — remote-native (host SFTP) vs local
+                mirror, a clickable toggle when the file exists on both sides.
+                Shared with the detached strip (see TabLocalityBadges). */}
+            <TabSourceBadge tabKey={tab.key} />
+            {/* Planner/doer badge (experimental, off by default) — click to switch
+                the agent between Plan and Auto. Only for agents that can actually
+                be launched into a mode AND resume on the respawn that costs (see
+                agentModes.ts); every other agent tab is untouched. */}
+            {agentModeToggle && supportsAgentMode(tab.cmd) && (() => {
+              const mode = tab.agentMode;
+              const title =
+                mode === "plan"
+                  ? "Plan: reads and proposes, never edits — click to switch to Auto"
+                  : mode === "auto"
+                    ? "Auto: auto-accepts edits (shell/network still ask) — click to switch to Plan"
+                    : "Agent default: asks before each action — click to switch to Plan";
+              return (
+                <button
+                  className={`tab-agent-mode ${mode ?? "unset"}`}
+                  title={`${title}. Switching restarts the agent; the conversation is resumed.`}
+                  onPointerDown={(e) => e.stopPropagation()}
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    handleAgentMode(tab.key, ptyId, mode);
+                  }}
+                >
+                  {mode === "plan" ? "⏸" : mode === "auto" ? "⚡" : "◇"}
+                </button>
+              );
+            })()}
+            {/* Locality badge — click to choose where this agent/shell tab runs:
+                the local mirror, the primary host, or (multi-host remote,
+                docs/multi_host_remote_plan.md) any worker machine. Only shown for
+                a remote project's locatable tabs. Shared with the detached strip. */}
+            {isRemoteScope && (
+              <TabLocalityBadge
+                tab={tab}
+                primaryHost={primaryHost}
+                computeHosts={computeHosts}
+                onOpen={(r, startOnMachines) =>
+                  setLocalityMenu({
+                    key: tab.key,
+                    x: r.left,
+                    y: r.bottom + 2,
+                    view: startOnMachines ? "machines" : "root",
+                  })
+                }
+              />
+            )}
             <button
               className="tab-close"
-              onClick={(e) => { e.stopPropagation(); removeTab(tab.key); }}
+              onClick={(e) => { e.stopPropagation(); closeTabWithConfirm(tab.key); }}
               title="Close tab"
             >
               ×
             </button>
           </div>
+          </Fragment>
         );
       })}
-      </div>
-      {canScrollRight && (
-        <button
-          className="tab-scroll-btn right"
-          title="Scroll tabs right"
-          onPointerDown={(e) => e.stopPropagation()}
-          onClick={() => scrollStrip(1)}
-        >
-          ›
-        </button>
+      {/* Insertion at the end of the bar (slot === tab count). */}
+      {isDropTarget && reorderIndex === tabs.length && tabs.length > 0 && (
+        <Fragment key="drop-marker-end">{dropPlaceholder}</Fragment>
       )}
       <div className="tab-new-wrap">
         <button
           ref={addBtnRef}
-          className="tab-new-btn"
+          // When this group has no tabs, the + is the only way to get started —
+          // pulse it to draw the eye to it.
+          className={`tab-new-btn${tabs.length === 0 ? " empty-hint" : ""}`}
+          data-hint-anchor="tab-add"
           title="New tab"
           onClick={openAddMenu}
         >
           +
         </button>
       </div>
-      {showGroupClose && (
+      </div>
+      {canScrollRight && (
         <button
-          className="subwindow-close"
-          title="Close subwindow"
-          // Stop the bar's onMouseDown focusGroup from running first (it isn't
-          // harmful, but keeping the close interaction self-contained avoids any
-          // focus/state churn racing the click) and ensure the click itself
-          // isn't bubbled into a tab/pointer handler.
-          onMouseDown={(e) => e.stopPropagation()}
-          onClick={(e) => { e.stopPropagation(); closeGroup(groupId); }}
+          className="tab-scroll-btn right"
+          title="Scroll tabs right"
+          onPointerDown={(e) => e.stopPropagation()}
+          onMouseEnter={() => startHoverScroll(1)}
+          onMouseLeave={stopHoverScroll}
+          onClick={() => scrollStrip(1)}
         >
-          ×
+          ›
         </button>
       )}
+      {/* The subwindow controls stay pinned at the far right of the bar. When a
+          file viewer is docked below, this cluster reserves the viewer's width
+          (`filesReserveWidth`) and right-aligns within it, so it sits directly
+          above the viewer while the scrolling tab strip stops at the pane edge. */}
+      <div
+        className="tab-controls"
+        style={filesReserveWidth != null ? { width: filesReserveWidth } : undefined}
+      >
+        {groupId !== EMPTY_GROUP_ID && (
+          <button
+            className={`subwindow-files-toggle${filesOpen ? " open" : ""}`}
+            title={filesOpen ? "Close this subwindow's file viewer" : "Open a file viewer in this subwindow"}
+            // Same self-contained interaction discipline as the hide/close buttons:
+            // stop the bar's focusGroup mousedown and don't let the click bubble.
+            onMouseDown={(e) => e.stopPropagation()}
+            onClick={(e) => { e.stopPropagation(); setGroupFiles(groupId, !filesOpen); }}
+          >
+            ◫
+          </button>
+        )}
+        {groupId !== EMPTY_GROUP_ID && (
+          <button
+            className="subwindow-hide"
+            title="Hide subwindow (bring it back from the right panel)"
+            // Same self-contained interaction discipline as the close button below:
+            // stop the bar's focusGroup mousedown and don't let the click bubble.
+            onMouseDown={(e) => e.stopPropagation()}
+            onClick={(e) => { e.stopPropagation(); hideGroup(groupId); }}
+          >
+            –
+          </button>
+        )}
+        {showGroupClose && (
+          <button
+            className="subwindow-close"
+            title="Close subwindow"
+            // Stop the bar's onMouseDown focusGroup from running first (it isn't
+            // harmful, but keeping the close interaction self-contained avoids any
+            // focus/state churn racing the click) and ensure the click itself
+            // isn't bubbled into a tab/pointer handler.
+            onMouseDown={(e) => e.stopPropagation()}
+            onClick={(e) => { e.stopPropagation(); closeGroup(groupId); }}
+          >
+            ×
+          </button>
+        )}
+      </div>
       {menuOpen && menuPos && createPortal(
         <div
           className="tab-new-menu"
           ref={addMenuRef}
           style={{ position: "fixed", left: menuPos.x, top: menuPos.y }}
         >
-          <div className="tab-new-menu-group-label">Agents</div>
-          {AGENT_ITEMS.map((item) => (
-            <button
-              key={item.cmd}
-              className="tab-new-menu-item"
-              onClick={() => handleAdd(item)}
-            >
-              <span className="tab-new-menu-dot" style={{ color: TAB_ACCENT[item.kind] }}>●</span>
-              {item.label}
-            </button>
-          ))}
-
-          <div className="tab-new-menu-group-label">Local Agents</div>
-          {ollamaLoading && (
-            <div className="tab-new-menu-hint">Loading…</div>
-          )}
-          {!ollamaLoading && ollamaError && (
-            <div className="tab-new-menu-hint">{ollamaError}</div>
-          )}
-          {!ollamaLoading && !ollamaError && ollamaModels.length === 0 && (
-            <div className="tab-new-menu-hint">No Ollama models found</div>
-          )}
-          {!ollamaLoading && ollamaModels.map((model) => (
-            <button
-              key={model}
-              className="tab-new-menu-item"
-              onClick={() => handleOllamaModel(model)}
-            >
-              <span className="tab-new-menu-dot" style={{ color: TAB_ACCENT["local_agent"] }}>●</span>
-              {model}
-            </button>
-          ))}
-
-          <div className="tab-new-menu-group-label">Shell</div>
-          {SHELL_ITEMS.filter((i) => i.kind === "shell").map((item) => (
-            <button
-              key={item.cmd}
-              className="tab-new-menu-item"
-              onClick={() => handleAdd(item)}
-            >
-              <span className="tab-new-menu-dot" style={{ color: TAB_ACCENT[item.kind] }}>●</span>
-              {item.label}
-            </button>
-          ))}
-
-          <div className="tab-new-menu-group-label">Files</div>
-          {SHELL_ITEMS.filter((i) => i.kind === "files").map((item) => (
-            <button
-              key={item.cmd}
-              className="tab-new-menu-item"
-              disabled={!projectCwd}
-              onClick={() => handleAdd(item)}
-            >
-              <span className="tab-new-menu-dot" style={{ color: TAB_ACCENT[item.kind] }}>●</span>
-              {item.label}
-            </button>
-          ))}
-
-          <div className="tab-new-menu-group-label">Project</div>
+          <AddTabMenuList
+            groups={[
+              {
+                label: "Agents",
+                entries: agentMenuEntries({
+                  installedBuiltins: enabledAgents,
+                  installedCmds: installedCustom,
+                  customAgents,
+                  pick: handleAdd,
+                  onAddCustom: () => {
+                    setMenuPos(null);
+                    setAgentDialogOpen(true);
+                  },
+                }),
+              },
+              // Only offer agents whose binary is actually installed: Mistral/vibe
+              // (checked against `installedAgents`) and the drivers the backend
+              // already marks `available` (which now includes an installed check).
+              {
+                label: localModel ? `Local Model · ${localModel}` : "Local Model",
+                entries: localModel
+                  ? [
+                      // Mistral/vibe keeps its bespoke per-model VIBE_HOME path.
+                      ...(enabledAgents?.has("vibe")
+                        ? [{
+                            key: "vibe",
+                            label: "Mistral",
+                            color: TAB_ACCENT["local_agent"],
+                            onPick: () => void handleOllamaModel(localModel),
+                          }]
+                        : []),
+                      // Other agents drive the same model via `ollama launch` / fallback.
+                      ...localDrivers.filter((d) => d.available).map((d) => ({
+                        key: d.id,
+                        label: d.label,
+                        color: TAB_ACCENT["local_agent"],
+                        onPick: () => void handleLocalLaunch(d.id, d.label, localModel),
+                      })),
+                    ]
+                  : [],
+                hint: localModel
+                  ? "No local agent installed — install one in the 🧠 menu"
+                  : "No local model set — pick one in the app bar",
+              },
+              {
+                label: "Shell",
+                entries: SHELL_ITEMS.filter((i) => i.kind === "shell").map((item) => ({
+                  key: item.cmd || "shell",
+                  label: item.label,
+                  color: TAB_ACCENT[item.kind],
+                  onPick: () => handleAdd(item),
+                })),
+              },
+              {
+                label: "Files",
+                entries: SHELL_ITEMS.filter((i) => isFileTabKind(i.kind)).map((item) => ({
+                  key: item.cmd,
+                  label: item.label,
+                  color: TAB_ACCENT[item.kind],
+                  disabled: !projectCwd,
+                  onPick: () => handleAdd(item),
+                })),
+              },
+              // System Monitor is whole-machine and Disk Usage picks its own scan
+              // root, so both are offered in every scope; Network Traffic is
+              // per-project (host/SSH link), so root has none.
+              {
+                label: "Monitoring",
+                entries: [
+                  {
+                    key: "monitor",
+                    label: "System Monitor",
+                    color: TAB_ACCENT.monitor,
+                    onPick: handleAddMonitor,
+                  },
+                  {
+                    key: "diskusage",
+                    label: "Disk Usage",
+                    dot: "◕",
+                    color: TAB_ACCENT.diskusage,
+                    onPick: handleAddDiskUsage,
+                  },
+                  ...(scope !== "root"
+                    ? [{
+                        key: "network",
+                        label: "Network Traffic",
+                        color: TAB_ACCENT.network,
+                        onPick: handleAddNetwork,
+                      }]
+                    : []),
+                ],
+              },
+              ...(showBlobItem
+                ? [{
+                    label: "Workspace",
+                    entries: [{
+                      key: "blob",
+                      label: "Projects (3D)",
+                      dot: "◍",
+                      color: TAB_ACCENT["projects3d"],
+                      onPick: handleAddBlob,
+                    }],
+                  }]
+                : []),
+              {
+                label: "Calendar",
+                entries: [{
+                  key: "calendar",
+                  label: "Calendar",
+                  dot: "◆",
+                  color: TAB_ACCENT.calendar,
+                  onPick: handleAddCalendar,
+                }],
+              },
+              {
+                label: "Project",
+                entries: [{
+                  key: "close-all",
+                  label: "Close all tabs",
+                  dot: "×",
+                  color: "var(--danger, #d9534f)",
+                  disabled: !hasAnyTabs,
+                  onPick: () => {
+                    closeAllTabs();
+                    setMenuPos(null);
+                  },
+                }],
+              },
+            ]}
+          />
+        </div>,
+        document.body,
+      )}
+      {agentDialogOpen && (
+        <CustomAgentDialog onClose={() => setAgentDialogOpen(false)} />
+      )}
+      {localityMenu && (
+        <LocalityMenu
+          menu={localityMenu}
+          current={tabLocation(tabs.find((t) => t.key === localityMenu.key))}
+          primaryHost={primaryHost}
+          computeHosts={computeHosts}
+          onClose={() => setLocalityMenu(null)}
+          onChangeView={(view) => setLocalityMenu((m) => (m ? { ...m, view } : m))}
+          onChoose={(key, loc) => setTabLocation(key, loc)}
+        />
+      )}
+      {tabMenu && createPortal(
+        <div
+          className="tab-new-menu"
+          ref={tabMenuRef}
+          style={{ position: "fixed", left: tabMenu.x, top: tabMenu.y }}
+        >
+          <button
+            className="tab-new-menu-item"
+            onClick={() => {
+              setEditingKey(tabMenu.key);
+              setTabMenu(null);
+            }}
+          >
+            <span className="tab-new-menu-dot" style={{ color: "var(--accent)" }}>✎</span>
+            Rename
+          </button>
+          <button
+            className="tab-new-menu-item"
+            onClick={() => {
+              closeTabWithConfirm(tabMenu.key);
+              setTabMenu(null);
+            }}
+          >
+            <span className="tab-new-menu-dot" style={{ color: "var(--danger, #d9534f)" }}>×</span>
+            Close
+          </button>
           <button
             className="tab-new-menu-item"
-            disabled={!hasAnyTabs}
+            disabled={tabs.length <= 1}
             onClick={() => {
-              closeAllTabs();
-              setMenuPos(null);
+              closeOthers(tabMenu.key);
+              setTabMenu(null);
             }}
           >
             <span className="tab-new-menu-dot" style={{ color: "var(--danger, #d9534f)" }}>×</span>
-            Close all tabs
+            Close others
+          </button>
+          <button
+            className="tab-new-menu-item"
+            disabled={tabMenu.index === 0}
+            onClick={() => {
+              closeToLeft(tabMenu.index);
+              setTabMenu(null);
+            }}
+          >
+            <span className="tab-new-menu-dot" style={{ color: "var(--danger, #d9534f)" }}>×</span>
+            Close to the left
+          </button>
+          <button
+            className="tab-new-menu-item"
+            disabled={tabMenu.index === tabs.length - 1}
+            onClick={() => {
+              closeToRight(tabMenu.index);
+              setTabMenu(null);
+            }}
+          >
+            <span className="tab-new-menu-dot" style={{ color: "var(--danger, #d9534f)" }}>×</span>
+            Close to the right
           </button>
         </div>,
         document.body,
       )}
+      {/* Styled tab hover card (matches the project pill popup). Suppressed
+          mid-drag and while a menu is open so it never overlaps them. The card
+          derives its own content from the tab + this window's stores. */}
+      {hoverTab && dragKey === null && !menuOpen && !tabMenu && (() => {
+        const tab = tabs.find((t) => t.key === hoverTab.key);
+        if (!tab) return null;
+        return (
+          <TabHoverCard
+            tab={tab}
+            scope={scope}
+            isRemote={isRemoteScope}
+            primaryHost={primaryHost}
+            computeHosts={computeHosts}
+            anchorX={hoverTab.x}
+            anchorY={hoverTab.y}
+          />
+        );
+      })()}
     </div>
   );
 }
diff --git a/src/components/tabs/TabDropPlaceholder.tsx b/src/components/tabs/TabDropPlaceholder.tsx
new file mode 100644
index 0000000..260ceb8
--- /dev/null
+++ b/src/components/tabs/TabDropPlaceholder.tsx
@@ -0,0 +1,15 @@
+/**
+ * The dashed accent slot previewing where a dragged tab will land, rendered in a
+ * tab bar at the resolved insertion index. Shared by the main-window `TabBar` and
+ * the detached popout's tab bar (`DetachedCenterPanel`) so the merge/reorder drop
+ * preview — the `.drop-target` bar wash plus this spring-opening slot — is byte
+ * for byte identical in both. Sized like a tab so the surrounding tabs slide to
+ * make exactly the room the dragged tab will occupy.
+ */
+export function TabDropPlaceholder({ label }: { label: string }) {
+  return (
+    <div className="tab tab-drop-placeholder" aria-hidden="true">
+      <span className="tab-drop-placeholder-label">{label || "New tab"}</span>
+    </div>
+  );
+}
diff --git a/src/components/tabs/TabHoverCard.tsx b/src/components/tabs/TabHoverCard.tsx
new file mode 100644
index 0000000..539b5c5
--- /dev/null
+++ b/src/components/tabs/TabHoverCard.tsx
@@ -0,0 +1,256 @@
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import {
+  effectiveTabLocation,
+  isLocatableKind,
+  isPtyTabKind,
+  isResumableAgentTab,
+  localityHostLabel,
+  remoteHostIdOf,
+  type LocalityHost,
+  type TabEntry,
+  type TabKind,
+} from "../../stores/tabs";
+import { lastPtyOutputAt, useActivityStore } from "../../stores/activity";
+import { useAgentTaskStore } from "../../stores/agentTask";
+import { useFileSourcesStore } from "../../stores/fileSources";
+import type { InternalViewer } from "../../lib/viewers/fileUtils";
+import { TAB_ACCENT } from "./newTabItems";
+
+/** Friendly, human-readable name for a tab kind, shown as the card's muted
+ *  sub-line. Falls back to the raw kind for anything unmapped. */
+const KIND_LABEL: Record<TabKind, string> = {
+  agent: "AI agent",
+  local_agent: "Local agent",
+  shell: "Shell",
+  files: "Files",
+  projectfiles: "Files (Project)",
+  embed: "Embedded app",
+  projects3d: "Projects (3D)",
+  network: "Network traffic",
+  monitor: "System monitor",
+  diskusage: "Disk usage",
+  calendar: "Calendar",
+};
+
+/** Which built-in viewer a file tab renders in — "Embedded app" says nothing
+ *  exactly where the card is most used, six viewer tabs deep. */
+const VIEWER_LABEL: Record<InternalViewer, string> = {
+  pdf: "PDF viewer",
+  image: "Image viewer",
+  gif: "GIF viewer",
+  markdown: "Markdown viewer",
+  text: "Text editor",
+  tex: "TeX editor",
+  table: "Table viewer",
+  notebook: "Notebook viewer",
+  diff: "Diff viewer",
+  syncdiff: "Sync diff",
+  syncmerge: "Sync merge",
+  odt: "Document viewer",
+  media: "Media player",
+  html: "HTML viewer",
+  sqlite: "SQLite browser",
+  yaml: "YAML/JSON editor",
+  eldeck: "Presentation",
+};
+
+/** Gap between the tab and the card, and the keep-inside-the-window margin. */
+const GAP = 6;
+const MARGIN = 8;
+
+/** "5 s" / "12 min" / "2 h 05 min" — the quiet-time readout. */
+function formatQuiet(ms: number): string {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s} s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m} min`;
+  return `${Math.floor(m / 60)} h ${String(m % 60).padStart(2, "0")} min`;
+}
+
+/**
+ * The folder shown on the card. A file tab's `cwd` is just the project root —
+ * the same for every file tab, so it says nothing; show the file's FOLDER
+ * relative to that root instead (the filename is already the card's title; a
+ * root-level file shows no path row at all). Falls back to the absolute folder
+ * for a file outside the root, e.g. a remote-native host path. Non-file tabs
+ * keep their cwd.
+ */
+function cardPath(tab: TabEntry): string {
+  if (tab.kind !== "embed" || !tab.embedPath) return tab.cwd;
+  const dirOf = (p: string) => {
+    const i = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+    return i >= 0 ? p.slice(0, i) : "";
+  };
+  const sep = tab.embedPath[tab.cwd.length];
+  return tab.embedPath.startsWith(tab.cwd) && (sep === "/" || sep === "\\")
+    ? dirOf(tab.embedPath.slice(tab.cwd.length + 1))
+    : dirOf(tab.embedPath);
+}
+
+/**
+ * Hover card for a tab — the tab-bar counterpart to `ProjectHoverCard`. Reuses
+ * the project popup's row classes so the two hovers look identical. Rendered
+ * into a portal by BOTH tab strips (the main window's `TabBar` and the detached
+ * popout's `DetachedCenterPanel`), which is why it takes the whole `TabEntry`
+ * and derives everything itself — the stores it reads (agent task title, file
+ * source, activity) are per-window heaps, so each window's card shows what that
+ * window knows and nothing has to be threaded across.
+ *
+ * `anchorX` is the tab's horizontal centre and `anchorY` its bottom edge. The
+ * card measures itself and clamps into the viewport (a tab near the right/left
+ * edge would otherwise push the centred card off-screen — "out of the app"), and
+ * flips above the bar if it would overflow the bottom.
+ */
+export function TabHoverCard({
+  tab,
+  scope,
+  /** Whether the owning project is a remote (SSH) one — gates the locality
+   *  line. The detached window is inert to the projects store and omits it. */
+  isRemote = false,
+  /** Primary host name + worker machines, so the locality line can name the
+   *  concrete machine ("Primary (gpu-1)", "gpu-2") not just "on host". Omitted by
+   *  the detached window (inert to the projects store) → falls back to "on host". */
+  primaryHost,
+  computeHosts,
+  anchorX,
+  anchorY,
+}: {
+  tab: TabEntry;
+  scope: string;
+  isRemote?: boolean;
+  primaryHost?: string;
+  computeHosts?: LocalityHost[];
+  anchorX: number;
+  anchorY: number;
+}) {
+  const ref = useRef<HTMLDivElement>(null);
+  // null until measured — kept hidden for that first frame so the clamp doesn't
+  // flash the card at the un-clamped position.
+  const [pos, setPos] = useState<{ left: number; top: number } | null>(null);
+
+  const ptyId = `${scope}:${tab.key}`;
+  // The agent task summary (terminal title); absent when the tab set none.
+  const summary = useAgentTaskStore((s) => s.titleByTab[tab.key]);
+  // Viewer file-source (remote-native vs local mirror), published by the file
+  // viewers on remote projects; absent otherwise.
+  const fileSource = useFileSourcesStore((s) => s.byTab[tab.key]);
+  const busy = useActivityStore((s) => !!s.busyByTab[ptyId]);
+
+  // The "quiet for…" line ages while the card is up; tick it along so a card
+  // hovered for a while doesn't freeze at its mount-time reading.
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    const id = window.setInterval(() => setNow(Date.now()), 10_000);
+    return () => window.clearInterval(id);
+  }, []);
+
+  const isAgent = tab.kind === "agent" || tab.kind === "local_agent";
+
+  // Muted kind line, enriched with what the tiny tab badges can only hint at:
+  // the concrete viewer, the agent's Plan/Auto mode, where the process runs
+  // (remote projects), and which side a viewed file came from.
+  const kindBits: string[] = [
+    tab.kind === "embed" && tab.viewer
+      ? (VIEWER_LABEL[tab.viewer] ?? KIND_LABEL.embed)
+      : (KIND_LABEL[tab.kind] ?? tab.kind),
+  ];
+  if (isAgent && tab.agentMode) {
+    kindBits.push(tab.agentMode === "plan" ? "Plan mode" : "Auto mode");
+  }
+  if (isRemote && isLocatableKind(tab.kind)) {
+    const loc = effectiveTabLocation(tab);
+    if (remoteHostIdOf(loc) === null) {
+      kindBits.push("local mirror");
+    } else {
+      // Name the concrete machine when known ("Primary (gpu-1)" / "gpu-2"); the
+      // detached window has no host list, so it degrades to a generic label.
+      const named = primaryHost || computeHosts ? localityHostLabel(loc, { primaryHost, computeHosts }) : null;
+      kindBits.push(named ? `on ${named}` : "on host (SSH)");
+    }
+  }
+  if (tab.kind === "embed" && fileSource === "remote") {
+    kindBits.push("remote-native (SFTP)");
+  } else if (tab.kind === "embed" && fileSource === "local") {
+    kindBits.push("local mirror");
+  }
+
+  // "working" / "quiet for N min" — only for tabs that own a process, and only
+  // once it produced output this session (a window that never saw the PTY —
+  // e.g. a fresh popout — has nothing truthful to say, so it says nothing).
+  const lastOut = isPtyTabKind(tab.kind) ? lastPtyOutputAt(ptyId) : undefined;
+  const activity = busy
+    ? "working — streaming output"
+    : lastOut !== undefined
+      ? `quiet for ${formatQuiet(now - lastOut)}`
+      : null;
+
+  // Whether the conversation survives an app restart — a real behavioral split
+  // between agents (see RESUMABLE_AGENTS) that nothing else surfaces.
+  const restart = isAgent
+    ? isResumableAgentTab(tab)
+      ? "conversation resumes on relaunch"
+      : "conversation is dropped on relaunch"
+    : null;
+
+  const path = cardPath(tab);
+
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const { width, height } = el.getBoundingClientRect();
+    // Centre under the tab, then clamp horizontally within the window.
+    let left = anchorX - width / 2;
+    left = Math.max(MARGIN, Math.min(left, window.innerWidth - MARGIN - width));
+    // Below the bar by default; flip above it if that would run off the bottom.
+    let top = anchorY + GAP;
+    if (top + height > window.innerHeight - MARGIN) {
+      top = Math.max(MARGIN, anchorY - height - GAP);
+    }
+    setPos({ left, top });
+  }, [anchorX, anchorY, tab, summary, fileSource, activity, restart, path]);
+
+  return createPortal(
+    <div
+      ref={ref}
+      className="project-pill-popup tab-popup"
+      style={{
+        left: pos?.left ?? anchorX,
+        top: pos?.top ?? anchorY,
+        // Own the position via left/top (with JS clamping); drop the shared
+        // class's centring transform so the measured box maps 1:1 to the window.
+        transform: "none",
+        visibility: pos ? "visible" : "hidden",
+      }}
+    >
+      <span className="tab-popup-header">
+        <span className="tab-popup-dot" style={{ color: TAB_ACCENT[tab.kind] }}>
+          ●
+        </span>
+        <span className="tab-popup-label">{tab.label}</span>
+      </span>
+      {summary && <span className="pill-popup-description">{summary}</span>}
+      <span className="tab-popup-kind">{kindBits.join(" · ")}</span>
+      {activity && (
+        <span className="pill-popup-path-row">
+          <span className="pill-popup-path-label">activity</span>
+          <span className={`tab-popup-meta${busy ? " working" : ""}`}>{activity}</span>
+        </span>
+      )}
+      {restart && (
+        <span className="pill-popup-path-row">
+          <span className="pill-popup-path-label">restart</span>
+          <span className="tab-popup-meta">{restart}</span>
+        </span>
+      )}
+      {path && <span className="pill-popup-path">{path}</span>}
+      {tab.sessionId && (
+        <span className="pill-popup-path-row">
+          <span className="pill-popup-path-label">session</span>
+          <span className="pill-popup-path">{tab.sessionId}</span>
+        </span>
+      )}
+    </div>,
+    document.body,
+  );
+}
diff --git a/src/components/tabs/TabLocalityBadges.tsx b/src/components/tabs/TabLocalityBadges.tsx
new file mode 100644
index 0000000..d3012a5
--- /dev/null
+++ b/src/components/tabs/TabLocalityBadges.tsx
@@ -0,0 +1,293 @@
+import { useState } from "react";
+import { createPortal } from "react-dom";
+import {
+  effectiveTabLocation,
+  remoteHostIdOf,
+  isLocatableKind,
+  localityHostLabel,
+  workerRunnable,
+  type LocalityHost,
+  type TabEntry,
+  type TabLocation,
+} from "../../stores/tabs";
+import { useFileSourcesStore } from "../../stores/fileSources";
+import { useRunHostPrefStore } from "../../stores/runHostPref";
+import { UntestedTag } from "../common/UntestedTag";
+
+/**
+ * The two per-tab local/remote badges + the locality menu, factored out so the
+ * main-window `TabBar` and each detached popout's tab strip render the SAME
+ * controls (the user asked for parity, and drift between two copies is exactly
+ * what an extraction prevents). Everything here reads the tab payload + the
+ * streamed host list; WHERE a location change is applied is the caller's
+ * `onChoose` (the main store directly, or a streamed edit from a popout).
+ */
+
+/** The open locality-menu state a strip owns: which tab, where to anchor it, and
+ *  the two-level drill (`root` = Local↔Remote, `machines` = primary + workers). */
+export interface LocalityMenuState {
+  key: string;
+  x: number;
+  y: number;
+  view: "root" | "machines";
+}
+
+/** A tab's effective location, or `"local"` for a missing tab — the `current`
+ *  a `LocalityMenu` dots, without the caller importing the tabs helpers. */
+export function tabLocation(tab: TabEntry | undefined): TabLocation {
+  return tab ? effectiveTabLocation(tab) : "local";
+}
+
+/** The file-source badge on a viewer tab: a clickable Local/Remote toggle when
+ *  the viewer published a switch (the file exists on both sides of a remote
+ *  project), else the plain read-only glyph. Renders nothing on a local tab. */
+export function TabSourceBadge({ tabKey }: { tabKey: string }) {
+  const src = useFileSourcesStore((s) => s.byTab[tabKey]);
+  const ctl = useFileSourcesStore((s) => s.controlsByTab[tabKey]);
+  if (ctl) {
+    const onRemote = ctl.current === "remote";
+    const blocked = !onRemote && ctl.remoteDisabled;
+    return (
+      <button
+        className={`tab-source clickable ${onRemote ? "remote" : "local"}${blocked ? " disabled" : ""}`}
+        title={
+          blocked
+            ? "This file has no copy on the host — nothing to switch to."
+            : onRemote
+              ? "Reading from the host over SFTP — click to read the local mirror copy."
+              : "Reading the local mirror copy — click to read from the host over SFTP."
+        }
+        onPointerDown={(e) => e.stopPropagation()}
+        onClick={(e) => {
+          e.stopPropagation();
+          if (blocked) return;
+          ctl.set(onRemote ? "local" : "remote");
+        }}
+      >
+        {onRemote ? "☁" : "⌂"}
+      </button>
+    );
+  }
+  if (src !== "remote" && src !== "local") return null;
+  return (
+    <span
+      className={`tab-source ${src}`}
+      title={
+        src === "remote"
+          ? "Remote-native: read directly from the host over SFTP (no local copy)."
+          : "Local mirror: read from this project's local synced copy of the host file."
+      }
+    >
+      {src === "remote" ? "☁" : "⌂"}
+    </span>
+  );
+}
+
+/** The locality badge (⌂ local / ☁ remote) on an agent/shell tab of a remote
+ *  project — click to open the machine menu. Renders nothing for a non-locatable
+ *  tab kind. Callers gate on the project being remote before rendering it. */
+export function TabLocalityBadge({
+  tab,
+  primaryHost,
+  computeHosts,
+  onOpen,
+}: {
+  tab: TabEntry;
+  primaryHost?: string;
+  computeHosts?: LocalityHost[];
+  /** Open the menu anchored under the badge; `startOnMachines` jumps straight to
+   *  the machine list when the tab already runs remotely (one click closer to a
+   *  remote→remote reassignment). */
+  onOpen: (rect: DOMRect, startOnMachines: boolean) => void;
+}) {
+  if (!isLocatableKind(tab.kind)) return null;
+  const loc = effectiveTabLocation(tab);
+  const hostId = remoteHostIdOf(loc);
+  const label = localityHostLabel(loc, { primaryHost, computeHosts });
+  return (
+    <button
+      className={`tab-locality ${hostId === null ? "local" : "remote"}`}
+      title={`Runs on: ${label} — click to change where this tab runs`}
+      onPointerDown={(e) => e.stopPropagation()}
+      onClick={(e) => {
+        e.stopPropagation();
+        onOpen((e.currentTarget as HTMLElement).getBoundingClientRect(), hostId !== null);
+      }}
+    >
+      {hostId === null ? "⌂" : "☁"}
+    </button>
+  );
+}
+
+/** The two-level locality menu (Local ↔ Remote, then a machine sub-picker). A
+ *  worker that holds no code (not shared-fs, sync off) is offered disabled — sync
+ *  always stays with the primary; the worker only runs scripts. Rendered in a
+ *  portal with a click-away backdrop. */
+export function LocalityMenu({
+  menu,
+  current,
+  primaryHost,
+  computeHosts,
+  onClose,
+  onChangeView,
+  onChoose,
+}: {
+  menu: LocalityMenuState;
+  /** The location currently selected (dotted in the menu). A tab's
+   *  `effectiveTabLocation`, or a file viewer's run-host preference. */
+  current: TabLocation;
+  primaryHost?: string;
+  computeHosts?: LocalityHost[];
+  onClose: () => void;
+  onChangeView: (view: "root" | "machines") => void;
+  onChoose: (key: string, loc: TabLocation) => void;
+}) {
+  const cur = current;
+  const onRemoteNow = remoteHostIdOf(cur) !== null;
+  const choose = (loc: TabLocation) => {
+    onChoose(menu.key, loc);
+    onClose();
+  };
+  const machineItem = (
+    loc: TabLocation,
+    glyph: string,
+    text: string,
+    opts?: { disabled?: boolean; note?: string; title?: string },
+  ) => (
+    <button
+      key={loc}
+      className="tab-new-menu-item"
+      title={opts?.title}
+      disabled={opts?.disabled}
+      onClick={() => !opts?.disabled && choose(loc)}
+    >
+      <span className="tab-new-menu-dot" style={{ color: "var(--accent)" }}>
+        {cur === loc ? "●" : glyph}
+      </span>
+      {text}
+      {opts?.note && <span className="tab-menu-hint">{opts.note}</span>}
+    </button>
+  );
+  return createPortal(
+    <>
+      <div
+        style={{ position: "fixed", inset: 0, zIndex: 40 }}
+        onPointerDown={onClose}
+      />
+      <div
+        className="tab-new-menu"
+        style={{ position: "fixed", left: menu.x, top: menu.y, zIndex: 41 }}
+      >
+        {menu.view === "root" ? (
+          <>
+            {machineItem("local", "⌂", "Local (mirror)")}
+            <button
+              className="tab-new-menu-item"
+              onClick={() => onChangeView("machines")}
+            >
+              <span className="tab-new-menu-dot" style={{ color: "var(--accent)" }}>
+                {onRemoteNow ? "●" : "☁"}
+              </span>
+              Remote…
+              <span className="tab-menu-hint">choose machine ›</span>
+            </button>
+          </>
+        ) : (
+          <>
+            <button
+              className="tab-new-menu-item tab-menu-back"
+              onClick={() => onChangeView("root")}
+            >
+              <span className="tab-new-menu-dot">‹</span>
+              Run on machine
+              <UntestedTag />
+            </button>
+            {machineItem(
+              "remote",
+              "☁",
+              primaryHost ? `Primary (${primaryHost})` : "Primary",
+            )}
+            {(computeHosts ?? []).map((h) =>
+              machineItem(
+                `host:${h.id}`,
+                "☁",
+                h.label || h.host || h.id,
+                workerRunnable(h)
+                  ? undefined
+                  : {
+                      disabled: true,
+                      note: "sync off",
+                      title:
+                        "This machine holds no code — enable “Auto-sync code” or shared filesystem in Remote machines… to run scripts here. Sync stays with the primary.",
+                    },
+              ),
+            )}
+          </>
+        )}
+      </div>
+    </>,
+    document.body,
+  );
+}
+
+/**
+ * The file viewer's "run on machine" picker — a labelled control (beside the
+ * Remote/Local *source* switch) that chooses WHICH machine a Run/Debug or shell
+ * launched from this project runs on, distinct from which side its files are
+ * *read* from. Writes the per-project run-host preference (`useRunHostPrefStore`)
+ * that `lib/pythonRun` reads at launch. Reuses the same two-level `LocalityMenu`
+ * as the tab badge, so the machine list + worker eligibility stay identical.
+ * Shown only for remote projects (a local project has no machine axis).
+ */
+export function RunHostPicker({
+  projectId,
+  primaryHost,
+  computeHosts,
+}: {
+  projectId: string;
+  primaryHost?: string;
+  computeHosts?: LocalityHost[];
+}) {
+  const pref = useRunHostPrefStore((s) => s.byProject[projectId]);
+  const setPref = useRunHostPrefStore((s) => s.set);
+  const [menu, setMenu] = useState<LocalityMenuState | null>(null);
+  // Unset ⇒ the shell default (the primary host) — the same default pythonRun
+  // falls back to, so the label never lies about where a run would land.
+  const current: TabLocation = pref ?? "remote";
+  const label = localityHostLabel(current, { primaryHost, computeHosts });
+  const onRemote = remoteHostIdOf(current) !== null;
+  return (
+    <>
+      <button
+        type="button"
+        className="right-panel-run-host"
+        // The label ellipsizes in a narrow (docked subwindow) row, so the full
+        // machine name has to survive somewhere — the tooltip names it.
+        title={`Runs on: ${label}\nWhere Run/Debug and shells launched from this project run — the machine, not which side files are read from.`}
+        onClick={(e) => {
+          const r = (e.currentTarget as HTMLElement).getBoundingClientRect();
+          setMenu({
+            key: projectId,
+            x: r.left,
+            y: r.bottom + 2,
+            view: onRemote ? "machines" : "root",
+          });
+        }}
+      >
+        <span aria-hidden="true">{onRemote ? "☁" : "⌂"}</span>
+        <span className="run-host-label">Run: {label}</span>
+      </button>
+      {menu && (
+        <LocalityMenu
+          menu={menu}
+          current={current}
+          primaryHost={primaryHost}
+          computeHosts={computeHosts}
+          onClose={() => setMenu(null)}
+          onChangeView={(view) => setMenu((m) => (m ? { ...m, view } : m))}
+          onChoose={(_key, loc) => setPref(projectId, loc)}
+        />
+      )}
+    </>
+  );
+}
diff --git a/src/components/tabs/TabPane.tsx b/src/components/tabs/TabPane.tsx
new file mode 100644
index 0000000..72ea1c0
--- /dev/null
+++ b/src/components/tabs/TabPane.tsx
@@ -0,0 +1,183 @@
+import { memo } from "react";
+import { TerminalView } from "../terminal/TerminalView";
+import { FileBrowser } from "../files/FileBrowser";
+import { ProjectFilesTab } from "../files/ProjectFilesTab";
+import { EmbedPane } from "../embed/EmbedPane";
+import { FileViewerPane } from "../embed/FileViewerPane";
+import { ProjectBlobPane } from "../common/ProjectBlobPane";
+import { NetworkTrafficPane } from "../monitoring/NetworkTrafficPane";
+import { SystemMonitorPane } from "../monitoring/SystemMonitorPane";
+import { DiskUsagePane } from "../monitoring/DiskUsagePane";
+import { CalendarPane } from "../calendar/CalendarPane";
+import { RemotePaneHold } from "../projects/RemotePaneHold";
+import { effectiveTabLocation, remoteHostIdOf, type TabEntry } from "../../stores/tabs";
+
+/**
+ * The single per-tab `kind → pane` render switch, shared by the main window
+ * (`CenterPanel`) and every detached popout (`DetachedCenterPanel`). Both windows
+ * are separate React roots in separate JS heaps, so this used to be TWO
+ * hand-maintained switches that silently drifted — a new pane kind or prop added
+ * to one was routinely forgotten in the other (that is the whole class of "works
+ * in the main window, dead in a popout" bugs). Keeping it here means a new pane
+ * kind or prop lands in both windows at once.
+ *
+ * Everything that GENUINELY differs between the two windows is lifted into a
+ * prop the HOST computes, because a popout is inert to the `projects`/`tabs`
+ * stores and can't derive it:
+ *  - `attachOnly` — a popout's terminals attach to the main window's PTY, never
+ *    spawn (so all the terminal spawn inputs below are cosmetic there).
+ *  - `ownsTabs` — only the main window owns the tab store, so only it may let a
+ *    pane retitle its tab (`tabKey`) or open new tabs (`canOpenTabs`). A popout
+ *    runs on a streamed COPY with no write channel back, so it passes neither.
+ *  - `filesProjectDir` / `terminalCwd` / `sandbox` / `holdRemoteTerminal` /
+ *    `onConnect` — all resolved from the projects store, which the popout lacks.
+ *
+ * Values that are computed IDENTICALLY from the tab alone in both windows
+ * (`projectId` from the scope, `localOnly`, `zoomable`) are derived here rather
+ * than threaded as props.
+ */
+export interface TabPaneProps {
+  tab: TabEntry;
+  /** The owning scope key ("root" or a project id). Also names the PTY id. */
+  scope: string;
+  /** Laid out on screen (its group's active tab, and not hidden by fullscreen). */
+  visible: boolean;
+  /** The group this pane sits in (viewer scroll-sync). Undefined in a popout. */
+  groupId?: string;
+  /** Popout: attach to the main window's PTY instead of spawning one. */
+  attachOnly?: boolean;
+  /** Main window only: the host owns the tab store (retitle / open-tabs). */
+  ownsTabs?: boolean;
+  /** Open the connect dialog (network pane + a held remote terminal). */
+  onConnect?: () => void;
+  /** A remote terminal whose SSH pool is down — hold rather than spawn. */
+  holdRemoteTerminal?: boolean;
+  /** The held terminal's host label (only read when `holdRemoteTerminal`). */
+  remoteHost?: string;
+  /** The Files-tab browse dir (mirror-swapped while a remote is disconnected). */
+  filesProjectDir: string;
+  /** The terminal's cwd (the mirror path for a local-on-remote tab). */
+  terminalCwd: string;
+  /** Run this (agent/shell) tab inside the project's session container. */
+  sandbox?: boolean;
+  /** The stable tmux session name to spawn-or-attach this remote shell/script tab
+   *  into (TODO #85), or undefined when the tab doesn't run persistently. */
+  tmuxSession?: string;
+}
+
+function TabPaneImpl({
+  tab,
+  scope,
+  visible,
+  groupId,
+  attachOnly = false,
+  ownsTabs = false,
+  onConnect,
+  holdRemoteTerminal = false,
+  remoteHost = "",
+  filesProjectDir,
+  terminalCwd,
+  sandbox = false,
+  tmuxSession,
+}: TabPaneProps) {
+  // Identical in both windows: null for the root scope, else the scope id.
+  const projectId = scope === "root" ? null : scope;
+  const zoomable = tab.kind === "agent" || tab.kind === "local_agent";
+
+  switch (tab.kind) {
+    case "projects3d":
+      return <ProjectBlobPane />;
+    case "calendar":
+      return <CalendarPane visible={visible} />;
+    case "network":
+      return <NetworkTrafficPane projectId={scope} visible={visible} onConnect={onConnect} />;
+    case "monitor":
+      return <SystemMonitorPane projectId={projectId} visible={visible} />;
+    case "diskusage":
+      return (
+        <DiskUsagePane
+          projectId={projectId}
+          projectCwd={tab.cwd}
+          // A popout can't retitle its tab (no write channel back), so it gets no
+          // tabKey — its Disk Usage tab keeps the label it was given.
+          {...(ownsTabs ? { tabKey: tab.key } : {})}
+          visible={visible}
+        />
+      );
+    case "files":
+      return <FileBrowser projectDir={filesProjectDir} projectId={projectId} active={visible} />;
+    case "projectfiles":
+      return (
+        <ProjectFilesTab
+          scope={scope}
+          cwd={tab.cwd}
+          // Same as Disk Usage above: no write channel back from a popout, so no
+          // tabKey (browsed folder stays the popout's) and no open-in-new-tab.
+          {...(ownsTabs ? { tabKey: tab.key, canOpenTabs: true } : {})}
+          folder={tab.folder}
+          visible={visible}
+        />
+      );
+    case "embed":
+      return tab.viewer ? (
+        <FileViewerPane
+          viewer={tab.viewer}
+          path={tab.embedPath ?? ""}
+          projectId={projectId}
+          tabKey={tab.key}
+          visible={visible}
+          groupId={groupId}
+        />
+      ) : (
+        <EmbedPane
+          path={tab.embedPath ?? ""}
+          exec={tab.embedExec}
+          projectId={projectId}
+          visible={visible}
+        />
+      );
+    default:
+      // Remote terminal pane while the pool is down (main window only): show a
+      // Connect placeholder rather than mount TerminalView, which would spawn
+      // `ssh -tt` and block on the dead pool.
+      if (holdRemoteTerminal) {
+        return <RemotePaneHold host={remoteHost} onConnect={onConnect ?? (() => {})} />;
+      }
+      return (
+        <TerminalView
+          // PTY ids include the scope: tab keys alone collide across projects.
+          id={`${scope}:${tab.key}`}
+          cmd={tab.cmd}
+          args={tab.args ?? []}
+          env={tab.env ?? {}}
+          // A popout is attach-only and never spawns, and its `terminal-ready`
+          // never fires, so it takes no initialInput (matches its old behavior).
+          initialInput={attachOnly ? undefined : tab.initialInput}
+          cwd={terminalCwd}
+          localOnly={effectiveTabLocation(tab) === "local"}
+          projectId={projectId}
+          // Multi-host: the worker id (or "primary") this tab runs on, so the
+          // backend resolves the right host's RemoteSpec (null for a local tab).
+          remoteHostId={remoteHostIdOf(effectiveTabLocation(tab))}
+          sandbox={sandbox}
+          // Persistent remote session (TODO #85). An explicit attach (opened from
+          // the Sessions view) wins over the tab's own persistent session.
+          tmuxSession={tmuxSession ?? null}
+          tmuxAttach={tab.tmuxAttach ?? null}
+          zoomable={zoomable}
+          visible={visible}
+          focused={visible}
+          attachOnly={attachOnly}
+        />
+      );
+  }
+}
+
+/**
+ * Memoized so a `CenterPanel` re-render (e.g. a pane-rect update every frame of a
+ * divider drag) skips every pane whose props are unchanged, instead of
+ * reconciling every terminal/viewer across every scope. Relies on all props being
+ * referentially stable across such re-renders — notably `onConnect`, which the
+ * host passes as a per-scope stable callback (never an inline arrow).
+ */
+export const TabPane = memo(TabPaneImpl);
diff --git a/src/components/tabs/agentModes.ts b/src/components/tabs/agentModes.ts
new file mode 100644
index 0000000..2a359cf
--- /dev/null
+++ b/src/components/tabs/agentModes.ts
@@ -0,0 +1,85 @@
+/**
+ * Per-tab agent authority mode: the "planner tab vs doer tab" split.
+ *
+ * A mode is passed to the agent as a *launch flag*, so switching one on a live
+ * tab means respawning it. That is only non-destructive for an agent whose
+ * conversation comes back on respawn — which is why this table is a capability
+ * table, not a universal field: an agent appears here only when BOTH halves are
+ * true of it.
+ *
+ *   - It has an ABSOLUTE mode flag. Claude's `--permission-mode` sets the mode
+ *     outright. (Its in-TUI shift+tab, by contrast, *cycles* — you cannot set a
+ *     known mode with it without first knowing the current one, which Eldrun
+ *     can't read back out of the TUI.)
+ *   - It RESUMES on respawn. `resolve_claude_session_impl` (backend) rewrites
+ *     `--session-id <uuid>` → `--resume <live-id>` once a session log exists, so
+ *     a Claude tab killed and respawned comes back on the same conversation.
+ *
+ * Claude and Gemini qualify:
+ *   - Claude — `--permission-mode` (absolute) + resume-by-id.
+ *   - Gemini — `--approval-mode` (default/auto_edit/yolo/plan — absolute) +
+ *     resume (see RESUMABLE_AGENTS). Its resume is *continue-last*, not
+ *     resume-by-id, which carries one accepted caveat: a respawn brings back the
+ *     project's most-recent Gemini session, so with two Gemini tabs in one
+ *     project a mid-session mode toggle can reattach to the sibling's
+ *     conversation — the very same ambiguity their ordinary restore already has,
+ *     not a new failure the toggle introduces.
+ *
+ * Deliberately absent:
+ *   - Codex — resumes fine, but has no plan mode: only a read-only sandbox that
+ *     approximates one, and it is unverified whether `--sandbox`/`--full-auto`
+ *     are accepted on `codex resume`.
+ *   - Everyone else — no mode flag at all.
+ */
+export type AgentMode = "plan" | "auto";
+
+/**
+ * `cmd` → the launch args that put the agent in a mode.
+ *
+ * "auto" is edits-only auto-approval, NOT full auto-approve: for Claude that is
+ * `acceptEdits` (the mode its own shift+tab reaches — "⏵⏵ auto-accept edits on",
+ * where file edits apply without asking but bash/network still prompt); for
+ * Gemini it is `auto_edit` (auto-approve edit tools), NOT `yolo` (auto-approve
+ * ALL tools). Mapping "auto" to the bypass-everything level would hide a strictly
+ * more dangerous authority behind a familiar word.
+ */
+export const AGENT_MODE_ARGS: Record<string, (mode: AgentMode) => string[]> = {
+  claude: (mode) => ["--permission-mode", mode === "plan" ? "plan" : "acceptEdits"],
+  gemini: (mode) => ["--approval-mode", mode === "plan" ? "plan" : "auto_edit"],
+};
+
+/** The flags whose `<flag> <value>` pair a mode owns, per agent. Stripped before
+ *  a new mode is applied so repeated toggling can never stack them. */
+const MODE_FLAGS: Record<string, string[]> = {
+  claude: ["--permission-mode"],
+  gemini: ["--approval-mode"],
+};
+
+/** Whether this agent can be mode-switched at all (see the note above). */
+export function supportsAgentMode(cmd: string): boolean {
+  return cmd in AGENT_MODE_ARGS;
+}
+
+/**
+ * Rewrite an agent tab's launch args to carry `mode`: drop any mode flag already
+ * present (with its value), then append the new one. Idempotent — toggling
+ * plan→auto→plan yields exactly one `--permission-mode` pair, never a stack —
+ * and it leaves every sibling arg (`--session-id <uuid>`, `--resume <id>`,
+ * `--remote-control`) untouched.
+ *
+ * Returns `args` unchanged for an agent with no mode support.
+ */
+export function withAgentMode(cmd: string, args: string[], mode: AgentMode): string[] {
+  const modeArgs = AGENT_MODE_ARGS[cmd];
+  if (!modeArgs) return args;
+  const flags = MODE_FLAGS[cmd] ?? [];
+  const stripped: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (flags.includes(args[i])) {
+      i++; // skip the flag's value too
+      continue;
+    }
+    stripped.push(args[i]);
+  }
+  return [...stripped, ...modeArgs(mode)];
+}
diff --git a/src/components/tabs/commitDrop.ts b/src/components/tabs/commitDrop.ts
index 9cfabbb..6463858 100644
--- a/src/components/tabs/commitDrop.ts
+++ b/src/components/tabs/commitDrop.ts
@@ -1,7 +1,9 @@
 import { type TabDrag } from "../../stores/drag";
 import { findGroupOfTab, useTabsStore } from "../../stores/tabs";
 import { useLinkRoutingStore } from "../../stores/linkRouting";
+import { useTabLandStore } from "../../stores/tabLand";
 import { openLinkedFile } from "../embed/FileViewerPane";
+import { basename, dirname } from "../../lib/paths";
 
 /**
  * Commit a finished tab drag. Reads store actions from getState() so it can live
@@ -39,7 +41,9 @@ export function commitDrop(d: TabDrag | null) {
       const to = from < d.reorderIndex ? d.reorderIndex - 1 : d.reorderIndex;
       if (to !== from && to >= 0) store.reorderInGroup(d.reorderGroup, from, to);
     } else {
+      // Dropped into ANOTHER bar's slot: play the destination drop-in landing.
       store.moveTab(d.key, d.reorderGroup, d.reorderIndex);
+      useTabLandStore.getState().markLanded(d.key);
     }
     return;
   }
@@ -49,9 +53,13 @@ export function commitDrop(d: TabDrag | null) {
       // keep the tab where it is rather than moving it to the end of its own
       // group. (A non-center edge is a real split-off intent, so it's allowed.)
       if (d.overGroup === d.fromGroup) return;
+      // Merged into another subwindow's tab bar → land in its new group.
       store.moveTab(d.key, d.overGroup);
+      useTabLandStore.getState().markLanded(d.key);
     } else {
+      // Split off into a brand-new subwindow → land in the new group's bar.
       store.splitWithTab(d.key, d.overGroup, d.edge);
+      useTabLandStore.getState().markLanded(d.key);
     }
   }
 }
@@ -66,10 +74,10 @@ export function commitLinkDrop(d: TabDrag) {
   useLinkRoutingStore
     .getState()
     .setRoute(d.linkingTabKey, d.linkTargetPath, d.overGroup);
-  const dir = d.linkTargetPath.slice(0, d.linkTargetPath.lastIndexOf("/")) || "/";
+  const dir = dirname(d.linkTargetPath) || "/";
   openLinkedFile(d.linkingTabKey, dir, {
     path: d.linkTargetPath,
     viewer: d.viewer,
-    label: d.linkTargetPath.slice(d.linkTargetPath.lastIndexOf("/") + 1),
+    label: basename(d.linkTargetPath),
   });
 }
diff --git a/src/components/tabs/commitFileDrop.ts b/src/components/tabs/commitFileDrop.ts
index 3fecc51..3a69a2a 100644
--- a/src/components/tabs/commitFileDrop.ts
+++ b/src/components/tabs/commitFileDrop.ts
@@ -1,12 +1,87 @@
-import { type TabDrag } from "../../stores/drag";
+import { type TabDrag, type FileDragItem } from "../../stores/drag";
 import {
   EMPTY_GROUP_ID,
   findGroup,
   useTabsStore,
+  type DetachedDockTarget,
   type DropEdge,
+  type TabEntry,
   type WindowBounds,
 } from "../../stores/tabs";
 import { useWindowsStore } from "../../stores/windows";
+import { reseedDetached } from "./detachedDropTargets";
+
+/**
+ * The embed-tab payload a dropped file becomes. Shared by every file-drop path —
+ * the main window's `commitFileDrop`, the detached window's own drop (see
+ * DetachedCenterPanel) — so the tab a file turns into is identical wherever it
+ * lands. `f` is a multi-drag member (its own viewer, no capability probe) or
+ * `null` for the single primary file (which keeps its cap-resolved `embedExec`).
+ */
+export function fileEmbedPayload(
+  d: TabDrag,
+  f: FileDragItem | null,
+  projectCwd: string,
+): Omit<TabEntry, "key"> {
+  if (f) {
+    return {
+      label: f.name,
+      cmd: "",
+      cwd: projectCwd,
+      kind: "embed",
+      embedPath: f.path,
+      viewer: f.viewer,
+    };
+  }
+  const cap = d.embedCap;
+  return {
+    label: d.fileName ?? "",
+    cmd: "",
+    cwd: projectCwd,
+    kind: "embed",
+    embedPath: d.filePath ?? "",
+    // A built-in viewer (pdf/markdown/text) renders the file in-app and takes
+    // precedence over the external handler — so don't carry embedExec then.
+    embedExec: d.viewer ? undefined : (cap?.resolved_exec ?? d.fileExec),
+    viewer: d.viewer,
+  };
+}
+
+/** The ordered embed-tab payloads a file drag commits to — one per file (a
+ *  multi-selection), else the single primary. */
+export function fileDropPayloads(d: TabDrag, projectCwd: string): Array<Omit<TabEntry, "key">> {
+  const multi = d.files && d.files.length > 1 ? d.files : null;
+  const items: (FileDragItem | null)[] = multi ?? [null];
+  return items.map((f) => fileEmbedPayload(d, f, projectCwd));
+}
+
+/**
+ * Should a released file drag open its OWN standalone window rather than land
+ * in-window? True only when the user explicitly asked (Shift) or the release is
+ * genuinely outside the main window's viewport.
+ *
+ * A popout whose bounds sit under the cursor deliberately does NOT count here: a
+ * FRONT popout is already docked into by the caller before this runs (see
+ * FileTree's `overFrontDetached` dock branch); an OCCLUDED popout (behind the
+ * main window) means the cursor is really over the main window, so the drop must
+ * stay in-window — never spawn a new window the user can't see they are aiming
+ * at. Folding `overDetached` into this test was the regression that made a drop
+ * over an occluded popout falsely open a new detached viewer window instead of
+ * splitting in-window.
+ */
+export function fileDropGoesToNewWindow(opts: {
+  shiftKey: boolean;
+  lastClient: { x: number; y: number };
+  viewport: { w: number; h: number };
+}): boolean {
+  return (
+    opts.shiftKey ||
+    opts.lastClient.x < 0 ||
+    opts.lastClient.y < 0 ||
+    opts.lastClient.x >= opts.viewport.w ||
+    opts.lastClient.y >= opts.viewport.h
+  );
+}
 
 /**
  * Commit a finished FILE drag (a file row dragged from the FileTree onto a tab
@@ -45,6 +120,13 @@ export function commitFileDrop(
   // Set when the file was released outside the main window: spawn a standalone
   // detached window at these screen-px bounds rather than docking into a tab.
   detachBounds?: WindowBounds | null,
+  // Set when the file was released over an open popout: dock it as an embed tab
+  // INTO that popout instead of spawning a new window (mirrors a tab dragged onto
+  // a popout). `target` is the specific pane the popout resolved under the cursor
+  // (a body edge splits, center/a slot merges; omitted → its first pane). Takes
+  // precedence over `detachBounds` (the cursor is over the popout and therefore
+  // also outside the main window).
+  detachedTarget?: { scope: string; groupId: string; target?: DetachedDockTarget } | null,
 ) {
   if (!d || d.kind !== "file" || !d.filePath || !d.fileName) return;
 
@@ -52,31 +134,65 @@ export function commitFileDrop(
   const overTabBar = d.reorderGroup != null && d.reorderIndex != null;
   const overSplit = d.overGroup != null && d.edge != null;
 
-  // Shared embed-tab payload for both the tab-bar and the new-subwindow paths.
-  const tabPayload = {
-    label: d.fileName,
-    cmd: "",
-    cwd: projectCwd,
-    kind: "embed" as const,
-    embedPath: d.filePath,
-    // A built-in viewer (pdf/markdown/text) renders the file in-app and takes
-    // precedence over the external handler — so don't carry embedExec then.
-    embedExec: d.viewer ? undefined : (cap?.resolved_exec ?? d.fileExec),
-    viewer: d.viewer,
-  };
+  // Multi-file drag (a selection dragged from the FileTree): replay each drop
+  // branch once per file. `items` is that list; a `null` sentinel means "the
+  // single primary file", which keeps the original single-file path (with its
+  // cap-resolved embedExec) byte-for-byte unchanged. A multi-file member has no
+  // per-file capability probe, so its tab carries no embedExec — EmbedPane opens
+  // a non-viewer file externally, matching the single-file fallback.
+  const multi = d.files && d.files.length > 1 ? d.files : null;
+  const items: (FileDragItem | null)[] = multi ?? [null];
+  const payloadFor = (f: FileDragItem | null) => fileEmbedPayload(d, f, projectCwd);
+
+  // Released over an open popout → dock the file as a new embed tab INTO it. We
+  // create the tab in this scope, then move it into the popout's subtree (the
+  // same addTab + dockTabIntoDetached path the tab drag uses); the intermediate
+  // in-window tab never renders because both store writes batch in this handler
+  // tick. Re-seed (with the new key as landedKey) so the popout renders the tab
+  // and plays the drop-in landing. Takes precedence over the new-window branch.
+  if (detachedTarget) {
+    const store = useTabsStore.getState();
+    let firstKey: string | null = null;
+    for (const f of items) {
+      const entry = store.addTab(payloadFor(f));
+      store.dockTabIntoDetached(
+        detachedTarget.scope,
+        detachedTarget.groupId,
+        entry.key,
+        detachedTarget.target,
+      );
+      if (!firstKey) firstKey = entry.key;
+    }
+    if (firstKey) reseedDetached(detachedTarget.scope, detachedTarget.groupId, firstKey);
+    return;
+  }
 
   // Released outside the main window → standalone window, regardless of layout
   // state. Takes precedence over every in-window target below. An external-app
   // file (no built-in viewer) opens directly in that app — don't wrap it in a
   // detached Eldrun subwindow; only built-in viewers get their own window.
   if (detachBounds) {
-    if (d.viewer) {
-      useTabsStore.getState().detachNewTab(tabPayload, detachBounds);
-    } else {
-      useWindowsStore
-        .getState()
-        .openFile(d.filePath, cap?.resolved_exec ?? d.fileExec, projectId, "file_drag_out")
-        .catch((e) => console.error(e));
+    for (const f of items) {
+      const viewer = f ? f.viewer : d.viewer;
+      if (viewer) {
+        useTabsStore.getState().detachNewTab(payloadFor(f), detachBounds);
+      } else {
+        // A multi-file member has no cap probe → open with the OS default; the
+        // single primary keeps its resolved handler hint.
+        useWindowsStore
+          .getState()
+          .openFile(
+            f ? f.path : d.filePath,
+            f ? undefined : cap?.resolved_exec ?? d.fileExec,
+            projectId,
+            "file_drag_out",
+            // Land the external app on the monitor the file was dropped onto:
+            // detachBounds is the physical drop rectangle (from the desktop
+            // cursor), matching the sibling viewer-window branch above.
+            { x: detachBounds.x, y: detachBounds.y },
+          )
+          .catch((e) => console.error(e));
+      }
     }
     return;
   }
@@ -89,7 +205,7 @@ export function commitFileDrop(
   // falls through and does nothing, so files never leak out as external opens.
   if (!useTabsStore.getState().layout) {
     if (d.reorderGroup === EMPTY_GROUP_ID || d.overGroup === EMPTY_GROUP_ID) {
-      useTabsStore.getState().addTab(tabPayload);
+      for (const f of items) useTabsStore.getState().addTab(payloadFor(f));
     }
     return;
   }
@@ -99,10 +215,14 @@ export function commitFileDrop(
     const targetGroup = d.reorderGroup as string;
     if (!findGroup(store.layout, targetGroup)) return;
     // R1: addTab appends to the focused group and ignores index — focus the
-    // target, add, then move to the resolved slot.
+    // target, add, then move to the resolved slot. For a multi drag, the files
+    // land in order at consecutive slots from the drop index.
     store.focusGroup(targetGroup);
-    const entry = store.addTab(tabPayload);
-    store.moveTab(entry.key, targetGroup, d.reorderIndex as number);
+    let slot = d.reorderIndex as number;
+    for (const f of items) {
+      const entry = store.addTab(payloadFor(f));
+      store.moveTab(entry.key, targetGroup, slot++);
+    }
     return;
   }
 
@@ -110,7 +230,11 @@ export function commitFileDrop(
     const store = useTabsStore.getState();
     const targetGroup = d.overGroup as string;
     if (!findGroup(store.layout, targetGroup)) return;
-    store.splitWithNewTab(tabPayload, targetGroup, d.edge as DropEdge);
+    // Carve the new subwindow with the first file; splitWithNewTab focuses the
+    // new group, so the rest of a multi drag addTab straight into it.
+    const [first, ...rest] = items;
+    store.splitWithNewTab(payloadFor(first), targetGroup, d.edge as DropEdge);
+    for (const f of rest) store.addTab(payloadFor(f));
     return;
   }
 
diff --git a/src/components/tabs/detachedDropTargets.ts b/src/components/tabs/detachedDropTargets.ts
new file mode 100644
index 0000000..cc56b63
--- /dev/null
+++ b/src/components/tabs/detachedDropTargets.ts
@@ -0,0 +1,197 @@
+import { emit, listen } from "@tauri-apps/api/event";
+import { WebviewWindow } from "@tauri-apps/api/webviewWindow";
+import {
+  DETACHED_PANES,
+  DETACHED_PANES_REQUEST,
+  buildSeed,
+  detachedDropPreviewEvent,
+  detachedSeedEvent,
+  type DetachedPanes,
+  type PaneRect,
+} from "../../stores/detached";
+import { pickEdge } from "./dragGeometry";
+import {
+  snapshotFrame,
+  physToClient,
+  pointInOuter,
+  type PhysPoint,
+  type WindowFrame,
+} from "../../lib/coords";
+import { useTabsStore, type DetachedDockTarget, type DropEdge } from "../../stores/tabs";
+
+/** An open popout of the active scope, with its physical-px window frame (see
+ *  lib/coords). All hit-tests take a physical desktop cursor (`PhysPoint`) — never
+ *  DOM `ev.screenX/Y`, whose units diverge across engines under DPI scaling. */
+export interface DetachedTarget {
+  label: string;
+  groupId: string;
+  scope: string;
+  /** The popout window's physical-px frame: its outer rect for the AABB test and
+   *  its inner origin/scale for mapping the cursor into the popout's client px. */
+  frame: WindowFrame;
+}
+
+/** Hit-test a cursor (popout-client px) against a popout's reported panes: over a
+ *  bar → merge into that group (center); over a body → edge-split (pickEdge). The
+ *  host runs this SYNCHRONOUSLY, so the release uses the final cursor with no
+ *  cross-window round-trip race. Bars win over bodies (a bar overlaps no body).
+ *  Exported for unit tests. */
+export function resolvePaneTarget(
+  panes: PaneRect[],
+  x: number,
+  y: number,
+): { groupId: string; edge: DropEdge } | null {
+  for (const p of panes) {
+    const b = p.bar;
+    if (x >= b.left && x <= b.right && y >= b.top && y <= b.bottom) {
+      return { groupId: p.groupId, edge: "center" };
+    }
+  }
+  for (const p of panes) {
+    const b = p.body;
+    if (x >= b.left && x <= b.right && y >= b.top && y <= b.bottom) {
+      const edge = pickEdge(
+        { left: b.left, top: b.top, width: b.right - b.left, height: b.bottom - b.top },
+        x,
+        y,
+      );
+      return { groupId: p.groupId, edge };
+    }
+  }
+  return null;
+}
+
+/**
+ * A drag gesture's view of the current scope's popouts as drop targets. Shared by
+ * the tab drag (`TabBar`) and the file drag (`FileTree`) so both light up the
+ * popout under the cursor and dock into it identically — rather than each
+ * re-implementing the cross-window hit-test (the divergence that left file drags
+ * spawning a new window over a popout instead of docking into it).
+ *
+ * The cursor leaves the main viewport while over a popout. The caller tracks it via
+ * the cross-platform `cursorPosition()` poll (`startCursorPoll`, physical desktop
+ * px), so a synchronous `at()` hit-test on every tick/release can tell whether the
+ * cursor is over a popout. `resolve()` is async (per-window IPC), so the caller
+ * kicks it off when the drag starts and hit-tests against whatever has resolved; an
+ * unfinished resolve simply means no popout target yet (caller falls back to its
+ * new-window detach).
+ */
+export function startDetachedDropSession() {
+  let targets: DetachedTarget[] = [];
+  let hovered: string | null = null;
+  // Each popout's pane geometry (client px), reported once when the drag starts so
+  // the host can hit-test the cursor SYNCHRONOUSLY — no release round-trip race.
+  const panesByLabel = new Map<string, PaneRect[]>();
+  let disposed = false;
+  let unlisten: (() => void) | undefined;
+  void listen<DetachedPanes>(DETACHED_PANES, (ev) => {
+    panesByLabel.set(ev.payload.label, ev.payload.panes);
+  })
+    .then((fn) => {
+      if (disposed) fn();
+      else unlisten = fn;
+    })
+    .catch(() => {});
+
+  const resolve = async () => {
+    const st = useTabsStore.getState();
+    const scope = st.scope;
+    const entries = st.detachedGroupsByScope[scope] ?? [];
+    const out: DetachedTarget[] = [];
+    for (const entry of entries) {
+      try {
+        const w = await WebviewWindow.getByLabel(entry.label);
+        if (!w) continue;
+        // Snapshot the popout's physical-px frame (outer rect + inner origin/scale).
+        // All later hit-tests stay in physical desktop px — no `/scale` divisions.
+        const frame = await snapshotFrame(w);
+        out.push({ label: entry.label, groupId: entry.id, scope, frame });
+        // Ask the popout for its pane geometry now (its tree is fixed for the drag)
+        // so the cursor hit-test is ready before it reaches the popout.
+        void emit(DETACHED_PANES_REQUEST, { label: entry.label });
+      } catch {
+        /* window gone / not yet resolvable — skip it as a target */
+      }
+    }
+    targets = out;
+  };
+
+  // Pure physical AABB: is the desktop cursor over a popout's OUTER rect?
+  const at = (cursorPhys: PhysPoint): DetachedTarget | null =>
+    targets.find((t) => pointInOuter(t.frame, cursorPhys)) ?? null;
+
+  // Resolve the pane the cursor is over inside a popout (synchronously, from its
+  // reported geometry). `null` if its panes haven't arrived yet or no pane is hit.
+  const resolveInPopout = (
+    pop: DetachedTarget,
+    cursorPhys: PhysPoint,
+  ): DetachedDockTarget | null => {
+    const panes = panesByLabel.get(pop.label);
+    if (!panes) return null;
+    // Map the physical cursor into the popout's OWN client px via its inner
+    // origin/scale (physToClient), the only DPI-correct conversion — then hit-test.
+    const c = physToClient(pop.frame, cursorPhys);
+    return resolvePaneTarget(panes, c.x, c.y);
+  };
+
+  // Drive the drop preview in the popout under the cursor: resolve the pane HERE
+  // and stream the resolved target so the popout renders its per-pane preview;
+  // clear the previous popout when the cursor moves off it. `label` is the dragged
+  // item's name (shown in the popout's ghost). Pass `pop === null` to clear all.
+  const hover = (pop: DetachedTarget | null, cursorPhys: PhysPoint, label?: string) => {
+    const next = pop?.label ?? null;
+    if (next !== hovered) {
+      if (hovered) void emit(detachedDropPreviewEvent(hovered), { active: false });
+      hovered = next;
+    }
+    if (pop && next) {
+      const target = resolveInPopout(pop, cursorPhys);
+      void emit(detachedDropPreviewEvent(next), {
+        active: true,
+        target,
+        cursorPhysX: cursorPhys.x,
+        cursorPhysY: cursorPhys.y,
+        label,
+      });
+    }
+  };
+
+  // The pane the cursor resolves to in the given popout AT the supplied physical
+  // cursor — computed synchronously for the release dock (no stale cross-window cache).
+  const targetAt = (
+    pop: DetachedTarget,
+    cursorPhys: PhysPoint,
+  ): DetachedDockTarget | undefined => resolveInPopout(pop, cursorPhys) ?? undefined;
+
+  // Clear any active highlight and tear down the panes listener. Call once the
+  // gesture ends (release/abort).
+  const dispose = () => {
+    if (hovered) void emit(detachedDropPreviewEvent(hovered), { active: false });
+    hovered = null;
+    disposed = true;
+    unlisten?.();
+  };
+
+  return { resolve, at, hover, targetAt, dispose };
+}
+
+/**
+ * Re-seed a popout after something is docked INTO it so it re-renders with the
+ * new tab. `landedKey` tags the seed so the popout plays the same drop-in landing
+ * for the freshly-docked tab as it does for an in-popout merge. Shared by the tab
+ * and file drop paths.
+ */
+export function reseedDetached(scope: string, groupId: string, landedKey?: string) {
+  const entry = useTabsStore
+    .getState()
+    .detachedGroupsByScope[scope]?.find((d) => d.id === groupId);
+  if (!entry) return;
+  const seed = buildSeed(
+    scope,
+    groupId,
+    useTabsStore.getState().tabsByScope[scope] ?? [],
+    entry.subtree,
+    entry.zoom,
+  );
+  void emit(detachedSeedEvent(entry.label), landedKey ? { ...seed, landedKey } : seed);
+}
diff --git a/src/components/tabs/dragPreview.ts b/src/components/tabs/dragPreview.ts
new file mode 100644
index 0000000..ac086f1
--- /dev/null
+++ b/src/components/tabs/dragPreview.ts
@@ -0,0 +1,33 @@
+import { allGroups, findGroup, removeNodeById, type LayoutNode } from "../../stores/tabs";
+
+/**
+ * The layout that should be RENDERED while a tab drag is in flight.
+ *
+ * When a subwindow's ONLY tab is being dragged, its (about-to-empty) subwindow is
+ * pruned so the remaining subwindows reflow to fill — the source closes "on
+ * dragging", not just on the drop. This is a render-only preview: the store
+ * layout is NOT mutated, so an aborted/Escaped drag restores instantly and the
+ * dragged tab's pane stays mounted in CenterPanel's flat pane layer (its PTY
+ * survives; the floating ghost previews its content). The real source-group
+ * collapse still happens in the store on commit (writeScope → pruneCollapse).
+ *
+ * Returns `layout` unchanged when there's nothing to collapse: no tab drag, the
+ * dragged tab isn't the lone tab of its source group, it's the only subwindow
+ * (nothing to expand into), or a group is fullscreen (its pane owns the panel).
+ */
+export function dragPreviewLayout(
+  layout: LayoutNode | null,
+  dragKind: string | null,
+  dragKey: string | null,
+  dragFromGroup: string | null,
+  fullscreen: boolean,
+): LayoutNode | null {
+  if (!layout || fullscreen) return layout;
+  if (dragKind !== "tab" || !dragKey || !dragFromGroup) return layout;
+  const src = findGroup(layout, dragFromGroup);
+  if (!src || src.tabKeys.length !== 1 || src.tabKeys[0] !== dragKey) return layout;
+  // Don't collapse the only subwindow — there's no sibling to expand into, and
+  // the placeholder/empty-state would flicker for the duration of the drag.
+  if (allGroups(layout).length <= 1) return layout;
+  return removeNodeById(layout, dragFromGroup) ?? layout;
+}
diff --git a/src/components/tabs/newTabItems.ts b/src/components/tabs/newTabItems.ts
new file mode 100644
index 0000000..d285e5f
--- /dev/null
+++ b/src/components/tabs/newTabItems.ts
@@ -0,0 +1,197 @@
+import {
+  FILES_TAB_CMD,
+  RESUMABLE_AGENTS,
+  TabEntry,
+  TabKind,
+} from "../../stores/tabs";
+import type { CustomAgent } from "../../types";
+import type { AddMenuEntry } from "./AddTabMenuList";
+
+/**
+ * A static entry in the "new tab" add menu. Shared by the main-window `TabBar`
+ * and the detached popout's own add menu so both draw from one source of truth.
+ */
+export interface StaticMenuItem {
+  label: string;
+  cmd: string;
+  kind: TabKind;
+  // Launch args, prepended before any session/resume args. Only custom agents
+  // set this today; the built-in AGENT_ITEMS take no leading args.
+  args?: string[];
+  env?: Record<string, string>;
+  // For a custom agent whose spec supplied a "continue last session" flag: the
+  // args that make the tab restart-resumable (cwd-continue tier). Threaded onto
+  // the tab as `resumeArgs`; see buildStaticTabSpec / isResumableAgentTab.
+  resumeArgs?: string[];
+  // Optional template for a command typed into the agent on launch to name its
+  // own session after the project. Only set for agents with a known
+  // session-rename command; others are skipped to avoid typing junk into them.
+  sessionRename?: (projectName: string) => string;
+  // When set, Eldrun mints a UUID at launch and passes it to the agent so it
+  // owns a deterministic session id (e.g. Claude's `--session-id <uuid>`). The
+  // returned strings are appended to the spawn args. Lets us surface the
+  // session id on hover and later resume the session.
+  sessionIdArgs?: (uuid: string) => string[];
+}
+
+// Only Claude and Gemini accept a caller-supplied session UUID at launch
+// (both via `--session-id <uuid>`), so only those get `sessionIdArgs`. Codex
+// (`codex resume <id>`) and Mistral/vibe (`--resume [id]`) mint their own ids
+// and only accept one when resuming, so there's no deterministic id to capture
+// up front — passing `--session-id` would just error and break the tab.
+export const AGENT_ITEMS: StaticMenuItem[] = [
+  { label: "Claude",   cmd: "claude",       kind: "agent", sessionRename: (n) => `/rename ${n}`, sessionIdArgs: (id) => ["--session-id", id] },
+  { label: "Codex",    cmd: "codex",        kind: "agent" },
+  { label: "Gemini",   cmd: "gemini",       kind: "agent", sessionIdArgs: (id) => ["--session-id", id] },
+  { label: "Mistral",  cmd: "vibe",         kind: "agent" },
+  { label: "Aider",    cmd: "aider",        kind: "agent" },
+  { label: "OpenCode", cmd: "opencode",     kind: "agent" },
+  { label: "Cursor",   cmd: "cursor-agent", kind: "agent" },
+  { label: "Copilot",  cmd: "copilot",      kind: "agent" },
+  { label: "Grok",     cmd: "grok",         kind: "agent" },
+  { label: "Qwen",     cmd: "qwen",         kind: "agent" },
+  { label: "OpenClaw", cmd: "openclaw",     kind: "agent" },
+];
+
+export const SHELL_ITEMS: StaticMenuItem[] = [
+  // Empty cmd → backend `default_shell()` picks the OS-appropriate shell
+  // (cmd.exe on Windows, zsh on macOS, bash on Linux). Hardcoding "bash" here
+  // fails to spawn on Windows where bash isn't on PATH.
+  { label: "Shell", cmd: "",              kind: "shell" },
+  { label: "Files", cmd: FILES_TAB_CMD,   kind: "files" },
+];
+
+/** The pure-frontend file panes kept to one tab per cwd (see TabBar.handleAdd).
+ *  "projectfiles" is no longer offered as a standalone new-tab entry (it merely
+ *  duplicated the right panel), but the kind still exists — a folder's "Open in
+ *  a new tab" action creates one, and persisted ones restore — so it stays in
+ *  the dedup predicate. */
+export function isFileTabKind(kind: TabKind): boolean {
+  return kind === "files" || kind === "projectfiles";
+}
+
+// Re-exported so both menus reference the same dot-accent palette.
+export const TAB_ACCENT: Record<TabKind, string> = {
+  agent: "var(--accent)",
+  local_agent: "var(--warning)",
+  shell: "var(--success)",
+  files: "var(--text-muted)",
+  projectfiles: "var(--text-muted)",
+  embed: "var(--info, #4aa3df)",
+  projects3d: "var(--accent-secondary)",
+  network: "var(--info, #4aa3df)",
+  monitor: "var(--success, #3fb950)",
+  diskusage: "var(--warning, #e3b341)",
+  calendar: "var(--accent)",
+};
+
+/**
+ * Build the full tab payload (minus the store-minted `key`) for a static
+ * agent/shell menu item. Mirrors the main-window `TabBar.handleAdd`: for
+ * resumable agents it mints a session UUID + `ELDRUN_TAB_UID`, threads
+ * `sessionIdArgs` into the launch args, and derives the session-rename input.
+ * Pure aside from `crypto.randomUUID`, so both the main and detached add menus
+ * produce identical specs.
+ */
+export function buildStaticTabSpec(
+  item: StaticMenuItem,
+  projectCwd: string,
+  projectName: string,
+): Omit<TabEntry, "key"> {
+  const initialInput =
+    item.sessionRename && projectName ? item.sessionRename(projectName) : undefined;
+  // "Resumable" now spans a built-in in the static table AND a custom agent that
+  // brought its own resume flag — both mint a session UUID so they satisfy the
+  // tab-persistence gate (isResumableAgentTab requires a sessionId).
+  const resumable = item.cmd in RESUMABLE_AGENTS || !!item.resumeArgs?.length;
+  const sessionId =
+    resumable || item.sessionIdArgs ? crypto.randomUUID() : undefined;
+  const args = [
+    ...(item.args ?? []),
+    ...(sessionId && item.sessionIdArgs ? item.sessionIdArgs(sessionId) : []),
+  ];
+  const env = {
+    ...(item.env ?? {}),
+    ...(resumable && sessionId ? { ELDRUN_TAB_UID: sessionId } : {}),
+  };
+  return {
+    label: item.label,
+    cmd: item.cmd,
+    args,
+    env,
+    cwd: projectCwd,
+    kind: item.kind,
+    initialInput,
+    sessionId,
+    ...(item.resumeArgs?.length ? { resumeArgs: item.resumeArgs } : {}),
+  };
+}
+
+/** Stable empty custom-agent array, so a settings selector's `?? …` fallback
+ *  keeps a constant reference (a fresh `[]` each render would loop the probe
+ *  effect that depends on it). */
+export const EMPTY_CUSTOM_AGENTS: CustomAgent[] = [];
+
+/** Adapt a persisted {@link CustomAgent} into a menu item so it launches through
+ *  the same `buildStaticTabSpec` path as the built-in agents. */
+export function customAgentToItem(ca: CustomAgent): StaticMenuItem {
+  return {
+    label: ca.label,
+    cmd: ca.cmd,
+    kind: "agent",
+    args: ca.args,
+    env: ca.env,
+    resumeArgs: ca.resumeArgs,
+  };
+}
+
+/**
+ * Build the "Agents" group's rows for the add-tab menu, shared by the main-window
+ * `TabBar` and the popout's `NewTabMenu` so both list agents identically:
+ *   1. built-in agents whose binary is installed (`installedBuiltins`),
+ *   2. every custom agent — greyed with a "(not found)" suffix when its command
+ *      is known-missing (`installedCmds` resolved and lacking it), since the user
+ *      added it deliberately and silently dropping it would be baffling,
+ *   3. the "＋ Add agent…" row that opens the manage-agents dialog.
+ *
+ * `installedBuiltins`/`installedCmds` are `null` until their probes resolve, so
+ * built-ins render nothing (no flash of all agents) while custom agents — which
+ * the user typed themselves — render enabled until a probe proves one missing.
+ */
+export function agentMenuEntries(opts: {
+  installedBuiltins: Set<string> | null;
+  installedCmds: Set<string> | null;
+  customAgents: CustomAgent[];
+  pick: (item: StaticMenuItem) => void;
+  onAddCustom: () => void;
+}): AddMenuEntry[] {
+  const builtins = AGENT_ITEMS.filter((item) =>
+    opts.installedBuiltins?.has(item.cmd),
+  ).map((item) => ({
+    key: item.cmd,
+    label: item.label,
+    color: TAB_ACCENT[item.kind],
+    onPick: () => opts.pick(item),
+  }));
+  const custom = opts.customAgents.map((ca) => {
+    const missing = opts.installedCmds != null && !opts.installedCmds.has(ca.cmd);
+    return {
+      key: `custom:${ca.id}`,
+      label: missing ? `${ca.label} (not found)` : ca.label,
+      color: TAB_ACCENT.agent,
+      disabled: missing,
+      onPick: () => opts.pick(customAgentToItem(ca)),
+    };
+  });
+  return [
+    ...builtins,
+    ...custom,
+    {
+      key: "__add_custom_agent__",
+      label: "Add agent…",
+      dot: "＋",
+      color: "var(--text-muted)",
+      onPick: opts.onAddCustom,
+    },
+  ];
+}
diff --git a/src/components/terminal/TerminalView.tsx b/src/components/terminal/TerminalView.tsx
index f181bd8..87473f9 100644
--- a/src/components/terminal/TerminalView.tsx
+++ b/src/components/terminal/TerminalView.tsx
@@ -3,9 +3,15 @@ import { Terminal } from "@xterm/xterm";
 import { FitAddon } from "@xterm/addon-fit";
 import { WebLinksAddon } from "@xterm/addon-web-links";
 import { invoke } from "@tauri-apps/api/core";
-import { listen, Event } from "@tauri-apps/api/event";
 import { useSettingsStore } from "../../stores/settings";
-import { isDetachedPtyId } from "../../stores/tabs";
+import { cmdToKind, isDetachedPtyId, type TabKind } from "../../stores/tabs";
+import { notePtySpawn, noteUserInput, splitPtyId, useActivityStore } from "../../stores/activity";
+import { useAgentTaskStore } from "../../stores/agentTask";
+import { noteInput } from "../../lib/promptCount";
+import { METRIC, agentPromptLeaf, sub } from "../../lib/usageMetrics";
+import { ROOT_SCOPE, bumpUsage, markAgentActive } from "../../stores/usage";
+import { onTerminalExit, onTerminalOutput, onTerminalReady } from "../../lib/terminalBus";
+import { claimInitialInput, initialInputForPty, isTerminalIdentityResponse } from "../../lib/terminalControl";
 import "@xterm/xterm/css/xterm.css";
 
 // Hoisted to module scope: keystroke input fires this on every key, so we reuse
@@ -14,16 +20,6 @@ import "@xterm/xterm/css/xterm.css";
 // arrays to a `Vec<u8>` command directly), avoiding the per-key `Array.from`.
 const PTY_ENCODER = new TextEncoder();
 
-interface TerminalOutput {
-  id: string;
-  data: string;
-}
-
-interface TerminalExit {
-  id: string;
-  code: number | null;
-}
-
 interface Props {
   id: string;
   cmd: string;
@@ -34,6 +30,26 @@ interface Props {
   // When true, never run this tab over ssh even for remote projects (e.g.
   // locally-bound Ollama agents). Forwarded to the backend spawn.
   localOnly?: boolean;
+  // When true, run this (agent) tab inside a Docker sandbox that mounts only the
+  // project dir. Set only for agent tabs of a sandbox-enabled local project.
+  sandbox?: boolean;
+  // The owning project's id for a project-scope tab (null/undefined for the root
+  // scope and connection terminals). Forwarded to the backend spawn so it can
+  // detect remoteness explicitly (resolve the project's RemoteSpec) instead of
+  // sniffing the cwd. Harmless for local projects — they resolve to no remote.
+  projectId?: string | null;
+  // Which of the project's remote hosts this tab runs on (multi-host remote,
+  // `docs/multi_host_remote_plan.md`): "primary" / undefined for the primary
+  // remote, a worker id for a `host:<id>` locality. Forwarded to the backend so
+  // it resolves the right worker's RemoteSpec. Ignored for local projects/tabs.
+  remoteHostId?: string | null;
+  // Persistent remote sessions (TODO #85): the stable tmux session name to spawn-
+  // or-attach this remote spawn into, so the run survives an SSH drop / relaunch.
+  // Set only for remote shell/script tabs of a persist-enabled project. No-op locally.
+  tmuxSession?: string | null;
+  // Attach this tab to an existing named tmux session instead of spawning one
+  // (TODO #85 Sessions view). Takes precedence over `tmuxSession`. No-op locally.
+  tmuxAttach?: string | null;
   // Whether this pane is laid out on screen (single-mode active tab, or any
   // pane in grid mode). Drives display + xterm fit.
   visible: boolean;
@@ -46,9 +62,55 @@ interface Props {
   // unmount (the main window's still-mounted pane owns the PTY lifetime). Such a
   // terminal opens blank and only shows output produced AFTER it attached.
   attachOnly?: boolean;
+  // When true (agent tabs), the pane is font-zoomable: Ctrl+wheel and
+  // Ctrl +/-/0 scale the font, with the level shared across all agent panes.
+  zoomable?: boolean;
+  // When true, do NOT kill the PTY when this view unmounts. Used by the
+  // non-headless connection terminals embedded in the project dialog: the
+  // OpenVPN/SSH login they run must outlive the dialog (the new project relies
+  // on the tunnel/master being up), so closing the dialog leaves the PTY
+  // running rather than tearing the connection down. This view owns the PTY
+  // (it spawns it, unlike `attachOnly`), it just declines to reap it on unmount.
+  persistOnUnmount?: boolean;
 }
 
 function terminalTheme(scheme: string | undefined) {
+  if (scheme === "light_lavender") {
+    // Neutral slots form a wide lavender ramp (not grey) so Claude Code's ANSI
+    // theme reads as lavender with strong contrast: `black` is a deep saturated
+    // lavender for the emphasized sent-message block / removed-diff background,
+    // `brightBlack` a clearly lighter lavender for dimmed previous messages /
+    // added-diff background, and `white` a light lavender for borders/dim text.
+    // The gap between black↔brightBlack↔white is deliberately large so the
+    // states are easy to tell apart. green/red are kept saturated so the +/-
+    // diff markers stay legible on top of the lavender line backgrounds.
+    // selection* + cursorAccent are set (xterm otherwise defaults them to a
+    // blue-grey) so selection/cursor also pick up the lavender hue.
+    return {
+      background: "#faf9fe",
+      foreground: "#2c2348",
+      cursor: "#7c5cdb",
+      cursorAccent: "#faf9fe",
+      selectionBackground: "#dccff2",
+      selectionForeground: "#241d38",
+      black: "#2f2358",
+      red: "#d1242f",
+      green: "#0f5a26",
+      yellow: "#9a6700",
+      blue: "#0969da",
+      magenta: "#7c5cdb",
+      cyan: "#1b7c83",
+      white: "#cbc0ec",
+      brightBlack: "#8878c4",
+      brightRed: "#cf222e",
+      brightGreen: "#1c7a39",
+      brightYellow: "#bf8700",
+      brightBlue: "#0550ae",
+      brightMagenta: "#b48cf0",
+      brightCyan: "#3192aa",
+      brightWhite: "#2c2348",
+    };
+  }
   if (scheme === "light" || scheme === "fancy_light") {
     return {
       background: "#ffffff",
@@ -102,7 +164,33 @@ function terminalTheme(scheme: string | undefined) {
 // scrollback on flush anyway.
 const PENDING_OUTPUT_CAP = 1_000_000;
 
-export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd, localOnly = false, visible, focused, attachOnly = false }: Props) {
+// Agent-terminal zoom. Agent TUIs (Claude, Codex, …) render dense layouts, so
+// zoomable agent panes let the user scale the font with Ctrl+wheel / Ctrl +/-/0.
+// The chosen size is a single global preference (one knob for every agent pane),
+// persisted in localStorage — mirrors the view-pref pattern used by FileTree /
+// GitHistory — and broadcast on a window event so all open agent panes restyle
+// live, not just the one being scrolled. Non-agent shells keep the fixed default.
+const AGENT_FONT_KEY = "eldrun.agentTermFontSize";
+const AGENT_ZOOM_EVENT = "eldrun-agent-zoom";
+const DEFAULT_FONT_SIZE = 13;
+const MIN_FONT_SIZE = 8;
+const MAX_FONT_SIZE = 32;
+
+function clampFontSize(n: number): number {
+  return Math.max(MIN_FONT_SIZE, Math.min(MAX_FONT_SIZE, Math.round(n)));
+}
+
+function readAgentFontSize(): number {
+  try {
+    const raw = localStorage.getItem(AGENT_FONT_KEY);
+    if (raw) return clampFontSize(parseInt(raw, 10) || DEFAULT_FONT_SIZE);
+  } catch {
+    /* ignore storage failures */
+  }
+  return DEFAULT_FONT_SIZE;
+}
+
+export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd, localOnly = false, sandbox = false, projectId = null, remoteHostId = null, tmuxSession = null, tmuxAttach = null, visible, focused, attachOnly = false, zoomable = false, persistOnUnmount = false }: Props) {
   const colorScheme = useSettingsStore((s) => s.settings?.color_scheme);
   const containerRef = useRef<HTMLDivElement>(null);
   const termRef = useRef<Terminal | null>(null);
@@ -111,7 +199,9 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
   const unlistenReady = useRef<(() => void) | null>(null);
   const unlistenExit = useRef<(() => void) | null>(null);
   const initialInputSent = useRef(false);
+  const initialInputPending = useRef(false);
   const initialEnterTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const openWatchTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
   const firstOutputAt = useRef<number | null>(null);
   // xterm crashes if opened/written into a zero-size or display:none element
   // (its renderer never initializes, so syncScrollArea dereferences undefined).
@@ -126,19 +216,33 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
   const focusedRef = useRef(focused);
   visibleRef.current = visible;
   focusedRef.current = focused;
+  // The live colour scheme, readable from inside the spawn effect without being
+  // one of its deps — that effect owns the PTY, so listing `colorScheme` there
+  // would respawn every terminal on a theme change. `tryOpen` reads it to adopt
+  // whatever the scheme became while the pane was still closed.
+  const colorSchemeRef = useRef(colorScheme);
+  colorSchemeRef.current = colorScheme;
   const argsKey = JSON.stringify(args);
   const envKey = JSON.stringify(env);
 
   useEffect(() => {
     if (!containerRef.current) return;
     let cancelled = false;
+    initialInputSent.current = false;
+    initialInputPending.current = !!initialInput;
 
     const term = new Terminal({
       scrollback: 5000,
       allowProposedApi: false,
       cursorBlink: true,
-      fontSize: 13,
-      fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace",
+      fontSize: zoomable ? readAgentFontSize() : DEFAULT_FONT_SIZE,
+      // 'JetBrains Mono Variable' is bundled (fontsource, imported in main.tsx)
+      // so it's always available; the rest of the stack is the fallback for a
+      // renderer that can't load it — Consolas/Cascadia Mono are the guaranteed
+      // Windows monospace fonts, kept ahead of the generic fallback so the
+      // terminal isn't a bitmap font there.
+      fontFamily:
+        "'JetBrains Mono Variable', 'JetBrains Mono', 'Fira Code', 'Cascadia Code', 'Cascadia Mono', Consolas, Menlo, monospace",
       theme: terminalTheme(colorScheme),
     });
 
@@ -181,6 +285,12 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
       if (!visibleRef.current || !hasLayout() || !containerRef.current) return;
       term.open(containerRef.current);
       openedRef.current = true;
+      // Adopt the current scheme now that there is a renderer to take it. The
+      // terminal was constructed with whatever `colorScheme` was at setup — which
+      // is `undefined` on a cold start, since settings load asynchronously — and
+      // the theme effect deliberately skips a closed terminal, so without this a
+      // pane opened after the settings landed would keep the fallback theme.
+      term.options.theme = terminalTheme(colorSchemeRef.current);
       fit.fit();
       if (pendingOutput.current) {
         term.write(pendingOutput.current);
@@ -198,91 +308,271 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
       document.fonts?.ready?.then(() => { if (!cancelled) doFitRef.current?.(); }).catch(() => {});
     };
 
-    // Wire keyboard input → PTY write.
+    // What this tab counts as for the usage recap. A `local_agent` tab always
+    // carries its model in the env Eldrun spawned it with, and that is the only
+    // signal here that distinguishes it from the cloud agent of the same command
+    // (a local model driven through `vibe` still has cmd "vibe") — TerminalView
+    // is handed cmd/env, not the TabEntry's kind.
+    const localModel = env.ELDRUN_LOCAL_MODEL || env.VIBE_ACTIVE_MODEL;
+    const kind: TabKind = localModel ? "local_agent" : cmdToKind(cmd);
+    const agentLeaf = agentPromptLeaf({ kind, cmd, env });
+    // A shell tab can be RESUMED with no initialInput to type — a tmux reattach on
+    // reconnect/relaunch. tmux probes the outer terminal on attach (secondary DA,
+    // `ESC[>c`); xterm's reply arrives after tmux has handed the pane to the shell,
+    // so it lands in readline as `^[[>0;276;0c`. Open the same startup-suppression
+    // window (line 226 only opens it for an auto-run tab) for ANY shell tab, closed
+    // on the first real keystroke in onData below — so the reattach junk is eaten
+    // but a program the user later launches still gets its own identity replies.
+    if (kind === "shell") initialInputPending.current = true;
+    const scope = splitPtyId(id)?.scope ?? ROOT_SCOPE;
+
+    /** One thing asked: a prompt to an agent, or a command in a shell. */
+    const countSubmit = () => {
+      if (agentLeaf) {
+        bumpUsage(scope, sub(METRIC.AGENT_PROMPT, agentLeaf));
+        // "Agent tabs you used today" — once per tab per day, however much you
+        // then ask it.
+        markAgentActive(scope, id, sub(METRIC.AGENT_ACTIVE, agentLeaf));
+      } else if (kind === "shell") {
+        bumpUsage(scope, METRIC.SHELL_COMMAND);
+      }
+    };
+
+    // Wire keyboard input → PTY write. The input stamp is what licenses this
+    // tab's later output to show as "working"/"done" (see noteUserInput).
+    //
+    // This is also the one place Eldrun sees everything the user asks an agent,
+    // so the usage recap's "you asked them N things" is counted here (see
+    // lib/promptCount): Enter with content pending = one submit.
     term.onData((data) => {
+      if (initialInputPending.current && isTerminalIdentityResponse(data)) {
+        return; // swallow the startup / tmux-reattach identity reply (see above)
+      }
+      // A genuine user keystroke — a printable char or Enter, i.e. NOT an
+      // ESC-prefixed control — closes the identity-suppression window. Terminal
+      // auto-reports (cursor-position `\x1b[…R`, other DA replies) are ALSO delivered
+      // through onData and are ESC-prefixed; they must NOT lift the gate, or a late
+      // DA2 reply arriving on the tmux-attach probe burst right after one of them
+      // would leak to the shell prompt as `^[[>0;276;0c` (the resume bug). A program
+      // that needs DA detection is launched by keystrokes, which close the window
+      // first, so its own replies still flow through.
+      if (initialInputPending.current && data && !data.startsWith("\x1b")) {
+        initialInputPending.current = false;
+      }
+      noteUserInput(id);
+      if (noteInput(id, data) > 0) countSubmit();
       invoke("pty_write", { id, data: PTY_ENCODER.encode(data) }).catch(console.error);
     });
 
-    const setupAndSpawn = async () => {
-      const outputListener = await listen<TerminalOutput>(
-        "terminal-output",
-        (ev: Event<TerminalOutput>) => {
-          if (ev.payload.id === id) {
-            // Record when the spawned program first produces output — used to
-            // tell when an agent TUI has actually started so we don't type the
-            // initialInput before it can accept keystrokes (see below).
-            if (firstOutputAt.current === null) firstOutputAt.current = Date.now();
-            writeTerm(ev.payload.data);
-          }
-        },
-      );
+    // A terminal bell means the agent wants to be looked at NOW, so it shortcuts
+    // the quiet window the activity store otherwise waits out before calling a
+    // turn finished. It is only a hint, never the source of truth: agents ring it
+    // optionally, and a pane that has never been opened has no xterm to parse it
+    // at all. WHAT the agent wants (a decision vs a finished turn) is worked out
+    // in the store from the raw output tail — reading the screen here would race
+    // the paint, since onBell fires as xterm parses the BEL, before the prompt
+    // that follows it in the same chunk has landed in the buffer.
+    // xterm fires this only for a real BEL control, not an OSC title terminator,
+    // so title changes don't false-trigger. Disposed with `term` on unmount.
+    term.onBell(() => {
+      useActivityStore.getState().noteBell(id);
+    });
 
-      const readyListener = await listen("terminal-ready", (ev: Event<{ id: string }>) => {
-        if (ev.payload.id === id) {
-          writeTerm("\r\n");
-          if (initialInput && !initialInputSent.current) {
-            initialInputSent.current = true;
-            // `terminal-ready` fires as soon as the PTY is spawned, but an agent
-            // TUI (Claude, etc.) needs a beat to boot before it reads stdin.
-            // Typing the command immediately means the keystrokes/Enter land
-            // before the input box is live, so the text appears but never
-            // submits. Wait until the program has produced output for a short
-            // cushion (boot done) — capped by a hard timeout — then type the
-            // text and submit it with a single Enter (CR) a beat later, as a
-            // separate write so a trailing newline isn't swallowed by the TUI's
-            // bracketed-paste/buffered input handling.
-            const READY_CUSHION_MS = 1200;
-            const MAX_WAIT_MS = 5000;
-            const scheduledAt = Date.now();
-            const typeWhenReady = () => {
-              if (cancelled) return;
-              const elapsed = Date.now() - scheduledAt;
-              const firstOut = firstOutputAt.current;
-              const ready =
-                firstOut !== null && Date.now() - firstOut >= READY_CUSHION_MS;
-              if (!ready && elapsed < MAX_WAIT_MS) {
-                initialEnterTimer.current = setTimeout(typeWhenReady, 100);
-                return;
-              }
-              invoke("pty_write", { id, data: PTY_ENCODER.encode(initialInput) }).catch(console.error);
-              initialEnterTimer.current = setTimeout(() => {
-                invoke("pty_write", { id, data: new Uint8Array([0x0d]) }).catch(console.error);
-              }, 200);
-            };
-            typeWhenReady();
-          }
+    // OSC 52 clipboard write: TUIs (Claude Code's own copy action among them)
+    // set the system clipboard by writing `ESC ] 52 ; c ; <base64> BEL/ST`
+    // rather than relying on a host-side mouse selection — the standard escape
+    // for "copy this over SSH/tmux where the program can't reach the clipboard
+    // itself". xterm parses OSC codes but performs no action on 52 without a
+    // handler, so the CLI reports success (it only confirms the write *reached
+    // the terminal*) while the OS clipboard silently keeps its old contents.
+    // `c` is the only target register Eldrun has one clipboard for; a `?`
+    // query (read-back) is intentionally left unhandled — implementing it would
+    // let any program read whatever the user last copied elsewhere.
+    const oscHandler = term.parser.registerOscHandler(52, (data) => {
+      const parts = data.split(";");
+      // Pc (parts[0]) names the target selection buffer(s) — "c" (clipboard),
+      // "" (spec default, also clipboard), or a combination like "cp"/"cs"
+      // that includes clipboard alongside primary/select. Anything without
+      // "c" (e.g. a primary-selection-only "p") isn't Eldrun's one clipboard.
+      if (parts.length < 2 || (parts[0] !== "" && !parts[0].includes("c")) || parts[1] === "?") return true;
+      try {
+        const binary = atob(parts[1]);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+        const text = new TextDecoder("utf-8").decode(bytes);
+        navigator.clipboard?.writeText(text).catch(() => {});
+      } catch {
+        /* malformed OSC 52 payload — ignore rather than surface a write error */
+      }
+      return true;
+    });
+
+    // Copy-on-select: a mouse-made selection (drag, double/triple-click) copies
+    // itself to the clipboard with no chord needed, matching most native
+    // terminals. Debounced so a drag firing onSelectionChange on every cell it
+    // crosses doesn't issue a clipboard write per event — only once ~60ms after
+    // the selection settles. Ctrl+Shift+C below stays as the explicit fallback
+    // (e.g. a selection made without the mouse never fires this).
+    let selectionCopyTimer: ReturnType<typeof setTimeout> | null = null;
+    term.onSelectionChange(() => {
+      const sel = term.getSelection();
+      if (!sel) return;
+      if (selectionCopyTimer) clearTimeout(selectionCopyTimer);
+      selectionCopyTimer = setTimeout(() => {
+        navigator.clipboard?.writeText(sel).catch(() => {});
+      }, 60);
+    });
+
+    // Agent CLIs set the terminal title (OSC 0/2) to a short summary of what
+    // they're doing — the same signal a native terminal shows in its tab. Capture
+    // it per tab so the tab hover card can surface it as the agent task summary.
+    // Disposed with `term` on unmount.
+    term.onTitleChange((title) => {
+      useAgentTaskStore.getState().setTabTitle(id, title);
+    });
+
+    // Copy/paste: xterm binds neither itself, so without this the terminal has no
+    // way to copy a selection (the agent-terminal "can't copy" report). Use the
+    // standard terminal chords — Ctrl+Shift+C copies the current selection, Ctrl+
+    // Shift+V pastes clipboard text into the PTY — and deliberately leave plain
+    // Ctrl+C alone so it still sends SIGINT to the running program (interrupting
+    // an agent). Returning false swallows the chord so xterm doesn't also forward
+    // it to the PTY as a control sequence.
+    // Apply a new font size to this pane and (when `persist`) save + broadcast it
+    // so every other open agent pane restyles to match. Refit on the next frame:
+    // xterm needs a beat to re-measure the cell after fontSize changes before
+    // FitAddon can read the new geometry.
+    const applyFontSize = (size: number, persist: boolean) => {
+      const next = clampFontSize(size);
+      if (next !== term.options.fontSize) {
+        term.options.fontSize = next;
+        requestAnimationFrame(() => { if (!cancelled) doFitRef.current?.(); });
+      }
+      if (persist) {
+        try {
+          localStorage.setItem(AGENT_FONT_KEY, String(next));
+        } catch {
+          /* ignore storage failures */
         }
-      });
+        window.dispatchEvent(new CustomEvent<number>(AGENT_ZOOM_EVENT, { detail: next }));
+      }
+    };
 
-      const exitListener = await listen<TerminalExit>(
-        "terminal-exit",
-        (ev: Event<TerminalExit>) => {
-          if (ev.payload.id === id) {
-            writeTerm("\r\n\x1b[33m[process exited]\x1b[0m\r\n");
-          }
-        },
-      );
+    term.attachCustomKeyEventHandler((e) => {
+      if (e.type !== "keydown") return true;
+      // Ctrl +/-/0 zoom (agent panes only). preventDefault stops WebKit's own
+      // page-zoom; returning false stops xterm forwarding the chord to the PTY;
+      // stopPropagation stops the WINDOW-level per-window zoom handler (useKeyboard
+      // / DetachedApp) from ALSO webview-zooming — an agent pane zooms its FONT, not
+      // the whole window.
+      if (zoomable && (e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey) {
+        const cur = term.options.fontSize ?? DEFAULT_FONT_SIZE;
+        if (e.code === "Equal") { e.preventDefault(); e.stopPropagation(); applyFontSize(cur + 1, true); return false; }
+        if (e.code === "Minus") { e.preventDefault(); e.stopPropagation(); applyFontSize(cur - 1, true); return false; }
+        if (e.code === "Digit0") { e.preventDefault(); e.stopPropagation(); applyFontSize(DEFAULT_FONT_SIZE, true); return false; }
+      }
+      if (!e.ctrlKey || !e.shiftKey) return true;
+      if (e.code === "KeyC") {
+        const sel = term.getSelection();
+        if (sel) navigator.clipboard?.writeText(sel).catch(() => {});
+        return false;
+      }
+      if (e.code === "KeyV") {
+        navigator.clipboard
+          ?.readText()
+          .then((text) => {
+            if (text) {
+              noteUserInput(id);
+              invoke("pty_write", { id, data: PTY_ENCODER.encode(text) }).catch(console.error);
+            }
+          })
+          .catch(() => {});
+        return false;
+      }
+      return true;
+    });
 
-      if (cancelled) {
-        outputListener();
-        readyListener();
-        exitListener();
-        return;
+    // Subscribed by id through the shared bus (lib/terminalBus) rather than each
+    // pane calling `listen()` itself — the backend emits these window-wide, not
+    // scoped per PTY, so one `listen()` per mounted terminal meant every output
+    // chunk from every running PTY was dispatched to and filtered by every
+    // mounted terminal (CenterPanel keeps ALL tabs, ALL scopes, mounted forever).
+    // The bus does that dispatch once, in O(1) per id, no matter how many panes
+    // are mounted. Subscribing is synchronous, so these are wired up before
+    // `setupAndSpawn` below ever awaits `pty_spawn` — no output can arrive first.
+    unlistenOutput.current = onTerminalOutput(id, (data) => {
+      // Record when the spawned program first produces output — used to tell
+      // when an agent TUI has actually started so we don't type the
+      // initialInput before it can accept keystrokes (see below).
+      if (firstOutputAt.current === null) firstOutputAt.current = Date.now();
+      writeTerm(data);
+    });
+
+    unlistenReady.current = onTerminalReady(id, () => {
+      writeTerm("\r\n");
+      if (initialInput && !initialInputSent.current) {
+        if (!claimInitialInput(id, initialInput)) {
+          initialInputSent.current = true;
+          initialInputPending.current = false;
+          return;
+        }
+        initialInputSent.current = true;
+        // `terminal-ready` fires as soon as the PTY is spawned, but an agent
+        // TUI (Claude, etc.) needs a beat to boot before it reads stdin.
+        // Typing the command immediately means the keystrokes/Enter land
+        // before the input box is live, so the text appears but never
+        // submits. Wait until the program has produced output for a short
+        // cushion (boot done) — capped by a hard timeout — then type the
+        // text and submit it with a single Enter (CR) a beat later, as a
+        // separate write so a trailing newline isn't swallowed by the TUI's
+        // bracketed-paste/buffered input handling.
+        const READY_CUSHION_MS = 1200;
+        const MAX_WAIT_MS = 5000;
+        const scheduledAt = Date.now();
+        const typeWhenReady = () => {
+          if (cancelled) return;
+          const elapsed = Date.now() - scheduledAt;
+          const firstOut = firstOutputAt.current;
+          const ready =
+            firstOut !== null && Date.now() - firstOut >= READY_CUSHION_MS;
+          if (!ready && elapsed < MAX_WAIT_MS) {
+            initialEnterTimer.current = setTimeout(typeWhenReady, 100);
+            return;
+          }
+          // Typed on the user's behalf — they triggered the flow that
+          // opened this tab with a command, so its work counts as asked-for.
+          noteUserInput(id);
+          invoke("pty_write", {
+            id,
+            data: PTY_ENCODER.encode(initialInputForPty(initialInput, kind)),
+          }).catch(console.error);
+          initialEnterTimer.current = setTimeout(() => {
+            initialInputPending.current = false;
+            invoke("pty_write", { id, data: new Uint8Array([0x0d]) }).catch(console.error);
+          }, 200);
+        };
+        typeWhenReady();
       }
+    });
 
-      unlistenOutput.current = outputListener;
-      unlistenReady.current = readyListener;
-      unlistenExit.current = exitListener;
+    unlistenExit.current = onTerminalExit(id, () => {
+      writeTerm("\r\n\x1b[33m[process exited]\x1b[0m\r\n");
+    });
 
+    const setupAndSpawn = async () => {
       // #42: an attach-only terminal (detached window) must NEVER spawn the PTY.
       // The PTY already exists, spawned by the main window's pane; pty_spawn with
       // a duplicate id would kill+respawn it, destroying scrollback / the agent
       // session. We only subscribe to the broadcast output/input by id.
       if (attachOnly) return;
 
+      // A (re)spawn is a new program: wipe what the activity store recorded
+      // about the previous occupant of this id, so a reopened project's resume
+      // replay can't ride an old input stamp into a "working"/"done" glow.
+      notePtySpawn(id);
       try {
         await invoke("pty_spawn", {
-          opts: { id, cmd, args, env, cwd, cols: term.cols, rows: term.rows, local_only: localOnly },
+          opts: { id, cmd, args, env, cwd, cols: term.cols, rows: term.rows, local_only: localOnly, sandbox, project_id: projectId ?? null, remote_host_id: remoteHostId ?? null, tmux_session: tmuxSession ?? null, tmux_attach: tmuxAttach ?? null },
         });
       } catch (e) {
         if (!cancelled) {
@@ -319,10 +609,61 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
     // for viewport-level changes (maximize, fullscreen toggle).
     window.addEventListener("resize", doFit);
 
+    // Open watchdog (the "black agent tab" gate, esp. Windows/WebView2).
+    // tryOpen() only runs from the ResizeObserver and the `visible` effect. When
+    // a pane goes display:none → flex while `visible` was already true, the only
+    // trigger is the ResizeObserver firing on that box change — and WebView2
+    // occasionally drops that callback. The PTY has already spawned and is
+    // buffering its output into pendingOutput, but xterm never opens, so the
+    // pane stays black AND unresponsive (no open → no focus → keystrokes go
+    // nowhere). This bounded poll guarantees we keep attempting tryOpen while the
+    // pane is visible-but-unopened, so it can never get stuck closed. It costs a
+    // few cheap ticks at mount, stops the instant the terminal opens, and is
+    // capped by a wall-clock deadline so it can't spin forever (a legitimately
+    // hidden pane is opened by the `visible` effect when it is next shown).
+    const OPEN_WATCH_INTERVAL_MS = 150;
+    const OPEN_WATCH_DEADLINE_MS = 8000;
+    const watchStart = Date.now();
+    const watchOpen = () => {
+      openWatchTimer.current = null;
+      if (cancelled || openedRef.current) return;
+      if (visibleRef.current) tryOpen();
+      if (openedRef.current || Date.now() - watchStart >= OPEN_WATCH_DEADLINE_MS) return;
+      openWatchTimer.current = setTimeout(watchOpen, OPEN_WATCH_INTERVAL_MS);
+    };
+    openWatchTimer.current = setTimeout(watchOpen, OPEN_WATCH_INTERVAL_MS);
+
+    // Agent-pane zoom: Ctrl+wheel scales the font; a window event keeps every
+    // other open agent pane in sync with the shared level. Both are no-ops for
+    // non-agent shells. The wheel listener is non-passive so it can preventDefault.
+    const onWheel = (e: WheelEvent) => {
+      if (!e.ctrlKey) return;
+      e.preventDefault();
+      const cur = termRef.current?.options.fontSize ?? DEFAULT_FONT_SIZE;
+      applyFontSize(cur + (e.deltaY < 0 ? 1 : -1), true);
+    };
+    // Typed as the global EventListener because the `Event` identifier is shadowed
+    // here by Tauri's generic Event<T> import.
+    const onZoomEvent: EventListener = (e) => {
+      const size = (e as CustomEvent<number>).detail;
+      if (typeof size === "number") applyFontSize(size, false);
+    };
+    if (zoomable) {
+      containerRef.current?.addEventListener("wheel", onWheel, { passive: false });
+      window.addEventListener(AGENT_ZOOM_EVENT, onZoomEvent);
+    }
+
     return () => {
       cancelled = true;
       if (initialEnterTimer.current) clearTimeout(initialEnterTimer.current);
+      if (openWatchTimer.current) clearTimeout(openWatchTimer.current);
+      if (selectionCopyTimer) clearTimeout(selectionCopyTimer);
+      oscHandler.dispose();
       window.removeEventListener("resize", doFit);
+      if (zoomable) {
+        containerRef.current?.removeEventListener("wheel", onWheel);
+        window.removeEventListener(AGENT_ZOOM_EVENT, onZoomEvent);
+      }
       ro.disconnect();
       doFitRef.current = null;
       unlistenOutput.current?.();
@@ -336,16 +677,50 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
       // unmounting *because its tab was just detached* into a popped-out window
       // (the detached attach-only viewer is now reading this PTY; killing it
       // would leave that window a dead black pane). Only a real close tears it
-      // down.
-      if (!attachOnly && !isDetachedPtyId(id)) {
+      // down. (c) `persistOnUnmount` — a dialog-embedded connection terminal
+      // whose tunnel/login must outlive the dialog.
+      if (!attachOnly && !isDetachedPtyId(id) && !persistOnUnmount) {
         invoke("pty_kill", { id }).catch(() => {});
+        // Drop the captured agent-task title so a closed tab's summary can't
+        // linger against a future tab that reuses the key.
+        const parts = id.split(":");
+        useAgentTaskStore.getState().clearTabTitle(parts.length > 1 ? parts.slice(1).join(":") : id);
       }
       term.dispose();
+      // Retire the lifecycle refs WITH the terminal they describe. Every guard in
+      // this file asks one of these three whether there is a terminal to touch
+      // (`openedRef` in the focus effect, `termRef` in the theme effect, both in
+      // `doFit`), and a disposed xterm answers none of them for itself — it keeps
+      // its object identity while tearing its renderer down, so a call that
+      // arrives afterwards fails inside xterm with
+      // "undefined is not an object (evaluating 'this._renderer.value.dimensions')"
+      // rather than being refused. That is not hypothetical: this effect re-runs
+      // whenever the spawn deps change (an agent mode flip, a container toggle,
+      // a host switch) and unmounts on every tab close, while `colorScheme`,
+      // focus and zoom are all driven from OUTSIDE it — so a theme or focus
+      // change landing in the same tick as a teardown reached a dead terminal.
+      // It was the single most common error in the crash log, thrown on every
+      // launch as restored tabs settled. Clearing here restores the invariant the
+      // guards assume: these refs describe a LIVE terminal or nothing.
+      termRef.current = null;
+      fitRef.current = null;
+      openedRef.current = false;
     };
-  }, [id, cmd, cwd, initialInput, argsKey, envKey, localOnly, attachOnly]);
+  }, [id, cmd, cwd, initialInput, argsKey, envKey, localOnly, sandbox, projectId, remoteHostId, tmuxSession, tmuxAttach, attachOnly, zoomable, persistOnUnmount]);
 
+  // Re-theme a LIVE, OPEN terminal. Both halves of that guard are load-bearing,
+  // and `termRef.current` alone was neither: assigning `options.theme` makes
+  // xterm refresh through its renderer, and the renderer exists only between
+  // `open()` and `dispose()`. Outside that window it throws
+  // "undefined is not an object (evaluating 'this._renderer.value.dimensions')".
+  // The closed case is the one that fired on every launch: `colorScheme` comes
+  // from settings, which load a few seconds AFTER the restored tabs mount, so the
+  // scheme arriving flipped this effect over a whole layout's worth of terminals
+  // that had been constructed but not yet opened (hidden tabs, panes still
+  // waiting on a layout box). `tryOpen` applies the scheme on open instead, so
+  // skipping a closed terminal here costs nothing.
   useEffect(() => {
-    if (termRef.current) {
+    if (openedRef.current && termRef.current) {
       termRef.current.options.theme = terminalTheme(colorScheme);
     }
   }, [colorScheme]);
@@ -373,7 +748,16 @@ export function TerminalView({ id, cmd, args = [], env = {}, initialInput, cwd,
         position: "relative",
         display: "flex",
         flexDirection: "column",
-        background: colorScheme === "light" || colorScheme === "fancy_light" ? "#ffffff" : "#0d1117",
+        // Agent panes get a touch more breathing room on the left and a bit less
+        // on the right (the viewport scrollbar already insets the right edge), so
+        // the text margins read as balanced. FitAddon accounts for this padding.
+        ...(zoomable ? { paddingLeft: 10, paddingRight: 4 } : null),
+        background:
+          colorScheme === "light_lavender"
+            ? "#faf9fe"
+            : colorScheme === "light" || colorScheme === "fancy_light"
+              ? "#ffffff"
+              : "#0d1117",
       }}
     />
   );
diff --git a/src/hooks/useClampToViewport.ts b/src/hooks/useClampToViewport.ts
new file mode 100644
index 0000000..0006a1e
--- /dev/null
+++ b/src/hooks/useClampToViewport.ts
@@ -0,0 +1,33 @@
+import { useLayoutEffect, type RefObject } from "react";
+
+/**
+ * Keeps a fixed-position popup (context menu, dropdown) inside the viewport.
+ * Popups are positioned at a cursor/anchor point and grow right/down, so one
+ * opened near the window's right or bottom edge clips off-screen. Measures
+ * the rendered element once mounted and shifts it back in. Guarded so the
+ * corrective set doesn't loop (it re-runs, finds nothing to fix, stops).
+ */
+export function useClampToViewport<T extends { x: number; y: number }>(
+  ref: RefObject<HTMLElement | null>,
+  pos: T | null,
+  setPos: (updater: (p: T | null) => T | null) => void,
+  margin = 8,
+) {
+  useLayoutEffect(() => {
+    if (!pos) return;
+    const el = ref.current;
+    if (!el) return;
+    const rect = el.getBoundingClientRect();
+    let nx = pos.x;
+    let ny = pos.y;
+    if (rect.right > window.innerWidth - margin) {
+      nx = Math.max(margin, window.innerWidth - margin - rect.width);
+    }
+    if (rect.bottom > window.innerHeight - margin) {
+      ny = Math.max(margin, window.innerHeight - margin - rect.height);
+    }
+    if (nx !== pos.x || ny !== pos.y) {
+      setPos((p) => (p ? { ...p, x: nx, y: ny } : p));
+    }
+  }, [pos, ref, setPos, margin]);
+}
diff --git a/src/hooks/useKeyboard.ts b/src/hooks/useKeyboard.ts
index f06e995..20a3116 100644
--- a/src/hooks/useKeyboard.ts
+++ b/src/hooks/useKeyboard.ts
@@ -1,14 +1,10 @@
 import { useEffect } from "react";
 import { getCurrentWindow } from "@tauri-apps/api/window";
-import {
-  allGroups,
-  findGroup,
-  neighborGroup,
-  useTabsStore,
-  type NavDirection,
-} from "../stores/tabs";
+import { PLATFORM } from "../lib/dragPlatform";
+import { allGroups, findGroup, useTabsStore } from "../stores/tabs";
 import { useProjectsStore } from "../stores/projects";
-import { useSettingsStore } from "../stores/settings";
+import { useSettingsStore, stepZoom } from "../stores/settings";
+import { useSubwindowNavStore } from "../stores/subwindowNav";
 import {
   chordMatches,
   resolveChord,
@@ -21,8 +17,10 @@ interface KeyboardOptions {
 }
 
 /** True when keystrokes belong to a text field (input/textarea/contenteditable)
- *  — we must not steal those for navigation chords. */
-function isEditableTarget(target: EventTarget | null): boolean {
+ *  — we must not steal those for navigation chords. Exported so the detached
+ *  popout's keyboard hook applies the exact same "don't shadow a focused text
+ *  field / xterm textarea" rule as the main window. */
+export function isEditableTarget(target: EventTarget | null): boolean {
   const el = target as HTMLElement | null;
   if (!el) return false;
   const tag = el.tagName;
@@ -34,14 +32,6 @@ function isEditableTarget(target: EventTarget | null): boolean {
   );
 }
 
-/** Focus actions → the direction they move the focused subwindow. */
-const FOCUS_DIR: Record<string, NavDirection> = {
-  focusLeft: "left",
-  focusRight: "right",
-  focusUp: "up",
-  focusDown: "down",
-};
-
 /**
  * #62: fast keyboard navigation across projects / subwindows / tabs, plus an
  * app-internal fullscreen toggle and keyboard close. Chords are deliberately
@@ -49,16 +39,19 @@ const FOCUS_DIR: Record<string, NavDirection> = {
  * shadowed; we only `preventDefault` when we actually act, and never while a
  * text field (e.g. an inline tab rename) is focused.
  *
- * The eight navigation chords are user-rebindable (see `src/lib/shortcuts.ts`
- * and the "Keyboard Shortcuts" settings panel); the defaults below are applied
- * when `settings.keyboard_shortcuts` has no override for an action. F11 (OS
- * fullscreen), Super (panels) and Escape (exit fullscreen) are fixed.
+ * The navigation chords are user-rebindable (see `src/lib/shortcuts.ts` and the
+ * "Keyboard Shortcuts" settings panel); the defaults below are applied when
+ * `settings.keyboard_shortcuts` has no override for an action. F11 (OS
+ * fullscreen), Super/F9 (panels — Super on Linux, F9 on Windows where the lone
+ * Win key belongs to the OS) and Escape (exit fullscreen) are fixed.
  *
  * Default bindings:
  *   - Ctrl+Enter           → toggle fullscreen for the focused subwindow
  *   - Escape               → exit fullscreen (when active) [fixed]
  *   - Shift+Ctrl+Tab       → cycle to the next active project
- *   - Shift+Arrow{L/R/U/D} → focus the neighbouring subwindow in that direction
+ *   - Shift+Left/Right     → previous / next tab within the focused subwindow
+ *   - Shift+Up/Down        → cycle the focused subwindow (numbered preview shown
+ *                            while Shift is held; focus commits on Shift release)
  *   - Shift+Tab            → cycle tabs within the focused subwindow
  *   - Shift+Ctrl+W         → close the focused subwindow
  *   - Ctrl+W               → close the active tab
@@ -68,21 +61,63 @@ export function useKeyboard({ onTogglePanels }: KeyboardOptions) {
     const win = getCurrentWindow();
 
     async function onKeyDown(e: KeyboardEvent) {
-      // F11 — OS fullscreen toggle (unchanged).
+      // F11 — OS fullscreen toggle. On Windows, real fullscreen strips the
+      // window styles that Aero Snap and native title-bar dragging rely on (see
+      // AppShell's startup), so toggle MAXIMIZE there instead — same "fill the
+      // screen" effect, but the window stays snappable/draggable like other apps.
       if (e.key === "F11") {
         e.preventDefault();
-        const isFs = await win.isFullscreen();
-        win.setFullscreen(!isFs);
+        if (PLATFORM === "windows") {
+          if (await win.isMaximized()) win.unmaximize();
+          else win.maximize();
+        } else {
+          const isFs = await win.isFullscreen();
+          win.setFullscreen(!isFs);
+        }
+        return;
+      }
+
+      // Super key — toggle right panel. Linux only: on macOS Cmd reports as
+      // "Meta" and is the platform-primary shortcut modifier (see
+      // shortcuts.chordMatches), so a lone-key toggle would fire on every Cmd+key
+      // chord. On Windows the lone Win key belongs to the OS — the Start menu
+      // opens on key *release* at the shell level and preventDefault() cannot
+      // stop it, and every global Win+X shortcut pressed while Eldrun is focused
+      // fires a lone "Meta" keydown first, spuriously toggling the panels.
+      // Windows therefore uses F9 (below) instead.
+      if (PLATFORM === "linux" && (e.key === "Meta" || e.key === "Super")) {
+        e.preventDefault();
+        onTogglePanels();
         return;
       }
 
-      // Super key — toggle right panel.
-      if (e.key === "Meta" || e.key === "Super") {
+      // F9 — panel toggle on Windows (see above; also harmless elsewhere, but
+      // only advertised on Windows to keep the per-OS onboarding copy simple).
+      if (e.key === "F9") {
         e.preventDefault();
         onTogglePanels();
         return;
       }
 
+      // Ctrl +/- / Ctrl+0 — per-window UI zoom (this is the MAIN window; a popout
+      // handles its own — see DetachedApp). Handled before the editable-target
+      // guard so it works from a focused terminal too (the browser-zoom
+      // convention). Agent panes consume these for font zoom and stopPropagation,
+      // so those never reach here. Persisted to `ui_zoom` (the main window's own
+      // value), which `updateSettings` also re-applies to this webview.
+      if ((e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey) {
+        const cur = useSettingsStore.getState().settings?.ui_zoom;
+        const set1 = (z: number) => {
+          e.preventDefault();
+          void useSettingsStore
+            .getState()
+            .updateSettings({ ui_zoom: z === 1 ? undefined : z });
+        };
+        if (e.code === "Equal") return set1(stepZoom(cur, 1));
+        if (e.code === "Minus") return set1(stepZoom(cur, -1));
+        if (e.code === "Digit0") return set1(1);
+      }
+
       const tabs = useTabsStore.getState();
 
       // Escape exits app-internal fullscreen (when active). Only act if we're
@@ -132,6 +167,30 @@ export function useKeyboard({ onTogglePanels }: KeyboardOptions) {
         return;
       }
 
+      // Hide the focused subwindow (park it in the right-panel Hidden list,
+      // keeping its tabs/PTYs alive). Unlike closeSubwindow this is allowed even
+      // for the last remaining subwindow — hiding it just shows the +-placeholder.
+      if (is("hideSubwindow")) {
+        const focused = tabs.focusedGroupId;
+        if (focused) {
+          e.preventDefault();
+          tabs.hideGroup(focused);
+        }
+        return;
+      }
+
+      // Toggle the focused subwindow's docked file viewer (same flag the ◫
+      // button and the sidebar's resize-edge double-click write).
+      if (is("toggleSubwindowFiles")) {
+        const focused = tabs.focusedGroupId;
+        const group = focused ? findGroup(tabs.layout, focused) : null;
+        if (focused && group) {
+          e.preventDefault();
+          tabs.setGroupFiles(focused, !group.filesOpen);
+        }
+        return;
+      }
+
       // Close the active tab.
       if (is("closeTab")) {
         if (tabs.activeKey) {
@@ -151,39 +210,71 @@ export function useKeyboard({ onTogglePanels }: KeyboardOptions) {
         return;
       }
 
-      // Focus the neighbouring subwindow in a direction.
-      for (const action of Object.keys(FOCUS_DIR) as ShortcutAction[]) {
-        if (is(action)) {
-          const focused = tabs.focusedGroupId;
-          if (focused) {
-            const next = neighborGroup(tabs.layout, focused, FOCUS_DIR[action]);
-            if (next) {
-              e.preventDefault();
-              tabs.focusGroup(next);
-            }
-          }
-          return;
-        }
-      }
-
-      // Cycle tabs within the focused subwindow.
-      if (is("cycleTabs")) {
+      // Previous / next tab within the focused subwindow, and the equivalent
+      // Shift+Tab cycle. All three step the focused group's active tab.
+      const prev = is("prevTab");
+      if (prev || is("nextTab") || is("cycleTabs")) {
         const focused = tabs.focusedGroupId;
         const group = focused ? findGroup(tabs.layout, focused) : null;
         if (group && group.tabKeys.length > 1) {
           e.preventDefault();
+          const len = group.tabKeys.length;
           const cur = group.activeKey
             ? group.tabKeys.indexOf(group.activeKey)
             : 0;
-          const next = group.tabKeys[(cur + 1) % group.tabKeys.length];
+          const delta = prev ? -1 : 1;
+          const next = group.tabKeys[(cur + delta + len) % len];
           tabs.setGroupActive(group.id, next);
         }
         return;
       }
+
+      // Cycle the focused subwindow. Enters a Shift-held preview: the frame moves
+      // to the previewed group and numbered badges show over every subwindow;
+      // focus only commits on Shift release (keyup below). Numbering is anchored
+      // to the committed focus (id 0), so stepping wraps in document order.
+      const down = is("subwindowDown");
+      if (down || is("subwindowUp")) {
+        const ids = allGroups(tabs.layout).map((g) => g.id);
+        const n = ids.length;
+        if (n >= 2) {
+          e.preventDefault();
+          const nav = useSubwindowNavStore.getState();
+          const base =
+            nav.active && nav.previewGroupId
+              ? nav.previewGroupId
+              : tabs.focusedGroupId;
+          const baseIdx = base ? ids.indexOf(base) : -1;
+          const from = baseIdx >= 0 ? baseIdx : 0;
+          const nextIdx = (from + (down ? 1 : -1) + n) % n;
+          nav.preview(ids[nextIdx]);
+        }
+        return;
+      }
+    }
+
+    // Commit the previewed subwindow focus when Shift is released; cancel (no
+    // focus move) if the window loses focus mid-preview.
+    function onKeyUp(e: KeyboardEvent) {
+      const nav = useSubwindowNavStore.getState();
+      if (nav.active && (e.key === "Shift" || !e.shiftKey)) {
+        if (nav.previewGroupId) useTabsStore.getState().focusGroup(nav.previewGroupId);
+        nav.end();
+      }
+    }
+    function onBlur() {
+      const nav = useSubwindowNavStore.getState();
+      if (nav.active) nav.end();
     }
 
     window.addEventListener("keydown", onKeyDown);
-    return () => window.removeEventListener("keydown", onKeyDown);
+    window.addEventListener("keyup", onKeyUp);
+    window.addEventListener("blur", onBlur);
+    return () => {
+      window.removeEventListener("keydown", onKeyDown);
+      window.removeEventListener("keyup", onKeyUp);
+      window.removeEventListener("blur", onBlur);
+    };
   }, [onTogglePanels]);
 }
 
diff --git a/src/hooks/useWindowFocused.ts b/src/hooks/useWindowFocused.ts
new file mode 100644
index 0000000..3482ed9
--- /dev/null
+++ b/src/hooks/useWindowFocused.ts
@@ -0,0 +1,46 @@
+import { useEffect, useState } from "react";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+/**
+ * Whether THIS OS window currently holds focus. Backs the "exactly one active
+ * subwindow across all windows" rule (#42 ergonomics): each window keeps its own
+ * focused-subwindow value, but only *paints* it as active while it owns OS focus,
+ * so a blurred main window and a focused popout never both show a highlight.
+ *
+ * Defaults to `true` and only updates on a real boolean: the main window then
+ * paints its active subwindow immediately on load (before the first event), and
+ * in a non-Tauri context (unit tests, where `getCurrentWindow` is inert) the
+ * value simply stays `true` — preserving the pre-gate behavior.
+ */
+export function useWindowFocused(): boolean {
+  const [focused, setFocused] = useState(true);
+  useEffect(() => {
+    let unlisten: (() => void) | undefined;
+    let cancelled = false;
+    try {
+      const win = getCurrentWindow();
+      win
+        .isFocused()
+        .then((f) => {
+          if (!cancelled && typeof f === "boolean") setFocused(f);
+        })
+        .catch(() => {});
+      win
+        .onFocusChanged(({ payload }) => {
+          if (typeof payload === "boolean") setFocused(payload);
+        })
+        .then((fn) => {
+          if (cancelled) fn();
+          else unlisten = fn;
+        })
+        .catch(() => {});
+    } catch {
+      // No Tauri window (tests): keep the single-window default.
+    }
+    return () => {
+      cancelled = true;
+      unlisten?.();
+    };
+  }, []);
+  return focused;
+}
diff --git a/src/lib/agentPrompt.ts b/src/lib/agentPrompt.ts
new file mode 100644
index 0000000..d5f449e
--- /dev/null
+++ b/src/lib/agentPrompt.ts
@@ -0,0 +1,76 @@
+/**
+ * Heuristic detection of an agent "waiting for a decision" prompt from its
+ * terminal output. An agent tab that has gone quiet is either done with its turn
+ * or blocked on a permission/choice prompt, and only the text on screen tells
+ * the two apart — so we sniff the tail of its output for the interactive
+ * selection menu that Claude/Codex (and similar) render while awaiting input.
+ *
+ * This is deliberately conservative and agent-shaped: it degrades to "not a
+ * decision" (→ treated as finished) for agents whose prompts we don't recognize,
+ * which is the safe default (a green "finished" lamp rather than a wrong orange).
+ */
+
+// A pointer glyph marking a numbered choice, e.g. "❯ 1. Yes" / "▶ 2) No" — the
+// shape Claude Code and Codex use for approval/selection prompts.
+const POINTER_CHOICE = /[❯▶►➤»›]\s*\d+[.)]\s/u;
+
+// A yes/no (or allow/deny) style numbered menu visible on screen, matched
+// independently of the pointer glyph (some renderers drop it while scrolling).
+const AFFIRM = /\b1[.)]\s*(yes|proceed|allow|approve|continue)/i;
+const DENY = /\b2[.)]\s*(no|keep|cancel|reject|deny|don'?t)/i;
+
+// A pointer glyph directly beside a bare yes/no-style word, e.g. "❯ Yes" /
+// "❯ Allow" — the shape a simple binary confirmation takes when it isn't
+// numbered (only multi-choice menus number their options).
+const POINTER_WORD =
+  /[❯▶►➤»›]\s*(yes|no|proceed|allow|approve|continue|cancel|reject|deny|don'?t)\b/i;
+
+// Terminal escape sequences, peeled off in this order: OSC (`ESC ] … BEL|ST`),
+// which can carry an arbitrary payload such as a window title; then CSI
+// (`ESC [ … final byte`), the colour/cursor traffic that makes up most of a TUI
+// redraw; then charset designators (`ESC ( B` and friends, which agents emit
+// constantly); then any remaining two-character escape.
+// ONE pass, not four. These alternatives were four separate global regexes run
+// as four chained `.replace()` calls, which meant four full scans of the text
+// and four fresh strings per call — and this runs on EVERY PTY output batch
+// (~60/s per streaming agent tab, see `notePtyOutput`). Alternation is tried
+// left-to-right at each position, so keeping the original order (OSC, CSI,
+// charset, then any remaining two-char escape) preserves the exact semantics
+// while allocating once.
+const ANSI =
+  /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b[()*+][@-~]|\x1b[@-Z\\-_]/g;
+
+/**
+ * Strip ANSI escape sequences from terminal text. The prompt regexes above are
+ * written against plain rows, but the text we classify comes straight off the
+ * PTY stream — the only source available for a tab whose xterm was never opened
+ * — where a menu line is shot through with colour codes.
+ */
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI, "");
+}
+
+/**
+ * True when ALREADY ANSI-stripped text looks like an agent decision/permission
+ * prompt awaiting the user's input.
+ *
+ * Split out because the hot caller (`stores/activity`'s `attentionFor`) tests a
+ * tail it built from stripped chunks — so routing it through `stripAnsi` again
+ * re-scanned and re-allocated the whole 8 KB tail several times a second, per
+ * agent tab, to delete escapes that were never there.
+ */
+export function looksLikeDecisionPromptStripped(plain: string): boolean {
+  if (POINTER_CHOICE.test(plain)) return true;
+  if (POINTER_WORD.test(plain)) return true;
+  if (AFFIRM.test(plain) && DENY.test(plain)) return true;
+  return false;
+}
+
+/**
+ * True when the given RAW terminal text (typically the tail of an agent's
+ * output) looks like an agent decision/permission prompt awaiting the user's
+ * input.
+ */
+export function looksLikeDecisionPrompt(text: string): boolean {
+  return looksLikeDecisionPromptStripped(stripAnsi(text));
+}
diff --git a/src/lib/alarms.ts b/src/lib/alarms.ts
new file mode 100644
index 0000000..2128eb8
--- /dev/null
+++ b/src/lib/alarms.ts
@@ -0,0 +1,154 @@
+/**
+ * Which reminders are due, and which have already been shown.
+ *
+ * Pure logic, kept out of the store so it can be tested without a clock or a
+ * notification backend. `stores/alarms.ts` drives it on a ticker.
+ *
+ * The invariant that matters: **an alarm fires exactly once.** Every fired alarm
+ * is recorded under a stable key — the event, the specific occurrence, and the
+ * offset — and that record is persisted, so a reminder does not fire again on the
+ * next tick, nor on the next launch. Occurrences are keyed by their
+ * *rule-generated* start, so moving one does not resurrect its alarm.
+ */
+
+import type { Alarm, Occurrence } from "../types";
+import { addDays, addMinutes, minutesBetween, toStamp } from "./calendarTime";
+
+/** A reminder that has come due and wants showing. */
+export interface DueAlarm {
+  /** Stable identity — the dedup key and the React key. */
+  key: string;
+  eventId: string;
+  occurrenceStart: string;
+  minutesBefore: number;
+  title: string;
+  location: string;
+  /** The occurrence's real start, for the "in 15 minutes" line. */
+  start: string;
+  allDay: boolean;
+}
+
+/** The key an alarm is remembered by, once fired. */
+export function alarmKey(
+  eventId: string,
+  occurrenceStart: string,
+  minutesBefore: number,
+): string {
+  return `${eventId}@${occurrenceStart}@${minutesBefore}`;
+}
+
+/**
+ * When an alarm should go off: the occurrence's start, less its offset.
+ *
+ * An all-day event has no meaningful time-of-day, so its reminders are measured
+ * from 09:00 on the day it starts rather than from midnight — a "1 day before"
+ * reminder on a birthday should arrive at a civilized hour the day before, not at
+ * 00:00.
+ */
+export function alarmTime(occurrence: Occurrence, minutesBefore: number): string {
+  const anchor = occurrence.allDay
+    ? `${occurrence.start.split("T")[0]}T09:00`
+    : occurrence.start;
+  return addMinutes(anchor, -minutesBefore);
+}
+
+/**
+ * The alarms that are due at `now` and have not been shown yet.
+ *
+ * "Due" means its time has arrived — including one that arrived while Eldrun was
+ * closed, which is why this looks backwards as well as at this instant. It does
+ * not look back forever, though: `graceMinutes` bounds how stale a reminder may
+ * be and still be worth showing (a week-old reminder is noise, not information).
+ */
+export function dueAlarms(
+  occurrences: Occurrence[],
+  fired: Set<string>,
+  now: Date = new Date(),
+  graceMinutes = 24 * 60,
+): DueAlarm[] {
+  const nowStamp = toStamp(now);
+  const out: DueAlarm[] = [];
+
+  for (const occ of occurrences) {
+    for (const alarm of occ.alarms ?? []) {
+      const key = alarmKey(occ.eventId, occ.occurrenceStart, alarm.minutes_before);
+      if (fired.has(key)) continue;
+
+      const at = alarmTime(occ, alarm.minutes_before);
+      const lateBy = minutesBetween(at, nowStamp);
+      // Not yet due.
+      if (lateBy < 0) continue;
+      // Due, but so long ago that showing it now would just be noise.
+      if (lateBy > graceMinutes) continue;
+
+      out.push({
+        key,
+        eventId: occ.eventId,
+        occurrenceStart: occ.occurrenceStart,
+        minutesBefore: alarm.minutes_before,
+        title: occ.title,
+        location: occ.location,
+        start: occ.start,
+        allDay: occ.allDay,
+      });
+    }
+  }
+
+  // Soonest-starting first, so the most imminent reminder is at the top of the stack.
+  return out.sort((a, b) => a.start.localeCompare(b.start));
+}
+
+/**
+ * The window an alarm scan needs to expand occurrences over.
+ *
+ * It must reach far enough back to catch a reminder that came due while the app
+ * was closed, and far enough forward to catch the longest lead time any event
+ * asks for — a "1 day before" reminder on an event next week is not due yet, but
+ * a scan that only looked at today would never see the event at all.
+ */
+export function alarmWindow(
+  events: { alarms?: Alarm[] }[],
+  now: Date = new Date(),
+): { start: string; end: string } {
+  const maxLead = events.reduce((max, e) => {
+    for (const a of e.alarms ?? []) max = Math.max(max, a.minutes_before);
+    return max;
+  }, 0);
+  // Round the lead up to whole days, plus a day of slack on each side.
+  const leadDays = Math.ceil(maxLead / (24 * 60)) + 1;
+  const today = toStamp(now).split("T")[0];
+  return { start: addDays(today, -1), end: addDays(today, leadDays + 1) };
+}
+
+/** A snooze: the alarm comes back this many minutes from now. */
+export interface Snoozed {
+  key: string;
+  /** When it should reappear. */
+  at: string;
+  alarm: DueAlarm;
+}
+
+/** Snooze `alarm` for `minutes` from `now`. */
+export function snooze(alarm: DueAlarm, minutes: number, now: Date = new Date()): Snoozed {
+  return { key: alarm.key, at: addMinutes(toStamp(now), minutes), alarm };
+}
+
+/** The snoozed alarms whose time has come back around. */
+export function wokenSnoozes(snoozes: Snoozed[], now: Date = new Date()): Snoozed[] {
+  const nowStamp = toStamp(now);
+  return snoozes.filter((s) => s.at <= nowStamp);
+}
+
+/** A human lead-in for the notification body: "in 15 minutes", "now", "2 hours ago". */
+export function describeLead(minutesBefore: number): string {
+  if (minutesBefore === 0) return "now";
+  const before = minutesBefore > 0;
+  const abs = Math.abs(minutesBefore);
+  const unit =
+    abs >= 1440
+      ? `${Math.round(abs / 1440)} day${Math.round(abs / 1440) === 1 ? "" : "s"}`
+      : abs >= 60
+        ? `${Math.round(abs / 60)} hour${Math.round(abs / 60) === 1 ? "" : "s"}`
+        : `${abs} minute${abs === 1 ? "" : "s"}`;
+  return before ? `in ${unit}` : `${unit} ago`;
+}
diff --git a/src/lib/calendarCategories.ts b/src/lib/calendarCategories.ts
new file mode 100644
index 0000000..15bc9f4
--- /dev/null
+++ b/src/lib/calendarCategories.ts
@@ -0,0 +1,42 @@
+/**
+ * Event categories — the colored tags Thunderbird puts on an event.
+ *
+ * A category is stored on the event as a plain key string; the color it renders
+ * in is looked up here. Keeping the palette in code (rather than on disk) means
+ * an imported ICS with an unknown `CATEGORIES:` value still round-trips — it just
+ * falls back to the calendar's own color instead of gaining a swatch.
+ */
+
+export interface Category {
+  key: string;
+  label: string;
+  /** CSS custom property holding the color, defined in `themes.css`. */
+  color: string;
+}
+
+/** The built-in category set, in menu order. */
+export const CATEGORIES: Category[] = [
+  { key: "work", label: "Work", color: "var(--cal-cat-work)" },
+  { key: "personal", label: "Personal", color: "var(--cal-cat-personal)" },
+  { key: "meeting", label: "Meeting", color: "var(--cal-cat-meeting)" },
+  { key: "travel", label: "Travel", color: "var(--cal-cat-travel)" },
+  { key: "birthday", label: "Birthday", color: "var(--cal-cat-birthday)" },
+  { key: "holiday", label: "Holiday", color: "var(--cal-cat-holiday)" },
+  { key: "important", label: "Important", color: "var(--cal-cat-important)" },
+];
+
+const BY_KEY = new Map(CATEGORIES.map((c) => [c.key, c]));
+
+/** The category for a key, or null when unset/unknown. */
+export function categoryFor(key: string | undefined): Category | null {
+  if (!key) return null;
+  return BY_KEY.get(key) ?? null;
+}
+
+/**
+ * The color an event should render in: its category's color when it has a known
+ * one, otherwise its calendar's color.
+ */
+export function eventColor(category: string | undefined, calendarColor: string): string {
+  return categoryFor(category)?.color ?? calendarColor;
+}
diff --git a/src/lib/calendarTime.ts b/src/lib/calendarTime.ts
new file mode 100644
index 0000000..705ac8c
--- /dev/null
+++ b/src/lib/calendarTime.ts
@@ -0,0 +1,466 @@
+/**
+ * Local wall-clock date/time math for the native calendar.
+ *
+ * Every timestamp the calendar stores is *local wall-clock*, never UTC:
+ * `"YYYY-MM-DDTHH:MM"` for a timed event, `"YYYY-MM-DD"` for an all-day one
+ * (mirroring `schema::calendar`). Keeping it wall-clock is what makes "09:00
+ * standup" stay at 09:00 across timezone changes, and it is why nothing here
+ * ever touches `Date.getTime()` epoch math for calendar arithmetic — a `Date` is
+ * only ever used as a *civil* (y, m, d, h, min) carrier.
+ *
+ * Ends are **exclusive**: an all-day event on the 8th is `start "2026-07-08"`,
+ * `end "2026-07-09"`. This is the iCalendar convention and it makes duration,
+ * overlap and multi-day slicing fall out as plain subtraction.
+ *
+ * Pure — no React, no Tauri. All of it is unit-tested.
+ */
+
+/** Minutes in a day; the unit the time grid positions blocks in. */
+export const MINUTES_PER_DAY = 24 * 60;
+
+/** `0` = Sunday … `6` = Saturday, matching `Date.getDay()` and `Rrule.byweekday`. */
+export type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+// ── Parse / format ──────────────────────────────────────────────────────────
+
+/** The civil fields of a stored stamp. `hour`/`minute` are 0 for a date-only stamp. */
+export interface Civil {
+  year: number;
+  month: number; // 1-12
+  day: number; // 1-31
+  hour: number;
+  minute: number;
+  /** True when the stamp carried no `T…` part (i.e. it is a bare date). */
+  dateOnly: boolean;
+}
+
+/** Parse `"YYYY-MM-DD"` or `"YYYY-MM-DDTHH:MM"`. Returns null on garbage. */
+export function parseStamp(stamp: string): Civil | null {
+  const m = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}))?/.exec(stamp);
+  if (!m) return null;
+  const [, y, mo, d, h, mi] = m;
+  const civil: Civil = {
+    year: Number(y),
+    month: Number(mo),
+    day: Number(d),
+    hour: h === undefined ? 0 : Number(h),
+    minute: mi === undefined ? 0 : Number(mi),
+    dateOnly: h === undefined,
+  };
+  if (civil.month < 1 || civil.month > 12) return null;
+  if (civil.day < 1 || civil.day > daysInMonth(civil.year, civil.month)) return null;
+  if (civil.hour > 23 || civil.minute > 59) return null;
+  return civil;
+}
+
+/** The date half of a stamp: `"2026-07-08T09:00"` → `"2026-07-08"`. */
+export function datePart(stamp: string): string {
+  return stamp.split("T")[0];
+}
+
+/** The time half, or `""` for a date-only stamp. */
+export function timePart(stamp: string): string {
+  const t = stamp.split("T")[1];
+  return t ?? "";
+}
+
+/** A `Date` (local) → `"YYYY-MM-DD"`. Mirrors `ActivityCalendar.toDateStr`. */
+export function toDateStr(d: Date): string {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+/** A `Date` (local) → `"YYYY-MM-DDTHH:MM"`. */
+export function toStamp(d: Date): string {
+  const h = String(d.getHours()).padStart(2, "0");
+  const mi = String(d.getMinutes()).padStart(2, "0");
+  return `${toDateStr(d)}T${h}:${mi}`;
+}
+
+/** `"YYYY-MM-DD"` (or a full stamp) → a local `Date` at that civil moment. */
+export function toDate(stamp: string): Date {
+  const c = parseStamp(stamp);
+  if (!c) return new Date(NaN);
+  return new Date(c.year, c.month - 1, c.day, c.hour, c.minute, 0, 0);
+}
+
+/** Today as `"YYYY-MM-DD"`. */
+export function todayStr(now: Date = new Date()): string {
+  return toDateStr(now);
+}
+
+// ── Civil arithmetic ────────────────────────────────────────────────────────
+
+export function isLeapYear(y: number): boolean {
+  return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+}
+
+/** Days in a 1-indexed month. */
+export function daysInMonth(y: number, m: number): number {
+  if (m === 2) return isLeapYear(y) ? 29 : 28;
+  return [4, 6, 9, 11].includes(m) ? 30 : 31;
+}
+
+/**
+ * Add `n` days to a date/stamp, preserving whichever form came in (a bare date
+ * stays a bare date; a timed stamp keeps its time).
+ *
+ * Goes through `Date` with the time pinned to noon. Midnight would be the obvious
+ * choice, but on a spring-forward DST day midnight may not exist locally and the
+ * `Date` constructor shifts it into the previous day — which would silently drop
+ * a day from every recurrence crossing a DST boundary. Noon is never ambiguous.
+ */
+export function addDays(stamp: string, n: number): string {
+  const c = parseStamp(stamp);
+  if (!c) return stamp;
+  const d = new Date(c.year, c.month - 1, c.day, 12, 0, 0, 0);
+  d.setDate(d.getDate() + n);
+  const date = toDateStr(d);
+  return c.dateOnly
+    ? date
+    : `${date}T${String(c.hour).padStart(2, "0")}:${String(c.minute).padStart(2, "0")}`;
+}
+
+/** Add `n` months, clamping the day to the target month's length (Jan 31 +1mo → Feb 28). */
+export function addMonths(stamp: string, n: number): string {
+  const c = parseStamp(stamp);
+  if (!c) return stamp;
+  const total = (c.year * 12 + (c.month - 1)) + n;
+  const year = Math.floor(total / 12);
+  const month = (total % 12) + 1;
+  const day = Math.min(c.day, daysInMonth(year, month));
+  const date = `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+  return c.dateOnly
+    ? date
+    : `${date}T${String(c.hour).padStart(2, "0")}:${String(c.minute).padStart(2, "0")}`;
+}
+
+/** Add `n` years, clamping Feb 29 → Feb 28 in a common year. */
+export function addYears(stamp: string, n: number): string {
+  return addMonths(stamp, n * 12);
+}
+
+/** Add `n` minutes to a timed stamp, rolling the date over. Date-only stamps pass through. */
+export function addMinutes(stamp: string, n: number): string {
+  const c = parseStamp(stamp);
+  if (!c) return stamp;
+  if (c.dateOnly) return stamp;
+  const total = c.hour * 60 + c.minute + n;
+  const dayShift = Math.floor(total / MINUTES_PER_DAY);
+  const within = ((total % MINUTES_PER_DAY) + MINUTES_PER_DAY) % MINUTES_PER_DAY;
+  const date = addDays(datePart(stamp), dayShift);
+  return `${date}T${String(Math.floor(within / 60)).padStart(2, "0")}:${String(within % 60).padStart(2, "0")}`;
+}
+
+/** Minutes from local midnight. A date-only stamp is 0. */
+export function minutesIntoDay(stamp: string): number {
+  const c = parseStamp(stamp);
+  if (!c) return 0;
+  return c.hour * 60 + c.minute;
+}
+
+/** Whole days between two dates (`b - a`), ignoring any time part. */
+export function daysBetween(a: string, b: string): number {
+  const ca = parseStamp(a);
+  const cb = parseStamp(b);
+  if (!ca || !cb) return 0;
+  // Noon again, so a DST transition inside the span cannot round the division wrong.
+  const da = new Date(ca.year, ca.month - 1, ca.day, 12).getTime();
+  const db = new Date(cb.year, cb.month - 1, cb.day, 12).getTime();
+  return Math.round((db - da) / 86_400_000);
+}
+
+/** Minutes between two timed stamps (`b - a`). Used for durations. */
+export function minutesBetween(a: string, b: string): number {
+  return daysBetween(a, b) * MINUTES_PER_DAY + (minutesIntoDay(b) - minutesIntoDay(a));
+}
+
+/** Weekday of a date/stamp, `0` = Sunday. */
+export function weekdayOf(stamp: string): Weekday {
+  const c = parseStamp(stamp);
+  if (!c) return 0;
+  return new Date(c.year, c.month - 1, c.day, 12).getDay() as Weekday;
+}
+
+// ── Ranges ──────────────────────────────────────────────────────────────────
+
+/**
+ * The date the containing week starts on. `weekStart` is 0 (Sunday) or 1 (Monday)
+ * — the two options the settings expose.
+ */
+export function startOfWeek(stamp: string, weekStart: 0 | 1): string {
+  const dow = weekdayOf(stamp);
+  const back = (dow - weekStart + 7) % 7;
+  return addDays(datePart(stamp), -back);
+}
+
+/** The `n` consecutive dates starting at `start` (inclusive). */
+export function dateRange(start: string, n: number): string[] {
+  const out: string[] = [];
+  let cur = datePart(start);
+  for (let i = 0; i < n; i++) {
+    out.push(cur);
+    cur = addDays(cur, 1);
+  }
+  return out;
+}
+
+/** The 7 dates of the week containing `stamp`. */
+export function weekDates(stamp: string, weekStart: 0 | 1): string[] {
+  return dateRange(startOfWeek(stamp, weekStart), 7);
+}
+
+/**
+ * The weeks covering a month's grid: whole weeks from the one containing the 1st
+ * through the one containing the last day, so the grid never clips the month.
+ * `weeks` forces a fixed count (6 gives the stable-height month grid the pane
+ * already renders; the multiweek view passes its own N).
+ */
+export function monthGrid(
+  year: number,
+  month: number,
+  weekStart: 0 | 1,
+  weeks = 6,
+): string[][] {
+  const first = `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-01`;
+  const gridStart = startOfWeek(first, weekStart);
+  const out: string[][] = [];
+  for (let w = 0; w < weeks; w++) {
+    out.push(dateRange(addDays(gridStart, w * 7), 7));
+  }
+  return out;
+}
+
+/** Whether `date` falls in `[rangeStart, rangeEnd)` — both bare dates. */
+export function dateInRange(date: string, rangeStart: string, rangeEnd: string): boolean {
+  const d = datePart(date);
+  return d >= datePart(rangeStart) && d < datePart(rangeEnd);
+}
+
+// ── Event geometry ──────────────────────────────────────────────────────────
+
+/** Anything with a start/end/all-day — an event or one expanded occurrence. */
+export interface Span {
+  start: string;
+  end: string;
+  allDay: boolean;
+}
+
+/**
+ * Normalize a span whose end is missing, malformed, or not after its start.
+ * A zero/negative-length event is unrenderable (and, in the time grid, invisible),
+ * so it is given a minimum length instead of being dropped: a timed event gets
+ * `minMinutes`, an all-day one gets its single day back.
+ */
+export function normalizeSpan(span: Span, minMinutes = 15): Span {
+  const { start, allDay } = span;
+  if (!parseStamp(start)) return span;
+
+  if (allDay) {
+    const end = parseStamp(span.end) ? datePart(span.end) : "";
+    const oneDay = addDays(datePart(start), 1);
+    return {
+      start: datePart(start),
+      end: end && end > datePart(start) ? end : oneDay,
+      allDay: true,
+    };
+  }
+
+  const end = parseStamp(span.end) ? span.end : "";
+  const ok = end && minutesBetween(start, end) >= minMinutes;
+  return { start, end: ok ? end : addMinutes(start, minMinutes), allDay: false };
+}
+
+/** Whether the span covers any part of `date` (exclusive end). */
+export function spanCoversDate(span: Span, date: string): boolean {
+  const s = normalizeSpan(span);
+  const d = datePart(date);
+  const startDate = datePart(s.start);
+  // An exclusive end lands on the day AFTER the last covered one — except for a
+  // timed event ending exactly at midnight, which must not claim the next day.
+  const endDate = s.allDay
+    ? datePart(s.end)
+    : minutesIntoDay(s.end) === 0
+      ? datePart(s.end)
+      : addDays(datePart(s.end), 1);
+  return d >= startDate && d < endDate;
+}
+
+/** Every date the span touches. A single-day event yields one date. */
+export function spanDates(span: Span): string[] {
+  const s = normalizeSpan(span);
+  const startDate = datePart(s.start);
+  const endDate = s.allDay
+    ? datePart(s.end)
+    : minutesIntoDay(s.end) === 0
+      ? datePart(s.end)
+      : addDays(datePart(s.end), 1);
+  const n = Math.max(1, daysBetween(startDate, endDate));
+  return dateRange(startDate, n);
+}
+
+/** Whether the span touches more than one day. */
+export function isMultiDay(span: Span): boolean {
+  return spanDates(span).length > 1;
+}
+
+/**
+ * An all-day event's stored (exclusive) end → the inclusive last day a date
+ * picker should show. Stored `"2026-07-09"` displays as `"2026-07-08"`.
+ *
+ * The pair below is the only place the exclusive-end convention is translated for
+ * a human. Getting the direction wrong lands the end a day before the start, so
+ * they are kept together and round-trip-tested.
+ */
+export function allDayEndToLastDay(end: string): string {
+  const d = datePart(end);
+  return parseStamp(d) ? addDays(d, -1) : end;
+}
+
+/** The inclusive last day from a picker → the exclusive end to store. */
+export function lastDayToAllDayEnd(lastDay: string): string {
+  const d = datePart(lastDay);
+  return parseStamp(d) ? addDays(d, 1) : lastDay;
+}
+
+/**
+ * The span's vertical extent within one day of the time grid, as minutes from
+ * that day's midnight. A multi-day event is clipped to the day: it starts at 0
+ * on any day after its first, and runs to `MINUTES_PER_DAY` on any day before
+ * its last. Returns null when the span does not touch the day at all.
+ */
+export function daySlice(
+  span: Span,
+  date: string,
+): { startMin: number; endMin: number } | null {
+  const s = normalizeSpan(span);
+  if (!spanCoversDate(s, date)) return null;
+
+  const d = datePart(date);
+  const startsHere = datePart(s.start) === d;
+  const lastDay = s.allDay
+    ? addDays(datePart(s.end), -1)
+    : minutesIntoDay(s.end) === 0
+      ? addDays(datePart(s.end), -1)
+      : datePart(s.end);
+  const endsHere = lastDay === d;
+
+  return {
+    startMin: startsHere ? minutesIntoDay(s.start) : 0,
+    endMin: endsHere ? minutesIntoDay(s.end) || MINUTES_PER_DAY : MINUTES_PER_DAY,
+  };
+}
+
+// ── Overlap layout ──────────────────────────────────────────────────────────
+
+/** An item to lay out in the time grid: its day-slice plus whatever payload. */
+export interface Placeable {
+  startMin: number;
+  endMin: number;
+}
+
+/** Where a laid-out block sits horizontally, as fractions of the day column. */
+export interface Placement {
+  /** Left edge, 0-1. */
+  left: number;
+  /** Width, 0-1. */
+  width: number;
+  /** Index within its overlap cluster, useful for z-order/debug. */
+  column: number;
+  /** How many columns its cluster was split into. */
+  columns: number;
+}
+
+/**
+ * Lay overlapping blocks side by side, the way every day/week grid does it.
+ *
+ * Blocks are grouped into *clusters* of transitively-overlapping items; within a
+ * cluster each block takes the leftmost column free at its start, and the cluster
+ * is divided into as many columns as its busiest moment needs. Two events that do
+ * not overlap therefore each keep the full width, while three that all collide
+ * each get a third.
+ *
+ * Returns placements positionally aligned with `items`.
+ */
+export function layoutOverlaps(items: Placeable[]): Placement[] {
+  const order = items
+    .map((item, i) => ({ item, i }))
+    .sort((a, b) => a.item.startMin - b.item.startMin || a.item.endMin - b.item.endMin);
+
+  const placements = new Array<Placement>(items.length);
+
+  // Walk in start order, accumulating a cluster until a gap appears (a block that
+  // starts at/after every open block has ended).
+  let cluster: { i: number; column: number; endMin: number }[] = [];
+  let clusterEnd = -Infinity;
+
+  const flush = () => {
+    if (cluster.length === 0) return;
+    const columns = Math.max(...cluster.map((c) => c.column)) + 1;
+    for (const c of cluster) {
+      placements[c.i] = {
+        left: c.column / columns,
+        width: 1 / columns,
+        column: c.column,
+        columns,
+      };
+    }
+    cluster = [];
+    clusterEnd = -Infinity;
+  };
+
+  // Column end-times within the current cluster; a column is free once its last
+  // block has ended.
+  let columnEnds: number[] = [];
+
+  for (const { item, i } of order) {
+    if (item.startMin >= clusterEnd) {
+      flush();
+      columnEnds = [];
+    }
+    let column = columnEnds.findIndex((end) => end <= item.startMin);
+    if (column === -1) {
+      column = columnEnds.length;
+      columnEnds.push(item.endMin);
+    } else {
+      columnEnds[column] = item.endMin;
+    }
+    cluster.push({ i, column, endMin: item.endMin });
+    clusterEnd = Math.max(clusterEnd, item.endMin);
+  }
+  flush();
+
+  return placements;
+}
+
+// ── Display ─────────────────────────────────────────────────────────────────
+
+/** `"09:00"` → `"9:00 AM"` when `use24h` is false; unchanged when it is true. */
+export function formatTime(hhmm: string, use24h: boolean): string {
+  if (use24h) return hhmm;
+  const [h, m] = hhmm.split(":").map(Number);
+  if (Number.isNaN(h)) return hhmm;
+  const suffix = h < 12 ? "AM" : "PM";
+  const hour12 = h % 12 === 0 ? 12 : h % 12;
+  return `${hour12}:${String(m).padStart(2, "0")} ${suffix}`;
+}
+
+/** The clock label for a stamp, or `""` for an all-day one. */
+export function formatStampTime(stamp: string, use24h: boolean): string {
+  const t = timePart(stamp);
+  return t ? formatTime(t, use24h) : "";
+}
+
+/** A long, human date: `"Wednesday, July 8, 2026"`. */
+export function formatLongDate(date: string, locale = "en"): string {
+  const d = toDate(date);
+  if (Number.isNaN(d.getTime())) return date;
+  return d.toLocaleDateString(locale, {
+    weekday: "long",
+    month: "long",
+    day: "numeric",
+    year: "numeric",
+  });
+}
diff --git a/src/lib/carefulHost.ts b/src/lib/carefulHost.ts
new file mode 100644
index 0000000..cf7b0b6
--- /dev/null
+++ b/src/lib/carefulHost.ts
@@ -0,0 +1,116 @@
+/**
+ * **Careful hosts** — "this machine is someone else's, so keep Eldrun's
+ * background load off it."
+ *
+ * The case it exists for is an HPC login node, where three separate things Eldrun
+ * does casually are things the site watches: CPU on the login node itself, a
+ * recursive `du` over a `$HOME` that usually sits on a *parallel* filesystem
+ * (a metadata storm against a shared Lustre/GPFS server), and repeated account
+ * lookups against a shared directory service. None of those are expensive for
+ * Eldrun. All of them are rude at a cadence.
+ *
+ * Three things about the shape, each of which is the whole reason it works:
+ *
+ * **It is keyed by SSH target, not by host id.** One physical login node is
+ * simultaneously a project's primary `remote`, a `compute_hosts` worker on
+ * another project, and a project-free global machine — three tables, three ids,
+ * one machine. A flag stored per record would be three values free to drift
+ * apart. `targetKey` is the identity `machineSync` already uses as the bridge
+ * between exactly those three, so it is the identity used here.
+ *
+ * **It is not named for HPC**, and — since it is now simply the default for every
+ * remote host — it no longer *detects* HPC either. There is no cluster-vs-dev-box
+ * classification anywhere in this module: an unanswered remote machine is treated
+ * carefully because Eldrun cannot know whose machine it is, and detection that
+ * guessed would only ever guess wrong in the expensive direction. What the flag
+ * means is a property of the machine's *politics*, not its hardware, and only the
+ * user knows that.
+ *
+ * **The stored value is an explicit answer, in both directions.** `settings
+ * .careful_hosts` records what the user actually said — which is why it is a map
+ * to `boolean` rather than a set of careful hosts. A machine of the user's own
+ * (a lab box, a workstation they own outright) is switched to normal once, per
+ * SSH target, and stays that way; a set could not distinguish "the user said
+ * normal" from "nobody has said anything", so the careful default would keep
+ * turning itself back on.
+ */
+
+import { targetKey, type Target } from "./machineSync";
+import type { ProjectEntry, Settings } from "../types";
+
+export type { Target };
+
+/**
+ * Whether `target` should be treated as careful: the user's explicit answer if
+ * there is one, otherwise **true** — every remote host is careful until the user
+ * says otherwise.
+ *
+ * Note the failure direction, which is the reverse of what it used to be. An
+ * unanswered host now reads `true`, so an unknown machine is under-collected
+ * rather than over-collected; the cost of a wrong careful is a thinner monitor
+ * pane and a skipped host census, the cost of a wrong *normal* is a policy
+ * violation on someone else's cluster. Only a local machine (no target) reads
+ * `false` — Eldrun is never a guest on the machine it runs on.
+ */
+export function isCarefulHost(
+  settings: Settings | null | undefined,
+  target: Target | null | undefined,
+): boolean {
+  if (!target?.host) return false;
+  const explicit = settings?.careful_hosts?.[targetKey(target)];
+  return typeof explicit === "boolean" ? explicit : true;
+}
+
+/** Whether the user has answered for this target at all (vs. it riding the
+ *  careful default). The toggle uses this to say "default" rather than claiming
+ *  the user chose. */
+export function carefulIsExplicit(
+  settings: Settings | null | undefined,
+  target: Target | null | undefined,
+): boolean {
+  if (!target?.host) return false;
+  return typeof settings?.careful_hosts?.[targetKey(target)] === "boolean";
+}
+
+/** The patch that records an explicit answer for `target`, for
+ *  `useSettingsStore.updateSettings`. Merges into the existing map rather than
+ *  replacing it — settings are saved whole, so a replace would drop every other
+ *  host's answer. */
+export function setCarefulPatch(
+  settings: Settings | null | undefined,
+  target: Target,
+  careful: boolean,
+): Pick<Settings, "careful_hosts"> {
+  return {
+    careful_hosts: { ...(settings?.careful_hosts ?? {}), [targetKey(target)]: careful },
+  };
+}
+
+/** Drop the explicit answer for `target`, returning it to the careful default. */
+export function clearCarefulPatch(
+  settings: Settings | null | undefined,
+  target: Target,
+): Pick<Settings, "careful_hosts"> {
+  const next = { ...(settings?.careful_hosts ?? {}) };
+  delete next[targetKey(target)];
+  return { careful_hosts: next };
+}
+
+/** The SSH target of a project's PRIMARY host, or null for a local project.
+ *  The primary is the host that owns files/git/mirror, so it is the one the du
+ *  census and the file-tree probes talk to. */
+export function primaryTargetOf(project: ProjectEntry | null | undefined): Target | null {
+  const r = project?.remote;
+  if (!r?.host) return null;
+  return { user: r.user || undefined, host: r.host, port: r.port ?? undefined };
+}
+
+/** The SSH target of any `RemoteSpec`-shaped record — a primary `remote`, a
+ *  `compute_hosts` worker, or a project-free global machine. All three spell
+ *  user/host/port the same way, which is the whole reason one key can span them. */
+export function targetOfSpec(
+  spec: { user?: string | null; host: string; port?: number | null } | null | undefined,
+): Target | null {
+  if (!spec?.host) return null;
+  return { user: spec.user || undefined, host: spec.host, port: spec.port ?? undefined };
+}
diff --git a/src/lib/categoryColor.ts b/src/lib/categoryColor.ts
new file mode 100644
index 0000000..698add0
--- /dev/null
+++ b/src/lib/categoryColor.ts
@@ -0,0 +1,60 @@
+/**
+ * Deterministic per-category colors. A project's category tags (e.g. "work",
+ * "research", "client-x") group projects in both the 3D project cloud and the
+ * pill bar; each tag is colored by a stable hue derived from its name so the
+ * same category always reads as the same color across the app — no color-picker
+ * UI or stored palette to keep in sync.
+ */
+
+/** Normalize a category label for storage/compare: trim, collapse, drop blanks. */
+export function normalizeCategory(raw: string): string {
+  return raw.trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Merge a list of category labels into a clean, de-duplicated set (case-
+ * insensitive dedupe, first spelling wins), with blanks removed and order
+ * preserved. Used both before persisting and when offering toggle chips.
+ */
+export function cleanCategories(raw: Iterable<string>): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const r of raw) {
+    const c = normalizeCategory(r);
+    if (!c) continue;
+    const key = c.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(c);
+  }
+  return out;
+}
+
+/** Read a project's category tags from its (extra-flattened) `categories` field. */
+export function projectCategories(project: { categories?: unknown }): string[] {
+  return Array.isArray(project.categories)
+    ? cleanCategories(project.categories.filter((c): c is string => typeof c === "string"))
+    : [];
+}
+
+/** djb2 string hash → 32-bit unsigned, for a stable hue per category name. */
+function hashString(s: string): number {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) >>> 0;
+  return h >>> 0;
+}
+
+/**
+ * A stable, theme-agnostic color for a category. The hue is hashed from the
+ * (lower-cased) name and spread around the wheel; saturation/lightness are
+ * fixed at values that stay legible on both light and dark panels.
+ */
+export function categoryColor(name: string): string {
+  const hue = hashString(normalizeCategory(name).toLowerCase()) % 360;
+  return `hsl(${hue} 62% 58%)`;
+}
+
+/** Primary (first) category's color, or null when the project has no tags. */
+export function primaryCategoryColor(categories: string[]): string | null {
+  return categories.length > 0 ? categoryColor(categories[0]) : null;
+}
diff --git a/src/lib/closeRemoteTab.ts b/src/lib/closeRemoteTab.ts
new file mode 100644
index 0000000..04db56d
--- /dev/null
+++ b/src/lib/closeRemoteTab.ts
@@ -0,0 +1,88 @@
+/**
+ * Close (detach) of a persistent tab (TODO #85), plus the helpers that classify
+ * which tmux session a tab owns.
+ *
+ * A shell/script tab can run inside a **tmux** session — remote (on the SSH host)
+ * or local (on this machine) — so the run survives an SSH drop / laptop sleep /
+ * Eldrun quit / crash. Closing a tab is therefore **non-destructive**: it detaches
+ * (unmounts the pane, killing only the ssh/PTY client) and leaves the session alive
+ * under its tmux daemon, reattachable from the Sessions view. The *only* way to
+ * terminate a session is its × (kill) in the Sessions view (`remote_tmux_kill` /
+ * `local_tmux_kill`); no tab close, quit, disconnect, or crash ends a run.
+ *
+ * `persistentSessionOf` / `localPersistentSessionOf` classify the tab (used by the
+ * Sessions view to mark which rows an open tab owns). They live outside the stores
+ * because they read BOTH the tabs and projects stores, and `stores/projects`
+ * already imports `stores/tabs` — a store-level import back would be a cycle.
+ */
+
+import {
+  useTabsStore,
+  effectiveTabLocation,
+  remoteHostIdOf,
+  type TabEntry,
+} from "../stores/tabs";
+import { useProjectsStore } from "../stores/projects";
+import { useSettingsStore } from "../stores/settings";
+import { shouldPersistTab } from "./tmuxSession";
+import { IS_WINDOWS } from "./platform";
+
+/**
+ * The persistent host tmux session a tab owns, or `null` if the tab is not a
+ * persistent remote session (a local tab, a non-shell tab, a persistence-off
+ * project). An **attach** tab (opened from the Sessions view) owns the named
+ * session it attached to; an ordinary persistent shell tab owns its stable minted
+ * `tmuxSession`. `hostId` is resolved like `CenterPanel` (a tab naming a removed
+ * worker falls back to the primary).
+ */
+export function persistentSessionOf(
+  scope: string,
+  tab: TabEntry,
+): { session: string; hostId: string } | null {
+  if (scope === "root") return null;
+  const project = useProjectsStore.getState().projects.find((p) => p.id === scope);
+  if (!project?.remote) return null;
+  const rawHostId = remoteHostIdOf(effectiveTabLocation(tab));
+  if (rawHostId === null) return null; // a local-running tab has no host session
+  const hostId =
+    rawHostId !== "primary" && !project.compute_hosts?.some((h) => h.id === rawHostId)
+      ? "primary"
+      : rawHostId;
+  // A Sessions-view attach tab owns exactly the (possibly foreign) name it attached to.
+  if (tab.tmuxAttach) return { session: tab.tmuxAttach, hostId };
+  if (!shouldPersistTab(tab.kind, hostId, project.remote, tab.ephemeral) || !tab.tmuxSession) return null;
+  return { session: tab.tmuxSession, hostId };
+}
+
+/**
+ * The persistent **local** tmux session a tab owns, or `null`. Mirrors
+ * `shouldPersistLocalTab`: a shell tab in a project scope running on the local
+ * machine (a local project, or a remote project's local/mirror tab) with the
+ * `persist_local_sessions` setting on — and never on Windows (no tmux).
+ */
+export function localPersistentSessionOf(scope: string, tab: TabEntry): string | null {
+  if (scope === "root" || IS_WINDOWS) return null;
+  if (tab.kind !== "shell" || !tab.tmuxSession) return null;
+  const project = useProjectsStore.getState().projects.find((p) => p.id === scope);
+  const localRunning = !project?.remote || effectiveTabLocation(tab) === "local";
+  if (!localRunning) return null;
+  if (useSettingsStore.getState().settings?.persist_local_sessions === false) return null;
+  return tab.tmuxSession;
+}
+
+/**
+ * Close a tab from an explicit user action (the × button, the tab context menu).
+ *
+ * Closing a tab **detaches** — it never terminates the underlying tmux session.
+ * `removeTab` unmounts the pane (killing only the ssh/PTY *client*), so a persistent
+ * session — remote (on an SSH host) or local (on this machine) — keeps running under
+ * its tmux daemon and stays discoverable + reattachable in the Sessions view. The one
+ * way to actually terminate a session is its × (kill) in the Sessions view; a tab
+ * close, a quit, and a crash leave it alive; disconnecting the machine ends its
+ * host sessions. (This function stays a
+ * seam — rather than inlining `removeTab` at the call sites — so a future confirm/hook
+ * has one home, and so `persistentSessionOf` keeps a co-located reader.)
+ */
+export function closeTabWithConfirm(key: string): void {
+  useTabsStore.getState().removeTab(key);
+}
diff --git a/src/lib/codexHooks.ts b/src/lib/codexHooks.ts
new file mode 100644
index 0000000..02cf3fa
--- /dev/null
+++ b/src/lib/codexHooks.ts
@@ -0,0 +1,55 @@
+import { useTabsStore } from "../stores/tabs";
+import { useProjectsStore } from "../stores/projects";
+import { AGENT_ITEMS, buildStaticTabSpec } from "../components/tabs/newTabItems";
+
+/**
+ * Whether Codex is actually running Eldrun's `SessionStart` hook — the precise
+ * way to follow a tab's *current* conversation (it survives `/clear`, and it
+ * can't confuse two Codex tabs sharing a directory). Mirrors the backend's
+ * `CodexHookState` (`services::agent_session`).
+ *
+ * Codex gates user-level hooks behind a one-time trust approval, and an
+ * untrusted hook silently never fires. Eldrun still resumes Codex tabs without
+ * it — `services::codex_bind` reconstructs the session from Codex's own rollout
+ * logs — but that is a heuristic, so it's worth one nudge to switch the exact
+ * path on.
+ */
+export type CodexHookState =
+  | "no_codex"
+  | "not_registered"
+  | "untrusted"
+  | "disabled"
+  | "enabled";
+
+/** The hook exists but Codex won't run it → resume is running on the fallback. */
+export function codexHookNeedsTrust(state: CodexHookState | null): boolean {
+  return state === "untrusted" || state === "disabled";
+}
+
+/**
+ * One-click fix: open a Codex tab with `/hooks` already typed, so the user lands
+ * directly in the list where the hook is enabled.
+ *
+ * Same policy as `runInstallInTab` — a command the user needs run is *run*, never
+ * handed over to be copy-pasted. `TerminalView` submits `initialInput` once the
+ * agent is up, and `buildStaticTabSpec` is reused so this is an ordinary Codex
+ * tab (uid minted, `ELDRUN_TAB_UID` set) that merely opens on a slash command.
+ *
+ * It opens in the **root** scope: the hook lives in `~/.codex/config.toml` and is
+ * machine-global, not project-scoped. The active project is left alone — yanking
+ * the user out of their scope from a hint click would be jarring — so a toast
+ * points at the root terminal.
+ */
+export function openCodexHooksTab(): void {
+  const item = AGENT_ITEMS.find((i) => i.cmd === "codex");
+  if (!item) return;
+  const rootDir = useProjectsStore.getState().rootDir ?? "";
+  useTabsStore.getState().addTabToScope("root", {
+    ...buildStaticTabSpec(item, rootDir, ""),
+    label: "Codex — hooks",
+    initialInput: "/hooks",
+  });
+  useProjectsStore.setState({
+    switchToast: "Opened Codex in the root terminal — enable Eldrun's hook in the list",
+  });
+}
diff --git a/src/lib/coords.ts b/src/lib/coords.ts
new file mode 100644
index 0000000..4d0e75c
--- /dev/null
+++ b/src/lib/coords.ts
@@ -0,0 +1,130 @@
+/**
+ * #42: canonical cross-window coordinate space for the detached drag-drop system.
+ *
+ * THE CANONICAL SPACE IS PHYSICAL DESKTOP PIXELS. Five of the six Tauri geometry
+ * primitives the drag pipeline uses (`cursorPosition`, `outerPosition`,
+ * `outerSize`, `innerPosition`, `setPosition`) are ALREADY physical and live in
+ * one global desktop frame, so we standardise on physical and ELIMINATE the only
+ * platform-divergent quantity — DOM `screenX/screenY`, whose units differ between
+ * WebKitGTK (Linux), WebView2 (Windows), and WKWebView (macOS) under DPI scaling.
+ *
+ * Why physical and not "logical desktop px" (the old implicit convention)? Logical
+ * desktop px is ill-defined under mixed-DPI multi-monitor: it divides a global
+ * cursor by one window's scale and subtracts another window's origin divided by a
+ * DIFFERENT scale. Physical has no such ambiguity — each window converts physical
+ * → its-own-client px AT THE LEAF, dividing by ITS OWN scale, the only DPI-correct
+ * place to divide. At the common `scaleFactor == 1` (e.g. the dev Linux box)
+ * physical == logical, so adopting physical changes nothing observable there.
+ */
+import { cursorPosition, getCurrentWindow } from "@tauri-apps/api/window";
+import type { Window } from "@tauri-apps/api/window";
+
+/** A point in physical desktop px (the canonical cross-window space). */
+export interface PhysPoint {
+  x: number;
+  y: number;
+}
+/** A point in a window's own CSS/client px (its `getBoundingClientRect` space). */
+export interface ClientPoint {
+  x: number;
+  y: number;
+}
+
+/**
+ * A window's geometry snapshot, captured ONCE at gesture start (a window doesn't
+ * move/rescale mid-gesture for our purposes — and when it does, the dock-back
+ * follow re-snapshots). All `*Phys` fields are physical desktop px.
+ */
+export interface WindowFrame {
+  /** Client-area (content) top-left, physical px. The ONLY origin used to map a
+   *  cursor into this window's client px — never `outerPhys`, so an invisible
+   *  frame/shadow (Windows) or title-bar area (macOS) can't skew the mapping. */
+  innerPhys: PhysPoint;
+  /** Window top-left INCLUDING the frame, physical px. Used only for the outer
+   *  AABB hit-test (is the cursor over this window at all). */
+  outerPhys: PhysPoint;
+  /** Outer window size, physical px. */
+  outerSize: { w: number; h: number };
+  /** This window's device-pixel ratio (logical→physical scale factor). */
+  scale: number;
+}
+
+/**
+ * Snapshot a window's frame. Reads `innerPosition`, `outerPosition`, `outerSize`,
+ * and `scaleFactor` (all permitted via `core:default` — no capability change).
+ * Defaults to the current window.
+ */
+export async function snapshotFrame(win: Window = getCurrentWindow()): Promise<WindowFrame> {
+  const [inner, outer, size, scale] = await Promise.all([
+    win.innerPosition(),
+    win.outerPosition(),
+    win.outerSize(),
+    win.scaleFactor(),
+  ]);
+  return {
+    innerPhys: { x: inner.x, y: inner.y },
+    outerPhys: { x: outer.x, y: outer.y },
+    outerSize: { w: size.width, h: size.height },
+    scale: scale || 1,
+  };
+}
+
+/** physical desktop px → this window's client CSS px. Uses `innerPhys` (NOT
+ *  `outerPhys`), so the frame/title-bar offset never enters the mapping. */
+export const physToClient = (f: WindowFrame, p: PhysPoint): ClientPoint => ({
+  x: (p.x - f.innerPhys.x) / f.scale,
+  y: (p.y - f.innerPhys.y) / f.scale,
+});
+
+/** this window's client CSS px → physical desktop px. Valid for points OUTSIDE
+ *  the viewport too (pure linear extrapolation), so it can seed a gesture from a
+ *  DOM `clientX/clientY` that began inside the window. */
+export const clientToPhys = (f: WindowFrame, c: ClientPoint): PhysPoint => ({
+  x: f.innerPhys.x + c.x * f.scale,
+  y: f.innerPhys.y + c.y * f.scale,
+});
+
+/** Is the physical point inside this window's OUTER rect? Pure AABB, no scale
+ *  involved (both operands are physical). */
+export const pointInOuter = (f: WindowFrame, p: PhysPoint): boolean =>
+  p.x >= f.outerPhys.x &&
+  p.x <= f.outerPhys.x + f.outerSize.w &&
+  p.y >= f.outerPhys.y &&
+  p.y <= f.outerPhys.y + f.outerSize.h;
+
+/** The OS cursor in physical desktop px (`cursorPosition` is already physical and
+ *  is the proven cross-platform position source for the dock-back path). */
+export const desktopCursor = async (): Promise<PhysPoint> => {
+  const p = await cursorPosition();
+  return { x: p.x, y: p.y };
+};
+
+/**
+ * Poll `cursorPosition()` every ~16ms and report each reading (physical px). This
+ * is the SOURCE OF TRUTH for cross-window position: DOM pointer events don't
+ * reliably cross OS window boundaries (WebKitGTK) and report divergent units
+ * (WebView2/WKWebView), whereas `cursorPosition()` is desktop-global and physical
+ * on every engine. Returns a stop function. Uses `setInterval` (NOT rAF — must
+ * keep firing while the source window is unfocused) with a re-entrancy guard so a
+ * slow `cursorPosition()` await can't overlap itself.
+ */
+export function startCursorPoll(onTick: (p: PhysPoint) => void): () => void {
+  let stopped = false;
+  let inFlight = false;
+  const id = window.setInterval(() => {
+    if (inFlight) return;
+    inFlight = true;
+    void cursorPosition()
+      .then((p) => {
+        if (!stopped) onTick({ x: p.x, y: p.y });
+      })
+      .catch(() => {})
+      .finally(() => {
+        inFlight = false;
+      });
+  }, 16);
+  return () => {
+    stopped = true;
+    window.clearInterval(id);
+  };
+}
diff --git a/src/lib/dirSizeGuard.ts b/src/lib/dirSizeGuard.ts
new file mode 100644
index 0000000..a7d1abc
--- /dev/null
+++ b/src/lib/dirSizeGuard.ts
@@ -0,0 +1,152 @@
+/**
+ * The guard around the file tree's per-folder size calls.
+ *
+ * Folder sizes are a **best-effort display aid** — the tree renders without them
+ * and simply shows no size when one doesn't arrive. That is what makes them safe
+ * to bound aggressively, and bounding them matters because of where they run: for
+ * a remote project `dir_size`/`dir_size_breakdown` are a `du` over SSH, and the
+ * tree fires **one per visible folder, all at once**.
+ *
+ * When the network under a remote project goes away — a dropped VPN tunnel, a
+ * suspended laptop — those calls do not fail. A black-holed socket produces no
+ * error, so each one blocks until ssh's own keepalive gives up (~45 s), and each
+ * blocked call is holding a backend blocking-pool thread the whole time. Opening
+ * one folder of thirty subfolders then means thirty stalled threads and a UI with
+ * nothing to render, which is exactly how a lost tunnel turned into a frozen app.
+ *
+ * Three limits, each aimed at a different part of that:
+ *
+ *  - **Timeout** — a size that hasn't arrived in {@link TIMEOUT_MS} is treated as
+ *    one that isn't coming. This does *not* cancel the backend call (a Tauri
+ *    command in flight cannot be recalled); it frees the caller, which is the
+ *    part that was stuck.
+ *  - **Concurrency cap** — at most {@link MAX_CONCURRENT} in flight per project,
+ *    so a wide folder queues instead of dispatching thirty calls into a network
+ *    that is not answering.
+ *  - **Circuit breaker** — {@link FAILURES_TO_OPEN} consecutive timeouts mean the
+ *    host, not the folder, is the problem. The breaker then opens for
+ *    {@link OPEN_MS} and every further request for that project is refused
+ *    *immediately*, so the other twenty-nine folders cost nothing at all rather
+ *    than each paying the timeout in turn. One success closes it again.
+ *
+ * Keyed by `projectDir`, because "is this host answering?" is a property of the
+ * project's remote, not of any one folder. A local project's walk never times out
+ * in practice, so the breaker stays shut and this is pure overhead-free
+ * pass-through for it.
+ */
+
+/** Longest a folder size may take before it is written off. */
+export const TIMEOUT_MS = 15_000;
+/** Most size calls in flight at once, per project. */
+export const MAX_CONCURRENT = 4;
+/** Consecutive timeouts that mean the host is gone, not the folder slow. */
+export const FAILURES_TO_OPEN = 3;
+/** How long the breaker stays open before one request is let through to retry. */
+export const OPEN_MS = 30_000;
+
+/** Thrown when the breaker refuses a call outright. Callers treat it like any
+ *  other failure — the size is simply left unresolved. */
+export class DirSizeUnavailable extends Error {
+  constructor(reason: string) {
+    super(reason);
+    this.name = "DirSizeUnavailable";
+  }
+}
+
+interface ProjectGate {
+  /** Consecutive timeouts since the last success. */
+  failures: number;
+  /** Epoch ms until which the breaker is open; 0 when shut. */
+  openUntil: number;
+  /** Calls currently in flight. */
+  active: number;
+  /** Waiters parked on the concurrency cap, released FIFO. */
+  queue: Array<() => void>;
+}
+
+const gates = new Map<string, ProjectGate>();
+
+function gateFor(projectDir: string): ProjectGate {
+  let g = gates.get(projectDir);
+  if (!g) {
+    g = { failures: 0, openUntil: 0, active: 0, queue: [] };
+    gates.set(projectDir, g);
+  }
+  return g;
+}
+
+function acquire(g: ProjectGate): Promise<void> {
+  if (g.active < MAX_CONCURRENT) {
+    g.active += 1;
+    return Promise.resolve();
+  }
+  return new Promise<void>((resolve) => g.queue.push(resolve));
+}
+
+function release(g: ProjectGate): void {
+  const next = g.queue.shift();
+  if (next) {
+    // Hand the slot straight to the next waiter — `active` never drops.
+    next();
+    return;
+  }
+  g.active -= 1;
+}
+
+/**
+ * Run one folder-size call under the timeout, the concurrency cap and the
+ * breaker. Rejects (with {@link DirSizeUnavailable} when the breaker is open, or
+ * a timeout error) rather than hanging; the caller leaves the size unresolved.
+ *
+ * `run` is a thunk, not a promise, so a queued call is not *started* until it has
+ * a slot — passing an already-running promise would defeat the cap.
+ */
+export async function guardedDirSize<T>(projectDir: string, run: () => Promise<T>): Promise<T> {
+  const g = gateFor(projectDir);
+  if (g.openUntil > Date.now()) {
+    throw new DirSizeUnavailable("folder sizes paused: the project's host is not responding");
+  }
+  await acquire(g);
+  let timer: number | undefined;
+  try {
+    const result = await Promise.race([
+      run(),
+      new Promise<never>((_, reject) => {
+        timer = window.setTimeout(
+          () => reject(new Error(`folder size timed out after ${TIMEOUT_MS}ms`)),
+          TIMEOUT_MS,
+        );
+      }),
+    ]);
+    // Any answer at all proves the host is talking — shut the breaker.
+    g.failures = 0;
+    g.openUntil = 0;
+    return result;
+  } catch (e) {
+    // Only a *timeout* is evidence about the host. A call that came back with an
+    // error (an unreadable folder, a backend that lacks the command) answered
+    // fine, and must not push the project toward a breaker trip.
+    if (!(e instanceof DirSizeUnavailable) && timer !== undefined && isHostTimeout(e)) {
+      g.failures += 1;
+      if (g.failures >= FAILURES_TO_OPEN) g.openUntil = Date.now() + OPEN_MS;
+    }
+    throw e;
+  } finally {
+    if (timer !== undefined) window.clearTimeout(timer);
+    release(g);
+  }
+}
+
+/** Whether a rejection means *the host stopped answering* rather than the call
+ *  itself failing — the distinction that decides whether a retry could ever
+ *  help. Only this guard's own timeout qualifies. */
+export function isHostTimeout(e: unknown): boolean {
+  return e instanceof Error && e.message.includes("timed out");
+}
+
+/** Drop a project's gate — on project close, so a stale open breaker can't
+ *  outlive the tree that tripped it. Exported for tests too. */
+export function resetDirSizeGuard(projectDir?: string): void {
+  if (projectDir === undefined) gates.clear();
+  else gates.delete(projectDir);
+}
diff --git a/src/lib/diskUsage.ts b/src/lib/diskUsage.ts
new file mode 100644
index 0000000..bc40dc2
Binary files /dev/null and b/src/lib/diskUsage.ts differ
diff --git a/src/lib/dragPlatform.ts b/src/lib/dragPlatform.ts
new file mode 100644
index 0000000..d6bb5fd
--- /dev/null
+++ b/src/lib/dragPlatform.ts
@@ -0,0 +1,176 @@
+/**
+ * #42: per-platform pointer/window-event flags for the detached drag-drop system.
+ *
+ * The divergent semantics split cleanly as Linux (WebKitGTK) vs {Windows
+ * (WebView2/Chromium), macOS (WKWebView)}, so OS detection off `navigator.platform`
+ * is sufficient and more robust than UA engine-parsing. Linux retains its EXACT
+ * current values on all three flags, so the working platform is byte-for-byte
+ * unchanged. Each flag is documented at its declaration; together they isolate
+ * every event-semantics uncertainty into ONE file a single runtime session can flip.
+ */
+// OS detection lives in the dependency-free `platform.ts` single source of
+// truth; re-exported here so existing `dragPlatform` importers keep working.
+import { PLATFORM } from "./platform";
+// TEMPORARY (Windows drag QA — remove together with every releaseDbg call):
+// mirrors each gesture's terminal event into crash.log so a dead gesture can be
+// diagnosed without devtools. `invoke` throws outside a Tauri webview (vitest),
+// hence the try/catch.
+import { invoke } from "@tauri-apps/api/core";
+
+export { PLATFORM };
+
+// TEMPORARY drag QA logger — see import note above.
+function releaseDbg(message: string) {
+  try {
+    void invoke("report_frontend_error", { kind: "drag-debug", message, stack: null }).catch(() => {});
+  } catch {
+    /* diagnostics must never affect the gesture */
+  }
+}
+
+export interface DragPlatform {
+  /**
+   * Whether a `pointercancel` ending a mouse drag should COMMIT the drop (vs.
+   * ABORT it).
+   *
+   * - Linux/WebKitGTK fires `pointercancel` *instead of* `pointerup` (its native
+   *   gesture/selection heuristic claims the stream), so a cancel must COMMIT.
+   * - Windows/WebView2 (Chromium) ALSO ends these drags with `pointercancel`,
+   *   not `pointerup`: we `preventDefault()` the pointerdown and `setPointerCapture`
+   *   the dragged `.tab`, which `.tab.dragging` collapses to zero width — Chromium's
+   *   drag heuristic then cancels the mouse pointer at release. So Windows commits
+   *   on cancel too. (A GENUINE capture loss — alt-tab, a focus-stealing dialog —
+   *   raises `blur` first, and `bindDragRelease` aborts on `blur` for
+   *   capture-needing engines, so it never reaches this commit path.)
+   * - macOS/WKWebView fires a real `pointerup`; a `pointercancel` there is a
+   *   genuine capture loss → ABORT, not commit.
+   */
+  cancelCommits: boolean;
+  /**
+   * WebKitGTK keeps delivering the terminal pointer event to the source window
+   * after the cursor leaves it (implicit grab); Chromium/WKWebView do not without
+   * an explicit `setPointerCapture`. We need capture ONLY so the single terminal
+   * `pointerup`/`pointercancel` lands on the source window — continuous position
+   * is poll-driven (`startCursorPoll`), a much weaker dependency.
+   */
+  needsPointerCapture: boolean;
+  /**
+   * The whole-window `setPosition` follow during dock-back is cosmetic (the main
+   * window already paints the dock preview + ghost). On Win/mac, `setPosition`
+   * under a physically-held button can drop the webview's mouse capture and emit a
+   * spurious `pointercancel` mid-drag, so it is disabled there. Linux keeps it.
+   */
+  followWindowOnDockDrag: boolean;
+}
+
+export const dragPlatform: DragPlatform =
+  PLATFORM === "linux"
+    ? { cancelCommits: true, needsPointerCapture: false, followWindowOnDockDrag: true }
+    : PLATFORM === "windows"
+      ? // WebView2 ends the drag with `pointercancel` (see cancelCommits), so it
+        // must commit on cancel; it still needs explicit pointer capture and skips
+        // the window-follow (both as on macOS).
+        { cancelCommits: true, needsPointerCapture: true, followWindowOnDockDrag: false }
+      : { cancelCommits: false, needsPointerCapture: true, followWindowOnDockDrag: false };
+
+/**
+ * Bind the terminal-event listeners for a drag with engine-correct semantics, so
+ * no call site can drift from the `cancelCommits` policy. Returns an unbind fn.
+ *
+ * - `pointerup`      → `onCommit(shiftKey)` (a real release).
+ * - `pointercancel`  → `onCommit` when `cancelCommits` (WebKitGTK pointerup-proxy),
+ *                       else `onAbort` (a genuine capture loss on Chromium/WKWebView).
+ * - `keydown` Escape → `onAbort`.
+ * - `window` `blur`  → `onAbort` ONLY on capture-needing engines (Win/mac), as a
+ *                       backstop for a swallowed terminal event. Linux is excluded:
+ *                       its implicit grab reliably delivers the release, and a
+ *                       spurious WebKitGTK `blur` mid-drag must not abort the gesture
+ *                       (keeps the working platform byte-for-byte unchanged).
+ *
+ * Shift at commit: the terminal event's OWN `shiftKey` cannot be trusted on
+ * Windows — WebView2 ends these drags with a `pointercancel` it synthesizes
+ * (see `cancelCommits`), and a synthesized pointer event carries NO modifier
+ * state, so `ev.shiftKey` is always false there and the Shift gestures
+ * (force-a-new-window on tab/file drops) never fired. The binding therefore
+ * tracks the real Shift state itself — from keydown/keyup and from every
+ * `pointermove` (whose modifiers are trustworthy on all engines) — and commits
+ * with `ev.shiftKey || tracked`. Purely additive: a genuine `pointerup` with
+ * `shiftKey: true` behaves exactly as before, so Linux is unchanged.
+ *
+ * Single-fire: the first terminal event unbinds the rest. Callers keep their own
+ * idempotency guards (store `end()` is a no-op once cleared), so a redundant fire
+ * elsewhere is harmless.
+ */
+export function bindDragRelease(opts: {
+  target?: EventTarget;
+  onCommit: (shiftKey: boolean) => void;
+  onAbort: () => void;
+}): () => void {
+  const target = opts.target ?? window;
+  let done = false;
+  // Real Shift state, self-tracked because a WebView2-synthesized pointercancel
+  // reports no modifiers (see the doc comment above). keydown/keyup catch a
+  // Shift pressed while stationary; pointermove keeps it honest either way.
+  let shiftHeld = false;
+  const trackMove = (ev: PointerEvent) => {
+    shiftHeld = ev.shiftKey;
+  };
+  const unbind = () => {
+    if (target === window) {
+      window.removeEventListener("pointerup", onUp);
+      window.removeEventListener("pointercancel", onCancel);
+    } else {
+      target.removeEventListener("pointerup", onUp as EventListener);
+      target.removeEventListener("pointercancel", onCancel as EventListener);
+    }
+    window.removeEventListener("pointermove", trackMove);
+    window.removeEventListener("keydown", onKey);
+    window.removeEventListener("keyup", onKeyUp);
+    if (dragPlatform.needsPointerCapture) window.removeEventListener("blur", onBlur);
+  };
+  const fire = (fn: () => void) => {
+    if (done) return;
+    done = true;
+    unbind();
+    fn();
+  };
+  const onUp = (ev: PointerEvent) => {
+    releaseDbg(`terminal pointerup shift=${ev.shiftKey} tracked=${shiftHeld}`); // TEMPORARY drag QA
+    fire(() => opts.onCommit(ev.shiftKey || shiftHeld));
+  };
+  const onCancel = (ev: PointerEvent) => {
+    // TEMPORARY drag QA
+    releaseDbg(
+      `terminal pointercancel commits=${dragPlatform.cancelCommits} shift=${ev.shiftKey} tracked=${shiftHeld}`,
+    );
+    fire(() =>
+      dragPlatform.cancelCommits ? opts.onCommit(ev.shiftKey || shiftHeld) : opts.onAbort(),
+    );
+  };
+  const onKey = (ev: KeyboardEvent) => {
+    shiftHeld = ev.shiftKey;
+    if (ev.key === "Escape") {
+      releaseDbg("terminal escape → abort"); // TEMPORARY drag QA
+      fire(opts.onAbort);
+    }
+  };
+  const onKeyUp = (ev: KeyboardEvent) => {
+    shiftHeld = ev.shiftKey;
+  };
+  const onBlur = () => {
+    releaseDbg("terminal blur → abort"); // TEMPORARY drag QA
+    fire(opts.onAbort);
+  };
+  if (target === window) {
+    window.addEventListener("pointerup", onUp);
+    window.addEventListener("pointercancel", onCancel);
+  } else {
+    target.addEventListener("pointerup", onUp as EventListener);
+    target.addEventListener("pointercancel", onCancel as EventListener);
+  }
+  window.addEventListener("pointermove", trackMove);
+  window.addEventListener("keydown", onKey);
+  window.addEventListener("keyup", onKeyUp);
+  if (dragPlatform.needsPointerCapture) window.addEventListener("blur", onBlur);
+  return unbind;
+}
diff --git a/src/lib/experimental.ts b/src/lib/experimental.ts
new file mode 100644
index 0000000..2cac999
--- /dev/null
+++ b/src/lib/experimental.ts
@@ -0,0 +1,45 @@
+/**
+ * Experimental features and the one rule that governs them.
+ *
+ * An experimental feature is **off for everyone and on in debug mode**: the flag
+ * is a tri-state, and when it is unset the answer is `settings.debug`. That is the
+ * whole point of the gate — a feature that is still moving needs to be invisible
+ * to someone using Eldrun to work, and present *by default* for someone using
+ * Eldrun to build Eldrun, without them having to re-tick a list of toggles every
+ * time a new one lands.
+ *
+ * Unset is therefore NOT the same as false. An explicit value always wins, in both
+ * directions: a user can opt into one experiment without debug mode, and can switch
+ * one off while *in* debug mode — otherwise "turn this off" would silently fail for
+ * exactly the people most likely to hit a broken experiment.
+ *
+ * Adding an experiment: add its key to `Settings` (and to the Rust `Settings`, so
+ * it round-trips through `save_settings`), list it here, and read it through
+ * `useExperimental`. Never read `settings.<flag> ?? false` at the call site — that
+ * spelling is what makes a flag miss the debug default.
+ */
+
+import { useSettingsStore } from "../stores/settings";
+import type { Settings } from "../types";
+
+/** Every experimental flag. Keys of `Settings`, all `boolean | undefined`. */
+export const EXPERIMENTAL_FLAGS = [
+  "agent_mode_toggle",
+  "python_run_debug",
+  "deck_presenter",
+] as const;
+
+export type ExperimentalFlag = (typeof EXPERIMENTAL_FLAGS)[number];
+
+/** Is `flag` live? Explicit setting if there is one, else debug mode, else off. */
+export function experimentalEnabled(
+  settings: Settings | null | undefined,
+  flag: ExperimentalFlag,
+): boolean {
+  return settings?.[flag] ?? settings?.debug ?? false;
+}
+
+/** `experimentalEnabled` as a store subscription — the call site for a component. */
+export function useExperimental(flag: ExperimentalFlag): boolean {
+  return useSettingsStore((s) => experimentalEnabled(s.settings, flag));
+}
diff --git a/src/lib/fuzzy.ts b/src/lib/fuzzy.ts
new file mode 100644
index 0000000..8ec4e08
--- /dev/null
+++ b/src/lib/fuzzy.ts
@@ -0,0 +1,126 @@
+/**
+ * Pure, dependency-free fuzzy matcher + ranker (Dev B), used by the Ctrl/Cmd+P
+ * quick-open palette. Case-insensitive subsequence matching with a heuristic
+ * score that rewards consecutive runs, matches at separators / word /
+ * camelCase boundaries, and matches near the basename — so an exact basename
+ * hit ranks above a path-scattered one.
+ *
+ * Kept allocation-light: a single positions array per match, no regexps.
+ */
+
+export interface FuzzyResult {
+  /** Higher is a better match. */
+  score: number;
+  /** Indices into `text` of the matched characters, in order. */
+  positions: number[];
+}
+
+/** True for characters that begin a "word" segment in a path. */
+function isSeparator(ch: number): boolean {
+  // '/' '\\' '.' '_' '-' ' '
+  return ch === 47 || ch === 92 || ch === 46 || ch === 95 || ch === 45 || ch === 32;
+}
+
+function isUpper(ch: number): boolean {
+  return ch >= 65 && ch <= 90;
+}
+
+function isLower(ch: number): boolean {
+  return ch >= 97 && ch <= 122;
+}
+
+/**
+ * Case-insensitive subsequence match of `query` against `text`. Returns the
+ * matched positions and a heuristic score, or null when `query`'s characters
+ * do not all appear in order. An empty query trivially matches with score 0.
+ */
+export function fuzzyMatch(query: string, text: string): FuzzyResult | null {
+  if (query.length === 0) return { score: 0, positions: [] };
+  if (text.length === 0) return null;
+
+  const q = query.toLowerCase();
+  const t = text.toLowerCase();
+
+  // Index of the basename start (char after the last path separator).
+  let basenameStart = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 47 || text.charCodeAt(i) === 92) basenameStart = i + 1;
+  }
+
+  const positions: number[] = [];
+  let score = 0;
+  let qi = 0;
+  let prevMatch = -2; // index of previously matched char in text
+
+  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+    if (t.charCodeAt(ti) !== q.charCodeAt(qi)) continue;
+
+    positions.push(ti);
+
+    // Base reward for any matched char.
+    let bonus = 1;
+
+    // Consecutive run: previous query char matched the immediately prior text char.
+    if (prevMatch === ti - 1) {
+      bonus += 5;
+    }
+
+    // Boundary bonuses (only meaningful when not already a consecutive run).
+    const orig = text;
+    const prevCh = ti > 0 ? orig.charCodeAt(ti - 1) : -1;
+    const curCh = orig.charCodeAt(ti);
+    if (ti === 0 || isSeparator(prevCh)) {
+      // Start of the string or right after a separator (word boundary).
+      bonus += 4;
+    } else if (isUpper(curCh) && isLower(prevCh)) {
+      // camelCase boundary.
+      bonus += 3;
+    }
+
+    // Matches inside the basename are more valuable than deep-path matches.
+    if (ti >= basenameStart) {
+      bonus += 2;
+    }
+
+    score += bonus;
+    prevMatch = ti;
+    qi++;
+  }
+
+  if (qi < q.length) return null;
+
+  // Prefer matches whose span is tight (early + contiguous) over scattered ones.
+  const span = positions[positions.length - 1] - positions[0] + 1;
+  score -= (span - q.length) * 0.1;
+
+  // Slightly prefer the match starting earlier in the basename.
+  score -= positions[0] * 0.01;
+
+  return { score, positions };
+}
+
+/**
+ * Filter `items` to those whose `key` fuzzily matches `query`, sorted by score
+ * descending. Stable for ties via shorter-text then localeCompare. An empty
+ * query is a no-op: `items` is returned unchanged.
+ */
+export function fuzzyRank<T>(query: string, items: T[], key: (t: T) => string): T[] {
+  if (query.trim().length === 0) return items;
+
+  const scored: { item: T; text: string; score: number; idx: number }[] = [];
+  for (let i = 0; i < items.length; i++) {
+    const text = key(items[i]);
+    const m = fuzzyMatch(query, text);
+    if (m) scored.push({ item: items[i], text, score: m.score, idx: i });
+  }
+
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    if (a.text.length !== b.text.length) return a.text.length - b.text.length;
+    const c = a.text.localeCompare(b.text);
+    if (c !== 0) return c;
+    return a.idx - b.idx; // keep original order on full ties (stable)
+  });
+
+  return scored.map((s) => s.item);
+}
diff --git a/src/lib/gpu.ts b/src/lib/gpu.ts
new file mode 100644
index 0000000..7a52642
--- /dev/null
+++ b/src/lib/gpu.ts
@@ -0,0 +1,166 @@
+/**
+ * The GPU-memory arithmetic, shared by the three surfaces that show it (the
+ * header readout, the system-monitor pane, the local-model menu). Pure — the
+ * sampling lives in the backend's `gpustat`.
+ *
+ * The one thing worth internalizing is what "GPU memory" *is*. A GPU has two
+ * pools and both are reported, because on an integrated GPU only one of them is
+ * real: the dedicated **VRAM** carve-out (typically 512 MB on an APU — the
+ * framebuffer, permanently ~full, so reading it alone says nothing useful) and
+ * the **shared** pool the driver maps out of system RAM (amdgpu's GTT — where a
+ * model actually lands). So the headline figure is the two summed: on a discrete
+ * card the shared pool is 0 and it collapses to plain device VRAM, and on an APU
+ * it becomes the number that answers "will this model fit?".
+ */
+
+/** One GPU, as sampled by the backend `gpustat::GpuSample`. */
+export interface GpuSample {
+  name: string;
+  driver: string;
+  /** Dedicated device memory. */
+  vram_used: number;
+  vram_total: number;
+  /** System memory mapped for the GPU (GTT); 0 on a discrete card. */
+  shared_used: number;
+  shared_total: number;
+  /** `null` when the driver won't report utilization — not the same as idle. */
+  busy_percent: number | null;
+  // Sensor readings. Each is `undefined`/`null` when the driver won't report it
+  // (the backend omits absent ones), which is distinct from a real zero — an
+  // unread temperature is unknown, not 0 °C. All optional so existing fixtures and
+  // the memory-only `gpu_memory_snapshot` callers keep type-checking.
+  /** GPU temperature, °C. */
+  temp_c?: number | null;
+  /** Board power draw, watts. */
+  power_w?: number | null;
+  /** Board power limit/cap, watts. */
+  power_cap_w?: number | null;
+  /** Core (shader) clock, MHz. */
+  sclk_mhz?: number | null;
+  /** Memory clock, MHz. */
+  mclk_mhz?: number | null;
+  /** Fan speed, 0–100% of range (not RPM). */
+  fan_percent?: number | null;
+  /** Driver version string (NVIDIA only). */
+  driver_version?: string | null;
+  /** Current PCIe link generation (1–5) and lane width. */
+  pcie_gen?: number | null;
+  pcie_width?: number | null;
+}
+
+/** One process's GPU memory, from the backend `gpustat::GpuProc`. */
+export interface GpuProc {
+  pid: number;
+  name: string;
+  mem_bytes: number;
+}
+
+/** Both pools of every adapter, summed: the machine's GPU memory. */
+export function gpuTotals(gpus: GpuSample[]): { used: number; total: number } {
+  return gpus.reduce(
+    (acc, g) => ({
+      used: acc.used + g.vram_used + g.shared_used,
+      total: acc.total + g.vram_total + g.shared_total,
+    }),
+    { used: 0, total: 0 },
+  );
+}
+
+/** Highest utilization across adapters; `null` when no driver reports any. */
+export function gpuBusy(gpus: GpuSample[]): number | null {
+  const busy = gpus.map((g) => g.busy_percent).filter((b): b is number => b != null);
+  return busy.length > 0 ? Math.max(...busy) : null;
+}
+
+export function gpuPercent(used: number, total: number): number {
+  if (!(total > 0)) return 0;
+  return Math.min(100, Math.max(0, (used / total) * 100));
+}
+
+/**
+ * Tone by **ratio**, not by absolute bytes. The old GPU row warned at 1 GB and
+ * went hot at 2 GB — thresholds that made sense for a figure counting only
+ * Ollama's models, and that a system-wide reading would trip permanently.
+ */
+export function gpuTone(used: number, total: number): "low" | "medium" | "high" {
+  const pct = gpuPercent(used, total);
+  if (pct >= 85) return "high";
+  if (pct >= 60) return "medium";
+  return "low";
+}
+
+/** Byte formatter shared by the GPU readouts (MB under a GiB, else GB). */
+export function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const mib = bytes / 1024 / 1024;
+  if (mib < 1024) return `${Math.round(mib)} MB`;
+  return `${(mib / 1024).toFixed(1)} GB`;
+}
+
+/** Temperature as `NN °C`, or `null` when unknown. */
+export function formatTempC(c: number | null | undefined): string | null {
+  return c == null ? null : `${Math.round(c)} °C`;
+}
+
+/**
+ * Power as `NN W`, or `NN / MM W` when a cap is known — the draw against its
+ * ceiling. `null` when the draw itself is unknown.
+ */
+export function formatWatts(
+  draw: number | null | undefined,
+  cap?: number | null,
+): string | null {
+  if (draw == null) return null;
+  return cap != null ? `${Math.round(draw)} / ${Math.round(cap)} W` : `${Math.round(draw)} W`;
+}
+
+/** A clock as `N.NN GHz` (or `NNN MHz` below a GHz), or `null` when unknown. */
+export function formatMhz(mhz: number | null | undefined): string | null {
+  if (mhz == null) return null;
+  return mhz >= 1000 ? `${(mhz / 1000).toFixed(2)} GHz` : `${mhz} MHz`;
+}
+
+/** Fan speed as `NN%`, or `null` when unknown. */
+export function formatFan(pct: number | null | undefined): string | null {
+  return pct == null ? null : `${Math.round(pct)}%`;
+}
+
+/** PCIe link as `PCIe 4.0 ×16`, dropping whichever half is unknown; `null` for none. */
+export function gpuLinkLabel(gpu: GpuSample): string | null {
+  const gen = gpu.pcie_gen != null ? `PCIe ${gpu.pcie_gen}.0` : null;
+  const width = gpu.pcie_width != null ? `×${gpu.pcie_width}` : null;
+  const parts = [gen, width].filter((p): p is string => p != null);
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+
+/** One adapter, named and split back into its two pools, then its live sensors. */
+export function gpuAdapterTooltip(gpu: GpuSample): string {
+  const head =
+    gpu.busy_percent != null ? `${gpu.name} — ${Math.round(gpu.busy_percent)}% busy` : gpu.name;
+  const vram = `  VRAM    ${formatBytes(gpu.vram_used)} / ${formatBytes(gpu.vram_total)}`;
+  const shared =
+    gpu.shared_total > 0
+      ? `\n  Shared  ${formatBytes(gpu.shared_used)} / ${formatBytes(gpu.shared_total)}`
+      : "";
+  // Append only the sensors the driver actually reported, so a card that exposes
+  // none reads exactly as it did before these fields existed.
+  const sensors: string[] = [];
+  const temp = formatTempC(gpu.temp_c);
+  const power = formatWatts(gpu.power_w, gpu.power_cap_w);
+  const clocks = [formatMhz(gpu.sclk_mhz), formatMhz(gpu.mclk_mhz)].filter(Boolean).join(" / ");
+  const link = gpuLinkLabel(gpu);
+  if (temp) sensors.push(`  Temp    ${temp}`);
+  if (power) sensors.push(`  Power   ${power}`);
+  if (clocks) sensors.push(`  Clocks  ${clocks}`);
+  if (link) sensors.push(`  Link    ${link}`);
+  const tail = sensors.length > 0 ? `\n${sensors.join("\n")}` : "";
+  return `${head}\n${vram}${shared}${tail}`;
+}
+
+/**
+ * The header's breakdown: every adapter's two pools, then Ollama's share of it
+ * all — the figure this readout used to consist of, now one line of context.
+ */
+export function gpuTooltip(gpus: GpuSample[], ollamaBytes: number): string {
+  return [...gpus.map(gpuAdapterTooltip), `Ollama models: ${formatBytes(ollamaBytes)}`].join("\n");
+}
diff --git a/src/lib/hints.ts b/src/lib/hints.ts
new file mode 100644
index 0000000..6f4cf08
--- /dev/null
+++ b/src/lib/hints.ts
@@ -0,0 +1,166 @@
+import { IS_MAC, IS_WINDOWS } from "./platform";
+
+// The panel-toggle key is "Super" on Linux/KDE, "F9" on Windows (the lone Win
+// key belongs to the OS — Start opens on release and can't be suppressed, see
+// useKeyboard), and "Cmd (⌘)" on macOS — keep onboarding copy honest per OS.
+// Single source of truth shared by the Feature Guide, the How-to-start dialog,
+// and the contextual hints so the wording never drifts.
+export const PANEL_TOGGLE_KEY = IS_MAC
+  ? "Cmd (⌘)"
+  : IS_WINDOWS
+    ? "F9"
+    : "Super";
+
+// How to enter "focus mode" (panels hidden). On Linux a lone Super toggles the
+// panels; on Windows it's F9 (the Win key is OS-reserved); on macOS the Meta
+// key is reserved for Cmd shortcuts, so the lone-key toggle is disabled (see
+// useKeyboard) — there the panels stay reachable via the cursor-to-edge reveal.
+// F11 always toggles fullscreen. Keeps the onboarding copy accurate per OS.
+export const FOCUS_MODE_TIP = IS_MAC
+  ? "Panels auto-reveal when you push the cursor to a screen edge; press F11 for fullscreen."
+  : `Press ${PANEL_TOGGLE_KEY} (while Eldrun is focused) to hide the panels for a full-screen terminal, and F11 for fullscreen.`;
+
+/** One numbered step in the first-run "How to start" instruction. The same copy
+ *  feeds the dialog and the Feature Guide so onboarding stays in lockstep. */
+export interface HowToStep {
+  title: string;
+  body: string;
+}
+
+export const HOW_TO_START_STEPS: HowToStep[] = [
+  {
+    title: "Use the root terminal",
+    body:
+      "The ▣ logo (top-left) is your always-on control terminal, living in Eldrun's root folder. Click + on its tab bar to open a shell or an AI agent there.",
+  },
+  {
+    title: "Create or import a project",
+    body:
+      "Click + in the project bar to create a new project (scaffolds files and a git repo) or import an existing folder. Each project gets its own terminals, tabs, and file tree.",
+  },
+  {
+    title: "Add agents and tabs",
+    body:
+      "Use + on a project's tab bar to add a Claude, Codex, or Gemini agent — or a plain shell. Drag a tab to a pane edge to split the view side-by-side.",
+  },
+  {
+    title: "Find your files and focus",
+    body:
+      `Push your cursor to the right edge to reveal the file tree; click the pin to dock it. ${FOCUS_MODE_TIP}`,
+  },
+];
+
+/** Stable id for a contextual hint. Persisted in `settings.hints_seen`, so renaming
+ *  one resets it for everyone — pick carefully. */
+export type HintId =
+  | "create-project"
+  | "add-tab"
+  | "toggle-panels"
+  | "file-tree"
+  | "codex-hook-trust";
+
+/** Stable id for a hint's optional one-click action. An id rather than a callback
+ *  so this module stays pure and store-free (and `HINTS` stays a plain constant);
+ *  `HintHost` maps it to the handler. */
+export type HintActionId = "codex-hooks";
+
+/** A snapshot of the bits of app state the hint predicates care about, assembled
+ *  by HintHost from the projects/tabs stores. Kept tiny and serializable-ish so
+ *  predicates stay pure and testable. */
+export interface HintCtx {
+  /** Number of active project pills. */
+  projectCount: number;
+  /** The current project scope, or null at root / no active project. */
+  activeId: string | null;
+  /** A Codex tab is open and Codex is refusing to run Eldrun's session hook, so
+   *  resume is on the rollout-scanning fallback. Optional: absent means "not
+   *  probed" (no Codex tab open), which is never eligible. */
+  codexHookNeedsTrust?: boolean;
+}
+
+export interface HintDef {
+  id: HintId;
+  /** Higher wins when several hints are eligible at once (shown one at a time). */
+  priority: number;
+  /** `document.querySelector` selector for the element to point at, or null to
+   *  render as a centered top banner (no anchor). */
+  anchor: string | null;
+  /** Which side of the anchor the bubble sits on. Ignored for banners. */
+  placement: "top" | "bottom";
+  title: string;
+  body: string;
+  /** An extra button that *does* the thing the hint is about, instead of only
+   *  describing it. */
+  action?: { label: string; id: HintActionId };
+  /** Eligible to surface only while this returns true for the current context. */
+  when: (ctx: HintCtx) => boolean;
+}
+
+export const HINTS: HintDef[] = [
+  {
+    // Actionable and situational rather than onboarding filler, so it outranks
+    // everything but the empty-workspace prompt.
+    id: "codex-hook-trust",
+    priority: 90,
+    anchor: null,
+    placement: "top",
+    title: "Codex resume is running on a fallback",
+    body:
+      "Codex won't run Eldrun's session hook until you trust it, so Eldrun has to work out which conversation belongs to which tab by itself. Enable the hook once for exact resume.",
+    action: { label: "Enable in Codex", id: "codex-hooks" },
+    when: (c) => c.codexHookNeedsTrust === true,
+  },
+  {
+    id: "create-project",
+    priority: 100,
+    anchor: '[data-hint-anchor="add-project"]',
+    placement: "bottom",
+    title: "Create your first project",
+    body:
+      "Click + here to create or import a project. Each one gets its own terminal, tabs, and file tree.",
+    when: (c) => c.projectCount === 0,
+  },
+  {
+    id: "add-tab",
+    priority: 80,
+    anchor: '[data-hint-anchor="tab-add"]',
+    placement: "bottom",
+    title: "Add an AI agent",
+    body:
+      "Use + on the tab bar to open a Claude, Codex, or Gemini agent — or a plain shell. Drag tabs to a pane edge to split the view.",
+    when: (c) => c.activeId !== null,
+  },
+  {
+    id: "toggle-panels",
+    priority: 60,
+    anchor: null,
+    placement: "top",
+    title: "Focus mode",
+    body: FOCUS_MODE_TIP,
+    when: (c) => c.activeId !== null,
+  },
+  {
+    id: "file-tree",
+    priority: 50,
+    anchor: null,
+    placement: "top",
+    title: "Your project files",
+    body:
+      "Push your cursor to the right edge to reveal the file tree. Click the pin to keep it docked.",
+    when: (c) => c.activeId !== null,
+  },
+];
+
+/** Pure selection: the highest-priority unseen hint eligible for this context,
+ *  or null. Returns null when hints are disabled. Exported for unit tests. */
+export function pickHint(
+  ctx: HintCtx,
+  seen: ReadonlySet<string>,
+  enabled: boolean,
+): HintId | null {
+  if (!enabled) return null;
+  const eligible = HINTS.filter((h) => !seen.has(h.id) && h.when(ctx)).sort(
+    (a, b) => b.priority - a.priority,
+  );
+  return eligible[0]?.id ?? null;
+}
diff --git a/src/lib/hostKey.ts b/src/lib/hostKey.ts
new file mode 100644
index 0000000..b6a1d5d
--- /dev/null
+++ b/src/lib/hostKey.ts
@@ -0,0 +1,55 @@
+import { useHostKeyPromptStore } from "../stores/hostKeyPrompt";
+
+/**
+ * First-contact host-key confirmation, from the caller's side.
+ *
+ * The backend refuses to release a password to a host whose SSH key has never
+ * been accepted here, failing with an error that carries `UNKNOWN_HOST_KEY` and
+ * the resolved target (`services::ssh_common::guard_first_contact`). Everything
+ * needed to recover is *in that error*, so a connect opts in by wrapping itself
+ * in `withHostKeyConfirm` — no call site has to know or re-derive which host it
+ * was talking to.
+ *
+ * Deliberately not applied to background/launch paths (auto-connect, sync): those
+ * promise never to prompt, so they simply stay disconnected until the user
+ * connects by hand and answers this. That is the intended outcome, not a gap.
+ */
+
+/** Must match `services::ssh_common::UNKNOWN_HOST_KEY`. */
+export const UNKNOWN_HOST_KEY = "ELDRUN_UNKNOWN_HOST_KEY";
+
+/**
+ * The `host:port` an unknown-host-key failure names, or `null` if `e` is any
+ * other error. Tolerates the error being a string, an `Error`, or a Tauri
+ * rejection value.
+ */
+export function unknownHostKeyTarget(e: unknown): string | null {
+  const text = e instanceof Error ? e.message : String(e);
+  const at = text.indexOf(UNKNOWN_HOST_KEY);
+  if (at < 0) return null;
+  const target = text.slice(at + UNKNOWN_HOST_KEY.length).trim().split(/\s+/)[0];
+  return target || null;
+}
+
+/**
+ * Run `attempt`; if it failed only because the host key has never been accepted,
+ * show the fingerprint, and retry once if the user accepts it. Any other failure
+ * — and a declined fingerprint — propagates unchanged, so a caller's existing
+ * error handling is untouched.
+ *
+ * `attempt` is invoked at most twice and must therefore be safe to repeat, which
+ * every connect call is (the first one authenticated nothing).
+ */
+export async function withHostKeyConfirm<T>(attempt: () => Promise<T>): Promise<T> {
+  try {
+    return await attempt();
+  } catch (e) {
+    const target = unknownHostKeyTarget(e);
+    if (!target) throw e;
+    const trusted = await useHostKeyPromptStore.getState().request(target);
+    // Declining is a decision, not an error to paper over: re-throw the original
+    // so the caller's lamp/message reflects that the connect did not happen.
+    if (!trusted) throw e;
+    return await attempt();
+  }
+}
diff --git a/src/lib/hostKeyOnce.ts b/src/lib/hostKeyOnce.ts
new file mode 100644
index 0000000..415f078
--- /dev/null
+++ b/src/lib/hostKeyOnce.ts
@@ -0,0 +1,36 @@
+import { unknownHostKeyTarget } from "./hostKey";
+import { useHostKeyPromptStore } from "../stores/hostKeyPrompt";
+
+/**
+ * `withHostKeyConfirm` for a **retry loop**.
+ *
+ * The plain wrapper asks once per attempt, which is right for a single connect
+ * and wrong the moment the caller retries: the extend-to-remote flow dials the
+ * freshly-created remote up to six times, four seconds apart, so an unknown host
+ * key would put six identical fingerprint dialogs in front of the user — and a
+ * decline on the first would be re-asked five more times, which is not a decline
+ * at all.
+ *
+ * So the decision is taken **once per loop** and then held:
+ *  - accepted → the key is in `known_hosts` now, so later attempts simply run;
+ *  - declined → later attempts fail with the original error and never re-prompt,
+ *    because "no" is an answer and asking again is how a gate gets worn down.
+ *
+ * Call it once at the top of the loop and use the returned function for every
+ * attempt; a new loop makes a new one (a fingerprint decision is per act, not a
+ * setting).
+ */
+export function hostKeyConfirmOnce(): <T>(attempt: () => Promise<T>) => Promise<T> {
+  let decided: boolean | null = null;
+  return async function run<T>(attempt: () => Promise<T>): Promise<T> {
+    try {
+      return await attempt();
+    } catch (e) {
+      const target = unknownHostKeyTarget(e);
+      if (!target) throw e;
+      if (decided === null) decided = await useHostKeyPromptStore.getState().request(target);
+      if (!decided) throw e;
+      return attempt();
+    }
+  };
+}
diff --git a/src/lib/hpcGuard.ts b/src/lib/hpcGuard.ts
new file mode 100644
index 0000000..a007bd7
--- /dev/null
+++ b/src/lib/hpcGuard.ts
@@ -0,0 +1,132 @@
+/**
+ * The HPC tag's **confirmable** half, from the caller's side.
+ *
+ * Most of what the tag gates is simply switched off (sync loops, lockstep
+ * polling, auto-connect, the census). Two things can't be, because the user
+ * sometimes genuinely wants them: a disk-usage scan of the cluster tree, and
+ * running something that computes on the login node. What the tag buys there is
+ * that neither happens *silently* — the backend refuses with a sentinel naming what was
+ * refused and which machine it was protecting, and the caller opts into a dialog
+ * by wrapping itself in [`withHpcConfirm`].
+ *
+ * Exactly the shape `lib/hostKey.ts` already established for an unknown host key,
+ * and for the same reason: everything needed to explain and retry rides in the
+ * error, so no call site has to know in advance that its target might be a
+ * cluster, and the 99% of users with no cluster never see any of it.
+ *
+ * Confirmation is **per run**, never remembered. A tag that could be worn down by
+ * clicking through once is not a gate; and the thing being confirmed (a metadata
+ * storm, a job on a login node) is a specific act, not a policy.
+ */
+
+import { useHpcGuardStore, type HpcGuardKind } from "../stores/hpcGuardPrompt";
+
+/** Must match `services::hpc_mode::HPC_GUARD`. */
+export const HPC_GUARD = "ELDRUN_HPC_GUARD";
+
+export interface HpcGuardRefusal {
+  /** What was refused — the dialog switches its wording on this. */
+  kind: HpcGuardKind;
+  /** The `user@host:port` being protected, for the dialog to name. */
+  target: string;
+}
+
+/**
+ * The refusal an error carries, or `null` for any other failure. Tolerates the
+ * error being a string, an `Error`, or a raw Tauri rejection value.
+ */
+export function hpcGuardRefusal(e: unknown): HpcGuardRefusal | null {
+  const text = e instanceof Error ? e.message : String(e);
+  const at = text.indexOf(HPC_GUARD);
+  if (at < 0) return null;
+  const [kind, target] = text
+    .slice(at + HPC_GUARD.length)
+    .trim()
+    .split(/\s+/);
+  if (!kind) return null;
+  return { kind: kind as HpcGuardKind, target: target ?? "" };
+}
+
+/**
+ * Run `attempt(confirmed)`; if it refused only because the target is tagged HPC,
+ * explain what it would cost and retry once — with `confirmed: true` — if the
+ * user says go ahead. Any other failure, and a declined confirmation, propagates
+ * unchanged, so existing error handling is untouched.
+ *
+ * `attempt` is invoked at most twice and must be safe to repeat: the refused
+ * first call did nothing by construction (the gate is the command's first act).
+ */
+export async function withHpcConfirm<T>(attempt: (confirmed: boolean) => Promise<T>): Promise<T> {
+  try {
+    return await attempt(false);
+  } catch (e) {
+    const refusal = hpcGuardRefusal(e);
+    if (!refusal) throw e;
+    const ok = await useHpcGuardStore.getState().request(refusal.kind, refusal.target);
+    // Declining is an answer, not an error to paper over: the original refusal
+    // propagates so the caller's own "it didn't happen" path runs.
+    if (!ok) throw e;
+    return attempt(true);
+  }
+}
+
+/**
+ * Ask before doing something on a tagged host that only the **frontend** knows
+ * about — a Python or script run landing on a login node, where there is no
+ * backend command to refuse (the run is a terminal tab like any other). Returns
+ * whether to go ahead; `false` means the user backed out.
+ */
+export async function confirmOnHpcHost(kind: HpcGuardKind, target: string): Promise<boolean> {
+  return useHpcGuardStore.getState().request(kind, target);
+}
+
+/**
+ * The gate in front of anything that would **run on a login node**: a Python run
+ * or debug, or a shell script, whose resolved host is tagged HPC.
+ *
+ * Returns `true` to go ahead, `false` if the user backed out. A local run, an
+ * untagged host, or a scope with no project resolves `true` without asking, so
+ * the ordinary path costs one map lookup and no dialog.
+ *
+ * Why ask rather than refuse: the login node is the right place for plenty of
+ * work (editing, moving data, submitting jobs), and Eldrun cannot tell from a
+ * command line which kind this is. What it can do is make sure nobody computes
+ * there *by accident*, which is the whole of what the site's rule is about.
+ *
+ * Deliberately NOT applied to opening a plain shell tab. On a cluster you open
+ * shells constantly — to submit, to check a queue, to move a file — and a prompt
+ * on each would be the warning everybody learns to click through, which is worse
+ * than none. The gate sits on the two actions that *are* compute.
+ */
+export async function guardLoginNodeRun(opts: {
+  /** The project owning the run; `null`/`"root"` scopes are never on a cluster. */
+  projectId: string | null;
+  /** The tab `location` the run would carry — `undefined`/`"local"` is this
+   *  machine, `"remote"` the project's primary, `host:<id>` a worker. */
+  location: string | undefined;
+  kind: Extract<HpcGuardKind, "login-node-run">;
+}): Promise<boolean> {
+  // The two cheap facts first, BEFORE anything is imported or any store is read:
+  // a run with no host (the overwhelming majority — every local project) can be
+  // answered without loading a line of this machinery.
+  if (!opts.projectId || opts.projectId === "root") return true;
+  if (!opts.location || opts.location === "local") return true;
+
+  // Imported here rather than at module scope: this module is pulled in by the
+  // dialog's own store, and the project/settings stores drag half the app behind
+  // them — a cycle that only shows up as an undefined store at first render.
+  const { useProjectsStore } = await import("../stores/projects");
+  const { useSettingsStore } = await import("../stores/settings");
+  const { isHpcHost } = await import("./hpcHost");
+  const { hostsForProject } = await import("./remoteHosts");
+  const { PRIMARY_HOST } = await import("../stores/remoteStatus");
+
+  const project = useProjectsStore.getState().projects.find((p) => p.id === opts.projectId);
+  const hostId = opts.location === "remote" ? PRIMARY_HOST : opts.location.replace(/^host:/, "");
+  const host = hostsForProject(project).find((h) => h.id === hostId);
+  const settings = useSettingsStore.getState().settings;
+  if (!host?.target || !isHpcHost(settings, host.target)) return true;
+
+  const label = `${host.target.user ? `${host.target.user}@` : ""}${host.target.host}`;
+  return confirmOnHpcHost(opts.kind, label);
+}
diff --git a/src/lib/hpcHost.ts b/src/lib/hpcHost.ts
new file mode 100644
index 0000000..ba9ee8e
--- /dev/null
+++ b/src/lib/hpcHost.ts
@@ -0,0 +1,107 @@
+/**
+ * **The HPC tag** — "this machine is a shared cluster login node."
+ *
+ * One tick, set on the login form and shown on the machine's row in the Machines
+ * menu, behind which every behaviour a cluster's usage rules object to is gated:
+ *
+ * | Gated | Why |
+ * |---|---|
+ * | full stats collection | other users' account names / command lines are not ours to collect — a tagged host is careful whatever the Light/Detailed switch says |
+ * | disk-usage scan, giant-folder census | a recursive `du` over a parallel filesystem is a metadata storm against a shared server |
+ * | auto byte-sync (25 s), git lockstep poll (12 s) | the same walk, unasked for, forever |
+ * | silent auto-connect at launch | an SSH master and a tmux server on a login node nobody asked for this session |
+ * | login-node compute (shells, Python/script runs) | interactive compute belongs in `srun --pty`; a login node's rules reserve the right to kill it |
+ *
+ * **Why a user tag and not detection.** SLURM on `PATH` says a machine has a
+ * scheduler, not that its operators mind — a compute node held through `srun` has
+ * `sbatch` too, and there you own the machine outright for the length of the job.
+ * The property being tagged is the machine's *politics*, and only the user knows
+ * it. (The probes still detect SLURM for `careful` collection, which is a reading
+ * question with a safe default. This is a behaviour question with no safe guess.)
+ *
+ * **Keyed by SSH target**, exactly as `carefulHost.ts` is, and for the same
+ * reason: one login node is simultaneously a project's primary `remote`, another
+ * project's `compute_hosts` worker, and a project-free global machine. Tagging it
+ * once must tag it everywhere, so the identity is `user@host:port` rather than
+ * any of the three record ids.
+ */
+
+import { targetKey, type Target } from "./machineSync";
+import type { ProjectEntry, Settings } from "../types";
+
+export { primaryTargetOf, targetOfSpec } from "./carefulHost";
+export type { Target };
+
+/** Whether `target` is tagged as a cluster login node. `false` for a local
+ *  sample and for any host nobody has tagged — unlike careful mode there is no
+ *  default to fall back to, because every gate here changes what Eldrun *does*
+ *  and an untagged host must behave exactly as it always has. */
+export function isHpcHost(
+  settings: Settings | null | undefined,
+  target: Target | null | undefined,
+): boolean {
+  if (!target?.host) return false;
+  return settings?.hpc_hosts?.[targetKey(target)] === true;
+}
+
+/**
+ * **May Eldrun reach `target` without a gesture?** — the single authority behind
+ * every unattended path: the launch/VPN-up sweeps, the reachability probe, the
+ * dead-host silent reconnect, and the pool `lib/machineSync` opens to mirror one
+ * lamp onto another. Nothing re-derives the rule; they all ask here.
+ *
+ * **Fails closed while settings are unloaded.** `isHpcHost(null, …)` answering
+ * `false` is right for what it does — it decides whether to *draw a badge*, and a
+ * badge that can't be computed is simply not drawn — but the identical answer
+ * here would *authorise a connect*. Launch is precisely the window where settings
+ * are still in flight AND every sweep fires, so "we don't know yet" has to read as
+ * "not yet"; a moment's delay costs nothing, an SSH master left on a shared login
+ * node because the app started before its own settings arrived is the exact thing
+ * the tag exists to prevent.
+ *
+ * A target with no host is likewise `false` — there is nothing to reach, and a
+ * caller that lost its host must not fall through to "sure, go ahead".
+ */
+export function mayAutoTouch(
+  settings: Settings | null | undefined,
+  target: Target | null | undefined,
+): boolean {
+  if (!settings || !target?.host) return false;
+  return !isHpcHost(settings, target);
+}
+
+/** The patch that tags (or untags) `target`, for `useSettingsStore.updateSettings`.
+ *  Merges into the existing map — settings are saved whole, so a replace would
+ *  drop every other machine's tag. Untagging writes `false` rather than deleting,
+ *  so the two spellings a settings blob can carry stay one shape. */
+export function setHpcPatch(
+  settings: Settings | null | undefined,
+  target: Target,
+  hpc: boolean,
+): Pick<Settings, "hpc_hosts"> {
+  return { hpc_hosts: { ...(settings?.hpc_hosts ?? {}), [targetKey(target)]: hpc } };
+}
+
+/** Whether a project's **primary** host is tagged — the host that owns files,
+ *  git, the mirror and therefore every walk the gates are about. */
+export function projectIsOnHpc(
+  settings: Settings | null | undefined,
+  project: ProjectEntry | null | undefined,
+): boolean {
+  const r = project?.remote;
+  if (!r?.host) return false;
+  return isHpcHost(settings, { user: r.user || undefined, host: r.host, port: r.port ?? undefined });
+}
+
+/** Whether *any* host of this project — primary or a `compute_hosts` worker — is
+ *  tagged. Used where the question is "may this project run background work
+ *  against a cluster at all", rather than "is this particular host one". */
+export function projectTouchesHpc(
+  settings: Settings | null | undefined,
+  project: ProjectEntry | null | undefined,
+): boolean {
+  if (projectIsOnHpc(settings, project)) return true;
+  return (project?.compute_hosts ?? []).some((h) =>
+    isHpcHost(settings, { user: h.user || undefined, host: h.host, port: h.port ?? undefined }),
+  );
+}
diff --git a/src/lib/hpcWorkspace.ts b/src/lib/hpcWorkspace.ts
new file mode 100644
index 0000000..1de63b2
--- /dev/null
+++ b/src/lib/hpcWorkspace.ts
@@ -0,0 +1,322 @@
+/**
+ * HPC **workspaces** — the step that has to happen *before* any data reaches a
+ * cluster (`docs/quirky-knitting-umbrella` plan, Phase C; backend
+ * `commands::hpc_ws`).
+ *
+ * On a cluster `$HOME` is a small, quota'd filesystem meant for code, and the
+ * bulk data of a computation belongs on the big parallel filesystem — handed out
+ * by the `hpc-workspace` tooling as a **workspace**: a directory with a name, a
+ * duration, and an expiry after which it is *deleted* (`ws_allocate <name>
+ * <days>` — a typical site allows up to 90 days and three extensions, offers a
+ * general-purpose default location plus a faster SSD one, and removes the data
+ * some weeks after expiry). Nothing here is site-specific — the host is asked
+ * what it offers.
+ *
+ * The integration is deliberately *one line of consequence*: the wizard makes the
+ * allocated workspace path the project's **remote root**, so every transport
+ * Eldrun already has (SFTP upload, byte-sync, git lockstep, the run tabs) lands on
+ * the parallel filesystem instead of `$HOME` with no change of its own. The
+ * alternative layout — project in `$HOME`, workspace symlinked in as `data/` — is
+ * offered too, but its link is for the *host's* tools: Eldrun's byte-sync never
+ * follows a symlink (`remote_sync::walk_host_files`, guard G3), so host-side files
+ * under it are not mirrored. `linkedWorkspaceCaveat` is that sentence, in one
+ * place, so both surfaces say it identically.
+ *
+ * Untested against a real cluster.
+ */
+
+import { invoke } from "@tauri-apps/api/core";
+import type { HpcInfo, ProjectEntry } from "../types";
+
+export type { HpcInfo };
+
+// ── Backend types (mirror `commands::hpc_ws`) ────────────────────────────────
+
+export interface HpcWsFilesystem {
+  name: string;
+  default: boolean;
+}
+
+export interface HpcWsInfo {
+  available: boolean;
+  filesystems: HpcWsFilesystem[];
+}
+
+export interface HpcWorkspace {
+  id: string;
+  path: string;
+  filesystem?: string;
+  /** The tooling's own phrasing, e.g. `"89 days 23 hours"`. */
+  remaining?: string;
+  remaining_days?: number;
+  extensions?: number;
+  expiration?: string;
+}
+
+/**
+ * Where a workspace command runs. **Either** a project (its `projectDir`, riding
+ * the pooled ControlMaster exactly as SLURM does) **or** a bare host — because
+ * the wizard allocates a workspace *before* the project that will live in it
+ * exists. `password` is single-use and never persisted by this path.
+ */
+export interface HpcWsTarget {
+  projectDir?: string;
+  hostId?: string;
+  user?: string;
+  host?: string;
+  port?: number;
+  password?: string;
+}
+
+export interface HpcWsAllocateReq {
+  id: string;
+  days: number;
+  filesystem?: string;
+  reminderDays?: number;
+  mail?: string;
+  group?: string;
+  groupReadable?: boolean;
+}
+
+// ── Invoke wrappers ──────────────────────────────────────────────────────────
+
+/** Does this host hand out workspaces, and on which filesystems? A plain SSH host
+ *  answers `available: false` — the UI hides the step rather than erroring. */
+export function wsAvailable(target: HpcWsTarget): Promise<HpcWsInfo> {
+  return invoke<HpcWsInfo>("hpc_ws_available", { target });
+}
+
+/** The caller's existing workspaces on the host (`ws_list` + `ws_find`). */
+export function wsList(target: HpcWsTarget): Promise<HpcWorkspace[]> {
+  return invoke<HpcWorkspace[]>("hpc_ws_list", { target });
+}
+
+/** Allocate a workspace (`ws_allocate <id> <days>`). */
+export function wsAllocate(target: HpcWsTarget, req: HpcWsAllocateReq): Promise<HpcWorkspace> {
+  return invoke<HpcWorkspace>("hpc_ws_allocate", { target, req });
+}
+
+/** Extend a workspace, spending one of its extensions. The filesystem used at
+ *  allocation must be repeated, so pass the workspace's own. */
+export function wsExtend(
+  target: HpcWsTarget,
+  id: string,
+  days: number,
+  filesystem?: string,
+): Promise<HpcWorkspace> {
+  return invoke<HpcWorkspace>("hpc_ws_extend", { target, id, days, filesystem });
+}
+
+/** Release a workspace (the directory goes away; sites keep the data for a grace
+ *  period). Confirm before calling. */
+export function wsRelease(target: HpcWsTarget, id: string, filesystem?: string): Promise<void> {
+  return invoke("hpc_ws_release", { target, id, filesystem });
+}
+
+/** Symlink a workspace into a project's remote root as `<linkName>`. Returns the
+ *  created link's absolute host path. See `linkedWorkspaceCaveat`. */
+export function wsLink(
+  projectDir: string,
+  workspacePath: string,
+  linkName: string,
+): Promise<string> {
+  return invoke<string>("hpc_ws_link", { projectDir, workspacePath, linkName });
+}
+
+// ── Clusters without workspace tooling ───────────────────────────────────────
+
+/** A directory the site itself nominates for bulk data — the `hpc-workspace`-less
+ *  cluster's answer to "where does this project go". */
+export interface ScratchCandidate {
+  /** `env` (a variable the site's profile exports) or `path` (a convention). */
+  source: string;
+  label: string;
+  path: string;
+  writable: boolean;
+  free_kb?: number;
+}
+
+/**
+ * Ask a cluster with **no** `ws_allocate` where its big filesystem is. Without
+ * this the pipeline would put such a project in the browsed folder — `$HOME` —
+ * which is the failure the workspace step exists to prevent. Nothing is assumed
+ * about the site: it answers with the variables its own profile exports.
+ */
+export function scratchCandidates(target: HpcWsTarget): Promise<ScratchCandidate[]> {
+  return invoke<ScratchCandidate[]>("hpc_scratch_candidates", { target });
+}
+
+/** "1.2 TB free" from the probe's KiB, or `""` when `df` said nothing. Binary
+ *  units, matching what a cluster's own tools report. */
+export function freeSpaceLabel(kb: number | undefined): string {
+  if (kb === undefined || !Number.isFinite(kb)) return "";
+  const units = ["KB", "MB", "GB", "TB", "PB"];
+  let v = kb;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  return `${v < 10 ? v.toFixed(1) : Math.round(v)} ${units[i]} free`;
+}
+
+// ── The home anchor + the project's record (Phase 1) ─────────────────────────
+
+/** The per-project folder in the user's cluster home: `logs/`, a `workspace`
+ *  symlink, and the append-only `workspaces.txt` record. */
+export interface HpcAnchor {
+  dir: string;
+  logs_dir?: string;
+  link?: string;
+}
+
+/**
+ * Create (idempotently) the home anchor and append a record line naming the
+ * workspace. This is the folder that **outlives the workspace**: the logs are the
+ * provenance of what was run, the symlink makes an unmemorable site path
+ * `cd`-able, and the record carries the workspace *name* — the handle
+ * `ws_restore` needs once the directory is gone.
+ */
+export function wsAnchor(
+  target: HpcWsTarget,
+  opts: {
+    anchorRel: string;
+    workspacePath?: string;
+    workspaceId?: string;
+    projectName: string;
+    mirrorPath?: string;
+    makeLogs?: boolean;
+  },
+): Promise<HpcAnchor> {
+  return invoke<HpcAnchor>("hpc_ws_anchor", { target, ...opts });
+}
+
+/** Persist the project's workspace/anchor record (project.json + the projects.json
+ *  entry). Pass `null` to clear it. */
+export function setProjectHpc(projectId: string, hpc: HpcInfo | null): Promise<void> {
+  return invoke("set_project_hpc", { projectId, hpc });
+}
+
+/** Copy the anchor's `logs/` into the local mirror's `logs/`. Returns the count. */
+export function pullLogs(projectId: string, logsDir: string): Promise<number> {
+  return invoke<number>("hpc_ws_pull_logs", { projectId, logsDir });
+}
+
+/** Re-point the project's primary remote root (the expiry escape hatch). The
+ *  caller must disconnect/reconnect around it — the pool caches the spec. */
+export function moveProjectRoot(projectId: string, newRoot: string): Promise<ProjectEntry> {
+  return invoke<ProjectEntry>("hpc_ws_move_root", { projectId, newRoot });
+}
+
+// ── Pure helpers ─────────────────────────────────────────────────────────────
+
+/** A target for a project's own host (the Jobs view, an existing project). */
+export function wsTargetForProject(projectDir: string, hostId?: string): HpcWsTarget {
+  return { projectDir, ...(hostId ? { hostId } : {}) };
+}
+
+/** A target for a host with no project yet (the wizard, right after login). The
+ *  password is the credential that login authenticated with — the pooled
+ *  ControlMaster it left up usually means ssh needs none, but a site without
+ *  multiplexing would otherwise prompt where no prompt can be answered. */
+export function wsTargetForHost(
+  conn: { user?: string | null; host: string; port?: number | null },
+  password?: string,
+): HpcWsTarget {
+  return {
+    user: conn.user ?? undefined,
+    host: conn.host,
+    port: conn.port ?? undefined,
+    ...(password ? { password } : {}),
+  };
+}
+
+/** The site's default workspace filesystem, when it named one. */
+export function defaultFilesystem(info: HpcWsInfo | null): string | undefined {
+  return info?.filesystems.find((f) => f.default)?.name;
+}
+
+/** Where a project created *inside* `ws` would live on the host. */
+export function projectPathIn(ws: HpcWorkspace | { path: string }, safeName: string): string {
+  const root = ws.path.replace(/\/+$/, "");
+  if (!safeName) return root;
+  return `${root}/${safeName}`;
+}
+
+/** A one-line "89 days left · 3 extensions" summary, built only from the fields
+ *  the site actually reported (a version that prints neither yields `""`). */
+export function remainingLabel(ws: HpcWorkspace): string {
+  const parts: string[] = [];
+  if (ws.remaining_days !== undefined) {
+    parts.push(`${ws.remaining_days} ${ws.remaining_days === 1 ? "day" : "days"} left`);
+  } else if (ws.remaining) {
+    parts.push(`${ws.remaining} left`);
+  }
+  if (ws.extensions !== undefined) {
+    parts.push(`${ws.extensions} ${ws.extensions === 1 ? "extension" : "extensions"}`);
+  }
+  return parts.join(" · ");
+}
+
+/** How loudly to say it: a workspace is *deleted* at expiry, so the last week is
+ *  a warning and the last two days are urgent. `"none"` when the site reported no
+ *  remaining time — silence is better than a colour invented from nothing. */
+export function expiryTone(ws: HpcWorkspace): "none" | "ok" | "warn" | "urgent" {
+  const d = ws.remaining_days;
+  if (d === undefined) return "none";
+  if (d <= 2) return "urgent";
+  if (d <= 7) return "warn";
+  return "ok";
+}
+
+/** The default home-anchor location for a project: `eldrun/<safe-name>`, relative
+ *  to the cluster `$HOME` (the backend resolves and validates it there, so no
+ *  caller has to know the remote home). */
+export function defaultAnchorRel(safeName: string): string {
+  const clean = safeName.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `eldrun/${clean || "project"}`;
+}
+
+/** The `#SBATCH --output` value that routes a job's log into the home anchor —
+ *  where it survives the workspace it was produced in. `%j` is SLURM's job id. */
+export function logOutputPattern(logsDir: string): string {
+  return `${logsDir.replace(/\/+$/, "")}/slurm-%j.out`;
+}
+
+/** Find the project's own workspace in a listing, by the path its root sits in
+ *  (the recorded id is checked first — a site can move a workspace's path, but
+ *  the name is the handle). `undefined` when the project isn't in one. */
+export function findProjectWorkspace(
+  list: HpcWorkspace[],
+  hpc: HpcInfo | undefined,
+  remotePath: string | undefined,
+): HpcWorkspace | undefined {
+  if (hpc?.workspace_id) {
+    const byId = list.find((w) => w.id === hpc.workspace_id);
+    if (byId) return byId;
+  }
+  if (!remotePath) return undefined;
+  return list.find((w) => {
+    const root = w.path.replace(/\/+$/, "");
+    return remotePath === root || remotePath.startsWith(`${root}/`);
+  });
+}
+
+/** Whether an expiry warning is warranted, and how loud. Mirrors `expiryTone`,
+ *  but only for the workspace the project actually lives in — the point at which
+ *  expiry stops meaning "some data is deleted" and starts meaning "this project's
+ *  host tree is deleted". */
+export function shouldWarnExpiry(ws: HpcWorkspace | undefined): boolean {
+  if (!ws) return false;
+  const tone = expiryTone(ws);
+  return tone === "warn" || tone === "urgent";
+}
+
+/** The caveat that must accompany every "link the workspace into the project"
+ *  affordance — in ONE place so both the wizard and the Jobs view say it the
+ *  same way. Eldrun's byte-sync walks the host tree lstat-typed and skips
+ *  symlinks by design, so a linked workspace is reachable to the *host's* tools
+ *  (job scripts, `cd`), not to the mirror. */
+export const linkedWorkspaceCaveat =
+  "The link is for your job scripts on the host — Eldrun's file sync does not follow it, " +
+  "so files written inside the workspace are not mirrored locally.";
diff --git a/src/lib/i18n.ts b/src/lib/i18n.ts
new file mode 100644
index 0000000..4816250
--- /dev/null
+++ b/src/lib/i18n.ts
@@ -0,0 +1,7478 @@
+import { useMemo } from "react";
+import { create } from "zustand";
+
+/**
+ * Eldrun's in-house internationalization (i18n) — the ONE place every language
+ * lives, so adding a string or a whole language is a single edit here and never
+ * a hunt through the component tree.
+ *
+ * Design (kept deliberately dependency-free — no i18next, no network):
+ *  - `TRANSLATIONS` is a flat `lang → (key → text)` map. English (`en`) is the
+ *    source of truth and holds *every* key; the other languages provide what
+ *    they translate and fall back to English (then to the raw key) for anything
+ *    missing, so a half-translated language degrades gracefully instead of
+ *    rendering blanks.
+ *  - The current language is a tiny zustand store (`useI18nStore`). Switching is
+ *    **instant**: `setLangLocal` flips one field and every component reading
+ *    `useT()` re-renders in place — no reload, no restart. Persistence rides the
+ *    ordinary settings file (`Settings.language`); this store is only the live,
+ *    reactive mirror, seeded from a localStorage cache so the first paint after
+ *    launch already shows the chosen language before settings finish loading.
+ *
+ * To add a language: add its code to `Language`, a `{ value, label }` row to
+ * `LANGUAGES`, and a block to `TRANSLATIONS`. To add a string: add the key to
+ * the `en` block (and, ideally, the others) and call `t("your.key")`.
+ */
+export type Language = "en" | "de" | "es" | "fr" | "it";
+
+/** The languages offered in the switcher, labelled in their own tongue. */
+export const LANGUAGES: { value: Language; label: string }[] = [
+  { value: "en", label: "English" },
+  { value: "de", label: "Deutsch" },
+  { value: "es", label: "Español" },
+  { value: "fr", label: "Français" },
+  { value: "it", label: "Italiano" },
+];
+
+const LANG_CODES = new Set<string>(LANGUAGES.map((l) => l.value));
+
+/** Coerce an arbitrary string (settings value, cache) to a supported language. */
+export function normalizeLang(value: string | null | undefined): Language {
+  return value && LANG_CODES.has(value) ? (value as Language) : "en";
+}
+
+// English is the base: it defines the full key set. Other languages need only
+// override; anything absent falls through to English via `translate`.
+const en = {
+  // Common action words, shared across surfaces.
+  "common.back": "Back",
+  "common.cancel": "Cancel",
+  "common.remove": "Remove",
+  "common.delete": "Delete",
+  "common.add": "Add",
+  "common.reset": "Reset",
+  "common.recheck": "Re-check",
+  "common.loading": "Loading…",
+  "common.default": "default",
+
+  // Settings — main panel.
+  "settings.title": "Settings",
+  "settings.theme": "Theme",
+  "settings.language": "Language",
+  "settings.language.help":
+    "Sets the language of Eldrun's interface. Takes effect immediately — no restart needed.",
+  "settings.runScriptsBg": "Run scripts in background",
+  "settings.claudeRemote": "Claude remote control",
+  "settings.headlessRemote": "Headless remote connections",
+  "settings.persistLocal": "Persistent local sessions (tmux)",
+  "settings.remoteFeatures": "Remote features",
+  "settings.vpnEnabled": "OpenVPN tunnel control",
+  "settings.machinesEnabled": "Global remote machines",
+  "settings.energySaver": "Energy saver",
+  "energy.off": "Off",
+  "energy.battery": "On battery",
+  "energy.always": "Always",
+  "settings.debug": "Debug mode",
+  "settings.experimental": "Experimental",
+  "settings.agentModeToggle": "Plan/Auto toggle on agent tabs",
+  "settings.pythonRunDebug": "Python Run/Debug in the code viewer",
+  "settings.resourceMonitor": "Resource monitor",
+  "settings.showCpu": "Show CPU usage",
+  "settings.showRam": "Show RAM usage",
+  "settings.showGpu": "Show GPU usage",
+  "settings.showClockSeconds": "Show seconds in header clock",
+
+  // Settings — calendar.
+  "settings.calendar": "Calendar",
+  "settings.weekStartsOn": "Week starts on",
+  "day.sunday": "Sunday",
+  "day.monday": "Monday",
+  "settings.defaultView": "Default view",
+  "view.day": "Day",
+  "view.week": "Week",
+  "view.multiweek": "Multiweek",
+  "view.month": "Month",
+  "view.agenda": "Agenda",
+  "view.tasks": "Tasks",
+  "settings.clock24": "24-hour clock",
+  "settings.dayGridStart": "Day grid starts at",
+  "settings.defaultReminder": "Default reminder",
+  "reminder.none": "None",
+  "reminder.5": "5 minutes before",
+  "reminder.15": "15 minutes before",
+  "reminder.30": "30 minutes before",
+  "reminder.60": "1 hour before",
+  "reminder.1440": "1 day before",
+
+  // Settings — hints & onboarding.
+  "settings.hintsOnboarding": "Hints & onboarding",
+  "settings.showHints": "Show contextual hints",
+  "settings.howToStart": "How to start...",
+  "settings.takeTour": "Take a tour",
+  "settings.lessons": "Lessons",
+  "settings.resetHints": "Reset hints",
+
+  // Settings — layout.
+  "settings.layout": "Layout",
+  "settings.windowZoom": "Window zoom",
+  "settings.minSubWidth": "Min subwindow width (px)",
+  "settings.minSubHeight": "Min subwindow height (px)",
+
+  // Settings — downloads.
+  "settings.downloads": "Downloads",
+  "settings.noDownloadFolders": "No folders added — the system Downloads folder is used.",
+  "settings.addDownloadFolder": "Add download folder...",
+
+  // Settings — usage stats.
+  "settings.usageStats": "Usage stats",
+  "settings.dailyRecap": "Show the recap at the start of each day",
+  "settings.openUsageStats": "Open usage stats",
+
+  // Settings — sub-panel navigation ("More settings").
+  "settings.moreSettings": "More settings",
+  "nav.git.title": "Git Hosting",
+  "nav.git.blurb": "Hosting profile, access token, and publishing.",
+  "nav.vpn.title": "VPN Auto-Connect",
+  "nav.vpn.blurb": "Arm a stored tunnel to connect on launch.",
+  "nav.remoteHosts.title": "Remote Connections",
+  "nav.remoteHosts.blurb": "Set a standard path per SSH host.",
+  "nav.global.title": "Global Apps",
+  "nav.global.blurb": "Toolbar launchers shown across every project.",
+  "nav.filetypes.title": "File Type Apps",
+  "nav.filetypes.blurb": "Choose which app opens each file type.",
+  "nav.agents.title": "Manage Agents",
+  "nav.agents.blurb": "Install or update the agent CLIs.",
+  "nav.shortcuts.title": "Keyboard Shortcuts",
+  "nav.shortcuts.blurb": "Rebind the navigation chords.",
+  "nav.archive.title": "Archived Projects",
+  "nav.archive.blurb": "Restore or permanently delete archived projects.",
+  "nav.scaffoldRepair.title": "Repair Project Scaffold",
+  "nav.scaffoldRepair.blurb": "Regenerate missing scaffold files.",
+  "nav.help.title": "Feature Guide",
+  "nav.help.blurb": "Full glossary of Eldrun's features.",
+  "settings.energyUnavailable": "Power state unavailable — treating as AC (inactive).",
+  "settings.energyActiveAlways": "Currently active — always on.",
+  "settings.energyActiveBattery": "Currently active — running on battery.",
+  "settings.energyOff": "Off — never throttles.",
+  "settings.energyInactive": "Inactive — on AC power.",
+  "settings.claudeRemoteHelp1": "Spawns Claude agent tabs with",
+  "settings.claudeRemoteHelp2": "so you can monitor and steer them from the Claude app or web. Requires a Claude subscription login (not an API key); only Claude supports it.",
+  "settings.headlessRemoteHelp": "When on (default), Eldrun makes SSH/OpenVPN connections in the background, handling the password transiently. Turn it off to instead open each connection as an interactive terminal in the Eldrun root — you type the password directly into that terminal and Eldrun never handles it.",
+  "settings.persistLocalHelp1": "When on (default), a local project's shell and Python/script tabs run inside a tmux session on this machine, so a long run keeps going if Eldrun crashes and the tab reattaches on restart. Closing a tab still ends its session. Requires",
+  "settings.persistLocalHelp2": "; agent tabs are unaffected.",
+  "settings.remoteFeaturesHelp": "Both add a machine-wide control to the header: an OpenVPN tunnel (routes this whole computer's traffic while up) and a list of SSH machines no project owns. Off by default; asked about once on first launch.",
+  "settings.energyHelp": "When active, Eldrun eases off to save power: it pauses the project blob's idle spin, calms the status glows, and slows background refreshes. \"On battery\" (default) does this only while unplugged.",
+  "settings.experimentalHelp1": "Features that are still moving. Each is off by default and",
+  "settings.experimentalHelpBold": "on by default in Debug mode",
+  "settings.experimentalHelp2": "— so building Eldrun means seeing them without re-ticking this list every time a new one lands. A switch here always wins, in either direction: you can take one on without Debug mode, or turn one off while in it.",
+  "settings.agentModeHelp1": "Puts a badge on each agent tab that switches it between",
+  "settings.agentModeHelp2": "(reads and proposes, never edits) and",
+  "settings.agentModeHelp3": "(auto-accepts edits; shell and network commands still ask) — so one tab can plan while another does the work, and each comes back in its mode after a restart. Switching restarts the agent: the conversation is resumed, but the terminal's scrollback is lost. Only Claude supports it — it is the one agent that can both be launched into a mode and resume its conversation on restart.",
+  "settings.pythonRunHelp1": "Gives a",
+  "settings.pythonRunHelp2": "file open in the editor a",
+  "settings.pythonRunHelp3": "and a",
+  "settings.pythonRunHelp4": "button, and turns its line numbers into a breakpoint gutter. Both open a terminal tab in the project — so they run on the host of a remote project and inside the container of a containerised one — and use the project's own interpreter. Debug is",
+  "settings.pythonRunHelp5": ", pre-loaded with the gutter's breakpoints. Off by default because Run executes the file. Ctrl+Click to a definition is not gated: it only reads.",
+  "settings.resourceMonitorHelp": "CPU and RAM cover Eldrun's own process tree; GPU shows VRAM in use by local models loaded in Ollama. The pill appears in the header next to the timer.",
+  "settings.reminderHelp": "Reminders fire as a desktop notification and as an in-app popup you can snooze. \"Day grid starts at\" only sets where the day and week views scroll to — earlier events are still there, just above the fold.",
+  "settings.zoomHelp1": "Window zoom scales the entire Eldrun interface — handy on 4K / high-DPI monitors. 100% is the default. Zoom is",
+  "settings.zoomHelpBold": "per window",
+  "settings.zoomHelp2": ": this sets the main window, and each popped-out subwindow keeps its own. Ctrl + / Ctrl − zoom the focused window and Ctrl 0 resets it.",
+  "settings.minSubwindowHelp": "Smallest a subwindow may be made by dragging a split divider. Defaults to {px}px when left blank.",
+  "settings.downloadsHelp": "Folders scanned by the right-panel Downloads section (the 📥 toggle), for quickly copying freshly downloaded files into a project. Read-only — Eldrun never changes any browser's download path. Defaults to your system Downloads folder when empty.",
+  "settings.removeFolderTitle": "Remove this folder",
+  "settings.dailyRecapHelp": "A summary of the day just finished: which agents you used and how much you asked them, files created/modified/deleted, commits, and time per project. Turning this off stops the popup, not the counting — everything stays local.",
+
+  // Settings — keyboard shortcuts panel.
+  "shortcuts.help":
+    "Click a shortcut, then press the new key combination. F11 (OS fullscreen) and Escape (exit fullscreen) are fixed and cannot be rebound.",
+  "shortcuts.captureTitle": "Click, then press a key combination",
+  "shortcuts.pressKeys": "Press keys…",
+  "shortcuts.resetTitle": "Reset to default",
+
+  // Settings — Git hosting panel.
+  "git.help":
+    "Your hosting profile and access token are used when publishing a project's repo to GitHub or GitLab.",
+  "git.profileUrl": "Profile URL",
+  "git.profileUrlPlaceholder": "https://github.com/me or https://gitlab.com/me",
+  "git.accessToken": "Access token",
+  "git.tokenPlaceholder": "ghp_... / glpat-...",
+
+  // Settings — VPN auto-connect panel.
+  "vpn.autoConnectHelp":
+    "Arm one stored OpenVPN tunnel to come up automatically when Eldrun starts. It reroutes this computer's traffic — not just Eldrun's — for as long as it is up, so only one config can be armed at a time; arming another disarms the first. Stored configs are added from a remote project's Connect dialog or the VPN menu in the header.",
+  "vpn.noConfig": "No OpenVPN config stored yet. Add one from a remote project's Connect dialog.",
+  "vpn.needsSavedPre": "Connect once with",
+  "vpn.needsSavedBold": "Save passphrase",
+  "vpn.needsSavedPost": "ticked to enable this — auto-connect never prompts.",
+  "vpn.startsWithEldrun": "Starts with Eldrun",
+  "vpn.waitsInRootTerminal": "(waits in the root terminal)",
+
+  // Settings — archived projects panel.
+  "archive.help":
+    "Deleted projects are kept here so you can restore them. Permanent deletion removes the archived copy and its time-tracking history. A remote (SSH) project's files on its host are never touched.",
+  "archive.empty": "No archived projects.",
+  "archive.remoteTag": "remote",
+  "archive.unsyncedVerifiedOne":
+    "{count} local commit on {branches} was never synced to the host and will be lost. The host's own files are unaffected.",
+  "archive.unsyncedVerifiedMany":
+    "{count} local commits on {branches} were never synced to the host and will be lost. The host's own files are unaffected.",
+  "archive.unsyncedUnverifiedOne":
+    "This mirror holds {count} commit that could not be verified against the host; deleting discards the local copy. The host's own files are unaffected.",
+  "archive.unsyncedUnverifiedMany":
+    "This mirror holds {count} commits that could not be verified against the host; deleting discards the local copy. The host's own files are unaffected.",
+  "archive.typeToDelete": "Type “{name}” to delete",
+  "archive.deleteForever": "Delete forever",
+  "archive.deleting": "Deleting…",
+  "archive.restore": "Restore",
+  "archive.restoring": "Restoring…",
+  "archive.deletePermanently": "Delete permanently…",
+  "archive.typeDeleteAll": "Type “delete” to clear all",
+  "archive.clearArchive": "Clear archive",
+  "archive.clearing": "Clearing…",
+  "archive.clearArchiveEllipsis": "Clear archive…",
+
+  // Settings — scaffold repair panel.
+  "scaffoldRepair.help":
+    "Fills in any scaffold file (AGENTS.md, CLAUDE.md, .claude/settings.json, …) or default .gitignore pattern that a project is missing — e.g. because it was created before that file/pattern was added to the default scaffold. Existing files are never overwritten; a pre-existing .gitignore only has missing default lines appended. Runs across every managed project (local directory or, for remote projects, their local mirror).",
+  "scaffoldRepair.runNow": "Repair all projects now",
+  "scaffoldRepair.running": "Repairing…",
+  "scaffoldRepair.upToDate": "Every project's scaffold is already up to date.",
+
+  // Settings — help / feature guide panel.
+  "help.title": "Eldrun Help",
+  "help.intro": "A quick guide to what each part of Eldrun does. Hover the toolbar buttons for shortcuts too.",
+  "help.workspaceLayout.title": "Workspace layout",
+  "help.workspaceLayout.introMac":
+    "Eldrun keeps your AI-assisted development in a single window. Push your cursor to a screen edge to reveal the panels, and press F11 for fullscreen.",
+  "help.workspaceLayout.introOther":
+    "Eldrun keeps your AI-assisted development in a single window. Press {key} while Eldrun is focused to toggle the panels, and F11 for fullscreen.",
+  "help.workspaceLayout.item1.term": "Root terminal (▣)",
+  "help.workspaceLayout.item1.desc":
+    "The control terminal that always lives in Eldrun's root folder, independent of any project.",
+  "help.workspaceLayout.item2.term": "Project pills",
+  "help.workspaceLayout.item2.desc":
+    "One pill per active project in the project switcher. Click to switch; each project keeps its own terminal and tabs. Drag pills to reorder them.",
+  "help.workspaceLayout.item3.term": "Center panel & tabs",
+  "help.workspaceLayout.item3.desc":
+    "The active project's terminals. Right-click the tab bar to add a Claude/Codex/Gemini agent or a plain shell, rename, or close tabs. Drag tabs to reorder.",
+  "help.workspaceLayout.item4.term": "Right file panel",
+  "help.workspaceLayout.item4.desc":
+    "A file-tree overlay for the active project. Open files, rename, and toggle hidden file types. The panel remembers the last folder per project.",
+  "help.projects.title": "Projects",
+  "help.projects.item1.term": "Add (+)",
+  "help.projects.item1.desc":
+    "Create a New Project (scaffolds files and a git repo in Eldrun's projects folder) or Import an existing folder without touching its contents.",
+  "help.projects.item2.term": "Search inactive",
+  "help.projects.item2.desc":
+    "The search box finds projects that aren't currently open; pick one to activate its pill and terminal.",
+  "help.projects.item3.term": "Remote (SSH) projects",
+  "help.projects.item3.desc":
+    "Projects on a remote host are sshfs-mounted locally and behave like any other project. Requires sshfs/FUSE installed.",
+  "help.projects.item4.term": "Tasks",
+  "help.projects.item4.desc":
+    "Right-click a tab to set, complete, or clear an agent task. Tasks persist in the project's project.json and can seed a new agent's prompt.",
+  "help.aiTerminals.title": "AI & terminals",
+  "help.aiTerminals.item1.term": "Agents",
+  "help.aiTerminals.item1.desc":
+    "Open an agent (claude, codex, gemini, vibe, aider, opencode, cursor, copilot, grok, qwen, openclaw) or a plain shell from the + menu on the tab bar. Missing commands fall back to a shell; closed agents respawn.",
+  "help.aiTerminals.item2.term": "Ollama models",
+  "help.aiTerminals.item2.desc":
+    "When Ollama is installed, the gear menu shows local models. Ctrl+K opens the local-model prompt dialog for the active context.",
+  "help.settingsExtras.title": "Settings & extras",
+  "help.settingsExtras.item1.term": "Settings (⚙)",
+  "help.settingsExtras.item1.desc":
+    "Theme, Git hosting profile/token, workspace management, background scripts, and debug mode.",
+  "help.settingsExtras.item2.term": "Workspace integration",
+  "help.settingsExtras.item2.desc":
+    "Per-project KDE/X11 virtual-desktop isolation (Linux only): each project's launched windows park on their own desktop.",
+  "help.settingsExtras.item3.term": "Time tracking",
+  "help.settingsExtras.item3.desc":
+    "Eldrun records active session time so you can see how long you spend per project.",
+
+  // Settings — Global Apps panel.
+  "globalApps.title": "Global Apps",
+  "globalApps.help": "Apps that stay visible across workspaces. Checked apps appear in the top toolbar.",
+  "globalApps.showRole": "Show {role}",
+  "globalApps.notFoundPlaceholder": "not found",
+
+  // Settings — File Type Apps panel.
+  "filetypes.title": "File Type Apps",
+  "filetypes.help": "Double-clicking a project file opens it with the app below.",
+  "filetypes.extPlaceholder": ".ext",
+  "filetypes.appPlaceholder": "app command",
+
+  // Settings — Remote Connections panel.
+  "remoteHosts.help":
+    "The folder a connect or browse opens in for a given SSH host, instead of the host's home directory. Set once here and it applies the next time you connect to that host — for a new remote project's folder browser and for reconnecting an existing one.",
+  "remoteHosts.empty": "No standard paths set — hosts default to their home directory.",
+  "remoteHosts.hostPlaceholder": "host",
+  "remoteHosts.pathPlaceholder": "/path/on/host",
+
+  // Settings — Manage Agents panel.
+  "agents.help1":
+    "AI coding agents Eldrun can launch as agent tabs. Install one with a single click (no administrator rights needed), then add it from a tab bar's",
+  "agents.help2": "menu. Many installers need",
+  "agents.help3": "on your",
+  "agents.help4": "— if it's missing, install Node.js first below.",
+  "agents.checkingInstalled": "Checking installed agents…",
+  "agents.installed": "installed",
+  "agents.notInstalled": "not installed",
+  "agents.disableToggleTitle":
+    "Hide this agent from tab-choice menus (add-tab Agents list, Local Model drivers) without uninstalling it",
+  "agents.disableAriaEnable": "Enable {label} in tab menus",
+  "agents.disableAriaDisable": "Disable {label} in tab menus",
+  "agents.disabled": "Disabled",
+  "agents.enabled": "Enabled",
+  "agents.removeTitle": "Remove the installed CLI",
+  "agents.removing": "Removing…",
+  "agents.remove": "Remove",
+  "agents.reinstallTitle": "Remove then run the official installer again",
+  "agents.reinstalling": "Reinstalling…",
+  "agents.reinstall": "Reinstall",
+  "agents.permissionHelpPre": "If Remove fails with a permission error, run it in a",
+  "agents.permissionHelpPost": "terminal tab instead (add",
+  "agents.permissionHelpPost2": "if prompted):",
+  "agents.runInTerminal": "Run in terminal",
+  "agents.installing": "Installing…",
+  "agents.installLabel": "Install {label}",
+  "agents.runningInstaller": "Running installer…",
+  "agents.orInstallInShellPre": "Or install it in a",
+  "agents.orInstallInShellPost": "terminal tab:",
+  "agents.noWindowsInstallerPre": "No one-line Windows installer yet — see",
+  "agents.installDocs": "the install docs",
+  "agents.noWindowsInstallerPost": ", then click",
+  "agents.stillNotDetected": "Still not detected — try a fresh terminal so the install dir is on PATH.",
+  "agents.codexHookLabel": "Session hook",
+  "agents.codexHookDisabled": "disabled",
+  "agents.codexHookNotTrusted": "not trusted",
+  "agents.codexHookHelpPre":
+    "Codex won't run Eldrun's session hook until you trust it, so Eldrun falls back to working out which conversation belongs to which tab from Codex's own logs. That works, but it can mix up two Codex tabs open in the same folder. Enable",
+  "agents.codexHookHelpPost": "in Codex's",
+  "agents.codexHookHelpPost2": "list for exact resume:",
+  "agents.openInCodex": "Open in Codex",
+  "agents.nodeNotDetected": "not detected",
+  "agents.nodeHelpPre": "Most agent CLIs install with",
+  "agents.nodeHelpMid": ", which ships with Node.js. Install it once (no administrator rights needed) in a",
+  "agents.nodeHelpPost": "terminal tab, then install your agents below:",
+  "agents.nodeManualPre": "Prefer a manual install? See",
+  "agents.nodeDownloads": "the Node.js downloads",
+
+  // Settings — Ollama Models panel.
+  "ollama.vibeTitle": "Local model runtime (Vibe)",
+  "ollama.vibeChecking": "Checking for Vibe…",
+  "ollama.vibeInstalled": "Vibe is installed — local models can launch as agent tabs.",
+  "ollama.vibeMissing1": "Local Ollama models run through Mistral's",
+  "ollama.vibeMissing2":
+    "CLI. It isn't installed yet, so a Local Model tab fails with “unable to spawn vibe”. Install it once (no administrator rights needed) and local models will launch.",
+  "ollama.installVibe": "Install Vibe",
+  "ollama.installingEllipsis": "Installing…",
+  "ollama.runningInstaller": "Running installer…",
+  "ollama.startingEllipsis": "Starting…",
+  "ollama.orInstallInShellPre": "Or install it in a",
+  "ollama.orInstallInShellPost": "tab:",
+  "ollama.runInTerminal": "Run in terminal",
+  "ollama.vibeStillNotDetectedWindows":
+    "Vibe is still not detected (open a fresh terminal so the install location is on PATH).",
+  "ollama.vibeStillNotDetectedOther":
+    "Vibe is still not detected (try a fresh terminal so ~/.local/bin is on PATH).",
+  "ollama.installTitle": "Install Ollama",
+  "ollama.notInstalledHelp":
+    "Ollama runs open-weight models locally on your machine. It isn't installed yet. Install it once and Eldrun will list the models you can download right here.",
+  "ollama.automaticInstall": "Automatic install",
+  "ollama.autoInstallHelpWindows":
+    "Installs Ollama with winget (silent, per-user). winget ships with Windows 10/11; if it's missing or the install fails, follow the manual steps below.",
+  "ollama.autoInstallHelpOther":
+    "Runs the official install script. It needs administrator rights to add the ollama service, so this works without prompting only when your account has passwordless sudo. If it fails, follow the manual steps below.",
+  "ollama.installBtn": "Install Ollama",
+  "ollama.installInTerminalTitle": "Install in a terminal",
+  "ollama.runInstallerNewPre": "Run the installer for your system in a new",
+  "ollama.runInstallerNewPost": "tab:",
+  "ollama.alsoDownloadFrom": "You can also download the installer directly from",
+  "ollama.approveUacPrompt": "Approve the User Account Control prompt if Windows asks.",
+  "ollama.enterPasswordSudo": "Enter your password if the installer asks for sudo.",
+  "ollama.onceFinishedClickPre": "Once it finishes, click",
+  "ollama.onceFinishedClickPost": "below — the installable models will appear automatically.",
+  "ollama.stillNotDetected": "Ollama is still not detected.",
+  "ollama.modelsTitle": "Ollama Models",
+  "ollama.checkingEllipsis": "Checking...",
+  "ollama.serverRunningLabel": "Server running · {label}",
+  "ollama.serverNotRunning": "Server not running",
+  "ollama.noModelLoaded": "No model loaded",
+  "ollama.noLoadedModel": "No loaded model",
+  "ollama.loadedModels": "Loaded: {names}",
+  "ollama.start": "Start",
+  "ollama.refresh": "Refresh",
+  "ollama.downloadingTitle": "Downloading",
+  "ollama.pauseTitle": "Pause this download (resume later)",
+  "ollama.pause": "Pause",
+  "ollama.downloadPaused": "Download paused — resume to finish it, or delete the partial data.",
+  "ollama.resume": "Resume",
+  "ollama.deletePartialTitle": "Delete the partial download to reclaim disk space",
+  "ollama.delete": "Delete",
+  "ollama.downloadInterrupted": "Download was interrupted — resume to finish it.",
+  "ollama.continueDownload": "Continue download",
+  "ollama.dismissTitle": "Forget this interrupted download",
+  "ollama.dismiss": "Dismiss",
+  "ollama.orphansSummaryOne":
+    "{count} orphaned partial layer ({size}) — interrupted downloads with no recoverable model name. Re-pull the model to resume, or delete to reclaim space.",
+  "ollama.orphansSummaryMany":
+    "{count} orphaned partial layers ({size}) — interrupted downloads with no recoverable model name. Re-pull the model to resume, or delete to reclaim space.",
+  "ollama.orphanLayer": "layer {digest}…",
+  "ollama.deleteLayerTitle": "Delete this partial layer to reclaim disk space",
+  "ollama.downloadedModelsTitle": "Downloaded Models",
+  "ollama.noModelsDownloaded": "No models downloaded",
+  "ollama.unloadTitle": "Unload from memory",
+  "ollama.unload": "Unload",
+  "ollama.loadTitle": "Load into memory now and keep it resident",
+  "ollama.load": "Load",
+  "ollama.loading": "Loading…",
+  "ollama.updateTitle": "Check for update and download latest",
+  "ollama.update": "Update",
+  "ollama.updating": "Updating…",
+  "ollama.deleteModelTitle": "Delete this model",
+  "ollama.loadingIntoMemoryTitle": "Loading into memory…",
+  "ollama.loadingIntoMemory": "Loading into memory…",
+  "ollama.browseRegistry": "Browse the Ollama registry",
+  "ollama.pullHelp1": "Pull any model from the Ollama registry. Type an exact ref to pull directly, or search and filter the full list below. Use a full ref like",
+  "ollama.pullHelp2": "or",
+  "ollama.pullPlaceholder": "model name or namespace/model:tag",
+  "ollama.pull": "Pull",
+  "ollama.pulling": "Pulling…",
+  "ollama.searchPlaceholder": "Search all models by name or description…",
+  "ollama.sortBy": "Sort by",
+  "ollama.sort.popular": "Most popular",
+  "ollama.sort.newest": "Newest",
+  "ollama.sort.pulls": "Most pulls",
+  "ollama.sort.name": "Name (A–Z)",
+  "ollama.sort.sizeAsc": "Size: small → large",
+  "ollama.sort.sizeDesc": "Size: large → small",
+  "ollama.filterType": "Type",
+  "ollama.filterParams": "Params",
+  "ollama.any": "Any",
+  "ollama.cap.tools": "tools",
+  "ollama.cap.vision": "vision",
+  "ollama.cap.thinking": "thinking",
+  "ollama.cap.embedding": "embedding",
+  "ollama.cap.audio": "audio",
+  "ollama.pullsSuffix": "{pulls} pulls",
+  "ollama.tagUpdateTitle": "Update {name}{size}",
+  "ollama.tagDownloadTitle": "Download {name}{size}",
+  "ollama.sizeLoadingSuffix": " — size…",
+  "ollama.pullLower": "pull",
+  "ollama.noModelsFound": "No models found",
+  "ollama.noMatchSizeFilter":
+    "No loaded models match the selected size — load more or clear the Params filter",
+  "ollama.endOfResults": "End of results",
+  "ollama.pausedBadge": "paused",
+  "ollama.interruptedBadge": "interrupted",
+  "globalAppMenu.title": "Global apps",
+  "howToStart.title": "Welcome to Eldrun",
+  "howToStart.intro": "Eldrun keeps your AI-assisted development in one window. Here's how to get going:",
+  "howToStart.openFeatureGuide": "Open Feature Guide...",
+  "howToStart.takeTour": "Take a tour",
+  "howToStart.lessons": "Lessons",
+  "howToStart.gotIt": "Got it",
+  "remoteFeatures.title": "Using VPN or remote machines?",
+  "remoteFeatures.help": "Eldrun can control an OpenVPN tunnel and connect to SSH machines you don't have a project on, both from the header. Both are off by default — turn on whichever you'll use. Either can be flipped any time from Settings.",
+  "remoteFeatures.continue": "Continue",
+  "lessons.title": "Lessons",
+  "lessons.intro": "Short guided walkthroughs for common tasks. Pick one — it'll point things out step by step.",
+  "globalApp.role.browser": "Browser",
+  "globalApp.role.mail": "Mail",
+  "globalApp.role.calendar": "Calendar",
+  "globalApp.role.print_manager": "Print Manager",
+  "globalApp.role.file_manager": "File Manager",
+  "globalApp.role.password_manager": "Password Manager",
+  "globalApp.role.video_conf": "Video Conf.",
+  "globalApp.role.media_player": "Media Player",
+  "globalApp.role.system_monitor": "System Monitor",
+  "globalApp.role.notes": "Notes",
+  "globalApp.role.screenshot": "Screenshot",
+  "globalApp.role.screen_recorder": "Screen Recorder",
+  "globalApp.role.chat": "Chat",
+  "globalApp.rightClickConfigure": "Right-click to configure",
+  "globalApp.noCommandConfigured": "No command configured",
+  "globalApp.clear": "Clear",
+  "globalApp.set": "Set",
+  "header.dragToMove": "Drag to move the Eldrun window",
+  "header.rootTerminal": "Root terminal",
+  "rightPanel.resizeTitle": "Drag to resize panel",
+  "rightPanel.moveRight": "Move panel to the right edge",
+  "rightPanel.moveLeft": "Move panel to the left edge",
+  "rightPanel.unpinTitle": "Unpin panel (allow auto-hide)",
+  "rightPanel.pinTitle": "Pin panel open",
+  "rightPanel.showHidden": "Show hidden subwindows",
+  "rightPanel.collapse": "Collapse",
+  "rightPanel.hiddenCount": "Hidden ({count})",
+  "rightPanel.hiddenWaiting": "A hidden subwindow is waiting on you",
+  "rightPanel.hiddenWorking": "A hidden subwindow is working",
+  "rightPanel.hiddenFinished": "A hidden subwindow finished, unseen",
+  "rightPanel.restoreFocusedOn": "Restore focused on “{label}”",
+  "rightPanel.restoreSubwindow": "Restore subwindow",
+  "rightPanel.closeSubwindow": "Close subwindow (discard its tabs)",
+  "vpnPrompt.titleConnected": "VPN connected",
+  "vpnPrompt.titlePassword": "VPN password",
+  "vpnPrompt.close": "Close",
+  "vpnPrompt.closeTitleConnected": "Close — the tunnel stays up.",
+  "vpnPrompt.closeTitleConnecting": "Stop bringing the tunnel up and close — any half-open tunnel is torn down.",
+  "vpnPrompt.closeTitleDefault": "Close without connecting.",
+  "vpnPrompt.upFor": "OpenVPN is up for",
+  "vpnPrompt.connectingFor": "Connecting OpenVPN for",
+  "vpnPrompt.trafficScope": "While the tunnel is up, this computer's traffic routes through it — your browser too, not just Eldrun.",
+  "vpnPrompt.username": "Username",
+  "vpnPrompt.usernamePlaceholder": "OpenVPN account username…",
+  "vpnPrompt.password": "Password",
+  "vpnPrompt.passphrase": "Passphrase",
+  "vpnPrompt.savedInKeychain": "(saved in OS keychain)",
+  "vpnPrompt.notStored": "(not stored)",
+  "vpnPrompt.keyPassphraseLabel": "Private key passphrase",
+  "vpnPrompt.keyPassphrasePlaceholder": "Passphrase for the config's encrypted key…",
+  "vpnPrompt.keyPassphraseHint": "This config's private key is encrypted, so OpenVPN asks for its passphrase separately from your account password.",
+  "vpnPrompt.saveVpnCredentials": "Save VPN credentials",
+  "vpnPrompt.savePassphrase": "Save passphrase",
+  "vpnPrompt.storedSecurely": "stored securely in your OS keychain",
+  "vpnPrompt.tunnelUp": "Tunnel up — this computer's traffic now routes through it.",
+  "vpnPrompt.challengeHintPre": "If this config asks for something these fields can't answer — a challenge code, or a prompt of its own — use",
+  "vpnPrompt.logInTerminal": "Log in in terminal",
+  "vpnPrompt.challengeHintPost": "below: OpenVPN asks there directly, and Eldrun still never sees what you type.",
+  "vpnPrompt.closeStaysUpTitle": "Close — the tunnel stays up. Bring it down from the header's VPN indicator.",
+  "vpnPrompt.terminalBtnStopFirst": "Stop the current attempt first, then log in in the terminal.",
+  "vpnPrompt.terminalBtnHandoff": "Hand this connect to a root-terminal tab and log in there — OpenVPN asks for the password (and any challenge code) itself, and Eldrun never sees it. This connect only; your headless setting stays as it is.",
+  "vpnPrompt.cancelTitleConnecting": "Stop bringing the tunnel up and close this — any half-open tunnel is torn down.",
+  "vpnPrompt.stop": "Stop",
+  "vpnPrompt.connectTitleConnecting": "Bringing the OpenVPN tunnel up — pkexec may prompt for elevation…",
+  "vpnPrompt.connectTitleError": "Connection failed — check the passphrase and retry.",
+  "vpnPrompt.connectTitleDefault": "Bring the OpenVPN tunnel up.",
+  "vpnPrompt.connecting": "Connecting…",
+  "vpnPrompt.retry": "Retry",
+  "vpnPrompt.connect": "Connect",
+  "projectSwitcher.howToStartMenu": "How to start",
+  "projectSwitcher.scrollLeft": "Scroll projects left",
+  "projectSwitcher.scrollRight": "Scroll projects right",
+  "projectSwitcher.addOrImport": "Add or import project",
+  "projectSwitcher.newProject": "New Project",
+  "projectSwitcher.importProject": "Import Project",
+  "projectSwitcher.importFromGitHub": "Import from GitHub/GitLab",
+  "projectSwitcher.hpcPipeline": "HPC pipeline…",
+  "projectSwitcher.newBox": "New Box",
+  "localModel.role.autocomplete": "Autocomplete",
+  "localModel.role.grammar": "Grammar",
+  "localModel.role.tabs": "Tabs",
+  "localModel.installTitle": "Install a local model",
+  "localModel.runningLoaded": "Ollama running · model loaded",
+  "localModel.running": "Ollama running",
+  "localModel.stopped": "Ollama stopped",
+  "localModel.modelSuffix": " · model: {name}",
+  "localModel.noModelSelected": " · no model selected",
+  "localModel.ariaLabel": "Local model",
+  "localModel.agentsGroup": "Agents",
+  "localModel.agentInstalled": "{label} installed",
+  "localModel.manageAgents": "Manage agents…",
+  "localModel.localModelsGroup": "Local Models",
+  "localModel.downloadingTitle": "Downloading",
+  "localModel.pausedTitle": "Paused",
+  "localModel.pauseDownloadTitle": "Pause download",
+  "localModel.resumeDownloadTitle": "Resume download",
+  "localModel.deletePartialDownloadTitle": "Delete partial download",
+  "localModel.gpuUsedTotal": "GPU {used} / {total}",
+  "localModel.gpuFree": "{free} free",
+  "localModel.notInstalled": "Ollama not installed",
+  "localModel.noModelsInstalled": "No models installed",
+  "localModel.serverStopped": "Server stopped",
+  "localModel.defaultLoadedTitle": "Default local model · loaded in memory",
+  "localModel.loadedClickDefaultTitle": "Loaded in memory — click to make default",
+  "localModel.defaultTag": "default",
+  "localModel.usedForRole": "Used for {role} — click to unassign",
+  "localModel.useForRole": "Use {name} for {role}",
+  "localModel.unloadFromMemoryTitle": "Unload {name} from memory",
+  "localModel.unloading": "Unloading…",
+  "localModel.loadIntoMemoryGroup": "Load into memory",
+  "localModel.failedRetryTitle": "Failed to load — click to retry",
+  "localModel.loadIntoMemoryTitle": "Load into memory",
+  "localModel.failed": "Failed",
+  "localModel.manageLocalModels": "Manage local models…",
+  "localModel.installOllamaEllipsis": "Install Ollama…",
+  "localModel.notRunning": "Ollama not running",
+  "localModel.failedToLoadModel": "Failed to load model",
+  "localModel.failedToUnloadModel": "Failed to unload model",
+  "localModel.failedToLoadModels": "Failed to load models",
+  "appShell.vpnStillActiveTitle": "VPN tunnel still active",
+  "appShell.vpnStillActiveMessage": "The OpenVPN tunnel is still active and reroutes this whole machine. It will keep running after Eldrun closes — use the VPN control in the header to close it yourself when you're done.",
+  "appShell.showFilesPanel": "Show files panel",
+  "detached.loadingSubwindow": "Loading subwindow…",
+  "centerPanel.noTabsOpen": "No tabs open",
+  "centerPanel.noTabsHintPre": "Use",
+  "centerPanel.noTabsHintPost": "on the tab bar above to open a shell or an AI agent.",
+  "detachedTabs.scrollLeft": "Scroll tabs left",
+  "detachedTabs.scrollRight": "Scroll tabs right",
+  "detachedTabs.dragToMove": "Drag to move this window",
+  "detachedTabs.closeTab": "Close tab",
+  "detachedTabs.newTab": "New tab",
+  "detachedTabs.hideWindow": "Hide this window into the right panel (bring it back from there)",
+  "tour.skip": "Skip tour",
+  "tour.back": "Back",
+  "tour.done": "Done",
+  "tour.next": "Next",
+  "hint.dismissAria": "Dismiss hint",
+  "hint.dontShowHints": "Don't show hints",
+  "hint.notNow": "Not now",
+  "untested.title": "This feature is implemented but not yet live-tested",
+  "untested.label": "untested",
+  "vpnNotice.ariaLabel": "OpenVPN tunnel",
+  "vpnNotice.alreadyUp": "OpenVPN tunnel already up",
+  "vpnNotice.desc": "This computer already routes through a tunnel, so this project needs no second one. Manage tunnels from the VPN control in the header.",
+  "connLog.ariaLabel": "OpenVPN connection log",
+  "connLog.startingVpn": "Starting OpenVPN…",
+  "folderPicker.upOneFolder": "Up one folder",
+  "folderPicker.up": "Up",
+  "folderPicker.noSubfolders": "No sub-folders here.",
+  "folderPicker.folderPrefix": "Folder:",
+  "blob.noProjectsYet": "No projects yet — create one to populate the cloud.",
+  "blob.backToProjects": "Back to projects",
+  "blob.sphereView": "Sphere",
+  "blob.sphereViewTitle": "3D project sphere",
+  "blob.pieView": "Pie",
+  "blob.pieViewTitle": "Time-tracked pie chart",
+  "blob.hintFocused": "Click a folder to enter · click a file to open · center or Esc to go back",
+  "blob.hintPie": "Slice size = time tracked · click to open a project · right-click for menu",
+  "blob.hintCloud": "Drag to orbit · scroll to zoom · click to explore files · double-click to open · right-click for menu",
+  "blob.noProjectsToChart": "No projects to chart yet.",
+  "blob.projectCountOne": "{count} project",
+  "blob.projectCountMany": "{count} projects",
+  "blob.projectRoot": "project root",
+  "blob.noDescriptionYet": "No description yet.",
+  "blob.hintCenterUp": "Click to go up · double-click to open · Esc to exit",
+  "blob.hintExploreOpen": "Click to explore files · double-click to open",
+  "blob.boxMetaOne": "Box · {count} project",
+  "blob.boxMetaMany": "Box · {count} projects",
+  "blob.doubleClickToOpen": "Double-click to open",
+  "blob.folder": "Folder",
+  "blob.extFile": "{ext} file",
+  "blob.file": "File",
+  "blob.clickToEnterFolder": "Click to enter folder",
+  "blob.clickToOpen": "Click to open",
+  "blob.open": "Open",
+  "blob.categoriesEllipsis": "Categories…",
+  "blob.activate": "Activate",
+  "blob.inactivate": "Inactivate",
+  "blob.loadingLower": "loading…",
+  "pageStrip.ariaLabel": "Pages",
+  "pageStrip.turnClockwiseTitle": "Turn this page 90° clockwise",
+  "pageStrip.turnClockwiseAria": "Turn page clockwise",
+  "pageStrip.removePageTitle": "Remove this page",
+  "pageStrip.removePageAria": "Remove page",
+  "pageStrip.turnRight": "Turn right",
+  "pageStrip.turnLeft": "Turn left",
+  "pageStrip.duplicate": "Duplicate",
+  "pageStrip.deleteOne": "Delete page",
+  "pageStrip.deleteMany": "Delete {count} pages",
+  "usage.toneGreen": "green",
+  "usage.toneOrange": "orange",
+  "usage.toneRed": "red",
+  "usage.utilizationAria": "utilization {tone}",
+  "usage.cpu": "CPU",
+  "usage.coresOne": "({count} core)",
+  "usage.coresMany": "({count} cores)",
+  "usage.loadAverage": "Load average",
+  "usage.memory": "Memory",
+  "usage.loggedIn": "Logged in",
+  "usage.carefulNote":
+    "HPC host — only your own sessions and processes are listed. A cluster's usage rules don't allow collecting other users' names or commands, so this report is not run automatically here.",
+  "usage.sessionsOne": "({count} session)",
+  "usage.sessionsMany": "({count} sessions)",
+  "usage.userCol": "User",
+  "usage.sessionsCol": "Sessions",
+  "usage.memCol": "Mem",
+  "usage.noInteractiveLogins": "No interactive logins on this host.",
+  "usage.topProcesses": "Top processes",
+  "usage.cpuSuffix": "cpu",
+  "usage.memSuffix": "mem",
+  "usage.title": "Current remote host usage",
+  "usage.noMachines": "No machines to check — add one in the Machines menu, or open a remote project.",
+  "usage.lede": "Load, memory and logged-in sessions on {hosts}, {reading} — here's what's running right now.",
+  "usage.hostSingular": "1 host",
+  "usage.hostsPlural": "{count} hosts",
+  "usage.beingReadNow": "being read now",
+  "usage.asLastRead": "as last read",
+  "usage.checkingEllipsis": "Checking…",
+  "usage.noReading": "No reading — the host may be unreachable.",
+  "usage.rechecking": "Rechecking…",
+  "usage.recheck": "Recheck",
+  "hostKey.title": "Is this the right machine?",
+  "hostKey.ledePre": "Eldrun has never connected to",
+  "hostKey.ledePost": "before, and it is about to send a password there. Check the fingerprint below against what the host's administrator (or another machine you already trust) shows — if it does not match, something else is answering for this address.",
+  "hostKey.readingKey": "Reading the host's key…",
+  "hostKey.errorHeading": "The host's key could not be read, so there is nothing to verify. Nothing was sent.",
+  "hostKey.acceptNotePre": "Accepting stores this key in",
+  "hostKey.acceptNotePost": ". You will not be asked again — and if the key ever changes, the connection is refused outright.",
+  "hostKey.accepting": "Accepting…",
+  "hostKey.acceptAndConnect": "Accept and connect",
+  "localLoss.kindDeleted": "deleted locally",
+  "localLoss.kindOverwritten": "overwritten locally",
+  "localLoss.sourceGit": "Git lockstep",
+  "localLoss.sourceSync": "File sync",
+  "localLoss.entryCountOne": "{count} file {kind}",
+  "localLoss.entryCountMany": "{count} files {kind}",
+  "localLoss.moreCount": "…and {count} more",
+  "localLoss.unrecoverable": "This content was only ever on this machine — it cannot be recovered.",
+  "localLoss.title": "Files changed on your local copy",
+  "localLoss.ledePre": "Syncing this project with the host destroyed something in your local copy —",
+  "localLoss.ledeMid": "across",
+  "localLoss.ledePost": ". This is what git and sync are supposed to do when the two sides move; it is listed here because it happened to your machine, and it happened without asking.",
+  "localLoss.filesCountOne": "{count} file",
+  "localLoss.filesCountMany": "{count} files",
+  "localLoss.opsCountOne": "{count} operation",
+  "localLoss.opsCountMany": "{count} operations",
+  "common.rename": "Rename",
+  "common.connect": "Connect",
+  "common.next": "Next",
+  "projectSearch.placeholder": "Search inactive...",
+  "projectSearch.noProjects": "No projects",
+  "projectSearch.boxMemberOne": "Box · {count} member",
+  "projectSearch.boxMemberMany": "Box · {count} members",
+  "categoryEditor.titleSuffix": "Categories",
+  "categoryEditor.desc": "Tag this project to color and group it in the project cloud and the pill bar. A project can carry several categories; the first is its primary color.",
+  "categoryEditor.removeCategory": "Remove this category",
+  "categoryEditor.addCategory": "Add this category",
+  "categoryEditor.addLabel": "Add a category",
+  "categoryEditor.placeholder": "e.g. work, research, client-x…",
+  "categoryEditor.saving": "Saving…",
+  "categoryEditor.save": "Save",
+  "boxPill.clickToOpenTitle": "{name} (box) — click to open",
+  "boxPill.memberCountOne": "{count} member",
+  "boxPill.memberCountMany": "{count} members",
+  "boxPill.noMembers": "No members",
+  "boxPill.switchToTitle": "Switch to {name}",
+  "boxPill.removeFromBox": "Remove from box",
+  "boxPill.openBox": "Open box",
+  "boxPill.deleteBox": "Delete box",
+  "activityCal.noActivity": "No activity",
+  "activityCal.less": "Less",
+  "activityCal.more": "More",
+  "activityCal.dayMon": "Mon",
+  "activityCal.dayWed": "Wed",
+  "activityCal.dayFri": "Fri",
+  "remotePane.notConnected": "Not connected",
+  "remotePane.hintPre": "This tab runs on",
+  "remotePane.theRemoteHost": "the remote host",
+  "remotePane.hintPost": "Connect to start it — your local tabs keep working on the mirror meanwhile.",
+  "extendRemote.title": "Extend “{name}” to remote",
+  "extendRemote.attachPre": "Attach",
+  "extendRemote.attachMid": "to this project as its primary remote host. The empty remote folder is created on the host; your existing local files become the synced working copy and stay put. Nothing is uploaded until you push it manually.",
+  "extendRemote.attachGeneric": "Attach a remote SSH host to this project. The empty remote folder is created on the host; your existing local files become the synced working copy and stay put. Nothing is uploaded until you push it manually.",
+  "extendRemote.summaryLede": "Creates the remote folder and pairs it with this project's existing local files:",
+  "extendRemote.local": "Local",
+  "extendRemote.remote": "Remote",
+  "extendRemote.readyTitle": "Attach the remote host to this project",
+  "extendRemote.notReadyTitle": "Connect and choose a remote folder first",
+  "extendRemote.connectFirstError": "Connect and choose a remote folder first.",
+  "extendRemote.extending": "Extending…",
+  "extendRemote.extendToRemote": "Extend to remote",
+  "pythonInterp.titleSuffix": "Python interpreter",
+  "pythonInterp.desc": "Used by the code viewer's Run and Debug buttons. Auto-detect is right for almost every project — pin one only when your environment lives somewhere Eldrun can't infer.",
+  "pythonInterp.remoteSuffix": "Probed on the host, since that is where this project runs.",
+  "pythonInterp.looking": "Looking for interpreters…",
+  "pythonInterp.interpreterLabel": "Interpreter",
+  "pythonInterp.autoDetectWith": "Auto-detect — {path}",
+  "pythonInterp.autoDetect": "Auto-detect",
+  "pythonInterp.customPath": "Custom path…",
+  "pythonInterp.pathLabel": "Path to the interpreter",
+  "pythonInterp.pathPlaceholder": "e.g. /opt/envs/ml/bin/python — relative paths resolve from the project root",
+  "pythonInterp.probeErrorPre": "Couldn't probe for interpreters (",
+  "pythonInterp.probeErrorPost": "). You can still set one by hand.",
+  "pythonInterp.saving": "Saving…",
+  "pythonInterp.save": "Save",
+  "remoteBrowser.ariaLabel": "Remote folder browser",
+  "remoteBrowser.goUp": "Go up",
+  "remoteBrowser.recentlyUsed": "Recently used…",
+  "remoteBrowser.jumpTitle": "Jump to a previously-used remote path for this host",
+  "remoteBrowser.useThisFolder": "Use this folder",
+  "remoteBrowser.newFolderPlaceholder": "New folder name…",
+  "remoteBrowser.addFolderTitle": "Create a new folder here",
+  "remoteBrowser.addFolder": "+ Add folder",
+  "remoteBrowser.listing": "Listing...",
+  "remoteBrowser.emptyFolder": "Empty folder.",
+  "bigFolder.titlePre": "Large folders in",
+  "bigFolder.thisProject": "this project",
+  "bigFolder.introPre": "These folders are big enough that syncing them would dominate every transfer. Sync copies bytes and",
+  "bigFolder.doesNotReadGitignore": "does not read .gitignore",
+  "bigFolder.introPost": ", so data kept on the host on purpose — experiment output, checkpoints, caches, virtualenvs — crosses like any other file unless it is excluded here.",
+  "bigFolder.measuring": "Measuring both sides…",
+  "bigFolder.nothingOversizedFull": "Nothing oversized found. Sync away.",
+  "bigFolder.nothingOversizedLocalOnly": "Nothing oversized found on the local side. Sync away.",
+  "bigFolder.colFolder": "Folder",
+  "bigFolder.colThisMachine": "This machine",
+  "bigFolder.colHost": "Host",
+  "bigFolder.notePre": "Ticked =",
+  "bigFolder.excludedFromSync": "excluded from sync",
+  "bigFolder.notePost": ". Nothing is deleted either way, and any folder can be re-included later from its right-click menu in the file tree. Git-tracked files still travel with your commits — exclusion applies to the byte sync.",
+  "bigFolder.hostNotMeasuredPre": "The host was not measured",
+  "bigFolder.hostNotConnected": "the project is not connected",
+  "bigFolder.hostNotMeasuredPost": ". Only this machine's folders are listed; re-open this from the file view once connected to see the host's.",
+  "bigFolder.hostSkippedCareful": "The host was not measured — this machine is marked careful, so the recursive scan that reads its whole tree is not run on its own.",
+  "bigFolder.measureHost": "Measure the host anyway",
+  "bigFolder.measuringHost": "Measuring the host…",
+  "bigFolder.notNow": "Not now",
+  "bigFolder.close": "Close",
+  "bigFolder.apply": "Apply",
+  "common.saving": "Saving…",
+  "common.save": "Save",
+  "common.close": "Close",
+  "pill.gitClean": "No pending changes",
+  "pill.gitDirty": "Uncommitted changes — not yet added",
+  "pill.gitStaged": "Staged changes — not yet committed",
+  "pill.gitUnpushed": "Committed — not yet pushed",
+  "pill.statusWorking": "{count} working",
+  "pill.statusWaiting": "{count} waiting on you",
+  "pill.statusFinished": "{count} finished",
+  "pill.categoriesLabel": "Categories: {list}",
+  "pill.closeProject": "Close project",
+  "pill.activityTitle": "{name} — Activity",
+  "pill.descTitle": "{name} — Description",
+  "pill.descPlaceholder": "Short description for this project…",
+  "pill.renameTitle": "Rename project",
+  "pill.namePlaceholder": "Project name…",
+  "pill.nameEmpty": "Name cannot be empty",
+  "pill.publishTitle": "{name} — Publish to {provider}",
+  "pill.currentPrefix": "Current:",
+  "pill.runsOnWorkRemote": "· runs on the work-remote host",
+  "pill.hostingProvider": "Hosting provider",
+  "pill.repoVisibility": "Repository visibility",
+  "pill.visPrivate": "private",
+  "pill.visPublic": "public",
+  "pill.publishRunsPre": "Runs",
+  "pill.publishRunsMid": "Requires",
+  "pill.publishRunsPost": "installed and authenticated (or a token under ⚙ Settings → Git hosting).",
+  "pill.publishCliMissingPre": "No",
+  "pill.publishCliMissingMid": "found on this machine — publishing creates the repository through the provider's own CLI, so install it (and sign in with",
+  "pill.publishCliMissingPost": ") before publishing.",
+  "pill.publishFrom": "Publish from",
+  "pill.publishFromLocal": "This computer (local mirror)",
+  "pill.publishFromRemote": "Work-remote host",
+  "pill.publishFromLocalHint": "The repository is created and pushed from this project's local mirror, using this machine's {cli} sign-in. Git lockstep must report the mirror in step with the host.",
+  "pill.publishRemoteCliHint": "The publish runs on the work-remote host — {cli} must be installed and signed in there, not on this machine, and the project must be connected.",
+  "pill.publishSignInHint": "Not connected via a saved token — publishing will use {cli}'s own login.",
+  "pill.publishSignInBtn": "Sign in with {cli}",
+  "pill.publishSignInTitle": "Run {cmd} in a new terminal tab",
+  "pill.getTokenCta": "Create a {provider} access token…",
+  "pill.getTokenHint": "Needs the \"repo\" scope on GitHub, or \"api\" (read/write repository) on GitLab.",
+  "pill.published": "Published.",
+  "pill.publishing": "Publishing…",
+  "pill.publish": "Publish",
+  "pill.gitHostingTitle": "{name} — Git hosting",
+  "pill.gitHostingDesc": "Overrides the global git hosting for this project only. Leave fields blank to inherit the global settings.",
+  "pill.inheritsGlobal": "Inherits global: {url}",
+  "pill.replaceToken": "Replace access token",
+  "pill.enterNewToken": "Enter a new token to replace…",
+  "pill.tokenStatusWillSet": "Will set a project token (overrides global).",
+  "pill.tokenStatusWillRemove": "Will remove the project token; reverts to the global one.",
+  "pill.tokenStatusHasToken": "A project token is set (hidden). Leave blank to keep it.",
+  "pill.tokenStatusInherits": "Inherits the global token.",
+  "pill.tokenStatusNone": "No token set — pushes use your system git credentials.",
+  "pill.removeProjectToken": "Remove the project token (use global)",
+  "pill.disableGitTitle": "{name} — Remove git & history",
+  "pill.disableGitWarn1": "This permanently deletes this project's",
+  "pill.disableGitWarn2": "directory — every commit, branch, stash, and remote.",
+  "pill.cannotBeUndone": "It cannot be undone.",
+  "pill.disableGitWarn3": "The project becomes a “No git (no repo)” project; your working files are left untouched.",
+  "pill.typeNameConfirmPre": "Type the project name",
+  "pill.typeNameConfirmPost": "to confirm",
+  "pill.removing": "Removing…",
+  "pill.deleteGitHistory": "Delete git history",
+  "pill.deleteProjectTitle": "Delete {name}",
+  "pill.archiveDescPre": "This disconnects",
+  "pill.archiveDescMid": "and moves it to the Eldrun archive. You can restore it — or permanently delete it — later from",
+  "pill.archiveSettingsLink": "Settings → Archived projects",
+  "pill.archiveRemoteNotTouchedPre": "The files on the remote host are",
+  "pill.notWord": "not",
+  "pill.archiveRemoteNotTouchedPost": "touched.",
+  "pill.deleting": "Deleting…",
+  "pill.deleteToArchive": "Delete to archive",
+  "pill.detachTitle": "{name} — Detach SSH host",
+  "pill.detachDesc1Pre": "This turns",
+  "pill.detachDesc1Mid": "back into a plain local project: its local working copy stays exactly where it is and becomes the project directory again. The files on the remote host are",
+  "pill.detachDesc1Post": "touched, and nothing local is deleted.",
+  "pill.detachDesc2Pre": "What it does drop is the",
+  "pill.pairingWord": "pairing",
+  "pill.detachDesc2Post": ": git lockstep stops, and the auto-sync scope you chose for this host — which folders cross, and the record of what was already in step — is discarded. Re-attaching the same host later means picking that scope again from scratch.",
+  "pill.detaching": "Detaching…",
+  "pill.detachToLocal": "Detach to local",
+  "pill.containerSettingsTitle": "{name} — Container settings",
+  "pill.containerAppliedNote": "Applied at the next container start (project activation or tab spawn) — a running container whose settings changed is replaced automatically.",
+  "pill.buildFromDockerfile": "Build from a Dockerfile in this project",
+  "pill.dockerfilePlaceholder": "e.g. Dockerfile — empty: use the image below",
+  "pill.image": "Image",
+  "pill.imagePlaceholder": "empty: eldrun-agent-sandbox:latest",
+  "pill.network": "Network",
+  "pill.networkPlaceholder": "empty: docker bridge — “none” blocks all egress (breaks cloud agents)",
+  "pill.networkNotePre": "Note: the default bridge still reaches services bound on this machine (Ollama, dev servers) via the docker gateway IP. Fully closed means",
+  "pill.networkNotePost": "or a custom allowlist network.",
+  "pill.memoryCap": "Memory cap",
+  "pill.memoryPlaceholder": "e.g. 4g — empty: unlimited",
+  "pill.cpuCap": "CPU cap",
+  "pill.cpuPlaceholder": "e.g. 2 — empty: unlimited",
+  "pill.processLimit": "Process limit",
+  "pill.processLimitPlaceholder": "empty: 1024 (fork-bomb guard)",
+  "pill.processLimitError": "Process limit must be a positive whole number.",
+  "pill.readonlyRootfs": "Read-only root filesystem (keeps a writable /tmp)",
+  "pill.unpublishTitle": "{name} — Unpublish",
+  "pill.unpublishDesc1": "This removes the",
+  "pill.unpublishDesc2": "remote and resets the project to a local git repo. Your commits stay intact and the repository on",
+  "pill.unpublishDesc3": "is",
+  "pill.unpublishDesc4": "deleted — only the local link to it is dropped. You can re-publish later.",
+  "pill.unpublishing": "Unpublishing…",
+  "pill.unpublishKeepRepo": "Unpublish (keep repo)",
+  "pill.changeVisibilityTitle": "{name} — Change visibility",
+  "pill.flipVisibility1": "Flip this repository from",
+  "pill.flipVisibility2": "to",
+  "pill.flipVisibility3": "in place via",
+  "pill.flipVisibility4": "The repo, its URL, and its history are preserved.",
+  "pill.applying": "Applying…",
+  "pill.makeVisibility": "Make {target}",
+  "pill.moveToProviderTitle": "{name} — Move to another provider",
+  "pill.newProvider": "New provider",
+  "pill.migrateDesc1": "Creates the repo on",
+  "pill.migrateDesc2": ", re-points",
+  "pill.migrateDesc3": ", and pushes. The existing",
+  "pill.migrateDesc4": "repository is",
+  "pill.leftIntact": "left intact",
+  "pill.migrateDesc5": "(kept as",
+  "pill.migrateDesc6": ") — delete it yourself if you no longer want it.",
+  "pill.migrating": "Migrating…",
+  "pill.moveToProvider": "Move to {provider}",
+  "pill.viewGroup": "View",
+  "pill.showActivity": "Show Activity",
+  "pill.showOnDiskRemoteTitle": "Open the local mirror (the connected working copy) in the file manager",
+  "pill.showOnDiskLocalTitle": "Open the project directory in the file manager",
+  "pill.showOnDisk": "Show on disk",
+  "pill.editGroup": "Edit",
+  "pill.renameEllipsis": "Rename…",
+  "pill.movePillTitle": "Move this project's local mirror (the connected working copy) to a new folder",
+  "pill.moveProjectEllipsis": "Move project…",
+  "pill.editDescription": "Edit description",
+  "pill.categoriesMenuTitle": "Tag this project to color and group it in the cloud and the pill bar",
+  "pill.repairScaffoldTitle": "Fill in any missing scaffold file, default .gitignore pattern, or .claude/settings.json — never overwrites existing content",
+  "pill.repairScaffold": "Repair scaffold files",
+  "pill.extendToRemoteMenuTitle": "Attach a remote SSH host to this local project — files stay put; push them up manually",
+  "pill.extendToRemoteEllipsis": "Extend to remote…",
+  "pill.gitGroup": "Git",
+  "pill.gitInitTitle": "Run git init to start version-controlling this project",
+  "pill.enableGit": "Enable git (git init)",
+  "pill.makePrivateTitle": "Flip the repository between public and private in place (gh/glab repo edit)",
+  "pill.makePrivate": "Make private…",
+  "pill.makePublic": "Make public…",
+  "pill.moveProviderMenuTitle": "Publish to the other provider and re-point origin; the old repo is left intact",
+  "pill.moveToGithub": "Move to GitHub…",
+  "pill.moveToGitlab": "Move to GitLab…",
+  "pill.unpublishMenuTitle": "Remove the origin remote and go back to a local repo; the hosted repo and history are kept",
+  "pill.unpublishKeepRepoEllipsis": "Unpublish (keep repo)…",
+  "pill.gitHostingMenuTitle": "Override the global git hosting (profile URL + token) for this project only",
+  "pill.gitHostingEllipsis": "Git hosting…",
+  "pill.publishEllipsis": "Publish to GitHub / GitLab…",
+  "pill.runtimeGroup": "Runtime",
+  "pill.containerRunTitle": "Run every terminal and agent tab of this project inside one closed Docker container. The project folder stays on the host at its normal path — the container just can't reach anything else.",
+  "pill.runInContainer": "Run this project in a container",
+  "pill.containerSettingsMenuTitle": "Image, network, memory/CPU caps and read-only rootfs for this project's container",
+  "pill.containerSettingsEllipsis": "Container settings…",
+  "pill.pythonInterpMenuTitle": "The Python environment this project's scripts run and debug in. Auto-detected by default (in-tree venv, poetry, conda, pyenv); pin one when your environment lives somewhere Eldrun can't infer.",
+  "pill.pythonInterpreterEllipsis": "Python interpreter…",
+  "pill.autoConnectTitleNonHeadless": "Connect this project by itself on launch and when you switch to it. Eldrun handles no passwords in this mode, so the login (and the VPN, if it has one) opens in the root terminal for you to authenticate — then the project connects on its own.",
+  "pill.autoConnectTitleEligible": "Connect this project by itself on launch and when you switch to it. It never asks for anything: it goes straight in when the host is reachable, and brings the VPN up only when it isn't.",
+  "pill.autoConnectTitleNotEligible": "Save the SSH password (or use key authentication) first — auto-connect is only offered when connecting needs nothing from you.",
+  "pill.autoConnectOnLaunch": "Auto-connect on launch",
+  "pill.persistSessionsMenuTitle": "Run this project's remote shell and Python/script tabs inside a tmux session on the host, so a long run keeps going through an SSH drop, a laptop sleep, or Eldrun quitting — the tab reattaches when you reconnect. Closing a tab still ends its session (with a confirm). Agent tabs are unaffected.",
+  "pill.persistentSessionsTmux": "Persistent sessions (tmux)",
+  "pill.remoteMachinesMenuTitle": "Add and manage extra machines this project runs on. They run the same code (kept in one-way sync) as read-only experiment workers; their outputs stay on each machine.",
+  "pill.remoteMachinesCount": "Remote machines… ({count})",
+  "pill.remoteMachinesEllipsis": "Remote machines…",
+  "pill.closeAllTabs": "Close all tabs and windows",
+  "pill.dangerZone": "Danger zone",
+  "pill.detachSshMenuTitle": "Turn this back into a local project. The local working copy stays put and the remote host's files are untouched — but the pairing is dropped: lockstep stops, and the auto-sync scope you set up for this host is discarded.",
+  "pill.detachSshEllipsis": "Detach SSH host…",
+  "pill.removeGitMenuTitle": "Delete this project's .git directory and all version-control history (cannot be undone)",
+  "pill.removeGitHistoryEllipsis": "Remove git & history…",
+  "pill.deleteProjectMenuTitle": "Disconnect this project and move it to the Eldrun archive. Restore or permanently delete it later from Settings. A remote host's files are never touched.",
+  "pill.deleteProjectEllipsis": "Delete project…",
+  "pill.nowVisibility": "Now {target}.",
+  "pill.migrated": "Migrated.",
+  "remoteConnect.titleWorker": "Connect worker · {host}",
+  "remoteConnect.titleProject": "Connect remote project",
+  "remoteConnect.remoteLabel": "Remote",
+  "remoteConnect.localLabel": "Local",
+  "remoteConnect.nameLabel": "Name",
+  "remoteConnect.namePlaceholder": "Project name",
+  "remoteConnect.nameHintWorker": "Shown on the pill and in “Remote machines”. Leave blank to use the host name.",
+  "remoteConnect.nameHintProject": "The project name, shown on its pill and across Eldrun.",
+  "remoteConnect.machineNameLabel": "Machine name",
+  "remoteConnect.machineNameHint": "Identifies this machine in the System Monitor and connection lamps when the project has more than one host. Leave blank to use the host name.",
+  "remoteConnect.vpnToggleTitle": "Connect via OpenVPN",
+  "remoteConnect.vpnDescLine1": "Bring up a tunnel first if this host is VPN-gated. Skip it when you're already on the right network — SSH connects directly.",
+  "remoteConnect.vpnDescLine2Pre": "The tunnel is",
+  "remoteConnect.vpnDescLine2Strong": "machine-wide",
+  "remoteConnect.vpnDescLine2Post": ": while it is up, this computer's traffic routes through it — your browser too, not just Eldrun.",
+  "remoteConnect.configLabel": "Config",
+  "remoteConnect.changeConfig": "Change…",
+  "remoteConnect.changeConfigTitle": "Pick a different OpenVPN config for this project.",
+  "remoteConnect.pickConfigHintChange": "Pick the OpenVPN config to use instead — the new choice replaces the saved one.",
+  "remoteConnect.pickConfigHintNew": "Choose the OpenVPN config for this host — it's saved to the project so you only pick it once.",
+  "remoteConnect.recentConfigsPlaceholder": "Recently used…",
+  "remoteConnect.recentConfigsTitle": "Reuse a previously-used OpenVPN config",
+  "remoteConnect.chooseConfigBtn": "Choose .ovpn config…",
+  "remoteConnect.vpnUsernameLabel": "VPN username",
+  "remoteConnect.vpnPasswordLabel": "VPN password",
+  "remoteConnect.vpnPassphraseLabel": "VPN passphrase",
+  "remoteConnect.vpnSavedPlaceholder": "Using saved passphrase — leave blank",
+  "remoteConnect.vpnAccountPasswordPlaceholder": "OpenVPN account password…",
+  "remoteConnect.vpnPassphrasePlaceholder": "OpenVPN passphrase…",
+  "remoteConnect.retryVpn": "Retry VPN",
+  "remoteConnect.connectVpn": "Connect VPN",
+  "remoteConnect.vpnStopTitleConnected": "Bring this OpenVPN tunnel down. The SSH connection is left as it is.",
+  "remoteConnect.vpnStopTitleConnecting": "Stop this VPN connection attempt and reset the tunnel state.",
+  "remoteConnect.disconnectVpn": "Disconnect VPN",
+  "remoteConnect.vpnTermBtnTitle": "Bring the OpenVPN tunnel up in a terminal below — enter the passphrase there.",
+  "remoteConnect.vpnTermOpenBelow": "VPN terminal open below",
+  "remoteConnect.vpnTermOpenBtn": "Open VPN login terminal",
+  "remoteConnect.vpnTermHint": "Authenticate the tunnel below — it keeps running for this project.",
+  "remoteConnect.disconnect": "Disconnect",
+  "remoteConnect.sshSectionLabel": "Sign in over SSH",
+  "remoteConnect.usernameLabel": "Username",
+  "remoteConnect.usernamePlaceholder": "SSH login name — blank uses your local account",
+  "remoteConnect.usernameHint": "The account on {host}. Changing it switches which saved password applies — they are stored per login.",
+  "remoteConnect.sshPasswordLabel": "Password or key passphrase",
+  "remoteConnect.sshSavedPlaceholder": "Using saved secret — leave blank",
+  "remoteConnect.sshPasswordPlaceholder": "SSH password, or your key's passphrase…",
+  "remoteConnect.connectedState": "Connected",
+  "remoteConnect.sshStopTitle": "Stop this SSH connection attempt and reset the connection state.",
+  "remoteConnect.savePassword": "Save password",
+  "remoteConnect.saveHintKeptTerminal": "kept in your OS keychain — a terminal login isn't seen by Eldrun, so it stores nothing new; turn off to delete it",
+  "remoteConnect.saveHintSaved": "saved in your OS keychain — turn off to delete it",
+  "remoteConnect.saveHintNothingTerminal": "nothing to store from a terminal login — Eldrun never sees it",
+  "remoteConnect.autoConnectTitleEligible": "Connect this project by itself on launch and when you switch to it. It never asks for anything: it goes straight in when the host is reachable, and brings the VPN up only when it isn't. Note that bringing the VPN up reroutes this whole computer's traffic — with auto-connect that happens without a prompt, so watch the header's VPN indicator.",
+  "remoteConnect.autoConnectTitleNotEligible": "Save the SSH password (or use key authentication) first — auto-connect is only offered when connecting needs nothing from you.",
+  "remoteConnect.autoConnectLabel": "Auto-connect",
+  "remoteConnect.autoConnectHintEligible": "on launch and on switch — VPN only if the host isn't reachable directly",
+  "remoteConnect.autoConnectHintNotEligible": "needs a saved password or key authentication",
+  "remoteConnect.autoConnectVpnWarningPre": "Heads up: if the host isn't reachable directly, auto-connect brings the VPN up",
+  "remoteConnect.autoConnectVpnWarningStrong": "without asking",
+  "remoteConnect.autoConnectVpnWarningPost": "— rerouting this computer's traffic on launch. The header's VPN indicator shows when a tunnel is up, and can bring it down.",
+  "remoteConnect.autoConnectInteractiveTitle": "Connect this project by itself on launch and when you switch to it. Eldrun handles no passwords in this mode, so the login (and the VPN, if this project has one) opens in the root terminal for you to authenticate — the project connects on its own once you're in.",
+  "remoteConnect.autoConnectInteractiveHint": "on launch and on switch — opens the login in the root terminal",
+  "remoteConnect.sshTermBtnTitle": "Open the SSH login in a terminal below — enter the password there.",
+  "remoteConnect.sshTermOpenBelow": "SSH terminal open below",
+  "remoteConnect.sshTermOpenBtn": "Open SSH login terminal",
+  "remoteConnect.tryConnectTitle": "If you've finished logging in above, connect now.",
+  "remoteConnect.tryConnectBtn": "I've logged in — connect",
+  "remoteConnect.sshTermHint": "Log in below — the pooled connection comes up once you're authenticated.",
+  "remoteConnect.killConfirmTitle": "Confirm: this kills every running tmux session on the host — it can't be undone.",
+  "remoteConnect.killConfirmBtn": "Confirm: end all jobs",
+  "remoteConnect.killArmTitle": "Actively disconnect: end every running tmux job on this host and close the connection. Jobs are killed only on this click — never on an Eldrun restart.",
+  "remoteConnect.killArmBtn": "Disconnect & end jobs",
+  "remoteConnect.forgetPasswordTitle": "Delete this host's saved password from your OS keychain. The current connection stays up; the next connect asks for the password again.",
+  "remoteConnect.forgetPasswordBtn": "Forget saved password",
+  "carefulHost.title": "Keep Eldrun's background work off this machine: the file-size census stops scanning the host by itself, and monitoring gets cheaper and slower. Use it for a login node or any machine you share with others — not for a compute node you hold for the length of a job, which is yours while you have it.",
+  "carefulHost.label": "Go easy on this machine",
+  "carefulHost.hintDefault": "for a login node or a shared box: skip the scans that read its whole filesystem",
+  "carefulHost.hintOnByDefault": "on by default for every remote machine — flip it off if this one is yours",
+  "carefulHost.hintNotCareful": "this machine is yours: full monitoring, same as local",
+  "carefulHost.hintHpcTagged": "always on: this machine is tagged as an HPC cluster login node",
+  "hpcHost.title": "Tag this machine as a shared cluster login node. Eldrun then never scans or measures its filesystem by itself, runs no background sync or lockstep polling against it, never connects to it silently at launch, reads it lightly whatever the reading switch says, and asks before a run lands on it. Nothing detects this — a scheduler on PATH says the machine has SLURM, not that its operators mind.",
+  "hpcHost.label": "HPC cluster (login node)",
+  "hpcHost.hintOn": "background work off, light reading forced, runs ask first",
+  "hpcHost.hintOff": "tick it for a cluster login node — never for a compute node you hold through a job",
+  "remoteConnect.vpnSectionAria": "OpenVPN tunnel",
+  "remoteConnect.sshSectionAria": "SSH login",
+  "remoteMachines.title": "{name} — Remote machines",
+  "remoteMachines.introPre": "Every machine this project reaches, in one place — the",
+  "remoteMachines.introStrongPrimary": "primary",
+  "remoteMachines.introMid1": "that owns its files and git, plus any extra worker machines that run its",
+  "remoteMachines.introStrongSameCode": "same code",
+  "remoteMachines.introMid2": ". Connect or manage any of them here, or add a new worker below. A new worker shares the primary's project folder by default (no copy, no git); tick",
+  "remoteMachines.introStrongSyncCopy": "Sync a copy",
+  "remoteMachines.introPost": "to give it its own one-way-synced copy — for hosts that don't share storage with the primary.",
+  "remoteMachines.primaryTagTitle": "The primary machine owns this project's files, git and local mirror, with full two-way sync.",
+  "remoteMachines.primaryTag": "Primary",
+  "remoteMachines.connectedDot": "Connected.",
+  "remoteMachines.notConnectedDot": "Not connected.",
+  "remoteMachines.localMirrorLabel": "Local mirror:",
+  "remoteMachines.manage": "Manage…",
+  "remoteMachines.connectEllipsis": "Connect…",
+  "remoteMachines.sharedFsTag": "Shared filesystem",
+  "remoteMachines.dropIntro": "From your global machines. Give the shared path it sees this project's folder at — everything else is already known.",
+  "remoteMachines.pathOnMachine": "Path on this machine",
+  "remoteMachines.absolutePathPlaceholder": "Absolute path (e.g. /home/me/project)",
+  "remoteMachines.adding": "Adding…",
+  "remoteMachines.addMachineBtn": "Add machine",
+  "remoteMachines.noWorkers": "No worker machines yet.",
+  "remoteMachines.sharedStatus": "Runs in the primary's shared folder — no copy, no sync.",
+  "remoteMachines.syncFailedLabel": "Sync failed:",
+  "remoteMachines.lastSyncedLabel": "Last synced:",
+  "remoteMachines.alreadyCurrent": "(already current)",
+  "remoteMachines.syncingEllipsis": "Syncing…",
+  "remoteMachines.notSyncedYet": "Not synced yet",
+  "remoteMachines.sharedTagTitle": "Shared filesystem: shells run in the primary's project folder on this machine. No code is copied and git is never run here.",
+  "remoteMachines.syncedTagTitle": "Synced copy: this machine keeps its own read-only copy of the code, one-way synced from the primary.",
+  "remoteMachines.syncedCopyTag": "Synced copy",
+  "remoteMachines.syncCodeNow": "Sync code now",
+  "remoteMachines.pullOutputsTitle": "Fetch this machine's experiment outputs (untracked files) to your computer. Confirms the size first.",
+  "remoteMachines.pulling": "Pulling…",
+  "remoteMachines.pullOutputsBtn": "Pull outputs…",
+  "remoteMachines.removeTitle": "Remove this machine from the project (its files on the host are left untouched).",
+  "remoteMachines.remove": "Remove",
+  "remoteMachines.syncCopyToggleTitle": "On: this machine keeps its own copy of the code, one-way synced from the primary. Off: it shares the primary's project folder over a shared filesystem (no copy, no git).",
+  "remoteMachines.syncCopyLabel": "Sync a copy of the code to this machine",
+  "remoteMachines.autoSyncTitle": "Keep this machine's tracked code synced to the project HEAD on every commit.",
+  "remoteMachines.autoSyncLabel": "Auto-sync code on every commit",
+  "remoteMachines.addMachineTitle": "Add a machine",
+  "remoteMachines.globalListTitle": "Your machines",
+  "remoteMachines.globalListHelp":
+    "Machines from the header's Machines list. They are already set up, so adding one here only needs its folder on that machine.",
+  "remoteMachines.globalQuickAdd": "Add",
+  "remoteMachines.globalQuickAddTitle":
+    "Add this machine as a shared-filesystem worker — confirm its folder above, then it is added and connected.",
+  "remoteMachines.globalFill": "Use in the form",
+  "remoteMachines.globalFillTitle":
+    "Put this machine's address into the form below, to browse its folders or sync a copy to it.",
+  "remoteMachines.globalAlreadyAdded": "Already added",
+  "remoteMachines.globalAlreadyAddedTitle":
+    "This machine is already this project's primary host or one of its workers.",
+  "remoteMachines.sshAddressLabel": "SSH address",
+  "remoteMachines.sshAddressPlaceholder": "host[:port]  (e.g. gpu-2:22)",
+  "remoteMachines.usernamePlaceholder": "SSH login user (e.g. me) — or include it as user@ above",
+  "remoteMachines.sshPasswordSavedPlaceholder": "Using saved password — leave blank",
+  "remoteMachines.sshPasswordPlaceholder": "SSH password or key passphrase — blank for an unlocked key",
+  "remoteMachines.saveTitleTerminal": "A terminal login is one Eldrun never sees, so it stores nothing new — and deletes nothing either. Any saved password stays as it is; the machine's own Connect menu is where you change it.",
+  "remoteMachines.saveTitleHeadless": "Save this machine's SSH password in your OS keychain, keyed by host — the machine's own Connect menu then finds it and won't ask again. Off by default; an untick deletes a previously-saved one.",
+  "remoteMachines.saveHintKeptTerminal": "Kept in your OS keychain — a terminal login isn't seen by Eldrun, so it neither stores nor deletes anything.",
+  "remoteMachines.saveHintNothingTerminal": "Nothing to store from a terminal login — Eldrun never sees it.",
+  "remoteMachines.saveHintSavedWillAskAgainOff": "Saved in your OS keychain — this machine's Connect won't ask again. Turn off to delete it.",
+  "remoteMachines.saveHintWillSave": "Will be saved to your OS keychain so this machine's Connect won't ask again.",
+  "remoteMachines.saveHintNotSavedPre": "Used only to log in — not saved. Turn on",
+  "remoteMachines.saveHintNotSavedPost": "to keep it.",
+  "remoteMachines.loginTermHint": "Log in below — the folder picker opens by itself once this login is through.",
+  "remoteMachines.retryBrowseTitle": "If you've finished logging in above, browse this machine now.",
+  "remoteMachines.waitingForLogin": "Waiting for the login…",
+  "remoteMachines.loggedInBrowse": "I've logged in — browse",
+  "remoteMachines.openLoginTerminal": "Open login terminal",
+  "remoteMachines.loggingIn": "Logging in…",
+  "remoteMachines.logIn": "Log in",
+  "remoteMachines.loggedInToPre": "Logged in to",
+  "remoteMachines.sharedFsToggleTitleStep2": "Off (default): this machine shares the primary's project folder over a shared filesystem — no copy, no git. On: give it its own one-way-synced copy of the code (for hosts that don't share storage).",
+  "remoteMachines.syncCopyDescOn": "This machine keeps its own copy of the code, one-way synced from the primary. Browse to (or create) the folder for that copy.",
+  "remoteMachines.syncCopyDescOff": "This machine shares the primary's project folder over a shared filesystem — no copy, no git. Browse to that folder on this machine.",
+  "remoteMachines.remotePathForCopy": "Remote path for this machine's copy",
+  "remoteMachines.pathToProject": "Path to the project on this machine",
+  "remoteMachines.reconnect": "Reconnect",
+  "remoteMachines.browseEllipsis": "Browse…",
+  "remoteMachines.browserFooter": "Browse to a folder, then click “Use this folder”.",
+  "remoteMachines.labelOptional": "Label (optional)",
+  "remoteMachines.labelPlaceholder": "e.g. gpu-2",
+  "remoteMachines.enterAbsolutePath": "Enter an absolute remote path (e.g. /home/me/project)",
+  "remoteMachines.enterHostBeforeBrowsing": "Enter a host as [user@]host[:port] before browsing",
+  "remoteMachines.enterHostBeforeLogin": "Enter a host as [user@]host[:port] before logging in",
+  "remoteMachines.enterHost": "Enter a host as [user@]host[:port]",
+  "remoteMachines.noOutputFiles": "No output files to pull.",
+  "remoteMachines.pullConfirm": "Pull {files} output file(s) ({bytes}) from this machine to your computer?",
+  "remoteMachines.pulledResult": "Pulled {pulled} file(s) → {dest}{errs}",
+  "remoteMachines.pullErrorsSuffix": " ({count} failed)",
+  "remoteMachines.pullFailed": "Pull failed: {error}",
+  "hpcWizard.stepLogin": "Login",
+  "hpcWizard.stepProject": "Project",
+  "hpcWizard.stepWorkspace": "Workspace",
+  "hpcWizard.stepData": "Load data",
+  "hpcWizard.stepRun": "Run job",
+  "hpcWizard.stepWatch": "Watch",
+  "hpcWizard.sbatchJobName": "Job name",
+  "hpcWizard.sbatchPartition": "Partition",
+  "hpcWizard.sbatchTime": "Time",
+  "hpcWizard.sbatchNodes": "Nodes",
+  "hpcWizard.sbatchTasks": "Tasks",
+  "hpcWizard.sbatchCpusPerTask": "CPUs/task",
+  "hpcWizard.sbatchMemory": "Memory",
+  "hpcWizard.sbatchGres": "GRES",
+  "hpcWizard.sbatchOutput": "Output",
+  "hpcWizard.title": "HPC pipeline",
+  "hpcWizard.loginHint": "Log in to your cluster. If it's only reachable through your institution's VPN, bring up the OpenVPN tunnel first (in the SSH section below).",
+  "hpcWizard.projectNameLabel": "Project name",
+  "hpcWizard.mirrorLabel": "Local location (synced mirror)",
+  "hpcWizard.noFolderSelected": "No folder selected",
+  "hpcWizard.browseBtn": "Browse...",
+  "hpcWizard.hostPathHintPre": "On the host:",
+  "hpcWizard.hostPathHintPost": "— the next step can move this into a workspace on the cluster's parallel filesystem.",
+  "hpcWizard.watchPre": "Your job was submitted and a log tab is now tailing its output. Open the Jobs view (the",
+  "hpcWizard.watchMid": "toggle in the file panel) to see it queue, run, and finish — with per-job",
+  "hpcWizard.watchWatchWord": "Watch",
+  "hpcWizard.watchCancelWord": "Cancel",
+  "hpcWizard.watchAnd": "and",
+  "hpcWizard.done": "Done",
+  "hpcWizard.noToolingPre": "This host has no workspace tooling (",
+  "hpcWizard.noToolingPost": ").",
+  "hpcWizard.noToolingScratchHint": "It does point at a big filesystem — pick where this project should live, since a home directory is usually quota'd and meant for code.",
+  "hpcWizard.noToolingNoScratchPre": "The project will live in the folder you browsed to:",
+  "hpcWizard.homeRadioLabel": "home",
+  "hpcWizard.readOnly": "read-only",
+  "hpcWizard.projectOnHostLabel": "Project on the host:",
+  "hpcWizard.creating": "Creating…",
+  "hpcWizard.createProject": "Create project",
+  "hpcWizard.introPre": "On a cluster your home directory is a small, quota'd filesystem meant for code. The data of a computation belongs in a",
+  "hpcWizard.introStrongWorkspace": "workspace",
+  "hpcWizard.introMid": "— a directory on the parallel filesystem with a name and a duration, which is",
+  "hpcWizard.introStrongDeleted": "deleted when it expires",
+  "hpcWizard.introPost": ". Allocate one now, before any data is uploaded or synced.",
+  "hpcWizard.checkingTooling": "Checking the host for workspace tooling…",
+  "hpcWizard.workspaceNameLabel": "Workspace name",
+  "hpcWizard.daysLabel": "Days",
+  "hpcWizard.filesystemLabel": "Filesystem",
+  "hpcWizard.siteDefault": "(site default)",
+  "hpcWizard.defaultSuffix": " (default)",
+  "hpcWizard.reminderEmailLabel": "Reminder e-mail",
+  "hpcWizard.optionalPlaceholder": "optional",
+  "hpcWizard.remindDaysLabel": "Remind days before",
+  "hpcWizard.reminderHint": "A reminder is worth setting — expiry deletes the data. Many sites only deliver to their own domain.",
+  "hpcWizard.allocating": "Allocating…",
+  "hpcWizard.allocateWorkspace": "Allocate workspace",
+  "hpcWizard.readingWorkspaces": "Reading your workspaces…",
+  "hpcWizard.yourWorkspaces": "Your workspaces",
+  "hpcWizard.whereProjectGoes": "Where the project goes",
+  "hpcWizard.inWorkspaceStrong": "In the workspace",
+  "hpcWizard.inWorkspaceDesc": "— everything Eldrun syncs (files, git, uploads) lands on the parallel filesystem, never in your home quota.",
+  "hpcWizard.inBrowsedStrong": "In the browsed folder",
+  "hpcWizard.inBrowsedDesc": ", with the workspace linked in as",
+  "hpcWizard.linkNameLabel": "Link name",
+  "hpcWizard.anchorPre": "Keep a small folder in my cluster home for this project — job",
+  "hpcWizard.anchorMid": ", a",
+  "hpcWizard.anchorPost": "link, and a record naming the workspace. It survives the workspace's expiry (nothing large is put there, and Eldrun never syncs it).",
+  "hpcWizard.anchorFolderLabel": "Folder (under your home)",
+  "hpcWizard.createWithoutWorkspace": "Create without a workspace",
+  "hpcWizard.dataHintPre": "Optionally upload input files. They land in",
+  "hpcWizard.dataHintWorkspaceSuffix": "— on the parallel filesystem, not in your home quota.",
+  "hpcWizard.dataHintPlainSuffix": ".",
+  "hpcWizard.dataHintPost": "Large trees are better marked auto-sync in the file panel; this is for a few files.",
+  "hpcWizard.theProjectFolder": "the project folder",
+  "hpcWizard.linkNotCreatedSuffix": "/ (link not created)",
+  "hpcWizard.uploading": "Uploading…",
+  "hpcWizard.addFiles": "Add files…",
+  "hpcWizard.skip": "Skip",
+  "hpcWizard.scriptHintPre": "A starter batch script (",
+  "hpcWizard.scriptHintPost": ") will be written to the project. Adjust its resources, then submit — it runs on a compute node.",
+  "hpcWizard.submitting": "Submitting…",
+  "hpcWizard.submitJob": "⏫ Submit job",
+  "projectDialog.installGitLabel": "Install git",
+  "projectDialog.installBinLabel": "Install {bin}",
+  "projectDialog.titleNew": "New Project",
+  "projectDialog.titleImport": "Import Project",
+  "projectDialog.remoteToggleTitle": "Remote (SSH) project",
+  "projectDialog.remoteToggleDesc": "Work on a project that lives on another machine — terminals, files, and git all run on the host over SSH.",
+  "projectDialog.localLocationLabel": "Local location",
+  "projectDialog.noFolderSelected": "No folder selected",
+  "projectDialog.browseBtn": "Browse...",
+  "projectDialog.localMirrorHint": "The synced local working copy lives here as {name}.",
+  "projectDialog.projectNameLabel": "Project name",
+  "projectDialog.descriptionLabel": "Project description",
+  "projectDialog.descFillModeTitle": "Project description fill mode",
+  "projectDialog.fillModeManual": "Manual",
+  "projectDialog.fillModeAgentChoice": "Agent choice",
+  "projectDialog.descriptionPlaceholder": "What this project is for",
+  "projectDialog.importFromLabel": "Import from",
+  "projectDialog.importFolderOpt": "Folder on this machine",
+  "projectDialog.importGitOpt": "GitHub / GitLab repository (clone)",
+  "projectDialog.importForkOpt": "GitHub / GitLab repository (fork, then clone)",
+  "projectDialog.sourceFolderLabel": "Source folder",
+  "projectDialog.repoToForkLabel": "Repository to fork",
+  "projectDialog.repoUrlLabel": "Repository URL",
+  "projectDialog.forkHintPre": "The repository is forked into your own account, and your fork is what gets cloned here — the original stays as the",
+  "projectDialog.forkHintMid": "remote. Forking runs through the provider's CLI (",
+  "projectDialog.forkHintPost": "), so it uses that CLI's login.",
+  "projectDialog.cloneHintPrivateConnected": "A private repository is cloned with the access token from Settings → Git Hosting. An SSH URL (git@…) uses your own SSH keys instead.",
+  "projectDialog.cloneHintPublicOnly": "Public repositories clone as-is. For a private one, add an access token in Settings → Git Hosting, or use an SSH URL (git@…) to authenticate with your SSH keys.",
+  "projectDialog.hostTypeLabel": "Host type",
+  "projectDialog.detectFromUrl": "Detect from the URL",
+  "projectDialog.detectFromUrlWithProvider": "Detect from the URL ({provider})",
+  "projectDialog.hostTypeHint": "This host doesn't name itself GitHub or GitLab (a self-hosted instance usually doesn't) — pick which it is, since the fork is made by that provider's CLI.",
+  "projectDialog.forkCliMissingPre": "No",
+  "projectDialog.forkCliMissingMid1": "found on this machine — a fork is created by the provider's own CLI, so install it (and sign in with",
+  "projectDialog.forkCliMissingPost": ") to fork from",
+  "projectDialog.runInTerminalBtn": "Run in terminal",
+  "projectDialog.locationLabel": "Location",
+  "projectDialog.cloneDestYourFork": "Your fork is",
+  "projectDialog.cloneDestTheRepo": "The repository is",
+  "projectDialog.cloneDestMid": "cloned into",
+  "projectDialog.cloneDestPost": "here.",
+  "projectDialog.gitHostingLabel": "Git hosting",
+  "projectDialog.gitNoneOpt": "No git (plain files, no repo)",
+  "projectDialog.gitLocalOpt": "Local repo only (not pushed anywhere)",
+  "projectDialog.gitRemotePrivateOpt": "Push to GitHub/GitLab · private",
+  "projectDialog.gitRemotePublicOpt": "Push to GitHub/GitLab · public",
+  "projectDialog.gitHostingHintPre": "“Push to GitHub/GitLab” publishes the repo to a hosting service",
+  "projectDialog.gitHostingHintRemoteSuffix": "— unrelated to the SSH host above, which is just where the project files live.",
+  "projectDialog.needsGitConnectionText": "No GitHub/GitLab connection set up in Eldrun yet. Add an access token in Settings → Git Hosting so the repo can be published.",
+  "projectDialog.setUpGitHostingBtn": "Set up GitHub/GitLab…",
+  "projectDialog.needsGitInstallTextPre": "No git found on this machine — install it to create a git-backed project",
+  "projectDialog.needsGitInstallOrClone": " or clone a repository",
+  "projectDialog.importModeLabel": "Import mode",
+  "projectDialog.modeKeepOpt": "Keep location (register in place)",
+  "projectDialog.modeCopyOpt": "Copy into Eldrun's projects folder",
+  "projectDialog.modeMoveOpt": "Move into Eldrun's projects folder",
+  "projectDialog.remoteImportKeepsFolder": "Remote import keeps the folder in place on the remote host.",
+  "projectDialog.skipScaffoldLabel": "Skip scaffolding (do not generate any scaffold files)",
+  "projectDialog.scaffoldGuidanceAria": "Import scaffold guidance",
+  "projectDialog.importGuidanceTitle": "Import guidance",
+  "projectDialog.stepSelectSource": "Select the source folder and project metadata.",
+  "projectDialog.stepRegisterKeep": "Register the project in its current location.",
+  "projectDialog.stepCopyValidate": "Copy the project to the Eldrun projects folder after manual validation.",
+  "projectDialog.stepMoveValidate": "Move the project to the Eldrun projects folder after manual validation.",
+  "projectDialog.stepCreateScaffold": "Create missing scaffold files and acknowledge files already there.",
+  "projectDialog.stepWriteProjectJson": "Write project.json and add the project to the switcher.",
+  "projectDialog.manualValidationCopy": "I manually validated the copy destination and source folder.",
+  "projectDialog.manualValidationMove": "I manually validated the move destination and source folder.",
+  "projectDialog.fillAllLabel": "Fill all",
+  "projectDialog.noMissingFiles": "No missing files",
+  "projectDialog.chooseFillMode": "Choose fill mode...",
+  "projectDialog.alreadyThere": "Already there",
+  "projectDialog.missingLabel": "Missing",
+  "projectDialog.alreadyThereKept": "Already there, will be kept",
+  "projectDialog.missingWillAdd": "Missing, will be added",
+  "projectDialog.statusOnly": "Status only",
+  "projectDialog.chooseSourceToPreview": "Choose a source folder to preview scaffold files.",
+  "projectDialog.loadingScaffoldPreview": "Loading scaffold preview...",
+  "projectDialog.remoteDestinationLabel": "Remote destination: {path}",
+  "projectDialog.remoteLocationLabel": "Remote location: {path}",
+  "projectDialog.changeFolderBtn": "Change folder",
+  "projectDialog.changeFolderTitleWinManual": "Go back to change the remote path",
+  "projectDialog.changeFolderTitleBrowse": "Go back to the remote browser to pick a different folder",
+  "projectDialog.destinationLabel": "Destination: {path}",
+  "projectDialog.locationColonLabel": "Location: {path}",
+  "projectDialog.forking": "Forking...",
+  "projectDialog.cloningEllipsis": "Cloning...",
+  "projectDialog.working": "Working...",
+  "projectDialog.create": "Create",
+  "projectDialog.forkAndImport": "Fork & Import",
+  "projectDialog.cloneAndImport": "Clone & Import",
+  "projectDialog.import": "Import",
+  "projectDialog.runInTerminalTitle": "Run this command in a new terminal tab",
+  "remoteProjectSection.vpnUpClickToReconnect": "OpenVPN tunnel is up. Click to reconnect.",
+  "remoteProjectSection.vpnFailedWithError": "VPN connection failed: {error}",
+  "remoteProjectSection.vpnFailedClickRetry": "VPN connection failed. Click to retry.",
+  "remoteProjectSection.vpnBringUpHint": "Bring the OpenVPN tunnel up now to reach a VPN-gated host.",
+  "remoteProjectSection.vpnSelectConfigFirst": "Select an OpenVPN config first.",
+  "remoteProjectSection.stepConnectLabel": "Connect",
+  "remoteProjectSection.stepBrowseLabel": "Browse",
+  "remoteProjectSection.stepDetailsLabel": "Details",
+  "remoteProjectSection.remoteStepsAria": "Remote project steps",
+  "remoteProjectSection.passwordAuthWarning": "Password auth needs OpenSSH 8.4+ or sshpass — update OpenSSH or install sshpass, or use SSH keys (leave the password blank).",
+  "remoteProjectSection.opensslMissingWarning": "openvpn/pkexec not found — VPN-gated hosts can't connect. Install openvpn and polkit.",
+  "remoteProjectSection.vpnToggleDescLine1": "Only needed for a VPN-gated host — leave off when you're already on the right network.",
+  "remoteProjectSection.vpnConfigLabel": "OpenVPN config",
+  "remoteProjectSection.vpnConfigCopiedHint": "(copied into Eldrun on selection)",
+  "remoteProjectSection.noOvpnSelected": "No .ovpn selected",
+  "remoteProjectSection.browseEllipsis": "Browse…",
+  "remoteProjectSection.storedWithProject": "(stored with the project)",
+  "remoteProjectSection.vpnUsernamePlaceholderNoDots": "OpenVPN account username",
+  "remoteProjectSection.savedInKeychainYour": "(saved in your OS keychain)",
+  "remoteProjectSection.notStoredUnlessSaved": "(not stored unless you save it below)",
+  "remoteProjectSection.vpnAccountPasswordNoDots": "OpenVPN account password",
+  "remoteProjectSection.keyPassphrasePlaceholderNoDots": "Passphrase for the config's encrypted key",
+  "remoteProjectSection.vpnTermBtnTitleActive": "Bring the OpenVPN tunnel up in a terminal below — enter the passphrase there. It stays up for the new project.",
+  "remoteProjectSection.vpnTermHintClosed": "Click above to open a terminal here — enter the passphrase there. Eldrun never handles it; the tunnel stays up for the new project.",
+  "remoteProjectSection.vpnTermHintOpen": "Authenticate the tunnel below — it keeps running for the new project after you close this dialog.",
+  "remoteProjectSection.sshAddressLabel": "SSH address",
+  "remoteProjectSection.reuseSshAddressTitle": "Reuse a previously-used SSH address",
+  "remoteProjectSection.sshAddressPlaceholder": "user@host or host:2222",
+  "remoteProjectSection.passwordLabel": "Password",
+  "remoteProjectSection.notStoredBlankKey": "(not stored unless you save it below; blank uses SSH key)",
+  "remoteProjectSection.sshSavedPlaceholder": "Using saved password — leave blank",
+  "remoteProjectSection.sshPasswordPlaceholderNoDots": "password, or your key's passphrase — blank if the key is unlocked",
+  "remoteProjectSection.connectingDotsShort": "Connecting...",
+  "remoteProjectSection.remotePathLabel": "Remote path",
+  "remoteProjectSection.remotePathHintNew": "(parent folder; the project is created inside it)",
+  "remoteProjectSection.remotePathHintImport": "(absolute path of the existing project)",
+  "remoteProjectSection.reuseRemotePathTitle": "Reuse a previously-used remote path for this host",
+  "remoteProjectSection.remotePathPlaceholder": "/home/user/projects",
+  "remoteProjectSection.sshTermBtnTitle": "Open the SSH login in a terminal below — enter any password there. The login stays up for the new project.",
+  "remoteProjectSection.tryBrowseTitle": "If you've finished logging in above, browse the remote tree now.",
+  "remoteProjectSection.sshTermHintClosedPre": "Click above to open a terminal here — enter any password there. Eldrun never handles it; the login stays up for the new project.",
+  "remoteProjectSection.sshTermHintClosedSuffix": " Once you're logged in, the remote tree opens for browsing.",
+  "remoteProjectSection.sshTermHintOpen": "Log in below — the session keeps running for the new project after you close this dialog.",
+  "remoteProjectSection.willCreateLabel": "Will create: {path}",
+  "remoteProjectSection.selectedLabel": "Selected: {path}",
+  "credentialPasteBar.typeItForMe": "Type it for me:",
+  "credentialPasteBar.pastedFlash": "pasted",
+  "credentialPasteBar.nothingSavedFlash": "nothing saved for this login (or the keyring is locked)",
+  "credentialPasteBar.pasteUsername": "Paste username",
+  "credentialPasteBar.pasteUsernameTitle": "Type \"{user}\" into the login terminal at the cursor.",
+  "credentialPasteBar.pastePassword": "Paste password",
+  "credentialPasteBar.pastePasswordTitle": "Type the password saved for this login into the terminal at the cursor — it goes from your OS keychain straight to the terminal, never through Eldrun's UI. Press Enter yourself.",
+  "credentialPasteBar.pasteVpnUsernameTitle": "Type this tunnel's auth username into the terminal at the cursor.",
+  "credentialPasteBar.pastePassphrase": "Paste passphrase",
+  "credentialPasteBar.pasteVpnSecretTitle": "Type the secret saved for this tunnel into the terminal at the cursor — from your OS keychain straight to the terminal. Press Enter yourself.",
+  "credentialPasteBar.pasteKeyPassphrase": "Paste key passphrase",
+  "credentialPasteBar.pasteKeyPassphraseTitle": "Type the saved private-key passphrase into the terminal at the cursor — OpenVPN asks for it separately from the account password.",
+  "terminalSignIn.sshHostWord": "SSH host",
+  "terminalSignIn.vpnTunnelWord": "OpenVPN tunnel",
+  "terminalSignIn.busyTitle": "Disconnect the login terminal below first.",
+  "terminalSignIn.titleTemplate": "Log in to the {what} in a terminal here instead of in these fields. It asks its own questions — a password, a challenge code, a second prompt — and you answer them directly; Eldrun never sees them. This connect only: your headless setting stays as it is.",
+  "terminalSignIn.label": "Sign in in a terminal",
+  "terminalSignIn.failedHint": "the login failed — if this {what} asks for anything but a password (a challenge code, a second prompt), only a terminal can answer it",
+  "terminalSignIn.defaultHint": "for a host that asks more than a password — a challenge code, a second prompt",
+  "projectHoverCard.statusCurrent": "Current",
+  "projectHoverCard.statusActive": "Active",
+  "projectHoverCard.statusInactive": "Inactive",
+  "projectHoverCard.timeUnderMinute": "< 1m",
+  "projectHoverCard.cpuIdle": "idle",
+  "projectHoverCard.remoteLabel": "remote",
+  "projectHoverCard.localLabel": "local",
+  "projectHoverCard.originLabel": "origin",
+  "projectHoverCard.todayPrefix": "Today:",
+  "projectHoverCard.pausedSuffix": "(paused)",
+  "projectHoverCard.cpuPrefix": "CPU:",
+  "windowControls.minimize": "Minimize",
+  "windowControls.maximize": "Maximize",
+  "connTypeIcon.offlineSuffix": " (offline)",
+  "appTimer.globalActivityTitle": "Global Activity",
+  "appTimer.pausedResumeHint": "Paused — click to resume",
+  "appTimer.clickPauseHint": "Click to pause • Right-click for activity",
+  "appResource.processCountOne": "{count} Eldrun process",
+  "appResource.processCountMany": "{count} Eldrun processes",
+  "appResource.gpuNoDeviceTitle": "GPU memory in use by local models (Ollama) — this machine's GPU reports no memory of its own",
+  "remoteConnMenu.statusError": "error",
+  "remoteConnMenu.statusConnecting": "connecting",
+  "remoteConnMenu.statusConnected": "connected",
+  "remoteConnMenu.statusOff": "off",
+  "remoteConnMenu.ariaLabel": "Remote machines — click to connect / manage this project's hosts",
+  "remoteConnMenu.workingWord": "working",
+  "vpnIndicator.keyringStayedLocked": "The keyring stayed locked — saved VPN credentials can't be read yet.",
+  "vpnIndicator.keyringLockedConnectReason": "Your OS keyring is locked, so the saved VPN credentials can't be read. Unlock it (or enter the passphrase below) to connect.",
+  "vpnIndicator.savedCredentialsDidntWork": "The saved VPN credentials didn't work: {error}",
+  "vpnIndicator.noCredentialStore": "This machine has no credential store, so nothing can be saved for this tunnel.",
+  "vpnIndicator.noSavedCredentialsYet": "No saved credentials for this tunnel yet — tick “Save login credentials” to skip this next time.",
+  "vpnIndicator.enterCredentialsOnce": "Enter the credentials once — they go into your OS keychain, and this tunnel connects without asking from now on.",
+  "vpnIndicator.saveCredentialsAria": "Save login credentials for {file}",
+  "vpnIndicator.saveCredsUnavailableTitle": "This machine has no OS credential store, so nothing can be saved.",
+  "vpnIndicator.saveCredsSavedTitle": "Credentials for this tunnel are in your OS keychain — connecting doesn't ask. Turn off to delete them.",
+  "vpnIndicator.saveCredsNotSavedTitle": "Ask once for this tunnel's credentials, keep them in your OS keychain, and connect without asking from then on.",
+  "vpnIndicator.saveLoginCredentialsLabel": "Save login credentials",
+  "vpnIndicator.savedButLocked": "Saved, but your keyring is locked — unlock it above to use them.",
+  "vpnIndicator.connectOnLaunchAria": "Connect {file} on launch",
+  "vpnIndicator.connectOnLaunchHeadlessTitle": "Bring this tunnel up automatically when Eldrun starts, using the saved credentials — no prompt. It reroutes this computer from launch.",
+  "vpnIndicator.connectOnLaunchInteractiveTitle": "Open this tunnel's connect command in the root terminal when Eldrun starts, for you to authenticate. It reroutes this computer once it is up.",
+  "vpnIndicator.connectOnLaunchLabel": "Connect on launch",
+  "vpnIndicator.needSaveCredsFirstHintPre": "Turn on",
+  "vpnIndicator.needSaveCredsFirstHintPost": "first — auto-connect never prompts, so it is only offered once connecting can be silent.",
+  "vpnIndicator.startsWithEldrun": "Starts with Eldrun",
+  "vpnIndicator.waitsInRootTerminal": " (waits in the root terminal)",
+  "vpnIndicator.mainAriaLabel": "OpenVPN — connect or disconnect a tunnel",
+  "vpnIndicator.titleOff": "OpenVPN — no tunnel. Connecting one routes this computer's traffic through it.",
+  "vpnIndicator.titleConnecting": "OpenVPN — connecting. Once it is up, this computer's traffic routes through the tunnel.",
+  "vpnIndicator.titleConnected": "OpenVPN — up. This computer's traffic routes through the tunnel.",
+  "vpnIndicator.vpnLabel": "VPN",
+  "vpnIndicator.note": "A tunnel routes",
+  "vpnIndicator.noteStrong": "this whole computer's",
+  "vpnIndicator.notePost": "traffic, not just Eldrun's — including your browser — for as long as it is up.",
+  "vpnIndicator.lockedBannerPre": "Your OS keyring is",
+  "vpnIndicator.lockedBannerStrong": "locked",
+  "vpnIndicator.lockedBannerPost": ", so saved VPN credentials can't be read — connecting will ask for them again until it is unlocked.",
+  "vpnIndicator.unlockTitle": "Unlock the OS credential store so the saved credentials can be used. Your desktop asks for the keyring password.",
+  "vpnIndicator.unlocking": "Unlocking…",
+  "vpnIndicator.unlockKeyring": "Unlock keyring",
+  "vpnIndicator.heldForPrefix": "for",
+  "vpnIndicator.heldByNoProject": "held by no project",
+  "vpnIndicator.stopConnectingTitle": "Stop trying to bring this tunnel up and restore normal routing.",
+  "vpnIndicator.stopConnecting": "Stop connecting",
+  "vpnIndicator.disconnectTunnelTitle": "Bring this tunnel down and restore normal routing. Projects using it stay open; their SSH may or may not survive without it.",
+  "vpnIndicator.disconnectTunnel": "Disconnect tunnel",
+  "vpnIndicator.connectGroupLabel": "Connect",
+  "vpnIndicator.removeConfigHint": "Removes this config from Eldrun and forgets its saved credentials.",
+  "vpnIndicator.usedByPre": "Used by",
+  "vpnIndicator.usedByPost": "— connecting that project will ask for a config again.",
+  "vpnIndicator.removeConfigBtn": "Remove config",
+  "vpnIndicator.keepBtn": "Keep",
+  "vpnIndicator.connectTunnelTitle": "Bring this tunnel up. It will route this computer's traffic — not only Eldrun's.",
+  "vpnIndicator.removeConfigTitle": "Remove this stored config from Eldrun and forget its saved credentials. Asks once more before doing it.",
+  "vpnIndicator.emptyStatePre": "No OpenVPN config stored yet — add a",
+  "vpnIndicator.emptyStatePost": "file, then connect it from its row (it asks for your password there).",
+  "vpnIndicator.addFirstConfigTitle": "Pick a .ovpn file and store it in Eldrun. Adding it does not connect — you connect it explicitly afterwards, where it asks for your password.",
+  "vpnIndicator.addAnotherConfigTitle": "Pick another .ovpn file and store it in Eldrun. Adding it does not connect — you connect it explicitly from its row afterwards.",
+  "vpnIndicator.addConfigBtn": "Add config…",
+
+  // ── "Save password" (SavePasswordRow) ────────────────────────────────────
+  // The tri-state a keychain read can land in, said out loud. "We can't tell" is
+  // a distinct answer from "nothing is saved", and conflating the two is what
+  // deleted a real credential (see `useSavedCredential`).
+  "savePassword.hintChecking": "checking your OS keychain…",
+  "savePassword.hintUnreadable":
+    "can't tell whether one is already saved — your OS credential store can't be read right now.",
+  "savePassword.titleHeadless": "Save this host's SSH password in your OS keychain, keyed by host.",
+  "savePassword.titleTerminal":
+    "A terminal login is one Eldrun never sees, so it stores nothing new — and deletes nothing either. Any saved password for this host stays as it is.",
+  "savePassword.saveFailedLabel": "Not saved:",
+  "savePassword.lockedBannerPost":
+    ", so a saved SSH password can't be read — this connect will ask for it again, and Eldrun can't tell you whether one is already stored.",
+  "savePassword.unavailableBanner":
+    "No OS credential store is available on this machine, so SSH passwords can't be saved or read here.",
+
+  // ── Auto-connect eligibility (autoConnectEligibility) ─────────────────────
+  "autoConnect.offWhileHpc": "— off while tagged HPC",
+  "autoConnect.hpcTitle":
+    "This machine is tagged as an HPC cluster login node, so Eldrun never connects to it on its own. Untag it to arm this.",
+
+  // ── Bounded login polls ───────────────────────────────────────────────────
+  "remoteLogin.pollGaveUp":
+    "No login detected after two minutes. Finish signing in in the terminal, then press the button again.",
+  "remoteMachines.dropConnectFailed":
+    "The machine was added, but connecting it failed: {error} — use its Connect button below to retry.",
+  // ── Machines (header "Global machines" menu) ───────────────────────────────
+  // The only remote-login surface that had no translation at all, while the
+  // `TerminalSignInToggle` inside its own add-form did — one row of a form
+  // switching language and the rest not.
+  "machines.label": "Machines",
+  "machines.ariaLabel": "Global machines — click to open the list",
+  "machines.triggerTitle": "Global worker machines — connect one, then add it to any project from its row. Opening this list checks each machine, which is a real SSH login, so it opens on a click and never on hover.",
+  "machines.groupLabel": "Global machines",
+  "machines.empty": "No global machines yet.",
+  "machines.note.strong": "Use a row's ⇥ button",
+  "machines.note.rest": "to add that machine to a project — as a shared-folder worker on a remote project, or as the primary host of a local one. Drag a row's grip (⠿) to reorder.",
+
+  // What a row is: a session we opened, and whether the host still answers, are
+  // two different questions and the words keep them apart.
+  "machines.state.connected": "connected",
+  "machines.state.stale": "connected, but not answering",
+  "machines.state.connecting": "connecting",
+  "machines.state.error": "error",
+  "machines.state.reachable": "up, not connected",
+  "machines.state.unreachable": "no answer",
+  "machines.state.unknown": "not checked",
+  "machines.badge.stale": "stale",
+  "machines.badge.reachable": "up",
+  "machines.badge.unreachable": "no answer",
+  "machines.badge.unknown": "not checked",
+  "machines.tip.connected": "Eldrun holds an SSH session on this machine.",
+  "machines.tip.stale": "Eldrun still holds a session here, but the machine did not answer the last check — the connection is most likely dead. Reconnect, or disconnect to clear it.",
+  "machines.tip.connecting": "Connecting…",
+  "machines.tip.error": "The last connect attempt failed — the reason is on the row.",
+  "machines.tip.reachable": "It answered the last check, so it can be connected — but no session is open on it yet.",
+  "machines.tip.unreachable": "It did not answer the last check, and no session is open on it.",
+  "machines.tip.unknown": "Nobody has checked this machine yet.",
+  "machines.tip.unknownHpc": "Not checked — this machine is tagged as a cluster login node, so Eldrun never logs in to it by itself. Use ◎ to check it now.",
+  "machines.lampGroup": "{count} {word} — {names}",
+  "machines.lampWorking": "{count} working: {names}",
+
+  // Fleet-wide actions.
+  "machines.retryAllAria": "Retry all",
+  "machines.retryAllTitle": "Retry all — connect every machine that isn't already connected. Machines tagged as cluster login nodes are left out; connect those from their own row. A host that needs a password we don't have stays red to retry on its row.",
+  "machines.disconnectAllAria": "Disconnect all",
+  "machines.disconnectAllTitle": "Disconnect all — actively disconnect every connected machine: end all their tmux jobs and close each SSH connection. Jobs are killed only on this click — never on an Eldrun restart.",
+  "machines.usageAria": "Remote host usage",
+  "machines.usageTitle": "Remote host usage — check who's logged in and what's running on every machine here: CPU, memory, GPU and top processes, read right now.",
+  "machines.tmuxJobs": "all tmux jobs",
+  "machines.disconnectAllHint.pre": "Ends",
+  "machines.disconnectAllHint.post": "on every connected machine and disconnects them. Can't be undone.",
+  "machines.disconnectAllConfirm": "Disconnect all & end jobs",
+  "machines.keep": "Keep",
+
+  // Row actions.
+  "machines.gripAria": "Reorder machine",
+  "machines.gripTitle": "Drag to reorder this machine — or focus it and use ↑/↓.",
+  "machines.connectAria": "Connect",
+  "machines.connectTitle": "Connect — log in to this machine now.",
+  "machines.reconnectAria": "Reconnect",
+  "machines.reconnectTitle": "Reconnect",
+  "machines.reconnectStaleTitle": "Reconnect — Eldrun still counts a session here, but the machine did not answer the last check.",
+  "machines.retryAria": "Retry",
+  "machines.retryTitle": "Retry — re-enter the SSH password",
+  "machines.hpcLoginAria": "Log in to this cluster now",
+  "machines.hpcLoginTitle": "Log in now. This machine is tagged as a cluster login node, so Eldrun never connects to it on its own — this button is the only thing that does.",
+  "machines.checkAria": "Check this machine",
+  "machines.checkTitle": "Check whether this machine answers, right now. It is a real SSH login, so it happens only when you ask; otherwise the list checks each machine at most once a minute.",
+  "machines.checkTitleHpc": "Check whether this machine answers, right now. It is tagged as a cluster login node, so no automatic check ever touches it — this button is its only reachability.",
+  "machines.disconnectAria": "Disconnect",
+  "machines.disconnectTitle": "Actively disconnect: end every running tmux job on this host and close the SSH connection. Jobs are killed only on this click — never on an Eldrun restart.",
+  "machines.attachAria": "Add this machine to a project",
+  "machines.attachTitle": "Add this machine to one of the open projects — as a compute host on a remote project, or as the primary host of a local one.",
+  "machines.editAria": "Edit machine",
+  "machines.editTitle": "Edit this machine's host, username, password or label.",
+  "machines.removeAria": "Remove machine",
+  "machines.removeTitle": "Remove this machine from the list — actively disconnecting it (and ending its tmux jobs) first if it is connected.",
+  "machines.showDetailsAria": "Show details",
+  "machines.hideDetailsAria": "Hide details",
+  "machines.showDetailsTitle": "Show address, usage & auto-connect",
+  "machines.hideDetailsTitle": "Hide address, usage & auto-connect",
+  "machines.systemMonitor": "System monitor…",
+  "machines.systemMonitorTitle": "Open the full system monitor (CPU, memory, GPU, processes) for this machine.",
+
+  // Per-machine toggles.
+  "machines.autoConnectLabel": "Connect on launch & VPN-up",
+  "machines.autoConnectTitle": "Silently connect this machine on Eldrun launch and whenever a VPN tunnel comes up. Never prompts — it only connects when the host is reachable without a password.",
+  "machines.autoConnectAddTitle": "Silently connect this machine on Eldrun launch and whenever a VPN tunnel comes up. Never prompts — it only connects when the host is reachable without a password, so an armed machine that can't connect silently simply stays off.",
+  "machines.autoBlockedHpc": "— off while tagged HPC",
+  "machines.autoBlockedHpcAdd": "— off for an HPC cluster",
+  "machines.hpcToggleLabel": "HPC cluster (login node)",
+  "machines.hpcToggleTitle": "Tag this machine as a shared cluster login node. Eldrun then reads it lightly (no other user's names or commands), never scans or measures its filesystem by itself, never runs background sync or lockstep polling against it, never checks or connects to it unless you ask, and asks before anything runs in its login-node shell. Tagging it also clears its connect-on-launch.",
+  "machines.hpcAddTitle": "Tag this machine as a shared cluster login node. Eldrun then reads it lightly (never other users' names or command lines), never scans or measures its filesystem by itself, runs no background sync or lockstep polling against it, never checks or connects to it unless you ask, and asks before anything runs in its login-node shell.",
+  "machines.hpcBadgeTitle": "Tagged as a shared cluster login node: read lightly, no disk-usage scan or folder census, no background sync or lockstep polling, no automatic reachability check, no silent auto-connect, and a warning before anything runs in a login-node shell.",
+
+  // Attach-to-a-project picker.
+  "machines.attachQuestionPre": "Add",
+  "machines.attachQuestionPost": "to which project?",
+  "machines.noActiveProject": "No active project.",
+  "machines.attachRemoteTitle": "Add it as a compute host on this remote project.",
+  "machines.attachLocalTitle": "Make it this local project's primary remote host (extend to remote).",
+  "machines.attachKindCompute": "compute host",
+  "machines.attachKindExtend": "extend to remote",
+
+  // Remove / disconnect confirms.
+  "machines.removeHintLive.pre": "Disconnects it first — ending",
+  "machines.removeHintLive.post": "here — then removes it from the list. Projects it was added to keep their own copy.",
+  "machines.removeHintIdle": "Removes this machine from the list. Projects it was added to keep their own copy.",
+  "machines.disconnectHint.pre": "Ends",
+  "machines.disconnectHint.post": "here and disconnects. Can't be undone.",
+  "machines.disconnectConfirm": "Disconnect & end jobs",
+
+  // Add / edit / retry forms.
+  "machines.addGroupLabel": "Add a machine",
+  "machines.addMachine": "Add machine…",
+  "machines.sshAddress": "SSH address",
+  "machines.addressPlaceholder": "[user@]host[:port]",
+  "machines.username": "Username",
+  "machines.usernamePlaceholder": "SSH login user — or include as user@ above",
+  "machines.password": "Password",
+  "machines.addPasswordPlaceholder": "SSH password — leave blank for key auth",
+  "machines.editPasswordPlaceholder": "Leave blank to keep the saved password",
+  "machines.sshUsernamePlaceholder": "SSH username",
+  "machines.sshPasswordPlaceholder": "SSH password",
+  "machines.savePassword": "Save password",
+  "machines.savePasswordTitle": "Save this machine's SSH password in your OS keychain, keyed by host.",
+  "machines.savePasswordTerminalTitle": "A terminal login is one Eldrun never sees, so it stores nothing new — and deletes nothing either. Any saved password for this host stays as it is.",
+  "machines.labelOptional": "Label (optional)",
+  "machines.labelPlaceholder": "e.g. gpu-2",
+  "machines.connecting": "Connecting…",
+  "machines.connectAndAdd": "Connect & add",
+  "machines.saving": "Saving…",
+  "machines.saveChanges": "Save changes",
+  "machines.retry": "Retry",
+  "machines.rootTerminal": "root terminal",
+  "machines.terminalLoginHint.pre": "Log in in the",
+  "machines.terminalLoginHint.post": "— this machine is added by itself once you're through. You can close this menu.",
+  "machines.loginInTerminal": "Log in in terminal",
+  "machines.loginInTerminalTitle": "Open this host's SSH login in the root terminal. Eldrun never sees the password, and adds the machine once the login is through.",
+  "machines.waitingForLogin": "Waiting for the login…",
+  "machines.loggedInAdd": "I've logged in — add",
+  "machines.err.address": "Enter a host as [user@]host[:port]",
+  "machines.err.saveFailed": "Logged in, but the machine couldn't be saved.",
+  "machines.err.noLoginYet": "No login detected yet. Finish logging in in the root terminal, then click “I've logged in — add”.",
+
+  // Import / export.
+  "machines.import": "Import…",
+  "machines.importTitle": "Import machines from a JSON file — connect them all with one shared username & password, then add them to this list.",
+  "machines.export": "Export…",
+  "machines.exportTitle": "Write selected machines to a shareable JSON file (host, port & label only — no credentials).",
+  "machines.exportDialogTitle": "Export machines",
+  "machines.importDialogTitle": "Import machines",
+  "machines.jsonFilter": "Machines JSON",
+  "machines.exportNote": "Choose which machines to write to a shareable JSON file. Only the host, port and label are saved — never a username or password.",
+  "machines.nothingToExport": "No machines to export.",
+  "machines.selectAll": "Select all",
+  "machines.deselectAll": "Deselect all",
+  "machines.selectAllTitle": "Select every machine",
+  "machines.deselectAllTitle": "Deselect every machine",
+  "machines.exportN": "Export {count}…",
+  "machines.readingFile": "Reading file…",
+  "machines.importCountOne": "{count} machine from the file. It will be connected with the username & password below, then added to your list.",
+  "machines.importCountMany": "{count} machines from the file. They'll all be connected with the one username & password below, then added to your list.",
+  "machines.importUserPlaceholder": "Shared SSH user for all imported machines",
+  "machines.importPasswordPlaceholder": "Shared SSH password — leave blank for key auth",
+  "machines.importAutoTitle": "Silently connect every imported machine on Eldrun launch and whenever a VPN tunnel comes up. Never prompts — each host is checked first, so one that needs a password you didn't save simply stays off.",
+  "machines.connectAndImport": "Connect & import",
+  "machines.importedOne": "Added {count} machine.",
+  "machines.importedMany": "Added {count} machines.",
+  "machines.importedOutcome": "{ok} connected, {bad} need attention.",
+  "machines.done": "Done",
+} as const;
+
+/** The key set every component is allowed to translate. */
+export type TranslationKey = keyof typeof en;
+
+type Dict = Partial<Record<TranslationKey, string>>;
+
+const de: Dict = {
+  "common.back": "Zurück",
+  "common.cancel": "Abbrechen",
+  "common.remove": "Entfernen",
+  "common.delete": "Löschen",
+  "common.add": "Hinzufügen",
+  "common.reset": "Zurücksetzen",
+  "common.recheck": "Erneut prüfen",
+  "common.loading": "Wird geladen…",
+  "common.default": "Standard",
+
+  "settings.title": "Einstellungen",
+  "settings.theme": "Design",
+  "settings.language": "Sprache",
+  "settings.language.help":
+    "Legt die Sprache der Eldrun-Oberfläche fest. Wirkt sofort — kein Neustart nötig.",
+  "settings.runScriptsBg": "Skripte im Hintergrund ausführen",
+  "settings.claudeRemote": "Claude-Fernsteuerung",
+  "settings.headlessRemote": "Verbindungen im Hintergrund",
+  "settings.persistLocal": "Persistente lokale Sitzungen (tmux)",
+  "settings.remoteFeatures": "Remote-Funktionen",
+  "settings.vpnEnabled": "OpenVPN-Tunnelsteuerung",
+  "settings.machinesEnabled": "Globale Remote-Maschinen",
+  "settings.energySaver": "Energiesparen",
+  "energy.off": "Aus",
+  "energy.battery": "Im Akkubetrieb",
+  "energy.always": "Immer",
+  "settings.debug": "Debug-Modus",
+  "settings.experimental": "Experimentell",
+  "settings.agentModeToggle": "Plan/Auto-Umschalter für Agenten-Tabs",
+  "settings.pythonRunDebug": "Python Ausführen/Debuggen im Code-Viewer",
+  "settings.resourceMonitor": "Ressourcenmonitor",
+  "settings.showCpu": "CPU-Auslastung anzeigen",
+  "settings.showRam": "RAM-Auslastung anzeigen",
+  "settings.showGpu": "GPU-Auslastung anzeigen",
+  "settings.showClockSeconds": "Sekunden in der Kopfzeilen-Uhr anzeigen",
+
+  "settings.calendar": "Kalender",
+  "settings.weekStartsOn": "Woche beginnt am",
+  "day.sunday": "Sonntag",
+  "day.monday": "Montag",
+  "settings.defaultView": "Standardansicht",
+  "view.day": "Tag",
+  "view.week": "Woche",
+  "view.multiweek": "Mehrere Wochen",
+  "view.month": "Monat",
+  "view.agenda": "Agenda",
+  "view.tasks": "Aufgaben",
+  "settings.clock24": "24-Stunden-Format",
+  "settings.dayGridStart": "Tagesraster beginnt um",
+  "settings.defaultReminder": "Standarderinnerung",
+  "reminder.none": "Keine",
+  "reminder.5": "5 Minuten vorher",
+  "reminder.15": "15 Minuten vorher",
+  "reminder.30": "30 Minuten vorher",
+  "reminder.60": "1 Stunde vorher",
+  "reminder.1440": "1 Tag vorher",
+
+  "settings.hintsOnboarding": "Hinweise & Einführung",
+  "settings.showHints": "Kontextbezogene Hinweise anzeigen",
+  "settings.howToStart": "Erste Schritte...",
+  "settings.takeTour": "Tour starten",
+  "settings.lessons": "Lektionen",
+  "settings.resetHints": "Hinweise zurücksetzen",
+
+  "settings.layout": "Layout",
+  "settings.windowZoom": "Fenster-Zoom",
+  "settings.minSubWidth": "Min. Breite des Unterfensters (px)",
+  "settings.minSubHeight": "Min. Höhe des Unterfensters (px)",
+
+  "settings.downloads": "Downloads",
+  "settings.noDownloadFolders":
+    "Keine Ordner hinzugefügt — der System-Download-Ordner wird verwendet.",
+  "settings.addDownloadFolder": "Download-Ordner hinzufügen...",
+
+  "settings.usageStats": "Nutzungsstatistik",
+  "settings.dailyRecap": "Zusammenfassung zu Beginn jedes Tages anzeigen",
+  "settings.openUsageStats": "Nutzungsstatistik öffnen",
+
+  "settings.moreSettings": "Weitere Einstellungen",
+  "nav.git.title": "Git-Hosting",
+  "nav.git.blurb": "Hosting-Profil, Zugriffstoken und Veröffentlichung.",
+  "nav.vpn.title": "VPN automatisch verbinden",
+  "nav.vpn.blurb": "Einen gespeicherten Tunnel beim Start verbinden.",
+  "nav.remoteHosts.title": "Remote-Verbindungen",
+  "nav.remoteHosts.blurb": "Einen Standardpfad je SSH-Host festlegen.",
+  "nav.global.title": "Globale Apps",
+  "nav.global.blurb": "Toolbar-Starter, die in jedem Projekt angezeigt werden.",
+  "nav.filetypes.title": "Apps nach Dateityp",
+  "nav.filetypes.blurb": "Wählen, welche App jeden Dateityp öffnet.",
+  "nav.agents.title": "Agenten verwalten",
+  "nav.agents.blurb": "Die Agenten-CLIs installieren oder aktualisieren.",
+  "nav.shortcuts.title": "Tastenkürzel",
+  "nav.shortcuts.blurb": "Die Navigationskürzel neu belegen.",
+  "nav.archive.title": "Archivierte Projekte",
+  "nav.archive.blurb": "Archivierte Projekte wiederherstellen oder endgültig löschen.",
+  "nav.scaffoldRepair.title": "Projektgerüst reparieren",
+  "nav.scaffoldRepair.blurb": "Fehlende Gerüstdateien neu erzeugen.",
+  "nav.help.title": "Funktionsübersicht",
+  "nav.help.blurb": "Vollständiges Glossar der Eldrun-Funktionen.",
+  "settings.energyUnavailable": "Energiestatus nicht verfügbar — wird als Netzbetrieb (inaktiv) behandelt.",
+  "settings.energyActiveAlways": "Derzeit aktiv — immer an.",
+  "settings.energyActiveBattery": "Derzeit aktiv — läuft im Akkubetrieb.",
+  "settings.energyOff": "Aus — drosselt nie.",
+  "settings.energyInactive": "Inaktiv — im Netzbetrieb.",
+  "settings.claudeRemoteHelp1": "Startet Claude-Agenten-Tabs mit",
+  "settings.claudeRemoteHelp2": "damit du sie über die Claude-App oder das Web überwachen und steuern kannst. Erfordert eine Claude-Abo-Anmeldung (kein API-Schlüssel); nur Claude unterstützt dies.",
+  "settings.headlessRemoteHelp": "Wenn aktiviert (Standard), stellt Eldrun SSH/OpenVPN-Verbindungen im Hintergrund her und handhabt das Passwort nur vorübergehend. Deaktiviere es, um stattdessen jede Verbindung als interaktives Terminal im Eldrun-Root zu öffnen — du gibst das Passwort direkt in dieses Terminal ein, und Eldrun fasst es nie an.",
+  "settings.persistLocalHelp1": "Wenn aktiviert (Standard), laufen die Shell- und Python-/Skript-Tabs eines lokalen Projekts in einer tmux-Sitzung auf diesem Rechner, sodass ein langer Lauf weitergeht, falls Eldrun abstürzt, und der Tab beim Neustart wieder verbunden wird. Das Schließen eines Tabs beendet dennoch dessen Sitzung. Erfordert",
+  "settings.persistLocalHelp2": "; Agenten-Tabs sind davon nicht betroffen.",
+  "settings.remoteFeaturesHelp": "Beide fügen der Kopfzeile eine rechnerweite Steuerung hinzu: einen OpenVPN-Tunnel (leitet den gesamten Datenverkehr dieses Computers um, solange er aktiv ist) und eine Liste von SSH-Maschinen, die keinem Projekt gehören. Standardmäßig aus; wird beim ersten Start einmal abgefragt.",
+  "settings.energyHelp": "Wenn aktiv, drosselt Eldrun, um Energie zu sparen: Es pausiert das Leerlauf-Drehen des Projekt-Blobs, beruhigt die Status-Leuchten und verlangsamt Hintergrundaktualisierungen. „Im Akkubetrieb“ (Standard) tut dies nur, solange kein Netzstecker steckt.",
+  "settings.experimentalHelp1": "Funktionen, die sich noch verändern. Jede ist standardmäßig aus und",
+  "settings.experimentalHelpBold": "im Debug-Modus standardmäßig an",
+  "settings.experimentalHelp2": "— wer Eldrun baut, sieht sie also, ohne diese Liste jedes Mal neu abzuhaken, wenn eine neue hinzukommt. Ein Schalter hier gewinnt immer, in beide Richtungen: Du kannst eine ohne Debug-Modus aktivieren oder eine darin deaktivieren.",
+  "settings.agentModeHelp1": "Setzt auf jeden Agenten-Tab ein Abzeichen, das ihn umschaltet zwischen",
+  "settings.agentModeHelp2": "(liest und schlägt vor, bearbeitet nie) und",
+  "settings.agentModeHelp3": "(akzeptiert Änderungen automatisch; Shell- und Netzwerkbefehle fragen weiterhin nach) — so kann ein Tab planen, während ein anderer die Arbeit erledigt, und jeder kehrt nach einem Neustart in seinem Modus zurück. Das Umschalten startet den Agenten neu: Das Gespräch wird fortgesetzt, aber der Terminal-Verlauf geht verloren. Nur Claude unterstützt dies — es ist der einzige Agent, der sowohl in einem Modus gestartet werden als auch sein Gespräch beim Neustart fortsetzen kann.",
+  "settings.pythonRunHelp1": "Gibt einer",
+  "settings.pythonRunHelp2": "im Editor geöffneten Datei einen",
+  "settings.pythonRunHelp3": "und einen",
+  "settings.pythonRunHelp4": "Button und verwandelt ihre Zeilennummern in eine Haltepunkt-Randleiste. Beide öffnen einen Terminal-Tab im Projekt — sie laufen also auf dem Host eines Remote-Projekts und im Container eines containerisierten — und verwenden den eigenen Interpreter des Projekts. Debug ist",
+  "settings.pythonRunHelp5": ", vorgeladen mit den Haltepunkten der Randleiste. Standardmäßig aus, weil Run die Datei ausführt. Strg+Klick auf eine Definition ist nicht gesperrt: Es liest nur.",
+  "settings.resourceMonitorHelp": "CPU und RAM decken den eigenen Prozessbaum von Eldrun ab; GPU zeigt den von in Ollama geladenen lokalen Modellen genutzten VRAM. Die Pille erscheint in der Kopfzeile neben dem Timer.",
+  "settings.reminderHelp": "Erinnerungen erscheinen als Desktop-Benachrichtigung und als In-App-Popup, das du snoozen kannst. „Tagesraster beginnt um“ legt nur fest, wohin die Tages- und Wochenansicht scrollt — frühere Termine sind weiterhin da, nur oberhalb der Ansicht.",
+  "settings.zoomHelp1": "Der Fenster-Zoom skaliert die gesamte Eldrun-Oberfläche — praktisch bei 4K-/High-DPI-Monitoren. 100 % ist Standard. Der Zoom ist",
+  "settings.zoomHelpBold": "pro Fenster",
+  "settings.zoomHelp2": ": Dies stellt das Hauptfenster ein, und jedes ausgeklinkte Unterfenster behält seinen eigenen Wert. Strg + / Strg − zoomen das fokussierte Fenster, Strg 0 setzt es zurück.",
+  "settings.minSubwindowHelp": "Kleinste Größe, auf die ein Unterfenster durch Ziehen einer Trennlinie verkleinert werden kann. Standardmäßig {px}px, wenn leer gelassen.",
+  "settings.downloadsHelp": "Ordner, die vom Downloads-Abschnitt des rechten Panels (der 📥-Schalter) durchsucht werden, um frisch heruntergeladene Dateien schnell in ein Projekt zu kopieren. Nur lesend — Eldrun ändert nie den Download-Pfad eines Browsers. Standardmäßig der System-Download-Ordner, wenn leer.",
+  "settings.removeFolderTitle": "Diesen Ordner entfernen",
+  "settings.dailyRecapHelp": "Eine Zusammenfassung des gerade beendeten Tages: welche Agenten du benutzt hast und wie viel du sie gefragt hast, erstellte/geänderte/gelöschte Dateien, Commits und Zeit pro Projekt. Dies auszuschalten stoppt das Popup, nicht die Zählung — alles bleibt lokal.",
+
+  "shortcuts.help":
+    "Klicke ein Tastenkürzel und drücke dann die neue Tastenkombination. F11 (System-Vollbild) und Escape (Vollbild beenden) sind fest und können nicht geändert werden.",
+  "shortcuts.captureTitle": "Klicken, dann eine Tastenkombination drücken",
+  "shortcuts.pressKeys": "Tasten drücken…",
+  "shortcuts.resetTitle": "Auf Standard zurücksetzen",
+
+  "git.help":
+    "Dein Hosting-Profil und Zugriffstoken werden verwendet, wenn das Repo eines Projekts auf GitHub oder GitLab veröffentlicht wird.",
+  "git.profileUrl": "Profil-URL",
+  "git.profileUrlPlaceholder": "https://github.com/me oder https://gitlab.com/me",
+  "git.accessToken": "Zugriffstoken",
+  "git.tokenPlaceholder": "ghp_... / glpat-...",
+
+  "vpn.autoConnectHelp":
+    "Bewaffnet einen gespeicherten OpenVPN-Tunnel, damit er beim Start von Eldrun automatisch aufgebaut wird. Er leitet den gesamten Datenverkehr dieses Computers um — nicht nur den von Eldrun —, solange er aktiv ist; daher kann nur eine Konfiguration gleichzeitig aktiviert sein, eine andere zu aktivieren deaktiviert die erste. Gespeicherte Konfigurationen werden über den Connect-Dialog eines Remote-Projekts oder das VPN-Menü in der Kopfzeile hinzugefügt.",
+  "vpn.noConfig": "Noch keine OpenVPN-Konfiguration gespeichert. Füge eine über den Connect-Dialog eines Remote-Projekts hinzu.",
+  "vpn.needsSavedPre": "Einmal verbinden mit aktiviertem",
+  "vpn.needsSavedBold": "Passphrase speichern",
+  "vpn.needsSavedPost": "um dies zu aktivieren — Auto-Connect fragt nie nach.",
+  "vpn.startsWithEldrun": "Startet mit Eldrun",
+  "vpn.waitsInRootTerminal": "(wartet im Root-Terminal)",
+
+  "archive.help":
+    "Gelöschte Projekte werden hier aufbewahrt, damit du sie wiederherstellen kannst. Endgültiges Löschen entfernt die archivierte Kopie und ihre Zeiterfassungshistorie. Die Dateien eines Remote-(SSH-)Projekts auf seinem Host werden nie angefasst.",
+  "archive.empty": "Keine archivierten Projekte.",
+  "archive.remoteTag": "remote",
+  "archive.unsyncedVerifiedOne":
+    "{count} lokaler Commit auf {branches} wurde nie mit dem Host synchronisiert und geht verloren. Die Dateien des Hosts selbst sind nicht betroffen.",
+  "archive.unsyncedVerifiedMany":
+    "{count} lokale Commits auf {branches} wurden nie mit dem Host synchronisiert und gehen verloren. Die Dateien des Hosts selbst sind nicht betroffen.",
+  "archive.unsyncedUnverifiedOne":
+    "Dieser Spiegel enthält {count} Commit, der nicht gegen den Host verifiziert werden konnte; Löschen verwirft die lokale Kopie. Die Dateien des Hosts selbst sind nicht betroffen.",
+  "archive.unsyncedUnverifiedMany":
+    "Dieser Spiegel enthält {count} Commits, die nicht gegen den Host verifiziert werden konnten; Löschen verwirft die lokale Kopie. Die Dateien des Hosts selbst sind nicht betroffen.",
+  "archive.typeToDelete": "„{name}“ eingeben, um zu löschen",
+  "archive.deleteForever": "Endgültig löschen",
+  "archive.deleting": "Wird gelöscht…",
+  "archive.restore": "Wiederherstellen",
+  "archive.restoring": "Wird wiederhergestellt…",
+  "archive.deletePermanently": "Endgültig löschen…",
+  "archive.typeDeleteAll": "„delete“ eingeben, um alle zu löschen",
+  "archive.clearArchive": "Archiv leeren",
+  "archive.clearing": "Wird geleert…",
+  "archive.clearArchiveEllipsis": "Archiv leeren…",
+
+  "scaffoldRepair.help":
+    "Ergänzt jede Gerüstdatei (AGENTS.md, CLAUDE.md, .claude/settings.json, …) oder Standard-.gitignore-Zeile, die einem Projekt fehlt — z. B. weil es erstellt wurde, bevor diese Datei/Zeile zum Standardgerüst hinzugefügt wurde. Vorhandene Dateien werden nie überschrieben; eine bereits bestehende .gitignore bekommt nur fehlende Standardzeilen angehängt. Läuft über jedes verwaltete Projekt (lokaler Ordner oder, bei Remote-Projekten, dessen lokaler Spiegel).",
+  "scaffoldRepair.runNow": "Alle Projekte jetzt reparieren",
+  "scaffoldRepair.running": "Wird repariert…",
+  "scaffoldRepair.upToDate": "Das Gerüst jedes Projekts ist bereits aktuell.",
+
+  "help.title": "Eldrun-Hilfe",
+  "help.intro": "Ein kurzer Überblick, was jeder Teil von Eldrun tut. Toolbar-Schaltflächen zeigen ihre Tastenkürzel per Hover.",
+  "help.workspaceLayout.title": "Arbeitsbereich-Layout",
+  "help.workspaceLayout.introMac":
+    "Eldrun hält deine KI-unterstützte Entwicklung in einem einzigen Fenster. Bewege den Mauszeiger an einen Bildschirmrand, um die Panels einzublenden, und drücke F11 für Vollbild.",
+  "help.workspaceLayout.introOther":
+    "Eldrun hält deine KI-unterstützte Entwicklung in einem einzigen Fenster. Drücke {key}, während Eldrun fokussiert ist, um die Panels umzuschalten, und F11 für Vollbild.",
+  "help.workspaceLayout.item1.term": "Root-Terminal (▣)",
+  "help.workspaceLayout.item1.desc":
+    "Das Kontrollterminal, das immer im Root-Ordner von Eldrun liegt, unabhängig von jedem Projekt.",
+  "help.workspaceLayout.item2.term": "Projekt-Pills",
+  "help.workspaceLayout.item2.desc":
+    "Eine Pille pro aktivem Projekt im Projekt-Umschalter. Klicken zum Wechseln; jedes Projekt behält sein eigenes Terminal und seine Tabs. Pillen per Drag neu anordnen.",
+  "help.workspaceLayout.item3.term": "Mittleres Panel & Tabs",
+  "help.workspaceLayout.item3.desc":
+    "Die Terminals des aktiven Projekts. Rechtsklick auf die Tab-Leiste, um einen Claude/Codex/Gemini-Agenten oder eine einfache Shell hinzuzufügen, umzubenennen oder Tabs zu schließen. Tabs per Drag neu anordnen.",
+  "help.workspaceLayout.item4.term": "Rechtes Dateipanel",
+  "help.workspaceLayout.item4.desc":
+    "Eine Datei-Baum-Überlagerung für das aktive Projekt. Dateien öffnen, umbenennen und versteckte Dateitypen umschalten. Das Panel merkt sich pro Projekt den letzten Ordner.",
+  "help.projects.title": "Projekte",
+  "help.projects.item1.term": "Hinzufügen (+)",
+  "help.projects.item1.desc":
+    "Ein neues Projekt erstellen (legt Dateien und ein Git-Repo im Projektordner von Eldrun an) oder einen vorhandenen Ordner importieren, ohne dessen Inhalt zu verändern.",
+  "help.projects.item2.term": "Inaktive suchen",
+  "help.projects.item2.desc":
+    "Das Suchfeld findet Projekte, die gerade nicht geöffnet sind; eines auswählen, um seine Pille und sein Terminal zu aktivieren.",
+  "help.projects.item3.term": "Remote-(SSH-)Projekte",
+  "help.projects.item3.desc":
+    "Projekte auf einem entfernten Host werden lokal per sshfs eingebunden und verhalten sich wie jedes andere Projekt. Erfordert installiertes sshfs/FUSE.",
+  "help.projects.item4.term": "Aufgaben",
+  "help.projects.item4.desc":
+    "Rechtsklick auf einen Tab, um eine Agentenaufgabe zu setzen, abzuschließen oder zu löschen. Aufgaben bleiben in der project.json des Projekts erhalten und können den Prompt eines neuen Agenten vorbelegen.",
+  "help.aiTerminals.title": "KI & Terminals",
+  "help.aiTerminals.item1.term": "Agenten",
+  "help.aiTerminals.item1.desc":
+    "Einen Agenten (claude, codex, gemini, vibe, aider, opencode, cursor, copilot, grok, qwen, openclaw) oder eine einfache Shell über das +-Menü der Tab-Leiste öffnen. Fehlende Befehle fallen auf eine Shell zurück; geschlossene Agenten starten neu.",
+  "help.aiTerminals.item2.term": "Ollama-Modelle",
+  "help.aiTerminals.item2.desc":
+    "Wenn Ollama installiert ist, zeigt das Zahnrad-Menü lokale Modelle. Strg+K öffnet den Lokales-Modell-Prompt-Dialog für den aktiven Kontext.",
+  "help.settingsExtras.title": "Einstellungen & Extras",
+  "help.settingsExtras.item1.term": "Einstellungen (⚙)",
+  "help.settingsExtras.item1.desc":
+    "Design, Git-Hosting-Profil/Token, Arbeitsbereichsverwaltung, Hintergrundskripte und Debug-Modus.",
+  "help.settingsExtras.item2.term": "Arbeitsbereichsintegration",
+  "help.settingsExtras.item2.desc":
+    "Projektweise KDE/X11-Desktop-Isolation (nur Linux): Die gestarteten Fenster jedes Projekts landen auf ihrem eigenen virtuellen Desktop.",
+  "help.settingsExtras.item3.term": "Zeiterfassung",
+  "help.settingsExtras.item3.desc":
+    "Eldrun zeichnet aktive Sitzungszeit auf, damit du siehst, wie viel Zeit du pro Projekt verbringst.",
+
+  "globalApps.title": "Globale Apps",
+  "globalApps.help": "Apps, die über alle Arbeitsbereiche sichtbar bleiben. Angehakte Apps erscheinen in der oberen Toolbar.",
+  "globalApps.showRole": "{role} anzeigen",
+  "globalApps.notFoundPlaceholder": "nicht gefunden",
+
+  "filetypes.title": "Apps nach Dateityp",
+  "filetypes.help": "Ein Doppelklick auf eine Projektdatei öffnet sie mit der unten angegebenen App.",
+  "filetypes.extPlaceholder": ".endung",
+  "filetypes.appPlaceholder": "App-Befehl",
+
+  "remoteHosts.help":
+    "Der Ordner, in dem ein Connect oder Browse für einen SSH-Host öffnet, statt im Home-Verzeichnis des Hosts. Einmal hier festgelegt, gilt es beim nächsten Verbinden zu diesem Host — für den Ordner-Browser eines neuen Remote-Projekts und beim erneuten Verbinden eines bestehenden.",
+  "remoteHosts.empty": "Keine Standardpfade gesetzt — Hosts verwenden standardmäßig ihr Home-Verzeichnis.",
+  "remoteHosts.hostPlaceholder": "Host",
+  "remoteHosts.pathPlaceholder": "/pfad/auf/dem/host",
+
+  "agents.help1":
+    "KI-Coding-Agenten, die Eldrun als Agenten-Tabs starten kann. Einen mit einem Klick installieren (keine Administratorrechte nötig), dann über das",
+  "agents.help2": "-Menü einer Tab-Leiste hinzufügen. Viele Installer brauchen",
+  "agents.help3": "in deinem",
+  "agents.help4": "— falls es fehlt, installiere zuerst Node.js weiter unten.",
+  "agents.checkingInstalled": "Installierte Agenten werden geprüft…",
+  "agents.installed": "installiert",
+  "agents.notInstalled": "nicht installiert",
+  "agents.disableToggleTitle":
+    "Diesen Agenten aus den Tab-Auswahlmenüs ausblenden (Agenten-Liste beim Tab-Hinzufügen, Lokales-Modell-Treiber), ohne ihn zu deinstallieren",
+  "agents.disableAriaEnable": "{label} in Tab-Menüs aktivieren",
+  "agents.disableAriaDisable": "{label} in Tab-Menüs deaktivieren",
+  "agents.disabled": "Deaktiviert",
+  "agents.enabled": "Aktiviert",
+  "agents.removeTitle": "Die installierte CLI entfernen",
+  "agents.removing": "Wird entfernt…",
+  "agents.remove": "Entfernen",
+  "agents.reinstallTitle": "Entfernen und den offiziellen Installer erneut ausführen",
+  "agents.reinstalling": "Wird neu installiert…",
+  "agents.reinstall": "Neu installieren",
+  "agents.permissionHelpPre": "Falls Entfernen mit einem Berechtigungsfehler fehlschlägt, führe es stattdessen in einem",
+  "agents.permissionHelpPost": "Terminal-Tab aus (füge",
+  "agents.permissionHelpPost2": "hinzu, falls nachgefragt):",
+  "agents.runInTerminal": "Im Terminal ausführen",
+  "agents.installing": "Wird installiert…",
+  "agents.installLabel": "{label} installieren",
+  "agents.runningInstaller": "Installer läuft…",
+  "agents.orInstallInShellPre": "Oder installiere es in einem",
+  "agents.orInstallInShellPost": "Terminal-Tab:",
+  "agents.noWindowsInstallerPre": "Noch kein Ein-Zeilen-Installer für Windows — siehe",
+  "agents.installDocs": "die Installationsanleitung",
+  "agents.noWindowsInstallerPost": ", dann klicke",
+  "agents.stillNotDetected": "Immer noch nicht erkannt — versuche ein frisches Terminal, damit der Installationsordner im PATH liegt.",
+  "agents.codexHookLabel": "Sitzungs-Hook",
+  "agents.codexHookDisabled": "deaktiviert",
+  "agents.codexHookNotTrusted": "nicht vertrauenswürdig",
+  "agents.codexHookHelpPre":
+    "Codex führt Eldruns Sitzungs-Hook erst aus, wenn du ihm vertraust; bis dahin ermittelt Eldrun anhand von Codex' eigenen Protokollen, welches Gespräch zu welchem Tab gehört. Das funktioniert, kann aber zwei im selben Ordner geöffnete Codex-Tabs verwechseln. Aktiviere",
+  "agents.codexHookHelpPost": "in Codex'",
+  "agents.codexHookHelpPost2": "-Liste für exaktes Fortsetzen:",
+  "agents.openInCodex": "In Codex öffnen",
+  "agents.nodeNotDetected": "nicht erkannt",
+  "agents.nodeHelpPre": "Die meisten Agenten-CLIs installieren mit",
+  "agents.nodeHelpMid": ", das mit Node.js kommt. Installiere es einmal (keine Administratorrechte nötig) in einem",
+  "agents.nodeHelpPost": "Terminal-Tab und installiere danach deine Agenten unten:",
+  "agents.nodeManualPre": "Lieber manuell installieren? Siehe",
+  "agents.nodeDownloads": "die Node.js-Downloads",
+
+  "ollama.vibeTitle": "Lokale Modell-Laufzeit (Vibe)",
+  "ollama.vibeChecking": "Vibe wird geprüft…",
+  "ollama.vibeInstalled": "Vibe ist installiert — lokale Modelle können als Agenten-Tabs starten.",
+  "ollama.vibeMissing1": "Lokale Ollama-Modelle laufen über Mistrals",
+  "ollama.vibeMissing2":
+    "-CLI. Sie ist noch nicht installiert, daher schlägt ein Lokales-Modell-Tab mit „unable to spawn vibe“ fehl. Einmal installieren (keine Administratorrechte nötig), dann starten lokale Modelle.",
+  "ollama.installVibe": "Vibe installieren",
+  "ollama.installingEllipsis": "Wird installiert…",
+  "ollama.runningInstaller": "Installer läuft…",
+  "ollama.startingEllipsis": "Startet…",
+  "ollama.orInstallInShellPre": "Oder installiere es in einem",
+  "ollama.orInstallInShellPost": "Tab:",
+  "ollama.runInTerminal": "Im Terminal ausführen",
+  "ollama.vibeStillNotDetectedWindows":
+    "Vibe wird immer noch nicht erkannt (öffne ein frisches Terminal, damit der Installationsort im PATH liegt).",
+  "ollama.vibeStillNotDetectedOther":
+    "Vibe wird immer noch nicht erkannt (versuche ein frisches Terminal, damit ~/.local/bin im PATH liegt).",
+  "ollama.installTitle": "Ollama installieren",
+  "ollama.notInstalledHelp":
+    "Ollama betreibt offene Modelle lokal auf deinem Rechner. Es ist noch nicht installiert. Einmal installieren, und Eldrun listet die herunterladbaren Modelle direkt hier auf.",
+  "ollama.automaticInstall": "Automatische Installation",
+  "ollama.autoInstallHelpWindows":
+    "Installiert Ollama mit winget (still, pro Benutzer). winget ist auf Windows 10/11 vorinstalliert; falls es fehlt oder die Installation fehlschlägt, folge den manuellen Schritten unten.",
+  "ollama.autoInstallHelpOther":
+    "Führt das offizielle Installationsskript aus. Es braucht Administratorrechte, um den ollama-Dienst hinzuzufügen; das funktioniert ohne Nachfrage nur, wenn dein Konto passwortloses sudo hat. Falls es fehlschlägt, folge den manuellen Schritten unten.",
+  "ollama.installBtn": "Ollama installieren",
+  "ollama.installInTerminalTitle": "Im Terminal installieren",
+  "ollama.runInstallerNewPre": "Führe den Installer für dein System in einem neuen",
+  "ollama.runInstallerNewPost": "Tab aus:",
+  "ollama.alsoDownloadFrom": "Du kannst den Installer auch direkt herunterladen von",
+  "ollama.approveUacPrompt": "Bestätige die Benutzerkontensteuerung, falls Windows fragt.",
+  "ollama.enterPasswordSudo": "Gib dein Passwort ein, falls der Installer nach sudo fragt.",
+  "ollama.onceFinishedClickPre": "Sobald es fertig ist, klicke",
+  "ollama.onceFinishedClickPost": "unten — die installierbaren Modelle erscheinen automatisch.",
+  "ollama.stillNotDetected": "Ollama wird immer noch nicht erkannt.",
+  "ollama.modelsTitle": "Ollama-Modelle",
+  "ollama.checkingEllipsis": "Wird geprüft...",
+  "ollama.serverRunningLabel": "Server läuft · {label}",
+  "ollama.serverNotRunning": "Server läuft nicht",
+  "ollama.noModelLoaded": "Kein Modell geladen",
+  "ollama.noLoadedModel": "Kein geladenes Modell",
+  "ollama.loadedModels": "Geladen: {names}",
+  "ollama.start": "Starten",
+  "ollama.refresh": "Aktualisieren",
+  "ollama.downloadingTitle": "Wird heruntergeladen",
+  "ollama.pauseTitle": "Diesen Download pausieren (später fortsetzen)",
+  "ollama.pause": "Pausieren",
+  "ollama.downloadPaused": "Download pausiert — fortsetzen, um ihn abzuschließen, oder die Teildaten löschen.",
+  "ollama.resume": "Fortsetzen",
+  "ollama.deletePartialTitle": "Den unvollständigen Download löschen, um Speicherplatz freizugeben",
+  "ollama.delete": "Löschen",
+  "ollama.downloadInterrupted": "Download wurde unterbrochen — fortsetzen, um ihn abzuschließen.",
+  "ollama.continueDownload": "Download fortsetzen",
+  "ollama.dismissTitle": "Diesen unterbrochenen Download verwerfen",
+  "ollama.dismiss": "Verwerfen",
+  "ollama.orphansSummaryOne":
+    "{count} verwaiste Teilschicht ({size}) — unterbrochene Downloads ohne wiederherstellbaren Modellnamen. Das Modell erneut ziehen, um fortzusetzen, oder löschen, um Speicherplatz freizugeben.",
+  "ollama.orphansSummaryMany":
+    "{count} verwaiste Teilschichten ({size}) — unterbrochene Downloads ohne wiederherstellbaren Modellnamen. Das Modell erneut ziehen, um fortzusetzen, oder löschen, um Speicherplatz freizugeben.",
+  "ollama.orphanLayer": "Schicht {digest}…",
+  "ollama.deleteLayerTitle": "Diese Teilschicht löschen, um Speicherplatz freizugeben",
+  "ollama.downloadedModelsTitle": "Heruntergeladene Modelle",
+  "ollama.noModelsDownloaded": "Keine Modelle heruntergeladen",
+  "ollama.unloadTitle": "Aus dem Speicher entladen",
+  "ollama.unload": "Entladen",
+  "ollama.loadTitle": "Jetzt in den Speicher laden und resident halten",
+  "ollama.load": "Laden",
+  "ollama.loading": "Wird geladen…",
+  "ollama.updateTitle": "Auf Updates prüfen und die neueste Version herunterladen",
+  "ollama.update": "Aktualisieren",
+  "ollama.updating": "Wird aktualisiert…",
+  "ollama.deleteModelTitle": "Dieses Modell löschen",
+  "ollama.loadingIntoMemoryTitle": "Wird in den Speicher geladen…",
+  "ollama.loadingIntoMemory": "Wird in den Speicher geladen…",
+  "ollama.browseRegistry": "Die Ollama-Registry durchsuchen",
+  "ollama.pullHelp1": "Ein beliebiges Modell aus der Ollama-Registry ziehen. Eine exakte Referenz eingeben, um direkt zu ziehen, oder unten die vollständige Liste durchsuchen und filtern. Eine vollständige Referenz wie",
+  "ollama.pullHelp2": "oder",
+  "ollama.pullPlaceholder": "Modellname oder namespace/model:tag",
+  "ollama.pull": "Ziehen",
+  "ollama.pulling": "Wird gezogen…",
+  "ollama.searchPlaceholder": "Alle Modelle nach Name oder Beschreibung durchsuchen…",
+  "ollama.sortBy": "Sortieren nach",
+  "ollama.sort.popular": "Am beliebtesten",
+  "ollama.sort.newest": "Neueste",
+  "ollama.sort.pulls": "Meiste Downloads",
+  "ollama.sort.name": "Name (A–Z)",
+  "ollama.sort.sizeAsc": "Größe: klein → groß",
+  "ollama.sort.sizeDesc": "Größe: groß → klein",
+  "ollama.filterType": "Typ",
+  "ollama.filterParams": "Parameter",
+  "ollama.any": "Alle",
+  "ollama.cap.tools": "Tools",
+  "ollama.cap.vision": "Vision",
+  "ollama.cap.thinking": "Denken",
+  "ollama.cap.embedding": "Embedding",
+  "ollama.cap.audio": "Audio",
+  "ollama.pullsSuffix": "{pulls} Downloads",
+  "ollama.tagUpdateTitle": "{name}{size} aktualisieren",
+  "ollama.tagDownloadTitle": "{name}{size} herunterladen",
+  "ollama.sizeLoadingSuffix": " — Größe…",
+  "ollama.pullLower": "ziehen",
+  "ollama.noModelsFound": "Keine Modelle gefunden",
+  "ollama.noMatchSizeFilter":
+    "Keine geladenen Modelle entsprechen der gewählten Größe — mehr laden oder den Parameter-Filter zurücksetzen",
+  "ollama.endOfResults": "Ende der Ergebnisse",
+  "ollama.pausedBadge": "pausiert",
+  "ollama.interruptedBadge": "unterbrochen",
+  "globalAppMenu.title": "Globale Apps",
+  "howToStart.title": "Willkommen bei Eldrun",
+  "howToStart.intro": "Eldrun hält deine KI-unterstützte Entwicklung in einem Fenster. So legst du los:",
+  "howToStart.openFeatureGuide": "Funktionsübersicht öffnen...",
+  "howToStart.takeTour": "Tour starten",
+  "howToStart.lessons": "Lektionen",
+  "howToStart.gotIt": "Verstanden",
+  "remoteFeatures.title": "Nutzt du VPN oder Remote-Maschinen?",
+  "remoteFeatures.help": "Eldrun kann einen OpenVPN-Tunnel steuern und dich mit SSH-Maschinen verbinden, auf denen du kein Projekt hast, beides von der Kopfzeile aus. Beides ist standardmäßig aus — schalte ein, was du brauchst. Beides lässt sich jederzeit über die Einstellungen umschalten.",
+  "remoteFeatures.continue": "Weiter",
+  "lessons.title": "Lektionen",
+  "lessons.intro": "Kurze geführte Rundgänge zu häufigen Aufgaben. Wähle eine aus — sie zeigt dir alles Schritt für Schritt.",
+  "globalApp.role.browser": "Browser",
+  "globalApp.role.mail": "Mail",
+  "globalApp.role.calendar": "Kalender",
+  "globalApp.role.print_manager": "Druckverwaltung",
+  "globalApp.role.file_manager": "Dateimanager",
+  "globalApp.role.password_manager": "Passwort-Manager",
+  "globalApp.role.video_conf": "Videokonferenz",
+  "globalApp.role.media_player": "Medienplayer",
+  "globalApp.role.system_monitor": "Systemmonitor",
+  "globalApp.role.notes": "Notizen",
+  "globalApp.role.screenshot": "Bildschirmfoto",
+  "globalApp.role.screen_recorder": "Bildschirmrekorder",
+  "globalApp.role.chat": "Chat",
+  "globalApp.rightClickConfigure": "Rechtsklick zum Konfigurieren",
+  "globalApp.noCommandConfigured": "Kein Befehl konfiguriert",
+  "globalApp.clear": "Leeren",
+  "globalApp.set": "Setzen",
+  "header.dragToMove": "Ziehen, um das Eldrun-Fenster zu verschieben",
+  "header.rootTerminal": "Root-Terminal",
+  "rightPanel.resizeTitle": "Ziehen, um das Panel zu skalieren",
+  "rightPanel.moveRight": "Panel an den rechten Rand verschieben",
+  "rightPanel.moveLeft": "Panel an den linken Rand verschieben",
+  "rightPanel.unpinTitle": "Panel lösen (automatisches Ausblenden erlauben)",
+  "rightPanel.pinTitle": "Panel offen anheften",
+  "rightPanel.showHidden": "Versteckte Unterfenster anzeigen",
+  "rightPanel.collapse": "Einklappen",
+  "rightPanel.hiddenCount": "Versteckt ({count})",
+  "rightPanel.hiddenWaiting": "Ein verstecktes Unterfenster wartet auf dich",
+  "rightPanel.hiddenWorking": "Ein verstecktes Unterfenster arbeitet",
+  "rightPanel.hiddenFinished": "Ein verstecktes Unterfenster ist fertig, ungesehen",
+  "rightPanel.restoreFocusedOn": "Wiederherstellen, fokussiert auf „{label}“",
+  "rightPanel.restoreSubwindow": "Unterfenster wiederherstellen",
+  "rightPanel.closeSubwindow": "Unterfenster schließen (Tabs verwerfen)",
+  "vpnPrompt.titleConnected": "VPN verbunden",
+  "vpnPrompt.titlePassword": "VPN-Passwort",
+  "vpnPrompt.close": "Schließen",
+  "vpnPrompt.closeTitleConnected": "Schließen — der Tunnel bleibt bestehen.",
+  "vpnPrompt.closeTitleConnecting": "Tunnelaufbau abbrechen und schließen — ein halb offener Tunnel wird abgebaut.",
+  "vpnPrompt.closeTitleDefault": "Schließen, ohne zu verbinden.",
+  "vpnPrompt.upFor": "OpenVPN ist verbunden für",
+  "vpnPrompt.connectingFor": "OpenVPN wird verbunden für",
+  "vpnPrompt.trafficScope": "Solange der Tunnel aktiv ist, läuft der Datenverkehr dieses Computers darüber — auch dein Browser, nicht nur Eldrun.",
+  "vpnPrompt.username": "Benutzername",
+  "vpnPrompt.usernamePlaceholder": "OpenVPN-Kontobenutzername…",
+  "vpnPrompt.password": "Passwort",
+  "vpnPrompt.passphrase": "Passphrase",
+  "vpnPrompt.savedInKeychain": "(im Schlüsselbund des Betriebssystems gespeichert)",
+  "vpnPrompt.notStored": "(nicht gespeichert)",
+  "vpnPrompt.keyPassphraseLabel": "Passphrase des privaten Schlüssels",
+  "vpnPrompt.keyPassphrasePlaceholder": "Passphrase für den verschlüsselten Schlüssel der Konfiguration…",
+  "vpnPrompt.keyPassphraseHint": "Der private Schlüssel dieser Konfiguration ist verschlüsselt, daher fragt OpenVPN dessen Passphrase getrennt vom Kontopasswort ab.",
+  "vpnPrompt.saveVpnCredentials": "VPN-Zugangsdaten speichern",
+  "vpnPrompt.savePassphrase": "Passphrase speichern",
+  "vpnPrompt.storedSecurely": "sicher im Schlüsselbund deines Betriebssystems gespeichert",
+  "vpnPrompt.tunnelUp": "Tunnel aktiv — der Datenverkehr dieses Computers läuft nun darüber.",
+  "vpnPrompt.challengeHintPre": "Falls diese Konfiguration nach etwas fragt, das diese Felder nicht beantworten können — ein Challenge-Code oder eine eigene Abfrage — nutze",
+  "vpnPrompt.logInTerminal": "Im Terminal anmelden",
+  "vpnPrompt.challengeHintPost": "unten: OpenVPN fragt dort direkt nach, und Eldrun sieht nie, was du eingibst.",
+  "vpnPrompt.closeStaysUpTitle": "Schließen — der Tunnel bleibt bestehen. Beende ihn über die VPN-Anzeige in der Kopfzeile.",
+  "vpnPrompt.terminalBtnStopFirst": "Beende zuerst den aktuellen Versuch, melde dich dann im Terminal an.",
+  "vpnPrompt.terminalBtnHandoff": "Übergibt diese Verbindung an einen Root-Terminal-Tab, in dem du dich anmeldest — OpenVPN fragt dort selbst nach Passwort (und Challenge-Code), und Eldrun sieht es nie. Nur für diese Verbindung; deine Headless-Einstellung bleibt unverändert.",
+  "vpnPrompt.cancelTitleConnecting": "Tunnelaufbau abbrechen und dies schließen — ein halb offener Tunnel wird abgebaut.",
+  "vpnPrompt.stop": "Stopp",
+  "vpnPrompt.connectTitleConnecting": "OpenVPN-Tunnel wird aufgebaut — pkexec fragt eventuell nach erhöhten Rechten…",
+  "vpnPrompt.connectTitleError": "Verbindung fehlgeschlagen — Passphrase prüfen und erneut versuchen.",
+  "vpnPrompt.connectTitleDefault": "OpenVPN-Tunnel aufbauen.",
+  "vpnPrompt.connecting": "Wird verbunden…",
+  "vpnPrompt.retry": "Erneut versuchen",
+  "vpnPrompt.connect": "Verbinden",
+  "projectSwitcher.howToStartMenu": "Erste Schritte",
+  "projectSwitcher.scrollLeft": "Projekte nach links scrollen",
+  "projectSwitcher.scrollRight": "Projekte nach rechts scrollen",
+  "projectSwitcher.addOrImport": "Projekt hinzufügen oder importieren",
+  "projectSwitcher.newProject": "Neues Projekt",
+  "projectSwitcher.importProject": "Projekt importieren",
+  "projectSwitcher.importFromGitHub": "Von GitHub/GitLab importieren",
+  "projectSwitcher.hpcPipeline": "HPC-Pipeline…",
+  "projectSwitcher.newBox": "Neue Box",
+  "localModel.role.autocomplete": "Autovervollständigung",
+  "localModel.role.grammar": "Grammatik",
+  "localModel.role.tabs": "Tabs",
+  "localModel.installTitle": "Ein lokales Modell installieren",
+  "localModel.runningLoaded": "Ollama läuft · Modell geladen",
+  "localModel.running": "Ollama läuft",
+  "localModel.stopped": "Ollama gestoppt",
+  "localModel.modelSuffix": " · Modell: {name}",
+  "localModel.noModelSelected": " · kein Modell ausgewählt",
+  "localModel.ariaLabel": "Lokales Modell",
+  "localModel.agentsGroup": "Agenten",
+  "localModel.agentInstalled": "{label} installiert",
+  "localModel.manageAgents": "Agenten verwalten…",
+  "localModel.localModelsGroup": "Lokale Modelle",
+  "localModel.downloadingTitle": "Wird heruntergeladen",
+  "localModel.pausedTitle": "Pausiert",
+  "localModel.pauseDownloadTitle": "Download pausieren",
+  "localModel.resumeDownloadTitle": "Download fortsetzen",
+  "localModel.deletePartialDownloadTitle": "Unvollständigen Download löschen",
+  "localModel.gpuUsedTotal": "GPU {used} / {total}",
+  "localModel.gpuFree": "{free} frei",
+  "localModel.notInstalled": "Ollama nicht installiert",
+  "localModel.noModelsInstalled": "Keine Modelle installiert",
+  "localModel.serverStopped": "Server gestoppt",
+  "localModel.defaultLoadedTitle": "Standard-Lokalmodell · im Speicher geladen",
+  "localModel.loadedClickDefaultTitle": "Im Speicher geladen — klicken, um als Standard festzulegen",
+  "localModel.defaultTag": "Standard",
+  "localModel.usedForRole": "Verwendet für {role} — klicken, um zuzuweisen aufzuheben",
+  "localModel.useForRole": "{name} für {role} verwenden",
+  "localModel.unloadFromMemoryTitle": "{name} aus dem Speicher entladen",
+  "localModel.unloading": "Wird entladen…",
+  "localModel.loadIntoMemoryGroup": "In den Speicher laden",
+  "localModel.failedRetryTitle": "Laden fehlgeschlagen — klicken, um erneut zu versuchen",
+  "localModel.loadIntoMemoryTitle": "In den Speicher laden",
+  "localModel.failed": "Fehlgeschlagen",
+  "localModel.manageLocalModels": "Lokale Modelle verwalten…",
+  "localModel.installOllamaEllipsis": "Ollama installieren…",
+  "localModel.notRunning": "Ollama läuft nicht",
+  "localModel.failedToLoadModel": "Modell konnte nicht geladen werden",
+  "localModel.failedToUnloadModel": "Modell konnte nicht entladen werden",
+  "localModel.failedToLoadModels": "Modelle konnten nicht geladen werden",
+  "appShell.vpnStillActiveTitle": "VPN-Tunnel noch aktiv",
+  "appShell.vpnStillActiveMessage": "Der OpenVPN-Tunnel ist noch aktiv und leitet diesen gesamten Rechner um. Er läuft weiter, nachdem Eldrun geschlossen wurde — nutze die VPN-Steuerung in der Kopfzeile, um ihn selbst zu beenden, wenn du fertig bist.",
+  "appShell.showFilesPanel": "Dateipanel anzeigen",
+  "detached.loadingSubwindow": "Unterfenster wird geladen…",
+  "centerPanel.noTabsOpen": "Keine Tabs geöffnet",
+  "centerPanel.noTabsHintPre": "Verwende",
+  "centerPanel.noTabsHintPost": "in der Tab-Leiste oben, um eine Shell oder einen KI-Agenten zu öffnen.",
+  "detachedTabs.scrollLeft": "Tabs nach links scrollen",
+  "detachedTabs.scrollRight": "Tabs nach rechts scrollen",
+  "detachedTabs.dragToMove": "Ziehen, um dieses Fenster zu verschieben",
+  "detachedTabs.closeTab": "Tab schließen",
+  "detachedTabs.newTab": "Neuer Tab",
+  "detachedTabs.hideWindow": "Dieses Fenster in das rechte Panel verstecken (von dort wiederherstellbar)",
+  "tour.skip": "Tour überspringen",
+  "tour.back": "Zurück",
+  "tour.done": "Fertig",
+  "tour.next": "Weiter",
+  "hint.dismissAria": "Hinweis verwerfen",
+  "hint.dontShowHints": "Hinweise nicht mehr anzeigen",
+  "hint.notNow": "Nicht jetzt",
+  "untested.title": "Diese Funktion ist implementiert, aber noch nicht live getestet",
+  "untested.label": "ungetestet",
+  "vpnNotice.ariaLabel": "OpenVPN-Tunnel",
+  "vpnNotice.alreadyUp": "OpenVPN-Tunnel bereits aktiv",
+  "vpnNotice.desc": "Dieser Computer leitet bereits über einen Tunnel um, daher braucht dieses Projekt keinen zweiten. Verwalte Tunnel über die VPN-Steuerung in der Kopfzeile.",
+  "connLog.ariaLabel": "OpenVPN-Verbindungsprotokoll",
+  "connLog.startingVpn": "OpenVPN wird gestartet…",
+  "folderPicker.upOneFolder": "Einen Ordner nach oben",
+  "folderPicker.up": "Nach oben",
+  "folderPicker.noSubfolders": "Keine Unterordner hier.",
+  "folderPicker.folderPrefix": "Ordner:",
+  "blob.noProjectsYet": "Noch keine Projekte — erstelle eines, um die Wolke zu füllen.",
+  "blob.backToProjects": "Zurück zu den Projekten",
+  "blob.sphereView": "Kugel",
+  "blob.sphereViewTitle": "3D-Projektkugel",
+  "blob.pieView": "Kreis",
+  "blob.pieViewTitle": "Kreisdiagramm der erfassten Zeit",
+  "blob.hintFocused": "Klicke einen Ordner zum Öffnen · klicke eine Datei zum Öffnen · Mitte oder Esc, um zurückzugehen",
+  "blob.hintPie": "Segmentgröße = erfasste Zeit · Klick öffnet ein Projekt · Rechtsklick für Menü",
+  "blob.hintCloud": "Ziehen zum Umkreisen · Scrollen zum Zoomen · Klick zum Erkunden von Dateien · Doppelklick zum Öffnen · Rechtsklick für Menü",
+  "blob.noProjectsToChart": "Noch keine Projekte für das Diagramm.",
+  "blob.projectCountOne": "{count} Projekt",
+  "blob.projectCountMany": "{count} Projekte",
+  "blob.projectRoot": "Projekt-Wurzel",
+  "blob.noDescriptionYet": "Noch keine Beschreibung.",
+  "blob.hintCenterUp": "Klick, um nach oben zu gehen · Doppelklick zum Öffnen · Esc zum Verlassen",
+  "blob.hintExploreOpen": "Klick zum Erkunden von Dateien · Doppelklick zum Öffnen",
+  "blob.boxMetaOne": "Box · {count} Projekt",
+  "blob.boxMetaMany": "Box · {count} Projekte",
+  "blob.doubleClickToOpen": "Doppelklick zum Öffnen",
+  "blob.folder": "Ordner",
+  "blob.extFile": "{ext}-Datei",
+  "blob.file": "Datei",
+  "blob.clickToEnterFolder": "Klick, um den Ordner zu öffnen",
+  "blob.clickToOpen": "Klick zum Öffnen",
+  "blob.open": "Öffnen",
+  "blob.categoriesEllipsis": "Kategorien…",
+  "blob.activate": "Aktivieren",
+  "blob.inactivate": "Deaktivieren",
+  "blob.loadingLower": "wird geladen…",
+  "pageStrip.ariaLabel": "Seiten",
+  "pageStrip.turnClockwiseTitle": "Diese Seite um 90° im Uhrzeigersinn drehen",
+  "pageStrip.turnClockwiseAria": "Seite im Uhrzeigersinn drehen",
+  "pageStrip.removePageTitle": "Diese Seite entfernen",
+  "pageStrip.removePageAria": "Seite entfernen",
+  "pageStrip.turnRight": "Nach rechts drehen",
+  "pageStrip.turnLeft": "Nach links drehen",
+  "pageStrip.duplicate": "Duplizieren",
+  "pageStrip.deleteOne": "Seite löschen",
+  "pageStrip.deleteMany": "{count} Seiten löschen",
+  "usage.toneGreen": "grün",
+  "usage.toneOrange": "orange",
+  "usage.toneRed": "rot",
+  "usage.utilizationAria": "Auslastung {tone}",
+  "usage.cpu": "CPU",
+  "usage.coresOne": "({count} Kern)",
+  "usage.coresMany": "({count} Kerne)",
+  "usage.loadAverage": "Durchschnittslast",
+  "usage.memory": "Arbeitsspeicher",
+  "usage.loggedIn": "Angemeldet",
+  "usage.carefulNote":
+    "HPC-Host — es werden nur Ihre eigenen Sitzungen und Prozesse aufgeführt. Die Nutzungsordnung eines Clusters erlaubt es nicht, Namen oder Kommandozeilen anderer Nutzerinnen und Nutzer zu erfassen; deshalb läuft dieser Bericht hier auch nicht automatisch.",
+  "usage.sessionsOne": "({count} Sitzung)",
+  "usage.sessionsMany": "({count} Sitzungen)",
+  "usage.userCol": "Benutzer",
+  "usage.sessionsCol": "Sitzungen",
+  "usage.memCol": "Spch",
+  "usage.noInteractiveLogins": "Keine interaktiven Anmeldungen auf diesem Host.",
+  "usage.topProcesses": "Wichtigste Prozesse",
+  "usage.cpuSuffix": "CPU",
+  "usage.memSuffix": "Spch",
+  "usage.title": "Aktuelle Auslastung des Remote-Hosts",
+  "usage.noMachines": "Keine Maschinen zu prüfen — füge eine im Maschinen-Menü hinzu oder öffne ein Remote-Projekt.",
+  "usage.lede": "Auslastung, Speicher und angemeldete Sitzungen auf {hosts}, {reading} — das läuft gerade.",
+  "usage.hostSingular": "1 Host",
+  "usage.hostsPlural": "{count} Hosts",
+  "usage.beingReadNow": "wird gerade gelesen",
+  "usage.asLastRead": "wie zuletzt gelesen",
+  "usage.checkingEllipsis": "Wird geprüft…",
+  "usage.noReading": "Kein Messwert — der Host ist möglicherweise nicht erreichbar.",
+  "usage.rechecking": "Wird erneut geprüft…",
+  "usage.recheck": "Erneut prüfen",
+  "hostKey.title": "Ist dies die richtige Maschine?",
+  "hostKey.ledePre": "Eldrun hat sich noch nie verbunden mit",
+  "hostKey.ledePost": "zuvor, und es steht kurz davor, dort ein Passwort zu senden. Vergleiche den Fingerabdruck unten mit dem, was der Administrator des Hosts (oder eine andere Maschine, der du bereits vertraust) zeigt — stimmt er nicht überein, antwortet etwas anderes für diese Adresse.",
+  "hostKey.readingKey": "Der Schlüssel des Hosts wird gelesen…",
+  "hostKey.errorHeading": "Der Schlüssel des Hosts konnte nicht gelesen werden, es gibt also nichts zu überprüfen. Es wurde nichts gesendet.",
+  "hostKey.acceptNotePre": "Das Akzeptieren speichert diesen Schlüssel in",
+  "hostKey.acceptNotePost": ". Du wirst nicht erneut gefragt — und falls sich der Schlüssel jemals ändert, wird die Verbindung rundweg abgelehnt.",
+  "hostKey.accepting": "Wird akzeptiert…",
+  "hostKey.acceptAndConnect": "Akzeptieren und verbinden",
+  "localLoss.kindDeleted": "lokal gelöscht",
+  "localLoss.kindOverwritten": "lokal überschrieben",
+  "localLoss.sourceGit": "Git-Gleichschritt",
+  "localLoss.sourceSync": "Dateisynchronisierung",
+  "localLoss.entryCountOne": "{count} Datei {kind}",
+  "localLoss.entryCountMany": "{count} Dateien {kind}",
+  "localLoss.moreCount": "…und {count} weitere",
+  "localLoss.unrecoverable": "Dieser Inhalt existierte immer nur auf diesem Rechner — er kann nicht wiederhergestellt werden.",
+  "localLoss.title": "Dateien in deiner lokalen Kopie geändert",
+  "localLoss.ledePre": "Die Synchronisierung dieses Projekts mit dem Host hat etwas in deiner lokalen Kopie zerstört —",
+  "localLoss.ledeMid": "über",
+  "localLoss.ledePost": ". Genau das sollen Git und Sync tun, wenn sich beide Seiten bewegen; es steht hier, weil es auf deinem Rechner passiert ist — und ohne zu fragen.",
+  "localLoss.filesCountOne": "{count} Datei",
+  "localLoss.filesCountMany": "{count} Dateien",
+  "localLoss.opsCountOne": "{count} Vorgang",
+  "localLoss.opsCountMany": "{count} Vorgänge",
+  "common.rename": "Umbenennen",
+  "common.connect": "Verbinden",
+  "common.next": "Weiter",
+  "projectSearch.placeholder": "Inaktive durchsuchen...",
+  "projectSearch.noProjects": "Keine Projekte",
+  "projectSearch.boxMemberOne": "Box · {count} Mitglied",
+  "projectSearch.boxMemberMany": "Box · {count} Mitglieder",
+  "categoryEditor.titleSuffix": "Kategorien",
+  "categoryEditor.desc": "Markiere dieses Projekt, um es in der Projektwolke und der Pillenleiste einzufärben und zu gruppieren. Ein Projekt kann mehrere Kategorien tragen; die erste ist seine Hauptfarbe.",
+  "categoryEditor.removeCategory": "Diese Kategorie entfernen",
+  "categoryEditor.addCategory": "Diese Kategorie hinzufügen",
+  "categoryEditor.addLabel": "Kategorie hinzufügen",
+  "categoryEditor.placeholder": "z. B. Arbeit, Forschung, Kunde-X…",
+  "categoryEditor.saving": "Wird gespeichert…",
+  "categoryEditor.save": "Speichern",
+  "boxPill.clickToOpenTitle": "{name} (Box) — Klick zum Öffnen",
+  "boxPill.memberCountOne": "{count} Mitglied",
+  "boxPill.memberCountMany": "{count} Mitglieder",
+  "boxPill.noMembers": "Keine Mitglieder",
+  "boxPill.switchToTitle": "Zu {name} wechseln",
+  "boxPill.removeFromBox": "Aus der Box entfernen",
+  "boxPill.openBox": "Box öffnen",
+  "boxPill.deleteBox": "Box löschen",
+  "activityCal.noActivity": "Keine Aktivität",
+  "activityCal.less": "Weniger",
+  "activityCal.more": "Mehr",
+  "activityCal.dayMon": "Mo",
+  "activityCal.dayWed": "Mi",
+  "activityCal.dayFri": "Fr",
+  "remotePane.notConnected": "Nicht verbunden",
+  "remotePane.hintPre": "Dieser Tab läuft auf",
+  "remotePane.theRemoteHost": "dem Remote-Host",
+  "remotePane.hintPost": "Verbinde, um sie zu starten — deine lokalen Tabs arbeiten währenddessen weiter am Spiegel.",
+  "extendRemote.title": "„{name}“ auf Remote erweitern",
+  "extendRemote.attachPre": "Verbinde",
+  "extendRemote.attachMid": "mit diesem Projekt als primärem Remote-Host. Der leere Remote-Ordner wird auf dem Host erstellt; deine vorhandenen lokalen Dateien werden zur synchronisierten Arbeitskopie und bleiben, wo sie sind. Nichts wird hochgeladen, bis du es manuell hochlädst.",
+  "extendRemote.attachGeneric": "Verbinde diesem Projekt einen Remote-SSH-Host. Der leere Remote-Ordner wird auf dem Host erstellt; deine vorhandenen lokalen Dateien werden zur synchronisierten Arbeitskopie und bleiben, wo sie sind. Nichts wird hochgeladen, bis du es manuell hochlädst.",
+  "extendRemote.summaryLede": "Erstellt den Remote-Ordner und paart ihn mit den vorhandenen lokalen Dateien dieses Projekts:",
+  "extendRemote.local": "Lokal",
+  "extendRemote.remote": "Remote",
+  "extendRemote.readyTitle": "Den Remote-Host mit diesem Projekt verbinden",
+  "extendRemote.notReadyTitle": "Zuerst verbinden und einen Remote-Ordner auswählen",
+  "extendRemote.connectFirstError": "Zuerst verbinden und einen Remote-Ordner auswählen.",
+  "extendRemote.extending": "Wird erweitert…",
+  "extendRemote.extendToRemote": "Auf Remote erweitern",
+  "pythonInterp.titleSuffix": "Python-Interpreter",
+  "pythonInterp.desc": "Wird von den Ausführen- und Debug-Schaltflächen des Code-Viewers verwendet. Automatische Erkennung ist für fast jedes Projekt richtig — pinne einen nur, wenn deine Umgebung dort liegt, wo Eldrun sie nicht erschließen kann.",
+  "pythonInterp.remoteSuffix": "Auf dem Host geprüft, da dieses Projekt dort läuft.",
+  "pythonInterp.looking": "Interpreter werden gesucht…",
+  "pythonInterp.interpreterLabel": "Interpreter",
+  "pythonInterp.autoDetectWith": "Automatisch erkennen — {path}",
+  "pythonInterp.autoDetect": "Automatisch erkennen",
+  "pythonInterp.customPath": "Benutzerdefinierter Pfad…",
+  "pythonInterp.pathLabel": "Pfad zum Interpreter",
+  "pythonInterp.pathPlaceholder": "z. B. /opt/envs/ml/bin/python — relative Pfade werden vom Projektstamm aus aufgelöst",
+  "pythonInterp.probeErrorPre": "Interpreter konnten nicht geprüft werden (",
+  "pythonInterp.probeErrorPost": "). Du kannst trotzdem einen manuell festlegen.",
+  "pythonInterp.saving": "Wird gespeichert…",
+  "pythonInterp.save": "Speichern",
+  "remoteBrowser.ariaLabel": "Remote-Ordner-Browser",
+  "remoteBrowser.goUp": "Nach oben",
+  "remoteBrowser.recentlyUsed": "Kürzlich verwendet…",
+  "remoteBrowser.jumpTitle": "Zu einem zuvor verwendeten Remote-Pfad für diesen Host springen",
+  "remoteBrowser.useThisFolder": "Diesen Ordner verwenden",
+  "remoteBrowser.newFolderPlaceholder": "Neuer Ordnername…",
+  "remoteBrowser.addFolderTitle": "Hier einen neuen Ordner erstellen",
+  "remoteBrowser.addFolder": "+ Ordner hinzufügen",
+  "remoteBrowser.listing": "Wird aufgelistet...",
+  "remoteBrowser.emptyFolder": "Leerer Ordner.",
+  "bigFolder.titlePre": "Große Ordner in",
+  "bigFolder.thisProject": "diesem Projekt",
+  "bigFolder.introPre": "Diese Ordner sind groß genug, dass ihre Synchronisierung jede Übertragung dominieren würde. Sync kopiert Bytes und",
+  "bigFolder.doesNotReadGitignore": "liest .gitignore nicht",
+  "bigFolder.introPost": ", daher überquert absichtlich auf dem Host gehaltene Daten — Experimentausgaben, Checkpoints, Caches, virtuelle Umgebungen — wie jede andere Datei, sofern sie hier nicht ausgeschlossen sind.",
+  "bigFolder.measuring": "Beide Seiten werden gemessen…",
+  "bigFolder.nothingOversizedFull": "Nichts Übergroßes gefunden. Los geht's mit der Synchronisierung.",
+  "bigFolder.nothingOversizedLocalOnly": "Auf der lokalen Seite nichts Übergroßes gefunden. Los geht's mit der Synchronisierung.",
+  "bigFolder.colFolder": "Ordner",
+  "bigFolder.colThisMachine": "Dieser Rechner",
+  "bigFolder.colHost": "Host",
+  "bigFolder.notePre": "Angehakt =",
+  "bigFolder.excludedFromSync": "von der Synchronisierung ausgeschlossen",
+  "bigFolder.notePost": ". So oder so wird nichts gelöscht, und jeder Ordner kann später über sein Rechtsklickmenü im Dateibaum wieder eingeschlossen werden. Git-verfolgte Dateien reisen weiterhin mit deinen Commits — der Ausschluss gilt nur für die Byte-Synchronisierung.",
+  "bigFolder.hostNotMeasuredPre": "Der Host wurde nicht gemessen",
+  "bigFolder.hostNotConnected": "das Projekt ist nicht verbunden",
+  "bigFolder.hostNotMeasuredPost": ". Es werden nur die Ordner dieses Rechners aufgelistet; öffne dies erneut aus der Dateiansicht, sobald verbunden, um die des Hosts zu sehen.",
+  "bigFolder.hostSkippedCareful": "Der Host wurde nicht gemessen — dieser Rechner ist als schonend markiert, daher läuft der rekursive Scan seines gesamten Baums nicht von selbst.",
+  "bigFolder.measureHost": "Host trotzdem messen",
+  "bigFolder.measuringHost": "Host wird gemessen…",
+  "bigFolder.notNow": "Nicht jetzt",
+  "bigFolder.close": "Schließen",
+  "bigFolder.apply": "Übernehmen",
+  "common.saving": "Wird gespeichert…",
+  "common.save": "Speichern",
+  "common.close": "Schließen",
+  "pill.gitClean": "Keine ausstehenden Änderungen",
+  "pill.gitDirty": "Nicht committete Änderungen — noch nicht hinzugefügt",
+  "pill.gitStaged": "Bereitgestellte Änderungen — noch nicht committet",
+  "pill.gitUnpushed": "Committet — noch nicht gepusht",
+  "pill.statusWorking": "{count} arbeiten",
+  "pill.statusWaiting": "{count} warten auf dich",
+  "pill.statusFinished": "{count} fertig",
+  "pill.categoriesLabel": "Kategorien: {list}",
+  "pill.closeProject": "Projekt schließen",
+  "pill.activityTitle": "{name} — Aktivität",
+  "pill.descTitle": "{name} — Beschreibung",
+  "pill.descPlaceholder": "Kurze Beschreibung für dieses Projekt…",
+  "pill.renameTitle": "Projekt umbenennen",
+  "pill.namePlaceholder": "Projektname…",
+  "pill.nameEmpty": "Name darf nicht leer sein",
+  "pill.publishTitle": "{name} — Bei {provider} veröffentlichen",
+  "pill.currentPrefix": "Aktuell:",
+  "pill.runsOnWorkRemote": "· läuft auf dem Arbeits-Remote-Host",
+  "pill.hostingProvider": "Hosting-Anbieter",
+  "pill.repoVisibility": "Repository-Sichtbarkeit",
+  "pill.visPrivate": "privat",
+  "pill.visPublic": "öffentlich",
+  "pill.publishRunsPre": "Führt aus",
+  "pill.publishRunsMid": "Erfordert",
+  "pill.publishRunsPost": "installiert und authentifiziert (oder ein Token unter ⚙ Einstellungen → Git-Hosting).",
+  "pill.publishCliMissingPre": "Kein",
+  "pill.publishCliMissingMid": "auf diesem Rechner gefunden — Veröffentlichen erstellt das Repository über die eigene CLI des Anbieters, also installiere sie (und melde dich an mit",
+  "pill.publishCliMissingPost": ") bevor du veröffentlichst.",
+  "pill.publishFrom": "Veröffentlichen von",
+  "pill.publishFromLocal": "Diesem Rechner (lokale Spiegelung)",
+  "pill.publishFromRemote": "Arbeits-Remote-Host",
+  "pill.publishFromLocalHint": "Das Repository wird aus der lokalen Spiegelung dieses Projekts erstellt und gepusht, mit der {cli}-Anmeldung dieses Rechners. Git-Lockstep muss die Spiegelung als im Gleichschritt mit dem Host melden.",
+  "pill.publishRemoteCliHint": "Die Veröffentlichung läuft auf dem Arbeits-Remote-Host — {cli} muss dort installiert und angemeldet sein, nicht auf diesem Rechner, und das Projekt muss verbunden sein.",
+  "pill.publishSignInHint": "Nicht über ein gespeichertes Token verbunden — die Veröffentlichung verwendet die eigene Anmeldung von {cli}.",
+  "pill.publishSignInBtn": "Mit {cli} anmelden",
+  "pill.publishSignInTitle": "{cmd} in einem neuen Terminal-Tab ausführen",
+  "pill.getTokenCta": "Ein {provider}-Zugriffstoken erstellen…",
+  "pill.getTokenHint": "Erfordert den Scope \"repo\" bei GitHub bzw. \"api\" (Lese-/Schreibzugriff auf Repository) bei GitLab.",
+  "pill.published": "Veröffentlicht.",
+  "pill.publishing": "Wird veröffentlicht…",
+  "pill.publish": "Veröffentlichen",
+  "pill.gitHostingTitle": "{name} — Git-Hosting",
+  "pill.gitHostingDesc": "Überschreibt das globale Git-Hosting nur für dieses Projekt. Felder leer lassen, um die globalen Einstellungen zu übernehmen.",
+  "pill.inheritsGlobal": "Übernimmt global: {url}",
+  "pill.replaceToken": "Zugriffstoken ersetzen",
+  "pill.enterNewToken": "Neues Token zum Ersetzen eingeben…",
+  "pill.tokenStatusWillSet": "Setzt ein Projekt-Token (überschreibt global).",
+  "pill.tokenStatusWillRemove": "Entfernt das Projekt-Token; kehrt zum globalen zurück.",
+  "pill.tokenStatusHasToken": "Ein Projekt-Token ist gesetzt (verborgen). Leer lassen, um es zu behalten.",
+  "pill.tokenStatusInherits": "Übernimmt das globale Token.",
+  "pill.tokenStatusNone": "Kein Token gesetzt — Pushes verwenden deine System-Git-Anmeldedaten.",
+  "pill.removeProjectToken": "Projekt-Token entfernen (global verwenden)",
+  "pill.disableGitTitle": "{name} — Git & Verlauf entfernen",
+  "pill.disableGitWarn1": "Dies löscht dauerhaft das",
+  "pill.disableGitWarn2": "-Verzeichnis dieses Projekts — jeden Commit, Branch, Stash und Remote.",
+  "pill.cannotBeUndone": "Dies kann nicht rückgängig gemacht werden.",
+  "pill.disableGitWarn3": "Das Projekt wird zu einem „Kein Git (kein Repo)“-Projekt; deine Arbeitsdateien bleiben unberührt.",
+  "pill.typeNameConfirmPre": "Gib den Projektnamen ein",
+  "pill.typeNameConfirmPost": "zur Bestätigung",
+  "pill.removing": "Wird entfernt…",
+  "pill.deleteGitHistory": "Git-Verlauf löschen",
+  "pill.deleteProjectTitle": "{name} löschen",
+  "pill.archiveDescPre": "Dies trennt",
+  "pill.archiveDescMid": "und verschiebt es in das Eldrun-Archiv. Du kannst es später wiederherstellen — oder endgültig löschen — unter",
+  "pill.archiveSettingsLink": "Einstellungen → Archivierte Projekte",
+  "pill.archiveRemoteNotTouchedPre": "Die Dateien auf dem Remote-Host sind",
+  "pill.notWord": "nicht",
+  "pill.archiveRemoteNotTouchedPost": "betroffen.",
+  "pill.deleting": "Wird gelöscht…",
+  "pill.deleteToArchive": "Ins Archiv löschen",
+  "pill.detachTitle": "{name} — SSH-Host trennen",
+  "pill.detachDesc1Pre": "Dies verwandelt",
+  "pill.detachDesc1Mid": "wieder in ein reines lokales Projekt: seine lokale Arbeitskopie bleibt genau dort, wo sie ist, und wird wieder zum Projektverzeichnis. Die Dateien auf dem Remote-Host sind",
+  "pill.detachDesc1Post": "betroffen, und nichts Lokales wird gelöscht.",
+  "pill.detachDesc2Pre": "Was dabei wegfällt, ist die",
+  "pill.pairingWord": "Kopplung",
+  "pill.detachDesc2Post": ": Git-Gleichschritt stoppt, und der Auto-Sync-Bereich, den du für diesen Host gewählt hast — welche Ordner übertragen werden und der Datensatz dessen, was bereits im Gleichschritt war — wird verworfen. Den gleichen Host später erneut anzuhängen bedeutet, diesen Bereich von Grund auf neu festzulegen.",
+  "pill.detaching": "Wird getrennt…",
+  "pill.detachToLocal": "Zu lokal trennen",
+  "pill.containerSettingsTitle": "{name} — Container-Einstellungen",
+  "pill.containerAppliedNote": "Wird beim nächsten Containerstart angewendet (Projektaktivierung oder Tab-Erzeugung) — ein laufender Container mit geänderten Einstellungen wird automatisch ersetzt.",
+  "pill.buildFromDockerfile": "Aus einem Dockerfile in diesem Projekt bauen",
+  "pill.dockerfilePlaceholder": "z. B. Dockerfile — leer: das Image unten verwenden",
+  "pill.image": "Image",
+  "pill.imagePlaceholder": "leer: eldrun-agent-sandbox:latest",
+  "pill.network": "Netzwerk",
+  "pill.networkPlaceholder": "leer: Docker-Bridge — „none“ blockiert jeglichen ausgehenden Verkehr (bricht Cloud-Agenten)",
+  "pill.networkNotePre": "Hinweis: Die Standard-Bridge erreicht weiterhin Dienste, die an diesen Rechner gebunden sind (Ollama, Dev-Server), über die Docker-Gateway-IP. Vollständig geschlossen bedeutet",
+  "pill.networkNotePost": "oder ein benutzerdefiniertes Allowlist-Netzwerk.",
+  "pill.memoryCap": "Speicherbegrenzung",
+  "pill.memoryPlaceholder": "z. B. 4g — leer: unbegrenzt",
+  "pill.cpuCap": "CPU-Begrenzung",
+  "pill.cpuPlaceholder": "z. B. 2 — leer: unbegrenzt",
+  "pill.processLimit": "Prozesslimit",
+  "pill.processLimitPlaceholder": "leer: 1024 (Fork-Bomben-Schutz)",
+  "pill.processLimitError": "Prozesslimit muss eine positive Ganzzahl sein.",
+  "pill.readonlyRootfs": "Root-Dateisystem schreibgeschützt (behält beschreibbares /tmp)",
+  "pill.unpublishTitle": "{name} — Veröffentlichung aufheben",
+  "pill.unpublishDesc1": "Dies entfernt das",
+  "pill.unpublishDesc2": "Remote und setzt das Projekt auf ein lokales Git-Repo zurück. Deine Commits bleiben erhalten, und das Repository auf",
+  "pill.unpublishDesc3": "ist",
+  "pill.unpublishDesc4": "gelöscht — nur die lokale Verknüpfung dazu wird entfernt. Du kannst später erneut veröffentlichen.",
+  "pill.unpublishing": "Veröffentlichung wird aufgehoben…",
+  "pill.unpublishKeepRepo": "Veröffentlichung aufheben (Repo behalten)",
+  "pill.changeVisibilityTitle": "{name} — Sichtbarkeit ändern",
+  "pill.flipVisibility1": "Dieses Repository wechseln von",
+  "pill.flipVisibility2": "zu",
+  "pill.flipVisibility3": "direkt über",
+  "pill.flipVisibility4": "Das Repo, seine URL und sein Verlauf bleiben erhalten.",
+  "pill.applying": "Wird angewendet…",
+  "pill.makeVisibility": "{target} machen",
+  "pill.moveToProviderTitle": "{name} — Zu einem anderen Anbieter wechseln",
+  "pill.newProvider": "Neuer Anbieter",
+  "pill.migrateDesc1": "Erstellt das Repo bei",
+  "pill.migrateDesc2": ", verweist erneut auf",
+  "pill.migrateDesc3": "um, und pusht. Das bestehende",
+  "pill.migrateDesc4": "-Repository ist",
+  "pill.leftIntact": "unangetastet gelassen",
+  "pill.migrateDesc5": "(behalten als",
+  "pill.migrateDesc6": ") — lösche es selbst, wenn du es nicht mehr willst.",
+  "pill.migrating": "Wird migriert…",
+  "pill.moveToProvider": "Zu {provider} wechseln",
+  "pill.viewGroup": "Ansicht",
+  "pill.showActivity": "Aktivität anzeigen",
+  "pill.showOnDiskRemoteTitle": "Den lokalen Spiegel (die verbundene Arbeitskopie) im Dateimanager öffnen",
+  "pill.showOnDiskLocalTitle": "Das Projektverzeichnis im Dateimanager öffnen",
+  "pill.showOnDisk": "Auf Datenträger anzeigen",
+  "pill.editGroup": "Bearbeiten",
+  "pill.renameEllipsis": "Umbenennen…",
+  "pill.movePillTitle": "Den lokalen Spiegel dieses Projekts (die verbundene Arbeitskopie) in einen neuen Ordner verschieben",
+  "pill.moveProjectEllipsis": "Projekt verschieben…",
+  "pill.editDescription": "Beschreibung bearbeiten",
+  "pill.categoriesMenuTitle": "Markiere dieses Projekt, um es in der Wolke und der Pillenleiste einzufärben und zu gruppieren",
+  "pill.repairScaffoldTitle": "Fehlende Gerüstdateien, Standard-.gitignore-Muster oder .claude/settings.json ergänzen — überschreibt nie vorhandenen Inhalt",
+  "pill.repairScaffold": "Gerüstdateien reparieren",
+  "pill.extendToRemoteMenuTitle": "Diesem lokalen Projekt einen Remote-SSH-Host anhängen — Dateien bleiben, wo sie sind; manuell hochladen",
+  "pill.extendToRemoteEllipsis": "Auf Remote erweitern…",
+  "pill.gitGroup": "Git",
+  "pill.gitInitTitle": "git init ausführen, um die Versionskontrolle für dieses Projekt zu starten",
+  "pill.enableGit": "Git aktivieren (git init)",
+  "pill.makePrivateTitle": "Das Repository direkt zwischen öffentlich und privat umschalten (gh/glab repo edit)",
+  "pill.makePrivate": "Privat machen…",
+  "pill.makePublic": "Öffentlich machen…",
+  "pill.moveProviderMenuTitle": "Beim anderen Anbieter veröffentlichen und origin neu verweisen; das alte Repo bleibt unangetastet",
+  "pill.moveToGithub": "Zu GitHub wechseln…",
+  "pill.moveToGitlab": "Zu GitLab wechseln…",
+  "pill.unpublishMenuTitle": "Das origin-Remote entfernen und zu einem lokalen Repo zurückkehren; das gehostete Repo und der Verlauf bleiben erhalten",
+  "pill.unpublishKeepRepoEllipsis": "Veröffentlichung aufheben (Repo behalten)…",
+  "pill.gitHostingMenuTitle": "Das globale Git-Hosting (Profil-URL + Token) nur für dieses Projekt überschreiben",
+  "pill.gitHostingEllipsis": "Git-Hosting…",
+  "pill.publishEllipsis": "Bei GitHub / GitLab veröffentlichen…",
+  "pill.runtimeGroup": "Laufzeit",
+  "pill.containerRunTitle": "Jeden Terminal- und Agenten-Tab dieses Projekts in einem geschlossenen Docker-Container ausführen. Der Projektordner bleibt auf dem Host unter seinem normalen Pfad — der Container kann nur nichts anderes erreichen.",
+  "pill.runInContainer": "Dieses Projekt in einem Container ausführen",
+  "pill.containerSettingsMenuTitle": "Image, Netzwerk, Speicher-/CPU-Begrenzungen und schreibgeschütztes Rootfs für den Container dieses Projekts",
+  "pill.containerSettingsEllipsis": "Container-Einstellungen…",
+  "pill.pythonInterpMenuTitle": "Die Python-Umgebung, in der die Skripte dieses Projekts laufen und debuggt werden. Standardmäßig automatisch erkannt (venv im Baum, poetry, conda, pyenv); pinne eine, wenn deine Umgebung dort liegt, wo Eldrun sie nicht erschließen kann.",
+  "pill.pythonInterpreterEllipsis": "Python-Interpreter…",
+  "pill.autoConnectTitleNonHeadless": "Dieses Projekt beim Start und beim Wechsel dorthin automatisch verbinden. Eldrun handhabt in diesem Modus keine Passwörter, daher öffnet sich die Anmeldung (und das VPN, falls vorhanden) im Root-Terminal zur Authentifizierung — dann verbindet sich das Projekt von selbst.",
+  "pill.autoConnectTitleEligible": "Dieses Projekt beim Start und beim Wechsel dorthin automatisch verbinden. Es fragt nie nach etwas: Es geht direkt hinein, wenn der Host erreichbar ist, und baut das VPN nur auf, wenn nicht.",
+  "pill.autoConnectTitleNotEligible": "Speichere zuerst das SSH-Passwort (oder verwende Schlüsselauthentifizierung) — Auto-Connect wird nur angeboten, wenn das Verbinden nichts von dir benötigt.",
+  "pill.autoConnectOnLaunch": "Automatisch beim Start verbinden",
+  "pill.persistSessionsMenuTitle": "Die Remote-Shell- und Python-/Skript-Tabs dieses Projekts in einer tmux-Sitzung auf dem Host ausführen, sodass ein langer Lauf über einen SSH-Abbruch, Laptop-Schlaf oder Eldrun-Beenden hinweg weiterläuft — der Tab verbindet sich beim erneuten Verbinden wieder. Das Schließen eines Tabs beendet dennoch dessen Sitzung (mit Bestätigung). Agenten-Tabs sind nicht betroffen.",
+  "pill.persistentSessionsTmux": "Persistente Sitzungen (tmux)",
+  "pill.remoteMachinesMenuTitle": "Zusätzliche Maschinen hinzufügen und verwalten, auf denen dieses Projekt läuft. Sie führen denselben Code aus (in Einweg-Sync gehalten) als schreibgeschützte Experiment-Worker; ihre Ausgaben bleiben auf jeder Maschine.",
+  "pill.remoteMachinesCount": "Remote-Maschinen… ({count})",
+  "pill.remoteMachinesEllipsis": "Remote-Maschinen…",
+  "pill.closeAllTabs": "Alle Tabs und Fenster schließen",
+  "pill.dangerZone": "Gefahrenzone",
+  "pill.detachSshMenuTitle": "Dies wieder in ein lokales Projekt verwandeln. Die lokale Arbeitskopie bleibt, wo sie ist, und die Dateien des Remote-Hosts bleiben unberührt — aber die Kopplung wird aufgehoben: Der Gleichschritt stoppt, und der Auto-Sync-Bereich, den du für diesen Host eingerichtet hast, wird verworfen.",
+  "pill.detachSshEllipsis": "SSH-Host trennen…",
+  "pill.removeGitMenuTitle": "Das .git-Verzeichnis dieses Projekts und den gesamten Versionskontrollverlauf löschen (kann nicht rückgängig gemacht werden)",
+  "pill.removeGitHistoryEllipsis": "Git & Verlauf entfernen…",
+  "pill.deleteProjectMenuTitle": "Dieses Projekt trennen und in das Eldrun-Archiv verschieben. Später über die Einstellungen wiederherstellen oder endgültig löschen. Die Dateien eines Remote-Hosts werden nie angefasst.",
+  "pill.deleteProjectEllipsis": "Projekt löschen…",
+  "pill.nowVisibility": "Jetzt {target}.",
+  "pill.migrated": "Migriert.",
+  "remoteConnect.titleWorker": "Worker verbinden · {host}",
+  "remoteConnect.titleProject": "Remote-Projekt verbinden",
+  "remoteConnect.remoteLabel": "Remote",
+  "remoteConnect.localLabel": "Lokal",
+  "remoteConnect.nameLabel": "Name",
+  "remoteConnect.namePlaceholder": "Projektname",
+  "remoteConnect.nameHintWorker": "Wird auf der Kachel und unter „Remote-Maschinen“ angezeigt. Leer lassen, um den Hostnamen zu verwenden.",
+  "remoteConnect.nameHintProject": "Der Projektname, angezeigt auf seiner Kachel und überall in Eldrun.",
+  "remoteConnect.machineNameLabel": "Maschinenname",
+  "remoteConnect.machineNameHint": "Kennzeichnet diese Maschine im Systemmonitor und bei den Verbindungslampen, wenn das Projekt mehr als einen Host hat. Leer lassen, um den Hostnamen zu verwenden.",
+  "remoteConnect.vpnToggleTitle": "Über OpenVPN verbinden",
+  "remoteConnect.vpnDescLine1": "Baue zuerst einen Tunnel auf, wenn dieser Host per VPN abgesichert ist. Überspringe es, wenn du dich bereits im richtigen Netzwerk befindest — SSH verbindet sich dann direkt.",
+  "remoteConnect.vpnDescLine2Pre": "Der Tunnel ist",
+  "remoteConnect.vpnDescLine2Strong": "systemweit",
+  "remoteConnect.vpnDescLine2Post": ": Solange er aktiv ist, läuft der gesamte Datenverkehr dieses Rechners darüber — auch dein Browser, nicht nur Eldrun.",
+  "remoteConnect.configLabel": "Konfiguration",
+  "remoteConnect.changeConfig": "Ändern…",
+  "remoteConnect.changeConfigTitle": "Wähle eine andere OpenVPN-Konfiguration für dieses Projekt.",
+  "remoteConnect.pickConfigHintChange": "Wähle die stattdessen zu verwendende OpenVPN-Konfiguration — die neue Wahl ersetzt die gespeicherte.",
+  "remoteConnect.pickConfigHintNew": "Wähle die OpenVPN-Konfiguration für diesen Host — sie wird im Projekt gespeichert, sodass du sie nur einmal auswählen musst.",
+  "remoteConnect.recentConfigsPlaceholder": "Zuletzt verwendet…",
+  "remoteConnect.recentConfigsTitle": "Eine zuvor verwendete OpenVPN-Konfiguration wiederverwenden",
+  "remoteConnect.chooseConfigBtn": "„.ovpn“-Konfiguration wählen…",
+  "remoteConnect.vpnUsernameLabel": "VPN-Benutzername",
+  "remoteConnect.vpnPasswordLabel": "VPN-Passwort",
+  "remoteConnect.vpnPassphraseLabel": "VPN-Passphrase",
+  "remoteConnect.vpnSavedPlaceholder": "Verwendet gespeicherte Passphrase — leer lassen",
+  "remoteConnect.vpnAccountPasswordPlaceholder": "OpenVPN-Kontopasswort…",
+  "remoteConnect.vpnPassphrasePlaceholder": "OpenVPN-Passphrase…",
+  "remoteConnect.retryVpn": "VPN erneut versuchen",
+  "remoteConnect.connectVpn": "VPN verbinden",
+  "remoteConnect.vpnStopTitleConnected": "Diesen OpenVPN-Tunnel trennen. Die SSH-Verbindung bleibt unverändert bestehen.",
+  "remoteConnect.vpnStopTitleConnecting": "Diesen VPN-Verbindungsversuch abbrechen und den Tunnelstatus zurücksetzen.",
+  "remoteConnect.disconnectVpn": "VPN trennen",
+  "remoteConnect.vpnTermBtnTitle": "Baue den OpenVPN-Tunnel in einem Terminal unten auf — gib die Passphrase dort ein.",
+  "remoteConnect.vpnTermOpenBelow": "VPN-Terminal unten geöffnet",
+  "remoteConnect.vpnTermOpenBtn": "VPN-Anmeldeterminal öffnen",
+  "remoteConnect.vpnTermHint": "Authentifiziere den Tunnel unten — er bleibt für dieses Projekt aktiv.",
+  "remoteConnect.disconnect": "Trennen",
+  "remoteConnect.sshSectionLabel": "Über SSH anmelden",
+  "remoteConnect.usernameLabel": "Benutzername",
+  "remoteConnect.usernamePlaceholder": "SSH-Anmeldename — leer verwendet dein lokales Konto",
+  "remoteConnect.usernameHint": "Das Konto auf {host}. Eine Änderung wechselt, welches gespeicherte Passwort gilt — sie werden pro Login gespeichert.",
+  "remoteConnect.sshPasswordLabel": "Passwort oder Schlüssel-Passphrase",
+  "remoteConnect.sshSavedPlaceholder": "Verwendet gespeichertes Geheimnis — leer lassen",
+  "remoteConnect.sshPasswordPlaceholder": "SSH-Passwort oder die Passphrase deines Schlüssels…",
+  "remoteConnect.connectedState": "Verbunden",
+  "remoteConnect.sshStopTitle": "Diesen SSH-Verbindungsversuch abbrechen und den Verbindungsstatus zurücksetzen.",
+  "remoteConnect.savePassword": "Passwort speichern",
+  "remoteConnect.saveHintKeptTerminal": "in deinem Betriebssystem-Schlüsselbund gespeichert — eine Terminal-Anmeldung wird von Eldrun nicht gesehen, sodass nichts Neues gespeichert wird; ausschalten, um es zu löschen",
+  "remoteConnect.saveHintSaved": "in deinem Betriebssystem-Schlüsselbund gespeichert — ausschalten, um es zu löschen",
+  "remoteConnect.saveHintNothingTerminal": "bei einer Terminal-Anmeldung gibt es nichts zu speichern — Eldrun sieht es nie",
+  "remoteConnect.autoConnectTitleEligible": "Verbindet dieses Projekt von selbst beim Start und wenn du zu ihm wechselst. Es fragt nie nach etwas: Es verbindet sich direkt, wenn der Host erreichbar ist, und baut das VPN nur auf, wenn er es nicht ist. Beachte, dass das Aufbauen des VPN den gesamten Datenverkehr dieses Rechners umleitet — bei Auto-Connect geschieht das ohne Nachfrage, behalte also die VPN-Anzeige in der Kopfzeile im Auge.",
+  "remoteConnect.autoConnectTitleNotEligible": "Speichere zuerst das SSH-Passwort (oder verwende Schlüssel-Authentifizierung) — Auto-Connect wird nur angeboten, wenn die Verbindung nichts von dir benötigt.",
+  "remoteConnect.autoConnectLabel": "Auto-Connect",
+  "remoteConnect.autoConnectHintEligible": "beim Start und beim Wechsel — VPN nur, wenn der Host nicht direkt erreichbar ist",
+  "remoteConnect.autoConnectHintNotEligible": "benötigt ein gespeichertes Passwort oder Schlüssel-Authentifizierung",
+  "remoteConnect.autoConnectVpnWarningPre": "Achtung: Ist der Host nicht direkt erreichbar, baut Auto-Connect das VPN auf",
+  "remoteConnect.autoConnectVpnWarningStrong": "ohne nachzufragen",
+  "remoteConnect.autoConnectVpnWarningPost": "— und leitet beim Start den Datenverkehr dieses Rechners um. Die VPN-Anzeige in der Kopfzeile zeigt, wenn ein Tunnel aktiv ist, und kann ihn beenden.",
+  "remoteConnect.autoConnectInteractiveTitle": "Verbindet dieses Projekt von selbst beim Start und wenn du zu ihm wechselst. Eldrun handhabt in diesem Modus keine Passwörter, daher öffnet sich die Anmeldung (und das VPN, falls dieses Projekt eines hat) im Root-Terminal, damit du dich authentifizieren kannst — das Projekt verbindet sich von selbst, sobald du angemeldet bist.",
+  "remoteConnect.autoConnectInteractiveHint": "beim Start und beim Wechsel — öffnet die Anmeldung im Root-Terminal",
+  "remoteConnect.sshTermBtnTitle": "Öffne die SSH-Anmeldung in einem Terminal unten — gib das Passwort dort ein.",
+  "remoteConnect.sshTermOpenBelow": "SSH-Terminal unten geöffnet",
+  "remoteConnect.sshTermOpenBtn": "SSH-Anmeldeterminal öffnen",
+  "remoteConnect.tryConnectTitle": "Wenn du dich oben fertig angemeldet hast, verbinde jetzt.",
+  "remoteConnect.tryConnectBtn": "Ich bin angemeldet — verbinden",
+  "remoteConnect.sshTermHint": "Melde dich unten an — die gepoolte Verbindung kommt zustande, sobald du authentifiziert bist.",
+  "remoteConnect.killConfirmTitle": "Bestätigen: Dies beendet jede laufende tmux-Sitzung auf dem Host — dies kann nicht rückgängig gemacht werden.",
+  "remoteConnect.killConfirmBtn": "Bestätigen: alle Jobs beenden",
+  "remoteConnect.killArmTitle": "Aktiv trennen: beendet jeden laufenden tmux-Job auf diesem Host und schließt die Verbindung. Jobs werden nur bei diesem Klick beendet — nie bei einem Eldrun-Neustart.",
+  "remoteConnect.killArmBtn": "Trennen & Jobs beenden",
+  "remoteConnect.forgetPasswordTitle": "Lösche das gespeicherte Passwort dieses Hosts aus deinem Betriebssystem-Schlüsselbund. Die aktuelle Verbindung bleibt bestehen; beim nächsten Verbinden wird erneut nach dem Passwort gefragt.",
+  "remoteConnect.forgetPasswordBtn": "Gespeichertes Passwort vergessen",
+  "carefulHost.title": "Hält Eldruns Hintergrundarbeit von dieser Maschine fern: Die Dateigrößen-Zählung scannt den Host nicht mehr von selbst, und die Überwachung wird günstiger und langsamer. Verwende dies für einen Login-Knoten oder jede Maschine, die du mit anderen teilst — nicht für einen Rechenknoten, den du für die Dauer eines Jobs besitzt und der so lange dir gehört.",
+  "carefulHost.label": "Diese Maschine schonen",
+  "carefulHost.hintDefault": "für einen Login-Knoten oder eine gemeinsam genutzte Maschine: überspringt die Scans, die das gesamte Dateisystem lesen",
+  "carefulHost.hintOnByDefault": "standardmäßig für jede Remote-Maschine aktiv — ausschalten, falls diese dir gehört",
+  "carefulHost.hintNotCareful": "diese Maschine gehört dir: volle Überwachung, wie bei einer lokalen Maschine",
+  "carefulHost.hintHpcTagged": "immer an: Diese Maschine ist als HPC-Cluster-Login-Knoten markiert",
+  "hpcHost.title": "Markiert diese Maschine als geteilten Cluster-Login-Knoten. Eldrun scannt oder vermisst dann von sich aus nichts mehr auf ihr, führt keine Hintergrund-Synchronisation und kein Lockstep-Polling gegen sie aus, verbindet sich nie still beim Start, liest sie unabhängig vom Lese-Schalter sparsam und fragt nach, bevor ein Lauf dort landet. Das wird nicht erkannt — ein Scheduler im PATH sagt, dass SLURM vorhanden ist, nicht, dass es die Betreiber stört.",
+  "hpcHost.label": "HPC-Cluster (Login-Knoten)",
+  "hpcHost.hintOn": "Hintergrundarbeit aus, sparsames Lesen erzwungen, Läufe fragen nach",
+  "hpcHost.hintOff": "für einen Cluster-Login-Knoten ankreuzen — nie für einen Rechenknoten, den du über einen Job hältst",
+  "remoteConnect.vpnSectionAria": "OpenVPN-Tunnel",
+  "remoteConnect.sshSectionAria": "SSH-Anmeldung",
+  "remoteMachines.title": "{name} — Remote-Maschinen",
+  "remoteMachines.introPre": "Jede Maschine, die dieses Projekt erreicht, an einem Ort — die",
+  "remoteMachines.introStrongPrimary": "primäre",
+  "remoteMachines.introMid1": "die seine Dateien und Git besitzt, sowie jede zusätzliche Worker-Maschine, die ihren",
+  "remoteMachines.introStrongSameCode": "gleichen Code ausführt",
+  "remoteMachines.introMid2": ". Verbinde oder verwalte jede davon hier, oder füge unten einen neuen Worker hinzu. Ein neuer Worker teilt sich standardmäßig den Projektordner der primären Maschine (keine Kopie, kein Git); aktiviere",
+  "remoteMachines.introStrongSyncCopy": "Eine Kopie synchronisieren",
+  "remoteMachines.introPost": ", um ihr eine eigene, einseitig synchronisierte Kopie zu geben — für Hosts, die keinen Speicher mit der primären Maschine teilen.",
+  "remoteMachines.primaryTagTitle": "Die primäre Maschine besitzt die Dateien, Git und den lokalen Spiegel dieses Projekts, mit vollständiger bidirektionaler Synchronisierung.",
+  "remoteMachines.primaryTag": "Primär",
+  "remoteMachines.connectedDot": "Verbunden.",
+  "remoteMachines.notConnectedDot": "Nicht verbunden.",
+  "remoteMachines.localMirrorLabel": "Lokaler Spiegel:",
+  "remoteMachines.manage": "Verwalten…",
+  "remoteMachines.connectEllipsis": "Verbinden…",
+  "remoteMachines.sharedFsTag": "Gemeinsames Dateisystem",
+  "remoteMachines.dropIntro": "Aus deinen globalen Maschinen. Gib den gemeinsamen Pfad an, unter dem sie den Ordner dieses Projekts sieht — alles andere ist bereits bekannt.",
+  "remoteMachines.pathOnMachine": "Pfad auf dieser Maschine",
+  "remoteMachines.absolutePathPlaceholder": "Absoluter Pfad (z. B. /home/me/project)",
+  "remoteMachines.adding": "Wird hinzugefügt…",
+  "remoteMachines.addMachineBtn": "Maschine hinzufügen",
+  "remoteMachines.noWorkers": "Noch keine Worker-Maschinen.",
+  "remoteMachines.sharedStatus": "Läuft im gemeinsamen Ordner der primären Maschine — keine Kopie, keine Synchronisierung.",
+  "remoteMachines.syncFailedLabel": "Synchronisierung fehlgeschlagen:",
+  "remoteMachines.lastSyncedLabel": "Zuletzt synchronisiert:",
+  "remoteMachines.alreadyCurrent": "(bereits aktuell)",
+  "remoteMachines.syncingEllipsis": "Synchronisiert…",
+  "remoteMachines.notSyncedYet": "Noch nicht synchronisiert",
+  "remoteMachines.sharedTagTitle": "Gemeinsames Dateisystem: Shells laufen im Projektordner der primären Maschine auf diesem Rechner. Es wird kein Code kopiert, und Git läuft hier nie.",
+  "remoteMachines.syncedTagTitle": "Synchronisierte Kopie: Diese Maschine behält ihre eigene schreibgeschützte Kopie des Codes, einseitig von der primären Maschine synchronisiert.",
+  "remoteMachines.syncedCopyTag": "Synchronisierte Kopie",
+  "remoteMachines.syncCodeNow": "Code jetzt synchronisieren",
+  "remoteMachines.pullOutputsTitle": "Holt die Experiment-Ausgaben dieser Maschine (nicht getrackte Dateien) auf deinen Rechner. Bestätigt zuerst die Größe.",
+  "remoteMachines.pulling": "Wird geholt…",
+  "remoteMachines.pullOutputsBtn": "Ausgaben holen…",
+  "remoteMachines.removeTitle": "Entfernt diese Maschine aus dem Projekt (ihre Dateien auf dem Host bleiben unangetastet).",
+  "remoteMachines.remove": "Entfernen",
+  "remoteMachines.syncCopyToggleTitle": "An: Diese Maschine behält ihre eigene Kopie des Codes, einseitig von der primären Maschine synchronisiert. Aus: Sie teilt sich den Projektordner der primären Maschine über ein gemeinsames Dateisystem (keine Kopie, kein Git).",
+  "remoteMachines.syncCopyLabel": "Eine Kopie des Codes auf diese Maschine synchronisieren",
+  "remoteMachines.autoSyncTitle": "Hält den getrackten Code dieser Maschine bei jedem Commit mit dem Projekt-HEAD synchron.",
+  "remoteMachines.autoSyncLabel": "Code bei jedem Commit automatisch synchronisieren",
+  "remoteMachines.addMachineTitle": "Eine Maschine hinzufügen",
+  "remoteMachines.globalListTitle": "Deine Maschinen",
+  "remoteMachines.globalListHelp":
+    "Maschinen aus der Maschinen-Liste in der Kopfzeile. Sie sind bereits eingerichtet – hier fehlt nur noch ihr Ordner auf der Maschine.",
+  "remoteMachines.globalQuickAdd": "Hinzufügen",
+  "remoteMachines.globalQuickAddTitle":
+    "Diese Maschine als Worker mit gemeinsamem Dateisystem hinzufügen – oben den Ordner bestätigen, dann wird sie hinzugefügt und verbunden.",
+  "remoteMachines.globalFill": "Ins Formular übernehmen",
+  "remoteMachines.globalFillTitle":
+    "Die Adresse dieser Maschine ins Formular unten eintragen – um ihre Ordner zu durchsuchen oder eine Kopie dorthin zu synchronisieren.",
+  "remoteMachines.globalAlreadyAdded": "Bereits hinzugefügt",
+  "remoteMachines.globalAlreadyAddedTitle":
+    "Diese Maschine ist bereits der primäre Host dieses Projekts oder einer seiner Worker.",
+  "remoteMachines.sshAddressLabel": "SSH-Adresse",
+  "remoteMachines.sshAddressPlaceholder": "Host[:Port]  (z. B. gpu-2:22)",
+  "remoteMachines.usernamePlaceholder": "SSH-Anmeldebenutzer (z. B. ich) — oder oben als user@ angeben",
+  "remoteMachines.sshPasswordSavedPlaceholder": "Verwendet gespeichertes Passwort — leer lassen",
+  "remoteMachines.sshPasswordPlaceholder": "SSH-Passwort oder Schlüssel-Passphrase — leer für einen entsperrten Schlüssel",
+  "remoteMachines.saveTitleTerminal": "Eine Terminal-Anmeldung sieht Eldrun nie, daher wird nichts Neues gespeichert — und auch nichts gelöscht. Ein gespeichertes Passwort bleibt unverändert; im eigenen Connect-Menü der Maschine kannst du es ändern.",
+  "remoteMachines.saveTitleHeadless": "Speichert das SSH-Passwort dieser Maschine im Betriebssystem-Schlüsselbund, indiziert nach Host — das eigene Connect-Menü der Maschine findet es dann und fragt nicht erneut. Standardmäßig aus; ein Abwählen löscht ein zuvor gespeichertes Passwort.",
+  "remoteMachines.saveHintKeptTerminal": "Im Betriebssystem-Schlüsselbund aufbewahrt — eine Terminal-Anmeldung wird von Eldrun nicht gesehen, daher wird weder gespeichert noch gelöscht.",
+  "remoteMachines.saveHintNothingTerminal": "Bei einer Terminal-Anmeldung gibt es nichts zu speichern — Eldrun sieht es nie.",
+  "remoteMachines.saveHintSavedWillAskAgainOff": "Im Betriebssystem-Schlüsselbund gespeichert — der Connect dieser Maschine fragt nicht erneut. Ausschalten, um es zu löschen.",
+  "remoteMachines.saveHintWillSave": "Wird in deinem Betriebssystem-Schlüsselbund gespeichert, sodass der Connect dieser Maschine nicht erneut fragt.",
+  "remoteMachines.saveHintNotSavedPre": "Nur zum Anmelden verwendet — nicht gespeichert. Aktiviere",
+  "remoteMachines.saveHintNotSavedPost": "um es zu behalten.",
+  "remoteMachines.loginTermHint": "Melde dich unten an — der Ordnerauswahldialog öffnet sich von selbst, sobald diese Anmeldung abgeschlossen ist.",
+  "remoteMachines.retryBrowseTitle": "Wenn du dich oben fertig angemeldet hast, durchsuche jetzt diese Maschine.",
+  "remoteMachines.waitingForLogin": "Warte auf die Anmeldung…",
+  "remoteMachines.loggedInBrowse": "Ich bin angemeldet — durchsuchen",
+  "remoteMachines.openLoginTerminal": "Anmeldeterminal öffnen",
+  "remoteMachines.loggingIn": "Wird angemeldet…",
+  "remoteMachines.logIn": "Anmelden",
+  "remoteMachines.loggedInToPre": "Angemeldet bei",
+  "remoteMachines.sharedFsToggleTitleStep2": "Aus (Standard): Diese Maschine teilt sich den Projektordner der primären Maschine über ein gemeinsames Dateisystem — keine Kopie, kein Git. An: Gib ihr eine eigene, einseitig synchronisierte Kopie des Codes (für Hosts, die keinen Speicher teilen).",
+  "remoteMachines.syncCopyDescOn": "Diese Maschine behält ihre eigene Kopie des Codes, einseitig von der primären Maschine synchronisiert. Navigiere zum (oder erstelle den) Ordner für diese Kopie.",
+  "remoteMachines.syncCopyDescOff": "Diese Maschine teilt sich den Projektordner der primären Maschine über ein gemeinsames Dateisystem — keine Kopie, kein Git. Navigiere zu diesem Ordner auf dieser Maschine.",
+  "remoteMachines.remotePathForCopy": "Remote-Pfad für die Kopie dieser Maschine",
+  "remoteMachines.pathToProject": "Pfad zum Projekt auf dieser Maschine",
+  "remoteMachines.reconnect": "Erneut verbinden",
+  "remoteMachines.browseEllipsis": "Durchsuchen…",
+  "remoteMachines.browserFooter": "Navigiere zu einem Ordner und klicke dann auf „Diesen Ordner verwenden“.",
+  "remoteMachines.labelOptional": "Bezeichnung (optional)",
+  "remoteMachines.labelPlaceholder": "z. B. gpu-2",
+  "remoteMachines.enterAbsolutePath": "Gib einen absoluten Remote-Pfad an (z. B. /home/me/project)",
+  "remoteMachines.enterHostBeforeBrowsing": "Gib vor dem Durchsuchen einen Host als [user@]host[:port] an",
+  "remoteMachines.enterHostBeforeLogin": "Gib vor der Anmeldung einen Host als [user@]host[:port] an",
+  "remoteMachines.enterHost": "Gib einen Host als [user@]host[:port] an",
+  "remoteMachines.noOutputFiles": "Keine Ausgabedateien zum Holen.",
+  "remoteMachines.pullConfirm": "{files} Ausgabedatei(en) ({bytes}) von dieser Maschine auf deinen Rechner holen?",
+  "remoteMachines.pulledResult": "{pulled} Datei(en) geholt → {dest}{errs}",
+  "remoteMachines.pullErrorsSuffix": " ({count} fehlgeschlagen)",
+  "remoteMachines.pullFailed": "Holen fehlgeschlagen: {error}",
+  "hpcWizard.stepLogin": "Anmeldung",
+  "hpcWizard.stepProject": "Projekt",
+  "hpcWizard.stepWorkspace": "Workspace",
+  "hpcWizard.stepData": "Daten laden",
+  "hpcWizard.stepRun": "Job ausführen",
+  "hpcWizard.stepWatch": "Beobachten",
+  "hpcWizard.sbatchJobName": "Job-Name",
+  "hpcWizard.sbatchPartition": "Partition",
+  "hpcWizard.sbatchTime": "Zeit",
+  "hpcWizard.sbatchNodes": "Knoten",
+  "hpcWizard.sbatchTasks": "Tasks",
+  "hpcWizard.sbatchCpusPerTask": "CPUs/Task",
+  "hpcWizard.sbatchMemory": "Speicher",
+  "hpcWizard.sbatchGres": "GRES",
+  "hpcWizard.sbatchOutput": "Ausgabe",
+  "hpcWizard.title": "HPC-Pipeline",
+  "hpcWizard.loginHint": "Melde dich an deinem Cluster an. Wenn er nur über das VPN deiner Institution erreichbar ist, baue zuerst den OpenVPN-Tunnel auf (im SSH-Bereich unten).",
+  "hpcWizard.projectNameLabel": "Projektname",
+  "hpcWizard.mirrorLabel": "Lokaler Ort (synchronisierter Spiegel)",
+  "hpcWizard.noFolderSelected": "Kein Ordner ausgewählt",
+  "hpcWizard.browseBtn": "Durchsuchen...",
+  "hpcWizard.hostPathHintPre": "Auf dem Host:",
+  "hpcWizard.hostPathHintPost": "— der nächste Schritt kann dies in einen Workspace auf dem parallelen Dateisystem des Clusters verschieben.",
+  "hpcWizard.watchPre": "Dein Job wurde übermittelt, und ein Log-Tab verfolgt jetzt seine Ausgabe. Öffne die Jobs-Ansicht (das",
+  "hpcWizard.watchMid": "Umschalter im Dateipanel), um ihn in der Warteschlange, beim Laufen und beim Abschluss zu sehen — mit job-eigenem",
+  "hpcWizard.watchWatchWord": "Beobachten",
+  "hpcWizard.watchCancelWord": "Abbrechen",
+  "hpcWizard.watchAnd": "und",
+  "hpcWizard.done": "Fertig",
+  "hpcWizard.noToolingPre": "Dieser Host hat keine Workspace-Tools (",
+  "hpcWizard.noToolingPost": ").",
+  "hpcWizard.noToolingScratchHint": "Er verweist jedoch auf ein großes Dateisystem — wähle, wo dieses Projekt liegen soll, da ein Home-Verzeichnis meist quotiert und für Code gedacht ist.",
+  "hpcWizard.noToolingNoScratchPre": "Das Projekt wird in dem Ordner liegen, zu dem du navigiert hast:",
+  "hpcWizard.homeRadioLabel": "Home",
+  "hpcWizard.readOnly": "schreibgeschützt",
+  "hpcWizard.projectOnHostLabel": "Projekt auf dem Host:",
+  "hpcWizard.creating": "Wird erstellt…",
+  "hpcWizard.createProject": "Projekt erstellen",
+  "hpcWizard.introPre": "Auf einem Cluster ist dein Home-Verzeichnis ein kleines, quotiertes Dateisystem, das für Code gedacht ist. Die Daten einer Berechnung gehören in einen",
+  "hpcWizard.introStrongWorkspace": "Workspace",
+  "hpcWizard.introMid": "— ein Verzeichnis auf dem parallelen Dateisystem mit einem Namen und einer Dauer, das",
+  "hpcWizard.introStrongDeleted": "beim Ablauf gelöscht wird",
+  "hpcWizard.introPost": ". Fordere jetzt einen an, bevor Daten hochgeladen oder synchronisiert werden.",
+  "hpcWizard.checkingTooling": "Prüft den Host auf Workspace-Tools…",
+  "hpcWizard.workspaceNameLabel": "Workspace-Name",
+  "hpcWizard.daysLabel": "Tage",
+  "hpcWizard.filesystemLabel": "Dateisystem",
+  "hpcWizard.siteDefault": "(Standard der Seite)",
+  "hpcWizard.defaultSuffix": " (Standard)",
+  "hpcWizard.reminderEmailLabel": "Erinnerungs-E-Mail",
+  "hpcWizard.optionalPlaceholder": "optional",
+  "hpcWizard.remindDaysLabel": "Tage vorher erinnern",
+  "hpcWizard.reminderHint": "Eine Erinnerung lohnt sich — beim Ablauf werden die Daten gelöscht. Viele Seiten liefern nur an die eigene Domain zu.",
+  "hpcWizard.allocating": "Wird zugewiesen…",
+  "hpcWizard.allocateWorkspace": "Workspace zuweisen",
+  "hpcWizard.readingWorkspaces": "Liest deine Workspaces…",
+  "hpcWizard.yourWorkspaces": "Deine Workspaces",
+  "hpcWizard.whereProjectGoes": "Wohin das Projekt kommt",
+  "hpcWizard.inWorkspaceStrong": "Im Workspace",
+  "hpcWizard.inWorkspaceDesc": "— alles, was Eldrun synchronisiert (Dateien, Git, Uploads), landet auf dem parallelen Dateisystem, nie in deiner Home-Quota.",
+  "hpcWizard.inBrowsedStrong": "Im durchsuchten Ordner",
+  "hpcWizard.inBrowsedDesc": ", wobei der Workspace verlinkt ist als",
+  "hpcWizard.linkNameLabel": "Link-Name",
+  "hpcWizard.anchorPre": "Behalte einen kleinen Ordner in meinem Cluster-Home für dieses Projekt — Job",
+  "hpcWizard.anchorMid": ", ein",
+  "hpcWizard.anchorPost": "-Link und einen Eintrag, der den Workspace benennt. Er überlebt den Ablauf des Workspace (dort wird nichts Großes abgelegt, und Eldrun synchronisiert ihn nie).",
+  "hpcWizard.anchorFolderLabel": "Ordner (unter deinem Home)",
+  "hpcWizard.createWithoutWorkspace": "Ohne Workspace erstellen",
+  "hpcWizard.dataHintPre": "Lade optional Eingabedateien hoch. Sie landen in",
+  "hpcWizard.dataHintWorkspaceSuffix": "— auf dem parallelen Dateisystem, nicht in deiner Home-Quota.",
+  "hpcWizard.dataHintPlainSuffix": ".",
+  "hpcWizard.dataHintPost": "Große Baumstrukturen markierst du besser als Auto-Sync im Dateipanel; dies ist für ein paar Dateien gedacht.",
+  "hpcWizard.theProjectFolder": "den Projektordner",
+  "hpcWizard.linkNotCreatedSuffix": "/ (Link nicht erstellt)",
+  "hpcWizard.uploading": "Wird hochgeladen…",
+  "hpcWizard.addFiles": "Dateien hinzufügen…",
+  "hpcWizard.skip": "Überspringen",
+  "hpcWizard.scriptHintPre": "Ein Starter-Batch-Skript (",
+  "hpcWizard.scriptHintPost": ") wird in das Projekt geschrieben. Passe seine Ressourcen an und übermittle es dann — es läuft auf einem Rechenknoten.",
+  "hpcWizard.submitting": "Wird übermittelt…",
+  "hpcWizard.submitJob": "⏫ Job übermitteln",
+  "projectDialog.installGitLabel": "Git installieren",
+  "projectDialog.installBinLabel": "{bin} installieren",
+  "projectDialog.titleNew": "Neues Projekt",
+  "projectDialog.titleImport": "Projekt importieren",
+  "projectDialog.remoteToggleTitle": "Remote-Projekt (SSH)",
+  "projectDialog.remoteToggleDesc": "Arbeite an einem Projekt, das auf einer anderen Maschine liegt — Terminals, Dateien und Git laufen alle über SSH auf dem Host.",
+  "projectDialog.localLocationLabel": "Lokaler Ort",
+  "projectDialog.noFolderSelected": "Kein Ordner ausgewählt",
+  "projectDialog.browseBtn": "Durchsuchen...",
+  "projectDialog.localMirrorHint": "Die synchronisierte lokale Arbeitskopie liegt hier als {name}.",
+  "projectDialog.projectNameLabel": "Projektname",
+  "projectDialog.descriptionLabel": "Projektbeschreibung",
+  "projectDialog.descFillModeTitle": "Ausfüllmodus für die Projektbeschreibung",
+  "projectDialog.fillModeManual": "Manuell",
+  "projectDialog.fillModeAgentChoice": "Agenten-Wahl",
+  "projectDialog.descriptionPlaceholder": "Wofür dieses Projekt gedacht ist",
+  "projectDialog.importFromLabel": "Importieren von",
+  "projectDialog.importFolderOpt": "Ordner auf diesem Rechner",
+  "projectDialog.importGitOpt": "GitHub-/GitLab-Repository (klonen)",
+  "projectDialog.importForkOpt": "GitHub-/GitLab-Repository (forken, dann klonen)",
+  "projectDialog.sourceFolderLabel": "Quellordner",
+  "projectDialog.repoToForkLabel": "Zu forkendes Repository",
+  "projectDialog.repoUrlLabel": "Repository-URL",
+  "projectDialog.forkHintPre": "Das Repository wird in dein eigenes Konto geforkt, und dein Fork ist es, der hier geklont wird — das Original bleibt als",
+  "projectDialog.forkHintMid": "-Remote erhalten. Das Forken läuft über die CLI des Anbieters (",
+  "projectDialog.forkHintPost": "), verwendet also deren Login.",
+  "projectDialog.cloneHintPrivateConnected": "Ein privates Repository wird mit dem Zugriffstoken aus Einstellungen → Git-Hosting geklont. Eine SSH-URL (git@…) verwendet stattdessen deine eigenen SSH-Schlüssel.",
+  "projectDialog.cloneHintPublicOnly": "Öffentliche Repositories werden unverändert geklont. Für ein privates füge ein Zugriffstoken in Einstellungen → Git-Hosting hinzu, oder verwende eine SSH-URL (git@…), um dich mit deinen SSH-Schlüsseln zu authentifizieren.",
+  "projectDialog.hostTypeLabel": "Host-Typ",
+  "projectDialog.detectFromUrl": "Aus der URL erkennen",
+  "projectDialog.detectFromUrlWithProvider": "Aus der URL erkennen ({provider})",
+  "projectDialog.hostTypeHint": "Dieser Host nennt sich nicht selbst GitHub oder GitLab (eine selbst gehostete Instanz tut das meist nicht) — wähle, welcher es ist, da der Fork über die CLI dieses Anbieters erstellt wird.",
+  "projectDialog.forkCliMissingPre": "Kein",
+  "projectDialog.forkCliMissingMid1": "auf diesem Rechner gefunden — ein Fork wird von der eigenen CLI des Anbieters erstellt, installiere sie also (und melde dich an mit",
+  "projectDialog.forkCliMissingPost": ") um zu forken von",
+  "projectDialog.runInTerminalBtn": "Im Terminal ausführen",
+  "projectDialog.locationLabel": "Ort",
+  "projectDialog.cloneDestYourFork": "Dein Fork wird",
+  "projectDialog.cloneDestTheRepo": "Das Repository wird",
+  "projectDialog.cloneDestMid": "geklont nach",
+  "projectDialog.cloneDestPost": "hier.",
+  "projectDialog.gitHostingLabel": "Git-Hosting",
+  "projectDialog.gitNoneOpt": "Kein Git (nur Dateien, kein Repo)",
+  "projectDialog.gitLocalOpt": "Nur lokales Repo (wird nirgendwo gepusht)",
+  "projectDialog.gitRemotePrivateOpt": "Zu GitHub/GitLab pushen · privat",
+  "projectDialog.gitRemotePublicOpt": "Zu GitHub/GitLab pushen · öffentlich",
+  "projectDialog.gitHostingHintPre": "„Zu GitHub/GitLab pushen“ veröffentlicht das Repo auf einem Hosting-Dienst",
+  "projectDialog.gitHostingHintRemoteSuffix": "— unabhängig vom SSH-Host oben, der lediglich der Ort ist, an dem die Projektdateien liegen.",
+  "projectDialog.needsGitConnectionText": "In Eldrun ist noch keine GitHub/GitLab-Verbindung eingerichtet. Füge einen Zugriffstoken in Einstellungen → Git-Hosting hinzu, damit das Repo veröffentlicht werden kann.",
+  "projectDialog.setUpGitHostingBtn": "GitHub/GitLab einrichten…",
+  "projectDialog.needsGitInstallTextPre": "Kein Git auf diesem Rechner gefunden — installiere es, um ein git-basiertes Projekt zu erstellen",
+  "projectDialog.needsGitInstallOrClone": " oder ein Repository zu klonen",
+  "projectDialog.importModeLabel": "Importmodus",
+  "projectDialog.modeKeepOpt": "Ort beibehalten (in Ort registrieren)",
+  "projectDialog.modeCopyOpt": "In Eldruns Projektordner kopieren",
+  "projectDialog.modeMoveOpt": "In Eldruns Projektordner verschieben",
+  "projectDialog.remoteImportKeepsFolder": "Der Remote-Import belässt den Ordner unverändert auf dem Remote-Host.",
+  "projectDialog.skipScaffoldLabel": "Scaffolding überspringen (keine Scaffold-Dateien erzeugen)",
+  "projectDialog.scaffoldGuidanceAria": "Scaffold-Anleitung für den Import",
+  "projectDialog.importGuidanceTitle": "Import-Anleitung",
+  "projectDialog.stepSelectSource": "Wähle den Quellordner und die Projektmetadaten.",
+  "projectDialog.stepRegisterKeep": "Registriere das Projekt an seinem aktuellen Ort.",
+  "projectDialog.stepCopyValidate": "Kopiere das Projekt nach manueller Validierung in Eldruns Projektordner.",
+  "projectDialog.stepMoveValidate": "Verschiebe das Projekt nach manueller Validierung in Eldruns Projektordner.",
+  "projectDialog.stepCreateScaffold": "Erstelle fehlende Scaffold-Dateien und bestätige bereits vorhandene Dateien.",
+  "projectDialog.stepWriteProjectJson": "Schreibe project.json und füge das Projekt dem Umschalter hinzu.",
+  "projectDialog.manualValidationCopy": "Ich habe das Kopierziel und den Quellordner manuell validiert.",
+  "projectDialog.manualValidationMove": "Ich habe das Verschiebeziel und den Quellordner manuell validiert.",
+  "projectDialog.fillAllLabel": "Alle ausfüllen",
+  "projectDialog.noMissingFiles": "Keine fehlenden Dateien",
+  "projectDialog.chooseFillMode": "Ausfüllmodus wählen...",
+  "projectDialog.alreadyThere": "Bereits vorhanden",
+  "projectDialog.missingLabel": "Fehlt",
+  "projectDialog.alreadyThereKept": "Bereits vorhanden, wird beibehalten",
+  "projectDialog.missingWillAdd": "Fehlt, wird hinzugefügt",
+  "projectDialog.statusOnly": "Nur Status",
+  "projectDialog.chooseSourceToPreview": "Wähle einen Quellordner, um Scaffold-Dateien in der Vorschau zu sehen.",
+  "projectDialog.loadingScaffoldPreview": "Scaffold-Vorschau wird geladen...",
+  "projectDialog.remoteDestinationLabel": "Remote-Ziel: {path}",
+  "projectDialog.remoteLocationLabel": "Remote-Ort: {path}",
+  "projectDialog.changeFolderBtn": "Ordner ändern",
+  "projectDialog.changeFolderTitleWinManual": "Zurückgehen, um den Remote-Pfad zu ändern",
+  "projectDialog.changeFolderTitleBrowse": "Zurückgehen zum Remote-Browser, um einen anderen Ordner zu wählen",
+  "projectDialog.destinationLabel": "Ziel: {path}",
+  "projectDialog.locationColonLabel": "Ort: {path}",
+  "projectDialog.forking": "Wird geforkt...",
+  "projectDialog.cloningEllipsis": "Wird geklont...",
+  "projectDialog.working": "Wird bearbeitet...",
+  "projectDialog.create": "Erstellen",
+  "projectDialog.forkAndImport": "Forken & Importieren",
+  "projectDialog.cloneAndImport": "Klonen & Importieren",
+  "projectDialog.import": "Importieren",
+  "projectDialog.runInTerminalTitle": "Diesen Befehl in einem neuen Terminal-Tab ausführen",
+  "remoteProjectSection.vpnUpClickToReconnect": "OpenVPN-Tunnel ist aktiv. Klicken zum erneuten Verbinden.",
+  "remoteProjectSection.vpnFailedWithError": "VPN-Verbindung fehlgeschlagen: {error}",
+  "remoteProjectSection.vpnFailedClickRetry": "VPN-Verbindung fehlgeschlagen. Klicken zum erneuten Versuchen.",
+  "remoteProjectSection.vpnBringUpHint": "Baue jetzt den OpenVPN-Tunnel auf, um einen VPN-gesicherten Host zu erreichen.",
+  "remoteProjectSection.vpnSelectConfigFirst": "Wähle zuerst eine OpenVPN-Konfiguration.",
+  "remoteProjectSection.stepConnectLabel": "Verbinden",
+  "remoteProjectSection.stepBrowseLabel": "Durchsuchen",
+  "remoteProjectSection.stepDetailsLabel": "Details",
+  "remoteProjectSection.remoteStepsAria": "Schritte für das Remote-Projekt",
+  "remoteProjectSection.passwordAuthWarning": "Passwort-Authentifizierung benötigt OpenSSH 8.4+ oder sshpass — aktualisiere OpenSSH oder installiere sshpass, oder verwende SSH-Schlüssel (Passwort leer lassen).",
+  "remoteProjectSection.opensslMissingWarning": "openvpn/pkexec nicht gefunden — VPN-gesicherte Hosts können sich nicht verbinden. Installiere openvpn und polkit.",
+  "remoteProjectSection.vpnToggleDescLine1": "Nur nötig für einen VPN-gesicherten Host — lass es aus, wenn du dich bereits im richtigen Netzwerk befindest.",
+  "remoteProjectSection.vpnConfigLabel": "OpenVPN-Konfiguration",
+  "remoteProjectSection.vpnConfigCopiedHint": "(wird bei Auswahl in Eldrun kopiert)",
+  "remoteProjectSection.noOvpnSelected": "Keine .ovpn ausgewählt",
+  "remoteProjectSection.browseEllipsis": "Durchsuchen…",
+  "remoteProjectSection.storedWithProject": "(mit dem Projekt gespeichert)",
+  "remoteProjectSection.vpnUsernamePlaceholderNoDots": "OpenVPN-Kontobenutzername",
+  "remoteProjectSection.savedInKeychainYour": "(in deinem Betriebssystem-Schlüsselbund gespeichert)",
+  "remoteProjectSection.notStoredUnlessSaved": "(nicht gespeichert, außer du speicherst es unten)",
+  "remoteProjectSection.vpnAccountPasswordNoDots": "OpenVPN-Kontopasswort",
+  "remoteProjectSection.keyPassphrasePlaceholderNoDots": "Passphrase für den verschlüsselten Schlüssel der Konfiguration",
+  "remoteProjectSection.vpnTermBtnTitleActive": "Baue den OpenVPN-Tunnel in einem Terminal unten auf — gib die Passphrase dort ein. Er bleibt für das neue Projekt aktiv.",
+  "remoteProjectSection.vpnTermHintClosed": "Klicke oben, um hier ein Terminal zu öffnen — gib die Passphrase dort ein. Eldrun verarbeitet sie nie; der Tunnel bleibt für das neue Projekt aktiv.",
+  "remoteProjectSection.vpnTermHintOpen": "Authentifiziere den Tunnel unten — er läuft für das neue Projekt weiter, nachdem du diesen Dialog geschlossen hast.",
+  "remoteProjectSection.sshAddressLabel": "SSH-Adresse",
+  "remoteProjectSection.reuseSshAddressTitle": "Eine zuvor verwendete SSH-Adresse wiederverwenden",
+  "remoteProjectSection.sshAddressPlaceholder": "user@host oder host:2222",
+  "remoteProjectSection.passwordLabel": "Passwort",
+  "remoteProjectSection.notStoredBlankKey": "(nicht gespeichert, außer du speicherst es unten; leer verwendet den SSH-Schlüssel)",
+  "remoteProjectSection.sshSavedPlaceholder": "Verwendet gespeichertes Passwort — leer lassen",
+  "remoteProjectSection.sshPasswordPlaceholderNoDots": "Passwort oder die Passphrase deines Schlüssels — leer, wenn der Schlüssel entsperrt ist",
+  "remoteProjectSection.connectingDotsShort": "Verbindet...",
+  "remoteProjectSection.remotePathLabel": "Remote-Pfad",
+  "remoteProjectSection.remotePathHintNew": "(übergeordneter Ordner; das Projekt wird darin erstellt)",
+  "remoteProjectSection.remotePathHintImport": "(absoluter Pfad des vorhandenen Projekts)",
+  "remoteProjectSection.reuseRemotePathTitle": "Einen zuvor verwendeten Remote-Pfad für diesen Host wiederverwenden",
+  "remoteProjectSection.remotePathPlaceholder": "/home/user/projects",
+  "remoteProjectSection.sshTermBtnTitle": "Öffne die SSH-Anmeldung in einem Terminal unten — gib dort jedes Passwort ein. Die Anmeldung bleibt für das neue Projekt aktiv.",
+  "remoteProjectSection.tryBrowseTitle": "Wenn du dich oben fertig angemeldet hast, durchsuche jetzt den Remote-Baum.",
+  "remoteProjectSection.sshTermHintClosedPre": "Klicke oben, um hier ein Terminal zu öffnen — gib dort jedes Passwort ein. Eldrun verarbeitet es nie; die Anmeldung bleibt für das neue Projekt aktiv.",
+  "remoteProjectSection.sshTermHintClosedSuffix": " Sobald du angemeldet bist, öffnet sich der Remote-Baum zum Durchsuchen.",
+  "remoteProjectSection.sshTermHintOpen": "Melde dich unten an — die Sitzung läuft für das neue Projekt weiter, nachdem du diesen Dialog geschlossen hast.",
+  "remoteProjectSection.willCreateLabel": "Wird erstellt: {path}",
+  "remoteProjectSection.selectedLabel": "Ausgewählt: {path}",
+  "credentialPasteBar.typeItForMe": "Für mich eintippen:",
+  "credentialPasteBar.pastedFlash": "eingefügt",
+  "credentialPasteBar.nothingSavedFlash": "für diesen Login nichts gespeichert (oder der Schlüsselbund ist gesperrt)",
+  "credentialPasteBar.pasteUsername": "Benutzername einfügen",
+  "credentialPasteBar.pasteUsernameTitle": "Tippt „{user}“ an der Cursorposition in das Anmeldeterminal ein.",
+  "credentialPasteBar.pastePassword": "Passwort einfügen",
+  "credentialPasteBar.pastePasswordTitle": "Tippt das für diesen Login gespeicherte Passwort an der Cursorposition in das Terminal ein — es geht direkt von deinem Betriebssystem-Schlüsselbund ins Terminal, nie über die Eldrun-Oberfläche. Drücke Enter selbst.",
+  "credentialPasteBar.pasteVpnUsernameTitle": "Tippt den Auth-Benutzernamen dieses Tunnels an der Cursorposition in das Terminal ein.",
+  "credentialPasteBar.pastePassphrase": "Passphrase einfügen",
+  "credentialPasteBar.pasteVpnSecretTitle": "Tippt das für diesen Tunnel gespeicherte Geheimnis an der Cursorposition in das Terminal ein — direkt von deinem Betriebssystem-Schlüsselbund ins Terminal. Drücke Enter selbst.",
+  "credentialPasteBar.pasteKeyPassphrase": "Schlüssel-Passphrase einfügen",
+  "credentialPasteBar.pasteKeyPassphraseTitle": "Tippt die gespeicherte Passphrase des privaten Schlüssels an der Cursorposition in das Terminal ein — OpenVPN fragt sie getrennt vom Kontopasswort ab.",
+  "terminalSignIn.sshHostWord": "SSH-Host",
+  "terminalSignIn.vpnTunnelWord": "OpenVPN-Tunnel",
+  "terminalSignIn.busyTitle": "Trenne zuerst das Anmeldeterminal unten.",
+  "terminalSignIn.titleTemplate": "Melde dich hier in einem Terminal am {what} an statt in diesen Feldern. Er stellt seine eigenen Fragen — ein Passwort, einen Challenge-Code, eine zweite Aufforderung — und du beantwortest sie direkt; Eldrun sieht sie nie. Nur für diese Verbindung: deine Headless-Einstellung bleibt unverändert.",
+  "terminalSignIn.label": "In einem Terminal anmelden",
+  "terminalSignIn.failedHint": "die Anmeldung ist fehlgeschlagen — wenn {what} nach etwas anderem als einem Passwort fragt (ein Challenge-Code, eine zweite Aufforderung), kann nur ein Terminal antworten",
+  "terminalSignIn.defaultHint": "für einen Host, der mehr als ein Passwort verlangt — einen Challenge-Code, eine zweite Aufforderung",
+  "projectHoverCard.statusCurrent": "Aktuell",
+  "projectHoverCard.statusActive": "Aktiv",
+  "projectHoverCard.statusInactive": "Inaktiv",
+  "projectHoverCard.timeUnderMinute": "< 1 Min.",
+  "projectHoverCard.cpuIdle": "inaktiv",
+  "projectHoverCard.remoteLabel": "remote",
+  "projectHoverCard.localLabel": "lokal",
+  "projectHoverCard.originLabel": "Ursprung",
+  "projectHoverCard.todayPrefix": "Heute:",
+  "projectHoverCard.pausedSuffix": "(pausiert)",
+  "projectHoverCard.cpuPrefix": "CPU:",
+  "windowControls.minimize": "Minimieren",
+  "windowControls.maximize": "Maximieren",
+  "connTypeIcon.offlineSuffix": " (offline)",
+  "appTimer.globalActivityTitle": "Globale Aktivität",
+  "appTimer.pausedResumeHint": "Pausiert — klicken zum Fortsetzen",
+  "appTimer.clickPauseHint": "Klicken zum Pausieren • Rechtsklick für Aktivität",
+  "appResource.processCountOne": "{count} Eldrun-Prozess",
+  "appResource.processCountMany": "{count} Eldrun-Prozesse",
+  "appResource.gpuNoDeviceTitle": "Vom lokalen Modellen (Ollama) genutzter GPU-Speicher — die GPU dieses Rechners meldet keinen eigenen Speicher",
+  "remoteConnMenu.statusError": "Fehler",
+  "remoteConnMenu.statusConnecting": "verbindet",
+  "remoteConnMenu.statusConnected": "verbunden",
+  "remoteConnMenu.statusOff": "aus",
+  "remoteConnMenu.ariaLabel": "Remote-Maschinen — klicken, um die Hosts dieses Projekts zu verbinden/verwalten",
+  "remoteConnMenu.workingWord": "aktiv",
+  "vpnIndicator.keyringStayedLocked": "Der Schlüsselbund blieb gesperrt — gespeicherte VPN-Zugangsdaten können noch nicht gelesen werden.",
+  "vpnIndicator.keyringLockedConnectReason": "Dein Betriebssystem-Schlüsselbund ist gesperrt, daher können die gespeicherten VPN-Zugangsdaten nicht gelesen werden. Entsperre ihn (oder gib die Passphrase unten ein), um dich zu verbinden.",
+  "vpnIndicator.savedCredentialsDidntWork": "Die gespeicherten VPN-Zugangsdaten haben nicht funktioniert: {error}",
+  "vpnIndicator.noCredentialStore": "Dieser Rechner hat keinen Zugangsdatenspeicher, daher kann für diesen Tunnel nichts gespeichert werden.",
+  "vpnIndicator.noSavedCredentialsYet": "Noch keine gespeicherten Zugangsdaten für diesen Tunnel — aktiviere „Anmeldedaten speichern“, um dies beim nächsten Mal zu überspringen.",
+  "vpnIndicator.enterCredentialsOnce": "Gib die Zugangsdaten einmal ein — sie gelangen in deinen Betriebssystem-Schlüsselbund, und dieser Tunnel verbindet sich ab jetzt ohne nachzufragen.",
+  "vpnIndicator.saveCredentialsAria": "Anmeldedaten für {file} speichern",
+  "vpnIndicator.saveCredsUnavailableTitle": "Dieser Rechner hat keinen Betriebssystem-Zugangsdatenspeicher, daher kann nichts gespeichert werden.",
+  "vpnIndicator.saveCredsSavedTitle": "Die Zugangsdaten für diesen Tunnel befinden sich in deinem Betriebssystem-Schlüsselbund — beim Verbinden wird nicht nachgefragt. Ausschalten, um sie zu löschen.",
+  "vpnIndicator.saveCredsNotSavedTitle": "Frage einmal nach den Zugangsdaten dieses Tunnels, bewahre sie in deinem Betriebssystem-Schlüsselbund auf und verbinde dich danach ohne nachzufragen.",
+  "vpnIndicator.saveLoginCredentialsLabel": "Anmeldedaten speichern",
+  "vpnIndicator.savedButLocked": "Gespeichert, aber dein Schlüsselbund ist gesperrt — entsperre ihn oben, um sie zu verwenden.",
+  "vpnIndicator.connectOnLaunchAria": "{file} beim Start verbinden",
+  "vpnIndicator.connectOnLaunchHeadlessTitle": "Baut diesen Tunnel automatisch beim Start von Eldrun auf, unter Verwendung der gespeicherten Zugangsdaten — ohne Nachfrage. Er leitet diesen Rechner ab dem Start um.",
+  "vpnIndicator.connectOnLaunchInteractiveTitle": "Öffnet den Verbindungsbefehl dieses Tunnels beim Start von Eldrun im Root-Terminal, damit du dich authentifizieren kannst. Er leitet diesen Rechner um, sobald er aktiv ist.",
+  "vpnIndicator.connectOnLaunchLabel": "Beim Start verbinden",
+  "vpnIndicator.needSaveCredsFirstHintPre": "Aktiviere",
+  "vpnIndicator.needSaveCredsFirstHintPost": "zuerst — Auto-Connect fragt nie nach, daher wird es nur angeboten, sobald die Verbindung ohne Nachfrage möglich ist.",
+  "vpnIndicator.startsWithEldrun": "Startet mit Eldrun",
+  "vpnIndicator.waitsInRootTerminal": " (wartet im Root-Terminal)",
+  "vpnIndicator.mainAriaLabel": "OpenVPN — einen Tunnel verbinden oder trennen",
+  "vpnIndicator.titleOff": "OpenVPN — kein Tunnel. Ein Verbinden leitet den Datenverkehr dieses Rechners darüber.",
+  "vpnIndicator.titleConnecting": "OpenVPN — verbindet. Sobald er aktiv ist, läuft der Datenverkehr dieses Rechners über den Tunnel.",
+  "vpnIndicator.titleConnected": "OpenVPN — aktiv. Der Datenverkehr dieses Rechners läuft über den Tunnel.",
+  "vpnIndicator.vpnLabel": "VPN",
+  "vpnIndicator.note": "Ein Tunnel leitet",
+  "vpnIndicator.noteStrong": "den gesamten Datenverkehr dieses Rechners",
+  "vpnIndicator.notePost": "— nicht nur den von Eldrun — einschließlich deines Browsers — solange er aktiv ist.",
+  "vpnIndicator.lockedBannerPre": "Dein Betriebssystem-Schlüsselbund ist",
+  "vpnIndicator.lockedBannerStrong": "gesperrt",
+  "vpnIndicator.lockedBannerPost": ", daher können gespeicherte VPN-Zugangsdaten nicht gelesen werden — beim Verbinden wird erneut danach gefragt, bis er entsperrt ist.",
+  "vpnIndicator.unlockTitle": "Entsperrt den Betriebssystem-Zugangsdatenspeicher, damit die gespeicherten Zugangsdaten verwendet werden können. Dein Desktop fragt nach dem Schlüsselbund-Passwort.",
+  "vpnIndicator.unlocking": "Wird entsperrt…",
+  "vpnIndicator.unlockKeyring": "Schlüsselbund entsperren",
+  "vpnIndicator.heldForPrefix": "für",
+  "vpnIndicator.heldByNoProject": "wird von keinem Projekt gehalten",
+  "vpnIndicator.stopConnectingTitle": "Beendet den Versuch, diesen Tunnel aufzubauen, und stellt die normale Routing wieder her.",
+  "vpnIndicator.stopConnecting": "Verbindung abbrechen",
+  "vpnIndicator.disconnectTunnelTitle": "Bringt diesen Tunnel herunter und stellt die normale Routing wieder her. Projekte, die ihn nutzen, bleiben geöffnet; ihr SSH übersteht das eventuell nicht.",
+  "vpnIndicator.disconnectTunnel": "Tunnel trennen",
+  "vpnIndicator.connectGroupLabel": "Verbinden",
+  "vpnIndicator.removeConfigHint": "Entfernt diese Konfiguration aus Eldrun und vergisst ihre gespeicherten Zugangsdaten.",
+  "vpnIndicator.usedByPre": "Verwendet von",
+  "vpnIndicator.usedByPost": "— beim Verbinden dieses Projekts wird erneut nach einer Konfiguration gefragt.",
+  "vpnIndicator.removeConfigBtn": "Konfiguration entfernen",
+  "vpnIndicator.keepBtn": "Behalten",
+  "vpnIndicator.connectTunnelTitle": "Baut diesen Tunnel auf. Er wird den Datenverkehr dieses Rechners umleiten — nicht nur den von Eldrun.",
+  "vpnIndicator.removeConfigTitle": "Entfernt diese gespeicherte Konfiguration aus Eldrun und vergisst ihre gespeicherten Zugangsdaten. Fragt vor der Ausführung noch einmal nach.",
+  "vpnIndicator.emptyStatePre": "Noch keine OpenVPN-Konfiguration gespeichert — füge eine",
+  "vpnIndicator.emptyStatePost": "-Datei hinzu, dann verbinde sie über ihre Zeile (dort wird nach deinem Passwort gefragt).",
+  "vpnIndicator.addFirstConfigTitle": "Wähle eine .ovpn-Datei und speichere sie in Eldrun. Das Hinzufügen verbindet nicht — du verbindest sie danach explizit, wobei nach deinem Passwort gefragt wird.",
+  "vpnIndicator.addAnotherConfigTitle": "Wähle eine weitere .ovpn-Datei und speichere sie in Eldrun. Das Hinzufügen verbindet nicht — du verbindest sie danach explizit über ihre Zeile.",
+  "vpnIndicator.addConfigBtn": "Konfiguration hinzufügen…",
+};
+
+const es: Dict = {
+  "common.back": "Atrás",
+  "common.cancel": "Cancelar",
+  "common.remove": "Quitar",
+  "common.delete": "Eliminar",
+  "common.add": "Añadir",
+  "common.reset": "Restablecer",
+  "common.recheck": "Volver a comprobar",
+  "common.loading": "Cargando…",
+  "common.default": "predeterminado",
+
+  "settings.title": "Configuración",
+  "settings.theme": "Tema",
+  "settings.language": "Idioma",
+  "settings.language.help":
+    "Establece el idioma de la interfaz de Eldrun. Se aplica al instante — sin reiniciar.",
+  "settings.runScriptsBg": "Ejecutar scripts en segundo plano",
+  "settings.claudeRemote": "Control remoto de Claude",
+  "settings.headlessRemote": "Conexiones remotas en segundo plano",
+  "settings.persistLocal": "Sesiones locales persistentes (tmux)",
+  "settings.remoteFeatures": "Funciones remotas",
+  "settings.vpnEnabled": "Control del túnel OpenVPN",
+  "settings.machinesEnabled": "Máquinas remotas globales",
+  "settings.energySaver": "Ahorro de energía",
+  "energy.off": "Desactivado",
+  "energy.battery": "Con batería",
+  "energy.always": "Siempre",
+  "settings.debug": "Modo de depuración",
+  "settings.experimental": "Experimental",
+  "settings.agentModeToggle": "Alternar Plan/Auto en pestañas de agente",
+  "settings.pythonRunDebug": "Ejecutar/Depurar Python en el visor de código",
+  "settings.resourceMonitor": "Monitor de recursos",
+  "settings.showCpu": "Mostrar uso de CPU",
+  "settings.showRam": "Mostrar uso de RAM",
+  "settings.showGpu": "Mostrar uso de GPU",
+  "settings.showClockSeconds": "Mostrar segundos en el reloj de cabecera",
+
+  "settings.calendar": "Calendario",
+  "settings.weekStartsOn": "La semana empieza el",
+  "day.sunday": "Domingo",
+  "day.monday": "Lunes",
+  "settings.defaultView": "Vista predeterminada",
+  "view.day": "Día",
+  "view.week": "Semana",
+  "view.multiweek": "Varias semanas",
+  "view.month": "Mes",
+  "view.agenda": "Agenda",
+  "view.tasks": "Tareas",
+  "settings.clock24": "Reloj de 24 horas",
+  "settings.dayGridStart": "La cuadrícula del día empieza a las",
+  "settings.defaultReminder": "Recordatorio predeterminado",
+  "reminder.none": "Ninguno",
+  "reminder.5": "5 minutos antes",
+  "reminder.15": "15 minutos antes",
+  "reminder.30": "30 minutos antes",
+  "reminder.60": "1 hora antes",
+  "reminder.1440": "1 día antes",
+
+  "settings.hintsOnboarding": "Sugerencias e introducción",
+  "settings.showHints": "Mostrar sugerencias contextuales",
+  "settings.howToStart": "Cómo empezar...",
+  "settings.takeTour": "Hacer un recorrido",
+  "settings.lessons": "Lecciones",
+  "settings.resetHints": "Restablecer sugerencias",
+
+  "settings.layout": "Diseño",
+  "settings.windowZoom": "Zoom de ventana",
+  "settings.minSubWidth": "Ancho mín. de subventana (px)",
+  "settings.minSubHeight": "Alto mín. de subventana (px)",
+
+  "settings.downloads": "Descargas",
+  "settings.noDownloadFolders":
+    "No se han añadido carpetas — se usa la carpeta de Descargas del sistema.",
+  "settings.addDownloadFolder": "Añadir carpeta de descargas...",
+
+  "settings.usageStats": "Estadísticas de uso",
+  "settings.dailyRecap": "Mostrar el resumen al inicio de cada día",
+  "settings.openUsageStats": "Abrir estadísticas de uso",
+
+  "settings.moreSettings": "Más ajustes",
+  "nav.git.title": "Alojamiento Git",
+  "nav.git.blurb": "Perfil de alojamiento, token de acceso y publicación.",
+  "nav.vpn.title": "Conexión automática VPN",
+  "nav.vpn.blurb": "Activar un túnel guardado para conectar al arrancar.",
+  "nav.remoteHosts.title": "Conexiones remotas",
+  "nav.remoteHosts.blurb": "Definir una ruta estándar por host SSH.",
+  "nav.global.title": "Apps globales",
+  "nav.global.blurb": "Lanzadores de la barra mostrados en todos los proyectos.",
+  "nav.filetypes.title": "Apps por tipo de archivo",
+  "nav.filetypes.blurb": "Elegir qué app abre cada tipo de archivo.",
+  "nav.agents.title": "Gestionar agentes",
+  "nav.agents.blurb": "Instalar o actualizar las CLI de los agentes.",
+  "nav.shortcuts.title": "Atajos de teclado",
+  "nav.shortcuts.blurb": "Reasignar los atajos de navegación.",
+  "nav.archive.title": "Proyectos archivados",
+  "nav.archive.blurb": "Restaurar o eliminar permanentemente proyectos archivados.",
+  "nav.scaffoldRepair.title": "Reparar estructura del proyecto",
+  "nav.scaffoldRepair.blurb": "Regenerar archivos de estructura que falten.",
+  "nav.help.title": "Guía de funciones",
+  "nav.help.blurb": "Glosario completo de las funciones de Eldrun.",
+  "settings.energyUnavailable": "Estado de energía no disponible — se trata como con corriente (inactivo).",
+  "settings.energyActiveAlways": "Actualmente activo — siempre encendido.",
+  "settings.energyActiveBattery": "Actualmente activo — funcionando con batería.",
+  "settings.energyOff": "Desactivado — nunca limita el rendimiento.",
+  "settings.energyInactive": "Inactivo — con corriente.",
+  "settings.claudeRemoteHelp1": "Genera pestañas de agente Claude con",
+  "settings.claudeRemoteHelp2": "para que puedas monitorearlas y dirigirlas desde la app o la web de Claude. Requiere iniciar sesión con una suscripción de Claude (no una clave de API); solo Claude lo admite.",
+  "settings.headlessRemoteHelp": "Cuando está activado (por defecto), Eldrun establece conexiones SSH/OpenVPN en segundo plano, gestionando la contraseña de forma transitoria. Desactívalo para abrir en su lugar cada conexión como una terminal interactiva en la raíz de Eldrun — escribes la contraseña directamente en esa terminal y Eldrun nunca la maneja.",
+  "settings.persistLocalHelp1": "Cuando está activado (por defecto), la shell y las pestañas de Python/script de un proyecto local se ejecutan dentro de una sesión tmux en esta máquina, así una ejecución larga sigue si Eldrun falla, y la pestaña se reconecta al reiniciar. Cerrar una pestaña sigue terminando su sesión. Requiere",
+  "settings.persistLocalHelp2": "; las pestañas de agente no se ven afectadas.",
+  "settings.remoteFeaturesHelp": "Ambas añaden un control a nivel de máquina en la cabecera: un túnel OpenVPN (redirige el tráfico de todo este ordenador mientras esté activo) y una lista de máquinas SSH que no pertenecen a ningún proyecto. Desactivado por defecto; se pregunta una vez en el primer inicio.",
+  "settings.energyHelp": "Cuando está activo, Eldrun se relaja para ahorrar energía: pausa el giro inactivo del blob del proyecto, calma los brillos de estado y ralentiza las actualizaciones en segundo plano. «Con batería» (por defecto) solo lo hace mientras está desenchufado.",
+  "settings.experimentalHelp1": "Funciones que aún están en evolución. Cada una está desactivada por defecto y",
+  "settings.experimentalHelpBold": "activada por defecto en el modo de depuración",
+  "settings.experimentalHelp2": "— así que compilar Eldrun significa verlas sin tener que marcar de nuevo esta lista cada vez que llega una nueva. Un interruptor aquí siempre gana, en cualquier dirección: puedes activar una sin el modo de depuración, o desactivar una estando en él.",
+  "settings.agentModeHelp1": "Coloca una insignia en cada pestaña de agente que la alterna entre",
+  "settings.agentModeHelp2": "(lee y propone, nunca edita) y",
+  "settings.agentModeHelp3": "(acepta ediciones automáticamente; los comandos de shell y red siguen preguntando) — así una pestaña puede planificar mientras otra hace el trabajo, y cada una vuelve a su modo tras un reinicio. Cambiar reinicia el agente: la conversación se reanuda, pero el historial de la terminal se pierde. Solo Claude lo admite — es el único agente que puede tanto lanzarse en un modo como reanudar su conversación al reiniciar.",
+  "settings.pythonRunHelp1": "Da a un archivo",
+  "settings.pythonRunHelp2": "abierto en el editor un botón",
+  "settings.pythonRunHelp3": "y un",
+  "settings.pythonRunHelp4": "botón, y convierte sus números de línea en un margen de puntos de interrupción. Ambos abren una pestaña de terminal en el proyecto — así se ejecutan en el host de un proyecto remoto y dentro del contenedor de uno en contenedor — y usan el propio intérprete del proyecto. Depurar es",
+  "settings.pythonRunHelp5": ", precargado con los puntos de interrupción del margen. Desactivado por defecto porque Ejecutar ejecuta el archivo. Ctrl+clic a una definición no está restringido: solo lee.",
+  "settings.resourceMonitorHelp": "CPU y RAM cubren el árbol de procesos propio de Eldrun; GPU muestra la VRAM en uso por los modelos locales cargados en Ollama. La pastilla aparece en la cabecera junto al temporizador.",
+  "settings.reminderHelp": "Los recordatorios se disparan como notificación de escritorio y como una ventana emergente en la app que puedes posponer. «La cuadrícula del día empieza a las» solo define hasta dónde se desplazan las vistas de día y semana — los eventos anteriores siguen ahí, justo por encima.",
+  "settings.zoomHelp1": "El zoom de ventana escala toda la interfaz de Eldrun — útil en monitores 4K / alta densidad. 100 % es el valor predeterminado. El zoom es",
+  "settings.zoomHelpBold": "por ventana",
+  "settings.zoomHelp2": ": esto ajusta la ventana principal, y cada subventana desprendida mantiene el suyo. Ctrl + / Ctrl − hacen zoom en la ventana enfocada y Ctrl 0 lo restablece.",
+  "settings.minSubwindowHelp": "El tamaño más pequeño al que se puede reducir una subventana arrastrando un divisor. Por defecto {px}px si se deja en blanco.",
+  "settings.downloadsHelp": "Carpetas escaneadas por la sección Descargas del panel derecho (el interruptor 📥), para copiar rápidamente archivos recién descargados a un proyecto. Solo lectura — Eldrun nunca cambia la ruta de descargas de ningún navegador. Por defecto, la carpeta de Descargas del sistema si está vacío.",
+  "settings.removeFolderTitle": "Quitar esta carpeta",
+  "settings.dailyRecapHelp": "Un resumen del día que acaba de terminar: qué agentes usaste y cuánto les preguntaste, archivos creados/modificados/eliminados, commits y tiempo por proyecto. Desactivar esto detiene la ventana emergente, no el conteo — todo permanece local.",
+
+  "shortcuts.help":
+    "Haz clic en un atajo y luego pulsa la nueva combinación de teclas. F11 (pantalla completa del sistema) y Escape (salir de pantalla completa) son fijos y no se pueden reasignar.",
+  "shortcuts.captureTitle": "Haz clic y luego pulsa una combinación de teclas",
+  "shortcuts.pressKeys": "Pulsa las teclas…",
+  "shortcuts.resetTitle": "Restablecer al valor predeterminado",
+
+  "git.help":
+    "Tu perfil de alojamiento y token de acceso se usan al publicar el repositorio de un proyecto en GitHub o GitLab.",
+  "git.profileUrl": "URL del perfil",
+  "git.profileUrlPlaceholder": "https://github.com/me o https://gitlab.com/me",
+  "git.accessToken": "Token de acceso",
+  "git.tokenPlaceholder": "ghp_... / glpat-...",
+
+  "vpn.autoConnectHelp":
+    "Activa un túnel OpenVPN guardado para que se conecte automáticamente al iniciar Eldrun. Redirige el tráfico de todo este ordenador — no solo el de Eldrun — mientras esté activo, así que solo puede haber una configuración activada a la vez; activar otra desactiva la primera. Las configuraciones guardadas se añaden desde el diálogo de conexión de un proyecto remoto o el menú VPN de la cabecera.",
+  "vpn.noConfig": "Aún no hay ninguna configuración de OpenVPN guardada. Añade una desde el diálogo de conexión de un proyecto remoto.",
+  "vpn.needsSavedPre": "Conéctate una vez con",
+  "vpn.needsSavedBold": "Guardar contraseña",
+  "vpn.needsSavedPost": "marcado para habilitar esto — la conexión automática nunca pregunta.",
+  "vpn.startsWithEldrun": "Se inicia con Eldrun",
+  "vpn.waitsInRootTerminal": "(espera en la terminal raíz)",
+
+  "archive.help":
+    "Los proyectos eliminados se guardan aquí para que puedas restaurarlos. La eliminación permanente borra la copia archivada y su historial de tiempo. Los archivos de un proyecto remoto (SSH) en su host nunca se tocan.",
+  "archive.empty": "No hay proyectos archivados.",
+  "archive.remoteTag": "remoto",
+  "archive.unsyncedVerifiedOne":
+    "{count} commit local en {branches} nunca se sincronizó con el host y se perderá. Los propios archivos del host no se ven afectados.",
+  "archive.unsyncedVerifiedMany":
+    "{count} commits locales en {branches} nunca se sincronizaron con el host y se perderán. Los propios archivos del host no se ven afectados.",
+  "archive.unsyncedUnverifiedOne":
+    "Este espejo contiene {count} commit que no se pudo verificar contra el host; eliminar descarta la copia local. Los propios archivos del host no se ven afectados.",
+  "archive.unsyncedUnverifiedMany":
+    "Este espejo contiene {count} commits que no se pudieron verificar contra el host; eliminar descarta la copia local. Los propios archivos del host no se ven afectados.",
+  "archive.typeToDelete": "Escribe «{name}» para eliminar",
+  "archive.deleteForever": "Eliminar para siempre",
+  "archive.deleting": "Eliminando…",
+  "archive.restore": "Restaurar",
+  "archive.restoring": "Restaurando…",
+  "archive.deletePermanently": "Eliminar permanentemente…",
+  "archive.typeDeleteAll": "Escribe «delete» para vaciar todo",
+  "archive.clearArchive": "Vaciar archivo",
+  "archive.clearing": "Vaciando…",
+  "archive.clearArchiveEllipsis": "Vaciar archivo…",
+
+  "scaffoldRepair.help":
+    "Completa cualquier archivo de estructura (AGENTS.md, CLAUDE.md, .claude/settings.json, …) o línea .gitignore predeterminada que falte en un proyecto — p. ej. porque se creó antes de añadir ese archivo/línea a la estructura predeterminada. Los archivos existentes nunca se sobrescriben; un .gitignore preexistente solo recibe las líneas predeterminadas que le faltan. Se ejecuta en todos los proyectos gestionados (carpeta local o, en proyectos remotos, su espejo local).",
+  "scaffoldRepair.runNow": "Reparar todos los proyectos ahora",
+  "scaffoldRepair.running": "Reparando…",
+  "scaffoldRepair.upToDate": "La estructura de todos los proyectos ya está actualizada.",
+
+  "help.title": "Ayuda de Eldrun",
+  "help.intro": "Una guía rápida de lo que hace cada parte de Eldrun. Pasa el cursor sobre los botones de la barra de herramientas para ver también sus atajos.",
+  "help.workspaceLayout.title": "Diseño del espacio de trabajo",
+  "help.workspaceLayout.introMac":
+    "Eldrun mantiene tu desarrollo asistido por IA en una sola ventana. Lleva el cursor a un borde de la pantalla para mostrar los paneles y pulsa F11 para pantalla completa.",
+  "help.workspaceLayout.introOther":
+    "Eldrun mantiene tu desarrollo asistido por IA en una sola ventana. Pulsa {key} mientras Eldrun está en primer plano para alternar los paneles, y F11 para pantalla completa.",
+  "help.workspaceLayout.item1.term": "Terminal raíz (▣)",
+  "help.workspaceLayout.item1.desc":
+    "La terminal de control que siempre vive en la carpeta raíz de Eldrun, independiente de cualquier proyecto.",
+  "help.workspaceLayout.item2.term": "Pastillas de proyecto",
+  "help.workspaceLayout.item2.desc":
+    "Una pastilla por proyecto activo en el selector de proyectos. Haz clic para cambiar; cada proyecto conserva su propia terminal y pestañas. Arrastra las pastillas para reordenarlas.",
+  "help.workspaceLayout.item3.term": "Panel central y pestañas",
+  "help.workspaceLayout.item3.desc":
+    "Las terminales del proyecto activo. Haz clic derecho en la barra de pestañas para añadir un agente Claude/Codex/Gemini o una shell simple, renombrar o cerrar pestañas. Arrastra las pestañas para reordenarlas.",
+  "help.workspaceLayout.item4.term": "Panel de archivos derecho",
+  "help.workspaceLayout.item4.desc":
+    "Una superposición de árbol de archivos para el proyecto activo. Abre archivos, renombra y alterna tipos de archivo ocultos. El panel recuerda la última carpeta por proyecto.",
+  "help.projects.title": "Proyectos",
+  "help.projects.item1.term": "Añadir (+)",
+  "help.projects.item1.desc":
+    "Crea un nuevo proyecto (genera archivos y un repositorio git en la carpeta de proyectos de Eldrun) o importa una carpeta existente sin tocar su contenido.",
+  "help.projects.item2.term": "Buscar inactivos",
+  "help.projects.item2.desc":
+    "El cuadro de búsqueda encuentra proyectos que no están abiertos actualmente; elige uno para activar su pastilla y terminal.",
+  "help.projects.item3.term": "Proyectos remotos (SSH)",
+  "help.projects.item3.desc":
+    "Los proyectos en un host remoto se montan localmente con sshfs y se comportan como cualquier otro proyecto. Requiere sshfs/FUSE instalado.",
+  "help.projects.item4.term": "Tareas",
+  "help.projects.item4.desc":
+    "Haz clic derecho en una pestaña para fijar, completar o borrar una tarea del agente. Las tareas persisten en el project.json del proyecto y pueden alimentar el prompt de un nuevo agente.",
+  "help.aiTerminals.title": "IA y terminales",
+  "help.aiTerminals.item1.term": "Agentes",
+  "help.aiTerminals.item1.desc":
+    "Abre un agente (claude, codex, gemini, vibe, aider, opencode, cursor, copilot, grok, qwen, openclaw) o una shell simple desde el menú + de la barra de pestañas. Los comandos que falten recurren a una shell; los agentes cerrados se reinician.",
+  "help.aiTerminals.item2.term": "Modelos Ollama",
+  "help.aiTerminals.item2.desc":
+    "Cuando Ollama está instalado, el menú de engranaje muestra los modelos locales. Ctrl+K abre el diálogo de prompt de modelo local para el contexto activo.",
+  "help.settingsExtras.title": "Ajustes y extras",
+  "help.settingsExtras.item1.term": "Ajustes (⚙)",
+  "help.settingsExtras.item1.desc":
+    "Tema, perfil/token de alojamiento Git, gestión del espacio de trabajo, scripts en segundo plano y modo de depuración.",
+  "help.settingsExtras.item2.term": "Integración del espacio de trabajo",
+  "help.settingsExtras.item2.desc":
+    "Aislamiento de escritorio virtual KDE/X11 por proyecto (solo Linux): las ventanas lanzadas de cada proyecto se ubican en su propio escritorio.",
+  "help.settingsExtras.item3.term": "Seguimiento de tiempo",
+  "help.settingsExtras.item3.desc":
+    "Eldrun registra el tiempo de sesión activo para que veas cuánto tiempo dedicas a cada proyecto.",
+
+  "globalApps.title": "Apps globales",
+  "globalApps.help": "Apps que permanecen visibles en todos los espacios de trabajo. Las apps marcadas aparecen en la barra superior.",
+  "globalApps.showRole": "Mostrar {role}",
+  "globalApps.notFoundPlaceholder": "no encontrado",
+
+  "filetypes.title": "Apps por tipo de archivo",
+  "filetypes.help": "Al hacer doble clic en un archivo del proyecto se abre con la app indicada abajo.",
+  "filetypes.extPlaceholder": ".ext",
+  "filetypes.appPlaceholder": "comando de la app",
+
+  "remoteHosts.help":
+    "La carpeta en la que se abre un connect o browse para un host SSH dado, en lugar del directorio de inicio del host. Se establece una vez aquí y se aplica la próxima vez que te conectes a ese host — tanto para el explorador de carpetas de un nuevo proyecto remoto como para reconectar uno existente.",
+  "remoteHosts.empty": "No hay rutas estándar establecidas — los hosts usan su directorio de inicio por defecto.",
+  "remoteHosts.hostPlaceholder": "host",
+  "remoteHosts.pathPlaceholder": "/ruta/en/el/host",
+
+  "agents.help1":
+    "Agentes de codificación con IA que Eldrun puede lanzar como pestañas de agente. Instala uno con un solo clic (sin necesitar privilegios de administrador), luego añádelo desde el menú",
+  "agents.help2": "de una barra de pestañas. Muchos instaladores necesitan",
+  "agents.help3": "en tu",
+  "agents.help4": "— si falta, instala Node.js primero, más abajo.",
+  "agents.checkingInstalled": "Comprobando agentes instalados…",
+  "agents.installed": "instalado",
+  "agents.notInstalled": "no instalado",
+  "agents.disableToggleTitle":
+    "Ocultar este agente de los menús de selección de pestañas (lista de agentes al añadir pestaña, controladores de Modelo Local) sin desinstalarlo",
+  "agents.disableAriaEnable": "Habilitar {label} en los menús de pestañas",
+  "agents.disableAriaDisable": "Deshabilitar {label} en los menús de pestañas",
+  "agents.disabled": "Deshabilitado",
+  "agents.enabled": "Habilitado",
+  "agents.removeTitle": "Eliminar la CLI instalada",
+  "agents.removing": "Eliminando…",
+  "agents.remove": "Eliminar",
+  "agents.reinstallTitle": "Eliminar y volver a ejecutar el instalador oficial",
+  "agents.reinstalling": "Reinstalando…",
+  "agents.reinstall": "Reinstalar",
+  "agents.permissionHelpPre": "Si Eliminar falla con un error de permisos, ejecútalo en una pestaña de terminal",
+  "agents.permissionHelpPost": "en su lugar (añade",
+  "agents.permissionHelpPost2": "si se solicita):",
+  "agents.runInTerminal": "Ejecutar en terminal",
+  "agents.installing": "Instalando…",
+  "agents.installLabel": "Instalar {label}",
+  "agents.runningInstaller": "Ejecutando instalador…",
+  "agents.orInstallInShellPre": "O instálalo en una pestaña de terminal",
+  "agents.orInstallInShellPost": ":",
+  "agents.noWindowsInstallerPre": "Aún no hay un instalador de una línea para Windows — mira",
+  "agents.installDocs": "la documentación de instalación",
+  "agents.noWindowsInstallerPost": ", luego haz clic en",
+  "agents.stillNotDetected": "Sigue sin detectarse — prueba con una terminal nueva para que la carpeta de instalación esté en el PATH.",
+  "agents.codexHookLabel": "Hook de sesión",
+  "agents.codexHookDisabled": "deshabilitado",
+  "agents.codexHookNotTrusted": "no es de confianza",
+  "agents.codexHookHelpPre":
+    "Codex no ejecutará el hook de sesión de Eldrun hasta que confíes en él, así que Eldrun recurre a deducir de los propios registros de Codex qué conversación pertenece a qué pestaña. Eso funciona, pero puede confundir dos pestañas de Codex abiertas en la misma carpeta. Habilita",
+  "agents.codexHookHelpPost": "en la lista",
+  "agents.codexHookHelpPost2": "de Codex para una reanudación exacta:",
+  "agents.openInCodex": "Abrir en Codex",
+  "agents.nodeNotDetected": "no detectado",
+  "agents.nodeHelpPre": "La mayoría de las CLI de agentes se instalan con",
+  "agents.nodeHelpMid": ", que viene con Node.js. Instálalo una vez (sin privilegios de administrador) en una pestaña de terminal",
+  "agents.nodeHelpPost": ", luego instala tus agentes abajo:",
+  "agents.nodeManualPre": "¿Prefieres instalar manualmente? Consulta",
+  "agents.nodeDownloads": "las descargas de Node.js",
+
+  "ollama.vibeTitle": "Runtime de modelo local (Vibe)",
+  "ollama.vibeChecking": "Comprobando Vibe…",
+  "ollama.vibeInstalled": "Vibe está instalado — los modelos locales pueden lanzarse como pestañas de agente.",
+  "ollama.vibeMissing1": "Los modelos locales de Ollama funcionan a través de la CLI",
+  "ollama.vibeMissing2":
+    "de Mistral. Aún no está instalada, así que una pestaña de Modelo Local falla con «unable to spawn vibe». Instálala una vez (sin privilegios de administrador) y los modelos locales se lanzarán.",
+  "ollama.installVibe": "Instalar Vibe",
+  "ollama.installingEllipsis": "Instalando…",
+  "ollama.runningInstaller": "Ejecutando instalador…",
+  "ollama.startingEllipsis": "Iniciando…",
+  "ollama.orInstallInShellPre": "O instálalo en una pestaña",
+  "ollama.orInstallInShellPost": ":",
+  "ollama.runInTerminal": "Ejecutar en terminal",
+  "ollama.vibeStillNotDetectedWindows":
+    "Vibe sigue sin detectarse (abre una terminal nueva para que la ubicación de instalación esté en el PATH).",
+  "ollama.vibeStillNotDetectedOther":
+    "Vibe sigue sin detectarse (prueba con una terminal nueva para que ~/.local/bin esté en el PATH).",
+  "ollama.installTitle": "Instalar Ollama",
+  "ollama.notInstalledHelp":
+    "Ollama ejecuta modelos de peso abierto localmente en tu máquina. Aún no está instalado. Instálalo una vez y Eldrun listará aquí mismo los modelos que puedes descargar.",
+  "ollama.automaticInstall": "Instalación automática",
+  "ollama.autoInstallHelpWindows":
+    "Instala Ollama con winget (silencioso, por usuario). winget viene con Windows 10/11; si falta o la instalación falla, sigue los pasos manuales de abajo.",
+  "ollama.autoInstallHelpOther":
+    "Ejecuta el script de instalación oficial. Necesita privilegios de administrador para añadir el servicio ollama, así que esto funciona sin preguntar solo si tu cuenta tiene sudo sin contraseña. Si falla, sigue los pasos manuales de abajo.",
+  "ollama.installBtn": "Instalar Ollama",
+  "ollama.installInTerminalTitle": "Instalar en una terminal",
+  "ollama.runInstallerNewPre": "Ejecuta el instalador para tu sistema en una nueva pestaña",
+  "ollama.runInstallerNewPost": ":",
+  "ollama.alsoDownloadFrom": "También puedes descargar el instalador directamente desde",
+  "ollama.approveUacPrompt": "Aprueba el aviso de Control de cuentas de usuario si Windows lo pide.",
+  "ollama.enterPasswordSudo": "Introduce tu contraseña si el instalador pide sudo.",
+  "ollama.onceFinishedClickPre": "Cuando termine, haz clic en",
+  "ollama.onceFinishedClickPost": "abajo — los modelos instalables aparecerán automáticamente.",
+  "ollama.stillNotDetected": "Ollama sigue sin detectarse.",
+  "ollama.modelsTitle": "Modelos de Ollama",
+  "ollama.checkingEllipsis": "Comprobando...",
+  "ollama.serverRunningLabel": "Servidor en ejecución · {label}",
+  "ollama.serverNotRunning": "Servidor no en ejecución",
+  "ollama.noModelLoaded": "Ningún modelo cargado",
+  "ollama.noLoadedModel": "Ningún modelo cargado",
+  "ollama.loadedModels": "Cargado: {names}",
+  "ollama.start": "Iniciar",
+  "ollama.refresh": "Actualizar",
+  "ollama.downloadingTitle": "Descargando",
+  "ollama.pauseTitle": "Pausar esta descarga (reanudar más tarde)",
+  "ollama.pause": "Pausar",
+  "ollama.downloadPaused": "Descarga pausada — reanuda para terminarla, o elimina los datos parciales.",
+  "ollama.resume": "Reanudar",
+  "ollama.deletePartialTitle": "Eliminar la descarga parcial para liberar espacio en disco",
+  "ollama.delete": "Eliminar",
+  "ollama.downloadInterrupted": "La descarga se interrumpió — reanúdala para terminarla.",
+  "ollama.continueDownload": "Continuar descarga",
+  "ollama.dismissTitle": "Olvidar esta descarga interrumpida",
+  "ollama.dismiss": "Descartar",
+  "ollama.orphansSummaryOne":
+    "{count} capa parcial huérfana ({size}) — descargas interrumpidas sin nombre de modelo recuperable. Vuelve a descargar el modelo para reanudar, o elimina para liberar espacio.",
+  "ollama.orphansSummaryMany":
+    "{count} capas parciales huérfanas ({size}) — descargas interrumpidas sin nombre de modelo recuperable. Vuelve a descargar el modelo para reanudar, o elimina para liberar espacio.",
+  "ollama.orphanLayer": "capa {digest}…",
+  "ollama.deleteLayerTitle": "Eliminar esta capa parcial para liberar espacio en disco",
+  "ollama.downloadedModelsTitle": "Modelos descargados",
+  "ollama.noModelsDownloaded": "No hay modelos descargados",
+  "ollama.unloadTitle": "Descargar de la memoria",
+  "ollama.unload": "Descargar",
+  "ollama.loadTitle": "Cargar en memoria ahora y mantenerlo residente",
+  "ollama.load": "Cargar",
+  "ollama.loading": "Cargando…",
+  "ollama.updateTitle": "Buscar actualización y descargar la más reciente",
+  "ollama.update": "Actualizar",
+  "ollama.updating": "Actualizando…",
+  "ollama.deleteModelTitle": "Eliminar este modelo",
+  "ollama.loadingIntoMemoryTitle": "Cargando en memoria…",
+  "ollama.loadingIntoMemory": "Cargando en memoria…",
+  "ollama.browseRegistry": "Explorar el registro de Ollama",
+  "ollama.pullHelp1": "Descarga cualquier modelo del registro de Ollama. Escribe una referencia exacta para descargarla directamente, o busca y filtra la lista completa de abajo. Usa una referencia completa como",
+  "ollama.pullHelp2": "o",
+  "ollama.pullPlaceholder": "nombre del modelo o namespace/model:tag",
+  "ollama.pull": "Descargar",
+  "ollama.pulling": "Descargando…",
+  "ollama.searchPlaceholder": "Buscar todos los modelos por nombre o descripción…",
+  "ollama.sortBy": "Ordenar por",
+  "ollama.sort.popular": "Más populares",
+  "ollama.sort.newest": "Más recientes",
+  "ollama.sort.pulls": "Más descargas",
+  "ollama.sort.name": "Nombre (A-Z)",
+  "ollama.sort.sizeAsc": "Tamaño: pequeño → grande",
+  "ollama.sort.sizeDesc": "Tamaño: grande → pequeño",
+  "ollama.filterType": "Tipo",
+  "ollama.filterParams": "Parámetros",
+  "ollama.any": "Cualquiera",
+  "ollama.cap.tools": "herramientas",
+  "ollama.cap.vision": "visión",
+  "ollama.cap.thinking": "razonamiento",
+  "ollama.cap.embedding": "embedding",
+  "ollama.cap.audio": "audio",
+  "ollama.pullsSuffix": "{pulls} descargas",
+  "ollama.tagUpdateTitle": "Actualizar {name}{size}",
+  "ollama.tagDownloadTitle": "Descargar {name}{size}",
+  "ollama.sizeLoadingSuffix": " — tamaño…",
+  "ollama.pullLower": "descargar",
+  "ollama.noModelsFound": "No se encontraron modelos",
+  "ollama.noMatchSizeFilter":
+    "Ningún modelo cargado coincide con el tamaño seleccionado — carga más o borra el filtro de parámetros",
+  "ollama.endOfResults": "Fin de los resultados",
+  "ollama.pausedBadge": "pausado",
+  "ollama.interruptedBadge": "interrumpido",
+  "globalAppMenu.title": "Apps globales",
+  "howToStart.title": "Bienvenido a Eldrun",
+  "howToStart.intro": "Eldrun mantiene tu desarrollo asistido por IA en una sola ventana. Así es como empezar:",
+  "howToStart.openFeatureGuide": "Abrir guía de funciones...",
+  "howToStart.takeTour": "Hacer un recorrido",
+  "howToStart.lessons": "Lecciones",
+  "howToStart.gotIt": "Entendido",
+  "remoteFeatures.title": "¿Usas VPN o máquinas remotas?",
+  "remoteFeatures.help": "Eldrun puede controlar un túnel OpenVPN y conectarse a máquinas SSH en las que no tienes un proyecto, ambos desde la cabecera. Ambos están desactivados por defecto — activa el que vayas a usar. Cualquiera se puede cambiar en cualquier momento desde Ajustes.",
+  "remoteFeatures.continue": "Continuar",
+  "lessons.title": "Lecciones",
+  "lessons.intro": "Recorridos guiados cortos para tareas comunes. Elige uno — te irá señalando todo paso a paso.",
+  "globalApp.role.browser": "Navegador",
+  "globalApp.role.mail": "Correo",
+  "globalApp.role.calendar": "Calendario",
+  "globalApp.role.print_manager": "Gestor de impresión",
+  "globalApp.role.file_manager": "Gestor de archivos",
+  "globalApp.role.password_manager": "Gestor de contraseñas",
+  "globalApp.role.video_conf": "Videoconf.",
+  "globalApp.role.media_player": "Reproductor multimedia",
+  "globalApp.role.system_monitor": "Monitor del sistema",
+  "globalApp.role.notes": "Notas",
+  "globalApp.role.screenshot": "Captura de pantalla",
+  "globalApp.role.screen_recorder": "Grabadora de pantalla",
+  "globalApp.role.chat": "Chat",
+  "globalApp.rightClickConfigure": "Clic derecho para configurar",
+  "globalApp.noCommandConfigured": "Ningún comando configurado",
+  "globalApp.clear": "Borrar",
+  "globalApp.set": "Establecer",
+  "header.dragToMove": "Arrastra para mover la ventana de Eldrun",
+  "header.rootTerminal": "Terminal raíz",
+  "rightPanel.resizeTitle": "Arrastra para redimensionar el panel",
+  "rightPanel.moveRight": "Mover el panel al borde derecho",
+  "rightPanel.moveLeft": "Mover el panel al borde izquierdo",
+  "rightPanel.unpinTitle": "Desanclar panel (permitir ocultado automático)",
+  "rightPanel.pinTitle": "Anclar panel abierto",
+  "rightPanel.showHidden": "Mostrar subventanas ocultas",
+  "rightPanel.collapse": "Contraer",
+  "rightPanel.hiddenCount": "Ocultas ({count})",
+  "rightPanel.hiddenWaiting": "Una subventana oculta está esperando tu respuesta",
+  "rightPanel.hiddenWorking": "Una subventana oculta está trabajando",
+  "rightPanel.hiddenFinished": "Una subventana oculta ha terminado, sin ver",
+  "rightPanel.restoreFocusedOn": "Restaurar enfocado en «{label}»",
+  "rightPanel.restoreSubwindow": "Restaurar subventana",
+  "rightPanel.closeSubwindow": "Cerrar subventana (descartar sus pestañas)",
+  "vpnPrompt.titleConnected": "VPN conectado",
+  "vpnPrompt.titlePassword": "Contraseña VPN",
+  "vpnPrompt.close": "Cerrar",
+  "vpnPrompt.closeTitleConnected": "Cerrar — el túnel sigue activo.",
+  "vpnPrompt.closeTitleConnecting": "Detener el establecimiento del túnel y cerrar — cualquier túnel a medio abrir se desmonta.",
+  "vpnPrompt.closeTitleDefault": "Cerrar sin conectar.",
+  "vpnPrompt.upFor": "OpenVPN está activo para",
+  "vpnPrompt.connectingFor": "Conectando OpenVPN para",
+  "vpnPrompt.trafficScope": "Mientras el túnel esté activo, el tráfico de este ordenador se enruta a través de él — también tu navegador, no solo Eldrun.",
+  "vpnPrompt.username": "Nombre de usuario",
+  "vpnPrompt.usernamePlaceholder": "Nombre de usuario de la cuenta OpenVPN…",
+  "vpnPrompt.password": "Contraseña",
+  "vpnPrompt.passphrase": "Frase de contraseña",
+  "vpnPrompt.savedInKeychain": "(guardada en el llavero del sistema)",
+  "vpnPrompt.notStored": "(no almacenada)",
+  "vpnPrompt.keyPassphraseLabel": "Frase de contraseña de la clave privada",
+  "vpnPrompt.keyPassphrasePlaceholder": "Frase de contraseña para la clave cifrada de la configuración…",
+  "vpnPrompt.keyPassphraseHint": "La clave privada de esta configuración está cifrada, así que OpenVPN pide su frase de contraseña por separado de la contraseña de tu cuenta.",
+  "vpnPrompt.saveVpnCredentials": "Guardar credenciales VPN",
+  "vpnPrompt.savePassphrase": "Guardar frase de contraseña",
+  "vpnPrompt.storedSecurely": "almacenada de forma segura en el llavero de tu sistema",
+  "vpnPrompt.tunnelUp": "Túnel activo — el tráfico de este ordenador ahora se enruta a través de él.",
+  "vpnPrompt.challengeHintPre": "Si esta configuración pide algo que estos campos no pueden responder — un código de desafío, o un aviso propio — usa",
+  "vpnPrompt.logInTerminal": "Iniciar sesión en la terminal",
+  "vpnPrompt.challengeHintPost": "abajo: OpenVPN pregunta ahí directamente, y Eldrun nunca ve lo que escribes.",
+  "vpnPrompt.closeStaysUpTitle": "Cerrar — el túnel sigue activo. Detenlo desde el indicador VPN de la cabecera.",
+  "vpnPrompt.terminalBtnStopFirst": "Detén primero el intento actual, luego inicia sesión en la terminal.",
+  "vpnPrompt.terminalBtnHandoff": "Cede esta conexión a una pestaña de terminal raíz e inicia sesión ahí — OpenVPN pide la contraseña (y cualquier código de desafío) directamente, y Eldrun nunca la ve. Solo para esta conexión; tu ajuste headless permanece igual.",
+  "vpnPrompt.cancelTitleConnecting": "Detén el establecimiento del túnel y cierra esto — cualquier túnel a medio abrir se desmonta.",
+  "vpnPrompt.stop": "Detener",
+  "vpnPrompt.connectTitleConnecting": "Estableciendo el túnel OpenVPN — pkexec puede pedir elevación de privilegios…",
+  "vpnPrompt.connectTitleError": "Conexión fallida — comprueba la frase de contraseña y vuelve a intentarlo.",
+  "vpnPrompt.connectTitleDefault": "Establecer el túnel OpenVPN.",
+  "vpnPrompt.connecting": "Conectando…",
+  "vpnPrompt.retry": "Reintentar",
+  "vpnPrompt.connect": "Conectar",
+  "projectSwitcher.howToStartMenu": "Cómo empezar",
+  "projectSwitcher.scrollLeft": "Desplazar proyectos a la izquierda",
+  "projectSwitcher.scrollRight": "Desplazar proyectos a la derecha",
+  "projectSwitcher.addOrImport": "Añadir o importar proyecto",
+  "projectSwitcher.newProject": "Nuevo proyecto",
+  "projectSwitcher.importProject": "Importar proyecto",
+  "projectSwitcher.importFromGitHub": "Importar desde GitHub/GitLab",
+  "projectSwitcher.hpcPipeline": "Flujo de trabajo HPC…",
+  "projectSwitcher.newBox": "Nueva caja",
+  "localModel.role.autocomplete": "Autocompletar",
+  "localModel.role.grammar": "Gramática",
+  "localModel.role.tabs": "Pestañas",
+  "localModel.installTitle": "Instalar un modelo local",
+  "localModel.runningLoaded": "Ollama en ejecución · modelo cargado",
+  "localModel.running": "Ollama en ejecución",
+  "localModel.stopped": "Ollama detenido",
+  "localModel.modelSuffix": " · modelo: {name}",
+  "localModel.noModelSelected": " · ningún modelo seleccionado",
+  "localModel.ariaLabel": "Modelo local",
+  "localModel.agentsGroup": "Agentes",
+  "localModel.agentInstalled": "{label} instalado",
+  "localModel.manageAgents": "Gestionar agentes…",
+  "localModel.localModelsGroup": "Modelos locales",
+  "localModel.downloadingTitle": "Descargando",
+  "localModel.pausedTitle": "Pausado",
+  "localModel.pauseDownloadTitle": "Pausar descarga",
+  "localModel.resumeDownloadTitle": "Reanudar descarga",
+  "localModel.deletePartialDownloadTitle": "Eliminar descarga parcial",
+  "localModel.gpuUsedTotal": "GPU {used} / {total}",
+  "localModel.gpuFree": "{free} libre",
+  "localModel.notInstalled": "Ollama no instalado",
+  "localModel.noModelsInstalled": "No hay modelos instalados",
+  "localModel.serverStopped": "Servidor detenido",
+  "localModel.defaultLoadedTitle": "Modelo local predeterminado · cargado en memoria",
+  "localModel.loadedClickDefaultTitle": "Cargado en memoria — clic para hacerlo predeterminado",
+  "localModel.defaultTag": "predeterminado",
+  "localModel.usedForRole": "Usado para {role} — clic para desasignar",
+  "localModel.useForRole": "Usar {name} para {role}",
+  "localModel.unloadFromMemoryTitle": "Descargar {name} de la memoria",
+  "localModel.unloading": "Descargando de memoria…",
+  "localModel.loadIntoMemoryGroup": "Cargar en memoria",
+  "localModel.failedRetryTitle": "Error al cargar — clic para reintentar",
+  "localModel.loadIntoMemoryTitle": "Cargar en memoria",
+  "localModel.failed": "Fallido",
+  "localModel.manageLocalModels": "Gestionar modelos locales…",
+  "localModel.installOllamaEllipsis": "Instalar Ollama…",
+  "localModel.notRunning": "Ollama no está en ejecución",
+  "localModel.failedToLoadModel": "No se pudo cargar el modelo",
+  "localModel.failedToUnloadModel": "No se pudo descargar el modelo",
+  "localModel.failedToLoadModels": "No se pudieron cargar los modelos",
+  "appShell.vpnStillActiveTitle": "Túnel VPN aún activo",
+  "appShell.vpnStillActiveMessage": "El túnel OpenVPN sigue activo y redirige toda esta máquina. Seguirá funcionando después de cerrar Eldrun — usa el control VPN de la cabecera para cerrarlo tú mismo cuando termines.",
+  "appShell.showFilesPanel": "Mostrar panel de archivos",
+  "detached.loadingSubwindow": "Cargando subventana…",
+  "centerPanel.noTabsOpen": "No hay pestañas abiertas",
+  "centerPanel.noTabsHintPre": "Usa",
+  "centerPanel.noTabsHintPost": "en la barra de pestañas de arriba para abrir una shell o un agente de IA.",
+  "detachedTabs.scrollLeft": "Desplazar pestañas a la izquierda",
+  "detachedTabs.scrollRight": "Desplazar pestañas a la derecha",
+  "detachedTabs.dragToMove": "Arrastra para mover esta ventana",
+  "detachedTabs.closeTab": "Cerrar pestaña",
+  "detachedTabs.newTab": "Nueva pestaña",
+  "detachedTabs.hideWindow": "Ocultar esta ventana en el panel derecho (recupérala desde ahí)",
+  "tour.skip": "Omitir recorrido",
+  "tour.back": "Atrás",
+  "tour.done": "Hecho",
+  "tour.next": "Siguiente",
+  "hint.dismissAria": "Descartar sugerencia",
+  "hint.dontShowHints": "No mostrar sugerencias",
+  "hint.notNow": "Ahora no",
+  "untested.title": "Esta función está implementada pero aún no probada en vivo",
+  "untested.label": "no probado",
+  "vpnNotice.ariaLabel": "Túnel OpenVPN",
+  "vpnNotice.alreadyUp": "El túnel OpenVPN ya está activo",
+  "vpnNotice.desc": "Este ordenador ya enruta a través de un túnel, así que este proyecto no necesita un segundo. Gestiona los túneles desde el control VPN de la cabecera.",
+  "connLog.ariaLabel": "Registro de conexión OpenVPN",
+  "connLog.startingVpn": "Iniciando OpenVPN…",
+  "folderPicker.upOneFolder": "Subir una carpeta",
+  "folderPicker.up": "Subir",
+  "folderPicker.noSubfolders": "No hay subcarpetas aquí.",
+  "folderPicker.folderPrefix": "Carpeta:",
+  "blob.noProjectsYet": "Aún no hay proyectos — crea uno para poblar la nube.",
+  "blob.backToProjects": "Volver a los proyectos",
+  "blob.sphereView": "Esfera",
+  "blob.sphereViewTitle": "Esfera 3D de proyectos",
+  "blob.pieView": "Circular",
+  "blob.pieViewTitle": "Gráfico circular de tiempo registrado",
+  "blob.hintFocused": "Haz clic en una carpeta para entrar · clic en un archivo para abrirlo · centro o Esc para volver",
+  "blob.hintPie": "Tamaño del sector = tiempo registrado · clic para abrir un proyecto · clic derecho para el menú",
+  "blob.hintCloud": "Arrastra para orbitar · desplaza para acercar · clic para explorar archivos · doble clic para abrir · clic derecho para el menú",
+  "blob.noProjectsToChart": "Aún no hay proyectos para graficar.",
+  "blob.projectCountOne": "{count} proyecto",
+  "blob.projectCountMany": "{count} proyectos",
+  "blob.projectRoot": "raíz del proyecto",
+  "blob.noDescriptionYet": "Aún no hay descripción.",
+  "blob.hintCenterUp": "Clic para subir · doble clic para abrir · Esc para salir",
+  "blob.hintExploreOpen": "Clic para explorar archivos · doble clic para abrir",
+  "blob.boxMetaOne": "Caja · {count} proyecto",
+  "blob.boxMetaMany": "Caja · {count} proyectos",
+  "blob.doubleClickToOpen": "Doble clic para abrir",
+  "blob.folder": "Carpeta",
+  "blob.extFile": "archivo {ext}",
+  "blob.file": "Archivo",
+  "blob.clickToEnterFolder": "Clic para entrar en la carpeta",
+  "blob.clickToOpen": "Clic para abrir",
+  "blob.open": "Abrir",
+  "blob.categoriesEllipsis": "Categorías…",
+  "blob.activate": "Activar",
+  "blob.inactivate": "Desactivar",
+  "blob.loadingLower": "cargando…",
+  "pageStrip.ariaLabel": "Páginas",
+  "pageStrip.turnClockwiseTitle": "Girar esta página 90° en sentido horario",
+  "pageStrip.turnClockwiseAria": "Girar página en sentido horario",
+  "pageStrip.removePageTitle": "Quitar esta página",
+  "pageStrip.removePageAria": "Quitar página",
+  "pageStrip.turnRight": "Girar a la derecha",
+  "pageStrip.turnLeft": "Girar a la izquierda",
+  "pageStrip.duplicate": "Duplicar",
+  "pageStrip.deleteOne": "Eliminar página",
+  "pageStrip.deleteMany": "Eliminar {count} páginas",
+  "usage.toneGreen": "verde",
+  "usage.toneOrange": "naranja",
+  "usage.toneRed": "rojo",
+  "usage.utilizationAria": "utilización {tone}",
+  "usage.cpu": "CPU",
+  "usage.coresOne": "({count} núcleo)",
+  "usage.coresMany": "({count} núcleos)",
+  "usage.loadAverage": "Carga promedio",
+  "usage.memory": "Memoria",
+  "usage.loggedIn": "Sesiones activas",
+  "usage.sessionsOne": "({count} sesión)",
+  "usage.sessionsMany": "({count} sesiones)",
+  "usage.userCol": "Usuario",
+  "usage.sessionsCol": "Sesiones",
+  "usage.memCol": "Mem",
+  "usage.noInteractiveLogins": "No hay sesiones interactivas en este host.",
+  "usage.topProcesses": "Procesos principales",
+  "usage.cpuSuffix": "cpu",
+  "usage.memSuffix": "mem",
+  "usage.title": "Uso actual del host remoto",
+  "usage.noMachines": "No hay máquinas para comprobar — añade una en el menú Máquinas, o abre un proyecto remoto.",
+  "usage.lede": "Carga, memoria y sesiones activas en {hosts}, {reading} — esto es lo que se ejecuta ahora mismo.",
+  "usage.hostSingular": "1 host",
+  "usage.hostsPlural": "{count} hosts",
+  "usage.beingReadNow": "leyéndose ahora",
+  "usage.asLastRead": "según la última lectura",
+  "usage.checkingEllipsis": "Comprobando…",
+  "usage.noReading": "Sin lectura — el host puede no estar accesible.",
+  "usage.rechecking": "Volviendo a comprobar…",
+  "usage.recheck": "Volver a comprobar",
+  "hostKey.title": "¿Es esta la máquina correcta?",
+  "hostKey.ledePre": "Eldrun nunca se ha conectado a",
+  "hostKey.ledePost": "antes, y está a punto de enviar allí una contraseña. Comprueba la huella digital de abajo con la que muestra el administrador del host (u otra máquina en la que ya confíes) — si no coincide, algo más está respondiendo por esta dirección.",
+  "hostKey.readingKey": "Leyendo la clave del host…",
+  "hostKey.errorHeading": "No se pudo leer la clave del host, así que no hay nada que verificar. No se envió nada.",
+  "hostKey.acceptNotePre": "Aceptar guarda esta clave en",
+  "hostKey.acceptNotePost": ". No se te preguntará de nuevo — y si la clave cambia alguna vez, la conexión se rechaza directamente.",
+  "hostKey.accepting": "Aceptando…",
+  "hostKey.acceptAndConnect": "Aceptar y conectar",
+  "localLoss.kindDeleted": "eliminado localmente",
+  "localLoss.kindOverwritten": "sobrescrito localmente",
+  "localLoss.sourceGit": "Sincronía Git",
+  "localLoss.sourceSync": "Sincronización de archivos",
+  "localLoss.entryCountOne": "{count} archivo {kind}",
+  "localLoss.entryCountMany": "{count} archivos {kind}",
+  "localLoss.moreCount": "…y {count} más",
+  "localLoss.unrecoverable": "Este contenido solo existió en esta máquina — no se puede recuperar.",
+  "localLoss.title": "Archivos cambiados en tu copia local",
+  "localLoss.ledePre": "Sincronizar este proyecto con el host destruyó algo en tu copia local —",
+  "localLoss.ledeMid": "en",
+  "localLoss.ledePost": ". Esto es lo que git y sync deben hacer cuando ambos lados avanzan; se lista aquí porque le sucedió a tu máquina, y sucedió sin preguntar.",
+  "localLoss.filesCountOne": "{count} archivo",
+  "localLoss.filesCountMany": "{count} archivos",
+  "localLoss.opsCountOne": "{count} operación",
+  "localLoss.opsCountMany": "{count} operaciones",
+  "common.rename": "Renombrar",
+  "common.connect": "Conectar",
+  "common.next": "Siguiente",
+  "projectSearch.placeholder": "Buscar inactivos...",
+  "projectSearch.noProjects": "No hay proyectos",
+  "projectSearch.boxMemberOne": "Caja · {count} miembro",
+  "projectSearch.boxMemberMany": "Caja · {count} miembros",
+  "categoryEditor.titleSuffix": "Categorías",
+  "categoryEditor.desc": "Etiqueta este proyecto para colorearlo y agruparlo en la nube de proyectos y en la barra de pastillas. Un proyecto puede llevar varias categorías; la primera es su color principal.",
+  "categoryEditor.removeCategory": "Quitar esta categoría",
+  "categoryEditor.addCategory": "Añadir esta categoría",
+  "categoryEditor.addLabel": "Añadir una categoría",
+  "categoryEditor.placeholder": "p. ej. trabajo, investigación, cliente-x…",
+  "categoryEditor.saving": "Guardando…",
+  "categoryEditor.save": "Guardar",
+  "boxPill.clickToOpenTitle": "{name} (caja) — clic para abrir",
+  "boxPill.memberCountOne": "{count} miembro",
+  "boxPill.memberCountMany": "{count} miembros",
+  "boxPill.noMembers": "Sin miembros",
+  "boxPill.switchToTitle": "Cambiar a {name}",
+  "boxPill.removeFromBox": "Quitar de la caja",
+  "boxPill.openBox": "Abrir caja",
+  "boxPill.deleteBox": "Eliminar caja",
+  "activityCal.noActivity": "Sin actividad",
+  "activityCal.less": "Menos",
+  "activityCal.more": "Más",
+  "activityCal.dayMon": "Lun",
+  "activityCal.dayWed": "Mié",
+  "activityCal.dayFri": "Vie",
+  "remotePane.notConnected": "No conectado",
+  "remotePane.hintPre": "Esta pestaña se ejecuta en",
+  "remotePane.theRemoteHost": "el host remoto",
+  "remotePane.hintPost": "Conecta para iniciarla — mientras tanto tus pestañas locales siguen funcionando en el espejo.",
+  "extendRemote.title": "Extender «{name}» a remoto",
+  "extendRemote.attachPre": "Adjunta",
+  "extendRemote.attachMid": "a este proyecto como su host remoto principal. La carpeta remota vacía se crea en el host; tus archivos locales existentes se convierten en la copia de trabajo sincronizada y permanecen en su lugar. Nada se sube hasta que lo hagas manualmente.",
+  "extendRemote.attachGeneric": "Adjunta un host SSH remoto a este proyecto. La carpeta remota vacía se crea en el host; tus archivos locales existentes se convierten en la copia de trabajo sincronizada y permanecen en su lugar. Nada se sube hasta que lo hagas manualmente.",
+  "extendRemote.summaryLede": "Crea la carpeta remota y la empareja con los archivos locales existentes de este proyecto:",
+  "extendRemote.local": "Local",
+  "extendRemote.remote": "Remoto",
+  "extendRemote.readyTitle": "Adjuntar el host remoto a este proyecto",
+  "extendRemote.notReadyTitle": "Primero conecta y elige una carpeta remota",
+  "extendRemote.connectFirstError": "Primero conecta y elige una carpeta remota.",
+  "extendRemote.extending": "Extendiendo…",
+  "extendRemote.extendToRemote": "Extender a remoto",
+  "pythonInterp.titleSuffix": "Intérprete de Python",
+  "pythonInterp.desc": "Usado por los botones Ejecutar y Depurar del visor de código. La detección automática es correcta para casi todos los proyectos — fija uno solo cuando tu entorno esté en un lugar que Eldrun no pueda inferir.",
+  "pythonInterp.remoteSuffix": "Comprobado en el host, ya que es donde se ejecuta este proyecto.",
+  "pythonInterp.looking": "Buscando intérpretes…",
+  "pythonInterp.interpreterLabel": "Intérprete",
+  "pythonInterp.autoDetectWith": "Detección automática — {path}",
+  "pythonInterp.autoDetect": "Detección automática",
+  "pythonInterp.customPath": "Ruta personalizada…",
+  "pythonInterp.pathLabel": "Ruta al intérprete",
+  "pythonInterp.pathPlaceholder": "p. ej. /opt/envs/ml/bin/python — las rutas relativas se resuelven desde la raíz del proyecto",
+  "pythonInterp.probeErrorPre": "No se pudieron sondear los intérpretes (",
+  "pythonInterp.probeErrorPost": "). Aún puedes establecer uno manualmente.",
+  "pythonInterp.saving": "Guardando…",
+  "pythonInterp.save": "Guardar",
+  "remoteBrowser.ariaLabel": "Explorador de carpetas remotas",
+  "remoteBrowser.goUp": "Subir",
+  "remoteBrowser.recentlyUsed": "Usado recientemente…",
+  "remoteBrowser.jumpTitle": "Ir a una ruta remota usada anteriormente para este host",
+  "remoteBrowser.useThisFolder": "Usar esta carpeta",
+  "remoteBrowser.newFolderPlaceholder": "Nombre de la nueva carpeta…",
+  "remoteBrowser.addFolderTitle": "Crear una nueva carpeta aquí",
+  "remoteBrowser.addFolder": "+ Añadir carpeta",
+  "remoteBrowser.listing": "Listando...",
+  "remoteBrowser.emptyFolder": "Carpeta vacía.",
+  "bigFolder.titlePre": "Carpetas grandes en",
+  "bigFolder.thisProject": "este proyecto",
+  "bigFolder.introPre": "Estas carpetas son lo bastante grandes como para que sincronizarlas domine cada transferencia. La sincronización copia bytes y",
+  "bigFolder.doesNotReadGitignore": "no lee .gitignore",
+  "bigFolder.introPost": ", así que los datos mantenidos intencionadamente en el host — salida de experimentos, checkpoints, cachés, entornos virtuales — cruzan como cualquier otro archivo a menos que se excluyan aquí.",
+  "bigFolder.measuring": "Midiendo ambos lados…",
+  "bigFolder.nothingOversizedFull": "No se encontró nada sobredimensionado. Adelante con la sincronización.",
+  "bigFolder.nothingOversizedLocalOnly": "No se encontró nada sobredimensionado en el lado local. Adelante con la sincronización.",
+  "bigFolder.colFolder": "Carpeta",
+  "bigFolder.colThisMachine": "Esta máquina",
+  "bigFolder.colHost": "Host",
+  "bigFolder.notePre": "Marcado =",
+  "bigFolder.excludedFromSync": "excluido de la sincronización",
+  "bigFolder.notePost": ". No se elimina nada en ningún caso, y cualquier carpeta puede volver a incluirse más tarde desde su menú contextual en el árbol de archivos. Los archivos rastreados por Git siguen viajando con tus commits — la exclusión se aplica a la sincronización de bytes.",
+  "bigFolder.hostNotMeasuredPre": "El host no fue medido",
+  "bigFolder.hostNotConnected": "el proyecto no está conectado",
+  "bigFolder.hostNotMeasuredPost": ". Solo se listan las carpetas de esta máquina; vuelve a abrir esto desde la vista de archivos una vez conectado para ver las del host.",
+  "bigFolder.hostSkippedCareful": "El host no fue medido: esta máquina está marcada como cuidadosa, así que el escaneo recursivo de todo su árbol no se ejecuta por sí solo.",
+  "bigFolder.measureHost": "Medir el host de todos modos",
+  "bigFolder.measuringHost": "Midiendo el host…",
+  "bigFolder.notNow": "Ahora no",
+  "bigFolder.close": "Cerrar",
+  "bigFolder.apply": "Aplicar",
+  "common.saving": "Guardando…",
+  "common.save": "Guardar",
+  "common.close": "Cerrar",
+  "pill.gitClean": "Sin cambios pendientes",
+  "pill.gitDirty": "Cambios sin confirmar — aún no añadidos",
+  "pill.gitStaged": "Cambios preparados — aún no confirmados",
+  "pill.gitUnpushed": "Confirmado — aún no subido",
+  "pill.statusWorking": "{count} trabajando",
+  "pill.statusWaiting": "{count} esperándote",
+  "pill.statusFinished": "{count} terminado(s)",
+  "pill.categoriesLabel": "Categorías: {list}",
+  "pill.closeProject": "Cerrar proyecto",
+  "pill.activityTitle": "{name} — Actividad",
+  "pill.descTitle": "{name} — Descripción",
+  "pill.descPlaceholder": "Descripción breve para este proyecto…",
+  "pill.renameTitle": "Renombrar proyecto",
+  "pill.namePlaceholder": "Nombre del proyecto…",
+  "pill.nameEmpty": "El nombre no puede estar vacío",
+  "pill.publishTitle": "{name} — Publicar en {provider}",
+  "pill.currentPrefix": "Actual:",
+  "pill.runsOnWorkRemote": "· se ejecuta en el host remoto de trabajo",
+  "pill.hostingProvider": "Proveedor de alojamiento",
+  "pill.repoVisibility": "Visibilidad del repositorio",
+  "pill.visPrivate": "privado",
+  "pill.visPublic": "público",
+  "pill.publishRunsPre": "Ejecuta",
+  "pill.publishRunsMid": "Requiere",
+  "pill.publishRunsPost": "instalado y autenticado (o un token en ⚙ Ajustes → Alojamiento Git).",
+  "pill.publishCliMissingPre": "No se encontró",
+  "pill.publishCliMissingMid": "en esta máquina — publicar crea el repositorio mediante la propia CLI del proveedor, así que instálala (e inicia sesión con",
+  "pill.publishCliMissingPost": ") antes de publicar.",
+  "pill.publishFrom": "Publicar desde",
+  "pill.publishFromLocal": "Este equipo (copia local)",
+  "pill.publishFromRemote": "Host de trabajo remoto",
+  "pill.publishFromLocalHint": "El repositorio se crea y se sube desde la copia local de este proyecto, usando la sesión de {cli} de esta máquina. Git lockstep debe indicar que la copia está sincronizada con el host.",
+  "pill.publishRemoteCliHint": "La publicación se ejecuta en el host de trabajo remoto — {cli} debe estar instalado y con sesión iniciada allí, no en esta máquina, y el proyecto debe estar conectado.",
+  "pill.publishSignInHint": "No conectado mediante un token guardado — la publicación usará el inicio de sesión propio de {cli}.",
+  "pill.publishSignInBtn": "Iniciar sesión con {cli}",
+  "pill.publishSignInTitle": "Ejecutar {cmd} en una nueva pestaña de terminal",
+  "pill.getTokenCta": "Crear un token de acceso de {provider}…",
+  "pill.getTokenHint": "Requiere el scope \"repo\" en GitHub, o \"api\" (lectura/escritura de repositorio) en GitLab.",
+  "pill.published": "Publicado.",
+  "pill.publishing": "Publicando…",
+  "pill.publish": "Publicar",
+  "pill.gitHostingTitle": "{name} — Alojamiento Git",
+  "pill.gitHostingDesc": "Anula el alojamiento Git global solo para este proyecto. Deja los campos en blanco para heredar la configuración global.",
+  "pill.inheritsGlobal": "Hereda global: {url}",
+  "pill.replaceToken": "Reemplazar token de acceso",
+  "pill.enterNewToken": "Introduce un nuevo token para reemplazar…",
+  "pill.tokenStatusWillSet": "Establecerá un token de proyecto (anula el global).",
+  "pill.tokenStatusWillRemove": "Eliminará el token del proyecto; volverá al global.",
+  "pill.tokenStatusHasToken": "Hay un token de proyecto establecido (oculto). Déjalo en blanco para conservarlo.",
+  "pill.tokenStatusInherits": "Hereda el token global.",
+  "pill.tokenStatusNone": "Ningún token establecido — los pushes usan tus credenciales de git del sistema.",
+  "pill.removeProjectToken": "Quitar el token del proyecto (usar el global)",
+  "pill.disableGitTitle": "{name} — Eliminar git e historial",
+  "pill.disableGitWarn1": "Esto elimina permanentemente el",
+  "pill.disableGitWarn2": "directorio de este proyecto — cada commit, rama, stash y remoto.",
+  "pill.cannotBeUndone": "No se puede deshacer.",
+  "pill.disableGitWarn3": "El proyecto se convierte en un proyecto «Sin git (sin repo)»; tus archivos de trabajo quedan intactos.",
+  "pill.typeNameConfirmPre": "Escribe el nombre del proyecto",
+  "pill.typeNameConfirmPost": "para confirmar",
+  "pill.removing": "Eliminando…",
+  "pill.deleteGitHistory": "Eliminar historial de git",
+  "pill.deleteProjectTitle": "Eliminar {name}",
+  "pill.archiveDescPre": "Esto desconecta",
+  "pill.archiveDescMid": "y lo mueve al archivo de Eldrun. Puedes restaurarlo — o eliminarlo permanentemente — más tarde desde",
+  "pill.archiveSettingsLink": "Ajustes → Proyectos archivados",
+  "pill.archiveRemoteNotTouchedPre": "Los archivos en el host remoto",
+  "pill.notWord": "no",
+  "pill.archiveRemoteNotTouchedPost": "tocados.",
+  "pill.deleting": "Eliminando…",
+  "pill.deleteToArchive": "Eliminar al archivo",
+  "pill.detachTitle": "{name} — Desconectar host SSH",
+  "pill.detachDesc1Pre": "Esto convierte",
+  "pill.detachDesc1Mid": "de nuevo en un proyecto local simple: su copia de trabajo local permanece exactamente donde está y vuelve a ser el directorio del proyecto. Los archivos en el host remoto",
+  "pill.detachDesc1Post": "no son tocados, y nada local se elimina.",
+  "pill.detachDesc2Pre": "Lo que sí se pierde es el",
+  "pill.pairingWord": "emparejamiento",
+  "pill.detachDesc2Post": ": el lockstep de git se detiene, y el alcance de auto-sincronización que elegiste para este host — qué carpetas cruzan, y el registro de lo que ya estaba sincronizado — se descarta. Volver a adjuntar el mismo host más tarde significa elegir ese alcance de nuevo desde cero.",
+  "pill.detaching": "Desconectando…",
+  "pill.detachToLocal": "Desconectar a local",
+  "pill.containerSettingsTitle": "{name} — Ajustes del contenedor",
+  "pill.containerAppliedNote": "Se aplica en el próximo inicio del contenedor (activación del proyecto o creación de pestaña) — un contenedor en ejecución cuya configuración cambió se reemplaza automáticamente.",
+  "pill.buildFromDockerfile": "Compilar desde un Dockerfile en este proyecto",
+  "pill.dockerfilePlaceholder": "p. ej. Dockerfile — vacío: usar la imagen de abajo",
+  "pill.image": "Imagen",
+  "pill.imagePlaceholder": "vacío: eldrun-agent-sandbox:latest",
+  "pill.network": "Red",
+  "pill.networkPlaceholder": "vacío: puente de docker — «none» bloquea toda salida (rompe los agentes en la nube)",
+  "pill.networkNotePre": "Nota: el puente predeterminado sigue alcanzando los servicios vinculados a esta máquina (Ollama, servidores de desarrollo) a través de la IP de la puerta de enlace de docker. Totalmente cerrado significa",
+  "pill.networkNotePost": "o una red de lista blanca personalizada.",
+  "pill.memoryCap": "Límite de memoria",
+  "pill.memoryPlaceholder": "p. ej. 4g — vacío: ilimitado",
+  "pill.cpuCap": "Límite de CPU",
+  "pill.cpuPlaceholder": "p. ej. 2 — vacío: ilimitado",
+  "pill.processLimit": "Límite de procesos",
+  "pill.processLimitPlaceholder": "vacío: 1024 (protección contra fork bombs)",
+  "pill.processLimitError": "El límite de procesos debe ser un número entero positivo.",
+  "pill.readonlyRootfs": "Sistema de archivos raíz de solo lectura (mantiene /tmp escribible)",
+  "pill.unpublishTitle": "{name} — Anular publicación",
+  "pill.unpublishDesc1": "Esto elimina el remoto",
+  "pill.unpublishDesc2": "y reinicia el proyecto a un repositorio git local. Tus commits permanecen intactos y el repositorio en",
+  "pill.unpublishDesc3": "está",
+  "pill.unpublishDesc4": "eliminado — solo se elimina el enlace local a él. Puedes volver a publicar más tarde.",
+  "pill.unpublishing": "Anulando publicación…",
+  "pill.unpublishKeepRepo": "Anular publicación (conservar repo)",
+  "pill.changeVisibilityTitle": "{name} — Cambiar visibilidad",
+  "pill.flipVisibility1": "Cambia este repositorio de",
+  "pill.flipVisibility2": "a",
+  "pill.flipVisibility3": "en el lugar mediante",
+  "pill.flipVisibility4": "El repositorio, su URL y su historial se conservan.",
+  "pill.applying": "Aplicando…",
+  "pill.makeVisibility": "Hacer {target}",
+  "pill.moveToProviderTitle": "{name} — Mover a otro proveedor",
+  "pill.newProvider": "Nuevo proveedor",
+  "pill.migrateDesc1": "Crea el repositorio en",
+  "pill.migrateDesc2": ", vuelve a apuntar",
+  "pill.migrateDesc3": ", y hace push. El repositorio existente de",
+  "pill.migrateDesc4": "es",
+  "pill.leftIntact": "dejado intacto",
+  "pill.migrateDesc5": "(conservado como",
+  "pill.migrateDesc6": ") — elimínalo tú mismo si ya no lo quieres.",
+  "pill.migrating": "Migrando…",
+  "pill.moveToProvider": "Mover a {provider}",
+  "pill.viewGroup": "Ver",
+  "pill.showActivity": "Mostrar actividad",
+  "pill.showOnDiskRemoteTitle": "Abrir el espejo local (la copia de trabajo conectada) en el gestor de archivos",
+  "pill.showOnDiskLocalTitle": "Abrir el directorio del proyecto en el gestor de archivos",
+  "pill.showOnDisk": "Mostrar en disco",
+  "pill.editGroup": "Editar",
+  "pill.renameEllipsis": "Renombrar…",
+  "pill.movePillTitle": "Mover el espejo local de este proyecto (la copia de trabajo conectada) a una nueva carpeta",
+  "pill.moveProjectEllipsis": "Mover proyecto…",
+  "pill.editDescription": "Editar descripción",
+  "pill.categoriesMenuTitle": "Etiqueta este proyecto para colorearlo y agruparlo en la nube y en la barra de pastillas",
+  "pill.repairScaffoldTitle": "Completa cualquier archivo de estructura, patrón .gitignore predeterminado o .claude/settings.json que falte — nunca sobrescribe contenido existente",
+  "pill.repairScaffold": "Reparar archivos de estructura",
+  "pill.extendToRemoteMenuTitle": "Adjunta un host SSH remoto a este proyecto local — los archivos permanecen; súbelos manualmente",
+  "pill.extendToRemoteEllipsis": "Extender a remoto…",
+  "pill.gitGroup": "Git",
+  "pill.gitInitTitle": "Ejecuta git init para empezar a versionar este proyecto",
+  "pill.enableGit": "Habilitar git (git init)",
+  "pill.makePrivateTitle": "Cambia el repositorio entre público y privado en el lugar (gh/glab repo edit)",
+  "pill.makePrivate": "Hacer privado…",
+  "pill.makePublic": "Hacer público…",
+  "pill.moveProviderMenuTitle": "Publica en el otro proveedor y reapunta origin; el repositorio antiguo queda intacto",
+  "pill.moveToGithub": "Mover a GitHub…",
+  "pill.moveToGitlab": "Mover a GitLab…",
+  "pill.unpublishMenuTitle": "Elimina el remoto origin y vuelve a un repositorio local; el repositorio alojado y el historial se conservan",
+  "pill.unpublishKeepRepoEllipsis": "Anular publicación (conservar repo)…",
+  "pill.gitHostingMenuTitle": "Anula el alojamiento Git global (URL de perfil + token) solo para este proyecto",
+  "pill.gitHostingEllipsis": "Alojamiento Git…",
+  "pill.publishEllipsis": "Publicar en GitHub / GitLab…",
+  "pill.runtimeGroup": "Tiempo de ejecución",
+  "pill.containerRunTitle": "Ejecuta cada pestaña de terminal y agente de este proyecto dentro de un contenedor Docker cerrado. La carpeta del proyecto permanece en el host en su ruta normal — el contenedor simplemente no puede alcanzar nada más.",
+  "pill.runInContainer": "Ejecutar este proyecto en un contenedor",
+  "pill.containerSettingsMenuTitle": "Imagen, red, límites de memoria/CPU y rootfs de solo lectura para el contenedor de este proyecto",
+  "pill.containerSettingsEllipsis": "Ajustes del contenedor…",
+  "pill.pythonInterpMenuTitle": "El entorno Python en el que se ejecutan y depuran los scripts de este proyecto. Detectado automáticamente por defecto (venv en el árbol, poetry, conda, pyenv); fija uno cuando tu entorno esté donde Eldrun no pueda inferirlo.",
+  "pill.pythonInterpreterEllipsis": "Intérprete de Python…",
+  "pill.autoConnectTitleNonHeadless": "Conecta este proyecto por sí solo al iniciar y al cambiar a él. Eldrun no maneja contraseñas en este modo, así que el inicio de sesión (y la VPN, si tiene una) se abre en la terminal raíz para que te autentiques — luego el proyecto se conecta solo.",
+  "pill.autoConnectTitleEligible": "Conecta este proyecto por sí solo al iniciar y al cambiar a él. Nunca pide nada: entra directamente cuando el host es accesible, y activa la VPN solo cuando no lo es.",
+  "pill.autoConnectTitleNotEligible": "Guarda primero la contraseña SSH (o usa autenticación por clave) — auto-conectar solo se ofrece cuando conectar no necesita nada de ti.",
+  "pill.autoConnectOnLaunch": "Conectar automáticamente al iniciar",
+  "pill.persistSessionsMenuTitle": "Ejecuta la shell remota y las pestañas de Python/script de este proyecto dentro de una sesión tmux en el host, para que una ejecución larga continúe a través de una caída SSH, la suspensión del portátil o el cierre de Eldrun — la pestaña se reconecta al volver a conectar. Cerrar una pestaña sigue terminando su sesión (con confirmación). Las pestañas de agente no se ven afectadas.",
+  "pill.persistentSessionsTmux": "Sesiones persistentes (tmux)",
+  "pill.remoteMachinesMenuTitle": "Añade y gestiona máquinas adicionales en las que se ejecuta este proyecto. Ejecutan el mismo código (mantenido en sincronización unidireccional) como trabajadores de experimentos de solo lectura; sus salidas permanecen en cada máquina.",
+  "pill.remoteMachinesCount": "Máquinas remotas… ({count})",
+  "pill.remoteMachinesEllipsis": "Máquinas remotas…",
+  "pill.closeAllTabs": "Cerrar todas las pestañas y ventanas",
+  "pill.dangerZone": "Zona de peligro",
+  "pill.detachSshMenuTitle": "Vuelve a convertir esto en un proyecto local. La copia de trabajo local permanece en su lugar y los archivos del host remoto quedan intactos — pero el emparejamiento se elimina: el lockstep se detiene, y el alcance de auto-sincronización que configuraste para este host se descarta.",
+  "pill.detachSshEllipsis": "Desconectar host SSH…",
+  "pill.removeGitMenuTitle": "Elimina el directorio .git de este proyecto y todo el historial de control de versiones (no se puede deshacer)",
+  "pill.removeGitHistoryEllipsis": "Eliminar git e historial…",
+  "pill.deleteProjectMenuTitle": "Desconecta este proyecto y muévelo al archivo de Eldrun. Restáuralo o elimínalo permanentemente más tarde desde Ajustes. Los archivos de un host remoto nunca se tocan.",
+  "pill.deleteProjectEllipsis": "Eliminar proyecto…",
+  "pill.nowVisibility": "Ahora {target}.",
+  "pill.migrated": "Migrado.",
+  "remoteConnect.titleWorker": "Conectar worker · {host}",
+  "remoteConnect.titleProject": "Conectar proyecto remoto",
+  "remoteConnect.remoteLabel": "Remoto",
+  "remoteConnect.localLabel": "Local",
+  "remoteConnect.nameLabel": "Nombre",
+  "remoteConnect.namePlaceholder": "Nombre del proyecto",
+  "remoteConnect.nameHintWorker": "Se muestra en la píldora y en «Máquinas remotas». Déjalo en blanco para usar el nombre del host.",
+  "remoteConnect.nameHintProject": "El nombre del proyecto, mostrado en su píldora y en toda la aplicación Eldrun.",
+  "remoteConnect.machineNameLabel": "Nombre de la máquina",
+  "remoteConnect.machineNameHint": "Identifica esta máquina en el Monitor del sistema y en las luces de conexión cuando el proyecto tiene más de un host. Déjalo en blanco para usar el nombre del host.",
+  "remoteConnect.vpnToggleTitle": "Conectar mediante OpenVPN",
+  "remoteConnect.vpnDescLine1": "Levanta primero un túnel si este host está protegido por VPN. Sáltalo si ya estás en la red correcta — SSH se conecta directamente.",
+  "remoteConnect.vpnDescLine2Pre": "El túnel es",
+  "remoteConnect.vpnDescLine2Strong": "de alcance para todo el equipo",
+  "remoteConnect.vpnDescLine2Post": ": mientras esté activo, todo el tráfico de este equipo pasa por él — también tu navegador, no solo Eldrun.",
+  "remoteConnect.configLabel": "Configuración",
+  "remoteConnect.changeConfig": "Cambiar…",
+  "remoteConnect.changeConfigTitle": "Elige otra configuración de OpenVPN para este proyecto.",
+  "remoteConnect.pickConfigHintChange": "Elige la configuración de OpenVPN que se usará en su lugar — la nueva elección reemplaza a la guardada.",
+  "remoteConnect.pickConfigHintNew": "Elige la configuración de OpenVPN para este host — se guarda en el proyecto, así que solo tienes que elegirla una vez.",
+  "remoteConnect.recentConfigsPlaceholder": "Usado recientemente…",
+  "remoteConnect.recentConfigsTitle": "Reutilizar una configuración de OpenVPN usada anteriormente",
+  "remoteConnect.chooseConfigBtn": "Elegir configuración .ovpn…",
+  "remoteConnect.vpnUsernameLabel": "Usuario VPN",
+  "remoteConnect.vpnPasswordLabel": "Contraseña VPN",
+  "remoteConnect.vpnPassphraseLabel": "Frase de contraseña VPN",
+  "remoteConnect.vpnSavedPlaceholder": "Usando la frase de contraseña guardada — déjalo en blanco",
+  "remoteConnect.vpnAccountPasswordPlaceholder": "Contraseña de la cuenta OpenVPN…",
+  "remoteConnect.vpnPassphrasePlaceholder": "Frase de contraseña de OpenVPN…",
+  "remoteConnect.retryVpn": "Reintentar VPN",
+  "remoteConnect.connectVpn": "Conectar VPN",
+  "remoteConnect.vpnStopTitleConnected": "Desactiva este túnel de OpenVPN. La conexión SSH se deja como está.",
+  "remoteConnect.vpnStopTitleConnecting": "Detén este intento de conexión VPN y restablece el estado del túnel.",
+  "remoteConnect.disconnectVpn": "Desconectar VPN",
+  "remoteConnect.vpnTermBtnTitle": "Levanta el túnel de OpenVPN en una terminal más abajo — introduce la frase de contraseña allí.",
+  "remoteConnect.vpnTermOpenBelow": "Terminal de VPN abierta más abajo",
+  "remoteConnect.vpnTermOpenBtn": "Abrir terminal de inicio de sesión VPN",
+  "remoteConnect.vpnTermHint": "Autentica el túnel más abajo — sigue funcionando para este proyecto.",
+  "remoteConnect.disconnect": "Desconectar",
+  "remoteConnect.sshSectionLabel": "Iniciar sesión por SSH",
+  "remoteConnect.usernameLabel": "Usuario",
+  "remoteConnect.usernamePlaceholder": "Nombre de inicio de sesión SSH — en blanco usa tu cuenta local",
+  "remoteConnect.usernameHint": "La cuenta en {host}. Cambiarla cambia qué contraseña guardada se aplica — se almacenan por inicio de sesión.",
+  "remoteConnect.sshPasswordLabel": "Contraseña o frase de contraseña de la clave",
+  "remoteConnect.sshSavedPlaceholder": "Usando el secreto guardado — déjalo en blanco",
+  "remoteConnect.sshPasswordPlaceholder": "Contraseña SSH, o la frase de contraseña de tu clave…",
+  "remoteConnect.connectedState": "Conectado",
+  "remoteConnect.sshStopTitle": "Detén este intento de conexión SSH y restablece el estado de la conexión.",
+  "remoteConnect.savePassword": "Guardar contraseña",
+  "remoteConnect.saveHintKeptTerminal": "guardado en el llavero de tu sistema operativo — un inicio de sesión por terminal no lo ve Eldrun, así que no se guarda nada nuevo; desactívalo para eliminarlo",
+  "remoteConnect.saveHintSaved": "guardado en el llavero de tu sistema operativo — desactívalo para eliminarlo",
+  "remoteConnect.saveHintNothingTerminal": "no hay nada que guardar en un inicio de sesión por terminal — Eldrun nunca lo ve",
+  "remoteConnect.autoConnectTitleEligible": "Conecta este proyecto por sí solo al iniciar y al cambiar a él. Nunca pide nada: entra directamente cuando el host es alcanzable, y solo activa la VPN cuando no lo es. Ten en cuenta que activar la VPN redirige todo el tráfico de este equipo — con la auto-conexión eso ocurre sin preguntar, así que vigila el indicador de VPN de la cabecera.",
+  "remoteConnect.autoConnectTitleNotEligible": "Primero guarda la contraseña SSH (o usa autenticación por clave) — la auto-conexión solo se ofrece cuando conectar no necesita nada de ti.",
+  "remoteConnect.autoConnectLabel": "Auto-conexión",
+  "remoteConnect.autoConnectHintEligible": "al iniciar y al cambiar — VPN solo si el host no es alcanzable directamente",
+  "remoteConnect.autoConnectHintNotEligible": "necesita una contraseña guardada o autenticación por clave",
+  "remoteConnect.autoConnectVpnWarningPre": "Aviso: si el host no es alcanzable directamente, la auto-conexión activa la VPN",
+  "remoteConnect.autoConnectVpnWarningStrong": "sin preguntar",
+  "remoteConnect.autoConnectVpnWarningPost": "— redirigiendo el tráfico de este equipo al iniciar. El indicador de VPN de la cabecera muestra cuándo hay un túnel activo, y puede desactivarlo.",
+  "remoteConnect.autoConnectInteractiveTitle": "Conecta este proyecto por sí solo al iniciar y al cambiar a él. Eldrun no maneja contraseñas en este modo, así que el inicio de sesión (y la VPN, si este proyecto tiene una) se abre en la terminal raíz para que te autentiques — el proyecto se conecta por sí solo en cuanto entras.",
+  "remoteConnect.autoConnectInteractiveHint": "al iniciar y al cambiar — abre el inicio de sesión en la terminal raíz",
+  "remoteConnect.sshTermBtnTitle": "Abre el inicio de sesión SSH en una terminal más abajo — introduce la contraseña allí.",
+  "remoteConnect.sshTermOpenBelow": "Terminal SSH abierta más abajo",
+  "remoteConnect.sshTermOpenBtn": "Abrir terminal de inicio de sesión SSH",
+  "remoteConnect.tryConnectTitle": "Si ya has terminado de iniciar sesión arriba, conecta ahora.",
+  "remoteConnect.tryConnectBtn": "Ya inicié sesión — conectar",
+  "remoteConnect.sshTermHint": "Inicia sesión más abajo — la conexión agrupada se establece en cuanto te autentiques.",
+  "remoteConnect.killConfirmTitle": "Confirmar: esto termina todas las sesiones tmux en ejecución en el host — no se puede deshacer.",
+  "remoteConnect.killConfirmBtn": "Confirmar: finalizar todos los trabajos",
+  "remoteConnect.killArmTitle": "Desconectar activamente: finaliza todos los trabajos tmux en ejecución en este host y cierra la conexión. Los trabajos se terminan solo con este clic — nunca al reiniciar Eldrun.",
+  "remoteConnect.killArmBtn": "Desconectar y finalizar trabajos",
+  "remoteConnect.forgetPasswordTitle": "Elimina la contraseña guardada de este host del llavero de tu sistema operativo. La conexión actual sigue activa; la próxima conexión volverá a pedir la contraseña.",
+  "remoteConnect.forgetPasswordBtn": "Olvidar contraseña guardada",
+  "carefulHost.title": "Mantiene el trabajo en segundo plano de Eldrun alejado de esta máquina: el censo de tamaño de archivos deja de escanear el host por sí solo, y la monitorización se vuelve más barata y lenta. Úsalo para un nodo de inicio de sesión o cualquier máquina que compartas con otros — no para un nodo de cómputo que ocupas durante la duración de un trabajo, que es tuyo mientras lo tienes.",
+  "carefulHost.label": "Tratar esta máquina con cuidado",
+  "carefulHost.hintDefault": "para un nodo de inicio de sesión o una máquina compartida: omite los escaneos que leen todo su sistema de archivos",
+  "usage.carefulNote":
+    "Host HPC — solo se listan tus propias sesiones y procesos. Las normas de uso de un clúster no permiten recopilar nombres o comandos de otros usuarios, así que este informe no se ejecuta automáticamente aquí.",
+  "carefulHost.hintOnByDefault": "activado por defecto para cada máquina remota — desactívalo si esta es tuya",
+  "carefulHost.hintNotCareful": "esta máquina es tuya: monitorización completa, igual que en local",
+  "remoteConnect.vpnSectionAria": "Túnel OpenVPN",
+  "remoteConnect.sshSectionAria": "Inicio de sesión SSH",
+  "remoteMachines.title": "{name} — Máquinas remotas",
+  "remoteMachines.introPre": "Todas las máquinas que alcanza este proyecto, en un solo lugar — la",
+  "remoteMachines.introStrongPrimary": "primaria",
+  "remoteMachines.introMid1": "que posee sus archivos y git, además de cualquier máquina worker adicional que ejecuta su",
+  "remoteMachines.introStrongSameCode": "mismo código",
+  "remoteMachines.introMid2": ". Conecta o gestiona cualquiera de ellas aquí, o añade un nuevo worker más abajo. Un nuevo worker comparte por defecto la carpeta del proyecto de la máquina primaria (sin copia, sin git); marca",
+  "remoteMachines.introStrongSyncCopy": "Sincronizar una copia",
+  "remoteMachines.introPost": "para darle su propia copia sincronizada en un solo sentido — para hosts que no comparten almacenamiento con la primaria.",
+  "remoteMachines.primaryTagTitle": "La máquina primaria posee los archivos, git y el espejo local de este proyecto, con sincronización bidireccional completa.",
+  "remoteMachines.primaryTag": "Primaria",
+  "remoteMachines.connectedDot": "Conectado.",
+  "remoteMachines.notConnectedDot": "No conectado.",
+  "remoteMachines.localMirrorLabel": "Espejo local:",
+  "remoteMachines.manage": "Gestionar…",
+  "remoteMachines.connectEllipsis": "Conectar…",
+  "remoteMachines.sharedFsTag": "Sistema de archivos compartido",
+  "remoteMachines.dropIntro": "De tus máquinas globales. Indica la ruta compartida en la que ve la carpeta de este proyecto — todo lo demás ya se conoce.",
+  "remoteMachines.pathOnMachine": "Ruta en esta máquina",
+  "remoteMachines.absolutePathPlaceholder": "Ruta absoluta (p. ej. /home/me/project)",
+  "remoteMachines.adding": "Añadiendo…",
+  "remoteMachines.addMachineBtn": "Añadir máquina",
+  "remoteMachines.noWorkers": "Aún no hay máquinas worker.",
+  "remoteMachines.sharedStatus": "Se ejecuta en la carpeta compartida de la primaria — sin copia, sin sincronización.",
+  "remoteMachines.syncFailedLabel": "Sincronización fallida:",
+  "remoteMachines.lastSyncedLabel": "Última sincronización:",
+  "remoteMachines.alreadyCurrent": "(ya actualizado)",
+  "remoteMachines.syncingEllipsis": "Sincronizando…",
+  "remoteMachines.notSyncedYet": "Aún no sincronizado",
+  "remoteMachines.sharedTagTitle": "Sistema de archivos compartido: las shells se ejecutan en la carpeta del proyecto de la primaria en esta máquina. No se copia código y git nunca se ejecuta aquí.",
+  "remoteMachines.syncedTagTitle": "Copia sincronizada: esta máquina mantiene su propia copia de solo lectura del código, sincronizada en un solo sentido desde la primaria.",
+  "remoteMachines.syncedCopyTag": "Copia sincronizada",
+  "remoteMachines.syncCodeNow": "Sincronizar código ahora",
+  "remoteMachines.pullOutputsTitle": "Trae los resultados del experimento de esta máquina (archivos no rastreados) a tu equipo. Confirma primero el tamaño.",
+  "remoteMachines.pulling": "Extrayendo…",
+  "remoteMachines.pullOutputsBtn": "Extraer resultados…",
+  "remoteMachines.removeTitle": "Elimina esta máquina del proyecto (sus archivos en el host quedan intactos).",
+  "remoteMachines.remove": "Eliminar",
+  "remoteMachines.syncCopyToggleTitle": "Activado: esta máquina mantiene su propia copia del código, sincronizada en un solo sentido desde la primaria. Desactivado: comparte la carpeta del proyecto de la primaria a través de un sistema de archivos compartido (sin copia, sin git).",
+  "remoteMachines.syncCopyLabel": "Sincronizar una copia del código a esta máquina",
+  "remoteMachines.autoSyncTitle": "Mantiene el código rastreado de esta máquina sincronizado con el HEAD del proyecto en cada commit.",
+  "remoteMachines.autoSyncLabel": "Sincronizar código automáticamente en cada commit",
+  "remoteMachines.addMachineTitle": "Añadir una máquina",
+  "remoteMachines.globalListTitle": "Tus máquinas",
+  "remoteMachines.globalListHelp":
+    "Máquinas de la lista Máquinas de la cabecera. Ya están configuradas, así que añadir una aquí solo requiere su carpeta en esa máquina.",
+  "remoteMachines.globalQuickAdd": "Añadir",
+  "remoteMachines.globalQuickAddTitle":
+    "Añadir esta máquina como worker de sistema de archivos compartido: confirma su carpeta arriba y se añade y se conecta.",
+  "remoteMachines.globalFill": "Usar en el formulario",
+  "remoteMachines.globalFillTitle":
+    "Poner la dirección de esta máquina en el formulario de abajo, para explorar sus carpetas o sincronizar una copia en ella.",
+  "remoteMachines.globalAlreadyAdded": "Ya añadida",
+  "remoteMachines.globalAlreadyAddedTitle":
+    "Esta máquina ya es el host principal de este proyecto o uno de sus workers.",
+  "remoteMachines.sshAddressLabel": "Dirección SSH",
+  "remoteMachines.sshAddressPlaceholder": "host[:puerto]  (p. ej. gpu-2:22)",
+  "remoteMachines.usernamePlaceholder": "Usuario de inicio de sesión SSH (p. ej. yo) — o inclúyelo como user@ arriba",
+  "remoteMachines.sshPasswordSavedPlaceholder": "Usando la contraseña guardada — déjalo en blanco",
+  "remoteMachines.sshPasswordPlaceholder": "Contraseña SSH o frase de contraseña de la clave — en blanco para una clave desbloqueada",
+  "remoteMachines.saveTitleTerminal": "Eldrun nunca ve un inicio de sesión por terminal, por lo que no guarda nada nuevo — y tampoco elimina nada. Cualquier contraseña guardada permanece como está; en el propio menú Conectar de la máquina puedes cambiarla.",
+  "remoteMachines.saveTitleHeadless": "Guarda la contraseña SSH de esta máquina en el llavero de tu sistema operativo, indexada por host — el propio menú Conectar de la máquina la encontrará y no volverá a preguntar. Desactivado por defecto; desmarcarlo elimina una contraseña guardada previamente.",
+  "remoteMachines.saveHintKeptTerminal": "Conservada en el llavero de tu sistema operativo — un inicio de sesión por terminal no lo ve Eldrun, así que no guarda ni elimina nada.",
+  "remoteMachines.saveHintNothingTerminal": "No hay nada que guardar en un inicio de sesión por terminal — Eldrun nunca lo ve.",
+  "remoteMachines.saveHintSavedWillAskAgainOff": "Guardada en el llavero de tu sistema operativo — el Conectar de esta máquina no volverá a preguntar. Desactívalo para eliminarla.",
+  "remoteMachines.saveHintWillSave": "Se guardará en el llavero de tu sistema operativo para que el Conectar de esta máquina no vuelva a preguntar.",
+  "remoteMachines.saveHintNotSavedPre": "Se usa solo para iniciar sesión — no se guarda. Activa",
+  "remoteMachines.saveHintNotSavedPost": "para conservarla.",
+  "remoteMachines.loginTermHint": "Inicia sesión más abajo — el selector de carpetas se abrirá por sí solo en cuanto se complete este inicio de sesión.",
+  "remoteMachines.retryBrowseTitle": "Si ya has terminado de iniciar sesión arriba, explora esta máquina ahora.",
+  "remoteMachines.waitingForLogin": "Esperando el inicio de sesión…",
+  "remoteMachines.loggedInBrowse": "Ya inicié sesión — explorar",
+  "remoteMachines.openLoginTerminal": "Abrir terminal de inicio de sesión",
+  "remoteMachines.loggingIn": "Iniciando sesión…",
+  "remoteMachines.logIn": "Iniciar sesión",
+  "remoteMachines.loggedInToPre": "Sesión iniciada en",
+  "remoteMachines.sharedFsToggleTitleStep2": "Desactivado (por defecto): esta máquina comparte la carpeta del proyecto de la primaria a través de un sistema de archivos compartido — sin copia, sin git. Activado: dale su propia copia del código sincronizada en un solo sentido (para hosts que no comparten almacenamiento).",
+  "remoteMachines.syncCopyDescOn": "Esta máquina mantiene su propia copia del código, sincronizada en un solo sentido desde la primaria. Navega hasta (o crea) la carpeta para esa copia.",
+  "remoteMachines.syncCopyDescOff": "Esta máquina comparte la carpeta del proyecto de la primaria a través de un sistema de archivos compartido — sin copia, sin git. Navega hasta esa carpeta en esta máquina.",
+  "remoteMachines.remotePathForCopy": "Ruta remota para la copia de esta máquina",
+  "remoteMachines.pathToProject": "Ruta al proyecto en esta máquina",
+  "remoteMachines.reconnect": "Reconectar",
+  "remoteMachines.browseEllipsis": "Explorar…",
+  "remoteMachines.browserFooter": "Navega hasta una carpeta y luego haz clic en «Usar esta carpeta».",
+  "remoteMachines.labelOptional": "Etiqueta (opcional)",
+  "remoteMachines.labelPlaceholder": "p. ej. gpu-2",
+  "remoteMachines.enterAbsolutePath": "Introduce una ruta remota absoluta (p. ej. /home/me/project)",
+  "remoteMachines.enterHostBeforeBrowsing": "Introduce un host como [usuario@]host[:puerto] antes de explorar",
+  "remoteMachines.enterHostBeforeLogin": "Introduce un host como [usuario@]host[:puerto] antes de iniciar sesión",
+  "remoteMachines.enterHost": "Introduce un host como [usuario@]host[:puerto]",
+  "remoteMachines.noOutputFiles": "No hay archivos de resultados para extraer.",
+  "remoteMachines.pullConfirm": "¿Extraer {files} archivo(s) de resultados ({bytes}) de esta máquina a tu equipo?",
+  "remoteMachines.pulledResult": "{pulled} archivo(s) extraído(s) → {dest}{errs}",
+  "remoteMachines.pullErrorsSuffix": " ({count} fallidos)",
+  "remoteMachines.pullFailed": "Fallo al extraer: {error}",
+  "hpcWizard.stepLogin": "Inicio de sesión",
+  "hpcWizard.stepProject": "Proyecto",
+  "hpcWizard.stepWorkspace": "Espacio de trabajo",
+  "hpcWizard.stepData": "Cargar datos",
+  "hpcWizard.stepRun": "Ejecutar trabajo",
+  "hpcWizard.stepWatch": "Observar",
+  "hpcWizard.sbatchJobName": "Nombre del trabajo",
+  "hpcWizard.sbatchPartition": "Partición",
+  "hpcWizard.sbatchTime": "Tiempo",
+  "hpcWizard.sbatchNodes": "Nodos",
+  "hpcWizard.sbatchTasks": "Tareas",
+  "hpcWizard.sbatchCpusPerTask": "CPU/tarea",
+  "hpcWizard.sbatchMemory": "Memoria",
+  "hpcWizard.sbatchGres": "GRES",
+  "hpcWizard.sbatchOutput": "Salida",
+  "hpcWizard.title": "Pipeline HPC",
+  "hpcWizard.loginHint": "Inicia sesión en tu clúster. Si solo es accesible a través de la VPN de tu institución, levanta primero el túnel de OpenVPN (en la sección SSH de abajo).",
+  "hpcWizard.projectNameLabel": "Nombre del proyecto",
+  "hpcWizard.mirrorLabel": "Ubicación local (espejo sincronizado)",
+  "hpcWizard.noFolderSelected": "Ninguna carpeta seleccionada",
+  "hpcWizard.browseBtn": "Explorar...",
+  "hpcWizard.hostPathHintPre": "En el host:",
+  "hpcWizard.hostPathHintPost": "— el siguiente paso puede mover esto a un espacio de trabajo en el sistema de archivos paralelo del clúster.",
+  "hpcWizard.watchPre": "Tu trabajo fue enviado y una pestaña de registro está siguiendo su salida. Abre la vista de Trabajos (el",
+  "hpcWizard.watchMid": "interruptor en el panel de archivos) para verlo en cola, ejecutarse y finalizar — con",
+  "hpcWizard.watchWatchWord": "Observar",
+  "hpcWizard.watchCancelWord": "Cancelar",
+  "hpcWizard.watchAnd": "y",
+  "hpcWizard.done": "Hecho",
+  "hpcWizard.noToolingPre": "Este host no tiene herramientas de workspace (",
+  "hpcWizard.noToolingPost": ").",
+  "hpcWizard.noToolingScratchHint": "Sí apunta a un sistema de archivos grande — elige dónde debería vivir este proyecto, ya que un directorio home suele tener cuota y está pensado para código.",
+  "hpcWizard.noToolingNoScratchPre": "El proyecto vivirá en la carpeta a la que navegaste:",
+  "hpcWizard.homeRadioLabel": "home",
+  "hpcWizard.readOnly": "solo lectura",
+  "hpcWizard.projectOnHostLabel": "Proyecto en el host:",
+  "hpcWizard.creating": "Creando…",
+  "hpcWizard.createProject": "Crear proyecto",
+  "hpcWizard.introPre": "En un clúster, tu directorio home es un sistema de archivos pequeño y con cuota, pensado para el código. Los datos de un cómputo pertenecen a un",
+  "hpcWizard.introStrongWorkspace": "espacio de trabajo",
+  "hpcWizard.introMid": "— un directorio en el sistema de archivos paralelo con un nombre y una duración, que",
+  "hpcWizard.introStrongDeleted": "se elimina al expirar",
+  "hpcWizard.introPost": ". Asigna uno ahora, antes de subir o sincronizar cualquier dato.",
+  "hpcWizard.checkingTooling": "Comprobando si el host tiene herramientas de workspace…",
+  "hpcWizard.workspaceNameLabel": "Nombre del espacio de trabajo",
+  "hpcWizard.daysLabel": "Días",
+  "hpcWizard.filesystemLabel": "Sistema de archivos",
+  "hpcWizard.siteDefault": "(predeterminado del sitio)",
+  "hpcWizard.defaultSuffix": " (predeterminado)",
+  "hpcWizard.reminderEmailLabel": "Correo de recordatorio",
+  "hpcWizard.optionalPlaceholder": "opcional",
+  "hpcWizard.remindDaysLabel": "Recordar días antes",
+  "hpcWizard.reminderHint": "Vale la pena configurar un recordatorio — la expiración elimina los datos. Muchos sitios solo entregan a su propio dominio.",
+  "hpcWizard.allocating": "Asignando…",
+  "hpcWizard.allocateWorkspace": "Asignar espacio de trabajo",
+  "hpcWizard.readingWorkspaces": "Leyendo tus espacios de trabajo…",
+  "hpcWizard.yourWorkspaces": "Tus espacios de trabajo",
+  "hpcWizard.whereProjectGoes": "Dónde va el proyecto",
+  "hpcWizard.inWorkspaceStrong": "En el espacio de trabajo",
+  "hpcWizard.inWorkspaceDesc": "— todo lo que Eldrun sincroniza (archivos, git, subidas) acaba en el sistema de archivos paralelo, nunca en tu cuota home.",
+  "hpcWizard.inBrowsedStrong": "En la carpeta explorada",
+  "hpcWizard.inBrowsedDesc": ", con el espacio de trabajo enlazado como",
+  "hpcWizard.linkNameLabel": "Nombre del enlace",
+  "hpcWizard.anchorPre": "Mantener una pequeña carpeta en mi home del clúster para este proyecto — job",
+  "hpcWizard.anchorMid": ", un",
+  "hpcWizard.anchorPost": "enlace, y un registro que nombra el espacio de trabajo. Sobrevive a la expiración del espacio de trabajo (no se coloca nada grande allí, y Eldrun nunca lo sincroniza).",
+  "hpcWizard.anchorFolderLabel": "Carpeta (bajo tu home)",
+  "hpcWizard.createWithoutWorkspace": "Crear sin un espacio de trabajo",
+  "hpcWizard.dataHintPre": "Opcionalmente, sube archivos de entrada. Acaban en",
+  "hpcWizard.dataHintWorkspaceSuffix": "— en el sistema de archivos paralelo, no en tu cuota home.",
+  "hpcWizard.dataHintPlainSuffix": ".",
+  "hpcWizard.dataHintPost": "Los árboles grandes se marcan mejor como auto-sincronización en el panel de archivos; esto es para unos pocos archivos.",
+  "hpcWizard.theProjectFolder": "la carpeta del proyecto",
+  "hpcWizard.linkNotCreatedSuffix": "/ (enlace no creado)",
+  "hpcWizard.uploading": "Subiendo…",
+  "hpcWizard.addFiles": "Añadir archivos…",
+  "hpcWizard.skip": "Omitir",
+  "hpcWizard.scriptHintPre": "Un script de lote inicial (",
+  "hpcWizard.scriptHintPost": ") se escribirá en el proyecto. Ajusta sus recursos y luego envíalo — se ejecuta en un nodo de cómputo.",
+  "hpcWizard.submitting": "Enviando…",
+  "hpcWizard.submitJob": "⏫ Enviar trabajo",
+  "projectDialog.installGitLabel": "Instalar git",
+  "projectDialog.installBinLabel": "Instalar {bin}",
+  "projectDialog.titleNew": "Nuevo proyecto",
+  "projectDialog.titleImport": "Importar proyecto",
+  "projectDialog.remoteToggleTitle": "Proyecto remoto (SSH)",
+  "projectDialog.remoteToggleDesc": "Trabaja en un proyecto que vive en otra máquina — las terminales, archivos y git se ejecutan todos en el host por SSH.",
+  "projectDialog.localLocationLabel": "Ubicación local",
+  "projectDialog.noFolderSelected": "Ninguna carpeta seleccionada",
+  "projectDialog.browseBtn": "Explorar...",
+  "projectDialog.localMirrorHint": "La copia de trabajo local sincronizada vive aquí como {name}.",
+  "projectDialog.projectNameLabel": "Nombre del proyecto",
+  "projectDialog.descriptionLabel": "Descripción del proyecto",
+  "projectDialog.descFillModeTitle": "Modo de rellenado de la descripción del proyecto",
+  "projectDialog.fillModeManual": "Manual",
+  "projectDialog.fillModeAgentChoice": "Elección del agente",
+  "projectDialog.descriptionPlaceholder": "Para qué sirve este proyecto",
+  "projectDialog.importFromLabel": "Importar desde",
+  "projectDialog.importFolderOpt": "Carpeta en esta máquina",
+  "projectDialog.importGitOpt": "Repositorio de GitHub / GitLab (clonar)",
+  "projectDialog.importForkOpt": "Repositorio de GitHub / GitLab (fork, luego clonar)",
+  "projectDialog.sourceFolderLabel": "Carpeta de origen",
+  "projectDialog.repoToForkLabel": "Repositorio a bifurcar",
+  "projectDialog.repoUrlLabel": "URL del repositorio",
+  "projectDialog.forkHintPre": "El repositorio se bifurca en tu propia cuenta, y tu fork es lo que se clona aquí — el original queda como el remoto",
+  "projectDialog.forkHintMid": "remoto. El fork se realiza a través de la CLI del proveedor (",
+  "projectDialog.forkHintPost": "), por lo que usa el inicio de sesión de esa CLI.",
+  "projectDialog.cloneHintPrivateConnected": "Un repositorio privado se clona con el token de acceso de Configuración → Alojamiento Git. Una URL SSH (git@…) usa en su lugar tus propias claves SSH.",
+  "projectDialog.cloneHintPublicOnly": "Los repositorios públicos se clonan tal cual. Para uno privado, añade un token de acceso en Configuración → Alojamiento Git, o usa una URL SSH (git@…) para autenticarte con tus claves SSH.",
+  "projectDialog.hostTypeLabel": "Tipo de host",
+  "projectDialog.detectFromUrl": "Detectar desde la URL",
+  "projectDialog.detectFromUrlWithProvider": "Detectar desde la URL ({provider})",
+  "projectDialog.hostTypeHint": "Este host no se identifica como GitHub o GitLab (una instancia autoalojada normalmente no lo hace) — elige cuál es, ya que el fork se hace con la CLI de ese proveedor.",
+  "projectDialog.forkCliMissingPre": "No se encontró",
+  "projectDialog.forkCliMissingMid1": "en esta máquina — un fork se crea con la propia CLI del proveedor, así que instálala (e inicia sesión con",
+  "projectDialog.forkCliMissingPost": ") para bifurcar desde",
+  "projectDialog.runInTerminalBtn": "Ejecutar en terminal",
+  "projectDialog.locationLabel": "Ubicación",
+  "projectDialog.cloneDestYourFork": "Tu fork se",
+  "projectDialog.cloneDestTheRepo": "El repositorio se",
+  "projectDialog.cloneDestMid": "clona en",
+  "projectDialog.cloneDestPost": "aquí.",
+  "projectDialog.gitHostingLabel": "Alojamiento Git",
+  "projectDialog.gitNoneOpt": "Sin git (archivos planos, sin repositorio)",
+  "projectDialog.gitLocalOpt": "Solo repositorio local (no se sube a ningún sitio)",
+  "projectDialog.gitRemotePrivateOpt": "Subir a GitHub/GitLab · privado",
+  "projectDialog.gitRemotePublicOpt": "Subir a GitHub/GitLab · público",
+  "projectDialog.gitHostingHintPre": "«Subir a GitHub/GitLab» publica el repositorio en un servicio de alojamiento",
+  "projectDialog.gitHostingHintRemoteSuffix": "— sin relación con el host SSH de arriba, que es simplemente donde viven los archivos del proyecto.",
+  "projectDialog.needsGitConnectionText": "Aún no hay una conexión de GitHub/GitLab configurada en Eldrun. Añade un token de acceso en Configuración → Alojamiento Git para que el repositorio pueda publicarse.",
+  "projectDialog.setUpGitHostingBtn": "Configurar GitHub/GitLab…",
+  "projectDialog.needsGitInstallTextPre": "No se encontró git en esta máquina — instálalo para crear un proyecto basado en git",
+  "projectDialog.needsGitInstallOrClone": " o clonar un repositorio",
+  "projectDialog.importModeLabel": "Modo de importación",
+  "projectDialog.modeKeepOpt": "Mantener ubicación (registrar en el lugar)",
+  "projectDialog.modeCopyOpt": "Copiar a la carpeta de proyectos de Eldrun",
+  "projectDialog.modeMoveOpt": "Mover a la carpeta de proyectos de Eldrun",
+  "projectDialog.remoteImportKeepsFolder": "La importación remota mantiene la carpeta en su lugar en el host remoto.",
+  "projectDialog.skipScaffoldLabel": "Omitir el andamiaje (no generar ningún archivo de scaffold)",
+  "projectDialog.scaffoldGuidanceAria": "Guía de scaffold de importación",
+  "projectDialog.importGuidanceTitle": "Guía de importación",
+  "projectDialog.stepSelectSource": "Selecciona la carpeta de origen y los metadatos del proyecto.",
+  "projectDialog.stepRegisterKeep": "Registra el proyecto en su ubicación actual.",
+  "projectDialog.stepCopyValidate": "Copia el proyecto a la carpeta de proyectos de Eldrun tras la validación manual.",
+  "projectDialog.stepMoveValidate": "Mueve el proyecto a la carpeta de proyectos de Eldrun tras la validación manual.",
+  "projectDialog.stepCreateScaffold": "Crea los archivos de scaffold que falten y confirma los que ya están.",
+  "projectDialog.stepWriteProjectJson": "Escribe project.json y añade el proyecto al selector.",
+  "projectDialog.manualValidationCopy": "He validado manualmente el destino de la copia y la carpeta de origen.",
+  "projectDialog.manualValidationMove": "He validado manualmente el destino del movimiento y la carpeta de origen.",
+  "projectDialog.fillAllLabel": "Rellenar todo",
+  "projectDialog.noMissingFiles": "No faltan archivos",
+  "projectDialog.chooseFillMode": "Elegir modo de rellenado...",
+  "projectDialog.alreadyThere": "Ya está",
+  "projectDialog.missingLabel": "Falta",
+  "projectDialog.alreadyThereKept": "Ya está, se conservará",
+  "projectDialog.missingWillAdd": "Falta, se añadirá",
+  "projectDialog.statusOnly": "Solo estado",
+  "projectDialog.chooseSourceToPreview": "Elige una carpeta de origen para previsualizar los archivos de scaffold.",
+  "projectDialog.loadingScaffoldPreview": "Cargando vista previa del scaffold...",
+  "projectDialog.remoteDestinationLabel": "Destino remoto: {path}",
+  "projectDialog.remoteLocationLabel": "Ubicación remota: {path}",
+  "projectDialog.changeFolderBtn": "Cambiar carpeta",
+  "projectDialog.changeFolderTitleWinManual": "Vuelve atrás para cambiar la ruta remota",
+  "projectDialog.changeFolderTitleBrowse": "Vuelve al navegador remoto para elegir otra carpeta",
+  "projectDialog.destinationLabel": "Destino: {path}",
+  "projectDialog.locationColonLabel": "Ubicación: {path}",
+  "projectDialog.forking": "Bifurcando...",
+  "projectDialog.cloningEllipsis": "Clonando...",
+  "projectDialog.working": "Trabajando...",
+  "projectDialog.create": "Crear",
+  "projectDialog.forkAndImport": "Bifurcar e importar",
+  "projectDialog.cloneAndImport": "Clonar e importar",
+  "projectDialog.import": "Importar",
+  "projectDialog.runInTerminalTitle": "Ejecutar este comando en una nueva pestaña de terminal",
+  "remoteProjectSection.vpnUpClickToReconnect": "El túnel OpenVPN está activo. Haz clic para reconectar.",
+  "remoteProjectSection.vpnFailedWithError": "La conexión VPN falló: {error}",
+  "remoteProjectSection.vpnFailedClickRetry": "La conexión VPN falló. Haz clic para reintentar.",
+  "remoteProjectSection.vpnBringUpHint": "Levanta ahora el túnel de OpenVPN para llegar a un host protegido por VPN.",
+  "remoteProjectSection.vpnSelectConfigFirst": "Selecciona primero una configuración de OpenVPN.",
+  "remoteProjectSection.stepConnectLabel": "Conectar",
+  "remoteProjectSection.stepBrowseLabel": "Explorar",
+  "remoteProjectSection.stepDetailsLabel": "Detalles",
+  "remoteProjectSection.remoteStepsAria": "Pasos del proyecto remoto",
+  "remoteProjectSection.passwordAuthWarning": "La autenticación por contraseña necesita OpenSSH 8.4+ o sshpass — actualiza OpenSSH o instala sshpass, o usa claves SSH (deja la contraseña en blanco).",
+  "remoteProjectSection.opensslMissingWarning": "No se encontró openvpn/pkexec — los hosts protegidos por VPN no pueden conectarse. Instala openvpn y polkit.",
+  "remoteProjectSection.vpnToggleDescLine1": "Solo necesario para un host protegido por VPN — déjalo desactivado si ya estás en la red correcta.",
+  "remoteProjectSection.vpnConfigLabel": "Configuración de OpenVPN",
+  "remoteProjectSection.vpnConfigCopiedHint": "(se copia en Eldrun al seleccionarlo)",
+  "remoteProjectSection.noOvpnSelected": "Ningún .ovpn seleccionado",
+  "remoteProjectSection.browseEllipsis": "Explorar…",
+  "remoteProjectSection.storedWithProject": "(almacenado con el proyecto)",
+  "remoteProjectSection.vpnUsernamePlaceholderNoDots": "Usuario de la cuenta OpenVPN",
+  "remoteProjectSection.savedInKeychainYour": "(guardado en el llavero de tu sistema operativo)",
+  "remoteProjectSection.notStoredUnlessSaved": "(no se guarda a menos que la guardes abajo)",
+  "remoteProjectSection.vpnAccountPasswordNoDots": "Contraseña de la cuenta OpenVPN",
+  "remoteProjectSection.keyPassphrasePlaceholderNoDots": "Frase de contraseña para la clave cifrada de la configuración",
+  "remoteProjectSection.vpnTermBtnTitleActive": "Levanta el túnel de OpenVPN en una terminal más abajo — introduce la frase de contraseña allí. Se mantiene activo para el nuevo proyecto.",
+  "remoteProjectSection.vpnTermHintClosed": "Haz clic arriba para abrir una terminal aquí — introduce la frase de contraseña allí. Eldrun nunca la maneja; el túnel se mantiene activo para el nuevo proyecto.",
+  "remoteProjectSection.vpnTermHintOpen": "Autentica el túnel más abajo — sigue funcionando para el nuevo proyecto después de cerrar este diálogo.",
+  "remoteProjectSection.sshAddressLabel": "Dirección SSH",
+  "remoteProjectSection.reuseSshAddressTitle": "Reutilizar una dirección SSH usada anteriormente",
+  "remoteProjectSection.sshAddressPlaceholder": "usuario@host o host:2222",
+  "remoteProjectSection.passwordLabel": "Contraseña",
+  "remoteProjectSection.notStoredBlankKey": "(no se guarda a menos que la guardes abajo; en blanco usa la clave SSH)",
+  "remoteProjectSection.sshSavedPlaceholder": "Usando la contraseña guardada — déjalo en blanco",
+  "remoteProjectSection.sshPasswordPlaceholderNoDots": "contraseña, o la frase de contraseña de tu clave — en blanco si la clave está desbloqueada",
+  "remoteProjectSection.connectingDotsShort": "Conectando...",
+  "remoteProjectSection.remotePathLabel": "Ruta remota",
+  "remoteProjectSection.remotePathHintNew": "(carpeta principal; el proyecto se crea dentro de ella)",
+  "remoteProjectSection.remotePathHintImport": "(ruta absoluta del proyecto existente)",
+  "remoteProjectSection.reuseRemotePathTitle": "Reutilizar una ruta remota usada anteriormente para este host",
+  "remoteProjectSection.remotePathPlaceholder": "/home/user/projects",
+  "remoteProjectSection.sshTermBtnTitle": "Abre el inicio de sesión SSH en una terminal más abajo — introduce ahí cualquier contraseña. El inicio de sesión permanece activo para el nuevo proyecto.",
+  "remoteProjectSection.tryBrowseTitle": "Si ya has terminado de iniciar sesión arriba, explora ahora el árbol remoto.",
+  "remoteProjectSection.sshTermHintClosedPre": "Haz clic arriba para abrir una terminal aquí — introduce ahí cualquier contraseña. Eldrun nunca la maneja; el inicio de sesión permanece activo para el nuevo proyecto.",
+  "remoteProjectSection.sshTermHintClosedSuffix": " En cuanto hayas iniciado sesión, el árbol remoto se abre para explorar.",
+  "remoteProjectSection.sshTermHintOpen": "Inicia sesión más abajo — la sesión sigue funcionando para el nuevo proyecto después de cerrar este diálogo.",
+  "remoteProjectSection.willCreateLabel": "Se creará: {path}",
+  "remoteProjectSection.selectedLabel": "Seleccionado: {path}",
+  "credentialPasteBar.typeItForMe": "Escríbelo por mí:",
+  "credentialPasteBar.pastedFlash": "pegado",
+  "credentialPasteBar.nothingSavedFlash": "no hay nada guardado para este inicio de sesión (o el llavero está bloqueado)",
+  "credentialPasteBar.pasteUsername": "Pegar usuario",
+  "credentialPasteBar.pasteUsernameTitle": "Escribe «{user}» en la terminal de inicio de sesión en la posición del cursor.",
+  "credentialPasteBar.pastePassword": "Pegar contraseña",
+  "credentialPasteBar.pastePasswordTitle": "Escribe la contraseña guardada para este inicio de sesión en la terminal en la posición del cursor — va directamente de tu llavero del sistema operativo a la terminal, nunca a través de la interfaz de Eldrun. Pulsa Intro tú mismo.",
+  "credentialPasteBar.pasteVpnUsernameTitle": "Escribe el nombre de usuario de autenticación de este túnel en la terminal en la posición del cursor.",
+  "credentialPasteBar.pastePassphrase": "Pegar frase de contraseña",
+  "credentialPasteBar.pasteVpnSecretTitle": "Escribe el secreto guardado para este túnel en la terminal en la posición del cursor — directamente de tu llavero del sistema operativo a la terminal. Pulsa Intro tú mismo.",
+  "credentialPasteBar.pasteKeyPassphrase": "Pegar passphrase de la clave",
+  "credentialPasteBar.pasteKeyPassphraseTitle": "Escribe la frase de contraseña de la clave privada guardada en la terminal en la posición del cursor — OpenVPN la pide por separado de la contraseña de la cuenta.",
+  "terminalSignIn.sshHostWord": "host SSH",
+  "terminalSignIn.vpnTunnelWord": "túnel OpenVPN",
+  "terminalSignIn.busyTitle": "Desconecta primero la terminal de inicio de sesión de abajo.",
+  "terminalSignIn.titleTemplate": "Inicia sesión en {what} en una terminal aquí en lugar de en estos campos. Hace sus propias preguntas — una contraseña, un código de desafío, un segundo aviso — y las respondes directamente; Eldrun nunca las ve. Solo para esta conexión: tu configuración headless permanece igual.",
+  "terminalSignIn.label": "Iniciar sesión en una terminal",
+  "terminalSignIn.failedHint": "el inicio de sesión falló — si {what} pide algo que no sea una contraseña (un código de desafío, un segundo aviso), solo una terminal puede responder",
+  "terminalSignIn.defaultHint": "para un host que pide más que una contraseña — un código de desafío, un segundo aviso",
+  "projectHoverCard.statusCurrent": "Actual",
+  "projectHoverCard.statusActive": "Activo",
+  "projectHoverCard.statusInactive": "Inactivo",
+  "projectHoverCard.timeUnderMinute": "< 1 min",
+  "projectHoverCard.cpuIdle": "inactivo",
+  "projectHoverCard.remoteLabel": "remoto",
+  "projectHoverCard.localLabel": "local",
+  "projectHoverCard.originLabel": "origen",
+  "projectHoverCard.todayPrefix": "Hoy:",
+  "projectHoverCard.pausedSuffix": "(en pausa)",
+  "projectHoverCard.cpuPrefix": "CPU:",
+  "windowControls.minimize": "Minimizar",
+  "windowControls.maximize": "Maximizar",
+  "connTypeIcon.offlineSuffix": " (sin conexión)",
+  "appTimer.globalActivityTitle": "Actividad global",
+  "appTimer.pausedResumeHint": "En pausa — haz clic para reanudar",
+  "appTimer.clickPauseHint": "Haz clic para pausar • Clic derecho para la actividad",
+  "appResource.processCountOne": "{count} proceso de Eldrun",
+  "appResource.processCountMany": "{count} procesos de Eldrun",
+  "appResource.gpuNoDeviceTitle": "Memoria de GPU en uso por modelos locales (Ollama) — la GPU de esta máquina no informa memoria propia",
+  "remoteConnMenu.statusError": "error",
+  "remoteConnMenu.statusConnecting": "conectando",
+  "remoteConnMenu.statusConnected": "conectado",
+  "remoteConnMenu.statusOff": "apagado",
+  "remoteConnMenu.ariaLabel": "Máquinas remotas — haz clic para conectar/gestionar los hosts de este proyecto",
+  "remoteConnMenu.workingWord": "en trabajo",
+  "vpnIndicator.keyringStayedLocked": "El llavero permaneció bloqueado — las credenciales VPN guardadas aún no se pueden leer.",
+  "vpnIndicator.keyringLockedConnectReason": "El llavero de tu sistema operativo está bloqueado, por lo que no se pueden leer las credenciales VPN guardadas. Desbloquéalo (o introduce la frase de contraseña abajo) para conectar.",
+  "vpnIndicator.savedCredentialsDidntWork": "Las credenciales VPN guardadas no funcionaron: {error}",
+  "vpnIndicator.noCredentialStore": "Esta máquina no tiene almacén de credenciales, así que no se puede guardar nada para este túnel.",
+  "vpnIndicator.noSavedCredentialsYet": "Aún no hay credenciales guardadas para este túnel — marca «Guardar credenciales de inicio de sesión» para saltarte esto la próxima vez.",
+  "vpnIndicator.enterCredentialsOnce": "Introduce las credenciales una vez — van a tu llavero del sistema operativo, y este túnel se conecta sin preguntar a partir de ahora.",
+  "vpnIndicator.saveCredentialsAria": "Guardar credenciales de inicio de sesión para {file}",
+  "vpnIndicator.saveCredsUnavailableTitle": "Esta máquina no tiene un almacén de credenciales del sistema operativo, así que no se puede guardar nada.",
+  "vpnIndicator.saveCredsSavedTitle": "Las credenciales de este túnel están en tu llavero del sistema operativo — conectar no pregunta. Desactívalo para eliminarlas.",
+  "vpnIndicator.saveCredsNotSavedTitle": "Pregunta una vez por las credenciales de este túnel, guárdalas en tu llavero del sistema operativo, y conecta sin preguntar a partir de entonces.",
+  "vpnIndicator.saveLoginCredentialsLabel": "Guardar credenciales de inicio de sesión",
+  "vpnIndicator.savedButLocked": "Guardado, pero tu llavero está bloqueado — desbloquéalo arriba para usarlas.",
+  "vpnIndicator.connectOnLaunchAria": "Conectar {file} al iniciar",
+  "vpnIndicator.connectOnLaunchHeadlessTitle": "Levanta este túnel automáticamente cuando Eldrun se inicia, usando las credenciales guardadas — sin preguntar. Reencamina este equipo desde el inicio.",
+  "vpnIndicator.connectOnLaunchInteractiveTitle": "Abre el comando de conexión de este túnel en la terminal raíz cuando Eldrun se inicia, para que te autentiques. Reencamina este equipo una vez que está activo.",
+  "vpnIndicator.connectOnLaunchLabel": "Conectar al iniciar",
+  "vpnIndicator.needSaveCredsFirstHintPre": "Activa",
+  "vpnIndicator.needSaveCredsFirstHintPost": "primero — la auto-conexión nunca pregunta, así que solo se ofrece cuando conectar puede ser silencioso.",
+  "vpnIndicator.startsWithEldrun": "Se inicia con Eldrun",
+  "vpnIndicator.waitsInRootTerminal": " (espera en la terminal raíz)",
+  "vpnIndicator.mainAriaLabel": "OpenVPN — conectar o desconectar un túnel",
+  "vpnIndicator.titleOff": "OpenVPN — sin túnel. Conectar uno enruta el tráfico de este equipo a través de él.",
+  "vpnIndicator.titleConnecting": "OpenVPN — conectando. Una vez activo, el tráfico de este equipo se enruta a través del túnel.",
+  "vpnIndicator.titleConnected": "OpenVPN — activo. El tráfico de este equipo se enruta a través del túnel.",
+  "vpnIndicator.vpnLabel": "VPN",
+  "vpnIndicator.note": "Un túnel enruta",
+  "vpnIndicator.noteStrong": "todo el tráfico de este equipo",
+  "vpnIndicator.notePost": "— no solo el de Eldrun — incluyendo tu navegador — mientras esté activo.",
+  "vpnIndicator.lockedBannerPre": "Tu llavero del sistema operativo está",
+  "vpnIndicator.lockedBannerStrong": "bloqueado",
+  "vpnIndicator.lockedBannerPost": ", así que las credenciales VPN guardadas no se pueden leer — conectar volverá a pedirlas hasta que se desbloquee.",
+  "vpnIndicator.unlockTitle": "Desbloquea el almacén de credenciales del sistema operativo para que se puedan usar las credenciales guardadas. Tu escritorio pide la contraseña del llavero.",
+  "vpnIndicator.unlocking": "Desbloqueando…",
+  "vpnIndicator.unlockKeyring": "Desbloquear llavero",
+  "vpnIndicator.heldForPrefix": "para",
+  "vpnIndicator.heldByNoProject": "no lo mantiene ningún proyecto",
+  "vpnIndicator.stopConnectingTitle": "Detiene el intento de levantar este túnel y restablece el enrutamiento normal.",
+  "vpnIndicator.stopConnecting": "Detener conexión",
+  "vpnIndicator.disconnectTunnelTitle": "Desactiva este túnel y restablece el enrutamiento normal. Los proyectos que lo usan permanecen abiertos; su SSH puede o no sobrevivir sin él.",
+  "vpnIndicator.disconnectTunnel": "Desconectar túnel",
+  "vpnIndicator.connectGroupLabel": "Conectar",
+  "vpnIndicator.removeConfigHint": "Elimina esta configuración de Eldrun y olvida sus credenciales guardadas.",
+  "vpnIndicator.usedByPre": "Usado por",
+  "vpnIndicator.usedByPost": "— conectar ese proyecto volverá a pedir una configuración.",
+  "vpnIndicator.removeConfigBtn": "Eliminar configuración",
+  "vpnIndicator.keepBtn": "Mantener",
+  "vpnIndicator.connectTunnelTitle": "Levanta este túnel. Enrutará el tráfico de este equipo — no solo el de Eldrun.",
+  "vpnIndicator.removeConfigTitle": "Elimina esta configuración guardada de Eldrun y olvida sus credenciales guardadas. Pregunta una vez más antes de hacerlo.",
+  "vpnIndicator.emptyStatePre": "Aún no hay ninguna configuración de OpenVPN guardada — añade un archivo",
+  "vpnIndicator.emptyStatePost": ", luego conéctala desde su fila (te pedirá la contraseña ahí).",
+  "vpnIndicator.addFirstConfigTitle": "Elige un archivo .ovpn y guárdalo en Eldrun. Añadirlo no conecta — lo conectas explícitamente después, donde pedirá tu contraseña.",
+  "vpnIndicator.addAnotherConfigTitle": "Elige otro archivo .ovpn y guárdalo en Eldrun. Añadirlo no conecta — lo conectas explícitamente desde su fila después.",
+  "vpnIndicator.addConfigBtn": "Añadir configuración…",
+};
+
+const fr: Dict = {
+  "common.back": "Retour",
+  "common.cancel": "Annuler",
+  "common.remove": "Supprimer",
+  "common.delete": "Supprimer",
+  "common.add": "Ajouter",
+  "common.reset": "Réinitialiser",
+  "common.recheck": "Revérifier",
+  "common.loading": "Chargement…",
+  "common.default": "par défaut",
+
+  "settings.title": "Paramètres",
+  "settings.theme": "Thème",
+  "settings.language": "Langue",
+  "settings.language.help":
+    "Définit la langue de l'interface d'Eldrun. Effet immédiat — aucun redémarrage.",
+  "settings.runScriptsBg": "Exécuter les scripts en arrière-plan",
+  "settings.claudeRemote": "Contrôle à distance de Claude",
+  "settings.headlessRemote": "Connexions distantes sans interface",
+  "settings.persistLocal": "Sessions locales persistantes (tmux)",
+  "settings.remoteFeatures": "Fonctions distantes",
+  "settings.vpnEnabled": "Contrôle du tunnel OpenVPN",
+  "settings.machinesEnabled": "Machines distantes globales",
+  "settings.energySaver": "Économiseur d'énergie",
+  "energy.off": "Désactivé",
+  "energy.battery": "Sur batterie",
+  "energy.always": "Toujours",
+  "settings.debug": "Mode débogage",
+  "settings.experimental": "Expérimental",
+  "settings.agentModeToggle": "Bascule Plan/Auto sur les onglets d'agent",
+  "settings.pythonRunDebug": "Exécuter/Déboguer Python dans la visionneuse de code",
+  "settings.resourceMonitor": "Moniteur de ressources",
+  "settings.showCpu": "Afficher l'utilisation du CPU",
+  "settings.showRam": "Afficher l'utilisation de la RAM",
+  "settings.showGpu": "Afficher l'utilisation du GPU",
+  "settings.showClockSeconds": "Afficher les secondes dans l'horloge d'en-tête",
+
+  "settings.calendar": "Calendrier",
+  "settings.weekStartsOn": "La semaine commence le",
+  "day.sunday": "Dimanche",
+  "day.monday": "Lundi",
+  "settings.defaultView": "Vue par défaut",
+  "view.day": "Jour",
+  "view.week": "Semaine",
+  "view.multiweek": "Multi-semaine",
+  "view.month": "Mois",
+  "view.agenda": "Agenda",
+  "view.tasks": "Tâches",
+  "settings.clock24": "Format 24 heures",
+  "settings.dayGridStart": "La grille du jour commence à",
+  "settings.defaultReminder": "Rappel par défaut",
+  "reminder.none": "Aucun",
+  "reminder.5": "5 minutes avant",
+  "reminder.15": "15 minutes avant",
+  "reminder.30": "30 minutes avant",
+  "reminder.60": "1 heure avant",
+  "reminder.1440": "1 jour avant",
+
+  "settings.hintsOnboarding": "Astuces et prise en main",
+  "settings.showHints": "Afficher les astuces contextuelles",
+  "settings.howToStart": "Comment démarrer...",
+  "settings.takeTour": "Faire une visite",
+  "settings.lessons": "Leçons",
+  "settings.resetHints": "Réinitialiser les astuces",
+
+  "settings.layout": "Disposition",
+  "settings.windowZoom": "Zoom de la fenêtre",
+  "settings.minSubWidth": "Largeur min. de la sous-fenêtre (px)",
+  "settings.minSubHeight": "Hauteur min. de la sous-fenêtre (px)",
+
+  "settings.downloads": "Téléchargements",
+  "settings.noDownloadFolders":
+    "Aucun dossier ajouté — le dossier Téléchargements du système est utilisé.",
+  "settings.addDownloadFolder": "Ajouter un dossier de téléchargement...",
+
+  "settings.usageStats": "Statistiques d'utilisation",
+  "settings.dailyRecap": "Afficher le récapitulatif au début de chaque journée",
+  "settings.openUsageStats": "Ouvrir les statistiques d'utilisation",
+
+  "settings.moreSettings": "Plus de paramètres",
+  "nav.git.title": "Hébergement Git",
+  "nav.git.blurb": "Profil d'hébergement, jeton d'accès et publication.",
+  "nav.vpn.title": "Connexion VPN automatique",
+  "nav.vpn.blurb": "Armer un tunnel enregistré pour se connecter au lancement.",
+  "nav.remoteHosts.title": "Connexions distantes",
+  "nav.remoteHosts.blurb": "Définir un chemin standard par hôte SSH.",
+  "nav.global.title": "Applications globales",
+  "nav.global.blurb": "Lanceurs de barre d'outils affichés dans tous les projets.",
+  "nav.filetypes.title": "Applications par type de fichier",
+  "nav.filetypes.blurb": "Choisir quelle application ouvre chaque type de fichier.",
+  "nav.agents.title": "Gérer les agents",
+  "nav.agents.blurb": "Installer ou mettre à jour les CLI des agents.",
+  "nav.shortcuts.title": "Raccourcis clavier",
+  "nav.shortcuts.blurb": "Réattribuer les raccourcis de navigation.",
+  "nav.archive.title": "Projets archivés",
+  "nav.archive.blurb": "Restaurer ou supprimer définitivement les projets archivés.",
+  "nav.scaffoldRepair.title": "Réparer la structure du projet",
+  "nav.scaffoldRepair.blurb": "Régénérer les fichiers de structure manquants.",
+  "nav.help.title": "Guide des fonctionnalités",
+  "nav.help.blurb": "Glossaire complet des fonctionnalités d'Eldrun.",
+  "settings.energyUnavailable": "État d'alimentation indisponible — traité comme sur secteur (inactif).",
+  "settings.energyActiveAlways": "Actuellement actif — toujours activé.",
+  "settings.energyActiveBattery": "Actuellement actif — fonctionne sur batterie.",
+  "settings.energyOff": "Désactivé — ne ralentit jamais.",
+  "settings.energyInactive": "Inactif — sur secteur.",
+  "settings.claudeRemoteHelp1": "Lance des onglets d'agent Claude avec",
+  "settings.claudeRemoteHelp2": "afin que vous puissiez les surveiller et les piloter depuis l'application ou le web Claude. Nécessite une connexion par abonnement Claude (pas une clé API) ; seul Claude le prend en charge.",
+  "settings.headlessRemoteHelp": "Lorsque c'est activé (par défaut), Eldrun établit les connexions SSH/OpenVPN en arrière-plan, en gérant le mot de passe de façon transitoire. Désactivez-le pour ouvrir plutôt chaque connexion comme un terminal interactif dans la racine d'Eldrun — vous tapez le mot de passe directement dans ce terminal et Eldrun ne le manipule jamais.",
+  "settings.persistLocalHelp1": "Lorsque c'est activé (par défaut), le shell et les onglets Python/script d'un projet local s'exécutent dans une session tmux sur cette machine, afin qu'une longue exécution continue si Eldrun plante, et l'onglet se rattache au redémarrage. Fermer un onglet met quand même fin à sa session. Nécessite",
+  "settings.persistLocalHelp2": " ; les onglets d'agent ne sont pas concernés.",
+  "settings.remoteFeaturesHelp": "Les deux ajoutent un contrôle à l'échelle de la machine dans l'en-tête : un tunnel OpenVPN (redirige le trafic de tout cet ordinateur tant qu'il est actif) et une liste de machines SSH qu'aucun projet ne possède. Désactivé par défaut ; demandé une fois au premier lancement.",
+  "settings.energyHelp": "Lorsque c'est actif, Eldrun se relâche pour économiser l'énergie : il met en pause la rotation au repos du blob de projet, calme les lueurs de statut et ralentit les actualisations en arrière-plan. « Sur batterie » (par défaut) ne le fait que lorsque débranché.",
+  "settings.experimentalHelp1": "Fonctionnalités encore en mouvement. Chacune est désactivée par défaut et",
+  "settings.experimentalHelpBold": "activée par défaut en mode débogage",
+  "settings.experimentalHelp2": "— ainsi, compiler Eldrun signifie les voir sans devoir recocher cette liste à chaque nouvelle arrivée. Un interrupteur ici l'emporte toujours, dans les deux sens : vous pouvez en activer une sans le mode débogage, ou en désactiver une tout en y étant.",
+  "settings.agentModeHelp1": "Place un badge sur chaque onglet d'agent qui le fait basculer entre",
+  "settings.agentModeHelp2": "(lit et propose, ne modifie jamais) et",
+  "settings.agentModeHelp3": "(accepte automatiquement les modifications ; les commandes shell et réseau demandent toujours) — ainsi un onglet peut planifier pendant qu'un autre fait le travail, et chacun revient dans son mode après un redémarrage. Basculer redémarre l'agent : la conversation reprend, mais l'historique du terminal est perdu. Seul Claude le prend en charge — c'est le seul agent capable à la fois d'être lancé dans un mode et de reprendre sa conversation au redémarrage.",
+  "settings.pythonRunHelp1": "Donne à un fichier",
+  "settings.pythonRunHelp2": "ouvert dans l'éditeur un bouton",
+  "settings.pythonRunHelp3": "et un",
+  "settings.pythonRunHelp4": "et transforme ses numéros de ligne en une marge de points d'arrêt. Les deux ouvrent un onglet terminal dans le projet — ils s'exécutent donc sur l'hôte d'un projet distant et dans le conteneur d'un projet conteneurisé — et utilisent le propre interpréteur du projet. Déboguer utilise",
+  "settings.pythonRunHelp5": ", préchargé avec les points d'arrêt de la marge. Désactivé par défaut car Exécuter exécute le fichier. Ctrl+clic vers une définition n'est pas verrouillé : il ne fait que lire.",
+  "settings.resourceMonitorHelp": "CPU et RAM couvrent l'arborescence de processus propre d'Eldrun ; GPU affiche la VRAM utilisée par les modèles locaux chargés dans Ollama. La pastille apparaît dans l'en-tête à côté du minuteur.",
+  "settings.reminderHelp": "Les rappels se déclenchent comme notification de bureau et comme fenêtre contextuelle dans l'app que vous pouvez reporter. « La grille du jour commence à » ne fait que définir jusqu'où défilent les vues jour et semaine — les événements antérieurs sont toujours là, juste au-dessus.",
+  "settings.zoomHelp1": "Le zoom de fenêtre redimensionne toute l'interface d'Eldrun — pratique sur les moniteurs 4K / haute densité. 100 % est la valeur par défaut. Le zoom est",
+  "settings.zoomHelpBold": "par fenêtre",
+  "settings.zoomHelp2": " : cela définit la fenêtre principale, et chaque sous-fenêtre détachée garde le sien. Ctrl + / Ctrl − zooment la fenêtre active et Ctrl 0 le réinitialise.",
+  "settings.minSubwindowHelp": "Taille minimale qu'une sous-fenêtre peut atteindre en faisant glisser un séparateur. Par défaut {px}px si laissé vide.",
+  "settings.downloadsHelp": "Dossiers analysés par la section Téléchargements du panneau de droite (le bouton 📥), pour copier rapidement des fichiers fraîchement téléchargés dans un projet. Lecture seule — Eldrun ne modifie jamais le chemin de téléchargement d'un navigateur. Par défaut, le dossier Téléchargements du système si vide.",
+  "settings.removeFolderTitle": "Supprimer ce dossier",
+  "settings.dailyRecapHelp": "Un résumé de la journée qui vient de se terminer : quels agents vous avez utilisés et combien vous les avez sollicités, fichiers créés/modifiés/supprimés, commits et temps par projet. Désactiver ceci arrête la fenêtre contextuelle, pas le comptage — tout reste local.",
+
+  "shortcuts.help":
+    "Cliquez sur un raccourci, puis appuyez sur la nouvelle combinaison de touches. F11 (plein écran du système) et Échap (quitter le plein écran) sont fixes et ne peuvent pas être réattribués.",
+  "shortcuts.captureTitle": "Cliquez, puis appuyez sur une combinaison de touches",
+  "shortcuts.pressKeys": "Appuyez sur les touches…",
+  "shortcuts.resetTitle": "Réinitialiser par défaut",
+
+  "git.help":
+    "Votre profil d'hébergement et votre jeton d'accès sont utilisés lors de la publication du dépôt d'un projet sur GitHub ou GitLab.",
+  "git.profileUrl": "URL du profil",
+  "git.profileUrlPlaceholder": "https://github.com/moi ou https://gitlab.com/moi",
+  "git.accessToken": "Jeton d'accès",
+  "git.tokenPlaceholder": "ghp_... / glpat-...",
+
+  "vpn.autoConnectHelp":
+    "Armez un tunnel OpenVPN enregistré pour qu'il se connecte automatiquement au démarrage d'Eldrun. Il redirige le trafic de tout cet ordinateur — pas seulement celui d'Eldrun — tant qu'il est actif ; une seule configuration peut donc être armée à la fois, en armer une autre désarme la première. Les configurations enregistrées s'ajoutent depuis la boîte de dialogue de connexion d'un projet distant ou le menu VPN de l'en-tête.",
+  "vpn.noConfig": "Aucune configuration OpenVPN enregistrée pour l'instant. Ajoutez-en une depuis la boîte de dialogue de connexion d'un projet distant.",
+  "vpn.needsSavedPre": "Connectez-vous une fois avec",
+  "vpn.needsSavedBold": "Enregistrer la phrase secrète",
+  "vpn.needsSavedPost": "coché pour activer ceci — la connexion automatique ne demande jamais.",
+  "vpn.startsWithEldrun": "Démarre avec Eldrun",
+  "vpn.waitsInRootTerminal": "(attend dans le terminal racine)",
+
+  "archive.help":
+    "Les projets supprimés sont conservés ici afin que vous puissiez les restaurer. La suppression permanente retire la copie archivée et son historique de suivi du temps. Les fichiers d'un projet distant (SSH) sur son hôte ne sont jamais touchés.",
+  "archive.empty": "Aucun projet archivé.",
+  "archive.remoteTag": "distant",
+  "archive.unsyncedVerifiedOne":
+    "{count} commit local sur {branches} n'a jamais été synchronisé avec l'hôte et sera perdu. Les fichiers de l'hôte lui-même ne sont pas affectés.",
+  "archive.unsyncedVerifiedMany":
+    "{count} commits locaux sur {branches} n'ont jamais été synchronisés avec l'hôte et seront perdus. Les fichiers de l'hôte lui-même ne sont pas affectés.",
+  "archive.unsyncedUnverifiedOne":
+    "Ce miroir contient {count} commit qui n'a pas pu être vérifié auprès de l'hôte ; la suppression abandonne la copie locale. Les fichiers de l'hôte lui-même ne sont pas affectés.",
+  "archive.unsyncedUnverifiedMany":
+    "Ce miroir contient {count} commits qui n'ont pas pu être vérifiés auprès de l'hôte ; la suppression abandonne la copie locale. Les fichiers de l'hôte lui-même ne sont pas affectés.",
+  "archive.typeToDelete": "Tapez « {name} » pour supprimer",
+  "archive.deleteForever": "Supprimer définitivement",
+  "archive.deleting": "Suppression…",
+  "archive.restore": "Restaurer",
+  "archive.restoring": "Restauration…",
+  "archive.deletePermanently": "Supprimer définitivement…",
+  "archive.typeDeleteAll": "Tapez « delete » pour tout vider",
+  "archive.clearArchive": "Vider l'archive",
+  "archive.clearing": "Vidage…",
+  "archive.clearArchiveEllipsis": "Vider l'archive…",
+
+  "scaffoldRepair.help":
+    "Complète tout fichier d'ossature (AGENTS.md, CLAUDE.md, .claude/settings.json, …) ou motif .gitignore par défaut manquant dans un projet — par ex. parce qu'il a été créé avant que ce fichier/motif ne soit ajouté à l'ossature par défaut. Les fichiers existants ne sont jamais écrasés ; un .gitignore préexistant ne reçoit que les lignes par défaut manquantes. S'exécute sur tous les projets gérés (dossier local ou, pour les projets distants, leur miroir local).",
+  "scaffoldRepair.runNow": "Réparer tous les projets maintenant",
+  "scaffoldRepair.running": "Réparation…",
+  "scaffoldRepair.upToDate": "L'ossature de chaque projet est déjà à jour.",
+
+  "help.title": "Aide d'Eldrun",
+  "help.intro": "Un guide rapide de ce que fait chaque partie d'Eldrun. Survolez aussi les boutons de la barre d'outils pour voir leurs raccourcis.",
+  "help.workspaceLayout.title": "Disposition de l'espace de travail",
+  "help.workspaceLayout.introMac":
+    "Eldrun garde votre développement assisté par IA dans une seule fenêtre. Poussez le curseur vers un bord de l'écran pour révéler les panneaux, et appuyez sur F11 pour le plein écran.",
+  "help.workspaceLayout.introOther":
+    "Eldrun garde votre développement assisté par IA dans une seule fenêtre. Appuyez sur {key} pendant qu'Eldrun a le focus pour basculer les panneaux, et F11 pour le plein écran.",
+  "help.workspaceLayout.item1.term": "Terminal racine (▣)",
+  "help.workspaceLayout.item1.desc":
+    "Le terminal de contrôle qui vit toujours dans le dossier racine d'Eldrun, indépendant de tout projet.",
+  "help.workspaceLayout.item2.term": "Pastilles de projet",
+  "help.workspaceLayout.item2.desc":
+    "Une pastille par projet actif dans le sélecteur de projets. Cliquez pour changer ; chaque projet garde son propre terminal et ses onglets. Faites glisser les pastilles pour les réordonner.",
+  "help.workspaceLayout.item3.term": "Panneau central et onglets",
+  "help.workspaceLayout.item3.desc":
+    "Les terminaux du projet actif. Clic droit sur la barre d'onglets pour ajouter un agent Claude/Codex/Gemini ou un shell simple, renommer ou fermer des onglets. Faites glisser les onglets pour les réordonner.",
+  "help.workspaceLayout.item4.term": "Panneau de fichiers de droite",
+  "help.workspaceLayout.item4.desc":
+    "Une superposition d'arborescence de fichiers pour le projet actif. Ouvrez des fichiers, renommez, et basculez les types de fichiers masqués. Le panneau retient le dernier dossier par projet.",
+  "help.projects.title": "Projets",
+  "help.projects.item1.term": "Ajouter (+)",
+  "help.projects.item1.desc":
+    "Créez un nouveau projet (génère des fichiers et un dépôt git dans le dossier de projets d'Eldrun) ou importez un dossier existant sans toucher à son contenu.",
+  "help.projects.item2.term": "Rechercher les inactifs",
+  "help.projects.item2.desc":
+    "La zone de recherche trouve les projets qui ne sont pas actuellement ouverts ; choisissez-en un pour activer sa pastille et son terminal.",
+  "help.projects.item3.term": "Projets distants (SSH)",
+  "help.projects.item3.desc":
+    "Les projets sur un hôte distant sont montés localement via sshfs et se comportent comme n'importe quel autre projet. Nécessite sshfs/FUSE installé.",
+  "help.projects.item4.term": "Tâches",
+  "help.projects.item4.desc":
+    "Clic droit sur un onglet pour définir, terminer ou effacer une tâche d'agent. Les tâches persistent dans le project.json du projet et peuvent alimenter le prompt d'un nouvel agent.",
+  "help.aiTerminals.title": "IA et terminaux",
+  "help.aiTerminals.item1.term": "Agents",
+  "help.aiTerminals.item1.desc":
+    "Ouvrez un agent (claude, codex, gemini, vibe, aider, opencode, cursor, copilot, grok, qwen, openclaw) ou un shell simple depuis le menu + de la barre d'onglets. Les commandes manquantes retombent sur un shell ; les agents fermés redémarrent.",
+  "help.aiTerminals.item2.term": "Modèles Ollama",
+  "help.aiTerminals.item2.desc":
+    "Quand Ollama est installé, le menu d'engrenage affiche les modèles locaux. Ctrl+K ouvre la boîte de dialogue de prompt de modèle local pour le contexte actif.",
+  "help.settingsExtras.title": "Paramètres et extras",
+  "help.settingsExtras.item1.term": "Paramètres (⚙)",
+  "help.settingsExtras.item1.desc":
+    "Thème, profil/jeton d'hébergement Git, gestion de l'espace de travail, scripts en arrière-plan et mode débogage.",
+  "help.settingsExtras.item2.term": "Intégration de l'espace de travail",
+  "help.settingsExtras.item2.desc":
+    "Isolation de bureau virtuel KDE/X11 par projet (Linux uniquement) : les fenêtres lancées de chaque projet se garent sur leur propre bureau.",
+  "help.settingsExtras.item3.term": "Suivi du temps",
+  "help.settingsExtras.item3.desc":
+    "Eldrun enregistre le temps de session actif pour que vous voyiez combien de temps vous passez par projet.",
+
+  "globalApps.title": "Applications globales",
+  "globalApps.help": "Applications qui restent visibles dans tous les espaces de travail. Les applications cochées apparaissent dans la barre d'outils supérieure.",
+  "globalApps.showRole": "Afficher {role}",
+  "globalApps.notFoundPlaceholder": "introuvable",
+
+  "filetypes.title": "Applications par type de fichier",
+  "filetypes.help": "Un double-clic sur un fichier du projet l'ouvre avec l'application ci-dessous.",
+  "filetypes.extPlaceholder": ".ext",
+  "filetypes.appPlaceholder": "commande de l'application",
+
+  "remoteHosts.help":
+    "Le dossier dans lequel une connexion ou un parcours s'ouvre pour un hôte SSH donné, au lieu du répertoire personnel de l'hôte. Défini une fois ici, il s'applique la prochaine fois que vous vous connectez à cet hôte — pour l'explorateur de dossiers d'un nouveau projet distant et pour la reconnexion d'un projet existant.",
+  "remoteHosts.empty": "Aucun chemin standard défini — les hôtes utilisent par défaut leur répertoire personnel.",
+  "remoteHosts.hostPlaceholder": "hôte",
+  "remoteHosts.pathPlaceholder": "/chemin/sur/l'hôte",
+
+  "agents.help1":
+    "Agents de codage IA qu'Eldrun peut lancer en onglets d'agent. Installez-en un en un clic (aucun droit administrateur requis), puis ajoutez-le depuis le menu",
+  "agents.help2": "d'une barre d'onglets. Beaucoup d'installateurs ont besoin de",
+  "agents.help3": "dans votre",
+  "agents.help4": "— s'il manque, installez d'abord Node.js ci-dessous.",
+  "agents.checkingInstalled": "Vérification des agents installés…",
+  "agents.installed": "installé",
+  "agents.notInstalled": "non installé",
+  "agents.disableToggleTitle":
+    "Masquer cet agent des menus de choix d'onglet (liste des agents à l'ajout d'onglet, pilotes de Modèle Local) sans le désinstaller",
+  "agents.disableAriaEnable": "Activer {label} dans les menus d'onglets",
+  "agents.disableAriaDisable": "Désactiver {label} dans les menus d'onglets",
+  "agents.disabled": "Désactivé",
+  "agents.enabled": "Activé",
+  "agents.removeTitle": "Supprimer la CLI installée",
+  "agents.removing": "Suppression…",
+  "agents.remove": "Supprimer",
+  "agents.reinstallTitle": "Supprimer puis relancer l'installateur officiel",
+  "agents.reinstalling": "Réinstallation…",
+  "agents.reinstall": "Réinstaller",
+  "agents.permissionHelpPre": "Si Supprimer échoue avec une erreur de permission, exécutez-le plutôt dans un onglet terminal",
+  "agents.permissionHelpPost": "(ajoutez",
+  "agents.permissionHelpPost2": "si demandé) :",
+  "agents.runInTerminal": "Exécuter dans le terminal",
+  "agents.installing": "Installation…",
+  "agents.installLabel": "Installer {label}",
+  "agents.runningInstaller": "Installateur en cours…",
+  "agents.orInstallInShellPre": "Ou installez-le dans un onglet terminal",
+  "agents.orInstallInShellPost": " :",
+  "agents.noWindowsInstallerPre": "Pas encore d'installateur en une ligne pour Windows — voir",
+  "agents.installDocs": "la documentation d'installation",
+  "agents.noWindowsInstallerPost": ", puis cliquez sur",
+  "agents.stillNotDetected": "Toujours pas détecté — essayez un terminal frais pour que le dossier d'installation soit dans le PATH.",
+  "agents.codexHookLabel": "Hook de session",
+  "agents.codexHookDisabled": "désactivé",
+  "agents.codexHookNotTrusted": "non approuvé",
+  "agents.codexHookHelpPre":
+    "Codex n'exécutera pas le hook de session d'Eldrun tant que vous ne lui faites pas confiance ; Eldrun se rabat alors sur la déduction, à partir des propres journaux de Codex, de la conversation appartenant à chaque onglet. Cela fonctionne, mais peut mélanger deux onglets Codex ouverts dans le même dossier. Activez",
+  "agents.codexHookHelpPost": "dans la liste",
+  "agents.codexHookHelpPost2": "de Codex pour une reprise exacte :",
+  "agents.openInCodex": "Ouvrir dans Codex",
+  "agents.nodeNotDetected": "non détecté",
+  "agents.nodeHelpPre": "La plupart des CLI d'agents s'installent avec",
+  "agents.nodeHelpMid": ", fourni avec Node.js. Installez-le une fois (aucun droit administrateur requis) dans un onglet terminal",
+  "agents.nodeHelpPost": ", puis installez vos agents ci-dessous :",
+  "agents.nodeManualPre": "Vous préférez une installation manuelle ? Voir",
+  "agents.nodeDownloads": "les téléchargements Node.js",
+
+  "ollama.vibeTitle": "Runtime de modèle local (Vibe)",
+  "ollama.vibeChecking": "Vérification de Vibe…",
+  "ollama.vibeInstalled": "Vibe est installé — les modèles locaux peuvent se lancer en onglets d'agent.",
+  "ollama.vibeMissing1": "Les modèles Ollama locaux fonctionnent via la CLI",
+  "ollama.vibeMissing2":
+    "de Mistral. Elle n'est pas encore installée, donc un onglet Modèle Local échoue avec « unable to spawn vibe ». Installez-la une fois (aucun droit administrateur requis) et les modèles locaux se lanceront.",
+  "ollama.installVibe": "Installer Vibe",
+  "ollama.installingEllipsis": "Installation…",
+  "ollama.runningInstaller": "Installateur en cours…",
+  "ollama.startingEllipsis": "Démarrage…",
+  "ollama.orInstallInShellPre": "Ou installez-le dans un onglet",
+  "ollama.orInstallInShellPost": " :",
+  "ollama.runInTerminal": "Exécuter dans le terminal",
+  "ollama.vibeStillNotDetectedWindows":
+    "Vibe n'est toujours pas détecté (ouvrez un terminal frais pour que l'emplacement d'installation soit dans le PATH).",
+  "ollama.vibeStillNotDetectedOther":
+    "Vibe n'est toujours pas détecté (essayez un terminal frais pour que ~/.local/bin soit dans le PATH).",
+  "ollama.installTitle": "Installer Ollama",
+  "ollama.notInstalledHelp":
+    "Ollama exécute des modèles ouverts localement sur votre machine. Il n'est pas encore installé. Installez-le une fois et Eldrun listera ici même les modèles que vous pouvez télécharger.",
+  "ollama.automaticInstall": "Installation automatique",
+  "ollama.autoInstallHelpWindows":
+    "Installe Ollama avec winget (silencieux, par utilisateur). winget est fourni avec Windows 10/11 ; s'il manque ou si l'installation échoue, suivez les étapes manuelles ci-dessous.",
+  "ollama.autoInstallHelpOther":
+    "Exécute le script d'installation officiel. Il nécessite des droits administrateur pour ajouter le service ollama, donc cela fonctionne sans invite seulement si votre compte a un sudo sans mot de passe. En cas d'échec, suivez les étapes manuelles ci-dessous.",
+  "ollama.installBtn": "Installer Ollama",
+  "ollama.installInTerminalTitle": "Installer dans un terminal",
+  "ollama.runInstallerNewPre": "Exécutez l'installateur pour votre système dans un nouvel onglet",
+  "ollama.runInstallerNewPost": " :",
+  "ollama.alsoDownloadFrom": "Vous pouvez aussi télécharger l'installateur directement depuis",
+  "ollama.approveUacPrompt": "Approuvez l'invite de contrôle de compte utilisateur si Windows le demande.",
+  "ollama.enterPasswordSudo": "Entrez votre mot de passe si l'installateur demande sudo.",
+  "ollama.onceFinishedClickPre": "Une fois terminé, cliquez sur",
+  "ollama.onceFinishedClickPost": "ci-dessous — les modèles installables apparaîtront automatiquement.",
+  "ollama.stillNotDetected": "Ollama n'est toujours pas détecté.",
+  "ollama.modelsTitle": "Modèles Ollama",
+  "ollama.checkingEllipsis": "Vérification...",
+  "ollama.serverRunningLabel": "Serveur en cours · {label}",
+  "ollama.serverNotRunning": "Serveur arrêté",
+  "ollama.noModelLoaded": "Aucun modèle chargé",
+  "ollama.noLoadedModel": "Aucun modèle chargé",
+  "ollama.loadedModels": "Chargé : {names}",
+  "ollama.start": "Démarrer",
+  "ollama.refresh": "Actualiser",
+  "ollama.downloadingTitle": "Téléchargement",
+  "ollama.pauseTitle": "Mettre en pause ce téléchargement (reprendre plus tard)",
+  "ollama.pause": "Pause",
+  "ollama.downloadPaused": "Téléchargement en pause — reprenez pour le terminer, ou supprimez les données partielles.",
+  "ollama.resume": "Reprendre",
+  "ollama.deletePartialTitle": "Supprimer le téléchargement partiel pour libérer de l'espace disque",
+  "ollama.delete": "Supprimer",
+  "ollama.downloadInterrupted": "Le téléchargement a été interrompu — reprenez-le pour le terminer.",
+  "ollama.continueDownload": "Continuer le téléchargement",
+  "ollama.dismissTitle": "Oublier ce téléchargement interrompu",
+  "ollama.dismiss": "Ignorer",
+  "ollama.orphansSummaryOne":
+    "{count} couche partielle orpheline ({size}) — téléchargements interrompus sans nom de modèle récupérable. Retéléchargez le modèle pour reprendre, ou supprimez pour libérer de l'espace.",
+  "ollama.orphansSummaryMany":
+    "{count} couches partielles orphelines ({size}) — téléchargements interrompus sans nom de modèle récupérable. Retéléchargez le modèle pour reprendre, ou supprimez pour libérer de l'espace.",
+  "ollama.orphanLayer": "couche {digest}…",
+  "ollama.deleteLayerTitle": "Supprimer cette couche partielle pour libérer de l'espace disque",
+  "ollama.downloadedModelsTitle": "Modèles téléchargés",
+  "ollama.noModelsDownloaded": "Aucun modèle téléchargé",
+  "ollama.unloadTitle": "Décharger de la mémoire",
+  "ollama.unload": "Décharger",
+  "ollama.loadTitle": "Charger en mémoire maintenant et le garder résident",
+  "ollama.load": "Charger",
+  "ollama.loading": "Chargement…",
+  "ollama.updateTitle": "Vérifier les mises à jour et télécharger la dernière",
+  "ollama.update": "Mettre à jour",
+  "ollama.updating": "Mise à jour…",
+  "ollama.deleteModelTitle": "Supprimer ce modèle",
+  "ollama.loadingIntoMemoryTitle": "Chargement en mémoire…",
+  "ollama.loadingIntoMemory": "Chargement en mémoire…",
+  "ollama.browseRegistry": "Parcourir le registre Ollama",
+  "ollama.pullHelp1": "Téléchargez n'importe quel modèle du registre Ollama. Tapez une référence exacte pour télécharger directement, ou recherchez et filtrez la liste complète ci-dessous. Utilisez une référence complète comme",
+  "ollama.pullHelp2": "ou",
+  "ollama.pullPlaceholder": "nom du modèle ou namespace/model:tag",
+  "ollama.pull": "Télécharger",
+  "ollama.pulling": "Téléchargement…",
+  "ollama.searchPlaceholder": "Rechercher tous les modèles par nom ou description…",
+  "ollama.sortBy": "Trier par",
+  "ollama.sort.popular": "Les plus populaires",
+  "ollama.sort.newest": "Les plus récents",
+  "ollama.sort.pulls": "Le plus de téléchargements",
+  "ollama.sort.name": "Nom (A–Z)",
+  "ollama.sort.sizeAsc": "Taille : petit → grand",
+  "ollama.sort.sizeDesc": "Taille : grand → petit",
+  "ollama.filterType": "Type",
+  "ollama.filterParams": "Paramètres",
+  "ollama.any": "Tous",
+  "ollama.cap.tools": "outils",
+  "ollama.cap.vision": "vision",
+  "ollama.cap.thinking": "raisonnement",
+  "ollama.cap.embedding": "embedding",
+  "ollama.cap.audio": "audio",
+  "ollama.pullsSuffix": "{pulls} téléchargements",
+  "ollama.tagUpdateTitle": "Mettre à jour {name}{size}",
+  "ollama.tagDownloadTitle": "Télécharger {name}{size}",
+  "ollama.sizeLoadingSuffix": " — taille…",
+  "ollama.pullLower": "télécharger",
+  "ollama.noModelsFound": "Aucun modèle trouvé",
+  "ollama.noMatchSizeFilter":
+    "Aucun modèle chargé ne correspond à la taille sélectionnée — chargez-en plus ou effacez le filtre Paramètres",
+  "ollama.endOfResults": "Fin des résultats",
+  "ollama.pausedBadge": "en pause",
+  "ollama.interruptedBadge": "interrompu",
+  "globalAppMenu.title": "Applications globales",
+  "howToStart.title": "Bienvenue dans Eldrun",
+  "howToStart.intro": "Eldrun garde votre développement assisté par IA dans une seule fenêtre. Voici comment démarrer :",
+  "howToStart.openFeatureGuide": "Ouvrir le guide des fonctionnalités...",
+  "howToStart.takeTour": "Faire une visite",
+  "howToStart.lessons": "Leçons",
+  "howToStart.gotIt": "Compris",
+  "remoteFeatures.title": "Utilisez-vous un VPN ou des machines distantes ?",
+  "remoteFeatures.help": "Eldrun peut contrôler un tunnel OpenVPN et se connecter à des machines SSH sur lesquelles vous n'avez pas de projet, tous deux depuis l'en-tête. Les deux sont désactivés par défaut — activez celui que vous utiliserez. L'un ou l'autre peut être basculé à tout moment depuis les Paramètres.",
+  "remoteFeatures.continue": "Continuer",
+  "lessons.title": "Leçons",
+  "lessons.intro": "De courtes visites guidées pour les tâches courantes. Choisissez-en une — elle vous montrera tout étape par étape.",
+  "globalApp.role.browser": "Navigateur",
+  "globalApp.role.mail": "Courrier",
+  "globalApp.role.calendar": "Calendrier",
+  "globalApp.role.print_manager": "Gestionnaire d'impression",
+  "globalApp.role.file_manager": "Gestionnaire de fichiers",
+  "globalApp.role.password_manager": "Gestionnaire de mots de passe",
+  "globalApp.role.video_conf": "Visioconf.",
+  "globalApp.role.media_player": "Lecteur multimédia",
+  "globalApp.role.system_monitor": "Moniteur système",
+  "globalApp.role.notes": "Notes",
+  "globalApp.role.screenshot": "Capture d'écran",
+  "globalApp.role.screen_recorder": "Enregistreur d'écran",
+  "globalApp.role.chat": "Discussion",
+  "globalApp.rightClickConfigure": "Clic droit pour configurer",
+  "globalApp.noCommandConfigured": "Aucune commande configurée",
+  "globalApp.clear": "Effacer",
+  "globalApp.set": "Définir",
+  "header.dragToMove": "Faites glisser pour déplacer la fenêtre Eldrun",
+  "header.rootTerminal": "Terminal racine",
+  "rightPanel.resizeTitle": "Faites glisser pour redimensionner le panneau",
+  "rightPanel.moveRight": "Déplacer le panneau vers le bord droit",
+  "rightPanel.moveLeft": "Déplacer le panneau vers le bord gauche",
+  "rightPanel.unpinTitle": "Détacher le panneau (autoriser le masquage automatique)",
+  "rightPanel.pinTitle": "Épingler le panneau ouvert",
+  "rightPanel.showHidden": "Afficher les sous-fenêtres masquées",
+  "rightPanel.collapse": "Réduire",
+  "rightPanel.hiddenCount": "Masquées ({count})",
+  "rightPanel.hiddenWaiting": "Une sous-fenêtre masquée attend votre action",
+  "rightPanel.hiddenWorking": "Une sous-fenêtre masquée est en cours de traitement",
+  "rightPanel.hiddenFinished": "Une sous-fenêtre masquée a terminé, non vue",
+  "rightPanel.restoreFocusedOn": "Restaurer avec le focus sur « {label} »",
+  "rightPanel.restoreSubwindow": "Restaurer la sous-fenêtre",
+  "rightPanel.closeSubwindow": "Fermer la sous-fenêtre (abandonner ses onglets)",
+  "vpnPrompt.titleConnected": "VPN connecté",
+  "vpnPrompt.titlePassword": "Mot de passe VPN",
+  "vpnPrompt.close": "Fermer",
+  "vpnPrompt.closeTitleConnected": "Fermer — le tunnel reste actif.",
+  "vpnPrompt.closeTitleConnecting": "Arrêter l'établissement du tunnel et fermer — tout tunnel à moitié ouvert est démantelé.",
+  "vpnPrompt.closeTitleDefault": "Fermer sans se connecter.",
+  "vpnPrompt.upFor": "OpenVPN est actif pour",
+  "vpnPrompt.connectingFor": "Connexion d'OpenVPN pour",
+  "vpnPrompt.trafficScope": "Tant que le tunnel est actif, le trafic de cet ordinateur y transite — votre navigateur aussi, pas seulement Eldrun.",
+  "vpnPrompt.username": "Nom d'utilisateur",
+  "vpnPrompt.usernamePlaceholder": "Nom d'utilisateur du compte OpenVPN…",
+  "vpnPrompt.password": "Mot de passe",
+  "vpnPrompt.passphrase": "Phrase secrète",
+  "vpnPrompt.savedInKeychain": "(enregistré dans le trousseau du système)",
+  "vpnPrompt.notStored": "(non stockée)",
+  "vpnPrompt.keyPassphraseLabel": "Phrase secrète de la clé privée",
+  "vpnPrompt.keyPassphrasePlaceholder": "Phrase secrète pour la clé chiffrée de la configuration…",
+  "vpnPrompt.keyPassphraseHint": "La clé privée de cette configuration est chiffrée, donc OpenVPN demande sa phrase secrète séparément du mot de passe du compte.",
+  "vpnPrompt.saveVpnCredentials": "Enregistrer les identifiants VPN",
+  "vpnPrompt.savePassphrase": "Enregistrer la phrase secrète",
+  "vpnPrompt.storedSecurely": "stockée en sécurité dans le trousseau de votre système",
+  "vpnPrompt.tunnelUp": "Tunnel actif — le trafic de cet ordinateur y transite désormais.",
+  "vpnPrompt.challengeHintPre": "Si cette configuration demande quelque chose que ces champs ne peuvent pas fournir — un code de challenge, ou une invite qui lui est propre — utilisez",
+  "vpnPrompt.logInTerminal": "Se connecter dans le terminal",
+  "vpnPrompt.challengeHintPost": "ci-dessous : OpenVPN y demande directement, et Eldrun ne voit toujours jamais ce que vous tapez.",
+  "vpnPrompt.closeStaysUpTitle": "Fermer — le tunnel reste actif. Coupez-le depuis l'indicateur VPN de l'en-tête.",
+  "vpnPrompt.terminalBtnStopFirst": "Arrêtez d'abord la tentative en cours, puis connectez-vous dans le terminal.",
+  "vpnPrompt.terminalBtnHandoff": "Confie cette connexion à un onglet terminal racine et connectez-vous là — OpenVPN demande lui-même le mot de passe (et tout code de challenge), et Eldrun ne le voit jamais. Cette connexion uniquement ; votre réglage headless reste inchangé.",
+  "vpnPrompt.cancelTitleConnecting": "Arrêtez l'établissement du tunnel et fermez ceci — tout tunnel à moitié ouvert est démantelé.",
+  "vpnPrompt.stop": "Arrêter",
+  "vpnPrompt.connectTitleConnecting": "Établissement du tunnel OpenVPN — pkexec peut demander une élévation…",
+  "vpnPrompt.connectTitleError": "Échec de la connexion — vérifiez la phrase secrète et réessayez.",
+  "vpnPrompt.connectTitleDefault": "Établir le tunnel OpenVPN.",
+  "vpnPrompt.connecting": "Connexion…",
+  "vpnPrompt.retry": "Réessayer",
+  "vpnPrompt.connect": "Connecter",
+  "projectSwitcher.howToStartMenu": "Comment démarrer",
+  "projectSwitcher.scrollLeft": "Faire défiler les projets vers la gauche",
+  "projectSwitcher.scrollRight": "Faire défiler les projets vers la droite",
+  "projectSwitcher.addOrImport": "Ajouter ou importer un projet",
+  "projectSwitcher.newProject": "Nouveau projet",
+  "projectSwitcher.importProject": "Importer un projet",
+  "projectSwitcher.importFromGitHub": "Importer depuis GitHub/GitLab",
+  "projectSwitcher.hpcPipeline": "Pipeline HPC…",
+  "projectSwitcher.newBox": "Nouvelle boîte",
+  "localModel.role.autocomplete": "Saisie automatique",
+  "localModel.role.grammar": "Grammaire",
+  "localModel.role.tabs": "Onglets",
+  "localModel.installTitle": "Installer un modèle local",
+  "localModel.runningLoaded": "Ollama en cours · modèle chargé",
+  "localModel.running": "Ollama en cours",
+  "localModel.stopped": "Ollama arrêté",
+  "localModel.modelSuffix": " · modèle : {name}",
+  "localModel.noModelSelected": " · aucun modèle sélectionné",
+  "localModel.ariaLabel": "Modèle local",
+  "localModel.agentsGroup": "Agents",
+  "localModel.agentInstalled": "{label} installé",
+  "localModel.manageAgents": "Gérer les agents…",
+  "localModel.localModelsGroup": "Modèles locaux",
+  "localModel.downloadingTitle": "Téléchargement",
+  "localModel.pausedTitle": "En pause",
+  "localModel.pauseDownloadTitle": "Mettre en pause le téléchargement",
+  "localModel.resumeDownloadTitle": "Reprendre le téléchargement",
+  "localModel.deletePartialDownloadTitle": "Supprimer le téléchargement partiel",
+  "localModel.gpuUsedTotal": "GPU {used} / {total}",
+  "localModel.gpuFree": "{free} libre",
+  "localModel.notInstalled": "Ollama non installé",
+  "localModel.noModelsInstalled": "Aucun modèle installé",
+  "localModel.serverStopped": "Serveur arrêté",
+  "localModel.defaultLoadedTitle": "Modèle local par défaut · chargé en mémoire",
+  "localModel.loadedClickDefaultTitle": "Chargé en mémoire — cliquez pour en faire le modèle par défaut",
+  "localModel.defaultTag": "par défaut",
+  "localModel.usedForRole": "Utilisé pour {role} — cliquez pour désassigner",
+  "localModel.useForRole": "Utiliser {name} pour {role}",
+  "localModel.unloadFromMemoryTitle": "Décharger {name} de la mémoire",
+  "localModel.unloading": "Déchargement…",
+  "localModel.loadIntoMemoryGroup": "Charger en mémoire",
+  "localModel.failedRetryTitle": "Échec du chargement — cliquez pour réessayer",
+  "localModel.loadIntoMemoryTitle": "Charger en mémoire",
+  "localModel.failed": "Échec",
+  "localModel.manageLocalModels": "Gérer les modèles locaux…",
+  "localModel.installOllamaEllipsis": "Installer Ollama…",
+  "localModel.notRunning": "Ollama n'est pas en cours",
+  "localModel.failedToLoadModel": "Échec du chargement du modèle",
+  "localModel.failedToUnloadModel": "Échec du déchargement du modèle",
+  "localModel.failedToLoadModels": "Échec du chargement des modèles",
+  "appShell.vpnStillActiveTitle": "Tunnel VPN toujours actif",
+  "appShell.vpnStillActiveMessage": "Le tunnel OpenVPN est toujours actif et redirige toute cette machine. Il continuera de fonctionner après la fermeture d'Eldrun — utilisez le contrôle VPN de l'en-tête pour le fermer vous-même une fois terminé.",
+  "appShell.showFilesPanel": "Afficher le panneau de fichiers",
+  "detached.loadingSubwindow": "Chargement de la sous-fenêtre…",
+  "centerPanel.noTabsOpen": "Aucun onglet ouvert",
+  "centerPanel.noTabsHintPre": "Utilisez",
+  "centerPanel.noTabsHintPost": "sur la barre d'onglets ci-dessus pour ouvrir un shell ou un agent IA.",
+  "detachedTabs.scrollLeft": "Faire défiler les onglets vers la gauche",
+  "detachedTabs.scrollRight": "Faire défiler les onglets vers la droite",
+  "detachedTabs.dragToMove": "Faites glisser pour déplacer cette fenêtre",
+  "detachedTabs.closeTab": "Fermer l'onglet",
+  "detachedTabs.newTab": "Nouvel onglet",
+  "detachedTabs.hideWindow": "Masquer cette fenêtre dans le panneau de droite (la récupérer depuis là)",
+  "tour.skip": "Ignorer la visite",
+  "tour.back": "Retour",
+  "tour.done": "Terminé",
+  "tour.next": "Suivant",
+  "hint.dismissAria": "Ignorer l'astuce",
+  "hint.dontShowHints": "Ne plus afficher les astuces",
+  "hint.notNow": "Pas maintenant",
+  "untested.title": "Cette fonctionnalité est implémentée mais pas encore testée en conditions réelles",
+  "untested.label": "non testé",
+  "vpnNotice.ariaLabel": "Tunnel OpenVPN",
+  "vpnNotice.alreadyUp": "Le tunnel OpenVPN est déjà actif",
+  "vpnNotice.desc": "Cet ordinateur transite déjà par un tunnel, ce projet n'en a donc pas besoin d'un second. Gérez les tunnels depuis le contrôle VPN de l'en-tête.",
+  "connLog.ariaLabel": "Journal de connexion OpenVPN",
+  "connLog.startingVpn": "Démarrage d'OpenVPN…",
+  "folderPicker.upOneFolder": "Remonter d'un dossier",
+  "folderPicker.up": "Remonter",
+  "folderPicker.noSubfolders": "Aucun sous-dossier ici.",
+  "folderPicker.folderPrefix": "Dossier :",
+  "blob.noProjectsYet": "Pas encore de projets — créez-en un pour peupler le nuage.",
+  "blob.backToProjects": "Retour aux projets",
+  "blob.sphereView": "Sphère",
+  "blob.sphereViewTitle": "Sphère 3D des projets",
+  "blob.pieView": "Camembert",
+  "blob.pieViewTitle": "Diagramme circulaire du temps suivi",
+  "blob.hintFocused": "Cliquez sur un dossier pour entrer · cliquez sur un fichier pour l'ouvrir · centre ou Échap pour revenir",
+  "blob.hintPie": "Taille de la part = temps suivi · cliquez pour ouvrir un projet · clic droit pour le menu",
+  "blob.hintCloud": "Faites glisser pour orbiter · défilez pour zoomer · cliquez pour explorer les fichiers · double-cliquez pour ouvrir · clic droit pour le menu",
+  "blob.noProjectsToChart": "Pas encore de projets à représenter.",
+  "blob.projectCountOne": "{count} projet",
+  "blob.projectCountMany": "{count} projets",
+  "blob.projectRoot": "racine du projet",
+  "blob.noDescriptionYet": "Pas encore de description.",
+  "blob.hintCenterUp": "Cliquez pour remonter · double-cliquez pour ouvrir · Échap pour quitter",
+  "blob.hintExploreOpen": "Cliquez pour explorer les fichiers · double-cliquez pour ouvrir",
+  "blob.boxMetaOne": "Boîte · {count} projet",
+  "blob.boxMetaMany": "Boîte · {count} projets",
+  "blob.doubleClickToOpen": "Double-cliquez pour ouvrir",
+  "blob.folder": "Dossier",
+  "blob.extFile": "fichier {ext}",
+  "blob.file": "Fichier",
+  "blob.clickToEnterFolder": "Cliquez pour entrer dans le dossier",
+  "blob.clickToOpen": "Cliquez pour ouvrir",
+  "blob.open": "Ouvrir",
+  "blob.categoriesEllipsis": "Catégories…",
+  "blob.activate": "Activer",
+  "blob.inactivate": "Désactiver",
+  "blob.loadingLower": "chargement…",
+  "pageStrip.ariaLabel": "Pages",
+  "pageStrip.turnClockwiseTitle": "Faire pivoter cette page de 90° dans le sens horaire",
+  "pageStrip.turnClockwiseAria": "Faire pivoter la page dans le sens horaire",
+  "pageStrip.removePageTitle": "Supprimer cette page",
+  "pageStrip.removePageAria": "Supprimer la page",
+  "pageStrip.turnRight": "Pivoter à droite",
+  "pageStrip.turnLeft": "Pivoter à gauche",
+  "pageStrip.duplicate": "Dupliquer",
+  "pageStrip.deleteOne": "Supprimer la page",
+  "pageStrip.deleteMany": "Supprimer {count} pages",
+  "usage.toneGreen": "vert",
+  "usage.toneOrange": "orange",
+  "usage.toneRed": "rouge",
+  "usage.utilizationAria": "utilisation {tone}",
+  "usage.cpu": "CPU",
+  "usage.coresOne": "({count} cœur)",
+  "usage.coresMany": "({count} cœurs)",
+  "usage.loadAverage": "Charge moyenne",
+  "usage.memory": "Mémoire",
+  "usage.loggedIn": "Connecté",
+  "usage.sessionsOne": "({count} session)",
+  "usage.sessionsMany": "({count} sessions)",
+  "usage.userCol": "Utilisateur",
+  "usage.sessionsCol": "Sessions",
+  "usage.memCol": "Mém",
+  "usage.noInteractiveLogins": "Aucune connexion interactive sur cet hôte.",
+  "usage.topProcesses": "Principaux processus",
+  "usage.cpuSuffix": "cpu",
+  "usage.memSuffix": "mém",
+  "usage.title": "Utilisation actuelle de l'hôte distant",
+  "usage.noMachines": "Aucune machine à vérifier — ajoutez-en une dans le menu Machines, ou ouvrez un projet distant.",
+  "usage.lede": "Charge, mémoire et sessions connectées sur {hosts}, {reading} — voici ce qui tourne en ce moment.",
+  "usage.hostSingular": "1 hôte",
+  "usage.hostsPlural": "{count} hôtes",
+  "usage.beingReadNow": "en cours de lecture",
+  "usage.asLastRead": "tel que lu la dernière fois",
+  "usage.checkingEllipsis": "Vérification…",
+  "usage.noReading": "Aucune lecture — l'hôte est peut-être injoignable.",
+  "usage.rechecking": "Nouvelle vérification…",
+  "usage.recheck": "Revérifier",
+  "hostKey.title": "Est-ce la bonne machine ?",
+  "hostKey.ledePre": "Eldrun ne s'est jamais connecté à",
+  "hostKey.ledePost": "auparavant, et il est sur le point d'y envoyer un mot de passe. Vérifiez l'empreinte ci-dessous avec celle indiquée par l'administrateur de l'hôte (ou une autre machine à laquelle vous faites déjà confiance) — si elle ne correspond pas, autre chose répond pour cette adresse.",
+  "hostKey.readingKey": "Lecture de la clé de l'hôte…",
+  "hostKey.errorHeading": "La clé de l'hôte n'a pas pu être lue, il n'y a donc rien à vérifier. Rien n'a été envoyé.",
+  "hostKey.acceptNotePre": "Accepter enregistre cette clé dans",
+  "hostKey.acceptNotePost": ". Vous ne serez plus demandé — et si la clé change un jour, la connexion sera purement refusée.",
+  "hostKey.accepting": "Acceptation…",
+  "hostKey.acceptAndConnect": "Accepter et se connecter",
+  "localLoss.kindDeleted": "supprimé localement",
+  "localLoss.kindOverwritten": "écrasé localement",
+  "localLoss.sourceGit": "Git en lockstep",
+  "localLoss.sourceSync": "Synchronisation de fichiers",
+  "localLoss.entryCountOne": "{count} fichier {kind}",
+  "localLoss.entryCountMany": "{count} fichiers {kind}",
+  "localLoss.moreCount": "…et {count} de plus",
+  "localLoss.unrecoverable": "Ce contenu n'a jamais existé que sur cette machine — il ne peut pas être récupéré.",
+  "localLoss.title": "Fichiers modifiés dans votre copie locale",
+  "localLoss.ledePre": "La synchronisation de ce projet avec l'hôte a détruit quelque chose dans votre copie locale —",
+  "localLoss.ledeMid": "sur",
+  "localLoss.ledePost": ". C'est exactement ce que git et la synchro sont censés faire quand les deux côtés évoluent ; c'est listé ici parce que c'est arrivé sur votre machine, et sans demander.",
+  "localLoss.filesCountOne": "{count} fichier",
+  "localLoss.filesCountMany": "{count} fichiers",
+  "localLoss.opsCountOne": "{count} opération",
+  "localLoss.opsCountMany": "{count} opérations",
+  "common.rename": "Renommer",
+  "common.connect": "Connecter",
+  "common.next": "Suivant",
+  "projectSearch.placeholder": "Rechercher les inactifs...",
+  "projectSearch.noProjects": "Aucun projet",
+  "projectSearch.boxMemberOne": "Boîte · {count} membre",
+  "projectSearch.boxMemberMany": "Boîte · {count} membres",
+  "categoryEditor.titleSuffix": "Catégories",
+  "categoryEditor.desc": "Étiquetez ce projet pour le colorer et le regrouper dans le nuage de projets et la barre de pastilles. Un projet peut porter plusieurs catégories ; la première est sa couleur principale.",
+  "categoryEditor.removeCategory": "Supprimer cette catégorie",
+  "categoryEditor.addCategory": "Ajouter cette catégorie",
+  "categoryEditor.addLabel": "Ajouter une catégorie",
+  "categoryEditor.placeholder": "p. ex. travail, recherche, client-x…",
+  "categoryEditor.saving": "Enregistrement…",
+  "categoryEditor.save": "Enregistrer",
+  "boxPill.clickToOpenTitle": "{name} (boîte) — cliquez pour ouvrir",
+  "boxPill.memberCountOne": "{count} membre",
+  "boxPill.memberCountMany": "{count} membres",
+  "boxPill.noMembers": "Aucun membre",
+  "boxPill.switchToTitle": "Passer à {name}",
+  "boxPill.removeFromBox": "Retirer de la boîte",
+  "boxPill.openBox": "Ouvrir la boîte",
+  "boxPill.deleteBox": "Supprimer la boîte",
+  "activityCal.noActivity": "Aucune activité",
+  "activityCal.less": "Moins",
+  "activityCal.more": "Plus",
+  "activityCal.dayMon": "Lun",
+  "activityCal.dayWed": "Mer",
+  "activityCal.dayFri": "Ven",
+  "remotePane.notConnected": "Non connecté",
+  "remotePane.hintPre": "Cet onglet s'exécute sur",
+  "remotePane.theRemoteHost": "l'hôte distant",
+  "remotePane.hintPost": "Connectez-vous pour la démarrer — vos onglets locaux continuent de fonctionner sur le miroir entre-temps.",
+  "extendRemote.title": "Étendre « {name} » vers le distant",
+  "extendRemote.attachPre": "Attacher",
+  "extendRemote.attachMid": "à ce projet en tant qu'hôte distant principal. Le dossier distant vide est créé sur l'hôte ; vos fichiers locaux existants deviennent la copie de travail synchronisée et restent en place. Rien n'est téléversé tant que vous ne le faites pas manuellement.",
+  "extendRemote.attachGeneric": "Attachez un hôte SSH distant à ce projet. Le dossier distant vide est créé sur l'hôte ; vos fichiers locaux existants deviennent la copie de travail synchronisée et restent en place. Rien n'est téléversé tant que vous ne le faites pas manuellement.",
+  "extendRemote.summaryLede": "Crée le dossier distant et l'associe aux fichiers locaux existants de ce projet :",
+  "extendRemote.local": "Local",
+  "extendRemote.remote": "Distant",
+  "extendRemote.readyTitle": "Attacher l'hôte distant à ce projet",
+  "extendRemote.notReadyTitle": "Connectez-vous d'abord et choisissez un dossier distant",
+  "extendRemote.connectFirstError": "Connectez-vous d'abord et choisissez un dossier distant.",
+  "extendRemote.extending": "Extension…",
+  "extendRemote.extendToRemote": "Étendre vers le distant",
+  "pythonInterp.titleSuffix": "Interpréteur Python",
+  "pythonInterp.desc": "Utilisé par les boutons Exécuter et Déboguer de la visionneuse de code. La détection automatique convient à presque tous les projets — n'en épinglez un que si votre environnement se trouve là où Eldrun ne peut pas le déduire.",
+  "pythonInterp.remoteSuffix": "Vérifié sur l'hôte, car c'est là que ce projet s'exécute.",
+  "pythonInterp.looking": "Recherche d'interpréteurs…",
+  "pythonInterp.interpreterLabel": "Interpréteur",
+  "pythonInterp.autoDetectWith": "Détection automatique — {path}",
+  "pythonInterp.autoDetect": "Détection automatique",
+  "pythonInterp.customPath": "Chemin personnalisé…",
+  "pythonInterp.pathLabel": "Chemin de l'interpréteur",
+  "pythonInterp.pathPlaceholder": "p. ex. /opt/envs/ml/bin/python — les chemins relatifs sont résolus depuis la racine du projet",
+  "pythonInterp.probeErrorPre": "Impossible de sonder les interpréteurs (",
+  "pythonInterp.probeErrorPost": "). Vous pouvez toujours en définir un manuellement.",
+  "pythonInterp.saving": "Enregistrement…",
+  "pythonInterp.save": "Enregistrer",
+  "remoteBrowser.ariaLabel": "Navigateur de dossiers distants",
+  "remoteBrowser.goUp": "Remonter",
+  "remoteBrowser.recentlyUsed": "Récemment utilisé…",
+  "remoteBrowser.jumpTitle": "Aller à un chemin distant déjà utilisé pour cet hôte",
+  "remoteBrowser.useThisFolder": "Utiliser ce dossier",
+  "remoteBrowser.newFolderPlaceholder": "Nom du nouveau dossier…",
+  "remoteBrowser.addFolderTitle": "Créer un nouveau dossier ici",
+  "remoteBrowser.addFolder": "+ Ajouter un dossier",
+  "remoteBrowser.listing": "Listage...",
+  "remoteBrowser.emptyFolder": "Dossier vide.",
+  "bigFolder.titlePre": "Dossiers volumineux dans",
+  "bigFolder.thisProject": "ce projet",
+  "bigFolder.introPre": "Ces dossiers sont assez volumineux pour que leur synchronisation domine chaque transfert. La synchro copie des octets et",
+  "bigFolder.doesNotReadGitignore": "ne lit pas .gitignore",
+  "bigFolder.introPost": ", donc les données conservées intentionnellement sur l'hôte — sorties d'expériences, points de contrôle, caches, environnements virtuels — traversent comme n'importe quel autre fichier sauf si elles sont exclues ici.",
+  "bigFolder.measuring": "Mesure des deux côtés…",
+  "bigFolder.nothingOversizedFull": "Rien de surdimensionné trouvé. La synchro peut se lancer.",
+  "bigFolder.nothingOversizedLocalOnly": "Rien de surdimensionné trouvé côté local. La synchro peut se lancer.",
+  "bigFolder.colFolder": "Dossier",
+  "bigFolder.colThisMachine": "Cette machine",
+  "bigFolder.colHost": "Hôte",
+  "bigFolder.notePre": "Coché =",
+  "bigFolder.excludedFromSync": "exclu de la synchro",
+  "bigFolder.notePost": ". Rien n'est supprimé dans un cas comme dans l'autre, et tout dossier peut être réinclus plus tard depuis son menu contextuel dans l'arborescence des fichiers. Les fichiers suivis par Git voyagent toujours avec vos commits — l'exclusion s'applique à la synchro d'octets.",
+  "bigFolder.hostNotMeasuredPre": "L'hôte n'a pas été mesuré",
+  "bigFolder.hostNotConnected": "le projet n'est pas connecté",
+  "bigFolder.hostNotMeasuredPost": ". Seuls les dossiers de cette machine sont listés ; rouvrez ceci depuis la vue des fichiers une fois connecté pour voir ceux de l'hôte.",
+  "bigFolder.hostSkippedCareful": "L'hôte n'a pas été mesuré — cette machine est marquée comme ménagée, donc l'analyse récursive de toute son arborescence ne s'exécute pas d'elle-même.",
+  "bigFolder.measureHost": "Mesurer l'hôte quand même",
+  "bigFolder.measuringHost": "Mesure de l'hôte…",
+  "bigFolder.notNow": "Pas maintenant",
+  "bigFolder.close": "Fermer",
+  "bigFolder.apply": "Appliquer",
+  "common.saving": "Enregistrement…",
+  "common.save": "Enregistrer",
+  "common.close": "Fermer",
+  "pill.gitClean": "Aucun changement en attente",
+  "pill.gitDirty": "Modifications non validées — pas encore ajoutées",
+  "pill.gitStaged": "Modifications indexées — pas encore validées",
+  "pill.gitUnpushed": "Validé — pas encore poussé",
+  "pill.statusWorking": "{count} en cours",
+  "pill.statusWaiting": "{count} en attente de vous",
+  "pill.statusFinished": "{count} terminé(s)",
+  "pill.categoriesLabel": "Catégories : {list}",
+  "pill.closeProject": "Fermer le projet",
+  "pill.activityTitle": "{name} — Activité",
+  "pill.descTitle": "{name} — Description",
+  "pill.descPlaceholder": "Brève description de ce projet…",
+  "pill.renameTitle": "Renommer le projet",
+  "pill.namePlaceholder": "Nom du projet…",
+  "pill.nameEmpty": "Le nom ne peut pas être vide",
+  "pill.publishTitle": "{name} — Publier sur {provider}",
+  "pill.currentPrefix": "Actuel :",
+  "pill.runsOnWorkRemote": "· s'exécute sur l'hôte distant de travail",
+  "pill.hostingProvider": "Fournisseur d'hébergement",
+  "pill.repoVisibility": "Visibilité du dépôt",
+  "pill.visPrivate": "privé",
+  "pill.visPublic": "public",
+  "pill.publishRunsPre": "Exécute",
+  "pill.publishRunsMid": "Nécessite",
+  "pill.publishRunsPost": "installé et authentifié (ou un jeton sous ⚙ Paramètres → Hébergement Git).",
+  "pill.publishCliMissingPre": "Aucun",
+  "pill.publishCliMissingMid": "trouvé sur cette machine — la publication crée le dépôt via la CLI propre au fournisseur, installez-la donc (et connectez-vous avec",
+  "pill.publishCliMissingPost": ") avant de publier.",
+  "pill.publishFrom": "Publier depuis",
+  "pill.publishFromLocal": "Cet ordinateur (miroir local)",
+  "pill.publishFromRemote": "Hôte distant de travail",
+  "pill.publishFromLocalHint": "Le dépôt est créé et poussé depuis le miroir local de ce projet, avec la connexion {cli} de cette machine. Git lockstep doit indiquer que le miroir est synchronisé avec l'hôte.",
+  "pill.publishRemoteCliHint": "La publication s'exécute sur l'hôte distant de travail — {cli} doit y être installé et connecté, pas sur cette machine, et le projet doit être connecté.",
+  "pill.publishSignInHint": "Non connecté via un jeton enregistré — la publication utilisera la propre connexion de {cli}.",
+  "pill.publishSignInBtn": "Se connecter avec {cli}",
+  "pill.publishSignInTitle": "Exécuter {cmd} dans un nouvel onglet de terminal",
+  "pill.getTokenCta": "Créer un jeton d'accès {provider}…",
+  "pill.getTokenHint": "Nécessite le scope « repo » sur GitHub, ou « api » (lecture/écriture du dépôt) sur GitLab.",
+  "pill.published": "Publié.",
+  "pill.publishing": "Publication…",
+  "pill.publish": "Publier",
+  "pill.gitHostingTitle": "{name} — Hébergement Git",
+  "pill.gitHostingDesc": "Remplace l'hébergement Git global pour ce projet uniquement. Laissez les champs vides pour hériter des paramètres globaux.",
+  "pill.inheritsGlobal": "Hérite du global : {url}",
+  "pill.replaceToken": "Remplacer le jeton d'accès",
+  "pill.enterNewToken": "Entrez un nouveau jeton de remplacement…",
+  "pill.tokenStatusWillSet": "Définira un jeton de projet (remplace le global).",
+  "pill.tokenStatusWillRemove": "Supprimera le jeton du projet ; reviendra au global.",
+  "pill.tokenStatusHasToken": "Un jeton de projet est défini (masqué). Laissez vide pour le conserver.",
+  "pill.tokenStatusInherits": "Hérite du jeton global.",
+  "pill.tokenStatusNone": "Aucun jeton défini — les push utilisent vos identifiants git système.",
+  "pill.removeProjectToken": "Supprimer le jeton du projet (utiliser le global)",
+  "pill.disableGitTitle": "{name} — Supprimer git et l'historique",
+  "pill.disableGitWarn1": "Cela supprime définitivement le",
+  "pill.disableGitWarn2": "de ce projet — chaque commit, branche, remisage et dépôt distant.",
+  "pill.cannotBeUndone": "Cela ne peut pas être annulé.",
+  "pill.disableGitWarn3": "Le projet devient un projet « Pas de git (pas de dépôt) » ; vos fichiers de travail restent intacts.",
+  "pill.typeNameConfirmPre": "Tapez le nom du projet",
+  "pill.typeNameConfirmPost": "pour confirmer",
+  "pill.removing": "Suppression…",
+  "pill.deleteGitHistory": "Supprimer l'historique git",
+  "pill.deleteProjectTitle": "Supprimer {name}",
+  "pill.archiveDescPre": "Ceci déconnecte",
+  "pill.archiveDescMid": "et le déplace vers l'archive Eldrun. Vous pouvez le restaurer — ou le supprimer définitivement — plus tard depuis",
+  "pill.archiveSettingsLink": "Paramètres → Projets archivés",
+  "pill.archiveRemoteNotTouchedPre": "Les fichiers sur l'hôte distant ne sont pas",
+  "pill.notWord": "pas",
+  "pill.archiveRemoteNotTouchedPost": "touchés.",
+  "pill.deleting": "Suppression…",
+  "pill.deleteToArchive": "Supprimer vers l'archive",
+  "pill.detachTitle": "{name} — Détacher l'hôte SSH",
+  "pill.detachDesc1Pre": "Ceci transforme",
+  "pill.detachDesc1Mid": "à nouveau en un simple projet local : sa copie de travail locale reste exactement où elle est et redevient le répertoire du projet. Les fichiers sur l'hôte distant ne sont",
+  "pill.detachDesc1Post": "pas touchés, et rien de local n'est supprimé.",
+  "pill.detachDesc2Pre": "Ce qui est bel et bien abandonné, c'est le",
+  "pill.pairingWord": "appairage",
+  "pill.detachDesc2Post": " : le lockstep git s'arrête, et la portée d'auto-synchronisation choisie pour cet hôte — quels dossiers traversent, et l'enregistrement de ce qui était déjà en phase — est abandonnée. Rattacher le même hôte plus tard signifie choisir cette portée à nouveau depuis le début.",
+  "pill.detaching": "Détachement…",
+  "pill.detachToLocal": "Détacher vers local",
+  "pill.containerSettingsTitle": "{name} — Paramètres du conteneur",
+  "pill.containerAppliedNote": "Appliqué au prochain démarrage du conteneur (activation du projet ou création d'onglet) — un conteneur en cours dont les paramètres ont changé est remplacé automatiquement.",
+  "pill.buildFromDockerfile": "Construire à partir d'un Dockerfile dans ce projet",
+  "pill.dockerfilePlaceholder": "p. ex. Dockerfile — vide : utiliser l'image ci-dessous",
+  "pill.image": "Image",
+  "pill.imagePlaceholder": "vide : eldrun-agent-sandbox:latest",
+  "pill.network": "Réseau",
+  "pill.networkPlaceholder": "vide : pont docker — « none » bloque toute sortie (casse les agents cloud)",
+  "pill.networkNotePre": "Remarque : le pont par défaut atteint toujours les services liés à cette machine (Ollama, serveurs de dev) via l'IP de la passerelle docker. Totalement fermé signifie",
+  "pill.networkNotePost": "ou un réseau de liste blanche personnalisé.",
+  "pill.memoryCap": "Limite de mémoire",
+  "pill.memoryPlaceholder": "p. ex. 4g — vide : illimité",
+  "pill.cpuCap": "Limite de CPU",
+  "pill.cpuPlaceholder": "p. ex. 2 — vide : illimité",
+  "pill.processLimit": "Limite de processus",
+  "pill.processLimitPlaceholder": "vide : 1024 (protection contre les fork bombs)",
+  "pill.processLimitError": "La limite de processus doit être un nombre entier positif.",
+  "pill.readonlyRootfs": "Système de fichiers racine en lecture seule (conserve /tmp inscriptible)",
+  "pill.unpublishTitle": "{name} — Dépublier",
+  "pill.unpublishDesc1": "Ceci supprime le dépôt distant",
+  "pill.unpublishDesc2": "et remet le projet à un dépôt git local. Vos commits restent intacts et le dépôt sur",
+  "pill.unpublishDesc3": "n'est",
+  "pill.unpublishDesc4": "pas supprimé — seul le lien local vers celui-ci est abandonné. Vous pourrez republier plus tard.",
+  "pill.unpublishing": "Dépublication…",
+  "pill.unpublishKeepRepo": "Dépublier (conserver le dépôt)",
+  "pill.changeVisibilityTitle": "{name} — Modifier la visibilité",
+  "pill.flipVisibility1": "Faire basculer ce dépôt de",
+  "pill.flipVisibility2": "à",
+  "pill.flipVisibility3": "sur place via",
+  "pill.flipVisibility4": "Le dépôt, son URL et son historique sont préservés.",
+  "pill.applying": "Application…",
+  "pill.makeVisibility": "Rendre {target}",
+  "pill.moveToProviderTitle": "{name} — Basculer vers un autre fournisseur",
+  "pill.newProvider": "Nouveau fournisseur",
+  "pill.migrateDesc1": "Crée le dépôt sur",
+  "pill.migrateDesc2": ", re-pointe",
+  "pill.migrateDesc3": ", et pousse. Le dépôt existant",
+  "pill.migrateDesc4": "est",
+  "pill.leftIntact": "laissé intact",
+  "pill.migrateDesc5": "(conservé sous",
+  "pill.migrateDesc6": ") — supprimez-le vous-même si vous n'en voulez plus.",
+  "pill.migrating": "Migration…",
+  "pill.moveToProvider": "Basculer vers {provider}",
+  "pill.viewGroup": "Affichage",
+  "pill.showActivity": "Afficher l'activité",
+  "pill.showOnDiskRemoteTitle": "Ouvrir le miroir local (la copie de travail connectée) dans le gestionnaire de fichiers",
+  "pill.showOnDiskLocalTitle": "Ouvrir le répertoire du projet dans le gestionnaire de fichiers",
+  "pill.showOnDisk": "Afficher sur le disque",
+  "pill.editGroup": "Modifier",
+  "pill.renameEllipsis": "Renommer…",
+  "pill.movePillTitle": "Déplacer le miroir local de ce projet (la copie de travail connectée) vers un nouveau dossier",
+  "pill.moveProjectEllipsis": "Déplacer le projet…",
+  "pill.editDescription": "Modifier la description",
+  "pill.categoriesMenuTitle": "Étiquetez ce projet pour le colorer et le regrouper dans le nuage et la barre de pastilles",
+  "pill.repairScaffoldTitle": "Complète tout fichier d'ossature manquant, motif .gitignore par défaut ou .claude/settings.json — n'écrase jamais le contenu existant",
+  "pill.repairScaffold": "Réparer les fichiers d'ossature",
+  "pill.extendToRemoteMenuTitle": "Attachez un hôte SSH distant à ce projet local — les fichiers restent en place ; téléversez-les manuellement",
+  "pill.extendToRemoteEllipsis": "Étendre vers le distant…",
+  "pill.gitGroup": "Git",
+  "pill.gitInitTitle": "Exécuter git init pour commencer à versionner ce projet",
+  "pill.enableGit": "Activer git (git init)",
+  "pill.makePrivateTitle": "Basculer le dépôt entre public et privé sur place (gh/glab repo edit)",
+  "pill.makePrivate": "Rendre privé…",
+  "pill.makePublic": "Rendre public…",
+  "pill.moveProviderMenuTitle": "Publier chez l'autre fournisseur et re-pointer origin ; l'ancien dépôt reste intact",
+  "pill.moveToGithub": "Basculer vers GitHub…",
+  "pill.moveToGitlab": "Basculer vers GitLab…",
+  "pill.unpublishMenuTitle": "Supprimer le dépôt distant origin et revenir à un dépôt local ; le dépôt hébergé et l'historique sont conservés",
+  "pill.unpublishKeepRepoEllipsis": "Dépublier (conserver le dépôt)…",
+  "pill.gitHostingMenuTitle": "Remplacer l'hébergement Git global (URL de profil + jeton) pour ce projet uniquement",
+  "pill.gitHostingEllipsis": "Hébergement Git…",
+  "pill.publishEllipsis": "Publier sur GitHub / GitLab…",
+  "pill.runtimeGroup": "Exécution",
+  "pill.containerRunTitle": "Exécute chaque onglet terminal et agent de ce projet dans un conteneur Docker fermé. Le dossier du projet reste sur l'hôte à son chemin normal — le conteneur ne peut simplement rien atteindre d'autre.",
+  "pill.runInContainer": "Exécuter ce projet dans un conteneur",
+  "pill.containerSettingsMenuTitle": "Image, réseau, limites mémoire/CPU et rootfs en lecture seule pour le conteneur de ce projet",
+  "pill.containerSettingsEllipsis": "Paramètres du conteneur…",
+  "pill.pythonInterpMenuTitle": "L'environnement Python dans lequel les scripts de ce projet s'exécutent et se déboguent. Détecté automatiquement par défaut (venv dans l'arborescence, poetry, conda, pyenv) ; épinglez-en un lorsque votre environnement se trouve là où Eldrun ne peut pas le déduire.",
+  "pill.pythonInterpreterEllipsis": "Interpréteur Python…",
+  "pill.autoConnectTitleNonHeadless": "Connecte ce projet tout seul au lancement et lors du passage à celui-ci. Eldrun ne gère aucun mot de passe dans ce mode, donc la connexion (et le VPN, s'il en a un) s'ouvre dans le terminal racine pour que vous vous authentifiiez — puis le projet se connecte de lui-même.",
+  "pill.autoConnectTitleEligible": "Connecte ce projet tout seul au lancement et lors du passage à celui-ci. Il ne demande jamais rien : il entre directement quand l'hôte est accessible, et n'active le VPN que lorsqu'il ne l'est pas.",
+  "pill.autoConnectTitleNotEligible": "Enregistrez d'abord le mot de passe SSH (ou utilisez l'authentification par clé) — la connexion automatique n'est proposée que lorsque la connexion ne nécessite rien de vous.",
+  "pill.autoConnectOnLaunch": "Connexion automatique au lancement",
+  "pill.persistSessionsMenuTitle": "Exécute le shell distant et les onglets Python/script de ce projet dans une session tmux sur l'hôte, afin qu'une longue exécution continue malgré une coupure SSH, une mise en veille du portable ou la fermeture d'Eldrun — l'onglet se rattache à la reconnexion. Fermer un onglet met quand même fin à sa session (avec confirmation). Les onglets d'agent ne sont pas concernés.",
+  "pill.persistentSessionsTmux": "Sessions persistantes (tmux)",
+  "pill.remoteMachinesMenuTitle": "Ajoutez et gérez des machines supplémentaires sur lesquelles ce projet s'exécute. Elles exécutent le même code (maintenu en synchro unidirectionnelle) en tant que workers d'expérimentation en lecture seule ; leurs sorties restent sur chaque machine.",
+  "pill.remoteMachinesCount": "Machines distantes… ({count})",
+  "pill.remoteMachinesEllipsis": "Machines distantes…",
+  "pill.closeAllTabs": "Fermer tous les onglets et fenêtres",
+  "pill.dangerZone": "Zone de danger",
+  "pill.detachSshMenuTitle": "Retransforme ceci en projet local. La copie de travail locale reste en place et les fichiers de l'hôte distant restent intacts — mais l'appairage est abandonné : le lockstep s'arrête, et la portée d'auto-synchronisation configurée pour cet hôte est écartée.",
+  "pill.detachSshEllipsis": "Détacher l'hôte SSH…",
+  "pill.removeGitMenuTitle": "Supprimer le répertoire .git de ce projet et tout l'historique de contrôle de version (irréversible)",
+  "pill.removeGitHistoryEllipsis": "Supprimer git et l'historique…",
+  "pill.deleteProjectMenuTitle": "Déconnectez ce projet et déplacez-le vers l'archive Eldrun. Restaurez-le ou supprimez-le définitivement plus tard depuis les Paramètres. Les fichiers d'un hôte distant ne sont jamais touchés.",
+  "pill.deleteProjectEllipsis": "Supprimer le projet…",
+  "pill.nowVisibility": "Désormais {target}.",
+  "pill.migrated": "Migré.",
+  "remoteConnect.titleWorker": "Connecter le worker · {host}",
+  "remoteConnect.titleProject": "Connecter le projet distant",
+  "remoteConnect.remoteLabel": "Distant",
+  "remoteConnect.localLabel": "Local",
+  "remoteConnect.nameLabel": "Nom",
+  "remoteConnect.namePlaceholder": "Nom du projet",
+  "remoteConnect.nameHintWorker": "Affiché sur la pastille et dans « Machines distantes ». Laisser vide pour utiliser le nom d'hôte.",
+  "remoteConnect.nameHintProject": "Le nom du projet, affiché sur sa pastille et partout dans Eldrun.",
+  "remoteConnect.machineNameLabel": "Nom de la machine",
+  "remoteConnect.machineNameHint": "Identifie cette machine dans le Moniteur système et les voyants de connexion lorsque le projet a plusieurs hôtes. Laisser vide pour utiliser le nom d'hôte.",
+  "remoteConnect.vpnToggleTitle": "Se connecter via OpenVPN",
+  "remoteConnect.vpnDescLine1": "Établissez d'abord un tunnel si cet hôte est protégé par VPN. Ignorez cette étape si vous êtes déjà sur le bon réseau — SSH se connecte directement.",
+  "remoteConnect.vpnDescLine2Pre": "Le tunnel est",
+  "remoteConnect.vpnDescLine2Strong": "à l'échelle de la machine",
+  "remoteConnect.vpnDescLine2Post": " : tant qu'il est actif, tout le trafic de cet ordinateur y transite — votre navigateur aussi, pas seulement Eldrun.",
+  "remoteConnect.configLabel": "Configuration",
+  "remoteConnect.changeConfig": "Modifier…",
+  "remoteConnect.changeConfigTitle": "Choisissez une autre configuration OpenVPN pour ce projet.",
+  "remoteConnect.pickConfigHintChange": "Choisissez la configuration OpenVPN à utiliser à la place — le nouveau choix remplace celui enregistré.",
+  "remoteConnect.pickConfigHintNew": "Choisissez la configuration OpenVPN pour cet hôte — elle est enregistrée dans le projet, vous ne la choisissez donc qu'une seule fois.",
+  "remoteConnect.recentConfigsPlaceholder": "Utilisé récemment…",
+  "remoteConnect.recentConfigsTitle": "Réutiliser une configuration OpenVPN déjà utilisée",
+  "remoteConnect.chooseConfigBtn": "Choisir un fichier .ovpn…",
+  "remoteConnect.vpnUsernameLabel": "Identifiant VPN",
+  "remoteConnect.vpnPasswordLabel": "Mot de passe VPN",
+  "remoteConnect.vpnPassphraseLabel": "Phrase secrète VPN",
+  "remoteConnect.vpnSavedPlaceholder": "Utilise la phrase secrète enregistrée — laisser vide",
+  "remoteConnect.vpnAccountPasswordPlaceholder": "Mot de passe du compte OpenVPN…",
+  "remoteConnect.vpnPassphrasePlaceholder": "Phrase secrète OpenVPN…",
+  "remoteConnect.retryVpn": "Réessayer le VPN",
+  "remoteConnect.connectVpn": "Connecter le VPN",
+  "remoteConnect.vpnStopTitleConnected": "Coupez ce tunnel OpenVPN. La connexion SSH reste inchangée.",
+  "remoteConnect.vpnStopTitleConnecting": "Arrêtez cette tentative de connexion VPN et réinitialisez l'état du tunnel.",
+  "remoteConnect.disconnectVpn": "Déconnecter le VPN",
+  "remoteConnect.vpnTermBtnTitle": "Établissez le tunnel OpenVPN dans un terminal ci-dessous — saisissez-y la phrase secrète.",
+  "remoteConnect.vpnTermOpenBelow": "Terminal VPN ouvert ci-dessous",
+  "remoteConnect.vpnTermOpenBtn": "Ouvrir le terminal de connexion VPN",
+  "remoteConnect.vpnTermHint": "Authentifiez le tunnel ci-dessous — il continue de fonctionner pour ce projet.",
+  "remoteConnect.disconnect": "Déconnecter",
+  "remoteConnect.sshSectionLabel": "Se connecter via SSH",
+  "remoteConnect.usernameLabel": "Identifiant",
+  "remoteConnect.usernamePlaceholder": "Nom de connexion SSH — vide utilise votre compte local",
+  "remoteConnect.usernameHint": "Le compte sur {host}. Le modifier change le mot de passe enregistré applicable — ils sont stockés par identifiant de connexion.",
+  "remoteConnect.sshPasswordLabel": "Mot de passe ou phrase secrète de la clé",
+  "remoteConnect.sshSavedPlaceholder": "Utilise le secret enregistré — laisser vide",
+  "remoteConnect.sshPasswordPlaceholder": "Mot de passe SSH, ou la phrase secrète de votre clé…",
+  "remoteConnect.connectedState": "Connecté",
+  "remoteConnect.sshStopTitle": "Arrêtez cette tentative de connexion SSH et réinitialisez l'état de la connexion.",
+  "remoteConnect.savePassword": "Enregistrer le mot de passe",
+  "remoteConnect.saveHintKeptTerminal": "conservé dans le trousseau de votre système — une connexion en terminal n'est pas vue par Eldrun, donc rien de nouveau n'est stocké ; désactivez pour le supprimer",
+  "remoteConnect.saveHintSaved": "enregistré dans le trousseau de votre système — désactivez pour le supprimer",
+  "remoteConnect.saveHintNothingTerminal": "rien à stocker pour une connexion en terminal — Eldrun ne le voit jamais",
+  "remoteConnect.autoConnectTitleEligible": "Connecte ce projet tout seul au démarrage et lors du basculement vers lui. Il ne demande jamais rien : il se connecte directement quand l'hôte est joignable, et n'active le VPN que lorsqu'il ne l'est pas. Notez qu'activer le VPN redirige tout le trafic de cet ordinateur — avec la connexion automatique, cela se produit sans confirmation, surveillez donc l'indicateur VPN de l'en-tête.",
+  "remoteConnect.autoConnectTitleNotEligible": "Enregistrez d'abord le mot de passe SSH (ou utilisez l'authentification par clé) — la connexion automatique n'est proposée que lorsque la connexion ne requiert rien de vous.",
+  "remoteConnect.autoConnectLabel": "Connexion automatique",
+  "remoteConnect.autoConnectHintEligible": "au démarrage et au basculement — VPN seulement si l'hôte n'est pas joignable directement",
+  "remoteConnect.autoConnectHintNotEligible": "nécessite un mot de passe enregistré ou une authentification par clé",
+  "remoteConnect.autoConnectVpnWarningPre": "Attention : si l'hôte n'est pas joignable directement, la connexion automatique active le VPN",
+  "remoteConnect.autoConnectVpnWarningStrong": "sans demander",
+  "remoteConnect.autoConnectVpnWarningPost": "— redirigeant le trafic de cet ordinateur au démarrage. L'indicateur VPN de l'en-tête montre quand un tunnel est actif, et peut le couper.",
+  "remoteConnect.autoConnectInteractiveTitle": "Connecte ce projet tout seul au démarrage et lors du basculement vers lui. Eldrun ne gère aucun mot de passe dans ce mode, donc la connexion (et le VPN, si ce projet en a un) s'ouvre dans le terminal racine pour que vous vous authentifiiez — le projet se connecte de lui-même une fois que vous êtes connecté.",
+  "remoteConnect.autoConnectInteractiveHint": "au démarrage et au basculement — ouvre la connexion dans le terminal racine",
+  "remoteConnect.sshTermBtnTitle": "Ouvrez la connexion SSH dans un terminal ci-dessous — saisissez-y le mot de passe.",
+  "remoteConnect.sshTermOpenBelow": "Terminal SSH ouvert ci-dessous",
+  "remoteConnect.sshTermOpenBtn": "Ouvrir le terminal de connexion SSH",
+  "remoteConnect.tryConnectTitle": "Si vous avez terminé de vous connecter ci-dessus, connectez-vous maintenant.",
+  "remoteConnect.tryConnectBtn": "Je suis connecté — connecter",
+  "remoteConnect.sshTermHint": "Connectez-vous ci-dessous — la connexion mutualisée s'établit une fois authentifié.",
+  "remoteConnect.killConfirmTitle": "Confirmer : ceci met fin à toutes les sessions tmux en cours sur l'hôte — c'est irréversible.",
+  "remoteConnect.killConfirmBtn": "Confirmer : mettre fin à tous les jobs",
+  "remoteConnect.killArmTitle": "Déconnexion active : met fin à tous les jobs tmux en cours sur cet hôte et ferme la connexion. Les jobs ne sont arrêtés qu'à ce clic — jamais lors d'un redémarrage d'Eldrun.",
+  "remoteConnect.killArmBtn": "Déconnecter et arrêter les jobs",
+  "remoteConnect.forgetPasswordTitle": "Supprime le mot de passe enregistré de cet hôte du trousseau de votre système. La connexion actuelle reste active ; la prochaine connexion redemandera le mot de passe.",
+  "remoteConnect.forgetPasswordBtn": "Oublier le mot de passe enregistré",
+  "carefulHost.title": "Empêche le travail en arrière-plan d'Eldrun sur cette machine : le recensement de la taille des fichiers arrête de scanner l'hôte de lui-même, et la surveillance devient moins coûteuse et plus lente. Utilisez ceci pour un nœud de connexion ou toute machine que vous partagez avec d'autres — pas pour un nœud de calcul que vous détenez pour la durée d'un job, qui est à vous tant que vous l'avez.",
+  "carefulHost.label": "Ménager cette machine",
+  "carefulHost.hintDefault": "pour un nœud de connexion ou une machine partagée : ignore les analyses qui lisent tout son système de fichiers",
+  "usage.carefulNote":
+    "Hôte HPC — seules vos propres sessions et processus sont listés. Les règles d'usage d'un cluster ne permettent pas de collecter les noms ou commandes d'autres utilisateurs, donc ce rapport n'est pas exécuté automatiquement ici.",
+  "carefulHost.hintOnByDefault": "activé par défaut pour chaque machine distante — désactivez-le si celle-ci est la vôtre",
+  "carefulHost.hintNotCareful": "cette machine est la vôtre : surveillance complète, comme en local",
+  "remoteConnect.vpnSectionAria": "Tunnel OpenVPN",
+  "remoteConnect.sshSectionAria": "Connexion SSH",
+  "remoteMachines.title": "{name} — Machines distantes",
+  "remoteMachines.introPre": "Toutes les machines que ce projet atteint, au même endroit — la",
+  "remoteMachines.introStrongPrimary": "principale",
+  "remoteMachines.introMid1": "qui possède ses fichiers et git, plus toute machine worker supplémentaire qui exécute son",
+  "remoteMachines.introStrongSameCode": "même code",
+  "remoteMachines.introMid2": ". Connectez ou gérez l'une d'elles ici, ou ajoutez un nouveau worker ci-dessous. Un nouveau worker partage par défaut le dossier du projet de la machine principale (pas de copie, pas de git) ; cochez",
+  "remoteMachines.introStrongSyncCopy": "Synchroniser une copie",
+  "remoteMachines.introPost": "pour lui donner sa propre copie synchronisée à sens unique — pour les hôtes qui ne partagent pas de stockage avec la principale.",
+  "remoteMachines.primaryTagTitle": "La machine principale possède les fichiers, git et le miroir local de ce projet, avec une synchronisation bidirectionnelle complète.",
+  "remoteMachines.primaryTag": "Principale",
+  "remoteMachines.connectedDot": "Connecté.",
+  "remoteMachines.notConnectedDot": "Non connecté.",
+  "remoteMachines.localMirrorLabel": "Miroir local :",
+  "remoteMachines.manage": "Gérer…",
+  "remoteMachines.connectEllipsis": "Connecter…",
+  "remoteMachines.sharedFsTag": "Système de fichiers partagé",
+  "remoteMachines.dropIntro": "Depuis vos machines globales. Indiquez le chemin partagé où elle voit le dossier de ce projet — tout le reste est déjà connu.",
+  "remoteMachines.pathOnMachine": "Chemin sur cette machine",
+  "remoteMachines.absolutePathPlaceholder": "Chemin absolu (p. ex. /home/me/project)",
+  "remoteMachines.adding": "Ajout…",
+  "remoteMachines.addMachineBtn": "Ajouter une machine",
+  "remoteMachines.noWorkers": "Aucune machine worker pour l'instant.",
+  "remoteMachines.sharedStatus": "S'exécute dans le dossier partagé de la machine principale — pas de copie, pas de synchronisation.",
+  "remoteMachines.syncFailedLabel": "Échec de la synchronisation :",
+  "remoteMachines.lastSyncedLabel": "Dernière synchronisation :",
+  "remoteMachines.alreadyCurrent": "(déjà à jour)",
+  "remoteMachines.syncingEllipsis": "Synchronisation…",
+  "remoteMachines.notSyncedYet": "Pas encore synchronisé",
+  "remoteMachines.sharedTagTitle": "Système de fichiers partagé : les shells s'exécutent dans le dossier du projet de la machine principale, sur cette machine. Aucun code n'est copié et git n'y est jamais exécuté.",
+  "remoteMachines.syncedTagTitle": "Copie synchronisée : cette machine conserve sa propre copie en lecture seule du code, synchronisée à sens unique depuis la machine principale.",
+  "remoteMachines.syncedCopyTag": "Copie synchronisée",
+  "remoteMachines.syncCodeNow": "Synchroniser le code maintenant",
+  "remoteMachines.pullOutputsTitle": "Récupère les sorties d'expérience de cette machine (fichiers non suivis) sur votre ordinateur. Confirme d'abord la taille.",
+  "remoteMachines.pulling": "Récupération…",
+  "remoteMachines.pullOutputsBtn": "Récupérer les sorties…",
+  "remoteMachines.removeTitle": "Retire cette machine du projet (ses fichiers sur l'hôte restent intacts).",
+  "remoteMachines.remove": "Retirer",
+  "remoteMachines.syncCopyToggleTitle": "Activé : cette machine conserve sa propre copie du code, synchronisée à sens unique depuis la machine principale. Désactivé : elle partage le dossier du projet de la machine principale via un système de fichiers partagé (pas de copie, pas de git).",
+  "remoteMachines.syncCopyLabel": "Synchroniser une copie du code sur cette machine",
+  "remoteMachines.autoSyncTitle": "Maintient le code suivi de cette machine synchronisé avec le HEAD du projet à chaque commit.",
+  "remoteMachines.autoSyncLabel": "Synchroniser automatiquement le code à chaque commit",
+  "remoteMachines.addMachineTitle": "Ajouter une machine",
+  "remoteMachines.globalListTitle": "Vos machines",
+  "remoteMachines.globalListHelp":
+    "Machines de la liste Machines de l'en-tête. Elles sont déjà configurées : en ajouter une ici ne demande que son dossier sur cette machine.",
+  "remoteMachines.globalQuickAdd": "Ajouter",
+  "remoteMachines.globalQuickAddTitle":
+    "Ajouter cette machine comme worker à système de fichiers partagé — confirmez son dossier ci-dessus, puis elle est ajoutée et connectée.",
+  "remoteMachines.globalFill": "Utiliser dans le formulaire",
+  "remoteMachines.globalFillTitle":
+    "Placer l'adresse de cette machine dans le formulaire ci-dessous, pour parcourir ses dossiers ou y synchroniser une copie.",
+  "remoteMachines.globalAlreadyAdded": "Déjà ajoutée",
+  "remoteMachines.globalAlreadyAddedTitle":
+    "Cette machine est déjà l'hôte principal de ce projet ou l'un de ses workers.",
+  "remoteMachines.sshAddressLabel": "Adresse SSH",
+  "remoteMachines.sshAddressPlaceholder": "hôte[:port]  (p. ex. gpu-2:22)",
+  "remoteMachines.usernamePlaceholder": "Identifiant de connexion SSH (p. ex. moi) — ou incluez-le en tant que user@ ci-dessus",
+  "remoteMachines.sshPasswordSavedPlaceholder": "Utilise le mot de passe enregistré — laisser vide",
+  "remoteMachines.sshPasswordPlaceholder": "Mot de passe SSH ou phrase secrète de la clé — vide pour une clé déverrouillée",
+  "remoteMachines.saveTitleTerminal": "Eldrun ne voit jamais une connexion en terminal, donc rien de nouveau n'est stocké — et rien n'est supprimé non plus. Tout mot de passe enregistré reste tel quel ; c'est dans le menu Connecter propre à la machine que vous le modifiez.",
+  "remoteMachines.saveTitleHeadless": "Enregistre le mot de passe SSH de cette machine dans le trousseau de votre système, indexé par hôte — le menu Connecter propre à la machine le retrouve alors et ne redemande plus. Désactivé par défaut ; décocher supprime un mot de passe précédemment enregistré.",
+  "remoteMachines.saveHintKeptTerminal": "Conservé dans le trousseau de votre système — une connexion en terminal n'est pas vue par Eldrun, donc rien n'est stocké ni supprimé.",
+  "remoteMachines.saveHintNothingTerminal": "Rien à stocker pour une connexion en terminal — Eldrun ne le voit jamais.",
+  "remoteMachines.saveHintSavedWillAskAgainOff": "Enregistré dans le trousseau de votre système — le Connecter de cette machine ne redemandera plus. Désactivez pour le supprimer.",
+  "remoteMachines.saveHintWillSave": "Sera enregistré dans le trousseau de votre système afin que le Connecter de cette machine ne redemande plus.",
+  "remoteMachines.saveHintNotSavedPre": "Utilisé uniquement pour se connecter — non enregistré. Activez",
+  "remoteMachines.saveHintNotSavedPost": "pour le conserver.",
+  "remoteMachines.loginTermHint": "Connectez-vous ci-dessous — le sélecteur de dossier s'ouvre de lui-même une fois cette connexion terminée.",
+  "remoteMachines.retryBrowseTitle": "Si vous avez terminé de vous connecter ci-dessus, parcourez cette machine maintenant.",
+  "remoteMachines.waitingForLogin": "En attente de la connexion…",
+  "remoteMachines.loggedInBrowse": "Je suis connecté — parcourir",
+  "remoteMachines.openLoginTerminal": "Ouvrir le terminal de connexion",
+  "remoteMachines.loggingIn": "Connexion…",
+  "remoteMachines.logIn": "Se connecter",
+  "remoteMachines.loggedInToPre": "Connecté à",
+  "remoteMachines.sharedFsToggleTitleStep2": "Désactivé (par défaut) : cette machine partage le dossier du projet de la machine principale via un système de fichiers partagé — pas de copie, pas de git. Activé : donnez-lui sa propre copie du code synchronisée à sens unique (pour les hôtes qui ne partagent pas de stockage).",
+  "remoteMachines.syncCopyDescOn": "Cette machine conserve sa propre copie du code, synchronisée à sens unique depuis la machine principale. Parcourez jusqu'au (ou créez le) dossier pour cette copie.",
+  "remoteMachines.syncCopyDescOff": "Cette machine partage le dossier du projet de la machine principale via un système de fichiers partagé — pas de copie, pas de git. Parcourez jusqu'à ce dossier sur cette machine.",
+  "remoteMachines.remotePathForCopy": "Chemin distant pour la copie de cette machine",
+  "remoteMachines.pathToProject": "Chemin vers le projet sur cette machine",
+  "remoteMachines.reconnect": "Reconnecter",
+  "remoteMachines.browseEllipsis": "Parcourir…",
+  "remoteMachines.browserFooter": "Parcourez jusqu'à un dossier, puis cliquez sur « Utiliser ce dossier ».",
+  "remoteMachines.labelOptional": "Étiquette (facultatif)",
+  "remoteMachines.labelPlaceholder": "p. ex. gpu-2",
+  "remoteMachines.enterAbsolutePath": "Saisissez un chemin distant absolu (p. ex. /home/me/project)",
+  "remoteMachines.enterHostBeforeBrowsing": "Saisissez un hôte sous la forme [user@]hôte[:port] avant de parcourir",
+  "remoteMachines.enterHostBeforeLogin": "Saisissez un hôte sous la forme [user@]hôte[:port] avant de vous connecter",
+  "remoteMachines.enterHost": "Saisissez un hôte sous la forme [user@]hôte[:port]",
+  "remoteMachines.noOutputFiles": "Aucun fichier de sortie à récupérer.",
+  "remoteMachines.pullConfirm": "Récupérer {files} fichier(s) de sortie ({bytes}) de cette machine vers votre ordinateur ?",
+  "remoteMachines.pulledResult": "{pulled} fichier(s) récupéré(s) → {dest}{errs}",
+  "remoteMachines.pullErrorsSuffix": " ({count} échoué(s))",
+  "remoteMachines.pullFailed": "Échec de la récupération : {error}",
+  "hpcWizard.stepLogin": "Connexion",
+  "hpcWizard.stepProject": "Projet",
+  "hpcWizard.stepWorkspace": "Espace de travail",
+  "hpcWizard.stepData": "Charger les données",
+  "hpcWizard.stepRun": "Exécuter le job",
+  "hpcWizard.stepWatch": "Observer",
+  "hpcWizard.sbatchJobName": "Nom du job",
+  "hpcWizard.sbatchPartition": "Partition",
+  "hpcWizard.sbatchTime": "Durée",
+  "hpcWizard.sbatchNodes": "Nœuds",
+  "hpcWizard.sbatchTasks": "Tâches",
+  "hpcWizard.sbatchCpusPerTask": "CPU/tâche",
+  "hpcWizard.sbatchMemory": "Mémoire",
+  "hpcWizard.sbatchGres": "GRES",
+  "hpcWizard.sbatchOutput": "Sortie",
+  "hpcWizard.title": "Pipeline HPC",
+  "hpcWizard.loginHint": "Connectez-vous à votre cluster. S'il n'est joignable que via le VPN de votre établissement, établissez d'abord le tunnel OpenVPN (dans la section SSH ci-dessous).",
+  "hpcWizard.projectNameLabel": "Nom du projet",
+  "hpcWizard.mirrorLabel": "Emplacement local (miroir synchronisé)",
+  "hpcWizard.noFolderSelected": "Aucun dossier sélectionné",
+  "hpcWizard.browseBtn": "Parcourir...",
+  "hpcWizard.hostPathHintPre": "Sur l'hôte :",
+  "hpcWizard.hostPathHintPost": "— l'étape suivante peut déplacer ceci vers un espace de travail sur le système de fichiers parallèle du cluster.",
+  "hpcWizard.watchPre": "Votre job a été soumis et un onglet de log suit maintenant sa sortie. Ouvrez la vue Jobs (le",
+  "hpcWizard.watchMid": "bascule dans le panneau de fichiers) pour le voir se mettre en file d'attente, s'exécuter et se terminer — avec, pour chaque job,",
+  "hpcWizard.watchWatchWord": "Observer",
+  "hpcWizard.watchCancelWord": "Annuler",
+  "hpcWizard.watchAnd": "et",
+  "hpcWizard.done": "Terminé",
+  "hpcWizard.noToolingPre": "Cet hôte n'a pas d'outils workspace (",
+  "hpcWizard.noToolingPost": ").",
+  "hpcWizard.noToolingScratchHint": "Il pointe cependant vers un grand système de fichiers — choisissez où ce projet doit vivre, car un répertoire home est généralement soumis à quota et destiné au code.",
+  "hpcWizard.noToolingNoScratchPre": "Le projet vivra dans le dossier vers lequel vous avez navigué :",
+  "hpcWizard.homeRadioLabel": "home",
+  "hpcWizard.readOnly": "lecture seule",
+  "hpcWizard.projectOnHostLabel": "Projet sur l'hôte :",
+  "hpcWizard.creating": "Création…",
+  "hpcWizard.createProject": "Créer le projet",
+  "hpcWizard.introPre": "Sur un cluster, votre répertoire home est un petit système de fichiers soumis à quota, destiné au code. Les données d'un calcul appartiennent à un",
+  "hpcWizard.introStrongWorkspace": "espace de travail",
+  "hpcWizard.introMid": "— un répertoire sur le système de fichiers parallèle avec un nom et une durée, qui",
+  "hpcWizard.introStrongDeleted": "est supprimé à son expiration",
+  "hpcWizard.introPost": ". Allouez-en un maintenant, avant qu'aucune donnée ne soit téléversée ou synchronisée.",
+  "hpcWizard.checkingTooling": "Vérification des outils workspace de l'hôte…",
+  "hpcWizard.workspaceNameLabel": "Nom de l'espace de travail",
+  "hpcWizard.daysLabel": "Jours",
+  "hpcWizard.filesystemLabel": "Système de fichiers",
+  "hpcWizard.siteDefault": "(par défaut du site)",
+  "hpcWizard.defaultSuffix": " (par défaut)",
+  "hpcWizard.reminderEmailLabel": "E-mail de rappel",
+  "hpcWizard.optionalPlaceholder": "facultatif",
+  "hpcWizard.remindDaysLabel": "Rappeler jours avant",
+  "hpcWizard.reminderHint": "Un rappel vaut la peine d'être configuré — l'expiration supprime les données. Beaucoup de sites ne délivrent qu'à leur propre domaine.",
+  "hpcWizard.allocating": "Allocation…",
+  "hpcWizard.allocateWorkspace": "Allouer l'espace de travail",
+  "hpcWizard.readingWorkspaces": "Lecture de vos espaces de travail…",
+  "hpcWizard.yourWorkspaces": "Vos espaces de travail",
+  "hpcWizard.whereProjectGoes": "Où va le projet",
+  "hpcWizard.inWorkspaceStrong": "Dans l'espace de travail",
+  "hpcWizard.inWorkspaceDesc": "— tout ce qu'Eldrun synchronise (fichiers, git, téléversements) atterrit sur le système de fichiers parallèle, jamais dans votre quota home.",
+  "hpcWizard.inBrowsedStrong": "Dans le dossier parcouru",
+  "hpcWizard.inBrowsedDesc": ", avec l'espace de travail lié en tant que",
+  "hpcWizard.linkNameLabel": "Nom du lien",
+  "hpcWizard.anchorPre": "Conserver un petit dossier dans mon home cluster pour ce projet — job",
+  "hpcWizard.anchorMid": ", un",
+  "hpcWizard.anchorPost": "lien, et un enregistrement nommant l'espace de travail. Il survit à l'expiration de l'espace de travail (rien de volumineux n'y est placé, et Eldrun ne le synchronise jamais).",
+  "hpcWizard.anchorFolderLabel": "Dossier (sous votre home)",
+  "hpcWizard.createWithoutWorkspace": "Créer sans espace de travail",
+  "hpcWizard.dataHintPre": "Téléversez éventuellement des fichiers d'entrée. Ils atterrissent dans",
+  "hpcWizard.dataHintWorkspaceSuffix": "— sur le système de fichiers parallèle, pas dans votre quota home.",
+  "hpcWizard.dataHintPlainSuffix": ".",
+  "hpcWizard.dataHintPost": "Les grandes arborescences sont mieux marquées en synchronisation automatique dans le panneau de fichiers ; ceci est pour quelques fichiers.",
+  "hpcWizard.theProjectFolder": "le dossier du projet",
+  "hpcWizard.linkNotCreatedSuffix": "/ (lien non créé)",
+  "hpcWizard.uploading": "Téléversement…",
+  "hpcWizard.addFiles": "Ajouter des fichiers…",
+  "hpcWizard.skip": "Ignorer",
+  "hpcWizard.scriptHintPre": "Un script batch de démarrage (",
+  "hpcWizard.scriptHintPost": ") sera écrit dans le projet. Ajustez ses ressources, puis soumettez-le — il s'exécute sur un nœud de calcul.",
+  "hpcWizard.submitting": "Soumission…",
+  "hpcWizard.submitJob": "⏫ Soumettre le job",
+  "projectDialog.installGitLabel": "Installer git",
+  "projectDialog.installBinLabel": "Installer {bin}",
+  "projectDialog.titleNew": "Nouveau projet",
+  "projectDialog.titleImport": "Importer un projet",
+  "projectDialog.remoteToggleTitle": "Projet distant (SSH)",
+  "projectDialog.remoteToggleDesc": "Travaillez sur un projet qui réside sur une autre machine — terminaux, fichiers et git s'exécutent tous sur l'hôte via SSH.",
+  "projectDialog.localLocationLabel": "Emplacement local",
+  "projectDialog.noFolderSelected": "Aucun dossier sélectionné",
+  "projectDialog.browseBtn": "Parcourir...",
+  "projectDialog.localMirrorHint": "La copie de travail locale synchronisée réside ici sous le nom {name}.",
+  "projectDialog.projectNameLabel": "Nom du projet",
+  "projectDialog.descriptionLabel": "Description du projet",
+  "projectDialog.descFillModeTitle": "Mode de remplissage de la description du projet",
+  "projectDialog.fillModeManual": "Manuel",
+  "projectDialog.fillModeAgentChoice": "Choix de l'agent",
+  "projectDialog.descriptionPlaceholder": "À quoi sert ce projet",
+  "projectDialog.importFromLabel": "Importer depuis",
+  "projectDialog.importFolderOpt": "Dossier sur cette machine",
+  "projectDialog.importGitOpt": "Dépôt GitHub / GitLab (clone)",
+  "projectDialog.importForkOpt": "Dépôt GitHub / GitLab (fork, puis clone)",
+  "projectDialog.sourceFolderLabel": "Dossier source",
+  "projectDialog.repoToForkLabel": "Dépôt à forker",
+  "projectDialog.repoUrlLabel": "URL du dépôt",
+  "projectDialog.forkHintPre": "Le dépôt est forké dans votre propre compte, et c'est votre fork qui est cloné ici — l'original reste en tant que remote",
+  "projectDialog.forkHintMid": ". Le fork passe par la CLI du fournisseur (",
+  "projectDialog.forkHintPost": "), il utilise donc la connexion de cette CLI.",
+  "projectDialog.cloneHintPrivateConnected": "Un dépôt privé est cloné avec le jeton d'accès de Paramètres → Hébergement Git. Une URL SSH (git@…) utilise à la place vos propres clés SSH.",
+  "projectDialog.cloneHintPublicOnly": "Les dépôts publics se clonent tels quels. Pour un dépôt privé, ajoutez un jeton d'accès dans Paramètres → Hébergement Git, ou utilisez une URL SSH (git@…) pour vous authentifier avec vos clés SSH.",
+  "projectDialog.hostTypeLabel": "Type d'hôte",
+  "projectDialog.detectFromUrl": "Détecter depuis l'URL",
+  "projectDialog.detectFromUrlWithProvider": "Détecter depuis l'URL ({provider})",
+  "projectDialog.hostTypeHint": "Cet hôte ne se déclare pas comme GitHub ou GitLab (une instance auto-hébergée ne le fait généralement pas) — choisissez lequel c'est, car le fork est réalisé par la CLI de ce fournisseur.",
+  "projectDialog.forkCliMissingPre": "Aucun",
+  "projectDialog.forkCliMissingMid1": "trouvé sur cette machine — un fork est créé par la CLI propre du fournisseur, installez-la donc (et connectez-vous avec",
+  "projectDialog.forkCliMissingPost": ") pour forker depuis",
+  "projectDialog.runInTerminalBtn": "Exécuter dans le terminal",
+  "projectDialog.locationLabel": "Emplacement",
+  "projectDialog.cloneDestYourFork": "Votre fork est",
+  "projectDialog.cloneDestTheRepo": "Le dépôt est",
+  "projectDialog.cloneDestMid": "cloné dans",
+  "projectDialog.cloneDestPost": "ici.",
+  "projectDialog.gitHostingLabel": "Hébergement Git",
+  "projectDialog.gitNoneOpt": "Pas de git (fichiers bruts, pas de dépôt)",
+  "projectDialog.gitLocalOpt": "Dépôt local uniquement (non poussé nulle part)",
+  "projectDialog.gitRemotePrivateOpt": "Pousser vers GitHub/GitLab · privé",
+  "projectDialog.gitRemotePublicOpt": "Pousser vers GitHub/GitLab · public",
+  "projectDialog.gitHostingHintPre": "« Pousser vers GitHub/GitLab » publie le dépôt sur un service d'hébergement",
+  "projectDialog.gitHostingHintRemoteSuffix": "— sans rapport avec l'hôte SSH ci-dessus, qui est simplement l'endroit où vivent les fichiers du projet.",
+  "projectDialog.needsGitConnectionText": "Aucune connexion GitHub/GitLab n'est encore configurée dans Eldrun. Ajoutez un jeton d'accès dans Paramètres → Hébergement Git pour que le dépôt puisse être publié.",
+  "projectDialog.setUpGitHostingBtn": "Configurer GitHub/GitLab…",
+  "projectDialog.needsGitInstallTextPre": "Aucun git trouvé sur cette machine — installez-le pour créer un projet basé sur git",
+  "projectDialog.needsGitInstallOrClone": " ou cloner un dépôt",
+  "projectDialog.importModeLabel": "Mode d'import",
+  "projectDialog.modeKeepOpt": "Conserver l'emplacement (enregistrer sur place)",
+  "projectDialog.modeCopyOpt": "Copier dans le dossier de projets d'Eldrun",
+  "projectDialog.modeMoveOpt": "Déplacer dans le dossier de projets d'Eldrun",
+  "projectDialog.remoteImportKeepsFolder": "L'import distant conserve le dossier tel quel sur l'hôte distant.",
+  "projectDialog.skipScaffoldLabel": "Ignorer le scaffolding (ne générer aucun fichier de scaffold)",
+  "projectDialog.scaffoldGuidanceAria": "Guide de scaffold pour l'import",
+  "projectDialog.importGuidanceTitle": "Guide d'import",
+  "projectDialog.stepSelectSource": "Sélectionnez le dossier source et les métadonnées du projet.",
+  "projectDialog.stepRegisterKeep": "Enregistrez le projet à son emplacement actuel.",
+  "projectDialog.stepCopyValidate": "Copiez le projet dans le dossier de projets d'Eldrun après validation manuelle.",
+  "projectDialog.stepMoveValidate": "Déplacez le projet dans le dossier de projets d'Eldrun après validation manuelle.",
+  "projectDialog.stepCreateScaffold": "Créez les fichiers de scaffold manquants et prenez acte de ceux déjà présents.",
+  "projectDialog.stepWriteProjectJson": "Écrivez project.json et ajoutez le projet au sélecteur.",
+  "projectDialog.manualValidationCopy": "J'ai validé manuellement la destination de copie et le dossier source.",
+  "projectDialog.manualValidationMove": "J'ai validé manuellement la destination de déplacement et le dossier source.",
+  "projectDialog.fillAllLabel": "Tout remplir",
+  "projectDialog.noMissingFiles": "Aucun fichier manquant",
+  "projectDialog.chooseFillMode": "Choisir un mode de remplissage...",
+  "projectDialog.alreadyThere": "Déjà présent",
+  "projectDialog.missingLabel": "Manquant",
+  "projectDialog.alreadyThereKept": "Déjà présent, sera conservé",
+  "projectDialog.missingWillAdd": "Manquant, sera ajouté",
+  "projectDialog.statusOnly": "Statut uniquement",
+  "projectDialog.chooseSourceToPreview": "Choisissez un dossier source pour prévisualiser les fichiers de scaffold.",
+  "projectDialog.loadingScaffoldPreview": "Chargement de l'aperçu du scaffold...",
+  "projectDialog.remoteDestinationLabel": "Destination distante : {path}",
+  "projectDialog.remoteLocationLabel": "Emplacement distant : {path}",
+  "projectDialog.changeFolderBtn": "Changer de dossier",
+  "projectDialog.changeFolderTitleWinManual": "Revenez en arrière pour changer le chemin distant",
+  "projectDialog.changeFolderTitleBrowse": "Revenez au navigateur distant pour choisir un autre dossier",
+  "projectDialog.destinationLabel": "Destination : {path}",
+  "projectDialog.locationColonLabel": "Emplacement : {path}",
+  "projectDialog.forking": "Fork en cours...",
+  "projectDialog.cloningEllipsis": "Clonage...",
+  "projectDialog.working": "Traitement...",
+  "projectDialog.create": "Créer",
+  "projectDialog.forkAndImport": "Forker et importer",
+  "projectDialog.cloneAndImport": "Cloner et importer",
+  "projectDialog.import": "Importer",
+  "projectDialog.runInTerminalTitle": "Exécuter cette commande dans un nouvel onglet de terminal",
+  "remoteProjectSection.vpnUpClickToReconnect": "Le tunnel OpenVPN est actif. Cliquez pour reconnecter.",
+  "remoteProjectSection.vpnFailedWithError": "Échec de la connexion VPN : {error}",
+  "remoteProjectSection.vpnFailedClickRetry": "Échec de la connexion VPN. Cliquez pour réessayer.",
+  "remoteProjectSection.vpnBringUpHint": "Établissez maintenant le tunnel OpenVPN pour atteindre un hôte protégé par VPN.",
+  "remoteProjectSection.vpnSelectConfigFirst": "Sélectionnez d'abord une configuration OpenVPN.",
+  "remoteProjectSection.stepConnectLabel": "Connexion",
+  "remoteProjectSection.stepBrowseLabel": "Parcourir",
+  "remoteProjectSection.stepDetailsLabel": "Détails",
+  "remoteProjectSection.remoteStepsAria": "Étapes du projet distant",
+  "remoteProjectSection.passwordAuthWarning": "L'authentification par mot de passe nécessite OpenSSH 8.4+ ou sshpass — mettez à jour OpenSSH ou installez sshpass, ou utilisez des clés SSH (laissez le mot de passe vide).",
+  "remoteProjectSection.opensslMissingWarning": "openvpn/pkexec introuvable — les hôtes protégés par VPN ne peuvent pas se connecter. Installez openvpn et polkit.",
+  "remoteProjectSection.vpnToggleDescLine1": "Nécessaire uniquement pour un hôte protégé par VPN — laissez désactivé si vous êtes déjà sur le bon réseau.",
+  "remoteProjectSection.vpnConfigLabel": "Configuration OpenVPN",
+  "remoteProjectSection.vpnConfigCopiedHint": "(copié dans Eldrun à la sélection)",
+  "remoteProjectSection.noOvpnSelected": "Aucun .ovpn sélectionné",
+  "remoteProjectSection.browseEllipsis": "Parcourir…",
+  "remoteProjectSection.storedWithProject": "(stocké avec le projet)",
+  "remoteProjectSection.vpnUsernamePlaceholderNoDots": "Identifiant du compte OpenVPN",
+  "remoteProjectSection.savedInKeychainYour": "(enregistré dans le trousseau de votre système)",
+  "remoteProjectSection.notStoredUnlessSaved": "(non stocké, sauf si vous l'enregistrez ci-dessous)",
+  "remoteProjectSection.vpnAccountPasswordNoDots": "Mot de passe du compte OpenVPN",
+  "remoteProjectSection.keyPassphrasePlaceholderNoDots": "Phrase secrète pour la clé chiffrée de la configuration",
+  "remoteProjectSection.vpnTermBtnTitleActive": "Établissez le tunnel OpenVPN dans un terminal ci-dessous — saisissez-y la phrase secrète. Il reste actif pour le nouveau projet.",
+  "remoteProjectSection.vpnTermHintClosed": "Cliquez ci-dessus pour ouvrir un terminal ici — saisissez-y la phrase secrète. Eldrun ne la traite jamais ; le tunnel reste actif pour le nouveau projet.",
+  "remoteProjectSection.vpnTermHintOpen": "Authentifiez le tunnel ci-dessous — il continue de fonctionner pour le nouveau projet après la fermeture de cette boîte de dialogue.",
+  "remoteProjectSection.sshAddressLabel": "Adresse SSH",
+  "remoteProjectSection.reuseSshAddressTitle": "Réutiliser une adresse SSH déjà utilisée",
+  "remoteProjectSection.sshAddressPlaceholder": "user@host ou hôte:2222",
+  "remoteProjectSection.passwordLabel": "Mot de passe",
+  "remoteProjectSection.notStoredBlankKey": "(non stocké sauf si vous l'enregistrez ci-dessous ; vide utilise la clé SSH)",
+  "remoteProjectSection.sshSavedPlaceholder": "Utilise le mot de passe enregistré — laisser vide",
+  "remoteProjectSection.sshPasswordPlaceholderNoDots": "mot de passe, ou la phrase secrète de votre clé — vide si la clé est déverrouillée",
+  "remoteProjectSection.connectingDotsShort": "Connexion...",
+  "remoteProjectSection.remotePathLabel": "Chemin distant",
+  "remoteProjectSection.remotePathHintNew": "(dossier parent ; le projet est créé à l'intérieur)",
+  "remoteProjectSection.remotePathHintImport": "(chemin absolu du projet existant)",
+  "remoteProjectSection.reuseRemotePathTitle": "Réutiliser un chemin distant déjà utilisé pour cet hôte",
+  "remoteProjectSection.remotePathPlaceholder": "/home/user/projects",
+  "remoteProjectSection.sshTermBtnTitle": "Ouvrez la connexion SSH dans un terminal ci-dessous — saisissez-y n'importe quel mot de passe. La connexion reste active pour le nouveau projet.",
+  "remoteProjectSection.tryBrowseTitle": "Si vous avez terminé de vous connecter ci-dessus, parcourez maintenant l'arborescence distante.",
+  "remoteProjectSection.sshTermHintClosedPre": "Cliquez ci-dessus pour ouvrir un terminal ici — saisissez-y n'importe quel mot de passe. Eldrun ne le traite jamais ; la connexion reste active pour le nouveau projet.",
+  "remoteProjectSection.sshTermHintClosedSuffix": " Une fois connecté, l'arborescence distante s'ouvre pour la navigation.",
+  "remoteProjectSection.sshTermHintOpen": "Connectez-vous ci-dessous — la session continue de fonctionner pour le nouveau projet après la fermeture de cette boîte de dialogue.",
+  "remoteProjectSection.willCreateLabel": "Sera créé : {path}",
+  "remoteProjectSection.selectedLabel": "Sélectionné : {path}",
+  "credentialPasteBar.typeItForMe": "Le taper pour moi :",
+  "credentialPasteBar.pastedFlash": "collé",
+  "credentialPasteBar.nothingSavedFlash": "rien d'enregistré pour cette connexion (ou le trousseau est verrouillé)",
+  "credentialPasteBar.pasteUsername": "Coller l'identifiant",
+  "credentialPasteBar.pasteUsernameTitle": "Tape « {user} » dans le terminal de connexion à l'emplacement du curseur.",
+  "credentialPasteBar.pastePassword": "Coller le mot de passe",
+  "credentialPasteBar.pastePasswordTitle": "Tape le mot de passe enregistré pour cette connexion dans le terminal à l'emplacement du curseur — il va directement de votre trousseau système au terminal, jamais via l'interface d'Eldrun. Appuyez vous-même sur Entrée.",
+  "credentialPasteBar.pasteVpnUsernameTitle": "Tape l'identifiant d'authentification de ce tunnel dans le terminal à l'emplacement du curseur.",
+  "credentialPasteBar.pastePassphrase": "Coller la phrase secrète",
+  "credentialPasteBar.pasteVpnSecretTitle": "Tape le secret enregistré pour ce tunnel dans le terminal à l'emplacement du curseur — directement de votre trousseau système au terminal. Appuyez vous-même sur Entrée.",
+  "credentialPasteBar.pasteKeyPassphrase": "Coller la phrase secrète de la clé",
+  "credentialPasteBar.pasteKeyPassphraseTitle": "Tape la phrase secrète de la clé privée enregistrée dans le terminal à l'emplacement du curseur — OpenVPN la demande séparément du mot de passe du compte.",
+  "terminalSignIn.sshHostWord": "hôte SSH",
+  "terminalSignIn.vpnTunnelWord": "tunnel OpenVPN",
+  "terminalSignIn.busyTitle": "Déconnectez d'abord le terminal de connexion ci-dessous.",
+  "terminalSignIn.titleTemplate": "Connectez-vous à {what} dans un terminal ici plutôt que dans ces champs. Il pose ses propres questions — un mot de passe, un code de défi, une seconde invite — et vous y répondez directement ; Eldrun ne les voit jamais. Pour cette connexion seulement : votre paramètre headless reste inchangé.",
+  "terminalSignIn.label": "Se connecter dans un terminal",
+  "terminalSignIn.failedHint": "la connexion a échoué — si {what} demande autre chose qu'un mot de passe (un code de défi, une seconde invite), seul un terminal peut y répondre",
+  "terminalSignIn.defaultHint": "pour un hôte qui demande plus qu'un mot de passe — un code de défi, une seconde invite",
+  "projectHoverCard.statusCurrent": "Actuel",
+  "projectHoverCard.statusActive": "Actif",
+  "projectHoverCard.statusInactive": "Inactif",
+  "projectHoverCard.timeUnderMinute": "< 1 min",
+  "projectHoverCard.cpuIdle": "inactif",
+  "projectHoverCard.remoteLabel": "distant",
+  "projectHoverCard.localLabel": "local",
+  "projectHoverCard.originLabel": "origine",
+  "projectHoverCard.todayPrefix": "Aujourd'hui :",
+  "projectHoverCard.pausedSuffix": "(en pause)",
+  "projectHoverCard.cpuPrefix": "CPU :",
+  "windowControls.minimize": "Réduire",
+  "windowControls.maximize": "Agrandir",
+  "connTypeIcon.offlineSuffix": " (hors ligne)",
+  "appTimer.globalActivityTitle": "Activité globale",
+  "appTimer.pausedResumeHint": "En pause — cliquez pour reprendre",
+  "appTimer.clickPauseHint": "Cliquez pour mettre en pause • Clic droit pour l'activité",
+  "appResource.processCountOne": "{count} processus Eldrun",
+  "appResource.processCountMany": "{count} processus Eldrun",
+  "appResource.gpuNoDeviceTitle": "Mémoire GPU utilisée par les modèles locaux (Ollama) — le GPU de cette machine ne rapporte aucune mémoire propre",
+  "remoteConnMenu.statusError": "erreur",
+  "remoteConnMenu.statusConnecting": "connexion",
+  "remoteConnMenu.statusConnected": "connecté",
+  "remoteConnMenu.statusOff": "désactivé",
+  "remoteConnMenu.ariaLabel": "Machines distantes — cliquez pour connecter/gérer les hôtes de ce projet",
+  "remoteConnMenu.workingWord": "en activité",
+  "vpnIndicator.keyringStayedLocked": "Le trousseau est resté verrouillé — les identifiants VPN enregistrés ne peuvent pas encore être lus.",
+  "vpnIndicator.keyringLockedConnectReason": "Le trousseau de votre système est verrouillé, les identifiants VPN enregistrés ne peuvent donc pas être lus. Déverrouillez-le (ou saisissez la phrase secrète ci-dessous) pour vous connecter.",
+  "vpnIndicator.savedCredentialsDidntWork": "Les identifiants VPN enregistrés n'ont pas fonctionné : {error}",
+  "vpnIndicator.noCredentialStore": "Cette machine n'a pas de magasin d'identifiants, donc rien ne peut être enregistré pour ce tunnel.",
+  "vpnIndicator.noSavedCredentialsYet": "Pas encore d'identifiants enregistrés pour ce tunnel — cochez « Enregistrer les identifiants de connexion » pour passer cette étape la prochaine fois.",
+  "vpnIndicator.enterCredentialsOnce": "Saisissez les identifiants une fois — ils vont dans votre trousseau système, et ce tunnel se connecte sans demander désormais.",
+  "vpnIndicator.saveCredentialsAria": "Enregistrer les identifiants de connexion pour {file}",
+  "vpnIndicator.saveCredsUnavailableTitle": "Cette machine n'a pas de magasin d'identifiants système, donc rien ne peut être enregistré.",
+  "vpnIndicator.saveCredsSavedTitle": "Les identifiants de ce tunnel sont dans votre trousseau système — la connexion ne demande rien. Désactivez pour les supprimer.",
+  "vpnIndicator.saveCredsNotSavedTitle": "Demandez une fois les identifiants de ce tunnel, conservez-les dans votre trousseau système, et connectez-vous sans demander par la suite.",
+  "vpnIndicator.saveLoginCredentialsLabel": "Enregistrer les identifiants de connexion",
+  "vpnIndicator.savedButLocked": "Enregistré, mais votre trousseau est verrouillé — déverrouillez-le ci-dessus pour les utiliser.",
+  "vpnIndicator.connectOnLaunchAria": "Connecter {file} au démarrage",
+  "vpnIndicator.connectOnLaunchHeadlessTitle": "Établit ce tunnel automatiquement au démarrage d'Eldrun, en utilisant les identifiants enregistrés — sans demander. Il redirige cet ordinateur dès le démarrage.",
+  "vpnIndicator.connectOnLaunchInteractiveTitle": "Ouvre la commande de connexion de ce tunnel dans le terminal racine au démarrage d'Eldrun, pour que vous vous authentifiiez. Il redirige cet ordinateur une fois actif.",
+  "vpnIndicator.connectOnLaunchLabel": "Connecter au démarrage",
+  "vpnIndicator.needSaveCredsFirstHintPre": "Activez",
+  "vpnIndicator.needSaveCredsFirstHintPost": "d'abord — la connexion automatique ne demande jamais rien, elle n'est donc proposée que lorsque la connexion peut être silencieuse.",
+  "vpnIndicator.startsWithEldrun": "Démarre avec Eldrun",
+  "vpnIndicator.waitsInRootTerminal": " (attend dans le terminal racine)",
+  "vpnIndicator.mainAriaLabel": "OpenVPN — connecter ou déconnecter un tunnel",
+  "vpnIndicator.titleOff": "OpenVPN — pas de tunnel. En connecter un y achemine le trafic de cet ordinateur.",
+  "vpnIndicator.titleConnecting": "OpenVPN — connexion en cours. Une fois actif, le trafic de cet ordinateur passe par le tunnel.",
+  "vpnIndicator.titleConnected": "OpenVPN — actif. Le trafic de cet ordinateur passe par le tunnel.",
+  "vpnIndicator.vpnLabel": "VPN",
+  "vpnIndicator.note": "Un tunnel achemine",
+  "vpnIndicator.noteStrong": "tout le trafic de cet ordinateur",
+  "vpnIndicator.notePost": "— pas seulement celui d'Eldrun — y compris votre navigateur — tant qu'il est actif.",
+  "vpnIndicator.lockedBannerPre": "Votre trousseau système est",
+  "vpnIndicator.lockedBannerStrong": "verrouillé",
+  "vpnIndicator.lockedBannerPost": ", donc les identifiants VPN enregistrés ne peuvent pas être lus — la connexion les redemandera jusqu'à ce qu'il soit déverrouillé.",
+  "vpnIndicator.unlockTitle": "Déverrouille le magasin d'identifiants système pour que les identifiants enregistrés puissent être utilisés. Votre bureau demande le mot de passe du trousseau.",
+  "vpnIndicator.unlocking": "Déverrouillage…",
+  "vpnIndicator.unlockKeyring": "Déverrouiller le trousseau",
+  "vpnIndicator.heldForPrefix": "pour",
+  "vpnIndicator.heldByNoProject": "détenu par aucun projet",
+  "vpnIndicator.stopConnectingTitle": "Arrête la tentative d'établir ce tunnel et restaure le routage normal.",
+  "vpnIndicator.stopConnecting": "Arrêter la connexion",
+  "vpnIndicator.disconnectTunnelTitle": "Coupe ce tunnel et restaure le routage normal. Les projets qui l'utilisent restent ouverts ; leur SSH peut ou non survivre sans lui.",
+  "vpnIndicator.disconnectTunnel": "Déconnecter le tunnel",
+  "vpnIndicator.connectGroupLabel": "Connecter",
+  "vpnIndicator.removeConfigHint": "Retire cette configuration d'Eldrun et oublie ses identifiants enregistrés.",
+  "vpnIndicator.usedByPre": "Utilisé par",
+  "vpnIndicator.usedByPost": "— la connexion à ce projet redemandera une configuration.",
+  "vpnIndicator.removeConfigBtn": "Retirer la configuration",
+  "vpnIndicator.keepBtn": "Conserver",
+  "vpnIndicator.connectTunnelTitle": "Établit ce tunnel. Il acheminera le trafic de cet ordinateur — pas seulement celui d'Eldrun.",
+  "vpnIndicator.removeConfigTitle": "Retire cette configuration enregistrée d'Eldrun et oublie ses identifiants enregistrés. Redemande confirmation avant de le faire.",
+  "vpnIndicator.emptyStatePre": "Aucune configuration OpenVPN enregistrée pour l'instant — ajoutez un fichier",
+  "vpnIndicator.emptyStatePost": ", puis connectez-le depuis sa ligne (il vous demandera votre mot de passe là).",
+  "vpnIndicator.addFirstConfigTitle": "Choisissez un fichier .ovpn et enregistrez-le dans Eldrun. L'ajouter ne connecte pas — vous le connectez explicitement ensuite, où il demande votre mot de passe.",
+  "vpnIndicator.addAnotherConfigTitle": "Choisissez un autre fichier .ovpn et enregistrez-le dans Eldrun. L'ajouter ne connecte pas — vous le connectez explicitement depuis sa ligne ensuite.",
+  "vpnIndicator.addConfigBtn": "Ajouter une configuration…",
+};
+
+const it: Dict = {
+  "common.back": "Indietro",
+  "common.cancel": "Annulla",
+  "common.remove": "Rimuovi",
+  "common.delete": "Elimina",
+  "common.add": "Aggiungi",
+  "common.reset": "Ripristina",
+  "common.recheck": "Ricontrolla",
+  "common.loading": "Caricamento…",
+  "common.default": "predefinito",
+
+  "settings.title": "Impostazioni",
+  "settings.theme": "Tema",
+  "settings.language": "Lingua",
+  "settings.language.help":
+    "Imposta la lingua dell'interfaccia di Eldrun. Ha effetto immediato — nessun riavvio.",
+  "settings.runScriptsBg": "Esegui script in background",
+  "settings.claudeRemote": "Controllo remoto di Claude",
+  "settings.headlessRemote": "Connessioni remote headless",
+  "settings.persistLocal": "Sessioni locali persistenti (tmux)",
+  "settings.remoteFeatures": "Funzioni remote",
+  "settings.vpnEnabled": "Controllo del tunnel OpenVPN",
+  "settings.machinesEnabled": "Macchine remote globali",
+  "settings.energySaver": "Risparmio energetico",
+  "energy.off": "Disattivato",
+  "energy.battery": "A batteria",
+  "energy.always": "Sempre",
+  "settings.debug": "Modalità debug",
+  "settings.experimental": "Sperimentale",
+  "settings.agentModeToggle": "Interruttore Plan/Auto sulle schede agente",
+  "settings.pythonRunDebug": "Esegui/Debug Python nel visualizzatore di codice",
+  "settings.resourceMonitor": "Monitoraggio risorse",
+  "settings.showCpu": "Mostra utilizzo CPU",
+  "settings.showRam": "Mostra utilizzo RAM",
+  "settings.showGpu": "Mostra utilizzo GPU",
+  "settings.showClockSeconds": "Mostra i secondi nell'orologio dell'intestazione",
+
+  "settings.calendar": "Calendario",
+  "settings.weekStartsOn": "La settimana inizia di",
+  "day.sunday": "Domenica",
+  "day.monday": "Lunedì",
+  "settings.defaultView": "Vista predefinita",
+  "view.day": "Giorno",
+  "view.week": "Settimana",
+  "view.multiweek": "Multisettimana",
+  "view.month": "Mese",
+  "view.agenda": "Agenda",
+  "view.tasks": "Attività",
+  "settings.clock24": "Formato 24 ore",
+  "settings.dayGridStart": "La griglia del giorno inizia alle",
+  "settings.defaultReminder": "Promemoria predefinito",
+  "reminder.none": "Nessuno",
+  "reminder.5": "5 minuti prima",
+  "reminder.15": "15 minuti prima",
+  "reminder.30": "30 minuti prima",
+  "reminder.60": "1 ora prima",
+  "reminder.1440": "1 giorno prima",
+
+  "settings.hintsOnboarding": "Suggerimenti e introduzione",
+  "settings.showHints": "Mostra suggerimenti contestuali",
+  "settings.howToStart": "Come iniziare...",
+  "settings.takeTour": "Fai un tour",
+  "settings.lessons": "Lezioni",
+  "settings.resetHints": "Reimposta suggerimenti",
+
+  "settings.layout": "Layout",
+  "settings.windowZoom": "Zoom finestra",
+  "settings.minSubWidth": "Larghezza min. sottofinestra (px)",
+  "settings.minSubHeight": "Altezza min. sottofinestra (px)",
+
+  "settings.downloads": "Download",
+  "settings.noDownloadFolders":
+    "Nessuna cartella aggiunta — viene usata la cartella Download di sistema.",
+  "settings.addDownloadFolder": "Aggiungi cartella download...",
+
+  "settings.usageStats": "Statistiche di utilizzo",
+  "settings.dailyRecap": "Mostra il riepilogo all'inizio di ogni giorno",
+  "settings.openUsageStats": "Apri statistiche di utilizzo",
+
+  "settings.moreSettings": "Altre impostazioni",
+  "nav.git.title": "Hosting Git",
+  "nav.git.blurb": "Profilo di hosting, token di accesso e pubblicazione.",
+  "nav.vpn.title": "Connessione automatica VPN",
+  "nav.vpn.blurb": "Attiva un tunnel salvato per connettersi all'avvio.",
+  "nav.remoteHosts.title": "Connessioni remote",
+  "nav.remoteHosts.blurb": "Imposta un percorso standard per host SSH.",
+  "nav.global.title": "App globali",
+  "nav.global.blurb": "Avvii della barra mostrati in ogni progetto.",
+  "nav.filetypes.title": "App per tipo di file",
+  "nav.filetypes.blurb": "Scegli quale app apre ogni tipo di file.",
+  "nav.agents.title": "Gestisci agenti",
+  "nav.agents.blurb": "Installa o aggiorna le CLI degli agenti.",
+  "nav.shortcuts.title": "Scorciatoie da tastiera",
+  "nav.shortcuts.blurb": "Riassegna le scorciatoie di navigazione.",
+  "nav.archive.title": "Progetti archiviati",
+  "nav.archive.blurb": "Ripristina o elimina definitivamente i progetti archiviati.",
+  "nav.scaffoldRepair.title": "Ripara struttura del progetto",
+  "nav.scaffoldRepair.blurb": "Rigenera i file di struttura mancanti.",
+  "nav.help.title": "Guida alle funzioni",
+  "nav.help.blurb": "Glossario completo delle funzioni di Eldrun.",
+  "settings.energyUnavailable": "Stato energia non disponibile — trattato come a corrente (inattivo).",
+  "settings.energyActiveAlways": "Attualmente attivo — sempre acceso.",
+  "settings.energyActiveBattery": "Attualmente attivo — funziona a batteria.",
+  "settings.energyOff": "Disattivato — non limita mai le prestazioni.",
+  "settings.energyInactive": "Inattivo — a corrente.",
+  "settings.claudeRemoteHelp1": "Avvia schede agente Claude con",
+  "settings.claudeRemoteHelp2": "così puoi monitorarle e guidarle dall'app o dal web di Claude. Richiede l'accesso con un abbonamento Claude (non una chiave API); solo Claude lo supporta.",
+  "settings.headlessRemoteHelp": "Se attivo (predefinito), Eldrun stabilisce le connessioni SSH/OpenVPN in background, gestendo la password in modo transitorio. Disattivalo per aprire invece ogni connessione come terminale interattivo nella root di Eldrun — digiti la password direttamente in quel terminale ed Eldrun non la gestisce mai.",
+  "settings.persistLocalHelp1": "Se attivo (predefinito), la shell e le schede Python/script di un progetto locale girano in una sessione tmux su questa macchina, così un'esecuzione lunga continua se Eldrun si blocca, e la scheda si ricollega al riavvio. Chiudere una scheda termina comunque la sua sessione. Richiede",
+  "settings.persistLocalHelp2": "; le schede agente non sono interessate.",
+  "settings.remoteFeaturesHelp": "Entrambi aggiungono un controllo a livello di macchina nell'intestazione: un tunnel OpenVPN (instrada il traffico di tutto questo computer finché è attivo) e un elenco di macchine SSH che non appartengono a nessun progetto. Disattivato per impostazione predefinita; richiesto una volta al primo avvio.",
+  "settings.energyHelp": "Quando attivo, Eldrun rallenta per risparmiare energia: mette in pausa la rotazione inattiva del blob del progetto, calma i bagliori di stato e rallenta gli aggiornamenti in background. «A batteria» (predefinito) lo fa solo quando scollegato.",
+  "settings.experimentalHelp1": "Funzionalità ancora in evoluzione. Ognuna è disattivata per impostazione predefinita e",
+  "settings.experimentalHelpBold": "attivata per impostazione predefinita in modalità debug",
+  "settings.experimentalHelp2": "— quindi compilare Eldrun significa vederle senza dover rispuntare questo elenco ogni volta che ne arriva una nuova. Un interruttore qui vince sempre, in entrambe le direzioni: puoi attivarne una senza la modalità debug, o disattivarne una mentre ci sei.",
+  "settings.agentModeHelp1": "Mette un badge su ogni scheda agente che la commuta tra",
+  "settings.agentModeHelp2": "(legge e propone, non modifica mai) e",
+  "settings.agentModeHelp3": "(accetta automaticamente le modifiche; i comandi shell e di rete chiedono comunque conferma) — così una scheda può pianificare mentre un'altra fa il lavoro, e ciascuna torna nella propria modalità dopo un riavvio. Il cambio riavvia l'agente: la conversazione riprende, ma lo scrollback del terminale va perso. Solo Claude lo supporta — è l'unico agente che può sia essere avviato in una modalità sia riprendere la sua conversazione al riavvio.",
+  "settings.pythonRunHelp1": "Dà a un file",
+  "settings.pythonRunHelp2": "aperto nell'editor un pulsante",
+  "settings.pythonRunHelp3": "e un",
+  "settings.pythonRunHelp4": "pulsante, e trasforma i suoi numeri di riga in un margine di breakpoint. Entrambi aprono una scheda terminale nel progetto — quindi girano sull'host di un progetto remoto e nel container di uno containerizzato — e usano l'interprete proprio del progetto. Il debug è",
+  "settings.pythonRunHelp5": ", precaricato con i breakpoint del margine. Disattivato per impostazione predefinita perché Esegui esegue il file. Ctrl+clic su una definizione non è bloccato: legge soltanto.",
+  "settings.resourceMonitorHelp": "CPU e RAM coprono l'albero dei processi proprio di Eldrun; GPU mostra la VRAM in uso dai modelli locali caricati in Ollama. La pillola appare nell'intestazione accanto al timer.",
+  "settings.reminderHelp": "I promemoria si attivano come notifica desktop e come popup in-app che puoi posticipare. «La griglia del giorno inizia alle» imposta solo dove scorrono le viste giorno e settimana — gli eventi precedenti sono ancora lì, appena sopra.",
+  "settings.zoomHelp1": "Lo zoom della finestra scala l'intera interfaccia di Eldrun — utile su monitor 4K / alta densità. 100% è il valore predefinito. Lo zoom è",
+  "settings.zoomHelpBold": "per finestra",
+  "settings.zoomHelp2": ": questo imposta la finestra principale, e ogni sottofinestra staccata mantiene il proprio. Ctrl + / Ctrl − ingrandiscono la finestra attiva e Ctrl 0 lo ripristina.",
+  "settings.minSubwindowHelp": "La dimensione minima a cui una sottofinestra può essere ridotta trascinando un divisore. Predefinito {px}px se lasciato vuoto.",
+  "settings.downloadsHelp": "Cartelle scansionate dalla sezione Download del pannello destro (l'interruttore 📥), per copiare rapidamente i file appena scaricati in un progetto. Sola lettura — Eldrun non modifica mai il percorso di download di alcun browser. Predefinita la cartella Download di sistema se vuoto.",
+  "settings.removeFolderTitle": "Rimuovi questa cartella",
+  "settings.dailyRecapHelp": "Un riepilogo della giornata appena conclusa: quali agenti hai usato e quanto li hai interpellati, file creati/modificati/eliminati, commit e tempo per progetto. Disattivarlo ferma il popup, non il conteggio — tutto resta locale.",
+
+  "shortcuts.help":
+    "Clicca su una scorciatoia, poi premi la nuova combinazione di tasti. F11 (schermo intero di sistema) ed Esc (esci da schermo intero) sono fissi e non possono essere riassegnati.",
+  "shortcuts.captureTitle": "Clicca, poi premi una combinazione di tasti",
+  "shortcuts.pressKeys": "Premi i tasti…",
+  "shortcuts.resetTitle": "Ripristina il valore predefinito",
+
+  "git.help":
+    "Il tuo profilo di hosting e il token di accesso vengono usati quando pubblichi il repository di un progetto su GitHub o GitLab.",
+  "git.profileUrl": "URL del profilo",
+  "git.profileUrlPlaceholder": "https://github.com/me o https://gitlab.com/me",
+  "git.accessToken": "Token di accesso",
+  "git.tokenPlaceholder": "ghp_... / glpat-...",
+
+  "vpn.autoConnectHelp":
+    "Attiva un tunnel OpenVPN salvato affinché si connetta automaticamente all'avvio di Eldrun. Instrada tutto il traffico di questo computer — non solo quello di Eldrun — finché è attivo, quindi può essere armata una sola configurazione alla volta; attivarne un'altra disattiva la prima. Le configurazioni salvate si aggiungono dalla finestra di connessione di un progetto remoto o dal menu VPN nell'intestazione.",
+  "vpn.noConfig": "Nessuna configurazione OpenVPN salvata ancora. Aggiungine una dalla finestra di connessione di un progetto remoto.",
+  "vpn.needsSavedPre": "Connettiti una volta con",
+  "vpn.needsSavedBold": "Salva passphrase",
+  "vpn.needsSavedPost": "selezionato per abilitare questo — la connessione automatica non chiede mai.",
+  "vpn.startsWithEldrun": "Si avvia con Eldrun",
+  "vpn.waitsInRootTerminal": "(attende nel terminale root)",
+
+  "archive.help":
+    "I progetti eliminati vengono conservati qui così puoi ripristinarli. L'eliminazione permanente rimuove la copia archiviata e la sua cronologia di tempo. I file di un progetto remoto (SSH) sul suo host non vengono mai toccati.",
+  "archive.empty": "Nessun progetto archiviato.",
+  "archive.remoteTag": "remoto",
+  "archive.unsyncedVerifiedOne":
+    "{count} commit locale su {branches} non è mai stato sincronizzato con l'host e andrà perso. I file dell'host stesso non sono interessati.",
+  "archive.unsyncedVerifiedMany":
+    "{count} commit locali su {branches} non sono mai stati sincronizzati con l'host e andranno persi. I file dell'host stesso non sono interessati.",
+  "archive.unsyncedUnverifiedOne":
+    "Questo mirror contiene {count} commit che non è stato possibile verificare rispetto all'host; l'eliminazione scarta la copia locale. I file dell'host stesso non sono interessati.",
+  "archive.unsyncedUnverifiedMany":
+    "Questo mirror contiene {count} commit che non è stato possibile verificare rispetto all'host; l'eliminazione scarta la copia locale. I file dell'host stesso non sono interessati.",
+  "archive.typeToDelete": "Digita «{name}» per eliminare",
+  "archive.deleteForever": "Elimina per sempre",
+  "archive.deleting": "Eliminazione…",
+  "archive.restore": "Ripristina",
+  "archive.restoring": "Ripristino…",
+  "archive.deletePermanently": "Elimina definitivamente…",
+  "archive.typeDeleteAll": "Digita «delete» per svuotare tutto",
+  "archive.clearArchive": "Svuota archivio",
+  "archive.clearing": "Svuotamento…",
+  "archive.clearArchiveEllipsis": "Svuota archivio…",
+
+  "scaffoldRepair.help":
+    "Completa qualsiasi file di struttura (AGENTS.md, CLAUDE.md, .claude/settings.json, …) o riga .gitignore predefinita mancante in un progetto — ad es. perché è stato creato prima che quel file/riga fosse aggiunto alla struttura predefinita. I file esistenti non vengono mai sovrascritti; a un .gitignore preesistente vengono solo aggiunte le righe predefinite mancanti. Viene eseguito su ogni progetto gestito (cartella locale o, per i progetti remoti, il loro mirror locale).",
+  "scaffoldRepair.runNow": "Ripara tutti i progetti ora",
+  "scaffoldRepair.running": "Riparazione…",
+  "scaffoldRepair.upToDate": "La struttura di ogni progetto è già aggiornata.",
+
+  "help.title": "Guida di Eldrun",
+  "help.intro": "Una guida rapida a cosa fa ogni parte di Eldrun. Passa il mouse sui pulsanti della barra degli strumenti per vedere anche le loro scorciatoie.",
+  "help.workspaceLayout.title": "Layout dello spazio di lavoro",
+  "help.workspaceLayout.introMac":
+    "Eldrun mantiene il tuo sviluppo assistito dall'IA in un'unica finestra. Sposta il cursore su un bordo dello schermo per rivelare i pannelli, e premi F11 per lo schermo intero.",
+  "help.workspaceLayout.introOther":
+    "Eldrun mantiene il tuo sviluppo assistito dall'IA in un'unica finestra. Premi {key} mentre Eldrun è a fuoco per alternare i pannelli, e F11 per lo schermo intero.",
+  "help.workspaceLayout.item1.term": "Terminale root (▣)",
+  "help.workspaceLayout.item1.desc":
+    "Il terminale di controllo che vive sempre nella cartella root di Eldrun, indipendente da qualsiasi progetto.",
+  "help.workspaceLayout.item2.term": "Pillole di progetto",
+  "help.workspaceLayout.item2.desc":
+    "Una pillola per ogni progetto attivo nel selettore di progetti. Clicca per passare da uno all'altro; ogni progetto mantiene il proprio terminale e le proprie schede. Trascina le pillole per riordinarle.",
+  "help.workspaceLayout.item3.term": "Pannello centrale e schede",
+  "help.workspaceLayout.item3.desc":
+    "I terminali del progetto attivo. Clic destro sulla barra delle schede per aggiungere un agente Claude/Codex/Gemini o una shell semplice, rinominare o chiudere le schede. Trascina le schede per riordinarle.",
+  "help.workspaceLayout.item4.term": "Pannello file destro",
+  "help.workspaceLayout.item4.desc":
+    "Una sovrapposizione ad albero dei file per il progetto attivo. Apri file, rinomina e attiva/disattiva i tipi di file nascosti. Il pannello ricorda l'ultima cartella per progetto.",
+  "help.projects.title": "Progetti",
+  "help.projects.item1.term": "Aggiungi (+)",
+  "help.projects.item1.desc":
+    "Crea un nuovo progetto (genera file e un repository git nella cartella progetti di Eldrun) oppure importa una cartella esistente senza toccarne il contenuto.",
+  "help.projects.item2.term": "Cerca inattivi",
+  "help.projects.item2.desc":
+    "La casella di ricerca trova i progetti non attualmente aperti; scegline uno per attivare la sua pillola e il suo terminale.",
+  "help.projects.item3.term": "Progetti remoti (SSH)",
+  "help.projects.item3.desc":
+    "I progetti su un host remoto vengono montati localmente tramite sshfs e si comportano come qualsiasi altro progetto. Richiede sshfs/FUSE installato.",
+  "help.projects.item4.term": "Attività",
+  "help.projects.item4.desc":
+    "Clic destro su una scheda per impostare, completare o cancellare un'attività dell'agente. Le attività persistono nel project.json del progetto e possono precompilare il prompt di un nuovo agente.",
+  "help.aiTerminals.title": "IA e terminali",
+  "help.aiTerminals.item1.term": "Agenti",
+  "help.aiTerminals.item1.desc":
+    "Apri un agente (claude, codex, gemini, vibe, aider, opencode, cursor, copilot, grok, qwen, openclaw) o una shell semplice dal menu + della barra delle schede. I comandi mancanti ricadono su una shell; gli agenti chiusi si riavviano.",
+  "help.aiTerminals.item2.term": "Modelli Ollama",
+  "help.aiTerminals.item2.desc":
+    "Quando Ollama è installato, il menu a ingranaggio mostra i modelli locali. Ctrl+K apre la finestra di prompt del modello locale per il contesto attivo.",
+  "help.settingsExtras.title": "Impostazioni ed extra",
+  "help.settingsExtras.item1.term": "Impostazioni (⚙)",
+  "help.settingsExtras.item1.desc":
+    "Tema, profilo/token di hosting Git, gestione dello spazio di lavoro, script in background e modalità debug.",
+  "help.settingsExtras.item2.term": "Integrazione dello spazio di lavoro",
+  "help.settingsExtras.item2.desc":
+    "Isolamento del desktop virtuale KDE/X11 per progetto (solo Linux): le finestre avviate di ogni progetto si posizionano sul proprio desktop.",
+  "help.settingsExtras.item3.term": "Monitoraggio del tempo",
+  "help.settingsExtras.item3.desc":
+    "Eldrun registra il tempo di sessione attivo così puoi vedere quanto tempo dedichi a ogni progetto.",
+
+  "globalApps.title": "App globali",
+  "globalApps.help": "App che restano visibili in tutti gli spazi di lavoro. Le app selezionate appaiono nella barra degli strumenti superiore.",
+  "globalApps.showRole": "Mostra {role}",
+  "globalApps.notFoundPlaceholder": "non trovato",
+
+  "filetypes.title": "App per tipo di file",
+  "filetypes.help": "Un doppio clic su un file del progetto lo apre con l'app indicata sotto.",
+  "filetypes.extPlaceholder": ".ext",
+  "filetypes.appPlaceholder": "comando dell'app",
+
+  "remoteHosts.help":
+    "La cartella in cui si apre una connessione o una navigazione per un dato host SSH, invece della directory home dell'host. Impostato una volta qui, si applica la prossima volta che ti connetti a quell'host — sia per il browser di cartelle di un nuovo progetto remoto sia per riconnettersi a uno esistente.",
+  "remoteHosts.empty": "Nessun percorso standard impostato — gli host usano di default la propria directory home.",
+  "remoteHosts.hostPlaceholder": "host",
+  "remoteHosts.pathPlaceholder": "/percorso/sull'host",
+
+  "agents.help1":
+    "Agenti di coding IA che Eldrun può avviare come schede agente. Installane uno con un clic (nessun diritto da amministratore necessario), poi aggiungilo dal menu",
+  "agents.help2": "di una barra delle schede. Molti installer richiedono",
+  "agents.help3": "nel tuo",
+  "agents.help4": "— se manca, installa prima Node.js qui sotto.",
+  "agents.checkingInstalled": "Verifica degli agenti installati…",
+  "agents.installed": "installato",
+  "agents.notInstalled": "non installato",
+  "agents.disableToggleTitle":
+    "Nascondi questo agente dai menu di scelta scheda (elenco agenti all'aggiunta scheda, driver Modello Locale) senza disinstallarlo",
+  "agents.disableAriaEnable": "Abilita {label} nei menu delle schede",
+  "agents.disableAriaDisable": "Disabilita {label} nei menu delle schede",
+  "agents.disabled": "Disabilitato",
+  "agents.enabled": "Abilitato",
+  "agents.removeTitle": "Rimuovi la CLI installata",
+  "agents.removing": "Rimozione…",
+  "agents.remove": "Rimuovi",
+  "agents.reinstallTitle": "Rimuovi e riesegui l'installer ufficiale",
+  "agents.reinstalling": "Reinstallazione…",
+  "agents.reinstall": "Reinstalla",
+  "agents.permissionHelpPre": "Se Rimuovi fallisce con un errore di permessi, eseguilo invece in una scheda terminale",
+  "agents.permissionHelpPost": "(aggiungi",
+  "agents.permissionHelpPost2": "se richiesto):",
+  "agents.runInTerminal": "Esegui nel terminale",
+  "agents.installing": "Installazione…",
+  "agents.installLabel": "Installa {label}",
+  "agents.runningInstaller": "Installer in esecuzione…",
+  "agents.orInstallInShellPre": "Oppure installalo in una scheda terminale",
+  "agents.orInstallInShellPost": ":",
+  "agents.noWindowsInstallerPre": "Ancora nessun installer a riga singola per Windows — vedi",
+  "agents.installDocs": "la documentazione di installazione",
+  "agents.noWindowsInstallerPost": ", poi clicca",
+  "agents.stillNotDetected": "Ancora non rilevato — prova un terminale nuovo perché la cartella di installazione sia nel PATH.",
+  "agents.codexHookLabel": "Hook di sessione",
+  "agents.codexHookDisabled": "disabilitato",
+  "agents.codexHookNotTrusted": "non attendibile",
+  "agents.codexHookHelpPre":
+    "Codex non eseguirà l'hook di sessione di Eldrun finché non ti fidi di esso, quindi Eldrun ripiega sul dedurre dai log stessi di Codex quale conversazione appartiene a quale scheda. Funziona, ma può confondere due schede Codex aperte nella stessa cartella. Abilita",
+  "agents.codexHookHelpPost": "nell'elenco",
+  "agents.codexHookHelpPost2": "di Codex per una ripresa esatta:",
+  "agents.openInCodex": "Apri in Codex",
+  "agents.nodeNotDetected": "non rilevato",
+  "agents.nodeHelpPre": "La maggior parte delle CLI degli agenti si installa con",
+  "agents.nodeHelpMid": ", che viene fornito con Node.js. Installalo una volta (nessun diritto da amministratore necessario) in una scheda terminale",
+  "agents.nodeHelpPost": ", poi installa i tuoi agenti qui sotto:",
+  "agents.nodeManualPre": "Preferisci un'installazione manuale? Vedi",
+  "agents.nodeDownloads": "i download di Node.js",
+
+  "ollama.vibeTitle": "Runtime del modello locale (Vibe)",
+  "ollama.vibeChecking": "Verifica di Vibe…",
+  "ollama.vibeInstalled": "Vibe è installato — i modelli locali possono avviarsi come schede agente.",
+  "ollama.vibeMissing1": "I modelli Ollama locali funzionano tramite la CLI",
+  "ollama.vibeMissing2":
+    "di Mistral. Non è ancora installata, quindi una scheda Modello Locale fallisce con «unable to spawn vibe». Installala una volta (nessun diritto da amministratore necessario) e i modelli locali si avvieranno.",
+  "ollama.installVibe": "Installa Vibe",
+  "ollama.installingEllipsis": "Installazione…",
+  "ollama.runningInstaller": "Installer in esecuzione…",
+  "ollama.startingEllipsis": "Avvio…",
+  "ollama.orInstallInShellPre": "Oppure installalo in una scheda",
+  "ollama.orInstallInShellPost": ":",
+  "ollama.runInTerminal": "Esegui nel terminale",
+  "ollama.vibeStillNotDetectedWindows":
+    "Vibe non è ancora rilevato (apri un terminale nuovo perché la posizione di installazione sia nel PATH).",
+  "ollama.vibeStillNotDetectedOther":
+    "Vibe non è ancora rilevato (prova un terminale nuovo perché ~/.local/bin sia nel PATH).",
+  "ollama.installTitle": "Installa Ollama",
+  "ollama.notInstalledHelp":
+    "Ollama esegue modelli open-weight localmente sulla tua macchina. Non è ancora installato. Installalo una volta ed Eldrun elencherà qui i modelli che puoi scaricare.",
+  "ollama.automaticInstall": "Installazione automatica",
+  "ollama.autoInstallHelpWindows":
+    "Installa Ollama con winget (silenzioso, per utente). winget è incluso in Windows 10/11; se manca o l'installazione fallisce, segui i passaggi manuali qui sotto.",
+  "ollama.autoInstallHelpOther":
+    "Esegue lo script di installazione ufficiale. Richiede diritti da amministratore per aggiungere il servizio ollama, quindi funziona senza richiesta solo se il tuo account ha sudo senza password. In caso di fallimento, segui i passaggi manuali qui sotto.",
+  "ollama.installBtn": "Installa Ollama",
+  "ollama.installInTerminalTitle": "Installa in un terminale",
+  "ollama.runInstallerNewPre": "Esegui l'installer per il tuo sistema in una nuova scheda",
+  "ollama.runInstallerNewPost": ":",
+  "ollama.alsoDownloadFrom": "Puoi anche scaricare l'installer direttamente da",
+  "ollama.approveUacPrompt": "Approva il prompt di Controllo account utente se Windows lo chiede.",
+  "ollama.enterPasswordSudo": "Inserisci la password se l'installer chiede sudo.",
+  "ollama.onceFinishedClickPre": "Una volta terminato, clicca",
+  "ollama.onceFinishedClickPost": "qui sotto — i modelli installabili appariranno automaticamente.",
+  "ollama.stillNotDetected": "Ollama non è ancora rilevato.",
+  "ollama.modelsTitle": "Modelli Ollama",
+  "ollama.checkingEllipsis": "Verifica in corso...",
+  "ollama.serverRunningLabel": "Server in esecuzione · {label}",
+  "ollama.serverNotRunning": "Server non in esecuzione",
+  "ollama.noModelLoaded": "Nessun modello caricato",
+  "ollama.noLoadedModel": "Nessun modello caricato",
+  "ollama.loadedModels": "Caricato: {names}",
+  "ollama.start": "Avvia",
+  "ollama.refresh": "Aggiorna",
+  "ollama.downloadingTitle": "Download in corso",
+  "ollama.pauseTitle": "Metti in pausa questo download (riprendi più tardi)",
+  "ollama.pause": "Pausa",
+  "ollama.downloadPaused": "Download in pausa — riprendi per completarlo, oppure elimina i dati parziali.",
+  "ollama.resume": "Riprendi",
+  "ollama.deletePartialTitle": "Elimina il download parziale per liberare spazio su disco",
+  "ollama.delete": "Elimina",
+  "ollama.downloadInterrupted": "Il download è stato interrotto — riprendilo per completarlo.",
+  "ollama.continueDownload": "Continua il download",
+  "ollama.dismissTitle": "Dimentica questo download interrotto",
+  "ollama.dismiss": "Ignora",
+  "ollama.orphansSummaryOne":
+    "{count} livello parziale orfano ({size}) — download interrotti senza un nome di modello recuperabile. Riscarica il modello per riprendere, oppure elimina per liberare spazio.",
+  "ollama.orphansSummaryMany":
+    "{count} livelli parziali orfani ({size}) — download interrotti senza un nome di modello recuperabile. Riscarica il modello per riprendere, oppure elimina per liberare spazio.",
+  "ollama.orphanLayer": "livello {digest}…",
+  "ollama.deleteLayerTitle": "Elimina questo livello parziale per liberare spazio su disco",
+  "ollama.downloadedModelsTitle": "Modelli scaricati",
+  "ollama.noModelsDownloaded": "Nessun modello scaricato",
+  "ollama.unloadTitle": "Scarica dalla memoria",
+  "ollama.unload": "Scarica",
+  "ollama.loadTitle": "Carica in memoria ora e mantienilo residente",
+  "ollama.load": "Carica",
+  "ollama.loading": "Caricamento…",
+  "ollama.updateTitle": "Controlla gli aggiornamenti e scarica l'ultima versione",
+  "ollama.update": "Aggiorna",
+  "ollama.updating": "Aggiornamento…",
+  "ollama.deleteModelTitle": "Elimina questo modello",
+  "ollama.loadingIntoMemoryTitle": "Caricamento in memoria…",
+  "ollama.loadingIntoMemory": "Caricamento in memoria…",
+  "ollama.browseRegistry": "Sfoglia il registro Ollama",
+  "ollama.pullHelp1": "Scarica qualsiasi modello dal registro Ollama. Digita un riferimento esatto per scaricare direttamente, oppure cerca e filtra l'elenco completo qui sotto. Usa un riferimento completo come",
+  "ollama.pullHelp2": "o",
+  "ollama.pullPlaceholder": "nome modello o namespace/model:tag",
+  "ollama.pull": "Scarica",
+  "ollama.pulling": "Download…",
+  "ollama.searchPlaceholder": "Cerca tutti i modelli per nome o descrizione…",
+  "ollama.sortBy": "Ordina per",
+  "ollama.sort.popular": "Più popolari",
+  "ollama.sort.newest": "Più recenti",
+  "ollama.sort.pulls": "Più download",
+  "ollama.sort.name": "Nome (A–Z)",
+  "ollama.sort.sizeAsc": "Dimensione: piccolo → grande",
+  "ollama.sort.sizeDesc": "Dimensione: grande → piccolo",
+  "ollama.filterType": "Tipo",
+  "ollama.filterParams": "Parametri",
+  "ollama.any": "Qualsiasi",
+  "ollama.cap.tools": "strumenti",
+  "ollama.cap.vision": "visione",
+  "ollama.cap.thinking": "ragionamento",
+  "ollama.cap.embedding": "embedding",
+  "ollama.cap.audio": "audio",
+  "ollama.pullsSuffix": "{pulls} download",
+  "ollama.tagUpdateTitle": "Aggiorna {name}{size}",
+  "ollama.tagDownloadTitle": "Scarica {name}{size}",
+  "ollama.sizeLoadingSuffix": " — dimensione…",
+  "ollama.pullLower": "scarica",
+  "ollama.noModelsFound": "Nessun modello trovato",
+  "ollama.noMatchSizeFilter":
+    "Nessun modello caricato corrisponde alla dimensione selezionata — carica altri o cancella il filtro Parametri",
+  "ollama.endOfResults": "Fine dei risultati",
+  "ollama.pausedBadge": "in pausa",
+  "ollama.interruptedBadge": "interrotto",
+  "globalAppMenu.title": "App globali",
+  "howToStart.title": "Benvenuto in Eldrun",
+  "howToStart.intro": "Eldrun mantiene il tuo sviluppo assistito dall'IA in un'unica finestra. Ecco come iniziare:",
+  "howToStart.openFeatureGuide": "Apri guida alle funzioni...",
+  "howToStart.takeTour": "Fai un tour",
+  "howToStart.lessons": "Lezioni",
+  "howToStart.gotIt": "Capito",
+  "remoteFeatures.title": "Usi VPN o macchine remote?",
+  "remoteFeatures.help": "Eldrun può controllare un tunnel OpenVPN e connettersi a macchine SSH su cui non hai un progetto, entrambi dall'intestazione. Entrambi sono disattivati per impostazione predefinita — attiva quello che userai. Ciascuno può essere commutato in qualsiasi momento dalle Impostazioni.",
+  "remoteFeatures.continue": "Continua",
+  "lessons.title": "Lezioni",
+  "lessons.intro": "Brevi percorsi guidati per le attività comuni. Scegline uno — ti mostrerà tutto passo dopo passo.",
+  "globalApp.role.browser": "Browser",
+  "globalApp.role.mail": "Posta",
+  "globalApp.role.calendar": "Calendario",
+  "globalApp.role.print_manager": "Gestione stampa",
+  "globalApp.role.file_manager": "Gestione file",
+  "globalApp.role.password_manager": "Gestione password",
+  "globalApp.role.video_conf": "Videoconf.",
+  "globalApp.role.media_player": "Lettore multimediale",
+  "globalApp.role.system_monitor": "Monitoraggio sistema",
+  "globalApp.role.notes": "Note",
+  "globalApp.role.screenshot": "Screenshot",
+  "globalApp.role.screen_recorder": "Registratore schermo",
+  "globalApp.role.chat": "Chat",
+  "globalApp.rightClickConfigure": "Clic destro per configurare",
+  "globalApp.noCommandConfigured": "Nessun comando configurato",
+  "globalApp.clear": "Cancella",
+  "globalApp.set": "Imposta",
+  "header.dragToMove": "Trascina per spostare la finestra di Eldrun",
+  "header.rootTerminal": "Terminale root",
+  "rightPanel.resizeTitle": "Trascina per ridimensionare il pannello",
+  "rightPanel.moveRight": "Sposta il pannello sul bordo destro",
+  "rightPanel.moveLeft": "Sposta il pannello sul bordo sinistro",
+  "rightPanel.unpinTitle": "Sblocca pannello (consenti auto-nascondimento)",
+  "rightPanel.pinTitle": "Blocca il pannello aperto",
+  "rightPanel.showHidden": "Mostra sottofinestre nascoste",
+  "rightPanel.collapse": "Comprimi",
+  "rightPanel.hiddenCount": "Nascoste ({count})",
+  "rightPanel.hiddenWaiting": "Una sottofinestra nascosta è in attesa di te",
+  "rightPanel.hiddenWorking": "Una sottofinestra nascosta sta lavorando",
+  "rightPanel.hiddenFinished": "Una sottofinestra nascosta ha finito, non vista",
+  "rightPanel.restoreFocusedOn": "Ripristina con focus su «{label}»",
+  "rightPanel.restoreSubwindow": "Ripristina sottofinestra",
+  "rightPanel.closeSubwindow": "Chiudi sottofinestra (scarta le sue schede)",
+  "vpnPrompt.titleConnected": "VPN connesso",
+  "vpnPrompt.titlePassword": "Password VPN",
+  "vpnPrompt.close": "Chiudi",
+  "vpnPrompt.closeTitleConnected": "Chiudi — il tunnel resta attivo.",
+  "vpnPrompt.closeTitleConnecting": "Interrompi l'attivazione del tunnel e chiudi — un tunnel a metà aperto viene smontato.",
+  "vpnPrompt.closeTitleDefault": "Chiudi senza connettersi.",
+  "vpnPrompt.upFor": "OpenVPN è attivo per",
+  "vpnPrompt.connectingFor": "Connessione OpenVPN per",
+  "vpnPrompt.trafficScope": "Finché il tunnel è attivo, il traffico di questo computer passa attraverso di esso — anche il tuo browser, non solo Eldrun.",
+  "vpnPrompt.username": "Nome utente",
+  "vpnPrompt.usernamePlaceholder": "Nome utente dell'account OpenVPN…",
+  "vpnPrompt.password": "Password",
+  "vpnPrompt.passphrase": "Passphrase",
+  "vpnPrompt.savedInKeychain": "(salvata nel portachiavi di sistema)",
+  "vpnPrompt.notStored": "(non memorizzata)",
+  "vpnPrompt.keyPassphraseLabel": "Passphrase della chiave privata",
+  "vpnPrompt.keyPassphrasePlaceholder": "Passphrase per la chiave cifrata della configurazione…",
+  "vpnPrompt.keyPassphraseHint": "La chiave privata di questa configurazione è cifrata, quindi OpenVPN chiede la sua passphrase separatamente dalla password dell'account.",
+  "vpnPrompt.saveVpnCredentials": "Salva le credenziali VPN",
+  "vpnPrompt.savePassphrase": "Salva passphrase",
+  "vpnPrompt.storedSecurely": "memorizzata in modo sicuro nel portachiavi del tuo sistema",
+  "vpnPrompt.tunnelUp": "Tunnel attivo — il traffico di questo computer ora passa attraverso di esso.",
+  "vpnPrompt.challengeHintPre": "Se questa configurazione chiede qualcosa a cui questi campi non possono rispondere — un codice di verifica, o una propria richiesta — usa",
+  "vpnPrompt.logInTerminal": "Accedi nel terminale",
+  "vpnPrompt.challengeHintPost": "qui sotto: OpenVPN chiede lì direttamente, ed Eldrun non vede mai ciò che digiti.",
+  "vpnPrompt.closeStaysUpTitle": "Chiudi — il tunnel resta attivo. Disattivalo dall'indicatore VPN nell'intestazione.",
+  "vpnPrompt.terminalBtnStopFirst": "Interrompi prima il tentativo in corso, poi accedi nel terminale.",
+  "vpnPrompt.terminalBtnHandoff": "Passa questa connessione a una scheda terminale root e accedi lì — OpenVPN chiede da solo la password (ed eventuali codici di verifica), ed Eldrun non la vede mai. Solo per questa connessione; la tua impostazione headless resta invariata.",
+  "vpnPrompt.cancelTitleConnecting": "Interrompi l'attivazione del tunnel e chiudi questo — un tunnel a metà aperto viene smontato.",
+  "vpnPrompt.stop": "Interrompi",
+  "vpnPrompt.connectTitleConnecting": "Attivazione del tunnel OpenVPN — pkexec potrebbe chiedere l'elevazione dei privilegi…",
+  "vpnPrompt.connectTitleError": "Connessione non riuscita — controlla la passphrase e riprova.",
+  "vpnPrompt.connectTitleDefault": "Attiva il tunnel OpenVPN.",
+  "vpnPrompt.connecting": "Connessione…",
+  "vpnPrompt.retry": "Riprova",
+  "vpnPrompt.connect": "Connetti",
+  "projectSwitcher.howToStartMenu": "Come iniziare",
+  "projectSwitcher.scrollLeft": "Scorri i progetti a sinistra",
+  "projectSwitcher.scrollRight": "Scorri i progetti a destra",
+  "projectSwitcher.addOrImport": "Aggiungi o importa progetto",
+  "projectSwitcher.newProject": "Nuovo progetto",
+  "projectSwitcher.importProject": "Importa progetto",
+  "projectSwitcher.importFromGitHub": "Importa da GitHub/GitLab",
+  "projectSwitcher.hpcPipeline": "Pipeline HPC…",
+  "projectSwitcher.newBox": "Nuova box",
+  "localModel.role.autocomplete": "Completamento automatico",
+  "localModel.role.grammar": "Grammatica",
+  "localModel.role.tabs": "Schede",
+  "localModel.installTitle": "Installa un modello locale",
+  "localModel.runningLoaded": "Ollama in esecuzione · modello caricato",
+  "localModel.running": "Ollama in esecuzione",
+  "localModel.stopped": "Ollama fermato",
+  "localModel.modelSuffix": " · modello: {name}",
+  "localModel.noModelSelected": " · nessun modello selezionato",
+  "localModel.ariaLabel": "Modello locale",
+  "localModel.agentsGroup": "Agenti",
+  "localModel.agentInstalled": "{label} installato",
+  "localModel.manageAgents": "Gestisci agenti…",
+  "localModel.localModelsGroup": "Modelli locali",
+  "localModel.downloadingTitle": "Download in corso",
+  "localModel.pausedTitle": "In pausa",
+  "localModel.pauseDownloadTitle": "Metti in pausa il download",
+  "localModel.resumeDownloadTitle": "Riprendi il download",
+  "localModel.deletePartialDownloadTitle": "Elimina il download parziale",
+  "localModel.gpuUsedTotal": "GPU {used} / {total}",
+  "localModel.gpuFree": "{free} libero",
+  "localModel.notInstalled": "Ollama non installato",
+  "localModel.noModelsInstalled": "Nessun modello installato",
+  "localModel.serverStopped": "Server fermato",
+  "localModel.defaultLoadedTitle": "Modello locale predefinito · caricato in memoria",
+  "localModel.loadedClickDefaultTitle": "Caricato in memoria — clicca per renderlo predefinito",
+  "localModel.defaultTag": "predefinito",
+  "localModel.usedForRole": "Usato per {role} — clicca per rimuovere l'assegnazione",
+  "localModel.useForRole": "Usa {name} per {role}",
+  "localModel.unloadFromMemoryTitle": "Scarica {name} dalla memoria",
+  "localModel.unloading": "Scaricamento…",
+  "localModel.loadIntoMemoryGroup": "Carica in memoria",
+  "localModel.failedRetryTitle": "Caricamento non riuscito — clicca per riprovare",
+  "localModel.loadIntoMemoryTitle": "Carica in memoria",
+  "localModel.failed": "Fallito",
+  "localModel.manageLocalModels": "Gestisci modelli locali…",
+  "localModel.installOllamaEllipsis": "Installa Ollama…",
+  "localModel.notRunning": "Ollama non è in esecuzione",
+  "localModel.failedToLoadModel": "Impossibile caricare il modello",
+  "localModel.failedToUnloadModel": "Impossibile scaricare il modello",
+  "localModel.failedToLoadModels": "Impossibile caricare i modelli",
+  "appShell.vpnStillActiveTitle": "Tunnel VPN ancora attivo",
+  "appShell.vpnStillActiveMessage": "Il tunnel OpenVPN è ancora attivo e instrada l'intera macchina. Continuerà a funzionare dopo la chiusura di Eldrun — usa il controllo VPN nell'intestazione per chiuderlo tu stesso quando hai finito.",
+  "appShell.showFilesPanel": "Mostra pannello file",
+  "detached.loadingSubwindow": "Caricamento sottofinestra…",
+  "centerPanel.noTabsOpen": "Nessuna scheda aperta",
+  "centerPanel.noTabsHintPre": "Usa",
+  "centerPanel.noTabsHintPost": "nella barra delle schede sopra per aprire una shell o un agente IA.",
+  "detachedTabs.scrollLeft": "Scorri le schede a sinistra",
+  "detachedTabs.scrollRight": "Scorri le schede a destra",
+  "detachedTabs.dragToMove": "Trascina per spostare questa finestra",
+  "detachedTabs.closeTab": "Chiudi scheda",
+  "detachedTabs.newTab": "Nuova scheda",
+  "detachedTabs.hideWindow": "Nascondi questa finestra nel pannello destro (recuperala da lì)",
+  "tour.skip": "Salta il tour",
+  "tour.back": "Indietro",
+  "tour.done": "Fatto",
+  "tour.next": "Avanti",
+  "hint.dismissAria": "Ignora suggerimento",
+  "hint.dontShowHints": "Non mostrare i suggerimenti",
+  "hint.notNow": "Non ora",
+  "untested.title": "Questa funzionalità è implementata ma non ancora testata dal vivo",
+  "untested.label": "non testato",
+  "vpnNotice.ariaLabel": "Tunnel OpenVPN",
+  "vpnNotice.alreadyUp": "Il tunnel OpenVPN è già attivo",
+  "vpnNotice.desc": "Questo computer instrada già attraverso un tunnel, quindi questo progetto non ne necessita un secondo. Gestisci i tunnel dal controllo VPN nell'intestazione.",
+  "connLog.ariaLabel": "Registro di connessione OpenVPN",
+  "connLog.startingVpn": "Avvio di OpenVPN…",
+  "folderPicker.upOneFolder": "Sali di una cartella",
+  "folderPicker.up": "Su",
+  "folderPicker.noSubfolders": "Nessuna sottocartella qui.",
+  "folderPicker.folderPrefix": "Cartella:",
+  "blob.noProjectsYet": "Ancora nessun progetto — creane uno per popolare la nuvola.",
+  "blob.backToProjects": "Torna ai progetti",
+  "blob.sphereView": "Sfera",
+  "blob.sphereViewTitle": "Sfera 3D dei progetti",
+  "blob.pieView": "Torta",
+  "blob.pieViewTitle": "Grafico a torta del tempo tracciato",
+  "blob.hintFocused": "Clicca una cartella per entrare · clicca un file per aprirlo · centro o Esc per tornare indietro",
+  "blob.hintPie": "Dimensione della fetta = tempo tracciato · clicca per aprire un progetto · clic destro per il menu",
+  "blob.hintCloud": "Trascina per orbitare · scorri per zoomare · clicca per esplorare i file · doppio clic per aprire · clic destro per il menu",
+  "blob.noProjectsToChart": "Ancora nessun progetto da rappresentare.",
+  "blob.projectCountOne": "{count} progetto",
+  "blob.projectCountMany": "{count} progetti",
+  "blob.projectRoot": "radice del progetto",
+  "blob.noDescriptionYet": "Ancora nessuna descrizione.",
+  "blob.hintCenterUp": "Clicca per risalire · doppio clic per aprire · Esc per uscire",
+  "blob.hintExploreOpen": "Clicca per esplorare i file · doppio clic per aprire",
+  "blob.boxMetaOne": "Box · {count} progetto",
+  "blob.boxMetaMany": "Box · {count} progetti",
+  "blob.doubleClickToOpen": "Doppio clic per aprire",
+  "blob.folder": "Cartella",
+  "blob.extFile": "file {ext}",
+  "blob.file": "File",
+  "blob.clickToEnterFolder": "Clicca per entrare nella cartella",
+  "blob.clickToOpen": "Clicca per aprire",
+  "blob.open": "Apri",
+  "blob.categoriesEllipsis": "Categorie…",
+  "blob.activate": "Attiva",
+  "blob.inactivate": "Disattiva",
+  "blob.loadingLower": "caricamento…",
+  "pageStrip.ariaLabel": "Pagine",
+  "pageStrip.turnClockwiseTitle": "Ruota questa pagina di 90° in senso orario",
+  "pageStrip.turnClockwiseAria": "Ruota la pagina in senso orario",
+  "pageStrip.removePageTitle": "Rimuovi questa pagina",
+  "pageStrip.removePageAria": "Rimuovi pagina",
+  "pageStrip.turnRight": "Ruota a destra",
+  "pageStrip.turnLeft": "Ruota a sinistra",
+  "pageStrip.duplicate": "Duplica",
+  "pageStrip.deleteOne": "Elimina pagina",
+  "pageStrip.deleteMany": "Elimina {count} pagine",
+  "usage.toneGreen": "verde",
+  "usage.toneOrange": "arancione",
+  "usage.toneRed": "rosso",
+  "usage.utilizationAria": "utilizzo {tone}",
+  "usage.cpu": "CPU",
+  "usage.coresOne": "({count} core)",
+  "usage.coresMany": "({count} core)",
+  "usage.loadAverage": "Carico medio",
+  "usage.memory": "Memoria",
+  "usage.loggedIn": "Accessi",
+  "usage.sessionsOne": "({count} sessione)",
+  "usage.sessionsMany": "({count} sessioni)",
+  "usage.userCol": "Utente",
+  "usage.sessionsCol": "Sessioni",
+  "usage.memCol": "Mem",
+  "usage.noInteractiveLogins": "Nessun accesso interattivo su questo host.",
+  "usage.topProcesses": "Processi principali",
+  "usage.cpuSuffix": "cpu",
+  "usage.memSuffix": "mem",
+  "usage.title": "Utilizzo attuale dell'host remoto",
+  "usage.noMachines": "Nessuna macchina da controllare — aggiungine una nel menu Macchine, o apri un progetto remoto.",
+  "usage.lede": "Carico, memoria e sessioni connesse su {hosts}, {reading} — ecco cosa sta girando in questo momento.",
+  "usage.hostSingular": "1 host",
+  "usage.hostsPlural": "{count} host",
+  "usage.beingReadNow": "in lettura ora",
+  "usage.asLastRead": "come letto l'ultima volta",
+  "usage.checkingEllipsis": "Verifica in corso…",
+  "usage.noReading": "Nessuna lettura — l'host potrebbe non essere raggiungibile.",
+  "usage.rechecking": "Nuovo controllo…",
+  "usage.recheck": "Ricontrolla",
+  "hostKey.title": "È questa la macchina giusta?",
+  "hostKey.ledePre": "Eldrun non si è mai connesso a",
+  "hostKey.ledePost": "in precedenza, ed è sul punto di inviare lì una password. Controlla l'impronta qui sotto con quella mostrata dall'amministratore dell'host (o un'altra macchina di cui ti fidi già) — se non corrisponde, qualcos'altro sta rispondendo per questo indirizzo.",
+  "hostKey.readingKey": "Lettura della chiave dell'host…",
+  "hostKey.errorHeading": "Non è stato possibile leggere la chiave dell'host, quindi non c'è nulla da verificare. Non è stato inviato nulla.",
+  "hostKey.acceptNotePre": "Accettando si memorizza questa chiave in",
+  "hostKey.acceptNotePost": ". Non ti verrà più richiesto — e se la chiave dovesse mai cambiare, la connessione viene rifiutata direttamente.",
+  "hostKey.accepting": "Accettazione…",
+  "hostKey.acceptAndConnect": "Accetta e connetti",
+  "localLoss.kindDeleted": "eliminato localmente",
+  "localLoss.kindOverwritten": "sovrascritto localmente",
+  "localLoss.sourceGit": "Git in sincronia",
+  "localLoss.sourceSync": "Sincronizzazione file",
+  "localLoss.entryCountOne": "{count} file {kind}",
+  "localLoss.entryCountMany": "{count} file {kind}",
+  "localLoss.moreCount": "…e altri {count}",
+  "localLoss.unrecoverable": "Questo contenuto è sempre esistito solo su questa macchina — non può essere recuperato.",
+  "localLoss.title": "File modificati nella tua copia locale",
+  "localLoss.ledePre": "La sincronizzazione di questo progetto con l'host ha distrutto qualcosa nella tua copia locale —",
+  "localLoss.ledeMid": "in",
+  "localLoss.ledePost": ". Questo è ciò che git e la sincronizzazione dovrebbero fare quando i due lati si muovono; è elencato qui perché è successo alla tua macchina, ed è successo senza chiedere.",
+  "localLoss.filesCountOne": "{count} file",
+  "localLoss.filesCountMany": "{count} file",
+  "localLoss.opsCountOne": "{count} operazione",
+  "localLoss.opsCountMany": "{count} operazioni",
+  "common.rename": "Rinomina",
+  "common.connect": "Connetti",
+  "common.next": "Avanti",
+  "projectSearch.placeholder": "Cerca inattivi...",
+  "projectSearch.noProjects": "Nessun progetto",
+  "projectSearch.boxMemberOne": "Box · {count} membro",
+  "projectSearch.boxMemberMany": "Box · {count} membri",
+  "categoryEditor.titleSuffix": "Categorie",
+  "categoryEditor.desc": "Etichetta questo progetto per colorarlo e raggrupparlo nella nuvola dei progetti e nella barra delle pillole. Un progetto può avere più categorie; la prima è il suo colore principale.",
+  "categoryEditor.removeCategory": "Rimuovi questa categoria",
+  "categoryEditor.addCategory": "Aggiungi questa categoria",
+  "categoryEditor.addLabel": "Aggiungi una categoria",
+  "categoryEditor.placeholder": "es. lavoro, ricerca, cliente-x…",
+  "categoryEditor.saving": "Salvataggio…",
+  "categoryEditor.save": "Salva",
+  "boxPill.clickToOpenTitle": "{name} (box) — clicca per aprire",
+  "boxPill.memberCountOne": "{count} membro",
+  "boxPill.memberCountMany": "{count} membri",
+  "boxPill.noMembers": "Nessun membro",
+  "boxPill.switchToTitle": "Passa a {name}",
+  "boxPill.removeFromBox": "Rimuovi dalla box",
+  "boxPill.openBox": "Apri box",
+  "boxPill.deleteBox": "Elimina box",
+  "activityCal.noActivity": "Nessuna attività",
+  "activityCal.less": "Meno",
+  "activityCal.more": "Più",
+  "activityCal.dayMon": "Lun",
+  "activityCal.dayWed": "Mer",
+  "activityCal.dayFri": "Ven",
+  "remotePane.notConnected": "Non connesso",
+  "remotePane.hintPre": "Questa scheda gira su",
+  "remotePane.theRemoteHost": "l'host remoto",
+  "remotePane.hintPost": "Connettiti per avviarla — le tue schede locali continuano a funzionare sul mirror nel frattempo.",
+  "extendRemote.title": "Estendi «{name}» al remoto",
+  "extendRemote.attachPre": "Collega",
+  "extendRemote.attachMid": "a questo progetto come suo host remoto principale. La cartella remota vuota viene creata sull'host; i tuoi file locali esistenti diventano la copia di lavoro sincronizzata e restano al loro posto. Nulla viene caricato finché non lo fai manualmente.",
+  "extendRemote.attachGeneric": "Collega un host SSH remoto a questo progetto. La cartella remota vuota viene creata sull'host; i tuoi file locali esistenti diventano la copia di lavoro sincronizzata e restano al loro posto. Nulla viene caricato finché non lo fai manualmente.",
+  "extendRemote.summaryLede": "Crea la cartella remota e la abbina ai file locali esistenti di questo progetto:",
+  "extendRemote.local": "Locale",
+  "extendRemote.remote": "Remoto",
+  "extendRemote.readyTitle": "Collega l'host remoto a questo progetto",
+  "extendRemote.notReadyTitle": "Prima connettiti e scegli una cartella remota",
+  "extendRemote.connectFirstError": "Prima connettiti e scegli una cartella remota.",
+  "extendRemote.extending": "Estensione…",
+  "extendRemote.extendToRemote": "Estendi al remoto",
+  "pythonInterp.titleSuffix": "Interprete Python",
+  "pythonInterp.desc": "Usato dai pulsanti Esegui e Debug del visualizzatore di codice. Il rilevamento automatico è corretto per quasi tutti i progetti — blocca un interprete solo quando il tuo ambiente si trova dove Eldrun non può dedurlo.",
+  "pythonInterp.remoteSuffix": "Verificato sull'host, poiché è lì che gira questo progetto.",
+  "pythonInterp.looking": "Ricerca di interpreti…",
+  "pythonInterp.interpreterLabel": "Interprete",
+  "pythonInterp.autoDetectWith": "Rilevamento automatico — {path}",
+  "pythonInterp.autoDetect": "Rilevamento automatico",
+  "pythonInterp.customPath": "Percorso personalizzato…",
+  "pythonInterp.pathLabel": "Percorso dell'interprete",
+  "pythonInterp.pathPlaceholder": "es. /opt/envs/ml/bin/python — i percorsi relativi vengono risolti dalla radice del progetto",
+  "pythonInterp.probeErrorPre": "Impossibile sondare gli interpreti (",
+  "pythonInterp.probeErrorPost": "). Puoi comunque impostarne uno manualmente.",
+  "pythonInterp.saving": "Salvataggio…",
+  "pythonInterp.save": "Salva",
+  "remoteBrowser.ariaLabel": "Browser cartelle remote",
+  "remoteBrowser.goUp": "Sali",
+  "remoteBrowser.recentlyUsed": "Usato di recente…",
+  "remoteBrowser.jumpTitle": "Vai a un percorso remoto usato in precedenza per questo host",
+  "remoteBrowser.useThisFolder": "Usa questa cartella",
+  "remoteBrowser.newFolderPlaceholder": "Nome nuova cartella…",
+  "remoteBrowser.addFolderTitle": "Crea una nuova cartella qui",
+  "remoteBrowser.addFolder": "+ Aggiungi cartella",
+  "remoteBrowser.listing": "Elenco in corso...",
+  "remoteBrowser.emptyFolder": "Cartella vuota.",
+  "bigFolder.titlePre": "Cartelle grandi in",
+  "bigFolder.thisProject": "questo progetto",
+  "bigFolder.introPre": "Queste cartelle sono abbastanza grandi da dominare ogni trasferimento se sincronizzate. La sincronizzazione copia byte e",
+  "bigFolder.doesNotReadGitignore": "non legge .gitignore",
+  "bigFolder.introPost": ", quindi i dati mantenuti intenzionalmente sull'host — output di esperimenti, checkpoint, cache, virtualenv — attraversano come qualsiasi altro file a meno che non vengano esclusi qui.",
+  "bigFolder.measuring": "Misurazione di entrambi i lati…",
+  "bigFolder.nothingOversizedFull": "Non è stato trovato nulla di sovradimensionato. Procedi pure con la sincronizzazione.",
+  "bigFolder.nothingOversizedLocalOnly": "Non è stato trovato nulla di sovradimensionato sul lato locale. Procedi pure con la sincronizzazione.",
+  "bigFolder.colFolder": "Cartella",
+  "bigFolder.colThisMachine": "Questa macchina",
+  "bigFolder.colHost": "Host",
+  "bigFolder.notePre": "Spuntato =",
+  "bigFolder.excludedFromSync": "escluso dalla sincronizzazione",
+  "bigFolder.notePost": ". In entrambi i casi non viene eliminato nulla, e qualsiasi cartella può essere reinclusa in seguito dal suo menu contestuale nell'albero dei file. I file tracciati da Git viaggiano comunque con i tuoi commit — l'esclusione si applica alla sincronizzazione dei byte.",
+  "bigFolder.hostNotMeasuredPre": "L'host non è stato misurato",
+  "bigFolder.hostNotConnected": "il progetto non è connesso",
+  "bigFolder.hostNotMeasuredPost": ". Sono elencate solo le cartelle di questa macchina; riapri questo dalla vista file una volta connesso per vedere quelle dell'host.",
+  "bigFolder.hostSkippedCareful": "L'host non è stato misurato: questa macchina è contrassegnata come prudente, quindi la scansione ricorsiva dell'intero albero non viene eseguita da sola.",
+  "bigFolder.measureHost": "Misura comunque l'host",
+  "bigFolder.measuringHost": "Misurazione dell'host…",
+  "bigFolder.notNow": "Non ora",
+  "bigFolder.close": "Chiudi",
+  "bigFolder.apply": "Applica",
+  "common.saving": "Salvataggio…",
+  "common.save": "Salva",
+  "common.close": "Chiudi",
+  "pill.gitClean": "Nessuna modifica in sospeso",
+  "pill.gitDirty": "Modifiche non commesse — non ancora aggiunte",
+  "pill.gitStaged": "Modifiche in staging — non ancora commesse",
+  "pill.gitUnpushed": "Commesso — non ancora pushato",
+  "pill.statusWorking": "{count} in lavorazione",
+  "pill.statusWaiting": "{count} in attesa di te",
+  "pill.statusFinished": "{count} terminato/i",
+  "pill.categoriesLabel": "Categorie: {list}",
+  "pill.closeProject": "Chiudi progetto",
+  "pill.activityTitle": "{name} — Attività",
+  "pill.descTitle": "{name} — Descrizione",
+  "pill.descPlaceholder": "Breve descrizione per questo progetto…",
+  "pill.renameTitle": "Rinomina progetto",
+  "pill.namePlaceholder": "Nome del progetto…",
+  "pill.nameEmpty": "Il nome non può essere vuoto",
+  "pill.publishTitle": "{name} — Pubblica su {provider}",
+  "pill.currentPrefix": "Attuale:",
+  "pill.runsOnWorkRemote": "· gira sull'host remoto di lavoro",
+  "pill.hostingProvider": "Provider di hosting",
+  "pill.repoVisibility": "Visibilità del repository",
+  "pill.visPrivate": "privato",
+  "pill.visPublic": "pubblico",
+  "pill.publishRunsPre": "Esegue",
+  "pill.publishRunsMid": "Richiede",
+  "pill.publishRunsPost": "installato e autenticato (o un token in ⚙ Impostazioni → Hosting Git).",
+  "pill.publishCliMissingPre": "Nessun",
+  "pill.publishCliMissingMid": "trovato su questa macchina — la pubblicazione crea il repository tramite la CLI del provider, quindi installala (e accedi con",
+  "pill.publishCliMissingPost": ") prima di pubblicare.",
+  "pill.publishFrom": "Pubblica da",
+  "pill.publishFromLocal": "Questo computer (mirror locale)",
+  "pill.publishFromRemote": "Host remoto di lavoro",
+  "pill.publishFromLocalHint": "Il repository viene creato e inviato dal mirror locale di questo progetto, con l'accesso {cli} di questa macchina. Git lockstep deve indicare che il mirror è allineato con l'host.",
+  "pill.publishRemoteCliHint": "La pubblicazione viene eseguita sull'host remoto di lavoro — {cli} deve essere installato e autenticato lì, non su questa macchina, e il progetto deve essere connesso.",
+  "pill.publishSignInHint": "Non connesso tramite un token salvato — la pubblicazione userà l'accesso proprio di {cli}.",
+  "pill.publishSignInBtn": "Accedi con {cli}",
+  "pill.publishSignInTitle": "Esegui {cmd} in una nuova scheda del terminale",
+  "pill.getTokenCta": "Crea un token di accesso {provider}…",
+  "pill.getTokenHint": "Richiede lo scope \"repo\" su GitHub, o \"api\" (lettura/scrittura repository) su GitLab.",
+  "pill.published": "Pubblicato.",
+  "pill.publishing": "Pubblicazione…",
+  "pill.publish": "Pubblica",
+  "pill.gitHostingTitle": "{name} — Hosting Git",
+  "pill.gitHostingDesc": "Sovrascrive l'hosting Git globale solo per questo progetto. Lascia i campi vuoti per ereditare le impostazioni globali.",
+  "pill.inheritsGlobal": "Eredita globale: {url}",
+  "pill.replaceToken": "Sostituisci token di accesso",
+  "pill.enterNewToken": "Inserisci un nuovo token da sostituire…",
+  "pill.tokenStatusWillSet": "Imposterà un token di progetto (sovrascrive quello globale).",
+  "pill.tokenStatusWillRemove": "Rimuoverà il token del progetto; tornerà a quello globale.",
+  "pill.tokenStatusHasToken": "È impostato un token di progetto (nascosto). Lascia vuoto per mantenerlo.",
+  "pill.tokenStatusInherits": "Eredita il token globale.",
+  "pill.tokenStatusNone": "Nessun token impostato — i push usano le credenziali git di sistema.",
+  "pill.removeProjectToken": "Rimuovi il token del progetto (usa quello globale)",
+  "pill.disableGitTitle": "{name} — Rimuovi git e cronologia",
+  "pill.disableGitWarn1": "Questo elimina permanentemente la",
+  "pill.disableGitWarn2": "cartella di questo progetto — ogni commit, branch, stash e remote.",
+  "pill.cannotBeUndone": "Non può essere annullato.",
+  "pill.disableGitWarn3": "Il progetto diventa un progetto «Nessun git (nessun repo)»; i tuoi file di lavoro restano intatti.",
+  "pill.typeNameConfirmPre": "Digita il nome del progetto",
+  "pill.typeNameConfirmPost": "per confermare",
+  "pill.removing": "Rimozione…",
+  "pill.deleteGitHistory": "Elimina cronologia git",
+  "pill.deleteProjectTitle": "Elimina {name}",
+  "pill.archiveDescPre": "Questo disconnette",
+  "pill.archiveDescMid": "e lo sposta nell'archivio di Eldrun. Puoi ripristinarlo — o eliminarlo definitivamente — più tardi da",
+  "pill.archiveSettingsLink": "Impostazioni → Progetti archiviati",
+  "pill.archiveRemoteNotTouchedPre": "I file sull'host remoto",
+  "pill.notWord": "non",
+  "pill.archiveRemoteNotTouchedPost": "vengono toccati.",
+  "pill.deleting": "Eliminazione…",
+  "pill.deleteToArchive": "Elimina nell'archivio",
+  "pill.detachTitle": "{name} — Scollega host SSH",
+  "pill.detachDesc1Pre": "Questo trasforma",
+  "pill.detachDesc1Mid": "di nuovo in un semplice progetto locale: la sua copia di lavoro locale resta esattamente dov'è e ridiventa la directory del progetto. I file sull'host remoto",
+  "pill.detachDesc1Post": "non vengono toccati, e nulla di locale viene eliminato.",
+  "pill.detachDesc2Pre": "Ciò che invece viene eliminato è l'",
+  "pill.pairingWord": "accoppiamento",
+  "pill.detachDesc2Post": ": il lockstep git si ferma, e l'ambito di auto-sincronizzazione scelto per questo host — quali cartelle attraversano, e il registro di ciò che era già in sincronia — viene scartato. Ricollegare lo stesso host in seguito significa scegliere di nuovo quell'ambito da zero.",
+  "pill.detaching": "Scollegamento…",
+  "pill.detachToLocal": "Scollega in locale",
+  "pill.containerSettingsTitle": "{name} — Impostazioni container",
+  "pill.containerAppliedNote": "Applicato al prossimo avvio del container (attivazione del progetto o creazione scheda) — un container in esecuzione le cui impostazioni sono cambiate viene sostituito automaticamente.",
+  "pill.buildFromDockerfile": "Compila da un Dockerfile in questo progetto",
+  "pill.dockerfilePlaceholder": "es. Dockerfile — vuoto: usa l'immagine sotto",
+  "pill.image": "Immagine",
+  "pill.imagePlaceholder": "vuoto: eldrun-agent-sandbox:latest",
+  "pill.network": "Rete",
+  "pill.networkPlaceholder": "vuoto: bridge docker — «none» blocca tutto il traffico in uscita (rompe gli agenti cloud)",
+  "pill.networkNotePre": "Nota: il bridge predefinito raggiunge comunque i servizi collegati a questa macchina (Ollama, server di sviluppo) tramite l'IP del gateway docker. Completamente chiuso significa",
+  "pill.networkNotePost": "o una rete con lista consentiti personalizzata.",
+  "pill.memoryCap": "Limite di memoria",
+  "pill.memoryPlaceholder": "es. 4g — vuoto: illimitato",
+  "pill.cpuCap": "Limite CPU",
+  "pill.cpuPlaceholder": "es. 2 — vuoto: illimitato",
+  "pill.processLimit": "Limite di processi",
+  "pill.processLimitPlaceholder": "vuoto: 1024 (protezione fork-bomb)",
+  "pill.processLimitError": "Il limite di processi deve essere un numero intero positivo.",
+  "pill.readonlyRootfs": "Filesystem root in sola lettura (mantiene /tmp scrivibile)",
+  "pill.unpublishTitle": "{name} — Annulla pubblicazione",
+  "pill.unpublishDesc1": "Questo rimuove il remote",
+  "pill.unpublishDesc2": "e reimposta il progetto su un repository git locale. I tuoi commit restano intatti e il repository su",
+  "pill.unpublishDesc3": "è",
+  "pill.unpublishDesc4": "eliminato — viene rimosso solo il collegamento locale ad esso. Puoi ripubblicare più tardi.",
+  "pill.unpublishing": "Annullamento pubblicazione…",
+  "pill.unpublishKeepRepo": "Annulla pubblicazione (mantieni repo)",
+  "pill.changeVisibilityTitle": "{name} — Cambia visibilità",
+  "pill.flipVisibility1": "Cambia questo repository da",
+  "pill.flipVisibility2": "a",
+  "pill.flipVisibility3": "sul posto tramite",
+  "pill.flipVisibility4": "Il repository, il suo URL e la sua cronologia vengono preservati.",
+  "pill.applying": "Applicazione…",
+  "pill.makeVisibility": "Rendi {target}",
+  "pill.moveToProviderTitle": "{name} — Passa a un altro provider",
+  "pill.newProvider": "Nuovo provider",
+  "pill.migrateDesc1": "Crea il repository su",
+  "pill.migrateDesc2": ", ripunta",
+  "pill.migrateDesc3": ", ed effettua il push. Il repository esistente",
+  "pill.migrateDesc4": "è",
+  "pill.leftIntact": "lasciato intatto",
+  "pill.migrateDesc5": "(mantenuto come",
+  "pill.migrateDesc6": ") — eliminalo tu stesso se non lo vuoi più.",
+  "pill.migrating": "Migrazione…",
+  "pill.moveToProvider": "Passa a {provider}",
+  "pill.viewGroup": "Visualizza",
+  "pill.showActivity": "Mostra attività",
+  "pill.showOnDiskRemoteTitle": "Apri il mirror locale (la copia di lavoro connessa) nel gestore file",
+  "pill.showOnDiskLocalTitle": "Apri la directory del progetto nel gestore file",
+  "pill.showOnDisk": "Mostra sul disco",
+  "pill.editGroup": "Modifica",
+  "pill.renameEllipsis": "Rinomina…",
+  "pill.movePillTitle": "Sposta il mirror locale di questo progetto (la copia di lavoro connessa) in una nuova cartella",
+  "pill.moveProjectEllipsis": "Sposta progetto…",
+  "pill.editDescription": "Modifica descrizione",
+  "pill.categoriesMenuTitle": "Etichetta questo progetto per colorarlo e raggrupparlo nella nuvola e nella barra delle pillole",
+  "pill.repairScaffoldTitle": "Completa qualsiasi file di struttura mancante, pattern .gitignore predefinito o .claude/settings.json — non sovrascrive mai il contenuto esistente",
+  "pill.repairScaffold": "Ripara file di struttura",
+  "pill.extendToRemoteMenuTitle": "Collega un host SSH remoto a questo progetto locale — i file restano al loro posto; caricali manualmente",
+  "pill.extendToRemoteEllipsis": "Estendi al remoto…",
+  "pill.gitGroup": "Git",
+  "pill.gitInitTitle": "Esegui git init per iniziare a versionare questo progetto",
+  "pill.enableGit": "Abilita git (git init)",
+  "pill.makePrivateTitle": "Cambia il repository tra pubblico e privato sul posto (gh/glab repo edit)",
+  "pill.makePrivate": "Rendi privato…",
+  "pill.makePublic": "Rendi pubblico…",
+  "pill.moveProviderMenuTitle": "Pubblica sull'altro provider e ripunta origin; il vecchio repo resta intatto",
+  "pill.moveToGithub": "Passa a GitHub…",
+  "pill.moveToGitlab": "Passa a GitLab…",
+  "pill.unpublishMenuTitle": "Rimuovi il remote origin e torna a un repository locale; il repository ospitato e la cronologia vengono mantenuti",
+  "pill.unpublishKeepRepoEllipsis": "Annulla pubblicazione (mantieni repo)…",
+  "pill.gitHostingMenuTitle": "Sovrascrivi l'hosting Git globale (URL profilo + token) solo per questo progetto",
+  "pill.gitHostingEllipsis": "Hosting Git…",
+  "pill.publishEllipsis": "Pubblica su GitHub / GitLab…",
+  "pill.runtimeGroup": "Runtime",
+  "pill.containerRunTitle": "Esegue ogni scheda terminale e agente di questo progetto all'interno di un container Docker chiuso. La cartella del progetto resta sull'host al suo percorso normale — il container semplicemente non può raggiungere nient'altro.",
+  "pill.runInContainer": "Esegui questo progetto in un container",
+  "pill.containerSettingsMenuTitle": "Immagine, rete, limiti memoria/CPU e rootfs in sola lettura per il container di questo progetto",
+  "pill.containerSettingsEllipsis": "Impostazioni container…",
+  "pill.pythonInterpMenuTitle": "L'ambiente Python in cui gli script di questo progetto vengono eseguiti e debuggati. Rilevato automaticamente per impostazione predefinita (venv nell'albero, poetry, conda, pyenv); blocca un interprete quando il tuo ambiente si trova dove Eldrun non può dedurlo.",
+  "pill.pythonInterpreterEllipsis": "Interprete Python…",
+  "pill.autoConnectTitleNonHeadless": "Connette questo progetto da solo all'avvio e quando vi passi. Eldrun non gestisce password in questa modalità, quindi il login (e la VPN, se presente) si apre nel terminale root per autenticarti — poi il progetto si connette da solo.",
+  "pill.autoConnectTitleEligible": "Connette questo progetto da solo all'avvio e quando vi passi. Non chiede mai nulla: entra direttamente quando l'host è raggiungibile, e attiva la VPN solo quando non lo è.",
+  "pill.autoConnectTitleNotEligible": "Salva prima la password SSH (o usa l'autenticazione a chiave) — la connessione automatica è offerta solo quando la connessione non richiede nulla da te.",
+  "pill.autoConnectOnLaunch": "Connessione automatica all'avvio",
+  "pill.persistSessionsMenuTitle": "Esegue la shell remota e le schede Python/script di questo progetto all'interno di una sessione tmux sull'host, così un'esecuzione lunga continua attraverso una caduta SSH, la sospensione del laptop o la chiusura di Eldrun — la scheda si ricollega alla riconnessione. Chiudere una scheda termina comunque la sua sessione (con conferma). Le schede agente non sono interessate.",
+  "pill.persistentSessionsTmux": "Sessioni persistenti (tmux)",
+  "pill.remoteMachinesMenuTitle": "Aggiungi e gestisci macchine aggiuntive su cui gira questo progetto. Eseguono lo stesso codice (mantenuto in sincronizzazione unidirezionale) come worker di esperimenti in sola lettura; i loro output restano su ciascuna macchina.",
+  "pill.remoteMachinesCount": "Macchine remote… ({count})",
+  "pill.remoteMachinesEllipsis": "Macchine remote…",
+  "pill.closeAllTabs": "Chiudi tutte le schede e finestre",
+  "pill.dangerZone": "Zona di pericolo",
+  "pill.detachSshMenuTitle": "Riconverte questo in un progetto locale. La copia di lavoro locale resta al suo posto e i file dell'host remoto restano intatti — ma l'accoppiamento viene eliminato: il lockstep si ferma, e l'ambito di auto-sincronizzazione impostato per questo host viene scartato.",
+  "pill.detachSshEllipsis": "Scollega host SSH…",
+  "pill.removeGitMenuTitle": "Elimina la directory .git di questo progetto e tutta la cronologia di controllo versione (non può essere annullato)",
+  "pill.removeGitHistoryEllipsis": "Rimuovi git e cronologia…",
+  "pill.deleteProjectMenuTitle": "Disconnetti questo progetto e spostalo nell'archivio di Eldrun. Ripristinalo o eliminalo definitivamente più tardi dalle Impostazioni. I file di un host remoto non vengono mai toccati.",
+  "pill.deleteProjectEllipsis": "Elimina progetto…",
+  "pill.nowVisibility": "Ora {target}.",
+  "pill.migrated": "Migrato.",
+  "remoteConnect.titleWorker": "Connetti worker · {host}",
+  "remoteConnect.titleProject": "Connetti progetto remoto",
+  "remoteConnect.remoteLabel": "Remoto",
+  "remoteConnect.localLabel": "Locale",
+  "remoteConnect.nameLabel": "Nome",
+  "remoteConnect.namePlaceholder": "Nome del progetto",
+  "remoteConnect.nameHintWorker": "Mostrato sulla pillola e in «Macchine remote». Lascia vuoto per usare il nome host.",
+  "remoteConnect.nameHintProject": "Il nome del progetto, mostrato sulla sua pillola e in tutto Eldrun.",
+  "remoteConnect.machineNameLabel": "Nome macchina",
+  "remoteConnect.machineNameHint": "Identifica questa macchina nel Monitor di sistema e nelle spie di connessione quando il progetto ha più di un host. Lascia vuoto per usare il nome host.",
+  "remoteConnect.vpnToggleTitle": "Connetti tramite OpenVPN",
+  "remoteConnect.vpnDescLine1": "Attiva prima un tunnel se questo host è protetto da VPN. Saltalo se sei già sulla rete giusta — SSH si connette direttamente.",
+  "remoteConnect.vpnDescLine2Pre": "Il tunnel è",
+  "remoteConnect.vpnDescLine2Strong": "a livello di macchina",
+  "remoteConnect.vpnDescLine2Post": ": finché è attivo, tutto il traffico di questo computer passa attraverso di esso — anche il tuo browser, non solo Eldrun.",
+  "remoteConnect.configLabel": "Configurazione",
+  "remoteConnect.changeConfig": "Cambia…",
+  "remoteConnect.changeConfigTitle": "Scegli un'altra configurazione OpenVPN per questo progetto.",
+  "remoteConnect.pickConfigHintChange": "Scegli la configurazione OpenVPN da usare al suo posto — la nuova scelta sostituisce quella salvata.",
+  "remoteConnect.pickConfigHintNew": "Scegli la configurazione OpenVPN per questo host — viene salvata nel progetto, quindi la scegli una sola volta.",
+  "remoteConnect.recentConfigsPlaceholder": "Usati di recente…",
+  "remoteConnect.recentConfigsTitle": "Riusa una configurazione OpenVPN già utilizzata",
+  "remoteConnect.chooseConfigBtn": "Scegli configurazione .ovpn…",
+  "remoteConnect.vpnUsernameLabel": "Nome utente VPN",
+  "remoteConnect.vpnPasswordLabel": "Password VPN",
+  "remoteConnect.vpnPassphraseLabel": "Passphrase VPN",
+  "remoteConnect.vpnSavedPlaceholder": "Usa la passphrase salvata — lascia vuoto",
+  "remoteConnect.vpnAccountPasswordPlaceholder": "Password dell'account OpenVPN…",
+  "remoteConnect.vpnPassphrasePlaceholder": "Passphrase OpenVPN…",
+  "remoteConnect.retryVpn": "Riprova VPN",
+  "remoteConnect.connectVpn": "Connetti VPN",
+  "remoteConnect.vpnStopTitleConnected": "Interrompi questo tunnel OpenVPN. La connessione SSH resta invariata.",
+  "remoteConnect.vpnStopTitleConnecting": "Interrompi questo tentativo di connessione VPN e reimposta lo stato del tunnel.",
+  "remoteConnect.disconnectVpn": "Disconnetti VPN",
+  "remoteConnect.vpnTermBtnTitle": "Attiva il tunnel OpenVPN in un terminale qui sotto — inserisci lì la passphrase.",
+  "remoteConnect.vpnTermOpenBelow": "Terminale VPN aperto qui sotto",
+  "remoteConnect.vpnTermOpenBtn": "Apri terminale di accesso VPN",
+  "remoteConnect.vpnTermHint": "Autentica il tunnel qui sotto — resta attivo per questo progetto.",
+  "remoteConnect.disconnect": "Disconnetti",
+  "remoteConnect.sshSectionLabel": "Accedi tramite SSH",
+  "remoteConnect.usernameLabel": "Nome utente",
+  "remoteConnect.usernamePlaceholder": "Nome di accesso SSH — vuoto usa il tuo account locale",
+  "remoteConnect.usernameHint": "L'account su {host}. Modificarlo cambia quale password salvata si applica — sono memorizzate per ogni accesso.",
+  "remoteConnect.sshPasswordLabel": "Password o passphrase della chiave",
+  "remoteConnect.sshSavedPlaceholder": "Usa il segreto salvato — lascia vuoto",
+  "remoteConnect.sshPasswordPlaceholder": "Password SSH, o la passphrase della tua chiave…",
+  "remoteConnect.connectedState": "Connesso",
+  "remoteConnect.sshStopTitle": "Interrompi questo tentativo di connessione SSH e reimposta lo stato della connessione.",
+  "remoteConnect.savePassword": "Salva password",
+  "remoteConnect.saveHintKeptTerminal": "conservata nel portachiavi del tuo sistema operativo — un accesso da terminale non viene visto da Eldrun, quindi non viene salvato nulla di nuovo; disattiva per eliminarla",
+  "remoteConnect.saveHintSaved": "salvata nel portachiavi del tuo sistema operativo — disattiva per eliminarla",
+  "remoteConnect.saveHintNothingTerminal": "nulla da salvare per un accesso da terminale — Eldrun non lo vede mai",
+  "remoteConnect.autoConnectTitleEligible": "Connette questo progetto da solo all'avvio e quando vi passi. Non chiede mai nulla: entra direttamente quando l'host è raggiungibile, e attiva la VPN solo quando non lo è. Nota che attivare la VPN reindirizza tutto il traffico di questo computer — con la connessione automatica ciò avviene senza chiedere conferma, quindi tieni d'occhio l'indicatore VPN nell'intestazione.",
+  "remoteConnect.autoConnectTitleNotEligible": "Salva prima la password SSH (o usa l'autenticazione a chiave) — la connessione automatica viene offerta solo quando connettersi non richiede nulla da parte tua.",
+  "remoteConnect.autoConnectLabel": "Connessione automatica",
+  "remoteConnect.autoConnectHintEligible": "all'avvio e al passaggio — VPN solo se l'host non è raggiungibile direttamente",
+  "remoteConnect.autoConnectHintNotEligible": "richiede una password salvata o l'autenticazione a chiave",
+  "remoteConnect.autoConnectVpnWarningPre": "Attenzione: se l'host non è raggiungibile direttamente, la connessione automatica attiva la VPN",
+  "remoteConnect.autoConnectVpnWarningStrong": "senza chiedere",
+  "remoteConnect.autoConnectVpnWarningPost": "— reindirizzando il traffico di questo computer all'avvio. L'indicatore VPN nell'intestazione mostra quando un tunnel è attivo, e può disattivarlo.",
+  "remoteConnect.autoConnectInteractiveTitle": "Connette questo progetto da solo all'avvio e quando vi passi. In questa modalità Eldrun non gestisce alcuna password, quindi l'accesso (e la VPN, se questo progetto ne ha una) si apre nel terminale root perché tu ti autentichi — il progetto si connette da solo non appena sei entrato.",
+  "remoteConnect.autoConnectInteractiveHint": "all'avvio e al passaggio — apre l'accesso nel terminale root",
+  "remoteConnect.sshTermBtnTitle": "Apri l'accesso SSH in un terminale qui sotto — inserisci lì la password.",
+  "remoteConnect.sshTermOpenBelow": "Terminale SSH aperto qui sotto",
+  "remoteConnect.sshTermOpenBtn": "Apri terminale di accesso SSH",
+  "remoteConnect.tryConnectTitle": "Se hai terminato l'accesso qui sopra, connettiti ora.",
+  "remoteConnect.tryConnectBtn": "Ho effettuato l'accesso — connetti",
+  "remoteConnect.sshTermHint": "Accedi qui sotto — la connessione condivisa si attiva non appena sei autenticato.",
+  "remoteConnect.killConfirmTitle": "Conferma: questo termina ogni sessione tmux in esecuzione sull'host — non può essere annullato.",
+  "remoteConnect.killConfirmBtn": "Conferma: termina tutti i job",
+  "remoteConnect.killArmTitle": "Disconnessione attiva: termina ogni job tmux in esecuzione su questo host e chiude la connessione. I job vengono terminati solo con questo clic — mai al riavvio di Eldrun.",
+  "remoteConnect.killArmBtn": "Disconnetti e termina i job",
+  "remoteConnect.forgetPasswordTitle": "Elimina la password salvata di questo host dal portachiavi del tuo sistema operativo. La connessione attuale resta attiva; la prossima connessione richiederà di nuovo la password.",
+  "remoteConnect.forgetPasswordBtn": "Dimentica password salvata",
+  "carefulHost.title": "Tiene il lavoro in background di Eldrun lontano da questa macchina: il censimento delle dimensioni dei file smette di scansionare l'host da solo, e il monitoraggio diventa più economico e lento. Usalo per un nodo di login o qualsiasi macchina condivisa con altri — non per un nodo di calcolo che tieni per la durata di un job, che è tuo finché lo hai.",
+  "carefulHost.label": "Vai piano su questa macchina",
+  "carefulHost.hintDefault": "per un nodo di login o una macchina condivisa: salta le scansioni che leggono l'intero filesystem",
+  "usage.carefulNote":
+    "Host HPC — sono elencate solo le tue sessioni e i tuoi processi. Le regole di utilizzo di un cluster non permettono di raccogliere nomi o comandi di altri utenti, quindi questo report non viene eseguito automaticamente qui.",
+  "carefulHost.hintOnByDefault": "attivo per impostazione predefinita per ogni macchina remota — disattivalo se questa è tua",
+  "carefulHost.hintNotCareful": "questa macchina è tua: monitoraggio completo, come in locale",
+  "remoteConnect.vpnSectionAria": "Tunnel OpenVPN",
+  "remoteConnect.sshSectionAria": "Accesso SSH",
+  "remoteMachines.title": "{name} — Macchine remote",
+  "remoteMachines.introPre": "Ogni macchina raggiunta da questo progetto, in un unico posto — la",
+  "remoteMachines.introStrongPrimary": "primaria",
+  "remoteMachines.introMid1": "che possiede i suoi file e git, più qualsiasi macchina worker aggiuntiva che esegue il suo",
+  "remoteMachines.introStrongSameCode": "stesso codice",
+  "remoteMachines.introMid2": ". Connetti o gestisci una qualsiasi di esse qui, oppure aggiungi un nuovo worker qui sotto. Per impostazione predefinita un nuovo worker condivide la cartella del progetto della macchina primaria (nessuna copia, nessun git); spunta",
+  "remoteMachines.introStrongSyncCopy": "Sincronizza una copia",
+  "remoteMachines.introPost": "per darle una propria copia sincronizzata in un solo verso — per host che non condividono l'archiviazione con la primaria.",
+  "remoteMachines.primaryTagTitle": "La macchina primaria possiede i file, git e il mirror locale di questo progetto, con sincronizzazione bidirezionale completa.",
+  "remoteMachines.primaryTag": "Primaria",
+  "remoteMachines.connectedDot": "Connesso.",
+  "remoteMachines.notConnectedDot": "Non connesso.",
+  "remoteMachines.localMirrorLabel": "Mirror locale:",
+  "remoteMachines.manage": "Gestisci…",
+  "remoteMachines.connectEllipsis": "Connetti…",
+  "remoteMachines.sharedFsTag": "Filesystem condiviso",
+  "remoteMachines.dropIntro": "Dalle tue macchine globali. Indica il percorso condiviso in cui vede la cartella di questo progetto — tutto il resto è già noto.",
+  "remoteMachines.pathOnMachine": "Percorso su questa macchina",
+  "remoteMachines.absolutePathPlaceholder": "Percorso assoluto (es. /home/me/project)",
+  "remoteMachines.adding": "Aggiunta in corso…",
+  "remoteMachines.addMachineBtn": "Aggiungi macchina",
+  "remoteMachines.noWorkers": "Nessuna macchina worker ancora.",
+  "remoteMachines.sharedStatus": "Viene eseguito nella cartella condivisa della primaria — nessuna copia, nessuna sincronizzazione.",
+  "remoteMachines.syncFailedLabel": "Sincronizzazione non riuscita:",
+  "remoteMachines.lastSyncedLabel": "Ultima sincronizzazione:",
+  "remoteMachines.alreadyCurrent": "(già aggiornato)",
+  "remoteMachines.syncingEllipsis": "Sincronizzazione…",
+  "remoteMachines.notSyncedYet": "Non ancora sincronizzato",
+  "remoteMachines.sharedTagTitle": "Filesystem condiviso: le shell vengono eseguite nella cartella del progetto della primaria su questa macchina. Nessun codice viene copiato e git non viene mai eseguito qui.",
+  "remoteMachines.syncedTagTitle": "Copia sincronizzata: questa macchina mantiene una propria copia in sola lettura del codice, sincronizzata in un solo verso dalla primaria.",
+  "remoteMachines.syncedCopyTag": "Copia sincronizzata",
+  "remoteMachines.syncCodeNow": "Sincronizza il codice ora",
+  "remoteMachines.pullOutputsTitle": "Recupera gli output dell'esperimento di questa macchina (file non tracciati) sul tuo computer. Conferma prima la dimensione.",
+  "remoteMachines.pulling": "Recupero in corso…",
+  "remoteMachines.pullOutputsBtn": "Recupera output…",
+  "remoteMachines.removeTitle": "Rimuove questa macchina dal progetto (i suoi file sull'host restano intatti).",
+  "remoteMachines.remove": "Rimuovi",
+  "remoteMachines.syncCopyToggleTitle": "Attivo: questa macchina mantiene una propria copia del codice, sincronizzata in un solo verso dalla primaria. Disattivo: condivide la cartella del progetto della primaria tramite un filesystem condiviso (nessuna copia, nessun git).",
+  "remoteMachines.syncCopyLabel": "Sincronizza una copia del codice su questa macchina",
+  "remoteMachines.autoSyncTitle": "Mantiene il codice tracciato di questa macchina sincronizzato con l'HEAD del progetto a ogni commit.",
+  "remoteMachines.autoSyncLabel": "Sincronizza automaticamente il codice a ogni commit",
+  "remoteMachines.addMachineTitle": "Aggiungi una macchina",
+  "remoteMachines.globalListTitle": "Le tue macchine",
+  "remoteMachines.globalListHelp":
+    "Macchine dall'elenco Macchine nell'intestazione. Sono già configurate: aggiungerne una qui richiede solo la sua cartella su quella macchina.",
+  "remoteMachines.globalQuickAdd": "Aggiungi",
+  "remoteMachines.globalQuickAddTitle":
+    "Aggiungi questa macchina come worker con filesystem condiviso: conferma la sua cartella sopra, poi viene aggiunta e connessa.",
+  "remoteMachines.globalFill": "Usa nel modulo",
+  "remoteMachines.globalFillTitle":
+    "Inserisci l'indirizzo di questa macchina nel modulo sotto, per sfogliare le sue cartelle o sincronizzarci una copia.",
+  "remoteMachines.globalAlreadyAdded": "Già aggiunta",
+  "remoteMachines.globalAlreadyAddedTitle":
+    "Questa macchina è già l'host primario di questo progetto o uno dei suoi worker.",
+  "remoteMachines.sshAddressLabel": "Indirizzo SSH",
+  "remoteMachines.sshAddressPlaceholder": "host[:porta]  (es. gpu-2:22)",
+  "remoteMachines.usernamePlaceholder": "Utente di accesso SSH (es. io) — oppure includilo come user@ sopra",
+  "remoteMachines.sshPasswordSavedPlaceholder": "Usa la password salvata — lascia vuoto",
+  "remoteMachines.sshPasswordPlaceholder": "Password SSH o passphrase della chiave — vuoto per una chiave sbloccata",
+  "remoteMachines.saveTitleTerminal": "Eldrun non vede mai un accesso da terminale, quindi non salva nulla di nuovo — e non elimina nulla. Qualsiasi password salvata resta invariata; è nel menu Connetti della macchina stessa che la modifichi.",
+  "remoteMachines.saveTitleHeadless": "Salva la password SSH di questa macchina nel portachiavi del tuo sistema operativo, indicizzata per host — il menu Connetti della macchina stessa la troverà e non chiederà più. Disattivato per impostazione predefinita; deselezionarlo elimina una password salvata in precedenza.",
+  "remoteMachines.saveHintKeptTerminal": "Conservata nel portachiavi del tuo sistema operativo — un accesso da terminale non viene visto da Eldrun, quindi non salva né elimina nulla.",
+  "remoteMachines.saveHintNothingTerminal": "Nulla da salvare per un accesso da terminale — Eldrun non lo vede mai.",
+  "remoteMachines.saveHintSavedWillAskAgainOff": "Salvata nel portachiavi del tuo sistema operativo — il Connetti di questa macchina non chiederà più. Disattiva per eliminarla.",
+  "remoteMachines.saveHintWillSave": "Verrà salvata nel portachiavi del tuo sistema operativo così il Connetti di questa macchina non chiederà più.",
+  "remoteMachines.saveHintNotSavedPre": "Usata solo per accedere — non salvata. Attiva",
+  "remoteMachines.saveHintNotSavedPost": "per conservarla.",
+  "remoteMachines.loginTermHint": "Accedi qui sotto — il selettore di cartelle si apre da solo non appena questo accesso è completato.",
+  "remoteMachines.retryBrowseTitle": "Se hai terminato l'accesso qui sopra, esplora ora questa macchina.",
+  "remoteMachines.waitingForLogin": "In attesa dell'accesso…",
+  "remoteMachines.loggedInBrowse": "Ho effettuato l'accesso — esplora",
+  "remoteMachines.openLoginTerminal": "Apri terminale di accesso",
+  "remoteMachines.loggingIn": "Accesso in corso…",
+  "remoteMachines.logIn": "Accedi",
+  "remoteMachines.loggedInToPre": "Accesso effettuato a",
+  "remoteMachines.sharedFsToggleTitleStep2": "Disattivo (predefinito): questa macchina condivide la cartella del progetto della primaria tramite un filesystem condiviso — nessuna copia, nessun git. Attivo: dalle una propria copia del codice sincronizzata in un solo verso (per host che non condividono l'archiviazione).",
+  "remoteMachines.syncCopyDescOn": "Questa macchina mantiene una propria copia del codice, sincronizzata in un solo verso dalla primaria. Naviga fino a (o crea) la cartella per quella copia.",
+  "remoteMachines.syncCopyDescOff": "Questa macchina condivide la cartella del progetto della primaria tramite un filesystem condiviso — nessuna copia, nessun git. Naviga fino a quella cartella su questa macchina.",
+  "remoteMachines.remotePathForCopy": "Percorso remoto per la copia di questa macchina",
+  "remoteMachines.pathToProject": "Percorso al progetto su questa macchina",
+  "remoteMachines.reconnect": "Riconnetti",
+  "remoteMachines.browseEllipsis": "Sfoglia…",
+  "remoteMachines.browserFooter": "Naviga fino a una cartella, poi fai clic su «Usa questa cartella».",
+  "remoteMachines.labelOptional": "Etichetta (opzionale)",
+  "remoteMachines.labelPlaceholder": "es. gpu-2",
+  "remoteMachines.enterAbsolutePath": "Inserisci un percorso remoto assoluto (es. /home/me/project)",
+  "remoteMachines.enterHostBeforeBrowsing": "Inserisci un host come [utente@]host[:porta] prima di sfogliare",
+  "remoteMachines.enterHostBeforeLogin": "Inserisci un host come [utente@]host[:porta] prima di accedere",
+  "remoteMachines.enterHost": "Inserisci un host come [utente@]host[:porta]",
+  "remoteMachines.noOutputFiles": "Nessun file di output da recuperare.",
+  "remoteMachines.pullConfirm": "Recuperare {files} file di output ({bytes}) da questa macchina al tuo computer?",
+  "remoteMachines.pulledResult": "{pulled} file recuperati → {dest}{errs}",
+  "remoteMachines.pullErrorsSuffix": " ({count} non riusciti)",
+  "remoteMachines.pullFailed": "Recupero non riuscito: {error}",
+  "hpcWizard.stepLogin": "Accesso",
+  "hpcWizard.stepProject": "Progetto",
+  "hpcWizard.stepWorkspace": "Workspace",
+  "hpcWizard.stepData": "Carica dati",
+  "hpcWizard.stepRun": "Esegui job",
+  "hpcWizard.stepWatch": "Osserva",
+  "hpcWizard.sbatchJobName": "Nome del job",
+  "hpcWizard.sbatchPartition": "Partizione",
+  "hpcWizard.sbatchTime": "Tempo",
+  "hpcWizard.sbatchNodes": "Nodi",
+  "hpcWizard.sbatchTasks": "Task",
+  "hpcWizard.sbatchCpusPerTask": "CPU/task",
+  "hpcWizard.sbatchMemory": "Memoria",
+  "hpcWizard.sbatchGres": "GRES",
+  "hpcWizard.sbatchOutput": "Output",
+  "hpcWizard.title": "Pipeline HPC",
+  "hpcWizard.loginHint": "Accedi al tuo cluster. Se è raggiungibile solo tramite la VPN della tua istituzione, attiva prima il tunnel OpenVPN (nella sezione SSH qui sotto).",
+  "hpcWizard.projectNameLabel": "Nome del progetto",
+  "hpcWizard.mirrorLabel": "Posizione locale (mirror sincronizzato)",
+  "hpcWizard.noFolderSelected": "Nessuna cartella selezionata",
+  "hpcWizard.browseBtn": "Sfoglia...",
+  "hpcWizard.hostPathHintPre": "Sull'host:",
+  "hpcWizard.hostPathHintPost": "— il passaggio successivo può spostarlo in un workspace sul filesystem parallelo del cluster.",
+  "hpcWizard.watchPre": "Il tuo job è stato inviato e una scheda di log ne sta seguendo l'output. Apri la vista Job (il",
+  "hpcWizard.watchMid": "interruttore nel pannello file) per vederlo in coda, in esecuzione e terminare — con",
+  "hpcWizard.watchWatchWord": "Osserva",
+  "hpcWizard.watchCancelWord": "Annulla",
+  "hpcWizard.watchAnd": "e",
+  "hpcWizard.done": "Fatto",
+  "hpcWizard.noToolingPre": "Questo host non ha strumenti workspace (",
+  "hpcWizard.noToolingPost": ").",
+  "hpcWizard.noToolingScratchHint": "Punta però a un filesystem di grandi dimensioni — scegli dove far vivere questo progetto, dato che una home directory di solito ha una quota ed è pensata per il codice.",
+  "hpcWizard.noToolingNoScratchPre": "Il progetto vivrà nella cartella in cui hai navigato:",
+  "hpcWizard.homeRadioLabel": "home",
+  "hpcWizard.readOnly": "sola lettura",
+  "hpcWizard.projectOnHostLabel": "Progetto sull'host:",
+  "hpcWizard.creating": "Creazione in corso…",
+  "hpcWizard.createProject": "Crea progetto",
+  "hpcWizard.introPre": "Su un cluster la tua home directory è un piccolo filesystem con quota, pensato per il codice. I dati di un calcolo appartengono a un",
+  "hpcWizard.introStrongWorkspace": "workspace",
+  "hpcWizard.introMid": "— una directory sul filesystem parallelo con un nome e una durata, che",
+  "hpcWizard.introStrongDeleted": "viene eliminata alla scadenza",
+  "hpcWizard.introPost": ". Allocane uno ora, prima che qualsiasi dato venga caricato o sincronizzato.",
+  "hpcWizard.checkingTooling": "Verifica degli strumenti workspace dell'host…",
+  "hpcWizard.workspaceNameLabel": "Nome del workspace",
+  "hpcWizard.daysLabel": "Giorni",
+  "hpcWizard.filesystemLabel": "Filesystem",
+  "hpcWizard.siteDefault": "(predefinito del sito)",
+  "hpcWizard.defaultSuffix": " (predefinito)",
+  "hpcWizard.reminderEmailLabel": "E-mail di promemoria",
+  "hpcWizard.optionalPlaceholder": "opzionale",
+  "hpcWizard.remindDaysLabel": "Ricorda giorni prima",
+  "hpcWizard.reminderHint": "Vale la pena impostare un promemoria — la scadenza elimina i dati. Molti siti consegnano solo al proprio dominio.",
+  "hpcWizard.allocating": "Allocazione in corso…",
+  "hpcWizard.allocateWorkspace": "Alloca workspace",
+  "hpcWizard.readingWorkspaces": "Lettura dei tuoi workspace…",
+  "hpcWizard.yourWorkspaces": "I tuoi workspace",
+  "hpcWizard.whereProjectGoes": "Dove va il progetto",
+  "hpcWizard.inWorkspaceStrong": "Nel workspace",
+  "hpcWizard.inWorkspaceDesc": "— tutto ciò che Eldrun sincronizza (file, git, caricamenti) finisce sul filesystem parallelo, mai nella tua quota home.",
+  "hpcWizard.inBrowsedStrong": "Nella cartella sfogliata",
+  "hpcWizard.inBrowsedDesc": ", con il workspace collegato come",
+  "hpcWizard.linkNameLabel": "Nome del collegamento",
+  "hpcWizard.anchorPre": "Mantieni una piccola cartella nella mia home del cluster per questo progetto — job",
+  "hpcWizard.anchorMid": ", un",
+  "hpcWizard.anchorPost": "collegamento, e un registro che nomina il workspace. Sopravvive alla scadenza del workspace (lì non viene messo nulla di grande, ed Eldrun non lo sincronizza mai).",
+  "hpcWizard.anchorFolderLabel": "Cartella (sotto la tua home)",
+  "hpcWizard.createWithoutWorkspace": "Crea senza workspace",
+  "hpcWizard.dataHintPre": "Carica facoltativamente i file di input. Finiscono in",
+  "hpcWizard.dataHintWorkspaceSuffix": "— sul filesystem parallelo, non nella tua quota home.",
+  "hpcWizard.dataHintPlainSuffix": ".",
+  "hpcWizard.dataHintPost": "Gli alberi di grandi dimensioni è meglio contrassegnarli come auto-sync nel pannello file; questo è per pochi file.",
+  "hpcWizard.theProjectFolder": "la cartella del progetto",
+  "hpcWizard.linkNotCreatedSuffix": "/ (collegamento non creato)",
+  "hpcWizard.uploading": "Caricamento in corso…",
+  "hpcWizard.addFiles": "Aggiungi file…",
+  "hpcWizard.skip": "Salta",
+  "hpcWizard.scriptHintPre": "Uno script batch iniziale (",
+  "hpcWizard.scriptHintPost": ") verrà scritto nel progetto. Regola le sue risorse, poi invialo — viene eseguito su un nodo di calcolo.",
+  "hpcWizard.submitting": "Invio in corso…",
+  "hpcWizard.submitJob": "⏫ Invia job",
+  "projectDialog.installGitLabel": "Installa git",
+  "projectDialog.installBinLabel": "Installa {bin}",
+  "projectDialog.titleNew": "Nuovo progetto",
+  "projectDialog.titleImport": "Importa progetto",
+  "projectDialog.remoteToggleTitle": "Progetto remoto (SSH)",
+  "projectDialog.remoteToggleDesc": "Lavora su un progetto che risiede su un'altra macchina — terminali, file e git vengono tutti eseguiti sull'host tramite SSH.",
+  "projectDialog.localLocationLabel": "Posizione locale",
+  "projectDialog.noFolderSelected": "Nessuna cartella selezionata",
+  "projectDialog.browseBtn": "Sfoglia...",
+  "projectDialog.localMirrorHint": "La copia di lavoro locale sincronizzata risiede qui come {name}.",
+  "projectDialog.projectNameLabel": "Nome del progetto",
+  "projectDialog.descriptionLabel": "Descrizione del progetto",
+  "projectDialog.descFillModeTitle": "Modalità di compilazione della descrizione del progetto",
+  "projectDialog.fillModeManual": "Manuale",
+  "projectDialog.fillModeAgentChoice": "Scelta dell'agente",
+  "projectDialog.descriptionPlaceholder": "A cosa serve questo progetto",
+  "projectDialog.importFromLabel": "Importa da",
+  "projectDialog.importFolderOpt": "Cartella su questa macchina",
+  "projectDialog.importGitOpt": "Repository GitHub / GitLab (clone)",
+  "projectDialog.importForkOpt": "Repository GitHub / GitLab (fork, poi clone)",
+  "projectDialog.sourceFolderLabel": "Cartella sorgente",
+  "projectDialog.repoToForkLabel": "Repository da forkare",
+  "projectDialog.repoUrlLabel": "URL del repository",
+  "projectDialog.forkHintPre": "Il repository viene forkato nel tuo account, ed è il tuo fork a essere clonato qui — l'originale resta come remote",
+  "projectDialog.forkHintMid": ". Il fork avviene tramite la CLI del provider (",
+  "projectDialog.forkHintPost": "), quindi usa il login di quella CLI.",
+  "projectDialog.cloneHintPrivateConnected": "Un repository privato viene clonato con il token di accesso da Impostazioni → Hosting Git. Un URL SSH (git@…) usa invece le tue chiavi SSH.",
+  "projectDialog.cloneHintPublicOnly": "I repository pubblici vengono clonati così come sono. Per uno privato, aggiungi un token di accesso in Impostazioni → Hosting Git, oppure usa un URL SSH (git@…) per autenticarti con le tue chiavi SSH.",
+  "projectDialog.hostTypeLabel": "Tipo di host",
+  "projectDialog.detectFromUrl": "Rileva dall'URL",
+  "projectDialog.detectFromUrlWithProvider": "Rileva dall'URL ({provider})",
+  "projectDialog.hostTypeHint": "Questo host non si dichiara GitHub o GitLab (un'istanza self-hosted di solito non lo fa) — scegli quale sia, dato che il fork viene creato dalla CLI di quel provider.",
+  "projectDialog.forkCliMissingPre": "Nessun",
+  "projectDialog.forkCliMissingMid1": "trovato su questa macchina — un fork viene creato dalla CLI stessa del provider, quindi installala (e accedi con",
+  "projectDialog.forkCliMissingPost": ") per fare il fork da",
+  "projectDialog.runInTerminalBtn": "Esegui nel terminale",
+  "projectDialog.locationLabel": "Posizione",
+  "projectDialog.cloneDestYourFork": "Il tuo fork viene",
+  "projectDialog.cloneDestTheRepo": "Il repository viene",
+  "projectDialog.cloneDestMid": "clonato in",
+  "projectDialog.cloneDestPost": "qui.",
+  "projectDialog.gitHostingLabel": "Hosting Git",
+  "projectDialog.gitNoneOpt": "Nessun git (semplici file, nessun repository)",
+  "projectDialog.gitLocalOpt": "Solo repository locale (non inviato da nessuna parte)",
+  "projectDialog.gitRemotePrivateOpt": "Invia a GitHub/GitLab · privato",
+  "projectDialog.gitRemotePublicOpt": "Invia a GitHub/GitLab · pubblico",
+  "projectDialog.gitHostingHintPre": "«Invia a GitHub/GitLab» pubblica il repository su un servizio di hosting",
+  "projectDialog.gitHostingHintRemoteSuffix": "— senza alcuna relazione con l'host SSH sopra, che è semplicemente dove risiedono i file del progetto.",
+  "projectDialog.needsGitConnectionText": "In Eldrun non è ancora stata configurata una connessione GitHub/GitLab. Aggiungi un token di accesso in Impostazioni → Hosting Git per poter pubblicare il repository.",
+  "projectDialog.setUpGitHostingBtn": "Configura GitHub/GitLab…",
+  "projectDialog.needsGitInstallTextPre": "Nessun git trovato su questa macchina — installalo per creare un progetto basato su git",
+  "projectDialog.needsGitInstallOrClone": " o clonare un repository",
+  "projectDialog.importModeLabel": "Modalità di importazione",
+  "projectDialog.modeKeepOpt": "Mantieni la posizione (registra sul posto)",
+  "projectDialog.modeCopyOpt": "Copia nella cartella progetti di Eldrun",
+  "projectDialog.modeMoveOpt": "Sposta nella cartella progetti di Eldrun",
+  "projectDialog.remoteImportKeepsFolder": "L'importazione remota mantiene la cartella dov'è sull'host remoto.",
+  "projectDialog.skipScaffoldLabel": "Salta lo scaffolding (non generare alcun file di scaffold)",
+  "projectDialog.scaffoldGuidanceAria": "Guida allo scaffold di importazione",
+  "projectDialog.importGuidanceTitle": "Guida all'importazione",
+  "projectDialog.stepSelectSource": "Seleziona la cartella sorgente e i metadati del progetto.",
+  "projectDialog.stepRegisterKeep": "Registra il progetto nella sua posizione attuale.",
+  "projectDialog.stepCopyValidate": "Copia il progetto nella cartella progetti di Eldrun dopo la convalida manuale.",
+  "projectDialog.stepMoveValidate": "Sposta il progetto nella cartella progetti di Eldrun dopo la convalida manuale.",
+  "projectDialog.stepCreateScaffold": "Crea i file di scaffold mancanti e prendi atto di quelli già presenti.",
+  "projectDialog.stepWriteProjectJson": "Scrivi project.json e aggiungi il progetto al selettore.",
+  "projectDialog.manualValidationCopy": "Ho convalidato manualmente la destinazione della copia e la cartella sorgente.",
+  "projectDialog.manualValidationMove": "Ho convalidato manualmente la destinazione dello spostamento e la cartella sorgente.",
+  "projectDialog.fillAllLabel": "Compila tutto",
+  "projectDialog.noMissingFiles": "Nessun file mancante",
+  "projectDialog.chooseFillMode": "Scegli modalità di compilazione...",
+  "projectDialog.alreadyThere": "Già presente",
+  "projectDialog.missingLabel": "Mancante",
+  "projectDialog.alreadyThereKept": "Già presente, verrà mantenuto",
+  "projectDialog.missingWillAdd": "Mancante, verrà aggiunto",
+  "projectDialog.statusOnly": "Solo stato",
+  "projectDialog.chooseSourceToPreview": "Scegli una cartella sorgente per visualizzare in anteprima i file di scaffold.",
+  "projectDialog.loadingScaffoldPreview": "Caricamento anteprima scaffold...",
+  "projectDialog.remoteDestinationLabel": "Destinazione remota: {path}",
+  "projectDialog.remoteLocationLabel": "Posizione remota: {path}",
+  "projectDialog.changeFolderBtn": "Cambia cartella",
+  "projectDialog.changeFolderTitleWinManual": "Torna indietro per cambiare il percorso remoto",
+  "projectDialog.changeFolderTitleBrowse": "Torna al browser remoto per scegliere un'altra cartella",
+  "projectDialog.destinationLabel": "Destinazione: {path}",
+  "projectDialog.locationColonLabel": "Posizione: {path}",
+  "projectDialog.forking": "Fork in corso...",
+  "projectDialog.cloningEllipsis": "Clonazione in corso...",
+  "projectDialog.working": "Elaborazione in corso...",
+  "projectDialog.create": "Crea",
+  "projectDialog.forkAndImport": "Fork e importa",
+  "projectDialog.cloneAndImport": "Clona e importa",
+  "projectDialog.import": "Importa",
+  "projectDialog.runInTerminalTitle": "Esegui questo comando in una nuova scheda del terminale",
+  "remoteProjectSection.vpnUpClickToReconnect": "Il tunnel OpenVPN è attivo. Clicca per riconnetterti.",
+  "remoteProjectSection.vpnFailedWithError": "Connessione VPN non riuscita: {error}",
+  "remoteProjectSection.vpnFailedClickRetry": "Connessione VPN non riuscita. Clicca per riprovare.",
+  "remoteProjectSection.vpnBringUpHint": "Attiva ora il tunnel OpenVPN per raggiungere un host protetto da VPN.",
+  "remoteProjectSection.vpnSelectConfigFirst": "Seleziona prima una configurazione OpenVPN.",
+  "remoteProjectSection.stepConnectLabel": "Connetti",
+  "remoteProjectSection.stepBrowseLabel": "Sfoglia",
+  "remoteProjectSection.stepDetailsLabel": "Dettagli",
+  "remoteProjectSection.remoteStepsAria": "Passaggi del progetto remoto",
+  "remoteProjectSection.passwordAuthWarning": "L'autenticazione con password richiede OpenSSH 8.4+ o sshpass — aggiorna OpenSSH o installa sshpass, oppure usa chiavi SSH (lascia vuota la password).",
+  "remoteProjectSection.opensslMissingWarning": "openvpn/pkexec non trovato — gli host protetti da VPN non possono connettersi. Installa openvpn e polkit.",
+  "remoteProjectSection.vpnToggleDescLine1": "Necessario solo per un host protetto da VPN — lascialo disattivato se sei già sulla rete giusta.",
+  "remoteProjectSection.vpnConfigLabel": "Configurazione OpenVPN",
+  "remoteProjectSection.vpnConfigCopiedHint": "(copiato in Eldrun alla selezione)",
+  "remoteProjectSection.noOvpnSelected": "Nessun .ovpn selezionato",
+  "remoteProjectSection.browseEllipsis": "Sfoglia…",
+  "remoteProjectSection.storedWithProject": "(memorizzata con il progetto)",
+  "remoteProjectSection.vpnUsernamePlaceholderNoDots": "Nome utente dell'account OpenVPN",
+  "remoteProjectSection.savedInKeychainYour": "(salvata nel portachiavi del tuo sistema operativo)",
+  "remoteProjectSection.notStoredUnlessSaved": "(non salvata a meno che tu non la salvi qui sotto)",
+  "remoteProjectSection.vpnAccountPasswordNoDots": "Password dell'account OpenVPN",
+  "remoteProjectSection.keyPassphrasePlaceholderNoDots": "Passphrase per la chiave cifrata della configurazione",
+  "remoteProjectSection.vpnTermBtnTitleActive": "Attiva il tunnel OpenVPN in un terminale qui sotto — inserisci lì la passphrase. Resta attivo per il nuovo progetto.",
+  "remoteProjectSection.vpnTermHintClosed": "Clicca sopra per aprire qui un terminale — inserisci lì la passphrase. Eldrun non la gestisce mai; il tunnel resta attivo per il nuovo progetto.",
+  "remoteProjectSection.vpnTermHintOpen": "Autentica il tunnel qui sotto — continua a funzionare per il nuovo progetto dopo che chiudi questa finestra.",
+  "remoteProjectSection.sshAddressLabel": "Indirizzo SSH",
+  "remoteProjectSection.reuseSshAddressTitle": "Riusa un indirizzo SSH già utilizzato",
+  "remoteProjectSection.sshAddressPlaceholder": "utente@host o host:2222",
+  "remoteProjectSection.passwordLabel": "Password",
+  "remoteProjectSection.notStoredBlankKey": "(non salvata a meno che tu non la salvi qui sotto; vuota usa la chiave SSH)",
+  "remoteProjectSection.sshSavedPlaceholder": "Usa la password salvata — lascia vuoto",
+  "remoteProjectSection.sshPasswordPlaceholderNoDots": "password, oppure la passphrase della tua chiave — vuota se la chiave è sbloccata",
+  "remoteProjectSection.connectingDotsShort": "Connessione in corso...",
+  "remoteProjectSection.remotePathLabel": "Percorso remoto",
+  "remoteProjectSection.remotePathHintNew": "(cartella padre; il progetto viene creato al suo interno)",
+  "remoteProjectSection.remotePathHintImport": "(percorso assoluto del progetto esistente)",
+  "remoteProjectSection.reuseRemotePathTitle": "Riusa un percorso remoto già utilizzato per questo host",
+  "remoteProjectSection.remotePathPlaceholder": "/home/user/projects",
+  "remoteProjectSection.sshTermBtnTitle": "Apri l'accesso SSH in un terminale qui sotto — inserisci lì qualsiasi password. L'accesso resta attivo per il nuovo progetto.",
+  "remoteProjectSection.tryBrowseTitle": "Se hai terminato l'accesso qui sopra, esplora ora l'albero remoto.",
+  "remoteProjectSection.sshTermHintClosedPre": "Clicca sopra per aprire qui un terminale — inserisci lì qualsiasi password. Eldrun non la gestisce mai; l'accesso resta attivo per il nuovo progetto.",
+  "remoteProjectSection.sshTermHintClosedSuffix": " Una volta effettuato l'accesso, l'albero remoto si apre per la navigazione.",
+  "remoteProjectSection.sshTermHintOpen": "Accedi qui sotto — la sessione continua a funzionare per il nuovo progetto dopo che chiudi questa finestra.",
+  "remoteProjectSection.willCreateLabel": "Verrà creato: {path}",
+  "remoteProjectSection.selectedLabel": "Selezionato: {path}",
+  "credentialPasteBar.typeItForMe": "Scrivilo per me:",
+  "credentialPasteBar.pastedFlash": "incollato",
+  "credentialPasteBar.nothingSavedFlash": "nulla salvato per questo accesso (o il portachiavi è bloccato)",
+  "credentialPasteBar.pasteUsername": "Incolla nome utente",
+  "credentialPasteBar.pasteUsernameTitle": "Digita «{user}» nel terminale di accesso alla posizione del cursore.",
+  "credentialPasteBar.pastePassword": "Incolla password",
+  "credentialPasteBar.pastePasswordTitle": "Digita la password salvata per questo accesso nel terminale alla posizione del cursore — passa direttamente dal portachiavi del tuo sistema operativo al terminale, mai attraverso l'interfaccia di Eldrun. Premi tu stesso Invio.",
+  "credentialPasteBar.pasteVpnUsernameTitle": "Digita il nome utente di autenticazione di questo tunnel nel terminale alla posizione del cursore.",
+  "credentialPasteBar.pastePassphrase": "Incolla passphrase",
+  "credentialPasteBar.pasteVpnSecretTitle": "Digita il segreto salvato per questo tunnel nel terminale alla posizione del cursore — direttamente dal portachiavi del tuo sistema operativo al terminale. Premi tu stesso Invio.",
+  "credentialPasteBar.pasteKeyPassphrase": "Incolla passphrase della chiave",
+  "credentialPasteBar.pasteKeyPassphraseTitle": "Digita la passphrase della chiave privata salvata nel terminale alla posizione del cursore — OpenVPN la richiede separatamente dalla password dell'account.",
+  "terminalSignIn.sshHostWord": "host SSH",
+  "terminalSignIn.vpnTunnelWord": "tunnel OpenVPN",
+  "terminalSignIn.busyTitle": "Disconnetti prima il terminale di accesso qui sotto.",
+  "terminalSignIn.titleTemplate": "Accedi a {what} in un terminale qui invece che in questi campi. Pone le proprie domande — una password, un codice di verifica, una seconda richiesta — e tu rispondi direttamente; Eldrun non le vede mai. Solo per questa connessione: la tua impostazione headless resta invariata.",
+  "terminalSignIn.label": "Accedi in un terminale",
+  "terminalSignIn.failedHint": "l'accesso non è riuscito — se {what} richiede qualcosa di diverso da una password (un codice di verifica, una seconda richiesta), solo un terminale può rispondere",
+  "terminalSignIn.defaultHint": "per un host che richiede più di una password — un codice di verifica, una seconda richiesta",
+  "projectHoverCard.statusCurrent": "Attuale",
+  "projectHoverCard.statusActive": "Attivo",
+  "projectHoverCard.statusInactive": "Inattivo",
+  "projectHoverCard.timeUnderMinute": "< 1 min",
+  "projectHoverCard.cpuIdle": "inattivo",
+  "projectHoverCard.remoteLabel": "remoto",
+  "projectHoverCard.localLabel": "locale",
+  "projectHoverCard.originLabel": "origine",
+  "projectHoverCard.todayPrefix": "Oggi:",
+  "projectHoverCard.pausedSuffix": "(in pausa)",
+  "projectHoverCard.cpuPrefix": "CPU:",
+  "windowControls.minimize": "Riduci a icona",
+  "windowControls.maximize": "Ingrandisci",
+  "connTypeIcon.offlineSuffix": " (offline)",
+  "appTimer.globalActivityTitle": "Attività globale",
+  "appTimer.pausedResumeHint": "In pausa — clicca per riprendere",
+  "appTimer.clickPauseHint": "Clicca per mettere in pausa • Clic destro per l'attività",
+  "appResource.processCountOne": "{count} processo Eldrun",
+  "appResource.processCountMany": "{count} processi Eldrun",
+  "appResource.gpuNoDeviceTitle": "Memoria GPU in uso dai modelli locali (Ollama) — la GPU di questa macchina non riporta una propria memoria",
+  "remoteConnMenu.statusError": "errore",
+  "remoteConnMenu.statusConnecting": "connessione",
+  "remoteConnMenu.statusConnected": "connesso",
+  "remoteConnMenu.statusOff": "spento",
+  "remoteConnMenu.ariaLabel": "Macchine remote — clicca per connettere/gestire gli host di questo progetto",
+  "remoteConnMenu.workingWord": "in attività",
+  "vpnIndicator.keyringStayedLocked": "Il portachiavi è rimasto bloccato — le credenziali VPN salvate non possono ancora essere lette.",
+  "vpnIndicator.keyringLockedConnectReason": "Il portachiavi del tuo sistema operativo è bloccato, quindi le credenziali VPN salvate non possono essere lette. Sbloccalo (o inserisci la passphrase qui sotto) per connetterti.",
+  "vpnIndicator.savedCredentialsDidntWork": "Le credenziali VPN salvate non hanno funzionato: {error}",
+  "vpnIndicator.noCredentialStore": "Questa macchina non ha un archivio di credenziali, quindi non può essere salvato nulla per questo tunnel.",
+  "vpnIndicator.noSavedCredentialsYet": "Nessuna credenziale salvata per questo tunnel ancora — spunta «Salva credenziali di accesso» per saltare questo passaggio la prossima volta.",
+  "vpnIndicator.enterCredentialsOnce": "Inserisci le credenziali una volta — vanno nel portachiavi del tuo sistema operativo, e questo tunnel si connette senza chiedere da ora in poi.",
+  "vpnIndicator.saveCredentialsAria": "Salva credenziali di accesso per {file}",
+  "vpnIndicator.saveCredsUnavailableTitle": "Questa macchina non ha un archivio di credenziali del sistema operativo, quindi non può essere salvato nulla.",
+  "vpnIndicator.saveCredsSavedTitle": "Le credenziali di questo tunnel sono nel portachiavi del tuo sistema operativo — la connessione non chiede nulla. Disattiva per eliminarle.",
+  "vpnIndicator.saveCredsNotSavedTitle": "Chiedi una volta le credenziali di questo tunnel, conservale nel portachiavi del tuo sistema operativo, e connettiti senza chiedere da quel momento in poi.",
+  "vpnIndicator.saveLoginCredentialsLabel": "Salva credenziali di accesso",
+  "vpnIndicator.savedButLocked": "Salvato, ma il tuo portachiavi è bloccato — sbloccalo sopra per usarle.",
+  "vpnIndicator.connectOnLaunchAria": "Connetti {file} all'avvio",
+  "vpnIndicator.connectOnLaunchHeadlessTitle": "Attiva automaticamente questo tunnel all'avvio di Eldrun, usando le credenziali salvate — senza chiedere. Reindirizza questo computer fin dall'avvio.",
+  "vpnIndicator.connectOnLaunchInteractiveTitle": "Apre il comando di connessione di questo tunnel nel terminale root all'avvio di Eldrun, perché tu ti autentichi. Reindirizza questo computer una volta attivo.",
+  "vpnIndicator.connectOnLaunchLabel": "Connetti all'avvio",
+  "vpnIndicator.needSaveCredsFirstHintPre": "Attiva",
+  "vpnIndicator.needSaveCredsFirstHintPost": "prima — la connessione automatica non chiede mai, quindi viene offerta solo quando la connessione può essere silenziosa.",
+  "vpnIndicator.startsWithEldrun": "Si avvia con Eldrun",
+  "vpnIndicator.waitsInRootTerminal": " (attende nel terminale root)",
+  "vpnIndicator.mainAriaLabel": "OpenVPN — connetti o disconnetti un tunnel",
+  "vpnIndicator.titleOff": "OpenVPN — nessun tunnel. Connetterne uno instrada il traffico di questo computer attraverso di esso.",
+  "vpnIndicator.titleConnecting": "OpenVPN — connessione in corso. Una volta attivo, il traffico di questo computer passa attraverso il tunnel.",
+  "vpnIndicator.titleConnected": "OpenVPN — attivo. Il traffico di questo computer passa attraverso il tunnel.",
+  "vpnIndicator.vpnLabel": "VPN",
+  "vpnIndicator.note": "Un tunnel instrada",
+  "vpnIndicator.noteStrong": "tutto il traffico di questo computer",
+  "vpnIndicator.notePost": "— non solo quello di Eldrun — incluso il tuo browser — finché è attivo.",
+  "vpnIndicator.lockedBannerPre": "Il portachiavi del tuo sistema operativo è",
+  "vpnIndicator.lockedBannerStrong": "bloccato",
+  "vpnIndicator.lockedBannerPost": ", quindi le credenziali VPN salvate non possono essere lette — la connessione le richiederà di nuovo finché non viene sbloccato.",
+  "vpnIndicator.unlockTitle": "Sblocca l'archivio di credenziali del sistema operativo per poter usare le credenziali salvate. Il tuo desktop chiede la password del portachiavi.",
+  "vpnIndicator.unlocking": "Sblocco in corso…",
+  "vpnIndicator.unlockKeyring": "Sblocca portachiavi",
+  "vpnIndicator.heldForPrefix": "per",
+  "vpnIndicator.heldByNoProject": "non mantenuto da alcun progetto",
+  "vpnIndicator.stopConnectingTitle": "Interrompe il tentativo di attivare questo tunnel e ripristina il routing normale.",
+  "vpnIndicator.stopConnecting": "Interrompi connessione",
+  "vpnIndicator.disconnectTunnelTitle": "Disattiva questo tunnel e ripristina il routing normale. I progetti che lo usano restano aperti; il loro SSH potrebbe o meno sopravvivere senza di esso.",
+  "vpnIndicator.disconnectTunnel": "Disconnetti tunnel",
+  "vpnIndicator.connectGroupLabel": "Connetti",
+  "vpnIndicator.removeConfigHint": "Rimuove questa configurazione da Eldrun e dimentica le sue credenziali salvate.",
+  "vpnIndicator.usedByPre": "Usato da",
+  "vpnIndicator.usedByPost": "— connettersi a quel progetto richiederà di nuovo una configurazione.",
+  "vpnIndicator.removeConfigBtn": "Rimuovi configurazione",
+  "vpnIndicator.keepBtn": "Mantieni",
+  "vpnIndicator.connectTunnelTitle": "Attiva questo tunnel. Instraderà il traffico di questo computer — non solo quello di Eldrun.",
+  "vpnIndicator.removeConfigTitle": "Rimuove questa configurazione salvata da Eldrun e dimentica le sue credenziali salvate. Chiede ancora una volta prima di farlo.",
+  "vpnIndicator.emptyStatePre": "Nessuna configurazione OpenVPN salvata ancora — aggiungi un file",
+  "vpnIndicator.emptyStatePost": ", poi connettilo dalla sua riga (lì chiederà la tua password).",
+  "vpnIndicator.addFirstConfigTitle": "Scegli un file .ovpn e salvalo in Eldrun. Aggiungerlo non connette — lo connetti esplicitamente in seguito, dove chiederà la tua password.",
+  "vpnIndicator.addAnotherConfigTitle": "Scegli un altro file .ovpn e salvalo in Eldrun. Aggiungerlo non connette — lo connetti esplicitamente dalla sua riga in seguito.",
+  "vpnIndicator.addConfigBtn": "Aggiungi configurazione…",
+};
+
+const TRANSLATIONS: Record<Language, Dict> = { en, de, es, fr, it };
+
+const LANG_CACHE_KEY = "eldrun-lang";
+
+function cachedLang(): Language {
+  try {
+    return normalizeLang(localStorage.getItem(LANG_CACHE_KEY));
+  } catch {
+    return "en";
+  }
+}
+
+interface I18nStore {
+  lang: Language;
+  /** Set the live language WITHOUT persisting (persistence rides settings.json).
+   *  Every `useT()` subscriber re-renders instantly. */
+  setLangLocal: (lang: Language) => void;
+}
+
+export const useI18nStore = create<I18nStore>((set) => ({
+  lang: cachedLang(),
+  setLangLocal: (lang) => set({ lang }),
+}));
+
+/** Apply a language app-wide: flips the reactive store and caches it so the next
+ *  launch paints this language before settings finish loading. Mirrors
+ *  `applyTheme` in `stores/settings`. */
+export function applyLanguage(value: string | null | undefined) {
+  const lang = normalizeLang(value);
+  useI18nStore.getState().setLangLocal(lang);
+  try {
+    localStorage.setItem(LANG_CACHE_KEY, lang);
+  } catch {
+    // localStorage unavailable — the switch still works this session.
+  }
+}
+
+/** Look up a key in `lang`, falling back to English then the raw key. `params`
+ *  substitutes `{name}` placeholders. */
+export function translate(
+  lang: Language,
+  key: TranslationKey,
+  params?: Record<string, string | number>,
+): string {
+  const raw = TRANSLATIONS[lang]?.[key] ?? en[key] ?? key;
+  if (!params) return raw;
+  return raw.replace(/\{(\w+)\}/g, (m, name) =>
+    name in params ? String(params[name]) : m,
+  );
+}
+
+/** The translator hook: `const t = useT(); t("settings.title")`. Re-renders the
+ *  component whenever the language changes, so switching is live. */
+export function useT() {
+  const lang = useI18nStore((s) => s.lang);
+  return useMemo(
+    () =>
+      (key: TranslationKey, params?: Record<string, string | number>) =>
+        translate(lang, key, params),
+    [lang],
+  );
+}
\ No newline at end of file
diff --git a/src/lib/ics.ts b/src/lib/ics.ts
new file mode 100644
index 0000000..f02428b
--- /dev/null
+++ b/src/lib/ics.ts
@@ -0,0 +1,572 @@
+/**
+ * iCalendar (RFC 5545) import/export — the subset Eldrun's model actually holds.
+ *
+ * Parsing lives here, in tested TypeScript, rather than in Rust: the backend
+ * stays a dumb store, and the format's real complexity (line folding, escaping,
+ * the DTSTART/DTEND value-type dance) is all string work that is far cheaper to
+ * unit-test on this side.
+ *
+ * **Times are read and written as local wall-clock**, matching the rest of the
+ * calendar. A `Z`-suffixed (UTC) timestamp in an imported file is converted to
+ * local time on the way in; everything is written back as floating local time.
+ * `VTIMEZONE` blocks are ignored — a `TZID` we do not understand would otherwise
+ * silently shift an event, and dropping to floating local is the honest failure.
+ *
+ * Supported: VEVENT, VTODO, VALARM (display, minute-offset triggers), RRULE
+ * (FREQ/INTERVAL/BYDAY/BYMONTHDAY/UNTIL/COUNT), EXDATE, CATEGORIES, LOCATION,
+ * DESCRIPTION, SUMMARY, STATUS, PRIORITY, PERCENT-COMPLETE, COMPLETED.
+ */
+
+import type {
+  Alarm,
+  CalendarEvent,
+  CalendarTask,
+  EventStatus,
+  Freq,
+  Rrule,
+} from "../types";
+import { addDays, datePart, parseStamp } from "./calendarTime";
+
+const ICS_WEEKDAYS = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+
+// ── Line handling ───────────────────────────────────────────────────────────
+
+/**
+ * Unfold the content lines. RFC 5545 wraps long lines by inserting CRLF followed
+ * by a single space or tab, which must be stitched back before anything is parsed.
+ */
+export function unfold(text: string): string[] {
+  const raw = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out: string[] = [];
+  for (const line of raw) {
+    if ((line.startsWith(" ") || line.startsWith("\t")) && out.length > 0) {
+      out[out.length - 1] += line.slice(1);
+    } else {
+      out.push(line);
+    }
+  }
+  return out.filter((l) => l.trim() !== "");
+}
+
+/** Fold a content line at 75 octets, per RFC 5545. */
+export function fold(line: string): string {
+  if (line.length <= 75) return line;
+  const parts: string[] = [line.slice(0, 75)];
+  let rest = line.slice(75);
+  while (rest.length > 74) {
+    parts.push(" " + rest.slice(0, 74));
+    rest = rest.slice(74);
+  }
+  if (rest) parts.push(" " + rest);
+  return parts.join("\r\n");
+}
+
+/** Escape a TEXT value: backslash, semicolon, comma and newline are special. */
+export function escapeText(value: string): string {
+  return value
+    .replace(/\\/g, "\\\\")
+    .replace(/;/g, "\\;")
+    .replace(/,/g, "\\,")
+    .replace(/\n/g, "\\n");
+}
+
+/** Reverse `escapeText`. */
+export function unescapeText(value: string): string {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === "\\" && i + 1 < value.length) {
+      const next = value[++i];
+      if (next === "n" || next === "N") out += "\n";
+      else out += next; // \\ \; \, and anything else → the literal char
+    } else {
+      out += value[i];
+    }
+  }
+  return out;
+}
+
+/** One parsed content line: `NAME;PARAM=X:VALUE`. */
+interface Line {
+  name: string;
+  params: Record<string, string>;
+  value: string;
+}
+
+/** Split a content line, honouring quoted parameter values (which may hold `:`). */
+export function parseLine(line: string): Line | null {
+  let colon = -1;
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (c === '"') inQuotes = !inQuotes;
+    else if (c === ":" && !inQuotes) {
+      colon = i;
+      break;
+    }
+  }
+  if (colon === -1) return null;
+
+  const head = line.slice(0, colon);
+  const value = line.slice(colon + 1);
+  const segments = head.split(";");
+  const name = segments[0].toUpperCase();
+
+  const params: Record<string, string> = {};
+  for (const seg of segments.slice(1)) {
+    const eq = seg.indexOf("=");
+    if (eq === -1) continue;
+    params[seg.slice(0, eq).toUpperCase()] = seg.slice(eq + 1).replace(/^"|"$/g, "");
+  }
+  return { name, params, value };
+}
+
+// ── Date/time values ────────────────────────────────────────────────────────
+
+/**
+ * An ICS DATE or DATE-TIME → a local stamp.
+ *
+ * `20260708`         → `"2026-07-08"`      (a date; all-day)
+ * `20260708T090000`  → `"2026-07-08T09:00"` (floating local)
+ * `20260708T070000Z` → converted from UTC into local time
+ */
+export function parseIcsDate(value: string): { stamp: string; dateOnly: boolean } | null {
+  const v = value.trim();
+
+  const dateOnly = /^(\d{4})(\d{2})(\d{2})$/.exec(v);
+  if (dateOnly) {
+    const [, y, m, d] = dateOnly;
+    return { stamp: `${y}-${m}-${d}`, dateOnly: true };
+  }
+
+  const dt = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})?(Z)?$/.exec(v);
+  if (!dt) return null;
+  const [, y, mo, d, h, mi, , z] = dt;
+
+  if (z) {
+    // UTC → local. This is the one place an epoch conversion is correct: the
+    // source really is an absolute instant.
+    const utc = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi));
+    const local = new Date(utc);
+    const p = (n: number) => String(n).padStart(2, "0");
+    return {
+      stamp: `${local.getFullYear()}-${p(local.getMonth() + 1)}-${p(local.getDate())}T${p(local.getHours())}:${p(local.getMinutes())}`,
+      dateOnly: false,
+    };
+  }
+
+  return { stamp: `${y}-${mo}-${d}T${h}:${mi}`, dateOnly: false };
+}
+
+/** A local stamp → an ICS DATE (all-day) or floating DATE-TIME. */
+export function formatIcsDate(stamp: string, allDay: boolean): string {
+  const c = parseStamp(stamp);
+  if (!c) return stamp;
+  const p = (n: number) => String(n).padStart(2, "0");
+  const date = `${String(c.year).padStart(4, "0")}${p(c.month)}${p(c.day)}`;
+  if (allDay) return date;
+  return `${date}T${p(c.hour)}${p(c.minute)}00`;
+}
+
+/** A UTC stamp for DTSTAMP, which must be absolute. */
+function icsNowUtc(now: Date): string {
+  const p = (n: number) => String(n).padStart(2, "0");
+  return (
+    `${now.getUTCFullYear()}${p(now.getUTCMonth() + 1)}${p(now.getUTCDate())}` +
+    `T${p(now.getUTCHours())}${p(now.getUTCMinutes())}${p(now.getUTCSeconds())}Z`
+  );
+}
+
+// ── RRULE ───────────────────────────────────────────────────────────────────
+
+/** `FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,FR;COUNT=10` → an `Rrule`. */
+export function parseRrule(value: string): Rrule | null {
+  const parts: Record<string, string> = {};
+  for (const chunk of value.split(";")) {
+    const eq = chunk.indexOf("=");
+    if (eq > 0) parts[chunk.slice(0, eq).toUpperCase()] = chunk.slice(eq + 1);
+  }
+
+  const freqRaw = (parts.FREQ ?? "").toUpperCase();
+  const freq = (
+    { DAILY: "daily", WEEKLY: "weekly", MONTHLY: "monthly", YEARLY: "yearly" } as const
+  )[freqRaw as "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY"];
+  // An unsupported FREQ (SECONDLY/MINUTELY/HOURLY) is dropped rather than guessed
+  // at — the event still imports, just without its rule.
+  if (!freq) return null;
+
+  const rule: Rrule = { freq: freq as Freq, interval: Number(parts.INTERVAL) || 1 };
+
+  if (parts.BYDAY) {
+    const days = parts.BYDAY.split(",")
+      // Strip any ordinal prefix ("2MO" = the 2nd Monday); the ordinal itself is
+      // beyond what the model holds, so it degrades to a plain weekday.
+      .map((d) => ICS_WEEKDAYS.indexOf(d.trim().toUpperCase().replace(/^[+-]?\d+/, "")))
+      .filter((i) => i >= 0);
+    if (days.length) rule.byweekday = days;
+  }
+
+  if (parts.BYMONTHDAY) {
+    const day = Number(parts.BYMONTHDAY.split(",")[0]);
+    if (day >= 1 && day <= 31) rule.bymonthday = day;
+  }
+
+  if (parts.COUNT) {
+    const n = Number(parts.COUNT);
+    if (n > 0) rule.count = n;
+  }
+
+  if (parts.UNTIL) {
+    const until = parseIcsDate(parts.UNTIL);
+    if (until) rule.until = datePart(until.stamp);
+  }
+
+  return rule;
+}
+
+/** An `Rrule` → an RRULE value. */
+export function formatRrule(rule: Rrule): string {
+  const parts = [`FREQ=${rule.freq.toUpperCase()}`];
+  if (rule.interval && rule.interval !== 1) parts.push(`INTERVAL=${rule.interval}`);
+  if (rule.byweekday?.length) {
+    parts.push(`BYDAY=${rule.byweekday.map((d) => ICS_WEEKDAYS[d]).join(",")}`);
+  }
+  if (rule.bymonthday) parts.push(`BYMONTHDAY=${rule.bymonthday}`);
+  if (rule.count) parts.push(`COUNT=${rule.count}`);
+  if (rule.until) parts.push(`UNTIL=${formatIcsDate(rule.until, true)}`);
+  return parts.join(";");
+}
+
+// ── Alarms ──────────────────────────────────────────────────────────────────
+
+/**
+ * A VALARM TRIGGER duration → minutes *before* the start.
+ *
+ * `-PT15M` → 15, `-PT1H` → 60, `-P1D` → 1440, `PT0S` → 0. A positive trigger
+ * (after the start) comes back negative, which is exactly how `Alarm` stores it.
+ */
+export function parseTrigger(value: string): number | null {
+  const m = /^([+-])?P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/.exec(value.trim());
+  if (!m) return null;
+  const [, sign, d, h, min, s] = m;
+  const total =
+    (Number(d) || 0) * 1440 +
+    (Number(h) || 0) * 60 +
+    (Number(min) || 0) +
+    Math.round((Number(s) || 0) / 60);
+  // A negative duration fires BEFORE the start → a positive minutes_before.
+  const minutes = sign === "-" ? total : -total;
+  // Negating zero yields -0, which is === 0 but not Object.is-equal to it and
+  // would serialize as "-0". Normalize it away.
+  return minutes === 0 ? 0 : minutes;
+}
+
+/** Minutes-before → a TRIGGER duration. */
+export function formatTrigger(minutesBefore: number): string {
+  const sign = minutesBefore >= 0 ? "-" : "";
+  const abs = Math.abs(minutesBefore);
+  if (abs === 0) return "PT0S";
+  const days = Math.floor(abs / 1440);
+  const hours = Math.floor((abs % 1440) / 60);
+  const mins = abs % 60;
+  let out = sign + "P";
+  if (days) out += `${days}D`;
+  if (hours || mins) {
+    out += "T";
+    if (hours) out += `${hours}H`;
+    if (mins) out += `${mins}M`;
+  }
+  return out;
+}
+
+// ── Parse ───────────────────────────────────────────────────────────────────
+
+export interface ParsedIcs {
+  events: Omit<CalendarEvent, "id" | "calendar_id">[];
+  tasks: Omit<CalendarTask, "id" | "calendar_id">[];
+  /** Components that could not be understood, for a "skipped N" report. */
+  skipped: number;
+}
+
+const STATUSES: Record<string, EventStatus> = {
+  CONFIRMED: "confirmed",
+  TENTATIVE: "tentative",
+  CANCELLED: "cancelled",
+};
+
+/**
+ * Parse an .ics file into events and tasks.
+ *
+ * Unknown components (VTIMEZONE, VFREEBUSY, VJOURNAL) and unparseable ones are
+ * skipped and counted, never guessed at — a partial import that reports what it
+ * dropped beats one that invents data.
+ */
+export function parseIcs(text: string): ParsedIcs {
+  const lines = unfold(text);
+  const events: ParsedIcs["events"] = [];
+  const tasks: ParsedIcs["tasks"] = [];
+  let skipped = 0;
+
+  // The component stack; only VEVENT/VTODO (and a VALARM inside one) are entered.
+  let mode: "none" | "event" | "todo" = "none";
+  let inAlarm = false;
+  let cur: Record<string, Line[]> = {};
+  let alarms: Alarm[] = [];
+  let alarmTrigger: number | null = null;
+
+  const reset = () => {
+    cur = {};
+    alarms = [];
+    inAlarm = false;
+    alarmTrigger = null;
+  };
+
+  const first = (name: string): Line | undefined => cur[name]?.[0];
+  const val = (name: string): string =>
+    first(name) ? unescapeText(first(name)!.value) : "";
+
+  for (const raw of lines) {
+    const line = parseLine(raw);
+    if (!line) continue;
+
+    if (line.name === "BEGIN") {
+      const comp = line.value.toUpperCase();
+      if (comp === "VEVENT") {
+        mode = "event";
+        reset();
+      } else if (comp === "VTODO") {
+        mode = "todo";
+        reset();
+      } else if (comp === "VALARM" && mode !== "none") {
+        inAlarm = true;
+        alarmTrigger = null;
+      }
+      continue;
+    }
+
+    if (line.name === "END") {
+      const comp = line.value.toUpperCase();
+
+      if (comp === "VALARM" && inAlarm) {
+        if (alarmTrigger !== null) alarms.push({ minutes_before: alarmTrigger });
+        inAlarm = false;
+        continue;
+      }
+
+      if (comp === "VEVENT" && mode === "event") {
+        const event = buildEvent(cur, alarms, val);
+        if (event) events.push(event);
+        else skipped++;
+        mode = "none";
+        reset();
+        continue;
+      }
+
+      if (comp === "VTODO" && mode === "todo") {
+        const task = buildTask(cur, alarms, val);
+        if (task) tasks.push(task);
+        else skipped++;
+        mode = "none";
+        reset();
+        continue;
+      }
+      continue;
+    }
+
+    if (mode === "none") continue;
+
+    if (inAlarm) {
+      if (line.name === "TRIGGER") alarmTrigger = parseTrigger(line.value);
+      continue;
+    }
+
+    (cur[line.name] ??= []).push(line);
+  }
+
+  return { events, tasks, skipped };
+}
+
+function buildEvent(
+  cur: Record<string, Line[]>,
+  alarms: Alarm[],
+  val: (n: string) => string,
+): Omit<CalendarEvent, "id" | "calendar_id"> | null {
+  const dtstart = cur.DTSTART?.[0];
+  if (!dtstart) return null;
+  const start = parseIcsDate(dtstart.value);
+  if (!start) return null;
+
+  const allDay =
+    start.dateOnly || (dtstart.params.VALUE ?? "").toUpperCase() === "DATE";
+
+  // DTEND is exclusive in ICS, exactly as we store it. A missing DTEND means a
+  // DURATION or a default: an all-day event is one day, a timed one an hour.
+  let end: string;
+  const dtend = cur.DTEND?.[0];
+  const parsedEnd = dtend ? parseIcsDate(dtend.value) : null;
+  if (parsedEnd) {
+    end = parsedEnd.stamp;
+  } else if (allDay) {
+    end = addDays(start.stamp, 1);
+  } else {
+    const c = parseStamp(start.stamp)!;
+    const mins = c.hour * 60 + c.minute + 60;
+    const p = (n: number) => String(n).padStart(2, "0");
+    end = `${addDays(datePart(start.stamp), Math.floor(mins / 1440))}T${p(Math.floor((mins % 1440) / 60))}:${p(mins % 60)}`;
+  }
+
+  const exdates: string[] = [];
+  for (const line of cur.EXDATE ?? []) {
+    for (const piece of line.value.split(",")) {
+      const d = parseIcsDate(piece);
+      if (d) exdates.push(d.stamp);
+    }
+  }
+
+  const rruleLine = cur.RRULE?.[0];
+  const rrule = rruleLine ? parseRrule(rruleLine.value) : null;
+
+  return {
+    start: start.stamp,
+    end,
+    all_day: allDay,
+    title: val("SUMMARY"),
+    location: val("LOCATION"),
+    notes: val("DESCRIPTION"),
+    // ICS allows several categories; the model holds one, so the first wins.
+    category: (val("CATEGORIES").split(",")[0] ?? "").trim().toLowerCase(),
+    status: STATUSES[val("STATUS").toUpperCase()] ?? "",
+    rrule,
+    exdates,
+    overrides: [],
+    alarms,
+  };
+}
+
+function buildTask(
+  cur: Record<string, Line[]>,
+  alarms: Alarm[],
+  val: (n: string) => string,
+): Omit<CalendarTask, "id" | "calendar_id"> | null {
+  const summary = val("SUMMARY");
+  if (!summary) return null;
+
+  const due = cur.DUE?.[0] ? parseIcsDate(cur.DUE[0].value) : null;
+  const start = cur.DTSTART?.[0] ? parseIcsDate(cur.DTSTART[0].value) : null;
+  const completed = cur.COMPLETED?.[0] ? parseIcsDate(cur.COMPLETED[0].value) : null;
+
+  const percentRaw = Number(val("PERCENT-COMPLETE"));
+  const status = val("STATUS").toUpperCase();
+  const percent = Number.isFinite(percentRaw)
+    ? Math.max(0, Math.min(100, percentRaw))
+    : status === "COMPLETED"
+      ? 100
+      : 0;
+
+  const priorityRaw = Number(val("PRIORITY"));
+
+  return {
+    title: summary,
+    notes: val("DESCRIPTION"),
+    due: due?.stamp ?? null,
+    start: start?.stamp ?? null,
+    priority: Number.isFinite(priorityRaw) ? Math.max(0, Math.min(9, priorityRaw)) : 0,
+    // A COMPLETED stamp means done, whatever PERCENT-COMPLETE claims.
+    percent: completed ? 100 : percent,
+    completed: completed?.stamp ?? (status === "COMPLETED" ? datePart(new Date().toISOString()) : null),
+    category: (val("CATEGORIES").split(",")[0] ?? "").trim().toLowerCase(),
+    alarms,
+  };
+}
+
+// ── Serialize ───────────────────────────────────────────────────────────────
+
+/**
+ * Write events and tasks as an .ics file.
+ *
+ * `now` is injected rather than read from the clock so the output is
+ * deterministic and the round-trip is testable.
+ */
+export function serializeIcs(
+  events: CalendarEvent[],
+  tasks: CalendarTask[] = [],
+  now: Date = new Date(),
+): string {
+  const stamp = icsNowUtc(now);
+  const lines: string[] = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Eldrun//Calendar//EN",
+    "CALSCALE:GREGORIAN",
+  ];
+
+  const push = (name: string, value: string) => lines.push(fold(`${name}:${value}`));
+
+  for (const e of events) {
+    lines.push("BEGIN:VEVENT");
+    push("UID", `${e.id}@eldrun`);
+    push("DTSTAMP", stamp);
+    lines.push(
+      fold(
+        e.all_day
+          ? `DTSTART;VALUE=DATE:${formatIcsDate(e.start, true)}`
+          : `DTSTART:${formatIcsDate(e.start, false)}`,
+      ),
+    );
+    lines.push(
+      fold(
+        e.all_day
+          ? `DTEND;VALUE=DATE:${formatIcsDate(e.end, true)}`
+          : `DTEND:${formatIcsDate(e.end, false)}`,
+      ),
+    );
+    push("SUMMARY", escapeText(e.title));
+    if (e.location) push("LOCATION", escapeText(e.location));
+    if (e.notes) push("DESCRIPTION", escapeText(e.notes));
+    if (e.category) push("CATEGORIES", escapeText(e.category));
+    if (e.status) push("STATUS", e.status.toUpperCase());
+    if (e.rrule) push("RRULE", formatRrule(e.rrule));
+    for (const ex of e.exdates ?? []) {
+      lines.push(
+        fold(
+          e.all_day
+            ? `EXDATE;VALUE=DATE:${formatIcsDate(ex, true)}`
+            : `EXDATE:${formatIcsDate(ex, false)}`,
+        ),
+      );
+    }
+    for (const alarm of e.alarms ?? []) {
+      lines.push("BEGIN:VALARM");
+      push("ACTION", "DISPLAY");
+      push("DESCRIPTION", escapeText(e.title));
+      push("TRIGGER", formatTrigger(alarm.minutes_before));
+      lines.push("END:VALARM");
+    }
+    lines.push("END:VEVENT");
+  }
+
+  for (const t of tasks) {
+    lines.push("BEGIN:VTODO");
+    push("UID", `${t.id}@eldrun`);
+    push("DTSTAMP", stamp);
+    push("SUMMARY", escapeText(t.title));
+    if (t.notes) push("DESCRIPTION", escapeText(t.notes));
+    if (t.start) push("DTSTART", formatIcsDate(t.start, !t.start.includes("T")));
+    if (t.due) push("DUE", formatIcsDate(t.due, !t.due.includes("T")));
+    if (t.priority) push("PRIORITY", String(t.priority));
+    if (t.percent) push("PERCENT-COMPLETE", String(t.percent));
+    if (t.percent >= 100) push("STATUS", "COMPLETED");
+    if (t.completed) push("COMPLETED", formatIcsDate(t.completed, false));
+    if (t.category) push("CATEGORIES", escapeText(t.category));
+    for (const alarm of t.alarms ?? []) {
+      lines.push("BEGIN:VALARM");
+      push("ACTION", "DISPLAY");
+      push("DESCRIPTION", escapeText(t.title));
+      push("TRIGGER", formatTrigger(alarm.minutes_before));
+      lines.push("END:VALARM");
+    }
+    lines.push("END:VTODO");
+  }
+
+  lines.push("END:VCALENDAR");
+  return lines.join("\r\n") + "\r\n";
+}
diff --git a/src/lib/installCommand.ts b/src/lib/installCommand.ts
new file mode 100644
index 0000000..41af382
--- /dev/null
+++ b/src/lib/installCommand.ts
@@ -0,0 +1,85 @@
+import { useTabsStore } from "../stores/tabs";
+import { useProjectsStore } from "../stores/projects";
+import { IS_WINDOWS, IS_MAC } from "./platform";
+
+/** A supported git-hosting provider, as chosen in the fork-import dropdown and
+ *  the publish-to-GitHub/GitLab dialog. */
+export type GitHostProvider = "github" | "gitlab";
+
+/** OS-appropriate install command for a hosting provider's own CLI — the tool
+ *  that actually talks to the host's API (`gh repo`/`glab repo`, forking,
+ *  publishing), which plain `git` cannot do. Shared by the fork-import banner
+ *  (`ProjectDialog`) and the publish banner (`ProjectPill`'s `PublishWindow`)
+ *  so the two don't carry separate copies that can drift. */
+export const PROVIDER_CLI_INSTALL: Record<GitHostProvider, { bin: string; cmd: string }> = {
+  github: {
+    bin: "gh",
+    cmd: IS_WINDOWS
+      ? "winget install --id GitHub.cli -e --source winget"
+      : IS_MAC
+        ? "brew install gh"
+        : "sudo apt-get install -y gh",
+  },
+  gitlab: {
+    bin: "glab",
+    cmd: IS_WINDOWS
+      ? "winget install --id GitLab.GLab -e --source winget"
+      : IS_MAC
+        ? "brew install glab"
+        : "sudo apt-get install -y glab",
+  },
+};
+
+/** The CLI's own sign-in command. Run in a visible terminal (via
+ *  `runInstallInTab`) rather than headlessly — both `gh auth login` and `glab
+ *  auth login` are interactive (a browser handoff, or a pasted one-time code). */
+export function providerAuthLoginCmd(provider: GitHostProvider): string {
+  return provider === "gitlab" ? "glab auth login" : "gh auth login";
+}
+
+/**
+ * One-click "install in a terminal tab" helper.
+ *
+ * Eldrun's policy is that any install-via-command flow (Ollama models, agent
+ * CLIs, and external tools like a LaTeX/TeX distribution or sshfs) must be a
+ * single click that opens a fresh terminal tab and *runs* the command — never a
+ * "copy this command and run it yourself" manual step.
+ *
+ * The command is typed into the freshly-spawned shell via the tab's
+ * `initialInput`; `TerminalView` submits it with a trailing CR once the shell is
+ * ready, so the install actually executes. Interactive prompts (a `sudo`
+ * password, MiKTeX's installer, etc.) are answered directly in that visible
+ * terminal — Eldrun never has to handle them.
+ *
+ * The tab opens in the **root** scope (installs are machine-global, not project
+ * scoped). The active project is deliberately left unchanged — switching scope
+ * from a settings click would be jarring — so a brief toast points the user at
+ * the root terminal where the install is running.
+ */
+export type InstallShellKind = "bash" | "powershell" | "default";
+
+/** Explicit terminal program for an installer shell. Shell-specific syntax must
+ * never be submitted to the host's unrelated default shell. */
+export function installShellCommand(shellKind: InstallShellKind): string {
+  if (shellKind === "bash") return "/bin/bash";
+  if (shellKind === "powershell") return "powershell.exe";
+  return "";
+}
+
+export function runInstallInTab(
+  label: string,
+  command: string,
+  shellKind: InstallShellKind,
+): void {
+  const rootDir = useProjectsStore.getState().rootDir ?? "";
+  useTabsStore.getState().addTabToScope("root", {
+    label,
+    cmd: installShellCommand(shellKind),
+    cwd: rootDir, // empty resolves to ~/eldrun/root on the backend
+    kind: "shell",
+    initialInput: command,
+  });
+  useProjectsStore.setState({
+    switchToast: `Installing ${label} — running in the root terminal`,
+  });
+}
diff --git a/src/lib/keyring.ts b/src/lib/keyring.ts
new file mode 100644
index 0000000..2ce811e
--- /dev/null
+++ b/src/lib/keyring.ts
@@ -0,0 +1,37 @@
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * The OS credential store as a *thing with a state*, not just a place secrets go.
+ *
+ * Every "is this password saved?" in Eldrun is a keychain read, and on Linux a read
+ * against a **locked** Secret Service collection answers exactly like an empty one:
+ * nothing saved. So a user who ticked "Save password", connected, and restarted finds
+ * the box blank, no silent connect, and no explanation — the credential was there the
+ * whole time, behind a lock nothing in the UI ever mentioned.
+ *
+ * These two calls are what let a surface say that instead of guessing. Neither ever
+ * throws: an unreachable backend degrades to "locked", which is the state with an
+ * action behind it, rather than to a false "unlocked" that sends the caller back into
+ * the silent path that is already failing.
+ */
+export type KeyringState = "unlocked" | "locked" | "unavailable";
+
+/** The store's lock state. Never prompts — the backend probes with a zero-second
+ *  prompt timeout, so asking is always safe (including on a launch path). */
+export async function keyringState(): Promise<KeyringState> {
+  return invoke<KeyringState>("keyring_state").catch(() => "locked" as const);
+}
+
+/**
+ * Ask the OS to unlock the store, raising **its own** dialog. Resolves `true` once
+ * unlocked (including when it already was), `false` if the dialog was dismissed or
+ * there is no store at all.
+ *
+ * Only call this from an explicit user action. Auto-connect promises not to prompt,
+ * and a system unlock dialog during startup is still a prompt.
+ */
+export async function unlockKeyring(): Promise<boolean> {
+  return invoke("keyring_unlock")
+    .then(() => true)
+    .catch(() => false);
+}
diff --git a/src/lib/lessons.ts b/src/lib/lessons.ts
new file mode 100644
index 0000000..b53d4b8
--- /dev/null
+++ b/src/lib/lessons.ts
@@ -0,0 +1,1105 @@
+import type { TourStep } from "./tour";
+
+/**
+ * Task "lessons" — short, replayable narrated walkthroughs for specific jobs
+ * (add a project, install an agent, use a local model, …). Each lesson is a
+ * step list run through the same engine as the high-level tour (`TourHost` /
+ * `useTourStore.startLesson`), so it reuses the spotlight, click-blocking, and
+ * Back/Next navigation. Picked from the `LessonsMenu`.
+ *
+ * Most steps spotlight a persistent entry-point control (the + button, the gear,
+ * the 🧠 menu) by a verified selector; menu/dialog internals — which only exist
+ * while open and which the narrated, click-blocking overlay can't keep pinned —
+ * are described as centered cards (`anchor: null`). Copy matches the terse,
+ * friendly onboarding voice.
+ *
+ * Order is meaningful: lessons run easiest → hardest and are grouped into tiers
+ * (`LESSON_CATEGORIES`). `LESSONS` stays sorted so each category's lessons are
+ * contiguous and the picker can render a header per tier just by walking the
+ * array. Within a tier the lessons themselves also ramp from simplest to most
+ * involved.
+ */
+
+/** Difficulty tiers, in the order the picker shows them (easy → hard). */
+export const LESSON_CATEGORIES = ["Basics", "Agents & models", "Advanced"] as const;
+export type LessonCategory = (typeof LESSON_CATEGORIES)[number];
+
+export interface Lesson {
+  /** Stable id (also the React key in the picker). */
+  id: string;
+  /** Difficulty tier; groups the lesson under a header in the picker. */
+  category: LessonCategory;
+  /** Menu label. */
+  title: string;
+  /** One-line description shown under the title in the picker. */
+  blurb: string;
+  steps: TourStep[];
+}
+
+/** Reveal the right-side file panel so a step's anchor exists to spotlight.
+ *  AppShell listens for this (the panel is otherwise hover-revealed). */
+const revealFilePanel = () => window.dispatchEvent(new Event("eldrun:reveal-right-panel"));
+
+export const LESSONS: Lesson[] = [
+  // ── Basics ──────────────────────────────────────────────────────────────
+  {
+    id: "add-project",
+    category: "Basics",
+    title: "Add a new project",
+    blurb: "Create or import a project — each gets its own terminal, tabs, and file tree.",
+    steps: [
+      {
+        id: "pill-strip",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Your projects live here",
+        body: "Every active project shows up as a pill in this strip. Click one to switch to it — each project keeps its own terminal, tabs, and file tree.",
+      },
+      {
+        id: "add-button",
+        anchor: '[data-hint-anchor="add-project"]',
+        placement: "bottom",
+        title: "The + button",
+        body: "Click + to open the add menu. It's your single entry point for starting a brand-new project, importing an existing folder, or grouping projects into a box.",
+      },
+      {
+        id: "add-menu",
+        anchor: null,
+        placement: "bottom",
+        title: "New, Import, or Box",
+        body: "The menu offers New Project (scaffold a fresh project), Import Project (register a folder you already have), and New Box (a meta-group for related pills). Pick New Project.",
+      },
+      {
+        id: "new-dialog",
+        anchor: null,
+        placement: "bottom",
+        title: "Fill in the details",
+        body: "The New Project dialog asks for a name and an optional description, and lets you pick a Git hosting option (no git, a local-only repo, or push to GitHub/GitLab as private or public). Flip the \"Remote (SSH) project\" toggle to host it on another machine instead.",
+      },
+      {
+        id: "scaffold-create",
+        anchor: null,
+        placement: "bottom",
+        title: "What you get",
+        body: "Hit Create and Eldrun makes the project folder under your projects directory (~/eldrun/projects by default — the Location picker changes it), scaffolds AGENTS.md, CLAUDE.md, .gitignore, README and friends, and initializes the repo. Tick \"Skip scaffolding\" if you'd rather start empty.",
+      },
+      {
+        id: "publish-remote",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Advanced: connect a remote",
+        body: "To put it on GitHub or GitLab, pick a \"Push to GitHub/GitLab\" hosting option in the dialog — or later, right-click the project's pill → \"Publish to GitHub / GitLab…\", choose the provider and public/private. Eldrun runs that provider's CLI (gh or glab) to create the repo and push. Needs the chosen CLI installed and signed in, or a token under ⚙ Settings → Git Hosting.",
+      },
+    ],
+  },
+  {
+    id: "import-project",
+    category: "Basics",
+    title: "Import a project",
+    blurb: "Register an existing folder — or a remote SSH host — without touching its contents.",
+    steps: [
+      {
+        id: "open-add-menu",
+        anchor: '[data-hint-anchor="add-project"]',
+        placement: "top",
+        title: "Open the add menu",
+        body: "Click the + button beside your project pills. It opens a small menu with New Project, Import Project, and New Box.",
+      },
+      {
+        id: "pick-import",
+        anchor: null,
+        placement: "bottom",
+        title: "Choose \"Import Project\"",
+        body: "Pick Import Project from that menu. A centered dialog opens for registering a folder you already have.",
+      },
+      {
+        id: "browse-folder",
+        anchor: null,
+        placement: "bottom",
+        title: "Point at your folder",
+        body: "Under Source folder, hit Browse… and select the existing project directory. Eldrun reads it in place and does not modify its contents.",
+      },
+      {
+        id: "import-mode",
+        anchor: null,
+        placement: "bottom",
+        title: "Keep, copy, or move",
+        body: "Import mode lets you keep the folder where it is, or copy/move it into Eldrun's projects folder. Set a name and a Git hosting option, then confirm to add the pill.",
+      },
+      {
+        id: "remote-import",
+        anchor: null,
+        placement: "bottom",
+        title: "Remote? Flip the SSH toggle",
+        body: "Tick \"Remote (SSH) project\" to import a folder living on another host. Eldrun pairs it with a synced local working copy: agent tabs work in the local copy by default, while shells, file browsing, and git reach the host over SSH/SFTP (with an optional OpenVPN step). No local mount needed.",
+      },
+      {
+        id: "publish-remote",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Advanced: connect a remote",
+        body: "Imported a folder that isn't on a remote yet? Right-click its pill → \"Publish to GitHub / GitLab…\", choose the provider and public/private, and Eldrun runs that provider's CLI (gh or glab) to create the repo and push your code. Needs the chosen CLI installed and authenticated, or a token under ⚙ Settings → Git Hosting.",
+      },
+    ],
+  },
+  {
+    id: "add-tab",
+    category: "Basics",
+    title: "Add a tab",
+    blurb: "Open a new agent, shell, or file-browser tab in any subwindow.",
+    steps: [
+      {
+        id: "find-plus",
+        anchor: '[data-hint-anchor="tab-add"]',
+        placement: "bottom",
+        title: "The + button",
+        body: "Every tab bar ends with a + button. Click it to open the new-tab menu for that subwindow.",
+      },
+      {
+        id: "the-menu",
+        anchor: null,
+        placement: "bottom",
+        title: "Pick what to open",
+        body: "The menu groups your choices: an Agents section (Claude, Codex, Gemini and any other installed CLIs), a Local Model section (your set on-device model), Shell and Files, a Monitoring section (Disk Usage, Network Traffic), and Calendar.",
+      },
+      {
+        id: "shell-files",
+        anchor: null,
+        placement: "bottom",
+        title: "Shell, Files & more",
+        body: "Choose Shell for a plain terminal in the project folder, or Files for an in-app file browser. The same menu also opens a Disk Usage or Network Traffic monitor and a Calendar. The new tab opens focused in this subwindow.",
+      },
+      {
+        id: "rename-close",
+        anchor: null,
+        placement: "bottom",
+        title: "Rename, close, reopen",
+        body: "Right-click a tab for its menu — Rename, Close, Close others, or close everything to one side. Shift+right-click renames inline straight away; the × on a tab closes it. Reopening a closed agent respawns it fresh from the same + menu.",
+      },
+    ],
+  },
+  {
+    id: "native-viewer",
+    category: "Basics",
+    title: "Open a file in the viewer",
+    blurb: "Reveal the file tree and open files in Eldrun's built-in viewers — no external app.",
+    steps: [
+      {
+        id: "reveal-tree",
+        anchor: '[data-hint-anchor="file-tree-edge"]',
+        placement: "left",
+        title: "Reveal the file tree",
+        body: "Push your cursor to the right edge of the window to slide out the project file tree.",
+        prepare: revealFilePanel,
+      },
+      {
+        id: "pin-panel",
+        anchor: ".right-panel-pin",
+        placement: "left",
+        title: "Pin it open",
+        body: "The panel auto-hides when your cursor leaves. Click the 📌 to keep it docked while you browse.",
+        prepare: revealFilePanel,
+      },
+      {
+        id: "open-file",
+        anchor: null,
+        placement: "bottom",
+        title: "Double-click a file",
+        body: "Double-click any file to open it; single-click a folder to step into it. You can also drag a file onto a tab bar to open it there.",
+      },
+      {
+        id: "viewer-pane",
+        anchor: null,
+        placement: "bottom",
+        title: "It opens in-app",
+        body: "PDFs, images (and GIFs), markdown, code, notebooks, YAML/JSON, tables and spreadsheets, diffs, audio/video, and TeX render in Eldrun's native viewer — no external app. The built-in viewer wins whenever one applies.",
+      },
+      {
+        id: "default-app",
+        anchor: null,
+        placement: "bottom",
+        title: "Change the handler",
+        body: "Right-click a file → \"Set default app…\" to send a type to an external app instead. Toggle native viewers per type under the file panel's own ⚙ (Project settings → Native Viewers).",
+      },
+    ],
+  },
+  {
+    id: "arrange-tabs",
+    category: "Basics",
+    title: "Arrange tabs",
+    blurb: "Reorder tabs, split panes, drag files in from the tree, and pop tabs into their own window.",
+    steps: [
+      {
+        id: "intro",
+        anchor: null,
+        placement: "bottom",
+        title: "Make room your way",
+        body: "Drag to arrange everything: reorder tabs, split the view, pull files in from the file tree, and pop panes out into their own windows. Let's walk through it.",
+      },
+      {
+        id: "tab-bar",
+        anchor: ".tab-bar",
+        placement: "bottom",
+        title: "The tab bar",
+        body: "Each subwindow has its own tab strip. Drag a tab left or right within this bar to reorder it.",
+      },
+      {
+        id: "split",
+        anchor: null,
+        placement: "bottom",
+        title: "Split a pane",
+        body: "Drag a tab onto the edge of a pane — top, bottom, left, or right — to split the view and tile it side-by-side or stacked. Drop it in the middle instead to move it into that group.",
+      },
+      {
+        id: "drag-from-tree",
+        anchor: '[data-hint-anchor="file-tree-edge"]',
+        placement: "left",
+        title: "Drag a file in from the tree",
+        body: "Slide out the file tree on the right and drag an openable file straight into the layout — drop it on a tab bar to add it there, on a pane edge to split, or in a pane's center to merge. It opens right where you drop it.",
+        prepare: revealFilePanel,
+      },
+      {
+        id: "detach",
+        anchor: null,
+        placement: "bottom",
+        title: "Pop out a window",
+        body: "Drag a tab (or a whole tab bar) out of the app to detach it into its own floating OS window. Drag it back over Eldrun to dock it again.",
+      },
+      {
+        id: "drag-to-detached",
+        anchor: null,
+        placement: "bottom",
+        title: "Drop across windows",
+        body: "That same drag reaches popped-out windows: drag a tab — or a file from the tree — onto a detached window that's in front and it docks there. Release over empty desktop instead to open it in a brand-new window.",
+      },
+      {
+        id: "outro",
+        anchor: null,
+        placement: "bottom",
+        title: "That's it",
+        body: "Reorder within a bar, drop on an edge to split or a center to merge, pull files in from the tree, and drag tabs out to detach or onto another window. Rearrange freely — your layout is saved.",
+      },
+    ],
+  },
+  {
+    id: "yaml-viewer",
+    category: "Basics",
+    title: "Edit YAML & JSON visually",
+    blurb: "Open a config file as editable cards or a tree — comments and formatting survive every edit.",
+    steps: [
+      {
+        id: "open-yaml",
+        anchor: null,
+        placement: "bottom",
+        title: "Open a .yaml, .yml, or .json file",
+        body: "Double-click any YAML or JSON file in the tree. Instead of raw text, it opens in a structured viewer that understands the file's shape — while still being the exact same file underneath.",
+      },
+      {
+        id: "three-views",
+        anchor: null,
+        placement: "bottom",
+        title: "Cards, Tree, or Source",
+        body: "The toolbar offers three views of the same file. Cards (the default) shows one level of the structure at a time as navigable cards; Tree shows the whole thing as nested, indented rows; Source is the raw text. Switch freely — they're three windows onto one document.",
+      },
+      {
+        id: "drill-cards",
+        anchor: null,
+        placement: "bottom",
+        title: "Drill through Cards",
+        body: "In Cards, each card shows its own scalar fields; click a card's title (or its \"N groups\" footer) to open it and reveal its nested collections as the next level down. A breadcrumb tracks where you are, and the current level's siblings let you step sideways without going up first.",
+      },
+      {
+        id: "edit-safely",
+        anchor: null,
+        placement: "bottom",
+        title: "Edits keep your comments",
+        body: "Change a value, add or delete a field, or drag a card's grip to reorder among its siblings — every action splices just that span of text, so your # comments, quoting style, and untouched lines stay byte-for-byte. It's an ordinary dirty/undo/save edit, and a comment travels with the key it describes.",
+      },
+      {
+        id: "copy-paste",
+        anchor: null,
+        placement: "bottom",
+        title: "Copy entries around",
+        body: "Each entry has a copy button feeding an app-wide buffer; a click-placed paste cursor drops it back in — but only where it fits (a mapping entry into a map, an item into a list), so a paste can never tear the file. Anything the viewer can't safely rewrite is shown read-only, never mangled.",
+      },
+    ],
+  },
+  {
+    id: "pdf-viewer",
+    category: "Basics",
+    title: "Read and reshape PDFs",
+    blurb: "Jump by chapter, then reorder, rotate, delete, and merge pages — nothing is written until you save.",
+    steps: [
+      {
+        id: "open-pdf",
+        anchor: null,
+        placement: "bottom",
+        title: "Open a PDF in-app",
+        body: "Double-click a PDF and it renders in Eldrun's own viewer — no external app — with a zoom, find, and print toolbar along the top and a thumbnail page rail down the side.",
+      },
+      {
+        id: "contents",
+        anchor: null,
+        placement: "bottom",
+        title: "The Contents sidebar",
+        body: "Click the ☰ at the far left of the toolbar to open Contents: the document's chapters and bookmarks. If a PDF has no embedded outline, Eldrun infers a heading tree from the text's typography instead. Click any entry to jump straight there.",
+      },
+      {
+        id: "page-tools",
+        anchor: null,
+        placement: "bottom",
+        title: "Rearrange pages",
+        body: "In the page rail you can drag pages to reorder them, shift-select a range, rotate, delete, or duplicate — and even pull pages between two open PDFs. The viewer shows an arrangement, not the file, so these are just moves you're staging.",
+      },
+      {
+        id: "save-pdf",
+        anchor: null,
+        placement: "bottom",
+        title: "Save writes the new file",
+        body: "Nothing touches the PDF on disk until you Save — only then is the rearranged document written out. Until then, undo/redo covers every page move, exactly like editing text.",
+      },
+      {
+        id: "synctex",
+        anchor: null,
+        placement: "bottom",
+        title: "TeX authors: SyncTeX",
+        body: "For a PDF built from LaTeX, the viewer supports SyncTeX both ways — click in the PDF to jump to the source line, and jump from the source to the page. Find and print work as you'd expect from the toolbar.",
+      },
+    ],
+  },
+  {
+    id: "run-python",
+    category: "Basics",
+    title: "Run and debug Python",
+    blurb: "Run or debug a .py file straight from the viewer — breakpoints, pdb, and go-to-definition included.",
+    steps: [
+      {
+        id: "open-py",
+        anchor: null,
+        placement: "bottom",
+        title: "Open a Python file",
+        body: "Open any .py file in the viewer. A small run bar appears with Run file and Debug file — no launch config to write.",
+      },
+      {
+        id: "run-file",
+        anchor: null,
+        placement: "bottom",
+        title: "Run file",
+        body: "Click Run file and Eldrun opens a terminal tab that runs it. Because it's a real tab, it inherits the project's locality for free — a remote SSH host or a Docker container — and stays fully interactive: input(), Ctrl+C, and output that survives after the process exits.",
+      },
+      {
+        id: "breakpoints",
+        anchor: null,
+        placement: "bottom",
+        title: "Set breakpoints in the gutter",
+        body: "Click the line-number gutter to drop a breakpoint. It snaps to the next executable line (pdb refuses blank or comment lines), and if you type above it the marker re-points so it always sits on the right statement.",
+      },
+      {
+        id: "debug-file",
+        anchor: null,
+        placement: "bottom",
+        title: "Debug file",
+        body: "Debug file launches the same terminal tab under pdb, pre-loaded with your gutter breakpoints and run to the first one. Step, inspect, and continue right there in the tab. (Debugging is behind the experimental flag — on by default in debug mode.)",
+      },
+      {
+        id: "go-to-def",
+        anchor: null,
+        placement: "bottom",
+        title: "Jump to a definition",
+        body: "Ctrl+click a name to go to where it's defined — Eldrun walks the import graph (relative imports, aliases, __init__ re-exports, src-layout). Only names it can actually follow are underlined, so the affordance never lies.",
+      },
+    ],
+  },
+  {
+    id: "file-search",
+    category: "Basics",
+    title: "Search inside your project",
+    blurb: "Find files by name or search their contents from the tree — every hit jumps and opens.",
+    steps: [
+      {
+        id: "reveal-tree",
+        anchor: '[data-hint-anchor="file-tree-edge"]',
+        placement: "left",
+        title: "Open the file tree",
+        body: "Push your cursor to the right edge of the window to slide out the file tree. Its search box sits at the top, above the listing.",
+        prepare: revealFilePanel,
+      },
+      {
+        id: "name-vs-content",
+        anchor: null,
+        placement: "bottom",
+        title: "Name or Content",
+        body: "Type in the box and pick a mode. Name matches a case-insensitive substring of file paths (basename hits rank first — deliberately not a fuzzy match that lights up everything). Content searches the actual lines inside your files, the same engine as the Search view.",
+      },
+      {
+        id: "jump-and-open",
+        anchor: null,
+        placement: "bottom",
+        title: "Every hit jumps and opens",
+        body: "Click a result to reveal and select it in the tree; a content hit also opens the file at the matched line. So search doubles as fast navigation, not just a lookup.",
+      },
+      {
+        id: "scope-root",
+        anchor: null,
+        placement: "bottom",
+        title: "This folder, or the whole project",
+        body: "By default the search is confined to the folder you're browsing. Flip the Root toggle to search the entire project instead. (It's local-source only — both modes walk the canonical local path.)",
+      },
+    ],
+  },
+  {
+    id: "calendar",
+    category: "Basics",
+    title: "Plan with the calendar",
+    blurb: "Open a calendar tab — drag to create events, set reminders, and import/export .ics.",
+    steps: [
+      {
+        id: "open-calendar",
+        anchor: '[data-hint-anchor="tab-add"]',
+        placement: "bottom",
+        title: "Open a Calendar tab",
+        body: "Click the + on any tab bar and pick Calendar (marked ◆). It opens a full calendar in that subwindow. Your calendars and events are global — one store shared across every project and box.",
+      },
+      {
+        id: "views",
+        anchor: null,
+        placement: "bottom",
+        title: "Day, Week, Month, Agenda, Tasks",
+        body: "The toolbar switches views: Day and Week hour grids, a Month (or multi-week) grid with spanning bars, a flat Agenda list of what's upcoming, and Tasks — your to-dos (VTODO). A search box and a mini-month sidebar help you jump around.",
+      },
+      {
+        id: "drag-create",
+        anchor: null,
+        placement: "bottom",
+        title: "Drag to create and adjust",
+        body: "In a Day/Week grid, drag across the hours to create an event, then drag its body to move it or its edge to resize. A now-line marks the current time. Everything is direct manipulation — no dialog needed to block out time.",
+      },
+      {
+        id: "event-editor",
+        anchor: null,
+        placement: "bottom",
+        title: "Repeats, reminders, categories",
+        body: "Double-click an event for the editor: set a recurrence rule, add reminders (which fire an OS notification and an in-app popup you can snooze), and tag it with a category color. Editing a repeating event asks whether you mean this occurrence or all of them.",
+      },
+      {
+        id: "ics",
+        anchor: null,
+        placement: "bottom",
+        title: "Import & export .ics",
+        body: "The toolbar imports and exports iCalendar (.ics) — VEVENT, VTODO, VALARM and RRULE all round-trip — so you can pull in an existing calendar or hand one off to another app.",
+      },
+    ],
+  },
+  {
+    id: "usage-recap",
+    category: "Basics",
+    title: "See your usage recap",
+    blurb: "A private daily summary: agents used, prompts asked, file churn, commits, and time per project.",
+    steps: [
+      {
+        id: "what-it-is",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "A recap of your day",
+        body: "Eldrun keeps a rolling, local-only tally of how you worked: which agents and local models you used, how many prompts and shell commands you ran, files created/modified/deleted, tabs opened, plus commits and time per project pulled from their sources.",
+      },
+      {
+        id: "when-it-opens",
+        anchor: null,
+        placement: "bottom",
+        title: "It pops up once a day",
+        body: "By default the recap for the day just finished appears on your first launch each day. It's a summary popup — you can read it and dismiss it. Everything it shows was counted locally; nothing leaves your machine.",
+      },
+      {
+        id: "windows",
+        anchor: null,
+        placement: "bottom",
+        title: "Day, week, month",
+        body: "Inside the recap you can switch between This day, This week, and This month to zoom out from a single day's activity to longer trends across all your projects.",
+      },
+      {
+        id: "open-anytime",
+        anchor: '[data-hint-anchor="settings"]',
+        placement: "bottom",
+        title: "Open it any time — or turn it off",
+        body: "Don't want to wait for tomorrow's launch? Open ⚙ Settings → Usage stats → \"Open usage stats\". The same panel has \"Show the recap at the start of each day\" — turning it off stops the popup, not the counting.",
+      },
+    ],
+  },
+
+  // ── Agents & models ─────────────────────────────────────────────────────
+  {
+    id: "install-agent",
+    category: "Agents & models",
+    title: "Choose an AI agent",
+    blurb: "Pick an AI coding agent for a tab, and install its CLI so it shows up.",
+    steps: [
+      {
+        id: "open-add-menu",
+        anchor: '[data-hint-anchor="tab-add"]',
+        placement: "bottom",
+        title: "Add an agent tab",
+        body: "The + button on any tab bar opens the add menu. That's where you pick which AI agent to launch in a new tab.",
+      },
+      {
+        id: "pick-from-list",
+        anchor: null,
+        placement: "bottom",
+        title: "Pick an agent",
+        body: "The menu lists agents like Claude, Codex, Gemini, Mistral, Aider, OpenCode, Cursor, Copilot, Grok, Qwen, and OpenClaw. Click one to spawn a tab running that agent in the project folder.",
+      },
+      {
+        id: "only-installed",
+        anchor: null,
+        placement: "bottom",
+        title: "Only installed agents appear",
+        body: "The menu hides any agent whose CLI isn't on your system — Eldrun probes each one's command first. If yours is missing, you just need to install it.",
+      },
+      {
+        id: "manage-agents",
+        anchor: '[data-hint-anchor="settings"]',
+        placement: "bottom",
+        title: "Install a missing agent",
+        body: "Open ⚙ → Manage Agents to install an agent CLI with one click (the installer's output streams right there), or run its vendor command in a terminal tab. Most CLIs need npm — the panel offers to install Node.js first if it's missing. The agent then appears in the + menu.",
+      },
+      {
+        id: "set-default",
+        anchor: '[data-hint-anchor="settings"]',
+        placement: "bottom",
+        title: "Agents come back after a relaunch",
+        body: "Shell and Files tabs are always restored when Eldrun relaunches. Claude and Codex agent tabs are restored too — they resume their previous conversation. Other agents start fresh from the + menu.",
+      },
+    ],
+  },
+  {
+    id: "local-model",
+    category: "Agents & models",
+    title: "Models & agents",
+    blurb: "The 🧠 menu hubs your on-device Ollama models and your installed AI agents.",
+    steps: [
+      {
+        id: "brain-button",
+        anchor: '[aria-label="Local model"]',
+        placement: "bottom",
+        title: "The model & agent menu",
+        body: "This 🧠 button is your model-and-agent hub: loaded and installed local (Ollama) models up top — those run on-device, nothing leaves your machine — and your installed AI agents below. Hover it to open; if Ollama isn't installed yet it offers \"Install Ollama…\".",
+      },
+      {
+        id: "pick-default",
+        anchor: null,
+        placement: "bottom",
+        title: "Pick a model",
+        body: "Models loaded in memory show a green lamp. Click a model's name to make it your default local model; models on disk can be loaded into memory from the same list.",
+      },
+      {
+        id: "role-chips",
+        anchor: null,
+        placement: "bottom",
+        title: "Assign tasks",
+        body: "Tag a loaded model with the Autocomplete, Grammar, or Tabs chips to pin it to that job. Several models can each own a different task; load just one and it auto-handles everything.",
+      },
+      {
+        id: "manage-models",
+        anchor: '[data-hint-anchor="settings"]',
+        placement: "bottom",
+        title: "Manage models",
+        body: "\"Manage local models…\" (or the gear → Settings → Ollama) is where you pull new models, watch download progress, and delete ones you no longer need.",
+      },
+      {
+        id: "agents-section",
+        anchor: null,
+        placement: "bottom",
+        title: "Agents live here too",
+        body: "Below the models, the Agents section lists every AI agent CLI Eldrun detected (a green lamp means it's installed). \"Manage agents…\" installs missing ones — the same agents you then launch from any tab's + menu.",
+      },
+      {
+        id: "use-autocomplete",
+        anchor: null,
+        placement: "bottom",
+        title: "Use it while editing",
+        body: "In native file viewers, ghost-text suggestions appear when you pause typing — or press Ctrl+Space to ask directly. Tab accepts the whole suggestion, → takes just the next word, Shift+Tab cycles the completion length (sentence → block → scope). It's opt-in per file type (a privacy gate).",
+      },
+    ],
+  },
+  {
+    id: "add-local-model",
+    category: "Agents & models",
+    title: "Add a local model or agent",
+    blurb: "Pull an on-device Ollama model, or install an AI agent CLI so it shows up.",
+    steps: [
+      {
+        id: "open-brain",
+        anchor: '[aria-label="Local model"]',
+        placement: "bottom",
+        title: "Open the 🧠 menu",
+        body: "This button is your model-and-agent hub. Hover it to open. Local (Ollama) models run on-device — nothing leaves your machine — and your installed agent CLIs are listed below them.",
+      },
+      {
+        id: "manage-models",
+        anchor: null,
+        placement: "bottom",
+        title: "Manage local models…",
+        body: "Click \"Manage local models…\" at the bottom of the menu (it reads \"Install Ollama…\" instead if Ollama isn't on your system yet — install that first). It opens the Ollama panel under ⚙ Settings.",
+      },
+      {
+        id: "pull-from-catalog",
+        anchor: null,
+        placement: "bottom",
+        title: "Pull a model",
+        body: "Browse the catalog, sort by size or popularity, and hit Pull on one you want. A progress bar tracks the download — you can pause and resume it, and the model loads into the 🧠 menu when it's done.",
+      },
+      {
+        id: "pull-by-name",
+        anchor: null,
+        placement: "bottom",
+        title: "Or pull any model by name",
+        body: "Not in the catalog? Type any Ollama registry ref (e.g. qwen2.5-coder:7b) into the free-text pull field and confirm. Eldrun fetches it the same way.",
+      },
+      {
+        id: "manage-agents",
+        anchor: '[data-hint-anchor="settings"]',
+        placement: "bottom",
+        title: "Add an AI agent instead",
+        body: "Back in the 🧠 menu, \"Manage agents…\" (or ⚙ → Manage Agents) one-click-installs an agent CLI — Claude, Codex, Gemini and friends — or runs its vendor command in a terminal tab. Installed agents then appear in any tab's + menu.",
+      },
+    ],
+  },
+
+  // ── Advanced ────────────────────────────────────────────────────────────
+  {
+    id: "project-boxes",
+    category: "Advanced",
+    title: "Group projects into a box",
+    blurb: "Bundle related projects under one box pill — drag them in, switch between them, open the box scope.",
+    steps: [
+      {
+        id: "why-boxes",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "When pills pile up",
+        body: "Once you have a lot of projects, this strip gets crowded. A box is a single pill that meta-groups related projects together so the strip stays tidy.",
+      },
+      {
+        id: "new-box",
+        anchor: '[data-hint-anchor="add-project"]',
+        placement: "bottom",
+        title: "Create a box",
+        body: "Click + beside your pills and pick New Box from the menu. Give it a name — an empty box pill (marked ▣) appears in the strip with a member count of 0.",
+      },
+      {
+        id: "assign-members",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Drag projects in",
+        body: "Drag any project pill onto the box pill to add it as a member; the count badge ticks up. The same drag that reorders pills assigns them — drop on the box instead of the strip. Shortcut: Alt-drag one pill onto another to box the two together in one move.",
+      },
+      {
+        id: "box-dropdown",
+        anchor: null,
+        placement: "bottom",
+        title: "Hover to see inside",
+        body: "Hover the box pill to drop down its member list. Click a member to switch straight to it, or hit the × beside one to ungroup it (the project stays, it just leaves the box).",
+      },
+      {
+        id: "box-scope",
+        anchor: null,
+        placement: "bottom",
+        title: "Open, rename, delete",
+        body: "Click the box pill itself to open the box scope, like opening a project. Right-click it for Open, Rename, or Delete — deleting a box never deletes its projects, only the grouping.",
+      },
+    ],
+  },
+  {
+    id: "docker-sandbox",
+    category: "Advanced",
+    title: "Run a project in a container",
+    blurb: "Confine a whole project's shells and agents to one closed Docker container — the folder stays on the host.",
+    steps: [
+      {
+        id: "why-sandbox",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Box the whole project in",
+        body: "By default a project's tabs run on your host with your full filesystem in reach. Turn on the container and every shell and agent tab of that project runs inside one closed, capability-dropped Docker container instead — so a misbehaving command or agent can't wander into unrelated host files. The project folder itself stays on the host, bind-mounted into the container at its exact same absolute path.",
+      },
+      {
+        id: "open-pill-menu",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Right-click the project pill",
+        body: "The toggle is per-project. Right-click the pill of the project you want to contain to open its context menu. (Offered for local projects only, and hidden on Windows.)",
+      },
+      {
+        id: "flip-toggle",
+        anchor: null,
+        placement: "bottom",
+        title: "\"Run this project in a container\"",
+        body: "Click \"Run this project in a container\"; a ✓ appears once it's on, and clicking again turns it back off. Flipping it respawns every live tab into (or out of) the container — the pill warns first if that would drop a non-resumable agent conversation. Because the folder never moves, the file tree, git, viewers, and agent resume all keep working across the flip.",
+      },
+      {
+        id: "image",
+        anchor: null,
+        placement: "bottom",
+        title: "The image (auto-adopted or built)",
+        body: "The first time you enable it, Eldrun adopts an in-repo Dockerfile or devcontainer image if there is one. If the image is missing, it opens a one-click build tab rather than failing silently. \"Container settings…\" in the same menu tunes the image, network, memory/CPU caps, and read-only rootfs — and those knobs survive turning the container off and on.",
+      },
+      {
+        id: "lifetime",
+        anchor: null,
+        placement: "bottom",
+        title: "One container, project-lived",
+        body: "There's a single container per project (named eldrun-<id>), created when the project activates and removed when it deactivates — unless tabs are still live in it — then swept at startup. Shells and agents docker exec into it; only a local-agent tab deliberately stays on the host. Needs Docker installed.",
+      },
+    ],
+  },
+  {
+    id: "add-ssh-project",
+    category: "Advanced",
+    title: "Add an SSH project",
+    blurb: "Work on a folder living on another machine — Eldrun runs it over SSH/SFTP (no mount).",
+    steps: [
+      {
+        id: "open-add-menu",
+        anchor: '[data-hint-anchor="add-project"]',
+        placement: "top",
+        title: "Open the add menu",
+        body: "Click the + button beside your project pills, then pick New Project or Import Project. Both dialogs can host the project on a remote machine.",
+      },
+      {
+        id: "flip-ssh-toggle",
+        anchor: null,
+        placement: "bottom",
+        title: "Flip the SSH toggle",
+        body: "Tick \"Remote (SSH) project\" at the top of the dialog. The dialog switches to remote mode: pick a Local location — where the project's synced local working copy will live — and the SSH connection fields appear below.",
+      },
+      {
+        id: "optional-vpn",
+        anchor: null,
+        placement: "bottom",
+        title: "Behind a VPN? (optional)",
+        body: "If the host is only reachable over a VPN, tick \"Connect via OpenVPN\", pick a .ovpn config (copied into Eldrun) and enter its passphrase, then hit Connect VPN before connecting SSH. Needs openvpn + polkit installed.",
+      },
+      {
+        id: "connect-ssh",
+        anchor: null,
+        placement: "bottom",
+        title: "Connect to the host",
+        body: "Type the SSH address as user@host or host:2222. Leave the password blank to use your SSH key/agent, or fill it in for password auth. Click Connect — Eldrun verifies it can reach the host.",
+      },
+      {
+        id: "browse-remote",
+        anchor: null,
+        placement: "bottom",
+        title: "Pick the remote folder",
+        body: "Once connected, a remote file browser appears. Step into the directory you want, then click \"Use this folder\". On New it creates a subfolder there; on Import it registers it in place.",
+      },
+      {
+        id: "create-mount",
+        anchor: null,
+        placement: "bottom",
+        title: "Create and connect",
+        body: "Finish naming and pick a Git hosting option, then Create/Import. Eldrun pairs the remote folder with your synced local copy: agent tabs work locally in it by default, shells run on the host, and file browsing and git go over SSH/SFTP — no sshfs/FUSE. Later, the pill's connection lamp reconnects the project on demand.",
+      },
+    ],
+  },
+  {
+    id: "ssh-via-openvpn",
+    category: "Advanced",
+    title: "SSH project via OpenVPN",
+    blurb: "Reach a host that's only available behind a VPN, then mount its folder over SSH.",
+    steps: [
+      {
+        id: "open-add-menu",
+        anchor: '[data-hint-anchor="add-project"]',
+        placement: "top",
+        title: "Open the add menu",
+        body: "Click the + button beside your project pills and pick New Project or Import Project. Either dialog can host the project on a VPN-gated remote.",
+      },
+      {
+        id: "flip-ssh-toggle",
+        anchor: null,
+        placement: "bottom",
+        title: "Flip the SSH toggle",
+        body: "Tick \"Remote (SSH) project\" at the top. The dialog switches to remote mode: a Local location picker for the synced local working copy, then the SSH connection fields — with an OpenVPN tunnel section above them.",
+      },
+      {
+        id: "enable-vpn",
+        anchor: null,
+        placement: "bottom",
+        title: "Enable the VPN tunnel",
+        body: "Tick \"Connect via OpenVPN\" when the host is only reachable through the tunnel — Eldrun brings the tunnel up first, then connects SSH through it. Needs openvpn + polkit (pkexec) installed locally.",
+      },
+      {
+        id: "pick-ovpn",
+        anchor: null,
+        placement: "bottom",
+        title: "Choose your .ovpn config",
+        body: "Hit Browse… next to \"OpenVPN config\" and select your .ovpn file. Eldrun copies it into its own config store so the tunnel can be re-established later.",
+      },
+      {
+        id: "connect-vpn",
+        anchor: null,
+        placement: "bottom",
+        title: "Enter the credentials and connect",
+        body: "Type the VPN passphrase — or the account username and password, if your .ovpn uses those — then click \"Connect VPN\". pkexec prompts for elevation, openvpn dials the tunnel, and the button flips to \"Connected\" once it's up.",
+      },
+      {
+        id: "connect-ssh",
+        anchor: null,
+        placement: "bottom",
+        title: "Now connect SSH",
+        body: "With the tunnel up, type the SSH address as user@host or host:2222. Leave the password blank to use your SSH key/agent, or fill it in for password auth. Click Connect — Eldrun reaches the host through the VPN.",
+      },
+      {
+        id: "browse-and-create",
+        anchor: null,
+        placement: "bottom",
+        title: "Pick the folder and create",
+        body: "Step through the remote browser to your directory and click \"Use this folder\". Finish naming, pick a Git hosting option, then Create/Import. Eldrun connects over SSH/SFTP and pairs the folder with a synced local working copy — no local mount.",
+      },
+    ],
+  },
+  {
+    id: "vpn-tunnel",
+    category: "Advanced",
+    title: "Control the VPN tunnel",
+    blurb: "Bring an OpenVPN tunnel up or down from the header — with or without a project behind it.",
+    steps: [
+      {
+        id: "machine-wide",
+        anchor: ".vpn-indicator-btn",
+        placement: "bottom",
+        title: "The OpenVPN indicator",
+        body: "The header's OpenVPN button controls a machine-wide tunnel. It's not tied to any project: a config that pushes redirect-gateway reroutes your whole computer — browser included — for as long as it's up. So it lives here, always visible, not buried in one project.",
+      },
+      {
+        id: "add-config",
+        anchor: null,
+        placement: "bottom",
+        title: "Add a .ovpn config",
+        body: "Open the menu and pick your .ovpn file — Eldrun copies it into its own config store so the tunnel can be re-established later. Every stored config is then listed here, ready to connect.",
+      },
+      {
+        id: "up-down",
+        anchor: null,
+        placement: "bottom",
+        title: "Connect or disconnect anytime",
+        body: "Click a config to bring its tunnel up or down directly from the header — no project required. While one tunnel is up, project-scoped VPN sections collapse to a \"tunnel already up\" notice pointing back here, because a second tunnel would be a second claim on one machine's routing.",
+      },
+      {
+        id: "auto-launch",
+        anchor: null,
+        placement: "bottom",
+        title: "Connect on launch",
+        body: "Toggle \"Connect on launch\" on a config to arm the tunnel at startup. It's exclusive — arming one disarms any other — and it never prompts: it's only offered when your saved credentials make the connect silent (tick \"Save passphrase\" when you first connect to enable it).",
+      },
+    ],
+  },
+  {
+    id: "extend-to-remote",
+    category: "Advanced",
+    title: "Extend a local project to a remote",
+    blurb: "Pair an existing local project with an SSH host — files stay local, git keeps the two in lockstep.",
+    steps: [
+      {
+        id: "why-extend",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Take a local project remote",
+        body: "Already have a local project and want a copy on another machine? Extending pairs it with an SSH host without moving your files: your local folder stays put and becomes the mirror, Eldrun creates a matching folder on the host, and git keeps the two in lockstep. It's the reverse of adding a fresh SSH project.",
+      },
+      {
+        id: "right-click-pill",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Right-click the project pill",
+        body: "Right-click the pill of the local project you want to extend to open its context menu, then pick \"Extend to remote…\". (It only shows for local projects — a project that's already remote has nothing to extend.)",
+      },
+      {
+        id: "connect-host",
+        anchor: null,
+        placement: "bottom",
+        title: "Connect to the host",
+        body: "Type the SSH address as user@host or host:2222. Leave the password blank to use your SSH key/agent, or fill it in for password auth. If the host sits behind a VPN, flip \"Connect via OpenVPN\" (off by default) and bring up the tunnel first. Click Connect, then Next.",
+      },
+      {
+        id: "pick-remote-folder",
+        anchor: null,
+        placement: "bottom",
+        title: "Choose the remote folder",
+        body: "A remote file browser appears. Step into the parent directory where the host copy should live and click \"Use this folder\" — Eldrun creates the project's folder there. Hit Next to review.",
+      },
+      {
+        id: "review-and-extend",
+        anchor: null,
+        placement: "bottom",
+        title: "Review Local ↔ Remote, then extend",
+        body: "The summary shows your existing Local path paired with the new Remote path. Click \"Extend to remote\". Your local files aren't touched — they become the git-lockstep mirror, and you push them up to the host through git when you're ready.",
+      },
+    ],
+  },
+  {
+    id: "compute-machines",
+    category: "Advanced",
+    title: "Add compute machines to a project",
+    blurb: "Reach more than one host from a remote project — a shared cluster node or a synced experiment box.",
+    steps: [
+      {
+        id: "why-machines",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "One project, many machines",
+        body: "A remote project's primary host owns its files and git. But you can attach extra compute machines — a second GPU box, an HPC compute node — and run tabs on any of them. Each machine gets its own connection lamp and its own tab locality.",
+      },
+      {
+        id: "open-hub",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Open \"Remote machines…\"",
+        body: "Right-click the project pill → Runtime → \"Remote machines…\" (or click any of the pill's connection lamps). The hub lists the primary host first, then every worker machine, plus an \"Add a machine\" form.",
+      },
+      {
+        id: "shared-vs-synced",
+        anchor: null,
+        placement: "bottom",
+        title: "Shared folder, or a synced copy",
+        body: "Add a machine and choose its kind. By default it shares the primary's project folder over a shared filesystem (an HPC node on a shared home) — Eldrun copies nothing and runs no git on it. Untick \"Sync a copy\" for that; leave it ticked to instead push a one-way, read-only copy of your code to a standalone box.",
+      },
+      {
+        id: "sync-and-pull",
+        anchor: null,
+        placement: "bottom",
+        title: "Sync code, pull outputs",
+        body: "For a synced (copy) worker, \"Sync code now\" pushes your latest tracked files to it, and \"Pull outputs…\" brings its experiment results back — the one worker→local path, always size-confirmed. A shared-folder worker needs neither: its outputs already sit in the primary's folder.",
+      },
+      {
+        id: "global-machines",
+        anchor: ".machines-indicator-btn",
+        placement: "bottom",
+        title: "Or connect a global machine once",
+        body: "The header's Machines indicator lets you authenticate a host once, project-independently, then drag it onto any project (its pill, or its open Remote machines window) to add it there as a shared-folder worker. Removing it from a project never disconnects it here.",
+      },
+      {
+        id: "run-on-host",
+        anchor: null,
+        placement: "bottom",
+        title: "Run a tab on a chosen machine",
+        body: "Once a machine is attached, a tab can run on it — its shells and agents land on that host. That's how one project spans a login node for editing and a compute node for the heavy run.",
+      },
+    ],
+  },
+  {
+    id: "persistent-sessions",
+    category: "Advanced",
+    title: "Keep long runs alive with sessions",
+    blurb: "Shell tabs run inside tmux, so a run survives an SSH drop, a laptop sleep, or Eldrun quitting.",
+    steps: [
+      {
+        id: "why-sessions",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "Runs that outlive the tab",
+        body: "A shell or script tab runs inside a tmux session, decoupled from the connection. On a remote host that means a long run survives an SSH drop, a laptop sleep, a VPN drop, or Eldrun quitting; locally it even survives an Eldrun crash. It's ON by default — nothing to enable.",
+      },
+      {
+        id: "which-tabs",
+        anchor: null,
+        placement: "bottom",
+        title: "Which tabs are covered",
+        body: "Shell tabs (a Python run opens one too) get a session. Agent tabs don't — they resume through their own mechanism — and the root scope never does. When you relaunch Eldrun, a covered tab reattaches to its still-running session instead of starting over.",
+      },
+      {
+        id: "close-detaches",
+        anchor: null,
+        placement: "bottom",
+        title: "Closing a tab detaches it",
+        body: "Closing a tab is non-destructive: it kills only the SSH/PTY client, so the session lives on under its tmux daemon and stays reattachable. A quit, crash, or respawn leaves it running too; disconnecting its machine ends that host's sessions.",
+      },
+      {
+        id: "sessions-view",
+        anchor: null,
+        placement: "bottom",
+        title: "The Sessions view (☰)",
+        body: "Those orphaned runs are discoverable: the ☰ toggle in the file panel opens the Sessions view, which aggregates every live session across the primary and every connected worker, each row host-tagged. Click a row to attach a tab to it.",
+      },
+      {
+        id: "kill-rename",
+        anchor: null,
+        placement: "bottom",
+        title: "Kill or rename a session",
+        body: "The only way to actually terminate a session is its × (kill) in the Sessions view — closing tabs never does. Each row also has Rename, which updates the owning tab's persisted name. To opt a whole project out, use the pill's \"Persistent sessions (tmux)\" toggle.",
+      },
+    ],
+  },
+  {
+    id: "hpc-pipeline",
+    category: "Advanced",
+    title: "Run a job on an HPC cluster",
+    blurb: "The guided SLURM pipeline: log in, create the project, upload data, submit a batch job, and watch it.",
+    steps: [
+      {
+        id: "why-hpc",
+        anchor: ".project-pills-region",
+        placement: "top",
+        title: "From login node to compute node",
+        body: "An HPC cluster forbids real work on the login node — you describe a job in a batch script and the SLURM scheduler runs it on a compute node. The HPC pipeline is a 5-step wizard that walks the whole path: log in over SSH, create a remote project, upload inputs, submit the job, and watch it queue, run, and finish.",
+      },
+      {
+        id: "open-add-menu",
+        anchor: '[data-hint-anchor="add-project"]',
+        placement: "bottom",
+        title: "Open the + menu",
+        body: "Click the + button beside your project pills, then pick \"HPC pipeline…\". The wizard opens on step 1 (Login) with the remote toggle already forced on — an HPC project is remote by definition.",
+      },
+      {
+        id: "step-login",
+        anchor: null,
+        placement: "bottom",
+        title: "1. Log in to the cluster",
+        body: "Type the SSH address as user@host (add :port if it isn't 22). If the cluster is only reachable through your institution's VPN, tick \"Connect via OpenVPN\" and bring the tunnel up first. Connect, then browse to the parent folder on the host where the project should live — pick a place with quota/space, not a tiny $HOME — and click \"Use this folder\".",
+      },
+      {
+        id: "step-project",
+        anchor: null,
+        placement: "bottom",
+        title: "2. Create the project",
+        body: "Give it a name and pick a Local location for its synced mirror — Eldrun keeps a local git-lockstep copy of the tracked files there while the real tree lives on the host. Click \"Create project\". Because it's git-backed, lockstep turns on automatically: a saved edit to a tracked file only reaches the host once you commit it.",
+      },
+      {
+        id: "step-data",
+        anchor: null,
+        placement: "bottom",
+        title: "3. Load data (optional)",
+        body: "\"Add files…\" streams a few local input files straight to the project on the host over SFTP. For large trees, skip this and mark the folder auto-sync in the file panel later instead. Hit Next (or Skip).",
+      },
+      {
+        id: "step-run-account",
+        anchor: null,
+        placement: "bottom",
+        title: "4. Set your account and resources",
+        body: "A starter job.slurm is prepared; edit its #SBATCH directives in the grid. Set Account to your working group's allocation — most clusters reject a job with no account — and set a real Partition (the <partition> placeholder is only a hint). Adjust Time, Nodes, Tasks, CPUs, Memory and GPUs to your job.",
+      },
+      {
+        id: "step-run-submit",
+        anchor: null,
+        placement: "bottom",
+        title: "4. Submit the job",
+        body: "Also fix the script body: the starter's `module load Python` is a placeholder — use your cluster's real module name (run `module avail` to find it). Click \"⏫ Submit job\". Eldrun writes the script to the host and runs sbatch on a compute node, then opens a log tab that tails the output.",
+      },
+      {
+        id: "step-watch",
+        anchor: null,
+        placement: "bottom",
+        title: "5. Watch it run",
+        body: "The log tab is already following the job's output (it waits out the queue). Open the Jobs view — the ⚙ toggle in the file panel — to see the job queue, run, and finish, with per-job Watch and Cancel. That's the whole pipeline; you can re-run it any time from the + menu.",
+      },
+      {
+        id: "without-wizard",
+        anchor: null,
+        placement: "bottom",
+        title: "Beyond the wizard",
+        body: "On any remote project that has sbatch, opening a file with a #SBATCH line shows a SLURM bar in the viewer: Submit job, a Variables form for the directives (including Account), and \"⚡ Interactive session…\" to land an srun --pty shell on a compute node. The Jobs view (⚙ in the file panel) tracks everything you've launched.",
+      },
+    ],
+  },
+];
diff --git a/src/lib/machineSync.ts b/src/lib/machineSync.ts
new file mode 100644
index 0000000..664ef06
--- /dev/null
+++ b/src/lib/machineSync.ts
@@ -0,0 +1,212 @@
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "../stores/projects";
+import { useGlobalMachinesStore } from "../stores/globalMachines";
+import { useSettingsStore } from "../stores/settings";
+import { mayAutoTouch } from "./hpcHost";
+import {
+  useRemoteStatusStore,
+  hostStateOf,
+  PRIMARY_HOST,
+  type ConnState,
+} from "../stores/remoteStatus";
+
+/**
+ * Keep a **global machine** (`stores/globalMachines`, header "Machines") and the
+ * **project host** it also is (a project's primary `remote` or a `compute_hosts`
+ * worker) in step, so connecting/disconnecting one reflects on the other.
+ *
+ * The two are never linked by id — a global machine dropped onto a project is
+ * copied by *value* — so the only bridge is the **SSH target** (`user@host:port`).
+ * `sameTarget` is that bridge, and the whole module keys off it.
+ *
+ * The physical connection really *is* shared (one OpenSSH ControlMaster per host
+ * target), so "sync" is mostly reconciling the two separate status stores rather
+ * than opening a second socket. Two rules keep it from looping or lying:
+ *
+ *  - **Global → project** is driven from **one** place: a subscription on the
+ *    global store's `status`, which by contract only ever moves on a *real
+ *    session* (`add`/`register`/`connect`/`disconnect` — `probeAll` writes
+ *    `reachable`, never `status`). It used to hang off two hand-placed calls in
+ *    `add` and `connect`, which is why `register` and the probe sweep propagated
+ *    nothing and a machine could sit green in the header while the project holding
+ *    the very same host stayed unconnected. One subscription cannot forget a path.
+ *    Only the **active** project's pool is opened; an inactive one is left alone
+ *    entirely (see `syncGlobalConnected` for why a mirrored lamp is worse than no
+ *    lamp). Disconnect stays imperative — it is a teardown with an ordering
+ *    (mirror first, kill jobs after), not a state a subscriber can reconstruct.
+ *  - **Project → global** is a *subscription* (`initMachineSync`) that only ever
+ *    *upgrades* a matching machine's lamp to `connected` — a project deactivating
+ *    (which clears its lamps) must never knock an independently-connected machine
+ *    offline, so `off` is deliberately not propagated upward.
+ *
+ * No loop: the global store's `setStatus` never touches `remoteStatus`, so the
+ * subscription can't re-enter the imperative path.
+ */
+
+export interface Target {
+  user?: string;
+  host: string;
+  port?: number;
+}
+
+function norm(t: Target): { user: string | undefined; host: string; port: number } {
+  return {
+    user: t.user && t.user.trim() ? t.user.trim() : undefined,
+    host: t.host.trim().toLowerCase(),
+    // A host with no explicit port and one pinned to 22 are the same machine.
+    port: t.port ?? 22,
+  };
+}
+
+/** Whether two SSH targets are the same machine+login (host case-insensitive,
+ *  default port 22, empty user ≡ absent). A different login on the same host is a
+ *  *different* connection, so `user` is matched strictly. */
+export function sameTarget(a: Target, b: Target): boolean {
+  const x = norm(a);
+  const y = norm(b);
+  return x.host === y.host && x.port === y.port && x.user === y.user;
+}
+
+/** The canonical string form of an SSH target — `sameTarget` as a map key, so a
+ *  store can index by machine identity without an id. Two targets share a key iff
+ *  `sameTarget` holds for them, which is what lets a global machine and the
+ *  project host that *is* it (copied by value, different ids) share one entry. */
+export function targetKey(t: Target): string {
+  const n = norm(t);
+  return `${n.user ?? ""}@${n.host}:${n.port}`;
+}
+
+interface ProjectHostRef {
+  projectId: string;
+  hostId: string;
+  target: Target;
+}
+
+/** Every project host (primary + workers) whose SSH target matches `target`. */
+function projectHostsMatching(target: Target): ProjectHostRef[] {
+  const { projects } = useProjectsStore.getState();
+  const out: ProjectHostRef[] = [];
+  for (const p of projects) {
+    if (p.remote && sameTarget(p.remote, target)) {
+      out.push({ projectId: p.id, hostId: PRIMARY_HOST, target: p.remote });
+    }
+    for (const h of p.compute_hosts ?? []) {
+      if (sameTarget(h, target)) out.push({ projectId: p.id, hostId: h.id, target: h });
+    }
+  }
+  return out;
+}
+
+// `viaLogin` is unconditional here and says what this function *is*: the machine was
+// authenticated in the header's Machines list, and this connect only succeeds because
+// it rides the master that left behind. Without it the backend reads the missing
+// password as key/agent auth and stamps `key_auth: true` on a password host, which
+// then advertises a promptless auto-connect it cannot deliver (`record_key_auth`).
+function remoteConnectArgs(ref: ProjectHostRef): Record<string, unknown> {
+  return ref.hostId === PRIMARY_HOST
+    ? { projectId: ref.projectId, password: null, viaLogin: true }
+    : { projectId: ref.projectId, hostId: ref.hostId, password: null, viaLogin: true };
+}
+
+/**
+ * A global machine gained a **real session** — open the matching pool on the
+ * ACTIVE project, if it holds the same host and is allowed to be reached.
+ *
+ * Two things it deliberately does *not* do.
+ *
+ * **It never mirrors a lamp onto an inactive project.** That used to write
+ * `"connected"` with no pool behind it, and a green lamp with no session is worse
+ * than no lamp twice over: the whole app reads it as "a pooled session is open"
+ * (`useRemoteBlocked`, `holdRemoteTerminal`, the tmux/slurm/workspace probes all
+ * un-gate on it and then dispatch at a session that isn't there), and it *blocks*
+ * the connect that would have made it true — `autoConnectPrimary` only proceeds
+ * from `"off"`, and this function skips anything already `"connected"`. An
+ * inactive project is left at `off` and opens its pool on activation, exactly as
+ * it always did.
+ *
+ * **It never opens a pool on a host tagged HPC.** `remote_connect` raises a
+ * `ControlPersist=600` master — a standing presence on a shared login node — and
+ * "because another surface authenticated the same host" is not a gesture against
+ * *this* project. Connecting it by hand is one click away and untouched.
+ */
+export function syncGlobalConnected(target: Target): void {
+  const { activeId } = useProjectsStore.getState();
+  const settings = useSettingsStore.getState().settings;
+  for (const ref of projectHostsMatching(target)) {
+    if (ref.projectId !== activeId) continue;
+    if (!mayAutoTouch(settings, ref.target)) continue;
+    const status = useRemoteStatusStore.getState();
+    const cur = hostStateOf(status, ref.projectId, ref.hostId).ssh;
+    if (cur === "connected" || cur === "connecting") continue;
+    status.setSsh(ref.projectId, "connecting", ref.hostId);
+    void invoke("remote_connect", remoteConnectArgs(ref))
+      .then(() => useRemoteStatusStore.getState().setSsh(ref.projectId, "connected", ref.hostId))
+      .catch(() => useRemoteStatusStore.getState().setSsh(ref.projectId, "error", ref.hostId));
+  }
+}
+
+/** A global machine actively disconnected (jobs ended, master closed) — tear the
+ *  matching pool on the active project and drop every matching lamp to `off`. */
+export function syncGlobalDisconnected(target: Target): void {
+  const { activeId } = useProjectsStore.getState();
+  for (const ref of projectHostsMatching(target)) {
+    if (ref.projectId === activeId) {
+      const t = ref.target;
+      void invoke("remote_kill_all_jobs", { user: t.user, host: t.host, port: t.port }).catch(
+        () => {},
+      );
+      void invoke("remote_disconnect", {
+        projectId: ref.projectId,
+        hostId: ref.hostId,
+      }).catch(() => {});
+    }
+    useRemoteStatusStore.getState().setSsh(ref.projectId, "off", ref.hostId);
+  }
+}
+
+/** Upgrade any global machine to `connected` when a project host with the same
+ *  target is connected. Never downgrades — a machine's lamp is its own, and a
+ *  project deactivating must not knock it offline. */
+function reconcileGlobalsFromProjects(): void {
+  const gm = useGlobalMachinesStore.getState();
+  const status = useRemoteStatusStore.getState();
+  for (const m of gm.machines) {
+    const cur: ConnState = gm.status[m.id] ?? "off";
+    if (cur === "connected") continue;
+    const anyConnected = projectHostsMatching(m).some(
+      (ref) => hostStateOf(status, ref.projectId, ref.hostId).ssh === "connected",
+    );
+    if (anyConnected) gm.setStatus(m.id, "connected");
+  }
+}
+
+let inited = false;
+
+/**
+ * Install both lamp mirrors. Idempotent; call once at startup (`AppShell`).
+ *
+ * The global → project direction is a subscription rather than a call in each
+ * action because "which action connected it" is not the question — *that a real
+ * session now exists* is, and `status` in the global store means exactly that
+ * (the probe sweep writes `reachable`). Every future path that opens a session
+ * gets the propagation for free; the two hand-placed calls this replaces had
+ * already missed `register` and the sweep.
+ *
+ * Still no loop. The chain global-status → `syncGlobalConnected` → `remoteStatus`
+ * → `reconcileGlobalsFromProjects` → `setStatus("connected")` dead-ends twice
+ * over: `setStatus` collapses a write of the value already there, and a second
+ * pass of `syncGlobalConnected` finds the project lamp `connected` and returns
+ * without touching anything.
+ */
+export function initMachineSync(): void {
+  if (inited) return;
+  inited = true;
+  useRemoteStatusStore.subscribe(() => reconcileGlobalsFromProjects());
+  useGlobalMachinesStore.subscribe((state, prev) => {
+    for (const m of state.machines) {
+      const now = state.status[m.id] ?? "off";
+      if (now !== "connected" || (prev.status[m.id] ?? "off") === "connected") continue;
+      syncGlobalConnected(m);
+    }
+  });
+}
diff --git a/src/lib/ollamaStatus.ts b/src/lib/ollamaStatus.ts
new file mode 100644
index 0000000..35d9e15
--- /dev/null
+++ b/src/lib/ollamaStatus.ts
@@ -0,0 +1,122 @@
+import { useEffect, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * **The** poll of Ollama's `stopped | idle | loaded` state — one timer for the
+ * whole app, however many components ask.
+ *
+ * `ollama_status` is a `GET /api/ps` round trip, and it had two independent
+ * callers on 5 s timers: the header's 🧠 `LocalModelMenu` lamp, and
+ * `useLocalModelLoaded` in the file viewer — the second of which is **per
+ * editable viewer tab**, so the request rate grew with the number of open tabs
+ * rather than staying a property of the app. The observable result was a steady
+ * stream of paired `/api/ps` hits a couple of seconds apart, forever, asking the
+ * same question and getting the same answer.
+ *
+ * The state is genuinely global — whether a model is resident in Ollama's memory
+ * is a fact about the machine, not about a tab — so a single shared poller is not
+ * just cheaper, it is the more correct model: every surface now flips on the same
+ * observation instead of each discovering it up to 5 s apart.
+ *
+ * Shape: subscribers register an interval they'd be happy with, the timer runs at
+ * the **shortest** one asked for, and it only exists while at least one component
+ * is subscribed. A tick that lands while a request is still in flight is skipped
+ * rather than queued, so a slow or wedged Ollama can never accumulate a backlog.
+ */
+export type OllamaStatus = "stopped" | "idle" | "loaded";
+
+/** Default cadence, matching what each caller polled at individually before. */
+export const DEFAULT_INTERVAL_MS = 5000;
+
+interface Subscriber {
+  notify: (s: OllamaStatus) => void;
+  intervalMs: number;
+}
+
+const subscribers = new Set<Subscriber>();
+let timer: number | undefined;
+let timerInterval = 0;
+let inFlight = false;
+/** Last observed value, replayed to a new subscriber so it renders the known
+ *  state immediately instead of flashing `stopped` until the next tick. */
+let current: OllamaStatus = "stopped";
+
+async function poll(): Promise<void> {
+  if (inFlight) return; // a wedged server must not build a queue of retries
+  inFlight = true;
+  try {
+    const next = await invoke<OllamaStatus>("ollama_status");
+    current = next;
+    for (const s of subscribers) s.notify(next);
+  } catch {
+    // Unreachable backend — report the same thing an unreachable Ollama does.
+    current = "stopped";
+    for (const s of subscribers) s.notify("stopped");
+  } finally {
+    inFlight = false;
+  }
+}
+
+/** (Re)start the shared timer at the shortest interval any subscriber wants, or
+ *  stop it entirely when the last one leaves. */
+function retime(): void {
+  if (subscribers.size === 0) {
+    if (timer !== undefined) window.clearInterval(timer);
+    timer = undefined;
+    timerInterval = 0;
+    return;
+  }
+  const wanted = Math.min(...[...subscribers].map((s) => s.intervalMs));
+  if (timer !== undefined && timerInterval === wanted) return;
+  if (timer !== undefined) window.clearInterval(timer);
+  timerInterval = wanted;
+  timer = window.setInterval(() => void poll(), wanted);
+}
+
+/**
+ * Subscribe to the shared Ollama status.
+ *
+ * `enabled` false unsubscribes (and reports `"stopped"`), so a caller gated on
+ * something else — the menu's "is Ollama even installed?" check — contributes no
+ * polling at all while it has nothing to show.
+ */
+export function useOllamaStatus(enabled = true, intervalMs = DEFAULT_INTERVAL_MS): OllamaStatus {
+  const [status, setStatus] = useState<OllamaStatus>(enabled ? current : "stopped");
+
+  useEffect(() => {
+    if (!enabled) {
+      setStatus("stopped");
+      return;
+    }
+    let cancelled = false;
+    const sub: Subscriber = {
+      notify: (s) => {
+        if (!cancelled) setStatus(s);
+      },
+      intervalMs,
+    };
+    subscribers.add(sub);
+    retime();
+    // Seat from the last known value, then ask straight away — a component that
+    // mounts between ticks must not wait a whole interval for its first answer.
+    setStatus(current);
+    void poll();
+    return () => {
+      cancelled = true;
+      subscribers.delete(sub);
+      retime();
+    };
+  }, [enabled, intervalMs]);
+
+  return status;
+}
+
+/** Reset the module between tests (no component is subscribed by then). */
+export function resetOllamaStatusPoller(): void {
+  subscribers.clear();
+  if (timer !== undefined) window.clearInterval(timer);
+  timer = undefined;
+  timerInterval = 0;
+  inFlight = false;
+  current = "stopped";
+}
diff --git a/src/lib/paths.ts b/src/lib/paths.ts
new file mode 100644
index 0000000..a0d09e7
--- /dev/null
+++ b/src/lib/paths.ts
@@ -0,0 +1,197 @@
+/**
+ * OS-independent path helpers for the frontend (cross-platform support).
+ *
+ * Absolute paths reach the UI straight from the Rust backend, which emits NATIVE
+ * separators: `/` on Unix, `\` (with a `C:` drive, or a `\\server` UNC prefix) on
+ * Windows. Relative ("rel") paths from the backend are already normalised to `/`
+ * (see `commands/fs.rs`, which does `.replace('\\', "/")`). These helpers
+ * therefore accept EITHER separator so the same component code runs on both
+ * platforms, and when they build a new path they preserve the input's own
+ * separator style — falling back to the host OS only for a separator-less input.
+ *
+ * Rust's `std::fs` accepts `/` on Windows too, so a `/`-joined path handed back to
+ * the backend still resolves; we keep native separators mainly so labels,
+ * `file://` URIs, and round-tripped paths read correctly.
+ */
+
+// OS detection lives in the dependency-free `platform.ts` single source of
+// truth. Imported for local use (sepFor) AND re-exported under the stable
+// `IS_WINDOWS` name this widely-imported module has always exposed. Only
+// consulted when a path's own separators can't reveal its style (e.g. a bare
+// relative segment with no separator at all).
+import { IS_WINDOWS } from "./platform";
+
+export { IS_WINDOWS };
+
+/** A Windows drive prefix like `C:` (anchored at the start). */
+const DRIVE_RE = /^[a-zA-Z]:(?=[/\\]|$)/;
+const UNC_RE = /^[/\\]{2}([^/\\]+)[/\\]+([^/\\]+)/;
+
+/** The separator to use when building onto `p`: matches the path's own style, or
+ *  the host OS when the path carries no separators to learn from. */
+function sepFor(p: string): "/" | "\\" {
+  if (p.includes("\\") || DRIVE_RE.test(p) || p.startsWith("\\\\")) return "\\";
+  if (p.includes("/")) return "/";
+  return IS_WINDOWS ? "\\" : "/";
+}
+
+/** Does this path use Windows conventions (drive letter, UNC, or any backslash)?
+ *  Mixed separators (`C:/a\b`) count as Windows. */
+function isWinStyle(p: string): boolean {
+  return DRIVE_RE.test(p) || p.startsWith("\\\\") || p.includes("\\");
+}
+
+/** Index of the last separator of either kind, or -1. */
+function lastSep(p: string): number {
+  return Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+}
+
+/** True for an absolute path on either OS: POSIX `/x`, Windows `C:\x` / `C:/x`,
+ *  or a `\\server\share` UNC path. */
+export function isAbsolute(p: string): boolean {
+  return p.startsWith("/") || p.startsWith("\\\\") || /^[a-zA-Z]:[/\\]/.test(p);
+}
+
+/** Final path segment (the file or last directory name). Trailing separators are
+ *  ignored; a bare root (`/`, `C:\`, `C:`) yields "". Works on both native and
+ *  forward-slash paths, so it is safe on backend rel paths too. */
+export function basename(p: string): string {
+  const trimmed = p.replace(/[/\\]+$/, "");
+  const i = lastSep(trimmed);
+  const base = i >= 0 ? trimmed.slice(i + 1) : trimmed;
+  // A lone drive ("C:") is a root, not a name.
+  return DRIVE_RE.test(base) ? "" : base;
+}
+
+/** Everything up to (not including) the final separator — the containing
+ *  directory. Preserves the root: dirname("/a")→"/", dirname("C:\\a")→"C:\\".
+ *  Returns "" when `p` has no directory part (callers that need a root fallback
+ *  keep their own `|| "/"`). */
+export function dirname(p: string): string {
+  const trimmed = p.replace(/[/\\]+$/, "");
+  const i = lastSep(trimmed);
+  if (i < 0) return "";
+  if (i === 0) return trimmed[0]; // POSIX root: "/x" → "/"
+  const head = trimmed.slice(0, i);
+  // Windows drive root: "C:\x" (separator at index 2) → "C:\"
+  if (DRIVE_RE.test(head) && head.length === 2) return trimmed.slice(0, i + 1);
+  return head;
+}
+
+/** Normalise `.`/`..`/duplicate-separator segments, preserving the root and the
+ *  path's separator style. */
+export function normalizePath(p: string): string {
+  const sep = sepFor(p);
+  const win = isWinStyle(p);
+
+  let root = "";
+  let body = p;
+  if (win) {
+    const drive = p.match(DRIVE_RE);
+    if (drive) {
+      root = drive[0] + sep; // "C:" + sep
+      body = p.slice(drive[0].length);
+    } else {
+      const unc = p.match(UNC_RE);
+      if (unc) {
+        // A UNC share is the filesystem root. Keep server/share outside the
+        // reducible stack so `..` cannot escape above it.
+        root = `${sep}${sep}${unc[1]}${sep}${unc[2]}`;
+        body = p.slice(unc[0].length);
+      } else if (/^[/\\]/.test(p)) {
+        root = sep;
+        body = p.slice(1);
+      }
+    }
+  } else if (p.startsWith("/")) {
+    root = "/";
+    body = p.slice(1);
+  }
+
+  const out: string[] = [];
+  for (const seg of body.split(/[/\\]+/)) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length && out[out.length - 1] !== "..") out.pop();
+      else if (!root) out.push("..");
+    } else out.push(seg);
+  }
+  if (!out.length) return root;
+  return root + (root && !root.endsWith(sep) ? sep : "") + out.join(sep);
+}
+
+/** True when `path` is `root` or lies below it on a segment boundary.
+ * Windows drive and UNC paths compare case-insensitively and accept mixed
+ * separators. POSIX paths remain case-sensitive. */
+export function isPathWithin(path: string, root: string): boolean {
+  if (!path || !root) return false;
+  const windows = isWinStyle(path) || isWinStyle(root);
+  const canonical = (value: string) => {
+    const normalized = normalizePath(value).replace(/\\/g, "/").replace(/\/+$/, "");
+    return windows ? normalized.toLowerCase() : normalized;
+  };
+  const child = canonical(path);
+  const parent = canonical(root);
+  return child === parent || child.startsWith(`${parent}/`);
+}
+
+/** Separator-normalized relative path when `path` is within `root`, otherwise
+ * null. The emitted relative path follows the backend's `/` convention. */
+export function relativePathWithin(root: string, path: string): string | null {
+  if (!isPathWithin(path, root)) return null;
+  const normalizedRoot = normalizePath(root).replace(/\\/g, "/").replace(/\/+$/, "");
+  const normalizedPath = normalizePath(path).replace(/\\/g, "/").replace(/\/+$/, "");
+  return normalizedPath.length === normalizedRoot.length
+    ? ""
+    : normalizedPath.slice(normalizedRoot.length + 1);
+}
+
+/** Resolve `target` against the directory `baseDir`. An absolute `target` is
+ *  normalised and returned as-is; a relative one is joined onto `baseDir`. The
+ *  result keeps `baseDir`'s separator style. */
+export function resolvePath(baseDir: string, target: string): string {
+  if (isAbsolute(target)) return normalizePath(target);
+  const sep = sepFor(baseDir);
+  return normalizePath(`${baseDir}${sep}${target}`);
+}
+
+/** Build a `file://` URI from an absolute local path, percent-encoding each
+ *  segment. Windows drive paths become `file:///C:/…` (extra `/`, forward
+ *  slashes) and UNC paths `file://server/share/…`, per RFC 8089. */
+export function toFileUri(p: string): string {
+  if (isWinStyle(p)) {
+    const encoded = p
+      .split(/[/\\]+/)
+      .filter((s) => s !== "")
+      // Keep the drive letter (`C:`) literal — encodeURIComponent would turn its
+      // colon into %3A, which file:// consumers don't accept.
+      .map((s, i) => (i === 0 && DRIVE_RE.test(s) ? s : encodeURIComponent(s)))
+      .join("/");
+    return p.startsWith("\\\\")
+      ? `file://${encoded}` // UNC: file://server/share/…
+      : `file:///${encoded}`; // drive: file:///C:/…
+  }
+  // POSIX: keep the leading "" from the absolute path so we get file:///abs/path.
+  return `file://${p.split("/").map(encodeURIComponent).join("/")}`;
+}
+
+/** Convert a `file://` URI back to an absolute local path (decoding `%20` etc.).
+ * A non-empty authority becomes a UNC server (`file://server/share/x` →
+ * `\\server\share\x`); the extra leading slash on a drive URI is stripped. */
+export function fromFileUri(uri: string): string | null {
+  if (!/^file:\/\//i.test(uri)) return null;
+  let rest = uri.slice("file://".length);
+  try {
+    rest = decodeURIComponent(rest);
+  } catch {
+    // Keep malformed escape sequences verbatim.
+  }
+  if (!rest.startsWith("/")) {
+    const slash = rest.indexOf("/");
+    const authority = slash < 0 ? rest : rest.slice(0, slash);
+    const path = slash < 0 ? "" : rest.slice(slash + 1);
+    return normalizePath(`\\\\${authority}\\${path.replace(/\//g, "\\")}`);
+  }
+  const local = rest.replace(/^\/([a-zA-Z]:)/, "$1");
+  return DRIVE_RE.test(local) ? normalizePath(local).replace(/\\/g, "/") : normalizePath(local);
+}
diff --git a/src/lib/platform.ts b/src/lib/platform.ts
new file mode 100644
index 0000000..addc5dd
--- /dev/null
+++ b/src/lib/platform.ts
@@ -0,0 +1,35 @@
+/**
+ * Single source of truth for OS detection in the frontend.
+ *
+ * Detected once from the webview's `navigator`. Every other detector
+ * (`paths.ts`, `dragPlatform.ts`, viewers, shortcuts, …) re-exports or derives
+ * from these flags so the logic never drifts across the codebase.
+ *
+ * IMPORTANT: this module must NOT import from `paths.ts`, `dragPlatform.ts`, or
+ * any other app module — keep it dependency-free so it can be the bottom of the
+ * import graph with no cycles.
+ */
+
+/** True on macOS (and iOS, harmless here). Detected once from the webview. */
+export const IS_MAC: boolean =
+  typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform || "");
+
+/** True when running on Windows. `navigator.platform` is authoritative when
+ *  present; otherwise we fall back to the UA string. */
+export const IS_WINDOWS: boolean = (() => {
+  if (typeof navigator === "undefined") return false;
+  const platform = navigator.platform || "";
+  if (platform) return /^win/i.test(platform);
+  return /windows/i.test(navigator.userAgent || "");
+})();
+
+/** True on Linux — the fallback when the host is neither macOS nor Windows. */
+export const IS_LINUX: boolean = !IS_MAC && !IS_WINDOWS;
+
+/** The host OS as a single discriminant. Windows wins over the macOS check so
+ *  the two are mutually exclusive even if a UA string is unusual. */
+export const PLATFORM: "windows" | "macos" | "linux" = IS_WINDOWS
+  ? "windows"
+  : IS_MAC
+    ? "macos"
+    : "linux";
diff --git a/src/lib/promptCount.ts b/src/lib/promptCount.ts
new file mode 100644
index 0000000..f2d4461
--- /dev/null
+++ b/src/lib/promptCount.ts
@@ -0,0 +1,82 @@
+/**
+ * Counting what you *asked* — prompts sent to agents, commands run in shells.
+ *
+ * There is no API for this: an agent CLI is a TUI on a PTY, and Eldrun only sees
+ * the bytes going into it. The one thing that reliably marks a submission is
+ * Enter (`\r`) pressed after you typed something. So we track, per PTY, whether
+ * any *content* has been typed since the last Enter, and count one submit each
+ * time Enter arrives with content pending.
+ *
+ * This is a heuristic, and it is the deliberate alternative to reading Claude's
+ * and Codex's private transcript directories: it works for all eleven agents and
+ * every local model, and it never touches another application's data.
+ *
+ * What it is careful about:
+ *
+ * - **Escape sequences** (arrow keys, Home/End, mouse reports) arrive as `\x1b…`
+ *   and are not content — otherwise navigating history would look like typing.
+ * - **Control characters** (Ctrl-C, Tab-completion, backspace) are not content.
+ * - **A paste** arrives as one `onData` chunk of printable text, so a
+ *   paste-then-Enter is one prompt, which is right.
+ * - **A bare Enter** on an empty line (scrolling an agent's menu, accepting a
+ *   default) counts nothing.
+ *
+ * What it cannot know: an Enter inside a multi-line editor buffer looks like a
+ * submit. It over-counts a little in that case. Stated in the recap rather than
+ * hidden.
+ */
+
+/** Whether a chunk of terminal input contains any printable content. */
+export function hasContent(data: string): boolean {
+  // Strip escape sequences first: an arrow key is "\x1b[A", whose "[A" would
+  // otherwise read as two printable characters.
+  const withoutEscapes = data.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b./g, "");
+  for (const ch of withoutEscapes) {
+    const code = ch.codePointAt(0) ?? 0;
+    // C0 controls (incl. \r, \n, \t, backspace, Ctrl-*) and DEL are not content.
+    if (code < 0x20 || code === 0x7f) continue;
+    return true;
+  }
+  return false;
+}
+
+/** Whether a chunk contains a submit key (Enter / carriage return). */
+export function hasSubmit(data: string): boolean {
+  return data.includes("\r") || data.includes("\n");
+}
+
+/**
+ * Per-PTY "has the user typed anything since the last Enter?" state.
+ *
+ * Kept outside React (like `activity.ts`'s per-PTY maps): it churns on every
+ * keystroke and nothing renders off it.
+ */
+const pendingByPty: Record<string, boolean> = {};
+
+/**
+ * Feed one `onData` chunk for a PTY. Returns the number of submits to count
+ * (0 or 1 — a chunk carrying several newlines is a multi-line paste, which is
+ * still one thing asked).
+ */
+export function noteInput(ptyId: string, data: string): number {
+  const content = hasContent(data);
+  if (!hasSubmit(data)) {
+    if (content) pendingByPty[ptyId] = true;
+    return 0;
+  }
+  // Enter arrived. A chunk can carry both (a bracketed paste ending in newline,
+  // or typing fast enough to batch) — content anywhere in it counts as pending.
+  const submits = pendingByPty[ptyId] || content ? 1 : 0;
+  pendingByPty[ptyId] = false;
+  return submits;
+}
+
+/** Forget a PTY's pending state (tab closed). */
+export function forgetPty(ptyId: string): void {
+  delete pendingByPty[ptyId];
+}
+
+/** Test seam: drop all pending state. */
+export function _resetPromptCountForTest(): void {
+  for (const key of Object.keys(pendingByPty)) delete pendingByPty[key];
+}
diff --git a/src/lib/pythonRun.ts b/src/lib/pythonRun.ts
new file mode 100644
index 0000000..4330528
--- /dev/null
+++ b/src/lib/pythonRun.ts
@@ -0,0 +1,318 @@
+/**
+ * Run and debug a Python file from the native code viewer (#py).
+ *
+ * Both buttons do the same structural thing: open a **terminal tab** in the
+ * project and type a command into it. That is deliberate, and it is what makes
+ * the feature work everywhere Eldrun already works, for free — a shell tab on a
+ * remote (SSH) project runs on the host, and one on a containerised project runs
+ * inside the container, because the tab is the thing that carries locality and
+ * sandboxing. A bespoke "run" IPC path would have to re-derive both and would get
+ * them wrong.
+ *
+ * It also means the process is a *visible, interactive terminal*: a script that
+ * prompts for input works, Ctrl+C works, and the shell survives the program's
+ * exit so the output (and the traceback) stays on screen and ↑ re-runs it. This
+ * is the same one-click-open-a-tab-and-run policy as `installCommand.ts`.
+ *
+ * Debugging is pdb, driven from the gutter's breakpoints: they are handed to it
+ * as `-c "b file:N"` commands, followed by `-c continue` so the session runs
+ * straight to the first one instead of halting on line 1. With no breakpoints set
+ * we omit the `continue` and let pdb stop at the top of the file, which is the
+ * only sensible reading of "debug this with no breakpoints".
+ */
+
+import { invoke } from "@tauri-apps/api/core";
+import { basename, dirname } from "./paths";
+import { useTabsStore, type TabEntry } from "../stores/tabs";
+import { useRunHostPrefStore } from "../stores/runHostPref";
+import { guardLoginNodeRun } from "./hpcGuard";
+
+/** How a run/debug tab is inserted into the layout. Given the built (keyless)
+ *  tab, place it and return the created entry — or null when it streamed the tab
+ *  elsewhere (a detached popout owns its own tabs), so the caller does nothing.
+ *  The default (no placer) opens in the owning project's focused subwindow; a
+ *  placer is supplied only to stream into a popout. See {@link placeForFocused}. */
+export type PyTabPlacer = (tab: Omit<TabEntry, "key">) => TabEntry | null;
+
+export type PyPlatform = "windows" | "unix";
+
+/** The env vars that mark a terminal tab as a viewer-launched run/debug of a
+ *  specific file. They are real env vars (the process can see them), and they are
+ *  also how a re-run finds the tab it should replace — a tab has no free-form
+ *  metadata, and matching on the label would collide across two `main.py`s in
+ *  different directories. */
+export const PY_TARGET_ENV = "ELDRUN_PY_TARGET";
+export const PY_MODE_ENV = "ELDRUN_PY_MODE";
+
+export type PyRunMode = "run" | "debug";
+
+/** Quote one shell argument. `cmd.exe` (Windows' default shell, via COMSPEC) has
+ *  no single-quote syntax, so the two platforms genuinely differ. */
+export function shellQuote(arg: string, platform: PyPlatform): string {
+  if (platform === "windows") return `"${arg.replace(/"/g, '""')}"`;
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+
+/** The last-resort interpreter when the backend can't be reached at all. */
+export function systemInterpreter(platform: PyPlatform): string {
+  return platform === "windows" ? "python" : "python3";
+}
+
+/** `<interp> <file> [args]` — the Run button's command line.
+ *
+ * `args` is appended **verbatim** (only trimmed), not shell-quoted: it is a raw
+ * argument string the user typed to be parsed by the host shell, so `main.py`
+ * plus `--epochs 5 "out dir"` runs with two real arguments. The tab is a real
+ * terminal (see the module header), so this is the natural place to type them. */
+export function buildRunCommand(
+  interp: string,
+  file: string,
+  platform: PyPlatform,
+  args?: string,
+): string {
+  const base = `${shellQuote(interp, platform)} ${shellQuote(file, platform)}`;
+  const extra = args?.trim();
+  return extra ? `${base} ${extra}` : base;
+}
+
+/**
+ * The Debug button's command line: pdb, pre-loaded with the gutter's breakpoints.
+ *
+ * `python -m pdb -c "b f.py:12" -c continue f.py` sets the breakpoints before the
+ * script starts and then runs to the first one. Without breakpoints the trailing
+ * `continue` is omitted — otherwise pdb would run the program to completion and
+ * "debug" would be indistinguishable from "run".
+ */
+export function buildDebugCommand(
+  interp: string,
+  file: string,
+  breakpoints: number[],
+  platform: PyPlatform,
+  args?: string,
+): string {
+  const parts = [shellQuote(interp, platform), "-m", "pdb"];
+  const sorted = [...new Set(breakpoints)].sort((a, b) => a - b);
+  for (const line of sorted) {
+    parts.push("-c", shellQuote(`b ${file}:${line}`, platform));
+  }
+  if (sorted.length > 0) parts.push("-c", shellQuote("continue", platform));
+  parts.push(shellQuote(file, platform));
+  // Script arguments follow the file, exactly as `python -m pdb script.py args…`
+  // expects them. Appended verbatim (see buildRunCommand) — pdb hands them to the
+  // debugged program's `sys.argv`.
+  const extra = args?.trim();
+  if (extra) parts.push(extra);
+  return parts.join(" ");
+}
+
+/** One interpreter the project could run — what `python_interpreters` offers the
+ *  picker. `kind` is `venv|poetry|conda|pyenv|active|system`. */
+export interface PyInterpreter {
+  kind: string;
+  path: string;
+  label: string;
+}
+
+/** Every interpreter this project could use (the picker's list). Probes the HOST
+ *  for a remote project — that is the machine the run tab will run on. */
+export function listInterpreters(projectDir: string): Promise<PyInterpreter[]> {
+  return invoke<PyInterpreter[]>("python_interpreters", { projectDir });
+}
+
+/** Pin the project's interpreter (or clear it back to auto-detect with `null`). */
+export function setProjectPython(
+  projectId: string,
+  interpreter: string | null,
+): Promise<string | null> {
+  return invoke<string | null>("set_project_python", { projectId, interpreter });
+}
+
+/**
+ * The interpreter to run with, right now.
+ *
+ * The backend owns the precedence (`commands::python`) — the project's pinned
+ * choice if it has one, else the best auto-detected environment (in-tree venv →
+ * poetry → active `VIRTUAL_ENV`/`CONDA_PREFIX` → pyenv → system). Deliberately not
+ * re-implemented here: two rankings that can disagree is a bug waiting to happen,
+ * and only the backend can see conda/poetry at all.
+ */
+export async function resolveInterpreter(
+  projectId: string | null,
+  projectDir: string,
+  platform: PyPlatform,
+): Promise<string> {
+  try {
+    return await invoke<string>("python_interpreter_for", { projectId, projectDir });
+  } catch {
+    // A disconnected/unreadable project is not a reason to refuse to run: fall
+    // back to the system interpreter and let the terminal report the truth.
+    return systemInterpreter(platform);
+  }
+}
+
+export function currentPlatform(): PyPlatform {
+  return navigator.userAgent.includes("Windows") ? "windows" : "unix";
+}
+
+/** The label a run/debug tab carries. */
+export function pyTabLabel(mode: PyRunMode, file: string): string {
+  return `${mode === "debug" ? "🐞" : "▶"} ${basename(file)}`;
+}
+
+/**
+ * Open a terminal tab running `command` for `file`, replacing the previous
+ * run/debug tab for that same file and mode.
+ *
+ * Replacing rather than reusing is the deliberate choice: re-typing the command
+ * into a *live* tab would send it to whatever is already running there (a pdb
+ * prompt, or a script blocked on input) instead of to a shell. Closing the old
+ * tab kills that PTY, so every run starts from a known-clean process.
+ */
+export function openPythonTab(opts: {
+  mode: PyRunMode;
+  file: string;
+  /** cwd for the tab — the project root, so relative paths and the venv resolve. */
+  projectDir: string;
+  /** The scope owning the tab: the project's id, or "root". Only used by the
+   *  default placement (when no `place` is supplied). */
+  scope: string;
+  command: string;
+  /** Where to insert the tab. Supplied only to stream the run into a detached
+   *  popout; when absent (the normal case) the tab lands in the owning project's
+   *  focused subwindow via `addTabToScope`. See {@link placeForFocused}. */
+  place?: PyTabPlacer;
+}): void {
+  const { mode, file, projectDir, scope, command, place } = opts;
+  const store = useTabsStore.getState();
+
+  const prior = store.tabs.find(
+    (t) =>
+      t.kind === "shell" &&
+      t.env?.[PY_TARGET_ENV] === file &&
+      t.env?.[PY_MODE_ENV] === mode,
+  );
+  if (prior) store.removeTab(prior.key);
+
+  // Which machine to run on: the project's run-host preference (set from the file
+  // viewer's `RunHostPicker`), keyed by the owning project. `scope` is the project
+  // id for a project tab ("root" has no pref). Honoured for EVERY remote project,
+  // including a genuinely multi-machine one with a synced-code worker — a Python
+  // Run creates a fresh tab, so the per-tab locality badge can't pre-target it and
+  // the project-wide picker is the only control that can send a run to a worker.
+  // Unset ⇒ `location` is omitted (⇒ the shell default, the primary). A pref naming
+  // a since-removed worker is harmless: CenterPanel/`wrap_pty_options` fall the tab
+  // back to the primary.
+  const runHost = useRunHostPrefStore.getState().byProject[scope];
+  const tab: Omit<TabEntry, "key"> = {
+    label: pyTabLabel(mode, file),
+    cmd: "", // the host's default shell
+    cwd: projectDir,
+    kind: "shell",
+    env: { [PY_TARGET_ENV]: file, [PY_MODE_ENV]: mode },
+    initialInput: command,
+    runFile: file,
+    ...(runHost ? { location: runHost } : {}),
+  };
+  // A placer OWNS insertion. It returns the created entry for a main-window store
+  // write (which we then activate), or null when it streamed the tab elsewhere (a
+  // detached popout, which owns its own tabs) — in which case there's nothing in
+  // this store to activate. Only with NO placer do we use the default scope group.
+  if (place) {
+    const entry = place(tab);
+    if (entry) useTabsStore.getState().setActive(entry.key);
+    return;
+  }
+  const entry = useTabsStore.getState().addTabToScope(scope, tab);
+  useTabsStore.getState().setActive(entry.key);
+}
+
+/** The login-node gate for a Python run/debug, resolving the run host the same
+ *  way {@link openPythonTab} does — the project's run-host preference. Returns
+ *  whether to go ahead; `false` means the user backed out or took an interactive
+ *  job instead. */
+async function guardRunHost(scope: string, projectId: string | null): Promise<boolean> {
+  const runHost = useRunHostPrefStore.getState().byProject[scope];
+  return guardLoginNodeRun({ projectId, location: runHost, kind: "login-node-run" });
+}
+
+/** Run `file` in a fresh terminal tab. */
+export async function runPythonFile(opts: {
+  file: string;
+  projectDir: string;
+  scope: string;
+  /** The project whose pinned interpreter applies; null in the root scope. */
+  projectId: string | null;
+  /** Raw argument string appended after the file (see buildRunCommand). */
+  args?: string;
+  /** Where to insert the run tab (see openPythonTab); defaults to the scope group. */
+  place?: PyTabPlacer;
+}): Promise<void> {
+  // A run lands on whichever machine the project's run-host preference names, and
+  // if that machine is a tagged cluster login node, ask before computing there
+  // (`lib/hpcGuard.ts`). Untagged hosts and local runs never see this.
+  if (!(await guardRunHost(opts.scope, opts.projectId))) return;
+  const platform = currentPlatform();
+  const interp = await resolveInterpreter(opts.projectId, opts.projectDir, platform);
+  openPythonTab({
+    mode: "run",
+    file: opts.file,
+    projectDir: opts.projectDir,
+    scope: opts.scope,
+    command: buildRunCommand(interp, opts.file, platform, opts.args),
+    place: opts.place,
+  });
+}
+
+/** Debug `file` under pdb, breaking on `breakpoints` (1-based lines). */
+export async function debugPythonFile(opts: {
+  file: string;
+  projectDir: string;
+  scope: string;
+  projectId: string | null;
+  breakpoints: number[];
+  /** Raw argument string appended after the file (see buildDebugCommand). */
+  args?: string;
+  /** Where to insert the debug tab (see openPythonTab); defaults to the scope group. */
+  place?: PyTabPlacer;
+}): Promise<void> {
+  if (!(await guardRunHost(opts.scope, opts.projectId))) return;
+  const platform = currentPlatform();
+  const interp = await resolveInterpreter(opts.projectId, opts.projectDir, platform);
+  openPythonTab({
+    mode: "debug",
+    file: opts.file,
+    projectDir: opts.projectDir,
+    scope: opts.scope,
+    command: buildDebugCommand(interp, opts.file, opts.breakpoints, platform, opts.args),
+    place: opts.place,
+  });
+}
+
+/** The project root to run from: the project's directory when the viewer has one,
+ *  else the file's own directory (a file opened in the root scope). */
+export function runCwd(projectDir: string | null | undefined, file: string): string {
+  return projectDir && projectDir.trim() ? projectDir : dirname(file) || "/";
+}
+
+/**
+ * The placer for the "Run opens in the focused subwindow" policy — where every
+ * viewer (the right-panel tree, the Files (Project) tab, and a code editor tab)
+ * sends its run/debug terminal.
+ *
+ * Inside a detached popout (`fileDrop` non-null) the main tab store isn't ours, so
+ * the tab must stream into THAT window via its controller (returns null so no
+ * main-store activate happens). Otherwise it returns `undefined`, which tells
+ * {@link openPythonTab} to use its default placement: `addTabToScope(scope, …)` —
+ * the focused subwindow of the project that owns the file. That is deliberately
+ * NOT "beside the tab you clicked from": a Run always lands where the user is
+ * looking, not in whichever subwindow happens to host the trigger.
+ */
+export function placeForFocused(
+  fileDrop: { openTab: (tab: Omit<TabEntry, "key">) => void } | null,
+): PyTabPlacer | undefined {
+  if (!fileDrop) return undefined;
+  return (tab) => {
+    fileDrop.openTab(tab);
+    return null;
+  };
+}
diff --git a/src/lib/recurrence.ts b/src/lib/recurrence.ts
new file mode 100644
index 0000000..c39a074
--- /dev/null
+++ b/src/lib/recurrence.ts
@@ -0,0 +1,375 @@
+/**
+ * Recurrence expansion — turning stored events into the occurrences a view draws.
+ *
+ * Every view asks for a *window* (the visible month/week/day) and gets back the
+ * occurrences falling inside it. A non-recurring event yields exactly one; a
+ * recurring one yields as many as the window holds. Expansion is always
+ * window-bounded, which is what makes an endless rule (no `until`, no `count`)
+ * safe to store and cheap to draw.
+ *
+ * Two escape hatches let a single occurrence break from its master, matching what
+ * "this event only" means in every desktop calendar:
+ *   - `exdates` — occurrence starts that were deleted from the series.
+ *   - `overrides` — occurrence starts whose fields were edited.
+ * Both are keyed by the occurrence's *original, rule-generated* start, so an
+ * override that moves the occurrence to another day still matches on the next
+ * expansion.
+ *
+ * Pure — no React, no Tauri. Unit-tested in `src/__tests__/Recurrence.test.ts`.
+ */
+
+import type { CalendarEvent, EventStatus, Occurrence, Rrule } from "../types";
+import {
+  addDays,
+  addMonths,
+  addYears,
+  datePart,
+  daysInMonth,
+  minutesBetween,
+  addMinutes,
+  normalizeSpan,
+  parseStamp,
+  spanCoversDate,
+  weekdayOf,
+} from "./calendarTime";
+
+/**
+ * Hard ceiling on occurrences generated for one event in one window. A window is
+ * at most a month or two of a daily rule, so this is far above any legitimate
+ * need; it exists so a corrupt rule (interval 0 handled, but e.g. a `count` of a
+ * billion) can never hang the render loop.
+ */
+const MAX_OCCURRENCES = 2000;
+
+/** Build the single occurrence a non-recurring event represents. */
+function baseOccurrence(event: CalendarEvent, occurrenceStart: string, start: string, end: string): Occurrence {
+  return {
+    eventId: event.id,
+    occurrenceStart,
+    start,
+    end,
+    allDay: event.all_day,
+    title: event.title,
+    location: event.location ?? "",
+    notes: event.notes ?? "",
+    category: event.category ?? "",
+    status: (event.status ?? "") as EventStatus | "",
+    calendarId: event.calendar_id,
+    recurring: !!event.rrule,
+    alarms: event.alarms ?? [],
+  };
+}
+
+/**
+ * Step a start stamp to the next candidate under `rule`.
+ *
+ * Weekly rules with `byweekday` are handled by the caller (which walks day by day
+ * within a week); this advances the *period*.
+ */
+function stepPeriod(stamp: string, rule: Rrule): string {
+  const interval = Math.max(1, rule.interval || 1);
+  switch (rule.freq) {
+    case "daily":
+      return addDays(stamp, interval);
+    case "weekly":
+      return addDays(stamp, 7 * interval);
+    case "monthly":
+      return addMonths(stamp, interval);
+    case "yearly":
+      return addYears(stamp, interval);
+    default:
+      return addDays(stamp, interval);
+  }
+}
+
+/**
+ * The rule-generated starts of `event`, from its own start until either the rule
+ * ends or the generated start passes `windowEnd`.
+ *
+ * Generation runs forward from the master's start rather than jumping straight to
+ * the window — `count`-limited rules and `bymonthday` clamping both depend on the
+ * ordinal position, so occurrence N cannot be computed without walking there.
+ * Windows are small and rules are cheap, so the cost is irrelevant in practice.
+ */
+function generateStarts(event: CalendarEvent, windowEnd: string): string[] {
+  const rule = event.rrule;
+  const first = event.start;
+  if (!rule || !parseStamp(first)) return parseStamp(first) ? [first] : [];
+
+  const interval = Math.max(1, rule.interval || 1);
+  const until = rule.until ? datePart(rule.until) : null;
+  const count = rule.count && rule.count > 0 ? rule.count : null;
+
+  const starts: string[] = [];
+  const stop = (candidate: string) => {
+    if (until && datePart(candidate) > until) return true;
+    if (datePart(candidate) > datePart(windowEnd)) return true;
+    if (count !== null && starts.length >= count) return true;
+    return starts.length >= MAX_OCCURRENCES;
+  };
+
+  // Weekly + byweekday: each period is a week, and within it the rule fires on
+  // each selected weekday. Anchor to the week the master starts in.
+  if (rule.freq === "weekly" && rule.byweekday && rule.byweekday.length > 0) {
+    const days = [...new Set(rule.byweekday)].filter((d) => d >= 0 && d <= 6).sort((a, b) => a - b);
+    if (days.length === 0) return [first];
+
+    const time = event.all_day ? "" : (first.split("T")[1] ?? "");
+    const firstDow = weekdayOf(first);
+    // Sunday-anchored start of the master's week; weekday d in week k is
+    // weekStart + 7k + d, which reproduces the master itself when d === firstDow.
+    let weekStart = addDays(datePart(first), -firstDow);
+
+    for (;;) {
+      for (const d of days) {
+        const date = addDays(weekStart, d);
+        // Never emit before the master's own start.
+        if (date < datePart(first)) continue;
+        const candidate = time ? `${date}T${time}` : date;
+        if (stop(candidate)) return starts;
+        starts.push(candidate);
+      }
+      weekStart = addDays(weekStart, 7 * interval);
+      if (datePart(weekStart) > datePart(windowEnd)) return starts;
+      if (until && datePart(weekStart) > until) return starts;
+      if (count !== null && starts.length >= count) return starts;
+      if (starts.length >= MAX_OCCURRENCES) return starts;
+    }
+  }
+
+  // Monthly + bymonthday: pin the day of month, skipping months too short to hold
+  // it (Jan 31 monthly does NOT fire in February — the iCalendar behaviour, and
+  // the one users expect: a "31st of the month" event simply has no February).
+  if (rule.freq === "monthly" && rule.bymonthday) {
+    const day = rule.bymonthday;
+    const time = event.all_day ? "" : (first.split("T")[1] ?? "");
+    const c = parseStamp(first);
+    if (!c) return [];
+    let year = c.year;
+    let month = c.month;
+
+    for (;;) {
+      if (day <= daysInMonth(year, month)) {
+        const date = `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+        if (date >= datePart(first)) {
+          const candidate = time ? `${date}T${time}` : date;
+          if (stop(candidate)) return starts;
+          starts.push(candidate);
+        }
+      }
+      month += interval;
+      while (month > 12) {
+        month -= 12;
+        year += 1;
+      }
+      const probe = `${String(year).padStart(4, "0")}-${String(month).padStart(2, "0")}-01`;
+      if (probe > datePart(windowEnd)) return starts;
+      if (until && probe > until) return starts;
+      if (count !== null && starts.length >= count) return starts;
+      if (starts.length >= MAX_OCCURRENCES) return starts;
+    }
+  }
+
+  // Plain daily / weekly / monthly / yearly: step the period from the master.
+  let cur = first;
+  for (;;) {
+    if (stop(cur)) return starts;
+    starts.push(cur);
+    cur = stepPeriod(cur, rule);
+  }
+}
+
+/**
+ * Expand `event` into the occurrences overlapping `[windowStart, windowEnd)`.
+ *
+ * The window is compared by *date*, and an occurrence is kept if any part of it
+ * falls inside — so a multi-day event that began before the window still shows on
+ * the days it covers. Deleted occurrences (`exdates`) are dropped and edited ones
+ * (`overrides`) have their fields applied, both keyed by the rule-generated start.
+ */
+export function expandEvent(
+  event: CalendarEvent,
+  windowStart: string,
+  windowEnd: string,
+): Occurrence[] {
+  if (!parseStamp(event.start)) return [];
+
+  const exdates = new Set(event.exdates ?? []);
+  const overrides = new Map((event.overrides ?? []).map((o) => [o.occurrence_start, o]));
+
+  // A recurring event's occurrences never start before the master, but a
+  // long-running one may still cover the window's first days, so generation runs
+  // to windowEnd and the window filter below decides what is visible.
+  const starts = generateStarts(event, windowEnd);
+
+  // Duration is taken from the master and carried to every occurrence, so moving
+  // the master's end lengthens the whole series (what an unqualified edit means).
+  const master = normalizeSpan({ start: event.start, end: event.end, allDay: event.all_day });
+  const durationMin = event.all_day ? 0 : minutesBetween(master.start, master.end);
+  const durationDays = event.all_day
+    ? Math.max(1, Math.round(
+        (new Date(datePart(master.end)).getTime() - new Date(datePart(master.start)).getTime()) / 86_400_000,
+      ))
+    : 0;
+
+  const out: Occurrence[] = [];
+
+  for (const occurrenceStart of starts) {
+    if (exdates.has(occurrenceStart)) continue;
+
+    let start = occurrenceStart;
+    let end = event.all_day
+      ? addDays(datePart(occurrenceStart), durationDays)
+      : addMinutes(occurrenceStart, durationMin);
+
+    const occ = baseOccurrence(event, occurrenceStart, start, end);
+
+    const ov = overrides.get(occurrenceStart);
+    if (ov) {
+      if (ov.start) {
+        start = ov.start;
+        // An override that moves the start but not the end keeps the duration.
+        end = event.all_day
+          ? addDays(datePart(start), durationDays)
+          : addMinutes(start, durationMin);
+        occ.start = start;
+        occ.end = end;
+      }
+      if (ov.end) occ.end = ov.end;
+      if (ov.title != null) occ.title = ov.title;
+      if (ov.location != null) occ.location = ov.location;
+      if (ov.notes != null) occ.notes = ov.notes;
+    }
+
+    // Keep it only if it actually shows in the window. `spanCoversDate` is the
+    // same predicate the views use, so what survives here is exactly what draws.
+    const span = { start: occ.start, end: occ.end, allDay: occ.allDay };
+    let visible = false;
+    for (let d = datePart(windowStart); d < datePart(windowEnd); d = addDays(d, 1)) {
+      if (spanCoversDate(span, d)) {
+        visible = true;
+        break;
+      }
+    }
+    if (visible) out.push(occ);
+  }
+
+  return out;
+}
+
+/**
+ * Expand every event into the occurrences visible in `[windowStart, windowEnd)`,
+ * sorted for display: all-day events first (they render as bars above the grid),
+ * then by start.
+ *
+ * `visibleCalendars` — when given — drops occurrences whose calendar is unchecked
+ * in the sidebar.
+ */
+export function expandEvents(
+  events: CalendarEvent[],
+  windowStart: string,
+  windowEnd: string,
+  visibleCalendars?: Set<string>,
+): Occurrence[] {
+  const out: Occurrence[] = [];
+  for (const event of events) {
+    if (visibleCalendars && !visibleCalendars.has(event.calendar_id)) continue;
+    out.push(...expandEvent(event, windowStart, windowEnd));
+  }
+  return sortOccurrences(out);
+}
+
+/** All-day first, then chronological, then by title so the order is stable. */
+export function sortOccurrences(occurrences: Occurrence[]): Occurrence[] {
+  return [...occurrences].sort((a, b) => {
+    if (a.allDay !== b.allDay) return a.allDay ? -1 : 1;
+    if (a.start !== b.start) return a.start < b.start ? -1 : 1;
+    return a.title.localeCompare(b.title);
+  });
+}
+
+/** The occurrences of a given day, in display order. */
+export function occurrencesOn(occurrences: Occurrence[], date: string): Occurrence[] {
+  return occurrences.filter((o) =>
+    spanCoversDate({ start: o.start, end: o.end, allDay: o.allDay }, date),
+  );
+}
+
+// ── Editing a series ────────────────────────────────────────────────────────
+
+/**
+ * Delete one occurrence of a series ("this event only") by excluding its
+ * rule-generated start. Returns the updated master.
+ */
+export function excludeOccurrence(event: CalendarEvent, occurrenceStart: string): CalendarEvent {
+  const exdates = new Set(event.exdates ?? []);
+  exdates.add(occurrenceStart);
+  return {
+    ...event,
+    exdates: [...exdates].sort(),
+    // An override for a now-deleted occurrence is dead weight.
+    overrides: (event.overrides ?? []).filter((o) => o.occurrence_start !== occurrenceStart),
+  };
+}
+
+/**
+ * Edit one occurrence of a series ("this event only"), leaving the rest alone.
+ * `changes` are the fields that differ from the master. Returns the updated master.
+ */
+export function overrideOccurrence(
+  event: CalendarEvent,
+  occurrenceStart: string,
+  changes: Partial<Pick<Occurrence, "start" | "end" | "title" | "location" | "notes">>,
+): CalendarEvent {
+  const rest = (event.overrides ?? []).filter((o) => o.occurrence_start !== occurrenceStart);
+  const existing = (event.overrides ?? []).find((o) => o.occurrence_start === occurrenceStart);
+  return {
+    ...event,
+    overrides: [
+      ...rest,
+      {
+        ...existing,
+        occurrence_start: occurrenceStart,
+        ...changes,
+      },
+    ].sort((a, b) => a.occurrence_start.localeCompare(b.occurrence_start)),
+  };
+}
+
+/** Whether an event actually repeats. */
+export function isRecurring(event: CalendarEvent): boolean {
+  return !!event.rrule;
+}
+
+/** A short human summary of a rule, for the event list and the editor. */
+export function describeRrule(rule: Rrule | null | undefined): string {
+  if (!rule) return "Does not repeat";
+  const n = Math.max(1, rule.interval || 1);
+  const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+
+  let base: string;
+  switch (rule.freq) {
+    case "daily":
+      base = n === 1 ? "Daily" : `Every ${n} days`;
+      break;
+    case "weekly": {
+      const days = (rule.byweekday ?? []).filter((d) => d >= 0 && d <= 6).sort((a, b) => a - b);
+      const on = days.length ? ` on ${days.map((d) => WEEKDAYS[d]).join(", ")}` : "";
+      base = (n === 1 ? "Weekly" : `Every ${n} weeks`) + on;
+      break;
+    }
+    case "monthly":
+      base = (n === 1 ? "Monthly" : `Every ${n} months`) +
+        (rule.bymonthday ? ` on day ${rule.bymonthday}` : "");
+      break;
+    case "yearly":
+      base = n === 1 ? "Yearly" : `Every ${n} years`;
+      break;
+    default:
+      base = "Repeats";
+  }
+
+  if (rule.count) return `${base}, ${rule.count} times`;
+  if (rule.until) return `${base}, until ${rule.until}`;
+  return base;
+}
diff --git a/src/lib/remoteAutoReconnect.ts b/src/lib/remoteAutoReconnect.ts
new file mode 100644
index 0000000..772fa27
--- /dev/null
+++ b/src/lib/remoteAutoReconnect.ts
@@ -0,0 +1,79 @@
+import { useVpnStatusStore } from "../stores/vpnStatus";
+import { useGlobalMachinesStore } from "../stores/globalMachines";
+import { useSettingsStore, whenSettingsLoaded } from "../stores/settings";
+import { retryAutoConnectAfterVpn } from "../stores/projects";
+
+/**
+ * Wire the two *event-driven* halves of remote auto-connect that the imperative
+ * connect paths can't own by themselves. The launch-time half already lives where
+ * it belongs — a project's active-project auto-connect fires from `projects.load()`
+ * / `setActive`, the armed VPN tunnel from `autoConnectVpnOnLaunch`. What was
+ * missing is a reaction to a **tunnel coming up**:
+ *
+ *  1. **On any tunnel becoming active**, re-attempt the things that were only
+ *     unreachable *because* the routing wasn't there yet — the active remote
+ *     project (`retryAutoConnectAfterVpn`) and every armed global machine. This is
+ *     what makes a project reachable *only through the VPN* connect promptly the
+ *     instant the tunnel is up, instead of sitting red until the user acts. It fires
+ *     whoever brought the tunnel up — the armed launch tunnel, a header connect, or
+ *     another project — because a tunnel is machine-wide.
+ *  2. **At launch**, sweep the global machines armed for auto-connect (the project
+ *     side already self-starts from its store) — but only when the Machines feature
+ *     is actually on, and only once settings have loaded to say so (`machineSweep`).
+ *
+ * We subscribe to the machine-level VPN store rather than poll, so the retry is
+ * immediate on the exact `→ connected` transition (an earlier poll-based reaction
+ * lagged the tunnel by seconds). Idempotent by construction: the retry paths skip a
+ * live/winning lamp, and `setState` collapses a no-op transition, so a tunnel that
+ * comes up as a *side effect* of an auto-connect (a project bringing up its own
+ * VPN) can't feed back into a loop.
+ */
+
+let installed = false;
+
+export function initRemoteAutoReconnect(): void {
+  if (installed) return;
+  installed = true;
+
+  // React to a tunnel becoming active. `refresh()` at launch seats a tunnel that
+  // outlived a previous run (prev has no entry → this fires for it too), which is
+  // exactly right: a remote reachable only through that tunnel should connect.
+  useVpnStatusStore.subscribe((state, prev) => {
+    const roseToConnected = Object.entries(state.byConfig).some(
+      ([config, s]) => s === "connected" && prev.byConfig[config] !== "connected",
+    );
+    if (roseToConnected) onVpnTunnelUp();
+  });
+
+  // Launch-time global-machine sweep, decoupled from the header component so it runs
+  // even before the Machines menu is ever opened.
+  void machineSweep();
+}
+
+/**
+ * The armed-machine sweep, behind the **feature switch**.
+ *
+ * `machines_enabled` is off by default and hides the header indicator — which was
+ * the whole surface for seeing a machine connect, disconnecting one, or disarming
+ * its toggle. Sweeping anyway meant a user who turned the feature off (or never
+ * turned it on, and imported a machine list once) still had every armed host
+ * dialled at launch and again on every tunnel-up, with nowhere to watch it happen
+ * and nothing to stop it with. A feature that is off connects nothing.
+ *
+ * Gated on settings being **loaded**, not merely present: an unloaded store reads
+ * as "off" for every field, so firing before it arrives would race the switch on
+ * exactly the launch path this is. Waiting costs a few hundred ms; the sweep is
+ * silent by construction and nothing is watching for it.
+ */
+async function machineSweep(): Promise<void> {
+  await whenSettingsLoaded();
+  if (!useSettingsStore.getState().settings?.machines_enabled) return;
+  const gm = useGlobalMachinesStore.getState();
+  if (!gm.loaded) await gm.load();
+  await useGlobalMachinesStore.getState().autoConnect();
+}
+
+function onVpnTunnelUp(): void {
+  retryAutoConnectAfterVpn();
+  void machineSweep();
+}
diff --git a/src/lib/remoteConnect.ts b/src/lib/remoteConnect.ts
new file mode 100644
index 0000000..bf82db5
--- /dev/null
+++ b/src/lib/remoteConnect.ts
@@ -0,0 +1,116 @@
+import { invoke } from "@tauri-apps/api/core";
+import { useTabsStore } from "../stores/tabs";
+import { useProjectsStore } from "../stores/projects";
+
+/**
+ * The directory a fresh connect/browse should open in for `host`: the standard
+ * path set in Settings' "Remote Connections" panel if there is one, else the
+ * SSH-reported home directory. Best-effort — either lookup failing just falls
+ * through to the next, never blocking a connect that already succeeded.
+ *
+ * Shared by every remote connect+browse flow (`useRemoteSession` for the
+ * new/extend-project dialog, `RemoteMachinesWindow` for add-worker-machine) so
+ * they resolve the starting folder identically.
+ */
+export async function resolveRemoteStartDir(
+  user: string | null | undefined,
+  host: string,
+  port: number | null | undefined,
+  password: string | null,
+): Promise<string> {
+  const configured = await invoke<string | null>("remote_get_default_path", { host }).catch(
+    () => null,
+  );
+  if (configured) return configured;
+  return invoke<string>("ssh_default_dir", { user, host, port, password }).catch(() => "");
+}
+
+/**
+ * Non-headless remote-connection support: instead of Eldrun handling the
+ * SSH/OpenVPN password itself, the actual connecting command is launched as an
+ * interactive shell tab in the Eldrun **root** scope, where the user types the
+ * password directly into the live terminal. Eldrun never sees or stores it.
+ *
+ * Gated by the `connections_headless` setting (default ON = old headless flow).
+ */
+
+/**
+ * Configs/targets we've already opened a connection tab for this session, so a
+ * project that is re-activated several times doesn't spawn a duplicate tab each
+ * time. Keyed by an opaque caller-supplied string (the .ovpn path or the SSH
+ * target). Session-only — cleared on reload like other transient state.
+ *
+ * The value is the **root tab** carrying that connection, or `null` for a
+ * connection some other surface owns (`markConnectionOpened` — the Connect dialog's
+ * embedded terminal). That distinction is what makes the dedupe self-healing rather
+ * than sticky: a tab the user closed is not a connection, so the mark expires with
+ * it. Without that, closing the login tab left the key claimed for the rest of the
+ * session and every later request — an activation, an auto-connect — silently opened
+ * nothing and then waited on a master that was never coming.
+ */
+const openedConnections = new Map<string, string | null>();
+
+/** Reset the dedupe entry (e.g. when a connection is torn down). */
+export function forgetConnection(dedupeKey: string): void {
+  openedConnections.delete(dedupeKey);
+}
+
+/** Whether this connection's terminal is still around to authenticate in. A tab
+ *  owned elsewhere (`null`) is that surface's business, not ours. Exported because a
+ *  caller waiting on the user to log in (`pollRootLoginReady`) needs to know when
+ *  they closed the tab instead — that is a "never mind", not a failure. */
+export function connectionStillOpen(dedupeKey: string): boolean {
+  if (!openedConnections.has(dedupeKey)) return false;
+  const tabKey = openedConnections.get(dedupeKey);
+  if (tabKey == null) return true;
+  return (useTabsStore.getState().tabsByScope.root ?? []).some((t) => t.key === tabKey);
+}
+
+/**
+ * Mark a connection as already opened WITHOUT spawning a root tab. The
+ * non-headless project dialog uses this when it brings a VPN tunnel / SSH login
+ * up in its own embedded terminal: pre-marking the same `dedupeKey` that
+ * activation would use makes the later `openConnectionInRoot` call a no-op, so
+ * the connection the user already authenticated in the dialog isn't duplicated
+ * as a root-terminal tab.
+ */
+export function markConnectionOpened(dedupeKey: string): void {
+  openedConnections.set(dedupeKey, null);
+}
+
+/**
+ * Open `command` as an interactive shell tab in the **root** scope. `command` is
+ * typed into the freshly-spawned shell via the tab's `initialInput` (see
+ * TerminalView), so a password prompt it raises is answered in that visible
+ * terminal — Eldrun never handles the password.
+ *
+ * The active project is deliberately NOT changed (this is called mid-activation,
+ * where switching scope would undo the activation in progress); instead a brief
+ * toast points the user at the root terminal. The user switches to root to
+ * authenticate when ready; downstream sshfs mounts retry and ride the shared
+ * master once it is up.
+ *
+ * `dedupeKey` suppresses a duplicate tab when the same connection is requested
+ * again within the session — but only while that tab is still there to type into
+ * (see `connectionStillOpen`); pass `null` to always open a new tab.
+ */
+export function openConnectionInRoot(opts: {
+  label: string;
+  command: string;
+  dedupeKey?: string | null;
+}): void {
+  const { label, command, dedupeKey } = opts;
+  if (dedupeKey != null && connectionStillOpen(dedupeKey)) return;
+  const rootDir = useProjectsStore.getState().rootDir ?? "";
+  const tab = useTabsStore.getState().addTabToScope("root", {
+    label,
+    cmd: "", // empty → backend default_shell()
+    cwd: rootDir, // empty resolves to ~/eldrun/root on the backend
+    kind: "shell",
+    initialInput: command,
+  });
+  if (dedupeKey != null) openedConnections.set(dedupeKey, tab.key);
+  // Surface it without stealing the active project: a transient toast (auto-clears
+  // in AppShell) tells the user the connection is waiting in the root terminal.
+  useProjectsStore.setState({ switchToast: `${label} — authenticate in root terminal` });
+}
diff --git a/src/lib/remoteHosts.ts b/src/lib/remoteHosts.ts
new file mode 100644
index 0000000..83b563f
--- /dev/null
+++ b/src/lib/remoteHosts.ts
@@ -0,0 +1,34 @@
+import { PRIMARY_HOST } from "../stores/remoteStatus";
+import { targetOfSpec, type Target } from "./carefulHost";
+import type { ProjectEntry } from "../types";
+
+export interface RemoteHostRef {
+  id: string;
+  label: string;
+  /** The host's SSH target (`user@host:port`) — the identity the **careful**
+   *  flag is keyed by (`lib/carefulHost.ts`), since one physical machine can be
+   *  this project's worker, another's primary and a global machine at once. The
+   *  host id cannot serve: it is per-record, the flag is per-machine. */
+  target: Target | null;
+}
+
+/**
+ * Every host a project's remote spans: the primary, then each `compute_hosts`
+ * worker (multi-host remote, `docs/multi_host_remote_plan.md`) — the same host
+ * set the System Monitor's source picker and the combined usage dialog both
+ * need. Empty for a non-remote project.
+ */
+export function hostsForProject(project: ProjectEntry | undefined): RemoteHostRef[] {
+  if (!project?.remote) return [];
+  const list: RemoteHostRef[] = [
+    {
+      id: PRIMARY_HOST,
+      label: project.remote.label || project.remote.host,
+      target: targetOfSpec(project.remote),
+    },
+  ];
+  for (const w of project.compute_hosts ?? []) {
+    list.push({ id: w.id, label: w.label || w.host, target: targetOfSpec(w) });
+  }
+  return list;
+}
diff --git a/src/lib/shellScriptRun.ts b/src/lib/shellScriptRun.ts
new file mode 100644
index 0000000..a87ccc3
--- /dev/null
+++ b/src/lib/shellScriptRun.ts
@@ -0,0 +1,107 @@
+import { relativePathWithin } from "./paths";
+import { isRemoteLocation, type TabLocation } from "../stores/tabs";
+import type { ProjectEntry } from "../types";
+
+export type ScriptShell = "bash" | "zsh" | "fish" | "ksh" | "powershell" | "cmd";
+
+export interface ShellScriptRunPlan {
+  cwd: string;
+  scriptRel: string;
+  initialInput: string;
+  location?: TabLocation;
+}
+
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/** Which interpreter runs a script of this extension, keyed by lowercased ending.
+ *  The cross-platform shells run everywhere; `.ps1`/`.bat`/`.cmd` are Windows-only
+ *  here (`pwsh` on Linux is too rarely installed to advertise the action). Returns
+ *  null for an ending we don't know how to run, so no Run button is offered. */
+export function shellRunnerFor(
+  extension: string | null,
+  platform: "windows" | string,
+): ScriptShell | null {
+  const ext = (extension ?? "").toLowerCase();
+  const win = platform === "windows";
+  switch (ext) {
+    case ".sh":
+    case ".bash":
+      return "bash";
+    case ".zsh":
+      return "zsh";
+    case ".fish":
+      return "fish";
+    case ".ksh":
+      return "ksh";
+    case ".ps1":
+      return win ? "powershell" : null;
+    case ".bat":
+    case ".cmd":
+      return win ? "cmd" : null;
+    default:
+      return null;
+  }
+}
+
+/** The command line that runs `scriptRel` under `interp`. PowerShell and cmd take
+ *  a flag before the path; the POSIX shells take it as a bare argument. */
+export function shellRunCommand(interp: ScriptShell, scriptRel: string): string {
+  const quoted = shellQuote(scriptRel);
+  if (interp === "powershell") return `powershell -File ${quoted}`;
+  if (interp === "cmd") return `cmd /c ${quoted}`;
+  return `${interp} ${quoted}`;
+}
+
+export function scriptRelFromRoot(root: string, absPath: string): string | null {
+  const rel = relativePathWithin(root, absPath);
+  return rel && rel.trim() ? rel : null;
+}
+
+/** Build the foreground terminal-tab run for a shell script from the tree side the
+ *  user is browsing. Mount-free remote listings return host paths, while the
+ *  tree's `projectDir` is the local state dir; using that dir to relativize a
+ *  host path produced `bash ''`. Use the host `remote_path` for remote-source
+ *  rows to compute the script's project-relative path.
+ *
+ *  WHERE the script runs is the project's run-host preference (`runHostPref`, the
+ *  machine chosen in the `RunHostPicker`) when set — so "pick machine X ⇒ shells
+ *  run on X" holds for a script Run exactly as for a Python Run — falling back to
+ *  the browsed side. `scriptRel` is project-relative, so it resolves against the
+ *  chosen host's own project root (the backend re-cds into the target host's
+ *  `remote_path`) or the local mirror, whichever the run location names — the two
+ *  sides mirror the same tree. */
+export function shellScriptRunPlan(opts: {
+  project: ProjectEntry | null | undefined;
+  treeRoot: string;
+  syncSource?: "remote" | "local";
+  scriptPath: string;
+  interp: ScriptShell;
+  /** The project's run-host preference (`useRunHostPrefStore`), if any. */
+  runHostPref?: TabLocation;
+}): ShellScriptRunPlan | null {
+  const remote = opts.project?.remote;
+  const isRemoteProject = !!remote;
+  const browsedRemote = isRemoteProject && opts.syncSource !== "local";
+  // The script's project-relative path, computed from the side it was browsed on
+  // (that is the side `scriptPath` belongs to).
+  const browsedRoot = browsedRemote ? remote.remote_path : opts.treeRoot;
+  const scriptRel = scriptRelFromRoot(browsedRoot, opts.scriptPath);
+  if (!scriptRel) return null;
+  // The run location: the chosen machine wins; unset ⇒ the browsed side.
+  const location: TabLocation | undefined = isRemoteProject
+    ? (opts.runHostPref ?? (browsedRemote ? "remote" : "local"))
+    : undefined;
+  // The tab cwd must match the run side so `scriptRel` resolves: the host project
+  // root for a remote run (the backend re-cds into the *target* host's remote_path
+  // anyway), the local mirror for a local run.
+  const runsRemote = location ? isRemoteLocation(location) : false;
+  const cwd = runsRemote && remote ? remote.remote_path : opts.treeRoot;
+  return {
+    cwd,
+    scriptRel,
+    initialInput: shellRunCommand(opts.interp, scriptRel),
+    location,
+  };
+}
diff --git a/src/lib/shortcuts.ts b/src/lib/shortcuts.ts
index b162dc5..2c64ff1 100644
--- a/src/lib/shortcuts.ts
+++ b/src/lib/shortcuts.ts
@@ -11,6 +11,7 @@
  * Escape (exit fullscreen) are deliberately *not* rebindable — they stay fixed
  * in `useKeyboard` — so only the eight navigation actions live here.
  */
+import { IS_MAC } from "./platform";
 
 /** A serializable key chord. `key` is a `KeyboardEvent.key` value, normalized:
  *  single letters are lower-cased, named keys ("Tab", "Enter", "ArrowLeft")
@@ -27,11 +28,13 @@ export interface ChordDescriptor {
 export type ShortcutAction =
   | "toggleFullscreen"
   | "cycleProject"
-  | "focusLeft"
-  | "focusRight"
-  | "focusUp"
-  | "focusDown"
+  | "prevTab"
+  | "nextTab"
+  | "subwindowUp"
+  | "subwindowDown"
   | "cycleTabs"
+  | "hideSubwindow"
+  | "toggleSubwindowFiles"
   | "closeSubwindow"
   | "closeTab"
   | "closeAllTabs";
@@ -60,23 +63,23 @@ export const SHORTCUT_DEFS: ShortcutDef[] = [
     default: { key: "Tab", ctrl: true, shift: true },
   },
   {
-    action: "focusLeft",
-    label: "Focus subwindow left",
+    action: "prevTab",
+    label: "Previous tab in subwindow",
     default: { key: "ArrowLeft", shift: true },
   },
   {
-    action: "focusRight",
-    label: "Focus subwindow right",
+    action: "nextTab",
+    label: "Next tab in subwindow",
     default: { key: "ArrowRight", shift: true },
   },
   {
-    action: "focusUp",
-    label: "Focus subwindow up",
+    action: "subwindowUp",
+    label: "Cycle focused subwindow up",
     default: { key: "ArrowUp", shift: true },
   },
   {
-    action: "focusDown",
-    label: "Focus subwindow down",
+    action: "subwindowDown",
+    label: "Cycle focused subwindow down",
     default: { key: "ArrowDown", shift: true },
   },
   {
@@ -84,6 +87,16 @@ export const SHORTCUT_DEFS: ShortcutDef[] = [
     label: "Cycle tabs in subwindow",
     default: { key: "Tab", shift: true },
   },
+  {
+    action: "hideSubwindow",
+    label: "Hide focused subwindow",
+    default: { key: "h", ctrl: true, shift: true },
+  },
+  {
+    action: "toggleSubwindowFiles",
+    label: "Toggle subwindow file viewer",
+    default: { key: "f", shift: true },
+  },
   {
     action: "closeSubwindow",
     label: "Close focused subwindow",
@@ -140,19 +153,45 @@ export function chordFromEvent(e: KeyboardEvent): ChordDescriptor | null {
   return chord;
 }
 
-/** True when `e` matches `chord` (modifiers exact, key normalized). */
+/**
+ * True when `e` matches `chord` (key normalized).
+ *
+ * Primary-modifier handling (macOS): the platform-primary modifier is Cmd
+ * (metaKey) on macOS and Ctrl elsewhere. The default chord table encodes the
+ * primary modifier as `ctrl` (its historical Linux/Windows shape). Rather than
+ * fork the whole table, on macOS we treat a chord's primary-modifier
+ * requirement — whether it was stored as `ctrl` (a default) or `meta` (a mac
+ * user's captured rebind) — as satisfied by EITHER Cmd or Ctrl. So both Cmd+W
+ * and Ctrl+W fire on a mac, while a plain key still rejects a stray Cmd press.
+ * This collapses ⌘/⌃ into one "primary" on macOS (you can't bind a mac-only
+ * Control-vs-Command distinction) — the deliberate, low-risk trade-off the task
+ * calls for. Off macOS, modifiers are matched exactly as before.
+ */
 export function chordMatches(chord: ChordDescriptor, e: KeyboardEvent): boolean {
-  return (
-    normalizeKey(e.key) === normalizeKey(chord.key) &&
-    e.ctrlKey === !!chord.ctrl &&
-    e.shiftKey === !!chord.shift &&
-    e.altKey === !!chord.alt &&
-    e.metaKey === !!chord.meta
-  );
+  if (normalizeKey(e.key) !== normalizeKey(chord.key)) return false;
+  if (e.shiftKey !== !!chord.shift) return false;
+  if (e.altKey !== !!chord.alt) return false;
+  if (IS_MAC) {
+    const wantsPrimary = !!chord.ctrl || !!chord.meta;
+    const hasPrimary = e.ctrlKey || e.metaKey;
+    return wantsPrimary === hasPrimary;
+  }
+  return e.ctrlKey === !!chord.ctrl && e.metaKey === !!chord.meta;
 }
 
-/** Human-readable label for a chord, e.g. "Shift+Ctrl+Tab". */
+/** Human-readable label for a chord, e.g. "Shift+Ctrl+Tab" — or native mac
+ *  glyphs ("⇧⌘Tab") on macOS. On macOS the primary modifier (stored as `ctrl`)
+ *  and `meta`/Super both render as ⌘ (deduped), matching what a mac user
+ *  actually presses; off macOS the textual labels are unchanged. */
 export function chordLabel(chord: ChordDescriptor): string {
+  if (IS_MAC) {
+    const parts: string[] = [];
+    if (chord.alt) parts.push("⌥"); // Option
+    if (chord.shift) parts.push("⇧"); // Shift
+    if (chord.ctrl || chord.meta) parts.push("⌘"); // primary modifier / Super
+    parts.push(prettyKey(chord.key));
+    return parts.join(""); // mac convention concatenates the glyphs
+  }
   const parts: string[] = [];
   if (chord.ctrl) parts.push("Ctrl");
   if (chord.shift) parts.push("Shift");
diff --git a/src/lib/slurm.ts b/src/lib/slurm.ts
new file mode 100644
index 0000000..756ae0c
--- /dev/null
+++ b/src/lib/slurm.ts
@@ -0,0 +1,393 @@
+/**
+ * SLURM run/watch glue for HPC projects (`docs/quirky-knitting-umbrella` plan).
+ *
+ * A SLURM cluster forbids real computation on the login node — everything heavy
+ * goes through the scheduler.
+ * This module lets a `.slurm` file be submitted, watched, and cancelled from the
+ * code viewer without the user memorizing `sbatch`/`squeue`/`scancel`.
+ *
+ * Two halves, both modeled on `lib/pythonRun.ts`:
+ *
+ *  1. **Pure text helpers** — `isSlurmScript`, `parseSbatchDirectives`,
+ *     `spliceDirective`. Like the YAML/table viewers, the directive form *renders
+ *     rows but edits text*: `spliceDirective` edits the file's `#SBATCH` lines by
+ *     splicing, never re-serializing, so every other byte of the script is left
+ *     alone and each edit is an ordinary dirty/undoable/saveable change.
+ *  2. **Tab glue** — the **log window** and the **interactive job shell** are just
+ *     terminal tabs, exactly as a Python run is. A tab carries locality and tmux
+ *     persistence for free, so a `tail -F` of the job log reattaches on relaunch
+ *     and an `srun --pty` lands on a compute node (the compliant interactive path).
+ */
+
+import { invoke } from "@tauri-apps/api/core";
+import { useTabsStore, type TabEntry, type TabLocation } from "../stores/tabs";
+import { useHpcJobsStore, type HpcJob } from "../stores/hpcJobs";
+import { shellQuote } from "./pythonRun";
+import { useProjectsStore } from "../stores/projects";
+import { useSettingsStore } from "../stores/settings";
+import { isHpcHost, targetOfSpec } from "./hpcHost";
+import { basename } from "./paths";
+
+// ── Backend types (mirror `commands::slurm`) ─────────────────────────────────
+
+export interface SlurmInfo {
+  available: boolean;
+  version?: string;
+}
+
+export interface SlurmSubmit {
+  job_id: string;
+  out_file: string;
+  err_file: string;
+  work_dir: string;
+}
+
+export interface SlurmJob {
+  id: string;
+  name: string;
+  state: string;
+  time: string;
+  nodes: string;
+  reason: string;
+}
+
+// ── Invoke wrappers ──────────────────────────────────────────────────────────
+
+/** Is SLURM available on the project's host? Lets the UI hide itself off-HPC. */
+export function slurmAvailable(projectDir: string, hostId?: string): Promise<SlurmInfo> {
+  return invoke<SlurmInfo>("slurm_available", { projectDir, hostId });
+}
+
+/** The current user's jobs on the host (for the Jobs view). */
+export function slurmQueue(projectDir: string, hostId?: string): Promise<SlurmJob[]> {
+  return invoke<SlurmJob[]>("slurm_queue", { projectDir, hostId });
+}
+
+/** Cancel a job by id. */
+export function slurmCancel(projectDir: string, jobId: string, hostId?: string): Promise<void> {
+  return invoke("slurm_cancel", { projectDir, jobId, hostId });
+}
+
+/** Resolve a job's stdout path (for Watch on a job we didn't submit this session).
+ *  `logDir` is the project's recorded HPC log folder (`hpc.logs_dir`): when the
+ *  pipeline routes `--output` into the home anchor, the backend's
+ *  `<WorkDir>/slurm-<id>.out` fallback names a file that never existed, so the
+ *  recorded folder is passed as the better guess. Whatever `scontrol` states
+ *  still wins over both. */
+export function slurmJobOut(
+  projectDir: string,
+  jobId: string,
+  hostId?: string,
+  logDir?: string,
+): Promise<string> {
+  return invoke<string>("slurm_job_out", { projectDir, jobId, hostId, logDir });
+}
+
+// ── #SBATCH directive parsing / splicing (render rows, edit text) ─────────────
+
+/** One `#SBATCH` field surfaced in the directive form. `key` is always the LONG
+ *  form (`job-name`), even when the file wrote the short flag (`-J`). */
+export interface SbatchField {
+  key: string;
+  value: string;
+}
+
+/** The keys the directive form surfaces as labeled fields, in display order. */
+export const COMMON_SBATCH_KEYS = [
+  "job-name",
+  "account",
+  "partition",
+  "time",
+  "nodes",
+  "ntasks",
+  "cpus-per-task",
+  "mem",
+  "gres",
+  "output",
+] as const;
+
+/** Short `sbatch` flags → their long equivalents, so `-t`/`--time` fold into one
+ *  field in the form. Only the flags the form surfaces need an entry. */
+const SHORT_TO_LONG: Record<string, string> = {
+  J: "job-name",
+  A: "account",
+  p: "partition",
+  t: "time",
+  N: "nodes",
+  n: "ntasks",
+  c: "cpus-per-task",
+  o: "output",
+  e: "error",
+};
+
+/** A `#SBATCH` directive line, matched leniently: optional leading space, `#SBATCH`
+ *  (case-insensitive), the flag, then `=value` or ` value`. `#SBATCH` with no flag
+ *  (a comment) doesn't match. */
+const SBATCH_RE = /^\s*#\s*SBATCH\s+(--?[A-Za-z][\w-]*)(?:[=\s]+(.*))?$/;
+
+/** True when `text` looks like a SLURM batch script: it carries at least one
+ *  `#SBATCH` directive line (the only reliable marker — a `.slurm` extension is
+ *  neither required nor sufficient, and a plain shell script has none). */
+export function isSlurmScript(text: string): boolean {
+  return text.split("\n").some((l) => SBATCH_RE.test(l));
+}
+
+/** Normalize a matched flag token (`--time`, `-t`) to its long key (`time`). */
+function normalizeKey(flag: string): string {
+  if (flag.startsWith("--")) return flag.slice(2);
+  const short = flag.slice(1);
+  return SHORT_TO_LONG[short] ?? short;
+}
+
+/** Every `#SBATCH` directive present in the script, long-key-normalized. A flag
+ *  with no value (a boolean like `--exclusive`) yields an empty string value. */
+export function parseSbatchDirectives(text: string): SbatchField[] {
+  const out: SbatchField[] = [];
+  for (const line of text.split("\n")) {
+    const m = SBATCH_RE.exec(line);
+    if (!m) continue;
+    out.push({ key: normalizeKey(m[1]), value: (m[2] ?? "").trim() });
+  }
+  return out;
+}
+
+/** The current value of `key` among parsed directives, or `""` when absent. */
+export function directiveValue(fields: SbatchField[], key: string): string {
+  return fields.find((f) => f.key === key)?.value ?? "";
+}
+
+/**
+ * Edit the script's `#SBATCH` lines so that `key` reads `value` — by SPLICING the
+ * text, never re-serializing (the view-on-text bargain: every untouched byte, and
+ * the whole rest of the script, is preserved). Three cases:
+ *  - **present** → its value is replaced in place (matching the flag form the file
+ *    used, long or short);
+ *  - **absent + non-empty** → a new `#SBATCH --key=value` line is inserted after
+ *    the last existing directive (or after the shebang, else at the top);
+ *  - **empty value** → the directive line is removed (a way to clear a field).
+ */
+export function spliceDirective(text: string, key: string, value: string): string {
+  const lines = text.split("\n");
+  const v = value.trim();
+
+  // Find an existing directive for this key (matched on the normalized long key).
+  let lastDirective = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const m = SBATCH_RE.exec(lines[i]);
+    if (!m) continue;
+    lastDirective = i;
+    if (normalizeKey(m[1]) !== key) continue;
+    // Matched: rewrite (or delete) this line.
+    if (v === "") {
+      lines.splice(i, 1);
+      return lines.join("\n");
+    }
+    const flag = m[1]; // keep the flag spelling the file already used
+    const sep = flag.startsWith("--") ? "=" : " ";
+    // Preserve any leading indentation the author had.
+    const indent = lines[i].match(/^\s*/)?.[0] ?? "";
+    lines[i] = `${indent}#SBATCH ${flag}${sep}${v}`;
+    return lines.join("\n");
+  }
+
+  if (v === "") return text; // nothing to clear
+
+  // Absent: insert a new directive. Prefer just after the last existing #SBATCH so
+  // directives stay grouped; else after a shebang; else at the very top.
+  const newLine = `#SBATCH --${key}=${v}`;
+  if (lastDirective >= 0) {
+    lines.splice(lastDirective + 1, 0, newLine);
+  } else if (lines[0]?.startsWith("#!")) {
+    lines.splice(1, 0, newLine);
+  } else {
+    lines.splice(0, 0, newLine);
+  }
+  return lines.join("\n");
+}
+
+// ── Tab glue (the log window + the interactive shell) ────────────────────────
+
+/** Where a run tab is inserted (see `pythonRun.PyTabPlacer`): a placer OWNS
+ *  insertion, returning the created entry for a main-store activate, or null when
+ *  it streamed the tab into a detached popout. */
+export type SlurmTabPlacer = (tab: Omit<TabEntry, "key">) => TabEntry | null;
+
+/** The tab `location` for `hostId`: `undefined` for a local project (everything is
+ *  local), `"remote"` for the primary of a remote project, `host:<id>` for a
+ *  worker — the same axis a tab's locality badge sets, carried verbatim. */
+export function locationForHost(hostId: string, isRemote: boolean): TabLocation | undefined {
+  if (!isRemote) return undefined;
+  return hostId === "primary" ? "remote" : `host:${hostId}`;
+}
+
+/** Open a shell tab running `initialInput`, placed like a Python run tab. */
+function openHostShellTab(opts: {
+  scope: string;
+  label: string;
+  cwd: string;
+  location: TabLocation | undefined;
+  initialInput: string;
+  /** Never tmux-wrap this tab — see `TabEntry.ephemeral`. */
+  ephemeral?: boolean;
+  place?: SlurmTabPlacer;
+}): void {
+  const tab: Omit<TabEntry, "key"> = {
+    label: opts.label,
+    cmd: "", // the host's default shell
+    cwd: opts.cwd,
+    kind: "shell",
+    initialInput: opts.initialInput,
+    ...(opts.location ? { location: opts.location } : {}),
+    ...(opts.ephemeral ? { ephemeral: true } : {}),
+  };
+  if (opts.place) {
+    const entry = opts.place(tab);
+    if (entry) useTabsStore.getState().setActive(entry.key);
+    return;
+  }
+  const entry = useTabsStore.getState().addTabToScope(opts.scope, tab);
+  useTabsStore.getState().setActive(entry.key);
+}
+
+/** The command that tails a job's log: `tail -n +1 -F <out>` follows by name and
+ *  retries, so it waits out the queue (the file doesn't exist until the job runs)
+ *  and streams from the top once it appears. */
+export function buildTailCommand(outFile: string): string {
+  return `tail -n +1 -F ${shellQuote(outFile, "unix")}`;
+}
+
+/** Open a log tab tailing `outFile` on `hostId`. Used by Submit and by the Jobs
+ *  view's Watch. */
+export function openLogTab(opts: {
+  scope: string;
+  projectDir: string;
+  outFile: string;
+  jobLabel: string;
+  hostId: string;
+  isRemote: boolean;
+  place?: SlurmTabPlacer;
+}): void {
+  openHostShellTab({
+    scope: opts.scope,
+    label: `📄 ${opts.jobLabel}`,
+    cwd: opts.projectDir,
+    location: locationForHost(opts.hostId, opts.isRemote),
+    initialInput: buildTailCommand(opts.outFile),
+    // A `tail -F` is re-openable from the Jobs view at any time, so persisting it
+    // buys nothing — and on a cluster login node it costs the one thing the HPC
+    // tag exists to prevent: a tmux daemon still running there after Eldrun quits,
+    // which nothing in the UI would then be pointing at. The job itself is
+    // untouched; it is SLURM's, not this tab's.
+    ephemeral: logTabIsEphemeral(opts.scope, opts.hostId),
+    place: opts.place,
+  });
+}
+
+/** Whether a log tab on this host must not outlive itself: true iff the host is
+ *  tagged HPC. Resolved here rather than at the call sites because both of them
+ *  (Submit and the Jobs view's Watch) already hand us the scope and host id. */
+function logTabIsEphemeral(scope: string, hostId: string): boolean {
+  const settings = useSettingsStore.getState().settings;
+  const project = useProjectsStore.getState().projects.find((p) => p.id === scope);
+  if (!project) return false;
+  const spec =
+    hostId === "primary"
+      ? project.remote
+      : (project.compute_hosts ?? []).find((h) => h.id === hostId);
+  return isHpcHost(settings, targetOfSpec(spec));
+}
+
+/**
+ * Submit `file` (its absolute host/local path) with `sbatch`, open a log tab
+ * tailing the job's output, and record the job in the session store so the Jobs
+ * view shows it immediately. Returns the recorded job.
+ */
+export async function submitSlurmJob(opts: {
+  /** Absolute path of the `.slurm` file (the viewer's path). */
+  file: string;
+  /** The backend project-dir key (the project's stored `directory`). */
+  projectDir: string;
+  /** cwd for the log tab (the project root). */
+  cwd: string;
+  /** Owning project id, for the Jobs store. */
+  projectId: string;
+  /** The tab scope (project id, or "root"). */
+  scope: string;
+  /** Host to submit on; defaults to the primary. */
+  host?: string;
+  /** Whether the project is remote (decides the tab's locality). */
+  isRemote: boolean;
+  place?: SlurmTabPlacer;
+}): Promise<HpcJob> {
+  const host = opts.host ?? "primary";
+  const res = await invoke<SlurmSubmit>("slurm_submit", {
+    projectDir: opts.projectDir,
+    scriptRel: opts.file,
+    hostId: host,
+  });
+  const name = basename(opts.file);
+  const job: HpcJob = {
+    jobId: res.job_id,
+    name,
+    outFile: res.out_file,
+    host,
+    submittedAt: Date.now(),
+  };
+  useHpcJobsStore.getState().add(opts.projectId, job);
+  openLogTab({
+    scope: opts.scope,
+    projectDir: opts.cwd,
+    outFile: res.out_file,
+    jobLabel: `${res.job_id} ${name}`,
+    hostId: host,
+    isRemote: opts.isRemote,
+    place: opts.place,
+  });
+  return job;
+}
+
+/** Resources for an interactive `srun --pty` session. All optional; only the set
+ *  ones are passed. */
+export interface InteractiveResources {
+  time?: string;
+  cpus?: string;
+  mem?: string;
+  gpus?: string;
+  partition?: string;
+  /** SLURM account (`--account`). Mandatory on group-allocated clusters, where
+   *  an interactive `srun` with no account is rejected. */
+  account?: string;
+}
+
+/** Build the `srun --pty … bash -l` command that lands an interactive shell on a
+ *  compute node (the compliant interactive path — never the login node). */
+export function buildInteractiveCommand(res: InteractiveResources): string {
+  const parts = ["srun", "--pty"];
+  if (res.account?.trim()) parts.push(`--account=${res.account.trim()}`);
+  if (res.partition?.trim()) parts.push(`--partition=${res.partition.trim()}`);
+  if (res.time?.trim()) parts.push(`--time=${res.time.trim()}`);
+  if (res.cpus?.trim()) parts.push(`--cpus-per-task=${res.cpus.trim()}`);
+  if (res.mem?.trim()) parts.push(`--mem=${res.mem.trim()}`);
+  if (res.gpus?.trim()) parts.push(`--gpus=${res.gpus.trim()}`);
+  parts.push("bash", "-l");
+  return parts.join(" ");
+}
+
+/** Open an interactive compute-node shell (`srun --pty …`) as a terminal tab. */
+export function openInteractiveJob(opts: {
+  scope: string;
+  cwd: string;
+  res: InteractiveResources;
+  hostId: string;
+  isRemote: boolean;
+  place?: SlurmTabPlacer;
+}): void {
+  openHostShellTab({
+    scope: opts.scope,
+    label: "⚡ srun",
+    cwd: opts.cwd,
+    location: locationForHost(opts.hostId, opts.isRemote),
+    initialInput: buildInteractiveCommand(opts.res),
+    place: opts.place,
+  });
+}
diff --git a/src/lib/terminalBus.ts b/src/lib/terminalBus.ts
new file mode 100644
index 0000000..423270d
--- /dev/null
+++ b/src/lib/terminalBus.ts
@@ -0,0 +1,82 @@
+import { listen } from "@tauri-apps/api/event";
+
+/**
+ * Single global subscription per PTY-lifecycle event, fanned out to per-id
+ * handlers. Every mounted `TerminalView` used to call `listen("terminal-output",
+ * ...)` itself and filter `ev.payload.id === id` client-side — but the backend
+ * emits these as plain window-wide events (`app.emit`, not scoped per PTY), so
+ * every chunk from every running PTY was dispatched to and filtered by EVERY
+ * mounted terminal (CenterPanel keeps all tabs, all scopes, mounted forever —
+ * see its "flat pane layer" comment). That's O(mounted terminals) work per
+ * output chunk, not O(1). Here there is exactly one `listen()` per event type
+ * for the app's lifetime, doing an O(1) Map lookup to reach the right pane(s).
+ */
+
+interface TerminalOutput {
+  id: string;
+  data: string;
+}
+
+interface TerminalExit {
+  id: string;
+  code: number | null;
+}
+
+type OutputHandler = (data: string) => void;
+type ReadyHandler = () => void;
+type ExitHandler = (code: number | null) => void;
+
+const outputHandlers = new Map<string, Set<OutputHandler>>();
+const readyHandlers = new Map<string, Set<ReadyHandler>>();
+const exitHandlers = new Map<string, Set<ExitHandler>>();
+
+let started = false;
+
+function ensureStarted() {
+  if (started) return;
+  started = true;
+
+  listen<TerminalOutput>("terminal-output", (ev) => {
+    const set = outputHandlers.get(ev.payload.id);
+    if (!set) return;
+    for (const h of set) h(ev.payload.data);
+  }).catch(() => {});
+
+  listen<{ id: string }>("terminal-ready", (ev) => {
+    const set = readyHandlers.get(ev.payload.id);
+    if (!set) return;
+    for (const h of set) h();
+  }).catch(() => {});
+
+  listen<TerminalExit>("terminal-exit", (ev) => {
+    const set = exitHandlers.get(ev.payload.id);
+    if (!set) return;
+    for (const h of set) h(ev.payload.code);
+  }).catch(() => {});
+}
+
+function subscribe<H>(registry: Map<string, Set<H>>, id: string, handler: H): () => void {
+  ensureStarted();
+  let set = registry.get(id);
+  if (!set) {
+    set = new Set();
+    registry.set(id, set);
+  }
+  set.add(handler);
+  return () => {
+    set.delete(handler);
+    if (set.size === 0) registry.delete(id);
+  };
+}
+
+export function onTerminalOutput(id: string, handler: OutputHandler): () => void {
+  return subscribe(outputHandlers, id, handler);
+}
+
+export function onTerminalReady(id: string, handler: ReadyHandler): () => void {
+  return subscribe(readyHandlers, id, handler);
+}
+
+export function onTerminalExit(id: string, handler: ExitHandler): () => void {
+  return subscribe(exitHandlers, id, handler);
+}
diff --git a/src/lib/terminalControl.ts b/src/lib/terminalControl.ts
new file mode 100644
index 0000000..c0dd841
--- /dev/null
+++ b/src/lib/terminalControl.ts
@@ -0,0 +1,35 @@
+import type { TabKind } from "../stores/tabs";
+
+const CSI = "\x1b[";
+const claimedInitialInputs = new Set<string>();
+
+/** xterm answers terminal identity probes by emitting CSI ... c back through
+ *  `onData`, for example secondary DA: `ESC [ > 0 ; 276 ; 0 c`. During an
+ *  auto-run tab startup that response can land in readline before Eldrun types
+ *  `initialInput`, making the shell execute `0;276;0c...` instead of the command.
+ *  Suppress only the standalone identity replies while an auto-input is pending;
+ *  normal interactive terminal programs can still receive them afterward. */
+export function isTerminalIdentityResponse(data: string): boolean {
+  return new RegExp(`^(?:${CSI.replace("[", "\\[")}[?>]?[0-9;]*c)+$`).test(data);
+}
+
+/** Clear any startup junk already sitting in a shell's readline buffer before
+ *  auto-typing a command. No-op for agent TUIs: their prompt behavior is not a
+ *  POSIX shell line editor. */
+export function initialInputForPty(input: string, kind: TabKind): string {
+  return kind === "shell" ? `\x15${input}` : input;
+}
+
+/** Claim the right to auto-submit `input` for `ptyId`. React dev remounts,
+ *  duplicate panes, or duplicate ready events must not type the same run command
+ *  twice into one shell. */
+export function claimInitialInput(ptyId: string, input: string): boolean {
+  const key = `${ptyId}\0${input}`;
+  if (claimedInitialInputs.has(key)) return false;
+  claimedInitialInputs.add(key);
+  return true;
+}
+
+export function clearClaimedInitialInputsForTest(): void {
+  claimedInitialInputs.clear();
+}
diff --git a/src/lib/tmuxSession.ts b/src/lib/tmuxSession.ts
new file mode 100644
index 0000000..015b852
--- /dev/null
+++ b/src/lib/tmuxSession.ts
@@ -0,0 +1,89 @@
+/**
+ * Persistent remote sessions (TODO #85) — the frontend half of the tmux wrap.
+ *
+ * A remote shell/script tab can run inside a **tmux** session on the host, so a
+ * long run survives an SSH drop, a laptop sleep, or Eldrun quitting: the session
+ * keeps running and the tab reattaches on reconnect/relaunch. The backend
+ * (`services::ssh_exec`) owns the actual wrap; these helpers decide *whether* a
+ * tab persists and mirror the session-name derivation so the frontend can address
+ * a session it did not just spawn (the Sessions view, the explicit-close kill).
+ */
+
+import type { RemoteSpec } from "../types";
+
+/**
+ * A project id can appear verbatim in a tmux session name (it's practice a uuid),
+ * but is not schema-guaranteed to be — mirrors the backend's `sandbox::sanitize_key`
+ * so an oddly-shaped id can never produce an invalid session name.
+ */
+function sanitizeForTmuxName(id: string): string {
+  const safe = id.replace(/[^A-Za-z0-9_-]/g, "_");
+  return safe || "x";
+}
+
+/**
+ * Mint a fresh, stable tmux session name for a shell tab. Minted **once** at tab
+ * creation and **persisted** on the tab (`TabEntry.tmuxSession`), because the tab's
+ * PTY id (`<scope>:<tab-key>`) is NOT stable — `loadFromLayout` regenerates the key
+ * on every restart — so deriving the name from the id would create a *second*
+ * session on relaunch instead of reattaching. A uuid is inherently tmux-safe
+ * (`[0-9a-f-]`, no `:`/`.`), so it needs no sanitising.
+ *
+ * `scope` (the owning project id, or `"root"`/a box id) is embedded right after
+ * the `eldrun-` prefix, separated from the uuid by a `--` that can never occur
+ * inside either half (uuids and project ids are single-hyphenated) — so the
+ * Sessions view (`remote_tmux_list`) can tell one project's sessions apart from
+ * another's on a host multiple projects share, instead of listing every session
+ * on the host for every project.
+ */
+export function newTmuxSessionName(scope: string): string {
+  return `eldrun-${sanitizeForTmuxName(scope)}--${crypto.randomUUID()}`;
+}
+
+/**
+ * Whether persistent sessions are enabled for a remote project. **Default ON** —
+ * `undefined`/`true` mean enabled; only an explicit `false` (the pill's toggle)
+ * opts out. `undefined`/local projects → off (there is no host to persist on).
+ */
+export function persistSessionsEnabled(remote: RemoteSpec | undefined | null): boolean {
+  return !!remote && remote.persist_sessions !== false;
+}
+
+/**
+ * Whether THIS tab should be tmux-wrapped: a **shell** tab (interactive shells and
+ * Python/script runs, which open a shell tab) running on a **remote host**
+ * (`hostId` non-null) of a persist-enabled remote project. Agent tabs are excluded
+ * — they resume via their own session — as are files/embed/monitor panes (no PTY).
+ *
+ * `ephemeral` is the per-tab opt-out (`TabEntry.ephemeral`): a tab whose work is
+ * re-openable and not worth a daemon on the host. It exists because the project
+ * toggle is too blunt for a cluster — switching `persist_sessions` off to stop a
+ * `tail -F` outliving the app would also drop the `srun --pty` session that is the
+ * whole point of persisting, so the exemption has to be the tab's, not the
+ * project's.
+ */
+export function shouldPersistTab(
+  kind: string,
+  hostId: string | null,
+  remote: RemoteSpec | undefined | null,
+  ephemeral?: boolean,
+): boolean {
+  return kind === "shell" && hostId !== null && !ephemeral && persistSessionsEnabled(remote);
+}
+
+/**
+ * Whether THIS tab should be tmux-wrapped **locally** (TODO #85): a **shell** tab
+ * (interactive shells + Python/script runs) that runs on the **local machine** —
+ * a local project's tab, or a remote project's local (mirror) tab — in a project
+ * scope. `localEnabled` folds the `persist_local_sessions` setting **and** the
+ * platform check (off on Windows, where there is no tmux). Keeps the run alive
+ * across an Eldrun crash and reattaches on restart.
+ */
+export function shouldPersistLocalTab(
+  kind: string,
+  scopeKey: string,
+  localRunning: boolean,
+  localEnabled: boolean,
+): boolean {
+  return kind === "shell" && scopeKey !== "root" && localRunning && localEnabled;
+}
diff --git a/src/lib/tour.ts b/src/lib/tour.ts
new file mode 100644
index 0000000..ff1e370
--- /dev/null
+++ b/src/lib/tour.ts
@@ -0,0 +1,144 @@
+import { HINTS, HOW_TO_START_STEPS, FOCUS_MODE_TIP, type HintCtx } from "./hints";
+
+/**
+ * The guided "Take a tour" walkthrough: an ordered, index-driven sequence of
+ * spotlight steps that dims the screen and highlights one real control at a
+ * time (root terminal → projects → tabs → files → apps → time → settings).
+ *
+ * This is the deliberate bridge between the static first-run `HowToStart` modal
+ * and the passive contextual `HINTS`: it reuses the same anchor-selector model
+ * (`HintDef.anchor`/`placement`) and pulls its copy from the existing onboarding
+ * strings so the four onboarding surfaces (modal, tour, hints, Feature Guide)
+ * never drift. Selection logic here is pure and unit-tested (`TourSelection`);
+ * `TourHost` owns the impure DOM measurement, timing, and event wiring.
+ */
+
+/** The tour reuses the hint context (project count + active scope) for its
+ *  per-step eligibility predicates, so a zero-project user skips project-only
+ *  steps cleanly. */
+export type TourCtx = HintCtx;
+
+/** Bubble placement relative to the spotlight target. Widens `HintDef`'s
+ *  top/bottom union with sides, which read better for the corner chrome the
+ *  tour points at (root logo top-left, gear top-right, file-tree right edge). */
+export type TourPlacement = "top" | "bottom" | "left" | "right";
+
+export interface TourStep {
+  /** Stable id; also the key used to mark the matching contextual hint seen so
+   *  the tour doesn't end into a hint storm (see `COVERED_HINTS`). */
+  id: string;
+  /** `document.querySelector` selector for the element to spotlight, or null to
+   *  render as a centered card. A step whose anchor is absent at runtime falls
+   *  back to the centered-card path rather than blocking the tour. */
+  anchor: string | null;
+  placement: TourPlacement;
+  title: string;
+  body: string;
+  /** Eligible only while this holds for the current context (defaults to
+   *  always). Ineligible steps are skipped by the Back/Next navigation. */
+  when?: (ctx: TourCtx) => boolean;
+  /** Optional side-effect run by `TourHost` when this step becomes active, e.g.
+   *  to reveal a panel so the step's anchor exists to spotlight. Kept off the
+   *  pure selectors — only the host calls it. */
+  prepare?: () => void;
+}
+
+/** Body copy for a contextual hint, by id — so the tour reuses the exact hint
+ *  prose instead of re-typing it (single source of truth, per `hints.ts`). */
+function hintBody(id: string): string {
+  return HINTS.find((h) => h.id === id)?.body ?? "";
+}
+
+export const TOUR_STEPS: TourStep[] = [
+  {
+    id: "root-terminal",
+    anchor: '[aria-label="Root terminal"]',
+    placement: "bottom",
+    title: "Use the root terminal",
+    body: HOW_TO_START_STEPS[0].body,
+  },
+  {
+    id: "create-project",
+    anchor: '[data-hint-anchor="add-project"]',
+    placement: "bottom",
+    title: "Create or import a project",
+    body: hintBody("create-project"),
+  },
+  {
+    id: "remote-projects",
+    anchor: null,
+    placement: "bottom",
+    title: "Work on remote machines",
+    body: "In the New/Import dialog, flip \"Remote (SSH) project\" to host a project on another machine — Eldrun runs it over SSH/SFTP (agent tabs, files, and git on the remote; no local mount). If the host sits behind a VPN, enable \"Connect via OpenVPN\" to bring up the tunnel first, then connect SSH through it. The Lessons menu has a step-by-step \"SSH project via OpenVPN\" walkthrough.",
+  },
+  {
+    id: "switch-projects",
+    anchor: ".project-pills-region",
+    placement: "bottom",
+    title: "Switch between projects",
+    body: "Each open project is a pill here. Click to switch; drag to reorder, or drop one onto another to group them into a box.",
+    // Nothing to point at until at least one project is open.
+    when: (c) => c.projectCount > 0,
+  },
+  {
+    id: "add-tab",
+    anchor: '[data-hint-anchor="tab-add"]',
+    placement: "bottom",
+    title: "Add agents and split tabs",
+    body: hintBody("add-tab"),
+  },
+  {
+    id: "file-tree",
+    anchor: '[data-hint-anchor="file-tree-edge"]',
+    placement: "left",
+    title: "Find your files",
+    body: hintBody("file-tree"),
+  },
+  {
+    id: "global-apps",
+    anchor: '[aria-label="Global apps"]',
+    placement: "bottom",
+    title: "Launch your tools",
+    body: "Open your editor, browser, or other tools from here. Right-click a slot to set which app it launches.",
+  },
+  {
+    id: "time-tracking",
+    anchor: ".app-timer-btn",
+    placement: "bottom",
+    title: "Track your time",
+    body: "Eldrun logs how long you work in each project. Click to pause, or right-click for the activity view.",
+  },
+  {
+    id: "settings-focus",
+    anchor: '[data-hint-anchor="settings"]',
+    placement: "bottom",
+    title: "Settings and focus mode",
+    body: `Theme, Git, and shortcuts live behind ⚙ — which also reopens this tour and the Feature Guide. ${FOCUS_MODE_TIP}`,
+  },
+];
+
+/** Contextual-hint ids the tour teaches, marked seen on finish so they don't
+ *  immediately re-fire once the overlay closes. */
+export const COVERED_HINTS = ["create-project", "add-tab", "toggle-panels", "file-tree"] as const;
+
+/** Whether a step applies to the given context (defaults to always-on). */
+export function isStepEligible(step: TourStep, ctx: TourCtx): boolean {
+  return step.when ? step.when(ctx) : true;
+}
+
+/** First index `>= from` whose step is eligible, or `steps.length` when none
+ *  remain — the signal the tour has run off the end and should finish. */
+export function nextEligibleIndex(steps: TourStep[], ctx: TourCtx, from: number): number {
+  for (let i = Math.max(0, from); i < steps.length; i++) {
+    if (isStepEligible(steps[i], ctx)) return i;
+  }
+  return steps.length;
+}
+
+/** Last index `<= from` whose step is eligible, or -1 when none precede it. */
+export function prevEligibleIndex(steps: TourStep[], ctx: TourCtx, from: number): number {
+  for (let i = Math.min(steps.length - 1, from); i >= 0; i--) {
+    if (isStepEligible(steps[i], ctx)) return i;
+  }
+  return -1;
+}
diff --git a/src/lib/usageMetrics.ts b/src/lib/usageMetrics.ts
new file mode 100644
index 0000000..3dc802b
--- /dev/null
+++ b/src/lib/usageMetrics.ts
@@ -0,0 +1,111 @@
+/**
+ * The metric keys of `usage_stats.json`, and how a tab maps onto them.
+ *
+ * Mirrors `schema::usage_stats::metric` (src-tauri) — keep the two in step. The
+ * key space is namespaced with `.` and deliberately open-ended: the trailing
+ * segment of an agent key is the agent's command (`claude`, `codex`) or a local
+ * model name (`qwen3:8b`), neither of which is a closed set.
+ */
+
+// Type-only, so this stays free of a runtime import cycle: `tabs.ts` imports
+// *this* module to count tab opens.
+import type { TabKind } from "../stores/tabs";
+
+export const METRIC = {
+  /** `agent.tab.<cmd>` — an agent tab was opened. */
+  AGENT_TAB: "agent.tab",
+  /** `agent.tab.local.<model>` — a local (Ollama-backed) agent tab was opened. */
+  AGENT_TAB_LOCAL: "agent.tab.local",
+  /** `agent.active.<cmd>` — distinct agent tabs that received ≥1 prompt that day. */
+  AGENT_ACTIVE: "agent.active",
+  /** `agent.prompt.<cmd>` — prompts submitted to an agent. */
+  AGENT_PROMPT: "agent.prompt",
+  /** Seconds agent tabs spent actually working. */
+  AGENT_WORKED_S: "agent.worked_s",
+  /** Times an agent stopped to ask you a decision. */
+  AGENT_DECISION: "agent.decision",
+  /** Times an agent finished a turn. */
+  AGENT_DONE: "agent.done",
+  /** Commands run in a shell tab. */
+  SHELL_COMMAND: "shell.command",
+  FILE_CREATED: "file.created",
+  FILE_MODIFIED: "file.modified",
+  FILE_DELETED: "file.deleted",
+  TAB_OPENED: "tab.opened",
+  TAB_CLOSED: "tab.closed",
+  APP_LAUNCHED: "app.launched",
+} as const;
+
+/** Compose `agent.prompt` + `claude` → `agent.prompt.claude`. */
+export function sub(prefix: string, leaf: string): string {
+  return `${prefix}.${leaf}`;
+}
+
+/**
+ * What an agent tab should be counted as: its agent command for a cloud agent
+ * (`claude`), or the model name for a local one (`qwen3:8b`).
+ *
+ * A `local_agent` tab's model is not a field on the tab — it is carried in the
+ * env Eldrun sets when spawning it (`ELDRUN_LOCAL_MODEL`, set at both local-model
+ * launch routes in `TabBar`/`NewTabMenu`), with `VIBE_ACTIVE_MODEL` as the
+ * fallback for the vibe route. Returns `null` for a tab that is not an agent.
+ *
+ * `kind === "agent"` is itself the test for "this cmd is a known agent" —
+ * `cmdToKind` only assigns that kind to a cmd in its `AGENT_CMDS` set — so there
+ * is no second registry to keep in step here.
+ */
+export function agentMetricLeaf(tab: {
+  kind: TabKind;
+  cmd: string;
+  env?: Record<string, string>;
+}): { prefix: string; leaf: string } | null {
+  if (tab.kind === "local_agent") {
+    const model = tab.env?.ELDRUN_LOCAL_MODEL || tab.env?.VIBE_ACTIVE_MODEL;
+    // A local agent tab with no recorded model would otherwise be filed under an
+    // empty key; count it under its driving command instead of inventing one.
+    if (model) return { prefix: METRIC.AGENT_TAB_LOCAL, leaf: model };
+    return { prefix: METRIC.AGENT_TAB, leaf: tab.cmd };
+  }
+  if (tab.kind === "agent" && tab.cmd) {
+    return { prefix: METRIC.AGENT_TAB, leaf: tab.cmd };
+  }
+  return null;
+}
+
+/**
+ * The leaf an agent tab's *prompts* are counted under — the same identity as
+ * {@link agentMetricLeaf}, flattened to a single string so `agent.prompt.<leaf>`
+ * and `agent.active.<leaf>` line up with the tab counts. A local model's leaf is
+ * prefixed `local.` so it stays distinguishable from a cloud agent of the same
+ * name.
+ */
+export function agentPromptLeaf(tab: {
+  kind: TabKind;
+  cmd: string;
+  env?: Record<string, string>;
+}): string | null {
+  const id = agentMetricLeaf(tab);
+  if (!id) return null;
+  return id.prefix === METRIC.AGENT_TAB_LOCAL ? `local.${id.leaf}` : id.leaf;
+}
+
+/** Human labels for the well-known agent commands; unknown leaves render as-is. */
+const AGENT_LABELS: Record<string, string> = {
+  claude: "Claude",
+  codex: "Codex",
+  gemini: "Gemini",
+  vibe: "Mistral",
+  aider: "Aider",
+  opencode: "OpenCode",
+  "cursor-agent": "Cursor",
+  copilot: "Copilot",
+  grok: "Grok",
+  qwen: "Qwen",
+  openclaw: "OpenClaw",
+};
+
+/** Display name for a metric leaf (`claude` → "Claude", `local.qwen3:8b` → "qwen3:8b"). */
+export function agentLabel(leaf: string): string {
+  if (leaf.startsWith("local.")) return leaf.slice("local.".length);
+  return AGENT_LABELS[leaf] ?? leaf;
+}
diff --git a/src/lib/usageRollup.ts b/src/lib/usageRollup.ts
new file mode 100644
index 0000000..6a3e3d8
--- /dev/null
+++ b/src/lib/usageRollup.ts
@@ -0,0 +1,181 @@
+/**
+ * Folding persisted per-bucket usage into calendar windows.
+ *
+ * Both stores Eldrun rolls up on disk — `net_usage.json` (bytes) and
+ * `usage_stats.json` (counters) — have the same shape: a map of UTC bucket keys
+ * ("YYYY-MM-DD" for days, "YYYY-MM-DDTHH" for hours) to a per-bucket payload. So
+ * the windowing is one implementation, generic over the payload, rather than one
+ * per store. `NetworkTrafficPane` and the usage recap both read it.
+ *
+ * Every key here is **UTC**, because the backend writes them with
+ * `storage::hour_utc()` / `today_utc()`. Computing the windows in local time
+ * would silently mis-file the hours around midnight.
+ *
+ * Windows are **calendar-aligned**, not rolling: "this week" is the elapsed part
+ * of the current ISO week (Mon–Sun), not the last seven days, to match how
+ * "today" and "this month" already read.
+ */
+
+const DAY_MS = 86_400_000;
+
+/** The five windows every usage surface shows. */
+export interface Windows<T> {
+  hour: T;
+  today: T;
+  week: T;
+  month: T;
+  overall: T;
+}
+
+/** A period the recap can be scoped to. */
+export type Period = "day" | "week" | "month";
+
+/** The UTC date key ("YYYY-MM-DD") for a timestamp. */
+export function dayKey(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+/** The UTC hour key ("YYYY-MM-DDTHH") for a timestamp. */
+export function hourKey(ms: number): string {
+  return new Date(ms).toISOString().slice(0, 13);
+}
+
+/**
+ * The seven UTC date keys of the ISO week (Monday–Sunday) containing `nowMs`.
+ * Calendar-aligned rather than a rolling seven days, to match "today" and "this
+ * month" — every window shown is the elapsed part of a calendar period.
+ */
+export function isoWeekKeys(nowMs: number): string[] {
+  const now = new Date(nowMs);
+  const sinceMonday = (now.getUTCDay() + 6) % 7; // getUTCDay: 0 = Sunday
+  const monday = nowMs - sinceMonday * DAY_MS;
+  return Array.from({ length: 7 }, (_, day) => dayKey(monday + day * DAY_MS));
+}
+
+/**
+ * Every UTC date key belonging to `period` as anchored at `anchorMs`.
+ *
+ * - `day` → just that date.
+ * - `week` → the ISO week containing it.
+ * - `month` → every day of that calendar month (not a rolling 30).
+ *
+ * Days in the future (the rest of the current week/month) are included and simply
+ * have no buckets — summing them contributes nothing.
+ */
+export function periodKeys(period: Period, anchorMs: number): string[] {
+  if (period === "day") return [dayKey(anchorMs)];
+  if (period === "week") return isoWeekKeys(anchorMs);
+  const anchor = new Date(anchorMs);
+  const year = anchor.getUTCFullYear();
+  const month = anchor.getUTCMonth();
+  // Day 0 of the *next* month is the last day of this one.
+  const days = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+  return Array.from({ length: days }, (_, i) => dayKey(Date.UTC(year, month, i + 1)));
+}
+
+/** A store's two bucket maps, as the backend returns them. */
+export interface BucketReport<T> {
+  hours?: Record<string, T>;
+  days?: Record<string, T>;
+}
+
+/**
+ * Fold a report into this-hour / today / this-week / this-month / overall.
+ *
+ * `zero` mints an empty accumulator and `add` folds one bucket into it — supply
+ * the pair for the payload in question (bytes, counters, …). Only the hour total
+ * reads `hours`; the rest sum `days`, which is why pruning the hour window can
+ * never change them.
+ */
+export function summarizeBuckets<T>(
+  report: BucketReport<T>,
+  nowMs: number,
+  zero: () => T,
+  add: (into: T, from: T | undefined) => void,
+): Windows<T> {
+  const iso = new Date(nowMs).toISOString();
+  const hour = iso.slice(0, 13); // YYYY-MM-DDTHH (UTC)
+  const today = iso.slice(0, 10); // YYYY-MM-DD (UTC)
+  const month = iso.slice(0, 7); // YYYY-MM (UTC)
+  const weekKeys = new Set(isoWeekKeys(nowMs));
+
+  const acc: Windows<T> = {
+    hour: zero(),
+    today: zero(),
+    week: zero(),
+    month: zero(),
+    overall: zero(),
+  };
+
+  add(acc.hour, report.hours?.[hour]);
+  for (const [date, payload] of Object.entries(report.days ?? {})) {
+    add(acc.overall, payload);
+    if (date.startsWith(month)) add(acc.month, payload);
+    if (weekKeys.has(date)) add(acc.week, payload);
+    if (date === today) add(acc.today, payload);
+  }
+  return acc;
+}
+
+// ── Counter payloads (usage_stats.json) ────────────────────────────────────
+
+/** metric key → count, as `schema::usage_stats::Counters` serializes. */
+export type Counters = Record<string, number>;
+
+/** Add every counter in `from` into `into`, in place. */
+export function addCounters(into: Counters, from: Counters | undefined): void {
+  if (!from) return;
+  for (const [key, n] of Object.entries(from)) {
+    into[key] = (into[key] ?? 0) + n;
+  }
+}
+
+/** Sum the counters of `keys`' buckets. Absent buckets contribute nothing. */
+export function sumCounters(buckets: Record<string, Counters> | undefined, keys: string[]): Counters {
+  const acc: Counters = {};
+  for (const key of keys) addCounters(acc, buckets?.[key]);
+  return acc;
+}
+
+/** The counters recorded over `period`, anchored at `anchorMs`. */
+export function countersForPeriod(
+  report: BucketReport<Counters>,
+  period: Period,
+  anchorMs: number,
+): Counters {
+  return sumCounters(report.days, periodKeys(period, anchorMs));
+}
+
+/**
+ * Counters whose key starts with `prefix.`, keyed by the remaining leaf.
+ *
+ * The metric key space is deliberately open — `agent.prompt.claude`,
+ * `agent.tab.local.qwen3:8b` — so this is how a breakdown ("prompts, by agent")
+ * is read back out without the reader needing to know which agents exist.
+ *
+ * `exclude` names deeper namespaces that sit *under* `prefix` and must not be
+ * folded into it: `agent.tab` has to skip `agent.tab.local.*`, or every local
+ * model would be counted both as its own model and as an agent named "local".
+ * It is passed explicitly rather than inferred from the leaf shape, because a
+ * leaf may legitimately contain dots — `llama3.1:8b` is one model, not a
+ * namespace.
+ */
+export function breakdown(
+  counters: Counters,
+  prefix: string,
+  exclude: string[] = [],
+): Record<string, number> {
+  const out: Record<string, number> = {};
+  const head = `${prefix}.`;
+  for (const [key, n] of Object.entries(counters)) {
+    if (!key.startsWith(head)) continue;
+    if (exclude.some((ex) => key.startsWith(`${ex}.`))) continue;
+    out[key.slice(head.length)] = (out[key.slice(head.length)] ?? 0) + n;
+  }
+  return out;
+}
+
+/** Total of every value in a breakdown. */
+export function totalOf(counts: Record<string, number>): number {
+  return Object.values(counts).reduce((sum, n) => sum + n, 0);
+}
diff --git a/src/lib/viewers/deck/export.ts b/src/lib/viewers/deck/export.ts
new file mode 100644
index 0000000..8218714
--- /dev/null
+++ b/src/lib/viewers/deck/export.ts
@@ -0,0 +1,373 @@
+/**
+ * Flattening a deck into a PDF — **the only place a deck is written as a PDF**,
+ * mirroring the rule `pdf/pdfDoc.ts` already keeps for the PDF viewer.
+ *
+ * Three things make the export trustworthy rather than approximate:
+ *
+ * **It lays text out with the same metrics the editor did.** `deck/fonts.ts` is
+ * shared, so a paragraph breaks into identical lines here and on screen. That is
+ * the whole reason the deck is limited to the standard-14 fonts.
+ *
+ * **All geometry goes through `deck/transform.ts`.** The normalized-y-down →
+ * points-y-up flip and the rotate-about-centre anchor are written once, tested,
+ * and never re-derived inline.
+ *
+ * **Every drawing primitive is `drawSvgPath`, `drawText` or `drawImage`.** Shapes
+ * and icons are already path data for exactly this reason — one geometry source
+ * for the stage and the page.
+ *
+ * The caller supplies bytes, not paths: this module never touches the
+ * filesystem, so it stays testable and works identically for a local project and
+ * a remote one.
+ */
+
+import {
+  PDFDocument,
+  degrees,
+  rgb,
+  type PDFFont,
+  type PDFPage,
+  type PDFImage,
+} from "pdf-lib";
+import type { Deck, DeckObject } from "./model";
+import {
+  type TextMetrics,
+  lineOffset,
+  standardFontFor,
+  wrapText,
+} from "./fonts";
+import { ICON_VIEWBOX, iconByKey } from "./icons";
+import { arrowHeadPath, isClosedShape, lineAngle, shapePath } from "./shapes";
+import { fitSquare, parseColor, pdfPlacement, toPdfRect } from "./transform";
+
+export interface ExportInputs {
+  deck: Deck;
+  /**
+   * Pristine bytes of the base PDF, or null for a deck with no plate.
+   *
+   * Pristine matters: pdf.js *detaches* the buffer it renders from, so these must
+   * be a separate copy — the same trap `pdf/pdfDoc.ts` documents.
+   */
+  baseBytes: Uint8Array | null;
+  /** Deck-relative image `src` → its file bytes (PNG or JPEG). */
+  images: ReadonlyMap<string, Uint8Array>;
+  /**
+   * Interstitial id → PNG bytes of its poster frame.
+   *
+   * A GIF cannot be a PDF page, so an interstitial exports as a still. Encoding
+   * that still needs a canvas, which is the caller's business, not this module's.
+   */
+  posters: ReadonlyMap<string, Uint8Array>;
+  metrics: TextMetrics;
+}
+
+export interface ExportResult {
+  bytes: Uint8Array;
+  /** Pages written. */
+  pages: number;
+  /** Things that could not be drawn, in plain words, for the caller to surface. */
+  warnings: string[];
+}
+
+/** PNG and JPEG magic numbers — pdf-lib needs to be told which embedder to use. */
+function imageKind(bytes: Uint8Array): "png" | "jpg" | null {
+  if (bytes.length > 8 && bytes[0] === 0x89 && bytes[1] === 0x50) return "png";
+  if (bytes.length > 3 && bytes[0] === 0xff && bytes[1] === 0xd8) return "jpg";
+  return null;
+}
+
+const color = (hex: string | undefined, fallback?: { r: number; g: number; b: number }) => {
+  const c = parseColor(hex);
+  if (!c) return fallback ? rgb(fallback.r, fallback.g, fallback.b) : undefined;
+  return rgb(c.r, c.g, c.b);
+};
+
+/** Opacity carried separately: pdf-lib takes it as its own option, not in the colour. */
+const alphaOf = (hex: string | undefined): number => parseColor(hex)?.a ?? 1;
+
+export async function exportDeck(input: ExportInputs): Promise<ExportResult> {
+  const { deck, baseBytes, images, posters, metrics } = input;
+  const warnings: string[] = [];
+  const out = await PDFDocument.create();
+
+  // --- base plate --------------------------------------------------------
+  // Copy the pages the slides point at, in slide order, so a reordered deck
+  // exports reordered. One `copyPages` call for the whole set, so shared fonts
+  // and images cross once rather than per page.
+  let copied: PDFPage[] = [];
+  if (baseBytes) {
+    try {
+      const src = await PDFDocument.load(baseBytes);
+      const wanted = deck.slides.map((s) => Math.min(src.getPageCount(), Math.max(1, s.anchor.page)) - 1);
+      copied = await out.copyPages(src, wanted);
+    } catch (e) {
+      warnings.push(`The base PDF could not be read, so slides export blank (${String(e)}).`);
+    }
+  }
+
+  // Fonts are embedded lazily and cached: a deck using one face must not carry
+  // twelve.
+  const fontCache = new Map<string, PDFFont>();
+  const fontFor = async (o: Extract<DeckObject, { kind: "text" }>): Promise<PDFFont> => {
+    const std = standardFontFor(o.style);
+    const hit = fontCache.get(std);
+    if (hit) return hit;
+    const f = await out.embedFont(std);
+    fontCache.set(std, f);
+    return f;
+  };
+
+  const imageCache = new Map<string, PDFImage | null>();
+  const imageFor = async (src: string): Promise<PDFImage | null> => {
+    if (imageCache.has(src)) return imageCache.get(src) ?? null;
+    const bytes = images.get(src);
+    let embedded: PDFImage | null = null;
+    if (!bytes) {
+      warnings.push(`Image "${src}" was not available and is missing from the export.`);
+    } else {
+      const kind = imageKind(bytes);
+      try {
+        if (kind === "png") embedded = await out.embedPng(bytes);
+        else if (kind === "jpg") embedded = await out.embedJpg(bytes);
+        else warnings.push(`Image "${src}" is not a PNG or JPEG; PDF can embed neither.`);
+      } catch (e) {
+        warnings.push(`Image "${src}" could not be embedded (${String(e)}).`);
+      }
+    }
+    imageCache.set(src, embedded);
+    return embedded;
+  };
+
+  // --- slides ------------------------------------------------------------
+  for (let i = 0; i < deck.slides.length; i += 1) {
+    const slide = deck.slides[i];
+    const page = copied[i] ? out.addPage(copied[i]) : out.addPage([deck.pageWidth, deck.pageHeight]);
+    const { width: pw, height: ph } = page.getSize();
+
+    for (const obj of slide.objects) {
+      if (obj.hidden) continue;
+      await drawObject(page, obj, pw, ph, { fontFor, imageFor, metrics, warnings });
+    }
+
+    // --- the interstitial that follows this slide ---
+    if (slide.after && deck.theme.exportInterstitials) {
+      const png = posters.get(slide.after.id);
+      const poster = out.addPage([pw, ph]);
+      const bg = parseColor(slide.after.background) ?? { r: 0, g: 0, b: 0, a: 1 };
+      poster.drawRectangle({ x: 0, y: 0, width: pw, height: ph, color: rgb(bg.r, bg.g, bg.b) });
+      if (png) {
+        try {
+          const img = await out.embedPng(png);
+          // `contain`: the poster is evidence of what played, so it must not be
+          // cropped even when the interstitial itself was set to `cover`.
+          const scale = Math.min(pw / img.width, ph / img.height);
+          const w = img.width * scale;
+          const h = img.height * scale;
+          poster.drawImage(img, { x: (pw - w) / 2, y: (ph - h) / 2, width: w, height: h });
+        } catch (e) {
+          warnings.push(`The poster frame for an animation could not be embedded (${String(e)}).`);
+        }
+      } else {
+        warnings.push(
+          `An animation had no poster frame, so its page in the export is blank.`,
+        );
+      }
+    }
+  }
+
+  if (out.getPageCount() === 0) {
+    // pdf-lib refuses to save a document with no pages, and a deck with no
+    // slides should produce an empty-looking PDF rather than an exception.
+    out.addPage([deck.pageWidth, deck.pageHeight]);
+    warnings.push("This deck has no slides; the export is a single blank page.");
+  }
+
+  return { bytes: await out.save(), pages: out.getPageCount(), warnings };
+}
+
+interface DrawCtx {
+  fontFor: (o: Extract<DeckObject, { kind: "text" }>) => Promise<PDFFont>;
+  imageFor: (src: string) => Promise<PDFImage | null>;
+  metrics: TextMetrics;
+  warnings: string[];
+}
+
+async function drawObject(
+  page: PDFPage,
+  obj: DeckObject,
+  pw: number,
+  ph: number,
+  ctx: DrawCtx,
+): Promise<void> {
+  const rect = toPdfRect(obj, pw, ph);
+
+  switch (obj.kind) {
+    case "shape": {
+      const sw = obj.strokeWidth;
+      // Same half-stroke inset the stage uses, so a stroked edge sits inside the
+      // box in both places and a snapped edge stays snapped.
+      const iw = Math.max(0, rect.w - sw);
+      const ih = Math.max(0, rect.h - sw);
+      const place = pdfPlacement(rect, obj.rot, sw / 2, sw / 2);
+      const fill = isClosedShape(obj.shape) ? color(obj.fill) : undefined;
+      page.drawSvgPath(shapePath(obj.shape, iw, ih, obj.radius ?? 0.12), {
+        x: place.x,
+        y: place.y,
+        rotate: degrees(place.rotate),
+        borderColor: color(obj.stroke, { r: 0, g: 0, b: 0 }),
+        borderWidth: sw,
+        borderOpacity: obj.opacity,
+        ...(fill ? { color: fill, opacity: obj.opacity * alphaOf(obj.fill) } : {}),
+      });
+      const angle = lineAngle(iw, ih);
+      for (const [head, hx, hy, a] of [
+        [obj.head, iw, ih, angle],
+        [obj.tail, 0, 0, angle + Math.PI],
+      ] as const) {
+        if (!head || head === "none") continue;
+        page.drawSvgPath(arrowHeadPath(head, hx, hy, a, sw), {
+          x: place.x,
+          y: place.y,
+          rotate: degrees(place.rotate),
+          color: color(obj.stroke, { r: 0, g: 0, b: 0 }),
+          opacity: obj.opacity,
+          borderColor: color(obj.stroke, { r: 0, g: 0, b: 0 }),
+          borderWidth: sw,
+          borderOpacity: obj.opacity,
+        });
+      }
+      return;
+    }
+
+    case "icon": {
+      const def = iconByKey(obj.icon);
+      if (!def) {
+        ctx.warnings.push(`Icon "${obj.icon}" is not in this build's library and was skipped.`);
+        return;
+      }
+      const { scale, offsetX, offsetY } = fitSquare(rect, ICON_VIEWBOX);
+      // The glyph's own rotation composes with the object's: both turn about the
+      // same centre, because the glyph box is centred in the object box.
+      const place = pdfPlacement(rect, obj.rot + (def.rotate ?? 0), offsetX, offsetY);
+      for (const d of def.paths) {
+        page.drawSvgPath(d, {
+          x: place.x,
+          y: place.y,
+          scale,
+          rotate: degrees(place.rotate),
+          ...(def.filled
+            ? { color: color(obj.color, { r: 0, g: 0, b: 0 }), opacity: obj.opacity }
+            : {
+                borderColor: color(obj.color, { r: 0, g: 0, b: 0 }),
+                // Stroke width is in points and `scale` multiplies it, so divide
+                // it back out to keep the drawn weight the author chose.
+                borderWidth: obj.strokeWidth / (scale || 1),
+                borderOpacity: obj.opacity,
+              }),
+        });
+      }
+      return;
+    }
+
+    case "image": {
+      const img = await ctx.imageFor(obj.src);
+      if (!img) return;
+      // Reproduce `object-fit`. `cover` would need a clip path, which pdf-lib
+      // does not expose — so it degrades to `contain` and says so, rather than
+      // silently overflowing the box across the rest of the slide.
+      let w = rect.w;
+      let h = rect.h;
+      let dx = 0;
+      let dy = 0;
+      if (obj.fit !== "stretch") {
+        if (obj.fit === "cover") {
+          ctx.warnings.push(
+            `Image "${obj.src}" uses "cover", which PDF cannot crop; it was fitted instead.`,
+          );
+        }
+        const s = Math.min(rect.w / img.width, rect.h / img.height);
+        w = img.width * s;
+        h = img.height * s;
+        dx = (rect.w - w) / 2;
+        dy = (rect.h - h) / 2;
+      }
+      const place = pdfPlacement(rect, obj.rot, dx, dy + h);
+      page.drawImage(img, {
+        x: place.x,
+        y: place.y,
+        width: w,
+        height: h,
+        rotate: degrees(place.rotate),
+        opacity: obj.opacity,
+      });
+      return;
+    }
+
+    case "text": {
+      const font = await ctx.fontFor(obj);
+      const s = obj.style;
+      const pad = obj.padding;
+
+      if (obj.fill) {
+        const place = pdfPlacement(rect, obj.rot, 0, rect.h);
+        page.drawRectangle({
+          x: place.x,
+          y: place.y,
+          width: rect.w,
+          height: rect.h,
+          rotate: degrees(place.rotate),
+          color: color(obj.fill),
+          opacity: obj.opacity * alphaOf(obj.fill),
+          ...(obj.stroke
+            ? {
+                borderColor: color(obj.stroke),
+                borderWidth: obj.strokeWidth ?? 1,
+                borderOpacity: obj.opacity,
+              }
+            : {}),
+        });
+      }
+
+      const inner = Math.max(1, rect.w - pad * 2);
+      const lines = wrapText(ctx.metrics, obj.text, s, inner, obj.list);
+      const lineH = s.size * s.lineHeight;
+      const ascent = ctx.metrics.ascent(s);
+      const textColor = color(s.color, { r: 0, g: 0, b: 0 })!;
+
+      lines.forEach((line, i) => {
+        // `drawText` positions a BASELINE; the wrap positions line BOXES. The
+        // ascent is the drop between them — without it every line sits high.
+        const baseline = pad + i * lineH + ascent;
+        if (line.marker) {
+          const mp = pdfPlacement(rect, obj.rot, pad, baseline);
+          page.drawText(line.marker, {
+            x: mp.x,
+            y: mp.y,
+            size: s.size,
+            font,
+            color: textColor,
+            opacity: obj.opacity,
+            rotate: degrees(mp.rotate),
+          });
+        }
+        if (!line.text) return;
+        const p = pdfPlacement(rect, obj.rot, pad + lineOffset(line, s, inner), baseline);
+        page.drawText(line.text, {
+          x: p.x,
+          y: p.y,
+          size: s.size,
+          font,
+          color: textColor,
+          opacity: obj.opacity,
+          rotate: degrees(p.rotate),
+        });
+      });
+      return;
+    }
+  }
+}
+
+/** The export's default filename: `talk.eldeck.json` → `talk.export.pdf`. */
+export function exportPathFor(deckPath: string): string {
+  return `${deckPath.replace(/\.eldeck\.json$/i, "")}.export.pdf`;
+}
diff --git a/src/lib/viewers/deck/fonts.ts b/src/lib/viewers/deck/fonts.ts
new file mode 100644
index 0000000..f8d42c2
--- /dev/null
+++ b/src/lib/viewers/deck/fonts.ts
@@ -0,0 +1,302 @@
+/**
+ * Text metrics and line breaking for the deck — **the single source of truth for
+ * both the editor and the PDF exporter**.
+ *
+ * This module exists to close the classic failure of a WYSIWYG-over-PDF editor:
+ * the editor wraps text using the browser's font metrics, the exporter wraps it
+ * using the PDF's, the two disagree by a few percent, and the export silently
+ * reflows — usually one word onto a new line, usually on the slide you cared
+ * about. Nothing about the editor's rendering can prevent that; only sharing the
+ * measurement can.
+ *
+ * So the deck measures with **pdf-lib's own metrics on both sides**. One
+ * throwaway `PDFDocument` is created at startup purely to embed the standard-14
+ * fonts and expose their `widthOfTextAtSize`; the stage lays out with it, the
+ * exporter lays out with it, and the export is identical to the screen by
+ * construction rather than by luck.
+ *
+ * The accepted cost is that a deck can use **only the standard-14 fonts**.
+ * Arbitrary TTFs would need `@pdf-lib/fontkit`, a font-embedding UI, and would
+ * reintroduce exactly the drift this avoids. On Linux, Helvetica/Times/Courier
+ * resolve to the metric-compatible Nimbus and Liberation families, so the painted
+ * glyphs match the measured advances too.
+ */
+
+import { PDFDocument, StandardFonts, type PDFFont } from "pdf-lib";
+import type { FontFamily, ListStyle, TextStyle } from "./model";
+
+/** The 12 faces a deck can use: three families × regular/bold/italic/bold-italic. */
+const FACES: Record<FontFamily, Record<string, StandardFonts>> = {
+  sans: {
+    r: StandardFonts.Helvetica,
+    b: StandardFonts.HelveticaBold,
+    i: StandardFonts.HelveticaOblique,
+    bi: StandardFonts.HelveticaBoldOblique,
+  },
+  serif: {
+    r: StandardFonts.TimesRoman,
+    b: StandardFonts.TimesRomanBold,
+    i: StandardFonts.TimesRomanItalic,
+    bi: StandardFonts.TimesRomanBoldItalic,
+  },
+  mono: {
+    r: StandardFonts.Courier,
+    b: StandardFonts.CourierBold,
+    i: StandardFonts.CourierOblique,
+    bi: StandardFonts.CourierBoldOblique,
+  },
+};
+
+/** Which of the four variants a style selects. */
+export function faceKey(bold: boolean, italic: boolean): string {
+  return bold && italic ? "bi" : bold ? "b" : italic ? "i" : "r";
+}
+
+/** The pdf-lib standard font a style maps to — used by the exporter to embed. */
+export function standardFontFor(style: {
+  family: FontFamily;
+  bold: boolean;
+  italic: boolean;
+}): StandardFonts {
+  return FACES[style.family][faceKey(style.bold, style.italic)];
+}
+
+export interface TextMetrics {
+  /** Advance width of `text` at `size` points, in points. */
+  width(text: string, style: MeasureStyle, size?: number): number;
+  /** Ascender-to-descender height at `size` points. */
+  height(style: MeasureStyle, size?: number): number;
+  /**
+   * Baseline offset from the top of a line, in points.
+   *
+   * The exporter needs this and the renderer does not: pdf-lib's `drawText`
+   * positions a **baseline**, while CSS positions a line box. Without it every
+   * exported line sits one ascender too high.
+   */
+  ascent(style: MeasureStyle, size?: number): number;
+}
+
+export type MeasureStyle = Pick<TextStyle, "family" | "bold" | "italic" | "size">;
+
+let cached: Promise<TextMetrics> | null = null;
+
+/**
+ * Embed the standard-14 faces once and expose their metrics.
+ *
+ * Memoized at module scope: the document exists only to own the font objects, is
+ * never written, and building a second one per deck tab would be pure waste.
+ */
+export function loadMetrics(): Promise<TextMetrics> {
+  if (cached) return cached;
+  cached = (async () => {
+    const doc = await PDFDocument.create();
+    const fonts = new Map<string, PDFFont>();
+    for (const family of Object.keys(FACES) as FontFamily[]) {
+      for (const variant of Object.keys(FACES[family])) {
+        fonts.set(`${family}-${variant}`, await doc.embedFont(FACES[family][variant]));
+      }
+    }
+    const pick = (s: MeasureStyle): PDFFont =>
+      fonts.get(`${s.family}-${faceKey(s.bold, s.italic)}`) ?? fonts.get("sans-r")!;
+    return {
+      width(text, style, size) {
+        if (!text) return 0;
+        try {
+          return pick(style).widthOfTextAtSize(text, size ?? style.size);
+        } catch {
+          // A character outside WinAnsi throws rather than measuring. Falling
+          // back to an em-based estimate keeps the layout sane instead of
+          // collapsing the line to zero — the export will substitute the glyph
+          // anyway, and a slightly wrong width beats a broken paragraph.
+          return text.length * (size ?? style.size) * 0.5;
+        }
+      },
+      height(style, size) {
+        return pick(style).heightAtSize(size ?? style.size);
+      },
+      ascent(style, size) {
+        // `descender: false` gives the ascent alone, which is exactly the drop
+        // from a line box's top to its baseline.
+        return pick(style).heightAtSize(size ?? style.size, { descender: false });
+      },
+    };
+  })();
+  return cached;
+}
+
+/** Drop the memo. Tests only. */
+export function resetMetrics(): void {
+  cached = null;
+}
+
+// ---------------------------------------------------------------------------
+// Line breaking
+// ---------------------------------------------------------------------------
+
+/** Gap between a list marker and its text, as a multiple of the font size. */
+export const MARKER_GAP = 0.45;
+
+export interface WrappedLine {
+  text: string;
+  /** The bullet/number, on the first visual line of a list item only. */
+  marker?: string;
+  /** Left inset for this line's text, in points. */
+  indent: number;
+  /** Measured advance width of `text`, in points. */
+  width: number;
+  /** Which source line (0-based) this came from — the build-step key for a
+   *  staggered list reveal. */
+  source: number;
+}
+
+/** The bullet/number a list line gets. Pure, and shared with the renderer so the
+ *  editor and the export never spell an enumeration differently. */
+export function listMarker(kind: ListStyle["kind"], index: number, start: number): string {
+  const n = start + index;
+  switch (kind) {
+    case "number":
+      return `${n}.`;
+    case "alpha":
+      // Wraps past 26 rather than going to "aa": a slide with 27 list items has
+      // a bigger problem than its numbering.
+      return `${String.fromCharCode(97 + ((n - 1) % 26))}.`;
+    case "roman":
+      return `${toRoman(n)}.`;
+    default:
+      return "•";
+  }
+}
+
+const ROMAN: ReadonlyArray<readonly [number, string]> = [
+  [1000, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"],
+];
+
+function toRoman(n: number): string {
+  let out = "";
+  let left = Math.max(1, Math.floor(n));
+  for (const [value, sym] of ROMAN) {
+    while (left >= value) {
+      out += sym;
+      left -= value;
+    }
+  }
+  return out;
+}
+
+/**
+ * Break `text` to fit `width` points.
+ *
+ * Greedy word wrapping, which is what every slide tool does and what readers
+ * expect; a Knuth–Plass optimum would be prettier and would also disagree with
+ * every other renderer the author compares against.
+ *
+ * A word longer than the whole line is broken by character rather than allowed
+ * to overflow — a pasted URL should look cramped, not spill off the slide.
+ * Explicit newlines always break, and each becomes its own list item.
+ */
+export function wrapText(
+  metrics: TextMetrics,
+  text: string,
+  style: MeasureStyle,
+  width: number,
+  list?: ListStyle,
+): WrappedLine[] {
+  const out: WrappedLine[] = [];
+  const paragraphs = text.split("\n");
+  const markerIndent = list
+    ? Math.max(
+        ...paragraphs.map((_p, i) =>
+          metrics.width(listMarker(list.kind, i, list.start), style),
+        ),
+      ) + style.size * MARKER_GAP
+    : 0;
+  const avail = Math.max(1, width - markerIndent);
+
+  paragraphs.forEach((para, pi) => {
+    const marker = list ? listMarker(list.kind, pi, list.start) : undefined;
+    const words = para.split(/(\s+)/).filter((w) => w !== "");
+    let line = "";
+    let first = true;
+
+    const push = () => {
+      out.push({
+        text: line,
+        ...(first && marker ? { marker } : {}),
+        indent: markerIndent,
+        width: metrics.width(line, style),
+        source: pi,
+      });
+      first = false;
+      line = "";
+    };
+
+    if (words.length === 0) {
+      push();
+      return;
+    }
+
+    for (const word of words) {
+      const candidate = line + word;
+      if (metrics.width(candidate, style) <= avail || line === "") {
+        // A single word wider than the line must still be broken, or it spills.
+        if (line === "" && metrics.width(word, style) > avail && !/^\s+$/.test(word)) {
+          let chunk = "";
+          for (const ch of word) {
+            if (chunk && metrics.width(chunk + ch, style) > avail) {
+              line = chunk;
+              push();
+              chunk = "";
+            }
+            chunk += ch;
+          }
+          line = chunk;
+          continue;
+        }
+        line = candidate;
+      } else {
+        // Trailing whitespace never justifies a break of its own.
+        line = line.replace(/\s+$/, "");
+        push();
+        line = /^\s+$/.test(word) ? "" : word;
+      }
+    }
+    line = line.replace(/\s+$/, "");
+    push();
+  });
+
+  return out;
+}
+
+/** Total laid-out height of `lines`, in points. */
+export function textHeight(lines: readonly WrappedLine[], style: TextStyle): number {
+  return lines.length * style.size * style.lineHeight;
+}
+
+/**
+ * Where a line's text starts, in points from the box's left inner edge, honouring
+ * alignment. Shared by the renderer and the exporter — a centred line that is
+ * centred differently in the export is the same bug as a reflowed one.
+ */
+export function lineOffset(line: WrappedLine, style: TextStyle, width: number): number {
+  const avail = width - line.indent;
+  switch (style.align) {
+    case "center":
+      return line.indent + Math.max(0, (avail - line.width) / 2);
+    case "right":
+      return line.indent + Math.max(0, avail - line.width);
+    default:
+      return line.indent;
+  }
+}
diff --git a/src/lib/viewers/deck/icons.ts b/src/lib/viewers/deck/icons.ts
new file mode 100644
index 0000000..fdb1521
--- /dev/null
+++ b/src/lib/viewers/deck/icons.ts
@@ -0,0 +1,536 @@
+/**
+ * The deck's built-in icon library — bundled, offline, and shaped by the export.
+ *
+ * Every icon is **SVG path data in a 24×24 box**, because that is the only vector
+ * form pdf-lib can emit (`drawSvgPath`): no `<circle>`, no groups, no gradients,
+ * no external sprite sheet. Storing paths therefore means the stage's `<path>`
+ * and the exported PDF draw from one geometry source and cannot disagree. It is
+ * also why the set is monochrome and stroke-based — a Lucide/Feather shape — and
+ * why nothing here is fetched at runtime, which keeps the app's offline story
+ * intact.
+ *
+ * Directional variants are **derived by rotation**, not hand-authored four times.
+ * One `arrow-right` becomes left/up/down by a `rotate` field the renderer and the
+ * exporter both honour: a quarter of the path data to get wrong, and a fix to the
+ * arrowhead fixes all four.
+ */
+
+export type IconCategory =
+  | "arrows"
+  | "shapes"
+  | "ui"
+  | "media"
+  | "files"
+  | "science"
+  | "tech"
+  | "people";
+
+export interface IconDef {
+  key: string;
+  label: string;
+  category: IconCategory;
+  /** Path data in a 24×24 box. Rendered stroked unless `filled`. */
+  paths: string[];
+  /** Degrees clockwise about (12, 12). Lets one glyph serve four directions. */
+  rotate?: number;
+  /** Filled rather than stroked (a play triangle, a solid dot). */
+  filled?: boolean;
+  /** Extra search terms beyond the label. */
+  alias?: string[];
+}
+
+/** A circle as two arcs — the only portable idiom, since `<circle>` cannot export. */
+const circle = (cx: number, cy: number, r: number): string =>
+  `M${cx - r} ${cy} a${r} ${r} 0 1 0 ${r * 2} 0 a${r} ${r} 0 1 0 ${-r * 2} 0`;
+
+/** Base glyphs. Directional variants are generated from these below. */
+const BASE: IconDef[] = [
+  // ── arrows ───────────────────────────────────────────────────────────────
+  { key: "arrow", label: "Arrow", category: "arrows", paths: ["M3 12 H20", "M14 6 L20 12 L14 18"] },
+  { key: "chevron", label: "Chevron", category: "arrows", paths: ["M9 5 L16 12 L9 19"] },
+  {
+    key: "arrow-both",
+    label: "Double arrow",
+    category: "arrows",
+    paths: ["M3 12 H21", "M8 7 L3 12 L8 17", "M16 7 L21 12 L16 17"],
+  },
+  {
+    key: "arrow-curve",
+    label: "Curved arrow",
+    category: "arrows",
+    paths: ["M5 18 C5 9 12 6 19 6", "M14 2 L19 6 L14 10"],
+  },
+  {
+    key: "refresh",
+    label: "Refresh",
+    category: "arrows",
+    paths: ["M20 12 A8 8 0 1 1 14.5 4.5", "M20 3 V9 H14"],
+    alias: ["cycle", "reload", "loop"],
+  },
+  {
+    key: "return",
+    label: "Return",
+    category: "arrows",
+    paths: ["M20 6 V12 a4 4 0 0 1-4 4 H5", "M9 12 L5 16 L9 20"],
+    alias: ["enter"],
+  },
+
+  // ── shapes ───────────────────────────────────────────────────────────────
+  { key: "square", label: "Square", category: "shapes", paths: ["M4 4 H20 V20 H4 Z"] },
+  { key: "circle", label: "Circle", category: "shapes", paths: [circle(12, 12, 9)] },
+  { key: "triangle", label: "Triangle", category: "shapes", paths: ["M12 3 L21 20 H3 Z"] },
+  { key: "diamond", label: "Diamond", category: "shapes", paths: ["M12 3 L21 12 L12 21 L3 12 Z"] },
+  {
+    key: "hexagon",
+    label: "Hexagon",
+    category: "shapes",
+    paths: ["M12 3 L20 7.5 V16.5 L12 21 L4 16.5 V7.5 Z"],
+  },
+  {
+    key: "star",
+    label: "Star",
+    category: "shapes",
+    paths: [
+      "M12 3 L14.6 9.3 L21.4 9.8 L16.2 14.2 L17.8 20.8 L12 17.2 L6.2 20.8 L7.8 14.2 L2.6 9.8 L9.4 9.3 Z",
+    ],
+  },
+  {
+    key: "heart",
+    label: "Heart",
+    category: "shapes",
+    paths: ["M12 20.5 C4 15 3 11 3 9 A5 5 0 0 1 12 6.5 A5 5 0 0 1 21 9 C21 11 20 15 12 20.5 Z"],
+  },
+  { key: "dot", label: "Dot", category: "shapes", paths: [circle(12, 12, 5)], filled: true },
+
+  // ── ui ───────────────────────────────────────────────────────────────────
+  { key: "check", label: "Check", category: "ui", paths: ["M4 12.5 L9.5 18 L20 6"], alias: ["tick", "yes", "done"] },
+  { key: "cross", label: "Cross", category: "ui", paths: ["M6 6 L18 18", "M18 6 L6 18"], alias: ["close", "no", "x"] },
+  { key: "plus", label: "Plus", category: "ui", paths: ["M12 5 V19", "M5 12 H19"], alias: ["add"] },
+  { key: "minus", label: "Minus", category: "ui", paths: ["M5 12 H19"], alias: ["remove", "subtract"] },
+  {
+    key: "search",
+    label: "Search",
+    category: "ui",
+    paths: [circle(11, 11, 7), "M16 16 L21 21"],
+    alias: ["find", "magnify"],
+  },
+  {
+    key: "gear",
+    label: "Settings",
+    category: "ui",
+    paths: [
+      circle(12, 12, 4),
+      "M12 2 V5",
+      "M12 19 V22",
+      "M2 12 H5",
+      "M19 12 H22",
+      "M5.2 5.2 L7.3 7.3",
+      "M16.7 16.7 L18.8 18.8",
+      "M18.8 5.2 L16.7 7.3",
+      "M7.3 16.7 L5.2 18.8",
+    ],
+    alias: ["cog", "config", "options"],
+  },
+  { key: "home", label: "Home", category: "ui", paths: ["M3 11 L12 3 L21 11", "M6 9.5 V21 H18 V9.5"] },
+  {
+    key: "filter",
+    label: "Filter",
+    category: "ui",
+    paths: ["M3 5 H21 L14 13 V20 L10 18 V13 Z"],
+  },
+  {
+    key: "eye",
+    label: "Visible",
+    category: "ui",
+    paths: ["M2 12 C5 7 8.5 5 12 5 C15.5 5 19 7 22 12 C19 17 15.5 19 12 19 C8.5 19 5 17 2 12 Z", circle(12, 12, 3)],
+    alias: ["view", "watch", "show"],
+  },
+  {
+    key: "lock",
+    label: "Lock",
+    category: "ui",
+    paths: ["M7 10 V7 a5 5 0 0 1 10 0 V10", "M4.5 10 H19.5 V21 H4.5 Z"],
+    alias: ["secure", "private"],
+  },
+  {
+    key: "key",
+    label: "Key",
+    category: "ui",
+    paths: [circle(15.5, 9, 4.5), "M12.3 12.2 L4 20.5", "M6.5 18 L9 20.5"],
+    alias: ["password", "auth"],
+  },
+  {
+    key: "warning",
+    label: "Warning",
+    category: "ui",
+    paths: ["M12 3 L22 20 H2 Z", "M12 9.5 V14.5", "M12 17 V17.6"],
+    alias: ["alert", "caution", "danger"],
+  },
+  { key: "info", label: "Info", category: "ui", paths: [circle(12, 12, 9), "M12 11 V17", "M12 7.4 V8"] },
+  {
+    key: "question",
+    label: "Question",
+    category: "ui",
+    paths: [circle(12, 12, 9), "M9.4 9.6 a2.6 2.6 0 1 1 2.6 3 V14.5", "M12 17.2 V17.8"],
+    alias: ["help", "unknown"],
+  },
+  {
+    key: "idea",
+    label: "Idea",
+    category: "ui",
+    paths: ["M9.5 18.5 H14.5", "M10.5 21.5 H13.5", "M12 2.5 A6 6 0 0 0 8.7 13.7 V16 H15.3 V13.7 A6 6 0 0 0 12 2.5 Z"],
+    alias: ["lightbulb", "insight", "hint"],
+  },
+  {
+    key: "pin",
+    label: "Pin",
+    category: "ui",
+    paths: ["M12 22 C12 22 19 14.5 19 9.5 A7 7 0 1 0 5 9.5 C5 14.5 12 22 12 22 Z", circle(12, 9.5, 2.6)],
+    alias: ["location", "marker", "place"],
+  },
+  { key: "tag", label: "Tag", category: "ui", paths: ["M3 12 V3.5 H11.5 L21 13 L13 21 Z", "M7 7.5 V7.6"] },
+  { key: "flag", label: "Flag", category: "ui", paths: ["M5 22 V3", "M5 4 H19 L16 9.5 L19 15 H5"] },
+  {
+    key: "bookmark",
+    label: "Bookmark",
+    category: "ui",
+    paths: ["M6 3 H18 V21 L12 16 L6 21 Z"],
+    alias: ["save"],
+  },
+  {
+    key: "target",
+    label: "Target",
+    category: "ui",
+    paths: [circle(12, 12, 9), circle(12, 12, 5.5), circle(12, 12, 2)],
+    alias: ["goal", "aim", "focus"],
+  },
+  {
+    key: "link",
+    label: "Link",
+    category: "ui",
+    paths: ["M10.5 13.5 a4.5 4.5 0 0 1 0-6.4 L13 4.6 a4.5 4.5 0 0 1 6.4 6.4 L18 12.4", "M13.5 10.5 a4.5 4.5 0 0 1 0 6.4 L11 19.4 a4.5 4.5 0 0 1-6.4-6.4 L6 11.6"],
+    alias: ["chain", "url"],
+  },
+  {
+    key: "trash",
+    label: "Delete",
+    category: "ui",
+    paths: ["M4 7 H20", "M9.5 7 V4 H14.5 V7", "M6 7 L7.2 21 H16.8 L18 7"],
+    alias: ["bin", "remove"],
+  },
+  {
+    key: "pencil",
+    label: "Edit",
+    category: "ui",
+    paths: ["M4 20 H8 L20 8 L16 4 L4 16 Z", "M14.5 5.5 L18.5 9.5"],
+    alias: ["write", "pen"],
+  },
+  { key: "copy", label: "Copy", category: "ui", paths: ["M9 9 H20 V20 H9 Z", "M15 9 V4 H4 V15 H9"] },
+  {
+    key: "grid",
+    label: "Grid",
+    category: "ui",
+    paths: ["M4 4 H10.5 V10.5 H4 Z", "M13.5 4 H20 V10.5 H13.5 Z", "M4 13.5 H10.5 V20 H4 Z", "M13.5 13.5 H20 V20 H13.5 Z"],
+  },
+  {
+    key: "list",
+    label: "List",
+    category: "ui",
+    paths: ["M9 6 H20", "M9 12 H20", "M9 18 H20", "M4.5 6 V6.1", "M4.5 12 V12.1", "M4.5 18 V18.1"],
+  },
+  {
+    key: "layers",
+    label: "Layers",
+    category: "ui",
+    paths: ["M12 3 L21 8 L12 13 L3 8 Z", "M3 12.5 L12 17.5 L21 12.5", "M3 16.5 L12 21.5 L21 16.5"],
+    alias: ["stack"],
+  },
+
+  // ── media ────────────────────────────────────────────────────────────────
+  { key: "play", label: "Play", category: "media", paths: ["M7 4 L20 12 L7 20 Z"], filled: true },
+  { key: "pause", label: "Pause", category: "media", paths: ["M8 4 V20", "M16 4 V20"] },
+  { key: "stop", label: "Stop", category: "media", paths: ["M6 6 H18 V18 H6 Z"], filled: true },
+  {
+    key: "camera",
+    label: "Camera",
+    category: "media",
+    paths: ["M3 8 H7 L9 5 H15 L17 8 H21 V20 H3 Z", circle(12, 13.5, 4)],
+    alias: ["photo"],
+  },
+  {
+    key: "image",
+    label: "Image",
+    category: "media",
+    paths: ["M3 5 H21 V19 H3 Z", "M3 16 L9 10 L13.5 14.5 L16.5 11.5 L21 16", "M8 9 V9.1"],
+    alias: ["picture", "photo"],
+  },
+  {
+    key: "video",
+    label: "Video",
+    category: "media",
+    paths: ["M3 6 H15 V18 H3 Z", "M15 10 L21 7 V17 L15 14"],
+    alias: ["film", "movie"],
+  },
+  {
+    key: "mic",
+    label: "Microphone",
+    category: "media",
+    paths: ["M12 3 a3 3 0 0 1 3 3 V11 a3 3 0 0 1-6 0 V6 a3 3 0 0 1 3-3 Z", "M5.5 11 a6.5 6.5 0 0 0 13 0", "M12 17.5 V21.5"],
+    alias: ["audio", "record", "voice"],
+  },
+
+  // ── files ────────────────────────────────────────────────────────────────
+  { key: "file", label: "File", category: "files", paths: ["M6 3 H14 L19 8 V21 H6 Z", "M14 3 V8 H19"] },
+  { key: "folder", label: "Folder", category: "files", paths: ["M3 6 H9.5 L11.5 9 H21 V19.5 H3 Z"] },
+  {
+    key: "database",
+    label: "Database",
+    category: "files",
+    paths: ["M4 6 a8 3 0 1 0 16 0 a8 3 0 1 0-16 0", "M4 6 V18 a8 3 0 0 0 16 0 V6", "M4 12 a8 3 0 0 0 16 0"],
+    alias: ["db", "storage", "data"],
+  },
+  {
+    key: "download",
+    label: "Download",
+    category: "files",
+    paths: ["M12 3 V15", "M6.5 10 L12 15.5 L17.5 10", "M4 20.5 H20"],
+  },
+  {
+    key: "upload",
+    label: "Upload",
+    category: "files",
+    paths: ["M12 16 V4", "M6.5 9.5 L12 4 L17.5 9.5", "M4 20.5 H20"],
+  },
+  { key: "mail", label: "Mail", category: "files", paths: ["M3 5 H21 V19 H3 Z", "M3 6 L12 13 L21 6"], alias: ["email", "envelope"] },
+  {
+    key: "book",
+    label: "Book",
+    category: "files",
+    paths: ["M12 6.5 C10 4.5 6.5 4 4 4.5 V19 C6.5 18.5 10 19 12 21", "M12 6.5 C14 4.5 17.5 4 20 4.5 V19 C17.5 18.5 14 19 12 21", "M12 6.5 V21"],
+    alias: ["read", "paper", "reference"],
+  },
+
+  // ── science ──────────────────────────────────────────────────────────────
+  {
+    key: "flask",
+    label: "Flask",
+    category: "science",
+    paths: ["M9.5 3 V9.5 L4 20.5 H20 L14.5 9.5 V3", "M8 3 H16", "M6.5 15.5 H17.5"],
+    alias: ["chemistry", "lab", "experiment"],
+  },
+  {
+    key: "atom",
+    label: "Atom",
+    category: "science",
+    paths: [circle(12, 12, 2), "M2.5 12 a9.5 4 0 1 0 19 0 a9.5 4 0 1 0-19 0", "M12 2.5 a4 9.5 0 1 0 0 19 a4 9.5 0 1 0 0-19"],
+    alias: ["physics", "science", "nucleus"],
+  },
+  {
+    key: "chart-bar",
+    label: "Bar chart",
+    category: "science",
+    paths: ["M3.5 20.5 H20.5", "M6.5 20.5 V12 H10 V20.5", "M13.5 20.5 V5.5 H17 V20.5"],
+    alias: ["graph", "histogram", "results"],
+  },
+  {
+    key: "chart-line",
+    label: "Line chart",
+    category: "science",
+    paths: ["M3.5 3.5 V20.5 H20.5", "M6 16.5 L10.5 11 L14 14 L20 6"],
+    alias: ["graph", "plot", "trend", "curve"],
+  },
+  {
+    key: "chart-pie",
+    label: "Pie chart",
+    category: "science",
+    paths: [circle(12, 12, 9), "M12 3 V12 H21"],
+    alias: ["graph", "share", "proportion"],
+  },
+  {
+    key: "sigma",
+    label: "Sum",
+    category: "science",
+    paths: ["M17.5 5 H6.5 L13 12 L6.5 19 H17.5"],
+    alias: ["sum", "total", "math"],
+  },
+  {
+    key: "infinity",
+    label: "Infinity",
+    category: "science",
+    paths: ["M8 8 a4 4 0 1 0 4 4 a4 4 0 1 1 4-4 a4 4 0 1 1-4 4 a4 4 0 1 0-4-4 Z"],
+    alias: ["endless", "math"],
+  },
+
+  // ── tech ─────────────────────────────────────────────────────────────────
+  {
+    key: "cpu",
+    label: "CPU",
+    category: "tech",
+    paths: ["M6 6 H18 V18 H6 Z", "M9.5 9.5 H14.5 V14.5 H9.5 Z", "M9 2.5 V6", "M15 2.5 V6", "M9 18 V21.5", "M15 18 V21.5", "M2.5 9 H6", "M2.5 15 H6", "M18 9 H21.5", "M18 15 H21.5"],
+    alias: ["processor", "chip", "compute"],
+  },
+  {
+    key: "server",
+    label: "Server",
+    category: "tech",
+    paths: ["M3 4 H21 V9.5 H3 Z", "M3 14.5 H21 V20 H3 Z", "M6.5 6.7 V6.8", "M6.5 17.2 V17.3"],
+    alias: ["host", "machine", "cluster", "hpc"],
+  },
+  {
+    key: "cloud",
+    label: "Cloud",
+    category: "tech",
+    paths: ["M7 19 A4.75 4.75 0 0 1 7.4 9.5 A6.25 6.25 0 0 1 19 11 A4 4 0 0 1 18 19 Z"],
+    alias: ["remote", "sync"],
+  },
+  {
+    key: "wifi",
+    label: "Wi-Fi",
+    category: "tech",
+    paths: ["M2.5 9 A14 14 0 0 1 21.5 9", "M6.5 13 A8.5 8.5 0 0 1 17.5 13", "M10 16.8 A3.5 3.5 0 0 1 14 16.8", "M12 20.5 V20.6"],
+    alias: ["network", "signal", "wireless"],
+  },
+  {
+    key: "terminal",
+    label: "Terminal",
+    category: "tech",
+    paths: ["M3 4.5 H21 V19.5 H3 Z", "M7 9.5 L10.5 12.5 L7 15.5", "M12.5 15.5 H17"],
+    alias: ["shell", "console", "command"],
+  },
+  {
+    key: "code",
+    label: "Code",
+    category: "tech",
+    paths: ["M9 7.5 L4 12 L9 16.5", "M15 7.5 L20 12 L15 16.5", "M13.5 4.5 L10.5 19.5"],
+    alias: ["dev", "program", "source"],
+  },
+  {
+    key: "git-branch",
+    label: "Branch",
+    category: "tech",
+    paths: [circle(7, 6, 2.5), circle(7, 18, 2.5), circle(17, 8.5, 2.5), "M7 8.5 V15.5", "M17 11 a6 6 0 0 1-6 6 H7"],
+    alias: ["git", "fork", "version"],
+  },
+  {
+    key: "network",
+    label: "Network",
+    category: "tech",
+    paths: [circle(12, 5, 2.5), circle(5, 19, 2.5), circle(19, 19, 2.5), "M10.5 7.2 L6.4 16.8", "M13.5 7.2 L17.6 16.8", "M7.5 19 H16.5"],
+    alias: ["graph", "nodes", "topology"],
+  },
+  {
+    key: "monitor",
+    label: "Monitor",
+    category: "tech",
+    paths: ["M3 4 H21 V16 H3 Z", "M9 20 H15", "M12 16 V20"],
+    alias: ["screen", "display", "desktop"],
+  },
+
+  // ── people ───────────────────────────────────────────────────────────────
+  {
+    key: "user",
+    label: "Person",
+    category: "people",
+    paths: [circle(12, 8, 4), "M4 21 a8 8 0 0 1 16 0"],
+    alias: ["person", "profile", "account"],
+  },
+  {
+    key: "users",
+    label: "People",
+    category: "people",
+    paths: [circle(9, 8, 3.5), "M2 21 a7 7 0 0 1 14 0", "M16 5 a3.5 3.5 0 0 1 0 7", "M17 14.5 a7 7 0 0 1 5 6.5"],
+    alias: ["group", "team", "audience"],
+  },
+  {
+    key: "speech",
+    label: "Speech",
+    category: "people",
+    paths: ["M4 4 H20 V16 H11 L6.5 20 V16 H4 Z"],
+    alias: ["comment", "chat", "quote", "bubble"],
+  },
+];
+
+/** Directions generated from a single base glyph, by rotation. */
+const DIRECTIONS: ReadonlyArray<readonly [string, number]> = [
+  ["right", 0],
+  ["down", 90],
+  ["left", 180],
+  ["up", 270],
+];
+
+/** Base glyphs that point right and should get all four directions. */
+const DIRECTIONAL = new Set(["arrow", "chevron"]);
+
+function buildLibrary(): IconDef[] {
+  const out: IconDef[] = [];
+  for (const def of BASE) {
+    if (!DIRECTIONAL.has(def.key)) {
+      out.push(def);
+      continue;
+    }
+    for (const [name, deg] of DIRECTIONS) {
+      out.push({
+        ...def,
+        key: `${def.key}-${name}`,
+        label: `${def.label} ${name}`,
+        ...(deg ? { rotate: deg } : {}),
+        alias: [...(def.alias ?? []), name],
+      });
+    }
+    // A diagonal, which people reach for constantly and no rotation of the four
+    // cardinals provides.
+    if (def.key === "arrow") {
+      out.push({
+        ...def,
+        key: "arrow-up-right",
+        label: "Arrow up-right",
+        rotate: 315,
+        alias: ["diagonal"],
+      });
+    }
+  }
+  return out;
+}
+
+/** Every icon, in display order. */
+export const ICONS: readonly IconDef[] = buildLibrary();
+
+const BY_KEY = new Map(ICONS.map((i) => [i.key, i]));
+
+export function iconByKey(key: string): IconDef | undefined {
+  return BY_KEY.get(key);
+}
+
+export const ICON_CATEGORIES: ReadonlyArray<{ id: IconCategory; label: string }> = [
+  { id: "arrows", label: "Arrows" },
+  { id: "shapes", label: "Shapes" },
+  { id: "ui", label: "Interface" },
+  { id: "media", label: "Media" },
+  { id: "files", label: "Files & data" },
+  { id: "science", label: "Science & charts" },
+  { id: "tech", label: "Tech" },
+  { id: "people", label: "People" },
+];
+
+/**
+ * Search by key, label and alias. Substring rather than fuzzy: a fuzzy
+ * subsequence match over ~80 short labels returns nearly everything for any
+ * two-letter query, which is worse than no search at all.
+ */
+export function searchIcons(query: string, category?: IconCategory): readonly IconDef[] {
+  const q = query.trim().toLowerCase();
+  const pool = category ? ICONS.filter((i) => i.category === category) : ICONS;
+  if (!q) return pool;
+  const scored: Array<{ def: IconDef; rank: number }> = [];
+  for (const def of pool) {
+    const label = def.label.toLowerCase();
+    const key = def.key.toLowerCase();
+    if (label.startsWith(q) || key.startsWith(q)) scored.push({ def, rank: 0 });
+    else if (label.includes(q) || key.includes(q)) scored.push({ def, rank: 1 });
+    else if (def.alias?.some((a) => a.includes(q))) scored.push({ def, rank: 2 });
+  }
+  return scored.sort((a, b) => a.rank - b.rank).map((s) => s.def);
+}
+
+/** The 24×24 box every path is authored in. */
+export const ICON_VIEWBOX = 24;
diff --git a/src/lib/viewers/deck/model.ts b/src/lib/viewers/deck/model.ts
new file mode 100644
index 0000000..6301979
--- /dev/null
+++ b/src/lib/viewers/deck/model.ts
@@ -0,0 +1,722 @@
+/**
+ * The presentation-deck model — the `pageModel` of the native presenter
+ * (`docs/deck_presenter_plan.md`), and like it: **pure**. Every operation takes a
+ * list and returns a new one, so a history stack is an array of snapshots and
+ * rendering is a straight `map`.
+ *
+ * Three ideas are worth internalising before reading the types.
+ *
+ * **The PDF is a background plate, not the document.** A deck lives in its own
+ * `*.eldeck.json` sidecar beside the base PDF. TeX regenerates that PDF on every
+ * compile, so anything stored *inside* it dies the next time the author fixes a
+ * typo. The sidecar survives arbitrarily many recompiles — and, being tracked
+ * text, it diffs, merges, and rides git lockstep to a remote host like any source
+ * file.
+ *
+ * **Geometry is normalized, type size is not.** Every object's `x/y/w/h` is a
+ * fraction (0..1) of the page box — the same choice `PresentationOverlay` makes
+ * for marker strokes — so zoom, a pane resize, a projector and an export at any
+ * DPI need no conversion table. Font size is in **PDF points**, because that is
+ * absolute: changing the base plate's size should move a caption, not reflow it
+ * to 19pt.
+ *
+ * **A GIF is a sequence entry, not an effect.** A PDF cannot carry animation at
+ * all, so `Slide.after` holds an {@link Interstitial}: a clip that plays *between*
+ * this slide and the next, occupying its own step in the presentation. That is
+ * what lets a pure TeX-generated deck show a training curve moving without
+ * leaving the deck. It is deliberately not a transition (`Transition` is the
+ * separate, purely cosmetic axis) and not an object (it never composites onto a
+ * page).
+ */
+
+/** Bumped only for a change old readers cannot survive. `sidecar.ts` migrates. */
+export const DECK_VERSION = 1;
+
+// ---------------------------------------------------------------------------
+// Ids
+// ---------------------------------------------------------------------------
+
+/**
+ * Ids must be unique across *sessions and branches*, not just within one list —
+ * a deck is a persisted, git-merged file, so the plain counter `pageModel` uses
+ * would hand the same `o7` to two branches that both added an object and let the
+ * merge silently fuse them. Hence counter + random suffix.
+ */
+let idCounter = 0;
+let randomSuffix: () => string = () =>
+  Math.random().toString(36).slice(2, 6);
+
+/** Install a deterministic suffix source. Tests only. */
+export function setIdSuffixSource(fn: () => string): void {
+  randomSuffix = fn;
+}
+
+/** Reset the id counter. Tests only. */
+export function resetIdCounter(): void {
+  idCounter = 0;
+}
+
+function mintId(prefix: string): string {
+  idCounter += 1;
+  return `${prefix}${idCounter.toString(36)}${randomSuffix()}`;
+}
+
+export const newObjectId = (): string => mintId("o");
+export const newSlideId = (): string => mintId("s");
+export const newInterstitialId = (): string => mintId("g");
+
+// ---------------------------------------------------------------------------
+// Text
+// ---------------------------------------------------------------------------
+
+/**
+ * The three standard-14 font families, which are the only ones a deck uses.
+ *
+ * That is a deliberate constraint, not an oversight: the editor and the exporter
+ * both wrap text with pdf-lib's own metrics (`deck/fonts.ts`), so what is on
+ * screen is what exports, *by construction*. Arbitrary TTFs would need
+ * `@pdf-lib/fontkit` plus a font-embedding UI, and would reintroduce exactly the
+ * editor-vs-exporter metric drift this avoids.
+ */
+export type FontFamily = "sans" | "serif" | "mono";
+
+export type TextAlign = "left" | "center" | "right";
+
+export interface TextStyle {
+  family: FontFamily;
+  /** PDF points — absolute, unlike the geometry around it. */
+  size: number;
+  bold: boolean;
+  italic: boolean;
+  /** `#rrggbb`. */
+  color: string;
+  align: TextAlign;
+  /** Baseline-to-baseline distance as a multiple of `size`. */
+  lineHeight: number;
+}
+
+export type ListKind = "bullet" | "number" | "alpha" | "roman";
+
+/**
+ * An "enumeration field" is a **style on a text object**, not an object kind of
+ * its own. Modeling it this way is what makes renumbering automatic, nesting fall
+ * out of per-line indent, and — the one that matters — stepped reveal free: list
+ * item *i* becomes build step *i* in one click, which is the most-used animation
+ * in any talk.
+ */
+export interface ListStyle {
+  kind: ListKind;
+  /** First ordinal (1 = "1." / "a." / "i."). Ignored for `bullet`. */
+  start: number;
+}
+
+// ---------------------------------------------------------------------------
+// Objects
+// ---------------------------------------------------------------------------
+
+export type BuildEffect = "none" | "fade" | "rise" | "scale" | "wipe" | "draw";
+
+/** When an object appears within its slide. `step: 0` = visible on entry. */
+export interface BuildStep {
+  step: number;
+  effect: BuildEffect;
+}
+
+interface ObjectBase {
+  id: string;
+  /** All four are fractions of the page box, 0..1. See the module note. */
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  /** Degrees clockwise. Free, unlike a PDF `/Rotate`. */
+  rot: number;
+  /** 0..1. */
+  opacity: number;
+  locked?: boolean;
+  hidden?: boolean;
+  build?: BuildStep;
+}
+
+export interface TextObject extends ObjectBase {
+  kind: "text";
+  text: string;
+  style: TextStyle;
+  list?: ListStyle;
+  /** Box fill behind the text, `#rrggbb`. Absent = transparent. */
+  fill?: string;
+  stroke?: string;
+  /** Points. */
+  strokeWidth?: number;
+  /** Inset between the box and the text, in points. */
+  padding: number;
+}
+
+export type ImageFit = "contain" | "cover" | "stretch";
+
+export interface ImageObject extends ObjectBase {
+  kind: "image";
+  /** Project-relative path. Relative so a deck survives being moved or synced. */
+  src: string;
+  fit: ImageFit;
+  /**
+   * Project-relative path to the `.tex` source that generates `src`, when this
+   * image is a **TeX figure** rather than an ordinary picture — placed via the
+   * deck toolbar's TeX FAB. `src` is a rasterized PNG of the compiled PDF's first
+   * page; Eldrun regenerates it whenever that PDF's mtime advances, so editing
+   * and recompiling the source (in its own tab) updates the slide in place. Absent
+   * for a plain image.
+   */
+  texSrc?: string;
+}
+
+/**
+ * Shapes are parametric path generators (`deck/shapes.ts`), and icons are
+ * single-path SVG data (`deck/icons.ts`), for one reason: pdf-lib emits vector
+ * art through `drawSvgPath`, which accepts path data and nothing else — no
+ * gradients, no groups, no SVG document. One renderer and one exporter therefore
+ * cover both, and the constraint is what picks the icon set (Lucide/Feather-shaped
+ * monochrome single-path icons).
+ */
+export type ShapeKind =
+  | "rect"
+  | "roundrect"
+  | "ellipse"
+  | "line"
+  | "arrow"
+  | "callout";
+
+export type ArrowHead = "none" | "arrow" | "dot" | "bar";
+
+export interface ShapeObject extends ObjectBase {
+  kind: "shape";
+  shape: ShapeKind;
+  fill?: string;
+  stroke: string;
+  /** Points. */
+  strokeWidth: number;
+  /** Corner radius for `roundrect`, as a fraction of the shorter side. */
+  radius?: number;
+  /** Endpoint markers, for `line`/`arrow`. */
+  head?: ArrowHead;
+  tail?: ArrowHead;
+}
+
+export interface IconObject extends ObjectBase {
+  kind: "icon";
+  /** Key into `deck/icons.ts`. */
+  icon: string;
+  color: string;
+  strokeWidth: number;
+}
+
+export type DeckObject = TextObject | ImageObject | ShapeObject | IconObject;
+export type ObjectKind = DeckObject["kind"];
+
+/** An object list, in paint order — index 0 is furthest back. */
+export type ObjectList = DeckObject[];
+
+// ---------------------------------------------------------------------------
+// Interstitials
+// ---------------------------------------------------------------------------
+
+/**
+ * How an interstitial ends.
+ *
+ * `manual` loops until the presenter advances — the right default for a clip the
+ * speaker talks over. `end` plays once and advances itself, for a short sting.
+ */
+export type InterstitialAdvance =
+  | { on: "manual" }
+  | { on: "end" }
+  | { on: "end-after"; loops: number };
+
+/**
+ * A GIF that plays **between** the slide carrying it and the next one, as its own
+ * step in the presentation sequence.
+ *
+ * This exists because a TeX-generated PDF cannot carry animation at all: without
+ * it the author has to alt-tab to a video player mid-talk. It hangs off a slide
+ * rather than living in the slide list so that the slide↔base-page anchoring
+ * (`sidecar.ts`) is completely unaffected by it.
+ */
+export interface Interstitial {
+  id: string;
+  /** Project-relative path to the `.gif`. */
+  src: string;
+  /** `contain` letterboxes; `cover` fills and crops. */
+  fit: "contain" | "cover";
+  /** What shows in the letterbox bars, `#rrggbb`. */
+  background: string;
+  advance: InterstitialAdvance;
+  /**
+   * 0-based frame used as the rail thumbnail, and written as a still page by the
+   * PDF export — a handout should show a placeholder where the animation was,
+   * not an unexplained jump.
+   */
+  poster: number;
+}
+
+// ---------------------------------------------------------------------------
+// Slides
+// ---------------------------------------------------------------------------
+
+/** Purely cosmetic page-replacement effect. Distinct from an interstitial. */
+export type Transition = "none" | "fade" | "push" | "wipe";
+
+/**
+ * How a slide finds its base page again after the `.tex` was recompiled.
+ *
+ * `page` is the answer as of the last successful resolve, and is right in the
+ * overwhelmingly common case where nothing structural changed. The other two are
+ * what make an *inserted* slide non-destructive:
+ *
+ *  - `line` — the SyncTeX source line that produced the page. `compile_tex`
+ *    already passes `-synctex=1` unconditionally, so this mapping is emitted and
+ *    thrown away today. It survives inserting, deleting and reordering other
+ *    slides exactly as well as the author's own mental model does, which makes it
+ *    strictly better than any content heuristic.
+ *  - `print` — a content fingerprint, for an imported PDF that has no source.
+ */
+export interface SlideAnchor {
+  /** 1-based page of the base PDF. */
+  page: number;
+  line?: number;
+  print?: string;
+}
+
+export interface Slide {
+  id: string;
+  anchor: SlideAnchor;
+  objects: ObjectList;
+  /** Speaker notes, shown only in the presenter view. */
+  notes: string;
+  transition: Transition;
+  /** Plays after this slide, before the next. See {@link Interstitial}. */
+  after?: Interstitial;
+}
+
+/**
+ * Layers that no longer have a base page — the bin a recompile puts orphans in
+ * rather than dropping them. A recompile that quietly eats an author's
+ * annotations is the failure mode that makes people stop using the tool, so this
+ * type exists to make the silent case impossible.
+ */
+export interface DetachedLayer {
+  /** Where it used to live, so the re-attach UI can say something useful. */
+  from: SlideAnchor;
+  objects: ObjectList;
+  notes: string;
+}
+
+// ---------------------------------------------------------------------------
+// Deck
+// ---------------------------------------------------------------------------
+
+/** Defaults a new object inherits, so a deck looks consistent without effort. */
+export interface DeckTheme {
+  text: TextStyle;
+  shapeFill: string;
+  shapeStroke: string;
+  shapeStrokeWidth: number;
+  iconColor: string;
+  iconStrokeWidth: number;
+  /** Safe-area inset as a fraction of the page, a snapping target. */
+  margin: number;
+  /** Whether the PDF export writes a poster page per interstitial. */
+  exportInterstitials: boolean;
+}
+
+export interface Deck {
+  version: number;
+  /** Project-relative path of the base PDF. `null` = no plate yet. */
+  base: string | null;
+  /** Project-relative path of the `.tex` that generates `base`, when there is one. */
+  source: string | null;
+  /** Base page box in PDF points. Drives every normalized→absolute conversion. */
+  pageWidth: number;
+  pageHeight: number;
+  slides: Slide[];
+  detached: DetachedLayer[];
+  theme: DeckTheme;
+}
+
+/** 16:9 at the usual TeX beamer size, in points. */
+export const DEFAULT_PAGE_WIDTH = 364.19;
+export const DEFAULT_PAGE_HEIGHT = 204.85;
+
+export function defaultTextStyle(): TextStyle {
+  return {
+    family: "sans",
+    size: 14,
+    bold: false,
+    italic: false,
+    color: "#111111",
+    align: "left",
+    lineHeight: 1.25,
+  };
+}
+
+export function defaultTheme(): DeckTheme {
+  return {
+    text: defaultTextStyle(),
+    shapeFill: "#00000000",
+    shapeStroke: "#111111",
+    shapeStrokeWidth: 1.5,
+    iconColor: "#111111",
+    iconStrokeWidth: 1.5,
+    margin: 0.05,
+    exportInterstitials: true,
+  };
+}
+
+/** An empty deck over `base`. `slides` is filled by `sidecar.ts` once the base
+ *  PDF's page count is known — the model never reads a PDF itself. */
+export function emptyDeck(base: string | null, source: string | null = null): Deck {
+  return {
+    version: DECK_VERSION,
+    base,
+    source,
+    pageWidth: DEFAULT_PAGE_WIDTH,
+    pageHeight: DEFAULT_PAGE_HEIGHT,
+    slides: [],
+    detached: [],
+    theme: defaultTheme(),
+  };
+}
+
+/** A slide showing 1-based `page` of the base plate, with nothing on it. */
+export function blankSlide(page: number): Slide {
+  return {
+    id: newSlideId(),
+    anchor: { page },
+    objects: [],
+    notes: "",
+    transition: "none",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Object operations — all pure, all returning a new list
+// ---------------------------------------------------------------------------
+
+/** Append `obj` on top of the stack. */
+export function addObject(list: ObjectList, obj: DeckObject): ObjectList {
+  return [...list, obj];
+}
+
+/**
+ * Replace every object in `ids` with `patch(object)`.
+ *
+ * A function rather than a partial so a caller can compute per-object — nudging a
+ * multi-selection needs each object's own `x`, not one shared value.
+ * Locked objects are skipped: that is what "locked" means, and enforcing it in
+ * one place beats every call site remembering to filter.
+ */
+export function updateObjects(
+  list: ObjectList,
+  ids: readonly string[],
+  patch: (obj: DeckObject) => DeckObject,
+): ObjectList {
+  const touching = new Set(ids);
+  return list.map((o) => (touching.has(o.id) && !o.locked ? patch(o) : o));
+}
+
+/** Drop every object in `ids`. Unknown ids are ignored; locked ones survive. */
+export function removeObjects(list: ObjectList, ids: readonly string[]): ObjectList {
+  const dropping = new Set(ids);
+  return list.filter((o) => !dropping.has(o.id) || o.locked === true);
+}
+
+/** Translate `ids` by a normalized delta. */
+export function moveObjects(
+  list: ObjectList,
+  ids: readonly string[],
+  dx: number,
+  dy: number,
+): ObjectList {
+  return updateObjects(list, ids, (o) => ({ ...o, x: o.x + dx, y: o.y + dy }));
+}
+
+/**
+ * Copy every object in `ids`, offset slightly so the copy is visibly on top of
+ * its original rather than exactly hiding it. Copies get fresh ids, so they
+ * select and move independently.
+ */
+export const DUPLICATE_OFFSET = 0.02;
+
+export function duplicateObjects(
+  list: ObjectList,
+  ids: readonly string[],
+): { list: ObjectList; ids: string[] } {
+  const copying = new Set(ids);
+  const fresh: string[] = [];
+  const out = list.flatMap((o) => {
+    if (!copying.has(o.id)) return [o];
+    const id = newObjectId();
+    fresh.push(id);
+    return [
+      o,
+      { ...o, id, x: o.x + DUPLICATE_OFFSET, y: o.y + DUPLICATE_OFFSET },
+    ];
+  });
+  return { list: out, ids: fresh };
+}
+
+/**
+ * Z-order. `toFront`/`toBack` move the selection as a block, preserving its
+ * internal order — the same bargain `pageModel.movePages` strikes, and for the
+ * same reason: a multi-selection that collapsed into a different order on every
+ * raise would be unusable.
+ */
+export function toFront(list: ObjectList, ids: readonly string[]): ObjectList {
+  const moving = new Set(ids);
+  return [...list.filter((o) => !moving.has(o.id)), ...list.filter((o) => moving.has(o.id))];
+}
+
+export function toBack(list: ObjectList, ids: readonly string[]): ObjectList {
+  const moving = new Set(ids);
+  return [...list.filter((o) => moving.has(o.id)), ...list.filter((o) => !moving.has(o.id))];
+}
+
+/**
+ * Raise each selected object one position, walking from the top so a block of
+ * adjacent selected objects slides up together instead of the topmost one
+ * repeatedly swapping with its selected neighbour and going nowhere.
+ */
+export function raiseObjects(list: ObjectList, ids: readonly string[]): ObjectList {
+  const moving = new Set(ids);
+  const out = [...list];
+  for (let i = out.length - 2; i >= 0; i -= 1) {
+    if (moving.has(out[i].id) && !moving.has(out[i + 1].id)) {
+      [out[i], out[i + 1]] = [out[i + 1], out[i]];
+    }
+  }
+  return out;
+}
+
+/** Lower each selected object one position. Mirror of {@link raiseObjects}. */
+export function lowerObjects(list: ObjectList, ids: readonly string[]): ObjectList {
+  const moving = new Set(ids);
+  const out = [...list];
+  for (let i = 1; i < out.length; i += 1) {
+    if (moving.has(out[i].id) && !moving.has(out[i - 1].id)) {
+      [out[i], out[i - 1]] = [out[i - 1], out[i]];
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Align & distribute
+// ---------------------------------------------------------------------------
+
+export type AlignEdge = "left" | "hcenter" | "right" | "top" | "vcenter" | "bottom";
+
+/**
+ * Align the selection to the **bounding box of the selection itself** when two or
+ * more objects are selected, and to the *page* when only one is.
+ *
+ * The single-object case is the one that would otherwise be a no-op, and "align
+ * this to the page" is precisely what someone means when they align one thing.
+ */
+export function alignObjects(
+  list: ObjectList,
+  ids: readonly string[],
+  edge: AlignEdge,
+): ObjectList {
+  const sel = list.filter((o) => ids.includes(o.id) && !o.locked);
+  if (sel.length === 0) return list;
+  const box =
+    sel.length === 1
+      ? { x: 0, y: 0, w: 1, h: 1 }
+      : boundingBox(sel);
+  return updateObjects(list, ids, (o) => {
+    switch (edge) {
+      case "left":
+        return { ...o, x: box.x };
+      case "hcenter":
+        return { ...o, x: box.x + (box.w - o.w) / 2 };
+      case "right":
+        return { ...o, x: box.x + box.w - o.w };
+      case "top":
+        return { ...o, y: box.y };
+      case "vcenter":
+        return { ...o, y: box.y + (box.h - o.h) / 2 };
+      case "bottom":
+        return { ...o, y: box.y + box.h - o.h };
+    }
+  });
+}
+
+/**
+ * Space the selection evenly between the two outermost objects, which stay put.
+ *
+ * Needs three objects to mean anything — with two there is no gap to equalise,
+ * and moving either would just be an align in disguise.
+ */
+export function distributeObjects(
+  list: ObjectList,
+  ids: readonly string[],
+  axis: "h" | "v",
+): ObjectList {
+  const sel = list.filter((o) => ids.includes(o.id) && !o.locked);
+  if (sel.length < 3) return list;
+  const pos = (o: DeckObject) => (axis === "h" ? o.x : o.y);
+  const len = (o: DeckObject) => (axis === "h" ? o.w : o.h);
+  const sorted = [...sel].sort((a, b) => pos(a) - pos(b));
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  // Distribute by the GAP between boxes, not by their origins: with mixed widths,
+  // equal origin spacing leaves visibly unequal gaps, which is the thing the user
+  // is actually trying to fix.
+  const span = pos(last) + len(last) - pos(first);
+  const total = sorted.reduce((s, o) => s + len(o), 0);
+  const gap = (span - total) / (sorted.length - 1);
+  const placed = new Map<string, number>();
+  let cursor = pos(first);
+  for (const o of sorted) {
+    placed.set(o.id, cursor);
+    cursor += len(o) + gap;
+  }
+  return updateObjects(list, ids, (o) => {
+    const p = placed.get(o.id);
+    if (p === undefined) return o;
+    return axis === "h" ? { ...o, x: p } : { ...o, y: p };
+  });
+}
+
+export interface Box {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+/** The tight box around `objects`. Empty input gives a zero box at the origin. */
+export function boundingBox(objects: readonly DeckObject[]): Box {
+  if (objects.length === 0) return { x: 0, y: 0, w: 0, h: 0 };
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const o of objects) {
+    x0 = Math.min(x0, o.x);
+    y0 = Math.min(y0, o.y);
+    x1 = Math.max(x1, o.x + o.w);
+    y1 = Math.max(y1, o.y + o.h);
+  }
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+
+// ---------------------------------------------------------------------------
+// Slide operations
+// ---------------------------------------------------------------------------
+
+/** Replace the slide at `index` with `patch(slide)`. Out-of-range is a no-op. */
+export function updateSlide(
+  slides: readonly Slide[],
+  index: number,
+  patch: (s: Slide) => Slide,
+): Slide[] {
+  if (index < 0 || index >= slides.length) return [...slides];
+  return slides.map((s, i) => (i === index ? patch(s) : s));
+}
+
+/** Splice `slide` in before `index` (`>= length` appends). */
+export function insertSlide(
+  slides: readonly Slide[],
+  slide: Slide,
+  index: number,
+): Slide[] {
+  const at = Math.min(Math.max(index, 0), slides.length);
+  return [...slides.slice(0, at), slide, ...slides.slice(at)];
+}
+
+export function removeSlides(slides: readonly Slide[], ids: readonly string[]): Slide[] {
+  const dropping = new Set(ids);
+  return slides.filter((s) => !dropping.has(s.id));
+}
+
+/**
+ * Move the slides in `ids` so the block lands at `toIndex`.
+ *
+ * `toIndex` counts the slides that are NOT moving — "insert before the
+ * `toIndex`-th survivor" — which is the index a drag naturally produces, because
+ * the dragged cards are exactly the ones the pointer is not hit-testing against.
+ * Same convention as `pageModel.movePages`, deliberately, so the two rails behave
+ * identically.
+ */
+export function moveSlides(
+  slides: readonly Slide[],
+  ids: readonly string[],
+  toIndex: number,
+): Slide[] {
+  const moving = new Set(ids);
+  const selected = slides.filter((s) => moving.has(s.id));
+  if (selected.length === 0) return [...slides];
+  const rest = slides.filter((s) => !moving.has(s.id));
+  const at = Math.min(Math.max(toIndex, 0), rest.length);
+  return [...rest.slice(0, at), ...selected, ...rest.slice(at)];
+}
+
+// ---------------------------------------------------------------------------
+// Presentation sequence
+// ---------------------------------------------------------------------------
+
+/**
+ * One stop in the presenter: a slide at a given build step, or an interstitial.
+ *
+ * Flattening the deck into this list up front is what makes the presenter's
+ * navigation trivially correct — `←` is `index - 1`, and the awkward cases
+ * (a slide with three builds followed by a GIF) are already expanded. In
+ * particular it is why `←` steps a build backwards instead of jumping a slide,
+ * which is the difference between surviving an audience question and losing the
+ * slide.
+ */
+export type Stop =
+  | { kind: "slide"; slide: number; step: number }
+  | { kind: "interstitial"; slide: number };
+
+/** The highest build step on a slide; 0 when nothing is animated. */
+export function maxBuildStep(slide: Slide): number {
+  return slide.objects.reduce((m, o) => Math.max(m, o.build?.step ?? 0), 0);
+}
+
+/** Expand the deck into the ordered list of presenter stops. */
+export function sequence(deck: Deck): Stop[] {
+  const out: Stop[] = [];
+  deck.slides.forEach((s, i) => {
+    const steps = maxBuildStep(s);
+    for (let step = 0; step <= steps; step += 1) {
+      out.push({ kind: "slide", slide: i, step });
+    }
+    if (s.after) out.push({ kind: "interstitial", slide: i });
+  });
+  return out;
+}
+
+/** Whether `obj` is visible at build `step`. */
+export function visibleAt(obj: DeckObject, step: number): boolean {
+  if (obj.hidden) return false;
+  return (obj.build?.step ?? 0) <= step;
+}
+
+/**
+ * Assign consecutive build steps to `ids`, in their current paint order — the
+ * one-click "reveal these one at a time" that the list-style model exists to make
+ * cheap. `from` is the step the first object gets.
+ */
+export function stagger(
+  list: ObjectList,
+  ids: readonly string[],
+  from: number,
+  effect: BuildEffect = "fade",
+): ObjectList {
+  const order = list.filter((o) => ids.includes(o.id)).map((o) => o.id);
+  const stepOf = new Map(order.map((id, i) => [id, from + i]));
+  return updateObjects(list, ids, (o) => ({
+    ...o,
+    build: { step: stepOf.get(o.id) ?? from, effect },
+  }));
+}
diff --git a/src/lib/viewers/deck/present.ts b/src/lib/viewers/deck/present.ts
new file mode 100644
index 0000000..6dc632d
--- /dev/null
+++ b/src/lib/viewers/deck/present.ts
@@ -0,0 +1,207 @@
+/**
+ * The dual-window presenter's wire protocol — and the navigation arithmetic both
+ * ends share.
+ *
+ * Two Tauri windows are two JS heaps: the audience window cannot read the
+ * editor's store, so everything it needs crosses as an event payload. The split
+ * that keeps it honest is **one owner**: the presenter (main) window owns the
+ * current stop and the blank screen; the audience window renders what it is told
+ * and forwards the keys pressed *in it* back as requests. A second copy of the
+ * index in the audience window is what would let the two displays disagree —
+ * which is the one failure the audience actually sees.
+ *
+ * The deck itself travels as its serialized sidecar text (small, and already the
+ * canonical form). The heavy parts — the base PDF, images, GIF frames — are NOT
+ * streamed: the audience window is given the deck's *path* and file scope and
+ * loads them itself through the ordinary confined file commands, so a 40 MB
+ * plate never becomes an event payload.
+ *
+ * Everything here is pure so both windows and the tests can share it.
+ */
+
+import type { Stop } from "./model";
+
+/** Blank-screen modes; `null` = showing the slide. */
+export type Blank = null | "black" | "white";
+
+// --- window identity -------------------------------------------------------
+
+/**
+ * FNV-1a (32-bit), base36. Only needs to be deterministic and collision-shy
+ * across the handful of decks one session opens — it names a window, it does not
+ * secure anything.
+ */
+function hash32(s: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(36);
+}
+
+/**
+ * The audience window's Tauri label for a deck.
+ *
+ * Derived from the path rather than minted per click so that opening the second
+ * display twice for one deck is idempotent (the backend returns the existing
+ * window), and so a re-opened presenter re-seeds the window that is already on
+ * the projector. The `present-` prefix is load-bearing: `capabilities/default.json`
+ * grants window permissions by that glob.
+ */
+export function presenterLabel(path: string): string {
+  return `present-${hash32(path)}`;
+}
+
+/**
+ * Parse the `?present=<label>` query that selects the audience-window render
+ * branch in `App`. Returns null when absent (→ the normal shell).
+ */
+export function parsePresentParam(search: string): string | null {
+  const raw = new URLSearchParams(search).get("present");
+  if (!raw) return null;
+  return /^present-[A-Za-z0-9_-]+$/.test(raw) ? raw : null;
+}
+
+// --- events ----------------------------------------------------------------
+
+/** Main → audience, namespaced: the whole deck + where to start. */
+export const presentSeedEvent = (label: string) => `deck-present-seed-${label}`;
+/** Main → audience, namespaced: the current stop / blank screen. */
+export const presentStateEvent = (label: string) => `deck-present-state-${label}`;
+/** Audience → main: "I am mounted, send me a seed" (carries its label). */
+export const PRESENT_READY = "deck-present-ready";
+/** Audience → main: a key was pressed over there; here is what it asked for. */
+export const PRESENT_NAV = "deck-present-nav";
+/** Audience → main: this window is going away (WM close), so drop back to one screen. */
+export const PRESENT_CLOSED = "deck-present-closed";
+
+export interface PresentSeed {
+  /** The deck's sidecar path — the audience window resolves its own assets from it. */
+  path: string;
+  /** File scope (owning project id) for the confined file commands; null = root. */
+  scope: string | null;
+  /** The deck, serialized exactly as the sidecar stores it. */
+  deck: string;
+  index: number;
+  blank: Blank;
+}
+
+export interface PresentState {
+  index: number;
+  blank: Blank;
+}
+
+/** What a key pressed in the audience window asks the presenter window to do. */
+export type NavAction =
+  | { kind: "next" }
+  | { kind: "prev" }
+  | { kind: "first" }
+  | { kind: "last" }
+  | { kind: "slide"; delta: number }
+  | { kind: "goto"; slide: number }
+  | { kind: "blank"; mode: Exclude<Blank, null> }
+  | { kind: "close" };
+
+export interface PresentNav {
+  label: string;
+  action: NavAction;
+}
+
+export interface PresentReady {
+  label: string;
+}
+
+// --- navigation (pure) -----------------------------------------------------
+
+export function clampStop(stops: readonly Stop[], i: number): number {
+  return Math.min(Math.max(i, 0), Math.max(0, stops.length - 1));
+}
+
+/**
+ * The index of the *entry* stop of slide `n` (its step 0), or -1.
+ *
+ * Deliberately the entry stop and not "any stop on that slide": jumping to a
+ * slide must show it as the audience first saw it, with its builds un-run.
+ */
+export function slideStopIndex(stops: readonly Stop[], n: number): number {
+  return stops.findIndex((s) => s.kind === "slide" && s.slide === n && s.step === 0);
+}
+
+/**
+ * Move a whole slide (the ↑/↓ behaviour): skip whatever builds remain rather
+ * than stepping through them. Staying put when there is no such slide is
+ * deliberate — running off the end of the deck mid-talk should do nothing.
+ */
+export function stepSlide(stops: readonly Stop[], i: number, delta: number): number {
+  const cur = stops[i];
+  if (!cur) return i;
+  const found = slideStopIndex(stops, cur.slide + delta);
+  return found >= 0 ? found : i;
+}
+
+/**
+ * Apply a navigation request from the audience window. Returns the new stop
+ * index; `close` is not a movement and is handled by the caller (it returns the
+ * index unchanged), and so is `blank`.
+ */
+export function applyNav(stops: readonly Stop[], index: number, action: NavAction): number {
+  switch (action.kind) {
+    case "next":
+      return clampStop(stops, index + 1);
+    case "prev":
+      return clampStop(stops, index - 1);
+    case "first":
+      return 0;
+    case "last":
+      return clampStop(stops, stops.length - 1);
+    case "slide":
+      return stepSlide(stops, index, action.delta);
+    case "goto": {
+      const found = slideStopIndex(stops, action.slide);
+      return found >= 0 ? found : index;
+    }
+    default:
+      return index;
+  }
+}
+
+/**
+ * The key → action mapping the audience window forwards.
+ *
+ * Shared with the presenter window's own handler so the two keyboards cannot
+ * drift: whichever display has focus, the same key does the same thing. Returns
+ * null for a key this surface does not claim (so it stays available to the
+ * browser/WM), and `digit` for a keystroke that is building a goto number —
+ * which only the caller can accumulate.
+ */
+export function keyToAction(key: string): NavAction | { kind: "digit"; digit: string } | null {
+  if (/^[0-9]$/.test(key)) return { kind: "digit", digit: key };
+  switch (key) {
+    case " ":
+    case "ArrowRight":
+    case "PageDown":
+      return { kind: "next" };
+    case "ArrowLeft":
+    case "PageUp":
+      return { kind: "prev" };
+    case "ArrowDown":
+      return { kind: "slide", delta: 1 };
+    case "ArrowUp":
+      return { kind: "slide", delta: -1 };
+    case "Home":
+      return { kind: "first" };
+    case "End":
+      return { kind: "last" };
+    case "b":
+    case "B":
+      return { kind: "blank", mode: "black" };
+    case "w":
+    case "W":
+      return { kind: "blank", mode: "white" };
+    case "Escape":
+      return { kind: "close" };
+    default:
+      return null;
+  }
+}
diff --git a/src/lib/viewers/deck/shapes.ts b/src/lib/viewers/deck/shapes.ts
new file mode 100644
index 0000000..475d6a7
--- /dev/null
+++ b/src/lib/viewers/deck/shapes.ts
@@ -0,0 +1,202 @@
+/**
+ * Parametric shape geometry for the deck — pure, and expressed as **SVG path
+ * data** rather than SVG elements.
+ *
+ * That choice is forced by the export end: pdf-lib emits vector art through
+ * `drawSvgPath`, which takes path data and nothing else — no `<rect>`, no
+ * `<ellipse>`, no groups, no gradients. Generating paths here means the stage and
+ * the PDF exporter draw from *one* geometry source, so a rounded corner can never
+ * be 6pt on screen and 8pt in the export. It is also why the icon library is
+ * single-path monochrome (`deck/icons.ts`): same renderer, same exporter.
+ *
+ * All coordinates are in the object's own box, `0,0` to `w,h`, with **y down**
+ * (SVG's convention, and the deck's). The exporter flips to PDF's y-up once, at
+ * the boundary, rather than every generator having to remember which way is up.
+ */
+
+import type { ArrowHead, ShapeKind } from "./model";
+
+/** Turn a run of points into a path, optionally closed. */
+function poly(pts: ReadonlyArray<readonly [number, number]>, close = false): string {
+  if (pts.length === 0) return "";
+  const [first, ...rest] = pts;
+  const body = rest.map(([x, y]) => `L ${r(x)} ${r(y)}`).join(" ");
+  return `M ${r(first[0])} ${r(first[1])} ${body}${close ? " Z" : ""}`;
+}
+
+/** Trim float noise so paths stay readable and diff cleanly in an export. */
+function r(n: number): number {
+  return Math.round(n * 1000) / 1000;
+}
+
+/**
+ * A cubic approximation of a quarter circle. The magic constant is the standard
+ * circle-to-Bézier ratio: with control points at `k·radius` the curve deviates
+ * from a true arc by <0.02%, which is invisible and avoids `A` arc commands that
+ * pdf-lib's path parser handles less predictably than curves.
+ */
+const KAPPA = 0.5522847498307936;
+
+export function rectPath(w: number, h: number): string {
+  return poly(
+    [
+      [0, 0],
+      [w, 0],
+      [w, h],
+      [0, h],
+    ],
+    true,
+  );
+}
+
+/** `radius` is a fraction of the shorter side, so a box keeps its look on resize. */
+export function roundRectPath(w: number, h: number, radius: number): string {
+  const rad = Math.min(Math.max(radius, 0), 0.5) * Math.min(w, h);
+  if (rad <= 0) return rectPath(w, h);
+  const c = rad * KAPPA;
+  return [
+    `M ${r(rad)} 0`,
+    `L ${r(w - rad)} 0`,
+    `C ${r(w - rad + c)} 0 ${r(w)} ${r(rad - c)} ${r(w)} ${r(rad)}`,
+    `L ${r(w)} ${r(h - rad)}`,
+    `C ${r(w)} ${r(h - rad + c)} ${r(w - rad + c)} ${r(h)} ${r(w - rad)} ${r(h)}`,
+    `L ${r(rad)} ${r(h)}`,
+    `C ${r(rad - c)} ${r(h)} 0 ${r(h - rad + c)} 0 ${r(h - rad)}`,
+    `L 0 ${r(rad)}`,
+    `C 0 ${r(rad - c)} ${r(rad - c)} 0 ${r(rad)} 0`,
+    "Z",
+  ].join(" ");
+}
+
+export function ellipsePath(w: number, h: number): string {
+  const rx = w / 2;
+  const ry = h / 2;
+  const cx = rx;
+  const cy = ry;
+  const ox = rx * KAPPA;
+  const oy = ry * KAPPA;
+  return [
+    `M ${r(cx)} 0`,
+    `C ${r(cx + ox)} 0 ${r(w)} ${r(cy - oy)} ${r(w)} ${r(cy)}`,
+    `C ${r(w)} ${r(cy + oy)} ${r(cx + ox)} ${r(h)} ${r(cx)} ${r(h)}`,
+    `C ${r(cx - ox)} ${r(h)} 0 ${r(cy + oy)} 0 ${r(cy)}`,
+    `C 0 ${r(cy - oy)} ${r(cx - ox)} 0 ${r(cx)} 0`,
+    "Z",
+  ].join(" ");
+}
+
+/** A line across the box's diagonal — so dragging a corner aims it. */
+export function linePath(w: number, h: number): string {
+  return poly([
+    [0, 0],
+    [w, h],
+  ]);
+}
+
+/**
+ * A speech callout: a rounded box occupying the top ~80% with a tail dropping
+ * from the lower-left third. The tail is part of the same path so fill and
+ * stroke treat the whole thing as one shape rather than a box with a triangle
+ * stuck on it.
+ */
+export function calloutPath(w: number, h: number, radius = 0.12): string {
+  const bodyH = h * 0.78;
+  const rad = Math.min(Math.max(radius, 0), 0.5) * Math.min(w, bodyH);
+  const c = rad * KAPPA;
+  const tailL = w * 0.22;
+  const tailR = w * 0.4;
+  return [
+    `M ${r(rad)} 0`,
+    `L ${r(w - rad)} 0`,
+    `C ${r(w - rad + c)} 0 ${r(w)} ${r(rad - c)} ${r(w)} ${r(rad)}`,
+    `L ${r(w)} ${r(bodyH - rad)}`,
+    `C ${r(w)} ${r(bodyH - rad + c)} ${r(w - rad + c)} ${r(bodyH)} ${r(w - rad)} ${r(bodyH)}`,
+    `L ${r(tailR)} ${r(bodyH)}`,
+    `L ${r(tailL)} ${r(h)}`,
+    `L ${r(tailL)} ${r(bodyH)}`,
+    `L ${r(rad)} ${r(bodyH)}`,
+    `C ${r(rad - c)} ${r(bodyH)} 0 ${r(bodyH - rad + c)} 0 ${r(bodyH - rad)}`,
+    `L 0 ${r(rad)}`,
+    `C 0 ${r(rad - c)} ${r(rad - c)} 0 ${r(rad)} 0`,
+    "Z",
+  ].join(" ");
+}
+
+/** The body path for a shape, in its own box. */
+export function shapePath(
+  shape: ShapeKind,
+  w: number,
+  h: number,
+  radius = 0.12,
+): string {
+  switch (shape) {
+    case "rect":
+      return rectPath(w, h);
+    case "roundrect":
+      return roundRectPath(w, h, radius);
+    case "ellipse":
+      return ellipsePath(w, h);
+    case "line":
+    case "arrow":
+      return linePath(w, h);
+    case "callout":
+      return calloutPath(w, h, radius);
+  }
+}
+
+/** Whether a shape's path should be filled at all. A line has no interior. */
+export function isClosedShape(shape: ShapeKind): boolean {
+  return shape !== "line" && shape !== "arrow";
+}
+
+/**
+ * A marker at `(x, y)` pointing along `angle` (radians).
+ *
+ * Sized from the stroke width rather than the object, so a head stays in
+ * proportion to the line it terminates instead of ballooning when the arrow is
+ * merely made longer.
+ */
+export function arrowHeadPath(
+  head: ArrowHead,
+  x: number,
+  y: number,
+  angle: number,
+  strokeWidth: number,
+): string {
+  if (head === "none") return "";
+  const s = Math.max(strokeWidth, 0.001) * 4;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  /** Rotate a point given in "along the line, across the line" space. */
+  const at = (along: number, across: number): [number, number] => [
+    x + along * cos - across * sin,
+    y + along * sin + across * cos,
+  ];
+  switch (head) {
+    case "arrow":
+      return poly([at(0, 0), at(-s, s * 0.5), at(-s, -s * 0.5)], true);
+    case "bar":
+      return poly([at(0, -s * 0.6), at(0, s * 0.6)]);
+    case "dot":
+      return circlePath(x, y, s * 0.35);
+  }
+}
+
+/** A circle centred on `(cx, cy)`, as curves. Used for the dot marker, which —
+ *  unlike every other shape — is positioned by its centre, not its box. */
+export function circlePath(cx: number, cy: number, rad: number): string {
+  const o = rad * KAPPA;
+  return [
+    `M ${r(cx)} ${r(cy - rad)}`,
+    `C ${r(cx + o)} ${r(cy - rad)} ${r(cx + rad)} ${r(cy - o)} ${r(cx + rad)} ${r(cy)}`,
+    `C ${r(cx + rad)} ${r(cy + o)} ${r(cx + o)} ${r(cy + rad)} ${r(cx)} ${r(cy + rad)}`,
+    `C ${r(cx - o)} ${r(cy + rad)} ${r(cx - rad)} ${r(cy + o)} ${r(cx - rad)} ${r(cy)}`,
+    `C ${r(cx - rad)} ${r(cy - o)} ${r(cx - o)} ${r(cy - rad)} ${r(cx)} ${r(cy - rad)}`,
+    "Z",
+  ].join(" ");
+}
+
+/** The angle of a shape's line, for placing its end markers. */
+export function lineAngle(w: number, h: number): number {
+  return Math.atan2(h, w);
+}
diff --git a/src/lib/viewers/deck/sidecar.ts b/src/lib/viewers/deck/sidecar.ts
new file mode 100644
index 0000000..a72d2f5
--- /dev/null
+++ b/src/lib/viewers/deck/sidecar.ts
@@ -0,0 +1,612 @@
+/**
+ * Reading, writing and — the part that matters — **re-anchoring** a deck sidecar
+ * (`docs/deck_presenter_plan.md` §2.1/§2.2). All pure: nothing here touches the
+ * filesystem, so every branch is testable and the viewer owns the I/O.
+ *
+ * Two jobs, and the second is the reason the feature is usable at all.
+ *
+ * **Parsing is defensive, not trusting.** A deck is hand-editable text under git,
+ * so it arrives having possibly been merged badly, half-edited in the YAML tree,
+ * or written by a newer build. `normalizeDeck` coerces every field to something
+ * renderable and drops what it cannot, because a viewer that throws on a bad
+ * merge is a viewer that loses the author's other twenty slides too.
+ *
+ * **Re-anchoring survives a recompile.** TeX rewrites the base PDF whenever the
+ * author fixes a typo, and inserting one slide shifts every page number after it.
+ * `reconcile` re-attaches layers to the pages they belong to, and — the invariant
+ * the whole design hangs on — **never silently drops one**. Anything it cannot
+ * place lands in `deck.detached` for the re-attach UI. A recompile that quietly
+ * eats annotations is what makes people stop trusting a tool.
+ */
+
+import {
+  DECK_VERSION,
+  type Deck,
+  type DetachedLayer,
+  type Slide,
+  blankSlide,
+  defaultTheme,
+  defaultTextStyle,
+  emptyDeck,
+  newSlideId,
+  type DeckObject,
+  type ObjectList,
+  type TextStyle,
+  type Transition,
+  type Interstitial,
+  newObjectId,
+  DEFAULT_PAGE_WIDTH,
+  DEFAULT_PAGE_HEIGHT,
+} from "./model";
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+/** The deck sidecar beside a base PDF: `talk.pdf` → `talk.eldeck.json`. */
+export function deckPathForPdf(pdfPath: string): string {
+  return `${pdfPath.replace(/\.pdf$/i, "")}.eldeck.json`;
+}
+
+/** The base PDF a deck sidecar names by convention, when it records none. */
+export function pdfPathForDeck(deckPath: string): string {
+  return `${deckPath.replace(/\.eldeck\.json$/i, "")}.pdf`;
+}
+
+// ---------------------------------------------------------------------------
+// Serialization
+// ---------------------------------------------------------------------------
+
+/**
+ * Two-space JSON with a trailing newline — the deck is a *tracked source file*,
+ * so it is formatted to diff line-by-line rather than to be compact. A one-line
+ * deck would make every edit a whole-file conflict.
+ */
+export function serializeDeck(deck: Deck): string {
+  return `${JSON.stringify(deck, null, 2)}\n`;
+}
+
+export interface ParseResult {
+  deck: Deck;
+  /** Set when the text could not be read at all and `deck` is a fresh empty one. */
+  error?: string;
+  /** Set when the file parsed but something in it was repaired or discarded. */
+  repaired?: string;
+}
+
+export function parseDeck(text: string, base: string | null = null): ParseResult {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    return { deck: emptyDeck(base), error: `not valid JSON: ${String(e)}` };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { deck: emptyDeck(base), error: "not a deck object" };
+  }
+  return normalizeDeck(raw as Record<string, unknown>, base);
+}
+
+// --- coercion helpers ------------------------------------------------------
+// Each returns the fallback rather than throwing: see the module note on why a
+// malformed field must never cost the author the rest of the deck.
+
+const num = (v: unknown, fb: number): number =>
+  typeof v === "number" && Number.isFinite(v) ? v : fb;
+
+const str = (v: unknown, fb: string): string => (typeof v === "string" ? v : fb);
+
+const bool = (v: unknown, fb: boolean): boolean =>
+  typeof v === "boolean" ? v : fb;
+
+const oneOf = <T extends string>(v: unknown, allowed: readonly T[], fb: T): T =>
+  typeof v === "string" && (allowed as readonly string[]).includes(v) ? (v as T) : fb;
+
+/** A hex color, or the fallback. Accepts `#rgb`, `#rrggbb`, `#rrggbbaa`. */
+const color = (v: unknown, fb: string): string =>
+  typeof v === "string" && /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(v) ? v : fb;
+
+/** Clamp into 0..1. Geometry outside the page is legal (an object can hang off
+ *  the edge) so only genuinely unbounded fields use this. */
+const unit = (v: unknown, fb: number): number => {
+  const n = num(v, fb);
+  return Math.min(1, Math.max(0, n));
+};
+
+function normalizeTextStyle(v: unknown): TextStyle {
+  const d = defaultTextStyle();
+  if (!v || typeof v !== "object") return d;
+  const o = v as Record<string, unknown>;
+  return {
+    family: oneOf(o.family, ["sans", "serif", "mono"] as const, d.family),
+    size: Math.max(1, num(o.size, d.size)),
+    bold: bool(o.bold, d.bold),
+    italic: bool(o.italic, d.italic),
+    color: color(o.color, d.color),
+    align: oneOf(o.align, ["left", "center", "right"] as const, d.align),
+    lineHeight: Math.max(0.5, num(o.lineHeight, d.lineHeight)),
+  };
+}
+
+function normalizeObject(v: unknown): DeckObject | null {
+  if (!v || typeof v !== "object") return null;
+  const o = v as Record<string, unknown>;
+  const kind = o.kind;
+  const common = {
+    id: str(o.id, "") || newObjectId(),
+    x: num(o.x, 0),
+    y: num(o.y, 0),
+    w: Math.max(0, num(o.w, 0.2)),
+    h: Math.max(0, num(o.h, 0.1)),
+    rot: num(o.rot, 0),
+    opacity: unit(o.opacity, 1),
+    ...(bool(o.locked, false) ? { locked: true } : {}),
+    ...(bool(o.hidden, false) ? { hidden: true } : {}),
+    ...(o.build && typeof o.build === "object"
+      ? {
+          build: {
+            step: Math.max(0, Math.round(num((o.build as Record<string, unknown>).step, 0))),
+            effect: oneOf(
+              (o.build as Record<string, unknown>).effect,
+              ["none", "fade", "rise", "scale", "wipe", "draw"] as const,
+              "fade",
+            ),
+          },
+        }
+      : {}),
+  };
+
+  switch (kind) {
+    case "text":
+      return {
+        ...common,
+        kind: "text",
+        text: str(o.text, ""),
+        style: normalizeTextStyle(o.style),
+        ...(o.list && typeof o.list === "object"
+          ? {
+              list: {
+                kind: oneOf(
+                  (o.list as Record<string, unknown>).kind,
+                  ["bullet", "number", "alpha", "roman"] as const,
+                  "bullet",
+                ),
+                start: Math.max(1, Math.round(num((o.list as Record<string, unknown>).start, 1))),
+              },
+            }
+          : {}),
+        ...(typeof o.fill === "string" ? { fill: color(o.fill, "#ffffff") } : {}),
+        ...(typeof o.stroke === "string" ? { stroke: color(o.stroke, "#111111") } : {}),
+        ...(typeof o.strokeWidth === "number" ? { strokeWidth: Math.max(0, o.strokeWidth) } : {}),
+        padding: Math.max(0, num(o.padding, 2)),
+      };
+    case "image":
+      // An image with no source cannot render and cannot be repaired — dropping
+      // it is the honest outcome, and it is reported as a repair.
+      if (typeof o.src !== "string" || !o.src) return null;
+      return {
+        ...common,
+        kind: "image",
+        src: o.src,
+        fit: oneOf(o.fit, ["contain", "cover", "stretch"] as const, "contain"),
+        ...(typeof o.texSrc === "string" && o.texSrc ? { texSrc: o.texSrc } : {}),
+      };
+    case "shape":
+      return {
+        ...common,
+        kind: "shape",
+        shape: oneOf(
+          o.shape,
+          ["rect", "roundrect", "ellipse", "line", "arrow", "callout"] as const,
+          "rect",
+        ),
+        ...(typeof o.fill === "string" ? { fill: color(o.fill, "#ffffff") } : {}),
+        stroke: color(o.stroke, "#111111"),
+        strokeWidth: Math.max(0, num(o.strokeWidth, 1.5)),
+        ...(typeof o.radius === "number" ? { radius: unit(o.radius, 0.1) } : {}),
+        ...(typeof o.head === "string"
+          ? { head: oneOf(o.head, ["none", "arrow", "dot", "bar"] as const, "none") }
+          : {}),
+        ...(typeof o.tail === "string"
+          ? { tail: oneOf(o.tail, ["none", "arrow", "dot", "bar"] as const, "none") }
+          : {}),
+      };
+    case "icon":
+      if (typeof o.icon !== "string" || !o.icon) return null;
+      return {
+        ...common,
+        kind: "icon",
+        icon: o.icon,
+        color: color(o.color, "#111111"),
+        strokeWidth: Math.max(0, num(o.strokeWidth, 1.5)),
+      };
+    default:
+      // An unknown kind is most likely a NEWER build's object. Dropping it is
+      // lossy but unavoidable — we cannot render or round-trip what we can't
+      // model — so it is counted as a repair rather than passed over in silence.
+      return null;
+  }
+}
+
+function normalizeInterstitial(v: unknown): Interstitial | null {
+  if (!v || typeof v !== "object") return null;
+  const o = v as Record<string, unknown>;
+  if (typeof o.src !== "string" || !o.src) return null;
+  const adv = (o.advance ?? {}) as Record<string, unknown>;
+  const on = oneOf(adv.on, ["manual", "end", "end-after"] as const, "manual");
+  return {
+    id: str(o.id, "") || `g${Math.random().toString(36).slice(2, 8)}`,
+    src: o.src,
+    fit: oneOf(o.fit, ["contain", "cover"] as const, "contain"),
+    background: color(o.background, "#000000"),
+    advance:
+      on === "end-after"
+        ? { on, loops: Math.max(1, Math.round(num(adv.loops, 1))) }
+        : { on },
+    poster: Math.max(0, Math.round(num(o.poster, 0))),
+  };
+}
+
+function normalizeObjects(v: unknown, report: (what: string) => void): ObjectList {
+  if (!Array.isArray(v)) return [];
+  const out: ObjectList = [];
+  for (const raw of v) {
+    const o = normalizeObject(raw);
+    if (o) out.push(o);
+    else report("object");
+  }
+  return out;
+}
+
+function normalizeSlide(v: unknown, report: (what: string) => void): Slide | null {
+  if (!v || typeof v !== "object") return null;
+  const o = v as Record<string, unknown>;
+  const anchorRaw = (o.anchor ?? {}) as Record<string, unknown>;
+  const page = Math.max(1, Math.round(num(anchorRaw.page, 1)));
+  const after = normalizeInterstitial(o.after);
+  return {
+    id: str(o.id, "") || newSlideId(),
+    anchor: {
+      page,
+      ...(typeof anchorRaw.line === "number"
+        ? { line: Math.max(1, Math.round(anchorRaw.line)) }
+        : {}),
+      ...(typeof anchorRaw.print === "string" ? { print: anchorRaw.print } : {}),
+    },
+    objects: normalizeObjects(o.objects, report),
+    notes: str(o.notes, ""),
+    transition: oneOf(
+      o.transition,
+      ["none", "fade", "push", "wipe"] as const satisfies readonly Transition[],
+      "none",
+    ),
+    ...(after ? { after } : {}),
+  };
+}
+
+/**
+ * Coerce an arbitrary parsed object into a renderable {@link Deck}, reporting
+ * whatever had to be repaired. Never throws.
+ */
+export function normalizeDeck(
+  raw: Record<string, unknown>,
+  base: string | null = null,
+): ParseResult {
+  const repairs: string[] = [];
+  const report = (what: string) => repairs.push(what);
+
+  const themeRaw = (raw.theme ?? {}) as Record<string, unknown>;
+  const dt = defaultTheme();
+
+  const slides: Slide[] = [];
+  if (Array.isArray(raw.slides)) {
+    for (const s of raw.slides) {
+      const slide = normalizeSlide(s, report);
+      if (slide) slides.push(slide);
+      else report("slide");
+    }
+  }
+
+  const detached: DetachedLayer[] = [];
+  if (Array.isArray(raw.detached)) {
+    for (const d of raw.detached) {
+      if (!d || typeof d !== "object") continue;
+      const o = d as Record<string, unknown>;
+      const fromRaw = (o.from ?? {}) as Record<string, unknown>;
+      detached.push({
+        from: { page: Math.max(1, Math.round(num(fromRaw.page, 1))) },
+        objects: normalizeObjects(o.objects, report),
+        notes: str(o.notes, ""),
+      });
+    }
+  }
+
+  const deck: Deck = {
+    version: DECK_VERSION,
+    base: typeof raw.base === "string" ? raw.base : base,
+    source: typeof raw.source === "string" ? raw.source : null,
+    pageWidth: Math.max(1, num(raw.pageWidth, DEFAULT_PAGE_WIDTH)),
+    pageHeight: Math.max(1, num(raw.pageHeight, DEFAULT_PAGE_HEIGHT)),
+    slides,
+    detached,
+    theme: {
+      text: normalizeTextStyle(themeRaw.text),
+      shapeFill: color(themeRaw.shapeFill, dt.shapeFill),
+      shapeStroke: color(themeRaw.shapeStroke, dt.shapeStroke),
+      shapeStrokeWidth: Math.max(0, num(themeRaw.shapeStrokeWidth, dt.shapeStrokeWidth)),
+      iconColor: color(themeRaw.iconColor, dt.iconColor),
+      iconStrokeWidth: Math.max(0, num(themeRaw.iconStrokeWidth, dt.iconStrokeWidth)),
+      margin: unit(themeRaw.margin, dt.margin),
+      exportInterstitials: bool(themeRaw.exportInterstitials, dt.exportInterstitials),
+    },
+  };
+
+  const version = num(raw.version, DECK_VERSION);
+  if (version > DECK_VERSION) {
+    repairs.push(`written by a newer Eldrun (deck v${version})`);
+  }
+
+  return {
+    deck,
+    ...(repairs.length ? { repaired: summarize(repairs) } : {}),
+  };
+}
+
+function summarize(repairs: string[]): string {
+  const counts = new Map<string, number>();
+  for (const r of repairs) counts.set(r, (counts.get(r) ?? 0) + 1);
+  return [...counts.entries()]
+    .map(([what, n]) => (n > 1 ? `${n} ${what}s` : what))
+    .join(", ");
+}
+
+// ---------------------------------------------------------------------------
+// Anchoring
+// ---------------------------------------------------------------------------
+
+/** A page of the base PDF, as the viewer reads it out of pdf.js. */
+export interface BasePage {
+  /** 1-based. */
+  page: number;
+  /** Page box in points. */
+  width: number;
+  height: number;
+  /** Extracted text, already collapsed to single spaces by the caller. */
+  text: string;
+  /**
+   * Source lines SyncTeX says contributed to this page, when the deck has a
+   * `.tex`. This is the *good* anchor — see {@link SlideAnchor}.
+   */
+  lines?: number[];
+}
+
+/** How many characters of page text the fingerprint covers. Enough to tell two
+ *  slides apart, short enough that editing a slide's body does not break it. */
+export const FINGERPRINT_CHARS = 200;
+
+/**
+ * A stable id for a base page's *content*.
+ *
+ * Deliberately coarse: the page box plus the first {@link FINGERPRINT_CHARS}
+ * characters, whitespace-collapsed and lowercased. It has to survive the author
+ * fixing a typo further down the slide (or it re-anchors constantly) while still
+ * telling two slides apart (or it re-anchors wrongly). Text before layout, so a
+ * font change does not move it.
+ */
+export function fingerprint(p: Pick<BasePage, "width" | "height" | "text">): string {
+  const head = p.text
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, FINGERPRINT_CHARS)
+    .toLowerCase();
+  return `${Math.round(p.width)}x${Math.round(p.height)}:${hash(head)}`;
+}
+
+/** FNV-1a, 32-bit, hex. Not cryptographic — it only has to be stable and cheap. */
+function hash(s: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i += 1) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+export interface ReconcileResult {
+  deck: Deck;
+  /** Slides whose base page moved under them. */
+  moved: number;
+  /** Slides added because the base gained pages. */
+  added: number;
+  /** Layers that could not be re-attached and went to `deck.detached`. */
+  detached: number;
+  /** True when nothing had to change — the overwhelmingly common case. */
+  unchanged: boolean;
+}
+
+/** Does a slide hold anything worth preserving? An empty one is free to drop. */
+function hasContent(s: Slide): boolean {
+  return s.objects.length > 0 || s.notes.trim() !== "" || s.after != null;
+}
+
+/**
+ * Re-attach `deck`'s slides to `pages` after the base PDF changed.
+ *
+ * Resolution order, cheapest and most trustworthy first:
+ *
+ *  1. **Nothing moved** — same page count and every recorded fingerprint still
+ *     matches its page. Returns untouched (bar refreshed fingerprints).
+ *  2. **SyncTeX line** — a slide anchored to source line *L* claims the page
+ *     whose `lines` contain *L*. Survives insertion/deletion/reordering of other
+ *     slides, because it is anchored to the author's own source.
+ *  3. **Fingerprint** — for an imported PDF with no source.
+ *  4. **Order** — remaining slides fill remaining pages front to back.
+ *
+ * Slides with content that still find no page go to `deck.detached`; empty ones
+ * are dropped, since there is nothing to lose. Pages with no slide get a blank
+ * one, so the deck always covers the whole base.
+ */
+export function reconcile(deck: Deck, pages: BasePage[]): ReconcileResult {
+  if (pages.length === 0) {
+    // A base that reports no pages is a failed load, not an empty document.
+    // Changing nothing is the only safe response — wiping every layer because
+    // pdf.js hiccuped would be exactly the silent loss this module exists to
+    // prevent.
+    return { deck, moved: 0, added: 0, detached: 0, unchanged: true };
+  }
+
+  const prints = pages.map((p) => fingerprint(p));
+
+  // 1 — fast path.
+  const sameCount = deck.slides.length === pages.length;
+  const allMatch =
+    sameCount &&
+    deck.slides.every((s, i) => {
+      if (s.anchor.page !== i + 1) return false;
+      return s.anchor.print == null || s.anchor.print === prints[i];
+    });
+  if (allMatch) {
+    return {
+      deck: {
+        ...deck,
+        pageWidth: pages[0].width,
+        pageHeight: pages[0].height,
+        slides: deck.slides.map((s, i) => ({
+          ...s,
+          anchor: { ...s.anchor, page: i + 1, print: prints[i] },
+        })),
+      },
+      moved: 0,
+      added: 0,
+      detached: 0,
+      unchanged: true,
+    };
+  }
+
+  // A page may be backed by MORE THAN ONE slide — that is what makes duplicating a
+  // slide durable: the copy shares its original's page (same line/fingerprint) and
+  // both survive a reload. So placement records which pages are *covered* rather
+  // than reserving each page for a single slide; only the order fallback (step 4),
+  // which has no evidence to share on, still hands out one uncovered page apiece.
+  const placed = new Map<string, number>(); // slide id → 0-based page index
+  const covered = new Set<number>();
+  const place = (slide: Slide, idx: number): void => {
+    if (idx < 0 || idx >= pages.length) return;
+    placed.set(slide.id, idx);
+    covered.add(idx);
+  };
+
+  // 2 — SyncTeX line.
+  const pageOfLine = new Map<number, number>();
+  pages.forEach((p, i) => {
+    for (const l of p.lines ?? []) if (!pageOfLine.has(l)) pageOfLine.set(l, i);
+  });
+  for (const s of deck.slides) {
+    if (s.anchor.line == null) continue;
+    const idx = pageOfLine.get(s.anchor.line);
+    if (idx != null) place(s, idx);
+  }
+
+  // 3 — fingerprint. Only unique fingerprints are trusted: two identical pages
+  // (a repeated section divider, say) carry no information about which slide is
+  // which, and guessing there would shuffle layers between them.
+  const printIdx = new Map<string, number[]>();
+  prints.forEach((p, i) => {
+    const list = printIdx.get(p);
+    if (list) list.push(i);
+    else printIdx.set(p, [i]);
+  });
+  for (const s of deck.slides) {
+    if (placed.has(s.id) || s.anchor.print == null) continue;
+    const hits = printIdx.get(s.anchor.print);
+    if (hits?.length === 1) place(s, hits[0]);
+  }
+
+  // 4 — order. Remaining slides take remaining UNCOVERED pages, front to back,
+  // preserving their relative order so a deck that merely gained a page at the end
+  // does the obvious thing.
+  let cursor = 0;
+  const orphans: Slide[] = [];
+  for (const s of deck.slides) {
+    if (placed.has(s.id)) continue;
+    while (cursor < pages.length && covered.has(cursor)) cursor += 1;
+    if (cursor < pages.length) place(s, cursor);
+    else orphans.push(s);
+  }
+
+  // Assemble preserving the deck's OWN slide order. The presentation sequence is
+  // the author's, not the base PDF's page order — a manual reorder must survive a
+  // reload, and a recompile only re-anchors each slide to the page it now backs.
+  // (A slide keeps the page it claimed above, so a pure reorder re-claims every
+  // page by fingerprint/line and `moved` stays 0.)
+  let moved = 0;
+  let added = 0;
+  const slides: Slide[] = [];
+  for (const s of deck.slides) {
+    const idx = placed.get(s.id);
+    if (idx == null) continue; // an orphan — collected into `newlyDetached` below
+    if (idx + 1 !== s.anchor.page) moved += 1;
+    slides.push({ ...s, anchor: { ...s.anchor, page: idx + 1, print: prints[idx] } });
+  }
+
+  // Cover every base page: a page no slide claimed is a frame the source just
+  // grew, so it gets a blank slide, spliced in before the first slide backing a
+  // later page (i.e. in page order relative to the placed slides) rather than
+  // dumped at the end. Blank slides carry nothing, so placement is cosmetic, never
+  // lossy.
+  for (let i = 0; i < pages.length; i += 1) {
+    if (covered.has(i)) continue;
+    added += 1;
+    let at = slides.length;
+    for (let j = 0; j < slides.length; j += 1) {
+      if (slides[j].anchor.page > i + 1) {
+        at = j;
+        break;
+      }
+    }
+    slides.splice(at, 0, { ...blankSlide(i + 1), anchor: { page: i + 1, print: prints[i] } });
+  }
+
+  const newlyDetached: DetachedLayer[] = orphans
+    .filter(hasContent)
+    .map((s) => ({ from: s.anchor, objects: s.objects, notes: s.notes }));
+
+  return {
+    deck: {
+      ...deck,
+      pageWidth: pages[0].width,
+      pageHeight: pages[0].height,
+      slides,
+      detached: [...deck.detached, ...newlyDetached],
+    },
+    moved,
+    added,
+    detached: newlyDetached.length,
+    unchanged: false,
+  };
+}
+
+/**
+ * Move a detached layer's objects back onto a slide, appending them on top.
+ *
+ * Re-attaching merges rather than replaces: the slide may have gained its own
+ * content since the layer came adrift, and silently overwriting it would be the
+ * same loss this module exists to prevent, just in the other direction.
+ */
+export function reattach(deck: Deck, detachedIndex: number, slideIndex: number): Deck {
+  const layer = deck.detached[detachedIndex];
+  if (!layer || slideIndex < 0 || slideIndex >= deck.slides.length) return deck;
+  return {
+    ...deck,
+    slides: deck.slides.map((s, i) =>
+      i === slideIndex
+        ? {
+            ...s,
+            objects: [...s.objects, ...layer.objects],
+            notes: [s.notes, layer.notes].filter((t) => t.trim()).join("\n\n"),
+          }
+        : s,
+    ),
+    detached: deck.detached.filter((_, i) => i !== detachedIndex),
+  };
+}
diff --git a/src/lib/viewers/deck/snap.ts b/src/lib/viewers/deck/snap.ts
new file mode 100644
index 0000000..ca7ad59
--- /dev/null
+++ b/src/lib/viewers/deck/snap.ts
@@ -0,0 +1,325 @@
+/**
+ * Snapping and alignment guides for the deck stage — pure, so the stage only has
+ * to paint what it is told (`docs/deck_presenter_plan.md` §4).
+ *
+ * Two things about this module are load-bearing.
+ *
+ * **The threshold is per-axis.** Everything in a deck is normalized to the page
+ * box, but a 16:9 page is not square — so one normalized unit is a different
+ * number of screen pixels horizontally and vertically. A single scalar threshold
+ * would make vertical snapping roughly twice as grabby as horizontal on a
+ * widescreen deck, which reads as "the snapping is broken" long before anyone
+ * works out why. Callers convert their pixel threshold once, per axis.
+ *
+ * **A guide is evidence, not decoration.** Every returned {@link Guide} is a line
+ * the result actually snapped to, carrying the span it should be drawn over. If
+ * the stage paints them faithfully, a snap that fires for the wrong reason is
+ * visible immediately rather than being felt as vague misbehaviour — which is the
+ * only practical defence against the sign errors this module is prone to.
+ */
+
+import type { Box } from "./model";
+
+/** A line to paint, plus why it exists. */
+export interface Guide {
+  /** `"x"` = a vertical line at `at`; `"y"` = a horizontal one. */
+  axis: "x" | "y";
+  /** Normalized position of the line along `axis`. */
+  at: number;
+  /** The span to draw, along the *other* axis. */
+  from: number;
+  to: number;
+  kind: "page" | "margin" | "object" | "spacing" | "size";
+}
+
+/** Per-axis snap radius, in normalized page units. */
+export interface Threshold {
+  x: number;
+  y: number;
+}
+
+export interface SnapContext {
+  /** Boxes to snap against. The caller excludes the selection itself. */
+  others: readonly Box[];
+  /** Safe-area inset as a fraction of the page. `0` disables margin targets. */
+  margin: number;
+  threshold: Threshold;
+  /** `false` while Alt is held — snapping suspended, guides empty. */
+  enabled: boolean;
+}
+
+/** Smallest box a resize may produce, so a handle can never invert or vanish. */
+export const MIN_SIZE = 0.01;
+
+interface Candidate {
+  /** Where the moving anchor should end up. */
+  at: number;
+  kind: Guide["kind"];
+}
+
+/** Targets along one axis: page edges/center, margins, and every other box's
+ *  near edge, center and far edge. */
+function axisTargets(
+  others: readonly Box[],
+  margin: number,
+  axis: "x" | "y",
+): Candidate[] {
+  const out: Candidate[] = [
+    { at: 0, kind: "page" },
+    { at: 0.5, kind: "page" },
+    { at: 1, kind: "page" },
+  ];
+  if (margin > 0) {
+    out.push({ at: margin, kind: "margin" }, { at: 1 - margin, kind: "margin" });
+  }
+  for (const o of others) {
+    const lo = axis === "x" ? o.x : o.y;
+    const len = axis === "x" ? o.w : o.h;
+    out.push(
+      { at: lo, kind: "object" },
+      { at: lo + len / 2, kind: "object" },
+      { at: lo + len, kind: "object" },
+    );
+  }
+  return out;
+}
+
+/**
+ * Equal-spacing targets: positions where the moving box would sit at the same
+ * distance from a neighbour as some existing pair of boxes already are from each
+ * other. This is distribute-by-drag, and it is the one snapping behaviour people
+ * miss most when it is absent.
+ *
+ * `movingLen` is needed because placing the box to the *left* of a neighbour
+ * positions its far edge, not its near one.
+ */
+function spacingTargets(
+  others: readonly Box[],
+  axis: "x" | "y",
+  movingLen: number,
+): Candidate[] {
+  const lo = (o: Box) => (axis === "x" ? o.x : o.y);
+  const len = (o: Box) => (axis === "x" ? o.w : o.h);
+  const sorted = [...others].sort((a, b) => lo(a) - lo(b));
+
+  const gaps = new Set<number>();
+  for (let i = 1; i < sorted.length; i += 1) {
+    const gap = lo(sorted[i]) - (lo(sorted[i - 1]) + len(sorted[i - 1]));
+    // A negative gap means the two overlap; there is no spacing to match.
+    if (gap > 0) gaps.add(round(gap));
+  }
+  if (gaps.size === 0) return [];
+
+  const out: Candidate[] = [];
+  for (const o of sorted) {
+    for (const gap of gaps) {
+      out.push({ at: lo(o) + len(o) + gap, kind: "spacing" });
+      out.push({ at: lo(o) - gap - movingLen, kind: "spacing" });
+    }
+  }
+  return out;
+}
+
+/** Kill float noise so `0.1 + 0.2` and `0.3` are one gap, not two. */
+function round(n: number): number {
+  return Math.round(n * 1e6) / 1e6;
+}
+
+/**
+ * Best delta to apply along one axis.
+ *
+ * `anchors` are the moving box's own snap points on this axis (near edge, center,
+ * far edge). The winner is the smallest correction across every (anchor, target)
+ * pair — not the nearest *target*, which would let a far edge 1 px away lose to a
+ * near edge 3 px away simply because the latter's target sorted first.
+ */
+function bestDelta(
+  anchors: readonly number[],
+  targets: readonly Candidate[],
+  threshold: number,
+): { delta: number; at: number; kind: Guide["kind"] } | null {
+  let best: { delta: number; at: number; kind: Guide["kind"] } | null = null;
+  for (const a of anchors) {
+    for (const t of targets) {
+      const delta = t.at - a;
+      if (Math.abs(delta) > threshold) continue;
+      if (!best || Math.abs(delta) < Math.abs(best.delta)) {
+        best = { delta, at: t.at, kind: t.kind };
+      }
+    }
+  }
+  return best;
+}
+
+/** The span a guide should be drawn over: from the moving box out to whatever it
+ *  aligned with, so the line visibly connects the two. */
+function guideSpan(
+  moving: Box,
+  others: readonly Box[],
+  axis: "x" | "y",
+  at: number,
+): { from: number; to: number } {
+  // Along the OTHER axis.
+  const lo = (b: Box) => (axis === "x" ? b.y : b.x);
+  const hi = (b: Box) => (axis === "x" ? b.y + b.h : b.x + b.w);
+  let from = lo(moving);
+  let to = hi(moving);
+  for (const o of others) {
+    const oLo = axis === "x" ? o.x : o.y;
+    const oLen = axis === "x" ? o.w : o.h;
+    const touches =
+      near(oLo, at) || near(oLo + oLen / 2, at) || near(oLo + oLen, at);
+    if (!touches) continue;
+    from = Math.min(from, lo(o));
+    to = Math.max(to, hi(o));
+  }
+  return { from, to };
+}
+
+const near = (a: number, b: number): boolean => Math.abs(a - b) < 1e-6;
+
+export interface SnapResult {
+  x: number;
+  y: number;
+  guides: Guide[];
+}
+
+/**
+ * Snap a dragged box's position. `box` is where the pointer would put it; the
+ * result is where it should actually go.
+ */
+export function snapMove(box: Box, ctx: SnapContext): SnapResult {
+  if (!ctx.enabled) return { x: box.x, y: box.y, guides: [] };
+
+  const guides: Guide[] = [];
+
+  const xTargets = [
+    ...axisTargets(ctx.others, ctx.margin, "x"),
+    ...spacingTargets(ctx.others, "x", box.w),
+  ];
+  const yTargets = [
+    ...axisTargets(ctx.others, ctx.margin, "y"),
+    ...spacingTargets(ctx.others, "y", box.h),
+  ];
+
+  const bx = bestDelta([box.x, box.x + box.w / 2, box.x + box.w], xTargets, ctx.threshold.x);
+  const by = bestDelta([box.y, box.y + box.h / 2, box.y + box.h], yTargets, ctx.threshold.y);
+
+  const x = box.x + (bx?.delta ?? 0);
+  const y = box.y + (by?.delta ?? 0);
+  const snapped: Box = { ...box, x, y };
+
+  if (bx) {
+    guides.push({ axis: "x", at: bx.at, kind: bx.kind, ...guideSpan(snapped, ctx.others, "x", bx.at) });
+  }
+  if (by) {
+    guides.push({ axis: "y", at: by.at, kind: by.kind, ...guideSpan(snapped, ctx.others, "y", by.at) });
+  }
+  return { x, y, guides };
+}
+
+/** Which handle is being dragged. */
+export type ResizeHandle = "nw" | "n" | "ne" | "e" | "se" | "s" | "sw" | "w";
+
+export interface ResizeResult {
+  box: Box;
+  guides: Guide[];
+}
+
+/**
+ * Snap a resize. Only the edges the handle actually moves are snapped — dragging
+ * the east handle must never shift the west edge, however close a guide is.
+ *
+ * Beyond the ordinary edge targets this adds **same-size** snapping: matching
+ * another object's exact width or height. Two boxes that are *nearly* the same
+ * size read as a mistake, and nothing else in the UI makes them agree.
+ */
+export function snapResize(
+  box: Box,
+  handle: ResizeHandle,
+  ctx: SnapContext,
+): ResizeResult {
+  const clamp = (b: Box): Box => ({
+    x: b.x,
+    y: b.y,
+    w: Math.max(MIN_SIZE, b.w),
+    h: Math.max(MIN_SIZE, b.h),
+  });
+
+  if (!ctx.enabled) return { box: clamp(box), guides: [] };
+
+  const movesW = handle.includes("w");
+  const movesE = handle.includes("e");
+  const movesN = handle.includes("n");
+  const movesS = handle.includes("s");
+
+  const guides: Guide[] = [];
+  let { x, y, w, h } = box;
+
+  const xTargets = axisTargets(ctx.others, ctx.margin, "x");
+  const yTargets = axisTargets(ctx.others, ctx.margin, "y");
+
+  // Same-size candidates are expressed as a target for the moving edge, so they
+  // flow through the same comparison as every other candidate and cannot win by
+  // a different rule.
+  const sizeX: Candidate[] = ctx.others.map((o) =>
+    movesE ? { at: x + o.w, kind: "size" as const } : { at: x + w - o.w, kind: "size" as const },
+  );
+  const sizeY: Candidate[] = ctx.others.map((o) =>
+    movesS ? { at: y + o.h, kind: "size" as const } : { at: y + h - o.h, kind: "size" as const },
+  );
+
+  if (movesW) {
+    const b = bestDelta([x], [...xTargets, ...sizeX], ctx.threshold.x);
+    if (b) {
+      const right = x + w;
+      x = b.at;
+      w = right - x;
+      guides.push({ axis: "x", at: b.at, kind: b.kind, ...guideSpan(box, ctx.others, "x", b.at) });
+    }
+  }
+  if (movesE) {
+    const b = bestDelta([x + w], [...xTargets, ...sizeX], ctx.threshold.x);
+    if (b) {
+      w = b.at - x;
+      guides.push({ axis: "x", at: b.at, kind: b.kind, ...guideSpan(box, ctx.others, "x", b.at) });
+    }
+  }
+  if (movesN) {
+    const b = bestDelta([y], [...yTargets, ...sizeY], ctx.threshold.y);
+    if (b) {
+      const bottom = y + h;
+      y = b.at;
+      h = bottom - y;
+      guides.push({ axis: "y", at: b.at, kind: b.kind, ...guideSpan(box, ctx.others, "y", b.at) });
+    }
+  }
+  if (movesS) {
+    const b = bestDelta([y + h], [...yTargets, ...sizeY], ctx.threshold.y);
+    if (b) {
+      h = b.at - y;
+      guides.push({ axis: "y", at: b.at, kind: b.kind, ...guideSpan(box, ctx.others, "y", b.at) });
+    }
+  }
+
+  return { box: clamp({ x, y, w, h }), guides };
+}
+
+/**
+ * Constrain a drag to one axis (Shift). Applied to the *raw* delta before
+ * snapping, so the locked axis cannot be reintroduced by a snap on the other one.
+ */
+export function axisLock(dx: number, dy: number): { dx: number; dy: number } {
+  return Math.abs(dx) >= Math.abs(dy) ? { dx, dy: 0 } : { dx: 0, dy };
+}
+
+/**
+ * Convert a pixel snap radius into normalized per-axis thresholds.
+ * `pageW`/`pageH` are the page's rendered size in CSS px.
+ */
+export function thresholdFor(px: number, pageW: number, pageH: number): Threshold {
+  return {
+    x: pageW > 0 ? px / pageW : 0,
+    y: pageH > 0 ? px / pageH : 0,
+  };
+}
diff --git a/src/lib/viewers/deck/template.ts b/src/lib/viewers/deck/template.ts
new file mode 100644
index 0000000..6c6b8b0
--- /dev/null
+++ b/src/lib/viewers/deck/template.ts
@@ -0,0 +1,137 @@
+/**
+ * Starter LaTeX for a new presentation.
+ *
+ * This is the "from blank" entry point: it exists so that **making a deck does
+ * not require knowing TeX**, while leaving a real `.tex` on disk for anyone who
+ * does. Eldrun never writes to it again — the deck's layers live in the sidecar —
+ * so the author owns the file from the moment it is created.
+ *
+ * Beamer is used because it is what an academic audience already has installed
+ * and already knows how to edit; nothing in Eldrun understands `\frame` or
+ * `\pause`, and nothing needs to. The one Eldrun-specific choice is `aspectratio=169`:
+ * the deck's normalized geometry adapts to any page box, but a 4:3 default in
+ * 2026 is a worse first impression than any layer editor can rescue.
+ */
+
+/**
+ * Escape the characters that break a LaTeX title or author field.
+ *
+ * **One pass, not a chain of `.replace()`s.** Chained replaces re-scan their own
+ * output: escaping `\` to `\textbackslash{}` and *then* escaping braces turns it
+ * into `\textbackslash\{\}`, which is a syntax error. A single regex with a
+ * lookup table cannot re-enter its own replacements.
+ */
+const TEX_ESCAPES: Readonly<Record<string, string>> = {
+  "\\": "\\textbackslash{}",
+  "&": "\\&",
+  "%": "\\%",
+  $: "\\$",
+  "#": "\\#",
+  _: "\\_",
+  "{": "\\{",
+  "}": "\\}",
+  "~": "\\textasciitilde{}",
+  "^": "\\textasciicircum{}",
+};
+
+export function texEscape(s: string): string {
+  return s.replace(/[\\&%$#_{}~^]/g, (c) => TEX_ESCAPES[c] ?? c);
+}
+
+export interface TemplateOptions {
+  title: string;
+  author?: string;
+  /** A first section, so the deck opens with something to look at. */
+  section?: string;
+}
+
+/** A minimal, compilable Beamer deck: title frame, outline, one content frame. */
+export function starterTex({ title, author, section }: TemplateOptions): string {
+  const sec = section?.trim() || "Introduction";
+  return `% Created by Eldrun as the base for a presentation.
+%
+% This file is yours: Eldrun compiles it to a PDF and lays its own editable
+% layers on top, in the .eldeck.json sidecar beside it. It never writes back to
+% this file, so edit it freely — recompiling keeps the layers, which re-anchor to
+% the slides they were placed on.
+
+\\documentclass[aspectratio=169]{beamer}
+
+\\usepackage[utf8]{inputenc}
+\\usepackage[T1]{fontenc}
+\\usepackage{graphicx}
+
+\\title{${texEscape(title)}}
+${author ? `\\author{${texEscape(author)}}` : "% \\author{Your name}"}
+\\date{\\today}
+
+\\begin{document}
+
+\\begin{frame}
+  \\titlepage
+\\end{frame}
+
+\\section{${texEscape(sec)}}
+
+\\begin{frame}{${texEscape(sec)}}
+  \\begin{itemize}
+    \\item First point
+    \\item Second point
+    \\item Third point
+  \\end{itemize}
+\\end{frame}
+
+\\begin{frame}{Results}
+  % A frame left deliberately empty: drop a figure, a table or Eldrun layers here.
+\\end{frame}
+
+\\end{document}
+`;
+}
+
+/**
+ * A blank, ready-to-compile TeX source for a single **figure** placed on a
+ * slide (the deck toolbar's TeX FAB) — as opposed to {@link starterTex}, which
+ * generates the whole deck's base plate.
+ *
+ * `standalone` crops the compiled PDF to its content's bounding box, which is
+ * exactly what belongs on a slide as an image: no page furniture, no margins to
+ * fight. TikZ and amsmath are preloaded since a formula or a diagram are the two
+ * things this FAB exists for.
+ */
+export function starterTexFigure(): string {
+  return `% A figure for one slide, compiled to a PDF and placed as an image.
+%
+% Eldrun rasterizes the compiled PDF's first page onto the slide and updates it
+% every time you recompile here — nothing to do on the deck's side but wait for
+% the change to appear. This file is yours; edit and compile it like any other.
+
+\\documentclass[border=4pt]{standalone}
+
+\\usepackage[utf8]{inputenc}
+\\usepackage{amsmath,amssymb}
+\\usepackage{tikz}
+
+\\begin{document}
+
+% Replace this with a formula, a TikZ picture, a table — anything standalone
+% can crop to its own size.
+$$E = mc^2$$
+
+\\end{document}
+`;
+}
+
+/** `talk.eldeck.json` → a sensible presentation title. */
+export function titleFromPath(deckOrPdfPath: string): string {
+  const base = deckOrPdfPath.split(/[\\/]/).pop() ?? "Presentation";
+  const stem = base.replace(/\.(eldeck\.json|tex|pdf)$/i, "");
+  // `my-great-talk` / `my_great_talk` → `My great talk`.
+  const words = stem.replace(/[-_]+/g, " ").trim();
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : "Presentation";
+}
+
+/** The `.tex` a deck's base plate is generated from. */
+export function texPathForDeck(deckPath: string): string {
+  return `${deckPath.replace(/\.eldeck\.json$/i, "")}.tex`;
+}
diff --git a/src/lib/viewers/deck/transform.ts b/src/lib/viewers/deck/transform.ts
new file mode 100644
index 0000000..38a8918
--- /dev/null
+++ b/src/lib/viewers/deck/transform.ts
@@ -0,0 +1,125 @@
+/**
+ * The one place the deck's coordinates become PDF coordinates.
+ *
+ * Everything in a deck is **normalized, y-down, measured from the page's top-left**
+ * — the same frame the browser and pdf.js use. A PDF is **absolute points, y-up,
+ * measured from the bottom-left**. Nothing in this repo did that flip before (the
+ * PDF viewer works entirely in pdf.js's already-flipped viewport space), so it is
+ * written here once, isolated and unit-tested, rather than inline in the exporter
+ * where a sign error would be invisible.
+ *
+ * Rotation is the subtle half. `DeckObject.rot` is degrees **clockwise as seen on
+ * the slide**; PDF's positive rotation is **counter-clockwise**, so the exported
+ * angle is negated. And pdf-lib rotates a drawing about the anchor point it is
+ * given, not about the object's centre — so to spin an object in place, the
+ * anchor must be moved to wherever the object's origin *lands* after the
+ * rotation. {@link pdfPlacement} does both.
+ */
+
+/** A deck object's box, normalized to the page (0..1, y-down from top-left). */
+export interface NormRect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+/** A box in PDF points, y-up from the bottom-left. */
+export interface PdfRect {
+  /** Left edge. */
+  x: number;
+  /** **Bottom** edge — the PDF origin corner. */
+  y: number;
+  w: number;
+  h: number;
+  /** Top edge, i.e. `y + h`. The anchor a y-down drawing starts from. */
+  top: number;
+}
+
+/** Normalized, y-down → absolute points, y-up. */
+export function toPdfRect(r: NormRect, pageW: number, pageH: number): PdfRect {
+  const w = r.w * pageW;
+  const h = r.h * pageH;
+  const x = r.x * pageW;
+  // The flip. `r.y` measures down from the top, so the box's TOP edge is at
+  // `pageH - r.y*pageH`, and its bottom is one height further down.
+  const top = pageH - r.y * pageH;
+  return { x, y: top - h, w, h, top };
+}
+
+export interface Placement {
+  /** Anchor to hand pdf-lib, in PDF points. */
+  x: number;
+  y: number;
+  /** Rotation to hand pdf-lib, in degrees (counter-clockwise positive). */
+  rotate: number;
+}
+
+/**
+ * Where to anchor a **y-down** drawing (an SVG path, a line of text, an image)
+ * so that it lands rotated about the object's own centre.
+ *
+ * `originX`/`originY` are the drawing's start point *within* the object's box, in
+ * points, measured y-down from the box's top-left — `(0, 0)` for a path or an
+ * image, and `(indent, baselineOffset)` for a line of text.
+ */
+export function pdfPlacement(
+  rect: PdfRect,
+  rotDeg: number,
+  originX = 0,
+  originY = 0,
+): Placement {
+  // The drawing's start point, unrotated, in PDF space.
+  const px = rect.x + originX;
+  const py = rect.top - originY;
+
+  // PDF rotation is counter-clockwise; the deck's is clockwise on screen.
+  const rotate = -rotDeg;
+  if (rotDeg === 0) return { x: px, y: py, rotate: 0 };
+
+  const cx = rect.x + rect.w / 2;
+  const cy = rect.y + rect.h / 2;
+  const rad = (rotate * Math.PI) / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const dx = px - cx;
+  const dy = py - cy;
+  return {
+    x: cx + dx * cos - dy * sin,
+    y: cy + dx * sin + dy * cos,
+    rotate,
+  };
+}
+
+/** `#rgb` / `#rrggbb` / `#rrggbbaa` → components in 0..1, plus alpha. */
+export function parseColor(
+  hex: string | undefined,
+): { r: number; g: number; b: number; a: number } | null {
+  if (!hex) return null;
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(hex.trim());
+  if (!m) return null;
+  let s = m[1];
+  if (s.length === 3) s = s.split("").map((c) => c + c).join("");
+  const r = parseInt(s.slice(0, 2), 16) / 255;
+  const g = parseInt(s.slice(2, 4), 16) / 255;
+  const b = parseInt(s.slice(4, 6), 16) / 255;
+  const a = s.length === 8 ? parseInt(s.slice(6, 8), 16) / 255 : 1;
+  return { r, g, b, a };
+}
+
+/**
+ * The scale and offset that fit a square `unit`-sized glyph box into `rect`,
+ * centred — the `preserveAspectRatio="xMidYMid meet"` the icon renderer uses,
+ * spelled out so the export places an icon exactly where the stage showed it.
+ */
+export function fitSquare(
+  rect: PdfRect,
+  unit: number,
+): { scale: number; offsetX: number; offsetY: number } {
+  const side = Math.min(rect.w, rect.h);
+  return {
+    scale: side / unit,
+    offsetX: (rect.w - side) / 2,
+    offsetY: (rect.h - side) / 2,
+  };
+}
diff --git a/src/lib/viewers/diff.ts b/src/lib/viewers/diff.ts
new file mode 100644
index 0000000..de907a4
--- /dev/null
+++ b/src/lib/viewers/diff.ts
@@ -0,0 +1,164 @@
+/**
+ * Pure unified-diff parser for the in-app diff viewer (Dev 3 / TODO Group K).
+ *
+ * Turns a unified diff string (the output of `git diff`, a `.diff`/`.patch`
+ * file, etc.) into structured files → hunks → lines, tracking running old/new
+ * line numbers so the viewer can render a two-column line-number gutter. The
+ * parser is deliberately tolerant: a bare diff with no `diff --git` header (just
+ * `---`/`+++`/`@@`) still parses into a single file, and multiple files /
+ * multiple hunks per file are handled.
+ *
+ * No DOM, no React — this is the unit-tested logic half of the viewer. All line
+ * text is preserved verbatim (the viewer is responsible for HTML-escaping it).
+ */
+
+export type DiffLineType = "context" | "add" | "del" | "hunk" | "meta" | "nonewline";
+
+export interface DiffLine {
+  type: DiffLineType;
+  /** The line's text, with any leading diff marker (`+`/`-`/space) stripped for
+   *  body lines, or the full text for meta/hunk/nonewline markers. */
+  text: string;
+  /** 1-based line number in the OLD file, or null (added / marker lines). */
+  oldNo: number | null;
+  /** 1-based line number in the NEW file, or null (deleted / marker lines). */
+  newNo: number | null;
+}
+
+export interface DiffHunk {
+  /** The raw `@@ -l,s +l,s @@` header (with any trailing section context). */
+  header: string;
+  lines: DiffLine[];
+}
+
+export interface DiffFile {
+  /** Old path with any `a/` prefix stripped; `/dev/null` for an added file. */
+  oldPath: string;
+  /** New path with any `b/` prefix stripped; `/dev/null` for a deleted file. */
+  newPath: string;
+  hunks: DiffHunk[];
+}
+
+/** Strip a leading `a/` or `b/` git prefix from a diff path. Leaves `/dev/null`
+ *  and bare paths untouched. */
+function stripPrefix(path: string): string {
+  if (path === "/dev/null") return path;
+  if (path.startsWith("a/") || path.startsWith("b/")) return path.slice(2);
+  return path;
+}
+
+/** Parse the path off a `--- ` / `+++ ` line: drop the marker, take up to the
+ *  first tab (git appends a timestamp after a tab), trim, strip the prefix. */
+function parsePathLine(line: string): string {
+  // line starts with "--- " or "+++ "
+  let rest = line.slice(4);
+  const tab = rest.indexOf("\t");
+  if (tab >= 0) rest = rest.slice(0, tab);
+  return stripPrefix(rest.trim());
+}
+
+/** Parse the starting line numbers out of a `@@ -oldStart,oldCount +newStart,newCount @@`
+ *  header. The counts are optional (`,n` may be omitted, meaning 1). Returns the
+ *  1-based old/new start lines, defaulting to 1 when unparseable. */
+function parseHunkStarts(header: string): { oldNo: number; newNo: number } {
+  const m = /@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(header);
+  if (!m) return { oldNo: 1, newNo: 1 };
+  return { oldNo: parseInt(m[1], 10), newNo: parseInt(m[2], 10) };
+}
+
+/**
+ * Parse a unified-diff string into a list of {@link DiffFile}. Robust to:
+ *  - `diff --git a/x b/x` headers starting a new file,
+ *  - `---`/`+++` path lines (sets old/new path, strips `a/`,`b/`, handles `/dev/null`),
+ *  - `@@ … @@` hunk headers (seeds running old/new line counters),
+ *  - body lines: `+` add (newNo advances), `-` del (oldNo advances),
+ *    ` ` context (both advance), `\ No newline at end of file` → a `nonewline` marker,
+ *  - a headerless diff (no `diff --git`) → a single file.
+ */
+export function parseUnifiedDiff(text: string): DiffFile[] {
+  const files: DiffFile[] = [];
+  let file: DiffFile | null = null;
+  let hunk: DiffHunk | null = null;
+  let oldNo = 0;
+  let newNo = 0;
+
+  const ensureFile = (): DiffFile => {
+    if (!file) {
+      file = { oldPath: "", newPath: "", hunks: [] };
+      files.push(file);
+    }
+    return file;
+  };
+
+  // Split on \n; tolerate \r\n by trimming a trailing \r from each line.
+  const lines = text.split("\n");
+  for (const raw of lines) {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+
+    if (line.startsWith("diff --git ")) {
+      // Start a brand-new file; subsequent ---/+++ fill in the paths.
+      file = { oldPath: "", newPath: "", hunks: [] };
+      files.push(file);
+      hunk = null;
+      continue;
+    }
+
+    if (line.startsWith("--- ")) {
+      ensureFile().oldPath = parsePathLine(line);
+      hunk = null;
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      ensureFile().newPath = parsePathLine(line);
+      hunk = null;
+      continue;
+    }
+
+    if (line.startsWith("@@")) {
+      const f = ensureFile();
+      hunk = { header: line, lines: [] };
+      f.hunks.push(hunk);
+      const starts = parseHunkStarts(line);
+      oldNo = starts.oldNo;
+      newNo = starts.newNo;
+      hunk.lines.push({ type: "hunk", text: line, oldNo: null, newNo: null });
+      continue;
+    }
+
+    // Body lines only count once we're inside a hunk; anything else (extended
+    // git headers like `index …`, `new file mode …`, etc.) is metadata.
+    if (!hunk) {
+      // Pre-hunk metadata. Attach to the current file as a meta line only when a
+      // file exists; otherwise ignore stray leading noise.
+      if (file) {
+        // Keep extended headers out of the rendered hunks (the viewer shows the
+        // file path itself); we simply skip them.
+      }
+      continue;
+    }
+
+    if (line.startsWith("\\")) {
+      // "\ No newline at end of file" marker — belongs to the preceding line.
+      hunk.lines.push({ type: "nonewline", text: line, oldNo: null, newNo: null });
+      continue;
+    }
+
+    const marker = line[0];
+    const body = line.slice(1);
+    if (marker === "+") {
+      hunk.lines.push({ type: "add", text: body, oldNo: null, newNo });
+      newNo++;
+    } else if (marker === "-") {
+      hunk.lines.push({ type: "del", text: body, oldNo, newNo: null });
+      oldNo++;
+    } else {
+      // A space-prefixed context line, or a bare empty line (some tools emit a
+      // truly empty context line rather than a single space).
+      hunk.lines.push({ type: "context", text: body, oldNo, newNo });
+      oldNo++;
+      newNo++;
+    }
+  }
+
+  return files;
+}
diff --git a/src/lib/viewers/fileUtils.ts b/src/lib/viewers/fileUtils.ts
index 699ec89..23e5deb 100644
--- a/src/lib/viewers/fileUtils.ts
+++ b/src/lib/viewers/fileUtils.ts
@@ -1,3 +1,5 @@
+import { relativePathWithin } from "../paths";
+
 export interface FileEntry {
   name: string;
   path: string;
@@ -20,6 +22,7 @@ export const STANDARD_PROJECT_FILES = new Set([
   "DOCUMENTATION.md",
   ".gitignore",
   ".claude",
+  ".git",
 ]);
 
 export const INTERNAL_PROJECT_FILES = new Set([
@@ -33,7 +36,49 @@ export type SortKey = "name" | "type" | "size" | "created" | "modified";
 
 /** Which built-in Eldrun viewer can render a file in-tab (drag from the right
  *  panel onto a tab bar). Independent of any external default app. */
-export type InternalViewer = "pdf" | "image" | "markdown" | "text" | "tex";
+export type InternalViewer =
+  | "pdf"
+  | "image"
+  | "markdown"
+  | "text"
+  | "tex"
+  | "table"
+  | "notebook"
+  | "diff"
+  // SSH-sync host-vs-mirror diff. Never auto-selected by extension — only opened
+  // explicitly from a diverged (amber) file's diff button; routed to `DiffView`
+  // in sync mode (backend `sync_diff`).
+  | "syncdiff"
+  // SSH-sync three-way merge (PyCharm-style): local mirror ⇄ editable result ⇄
+  // remote host, with per-block take-left/right. Never auto-selected — only
+  // opened from a diverged (amber) file in the orange list; routed to
+  // `SyncMergeView`. Apply resolves the divergence (writes mirror + force-push).
+  | "syncmerge"
+  | "odt"
+  | "media"
+  | "gif"
+  | "html"
+  | "sqlite"
+  | "yaml"
+  // The native presenter's deck sidecar (`*.eldeck.json`, EXPERIMENTAL — see
+  // `docs/deck_presenter_plan.md`). A deck is JSON, so this must be matched by
+  // FILENAME before the generic `.json` rule; see `naturalViewerFor`.
+  | "eldeck";
+
+// Audio/video formats the webview plays natively via <audio>/<video> from a
+// Blob URL (Dev D). Kept separate from IMAGE_EXTS so the media viewer wins.
+const MEDIA_EXTS = new Set([
+  ".mp3", ".wav", ".ogg", ".oga", ".flac", ".m4a", ".aac", ".opus",
+  ".mp4", ".webm", ".mov", ".mkv", ".m4v", ".ogv",
+]);
+
+// SQLite database files → the table-browser viewer (Dev C). These are binary, so
+// they are deliberately NOT in TEXT_EXTS; the viewer reads them via the backend.
+const SQLITE_EXTS = new Set([".db", ".sqlite", ".sqlite3"]);
+
+// Spreadsheet workbooks the table viewer renders via the calamine backend (Dev
+// G). Binary, so not in TEXT_EXTS.
+const SPREADSHEET_EXTS = new Set([".xlsx", ".xls", ".xlsm"]);
 
 const MARKDOWN_EXTS = new Set([".md", ".markdown", ".mdown", ".mkd", ".mdx"]);
 
@@ -75,10 +120,58 @@ const TEXT_FILENAMES = new Set([
  * dragged onto a tab bar regardless of (and independent of) whatever external
  * app is the system default — see TODO Group K #40.
  */
-export function internalViewerFor(entry: FileEntry): InternalViewer | null {
+export function internalViewerFor(
+  entry: FileEntry,
+  disabled?: ReadonlySet<InternalViewer>,
+): InternalViewer | null {
+  const viewer = naturalViewerFor(entry);
+  // When the user has opted this type out (#48), return null so the file falls
+  // through to the external-app path (commitFileDrop routes it via embedExec) —
+  // unless the type has a native fallback that is itself still enabled. YAML is
+  // the case: turning off its tree is a vote against the *tree*, not against
+  // editing YAML in Eldrun at all, so it drops back to the plain code editor
+  // (which is where .yaml opened before the tree existed).
+  if (viewer && disabled?.has(viewer)) {
+    const fallback = VIEWER_FALLBACK[viewer];
+    return fallback && !disabled.has(fallback) ? fallback : null;
+  }
+  return viewer;
+}
+
+/** Where a type lands when its own viewer is opted out (#48), before the
+ *  external-app path. Only for types whose bytes another native viewer can still
+ *  render honestly. */
+const VIEWER_FALLBACK: Partial<Record<InternalViewer, InternalViewer>> = {
+  yaml: "text",
+  // Opting out the GIF transport UI is not a vote against viewing GIFs in-app:
+  // the plain image viewer still animates them honestly (the webview animates
+  // <img> GIFs natively) — it just offers no frame control.
+  gif: "image",
+  // A deck IS JSON, so opting the presenter out should leave you editing the
+  // sidecar by hand in the tree rather than handing a `.json` to an external app.
+  eldeck: "yaml",
+};
+
+/** A presentation deck sidecar: `<name>.eldeck.json`, case-insensitive. Exported
+ *  so the deck viewer and its "new presentation" flow name the file exactly one
+ *  way. `.eldeck.json` alone (an empty stem) is deliberately NOT a deck. */
+export const DECK_SUFFIX = ".eldeck.json";
+const DECK_SUFFIX_RE = /.+\.eldeck\.json$/i;
+
+/** Whether `name` (or a path ending in one) is a deck sidecar. */
+export function isDeckFile(name: string): boolean {
+  return DECK_SUFFIX_RE.test(name);
+}
+
+/** The viewer a file *type* maps to, ignoring any user opt-out. */
+function naturalViewerFor(entry: FileEntry): InternalViewer | null {
   if (entry.is_dir) return null;
   const ext = (entry.extension ?? "").toLowerCase();
   if (ext === ".pdf") return "pdf";
+  // .gif gets the dedicated animated-GIF viewer (frame transport: pause, step,
+  // scrub — #gifviewer). It is also in IMAGE_EXTS, so this early return must
+  // win — exactly like .tex/.csv below.
+  if (ext === ".gif") return "gif";
   if (IMAGE_EXTS.has(ext)) return "image";
   if (MARKDOWN_EXTS.has(ext)) return "markdown";
   // .tex gets the dedicated LaTeX viewer (compile to a PDF tab when a TeX engine
@@ -86,17 +179,73 @@ export function internalViewerFor(entry: FileEntry): InternalViewer | null {
   // plain text via the generic TEXT_EXTS check below. This early return must win
   // even though .tex is also in TEXT_EXTS.
   if (ext === ".tex") return "tex";
+  // .csv/.tsv get the table viewer, .ipynb the notebook viewer, .diff/.patch the
+  // diff viewer. .csv/.tsv/.diff/.patch are also in TEXT_EXTS, so these specific
+  // returns must win — exactly like .tex above. .ipynb is intentionally NOT in
+  // TEXT_EXTS so that, when the notebook viewer is opted out (#48), it opens
+  // externally rather than as raw JSON.
+  if (ext === ".csv" || ext === ".tsv") return "table";
+  if (ext === ".ipynb") return "notebook";
+  if (ext === ".diff" || ext === ".patch") return "diff";
+  // .odt gets the lightweight OpenDocument Text viewer: it unzips the archive and
+  // renders content.xml to a readable HTML subset (headings/lists/tables/images).
+  // The faithful path stays "Open externally"; opting the viewer out (#48) routes
+  // it there. The remaining office/spreadsheet formats are still deferred below.
+  if (ext === ".odt") return "odt";
+  // Audio/video → the native media player (Dev D).
+  if (MEDIA_EXTS.has(ext)) return "media";
+  // SQLite databases → the table-browser viewer (Dev C).
+  if (SQLITE_EXTS.has(ext)) return "sqlite";
+  // Spreadsheets → the CSV/TSV table viewer, which loads them via the backend
+  // (Dev G). Retires the .xlsx part of the deferred #51 office gap.
+  if (SPREADSHEET_EXTS.has(ext)) return "table";
+  // .html/.htm/.svg get the rendered-preview viewer with a Preview/Source toggle
+  // (Dev E). These are also in TEXT_EXTS, so this specific return must win — like
+  // .tex above. Opting it out (#48) falls back to the plain text editor.
+  if (ext === ".html" || ext === ".htm" || ext === ".svg") return "html";
+  // .yaml/.yml/.json get the structured tree editor with a Tree/Source toggle
+  // (#yaml). JSON is YAML's flow syntax — the same tree renders it, written back
+  // in the stricter dialect — so the two share a viewer rather than duplicating
+  // one. All three are also in TEXT_EXTS, so this specific return must win, like
+  // .tex above. Opting it out (#48) falls back to the plain code editor, not the
+  // external app (see VIEWER_FALLBACK).
+  // A presentation deck (`talk.eldeck.json`) is matched on the FILENAME, not the
+  // extension, and must win over the `.json` rule below. `entry.extension` is only
+  // the last dotted component — the backend builds it with `Path::extension()` —
+  // so a deck arrives here claiming to be a plain `.json` and would otherwise open
+  // as a YAML tree. Opting the viewer out lands it there deliberately instead (see
+  // VIEWER_FALLBACK); the experimental gate is applied at the dispatch site, not
+  // here, so a deck still resolves to a viewer for drag-to-tab either way.
+  if (DECK_SUFFIX_RE.test(entry.name)) return "eldeck";
+  if (ext === ".yaml" || ext === ".yml" || ext === ".json") return "yaml";
   if (ext && TEXT_EXTS.has(ext)) return "text";
   if (!ext && TEXT_FILENAMES.has(entry.name.toLowerCase())) return "text";
-  // DEFERRED (#51, DECISION B): OpenDocument / spreadsheet formats (.odt/.xlsx,
-  // and the sibling office formats) do NOT get a native in-app renderer for now.
-  // Rendering them faithfully needs a heavy dependency (e.g. calamine + a table
-  // renderer) that isn't worth it yet, so we return null here and let them fall
-  // through to the existing external-app path (the "Open externally" affordance).
-  // Revisit if/when a lightweight Tauri-side renderer becomes available.
+  // DEFERRED (#51, DECISION B): the remaining OpenDocument / spreadsheet formats
+  // (.ods/.xlsx/.docx and siblings) do NOT get a native in-app renderer yet —
+  // faithful rendering needs a heavy dependency (e.g. calamine + a table/layout
+  // renderer). We return null and let them fall through to the external-app path
+  // (the "Open externally" affordance). Revisit per-format as lightweight
+  // renderers land (.odt already has one above).
   return null;
 }
 
+/**
+ * The set of native viewers the user has opted out of (#48), derived from
+ * `settings.viewer_prefs[id].enabled === false`. Absent/true means enabled, so
+ * an empty/missing prefs map yields an empty set (all viewers on). Pass the
+ * result to `internalViewerFor` at file-open sites to honour the opt-out.
+ */
+export function disabledViewers(
+  viewerPrefs?: Record<string, { enabled?: boolean }>,
+): Set<InternalViewer> {
+  const out = new Set<InternalViewer>();
+  if (!viewerPrefs) return out;
+  for (const t of VIEWER_PREF_TYPES) {
+    if (viewerPrefs[t.id]?.enabled === false) out.add(t.id);
+  }
+  return out;
+}
+
 /**
  * Office/spreadsheet formats whose in-app rendering is deferred (#51): they have
  * no native viewer and open in the external app. Exported so the file tree / drop
@@ -104,7 +253,7 @@ export function internalViewerFor(entry: FileEntry): InternalViewer | null {
  * viewer" binaries.
  */
 export const DEFERRED_OFFICE_EXTS = new Set([
-  ".odt", ".ods", ".odp", ".xlsx", ".xls", ".docx", ".doc", ".pptx", ".ppt",
+  ".ods", ".odp", ".docx", ".doc", ".pptx", ".ppt",
 ]);
 
 /** True when a file is a deferred office/spreadsheet type (#51). */
@@ -132,7 +281,7 @@ export const VIEWER_PREF_TYPES: ViewerTypeMeta[] = [
   {
     id: "text",
     label: "Text / code",
-    extensions: [".txt", ".json", ".py", ".rs", ".ts", ".svg", ".bib", "…"],
+    extensions: [".txt", ".toml", ".py", ".rs", ".ts", ".svg", ".bib", "…"],
     autocomplete: true,
   },
   {
@@ -147,13 +296,73 @@ export const VIEWER_PREF_TYPES: ViewerTypeMeta[] = [
     extensions: [".md", ".markdown", ".mdx"],
     autocomplete: true,
   },
+  {
+    id: "yaml",
+    label: "YAML / JSON tree",
+    extensions: [".yaml", ".yml", ".json"],
+    autocomplete: true,
+  },
   {
     id: "image",
     label: "Images",
-    extensions: [".png", ".jpg", ".gif", ".webp", "…"],
+    extensions: [".png", ".jpg", ".bmp", ".webp", "…"],
+    autocomplete: false,
+  },
+  {
+    id: "gif",
+    label: "Animated GIF",
+    extensions: [".gif"],
     autocomplete: false,
   },
   { id: "pdf", label: "PDF", extensions: [".pdf"], autocomplete: false },
+  {
+    id: "table",
+    label: "Table / spreadsheet",
+    extensions: [".csv", ".tsv", ".xlsx", ".xls"],
+    autocomplete: false,
+  },
+  {
+    id: "notebook",
+    label: "Jupyter notebook",
+    extensions: [".ipynb"],
+    autocomplete: false,
+  },
+  {
+    id: "diff",
+    label: "Diff / patch",
+    extensions: [".diff", ".patch"],
+    autocomplete: false,
+  },
+  {
+    id: "odt",
+    label: "OpenDocument Text",
+    extensions: [".odt"],
+    autocomplete: false,
+  },
+  {
+    id: "media",
+    label: "Audio / video",
+    extensions: [".mp3", ".mp4", ".webm", ".wav", "…"],
+    autocomplete: false,
+  },
+  {
+    id: "html",
+    label: "HTML / SVG preview",
+    extensions: [".html", ".htm", ".svg"],
+    autocomplete: false,
+  },
+  {
+    id: "sqlite",
+    label: "SQLite database",
+    extensions: [".db", ".sqlite", ".sqlite3"],
+    autocomplete: false,
+  },
+  {
+    id: "eldeck",
+    label: "Presentation (deck)",
+    extensions: [".eldeck.json"],
+    autocomplete: false,
+  },
 ];
 
 export function joinRel(base: string, name: string): string {
@@ -167,10 +376,48 @@ export function parentRel(path: string): string {
 }
 
 export function relFromAbs(projectDir: string, absPath: string): string {
-  const root = projectDir.replace(/\/+$/, "");
-  if (absPath === root) return "";
-  if (!absPath.startsWith(`${root}/`)) return "";
-  return absPath.slice(root.length + 1);
+  return relativePathWithin(projectDir, absPath) ?? "";
+}
+
+// ── File-tree multi-selection (pure logic, unit-tested) ──────────────────────
+// Selection is a set of entry *absolute paths*; `ordered` is the flat list of
+// visible rows in on-screen order (regular, then scaffold, then gitignored),
+// which is what a shift-range spans.
+
+/** The contiguous slice of `ordered` between `anchor` and `target` (inclusive),
+ *  order-independent. If either endpoint isn't in `ordered`, falls back to just
+ *  `target`. */
+export function rangeSelect(ordered: string[], anchor: string, target: string): string[] {
+  const a = ordered.indexOf(anchor);
+  const b = ordered.indexOf(target);
+  if (a === -1 || b === -1) return [target];
+  const [lo, hi] = a <= b ? [a, b] : [b, a];
+  return ordered.slice(lo, hi + 1);
+}
+
+/** Next selection + anchor after a click on `path`, given the current selection,
+ *  the visible order, and the modifier keys:
+ *   - shift (with an anchor)  → replace with the anchor→path range.
+ *   - toggle (ctrl/cmd)       → flip `path`; anchor becomes `path`.
+ *   - plain                   → select only `path`; anchor becomes `path`.
+ *  Shift without a prior anchor behaves like a plain click. */
+export function nextSelection(
+  cur: ReadonlySet<string>,
+  ordered: string[],
+  anchor: string | null,
+  path: string,
+  mods: { shift: boolean; toggle: boolean },
+): { selected: Set<string>; anchor: string } {
+  if (mods.shift && anchor) {
+    return { selected: new Set(rangeSelect(ordered, anchor, path)), anchor };
+  }
+  if (mods.toggle) {
+    const selected = new Set(cur);
+    if (selected.has(path)) selected.delete(path);
+    else selected.add(path);
+    return { selected, anchor: path };
+  }
+  return { selected: new Set([path]), anchor: path };
 }
 
 export function visibleEntries(
@@ -225,51 +472,6 @@ export function visibleEntries(
     .sort((a, b) => compareEntries(a, b, sortKey, descending));
 }
 
-/**
- * Dotfiles that `visibleEntries` filters out of the inline tree (the `showHidden`
- * step), surfaced so the panel can gather them into a collapsed "hidden" section.
- *
- * Returns the entries hidden *solely* by the dotfile rule — items removed by the
- * other filters (internal, hiddenEndings, hiddenPaths) stay fully hidden, and
- * `.gitignore`, scaffold/standard files, and explicitly-shown paths are excluded
- * because they already render inline or in the scaffold section. When
- * `showHidden` is on, dotfiles appear inline already, so the bucket is empty.
- */
-export function hiddenEntries(
-  entries: FileEntry[],
-  options: {
-    showHidden: boolean;
-    sortKey?: SortKey;
-    descending?: boolean;
-    hiddenEndings?: string[];
-    relPath?: string;
-    hiddenPaths?: string[];
-    shownPaths?: string[];
-  },
-): FileEntry[] {
-  if (options.showHidden) return [];
-  const sortKey = options.sortKey ?? "name";
-  const descending = options.descending ?? false;
-  const relPath = (options.relPath ?? "").replace(/^\/+|\/+$/g, "");
-  const hiddenEndings = (options.hiddenEndings ?? [])
-    .map((ending) => ending.trim().toLowerCase())
-    .filter(Boolean);
-  const hiddenPaths = new Set((options.hiddenPaths ?? []).map(normalizeRulePath));
-  const shownPaths = new Set((options.shownPaths ?? []).map(normalizeRulePath));
-
-  return entries
-    .filter((entry) => {
-      if (!entry.name.startsWith(".") || entry.name === ".gitignore") return false;
-      if (INTERNAL_PROJECT_FILES.has(entry.name) || STANDARD_PROJECT_FILES.has(entry.name)) return false;
-      const entryRelPath = normalizeRulePath(relPath ? `${relPath}/${entry.name}` : entry.name);
-      if (shownPaths.has(entryRelPath)) return false; // already shown inline
-      if (hiddenPaths.has(entryRelPath)) return false; // user chose to fully hide
-      if (hiddenEndings.some((ending) => entry.name.toLowerCase().endsWith(ending))) return false;
-      return true;
-    })
-    .sort((a, b) => compareEntries(a, b, sortKey, descending));
-}
-
 function normalizeRulePath(path: string): string {
   return path.trim().replace(/^\/+|\/+$/g, "").toLowerCase();
 }
@@ -306,6 +508,7 @@ export function fileIcon(ext: string | null): string {
     case ".png":
     case ".jpg":
     case ".jpeg":
+    case ".gif":
     case ".svg": return "🖼";
     case ".sh": return "⚙";
     default: return "📄";
diff --git a/src/lib/viewers/format.ts b/src/lib/viewers/format.ts
new file mode 100644
index 0000000..b729bea
--- /dev/null
+++ b/src/lib/viewers/format.ts
@@ -0,0 +1,124 @@
+/**
+ * Pure per-format helpers for the built-in text viewer's "extra" features
+ * (Group K follow-up): which formatter a file uses, in-process JSON
+ * prettifying, which files get inline JSON/YAML validation, and which files get
+ * a rendered-preview pane (HTML/SVG/CSS). Kept dependency-free and side-effect
+ * free so they unit-test without React or Tauri.
+ *
+ * The heavy lifting (running prettier/black/… and parsing JSON/YAML for exact
+ * error positions) lives in the Rust `commands::format` module; these helpers
+ * only decide *what* applies to a given path and build the preview document.
+ */
+
+/** Lowercase extension of `path` including the dot (e.g. ".css"), or "". */
+function extOf(path: string): string {
+  const name = (path.split(/[/\\]/).filter(Boolean).pop() ?? path).toLowerCase();
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot) : "";
+}
+
+// Extension → the formatter `lang` id understood by the Rust `format_source`
+// command. JSON is intentionally absent here: it is formatted in-process by
+// `formatJsonText` (no external tool needed). Languages whose only formatter is
+// a heavy/rare external tool we don't auto-wire are simply omitted.
+const FORMAT_LANG: Record<string, string> = {
+  ".css": "css", ".scss": "scss", ".less": "less",
+  ".html": "html", ".htm": "html",
+  ".js": "js", ".cjs": "js", ".mjs": "js", ".jsx": "jsx",
+  ".ts": "ts", ".tsx": "tsx", ".vue": "vue",
+  ".yaml": "yaml", ".yml": "yaml",
+  ".graphql": "graphql", ".gql": "graphql",
+  ".md": "markdown", ".markdown": "markdown",
+  ".py": "python", ".pyi": "python",
+  ".rs": "rust",
+  ".go": "go",
+};
+
+/**
+ * The backend formatter `lang` for `path`, or `null` when no external formatter
+ * is wired for the type. `.json` returns `null` here because JSON is formatted
+ * in-process — see {@link jsonFormatLangForPath}.
+ */
+export function formatLangForPath(path: string): string | null {
+  return FORMAT_LANG[extOf(path)] ?? null;
+}
+
+/** True when `path` is a `.json` family file we prettify in-process (no tool). */
+export function isInProcessJson(path: string): boolean {
+  return extOf(path) === ".json";
+}
+
+export type FormatResult =
+  | { ok: true; text: string }
+  | { ok: false; error: string };
+
+/**
+ * Pretty-print JSON in-process via `JSON.parse`/`JSON.stringify` with a
+ * `indent`-space indent. Returns the formatted text, or a parse error message
+ * (so the viewer can surface it rather than silently no-op'ing). A trailing
+ * newline is added to match what on-disk formatters produce.
+ */
+export function formatJsonText(text: string, indent = 2): FormatResult {
+  try {
+    const value = JSON.parse(text);
+    return { ok: true, text: JSON.stringify(value, null, indent) + "\n" };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+/** Language to inline-validate `path` against, or `null` for none. */
+export function validationLangForPath(path: string): "json" | "yaml" | null {
+  const ext = extOf(path);
+  if (ext === ".json") return "json";
+  if (ext === ".yaml" || ext === ".yml") return "yaml";
+  return null;
+}
+
+export type PreviewKind = "html" | "svg" | "css";
+
+/** The rendered-preview kind for `path` (HTML/SVG/CSS), or `null` for none.
+ *  Only plain `.css` previews — SCSS/LESS need compilation the webview can't do,
+ *  so they stay edit-only (but keep their Format action). */
+export function previewKindForPath(path: string): PreviewKind | null {
+  const ext = extOf(path);
+  if (ext === ".html" || ext === ".htm") return "html";
+  if (ext === ".svg") return "svg";
+  if (ext === ".css") return "css";
+  return null;
+}
+
+// A small representative document the CSS preview applies the stylesheet to, so
+// the reader sees their rules take effect (headings, text, links, controls,
+// lists, a table). Authored as plain markup; the user's CSS is injected via a
+// <style> tag (see buildPreviewDoc).
+const CSS_PREVIEW_SAMPLE = `
+<h1>Heading 1</h1>
+<h2>Heading 2</h2>
+<p>The quick brown fox jumps over the lazy dog. Here is a
+<a href="#">link</a>, some <strong>bold</strong> and <em>italic</em> text,
+and <code>inline code</code>.</p>
+<blockquote>A short blockquote for styling.</blockquote>
+<button>Button</button>
+<input placeholder="Input field" />
+<ul><li>First item</li><li>Second item</li><li>Third item</li></ul>
+<table>
+  <thead><tr><th>Name</th><th>Value</th></tr></thead>
+  <tbody><tr><td>Alpha</td><td>1</td></tr><tr><td>Beta</td><td>2</td></tr></tbody>
+</table>
+`;
+
+/**
+ * Build the `srcDoc` for the rendered-preview iframe. The iframe is always
+ * rendered with `sandbox=""` (no scripts), so even a hostile file is inert.
+ *  - "html"/"svg": the file's own source is the document.
+ *  - "css": the stylesheet is injected into a sample document so its effect is
+ *    visible.
+ */
+export function buildPreviewDoc(kind: PreviewKind, content: string): string {
+  if (kind === "css") {
+    return `<!doctype html><html><head><meta charset="utf-8"><style>\n${content}\n</style></head><body>${CSS_PREVIEW_SAMPLE}</body></html>`;
+  }
+  // HTML and SVG render their own source directly.
+  return content;
+}
diff --git a/src/lib/viewers/gif.ts b/src/lib/viewers/gif.ts
new file mode 100644
index 0000000..af79507
--- /dev/null
+++ b/src/lib/viewers/gif.ts
@@ -0,0 +1,440 @@
+/**
+ * Pure GIF decoder backing the native GIF viewer. All pure — the decoder takes
+ * a `Uint8Array` and never touches the fs (same bargain as `yaml.ts`/`table.ts`).
+ * WebKitGTK has no `ImageDecoder` API, so frame-level control (pause, step,
+ * scrub) means decoding GIF's LZW + compositing ourselves. GIF89a is a frozen
+ * spec, so hand-rolling costs no maintenance tail.
+ *
+ * Two load-bearing ideas:
+ *
+ * 1. **Every frame is composited to a full-canvas RGBA buffer.** A GIF frame is
+ *    a rect patched onto the previous state (plus a disposal method), so frame N
+ *    is only meaningful given N−1 — GIF has no keyframes. Decoding upfront to
+ *    full frames is what makes scrubbing and prev-step O(1); the memory cost
+ *    (`w*h*4*frames`) is bounded by `maxPixelBytes` — when the next frame would
+ *    exceed it, decoding stops and the result says `truncated`.
+ *
+ * 2. **Delays are stored as authored, played as convention.** GIFs in the wild
+ *    authored with a 0 or 1 hundredth delay were authored *against* the browser
+ *    clamp (every engine renders <2 hundredths as 100ms); honoring 0ms literally
+ *    would strobe them. `effectiveDelayMs` applies the convention at playback
+ *    (<20ms → 100ms, everything else exact) while `GifFrame.delayMs` keeps the
+ *    authored value for the readout.
+ *
+ * Disposal 2 ("restore to background") clears the frame rect to *transparent*,
+ * not the logical-screen background color — the spec says background, every
+ * browser ever shipped says transparent, and files are authored against the
+ * browsers. Pinned by a test.
+ *
+ * Error policy: an unreadable header throws `GifDecodeError`; corruption or EOF
+ * after at least one complete frame returns what decoded cleanly with
+ * `truncated: true` (browsers render a truncated GIF the same way).
+ */
+
+export interface GifFrame {
+  /** Full-canvas RGBA pixels (width*height*4), already composited. Typed over
+   *  a plain ArrayBuffer so it feeds `new ImageData(...)` without a cast. */
+  pixels: Uint8ClampedArray<ArrayBuffer>;
+  /** Authored delay in ms (raw GCE hundredths × 10). 0 is preserved as 0;
+   *  playback applies {@link effectiveDelayMs}. */
+  delayMs: number;
+  /** Raw GCE disposal method 0–3, kept for tests/debug readouts. */
+  disposal: number;
+}
+
+export interface GifData {
+  /** Logical screen size — every frame's `pixels` buffer is this size. */
+  width: number;
+  height: number;
+  /** At least one; a GIF with zero decodable frames throws instead. */
+  frames: GifFrame[];
+  /** Netscape iteration count: 0 = loop forever; 1 when the extension is
+   *  absent (play once). */
+  loopCount: number;
+  /** True when the file ended mid-stream, a frame was corrupt, or the memory
+   *  cap stopped decoding; `frames` holds what decoded cleanly. */
+  truncated: boolean;
+}
+
+export class GifDecodeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "GifDecodeError";
+  }
+}
+
+/** The delay a frame actually plays at (see module comment): authored delays
+ *  under 20ms mean "browser default", i.e. 100ms; everything else is exact. */
+export function effectiveDelayMs(delayMs: number): number {
+  return delayMs < 20 ? 100 : delayMs;
+}
+
+/** Default cap on total decoded frame memory (RGBA bytes across all frames).
+ *  Typical GIFs (a few MB file, <200 frames, <600px) land well under this;
+ *  a pathological one stops here with `truncated` instead of eating the heap. */
+export const DEFAULT_MAX_PIXEL_BYTES = 256 * 1024 * 1024;
+
+// ── Byte cursor ──────────────────────────────────────────────────────────────
+
+interface Cursor {
+  bytes: Uint8Array;
+  pos: number;
+}
+
+function u8(c: Cursor): number {
+  if (c.pos >= c.bytes.length) throw new GifDecodeError("unexpected end of file");
+  return c.bytes[c.pos++];
+}
+
+function u16le(c: Cursor): number {
+  return u8(c) | (u8(c) << 8);
+}
+
+function take(c: Cursor, n: number): Uint8Array {
+  if (c.pos + n > c.bytes.length) throw new GifDecodeError("unexpected end of file");
+  const v = c.bytes.subarray(c.pos, c.pos + n);
+  c.pos += n;
+  return v;
+}
+
+/** Read a sub-block chain (length byte, data, … until a 0 length) into one
+ *  contiguous buffer. */
+function readSubBlocks(c: Cursor): Uint8Array {
+  const parts: Uint8Array[] = [];
+  let total = 0;
+  for (let len = u8(c); len !== 0; len = u8(c)) {
+    parts.push(take(c, len));
+    total += len;
+  }
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const p of parts) {
+    out.set(p, pos);
+    pos += p.length;
+  }
+  return out;
+}
+
+// ── LZW ──────────────────────────────────────────────────────────────────────
+
+/**
+ * GIF-flavored LZW: variable code width from `minCodeSize+1` up to 12 bits,
+ * clear code resets the dictionary, EOI ends the stream. The dictionary is flat
+ * prefix/suffix arrays (an entry is "prefix entry's expansion + one suffix
+ * byte"), expanded through a stack — no string building. Tolerates the two
+ * real-world stream shapes: filling `expected` pixels before EOI (common), and
+ * ending early (returns how many pixels landed; the caller marks truncated).
+ * A code beyond the next free dictionary slot is corruption and throws.
+ */
+function lzwDecode(
+  minCodeSize: number,
+  data: Uint8Array,
+  expected: number,
+): { indices: Uint8Array; filled: number } {
+  const MAX_DICT = 4096;
+  const clear = 1 << minCodeSize;
+  const eoi = clear + 1;
+  const prefix = new Int32Array(MAX_DICT);
+  const suffix = new Uint8Array(MAX_DICT);
+  const stack = new Uint8Array(MAX_DICT + 1);
+  const out = new Uint8Array(expected);
+
+  let dictSize = eoi + 1;
+  let codeSize = minCodeSize + 1;
+  let prev = -1;
+  let acc = 0;
+  let bits = 0;
+  let pos = 0;
+  let outPos = 0;
+
+  while (outPos < expected) {
+    while (bits < codeSize) {
+      if (pos >= data.length) return { indices: out, filled: outPos }; // stream ended early
+      acc |= data[pos++] << bits;
+      bits += 8;
+    }
+    const code = acc & ((1 << codeSize) - 1);
+    acc >>= codeSize;
+    bits -= codeSize;
+
+    if (code === clear) {
+      dictSize = eoi + 1;
+      codeSize = minCodeSize + 1;
+      prev = -1;
+      continue;
+    }
+    if (code === eoi) break;
+
+    // Expand the code (or, for the KwKwK case where the code IS the next free
+    // slot, the previous code + its own first byte) through the stack.
+    let cur = code;
+    let sp = 0;
+    let kwkwk = false;
+    if (cur >= dictSize) {
+      if (cur !== dictSize || prev < 0) throw new GifDecodeError("corrupt LZW stream");
+      kwkwk = true;
+      cur = prev;
+    }
+    while (cur >= clear) {
+      stack[sp++] = suffix[cur];
+      cur = prefix[cur];
+    }
+    const first = cur; // the expansion's first byte (a literal)
+    stack[sp++] = first;
+    for (let i = sp - 1; i >= 0 && outPos < expected; i--) out[outPos++] = stack[i];
+    if (kwkwk && outPos < expected) out[outPos++] = first;
+
+    if (prev >= 0 && dictSize < MAX_DICT) {
+      prefix[dictSize] = prev;
+      suffix[dictSize] = first;
+      dictSize++;
+      // Grow the code width when the dictionary fills the current one; a full
+      // dictionary (4096) stays at 12 bits until the encoder sends a clear.
+      if (dictSize === 1 << codeSize && codeSize < 12) codeSize++;
+    }
+    prev = code;
+  }
+  return { indices: out, filled: outPos };
+}
+
+// ── Interlace ────────────────────────────────────────────────────────────────
+
+/** Reorder an interlaced frame's rows into display order (the 4-pass 8/8/4/2
+ *  row scheme). */
+function deinterlace(indices: Uint8Array, w: number, h: number): Uint8Array {
+  const out = new Uint8Array(indices.length);
+  const offsets = [0, 4, 2, 1];
+  const steps = [8, 8, 4, 2];
+  let src = 0;
+  for (let pass = 0; pass < 4; pass++) {
+    for (let y = offsets[pass]; y < h; y += steps[pass]) {
+      out.set(indices.subarray(src, src + w), y * w);
+      src += w;
+    }
+  }
+  return out;
+}
+
+// ── Compositor ───────────────────────────────────────────────────────────────
+
+/** Patch a frame's palette indices onto the full canvas. The transparent index
+ *  leaves the underlying pixel; rows/cols outside the logical screen (broken
+ *  files) and indices beyond the color table are skipped. `filled` bounds a
+ *  partially decoded frame to the pixels that actually landed. */
+function drawFrame(
+  canvas: Uint8ClampedArray,
+  cw: number,
+  ch: number,
+  indices: Uint8Array,
+  filled: number,
+  left: number,
+  top: number,
+  w: number,
+  h: number,
+  table: Uint8Array,
+  transparent: number,
+): void {
+  for (let row = 0; row < h; row++) {
+    const cy = top + row;
+    if (cy < 0 || cy >= ch) continue;
+    const rowBase = row * w;
+    if (rowBase >= filled) break;
+    for (let col = 0; col < w; col++) {
+      const src = rowBase + col;
+      if (src >= filled) break;
+      const cx = left + col;
+      if (cx < 0 || cx >= cw) continue;
+      const idx = indices[src];
+      if (idx === transparent) continue;
+      const t = idx * 3;
+      if (t + 2 >= table.length) continue;
+      const p = (cy * cw + cx) * 4;
+      canvas[p] = table[t];
+      canvas[p + 1] = table[t + 1];
+      canvas[p + 2] = table[t + 2];
+      canvas[p + 3] = 255;
+    }
+  }
+}
+
+/** Clear a rect to transparent (disposal 2 — see module comment). */
+function clearRect(
+  canvas: Uint8ClampedArray,
+  cw: number,
+  ch: number,
+  left: number,
+  top: number,
+  w: number,
+  h: number,
+): void {
+  const x0 = Math.max(0, left);
+  const x1 = Math.min(cw, left + w);
+  const y0 = Math.max(0, top);
+  const y1 = Math.min(ch, top + h);
+  for (let y = y0; y < y1; y++) canvas.fill(0, (y * cw + x0) * 4, (y * cw + x1) * 4);
+}
+
+// ── Stream decoder ───────────────────────────────────────────────────────────
+
+/** Incremental decoder: `nextFrame()` decodes and returns one composited frame
+ *  at a time (null after the trailer / truncation), so a caller can yield to
+ *  the event loop between frames instead of blocking on a long file.
+ *  `loopCount`/`truncated` are settled once `nextFrame()` has returned null. */
+export interface GifStream {
+  readonly width: number;
+  readonly height: number;
+  nextFrame(): GifFrame | null;
+  readonly loopCount: number;
+  readonly truncated: boolean;
+}
+
+/** Parse the header/logical screen (throws `GifDecodeError` when `bytes` is not
+ *  a GIF) and return a {@link GifStream} over the frames. */
+export function openGif(
+  bytes: Uint8Array,
+  opts?: { maxPixelBytes?: number },
+): GifStream {
+  const c: Cursor = { bytes, pos: 0 };
+  const magic = String.fromCharCode(...take(c, 6));
+  if (magic !== "GIF87a" && magic !== "GIF89a") throw new GifDecodeError("not a GIF file");
+  const width = u16le(c);
+  const height = u16le(c);
+  if (width === 0 || height === 0) throw new GifDecodeError("empty logical screen");
+  const lsdFlags = u8(c);
+  u8(c); // background color index — unused (see module comment on disposal 2)
+  u8(c); // pixel aspect ratio — universally ignored
+  const gct = lsdFlags & 0x80 ? take(c, 3 * (2 << (lsdFlags & 7))) : null;
+
+  const maxPixelBytes = opts?.maxPixelBytes ?? DEFAULT_MAX_PIXEL_BYTES;
+  const frameBytes = width * height * 4;
+  // The persistent composite canvas; starts fully transparent.
+  const canvas = new Uint8ClampedArray(frameBytes);
+  let snapshot: Uint8ClampedArray | null = null;
+  // The pending Graphic Control Extension — it precedes and applies to the next
+  // image descriptor only.
+  let pending: { delayMs: number; disposal: number; transparent: number } | null = null;
+  let loopCount = 1;
+  let truncated = false;
+  let done = false;
+  let delivered = 0;
+
+  function readNext(): GifFrame | null {
+    while (true) {
+      const block = u8(c);
+      if (block === 0x3b) return null; // trailer
+      if (block === 0x21) {
+        const label = u8(c);
+        if (label === 0xf9) {
+          // Graphic Control Extension: disposal + transparency + delay.
+          const d = readSubBlocks(c);
+          if (d.length >= 4) {
+            pending = {
+              disposal: (d[0] >> 2) & 7,
+              transparent: d[0] & 1 ? d[3] : -1,
+              delayMs: (d[1] | (d[2] << 8)) * 10,
+            };
+          }
+        } else if (label === 0xff) {
+          // Application extension — only the Netscape loop count matters.
+          const d = readSubBlocks(c);
+          const id = String.fromCharCode(...d.subarray(0, 11));
+          if ((id === "NETSCAPE2.0" || id === "ANIMEXTS1.0") && d.length >= 14 && d[11] === 1) {
+            loopCount = d[12] | (d[13] << 8);
+          }
+        } else {
+          // Comment / plain-text / unknown extension: skip leniently — real-world
+          // GIFs carry junk extensions.
+          readSubBlocks(c);
+        }
+        continue;
+      }
+      if (block === 0x2c) {
+        // Image descriptor.
+        const left = u16le(c);
+        const top = u16le(c);
+        const w = u16le(c);
+        const h = u16le(c);
+        const dFlags = u8(c);
+        const lct = dFlags & 0x80 ? take(c, 3 * (2 << (dFlags & 7))) : null;
+        const table = lct ?? gct;
+        if (!table) throw new GifDecodeError("frame has no color table");
+        if (w === 0 || h === 0) throw new GifDecodeError("empty frame");
+        if ((delivered + 1) * frameBytes > maxPixelBytes) {
+          truncated = true;
+          return null;
+        }
+        const minCodeSize = u8(c);
+        if (minCodeSize < 1 || minCodeSize > 11) throw new GifDecodeError("corrupt LZW code size");
+        const { indices, filled } = lzwDecode(minCodeSize, readSubBlocks(c), w * h);
+        const idx = dFlags & 0x40 ? deinterlace(indices, w, h) : indices;
+        const gce = pending;
+        pending = null;
+        const disposal = gce?.disposal ?? 0;
+        // Disposal 3 restores the state from BEFORE this frame drew — snapshot
+        // only then, so ordinary frames cost no copy.
+        if (disposal === 3) snapshot = canvas.slice();
+        drawFrame(canvas, width, height, idx, filled, left, top, w, h, table, gce?.transparent ?? -1);
+        const frame: GifFrame = {
+          pixels: canvas.slice(),
+          delayMs: gce?.delayMs ?? 0,
+          disposal,
+        };
+        // Apply this frame's disposal now, preparing the canvas the NEXT frame
+        // composites onto.
+        if (disposal === 2) clearRect(canvas, width, height, left, top, w, h);
+        else if (disposal === 3 && snapshot) {
+          canvas.set(snapshot);
+          snapshot = null;
+        }
+        if (filled < w * h) truncated = true; // LZW stream ended early
+        delivered++;
+        return frame;
+      }
+      throw new GifDecodeError(`unknown block 0x${block.toString(16)}`);
+    }
+  }
+
+  return {
+    width,
+    height,
+    get loopCount() {
+      return loopCount;
+    },
+    get truncated() {
+      return truncated;
+    },
+    nextFrame() {
+      if (done) return null;
+      let frame: GifFrame | null = null;
+      try {
+        frame = readNext();
+      } catch (e) {
+        // Corruption/EOF before the first complete frame is a hard error; after
+        // one, render what decoded cleanly (what browsers do).
+        if (delivered === 0) {
+          done = true;
+          throw e instanceof GifDecodeError ? e : new GifDecodeError(String(e));
+        }
+        truncated = true;
+      }
+      if (frame === null) done = true;
+      return frame;
+    },
+  };
+}
+
+/** Decode a whole GIF upfront (drains {@link openGif}). Throws `GifDecodeError`
+ *  when the bytes are not a GIF or no frame decodes. */
+export function decodeGif(bytes: Uint8Array, opts?: { maxPixelBytes?: number }): GifData {
+  const stream = openGif(bytes, opts);
+  const frames: GifFrame[] = [];
+  for (let f = stream.nextFrame(); f !== null; f = stream.nextFrame()) frames.push(f);
+  if (frames.length === 0) throw new GifDecodeError("GIF contains no image frames");
+  return {
+    width: stream.width,
+    height: stream.height,
+    frames,
+    loopCount: stream.loopCount,
+    truncated: stream.truncated,
+  };
+}
diff --git a/src/lib/viewers/highlight.ts b/src/lib/viewers/highlight.ts
index d3abb1d..b9dd3c1 100644
--- a/src/lib/viewers/highlight.ts
+++ b/src/lib/viewers/highlight.ts
@@ -31,9 +31,10 @@ export type Lang =
   | "sql"
   | "tex"
   | "markup"
+  | "markdown"
   | "plain";
 
-function escapeHtml(s: string): string {
+export function escapeHtml(s: string): string {
   return s
     .replace(/&/g, "&amp;")
     .replace(/</g, "&lt;")
@@ -150,7 +151,7 @@ const SQL_KW = set(
 
 const TOML_KW = set("true", "false");
 
-const SPECS: Record<Exclude<Lang, "markup" | "tex" | "plain">, LangSpec> = {
+const SPECS: Record<Exclude<Lang, "markup" | "tex" | "markdown" | "plain">, LangSpec> = {
   js: { line: ["//"], block: ["/*", "*/"], strings: ['"', "'", "`"], keywords: JS_KW, literals: set("true", "false", "null", "undefined", "NaN", "Infinity"), types: JS_TYPES },
   rust: { line: ["//"], block: ["/*", "*/"], strings: ['"'], keywords: RUST_KW, literals: set("true", "false", "None", "Some", "Ok", "Err"), types: RUST_TYPES },
   python: { line: ["#"], strings: ['"', "'"], triple: true, keywords: PY_KW, literals: set("True", "False", "None", "self", "cls"), types: PY_TYPES },
@@ -184,6 +185,8 @@ const EXT_LANG: Record<string, Lang> = {
   ".sql": "sql",
   ".tex": "tex", ".sty": "tex", ".cls": "tex", ".ltx": "tex",
   ".html": "markup", ".htm": "markup", ".xml": "markup", ".svg": "markup",
+  ".md": "markdown", ".markdown": "markdown", ".mdown": "markdown",
+  ".mkd": "markdown", ".mdx": "markdown",
 };
 
 const FILENAME_LANG: Record<string, Lang> = {
@@ -198,7 +201,7 @@ const FILENAME_LANG: Record<string, Lang> = {
  *  then shows the file uncoloured). Matched by extension first, then by a few
  *  well-known extensionless filenames. */
 export function languageForPath(path: string): Lang {
-  const name = (path.split("/").filter(Boolean).pop() ?? path).toLowerCase();
+  const name = (path.split(/[/\\]/).filter(Boolean).pop() ?? path).toLowerCase();
   const dot = name.lastIndexOf(".");
   // A leading-dot name (".gitignore") has no extension; only a dot past index 0
   // separates a real extension.
@@ -470,6 +473,147 @@ function scanTex(code: string): string {
   return out;
 }
 
+const isWordChar = (c: string | undefined) => !!c && /[A-Za-z0-9]/.test(c);
+
+/** Highlight the inline span content of one markdown line: code spans, links/
+ *  images, and `**strong**` / `*emphasis*` runs. Emphasis uses CommonMark-style
+ *  flanking checks (no space just inside the markers, underscores not intra-word)
+ *  so stray `*`/`_` in prose or `2 * 3` math don't get coloured. Everything not
+ *  matched passes through HTML-escaped. */
+function scanMarkdownInline(text: string): string {
+  let out = "";
+  let i = 0;
+  const n = text.length;
+
+  while (i < n) {
+    const c = text[i];
+
+    // Inline code: a run of N backticks closed by the same run.
+    if (c === "`") {
+      let ticks = 0;
+      while (text[i + ticks] === "`") ticks += 1;
+      const close = text.indexOf("`".repeat(ticks), i + ticks);
+      if (close !== -1) {
+        out += span("md-code", text.slice(i, close + ticks));
+        i = close + ticks;
+        continue;
+      }
+    }
+
+    // Link `[text](url)` or image `![alt](url)`.
+    if (c === "[" || (c === "!" && text[i + 1] === "[")) {
+      const lb = c === "!" ? i + 1 : i;
+      const rb = text.indexOf("]", lb + 1);
+      if (rb !== -1 && text[rb + 1] === "(") {
+        const rp = text.indexOf(")", rb + 2);
+        if (rp !== -1) {
+          if (c === "!") out += escapeHtml("!");
+          out += escapeHtml("[") + span("md-link", text.slice(lb + 1, rb)) + escapeHtml("](");
+          out += span("md-url", text.slice(rb + 2, rp)) + escapeHtml(")");
+          i = rp + 1;
+          continue;
+        }
+      }
+    }
+
+    // Strong: ** or __ (checked before emphasis so `**` wins over `*`).
+    if (
+      (c === "*" || c === "_") && text[i + 1] === c &&
+      text[i + 2] !== undefined && text[i + 2] !== " " &&
+      !(c === "_" && isWordChar(text[i - 1]))
+    ) {
+      const close = text.indexOf(c + c, i + 2);
+      if (close !== -1 && text[close - 1] !== " " &&
+          !(c === "_" && isWordChar(text[close + 2]))) {
+        out += span("md-strong", text.slice(i, close + 2));
+        i = close + 2;
+        continue;
+      }
+    }
+
+    // Emphasis: a single * or _.
+    if (
+      (c === "*" || c === "_") &&
+      text[i + 1] !== undefined && text[i + 1] !== " " && text[i + 1] !== c &&
+      !(c === "_" && isWordChar(text[i - 1]))
+    ) {
+      const close = text.indexOf(c, i + 1);
+      if (close !== -1 && text[close - 1] !== " " &&
+          !(c === "_" && isWordChar(text[close + 1]))) {
+        out += span("md-em", text.slice(i, close + 1));
+        i = close + 1;
+        continue;
+      }
+    }
+
+    out += escapeHtml(c);
+    i += 1;
+  }
+
+  return out;
+}
+
+/** Tokenize Markdown line-by-line: fenced code blocks, ATX headings, horizontal
+ *  rules, blockquote/list line prefixes, plus the inline spans handled by
+ *  {@link scanMarkdownInline}. A focused subset, like the other scanners. */
+function scanMarkdown(code: string): string {
+  const lines = code.split("\n");
+  let out = "";
+  let inFence = false;
+  let fence = "";
+
+  for (let li = 0; li < lines.length; li += 1) {
+    const line = lines[li];
+    const nl = li < lines.length - 1 ? "\n" : "";
+
+    // Inside a fenced code block: paint verbatim until a matching close fence.
+    if (inFence) {
+      out += span("md-code", line) + nl;
+      if (line.trimStart().startsWith(fence)) inFence = false;
+      continue;
+    }
+
+    // Opening code fence (``` or ~~~, optionally with an info string).
+    const open = /^\s{0,3}(```+|~~~+)/.exec(line);
+    if (open) {
+      inFence = true;
+      fence = open[1].slice(0, 3);
+      out += span("md-code", line) + nl;
+      continue;
+    }
+
+    // ATX heading (#…######).
+    if (/^\s{0,3}#{1,6}(\s|$)/.test(line)) {
+      out += span("md-heading", line) + nl;
+      continue;
+    }
+
+    // Horizontal rule (three or more -, *, or _).
+    if (/^\s{0,3}([-*_])\s*(?:\1\s*){2,}$/.test(line)) {
+      out += span("md-hr", line) + nl;
+      continue;
+    }
+
+    // Leading blockquote markers and/or a list marker, then inline content.
+    let rest = line;
+    let prefix = "";
+    const bq = /^(\s{0,3}(?:>\s?)+)/.exec(rest);
+    if (bq) {
+      prefix += span("md-quote", bq[1]);
+      rest = rest.slice(bq[1].length);
+    }
+    const list = /^(\s*)([-*+]|\d{1,9}[.)])(\s+)/.exec(rest);
+    if (list) {
+      prefix += escapeHtml(list[1]) + span("md-list", list[2]) + escapeHtml(list[3]);
+      rest = rest.slice(list[0].length);
+    }
+
+    out += prefix + scanMarkdownInline(rest) + nl;
+  }
+
+  return out;
+}
+
 /** Largest source we will highlight, in characters. Beyond this the viewer falls
  *  back to plain text so editing a huge file stays responsive (re-highlight runs
  *  on every keystroke). */
@@ -485,5 +629,6 @@ export function highlight(code: string, lang: Lang): string | null {
   if (code.length > HIGHLIGHT_MAX_CHARS) return null;
   if (lang === "markup") return scanMarkup(code);
   if (lang === "tex") return scanTex(code);
+  if (lang === "markdown") return scanMarkdown(code);
   return scanCode(code, SPECS[lang]);
 }
diff --git a/src/lib/viewers/linediff.ts b/src/lib/viewers/linediff.ts
new file mode 100644
index 0000000..ddd08d9
--- /dev/null
+++ b/src/lib/viewers/linediff.ts
@@ -0,0 +1,279 @@
+/**
+ * Pure line-level diff/merge logic for the in-app three-column compare view.
+ *
+ * Unlike `diff.ts` (which *parses* git's unified-diff output), this diffs two
+ * arbitrary strings — the "old" committed version of a file and the live editor
+ * content — into aligned rows the compare view renders side-by-side, groups the
+ * changes into accept/reject blocks, and assembles/edits the merged result.
+ *
+ * No DOM, no React — this is the unit-tested logic half of `CompareView.tsx`.
+ * Text is preserved verbatim (splitting on "\n" and re-joining round-trips
+ * losslessly); the viewer is responsible for HTML-escaping when rendering.
+ */
+
+/** One aligned row of the side-by-side diff. `same` rows have equal left/right;
+ *  `change` pairs an old line with a new line; `del`/`add` are one-sided. */
+export interface AlignRow {
+  /** The old-file line, or null for a pure addition. */
+  left: string | null;
+  /** The new-file line, or null for a pure deletion. */
+  right: string | null;
+  kind: "same" | "change" | "add" | "del";
+}
+
+/** A contiguous run of non-`same` rows — the unit the user accepts or rejects. */
+export interface ChangeBlock {
+  /** Stable id (its ordinal in the block list). */
+  id: number;
+  /** Inclusive start index into the `AlignRow[]`. */
+  startRow: number;
+  /** Exclusive end index into the `AlignRow[]`. */
+  endRow: number;
+  /** The old-side lines (what "reject" restores). */
+  oldLines: string[];
+  /** The new-side lines (what "accept" keeps). */
+  newLines: string[];
+  /** Up to a few unchanged lines immediately before the block (for anchoring
+   *  a splice into a hand-edited merge buffer). */
+  contextBefore: string[];
+  /** Up to a few unchanged lines immediately after the block. */
+  contextAfter: string[];
+}
+
+/** accept = keep the new (right) side; reject = restore the old (left) side. */
+export type Decision = "accept" | "reject";
+
+/** Lines of unchanged context captured on each side of a block for re-anchoring. */
+const CONTEXT = 3;
+
+/** Guard against a pathological O(n·m) LCS table. Beyond this the middle region
+ *  is treated as a wholesale replace (all old removed, all new added) rather than
+ *  risking a huge allocation. */
+const LCS_CELL_CAP = 4_000_000;
+
+function splitLines(text: string): string[] {
+  return text.split("\n");
+}
+
+type Op =
+  | { t: "eq"; left: string; right: string }
+  | { t: "del"; left: string }
+  | { t: "ins"; right: string };
+
+/** Longest-common-subsequence op list between two line arrays. */
+function lcsOps(a: string[], b: string[]): Op[] {
+  const n = a.length;
+  const m = b.length;
+  if (n === 0 || m === 0 || n * m > LCS_CELL_CAP) {
+    // Trivial or too large — emit all deletions then all insertions.
+    return [
+      ...a.map((left): Op => ({ t: "del", left })),
+      ...b.map((right): Op => ({ t: "ins", right })),
+    ];
+  }
+  // dp[i][j] = LCS length of a[i..], b[j..].
+  const dp: Uint32Array[] = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+  for (let i = n - 1; i >= 0; i--) {
+    const row = dp[i];
+    const next = dp[i + 1];
+    for (let j = m - 1; j >= 0; j--) {
+      row[j] = a[i] === b[j] ? next[j + 1] + 1 : Math.max(next[j], row[j + 1]);
+    }
+  }
+  const ops: Op[] = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ t: "eq", left: a[i], right: b[j] });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ t: "del", left: a[i] });
+      i++;
+    } else {
+      ops.push({ t: "ins", right: b[j] });
+      j++;
+    }
+  }
+  while (i < n) ops.push({ t: "del", left: a[i++] });
+  while (j < m) ops.push({ t: "ins", right: b[j++] });
+  return ops;
+}
+
+/** Flush a run of deletions/insertions into rows: pair as many as possible into
+ *  `change` rows, then the leftover as one-sided `del`/`add` rows. */
+function flushGap(rows: AlignRow[], dels: string[], ins: string[]): void {
+  const k = Math.min(dels.length, ins.length);
+  for (let x = 0; x < k; x++) rows.push({ left: dels[x], right: ins[x], kind: "change" });
+  for (let x = k; x < dels.length; x++) rows.push({ left: dels[x], right: null, kind: "del" });
+  for (let x = k; x < ins.length; x++) rows.push({ left: null, right: ins[x], kind: "add" });
+}
+
+/**
+ * Diff two texts into aligned rows. Trims the common prefix/suffix first (the
+ * usual case for an edited file) so the LCS runs only over the changed middle.
+ */
+export function diffLines(oldText: string, newText: string): AlignRow[] {
+  const a = splitLines(oldText);
+  const b = splitLines(newText);
+  const rows: AlignRow[] = [];
+
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+
+  for (let i = 0; i < start; i++) rows.push({ left: a[i], right: b[i], kind: "same" });
+
+  const ops = lcsOps(a.slice(start, endA), b.slice(start, endB));
+  let dels: string[] = [];
+  let ins: string[] = [];
+  for (const op of ops) {
+    if (op.t === "eq") {
+      flushGap(rows, dels, ins);
+      dels = [];
+      ins = [];
+      rows.push({ left: op.left, right: op.right, kind: "same" });
+    } else if (op.t === "del") {
+      dels.push(op.left);
+    } else {
+      ins.push(op.right);
+    }
+  }
+  flushGap(rows, dels, ins);
+
+  // Common suffix (a[endA..] and b[endB..] are element-wise equal).
+  for (let i = endA, j = endB; i < a.length; i++, j++) {
+    rows.push({ left: a[i], right: b[j], kind: "same" });
+  }
+  return rows;
+}
+
+/** Collapse runs of non-`same` rows into accept/reject blocks. */
+export function groupChanges(rows: AlignRow[]): ChangeBlock[] {
+  const blocks: ChangeBlock[] = [];
+  let i = 0;
+  while (i < rows.length) {
+    if (rows[i].kind === "same") {
+      i++;
+      continue;
+    }
+    const startRow = i;
+    while (i < rows.length && rows[i].kind !== "same") i++;
+    const endRow = i;
+    const slice = rows.slice(startRow, endRow);
+    const oldLines = slice.filter((r) => r.left != null).map((r) => r.left as string);
+    const newLines = slice.filter((r) => r.right != null).map((r) => r.right as string);
+
+    const contextBefore: string[] = [];
+    for (let j = startRow - 1; j >= 0 && rows[j].kind === "same" && contextBefore.length < CONTEXT; j--) {
+      contextBefore.unshift(rows[j].left as string);
+    }
+    const contextAfter: string[] = [];
+    for (let j = endRow; j < rows.length && rows[j].kind === "same" && contextAfter.length < CONTEXT; j++) {
+      contextAfter.push(rows[j].left as string);
+    }
+
+    blocks.push({
+      id: blocks.length,
+      startRow,
+      endRow,
+      oldLines,
+      newLines,
+      contextBefore,
+      contextAfter,
+    });
+  }
+  return blocks;
+}
+
+/**
+ * Assemble the merged text from scratch given a decision per block. Unchanged
+ * rows contribute their line; each block contributes its new lines (accept, the
+ * default) or old lines (reject). With every block accepted this reproduces the
+ * new text exactly.
+ */
+export function buildMerged(
+  rows: AlignRow[],
+  blocks: ChangeBlock[],
+  decisions: Record<number, Decision>,
+): string {
+  const out: string[] = [];
+  let i = 0;
+  let bi = 0;
+  while (i < rows.length) {
+    if (bi < blocks.length && blocks[bi].startRow === i) {
+      const b = blocks[bi];
+      const dec = decisions[b.id] ?? "accept";
+      out.push(...(dec === "accept" ? b.newLines : b.oldLines));
+      i = b.endRow;
+      bi++;
+    } else {
+      out.push(rows[i].left as string); // `same` row: left === right
+      i++;
+    }
+  }
+  return out.join("\n");
+}
+
+/** True when `sub` occurs in `lines` starting at `at` (out-of-range ⇒ false). */
+function matchAt(lines: string[], at: number, sub: string[]): boolean {
+  if (at < 0 || at + sub.length > lines.length) return false;
+  for (let k = 0; k < sub.length; k++) if (lines[at + k] !== sub[k]) return false;
+  return true;
+}
+
+/**
+ * Find where a block's current side sits in a (possibly hand-edited) merge
+ * buffer, anchored by its surrounding context. Returns the `{ start, len }`
+ * slice range, or null when it can't be located uniquely (e.g. the user edited
+ * around it) — in which case the caller disables that block's toggle.
+ */
+export function locateBlock(
+  resultLines: string[],
+  block: ChangeBlock,
+  decision: Decision,
+): { start: number; len: number } | null {
+  const side = decision === "accept" ? block.newLines : block.oldLines;
+  const before = block.contextBefore;
+  const after = block.contextAfter;
+  const matches: number[] = [];
+  for (let i = 0; i + side.length <= resultLines.length; i++) {
+    if (!matchAt(resultLines, i, side)) continue;
+    if (!matchAt(resultLines, i - before.length, before)) continue;
+    if (!matchAt(resultLines, i + side.length, after)) continue;
+    matches.push(i);
+    if (matches.length > 1) return null; // ambiguous
+  }
+  return matches.length === 1 ? { start: matches[0], len: side.length } : null;
+}
+
+/** Whether a block can be toggled against the given merge buffer. */
+export function canToggle(resultText: string, block: ChangeBlock, decision: Decision): boolean {
+  return locateBlock(splitLines(resultText), block, decision) != null;
+}
+
+/**
+ * Toggle a single block within a hand-editable merge buffer by splicing its
+ * region (located via {@link locateBlock}) from its current side to the other.
+ * Returns the new text and decision, or null when the block can't be located
+ * (the toggle should be disabled). Edits elsewhere in the buffer are preserved.
+ */
+export function applyBlockToggle(
+  resultText: string,
+  block: ChangeBlock,
+  currentDecision: Decision,
+): { text: string; decision: Decision } | null {
+  const lines = splitLines(resultText);
+  const loc = locateBlock(lines, block, currentDecision);
+  if (!loc) return null;
+  const next: Decision = currentDecision === "accept" ? "reject" : "accept";
+  const replacement = next === "accept" ? block.newLines : block.oldLines;
+  lines.splice(loc.start, loc.len, ...replacement);
+  return { text: lines.join("\n"), decision: next };
+}
diff --git a/src/lib/viewers/markdown.ts b/src/lib/viewers/markdown.ts
index 6043859..e81b9aa 100644
--- a/src/lib/viewers/markdown.ts
+++ b/src/lib/viewers/markdown.ts
@@ -34,6 +34,21 @@ function safeHref(url: string): string | null {
   return SAFE_HREF.test(trimmed) ? trimmed : null;
 }
 
+/** Classify an image URL from `![alt](url)`. Remote `http(s)` and `data:image/`
+ *  targets are emitted directly as the <img src>. Local targets (relative or
+ *  absolute filesystem paths, or `file:`) can't be loaded by the webview from the
+ *  app origin nor resolved here (the markdown file's directory is unknown), so
+ *  they are reported as `local` for the viewer to resolve and inline from disk.
+ *  Anything carrying another scheme (e.g. `javascript:`) is rejected. */
+function imgSrc(url: string): { kind: "remote" | "local"; url: string } | null {
+  const u = url.trim();
+  if (!u) return null;
+  if (/^(https?:\/\/|data:image\/)/i.test(u)) return { kind: "remote", url: u };
+  if (/^file:/i.test(u)) return { kind: "local", url: u };
+  if (/^[a-z][a-z0-9+.-]*:/i.test(u)) return null; // other explicit scheme → reject
+  return { kind: "local", url: u }; // no scheme → relative/absolute local path
+}
+
 /** #49: true when a (already-safe) href points at a local file rather than a
  *  remote/anchor target, so the markdown viewer can mark it visibly clickable.
  *  Relative paths, absolute paths, and the `file:` scheme count; http(s)/
@@ -86,14 +101,44 @@ function renderInline(raw: string): string {
     return ` C${idx} `;
   });
 
+  // Pull math out next so emphasis/escape never touches the TeX. We emit a
+  // placeholder span that the post-render `enrichMarkdownDom` pass replaces with
+  // KaTeX. The TeX is HTML-escaped here (escape-first invariant); KaTeX consumes
+  // the de-escaped textContent, which is safe with trust:false.
+  //
+  // Heuristic to avoid treating prose dollar amounts ("It cost $5 today") as
+  // math: a `$` only opens/closes math when it sits directly against a non-space
+  // char on the inside, and no newline appears between the delimiters. Block math
+  // (`$$…$$`) is pulled before inline (`$…$`) so the longer delimiter wins; the
+  // single-line `$$x$$` form is handled here, which covers our docs in v1.
+  const mathSpans: string[] = [];
+  const pushMath = (tex: string, display: boolean): string => {
+    const idx =
+      mathSpans.push(
+        `<span class="md-math" data-display="${display}">${escapeHtml(tex)}</span>`,
+      ) - 1;
+    return ` M${idx} `;
+  };
+  text = text.replace(/\$\$(?!\s)([^\n]+?)(?<!\s)\$\$/g, (_m, tex: string) =>
+    pushMath(tex, true),
+  );
+  text = text.replace(/\$(?!\s)([^$\n]+?)(?<!\s)\$/g, (_m, tex: string) =>
+    pushMath(tex, false),
+  );
+
   // Pull links/images out next so their text/url are not mangled by emphasis.
   const links: string[] = [];
   text = text.replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_m, alt: string, url: string) => {
-    const href = safeHref(url);
     const altEsc = escapeHtml(alt);
-    const html = href
-      ? `<img src="${escapeHtml(href)}" alt="${altEsc}" />`
-      : `[${altEsc}]`;
+    const img = imgSrc(url);
+    // Local images get a placeholder (no `src`, so they don't 404 against the app
+    // origin); the markdown viewer resolves `data-md-src` against the file's dir
+    // and swaps in the bytes. Remote/data images are emitted directly.
+    const html = !img
+      ? `[${altEsc}]`
+      : img.kind === "remote"
+        ? `<img src="${escapeHtml(img.url)}" alt="${altEsc}" />`
+        : `<img class="md-img-local" data-md-src="${escapeHtml(img.url)}" alt="${altEsc}" />`;
     const idx = links.push(html) - 1;
     return ` L${idx} `;
   });
@@ -137,7 +182,8 @@ function renderInline(raw: string): string {
   text = text.replace(/(^|[^_])_([^_\s][^_]*?)_/g, "$1<em>$2</em>");
   text = text.replace(/~~([^~]+)~~/g, "<del>$1</del>");
 
-  // Restore links then code spans.
+  // Restore math, then links, then code spans.
+  text = text.replace(/ M(\d+) /g, (_m, i: string) => mathSpans[Number(i)]);
   text = text.replace(/ L(\d+) /g, (_m, i: string) => links[Number(i)]);
   text = text.replace(/ C(\d+) /g, (_m, i: string) => codeSpans[Number(i)]);
   return text;
diff --git a/src/lib/viewers/markdownEdit.ts b/src/lib/viewers/markdownEdit.ts
new file mode 100644
index 0000000..0883541
--- /dev/null
+++ b/src/lib/viewers/markdownEdit.ts
@@ -0,0 +1,188 @@
+/**
+ * Pure text transforms backing the Markdown editing toolbar (bold/italic/code/
+ * heading/link/list) and the "Insert table of contents" action. Each transform
+ * takes the buffer plus a selection `[start, end)` and returns the new buffer
+ * with an updated selection, so the editor can apply it through its normal
+ * set-value path (keeping undo/redo and highlighting consistent). Dependency-
+ * free and exported for unit testing.
+ */
+
+export interface EditResult {
+  value: string;
+  selStart: number;
+  selEnd: number;
+}
+
+/**
+ * Toggle an inline `marker` (e.g. `**`, `_`, `` ` ``) around the selection. If
+ * the selection is already wrapped — either the markers sit just outside it, or
+ * they are the first/last characters of the selection — they are removed;
+ * otherwise they are added. The selection is kept on the inner text.
+ */
+export function toggleInline(
+  value: string,
+  start: number,
+  end: number,
+  marker: string,
+): EditResult {
+  const sel = value.slice(start, end);
+  const before = value.slice(0, start);
+  const after = value.slice(end);
+  const m = marker.length;
+
+  // Markers immediately outside the selection → unwrap them.
+  if (before.endsWith(marker) && after.startsWith(marker)) {
+    return {
+      value: before.slice(0, -m) + sel + after.slice(m),
+      selStart: start - m,
+      selEnd: end - m,
+    };
+  }
+  // Markers are the outermost chars of the selection → strip them.
+  if (sel.length >= m * 2 && sel.startsWith(marker) && sel.endsWith(marker)) {
+    const inner = sel.slice(m, sel.length - m);
+    return { value: before + inner + after, selStart: start, selEnd: start + inner.length };
+  }
+  // Otherwise wrap.
+  return {
+    value: before + marker + sel + marker + after,
+    selStart: start + m,
+    selEnd: end + m,
+  };
+}
+
+/** The `[lineStart, lineEnd)` of the line containing offset `pos`. */
+function lineBounds(value: string, pos: number): [number, number] {
+  const lineStart = value.lastIndexOf("\n", pos - 1) + 1;
+  let lineEnd = value.indexOf("\n", pos);
+  if (lineEnd === -1) lineEnd = value.length;
+  return [lineStart, lineEnd];
+}
+
+/**
+ * Cycle the heading level of the line at `pos`: none → `#` → `##` → `###` →
+ * none. The caret is kept at the same place within the line text.
+ */
+export function cycleHeading(value: string, pos: number): EditResult {
+  const [ls, le] = lineBounds(value, pos);
+  const line = value.slice(ls, le);
+  const m = line.match(/^(#{1,6})\s+/);
+  const cur = m ? m[1].length : 0;
+  const rest = m ? line.slice(m[0].length) : line.replace(/^\s+/, "");
+  const next = cur >= 3 ? 0 : cur + 1;
+  const newLine = next === 0 ? rest : `${"#".repeat(next)} ${rest}`;
+  const delta = newLine.length - line.length;
+  const caret = Math.max(ls, pos + delta);
+  return {
+    value: value.slice(0, ls) + newLine + value.slice(le),
+    selStart: caret,
+    selEnd: caret,
+  };
+}
+
+/**
+ * Toggle a line `prefix` (e.g. `"- "` for a bullet list) on every line the
+ * selection touches: if all such lines already carry it, remove it; otherwise
+ * add it. The selection is expanded to cover the affected lines.
+ */
+export function toggleLinePrefix(
+  value: string,
+  start: number,
+  end: number,
+  prefix: string,
+): EditResult {
+  const blockStart = value.lastIndexOf("\n", start - 1) + 1;
+  let blockEnd = value.indexOf("\n", end > start ? end - 1 : end);
+  if (blockEnd === -1) blockEnd = value.length;
+  const block = value.slice(blockStart, blockEnd);
+  const lines = block.split("\n");
+  const allPrefixed = lines.every((l) => l.startsWith(prefix));
+  const next = lines
+    .map((l) => (allPrefixed ? l.slice(prefix.length) : prefix + l))
+    .join("\n");
+  return {
+    value: value.slice(0, blockStart) + next + value.slice(blockEnd),
+    selStart: blockStart,
+    selEnd: blockStart + next.length,
+  };
+}
+
+/**
+ * Wrap the selection as a Markdown link `[text](url)`. With a non-empty
+ * selection it becomes the link text and the `url` placeholder is selected;
+ * with no selection a `text` placeholder is selected so the user can type it.
+ */
+export function makeLink(value: string, start: number, end: number): EditResult {
+  const sel = value.slice(start, end);
+  const before = value.slice(0, start);
+  const after = value.slice(end);
+  if (sel) {
+    const inserted = `[${sel}](url)`;
+    const urlStart = start + sel.length + 3; // after "[sel]("
+    return { value: before + inserted + after, selStart: urlStart, selEnd: urlStart + 3 };
+  }
+  const inserted = "[text](url)";
+  return { value: before + inserted + after, selStart: start + 1, selEnd: start + 5 };
+}
+
+/** GitHub-style heading slug: lowercase, drop punctuation, spaces → dashes. */
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, "")
+    .replace(/\s+/g, "-");
+}
+
+interface Heading {
+  level: number;
+  title: string;
+}
+
+/** Collect ATX (`#`) headings in document order, skipping fenced code blocks. */
+function collectHeadings(markdown: string): Heading[] {
+  const out: Heading[] = [];
+  let inFence = false;
+  let fence = "";
+  for (const raw of markdown.split("\n")) {
+    const line = raw.trimEnd();
+    const fenceMatch = line.match(/^\s*(```+|~~~+)/);
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true;
+        fence = fenceMatch[1][0];
+      } else if (line.trimStart().startsWith(fence)) {
+        inFence = false;
+      }
+      continue;
+    }
+    if (inFence) continue;
+    const m = line.match(/^(#{1,6})\s+(.*)$/);
+    if (m && m[2].trim()) out.push({ level: m[1].length, title: m[2].trim() });
+  }
+  return out;
+}
+
+/**
+ * Generate a Markdown table-of-contents list from the document's ATX headings,
+ * nested by level (relative to the shallowest heading) and linking to each
+ * heading's GitHub-style anchor. Returns an empty string when there are no
+ * headings.
+ */
+export function generateToc(markdown: string): string {
+  const headings = collectHeadings(markdown);
+  if (headings.length === 0) return "";
+  const min = Math.min(...headings.map((h) => h.level));
+  const seen = new Map<string, number>();
+  return headings
+    .map((h) => {
+      const base = slugify(h.title);
+      // De-dupe repeated headings the way GitHub does: append -1, -2, …
+      const n = seen.get(base) ?? 0;
+      seen.set(base, n + 1);
+      const anchor = n === 0 ? base : `${base}-${n}`;
+      const indent = "  ".repeat(h.level - min);
+      return `${indent}- [${h.title}](#${anchor})`;
+    })
+    .join("\n");
+}
diff --git a/src/lib/viewers/markdownEnrich.ts b/src/lib/viewers/markdownEnrich.ts
new file mode 100644
index 0000000..64c65c1
--- /dev/null
+++ b/src/lib/viewers/markdownEnrich.ts
@@ -0,0 +1,91 @@
+/**
+ * Mermaid + KaTeX enrichment for the markdown preview (Dev A).
+ *
+ * `renderMarkdown` (markdown.ts) stays a dependency-free, escape-first HTML
+ * renderer. The heavyweight diagram/math libraries live HERE and run as a
+ * post-render DOM pass: after the preview HTML is committed, `enrichMarkdownDom`
+ * walks the container, finds the placeholders renderMarkdown emitted, and
+ * renders them in place with `mermaid` / `katex`.
+ *
+ * Contract (do not change without updating markdown.ts + the MarkdownView call
+ * site in FileViewerPane.tsx):
+ *   - Mermaid: a fenced ```mermaid block renders to
+ *       <pre class="md-code" data-lang="mermaid"><code …>SOURCE</code></pre>
+ *     (the existing renderCodeBlock output, since "mermaid" is not a highlight
+ *     language). This pass replaces such <pre> nodes with the rendered SVG.
+ *   - Math: markdown.ts (Dev A) emits inline `$…$` as
+ *       <span class="md-math" data-display="false">ESCAPED_TEX</span>
+ *     and block `$$…$$` as
+ *       <span class="md-math" data-display="true">ESCAPED_TEX</span>.
+ *     This pass reads each node's textContent and renders it with KaTeX.
+ *
+ * SECURITY: KaTeX runs with `trust: false` / `throwOnError: false`; mermaid with
+ * `securityLevel: "strict"`. Both consume already-escaped text content (never
+ * raw HTML from the document), preserving the repo's escape-first invariant.
+ *
+ * IDEMPOTENCY: the effect re-runs whenever the draft changes, so every node is
+ * tagged with a `data-*` flag once handled and skipped on subsequent passes.
+ */
+
+import mermaid from "mermaid";
+import katex from "katex";
+import "katex/dist/katex.min.css";
+
+// Initialize mermaid once at module load. `startOnLoad:false` keeps mermaid from
+// scanning the DOM on its own — we drive rendering explicitly per <pre> node.
+// `securityLevel:"strict"` sanitizes the generated SVG (no inline scripts/HTML).
+mermaid.initialize({ startOnLoad: false, securityLevel: "strict", theme: "default" });
+
+// Module-scoped counter for unique mermaid render ids (mermaid needs a DOM-safe,
+// unique id per render). A monotonic counter avoids Date.now()/random collisions.
+let mermaidSeq = 0;
+
+function escapeText(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+async function renderMermaid(container: HTMLElement): Promise<void> {
+  const blocks = container.querySelectorAll<HTMLElement>(
+    'pre.md-code[data-lang="mermaid"]:not([data-mermaid-done])',
+  );
+  for (const pre of Array.from(blocks)) {
+    // Mark first so a thrown render (below) still flags the node and re-runs
+    // don't retry a permanently-broken diagram.
+    pre.setAttribute("data-mermaid-done", "");
+    const code = pre.querySelector("code");
+    const source = code?.textContent ?? "";
+    const div = document.createElement("div");
+    div.className = "md-mermaid";
+    try {
+      const { svg } = await mermaid.render(`md-mermaid-${mermaidSeq++}`, source);
+      div.innerHTML = svg;
+    } catch (err) {
+      // Leave a small, escaped error note in place of the diagram.
+      const msg = err instanceof Error ? err.message : String(err);
+      div.innerHTML = `<span class="md-mermaid-error">Mermaid error: ${escapeText(msg)}</span>`;
+    }
+    pre.replaceWith(div);
+  }
+}
+
+function renderMath(container: HTMLElement): void {
+  const spans = container.querySelectorAll<HTMLElement>(
+    "span.md-math:not([data-math-done])",
+  );
+  for (const span of Array.from(spans)) {
+    span.setAttribute("data-math-done", "");
+    const tex = span.textContent ?? "";
+    const displayMode = span.dataset.display === "true";
+    // throwOnError:false makes KaTeX render an error indicator inline rather
+    // than throw, so a single bad expression doesn't break the whole preview.
+    katex.render(tex, span, { displayMode, throwOnError: false, trust: false });
+  }
+}
+
+export async function enrichMarkdownDom(container: HTMLElement): Promise<void> {
+  renderMath(container);
+  await renderMermaid(container);
+}
diff --git a/src/lib/viewers/notebook.ts b/src/lib/viewers/notebook.ts
new file mode 100644
index 0000000..f313266
--- /dev/null
+++ b/src/lib/viewers/notebook.ts
@@ -0,0 +1,147 @@
+/**
+ * Pure, dependency-free parsing for the built-in Jupyter `.ipynb` viewer
+ * (TODO Group K #40, new viewers). It turns an nbformat v4 notebook (JSON string
+ * or already-parsed object) into a small, render-ready shape — a list of
+ * markdown/code cells, code cells carrying classified output blocks.
+ *
+ * Scope is deliberately a focused nbformat v4 subset: enough to render a
+ * notebook readably, not to round-trip it. Anything we don't understand is
+ * skipped rather than guessed at.
+ *
+ * SECURITY: this module produces only plain strings and base64 blobs — never
+ * HTML. The viewer is responsible for escaping/sanitizing before rendering.
+ * Critically, notebook `text/html` outputs are NEVER surfaced here (they would
+ * be attacker-controlled HTML); only `text/plain`, `image/png`, stream text, and
+ * error tracebacks are emitted. Stream/error text is ANSI-stripped here so the
+ * viewer's escaping isn't fed raw escape sequences.
+ */
+
+export interface NbCell {
+  type: "markdown" | "code";
+  source: string;
+  /** Present (possibly empty) for code cells; absent for markdown cells. */
+  outputs?: NbOutput[];
+}
+
+export interface NbOutput {
+  kind: "text" | "image";
+  /** Set for `kind: "text"` — already ANSI-stripped, NOT yet HTML-escaped. */
+  text?: string;
+  /** Set for `kind: "image"` — a base64 PNG payload, as stored in the notebook. */
+  pngBase64?: string;
+}
+
+export interface ParsedNotebook {
+  language: string;
+  cells: NbCell[];
+}
+
+/**
+ * Strip ANSI SGR / CSI escape sequences from `s`. nbformat stream and error
+ * outputs commonly embed colour codes (`\x1b[0;31m`); we render them as plain
+ * text, so the codes are noise. Covers CSI sequences (`\x1b[ ... <final>`),
+ * which subsumes the common `\x1b[0;31m` colour form.
+ */
+export function stripAnsi(s: string): string {
+  // eslint-disable-next-line no-control-regex
+  return s.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "");
+}
+
+/** Join an nbformat `source`/`text` value, which is either a string or an array
+ *  of line strings (each usually keeping its trailing newline), into one string. */
+function joinSource(src: unknown): string {
+  if (Array.isArray(src)) return src.map((s) => (typeof s === "string" ? s : "")).join("");
+  return typeof src === "string" ? src : "";
+}
+
+/**
+ * Classify a single nbformat output object into zero or more render blocks:
+ *  - `stream`        → one text block from `out.text` (ANSI-stripped).
+ *  - `execute_result`/`display_data` → an `image/png` block if present, else a
+ *    `text/plain` block. `text/html` is intentionally SKIPPED (untrusted HTML).
+ *  - `error`         → one text block from the joined `out.traceback`
+ *    (ANSI-stripped — tracebacks carry colour codes).
+ *  - anything else   → no blocks.
+ */
+export function outputToBlocks(out: any): NbOutput[] {
+  if (!out || typeof out !== "object") return [];
+  switch (out.output_type) {
+    case "stream":
+      return [{ kind: "text", text: stripAnsi(joinSource(out.text)) }];
+    case "execute_result":
+    case "display_data": {
+      const data = out.data ?? {};
+      const png = data["image/png"];
+      if (typeof png === "string" && png) {
+        // nbformat stores image/png base64 either as one string or split lines.
+        return [{ kind: "image", pngBase64: png }];
+      }
+      if (Array.isArray(png) && png.length) {
+        return [{ kind: "image", pngBase64: png.join("") }];
+      }
+      const plain = data["text/plain"];
+      if (plain != null) {
+        return [{ kind: "text", text: stripAnsi(joinSource(plain)) }];
+      }
+      // text/html (and other rich types) deliberately skipped.
+      return [];
+    }
+    case "error":
+      return [{ kind: "text", text: stripAnsi(joinSource(out.traceback)) }];
+    default:
+      return [];
+  }
+}
+
+/**
+ * Parse a notebook (JSON string or already-parsed object) into a
+ * `ParsedNotebook`. Tolerant of a missing/odd shape: a parse failure or a
+ * non-object yields an empty notebook rather than throwing.
+ *
+ *  - Cell `source` arrays are joined into a single string.
+ *  - Kernel language comes from `metadata.kernelspec.language`, else
+ *    `metadata.language_info.name`, defaulting to `"python"`.
+ *  - `markdown`/`code` cells are kept; `raw` cells are rendered as markdown-typed
+ *    plain text (their source carried through verbatim) so their content is not
+ *    silently lost; all other cell types are dropped.
+ */
+export function parseNotebook(json: string | object): ParsedNotebook {
+  let nb: any;
+  if (typeof json === "string") {
+    try {
+      nb = JSON.parse(json);
+    } catch {
+      return { language: "python", cells: [] };
+    }
+  } else {
+    nb = json;
+  }
+  if (!nb || typeof nb !== "object") return { language: "python", cells: [] };
+
+  const meta = nb.metadata ?? {};
+  const language =
+    (meta.kernelspec && typeof meta.kernelspec.language === "string" && meta.kernelspec.language) ||
+    (meta.language_info && typeof meta.language_info.name === "string" && meta.language_info.name) ||
+    "python";
+
+  const rawCells = Array.isArray(nb.cells) ? nb.cells : [];
+  const cells: NbCell[] = [];
+  for (const cell of rawCells) {
+    if (!cell || typeof cell !== "object") continue;
+    const source = joinSource(cell.source);
+    if (cell.cell_type === "code") {
+      const rawOutputs = Array.isArray(cell.outputs) ? cell.outputs : [];
+      const outputs = rawOutputs.flatMap((o: any) => outputToBlocks(o));
+      cells.push({ type: "code", source, outputs });
+    } else if (cell.cell_type === "markdown") {
+      cells.push({ type: "markdown", source });
+    } else if (cell.cell_type === "raw") {
+      // Surface raw cells as plain markdown text rather than dropping them; their
+      // source is escaped by the markdown renderer downstream.
+      cells.push({ type: "markdown", source });
+    }
+    // unknown cell types: dropped.
+  }
+
+  return { language, cells };
+}
diff --git a/src/lib/viewers/odt.ts b/src/lib/viewers/odt.ts
new file mode 100644
index 0000000..68109ce
--- /dev/null
+++ b/src/lib/viewers/odt.ts
@@ -0,0 +1,306 @@
+/**
+ * Lightweight OpenDocument Text (`.odt`) → HTML rendering (#51).
+ *
+ * An `.odt` is a ZIP holding `content.xml` (the document body as ODF XML),
+ * `styles.xml`, and embedded images under `Pictures/`. This module is the pure,
+ * framework-free half: it turns the *already-unzipped* archive into safe HTML.
+ * The ZIP is opened by `OdtView` (via fflate), which hands the raw entry map to
+ * `extractOdt`; keeping fflate out of here means the transform is unit-testable
+ * with a plain `content.xml` string and no real archive.
+ *
+ * Scope is deliberately a readable v1 subset: headings, paragraphs, bold/italic/
+ * underline runs, hyperlinks, ordered/unordered lists, tables, inline images,
+ * line breaks, tabs and explicit spaces. Anything unrecognised degrades to its
+ * inner text rather than failing. "Open externally" remains the faithful path.
+ *
+ * SECURITY: the returned HTML is assembled here tag-by-tag from a fixed
+ * whitelist. Every run of document text and every attribute value is escaped
+ * (`esc`/`escAttr`); no ODF-supplied markup is ever passed through, hyperlink
+ * hrefs are protocol-filtered, and image `src`s are `data:` URLs built from the
+ * archive's own bytes. The result is therefore safe to inject with
+ * `dangerouslySetInnerHTML`, matching the no-DOMPurify policy the other viewers
+ * follow (see NotebookView).
+ */
+
+/** Escape text for HTML body context (mirrors `escapeHtmlText` in the viewer). */
+function esc(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+/** Escape a value destined for a double-quoted HTML attribute. */
+function escAttr(s: string): string {
+  return esc(s).replace(/"/g, "&quot;");
+}
+
+/** Map a `Pictures/…` entry name to an image MIME type by extension. */
+function imageMime(name: string): string {
+  const ext = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
+  switch (ext) {
+    case "png": return "image/png";
+    case "jpg":
+    case "jpeg": return "image/jpeg";
+    case "gif": return "image/gif";
+    case "webp": return "image/webp";
+    case "bmp": return "image/bmp";
+    case "svg": return "image/svg+xml";
+    default: return "application/octet-stream";
+  }
+}
+
+/** Base64-encode bytes in chunks so a large image can't blow the call stack of a
+ *  single `String.fromCharCode(...)` spread. */
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = "";
+  const chunk = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+
+/**
+ * Pull the renderable pieces out of an unzipped `.odt`: the `content.xml` text
+ * and a map from each embedded image's archive path (e.g. `Pictures/100.png`,
+ * the exact `xlink:href` ODF uses) to a `data:` URL. Throws when `content.xml`
+ * is absent (not an ODF document). Accepts a plain `Record` so tests can pass a
+ * hand-built map without fflate.
+ */
+export function extractOdt(
+  entries: Record<string, Uint8Array>,
+): { contentXml: string; images: Map<string, string> } {
+  const contentBytes = entries["content.xml"];
+  if (!contentBytes) {
+    throw new Error("not an OpenDocument file (missing content.xml)");
+  }
+  const contentXml = new TextDecoder("utf-8").decode(contentBytes);
+  const images = new Map<string, string>();
+  for (const [name, bytes] of Object.entries(entries)) {
+    if (name.startsWith("Pictures/") && bytes.length > 0) {
+      images.set(name, `data:${imageMime(name)};base64,${bytesToBase64(bytes)}`);
+    }
+  }
+  return { contentXml, images };
+}
+
+/** Inline character formatting resolved from an automatic text style. */
+interface TextFmt {
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+}
+
+/** First attribute whose *local* name matches, ignoring the namespace prefix —
+ *  ODF attributes are prefixed (`fo:font-weight`, `xlink:href`, …) and the
+ *  prefix is not guaranteed, so we match on local name only. */
+function attr(el: Element, local: string): string | null {
+  for (const a of Array.from(el.attributes)) {
+    if (a.localName === local) return a.value;
+  }
+  return null;
+}
+
+/** All descendant elements with the given local name, prefix-agnostic. */
+function byLocal(root: Element, local: string): Element[] {
+  const out: Element[] = [];
+  const walk = (el: Element) => {
+    for (const child of Array.from(el.children)) {
+      if (child.localName === local) out.push(child);
+      walk(child);
+    }
+  };
+  walk(root);
+  return out;
+}
+
+/** First child element with the given local name, or null. */
+function firstChild(el: Element, local: string): Element | null {
+  for (const child of Array.from(el.children)) {
+    if (child.localName === local) return child;
+  }
+  return null;
+}
+
+/** Build `style:name → TextFmt` from the document's automatic text styles. */
+function collectTextStyles(root: Element): Map<string, TextFmt> {
+  const map = new Map<string, TextFmt>();
+  for (const st of byLocal(root, "style")) {
+    if (attr(st, "family") !== "text") continue;
+    const name = attr(st, "name");
+    if (!name) continue;
+    const tp = firstChild(st, "text-properties");
+    if (!tp) continue;
+    const fmt: TextFmt = {};
+    if (attr(tp, "font-weight") === "bold") fmt.bold = true;
+    if (attr(tp, "font-style") === "italic") fmt.italic = true;
+    const ul = attr(tp, "text-underline-style");
+    if (ul && ul !== "none") fmt.underline = true;
+    map.set(name, fmt);
+  }
+  return map;
+}
+
+/** Build `style:name → "ol" | "ul"` from the document's list styles (a list is
+ *  ordered when its first level is a number style, else bulleted). */
+function collectListStyles(root: Element): Map<string, "ol" | "ul"> {
+  const map = new Map<string, "ol" | "ul">();
+  for (const ls of byLocal(root, "list-style")) {
+    const name = attr(ls, "name");
+    if (!name) continue;
+    const firstLevel = Array.from(ls.children)[0];
+    const ordered = firstLevel?.localName === "list-level-style-number";
+    map.set(name, ordered ? "ol" : "ul");
+  }
+  return map;
+}
+
+/** Allow only safe, non-script hyperlink targets. */
+function safeHref(href: string | null): string | null {
+  if (!href) return null;
+  const trimmed = href.trim();
+  return /^(https?:|mailto:|#)/i.test(trimmed) ? trimmed : null;
+}
+
+/**
+ * Render the `content.xml` of an `.odt` to a sanitised HTML fragment. `images`
+ * maps each embedded image's `xlink:href` to a `data:` URL (from `extractOdt`);
+ * omit it and images are dropped. Throws on XML that fails to parse or that has
+ * no document body.
+ */
+export function renderOdtDocument(
+  contentXml: string,
+  opts: { images?: Map<string, string> } = {},
+): string {
+  const images = opts.images;
+  const doc = new DOMParser().parseFromString(contentXml, "application/xml");
+  if (doc.getElementsByTagName("parsererror").length > 0 || !doc.documentElement) {
+    throw new Error("could not parse the document XML");
+  }
+  const root = doc.documentElement;
+  const body = byLocal(root, "text")[0]; // <office:text>
+  if (!body) throw new Error("no document body found");
+
+  const textStyles = collectTextStyles(root);
+  const listStyles = collectListStyles(root);
+
+  const renderImage = (imgEl: Element): string => {
+    const href = attr(imgEl, "href");
+    if (!href) return "";
+    const url = images?.get(href) ?? images?.get(href.replace(/^\.\//, ""));
+    return url ? `<img class="odt-image" src="${escAttr(url)}" alt="" />` : "";
+  };
+
+  const inlineChildren = (el: Element): string => {
+    let out = "";
+    for (const child of Array.from(el.childNodes)) out += renderInline(child);
+    return out;
+  };
+
+  function renderInline(node: Node): string {
+    if (node.nodeType === 3 /* text */) return esc(node.nodeValue ?? "");
+    if (node.nodeType !== 1 /* element */) return "";
+    const el = node as Element;
+    switch (el.localName) {
+      case "span": {
+        const fmt = textStyles.get(attr(el, "style-name") ?? "") ?? {};
+        let inner = inlineChildren(el);
+        if (fmt.underline) inner = `<u>${inner}</u>`;
+        if (fmt.italic) inner = `<em>${inner}</em>`;
+        if (fmt.bold) inner = `<strong>${inner}</strong>`;
+        return inner;
+      }
+      case "a": {
+        const href = safeHref(attr(el, "href"));
+        const inner = inlineChildren(el);
+        return href
+          ? `<a href="${escAttr(href)}" target="_blank" rel="noreferrer noopener">${inner}</a>`
+          : inner;
+      }
+      case "line-break":
+        return "<br/>";
+      case "tab":
+        return "    ";
+      case "s": {
+        const count = Math.max(1, parseInt(attr(el, "c") ?? "1", 10) || 1);
+        return " ".repeat(count);
+      }
+      case "frame": {
+        const img = byLocal(el, "image")[0];
+        return img ? renderImage(img) : inlineChildren(el);
+      }
+      case "image":
+        return renderImage(el);
+      default:
+        // Unknown inline wrapper: keep its text content.
+        return inlineChildren(el);
+    }
+  }
+
+  const renderListItem = (item: Element): string => {
+    let out = "";
+    for (const child of Array.from(item.children)) {
+      if (child.localName === "list") out += renderList(child);
+      else out += renderInline(child); // a <text:p> renders as inline li content
+    }
+    return `<li>${out}</li>`;
+  };
+
+  function renderList(el: Element): string {
+    const kind = listStyles.get(attr(el, "style-name") ?? "") ?? "ul";
+    let items = "";
+    for (const child of Array.from(el.children)) {
+      if (child.localName === "list-item") items += renderListItem(child);
+    }
+    return `<${kind}>${items}</${kind}>`;
+  }
+
+  const renderTable = (el: Element): string => {
+    const rowsFrom = (parent: Element): string => {
+      let rows = "";
+      for (const child of Array.from(parent.children)) {
+        if (child.localName === "table-header-rows") {
+          rows += rowsFrom(child);
+        } else if (child.localName === "table-row") {
+          let cells = "";
+          for (const cell of Array.from(child.children)) {
+            if (cell.localName === "table-cell") {
+              cells += `<td>${renderBlocks(cell)}</td>`;
+            }
+          }
+          rows += `<tr>${cells}</tr>`;
+        }
+      }
+      return rows;
+    };
+    return `<table class="odt-table"><tbody>${rowsFrom(el)}</tbody></table>`;
+  };
+
+  function renderBlocks(parent: Element): string {
+    let out = "";
+    for (const child of Array.from(parent.children)) {
+      switch (child.localName) {
+        case "h": {
+          const n = parseInt(attr(child, "outline-level") ?? "1", 10);
+          const lvl = Math.min(6, Math.max(1, Number.isNaN(n) ? 1 : n));
+          out += `<h${lvl}>${renderInline(child)}</h${lvl}>`;
+          break;
+        }
+        case "p":
+          out += `<p>${inlineChildren(child)}</p>`;
+          break;
+        case "list":
+          out += renderList(child);
+          break;
+        case "table":
+          out += renderTable(child);
+          break;
+        default:
+          // Wrappers like <text:section> / <text:soft-page-break>: recurse so
+          // their block children still render.
+          if (child.children.length > 0) out += renderBlocks(child);
+      }
+    }
+    return out;
+  }
+
+  return renderBlocks(body);
+}
diff --git a/src/lib/viewers/pageModel.ts b/src/lib/viewers/pageModel.ts
new file mode 100644
index 0000000..b89c8af
--- /dev/null
+++ b/src/lib/viewers/pageModel.ts
@@ -0,0 +1,143 @@
+/**
+ * The page-arrangement model shared by the print preview and the PDF viewer's
+ * page rail.
+ *
+ * An arrangement is a plain ordered list of {@link PageRef}s — one entry per sheet,
+ * in the order it appears. Every operation is pure and returns a new list, so a
+ * history stack is just an array of lists, and rendering is a straight map.
+ *
+ * Each entry carries its OWN id, source and rotation. That is the whole point, and
+ * it is what the print preview's earlier model (`order: number[]` plus rotations
+ * keyed by original page number) could not express:
+ *
+ *   - `src` lets one arrangement draw pages from SEVERAL documents, which is what
+ *     merging a second PDF needs.
+ *   - `rot` per entry lets a duplicated page be turned independently of its twin;
+ *     keyed by original page number, both copies would have turned together.
+ *   - the operations take a SET of ids, so a multi-selection moves as one block.
+ *
+ * The print preview is the degenerate case: every entry has `src === SELF`, and the
+ * list starts as the identity mapping over the document's own pages.
+ */
+
+/** Which document an entry's page comes from. */
+export type SourceId = string;
+
+/** The source id of the document the arrangement belongs to (the file on disk). */
+export const SELF: SourceId = "self";
+
+/** A quarter-turn multiple. Anything else is not representable in a PDF's /Rotate. */
+export type Rotation = 0 | 90 | 180 | 270;
+
+/** One sheet in an arrangement: a 1-based page of some source, at some rotation. */
+export interface PageRef {
+  /** Unique within its list, and stable across moves — selection keys off it. */
+  id: string;
+  src: SourceId;
+  /** 1-based page number *within `src`*. */
+  page: number;
+  rot: Rotation;
+}
+
+/** An arrangement: the sheets, in order. The single source of truth. */
+export type PageList = PageRef[];
+
+// Ids only have to be unique within one list, so a counter is enough — and unlike a
+// random id it keeps tests readable and diffs stable.
+let nextId = 0;
+
+/** A fresh entry id. */
+export function newPageId(): string {
+  nextId += 1;
+  return `p${nextId}`;
+}
+
+/** The identity arrangement over a document's own pages — the starting point. */
+export function initialPages(pageCount: number, src: SourceId = SELF): PageList {
+  return Array.from({ length: Math.max(0, pageCount) }, (_, i) => ({
+    id: newPageId(),
+    src,
+    page: i + 1,
+    rot: 0 as Rotation,
+  }));
+}
+
+/** Build entries for `pageCount` pages of `src` — the pages a merge splices in. */
+export function pagesOf(src: SourceId, pageCount: number): PageList {
+  return initialPages(pageCount, src);
+}
+
+/**
+ * Move every entry in `ids` so the block lands at `toIndex`.
+ *
+ * `toIndex` counts the entries that are NOT being moved — it is an index into the
+ * list with the selection already taken out ("insert before the `toIndex`-th
+ * survivor"; `>= survivors` appends). That is the index a drag naturally produces,
+ * because the dragged cards are exactly the ones the pointer is not hit-testing
+ * against, and it is the convention the print strip has always used.
+ *
+ * The moved entries keep their relative order, so dragging a multi-selection moves
+ * it as a block rather than collapsing it.
+ */
+export function movePages(list: PageList, ids: readonly string[], toIndex: number): PageList {
+  const moving = new Set(ids);
+  const selected = list.filter((r) => moving.has(r.id));
+  if (selected.length === 0) return [...list];
+  const rest = list.filter((r) => !moving.has(r.id));
+  const at = Math.min(Math.max(toIndex, 0), rest.length);
+  return [...rest.slice(0, at), ...selected, ...rest.slice(at)];
+}
+
+/** Drop every entry in `ids`. Unknown ids are ignored. */
+export function deletePages(list: PageList, ids: readonly string[]): PageList {
+  const dropping = new Set(ids);
+  return list.filter((r) => !dropping.has(r.id));
+}
+
+/**
+ * Turn every entry in `ids` by `by` degrees (default a quarter turn clockwise).
+ * Wraps, so four turns is a full circle back to upright.
+ */
+export function rotatePages(list: PageList, ids: readonly string[], by = 90): PageList {
+  const turning = new Set(ids);
+  return list.map((r) =>
+    turning.has(r.id)
+      ? { ...r, rot: ((((r.rot + by) % 360) + 360) % 360) as Rotation }
+      : r,
+  );
+}
+
+/**
+ * Copy every entry in `ids`, placing each copy right after its original. Copies get
+ * fresh ids, so they select, move and rotate independently of the pages they came
+ * from.
+ */
+export function duplicatePages(list: PageList, ids: readonly string[]): PageList {
+  const copying = new Set(ids);
+  return list.flatMap((r) =>
+    copying.has(r.id) ? [r, { ...r, id: newPageId() }] : [r],
+  );
+}
+
+/**
+ * Splice `refs` in before the entry at `atIndex` (`>= list.length` appends). The
+ * refs are re-id'd, so inserting the same pages twice — or pages that came from
+ * this very list — never collides.
+ */
+export function insertPages(list: PageList, refs: PageList, atIndex: number): PageList {
+  const at = Math.min(Math.max(atIndex, 0), list.length);
+  const fresh = refs.map((r) => ({ ...r, id: newPageId() }));
+  return [...list.slice(0, at), ...fresh, ...list.slice(at)];
+}
+
+/**
+ * True when `list` is still the untouched identity arrangement over a `pageCount`-page
+ * document: same length, original order, nothing turned, nothing merged in. Drives
+ * the "Reset pages" affordance and the viewer's dirty marker.
+ */
+export function isPristine(list: PageList, pageCount: number): boolean {
+  return (
+    list.length === pageCount &&
+    list.every((r, i) => r.src === SELF && r.page === i + 1 && r.rot === 0)
+  );
+}
diff --git a/src/lib/viewers/print.ts b/src/lib/viewers/print.ts
new file mode 100644
index 0000000..8e46e11
--- /dev/null
+++ b/src/lib/viewers/print.ts
@@ -0,0 +1,814 @@
+// Frontend-only print pipeline for the in-app file viewers.
+//
+// The strategy is deliberately dependency-free: instead of generating a PDF on
+// disk, each viewer renders the content it already has into a clean, paginated
+// standalone HTML document, which we drop into an off-screen iframe and hand to
+// the platform's own `window.print()`. The native (GTK/WebKit) print dialog then
+// lets the user send it to a printer OR "Print to File → PDF" — so for plain text
+// and Markdown this *is* the "transform to PDF before printing" step, with no
+// backend and no new dependency.
+//
+// WebKitGTK has no built-in PDF engine (that's why the app renders PDFs with
+// pdf.js onto <canvas>), so a PDF can't be printed by feeding the file to an
+// iframe. `renderPdfToPrintImages` re-renders the already-open pages to images
+// which then print through the same path as everything else.
+
+import { createElement } from "react";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import { initialPages, isPristine, type PageList } from "./pageModel";
+import {
+  mountPageStrip,
+  type MountedPageStrip,
+} from "../../components/common/mountPageStrip";
+import type { PageStripProps } from "../../components/common/PageStrip";
+
+// ── Print options ────────────────────────────────────────────────────────────
+// The preview overlay exposes the options a printer dialog normally would. They
+// are applied by injecting one stylesheet into the *already-loaded* preview
+// document (see `printDocument`) rather than by rebuilding it: the HTML/SVG/CSS
+// viewer prints a document Eldrun did not assemble (`buildPreviewDoc`), and an
+// injected sheet reaches that one too — and never costs an iframe reload.
+
+export type PaperSize = "A4" | "Letter" | "Legal" | "A3" | "A5";
+export type Orientation = "portrait" | "landscape";
+export type MarginPreset = "none" | "narrow" | "normal" | "wide";
+export type PageSelection = "all" | "odd" | "even" | "custom";
+
+export interface PrintOptions {
+  paper: PaperSize;
+  orientation: Orientation;
+  margin: MarginPreset;
+  /** Percent; the printer-dialog "Scale" equivalent. */
+  scale: number;
+  pages: PageSelection;
+  /** Custom page spec, e.g. "1-3, 5". Only read when `pages === "custom"`. */
+  range: string;
+  grayscale: boolean;
+  /** Print background colors/images (off saves ink). */
+  background: boolean;
+  /** Footer page numbers; only possible on page-based documents (see below). */
+  pageNumbers: boolean;
+}
+
+/** Paper dimensions in cm, portrait (width × height). */
+export const PAPER_CM: Record<PaperSize, readonly [number, number]> = {
+  A3: [29.7, 42],
+  A4: [21, 29.7],
+  A5: [14.8, 21],
+  Letter: [21.59, 27.94],
+  Legal: [21.59, 35.56],
+};
+
+/** Margin presets in cm. `normal` matches the padding the viewers hardcoded. */
+export const MARGIN_CM: Record<MarginPreset, number> = {
+  none: 0,
+  narrow: 1.27,
+  normal: 2.54,
+  wide: 3.81,
+};
+
+export const SCALE_CHOICES = [50, 75, 90, 100, 110, 125, 150, 200] as const;
+
+export const DEFAULT_PRINT_OPTIONS: PrintOptions = {
+  paper: "A4",
+  orientation: "portrait",
+  margin: "normal",
+  scale: 100,
+  pages: "all",
+  range: "",
+  grayscale: false,
+  background: true,
+  pageNumbers: false,
+};
+
+/** Sheet box in cm for the chosen paper + orientation (landscape swaps them). */
+export function pageBoxCm(opts: PrintOptions): [number, number] {
+  const [w, h] = PAPER_CM[opts.paper] ?? PAPER_CM.A4;
+  return opts.orientation === "landscape" ? [h, w] : [w, h];
+}
+
+/** The printable box in cm: the sheet minus the margin on each side. */
+export function contentBoxCm(opts: PrintOptions): [number, number] {
+  const [w, h] = pageBoxCm(opts);
+  const m = MARGIN_CM[opts.margin] ?? MARGIN_CM.normal;
+  return [round2(Math.max(1, w - 2 * m)), round2(Math.max(1, h - 2 * m))];
+}
+
+/**
+ * Thumbnail box in px for the strip, in the sheet's own proportions — so a
+ * landscape sheet gets a landscape card rather than an upright one. Height is
+ * fixed so the strip keeps a single row height; the width follows the aspect.
+ */
+export function thumbSizePx(opts: PrintOptions, height = 84): [number, number] {
+  const [w, h] = pageBoxCm(opts);
+  return [Math.round((height * w) / h), height];
+}
+
+/**
+ * Parse a printer-style page spec ("1-3, 5", "2 4", "7-") against a known page
+ * count. Deliberately tolerant — it runs on every keystroke of the range input,
+ * so garbage is dropped rather than thrown. Result is clamped to 1..total,
+ * deduped and sorted.
+ */
+export function parsePageRange(spec: string, total: number): number[] {
+  const pages = new Set<number>();
+  if (total <= 0) return [];
+  for (const part of spec.split(/[,;\s]+/)) {
+    if (!part) continue;
+    const m = /^(\d*)(-?)(\d*)$/.exec(part);
+    if (!m || (!m[1] && !m[3])) continue;
+    const open = m[2] === "-";
+    let lo = m[1] ? Number(m[1]) : open ? 1 : NaN;
+    let hi = open ? (m[3] ? Number(m[3]) : total) : lo;
+    if (!Number.isFinite(lo) || !Number.isFinite(hi)) continue;
+    if (lo > hi) [lo, hi] = [hi, lo];
+    for (let p = Math.max(1, lo); p <= Math.min(total, hi); p++) pages.add(p);
+  }
+  return [...pages].sort((a, b) => a - b);
+}
+
+/** The 1-based pages the current options select out of `total`. */
+export function selectedPages(opts: PrintOptions, total: number): number[] {
+  if (total <= 0) return [];
+  const all = Array.from({ length: total }, (_, i) => i + 1);
+  switch (opts.pages) {
+    case "odd":
+      return all.filter((p) => p % 2 === 1);
+    case "even":
+      return all.filter((p) => p % 2 === 0);
+    case "custom":
+      return parsePageRange(opts.range, total);
+    default:
+      return all;
+  }
+}
+
+// ── Page arrangement ─────────────────────────────────────────────────────────
+// The arrangement itself lives in `lib/viewers/pageModel` — the same model the PDF
+// viewer's page rail edits, so reordering/deleting/turning pages behaves identically
+// in both places. Only the *print* reading of it belongs here.
+
+/**
+ * The sheets that will actually print, in print order: the arrangement, filtered by
+ * the page selection. The selection counts *positions* in the current arrangement
+ * (so "1-3" means the first three sheets as shown), which is the only reading that
+ * stays meaningful once pages have been moved.
+ */
+export function printSequence(pages: PageList, opts: PrintOptions): PageList {
+  const positions = new Set(selectedPages(opts, pages.length));
+  return pages.filter((_, i) => positions.has(i + 1));
+}
+
+/**
+ * The stylesheet the options translate to, injected last into the print
+ * document so it overrides both the `buildPrintDoc` base and the caller's CSS.
+ *
+ * Margins are body padding and scale is `zoom` — NOT `@page{margin}` — because
+ * WebKitGTK does not implement the `@page` margin box (same reason the viewer
+ * stylesheets below set `body{padding}`; a bare `@page` margin prints
+ * edge-to-edge). On screen the sheet must stay true size while the content
+ * scales inside it (that is what a printer's scale does), so the sheet box is
+ * divided by the zoom factor, which then multiplies it back.
+ */
+export function buildOptionsCss(opts: PrintOptions): string {
+  const [w, h] = pageBoxCm(opts);
+  const pad = MARGIN_CM[opts.margin] ?? MARGIN_CM.normal;
+  const zoom = clampScale(opts.scale) / 100;
+  const sheetW = round2(w / zoom);
+  const sheetH = round2(h / zoom);
+
+  const css = [
+    `@page{size:${w}cm ${h}cm;margin:0}`,
+    `body{margin:0;padding:${pad}cm;zoom:${zoom};background:#fff}`,
+    `.eldrun-print-hidden{display:none!important}`,
+    // Screen-only: show the actual sheet on a backdrop, so the preview is WYSIWYG.
+    `@media screen{html{background:#3f4245;padding:18px 0}` +
+      `body{width:${sheetW}cm;min-height:${sheetH}cm;margin:0 auto;` +
+      `box-shadow:0 2px 12px rgba(0,0,0,.45)}}`,
+  ];
+
+  if (opts.grayscale) css.push(`body{filter:grayscale(1)}`);
+
+  if (opts.background) {
+    css.push(`body,body *{-webkit-print-color-adjust:exact;print-color-adjust:exact}`);
+  } else {
+    // Scoped to body's descendants so the sheet itself keeps its white/shadow.
+    css.push(
+      `body *{background:transparent!important;background-image:none!important;` +
+        `box-shadow:none!important}`,
+    );
+  }
+
+  // Per-page rotation (classes stamped on the page elements by printDocument).
+  // A quarter turn is the awkward one: `transform` does not change the layout
+  // box, so a rotated page would reserve its *unrotated* size and overflow the
+  // sheet. The page therefore becomes a fixed printable-height box and the image
+  // is centred out of flow inside it, pre-constrained to the *swapped* printable
+  // box — after the turn its bounding box is exactly the printable area.
+  const [cw, ch] = contentBoxCm(opts);
+  css.push(
+    `.print-page.eldrun-rot-90,.print-page.eldrun-rot-270{position:relative;height:${ch}cm}` +
+      `.print-page.eldrun-rot-90 img,.print-page.eldrun-rot-270 img{position:absolute;` +
+      `left:50%;top:50%;width:auto;height:auto;max-width:${ch}cm;max-height:${cw}cm}` +
+      `.print-page.eldrun-rot-90 img{transform:translate(-50%,-50%) rotate(90deg)}` +
+      `.print-page.eldrun-rot-270 img{transform:translate(-50%,-50%) rotate(270deg)}` +
+      `.print-page.eldrun-rot-180 img{transform:rotate(180deg)}`,
+  );
+
+  if (opts.pageNumbers) {
+    // A real running footer would need @page margin boxes, which WebKitGTK does
+    // not have — hence numbers are stamped onto the page elements themselves
+    // (`data-page`, set by printDocument) and exist only for paged documents.
+    css.push(
+      `.print-page{position:relative;padding-bottom:16px}` +
+        `.print-page::after{content:attr(data-page);position:absolute;` +
+        `left:0;right:0;bottom:0;text-align:center;color:#555;` +
+        `font:10px/1 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif}`,
+    );
+  }
+
+  return css.join("\n");
+}
+
+const STORAGE_KEY = "eldrun.print.options";
+
+/**
+ * Last used options, or the defaults. Never throws (private mode, junk JSON).
+ *
+ * The page *selection* is deliberately not restored: a range like "2-3" belongs
+ * to the document it was typed for, and silently re-applying it to the next file
+ * would drop pages the user never chose to drop. Printer settings (paper,
+ * margins, scale…) do carry over, which is what a printer dialog does.
+ */
+export function loadPrintOptions(): PrintOptions {
+  const stored = (() => {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      return raw ? sanitizePrintOptions(JSON.parse(raw)) : { ...DEFAULT_PRINT_OPTIONS };
+    } catch {
+      return { ...DEFAULT_PRINT_OPTIONS };
+    }
+  })();
+  return { ...stored, pages: DEFAULT_PRINT_OPTIONS.pages, range: DEFAULT_PRINT_OPTIONS.range };
+}
+
+export function savePrintOptions(opts: PrintOptions): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(opts));
+  } catch {
+    /* storage unavailable: options simply don't persist */
+  }
+}
+
+/** Coerce arbitrary stored JSON back into a valid `PrintOptions`. */
+export function sanitizePrintOptions(v: unknown): PrintOptions {
+  const o = (v && typeof v === "object" ? v : {}) as Partial<PrintOptions>;
+  const pick = <T extends string>(val: unknown, allowed: readonly T[], fallback: T): T =>
+    allowed.includes(val as T) ? (val as T) : fallback;
+  return {
+    paper: pick(o.paper, Object.keys(PAPER_CM) as PaperSize[], DEFAULT_PRINT_OPTIONS.paper),
+    orientation: pick(o.orientation, ["portrait", "landscape"], DEFAULT_PRINT_OPTIONS.orientation),
+    margin: pick(o.margin, ["none", "narrow", "normal", "wide"], DEFAULT_PRINT_OPTIONS.margin),
+    scale: clampScale(typeof o.scale === "number" ? o.scale : DEFAULT_PRINT_OPTIONS.scale),
+    pages: pick(o.pages, ["all", "odd", "even", "custom"], DEFAULT_PRINT_OPTIONS.pages),
+    range: typeof o.range === "string" ? o.range : "",
+    grayscale: o.grayscale === true,
+    background: o.background !== false,
+    pageNumbers: o.pageNumbers === true,
+  };
+}
+
+function clampScale(n: number): number {
+  if (!Number.isFinite(n)) return 100;
+  return Math.min(400, Math.max(10, Math.round(n)));
+}
+
+function round2(n: number): number {
+  return Math.round(n * 100) / 100;
+}
+
+/**
+ * Assemble a complete, self-contained print document. Pure (no DOM), so the
+ * scaffolding + escaping is unit-testable. `bodyHtml` is trusted markup the
+ * caller has already sanitised/escaped; `css` is inlined into a <style> after a
+ * small print-oriented base (page margins, reset). The print options are layered
+ * on later, by `printDocument`, as an injected stylesheet.
+ */
+export function buildPrintDoc(bodyHtml: string, css: string, title = "Print"): string {
+  const base = `*{box-sizing:border-box}html,body{margin:0;padding:0}` +
+    `@page{margin:1.5cm}` +
+    `body{background:#fff;color:#111;` +
+    `font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;` +
+    `font-size:12px;line-height:1.5}`;
+  return (
+    `<!doctype html><html><head><meta charset="utf-8">` +
+    `<title>${escapeAttr(title)}</title>` +
+    `<style>${base}\n${css}</style>` +
+    `</head><body>${bodyHtml}</body></html>`
+  );
+}
+
+/**
+ * Show a print preview and, on confirmation, hand the document to the platform
+ * print dialog. Mounts a modal overlay whose visible iframe renders the exact
+ * standalone document that will print (WYSIWYG for paper), an options row with
+ * the settings a printer dialog normally carries (paper, orientation, margins,
+ * scale, page selection, backgrounds, grayscale, page numbers), and a Print
+ * button that calls `print()` on the iframe's own window — so only the document,
+ * not the surrounding app, prints. The overlay stays open after the dialog closes
+ * (so the user can adjust and print again) and tears down on Close / backdrop
+ * click / Escape, which is when the returned promise resolves.
+ *
+ * Page selection *and* rearranging are exact for *paged* documents — those built
+ * out of `.print-page` elements (the PDF and image viewers) — because those pages
+ * are real elements we can reorder, hide and drop. Those documents also get a
+ * thumbnail strip for drag-to-reorder and per-page delete. Flowing documents
+ * (markdown, text, HTML) have no such elements; there the page controls are
+ * disabled and the system dialog's own range field does the job.
+ */
+export function printDocument(fullHtml: string): Promise<void> {
+  return new Promise<void>((resolve) => {
+    // ── Overlay chrome (reuses the app's shared modal classes) ──────────────
+    const backdrop = document.createElement("div");
+    backdrop.className = "modal-backdrop print-preview-backdrop";
+
+    const dialog = document.createElement("div");
+    dialog.className = "settings-dialog print-preview-dialog";
+
+    const titlebar = document.createElement("div");
+    titlebar.className = "print-preview-titlebar";
+
+    const title = document.createElement("span");
+    title.className = "print-preview-title";
+    title.textContent = "Print preview";
+
+    const actions = document.createElement("div");
+    actions.className = "print-preview-actions";
+
+    const printBtn = document.createElement("button");
+    printBtn.className = "print-preview-print";
+    printBtn.type = "button";
+    // Disabled with a "Preparing…" affordance until images decode; mirrors the
+    // viewer toolbar's PrintButton busy state.
+    printBtn.disabled = true;
+    printBtn.innerHTML =
+      `<span class="file-viewer-save-spinner" aria-hidden="true"></span>Preparing…`;
+
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "dialog-close-btn print-preview-close";
+    closeBtn.type = "button";
+    closeBtn.textContent = "Close";
+
+    const iframe = document.createElement("iframe");
+    iframe.className = "print-preview-frame";
+    iframe.setAttribute("title", "Print preview");
+
+    // ── Options row ─────────────────────────────────────────────────────────
+    let opts = loadPrintOptions();
+    const optionsRow = document.createElement("div");
+    optionsRow.className = "print-preview-options";
+
+    const paper = selectField(
+      "Paper",
+      (Object.keys(PAPER_CM) as PaperSize[]).sort().map((p) => [p, p] as const),
+      opts.paper,
+      (v) => set({ paper: v as PaperSize }),
+    );
+    const orientation = selectField(
+      "Layout",
+      [
+        ["portrait", "Portrait"],
+        ["landscape", "Landscape"],
+      ],
+      opts.orientation,
+      (v) => set({ orientation: v as Orientation }),
+    );
+    const margin = selectField(
+      "Margins",
+      [
+        ["none", "None"],
+        ["narrow", "Narrow"],
+        ["normal", "Normal"],
+        ["wide", "Wide"],
+      ],
+      opts.margin,
+      (v) => set({ margin: v as MarginPreset }),
+    );
+    const scale = selectField(
+      "Scale",
+      SCALE_CHOICES.map((s) => [String(s), `${s}%`] as const),
+      String(opts.scale),
+      (v) => set({ scale: Number(v) }),
+    );
+    const pages = selectField(
+      "Pages",
+      [
+        ["all", "All"],
+        ["odd", "Odd"],
+        ["even", "Even"],
+        ["custom", "Custom"],
+      ],
+      opts.pages,
+      (v) => set({ pages: v as PageSelection }),
+    );
+
+    const rangeInput = document.createElement("input");
+    rangeInput.className = "print-opt-range";
+    rangeInput.type = "text";
+    rangeInput.placeholder = "e.g. 1-3, 5";
+    rangeInput.value = opts.range;
+    rangeInput.setAttribute("aria-label", "Page range");
+    rangeInput.addEventListener("input", () => set({ range: rangeInput.value }));
+
+    const background = checkField("Backgrounds", opts.background, (v) =>
+      set({ background: v }),
+    );
+    const grayscale = checkField("Grayscale", opts.grayscale, (v) => set({ grayscale: v }));
+    const pageNumbers = checkField("Page numbers", opts.pageNumbers, (v) =>
+      set({ pageNumbers: v }),
+    );
+
+    optionsRow.append(
+      paper.wrap,
+      orientation.wrap,
+      margin.wrap,
+      scale.wrap,
+      pages.wrap,
+      rangeInput,
+      background.wrap,
+      grayscale.wrap,
+      pageNumbers.wrap,
+    );
+
+    // ── Page strip (paged documents only) ───────────────────────────────────
+    const strip = document.createElement("div");
+    strip.className = "print-preview-strip";
+    strip.hidden = true;
+
+    const stripHint = document.createElement("span");
+    stripHint.className = "print-strip-hint";
+    stripHint.textContent =
+      "Drag to reorder · shift-click for a range · ⟳ turns a page · ✕ removes it";
+
+    const resetBtn = document.createElement("button");
+    resetBtn.className = "print-strip-reset";
+    resetBtn.type = "button";
+    resetBtn.textContent = "Reset pages";
+    resetBtn.addEventListener("click", () => {
+      arrangement = initialPages(pageEls.length);
+      opts = { ...opts, pages: "all", range: "" };
+      pages.select.value = "all";
+      rangeInput.value = "";
+      apply();
+    });
+
+    const stripBar = document.createElement("div");
+    stripBar.className = "print-strip-bar";
+    stripBar.append(stripHint, resetBtn);
+
+    const stripPages = document.createElement("div");
+    stripPages.className = "print-strip-pages";
+    strip.append(stripBar, stripPages);
+
+    actions.append(printBtn, closeBtn);
+    titlebar.append(title, actions);
+    dialog.append(titlebar, optionsRow, strip, iframe);
+    backdrop.append(dialog);
+
+    // ── Live state of the previewed document ────────────────────────────────
+    let frameWin: Window | null = null;
+    let styleEl: HTMLStyleElement | null = null;
+    /** Page elements indexed by original page number − 1; never reordered. */
+    let pageEls: HTMLElement[] = [];
+    /** Working arrangement (see `pageModel`): the sheets, moved/dropped/turned by
+     *  the strip. Every entry's `src` is SELF — a print job never merges documents. */
+    let arrangement: PageList = [];
+    let ready = false; // images decoded — safe to print
+    /** The mounted <PageStrip>; created on the first paged render. */
+    let stripUi: MountedPageStrip | null = null;
+
+    const NO_PAGES_HINT =
+      "This document has no fixed pages — use the system print dialog's page range.";
+
+    /** Push the arrangement + options into the previewed document and the UI. */
+    const apply = () => {
+      savePrintOptions(opts);
+      const paged = pageEls.length > 0;
+      pages.select.disabled = !paged;
+      pageNumbers.input.disabled = !paged;
+      rangeInput.disabled = !paged || opts.pages !== "custom";
+      pages.wrap.title = paged ? "" : NO_PAGES_HINT;
+      pageNumbers.wrap.title = paged ? "" : NO_PAGES_HINT;
+      rangeInput.title = paged ? "" : NO_PAGES_HINT;
+      strip.hidden = !paged;
+      resetBtn.disabled = isPristine(arrangement, pageEls.length) && opts.pages === "all";
+
+      if (styleEl) styleEl.textContent = buildOptionsCss(opts);
+
+      // Cards take the sheet's proportions, so a landscape sheet gets a landscape
+      // card instead of an upright one. Set on the host, inherited by the cards.
+      const [thumbW, thumbH] = thumbSizePx(opts);
+      stripPages.style.setProperty("--page-thumb-w", `${thumbW}px`);
+      stripPages.style.setProperty("--page-thumb-h", `${thumbH}px`);
+
+      const sequence = printSequence(arrangement, opts);
+      const printing = new Set(sequence.map((r) => r.page));
+      const parent = pageEls[0]?.parentElement ?? null;
+      // `pageEls` is indexed by original page number − 1 and never reordered.
+      pageEls.forEach((el, i) =>
+        el.classList.toggle("eldrun-print-hidden", !printing.has(i + 1)),
+      );
+      // The DOM *is* the print order, so realise the arrangement by re-appending
+      // the pages in sequence. The page break is set inline per page rather than
+      // left to `.print-page + .print-page`, whose sibling match would also fire
+      // on the first printed page when a removed one still precedes it in the DOM
+      // — one blank leading sheet.
+      sequence.forEach((ref, i) => {
+        const el = pageEls[ref.page - 1];
+        if (!el) return;
+        parent?.appendChild(el);
+        el.style.pageBreakBefore = i === 0 ? "auto" : "always";
+        el.style.breakBefore = i === 0 ? "auto" : "page";
+        el.setAttribute("data-page", String(i + 1));
+        el.classList.remove("eldrun-rot-90", "eldrun-rot-180", "eldrun-rot-270");
+        if (ref.rot) el.classList.add(`eldrun-rot-${ref.rot}`);
+      });
+
+      // Safe to re-render mid-drag: React reorders the SAME card elements (they are
+      // keyed by page id), so the dragged card keeps its identity — and its grab.
+      renderStrip(sequence);
+
+      if (!ready) return;
+      const empty = paged && sequence.length === 0;
+      printBtn.disabled = empty;
+      printBtn.textContent = empty
+        ? "No pages selected"
+        : paged && sequence.length < pageEls.length
+          ? `🖨 Print (${sequence.length} ${sequence.length === 1 ? "page" : "pages"})`
+          : "🖨 Print";
+    };
+
+    /** Merge an option change and re-apply. */
+    const set = (patch: Partial<PrintOptions>) => {
+      opts = { ...opts, ...patch };
+      apply();
+    };
+
+    /**
+     * Push the current arrangement into the strip.
+     *
+     * The strip is the shared `<PageStrip>` — the very component the PDF viewer's
+     * page rail uses — so dragging, shift-selecting, turning and deleting pages
+     * behave the same in both. It owns the gesture and reports each edit back
+     * through `onChange`; `arrangement` (and thus the preview) follows.
+     */
+    const renderStrip = (sequence: PageList) => {
+      if (pageEls.length === 0) return;
+      const printing = new Set(sequence.map((r) => r.id));
+      const props: PageStripProps = {
+        pages: arrangement,
+        orientation: "row",
+        onChange: (next) => {
+          arrangement = next;
+          apply();
+        },
+        // The thumbnail is the page's own already-rasterised image, taken straight
+        // from the previewed document (the PDF viewer rasterises pages itself).
+        renderThumb: (ref) => {
+          const src = pageEls[ref.page - 1]?.querySelector("img")?.src;
+          return src
+            ? createElement("img", { src, alt: "" })
+            : createElement("span", { className: "page-strip-blank" }, String(ref.page));
+        },
+        badgeFor: (ref) =>
+          printing.has(ref.id)
+            ? String(sequence.findIndex((r) => r.id === ref.id) + 1)
+            : "—",
+        isExcluded: (ref) => !printing.has(ref.id),
+        titleFor: (ref) =>
+          `Page ${ref.page} of the original document` +
+          (ref.rot ? ` · turned ${ref.rot}°` : ""),
+      };
+      if (stripUi) stripUi.update(props);
+      else stripUi = mountPageStrip(stripPages, props);
+    };
+
+    // ── Teardown (single-shot) ──────────────────────────────────────────────
+    let done = false;
+    const cleanup = () => {
+      if (done) return;
+      done = true;
+      document.removeEventListener("keydown", onKeyDown);
+      stripUi?.destroy();
+      stripUi = null;
+      backdrop.remove();
+      resolve();
+    };
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        cleanup();
+      }
+    };
+
+    closeBtn.addEventListener("click", cleanup);
+    // Backdrop click closes; clicks inside the dialog must not bubble to it.
+    backdrop.addEventListener("mousedown", (e) => {
+      if (e.target === backdrop) cleanup();
+    });
+    document.addEventListener("keydown", onKeyDown);
+
+    printBtn.addEventListener("click", () => {
+      if (printBtn.disabled || !frameWin) return;
+      try {
+        frameWin.focus();
+        frameWin.print();
+      } catch {
+        /* printing unsupported / dialog refused: leave preview open */
+      }
+    });
+
+    iframe.onload = () => {
+      const win = iframe.contentWindow;
+      const doc = iframe.contentDocument;
+      if (!win || !doc) return;
+      frameWin = win;
+
+      // Injected last, so it wins over the document's own rules at equal
+      // specificity — including for documents Eldrun did not assemble.
+      styleEl = doc.createElement("style");
+      styleEl.id = "eldrun-print-options";
+      (doc.head ?? doc.documentElement).appendChild(styleEl);
+
+      pageEls = Array.from(doc.querySelectorAll<HTMLElement>(".print-page"));
+      arrangement = initialPages(pageEls.length);
+      apply(); // style the preview immediately; the button stays "Preparing…"
+
+      Promise.all(
+        Array.from(doc.images).map((img) =>
+          Promise.resolve(img.decode?.()).catch(() => {
+            /* broken/missing image: preview what loaded rather than block */
+          }),
+        ),
+      ).then(() => {
+        if (done) return;
+        ready = true;
+        apply();
+      });
+    };
+
+    document.body.appendChild(backdrop);
+    iframe.srcdoc = fullHtml;
+  });
+}
+
+/** A labelled `<select>` for the options row. */
+function selectField(
+  label: string,
+  choices: readonly (readonly [string, string])[],
+  value: string,
+  onChange: (value: string) => void,
+): { wrap: HTMLLabelElement; select: HTMLSelectElement } {
+  const wrap = document.createElement("label");
+  wrap.className = "print-opt";
+  const text = document.createElement("span");
+  text.className = "print-opt-label";
+  text.textContent = label;
+  const select = document.createElement("select");
+  select.className = "print-opt-select";
+  for (const [v, l] of choices) {
+    const option = document.createElement("option");
+    option.value = v;
+    option.textContent = l;
+    select.appendChild(option);
+  }
+  select.value = value;
+  select.addEventListener("change", () => onChange(select.value));
+  wrap.append(text, select);
+  return { wrap, select };
+}
+
+/** A labelled checkbox for the options row. */
+function checkField(
+  label: string,
+  checked: boolean,
+  onChange: (checked: boolean) => void,
+): { wrap: HTMLLabelElement; input: HTMLInputElement } {
+  const wrap = document.createElement("label");
+  wrap.className = "print-opt print-opt-check";
+  const input = document.createElement("input");
+  input.type = "checkbox";
+  input.checked = checked;
+  input.addEventListener("change", () => onChange(input.checked));
+  const text = document.createElement("span");
+  text.className = "print-opt-label";
+  text.textContent = label;
+  wrap.append(input, text);
+  return { wrap, input };
+}
+
+/** Convenience: build the document from a body + css and print it. */
+export function printHtmlBody(bodyHtml: string, css: string, title?: string): Promise<void> {
+  return printDocument(buildPrintDoc(bodyHtml, css, title));
+}
+
+/**
+ * Rasterise an ARRANGEMENT — the sheets the PDF viewer is currently showing, in its
+ * current order and with its turns applied — to PNG data URLs for printing, pulling
+ * each sheet from its own already-open pdf.js document. So printing an edited PDF
+ * prints what you see, without first having to save it. `scale` trades size for print
+ * sharpness (~2× ≈ good on paper).
+ */
+export async function renderPdfPagesToImages(
+  refs: readonly { src: string; page: number; rot: number }[],
+  docFor: (src: string) => PDFDocumentProxy | undefined,
+  scale = 2,
+): Promise<string[]> {
+  const urls: string[] = [];
+  for (const ref of refs) {
+    const doc = docFor(ref.src);
+    if (!doc) continue;
+    const page = await doc.getPage(ref.page);
+    // The viewer's turn rides ON TOP of whatever the page already carried, and
+    // pdf.js' `rotation` is the total — so the two are added, not substituted.
+    const viewport = page.getViewport({
+      scale,
+      rotation: (((page.rotate + ref.rot) % 360) + 360) % 360,
+    });
+    const canvas = document.createElement("canvas");
+    canvas.width = Math.ceil(viewport.width);
+    canvas.height = Math.ceil(viewport.height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) continue;
+    await page.render({ canvasContext: ctx, viewport }).promise;
+    urls.push(canvas.toDataURL("image/png"));
+  }
+  return urls;
+}
+
+/** Escape a string for use inside a double-quoted HTML attribute. */
+function escapeAttr(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+
+// ── Print stylesheets ────────────────────────────────────────────────────────
+// Concrete light-on-white colors: the app's themed `var(--…)` tokens don't exist
+// inside the print iframe, and print output is on paper.
+
+/** Print styling for `renderMarkdown` output wrapped in `.markdown-body`.
+ *
+ * Margins come from body padding, NOT `@page{margin}`: WebKitGTK (the Linux
+ * webview) does not implement the `@page` margin box, so an `@page` margin alone
+ * prints edge-to-edge. Body padding is honored by every engine. `@page` margin
+ * is zeroed so Chromium-based WebView2 doesn't add its own on top (double
+ * margin). This overrides the `html,body{padding:0}` reset in `buildPrintDoc`. */
+export const MARKDOWN_PRINT_CSS = `
+@page{margin:0}
+body{padding:2.54cm}
+.markdown-body{max-width:100%;color:#111}
+.markdown-body h1,.markdown-body h2,.markdown-body h3,
+.markdown-body h4,.markdown-body h5,.markdown-body h6{
+  line-height:1.25;margin:1.2em 0 .5em;font-weight:600;page-break-after:avoid}
+.markdown-body h1{font-size:1.9em;border-bottom:1px solid #ddd;padding-bottom:.2em}
+.markdown-body h2{font-size:1.5em;border-bottom:1px solid #eee;padding-bottom:.2em}
+.markdown-body h3{font-size:1.25em}
+.markdown-body p,.markdown-body ul,.markdown-body ol,.markdown-body blockquote{margin:.6em 0}
+.markdown-body ul,.markdown-body ol{padding-left:1.6em}
+.markdown-body a{color:#0645ad;text-decoration:underline}
+.markdown-body code{
+  font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
+  font-size:.9em;background:#f4f4f4;padding:.1em .3em;border-radius:3px}
+.markdown-body pre{
+  background:#f6f8fa;border:1px solid #e1e4e8;border-radius:4px;padding:.8em;
+  overflow:auto;page-break-inside:avoid}
+.markdown-body pre code{background:none;padding:0}
+.markdown-body blockquote{
+  border-left:4px solid #ddd;color:#555;padding-left:1em;margin-left:0}
+.markdown-body table{border-collapse:collapse;margin:.6em 0;page-break-inside:avoid}
+.markdown-body th,.markdown-body td{border:1px solid #ccc;padding:.35em .6em;text-align:left}
+.markdown-body th{background:#f4f4f4}
+.markdown-body img,.markdown-body svg{max-width:100%;height:auto}
+.markdown-body hr{border:0;border-top:1px solid #ddd;margin:1.2em 0}
+`;
+
+/** Print styling for plain text / source shown in a single `<pre>`.
+ * Margins via body padding — see MARKDOWN_PRINT_CSS for why `@page{margin}`
+ * alone prints borderless on WebKitGTK. */
+export const TEXT_PRINT_CSS = `
+@page{margin:0}
+body{padding:2.54cm}
+pre.print-pre{
+  font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
+  font-size:11px;line-height:1.45;color:#111;margin:0;
+  white-space:pre-wrap;word-break:break-word}
+`;
+
+/** Print styling for a single image / one image per PDF page. */
+export const IMAGE_PRINT_CSS = `
+.print-page{text-align:center}
+.print-page img{max-width:100%;max-height:100vh;height:auto}
+.print-page + .print-page{page-break-before:always}
+`;
+
+/** Alias — PDF prints as one image per page with the same rules. */
+export const PDF_PRINT_CSS = IMAGE_PRINT_CSS;
diff --git a/src/lib/viewers/python.ts b/src/lib/viewers/python.ts
new file mode 100644
index 0000000..83c0a7f
--- /dev/null
+++ b/src/lib/viewers/python.ts
@@ -0,0 +1,635 @@
+/**
+ * Python editor intelligence for the native code viewer (#py).
+ *
+ * Two independent features live here, both **pure** — every filesystem touch is
+ * injected — so the whole surface is unit-testable without a webview or a host:
+ *
+ *  1. **Breakpoints.** The gutter's red dots. A breakpoint is a line number, and
+ *     the only two hard parts are that pdb refuses blank/comment lines (so a
+ *     click has to *snap* to the next executable one) and that a breakpoint must
+ *     survive an edit above it (so it has to be *remapped* as the draft changes).
+ *  2. **Go-to-definition.** Ctrl/Cmd+Click a name and land on its `def`/`class` —
+ *     in this file or in the module it was imported from.
+ *
+ * The resolver is deliberately a *lexical* one, not a type inferencer: it follows
+ * the import graph and matches `def`/`class`/assignment names. That covers the
+ * overwhelmingly common cases (`from .util import helper` → `util.py`'s
+ * `def helper`) and, crucially, it is honest about what it can't do — an
+ * unresolvable name simply doesn't underline, so the affordance never lies.
+ * Anything requiring real type inference (`obj.method()` where `obj` is a local)
+ * is out of scope by construction.
+ */
+
+import { dirname, resolvePath } from "../paths";
+
+const PY_EXTENSIONS = [".py", ".pyi", ".pyw"];
+
+export function isPythonPath(path: string): boolean {
+  const lower = path.toLowerCase();
+  return PY_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+
+const MAIN_GUARD_RE = /^if[ \t]+__name__[ \t]*==[ \t]*(['"])__main__\1[ \t]*:/m;
+
+/** Whether `source` is written to be *run*, not just imported — the standard,
+ *  unambiguous signal being a module-level `if __name__ == "__main__":` guard.
+ *  Gates the Run button: a plain library file has nothing useful to execute. */
+export function isPythonMainScript(source: string): boolean {
+  return MAIN_GUARD_RE.test(source);
+}
+
+// ── Breakpoints ──────────────────────────────────────────────────────────────
+
+/**
+ * Can pdb break on this line's text? Blank lines and pure comments carry no
+ * bytecode, and `break` on one is an error ("Blank or comment"), so the gutter
+ * must never place a breakpoint there. Decorators are excluded too: `@foo` is
+ * executed at *definition* time, and a break there fires on import rather than
+ * on the call the user meant.
+ */
+export function isExecutableLine(text: string): boolean {
+  const t = text.trim();
+  if (t === "") return false;
+  if (t.startsWith("#")) return false;
+  if (t.startsWith("@")) return false;
+  return true;
+}
+
+/**
+ * The line a click on `line` (1-based) should actually breakpoint on: `line`
+ * itself when it is executable, else the next executable line below it. Returns
+ * null when nothing below is executable (a click in the trailing blank space
+ * after the last statement), so the caller can no-op rather than set a
+ * breakpoint pdb will reject.
+ */
+export function snapBreakpointLine(source: string, line: number): number | null {
+  const lines = source.split("\n");
+  for (let i = line - 1; i < lines.length; i++) {
+    if (isExecutableLine(lines[i])) return i + 1;
+  }
+  return null;
+}
+
+/**
+ * Carry breakpoints across an edit.
+ *
+ * A breakpoint is bound to a *line number*, so inserting or deleting lines above
+ * one silently re-points it at the wrong statement — the dot stays put on screen
+ * while the code under it slides. We recompute instead: find the span of lines the
+ * edit actually touched (the unchanged common prefix/suffix of the two drafts) and
+ * shift every breakpoint below it by the line-count delta. Breakpoints *inside* the
+ * edited span are dropped — their statement may not exist any more, and guessing
+ * where it went would be worse than losing the dot the user can see is gone.
+ */
+export function remapBreakpoints(prev: string, next: string, bps: number[]): number[] {
+  if (prev === next || bps.length === 0) return bps;
+
+  const a = prev.split("\n");
+  const b = next.split("\n");
+
+  // Common prefix of unchanged lines.
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head++;
+  // Common suffix of unchanged lines, not overlapping the prefix.
+  let tail = 0;
+  while (
+    tail < a.length - head &&
+    tail < b.length - head &&
+    a[a.length - 1 - tail] === b[b.length - 1 - tail]
+  ) {
+    tail++;
+  }
+
+  // Lines [head+1 … a.length-tail] (1-based) of `prev` were replaced.
+  const editedFrom = head + 1;
+  const editedTo = a.length - tail;
+  const delta = b.length - a.length;
+
+  const out: number[] = [];
+  for (const bp of bps) {
+    if (bp < editedFrom) out.push(bp); // above the edit: untouched
+    else if (bp > editedTo) out.push(bp + delta); // below it: slides by the delta
+    // inside the edited span: dropped
+  }
+  return [...new Set(out)].sort((x, y) => x - y);
+}
+
+// ── Lexing ───────────────────────────────────────────────────────────────────
+
+const IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/y;
+/** String prefixes (`r"…"`, `f"…"`, `rb"…"`, …). An identifier immediately
+ *  followed by a quote is a prefix, not a name. */
+const STRING_PREFIX = new Set(["r", "b", "u", "f", "rb", "br", "fr", "rf"]);
+
+const PY_KEYWORDS = new Set([
+  "False", "None", "True", "and", "as", "assert", "async", "await", "break",
+  "class", "continue", "def", "del", "elif", "else", "except", "finally",
+  "for", "from", "global", "if", "import", "in", "is", "lambda", "nonlocal",
+  "not", "or", "pass", "raise", "return", "try", "while", "with", "yield",
+]);
+
+/** One identifier occurrence in code (never inside a string or comment). */
+export interface PyToken {
+  name: string;
+  start: number;
+  end: number;
+  /** The identifier immediately before a `.` preceding this one (`os.path` →
+   *  `path`'s qualifier is `os`), or null when this name stands alone. */
+  qualifier: string | null;
+}
+
+/**
+ * Every identifier in `source` that is really *code* — string bodies, comments
+ * and string prefixes are skipped. This is the substrate for both the link
+ * ranges and the ref-at-caret lookup: a lexer, not a parser, which is all the
+ * lexical resolver needs and is robust against the syntax errors a live editor
+ * buffer is full of.
+ */
+export function pythonTokens(source: string): PyToken[] {
+  const out: PyToken[] = [];
+  const n = source.length;
+  let i = 0;
+  // The last identifier seen, and whether a bare `.` sat between it and here —
+  // together they give each token its qualifier.
+  let prevIdent: string | null = null;
+  let prevIdentEnd = -1;
+
+  while (i < n) {
+    const c = source[i];
+
+    if (c === "#") {
+      while (i < n && source[i] !== "\n") i++;
+      continue;
+    }
+
+    if (c === '"' || c === "'") {
+      i = skipString(source, i);
+      prevIdent = null;
+      continue;
+    }
+
+    if (/[A-Za-z_]/.test(c)) {
+      IDENT_RE.lastIndex = i;
+      const m = IDENT_RE.exec(source);
+      // The regex is sticky and `c` starts an identifier, so this always matches.
+      const name = m![0];
+      const start = i;
+      const end = i + name.length;
+
+      // A string prefix (`f"…"`) is part of the literal, not a name.
+      const next = source[end];
+      if ((next === '"' || next === "'") && STRING_PREFIX.has(name.toLowerCase())) {
+        i = skipString(source, end);
+        prevIdent = null;
+        continue;
+      }
+
+      // Qualified? Only when a single `.` separates us from the previous
+      // identifier (whitespace around it is legal Python).
+      let qualifier: string | null = null;
+      if (prevIdent != null) {
+        const between = source.slice(prevIdentEnd, start);
+        if (/^\s*\.\s*$/.test(between)) qualifier = prevIdent;
+      }
+
+      out.push({ name, start, end, qualifier });
+      prevIdent = name;
+      prevIdentEnd = end;
+      i = end;
+      continue;
+    }
+
+    // Anything that isn't whitespace or a dot breaks a dotted chain.
+    if (!/[\s.]/.test(c)) {
+      prevIdent = null;
+    }
+    i++;
+  }
+
+  return out;
+}
+
+/** Index just past the string literal starting at `i` (which is on its quote).
+ *  Handles triple quotes and backslash escapes; an unterminated literal (the
+ *  normal state of a buffer being typed into) consumes to EOF. */
+function skipString(source: string, i: number): number {
+  const q = source[i];
+  const triple = source.startsWith(q.repeat(3), i);
+  const close = triple ? q.repeat(3) : q;
+  let j = i + close.length;
+  while (j < source.length) {
+    if (source[j] === "\\") {
+      j += 2;
+      continue;
+    }
+    if (source.startsWith(close, j)) return j + close.length;
+    // A single-quoted literal cannot span a newline.
+    if (!triple && source[j] === "\n") return j;
+    j++;
+  }
+  return source.length;
+}
+
+// ── Definitions ──────────────────────────────────────────────────────────────
+
+export interface PyDef {
+  name: string;
+  /** 1-based line of the definition. */
+  line: number;
+  /** 0-based column of the *name* (so the caret lands on it, not on `def`). */
+  column: number;
+  kind: "def" | "class" | "var";
+}
+
+const DEF_RE = /^[ \t]*(?:async[ \t]+)?(def|class)[ \t]+([A-Za-z_][A-Za-z0-9_]*)/;
+/** A module-level (unindented) binding: `NAME = …` or `NAME: T = …`. Catches the
+ *  constants and singletons a `from x import CONFIG` points at. */
+const ASSIGN_RE = /^([A-Za-z_][A-Za-z0-9_]*)[ \t]*(?::[^=\n]+)?=(?!=)/;
+
+/** Every `def`/`class`/module-level assignment in `source`, in file order. */
+export function findPythonDefs(source: string): PyDef[] {
+  const out: PyDef[] = [];
+  const lines = source.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const text = lines[i];
+    const d = DEF_RE.exec(text);
+    if (d) {
+      out.push({
+        name: d[2],
+        line: i + 1,
+        column: text.indexOf(d[2], d[0].length - d[2].length),
+        kind: d[1] === "class" ? "class" : "def",
+      });
+      continue;
+    }
+    const a = ASSIGN_RE.exec(text);
+    if (a) out.push({ name: a[1], line: i + 1, column: 0, kind: "var" });
+  }
+  return out;
+}
+
+/** The definition of `name` in `source`, preferring a `def`/`class` over a bare
+ *  assignment (a function shadowed by a later `f = None` should still jump to
+ *  the function). */
+export function findDef(source: string, name: string): PyDef | null {
+  const defs = findPythonDefs(source).filter((d) => d.name === name);
+  if (defs.length === 0) return null;
+  return defs.find((d) => d.kind !== "var") ?? defs[0];
+}
+
+// ── Imports ──────────────────────────────────────────────────────────────────
+
+/**
+ * One name this file binds via an import.
+ *
+ * The two Python import forms collapse into one record. `import os.path as p`
+ * binds the *module* `os.path` to `p` (`symbol` empty). `from .util import helper`
+ * binds the *symbol* `helper` out of the relative module `util` (`level` 1).
+ */
+export interface PyImport {
+  /** The name as it is used in this file (the `as` alias when there is one). */
+  local: string;
+  /** Dotted module path; "" for a bare relative import (`from . import x`). */
+  module: string;
+  /** Leading-dot count: 0 = absolute, 1 = this package, 2 = parent, … */
+  level: number;
+  /** The symbol taken out of `module`, or "" when `local` *is* the module. */
+  symbol: string;
+}
+
+/**
+ * Parse the import statements of `source`.
+ *
+ * Comments and strings are stripped first (via {@link pythonTokens}' sibling
+ * logic) — a docstring containing the word "import" must not bind a name. Only
+ * statement-leading `import`/`from` are considered, and parenthesised multi-line
+ * `from x import (a, b)` lists are joined before splitting.
+ */
+export function parsePythonImports(source: string): PyImport[] {
+  const out: PyImport[] = [];
+  for (const stmt of importStatements(source)) {
+    const from = /^from[ \t]+(\.*)([A-Za-z_][A-Za-z0-9_.]*)?[ \t]+import[ \t]+(.+)$/s.exec(stmt);
+    if (from) {
+      const level = from[1].length;
+      const module = from[2] ?? "";
+      const body = from[3].replace(/^\(|\)$/g, "").trim();
+      for (const part of body.split(",")) {
+        const item = /^([A-Za-z_][A-Za-z0-9_]*)(?:[ \t]+as[ \t]+([A-Za-z_][A-Za-z0-9_]*))?$/.exec(
+          part.trim(),
+        );
+        if (!item) continue; // `*`, or a fragment mid-typing
+        out.push({ local: item[2] ?? item[1], module, level, symbol: item[1] });
+      }
+      continue;
+    }
+
+    const plain = /^import[ \t]+(.+)$/s.exec(stmt);
+    if (plain) {
+      for (const part of plain[1].split(",")) {
+        const item = /^([A-Za-z_][A-Za-z0-9_.]*)(?:[ \t]+as[ \t]+([A-Za-z_][A-Za-z0-9_]*))?$/.exec(
+          part.trim(),
+        );
+        if (!item) continue;
+        const module = item[1];
+        // `import a.b` binds `a`; `import a.b as c` binds `c` to `a.b`.
+        const local = item[2] ?? module.split(".")[0];
+        out.push({ local, module, level: 0, symbol: "" });
+      }
+    }
+  }
+  return out;
+}
+
+/** The logical import statements of `source`: comment/string-free, with
+ *  parenthesised and backslash continuations folded into one line each. */
+function importStatements(source: string): string[] {
+  const out: string[] = [];
+  const lines = stripCommentsAndStrings(source).split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    let text = lines[i];
+    if (!/^[ \t]*(?:import|from)[ \t]/.test(text)) continue;
+    // Fold continuations: an open paren, or a trailing backslash.
+    let depth = (text.match(/\(/g)?.length ?? 0) - (text.match(/\)/g)?.length ?? 0);
+    while ((depth > 0 || /\\$/.test(text)) && i + 1 < lines.length) {
+      text = text.replace(/\\$/, "") + " " + lines[++i].trim();
+      depth = (text.match(/\(/g)?.length ?? 0) - (text.match(/\)/g)?.length ?? 0);
+    }
+    out.push(text.trim());
+  }
+  return out;
+}
+
+/** Blank out comments and string bodies, preserving offsets and line structure,
+ *  so line-oriented matching can't be fooled by a docstring. */
+function stripCommentsAndStrings(source: string): string {
+  const chars = source.split("");
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "#") {
+      while (i < source.length && source[i] !== "\n") chars[i++] = " ";
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const end = skipString(source, i);
+      for (let j = i; j < end; j++) if (chars[j] !== "\n") chars[j] = " ";
+      i = end;
+      continue;
+    }
+    i++;
+  }
+  return chars.join("");
+}
+
+// ── Reference at the caret ───────────────────────────────────────────────────
+
+/** The name under the caret, with its source range and dotted qualifier. */
+export type PyRef = PyToken;
+
+/** The identifier the caret sits in (or immediately after), or null. */
+export function pythonRefAt(source: string, caret: number): PyRef | null {
+  for (const t of pythonTokens(source)) {
+    if (caret >= t.start && caret <= t.end) return t;
+    if (t.start > caret) break; // tokens are in source order
+  }
+  return null;
+}
+
+/**
+ * The source ranges to underline as ctrl-clickable (#49's `linkRanges` contract).
+ *
+ * Only names this resolver can actually *follow* are underlined — a name defined
+ * in this file, a name imported into it, or an attribute of an imported module.
+ * That keeps the affordance honest: if it's underlined, clicking it lands
+ * somewhere. Definition sites themselves are excluded (jumping from `def foo` to
+ * `def foo` is a no-op that would make every definition look like a link).
+ */
+export function pythonLinkRanges(source: string): { start: number; end: number }[] {
+  const defs = findPythonDefs(source);
+  const defNames = new Set(defs.map((d) => d.name));
+  // Every definition site — `def`/`class` AND a module-level binding. A name is
+  // not a link where it is being *defined*: the jump would land on itself.
+  const defSites = new Set(defs.map((d) => `${d.line}:${d.name}`));
+
+  const imports = parsePythonImports(source);
+  const importedNames = new Set(imports.map((i) => i.local));
+  const importedModules = new Set(imports.filter((i) => i.symbol === "").map((i) => i.local));
+
+  // Line number of each offset, so a def site can be excluded by (line, name).
+  const lineOf = lineIndex(source);
+
+  const out: { start: number; end: number }[] = [];
+  for (const t of pythonTokens(source)) {
+    if (PY_KEYWORDS.has(t.name)) continue;
+
+    if (t.qualifier != null) {
+      // `mod.thing` — followable only when `mod` is an imported module, or when
+      // it is `self` (then `thing` is a method of the class in THIS file).
+      if (importedModules.has(t.qualifier) || t.qualifier === "self") {
+        if (t.qualifier === "self" && !defNames.has(t.name)) continue;
+        out.push({ start: t.start, end: t.end });
+      }
+      continue;
+    }
+
+    if (importedNames.has(t.name)) {
+      out.push({ start: t.start, end: t.end });
+      continue;
+    }
+    if (defNames.has(t.name) && !defSites.has(`${lineOf(t.start)}:${t.name}`)) {
+      out.push({ start: t.start, end: t.end });
+    }
+  }
+  return out;
+}
+
+/** A function mapping a source offset to its 1-based line number. */
+function lineIndex(source: string): (offset: number) => number {
+  const starts: number[] = [0];
+  for (let i = 0; i < source.length; i++) if (source[i] === "\n") starts.push(i + 1);
+  return (offset: number) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (starts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+}
+
+// ── Module → file ────────────────────────────────────────────────────────────
+
+/**
+ * The files an import could name, best candidate first.
+ *
+ * A relative import (`level > 0`) is anchored at this file's directory, walking
+ * up one level per extra dot — unambiguous. An absolute one is genuinely
+ * ambiguous without the interpreter's `sys.path`, so we probe the roots a project
+ * actually uses, in order: the project root (flat layout), a `src/` root
+ * (src-layout), and finally the importing file's own directory (scripts that sit
+ * beside their modules). Each root yields both `pkg/mod.py` and the package form
+ * `pkg/mod/__init__.py`.
+ */
+export function modulePathCandidates(
+  imp: Pick<PyImport, "module" | "level">,
+  filePath: string,
+  projectRoot: string,
+): string[] {
+  const parts = imp.module ? imp.module.split(".") : [];
+
+  const roots: string[] = [];
+  if (imp.level > 0) {
+    // `.` = this file's package; each extra dot climbs one more.
+    let base = dirname(filePath) || "/";
+    for (let i = 1; i < imp.level; i++) base = dirname(base) || base;
+    roots.push(base);
+  } else {
+    if (projectRoot) {
+      roots.push(projectRoot);
+      roots.push(resolvePath(projectRoot, "src"));
+    }
+    roots.push(dirname(filePath) || "/");
+  }
+
+  const out: string[] = [];
+  for (const root of roots) {
+    // A bare `from . import x` names the package directory itself.
+    const base = parts.length ? resolvePath(root, parts.join("/")) : root;
+    if (parts.length) out.push(`${base}.py`);
+    out.push(resolvePath(base, "__init__.py"));
+  }
+  return [...new Set(out)];
+}
+
+// ── Resolution ───────────────────────────────────────────────────────────────
+
+/** Where a definition lives: an absolute path and a 1-based caret target. */
+export interface PyLocation {
+  path: string;
+  line: number;
+  column: number;
+}
+
+/** Injected file access, so resolution is testable without a host. Returns null
+ *  when the path does not exist (or can't be read) — reading a candidate IS the
+ *  existence check, since the content is needed anyway. */
+export type PyReader = (path: string) => Promise<string | null>;
+
+/**
+ * Resolve the name at `caret` to its definition — the whole point of ctrl+click.
+ *
+ * The cases, in the order they are tried:
+ *  - `self.method()` → the `def` in this file's class.
+ *  - `mod.thing` where `mod` was imported → `thing`'s def in the module's file.
+ *  - a name from `from mod import name` → its def in the module's file; failing
+ *    that, `mod/name.py` (the form where the "symbol" is itself a submodule).
+ *  - an imported module name → the top of that module's file.
+ *  - anything else defined in this file → its def here.
+ *
+ * Returns null when nothing resolves — the caller must treat that as "not a
+ * link" rather than guessing.
+ */
+export async function resolvePythonDefinition(
+  source: string,
+  caret: number,
+  filePath: string,
+  projectRoot: string,
+  read: PyReader,
+): Promise<PyLocation | null> {
+  const ref = pythonRefAt(source, caret);
+  if (!ref || PY_KEYWORDS.has(ref.name)) return null;
+
+  const imports = parsePythonImports(source);
+  const localDef = (name: string): PyLocation | null => {
+    const d = findDef(source, name);
+    return d ? { path: filePath, line: d.line, column: d.column } : null;
+  };
+
+  // `self.method` — a method of a class in this very file.
+  if (ref.qualifier === "self") return localDef(ref.name);
+
+  // `mod.thing` — follow `mod` to its file, then find `thing` in it.
+  if (ref.qualifier != null) {
+    const mod = imports.find((i) => i.local === ref.qualifier && i.symbol === "");
+    if (!mod) return null;
+    return await defInModule(mod, ref.name, filePath, projectRoot, read, new Set());
+  }
+
+  const imported = imports.find((i) => i.local === ref.name);
+  if (imported) {
+    if (imported.symbol) {
+      // `from mod import name` — `name`'s def in mod, else mod/name.py.
+      const hit = await defInModule(
+        imported,
+        imported.symbol,
+        filePath,
+        projectRoot,
+        read,
+        new Set(),
+      );
+      if (hit) return hit;
+      const asModule: PyImport = {
+        ...imported,
+        module: imported.module
+          ? `${imported.module}.${imported.symbol}`
+          : imported.symbol,
+      };
+      return await moduleHead(asModule, filePath, projectRoot, read);
+    }
+    // `import mod` — open the module itself.
+    return await moduleHead(imported, filePath, projectRoot, read);
+  }
+
+  return localDef(ref.name);
+}
+
+/**
+ * `name`'s definition inside `imp`'s module file, or null.
+ *
+ * Follows one hop of re-export (`__init__.py` doing `from .impl import thing` is
+ * the single most common shape in real packages), which makes the recursion able
+ * to cycle: `a` re-exports from `b` while `b` imports from `a` is legal Python and
+ * happens. `seen` is what makes that terminate — without it a circular re-export
+ * hangs the click.
+ */
+async function defInModule(
+  imp: PyImport,
+  name: string,
+  filePath: string,
+  projectRoot: string,
+  read: PyReader,
+  seen: Set<string>,
+): Promise<PyLocation | null> {
+  for (const candidate of modulePathCandidates(imp, filePath, projectRoot)) {
+    const visitKey = `${candidate}#${name}`;
+    if (seen.has(visitKey)) continue;
+    seen.add(visitKey);
+
+    const text = await read(candidate);
+    if (text == null) continue;
+    const d = findDef(text, name);
+    if (d) return { path: candidate, line: d.line, column: d.column };
+    // The module exists but doesn't define the name — it may re-export it.
+    const via = parsePythonImports(text).find((i) => i.local === name && i.symbol);
+    if (via) {
+      const hit = await defInModule(via, via.symbol, candidate, projectRoot, read, seen);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+
+/** The top of `imp`'s module file, or null when no candidate exists. */
+async function moduleHead(
+  imp: PyImport,
+  filePath: string,
+  projectRoot: string,
+  read: PyReader,
+): Promise<PyLocation | null> {
+  for (const candidate of modulePathCandidates(imp, filePath, projectRoot)) {
+    if ((await read(candidate)) != null) return { path: candidate, line: 1, column: 0 };
+  }
+  return null;
+}
diff --git a/src/lib/viewers/table.ts b/src/lib/viewers/table.ts
new file mode 100644
index 0000000..0a23a80
--- /dev/null
+++ b/src/lib/viewers/table.ts
@@ -0,0 +1,462 @@
+/**
+ * Pure, dependency-free CSV/TSV parsing, sniffing, editing and sorting for the
+ * table viewer (#40). No DOM, no React — unit-tested in isolation
+ * (`src/__tests__/table.test.ts`).
+ *
+ * Two things are worth internalising before changing anything here:
+ *
+ *  - **The separator is guessed, not known.** `.csv` says nothing about which
+ *    character separates the columns: a European export is `;`-delimited, a pipe
+ *    dump `|`-delimited, and both are called `.csv`. Assuming "comma" from the
+ *    extension is exactly what makes such a file render as a single column. So
+ *    the delimiter is *sniffed* from the content, and stays user-overridable —
+ *    see {@link sniffDelimiter}.
+ *
+ *  - **The table is a view on the text, not a model of it.** Every edit
+ *    ({@link replaceCell}, {@link insertRowAfter}, {@link deleteRow}) is a
+ *    surgical splice into the source string, addressed by the spans
+ *    {@link parseTable} hands back — never a re-serialisation of the parsed
+ *    rows. That is the only way editing one cell leaves every *other* cell
+ *    byte-for-byte alone, keeping each field's original quoting style, the
+ *    file's line endings and its delimiter. It is the same bargain
+ *    `lib/viewers/yaml.ts` strikes to keep a config file's comments.
+ */
+
+/** A leading UTF-8 BOM that some editors prepend; skipped, never sliced off. */
+const BOM = "";
+
+/** The source range of one parsed field, as offsets into the *original* text. */
+export interface CellSpan {
+  /** Offset of the field's first character (inclusive). */
+  start: number;
+  /** Offset one past the field's last character (exclusive). */
+  end: number;
+}
+
+/** The source range of one parsed row, as offsets into the *original* text. */
+export interface RowSpan {
+  /** Offset of the row's first character (inclusive). */
+  start: number;
+  /** Offset one past the row's last character, EXCLUDING its line terminator. */
+  end: number;
+  /**
+   * Offset one past the row's line terminator — equal to `end` for a final row
+   * the file leaves unterminated. That equality is how the edit ops tell "this
+   * row ends with a newline" from "this row ends with the file".
+   */
+  next: number;
+}
+
+/** {@link parseTable}'s result: the cells, and where each one came from. */
+export interface ParsedTable {
+  /** Row-major cell values, quoting already decoded. */
+  rows: string[][];
+  /** `cells[r][c]` is the source span of `rows[r][c]`. Same shape as `rows`. */
+  cells: CellSpan[][];
+  /** `rowSpans[r]` is the source span of `rows[r]`. */
+  rowSpans: RowSpan[];
+  /** The file's dominant line terminator, used when a new row is inserted. */
+  newline: string;
+}
+
+/**
+ * A row paired with its index into {@link ParsedTable.rows}. Filtering and
+ * sorting reorder and drop rows, so a row on screen can no longer say where it
+ * came from — but an edit has to splice the row it *actually* came from. The
+ * index is what survives the reordering.
+ */
+export interface RowRef {
+  cells: string[];
+  /** Index into `ParsedTable.rows` — so `0` is the header, `1` the first body row. */
+  index: number;
+}
+
+/**
+ * Parse `text` as RFC 4180 delimited data with the given single-character
+ * `delimiter`, recording the source span of every cell and row so the result can
+ * be edited by splicing rather than re-serialising.
+ *
+ * Handles:
+ *  - quoted fields (`"…"`) that may contain the delimiter, CR, LF, or CRLF;
+ *  - the `""` escape for a literal double-quote inside a quoted field;
+ *  - CRLF and bare-LF (and bare-CR) line endings;
+ *  - a leading BOM, skipped — offsets stay absolute into the original text, so a
+ *    span can be spliced straight back into it;
+ *  - a single trailing newline — it does NOT emit a trailing empty row.
+ *
+ * A quote that appears mid-field in an unquoted context is treated as a literal
+ * character (lenient, like most spreadsheet importers), so malformed input still
+ * yields cells rather than throwing.
+ */
+export function parseTable(text: string, delimiter: string): ParsedTable {
+  // Skip a BOM by starting past it rather than slicing it away: every span must
+  // index into the caller's string, or splicing one back would be off by one.
+  const begin = text.startsWith(BOM) ? 1 : 0;
+
+  const rows: string[][] = [];
+  const cells: CellSpan[][] = [];
+  const rowSpans: RowSpan[] = [];
+
+  let row: string[] = [];
+  let rowCells: CellSpan[] = [];
+  let field = "";
+  let fieldStart = begin;
+  let rowStart = begin;
+  let inQuotes = false;
+  // Tracks whether the current row has seen any content, so we can decide
+  // whether a final dangling row (after a trailing newline) should be emitted.
+  let rowStarted = false;
+
+  const pushField = (end: number) => {
+    row.push(field);
+    rowCells.push({ start: fieldStart, end });
+    field = "";
+  };
+  const pushRow = (end: number, next: number) => {
+    pushField(end);
+    rows.push(row);
+    cells.push(rowCells);
+    rowSpans.push({ start: rowStart, end, next });
+    row = [];
+    rowCells = [];
+    rowStarted = false;
+    fieldStart = next;
+    rowStart = next;
+  };
+
+  for (let i = begin; i < text.length; i++) {
+    const ch = text[i];
+
+    if (inQuotes) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          // Escaped quote inside a quoted field.
+          field += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+
+    if (ch === '"') {
+      inQuotes = true;
+      rowStarted = true;
+      continue;
+    }
+    if (ch === delimiter) {
+      pushField(i);
+      fieldStart = i + 1;
+      rowStarted = true;
+      continue;
+    }
+    if (ch === "\r") {
+      // Treat CRLF as one line ending; a bare CR also ends the line.
+      const crlf = text[i + 1] === "\n";
+      pushRow(i, crlf ? i + 2 : i + 1);
+      if (crlf) i++;
+      continue;
+    }
+    if (ch === "\n") {
+      pushRow(i, i + 1);
+      continue;
+    }
+    field += ch;
+    rowStarted = true;
+  }
+
+  // Flush the final field/row unless the input ended exactly on a row terminator
+  // (a single trailing newline must not produce a trailing empty row).
+  if (rowStarted || field !== "" || row.length > 0 || inQuotes) {
+    pushRow(text.length, text.length);
+  }
+
+  return {
+    rows,
+    cells,
+    rowSpans,
+    newline: text.includes("\r\n") ? "\r\n" : "\n",
+  };
+}
+
+/** {@link parseTable}, when only the values are wanted. */
+export function parseDelimited(text: string, delimiter: string): string[][] {
+  return parseTable(text, delimiter).rows;
+}
+
+// ── Choosing the separator ───────────────────────────────────────────────────
+
+/** The separators {@link sniffDelimiter} considers, and the viewer offers. */
+export const DELIMITER_CANDIDATES = [",", ";", "\t", "|"] as const;
+
+/** How much of a large file to look at when sniffing, and how many rows of it. */
+const SNIFF_CHARS = 64 * 1024;
+const SNIFF_ROWS = 50;
+
+/**
+ * Guess which character separates the columns of `text`, falling back to
+ * `fallback` when nothing splits it convincingly — a genuinely single-column
+ * file has no delimiter to find, and inventing one would shred it.
+ *
+ * Each candidate is scored by parsing a sample of the file *with that candidate*
+ * — so a comma sitting inside a quoted field can't fool the `;` reading — and
+ * asking how rectangular the result is. The modal column count decides, on two
+ * premises:
+ *
+ *  - a character that never splits a row (modal width 1) is not the delimiter,
+ *    however consistently it fails to appear. This is what rejects `,` on a
+ *    `;`-delimited file, where every row would otherwise score a perfect 1.0;
+ *  - real tabular data is rectangular, so the delimiter yielding the *same* width
+ *    on the most rows is the one the file was written with. Consistency therefore
+ *    dominates the score, and the column count only breaks ties — in favour of
+ *    the separator that explains more of the row.
+ */
+export function sniffDelimiter(text: string, fallback = ","): string {
+  const truncated = text.length > SNIFF_CHARS;
+  const sample = truncated ? text.slice(0, SNIFF_CHARS) : text;
+
+  let best: string | null = null;
+  let bestScore = -1;
+
+  for (const candidate of DELIMITER_CANDIDATES) {
+    const parsed = parseDelimited(sample, candidate);
+    const rows = (truncated && parsed.length > 1 ? parsed.slice(0, -1) : parsed)
+      // A sample cut mid-row reports a short final row that isn't real (above);
+      // blank lines say nothing about the delimiter either way.
+      .slice(0, SNIFF_ROWS)
+      .filter((r) => !(r.length === 1 && r[0].trim() === ""));
+    if (rows.length === 0) continue;
+
+    const freq = new Map<number, number>();
+    for (const r of rows) freq.set(r.length, (freq.get(r.length) ?? 0) + 1);
+
+    let mode = 0;
+    let modeCount = 0;
+    for (const [width, count] of freq) {
+      // On a tie, the wider reading wins — it explains more of the row.
+      if (count > modeCount || (count === modeCount && width > mode)) {
+        mode = width;
+        modeCount = count;
+      }
+    }
+    if (mode < 2) continue; // splits nothing ⇒ not the delimiter
+
+    const score = (modeCount / rows.length) * 100 + Math.min(mode, 50);
+    if (score > bestScore) {
+      bestScore = score;
+      best = candidate;
+    }
+  }
+
+  return best ?? fallback;
+}
+
+/** The separator a path's extension implies: `.tsv` → tab, else comma. */
+export function delimiterForPath(path: string): string {
+  return /\.tsv$/i.test(path) ? "\t" : ",";
+}
+
+/**
+ * The separator to open `path` with: sniffed from the content, falling back to
+ * what the extension implies when the content is inconclusive — so a one-column
+ * `.tsv` still reads as a TSV.
+ */
+export function resolveDelimiter(path: string, text: string): string {
+  return sniffDelimiter(text, delimiterForPath(path));
+}
+
+// ── Editing: splices, never re-serialisation ─────────────────────────────────
+
+/**
+ * Encode one value as a field, quoting only when the value would otherwise be
+ * misread: it contains the delimiter, a quote, a newline, or leading/trailing
+ * whitespace that a reader would be free to trim.
+ */
+export function encodeCell(value: string, delimiter: string): string {
+  const ambiguous =
+    value.includes(delimiter) ||
+    value.includes('"') ||
+    value.includes("\n") ||
+    value.includes("\r") ||
+    value !== value.trim();
+  return ambiguous ? `"${value.replace(/"/g, '""')}"` : value;
+}
+
+/**
+ * Return `text` with the cell at (`row`, `col`) set to `value`, splicing only
+ * that one field's span so every other byte of the file survives untouched.
+ *
+ * When `col` lies past the end of a **ragged** row, the row is padded out with
+ * empty fields first: the viewer pads short rows to the table's full width on
+ * screen, so a cell can be visible in a row that holds no such field, and typing
+ * into it must write where it appears rather than land in the wrong column.
+ */
+export function replaceCell(
+  text: string,
+  table: ParsedTable,
+  row: number,
+  col: number,
+  value: string,
+  delimiter: string,
+): string {
+  const spans = table.cells[row];
+  if (!spans || spans.length === 0 || col < 0) return text;
+  const encoded = encodeCell(value, delimiter);
+
+  if (col < spans.length) {
+    const span = spans[col];
+    return text.slice(0, span.start) + encoded + text.slice(span.end);
+  }
+
+  const last = spans[spans.length - 1];
+  const padding = delimiter.repeat(col - spans.length + 1);
+  return text.slice(0, last.end) + padding + encoded + text.slice(last.end);
+}
+
+/** Return `text` with a blank `width`-column row inserted after `row`. */
+export function insertRowAfter(
+  text: string,
+  table: ParsedTable,
+  row: number,
+  width: number,
+  delimiter: string,
+): string {
+  const span = table.rowSpans[row];
+  if (!span) return text;
+  const blank = delimiter.repeat(Math.max(0, width - 1));
+  // A terminated row already ends in a newline, so the blank row follows it and
+  // brings its own. An unterminated final row needs the newline first — and must
+  // stay unterminated, or the file grows a trailing blank line it never had.
+  const terminated = span.next > span.end;
+  const insert = terminated ? blank + table.newline : table.newline + blank;
+  return text.slice(0, span.next) + insert + text.slice(span.next);
+}
+
+/** Return `text` with `row` removed, taking exactly one line terminator with it. */
+export function deleteRow(text: string, table: ParsedTable, row: number): string {
+  const span = table.rowSpans[row];
+  if (!span) return text;
+  // Normally a row takes its own trailing terminator with it. A final,
+  // unterminated row has none — so it takes the *preceding* one instead, rather
+  // than leaving the file ending on a dangling newline.
+  if (span.next > span.end) {
+    return text.slice(0, span.start) + text.slice(span.next);
+  }
+  const previous = row > 0 ? table.rowSpans[row - 1] : null;
+  const from = previous ? previous.end : span.start;
+  return text.slice(0, from) + text.slice(span.next);
+}
+
+// ── Filtering, sorting, layout ───────────────────────────────────────────────
+
+/** The body rows (everything below the header), each keeping its source index. */
+export function bodyRefs(rows: string[][]): RowRef[] {
+  const refs: RowRef[] = [];
+  for (let i = 1; i < rows.length; i++) refs.push({ cells: rows[i], index: i });
+  return refs;
+}
+
+/**
+ * The rows in which some cell contains `query`, case-insensitively. A blank query
+ * matches everything rather than nothing, so clearing the box restores the table.
+ *
+ * `cols` restricts the search to those column indices — the columns the reader can
+ * actually **see**. A row matched on a hidden column would appear in the results
+ * with nothing on it to explain why, which reads as a bug in the filter.
+ */
+export function filterRefs(refs: RowRef[], query: string, cols?: number[]): RowRef[] {
+  const needle = query.trim().toLowerCase();
+  if (needle === "") return refs;
+  const hit = (v: string) => v.toLowerCase().includes(needle);
+  if (!cols) return refs.filter((r) => r.cells.some(hit));
+  return refs.filter((r) => cols.some((c) => hit(r.cells[c] ?? "")));
+}
+
+/**
+ * Whether every cell in `values` parses as a finite number (so the column should
+ * sort numerically). An empty input or an empty/blank cell makes it non-numeric,
+ * since a blank can't be ordered numerically against real numbers.
+ */
+function allNumeric(values: string[]): boolean {
+  if (values.length === 0) return false;
+  for (const v of values) {
+    const t = v.trim();
+    if (t === "") return false;
+    const n = Number(t);
+    if (!Number.isFinite(n)) return false;
+  }
+  return true;
+}
+
+/**
+ * Return a new copy of `refs` sorted by column `col` in direction `dir`. Numeric
+ * comparison is used when every cell in that column parses as a finite number;
+ * otherwise `localeCompare`. Missing cells (ragged rows) are treated as empty
+ * strings. Does not mutate the input. Stable for equal keys.
+ */
+export function sortRefs(refs: RowRef[], col: number, dir: "asc" | "desc"): RowRef[] {
+  const numeric = allNumeric(refs.map((r) => r.cells[col] ?? ""));
+  // Decorate with the current position for a stable sort across engines.
+  const indexed = refs.map((r, i) => ({ r, i }));
+  indexed.sort((a, b) => {
+    const av = a.r.cells[col] ?? "";
+    const bv = b.r.cells[col] ?? "";
+    let cmp = numeric ? Number(av.trim()) - Number(bv.trim()) : av.localeCompare(bv);
+    if (cmp === 0) cmp = a.i - b.i; // keep stable order for ties
+    return dir === "asc" ? cmp : -cmp;
+  });
+  return indexed.map((x) => x.r);
+}
+
+/**
+ * Return a new copy of `refs` ordered by each row's **source index** — the file's
+ * own row order (`asc`) or its reverse (`desc`). This is what the row-number
+ * gutter sorts on: the gutter shows each row's source index, so ordering by it
+ * restores (asc) the order the rows have in the file — whatever a column sort did
+ * to the view — or reverses it (desc). Does not mutate the input.
+ */
+export function sortRefsByIndex(refs: RowRef[], dir: "asc" | "desc"): RowRef[] {
+  const sorted = [...refs].sort((a, b) => a.index - b.index);
+  return dir === "asc" ? sorted : sorted.reverse();
+}
+
+/** {@link sortRefs} over bare rows, for callers with no source indices to keep. */
+export function sortRows(
+  rows: string[][],
+  col: number,
+  dir: "asc" | "desc",
+): string[][] {
+  const refs = rows.map((cells, index) => ({ cells, index }));
+  return sortRefs(refs, col, dir).map((r) => r.cells);
+}
+
+/** Rows sampled when measuring column widths — enough to be representative. */
+const WIDTH_SAMPLE_ROWS = 1000;
+/** Width bounds, in characters, before the cell's own padding. */
+const MIN_WIDTH_CH = 4;
+const MAX_WIDTH_CH = 48;
+
+/**
+ * The display width of each of the table's `width` columns, in characters.
+ *
+ * Measured **once over the whole table**, not over what happens to be on screen,
+ * because the viewer only renders the rows in view: had each column sized itself
+ * to its visible content, every column would resize as the reader scrolled. A
+ * sample bounds the cost on a huge file — a later row that overflows its column
+ * is clipped, and the viewer offers the full value on hover, which is the price
+ * of columns that hold still.
+ */
+export function columnWidths(rows: string[][], width: number): number[] {
+  const widths = new Array<number>(width).fill(MIN_WIDTH_CH);
+  const limit = Math.min(rows.length, WIDTH_SAMPLE_ROWS);
+  for (let r = 0; r < limit; r++) {
+    const row = rows[r];
+    for (let c = 0; c < row.length && c < width; c++) {
+      if (row[c].length > widths[c]) widths[c] = row[c].length;
+    }
+  }
+  return widths.map((w) => Math.min(w, MAX_WIDTH_CH));
+}
diff --git a/src/lib/viewers/tex.ts b/src/lib/viewers/tex.ts
index 684de4c..191a792 100644
--- a/src/lib/viewers/tex.ts
+++ b/src/lib/viewers/tex.ts
@@ -1,5 +1,6 @@
 import { invoke } from "@tauri-apps/api/core";
 import { internalViewerFor, type FileEntry, type InternalViewer } from "./fileUtils";
+import { basename, dirname, isAbsolute, normalizePath, resolvePath } from "../paths";
 
 /** Which TeX tools are on PATH; mirrors the backend `TexCapability`. */
 export type TexCapability = {
@@ -34,6 +35,16 @@ export function getTexCapability(): Promise<TexCapability> {
   return texCapPromise;
 }
 
+/** Drop the cached probe and re-query the backend. The one-shot cache above is
+ *  right for a probe that never changes mid-session, but it goes stale the
+ *  moment the user installs a TeX distribution from the "no engine found"
+ *  banner — call this after that install (or from a manual "Recheck") so the
+ *  viewer picks up the newly-detected engine without an app restart. */
+export function refreshTexCapability(): Promise<TexCapability> {
+  texCapPromise = null;
+  return getTexCapability();
+}
+
 /** Last meaningful line of a build log, for a terse error message. */
 export function lastLogLine(log: string): string {
   const lines = log.split("\n").map((l) => l.trim()).filter(Boolean);
@@ -84,10 +95,10 @@ export function parseTexErrors(log: string): TexError[] {
  *  (the TeX root's folder) into an absolute path the editor can open. Absolute
  *  paths and `./`-relative paths are both handled. */
 export function resolveTexErrorPath(rootDir: string, file: string): string {
-  if (file.startsWith("/")) return file;
-  const rel = file.replace(/^\.\//, "");
-  const base = rootDir.replace(/\/+$/, "");
-  return base ? `${base}/${rel}` : rel;
+  // Absolute (POSIX `/x`, Windows `C:\x` / UNC) passes through unchanged.
+  if (isAbsolute(file)) return file;
+  const rel = file.replace(/^\.[/\\]+/, "");
+  return rootDir ? resolvePath(rootDir, rel) : rel;
 }
 
 // --- SyncTeX forward/reverse search -----------------------------------------
@@ -207,9 +218,8 @@ export function pickSyncRect(records: SyncRect[], frac: number): SyncRect | null
  *  (deduped). Pure / unit-tested — {@link synctexViewBest} feeds each to
  *  `synctex view -i` until one matches. */
 export function forwardInputCandidates(input: string, rootDir: string): string[] {
-  const dir = rootDir.replace(/\/+$/, "") + "/";
-  const rel = input.startsWith(dir) ? input.slice(dir.length) : null;
-  const base = input.slice(input.lastIndexOf("/") + 1);
+  const rel = forwardRelative(rootDir, input);
+  const base = basename(input);
   // SyncTeX may have stored the path with a `./` prefix (a common engine
   // spelling); try those forms too.
   const out: string[] = [input];
@@ -220,6 +230,18 @@ export function forwardInputCandidates(input: string, rootDir: string): string[]
   return Array.from(new Set(out));
 }
 
+/** `file` expressed relative to directory `dir`, using forward slashes (the
+ *  spelling SyncTeX records on every platform), or null when `file` is not under
+ *  `dir`. Accepts either separator on either argument so it is correct for native
+ *  Windows paths (`C:\proj` + `C:\proj\ch\x.tex` → `ch/x.tex`) as well as POSIX. */
+function forwardRelative(dir: string, file: string): string | null {
+  const trimmed = dir.replace(/[/\\]+$/, "");
+  if (!trimmed) return null;
+  const nDir = trimmed.replace(/\\/g, "/");
+  const nFile = file.replace(/\\/g, "/");
+  return nFile.startsWith(nDir + "/") ? nFile.slice(nDir.length + 1) : null;
+}
+
 /** Resolve the file that should actually be compiled for `path` (a child file
  *  redirects to its main document). Falls back to `path` on any error. */
 export function resolveTexRoot(path: string): Promise<string> {
@@ -260,6 +282,56 @@ export function bigPointsToCssRect(
   };
 }
 
+/**
+ * Find every occurrence of `query` in a PDF page's extracted text runs,
+ * returning one entry per match — each a list of big-point boxes ({@link
+ * SyncRect}) covering it. Most matches yield a single box; a match that straddles
+ * text-run boundaries yields one box per run it touches. Case-insensitive unless
+ * `caseSensitive`. The runs are concatenated in reading order exactly as pdf.js
+ * emits them (no inserted separators), so a query matches the text a reader sees;
+ * each run's box is sliced by the matched character span using its uniform
+ * per-character width. An empty query (or no items) yields no matches. Pure —
+ * unit-tested; the caller derives `items` via `getTextContent()` at scale 1, the
+ * same boxes SyncTeX word-refinement uses, so highlights sit on the glyphs.
+ */
+export function pdfPageMatches(
+  items: TextItemBox[],
+  page: number,
+  query: string,
+  caseSensitive: boolean,
+): SyncRect[][] {
+  if (!query) return [];
+  // Concatenate the runs, remembering each run's start offset in the joined text.
+  let text = "";
+  const starts: number[] = [];
+  for (const it of items) {
+    starts.push(text.length);
+    text += it.str;
+  }
+  const hay = caseSensitive ? text : text.toLowerCase();
+  const needle = caseSensitive ? query : query.toLowerCase();
+  const out: SyncRect[][] = [];
+  for (let from = 0; ; ) {
+    const idx = hay.indexOf(needle, from);
+    if (idx < 0) break;
+    const end = idx + needle.length;
+    const rects: SyncRect[] = [];
+    for (let i = 0; i < items.length; i++) {
+      const it = items[i];
+      const s = starts[i];
+      const e = s + it.str.length;
+      if (e <= idx || s >= end || it.w <= 0 || it.str.length === 0) continue;
+      const a = Math.max(idx, s) - s; // first matched char within this run
+      const b = Math.min(end, e) - s; // one past the last matched char
+      const charW = it.w / it.str.length;
+      rects.push({ page, x: it.x + a * charW, y: it.y, w: (b - a) * charW, h: it.h });
+    }
+    if (rects.length) out.push(rects);
+    from = end; // non-overlapping, mirroring findMatches
+  }
+  return out;
+}
+
 /** Character offset of the start of (1-based) `line` in `text`. Clamped to the
  *  valid range; a line past the end maps to the text length. */
 export function lineStartOffset(text: string, line: number): number {
@@ -702,20 +774,24 @@ export interface ResolvedTexRef {
  * null when no extension can be assumed (a bare `\includegraphics`) or no viewer
  * handles the file type.
  */
-export function resolveTexRef(currentPath: string, target: TexRefTarget): ResolvedTexRef | null {
+export function resolveTexRef(
+  currentPath: string,
+  target: TexRefTarget,
+  disabled?: ReadonlySet<InternalViewer>,
+): ResolvedTexRef | null {
   const def = TEX_REF_COMMANDS[target.command] ?? null;
   const token = target.token.trim();
   if (!token) return null;
 
-  const base = token.slice(token.lastIndexOf("/") + 1);
+  const base = basename(token);
   const dot = base.lastIndexOf(".");
   const hasExt = dot > 0 && dot < base.length - 1;
   const rel = hasExt ? token : def == null ? null : token + def;
   if (rel == null) return null;
 
-  const dir = currentPath.slice(0, currentPath.lastIndexOf("/"));
-  const abs = rel.startsWith("/") ? normalizePath(rel) : normalizePath(`${dir}/${rel}`);
-  const name = abs.slice(abs.lastIndexOf("/") + 1);
+  const dir = dirname(currentPath);
+  const abs = resolvePath(dir, rel);
+  const name = basename(abs);
   const lastDot = name.lastIndexOf(".");
   const extension = lastDot > 0 ? name.slice(lastDot).toLowerCase() : null;
   const entry: FileEntry = {
@@ -726,7 +802,7 @@ export function resolveTexRef(currentPath: string, target: TexRefTarget): Resolv
     extension,
     mime: null,
   };
-  const viewer = internalViewerFor(entry);
+  const viewer = internalViewerFor(entry, disabled);
   if (!viewer) return null;
   return { path: abs, viewer, label: name };
 }
@@ -750,22 +826,24 @@ const GRAPHICS_EXTS = [
 export async function resolveTexRefAsync(
   currentPath: string,
   target: TexRefTarget,
+  disabled?: ReadonlySet<InternalViewer>,
 ): Promise<ResolvedTexRef | null> {
-  const direct = resolveTexRef(currentPath, target);
+  const direct = resolveTexRef(currentPath, target, disabled);
   if (direct) return direct;
   if (target.command !== "includegraphics") return null;
 
   const token = target.token.trim();
   if (!token) return null;
+  // TeX reference tokens are written with forward slashes regardless of OS.
   const slash = token.lastIndexOf("/");
   const sub = slash >= 0 ? token.slice(0, slash) : "";
   const stem = (slash >= 0 ? token.slice(slash + 1) : token).toLowerCase();
   if (!stem) return null;
 
-  const dir = currentPath.slice(0, currentPath.lastIndexOf("/"));
-  const absDir = token.startsWith("/")
+  const dir = dirname(currentPath);
+  const absDir = isAbsolute(token)
     ? normalizePath(sub || "/")
-    : normalizePath(`${dir}/${sub}`);
+    : resolvePath(dir, sub);
 
   let entries: FileEntry[];
   try {
@@ -786,7 +864,7 @@ export async function resolveTexRefAsync(
     if (!best || rank < best.rank) best = { entry: e, rank };
   }
   if (!best) return null;
-  const viewer = internalViewerFor(best.entry);
+  const viewer = internalViewerFor(best.entry, disabled);
   if (!viewer) return null;
   return { path: best.entry.path, viewer, label: best.entry.name };
 }
@@ -978,11 +1056,11 @@ function texCommandTokens(source: string, commands: string[]): string[] {
 /** Resolve a `\input`/`\bibliography` token to an absolute path against the
  *  referencing file's dir, appending `defExt` when it has none. */
 function resolveSibling(fromFile: string, token: string, defExt: string): string {
-  const base = token.slice(token.lastIndexOf("/") + 1);
+  const base = basename(token);
   const hasExt = base.includes(".");
   const rel = hasExt ? token : token + defExt;
-  const dir = fromFile.slice(0, fromFile.lastIndexOf("/")) || "/";
-  return rel.startsWith("/") ? normalizePath(rel) : normalizePath(`${dir}/${rel}`);
+  const dir = dirname(fromFile) || "/";
+  return resolvePath(dir, rel);
 }
 
 const TEX_INPUT_CMDS = ["input", "include", "subfile", "subfileinclude"];
@@ -1003,7 +1081,10 @@ export interface TexCompletions {
  * best-effort: a missing/unreadable file is skipped. Pure parsing is delegated
  * to the tested helpers above.
  */
-export async function gatherTexCompletions(currentPath: string): Promise<TexCompletions> {
+export async function gatherTexCompletions(
+  currentPath: string,
+  projectId: string | null = null,
+): Promise<TexCompletions> {
   const root = await resolveTexRoot(currentPath);
   const seenTex = new Set<string>();
   const queue = [root, currentPath];
@@ -1016,7 +1097,7 @@ export async function gatherTexCompletions(currentPath: string): Promise<TexComp
     seenTex.add(file);
     let text: string;
     try {
-      text = await invoke<string>("read_file_text", { path: file });
+      text = await invoke<string>("read_file_text", { path: file, projectId });
     } catch {
       continue;
     }
@@ -1034,7 +1115,7 @@ export async function gatherTexCompletions(currentPath: string): Promise<TexComp
   for (const bib of bibPaths) {
     let text: string;
     try {
-      text = await invoke<string>("read_file_text", { path: bib });
+      text = await invoke<string>("read_file_text", { path: bib, projectId });
     } catch {
       continue;
     }
@@ -1047,19 +1128,3 @@ export async function gatherTexCompletions(currentPath: string): Promise<TexComp
 
   return { labels: Array.from(new Set(labels)), cites };
 }
-
-/** Collapse `.`/`..` segments in a `/`-separated path, preserving a leading `/`. */
-function normalizePath(p: string): string {
-  const isAbs = p.startsWith("/");
-  const out: string[] = [];
-  for (const seg of p.split("/")) {
-    if (seg === "" || seg === ".") continue;
-    if (seg === "..") {
-      if (out.length && out[out.length - 1] !== "..") out.pop();
-      else if (!isAbs) out.push("..");
-    } else {
-      out.push(seg);
-    }
-  }
-  return (isAbs ? "/" : "") + out.join("/");
-}
diff --git a/src/lib/viewers/yaml.ts b/src/lib/viewers/yaml.ts
new file mode 100644
index 0000000..19f3a9b
--- /dev/null
+++ b/src/lib/viewers/yaml.ts
@@ -0,0 +1,1930 @@
+/**
+ * The YAML/JSON tree model and its edit operations (#yaml).
+ *
+ * The tree is a VIEW ON THE TEXT, never a replacement for it: every edit is a
+ * surgical splice back into the source. Re-serializing the parsed model — the
+ * obvious shortcut — would rewrite the whole file and drop every comment in it,
+ * which for a config file is the one thing you must not do. Splicing instead
+ * keeps comments, blank lines, quoting style, anchors and key order exactly as
+ * the author left them, and it is what lets Tree and Source be two views on ONE
+ * draft: switching modes converts nothing, and Ctrl+S / undo / redo / format /
+ * validation keep working on the text underneath.
+ *
+ * BOTH of YAML's syntaxes are first-class here, because real files mix them:
+ *  - **block** style (`key:` / `- item`), structured by indentation, and
+ *  - **flow** style (`{a: 1, b: [2, 3]}`) — which is also, exactly, JSON. A flow
+ *    collection parses into real map/seq nodes with real children whether it sits
+ *    on one line or spreads over twenty, so a JSON-formatted `.yml` — and a
+ *    `.json` file, which is the same thing — opens as a tree rather than as one
+ *    opaque blob.
+ * Which syntax a node is written in decides how it is edited, and the tree keeps
+ * the author's choice: a block node is spliced by LINES, a flow node by its SPAN,
+ * so adding to `[a, b]` yields `[a, b, c]` and never a silent rewrite into block.
+ * Every node therefore carries absolute text offsets (key, value, whole span);
+ * block nodes additionally carry the lines they own.
+ *
+ * `strict` (set for `.json`) is the one thing the writer needs to know about the
+ * dialect: JSON has no plain scalars, so a key or value written there is quoted
+ * unless it is a number/bool/null.
+ *
+ * COMMENTS are a node's own, not scenery. A `#` is the only place a YAML file can
+ * say what a key means, so each node reads the one written behind its value and the
+ * run written directly above it at its own indent, the tree shows that on the key,
+ * and it is editable. The consequence is in the edits: a comment TRAVELS with the
+ * node it belongs to — deleting or reordering a key takes its description along,
+ * because a description left behind would silently come to sit above whichever key
+ * slid into that place, and describe the wrong thing.
+ *
+ * What it will not do: a construct it can render but could not rewrite without
+ * botching it — an anchor, an alias, a merge key, a plain scalar continued across
+ * lines — parses to an `editable: false` node, so the tree never offers an edit it
+ * cannot make. A line it cannot classify at all fails the parse (`YamlDoc.error`)
+ * and the tree defers to Source rather than showing a structure that isn't the
+ * file's.
+ *
+ * Pure: no React, no Tauri, no fs. Unit-tested in `src/__tests__/Yaml*.test.ts`.
+ */
+
+export type YamlKind = "map" | "seq" | "scalar";
+
+/** How a scalar is written, so an edit round-trips in the author's own style.
+ *  "empty" is a key with no value at all (`key:`) — YAML null, and the one place
+ *  a scalar can still grow children. */
+export type ScalarStyle = "plain" | "single" | "double" | "block" | "empty";
+
+export interface YamlNode {
+  /** Stable across re-parses (it is the node's path), so the tree's collapse
+   *  state and the row being edited survive the re-parse an edit triggers. */
+  id: string;
+  /** Keys and sequence indices from the document root down to this node. */
+  path: (string | number)[];
+  kind: YamlKind;
+  /** Decoded mapping key; null for sequence items and document roots. */
+  key: string | null;
+  /** The key exactly as written (quotes included), or null. */
+  keyRaw: string | null;
+  /** Absolute offsets of the key token, for an in-place rename. */
+  keyStart: number;
+  keyEnd: number;
+  /** Scalars: the decoded value (a block scalar's body, dedented). "" otherwise. */
+  value: string;
+  /** Scalars: the value exactly as written. */
+  raw: string;
+  style: ScalarStyle;
+  /** Absolute offsets of the value token. For "empty" both sit at the insertion
+   *  point right after the `:` / `-`, so writing a first value splices there. */
+  valueStart: number;
+  valueEnd: number;
+  /** The node's whole span (key through value/children) — what a flow edit moves. */
+  start: number;
+  end: number;
+  /** Block scalars only: the column their body lines are indented to. */
+  blockIndent: number;
+  /** A container written in FLOW style: its children are spliced into its own
+   *  span rather than added as lines. -1 when not flow; else the `[`/`{` offset. */
+  flowOpen: number;
+  /** This node lives INSIDE a flow collection, so it owns a span, not lines. */
+  inFlow: boolean;
+  /** 0-based first line of the node. */
+  line: number;
+  /** 0-based last line of the node's block, children included (inclusive). */
+  endLine: number;
+  /** Column of the key / of the `-` (block nodes). */
+  indent: number;
+  /** The `#` comment written BEHIND this node, on its own line ("" when none). */
+  comment: string;
+  /** The `#` comment written ABOVE it: the contiguous run of comment lines directly
+   *  over it at its own indent, `#` markers stripped ("" when none). A blank line
+   *  or a differently-indented comment ends the run, so a node only claims prose
+   *  that is unambiguously about it. */
+  lead: string;
+  /** Offset of the `#` that starts the trailing comment, or -1 when there is none. */
+  commentStart: number;
+  /** Where a trailing comment goes: the end of the node's own content on its line.
+   *  -1 when the node cannot carry one at all — it lives inside a flow collection,
+   *  where a `#` would swallow the closing bracket and everything up to it. */
+  commentAnchor: number;
+  /** Whether the tree may rewrite this node's value in place. */
+  editable: boolean;
+  /** Whether this node can be removed on its own. */
+  deletable: boolean;
+  /** This entry STARTS ON ITS LIST ITEM'S DASH LINE (`- name: a` → the `name`
+   *  key, `- - x` → the first nested item): its first line is shared with the
+   *  dash, so every whole-line edit must splice around the dash — take the line's
+   *  content but leave (or hand over) the `- ` prefix — rather than take the
+   *  line. Its `lead` is also NOT its own to move: a comment run above the dash
+   *  line reads as the item's prose and stays put. */
+  onDash?: boolean;
+  /** Whether this node's comment lives ABOVE its line (a lead comment) rather than
+   *  behind it. Set for a mapping/sequence written on a `-` dash line: a comment
+   *  behind that line would belong to the item's first child (which owns the line),
+   *  so the whole entry is documented on the line above it instead. */
+  leadComment?: boolean;
+  children: YamlNode[];
+}
+
+/** True when the container is written in flow (`{…}` / `[…]`, i.e. JSON) style. */
+export function isFlow(node: YamlNode): boolean {
+  return node.flowOpen >= 0;
+}
+
+export interface YamlDoc {
+  /** One synthetic root per YAML document (`---`-separated); usually just one. */
+  docs: YamlNode[];
+  /** First construct the tree could not classify — the tree defers to Source. */
+  error: { line: number; message: string } | null;
+  /** The document's own indent step, so inserted lines match the file's style. */
+  indentStep: number;
+  /** JSON dialect: no plain scalars, so what is written is quoted or numeric. */
+  strict: boolean;
+}
+
+/** The value a new entry is created with. Mirrors the type picker in the UI. */
+export type YamlValueType = "text" | "number" | "boolean" | "null" | "map" | "seq";
+
+function extOf(path: string): string {
+  const name = (path.split(/[/\\]/).filter(Boolean).pop() ?? path).toLowerCase();
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot) : "";
+}
+
+export function isYamlPath(path: string): boolean {
+  const ext = extOf(path);
+  return ext === ".yaml" || ext === ".yml";
+}
+
+/** JSON is YAML's flow syntax, so it gets the same tree — written back in the
+ *  stricter dialect (see {@link YamlDoc.strict}). */
+export function isJsonPath(path: string): boolean {
+  return extOf(path) === ".json";
+}
+
+/** Every path the structure tree can edit. */
+export function isTreePath(path: string): boolean {
+  return isYamlPath(path) || isJsonPath(path);
+}
+
+// ── Text plumbing ───────────────────────────────────────────────────────────
+// Block edits address whole lines, flow edits address spans; both splice into the
+// original string by offset, so nothing outside the edited region — including a
+// mixed or missing trailing newline — is rewritten.
+
+interface LineIndex {
+  lines: string[];
+  /** Offset of each line's first character. */
+  starts: number[];
+  eol: string;
+}
+
+function indexLines(text: string): LineIndex {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const lines: string[] = [];
+  const starts: number[] = [];
+  let at = 0;
+  for (;;) {
+    const nl = text.indexOf("\n", at);
+    starts.push(at);
+    if (nl === -1) {
+      lines.push(text.slice(at));
+      break;
+    }
+    const end = nl > at && text[nl - 1] === "\r" ? nl - 1 : nl;
+    lines.push(text.slice(at, end));
+    at = nl + 1;
+  }
+  return { lines, starts, eol };
+}
+
+function lineOfOffset(starts: number[], offset: number): number {
+  let lo = 0;
+  let hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+
+/** The plain splice every edit ultimately reduces to. */
+function splice(text: string, from: number, to: number, next: string): string {
+  return text.slice(0, from) + next + text.slice(to);
+}
+
+/** Replace lines [from..to] (inclusive) with `next`; `next` empty deletes them. */
+function replaceLines(text: string, from: number, to: number, next: string[]): string {
+  const idx = indexLines(text);
+  if (from < 0 || to >= idx.lines.length || from > to) return text;
+  const start = idx.starts[from];
+  const end = to + 1 < idx.starts.length ? idx.starts[to + 1] : text.length;
+  // Only re-terminate the replacement when the region we cut was terminated —
+  // otherwise a file with no trailing newline would grow one.
+  const cutEndedWithEol = end > start && text[end - 1] === "\n";
+  let body = next.map((l) => l + idx.eol).join("");
+  if (body && !cutEndedWithEol) body = body.slice(0, -idx.eol.length);
+  return splice(text, start, end, body);
+}
+
+/** Insert `next` before line `at` (== line count appends at EOF). */
+function insertLines(text: string, at: number, next: string[]): string {
+  if (!next.length) return text;
+  const idx = indexLines(text);
+  if (at >= idx.lines.length) {
+    const needsEol = text.length > 0 && !text.endsWith("\n");
+    return text + (needsEol ? idx.eol : "") + next.map((l) => l + idx.eol).join("");
+  }
+  const start = idx.starts[Math.max(0, at)];
+  return splice(text, start, start, next.map((l) => l + idx.eol).join(""));
+}
+
+// ── Encoding ────────────────────────────────────────────────────────────────
+
+const SPECIAL_FIRST = new Set([
+  "-", "?", ":", ",", "[", "]", "{", "}", "#", "&", "*", "!", "|", ">", "'", '"',
+  "%", "@", "`",
+]);
+
+/** True when the value must be quoted to survive a round-trip as written. */
+export function needsQuoting(value: string): boolean {
+  if (value === "") return true;
+  if (/^\s|\s$/.test(value)) return true;
+  if (SPECIAL_FIRST.has(value[0])) return true;
+  if (value.includes(": ") || value.endsWith(":")) return true;
+  if (value.includes(" #")) return true;
+  if (/[\n\r\t]/.test(value)) return true;
+  return false;
+}
+
+/** True when a plain (unquoted) `value` would be read back as a non-string —
+ *  a number, a bool, a null. Quoting is what makes "no" the string "no". */
+export function parsesAsNonString(value: string): boolean {
+  const v = value.trim();
+  if (v === "") return false;
+  if (/^-?(\d+|\d*\.\d+)([eE][+-]?\d+)?$/.test(v)) return true;
+  if (/^0[xob][0-9a-fA-F_]+$/.test(v)) return true;
+  return /^(true|false|yes|no|on|off|null|~)$/i.test(v);
+}
+
+/** True when `v` is a bare JSON literal — the only things JSON leaves unquoted. */
+function isJsonLiteral(v: string): boolean {
+  return /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(v) || v === "true" || v === "false" || v === "null";
+}
+
+function encodeDouble(value: string): string {
+  const escaped = value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, "\\n")
+    .replace(/\r/g, "\\r")
+    .replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+}
+
+function encodeSingle(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+/**
+ * Write `value` back in `style`, falling back to a quoted form when the style
+ * cannot carry it. In `strict` (JSON) there are no plain scalars at all, so
+ * anything that is not a bare literal comes back quoted.
+ */
+export function encodeScalar(value: string, style: ScalarStyle, strict = false): string {
+  if (style === "double") return encodeDouble(value);
+  if (style === "single") return value.includes("\n") ? encodeDouble(value) : encodeSingle(value);
+  if (strict) return isJsonLiteral(value.trim()) ? value.trim() : encodeDouble(value);
+  return needsQuoting(value) ? encodeDouble(value) : value;
+}
+
+/** A mapping key, quoted only when it must be — which in JSON is always. */
+export function encodeKey(key: string, strict = false): string {
+  if (
+    strict ||
+    key === "" ||
+    /^\s|\s$/.test(key) ||
+    SPECIAL_FIRST.has(key[0]) ||
+    key.includes(":") ||
+    key.includes("#")
+  ) {
+    return encodeDouble(key);
+  }
+  return key;
+}
+
+/**
+ * The literal a newly added entry is written with. In YAML, `text` quotes whenever
+ * a plain token would read back as a number/bool/null, so the type the user picked
+ * is the type the file gets; in JSON every string is quoted anyway. A container is
+ * created as an EMPTY FLOW collection (`{}` / `[]`) — a real, empty collection in
+ * either dialect, which the tree then adds children to in flow style.
+ */
+export function literalFor(type: YamlValueType, value: string, strict = false): string {
+  switch (type) {
+    case "number":
+      return value.trim() === "" ? "0" : value.trim();
+    case "boolean":
+      return value.trim().toLowerCase() === "true" ? "true" : "false";
+    case "null":
+      return "null";
+    case "map":
+      return "{}";
+    case "seq":
+      return "[]";
+    default:
+      if (strict) return encodeDouble(value);
+      return needsQuoting(value) || parsesAsNonString(value) ? encodeDouble(value) : value;
+  }
+}
+
+function decodeDouble(raw: string): string {
+  const body = raw.slice(1, -1);
+  return body.replace(/\\(u[0-9a-fA-F]{4}|.)/g, (_m, esc: string) => {
+    if (esc[0] === "u") return String.fromCharCode(parseInt(esc.slice(1), 16));
+    switch (esc) {
+      case "n": return "\n";
+      case "t": return "\t";
+      case "r": return "\r";
+      case "0": return "\0";
+      default: return esc;
+    }
+  });
+}
+
+function decodeSingle(raw: string): string {
+  return raw.slice(1, -1).replace(/''/g, "'");
+}
+
+function decodeQuoted(raw: string): string {
+  return raw[0] === '"' ? decodeDouble(raw) : decodeSingle(raw);
+}
+
+// ── Scanning ────────────────────────────────────────────────────────────────
+
+/** End index (exclusive) of the quoted token starting at `start`, or -1 when it is
+ *  not terminated in `s`. Used on a single line (block) and on the whole text
+ *  (flow), which is why it takes the string rather than a line. */
+function scanQuoted(s: string, start: number): number {
+  const q = s[start];
+  let i = start + 1;
+  while (i < s.length) {
+    const c = s[i];
+    if (q === '"' && c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === q) {
+      if (q === "'" && s[i + 1] === "'") {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return -1;
+}
+
+const BLOCK_HEADER = /^[|>][+-]?\d*\s*(#.*)?$/;
+
+interface ScannedValue {
+  raw: string;
+  value: string;
+  style: ScalarStyle;
+  valueCol: number;
+  valueEnd: number;
+  /** An unterminated quote — the scalar continues on the next line. */
+  open: boolean;
+  /** An anchor/alias/tag prefix — we render it, we never rewrite it. */
+  opaque: boolean;
+  /** A block scalar header (`|`, `>-`, …) — its body is on the lines below. */
+  block: boolean;
+  /** A flow collection starts here — the flow parser takes over at `valueCol`. */
+  flow: boolean;
+}
+
+const NO_FLAGS = { open: false, opaque: false, block: false, flow: false };
+
+/** Read the value token that starts at/after `from` on `line`. `from` is the
+ *  insertion point (just past the `:` or `-`), so an empty value reports itself
+ *  there and a first value splices in exactly the right place. */
+function readValue(line: string, from: number): ScannedValue {
+  let i = from;
+  while (i < line.length && (line[i] === " " || line[i] === "\t")) i++;
+  if (i >= line.length || line[i] === "#") {
+    return { raw: "", value: "", style: "empty", valueCol: from, valueEnd: from, ...NO_FLAGS };
+  }
+
+  const c = line[i];
+  if (c === '"' || c === "'") {
+    const end = scanQuoted(line, i);
+    if (end < 0) {
+      return {
+        raw: line.slice(i), value: line.slice(i), style: "plain",
+        valueCol: i, valueEnd: line.length, ...NO_FLAGS, open: true,
+      };
+    }
+    const raw = line.slice(i, end);
+    return {
+      raw, value: decodeQuoted(raw), style: c === '"' ? "double" : "single",
+      valueCol: i, valueEnd: end, ...NO_FLAGS,
+    };
+  }
+
+  if (c === "[" || c === "{") {
+    // The flow parser owns this — it may well run past the end of the line.
+    return { raw: "", value: "", style: "plain", valueCol: i, valueEnd: i, ...NO_FLAGS, flow: true };
+  }
+
+  const rest = line.slice(i);
+  if (BLOCK_HEADER.test(rest)) {
+    const header = rest.replace(/\s*#.*$/, "");
+    return {
+      raw: header, value: "", style: "block",
+      valueCol: i, valueEnd: i + header.length, ...NO_FLAGS, block: true,
+    };
+  }
+
+  // Plain scalar: runs to a ` #` comment or the end of the line.
+  let end = line.length;
+  for (let j = i; j < line.length; j++) {
+    if (line[j] === "#" && j > i && (line[j - 1] === " " || line[j - 1] === "\t")) {
+      end = j;
+      break;
+    }
+  }
+  while (end > i && (line[end - 1] === " " || line[end - 1] === "\t")) end--;
+  const raw = line.slice(i, end);
+  return {
+    raw, value: raw, style: "plain", valueCol: i, valueEnd: end,
+    ...NO_FLAGS, opaque: c === "&" || c === "*" || c === "!",
+  };
+}
+
+interface ScannedKey {
+  keyRaw: string;
+  key: string;
+  keyCol: number;
+  keyEnd: number;
+  /** Column just past the `:`, where the value begins. */
+  afterColon: number;
+}
+
+/** Read a block mapping key starting at `from`, or null when this line does not
+ *  open a mapping entry (no `:` terminator before a comment/EOL). */
+function readKey(line: string, from: number): ScannedKey | null {
+  const c = line[from];
+  if (c === undefined || c === "#") return null;
+
+  let keyEnd: number;
+  if (c === '"' || c === "'") {
+    const end = scanQuoted(line, from);
+    if (end < 0) return null;
+    keyEnd = end;
+  } else {
+    let j = from;
+    let found = -1;
+    while (j < line.length) {
+      const ch = line[j];
+      if (ch === "#" && j > from && line[j - 1] === " ") return null;
+      if (ch === ":" && (j + 1 === line.length || line[j + 1] === " " || line[j + 1] === "\t")) {
+        found = j;
+        break;
+      }
+      j++;
+    }
+    if (found < 0) return null;
+    keyEnd = found;
+    while (keyEnd > from && (line[keyEnd - 1] === " " || line[keyEnd - 1] === "\t")) keyEnd--;
+  }
+
+  let colon = keyEnd;
+  while (colon < line.length && (line[colon] === " " || line[colon] === "\t")) colon++;
+  if (line[colon] !== ":") return null;
+
+  const keyRaw = line.slice(from, keyEnd);
+  const key = keyRaw[0] === '"' || keyRaw[0] === "'" ? decodeQuoted(keyRaw) : keyRaw;
+  return { keyRaw, key, keyCol: from, keyEnd, afterColon: colon + 1 };
+}
+
+/** A flow mapping key, addressed by absolute offsets (it can sit anywhere). */
+interface FlowKey {
+  keyRaw: string;
+  key: string;
+  start: number;
+  end: number;
+  /** Offset just past the `:`. */
+  colonEnd: number;
+}
+
+interface FlowScalar {
+  raw: string;
+  value: string;
+  style: ScalarStyle;
+  start: number;
+  end: number;
+}
+
+// ── Parser ──────────────────────────────────────────────────────────────────
+
+class Bail extends Error {
+  constructor(readonly line: number, readonly reason: string) {
+    super(reason);
+  }
+}
+
+const indentOf = (line: string): number => line.length - line.trimStart().length;
+const isBlank = (line: string): boolean => line.trim() === "";
+const isComment = (line: string): boolean => line.trimStart().startsWith("#");
+const isDirective = (line: string): boolean => line.startsWith("%");
+const isDocStart = (line: string): boolean => line === "---" || line.startsWith("--- ");
+const isDocEnd = (line: string): boolean => line === "..." || line.startsWith("... ");
+
+/** Parse `text` into one tree per YAML document. Never throws: a construct the
+ *  tree cannot model comes back as `error` with the offending 1-based line. */
+export function parseYaml(text: string, opts: { strict?: boolean } = {}): YamlDoc {
+  const strict = !!opts.strict;
+  const { lines, starts } = indexLines(text);
+  const parser = new Parser(lines, starts, text);
+  try {
+    const docs = parser.parseDocuments();
+    return { docs, error: null, indentStep: parser.indentStep(docs), strict };
+  } catch (e) {
+    if (e instanceof Bail) {
+      return { docs: [], error: { line: e.line + 1, message: e.reason }, indentStep: 2, strict };
+    }
+    throw e;
+  }
+}
+
+class Parser {
+  private i = 0;
+  /** A copy of the source lines in which a sequence dash is blanked to a space, so
+   *  a mapping written inline after it (`- name: a`) is read at its true column.
+   *  Same length as the original line, so every column we record is a valid offset
+   *  into the real text. */
+  private view: string[];
+
+  constructor(
+    private readonly lines: string[],
+    private readonly starts: number[],
+    private readonly text: string,
+  ) {
+    this.view = lines.slice();
+  }
+
+  private off(line: number, col: number): number {
+    return this.starts[line] + col;
+  }
+
+  private lineOf(offset: number): number {
+    return lineOfOffset(this.starts, offset);
+  }
+
+  private lineEnd(line: number): number {
+    return this.off(line, this.lines[line]?.length ?? 0);
+  }
+
+  /** The comment run written directly ABOVE line `at` at column `indent`. A blank
+   *  line, a differently-indented comment, or any real content ends it — so a node
+   *  claims only the prose that is unambiguously about it, and never the section
+   *  header two keys up. */
+  private leadAt(at: number, indent: number): string {
+    const out: string[] = [];
+    for (let j = at - 1; j >= 0; j--) {
+      const l = this.lines[j];
+      if (!isComment(l) || indentOf(l) !== indent) break;
+      out.unshift(l.trimStart().replace(/^#[ \t]?/, ""));
+    }
+    return out.join("\n");
+  }
+
+  /** Attach a block node's `#` comments. `col` is where its own content ends on
+   *  `line` — always past its key and value tokens, so a `#` inside a quoted string
+   *  can never be mistaken for the start of a comment. */
+  private annotate(node: YamlNode, line: number, col: number): YamlNode {
+    const l = this.lines[line] ?? "";
+    const hash = l.indexOf("#", col);
+    node.comment = hash < 0 ? "" : l.slice(hash + 1).trim();
+    node.commentStart = hash < 0 ? -1 : this.off(line, hash);
+    node.commentAnchor = this.off(line, col);
+    node.lead = this.leadAt(node.line, node.indent);
+    return node;
+  }
+
+  parseDocuments(): YamlNode[] {
+    const docs: YamlNode[] = [];
+    let docIndex = 0;
+    this.skipIgnorable();
+    while (this.i < this.lines.length) {
+      const l = this.lines[this.i];
+      if (isDocStart(l) || isDocEnd(l)) {
+        this.i++;
+        this.skipIgnorable();
+        continue;
+      }
+      const root = this.parseCollection(indentOf(this.view[this.i]), [], docIndex);
+      if (root) docs.push(root);
+      docIndex++;
+      this.skipIgnorable();
+    }
+    return docs;
+  }
+
+  /** The document's own indent step, read off its first block nesting; 2 default. */
+  indentStep(docs: YamlNode[]): number {
+    const walk = (n: YamlNode): number | null => {
+      if (!isFlow(n) && n.key !== null) {
+        for (const c of n.children) {
+          if (!c.inFlow && c.indent > n.indent) return c.indent - n.indent;
+        }
+      }
+      for (const c of n.children) {
+        const deeper = walk(c);
+        if (deeper) return deeper;
+      }
+      return null;
+    };
+    for (const d of docs) {
+      const step = walk(d);
+      if (step && step > 0) return step;
+    }
+    return 2;
+  }
+
+  private skipIgnorable(): void {
+    while (this.i < this.lines.length) {
+      const l = this.lines[this.i];
+      if (isBlank(l) || isComment(l) || isDirective(l)) this.i++;
+      else break;
+    }
+  }
+
+  /** True when the cursor sits on a line that ends the current block. */
+  private atBoundary(): boolean {
+    if (this.i >= this.lines.length) return true;
+    const l = this.lines[this.i];
+    return isDocStart(l) || isDocEnd(l);
+  }
+
+  /** Parse whatever block starts at the cursor at column `indent`. */
+  private parseCollection(
+    indent: number,
+    path: (string | number)[],
+    docIndex: number,
+  ): YamlNode | null {
+    this.skipIgnorable();
+    if (this.atBoundary()) return null;
+    if (/^\t/.test(this.lines[this.i])) {
+      throw new Bail(this.i, "This file indents with tabs, which YAML does not allow.");
+    }
+    const line = this.view[this.i];
+    // A document written in flow/JSON syntax, however many lines it spans. This is
+    // what makes a JSON file — and a JSON-formatted .yml — a tree.
+    if (line[indent] === "{" || line[indent] === "[") {
+      return this.takeFlow(this.off(this.i, indent), path, docIndex, null, indent);
+    }
+    if (this.isSeqDash(line, indent)) return this.parseSeq(indent, path, docIndex);
+    return this.parseMap(indent, path, docIndex);
+  }
+
+  /** Parse a flow collection, then resume block parsing on the line after it. */
+  private takeFlow(
+    at: number,
+    path: (string | number)[],
+    docIndex: number,
+    k: ScannedKey | null,
+    indent: number,
+  ): YamlNode {
+    const keyLine = this.lineOf(at);
+    const fk: FlowKey | null = k
+      ? {
+          keyRaw: k.keyRaw,
+          key: k.key,
+          start: this.off(keyLine, k.keyCol),
+          end: this.off(keyLine, k.keyEnd),
+          colonEnd: this.off(keyLine, k.afterColon),
+        }
+      : null;
+    const node = this.parseFlowCollection(at, path, docIndex, fk, false);
+    node.line = keyLine;
+    node.endLine = this.lineOf(node.end);
+    node.indent = indent;
+    // Its key sits on a block line, so it can carry a comment after all — behind the
+    // closing bracket, wherever the author put that.
+    this.annotate(node, node.endLine, node.end - this.starts[node.endLine]);
+    // A flow value can run past its own line; block parsing resumes after it.
+    this.i = node.endLine + 1;
+    return node;
+  }
+
+  private isSeqDash(line: string, indent: number): boolean {
+    return line[indent] === "-" && (line.length === indent + 1 || line[indent + 1] === " ");
+  }
+
+  private parseMap(indent: number, path: (string | number)[], docIndex: number): YamlNode {
+    const start = this.i;
+    const children: YamlNode[] = [];
+    let endLine = start;
+
+    for (;;) {
+      this.skipIgnorable();
+      if (this.atBoundary()) break;
+      const line = this.view[this.i];
+      const ind = indentOf(line);
+      if (ind < indent) break;
+      if (ind > indent) throw new Bail(this.i, "Unexpected indentation.");
+      if (this.isSeqDash(line, ind)) break;
+      if (line.slice(ind).startsWith("? ")) {
+        throw new Bail(this.i, "Explicit keys (`? `) aren't supported by the tree.");
+      }
+
+      const child = this.parseMapEntry(indent, path, docIndex);
+      children.push(child);
+      endLine = child.endLine;
+    }
+
+    return this.container("map", null, path, docIndex, start, endLine, indent, children);
+  }
+
+  /** One `key: …` entry, including whatever block hangs below it. */
+  private parseMapEntry(indent: number, path: (string | number)[], docIndex: number): YamlNode {
+    const at = this.i;
+    const line = this.view[at];
+    const k = readKey(line, indent);
+    if (!k) throw new Bail(at, "This line isn't a `key: value` pair the tree can read.");
+    const childPath = [...path, k.key];
+    const v = readValue(line, k.afterColon);
+    this.i++;
+    if (v.flow) return this.takeFlow(this.off(at, v.valueCol), childPath, docIndex, k, indent);
+    return this.finishValue(at, indent, k, v, childPath, docIndex);
+  }
+
+  private parseSeq(indent: number, path: (string | number)[], docIndex: number): YamlNode {
+    const start = this.i;
+    const items: YamlNode[] = [];
+    let endLine = start;
+
+    for (;;) {
+      this.skipIgnorable();
+      if (this.atBoundary()) break;
+      const line = this.view[this.i];
+      const ind = indentOf(line);
+      if (ind < indent) break;
+      if (ind > indent || !this.isSeqDash(line, ind)) break;
+
+      const item = this.parseSeqItem(indent, [...path, items.length], docIndex);
+      items.push(item);
+      endLine = item.endLine;
+    }
+
+    return this.container("seq", null, path, docIndex, start, endLine, indent, items);
+  }
+
+  private parseSeqItem(indent: number, path: (string | number)[], docIndex: number): YamlNode {
+    const at = this.i;
+    const line = this.view[at];
+    // The content column: the first non-space after the dash.
+    let content = indent + 1;
+    while (content < line.length && line[content] === " ") content++;
+    const rest = line.slice(content);
+
+    if (rest === "" || rest.startsWith("#")) {
+      // A bare `-`: whatever hangs below it (indented past the dash) is the item.
+      this.i++;
+      const child = this.childBlock(indent, path, docIndex);
+      if (child) {
+        const node = this.container(
+          child.kind, null, path, docIndex, at, child.endLine, indent, child.children,
+        );
+        node.flowOpen = child.flowOpen;
+        node.end = child.end;
+        return node;
+      }
+      return this.scalar(null, path, docIndex, at, indent, {
+        raw: "", value: "", style: "empty",
+        valueCol: indent + 1, valueEnd: indent + 1, ...NO_FLAGS,
+      }, true, true);
+    }
+
+    if (this.isSeqDash(line, content)) {
+      // `- - x` — the item is a nested SEQUENCE that starts on the dash's own line.
+      // Same trick as `- key: value` below: blank the outer dash in the parse view
+      // so the nested list reads at column `content`, where the items it continues
+      // with on the lines below also sit. It nests to any depth (`- - - x`), because
+      // each level blanks its own dash before handing on.
+      this.view[at] = line.slice(0, indent) + " " + line.slice(indent + 1);
+      const seq = this.parseSeq(content, path, docIndex);
+      // The nested list's first entry shares the outer item's dash line, so its
+      // whole-line edits must splice around the dash (see YamlNode.onDash).
+      if (seq.children.length) seq.children[0].onDash = true;
+      return {
+        ...seq,
+        line: at,
+        indent,
+        path,
+        id: idFor(docIndex, path),
+        start: this.off(at, indent),
+        // The item is written at the dash's column, so that is where the prose about
+        // it sits — not at the nested list's.
+        lead: this.leadAt(at, indent),
+        // A comment on this item is written above its dash line (a comment behind
+        // it would belong to the nested list's first entry, which owns the line).
+        leadComment: true,
+      };
+    }
+
+    // `- {a: 1}` / `- [1, 2]`: the item is a flow collection.
+    if (line[content] === "{" || line[content] === "[") {
+      const node = this.takeFlow(this.off(at, content), path, docIndex, null, indent);
+      node.start = this.off(at, indent);
+      return node;
+    }
+
+    const k = readKey(line, content);
+    if (k) {
+      // `- key: value` — the item is a mapping that starts on the dash's own line.
+      // Blank the dash in the parse view so the mapping reads at column `content`,
+      // where its siblings on the lines below also sit.
+      this.view[at] = line.slice(0, indent) + " " + line.slice(indent + 1);
+      const map = this.parseMap(content, path, docIndex);
+      // The first key shares the item's dash line, so its whole-line edits must
+      // splice around the dash (see YamlNode.onDash).
+      if (map.children.length) map.children[0].onDash = true;
+      return {
+        ...map,
+        line: at,
+        indent,
+        path,
+        id: idFor(docIndex, path),
+        start: this.off(at, indent),
+        lead: this.leadAt(at, indent),
+        // A comment on this item is written above its dash line — behind it would
+        // belong to the first key, which owns the line (`- name: a  # …`).
+        leadComment: true,
+      };
+    }
+
+    const v = readValue(line, content);
+    this.i++;
+    return this.finishValue(at, indent, null, v, path, docIndex);
+  }
+
+  /**
+   * Turn a scanned (non-flow) value into a node, consuming whatever it drags
+   * along: a block scalar's body, an unterminated quote's continuation lines, a
+   * nested block hanging under an empty value, or a plain scalar continued across
+   * lines.
+   */
+  private finishValue(
+    at: number,
+    indent: number,
+    k: ScannedKey | null,
+    v: ScannedValue,
+    path: (string | number)[],
+    docIndex: number,
+  ): YamlNode {
+    if (v.block) {
+      const { endLine, blockIndent, body } = this.readBlockBody(at, indent);
+      const node = this.scalar(k, path, docIndex, at, indent, { ...v, value: body }, true, true);
+      node.endLine = endLine;
+      node.blockIndent = blockIndent;
+      node.end = this.lineEnd(endLine);
+      return node;
+    }
+
+    if (v.open) {
+      // An unterminated quote: swallow lines until it closes. We can render it, we
+      // will never rewrite it.
+      const endLine = this.consumeOpenQuote(at, v);
+      const node = this.scalar(k, path, docIndex, at, indent, v, false, true);
+      node.endLine = endLine;
+      node.end = this.lineEnd(endLine);
+      return node;
+    }
+
+    if (v.style === "empty" || (v.opaque && v.raw !== "" && this.hasChildBlock(indent))) {
+      // A block sequence may sit at the SAME column as its key — `key:` on one
+      // line, `- item` at the key's own indent below — which is valid YAML (a
+      // sequence needn't indent past its key). `childBlock` only sees a deeper
+      // block, so try the same-indent sequence when it finds nothing.
+      const child = this.childBlock(indent, path, docIndex)
+        ?? this.sameIndentSeq(indent, path, docIndex);
+      if (child) {
+        const node = this.container(
+          child.kind, k, path, docIndex, at, child.endLine, indent, child.children,
+        );
+        node.flowOpen = child.flowOpen;
+        node.valueStart = this.off(at, v.valueCol);
+        node.valueEnd = this.off(at, v.valueEnd);
+        node.raw = v.raw;
+        node.editable = !v.opaque;
+        node.end = child.end;
+        // The key's own line ends here, so a comment behind it is this node's.
+        return this.annotate(node, at, v.valueEnd);
+      }
+      return this.scalar(k, path, docIndex, at, indent, v, !v.opaque, true);
+    }
+
+    // A scalar with a value. If more-indented lines follow, it is a plain scalar
+    // continued across lines — legal YAML we render but do not rewrite.
+    if (this.hasChildBlock(indent)) {
+      const endLine = this.consumeIndentedBlock(indent);
+      const joined = [v.raw, ...this.lines.slice(at + 1, endLine + 1).map((l) => l.trim())].join(" ");
+      const node = this.scalar(k, path, docIndex, at, indent, { ...v, value: joined }, false, true);
+      node.endLine = endLine;
+      node.end = this.lineEnd(endLine);
+      return node;
+    }
+
+    return this.scalar(k, path, docIndex, at, indent, v, !v.opaque, true);
+  }
+
+  /** True when the line at the cursor belongs to a block nested under `indent`. */
+  private hasChildBlock(indent: number): boolean {
+    const save = this.i;
+    this.skipIgnorable();
+    const ok = !this.atBoundary() && indentOf(this.view[this.i]) > indent;
+    this.i = save;
+    return ok;
+  }
+
+  /** Parse the block nested under a key at `indent`, or null when there is none. */
+  private childBlock(indent: number, path: (string | number)[], docIndex: number): YamlNode | null {
+    if (!this.hasChildBlock(indent)) return null;
+    this.skipIgnorable();
+    return this.parseCollection(indentOf(this.view[this.i]), path, docIndex);
+  }
+
+  /**
+   * A key's value written as a block SEQUENCE at the key's OWN column — valid
+   * YAML (a sequence needn't indent past its key), e.g.
+   *     values:
+   *     - 1
+   *     - 2
+   * Unambiguous in a mapping: a bare `- item` at the key's indent can only be
+   * that key's value, since a map holds `key:` entries, never a lone seq item.
+   * (This is why it's resolved here, not in `childBlock`, which is also called for
+   * a bare `-` seq item, where a same-indent dash is a SIBLING, not a child.)
+   * Returns null — cursor untouched — when the next line isn't such a sequence.
+   */
+  private sameIndentSeq(
+    indent: number,
+    path: (string | number)[],
+    docIndex: number,
+  ): YamlNode | null {
+    const save = this.i;
+    this.skipIgnorable();
+    if (
+      this.atBoundary() ||
+      indentOf(this.view[this.i]) !== indent ||
+      !this.isSeqDash(this.view[this.i], indent)
+    ) {
+      this.i = save;
+      return null;
+    }
+    return this.parseSeq(indent, path, docIndex);
+  }
+
+  /** Consume the lines indented past `indent` (a plain scalar's continuation). */
+  private consumeIndentedBlock(indent: number): number {
+    let end = this.i - 1;
+    while (this.i < this.lines.length) {
+      const l = this.lines[this.i];
+      if (isBlank(l) || isDocStart(l) || isDocEnd(l) || indentOf(l) <= indent) break;
+      end = this.i;
+      this.i++;
+    }
+    return end;
+  }
+
+  /** Consume a block scalar's body: every line indented past the header's key. */
+  private readBlockBody(
+    at: number,
+    indent: number,
+  ): { endLine: number; blockIndent: number; body: string } {
+    const bodyLines: string[] = [];
+    let endLine = at;
+    let blockIndent = -1;
+    while (this.i < this.lines.length) {
+      const l = this.lines[this.i];
+      if (isBlank(l)) {
+        bodyLines.push("");
+        this.i++;
+        continue;
+      }
+      if (isDocStart(l) || isDocEnd(l) || indentOf(l) <= indent) break;
+      if (blockIndent < 0) blockIndent = indentOf(l);
+      bodyLines.push(l.slice(Math.min(blockIndent, indentOf(l))));
+      endLine = this.i;
+      this.i++;
+    }
+    // Trailing blank lines are not part of the node's block: an insertion after it
+    // should land on them, not past them.
+    while (bodyLines.length && bodyLines[bodyLines.length - 1] === "") bodyLines.pop();
+    if (blockIndent < 0) blockIndent = indent + 2;
+    return { endLine, blockIndent, body: bodyLines.join("\n") };
+  }
+
+  /** Swallow the continuation lines of an unterminated quoted scalar. */
+  private consumeOpenQuote(at: number, v: ScannedValue): number {
+    const quote = this.lines[at][v.valueCol];
+    let end = at;
+    while (this.i < this.lines.length) {
+      const l = this.lines[this.i];
+      end = this.i;
+      this.i++;
+      if (l.includes(quote)) break;
+    }
+    return end;
+  }
+
+  // ── Flow (JSON) syntax ────────────────────────────────────────────────────
+  // Offset-driven, because a flow collection is a span, not a set of lines: it may
+  // sit inline (`[a, b]`) or spread over twenty, and its children are edited by
+  // splicing that span rather than by rewriting whole lines.
+
+  /** Skip whitespace, newlines and comments from `o`. */
+  private ws(o: number): number {
+    const t = this.text;
+    while (o < t.length) {
+      const c = t[o];
+      if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+        o++;
+        continue;
+      }
+      if (c === "#") {
+        while (o < t.length && t[o] !== "\n") o++;
+        continue;
+      }
+      break;
+    }
+    return o;
+  }
+
+  /**
+   * Parse the flow collection whose `[`/`{` is at `at`. `k` is the mapping key it
+   * is the value of, when it is one — the node then spans from that key, so
+   * deleting it takes the key with it.
+   */
+  private parseFlowCollection(
+    at: number,
+    path: (string | number)[],
+    docIndex: number,
+    k: FlowKey | null,
+    inFlow: boolean,
+  ): YamlNode {
+    const t = this.text;
+    const isSeq = t[at] === "[";
+    const close = isSeq ? "]" : "}";
+    const children: YamlNode[] = [];
+
+    let p = this.ws(at + 1);
+    while (p < t.length && t[p] !== close) {
+      if (t[p] === ",") {
+        p = this.ws(p + 1);
+        continue;
+      }
+      const child = isSeq
+        ? this.parseFlowValue(p, [...path, children.length], docIndex, null)
+        : this.parseFlowEntry(p, path, docIndex);
+      children.push(child);
+      const next = this.ws(child.end);
+      if (next <= p) break; // no progress: refuse to spin
+      p = next;
+    }
+    if (p >= t.length || t[p] !== close) {
+      throw new Bail(this.lineOf(at), `This \`${t[at]}\` is never closed.`);
+    }
+    const end = p + 1;
+    const line = this.lineOf(at);
+
+    return {
+      id: idFor(docIndex, path),
+      path,
+      kind: isSeq ? "seq" : "map",
+      key: k?.key ?? null,
+      keyRaw: k?.keyRaw ?? null,
+      keyStart: k?.start ?? -1,
+      keyEnd: k?.end ?? -1,
+      value: "",
+      raw: "",
+      style: "empty",
+      valueStart: at,
+      valueEnd: end,
+      start: k ? k.start : at,
+      end,
+      blockIndent: -1,
+      flowOpen: at,
+      inFlow,
+      line,
+      endLine: this.lineOf(end),
+      indent: -1,
+      // Inside a flow collection a `#` would swallow the closing bracket, so there
+      // is nowhere to put one. `takeFlow` annotates the outermost node — the one
+      // whose key sits on a block line, where a comment is safe.
+      comment: "",
+      lead: "",
+      commentStart: -1,
+      commentAnchor: -1,
+      editable: true,
+      deletable: true,
+      children,
+    };
+  }
+
+  /** One `key: value` entry inside a flow mapping. */
+  private parseFlowEntry(at: number, path: (string | number)[], docIndex: number): YamlNode {
+    const t = this.text;
+    const k = this.readFlowKey(at);
+    if (!k) {
+      throw new Bail(this.lineOf(at), "This isn't a `key: value` pair the tree can read.");
+    }
+    const childPath = [...path, k.key];
+    const p = this.ws(k.colonEnd);
+    // `{a: , b: 1}` — an empty value; the insertion point is right after the colon.
+    if (p >= t.length || t[p] === "," || t[p] === "}" || t[p] === "]") {
+      return this.flowScalar(childPath, docIndex, k, {
+        raw: "", value: "", style: "empty", start: k.colonEnd, end: k.colonEnd,
+      });
+    }
+    return this.parseFlowValue(p, childPath, docIndex, k);
+  }
+
+  /** A value inside a flow collection: a nested collection, or a scalar. */
+  private parseFlowValue(
+    at: number,
+    path: (string | number)[],
+    docIndex: number,
+    k: FlowKey | null,
+  ): YamlNode {
+    const c = this.text[at];
+    if (c === "[" || c === "{") return this.parseFlowCollection(at, path, docIndex, k, true);
+    return this.flowScalar(path, docIndex, k, this.readFlowScalar(at));
+  }
+
+  private flowScalar(
+    path: (string | number)[],
+    docIndex: number,
+    k: FlowKey | null,
+    s: FlowScalar,
+  ): YamlNode {
+    const opaque = s.raw[0] === "&" || s.raw[0] === "*" || s.raw[0] === "!";
+    return {
+      id: idFor(docIndex, path),
+      path,
+      kind: "scalar",
+      key: k?.key ?? null,
+      keyRaw: k?.keyRaw ?? null,
+      keyStart: k?.start ?? -1,
+      keyEnd: k?.end ?? -1,
+      value: s.value,
+      raw: s.raw,
+      style: s.style,
+      valueStart: s.start,
+      valueEnd: s.end,
+      start: k ? k.start : s.start,
+      end: s.end,
+      blockIndent: -1,
+      flowOpen: -1,
+      inFlow: true,
+      line: this.lineOf(k ? k.start : s.start),
+      endLine: this.lineOf(s.end),
+      indent: -1,
+      comment: "",
+      lead: "",
+      commentStart: -1,
+      commentAnchor: -1,
+      editable: !opaque,
+      deletable: true,
+      children: [],
+    };
+  }
+
+  /** A flow mapping key: quoted or plain, terminated by `:`. */
+  private readFlowKey(at: number): FlowKey | null {
+    const t = this.text;
+    const c = t[at];
+    let end: number;
+    if (c === '"' || c === "'") {
+      end = scanQuoted(t, at);
+      if (end < 0) return null;
+    } else {
+      let j = at;
+      while (
+        j < t.length &&
+        t[j] !== ":" && t[j] !== "," && t[j] !== "}" && t[j] !== "]" && t[j] !== "\n"
+      ) {
+        j++;
+      }
+      if (t[j] !== ":") return null;
+      end = j;
+      while (end > at && (t[end - 1] === " " || t[end - 1] === "\t")) end--;
+    }
+    const colon = this.ws(end);
+    if (t[colon] !== ":") return null;
+    const keyRaw = t.slice(at, end);
+    return {
+      keyRaw,
+      key: c === '"' || c === "'" ? decodeQuoted(keyRaw) : keyRaw,
+      start: at,
+      end,
+      colonEnd: colon + 1,
+    };
+  }
+
+  /** A scalar inside a flow collection: quoted, or plain up to `,` / `]` / `}`. */
+  private readFlowScalar(at: number): FlowScalar {
+    const t = this.text;
+    const c = t[at];
+    if (c === '"' || c === "'") {
+      const end = scanQuoted(t, at);
+      if (end < 0) throw new Bail(this.lineOf(at), "This quoted value is never closed.");
+      const raw = t.slice(at, end);
+      return {
+        raw, value: decodeQuoted(raw),
+        style: c === '"' ? "double" : "single",
+        start: at, end,
+      };
+    }
+    let j = at;
+    while (j < t.length && t[j] !== "," && t[j] !== "]" && t[j] !== "}" && t[j] !== "\n") {
+      if (t[j] === "#" && j > at && t[j - 1] === " ") break;
+      j++;
+    }
+    let end = j;
+    while (end > at && (t[end - 1] === " " || t[end - 1] === "\t")) end--;
+    const raw = t.slice(at, end);
+    return { raw, value: raw, style: "plain", start: at, end };
+  }
+
+  // ── Node builders ─────────────────────────────────────────────────────────
+
+  private container(
+    kind: YamlKind,
+    k: ScannedKey | null,
+    path: (string | number)[],
+    docIndex: number,
+    line: number,
+    endLine: number,
+    indent: number,
+    children: YamlNode[],
+  ): YamlNode {
+    return {
+      id: idFor(docIndex, path),
+      path,
+      kind,
+      key: k?.key ?? null,
+      keyRaw: k?.keyRaw ?? null,
+      keyStart: k ? this.off(line, k.keyCol) : -1,
+      keyEnd: k ? this.off(line, k.keyEnd) : -1,
+      value: "",
+      raw: "",
+      style: "empty",
+      valueStart: -1,
+      valueEnd: -1,
+      start: this.off(line, indent),
+      end: this.lineEnd(endLine),
+      blockIndent: -1,
+      flowOpen: -1,
+      inFlow: false,
+      line,
+      endLine,
+      indent,
+      // A synthetic container (a document root, or the mapping/list a `-` opens on
+      // its own line) has no value column of its own, so nothing behind it is its
+      // comment — the entry written on that line owns it. The prose above it is
+      // still its own.
+      comment: "",
+      lead: this.leadAt(line, indent),
+      commentStart: -1,
+      commentAnchor: -1,
+      editable: true,
+      deletable: true,
+      children,
+    };
+  }
+
+  private scalar(
+    k: ScannedKey | null,
+    path: (string | number)[],
+    docIndex: number,
+    line: number,
+    indent: number,
+    v: ScannedValue,
+    editable: boolean,
+    deletable: boolean,
+  ): YamlNode {
+    return this.annotate({
+      id: idFor(docIndex, path),
+      path,
+      kind: "scalar",
+      key: k?.key ?? null,
+      keyRaw: k?.keyRaw ?? null,
+      keyStart: k ? this.off(line, k.keyCol) : -1,
+      keyEnd: k ? this.off(line, k.keyEnd) : -1,
+      value: v.value,
+      raw: v.raw,
+      style: v.style,
+      valueStart: this.off(line, v.valueCol),
+      valueEnd: this.off(line, v.valueEnd),
+      start: this.off(line, k ? k.keyCol : indent),
+      end: this.off(line, v.valueEnd),
+      blockIndent: -1,
+      flowOpen: -1,
+      inFlow: false,
+      line,
+      endLine: line,
+      indent,
+      comment: "",
+      lead: "",
+      commentStart: -1,
+      commentAnchor: -1,
+      editable,
+      deletable,
+      children: [],
+    }, line, v.valueEnd);
+  }
+}
+
+/** A node's identity: its document plus its path, JSON-encoded so that a key
+ *  holding the separator character cannot collide with a deeper path. Stable
+ *  across re-parses, which is what lets the tree keep its collapse state and its
+ *  open editor across the re-parse every edit triggers. */
+function idFor(docIndex: number, path: (string | number)[]): string {
+  return `${docIndex}:${JSON.stringify(path)}`;
+}
+
+// ── Edits ───────────────────────────────────────────────────────────────────
+// Each takes the current text and returns the next text. They are total: an edit
+// the node does not support returns the text unchanged, so a stale node from a
+// previous parse can never corrupt the file.
+
+/** Rewrite a scalar's value in place, keeping its key, its style and its trailing
+ *  comment. Block scalars rewrite their body lines. */
+export function setValue(text: string, doc: YamlDoc, node: YamlNode, next: string): string {
+  if (!node.editable || node.kind !== "scalar") return text;
+
+  if (node.style === "block") {
+    const body = next === ""
+      ? []
+      : next.split("\n").map((l) => (l === "" ? "" : " ".repeat(node.blockIndent) + l));
+    if (node.endLine > node.line) return replaceLines(text, node.line + 1, node.endLine, body);
+    return insertLines(text, node.line + 1, body);
+  }
+
+  const literal = encodeScalar(next, node.style, doc.strict);
+  // An empty value has no token to replace: the splice point sits right after the
+  // `:`/`-`, so the leading space has to come with the literal.
+  const lead = node.style === "empty" ? " " : "";
+  return splice(text, node.valueStart, node.valueEnd, lead + literal);
+}
+
+/**
+ * The values of a list the tree can show — and edit — as ONE comma-separated
+ * line, or null when it must stay rows. Every item has to be a single-line
+ * scalar the tree could rewrite, carrying nothing a `a, b, c` reading would
+ * drop: no comment (the line has nowhere to keep it), no nested collection, no
+ * anchor, no shared dash line, no comma or newline inside a value (the display
+ * could not round-trip), no empty value (an invisible token between commas).
+ * A flow list spread over lines also stays rows — collapsing it onto one line
+ * would rewrite the author's layout, which the tree never does.
+ */
+export function inlineListValues(node: YamlNode): string[] | null {
+  if (node.kind !== "seq" || !node.editable || !node.children.length) return null;
+  if (isFlow(node) && node.endLine !== node.line) return null;
+  const out: string[] = [];
+  for (const c of node.children) {
+    // The shared-dash check is what keeps a nested `- - x` list in rows: its
+    // first item's line is the outer item's dash line, which the comma line's
+    // rewrite (setListItems replaces whole item lines) would overwrite.
+    if (c.kind !== "scalar" || !c.editable || !c.deletable || c.onDash) return null;
+    if (c.style === "block" || c.style === "empty") return null;
+    if (c.comment || c.lead) return null;
+    if (c.value === "" || /[\n,]/.test(c.value)) return null;
+    out.push(c.value);
+  }
+  return out;
+}
+
+/**
+ * Rewrite an inline-edited list ({@link inlineListValues}) to exactly `values`,
+ * in the list's own style: a flow list inside its brackets, a block list as
+ * `- item` lines at the items' own indent. A value an existing item already
+ * holds keeps that item's written form (its quotes), so reordering or appending
+ * never restyles a neighbour; a new value is written as typed — plain unless it
+ * NEEDS quoting (typing `8080` into a list of ports means the number), quoted
+ * in the strict (JSON) dialect. An empty `values` empties the list: a flow list
+ * to `[]`, a block list down to its bare key.
+ */
+export function setListItems(
+  text: string,
+  doc: YamlDoc,
+  node: YamlNode,
+  values: string[],
+): string {
+  if (inlineListValues(node) === null) return text;
+  const rawFor = new Map<string, string>();
+  for (const c of node.children) if (!rawFor.has(c.value)) rawFor.set(c.value, c.raw);
+  const enc = (v: string) => rawFor.get(v) ?? encodeScalar(v, "plain", doc.strict);
+
+  if (isFlow(node)) {
+    return splice(text, node.flowOpen, node.end, `[${values.map(enc).join(", ")}]`);
+  }
+  const first = node.children[0];
+  const pad = " ".repeat(first.indent);
+  return replaceLines(
+    text,
+    first.line,
+    node.endLine,
+    values.map((v) => `${pad}- ${enc(v)}`),
+  );
+}
+
+/** Rename a mapping key in place, in the dialect it is written in. */
+export function renameKey(text: string, doc: YamlDoc, node: YamlNode, nextKey: string): string {
+  if (node.keyRaw === null || node.keyStart < 0 || nextKey === "") return text;
+  // A key already written quoted stays quoted, whatever the dialect.
+  const quoted = node.keyRaw[0] === '"' || node.keyRaw[0] === "'";
+  return splice(text, node.keyStart, node.keyEnd, encodeKey(nextKey, doc.strict || quoted));
+}
+
+/** The lines a BLOCK node owns: its own, plus the comment run written above it.
+ *  Both edits that move lines around use it, because a node's comment is part of
+ *  the node — left behind, it would silently re-attach itself to whichever entry
+ *  slid into its place, and describe the wrong thing. */
+function blockSpan(node: YamlNode): [number, number] {
+  const lead = node.lead === "" ? 0 : node.lead.split("\n").length;
+  return [node.line - lead, node.endLine];
+}
+
+/**
+ * Remove a node, and the comments that are its own: the one behind it and the run
+ * written above it (see {@link blockSpan}). A node inside a FLOW collection gives
+ * up its span plus the one comma that separated it, so `[a, b, c]` minus `b` is
+ * `[a, c]` and not `[a, , c]`.
+ */
+export function deleteNode(text: string, node: YamlNode): string {
+  if (!node.deletable) return text;
+  if (node.onDash && !node.inFlow) {
+    // The entry shares its item's dash line, so the dash is not its to take:
+    // pull the next sibling up onto it when one follows on its own line
+    // (`- name: a\n  port: 1` minus `name` → `- port: 1`), otherwise leave a
+    // bare `-` — a comment-led sibling keeps its lead run where it is, above
+    // its own line, rather than have the pull-up drag a comment onto the dash.
+    const { lines, starts } = indexLines(text);
+    const next = lines[node.endLine + 1];
+    if (next !== undefined && next.trim() !== "" && !isComment(next) && indentOf(next) === node.indent) {
+      return splice(text, node.start, starts[node.endLine + 1] + node.indent, "");
+    }
+    return replaceLines(text, node.line, node.endLine, [
+      lines[node.line].slice(0, node.indent).trimEnd(),
+    ]);
+  }
+  if (!node.inFlow) {
+    const [from, to] = blockSpan(node);
+    return replaceLines(text, from, to, []);
+  }
+
+  let from = node.start;
+  let to = node.end;
+  // Prefer eating the comma BEFORE us (it keeps the opening bracket clean);
+  // failing that, the one after — we are the collection's first entry.
+  let back = from - 1;
+  while (back >= 0 && /\s/.test(text[back])) back--;
+  if (back >= 0 && text[back] === ",") {
+    from = back;
+  } else {
+    let fwd = to;
+    while (fwd < text.length && /\s/.test(text[fwd])) fwd++;
+    if (text[fwd] === ",") {
+      fwd++;
+      while (fwd < text.length && (text[fwd] === " " || text[fwd] === "\t")) fwd++;
+      to = fwd;
+    }
+  }
+  return splice(text, from, to, "");
+}
+
+/**
+ * Insert a copy of `node` right after it, as a new sibling — what "copy last
+ * item" does when growing a list. A BLOCK node's own lines (its nested block and
+ * the comment behind it, but NOT the prose above it — a copy is not the original)
+ * are duplicated verbatim, so the new entry keeps the source's exact shape and
+ * indentation. A FLOW node's span is duplicated after it with a separating comma.
+ */
+export function duplicateNode(text: string, node: YamlNode): string {
+  if (!node.deletable) return text;
+  if (!node.inFlow) {
+    const { lines } = indexLines(text);
+    const copy = lines.slice(node.line, node.endLine + 1);
+    // A dash-line entry's first line carries the item's `- `; the copy gets
+    // spaces there instead — the dash is the item's, not the entry's.
+    if (node.onDash) copy[0] = " ".repeat(node.indent) + copy[0].slice(node.indent);
+    return insertLines(text, node.endLine + 1, copy);
+  }
+  const body = text.slice(node.start, node.end);
+  return splice(text, node.end, node.end, `, ${body}`);
+}
+
+// ── Copy & paste ────────────────────────────────────────────────────────────
+
+/** An entry captured by the tree's copy button: the node's own source, ready to
+ *  be put back down after another node ({@link pasteAfter}) or handed to the
+ *  system clipboard. A BLOCK entry carries its lines dedented to column 0, so
+ *  `text` reads as a clean fragment and a paste only has to indent it to its new
+ *  siblings' column; a FLOW entry is its span, pasted back between commas. */
+export interface YamlClip {
+  /** The entry as YAML text — what goes on the system clipboard. */
+  text: string;
+  /** Block form: the node's own lines (its trailing comment included, the lead
+   *  run above it not — a copy is not the original; same rule as
+   *  {@link duplicateNode}), dedented to column 0. Empty for a flow entry. */
+  lines: string[];
+  /** Captured from inside a flow collection — pastes back into one. */
+  inFlow: boolean;
+  /** `key: …` (a mapping entry) vs a bare item — decides which containers can
+   *  take it (see {@link canPasteAfter}). */
+  isMapEntry: boolean;
+  kind: YamlKind;
+  /** What the copy is called in the banner and the paste button. */
+  label: string;
+}
+
+function leadingSpaces(line: string): number {
+  let n = 0;
+  while (n < line.length && line[n] === " ") n++;
+  return n;
+}
+
+/** Capture a node for copy/paste, or null when it cannot be removed on its own
+ *  (a copy exists to be pasted, and a paste of it must be deletable again). */
+export function copyNode(text: string, node: YamlNode, label?: string): YamlClip | null {
+  if (!node.deletable) return null;
+  const isMapEntry = node.key !== null;
+  const name = label ?? node.key ?? "item";
+  if (node.inFlow) {
+    const body = text.slice(node.start, node.end);
+    return { text: body, lines: [], inFlow: true, isMapEntry, kind: node.kind, label: name };
+  }
+  const { lines } = indexLines(text);
+  // Dedent by the node's own column — but never past a line's actual indent, so
+  // an oddly out-dented line loses only what it has (a blank line stays blank).
+  const own = lines
+    .slice(node.line, node.endLine + 1)
+    .map((l) => l.slice(Math.min(node.indent, leadingSpaces(l))));
+  // A dash-line entry's first line: the min-guard above would keep the item's
+  // `- ` (the dash sits before the entry's column), so it dedents past it here —
+  // the copy is the entry, not the item.
+  if (node.onDash) own[0] = lines[node.line].slice(node.indent);
+  return { text: own.join("\n"), lines: own, inFlow: false, isMapEntry, kind: node.kind, label: name };
+}
+
+/**
+ * Whether {@link pasteAfter} can put `clip` down as `anchor`'s next sibling. The
+ * entry must FIT the container it would land in — a `key: …` belongs in a
+ * mapping, a bare item in a list, and a block entry has no place inside a flow
+ * collection (nor a flow span on a block line of its own) — so the paste cursor
+ * simply never lands where the splice would tear the file.
+ */
+export function canPasteAfter(clip: YamlClip, anchor: YamlNode, parentKind: string): boolean {
+  if (anchor.inFlow !== clip.inFlow) return false;
+  if (parentKind === "map") return clip.isMapEntry;
+  if (parentKind === "seq") return !clip.isMapEntry;
+  return false;
+}
+
+/**
+ * Insert a copied entry as `anchor`'s next sibling — the spot the paste cursor
+ * marks. A BLOCK clip's lines land right after the anchor's block, re-indented
+ * to the anchor's own column ({@link duplicateNode}'s insertion point, with the
+ * re-indent a copy from another depth needs). A FLOW clip splices in after the
+ * anchor's span — on its own line at the anchor's column when the collection is
+ * spread over lines, inline with a `, ` when it isn't (mirroring how
+ * {@link addChild} grows a flow collection).
+ */
+export function pasteAfter(text: string, anchor: YamlNode, clip: YamlClip): string {
+  if (clip.inFlow) {
+    if (!anchor.inFlow) return text;
+    const { starts, eol } = indexLines(text);
+    const line = lineOfOffset(starts, anchor.start);
+    const ownLine = /^[ \t]*$/.test(text.slice(starts[line], anchor.start));
+    const col = anchor.start - starts[line];
+    return ownLine
+      ? splice(text, anchor.end, anchor.end, `,${eol}${" ".repeat(col)}${clip.text}`)
+      : splice(text, anchor.end, anchor.end, `, ${clip.text}`);
+  }
+  if (anchor.inFlow) return text;
+  const pad = " ".repeat(anchor.indent);
+  return insertLines(
+    text,
+    anchor.endLine + 1,
+    clip.lines.map((l) => (l === "" ? "" : pad + l)),
+  );
+}
+
+/** True when the node holds nothing yet, so its first child can replace the
+ *  placeholder: `key:` or `key: null`. (An empty `[]`/`{}` is NOT a placeholder —
+ *  it is a real, empty flow collection, and it grows children in flow style.) */
+export function isEmptyPlaceholder(node: YamlNode): boolean {
+  if (node.kind !== "scalar" || !node.editable) return false;
+  if (node.style === "empty") return true;
+  const raw = node.raw.trim();
+  return raw === "null" || raw === "~";
+}
+
+/** Whether the tree can add a `kind` child to this node. A map takes keys; a list
+ *  takes items and — as "+ key" — an item that IS a mapping (`- name: api`), which
+ *  is the shape a list of mappings actually grows by; an empty placeholder takes
+ *  either, and becomes that kind. */
+export function canAddChild(node: YamlNode, kind: "key" | "item"): boolean {
+  if (node.kind === "map") return kind === "key";
+  if (node.kind === "seq") return true;
+  return isEmptyPlaceholder(node);
+}
+
+/**
+ * Append a child to `parent`, in the parent's OWN style:
+ *  - a BLOCK collection gains a line (`  key: value` / `  - item`) at its
+ *    children's indent, matching the file's indent step;
+ *  - a FLOW collection gains an entry inside its brackets — inline when it is
+ *    written inline (`[a, b]` → `[a, b, c]`), on its own line at its siblings'
+ *    column when it is spread over lines. It is never rewritten into block style
+ *    behind the author's back.
+ * On a LIST, `kind: "key"` means an item that IS a mapping (`- name: api`) — a list
+ * of mappings is grown by adding keys to it, not by adding a container and then
+ * filling it.
+ * Adding the first child to an empty placeholder (`key:` / `key: null`) clears the
+ * placeholder, so the key holds the new block rather than a scalar AND a block.
+ */
+export function addChild(
+  text: string,
+  doc: YamlDoc,
+  parent: YamlNode,
+  kind: "key" | "item",
+  key: string,
+  literal: string,
+): string {
+  if (!canAddChild(parent, kind)) return text;
+
+  // "+ key" on a list writes an item, not a key: `- name: api`.
+  const asItem = parent.kind === "seq" && kind === "key";
+  const pair = `${encodeKey(key, doc.strict)}:${literal ? ` ${literal}` : ""}`;
+  const flowPair = `${encodeKey(key, doc.strict)}: ${literal || "null"}`;
+
+  // A placeholder INSIDE a flow collection — `{a: null}`, `[a, null]`, and so every
+  // null in a JSON file — has no lines to grow into: it holds a span, and a flow
+  // node has no column at all (`indent` is -1). Growing it as a block would splice a
+  // line at column -1 into the middle of the brackets and tear the collection open.
+  // It becomes a collection in place instead, in the only style available to it.
+  if (parent.inFlow && isEmptyPlaceholder(parent)) {
+    const coll = kind === "item" ? `[${literal}]` : `{${flowPair}}`;
+    // An empty value (`{a: , …}`) has no token to replace: the splice point sits
+    // right after the `:`, so the space comes with the collection — and the spaces
+    // already sitting there go with the splice, or they would be left stranded
+    // between the value and the comma.
+    if (parent.style !== "empty") {
+      return splice(text, parent.valueStart, parent.valueEnd, coll);
+    }
+    let to = parent.valueEnd;
+    while (to < text.length && (text[to] === " " || text[to] === "\t")) to++;
+    return splice(text, parent.valueStart, to, ` ${coll}`);
+  }
+
+  if (isFlow(parent)) {
+    const body = kind === "item" ? literal : asItem ? `{${flowPair}}` : flowPair;
+    return addFlowChild(text, parent, body);
+  }
+
+  const body = kind === "item"
+    ? `- ${literal}`.trimEnd()
+    : asItem
+      ? `- ${pair}`
+      : pair;
+
+  if (parent.children.length) {
+    const childIndent = parent.children[0].indent;
+    const last = parent.children[parent.children.length - 1];
+    return insertLines(text, last.endLine + 1, [" ".repeat(childIndent) + body]);
+  }
+
+  // First child. A placeholder value on the parent's line has to go first, or the
+  // key would hold both a scalar and a block.
+  let out = text;
+  if (parent.kind === "scalar" && parent.style !== "empty") {
+    out = splice(out, parent.valueStart, parent.valueEnd, "");
+    out = trimLineEnd(out, parent.line);
+  }
+  const childIndent = parent.indent + (doc.indentStep || 2);
+  return insertLines(out, parent.line + 1, [" ".repeat(childIndent) + body]);
+}
+
+/** Splice a new entry into a flow collection, matching how it is laid out. */
+function addFlowChild(text: string, parent: YamlNode, body: string): string {
+  if (!parent.children.length) {
+    // An empty `{}` / `[]`: the entry goes straight after the bracket.
+    return splice(text, parent.flowOpen + 1, parent.flowOpen + 1, body);
+  }
+
+  const last = parent.children[parent.children.length - 1];
+  const spread = text.slice(parent.flowOpen, parent.end).includes("\n");
+  if (!spread) return splice(text, last.end, last.end, `, ${body}`);
+
+  // Written over several lines: put the entry on its own line, at the column its
+  // siblings are written at, and leave the closing bracket where the author put it.
+  const { starts, eol } = indexLines(text);
+  const lastLine = lineOfOffset(starts, last.start);
+  const col = last.start - starts[lastLine];
+  return splice(text, last.end, last.end, `,${eol}${" ".repeat(col)}${body}`);
+}
+
+/**
+ * Append a top-level entry. This is the one add with no parent node to hang off —
+ * an empty (or comment-only) file, where the tree has nothing to show yet but must
+ * still be able to seed the document. A JSON file is seeded with the collection
+ * itself, since JSON has no block form to grow into.
+ */
+export function addRootEntry(
+  text: string,
+  kind: "key" | "item",
+  key: string,
+  literal: string,
+  strict = false,
+): string {
+  const body = strict
+    ? kind === "item"
+      ? `[${literal}]`
+      : `{${encodeKey(key, true)}: ${literal || "null"}}`
+    : kind === "item"
+      ? `- ${literal}`.trimEnd()
+      : `${encodeKey(key)}:${literal ? ` ${literal}` : ""}`;
+  const { lines } = indexLines(text);
+  return insertLines(text, lines.length, [body]);
+}
+
+/** Drop trailing whitespace from one line (used after clearing a placeholder). */
+function trimLineEnd(text: string, line: number): string {
+  const idx = indexLines(text);
+  if (line < 0 || line >= idx.lines.length) return text;
+  const l = idx.lines[line];
+  const trimmed = l.replace(/[ \t]+$/, "");
+  if (trimmed === l) return text;
+  return splice(text, idx.starts[line], idx.starts[line] + l.length, trimmed);
+}
+
+/**
+ * Move a node to the position its sibling at `to` holds — what a drag onto that row
+ * means, and what the ↑/↓ buttons ask for one step at a time. A BLOCK node moves
+ * whole lines: its nested block, its trailing comment and the prose above it all
+ * travel with it ({@link blockSpan}), and the siblings it passes keep theirs. A FLOW
+ * node moves its span, taking its separating comma along, so `[a, b, c]` stays a
+ * well-formed flow list however its entries are shuffled.
+ *
+ * It is a MOVE, not a chain of swaps: a swap-per-step would have to re-parse the
+ * text between steps (every splice invalidates every offset after it), and a drag
+ * across five rows is one edit, not five.
+ */
+export function moveNodeTo(
+  text: string,
+  siblings: YamlNode[],
+  node: YamlNode,
+  to: number,
+): string {
+  const from = siblings.findIndex((s) => s.id === node.id);
+  if (from < 0 || to < 0 || to >= siblings.length || to === from) return text;
+  const target = siblings[to];
+  if (!node.deletable || !target.deletable) return text;
+
+  if (node.inFlow && target.inFlow) {
+    const body = text.slice(node.start, node.end);
+    const cut = deleteNode(text, node); // takes the one comma that separated it
+    // Everything after the removed region shifted left by exactly what was removed;
+    // everything before it (which is where a target above us sits) did not move.
+    const shift = text.length - cut.length;
+    const anchor = to < from ? target.start : target.end;
+    const at = anchor > node.start ? anchor - shift : anchor;
+    return splice(cut, at, at, to < from ? `${body}, ` : `, ${body}`);
+  }
+
+  const { lines } = indexLines(text);
+  // A dash-line entry's span is its own lines only — never blockSpan's, whose
+  // lead is the prose above the item's dash line and not the entry's to move.
+  const spanOf = (n: YamlNode): [number, number] =>
+    n.onDash ? [n.line, n.endLine] : blockSpan(n);
+  const [nodeFrom, nodeTo] = spanOf(node);
+  const [targetFrom, targetTo] = spanOf(target);
+  // Rewrite only the run of lines the two of them span, so nothing outside it —
+  // another sibling's comment, a blank line, the trailing newline — is touched.
+  const lo = Math.min(nodeFrom, targetFrom);
+  const hi = Math.max(nodeTo, targetTo);
+  const span = lines.slice(lo, hi + 1);
+  // When first place changes hands, so does the item's dash: the current first
+  // entry gives its `- ` prefix up (its line is dedashed inside the span)…
+  const dash = siblings[0].onDash && (from === 0 || to === 0) ? siblings[0] : null;
+  const prefix = dash ? lines[dash.line].slice(0, dash.indent) : "";
+  if (dash) {
+    span[dash.line - lo] = " ".repeat(dash.indent) + span[dash.line - lo].slice(dash.indent);
+  }
+  const block = span.splice(nodeFrom - lo, nodeTo - nodeFrom + 1);
+  const at = to < from ? targetFrom - lo : targetTo + 1 - lo - block.length;
+  span.splice(at, 0, ...block);
+  // …and the new first entry takes it, on its ENTRY line — its lead comments
+  // stay above the dash line, which is exactly where an item's prose lives
+  // (`leadComment`). The entry line is the span's first line of real content.
+  if (dash) {
+    const entry = span.findIndex((l) => l.trim() !== "" && !isComment(l));
+    if (entry >= 0) span[entry] = prefix + span[entry].slice(prefix.length);
+  }
+  return replaceLines(text, lo, hi, span);
+}
+
+/** Move a node one place up (-1) or down (+1). */
+export function moveNode(
+  text: string,
+  siblings: YamlNode[],
+  node: YamlNode,
+  delta: -1 | 1,
+): string {
+  const at = siblings.findIndex((s) => s.id === node.id);
+  if (at < 0) return text;
+  return moveNodeTo(text, siblings, node, at + delta);
+}
+
+// ── Comments ────────────────────────────────────────────────────────────────
+// A `#` comment is the only place a YAML file documents a key, so the tree treats
+// it as the key's description rather than as scenery: it is read on both of the
+// two places it can be written (above the key, or behind the value), shown on the
+// key, and it travels with the key when the key moves or goes.
+
+/** The node's comment, whichever way round the author wrote it. */
+export function commentOf(node: YamlNode): string {
+  return node.comment || node.lead;
+}
+
+/** Whether the tree may write a comment here. JSON has none to write (it is not a
+ *  YAML dialect thing — the format simply has no comments), and inside a flow
+ *  collection a `#` would swallow the closing bracket and everything up to it. */
+export function canComment(doc: YamlDoc, node: YamlNode): boolean {
+  // A dash-line item carries its comment above (`leadComment`), so it needs no
+  // trailing anchor of its own; every other node needs a place to put one.
+  return !doc.strict && (node.commentAnchor >= 0 || !!node.leadComment);
+}
+
+/**
+ * Write (or, with an empty `next`, clear) a node's comment, KEEPING THE AUTHOR'S
+ * PLACEMENT: one written above the key is rewritten above it, one written behind
+ * the value stays behind it. A node with no comment yet gets one behind — the
+ * placement that adds no line and so cannot disturb anything around it.
+ */
+export function setComment(text: string, doc: YamlDoc, node: YamlNode, next: string): string {
+  if (!canComment(doc, node)) return text;
+  const body = next.trim();
+  const leadLines = node.lead === "" ? 0 : node.lead.split("\n").length;
+
+  // A comment written ABOVE the node's line: when it already has a lead run (any
+  // node), or when it's a dash-line item whose comment lives above by rule. An
+  // existing run is replaced (empty body clears it); a brand-new one is inserted.
+  if ((leadLines > 0 && node.commentStart < 0) || (node.leadComment && node.commentStart < 0)) {
+    const pad = " ".repeat(Math.max(0, node.indent));
+    const written = body === "" ? [] : body.split("\n").map((l) => `${pad}# ${l}`.trimEnd());
+    if (leadLines > 0) {
+      return replaceLines(text, node.line - leadLines, node.line - 1, written);
+    }
+    return insertLines(text, node.line, written);
+  }
+
+  const idx = indexLines(text);
+  const line = lineOfOffset(idx.starts, node.commentAnchor);
+  const eol = idx.starts[line] + idx.lines[line].length;
+  const had = node.commentStart >= 0;
+
+  if (body === "") {
+    // Take the run of spaces before the `#` with it, or clearing the comment would
+    // leave the line with trailing whitespace no one asked for.
+    let from = had ? node.commentStart : node.commentAnchor;
+    while (from > node.commentAnchor && /[ \t]/.test(text[from - 1])) from--;
+    return splice(text, from, eol, "");
+  }
+
+  // Rewriting an existing comment starts at its own `#`, so the gap the author left
+  // in front of it — which may be aligning it with the comments above and below —
+  // survives. Only a brand-new one has to choose a gap.
+  const from = had ? node.commentStart : node.commentAnchor;
+  // A comment behind the value is one line by definition.
+  return splice(text, from, eol, `${had ? "" : "  "}# ${body.replace(/\s*\n+\s*/g, " ")}`);
+}
+
+/** A scalar's type, for the tree's value styling. Display only. */
+export function scalarType(node: YamlNode): "string" | "number" | "boolean" | "null" {
+  if (node.style === "double" || node.style === "single" || node.style === "block") return "string";
+  const v = node.raw.trim();
+  if (node.style === "empty" || v === "null" || v === "~") return "null";
+  if (/^-?(\d+|\d*\.\d+)([eE][+-]?\d+)?$/.test(v) || /^0[xob][0-9a-fA-F_]+$/.test(v)) return "number";
+  if (/^(true|false|yes|no|on|off)$/i.test(v)) return "boolean";
+  return "string";
+}
+
+/** Flatten a document's nodes, parents before children (used by tests). */
+export function walkYaml(node: YamlNode, visit: (n: YamlNode) => void): void {
+  visit(node);
+  for (const c of node.children) walkYaml(c, visit);
+}
diff --git a/src/lib/viewers/yamlGrid.ts b/src/lib/viewers/yamlGrid.ts
new file mode 100644
index 0000000..a3dce28
--- /dev/null
+++ b/src/lib/viewers/yamlGrid.ts
@@ -0,0 +1,234 @@
+/**
+ * The YAML/JSON **card grid** model (#yaml-grid) — a third view on the same text the
+ * tree and Source share, and the pure helpers behind it.
+ *
+ * The VIEW is recursive and tree-like: the document is one centred top card (or, for
+ * a root list, a row of them); every nested mapping/sequence is a card, and its own
+ * nested collections become **subcards laid out in columns below it** — click a
+ * card's header to collapse/expand. Scalars are the editable fields inside a card.
+ * So a deep config reads as a wall of nested cards you drill into, not a ladder you
+ * scroll (the RENDER lives in `components/embed/YamlGrid`).
+ *
+ * Like the tree, the cards are a VIEW ON THE TEXT, not a model of it: every EDIT is
+ * delegated back to `lib/viewers/yaml`'s splice ops (`setValue` for a field,
+ * `addChild` for a new field/card, `deleteNode` for a record), so a card edit keeps
+ * comments, quoting and untouched bytes exactly as the tree's does, and lands in the
+ * same draft as an ordinary dirty/undoable/saveable change. Two views, one text.
+ *
+ * What a field can be (mirrors the tree's honesty rule — never offer an edit it
+ * can't make):
+ *  - a **scalar** the tree could rewrite → an editable field (`setValue`),
+ *  - a **scalar the tree won't touch** (anchor/alias/multiline) → shown, read-only,
+ *  - a **nested collection** → a **subcard** (recursively), or — inside a flat cell,
+ *    e.g. the tabular helpers below — a read-only `{…}` / `[…]` chip.
+ *
+ * This file also keeps the **tabular** helpers (`gridModelFor` / `gridCandidates` /
+ * `hasGrid`): the flat rows × columns model of a single list/map-of-records. The
+ * card view doesn't render it, but it stays a tested, reusable way to ask "is this
+ * region a table?" — and it is what {@link cellKind} / {@link nestedLabel} classify
+ * cells for.
+ *
+ * Pure: no React, no Tauri, no fs. Unit-tested in `src/__tests__/YamlGrid.test.ts`.
+ */
+
+import { parseYaml, isFlow, type YamlDoc, type YamlNode } from "./yaml";
+
+/** True when `node` is a mapping or sequence — i.e. it renders as a card, not a
+ *  scalar field. */
+export function isContainer(node: YamlNode): boolean {
+  return node.kind === "map" || node.kind === "seq";
+}
+
+/** Whether the card view has anything worth showing over the plain tree: at least
+ *  one collection nested inside another (a map/seq as a child of the root or deeper).
+ *  A wholly flat file (a map of scalars, or a list of scalars) has no subcards, so
+ *  the Grid toggle stays hidden and the tree/Source carry it. */
+export function hasCards(text: string, strict = false): boolean {
+  const doc = parseYaml(text, { strict });
+  if (doc.error) return false;
+  const hasNestedContainer = (node: YamlNode): boolean => {
+    for (const c of node.children) {
+      if (isContainer(c)) return true;
+      if (hasNestedContainer(c)) return true;
+    }
+    return false;
+  };
+  return doc.docs.some(hasNestedContainer);
+}
+
+/** One record's cell for a column: the scalar/container node that holds it, or
+ *  `null` when this row's mapping has no such key (an editable empty cell). */
+export type GridCell = YamlNode | null;
+
+export interface GridRow {
+  /** Stable across re-parses (the row mapping's node id), so an open cell editor
+   *  and the selection survive the re-parse an edit triggers. */
+  id: string;
+  /** What heads the row: the list index (`0`, `1`, …) for a list-of-maps, or the
+   *  outer key for a map-of-maps. Display only. */
+  header: string;
+  /** The record itself — the container child. Usually the mapping ({@link map}),
+   *  but a non-mapping member (a bare list scalar) keeps its node here so a card can
+   *  still render its one value. */
+  node: YamlNode;
+  /** The mapping node this row's cells live in — the target a missing-cell add or
+   *  a whole-row delete addresses. A non-mapping member (a bare list scalar) has
+   *  none, so its row is all-empty and cannot grow cells. */
+  map: YamlNode | null;
+  /** Whether the whole row can be removed on its own (`deleteNode` on `map`). */
+  deletable: boolean;
+  /** Cells aligned 1:1 to {@link YamlGridModel.columns}. */
+  cells: GridCell[];
+}
+
+export interface YamlGridModel {
+  /** The collection that was gridded (a `seq` or a `map`). */
+  container: YamlNode;
+  /** `seq` = list of mappings (rows headed by index); `map` = map of mappings
+   *  (rows headed by key). Decides how a new row is added and what heads a row. */
+  shape: "seq" | "map";
+  /** The union of keys across the rows, in first-seen order — the columns. */
+  columns: string[];
+  rows: GridRow[];
+  /** Whether the grid can add a new row (`addChild` to the container). A flow
+   *  container can, a synthetic root cannot carry one, etc.— all editable here. */
+  canAddRow: boolean;
+  /** A short, stable label for the region (`items` / a key path), so a file with
+   *  more than one tabular region can offer a pick between them. */
+  label: string;
+}
+
+/** How much of a container's children must be mappings for it to read as a table
+ *  rather than a plain config collection. Two records is the floor (one is not a
+ *  pattern); a strong majority keeps a mostly-scalar map (with one nested block)
+ *  from masquerading as a grid. */
+const MIN_ROWS = 2;
+const MIN_MAP_FRACTION = 0.6;
+
+/** The mapping children of a container, in order — the rows-to-be. */
+function mapChildren(node: YamlNode): YamlNode[] {
+  return node.children.filter((c) => c.kind === "map");
+}
+
+/** Whether `node` is a collection worth showing as a grid: a seq or map whose
+ *  members are (mostly) mappings, with at least {@link MIN_ROWS} of them. */
+function isGridContainer(node: YamlNode): boolean {
+  if (node.kind !== "seq" && node.kind !== "map") return false;
+  if (node.children.length < MIN_ROWS) return false;
+  const maps = mapChildren(node);
+  if (maps.length < MIN_ROWS) return false;
+  return maps.length / node.children.length >= MIN_MAP_FRACTION;
+}
+
+/** A stable, human label for a container by its path (`items`, `services`,
+ *  `spec.containers`), or `document` for a bare root collection. */
+function labelFor(node: YamlNode): string {
+  if (!node.path.length) return "document";
+  return node.path.map((p) => String(p)).join(".");
+}
+
+/** Build the grid model for one container. Columns are the union of the row
+ *  mappings' keys in first-seen order; each row's cells are aligned to them, with
+ *  `null` where a row lacks that key. */
+export function gridModelFor(container: YamlNode): YamlGridModel {
+  const columns: string[] = [];
+  const seen = new Set<string>();
+  for (const child of container.children) {
+    if (child.kind !== "map") continue;
+    for (const entry of child.children) {
+      if (entry.key !== null && !seen.has(entry.key)) {
+        seen.add(entry.key);
+        columns.push(entry.key);
+      }
+    }
+  }
+
+  const rows: GridRow[] = container.children.map((child, i) => {
+    const isMap = child.kind === "map";
+    const byKey = new Map<string, YamlNode>();
+    if (isMap) for (const e of child.children) if (e.key !== null) byKey.set(e.key, e);
+    return {
+      id: child.id,
+      header: container.kind === "map" ? child.key ?? String(i) : String(i),
+      node: child,
+      map: isMap ? child : null,
+      deletable: child.deletable,
+      cells: columns.map((col) => byKey.get(col) ?? null),
+    };
+  });
+
+  return {
+    container,
+    shape: container.kind === "map" ? "map" : "seq",
+    columns,
+    rows,
+    canAddRow: container.deletable !== false,
+    label: labelFor(container),
+  };
+}
+
+/** Every tabular region in the document, largest first — a file may hold more than
+ *  one (a list of jobs *and* a map of hosts). "Largest" = most cells, so the one a
+ *  reader most wants a grid for is offered first; ties break toward the shallower,
+ *  earlier region so the choice is stable across re-parses. */
+export function gridCandidates(doc: YamlDoc): YamlNode[] {
+  if (doc.error) return [];
+  const found: YamlNode[] = [];
+  const walk = (node: YamlNode) => {
+    if (isGridContainer(node)) found.push(node);
+    for (const c of node.children) walk(c);
+  };
+  for (const root of doc.docs) walk(root);
+  const area = (n: YamlNode) => {
+    const model = gridModelFor(n);
+    return model.rows.length * Math.max(1, model.columns.length);
+  };
+  return found.sort((a, b) => {
+    const d = area(b) - area(a);
+    if (d !== 0) return d;
+    const depth = a.path.length - b.path.length;
+    if (depth !== 0) return depth;
+    return a.start - b.start;
+  });
+}
+
+/** The parsed document plus its tabular regions — one parse feeds both the toggle
+ *  (is a grid available?) and the grid itself. */
+export interface YamlGridDoc {
+  doc: YamlDoc;
+  candidates: YamlNode[];
+}
+
+export function parseGridDoc(text: string, opts: { strict?: boolean } = {}): YamlGridDoc {
+  const doc = parseYaml(text, opts);
+  return { doc, candidates: gridCandidates(doc) };
+}
+
+/** Whether this text has any region worth a grid — what the Grid toggle keys on,
+ *  so it appears exactly for the files where it does something. */
+export function hasGrid(text: string, strict = false): boolean {
+  return parseGridDoc(text, { strict }).candidates.length > 0;
+}
+
+/** A cell's editability, so the grid never offers a control it can't honour
+ *  (mirrors the tree's `source only` rule):
+ *   - `"scalar"`  — a scalar the tree can rewrite in place,
+ *   - `"empty"`   — no node yet; typing adds the key to the row (a new scalar),
+ *   - `"nested"`  — a sub-collection, read-only in a flat grid,
+ *   - `"locked"`  — a scalar the tree won't touch (anchor/alias/multiline). */
+export type CellKind = "scalar" | "empty" | "nested" | "locked";
+
+export function cellKind(cell: GridCell, rowMap: YamlNode | null): CellKind {
+  if (cell === null) return rowMap ? "empty" : "locked";
+  if (cell.kind !== "scalar") return "nested";
+  return cell.editable ? "scalar" : "locked";
+}
+
+/** The read-only chip shown for a nested cell — `{ N }` for a map, `[ N ]` for a
+ *  list — so a sub-collection reads as one at a glance without expanding it. */
+export function nestedLabel(cell: YamlNode): string {
+  const n = cell.children.length;
+  const flow = isFlow(cell);
+  if (cell.kind === "seq") return flow ? `[ ${n} ]` : `${n} item${n === 1 ? "" : "s"}`;
+  return flow ? `{ ${n} }` : `${n} key${n === 1 ? "" : "s"}`;
+}
diff --git a/src/lib/vpnAutoConnect.ts b/src/lib/vpnAutoConnect.ts
new file mode 100644
index 0000000..eabd801
--- /dev/null
+++ b/src/lib/vpnAutoConnect.ts
@@ -0,0 +1,273 @@
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "../stores/projects";
+import { useSettingsStore } from "../stores/settings";
+import {
+  markVpnConnected,
+  markVpnConnecting,
+  markVpnError,
+  useVpnStatusStore,
+} from "../stores/vpnStatus";
+import { canConnectVpnSilently, connectVpnSilently } from "./vpnConnect";
+import { keyringState } from "./keyring";
+import { openConnectionInRoot } from "./remoteConnect";
+
+/**
+ * "Connect this tunnel on launch" — the machine-level twin of a project's
+ * `remote.auto_connect`, armed per config in the header's VPN menu.
+ *
+ * It is armed on the *tunnel*, not on a project, because that is what a tunnel is:
+ * it reroutes the whole computer for as long as it is up, and a VPN you always want
+ * up is a property of where you work, not of which project happens to be open. So it
+ * can be armed for a config no project uses at all.
+ *
+ * Two promises, both inherited from the project-side rule (see `autoConnectRemote`):
+ *
+ *  1. **It never prompts.** The opt-in is only offered when it can be kept — the
+ *     credentials are saved — and it is *re-checked* here at launch rather than
+ *     trusted, so an opt-in that went stale (the password was forgotten meanwhile)
+ *     degrades to leaving the tunnel down, never to ambushing the user with a modal
+ *     during startup.
+ *  2. **It never elevates twice.** `pkexec` raises its polkit dialog before OpenVPN
+ *     validates anything, so a doomed attempt is not free (see `lib/vpnConnect`).
+ *
+ * Non-headless mode is the deliberate exception to (1): with `connections_headless`
+ * off, Eldrun handles no passwords at all, so "connect on launch" can only mean
+ * "open the connect command in the root terminal" — one tab, waiting for the user,
+ * which is exactly what activating a VPN-gated project does in that mode.
+ */
+
+/** Whether a tunnel is armed to come up on launch. */
+export function isVpnAutoConnect(config: string): boolean {
+  return useSettingsStore.getState().settings?.vpn_auto_connect === config;
+}
+
+/**
+ * Arm `config` to connect on launch, or disarm it. Arming is exclusive: a tunnel owns
+ * the machine's routing, so two armed configs would just be two tunnels fighting over
+ * it — arming one disarms the other by construction (a single stored path, not a set).
+ */
+export async function setVpnAutoConnect(config: string, enabled: boolean): Promise<void> {
+  const current = useSettingsStore.getState().settings?.vpn_auto_connect ?? null;
+  if (enabled) {
+    if (current === config) return;
+  } else if (current !== config) {
+    return;
+  }
+  await useSettingsStore.getState().updateSettings({ vpn_auto_connect: enabled ? config : null });
+}
+
+/**
+ * Whether the user asked Eldrun to remember this config's credentials.
+ *
+ * Deliberately read from *settings*, not from the keychain. The keychain is the only
+ * place the secret lives, but it cannot always be asked: a locked Secret Service
+ * collection answers every read like an empty one, so `vpn_has_saved_password` says
+ * "no" over a perfectly good saved password — which is what made the save toggle
+ * appear to do nothing after a restart. This flag survives that, and is reconciled
+ * back to the truth by [`syncVpnCredentialSaved`] whenever the keychain *is* readable.
+ */
+export function isVpnCredentialSaved(config: string): boolean {
+  return (useSettingsStore.getState().settings?.vpn_saved_configs ?? []).includes(config);
+}
+
+/** Record (or drop) the "remember this config's credentials" intent. */
+export async function setVpnCredentialSaved(config: string, saved: boolean): Promise<void> {
+  const current = useSettingsStore.getState().settings?.vpn_saved_configs ?? [];
+  const next = saved
+    ? current.includes(config)
+      ? current
+      : [...current, config]
+    : current.filter((c) => c !== config);
+  if (next.length === current.length && next.every((c, i) => c === current[i])) return;
+  await useSettingsStore.getState().updateSettings({ vpn_saved_configs: next });
+}
+
+/**
+ * Reconcile the recorded intent against what the keychain actually holds. Call only
+ * with a reading taken while the keychain was **readable** — feeding it the `false`
+ * a locked keyring returns would erase exactly the record that exists to survive
+ * that lock.
+ */
+export async function syncVpnCredentialSaved(config: string, actuallySaved: boolean): Promise<void> {
+  if (actuallySaved === isVpnCredentialSaved(config)) return;
+  await setVpnCredentialSaved(config, actuallySaved);
+}
+
+/**
+ * The auth username for an `auth-user-pass` config, as far as the frontend knows one:
+ * a project that uses this config carries it on its spec. It is not a secret, and the
+ * backend also keeps a copy beside the saved password (which is the only way a
+ * project-less tunnel can know it) — so `undefined` here is not "no username", it is
+ * "none on this side"; the backend fills it in.
+ */
+export function vpnUsernameFor(config: string): string | undefined {
+  return useProjectsStore
+    .getState()
+    .projects.find((p) => p.remote?.openvpn?.config === config)?.remote?.openvpn?.username;
+}
+
+/** Guards the launch connect against a second run (a re-mount, a second window). */
+let launched = false;
+
+/**
+ * Bring the armed tunnel up, once, at startup. Call after settings and projects have
+ * loaded (the username seed lives on a project's spec). Best-effort and silent: every
+ * exit that isn't a live tunnel leaves the lamp dark and the machine's routing alone.
+ */
+export async function autoConnectVpnOnLaunch(): Promise<void> {
+  if (launched) return;
+  const settings = useSettingsStore.getState().settings;
+  const config = settings?.vpn_auto_connect;
+  if (!config) return;
+  launched = true;
+
+  const status = useVpnStatusStore.getState();
+  // A tunnel can outlive the app (it is a root daemon, not our child), so the one we
+  // are about to start may already be up from a previous run. Reconcile first.
+  await status.refresh();
+  if (useVpnStatusStore.getState().byConfig[config]) return;
+
+  const username = vpnUsernameFor(config);
+
+  // Non-headless: Eldrun handles no password, so "auto-connect" means the connect
+  // command is waiting in the root terminal for the user to authenticate. Building it
+  // also arms the tunnel backend-side (`--writepid`), so it stays visible and killable.
+  if (settings?.connections_headless === false) {
+    try {
+      await openVpnLoginInTerminal(config);
+    } catch (error) {
+      useVpnStatusStore.getState().setState(config, "off");
+      console.warn("VPN auto-connect (root terminal) skipped", error);
+    }
+    return;
+  }
+
+  // Headless: re-check the promise rather than trusting the toggle. A saved password
+  // that has since been forgotten must leave the tunnel down — never open a modal the
+  // user did not ask for while the app is still starting up.
+  if (!(await canConnectVpnSilently(config, username))) {
+    // Distinguish the two ways that check fails, because only one of them is the
+    // user's fault. A **locked** keyring reads exactly like "nothing saved", so the
+    // tunnel that was armed to come up silently just... doesn't, with no explanation
+    // anywhere — the single most confusing outcome this feature has. Unlocking would
+    // mean prompting during startup, which auto-connect promises not to do, so say so
+    // instead and leave the remedy one click away in the header.
+    if (isVpnCredentialSaved(config) && (await keyringState()) === "locked") {
+      useProjectsStore.setState({
+        connToast: `VPN not started · ${fileOf(config)} — your OS keyring is locked, so its saved credentials can't be read. Unlock it from the VPN menu.`,
+      });
+    }
+    console.warn("VPN auto-connect skipped: credentials no longer allow a silent connect");
+    return;
+  }
+  useVpnStatusStore.getState().setState(config, "connecting");
+  try {
+    await connectVpnSilently(config, username);
+    useVpnStatusStore.getState().setState(config, "connected");
+    useProjectsStore.setState({
+      connToast: `VPN up · ${fileOf(config)} — this computer's traffic now routes through the tunnel`,
+    });
+  } catch (error) {
+    useVpnStatusStore.getState().setState(config, "off");
+    console.warn("VPN auto-connect failed", error);
+  }
+}
+
+/**
+ * **The** non-headless VPN login: hand `config` to an interactive root-terminal tab
+ * and let OpenVPN itself ask for whatever it needs — the account password, a key
+ * passphrase, a challenge/OTP — none of which Eldrun ever sees or has to model.
+ *
+ * It is the one implementation of that handoff, shared by every caller that reaches
+ * for it: the `connections_headless: false` paths (activation, auto-connect, the
+ * header menu) which *always* go this way, and the headless paths that fall back to
+ * it **per connect** when their own login failed (the modal's "Log in in terminal",
+ * see `stores/vpnPrompt`'s `useTerminal`). That fallback is deliberately a *local*
+ * switch — one tunnel, one click — and never writes the global setting: a mode is
+ * how the user wants Eldrun to behave, not something a failed handshake gets to
+ * decide for them.
+ *
+ * Building the command also **arms** the tunnel backend-side (the pidfile +
+ * `--writepid` + management socket `interactive_connect_command` appends), so a
+ * tunnel authenticated in the terminal is as visible and as killable as a headless
+ * one — which is also what makes the `pollVpnUp` below able to observe it at all.
+ *
+ * Throws if the command can't be built; the lamp is only moved once it can, so a
+ * failed handoff leaves no phantom "connecting" behind.
+ */
+export async function openVpnLoginInTerminal(
+  config: string,
+  opts?: { label?: string; projectId?: string | null },
+): Promise<void> {
+  const name = opts?.label ?? fileOf(config);
+  const command = await invoke<string>("openvpn_login_command", { config });
+  if (opts?.projectId) markVpnConnecting(opts.projectId, config);
+  else useVpnStatusStore.getState().setState(config, "connecting");
+  openConnectionInRoot({
+    label: `OpenVPN · ${name}`,
+    command,
+    dedupeKey: `vpn:${config}`,
+  });
+  pollVpnUp(config, { projectId: opts?.projectId, name });
+}
+
+/**
+ * Poll until the root-terminal tunnel is up (non-headless: the user authenticates in
+ * that terminal, so `openvpn_status` is the only completion signal). Bounded, so a
+ * tunnel that is never authenticated stops polling instead of spinning forever.
+ *
+ * With a `projectId` it also drives that project's pill lamp and takes its hold on
+ * the tunnel, so a project-scoped handoff ends on the same marks a headless connect
+ * would have left.
+ *
+ * It deliberately does **not** bail when the project is switched away from, and it
+ * always runs to a *terminal* mark — connected, or off/error after the bound. The
+ * tunnel is machine-wide; its coming up has nothing to do with which project is on
+ * screen, and an early bail would strand the shared lamp mid-handshake: a phantom the
+ * header's Disconnect won't touch (it is disabled while connecting) and every Connect
+ * dialog reads as a live tunnel. Updating an inactive project's lamp on the way is
+ * harmless; leaving the machine-wide one at "connecting" forever is not.
+ */
+export function pollVpnUp(
+  config: string,
+  opts?: { projectId?: string | null; name?: string },
+): void {
+  const projectId = opts?.projectId;
+  let attempts = 0;
+  const maxAttempts = 40; // ~60s at 1.5s cadence
+  const succeed = () => {
+    if (projectId) markVpnConnected(projectId, config);
+    else useVpnStatusStore.getState().setState(config, "connected");
+    useProjectsStore.setState({
+      connToast: `VPN up · ${opts?.name ?? fileOf(config)} — this computer's traffic now routes through the tunnel`,
+    });
+  };
+  const giveUp = () => {
+    if (projectId) markVpnError(projectId, config);
+    else useVpnStatusStore.getState().setState(config, "off");
+  };
+  const tick = () => {
+    void invoke<boolean>("openvpn_status", { config })
+      .then((up) => {
+        if (up) {
+          succeed();
+          return;
+        }
+        if (++attempts >= maxAttempts) {
+          giveUp();
+          return;
+        }
+        setTimeout(tick, 1500);
+      })
+      .catch(() => {
+        if (++attempts >= maxAttempts) giveUp();
+        else setTimeout(tick, 1500);
+      });
+  };
+  setTimeout(tick, 1500);
+}
+
+/** The config's file name — the whole path is a tooltip, not a label. */
+export function fileOf(config: string): string {
+  return config.split(/[\\/]/).pop() || config;
+}
diff --git a/src/lib/vpnConnect.ts b/src/lib/vpnConnect.ts
new file mode 100644
index 0000000..2d31043
--- /dev/null
+++ b/src/lib/vpnConnect.ts
@@ -0,0 +1,60 @@
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * The two questions every *silent* OpenVPN connect has to ask, in the order it has
+ * to ask them.
+ *
+ * Bringing a tunnel up is elevated (`pkexec openvpn`), and **polkit authenticates
+ * the user before OpenVPN has looked at the config at all**. So a connect attempt
+ * is not a cheap thing to get wrong: an attempt that was always going to be
+ * rejected — a missing `auth-user-pass` username, say — still costs the user a
+ * system password dialog, and the modal that then opens to collect what was missing
+ * costs them a *second* one. One tunnel, two system prompts, which is what the
+ * header's VPN menu used to do on every reconnect: the username lives on a
+ * project's spec, and a tunnel started from the header has no project.
+ *
+ * Hence [`canConnectVpnSilently`]: ask the backend whether the connect can be made
+ * with no prompt of any kind, and only then [`connectVpnSilently`]. If the answer is
+ * no, go straight to the password modal — one prompt, one elevation.
+ *
+ * These are deliberately free of store imports so `stores/projects` can use them
+ * without closing an import cycle; the callers own the lamps (see `stores/vpnStatus`).
+ */
+
+/**
+ * Whether `config` would come up with **no prompt** right now: every secret it needs
+ * is in the keychain, and an `auth-user-pass` config has a username to go with them —
+ * either the `username` passed here (a project's spec) or one saved beside the
+ * password. Never throws; an unreachable backend answers "no", which degrades to the
+ * modal rather than to a silent failure.
+ */
+export async function canConnectVpnSilently(
+  config: string,
+  username?: string | null,
+): Promise<boolean> {
+  return invoke<boolean>("vpn_can_connect_silently", {
+    config,
+    username: username || null,
+  }).catch(() => false);
+}
+
+/**
+ * Bring `config` up from the saved credentials. Throws if it fails, so the caller can
+ * fall back to the modal.
+ *
+ * `remember: null` is load-bearing: there is no checkbox behind this call, so the
+ * keychain must be left exactly as it was found. Passing `false` would delete the very
+ * credentials the connect just authenticated with.
+ */
+export async function connectVpnSilently(
+  config: string,
+  username?: string | null,
+): Promise<void> {
+  await invoke("openvpn_connect", {
+    config,
+    username: username || null,
+    password: null,
+    keyPassphrase: null,
+    remember: null,
+  });
+}
diff --git a/src/lib/windowState.ts b/src/lib/windowState.ts
new file mode 100644
index 0000000..6f8efe2
--- /dev/null
+++ b/src/lib/windowState.ts
@@ -0,0 +1,62 @@
+/**
+ * Pure logic behind the main window's geometry persistence: given the window's
+ * live outer rect and what we last saved, decide what (if anything) to write.
+ *
+ * Kept out of `AppShell` so the one genuinely subtle rule below — what to store
+ * while the window is MAXIMIZED — is unit-tested rather than reasoned about.
+ *
+ * All rects are PHYSICAL desktop px (`src/lib/coords.ts`): `outerPosition()` and
+ * `outerSize()` already report physical, and the backend's `set_position` /
+ * `set_size` consume physical, so nothing is ever converted.
+ *
+ * The consumer is `services::window_state::resolve_startup_geometry` on the Rust
+ * side, which decides at startup whether a saved rect is still placeable.
+ */
+import type { WindowState } from "../types";
+
+/** A window's outer rect, physical desktop px. */
+export interface OuterRect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+export const sameWindowState = (a: WindowState, b: WindowState): boolean =>
+  a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h && a.maximized === b.maximized;
+
+/**
+ * The `WindowState` to persist, or `null` to write nothing (either the rect is
+ * degenerate, or it is identical to what we already saved — a window drag fires a
+ * lot of events and most of them settle back on the same place).
+ *
+ * The maximized rule: while the window is maximized its outer rect IS the monitor,
+ * so it is not a *restore* geometry. Storing it would leave the window with no
+ * known "normal" size, which is precisely the state `WindowControls.tsx` has to
+ * work around — un-maximizing then appears to do nothing. So while maximized we
+ * keep the last floating rect and only flip the flag.
+ *
+ * The exception is the very first run, when there is no floating rect at all
+ * (Eldrun opens maximized, and the user may never un-maximize it). Storing nothing
+ * would mean never learning WHICH MONITOR the window is on — the whole point of
+ * the feature. So we record the maximized rect: it is a correct monitor hint, and
+ * it self-corrects into a true restore rect the first time the user un-maximizes.
+ */
+export function nextWindowState(
+  prev: WindowState | undefined,
+  outer: OuterRect,
+  maximized: boolean,
+): WindowState | null {
+  const keepPrevRect = maximized && prev !== undefined;
+  const rect: OuterRect = keepPrevRect
+    ? { x: prev.x, y: prev.y, w: prev.w, h: prev.h }
+    : outer;
+
+  // A 0-sized rect means the window was queried mid-map (or is minimized on some
+  // WMs). Persisting it would produce a window the user cannot see next launch.
+  if (rect.w <= 0 || rect.h <= 0) return null;
+
+  const next: WindowState = { ...rect, maximized };
+  if (prev && sameWindowState(prev, next)) return null;
+  return next;
+}
diff --git a/src/main.tsx b/src/main.tsx
index 7fa4f9c..afa0369 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -2,6 +2,8 @@ import React from "react";
 import ReactDOM from "react-dom/client";
 import { App } from "./App";
 import { installCrashReporter } from "./crashReporter";
+import "@fontsource-variable/inter";
+import "@fontsource-variable/jetbrains-mono";
 import "./styles/themes.css";
 
 installCrashReporter();
diff --git a/src/stores/activity.ts b/src/stores/activity.ts
index 033f364..437499b 100644
--- a/src/stores/activity.ts
+++ b/src/stores/activity.ts
@@ -1,26 +1,341 @@
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { create } from "zustand";
-import { useTabsStore } from "./tabs";
+import { looksLikeDecisionPromptStripped, stripAnsi } from "../lib/agentPrompt";
+import { METRIC, agentPromptLeaf } from "../lib/usageMetrics";
+import { allGroups, isPtyTabKind, useTabsStore } from "./tabs";
+import type { TabEntry } from "./tabs";
+import { bumpUsage } from "./usage";
 
-/// A scope (project) counts as "running" while any of its PTYs has emitted
-/// output within this window. Short enough to clear quickly when a task ends,
-/// long enough to bridge the gaps in bursty agent/terminal output.
+/// A scope (project) stays "running" until its PTYs have been quiet for this
+/// window. Short enough to clear quickly when a task ends, long enough to bridge
+/// the gaps in bursty agent/terminal output.
 const BUSY_WINDOW_MS = 800;
 
-// Last terminal-output timestamp per PTY id. Kept outside the store: it churns
-// on every output batch (~60/s) and nothing renders off it directly — only the
-// derived `busyByScope` map, recomputed on an interval, drives the UI.
+/// But it only BECOMES "running" once output has been sustained for this long —
+/// an onset debounce so a brief blip (a quick command, a keystroke echo) doesn't
+/// flash the working indicator. A burst must last past this before it counts.
+const WORK_ONSET_MS = 1500;
+
+/// How long an unwatched agent tab must have been quiet before we call what it's
+/// doing. The two are deliberately asymmetric: a decision prompt in its output is
+/// POSITIVE evidence that the agent is blocked, so it may glow almost at once;
+/// "done" is inferred from the ABSENCE of output, so it waits out a longer
+/// silence rather than calling every pause between writes a finished turn.
+const DECISION_QUIET_MS = 600;
+const DONE_QUIET_MS = 2500;
+
+/// How much of an agent's output tail is kept to classify it by — enough to hold
+/// the last screenful of a TUI redraw, small enough to be free.
+const TAIL_CAP = 8000;
+
+// Per-PTY activity, all keyed by the composed PTY id (`<scope>:<tabKey>`, the id
+// the backend emits under): when output last arrived; when the current burst of
+// output began (reset whenever output resumes after a quiet gap); the ANSI-
+// stripped tail of that burst; when the user last had eyes on the tab; when the
+// agent in it last rang the terminal bell; and when the user last sent input to
+// it. Kept outside the store: they churn on every output batch (~60/s) and
+// nothing renders off them directly — only the derived maps, recomputed on an
+// interval, drive the UI.
+/// When `recompute` last ran, so the usage recap can bill agent working time by
+/// the real gap between ticks rather than by an assumed interval.
+let lastTickAt: number | null = null;
+
+/// The largest gap between two `recompute` ticks that may be billed as agent
+/// working time. A longer gap means the interval was not running — the laptop
+/// slept, the tab was throttled — and whatever the agents were doing across it is
+/// not something we observed. Billing it would silently invent hours.
+const MAX_WORK_TICK_MS = 5_000;
+
 const lastOutputByPty: Record<string, number> = {};
+const onsetByPty: Record<string, number> = {};
+const tailByPty: Record<string, string> = {};
+const seenAtByPty: Record<string, number> = {};
+const bellByPty: Record<string, number> = {};
+const inputByPty: Record<string, number> = {};
+
+/// Memo for the decision-prompt test, keyed by PTY id and validated against the
+/// tail it was computed from. `attentionFor` asks the question of every agent tab
+/// on every 300ms tick, but the answer can only change when the tail does — and a
+/// tab quiet enough to hold a decision prompt is precisely one whose tail is NOT
+/// changing. Without this, a settled prompt re-ran four regexes over 8 KB, three
+/// of them case-insensitive, ~3.3 times a second forever. The guard is a string
+/// compare that hits JS's reference-equality fast path, since `tailByPty` holds
+/// the same string instance while the tab is quiet.
+const decisionMemo = new Map<string, { tail: string; hit: boolean }>();
+
+function tailLooksLikeDecision(ptyId: string): boolean {
+  // Already ANSI-stripped on the way in (see `notePtyOutput`), so this must NOT
+  // be routed through `stripAnsi` again.
+  const tail = tailByPty[ptyId] ?? "";
+  const memo = decisionMemo.get(ptyId);
+  if (memo !== undefined && memo.tail === tail) return memo.hit;
+  const hit = looksLikeDecisionPromptStripped(tail);
+  decisionMemo.set(ptyId, { tail, hit });
+  return hit;
+}
+
+const PTY_MAPS: Record<string, unknown>[] = [
+  lastOutputByPty,
+  onsetByPty,
+  tailByPty,
+  seenAtByPty,
+  bellByPty,
+  inputByPty,
+];
+
+/** Record that a PTY produced output just now, keeping the tail of the current
+ *  burst so `recompute` can tell a finished turn from a decision prompt. Cheap;
+ *  safe to call often. */
+export function notePtyOutput(ptyId: string, data = "") {
+  const now = Date.now();
+  const prev = lastOutputByPty[ptyId];
+  // Start of a fresh burst after quiet (or the very first output): reset the
+  // onset. Output within the busy window keeps the existing onset, so a
+  // continuous stream ages past WORK_ONSET_MS and flips to "working".
+  if (prev === undefined || now - prev >= BUSY_WINDOW_MS) {
+    onsetByPty[ptyId] = now;
+    // A new burst redraws the screen, so the last one's tail is stale. Dropping
+    // it is what stops an ALREADY-ANSWERED prompt from being matched again as a
+    // live one: an agent sits quiet while a prompt awaits the human, so whatever
+    // it does once answered necessarily arrives as a new burst.
+    tailByPty[ptyId] = "";
+  }
+  lastOutputByPty[ptyId] = now;
+  if (data) {
+    const tail = (tailByPty[ptyId] ?? "") + stripAnsi(data);
+    tailByPty[ptyId] = tail.length > TAIL_CAP ? tail.slice(-TAIL_CAP) : tail;
+  }
+}
+
+/** When a PTY last produced output (ms epoch), or undefined if none was seen
+ *  this session. Read-only view for the tab hover card's "quiet for…" line —
+ *  the raw map stays module-private because it churns per output batch. */
+export function lastPtyOutputAt(ptyId: string): number | undefined {
+  return lastOutputByPty[ptyId];
+}
 
-/** Record that a PTY produced output just now. Cheap; safe to call often. */
-export function notePtyOutput(ptyId: string) {
-  lastOutputByPty[ptyId] = Date.now();
+/** Record that input was sent to a PTY on the user's behalf — a keystroke, a
+ *  paste, or a user-triggered flow typing its command (`initialInput`). This is
+ *  what makes output COUNT: "working" and "done" only ever arise from output
+ *  produced after input this session, so a restored tab bursting its resume
+ *  banner or replaying a prior transcript — real bytes, but nothing anybody
+ *  asked for — never lights up a tab or its project pill. `decision` is exempt:
+ *  a resumed agent genuinely sitting at an unanswered prompt is real signal
+ *  worth surfacing immediately, commanded or not.
+ *
+ *  Sending input also drops the tail: answering a prompt is input, and a menu
+ *  that has been answered must not be matched again as a live one. This is the
+ *  ONLY thing that retires a decision prompt the user is looking at (looking is
+ *  no longer enough — see `attentionFor`), and it covers the case the per-burst
+ *  reset in `notePtyOutput` misses: an answer so fast that the agent's next
+ *  output lands inside the same burst, leaving the answered menu in the tail. */
+export function noteUserInput(ptyId: string) {
+  inputByPty[ptyId] = Date.now();
+  tailByPty[ptyId] = "";
+}
+
+/** Forget everything recorded about a PTY, called when it is (re)spawned. A
+ *  respawn — app launch, a project closed and reopened, a pane remounting — is
+ *  a new program: input sent to its predecessor mustn't license the successor's
+ *  restore/resume replay as a finished turn. */
+export function notePtySpawn(ptyId: string) {
+  for (const map of PTY_MAPS) delete map[ptyId];
+  decisionMemo.delete(ptyId);
+}
+
+/** Split a composed PTY id (`<scope>:<tabKey>`) into its parts, mirroring
+ *  `isDetachedPtyId` in stores/tabs. Returns null for a bare (colon-less) id. */
+export function splitPtyId(ptyId: string): { scope: string; key: string } | null {
+  const idx = ptyId.indexOf(":");
+  if (idx < 0) return null;
+  return { scope: ptyId.slice(0, idx), key: ptyId.slice(idx + 1) };
+}
+
+/** True when the tab is the one the user is currently looking at: it's the
+ *  active (visible) tab of its group in the CURRENT scope. Background tabs and
+ *  background projects are never "looked at". */
+function isTabLookedAt(scope: string, key: string): boolean {
+  const st = useTabsStore.getState();
+  if (st.scope !== scope) return false;
+  for (const g of allGroups(st.layoutByScope[scope] ?? null)) {
+    if (g.tabKeys.includes(key)) return g.activeKey === key;
+  }
+  return false;
+}
+
+/** True when the tab lives in a detached popout (#42). Such a tab has its own OS
+ *  window and its own tab strip, and this window has no idea whether the user is
+ *  looking at it — so it raises no attention here, which also stops a popped-out
+ *  agent from leaving its project pill glowing with a flag nothing can clear. */
+function isTabDetached(scope: string, key: string): boolean {
+  const groups = useTabsStore.getState().detachedGroupsByScope[scope] ?? [];
+  return groups.some((d) =>
+    allGroups(d.subtree).some((g) => g.tabKeys.includes(key)),
+  );
 }
 
 /** Test-only: forget all recorded PTY activity so cases start isolated. */
 export function _clearPtyActivityForTest() {
-  for (const k of Object.keys(lastOutputByPty)) delete lastOutputByPty[k];
+  for (const map of PTY_MAPS) {
+    for (const k of Object.keys(map)) delete map[k];
+  }
+  decisionMemo.clear();
+  useActivityStore.setState({
+    busyByScope: {},
+    busyByTab: {},
+    attentionByTab: {},
+    attentionByScope: {},
+    statusCountsByScope: {},
+  });
+}
+
+/** The kind of attention a tab/scope is raising: an agent waiting on a user
+ *  decision (a prompt is on screen) vs one that simply finished its turn. */
+export type AttentionKind = "decision" | "done";
+
+/** What an agent tab is asking for, or null if it isn't asking for anything.
+ *  Derived on each `recompute` tick from the tab's own output rather than pushed
+ *  in by the terminal: the bell we used to rely on is optional in every agent we
+ *  support (and never even reaches xterm for a tab whose pane has not been opened
+ *  yet), which left a finished agent showing no state at all.
+ *
+ *  The two kinds treat "the user is looking at this tab" differently, because
+ *  they mean different things:
+ *  - `done` is about UNREAD output, so looking at the tab IS the thing that
+ *    retires it. A looked-at tab also stamps `seenAtByPty`, so only what the
+ *    agent does AFTER the user looks away can raise the flag again.
+ *  - `decision` is about a BLOCKED agent, and looking at a prompt does not answer
+ *    it. It therefore holds while watched (nothing else in the UI says "this one
+ *    is stuck on you" once the tab is on screen but the eyes are elsewhere), and
+ *    is retired only by input — `noteUserInput` drops the tail the match is made
+ *    against. */
+function attentionFor(
+  scope: string,
+  tab: TabEntry,
+  ptyId: string,
+  now: number,
+): AttentionKind | null {
+  // Only AI agent tabs raise attention; a shell finishing a build doesn't.
+  if (tab.kind !== "agent" && tab.kind !== "local_agent") return null;
+  if (isTabDetached(scope, tab.key)) return null;
+  const lookedAt = isTabLookedAt(scope, tab.key);
+  // What's on screen has been read, so it can't be what raises a "done" later.
+  if (lookedAt) seenAtByPty[ptyId] = now;
+  const seen = seenAtByPty[ptyId] ?? 0;
+  const out = lastOutputByPty[ptyId] ?? 0;
+  const bell = bellByPty[ptyId] ?? 0;
+  const quiet = now - Math.max(out, bell);
+  if (quiet >= DECISION_QUIET_MS && tailLooksLikeDecision(ptyId)) {
+    return "decision";
+  }
+  // Past here everything is inferred from silence, which a watched tab's own
+  // screen already tells the user better than a lamp could.
+  if (lookedAt) return null;
+  // Nothing has happened here since the user last had eyes on the tab.
+  if (out <= seen && bell <= seen) return null;
+  // "Done" means the agent finished work somebody asked for, so it requires
+  // input to have been sent this session (see `noteUserInput`): without it, the
+  // quiet that follows a restore banner or a resumed session's replayed
+  // transcript — and any stray bell replayed with it — would read as a finished
+  // turn on every launch. A bell after real input is the agent explicitly
+  // asking to be looked at, so it doesn't have to wait out the full silence.
+  if (!inputByPty[ptyId]) return null;
+  if (bell > seen || quiet >= DONE_QUIET_MS) return "done";
+  // Still streaming: the "working" glow already speaks for it.
+  return null;
+}
+
+/** Roll the per-tab attention flags up to a per-scope kind (decision outranks
+ *  done), so the project pill can reflect a backgrounded project's state. */
+function rollupAttentionScopes(
+  attentionByTab: Record<string, AttentionKind>,
+): Record<string, AttentionKind> {
+  const byScope: Record<string, AttentionKind> = {};
+  for (const [ptyId, kind] of Object.entries(attentionByTab)) {
+    const parts = splitPtyId(ptyId);
+    if (!parts) continue;
+    if (kind === "decision" || byScope[parts.scope] === undefined) {
+      byScope[parts.scope] = kind;
+    }
+  }
+  return byScope;
+}
+
+/** True when two attention maps hold the same flags. */
+function sameAttention(
+  a: Record<string, AttentionKind>,
+  b: Record<string, AttentionKind>,
+): boolean {
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((k) => a[k] === b[k]);
+}
+
+/** A project's tally of tab statuses — one entry per tab, drawn as one little
+ *  bar each along the bottom of the project pill. */
+export interface TabStatusCounts {
+  working: number;
+  decision: number;
+  done: number;
+}
+
+function sameCounts(a: TabStatusCounts, b: TabStatusCounts): boolean {
+  return a.working === b.working && a.decision === b.decision && a.done === b.done;
+}
+
+/** True when two count maps are equivalent. Relies on `countStatusScopes`
+ *  preserving object identity for unchanged scopes, so a per-scope `===` is a
+ *  full comparison. */
+function sameCountMaps(
+  a: Record<string, TabStatusCounts>,
+  b: Record<string, TabStatusCounts>,
+): boolean {
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((k) => a[k] === b[k]);
+}
+
+/** Tally each scope's tabs by status. A tab counts exactly once: working wins
+ *  over a pending attention flag, mirroring how the tab bar resolves its own
+ *  glow, so the pill's bars can never disagree with the tabs they stand for.
+ *  Every tab counts, including the one under the user's eyes: the pill's strip is
+ *  a tally of what the PROJECT is doing, not of what still needs a glance, and a
+ *  project whose bars emptied out the moment it was selected could not answer the
+ *  one question the strip exists for — "is anything still running in there?" —
+ *  for the project you are actually in. (The tab bar still hides the viewed tab's
+ *  own glow: there, the tab IS the thing you're looking at.) A looked-at tab that
+ *  went quiet can still hold no `done` flag, so what a selected project shows is
+ *  its working tabs and its unanswered prompts — see `attentionFor`.
+ *  Scopes whose counts are unchanged keep their previous object identity, so a
+ *  tab going busy in one project doesn't re-render every other project's pill. */
+function countStatusScopes(
+  busyByTab: Record<string, boolean>,
+  attentionByTab: Record<string, AttentionKind>,
+  prev: Record<string, TabStatusCounts>,
+): Record<string, TabStatusCounts> {
+  const { tabsByScope } = useTabsStore.getState();
+  const next: Record<string, TabStatusCounts> = {};
+  for (const [scope, tabs] of Object.entries(tabsByScope)) {
+    const counts: TabStatusCounts = { working: 0, decision: 0, done: 0 };
+    for (const t of tabs) {
+      const ptyId = `${scope}:${t.key}`;
+      if (isPtyTabKind(t.kind) && busyByTab[ptyId]) counts.working++;
+      else if (attentionByTab[ptyId] === "decision") counts.decision++;
+      else if (attentionByTab[ptyId] === "done") counts.done++;
+    }
+    if (!counts.working && !counts.decision && !counts.done) continue;
+    const before = prev[scope];
+    next[scope] = before && sameCounts(before, counts) ? before : counts;
+  }
+  return next;
+}
+
+/** True when two string sets hold exactly the same members. */
+function sameStringSet(a: Set<string>, b: Set<string>): boolean {
+  if (a.size !== b.size) return false;
+  for (const v of a) if (!b.has(v)) return false;
+  return true;
 }
 
 function withoutScript(set: Set<string>, scriptPath: string): Set<string> {
@@ -33,15 +348,43 @@ function withoutScript(set: Set<string>, scriptPath: string): Set<string> {
 interface ActivityStore {
   /** project scope ("root" or project id) → has a running task right now. */
   busyByScope: Record<string, boolean>;
-  /** PTY/tab id → that individual tab is actively producing output right now.
-   *  Drives the per-tab "working" animation in the tab bar. */
+  /** Composed PTY id (`<scope>:<tabKey>`) → that individual tab is actively
+   *  producing output right now. Drives the per-tab "working" animation in the
+   *  tab bar. */
   busyByTab: Record<string, boolean>;
-  /** Recompute `busyByScope`/`busyByTab` from recent PTY output. Call on an
-   *  interval. */
+  /** Composed PTY id → an agent tab nobody is looking at wants something:
+   *  `decision` (a prompt is on its screen) or `done` (it finished its turn).
+   *  Derived from the tab's own output by `recompute`; drives the per-tab "needs
+   *  attention" glow and clears once the tab is viewed. */
+  attentionByTab: Record<string, AttentionKind>;
+  /** Per-scope rollup of `attentionByTab` (decision outranks done) so the project
+   *  pill can glow for a backgrounded project. */
+  attentionByScope: Record<string, AttentionKind>;
+  /** Scope → how many of its tabs are working / awaiting a decision / finished.
+   *  Drives the per-tab status bars along the bottom of the project pill. Scopes
+   *  with nothing to report are absent. */
+  statusCountsByScope: Record<string, TabStatusCounts>;
+  /** Record a terminal bell from a PTY (`ptyId` is the composed `<scope>:<key>`).
+   *  Only a hint that the agent wants attention now — WHAT it wants is worked out
+   *  from its output on the next `recompute`, which doesn't race the paint the way
+   *  reading the screen inside the bell handler did. */
+  noteBell: (ptyId: string) => void;
+  /** Clear a tab's attention flag and mark its output read (called the moment the
+   *  tab becomes the visible one, ahead of the next `recompute`). */
+  clearAttention: (ptyId: string) => void;
+  /** Recompute `busyByScope`/`busyByTab`/`attentionByTab` from recent PTY output.
+   *  Call on an interval. */
   recompute: () => void;
   /** Absolute paths of `.sh` scripts currently running detached. The run_id
    *  used with the backend is the script's absolute path (see runScript). */
   runningScripts: Set<string>;
+  /** Absolute paths of files whose run-launched terminal tab (Python Run/Debug
+   *  or a foreground shell run, tagged via `TabEntry.runFile`) is producing
+   *  sustained output right now. Derived by `recompute` from `busyByTab`, so it
+   *  drops out the moment the tab closes or goes quiet. Drives the green pulse on
+   *  the file tree's ▶ run button for the tab-backed run paths (the detached `.sh`
+   *  path uses `runningScripts` instead). */
+  runningRunFiles: Set<string>;
   /** Spawn a `.sh` script detached and track it so the run button can show a
    *  spinner until the backend emits `script-finished`. */
   runScript: (scriptPath: string, cwd: string) => void;
@@ -50,7 +393,39 @@ interface ActivityStore {
 export const useActivityStore = create<ActivityStore>((set, get) => ({
   busyByScope: {},
   busyByTab: {},
+  attentionByTab: {},
+  attentionByScope: {},
+  statusCountsByScope: {},
   runningScripts: new Set(),
+  runningRunFiles: new Set(),
+
+  noteBell: (ptyId) => {
+    if (!splitPtyId(ptyId)) return;
+    bellByPty[ptyId] = Date.now();
+    get().recompute();
+  },
+
+  clearAttention: (ptyId) => {
+    seenAtByPty[ptyId] = Date.now();
+    const kind = get().attentionByTab[ptyId];
+    if (!kind) return;
+    // Looking at a tab marks its output read — but it does not ANSWER a prompt,
+    // and the next `recompute` would only raise the flag straight back (see
+    // `attentionFor`). Keep it, so the lamp holds steady instead of blinking off
+    // and on at the switch. Input is what retires it.
+    if (kind === "decision" && tailLooksLikeDecision(ptyId)) return;
+    const attentionByTab = { ...get().attentionByTab };
+    delete attentionByTab[ptyId];
+    set({
+      attentionByTab,
+      attentionByScope: rollupAttentionScopes(attentionByTab),
+      statusCountsByScope: countStatusScopes(
+        get().busyByTab,
+        attentionByTab,
+        get().statusCountsByScope,
+      ),
+    });
+  },
 
   runScript: (scriptPath, cwd) => {
     set((s) => ({ runningScripts: new Set(s.runningScripts).add(scriptPath) }));
@@ -62,23 +437,83 @@ export const useActivityStore = create<ActivityStore>((set, get) => ({
 
   recompute: () => {
     const now = Date.now();
+    // Seconds of agent work this tick is worth, for the usage recap. Derived from
+    // the gap since the last tick rather than assuming the interval, and clamped:
+    // a suspended laptop or a stalled interval must not book hours of "agent
+    // working time" that never happened.
+    const sinceLastTick = lastTickAt === null ? 0 : now - lastTickAt;
+    const workedDeltaS =
+      sinceLastTick > 0 && sinceLastTick <= MAX_WORK_TICK_MS ? sinceLastTick / 1000 : 0;
+    lastTickAt = now;
+
     const { tabsByScope } = useTabsStore.getState();
     const prevScope = get().busyByScope;
     const prevTab = get().busyByTab;
+    const prevAttn = get().attentionByTab;
     const nextScope: Record<string, boolean> = {};
     const nextTab: Record<string, boolean> = {};
+    const nextAttn: Record<string, AttentionKind> = {};
+    // Files whose run-launched tab is busy this tick (see `runningRunFiles`).
+    // Collected from live tabs only, so a closed/replaced run tab drops out.
+    const nextRunFiles = new Set<string>();
+    const live = new Set<string>();
     let changed = false;
 
     for (const [scope, tabs] of Object.entries(tabsByScope)) {
       let scopeBusy = false;
       for (const t of tabs) {
-        const ts = lastOutputByPty[t.key];
-        const tabBusy = ts !== undefined && now - ts < BUSY_WINDOW_MS;
+        // PTY output is recorded under the composed id (`<scope>:<tabKey>`, what
+        // the backend emits and AppShell feeds in), and tab keys can collide
+        // across projects, so every derived map is keyed the same way — a bare
+        // key would let one project's agent light another project's pill.
+        const ptyId = `${scope}:${t.key}`;
+        live.add(ptyId);
+        const ts = lastOutputByPty[ptyId];
+        const onset = onsetByPty[ptyId];
+        // Busy = the tab was commanded at some point this session (see
+        // `noteUserInput` — so restored tabs bursting resume banners on launch
+        // never read as "working"), output is still recent, AND the burst has
+        // been sustained past the onset debounce (so a lone blip never
+        // registers as "working").
+        const tabBusy =
+          inputByPty[ptyId] !== undefined &&
+          ts !== undefined &&
+          now - ts < BUSY_WINDOW_MS &&
+          onset !== undefined &&
+          now - onset >= WORK_ONSET_MS;
         if (tabBusy) {
-          nextTab[t.key] = true;
+          nextTab[ptyId] = true;
           scopeBusy = true;
+          // A run-launched tab (Python Run/Debug, foreground shell run) pulses
+          // its source file's ▶ run button while it produces output. Busy-gated,
+          // so a restored-but-quiet run tab never lights up.
+          if (t.runFile) nextRunFiles.add(t.runFile);
+        }
+        if ((prevTab[ptyId] ?? false) !== tabBusy) changed = true;
+
+        const attn = attentionFor(scope, t, ptyId, now);
+        if (attn) nextAttn[ptyId] = attn;
+
+        // ── Usage recap ────────────────────────────────────────────────────
+        // The busy/attention state this tick is already the truth about what the
+        // agents are doing; the recap just needs it accumulated rather than only
+        // rendered. Only agent tabs count — a busy shell is the user working, not
+        // an agent.
+        if (agentPromptLeaf(t)) {
+          if (tabBusy && workedDeltaS > 0) {
+            // Agent-seconds: two agents working in parallel for a minute is two
+            // agent-minutes. That is the quantity worth reporting.
+            bumpUsage(scope, METRIC.AGENT_WORKED_S, workedDeltaS);
+          }
+          // Count the EDGE, not the state: an agent sitting on a decision prompt
+          // for ten ticks stopped to ask once, not ten times.
+          if (attn && prevAttn[ptyId] !== attn) {
+            bumpUsage(
+              scope,
+              attn === "decision" ? METRIC.AGENT_DECISION : METRIC.AGENT_DONE,
+            );
+          }
         }
-        if ((prevTab[t.key] ?? false) !== tabBusy) changed = true;
       }
       if (scopeBusy) nextScope[scope] = true;
       if ((prevScope[scope] ?? false) !== scopeBusy) changed = true;
@@ -90,8 +525,40 @@ export const useActivityStore = create<ActivityStore>((set, get) => ({
     for (const tab of Object.keys(prevTab)) {
       if (!(tab in nextTab) && prevTab[tab]) changed = true;
     }
+    // Closed tabs would otherwise keep their output history (and their tail)
+    // forever, and hand it back to whatever tab next reuses the key.
+    for (const map of PTY_MAPS) {
+      for (const ptyId of Object.keys(map)) {
+        if (!live.has(ptyId)) delete map[ptyId];
+      }
+    }
+    for (const ptyId of decisionMemo.keys()) {
+      if (!live.has(ptyId)) decisionMemo.delete(ptyId);
+    }
 
-    if (changed) set({ busyByScope: nextScope, busyByTab: nextTab });
+    const attnChanged = !sameAttention(prevAttn, nextAttn);
+    const prevCounts = get().statusCountsByScope;
+    const nextCounts = countStatusScopes(nextTab, nextAttn, prevCounts);
+    // The tally can move even when no tab flipped busy — a tab carrying an
+    // attention flag was closed, say — so it gates the publish independently.
+    const countsChanged = !sameCountMaps(prevCounts, nextCounts);
+    // The run-file set can move independently of `busyByTab` — a run tab going
+    // busy flips both, but a run tab closing while still "busy" drops out here
+    // via `live` even if some other tab keeps the same busy tally — so gate it
+    // on its own comparison, same as the other maps.
+    const runFilesChanged = !sameStringSet(get().runningRunFiles, nextRunFiles);
+    if (!changed && !attnChanged && !countsChanged && !runFilesChanged) return;
+    // Only re-publish the maps that actually moved: every tab bar subscribes to
+    // the whole `busyByTab` object, so handing it a fresh-but-equal one on each
+    // interval tick would re-render them all for nothing.
+    set({
+      ...(changed ? { busyByScope: nextScope, busyByTab: nextTab } : {}),
+      ...(attnChanged
+        ? { attentionByTab: nextAttn, attentionByScope: rollupAttentionScopes(nextAttn) }
+        : {}),
+      ...(countsChanged ? { statusCountsByScope: nextCounts } : {}),
+      ...(runFilesChanged ? { runningRunFiles: nextRunFiles } : {}),
+    });
   },
 }));
 
diff --git a/src/stores/agentTask.ts b/src/stores/agentTask.ts
new file mode 100644
index 0000000..483b460
--- /dev/null
+++ b/src/stores/agentTask.ts
@@ -0,0 +1,45 @@
+import { create } from "zustand";
+import { splitPtyId } from "./activity";
+
+/**
+ * Per-tab agent task summary, captured from the terminal title an agent CLI sets
+ * via OSC 0/2 ("set window title") — the same signal a native terminal shows in
+ * its tab. Claude Code, Codex and friends update this as they work, so it reads
+ * as a short "what is this agent doing" summary, surfaced in the tab hover card.
+ *
+ * Kept in its own store (not `activity`): titles are event-driven and unrelated
+ * to activity's interval-recomputed busy maps, so a dedicated store keeps the
+ * hover card the only thing that re-renders on a title change.
+ */
+
+interface AgentTaskStore {
+  /** Bare tab key → the latest terminal title that tab's PTY set. */
+  titleByTab: Record<string, string>;
+  /** Record a terminal title for a PTY (`ptyId` is the composed `<scope>:<key>`).
+   *  Trims, ignores empty titles, and only writes when the value changed. */
+  setTabTitle: (ptyId: string, title: string) => void;
+  /** Forget a tab's title (called when its PTY is torn down). */
+  clearTabTitle: (tabKey: string) => void;
+}
+
+export const useAgentTaskStore = create<AgentTaskStore>((set, get) => ({
+  titleByTab: {},
+
+  setTabTitle: (ptyId, title) => {
+    const parts = splitPtyId(ptyId);
+    if (!parts) return;
+    const trimmed = title.trim();
+    if (!trimmed) return;
+    if (get().titleByTab[parts.key] === trimmed) return;
+    set((s) => ({ titleByTab: { ...s.titleByTab, [parts.key]: trimmed } }));
+  },
+
+  clearTabTitle: (tabKey) => {
+    if (!(tabKey in get().titleByTab)) return;
+    set((s) => {
+      const next = { ...s.titleByTab };
+      delete next[tabKey];
+      return { titleByTab: next };
+    });
+  },
+}));
diff --git a/src/stores/alarms.ts b/src/stores/alarms.ts
new file mode 100644
index 0000000..9e0b7ee
--- /dev/null
+++ b/src/stores/alarms.ts
@@ -0,0 +1,178 @@
+import { create } from "zustand";
+import {
+  isPermissionGranted,
+  requestPermission,
+  sendNotification,
+} from "@tauri-apps/plugin-notification";
+import type { DueAlarm, Snoozed } from "../lib/alarms";
+import {
+  alarmWindow,
+  describeLead,
+  dueAlarms,
+  snooze as makeSnooze,
+  wokenSnoozes,
+} from "../lib/alarms";
+import { expandEvents } from "../lib/recurrence";
+import { formatStampTime } from "../lib/calendarTime";
+import { useCalendarStore } from "./calendar";
+
+/** How often the ticker looks for due reminders. */
+const TICK_MS = 30_000;
+
+/**
+ * Where the "already fired" set is persisted.
+ *
+ * localStorage, not the calendar file: this is per-machine UI state, not calendar
+ * data. Writing it into `calendar.json` would mean an exported .ics carried
+ * "this user already dismissed this" — which is nobody else's business, and would
+ * churn the file on every reminder.
+ */
+const FIRED_KEY = "eldrun.calendar.firedAlarms";
+
+/** Cap on remembered keys, so the list cannot grow without bound. */
+const MAX_FIRED = 500;
+
+function loadFired(): Set<string> {
+  try {
+    const raw = localStorage.getItem(FIRED_KEY);
+    const list = raw ? (JSON.parse(raw) as unknown) : [];
+    return new Set(Array.isArray(list) ? list.filter((k): k is string => typeof k === "string") : []);
+  } catch {
+    return new Set();
+  }
+}
+
+function saveFired(fired: Set<string>) {
+  try {
+    // Keep the most recent; the oldest reminders will never come due again.
+    const list = [...fired].slice(-MAX_FIRED);
+    localStorage.setItem(FIRED_KEY, JSON.stringify(list));
+  } catch {
+    // A full/blocked localStorage must not take the reminder loop down; the cost
+    // is only that an alarm may re-fire after a restart.
+  }
+}
+
+interface AlarmStore {
+  /** Reminders showing in the in-app popup right now. */
+  active: DueAlarm[];
+  /** Snoozed reminders, waiting to come back. */
+  snoozed: Snoozed[];
+  /** Keys of every reminder already shown — the fire-once guard. */
+  fired: Set<string>;
+  started: boolean;
+
+  /** Begin the ticker. Idempotent. */
+  start: () => void;
+  stop: () => void;
+  /** One scan. Exposed for tests and for an immediate check after an edit. */
+  tick: (now?: Date) => Promise<void>;
+
+  dismiss: (key: string) => void;
+  dismissAll: () => void;
+  snooze: (key: string, minutes: number) => void;
+}
+
+let timer: ReturnType<typeof setInterval> | null = null;
+/** Whether the OS has granted notification permission (asked once, lazily). */
+let osPermission: boolean | null = null;
+
+async function notifyOs(alarm: DueAlarm) {
+  try {
+    if (osPermission === null) {
+      osPermission = await isPermissionGranted();
+      if (!osPermission) osPermission = (await requestPermission()) === "granted";
+    }
+    if (!osPermission) return;
+
+    const when = alarm.allDay
+      ? "Today"
+      : formatStampTime(alarm.start, true) || describeLead(alarm.minutesBefore);
+    sendNotification({
+      title: alarm.title || "Event",
+      body: [when, alarm.location].filter(Boolean).join(" · "),
+    });
+  } catch {
+    // No OS notification (permission denied, no daemon, headless CI). The in-app
+    // popup still shows, so the reminder is not lost — this channel is additive.
+  }
+}
+
+/**
+ * The reminder engine.
+ *
+ * A single ticker scans the calendar for reminders that have come due and shows
+ * each one **twice over**: an OS notification (which reaches the user when Eldrun
+ * is not focused, or not even visible) and an in-app popup (which offers snooze
+ * and dismiss). Both channels are driven from one fire-once record, so a reminder
+ * cannot double-show or re-show after a restart.
+ */
+export const useAlarmStore = create<AlarmStore>((set, get) => ({
+  active: [],
+  snoozed: [],
+  fired: loadFired(),
+  started: false,
+
+  start: () => {
+    if (get().started) return;
+    set({ started: true });
+    void get().tick();
+    timer = setInterval(() => void get().tick(), TICK_MS);
+  },
+
+  stop: () => {
+    if (timer) clearInterval(timer);
+    timer = null;
+    set({ started: false });
+  },
+
+  tick: async (now = new Date()) => {
+    const { events, loaded } = useCalendarStore.getState();
+    if (!loaded) return;
+
+    const { active, snoozed, fired } = get();
+
+    // Snoozed reminders that have come back around.
+    const woken = wokenSnoozes(snoozed, now);
+    const stillSnoozed = snoozed.filter((s) => !woken.some((w) => w.key === s.key));
+
+    // Expand only far enough to see every reminder that could be due.
+    const window = alarmWindow(events, now);
+    const occurrences = expandEvents(events, window.start, window.end);
+    const due = dueAlarms(occurrences, fired, now);
+
+    if (due.length === 0 && woken.length === 0) {
+      if (stillSnoozed.length !== snoozed.length) set({ snoozed: stillSnoozed });
+      return;
+    }
+
+    // Fresh reminders get both channels; a woken snooze is already known to the
+    // user, so it only comes back to the popup.
+    for (const alarm of due) void notifyOs(alarm);
+
+    const nextFired = new Set(fired);
+    for (const alarm of due) nextFired.add(alarm.key);
+    saveFired(nextFired);
+
+    const showing = [...active];
+    for (const alarm of [...due, ...woken.map((w) => w.alarm)]) {
+      if (!showing.some((a) => a.key === alarm.key)) showing.push(alarm);
+    }
+
+    set({ active: showing, snoozed: stillSnoozed, fired: nextFired });
+  },
+
+  dismiss: (key) => set((s) => ({ active: s.active.filter((a) => a.key !== key) })),
+
+  dismissAll: () => set({ active: [] }),
+
+  snooze: (key, minutes) =>
+    set((s) => {
+      const alarm = s.active.find((a) => a.key === key);
+      if (!alarm) return s;
+      return {
+        active: s.active.filter((a) => a.key !== key),
+        snoozed: [...s.snoozed.filter((x) => x.key !== key), makeSnooze(alarm, minutes)],
+      };
+    }),
+}));
diff --git a/src/stores/bigFolders.ts b/src/stores/bigFolders.ts
new file mode 100644
index 0000000..ec18b17
--- /dev/null
+++ b/src/stores/bigFolders.ts
@@ -0,0 +1,39 @@
+import { create } from "zustand";
+
+/**
+ * Which project's giant-folder prompt is open, if any.
+ *
+ * A single `<BigFolderDialogHost>` is mounted once (in AppShell) and reads this
+ * store, mirroring `stores/remoteMachines`. Keyed by an explicit project id —
+ * not the active project — because the moment that opens it (a project just
+ * created, imported, or extended to a host) is also a moment the user may switch
+ * away from, and the prompt must keep asking about the tree it measured.
+ *
+ * `askedProjects` is the once-per-project latch: the prompt is a *setup*
+ * question, so it opens itself unasked exactly once per project and is a menu
+ * item thereafter. It lives in memory only — a session that answered it has an
+ * answer in the sync manifest, and a session that dismissed it can be asked
+ * again next launch rather than losing the question forever.
+ */
+interface BigFolderDialogStore {
+  projectId: string | null;
+  askedProjects: Set<string>;
+  /** Open the prompt for a project (a manual "Big folders…" click). */
+  open: (projectId: string) => void;
+  /** Open it only if this project has not been asked in this session — the
+   *  post-create / post-extend trigger. */
+  openOnce: (projectId: string) => void;
+  close: () => void;
+}
+
+export const useBigFoldersStore = create<BigFolderDialogStore>((set, get) => ({
+  projectId: null,
+  askedProjects: new Set(),
+  open: (projectId) =>
+    set((s) => ({ projectId, askedProjects: new Set(s.askedProjects).add(projectId) })),
+  openOnce: (projectId) => {
+    if (get().askedProjects.has(projectId)) return;
+    get().open(projectId);
+  },
+  close: () => set({ projectId: null }),
+}));
diff --git a/src/stores/calendar.ts b/src/stores/calendar.ts
new file mode 100644
index 0000000..1786cbc
--- /dev/null
+++ b/src/stores/calendar.ts
@@ -0,0 +1,182 @@
+import { invoke } from "@tauri-apps/api/core";
+import { create } from "zustand";
+import type {
+  Calendar,
+  CalendarData,
+  CalendarEvent,
+  CalendarTask,
+  Occurrence,
+} from "../types";
+// `CalendarData` is the shape `calendar_load` returns; the store flattens it.
+import { excludeOccurrence, overrideOccurrence } from "../lib/recurrence";
+
+/**
+ * The native calendar's store: one global set of calendars, events and tasks,
+ * backed by `~/.local/share/eldrun/calendar.json`.
+ *
+ * The store is deliberately *global*, not per-project — a calendar tab opened
+ * from any scope shows the same events, and an edit in one is seen live by the
+ * others (see `CALENDAR_TAB_CMD` in `stores/tabs.ts`).
+ *
+ * It holds only stored state. Recurrence expansion, alarm evaluation and ICS
+ * parsing are pure functions in `src/lib/{recurrence,ics,calendarTime}.ts`;
+ * components call those on the state they select here.
+ *
+ * Every mutation writes through to the backend and then patches local state with
+ * what the backend returned, so the store never drifts from disk.
+ */
+interface CalendarStore {
+  calendars: Calendar[];
+  events: CalendarEvent[];
+  tasks: CalendarTask[];
+  loaded: boolean;
+
+  /** Load the whole store. Safe to call repeatedly; only the first does work. */
+  load: () => Promise<void>;
+  /** Re-read from disk unconditionally (after an ICS import rewrites the file). */
+  reload: () => Promise<void>;
+
+  createEvent: (event: Omit<CalendarEvent, "id">) => Promise<CalendarEvent>;
+  updateEvent: (event: CalendarEvent) => Promise<void>;
+  deleteEvent: (id: string) => Promise<void>;
+
+  /**
+   * Delete a single occurrence of a recurring event ("this event only") by
+   * excluding its rule-generated start, leaving the series intact.
+   */
+  deleteOccurrence: (eventId: string, occurrenceStart: string) => Promise<void>;
+  /** Edit a single occurrence, leaving the rest of the series alone. */
+  updateOccurrence: (
+    eventId: string,
+    occurrenceStart: string,
+    changes: Partial<Pick<Occurrence, "start" | "end" | "title" | "location" | "notes">>,
+  ) => Promise<void>;
+
+  createTask: (task: Omit<CalendarTask, "id">) => Promise<CalendarTask>;
+  updateTask: (task: CalendarTask) => Promise<void>;
+  deleteTask: (id: string) => Promise<void>;
+
+  createCalendar: (calendar: Omit<Calendar, "id">) => Promise<Calendar>;
+  updateCalendar: (calendar: Calendar) => Promise<void>;
+  deleteCalendar: (id: string) => Promise<void>;
+  /** Toggle a calendar's checkbox in the sidebar. */
+  toggleCalendarVisible: (id: string) => Promise<void>;
+}
+
+/** A new event carries no id — the backend mints one. */
+const withoutId = (event: Omit<CalendarEvent, "id">): CalendarEvent =>
+  ({ ...event, id: "" }) as CalendarEvent;
+
+export const useCalendarStore = create<CalendarStore>((set, get) => ({
+  calendars: [],
+  events: [],
+  tasks: [],
+  loaded: false,
+
+  load: async () => {
+    if (get().loaded) return;
+    await get().reload();
+  },
+
+  reload: async () => {
+    const data = await invoke<CalendarData>("calendar_load").catch(() => null);
+    set({
+      calendars: data?.calendars ?? [],
+      events: data?.events ?? [],
+      tasks: data?.tasks ?? [],
+      loaded: true,
+    });
+  },
+
+  // ── Events ──────────────────────────────────────────────────────────────
+
+  createEvent: async (draft) => {
+    const event = await invoke<CalendarEvent>("create_event", { event: withoutId(draft) });
+    set((s) => ({ events: [...s.events, event] }));
+    return event;
+  },
+
+  updateEvent: async (event) => {
+    const updated = await invoke<CalendarEvent>("update_event", { event });
+    set((s) => ({ events: s.events.map((e) => (e.id === updated.id ? updated : e)) }));
+  },
+
+  deleteEvent: async (id) => {
+    await invoke<void>("delete_event", { id });
+    set((s) => ({ events: s.events.filter((e) => e.id !== id) }));
+  },
+
+  deleteOccurrence: async (eventId, occurrenceStart) => {
+    const master = get().events.find((e) => e.id === eventId);
+    if (!master) return;
+    await get().updateEvent(excludeOccurrence(master, occurrenceStart));
+  },
+
+  updateOccurrence: async (eventId, occurrenceStart, changes) => {
+    const master = get().events.find((e) => e.id === eventId);
+    if (!master) return;
+    await get().updateEvent(overrideOccurrence(master, occurrenceStart, changes));
+  },
+
+  // ── Tasks ───────────────────────────────────────────────────────────────
+
+  createTask: async (draft) => {
+    const task = await invoke<CalendarTask>("create_task", {
+      task: { ...draft, id: "" } as CalendarTask,
+    });
+    set((s) => ({ tasks: [...s.tasks, task] }));
+    return task;
+  },
+
+  updateTask: async (task) => {
+    const updated = await invoke<CalendarTask>("update_task", { task });
+    set((s) => ({ tasks: s.tasks.map((t) => (t.id === updated.id ? updated : t)) }));
+  },
+
+  deleteTask: async (id) => {
+    await invoke<void>("delete_task", { id });
+    set((s) => ({ tasks: s.tasks.filter((t) => t.id !== id) }));
+  },
+
+  // ── Calendars ───────────────────────────────────────────────────────────
+
+  createCalendar: async (draft) => {
+    const calendar = await invoke<Calendar>("create_calendar", {
+      calendar: { ...draft, id: "" } as Calendar,
+    });
+    set((s) => ({ calendars: [...s.calendars, calendar] }));
+    return calendar;
+  },
+
+  updateCalendar: async (calendar) => {
+    const updated = await invoke<Calendar>("update_calendar", { calendar });
+    set((s) => ({ calendars: s.calendars.map((c) => (c.id === updated.id ? updated : c)) }));
+  },
+
+  deleteCalendar: async (id) => {
+    await invoke<void>("delete_calendar", { id });
+    // The backend deletes the calendar's events and tasks with it; mirror that
+    // locally rather than re-reading the whole file.
+    set((s) => ({
+      calendars: s.calendars.filter((c) => c.id !== id),
+      events: s.events.filter((e) => e.calendar_id !== id),
+      tasks: s.tasks.filter((t) => t.calendar_id !== id),
+    }));
+  },
+
+  toggleCalendarVisible: async (id) => {
+    const cal = get().calendars.find((c) => c.id === id);
+    if (!cal) return;
+    await get().updateCalendar({ ...cal, visible: !cal.visible });
+  },
+}));
+
+/** The ids of the calendars currently checked in the sidebar. */
+export function visibleCalendarIds(calendars: Calendar[]): Set<string> {
+  return new Set(calendars.filter((c) => c.visible).map((c) => c.id));
+}
+
+/** A calendar's color, falling back to the accent when it has been deleted. */
+export function calendarColor(calendars: Calendar[], id: string): string {
+  return calendars.find((c) => c.id === id)?.color ?? "var(--accent)";
+}
diff --git a/src/stores/connectDialog.ts b/src/stores/connectDialog.ts
new file mode 100644
index 0000000..2acc198
--- /dev/null
+++ b/src/stores/connectDialog.ts
@@ -0,0 +1,26 @@
+import { create } from "zustand";
+
+/**
+ * Which remote project's Connect modal is open, if any. A single
+ * `<RemoteConnectDialog>` is mounted once (in AppShell) and reads this store;
+ * the per-pill SSH status lamp (and the disconnected-pane placeholder) open the
+ * modal by calling `open(projectId)`. Keyed by an explicit project id — not the
+ * active project — so switching projects never retargets an open modal.
+ */
+interface ConnectDialogStore {
+  projectId: string | null;
+  /** Which host of the project the modal targets (multi-host remote,
+   *  `docs/multi_host_remote_plan.md`): `"primary"` (the default) or a worker id.
+   *  `null` when no modal is open. */
+  hostId: string | null;
+  /** Open the Connect modal for a project host. `hostId` defaults to the primary. */
+  open: (projectId: string, hostId?: string) => void;
+  close: () => void;
+}
+
+export const useConnectDialogStore = create<ConnectDialogStore>((set) => ({
+  projectId: null,
+  hostId: null,
+  open: (projectId, hostId = "primary") => set({ projectId, hostId }),
+  close: () => set({ projectId: null, hostId: null }),
+}));
diff --git a/src/stores/detached.ts b/src/stores/detached.ts
index 48dca85..705990f 100644
--- a/src/stores/detached.ts
+++ b/src/stores/detached.ts
@@ -15,8 +15,19 @@ import { emit, listen } from "@tauri-apps/api/event";
 import { WebviewWindow } from "@tauri-apps/api/webviewWindow";
 import {
   useTabsStore,
-  type GroupNode,
+  orderedTabKeys,
+  findGroupOfTab,
+  mapGroup,
+  removeKeyFromTree,
+  splitSubtree,
+  applyResize,
+  moveKeyInTree,
+  allGroups,
+  type DropEdge,
+  type LayoutNode,
+  type LocalityHost,
   type TabEntry,
+  type TabLocation,
   type WindowBounds,
 } from "./tabs";
 import { useProjectsStore } from "./projects";
@@ -65,54 +76,145 @@ export const DETACHED_DOCK = "detached-dock";
  * and do not restore on next launch.
  */
 export const DETACHED_CLOSE = "detached-close";
+/**
+ * Detached → main: hide this popout into the main window's right-panel "Hidden
+ * subwindows" list instead of docking it live (DETACHED_DOCK) or discarding it
+ * (DETACHED_CLOSE). The group's tabs stay mounted (PTYs alive); the main window
+ * parks its subtree in `hiddenGroupsByScope`, from which it is restored or closed
+ * exactly like a hidden main-window subwindow. Same envelope shape as the dock.
+ */
+export const DETACHED_HIDE = "detached-hide";
 /** Detached → main: the popout's OS geometry changed (persisted for respawn). */
 export const DETACHED_BOUNDS = "detached-bounds";
+/**
+ * Detached → main: the popout's own UI zoom changed (Ctrl +/- in the popout).
+ * Zoom is per-window, so the main window records it on the popout's detached
+ * entry (persisted, and shipped back in the seed) — never touching the global
+ * `ui_zoom` or any other window.
+ */
+export const DETACHED_ZOOM = "detached-zoom";
 /**
  * #42: cross-window drag-to-dock. The detached window streams the gesture to the
  * main window, which renders the dock preview and docks the group on release.
  * START opens the preview, MOVE updates it, and END commits (or cancels). One
  * popout drags at a time, so MOVE/END carry no id.
  *
- * The streamed coords are OS-level desktop CURSOR coords (logical/CSS px),
- * polled from `cursorPosition()` — NOT DOM pointer-event coords. On WebKitGTK
- * (esp. Wayland) DOM pointermove/up do not cross the OS window boundary, so once
- * the cursor leaves the popout the DOM stream dies at the popout's edge. Polling
- * the OS cursor keeps MOVE flowing over the main window, and END carries the last
- * polled cursor position so the drop resolves where the cursor really is.
+ * The streamed coords are OS-level desktop CURSOR coords in PHYSICAL desktop px
+ * (the canonical cross-window space — see `lib/coords`), polled from
+ * `cursorPosition()` — NOT DOM pointer-event coords. DOM `screenX/Y` units diverge
+ * across engines under DPI scaling, and on WebKitGTK (esp. Wayland) DOM
+ * pointermove/up don't cross the OS window boundary, so the DOM stream would die at
+ * the popout's edge. Polling the OS cursor keeps MOVE flowing over the main window
+ * in a single DPI-correct frame, and END carries the last polled cursor position so
+ * the drop resolves where the cursor really is. The receiver converts physical →
+ * its-own-client px at the leaf (`physToClient`), the only DPI-correct place.
  */
 export const DETACHED_DRAG_START = "detached-drag-start";
 export const DETACHED_DRAG_MOVE = "detached-drag-move";
 export const DETACHED_DRAG_END = "detached-drag-end";
 
 /**
- * Detached → main: begin a drag-to-dock. Without `tabKey` it drags the WHOLE
- * popout (the tab-bar handle); with `tabKey` it drags that single tab, which the
- * host docks on its own via `attachDetachedTab`.
+ * #42: main → detached drop preview. The mirror image of the DETACHED_DRAG_*
+ * stream: while a tab dragged OUT of the main window hovers over a popout, the
+ * main window streams `active:true` on the popout's label-namespaced channel so
+ * it highlights itself as a drop target; `active:false` (cursor left, released
+ * elsewhere, or drag cancelled) clears it. The dock itself is a main-side store
+ * mutation (`dockTabIntoDetached`) + re-seed — the popout only renders the
+ * highlight, never owns the layout. Namespaced per label (like the seed) so the
+ * main targets exactly the one popout under the cursor.
+ */
+export const detachedDropPreviewEvent = (label: string) =>
+  `detached-drop-preview-${label}`;
+/**
+ * Main → detached: drive THIS popout's drop preview while a tab/file dragged out
+ * of the main window hovers it. The host resolves WHICH pane the cursor is over
+ * (synchronously, from the popout's reported geometry — see DETACHED_PANES) and
+ * streams the resolved `target` here; the popout renders the per-pane split/merge
+ * preview for it (no release race — the host already holds the target on release).
+ * `active:false` clears the preview. `label` is the dragged item's name (ghost).
+ */
+export interface DetachedDropPreview {
+  active: boolean;
+  target?: { groupId: string; edge: DropEdge } | null;
+  // OS cursor in PHYSICAL desktop px (see lib/coords) so the popout can position
+  // its own drag ghost while the main-window item hovers (the main's ghost lives in
+  // the main window and isn't visible over the popout). Cosmetic — the target
+  // drives the drop.
+  cursorPhysX?: number;
+  cursorPhysY?: number;
+  label?: string;
+}
+
+/**
+ * Host → detached: ask a popout to report its per-pane geometry so the host can
+ * hit-test the cursor against it. Sent once when a drag starts (the popout's tree
+ * is fixed until the drop). Namespaced by label so only the addressed popout
+ * replies. The popout answers on DETACHED_PANES.
+ */
+export const DETACHED_PANES_REQUEST = "detached-panes-request";
+export interface DetachedPanesRequest {
+  label: string;
+}
+/**
+ * Detached → host: this popout's panes in CLIENT px (its own getBoundingClientRect
+ * space). The host converts the physical cursor into THIS popout's client px via
+ * its `innerPosition`/scale (`physToClient` — never `outerPosition`, so an
+ * invisible frame/shadow can't skew it) before hit-testing against these: over a
+ * bar → merge into that group; over a body → edge-split (pickEdge). One channel
+ * carrying the label, so the host needs a single listener.
+ */
+export const DETACHED_PANES = "detached-panes";
+export interface PaneRect {
+  groupId: string;
+  bar: { left: number; top: number; right: number; bottom: number };
+  body: { left: number; top: number; right: number; bottom: number };
+}
+export interface DetachedPanes {
+  label: string;
+  panes: PaneRect[];
+}
+
+/**
+ * Detached → main: begin a drag-to-dock. Without `tabKey`/`paneId` it drags the
+ * WHOLE popout (the titlebar, or the bar grip of a single-pane popout); with
+ * `tabKey` it drags that single tab, which the host docks on its own via
+ * `attachDetachedTab`; with `paneId` it drags ONE pane (an inner group) of a
+ * multi-pane popout, which the host docks via `attachDetachedPane` — never the
+ * whole popout, so the sibling panes stay floating.
  */
 export interface DetachedDragStart {
   scope: string;
   groupId: string;
   label: string;
-  screenX: number;
-  screenY: number;
+  cursorPhysX: number;
+  cursorPhysY: number;
   tabKey?: string;
+  paneId?: string;
 }
-/** Detached → main: the OS cursor moved (desktop logical/CSS px). */
+/** Detached → main: the OS cursor moved (physical desktop px — see lib/coords). */
 export interface DetachedDragMove {
-  screenX: number;
-  screenY: number;
+  cursorPhysX: number;
+  cursorPhysY: number;
 }
 /**
- * Detached → main: the drag ended; `cancelled` skips docking. `screenX/Y` carry
- * the LAST OS-level cursor position (logical/CSS px), so the main window resolves
- * the drop against where the cursor actually is — not the stale DOM coordinates of
- * the release event, which on WebKitGTK fire inside the popout even when the
- * cursor is released over the main window. Absent only on a cancel.
+ * Detached → main: the drag ended; `cancelled` skips docking. `cursorPhysX/Y` carry
+ * the LAST OS-level cursor position (physical desktop px — see lib/coords), so the
+ * main window resolves the drop against where the cursor actually is — not the
+ * stale DOM coordinates of the release event, which on WebKitGTK fire inside the
+ * popout even when the cursor is released over the main window. Absent only on a
+ * cancel.
  */
 export interface DetachedDragEnd {
   cancelled: boolean;
-  screenX?: number;
-  screenY?: number;
+  cursorPhysX?: number;
+  cursorPhysY?: number;
+  /**
+   * Shift held at release → keep the popout floating as its own window instead of
+   * docking it back into the main window (mirrors the main-window tab rule where
+   * Shift always means "new window"). For a drag that originates in a popout, the
+   * popout already IS a separate window, so "always new window" = don't dock.
+   */
+  shift?: boolean;
 }
 
 /** The seed the main window ships to a freshly-opened detached window. */
@@ -120,20 +222,55 @@ export interface DetachedSeed {
   scope: string;
   groupId: string;
   tabs: TabEntry[];
-  subtree: GroupNode;
+  subtree: LayoutNode;
+  /**
+   * Set only when this seed is the result of a tab being docked INTO the popout
+   * from another window (a cross-window merge): the docked tab's key, so the
+   * popout plays the same drop-in landing flourish it would for an in-popout
+   * merge. Absent on a plain (re)seed, so a refresh never re-animates.
+   */
+  landedKey?: string;
+  /**
+   * The popout's persisted per-window zoom (undefined = 100%). The popout applies
+   * it to its OWN webview on the FIRST seed, restoring the zoom it was left at
+   * (zoom is per-window, not the global `ui_zoom`). Later re-seeds carry the
+   * up-to-date value but the popout ignores it — it owns its zoom once open.
+   */
+  zoom?: number;
+  /**
+   * The owning project's remote identity, captured at seed time — the detached
+   * window is inert to the projects store, so this is the only way its tab strip
+   * can render the locality badge/menu and name the machine a tab runs on
+   * (`docs/multi_host_remote_plan.md`). Absent for a local project. `computeHosts`
+   * can go stale if a worker is added while the popout is open (re-seed only on a
+   * tab add); acceptable — the machine list refreshes next time it re-seeds.
+   */
+  remote?: DetachedRemoteInfo;
+}
+
+/** The slice of a project's remoteness a detached window needs to drive its
+ *  locality UI (streamed in the seed since the projects store is unavailable). */
+export interface DetachedRemoteInfo {
+  primaryHost?: string;
+  computeHosts?: LocalityHost[];
 }
 
-/** Build a seed payload from a detached group's tabs + subtree. Pure. */
+/** Build a seed payload from a detached popout's tabs + subtree. Pure. The
+ *  subtree may be a split (multi-pane popout), so collect keys across the tree.
+ *  `zoom` is the popout's persisted per-window zoom (from its detached entry);
+ *  `remote` names the machines a locatable tab can run on (undefined = local). */
 export function buildSeed(
   scope: string,
   groupId: string,
   allScopeTabs: TabEntry[],
-  subtree: GroupNode,
+  subtree: LayoutNode,
+  zoom?: number,
+  remote?: DetachedRemoteInfo,
 ): DetachedSeed {
-  const keys = new Set(subtree.tabKeys);
-  // Ship only the group's own tabs (the detached window renders just this group).
+  const keys = new Set(orderedTabKeys(subtree));
+  // Ship only the popout's own tabs (it renders just this subtree).
   const tabs = allScopeTabs.filter((t) => keys.has(t.key));
-  return { scope, groupId, tabs, subtree };
+  return { scope, groupId, tabs, subtree, zoom, remote };
 }
 
 /**
@@ -144,7 +281,33 @@ export type DetachedEdit =
   | { kind: "activate"; key: string }
   | { kind: "rename"; key: string; label: string }
   | { kind: "close"; key: string }
-  | { kind: "reorder"; tabKeys: string[] };
+  | { kind: "reorder"; tabKeys: string[] }
+  // Multi-host: change WHERE a locatable tab runs (local mirror / primary / a
+  // worker), chosen from the popout's own locality badge. The detached tab's PTY
+  // is owned by the MAIN window's flat pane layer, so the main window applies this
+  // to `tabsByScope` (which respawns that pane on the new host); the popout applies
+  // it to its own tab payload optimistically so the badge updates at once.
+  | { kind: "setLocation"; key: string; location: TabLocation }
+  // New tab created FROM the popout's own "+" menu, or a file dropped onto a pane
+  // inside the popout. The detached window can't mint the store-unique tab key (or
+  // own the PTY), so it ships the resolved payload + the popout group it should
+  // land in; the MAIN window mints the key, adds the payload (spawning/owning the
+  // PTY), and re-seeds the popout so it renders it. With `edge` set to a side
+  // (left/right/top/bottom) the tab carves a NEW pane at that edge of the target
+  // group (a file dropped on a body edge); omitted or "center" appends it to the
+  // target group (the "+" menu, or a drop on a tab bar / pane centre).
+  | { kind: "add"; tab: Omit<TabEntry, "key">; targetGroupId: string; edge?: DropEdge }
+  // Multi-pane popouts: split `key` into a new pane at `edge` of `targetGroupId`.
+  | { kind: "split"; key: string; targetGroupId: string; edge: DropEdge }
+  // Multi-pane popouts: resize the divider between children i and i+1 of a split.
+  | { kind: "resize"; splitId: string; dividerIndex: number; fraction: number }
+  // Multi-pane popouts: merge `key` into `targetGroupId` (at `index`, else append).
+  | { kind: "move"; key: string; targetGroupId: string; index?: number }
+  // Toggle/resize a group's docked file-viewer column (the per-subwindow right
+  // file viewer), or record the folder it browsed to. Applied optimistically
+  // popout-side, mirrored by the main window into its detached record so the
+  // state persists + survives a dock.
+  | { kind: "files"; groupId: string; open?: boolean; width?: number; folder?: string };
 
 /** Envelope for a detached→main edit (identity + the edit itself). */
 export interface DetachedEditEnvelope {
@@ -166,6 +329,13 @@ export interface DetachedBoundsEnvelope {
   bounds: WindowBounds;
 }
 
+/** Envelope for a detached→main per-window zoom update. */
+export interface DetachedZoomEnvelope {
+  scope: string;
+  groupId: string;
+  zoom: number;
+}
+
 /** Identity the detached window sends when requesting its seed. */
 export interface DetachedSeedRequest {
   label: string;
@@ -181,34 +351,64 @@ export interface DetachedSeedRequest {
  * caller; this only updates the group node (tabKeys/activeKey).
  */
 export function applyEditToSubtree(
-  subtree: GroupNode,
+  subtree: LayoutNode,
   edit: DetachedEdit,
-): GroupNode {
+): LayoutNode | null {
   switch (edit.kind) {
-    case "activate":
-      return subtree.tabKeys.includes(edit.key)
-        ? { ...subtree, activeKey: edit.key }
+    case "activate": {
+      const g = findGroupOfTab(subtree, edit.key);
+      return g
+        ? mapGroup(subtree, g.group.id, (grp) => ({ ...grp, activeKey: edit.key }))
         : subtree;
-    case "close": {
-      const tabKeys = subtree.tabKeys.filter((k) => k !== edit.key);
-      const activeKey =
-        subtree.activeKey === edit.key ? (tabKeys[0] ?? null) : subtree.activeKey;
-      return { ...subtree, tabKeys, activeKey };
     }
+    case "close":
+      // Returns null if the popout emptied (caller closes the window).
+      return removeKeyFromTree(subtree, edit.key);
     case "reorder": {
-      // Keep only keys the group actually owns, preserving the requested order.
-      const owned = new Set(subtree.tabKeys);
-      const tabKeys = edit.tabKeys.filter((k) => owned.has(k));
-      if (tabKeys.length !== subtree.tabKeys.length) return subtree;
-      const activeKey =
-        subtree.activeKey && tabKeys.includes(subtree.activeKey)
-          ? subtree.activeKey
-          : (tabKeys[0] ?? null);
-      return { ...subtree, tabKeys, activeKey };
+      // Find the group whose tab set the reordered list permutes, then reapply.
+      const want = new Set(edit.tabKeys);
+      const g = allGroups(subtree).find(
+        (grp) =>
+          grp.tabKeys.length === edit.tabKeys.length &&
+          grp.tabKeys.every((k) => want.has(k)),
+      );
+      if (!g) return subtree;
+      return mapGroup(subtree, g.id, (grp) => {
+        const activeKey =
+          grp.activeKey && edit.tabKeys.includes(grp.activeKey)
+            ? grp.activeKey
+            : (edit.tabKeys[0] ?? null);
+        return { ...grp, tabKeys: edit.tabKeys, activeKey };
+      });
     }
+    case "split": {
+      // Optimistic local split; null (invalid) leaves the popout unchanged.
+      return splitSubtree(subtree, edit.key, edit.targetGroupId, edit.edge) ?? subtree;
+    }
+    case "resize":
+      // Optimistic local divider resize (mirrors the main window's resizeSplit).
+      return applyResize(subtree, edit.splitId, edit.dividerIndex, edit.fraction);
+    case "move":
+      // Optimistic local cross-group merge; null (invalid) leaves it unchanged.
+      return moveKeyInTree(subtree, edit.key, edit.targetGroupId, edit.index) ?? subtree;
+    case "files":
+      // Optimistic local file-viewer toggle/resize on the target group.
+      return mapGroup(subtree, edit.groupId, (grp) => ({
+        ...grp,
+        ...(edit.open != null ? { filesOpen: edit.open } : {}),
+        ...(edit.width != null ? { filesWidth: edit.width } : {}),
+        ...(edit.folder != null ? { filesFolder: edit.folder } : {}),
+      }));
+    case "add":
+      // The detached window can't mint the tab key — it leaves the subtree as-is
+      // and waits for the main window's re-seed (with the real, keyed tab).
+      return subtree;
     case "rename":
       // Label lives on the tab payload, not the group node — no node change.
       return subtree;
+    case "setLocation":
+      // Locality lives on the tab payload, not the group node — no node change.
+      return subtree;
   }
 }
 
@@ -223,6 +423,124 @@ export function applyRenameToTabs(
   return tabs.map((t) => (t.key === key ? { ...t, label: next } : t));
 }
 
+/** Apply a `setLocation` edit to a tab payload list (popout-side optimistic
+ *  update, so the locality badge flips before the main window's re-derive). Pure. */
+export function applyLocationToTabs(
+  tabs: TabEntry[],
+  key: string,
+  location: TabLocation,
+): TabEntry[] {
+  return tabs.map((t) => (t.key === key ? { ...t, location } : t));
+}
+
+/**
+ * #42: the UNIFIED cross-window drop decision for a single dragged tab. Keyed on
+ * the physical desktop cursor's relationship to the windows, this resolves a drag
+ * to ONE destination the SAME way regardless of which window it started in — the
+ * main window's `DETACHED_DRAG_END` host and (via the same ladder) `TabBar`'s own
+ * commit both consult it. Pure, so every branch is unit-testable.
+ *
+ * Ladder (first match wins):
+ *   1. `cancelled` (Escape / abort) → `none`.
+ *   2. released over the SOURCE popout & handled there → `local` (caller emitted
+ *      `cancelled:true`; this is defensive — such a release never reaches here).
+ *   3. `shift` → `newWindow` (Shift ALWAYS means "pop into its own window",
+ *      mirroring the main-window tab rule; a lone-tab source is refused downstream,
+ *      so it's a clean no-op rather than a hang).
+ *   4. over a SIBLING popout → `dockDetached` into it.
+ *   5. over the MAIN window → `dockMain` at the resolved pane target.
+ *   6. free space (no Eldrun window under the cursor) → `newWindow`.
+ */
+export type DetachedTabDrop =
+  | { kind: "none" } // cancelled — leave everything as-is
+  | { kind: "local" } // the source popout already committed a within-popout drop
+  | { kind: "newWindow" } // Shift, or released in free space → own new popout
+  | { kind: "dockDetached"; toGroupId: string } // released over a sibling popout
+  | { kind: "dockMain" }; // released over the main window (caller has the target)
+
+export function decideDetachedTabDrop(input: {
+  cancelled: boolean;
+  shift: boolean;
+  inMain: boolean;
+  /** A sibling popout under the cursor, or null (none / it's the source popout). */
+  overPopoutId: string | null;
+  srcGroupId: string;
+}): DetachedTabDrop {
+  if (input.cancelled) return { kind: "local" };
+  if (input.shift) return { kind: "newWindow" };
+  if (input.overPopoutId && input.overPopoutId !== input.srcGroupId) {
+    return { kind: "dockDetached", toGroupId: input.overPopoutId };
+  }
+  if (input.inMain) return { kind: "dockMain" };
+  return { kind: "newWindow" };
+}
+
+/**
+ * #42: the UNIFIED cross-window drop decision for a whole detached GROUP dragged
+ * from a popout. A group is already its own OS window, so "new window" just means
+ * "stay floating" (`float`). Docking a whole group into a SIBLING popout is out of
+ * scope (there is no merge-group-into-popout action), so a group over a sibling
+ * popout also stays floating. Pure/testable.
+ */
+export type DetachedGroupDrop =
+  | { kind: "float" } // Shift, free space, or over a sibling popout → keep floating
+  | { kind: "dockMain" }; // released over the main window (caller has the target)
+
+export function decideDetachedGroupDrop(input: {
+  cancelled: boolean;
+  shift: boolean;
+  inMain: boolean;
+  overPopoutId: string | null;
+  srcGroupId: string;
+}): DetachedGroupDrop {
+  if (input.cancelled || input.shift) return { kind: "float" };
+  if (input.overPopoutId && input.overPopoutId !== input.srcGroupId) {
+    return { kind: "float" };
+  }
+  if (input.inMain) return { kind: "dockMain" };
+  return { kind: "float" };
+}
+
+/**
+ * #42: the UNIFIED cross-window drop decision for ONE PANE (inner group) dragged
+ * out of a MULTI-pane popout by its bar grip. The pane is a subwindow in its own
+ * right, so it follows the single-tab ladder — dock JUST the pane into the main
+ * window, or pop it into its own window — never the whole-popout one, which is
+ * exactly the bug this exists to prevent: a pane drop docking every sibling pane
+ * into the main window. Docking a pane into a SIBLING popout is out of scope
+ * (same as whole groups) → stays put. Pure/testable.
+ */
+export type DetachedPaneDrop =
+  | { kind: "none" } // cancelled / released over the source popout — stay put
+  | { kind: "newWindow" } // Shift, or released in free space → own new popout
+  | { kind: "dockMain" }; // released over the main window (caller has the target)
+
+export function decideDetachedPaneDrop(input: {
+  cancelled: boolean;
+  shift: boolean;
+  inMain: boolean;
+  overPopoutId: string | null;
+  srcGroupId: string;
+}): DetachedPaneDrop {
+  if (input.cancelled) return { kind: "none" };
+  if (input.shift) return { kind: "newWindow" };
+  if (input.overPopoutId && input.overPopoutId !== input.srcGroupId) {
+    return { kind: "none" };
+  }
+  if (input.inMain) return { kind: "dockMain" };
+  return { kind: "newWindow" };
+}
+
+/** The remoteness a popout of `scope` needs to name its machines — read from the
+ *  MAIN window's projects store at seed time. `undefined` for a local project (no
+ *  locality axis) so the popout renders no locality badge, exactly like a local
+ *  project's main-window tab strip. */
+function remoteInfoForScope(scope: string): DetachedRemoteInfo | undefined {
+  const project = useProjectsStore.getState().projects.find((p) => p.id === scope);
+  if (!project?.remote) return undefined;
+  return { primaryHost: project.remote.host, computeHosts: project.compute_hosts };
+}
+
 /**
  * MAIN window: wire the host side of the detached-subwindow protocol. Responds
  * to a detached window's seed request by shipping its group's tabs+subtree,
@@ -238,13 +556,49 @@ export async function listenDetachedHost(): Promise<() => void> {
       (d) => d.id === groupId,
     );
     if (!entry) return;
-    const seed = buildSeed(scope, groupId, store.tabsByScope[scope] ?? [], entry.subtree);
+    const seed = buildSeed(
+      scope,
+      groupId,
+      store.tabsByScope[scope] ?? [],
+      entry.subtree,
+      entry.zoom,
+      remoteInfoForScope(scope),
+    );
     void emit(detachedSeedEvent(label), seed);
   });
 
   const unEdit = await listen<DetachedEditEnvelope>(DETACHED_EDIT, (ev) => {
     const { scope, groupId, edit } = ev.payload;
-    useTabsStore.getState().applyDetachedEdit(scope, groupId, edit);
+    const store = useTabsStore.getState();
+    if (edit.kind === "add") {
+      // The main window owns tab creation + the PTY: mint the tab into the
+      // popout's subtree (spawning the pane in the main window's flat pane layer),
+      // then re-seed the popout so it re-renders — attaching to the new PTY — and
+      // plays the drop-in landing for the freshly-added tab. A side `edge` carves
+      // the tab into a NEW pane at that edge (a file dropped on a body edge);
+      // otherwise it appends to the target group (the "+" menu / a pane-centre or
+      // tab-bar drop).
+      const key =
+        edit.edge && edit.edge !== "center"
+          ? store.addDetachedTabSplit(scope, groupId, edit.tab, edit.targetGroupId, edit.edge)
+          : store.addDetachedTab(scope, groupId, edit.tab, edit.targetGroupId);
+      if (!key) return;
+      const entry = (useTabsStore.getState().detachedGroupsByScope[scope] ?? []).find(
+        (d) => d.id === groupId,
+      );
+      if (!entry) return;
+      const seed = buildSeed(
+        scope,
+        groupId,
+        useTabsStore.getState().tabsByScope[scope] ?? [],
+        entry.subtree,
+        entry.zoom,
+        remoteInfoForScope(scope),
+      );
+      void emit(detachedSeedEvent(entry.label), { ...seed, landedKey: key });
+      return;
+    }
+    store.applyDetachedEdit(scope, groupId, edit);
   });
 
   const unBounds = await listen<DetachedBoundsEnvelope>(DETACHED_BOUNDS, (ev) => {
@@ -252,6 +606,11 @@ export async function listenDetachedHost(): Promise<() => void> {
     useTabsStore.getState().setDetachedBounds(scope, groupId, bounds);
   });
 
+  const unZoom = await listen<DetachedZoomEnvelope>(DETACHED_ZOOM, (ev) => {
+    const { scope, groupId, zoom } = ev.payload;
+    useTabsStore.getState().setDetachedZoom(scope, groupId, zoom);
+  });
+
   const unDock = await listen<DetachedDockEnvelope>(DETACHED_DOCK, (ev) => {
     const { scope, groupId } = ev.payload;
     // `attachGroup` operates on the ACTIVE scope's live layout, so it can only
@@ -285,12 +644,31 @@ export async function listenDetachedHost(): Promise<() => void> {
     if (localFile) void store.persistScope(scope, localFile);
   });
 
+  const unHide = await listen<DetachedDockEnvelope>(DETACHED_HIDE, (ev) => {
+    const { scope, groupId } = ev.payload;
+    const store = useTabsStore.getState();
+    // Park the popout in the scope's Hidden list (tabs stay mounted). Works for
+    // the active scope (shows in the right panel now) and an inactive one (shows
+    // when that project is next activated) — `hiddenGroupsByScope` is per-scope.
+    store.hideDetachedGroup(scope, groupId);
+    // Persist so the group is saved as HIDDEN (not detached) and restores into the
+    // Hidden list on next launch. The active scope's CenterPanel also debounce-
+    // saves, but a parked (inactive) scope has nothing else to write its
+    // project.json. Root has no project.json, so there's nothing to persist.
+    const localFile = useProjectsStore
+      .getState()
+      .projects.find((p) => p.id === scope)?.local_file;
+    if (localFile) void store.persistScope(scope, localFile);
+  });
+
   return () => {
     unSeed();
     unEdit();
     unBounds();
+    unZoom();
     unDock();
     unClose();
+    unHide();
   };
 }
 
diff --git a/src/stores/drag.ts b/src/stores/drag.ts
index 18a9c95..cb53849 100644
--- a/src/stores/drag.ts
+++ b/src/stores/drag.ts
@@ -26,6 +26,14 @@ export interface EmbedCap {
  *             subwindow holding it (overGroup/edge, like tab drags). Capability
  *             is resolved at release time (embed vs external), not a drop gate.
  */
+/** One file in a multi-file FileTree drag. `viewer` is the built-in viewer that
+ *  should render it (resolved at drag start), else undefined → external embed. */
+export interface FileDragItem {
+  path: string;
+  name: string;
+  viewer?: InternalViewer;
+}
+
 export interface TabDrag {
   kind: "tab" | "file" | "link" | "detached";
   key: string; // the dragged tab's key (tab drags); "" for file/link/detached drags
@@ -46,6 +54,12 @@ export interface TabDrag {
   // When set, drop opens the file in the named built-in viewer (pdf/image/
   // markdown/text/tex) rather than the external embed path. See commitFileDrop.
   viewer?: InternalViewer;
+  // Multi-file drag (dragging a selection from the FileTree). When present with
+  // length > 1, commitFileDrop repeats each drop branch per file (one embed tab
+  // each), and drag-to-move relocates every one. `filePath`/`fileName`/`viewer`
+  // still describe the primary (first) file so single-file consumers keep
+  // working; a length-1 array is equivalent to a plain single-file drag.
+  files?: FileDragItem[];
   // Prefetched capability for this file (null while the query is in flight).
   embedCap?: EmbedCap | null;
   // ── Link-drag payload (kind === "link") ───────────────────────────────────
@@ -67,6 +81,10 @@ export interface TabDrag {
   // popout. The host then docks just this tab into the main layout via
   // attachDetachedTab instead of re-attaching the whole group.
   detachedTabKey?: string;
+  // #42: set when ONE PANE (inner group) of a MULTI-pane popout is being dragged
+  // by its bar grip. The host then docks just this pane via attachDetachedPane —
+  // never the whole popout, so its sibling panes stay floating.
+  detachedPaneId?: string;
   // ── Content thumbnail (tab drags) ─────────────────────────────────────────
   // A clone of the dragged tab's live pane DOM, captured once at drag start, so
   // the floating ghost can preview the tab's CONTENT (not just its label). The
@@ -98,6 +116,7 @@ interface DragStore {
       fileName: string;
       fileExec?: string;
       viewer?: InternalViewer;
+      files?: FileDragItem[];
     },
   ) => void;
   startLinkDrag: (
@@ -112,6 +131,7 @@ interface DragStore {
       detachedScope: string;
       detachedGroupId: string;
       detachedTabKey?: string;
+      detachedPaneId?: string;
     },
   ) => void;
   setEmbedCap: (cap: EmbedCap | null) => void;
@@ -152,6 +172,7 @@ export const useDragStore = create<DragStore>((set) => ({
         fileName: d.fileName,
         fileExec: d.fileExec,
         viewer: d.viewer,
+        files: d.files,
         embedCap: null,
       },
     }),
@@ -190,6 +211,7 @@ export const useDragStore = create<DragStore>((set) => ({
         detachedScope: d.detachedScope,
         detachedGroupId: d.detachedGroupId,
         detachedTabKey: d.detachedTabKey,
+        detachedPaneId: d.detachedPaneId,
       },
     }),
   setEmbedCap: (cap) =>
diff --git a/src/stores/fileClipboard.ts b/src/stores/fileClipboard.ts
index 8dd99ec..46d5e9c 100644
--- a/src/stores/fileClipboard.ts
+++ b/src/stores/fileClipboard.ts
@@ -10,14 +10,20 @@ export type ClipboardOp = "copy" | "cut";
 export interface FileClipboardEntry {
   projectDir: string;
   relPath: string;
+  // Absolute source path (matches an open viewer tab's `embedPath`), so a
+  // same-project cut/paste can retarget that tab to the moved file.
+  path: string;
   name: string;
   isDir: boolean;
   op: ClipboardOp;
 }
 
 interface FileClipboardState {
-  entry: FileClipboardEntry | null;
-  setEntry: (entry: FileClipboardEntry) => void;
+  /** The copied/cut files. Empty = clipboard clear; length 1 = a single
+   *  file/folder (keeps the rename-on-paste prompt); length > 1 = a multi
+   *  selection (pasted in bulk, auto-named on collision). */
+  entries: FileClipboardEntry[];
+  setEntries: (entries: FileClipboardEntry[]) => void;
   clear: () => void;
 }
 
@@ -25,7 +31,7 @@ interface FileClipboardState {
  *  module-level store (not per-tree state) so a copy in one folder/tree can be
  *  pasted in another. */
 export const useFileClipboardStore = create<FileClipboardState>((set) => ({
-  entry: null,
-  setEntry: (entry) => set({ entry }),
-  clear: () => set({ entry: null }),
+  entries: [],
+  setEntries: (entries) => set({ entries }),
+  clear: () => set({ entries: [] }),
 }));
diff --git a/src/stores/fileSourcePref.ts b/src/stores/fileSourcePref.ts
new file mode 100644
index 0000000..b8e6fdb
--- /dev/null
+++ b/src/stores/fileSourcePref.ts
@@ -0,0 +1,21 @@
+import { create } from "zustand";
+
+/**
+ * Ephemeral, non-persisted "which side is this remote project's file view
+ * currently showing" preference, keyed by project id. The single source of
+ * truth for the right file tree / Files (Project) tab's Local/Remote switch
+ * (`useFileSource` in `components/files/ProjectFilesPane.tsx`), and read (not
+ * subscribed — a snapshot at open time, not a live sync) by `FileViewerPane` so
+ * a freshly opened subwindow file viewer defaults to the same side the tree is
+ * currently showing, instead of whichever side its own path happened to be on.
+ */
+interface FileSourcePrefStore {
+  byProject: Record<string, "local" | "remote">;
+  set: (projectId: string, source: "local" | "remote") => void;
+}
+
+export const useFileSourcePrefStore = create<FileSourcePrefStore>((set) => ({
+  byProject: {},
+  set: (projectId, source) =>
+    set((s) => ({ byProject: { ...s.byProject, [projectId]: source } })),
+}));
diff --git a/src/stores/fileSources.ts b/src/stores/fileSources.ts
new file mode 100644
index 0000000..c747b5a
--- /dev/null
+++ b/src/stores/fileSources.ts
@@ -0,0 +1,58 @@
+import { create } from "zustand";
+import type { FileSource } from "../components/embed/fileAccess";
+
+/**
+ * Ephemeral, non-persisted map of a viewer tab's resolved file source
+ * (`"remote"` = read straight from the host over SFTP, `"local"` = the paired
+ * local mirror copy, `"none"` = a local project / not applicable), keyed by tab
+ * key. `FileViewerPane` publishes each viewer tab's source here so the tab strip
+ * can render the Remote/Local badge on the tab itself instead of spending a
+ * whole header row on it. Cleared when the viewer unmounts.
+ */
+/**
+ * The Local/Remote switch a viewer tab exposes, mirrored out of `FileViewerPane`
+ * (which owns the `sideOverride` state) so the tab strip's file-source badge can
+ * be a *clickable* toggle — not just a read-only glyph — for a file that exists on
+ * both sides of a remote project. Absent when switching doesn't apply (local
+ * project, or a path with no counterpart on the other side). `remoteDisabled`
+ * means the host has no such file, so the badge must not flip to remote.
+ */
+export interface FileSourceControls {
+  current: "local" | "remote";
+  set: (s: "local" | "remote") => void;
+  remoteDisabled: boolean;
+}
+
+interface FileSourcesStore {
+  byTab: Record<string, FileSource>;
+  controlsByTab: Record<string, FileSourceControls>;
+  setSource: (tabKey: string, source: FileSource) => void;
+  clearSource: (tabKey: string) => void;
+  setControls: (tabKey: string, controls: FileSourceControls) => void;
+  clearControls: (tabKey: string) => void;
+}
+
+export const useFileSourcesStore = create<FileSourcesStore>((set) => ({
+  byTab: {},
+  controlsByTab: {},
+  setSource: (tabKey, source) =>
+    set((s) =>
+      s.byTab[tabKey] === source ? s : { byTab: { ...s.byTab, [tabKey]: source } },
+    ),
+  clearSource: (tabKey) =>
+    set((s) => {
+      if (!(tabKey in s.byTab)) return s;
+      const next = { ...s.byTab };
+      delete next[tabKey];
+      return { byTab: next };
+    }),
+  setControls: (tabKey, controls) =>
+    set((s) => ({ controlsByTab: { ...s.controlsByTab, [tabKey]: controls } })),
+  clearControls: (tabKey) =>
+    set((s) => {
+      if (!(tabKey in s.controlsByTab)) return s;
+      const next = { ...s.controlsByTab };
+      delete next[tabKey];
+      return { byTab: s.byTab, controlsByTab: next };
+    }),
+}));
diff --git a/src/stores/gitDirty.ts b/src/stores/gitDirty.ts
new file mode 100644
index 0000000..59f6ec6
--- /dev/null
+++ b/src/stores/gitDirty.ts
@@ -0,0 +1,104 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "./projects";
+
+/** Highest-priority pending git state for a project, by the user's mental model:
+ *  uncommitted working-tree changes ▸ staged-not-committed ▸ committed-not-pushed
+ *  ▸ clean. Drives the colored dot on each project pill. */
+export type GitDirtyState = "clean" | "unpushed" | "staged" | "dirty";
+
+interface GitStatus {
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  has_remote: boolean;
+  is_repo: boolean;
+}
+
+/** Reduce a `git_status` probe plus the unpushed-commit count to a single dot
+ *  level. Priority mirrors the file-tree markers (red ▸ orange ▸ green):
+ *    "dirty"    – untracked or unstaged working-tree changes (not added) — red
+ *    "staged"   – staged but not committed — orange
+ *    "unpushed" – committed locally but not pushed — green
+ *    "clean"    – nothing pending, or not a git repo (no dot) */
+export function gitDirtyState(status: GitStatus, unpushed: number): GitDirtyState {
+  if (!status.is_repo) return "clean";
+  if (status.untracked > 0 || status.unstaged > 0) return "dirty";
+  if (status.staged > 0) return "staged";
+  if (unpushed > 0) return "unpushed";
+  return "clean";
+}
+
+/** Consecutive probes that found NO `.git` for a project, keyed by id. A single
+ *  `is_repo:false` must never disable git: `setProjectGitDisabled(id, true)` is a
+ *  DESTRUCTIVE, persisted action (deletes `.git`, writes `git_type:"none"`), and a
+ *  transient absence — lockstep/sync rebuilding `.git`, a resolver blip, a dir
+ *  momentarily unreadable — would otherwise persist "none" and could race a
+ *  re-created `.git` into deletion. We require several *consecutive* confirmed
+ *  misses (one poll cycle each) before acting, so only a genuine, sustained `.git`
+ *  removal (e.g. `rm -rf .git` in a terminal) trips it. Module-level, not store
+ *  state, so accumulating a streak never re-renders a pill. */
+const GIT_GONE_STREAK = new Map<string, number>();
+/** ~3 poll cycles (~36s at the 12s switcher poll) of confirmed absence. */
+const GIT_GONE_THRESHOLD = 3;
+
+interface GitDirtyStore {
+  /** Per-project dot level. Absent until first probed (rendered as no dot). */
+  byId: Record<string, GitDirtyState>;
+  /** Apply an already-computed level (used by callers that have the data). */
+  set: (projectId: string, state: GitDirtyState) => void;
+  /** Probe a project's directory and store its dot level. No-ops on empty dir. */
+  refresh: (projectId: string, dir: string) => Promise<void>;
+}
+
+export const useGitDirtyStore = create<GitDirtyStore>((set) => ({
+  byId: {},
+  set: (projectId, state) =>
+    set((s) =>
+      s.byId[projectId] === state ? s : { byId: { ...s.byId, [projectId]: state } },
+    ),
+  refresh: async (projectId, dir) => {
+    if (!dir) return;
+    let next: GitDirtyState = "clean";
+    try {
+      const [status, unpushed] = await Promise.all([
+        invoke<GitStatus>("git_status", { projectDir: dir }),
+        invoke<string[]>("git_unpushed_commits", { projectDir: dir }).catch(
+          () => [] as string[],
+        ),
+      ]);
+      next = gitDirtyState(status, unpushed.length);
+      // `.git` can be deleted outside the app (e.g. `rm -rf .git` in a terminal
+      // tab). Reflect that by flipping the project back to "none" — but only
+      // after several *consecutive* confirmed misses (see GIT_GONE_STREAK): a
+      // single is_repo:false during lockstep/sync `.git` churn must not persist
+      // "none" or race a re-created `.git` into deletion.
+      if (!status.is_repo) {
+        const streak = (GIT_GONE_STREAK.get(projectId) ?? 0) + 1;
+        GIT_GONE_STREAK.set(projectId, streak);
+        const project = useProjectsStore.getState().projects.find((p) => p.id === projectId);
+        if (
+          streak >= GIT_GONE_THRESHOLD &&
+          project &&
+          typeof project.git_type === "string" &&
+          project.git_type !== "none"
+        ) {
+          GIT_GONE_STREAK.delete(projectId);
+          void useProjectsStore.getState().setProjectGitDisabled(projectId, true);
+        }
+      } else {
+        // A repo is present again — clear the streak so a past blip can never
+        // combine with a later one to cross the threshold.
+        GIT_GONE_STREAK.delete(projectId);
+      }
+    } catch {
+      next = "clean";
+      // An errored probe (host down, git spawn failure) proves nothing about the
+      // repo's existence, so it must not count toward disabling git.
+      GIT_GONE_STREAK.delete(projectId);
+    }
+    set((s) =>
+      s.byId[projectId] === next ? s : { byId: { ...s.byId, [projectId]: next } },
+    );
+  },
+}));
diff --git a/src/stores/globalMachineMonitor.ts b/src/stores/globalMachineMonitor.ts
new file mode 100644
index 0000000..89d937c
--- /dev/null
+++ b/src/stores/globalMachineMonitor.ts
@@ -0,0 +1,32 @@
+import { create } from "zustand";
+
+/** The global machine a `GlobalMachineMonitorDialog` samples — enough identity
+ *  to both authenticate ad-hoc (`user`/`host`/`port`) and title the dialog
+ *  (`label`). Mirrors `DroppedGlobalMachine` (`stores/remoteMachines.ts`). */
+export interface GlobalMachineMonitorTarget {
+  id: string;
+  user?: string;
+  host: string;
+  port?: number;
+  label?: string;
+}
+
+/**
+ * Which global machine's full system-monitor dialog is open, if any. A single
+ * `<GlobalMachineMonitorDialogHost>` is mounted once (in AppShell) and reads
+ * this store; the header's Machines menu (`MachinesIndicator`) opens it via
+ * `open(machine)` from a row's "System monitor…" button — the same
+ * mount-once/store-driven pattern `stores/remoteMachines.ts` uses for the
+ * project-scoped Remote machines window.
+ */
+interface GlobalMachineMonitorStore {
+  machine: GlobalMachineMonitorTarget | null;
+  open: (machine: GlobalMachineMonitorTarget) => void;
+  close: () => void;
+}
+
+export const useGlobalMachineMonitorStore = create<GlobalMachineMonitorStore>((set) => ({
+  machine: null,
+  open: (machine) => set({ machine }),
+  close: () => set({ machine: null }),
+}));
diff --git a/src/stores/globalMachines.ts b/src/stores/globalMachines.ts
new file mode 100644
index 0000000..9e2a948
--- /dev/null
+++ b/src/stores/globalMachines.ts
@@ -0,0 +1,572 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+import type { ConnState } from "./remoteStatus";
+import type { GlobalMachine, MachineImportEntry } from "../types";
+import { syncGlobalDisconnected } from "../lib/machineSync";
+import { useHostBusyStore } from "./hostBusy";
+import { withHostKeyConfirm } from "../lib/hostKey";
+import { mayAutoTouch } from "../lib/hpcHost";
+import { useSettingsStore } from "./settings";
+
+/** Per-machine outcome of a bulk import (`importMachines`): whether the shared
+ *  credentials authenticated against that host. The machine is added to the list
+ *  either way — a failed connect just leaves its lamp red to retry, mirroring
+ *  `probeAll`, rather than silently dropping the row. */
+export interface ImportResult {
+  host: string;
+  label?: string;
+  ok: boolean;
+}
+
+/**
+ * Globally connected worker machines — the VPN-tunnel pattern applied to SSH
+ * hosts: authenticated once via the ordinary login mechanism
+ * (`ssh_connect`), with no `remote_path`, so a machine is not tied to any one
+ * project. Later dragged onto a project (`MachinesIndicator`'s rows are the
+ * drag source) to become a `shared_fs` compute host there.
+ *
+ * Unlike `vpnStatus.ts`, there is no backend liveness registry to reconcile
+ * against on focus: `ssh_connect` only *verifies* auth (it warms the shared
+ * OpenSSH ControlMaster opportunistically but does not create/persist one —
+ * see `ssh_common::ssh_base_args`'s `ControlMaster=no`), it doesn't leave a
+ * pooled session running the way a project's `remote_connect` does. So
+ * `status` here is set only by the explicit actions that open or end a session —
+ * `add`/`register`/`connect`/`disconnect` — never polled, and pointedly **not**
+ * by the `probeAll` sweep (see `reachable`).
+ */
+interface GlobalMachinesStore {
+  machines: GlobalMachine[];
+  /** Per-machine id; absent = "off". **"A session this app opened"**, never "the
+   *  host answered" — that is `reachable`. The distinction is load-bearing:
+   *  `lib/machineSync` propagates a machine's `connected` onto the project that
+   *  holds the same host and opens its pool, so a lamp lit by a mere probe would
+   *  claim a session nothing ever opened. Written only by `add`/`register`/
+   *  `connect`/`disconnect`. */
+  status: Record<string, ConnState>;
+  /** Per-machine id: the last `probeAll` answer — "this host was reachable and
+   *  authenticated our credential", which is *not* a session and must never be
+   *  mistaken for one. Absent = never probed. Kept beside `status` rather than
+   *  folded into it so the row can say "up, but not connected" instead of lying
+   *  in either direction. */
+  reachable: Record<string, boolean>;
+  /** Per-machine id: the message from the last failed `connect`/`update`, so a
+   *  red lamp is never just "error" with no way to tell why — an unknown host
+   *  key, a rejected password, a network timeout, and a keychain that couldn't
+   *  be read all fail differently and the backend already says which. Cleared
+   *  on the next successful connect for that machine; left in place across a
+   *  probe (`probeAll` only ever *reads* reachability, it never explains a
+   *  failure) so it survives until the next real attempt. */
+  errors: Record<string, string>;
+  loaded: boolean;
+
+  load: () => Promise<void>;
+  add: (m: {
+    user?: string;
+    host: string;
+    port?: number;
+    label?: string;
+    password?: string;
+    remember?: boolean;
+  }) => Promise<GlobalMachine>;
+  /** Surface an **already-connected** host in the list without re-authenticating
+   *  — the caller (e.g. the HPC wizard) has just run `ssh_connect` itself, so
+   *  this only persists the identity (`global_machine_add`, idempotent by target)
+   *  and marks the lamp connected. The counterpart to `add`, which owns the
+   *  connect. Returns the registered (or pre-existing) machine, or `undefined` on
+   *  a persist failure — registration must never break the flow that connected. */
+  register: (m: {
+    user?: string;
+    host: string;
+    port?: number;
+    label?: string;
+  }) => Promise<GlobalMachine | undefined>;
+  /**
+   * Edit an existing machine's connection identity (`user`/`host`/`port`/`label`)
+   * via `global_machine_update`, then — when `connect` is set — re-authenticate the
+   * (possibly new) target with the given password, updating the lamp. The SSH
+   * password isn't stored on the machine, so a password change is applied only by
+   * that connect: `remember: true` saves it to the keychain, `undefined`/`null`
+   * leaves any existing saved credential untouched. Never pass `false` from an
+   * edit — that would *clear* a saved password the user didn't mean to drop
+   * (`remote_credentials::Remember::Clear`). Throws if the update itself fails
+   * (validation / address collision) so the form can surface it; a failed connect
+   * only reddens the lamp.
+   */
+  update: (
+    id: string,
+    fields: { user?: string; host: string; port?: number; label?: string },
+    opts?: { password?: string; remember?: boolean; connect?: boolean },
+  ) => Promise<void>;
+  /** Remove a machine from the list — **actively disconnecting it first** if it
+   *  is live (see the implementation). Detaching it from any project it was also
+   *  added to is deliberately NOT part of this: a project host is a copy by
+   *  value, with its own path and its own lifetime. */
+  remove: (id: string) => Promise<void>;
+  /** Connect one machine. `background` marks the call as *unattended* (the launch /
+   *  VPN-up sweep) rather than a row the user clicked — the backend's dial policy
+   *  refuses an unattended dial to a host tagged HPC. Omitted = a gesture. */
+  connect: (id: string, password?: string, opts?: { background?: boolean }) => Promise<void>;
+  /** Actively disconnect a machine: **end every running tmux job** on it and
+   *  close any live SSH master, then reset the lamp to "off". This is an
+   *  explicit user action ONLY — persistent tmux sessions are meant to outlive a
+   *  relaunch, and this is the one path that deliberately kills them (the
+   *  backend `remote_kill_all_jobs` never runs on restart). Both backend steps
+   *  are best-effort (a machine with nothing running / no master is a no-op);
+   *  the lamp is cleared regardless. */
+  disconnect: (id: string) => Promise<void>;
+  /** Persist a new machine order given the desired id list — the reorder drag
+   *  computes the live-preview order (drop can land before *or* after any row,
+   *  including past the last one), this commits it. Applies client-side first
+   *  (mirrors `stores::projects`' `reorderProjects`), then persists. There's no
+   *  separate position field: array order in `global_machines.json` *is* the
+   *  order. */
+  reorder: (orderedIds: string[]) => Promise<void>;
+  /** Read-only reachability sweep (`ssh_probe`, no keychain writes) — call when
+   *  the header menu opens, mirroring `VpnIndicator`'s per-config silent check.
+   *  Writes `reachable` (and `errors`) ONLY, never `status`: a probe is not a
+   *  session. Skips HPC-tagged machines — this menu opens on hover and `ssh_probe`
+   *  is a real authenticated login, not a ping. */
+  probeAll: () => Promise<void>;
+  /** Fleet-wide (re)connect: attempt `connect` on every machine not already
+   *  connected/connecting, concurrently, each with any saved credential. A host
+   *  that needs a password we don't hold just reddens its lamp to retry
+   *  individually (no per-host prompt is possible from a bulk action) — mirroring
+   *  `importMachines`. Idempotent for already-connected rows. */
+  retryAll: () => Promise<void>;
+  /** Fleet-wide active disconnect: `disconnect` (end tmux jobs + close master)
+   *  every machine currently connected, concurrently. Off/error rows are skipped.
+   *  Explicit user action only — same contract as the per-row `disconnect`. */
+  disconnectAll: () => Promise<void>;
+  /** Arm/disarm a machine for silent auto-connect on launch / VPN-up. */
+  setAutoConnect: (id: string, enabled: boolean) => Promise<void>;
+  /**
+   * Silently connect every machine armed with `auto_connect` — the launch-time
+   * and VPN-up sweep. Mirrors a project's `autoConnectPrimary`: it **probes
+   * first** (`ssh_probe`, read-only) and only calls `connect` when the host is
+   * reachable, so it never prompts and a machine that can't connect silently
+   * (offline, or a saved password since forgotten) degrades to staying off
+   * rather than turning red or opening a modal at startup. Idempotent: skips a
+   * machine already connected or connecting.
+   */
+  autoConnect: () => Promise<void>;
+  /** Write the given machines (by id, in the passed order) to a shareable JSON
+   *  file at `path`. Thin pass-through to `global_machines_export` — host/port/
+   *  label only, never a username or password (see `commands::global_machines`).
+   *  The path comes from a native save dialog. */
+  exportMachines: (ids: string[], path: string) => Promise<void>;
+  /**
+   * Connect + add a batch of imported machines with **one shared credential**.
+   * For each entry: `ssh_connect` with the shared user/password (an entry may
+   * pin its own `user`, which wins), then `global_machine_add` **regardless** of
+   * whether that connect succeeded — a machine that fails to authenticate is
+   * still registered with a red lamp to retry (mirrors `probeAll`), never
+   * silently dropped. Runs sequentially so the concurrent `global_machine_add`
+   * writes can't race `global_machines.json`. Returns a per-host outcome list.
+   *
+   * `autoConnect` arms every imported row for the launch/VPN-up sweep in the same
+   * pass (`setAutoConnect`), so a bulk import doesn't leave the user ticking the
+   * per-row toggle N times. Arming is safe regardless of how the connect went: the
+   * sweep probes first, so a machine that can't connect silently (no saved
+   * password, host away) just stays dark.
+   */
+  importMachines: (
+    entries: MachineImportEntry[],
+    opts: { user?: string; password?: string; remember?: boolean; autoConnect?: boolean },
+  ) => Promise<ImportResult[]>;
+  setStatus: (id: string, status: ConnState) => void;
+}
+
+export const useGlobalMachinesStore = create<GlobalMachinesStore>((set, get) => ({
+  machines: [],
+  status: {},
+  reachable: {},
+  errors: {},
+  loaded: false,
+
+  load: async () => {
+    // `.catch` only covers a rejection — a command that resolves to nothing must
+    // not leave `machines` non-iterable, since every consumer maps over it.
+    const list = await invoke<GlobalMachine[]>("global_machines_list").catch(() => []);
+    set({ machines: Array.isArray(list) ? list : [], loaded: true });
+  },
+
+  add: async ({ user, host, port, label, password, remember }) => {
+    // First contact: show the host key's fingerprint before the password is sent.
+    await withHostKeyConfirm(() =>
+      invoke("ssh_connect", {
+        user,
+        host,
+        port,
+        password,
+        // Adding a machine is a form the user filled in and submitted. Without
+        // this the dial policy's background default refuses it outright on a host
+        // they tagged HPC — i.e. a tagged cluster could not be added at all.
+        background: false,
+        // Only `true` (save) or `null` (leave alone) — the same rule `update` states
+        // at length. A raw `false` is `Remember::Clear`, which DELETES the keychain
+        // entry, and this call has just authenticated with it: an unticked box on an
+        // ordinary add would destroy a password saved by an earlier one. Only an
+        // explicit forget may clear a credential.
+        remember: remember ? true : null,
+      }),
+    );
+    const machine = await invoke<GlobalMachine>("global_machine_add", { user, host, port, label });
+    // The lamp is the propagation trigger: `lib/machineSync`'s subscription reflects
+    // this onto any project that already holds the host. Nothing is called by hand
+    // here — that is exactly how `register` and the probe sweep ended up propagating
+    // nothing at all.
+    set((s) => ({
+      machines: [...s.machines, machine],
+      status: { ...s.status, [machine.id]: "connected" },
+    }));
+    return machine;
+  },
+
+  register: async ({ user, host, port, label }) => {
+    // No `ssh_connect` here — the caller already authenticated this host. Persist
+    // is idempotent by target (backend `global_machine_add`), so a repeat call for
+    // the same host returns the existing row; reconcile it into the list either
+    // way and light the lamp.
+    const machine = await invoke<GlobalMachine>("global_machine_add", { user, host, port, label }).catch(
+      () => null,
+    );
+    if (!machine) return undefined;
+    set((s) => ({
+      machines: s.machines.some((m) => m.id === machine.id) ? s.machines : [...s.machines, machine],
+      status: { ...s.status, [machine.id]: "connected" },
+    }));
+    return machine;
+  },
+
+  update: async (id, { user, host, port, label }, opts) => {
+    // Let a failed update (validation / collision) propagate so the form shows it.
+    const list = await invoke<GlobalMachine[]>("global_machine_update", {
+      id,
+      user,
+      host,
+      port,
+      label,
+    });
+    set({ machines: list });
+    if (!opts?.connect) return;
+    set((s) => ({ status: { ...s.status, [id]: "connecting" } }));
+    try {
+      await withHostKeyConfirm(() =>
+        invoke("ssh_connect", {
+          user,
+          host,
+          port,
+          password: opts.password || null,
+          // Only `true` (save) or `null` (leave) — never `false`, which would clear
+          // a credential the edit didn't intend to drop.
+          remember: opts.remember ? true : null,
+          // An edit-and-reconnect is a gesture, same as `add` above.
+          background: false,
+        }),
+      );
+      set((s) => {
+        const errors = { ...s.errors };
+        delete errors[id];
+        return { status: { ...s.status, [id]: "connected" }, errors };
+      });
+    } catch (e) {
+      set((s) => ({ status: { ...s.status, [id]: "error" }, errors: { ...s.errors, [id]: String(e) } }));
+    }
+  },
+
+  remove: async (id) => {
+    // Removing a machine ENDS it. Dropping the row while its SSH master (and any
+    // tmux job under it) stayed up would leave a live connection nothing in the
+    // UI still points at — unkillable, since the only handle on it was the row
+    // being deleted. So a live machine gets the same active disconnect its own
+    // ⏻ performs, and for the same reason its confirm names the jobs it kills.
+    // Gated on the lamp: an `off`/`error` row has no session, and
+    // `remote_kill_all_jobs` on it would dial the host just to find nothing.
+    const live = get().status[id];
+    if (live === "connected" || live === "connecting") await get().disconnect(id);
+    const list = await invoke<GlobalMachine[]>("global_machine_remove", { id }).catch(() => null);
+    if (!list) return;
+    set((s) => {
+      const status = { ...s.status };
+      delete status[id];
+      const reachable = { ...s.reachable };
+      delete reachable[id];
+      const errors = { ...s.errors };
+      delete errors[id];
+      return { machines: list, status, reachable, errors };
+    });
+  },
+
+  connect: async (id, password, opts) => {
+    const m = get().machines.find((x) => x.id === id);
+    if (!m) return;
+    set((s) => ({ status: { ...s.status, [id]: "connecting" } }));
+    try {
+      await withHostKeyConfirm(() =>
+        invoke("ssh_connect", {
+          user: m.user,
+          host: m.host,
+          port: m.port,
+          password,
+          remember: null,
+          // A credential-less `ssh_connect` is ambiguous to the backend's dial policy
+          // — it is either a row the user clicked or the launch sweep — so this path
+          // has to say which. It defaults to the gesture, because that is the only
+          // caller a tagged HPC machine has left: the sweep passes `background` and
+          // is refused, by design, on both sides.
+          background: opts?.background === true,
+        }),
+      );
+      set((s) => {
+        const errors = { ...s.errors };
+        delete errors[id];
+        // Propagation onto a project holding this host rides the lamp itself
+        // (`lib/machineSync`'s subscription), not a call from here.
+        return { status: { ...s.status, [id]: "connected" }, errors };
+      });
+    } catch (e) {
+      set((s) => ({ status: { ...s.status, [id]: "error" }, errors: { ...s.errors, [id]: String(e) } }));
+    }
+  },
+
+  disconnect: async (id) => {
+    const m = get().machines.find((x) => x.id === id);
+    if (!m) return;
+    // Clear the lamp first — the kill + master-close are best-effort and must
+    // not leave the row stuck on "connected" if the host is momentarily away.
+    set((s) => ({ status: { ...s.status, [id]: "off" } }));
+    // Mirror onto any project holding this host: tear the active project's pool
+    // and drop every matching lamp before the machine's own teardown runs.
+    syncGlobalDisconnected(m);
+    // This is the one path that deliberately ENDS every tmux session on the host,
+    // so the cached busy reading is now a lie. Drop it, or the lamp would keep
+    // pulsing for work this very call killed (the reading is only re-probed when
+    // a menu opens, so nothing else would correct it).
+    useHostBusyStore.getState().clear(m);
+    const target = { user: m.user, host: m.host, port: m.port };
+    await invoke("remote_kill_all_jobs", target).catch(() => {});
+    await invoke("ssh_close_master", target).catch(() => {});
+  },
+
+  reorder: async (orderedIds) => {
+    const before = get().machines;
+    const byId = new Map(before.map((m) => [m.id, m]));
+    const reordered = orderedIds.map((id) => byId.get(id)).filter(Boolean) as GlobalMachine[];
+    // Guard against a stale/partial id list: only commit a full permutation.
+    if (reordered.length !== before.length) return;
+    if (reordered.every((m, i) => m.id === before[i].id)) return; // no-op drop
+    set({ machines: reordered });
+    const list = await invoke<GlobalMachine[]>("global_machine_reorder", {
+      ids: orderedIds,
+    }).catch(() => null);
+    if (list) set({ machines: list });
+  },
+
+  probeAll: async () => {
+    // Never sweep a tagged cluster. This menu opens on *hover*, and `ssh_probe` is
+    // a real authenticated login rather than a ping — a fleet sweep that includes a
+    // login node dials it every time the pointer crosses the header, which is the
+    // unattended presence the tag exists to stop. Fail-closed while settings load.
+    const settings = useSettingsStore.getState().settings;
+    const machines = get().machines.filter((m) =>
+      mayAutoTouch(settings, { user: m.user, host: m.host, port: m.port }),
+    );
+    const results = await Promise.all(
+      machines.map((m) =>
+        invoke<{ ok: boolean; error: string }>("ssh_probe", { user: m.user, host: m.host, port: m.port })
+          .then((r) => [m.id, r.ok, r.error] as const)
+          .catch((e) => [m.id, false, String(e)] as const),
+      ),
+    );
+    // The sweep writes `reachable`, NEVER `status`. A probe says the host answered;
+    // `status` says this app holds a session on it, and `lib/machineSync` acts on
+    // the second — opening the pool of a project that holds the same host. Folding
+    // the first into the second is what lit a machine green off a hover while every
+    // project holding it stayed unconnected, with nothing to propagate.
+    //
+    // Same idempotence rule as `setStatus`: a sweep that finds everything as it
+    // already was is a no-op and must not notify. This one is the more valuable of
+    // the two — it writes EVERY machine at once, so on a fleet of N an unchanged
+    // sweep used to invalidate the whole list.
+    set((s) => {
+      const nextReachable = Object.fromEntries(results.map(([id, ok]) => [id, ok]));
+      const changed = Object.entries(nextReachable).some(([id, ok]) => s.reachable[id] !== ok);
+      // `ssh_probe` already carries the reason a re-auth failed (bad password,
+      // unreachable network, refused prompt…) — capture it the same way `connect`
+      // does, so a menu-open sweep explains a red lamp exactly as well as a manual
+      // retry would, instead of throwing that text away.
+      const errors = { ...s.errors };
+      let changedErrors = false;
+      for (const [id, ok, err] of results) {
+        if (ok) {
+          if (errors[id] !== undefined) {
+            delete errors[id];
+            changedErrors = true;
+          }
+        } else if (err && errors[id] !== err) {
+          errors[id] = err;
+          changedErrors = true;
+        }
+      }
+      if (!changed && !changedErrors) return s;
+      return { reachable: changed ? { ...s.reachable, ...nextReachable } : s.reachable, errors };
+    });
+  },
+
+  retryAll: async () => {
+    const { machines, status, connect } = get();
+    // "Retry everything" is a gesture at the fleet, not at any one login node: a
+    // tagged cluster is left out and stays connectable from its own row's button,
+    // which IS a gesture at it.
+    const settings = useSettingsStore.getState().settings;
+    await Promise.all(
+      machines.map((m) => {
+        if (!mayAutoTouch(settings, { user: m.user, host: m.host, port: m.port }))
+          return Promise.resolve();
+        const st = status[m.id] ?? "off";
+        if (st === "connected" || st === "connecting") return Promise.resolve();
+        return connect(m.id);
+      }),
+    );
+  },
+
+  disconnectAll: async () => {
+    const { machines, status, disconnect } = get();
+    await Promise.all(
+      machines.map((m) =>
+        (status[m.id] ?? "off") === "connected" ? disconnect(m.id) : Promise.resolve(),
+      ),
+    );
+  },
+
+  setAutoConnect: async (id, enabled) => {
+    try {
+      const list = await invoke<GlobalMachine[]>("global_machine_set_auto_connect", {
+        id,
+        enabled,
+      });
+      set({ machines: list });
+    } catch (e) {
+      // A swallowed persist failure is worse here than elsewhere: the toggle springs
+      // back on the next render with nothing said, so the user believes a machine is
+      // armed for launch when it isn't. Same `errors` map a failed connect writes, so
+      // the row already has somewhere to show it.
+      set((s) => ({ errors: { ...s.errors, [id]: `auto-connect not saved: ${String(e)}` } }));
+    }
+  },
+
+  autoConnect: async () => {
+    // A machine tagged HPC is never in the launch/VPN-up sweep, whatever its own
+    // auto-connect toggle says (the toggle is disabled for one, but an older
+    // settings file can carry both). An SSH master opened on a shared login node
+    // because an app started is exactly the unattended presence the tag exists to
+    // stop; connecting by hand is untouched. `mayAutoTouch` is the shared authority
+    // for that question, and it also fails closed while settings are still loading —
+    // the exact window this launch sweep runs in.
+    const settings = useSettingsStore.getState().settings;
+    const machines = get()
+      .machines.filter((m) => m.auto_connect)
+      .filter((m) => mayAutoTouch(settings, { user: m.user, host: m.host, port: m.port }));
+    await Promise.all(
+      machines.map(async (m) => {
+        const st = get().status[m.id] ?? "off";
+        if (st === "connected" || st === "connecting") return;
+        // Probe is the silent-connect gate: an `ok` probe means `ssh_connect` will
+        // succeed with no prompt (key/agent/saved-password). On anything else leave
+        // the lamp untouched — a stale opt-in must stay dark, never flash red or ask.
+        const reachable = await invoke<{ ok: boolean }>("ssh_probe", {
+          user: m.user,
+          host: m.host,
+          port: m.port,
+          background: true,
+        })
+          .then((r) => r.ok)
+          .catch(() => false);
+        if (!reachable) return;
+        await get().connect(m.id, undefined, { background: true });
+      }),
+    );
+  },
+
+  exportMachines: async (ids, path) => {
+    await invoke("global_machines_export", { ids, path });
+  },
+
+  importMachines: async (entries, { user, password, remember, autoConnect }) => {
+    const results: ImportResult[] = [];
+    // Sequential on purpose: each `global_machine_add` rewrites the whole
+    // `global_machines.json`, so parallel adds would clobber each other's writes.
+    for (const entry of entries) {
+      const effUser = entry.user || user || undefined;
+      let ok = true;
+      try {
+        // Deliberately NOT wrapped in `withHostKeyConfirm`: this is a bulk loop, and
+        // one fingerprint modal per imported machine would be a wall of prompts. An
+        // unknown host simply fails here and lands as a red row, whose Connect button
+        // asks the question once, for the one machine the user actually wants.
+        await invoke("ssh_connect", {
+          user: effUser,
+          host: entry.host,
+          port: entry.port,
+          password: password || null,
+          // The user picked a file and pressed Import — a gesture, even though it is
+          // a bulk one, so a tagged host in the file is still importable by hand.
+          background: false,
+          // `true` or `null`, never the raw flag: an unticked "Save password" on an
+          // import used to arrive as `false` = `Remember::Clear` and DELETE whatever
+          // was already saved for each host it walked — with the credential it had
+          // just authenticated with. Only an explicit forget clears one.
+          remember: remember ? true : null,
+        });
+      } catch {
+        ok = false;
+      }
+      // Add even on a failed connect — the row stays with a red lamp to retry.
+      const machine = await invoke<GlobalMachine>("global_machine_add", {
+        user: effUser,
+        host: entry.host,
+        port: entry.port,
+        label: entry.label,
+      }).catch(() => null);
+      if (machine) {
+        set((s) => {
+          const exists = s.machines.some((m) => m.id === machine.id);
+          return {
+            machines: exists
+              ? s.machines.map((m) => (m.id === machine.id ? machine : m))
+              : [...s.machines, machine],
+            status: { ...s.status, [machine.id]: ok ? "connected" : "error" },
+          };
+        });
+        // Arm the launch/VPN-up sweep in the same pass. Only ever *enables* —
+        // a re-import of a host already in the list must not silently disarm a
+        // toggle the user set by hand. Never on a tagged cluster: both by-hand add
+        // paths already refuse to arm one, and a bulk import must not be the hole
+        // that writes the flag the sweep then has to filter back out.
+        if (
+          autoConnect &&
+          mayAutoTouch(useSettingsStore.getState().settings, {
+            user: effUser,
+            host: entry.host,
+            port: entry.port,
+          })
+        )
+          await get().setAutoConnect(machine.id, true);
+      }
+      results.push({ host: entry.host, label: entry.label, ok });
+    }
+    return results;
+  },
+
+  // Writing a lamp the value it already has must NOT notify. Rebuilding
+  // `status` unconditionally allocated a new object every call, and zustand
+  // notifies on identity — so a no-op write woke every subscriber of this store.
+  // `MachinesIndicator` alone holds fourteen selectors against it, so one no-op
+  // re-ran all fourteen and re-rendered the header, which re-rendered the pills,
+  // the file panel and the tree beneath them. Measured: 64 `status` writes per
+  // 10 s driving ~140 full commits per 10 s on an idle app, with the main thread
+  // stalling ~300-400 ms in every window. Returning `s` unchanged makes zustand's
+  // `Object.is` check collapse the write into nothing.
+  setStatus: (id, status) =>
+    set((s) => (s.status[id] === status ? s : { status: { ...s.status, [id]: status } })),
+}));
diff --git a/src/stores/hints.ts b/src/stores/hints.ts
new file mode 100644
index 0000000..8380a92
--- /dev/null
+++ b/src/stores/hints.ts
@@ -0,0 +1,61 @@
+import { create } from "zustand";
+import { useSettingsStore } from "./settings";
+import type { HintId } from "../lib/hints";
+
+/**
+ * Live state for the contextual hint engine. The catalog (`HINTS`) and selection
+ * logic live in `src/lib/hints.ts` (pure); this store only holds the *currently
+ * shown* hint plus thin actions that persist the seen-set and master toggle
+ * through `useSettingsStore` — the single writer of `settings.json`. Mirrors the
+ * session-only pattern of `vpnPrompt.ts`/`drag.ts`, except dismissals persist.
+ *
+ * Mounted only by `AppShell` (not the detached-window `DetachedApp` branch), so
+ * hints never appear in popped-out subwindows.
+ */
+interface HintsStore {
+  /** The hint currently on screen, or null when nothing is shown. */
+  active: HintId | null;
+  show: (id: HintId) => void;
+  /** Dismiss the active hint (× / Esc): mark it seen and clear it. */
+  dismiss: (id: HintId) => void;
+  /** Mark a hint seen because the user performed its action elsewhere. Clears it
+   *  if it happened to be on screen. Safe to call for an already-seen hint. */
+  markSeen: (id: HintId) => void;
+  /** Turn the whole hint system off (the "Don't show hints" affordance). */
+  disableAll: () => void;
+  /** Settings → clear the seen-set and re-enable, so hints replay. */
+  reset: () => void;
+}
+
+function persistSeen(id: HintId) {
+  const settings = useSettingsStore.getState().settings;
+  const prev = Array.isArray(settings?.hints_seen) ? (settings!.hints_seen as string[]) : [];
+  if (prev.includes(id)) return;
+  void useSettingsStore.getState().updateSettings({ hints_seen: [...prev, id] });
+}
+
+export const useHintsStore = create<HintsStore>((set, get) => ({
+  active: null,
+
+  show: (id) => set({ active: id }),
+
+  dismiss: (id) => {
+    persistSeen(id);
+    if (get().active === id) set({ active: null });
+  },
+
+  markSeen: (id) => {
+    persistSeen(id);
+    if (get().active === id) set({ active: null });
+  },
+
+  disableAll: () => {
+    void useSettingsStore.getState().updateSettings({ hints_enabled: false });
+    set({ active: null });
+  },
+
+  reset: () => {
+    void useSettingsStore.getState().updateSettings({ hints_seen: [], hints_enabled: true });
+    set({ active: null });
+  },
+}));
diff --git a/src/stores/hostBusy.ts b/src/stores/hostBusy.ts
new file mode 100644
index 0000000..e622f13
--- /dev/null
+++ b/src/stores/hostBusy.ts
@@ -0,0 +1,172 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+import { targetKey, type Target } from "../lib/machineSync";
+import { mayAutoTouch } from "../lib/hpcHost";
+import { useSettingsStore } from "./settings";
+import { PRIMARY_HOST } from "./remoteStatus";
+
+/**
+ * Which hosts are **actually being worked on**, as opposed to merely connected.
+ *
+ * A green `ConnLamp` says only that a host authenticates — with a fleet of
+ * machines held open all day (one pooled ControlMaster apiece, kept alive by
+ * `ServerAliveInterval` and nothing else) that is the *steady* state, so it can
+ * no longer answer "where am I running something?". The busy reading answers
+ * that, and the lamp pulses green for it.
+ *
+ * **Busy = the host has ≥1 live tmux session.** That is the right signal
+ * precisely because of the tmux contract (TODO #85): a run is decoupled from the
+ * ssh channel that started it, so a session outliving its tab, an Eldrun
+ * relaunch, or a VPN drop is exactly the work that would otherwise be invisible.
+ * A *detached* session counts — a training run nobody is watching is still a
+ * training run. A foreign session (one Eldrun never started) counts too: the
+ * question is what the machine is doing, not what Eldrun launched.
+ *
+ * **Keyed by SSH target, never by id.** A global machine (`stores/globalMachines`)
+ * and the project host it also is (a primary `remote` or a `compute_hosts`
+ * worker) are copies by value with different ids — `lib/machineSync` already
+ * establishes that `user@host:port` is the only bridge between them. Keying on
+ * `targetKey` means one probe of a machine lights it in the header, on every
+ * project pill that holds it, and in the Remote-machines hub, with no second
+ * round trip and no chance of the three disagreeing.
+ *
+ * **Probed on demand only — never polled.** Each probe is one SSH round trip per
+ * host, and a fleet of sixteen would otherwise mean sixteen `tmux ls`es a minute
+ * forever, for a reading nobody is looking at. So a surface that *shows* the
+ * pulse sweeps when it opens (`MachinesIndicator`'s menu, `RemoteMachinesWindow`)
+ * and the always-visible pill lamps render the **cached** result of whichever
+ * sweep last ran. The cache is therefore a last-known reading, not live truth —
+ * which is why `staleAfterMs` exists and why a disconnect clears it: a lamp
+ * pulsing for a machine that finished an hour ago is worse than one not pulsing.
+ */
+
+/** How long a reading stays trustworthy enough to pulse a lamp nobody re-probed.
+ *  Past this, the cached count is ignored (the lamp goes back to steady green)
+ *  rather than shown as current. Ten minutes matches `ControlPersist`. */
+const STALE_AFTER_MS = 10 * 60 * 1000;
+
+interface Reading {
+  /** Number of live tmux sessions on the host at `at`. */
+  sessions: number;
+  /** Session names, for the lamp's tooltip. */
+  names: string[];
+  /** `Date.now()` of the probe. */
+  at: number;
+}
+
+interface HostBusyStore {
+  /** `targetKey(target)` → last reading. */
+  readings: Record<string, Reading>;
+  /** Targets with a probe in flight, so a re-open can't stack round trips. */
+  inFlight: Record<string, true>;
+
+  /** Probe one **global machine** (no project → ad-hoc auth). Skipped entirely on
+   *  an HPC-tagged host — see the implementation. */
+  probeGlobal: (target: Target) => Promise<void>;
+  /** Probe one **project host**, riding that project's pooled ControlMaster. */
+  probeProjectHost: (projectId: string, hostId: string, target: Target) => Promise<void>;
+  /** Forget a host's reading — call on an explicit disconnect, whose whole point
+   *  is that it ended every session. Leaving the stale count would keep the lamp
+   *  pulsing for work that was just killed. */
+  clear: (target: Target) => void;
+}
+
+/** Fold a probe result into the store, or drop the in-flight mark on failure.
+ *  A failed probe deliberately leaves any previous reading alone: an unreachable
+ *  host is an SSH-status problem, and the *connection* lamp already says so. */
+function commit(
+  set: (fn: (s: HostBusyStore) => Partial<HostBusyStore>) => void,
+  key: string,
+  names: string[] | null,
+) {
+  set((s) => {
+    const inFlight = { ...s.inFlight };
+    delete inFlight[key];
+    if (!names) return { inFlight };
+    return {
+      inFlight,
+      readings: { ...s.readings, [key]: { sessions: names.length, names, at: Date.now() } },
+    };
+  });
+}
+
+interface TmuxSessionRow {
+  name: string;
+  windows: number;
+  created: number;
+  attached: boolean;
+}
+
+export const useHostBusyStore = create<HostBusyStore>((set, get) => ({
+  readings: {},
+  inFlight: {},
+
+  probeGlobal: async (target) => {
+    // Not on a tagged cluster. Unlike `probeProjectHost`, which rides a pool the
+    // user opened, this authenticates ad-hoc — and its caller is a sweep over the
+    // whole machine list run from a menu that opens on *hover*. A `tmux ls` is
+    // cheap; an unasked-for login on a shared login node, every time the pointer
+    // crosses the header, is not. The cost is that a tagged machine never pulses;
+    // the Sessions view is where its running work is read instead.
+    if (!mayAutoTouch(useSettingsStore.getState().settings, target)) return;
+    const key = targetKey(target);
+    if (get().inFlight[key]) return;
+    set((s) => ({ inFlight: { ...s.inFlight, [key]: true } }));
+    const rows = await invoke<TmuxSessionRow[]>("global_machine_tmux_list", {
+      user: target.user,
+      host: target.host,
+      port: target.port,
+    }).catch(() => null);
+    commit(set, key, rows ? rows.map((r) => r.name) : null);
+  },
+
+  probeProjectHost: async (projectId, hostId, target) => {
+    const key = targetKey(target);
+    if (get().inFlight[key]) return;
+    set((s) => ({ inFlight: { ...s.inFlight, [key]: true } }));
+    const rows = await invoke<TmuxSessionRow[]>("remote_tmux_list", {
+      projectId,
+      hostId: hostId === PRIMARY_HOST ? null : hostId,
+    }).catch(() => null);
+    commit(set, key, rows ? rows.map((r) => r.name) : null);
+  },
+
+  clear: (target) => {
+    const key = targetKey(target);
+    set((s) => {
+      const readings = { ...s.readings };
+      delete readings[key];
+      return { readings };
+    });
+  },
+}));
+
+/** The live reading for a target, or `null` when there is none or it has gone
+ *  stale. Read this rather than `readings[key]` directly — the staleness gate is
+ *  what stops a lamp pulsing for a run that ended while nobody looked. */
+export function busyReading(
+  state: Pick<HostBusyStore, "readings">,
+  target: Target | undefined,
+  staleAfterMs = STALE_AFTER_MS,
+): Reading | null {
+  if (!target?.host) return null;
+  const r = state.readings[targetKey(target)];
+  if (!r || r.sessions === 0) return null;
+  return Date.now() - r.at > staleAfterMs ? null : r;
+}
+
+/** Whether a host should pulse. A host that isn't `connected` never pulses: the
+ *  reading is by definition from before it dropped. */
+export function isBusy(
+  state: Pick<HostBusyStore, "readings">,
+  target: Target | undefined,
+  connected: boolean,
+): boolean {
+  return connected && busyReading(state, target) !== null;
+}
+
+/** The lamp tooltip for a busy host — "2 sessions running: build, train". */
+export function busyLabel(reading: Reading): string {
+  const n = reading.sessions;
+  return `${n} session${n === 1 ? "" : "s"} running: ${reading.names.join(", ")}`;
+}
diff --git a/src/stores/hostKeyPrompt.ts b/src/stores/hostKeyPrompt.ts
new file mode 100644
index 0000000..37c8798
--- /dev/null
+++ b/src/stores/hostKeyPrompt.ts
@@ -0,0 +1,124 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * Mediates the first-contact host-key confirmation.
+ *
+ * The backend refuses to send a password to a host whose SSH key has never been
+ * accepted on this machine (`ssh_common::guard_first_contact`) — `accept-new`
+ * silently trusts a first key, which is the ordinary TOFU bargain for key auth
+ * but not for a secret. This store is the other half: it fetches the keys the
+ * host is offering and shows their fingerprints so the user can decide, and only
+ * on a yes does it write them to `~/.ssh/known_hosts` (which is what clears the
+ * gate — there is no separate "confirmed" state to keep in step).
+ *
+ * Like `vpnPrompt`, the store owns the whole lifecycle so a failed scan surfaces
+ * *in the modal* rather than as a silent nothing, and `request()` resolves with
+ * the user's answer instead of throwing.
+ */
+
+/** One key the host offered, as `ssh-keygen -l` reports it. */
+export interface HostKeyFingerprint {
+  keyType: string;
+  fingerprint: string;
+  bits: number;
+}
+
+interface HostKeyPreview {
+  target: string;
+  known: boolean;
+  keys: HostKeyFingerprint[];
+  /** Opaque known_hosts text; handed back verbatim so what is stored is what was
+   *  shown. Never re-scanned at accept time. */
+  scan: string;
+}
+
+interface PendingPrompt {
+  /** `host:port` as the backend resolved it (after `~/.ssh/config`), so the modal
+   *  names the machine the key belongs to and not the alias that was typed. */
+  target: string;
+  /** Resolved with `true` once the key is trusted, `false` on cancel. Never
+   *  rejects: the caller's fallback is simply "don't connect". */
+  resolve: (trusted: boolean) => void;
+}
+
+type Status = "loading" | "ready" | "trusting" | "error";
+
+interface HostKeyPromptState {
+  pending: PendingPrompt | null;
+  status: Status;
+  error: string;
+  keys: HostKeyFingerprint[];
+  scan: string;
+  /** Open the confirmation for `target` (`host` or `host:port`). Resolves `true`
+   *  when the user accepted the key, `false` otherwise. */
+  request: (target: string) => Promise<boolean>;
+  /** Write the shown keys to known_hosts and resolve the caller with `true`. */
+  accept: () => Promise<void>;
+  /** Dismiss without trusting; the caller's connect stays failed. */
+  cancel: () => void;
+}
+
+/** Split `host:port` / bare `host` into what the preview command wants. */
+function splitTarget(target: string): { host: string; port: number | null } {
+  const at = target.lastIndexOf(":");
+  if (at <= 0) return { host: target, port: null };
+  const port = Number(target.slice(at + 1));
+  if (!Number.isInteger(port) || port <= 0) return { host: target, port: null };
+  return { host: target.slice(0, at), port };
+}
+
+export const useHostKeyPromptStore = create<HostKeyPromptState>((set, get) => ({
+  pending: null,
+  status: "loading",
+  error: "",
+  keys: [],
+  scan: "",
+  request: (target) =>
+    new Promise<boolean>((resolve) => {
+      // A prompt already open is answered "no" before being replaced — its caller
+      // must not be left hanging on a modal that is no longer on screen.
+      get().pending?.resolve(false);
+      set({ pending: { target, resolve }, status: "loading", error: "", keys: [], scan: "" });
+      const { host, port } = splitTarget(target);
+      void invoke<HostKeyPreview>("ssh_host_key_preview", { host, port })
+        .then((preview) => {
+          if (get().pending?.resolve !== resolve) return; // superseded
+          // Already known — the gate was cleared while we were asking (another
+          // connect accepted it). Nothing to confirm; let the caller retry.
+          if (preview.known) {
+            set({ pending: null, status: "ready", keys: [], scan: "" });
+            resolve(true);
+            return;
+          }
+          set({ status: "ready", keys: preview.keys, scan: preview.scan });
+        })
+        .catch((e) => {
+          if (get().pending?.resolve !== resolve) return;
+          // Can't show a fingerprint ⇒ can't ask the question. The modal says so
+          // and offers only Cancel: there is nothing here to accept.
+          set({ status: "error", error: String(e), keys: [], scan: "" });
+        });
+    }),
+  accept: async () => {
+    const p = get().pending;
+    const scan = get().scan;
+    if (!p || !scan || get().status === "trusting") return;
+    set({ status: "trusting", error: "" });
+    try {
+      await invoke("ssh_trust_host_key", { scan });
+      if (get().pending !== p) return;
+      set({ pending: null, status: "ready", error: "", keys: [], scan: "" });
+      p.resolve(true);
+    } catch (e) {
+      if (get().pending !== p) return;
+      set({ status: "error", error: String(e) });
+    }
+  },
+  cancel: () => {
+    const p = get().pending;
+    if (!p) return;
+    set({ pending: null, status: "ready", error: "", keys: [], scan: "" });
+    p.resolve(false);
+  },
+}));
diff --git a/src/stores/hpcGuardPrompt.ts b/src/stores/hpcGuardPrompt.ts
new file mode 100644
index 0000000..c99c77a
--- /dev/null
+++ b/src/stores/hpcGuardPrompt.ts
@@ -0,0 +1,66 @@
+import { create } from "zustand";
+
+/**
+ * Mediates the HPC tag's confirmation dialog.
+ *
+ * A machine tagged HPC (`lib/hpcHost.ts`) has its background work switched off
+ * outright — sync loops, lockstep polling, auto-connect, full stats. Two things
+ * can't be settled that way, because the user sometimes genuinely wants them: a
+ * disk-usage scan of the cluster tree, and running a command in a login-node
+ * shell. Those are *asked about* instead, once per act, here.
+ *
+ * The store owns the whole lifecycle so a caller only awaits an answer
+ * (`request()` resolves, never rejects) — the same bargain `hostKeyPrompt` and
+ * `vpnPrompt` strike. Nothing is remembered between prompts: a tag that could be
+ * worn down by clicking through once would not be a gate, and each of these is a
+ * specific act rather than a policy.
+ */
+
+/** What is being asked about. Mirrors the slugs `services::hpc_mode`'s refusals
+ *  carry (`du-scan`, `census`), plus the two the frontend raises on its own. */
+export type HpcGuardKind = "du-scan" | "census" | "login-node-run";
+
+interface Pending {
+  kind: HpcGuardKind;
+  /** `user@host:port`, as the tag is keyed — the dialog names the machine. */
+  target: string;
+  resolve: (proceed: boolean) => void;
+}
+
+interface HpcGuardState {
+  pending: Pending | null;
+  /** Ask about `kind` on `target`. Resolves `true` only if the user chose to go
+   *  ahead anyway, `false` on cancel. */
+  request: (kind: HpcGuardKind, target: string) => Promise<boolean>;
+  /** Go ahead regardless — the user's call to make. */
+  proceed: () => void;
+  /** Back out; nothing runs. */
+  cancel: () => void;
+}
+
+export const useHpcGuardStore = create<HpcGuardState>((set, get) => ({
+  pending: null,
+
+  request: (kind, target) =>
+    new Promise<boolean>((resolve) => {
+      // A second ask while one is open answers the newcomer "no" rather than
+      // stacking modals or silently replacing the question being read.
+      if (get().pending) {
+        resolve(false);
+        return;
+      }
+      set({ pending: { kind, target, resolve } });
+    }),
+
+  proceed: () => {
+    const p = get().pending;
+    set({ pending: null });
+    p?.resolve(true);
+  },
+
+  cancel: () => {
+    const p = get().pending;
+    set({ pending: null });
+    p?.resolve(false);
+  },
+}));
diff --git a/src/stores/hpcJobs.ts b/src/stores/hpcJobs.ts
new file mode 100644
index 0000000..4773491
--- /dev/null
+++ b/src/stores/hpcJobs.ts
@@ -0,0 +1,52 @@
+import { create } from "zustand";
+
+/**
+ * The jobs this Eldrun session submitted, per project — so the Jobs view can show
+ * a freshly-submitted job (and re-open its log) *before* the next `squeue` poll
+ * catches up, and can resolve a job id back to the output file it should tail.
+ *
+ * `squeue` on the host is the source of truth for what is actually queued/running
+ * (`slurm_queue`); this store is only the small local memory of "what did *I* just
+ * launch, and where does its log live". It is purely in-memory: a relaunch forgets
+ * it, and the next `squeue` poll re-lists whatever is still real. No persistence —
+ * the out-file paths are re-derivable from `scontrol` and a stale path helps nobody.
+ */
+export interface HpcJob {
+  jobId: string;
+  name: string;
+  /** Absolute path to the job's stdout on the host — what a Watch tab tails. */
+  outFile: string;
+  /** Host id the job runs on (`"primary"` or a worker id). */
+  host: string;
+  /** Submit time, ms since epoch (local clock — display only). */
+  submittedAt: number;
+}
+
+interface HpcJobsStore {
+  /** projectId → jobs submitted this session, newest first. */
+  byProject: Record<string, HpcJob[]>;
+  /** Record a just-submitted job (deduped by jobId+host, newest kept). */
+  add: (projectId: string, job: HpcJob) => void;
+  /** Forget a job (e.g. after a successful cancel). */
+  remove: (projectId: string, jobId: string, host: string) => void;
+}
+
+export const useHpcJobsStore = create<HpcJobsStore>((set) => ({
+  byProject: {},
+  add: (projectId, job) =>
+    set((s) => {
+      const prev = s.byProject[projectId] ?? [];
+      const deduped = prev.filter((j) => !(j.jobId === job.jobId && j.host === job.host));
+      return { byProject: { ...s.byProject, [projectId]: [job, ...deduped] } };
+    }),
+  remove: (projectId, jobId, host) =>
+    set((s) => {
+      const prev = s.byProject[projectId] ?? [];
+      return {
+        byProject: {
+          ...s.byProject,
+          [projectId]: prev.filter((j) => !(j.jobId === jobId && j.host === host)),
+        },
+      };
+    }),
+}));
diff --git a/src/stores/hpcPipeline.ts b/src/stores/hpcPipeline.ts
new file mode 100644
index 0000000..cdfca31
--- /dev/null
+++ b/src/stores/hpcPipeline.ts
@@ -0,0 +1,23 @@
+import { create } from "zustand";
+
+/**
+ * Open/closed state for the guided **HPC pipeline wizard**
+ * (`docs/quirky-knitting-umbrella` plan Phase B). The wizard itself
+ * (`components/projects/HpcPipelineWizard`) holds its per-step form state; this
+ * store only decides whether it is on screen, so the project-switcher **+** menu
+ * (and anywhere else) can launch it without prop-drilling a callback down.
+ *
+ * Mirrors `stores/remoteMachines` — one boolean plus open/close, mounted once as a
+ * host in `AppShell`.
+ */
+interface HpcPipelineStore {
+  open: boolean;
+  openWizard: () => void;
+  close: () => void;
+}
+
+export const useHpcPipelineStore = create<HpcPipelineStore>((set) => ({
+  open: false,
+  openWizard: () => set({ open: true }),
+  close: () => set({ open: false }),
+}));
diff --git a/src/stores/localLoss.ts b/src/stores/localLoss.ts
new file mode 100644
index 0000000..31fb2e4
--- /dev/null
+++ b/src/stores/localLoss.ts
@@ -0,0 +1,74 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * The local-loss warning log for the active remote project (#28q).
+ *
+ * Mirrors `services::local_loss`. Both transports that keep a remote project in step
+ * write into the local mirror, and a few of those writes destroy what is already there:
+ * a lockstep fast-forward / `reset --hard` / checkout deletes the tracked files the
+ * incoming commit dropped, the `git clean` that un-blocks a refused fast-forward removes
+ * untracked ones, and a manual byte-sync pull overwrites a mirror file holding unsynced
+ * local edits. The backend records each one; this store reads them back and
+ * `LocalLossDialog` raises the unacknowledged ones.
+ *
+ * Pulled, not pushed: the backend writes the log from `AppHandle`-free services during
+ * background passes (see the module doc there), so the frontend re-reads it whenever a
+ * lockstep or sync pass reports in — which also means a loss recorded while the app was
+ * closed surfaces on the next launch rather than being missed forever.
+ */
+
+/** Mirrors `services::local_loss::LocalLoss` (camelCase). */
+export interface LocalLoss {
+  /** Unix seconds; also the entry's identity. */
+  ts: number;
+  /** Which transport destroyed it — the two have different recovery stories. */
+  source: "git" | "sync";
+  kind: "deleted" | "overwritten";
+  /** The operation, as a user-facing phrase. */
+  op: string;
+  /** Project-relative paths (truncated; `total` carries the real count). */
+  paths: string[];
+  total: number;
+  /** How to get the content back, or null when it cannot be got back. */
+  recovery: string | null;
+  acked: boolean;
+}
+
+interface LocalLossStore {
+  /** Entries for the project last refreshed, newest first. */
+  entries: LocalLoss[];
+  /** Which project `entries` belongs to. The dialog renders only when this still
+   *  matches the active project, so a response landing after a project switch can
+   *  never paint one project's losses over another's. */
+  projectId: string | null;
+  /** Re-read the log. A local project has no mirror, so it simply reads empty. */
+  refresh: (projectId: string) => Promise<void>;
+  /** Mark everything seen (the dialog's "Got it"). Entries stay on disk. */
+  ack: (projectId: string) => Promise<void>;
+}
+
+export const useLocalLossStore = create<LocalLossStore>((set) => ({
+  entries: [],
+  projectId: null,
+
+  refresh: async (projectId) => {
+    try {
+      const entries = await invoke<LocalLoss[]>("local_loss_list", { projectId });
+      set({ entries, projectId });
+    } catch {
+      // A log we cannot read is not worth a second failure on top of the first.
+    }
+  },
+
+  ack: async (projectId) => {
+    // Optimistic: the dialog closes on this state, not on the round trip. A failed ack
+    // means it reappears on the next refresh — the safe direction for a warning.
+    set((s) => ({ entries: s.entries.map((e) => ({ ...e, acked: true })) }));
+    try {
+      await invoke("local_loss_ack", { projectId });
+    } catch {
+      /* best-effort */
+    }
+  },
+}));
diff --git a/src/stores/pdfDrag.ts b/src/stores/pdfDrag.ts
new file mode 100644
index 0000000..5616af6
--- /dev/null
+++ b/src/stores/pdfDrag.ts
@@ -0,0 +1,250 @@
+/**
+ * Dragging PDF pages out of one page strip and into another — in the same window, or
+ * across two Eldrun windows.
+ *
+ * Two problems have to be solved separately, because they have different shapes:
+ *
+ *  1. **The bytes.** A detached subwindow (#42) is a separate WebView with its own JS
+ *     heap, so the dragged pages cannot travel as a JavaScript object. They are
+ *     extracted into a small PDF, parked in the backend (`pdf_clip_set`), and the
+ *     drag carries only the TOKEN naming them. Whichever strip the drop lands in
+ *     fetches them (`pdf_clip_get`). Events stay tiny.
+ *
+ *  2. **The position.** DOM pointer events do NOT cross an OS window boundary on
+ *     WebKitGTK, and their units diverge across engines under DPI scaling. So once a
+ *     drag leaves its own window the position comes from polling the OS cursor in
+ *     physical desktop px (`lib/coords`), exactly as the tab drag-dock does, and each
+ *     window converts to its OWN client px at the leaf (`physToClient`).
+ *
+ * On release the origin window streams a single END carrying the LAST POLLED cursor
+ * — never the DOM release coordinates, which on WebKitGTK are reported inside the
+ * origin window even when the cursor is visibly over another one. Every window
+ * receives it, and the one whose outer rect actually contains that point claims the
+ * drop and acknowledges. A Shift-drag (a move, not a copy) only removes the pages
+ * from the source once that acknowledgement arrives, so a drop that lands nowhere can
+ * never destroy them.
+ */
+import { emit, listen } from "@tauri-apps/api/event";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import {
+  snapshotFrame,
+  physToClient,
+  pointInOuter,
+  type ClientPoint,
+  type PhysPoint,
+  type WindowFrame,
+} from "../lib/coords";
+
+/** The dragged pages, as parked in the backend page clipboard. */
+export interface PageTransfer {
+  /** `pdf_clip_set` token naming a small PDF holding exactly the dragged pages. */
+  token: string;
+  count: number;
+}
+
+/** A resolved drop: which strip, and where in it. */
+export interface DropTarget {
+  stripId: string;
+  /** Insertion index among the strip's cards (`movePages`/`insertPages` convention). */
+  index: number;
+}
+
+/** What a mounted strip publishes so a foreign drag can find and feed it. */
+export interface StripHandle {
+  el: HTMLElement;
+  /** Insertion index for a point in this window's client px. */
+  indexAt: (p: ClientPoint) => number;
+  /** Splice the transferred pages in at `index`. */
+  onImport: (transfer: PageTransfer, index: number) => void;
+  /** Paint (or clear) the insertion caret. */
+  setCaret: (index: number | null) => void;
+}
+
+// Every page strip mounted in THIS window that accepts page drops. Module-level
+// rather than a React context because a drop is resolved from a raw desktop
+// coordinate, outside any component's tree.
+const strips = new Map<string, StripHandle>();
+
+export function registerPageStrip(id: string, handle: StripHandle): () => void {
+  strips.set(id, handle);
+  return () => {
+    strips.delete(id);
+  };
+}
+
+/** The strip under `p` (this window's client px), and where in it a drop would land.
+ *  `exclude` skips the strip the drag came from — that case is a plain reorder. */
+export function resolveDropTarget(p: ClientPoint, exclude?: string): DropTarget | null {
+  for (const [id, s] of strips) {
+    if (id === exclude) continue;
+    const r = s.el.getBoundingClientRect();
+    if (p.x >= r.left && p.x <= r.right && p.y >= r.top && p.y <= r.bottom) {
+      return { stripId: id, index: s.indexAt(p) };
+    }
+  }
+  return null;
+}
+
+/** Paint the caret on `target`'s strip and clear it everywhere else. */
+export function paintCaret(target: DropTarget | null): void {
+  for (const [id, s] of strips) {
+    s.setCaret(target && target.stripId === id ? target.index : null);
+  }
+}
+
+export function importInto(target: DropTarget, transfer: PageTransfer): boolean {
+  const s = strips.get(target.stripId);
+  if (!s) return false;
+  s.onImport(transfer, target.index);
+  return true;
+}
+
+// ── The cross-window protocol ────────────────────────────────────────────────
+// Mirrors `stores/detached`'s DETACHED_DRAG_* stream: identity + physical coords out,
+// a resolved drop in. Every payload carries the origin window's label so a window can
+// ignore the events it emitted itself (Tauri broadcasts to all webviews, including the
+// sender), leaving same-window drops to the direct DOM path above.
+
+export const PDF_DRAG_START = "pdf-page-drag-start";
+export const PDF_DRAG_MOVE = "pdf-page-drag-move";
+export const PDF_DRAG_END = "pdf-page-drag-end";
+export const PDF_DROP_ACK = "pdf-page-drop-ack";
+
+export interface PdfDragStart {
+  originLabel: string;
+  count: number;
+}
+export interface PdfDragMove {
+  originLabel: string;
+  physX: number;
+  physY: number;
+}
+export interface PdfDragEnd {
+  originLabel: string;
+  token: string;
+  count: number;
+  physX: number;
+  physY: number;
+  /** Shift was held: the origin will DELETE the pages, but only once acknowledged. */
+  shift: boolean;
+  cancelled: boolean;
+}
+export interface PdfDropAck {
+  token: string;
+  accepted: boolean;
+}
+
+/** Fire-and-forget: outside Tauri (tests) there is no event bus, and that is fine. */
+function post(event: string, payload: unknown): void {
+  try {
+    void emit(event, payload).catch(() => {});
+  } catch {
+    /* no Tauri event bus */
+  }
+}
+
+export function emitPdfDragStart(originLabel: string, count: number): void {
+  post(PDF_DRAG_START, { originLabel, count } satisfies PdfDragStart);
+}
+export function emitPdfDragMove(originLabel: string, p: PhysPoint): void {
+  post(PDF_DRAG_MOVE, { originLabel, physX: p.x, physY: p.y } satisfies PdfDragMove);
+}
+export function emitPdfDragEnd(e: PdfDragEnd): void {
+  post(PDF_DRAG_END, e);
+}
+
+/** This window's label, or `""` outside Tauri. */
+export function currentWindowLabel(): string {
+  try {
+    return getCurrentWindow().label;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Listen, in THIS window, for page drags coming from ANOTHER one: track the cursor to
+ * paint an insertion caret, and claim the drop if it lands here.
+ *
+ * Registered once per window (`PageStrip` refcounts it, so it exists exactly while at
+ * least one droppable strip is mounted). Returns an unlisten.
+ */
+export async function listenForeignPageDrags(): Promise<() => void> {
+  const me = currentWindowLabel();
+  // Snapshotted when a foreign drag starts: a window does not move mid-gesture, and
+  // this is what maps the streamed desktop cursor into our own client px.
+  let frame: WindowFrame | null = null;
+
+  const clientOf = (physX: number, physY: number): ClientPoint | null => {
+    const p = { x: physX, y: physY };
+    if (!frame || !pointInOuter(frame, p)) return null;
+    return physToClient(frame, p);
+  };
+
+  try {
+    const unStart = await listen<PdfDragStart>(PDF_DRAG_START, (ev) => {
+      if (ev.payload.originLabel === me) return; // our own drag: handled via the DOM
+      void snapshotFrame()
+        .then((f) => {
+          frame = f;
+        })
+        .catch(() => {});
+    });
+
+    const unMove = await listen<PdfDragMove>(PDF_DRAG_MOVE, (ev) => {
+      if (ev.payload.originLabel === me) return;
+      const c = clientOf(ev.payload.physX, ev.payload.physY);
+      paintCaret(c ? resolveDropTarget(c) : null);
+    });
+
+    const unEnd = await listen<PdfDragEnd>(PDF_DRAG_END, (ev) => {
+      if (ev.payload.originLabel === me) return;
+      paintCaret(null);
+      const { cancelled, physX, physY, token, count } = ev.payload;
+      if (cancelled) return;
+      const c = clientOf(physX, physY);
+      // Only the window the cursor is ACTUALLY over resolves a target, so exactly one
+      // window claims the drop and exactly one acknowledgement comes back.
+      const target = c ? resolveDropTarget(c) : null;
+      if (!target) return;
+      const accepted = importInto(target, { token, count });
+      post(PDF_DROP_ACK, { token, accepted } satisfies PdfDropAck);
+    });
+
+    return () => {
+      unStart();
+      unMove();
+      unEnd();
+    };
+  } catch {
+    return () => {}; // no Tauri event bus (tests)
+  }
+}
+
+/**
+ * Wait for a drop of `token` to be acknowledged by whichever window claimed it.
+ * Resolves `false` if nobody does within `timeoutMs` — a Shift-drag (a move) must NOT
+ * delete the pages from the source in that case.
+ */
+export async function awaitDropAck(token: string, timeoutMs = 4000): Promise<boolean> {
+  try {
+    return await new Promise<boolean>((resolve) => {
+      let done = false;
+      const timer = window.setTimeout(() => {
+        if (done) return;
+        done = true;
+        void un.then((f) => f());
+        resolve(false);
+      }, timeoutMs);
+      const un = listen<PdfDropAck>(PDF_DROP_ACK, (ev) => {
+        if (done || ev.payload.token !== token) return;
+        done = true;
+        window.clearTimeout(timer);
+        void un.then((f) => f());
+        resolve(ev.payload.accepted);
+      });
+    });
+  } catch {
+    return false;
+  }
+}
diff --git a/src/stores/pillDrag.ts b/src/stores/pillDrag.ts
new file mode 100644
index 0000000..68b5e56
--- /dev/null
+++ b/src/stores/pillDrag.ts
@@ -0,0 +1,53 @@
+import { create } from "zustand";
+
+/**
+ * Pointer-driven project-pill reorder/group/assign-to-box state (replaces the
+ * old native HTML5 DnD, which WebKitGTK's other draggables — TabBar, YamlTree,
+ * MachinesIndicator — all avoid for the same reason: a native drag out of a
+ * gesture the webview didn't originate can hang or drop mid-drag). Kept in its
+ * own store, mirroring `stores/drag.ts`'s tab-drag isolation, so the
+ * high-frequency pointermove updates only re-render the pills that actually
+ * read it (the dragged pill + whichever siblings must part to open its landing
+ * slot), not the whole switcher.
+ *
+ * `width` is the dragged pill's own measured width: removing an item of that
+ * width from the strip and reinserting it elsewhere shifts every pill BETWEEN
+ * the old and new slot by exactly that amount, regardless of their own widths
+ * — so a uniform ± shift is correct even though pills vary in width (mirrors
+ * MachinesIndicator's `dragH` shift, generalized to the horizontal axis).
+ */
+export interface PillDrag {
+  id: string;
+  width: number;
+  /** Live pointer delta (px) since the gesture started — the dragged pill's
+   *  own follow-the-cursor translateX. */
+  dx: number;
+  /** Index the dragged pill would land at, into the list of OTHER visible
+   *  project pills (i.e. not counting the dragged one) — purely a preview for
+   *  which siblings part; the actual commit re-resolves the drop target by
+   *  hit-testing at release (see ProjectPill), so this never has to be exact. */
+  overIndex: number;
+  /** A box pill the cursor is currently over — assign-to-box target instead of
+   *  a reorder; suppresses the parting preview (nothing will move). */
+  overBoxId: string | null;
+  /** Alt held while hovering another project pill — group (new box) target
+   *  instead of reorder; also suppresses the parting preview. */
+  groupTargetId: string | null;
+}
+
+interface PillDragStore {
+  drag: PillDrag | null;
+  start: (id: string, width: number, overIndex: number) => void;
+  move: (dx: number) => void;
+  setTarget: (t: Pick<PillDrag, "overIndex" | "overBoxId" | "groupTargetId">) => void;
+  end: () => void;
+}
+
+export const usePillDragStore = create<PillDragStore>((set) => ({
+  drag: null,
+  start: (id, width, overIndex) =>
+    set({ drag: { id, width, dx: 0, overIndex, overBoxId: null, groupTargetId: null } }),
+  move: (dx) => set((s) => (s.drag ? { drag: { ...s.drag, dx } } : {})),
+  setTarget: (t) => set((s) => (s.drag ? { drag: { ...s.drag, ...t } } : {})),
+  end: () => set({ drag: null }),
+}));
diff --git a/src/stores/power.ts b/src/stores/power.ts
new file mode 100644
index 0000000..228bda5
--- /dev/null
+++ b/src/stores/power.ts
@@ -0,0 +1,84 @@
+import { invoke } from "@tauri-apps/api/core";
+import { create } from "zustand";
+import { useSettingsStore } from "./settings";
+
+/** Mirrors the backend `PowerState` (commands/power.rs). */
+interface PowerState {
+  on_battery: boolean;
+  supported: boolean;
+}
+
+/** How often we re-read the AC/battery state. A generous interval: the only
+ *  consumer is Energy Saver, where a few seconds of lag on plug/unplug is fine
+ *  and a tight poll would itself cost power. */
+const POLL_MS = 30_000;
+
+interface PowerStore {
+  /** True only while every present battery is discharging. */
+  onBattery: boolean;
+  /** False when the backend could not read power state at all (fail open to AC). */
+  supported: boolean;
+  /** Whether the poll loop has produced at least one reading. */
+  ready: boolean;
+  /** Begin polling; returns a stop function that clears the interval. Idempotent
+   *  enough for React StrictMode double-mount (the stop from the first run tears
+   *  the first interval down). */
+  start: () => () => void;
+}
+
+export const usePowerStore = create<PowerStore>((set) => ({
+  onBattery: false,
+  supported: false,
+  ready: false,
+
+  start: () => {
+    const poll = async () => {
+      try {
+        const s = await invoke<PowerState>("get_power_state");
+        set({ onBattery: s.on_battery, supported: s.supported, ready: true });
+      } catch {
+        // Treat a failed query as on-AC (fail open) so Energy Saver never
+        // sticks the app in a throttled state because of a transient error.
+        set({ onBattery: false, supported: false, ready: true });
+      }
+    };
+    void poll();
+    const id = setInterval(() => void poll(), POLL_MS);
+    return () => clearInterval(id);
+  },
+}));
+
+/** Resolve the effective mode + power state into "is Energy Saver active right
+ *  now". Shared by the hook and the non-hook getter so the rule lives once. */
+function isActive(mode: string | undefined, onBattery: boolean): boolean {
+  switch (mode ?? "battery") {
+    case "off":
+      return false;
+    case "always":
+      return true;
+    case "battery":
+    default:
+      return onBattery;
+  }
+}
+
+/** Reactive: true when Energy Saver should be throttling activity. Re-renders
+ *  its caller when either the setting or the power state changes. */
+export function useEnergySaver(): boolean {
+  const mode = useSettingsStore((s) => s.settings?.energy_saver);
+  const onBattery = usePowerStore((s) => s.onBattery);
+  return isActive(mode, onBattery);
+}
+
+/** Non-reactive snapshot of {@link useEnergySaver}, for reads inside animation
+ *  loops (e.g. the ProjectBlobPane rAF) that must not resubscribe per frame. */
+export function energySaverActive(): boolean {
+  const mode = useSettingsStore.getState().settings?.energy_saver;
+  return isActive(mode, usePowerStore.getState().onBattery);
+}
+
+/** Widen a base interval (ms) when Energy Saver is active. Kept here so the
+ *  throttle factor lives in one place across every always-on timer site. */
+export function saverInterval(base: number, active: boolean, factor = 3): number {
+  return active ? base * factor : base;
+}
diff --git a/src/stores/projects.ts b/src/stores/projects.ts
index 6b20cf6..26763e0 100644
--- a/src/stores/projects.ts
+++ b/src/stores/projects.ts
@@ -1,35 +1,705 @@
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { create } from "zustand";
-import { resolveProjectDirectory, type ProjectEntry } from "../types";
+import {
+  formatRemoteTarget,
+  resolveLocalMirror,
+  resolveProjectDirectory,
+  type ComputeHost,
+  type GitHostingInfo,
+  type GitProvider,
+  type ProjectEntry,
+  type PublishFrom,
+  type RemoteSpec,
+  type SandboxSpec,
+  type SshProbe,
+} from "../types";
 import {
   cmdToKind,
   isRestorableTab,
   useTabsStore,
   type SavedLayoutTree,
   type TabKind,
+  type TabLocation,
+  type ViewerState,
 } from "./tabs";
+import { useRunHostPrefStore } from "./runHostPref";
+import { type AgentMode } from "../components/tabs/agentModes";
 import { useTimerStore } from "./timer";
-import { useVpnPromptStore } from "./vpnPrompt";
+import { useSettingsStore, whenSettingsLoaded } from "./settings";
+import { mayAutoTouch, targetOfSpec } from "../lib/hpcHost";
+import { PRIMARY_HOST, useRemoteStatusStore } from "./remoteStatus";
+import { markVpnConnected, markVpnConnecting, markVpnError, releaseVpn } from "./vpnStatus";
+import { useConnectDialogStore } from "./connectDialog";
+import { connectionStillOpen, openConnectionInRoot } from "../lib/remoteConnect";
+import { describeScaffoldRepair, type ProjectScaffoldRepair } from "../components/projects/scaffold";
+import type { SavedPasswordState } from "../components/projects/useSavedCredential";
+
+function connectionsHeadless(): boolean {
+  return useSettingsStore.getState().settings?.connections_headless ?? true;
+}
+
+/**
+ * Toast text for a tunnel that just came up. It names the scope on purpose: a
+ * bare "VPN connected · <project>" reads as though the tunnel belongs to the
+ * project, when what actually happened is that the whole machine's routing (and
+ * usually its DNS) moved — browser and all. That is worth one sentence, especially
+ * on the auto-connect path, where this toast is the *only* thing the user sees.
+ */
+function vpnToast(name: string): string {
+  return `VPN up · ${name} — this computer's traffic now routes through the tunnel`;
+}
+
+/**
+ * The password a create/extend dialog authenticated its SSH session with, handed
+ * over for that project's **first** pooled connect and forgotten the moment it is
+ * used (or the connect gives up). Never persisted — persisting is what the dialog's
+ * "Save password" toggle is for, and a user who declined it must not have the
+ * secret written anywhere.
+ *
+ * Without this, the first `remote_connect` for a just-created remote project ran
+ * with `password: null` and only succeeded because the dialog's ControlMaster was
+ * still up. Two things came out wrong: the pool depended on a master it doesn't own,
+ * and the backend — which reads "no password given, none saved" as *key* auth —
+ * recorded `key_auth: true` on a host that in fact needs a password, so the project
+ * then advertised itself as auto-connect-eligible and the auto-connect failed on the
+ * next launch.
+ *
+ * **Currently write-only.** The reader was `ensureRemotePool`, reachable only from
+ * `reconnectRemote`, which nothing has called for some time; both were deleted with
+ * the auto-connect audit rather than left as an ungated retry loop waiting to be
+ * re-wired. The dialogs still stash, so the hand-over is one call away — but until a
+ * caller exists, a just-created project's first pooled connect gets its credential
+ * from the keychain or the dialog's own master, exactly as it did before.
+ */
+const pendingRemotePassword = new Map<string, string>();
+
+/** Hand `projectId`'s first pooled connect the password the dialog just used. */
+export function stashRemotePassword(projectId: string, password: string): void {
+  if (password) pendingRemotePassword.set(projectId, password);
+}
+
+/**
+ * Projects whose first pooled connect will be riding a **login terminal's**
+ * ControlMaster rather than a credential of its own.
+ *
+ * Normally that is implied by the mode — `connections_headless: false` means every
+ * login is a terminal. But the dialogs now offer "Sign in in a terminal" for a single
+ * connect *while headless*, and in that case there is no password to stash and the
+ * mode says the opposite of what happened. Without this, that connect succeeds
+ * credential-less and `record_key_auth` (commands/remote.rs) reads it as key auth —
+ * stamping `key_auth: true` onto a password host, which then advertises a promptless
+ * auto-connect that fails on every launch. The frontend is the only side that knows,
+ * so it has to say.
+ */
+const pendingViaLogin = new Set<string>();
+
+/** Mark `projectId`'s first pooled connect as riding a login terminal's master. */
+export function stashRemoteViaLogin(projectId: string): void {
+  pendingViaLogin.add(projectId);
+}
+
+/** Projects with an auto-connect attempt in flight, so a switch away and back
+ *  (or a launch racing an activation) can't start a second one. */
+const autoConnecting = new Set<string>();
+
+/** The SSH coordinates of one host, as every auto-connect command wants them. */
+type SshArgs = { user: string | null; host: string; port: number | null };
+
+/**
+ * Say why an armed auto-connect did nothing.
+ *
+ * The opt-in is re-checked against the backend on every attempt — a saved password
+ * can be forgotten, a keyring can be locked — and until now that check failing was
+ * completely silent: no lamp (the project simply never leaves "off"), no toast, not
+ * even a `console.warn`. From the outside that is indistinguishable from "the
+ * toggle is broken", which is precisely how it got reported. The one path that
+ * deliberately does nothing now says so, naming the project, the login, and the
+ * thing that would fix it.
+ */
+function autoConnectIneligible(scope: string, sshArgs: SshArgs, state: SavedPasswordState): void {
+  const target = `${sshArgs.user ? `${sshArgs.user}@` : ""}${sshArgs.host}`;
+  // The two fixes are opposites, so the two cases must not share a sentence. A
+  // **locked** (or unreachable) store answers every lookup exactly like an empty one
+  // (`lib/keyring.ts`), so `saved: false` alone would tell a user whose password is
+  // sitting on the ring to go save it again — the one instruction that cannot help.
+  // Same split, and deliberately the same wording, as the machine-wide VPN twin in
+  // `lib/vpnAutoConnect`: one feature, one explanation.
+  const reason =
+    state.keyring === "unlocked"
+      ? `no saved SSH password for ${target} — connect once with "Save password" ticked`
+      : `your OS keyring is locked, so the password saved for ${target} can't be read. Unlock it from the VPN menu.`;
+  console.warn(`auto-connect skipped · ${scope}: ${reason}`);
+  useProjectsStore.setState({ connToast: `Auto-connect skipped · ${scope} — ${reason}` });
+}
+
+/** The saved-password answer every eligibility check asks for, with the one failure
+ *  that keeps the decision safe: an unanswered read is never a confident "saved". */
+async function savedPasswordState(sshArgs: SshArgs): Promise<SavedPasswordState> {
+  return invoke<SavedPasswordState>("remote_saved_password_state", sshArgs).catch(
+    () => ({ saved: false, keyring: "unavailable" }) as SavedPasswordState,
+  );
+}
+
+/**
+ * Auto-connect **without headless credentials** (`connections_headless` off), for one
+ * host.
+ *
+ * In that mode Eldrun handles no passwords at all — there is nothing in the keychain
+ * to re-check and `remote_has_saved_password` is always false — so the headless
+ * eligibility gate (a saved password, or a `key_auth` host) rejected *every* project
+ * and auto-connect silently did nothing at all. This is the same substitution the
+ * machine-wide VPN toggle already makes (`lib/vpnAutoConnect`): "connect on launch"
+ * means *the connect command is waiting in the root terminal*, where the user types
+ * the password into a visible shell, rather than a connect Eldrun completes by itself.
+ *
+ * So the promise the toggle keeps is unchanged in substance — it never opens a
+ * **modal** — but it is kept differently: one root-terminal login, deduped, then the
+ * pooled connection rides the ControlMaster that login leaves behind, exactly as the
+ * Connect dialog's non-headless path does (`useRemoteReconnect`'s `pollSshReady`).
+ *
+ * A key/agent host still needs no terminal at all: the probe authenticates, and we go
+ * straight to the pool.
+ */
+async function autoConnectInteractive(
+  projectId: string,
+  sshArgs: SshArgs,
+  hostId?: string,
+  /** A probe the caller already ran (the primary probes first to decide the VPN). */
+  probed?: SshProbe,
+): Promise<void> {
+  const status = () => useRemoteStatusStore.getState();
+  const stillActive = () => useProjectsStore.getState().activeId === projectId;
+  const probe =
+    probed ??
+    (await invoke<SshProbe>("ssh_probe", sshArgs).catch(
+      () => ({ ok: false, unreachable: false, error: "probe failed" }) as SshProbe,
+    ));
+  if (!stillActive()) return abandonAutoConnect(projectId, hostId);
+  if (!probe.ok) {
+    // Password host (or one whose key auth just failed): hand the login to the root
+    // terminal and wait for its master. Deduped by target, so a login the Connect
+    // dialog or a previous activation already opened is reused, never duplicated.
+    const command = await invoke<string>("remote_login_command", sshArgs);
+    const target = `${sshArgs.user ? `${sshArgs.user}@` : ""}${sshArgs.host}`;
+    const dedupeKey = `ssh:${target}:${sshArgs.port ?? ""}`;
+    openConnectionInRoot({ label: `ssh · ${target}`, command, dedupeKey });
+    const ready = await pollRootLoginReady(projectId, sshArgs, dedupeKey);
+    if (!stillActive()) return abandonAutoConnect(projectId, hostId);
+    if (ready === "closed") {
+      // The user closed the login tab: that is "not now", not a failure. Back to
+      // *disconnected* rather than red, which is the difference between a project the
+      // next activation will offer the login for again and one wedged shut until the
+      // pill's lamp is clicked (the re-attempt guard only fires from "off").
+      status().setSsh(projectId, "off", hostId);
+      return;
+    }
+    if (ready === "timeout") {
+      // Never authenticated within the window. Red lamp, no retry loop — the user
+      // finishes the login and connects from the pill's lamp (the tab is still
+      // sitting there with the command in it).
+      status().setSsh(projectId, "error", hostId);
+      return;
+    }
+  }
+  // `viaLogin`: this path only runs non-headless, where a credential-less connect
+  // rides the login terminal's master — it is not evidence of key auth, and recording
+  // it as such is what used to leave a password host permanently claiming a
+  // promptless connect it can't deliver (`record_key_auth`).
+  await invoke("remote_connect", {
+    projectId,
+    hostId: hostId ?? null,
+    password: null,
+    viaLogin: true,
+  });
+  if (!stillActive()) return abandonAutoConnect(projectId, hostId);
+  status().setSsh(projectId, "connected", hostId);
+}
+
+/**
+ * Poll for the root-terminal login's ControlMaster to come up: a credential-less
+ * `ssh_connect` rides the master the moment it is live. Bounded (~2 min at a 3s
+ * cadence) so a login the user never authenticates stops polling; bails early if the
+ * project is switched away from. Mirrors `useRemoteReconnect`'s `pollSshReady` — the
+ * Connect dialog's version of the same wait.
+ *
+ * `"closed"` is its own outcome because the tab *is* the connection here: once the
+ * user closes it there is nothing left to authenticate into, and waiting out the
+ * remaining two minutes only to paint the lamp red misreads a deliberate dismissal
+ * as a failed connect.
+ */
+async function pollRootLoginReady(
+  projectId: string,
+  sshArgs: SshArgs,
+  dedupeKey: string,
+): Promise<"ready" | "timeout" | "closed"> {
+  const maxAttempts = 40; // ~2 min at 3s cadence
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+    if (useProjectsStore.getState().activeId !== projectId) return "timeout";
+    if (!connectionStillOpen(dedupeKey)) return "closed";
+    // `password: null` and nothing saved → this only ever succeeds by riding the
+    // master the interactive login established (or on a key/agent host).
+    const ok = await invoke<void>("ssh_connect", { ...sshArgs, password: null })
+      .then(() => true)
+      .catch(() => false);
+    if (ok) return "ready";
+  }
+  return "timeout";
+}
+
+/** Hand a lamp we ourselves turned "connecting" back to "disconnected" when we give
+ *  up on a connect (the user switched away mid-attempt). Never touches a lamp in any
+ *  other state — that one belongs to whoever set it. */
+function abandonAutoConnect(projectId: string, hostId?: string): void {
+  const status = useRemoteStatusStore.getState();
+  const current = hostId
+    ? status.byHost[projectId]?.[hostId]?.ssh
+    : status.byProject[projectId]?.ssh;
+  if (current === "connecting") status.setSsh(projectId, "off", hostId);
+}
+
+/**
+ * Connect a remote project that has opted into **auto-connect** (launch and
+ * activation), and do it *silently* — this path never prompts. That is the whole
+ * contract of the toggle: it is only offered once the connection can complete with
+ * no user input (a saved SSH password, or a host recorded as `key_auth`), so an
+ * automatic connect can never ambush the user with a modal. Everything else keeps
+ * the old default: the project surfaces disconnected and the user brings it up from
+ * the pill's connection lamp.
+ *
+ * The tricky part is the VPN, because the *same* project is often reachable
+ * directly on one network and only through the tunnel on another — so whether the
+ * tunnel is needed is a property of the current network, not of the project, and
+ * can't be stored. We therefore probe rather than assume:
+ *
+ *  1. `ssh_probe` the host (read-only; it reuses the saved credential but, unlike
+ *     `ssh_connect`, never rewrites the keychain).
+ *  2. Reachable → open the pooled connection (`remote_connect`, which falls back to
+ *     the keychain itself). The tunnel is left alone — on the network that doesn't
+ *     need it, it is never brought up.
+ *  3. *Unreachable* (not "credential rejected" — see the backend's `ssh_unreachable`;
+ *     no tunnel fixes a wrong password) and the project has an `.ovpn` whose
+ *     passphrase is saved → bring the tunnel up from the keychain and re-probe.
+ *  4. Anything else → red lamp and stop. No prompt, no retry loop.
+ *
+ * Fire-and-forget: it never blocks a switch. Local tabs restore and work on the
+ * mirror regardless, and remote panes stay held until the pool is actually up.
+ */
+async function autoConnectPrimary(projectId: string): Promise<void> {
+  const project = useProjectsStore.getState().projects.find((p) => p.id === projectId);
+  const remote = project?.remote;
+  if (!remote?.auto_connect) return;
+  // Never silently, on a machine tagged HPC (`lib/hpcHost.ts`). A connect is not
+  // free on a cluster login node — it opens an SSH master, and Eldrun's own
+  // session machinery may raise a tmux server behind it — and "silently, because
+  // the app happened to start" is precisely the shape of unattended presence a
+  // shared login node's rules ask you not to leave lying around. Connecting by
+  // hand still works and is one click away; only the automatic path is off.
+  // `mayAutoTouch` is the shared authority, and it also fails closed while settings
+  // are unloaded — `load()` waits for them before firing this, so a launch can no
+  // longer sail past the gate simply by being early.
+  if (!mayAutoTouch(useSettingsStore.getState().settings, targetOfSpec(remote))) return;
+  // Skip unless the lamp is disconnected: never fight an in-flight attempt, never
+  // re-attack a host that already failed this session (switching back and forth
+  // would otherwise re-probe an unreachable host every time), and never re-connect
+  // a live pool.
+  const state = useRemoteStatusStore.getState().byProject[projectId];
+  if ((state?.ssh ?? "off") !== "off" || autoConnecting.has(projectId)) return;
+  // Claim the project BEFORE the first await: the lamp only turns "connecting" once
+  // the eligibility round-trip is back, so two rapid activations (switch away and
+  // straight back) would otherwise both sail past the guard above.
+  autoConnecting.add(projectId);
+
+  const stillActive = () => useProjectsStore.getState().activeId === projectId;
+  const status = () => useRemoteStatusStore.getState();
+  // Hand the lamp back to "disconnected" when we abandon a connect we started (the
+  // user switched away mid-probe). A lamp left stuck on "connecting" would lie in
+  // the header *and* wedge the project shut: the guard above only re-attempts from
+  // "off". Only ever resets our own "connecting" — never a lamp someone else owns.
+  const abandon = () => {
+    if (status().byProject[projectId]?.ssh === "connecting") status().setSsh(projectId, "off");
+  };
+  try {
+    const sshArgs: SshArgs = {
+      user: remote.user ?? null,
+      host: remote.host,
+      port: remote.port ?? null,
+    };
+
+    // ── Non-headless (`connections_headless` off) ───────────────────────────────
+    // Eldrun holds no credentials in this mode, so the eligibility gate below can
+    // never pass and auto-connect used to do *nothing at all* here. Connect the way
+    // this mode connects instead: the tunnel and the login go to the root terminal
+    // for the user to authenticate, and the pool rides what they leave behind.
+    if (!connectionsHeadless()) {
+      status().setSsh(projectId, "connecting");
+      // The VPN decision is unchanged and stays the *network's*, not the project's:
+      // probe first, escalate only on genuinely unreachable. A credential-less probe
+      // can't authenticate a password host, but it can still tell "the host said no"
+      // (reachable — no tunnel needed, and none would help) from "nothing answered".
+      const probe = await invoke<SshProbe>("ssh_probe", sshArgs).catch(
+        () => ({ ok: false, unreachable: false, error: "probe failed" }) as SshProbe,
+      );
+      if (!stillActive()) return abandon();
+      const config = remote.openvpn?.config;
+      if (!probe.ok && probe.unreachable && config) {
+        // Host needs a route this network doesn't have. In non-headless mode Eldrun
+        // holds no passphrase, so the tunnel is the *user's* to authenticate — surface
+        // its login in the root terminal (deduped; a tunnel already up isn't opened
+        // again) and stop there.
+        //
+        // Crucially we do NOT mark the machine-wide tunnel "connecting" or poll it
+        // from here. That is exactly what wedged the header: a tunnel is machine-wide,
+        // its lamp is shared, and an *unattended* project poll that resolves late (or
+        // not at all, on a switch-away) strands it on a phantom "connecting" — which
+        // the header's Disconnect button refuses to touch (it's disabled while
+        // connecting) and the Connect dialog reads as "a tunnel is already up". The
+        // lamp instead belongs to the one owner that can't strand it: `VpnIndicator`'s
+        // 10s `refresh` reconcile, driven by the backend's real tunnel set. When it
+        // flips the tunnel to "connected" it fires `retryAutoConnectAfterVpn`, which
+        // resets the red SSH lamp below and re-runs this connect — now reachable.
+        const up = await invoke<boolean>("openvpn_status", { config }).catch(() => false);
+        if (!up) {
+          try {
+            const command = await invoke<string>("openvpn_login_command", { config });
+            openConnectionInRoot({
+              label: `OpenVPN · ${project!.name}`,
+              command,
+              dedupeKey: `vpn:${config}`,
+            });
+          } catch (error) {
+            console.warn("auto-connect: VPN root-terminal login failed", error);
+          }
+        }
+        if (!stillActive()) return abandon();
+        // Red, not "connecting": the host is unreachable until the tunnel is up, and a
+        // red lamp is precisely what `retryAutoConnectAfterVpn` clears and re-attempts
+        // the instant the reconcile sees the tunnel connected. Leaving it "connecting"
+        // would wedge *this* lamp the same way (the re-attempt guard only fires from
+        // "off", which only the reset from "error" produces).
+        status().setSsh(projectId, "error");
+        return;
+      }
+      await autoConnectInteractive(projectId, sshArgs, undefined, probe);
+      return;
+    }
+
+    // Re-check eligibility against the backend rather than trusting the toggle: the
+    // saved password may have been forgotten since it was ticked, and a stale opt-in
+    // must degrade to "stay disconnected", never to a prompt.
+    // A key host needs no credential at all, so it never pays the keychain read.
+    const saved = remote.key_auth === true ? null : await savedPasswordState(sshArgs);
+    if (saved && !saved.saved) {
+      autoConnectIneligible(project!.name, sshArgs, saved);
+      return;
+    }
+    if (!stillActive()) return;
+
+    status().setSsh(projectId, "connecting");
+    let probe = await invoke<SshProbe>("ssh_probe", sshArgs);
+
+    const config = remote.openvpn?.config;
+    if (!probe.ok && probe.unreachable && config && stillActive()) {
+      const vpnSaved = await invoke<boolean>("vpn_has_saved_password", { config }).catch(
+        () => false,
+      );
+      if (vpnSaved) {
+        markVpnConnecting(projectId, config);
+        try {
+          await invoke("openvpn_connect", {
+            config,
+            username: remote.openvpn?.username ?? null,
+            password: null,
+            keyPassphrase: null,
+            // No checkbox behind an auto-connect: authenticate from the keychain,
+            // and leave it exactly as we found it.
+            remember: null,
+          });
+          markVpnConnected(projectId, config);
+          // The only disclosure on this path: auto-connect never prompts, so this
+          // toast (and the header indicator it lights) is the whole of what the user
+          // is told before their machine's routing changes under them.
+          useProjectsStore.setState({ connToast: vpnToast(project!.name) });
+          probe = await invoke<SshProbe>("ssh_probe", sshArgs);
+        } catch (error) {
+          markVpnError(projectId, config);
+          console.warn("auto-connect: VPN tunnel failed", error);
+        }
+      }
+    }
+
+    if (!stillActive()) return abandon();
+    if (!probe.ok) {
+      console.warn("auto-connect: host not reachable/authenticating", probe.error);
+      status().setSsh(projectId, "error");
+      return;
+    }
+    await invoke("remote_connect", { projectId, password: null });
+    if (!stillActive()) return abandon();
+    status().setSsh(projectId, "connected");
+  } catch (error) {
+    console.warn("auto-connect failed", error);
+    if (stillActive()) status().setSsh(projectId, "error");
+    else abandon();
+  } finally {
+    autoConnecting.delete(projectId);
+  }
+}
+
+/**
+ * Auto-connect a remote project on launch/activation: the primary first, then any
+ * worker (`compute_hosts`) that opted in. The primary is awaited before the
+ * workers fire so a VPN it brings up (the tunnel is machine-wide) is already there
+ * when a worker reachable only through it is probed. Fire-and-forget per host —
+ * one worker being unreachable never blocks the others or the primary.
+ */
+async function autoConnectRemote(projectId: string): Promise<void> {
+  await autoConnectPrimary(projectId);
+  const project = useProjectsStore.getState().projects.find((p) => p.id === projectId);
+  for (const host of project?.compute_hosts ?? []) {
+    if (host.auto_connect) void autoConnectWorker(projectId, host);
+  }
+}
+
+/**
+ * The worker twin of `autoConnectPrimary`: connect one opted-in worker host with no
+ * prompt. Simpler than the primary — a worker has no VPN escalation of its own (the
+ * tunnel is machine-wide, so the primary or the header owns it) — but it keeps the
+ * same guards: only from an "off" lamp, only when eligible (`key_auth` or a saved
+ * password, re-checked against the backend so a stale opt-in degrades to
+ * "stay disconnected"), and it abandons its own "connecting" lamp if the user
+ * switches away mid-probe. Keyed in `autoConnecting` by `project:host` so it never
+ * collides with the primary's per-project claim.
+ */
+async function autoConnectWorker(projectId: string, host: ComputeHost): Promise<void> {
+  const hostId = host.id;
+  // Same rule as the primary's: a tagged cluster is never dialled by itself.
+  if (!mayAutoTouch(useSettingsStore.getState().settings, targetOfSpec(host))) return;
+  const claim = `${projectId}:${hostId}`;
+  const state = useRemoteStatusStore.getState().byHost[projectId]?.[hostId];
+  if ((state?.ssh ?? "off") !== "off" || autoConnecting.has(claim)) return;
+  autoConnecting.add(claim);
+
+  const stillActive = () => useProjectsStore.getState().activeId === projectId;
+  const status = () => useRemoteStatusStore.getState();
+  const abandon = () => {
+    if (status().byHost[projectId]?.[hostId]?.ssh === "connecting")
+      status().setSsh(projectId, "off", hostId);
+  };
+  try {
+    const sshArgs: SshArgs = {
+      user: host.user ?? null,
+      host: host.host,
+      port: host.port ?? null,
+    };
+
+    // Non-headless: no keychain to be eligible against — the login goes to the root
+    // terminal and the pool rides its master (see `autoConnectInteractive`). No VPN
+    // step: the tunnel is machine-wide, so the primary (or the header) owns it, and
+    // the primary is awaited before any worker fires.
+    if (!connectionsHeadless()) {
+      status().setSsh(projectId, "connecting", hostId);
+      await autoConnectInteractive(projectId, sshArgs, hostId);
+      return;
+    }
+
+    const saved = host.key_auth === true ? null : await savedPasswordState(sshArgs);
+    if (saved && !saved.saved) {
+      // Named down to the machine: a project can arm four workers, and "auto-connect
+      // did nothing" is useless if it doesn't say which one.
+      const project = useProjectsStore.getState().projects.find((p) => p.id === projectId);
+      autoConnectIneligible(
+        `${project?.name ?? projectId} · ${host.label || host.host}`,
+        sshArgs,
+        saved,
+      );
+      return;
+    }
+    if (!stillActive()) return;
+
+    status().setSsh(projectId, "connecting", hostId);
+    const probe = await invoke<SshProbe>("ssh_probe", sshArgs);
+    if (!stillActive()) return abandon();
+    if (!probe.ok) {
+      console.warn("worker auto-connect: host not reachable/authenticating", probe.error);
+      status().setSsh(projectId, "error", hostId);
+      return;
+    }
+    await invoke("remote_connect", { projectId, hostId, password: null });
+    if (!stillActive()) return abandon();
+    status().setSsh(projectId, "connected", hostId);
+  } catch (error) {
+    console.warn("worker auto-connect failed", error);
+    if (stillActive()) status().setSsh(projectId, "error", hostId);
+    else abandon();
+  } finally {
+    autoConnecting.delete(claim);
+  }
+}
 
 /**
- * If `project` is VPN-gated, ensure its OpenVPN tunnel is up before any sshfs
- * mount / ssh runs. The password is prompted each time (never persisted). Best
- * effort: a cancelled prompt or a failed connect is logged and we proceed, so a
- * VPN hiccup degrades to the same "host unreachable" path as an offline host
- * rather than blocking activation.
+ * Silently retry a background pooled connection the AppShell reconciler found
+ * dead (`remote_connected_targets` no longer lists it — the ssh child exited on
+ * its own: a keepalive kill after a dropped VPN/network, a laptop sleep, or an
+ * HPC job's long queue wait past `ControlPersist`). Without this, a project the
+ * store still marks "connected" is corrected to "error" and STAYS there
+ * indefinitely — nothing ever moves an `error` lamp back except the user
+ * clicking reconnect, even though `services::remote::connect_host`'s own
+ * liveness check means the very next tab opened on that host reconnects the
+ * pool anyway. This closes that gap for the lamp itself.
+ *
+ * Deliberately does NOT gate on `stillActive()` like `autoConnectPrimary`/
+ * `autoConnectWorker` do: those guard an activation-time attempt the user might
+ * have already switched away from, but a dead background connection can belong
+ * to a project that isn't active at all (e.g. an HPC project a long `squeue`
+ * watch tab keeps running in) and must keep working regardless of which
+ * project is on screen.
+ *
+ * **Everything else about the eligibility bar it now genuinely shares** with
+ * `autoConnectPrimary`/`autoConnectWorker` — which its own comment used to claim
+ * while applying neither of the two gates that matter. It ran on any host the
+ * reconciler found dead, so a project whose `auto_connect` the user had never
+ * ticked, on a machine tagged HPC, was re-dialled unattended every time the master
+ * expired — and each success re-armed the lamp for the next `ControlPersist`
+ * timeout, a loop with no end and no surface. A connection the user never asked to
+ * be automatic ends at a red lamp they click, which is what it did before this
+ * function existed. The three gates are therefore: headless mode, the host's own
+ * `auto_connect`, and `mayAutoTouch`; then, as before, key/agent auth or a saved
+ * password.
  */
-async function ensureVpnIfNeeded(project: ProjectEntry | undefined): Promise<void> {
-  const config = project?.remote?.openvpn?.config;
-  if (!config) return;
+export async function silentReconnectDeadHost(projectId: string, hostId: string): Promise<void> {
+  const status = () => useRemoteStatusStore.getState();
+  // Every early-out below falls back to the pre-existing behavior (a plain
+  // "error" lamp) rather than silently leaving the store's stale "connected"
+  // in place — only the eligible-but-still-unreachable case in the try block
+  // is a genuine "we tried and it didn't work" that also lands here.
+  const markError = () => status().setSsh(projectId, "error", hostId);
+  if (!connectionsHeadless()) return markError();
+  const project = useProjectsStore.getState().projects.find((p) => p.id === projectId);
+  if (!project?.remote) return markError();
+  const target =
+    hostId === PRIMARY_HOST
+      ? {
+          user: project.remote.user ?? null,
+          host: project.remote.host,
+          port: project.remote.port ?? null,
+          keyAuth: project.remote.key_auth === true,
+          autoConnect: project.remote.auto_connect === true,
+        }
+      : (() => {
+          const host = project.compute_hosts?.find((h) => h.id === hostId);
+          return host
+            ? {
+                user: host.user ?? null,
+                host: host.host,
+                port: host.port ?? null,
+                keyAuth: host.key_auth === true,
+                autoConnect: host.auto_connect === true,
+              }
+            : null;
+        })();
+  if (!target) return markError();
+  // The opt-in is per host and it means "reconnect me without asking" — a host that
+  // never opted in has no automatic reconnect to inherit just because it once got
+  // connected by hand and then dropped.
+  if (!target.autoConnect) return markError();
+  // And never a tagged cluster, on the same terms as the two auto-connect paths: a
+  // background re-dial of a login node is the definition of unattended presence, and
+  // this one isn't even tied to the project being on screen.
+  if (
+    !mayAutoTouch(useSettingsStore.getState().settings, {
+      user: target.user ?? undefined,
+      host: target.host,
+      port: target.port ?? undefined,
+    })
+  )
+    return markError();
+
+  const claim = hostId === PRIMARY_HOST ? projectId : `${projectId}:${hostId}`;
+  if (autoConnecting.has(claim)) return; // an activation-time auto-connect already owns this host — let it finish
+  autoConnecting.add(claim);
   try {
-    const up = await invoke<boolean>("openvpn_status", { config }).catch(() => false);
-    if (up) return;
-    const password = await useVpnPromptStore.getState().request(config, project!.name);
-    await invoke("openvpn_connect", { config, password });
+    const sshArgs: SshArgs = { user: target.user, host: target.host, port: target.port };
+    const eligible =
+      target.keyAuth || (await invoke<boolean>("remote_has_saved_password", sshArgs).catch(() => false));
+    if (!eligible) return markError(); // nothing silent left to try
+
+    status().setSsh(projectId, "connecting", hostId);
+    const probe = await invoke<SshProbe>("ssh_probe", sshArgs).catch(
+      () => ({ ok: false, unreachable: false, error: "probe failed" }) as SshProbe,
+    );
+    if (!probe.ok) {
+      status().setSsh(projectId, "error", hostId);
+      return;
+    }
+    await invoke("remote_connect", { projectId, hostId, password: null });
+    status().setSsh(projectId, "connected", hostId);
   } catch (error) {
-    console.warn("OpenVPN connect skipped/failed", error);
+    console.warn("silent reconnect of dead host failed", error);
+    status().setSsh(projectId, "error", hostId);
+  } finally {
+    autoConnecting.delete(claim);
+  }
+}
+
+/**
+ * Re-attempt auto-connect for the **active** remote project after a VPN tunnel has
+ * just come up (the machine-wide event `lib/remoteAutoReconnect` subscribes to).
+ *
+ * A first auto-connect at launch may have run *before* the armed tunnel was up: the
+ * probe found the host unreachable and left the lamp red (`autoConnectPrimary` step
+ * 4 — no retry loop of its own). Now the routing exists, so we reset that red lamp
+ * (primary and each opted-in worker) back to "off" and fire `autoConnectRemote`
+ * again — the guard there only re-attempts from "off", so without this reset the
+ * fresh tunnel would go unused until the user connected by hand. Only ever clears an
+ * `error` lamp: a `connecting`/`connected` lamp is a live or winning attempt and is
+ * left strictly alone. No-op unless the active project is a remote that opted in.
+ */
+export function retryAutoConnectAfterVpn(): void {
+  const { activeId, projects } = useProjectsStore.getState();
+  if (!activeId) return;
+  const project = projects.find((p) => p.id === activeId);
+  if (!project?.remote?.auto_connect) return;
+  const status = useRemoteStatusStore.getState();
+  if ((status.byProject[activeId]?.ssh ?? "off") === "error") status.setSsh(activeId, "off");
+  for (const host of project.compute_hosts ?? []) {
+    if (host.auto_connect && (status.byHost[activeId]?.[host.id]?.ssh ?? "off") === "error")
+      status.setSsh(activeId, "off", host.id);
   }
+  void autoConnectRemote(activeId);
+}
+
+/** Tear down a remote project's pooled connection on deactivation — the primary
+ *  AND every worker host (multi-host remote). Best-effort. */
+function dropRemotePool(projectId: string): void {
+  useRemoteStatusStore.getState().clear(projectId);
+  void invoke("remote_disconnect_all_hosts", { projectId }).catch(() => {});
+}
+
+/** Tear a remote project's connection down on demand (header lamp menu): drop the
+ *  pooled SSH/SFTP connection and reset its lamps to disconnected. The restored
+ *  tabs stay open (their sessions just go dead) until the user reconnects. */
+export function disconnectRemote(projectId: string): void {
+  dropRemotePool(projectId);
+}
+
+/**
+ * One-click log out of a *connected* remote project (the pill's logout button):
+ * drop the pooled SSH/SFTP connection and release its claim on the OpenVPN tunnel,
+ * without routing through the Connect modal. The modal's Disconnect does the same
+ * plus cancels an in-flight connect via `useRemoteReconnect`'s generation counters
+ * — unreachable from here, and unnecessary: this button only shows once SSH is
+ * `connected`, so there is no attempt left to abandon.
+ *
+ * *Release*, not disconnect: the tunnel is machine-wide and shared by config path,
+ * so it only actually comes down if no other project is still holding it (see
+ * `releaseVpn`). To bring a tunnel down regardless, the header's VPN indicator is
+ * the place — that acts on the tunnel, not on a project.
+ */
+export function logoutRemote(project: ProjectEntry): void {
+  releaseVpn(project.id, project.remote?.openvpn?.config);
+  dropRemotePool(project.id);
 }
 
 interface ProjectRuntimeSwitchedPayload {
@@ -45,6 +715,11 @@ interface ProjectRuntimeSwitchedPayload {
     embedPath?: string;
     embedExec?: string;
     viewer?: "pdf" | "image" | "markdown" | "text";
+    viewerState?: ViewerState;
+    location?: "local" | "remote";
+    agentMode?: AgentMode;
+    /** A "projectfiles" tab's browsed folder (see TabEntry.folder). */
+    folder?: string;
   }>;
   // Opaque split/group layout tree (camelCased by the backend's serde rename);
   // absent → restored as a single group.
@@ -61,6 +736,10 @@ interface ProjectsStore {
   loaded: boolean;
   rootDir: string | null;
   switchToast: string | null;
+  /** A transient one-off action notice (e.g. "VPN connected · proj", a scaffold
+   *  repair summary). Kept separate from `switchToast` so a project switch
+   *  doesn't clobber it (and vice-versa). */
+  connToast: string | null;
   rightPanelFolderByProject: Record<string, string>;
   /** Incremented only on explicit setActive calls, never by load(). */
   switchGeneration: number;
@@ -69,10 +748,97 @@ interface ProjectsStore {
   reorderProjects: (fromId: string, toId: string) => Promise<void>;
   setRightPanelFolder: (projectId: string, folder: string) => void;
   clearSwitchToast: () => void;
+  clearConnToast: () => void;
   addProject: (project: ProjectEntry) => Promise<void>;
+  activateProject: (id: string) => Promise<void>;
   deactivateProject: (id: string) => Promise<void>;
+  /** Delete a project: tear down all its Eldrun-side connections/state and move
+   * it into the archive (`~/eldrun/archive/<id>/`). Reversible from Settings; the
+   * remote host tree of an SSH project is never touched. */
+  archiveProject: (id: string) => Promise<void>;
   updateProjectDescription: (id: string, description: string) => Promise<void>;
-  publishProject: (id: string, visibility: "public" | "private") => Promise<string>;
+  renameProject: (id: string, name: string) => Promise<void>;
+  /** Relocate a remote (SSH) project's local mirror folder into `parentDir`
+   * (the folder is moved to `<parentDir>/<name>`). Returns the new mirror path. */
+  moveRemoteMirror: (id: string, name: string, parentDir: string) => Promise<string>;
+  /** Attach a remote (SSH) spec to an existing local project. The project's
+   * current local directory becomes its local mirror in place (no data upload);
+   * the empty remote root is created on the host. Returns the updated entry,
+   * which is a disconnected remote project (user reconnects via the pill lamp). */
+  extendProjectToRemote: (id: string, remote: RemoteSpec) => Promise<void>;
+  setProjectSandbox: (id: string, enabled: boolean) => Promise<void>;
+  /** Replace a project's container spec (the Container settings dialog's save).
+   *  Backend normalizes blank fields away and stores it in both projects.json
+   *  and project.json; the stored spec is mirrored into local state. */
+  setProjectSandboxSpec: (id: string, spec: SandboxSpec) => Promise<void>;
+  /** Pin the project's Python interpreter, or `null` to restore auto-detect (#87). */
+  setProjectPython: (id: string, interpreter: string | null) => Promise<void>;
+  /** Opt a remote project in/out of auto-connect (connect it silently on launch
+   *  and activation). Only offered once the connect can complete with no prompt —
+   *  a saved SSH password, or a host recorded as `key_auth`; `autoConnectRemote`
+   *  re-checks that, so a stale opt-in degrades to staying disconnected. */
+  setProjectAutoConnect: (id: string, enabled: boolean) => Promise<void>;
+  /** Opt a remote project in/out of persistent (tmux) sessions (TODO #85). Default
+   *  ON, so this only records an opt-out; re-enabling clears the field. */
+  setProjectPersistSessions: (id: string, enabled: boolean) => Promise<void>;
+  /** Set (or clear, on blank) the display name for a remote project's PRIMARY
+   *  machine — the counterpart of a worker's `label` (`patch_compute_host`).
+   *  Distinct from the project name: this labels the host, shown wherever a
+   *  project's hosts are listed side by side (System Monitor, pill lamps). */
+  setProjectRemoteLabel: (id: string, label: string) => Promise<void>;
+  /** Set (or clear, on blank) the **SSH login name** a remote project's primary
+   *  host is reached as. The address is fixed at creation, so this is the only way
+   *  to correct a project created without a user (ssh then authenticates as the
+   *  local account name) or with the wrong one. Clears `key_auth` with it — that
+   *  was recorded for the account being replaced. */
+  setProjectRemoteUser: (id: string, user: string) => Promise<void>;
+  /** Attach (or clear) an OpenVPN config on a remote project's SSH spec, so a
+   *  project created without a VPN can gain one later when reconnecting from a
+   *  VPN-gated network. `config = null`/"" clears it. Mirrors the stored path
+   *  into local state so the Connect dialog picks it up immediately. */
+  setProjectOpenvpn: (id: string, config: string | null, username?: string | null) => Promise<void>;
+  /** Replace a project's category tags (color/group it in the cloud + pills).
+   * Backend cleans + dedupes; mirrors the cleaned list into local state. */
+  setProjectCategories: (id: string, categories: string[]) => Promise<void>;
+  /** Disable (delete .git → git_type "none") or re-enable (git init → "local")
+   * git for an existing project. Destructive when disabling. */
+  setProjectGitDisabled: (id: string, disabled: boolean) => Promise<void>;
+  /** Fill in any scaffold file/`.gitignore` pattern this project is missing
+   * relative to current defaults (e.g. it predates that default). Additive
+   * only — never overwrites existing content. Surfaces the result as a
+   * transient toast. */
+  repairProjectScaffold: (id: string) => Promise<ProjectScaffoldRepair>;
+  /** `publishFrom` picks the side for a work-remote project: `"local"` (the
+   * default — the lockstep mirror, using this machine's `gh`/`glab` login) or
+   * `"remote"` (the host's own login). Ignored for a local project. */
+  publishProject: (
+    id: string,
+    provider: GitProvider,
+    visibility: "public" | "private",
+    publishFrom?: PublishFrom,
+  ) => Promise<string>;
+  /** Detach a remote (SSH) project back to a plain local project: its mirror
+   * becomes the project directory in place. The host's files are never touched. */
+  detachProjectFromRemote: (id: string) => Promise<void>;
+  /** Forget a published project's push target without deleting the hosted repo
+   * or local history: removes `origin`, resets git_type → "local". */
+  unpublishProject: (id: string) => Promise<void>;
+  /** Flip a published project's visibility (public ↔ private) in place via the
+   * provider's `repo edit`. Returns the CLI stdout. */
+  setProjectVisibility: (id: string, visibility: "public" | "private") => Promise<string>;
+  /** Migrate a published project to the other provider (old repo left intact as
+   * `origin-old`). Returns the create CLI stdout (new repo URL). */
+  switchProjectProvider: (
+    id: string,
+    provider: GitProvider,
+    visibility: "public" | "private",
+    publishFrom?: PublishFrom,
+  ) => Promise<string>;
+  getProjectGitHosting: (id: string) => Promise<GitHostingInfo>;
+  setProjectGitHosting: (
+    id: string,
+    args: { profileUrl?: string | null; token?: string | null; clearToken?: boolean },
+  ) => Promise<GitHostingInfo>;
 }
 
 export const useProjectsStore = create<ProjectsStore>((set, get) => ({
@@ -81,6 +847,7 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
   loaded: false,
   rootDir: null,
   switchToast: null,
+  connToast: null,
   rightPanelFolderByProject: {},
   switchGeneration: 0,
 
@@ -113,22 +880,46 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
       activeId,
       rightPanelFolderByProject,
     });
-    // The initially-active project never fires a switch (which is what mounts
-    // remote projects on activation). If it is remote, ensure its sshfs mount
-    // is up so the file tree / terminal see its bytes. Best-effort and
-    // non-fatal: a remote host may be offline at boot, which must not block or
-    // crash app start — re-switching to the project later will retry the mount.
-    if (activeId) {
-      const active = projects.find((p) => p.id === activeId);
-      if (active?.remote) {
-        void (async () => {
-          await ensureVpnIfNeeded(active);
-          await invoke("ensure_project_mounted", { projectId: activeId }).catch(
-            (error) => console.warn("ensure_project_mounted (startup) failed", error),
-          );
-        })();
-      }
-    }
+    // Re-hydrate the run-host preference (which machine shells run on) from each
+    // project's persisted `run_host`, so a choice made in a previous session still
+    // sends this session's Run/Debug and "+" shells to that machine. Merge-only, so
+    // a change made this session before a reload is never clobbered.
+    useRunHostPrefStore.getState().seed(
+      projects.map((p) => ({
+        projectId: p.id,
+        location: p.run_host as TabLocation | undefined,
+      })),
+    );
+    // Fire-and-forget: sniff each local repo's `origin` host so pills can badge
+    // a hosting provider (GitHub/GitLab) and the hover can show the git address,
+    // even when the repo was pushed outside Eldrun's Publish flow. Host-only, no
+    // network — must not block the list.
+    void invoke<Record<string, { provider: string; url: string }>>("detect_git_providers")
+      .then((map) =>
+        set((state) => ({
+          projects: state.projects.map((p) => {
+            const hit = map[p.id];
+            if (hit?.provider === "github" || hit?.provider === "gitlab") {
+              return { ...p, detected_provider: hit.provider as GitProvider, git_origin_url: hit.url };
+            }
+            return p;
+          }),
+        })),
+      )
+      .catch(() => {});
+    // The initially-active remote project is NOT connected on launch unless it opted
+    // into auto-connect. Its saved tabs DO restore either way (local tabs run on the
+    // mirror offline), but any REMOTE pane is held until the pool is up — without the
+    // opt-in it starts DISCONNECTED (no status entry → "off" lamp) and the user brings
+    // it up from the pill's connection lamp (the `RemoteConnectDialog` modal).
+    //
+    // Waits for settings first. The HPC gate reads them and `mayAutoTouch` fails
+    // closed on an unloaded store — which is the safe direction, but it means firing
+    // here against a half-booted store would skip a perfectly eligible project purely
+    // because `AppShell` starts both loads in parallel and this one won the race. (It
+    // is also the window in which the gate could once fail *open*.) Fire-and-forget
+    // still: nothing about the project list waits on a connect.
+    if (activeId) void whenSettingsLoaded().then(() => autoConnectRemote(activeId));
   },
 
   setActive: async (id) => {
@@ -173,7 +964,17 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
       } else {
         const proj = state.projects.find((p) => p.id === id);
         if (proj) {
-          toastPath = resolveProjectDirectory(proj) || proj.name;
+          if (proj.remote) {
+            // A remote (SSH) project lives in two places — show both: the
+            // paired local working copy ("mirror", ~/eldrun/projects/ssh/…) and
+            // the remote target (user@host:remote_path). Rendered as two lines
+            // (AppShell adds a `multiline` class when it sees the newline).
+            const local =
+              resolveLocalMirror(proj) || resolveProjectDirectory(proj) || proj.name;
+            toastPath = `local   ${local}\nremote  ${formatRemoteTarget(proj.remote)}`;
+          } else {
+            toastPath = resolveProjectDirectory(proj) || proj.name;
+          }
         }
       }
       return {
@@ -185,12 +986,13 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
     });
     await invoke<void>("save_projects", { projects: nextProjects });
     void useTimerStore.getState().setProject(id);
-    // Bring up the VPN (if this project is VPN-gated) before the switch mounts
-    // its sshfs filesystem. Prompts for the password each time; non-blocking on
-    // failure (the mount then degrades like an offline host).
-    if (id !== null) {
-      await ensureVpnIfNeeded(nextProjects.find((p) => p.id === id));
-    }
+    // Switching TO a remote project does NOT bring it up by default: it surfaces
+    // disconnected (local tabs restore and work on the mirror; remote panes are held
+    // until the pool is up) and the user connects it from the pill's connection lamp.
+    // The one exception is a project that opted into auto-connect, which is connected
+    // here silently — see `autoConnectRemote`. Fire-and-forget; never blocks the switch.
+    const activated = nextProjects.find((p) => p.id === id);
+    if (activated?.remote) void autoConnectRemote(activated.id);
     // Fire-and-forget: the switch runs on a backend worker thread and returns
     // immediately. The resulting tab layout / right-panel folder arrives via the
     // `project-runtime-switched` event, handled by listenProjectRuntimeSwitched.
@@ -198,6 +1000,12 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
       projectId: id,
       previousProjectId: previousId,
       previousSnapshot: {
+        // Keep in step with the canonical persist in `tabs.ts` (persistScope):
+        // this snapshot OVERWRITES the previous project's project.json on switch,
+        // so any field dropped here is lost on a switch even though the debounced
+        // save wrote it. That is how a Files (Project) tab's browsed `folder` (and
+        // a viewer's scroll position / an agent's plan-mode) went missing on
+        // switch-away.
         tabLayout: tabs.map((t) => ({
           key: t.key,
           label: t.label,
@@ -209,6 +1017,10 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
           embedPath: t.embedPath,
           embedExec: t.embedExec,
           viewer: t.viewer,
+          viewerState: t.viewerState,
+          location: t.location,
+          agentMode: t.agentMode,
+          folder: t.folder,
         })),
         tabGroups,
         activeTabIndex,
@@ -277,6 +1089,8 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
 
   clearSwitchToast: () => set({ switchToast: null }),
 
+  clearConnToast: () => set({ connToast: null }),
+
   addProject: async (project) => {
     let nextProjects: ProjectEntry[] = [];
     set((state) => {
@@ -286,6 +1100,27 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
     await useProjectsStore.getState().setActive(project.id);
   },
 
+  activateProject: async (id) => {
+    // Promote an inactive project to "active" (available, but NOT the current
+    // focused project). Leaves activeId/scope untouched — opening (making it
+    // current) is a separate, explicit action via setActive.
+    let nextProjects: ProjectEntry[] = [];
+    let changed = false;
+    set((state) => {
+      nextProjects = state.projects.map((project) => {
+        if (project.id === id && project.status === "inactive") {
+          changed = true;
+          return { ...project, status: "active" };
+        }
+        return project;
+      });
+      return changed ? { projects: nextProjects } : {};
+    });
+    if (changed) {
+      await invoke<void>("save_projects", { projects: nextProjects });
+    }
+  },
+
   deactivateProject: async (id) => {
     let nextProjects: ProjectEntry[] = [];
     let nextActiveId: string | null = null;
@@ -302,11 +1137,57 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
       return { projects: nextProjects };
     });
     await invoke<void>("save_projects", { projects: nextProjects });
+    // Close the pooled SSH/SFTP connection for a deactivated remote project so no
+    // ssh ControlMaster child lingers for a project no longer in use (Phase 0).
+    if (nextProjects.find((p) => p.id === id)?.remote) dropRemotePool(id);
     if (useProjectsStore.getState().activeId !== nextActiveId) {
       await useProjectsStore.getState().setActive(nextActiveId);
     }
   },
 
+  archiveProject: async (id) => {
+    const entry = get().projects.find((p) => p.id === id);
+    if (!entry) return;
+
+    // ── Tear down all Eldrun-side connections/state for this project ──────────
+    // Drop the pooled SSH/SFTP ControlMaster + reset its lamps (remote only).
+    if (entry.remote) dropRemotePool(id);
+    // Close its Connect modal if it happens to be targeting this project.
+    if (useConnectDialogStore.getState().projectId === id) {
+      useConnectDialogStore.getState().close();
+    }
+    // Release its claim on the OpenVPN tunnel — which comes down only if no other
+    // project is still holding it. (This used to scan the project list for another
+    // project *configured* with the same config, which is a different question: it
+    // kept the tunnel up for projects that weren't even connected. `releaseVpn`
+    // counts actual holders.)
+    releaseVpn(id, entry.remote?.openvpn?.config);
+    // Drop its tabs/PTYs/sessions (in memory; the folder move discards the file).
+    useTabsStore.getState().closeAllTabs(id);
+    // Remove it from any box (clears box_id on it + dissolves a now-singleton box).
+    if (entry.box_id) {
+      const { useBoxesStore } = await import("./boxes");
+      await useBoxesStore.getState().assignToBox(id, null);
+    }
+
+    // ── Move it into the archive + drop it from projects.json ────────────────
+    await invoke("archive_project", { projectId: id, archivedAt: new Date().toISOString() });
+
+    // ── Update the store: remove the pill, re-focus if it was active ──────────
+    let nextActiveId: string | null = null;
+    set((state) => {
+      const projects = state.projects.filter((p) => p.id !== id);
+      nextActiveId =
+        state.activeId === id
+          ? (projects.find((p) => p.status === "active") ?? projects[0])?.id ?? null
+          : state.activeId;
+      return { projects };
+    });
+    if (get().activeId !== nextActiveId) {
+      await get().setActive(nextActiveId);
+    }
+  },
+
   updateProjectDescription: async (id, description) => {
     // Backend cleans (trims, empties → null) and writes projects.json +
     // project.json; mirror the cleaned value into local state.
@@ -321,19 +1202,349 @@ export const useProjectsStore = create<ProjectsStore>((set, get) => ({
     }));
   },
 
-  publishProject: async (id, visibility) => {
-    // Backend runs `gh repo create … --push` (locally, or over ssh for a
-    // work-remote project) and writes the new push target into projects.json +
-    // project.json; mirror it into local state. Returns gh's stdout (repo URL).
-    const output = await invoke<string>("github_publish", { projectId: id, visibility });
-    const gitType = `remote-${visibility}`;
+  renameProject: async (id, name) => {
+    // Backend trims, rejects blank, and writes projects.json + project.json;
+    // mirror the cleaned name into local state so the pill updates immediately.
+    const cleaned = await invoke<string>("set_project_name", {
+      projectId: id,
+      name,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id ? { ...project, name: cleaned } : project,
+      ),
+    }));
+  },
+
+  moveRemoteMirror: async (id, name, parentDir) => {
+    // Backend moves the mirror folder + its bytes to `<parentDir>/<name>` and
+    // persists the new pointer (projects.json `extra["mirror"]`). The mirror IS
+    // held on the entry (flattened `mirror`, read by resolveLocalMirror), so patch
+    // it in memory too — otherwise the switch toast, the disconnected file-browser
+    // pane, and local tab titles keep the old path until the next reload.
+    const newPath = await invoke<string>("move_remote_mirror", { projectId: id, name, parentDir });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id ? { ...project, mirror: newPath } : project,
+      ),
+    }));
+    return newPath;
+  },
+
+  extendProjectToRemote: async (id, remote) => {
+    // Backend attaches the remote spec, creates the empty host root, and moves
+    // the project into the mount-free remote layout (its old local dir becomes
+    // the mirror). No data is uploaded — the returned entry is a disconnected
+    // remote project. Replace the whole entry so `remote`/`mirror`/`directory`
+    // (and thus the pill lamp + file tree) update immediately.
+    const updated = await invoke<ProjectEntry>("extend_project_to_remote", {
+      req: { projectId: id, remote },
+    });
+    set((state) => ({
+      projects: state.projects.map((project) => (project.id === id ? updated : project)),
+    }));
+  },
+
+  setProjectSandbox: async (id, enabled) => {
+    // Backend flips `enabled` on the stored spec (preserving hand-tuned
+    // image/network/… fields, auto-detecting in-repo sources on first enable)
+    // and returns the resulting spec; mirror it into local state so the pill
+    // toggle and the spawn-time gate (CenterPanel) see it immediately.
+    const spec = await invoke<SandboxSpec>("set_project_sandbox", { projectId: id, enabled });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id ? { ...project, sandbox: spec } : project,
+      ),
+    }));
+  },
+
+  setProjectSandboxSpec: async (id, spec) => {
+    const saved = await invoke<SandboxSpec>("set_project_sandbox_spec", {
+      projectId: id,
+      spec,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id ? { ...project, sandbox: saved } : project,
+      ),
+    }));
+  },
+
+  setProjectPython: async (id, interpreter) => {
+    // Backend writes both stores (projects.json mirror + project.json) and returns
+    // what it stored — null when cleared back to auto-detect.
+    const saved = await invoke<string | null>("set_project_python", {
+      projectId: id,
+      interpreter,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id
+          ? { ...project, python_interpreter: saved ?? undefined }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectAutoConnect: async (id, enabled) => {
+    // Backend patches `auto_connect` on the remote spec in both projects.json and
+    // project.json and returns the resulting state; mirror it into local state so
+    // both surfaces (pill menu + Connect dialog) reflect it at once.
+    const result = await invoke<boolean>("set_project_auto_connect", {
+      projectId: id,
+      enabled,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id && project.remote
+          ? { ...project, remote: { ...project.remote, auto_connect: result || undefined } }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectPersistSessions: async (id, enabled) => {
+    // TODO #85: persistent (tmux) sessions are DEFAULT ON for a remote project, so
+    // the backend stores only an explicit opt-out (`persist_sessions: false`) and
+    // clears the field when re-enabled. Mirror the resulting state into local state
+    // as `persist_sessions: enabled ? undefined : false` so the pill reflects it.
+    const result = await invoke<boolean>("set_project_persist_sessions", {
+      projectId: id,
+      enabled,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id && project.remote
+          ? {
+              ...project,
+              remote: { ...project.remote, persist_sessions: result ? undefined : false },
+            }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectRemoteLabel: async (id, label) => {
+    const result = await invoke<string | null>("set_project_remote_label", {
+      projectId: id,
+      label,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id && project.remote
+          ? { ...project, remote: { ...project.remote, label: result ?? undefined } }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectRemoteUser: async (id, user) => {
+    const result = await invoke<string | null>("set_project_remote_user", {
+      projectId: id,
+      user,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id && project.remote
+          ? {
+              ...project,
+              remote: {
+                ...project.remote,
+                user: result ?? undefined,
+                // The backend drops `key_auth` with the login name; mirror that
+                // rather than leave a stale "this host needs no password" claim
+                // driving the Auto-connect toggle for an account that never proved it.
+                key_auth: undefined,
+              },
+            }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectOpenvpn: async (id, config, username) => {
+    // Backend patches the `openvpn` field on the remote spec in both projects.json
+    // and project.json and returns the stored config path (""=cleared); mirror it
+    // into the entry's `remote.openvpn` so the Connect dialog reflects it at once.
+    // `username` (for `auth-user-pass` configs) is stored alongside; undefined
+    // leaves it untouched here by re-sending the current value.
+    const cleanUser = username?.trim() || undefined;
+    const stored = await invoke<string>("set_project_openvpn", {
+      projectId: id,
+      config: config && config.trim() ? config : null,
+      username: cleanUser ?? null,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id && project.remote
+          ? {
+              ...project,
+              remote: {
+                ...project.remote,
+                openvpn: stored ? { config: stored, username: cleanUser } : undefined,
+              },
+            }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectCategories: async (id, categories) => {
+    // Backend trims/dedupes and writes projects.json + project.json, returning
+    // the cleaned list; mirror it so the pill bar and project cloud recolor
+    // immediately.
+    const cleaned = await invoke<string[]>("set_project_categories", {
+      projectId: id,
+      categories,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id
+          ? { ...project, categories: cleaned.length > 0 ? cleaned : undefined }
+          : project,
+      ),
+    }));
+  },
+
+  setProjectGitDisabled: async (id, disabled) => {
+    // Backend deletes/inits .git, writes projects.json + project.json, and
+    // returns the resulting git_type ("none" or "local"); mirror it so the pill
+    // label and context-menu state update immediately.
+    const gitType = await invoke<string>("set_project_git_disabled", {
+      projectId: id,
+      disabled,
+    });
     set((state) => ({
       projects: state.projects.map((project) =>
         project.id === id ? { ...project, git_type: gitType } : project,
       ),
     }));
+  },
+
+  repairProjectScaffold: async (id) => {
+    const repair = await invoke<ProjectScaffoldRepair>("repair_project_scaffold", { projectId: id });
+    useProjectsStore.setState({ connToast: describeScaffoldRepair(repair) });
+    return repair;
+  },
+
+  publishProject: async (id, provider, visibility, publishFrom = "local") => {
+    // Backend runs the provider CLI (`gh`/`glab` repo create … then push) and
+    // writes the new push target + provider into projects.json + project.json;
+    // mirror it into local state. For a work-remote project `publishFrom`
+    // chooses the side — the local mirror by default, because the provider
+    // login is this machine's. Returns the CLI's stdout (repo URL).
+    const output = await invoke<string>("publish_project", {
+      projectId: id,
+      provider,
+      visibility,
+      publishFrom,
+    });
+    const gitType = `remote-${visibility}`;
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id
+          ? { ...project, git_type: gitType, git_provider: provider }
+          : project,
+      ),
+    }));
+    return output;
+  },
+
+  detachProjectFromRemote: async (id) => {
+    // Backend promotes the local mirror back to the project directory and drops
+    // the remote/mirror pointers (host files untouched), returning the updated
+    // local entry. Replace the whole entry so the pill lamp + file tree update.
+    const oldDir = get().projects.find((p) => p.id === id)?.directory ?? "";
+    const updated = await invoke<ProjectEntry>("detach_project_from_remote", { projectId: id });
+    set((state) => ({
+      projects: state.projects.map((project) => (project.id === id ? updated : project)),
+    }));
+
+    // Re-point the tabs. `directory` just changed out from under them: it was the remote
+    // state dir, and it is now the promoted mirror. Every tab still holds the old one as
+    // its cwd — harmless while the project was remote (localTabCwd rewrote it at render),
+    // instantly wrong the moment it isn't, because that override is gated on the project
+    // BEING remote. Left alone, agents relaunch inside the state dir this detach just
+    // emptied, and Claude — which keys its session history by cwd — can no longer find the
+    // conversation to `--resume`. See `detachScopeFromRemote`.
+    if (oldDir && updated.directory) {
+      useTabsStore.getState().detachScopeFromRemote(id, oldDir, updated.directory);
+    }
+
+    // The SSH/VPN lamp lives in its own store, keyed by project — nothing about replacing
+    // the project entry clears it, so a detached project would keep showing a connection
+    // to a host it no longer has.
+    useRemoteStatusStore.getState().clear(id);
+  },
+
+  unpublishProject: async (id) => {
+    // Backend removes the `origin` remote (locally or over ssh) and resets the
+    // push target to local, leaving history + the hosted repo intact. Mirror the
+    // git_type/provider reset into local state.
+    await invoke("unpublish_project", { projectId: id });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id ? { ...project, git_type: "local", git_provider: undefined } : project,
+      ),
+    }));
+  },
+
+  setProjectVisibility: async (id, visibility) => {
+    // Backend flips visibility in place via the provider CLI (`gh/glab repo
+    // edit`), locally or over ssh, and writes the new remote-<vis> git_type.
+    const output = await invoke<string>("set_project_visibility", { projectId: id, visibility });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id ? { ...project, git_type: `remote-${visibility}` } : project,
+      ),
+    }));
+    return output;
+  },
+
+  switchProjectProvider: async (id, provider, visibility, publishFrom = "local") => {
+    // Backend moves the old origin aside (old repo left intact, on whichever side
+    // holds it) and re-publishes to the new provider, writing the new git_type +
+    // git_provider. Returns the create CLI stdout (new repo URL); mirror the new
+    // provider/type into state.
+    const output = await invoke<string>("switch_project_provider", {
+      projectId: id,
+      provider,
+      visibility,
+      publishFrom,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id
+          ? { ...project, git_type: `remote-${visibility}`, git_provider: provider }
+          : project,
+      ),
+    }));
     return output;
   },
+
+  getProjectGitHosting: async (id) => {
+    return invoke<GitHostingInfo>("get_project_git_hosting", { projectId: id });
+  },
+
+  setProjectGitHosting: async (id, args) => {
+    // Backend writes the profile URL to project.json + projects.json and the
+    // token to the OS keyring, then returns the resulting (token-free) info.
+    // Mirror the profile URL into local pill state so it's visible immediately.
+    const info = await invoke<GitHostingInfo>("set_project_git_hosting", {
+      projectId: id,
+      profileUrl: args.profileUrl ?? null,
+      token: args.token ?? null,
+      clearToken: args.clearToken ?? false,
+    });
+    set((state) => ({
+      projects: state.projects.map((project) =>
+        project.id === id
+          ? { ...project, git_profile_url: info.profile_url ?? undefined }
+          : project,
+      ),
+    }));
+    return info;
+  },
 }));
 
 /// Listen for the backend's `project-runtime-switched` event and apply the
@@ -346,7 +1557,7 @@ export function listenProjectRuntimeSwitched(): Promise<() => void> {
     const payload = ev.payload;
     const scopeKey = payload.projectId ?? "root";
     const tabsStore = useTabsStore.getState();
-    // Keep shell/files tabs, resumable agent tabs (Claude with a sessionId), and
+    // Keep shell/files/network tabs, resumable agent tabs (Claude with a sessionId), and
     // in-app file-viewer embeds; other agent tabs (and external-app embeds) are
     // dropped (no session to restore). Newer snapshots carry `kind`/`sessionId`;
     // fall back to deriving the kind from the command. The saved groups tree
@@ -360,12 +1571,24 @@ export function listenProjectRuntimeSwitched(): Promise<() => void> {
         viewer: t.viewer,
       }),
     );
+    // Mount-free remote: defer restoring a remote project's tabs until its pooled
+    // SSH/SFTP connection is up. Restoring them while disconnected spawns `ssh -tt`
+    // PTYs and SFTP listings that block on the dead pool (the "hang"). The
+    // CenterPanel restore effect — gated on the SSH status reaching "connected" —
+    // performs the restore once the user reconnects via the header lamp.
+    const switchedProject = payload.projectId
+      ? useProjectsStore.getState().projects.find((p) => p.id === payload.projectId) ?? null
+      : null;
+    if (
+      switchedProject?.remote &&
+      useRemoteStatusStore.getState().byProject[payload.projectId ?? ""]?.ssh !== "connected"
+    ) {
+      return;
+    }
     // Only restore from disk if this scope was never initialized this session.
     // An existing (possibly empty) entry means the user's in-memory tabs win.
     if (restorable.length > 0 && !(scopeKey in tabsStore.tabsByScope)) {
-      const project = payload.projectId
-        ? useProjectsStore.getState().projects.find((p) => p.id === payload.projectId) ?? null
-        : null;
+      const project = switchedProject;
       tabsStore.loadFromLayout(
         restorable,
         resolveProjectDirectory(project),
diff --git a/src/stores/remoteMachines.ts b/src/stores/remoteMachines.ts
new file mode 100644
index 0000000..d1435bf
--- /dev/null
+++ b/src/stores/remoteMachines.ts
@@ -0,0 +1,55 @@
+import { create } from "zustand";
+
+/** A global machine handed to a project, awaiting only its shared path
+ *  before `RemoteMachinesWindow` turns it into a `shared_fs` compute host.
+ *  (Named for the drag gesture that used to deliver it; the machine now
+ *  arrives from the header menu's "add to a project" picker instead.) */
+export interface DroppedGlobalMachine {
+  id: string;
+  host: string;
+  user?: string;
+  port?: number;
+  label?: string;
+}
+
+/**
+ * Which remote project's "Remote machines" manager is open, if any (multi-host
+ * remote, `docs/multi_host_remote_plan.md`). A single `<RemoteMachinesDialogHost>`
+ * is mounted once (in AppShell) and reads this store; the pill's Runtime menu item
+ * and a right-click on the pill's remote lamp both open it via `open(projectId)`.
+ * Keyed by an explicit project id — not the active project — so switching projects
+ * never retargets an open manager.
+ *
+ * `pendingDrop` seeds the "confirm shared path" panel when a global machine
+ * (`stores/globalMachines.ts`) is added to this **remote** project — picked from
+ * the header machine menu's "add to a project" list, which calls
+ * `open(projectId, payload)` to open this window with the machine pre-filled.
+ *
+ * `extendTarget` is the same handoff for a **local** project, whose answer is
+ * not a worker but the "Extend to remote" flow — a dialog `ProjectPill` owns.
+ * The picker lists only *open* projects, so the target's pill is mounted and
+ * picks this up in an effect (clearing it). It lives here, beside `pendingDrop`,
+ * because the two are one decision: which of the two ways a machine can join a
+ * project applies to the one that was picked.
+ */
+interface RemoteMachinesDialogStore {
+  projectId: string | null;
+  pendingDrop: DroppedGlobalMachine | null;
+  extendTarget: { projectId: string; machine: DroppedGlobalMachine } | null;
+  open: (projectId: string, pendingDrop?: DroppedGlobalMachine | null) => void;
+  setPendingDrop: (pendingDrop: DroppedGlobalMachine | null) => void;
+  requestExtend: (projectId: string, machine: DroppedGlobalMachine) => void;
+  clearExtend: () => void;
+  close: () => void;
+}
+
+export const useRemoteMachinesStore = create<RemoteMachinesDialogStore>((set) => ({
+  projectId: null,
+  pendingDrop: null,
+  extendTarget: null,
+  open: (projectId, pendingDrop = null) => set({ projectId, pendingDrop }),
+  setPendingDrop: (pendingDrop) => set({ pendingDrop }),
+  requestExtend: (projectId, machine) => set({ extendTarget: { projectId, machine } }),
+  clearExtend: () => set({ extendTarget: null }),
+  close: () => set({ projectId: null, pendingDrop: null }),
+}));
diff --git a/src/stores/remoteStatus.ts b/src/stores/remoteStatus.ts
new file mode 100644
index 0000000..4685c33
--- /dev/null
+++ b/src/stores/remoteStatus.ts
@@ -0,0 +1,132 @@
+import { create } from "zustand";
+
+/**
+ * Live connection state of a remote (SSH) project's two channels:
+ *  - `off`        — not a remote project, or torn down / never opened
+ *  - `connecting` — handshake in flight (orange lamp)
+ *  - `connected`  — channel is up (green lamp)
+ *  - `error`      — the attempt failed (red lamp)
+ */
+export type ConnState = "off" | "connecting" | "connected" | "error";
+
+export interface HostConnState {
+  ssh: ConnState;
+  vpn: ConnState;
+}
+
+const OFF: HostConnState = { ssh: "off", vpn: "off" };
+
+/** The backend id of a project's PRIMARY remote (`docs/multi_host_remote_plan.md`).
+ *  Kept in step with `services::remote::PRIMARY_HOST`. */
+export const PRIMARY_HOST = "primary";
+
+interface RemoteStatusStore {
+  /** PRIMARY-host status, keyed by project id. Kept as the flat, primary-only map
+   *  it has always been so the ~300 file/git/sync readers that only ever care about
+   *  the primary (the file UI stays Local | Remote(primary), plan §6) work
+   *  unchanged. Keyed (not a single active slot) so an in-flight connect for a
+   *  project the user just switched away from can never flip the now-active
+   *  project's lamp — the header reads only the active id's entry. */
+  byProject: Record<string, HostConnState>;
+  /** Extra WORKER-host status (`docs/multi_host_remote_plan.md`), keyed
+   *  `[projectId][hostId]`. The primary is NOT stored here — it lives in
+   *  `byProject`; [`sshOf`]/[`vpnOf`] route `"primary"` to it. */
+  byHost: Record<string, Record<string, HostConnState>>;
+  /** Set a host's SSH lamp. `hostId` defaults to the primary. */
+  setSsh: (projectId: string, state: ConnState, hostId?: string) => void;
+  /** Set a host's VPN lamp. `hostId` defaults to the primary. */
+  setVpn: (projectId: string, state: ConnState, hostId?: string) => void;
+  /** Forget a project's status entirely — primary AND every worker host (on
+   *  deactivation / switch-away). */
+  clear: (projectId: string) => void;
+  /** Forget one worker host's status (host removed / disconnected). */
+  clearHost: (projectId: string, hostId: string) => void;
+}
+
+export const useRemoteStatusStore = create<RemoteStatusStore>((set) => ({
+  byProject: {},
+  byHost: {},
+  setSsh: (projectId, state, hostId = PRIMARY_HOST) =>
+    set((s) => setHostField(s, projectId, hostId, "ssh", state)),
+  setVpn: (projectId, state, hostId = PRIMARY_HOST) =>
+    set((s) => setHostField(s, projectId, hostId, "vpn", state)),
+  clear: (projectId) =>
+    set((s) => {
+      const inProject = projectId in s.byProject;
+      const inHost = projectId in s.byHost;
+      if (!inProject && !inHost) return {};
+      const byProject = { ...s.byProject };
+      delete byProject[projectId];
+      const byHost = { ...s.byHost };
+      delete byHost[projectId];
+      return { byProject, byHost };
+    }),
+  clearHost: (projectId, hostId) =>
+    set((s) => {
+      if (hostId === PRIMARY_HOST) {
+        if (!(projectId in s.byProject)) return {};
+        const byProject = { ...s.byProject };
+        delete byProject[projectId];
+        return { byProject };
+      }
+      const hosts = s.byHost[projectId];
+      if (!hosts || !(hostId in hosts)) return {};
+      const nextHosts = { ...hosts };
+      delete nextHosts[hostId];
+      const byHost = { ...s.byHost };
+      if (Object.keys(nextHosts).length === 0) delete byHost[projectId];
+      else byHost[projectId] = nextHosts;
+      return { byHost };
+    }),
+}));
+
+/** Immutably set one field of one host's lamp, routing the primary to `byProject`
+ *  and any worker to `byHost[projectId][hostId]`. */
+function setHostField(
+  s: RemoteStatusStore,
+  projectId: string,
+  hostId: string,
+  field: keyof HostConnState,
+  value: ConnState,
+): Partial<RemoteStatusStore> {
+  if (hostId === PRIMARY_HOST) {
+    const prev = s.byProject[projectId] ?? OFF;
+    return { byProject: { ...s.byProject, [projectId]: { ...prev, [field]: value } } };
+  }
+  const hosts = s.byHost[projectId] ?? {};
+  const prev = hosts[hostId] ?? OFF;
+  return {
+    byHost: {
+      ...s.byHost,
+      [projectId]: { ...hosts, [hostId]: { ...prev, [field]: value } },
+    },
+  };
+}
+
+/** Read a host's SSH lamp from a store snapshot (`"primary"` → `byProject`). */
+export function sshOf(
+  s: Pick<RemoteStatusStore, "byProject" | "byHost">,
+  projectId: string,
+  hostId: string = PRIMARY_HOST,
+): ConnState {
+  return hostStateOf(s, projectId, hostId).ssh;
+}
+
+/** Read a host's VPN lamp from a store snapshot (`"primary"` → `byProject`). */
+export function vpnOf(
+  s: Pick<RemoteStatusStore, "byProject" | "byHost">,
+  projectId: string,
+  hostId: string = PRIMARY_HOST,
+): ConnState {
+  return hostStateOf(s, projectId, hostId).vpn;
+}
+
+/** A host's full `{ssh, vpn}` from a store snapshot, or `{off, off}` when absent. */
+export function hostStateOf(
+  s: Pick<RemoteStatusStore, "byProject" | "byHost">,
+  projectId: string,
+  hostId: string = PRIMARY_HOST,
+): HostConnState {
+  if (hostId === PRIMARY_HOST) return s.byProject[projectId] ?? OFF;
+  return s.byHost[projectId]?.[hostId] ?? OFF;
+}
diff --git a/src/stores/remoteUsage.ts b/src/stores/remoteUsage.ts
new file mode 100644
index 0000000..10a5752
--- /dev/null
+++ b/src/stores/remoteUsage.ts
@@ -0,0 +1,139 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+
+/**
+ * Host usage reports — who's logged in, CPU/load, memory, GPU, top processes
+ * (see `services::remote_usage` for the probe).
+ *
+ * **On demand only.** The dialog is opened by the header Machines menu's
+ * "Remote host usage…" button and by nothing else — a connect no longer pops it
+ * up. `remote_connect` still fires its probe fire-and-forget and emits a
+ * `remote-usage-report` event per project host; this store keeps those reports
+ * so the dialog has something to show the instant it opens, but receiving one
+ * never puts it on screen.
+ *
+ * **Keyed by host, not by project.** The dialog lives in the *Machines* menu, so
+ * its subject is the machine list: every global machine, in that list's order,
+ * plus whichever of the active project's own hosts aren't already in it. A
+ * project id can't key that, hence [`UsageTarget`] and its `key` — and hence two
+ * probe commands behind one `recheck`: a global machine authenticates ad-hoc
+ * (`global_machine_usage_check`), a project host rides its pooled ControlMaster
+ * (`remote_usage_check`). Both run the same script through the same parser, so
+ * the two kinds of section read identically.
+ */
+
+export interface UserSession {
+  user: string;
+  tty: string;
+  detail: string;
+}
+
+export interface ProcInfo {
+  user: string;
+  pid: string;
+  cpuPct: number;
+  memPct: number;
+  command: string;
+}
+
+/** One NVIDIA GPU's utilization + memory (NVIDIA-only — see backend doc). */
+export interface GpuUsage {
+  name: string;
+  utilPct: number;
+  memUsedMb: number;
+  memTotalMb: number;
+}
+
+/** Mirrors `services::remote_usage::RemoteUsageReport` (camelCase). */
+export interface RemoteUsageReport {
+  users: UserSession[];
+  /** Instantaneous CPU usage (0-100), measured via /proc/stat, not load average. */
+  cpuPct: number;
+  load1: number;
+  load5: number;
+  load15: number;
+  cpuCount: number;
+  memTotalMb: number;
+  memUsedMb: number;
+  /** NVIDIA GPUs only; empty on a GPU-less/AMD/Intel-only host. */
+  gpus: GpuUsage[];
+  topProcs: ProcInfo[];
+  busy: boolean;
+  reasons: string[];
+  /** The host reported itself an HPC node (SLURM on its `PATH`), so this report
+   *  was taken carefully: `users` holds only this account's own sessions and
+   *  `topProcs` only its own processes — a cluster's usage rules don't allow
+   *  collecting other people's (`docs/context/hpc_careful_mode.md`). The
+   *  aggregate CPU/memory/GPU figures are unaffected. On such a host the probe
+   *  also stops firing automatically after the first connect; the report is
+   *  on-demand from the Machines menu. */
+  careful?: boolean;
+}
+
+/** One host the dialog shows a section for. `kind` decides which probe command
+ *  reads it; `key` is how its report is stored and must be stable across
+ *  reopens (so a cached report survives). */
+export type UsageTarget =
+  | {
+      kind: "machine";
+      key: string;
+      label: string;
+      user?: string;
+      host: string;
+      port?: number;
+    }
+  | { kind: "projectHost"; key: string; label: string; projectId: string; hostId: string };
+
+/** Report key for a global machine (`stores/globalMachines` id). */
+export const machineKey = (id: string) => `gm:${id}`;
+/** Report key for one of a project's own hosts (`"primary"` or a worker id). */
+export const projectHostKey = (projectId: string, hostId: string) =>
+  `ph:${projectId}:${hostId}`;
+
+interface RemoteUsageStore {
+  /** Latest report per [`UsageTarget`] key. */
+  reports: Record<string, RemoteUsageReport>;
+  /** Whether the usage dialog is on screen. The ONLY thing that sets it is the
+   *  Machines menu's "Remote host usage…" button — an arriving report never
+   *  does, which is what makes the dialog on-demand rather than a connect-time
+   *  popup. */
+  isOpen: boolean;
+  setReport: (key: string, report: RemoteUsageReport) => void;
+  open: () => void;
+  close: () => void;
+  /** On-demand read of one host, awaited directly rather than round-tripped
+   *  through the connect-time event. Best-effort: a failed probe (host down,
+   *  credential gone) leaves whatever was cached, so a machine that can't be
+   *  reached simply shows no reading instead of tearing down the dialog. */
+  recheck: (target: UsageTarget) => Promise<void>;
+}
+
+export const useRemoteUsageStore = create<RemoteUsageStore>((set) => ({
+  reports: {},
+  isOpen: false,
+
+  setReport: (key, report) => set((s) => ({ reports: { ...s.reports, [key]: report } })),
+
+  open: () => set({ isOpen: true }),
+  close: () => set({ isOpen: false }),
+
+  recheck: async (target) => {
+    try {
+      const report =
+        target.kind === "machine"
+          ? await invoke<RemoteUsageReport>("global_machine_usage_check", {
+              user: target.user,
+              host: target.host,
+              port: target.port,
+            })
+          : await invoke<RemoteUsageReport>("remote_usage_check", {
+              projectId: target.projectId,
+              hostId: target.hostId,
+            });
+      set((s) => ({ reports: { ...s.reports, [target.key]: report } }));
+    } catch {
+      // Best-effort, like the connect-time probe — a failed recheck just
+      // leaves the previous report (or none) in place.
+    }
+  },
+}));
diff --git a/src/stores/runHostPref.ts b/src/stores/runHostPref.ts
new file mode 100644
index 0000000..bb0f92b
--- /dev/null
+++ b/src/stores/runHostPref.ts
@@ -0,0 +1,58 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+import type { TabLocation } from "./tabs";
+
+/**
+ * "Which machine should scripts and shells launched from this project run on"
+ * preference, keyed by project id (`docs/multi_host_remote_plan.md`). Set from the
+ * `RunHostPicker`, read at launch time by `lib/pythonRun`, `lib/shellScriptRun`,
+ * and `stores/tabs`' new-shell-tab funnel so a Run/Debug or a "+" shell lands on
+ * the chosen host (primary or a worker) instead of the shell default.
+ *
+ * The picker + this preference apply to EVERY remote project, including a
+ * genuinely multi-machine one with a synced-code worker: a Run opens a fresh tab,
+ * so the per-tab locality badge can't pre-target it — the project-wide picker is
+ * the only control that can send a run to a worker.
+ *
+ * This live store is the read cache; the value is **persisted** per project (in
+ * `project.json`'s `run_host`, mirrored into `projects.json`) so the choice
+ * survives a relaunch. `set` writes through to the backend; `seed` re-hydrates the
+ * cache from the loaded projects on startup (see `stores/projects` `load`). Unset ⇒
+ * the tab's own kind default (a shell defaults to the primary on a remote project),
+ * so a project that never touches the picker behaves exactly as before. A value is
+ * a `TabLocation` (`"local" | "remote" | "host:<id>"`), the same axis a tab's
+ * locality badge sets, so the run tab carries it verbatim.
+ */
+interface RunHostPrefStore {
+  byProject: Record<string, TabLocation>;
+  /** Set (and persist) the run host for a project. The store updates immediately;
+   *  the disk write is fire-and-forget (a failure only means it won't survive a
+   *  relaunch — never worth blocking the click or the run). */
+  set: (projectId: string, location: TabLocation) => void;
+  /** Re-hydrate the cache from the persisted per-project values on load. Merges
+   *  (never clobbers a choice already made this session), so it is safe to call on
+   *  every projects reload. */
+  seed: (entries: { projectId: string; location: TabLocation | undefined }[]) => void;
+}
+
+export const useRunHostPrefStore = create<RunHostPrefStore>((set) => ({
+  byProject: {},
+  set: (projectId, location) => {
+    set((s) => ({ byProject: { ...s.byProject, [projectId]: location } }));
+    void invoke("set_project_run_host", { projectId, location }).catch((e) =>
+      console.error(`persist run host for ${projectId} failed`, e),
+    );
+  },
+  seed: (entries) =>
+    set((s) => {
+      const byProject = { ...s.byProject };
+      for (const { projectId, location } of entries) {
+        // A choice already made this session wins over the persisted one (they
+        // can only differ if the user just changed it before this reload).
+        if (location && byProject[projectId] === undefined) {
+          byProject[projectId] = location;
+        }
+      }
+      return { byProject };
+    }),
+}));
diff --git a/src/stores/scrollSync.ts b/src/stores/scrollSync.ts
new file mode 100644
index 0000000..4d8636f
--- /dev/null
+++ b/src/stores/scrollSync.ts
@@ -0,0 +1,145 @@
+import { useEffect, useRef, type RefObject } from "react";
+import { create } from "zustand";
+
+/**
+ * Proportional scroll-linking between two side-by-side viewer subwindows.
+ *
+ * When the user links two adjacent viewer subwindows (text/code/markdown/PDF)
+ * via the divider button, scrolling one drives the other by RATIO — content
+ * heights differ, so this mirrors `CompareView`'s 3-pane `syncFrom` rather than
+ * copying a raw `scrollTop`. Links are keyed by **group id** (a subwindow), held
+ * symmetrically (`links[a]=b` and `links[b]=a`), and are ephemeral: they live
+ * only in memory and are pruned when either endpoint stops being a syncable
+ * viewer (see `CenterPanel`), matching the ephemeral `fullscreenGroupId` model.
+ *
+ * Each mounted viewer registers a `ScrollHandle` for its group id (via the
+ * `useScrollSync` hook) and reports its scroll ratio; the store forwards that
+ * ratio to the linked partner's handle. A module-level `suppress` flag +
+ * `requestAnimationFrame` breaks the feedback loop, exactly as `CompareView`
+ * guards its own sync.
+ */
+export interface ScrollHandle {
+  /** Scroll this pane to a normalized [0,1] ratio of its scrollable height. */
+  applyRatio: (ratio: number) => void;
+}
+
+interface ScrollSyncState {
+  /** Symmetric adjacency: `links[a] === b` iff a and b are linked. */
+  links: Record<string, string>;
+  /** Live per-group scroll handles. A plain Map (non-reactive) — only `links`
+   *  drives re-renders (the divider button); scroll forwarding reads handles
+   *  imperatively. */
+  handles: Map<string, ScrollHandle>;
+  isLinked: (a: string, b: string) => boolean;
+  /** Link a↔b if unlinked, otherwise unlink them. */
+  toggleLink: (a: string, b: string) => void;
+  register: (groupId: string, h: ScrollHandle) => () => void;
+  /** Push `groupId`'s current scroll ratio to its linked partner (if any). */
+  report: (groupId: string, ratio: number) => void;
+  /** Drop any link whose endpoints are no longer both valid syncable groups. */
+  prune: (validGroups: Set<string>) => void;
+}
+
+// Re-entrancy guard: true while we're applying a ratio to a partner pane. A
+// handler that scrolls synchronously in response (or a test that models the
+// induced scroll inline) must NOT bounce back as a fresh `report`. Held only for
+// the synchronous span of `applyRatio` (cleared in `finally`) — the real,
+// asynchronous scroll event the mirrored write triggers is harmless on its own:
+// it re-applies the originator's *current* position, which doesn't move it, so
+// no further scroll event fires and the exchange converges without the guard.
+let suppress = false;
+
+export const useScrollSyncStore = create<ScrollSyncState>((set, get) => ({
+  links: {},
+  handles: new Map(),
+  isLinked: (a, b) => get().links[a] === b,
+  toggleLink: (a, b) =>
+    set((s) => {
+      const next = { ...s.links };
+      if (next[a] === b) {
+        delete next[a];
+        delete next[b];
+      } else {
+        // A group links to at most one partner; drop any prior pairing on both
+        // sides before forming the new one so `links` stays a clean matching.
+        if (next[a]) delete next[next[a]];
+        if (next[b]) delete next[next[b]];
+        next[a] = b;
+        next[b] = a;
+      }
+      return { links: next };
+    }),
+  register: (groupId, h) => {
+    get().handles.set(groupId, h);
+    return () => {
+      // Only remove if it's still ours (a remount may have replaced it).
+      if (get().handles.get(groupId) === h) get().handles.delete(groupId);
+    };
+  },
+  report: (groupId, ratio) => {
+    if (suppress) return;
+    const partner = get().links[groupId];
+    if (!partner) return;
+    const handle = get().handles.get(partner);
+    if (!handle) return;
+    suppress = true;
+    try {
+      handle.applyRatio(ratio);
+    } finally {
+      suppress = false;
+    }
+  },
+  prune: (validGroups) =>
+    set((s) => {
+      let changed = false;
+      const next = { ...s.links };
+      for (const [a, b] of Object.entries(s.links)) {
+        if (!validGroups.has(a) || !validGroups.has(b)) {
+          delete next[a];
+          delete next[b];
+          changed = true;
+        }
+      }
+      return changed ? { links: next } : {};
+    }),
+}));
+
+/**
+ * Wire a viewer's scroll container into the scroll-sync store for `groupId`.
+ *
+ * Registers an `applyRatio` handle (which sets `scrollTop` on `elRef` while the
+ * store's suppress guard is up) and returns an `onScroll` handler the caller
+ * attaches to that same container. No-op when `groupId` is null/undefined (the
+ * pane isn't placed in a syncable group) or the ref is empty. The handle is
+ * re-registered whenever `groupId` changes.
+ */
+export function useScrollSync(
+  groupId: string | null | undefined,
+  elRef: RefObject<HTMLElement>,
+): () => void {
+  useEffect(() => {
+    if (!groupId) return;
+    const handle: ScrollHandle = {
+      applyRatio: (ratio) => {
+        const el = elRef.current;
+        if (!el) return;
+        const max = el.scrollHeight - el.clientHeight;
+        if (max > 0) el.scrollTop = ratio * max;
+      },
+    };
+    return useScrollSyncStore.getState().register(groupId, handle);
+  }, [groupId, elRef]);
+
+  // Stable onScroll: reads the live ref + groupId through a ref so attaching it
+  // once (uncontrolled) still reports against the current group.
+  const gidRef = useRef(groupId);
+  gidRef.current = groupId;
+  const onScrollRef = useRef(() => {
+    const gid = gidRef.current;
+    const el = elRef.current;
+    if (!gid || !el) return;
+    const max = el.scrollHeight - el.clientHeight;
+    useScrollSyncStore.getState().report(gid, max > 0 ? el.scrollTop / max : 0);
+  });
+  return onScrollRef.current;
+}
diff --git a/src/stores/settings.ts b/src/stores/settings.ts
index 3a4c606..5fe5a46 100644
--- a/src/stores/settings.ts
+++ b/src/stores/settings.ts
@@ -1,26 +1,144 @@
 import { invoke } from "@tauri-apps/api/core";
+import { getCurrentWebview } from "@tauri-apps/api/webview";
+import { emit } from "@tauri-apps/api/event";
 import { create } from "zustand";
-import type { Settings, Theme } from "../types";
+import type { Settings, Theme, WindowState } from "../types";
+import { applyLanguage, type Language } from "../lib/i18n";
 
-function applyTheme(scheme: string) {
+/** Each Tauri window is its own JS runtime with its own copy of this store, so
+ *  a theme change made in one (normally the main window's Settings dialog)
+ *  only calls `applyTheme` on that window's own `document` — a detached/popped-
+ *  out subwindow (`DetachedApp`) keeps whatever theme it loaded at open time.
+ *  Broadcast the new scheme so every live window can re-apply it; see the
+ *  listener in `DetachedApp`. */
+export const THEME_CHANGED_EVENT = "eldrun:theme-changed";
+
+/** Like THEME_CHANGED_EVENT, but for the UI language: broadcast so every live
+ *  window (including detached popouts, which each hold their own i18n store)
+ *  re-applies the new language. See the listener in `DetachedApp`. */
+export const LANGUAGE_CHANGED_EVENT = "eldrun:language-changed";
+
+export function applyTheme(scheme: string) {
   document.documentElement.setAttribute("data-theme", scheme);
+  // Cache for index.html's pre-paint inline script, so the next launch
+  // paints the right theme immediately instead of flashing the CSS
+  // :root default until settings arrive over the async invoke.
+  try {
+    localStorage.setItem("eldrun-theme", scheme);
+  } catch {
+    // localStorage unavailable — worst case is the old one-frame flash.
+  }
+}
+
+/** UI zoom (4K-monitor scaling). `1` is 100% (the current/default look); higher
+ *  enlarges the whole interface, lower shrinks it. Applied via the webview's
+ *  native zoom so every layer scales — including `position: fixed` / portaled
+ *  overlays (menus, dropdowns, hover popovers) that a CSS `zoom` misses on
+ *  WebKitGTK.
+ *
+ *  Zoom is **per window**, not global: each OS window (the main window and every
+ *  detached popout, #42) is its own webview and holds its own zoom. `ui_zoom`
+ *  persists the MAIN window's value; a popout persists its own alongside its
+ *  bounds (see `DetachedGroup.zoom`). So bumping one window's zoom never rescales
+ *  another, and each window restores at the zoom it was left at. */
+export const MIN_UI_ZOOM = 0.5;
+export const MAX_UI_ZOOM = 3;
+
+/** The zoom ladder shared by the Settings dropdown and the Ctrl +/- keyboard
+ *  steps, so both surfaces move through the same stops. */
+export const ZOOM_STEPS = [0.5, 0.75, 0.9, 1, 1.1, 1.25, 1.5, 1.75, 2, 2.5, 3];
+
+export function clampZoom(z: number | undefined | null): number {
+  if (typeof z !== "number" || !Number.isFinite(z)) return 1;
+  return Math.min(MAX_UI_ZOOM, Math.max(MIN_UI_ZOOM, z));
+}
+
+/** Next zoom stop up (`dir > 0`) or down (`dir < 0`) from `current` on the
+ *  `ZOOM_STEPS` ladder, for the Ctrl +/- keyboard shortcuts. Clamped to the ends. */
+export function stepZoom(current: number | undefined, dir: 1 | -1): number {
+  const cur = clampZoom(current);
+  if (dir > 0) {
+    const up = ZOOM_STEPS.find((z) => z > cur + 1e-6);
+    return up ?? MAX_UI_ZOOM;
+  }
+  const down = [...ZOOM_STEPS].reverse().find((z) => z < cur - 1e-6);
+  return down ?? MIN_UI_ZOOM;
+}
+
+/** Apply a zoom to THIS window's webview (native WebKitGTK `zoom_level` /
+ *  WebView2 ZoomFactor). Exported so a detached popout can drive its OWN zoom
+ *  (the popout skips the global apply in `load` and owns its value; see
+ *  DetachedApp). CSS `zoom` on the root is deliberately not used: it does not
+ *  scale `position: fixed` / portaled overlays in WebKitGTK, so those stayed at
+ *  100%. Native zoom scales the entire webview uniformly, overlays included. */
+export function applyZoom(zoom: number | undefined) {
+  const z = clampZoom(zoom);
+  void getCurrentWebview()
+    .setZoom(z)
+    .catch((err) => {
+      console.warn("failed to apply UI zoom", err);
+    });
 }
 
 interface SettingsStore {
   settings: Settings | null;
   loaded: boolean;
-  load: () => Promise<void>;
+  /** Load settings and apply theme. `skipZoom` suppresses applying the persisted
+   *  `ui_zoom` to this window's webview — used by a detached popout, which owns
+   *  its OWN zoom (restored from its seed) rather than the main window's. */
+  load: (opts?: { skipZoom?: boolean }) => Promise<void>;
   setTheme: (theme: Theme) => Promise<void>;
+  setLanguage: (lang: Language) => Promise<void>;
   updateSettings: (patch: Partial<Settings>) => Promise<void>;
+  saveWindowState: (ws: WindowState) => Promise<void>;
+  /** Set (or clear, with "") the Python Run/Debug args for one file, keyed by its
+   *  absolute path. Kept per file so every viewer of the same script shares them;
+   *  persisted in settings.json so they survive a restart (see Settings.python_run_args). */
+  setPythonRunArgs: (path: string, args: string) => Promise<void>;
+}
+
+/**
+ * Resolve once settings have loaded — or after `timeoutMs`, whichever comes first.
+ *
+ * Every gate that decides whether Eldrun may reach a host **without a gesture**
+ * reads settings (`lib/hpcHost`'s `mayAutoTouch`, `machines_enabled`) and every one
+ * of them fails closed on an unloaded store. That is the right default, and its
+ * consequence is that the launch sweeps must *wait* rather than fire into the gap:
+ * `AppShell` starts this load in parallel with the projects load, so the answer is
+ * milliseconds away, and firing first would either skip a project that is perfectly
+ * eligible or — before the gates existed — dial a tagged cluster.
+ *
+ * It waits; it never loads. A second `get_settings` from a background caller would
+ * re-apply the theme and this window's zoom as a side effect. On timeout the caller
+ * proceeds against an unloaded store, i.e. every gate answers "no" — the failure
+ * mode is "nothing connected", never "something connected blind".
+ */
+export function whenSettingsLoaded(timeoutMs = 5000): Promise<void> {
+  if (useSettingsStore.getState().loaded) return Promise.resolve();
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer);
+      unsubscribe();
+      resolve();
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    const unsubscribe = useSettingsStore.subscribe((s) => {
+      if (s.loaded) finish();
+    });
+  });
 }
 
 export const useSettingsStore = create<SettingsStore>((set, get) => ({
   settings: null,
   loaded: false,
 
-  load: async () => {
+  load: async (opts) => {
     const settings = await invoke<Settings>("get_settings");
     applyTheme(settings.color_scheme ?? "fancy_dark");
+    applyLanguage(settings.language);
+    // `ui_zoom` is the MAIN window's own zoom. A popout skips it and applies its
+    // own persisted zoom from its seed instead (zoom is per window, not global).
+    if (!opts?.skipZoom) applyZoom(settings.ui_zoom);
     set({ settings, loaded: true });
   },
 
@@ -29,6 +147,16 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     const updated = { ...current, color_scheme: theme };
     await invoke<void>("save_settings", { settings: updated });
     applyTheme(theme);
+    void emit(THEME_CHANGED_EVENT, theme);
+    set({ settings: updated as Settings });
+  },
+
+  setLanguage: async (lang) => {
+    const current = get().settings ?? {};
+    const updated = { ...current, language: lang };
+    await invoke<void>("save_settings", { settings: updated });
+    applyLanguage(lang);
+    void emit(LANGUAGE_CHANGED_EVENT, lang);
     set({ settings: updated as Settings });
   },
 
@@ -38,7 +166,50 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
     await invoke<void>("save_settings", { settings: updated });
     if (typeof updated.color_scheme === "string") {
       applyTheme(updated.color_scheme);
+      if ("color_scheme" in patch) {
+        void emit(THEME_CHANGED_EVENT, updated.color_scheme);
+      }
+    }
+    if ("ui_zoom" in patch) {
+      applyZoom(updated.ui_zoom);
     }
     set({ settings: updated as Settings });
   },
+
+  // Persist the main window's geometry through its OWN command rather than
+  // `updateSettings`. This fires on a debounce every time the user drags or
+  // resizes the window, and `updateSettings` writes the *whole* settings object
+  // back from this cache — so routing it there would rewrite the entire settings
+  // file on every window nudge and clobber anything changed elsewhere meanwhile.
+  // `save_window_state` read-modify-writes the single field on disk.
+  //
+  // The local cache is still updated, for two reasons: the debounced save diffs
+  // against it to skip no-op writes, and a later `updateSettings` spreads this
+  // cache — a stale `window_state` here would be written straight back over the
+  // fresh one on disk.
+  saveWindowState: async (ws) => {
+    const current = get().settings;
+    if (!current) return;
+    set({ settings: { ...current, window_state: ws } });
+    try {
+      await invoke<void>("save_window_state", { state: ws });
+    } catch (err) {
+      console.warn("failed to save window state", err);
+    }
+  },
+
+  setPythonRunArgs: async (path, args) => {
+    const current = get().settings ?? {};
+    const map = { ...(current.python_run_args ?? {}) };
+    const trimmed = args.trim();
+    // "" clears the entry outright rather than storing an empty string, so the map
+    // holds only files that actually have args (and reading back a cleared file
+    // yields undefined → "", identical to never having set it).
+    if (trimmed) map[path] = trimmed;
+    else delete map[path];
+    // No-op if nothing changed, so re-committing identical args (e.g. the popover's
+    // outside-click after a run) doesn't rewrite the whole settings file.
+    if ((current.python_run_args ?? {})[path] === map[path]) return;
+    await get().updateSettings({ python_run_args: map });
+  },
 }));
diff --git a/src/stores/subwindowNav.ts b/src/stores/subwindowNav.ts
new file mode 100644
index 0000000..38d0cac
--- /dev/null
+++ b/src/stores/subwindowNav.ts
@@ -0,0 +1,31 @@
+import { create } from "zustand";
+
+/**
+ * Transient state for keyboard-driven subwindow navigation (Shift+↑/↓).
+ *
+ * Kept separate from the tabs store so entering/stepping the preview doesn't
+ * churn the layout tree or move the real focus — focus only commits (via
+ * `tabs.focusGroup`) when Shift is released. While `active`, `CenterPanel`'s
+ * `FocusFrameOverlay` shows numbered badges over every subwindow and draws the
+ * focus frame on `previewGroupId` instead of the committed focused group.
+ *
+ * `useKeyboard` mutates this imperatively via `getState()`; the overlay
+ * subscribes reactively.
+ */
+interface SubwindowNavState {
+  /** Nav mode on → badges visible, frame follows `previewGroupId`. */
+  active: boolean;
+  /** Group the preview frame currently sits on (null when inactive). */
+  previewGroupId: string | null;
+  /** Enter/continue nav mode, moving the preview to `groupId`. */
+  preview: (groupId: string) => void;
+  /** Leave nav mode (hide badges, drop the preview). */
+  end: () => void;
+}
+
+export const useSubwindowNavStore = create<SubwindowNavState>((set) => ({
+  active: false,
+  previewGroupId: null,
+  preview: (groupId) => set({ active: true, previewGroupId: groupId }),
+  end: () => set({ active: false, previewGroupId: null }),
+}));
diff --git a/src/stores/sync.ts b/src/stores/sync.ts
new file mode 100644
index 0000000..1d4776a
--- /dev/null
+++ b/src/stores/sync.ts
@@ -0,0 +1,381 @@
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { create } from "zustand";
+
+/**
+ * SSH-sync Phase 1 — frontend cache of each remote project's sync manifest plus a
+ * subscription to the backend `sync-progress` stream. The remote file view reads
+ * `byProject[projectId][relPath]` to overlay green/amber beside the git marker and
+ * to drive the "sync this / stop syncing" affordance; `progressByProject` drives
+ * the in-flight transfer indicator. The backend (`commands::sync`) is the source
+ * of truth — every action here calls it, then refreshes the cached status.
+ * Plan: docs/ssh_sync_plan.md.
+ */
+
+export type SyncFileState = "green" | "amber" | "none";
+
+/** One status row as returned by the `sync_status` command. */
+interface SyncStatusEntry {
+  rel_path: string;
+  is_dir: boolean;
+  selected: boolean;
+  state: SyncFileState;
+  /** Effective auto-sync (own entry or an ancestor auto folder marker). */
+  auto_sync: boolean;
+  /** This path's OWN byte-sync exclusion marker (not an inherited one). */
+  excluded: boolean;
+  /** Current host modification time, when the sync-status probe reported one. */
+  host_mtime: number | null;
+  /** Current local-mirror modification time, when known. */
+  local_mtime: number | null;
+}
+
+/** Payload of the backend `sync-progress` event. */
+interface SyncProgress {
+  project_id: string;
+  /** "start" | "file" | "done" */
+  phase: string;
+  rel_path: string;
+  done: number;
+  total: number;
+}
+
+/** Cached per-path status (the shape consumers read). */
+export interface SyncEntryStatus {
+  state: SyncFileState;
+  selected: boolean;
+  isDir: boolean;
+  /** Whether this path auto-syncs (own flag or an ancestor auto folder). */
+  auto: boolean;
+  /** Carries its own "excluded from byte-sync" marker (giant-folder prompt or
+   *  the tree's own Exclude item). Inherited exclusion is the backend's to
+   *  resolve; this is what flips the menu item's label. */
+  excluded: boolean;
+  /** Current host modification time, for the diverged-files list. */
+  hostMtime: number | null;
+  /** Current local-mirror modification time, for the diverged-files list. */
+  localMtime: number | null;
+}
+
+/** One side (local mirror or host) of a tracked file, from `sync_file_meta`. */
+export interface SyncSideMeta {
+  exists: boolean;
+  size: number;
+  /** Unix seconds, or null when the side reports none. */
+  mtime: number | null;
+}
+
+/** Local + host metadata for a tracked file (backs the amber resolve popup). */
+export interface SyncFileMeta {
+  rel_path: string;
+  local: SyncSideMeta;
+  host: SyncSideMeta;
+  base_size: number;
+  base_mtime: number | null;
+}
+
+/** Size of the host subtree an auto-sync toggle would put in scope
+ *  (`sync_auto_preview`). Byte-sync ignores `.gitignore`, so this is what stands
+ *  between a right-click and a multi-GB experiment tree landing in the mirror. */
+export interface AutoSyncPreview {
+  files: number;
+  bytes: number;
+}
+
+/** One folder big enough to be worth asking about before the first sync pass
+ *  (`sync_big_folders`), with what each side holds. A folder present on only one
+ *  side reports zeros for the other — which is itself the useful answer. */
+export interface BigFolderRow {
+  rel: string;
+  localFiles: number;
+  localBytes: number;
+  hostFiles: number;
+  hostBytes: number;
+  excluded: boolean;
+}
+
+/** The giant-folder census. `hostScanned` is false when the project was not
+ *  connected — the rows then carry local numbers only and the caller re-runs
+ *  once the pool comes up. */
+export interface BigFolderScan {
+  folders: BigFolderRow[];
+  hostScanned: boolean;
+  hostError: string | null;
+}
+
+/** Live transfer progress for a project (null when idle). */
+export interface SyncProgressState {
+  rel: string;
+  done: number;
+  total: number;
+}
+
+interface SyncStore {
+  /** projectId → (project-relative path → status). */
+  byProject: Record<string, Record<string, SyncEntryStatus>>;
+  /** projectId → in-flight transfer progress, or null when idle. */
+  progressByProject: Record<string, SyncProgressState | null>;
+
+  /** Re-stat the host for the project's selected files and refresh the cache. */
+  refreshStatus: (projectId: string) => Promise<void>;
+  /** Fetch local+host metadata for one file (backs the amber resolve popup). */
+  fileMeta: (projectId: string, relPath: string) => Promise<SyncFileMeta>;
+  /** Pull one file or a whole folder subtree into the mirror, then refresh. */
+  pull: (projectId: string, relPath: string) => Promise<void>;
+  /** Pull the whole project tree into the mirror. */
+  syncWholeProject: (projectId: string) => Promise<void>;
+  /** Push the whole local mirror to the host, skipping host-diverged (amber)
+   *  files (force=false → conflicts are returned, not clobbered). */
+  pushWholeProject: (
+    projectId: string,
+  ) => Promise<{ pushed: number; conflicts: string[] }>;
+  /** Re-pull every selected file (reconcile; clears amber). */
+  syncNow: (projectId: string) => Promise<void>;
+  /** Push a local mirror file/folder to the host. Blocks stale files (returned in
+   *  `conflicts`) unless `force`; the caller prompts and re-calls per conflict. */
+  push: (
+    projectId: string,
+    relPath: string,
+    force?: boolean,
+  ) => Promise<{ pushed: number; conflicts: string[] }>;
+  /** Resolve a batch of diverged files by taking one side for every path at once:
+   *  "host" pulls each (host overwrites the mirror), "local" force-pushes each
+   *  (the mirror overwrites the host). Refreshes the status once at the end rather
+   *  than per file. Backs the orange view's "…for all" buttons. */
+  resolveAll: (
+    projectId: string,
+    relPaths: string[],
+    side: "host" | "local",
+  ) => Promise<void>;
+  /** Toggle the selected flag for paths without transferring (deselect = stop). */
+  markSelected: (
+    projectId: string,
+    relPaths: string[],
+    selected: boolean,
+    isDir: boolean,
+  ) => Promise<void>;
+  /** Toggle auto-sync for paths (on a folder = its whole subtree). Turning on
+   *  implies selected; the backend engine reconciles on its next pass. */
+  setAuto: (
+    projectId: string,
+    relPaths: string[],
+    auto: boolean,
+    isDir: boolean,
+  ) => Promise<void>;
+  /** What auto-syncing `relPath` would start pulling from the host. Read-only —
+   *  the caller confirms a large answer before committing to `setAuto`. */
+  autoPreview: (projectId: string, relPath: string) => Promise<AutoSyncPreview>;
+  /** Census the folders too big to sync silently, on BOTH sides (mirror + host).
+   *  Read-only; the host half is skipped when the project isn't connected.
+   *
+   *  `scanHost` (default true) is what a **careful** host turns off: the host half
+   *  is a recursive `du -ak -x`, which on a cluster runs against a parallel
+   *  filesystem's metadata server. Passing false keeps the local walk and skips
+   *  the host entirely, leaving `hostScanned` false. See `lib/carefulHost.ts`. */
+  bigFolders: (projectId: string, scanHost?: boolean) => Promise<BigFolderScan>;
+  /** Record (or lift) an explicit byte-sync exclusion for folders. Stronger than
+   *  `setAuto(false)`: the whole-project pull and push skip an excluded tree too.
+   *  Never deletes — mirror bytes already present stay put. */
+  setExcluded: (
+    projectId: string,
+    relPaths: string[],
+    excluded: boolean,
+  ) => Promise<void>;
+}
+
+function indexStatus(rows: SyncStatusEntry[]): Record<string, SyncEntryStatus> {
+  const out: Record<string, SyncEntryStatus> = {};
+  for (const r of rows) {
+    out[r.rel_path] = {
+      state: r.state,
+      selected: r.selected,
+      isDir: r.is_dir,
+      auto: r.auto_sync,
+      excluded: r.excluded,
+      hostMtime: r.host_mtime,
+      localMtime: r.local_mtime,
+    };
+  }
+  return out;
+}
+
+/**
+ * All project-relative paths currently diverged (amber/orange) for a project,
+ * from the cached status. Backs the right-panel "orange files" list and the
+ * toolbar count badge. Reads the passed-in map so callers subscribe to it.
+ */
+export function amberPaths(
+  byPath: Record<string, SyncEntryStatus> | undefined,
+): string[] {
+  if (!byPath) return [];
+  return Object.entries(byPath)
+    .filter(([, s]) => s.state === "amber")
+    .map(([rel]) => rel)
+    .sort();
+}
+
+/**
+ * Effective (own-marker-OR-inherited) byte-sync exclusion for `rel`, mirroring
+ * the backend's `remote_sync::is_excluded(manifest, rel, "")` nearest-marker
+ * walk: `rel`'s own entry, then each ancestor DIRECTORY entry, root last. The
+ * first entry with its own `excluded` wins; a nearer `auto` re-includes a path
+ * inside an excluded ancestor tree. Root ("") is never itself consulted here
+ * (mirrors the backend's `under === ""` skip), only used as the walk's floor.
+ * Cheap to call per row — `byPath` already holds every manifest entry the tree
+ * needs (no extra fetch), same map `amberPaths`/the per-row sync slot read.
+ */
+export function isPathExcluded(
+  byPath: Record<string, SyncEntryStatus> | undefined,
+  rel: string,
+): boolean {
+  if (!byPath) return false;
+  let cur = rel;
+  for (;;) {
+    if (cur !== "") {
+      const e = byPath[cur];
+      if (e && (e.isDir || cur === rel)) {
+        if (e.excluded) return true;
+        if (e.auto) return false;
+      }
+    }
+    const idx = cur.lastIndexOf("/");
+    if (idx >= 0) cur = cur.slice(0, idx);
+    else if (cur !== "") cur = "";
+    else return false;
+  }
+}
+
+export const useSyncStore = create<SyncStore>((set, get) => ({
+  byProject: {},
+  progressByProject: {},
+
+  refreshStatus: async (projectId) => {
+    try {
+      const rows = await invoke<SyncStatusEntry[]>("sync_status", { projectId });
+      set((s) => ({
+        byProject: { ...s.byProject, [projectId]: indexStatus(rows) },
+      }));
+    } catch (e) {
+      // A disconnected/local project just has no sync status — don't surface it.
+      console.debug("sync_status failed", e);
+    }
+  },
+
+  fileMeta: async (projectId, relPath) =>
+    invoke<SyncFileMeta>("sync_file_meta", { projectId, relPath }),
+
+  pull: async (projectId, relPath) => {
+    await invoke("sync_pull", { projectId, relPath });
+    await get().refreshStatus(projectId);
+  },
+
+  syncWholeProject: async (projectId) => {
+    await invoke("sync_whole_project", { projectId });
+    await get().refreshStatus(projectId);
+  },
+
+  // Whole-mirror push counterpart to `syncWholeProject`. Reuses `push` with an
+  // empty rel (the whole mirror) and force=false, so host-diverged (amber) files
+  // come back in `conflicts` and are never overwritten — the toolbar caller just
+  // fires it and lets the tree overlay show what stayed orange.
+  pushWholeProject: async (projectId) => get().push(projectId, "", false),
+
+  syncNow: async (projectId) => {
+    await invoke("sync_now", { projectId });
+    await get().refreshStatus(projectId);
+  },
+
+  push: async (projectId, relPath, force = false) => {
+    const result = await invoke<{ pushed: number; conflicts: string[] }>("sync_push", {
+      projectId,
+      relPath,
+      force,
+    });
+    await get().refreshStatus(projectId);
+    return result;
+  },
+
+  resolveAll: async (projectId, relPaths, side) => {
+    // Iterate per path (each side has its own single-file command) but refresh
+    // the cached status only once at the end — refreshing per file would re-stat
+    // the whole selection N times. A single failed file is logged and skipped so
+    // one bad path doesn't abort the rest of the batch.
+    for (const rel of relPaths) {
+      try {
+        if (side === "host") {
+          await invoke("sync_pull", { projectId, relPath: rel });
+        } else {
+          await invoke("sync_push", { projectId, relPath: rel, force: true });
+        }
+      } catch (e) {
+        console.error(`resolveAll: ${side} failed for ${rel}`, e);
+      }
+    }
+    await get().refreshStatus(projectId);
+  },
+
+  markSelected: async (projectId, relPaths, selected, isDir) => {
+    await invoke("sync_mark_selected", { projectId, relPaths, selected, isDir });
+    await get().refreshStatus(projectId);
+  },
+
+  setAuto: async (projectId, relPaths, auto, isDir) => {
+    await invoke("sync_set_auto", { projectId, relPaths, auto, isDir });
+    await get().refreshStatus(projectId);
+  },
+
+  autoPreview: async (projectId, relPath) =>
+    invoke<AutoSyncPreview>("sync_auto_preview", { projectId, relPath }),
+
+  bigFolders: async (projectId, scanHost = true) =>
+    invoke<BigFolderScan>("sync_big_folders", { projectId, scanHost }),
+
+  setExcluded: async (projectId, relPaths, excluded) => {
+    await invoke("sync_set_excluded", { projectId, relPaths, excluded });
+    await get().refreshStatus(projectId);
+  },
+}));
+
+/** Payload of the backend `auto-sync` event (one per reconcile pass that moved
+ *  files). We only need the project id to refresh; counts are informational. */
+interface AutoSyncEvent {
+  project_id: string;
+  pulled: number;
+  pushed: number;
+  skipped_amber: number;
+}
+
+let progressUnlisten: Promise<() => void> | null = null;
+
+/**
+ * Subscribe to the backend `sync-progress` and `auto-sync` streams (idempotent —
+ * registers once). `sync-progress` updates `progressByProject` as files transfer
+ * and refreshes the cached status when a transfer completes; `auto-sync` refreshes
+ * the cached status after a background reconcile pass so the tree/orange list stay
+ * live. Call once at app startup.
+ */
+export function listenSyncProgress(): Promise<() => void> {
+  if (progressUnlisten) return progressUnlisten;
+  progressUnlisten = Promise.all([
+    listen<SyncProgress>("sync-progress", (ev) => {
+      const p = ev.payload;
+      if (p.phase === "done") {
+        useSyncStore.setState((s) => ({
+          progressByProject: { ...s.progressByProject, [p.project_id]: null },
+        }));
+        void useSyncStore.getState().refreshStatus(p.project_id);
+        return;
+      }
+      useSyncStore.setState((s) => ({
+        progressByProject: {
+          ...s.progressByProject,
+          [p.project_id]: { rel: p.rel_path, done: p.done, total: p.total },
+        },
+      }));
+    }),
+    listen<AutoSyncEvent>("auto-sync", (ev) => {
+      void useSyncStore.getState().refreshStatus(ev.payload.project_id);
+    }),
+  ]).then((unlisteners) => () => unlisteners.forEach((u) => u()));
+  return progressUnlisten;
+}
diff --git a/src/stores/tabLand.ts b/src/stores/tabLand.ts
new file mode 100644
index 0000000..cef28b8
--- /dev/null
+++ b/src/stores/tabLand.ts
@@ -0,0 +1,41 @@
+import { create } from "zustand";
+
+/**
+ * One-shot "landing" flourish played when a tab is dropped INTO a different tab
+ * bar (a cross-group move or a split-off into a new subwindow). The destination
+ * `TabBar` mounts the moved tab fresh, so it plays a brief drop-in animation
+ * (the tab settles into its slot with an accent glow) to make it clear WHERE the
+ * dragged tab landed.
+ *
+ * Kept in its own store (mirroring `drag.ts` / `detachAnim.ts`) so the single
+ * drop authority (`commitDrop`) can fire it and the destination `TabBar` can
+ * render it, without threading props. Within-bar reorders never land here — they
+ * already have the gap feedback during the drag — and out-of-window detaches use
+ * the `detachAnim` fly-out instead.
+ */
+export interface TabLanding {
+  /** Key of the tab that just landed in a new bar. */
+  key: string;
+  /** Strictly-increasing id so a repeat landing re-runs the CSS animation and
+   *  the destination `TabBar` clears exactly the play it started. */
+  nonce: number;
+}
+
+interface TabLandStore {
+  landed: TabLanding | null;
+  /** Mark `key` as freshly landed so its destination tab plays the drop-in. */
+  markLanded: (key: string) => void;
+  /** Clear the landing once its animation has finished (matched by `nonce`). */
+  clear: (nonce: number) => void;
+}
+
+// Module counter: the nonce must strictly increase across plays so a repeat
+// landing for the same tab still re-triggers the animation.
+let landSeq = 0;
+
+export const useTabLandStore = create<TabLandStore>((set) => ({
+  landed: null,
+  markLanded: (key) => set({ landed: { key, nonce: ++landSeq } }),
+  clear: (nonce) =>
+    set((s) => (s.landed?.nonce === nonce ? { landed: null } : {})),
+}));
diff --git a/src/stores/tabs.ts b/src/stores/tabs.ts
index 1eed3a6..75e0038 100644
--- a/src/stores/tabs.ts
+++ b/src/stores/tabs.ts
@@ -1,13 +1,168 @@
 import { invoke } from "@tauri-apps/api/core";
 import { create } from "zustand";
 import { useShallow } from "zustand/react/shallow";
+import { type AgentMode, withAgentMode } from "../components/tabs/agentModes";
 import type { InternalViewer } from "../lib/viewers/fileUtils";
+import type { AutocompleteMode } from "../types";
+import { forgetPty } from "../lib/promptCount";
+import { METRIC, agentMetricLeaf, sub } from "../lib/usageMetrics";
 import { useLinkRoutingStore } from "./linkRouting";
+import { bumpUsage } from "./usage";
+import { newTmuxSessionName } from "../lib/tmuxSession";
+import { useRunHostPrefStore } from "./runHostPref";
+
+/** A shell tab gets a stable persisted tmux session name at creation (TODO #85),
+ *  so a persistent remote run reattaches after a relaunch instead of forking a
+ *  second session. Non-shell tabs, and shell tabs that already carry one (or an
+ *  explicit attach), are left untouched. */
+function withTmuxSession(
+  tab: Omit<TabEntry, "key">,
+  scope: string,
+): Omit<TabEntry, "key"> {
+  if (tab.kind === "shell" && !tab.tmuxSession && !tab.tmuxAttach) {
+    return { ...tab, tmuxSession: newTmuxSessionName(scope) };
+  }
+  return tab;
+}
+
+/** A new SHELL tab launched from a project inherits that project's run-host
+ *  preference (the machine chosen in the `RunHostPicker`) as its `location`, so
+ *  "pick machine X ⇒ ALL shells run on X" — the "+" → Shell tab, not just a
+ *  Python/script Run. Scoped tightly: only a `shell` tab, only when it did NOT
+ *  already pin a `location` (a script/tmux/SLURM/git-resolve tab sets its own and
+ *  must keep it), and only when the owning scope has a stored preference (a local
+ *  project, the root scope, and a box scope have none → unchanged). Baked in at
+ *  creation because `effectiveTabLocation`'s per-kind default has no project
+ *  context to consult the preference. */
+function withRunHostDefault(
+  scope: string,
+  tab: Omit<TabEntry, "key">,
+): Omit<TabEntry, "key"> {
+  if (tab.kind !== "shell" || tab.location !== undefined) return tab;
+  const pref = useRunHostPrefStore.getState().byProject[scope];
+  return pref ? { ...tab, location: pref } : tab;
+}
+
+export type TabKind =
+  | "agent"
+  | "local_agent"
+  | "shell"
+  | "files"
+  | "projectfiles"
+  | "embed"
+  | "projects3d"
+  | "network"
+  | "monitor"
+  | "diskusage"
+  | "calendar";
+
+/**
+ * SSH-sync Phase 0 — a PTY tab's locality on a REMOTE (SSH) project: does it run
+ * locally (in the project's local mirror) or on the host over `ssh -tt`? Only
+ * meaningful for `agent`/`shell` tabs (see {@link isLocatableKind}); `local_agent`
+ * is always local and non-PTY kinds have no locality. On a LOCAL project the axis
+ * is inert (everything is local — the backend gates the ssh-wrap on remoteness).
+ * Plan: docs/ssh_sync_plan.md.
+ */
+export type TabLocation = "local" | "remote" | `host:${string}`;
+
+/** The backend host id a tab location runs on: `"primary"` for the primary remote
+ *  (`"remote"`), the worker id for a `host:<id>` location, or `null` for `"local"`
+ *  (`docs/multi_host_remote_plan.md` §4.1). Pass to PTY spawn / lamp reads. */
+export function remoteHostIdOf(loc: TabLocation | undefined): string | null {
+  if (loc === "remote") return "primary";
+  if (loc && loc.startsWith("host:")) return loc.slice("host:".length);
+  return null; // "local" or unset
+}
+
+/** Whether a tab location runs on a remote host (primary or a worker) rather than
+ *  the local mirror. */
+export function isRemoteLocation(loc: TabLocation | undefined): boolean {
+  return remoteHostIdOf(loc) !== null;
+}
+
+/** The minimal shape of a worker machine (`ComputeHost`) the locality UI reads —
+ *  structural so `tabs.ts` need not import the full project types. */
+export interface LocalityHost {
+  id: string;
+  label?: string;
+  host: string;
+  sync_code?: boolean;
+  shared_fs?: boolean;
+}
 
-export type TabKind = "agent" | "local_agent" | "shell" | "files" | "embed";
+/** Human-readable name of the machine a tab location runs on — the ONE place the
+ *  tab badge, its locality menu, and the hover card agree on wording
+ *  (`docs/multi_host_remote_plan.md`). `"local"` → the mirror; `"remote"` → the
+ *  primary host (named when known); `host:<id>` → the worker's label/host/id. */
+export function localityHostLabel(
+  loc: TabLocation | undefined,
+  opts: { primaryHost?: string; computeHosts?: LocalityHost[] } = {},
+): string {
+  const hostId = remoteHostIdOf(loc);
+  if (hostId === null) return "Local (mirror)";
+  if (hostId === "primary") {
+    return opts.primaryHost ? `Primary (${opts.primaryHost})` : "Primary";
+  }
+  const w = opts.computeHosts?.find((h) => h.id === hostId);
+  return w?.label || w?.host || hostId;
+}
+
+/** Whether a worker machine can actually RUN a shell/agent tab: it must hold the
+ *  code — either it shares the primary's filesystem (`shared_fs`) or it keeps a
+ *  synced copy (`sync_code`, default on). A worker with neither has no tree to run
+ *  in; sync always stays with the primary, so such a worker is offered disabled.
+ *  The primary (`"primary"`/`undefined`) and the local mirror are always runnable. */
+export function workerRunnable(h: LocalityHost): boolean {
+  return !!h.shared_fs || h.sync_code !== false;
+}
 
 export const FILES_TAB_CMD = "__eldrun_files__";
 
+/**
+ * Sentinel `cmd` for the "Files (Project)" tab: the SAME file view the right
+ * panel shows (`ProjectFilesPane` → `FileTree`), hosted in a tab — git markers,
+ * drag-to-open/move, OS import/export, the remote sync overlay. Distinct from
+ * `FILES_TAB_CMD`, which is the separate two-pane `FileBrowser` explorer; both
+ * are offered, they are different tools.
+ */
+export const PROJECT_FILES_TAB_CMD = "__eldrun_project_files__";
+
+/**
+ * Sentinel `cmd` for the 3D project-blob tab (root scope only): a navigable 3D
+ * cloud of every project (active + inactive) and box. Carries no PTY — like the
+ * files tab it's a pure-frontend pane, identified by this command so cmdToKind
+ * can recover its kind from a bare command string.
+ */
+export const BLOB_TAB_CMD = "__eldrun_blob__";
+
+/** Sentinel command for the read-only local/SSH host traffic dashboard. */
+export const NETWORK_TAB_CMD = "__eldrun_network__";
+
+/**
+ * Sentinel `cmd` for the native htop-like system monitor tab: a read-only,
+ * whole-machine process/CPU/memory view. Carries no PTY — like the network pane
+ * it's identified by this command so cmdToKind can recover its kind on restore.
+ */
+export const MONITOR_TAB_CMD = "__eldrun_monitor__";
+
+/**
+ * Sentinel `cmd` for the native disk usage analyzer tab: a baobab-like rings/
+ * treemap view of what is filling a folder. Carries no PTY — like the monitor pane
+ * it is identified by this command so cmdToKind can recover its kind on restore.
+ */
+export const DISKUSAGE_TAB_CMD = "__eldrun_diskusage__";
+
+/**
+ * Sentinel `cmd` for the native calendar tab: a local, self-contained month-grid
+ * event calendar, offered in every scope (root and each project). The event store
+ * is global — one `calendar.json`, one zustand store — so every calendar tab shows
+ * the same events regardless of the project it was opened from, and edits in one
+ * are seen live by the others. Carries no PTY — like the files pane it's identified
+ * by this command so cmdToKind can recover its kind.
+ */
+export const CALENDAR_TAB_CMD = "__eldrun_calendar__";
+
 /**
  * Synthetic group id for the empty-state placeholder subwindow (rendered by
  * CenterPanel when a scope has no layout yet). It is NOT a real group in the
@@ -28,6 +183,87 @@ export interface ViewerState {
   scale?: number;
   offsetX?: number;
   offsetY?: number;
+  // Tab-local editor text size (#48). When set it overrides the per-type
+  // `viewer_prefs[type].font_size` default for THIS tab only, so zooming one
+  // text/markdown/TeX tab no longer resizes every other viewer of that type;
+  // absent means the tab tracks the per-type default. Survives reopen/restart.
+  fontSize?: number;
+  // Tab-local AI-assist overrides (#45). When set, they override the per-type
+  // `viewer_prefs` default for THIS tab only; when absent the editor falls back
+  // to the per-type setting. Toggled from the in-tab AI-assist controls.
+  autocomplete?: boolean;
+  autocompleteMode?: AutocompleteMode;
+  grammarCheck?: boolean;
+  // Debug breakpoints (#py), as 1-based line numbers into the file. Persisted per
+  // tab like the reader's scroll position, so the dots survive closing the file
+  // and an Eldrun restart. Remapped as the draft is edited (see useBreakpoints);
+  // what is stored is always resolved against the file as last seen.
+  breakpoints?: number[];
+  // Collapsed nodes of the YAML tree (#yaml), as node ids (document + path). Like
+  // the scroll position, folding a big config stays folded across a reopen and a
+  // restart. Ids are re-derived from the file on every parse, so an id that no
+  // longer resolves is simply inert.
+  yamlCollapsed?: string[];
+  // The YAML TREE's scroll position (#yaml). Kept apart from `scrollTop` (the
+  // Source editor's) because Tree and Source are two views of one file with
+  // unrelated pixel heights — one scroll offset can't serve both — so switching
+  // Tree↔Source restores each side where it was.
+  yamlScrollTop?: number;
+  // Collapsed cards of the YAML card grid (#yaml-grid), as node ids — the card
+  // view's twin of `yamlCollapsed`, kept apart so folding a card and folding a tree
+  // row don't clobber each other. Ids are re-derived on every parse, so a stale one
+  // is inert.
+  gridCollapsed?: string[];
+  // The focused ("main") card of the YAML card grid (#yaml-grid), as its node id,
+  // for the drill navigation: the grid shows that card's level (its siblings, it
+  // highlighted) and its children below. Absent/unmatched = the top overview.
+  // Re-derived on every parse, so a stale id is inert (falls back to overview).
+  gridFocus?: string;
+  // The table viewer's column separator (#40), as the literal character. Absent
+  // means "auto" — sniffed from the content on every open. It is persisted only
+  // when the reader *overrides* the guess, because that is the case the sniffer
+  // got wrong: re-sniffing would just talk them back out of it on the next open.
+  delimiter?: string;
+  // The table viewer's hidden columns (#40), as indices into the parsed row. They
+  // are only meaningful for the separator that produced them — a different one
+  // cuts the row into different columns — so the viewer drops them when the
+  // delimiter changes rather than hiding whatever now sits at those indices.
+  hiddenColumns?: number[];
+  // The table viewer's drag-resized column widths (#40), keyed by parsed-column
+  // index → total pixel width (padding included). Absent for a column means it
+  // keeps its measured `ch` width. Like `hiddenColumns` the indices only mean
+  // anything under the separator that produced them, so a delimiter change drops
+  // the overrides rather than re-applying them to whatever the new cut lands on.
+  columnWidths?: Record<number, number>;
+  // The deck editor's slide-overview rail width (px), user-resizable via a drag
+  // handle. Like the table's column widths, only ever written on an explicit
+  // resize — the default is computed, not persisted, so a deck opened for the
+  // first time (or by an older build with no field) gets the current default
+  // rather than a stale one baked into the file.
+  deckRailWidth?: number;
+}
+
+// Detached windows render their tabs from a Tauri-event SEED into local React
+// state; those tabs never enter `useTabsStore` (the main window owns the layout
+// store — see DetachedApp/jumpToSource). Viewer hooks seed their per-tab state
+// (scroll/zoom + the #45 autocomplete/grammar overrides) from
+// `useTabsStore`, so in a detached window that probe misses and the editor falls
+// back to the per-type default — e.g. a per-tab autocomplete toggle silently
+// reverts to off. This per-window registry lets those hooks recover a detached
+// tab's seeded `viewerState` by key. Populated by DetachedApp from each seed;
+// lives only in the detached window's heap (no-op/empty in the main window).
+const detachedViewerState = new Map<string, ViewerState>();
+
+/** Register (or clear, when `vs` is undefined) a detached tab's seeded
+ *  `viewerState` so viewer hooks can read it when `useTabsStore` has no entry. */
+export function setDetachedViewerState(key: string, vs: ViewerState | undefined): void {
+  if (vs) detachedViewerState.set(key, vs);
+  else detachedViewerState.delete(key);
+}
+
+/** A detached tab's seeded `viewerState`, or undefined. See {@link setDetachedViewerState}. */
+export function getDetachedViewerState(key: string): ViewerState | undefined {
+  return detachedViewerState.get(key);
 }
 
 /**
@@ -56,6 +292,26 @@ export interface TabEntry {
   // `--session-id <uuid>`), the UUID Eldrun minted and launched the agent with.
   // Surfaced on tab hover and intended to later drive session resume.
   sessionId?: string;
+  // This tab's work is **not** worth outliving it: never tmux-wrapped, however
+  // persist-enabled its project is (`lib/tmuxSession`'s `shouldPersistTab`). Set
+  // by the SLURM log tab on an HPC-tagged host — a `tail -F` left running under a
+  // tmux daemon on a shared login node after Eldrun quits is exactly the standing
+  // presence the tag forbids, and the tail is one click away in the Jobs view.
+  // A real run (`srun --pty`, a training job) is untouched: it is the case tmux
+  // persistence exists for. Persisted with the tab, so a restored log tab does
+  // not quietly regain a session on the next launch.
+  ephemeral?: boolean;
+  // For a custom agent (see CustomAgent) whose spec carries a "continue last
+  // session" flag: the resume args this tab respawns with after a restart. Its
+  // presence is what makes such a tab restart-resumable without the cmd being in
+  // the static RESUMABLE_AGENTS map (see isResumableAgentTab / loadFromLayout).
+  // Persisted, since args are rebuilt from scratch on restore.
+  resumeArgs?: string[];
+  // Absolute path of the script this terminal tab was launched to run (Python
+  // Run/Debug, or a foreground shell-script run). Lets the activity store pulse
+  // the file's run button while the tab is producing output. Busy-gated on read,
+  // so a restored non-busy run tab never falsely lights up.
+  runFile?: string;
   // For "embed" tabs (a file dragged from the FileTree onto a tab bar): the
   // absolute path of the embedded file and the resolved executable that opens
   // it. Phase 1 opens the file externally; Phase 2 will reparent the app's
@@ -72,6 +328,38 @@ export interface TabEntry {
   // the file (or restarting) restores the position instead of jumping to the top
   // (see ViewerState). Written by the viewer panes, persisted in project.json.
   viewerState?: ViewerState;
+  // SSH-sync Phase 0: for `agent`/`shell` tabs on a remote project, whether this
+  // tab runs locally (in the mirror) or on the host. Absent → the per-kind
+  // default (agents local, shells remote — see effectiveTabLocation). Inert on a
+  // local project. Persisted so the choice survives a restart.
+  location?: TabLocation;
+  // The tab's agent authority mode — the planner/doer split ("plan" proposes,
+  // "auto" auto-accepts edits). Only meaningful for agents in the capability
+  // table (Claude and Gemini; see components/tabs/agentModes.ts) and only
+  // surfaced when the experimental `agent_mode_toggle` setting is on. Absent →
+  // no mode flag is passed and the agent runs in its own default (ask each
+  // time), which is the behaviour of every tab predating this feature. The mode
+  // rides in `args` as the agent's mode flag (`--permission-mode`/`--approval-mode
+  // <x>`); this field is the durable record of it, since `args` are rebuilt from
+  // scratch on restore (loadFromLayout).
+  agentMode?: AgentMode;
+  // For "projectfiles" tabs: the project-relative folder the tree is browsed
+  // into. Persisted, so "Open in new tab" on a folder (and the tab's own
+  // navigation) survive a restart instead of coming back at the project root.
+  folder?: string;
+  // Persistent remote sessions (TODO #85): the STABLE tmux session name this shell
+  // tab spawns-or-attaches on the host. Minted once at creation and persisted,
+  // because the tab's PTY id (scope:key) is regenerated on restore — so the name
+  // must live on the tab to survive a relaunch and let the tab REATTACH rather than
+  // start a second session. Passed to the backend as `tmux_session` when the tab
+  // actually runs persistently (a remote shell tab of a persist-enabled project);
+  // inert otherwise. See `lib/tmuxSession.ts`, `shouldPersistTab`.
+  tmuxSession?: string;
+  // When set, this shell tab **attaches** to an existing named tmux session on the
+  // host (opened from the Sessions view onto a running, possibly hand-started
+  // session) instead of spawning a fresh one. Persisted so it reattaches across a
+  // restart. Passed as `tmux_attach`, which takes precedence over `tmuxSession`.
+  tmuxAttach?: string;
 }
 
 export type SplitDir = "row" | "column";
@@ -91,6 +379,20 @@ export interface GroupNode {
   id: string;
   tabKeys: string[]; // order shown in this subwindow's tab bar
   activeKey: string | null; // active tab within this group
+  // Per-subwindow right file viewer: when true this group renders a docked
+  // file-viewer column (the shared ProjectFilesView, hosted by
+  // SubwindowFilesSidebar) on its right edge — in the main window and in a
+  // detached popout alike. Persisted with the layout tree so it survives a
+  // restart, and carried through detach/attach so a popped-out subwindow keeps
+  // its viewer.
+  filesOpen?: boolean;
+  // The sidebar column's width in px (unset → the component default).
+  filesWidth?: number;
+  // The browsed folder (project-relative) the docked viewer last showed, so the
+  // subwindow reopens where it was left. Lives on the node — like the open flag
+  // and width — so it persists with the layout, travels with a detach, and is
+  // freed when the group (subwindow) is dropped.
+  filesFolder?: string;
 }
 
 export type LayoutNode = SplitNode | GroupNode;
@@ -117,12 +419,37 @@ export interface WindowBounds {
  * arbitrary split subtree), keeping the re-attach merge math simple.
  */
 export interface DetachedGroup {
-  id: string; // the detached group node's id
-  subtree: GroupNode;
+  id: string; // the detached popout's identity (window/registry label key)
+  // The popout's layout. Usually a single GroupNode, but can be a SplitNode once
+  // the user splits panes inside the popout (multi-pane popouts). The root node's
+  // id need NOT equal `id` — `id` identifies the OS window, the subtree is its
+  // content.
+  subtree: LayoutNode;
   label: string; // backend window/registry label
   // Last-known OS geometry of the popout, streamed back by the window. Persisted
   // (via the saved tree) so the popout reopens at the same place/size on restart.
   bounds?: WindowBounds;
+  // The popout's OWN UI zoom (per-window, not the global/main-window `ui_zoom`),
+  // streamed back over DETACHED_ZOOM. Persisted (via the saved tree) and shipped
+  // in the popout's seed so it reopens at the zoom it was left at. Undefined = 100%.
+  zoom?: number;
+}
+
+/**
+ * A tab group that has been HIDDEN from the in-window layout tree. Mechanically
+ * this is "detach minus the OS window": the group's node leaves
+ * `layoutByScope[scope]` while its tab PAYLOADS stay in `tabsByScope` (so PTYs
+ * never unmount — `CenterPanel`'s flat pane layer keeps them mounted but
+ * `display:none`, since no live layout node references their keys). The user
+ * brings it back from the right-panel Hidden list (`unhideGroup`). Unlike a
+ * detached popout there is no OS window and thus no `bounds`/`label` handoff.
+ */
+export interface HiddenGroup {
+  id: string; // the hidden group's identity (the original group's id)
+  // The hidden subtree. Usually a single GroupNode, but can be a SplitNode when
+  // a multi-pane split was hidden whole.
+  subtree: LayoutNode;
+  label: string; // debug/label tag, mirrors DetachedGroup.label
 }
 
 /**
@@ -130,13 +457,29 @@ export interface DetachedGroup {
  * `detached.ts`) so `tabs.ts` stays free of a circular import; `detached.ts`'s
  * `DetachedEdit` is structurally identical.
  */
+export type DropEdge = "left" | "right" | "top" | "bottom" | "center";
+
 export type DetachedEditPayload =
   | { kind: "activate"; key: string }
   | { kind: "rename"; key: string; label: string }
+  // Multi-host: change where a locatable tab runs; applied to the payload here so
+  // the main window's flat pane layer (which owns the popout's PTY) respawns it.
+  | { kind: "setLocation"; key: string; location: TabLocation }
   | { kind: "close"; key: string }
-  | { kind: "reorder"; tabKeys: string[] };
-
-export type DropEdge = "left" | "right" | "top" | "bottom" | "center";
+  | { kind: "reorder"; tabKeys: string[] }
+  // Multi-pane popouts: split `key` out into a new pane at `edge` of
+  // `targetGroupId` (a group within the popout's subtree).
+  | { kind: "split"; key: string; targetGroupId: string; edge: DropEdge }
+  // Multi-pane popouts: resize the divider between children `dividerIndex`/
+  // `dividerIndex+1` of the split `splitId` within the popout's subtree.
+  | { kind: "resize"; splitId: string; dividerIndex: number; fraction: number }
+  // Multi-pane popouts: move `key` into `targetGroupId` (at `index`, else append),
+  // merging it across the popout's groups (collapses an emptied source pane).
+  | { kind: "move"; key: string; targetGroupId: string; index?: number }
+  // Toggle/resize a popout group's docked file-viewer column (the per-subwindow
+  // right file viewer), or record the folder it browsed to. Applied to the group
+  // node inside the popout's subtree.
+  | { kind: "files"; groupId: string; open?: boolean; width?: number; folder?: string };
 
 /** Flat tab shape as persisted in project.json's `tab_layout`. */
 export interface SavedTabEntry {
@@ -157,11 +500,44 @@ export interface SavedTabEntry {
   viewer?: InternalViewer;
   // Persisted reader position (scroll/zoom/pan) for in-app viewer embeds.
   viewerState?: ViewerState;
+  // SSH-sync Phase 0: persisted per-tab local/remote locality (see TabEntry).
+  location?: TabLocation;
+  // Persisted planner/doer mode (see TabEntry.agentMode). Re-applied to the
+  // launch args on restore, so a tab comes back in the mode it was left in.
+  agentMode?: AgentMode;
+  // Persisted browsed folder of a "projectfiles" tab (see TabEntry.folder).
+  folder?: string;
+  // Persisted resume args of a restart-resumable custom agent (see
+  // TabEntry.resumeArgs). Re-applied as the launch args on restore.
+  resumeArgs?: string[];
+  // Persisted stable tmux session name for a shell tab (see TabEntry.tmuxSession).
+  tmuxSession?: string;
+  // Persisted tmux session this shell tab attaches to (see TabEntry.tmuxAttach).
+  tmuxAttach?: string;
+  // Persisted "never tmux-wrap this tab" marker (see TabEntry.ephemeral).
+  ephemeral?: boolean;
 }
 
 /** Serialized layout tree as persisted in project.json's `tab_groups`. */
 export type SavedLayoutTree =
-  | { type: "split"; dir: SplitDir; children: SavedLayoutTree[]; sizes: number[] }
+  | {
+      type: "split";
+      dir: SplitDir;
+      children: SavedLayoutTree[];
+      sizes: number[];
+      // #42: a MULTI-PANE popout's content is a split, so the detached tag can sit
+      // on a split node too — restore re-opens the whole split subtree as one
+      // floating popout (see withDetachedDocked / deserializeTree / detachGroup).
+      detached?: boolean;
+      bounds?: WindowBounds;
+      // A detached popout's own per-window zoom (see DetachedGroup.zoom).
+      zoom?: number;
+      // When true, this split subtree was HIDDEN (parked out of the tiled layout).
+      // Persisted as a docked node so its tabs survive, but tagged so restore
+      // routes it back into `hiddenGroupsByScope` instead of the live tree.
+      // See withHiddenDocked / deserializeTree / loadFromLayout.
+      hidden?: boolean;
+    }
   | {
       type: "group";
       tabKeys: string[];
@@ -172,6 +548,15 @@ export type SavedLayoutTree =
       // at `bounds` instead of docking it. See withDetachedDocked / loadFromLayout.
       detached?: boolean;
       bounds?: WindowBounds;
+      // A detached popout's own per-window zoom (see DetachedGroup.zoom).
+      zoom?: number;
+      // When true, this group was HIDDEN (see the split variant's note). Restore
+      // moves it into `hiddenGroupsByScope` rather than docking it live.
+      hidden?: boolean;
+      // Per-subwindow right file viewer (see GroupNode.filesOpen/filesWidth).
+      filesOpen?: boolean;
+      filesWidth?: number;
+      filesFolder?: string;
     };
 
 /**
@@ -199,6 +584,12 @@ interface TabsStore {
   // Their tab payloads still live in `tabsByScope[scope]`; only their layout
   // node has left `layoutByScope[scope]`.
   detachedGroupsByScope: Record<string, DetachedGroup[]>;
+  // Per-scope groups the user has HIDDEN (parked out of the tiled layout while
+  // keeping their tabs/PTYs alive — detach minus the OS window). Like the
+  // detached map, the payloads stay in `tabsByScope[scope]`; only the layout
+  // node lives here. Surfaced by the right-panel Hidden list; restored via
+  // `unhideGroup`. Persists across restart via the SavedLayoutTree `hidden` tag.
+  hiddenGroupsByScope: Record<string, HiddenGroup[]>;
   // #42: per-scope groups that were detached when the scope was last saved and
   // must be re-opened as floating popouts once the scope's layout is live and its
   // panes (PTYs) have mounted. Populated by loadFromLayout, drained by
@@ -225,12 +616,51 @@ interface TabsStore {
   setGroupActive: (groupId: string, key: string) => void;
 
   // tab lifecycle
-  addTab: (tab: Omit<TabEntry, "key">) => TabEntry; // into focused group
+  // `seeded` marks a tab Eldrun opened by itself rather than one the user asked
+  // for (the root scope's default 3D-blob tab). Such a tab must not be counted as
+  // a tab the user opened — see `countTabOpen`.
+  addTab: (tab: Omit<TabEntry, "key">, opts?: { seeded?: boolean }) => TabEntry; // into focused group
+  // Add a tab into a SPECIFIC scope's focused group, regardless of which scope is
+  // currently active. Used to surface remote SSH/OpenVPN connections in the root
+  // scope without disturbing the active project. When `scope` is the current
+  // scope this behaves exactly like `addTab`; otherwise the tab is written into
+  // that scope's maps only (the user sees it after switching to it).
+  addTabToScope: (scope: string, tab: Omit<TabEntry, "key">) => TabEntry;
   ensureTab: (
     tab: Omit<TabEntry, "key">,
     matches: (tab: TabEntry) => boolean,
   ) => TabEntry;
   renameTab: (key: string, label: string) => void;
+  // Rewrite the embedPath (and label) of every in-app "embed" tab in the CURRENT
+  // scope whose file was renamed/moved on disk — an exact match (`embedPath ===
+  // oldAbs`) or, for a directory rename/move, any tab UNDER it (`embedPath`
+  // starts with `oldAbs + "/"`, prefix-swapped to `newAbs`). Payload-only (keys
+  // unchanged), so the main CenterPanel re-renders from the store and the updated
+  // payloads are what a subsequent reseed ships to any detached popout. On an
+  // exact match the label is refreshed to the new basename only when it still
+  // equals the old basename (so a user-renamed tab keeps its label). No-op when
+  // nothing matches. Delete/rename tab-sync lives in components/files/fileTabSync.
+  /**
+   * Re-point a project's tabs after it is detached from its SSH host, moving every cwd
+   * out of the old remote-project state dir and into the promoted mirror.
+   *
+   * This is not cosmetic; without it a detach silently breaks every agent tab. While a
+   * project is remote its `directory` is the **state dir**
+   * (`~/.local/share/eldrun/remote-projects/<id>/`), and `loadFromLayout` stores exactly
+   * that as each tab's `cwd` (agents unconditionally, others via `t.cwd || defaultCwd`).
+   * Nothing noticed, because `localTabCwd` overrode it at render time to the real mirror —
+   * an override gated on `isRemoteProject`. Detach flips that to false, the override stops
+   * firing, and every tab falls back to the stored cwd it never should have had: the state
+   * dir. Agents then launch inside `~/.local/share/eldrun/remote-projects/<id>/` — a
+   * directory that detach has just emptied — so Claude asks for permissions there and
+   * `--resume` finds no session, because Claude keys its history by cwd and the whole
+   * conversation lives under the mirror's path instead.
+   *
+   * Host-located tabs are converted to local too: their cwd is a path on a machine this
+   * project is no longer attached to.
+   */
+  detachScopeFromRemote: (scope: string, oldDir: string, newDir: string) => void;
+  retargetTabs: (oldAbs: string, newAbs: string) => void;
   removeTab: (key: string) => void; // drop; collapse empty groups/splits
   closeGroup: (groupId: string) => void; // close a whole subwindow; siblings resize
   // Close EVERY tab/subwindow in a scope (defaults to the current scope),
@@ -239,10 +669,28 @@ interface TabsStore {
   // explicitly at the call site if the scope isn't the active project.
   closeAllTabs: (scope?: string) => void;
   updateTabEnv: (key: string, env: Record<string, string>) => void;
+  // Persistent sessions (TODO #85): rename a tab's tmux session name after the
+  // Sessions view renamed the host session, so the persisted name still matches
+  // and the tab reattaches to the renamed session on restart. Updates whichever
+  // field the tab uses (`tmuxAttach` for an attach tab, else `tmuxSession`).
+  // Scope-explicit (the Sessions view may act on a non-active project).
+  setTabTmuxName: (scope: string, key: string, name: string) => void;
+  // SSH-sync Phase 0: set a tab's local/remote locality (agent/shell tabs on a
+  // remote project). No-op when unchanged. The CenterPanel's localOnly/cwd
+  // computation reads the result so the next mount spawns on the chosen side.
+  setTabLocation: (key: string, location: TabLocation) => void;
+  // Set an agent tab's planner/doer mode. Rewrites the tab's launch args, which
+  // respawns its PTY (TerminalView's spawn effect keys on the args) — the agent
+  // comes back on the same conversation via the backend's resume rewrite. No-op
+  // when unchanged, or for an agent with no mode support.
+  setAgentMode: (key: string, mode: AgentMode) => void;
   // Merge a patch into an embed tab's persisted viewer position (scroll/zoom/
   // pan). The viewer panes call this as the reader scrolls/zooms; the debounced
   // saveLayout effect then flushes it to project.json (see ViewerState).
   setViewerState: (key: string, patch: ViewerState) => void;
+  // Record the folder a "projectfiles" tab is browsed into, so it reopens there
+  // (see TabEntry.folder). No-op when unchanged.
+  setTabFolder: (key: string, folder: string) => void;
 
   // arrangement
   reorderInGroup: (groupId: string, from: number, to: number) => void;
@@ -258,6 +706,23 @@ interface TabsStore {
     edge: DropEdge,
   ) => TabEntry | null;
   resizeSplit: (splitId: string, dividerIndex: number, fraction: number) => void;
+  // Merge two adjacent subwindows into one (double-click the divider between
+  // them): append every tab of `sourceGroupId` onto `targetGroupId`, then let
+  // `writeScope`'s collapse pass drop the emptied source and unwrap the split.
+  // PTYs are preserved (tabs move, not close); the survivor keeps its activeKey.
+  // No-op if either group is missing or they are the same group.
+  mergeGroups: (targetGroupId: string, sourceGroupId: string) => void;
+
+  // Per-subwindow right file viewer: open/close a group's docked file-viewer
+  // column, and persist its width. Both write the flag onto the group NODE
+  // (GroupNode.filesOpen/filesWidth), so the sidebar persists with the layout
+  // tree and travels with a detach. No-ops if the group isn't in the current
+  // scope's live layout (popout-side toggles arrive via applyDetachedEdit).
+  setGroupFiles: (groupId: string, open: boolean) => void;
+  setGroupFilesWidth: (groupId: string, width: number) => void;
+  // Persist the folder the group's docked viewer last browsed to (see
+  // GroupNode.filesFolder). Same node-write path as the flag/width.
+  setGroupFilesFolder: (groupId: string, folder: string) => void;
 
   // #42: detach / re-attach a subwindow (group) to/from its own OS window.
   // `detachGroup` removes the group from the in-window tree, records it in
@@ -270,7 +735,14 @@ interface TabsStore {
   // group's label, or null if refused / not found.
   detachGroup: (
     groupId: string,
-    opts?: { skipBackend?: boolean; bounds?: WindowBounds; allowLastGroup?: boolean },
+    opts?: {
+      skipBackend?: boolean;
+      bounds?: WindowBounds;
+      allowLastGroup?: boolean;
+      // Restart respawn only: the popout's persisted per-window zoom, recorded on
+      // the fresh detached entry so its seed restores it (see RespawnTarget.zoom).
+      zoom?: number;
+    },
   ) => string | null;
   // Drag-a-tab-to-another-monitor: pop a SINGLE existing tab out of the in-window
   // layout into its own fresh detached OS window at `bounds` (screen px). Unlike
@@ -292,6 +764,22 @@ interface TabsStore {
     detachedId: string,
     opts?: { targetGroupId?: string; edge?: DropEdge; skipBackend?: boolean },
   ) => void;
+  // Hide a subwindow (group) from the tiled layout without killing it: strips its
+  // node from `layoutByScope`, keeps its tab payloads in `tabsByScope` (PTYs stay
+  // mounted-but-hidden), and parks the subtree in `hiddenGroupsByScope`. Unlike
+  // `detachGroup` it allows hiding the LAST group (the scope then shows the
+  // +-placeholder) and spawns no OS window. No-op if the group isn't found.
+  hideGroup: (groupId: string) => void;
+  // Restore a hidden group into the live layout (the reverse of `hideGroup`,
+  // modeled on `attachGroup`): regenerates the subtree's ids, injects it as a new
+  // pane (or as the root if the layout emptied), drops the hidden record, and
+  // focuses it. `opts.activeKey` restores it focused on a specific tab (tab-chip
+  // click in the Hidden list). No-op if the hidden entry is gone.
+  unhideGroup: (hiddenId: string, opts?: { activeKey?: string }) => void;
+  // Permanently close a hidden group: drops the hidden record AND its tab
+  // payloads from `tabsByScope` (killing the PTYs, mirroring `closeGroup`). Used
+  // by the ✕ on a Hidden-list row. No-op if the hidden entry is gone.
+  closeHiddenGroup: (hiddenId: string) => void;
   // #42: dock a SINGLE tab out of a popout back into a scope's layout (the
   // per-tab analog of attachGroup, used when one tab — not the whole group — is
   // dragged onto the main window). Inserts the tab at `targetGroupId`/`edge`
@@ -306,6 +794,87 @@ interface TabsStore {
     tabKey: string,
     opts?: { targetGroupId?: string; edge?: DropEdge; skipBackend?: boolean },
   ) => void;
+  // #42: dock ONE PANE (an inner group) of a MULTI-pane popout back into a
+  // scope's layout — the per-pane analog of attachDetachedTab, fired when a
+  // pane's bar grip is dragged onto the main window. Moves the pane's tabs as
+  // one group into the layout at `targetGroupId`/`edge` (center merges, an edge
+  // splits, default lands as its own pane) and removes the group node from the
+  // popout's subtree, leaving the sibling panes floating. If the pane is the
+  // popout's ONLY group this IS a whole-popout dock and delegates to
+  // attachGroup / dropDetachedGroup (which also close the OS window). The tab
+  // payloads already live in `tabsByScope`, so they survive the move. No-op if
+  // the popout or pane is gone.
+  attachDetachedPane: (
+    scope: string,
+    detachedGroupId: string,
+    paneId: string,
+    opts?: { targetGroupId?: string; edge?: DropEdge; skipBackend?: boolean },
+  ) => void;
+  // #42: pop ONE PANE (an inner group) of a MULTI-pane popout into its OWN brand
+  // new detached OS window — the per-pane analog of detachTabToNewWindow, fired
+  // when a pane's bar grip is dragged and released in FREE SPACE. Removes the
+  // group node from the source popout's subtree and records a fresh detached
+  // entry holding just that group at `bounds`, then spawns its OS window. The
+  // tab payloads stay in `tabsByScope` (shared). Refuses (returns null) when the
+  // popout/pane is gone OR the pane is the popout's only group — the popout
+  // already IS that pane's window. Returns the new window label.
+  detachPaneToNewWindow: (
+    scope: string,
+    fromGroupId: string,
+    paneId: string,
+    bounds: WindowBounds,
+  ) => string | null;
+  // #42: pop a SINGLE tab OUT of an existing detached popout into its OWN brand
+  // new detached OS window (the popout analog of TabBar's `popToNewWindow`),
+  // fired when a tab dragged out of a popout is released in FREE SPACE — outside
+  // both the main window and the popout. Removes `tabKey` from the source
+  // popout's subtree and records a fresh single-tab detached entry at `bounds`,
+  // then spawns its OS window. The tab payload stays in `tabsByScope[scope]`
+  // (shared), so the new popout self-seeds and the PTY never dies. No-ops
+  // (returns null) when the source/tab is gone OR when removing the tab would
+  // empty the source popout — a lone-tab popout dragged whole is already its own
+  // window, so re-detaching it would be needless churn. Returns the new label.
+  detachTabToNewWindow: (
+    scope: string,
+    fromGroupId: string,
+    tabKey: string,
+    bounds: WindowBounds,
+  ) => string | null;
+  // #42 (main → detached): dock a SINGLE existing in-window tab INTO an already
+  // open detached popout's group — the inverse of `attachDetachedTab`, fired when
+  // a tab dragged out of the main window is released over a popout (so no new OS
+  // window opens). Removes the tab from its source group in `scope`'s in-window
+  // layout (its payload STAYS in `tabsByScope`, so the PTY never dies: the main
+  // keeps the pane mounted-but-hidden and the popout re-attaches to it), appends
+  // it to the detached group's subtree, and activates it there. The caller
+  // re-seeds the popout so the new tab renders. No-op if the tab or detached
+  // group is gone.
+  dockTabIntoDetached: (
+    scope: string,
+    detachedGroupId: string,
+    tabKey: string,
+    // #42: where inside the popout to place the tab — a specific pane resolved
+    // from the cursor (a body edge splits, center/a bar slot merges into that
+    // group). Omitted → append to the popout's first pane (legacy behaviour).
+    target?: DetachedDockTarget,
+  ) => void;
+  // #42 (detached → detached): move a SINGLE tab from one open popout INTO another
+  // open popout of the SAME scope — fired when a tab dragged out of popout A is
+  // released over popout B. Removes `tabKey` from the source popout's subtree
+  // (dropping the source record + closing its OS window when it empties, mirroring
+  // `attachDetachedTab`) and places it into the destination popout's subtree at
+  // `target`. The payload STAYS in `tabsByScope` (shared), so the PTY the MAIN
+  // window owns never dies and both popouts re-attach to it after the re-seed.
+  // No-op if either popout is gone, the tab is absent from the source, or it is
+  // already in the destination.
+  moveTabBetweenDetached: (
+    scope: string,
+    fromGroupId: string,
+    toGroupId: string,
+    tabKey: string,
+    target?: DetachedDockTarget,
+    opts?: { skipBackend?: boolean },
+  ) => void;
   // #42: apply an edit streamed back from a detached window to the main store's
   // record of that detached group (its subtree node + tab payloads). Keeps the
   // main window — the single persistence owner — in sync with the detached one.
@@ -314,6 +883,43 @@ interface TabsStore {
     groupId: string,
     edit: DetachedEditPayload,
   ) => void;
+  // #42: create a NEW tab inside a detached popout, from its own "+" menu. The
+  // main window mints the key + owns the PTY, so this appends the payload to
+  // `tabsByScope[scope]` (spawning its pane in the main window's flat pane layer)
+  // and inserts the key into `targetGroupId` within the popout's subtree,
+  // activating it. Returns the minted key (or null if the popout/group is gone),
+  // so the caller can re-seed the popout to render + attach to the new tab.
+  addDetachedTab: (
+    scope: string,
+    detachedGroupId: string,
+    tab: Omit<TabEntry, "key">,
+    targetGroupId: string,
+  ) => string | null;
+  // Like `addDetachedTab`, but the new tab carves a NEW pane at `edge` of
+  // `targetGroupId` within the popout's subtree instead of appending to it — a
+  // file dropped on a body edge inside a detached popout. Mints the key + owns
+  // the PTY (main window), so it returns the minted key (or null if the popout /
+  // group is gone) for the caller's re-seed. `edge` must be a side, never
+  // "center" (that appends → use `addDetachedTab`).
+  addDetachedTabSplit: (
+    scope: string,
+    detachedGroupId: string,
+    tab: Omit<TabEntry, "key">,
+    targetGroupId: string,
+    edge: DropEdge,
+  ) => string | null;
+  // Multi-pane popouts: split a tab inside a detached popout's own subtree,
+  // carving a new pane at `edge` of `targetGroupId` (a group WITHIN the
+  // popout's subtree). Mirrors `splitWithTab` but mutates
+  // `detachedGroupsByScope[scope][i].subtree` instead of the in-window layout.
+  // The caller re-seeds the popout so it re-renders the new split.
+  splitDetachedGroup: (
+    scope: string,
+    detachedGroupId: string,
+    key: string,
+    targetGroupId: string,
+    edge: DropEdge,
+  ) => void;
   // #42: dock-back for a group whose scope is NOT active. We re-inject the
   // detached subtree into that scope's STORED layout (`layoutByScope[scope]`,
   // not the live `layout`) so its tabs remain referenced by a layout node and
@@ -329,9 +935,21 @@ interface TabsStore {
   // gone — persist the scope afterwards (persistScope) so disk agrees and they
   // don't restore on next launch. Closes the OS window via `attach_subwindow`.
   closeDetachedGroup: (scope: string, groupId: string) => void;
+  // #42: hide a popout into the right-panel "Hidden subwindows" list instead of
+  // docking it live or closing it — the detached twin of `hideGroup`. Moves the
+  // popout's subtree from `detachedGroupsByScope` into `hiddenGroupsByScope[scope]`
+  // (its tab payloads never left `tabsByScope`, so the flat pane layer keeps their
+  // PTYs mounted through the move) and closes the OS window via `attach_subwindow`.
+  // Restored/closed from the Hidden list exactly like a hidden main-window
+  // subwindow (`unhideGroup`/`closeHiddenGroup`), which docks it back into the
+  // tiled layout. No-op if the detached entry is gone.
+  hideDetachedGroup: (scope: string, groupId: string) => void;
   // #42: record a popout's latest OS geometry (streamed back from the window) so
   // it persists and the popout reopens where the user left it after a restart.
   setDetachedBounds: (scope: string, groupId: string, bounds: WindowBounds) => void;
+  // Record a popout's latest per-window zoom (streamed back over DETACHED_ZOOM)
+  // so it persists and the popout reopens at that zoom after a restart.
+  setDetachedZoom: (scope: string, groupId: string, zoom: number) => void;
   // #42: return and clear the scope's pending respawn targets (groups that were
   // detached at save time). Caller re-opens each via detachGroup once its pane
   // has mounted. Returns [] when there is nothing to respawn.
@@ -362,6 +980,22 @@ interface TabsStore {
   saveLayout: (localFile: string) => Promise<void>;
 }
 
+/**
+ * Count a tab open for the usage recap.
+ *
+ * Deliberately here rather than at the backend's `pty_spawn`: that fires again
+ * for every resumable agent tab respawned on relaunch, so counting there would
+ * report a fresh "agent tab opened" each morning for tabs opened days ago.
+ * `loadFromLayout` builds restored tabs directly and never calls `addTab`, so
+ * these entry points see only tabs a person actually opened — with one exception,
+ * the root scope's auto-seeded 3D-blob tab, which opts out via `{ seeded: true }`.
+ */
+function countTabOpen(scope: string, tab: TabEntry) {
+  bumpUsage(scope, METRIC.TAB_OPENED);
+  const agent = agentMetricLeaf(tab);
+  if (agent) bumpUsage(scope, sub(agent.prefix, agent.leaf));
+}
+
 let _keyCounter = 0;
 function nextKey(prefix: string) {
   return `${prefix}-${++_keyCounter}`;
@@ -388,6 +1022,40 @@ export function findGroup(node: LayoutNode | null, id: string): GroupNode | null
   return null;
 }
 
+/** Find a SPLIT node by id anywhere in the tree (#42: a multi-pane popout's root
+ *  is a split, so its respawn detaches the whole split subtree by this id). */
+export function findSplit(node: LayoutNode | null, id: string): SplitNode | null {
+  if (!node || node.type !== "split") return null;
+  if (node.id === id) return node;
+  for (const child of node.children) {
+    const found = findSplit(child, id);
+    if (found) return found;
+  }
+  return null;
+}
+
+/** Remove the subtree rooted at `id` (a group OR split) from `node`, collapsing
+ *  single-child splits that result. Returns the remaining tree (null if it
+ *  empties). Used to pop a whole multi-pane popout out of the in-window layout. */
+export function removeNodeById(node: LayoutNode | null, id: string): LayoutNode | null {
+  if (!node) return null;
+  if (node.id === id) return null;
+  if (node.type === "group") return node;
+  const kept: LayoutNode[] = [];
+  const sizes: number[] = [];
+  node.children.forEach((child, i) => {
+    const r = removeNodeById(child, id);
+    if (r) {
+      kept.push(r);
+      sizes.push(node.sizes[i] ?? 1);
+    }
+  });
+  if (kept.length === 0) return null;
+  if (kept.length === 1) return kept[0];
+  const total = sizes.reduce((a, b) => a + b, 0) || 1;
+  return { ...node, children: kept, sizes: sizes.map((s) => s / total) };
+}
+
 /** Find the group that currently holds `key` (and the key's index in it). */
 export function findGroupOfTab(
   node: LayoutNode | null,
@@ -413,10 +1081,142 @@ export function allGroups(node: LayoutNode | null): GroupNode[] {
 }
 
 /** Flat list of all tab keys, in stable left-to-right tree order. */
-function orderedTabKeys(node: LayoutNode | null): string[] {
+export function orderedTabKeys(node: LayoutNode | null): string[] {
   return allGroups(node).flatMap((g) => g.tabKeys);
 }
 
+/** Remove a tab key from whichever group holds it within a subtree, collapsing
+ *  an emptied group / lone-child split. Returns the new (possibly null) subtree;
+ *  returns the input unchanged if the key isn't present. Used by the detached
+ *  subtree mutators, which (post-split) operate on a LayoutNode, not a single
+ *  group. */
+export function removeKeyFromTree(node: LayoutNode, key: string): LayoutNode | null {
+  const found = findGroupOfTab(node, key);
+  if (!found) return node;
+  const removed = mapGroup(node, found.group.id, (g) => {
+    const tabKeys = g.tabKeys.filter((k) => k !== key);
+    return {
+      ...g,
+      tabKeys,
+      activeKey: g.activeKey === key ? (tabKeys[0] ?? null) : g.activeKey,
+    };
+  });
+  return collapse(removed);
+}
+
+/** Append a tab key to a subtree's FIRST group (depth-first) and activate it
+ *  there. Mirrors the single-group append for a tree subtree. */
+function appendKeyToTree(node: LayoutNode, key: string): LayoutNode {
+  const g = firstGroup(node);
+  return mapGroup(node, g.id, (grp) => ({
+    ...grp,
+    tabKeys: [...grp.tabKeys, key],
+    activeKey: key,
+  }));
+}
+
+/**
+ * #42: where to place a NEW key inside a detached popout's subtree when docking a
+ * tab/file INTO it from another window. `edge` carves a new pane at that side of
+ * the target group (center merges into it); `index` inserts into the target
+ * group's bar at that slot. Mirrors the within-popout drop semantics.
+ */
+export type DetachedDockTarget =
+  | { groupId: string; edge: DropEdge }
+  | { groupId: string; index: number };
+
+/** Place a NEW key into a subtree at `target` (or the first group when no target,
+ *  matching the legacy append). A non-center edge splits off a new pane beside the
+ *  target group; center / a bar slot inserts into the target group. Falls back to
+ *  an append when the target group is gone. Pure; activates the key. */
+function placeKeyInTree(
+  node: LayoutNode,
+  key: string,
+  target?: DetachedDockTarget,
+): LayoutNode {
+  if (!target || !findGroup(node, target.groupId)) return appendKeyToTree(node, key);
+  if ("index" in target) {
+    return mapGroup(node, target.groupId, (g) => {
+      const at = Math.min(Math.max(target.index, 0), g.tabKeys.length);
+      const tabKeys = [...g.tabKeys];
+      tabKeys.splice(at, 0, key);
+      return { ...g, tabKeys, activeKey: key };
+    });
+  }
+  if (target.edge === "center") {
+    return mapGroup(node, target.groupId, (g) => ({
+      ...g,
+      tabKeys: [...g.tabKeys, key],
+      activeKey: key,
+    }));
+  }
+  const newGroup: GroupNode = { type: "group", id: nextGroupId(), tabKeys: [key], activeKey: key };
+  const dir: SplitDir = target.edge === "left" || target.edge === "right" ? "row" : "column";
+  const before = target.edge === "left" || target.edge === "top";
+  return insertAdjacent(node, target.groupId, newGroup, dir, before);
+}
+
+/** Move `key` out of its current group into `targetGroupId` at `index` (append
+ *  when `index` is undefined), activating it there. Collapses the source group /
+ *  lone-child split if the move empties it — so dragging a split pane's only tab
+ *  onto the other pane's bar merges the two panes back into one. Pure; used by a
+ *  detached popout to merge a tab across its own groups. Returns the input
+ *  unchanged when the key isn't present, or null if removal empties the tree
+ *  (can't happen for a cross-group move, which always leaves the target).
+ *  No-ops (returns the input) when the target is the key's own group — that case
+ *  is a within-group reorder, handled elsewhere. */
+export function moveKeyInTree(
+  node: LayoutNode,
+  key: string,
+  targetGroupId: string,
+  index?: number,
+): LayoutNode | null {
+  const source = findGroupOfTab(node, key);
+  if (!source) return node;
+  if (source.group.id === targetGroupId) return node;
+  const cleaned = removeKeyFromTree(node, key);
+  if (!cleaned) return null;
+  // The target survives the removal (it's non-empty); bail if it somehow doesn't.
+  if (!findGroup(cleaned, targetGroupId)) return node;
+  return mapGroup(cleaned, targetGroupId, (g) => {
+    const tabKeys = [...g.tabKeys];
+    const at = index == null ? tabKeys.length : Math.min(Math.max(index, 0), tabKeys.length);
+    tabKeys.splice(at, 0, key);
+    return { ...g, tabKeys, activeKey: key };
+  });
+}
+
+/** Split `key` out of its group into a new pane at `edge` of `targetGroupId`,
+ *  within `node`. Pure; mirrors `splitWithTab`'s algorithm but on an arbitrary
+ *  subtree so the in-window layout AND a detached popout's subtree share it.
+ *  Returns the new subtree, or null if the split is a no-op / invalid. */
+export function splitSubtree(
+  node: LayoutNode,
+  key: string,
+  targetGroupId: string,
+  edge: DropEdge,
+): LayoutNode | null {
+  if (edge === "center") return null; // center merges, it isn't a split
+  const source = findGroupOfTab(node, key);
+  const target = findGroup(node, targetGroupId);
+  if (!source || !target) return null;
+  // Dropping a group's only tab onto its own edge would remove then re-add it.
+  if (source.group.id === targetGroupId && source.group.tabKeys.length === 1) {
+    return null;
+  }
+  const cleaned = removeKeyFromTree(node, key);
+  if (!cleaned || !findGroup(cleaned, targetGroupId)) return null;
+  const newGroup: GroupNode = {
+    type: "group",
+    id: nextGroupId(),
+    tabKeys: [key],
+    activeKey: key,
+  };
+  const dir: SplitDir = edge === "left" || edge === "right" ? "row" : "column";
+  const before = edge === "left" || edge === "top";
+  return insertAdjacent(cleaned, targetGroupId, newGroup, dir, before);
+}
+
 export type NavDirection = "left" | "right" | "up" | "down";
 
 /** The split axis a direction navigates along ("row" = horizontal). */
@@ -566,7 +1366,9 @@ function pruneCollapseCollect(
 function insertAdjacent(
   root: LayoutNode,
   targetId: string,
-  newGroup: GroupNode,
+  // The node to inject beside the target. Usually a fresh GroupNode, but may be
+  // a whole SplitNode (e.g. re-attaching a multi-pane detached popout's subtree).
+  newGroup: LayoutNode,
   dir: SplitDir,
   before: boolean,
 ): LayoutNode {
@@ -627,8 +1429,9 @@ function makeSplit(dir: SplitDir, children: LayoutNode[]): SplitNode {
   };
 }
 
-/** Apply a resize to the divider between child i and i+1 of `splitId`. */
-function applyResize(
+/** Apply a resize to the divider between child i and i+1 of `splitId`. Exported
+ *  so a detached popout's subtree can be resized through the same pure path. */
+export function applyResize(
   node: LayoutNode,
   splitId: string,
   dividerIndex: number,
@@ -734,7 +1537,16 @@ function currentScopeState(s: TabsStore) {
 export function serializeTree(node: LayoutNode | null): SavedLayoutTree | null {
   if (!node) return null;
   if (node.type === "group") {
-    return { type: "group", tabKeys: [...node.tabKeys], activeKey: node.activeKey };
+    return {
+      type: "group",
+      tabKeys: [...node.tabKeys],
+      activeKey: node.activeKey,
+      // Persist the per-subwindow file viewer (open flag + width + browsed
+      // folder) so it comes back on restart.
+      ...(node.filesOpen ? { filesOpen: true } : {}),
+      ...(node.filesWidth != null ? { filesWidth: node.filesWidth } : {}),
+      ...(node.filesFolder ? { filesFolder: node.filesFolder } : {}),
+    };
   }
   return {
     type: "split",
@@ -750,6 +1562,9 @@ export function serializeTree(node: LayoutNode | null): SavedLayoutTree | null {
 export interface RespawnTarget {
   id: string; // the FRESH group id minted during deserialize
   bounds?: WindowBounds;
+  // The popout's persisted per-window zoom (see DetachedGroup.zoom), carried so
+  // the respawn re-detaches it at the zoom it was left at. Undefined = 100%.
+  zoom?: number;
 }
 
 /**
@@ -760,11 +1575,16 @@ export interface RespawnTarget {
  * is pushed onto `detachedOut` so the caller can re-open it as a floating popout
  * after the layout is live (loadFromLayout). The node is still built into the
  * tree (docked) so its tabs mount and spawn their PTYs before the re-detach.
+ *
+ * A `hidden`-tagged node works the same way but pushes its fresh id onto
+ * `hiddenOut`; the caller then strips it from the built tree into
+ * `hiddenGroupsByScope` (see loadFromLayout).
  */
 function deserializeTree(
   saved: SavedLayoutTree,
   keyMap: Map<string, string>,
   detachedOut?: RespawnTarget[],
+  hiddenOut?: string[],
 ): LayoutNode | null {
   if (saved.type === "group") {
     const tabKeys = saved.tabKeys
@@ -777,15 +1597,37 @@ function deserializeTree(
       null;
     const id = nextGroupId();
     if (saved.detached && detachedOut) {
-      detachedOut.push({ id, bounds: saved.bounds });
+      detachedOut.push({ id, bounds: saved.bounds, zoom: saved.zoom });
+    }
+    if (saved.hidden && hiddenOut) {
+      hiddenOut.push(id);
     }
-    return { type: "group", id, tabKeys, activeKey };
+    return {
+      type: "group",
+      id,
+      tabKeys,
+      activeKey,
+      ...(saved.filesOpen ? { filesOpen: true } : {}),
+      ...(saved.filesWidth != null ? { filesWidth: saved.filesWidth } : {}),
+      ...(saved.filesFolder ? { filesFolder: saved.filesFolder } : {}),
+    };
   }
   const children = saved.children
-    .map((c) => deserializeTree(c, keyMap, detachedOut))
+    .map((c) => deserializeTree(c, keyMap, detachedOut, hiddenOut))
     .filter((c): c is LayoutNode => c != null);
   if (children.length === 0) return null;
-  if (children.length === 1) return children[0];
+  if (children.length === 1) {
+    // Collapsed to a single child. If this split was a detached (multi-pane)
+    // popout, the survivor inherits the respawn so the popout still re-opens.
+    if (saved.detached && detachedOut) {
+      detachedOut.push({ id: children[0].id, bounds: saved.bounds, zoom: saved.zoom });
+    }
+    // Likewise inherit a hidden tag so the survivor is parked, not docked live.
+    if (saved.hidden && hiddenOut) {
+      hiddenOut.push(children[0].id);
+    }
+    return children[0];
+  }
   // Align sizes to surviving children where possible, else even split.
   let sizes: number[];
   if (saved.sizes.length === children.length) {
@@ -794,7 +1636,18 @@ function deserializeTree(
   } else {
     sizes = children.map(() => 1 / children.length);
   }
-  return { type: "split", id: nextSplitId(), dir: saved.dir, children, sizes };
+  const id = nextSplitId();
+  // #42: a tagged split is a multi-pane popout — collect ONE respawn target for
+  // the whole subtree (its children aren't individually tagged) so the respawn
+  // path re-detaches the entire split as a single floating window.
+  if (saved.detached && detachedOut) {
+    detachedOut.push({ id, bounds: saved.bounds, zoom: saved.zoom });
+  }
+  // A hidden split is parked whole by its root id (same one-target logic).
+  if (saved.hidden && hiddenOut) {
+    hiddenOut.push(id);
+  }
+  return { type: "split", id, dir: saved.dir, children, sizes };
 }
 
 // ── Store ────────────────────────────────────────────────────────────────────
@@ -805,6 +1658,7 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
   layoutByScope: {},
   focusedGroupByScope: {},
   detachedGroupsByScope: {},
+  hiddenGroupsByScope: {},
   pendingRespawnByScope: {},
   tabs: [],
   layout: null,
@@ -871,10 +1725,14 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
-  addTab: (tab) => {
+  addTab: (tab, opts) => {
     const key = nextKey(tab.kind);
     // Spread first so a stray `key` on the payload can't shadow the minted one.
-    const entry: TabEntry = { ...tab, key };
+    const entry: TabEntry = {
+      ...withTmuxSession(withRunHostDefault(get().scope, tab), get().scope),
+      key,
+    };
+    if (!opts?.seeded) countTabOpen(get().scope, entry);
     set((s) => {
       const { tabs, layout, focusedGroupId } = currentScopeState(s);
       const nextTabs = [...tabs, entry];
@@ -904,6 +1762,45 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     return entry;
   },
 
+  addTabToScope: (scope, tab) => {
+    const key = nextKey(tab.kind);
+    const entry: TabEntry = {
+      ...withTmuxSession(withRunHostDefault(scope, tab), scope),
+      key,
+      scope,
+    };
+    countTabOpen(scope, entry);
+    set((s) => {
+      const tabs = s.tabsByScope[scope] ?? [];
+      const layout = s.layoutByScope[scope] ?? null;
+      const focusedGroupId = s.focusedGroupByScope[scope] ?? null;
+      const nextTabs = [...tabs, entry];
+
+      // No layout yet → create a root group containing this tab.
+      if (!layout) {
+        const root: GroupNode = {
+          type: "group",
+          id: nextGroupId(),
+          tabKeys: [key],
+          activeKey: key,
+        };
+        return writeScope(s, scope, nextTabs, root, root.id);
+      }
+
+      // Add into that scope's focused group (fall back to its first group).
+      const target =
+        (focusedGroupId && findGroup(layout, focusedGroupId)) ||
+        allGroups(layout)[0];
+      const next = mapGroup(layout, target.id, (g) => ({
+        ...g,
+        tabKeys: [...g.tabKeys, key],
+        activeKey: key,
+      }));
+      return writeScope(s, scope, nextTabs, next, target.id);
+    });
+    return entry;
+  },
+
   ensureTab: (tab, matches) => {
     const existing = get().tabs.find(matches);
     if (existing) {
@@ -925,9 +1822,72 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
+  detachScopeFromRemote: (scope, oldDir, newDir) => {
+    set((s) => {
+      const tabs = s.tabsByScope[scope] ?? [];
+      if (!tabs.length || !oldDir || !newDir || oldDir === newDir) return {};
+      let changed = false;
+      const nextTabs = tabs.map((t) => {
+        const wasRemoteLoc = t.location === "remote";
+        const underOld = t.cwd === oldDir || t.cwd.startsWith(`${oldDir}/`);
+        if (!wasRemoteLoc && !underOld) return t;
+        changed = true;
+        return {
+          ...t,
+          // A tab that ran ON THE HOST has a cwd in the host's filesystem, which means
+          // nothing here — it can only land in the promoted mirror root.
+          cwd: underOld ? `${newDir}${t.cwd.slice(oldDir.length)}` : newDir,
+          // …and it must stop claiming to run on a host this project no longer has.
+          location: wasRemoteLoc ? undefined : t.location,
+        };
+      });
+      if (!changed) return {};
+      const layout = s.layoutByScope[scope] ?? null;
+      const focused = s.focusedGroupByScope[scope] ?? null;
+      return writeScope(s, scope, nextTabs, layout, focused);
+    });
+  },
+
+  retargetTabs: (oldAbs, newAbs) => {
+    set((s) => {
+      const scope = s.scope;
+      const tabs = s.tabsByScope[scope] ?? [];
+      const oldBase = oldAbs.slice(oldAbs.lastIndexOf("/") + 1);
+      const newBase = newAbs.slice(newAbs.lastIndexOf("/") + 1);
+      let changed = false;
+      const nextTabs = tabs.map((t) => {
+        if (t.kind !== "embed" || !t.embedPath) return t;
+        if (t.embedPath === oldAbs) {
+          changed = true;
+          // Refresh the label to the new basename only when it still shows the
+          // old one — don't clobber a tab the user renamed.
+          const label = t.label === oldBase ? newBase : t.label;
+          return { ...t, embedPath: newAbs, label };
+        }
+        if (t.embedPath.startsWith(`${oldAbs}/`)) {
+          // A tab under a renamed/moved directory: prefix-swap, keep the label.
+          changed = true;
+          return { ...t, embedPath: `${newAbs}${t.embedPath.slice(oldAbs.length)}` };
+        }
+        return t;
+      });
+      if (!changed) return {};
+      const patch: Partial<TabsStore> = {
+        tabsByScope: { ...s.tabsByScope, [scope]: nextTabs },
+      };
+      // Keep the flat mirror in sync so the active scope's CenterPanel re-renders.
+      patch.tabs = nextTabs;
+      return patch;
+    });
+  },
+
   removeTab: (key) => {
     // Discard any session-only link routes that pointed FROM this tab (#50).
     useLinkRoutingStore.getState().purgeForTab(key);
+    bumpUsage(get().scope, METRIC.TAB_CLOSED);
+    // The PTY is gone; drop its half-typed-prompt state so a recycled id can
+    // never inherit it.
+    forgetPty(`${get().scope}:${key}`);
     set((s) => {
       const { tabs, layout, focusedGroupId } = currentScopeState(s);
       const nextTabs = tabs.filter((t) => t.key !== key);
@@ -998,6 +1958,72 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
+  setTabTmuxName: (scope, key, name) => {
+    set((s) => {
+      const tabs = s.tabsByScope[scope] ?? [];
+      const nextTabs = tabs.map((t) =>
+        t.key === key
+          ? t.tmuxAttach
+            ? { ...t, tmuxAttach: name }
+            : { ...t, tmuxSession: name }
+          : t,
+      );
+      const patch: Partial<TabsStore> = {
+        tabsByScope: { ...s.tabsByScope, [scope]: nextTabs },
+      };
+      if (s.scope === scope) patch.tabs = nextTabs;
+      return patch;
+    });
+  },
+
+  setTabLocation: (key, location) => {
+    set((s) => {
+      const { tabs, layout, focusedGroupId } = currentScopeState(s);
+      let changed = false;
+      const nextTabs = tabs.map((t) => {
+        if (t.key !== key || t.location === location) return t;
+        changed = true;
+        return { ...t, location };
+      });
+      // No-op (stable array) when the value is unchanged, so an idle re-toggle
+      // doesn't churn the tabs array / wake the saveLayout debounce.
+      if (!changed) return {};
+      return writeScope(s, s.scope, nextTabs, layout, focusedGroupId);
+    });
+  },
+
+  setAgentMode: (key, mode) => {
+    set((s) => {
+      const { tabs, layout, focusedGroupId } = currentScopeState(s);
+      let changed = false;
+      const nextTabs = tabs.map((t) => {
+        if (t.key !== key || t.agentMode === mode) return t;
+        const prev = t.args ?? [];
+        const args = withAgentMode(t.cmd, prev, mode);
+        // withAgentMode hands back the very same array for an agent with no mode
+        // support — don't record a mode we didn't actually pass.
+        if (args === prev) return t;
+        changed = true;
+        return {
+          ...t,
+          agentMode: mode,
+          // The args change is what respawns the PTY (TerminalView keys its
+          // spawn effect on them).
+          args,
+          // The respawn replays `initialInput` — for Claude that is the
+          // `/rename <project>` launch command. Typing it again into a session
+          // we are *resuming* would be junk, so retire it once the tab has
+          // launched at least once.
+          initialInput: undefined,
+        };
+      });
+      // Stable array when nothing changed, so an idle re-toggle doesn't churn
+      // the tabs array / wake the saveLayout debounce.
+      if (!changed) return {};
+      return writeScope(s, s.scope, nextTabs, layout, focusedGroupId);
+    });
+  },
+
   setViewerState: (key, patch) => {
     set((s) => {
       const { tabs, layout, focusedGroupId } = currentScopeState(s);
@@ -1009,10 +2035,19 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       const cur = tab.viewerState ?? {};
       if (
         cur.scrollTop === merged.scrollTop &&
+        cur.yamlScrollTop === merged.yamlScrollTop &&
         cur.scrollLeft === merged.scrollLeft &&
         cur.scale === merged.scale &&
         cur.offsetX === merged.offsetX &&
-        cur.offsetY === merged.offsetY
+        cur.offsetY === merged.offsetY &&
+        cur.fontSize === merged.fontSize &&
+        cur.autocomplete === merged.autocomplete &&
+        cur.autocompleteMode === merged.autocompleteMode &&
+        cur.grammarCheck === merged.grammarCheck &&
+        // New array ref on every change, so this term is false exactly when a card
+        // was folded/unfolded — which is what lets a collapse-only patch through the
+        // guard (it touches none of the scalar fields above).
+        cur.gridCollapsed === merged.gridCollapsed
       ) {
         return {};
       }
@@ -1023,6 +2058,18 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
+  setTabFolder: (key, folder) => {
+    set((s) => {
+      const { tabs, layout, focusedGroupId } = currentScopeState(s);
+      const tab = tabs.find((t) => t.key === key);
+      // No-op when unchanged, so re-listing the same folder doesn't churn the
+      // tabs array and wake the saveLayout debounce for nothing.
+      if (!tab || (tab.folder ?? "") === folder) return {};
+      const nextTabs = tabs.map((t) => (t.key === key ? { ...t, folder } : t));
+      return writeScope(s, s.scope, nextTabs, layout, focusedGroupId);
+    });
+  },
+
   reorderInGroup: (groupId, from, to) => {
     set((s) => {
       const { tabs, layout, focusedGroupId } = currentScopeState(s);
@@ -1087,11 +2134,35 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
-  splitWithTab: (key, targetGroupId, edge) => {
-    if (edge === "center") {
-      get().moveTab(key, targetGroupId);
-      return;
-    }
+  mergeGroups: (targetGroupId, sourceGroupId) => {
+    set((s) => {
+      const { tabs, layout } = currentScopeState(s);
+      if (!layout || targetGroupId === sourceGroupId) return {};
+      const target = findGroup(layout, targetGroupId);
+      const source = findGroup(layout, sourceGroupId);
+      if (!target || !source) return {};
+      const moved = source.tabKeys;
+      // Append source's tabs onto the target (survivor keeps its own activeKey),
+      // then empty the source so collapse drops it and unwraps the split.
+      let next = mapGroup(layout, targetGroupId, (g) => ({
+        ...g,
+        tabKeys: [...g.tabKeys, ...moved],
+        activeKey: g.activeKey ?? moved[0] ?? null,
+      }));
+      next = mapGroup(next, sourceGroupId, (g) => ({
+        ...g,
+        tabKeys: [],
+        activeKey: null,
+      }));
+      return writeScope(s, s.scope, tabs, next, targetGroupId);
+    });
+  },
+
+  splitWithTab: (key, targetGroupId, edge) => {
+    if (edge === "center") {
+      get().moveTab(key, targetGroupId);
+      return;
+    }
     set((s) => {
       const { tabs, layout } = currentScopeState(s);
       if (!layout) return {};
@@ -1140,7 +2211,11 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
   splitWithNewTab: (tab, targetGroupId, edge) => {
     const key = nextKey(tab.kind);
     // Spread first so a stray `key` on the payload can't shadow the minted one.
-    const entry: TabEntry = { ...tab, key };
+    // Mint a persistent tmux session name like addTab/addTabToScope, so a shell
+    // tab created by a split-drag (or a Python run placed via one) is persistence-
+    // eligible — otherwise it silently skips the tmux wrap (idempotent: no-op for a
+    // tab that already carries a session or is a non-shell kind).
+    const entry: TabEntry = { ...withTmuxSession(tab, get().scope), key };
     let created = false;
     set((s) => {
       const { tabs, layout } = currentScopeState(s);
@@ -1185,44 +2260,85 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
+  setGroupFiles: (groupId, open) => {
+    set((s) => {
+      const { tabs, layout, focusedGroupId } = currentScopeState(s);
+      if (!layout || !findGroup(layout, groupId)) return {};
+      const next = mapGroup(layout, groupId, (g) => ({ ...g, filesOpen: open }));
+      return writeScope(s, s.scope, tabs, next, focusedGroupId);
+    });
+  },
+
+  setGroupFilesWidth: (groupId, width) => {
+    set((s) => {
+      const { tabs, layout, focusedGroupId } = currentScopeState(s);
+      if (!layout || !findGroup(layout, groupId)) return {};
+      const next = mapGroup(layout, groupId, (g) => ({ ...g, filesWidth: width }));
+      return writeScope(s, s.scope, tabs, next, focusedGroupId);
+    });
+  },
+
+  setGroupFilesFolder: (groupId, folder) => {
+    set((s) => {
+      const { tabs, layout, focusedGroupId } = currentScopeState(s);
+      const g = layout && findGroup(layout, groupId);
+      // No-op when unchanged, so re-listing the same folder doesn't churn the
+      // layout and wake the saveLayout debounce for nothing (mirrors setTabFolder).
+      if (!g || (g.filesFolder ?? "") === folder) return {};
+      const next = mapGroup(layout, groupId, (grp) => ({ ...grp, filesFolder: folder }));
+      return writeScope(s, s.scope, tabs, next, focusedGroupId);
+    });
+  },
+
   detachGroup: (groupId, opts) => {
     const scope = get().scope;
     const layout = get().layoutByScope[scope] ?? null;
+    // The id is usually a GROUP (live drag-out), but on restart respawn it can be
+    // a SPLIT node — a multi-pane popout re-detached as one whole subtree (#42).
     const group = findGroup(layout, groupId);
-    if (!group) return null;
+    const split = group ? null : findSplit(layout, groupId);
+    if (!group && !split) return null;
     // Refuse to detach the only group: the in-window layout must keep a body —
     // except on restart respawn (`allowLastGroup`), where the popout legitimately
     // becomes the scope's only window and the main center is left empty.
     if (!opts?.allowLastGroup && allGroups(layout).length <= 1) return null;
 
     const label = `detached-${scope}-${groupId}`;
-    // Snapshot the group's subtree (it is a single GroupNode in v1).
-    const subtree: GroupNode = {
-      type: "group",
-      id: group.id,
-      tabKeys: [...group.tabKeys],
-      activeKey: group.activeKey,
-    };
+    // Snapshot the popout's subtree: a single GroupNode, or the whole split node
+    // (multi-pane popout) verbatim — its ids are reused as the popout's content.
+    const subtree: LayoutNode = group
+      // Spread so per-group extras (the files sidebar's open flag + width)
+      // travel with the subtree.
+      ? { ...group, tabKeys: [...group.tabKeys] }
+      : (split as SplitNode);
+    // Group ids that leave the in-window layout (one for a group, several for a
+    // split) — used to drop focus if it pointed into the detached subtree.
+    const detachedGroupIds = new Set(allGroups(subtree).map((g) => g.id));
 
     set((s) => {
       const tabs = s.tabsByScope[scope] ?? [];
       const focus = s.focusedGroupByScope[scope] ?? null;
-      // Empty the detached group's node, then collapse via writeScope WITHOUT
-      // dropping its tab payloads (they stay in tabsByScope — the detached
-      // window renders them). Mirrors closeGroup's node-empty step, but keeps
-      // the payloads (closeGroup drops them).
-      const emptied = layout
-        ? mapGroup(layout, groupId, (g) => ({ ...g, tabKeys: [], activeKey: null }))
-        : null;
-      // Re-pick focus off the detached group onto a surviving one.
-      const nextFocus = focus === groupId ? null : focus;
-      const base = writeScope(s, scope, tabs, emptied, nextFocus);
+      // Remove the detached subtree from the in-window layout WITHOUT dropping its
+      // tab payloads (they stay in tabsByScope — the detached window renders them).
+      // A group is emptied in place (collapse drops it); a split subtree is pruned
+      // out whole. Mirrors closeGroup's node-empty step, but keeps the payloads.
+      const stripped = !layout
+        ? null
+        : group
+          ? mapGroup(layout, groupId, (g) => ({ ...g, tabKeys: [], activeKey: null }))
+          : removeNodeById(layout, groupId);
+      // Re-pick focus off the detached subtree onto a surviving group.
+      const nextFocus = focus && detachedGroupIds.has(focus) ? null : focus;
+      const base = writeScope(s, scope, tabs, stripped, nextFocus);
       const existing = s.detachedGroupsByScope[scope] ?? [];
       return {
         ...base,
         detachedGroupsByScope: {
           ...s.detachedGroupsByScope,
-          [scope]: [...existing, { id: groupId, subtree, label, bounds: opts?.bounds }],
+          [scope]: [
+            ...existing,
+            { id: groupId, subtree, label, bounds: opts?.bounds, zoom: opts?.zoom },
+          ],
         },
       };
     });
@@ -1307,8 +2423,9 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     const label = `detached-${scope}-${groupId}`;
     // Spread first so a stray `key` on the payload can't shadow the minted one;
     // stamp the owning scope (writeScope isn't on this path since the layout is
-    // untouched, so do its scope-stamp here).
-    const entry: TabEntry = { ...tab, key, scope };
+    // untouched, so do its scope-stamp here). Mint the tmux session name too, so a
+    // shell tab detached straight into its own popout stays persistence-eligible.
+    const entry: TabEntry = { ...withTmuxSession(tab, scope), key, scope };
     const subtree: GroupNode = {
       type: "group",
       id: groupId,
@@ -1352,8 +2469,9 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       const tabs = s.tabsByScope[scope] ?? [];
       let layout = s.layoutByScope[scope] ?? null;
       // Regenerate the subtree's ids so a docked-then-redetached group never
-      // collides with a live node id.
-      const fresh = regenIds(entry.subtree) as GroupNode;
+      // collides with a live node id. The subtree may be a split (multi-pane
+      // popout), so keep it a LayoutNode.
+      const fresh = regenIds(entry.subtree);
       if (!layout) {
         // The in-window tree emptied while detached → install as the root.
         layout = fresh;
@@ -1365,23 +2483,26 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
           layout = fresh;
         } else {
           const edge = opts?.edge ?? "right";
-          if (edge === "center") {
-            // Merge the detached tabs into the target group.
+          if (edge === "center" && fresh.type === "group") {
+            // Merge a single-group popout's tabs into the target group.
             layout = mapGroup(layout, target.id, (g) => ({
               ...g,
               tabKeys: [...g.tabKeys, ...fresh.tabKeys],
               activeKey: fresh.activeKey ?? g.activeKey,
             }));
           } else {
+            // Split popout (or a non-center edge): inject the whole subtree
+            // adjacent to the target as its own pane(s).
+            const e = edge === "center" ? "right" : edge;
             const dir: SplitDir =
-              edge === "left" || edge === "right" ? "row" : "column";
-            const before = edge === "left" || edge === "top";
+              e === "left" || e === "right" ? "row" : "column";
+            const before = e === "left" || e === "top";
             layout = insertAdjacent(layout, target.id, fresh, dir, before);
           }
         }
       }
       const remaining = entries.filter((d) => d.id !== detachedId);
-      const base = writeScope(s, scope, tabs, layout, fresh.id);
+      const base = writeScope(s, scope, tabs, layout, firstGroup(fresh).id);
       return {
         ...base,
         detachedGroupsByScope: {
@@ -1396,14 +2517,125 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     }
   },
 
+  hideGroup: (groupId) => {
+    const scope = get().scope;
+    const layout = get().layoutByScope[scope] ?? null;
+    // Mirror detachGroup's node resolution: usually a GROUP, but can be a SPLIT
+    // node (a multi-pane subtree hidden whole).
+    const group = findGroup(layout, groupId);
+    const split = group ? null : findSplit(layout, groupId);
+    if (!group && !split) return;
+    // Unlike detachGroup we DO allow hiding the only group: hiding everything
+    // leaves the scope empty (the +-placeholder), a valid resting state.
+
+    const label = `hidden-${scope}-${groupId}`;
+    const subtree: LayoutNode = group
+      // Spread so per-group extras (the files sidebar's open flag + width)
+      // travel with the subtree.
+      ? { ...group, tabKeys: [...group.tabKeys] }
+      : (split as SplitNode);
+    const hiddenGroupIds = new Set(allGroups(subtree).map((g) => g.id));
+
+    set((s) => {
+      const tabs = s.tabsByScope[scope] ?? [];
+      const focus = s.focusedGroupByScope[scope] ?? null;
+      // Strip the hidden subtree from the live layout WITHOUT dropping its tab
+      // payloads (they stay in tabsByScope so the flat pane layer keeps their
+      // PTYs mounted, just display:none). Mirrors detachGroup minus the OS window.
+      const stripped = !layout
+        ? null
+        : group
+          ? mapGroup(layout, groupId, (g) => ({ ...g, tabKeys: [], activeKey: null }))
+          : removeNodeById(layout, groupId);
+      const nextFocus = focus && hiddenGroupIds.has(focus) ? null : focus;
+      const base = writeScope(s, scope, tabs, stripped, nextFocus);
+      const existing = s.hiddenGroupsByScope[scope] ?? [];
+      return {
+        ...base,
+        hiddenGroupsByScope: {
+          ...s.hiddenGroupsByScope,
+          [scope]: [...existing, { id: groupId, subtree, label }],
+        },
+      };
+    });
+  },
+
+  unhideGroup: (hiddenId, opts) => {
+    const scope = get().scope;
+    const entries = get().hiddenGroupsByScope[scope] ?? [];
+    const entry = entries.find((h) => h.id === hiddenId);
+    if (!entry) return;
+
+    set((s) => {
+      const tabs = s.tabsByScope[scope] ?? [];
+      let layout = s.layoutByScope[scope] ?? null;
+      // Regenerate ids so a hidden-then-restored group never collides with a live
+      // node id (mirrors attachGroup). regenIds rewrites GROUP ids but keeps tab
+      // KEYS, so an activeKey maps straight through.
+      let fresh = regenIds(entry.subtree);
+      if (opts?.activeKey) {
+        const target = findGroupOfTab(fresh, opts.activeKey);
+        if (target) {
+          fresh = mapGroup(fresh, target.group.id, (g) => ({ ...g, activeKey: opts.activeKey! }));
+        }
+      }
+      if (!layout) {
+        // The tree emptied while hidden → install the restored subtree as root.
+        layout = fresh;
+      } else {
+        const target = allGroups(layout)[0];
+        if (!target) {
+          layout = fresh;
+        } else {
+          // Inject the whole subtree as a new pane to the right of the first group.
+          layout = insertAdjacent(layout, target.id, fresh, "row", false);
+        }
+      }
+      const remaining = entries.filter((h) => h.id !== hiddenId);
+      const base = writeScope(s, scope, tabs, layout, firstGroup(fresh).id);
+      return {
+        ...base,
+        hiddenGroupsByScope: {
+          ...s.hiddenGroupsByScope,
+          [scope]: remaining,
+        },
+      };
+    });
+  },
+
+  closeHiddenGroup: (hiddenId) => {
+    set((s) => {
+      const scope = s.scope;
+      const entries = s.hiddenGroupsByScope[scope] ?? [];
+      const entry = entries.find((h) => h.id === hiddenId);
+      if (!entry) return {};
+      // Kill the hidden group's tabs for good: drop their payloads (the flat pane
+      // layer then unmounts each pane → pty_kill) and purge their link routes,
+      // mirroring closeGroup. The subtree may be a split, so collect every key.
+      const removing = new Set(orderedTabKeys(entry.subtree));
+      const purge = useLinkRoutingStore.getState().purgeForTab;
+      removing.forEach((k) => purge(k));
+      const nextTabs = (s.tabsByScope[scope] ?? []).filter((t) => !removing.has(t.key));
+      const remaining = entries.filter((h) => h.id !== hiddenId);
+      const { layout, focusedGroupId } = currentScopeState(s);
+      const base = writeScope(s, scope, nextTabs, layout, focusedGroupId);
+      return {
+        ...base,
+        hiddenGroupsByScope: {
+          ...s.hiddenGroupsByScope,
+          [scope]: remaining,
+        },
+      };
+    });
+  },
+
   attachDetachedTab: (scope, detachedGroupId, tabKey, opts) => {
     const entries = get().detachedGroupsByScope[scope] ?? [];
     const entry = entries.find((d) => d.id === detachedGroupId);
-    if (!entry || !entry.subtree.tabKeys.includes(tabKey)) return;
+    if (!entry || !orderedTabKeys(entry.subtree).includes(tabKey)) return;
 
-    // The detached group is emptied by this tab leaving → close the popout.
-    const remainingKeys = entry.subtree.tabKeys.filter((k) => k !== tabKey);
-    const willEmpty = remainingKeys.length === 0;
+    // The detached popout is emptied by this tab leaving → close the window.
+    const willEmpty = orderedTabKeys(entry.subtree).filter((k) => k !== tabKey).length === 0;
 
     set((s) => {
       // 1. Insert the tab into the destination layout (the docked-into scope's,
@@ -1449,21 +2681,11 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       //    it leaves the popout empty.
       const nextEntries = willEmpty
         ? entries.filter((d) => d.id !== detachedGroupId)
-        : entries.map((d) =>
-            d.id === detachedGroupId
-              ? {
-                  ...d,
-                  subtree: {
-                    ...d.subtree,
-                    tabKeys: remainingKeys,
-                    activeKey:
-                      d.subtree.activeKey === tabKey
-                        ? (remainingKeys[0] ?? null)
-                        : d.subtree.activeKey,
-                  },
-                }
-              : d,
-          );
+        : entries.map((d) => {
+            if (d.id !== detachedGroupId) return d;
+            const sub = removeKeyFromTree(d.subtree, tabKey);
+            return sub ? { ...d, subtree: sub } : d;
+          });
 
       // 3. Commit the layout (writeScope keeps the payload + updates the live
       //    mirrors for the active scope; it's a no-op on the mirrors otherwise),
@@ -1484,6 +2706,264 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     }
   },
 
+  attachDetachedPane: (scope, detachedGroupId, paneId, opts) => {
+    const entries = get().detachedGroupsByScope[scope] ?? [];
+    const entry = entries.find((d) => d.id === detachedGroupId);
+    if (!entry) return;
+    const pane = findGroup(entry.subtree, paneId);
+    if (!pane) return;
+
+    // The pane is the popout's only group → this IS a whole-popout dock; the
+    // whole-group paths also close the OS window.
+    const remaining = removeNodeById(entry.subtree, paneId);
+    if (!remaining) {
+      if (get().scope === scope) get().attachGroup(detachedGroupId, opts);
+      else get().dropDetachedGroup(scope, detachedGroupId);
+      return;
+    }
+
+    set((s) => {
+      // 1. Inject the pane into the destination layout as one group (fresh id so
+      //    it can never collide with a live node id). Its tab payloads already
+      //    live in tabsByScope[scope]; only the keys move.
+      let layout = s.layoutByScope[scope] ?? null;
+      const fresh: GroupNode = {
+        type: "group",
+        id: nextGroupId(),
+        tabKeys: [...pane.tabKeys],
+        activeKey: pane.activeKey ?? pane.tabKeys[0] ?? null,
+      };
+      let destId = fresh.id;
+      if (!layout) {
+        layout = fresh; // empty scope → the pane becomes the root group.
+      } else {
+        const target =
+          (opts?.targetGroupId && findGroup(layout, opts.targetGroupId)) ||
+          allGroups(layout)[0];
+        if (!target) {
+          layout = fresh;
+        } else if (opts?.edge === "center") {
+          // Merge the pane's tabs into the target group.
+          layout = mapGroup(layout, target.id, (g) => ({
+            ...g,
+            tabKeys: [...g.tabKeys, ...pane.tabKeys],
+            activeKey: pane.activeKey ?? g.activeKey,
+          }));
+          destId = target.id;
+        } else {
+          // Default (no resolved target): land as its own pane on the right —
+          // a pane is a subwindow, so it keeps being one (mirrors attachGroup).
+          const edge = opts?.edge ?? "right";
+          const dir: SplitDir = edge === "left" || edge === "right" ? "row" : "column";
+          const before = edge === "left" || edge === "top";
+          layout = insertAdjacent(layout, target.id, fresh, dir, before);
+        }
+      }
+
+      // 2. Drop the pane's group node from the popout's subtree — the sibling
+      //    panes stay floating in the popout.
+      const nextEntries = (s.detachedGroupsByScope[scope] ?? []).map((d) =>
+        d.id === detachedGroupId ? { ...d, subtree: remaining } : d,
+      );
+
+      const tabs = s.tabsByScope[scope] ?? [];
+      const base = writeScope(s, scope, tabs, layout, destId);
+      return {
+        ...base,
+        detachedGroupsByScope: {
+          ...s.detachedGroupsByScope,
+          [scope]: nextEntries,
+        },
+      };
+    });
+  },
+
+  detachTabToNewWindow: (scope, fromGroupId, tabKey, bounds) => {
+    const entries = get().detachedGroupsByScope[scope] ?? [];
+    const src = entries.find((d) => d.id === fromGroupId);
+    // The source popout (and the tab within it) must still exist.
+    if (!src || !orderedTabKeys(src.subtree).includes(tabKey)) return null;
+    // A lone-tab popout dragged whole is already its own window — re-detaching it
+    // would empty the source and churn for nothing, so refuse that case.
+    const remaining = removeKeyFromTree(src.subtree, tabKey);
+    if (!remaining || orderedTabKeys(remaining).length === 0) return null;
+
+    const groupId = nextGroupId();
+    const label = `detached-${scope}-${groupId}`;
+    // The popped tab becomes the sole member of a fresh single-tab group; its
+    // payload stays in tabsByScope (shared), so the new popout self-seeds and the
+    // PTY never unmounts (mirrors `detachTab`).
+    const subtree: GroupNode = {
+      type: "group",
+      id: groupId,
+      tabKeys: [tabKey],
+      activeKey: tabKey,
+    };
+
+    set((s) => {
+      const existing = s.detachedGroupsByScope[scope] ?? [];
+      // One atomic update: strip the tab from the source popout's subtree AND
+      // append the new detached entry. The payload in `tabsByScope` is untouched.
+      const nextEntries = existing.map((d) =>
+        d.id === fromGroupId ? { ...d, subtree: remaining } : d,
+      );
+      return {
+        detachedGroupsByScope: {
+          ...s.detachedGroupsByScope,
+          [scope]: [...nextEntries, { id: groupId, subtree, label, bounds }],
+        },
+      };
+    });
+
+    invoke("detach_subwindow", {
+      projectId: scope,
+      groupId,
+      x: bounds.x,
+      y: bounds.y,
+      width: bounds.w,
+      height: bounds.h,
+    }).catch(() => {});
+    return label;
+  },
+
+  detachPaneToNewWindow: (scope, fromGroupId, paneId, bounds) => {
+    const entries = get().detachedGroupsByScope[scope] ?? [];
+    const src = entries.find((d) => d.id === fromGroupId);
+    if (!src) return null;
+    const pane = findGroup(src.subtree, paneId);
+    if (!pane) return null;
+    // A lone-pane popout dragged by its grip is already its own window —
+    // re-detaching it would empty the source and churn for nothing.
+    const remaining = removeNodeById(src.subtree, paneId);
+    if (!remaining) return null;
+
+    const groupId = nextGroupId();
+    const label = `detached-${scope}-${groupId}`;
+    // The pane becomes the whole subtree of a fresh popout; its tab payloads
+    // stay in tabsByScope (shared), so the new popout self-seeds and the PTYs
+    // never unmount (mirrors detachTabToNewWindow).
+    const subtree: GroupNode = {
+      type: "group",
+      id: groupId,
+      tabKeys: [...pane.tabKeys],
+      activeKey: pane.activeKey ?? pane.tabKeys[0] ?? null,
+    };
+
+    set((s) => {
+      const existing = s.detachedGroupsByScope[scope] ?? [];
+      // One atomic update: strip the pane from the source popout's subtree AND
+      // append the new detached entry. The payloads in `tabsByScope` are untouched.
+      const nextEntries = existing.map((d) =>
+        d.id === fromGroupId ? { ...d, subtree: remaining } : d,
+      );
+      return {
+        detachedGroupsByScope: {
+          ...s.detachedGroupsByScope,
+          [scope]: [...nextEntries, { id: groupId, subtree, label, bounds }],
+        },
+      };
+    });
+
+    invoke("detach_subwindow", {
+      projectId: scope,
+      groupId,
+      x: bounds.x,
+      y: bounds.y,
+      width: bounds.w,
+      height: bounds.h,
+    }).catch(() => {});
+    return label;
+  },
+
+  dockTabIntoDetached: (scope, detachedGroupId, tabKey, target) => {
+    const entries = get().detachedGroupsByScope[scope] ?? [];
+    const entry = entries.find((d) => d.id === detachedGroupId);
+    // Reject a no-op: the tab must exist in this scope and not already be in the
+    // target popout.
+    if (!entry || orderedTabKeys(entry.subtree).includes(tabKey)) return;
+
+    set((s) => {
+      const tabs = s.tabsByScope[scope] ?? [];
+      if (!tabs.some((t) => t.key === tabKey)) return {};
+      const layout = s.layoutByScope[scope] ?? null;
+      const focus = s.focusedGroupByScope[scope] ?? null;
+      // 1. Drop the tab from its source in-window group (its payload stays in
+      //    `tabs`, so writeScope keeps it and the pane stays mounted-but-hidden).
+      //    An emptied source group/layout is fine — the main center falls back to
+      //    the placeholder, exactly like `detachTab`.
+      const found = findGroupOfTab(layout, tabKey);
+      const stripped =
+        found && layout
+          ? mapGroup(layout, found.group.id, (g) => {
+              const tabKeys = g.tabKeys.filter((k) => k !== tabKey);
+              const activeKey =
+                g.activeKey === tabKey
+                  ? (tabKeys[Math.min(found.index, tabKeys.length - 1)] ?? null)
+                  : g.activeKey;
+              return { ...g, tabKeys, activeKey };
+            })
+          : layout;
+      const base = writeScope(s, scope, tabs, stripped, focus);
+      // 2. Place the tab in the detached group's subtree at the resolved pane
+      //    target (a body edge splits, center/a slot merges) + activate it there.
+      //    No target → append to the first pane (legacy single-pane behaviour).
+      const nextEntries = (s.detachedGroupsByScope[scope] ?? []).map((d) =>
+        d.id === detachedGroupId
+          ? { ...d, subtree: placeKeyInTree(d.subtree, tabKey, target) }
+          : d,
+      );
+      return {
+        ...base,
+        detachedGroupsByScope: {
+          ...s.detachedGroupsByScope,
+          [scope]: nextEntries,
+        },
+      };
+    });
+  },
+
+  moveTabBetweenDetached: (scope, fromGroupId, toGroupId, tabKey, target, opts) => {
+    // A tab can't move onto itself, and both endpoints must exist.
+    if (fromGroupId === toGroupId) return;
+    const entries = get().detachedGroupsByScope[scope] ?? [];
+    const from = entries.find((d) => d.id === fromGroupId);
+    const to = entries.find((d) => d.id === toGroupId);
+    if (!from || !to) return;
+    // The tab must live in the source and NOT already in the destination.
+    if (!orderedTabKeys(from.subtree).includes(tabKey)) return;
+    if (orderedTabKeys(to.subtree).includes(tabKey)) return;
+    // The source popout is emptied by this tab leaving → close its OS window.
+    const willEmpty =
+      orderedTabKeys(from.subtree).filter((k) => k !== tabKey).length === 0;
+
+    set((s) => {
+      const list = s.detachedGroupsByScope[scope] ?? [];
+      // One atomic pass: place the key in the destination subtree and strip it
+      // from the source. The payload in `tabsByScope` is untouched (shared PTY).
+      let next = list.map((d) => {
+        if (d.id === toGroupId) {
+          return { ...d, subtree: placeKeyInTree(d.subtree, tabKey, target) };
+        }
+        if (d.id === fromGroupId) {
+          const sub = removeKeyFromTree(d.subtree, tabKey);
+          return sub ? { ...d, subtree: sub } : d;
+        }
+        return d;
+      });
+      // Drop the source record entirely when the tab leaving emptied it.
+      if (willEmpty) next = next.filter((d) => d.id !== fromGroupId);
+      return {
+        detachedGroupsByScope: { ...s.detachedGroupsByScope, [scope]: next },
+      };
+    });
+
+    // Close the emptied source popout's OS window (frees the registry slot). The
+    // destination window is re-seeded by the caller so the moved tab renders.
+    if (willEmpty && !opts?.skipBackend) {
+      invoke("attach_subwindow", { registryId: from.label }).catch(() => {});
+    }
+  },
+
   applyDetachedEdit: (scope, groupId, edit) => {
     set((s) => {
       const entries = s.detachedGroupsByScope[scope] ?? [];
@@ -1491,14 +2971,18 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       if (idx < 0) return {};
       const entry = entries[idx];
       const sub = entry.subtree;
-      let nextSub: GroupNode = sub;
+      // A subtree may be a split (multi-pane popout); each edit targets the group
+      // that owns `edit.key` (or, for reorder, the group whose tabs it permutes).
+      let nextSub: LayoutNode | null = sub;
       let nextTabs = s.tabsByScope[scope] ?? null;
       switch (edit.kind) {
-        case "activate":
-          if (sub.tabKeys.includes(edit.key)) {
-            nextSub = { ...sub, activeKey: edit.key };
+        case "activate": {
+          const g = findGroupOfTab(sub, edit.key);
+          if (g) {
+            nextSub = mapGroup(sub, g.group.id, (grp) => ({ ...grp, activeKey: edit.key }));
           }
           break;
+        }
         case "rename": {
           const label = edit.label.trim();
           if (label && nextTabs) {
@@ -1508,28 +2992,68 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
           }
           break;
         }
+        case "setLocation": {
+          // Locality lives on the payload; the popout's pane is owned by THIS
+          // (main) window's flat pane layer, so updating it here respawns that
+          // pane on the chosen host (same path as the main-window locality badge).
+          if (nextTabs) {
+            nextTabs = nextTabs.map((t) =>
+              t.key === edit.key && t.location !== edit.location
+                ? { ...t, location: edit.location }
+                : t,
+            );
+          }
+          break;
+        }
         case "close": {
-          const tabKeys = sub.tabKeys.filter((k) => k !== edit.key);
-          const activeKey =
-            sub.activeKey === edit.key ? (tabKeys[0] ?? null) : sub.activeKey;
-          nextSub = { ...sub, tabKeys, activeKey };
+          nextSub = removeKeyFromTree(sub, edit.key);
           // Drop the closed tab's payload (its pane in the detached window
           // unmounted; the PTY is killed there by the spawning pane's lifetime).
           if (nextTabs) nextTabs = nextTabs.filter((t) => t.key !== edit.key);
           break;
         }
         case "reorder": {
-          const owned = new Set(sub.tabKeys);
-          const tabKeys = edit.tabKeys.filter((k) => owned.has(k));
-          if (tabKeys.length === sub.tabKeys.length) {
-            nextSub = { ...sub, tabKeys };
+          // Find the group whose tab set the reordered list permutes, then
+          // reapply that order to it.
+          const want = new Set(edit.tabKeys);
+          const g = allGroups(sub).find(
+            (grp) =>
+              grp.tabKeys.length === edit.tabKeys.length &&
+              grp.tabKeys.every((k) => want.has(k)),
+          );
+          if (g) {
+            nextSub = mapGroup(sub, g.id, (grp) => ({ ...grp, tabKeys: edit.tabKeys }));
           }
           break;
         }
+        case "split":
+          // A pane split inside the popout: split the subtree, or no-op if the
+          // split is invalid (keeps the popout unchanged).
+          nextSub = splitSubtree(sub, edit.key, edit.targetGroupId, edit.edge) ?? sub;
+          break;
+        case "resize":
+          // A divider drag inside a multi-pane popout: adjust the targeted
+          // split's child fractions.
+          nextSub = applyResize(sub, edit.splitId, edit.dividerIndex, edit.fraction);
+          break;
+        case "move":
+          // Merge a tab across the popout's groups: null (removal emptied the
+          // tree — impossible for a cross-group move) leaves the popout unchanged.
+          nextSub = moveKeyInTree(sub, edit.key, edit.targetGroupId, edit.index) ?? sub;
+          break;
+        case "files":
+          // The popout toggled/resized a group's docked file-viewer column.
+          nextSub = mapGroup(sub, edit.groupId, (grp) => ({
+            ...grp,
+            ...(edit.open != null ? { filesOpen: edit.open } : {}),
+            ...(edit.width != null ? { filesWidth: edit.width } : {}),
+            ...(edit.folder != null ? { filesFolder: edit.folder } : {}),
+          }));
+          break;
       }
       const nextEntries = [...entries];
-      // If the detached group emptied, remove it entirely.
-      if (nextSub.tabKeys.length === 0) {
+      // If the detached popout emptied, remove it entirely.
+      if (!nextSub || orderedTabKeys(nextSub).length === 0) {
         nextEntries.splice(idx, 1);
       } else {
         nextEntries[idx] = { ...entry, subtree: nextSub };
@@ -1545,6 +3069,106 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
+  addDetachedTab: (scope, detachedGroupId, tab, targetGroupId) => {
+    const key = nextKey(tab.kind);
+    // Spread first so a stray `key` on the payload can't shadow the minted one;
+    // stamp the owning scope (this path never touches the in-window layout, so it
+    // does writeScope's scope-stamp itself). Mint the tmux session name like the
+    // in-window adds, so a Python/shell run STREAMED into a detached popout (its
+    // Run button places the tab here, not via addTabToScope) is persistence-
+    // eligible instead of silently skipping the tmux wrap.
+    const entry: TabEntry = { ...withTmuxSession(tab, scope), key, scope };
+    let created: string | null = null;
+    set((s) => {
+      const entries = s.detachedGroupsByScope[scope] ?? [];
+      const idx = entries.findIndex((d) => d.id === detachedGroupId);
+      if (idx < 0) return {};
+      const rec = entries[idx];
+      // Land the tab in the requested pane; fall back to the popout's first group
+      // (a single-pane popout, or a stale target id).
+      const target = findGroup(rec.subtree, targetGroupId) ?? allGroups(rec.subtree)[0];
+      if (!target) return {};
+      const nextSub = mapGroup(rec.subtree, target.id, (g) => ({
+        ...g,
+        tabKeys: [...g.tabKeys, key],
+        activeKey: key,
+      }));
+      const nextEntries = [...entries];
+      nextEntries[idx] = { ...rec, subtree: nextSub };
+      // Append the payload so the MAIN window's pane layer mounts + owns the PTY;
+      // the detached window attaches to it after the re-seed.
+      const nextTabs = [...(s.tabsByScope[scope] ?? []), entry];
+      created = key;
+      return {
+        tabsByScope: { ...s.tabsByScope, [scope]: nextTabs },
+        // Mirror the current-scope convenience copy (writeScope normally does
+        // this, but this path leaves the in-window layout untouched and skips it).
+        ...(s.scope === scope ? { tabs: nextTabs } : {}),
+        detachedGroupsByScope: {
+          ...s.detachedGroupsByScope,
+          [scope]: nextEntries,
+        },
+      };
+    });
+    return created;
+  },
+
+  addDetachedTabSplit: (scope, detachedGroupId, tab, targetGroupId, edge) => {
+    const key = nextKey(tab.kind);
+    // Spread first so a stray `key` can't shadow the minted one; stamp the scope
+    // (this path never touches the in-window layout, so no writeScope to do it).
+    // Mint the tmux session name too (see addDetachedTab) so a shell tab streamed
+    // into a popout via a split-drop is persistence-eligible.
+    const entry: TabEntry = { ...withTmuxSession(tab, scope), key, scope };
+    let created: string | null = null;
+    set((s) => {
+      const entries = s.detachedGroupsByScope[scope] ?? [];
+      const idx = entries.findIndex((d) => d.id === detachedGroupId);
+      if (idx < 0) return {};
+      const rec = entries[idx];
+      // Carve a new pane holding the tab at `edge` of the target group, leaving
+      // the target's own tabs untouched — mirrors `splitWithNewTab`'s edge
+      // branch, but on the popout's subtree. A stale target id → no split.
+      if (!findGroup(rec.subtree, targetGroupId)) return {};
+      const newGroup: GroupNode = {
+        type: "group",
+        id: nextGroupId(),
+        tabKeys: [key],
+        activeKey: key,
+      };
+      const dir: SplitDir = edge === "left" || edge === "right" ? "row" : "column";
+      const before = edge === "left" || edge === "top";
+      const nextSub = insertAdjacent(rec.subtree, targetGroupId, newGroup, dir, before);
+      const nextEntries = [...entries];
+      nextEntries[idx] = { ...rec, subtree: nextSub };
+      // Append the payload so the MAIN window's pane layer mounts + owns the PTY;
+      // the detached window attaches to it after the re-seed.
+      const nextTabs = [...(s.tabsByScope[scope] ?? []), entry];
+      created = key;
+      return {
+        tabsByScope: { ...s.tabsByScope, [scope]: nextTabs },
+        ...(s.scope === scope ? { tabs: nextTabs } : {}),
+        detachedGroupsByScope: { ...s.detachedGroupsByScope, [scope]: nextEntries },
+      };
+    });
+    return created;
+  },
+
+  splitDetachedGroup: (scope, detachedGroupId, key, targetGroupId, edge) => {
+    set((s) => {
+      const entries = s.detachedGroupsByScope[scope] ?? [];
+      const idx = entries.findIndex((d) => d.id === detachedGroupId);
+      if (idx < 0) return {};
+      const nextSub = splitSubtree(entries[idx].subtree, key, targetGroupId, edge);
+      if (!nextSub) return {};
+      const nextEntries = [...entries];
+      nextEntries[idx] = { ...entries[idx], subtree: nextSub };
+      return {
+        detachedGroupsByScope: { ...s.detachedGroupsByScope, [scope]: nextEntries },
+      };
+    });
+  },
+
   dropDetachedGroup: (scope, groupId) => {
     const entries = get().detachedGroupsByScope[scope] ?? [];
     const entry = entries.find((d) => d.id === groupId);
@@ -1556,7 +3180,7 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       );
       // Re-inject the subtree into the inactive scope's STORED layout so its
       // tabs are referenced by a layout node (and thus persist) on next save.
-      const fresh = regenIds(entry.subtree) as GroupNode;
+      const fresh = regenIds(entry.subtree);
       const stored = s.layoutByScope[scope] ?? null;
       let nextLayout: LayoutNode;
       if (!stored) {
@@ -1577,12 +3201,45 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     invoke("attach_subwindow", { registryId: entry.label }).catch(() => {});
   },
 
+  hideDetachedGroup: (scope, groupId) => {
+    const entries = get().detachedGroupsByScope[scope] ?? [];
+    const entry = entries.find((d) => d.id === groupId);
+    if (!entry) return;
+
+    set((s) => {
+      const remaining = (s.detachedGroupsByScope[scope] ?? []).filter(
+        (d) => d.id !== groupId,
+      );
+      const existing = s.hiddenGroupsByScope[scope] ?? [];
+      // The popout's tab payloads never left `tabsByScope`, so the flat pane
+      // layer keeps their PTYs mounted through the move — only the subtree
+      // changes home, from the detached record to the hidden one. Ids are kept
+      // as-is (like `hideGroup`); `unhideGroup` regenerates them on restore to
+      // avoid colliding with a live node. Mirror the flat tab list is untouched
+      // (no tab payload changes here).
+      return {
+        detachedGroupsByScope: { ...s.detachedGroupsByScope, [scope]: remaining },
+        hiddenGroupsByScope: {
+          ...s.hiddenGroupsByScope,
+          [scope]: [
+            ...existing,
+            { id: entry.id, subtree: entry.subtree, label: entry.label },
+          ],
+        },
+      };
+    });
+
+    // Close the detached OS window + drop the backend registry entry (best-effort;
+    // the popout also destroys its own window). Mirrors dropDetachedGroup.
+    invoke("attach_subwindow", { registryId: entry.label }).catch(() => {});
+  },
+
   closeDetachedGroup: (scope, groupId) => {
     const entries = get().detachedGroupsByScope[scope] ?? [];
     const entry = entries.find((d) => d.id === groupId);
     if (!entry) return;
 
-    const keys = entry.subtree.tabKeys;
+    const keys = orderedTabKeys(entry.subtree);
     const byKey = new Map((get().tabsByScope[scope] ?? []).map((t) => [t.key, t] as const));
     // Tear down each tab BEFORE the store mutation: discard its session-only
     // link routes (#50) and kill its PTY. Files/embed tabs have no PTY; terminal
@@ -1593,7 +3250,7 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     for (const key of keys) {
       purge(key);
       const tab = byKey.get(key);
-      if (tab && tab.kind !== "files" && tab.kind !== "embed") {
+      if (tab && isPtyTabKind(tab.kind)) {
         invoke("pty_kill", { id: `${scope}:${key}` }).catch(() => {});
       }
     }
@@ -1641,6 +3298,21 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     });
   },
 
+  setDetachedZoom: (scope, groupId, zoom) => {
+    set((s) => {
+      const entries = s.detachedGroupsByScope[scope];
+      if (!entries) return {};
+      let changed = false;
+      const next = entries.map((d) => {
+        if (d.id !== groupId || d.zoom === zoom) return d;
+        changed = true;
+        return { ...d, zoom };
+      });
+      if (!changed) return {};
+      return { detachedGroupsByScope: { ...s.detachedGroupsByScope, [scope]: next } };
+    });
+  },
+
   consumePendingRespawn: (scope) => {
     const pending = get().pendingRespawnByScope[scope] ?? [];
     if (pending.length === 0) return [];
@@ -1673,9 +3345,14 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     );
     // #42: re-dock detached groups into the persisted tree (detach is
     // session-only; a restart restores them docked), merge BEFORE pruning so
-    // dropped tabs prune out consistently.
+    // dropped tabs prune out consistently. Hidden groups are folded in the same
+    // way but tagged `hidden` so they restore still-hidden (not docked live).
     const detached = s.detachedGroupsByScope[scope];
-    const merged = withDetachedDocked(serializeTree(layout), detached);
+    const hidden = s.hiddenGroupsByScope[scope];
+    const merged = withHiddenDocked(
+      withDetachedDocked(serializeTree(layout), detached),
+      hidden,
+    );
     const tabGroups = pruneSavedTree(merged, keepKeys);
     return { tabs, tabGroups, activeTabIndex };
   },
@@ -1697,11 +3374,25 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       // Resumable agent tabs (Claude with a sessionId) respawn with their
       // resume flag so the prior conversation comes back; everyone else starts
       // fresh with no args.
-      const tabShape = { kind, cmd: t.cmd, sessionId: t.sessionId };
-      const args =
+      const tabShape = {
+        kind,
+        cmd: t.cmd,
+        sessionId: t.sessionId,
+        resumeArgs: t.resumeArgs,
+      };
+      // A custom agent carries its own resume flag on the tab; a built-in looks
+      // its cmd up in the static table (which needs the captured session id).
+      const base =
         isResumableAgentTab(tabShape) && t.sessionId
-          ? RESUMABLE_AGENTS[t.cmd](t.sessionId)
+          ? t.resumeArgs?.length
+            ? t.resumeArgs
+            : RESUMABLE_AGENTS[t.cmd](t.sessionId)
           : [];
+      // Args are rebuilt from scratch here, so a persisted planner/doer mode has
+      // to be re-applied onto them or the tab would silently come back in the
+      // agent's default mode — half the point of the toggle is that the split
+      // survives a restart.
+      const args = t.agentMode ? withAgentMode(t.cmd, base, t.agentMode) : base;
       return {
         key: freshKey,
         label: t.label,
@@ -1711,12 +3402,36 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
         cwd: isAgent && defaultCwd ? defaultCwd : t.cwd || defaultCwd,
         kind,
         sessionId: t.sessionId,
+        // A restart-resumable custom agent keeps its resume flag (already folded
+        // into `base`/`args` above) so a *second* restart resumes it again.
+        resumeArgs: t.resumeArgs,
         // Restored file embed tabs (kind === "embed") carry their durable path
         // and how to open it so the pane rebuilds exactly.
         embedPath: t.embedPath,
         embedExec: t.embedExec,
         viewer: t.viewer,
         viewerState: t.viewerState,
+        // SSH-sync Phase 0: restore the persisted per-tab locality.
+        location: t.location,
+        // Restore the planner/doer mode (already folded into `args` above).
+        agentMode: t.agentMode,
+        // A "projectfiles" tab reopens on the folder it was browsed into.
+        folder: t.folder,
+        // Persistent sessions (TODO #85): keep the stable session name so the
+        // reattach targets the SAME host session after a relaunch. Mint one for a
+        // shell tab persisted before this feature existed (it then reattaches on
+        // every subsequent restart).
+        tmuxSession:
+          t.tmuxSession ??
+          (kind === "shell" && !t.tmuxAttach
+            ? newTmuxSessionName(targetScope ?? get().scope)
+            : undefined),
+        // A Sessions-view attach tab reattaches to its tmux session on restart.
+        tmuxAttach: t.tmuxAttach,
+        // Restore the no-tmux marker BEFORE anything reads it: the minted name
+        // above is harmless on such a tab precisely because `shouldPersistTab`
+        // refuses to use it.
+        ephemeral: t.ephemeral,
       };
     });
 
@@ -1726,8 +3441,12 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     // re-open them as floating popouts once their panes have mounted.
     let root: LayoutNode | null = null;
     const respawn: RespawnTarget[] = [];
+    // Fresh ids of groups/splits tagged `hidden` in the saved tree. They are
+    // built into the tree (so their tabs mint payloads/PTYs) then stripped out
+    // into `hiddenGroupsByScope` below, so they restore parked, not docked.
+    const hiddenIds: string[] = [];
     if (groups) {
-      root = deserializeTree(groups, keyMap, respawn);
+      root = deserializeTree(groups, keyMap, respawn, hiddenIds);
     }
     if (!root && tabs.length > 0) {
       root = {
@@ -1754,12 +3473,34 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
       }
     }
     root = collapse(root);
+
+    // Extract hidden-tagged subtrees out of the live tree into parked
+    // HiddenGroups (the restore-time mirror of `hideGroup`). Snapshot every node
+    // first (ids are stable across sibling strips), then remove them so the tabs
+    // stay in `tabsByScope` (payloads/PTYs mounted, hidden) but leave the layout.
+    const hiddenGroups: HiddenGroup[] = [];
+    for (const id of hiddenIds) {
+      const g = findGroup(root, id);
+      const sp = g ? null : findSplit(root, id);
+      if (!g && !sp) continue;
+      const subtree: LayoutNode = g
+        ? { type: "group", id: g.id, tabKeys: [...g.tabKeys], activeKey: g.activeKey }
+        : (sp as SplitNode);
+      hiddenGroups.push({ id, subtree, label: `hidden-${targetScope ?? get().scope}-${id}` });
+    }
+    for (const h of hiddenGroups) {
+      root = removeNodeById(root, h.id);
+    }
+
     const focus = allGroups(root)[0]?.id ?? null;
 
-    // Only respawn targets still present in the (possibly pruned/healed) tree:
-    // a detached group whose tabs were all dropped on restore won't exist.
-    const liveIds = new Set(allGroups(root).map((g) => g.id));
-    const pending = respawn.filter((r) => liveIds.has(r.id));
+    // Only respawn targets still present in the (possibly pruned/healed) tree: a
+    // detached popout whose tabs were all dropped on restore won't exist. A target
+    // id may be a GROUP (single-pane popout) or a SPLIT (multi-pane popout), so
+    // check both — `allGroups` alone would drop every split target.
+    const pending = respawn.filter(
+      (r) => findGroup(root, r.id) != null || findSplit(root, r.id) != null,
+    );
 
     set((s) => {
       // Use the explicitly requested scope when provided; this prevents a race
@@ -1773,6 +3514,10 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
           pending.length > 0
             ? { ...s.pendingRespawnByScope, [scope]: pending }
             : s.pendingRespawnByScope,
+        hiddenGroupsByScope:
+          hiddenGroups.length > 0
+            ? { ...s.hiddenGroupsByScope, [scope]: hiddenGroups }
+            : s.hiddenGroupsByScope,
       };
     });
   },
@@ -1780,6 +3525,26 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
   persistScope: async (scope, localFile) => {
     const layout = get().layoutByScope[scope] ?? null;
     const scopeTabs = get().tabsByScope[scope] ?? [];
+    // Whether an EMPTY layout may erase what's on disk. Saving empty is destructive —
+    // it drops `tab_layout`/`tab_groups` AND overwrites the `.eldrun` session mirror,
+    // taking a resumable agent tab's `sessionId` (the only handle on its conversation)
+    // with them. So it must mean "the user closed every tab", and only two things here
+    // can distinguish that from a caller with nothing loaded:
+    //
+    //   hydrated            — the scope has been restored from disk this session. An
+    //                         ABSENT key is a scope we know nothing about; its emptiness
+    //                         is ignorance, not intent. (A scope whose restore found no
+    //                         restorable tabs never creates the key — see CenterPanel.)
+    //   scopeTabs.length    — the scope really holds zero tabs. A scope holding tabs that
+    //                         all get filtered out below (non-restorable, or belonging to
+    //                         another scope) yields an empty list that looks identical to
+    //                         a close-all and is nothing of the sort — that is how
+    //                         a live project's four tabs were erased on detach.
+    //
+    // Anything else: the backend keeps what it has. Worst case we persist a layout one
+    // save late; the alternative loses conversations.
+    const hydrated = Object.prototype.hasOwnProperty.call(get().tabsByScope, scope);
+    const allowClear = hydrated && scopeTabs.length === 0;
     // Order the flat tab union by the tree's stable left-to-right order so the
     // persisted `tabs` array and `groups` tree agree.
     const keyOrder = orderedTabKeys(layout);
@@ -1791,7 +3556,7 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
     for (const t of scopeTabs) {
       if (!keyOrder.includes(t.key)) ordered.push(t);
     }
-    // Shell/files tabs, resumable agent tabs (Claude with a sessionId), and
+    // Shell/files/network tabs, resumable agent tabs (Claude with a sessionId), and
     // in-app file-viewer embeds are persisted; other agent/embed tabs (including
     // external-app embeds) are dropped here and the saved tree is pruned to
     // match. See isRestorableTab. Defense-in-depth (#55): also drop any tab not
@@ -1820,6 +3585,25 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
         embedExec: t.embedExec,
         viewer: t.viewer,
         viewerState: t.viewerState,
+        // SSH-sync Phase 0: persist the per-tab locality.
+        location: t.location,
+        // Persist the planner/doer mode so the tab comes back in it (the args
+        // that carry it are NOT persisted — they're rebuilt in loadFromLayout).
+        agentMode: t.agentMode,
+        // Persist a "projectfiles" tab's browsed folder.
+        folder: t.folder,
+        // Persist a restart-resumable custom agent's resume flag (the args that
+        // carry it are rebuilt in loadFromLayout, like agentMode).
+        resumeArgs: t.resumeArgs,
+        // Persist the stable tmux session name + any attach target, so a persistent
+        // remote shell tab REATTACHES to the same host session after a relaunch.
+        tmuxSession: t.tmuxSession,
+        tmuxAttach: t.tmuxAttach,
+        // Persist the no-tmux marker. Without it a restored SLURM log tab is an
+        // ordinary shell tab again, gets a freshly minted session name, and leaves
+        // the `tail -F` daemon on the login node the flag exists to prevent — and
+        // a relaunch after a crash is exactly when that would happen.
+        ephemeral: t.ephemeral,
       }));
       // #42: re-dock detached groups into the persisted tree so disk reflects a
       // restart-as-docked layout (their tabs are already in the flat list above
@@ -1833,19 +3617,34 @@ export const useTabsStore = create<TabsStore>((set, get) => ({
         tabs: tabLayout,
         groups,
         sessions,
+        allowClear,
       });
     } catch {
       // tab layout is non-critical
     }
   },
 
+  /**
+   * Persist the CURRENT scope into `localFile`.
+   *
+   * Prefer `persistScope(scope, localFile)`. This overload pairs the store's live
+   * `scope` with a `localFile` the caller supplies, and those are two independently
+   * tracked values: whenever they drift, this writes one project's tabs into another
+   * project's file — or, once the per-scope filter has dropped every foreign tab, an
+   * empty layout, which used to erase the target's tabs outright. That is exactly how
+   * a live project lost four of them on detach (which swaps `local_file` under the store).
+   * The backend now refuses an unvouched empty save, so this can no longer destroy
+   * anything, but the mismatch is still wrong at the source. No production caller
+   * remains — CenterPanel passes its scope explicitly, and `detached.ts` derives
+   * `localFile` FROM the scope. Kept for the tests that drive it directly.
+   */
   saveLayout: async (localFile) => {
     await get().persistScope(get().scope, localFile);
   },
 }));
 
 /** Replace the group `groupId` via `fn`, returning a new tree (structural). */
-function mapGroup(
+export function mapGroup(
   node: LayoutNode,
   groupId: string,
   fn: (g: GroupNode) => GroupNode,
@@ -1859,17 +3658,38 @@ function mapGroup(
   };
 }
 
+// Commands that launch an AI coding agent (mirrors TabBar's AGENT_ITEMS and the
+// backend agent registry in commands::agents). Used to classify a tab by its cmd.
+const AGENT_CMDS = new Set([
+  "claude",
+  "codex",
+  "gemini",
+  "vibe",
+  "aider",
+  "opencode",
+  "cursor-agent",
+  "copilot",
+  "grok",
+  "qwen",
+  "openclaw",
+]);
+
 export function cmdToKind(cmd: string): TabKind {
   if (cmd === FILES_TAB_CMD) return "files";
-  if (cmd === "claude" || cmd === "codex" || cmd === "gemini" || cmd === "vibe")
-    return "agent";
+  if (cmd === PROJECT_FILES_TAB_CMD) return "projectfiles";
+  if (cmd === BLOB_TAB_CMD) return "projects3d";
+  if (cmd === NETWORK_TAB_CMD) return "network";
+  if (cmd === MONITOR_TAB_CMD) return "monitor";
+  if (cmd === DISKUSAGE_TAB_CMD) return "diskusage";
+  if (cmd === CALENDAR_TAB_CMD) return "calendar";
+  if (AGENT_CMDS.has(cmd)) return "agent";
   return "shell";
 }
 
 /**
- * Whether a tab KIND alone survives a restart. Shell/files tabs are restorable
- * by kind; agent / local-agent and embed tabs are not, because the kind alone
- * carries no session to resume. Prefer the tab-level `isRestorableTab` at call
+ * Whether a tab KIND alone survives a restart. Shell/files/network tabs are
+ * restorable by kind; agent / local-agent and embed tabs are not, because the
+ * kind alone carries no session to resume. Prefer the tab-level `isRestorableTab` at call
  * sites that have the full tab — a resumable agent tab (Claude with a sessionId)
  * IS restorable even though its kind is not. This kind-only check stays for the
  * places that only have a `TabKind`.
@@ -1880,14 +3700,40 @@ export function cmdToKind(cmd: string): TabKind {
  * not here.
  */
 export function isRestorableKind(kind: TabKind): boolean {
-  return kind === "shell" || kind === "files";
+  return (
+    kind === "shell" ||
+    kind === "files" ||
+    kind === "projectfiles" ||
+    kind === "network" ||
+    kind === "monitor" ||
+    // The tab comes back, but on its home screen — a scan is far too expensive to
+    // replay on every launch, so the pane never auto-rescans.
+    kind === "diskusage" ||
+    kind === "calendar"
+  );
+}
+
+/** Whether a tab owns a backend PTY. Pure frontend panes must never be sent
+ * through terminal spawn/kill/activity paths merely because they are not files. */
+export function isPtyTabKind(kind: TabKind): boolean {
+  return kind === "agent" || kind === "local_agent" || kind === "shell";
 }
 
 /**
  * Agents whose prior session can be resumed, mapping `cmd` → the launch args to
- * relaunch with that session. Claude (`--resume <id>`) and Codex (`codex resume`,
- * args injected by the backend) are wired; Gemini/Vibe stay excluded until their
- * resume path is confirmed (39d).
+ * relaunch with that session. Two resume styles are wired:
+ *
+ *  - id-based: Claude (`--resume <id>`) and Codex (`codex resume`, args injected
+ *    by the backend) resume a *specific* captured session.
+ *  - cwd "continue last": Qwen, OpenCode, Copilot, Cursor, Grok, Gemini and
+ *    Mistral/vibe have no caller-supplied launch id, so Eldrun re-launches with
+ *    their "continue the most recent session" flag. Because each agent tab
+ *    launches in the project directory, that most-recent session IS the tab's
+ *    prior conversation. These ignore the minted id (it only satisfies the
+ *    persistence gate below and is set as ELDRUN_TAB_UID). Caveat: two tabs of
+ *    the same agent in one project both resume that project's single latest
+ *    session, so they can't be told apart on restore. Aider stays excluded — it
+ *    has no per-session resume (only `--restore-chat-history`).
  */
 export const RESUMABLE_AGENTS: Record<string, (id: string) => string[]> = {
   // Claude: `--resume <launch-id>`; the backend upgrades the id to the live one
@@ -1898,6 +3744,20 @@ export const RESUMABLE_AGENTS: Record<string, (id: string) => string[]> = {
   // reads the hook-recorded live id and injects `codex resume <live-id>` at spawn
   // (terminal::resolve_codex_session).
   codex: () => [],
+  // cwd "continue last session" — no captured id needed (see note above).
+  qwen: () => ["--continue"],
+  opencode: () => ["--continue"],
+  copilot: () => ["--continue"],
+  "cursor-agent": () => ["--continue"],
+  grok: () => ["--session", "latest"],
+  // Gemini's `--resume` takes "latest" (or an index), not a uuid, so it can only
+  // continue the project's most-recent session — not the specific one its launch
+  // `--session-id <uuid>` minted. That makes it continue-last like the others.
+  gemini: () => ["--resume", "latest"],
+  // Mistral/vibe: `-c/--continue` resumes the most recent saved session. (Its
+  // `--resume [id]` with no id would open an interactive picker, which hangs a
+  // restore — so `--continue` is the non-interactive path.)
+  vibe: () => ["--continue"],
 };
 
 /**
@@ -1906,12 +3766,14 @@ export const RESUMABLE_AGENTS: Record<string, (id: string) => string[]> = {
  * restart (their conversation is resumed); other agent tabs are still dropped.
  */
 export function isResumableAgentTab(
-  tab: { kind: TabKind; cmd: string; sessionId?: string },
+  tab: { kind: TabKind; cmd: string; sessionId?: string; resumeArgs?: string[] },
 ): boolean {
   return (
     (tab.kind === "agent" || tab.kind === "local_agent") &&
     !!tab.sessionId &&
-    tab.cmd in RESUMABLE_AGENTS
+    // Built-in resumable (cmd in the static table) OR a custom agent whose spec
+    // supplied a "continue last session" flag (carried on the tab as resumeArgs).
+    (tab.cmd in RESUMABLE_AGENTS || !!tab.resumeArgs?.length)
   );
 }
 
@@ -1975,19 +3837,39 @@ export function pruneSavedTree(
       tabKeys,
       activeKey,
       ...(tree.detached ? { detached: true, bounds: tree.bounds } : {}),
+      // Carry the hidden tag through pruning so a hidden group stays parked on
+      // restore rather than docking live (mirrors the detached tag).
+      ...(tree.hidden ? { hidden: true } : {}),
+      // Carry the per-subwindow file viewer through pruning (same rationale).
+      ...(tree.filesOpen ? { filesOpen: true } : {}),
+      ...(tree.filesWidth != null ? { filesWidth: tree.filesWidth } : {}),
+      ...(tree.filesFolder ? { filesFolder: tree.filesFolder } : {}),
     };
   }
   const kept = tree.children
     .map((c, i) => ({ child: pruneSavedTree(c, keep), size: tree.sizes[i] ?? 1 }))
     .filter((e): e is { child: SavedLayoutTree; size: number } => e.child != null);
   if (kept.length === 0) return null;
-  if (kept.length === 1) return kept[0].child;
+  // #42: carry a multi-pane popout's detached tag + bounds through pruning, just
+  // like the group branch — else the split would persist as a plain docked node
+  // and the popout would restore inside the main panel.
+  const tag = tree.detached
+    ? { detached: true as const, bounds: tree.bounds }
+    : tree.hidden
+      ? { hidden: true as const }
+      : {};
+  if (kept.length === 1) {
+    // Collapsed to a single surviving child: it inherits the popout's detached
+    // tag (so it respawns floating) or the hidden tag (so it stays parked).
+    return tree.detached || tree.hidden ? { ...kept[0].child, ...tag } : kept[0].child;
+  }
   const total = kept.reduce((a, e) => a + e.size, 0) || 1;
   return {
     type: "split",
     dir: tree.dir,
     children: kept.map((e) => e.child),
     sizes: kept.map((e) => e.size / total),
+    ...tag,
   };
 }
 
@@ -1995,6 +3877,67 @@ export function isLocalAgentKind(kind: TabKind): kind is "local_agent" {
   return kind === "local_agent";
 }
 
+/**
+ * SSH-sync Phase 0: whether a tab kind has a user-toggleable local/remote
+ * locality. Only `agent` and `shell` tabs run a PTY that can sit on either side;
+ * `local_agent` is fixed-local and the non-PTY kinds
+ * (files/embed/projects3d/network)
+ * have no locality.
+ */
+export function isLocatableKind(kind: TabKind): boolean {
+  return kind === "agent" || kind === "shell";
+}
+
+/**
+ * SSH-sync Phase 0: the default locality for a kind on a remote project (product
+ * decision 1): **agents default LOCAL** (cwd = the local mirror), **shells
+ * default REMOTE** (run remote scripts on the host). `local_agent` and the
+ * non-PTY kinds resolve local. See docs/ssh_sync_plan.md.
+ */
+export function defaultLocationForKind(kind: TabKind): TabLocation {
+  return kind === "shell" ? "remote" : "local";
+}
+
+/**
+ * SSH-sync Phase 0: a tab's effective locality — its explicit `location`, or the
+ * per-kind default when unset. `local_agent` is always local regardless of any
+ * stored value. Consumed by CenterPanel/DetachedCenterPanel to decide `localOnly`
+ * and resolve the local `cwd` (mirror root) for a local-on-remote tab.
+ */
+export function effectiveTabLocation(
+  tab: { kind: TabKind; location?: TabLocation },
+): TabLocation {
+  if (isLocalAgentKind(tab.kind)) return "local";
+  return tab.location ?? defaultLocationForKind(tab.kind);
+}
+
+/**
+ * SSH-sync Phase 1: the local working directory a PTY tab should run in when it
+ * runs LOCALLY on a REMOTE project. A local-on-remote tab can't cwd into the
+ * remote tree, so it runs in the project's local **mirror** — the synced twin.
+ * This is the value shown in the tab title (and the path the disconnected file
+ * browser lists); the backend resolves the same path authoritatively at spawn
+ * (and guarantees it exists).
+ *
+ * The mirror can be relocated to a custom folder ("Move project…"), so prefer the
+ * project's persisted override (`opts.mirror`, from resolveLocalMirror) when set;
+ * fall back to the default `<state dir>/mirror` for legacy projects with none.
+ * Returns `fallback` (the tab's own cwd) unchanged for a local project or a tab
+ * that runs on the host (remote locality).
+ */
+export function localTabCwd(
+  tab: { kind: TabKind; location?: TabLocation },
+  opts: { isRemoteProject: boolean; projectDirectory: string; fallback: string; mirror?: string | null },
+): string {
+  if (!opts.isRemoteProject || effectiveTabLocation(tab) !== "local") {
+    return opts.fallback;
+  }
+  const override = opts.mirror?.trim();
+  if (override) return override.replace(/[/\\]+$/, "");
+  if (!opts.projectDirectory) return opts.fallback;
+  return `${opts.projectDirectory.replace(/[/\\]+$/, "")}/mirror`;
+}
+
 /**
  * #42: build the saved layout tree that should be PERSISTED for a scope that has
  * detached groups. Each detached group's serialized subtree is appended to the
@@ -2016,9 +3959,11 @@ export function withDetachedDocked(
   for (const d of detached ?? []) {
     const t = serializeTree(d.subtree);
     if (!t) continue;
-    // v1 detaches a single GroupNode, so the serialized subtree is a group; tag
-    // it so restore knows to respawn the popout instead of docking it.
-    docked.push(t.type === "group" ? { ...t, detached: true, bounds: d.bounds } : t);
+    // Tag the popout's root (a single GroupNode, or a SplitNode for a multi-pane
+    // popout) so restore respawns the WHOLE subtree as one floating window rather
+    // than docking it into the main panel. `detachGroup` re-detaches either shape
+    // by the tagged node's id (see deserializeTree → pendingRespawn).
+    docked.push({ ...t, detached: true, bounds: d.bounds, zoom: d.zoom });
   }
   if (docked.length === 0) return inWindow;
   const all = inWindow ? [inWindow, ...docked] : docked;
@@ -2033,7 +3978,39 @@ export function withDetachedDocked(
 
 /** #42: the tab keys held by a scope's detached groups (for owned-keys unions). */
 export function detachedTabKeys(detached: DetachedGroup[] | undefined): string[] {
-  return (detached ?? []).flatMap((d) => d.subtree.tabKeys);
+  return (detached ?? []).flatMap((d) => orderedTabKeys(d.subtree));
+}
+
+/**
+ * Fold a scope's HIDDEN groups back into its serialized tree, each tagged
+ * `hidden: true`, so a restart persists them (their tabs survive) and restore
+ * re-parks them into `hiddenGroupsByScope` rather than docking them live. Mirrors
+ * `withDetachedDocked`, minus bounds (a hidden group has no OS window).
+ */
+export function withHiddenDocked(
+  inWindow: SavedLayoutTree | null,
+  hidden: HiddenGroup[] | undefined,
+): SavedLayoutTree | null {
+  const docked: SavedLayoutTree[] = [];
+  for (const h of hidden ?? []) {
+    const t = serializeTree(h.subtree);
+    if (!t) continue;
+    docked.push({ ...t, hidden: true });
+  }
+  if (docked.length === 0) return inWindow;
+  const all = inWindow ? [inWindow, ...docked] : docked;
+  if (all.length === 1) return all[0];
+  return {
+    type: "split",
+    dir: "row",
+    children: all,
+    sizes: all.map(() => 1 / all.length),
+  };
+}
+
+/** The tab keys held by a scope's hidden groups (for owned-keys unions). */
+export function hiddenTabKeys(hidden: HiddenGroup[] | undefined): string[] {
+  return (hidden ?? []).flatMap((h) => orderedTabKeys(h.subtree));
 }
 
 // Re-export the id regeneration helper so consumers / tests that build trees
@@ -2056,7 +4033,7 @@ export function isDetachedPtyId(id: string): boolean {
   const scope = id.slice(0, idx);
   const tabKey = id.slice(idx + 1);
   const groups = useTabsStore.getState().detachedGroupsByScope[scope] ?? [];
-  return groups.some((g) => g.subtree.tabKeys.includes(tabKey));
+  return groups.some((g) => orderedTabKeys(g.subtree).includes(tabKey));
 }
 
 // ── Fine-grained per-group selectors (Eff #3/#4/#7 + Struct #3) ───────────────
diff --git a/src/stores/tour.ts b/src/stores/tour.ts
new file mode 100644
index 0000000..03c28c5
--- /dev/null
+++ b/src/stores/tour.ts
@@ -0,0 +1,111 @@
+import { create } from "zustand";
+import { useSettingsStore } from "./settings";
+import { useProjectsStore } from "./projects";
+import { useHintsStore } from "./hints";
+import type { HintId } from "../lib/hints";
+import {
+  TOUR_STEPS,
+  COVERED_HINTS,
+  nextEligibleIndex,
+  prevEligibleIndex,
+  type TourStep,
+  type TourCtx,
+} from "../lib/tour";
+
+/**
+ * Live state for the guided overlay — both the high-level "Take a tour"
+ * walkthrough (`TOUR_STEPS`) and the task "lessons" (each a step list from
+ * `lib/lessons.ts`). The step catalogs and selection logic are pure
+ * (`lib/tour.ts` / `lib/lessons.ts`); this store only holds which sequence is
+ * running and where, plus the thin action that persists the terminal
+ * `tour_completed` flag through `useSettingsStore` (the single writer of
+ * `settings.json`). Session-only otherwise — the active step is never persisted.
+ *
+ * Mounted only by `AppShell` (not the detached-window `DetachedApp` branch), so
+ * the overlay never appears in popped-out subwindows. Mirrors `stores/hints.ts`.
+ */
+interface TourStore {
+  /** True while the overlay is on screen. */
+  active: boolean;
+  /** Index into `steps` of the step currently shown (valid while active). */
+  index: number;
+  /** The sequence currently running (the main tour or a lesson). */
+  steps: TourStep[];
+  /** Settings flag to set true on finish, or null for replayable lessons. */
+  persistKey: "tour_completed" | null;
+  /** Begin the high-level "Take a tour" walkthrough. */
+  start: () => void;
+  /** Begin a task lesson (replayable; nothing persisted). */
+  startLesson: (steps: TourStep[]) => void;
+  /** Advance to the next eligible step, or finish past the end. */
+  next: () => void;
+  /** Step back to the previous eligible step (no-op at the first). */
+  prev: () => void;
+  /** Leave early (Skip / Esc): same persistence as finishing. */
+  skip: () => void;
+  /** Complete: record it (main tour only) and stop the hints it taught. */
+  finish: () => void;
+}
+
+/** Snapshot the bits of app state the per-step `when` predicates read. */
+function ctx(): TourCtx {
+  const s = useProjectsStore.getState();
+  return { projectCount: s.projects.length, activeId: s.activeId };
+}
+
+/** Mark `tour_completed` and stop the hints the main tour covered from
+ *  re-firing the moment it closes. Lessons don't persist. */
+function persistDone() {
+  void useSettingsStore.getState().updateSettings({ tour_completed: true });
+  const hints = useHintsStore.getState();
+  for (const id of COVERED_HINTS) hints.markSeen(id as HintId);
+}
+
+export const useTourStore = create<TourStore>((set, get) => {
+  // Clear any on-screen contextual hint (without marking it seen) so the two
+  // overlays never paint at once, then open at the first eligible step.
+  const begin = (steps: TourStep[], persistKey: "tour_completed" | null) => {
+    useHintsStore.setState({ active: null });
+    const first = nextEligibleIndex(steps, ctx(), 0);
+    if (first >= steps.length) return; // nothing eligible — don't open empty
+    set({ active: true, index: first, steps, persistKey });
+  };
+
+  return {
+    active: false,
+    index: 0,
+    steps: TOUR_STEPS,
+    persistKey: null,
+
+    start: () => begin(TOUR_STEPS, "tour_completed"),
+
+    startLesson: (steps) => begin(steps, null),
+
+    next: () => {
+      const { steps, index } = get();
+      const nextIdx = nextEligibleIndex(steps, ctx(), index + 1);
+      if (nextIdx >= steps.length) {
+        get().finish();
+        return;
+      }
+      set({ index: nextIdx });
+    },
+
+    prev: () => {
+      const { steps, index } = get();
+      const prevIdx = prevEligibleIndex(steps, ctx(), index - 1);
+      if (prevIdx < 0) return;
+      set({ index: prevIdx });
+    },
+
+    skip: () => {
+      if (get().persistKey === "tour_completed") persistDone();
+      set({ active: false });
+    },
+
+    finish: () => {
+      if (get().persistKey === "tour_completed") persistDone();
+      set({ active: false });
+    },
+  };
+});
diff --git a/src/stores/usage.ts b/src/stores/usage.ts
new file mode 100644
index 0000000..b1b1aca
--- /dev/null
+++ b/src/stores/usage.ts
@@ -0,0 +1,144 @@
+import { invoke } from "@tauri-apps/api/core";
+import { create } from "zustand";
+
+import type { BucketReport, Counters, Period } from "../lib/usageRollup";
+import { countersForPeriod, dayKey } from "../lib/usageRollup";
+
+/**
+ * The usage counters behind the daily recap.
+ *
+ * Two halves:
+ *
+ * - **Recording** — a plain module-level accumulator (not store state: it churns
+ *   on every keystroke and nothing renders off it, the same reason `activity.ts`
+ *   keeps its per-PTY maps outside React). Counters are flushed to the backend on
+ *   an interval and on window close, so a burst of typing costs one whole-file
+ *   rewrite per flush rather than one per key.
+ * - **Reading** — the zustand store proper, holding the report the recap renders.
+ *
+ * Scopes are the same ids tabs use: a project id, or `"root"` for the root
+ * terminal.
+ */
+
+/** The scope the root terminal's counters are filed under. */
+export const ROOT_SCOPE = "root";
+
+/** scope → metric → count, pending flush. */
+let pending: Record<string, Counters> = {};
+
+/**
+ * Tabs already counted as "active" (given ≥1 prompt) today, keyed `date|ptyId`.
+ * `agent.active.*` answers "how many agent tabs did you actually use", so a tab
+ * must contribute exactly once per day no matter how many prompts it gets — and
+ * keying by date means a long-running tab counts again tomorrow.
+ */
+const activeSeen = new Set<string>();
+
+/**
+ * Accumulate `n` against a metric. The unit of every write path.
+ *
+ * `n` may be fractional — agent working time arrives as a sub-second slice per
+ * activity tick. It is summed as a float here and only rounded at flush (see
+ * {@link flushUsage}), so those slices add up to whole seconds instead of each
+ * being floored to zero.
+ */
+export function bumpUsage(scope: string, key: string, n = 1): void {
+  if (!scope || !key || !Number.isFinite(n) || n <= 0) return;
+  const counters = (pending[scope] ??= {});
+  counters[key] = (counters[key] ?? 0) + n;
+}
+
+/**
+ * Count a tab as "used today" the first time it is asked something. Returns true
+ * if this was its first prompt today (so the caller knows a counter moved).
+ */
+export function markAgentActive(scope: string, ptyId: string, activeKey: string): boolean {
+  const seen = `${dayKey(Date.now())}|${ptyId}`;
+  if (activeSeen.has(seen)) return false;
+  activeSeen.add(seen);
+  bumpUsage(scope, activeKey);
+  return true;
+}
+
+/**
+ * Push everything accumulated so far to the backend and clear it.
+ *
+ * Drains *before* awaiting, so counters recorded while the flush is in flight
+ * land in the next batch rather than being dropped by the clear. A failed invoke
+ * loses that batch — acceptable for a statistic, and far better than retrying
+ * into an unbounded buffer.
+ *
+ * Counts are rounded to integers on the way out: the store is `u64`-typed, so a
+ * fractional value would fail to deserialize and lose the whole batch. Anything
+ * that rounds to zero is dropped rather than sent as a no-op.
+ */
+export async function flushUsage(): Promise<void> {
+  const batch = pending;
+  pending = {};
+  const payloads: [string, Counters][] = [];
+  for (const [scope, counters] of Object.entries(batch)) {
+    const metrics: Counters = {};
+    for (const [key, n] of Object.entries(counters)) {
+      const rounded = Math.round(n);
+      if (rounded > 0) metrics[key] = rounded;
+    }
+    if (Object.keys(metrics).length > 0) payloads.push([scope, metrics]);
+  }
+  if (payloads.length === 0) return;
+  await Promise.all(
+    payloads.map(([scope, metrics]) =>
+      invoke("usage_bump", { projectId: scope, metrics }).catch(() => {}),
+    ),
+  );
+}
+
+/** Test seam: drop all pending counters and dedup state. */
+export function _resetUsageForTest(): void {
+  pending = {};
+  activeSeen.clear();
+}
+
+/** Test seam: read the pending batch without flushing it. */
+export function _pendingUsageForTest(): Record<string, Counters> {
+  return pending;
+}
+
+// ── Reading (the recap) ────────────────────────────────────────────────────
+
+/** Commits/lines for a project, as `usage_git_stats` returns them. */
+export interface GitStats {
+  commits: number;
+  filesChanged: number;
+  linesAdded: number;
+  linesRemoved: number;
+}
+
+interface UsageStore {
+  /** Every project's counters, summed — the recap is a global view. */
+  report: BucketReport<Counters> | null;
+  loading: boolean;
+  load: () => Promise<void>;
+  /** Counters for one period, anchored on a day. */
+  countersFor: (period: Period, anchorMs: number) => Counters;
+}
+
+export const useUsageStore = create<UsageStore>((set, get) => ({
+  report: null,
+  loading: false,
+
+  load: async () => {
+    set({ loading: true });
+    // Empty projectId = summed across every project, which is what the recap
+    // shows; the per-project split it needs comes from the time store.
+    const report = await invoke<BucketReport<Counters>>("usage_summary", {
+      projectId: "",
+    }).catch(() => ({ hours: {}, days: {} }));
+    set({ report, loading: false });
+  },
+
+  countersFor: (period, anchorMs) => {
+    const report = get().report;
+    if (!report) return {};
+    return countersForPeriod(report, period, anchorMs);
+  },
+}));
diff --git a/src/stores/vpnPrompt.ts b/src/stores/vpnPrompt.ts
index 3ec3477..37ed218 100644
--- a/src/stores/vpnPrompt.ts
+++ b/src/stores/vpnPrompt.ts
@@ -1,44 +1,278 @@
 import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+import { useProjectsStore } from "./projects";
+import { markVpnConnected, useVpnStatusStore } from "./vpnStatus";
+import { openVpnLoginInTerminal } from "../lib/vpnAutoConnect";
 
 /**
- * Mediates the activation-time OpenVPN password prompt. The VPN password is
- * never persisted (see services::openvpn), so each time a VPN-gated project is
- * activated we ask for it via a modal. `request()` returns a promise that
- * resolves with the entered password or rejects if the user cancels.
+ * Mediates the activation-time OpenVPN connection. By default the VPN password
+ * is not persisted, so each time a VPN-gated project is activated we ask for it
+ * via a modal — unless the user ticked "Save passphrase", in which case the
+ * backend reconnects silently from the OS keychain and this prompt is skipped
+ * (see `autoConnectPrimary`'s VPN escalation and services::remote_credentials).
+ *
+ * The store owns the whole connect lifecycle — not just collecting the password
+ * — so a failed tunnel surfaces *in the modal* (status + error, with a retry)
+ * instead of failing silently in the background. `request()` resolves once the
+ * tunnel is up and rejects if the user cancels.
  */
 interface PendingPrompt {
   config: string;
+  /** What the tunnel is being brought up *for* — a project name, or the config's
+   *  own name when the connect came from the header (no project behind it). */
   projectName: string;
-  resolve: (password: string) => void;
+  /**
+   * Project id, so a username typed here can be persisted to the spec — and so the
+   * project is recorded as a holder of the tunnel.
+   *
+   * `null` for a connect started from the header's VPN menu: the tunnel is a
+   * machine-level thing and can legitimately be brought up on its own, with no
+   * project asking for it (and therefore no spec to persist a username into).
+   */
+  projectId: string | null;
+  /** Auth username seed for `auth-user-pass` configs (from the stored spec). */
+  username?: string;
+  /**
+   * Why the modal is open at all, when it was *meant* to be a silent connect: the
+   * saved credentials were rejected, or unreadable, or there were none. Shown at the
+   * top of the prompt, because "it just asked me again" with no reason given is
+   * exactly the failure mode a saved credential is supposed to remove — and the
+   * backend already knows which of the three it was.
+   *
+   * Absent for a prompt that was never going to be silent (a first-ever connect).
+   */
+  reason?: string;
+  /**
+   * Seed for the "Save passphrase" toggle, overriding the "is one already saved?"
+   * default. Set to `true` when the prompt *is* the save action (the VPN menu's
+   * "Save login credentials"): there is nothing saved yet, so the default would
+   * come back unticked and the connect the user asked to remember would remember
+   * nothing.
+   */
+  remember?: boolean;
+  /** Resolved once the tunnel is up. */
+  resolve: () => void;
+  /** Rejected if the user cancels (or the prompt is superseded). */
   reject: (reason?: unknown) => void;
 }
 
+type ConnectStatus = "idle" | "connecting" | "connected" | "error";
+
+/**
+ * Why `request()` rejected when the user chose the terminal instead (`handoffToTerminal`).
+ *
+ * It is *not* a failure and must not be treated as one: the tunnel is coming up in a
+ * root-terminal tab, the lamp is already "connecting", and `pollVpnUp` owns the
+ * outcome from here. A caller that reads every rejection as "no tunnel" would flip
+ * that lamp red over a login the user is in the middle of typing — so every caller
+ * of `request` checks for this first (see `VpnIndicator.connect`).
+ */
+export const VPN_TERMINAL_HANDOFF = "vpn-terminal-handoff";
+
+/** Whether a `request()` rejection is the terminal handoff rather than a failure. */
+export function isVpnTerminalHandoff(e: unknown): boolean {
+  return e instanceof Error && e.message === VPN_TERMINAL_HANDOFF;
+}
+
 interface VpnPromptState {
   pending: PendingPrompt | null;
-  /** Open the prompt for a project; resolves with the password, rejects on cancel. */
-  request: (config: string, projectName: string) => Promise<string>;
-  submit: (password: string) => void;
+  status: ConnectStatus;
+  error: string;
+  /** Open the prompt for a project; resolves when connected, rejects on cancel.
+   *  `username` seeds the field for `auth-user-pass` configs; `opts` carries why a
+   *  connect that should have been silent is asking (`reason`) and an override for
+   *  the save toggle (`remember`). */
+  request: (
+    config: string,
+    projectName: string,
+    projectId: string | null,
+    username?: string,
+    opts?: { reason?: string; remember?: boolean },
+  ) => Promise<void>;
+  /** Attempt the tunnel with `username`/`password`, plus `keyPassphrase` for a
+   *  config that has an encrypted key *and* an `auth-user-pass` account (OpenVPN
+   *  prompts for those two separately; answering only one hangs the handshake on
+   *  the other). `remember` opts into saving the secrets in the OS keychain for
+   *  no-prompt reconnects (default off). On success closes + resolves (persisting
+   *  the username to the spec); on failure keeps the modal open with the error so
+   *  the user can retry. */
+  submit: (
+    password: string,
+    remember?: boolean,
+    username?: string,
+    keyPassphrase?: string,
+  ) => Promise<void>;
   cancel: () => void;
+  /**
+   * Give up on the headless login for this config and hand it to a root terminal —
+   * the non-headless flow, switched on for **this connect only** (the global
+   * `connections_headless` setting is untouched).
+   *
+   * This is the escape hatch for a config Eldrun cannot log in to on its own: a
+   * server that answers with a challenge/OTP prompt, or any handshake whose real
+   * question never reaches these two password fields. The symptom is the sequence
+   * this modal was showing — the saved-credential connect errors, the prompt opens,
+   * and the password typed into it is rejected too, forever. In the terminal OpenVPN
+   * asks its own questions and the user answers them directly.
+   *
+   * Closes the modal and rejects the caller with [`VPN_TERMINAL_HANDOFF`]: the tunnel
+   * is not up yet, so resolving would be a lie, but the attempt is very much alive
+   * (`openVpnLoginInTerminal` leaves the lamp connecting and polls) so it is not a
+   * failure either. Rejects with the underlying error instead if the handoff itself
+   * failed, leaving the modal open so the user still has somewhere to be.
+   */
+  handoffToTerminal: () => Promise<void>;
+  /** Dismiss the modal once the tunnel is up. Unlike `cancel`, it tears **nothing**
+   *  down — the connect already succeeded and resolved — it just closes the panel. */
+  close: () => void;
+  /** Adopt a tunnel that came up out-of-band: our own `openvpn_connect` can hang
+   *  without ever resolving (the "Initialization Sequence Completed" marker was
+   *  muted/slow), yet the header's periodic `openvpn_status` reconcile flips the
+   *  machine-level lamp green. When that happens under a still-"connecting" modal,
+   *  reflect it — flip to connected and resolve the caller — so the modal never
+   *  strands on "Connecting…" over a tunnel that is actually up. Idempotent. */
+  markConnected: () => void;
+}
+
+/**
+ * The tunnel is up: light the machine-level lamp (so no caller of `request` resolves
+ * without the header indicator showing it), take the project's hold on it, persist the
+ * non-secret username, resolve the caller — and then **leave the modal open** on a
+ * `connected` status. Success used to slam the panel shut, which read as "did it work?";
+ * now it says so, with a Close button, and the user dismisses it when they're ready.
+ */
+function finishConnected(p: PendingPrompt, username?: string): void {
+  if (p.projectId) markVpnConnected(p.projectId, p.config);
+  else useVpnStatusStore.getState().setState(p.config, "connected");
+  if (username?.trim() && p.projectId) {
+    void useProjectsStore
+      .getState()
+      .setProjectOpenvpn(p.projectId, p.config, username.trim())
+      .catch(() => {});
+  }
+  useVpnPromptStore.setState({ status: "connected", error: "" });
+  p.resolve();
 }
 
 export const useVpnPromptStore = create<VpnPromptState>((set, get) => ({
   pending: null,
-  request: (config, projectName) =>
-    new Promise<string>((resolve, reject) => {
+  status: "idle",
+  error: "",
+  request: (config, projectName, projectId, username, opts) =>
+    new Promise<void>((resolve, reject) => {
       // If a prompt is already open, cancel it before replacing.
       get().pending?.reject(new Error("superseded"));
-      set({ pending: { config, projectName, resolve, reject } });
+      set({
+        pending: {
+          config,
+          projectName,
+          projectId,
+          username,
+          reason: opts?.reason,
+          remember: opts?.remember,
+          resolve,
+          reject,
+        },
+        status: "idle",
+        error: "",
+      });
     }),
-  submit: (password) => {
+  submit: async (password, remember = false, username, keyPassphrase) => {
     const p = get().pending;
-    if (!p) return;
-    set({ pending: null });
-    p.resolve(password);
+    if (!p || get().status === "connecting") return;
+    set({ status: "connecting", error: "" });
+    try {
+      await invoke("openvpn_connect", {
+        config: p.config,
+        username: username?.trim() || null,
+        password,
+        keyPassphrase: keyPassphrase || null,
+        // `true` or `null`, NEVER the raw flag — the SSH rule
+        // (`components/projects/useSavedCredential`'s `rememberArg`) applies here
+        // for the same reason. `false` is `Remember::Clear`, and `openvpn_connect`
+        // applies it *after* authenticating with the passphrase/username it
+        // resolved from the keychain — so an unticked box deletes all three
+        // secrets it just used. And this box is seeded by an unbounded async read
+        // (`vpn_has_saved_password`), so submitting before that lands sends
+        // `false` for a config that does have saved credentials. Forgetting stays
+        // the explicit action's job.
+        remember: remember ? true : null,
+      });
+      // Aborted while this attempt was in flight (Stop/Escape during connect): the
+      // backend attempt runs to its own timeout regardless and may even have brought
+      // the tunnel up, so don't resurrect a cancelled UI — tear down whatever opened
+      // and leave. `cancel` already reset the lamp; a late green here would undo it.
+      if (get().pending !== p) {
+        void invoke("openvpn_disconnect", { config: p.config }).catch(() => {});
+        return;
+      }
+      finishConnected(p, username);
+    } catch (e) {
+      // Aborted mid-connect — the modal is already gone; don't reopen it with an error.
+      if (get().pending !== p) return;
+      // The connect *reported* a failure — but `connect_streaming` calls it a failure
+      // if it doesn't see "Initialization Sequence Completed" within its window, and a
+      // tunnel can be genuinely up while that marker was muted, reordered, or just slow.
+      // So before showing red, ask the backend directly whether the tunnel is up. This
+      // is the "it connected but the modal didn't notice" case, made to notice.
+      const up = await invoke<boolean>("openvpn_status", { config: p.config }).catch(() => false);
+      if (get().pending !== p) return;
+      if (up) {
+        finishConnected(p, username);
+        return;
+      }
+      // Keep the modal open so the user can fix the passphrase and retry.
+      set({ status: "error", error: String(e) });
+    }
   },
   cancel: () => {
     const p = get().pending;
     if (!p) return;
-    set({ pending: null });
+    // A cancel *during* an in-flight connect is an abort, not just a dismissal: the
+    // backend attempt keeps running to its own timeout and may bring the tunnel up,
+    // so tear down whatever half-opened and reset the machine-level lamp now. The
+    // pending-identity guard in `submit` then drops the late result instead of
+    // flipping the lamp green behind a UI the user already closed.
+    const wasConnecting = get().status === "connecting";
+    set({ pending: null, status: "idle", error: "" });
+    if (wasConnecting) {
+      void invoke("openvpn_disconnect", { config: p.config }).catch(() => {});
+      useVpnStatusStore.getState().setState(p.config, "off");
+    }
     p.reject(new Error("cancelled"));
   },
+  handoffToTerminal: async () => {
+    const p = get().pending;
+    // Never while a headless attempt is in flight: that attempt can still come up on
+    // its own, and `submit`'s superseded-guard tears down whatever it opened — by
+    // config, which is the *same* config the terminal tunnel would be registering
+    // under. So it would kill the login the user just switched to. The button is
+    // disabled while connecting for exactly this reason; this is the guard behind it.
+    if (!p || get().status === "connecting" || get().status === "connected") return;
+    try {
+      await openVpnLoginInTerminal(p.config, {
+        label: p.projectName,
+        projectId: p.projectId,
+      });
+    } catch (e) {
+      // The command couldn't even be built — nothing was opened and no lamp moved, so
+      // keep the modal (and its password fields) exactly where they were.
+      set({ status: "error", error: String(e) });
+      return;
+    }
+    if (get().pending !== p) return;
+    set({ pending: null, status: "idle", error: "" });
+    p.reject(new Error(VPN_TERMINAL_HANDOFF));
+  },
+  close: () => {
+    // Only meaningful once connected: the tunnel stays up, the caller already resolved
+    // (`finishConnected`), so this is a pure UI dismissal — no teardown, no reject.
+    if (!get().pending) return;
+    set({ pending: null, status: "idle", error: "" });
+  },
+  markConnected: () => {
+    const p = get().pending;
+    if (!p || get().status === "connected") return;
+    finishConnected(p);
+  },
 }));
diff --git a/src/stores/vpnStatus.ts b/src/stores/vpnStatus.ts
new file mode 100644
index 0000000..7fc96b3
--- /dev/null
+++ b/src/stores/vpnStatus.ts
@@ -0,0 +1,279 @@
+import { create } from "zustand";
+import { invoke } from "@tauri-apps/api/core";
+import { useRemoteStatusStore, type ConnState } from "./remoteStatus";
+
+/**
+ * Live state of the machine's OpenVPN tunnels, keyed by **config path**.
+ *
+ * A tunnel is not a property of a project, however much the Connect dialog makes
+ * it look like one. `openvpn` runs elevated (`pkexec openvpn --config …`) and
+ * Eldrun passes it no routing flags, so whatever the `.ovpn` pushes — typically
+ * `redirect-gateway def1` plus DNS — applies to the *whole computer*, for as long
+ * as the tunnel is up, no matter which project asked for it. Three facts follow,
+ * and this store exists for all of them:
+ *
+ *  1. **It outlives the project view.** `dropRemotePool` clears a project's lamps
+ *     on deactivation and the pill only renders the *active* project's — so
+ *     per-project state cannot answer "is a tunnel up right now?". This store can,
+ *     and the header's `VpnIndicator` reads it.
+ *  2. **It is shared.** The backend registry is keyed by config path, so two
+ *     projects on the same `.ovpn` ride one tunnel. `holders` is the refcount that
+ *     makes teardown safe: logging out of one project must not pull the tunnel out
+ *     from under the other (and out from under the rest of the OS).
+ *  3. **It can exist with no project at all.** A tunnel brought up from the header
+ *     has no holder — it is simply up. So can one that outlived a reload, or a
+ *     previous run of the app. `refresh` finds those; a holder count of zero is a
+ *     normal state, not an inconsistency.
+ *
+ * The refcount lives here rather than being scanned off the projects store on
+ * demand precisely because of (1): by the time a project is torn down its lamps are
+ * already gone, so it is not a record of who is holding what.
+ */
+interface VpnStatusStore {
+  /** Tunnel state per config path. A config absent from the map is `off`. */
+  byConfig: Record<string, ConnState>;
+  /** Project ids currently holding each config's tunnel — the refcount. */
+  holders: Record<string, string[]>;
+
+  /** Set a tunnel's state. `off` forgets it (and its holders) entirely. */
+  setState: (config: string, state: ConnState) => void;
+  /** Register `projectId` as a holder of `config`'s tunnel. Idempotent. */
+  acquire: (config: string, projectId: string) => void;
+  /**
+   * Drop `projectId`'s claim on `config`. Returns **true** when that was the last
+   * holder and the caller should therefore actually invoke `openvpn_disconnect`;
+   * false when another live project still needs the tunnel.
+   */
+  release: (config: string, projectId: string) => boolean;
+  /** Drop every claim on `config` (the header's explicit "disconnect tunnel"). */
+  releaseAll: (config: string) => void;
+  /**
+   * Reconcile against the backend's live tunnel set (`openvpn_active`), so a tunnel
+   * that outlived a reload, a renderer crash, or a previous run of the app still
+   * shows up. In-flight (`connecting`) tunnels survive the reconcile: they are not
+   * in the backend registry yet, and dropping them would blank the indicator
+   * mid-handshake.
+   */
+  refresh: () => Promise<void>;
+}
+
+/** Forget everything we know about `config`'s tunnel. */
+function forget(s: VpnStatusStore, config: string) {
+  const byConfig = { ...s.byConfig };
+  const holders = { ...s.holders };
+  delete byConfig[config];
+  delete holders[config];
+  return { byConfig, holders };
+}
+
+export const useVpnStatusStore = create<VpnStatusStore>((set) => ({
+  byConfig: {},
+  holders: {},
+
+  setState: (config, state) =>
+    set((s) => {
+      if (state === "off") {
+        if (!(config in s.byConfig) && !(config in s.holders)) return {};
+        return forget(s, config);
+      }
+      if (s.byConfig[config] === state) return {};
+      return { byConfig: { ...s.byConfig, [config]: state } };
+    }),
+
+  acquire: (config, projectId) =>
+    set((s) => {
+      const prev = s.holders[config] ?? [];
+      if (prev.includes(projectId)) return {};
+      return { holders: { ...s.holders, [config]: [...prev, projectId] } };
+    }),
+
+  release: (config, projectId) => {
+    let last = false;
+    set((s) => {
+      const next = (s.holders[config] ?? []).filter((id) => id !== projectId);
+      if (next.length > 0) {
+        return { holders: { ...s.holders, [config]: next } };
+      }
+      // Last holder out (or a tunnel nobody claimed — one brought up from the header,
+      // or seated by `refresh` from a previous run). The caller disconnects; forget
+      // it here.
+      last = true;
+      return forget(s, config);
+    });
+    return last;
+  },
+
+  releaseAll: (config) => set((s) => forget(s, config)),
+
+  refresh: async () => {
+    const active = await invoke<string[]>("openvpn_active").catch(() => null);
+    if (!active) return;
+    let dropped: string[] = [];
+    set((s) => {
+      const byConfig: Record<string, ConnState> = {};
+      // What the backend says is up...
+      for (const config of active) byConfig[config] = "connected";
+      // ...plus anything still mid-handshake: it isn't in the backend registry yet,
+      // so the reconcile would otherwise blank a tunnel that is actively coming up.
+      for (const [config, state] of Object.entries(s.byConfig)) {
+        if (state === "connecting" && !(config in byConfig)) byConfig[config] = state;
+      }
+      // A tunnel we believed was UP that the backend no longer reports has
+      // **died on its own** — it was not disconnected from the UI, because every
+      // deliberate teardown (`disconnectVpnTunnel`, `releaseAll`, `setState off`)
+      // forgets the config here first, so it is already absent by the time the
+      // next reconcile runs. Only an unplanned death reaches this branch.
+      dropped = Object.keys(s.byConfig).filter(
+        (config) => s.byConfig[config] === "connected" && !(config in byConfig),
+      );
+      return { byConfig };
+    });
+    for (const config of dropped) {
+      onTunnelDropped(config);
+      // Drop the claims too: the tunnel they were holding no longer exists, so
+      // leaving them behind would make a later reconnect look already-held.
+      useVpnStatusStore.getState().releaseAll(config);
+    }
+  },
+}));
+
+/**
+ * React to a tunnel that died without being asked to (see `refresh`).
+ *
+ * The point is not the lamp — it is that **every SSH/SFTP call belonging to a
+ * project that was riding this tunnel is now aimed at a peer that will never
+ * answer**. Those calls are synchronous Tauri commands over a pooled
+ * ControlMaster: nothing about a black-holed socket produces an error, so each
+ * one blocks until ssh's own keepalive gives up (~45 s), and the file tree
+ * issues one per visible folder. That is the freeze this exists to prevent —
+ * clearing the project's status flips `useRemoteBlocked`, so the probes are
+ * never dispatched in the first place rather than each paying the timeout.
+ *
+ * Scoped to the tunnel's **holders**: a project that never claimed this config
+ * reaches its host by some other route and is none of this tunnel's business.
+ *
+ * The backend's pooled session is deliberately NOT torn down here. Reaping it is
+ * already the pooled reader's job (`services::remote::pooled_sftp_host` evicts a
+ * child whose ssh keepalive killed it), and a teardown issued from this path
+ * would itself be a call over the dead connection — the exact thing being
+ * avoided.
+ */
+function onTunnelDropped(config: string): void {
+  const holders = useVpnStatusStore.getState().holders[config] ?? [];
+  const remote = useRemoteStatusStore.getState();
+  for (const projectId of holders) remote.clear(projectId);
+}
+
+/** True when at least one tunnel is up or coming up — i.e. the machine's routing
+ *  is (or is about to be) Eldrun's doing. */
+export function anyVpnLive(byConfig: Record<string, ConnState>): boolean {
+  return Object.values(byConfig).some((s) => s === "connected" || s === "connecting");
+}
+
+/**
+ * Whether a dialog's own "Connect via OpenVPN" section still has anything to offer.
+ * Every remote menu that can start a tunnel asks this, so they all answer it alike:
+ * the Connect modal, and the SSH section the new-project and extend-to-remote
+ * dialogs share.
+ *
+ * A tunnel is machine-wide, so once *any* config is live the routing is already
+ * there and a project-scoped second connect path is noise — the section collapses
+ * to `VpnTunnelUpNotice` and the dialog goes straight to SSH. The exception is a
+ * tunnel **this** dialog brought up (`ownTunnelBusy`): its controls (handshake log,
+ * Stop/Disconnect) must stay reachable where the user started it.
+ */
+export function useVpnSectionVisible(ownTunnelBusy: boolean): boolean {
+  const globallyLive = useVpnStatusStore((s) => anyVpnLive(s.byConfig));
+  return !globallyLive || ownTunnelBusy;
+}
+
+// ── Lamp helpers ────────────────────────────────────────────────────────────────
+// A tunnel has two audiences and every connect path has to serve both: the project
+// that asked for it (its pill lamp) and the machine it reroutes (the header
+// indicator + the refcount). These keep the two in step so a call site can't
+// remember one and forget the other. They live here, next to the store, rather
+// than in `projects.ts`: `vpnPrompt` and `useRemoteReconnect` need them too, and
+// routing them through `projects.ts` would close an import cycle.
+
+/** A tunnel is being brought up for `projectId`. */
+export function markVpnConnecting(projectId: string, config: string): void {
+  useRemoteStatusStore.getState().setVpn(projectId, "connecting");
+  useVpnStatusStore.getState().setState(config, "connecting");
+}
+
+/** A tunnel is up, at `projectId`'s request — which makes that project a holder. */
+export function markVpnConnected(projectId: string, config: string): void {
+  useRemoteStatusStore.getState().setVpn(projectId, "connected");
+  useVpnStatusStore.getState().setState(config, "connected");
+  useVpnStatusStore.getState().acquire(config, projectId);
+}
+
+/**
+ * A tunnel failed to come up for `projectId`. The project's lamp goes red — that
+ * failure is its business — but the machine-level entry is *forgotten*: a tunnel
+ * that never came up is rerouting nothing, and a red badge parked in the header
+ * would claim otherwise. No holder is recorded; there is nothing held.
+ */
+export function markVpnError(projectId: string, config: string): void {
+  useRemoteStatusStore.getState().setVpn(projectId, "error");
+  useVpnStatusStore.getState().setState(config, "off");
+}
+
+/**
+ * Drop `projectId`'s claim on `config`'s tunnel, and tear the tunnel down **only if
+ * nobody else is still holding it**.
+ *
+ * This is the one place a project-scoped action is allowed to touch a machine-scoped
+ * resource. Every project-side teardown routes through it — the pill's logout, the
+ * Connect modal's Disconnect, archiving a project — because an unconditional
+ * `openvpn_disconnect` here yanks the routing out from under any *other* project on
+ * the same config, and out from under the rest of the OS with it.
+ *
+ * Safe to call in any order relative to `dropRemotePool`: the holder list is kept
+ * here, deliberately independent of the per-project lamps that `dropRemotePool`
+ * clears.
+ */
+export function releaseVpn(projectId: string, config: string | undefined): void {
+  if (!config) return;
+  if (useVpnStatusStore.getState().release(config, projectId)) {
+    void invoke("openvpn_disconnect", { config }).catch(() => {});
+  }
+}
+
+/**
+ * Tear a tunnel down outright, dropping every holder — the header indicator's
+ * "Disconnect", where the user is acting on the *tunnel*, not on a project. The
+ * holders' SSH sessions are left alone: they may well survive (the host can be
+ * reachable without the tunnel), and if they don't, their own lamps will say so.
+ *
+ * Reaches interactive (terminal-started) tunnels too: the backend arms every
+ * interactive connect with a `--writepid` it owns, so it has a pid to signal.
+ */
+export function disconnectVpnTunnel(config: string): void {
+  useVpnStatusStore.getState().releaseAll(config);
+  void invoke("openvpn_disconnect", { config }).catch(() => {});
+}
+
+/**
+ * Tear down every live tunnel on the **app-close path, before the window (and the
+ * popouts) go away** — awaited, so the UI stays on screen until it is done. Returns
+ * `true` when every tunnel is down, `false` when the user dismissed the teardown
+ * prompt: the tunnel (and the machine-wide routing it installed) is still up, so
+ * the caller should warn the user — but the quit is **not** aborted. This is a
+ * one-shot ask: a decline here is recorded on the backend so `RunEvent::Exit`'s own
+ * teardown pass never re-prompts for the same tunnel with the window already gone.
+ *
+ * The backend also disconnects all tunnels in its `RunEvent::Exit` handler, but that
+ * fires only *after* the webview window has been destroyed, so the elevated
+ * `pkexec kill` raised its polkit password prompt against a screen where Eldrun had
+ * already vanished — password *after* close, the wrong order. `openvpn_disconnect_all_on_quit`
+ * tears down the **same registered set** that exit-time handler would (not the liveness-
+ * filtered `openvpn_active` subset, which could skip a tunnel that then prompts at exit),
+ * surfaces a refused prompt as an error, and keeps the tunnel registered — so this runs
+ * to completion, prompt and all, while Eldrun is still visible.
+ */
+export async function disconnectAllTunnelsOnQuit(): Promise<boolean> {
+  return invoke("openvpn_disconnect_all_on_quit")
+    .then(() => true)
+    .catch(() => false);
+}
diff --git a/src/stores/windowMove.ts b/src/stores/windowMove.ts
new file mode 100644
index 0000000..c44c5a7
--- /dev/null
+++ b/src/stores/windowMove.ts
@@ -0,0 +1,72 @@
+import { create } from "zustand";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+/**
+ * Whether the MAIN window is currently being moved by a native OS title-bar drag
+ * (`startDragging`). On Windows/WebView2, WebView2 cannot repaint the heavy
+ * terminal canvases fast enough during the OS modal move loop, so the content
+ * lags/swims behind the frame. While this flag is set, `CenterPanel` hides the
+ * pane layer (`.center-panel.moving`), leaving only the cheap subwindow frame for
+ * WebView2 to composite — so the window keeps up with the cursor.
+ *
+ * Lives in its own tiny store (mirroring `drag.ts` / `detachAnim.ts`) because the
+ * drag is started in `HeaderBar` but the heavy panes it must hide live in
+ * `CenterPanel`; a store bridges the two without prop threading. The detached
+ * popout solves the identical problem with local state in `DetachedCenterPanel`.
+ */
+interface WindowMoveState {
+  moving: boolean;
+  setMoving: (v: boolean) => void;
+}
+
+export const useWindowMoveStore = create<WindowMoveState>((set) => ({
+  moving: false,
+  setMoving: (moving) => set({ moving }),
+}));
+
+/**
+ * Track the lifetime of a native window move started via `startDragging`, toggling
+ * `useWindowMoveStore.moving` so the pane layer is hidden only for the duration of
+ * the OS move loop. Call this immediately BEFORE `startDragging()`.
+ *
+ * End detection is deliberately belt-and-suspenders because the native move loop
+ * can swallow the DOM `pointerup` (mirrors `DetachedCenterPanel.beginWindowMove`):
+ *   • show on the FIRST `onMoved` (so a non-drag click never flashes the hide),
+ *   • hide on `pointerup`/`pointercancel` (the normal release, cursor over us),
+ *   • hide once the window has stopped moving for a beat (release while the
+ *     cursor is over a snap target / another monitor, where we never see the up),
+ *   • a hard timeout so the hide can never get stuck on.
+ */
+export function trackWindowMove(): void {
+  const win = getCurrentWindow();
+  const { setMoving } = useWindowMoveStore.getState();
+  let idle: ReturnType<typeof setTimeout> | undefined;
+  let unMoved: (() => void) | undefined;
+  let shown = false;
+  let done = false;
+  const finish = () => {
+    if (done) return;
+    done = true;
+    if (idle) clearTimeout(idle);
+    clearTimeout(hardStop);
+    unMoved?.();
+    window.removeEventListener("pointerup", finish);
+    window.removeEventListener("pointercancel", finish);
+    if (shown) setMoving(false);
+  };
+  const onMoved = () => {
+    if (!shown) {
+      shown = true;
+      setMoving(true);
+    }
+    if (idle) clearTimeout(idle);
+    idle = setTimeout(finish, 250);
+  };
+  const hardStop = setTimeout(finish, 10000);
+  window.addEventListener("pointerup", finish);
+  window.addEventListener("pointercancel", finish);
+  win
+    .onMoved(onMoved)
+    .then((fn) => (done ? fn() : (unMoved = fn)))
+    .catch(() => {});
+}
diff --git a/src/stores/windows.ts b/src/stores/windows.ts
index e977659..75c2735 100644
--- a/src/stores/windows.ts
+++ b/src/stores/windows.ts
@@ -23,6 +23,10 @@ interface WindowsStore {
     handler?: string,
     projectId?: string | null,
     origin?: string,
+    // Physical desktop coordinates to place the launched window at (X11 only,
+    // best-effort). Used to open an external app on the screen a file was
+    // dropped onto. Omitted → the WM places the window.
+    position?: { x: number; y: number },
   ) => Promise<TrackedWindow>;
 }
 
@@ -52,12 +56,14 @@ export const useWindowsStore = create<WindowsStore>((set) => ({
     set((s) => ({ windows: s.windows.filter((w) => w.id !== id) }));
   },
 
-  openFile: async (path, handler, projectId, origin) => {
+  openFile: async (path, handler, projectId, origin, position) => {
     const win = await invoke<TrackedWindow>("open_file", {
       path,
       handler: handler ?? null,
       projectId: projectId ?? null,
       origin: origin ?? null,
+      x: position?.x ?? null,
+      y: position?.y ?? null,
     });
     set((s) => ({ windows: [...s.windows, win] }));
     return win;
diff --git a/src/styles/themes.css b/src/styles/themes.css
index 26c5a84..1948abe 100644
--- a/src/styles/themes.css
+++ b/src/styles/themes.css
@@ -41,6 +41,66 @@ html, body, #root {
   height: 100%;
 }
 
+/* #42 (Windows): while the popout is moved by a native title-bar drag, take the
+   heavy pane content OUT of compositing so WebView2 only paints the cheap
+   placeholder and can keep up with the OS-moved frame (otherwise the terminal
+   canvases lag/swim behind the frame). `visibility: hidden` (not display:none)
+   keeps the layout intact, so no xterm reflow/refit churn on release — the
+   content reappears at the same size the instant the move ends. */
+.detached-center.moving .pane-layer {
+  visibility: hidden;
+}
+/* The placeholder shown in place of the hidden content during the move. Solid,
+   opaque, trivially cheap to composite. Fills the body (its positioning context,
+   `.detached-body { position: relative }`); sits above the panes but below nothing
+   that matters during a move. Click-through so it never swallows the gesture. */
+.detached-move-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 6;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--bg-panel);
+  color: var(--text-muted, #9fb0d0);
+  font-size: 13px;
+  letter-spacing: 0.02em;
+  pointer-events: none;
+}
+
+/* #42: the popout's own title bar — a full-width strip above the tab layout that
+   always hosts the min/max/close controls in the top-right corner. Before, the
+   controls lived in the root group's tab bar; once the popout was split the root
+   group became a narrow split child and the controls slid left with it. A
+   dedicated outer frame keeps them pinned regardless of splits. */
+.detached-titlebar {
+  flex: 0 0 auto;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  min-height: 30px;
+  padding: 0 4px;
+  background: var(--bg-panel);
+  border-bottom: 1px solid var(--border-color);
+}
+
+/* The layout tree lives below the title bar and is the positioning context for
+   the absolutely-inset split/subwindow nodes + the split-preview overlay. (In the
+   main window the panel itself plays this role; here the title bar sits above, so
+   the tree is wrapped one level deeper — these rules mirror the `.center-panel >`
+   ones for that wrapper.) */
+.detached-body {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+}
+.detached-body > .split,
+.detached-body > .subwindow {
+  position: absolute;
+  inset: 0;
+}
+
 /* #42: the detached window's tab bar doubles as a drag handle — its empty area
    drags the whole popout back onto the main window (or repositions it). */
 .detached-drag-handle {
@@ -50,49 +110,120 @@ html, body, #root {
   cursor: grabbing;
 }
 
+/* #42: drop-target frame painted while a tab/file dragged out of the main window
+   hovers over this popout. Just a thin accent OUTLINE around the whole window so
+   it's clear which popout will receive the drop when several are open — the
+   per-pane split/merge preview (`.split-preview`, driven by the popout's own
+   resolveLocalTarget) shows WHERE inside it the drop lands, so no full-window dark
+   fill (which would muddy that preview and read as "drops anywhere"). z-index sits
+   below the preview (5) so the preview paints on top; pointer-events:none. */
+.detached-drop-target {
+  position: fixed;
+  inset: 0;
+  z-index: 4;
+  pointer-events: none;
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+
 /* ── Global scrollbar baseline ───────────────────────────────────────────
-   Theme every scrollable surface so none fall back to the native (white)
-   WebKitGTK scrollbar in dark themes. More specific rules below (e.g.
-   .file-browser-main) still win on the surfaces they target. */
+   ONE consistent thin, themed (bluish) scrollbar on every surface, across
+   WebKitGTK versions. The standard `scrollbar-color`/`scrollbar-width` is the
+   source of truth — it is the one mechanism every WebKitGTK build honors — and
+   the ::-webkit-scrollbar pseudo-elements below only mirror it as a fallback for
+   engines that implement them (inert in most WebKitGTK builds). Both use SOLID
+   themed colors so the bar never falls back to the native light GTK scrollbar
+   (white trough + grey slider), which happens when the track is `transparent`.
+   More specific rules below still win on the surfaces they target. */
 * {
-  scrollbar-color: var(--border-color) transparent;
   scrollbar-width: thin;
+  scrollbar-color: var(--scrollbar-thumb) var(--scrollbar-track);
 }
 
 *::-webkit-scrollbar {
-  width: 10px;
-  height: 10px;
+  width: 8px;
+  height: 8px;
 }
 
 *::-webkit-scrollbar-track {
-  background: transparent;
+  background: var(--scrollbar-track);
 }
 
 *::-webkit-scrollbar-thumb {
-  background-color: var(--border-color);
-  border: 2px solid transparent;
+  background-color: var(--scrollbar-thumb);
+  border: 2px solid var(--scrollbar-track);
   background-clip: padding-box;
-  border-radius: 6px;
+  border-radius: var(--radius);
 }
 
 *::-webkit-scrollbar-thumb:hover {
-  background-color: var(--accent);
+  background-color: var(--scrollbar-thumb-hover);
 }
 
 *::-webkit-scrollbar-corner {
-  background: transparent;
+  background: var(--scrollbar-track);
+}
+
+/* xterm's viewport has a pure-black background and hardcodes `overflow-y: scroll`,
+   which paints an always-present scrollbar — with no scrollback the thumb fills
+   the whole track and reads as a solid accent bar down the right edge. Force
+   `auto` so the bar only appears when there's actually something to scroll. The
+   thumb inherits the same standard scrollbar-color as everything else so its bar
+   matches (a themed bluish thumb on a themed track). */
+.xterm-viewport {
+  overflow-y: auto !important;
+  scrollbar-width: thin;
+  scrollbar-color: var(--scrollbar-thumb) var(--scrollbar-track);
 }
 
 /* ── Activity calendar color levels (shared across themes) ──────────── */
 /* Override per-theme below where contrast requires it. */
 
+/* ─────────────────────────────────────────────────────────────────────
+   HOW TO ADD A THEME (quick reference)
+   1. Copy one of the [data-theme="..."] blocks below (start from `light`
+      or `dark` — the "fancy" ones add gradients/token overrides).
+   2. Rename the selector: [data-theme="my_theme"] { ... }
+   3. Register it so the Settings → Theme picker shows it, in
+      src/types/index.ts: add to the `Theme` union AND the `THEMES` array.
+   No other file needs changing — settings just stores the id string and
+   App.tsx puts it on <html data-theme="...">.
+
+   The variables you actually recolor (everything else can be left alone):
+     --bg-main / --bg-panel / --bg-header  → window, panels, header
+     --bg-elevated                          → menus/dialogs/popovers (a step
+       lighter than --bg-panel in dark themes, white in light ones)
+     --shadow-1/2/3                         → elevation (dark defaults on :root;
+       light themes override with the softer grey set — copy from `light`)
+     --border-color / --border-subtle       → separators, outlines
+     --text-primary / --text-secondary / --text-muted → text tiers
+     --accent / --accent-hover / --accent-active      → the theme's hue
+       (buttons, active pill, links, scrollbar thumb, focus rings)
+     --accent-secondary                     → secondary highlight hue
+     --control-bg / --control-hover-bg / --control-border → inputs/buttons
+     --pill-active-bg / --pill-active-border / --pill-hover-bg → project pills
+     --success / --warning / --danger        → status colors (usually keep)
+     --wm-close / --wm-minimize / --wm-maximize → window-control buttons
+     --activity-0..4                         → calendar heatmap ramp (light→dark)
+   Tip: pick one --accent, then derive -hover (darker), -active (darker
+   still), and the pill-active-* rgba() from that same hue.
+   ───────────────────────────────────────────────────────────────────── */
+
 /* ── Theme: fancy_dark (default) ─────────────────────────────────────── */
 :root,
 [data-theme="fancy_dark"] {
   --bg-main: #101624;
   --bg-panel: #16213a;
+  --bg-elevated: #1b2946;
   --bg-header: linear-gradient(90deg, #101624 0%, #16213a 48%, #241735 100%);
-  --border-color: rgba(94, 220, 255, 0.35);
+  /* The header tone as a SOLID, opaque color. --bg-header is a gradient in the
+     "fancy" themes, which makes it unusable wherever a color is required: a
+     `color-mix(… var(--bg-header))` is then an invalid value and the whole
+     declaration drops, leaving the surface TRANSPARENT (a sticky table header
+     the body then bleeds through). Any table header / sticky chrome reads this
+     instead; every theme declares it as a plain color. */
+  --bg-header-solid: #16213a;
+  --border-color: rgba(94, 220, 255, 0.2);
   --border-subtle: #22304a;
   --text-primary: #f4f8ff;
   --text-secondary: #d8e2f3;
@@ -101,12 +232,65 @@ html, body, #root {
   --accent-hover: #5edcff;
   --accent-active: #1ca7d8;
   --accent-secondary: #b388ff;
+  --info: #6cb6ff;
+  /* Header logo: pure black on light themes, pure white on dark. Defaulted on
+     :root so the plain `dark` theme inherits #fff without redeclaring it. */
+  --logo-color: #fff;
+  /* Text color for solid-accent-filled controls (e.g. .dialog-connect-btn,
+     .how-to-start-num). One constant across themes (not redeclared per theme,
+     so it cascades from :root everywhere). NOTE: this fixed white gives poor
+     contrast on the bright accents (e.g. fancy_dark's cyan), so filled-accent
+     CTA buttons use --bg-main instead (see .btn-primary) — which is dark in dark
+     themes and light in light themes, tracking the accent for legible text. */
+  --accent-contrast: #ffffff;
+  /* Corner-radius scale for the whole app. Every surface/button rule reads one
+     of these tokens, so the app-wide feel flips from here: --radius-sm for
+     small controls (inputs, buttons, chips), --radius for panels/cards/menus,
+     --radius-lg for dialogs and large surfaces, --radius-full for circles and
+     pill shapes. Defined once on :root (not per theme); a theme that wants the
+     old sharp-corner house style can override these to 0 in its own block. */
+  --radius-sm: 5px;
+  --radius: 8px;
+  --radius-lg: 12px;
+  --radius-full: 999px;
+  /* Elevation scale. Depth is expressed by surface tone (--bg-main < --bg-panel
+     < --bg-elevated) plus these soft layered shadows — not by loud borders.
+     --shadow-1: resting controls/cards; --shadow-2: popovers, dropdowns,
+     tooltips; --shadow-3: dialogs and floating windows. Dark defaults here;
+     light themes override with softer, bluer-grey shadows below. */
+  --shadow-1: 0 1px 2px rgba(0, 0, 0, 0.24), 0 1px 3px rgba(0, 0, 0, 0.18);
+  --shadow-2: 0 4px 16px rgba(0, 0, 0, 0.32), 0 2px 6px rgba(0, 0, 0, 0.22);
+  --shadow-3: 0 16px 48px rgba(0, 0, 0, 0.5), 0 4px 12px rgba(0, 0, 0, 0.3);
+  /* Motion: one quick ease for hover/press/focus feedback everywhere, one
+     slower ease for layout-level movement (panel dock, drawer slide). */
+  --transition: 140ms ease;
+  --transition-slow: 240ms ease;
+  /* Typography. The variable fonts are bundled (fontsource, imported in
+     main.tsx) so the app renders identically on every OS; the stacks fall back
+     to the platform faces when the import is unavailable. */
+  --font-sans: "Inter Variable", Inter, -apple-system, BlinkMacSystemFont,
+    "Segoe UI", Roboto, sans-serif;
+  --font-mono: "JetBrains Mono Variable", "JetBrains Mono", ui-monospace,
+    "SF Mono", Menlo, Consolas, monospace;
+  /* Scrollbar colors. Defined ONCE on :root but referencing the theme's own
+     --accent / --bg-panel, which are re-declared per theme on this same <html>
+     element — so `var()`'s lazy resolution gives every theme a bluish (accent)
+     thumb on its own panel-colored track without per-theme scrollbar rules. Both
+     are SOLID on purpose: a `transparent` track makes some WebKitGTK builds fall
+     back to the native light GTK scrollbar (white trough + grey slider), and a
+     low-alpha thumb over that washes to grey — the bug this replaces. */
+  --scrollbar-thumb: var(--accent);
+  --scrollbar-thumb-hover: var(--accent-hover, var(--accent));
+  --scrollbar-track: var(--bg-panel);
   --control-bg: #18243b;
   --control-hover-bg: #22304a;
   --control-border: #293852;
   --success: #7ee787;
   --warning: #ffd166;
   --danger: #ff5c8a;
+  /* Helix signature hues for the pill/tab labels (apricot + green). */
+  --helix-orange: #f47868;
+  --helix-green: #9fd86a;
   --pill-bg: transparent;
   --pill-active-bg: rgba(54, 197, 240, 0.16);
   --pill-active-border: #36c5f0;
@@ -120,13 +304,28 @@ html, body, #root {
   --activity-2: #006d32;
   --activity-3: #26a641;
   --activity-4: #39d353;
+  /* Glass chrome tokens — read only by the "Glass chrome" section below, never
+     by the plain --bg-panel/--bg-elevated/--bg-header vars (100+ nested-content
+     rules read those; making those translucent app-wide would stack
+     translucency-on-translucency and wreck contrast everywhere). These instead
+     recolor just the outer chrome surfaces (header, side panel, tab bars,
+     dialogs, menus, pills) for a frosted-glass look. */
+  --glass-blur: 18px;
+  --glass-blur-strong: 34px;
+  --glass-saturate: 150%;
+  --glass-panel: rgba(20, 30, 52, 0.6);
+  --glass-elevated: rgba(22, 32, 56, 0.94);
+  --glass-header: linear-gradient(90deg, rgba(16, 22, 36, 0.55) 0%, rgba(22, 33, 58, 0.55) 48%, rgba(36, 23, 53, 0.55) 100%);
+  --glass-border: rgba(255, 255, 255, 0.14);
 }
 
 /* ── Theme: dark (plain dark) ────────────────────────────────────────── */
 [data-theme="dark"] {
   --bg-main: #0d1117;
   --bg-panel: #161b22;
+  --bg-elevated: #1c2128;
   --bg-header: #161b22;
+  --bg-header-solid: #161b22;
   --border-color: #30363d;
   --border-subtle: #21262d;
   --text-primary: #e6edf3;
@@ -136,12 +335,15 @@ html, body, #root {
   --accent-hover: #58a6ff;
   --accent-active: #1f6feb;
   --accent-secondary: #d29922;
+  --info: #58a6ff;
   --control-bg: #1c2128;
   --control-hover-bg: #262d36;
   --control-border: #30363d;
   --success: #3fb950;
   --warning: #e3b341;
   --danger: #f85149;
+  --helix-orange: #f47868;
+  --helix-green: #9fd86a;
   --pill-bg: transparent;
   --pill-active-bg: rgba(56, 139, 253, 0.1);
   --pill-active-border: rgba(56, 139, 253, 0.2);
@@ -161,7 +363,12 @@ html, body, #root {
 [data-theme="light"] {
   --bg-main: #ffffff;
   --bg-panel: #f6f8fa;
+  --bg-elevated: #ffffff;
   --bg-header: #f6f8fa;
+  --bg-header-solid: #f6f8fa;
+  --shadow-1: 0 1px 2px rgba(16, 24, 40, 0.06), 0 1px 3px rgba(16, 24, 40, 0.1);
+  --shadow-2: 0 4px 16px rgba(16, 24, 40, 0.12), 0 2px 6px rgba(16, 24, 40, 0.08);
+  --shadow-3: 0 16px 48px rgba(16, 24, 40, 0.18), 0 4px 12px rgba(16, 24, 40, 0.1);
   --border-color: #d0d7de;
   --border-subtle: #eaecef;
   --text-primary: #24292f;
@@ -171,12 +378,16 @@ html, body, #root {
   --accent-hover: #0550ae;
   --accent-active: #054da7;
   --accent-secondary: #bf8700;
+  --info: #0969da;
+  --logo-color: #000;
   --control-bg: #ffffff;
   --control-hover-bg: #f6f8fa;
   --control-border: #d0d7de;
   --success: #1a7f37;
   --warning: #9a6700;
   --danger: #d1242f;
+  --helix-orange: #d6492f;
+  --helix-green: #2e7d32;
   --pill-bg: transparent;
   --pill-active-bg: rgba(9, 105, 218, 0.1);
   --pill-active-border: rgba(9, 105, 218, 0.24);
@@ -196,7 +407,12 @@ html, body, #root {
 [data-theme="fancy_light"] {
   --bg-main: #f7fbff;
   --bg-panel: #e8f7ff;
+  --bg-elevated: #ffffff;
   --bg-header: linear-gradient(90deg, #f7fbff 0%, #e8f7ff 48%, #f5ecff 100%);
+  --bg-header-solid: #e8f7ff;
+  --shadow-1: 0 1px 2px rgba(16, 24, 40, 0.06), 0 1px 3px rgba(16, 24, 40, 0.1);
+  --shadow-2: 0 4px 16px rgba(16, 24, 40, 0.12), 0 2px 6px rgba(16, 24, 40, 0.08);
+  --shadow-3: 0 16px 48px rgba(16, 24, 40, 0.18), 0 4px 12px rgba(16, 24, 40, 0.1);
   --border-color: rgba(9, 105, 218, 0.28);
   --border-subtle: #d8e5f0;
   --text-primary: #1f2937;
@@ -206,12 +422,16 @@ html, body, #root {
   --accent-hover: #0550ae;
   --accent-active: #054da7;
   --accent-secondary: #14b8a6;
+  --info: #0ea5e9;
+  --logo-color: #000;
   --control-bg: #ffffff;
   --control-hover-bg: #f6f8fa;
   --control-border: #c9d7e5;
   --success: #1a7f37;
   --warning: #9a6700;
   --danger: #d1242f;
+  --helix-orange: #d6492f;
+  --helix-green: #2e7d32;
   --pill-bg: transparent;
   --pill-active-bg: rgba(9, 105, 218, 0.16);
   --pill-active-border: #0969da;
@@ -227,6 +447,179 @@ html, body, #root {
   --activity-4: #216e39;
 }
 
+/* ── Theme: light_lavender ──────────────────────────────────────────── */
+[data-theme="light_lavender"] {
+  --bg-main: #faf9fe;
+  --bg-panel: #f2effa;
+  --bg-elevated: #ffffff;
+  --bg-header: #f2effa;
+  --bg-header-solid: #f2effa;
+  --shadow-1: 0 1px 2px rgba(16, 24, 40, 0.06), 0 1px 3px rgba(16, 24, 40, 0.1);
+  --shadow-2: 0 4px 16px rgba(16, 24, 40, 0.12), 0 2px 6px rgba(16, 24, 40, 0.08);
+  --shadow-3: 0 16px 48px rgba(16, 24, 40, 0.18), 0 4px 12px rgba(16, 24, 40, 0.1);
+  --border-color: #ddd6f0;
+  --border-subtle: #ebe7f6;
+  --text-primary: #2e2a3d;
+  --text-secondary: #5f5878;
+  --text-muted: #938bab;
+  --accent: #7c5cdb;
+  --accent-hover: #6a49c8;
+  --accent-active: #5d3eb8;
+  --accent-secondary: #9d6ecb;
+  --info: #6d7fd4;
+  --logo-color: #000;
+  --control-bg: #ffffff;
+  --control-hover-bg: #f2effa;
+  --control-border: #ddd6f0;
+  --success: #2e7d5b;
+  --warning: #9a6700;
+  --danger: #d1242f;
+  --helix-orange: #d6492f;
+  --helix-green: #2e7d32;
+  --pill-bg: transparent;
+  --pill-active-bg: rgba(124, 92, 219, 0.12);
+  --pill-active-border: rgba(124, 92, 219, 0.28);
+  --pill-hover-bg: rgba(95, 88, 120, 0.08);
+  --offline-bg: rgba(209, 36, 47, 0.88);
+  --wm-close: #f85149;
+  --wm-minimize: #e3b341;
+  --wm-maximize: #3fb950;
+  --activity-0: #ece8f5;
+  --activity-1: #cdbdf0;
+  --activity-2: #a98fe0;
+  --activity-3: #8968cf;
+  --activity-4: #6344ab;
+  /* Glass chrome tokens — see the matching comment in fancy_dark above; same
+     idea, tuned for a light, lavender-tinted frosted glass. */
+  --glass-blur: 16px;
+  --glass-blur-strong: 30px;
+  --glass-saturate: 130%;
+  --glass-panel: rgba(242, 239, 250, 0.58);
+  --glass-elevated: rgba(248, 246, 253, 0.95);
+  --glass-header: rgba(242, 239, 250, 0.5);
+  --glass-border: rgba(255, 255, 255, 0.75);
+}
+
+/* ── Glass chrome (fancy_dark / light_lavender) ───────────────────────────
+   Frosted-glass treatment for the app's outer chrome ONLY — header, right
+   file panel, tab bars, docked file sidebar, project pills, dialogs, and
+   popover menus. Reads the --glass-* tokens defined on each theme above, not
+   the shared --bg-panel/--bg-elevated (see the comment on those tokens for
+   why). Both themes share one rule set since they read the same variable
+   names with theme-appropriate values. */
+[data-theme="fancy_dark"] .app-header,
+[data-theme="light_lavender"] .app-header,
+[data-theme="fancy_dark"] .right-panel,
+[data-theme="light_lavender"] .right-panel,
+[data-theme="fancy_dark"] .tab-bar,
+[data-theme="light_lavender"] .tab-bar,
+[data-theme="fancy_dark"] .subwindow-files,
+[data-theme="light_lavender"] .subwindow-files {
+  backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturate));
+  -webkit-backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturate));
+}
+
+/* Dialogs and popover menus float directly over readable content (terminal
+   text, code, file trees) — they need to fully obscure it, not just tint it,
+   so these get a much stronger blur plus a near-opaque fill (--glass-elevated)
+   rather than the lighter chrome-panel treatment above. */
+[data-theme="fancy_dark"] .project-dialog,
+[data-theme="light_lavender"] .project-dialog,
+[data-theme="fancy_dark"] .settings-dialog,
+[data-theme="light_lavender"] .settings-dialog,
+[data-theme="fancy_dark"] .stats-dialog,
+[data-theme="light_lavender"] .stats-dialog,
+[data-theme="fancy_dark"] .context-menu,
+[data-theme="light_lavender"] .context-menu,
+[data-theme="fancy_dark"] .tab-new-menu,
+[data-theme="light_lavender"] .tab-new-menu,
+[data-theme="fancy_dark"] .project-switcher-add-menu,
+[data-theme="light_lavender"] .project-switcher-add-menu {
+  backdrop-filter: blur(var(--glass-blur-strong)) saturate(var(--glass-saturate));
+  -webkit-backdrop-filter: blur(var(--glass-blur-strong)) saturate(var(--glass-saturate));
+}
+
+[data-theme="fancy_dark"] .app-header,
+[data-theme="light_lavender"] .app-header {
+  background: var(--glass-header);
+  box-shadow: inset 0 -1px 0 var(--glass-border), 0 8px 24px -16px rgba(0, 0, 0, 0.4);
+}
+
+/* The right-side file panel is fully opaque even in the glass themes: it floats
+   over live terminal/code content, and a translucent tree is hard to read. It
+   opts out of the shared frosted-glass rule above (opaque fill ⇒ blur is moot). */
+[data-theme="fancy_dark"] .right-panel,
+[data-theme="light_lavender"] .right-panel {
+  background-color: var(--bg-panel);
+  backdrop-filter: none;
+  -webkit-backdrop-filter: none;
+}
+
+[data-theme="fancy_dark"] .tab-bar,
+[data-theme="light_lavender"] .tab-bar {
+  background-color: var(--glass-panel);
+  box-shadow: inset 0 1px 0 var(--glass-border);
+}
+
+[data-theme="fancy_dark"] .subwindow-files,
+[data-theme="light_lavender"] .subwindow-files {
+  background: var(--glass-panel);
+}
+
+/* No glass-theme pill background: pills are transparent in every theme so they
+   melt into the header bar behind them, showing its exact color. Only text (and
+   the active pill's accent frame) distinguishes a pill from the bar. */
+
+[data-theme="fancy_dark"] .project-dialog,
+[data-theme="light_lavender"] .project-dialog,
+[data-theme="fancy_dark"] .settings-dialog,
+[data-theme="light_lavender"] .settings-dialog,
+[data-theme="fancy_dark"] .stats-dialog,
+[data-theme="light_lavender"] .stats-dialog {
+  background: var(--glass-elevated);
+  border-color: var(--glass-border);
+  /* Keep the accent top rail even though border-color above just reset every
+     edge to --glass-border — the rail is what ties a glass dialog back to the
+     header's tint. */
+  border-top-color: var(--accent);
+  box-shadow: var(--shadow-3), inset 0 1px 0 var(--glass-border);
+}
+
+[data-theme="fancy_dark"] .context-menu,
+[data-theme="light_lavender"] .context-menu,
+[data-theme="fancy_dark"] .tab-new-menu,
+[data-theme="light_lavender"] .tab-new-menu,
+[data-theme="fancy_dark"] .project-switcher-add-menu,
+[data-theme="light_lavender"] .project-switcher-add-menu {
+  background: var(--glass-elevated);
+  border-color: var(--glass-border);
+  border-top-color: var(--accent);
+  box-shadow: var(--shadow-3), inset 0 1px 0 var(--glass-border);
+}
+
+/* Blur the whole app behind an open dialog too, so a modal reads as one
+   continuous glass surface rather than just a frosted frame. */
+[data-theme="fancy_dark"] .modal-backdrop,
+[data-theme="light_lavender"] .modal-backdrop {
+  backdrop-filter: blur(8px) saturate(120%);
+  -webkit-backdrop-filter: blur(8px) saturate(120%);
+}
+
+/* Ambient color wash behind the glass chrome — flat single-color bg-main
+   gives blurred edges nothing to reveal; a faint tinted glow makes the
+   frosted panels read as glass over a scene instead of glass over a void. */
+[data-theme="fancy_dark"] .app-shell {
+  background-image:
+    radial-gradient(1200px 600px at 12% -10%, rgba(54, 197, 240, 0.09), transparent 60%),
+    radial-gradient(1000px 520px at 100% 0%, rgba(179, 136, 255, 0.08), transparent 55%);
+}
+
+[data-theme="light_lavender"] .app-shell {
+  background-image:
+    radial-gradient(1200px 600px at 12% -10%, rgba(124, 92, 219, 0.08), transparent 60%),
+    radial-gradient(1000px 520px at 100% 0%, rgba(157, 110, 203, 0.07), transparent 55%);
+}
+
 /* ── App layout shell ─────────────────────────────────────────────────── */
 .app-shell {
   display: flex;
@@ -234,7 +627,7 @@ html, body, #root {
   height: 100%;
   background-color: var(--bg-main);
   color: var(--text-primary);
-  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  font-family: var(--font-sans, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif);
   font-size: 13px;
 }
 
@@ -253,8 +646,8 @@ select {
   background-color: var(--control-bg);
   color: var(--text-primary);
   border: 1px solid var(--control-border);
-  border-radius: 3px;
-  padding: 3px 28px 3px 8px;
+  border-radius: var(--radius-sm);
+  padding: 4px 28px 4px 9px;
   cursor: pointer;
   background-image:
     linear-gradient(45deg, transparent 50%, var(--text-primary) 50%),
@@ -272,6 +665,21 @@ select:focus {
   outline: none;
 }
 
+/* ── Standard focus ring ─────────────────────────────────────────────────
+   One keyboard-focus affordance for every interactive element: a soft accent
+   ring, offset so it never collides with the element's own border. More
+   specific per-component :focus-visible rules below still win where they set
+   their own treatment. The xterm helper textarea is excluded — it holds focus
+   whenever a terminal is active and must stay invisible. */
+button:focus-visible,
+select:focus-visible,
+input:focus-visible,
+[tabindex]:focus-visible,
+textarea:focus-visible:not(.xterm-helper-textarea) {
+  outline: 2px solid color-mix(in srgb, var(--accent) 55%, transparent);
+  outline-offset: 1px;
+}
+
 select option {
   background: var(--bg-panel);
   color: var(--text-primary);
@@ -282,16 +690,21 @@ select option {
   display: flex;
   position: relative;
   overflow: hidden;
-  transition: padding-right 0.2s ease;
+  transition: padding-right var(--transition-slow), padding-left var(--transition-slow);
 }
 
-/* When the right panel is pinned it docks into layout: inset the body by the
-   panel width so the center panel reflows instead of being overlaid. The panel
-   is absolutely positioned at right:0, so it fills the freed padding region. */
+/* When the panel is pinned it docks into layout: inset the body by the panel
+   width so the center panel reflows instead of being overlaid. The panel is
+   absolutely positioned against its edge, so it fills the freed padding region.
+   `left-docked` is the mirror for the left-side variant. */
 .app-body.right-docked {
   padding-right: 280px;
 }
 
+.app-body.left-docked {
+  padding-left: 280px;
+}
+
 /* ── Header bar ─────────────────────────────────────────────────────── */
 .app-header {
   height: 44px;
@@ -304,6 +717,24 @@ select option {
   z-index: 80;
 }
 
+/* A soft theme-accent wash over the header bar (lavender in light_lavender,
+   cyan-blue in fancy_dark, etc.) so the top bar reads as themed, not just a
+   neutral panel. A translucent overlay rather than recoloring --bg-header
+   directly, since that variable is a plain color in some themes and a
+   gradient in others (fancy_dark/fancy_light) — an overlay works over either
+   with no per-theme branching. Negative z-index keeps it under the header's
+   own (unpositioned, normal-flow) children within .app-header's own stacking
+   context. */
+.app-header::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: var(--accent);
+  opacity: 0.32;
+  pointer-events: none;
+  z-index: -1;
+}
+
 .header-left {
   display: flex;
   align-items: center;
@@ -313,13 +744,39 @@ select option {
 
 }
 
+/* Explicit window-move grip at the top-left of the header, mirroring the
+   subwindow `.tab-drag-grip`. The header is already a drag region, but this is
+   an always-present, obvious handle. */
+.app-drag-grip {
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 22px;
+  color: var(--text-muted);
+  font-size: 14px;
+  line-height: 1;
+  user-select: none;
+  opacity: 0.6;
+  cursor: grab;
+  transition: opacity var(--transition), color var(--transition);
+}
+.app-drag-grip:hover {
+  opacity: 1;
+  color: var(--text-primary);
+}
+.app-drag-grip:active { cursor: grabbing; }
+
 .header-center {
   flex: 1;
   min-width: 0;
   display: flex;
   align-items: stretch;
   overflow: visible;
-
+  /* Equal spacing between the brain/global-apps buttons and the project
+     switcher's leading settings gear — .project-switcher supplies none of its
+     own left padding, so this gap is the only thing between any of the three. */
+  gap: 6px;
 }
 
 .header-right {
@@ -331,54 +788,88 @@ select option {
 
 }
 
-/* ── Window controls (traffic lights) ───────────────────────────────── */
+/* macOS draws native traffic-light buttons over the top-left of the window
+   (Overlay title-bar style; see tauri.macos.conf.json). Reserve room so the
+   logo and version don't sit under them, and the custom `.wm-controls` are
+   hidden in WindowControls.tsx on macOS. */
+.app-header.is-mac .header-left {
+  padding-left: 78px;
+}
+
+/* ── Window controls (rectangular, colored glyphs) ──────────────────── */
 .wm-controls {
   display: flex;
   align-items: center;
-  gap: 8px;
+  gap: 4px;
   flex-shrink: 0;
 }
 
 .wm-btn {
   position: relative;
-  width: 13px;
-  height: 13px;
+  width: 30px;
+  height: 22px;
   padding: 0;
-  border-radius: 50%;
-  border: 1px solid rgba(0, 0, 0, 0.18);
+  border-radius: 6px;
+  border: 1px solid transparent;
+  background: transparent;
   cursor: pointer;
   flex-shrink: 0;
   display: flex;
   align-items: center;
   justify-content: center;
-  transition: filter 0.12s ease, transform 0.08s ease;
+  transition: background-color var(--transition), border-color var(--transition),
+    transform var(--transition);
 }
 
-.wm-btn:hover { filter: brightness(1.12); }
-.wm-btn:active { transform: scale(0.92); filter: brightness(0.9); }
+.wm-btn:active { transform: scale(0.92); }
 .wm-btn:focus-visible {
   outline: 2px solid var(--accent, #58a6ff);
   outline-offset: 2px;
 }
 
-.wm-close    { background-color: var(--wm-close); }
-.wm-minimize { background-color: var(--wm-minimize); }
-.wm-maximize { background-color: var(--wm-maximize); }
+.wm-minimize:hover {
+  background: color-mix(in srgb, var(--wm-minimize) 20%, transparent);
+  border-color: color-mix(in srgb, var(--wm-minimize) 45%, transparent);
+}
+.wm-maximize:hover {
+  background: color-mix(in srgb, var(--wm-maximize) 20%, transparent);
+  border-color: color-mix(in srgb, var(--wm-maximize) 45%, transparent);
+}
+.wm-close:hover {
+  background: color-mix(in srgb, var(--wm-close) 26%, transparent);
+  border-color: color-mix(in srgb, var(--wm-close) 55%, transparent);
+}
 
-/* Glyphs revealed when hovering anywhere over the group. */
-.wm-btn::before {
+/* Minimize glyph: a single bar. */
+.wm-minimize::before {
   content: "";
-  color: rgba(0, 0, 0, 0.55);
-  font-size: 9px;
-  line-height: 1;
-  font-weight: 700;
-  opacity: 0;
-  transition: opacity 0.12s ease;
+  width: 10px;
+  height: 2px;
+  border-radius: 1px;
+  background: var(--wm-minimize);
+}
+
+/* Maximize glyph: a small window outline. */
+.wm-maximize::before {
+  content: "";
+  width: 9px;
+  height: 9px;
+  border-radius: 2px;
+  border: 1.5px solid var(--wm-maximize);
+}
+
+/* Close glyph: an × from two crossed bars. */
+.wm-close::before,
+.wm-close::after {
+  content: "";
+  position: absolute;
+  width: 12px;
+  height: 2px;
+  border-radius: 1px;
+  background: var(--wm-close);
 }
-.wm-controls:hover .wm-btn::before { opacity: 1; }
-.wm-close::before    { content: "\00d7"; }   /* × */
-.wm-minimize::before { content: "\2013"; }   /* – */
-.wm-maximize::before { content: "\002b"; }  /* + */
+.wm-close::before { transform: rotate(45deg); }
+.wm-close::after { transform: rotate(-45deg); }
 
 /* ── App logo ────────────────────────────────────────────────────────── */
 .app-logo {
@@ -387,8 +878,9 @@ select option {
   object-fit: contain;
   flex-shrink: 0;
   /* Ring/branch strokes use currentColor so the logo stays legible on every
-     theme (the dark-green original vanished on the dark background). */
-  color: var(--text-primary);
+     theme (the dark-green original vanished on the dark background). Pure
+     black on light themes, pure white on dark, via the per-theme token. */
+  color: var(--logo-color, var(--text-primary));
 }
 
 /* The logo doubles as the root-terminal switch button. */
@@ -399,11 +891,11 @@ select option {
   padding: 4px;
   margin-right: 2px;
   border: 1px solid transparent;
-  border-radius: 0;
+  border-radius: var(--radius-sm);
   background: transparent;
   cursor: pointer;
   flex-shrink: 0;
-  transition: background-color 0.1s, border-color 0.1s;
+  transition: background-color var(--transition), border-color var(--transition);
 }
 
 .root-logo-btn:hover {
@@ -414,19 +906,9 @@ select option {
 .root-logo-btn.active {
   background: var(--pill-active-bg);
   border-color: var(--pill-active-border);
-  box-shadow: inset 0 3px 0 var(--accent);
-}
-
-/* ── Status lamp (● dot) ─────────────────────────────────────────────── */
-.status-lamp {
-  font-size: 16px;
-  line-height: 1;
-  flex-shrink: 0;
+  box-shadow: inset 0 4px 0 var(--accent);
 }
 
-.status-online  { color: var(--success); }
-.status-offline { color: var(--danger); }
-
 /* ── Version / debug / conn-type ─────────────────────────────────────── */
 .app-version-stack {
   display: flex;
@@ -454,8 +936,8 @@ select option {
   height: 32px;
   min-width: 82px;
   padding: 0 6px;
-  border: 1px solid var(--control-border);
-  background: var(--control-bg);
+  border: none;
+  background: transparent;
   color: var(--text-secondary);
   display: inline-flex;
   flex-direction: column;
@@ -502,6 +984,10 @@ select option {
   flex-shrink: 0;
 }
 
+.conn-type-icon.conn-offline {
+  color: var(--danger);
+}
+
 /* ── Clock ───────────────────────────────────────────────────────────── */
 .header-clock {
   font-size: 11px;
@@ -522,9 +1008,9 @@ select option {
   font-size: 11px;
   font-variant-numeric: tabular-nums;
   padding: 2px 5px;
-  border-radius: 3px;
+  border-radius: var(--radius-sm);
   flex-shrink: 0;
-  transition: color 0.15s;
+  transition: color var(--transition);
 }
 .app-timer-btn:hover {
   background: var(--control-hover-bg);
@@ -536,7 +1022,7 @@ select option {
   border-radius: 50%;
   background: var(--success);
   flex-shrink: 0;
-  transition: background 0.2s;
+  transition: background var(--transition-slow);
 }
 .app-timer-btn.paused .app-timer-dot {
   background: var(--text-muted);
@@ -579,5228 +1065,19240 @@ select option {
   overflow: hidden;
 }
 
-.file-viewer-header {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 4px 8px;
-  border-bottom: 1px solid var(--border-color);
-  font-size: 11px;
-  flex-shrink: 0;
+/* ── Presentation overlay (marker + laser), over every native viewer ──────── */
+.presentation-host {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
 }
 
-.file-viewer-header-spacer {
-  flex: 1;
+.presentation-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 40;
+  overflow: hidden;
 }
 
-.file-viewer-open-external {
+.presentation-canvas {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+}
+
+/* The transparent drag surface that captures marker/laser pointer input; only
+   present while a tool is active, so clicks otherwise pass through. */
+.presentation-capture {
+  position: absolute;
+  inset: 0;
+  pointer-events: auto;
+  touch-action: none;
+}
+
+.presentation-toolbar {
+  position: absolute;
+  right: 10px;
+  bottom: 10px;
+  z-index: 2;
+}
+
+.presentation-fab,
+.presentation-tool {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  background: transparent;
-  color: var(--text-muted);
   border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 0;
-  width: 20px;
-  height: 18px;
-  font-size: 13px;
-  line-height: 1;
+  background: var(--bg-elevated, var(--bg-panel));
+  color: var(--text-primary);
   cursor: pointer;
+  border-radius: 7px;
 }
 
-.file-viewer-open-external:hover {
-  color: var(--text-primary);
-  border-color: var(--text-muted);
+.presentation-fab {
+  width: 32px;
+  height: 32px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.35);
+  opacity: 0.55;
+  transition: opacity 0.12s ease;
 }
 
-/* Edit/Preview segmented toggle for the markdown viewer. */
-.file-viewer-modes {
-  display: inline-flex;
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  overflow: hidden;
+.presentation-fab:hover {
+  opacity: 1;
 }
 
-.file-viewer-mode {
-  background: transparent;
-  color: var(--text-muted);
-  border: 0;
-  padding: 1px 8px;
-  font-size: 10px;
-  cursor: pointer;
+.presentation-tools {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 5px;
+  border: 1px solid var(--border-color);
+  border-radius: 9px;
+  background: var(--bg-elevated, var(--bg-panel));
+  box-shadow: 0 4px 14px rgba(0, 0, 0, 0.4);
 }
 
-.file-viewer-mode + .file-viewer-mode {
-  border-left: 1px solid var(--border-color);
+.presentation-tool {
+  width: 28px;
+  height: 28px;
+  font-size: 14px;
+  line-height: 1;
 }
 
-.file-viewer-mode.active {
-  background: var(--accent, #4493f8);
-  color: #fff;
+.presentation-tool:hover:not(:disabled) {
+  border-color: var(--accent-color);
+  color: var(--accent-color);
 }
 
-.file-viewer-save {
-  background: transparent;
-  color: var(--text-muted);
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 1px 8px;
-  font-size: 10px;
-  cursor: pointer;
+.presentation-tool:disabled {
+  opacity: 0.4;
+  cursor: default;
 }
 
-.file-viewer-save:disabled {
-  opacity: 0.6;
-  cursor: default;
+.presentation-tool.on {
+  background: var(--accent-color);
+  border-color: var(--accent-color);
+  color: var(--bg-panel);
 }
 
-.file-viewer-save:not(:disabled):hover {
-  color: var(--text-primary);
-  border-color: var(--text-muted);
+.presentation-sep {
+  width: 1px;
+  align-self: stretch;
+  margin: 2px 2px;
+  background: var(--border-color);
 }
 
-.file-viewer-editor {
-  width: 100%;
-  height: 100%;
-  box-sizing: border-box;
-  resize: none;
-  border: 0;
-  outline: none;
-  padding: 10px 12px;
-  background: var(--bg-panel);
-  color: var(--text-primary);
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: 12px;
-  line-height: 1.5;
-  tab-size: 2;
-  /* Disable ligatures/kerning: the highlight overlay below splits the text into
-     many <span> tokens, which breaks ligature shaping at span boundaries. If the
-     textarea (plain text) still formed ligatures, its glyph advances would
-     diverge from the overlay's, so the caret drifts further from the coloured
-     text toward the end of each line. A fixed per-glyph advance keeps them 1:1. */
-  font-variant-ligatures: none;
-  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
-  font-kerning: none;
-  /* Force sub-pixel glyph advances. WebKitGTK otherwise rounds the textarea's
-     per-glyph advance to a whole pixel when placing the caret, while the <pre>
-     overlay lays glyphs out with sub-pixel precision. That fractional per-char
-     difference is invisible at a line's start but accumulates into a visible
-     caret/text drift toward the end of long lines. Pinning both layers to
-     geometricPrecision makes their advances identical so they stay aligned. */
-  text-rendering: geometricPrecision;
+.presentation-swatches {
+  display: flex;
+  align-items: center;
+  gap: 3px;
+  padding: 0 2px;
 }
 
-/* Zoom controls in the image viewer header. */
-.file-viewer-zoom {
+.presentation-swatch {
+  width: 18px;
+  height: 18px;
+  border-radius: 50%;
+  border: 2px solid transparent;
+  cursor: pointer;
+  padding: 0;
+}
+
+.presentation-swatch.on {
+  border-color: var(--text-primary);
+  box-shadow: 0 0 0 1px var(--bg-panel);
+}
+
+.presentation-settings-wrap {
+  position: relative;
   display: inline-flex;
+}
+
+.presentation-settings {
+  position: absolute;
+  right: 0;
+  bottom: calc(100% + 8px);
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  width: 190px;
+  padding: 10px;
+  border: 1px solid var(--border-color);
+  border-radius: 9px;
+  background: var(--bg-elevated, var(--bg-panel));
+  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.45);
+}
+
+.presentation-slider {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  font-size: 11px;
+  color: var(--text-primary);
+}
+
+.presentation-slider-label {
+  display: flex;
+  justify-content: space-between;
+  color: var(--text-muted);
+}
+
+.presentation-slider-label b {
+  color: var(--text-primary);
+  font-weight: 600;
+}
+
+.presentation-slider input[type="range"] {
+  width: 100%;
+  accent-color: var(--accent-color);
+  cursor: pointer;
+}
+
+.presentation-preview {
+  width: 100%;
+  border-radius: 4px;
+  min-height: 4px;
+}
+
+.file-viewer-header {
+  display: flex;
   align-items: center;
-  gap: 2px;
+  gap: 8px;
+  padding: 4px 8px;
+  border-bottom: 1px solid var(--border-color);
+  font-size: 11px;
+  flex-shrink: 0;
 }
 
-.file-viewer-zoom-btn {
+.file-viewer-header-spacer {
+  flex: 1;
+}
+
+.file-viewer-open-external {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
   background: transparent;
   color: var(--text-muted);
   border: 1px solid var(--border-color);
-  border-radius: 3px;
-  min-width: 20px;
+  border-radius: var(--radius-sm);
+  padding: 0;
+  width: 20px;
   height: 18px;
-  padding: 0 5px;
-  font-size: 12px;
+  font-size: 13px;
   line-height: 1;
   cursor: pointer;
 }
 
-.file-viewer-zoom-btn.file-viewer-zoom-text {
-  font-size: 10px;
+.file-viewer-open-external:hover {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
 }
 
-.file-viewer-zoom-btn:disabled {
-  opacity: 0.5;
-  cursor: default;
+/* Print button — shared across the viewers, mirrors the open-external icon. */
+.file-viewer-print {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 0;
+  width: 22px;
+  height: 18px;
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
 }
 
-.file-viewer-zoom-btn:not(:disabled):hover {
+.file-viewer-print:hover:not(:disabled) {
   color: var(--text-primary);
   border-color: var(--text-muted);
 }
 
-.file-viewer-zoom-level {
-  min-width: 38px;
-  text-align: center;
-  font-size: 10px;
-  color: var(--text-muted);
-  font-variant-numeric: tabular-nums;
+.file-viewer-print:disabled {
+  opacity: 0.5;
+  cursor: default;
 }
 
-/* Text-size control: the numeric level doubles as a "reset to default" button. */
-.file-viewer-fontsize-level {
-  min-width: 22px;
+/* Auto-sync toggle in the viewer header (remote projects only). Off = muted
+   outline; on = accent-tinted so it reads as active. */
+.file-viewer-autosync {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
   background: transparent;
-  border: 0;
-  padding: 0 2px;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 0;
+  width: 20px;
+  height: 18px;
+  font-size: 12px;
+  line-height: 1;
   cursor: pointer;
 }
 
-.file-viewer-fontsize-level:hover {
+.file-viewer-autosync:hover:not(:disabled) {
   color: var(--text-primary);
+  border-color: var(--text-muted);
 }
 
-/* Image viewer: a clipped viewport over a checkerboard so transparency shows.
-   The <img> inside is positioned by a JS-driven transform (zoom/pan). */
-.file-viewer-image-body {
-  overflow: hidden;
+.file-viewer-autosync.on {
+  color: var(--accent, #3fb950);
+  border-color: color-mix(in srgb, var(--accent, #3fb950) 60%, transparent);
+  background: color-mix(in srgb, var(--accent, #3fb950) 14%, transparent);
 }
 
-.file-viewer-image-viewport {
-  position: relative;
-  width: 100%;
-  height: 100%;
-  overflow: hidden;
-  cursor: grab;
-  touch-action: none;
-  background-color: var(--bg-panel);
-  background-image:
-    linear-gradient(45deg, rgba(127, 127, 127, 0.12) 25%, transparent 25%),
-    linear-gradient(-45deg, rgba(127, 127, 127, 0.12) 25%, transparent 25%),
-    linear-gradient(45deg, transparent 75%, rgba(127, 127, 127, 0.12) 75%),
-    linear-gradient(-45deg, transparent 75%, rgba(127, 127, 127, 0.12) 75%);
-  background-size: 20px 20px;
-  background-position: 0 0, 0 10px, 10px -10px, -10px 0;
+.file-viewer-autosync:disabled {
+  cursor: default;
+  opacity: 0.45;
 }
 
-.file-viewer-image-viewport.dragging {
-  cursor: grabbing;
+/* "Resolve divergence" button — only shown for an amber (diverged) file. It
+   wears the exact amber (#d29922) of the Orange list's `±` dot it opens, so the
+   affordance reads as the same thing in both places (not the theme-varying
+   --warning, which the Orange list also deliberately doesn't use). */
+.file-viewer-resolve {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 18px;
+  padding: 0;
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
+  border-radius: var(--radius-sm);
+  color: #d29922;
+  border: 1px solid color-mix(in srgb, #d29922 55%, transparent);
+  background: color-mix(in srgb, #d29922 14%, transparent);
 }
 
-.file-viewer-image {
-  position: absolute;
-  top: 0;
-  left: 0;
-  max-width: none;
-  max-height: none;
-  user-select: none;
-  -webkit-user-drag: none;
-  will-change: transform;
+.file-viewer-resolve:hover {
+  color: #d29922;
+  border-color: #d29922;
+  background: color-mix(in srgb, #d29922 24%, transparent);
 }
 
-.file-viewer-body {
-  flex: 1;
-  overflow: auto;
-  min-height: 0;
+/* Edit/Preview segmented toggle for the markdown viewer. */
+.file-viewer-modes {
+  display: inline-flex;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
 }
 
-.file-viewer-loading,
-.file-viewer-error {
-  padding: 12px;
-  font-size: 12px;
+.file-viewer-mode {
+  background: transparent;
   color: var(--text-muted);
+  border: 0;
+  padding: 1px 8px;
+  font-size: 10px;
+  cursor: pointer;
 }
 
-.file-viewer-error {
-  color: var(--danger, #f85149);
-  white-space: pre-wrap;
-  word-break: break-word;
+.file-viewer-mode + .file-viewer-mode {
+  border-left: 1px solid var(--border-color);
 }
 
-/* Code editor: a line-number gutter beside a scrolling monospace textarea. The
-   gutter is scroll-synced from JS (file-viewer-gutter has no scrollbar), so the
-   body must not scroll — the textarea owns the scroll. Font metrics (size 12px,
-   line-height 18px, 10px top padding) are shared so the numbers stay aligned. */
-.file-viewer-code-body {
-  overflow: hidden;
+.file-viewer-mode.active {
+  background: var(--accent, #4493f8);
+  color: var(--accent-contrast);
 }
 
-.file-viewer-code {
-  position: relative;
-  display: flex;
-  height: 100%;
-  min-height: 0;
-  /* Editor font metrics. Defaults match the shared 12px/18px layout; the text
-     size control overrides these inline so the gutter + overlay layers scale
-     together and stay aligned. */
-  --code-font-size: 12px;
-  --code-line-height: 18px;
+.file-viewer-save {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 1px 8px;
+  font-size: 10px;
+  cursor: pointer;
 }
 
-.file-viewer-gutter {
-  flex-shrink: 0;
-  overflow: hidden;
-  padding: 10px 8px 10px 10px;
-  text-align: right;
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: var(--code-font-size, 12px);
-  line-height: var(--code-line-height, 18px);
-  color: var(--text-muted);
-  background: var(--bg-panel);
-  border-right: 1px solid var(--border-color);
-  user-select: none;
-  font-variant-numeric: tabular-nums;
+.file-viewer-save:disabled {
+  opacity: 0.6;
+  cursor: default;
 }
 
-/* The line numbers are translated as a block to follow the textarea's vertical
-   scroll (see syncScroll); the gutter itself stays put and clips them. */
-.file-viewer-gutter-inner {
-  will-change: transform;
-}
-
-.file-viewer-gutter-line {
-  height: var(--code-line-height, 18px);
-}
-
-/* #67: gutter line numbers for lines that contain a search match — the current
-   match brightest, echoing the in-text highlight colours. */
-.file-viewer-gutter-line.has-match {
+.file-viewer-save:not(:disabled):hover {
   color: var(--text-primary);
-  background: rgba(255, 213, 0, 0.28);
-  border-radius: 2px;
-}
-.file-viewer-gutter-line.current-match {
-  color: #1a1a1a;
-  background: rgba(255, 145, 0, 0.85);
-  border-radius: 2px;
-  font-weight: 600;
-}
-
-/* Hidden mirror that measures each logical line's wrapped height so the wrap-mode
-   gutter (LaTeX viewer) can size its cells to match. Shares the editor's font
-   metrics, padding and wrap rules; its width is set inline to the textarea's
-   content width. Never painted — visibility:hidden keeps it laid out. */
-.file-viewer-gutter-measure {
-  position: absolute;
-  top: 0;
-  left: 0;
-  margin: 0;
-  padding: 10px 12px;
-  box-sizing: border-box;
-  visibility: hidden;
-  pointer-events: none;
-  z-index: -1;
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: var(--code-font-size, 12px);
-  line-height: var(--code-line-height, 18px);
-  tab-size: 4;
-  font-variant-ligatures: none;
-  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
-  font-kerning: none;
-  text-rendering: geometricPrecision;
-}
-.fv-measure-line {
-  white-space: pre-wrap;
-  overflow-wrap: anywhere;
-  word-break: normal;
-}
-
-/* The editing area beside the gutter. It holds the highlight <pre> layer and the
-   <textarea> stacked on top of each other; the textarea owns the scroll and the
-   <pre> is scroll-synced from JS. Both share identical font metrics and padding
-   so the coloured text sits exactly under the editable text. */
-.file-viewer-code-area {
-  position: relative;
-  flex: 1;
-  min-width: 0;
-  height: 100%;
-  overflow: hidden;
-  background: var(--bg-panel);
+  border-color: var(--text-muted);
 }
 
-.file-viewer-code-editor {
-  position: absolute;
-  inset: 0;
-  width: 100%;
-  height: 100%;
-  z-index: 1;
+/* "Format document" button — same chrome as the save button. */
+.file-viewer-format-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
   background: transparent;
-  font-size: var(--code-font-size, 12px);
-  line-height: var(--code-line-height, 18px);
-  white-space: pre;
-  overflow: auto;
-  tab-size: 4;
-}
-
-/* While a follow modifier (Ctrl/Cmd) is held AND the pointer is over a recognised
-   link in the LaTeX source editor, show a link cursor so Ctrl/Cmd+Click to open a
-   referenced file is discoverable. Gated on hover so only the link reads as
-   clickable, not the whole editor. */
-.file-viewer-code-area.link-hover .file-viewer-code-editor {
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 1px 8px;
+  font-size: 10px;
   cursor: pointer;
 }
 
-/* With a highlight layer present, hide the textarea's own glyphs (keeping the
-   caret visible) so the coloured <pre> underneath shows through. The selection
-   highlight still paints over the transparent text. */
-.file-viewer-code-area.highlighted .file-viewer-code-editor {
-  color: transparent;
-  -webkit-text-fill-color: transparent;
-  caret-color: var(--text-primary);
+.file-viewer-format-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
 }
 
-.file-viewer-highlight {
-  position: absolute;
-  /* Sized to its own content (not inset to the box) and translated to follow the
-     textarea's scroll; the parent (.file-viewer-code-area, overflow:hidden) clips
-     it. A transform isn't clamped to a scroll range, so it tracks the textarea
-     past where the overlay could scroll itself — see syncScroll. */
-  top: 0;
-  left: 0;
-  min-width: 100%;
-  margin: 0;
-  padding: 10px 12px;
-  box-sizing: border-box;
-  will-change: transform;
-  pointer-events: none;
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: var(--code-font-size, 12px);
-  line-height: var(--code-line-height, 18px);
-  white-space: pre;
-  tab-size: 4;
+.file-viewer-format-btn:not(:disabled):hover {
   color: var(--text-primary);
-  /* Match the textarea's fixed glyph advance so the coloured text stays exactly
-     under the editable text and the caret never drifts (see .file-viewer-editor). */
-  font-variant-ligatures: none;
-  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
-  font-kerning: none;
-  text-rendering: geometricPrecision;
+  border-color: var(--text-muted);
 }
 
-/* Syntax token colours. These reference the existing per-theme semantic
-   variables, so highlighting adapts to every theme automatically with no
-   per-theme additions. */
-.tok-comment { color: var(--text-muted); font-style: italic; }
-.tok-string { color: var(--success); }
-.tok-keyword { color: var(--accent-secondary); }
-.tok-num { color: var(--warning); }
-.tok-type { color: var(--accent-hover); }
-.tok-func { color: var(--accent); }
-.tok-tag { color: var(--accent); }
-.tok-attr { color: var(--accent-secondary); }
-.tok-prop { color: var(--accent); }
-
-/* #49 link-decoration + #45 ghost overlays: transparent <pre> layers aligned to
-   the textarea exactly like .file-viewer-highlight, so only their styled spans
-   paint. They sit ABOVE the highlight layer but below the textarea caret. */
-.file-viewer-link-layer,
-.file-viewer-search-layer,
-.file-viewer-change-layer,
-.file-viewer-ghost {
-  position: absolute;
-  inset: 0;
-  margin: 0;
-  padding: 10px 12px;
-  box-sizing: border-box;
-  overflow: hidden;
-  pointer-events: none;
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: var(--code-font-size, 12px);
-  line-height: var(--code-line-height, 18px);
-  white-space: pre;
-  tab-size: 4;
-  color: transparent;
-  /* Same fixed glyph advance as the textarea/highlight layer (see above). */
-  font-variant-ligatures: none;
-  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
-  font-kerning: none;
-  text-rendering: geometricPrecision;
+/* Sync-merge "Take all local / remote" buttons take the same colors as the
+   file view's local (green) / remote (amber) locality tags, so the button
+   that pulls a side reads as that side at a glance. */
+.file-viewer-compare-take-all.local {
+  color: var(--success);
+  border-color: color-mix(in srgb, var(--success) 45%, transparent);
 }
-
-/* The link layer is scroll-synced with a transform like .file-viewer-highlight,
-   so it is sized to its own content and clipped by the parent (not inset to the
-   box). The ghost layer keeps the inset/overflow model above. */
-.file-viewer-link-layer,
-.file-viewer-search-layer,
-.file-viewer-change-layer {
-  inset: auto;
-  top: 0;
-  left: 0;
-  min-width: 100%;
-  overflow: visible;
-  will-change: transform;
+.file-viewer-compare-take-all.local:not(:disabled):hover {
+  color: var(--success);
+  border-color: var(--success);
 }
-
-/* #67 in-editor search: the match spans paint a translucent highlight behind the
-   editable text (the layer sits below the textarea), the current match brighter —
-   like a find highlight. Fixed rgba so it reads on both light and dark themes. */
-.file-viewer-search-layer .file-viewer-search-match {
-  border-radius: 2px;
-  background: rgba(255, 213, 0, 0.32);
+.file-viewer-compare-take-all.remote {
+  color: var(--warning);
+  border-color: color-mix(in srgb, var(--warning) 45%, transparent);
 }
-.file-viewer-search-layer .file-viewer-search-match.current {
-  background: rgba(255, 145, 0, 0.6);
+.file-viewer-compare-take-all.remote:not(:disabled):hover {
+  color: var(--warning);
+  border-color: var(--warning);
 }
 
-/* Last-change marker: tint the most recently inserted/edited run so the latest
-   edit stands out. Sits below the textarea like the other overlays, so the tint
-   paints behind the editable glyphs. A green "changed" tint, distinct from the
-   yellow/orange search highlight; fixed rgba so it reads on both light and dark
-   themes (color-mix/theme vars are unreliable on WebKitGTK here). */
-.file-viewer-change-layer .file-viewer-change-mark {
-  border-radius: 2px;
-  background: rgba(63, 185, 80, 0.28);
+/* #py Run/Debug: the wrapper anchors the right-click "arguments" popover. */
+.file-viewer-run-controls {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
 }
-
-/* #49: recognised file links read as clickable — a dotted underline in the link
-   accent colour. Applies in both the code editor overlay and rendered markdown. */
-.file-viewer-link-layer .file-link,
-.markdown-body a.file-link {
-  text-decoration: underline dotted;
-  text-underline-offset: 2px;
-  text-decoration-color: var(--accent, #4493f8);
+/* Right-click-Run "arguments" popover — canonical panel chrome (see the menu
+   layout convention): explicit colours so a portal-free child never inherits
+   the body's default black text. */
+.file-viewer-run-args {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  z-index: 40;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  min-width: 220px;
+  padding: 8px;
+  background: var(--bg-elevated);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  box-shadow: var(--shadow-2);
 }
-.markdown-body a.file-link {
-  color: var(--accent, #4493f8);
+.file-viewer-run-args-label {
+  font-size: 10px;
+  color: var(--text-muted);
 }
-
-/* #49: hover hint advertising the open shortcut (e.g. "Ctrl+Click to open") for a
-   recognised file link, in both the LaTeX source editor and the markdown preview.
-   Anchored (position:fixed) just above the link's top-left; never blocks a click. */
-.link-open-hint {
-  position: fixed;
-  z-index: 60;
-  transform: translateY(-100%);
-  margin-top: -6px;
-  padding: 2px 7px;
-  border-radius: 5px;
-  background: var(--bg-main, #1f2430);
+.file-viewer-run-args-input {
+  background: var(--bg-input, var(--bg-panel));
   color: var(--text-primary);
   border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 3px 6px;
+  font-family: var(--font-mono, monospace);
   font-size: 11px;
-  line-height: 1.4;
-  white-space: nowrap;
-  pointer-events: none;
-  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.35);
 }
-
-/* #67 in-editor find bar: a small floating toolbar pinned to the editor's
-   top-right (anchored to .file-viewer-code, position:relative). */
-.file-viewer-find {
-  position: absolute;
-  top: 6px;
-  right: 14px;
-  z-index: 5;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-  padding: 4px 6px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.35);
+.file-viewer-run-args-input:focus {
+  outline: none;
+  border-color: var(--accent, #4493f8);
 }
-.file-viewer-find-row {
+.file-viewer-run-args-row {
   display: flex;
-  align-items: center;
   gap: 4px;
 }
-/* Chevron that toggles the replace row; sized to align with the inputs. */
-.file-viewer-find-toggle {
-  background: transparent;
-  color: var(--text-muted);
-  border: 1px solid transparent;
-  border-radius: 3px;
-  padding: 1px 4px;
-  font-size: 11px;
-  line-height: 1.2;
-  cursor: pointer;
+/* SLURM directive / interactive-resource form: a two-column grid of labeled
+   fields inside the run-args popover (HPC #SBATCH editor + srun resources). */
+.slurm-directive-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 5px 8px;
 }
-.file-viewer-find-toggle:hover,
-.file-viewer-find-toggle.active { color: var(--text-primary); }
-/* The replace row lines up under the find input: a leading spacer the width of
-   the chevron keeps both inputs left-aligned. */
-.file-viewer-replace-row { padding-left: 26px; }
-.file-viewer-replace-btn { white-space: nowrap; }
-.file-viewer-find-input {
-  background: var(--bg-base, var(--bg-main, var(--bg-panel)));
-  color: var(--text-primary);
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 2px 6px;
-  font-size: 12px;
-  width: 150px;
+.slurm-directive-field {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 0;
 }
-.file-viewer-find-count {
-  min-width: 42px;
-  text-align: center;
-  font-size: 11px;
+.slurm-directive-key {
+  font-size: 10px;
   color: var(--text-muted);
-  font-variant-numeric: tabular-nums;
 }
-.file-viewer-find-btn {
-  background: transparent;
+/* Header row for the Jobs (SLURM) view — just carries the untested tag. */
+.right-panel-jobs-head {
+  display: flex;
+  justify-content: flex-end;
+  padding: 4px 6px 0;
+}
+
+/* HPC pipeline wizard (Phase B). Reuses the project-dialog chrome; these add the
+   step breadcrumb, the footer action row and the uploaded-files list. */
+.hpc-wizard-trail {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 10px;
+  margin-bottom: 10px;
+  font-size: 11px;
   color: var(--text-muted);
-  border: 1px solid transparent;
-  border-radius: 3px;
-  padding: 1px 6px;
-  font-size: 12px;
-  line-height: 1.2;
-  cursor: pointer;
 }
-.file-viewer-find-btn:hover:not(:disabled) {
+.hpc-wizard-trail-step.active {
   color: var(--text-primary);
-  border-color: var(--border-color);
+  font-weight: 600;
 }
-.file-viewer-find-btn:disabled { opacity: 0.4; cursor: default; }
-.file-viewer-find-btn.active {
+.hpc-wizard-trail-step.done {
   color: var(--accent, #4493f8);
-  border-color: var(--accent, #4493f8);
 }
-
-/* \ref/\cite key completion dropdown (LaTeX viewer). Fixed-positioned at the
-   caret so it isn't clipped by the editor's scroll; a scrollable list of keys
-   with an optional second column (the bib entry's author/year/title). */
-.file-viewer-tex-compl {
-  position: fixed;
-  z-index: 20;
-  margin: 0;
-  padding: 3px;
+.hpc-wizard .project-dialog-actions {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+  margin-top: 14px;
+}
+.hpc-wizard-uploaded {
+  margin: 6px 0 0;
+  padding-left: 4px;
   list-style: none;
-  min-width: 160px;
-  max-width: 460px;
-  max-height: 260px;
-  overflow-y: auto;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.4);
-  font-size: 12px;
+  font-size: 11px;
+  color: var(--text-muted);
 }
-.file-viewer-tex-compl-item {
+.hpc-wizard-uploaded li {
+  padding: 1px 0;
+}
+/* Workspace step (Phase C): the allocate form, the existing-workspace picker and
+   the project-layout choice. A workspace is DELETED at expiry, so its remaining
+   time is toned rather than being one more grey line. */
+.hpc-ws-form {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 5px 8px;
+  margin: 4px 0;
+}
+.hpc-ws-list,
+.hpc-ws-layout {
   display: flex;
-  align-items: baseline;
-  gap: 8px;
-  padding: 3px 8px;
-  border-radius: 4px;
-  cursor: pointer;
-  white-space: nowrap;
+  flex-direction: column;
+  gap: 3px;
+  margin: 8px 0 4px;
 }
-.file-viewer-tex-compl-item.active {
-  background: var(--accent);
-  color: #fff;
+.hpc-ws-row {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  font-size: 11px;
+  min-width: 0;
 }
-.file-viewer-tex-compl-key {
-  font-family: var(--font-mono, monospace);
-  color: var(--text-primary);
+.hpc-ws-id {
+  font-weight: 600;
 }
-.file-viewer-tex-compl-item.active .file-viewer-tex-compl-key { color: #fff; }
-.file-viewer-tex-compl-detail {
-  flex: 1 1 auto;
+.hpc-ws-path {
+  color: var(--text-muted);
   overflow: hidden;
   text-overflow: ellipsis;
-  color: var(--text-muted);
-  font-size: 11px;
+  white-space: nowrap;
+  min-width: 0;
+  flex: 1;
 }
-.file-viewer-tex-compl-item.active .file-viewer-tex-compl-detail {
-  color: rgba(255, 255, 255, 0.85);
+.hpc-ws-remaining {
+  white-space: nowrap;
 }
-
-/* Soft-wrap mode (LaTeX viewer): wrap long lines to the editor width instead of
-   scrolling horizontally. The textarea (wrap="soft") and all overlay <pre> layers
-   must wrap identically — same width, same break rules — so the caret, coloured
-   glyphs and link spans stay aligned. overflow-wrap:anywhere breaks tokens with no
-   break point (long URLs/paths) at the edge rather than overflowing. With no
-   horizontal scroll, the editor's overflow-x is hidden. */
-.file-viewer-code-area.is-wrapped .file-viewer-code-editor,
-.file-viewer-code-area.is-wrapped .file-viewer-highlight,
-.file-viewer-code-area.is-wrapped .file-viewer-link-layer,
-.file-viewer-code-area.is-wrapped .file-viewer-search-layer,
-.file-viewer-code-area.is-wrapped .file-viewer-change-layer,
-.file-viewer-code-area.is-wrapped .file-viewer-ghost {
-  white-space: pre-wrap;
-  overflow-wrap: anywhere;
-  word-break: normal;
+.hpc-ws-remaining.tone-ok {
+  color: var(--text-muted);
 }
-/* The overlay layers are pinned to the textarea's content width (excluding its
-   vertical scrollbar) via an inline width, so they wrap line-for-line with the
-   caret. Drop the defaults that would otherwise force them back to the full box
-   width (min-width:100% on the highlight, right:0 from inset on the others). */
-.file-viewer-code-area.is-wrapped .file-viewer-highlight,
-.file-viewer-code-area.is-wrapped .file-viewer-link-layer,
-.file-viewer-code-area.is-wrapped .file-viewer-search-layer,
-.file-viewer-code-area.is-wrapped .file-viewer-change-layer,
-.file-viewer-code-area.is-wrapped .file-viewer-ghost {
-  min-width: 0;
-  right: auto;
+.hpc-ws-remaining.tone-warn {
+  color: var(--warning, #d29922);
 }
-.file-viewer-code-area.is-wrapped .file-viewer-code-editor {
-  overflow-x: hidden;
+.hpc-ws-remaining.tone-urgent {
+  color: var(--danger, #f85149);
+  font-weight: 600;
 }
-
-/* #45 ghost text: the accepted-on-Tab autocomplete suggestion, dimmed inline. */
-.file-viewer-ghost-hidden { color: transparent; }
-.file-viewer-ghost-text {
-  color: var(--text-muted);
-  opacity: 0.8;
+/* Hover hint showing the saved run arguments. The native `title` tooltip is
+   unreliable under WebKitGTK, so this is an explicit in-DOM popover — same panel
+   chrome as the args editor, but read-only and pointer-transparent so it never
+   blocks the click beneath it. */
+.file-viewer-run-argshint {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  z-index: 40;
+  max-width: 360px;
+  padding: 5px 8px;
+  background: var(--bg-elevated);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  box-shadow: var(--shadow-2);
+  font-size: 10px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  pointer-events: none;
 }
-
-/* #47 save-state icon button: square-ish, icon-only. */
-.file-viewer-save .file-viewer-save-icon.dirty { color: var(--warning, #d29922); }
-.file-viewer-save .file-viewer-save-icon.clean { color: var(--success, #3fb950); }
-.file-viewer-save-spinner,
-.file-viewer-tex-spinner {
-  display: inline-block;
-  width: 11px;
-  height: 11px;
-  border: 2px solid var(--border-color);
-  border-top-color: var(--accent, #4493f8);
-  border-radius: 50%;
-  animation: file-viewer-spin 0.7s linear infinite;
+.file-viewer-run-argshint-label {
+  color: var(--text-muted);
+  margin-right: 4px;
 }
-@keyframes file-viewer-spin {
-  to { transform: rotate(360deg); }
+.file-viewer-run-argshint-val {
+  font-family: var(--font-mono, monospace);
 }
 
-/* #46 undo/redo toolbar. */
-.file-viewer-history {
+/* #45 in-tab AI-assist controls: Autocomplete on/off + length mode, Grammar
+   on/off. Same chrome as the save/format buttons; the "active" (enabled) state is
+   accent-filled so it's obvious at a glance whether each is on for this tab. */
+.file-viewer-ai-controls {
   display: inline-flex;
-  gap: 2px;
+  align-items: center;
+  gap: 4px;
 }
-.file-viewer-history-btn {
+.file-viewer-ai-btn {
   background: transparent;
   color: var(--text-muted);
   border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 1px 6px;
-  font-size: 11px;
-  line-height: 1;
+  border-radius: var(--radius-sm);
+  padding: 1px 8px;
+  font-size: 10px;
   cursor: pointer;
 }
-.file-viewer-history-btn:disabled { opacity: 0.45; cursor: default; }
-.file-viewer-history-btn:not(:disabled):hover {
+.file-viewer-ai-btn:hover {
   color: var(--text-primary);
   border-color: var(--text-muted);
 }
-
-/* #43 external-change reconcile banner (non-destructive). */
-.file-viewer-reload-banner {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 4px 10px;
-  font-size: 11px;
-  background: color-mix(in srgb, var(--warning, #d29922) 18%, var(--bg-panel));
-  color: var(--text-primary);
-  border-bottom: 1px solid var(--border-color);
+.file-viewer-ai-btn.active {
+  background: var(--accent, #4493f8);
+  border-color: var(--accent, #4493f8);
+  color: var(--accent-contrast);
 }
-.file-viewer-reload-btn {
-  background: transparent;
-  color: var(--accent, #4493f8);
+.file-viewer-ai-mode {
+  background: var(--bg-panel);
+  color: var(--text-primary);
   border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 1px 8px;
-  font-size: 11px;
+  border-radius: var(--radius-sm);
+  padding: 1px 4px;
+  font-size: 10px;
   cursor: pointer;
 }
-.file-viewer-reload-btn:hover { border-color: var(--accent, #4493f8); }
 
-/* #54 TeX compiler-options panel + actions. */
-.file-viewer-tex-options {
-  display: flex;
-  flex-wrap: wrap;
+/* Markdown formatting toolbar (bold/italic/heading/link/list/TOC). */
+.file-viewer-md-toolbar {
+  display: inline-flex;
   align-items: center;
-  gap: 10px;
-  padding: 6px 10px;
-  border-bottom: 1px solid var(--border-color);
-  background: var(--bg-panel);
-  font-size: 11px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
 }
-.file-viewer-tex-option {
+
+.file-viewer-md-btn {
   display: inline-flex;
   align-items: center;
-  gap: 6px;
+  justify-content: center;
+  min-width: 22px;
+  height: 18px;
+  padding: 0 5px;
+  background: transparent;
   color: var(--text-muted);
+  border: 0;
+  font-size: 11px;
+  line-height: 1;
+  cursor: pointer;
 }
-.file-viewer-tex-option input {
-  background: var(--bg-base, var(--bg-panel));
+
+.file-viewer-md-btn + .file-viewer-md-btn {
+  border-left: 1px solid var(--border-color);
+}
+
+.file-viewer-md-btn:hover {
   color: var(--text-primary);
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 2px 6px;
-  font-size: 11px;
-  min-width: 160px;
+  background: var(--bg-hover, rgba(127, 127, 127, 0.15));
 }
-.file-viewer-tex-options-note {
-  flex-basis: 100%;
-  margin: 0;
+
+/* Transient status line under the header (format errors / "no formatter"). */
+.file-viewer-status-line {
+  flex-shrink: 0;
+  padding: 3px 10px;
+  font-size: 11px;
   color: var(--text-muted);
-  font-size: 10px;
-}
-.file-viewer-tex-options-toggle,
-.file-viewer-tex-open-pdf {
-  background: transparent;
-  color: var(--text-muted);
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 1px 8px;
-  font-size: 10px;
-  cursor: pointer;
-}
-.file-viewer-tex-options-toggle.active,
-.file-viewer-tex-options-toggle:hover,
-.file-viewer-tex-open-pdf:hover {
-  color: var(--text-primary);
-  border-color: var(--text-muted);
+  background: var(--bg-panel);
+  border-bottom: 1px solid var(--border-color);
+  white-space: pre-wrap;
 }
 
-/* #48 per-type native-viewer settings section. */
-.viewer-prefs-list {
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-}
-.viewer-pref-row {
+/* Inline JSON/YAML parse-error banner. */
+.file-viewer-validation {
   display: flex;
   align-items: center;
-  gap: 10px;
+  gap: 8px;
+  flex-shrink: 0;
+  padding: 3px 10px;
   font-size: 11px;
+  color: var(--text-primary);
+  /* Plain translucent red over the panel — color-mix is unreliable on this
+     WebKitGTK build (see .split-preview), so tint with a flat rgba instead. */
+  background: rgba(229, 83, 75, 0.16);
+  border-bottom: 1px solid rgba(229, 83, 75, 0.5);
 }
-.viewer-pref-name { min-width: 96px; color: var(--text-primary); }
-.viewer-pref-exts { color: var(--text-muted); font-size: 10px; flex: 1; }
-.viewer-pref-toggle {
-  display: inline-flex;
-  align-items: center;
-  gap: 4px;
-  color: var(--text-muted);
+
+.file-viewer-validation-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: #e5534b;
+  flex-shrink: 0;
 }
 
-/* pdf.js viewer: a zoom toolbar above a scrolling stack of page canvases. The
-   host and scroll surround use theme variables, so the viewer is dark in dark
-   themes; the page canvases stay white sheets (rendered as authored). The scroll
-   area's scrollbar is themed by the global *::-webkit-scrollbar rules. */
-.file-viewer-pdf-host {
-  display: flex;
-  flex-direction: column;
-  width: 100%;
-  height: 100%;
-  min-height: 0;
+.file-viewer-validation-msg {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
-.file-viewer-pdf-toolbar {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  padding: 3px 8px;
-  border-bottom: 1px solid var(--border-color);
-  background: var(--bg-panel);
+.file-viewer-validation-jump {
   flex-shrink: 0;
+  background: transparent;
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 0 6px;
+  font-size: 10px;
+  cursor: pointer;
 }
 
-/* Push the optional "Open externally" button to the toolbar's trailing edge. */
-.file-viewer-pdf-external {
-  margin-left: auto;
+.file-viewer-validation-jump:hover {
+  border-color: var(--text-muted);
 }
 
-.file-viewer-pdf-scroll {
-  flex: 1;
-  min-height: 0;
-  overflow: auto;
-  padding: 12px;
-  background: var(--bg-main);
+.file-viewer-editor {
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  resize: none;
+  border: 0;
+  outline: none;
+  padding: 10px 12px;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 12px;
+  line-height: 1.5;
+  tab-size: 2;
+  /* Disable ligatures/kerning: the highlight overlay below splits the text into
+     many <span> tokens, which breaks ligature shaping at span boundaries. If the
+     textarea (plain text) still formed ligatures, its glyph advances would
+     diverge from the overlay's, so the caret drifts further from the coloured
+     text toward the end of each line. A fixed per-glyph advance keeps them 1:1. */
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
+  font-kerning: none;
+  /* Force sub-pixel glyph advances. WebKitGTK otherwise rounds the textarea's
+     per-glyph advance to a whole pixel when placing the caret, while the <pre>
+     overlay lays glyphs out with sub-pixel precision. That fractional per-char
+     difference is invisible at a line's start but accumulates into a visible
+     caret/text drift toward the end of long lines. Pinning both layers to
+     geometricPrecision makes their advances identical so they stay aligned. */
+  text-rendering: geometricPrecision;
 }
 
-/* The page stack lives in an inner wrapper so a Ctrl+wheel zoom can grow it past
-   the viewport and scroll horizontally. min-width:min-content lets the wrapper
-   expand to the widest page (enabling horizontal scroll when zoomed in) while
-   align-items:center keeps narrower pages centred. */
-.file-viewer-pdf-pages {
-  display: flex;
-  flex-direction: column;
+/* Zoom controls in the image viewer header. */
+.file-viewer-zoom {
+  display: inline-flex;
   align-items: center;
-  gap: 12px;
-  min-width: min-content;
+  gap: 2px;
 }
 
-.file-viewer-pdf-page {
-  display: block;
-  max-width: 100%;
-  background: #fff;
-  box-shadow: 0 1px 8px rgba(0, 0, 0, 0.4);
+.file-viewer-zoom-btn {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  min-width: 20px;
+  height: 18px;
+  padding: 0 5px;
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
 }
 
-/* LaTeX viewer: a compile toolbar above a source-editor | PDF-preview split.
-   With no TeX engine on PATH the viewer renders just the plain code editor (the
-   compile controls/split below are never mounted), so it degrades to the text
-   viewer. The compile controls live in the shared header row (ViewerHeader),
-   not on a separate toolbar line. */
-.file-viewer-tex-compile {
-  background: var(--accent, #4493f8);
-  color: #fff;
-  border: 0;
-  border-radius: 3px;
-  padding: 2px 10px;
-  font-size: 11px;
-  cursor: pointer;
+.file-viewer-zoom-btn.file-viewer-zoom-text {
+  font-size: 10px;
 }
 
-.file-viewer-tex-compile:disabled {
-  opacity: 0.6;
+.file-viewer-zoom-btn:disabled {
+  opacity: 0.5;
   cursor: default;
 }
 
-/* Inherits the shared Dropdown look; only the toolbar's compact sizing differs. */
-.file-viewer-tex-engine .dropdown-trigger {
-  min-height: 0;
-  padding: 1px 6px;
-  font-size: 11px;
+.file-viewer-zoom-btn:not(:disabled):hover {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
 }
 
-.file-viewer-tex-spinner {
-  width: 12px;
-  height: 12px;
-  border: 2px solid var(--border-color);
-  border-top-color: var(--accent, #4493f8);
-  border-radius: 50%;
-  animation: file-viewer-tex-spin 0.7s linear infinite;
+.file-viewer-zoom-level {
+  min-width: 38px;
+  text-align: center;
+  font-size: 10px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
 }
 
-@keyframes file-viewer-tex-spin {
-  to { transform: rotate(360deg); }
+/* PDF toolbar "current page / total" readout — also the go-to-page trigger
+   (click, or Ctrl+G). */
+.file-viewer-pdf-pagenum {
+  text-align: center;
+  font-size: 10px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+  padding: 0 4px;
 }
 
-/* Compile run animation: while a build is in flight the button shows an
-   indeterminate sliding sheen and a thin progress strip animates under the
-   header, so a multi-second parent build reads as live. Both derive purely from
-   the `compiling` flag (the `.is-compiling` class / mounted strip). */
-.file-viewer-tex-compile.is-compiling {
-  background-image: linear-gradient(
-    100deg,
-    transparent 20%,
-    rgba(255, 255, 255, 0.35) 50%,
-    transparent 80%
-  );
-  background-size: 200% 100%;
-  background-repeat: no-repeat;
-  animation: file-viewer-tex-sheen 1.1s linear infinite;
+/* Inline "go to page" input, swapped in for the readout above while active. */
+.file-viewer-pdf-pagejump-input {
+  background: var(--bg-base, var(--bg-main, var(--bg-panel)));
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  height: 18px;
+  width: 42px;
+  padding: 0 4px;
+  font-size: 10px;
+  font-variant-numeric: tabular-nums;
+  text-align: center;
 }
 
-@keyframes file-viewer-tex-sheen {
-  from { background-position: 200% 0; }
-  to { background-position: -200% 0; }
+/* Text-size control: the numeric level doubles as a "reset to default" button. */
+.file-viewer-fontsize-level {
+  min-width: 22px;
+  background: transparent;
+  border: 0;
+  padding: 0 2px;
+  cursor: pointer;
 }
 
-.file-viewer-tex-progress {
-  flex-shrink: 0;
-  height: 2px;
-  overflow: hidden;
-  background: color-mix(in srgb, var(--accent, #4493f8) 22%, transparent);
+.file-viewer-fontsize-level:hover {
+  color: var(--text-primary);
 }
 
-.file-viewer-tex-progress-bar {
-  height: 100%;
-  width: 40%;
-  background: var(--accent, #4493f8);
-  animation: file-viewer-tex-progress-slide 1.1s ease-in-out infinite;
+/* Image viewer: a clipped viewport over a checkerboard so transparency shows.
+   The <img> inside is positioned by a JS-driven transform (zoom/pan). */
+.file-viewer-image-body {
+  overflow: hidden;
 }
 
-@keyframes file-viewer-tex-progress-slide {
-  from { transform: translateX(-100%); }
-  to { transform: translateX(350%); }
+.file-viewer-image-viewport {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  cursor: grab;
+  touch-action: none;
+  background-color: var(--bg-panel);
+  background-image:
+    linear-gradient(45deg, rgba(127, 127, 127, 0.12) 25%, transparent 25%),
+    linear-gradient(-45deg, rgba(127, 127, 127, 0.12) 25%, transparent 25%),
+    linear-gradient(45deg, transparent 75%, rgba(127, 127, 127, 0.12) 75%),
+    linear-gradient(-45deg, transparent 75%, rgba(127, 127, 127, 0.12) 75%);
+  background-size: 20px 20px;
+  background-position: 0 0, 0 10px, 10px -10px, -10px 0;
 }
 
-/* SyncTeX (#56): each PDF page sits in a positioned wrapper so a forward-search
-   highlight box can overlay it; a syncable page shows a crosshair to hint that a
-   click jumps to the source. */
-.file-viewer-pdf-page-wrap {
-  position: relative;
-  line-height: 0;
-  max-width: 100%;
+.file-viewer-image-viewport.dragging {
+  cursor: grabbing;
 }
 
-.file-viewer-pdf-page.is-syncable {
-  cursor: crosshair;
-}
-
-.file-viewer-pdf-sync-highlight {
+.file-viewer-image {
   position: absolute;
-  pointer-events: none;
-  background: color-mix(in srgb, var(--accent, #4493f8) 38%, transparent);
-  border: 1px solid var(--accent, #4493f8);
-  border-radius: 2px;
-  animation: file-viewer-pdf-sync-fade 1.6s ease-out forwards;
+  top: 0;
+  left: 0;
+  max-width: none;
+  max-height: none;
+  user-select: none;
+  -webkit-user-drag: none;
+  will-change: transform;
 }
 
-@keyframes file-viewer-pdf-sync-fade {
-  0% { opacity: 0; }
-  15% { opacity: 1; }
-  100% { opacity: 0; }
+/* GIF viewer transport (#gifviewer). The frame scrubber rides inside the shared
+   .file-viewer-zoom pill; the speed dropdown inherits the shared Dropdown look
+   with only the toolbar's compact sizing (same bargain as the TeX engine
+   selector). */
+.gif-transport .gif-scrubber {
+  width: 110px;
+  accent-color: var(--accent, #4493f8);
 }
 
-/* Reverse-search click feedback (#56): a small ring centred on the point the
-   reader Ctrl/⌘-clicked in the PDF, pulsing then fading over ~2s, so the
-   source-jump is visibly anchored on the PDF side too. Margin centres the 16px
-   marker on its (left,top) click coordinate. */
-.file-viewer-pdf-click-mark {
-  position: absolute;
-  pointer-events: none;
-  width: 16px;
-  height: 16px;
-  margin: -8px 0 0 -8px;
-  border-radius: 50%;
-  background: color-mix(in srgb, var(--accent, #4493f8) 40%, transparent);
-  border: 1.5px solid var(--accent, #4493f8);
-  animation: file-viewer-pdf-click-fade 2s ease-out forwards;
+.gif-transport .gif-scrubber:disabled {
+  opacity: 0.5;
 }
 
-@keyframes file-viewer-pdf-click-fade {
-  0% { opacity: 0; transform: scale(0.4); }
-  12% { opacity: 1; transform: scale(1); }
-  100% { opacity: 0; transform: scale(1.7); }
+.gif-speed .dropdown-trigger {
+  min-height: 0;
+  padding: 1px 6px;
+  font-size: 11px;
 }
 
-@media (prefers-reduced-motion: reduce) {
-  .file-viewer-tex-compile.is-compiling {
-    animation: none;
-    background-image: none;
-  }
-  .file-viewer-tex-progress-bar {
-    width: 100%;
-    animation: none;
-    opacity: 0.7;
-  }
-  /* Hold a static highlight briefly rather than animating its opacity. */
-  .file-viewer-pdf-sync-highlight {
-    animation: none;
-    opacity: 1;
-  }
-  .file-viewer-pdf-click-mark {
-    animation: none;
-    opacity: 1;
-  }
+.file-viewer-body {
+  flex: 1;
+  overflow: auto;
+  min-height: 0;
 }
 
-/* Shell-escape warning banner: shown when a compile ran with \write18 active
-   despite our args never enabling it. Amber, distinct from the red error rows. */
-.file-viewer-tex-shell-warning {
-  flex-shrink: 0;
-  padding: 8px 12px;
+.file-viewer-loading,
+.file-viewer-error {
+  padding: 12px;
   font-size: 12px;
-  line-height: 1.4;
-  color: var(--warning, #d29922);
-  background: color-mix(in srgb, var(--warning, #d29922) 12%, transparent);
-  border-bottom: 1px solid var(--warning, #d29922);
+  color: var(--text-muted);
 }
 
-.file-viewer-tex-shell-warning code {
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: 11px;
+.file-viewer-error {
+  color: var(--danger, #f85149);
+  white-space: pre-wrap;
+  word-break: break-word;
 }
 
-/* Transient, low-key info notice: a forward-search (caret → PDF) miss after a
-   successful compile. Muted/informational, distinct from the warning + error
-   styles above so it doesn't read as a failure. */
-.file-viewer-tex-sync-miss {
-  flex-shrink: 0;
-  padding: 6px 12px;
+/* YAML structure tree (#yaml) — the editable half of the YAML viewer. Rows are
+   monospace so keys and values line up like the file does; the action buttons are
+   revealed on hover/focus so a big config reads as data, not as a form. */
+.yaml-tree {
+  padding: 8px 10px 24px;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, monospace);
   font-size: 12px;
-  line-height: 1.4;
-  color: var(--text-muted);
-  background: var(--bg-subtle, rgba(127, 127, 127, 0.08));
+  color: var(--text-primary);
+  /* The per-level indent-guide colors (`rowPad` in YamlTree.tsx draws one
+     vertical line per ancestor level, cycling these by depth). */
+  --yaml-guide-0: color-mix(in srgb, var(--accent, #4493f8) 38%, transparent);
+  --yaml-guide-1: color-mix(in srgb, #a887e8 38%, transparent);
+  --yaml-guide-2: color-mix(in srgb, #4fc1a6 38%, transparent);
+  --yaml-guide-3: color-mix(in srgb, #d9a05b 38%, transparent);
+}
+
+.yaml-doc + .yaml-doc {
+  margin-top: 10px;
+}
+
+.yaml-doc-sep {
+  margin: 6px 0 4px;
+  padding-bottom: 2px;
   border-bottom: 1px solid var(--border-color);
+  color: var(--text-muted);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
 }
 
-/* Build-log error area: a terse last line, plus an expandable full log. */
-.file-viewer-tex-log-error {
-  flex-shrink: 0;
-  max-height: 40%;
-  overflow: auto;
+.yaml-row {
+  /* Anchors the absolute action gutter (`.yaml-gutter`) on the row's left. */
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  min-height: 22px;
+  border-radius: var(--radius-sm);
+  /* The drop line is drawn as a border, so every row reserves the space for one —
+     otherwise the rows below the pointer would jump by a pixel as it is drawn. */
+  border-top: 1px solid transparent;
+  border-bottom: 1px solid transparent;
 }
 
-.file-viewer-tex-log-line {
-  font-weight: 600;
+.yaml-row:hover {
+  background: var(--bg-subtle, rgba(255, 255, 255, 0.03));
 }
 
-.file-viewer-tex-log-toggle {
-  margin-top: 4px;
+/* Reorder-by-drag: the grip appears on hover (it is an affordance, not furniture),
+   but keeps its width at all times so no row shifts when it does. */
+.yaml-grip {
+  flex: none;
+  width: 10px;
   background: transparent;
+  border: 0;
+  padding: 0;
   color: var(--text-muted);
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 1px 6px;
   font-size: 10px;
-  cursor: pointer;
+  line-height: 1;
+  cursor: grab;
+  opacity: 0;
+  touch-action: none;
 }
 
-/* Jump-to-error list under a failed compile. Each row is a button: a
-   monospace `file:line` chip plus the TeX message. */
-.file-viewer-tex-errors {
-  list-style: none;
-  margin: 6px 0 0;
-  padding: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
+.yaml-row:hover .yaml-grip,
+.yaml-grip:focus-visible {
+  opacity: 0.7;
 }
 
-.file-viewer-tex-error-jump {
-  display: flex;
-  align-items: baseline;
-  gap: 8px;
-  width: 100%;
-  text-align: left;
-  background: transparent;
-  border: 1px solid transparent;
-  border-radius: 3px;
-  padding: 2px 6px;
-  cursor: pointer;
-  color: var(--text-primary);
-  font-size: 11px;
+.yaml-grip-empty {
+  cursor: default;
 }
 
-.file-viewer-tex-error-jump:hover {
-  background: var(--bg-input, var(--bg-panel));
-  border-color: var(--border-color);
+.yaml-row-dragging {
+  opacity: 0.45;
+  /* The dragged row keeps the action-hover accent for the whole gesture, so the
+     block being moved stays marked while the pointer travels the list. */
+  background: color-mix(in srgb, var(--accent, #4493f8) 14%, transparent);
 }
 
-.file-viewer-tex-error-loc {
-  flex-shrink: 0;
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-weight: 600;
-  color: var(--accent, var(--text-primary));
+.yaml-row-dragging .yaml-grip {
+  cursor: grabbing;
 }
 
-.file-viewer-tex-error-msg {
-  color: var(--text-muted);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+.yaml-row-drop-before {
+  border-top-color: var(--accent, #4493f8);
 }
 
-.file-viewer-tex-log {
-  margin: 6px 0 0;
-  padding: 8px;
-  background: var(--bg-input, var(--bg-panel));
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: 11px;
-  line-height: 1.45;
-  color: var(--text-primary);
-  white-space: pre-wrap;
-  word-break: break-word;
+.yaml-row-drop-after {
+  border-bottom-color: var(--accent, #4493f8);
 }
 
-/* Rendered markdown. */
-.markdown-body {
-  padding: 16px 22px;
-  font-size: 13px;
-  line-height: 1.65;
-  max-width: 880px;
+/* During a reorder drag, an entry the drop can't land on (it owns its item's
+   dash line, so it can't be displaced from first place) is blended out, so the
+   impossible positions read as unavailable rather than silently ignoring a drop. */
+.yaml-row-blocked {
+  opacity: 0.35;
 }
 
-.markdown-body > :first-child { margin-top: 0; }
-.markdown-body > :last-child { margin-bottom: 0; }
+/* Hovering a container's row marks its whole substructure, not just its own
+   line — what the row names IS the block beneath it. The rows are DOM siblings,
+   so the mark is handed down in React (`yaml-row-marked`), matching the plain
+   hover tint; a hovered delete hands down the danger tint instead, so everything
+   tinted is exactly what the × will take. */
+.yaml-row-marked {
+  background: var(--bg-subtle, rgba(255, 255, 255, 0.03));
+}
 
-.markdown-body h1,
-.markdown-body h2,
-.markdown-body h3,
-.markdown-body h4,
-.markdown-body h5,
-.markdown-body h6 {
-  margin: 1.4em 0 0.55em;
-  line-height: 1.25;
-  font-weight: 650;
-  letter-spacing: -0.01em;
+.yaml-row-marked-del {
+  background: color-mix(in srgb, var(--danger, #f85149) 16%, transparent);
 }
 
-.markdown-body h1 { font-size: 1.8em; border-bottom: 1px solid var(--border-color); padding-bottom: 0.3em; }
-.markdown-body h2 { font-size: 1.45em; border-bottom: 1px solid var(--border-color); padding-bottom: 0.25em; }
-.markdown-body h3 { font-size: 1.2em; }
-.markdown-body h4 { font-size: 1.05em; }
-.markdown-body h5 { font-size: 0.95em; }
-.markdown-body h6 { font-size: 0.9em; color: var(--text-muted); }
+/* …and a hovered whole-entry action (copy, move, comment, grip) hands down the
+   accent tint, matching the row's own :has() highlight below — the entry the
+   button acts on is its block, not its one line. */
+.yaml-row-marked-act {
+  background: color-mix(in srgb, var(--accent, #4493f8) 14%, transparent);
+}
 
-.markdown-body p { margin: 0.65em 0; }
+/* The grip's own mark on top of the accent: the block "pulls out" a few px,
+   the affordance that this handle is what moves it. The hovered row itself
+   shifts via the :has() below; its marked children ride `yaml-row-pulled`. */
+.yaml-row {
+  transition: transform var(--transition);
+}
 
-.markdown-body a { color: var(--accent, #4493f8); text-decoration: none; }
-.markdown-body a:hover { text-decoration: underline; }
+.yaml-row-pulled,
+.yaml-row-dragging,
+.yaml-row:has(> .yaml-actions .yaml-grip:hover) {
+  transform: translateX(3px);
+}
 
-.markdown-body strong { font-weight: 650; }
+/* Hovering a row's action (drag, move up/down, delete, add) highlights that row,
+   so it is obvious which entry the button will act on — delete tinted with
+   danger, the rest with the accent. `:has()` scopes it to the row whose OWN
+   actions are hovered (a child row's actions live in a separate row element). */
+.yaml-row:has(> .yaml-actions .yaml-act:hover),
+.yaml-row:has(> .yaml-actions .yaml-add:hover),
+.yaml-row:has(> .yaml-actions .yaml-grip:hover) {
+  background: color-mix(in srgb, var(--accent, #4493f8) 14%, transparent);
+}
 
-.markdown-body code {
-  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
-  font-size: 0.88em;
-  background: var(--bg-input, rgba(127, 127, 127, 0.15));
-  padding: 0.12em 0.35em;
-  border-radius: 3px;
+.yaml-row:has(> .yaml-actions .yaml-act-del:hover) {
+  background: color-mix(in srgb, var(--danger, #f85149) 16%, transparent);
 }
 
-.markdown-body pre {
-  position: relative;
-  background: var(--bg-input, rgba(127, 127, 127, 0.12));
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  padding: 11px 13px;
-  overflow-x: auto;
-  margin: 0.8em 0;
+/* The persistent add row: hovering either button tints it, so it's clear a new
+   entry will land here. */
+.yaml-row-add:has(.yaml-add:hover) {
+  background: color-mix(in srgb, var(--accent, #4493f8) 12%, transparent);
 }
 
-/* Language label on fenced code blocks (set from the info string). */
-.markdown-body pre.md-code[data-lang]::before {
-  content: attr(data-lang);
-  position: absolute;
+/* "Copy last" — the alternative to building a new item — reads as the accent
+   action it is, next to the plain new-entry builder. */
+.yaml-add-copy {
+  color: var(--accent, #4493f8);
+  border-color: color-mix(in srgb, var(--accent, #4493f8) 55%, transparent);
+}
+
+/* Copy → paste cursor. While an entry sits on the copy buffer the banner says
+   what is held (and is the mouse user's cancel), a row the paste fits after
+   advertises itself with the copy cursor, and the placed cursor row draws the
+   insertion line — the same accent line a reorder drag draws — plus the button
+   that lands the paste. */
+.yaml-clip-banner {
+  /* Pinned to the top of the scroller (`.file-viewer-body`) so it stays put
+     while you scroll a long file to the row you want to paste after — otherwise
+     it slides up among the entries and out of view before you get there. The
+     background must be OPAQUE (mixed over the panel, not transparent) so the
+     rows scrolling under it don't read through. */
+  position: sticky;
   top: 0;
-  right: 0;
-  padding: 1px 7px;
-  font-size: 0.68em;
-  font-family: var(--font-mono, ui-monospace, monospace);
-  letter-spacing: 0.04em;
-  text-transform: uppercase;
-  color: var(--text-muted);
-  background: var(--bg-secondary, rgba(127, 127, 127, 0.18));
-  border-left: 1px solid var(--border-color);
-  border-bottom: 1px solid var(--border-color);
-  border-bottom-left-radius: 5px;
-  border-top-right-radius: 5px;
-  pointer-events: none;
+  z-index: 3;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 0 0 6px;
+  padding: 3px 8px;
+  border: 1px solid color-mix(in srgb, var(--accent, #4493f8) 45%, transparent);
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--accent, #4493f8) 12%, var(--bg-panel));
+  font-size: 11px;
 }
 
-.markdown-body pre code {
-  background: none;
-  padding: 0;
-  font-size: 0.85em;
-  line-height: 1.5;
+.yaml-clip-banner .yaml-act {
+  margin-left: auto;
 }
 
-.markdown-body blockquote {
-  margin: 0.8em 0;
-  padding: 0.1em 0.95em;
-  border-left: 3px solid var(--accent, var(--border-color));
-  color: var(--text-muted);
+.yaml-row-pastable {
+  cursor: copy;
 }
 
-.markdown-body blockquote > :first-child { margin-top: 0; }
-.markdown-body blockquote > :last-child { margin-bottom: 0; }
-
-.markdown-body ul,
-.markdown-body ol { margin: 0.55em 0; padding-left: 1.6em; }
-.markdown-body li { margin: 0.22em 0; }
-.markdown-body li > ul,
-.markdown-body li > ol { margin: 0.22em 0; }
+/* The hover PREVIEW of where a click would land the paste: a zero-height row
+   drawing the same accent line the placed cursor row does, right after the
+   hovered entry's whole block — the outcome is visible before the click, and
+   nothing below it shifts. */
+.yaml-paste-preview {
+  min-height: 0;
+  height: 0;
+  border: 0;
+  overflow: visible;
+}
 
-/* GitHub-style task list items. */
-.markdown-body li.task-item {
-  list-style: none;
-  margin-left: -1.35em;
-  display: flex;
-  align-items: flex-start;
-  gap: 0.5em;
+.yaml-paste-preview-line {
+  flex: 1;
+  height: 0;
+  border-top: 2px solid color-mix(in srgb, var(--accent, #4493f8) 65%, transparent);
+  margin-top: -1px;
+  pointer-events: none;
 }
-.markdown-body li.task-item > input[type="checkbox"] {
-  margin: 0.32em 0 0;
-  accent-color: var(--accent);
-  flex: 0 0 auto;
+
+.yaml-cursor-row {
+  gap: 4px;
+  padding: 2px 0;
+  border-top-color: var(--accent, #4493f8);
 }
 
-.markdown-body hr {
+.yaml-paste-here {
+  color: var(--accent, #4493f8);
+  border-color: color-mix(in srgb, var(--accent, #4493f8) 55%, transparent);
+}
+
+/* The `#` a commented row wears: visible without a hover, because a config file's
+   comments are the half of it worth reading. The comment itself is on the tooltip
+   (and on the key's), so the row stays the width of its data. */
+.yaml-note {
+  flex: none;
+  background: transparent;
   border: 0;
-  border-top: 1px solid var(--border-color);
-  margin: 1.4em 0;
+  padding: 0 2px;
+  color: var(--text-muted);
+  font: inherit;
+  opacity: 0.7;
+  cursor: pointer;
 }
 
-.markdown-body img {
-  max-width: 100%;
-  border-radius: 4px;
+.yaml-note:hover {
+  color: var(--accent, #4493f8);
+  opacity: 1;
 }
 
-/* Tables: rounded frame, header tint, zebra striping. */
-.markdown-body table,
-.markdown-body table.md-table {
-  border-collapse: collapse;
-  margin: 0.9em 0;
-  width: auto;
-  max-width: 100%;
+.yaml-comment-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  max-width: 46ch;
+  background: var(--bg-panel);
+  color: var(--text-muted);
   border: 1px solid var(--border-color);
-  border-radius: 6px;
-  overflow: hidden;
+  border-radius: var(--radius-sm);
+  padding: 0 4px;
+  font: inherit;
+  font-style: italic;
 }
 
-.markdown-body th,
-.markdown-body td {
-  border: 1px solid var(--border-color);
-  padding: 5px 11px;
+.yaml-comment-input:focus {
+  outline: none;
+  border-color: var(--accent, #4493f8);
 }
 
-.markdown-body thead th {
-  background: var(--bg-secondary, rgba(127, 127, 127, 0.16));
-  font-weight: 650;
+.yaml-caret {
+  flex: none;
+  width: 14px;
+  background: transparent;
+  border: 0;
+  padding: 0;
+  color: var(--text-muted);
+  font-size: 10px;
+  line-height: 1;
+  cursor: pointer;
+}
+
+.yaml-caret-empty {
+  cursor: default;
+}
+
+.yaml-key {
+  background: transparent;
+  border: 0;
+  border-radius: var(--radius-sm);
+  padding: 1px 2px;
+  color: var(--accent, #4493f8);
+  font: inherit;
+  cursor: text;
+  /* Sibling keys are padded to one column (see keyWidth in YamlTree), so the
+     key must hug its left edge for the values to land on a shared one. */
   text-align: left;
 }
 
-.markdown-body tbody tr:nth-child(even) {
-  background: var(--bg-input, rgba(127, 127, 127, 0.07));
+.yaml-key:hover {
+  background: color-mix(in srgb, var(--accent, #4493f8) 14%, transparent);
 }
 
-/* GitHub alert callouts (> [!NOTE] / [!TIP] / [!IMPORTANT] / [!WARNING] / [!CAUTION]).
-   Theme-safe: a coloured left rail + tinted title, neutral background, so no
-   color-mix is needed (avoids the WebKitGTK color-mix caveat). */
-.markdown-body .md-alert {
-  margin: 0.9em 0;
-  padding: 0.5em 0.95em;
-  border-left: 4px solid var(--border-color);
-  border-radius: 0 5px 5px 0;
-  background: var(--bg-input, rgba(127, 127, 127, 0.08));
+.yaml-colon {
+  color: var(--text-muted);
 }
-.markdown-body .md-alert > :first-child { margin-top: 0; }
-.markdown-body .md-alert > :last-child { margin-bottom: 0; }
-.markdown-body .md-alert-title {
-  font-weight: 650;
-  margin: 0 0 0.25em;
-  font-size: 0.92em;
+
+.yaml-index {
+  flex: none;
+  min-width: 18px;
+  color: var(--text-muted);
 }
 
-.markdown-body .md-alert-note     { border-left-color: var(--accent); }
-.markdown-body .md-alert-note .md-alert-title { color: var(--accent); }
-.markdown-body .md-alert-tip      { border-left-color: var(--success); }
-.markdown-body .md-alert-tip .md-alert-title { color: var(--success); }
-.markdown-body .md-alert-important { border-left-color: var(--accent-secondary); }
-.markdown-body .md-alert-important .md-alert-title { color: var(--accent-secondary); }
-.markdown-body .md-alert-warning  { border-left-color: var(--warning); }
-.markdown-body .md-alert-warning .md-alert-title { color: var(--warning); }
-.markdown-body .md-alert-caution  { border-left-color: var(--danger); }
-.markdown-body .md-alert-caution .md-alert-title { color: var(--danger); }
+.yaml-count {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  color: var(--text-muted);
+  font-size: 11px;
+}
 
-/* ── Tiling subwindows ───────────────────────────────────────────────────── */
+/* Flow (JSON) style marker on a container: what you are editing stays flow, so
+   the row says so. */
+.yaml-flow-tag {
+  color: var(--accent-secondary);
+  opacity: 0.85;
+  letter-spacing: -0.05em;
+}
 
-/* A split node: a flex container of children with dividers between them. The
-   layout tree (subwindow frames) fills the panel; the pane layer overlays it. */
-.split {
+.yaml-key-input,
+.yaml-value-input {
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 0 4px;
+  font: inherit;
+  min-width: 0;
+}
+
+/* A value reads as a value, not as a form field: the input keeps its box (so
+   focus/hover can restore it without a layout shift) but wears no chrome until
+   pointed at. Click-to-edit stays — it IS the input, just undressed. */
+.yaml-value-input {
+  flex: 1 1 auto;
+  /* No fixed cap: the value fills whatever room the row has to its right, so a
+     long value is never clipped inside a narrow box while the pane sits empty
+     beside it. It still shrinks (min-width: 0 above) when the pane is narrow. */
+  max-width: none;
+  background: transparent;
+  border-color: transparent;
+  cursor: text;
+}
+
+.yaml-value-input:hover:not(:focus) {
+  background: color-mix(in srgb, var(--accent, #4493f8) 10%, transparent);
+}
+
+/* A scalar-only list edited as one comma-separated line: it holds the whole
+   list, so it gets more room than a single value would. The wrap owns the width
+   and hosts the overflow chevrons; hovering one glides the content that way. */
+.yaml-list-wrap {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  flex: 1 1 auto;
+  min-width: 0;
+  /* No fixed cap: the comma-line list fills the room to its right rather than
+     stopping short and hiding entries behind the overflow chevrons while space
+     goes unused. The chevrons still appear if it genuinely overflows. */
+  max-width: none;
+}
+
+/* The input and its color mirror. The entries keep the value colors their own
+   rows would carry — an input cannot color parts of itself, so its text is
+   transparent (the caret is not) and the mirror on top repaints the same buffer
+   token by token, scroll-synced from the component. */
+.yaml-list-field {
+  position: relative;
+  display: inline-flex;
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.yaml-list-field .yaml-list-input {
+  flex: 1 1 auto;
+  min-width: 0;
+  max-width: none;
+  color: transparent;
+  caret-color: var(--text-primary);
+}
+
+.yaml-list-mirror {
   position: absolute;
   inset: 0;
   display: flex;
+  align-items: center;
+  border: 1px solid transparent; /* the input's box, so the glyphs land on its */
+  padding: 0 4px; /* exact pixels */
   overflow: hidden;
+  white-space: pre;
+  pointer-events: none;
 }
 
-.split-child {
-  position: relative;
+.yaml-list-chevron {
+  flex: none;
+  border: 0;
+  background: transparent;
+  color: var(--accent, #4493f8);
+  cursor: pointer;
+  padding: 0 2px;
+  font-size: 13px;
+  line-height: 1;
+}
+
+.yaml-list-chevron:disabled {
+  opacity: 0.25;
+  cursor: default;
+}
+
+.yaml-key-input:focus,
+.yaml-value-input:focus {
+  outline: none;
+  border-color: var(--accent, #4493f8);
+}
+
+/* Editing dresses the value back up as a field. */
+.yaml-value-input:focus {
+  background: var(--bg-panel);
+}
+
+/* Value colouring by YAML type, so a quoted "8080" reads differently from 8080.
+   Reuses the same semantic variables as the syntax tokens, so it adapts to every
+   theme with no per-theme additions (see .tok-* below). */
+.yaml-val-number { color: var(--warning); }
+.yaml-val-boolean { color: var(--accent-secondary); }
+.yaml-val-null { color: var(--text-muted); font-style: italic; }
+/* Strings get the string-token green (as in the syntax highlighter) rather than
+   the plain body colour, so a value reads as a value and doesn't disappear into
+   the surrounding text. */
+.yaml-val-string { color: var(--success); }
+.yaml-val-other { color: var(--success); }
+
+.yaml-value-locked {
+  color: var(--text-muted);
+  font-style: italic;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  max-width: 46ch;
+}
+
+.yaml-block {
+  display: inline-flex;
+  align-items: flex-start;
+  gap: 4px;
+  flex: 1 1 auto;
   min-width: 0;
-  min-height: 0;
-  display: flex;
 }
 
-/* Children of a split need their own relative coordinate space so a nested
-   subwindow/split can fill them via absolute insets. The top-level layout node
-   (a direct child of the center panel) fills the panel the same way — otherwise
-   a single-group subwindow collapses to its tab-bar height and the pane layer
-   overlays the tabs. */
-.split-child > .subwindow,
-.split-child > .split,
-.center-panel > .subwindow,
-.center-panel > .split {
+.yaml-block-tag {
+  color: var(--text-muted);
+}
+
+.yaml-block-input {
+  flex: 1 1 auto;
+  max-width: 60ch;
+  resize: vertical;
+  background: transparent;
+  color: var(--text-primary);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  padding: 2px 4px;
+  font: inherit;
+  cursor: text;
+}
+
+.yaml-block-input:hover:not(:focus) {
+  background: color-mix(in srgb, var(--accent, #4493f8) 10%, transparent);
+}
+
+.yaml-block-input:focus {
+  outline: none;
+  background: var(--bg-panel);
+  border-color: var(--accent, #4493f8);
+}
+
+.yaml-type {
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 0 2px;
+  font: inherit;
+  cursor: pointer;
+}
+
+/* Row actions stay out of the way until the row is hovered — but never hide from
+   the keyboard, so tabbing through the tree reaches every one of them. */
+.yaml-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  opacity: 0;
+}
+
+/* The entry's own actions (# ⧉ ↑ ↓ ×) live in a FIXED gutter on the row's left —
+   one stable button column in front of the tree, whatever the row's depth. Every
+   row reserves its width via `rowPad` (YamlTree's GUTTER const, kept in step with
+   this one), so the buttons overlay reserved space, never the content. */
+.yaml-gutter {
   position: absolute;
-  inset: 0;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 130px;
+  /* The left padding keeps the drag grip off the panel border. */
+  padding: 0 10px 0 8px;
 }
 
-/* Resize divider between two split children. Wide hit area, thin visual line. */
-.split-divider {
-  flex: 0 0 auto;
-  position: relative;
-  z-index: 4;
-  background: var(--control-border);
-  transition: background-color 0.12s;
+/* Six FIXED slots (⠿ # ⧉ ↑ ↓ ×): an action a row doesn't offer is rendered as
+   an empty slot of the same width, so every button keeps its column on every
+   row and the pointer never chases a shifting target. */
+.yaml-gutter .yaml-act,
+.yaml-gutter .yaml-slot {
+  flex: none;
+  width: 18px;
+  padding: 0;
+  text-align: center;
+}
+
+.yaml-gutter .yaml-grip,
+.yaml-gutter .yaml-slot-grip {
+  flex: none;
+  width: 12px;
+}
+
+/* The add controls a collapsed/empty container keeps IN the row, next to what
+   they grow (an open container grows through its persistent add row instead). */
+.yaml-actions-row {
+  margin-left: auto;
+}
+
+.yaml-row:hover .yaml-actions,
+.yaml-actions:focus-within {
+  opacity: 1;
+}
+
+.yaml-act,
+.yaml-add {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 0 5px;
+  font-size: 10px;
+  line-height: 16px;
+  cursor: pointer;
+}
+
+.yaml-act:not(:disabled):hover,
+.yaml-add:not(:disabled):hover {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+.yaml-act:disabled,
+.yaml-add:disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+
+.yaml-act-del:not(:disabled):hover {
+  color: var(--danger, #f85149);
+  border-color: var(--danger, #f85149);
+}
+
+.yaml-add-inline {
+  display: inline-flex;
+  gap: 2px;
+}
+
+/* The add-entry form and the empty-file seed row are always visible — they are
+   the affordance, not a hover action. */
+.yaml-row-add,
+.yaml-row-form {
+  gap: 4px;
+  padding: 2px 0;
+}
+
+.yaml-row-add .yaml-add {
+  opacity: 1;
+}
+
+/* "source only" keeps the old action cluster's spot and hover reveal — it is a
+   note about the row, not part of the gutter's buttons. */
+.yaml-locked {
+  color: var(--text-muted);
+  font-size: 10px;
+  font-style: italic;
+  margin-left: auto;
+  opacity: 0;
+}
+
+.yaml-row:hover .yaml-locked {
+  opacity: 1;
+}
+
+.yaml-tree-notice {
+  padding: 12px;
+  font-size: 12px;
+  color: var(--text-muted);
+  font-family: var(--font-sans, system-ui, sans-serif);
+}
+
+.yaml-tree-notice-hint {
+  margin-top: 4px;
+}
+
+/* YAML card grid (#yaml-grid) — the recursive, tree-like card view. The document is
+   one centred top card (or a row of them for a root list); every nested collection
+   is a card whose own nested collections are subcards in a grid below it, folding
+   from the header. Monospace like the tree so values read as data; it reuses the
+   tree's value colours (.yaml-val-*) and its .yaml-value-input / .yaml-add / .yaml-act
+   primitives, and each field edit splices the file text (see YamlGrid.tsx). */
+.yaml-cards {
+  padding: 8px 12px 24px;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, monospace);
+  font-size: 12px;
+  color: var(--text-primary);
+}
+
+/* A thin bar carrying only the untested tag today — a home for future view controls
+   (expand/collapse all, density). */
+.yaml-cards-bar {
+  display: flex;
+  align-items: center;
+  margin-bottom: 6px;
+}
+
+.yaml-cards-bar-spacer {
+  flex: 1 1 auto;
+}
+
+/* The centred top card (or root card list): a readable column that doesn't sprawl
+   the full width of a wide pane. */
+.yaml-card-root {
+  max-width: 1040px;
+  margin: 0 auto;
+}
+
+.yaml-card-root + .yaml-card-root {
+  margin-top: 12px;
+}
+
+.yaml-card {
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-md, 8px);
+  background: var(--bg-panel);
+  overflow: hidden;
+}
+
+/* Depth-tinted left edge, so a subcard reads as nested inside its parent at a glance
+   (the guide-line colours cycle by depth, like the tree's indent guides). */
+.yaml-card-d0 { border-left: 2px solid var(--yaml-guide-0, var(--accent)); }
+.yaml-card-d1 { border-left: 2px solid var(--yaml-guide-1, var(--accent)); }
+.yaml-card-d2 { border-left: 2px solid var(--yaml-guide-2, var(--accent)); }
+.yaml-card-d3 { border-left: 2px solid var(--yaml-guide-3, var(--accent)); }
+.yaml-card-d4 { border-left: 2px solid var(--yaml-guide-0, var(--accent)); }
+.yaml-card-d5 { border-left: 2px solid var(--yaml-guide-1, var(--accent)); }
+/* The guide-line colours (mirrors .yaml-tree's), so subcard edges match the tree. */
+.yaml-cards {
+  --yaml-guide-0: color-mix(in srgb, var(--accent, #4493f8) 55%, transparent);
+  --yaml-guide-1: color-mix(in srgb, #a887e8 55%, transparent);
+  --yaml-guide-2: color-mix(in srgb, #4fc1a6 55%, transparent);
+  --yaml-guide-3: color-mix(in srgb, #d9a05b 55%, transparent);
+}
+
+/* The card header names the collection (its key or list index) + a folding toggle,
+   a flow badge, a key/item count, and the delete — chrome tinted apart from the body. */
+.yaml-card-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 3px 6px;
+  background: var(--bg-subtle, rgba(255, 255, 255, 0.03));
+  border-bottom: 1px solid var(--border-color);
+}
+
+/* The whole "caret + title" is one click target that folds the card. */
+.yaml-card-toggle {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex: 1 1 auto;
+  min-width: 0;
+  background: transparent;
+  border: 0;
+  padding: 1px 2px;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  text-align: left;
+}
+
+.yaml-card-caret {
+  flex: none;
+  width: 12px;
+  color: var(--text-muted);
+}
+
+.yaml-card-title {
+  color: var(--text-primary);
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.yaml-card-badge {
+  flex: none;
+  color: var(--text-muted);
+  font-size: 10px;
+  white-space: nowrap;
+}
+
+/* The × keeps its slot but only paints on card-header hover, so it isn't furniture. */
+.yaml-card-del,
+.yaml-card-field-del {
+  flex: none;
+  opacity: 0;
+}
+
+.yaml-card-head:hover .yaml-card-del,
+.yaml-card-del:focus-visible,
+.yaml-card-field:hover .yaml-card-field-del,
+.yaml-card-field-del:focus-visible {
+  opacity: 1;
+}
+
+.yaml-card-body {
+  padding: 4px 4px 6px;
+}
+
+.yaml-card-fields {
+  display: flex;
+  flex-direction: column;
+}
+
+/* A field row: a key column on the left, the editable value filling the rest, and a
+   hover-delete — the label/value pairing that makes a record read as a record. */
+.yaml-card-field {
+  display: grid;
+  grid-template-columns: minmax(0, 9em) 1fr auto;
+  align-items: center;
+  gap: 6px;
+  padding: 1px 4px;
+}
+
+.yaml-card-field-scalar {
+  grid-template-columns: 1fr auto;
+}
+
+.yaml-card-key {
+  color: var(--text-muted);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* A list value's label is a bullet, not an index — a value list reads as a list. */
+.yaml-card-bullet {
+  color: var(--accent, #4493f8);
+  text-align: center;
+  opacity: 0.7;
+}
+
+/* The value input fills its column with no chrome until pointed at — the same
+   undressed-field bargain the tree's values strike. */
+.yaml-card-field .yaml-value-input {
+  display: block;
+  width: 100%;
+  border-color: transparent;
+  padding: 2px 4px;
+}
+
+.yaml-card-field .yaml-value-input:hover:not(:focus) {
+  background: color-mix(in srgb, var(--accent, #4493f8) 10%, transparent);
+}
+
+.yaml-card-field .yaml-value-input:focus {
+  background: var(--bg-panel);
+  border-color: var(--accent, #4493f8);
+}
+
+.yaml-card-field .yaml-value-locked {
+  display: block;
+  padding: 2px 4px;
+  max-width: 100%;
+}
+
+/* Subcards laid out in COLUMNS below the parent's fields — a responsive auto-fill
+   grid, so a list of records becomes a wall of cards and a heterogeneous set wraps. */
+.yaml-subcards {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+  gap: 8px;
+  align-items: start;
+  margin-top: 6px;
+}
+
+/* At the very top, a root list's cards get a touch more room to breathe. */
+.yaml-subcards-root {
+  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
+  gap: 10px;
+  margin-top: 0;
+}
+
+/* A bare-scalar list item card: value only, no fields grid. */
+.yaml-card-scalar .yaml-card-body {
+  padding: 4px;
+}
+
+.yaml-card-add {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  padding: 6px 4px 0;
+}
+
+/* Drag-to-reorder (pointer-based, like the tree's grip): the grip appears on the
+   card header's hover but keeps its width always, so no header shifts when it does. */
+.yaml-card-grip {
+  flex: none;
+  cursor: grab;
+  opacity: 0;
+  touch-action: none; /* the pointer drag owns the gesture, not the scroller */
+}
+
+.yaml-card-head:hover .yaml-card-grip,
+.yaml-card-grip:focus-visible {
+  opacity: 1;
+}
+
+/* The card being dragged lifts and dims; the card it would land on rings in accent;
+   a card that can't be a target (locked) fades to show the drop won't land there. */
+.yaml-card-dragging {
+  opacity: 0.5;
+}
+
+.yaml-card-dragging .yaml-card-grip {
+  cursor: grabbing;
+}
+
+.yaml-card-drop {
+  outline: 2px solid var(--accent, #4493f8);
+  outline-offset: 1px;
+}
+
+.yaml-card-blocked {
+  opacity: 0.4;
+}
+
+/* ── Drill navigation (#yaml-grid) ────────────────────────────────────────────
+   The grid is a drill: a breadcrumb path, the main card's level (siblings, it
+   highlighted), and its children as the level below. Each level is an equal-height
+   grid; a card with more fields than fit scrolls inside itself. */
+.yaml-grid-breadcrumb {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 2px;
+  min-width: 0;
+  font-size: 11px;
+}
+
+.yaml-crumb-wrap {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  min-width: 0;
+}
+
+.yaml-crumb-sep {
+  color: var(--text-muted);
+  opacity: 0.6;
+}
+
+.yaml-crumb {
+  max-width: 16em;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  background: transparent;
+  border: 0;
+  padding: 2px 6px;
+  border-radius: 5px;
+  color: var(--text-muted);
+  font: inherit;
+  cursor: pointer;
+}
+
+.yaml-crumb:hover {
+  background: color-mix(in srgb, var(--accent, #4493f8) 12%, transparent);
+  color: var(--text-primary);
+}
+
+.yaml-crumb.on {
+  color: var(--text-primary);
+  font-weight: 600;
+}
+
+.yaml-level {
+  margin-top: 10px;
+}
+
+.yaml-level:first-of-type {
+  margin-top: 4px;
+}
+
+/* Each deeper level is inset a touch and rail-marked, so the drill reads as a
+   descent even though every level is a full-width grid. */
+.yaml-level + .yaml-level {
+  margin-left: 12px;
+  padding-left: 10px;
+  border-left: 2px solid var(--yaml-guide-0, var(--accent));
+}
+
+.yaml-level-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+  gap: 8px;
+  align-items: start;
+}
+
+/* A level card is a fixed-height flex column (height set inline from the level's
+   measured max): head + a scrolling field area + the add bar + the drill footer. */
+.yaml-level-card {
+  display: flex;
+  flex-direction: column;
+}
+
+.yaml-card-scroll {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  padding: 4px 4px 2px;
+}
+
+.yaml-card-empty {
+  padding: 6px 4px;
+  color: var(--text-muted);
+  font-style: italic;
+  opacity: 0.7;
+}
+
+/* The card the drill is currently on: ringed and lifted so it reads as "main"
+   among its siblings. */
+.yaml-card-main {
+  border-color: var(--accent, #4493f8);
+  box-shadow: 0 0 0 1px var(--accent, #4493f8);
+}
+
+.yaml-card-main .yaml-card-head {
+  background: color-mix(in srgb, var(--accent, #4493f8) 16%, transparent);
+}
+
+/* A non-drillable card's title isn't a button — keep it aligned with the ones
+   that are. */
+.yaml-card-title-static {
+  flex: 1 1 auto;
+  min-width: 0;
+  padding: 1px 2px;
+}
+
+/* The footer that opens a card's nested groups as the next level. */
+.yaml-card-drill {
+  flex: none;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 4px;
+  padding: 4px 6px;
+  border: 0;
+  border-top: 1px solid var(--border-color);
+  background: var(--bg-subtle, rgba(255, 255, 255, 0.03));
+  color: var(--accent, #4493f8);
+  font: inherit;
+  font-size: 11px;
+  cursor: pointer;
+}
+
+.yaml-card-drill:hover {
+  background: color-mix(in srgb, var(--accent, #4493f8) 14%, transparent);
+}
+
+/* "No LaTeX engine — install one" prompt in the TeX viewer's no-engine state.
+   Mirrors the install-cmd rows used in the Ollama/Agents settings panels. */
+.tex-install-banner {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding: 8px 12px;
+  font-size: 12px;
+  border-bottom: 1px solid var(--border, #30363d);
+  background: var(--bg-subtle, rgba(255, 255, 255, 0.03));
+}
+
+.tex-install-banner-text {
+  color: var(--text-muted);
+}
+
+.tex-install-banner .ollama-install-cmd {
+  flex: 1 1 240px;
+  min-width: 0;
+}
+
+/* OpenDocument Text viewer (#51): a scrolling, theme-coloured reading surface for
+   the HTML subset rendered from content.xml. A centred max-width column keeps
+   prose readable; tables and images stay within it. */
+.odt-viewer-body {
+  flex: 1;
+  min-height: 0;
+  overflow: auto;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+}
+
+.odt-document {
+  max-width: 48rem;
+  margin: 0 auto;
+  padding: 28px 32px 56px;
+  line-height: 1.6;
+  font-size: 14px;
+}
+
+.odt-document h1,
+.odt-document h2,
+.odt-document h3,
+.odt-document h4,
+.odt-document h5,
+.odt-document h6 {
+  line-height: 1.25;
+  margin: 1.4em 0 0.5em;
+  font-weight: 600;
+}
+
+.odt-document p {
+  margin: 0 0 0.8em;
+  white-space: pre-wrap;
+}
+
+.odt-document a {
+  color: var(--accent, #3b82f6);
+  text-decoration: underline;
+}
+
+.odt-document ul,
+.odt-document ol {
+  margin: 0 0 0.8em 1.5em;
+  padding: 0;
+}
+
+.odt-image {
+  max-width: 100%;
+  height: auto;
+}
+
+.odt-table {
+  border-collapse: collapse;
+  margin: 0 0 1em;
+  font-size: 13px;
+}
+
+.odt-table td {
+  border: 1px solid var(--border-color);
+  padding: 4px 8px;
+  vertical-align: top;
+}
+
+/* Code editor: a line-number gutter beside a scrolling monospace textarea. The
+   gutter is scroll-synced from JS (file-viewer-gutter has no scrollbar), so the
+   body must not scroll — the textarea owns the scroll. Font metrics (size 12px,
+   line-height 18px, 10px top padding) are shared so the numbers stay aligned. */
+.file-viewer-code-body {
+  overflow: hidden;
+}
+
+.file-viewer-code {
+  position: relative;
+  display: flex;
+  height: 100%;
+  min-height: 0;
+  /* Editor font metrics. Defaults match the shared 12px/18px layout; the text
+     size control overrides these inline so the gutter + overlay layers scale
+     together and stay aligned. */
+  --code-font-size: 12px;
+  --code-line-height: 18px;
+}
+
+.file-viewer-gutter {
+  flex-shrink: 0;
+  overflow: hidden;
+  padding: 10px 8px 10px 10px;
+  text-align: right;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: var(--code-font-size, 12px);
+  line-height: var(--code-line-height, 18px);
+  color: var(--text-muted);
+  background: var(--bg-panel);
+  border-right: 1px solid var(--border-color);
+  user-select: none;
+  font-variant-numeric: tabular-nums;
+}
+
+/* The line numbers are translated as a block to follow the textarea's vertical
+   scroll (see syncScroll); the gutter itself stays put and clips them. */
+.file-viewer-gutter-inner {
+  will-change: transform;
+}
+
+.file-viewer-gutter-line {
+  height: var(--code-line-height, 18px);
+}
+
+/* #67: gutter line numbers for lines that contain a search match — the current
+   match brightest, echoing the in-text highlight colours. */
+.file-viewer-gutter-line.has-match {
+  color: var(--text-primary);
+  background: rgba(255, 213, 0, 0.28);
+  border-radius: 2px;
+}
+.file-viewer-gutter-line.current-match {
+  color: #1a1a1a;
+  background: rgba(255, 145, 0, 0.85);
+  border-radius: 2px;
+  font-weight: 600;
+}
+
+/* #py: a breakpoint-capable gutter (the Python editor). The cell becomes a real
+   <button>, so it has to be stripped back to looking exactly like the plain
+   number it replaces — same metrics, same colour — and only then gain its
+   affordances. Everything below is either a reset or a hover/active state. */
+.file-viewer-gutter-line.is-breakable {
+  display: block;
+  position: relative;
+  width: 100%;
+  margin: 0;
+  padding: 0;
+  border: none;
+  background: none;
+  color: inherit;
+  font: inherit;
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+  cursor: pointer;
+}
+
+/* The dot lives in the gutter's left padding, clear of the numbers. Shown faint
+   on hover so the column advertises what a click does, solid once set. */
+.file-viewer-gutter-line.is-breakable::before {
+  content: "";
+  position: absolute;
+  left: -7px;
+  top: 50%;
+  width: 8px;
+  height: 8px;
+  transform: translateY(-50%);
+  border-radius: 50%;
+  background: #e5484d;
+  opacity: 0;
+  transition: opacity var(--transition);
+}
+.file-viewer-gutter-line.is-breakable:hover::before {
+  opacity: 0.35;
+}
+.file-viewer-gutter-line.has-breakpoint::before,
+.file-viewer-gutter-line.has-breakpoint:hover::before {
+  opacity: 1;
+}
+.file-viewer-gutter-line.has-breakpoint {
+  color: #e5484d;
+  font-weight: 600;
+}
+.file-viewer-gutter-line.is-breakable:focus-visible {
+  outline: 1px solid var(--accent-color);
+  outline-offset: -1px;
+}
+
+/* Hidden mirror that measures each logical line's wrapped height so the wrap-mode
+   gutter (LaTeX viewer) can size its cells to match. Shares the editor's font
+   metrics, padding and wrap rules; its width is set inline to the textarea's
+   content width. Never painted — visibility:hidden keeps it laid out. */
+.file-viewer-gutter-measure {
+  position: absolute;
+  top: 0;
+  left: 0;
+  margin: 0;
+  padding: 10px 12px;
+  box-sizing: border-box;
+  visibility: hidden;
+  pointer-events: none;
+  z-index: -1;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: var(--code-font-size, 12px);
+  line-height: var(--code-line-height, 18px);
+  tab-size: 4;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
+  font-kerning: none;
+  text-rendering: geometricPrecision;
+}
+.fv-measure-line {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  word-break: normal;
+}
+
+/* The editing area beside the gutter. It holds the highlight <pre> layer and the
+   <textarea> stacked on top of each other; the textarea owns the scroll and the
+   <pre> is scroll-synced from JS. Both share identical font metrics and padding
+   so the coloured text sits exactly under the editable text. */
+.file-viewer-code-area {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  height: 100%;
+  overflow: hidden;
+  background: var(--bg-panel);
+}
+
+.file-viewer-code-editor {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 1;
+  background: transparent;
+  font-size: var(--code-font-size, 12px);
+  line-height: var(--code-line-height, 18px);
+  white-space: pre;
+  overflow: auto;
+  tab-size: 4;
+}
+
+/* While a follow modifier (Ctrl/Cmd) is held AND the pointer is over a recognised
+   link in the LaTeX source editor, show a link cursor so Ctrl/Cmd+Click to open a
+   referenced file is discoverable. Gated on hover so only the link reads as
+   clickable, not the whole editor. */
+.file-viewer-code-area.link-hover .file-viewer-code-editor {
+  cursor: pointer;
+}
+
+/* With a highlight layer present, hide the textarea's own glyphs (keeping the
+   caret visible) so the coloured <pre> underneath shows through. The selection
+   highlight still paints over the transparent text. */
+.file-viewer-code-area.highlighted .file-viewer-code-editor {
+  color: transparent;
+  -webkit-text-fill-color: transparent;
+  caret-color: var(--text-primary);
+}
+
+.file-viewer-highlight {
+  position: absolute;
+  /* Sized to its own content (not inset to the box) and translated to follow the
+     textarea's scroll; the parent (.file-viewer-code-area, overflow:hidden) clips
+     it. A transform isn't clamped to a scroll range, so it tracks the textarea
+     past where the overlay could scroll itself — see syncScroll. */
+  top: 0;
+  left: 0;
+  min-width: 100%;
+  margin: 0;
+  padding: 10px 12px;
+  box-sizing: border-box;
+  will-change: transform;
+  pointer-events: none;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: var(--code-font-size, 12px);
+  line-height: var(--code-line-height, 18px);
+  white-space: pre;
+  tab-size: 4;
+  color: var(--text-primary);
+  /* Match the textarea's fixed glyph advance so the coloured text stays exactly
+     under the editable text and the caret never drifts (see .file-viewer-editor). */
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
+  font-kerning: none;
+  text-rendering: geometricPrecision;
+}
+
+/* Syntax token colours. These reference the existing per-theme semantic
+   variables, so highlighting adapts to every theme automatically with no
+   per-theme additions. */
+.tok-comment { color: var(--text-muted); font-style: italic; }
+.tok-string { color: var(--success); }
+.tok-keyword { color: var(--accent-secondary); }
+.tok-num { color: var(--warning); }
+.tok-type { color: var(--accent-hover); }
+.tok-func { color: var(--accent); }
+.tok-tag { color: var(--accent); }
+.tok-attr { color: var(--accent-secondary); }
+.tok-prop { color: var(--accent); }
+
+/* Markdown source highlighting (the .md "Edit" view). Reuses the same semantic
+   variables so it adapts per theme; headings/strong stay bold, emphasis italic. */
+.tok-md-heading { color: var(--accent); font-weight: 700; }
+.tok-md-strong  { color: var(--text-primary); font-weight: 700; }
+.tok-md-em      { color: var(--text-primary); font-style: italic; }
+.tok-md-code    { color: var(--success); }
+.tok-md-link    { color: var(--accent); }
+.tok-md-url     { color: var(--accent-secondary); text-decoration: underline; }
+.tok-md-quote   { color: var(--text-muted); font-style: italic; }
+.tok-md-list    { color: var(--accent-secondary); font-weight: 700; }
+.tok-md-hr      { color: var(--text-muted); }
+
+/* Fancy themes: a Helix-inspired, high-contrast palette so code in the viewer
+   pops — built from Helix's default signature hues (apricot red-orange, lilac &
+   lavender purple, honey/chamois gold) pushed brighter for contrast, plus a
+   green for strings (Helix's default uses grey there, too flat for this).
+   `fancy_dark` carries the Helix dark-purple vibe; `fancy_light` drops the same
+   hues darker so they stay legible on the light surface. Plain `dark`/`light`
+   keep the calm semantic colors above. */
+[data-theme="fancy_dark"] .tok-comment { color: #697c81; }   /* sirocco  */
+[data-theme="fancy_dark"] .tok-string  { color: #9fd86a; }   /* green    */
+[data-theme="fancy_dark"] .tok-keyword { color: #d9bfff; }   /* lilac    */
+[data-theme="fancy_dark"] .tok-num     { color: #efba5d; }   /* honey    */
+[data-theme="fancy_dark"] .tok-type    { color: #e8dca0; }   /* chamois  */
+[data-theme="fancy_dark"] .tok-func    { color: #a4a0e8; }   /* lavender */
+[data-theme="fancy_dark"] .tok-tag     { color: #f47868; }   /* apricot  */
+[data-theme="fancy_dark"] .tok-attr    { color: #dbbfef; }   /* lilac    */
+[data-theme="fancy_dark"] .tok-prop    { color: #b9b4f5; }   /* lavender */
+
+[data-theme="fancy_dark"] .tok-md-heading { color: #f47868; }  /* apricot  */
+[data-theme="fancy_dark"] .tok-md-strong  { color: #e8dca0; }  /* chamois  */
+[data-theme="fancy_dark"] .tok-md-em      { color: #e8dca0; }  /* chamois  */
+[data-theme="fancy_dark"] .tok-md-code    { color: #9fd86a; }  /* green    */
+[data-theme="fancy_dark"] .tok-md-link    { color: #a4a0e8; }  /* lavender */
+[data-theme="fancy_dark"] .tok-md-url     { color: #697c81; }  /* sirocco  */
+[data-theme="fancy_dark"] .tok-md-quote   { color: #697c81; }  /* sirocco  */
+[data-theme="fancy_dark"] .tok-md-list    { color: #d9bfff; }  /* lilac    */
+[data-theme="fancy_dark"] .tok-md-hr      { color: #697c81; }  /* sirocco  */
+
+[data-theme="fancy_light"] .tok-comment { color: #6b7280; }
+[data-theme="fancy_light"] .tok-string  { color: #2e7d32; }  /* green    */
+[data-theme="fancy_light"] .tok-keyword { color: #8e24aa; }  /* lilac    */
+[data-theme="fancy_light"] .tok-num     { color: #b8540a; }  /* honey    */
+[data-theme="fancy_light"] .tok-type    { color: #8a6d1a; }  /* chamois  */
+[data-theme="fancy_light"] .tok-func    { color: #5145c4; }  /* lavender */
+[data-theme="fancy_light"] .tok-tag     { color: #d6492f; }  /* apricot  */
+[data-theme="fancy_light"] .tok-attr    { color: #9333ea; }  /* lilac    */
+[data-theme="fancy_light"] .tok-prop    { color: #6d28d9; }  /* lavender */
+
+[data-theme="fancy_light"] .tok-md-heading { color: #d6492f; }  /* apricot  */
+[data-theme="fancy_light"] .tok-md-strong  { color: #6d4c00; }  /* chamois  */
+[data-theme="fancy_light"] .tok-md-em      { color: #6d4c00; }  /* chamois  */
+[data-theme="fancy_light"] .tok-md-code    { color: #2e7d32; }  /* green    */
+[data-theme="fancy_light"] .tok-md-link    { color: #5145c4; }  /* lavender */
+[data-theme="fancy_light"] .tok-md-url     { color: #6b7280; }  /* sirocco  */
+[data-theme="fancy_light"] .tok-md-quote   { color: #6b7280; }  /* sirocco  */
+[data-theme="fancy_light"] .tok-md-list    { color: #8e24aa; }  /* lilac    */
+[data-theme="fancy_light"] .tok-md-hr      { color: #6b7280; }  /* sirocco  */
+
+/* #49 link-decoration + #45 ghost overlays: transparent <pre> layers aligned to
+   the textarea exactly like .file-viewer-highlight, so only their styled spans
+   paint. They sit ABOVE the highlight layer but below the textarea caret. */
+.file-viewer-link-layer,
+.file-viewer-search-layer,
+.file-viewer-change-layer,
+.file-viewer-delete-layer,
+.file-viewer-grammar-layer,
+.file-viewer-ghost {
+  position: absolute;
+  inset: 0;
+  margin: 0;
+  padding: 10px 12px;
+  box-sizing: border-box;
+  overflow: hidden;
+  pointer-events: none;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: var(--code-font-size, 12px);
+  line-height: var(--code-line-height, 18px);
+  white-space: pre;
+  tab-size: 4;
+  color: transparent;
+  /* Same fixed glyph advance as the textarea/highlight layer (see above). */
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0, "clig" 0, "calt" 0;
+  font-kerning: none;
+  text-rendering: geometricPrecision;
+}
+
+/* The link layer is scroll-synced with a transform like .file-viewer-highlight,
+   so it is sized to its own content and clipped by the parent (not inset to the
+   box). The ghost layer keeps the inset/overflow model above. */
+.file-viewer-link-layer,
+.file-viewer-search-layer,
+.file-viewer-change-layer,
+.file-viewer-delete-layer,
+.file-viewer-grammar-layer {
+  inset: auto;
+  top: 0;
+  left: 0;
+  min-width: 100%;
+  overflow: visible;
+  will-change: transform;
+}
+
+/* Grammar/spelling check overlay: each flagged span paints a coloured wavy
+   underline (the layer sits below the textarea, so the underline shows beneath
+   the editable glyphs). Colour encodes the category — spelling=red, grammar=blue,
+   style=green. Fixed colours so they read on both light and dark themes. */
+.file-viewer-grammar-layer .file-viewer-grammar-mark {
+  text-decoration-line: underline;
+  text-decoration-style: wavy;
+  text-decoration-skip-ink: none;
+  text-underline-offset: 2px;
+  /* The mark text itself stays transparent (only the decoration paints); set the
+     decoration colour per category below. */
+}
+.file-viewer-grammar-layer .file-viewer-grammar-mark.cat-spelling {
+  text-decoration-color: #f85149;
+}
+.file-viewer-grammar-layer .file-viewer-grammar-mark.cat-grammar {
+  text-decoration-color: #4493f8;
+}
+.file-viewer-grammar-layer .file-viewer-grammar-mark.cat-style {
+  text-decoration-color: #3fb950;
+}
+
+/* Hover tooltip for a grammar mark: category, message, and a one-click fix.
+   position:fixed + anchored just above the pointer; pointer-events auto so the
+   Fix button is clickable (the underline overlay itself is pointer-events:none). */
+.file-viewer-grammar-tip {
+  position: fixed;
+  z-index: 60;
+  transform: translateY(-100%);
+  margin-top: -8px;
+  max-width: 320px;
+  padding: 6px 9px;
+  border-radius: var(--radius);
+  background: var(--bg-main, #1f2430);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-left: 3px solid var(--border-color);
+  font-size: 11px;
+  line-height: 1.45;
+  box-shadow: var(--shadow-2);
+}
+.file-viewer-grammar-tip.cat-spelling { border-left-color: #f85149; }
+.file-viewer-grammar-tip.cat-grammar { border-left-color: #4493f8; }
+.file-viewer-grammar-tip.cat-style { border-left-color: #3fb950; }
+.file-viewer-grammar-tip-cat {
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  font-size: 9px;
+  opacity: 0.7;
+  margin-bottom: 2px;
+}
+.file-viewer-grammar-tip-msg {
+  margin-bottom: 4px;
+}
+.file-viewer-grammar-tip-fix {
+  display: inline-block;
+  max-width: 100%;
+  padding: 2px 8px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-color);
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  font-size: 11px;
+  cursor: pointer;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.file-viewer-grammar-tip-fix:hover {
+  border-color: var(--accent, #4493f8);
+}
+.file-viewer-grammar-tip-sugg {
+  font-family: var(--font-mono, ui-monospace, Menlo, Consolas, monospace);
+  color: var(--accent, #4493f8);
+}
+
+/* ── Git blame (#blame) ─────────────────────────────────────────────────────
+   A per-line attribution column left of the numbers, a faint current-line inline
+   hint, and a hovercard. The column shares the gutter's font metrics and cell
+   heights (incl. wrap mode) so its rows line up with the numbers and the code. */
+.file-viewer-blame-gutter {
+  flex-shrink: 0;
+  overflow: hidden;
+  max-width: 22ch;
+  padding: 10px 6px 10px 8px;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: var(--code-font-size, 12px);
+  line-height: var(--code-line-height, 18px);
+  color: var(--text-muted);
+  background: var(--bg-panel);
+  border-right: 1px solid var(--border-subtle);
+  user-select: none;
+  cursor: default;
+}
+/* Scroll-locked as a block, mirroring the number gutter (see syncScroll). */
+.file-viewer-blame-inner {
+  will-change: transform;
+}
+.file-viewer-blame-line {
+  height: var(--code-line-height, 18px);
+  display: flex;
+  gap: 6px;
+  align-items: center;
+  white-space: nowrap;
+  overflow: hidden;
+  border-radius: 2px;
+}
+.file-viewer-blame-line.current {
+  color: var(--text-primary);
+  outline: 1px solid var(--border-subtle);
+}
+.file-viewer-blame-line .fv-blame-author {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.file-viewer-blame-line .fv-blame-date {
+  flex-shrink: 0;
+  opacity: 0.75;
+  font-variant-numeric: tabular-nums;
+}
+.file-viewer-blame-line.uncommitted {
+  opacity: 0.4;
+}
+.file-viewer-blame-line .fv-blame-none {
+  opacity: 0.5;
+}
+
+/* Faint right-aligned annotation on the caret's line, over the code area but not
+   interactive (no pointer events). Scroll-locked with the blame column. */
+.file-viewer-blame-inline {
+  position: absolute;
+  right: 12px;
+  z-index: 2;
+  max-width: 60%;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  pointer-events: none;
+  font-size: calc(var(--code-font-size, 12px) - 1px);
+  color: var(--text-muted);
+  opacity: 0.8;
+  font-style: italic;
+  will-change: transform;
+}
+
+/* Blame hovercard: same chrome as the grammar tooltip. Explicit color so it
+   reads correctly regardless of surrounding context (canonical menu scheme). */
+.file-viewer-blame-tip {
+  position: fixed;
+  z-index: 60;
+  transform: translateY(-100%);
+  margin-top: -8px;
+  max-width: 360px;
+  padding: 6px 9px;
+  border-radius: var(--radius);
+  background: var(--bg-main, #1f2430);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-left: 3px solid var(--accent, #4493f8);
+  font-size: 11px;
+  line-height: 1.45;
+  box-shadow: var(--shadow-2);
+  pointer-events: none;
+}
+.file-viewer-blame-tip-head {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  margin-bottom: 2px;
+}
+.file-viewer-blame-tip-hash {
+  font-family: var(--font-mono, ui-monospace, Menlo, Consolas, monospace);
+  color: var(--accent, #4493f8);
+}
+.file-viewer-blame-tip-author {
+  font-weight: 600;
+}
+.file-viewer-blame-tip-date {
+  opacity: 0.7;
+  margin-bottom: 4px;
+}
+.file-viewer-blame-tip-summary {
+  white-space: normal;
+}
+
+/* The Blame toggle reuses the format-button chrome; the active state is accented
+   like the other in-editor toggles. */
+.file-viewer-blame-btn.active,
+.file-viewer-compare-btn.active {
+  border-color: var(--accent, #4493f8);
+  color: var(--accent, #4493f8);
+}
+
+/* Three-column compare/merge view (old commit ⇄ live content ⇄ editable result).
+   Fills the editor body; its own sub-toolbar sits above the three columns. */
+.file-viewer-compare {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  min-height: 0;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+}
+.file-viewer-compare-bar {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 0 0 auto;
+  padding: 4px 8px;
+  border-bottom: 1px solid var(--border-color);
+  font-size: 11px;
+}
+.file-viewer-compare-label {
+  color: var(--text-muted);
+}
+.file-viewer-compare-date {
+  color: var(--text-muted);
+  font-size: 10px;
+}
+.file-viewer-compare-bar-gap {
+  flex: 1 1 auto;
+}
+.file-viewer-compare-apply {
+  border-color: var(--accent, #4493f8);
+  color: var(--accent, #4493f8);
+}
+.file-viewer-compare-cols {
+  display: grid;
+  grid-template-columns: 1fr 1fr 1fr;
+  gap: 1px;
+  flex: 1 1 auto;
+  min-height: 0;
+  background: var(--border-color);
+}
+.file-viewer-compare-col {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  min-height: 0;
+  background: var(--bg-panel);
+}
+.file-viewer-compare-col-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 0 0 auto;
+  padding: 3px 8px;
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-elevated, rgba(127, 127, 127, 0.08));
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--text-secondary, var(--text-muted));
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+/* Body + its overlay ruler share one relatively-positioned wrapper so the ruler
+   can pin to the scrollbar edge. */
+.file-viewer-compare-col-body-wrap {
+  position: relative;
+  flex: 1 1 auto;
+  min-height: 0;
+  display: flex;
+}
+.file-viewer-compare-col-body {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow: auto;
+  font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
+  font-size: 12px;
+  line-height: 1.5;
+}
+.file-viewer-compare-line {
+  position: relative;
+  display: flex;
+  white-space: pre;
+}
+.file-viewer-compare-line.is-block-start {
+  scroll-margin-top: 36px; /* keep ~2 lines of leading context above the hunk */
+}
+.file-viewer-compare-lno {
+  flex: 0 0 auto;
+  width: 3em;
+  padding-right: 0.5em;
+  text-align: right;
+  color: var(--text-muted);
+  opacity: 0.7;
+  user-select: none;
+}
+.file-viewer-compare-code {
+  flex: 1 1 auto;
+  padding-left: 0.5em;
+}
+/* The middle result is an editable textarea seeded from the merge — but rendered
+   like the two side columns: a syntax-highlighted backdrop (`-result-hl`) paints
+   the colored text, and the textarea sits transparently on top of it (its own
+   text hidden, only caret + selection visible) so editing stays live while the
+   result reads in color instead of flat monochrome. Backdrop and textarea MUST
+   share identical font/padding/line-height or the caret drifts off the glyphs. */
+.file-viewer-compare-col-mid .file-viewer-compare-col-head {
+  flex-wrap: wrap;
+}
+.file-viewer-compare-result-wrap {
+  position: relative;
+  flex: 1 1 auto;
+  min-height: 0;
+}
+.file-viewer-compare-result-hl {
+  position: absolute;
+  inset: 0;
+  overflow: hidden;
+  padding: 0 0.5em;
+  background: var(--bg-panel);
+  font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
+  font-size: 12px;
+  line-height: 1.5;
+  white-space: pre;
+  pointer-events: none;
+}
+.file-viewer-compare-hl-line {
+  min-height: 1.5em;
+}
+/* Changed lines in the middle result: tinted the same blue as the mid ruler
+   marks, but brighter and low-opacity so the syntax colors still read through. */
+.file-viewer-compare-hl-line.changed {
+  background: rgba(88, 166, 255, 0.16);
+  box-shadow: inset 2px 0 0 rgba(88, 166, 255, 0.7);
+}
+.file-viewer-compare-result {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  resize: none;
+  border: 0;
+  outline: none;
+  padding: 0 0.5em;
+  background: transparent;
+  color: transparent;
+  caret-color: var(--text-primary);
+  font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
+  font-size: 12px;
+  line-height: 1.5;
+  white-space: pre;
+}
+.file-viewer-compare-result::selection {
+  background: var(--accent, #4493f8);
+  color: #fff;
+}
+
+/* Per-hunk take arrows live in an overlay layer that spans the column body and
+   is clipped to it; only the buttons take pointer events so the text underneath
+   stays selectable and the scrollbar still drags. */
+.file-viewer-compare-take-layer {
+  position: absolute;
+  inset: 0;
+  overflow: hidden;
+  pointer-events: none;
+  z-index: 4;
+}
+.file-viewer-compare-take-layer.left {
+  /* leave the scrollbar/ruler edge clear; arrows hug the inner (result) edge */
+  right: 6px;
+}
+.file-viewer-compare-take-layer.right {
+  left: 0;
+}
+/* Inner layer the arrows are pinned to; translated by the body's scrollTop in a
+   ref-driven handler (never React state) so scrolling doesn't re-render lines. */
+.file-viewer-compare-take-scroll {
+  position: absolute;
+  inset: 0;
+  will-change: transform;
+}
+/* The button itself: a bold, colored pill pinned to the column's inner edge —
+   left column pushes toward the result on the right, right column on its left.
+   Colored by side (left = restore old/reject = warm, right = keep new/accept =
+   green); a solid fill marks the side currently chosen for that hunk. */
+.file-viewer-compare-take {
+  position: absolute;
+  pointer-events: auto;
+  cursor: pointer;
+  height: 18px;
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  padding: 0 7px;
+  border: 1px solid;
+  border-radius: 9px;
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+  white-space: nowrap;
+  user-select: none;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.28);
+  transition:
+    background 0.1s,
+    transform 0.06s;
+}
+.file-viewer-compare-take:hover {
+  transform: scale(1.06);
+}
+.file-viewer-compare-take:active {
+  transform: scale(0.97);
+}
+.file-viewer-compare-take.left {
+  right: 0;
+}
+.file-viewer-compare-take.right {
+  left: 6px;
+}
+/* Idle: tinted outline pill in the side's color. */
+.file-viewer-compare-take.left {
+  border-color: rgba(248, 81, 73, 0.65);
+  background: rgba(248, 81, 73, 0.14);
+  color: #f85149;
+}
+.file-viewer-compare-take.right {
+  border-color: rgba(63, 185, 80, 0.65);
+  background: rgba(63, 185, 80, 0.14);
+  color: #3fb950;
+}
+/* Chosen side: solid fill, white text — reads as "this is what the result holds". */
+.file-viewer-compare-take.left.active {
+  background: #f85149;
+  border-color: #f85149;
+  color: #fff;
+}
+.file-viewer-compare-take.right.active {
+  background: #3fb950;
+  border-color: #3fb950;
+  color: #fff;
+}
+/* Sync-merge mode: the two sides are the local mirror (left) and the remote host
+   (right), so the take arrows take the local/remote locality-tag colors —
+   green (--success) on the left, amber (--warning) on the right — instead of the
+   git-compare red/green (old/new). */
+.file-viewer-compare.sync .file-viewer-compare-take.left {
+  border-color: color-mix(in srgb, var(--success) 65%, transparent);
+  background: color-mix(in srgb, var(--success) 14%, transparent);
+  color: var(--success);
+}
+.file-viewer-compare.sync .file-viewer-compare-take.right {
+  border-color: color-mix(in srgb, var(--warning) 65%, transparent);
+  background: color-mix(in srgb, var(--warning) 14%, transparent);
+  color: var(--warning);
+}
+.file-viewer-compare.sync .file-viewer-compare-take.left.active {
+  background: var(--success);
+  border-color: var(--success);
+  color: #000;
+}
+.file-viewer-compare.sync .file-viewer-compare-take.right.active {
+  background: var(--warning);
+  border-color: var(--warning);
+  color: #000;
+}
+.file-viewer-compare-take.disabled {
+  opacity: 0.3;
+  cursor: default;
+  box-shadow: none;
+}
+.file-viewer-compare-take.disabled:hover {
+  transform: none;
+}
+
+/* Overview ruler: a thin strip over each column's scrollbar edge with one bar per
+   change block (row-fraction placement keeps the three columns' bars aligned).
+   pointer-events:none so the native scrollbar underneath still drags. */
+.file-viewer-compare-ruler {
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: 5px;
+  height: 100%;
+  z-index: 3;
+  pointer-events: none; /* strip is inert; only the bars react, so the scrollbar drags between them */
+}
+.file-viewer-compare-result-wrap .file-viewer-compare-ruler {
+  right: 1px;
+}
+.file-viewer-compare-ruler-mark {
+  position: absolute;
+  right: 0;
+  width: 100%;
+  min-height: 2px;
+  border-radius: 1px;
+  opacity: 0.8;
+}
+.file-viewer-compare-ruler-mark.clickable {
+  pointer-events: auto;
+  cursor: pointer;
+}
+.file-viewer-compare-ruler-mark.clickable:hover {
+  opacity: 1;
+  /* widen a touch on hover so a thin bar is easy to hit */
+  width: 220%;
+  right: 0;
+}
+.file-viewer-compare-ruler-mark.left {
+  background: #f85149;
+}
+.file-viewer-compare-ruler-mark.right {
+  background: #3fb950;
+}
+.file-viewer-compare-ruler-mark.mid {
+  background: var(--accent, #4493f8);
+}
+/* Sync merge: the side rulers take the local/remote locality-tag colors, matching
+   the take arrows and side-line tints (git-compare keeps red/green old/new). */
+.file-viewer-compare.sync .file-viewer-compare-ruler-mark.left {
+  background: var(--success);
+}
+.file-viewer-compare.sync .file-viewer-compare-ruler-mark.right {
+  background: var(--warning);
+}
+/* Per-change chips: accept (keep new) is accent, reject (restore old) is warm;
+   a hand-edited, un-anchorable change is dimmed and non-interactive. */
+.file-viewer-compare-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 3px;
+}
+.file-viewer-compare-chip {
+  cursor: pointer;
+  border-radius: var(--radius-sm);
+  padding: 0 5px;
+  font-size: 10px;
+  border: 1px solid var(--border-color);
+  user-select: none;
+}
+.file-viewer-compare-chip.accept {
+  border-color: rgba(63, 185, 80, 0.6);
+  color: #3fb950;
+}
+.file-viewer-compare-chip.reject {
+  border-color: rgba(248, 81, 73, 0.6);
+  color: #f85149;
+}
+.file-viewer-compare-chip.disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+
+/* #67 in-editor search: the match spans paint a translucent highlight behind the
+   editable text (the layer sits below the textarea), the current match brighter —
+   like a find highlight. Fixed rgba so it reads on both light and dark themes. */
+.file-viewer-search-layer .file-viewer-search-match {
+  border-radius: 2px;
+  background: rgba(255, 213, 0, 0.32);
+}
+.file-viewer-search-layer .file-viewer-search-match.current {
+  background: rgba(255, 145, 0, 0.6);
+}
+
+/* Change-tint trail: tint recently typed runs so the latest edits stand out,
+   sequenced new→old across tiers (.tier-0 newest … .tier-17 oldest). Each tier
+   shifts hue green→teal→blue and fades, so the freshest keystrokes read brightest
+   and older runs cool off before the idle decay retires them. Sits below the
+   textarea like the other overlays, so the tint paints behind the editable
+   glyphs. Fixed rgba so it reads on both light and dark themes (color-mix/theme
+   vars are unreliable on WebKitGTK here). Must stay in sync with CHANGE_TIERS. */
+.file-viewer-change-layer .file-viewer-change-mark {
+  border-radius: 2px;
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-0 {
+  background: rgba(63, 185, 80, 0.34);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-1 {
+  background: rgba(64, 181, 88, 0.33);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-2 {
+  background: rgba(65, 177, 95, 0.31);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-3 {
+  background: rgba(66, 173, 103, 0.30);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-4 {
+  background: rgba(67, 169, 111, 0.28);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-5 {
+  background: rgba(67, 165, 118, 0.27);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-6 {
+  background: rgba(68, 161, 126, 0.25);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-7 {
+  background: rgba(69, 157, 134, 0.24);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-8 {
+  background: rgba(70, 153, 141, 0.22);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-9 {
+  background: rgba(71, 148, 149, 0.21);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-10 {
+  background: rgba(72, 144, 156, 0.19);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-11 {
+  background: rgba(73, 140, 164, 0.18);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-12 {
+  background: rgba(74, 136, 172, 0.16);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-13 {
+  background: rgba(74, 132, 179, 0.15);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-14 {
+  background: rgba(75, 128, 187, 0.13);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-15 {
+  background: rgba(76, 124, 195, 0.12);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-16 {
+  background: rgba(77, 120, 202, 0.10);
+}
+.file-viewer-change-layer .file-viewer-change-mark.tier-17 {
+  background: rgba(78, 116, 210, 0.09);
+}
+
+/* Deletion ghosts: the counterpart to the green change trail on the removal
+   side. Just-deleted text is injected back at the spot it vanished and shown in
+   red with a strike-through, then fades out over DELETE_GHOST_MS (kept in sync
+   with `fv-delete-fade` below). The mark carries an OPAQUE panel background so it
+   cleanly masks whatever live text now occupies that position (the rest of the
+   injected layer reflows transparently and never paints). Fixed red so it reads
+   on both light and dark themes, matching the grammar spelling red. */
+.file-viewer-delete-layer .file-viewer-delete-mark {
+  color: #f85149;
+  background: var(--bg-panel, #1f2430);
+  text-decoration: line-through;
+  text-decoration-color: #f85149;
+  border-radius: 2px;
+  animation: fv-delete-fade 2600ms ease-out forwards;
+}
+/* Retire the ghost by both fading it AND collapsing its width to nothing:
+   animating font-size shrinks the inline glyph advances (and the opaque
+   background + strike-through that scale with them) to 0, so the red run
+   shrivels toward its anchor instead of sitting — translucent — on top of the
+   live text once the opacity drops. `1em` is the inherited --code-font-size, so
+   it tracks the editor's current zoom. Held full for the first ~55% ("after some
+   time"), then shrunk away. Duration stays in sync with DELETE_GHOST_MS. */
+@keyframes fv-delete-fade {
+  0%,
+  55% {
+    opacity: 1;
+    font-size: 1em;
+  }
+  100% {
+    opacity: 0;
+    font-size: 0;
+  }
+}
+
+/* #49: recognised file links read as clickable — a dotted underline in the link
+   accent colour. Applies in both the code editor overlay and rendered markdown. */
+.file-viewer-link-layer .file-link,
+.markdown-body a.file-link {
+  text-decoration: underline dotted;
+  text-underline-offset: 2px;
+  text-decoration-color: var(--accent, #4493f8);
+}
+.markdown-body a.file-link {
+  color: var(--accent, #4493f8);
+}
+
+/* #49: hover hint advertising the open shortcut (e.g. "Ctrl+Click to open") for a
+   recognised file link, in both the LaTeX source editor and the markdown preview.
+   Anchored (position:fixed) just above the link's top-left; never blocks a click. */
+.link-open-hint {
+  position: fixed;
+  z-index: 60;
+  transform: translateY(-100%);
+  margin-top: -6px;
+  padding: 2px 7px;
+  border-radius: var(--radius-sm);
+  background: var(--bg-main, #1f2430);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  font-size: 11px;
+  line-height: 1.4;
+  white-space: nowrap;
+  pointer-events: none;
+  box-shadow: var(--shadow-2);
+}
+
+/* #67 in-editor find bar: a small floating toolbar pinned to the editor's
+   top-right (anchored to .file-viewer-code, position:relative). */
+.file-viewer-find {
+  position: absolute;
+  top: 6px;
+  right: 14px;
+  z-index: 5;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 4px 6px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-2);
+}
+.file-viewer-find-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+/* Chevron that toggles the replace row; sized to align with the inputs. */
+.file-viewer-find-toggle {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  padding: 1px 4px;
+  font-size: 11px;
+  line-height: 1.2;
+  cursor: pointer;
+}
+.file-viewer-find-toggle:hover,
+.file-viewer-find-toggle.active { color: var(--text-primary); }
+/* The replace row lines up under the find input: a leading spacer the width of
+   the chevron keeps both inputs left-aligned. */
+.file-viewer-replace-row { padding-left: 26px; }
+.file-viewer-replace-btn { white-space: nowrap; }
+.file-viewer-find-input {
+  background: var(--bg-base, var(--bg-main, var(--bg-panel)));
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 2px 6px;
+  font-size: 12px;
+  width: 150px;
+}
+.file-viewer-find-count {
+  min-width: 42px;
+  text-align: center;
+  font-size: 11px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+}
+.file-viewer-find-btn {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  padding: 1px 6px;
+  font-size: 12px;
+  line-height: 1.2;
+  cursor: pointer;
+}
+.file-viewer-find-btn:hover:not(:disabled) {
+  color: var(--text-primary);
+  border-color: var(--border-color);
+}
+.file-viewer-find-btn:disabled { opacity: 0.4; cursor: default; }
+.file-viewer-find-btn.active {
+  color: var(--accent, #4493f8);
+  border-color: var(--accent, #4493f8);
+}
+
+/* \ref/\cite key completion dropdown (LaTeX viewer). Fixed-positioned at the
+   caret so it isn't clipped by the editor's scroll; a scrollable list of keys
+   with an optional second column (the bib entry's author/year/title). */
+.file-viewer-tex-compl {
+  position: fixed;
+  z-index: 20;
+  margin: 0;
+  padding: 3px;
+  list-style: none;
+  min-width: 160px;
+  max-width: 460px;
+  max-height: 260px;
+  overflow-y: auto;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-2);
+  font-size: 12px;
+}
+.file-viewer-tex-compl-item {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 3px 8px;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  white-space: nowrap;
+}
+.file-viewer-tex-compl-item.active {
+  background: var(--accent);
+  color: var(--accent-contrast);
+}
+.file-viewer-tex-compl-key {
+  font-family: var(--font-mono, monospace);
+  color: var(--text-primary);
+}
+.file-viewer-tex-compl-item.active .file-viewer-tex-compl-key { color: var(--accent-contrast); }
+.file-viewer-tex-compl-detail {
+  flex: 1 1 auto;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  color: var(--text-muted);
+  font-size: 11px;
+}
+.file-viewer-tex-compl-item.active .file-viewer-tex-compl-detail {
+  color: rgba(255, 255, 255, 0.85);
+}
+
+/* Soft-wrap mode (LaTeX viewer): wrap long lines to the editor width instead of
+   scrolling horizontally. The textarea (wrap="soft") and all overlay <pre> layers
+   must wrap identically — same width, same break rules — so the caret, coloured
+   glyphs and link spans stay aligned. overflow-wrap:anywhere breaks tokens with no
+   break point (long URLs/paths) at the edge rather than overflowing. With no
+   horizontal scroll, the editor's overflow-x is hidden. */
+.file-viewer-code-area.is-wrapped .file-viewer-code-editor,
+.file-viewer-code-area.is-wrapped .file-viewer-highlight,
+.file-viewer-code-area.is-wrapped .file-viewer-link-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-search-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-change-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-delete-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-grammar-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-ghost {
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  word-break: normal;
+}
+/* The overlay layers are pinned to the textarea's content width (excluding its
+   vertical scrollbar) via an inline width, so they wrap line-for-line with the
+   caret. Drop the defaults that would otherwise force them back to the full box
+   width (min-width:100% on the highlight, right:0 from inset on the others). */
+.file-viewer-code-area.is-wrapped .file-viewer-highlight,
+.file-viewer-code-area.is-wrapped .file-viewer-link-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-search-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-change-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-delete-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-grammar-layer,
+.file-viewer-code-area.is-wrapped .file-viewer-ghost {
+  min-width: 0;
+  right: auto;
+}
+.file-viewer-code-area.is-wrapped .file-viewer-code-editor {
+  overflow-x: hidden;
+}
+
+/* #45 ghost text: the accepted-on-Tab autocomplete suggestion, dimmed inline. */
+/* The ghost shows the whole projected document (prefix + suggestion + shifted
+   suffix) over an opaque background, masking the highlight/search/etc. layers so
+   the proposal displaces the existing text rather than overlaying it. Base text
+   renders in the normal colour; only the suggestion span is tinted. Syntax
+   colours are dropped for the brief moment a suggestion is on screen. */
+.file-viewer-ghost {
+  color: var(--text-primary);
+  background: var(--bg-panel);
+}
+.file-viewer-ghost-text {
+  /* Distinct from the edited text so an auto-suggestion reads as a proposal,
+     not committed content. Accent-tinted + italic; Tab accepts it. */
+  color: var(--accent, #4493f8);
+  opacity: 0.85;
+  font-style: italic;
+}
+
+/* While a suggestion is on screen the opaque ghost shows the projected text, so
+   hide the textarea's own glyphs (keeping the caret) — even in plain-text mode
+   where there is no highlight layer making them transparent already. */
+.file-viewer-code-area.has-suggestion .file-viewer-code-editor {
+  color: transparent;
+  -webkit-text-fill-color: transparent;
+  caret-color: var(--text-primary);
+}
+
+/* #45 autocomplete status toast: a small floating pill in the editor's
+   bottom-right reporting an in-flight/empty/unavailable completion so the
+   feature never fails silently. pointer-events:none so it never blocks a click. */
+.file-viewer-ac-status {
+  position: absolute;
+  right: 10px;
+  bottom: 8px;
+  z-index: 6;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 80%;
+  padding: 3px 9px;
+  font-size: 11px;
+  line-height: 1.3;
+  color: var(--text-primary);
+  /* --bg-elevated/--bg-secondary are never defined, so this used to pin to a
+     hardcoded dark (#1c2128): dark-on-dark and unreadable on light themes. Use
+     the defined panel token so the pill contrasts its --text-primary on every
+     theme. */
+  background: var(--bg-panel, #1c2128);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  box-shadow: var(--shadow-2);
+  pointer-events: none;
+}
+
+/* Grammar-check status pill: same look as the autocomplete pill, stacked just
+   above it (bottom offset) so the two never overlap when both are visible. */
+.file-viewer-grammar-status {
+  position: absolute;
+  right: 10px;
+  bottom: 36px;
+  z-index: 6;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  max-width: 80%;
+  padding: 3px 9px;
+  font-size: 11px;
+  line-height: 1.3;
+  color: var(--text-primary);
+  background: var(--bg-panel, #1c2128);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  box-shadow: var(--shadow-2);
+  pointer-events: none;
+}
+
+/* In-flight spinner inside the autocomplete status pill (reuses file-viewer-spin). */
+.file-viewer-ac-spinner {
+  display: inline-block;
+  flex: none;
+  width: 10px;
+  height: 10px;
+  border: 2px solid var(--border-color);
+  border-top-color: var(--accent, #4493f8);
+  border-radius: 50%;
+  animation: file-viewer-spin 0.7s linear infinite;
+}
+
+/* #45 context-files bar: attach project files as read-only autocomplete context.
+   Pinned bottom-left (the status pill sits bottom-right) so the two never collide. */
+.file-viewer-ac-context {
+  position: absolute;
+  left: 10px;
+  bottom: 8px;
+  z-index: 6;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 5px;
+  max-width: 60%;
+}
+
+.file-viewer-ac-context-add {
+  flex: none;
+  padding: 2px 8px;
+  font-size: 11px;
+  line-height: 1.3;
+  color: var(--text-secondary, var(--text-primary));
+  /* --bg-elevated/--bg-secondary are undefined, so this used to pin to a dark
+     #1c2128 — unreadable on light themes. Use the defined panel token. */
+  background: var(--bg-panel, #1c2128);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  opacity: 0.75;
+}
+.file-viewer-ac-context-add:hover {
+  opacity: 1;
+  color: var(--text-primary);
+}
+
+.file-viewer-ac-context-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  max-width: 160px;
+  padding: 2px 4px 2px 8px;
+  font-size: 11px;
+  line-height: 1.3;
+  color: var(--text-primary);
+  background: var(--bg-panel, #1c2128);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.file-viewer-ac-context-chip > button {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 14px;
+  height: 14px;
+  padding: 0;
+  font-size: 13px;
+  line-height: 1;
+  color: var(--text-secondary, var(--text-primary));
+  background: transparent;
+  border: none;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+}
+.file-viewer-ac-context-chip > button:hover {
+  color: var(--text-primary);
+  /* Neutral gray reads on both light and dark panels (the white fallback was
+     invisible on light themes). */
+  background: var(--bg-hover, rgba(127, 127, 127, 0.18));
+}
+
+/* #47 save-state icon button: square-ish, icon-only. */
+.file-viewer-save .file-viewer-save-icon.dirty { color: var(--warning, #d29922); }
+.file-viewer-save .file-viewer-save-icon.clean { color: var(--success, #3fb950); }
+.file-viewer-save-spinner,
+.file-viewer-tex-spinner {
+  display: inline-block;
+  width: 11px;
+  height: 11px;
+  border: 2px solid var(--border-color);
+  border-top-color: var(--accent, #4493f8);
+  border-radius: 50%;
+  animation: file-viewer-spin 0.7s linear infinite;
+}
+@keyframes file-viewer-spin {
+  to { transform: rotate(360deg); }
+}
+
+/* #46 undo/redo toolbar. */
+.file-viewer-history {
+  display: inline-flex;
+  gap: 2px;
+}
+.file-viewer-history-btn {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 1px 6px;
+  font-size: 11px;
+  line-height: 1;
+  cursor: pointer;
+}
+.file-viewer-history-btn:disabled { opacity: 0.45; cursor: default; }
+.file-viewer-history-btn:not(:disabled):hover {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+/* #43 external-change reconcile banner (non-destructive). */
+.file-viewer-reload-banner {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 10px;
+  font-size: 11px;
+  background: color-mix(in srgb, var(--warning, #d29922) 18%, var(--bg-panel));
+  color: var(--text-primary);
+  border-bottom: 1px solid var(--border-color);
+}
+.file-viewer-reload-btn {
+  background: transparent;
+  color: var(--accent, #4493f8);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 1px 8px;
+  font-size: 11px;
+  cursor: pointer;
+}
+.file-viewer-reload-btn:hover { border-color: var(--accent, #4493f8); }
+
+/* #54 TeX compiler-options panel + actions. */
+.file-viewer-tex-options {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 10px;
+  padding: 6px 10px;
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-panel);
+  font-size: 11px;
+}
+.file-viewer-tex-option {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  color: var(--text-muted);
+}
+.file-viewer-tex-option input {
+  background: var(--bg-base, var(--bg-panel));
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 2px 6px;
+  font-size: 11px;
+  min-width: 160px;
+}
+.file-viewer-tex-options-note {
+  flex-basis: 100%;
+  margin: 0;
+  color: var(--text-muted);
+  font-size: 10px;
+}
+.file-viewer-tex-options-toggle,
+.file-viewer-tex-open-pdf {
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 1px 8px;
+  font-size: 10px;
+  cursor: pointer;
+}
+.file-viewer-tex-options-toggle.active,
+.file-viewer-tex-options-toggle:hover,
+.file-viewer-tex-open-pdf:hover {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+/* #48 per-type native-viewer settings section. */
+.viewer-prefs-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.viewer-pref-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  font-size: 11px;
+}
+.viewer-pref-name { min-width: 96px; color: var(--text-primary); }
+.viewer-pref-exts { color: var(--text-muted); font-size: 10px; flex: 1; }
+.viewer-pref-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  color: var(--text-muted);
+}
+/* #45 per-type default completion-length mode (Sentence/Block/Scope). */
+.viewer-pref-mode {
+  font-size: 10px;
+  padding: 1px 4px;
+  color: var(--text-primary);
+  background: var(--bg-secondary, var(--bg-primary));
+  border: 1px solid var(--border, #444);
+  border-radius: var(--radius-sm);
+}
+.viewer-pref-mode:disabled { opacity: 0.5; }
+
+/* pdf.js viewer: a zoom toolbar above a scrolling stack of page canvases. The
+   host and scroll surround use theme variables, so the viewer is dark in dark
+   themes; the page canvases stay white sheets (rendered as authored). The scroll
+   area's scrollbar is themed by the global *::-webkit-scrollbar rules. */
+.file-viewer-pdf-host {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+}
+
+.file-viewer-pdf-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 3px 8px;
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-panel);
+  flex-shrink: 0;
+}
+
+/* Push the optional "Open externally" button to the toolbar's trailing edge. */
+.file-viewer-pdf-external {
+  margin-left: auto;
+}
+
+/* Wraps the scroll area so the find-match marker rail can overlay its native
+   scrollbar without scrolling along with the content. Row flex so the scroll
+   area fills it; min-height/min-width:0 lets it shrink within the host column. */
+.file-viewer-pdf-scroll-wrap {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  min-width: 0;
+  display: flex;
+}
+
+.file-viewer-pdf-scroll {
+  flex: 1;
+  min-height: 0;
+  min-width: 0;
+  overflow: auto;
+  padding: 12px;
+  background: var(--bg-main);
+}
+/* The scroll area is focusable (tabIndex) so Ctrl+F works without first clicking
+   a control; suppress the focus ring — the page content carries no caret. */
+.file-viewer-pdf-scroll:focus { outline: none; }
+
+/* Page-number divider under each page: a muted "N / total" label flanked by
+   dashed rules, so page boundaries and numbers are identifiable while
+   scrolling. Lives inside the page wrap (below the canvas) so overlays and the
+   search-marker math, both anchored to the wrap's top, are unaffected. The
+   label itself provides the whole inter-page gap (the pages stack has gap: 0)
+   and vertically centers its text, so the number sits midway between pages.
+   The wrap zeroes line-height for the canvas; restore it here. */
+.file-viewer-pdf-page-gap {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  height: 28px;
+  line-height: normal;
+  font-size: 10px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+  user-select: none;
+}
+
+.file-viewer-pdf-page-gap::before,
+.file-viewer-pdf-page-gap::after {
+  content: "";
+  flex: 1;
+  border-top: 1px dashed var(--border-color);
+}
+
+/* #71 search-match markers: a non-interactive rail laid over the scroll area's
+   native scrollbar, one tick per Ctrl+F hit at its fractional document position
+   so off-screen matches stay locatable. pointer-events:none keeps the scrollbar
+   draggable; the current match's tick is brighter and a touch larger (mirrors
+   the on-page hit colours). */
+.file-viewer-pdf-search-rail {
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: 16px;
+  height: 100%;
+  pointer-events: none;
+  z-index: 2;
+}
+/* Ticks are wider than the 8px scrollbar so they protrude past the thumb into
+   the page margin (a clear notch), and carry a 1px dark ring so the fixed yellow
+   reads over both the light PDF area and the accent-coloured scrollbar thumb. */
+.file-viewer-pdf-search-tick {
+  position: absolute;
+  right: 1px;
+  width: 12px;
+  height: 4px;
+  border-radius: 2px;
+  background: rgba(255, 213, 0, 1);
+  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.55);
+  transform: translateY(-2px);
+}
+/* The current match spans the full rail, is taller/orange, and sits above the
+   normal ticks so an adjacent hit never hides it. */
+.file-viewer-pdf-search-tick.current {
+  right: 0;
+  width: 16px;
+  height: 5px;
+  background: rgba(229, 110, 0, 1);
+  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.7);
+  transform: translateY(-2.5px);
+  z-index: 1;
+}
+
+/* #71: the Ctrl+F bar for the native PDF viewer renders as a static row
+   between the zoom toolbar and the page stack (overriding the editor find bar's
+   floating position so it never covers the toolbar's trailing buttons). */
+.file-viewer-find-pdf {
+  position: static;
+  flex-direction: row;
+  align-items: center;
+  border: none;
+  border-bottom: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  box-shadow: none;
+  background: var(--bg-panel);
+  flex-shrink: 0;
+}
+
+/* #71: a translucent box over each search hit on the page canvas; the
+   current match is brighter. Fixed rgba so it reads over white PDF pages in both
+   light and dark themes (mirrors the editor's search highlight colours). */
+.file-viewer-pdf-search-hit {
+  position: absolute;
+  pointer-events: none;
+  border-radius: 1px;
+  background: rgba(255, 213, 0, 0.4);
+}
+.file-viewer-pdf-search-hit.current {
+  background: rgba(255, 145, 0, 0.6);
+  outline: 1px solid rgba(229, 110, 0, 0.9);
+}
+
+/* The page stack lives in an inner wrapper so a Ctrl+wheel zoom can grow it past
+   the viewport and scroll horizontally. min-width:min-content lets the wrapper
+   expand to the widest page (enabling horizontal scroll when zoomed in) while
+   align-items:center keeps narrower pages centred. */
+.file-viewer-pdf-pages {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  /* Inter-page spacing comes from each wrap's page-gap divider, whose label
+     centers vertically within it — no flex gap on top of that. */
+  gap: 0;
+  min-width: min-content;
+}
+
+.file-viewer-pdf-page {
+  display: block;
+  max-width: 100%;
+  background: #fff;
+  box-shadow: var(--shadow-2);
+}
+
+/* LaTeX viewer: a compile toolbar above a source-editor | PDF-preview split.
+   With no TeX engine on PATH the viewer renders just the plain code editor (the
+   compile controls/split below are never mounted), so it degrades to the text
+   viewer. The compile controls live in the shared header row (ViewerHeader),
+   not on a separate toolbar line. */
+.file-viewer-tex-compile {
+  background: var(--accent, #4493f8);
+  color: var(--accent-contrast);
+  border: 0;
+  border-radius: var(--radius-sm);
+  padding: 2px 10px;
+  font-size: 11px;
+  cursor: pointer;
+}
+
+.file-viewer-tex-compile:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+
+/* Inherits the shared Dropdown look; only the toolbar's compact sizing differs. */
+.file-viewer-tex-engine .dropdown-trigger {
+  min-height: 0;
+  padding: 1px 6px;
+  font-size: 11px;
+}
+
+.file-viewer-tex-spinner {
+  width: 12px;
+  height: 12px;
+  border: 2px solid var(--border-color);
+  border-top-color: var(--accent, #4493f8);
+  border-radius: 50%;
+  animation: file-viewer-tex-spin 0.7s linear infinite;
+}
+
+@keyframes file-viewer-tex-spin {
+  to { transform: rotate(360deg); }
+}
+
+/* Compile run animation: while a build is in flight the button shows an
+   indeterminate sliding sheen and a thin progress strip animates under the
+   header, so a multi-second parent build reads as live. Both derive purely from
+   the `compiling` flag (the `.is-compiling` class / mounted strip). */
+.file-viewer-tex-compile.is-compiling {
+  background-image: linear-gradient(
+    100deg,
+    transparent 20%,
+    rgba(255, 255, 255, 0.35) 50%,
+    transparent 80%
+  );
+  background-size: 200% 100%;
+  background-repeat: no-repeat;
+  animation: file-viewer-tex-sheen 1.1s linear infinite;
+}
+
+@keyframes file-viewer-tex-sheen {
+  from { background-position: 200% 0; }
+  to { background-position: -200% 0; }
+}
+
+.file-viewer-tex-progress {
+  flex-shrink: 0;
+  height: 2px;
+  overflow: hidden;
+  background: color-mix(in srgb, var(--accent, #4493f8) 22%, transparent);
+}
+
+.file-viewer-tex-progress-bar {
+  height: 100%;
+  width: 40%;
+  background: var(--accent, #4493f8);
+  animation: file-viewer-tex-progress-slide 1.1s ease-in-out infinite;
+}
+
+@keyframes file-viewer-tex-progress-slide {
+  from { transform: translateX(-100%); }
+  to { transform: translateX(350%); }
+}
+
+/* SyncTeX (#56): each PDF page sits in a positioned wrapper so a forward-search
+   highlight box can overlay it; a syncable page shows a crosshair to hint that a
+   click jumps to the source. */
+.file-viewer-pdf-page-wrap {
+  position: relative;
+  line-height: 0;
+  max-width: 100%;
+}
+
+.file-viewer-pdf-page.is-syncable {
+  cursor: crosshair;
+}
+
+.file-viewer-pdf-sync-highlight {
+  position: absolute;
+  pointer-events: none;
+  background: color-mix(in srgb, var(--accent, #4493f8) 38%, transparent);
+  border: 1px solid var(--accent, #4493f8);
+  border-radius: 2px;
+  animation: file-viewer-pdf-sync-fade 1.6s ease-out forwards;
+}
+
+@keyframes file-viewer-pdf-sync-fade {
+  0% { opacity: 0; }
+  15% { opacity: 1; }
+  100% { opacity: 0; }
+}
+
+/* Reverse-search click feedback (#56): a small ring centred on the point the
+   reader Ctrl/⌘-clicked in the PDF, pulsing then fading over ~2s, so the
+   source-jump is visibly anchored on the PDF side too. Margin centres the 16px
+   marker on its (left,top) click coordinate. */
+.file-viewer-pdf-click-mark {
+  position: absolute;
+  pointer-events: none;
+  width: 16px;
+  height: 16px;
+  margin: -8px 0 0 -8px;
+  border-radius: 50%;
+  background: color-mix(in srgb, var(--accent, #4493f8) 40%, transparent);
+  border: 1.5px solid var(--accent, #4493f8);
+  animation: file-viewer-pdf-click-fade 2s ease-out forwards;
+}
+
+@keyframes file-viewer-pdf-click-fade {
+  0% { opacity: 0; transform: scale(0.4); }
+  12% { opacity: 1; transform: scale(1); }
+  100% { opacity: 0; transform: scale(1.7); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .file-viewer-tex-compile.is-compiling {
+    animation: none;
+    background-image: none;
+  }
+  .file-viewer-tex-progress-bar {
+    width: 100%;
+    animation: none;
+    opacity: 0.7;
+  }
+  /* Hold a static highlight briefly rather than animating its opacity. */
+  .file-viewer-pdf-sync-highlight {
+    animation: none;
+    opacity: 1;
+  }
+  .file-viewer-pdf-click-mark {
+    animation: none;
+    opacity: 1;
+  }
+}
+
+/* Shell-escape warning banner: shown when a compile ran with \write18 active
+   despite our args never enabling it. Amber, distinct from the red error rows. */
+.file-viewer-tex-shell-warning {
+  flex-shrink: 0;
+  padding: 8px 12px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--warning, #d29922);
+  background: color-mix(in srgb, var(--warning, #d29922) 12%, transparent);
+  border-bottom: 1px solid var(--warning, #d29922);
+}
+
+.file-viewer-tex-shell-warning code {
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 11px;
+}
+
+/* Transient, low-key info notice: a forward-search (caret → PDF) miss after a
+   successful compile. Muted/informational, distinct from the warning + error
+   styles above so it doesn't read as a failure. */
+.file-viewer-tex-sync-miss {
+  flex-shrink: 0;
+  padding: 6px 12px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--text-muted);
+  background: var(--bg-subtle, rgba(127, 127, 127, 0.08));
+  border-bottom: 1px solid var(--border-color);
+}
+
+/* Build-log error area: a terse last line, plus an expandable full log. */
+.file-viewer-tex-log-error {
+  flex-shrink: 0;
+  max-height: 40%;
+  overflow: auto;
+}
+
+.file-viewer-tex-log-line {
+  font-weight: 600;
+}
+
+.file-viewer-tex-log-toggle {
+  margin-top: 4px;
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 1px 6px;
+  font-size: 10px;
+  cursor: pointer;
+}
+
+/* Jump-to-error list under a failed compile. Each row is a button: a
+   monospace `file:line` chip plus the TeX message. */
+.file-viewer-tex-errors {
+  list-style: none;
+  margin: 6px 0 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.file-viewer-tex-error-jump {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  width: 100%;
+  text-align: left;
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  padding: 2px 6px;
+  cursor: pointer;
+  color: var(--text-primary);
+  font-size: 11px;
+}
+
+.file-viewer-tex-error-jump:hover {
+  background: var(--bg-input, var(--bg-panel));
+  border-color: var(--border-color);
+}
+
+.file-viewer-tex-error-loc {
+  flex-shrink: 0;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-weight: 600;
+  color: var(--accent, var(--text-primary));
+}
+
+.file-viewer-tex-error-msg {
+  color: var(--text-muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-viewer-tex-log {
+  margin: 6px 0 0;
+  padding: 8px;
+  background: var(--bg-input, var(--bg-panel));
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-primary);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/* Rendered markdown. Fills the full pane width — paragraphs reflow to the
+   window so a wide window uses the whole line (no fixed readable-column cap). */
+.markdown-body {
+  padding: 16px 22px;
+  font-size: 13px;
+  line-height: 1.65;
+}
+
+.markdown-body > :first-child { margin-top: 0; }
+.markdown-body > :last-child { margin-bottom: 0; }
+
+.markdown-body h1,
+.markdown-body h2,
+.markdown-body h3,
+.markdown-body h4,
+.markdown-body h5,
+.markdown-body h6 {
+  margin: 1.4em 0 0.55em;
+  line-height: 1.25;
+  font-weight: 650;
+  letter-spacing: -0.01em;
+}
+
+/* h1/h2 lean on the theme's two signature hues (same pairing the settings
+   dialog uses for its title vs. section headings) instead of plain
+   --text-primary, so a document's structure reads at a glance; the
+   underlines fade out via the accent color itself rather than a flat
+   --border-color rule, echoing the accent-tinted borders used across the
+   rest of the glass chrome. h3+ stay text-colored (too many accent tiers
+   reads as noise) but pick up a small accent marker instead. */
+.markdown-body h1 {
+  font-size: 1.8em;
+  color: var(--accent);
+  border-bottom: 2px solid color-mix(in srgb, var(--accent) 40%, transparent);
+  padding-bottom: 0.3em;
+}
+.markdown-body h2 {
+  font-size: 1.45em;
+  color: var(--accent-secondary, var(--accent));
+  border-bottom: 1px solid color-mix(in srgb, var(--accent-secondary, var(--accent)) 35%, transparent);
+  padding-bottom: 0.25em;
+}
+.markdown-body h3 { font-size: 1.2em; }
+.markdown-body h3::before {
+  content: "";
+  display: inline-block;
+  width: 6px;
+  height: 6px;
+  margin-right: 0.55em;
+  margin-bottom: 0.1em;
+  border-radius: 50%;
+  background: var(--accent);
+  vertical-align: middle;
+}
+.markdown-body h4 { font-size: 1.05em; }
+.markdown-body h5 { font-size: 0.95em; }
+.markdown-body h6 { font-size: 0.9em; color: var(--text-muted); }
+
+.markdown-body p { margin: 0.65em 0; }
+
+.markdown-body a { color: var(--accent, #4493f8); text-decoration: none; }
+.markdown-body a:hover { text-decoration: underline; }
+
+.markdown-body strong { font-weight: 650; color: var(--text-primary); }
+
+.markdown-body code {
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 0.88em;
+  color: var(--accent-secondary, var(--accent));
+  background: color-mix(in srgb, var(--accent-secondary, var(--accent)) 12%, var(--bg-input, rgba(127, 127, 127, 0.15)));
+  padding: 0.12em 0.35em;
+  border-radius: var(--radius-sm);
+}
+
+.markdown-body pre {
+  position: relative;
+  background: var(--bg-input, rgba(127, 127, 127, 0.12));
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  padding: 11px 13px;
+  overflow-x: auto;
+  margin: 0.8em 0;
+  /* A faint top accent rail — enough to tie code blocks into the same
+     accent language as the headings/tables without competing with the
+     syntax-highlighted content inside. */
+  box-shadow: inset 0 2px 0 color-mix(in srgb, var(--accent) 30%, transparent);
+}
+
+/* Language label on fenced code blocks (set from the info string). */
+.markdown-body pre.md-code[data-lang]::before {
+  content: attr(data-lang);
+  position: absolute;
+  top: 0;
+  right: 0;
+  padding: 1px 7px;
+  font-size: 0.68em;
+  font-family: var(--font-mono, ui-monospace, monospace);
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--text-muted);
+  background: var(--bg-secondary, rgba(127, 127, 127, 0.18));
+  border-left: 1px solid var(--border-color);
+  border-bottom: 1px solid var(--border-color);
+  border-bottom-left-radius: 5px;
+  border-top-right-radius: 5px;
+  pointer-events: none;
+}
+
+.markdown-body pre code {
+  /* Undo the inline-code accent tint above — this is the syntax-highlighted
+     case (.tok-* spans set their own colors) and a flat accent color here
+     would wash out over every un-highlighted token. */
+  color: var(--text-primary);
+  background: none;
+  padding: 0;
+  font-size: 0.85em;
+  line-height: 1.5;
+}
+
+.markdown-body blockquote {
+  margin: 0.8em 0;
+  padding: 0.35em 0.95em;
+  border-left: 3px solid var(--accent, var(--border-color));
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  background: color-mix(in srgb, var(--accent) 6%, transparent);
+  color: var(--text-muted);
+}
+
+.markdown-body blockquote > :first-child { margin-top: 0; }
+.markdown-body blockquote > :last-child { margin-bottom: 0; }
+
+.markdown-body ul,
+.markdown-body ol { margin: 0.55em 0; padding-left: 1.6em; }
+.markdown-body li { margin: 0.22em 0; }
+.markdown-body li > ul,
+.markdown-body li > ol { margin: 0.22em 0; }
+
+/* GitHub-style task list items. */
+.markdown-body li.task-item {
+  list-style: none;
+  margin-left: -1.35em;
+  display: flex;
+  align-items: flex-start;
+  gap: 0.5em;
+}
+.markdown-body li.task-item > input[type="checkbox"] {
+  margin: 0.32em 0 0;
+  accent-color: var(--accent);
+  flex: 0 0 auto;
+}
+
+.markdown-body hr {
+  border: 0;
+  height: 1px;
+  margin: 1.4em 0;
+  background: linear-gradient(
+    90deg,
+    transparent,
+    color-mix(in srgb, var(--accent) 45%, var(--border-color)) 20%,
+    color-mix(in srgb, var(--accent) 45%, var(--border-color)) 80%,
+    transparent
+  );
+}
+
+.markdown-body img {
+  max-width: 100%;
+  border-radius: var(--radius-sm);
+}
+
+/* Tables: rounded frame, header tint, zebra striping. */
+.markdown-body table,
+.markdown-body table.md-table {
+  border-collapse: collapse;
+  margin: 0.9em 0;
+  width: auto;
+  max-width: 100%;
+  border: 1px solid color-mix(in srgb, var(--accent) 25%, var(--border-color));
+  border-radius: var(--radius);
+  overflow: hidden;
+  box-shadow: var(--shadow-1);
+}
+
+.markdown-body th,
+.markdown-body td {
+  border: 1px solid var(--border-color);
+  padding: 5px 11px;
+}
+
+.markdown-body thead th {
+  background: color-mix(in srgb, var(--accent) 14%, var(--bg-secondary, rgba(127, 127, 127, 0.16)));
+  color: var(--text-primary);
+  font-weight: 650;
+  text-align: left;
+  border-bottom: 2px solid color-mix(in srgb, var(--accent) 40%, transparent);
+}
+
+.markdown-body tbody tr:nth-child(even) {
+  background: var(--bg-input, rgba(127, 127, 127, 0.07));
+}
+
+.markdown-body tbody tr:hover {
+  background: color-mix(in srgb, var(--accent) 8%, transparent);
+}
+
+/* GitHub alert callouts (> [!NOTE] / [!TIP] / [!IMPORTANT] / [!WARNING] / [!CAUTION]).
+   Theme-safe: a coloured left rail + tinted title, neutral background, so no
+   color-mix is needed (avoids the WebKitGTK color-mix caveat). */
+.markdown-body .md-alert {
+  margin: 0.9em 0;
+  padding: 0.5em 0.95em;
+  border-left: 4px solid var(--border-color);
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  background: var(--bg-input, rgba(127, 127, 127, 0.08));
+}
+.markdown-body .md-alert > :first-child { margin-top: 0; }
+.markdown-body .md-alert > :last-child { margin-bottom: 0; }
+.markdown-body .md-alert-title {
+  font-weight: 650;
+  margin: 0 0 0.25em;
+  font-size: 0.92em;
+}
+
+.markdown-body .md-alert-note     { border-left-color: var(--accent); }
+.markdown-body .md-alert-note .md-alert-title { color: var(--accent); }
+.markdown-body .md-alert-tip      { border-left-color: var(--success); }
+.markdown-body .md-alert-tip .md-alert-title { color: var(--success); }
+.markdown-body .md-alert-important { border-left-color: var(--accent-secondary); }
+.markdown-body .md-alert-important .md-alert-title { color: var(--accent-secondary); }
+.markdown-body .md-alert-warning  { border-left-color: var(--warning); }
+.markdown-body .md-alert-warning .md-alert-title { color: var(--warning); }
+.markdown-body .md-alert-caution  { border-left-color: var(--danger); }
+.markdown-body .md-alert-caution .md-alert-title { color: var(--danger); }
+
+/* ── Tiling subwindows ───────────────────────────────────────────────────── */
+
+/* A split node: a flex container of children with dividers between them. The
+   layout tree (subwindow frames) fills the panel; the pane layer overlays it. */
+.split {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  overflow: hidden;
+}
+
+.split-child {
+  position: relative;
+  min-width: 0;
+  min-height: 0;
+  display: flex;
+}
+
+/* Children of a split need their own relative coordinate space so a nested
+   subwindow/split can fill them via absolute insets. The top-level layout node
+   (a direct child of the center panel) fills the panel the same way — otherwise
+   a single-group subwindow collapses to its tab-bar height and the pane layer
+   overlays the tabs. */
+.split-child > .subwindow,
+.split-child > .split,
+.center-panel > .subwindow,
+.center-panel > .split {
+  position: absolute;
+  inset: 0;
+}
+
+/* Resize divider between two split children. Wide hit area, thin visual line. */
+.split-divider {
+  flex: 0 0 auto;
+  position: relative;
+  z-index: 4;
+  background: var(--control-border);
+  transition: background-color var(--transition);
+}
+.split-divider-row {
+  width: 5px;
+  cursor: col-resize;
+}
+.split-divider-column {
+  height: 5px;
+  cursor: row-resize;
+}
+.split-divider:hover,
+.split-divider:active {
+  background: var(--accent);
+}
+
+/* Scroll-link toggle straddling a divider between two viewer subwindows.
+   Absolutely centred so it works for both row (vertical) and column
+   (horizontal) dividers; lifted above the divider so its own pointer events
+   fire instead of starting a resize drag. */
+.split-scroll-link-btn {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 5;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  padding: 0;
+  border-radius: var(--radius);
+  border: 1px solid var(--control-border);
+  background: var(--bg-panel);
+  color: var(--text-muted);
+  cursor: pointer;
+  opacity: 0.55;
+  transition: opacity var(--transition), color var(--transition), background-color var(--transition), border-color var(--transition);
+}
+.split-divider:hover .split-scroll-link-btn {
+  opacity: 1;
+}
+.split-scroll-link-btn:hover {
+  opacity: 1;
+  color: var(--text-primary);
+  border-color: var(--accent);
+}
+.split-scroll-link-btn.linked {
+  opacity: 1;
+  color: var(--accent-contrast, #fff);
+  background: var(--accent);
+  border-color: var(--accent);
+}
+
+/* A subwindow: per-group tab bar over its pane region. */
+.subwindow {
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  background-color: var(--bg-main);
+}
+/* The focused-subwindow frame + Shift-nav numbering are drawn by
+   FocusFrameOverlay above the pane layer (.focus-frame / .subwindow-number
+   below), not on .subwindow itself — an opaque pane (z-index:2) would paint
+   over an in-body frame. */
+
+.subwindow-body {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+  /* Row: the measured pane region + (optionally) the docked file-viewer
+     column on the right. With no sidebar the region simply fills the body. */
+  display: flex;
+}
+
+/* The pane region: what the pane layer measures/overlays (main window) or
+   directly holds (popout). Shrinks when the group's file-viewer column is
+   open, so panes never cover the sidebar. */
+.subwindow-pane-region {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  min-height: 0;
+}
+
+/* Empty measured slot the pane layer positions panes over. */
+.subwindow-pane-slot {
+  position: absolute;
+  inset: 0;
+}
+
+/* Per-subwindow right file viewer (◫): a docked column on the subwindow's
+   right edge hosting the shared ProjectFilesView (via ProjectFilesTab). Sits
+   BESIDE the measured pane region, so the main window's flat pane layer
+   (whose panes are sized to the region's rect) never paints over it. */
+.subwindow-files {
+  position: relative;
+  flex-shrink: 0;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  min-width: 0;
+  overflow: hidden;
+  border-left: 1px solid var(--border-color);
+  background: var(--bg-panel);
+}
+
+/* Left-edge resize handle of the file-viewer column. */
+.subwindow-files-resize {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  width: 5px;
+  cursor: col-resize;
+  z-index: 13;
+}
+.subwindow-files-resize:hover {
+  background: var(--accent);
+  opacity: 0.35;
+}
+
+/* Pane layer holds all PTYs (every scope), positioned over group bodies. The
+   wrapper is click-through; individual panes re-enable pointer events. While a
+   tab is being dragged the whole layer goes click-through so hit-testing falls
+   to the drop zones rendered in the subwindow bodies beneath. */
+.pane-layer {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  z-index: 2;
+}
+/* During a tab drag, panes go click-through so elementFromPoint can reach the
+   tab bars / subwindow bodies underneath for the hit-test. */
+.center-panel.dragging .pane-layer,
+.center-panel.dragging .center-pane {
+  pointer-events: none;
+}
+
+/* Windows: while the whole window is moved by a native title-bar drag, take the
+   heavy pane content OUT of compositing so WebView2 only paints the cheap frame
+   (tab bars / empty bodies) and can keep up with the OS-moved window — otherwise
+   the terminal canvases lag/swim behind the frame. Mirrors `.detached-center.moving`
+   (#42). `visibility: hidden` (not display:none) keeps the layout intact, so no
+   xterm reflow/refit churn — the content reappears at the same size the instant
+   the move ends. */
+.center-panel.moving .pane-layer {
+  visibility: hidden;
+}
+
+/* Each pane is absolutely positioned by CenterPanel to a group's body rect.
+   Hidden panes keep their PTY mounted via display:none. */
+.center-pane {
+  position: absolute;
+  flex-direction: column;
+  overflow: hidden;
+  pointer-events: auto;
+}
+
+/* ── 3D project blob (root "Projects" tab) ───────────────────────────────────
+   A navigable cloud of every project + box. The viewport owns the orbit/zoom
+   pointer surface; the scene is a preserve-3d space whose rotation/zoom is
+   written straight to the DOM by ProjectBlobPane's rAF loop. Nodes ride the
+   sphere via translate3d and counter-rotate to billboard toward the camera. */
+.blob-viewport {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  background:
+    radial-gradient(circle at 50% 42%, color-mix(in srgb, var(--accent) 12%, transparent) 0%, transparent 60%),
+    var(--bg-main);
+  cursor: grab;
+  user-select: none;
+  touch-action: none;
+  perspective: 1100px;
+}
+.blob-viewport:active {
+  cursor: grabbing;
+}
+.blob-empty {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.blob-empty-card {
+  padding: 16px 22px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-lg);
+  background: var(--bg-panel);
+  color: var(--text-secondary);
+  font-size: 13px;
+}
+/* Clickable path bar shown while the spherical file viewer is open. */
+.blob-breadcrumb {
+  position: absolute;
+  left: 50%;
+  top: 12px;
+  transform: translateX(-50%);
+  z-index: 4;
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  max-width: 80%;
+  padding: 4px 8px;
+  border-radius: var(--radius);
+  background: color-mix(in srgb, var(--bg-panel) 82%, transparent);
+  border: 1px solid var(--border-subtle);
+  overflow-x: auto;
+  white-space: nowrap;
+}
+.blob-crumb {
+  flex-shrink: 0;
+  padding: 2px 7px;
+  border: none;
+  border-radius: var(--radius);
+  background: transparent;
+  color: var(--text-secondary);
+  font-size: 12px;
+  cursor: pointer;
+}
+.blob-crumb:hover {
+  background: color-mix(in srgb, var(--accent) 22%, transparent);
+  color: var(--text-primary);
+}
+.blob-crumb-exit {
+  color: var(--text-muted);
+  font-size: 11px;
+}
+.blob-crumb-sep {
+  flex-shrink: 0;
+  color: var(--text-muted);
+  font-size: 11px;
+}
+.blob-crumb-loading {
+  flex-shrink: 0;
+  margin-left: 6px;
+  color: var(--text-muted);
+  font-size: 11px;
+}
+.blob-hint {
+  position: absolute;
+  left: 50%;
+  bottom: 14px;
+  transform: translateX(-50%);
+  z-index: 3;
+  padding: 4px 12px;
+  border-radius: var(--radius-full);
+  background: color-mix(in srgb, var(--bg-panel) 75%, transparent);
+  border: 1px solid var(--border-subtle);
+  color: var(--text-muted);
+  font-size: 11px;
+  pointer-events: none;
+  white-space: nowrap;
+}
+/* Sphere/Pie segmented toggle, top-right of the project cloud. */
+.blob-view-toggle {
+  position: absolute;
+  top: 12px;
+  right: 12px;
+  z-index: 5;
+  display: flex;
+  gap: 2px;
+  padding: 3px;
+  border-radius: var(--radius-full);
+  background: color-mix(in srgb, var(--bg-panel) 82%, transparent);
+  border: 1px solid var(--border-subtle);
+}
+.blob-view-toggle button {
+  padding: 3px 12px;
+  border: none;
+  border-radius: var(--radius-full);
+  background: transparent;
+  color: var(--text-secondary);
+  font-size: 11px;
+  cursor: pointer;
+}
+.blob-view-toggle button:hover {
+  color: var(--text-primary);
+}
+.blob-view-toggle button.is-active {
+  background: var(--accent);
+  color: var(--accent-contrast, #fff);
+}
+/* Pie mode: flat chart, so drop the grab cursor + 3D perspective. */
+.blob-viewport-pie {
+  cursor: default;
+  perspective: none;
+}
+.blob-pie-stage {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 56px 16px 48px;
+}
+.blob-pie-svg {
+  width: 100%;
+  height: 100%;
+  max-width: 560px;
+  max-height: 560px;
+  overflow: visible;
+}
+.blob-pie-slice path {
+  stroke: var(--bg-main);
+  stroke-width: 2;
+  cursor: pointer;
+  transition: opacity var(--transition);
+}
+.blob-pie-slice:hover path {
+  opacity: 0.82;
+}
+.blob-pie-slice.is-active path {
+  stroke: var(--text-primary);
+  stroke-width: 3;
+}
+.blob-pie-label {
+  fill: var(--bg-main);
+  font-size: 9px;
+  font-weight: 600;
+  pointer-events: none;
+  paint-order: stroke;
+  stroke: color-mix(in srgb, var(--text-primary) 35%, transparent);
+  stroke-width: 0.4;
+}
+.blob-pie-center {
+  fill: var(--text-primary);
+  font-size: 14px;
+  font-weight: 600;
+}
+.blob-pie-center-sub {
+  fill: var(--text-muted);
+  font-size: 11px;
+}
+.blob-pie-empty {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: var(--text-muted);
+  font-size: 13px;
+}
+.blob-stage {
+  position: absolute;
+  inset: 0;
+  transform-style: preserve-3d;
+}
+.blob-scene {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  width: 0;
+  height: 0;
+  transform-style: preserve-3d;
+  will-change: transform;
+}
+.blob-node {
+  position: absolute;
+  /* Center each card on its sphere point (translate3d in the inline transform). */
+  left: -70px;
+  top: -16px;
+  width: 140px;
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  padding: 5px 10px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border-subtle);
+  background: color-mix(in srgb, var(--bg-panel) 92%, transparent);
+  color: var(--text-primary);
+  font-size: 12px;
+  cursor: pointer;
+  will-change: transform;
+  transition: border-color var(--transition), box-shadow var(--transition), background var(--transition);
+}
+.blob-node:hover {
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px color-mix(in srgb, var(--accent) 35%, transparent);
+  background: var(--bg-panel);
+}
+.blob-node-icon {
+  flex-shrink: 0;
+  font-size: 11px;
+  line-height: 1;
+}
+.blob-node-label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.blob-node-sub {
+  margin-left: auto;
+  flex-shrink: 0;
+  padding: 0 6px;
+  border-radius: var(--radius-full);
+  background: color-mix(in srgb, var(--accent-secondary) 25%, transparent);
+  color: var(--text-secondary);
+  font-size: 10px;
+}
+/* Status coloring of the leading dot/glyph + accents. */
+.blob-status-current .blob-node-icon { color: var(--accent); }
+.blob-status-active .blob-node-icon { color: var(--success); }
+.blob-status-inactive { opacity: 0.55; }
+.blob-status-inactive .blob-node-icon { color: var(--text-muted); }
+.blob-node-box .blob-node-icon { color: var(--accent-secondary); }
+.blob-node-box { border-style: dashed; }
+.blob-node-active {
+  border-color: var(--accent);
+  box-shadow: 0 0 0 2px var(--accent), 0 0 18px color-mix(in srgb, var(--accent) 45%, transparent);
+}
+/* The focused project, pinned at the center of the spherical file viewer. */
+.blob-node-center {
+  border-color: var(--accent);
+  background: var(--bg-panel);
+  font-weight: 600;
+  box-shadow: 0 0 0 2px var(--accent), 0 0 24px color-mix(in srgb, var(--accent) 55%, transparent);
+}
+.blob-node-center .blob-node-icon { color: var(--accent); }
+/* File/folder nodes orbiting the focused project. */
+.blob-file-dir .blob-node-icon,
+.blob-file-doc .blob-node-icon { font-size: 13px; }
+.blob-file-dir { border-color: color-mix(in srgb, var(--accent-secondary) 55%, var(--border-subtle)); }
+.blob-file-dir .blob-node-label { font-weight: 500; }
+/* A project node tinted by its primary category color (grouping in the cloud).
+   The leading dot + a left accent stripe take the category hue. */
+.blob-node-categorized {
+  border-color: color-mix(in srgb, var(--cat-color) 60%, var(--border-subtle));
+  box-shadow: inset 3px 0 0 var(--cat-color);
+}
+.blob-node-categorized .blob-node-icon { color: var(--cat-color); }
+.blob-node-categorized:hover {
+  border-color: var(--cat-color);
+  box-shadow: inset 3px 0 0 var(--cat-color),
+    0 0 0 2px color-mix(in srgb, var(--cat-color) 35%, transparent);
+}
+/* Category chips inside the hover info card. */
+.blob-hover-categories {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 6px;
+}
+.blob-hover-category {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 1px 7px 1px 5px;
+  border-radius: var(--radius-full);
+  font-size: 10px;
+  color: var(--text-secondary);
+  background: color-mix(in srgb, var(--cat-color) 18%, transparent);
+  border: 1px solid color-mix(in srgb, var(--cat-color) 45%, transparent);
+}
+.blob-hover-category-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--cat-color);
+}
+/* Pointer-anchored info card shown while hovering a node (project description /
+   box details). Rendered in a body portal so it's never clipped or scaled by
+   the 3D scene. */
+.blob-hover-card {
+  position: fixed;
+  z-index: 40;
+  width: max-content;
+  max-width: 760px;
+  padding: 10px 12px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius);
+  background: var(--bg-elevated);
+  box-shadow: var(--shadow-3);
+  pointer-events: none;
+}
+.blob-hover-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.blob-hover-meta {
+  margin-top: 2px;
+  font-size: 11px;
+  text-transform: capitalize;
+  color: var(--accent);
+}
+.blob-hover-desc {
+  margin-top: 6px;
+  max-width: 360px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--text-secondary);
+  display: -webkit-box;
+  -webkit-line-clamp: 4;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+/* The embedded GitHub-style activity heatmap inside the hover card. The card is
+   pointer-events:none, so the calendar reads as a static "how much I worked"
+   strip — its per-cell tooltips intentionally don't fire here. */
+.blob-hover-activity {
+  margin-top: 10px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border-subtle);
+}
+.blob-hover-hint {
+  margin-top: 8px;
+  font-size: 10px;
+  color: var(--text-muted);
+}
+
+/* ── Split preview (shown while a tab is being dragged over a subwindow) ──── */
+/* CenterPanel's hit-test sets the hovered group's edge; CenterPanel renders this
+   overlay (NOT the subwindow — it must paint above the pane layer) at the half
+   (or whole, for center) the drop would carve out, in panel-relative px. z-index
+   sits above the pane layer (z-index:2) so the opaque terminal doesn't hide it.
+   A plain rgba fill is used over color-mix (which doesn't render reliably on this
+   WebKitGTK build) so the darkening is always visible. The left/top/width/height
+   transition makes the preview glide as the targeted edge changes. */
+.split-preview {
+  position: absolute;
+  z-index: 5;
+  pointer-events: none;
+  background: rgba(0, 0, 0, 0.28);
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+  transition: left var(--transition), top var(--transition), width var(--transition), height var(--transition);
+}
+
+/* ── Focused-subwindow frame + Shift+↑/↓ subwindow numbering ──────────────── */
+/* FocusFrameOverlay draws both above the pane layer (z-index:2) in panel-
+   relative px — an in-body frame would be hidden by the opaque panes. The frame
+   is outline-only (no fill) so it reads as a light, theme-fitting marker rather
+   than the split preview's dark wash; it glides between subwindows as focus (or
+   the Shift preview) moves. */
+.focus-frame {
+  position: absolute;
+  z-index: 3;
+  pointer-events: none;
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+  border-radius: 2px;
+  transition: left var(--transition), top var(--transition), width var(--transition), height var(--transition);
+}
+.subwindow-number {
+  position: absolute;
+  z-index: 6;
+  pointer-events: none;
+  min-width: 18px;
+  height: 18px;
+  padding: 0 5px;
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 1;
+  color: var(--bg-main);
+  background: var(--accent);
+  border-radius: var(--radius);
+}
+
+/* Floating label following the pointer during a tab drag. */
+.tab-drag-ghost {
+  position: fixed;
+  z-index: 9999;
+  transform: translate(8px, 8px);
+  pointer-events: none;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 4px;
+}
+
+.tab-drag-ghost-label {
+  padding: 4px 10px;
+  font-size: 12px;
+  background: var(--control-hover-bg);
+  border: 1px solid var(--accent);
+  color: var(--text-primary);
+  white-space: nowrap;
+  box-shadow: var(--shadow-2);
+}
+
+/* Options legend shown under the label during a file drag: lists what each
+   release / modifier does. The line matching the current modifier state gets
+   `.active` to stand out (see DragGhost). */
+.tab-drag-ghost-opts {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 4px 8px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-subtle, var(--accent));
+  box-shadow: var(--shadow-2);
+}
+
+.tab-drag-ghost-opt {
+  font-size: 10px;
+  white-space: nowrap;
+  color: var(--text-secondary, var(--text-primary));
+  opacity: 0.6;
+}
+
+.tab-drag-ghost-opt.active {
+  color: var(--accent);
+  opacity: 1;
+  font-weight: 600;
+}
+
+/* Scaled clone of the dragged tab's pane. The clone inside is transform-scaled
+   to GHOST_THUMB_W (see DragGhost); this box clips it to the thumbnail size. */
+.tab-drag-ghost-thumb {
+  position: relative;
+  overflow: hidden;
+  background: var(--bg-elevated);
+  border: 1px solid var(--accent);
+  box-shadow: var(--shadow-2);
+  opacity: 0.9;
+}
+
+/* One-shot send-off when a tab/subwindow is dropped OUT to its own OS window
+   (see DetachFlourish / stores/detachAnim). A card at the exit point lifts,
+   scales, and slides toward the edge the content left through, then fades —
+   reading as the content being ejected into its own window. The fly direction
+   comes from CSS custom props set per play (--fly-dx / --fly-dy). */
+.tab-detach-flourish {
+  position: fixed;
+  z-index: 9998; /* just under the live drag ghost (.tab-drag-ghost: 9999) */
+  pointer-events: none;
+  display: flex;
+  align-items: flex-start;
+  background: var(--bg-panel);
+  border: 1px solid var(--accent);
+  box-shadow: 0 8px 28px rgba(0, 0, 0, 0.45), 0 0 0 1px var(--accent) inset;
+  overflow: hidden;
+  transform-origin: center center;
+  will-change: transform, opacity;
+  animation: tab-detach-fly 0.42s cubic-bezier(0.2, 0.7, 0.3, 1) forwards;
+}
+
+.tab-detach-flourish-label {
+  padding: 4px 10px;
+  font-size: 12px;
+  background: var(--control-hover-bg);
+  border-bottom: 1px solid var(--accent);
+  color: var(--text-primary);
+  white-space: nowrap;
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* A pulse ring that expands out of the card to punctuate the launch. */
+.tab-detach-flourish::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border: 2px solid var(--accent);
+  opacity: 0.6;
+  animation: tab-detach-ring 0.42s ease-out forwards;
+}
+
+@keyframes tab-detach-fly {
+  0% {
+    transform: translate(-50%, -50%) scale(1);
+    opacity: 0.96;
+  }
+  32% {
+    transform: translate(-50%, -50%) scale(1.06);
+    opacity: 0.92;
+  }
+  100% {
+    transform: translate(calc(-50% + var(--fly-dx, 0px)), calc(-50% + var(--fly-dy, -64px)))
+      scale(0.42);
+    opacity: 0;
+  }
+}
+
+@keyframes tab-detach-ring {
+  0% {
+    transform: scale(1);
+    opacity: 0.6;
+  }
+  100% {
+    transform: scale(1.35);
+    opacity: 0;
+  }
+}
+
+/* Respect reduced-motion: collapse the launch to a simple fade, no slide/zoom. */
+@media (prefers-reduced-motion: reduce) {
+  .tab-detach-flourish {
+    animation: tab-detach-fade 0.25s ease-out forwards;
+  }
+  .tab-detach-flourish::after {
+    animation: none;
+    opacity: 0;
+  }
+  @keyframes tab-detach-fade {
+    0% {
+      transform: translate(-50%, -50%);
+      opacity: 0.9;
+    }
+    100% {
+      transform: translate(-50%, -50%);
+      opacity: 0;
+    }
+  }
+}
+
+/* ── Right panel overlay ──────────────────────────────────────────────── */
+.right-panel {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  width: 280px;
+  background-color: var(--bg-panel);
+  border-left: 1px solid var(--border-color);
+  display: flex;
+  flex-direction: column;
+  transform: translateX(calc(100% + 2px));
+  transition: transform var(--transition-slow);
+  /* Above all subwindow/tab-bar chrome (active tab 11, sticky ×/hide/files
+     toggle/scroll chevrons 12, docked-sidebar resize grip 13) — which all
+     resolve in this same stacking context — so the slid-out overlay fully
+     covers them. Stays below fixed editor tooltips/completion (20/60), the
+     header (80), and dialogs. */
+  z-index: 15;
+}
+
+.right-panel:not(.open) {
+  transform: translateX(calc(100% + 2px));
+  border-left-color: transparent;
+}
+
+.right-panel.open {
+  transform: translateX(0);
+}
+
+/* ── Left-docked variant ──────────────────────────────────────────────────
+   The same panel mirrored to the opposite edge: pinned to left:0, its border
+   and closed-slide direction flipped, and the resize grip moved to the right
+   (inner) edge. Two-class selectors beat the base `.right-panel` rules. */
+.right-panel.left {
+  right: auto;
+  left: 0;
+  border-left: none;
+  border-right: 1px solid var(--border-color);
+  transform: translateX(calc(-100% - 2px));
+}
+
+.right-panel.left:not(.open) {
+  transform: translateX(calc(-100% - 2px));
+  border-right-color: transparent;
+}
+
+.right-panel.left.open {
+  transform: translateX(0);
+}
+
+.right-panel.left .right-panel-resize {
+  left: auto;
+  right: -3px;
+}
+
+/* Side-flip button in the header — shares the pin's box; the ⇄ is a plain glyph
+   (not a color emoji), so it's unaffected by the pin's filter caveat. */
+.right-panel-flip {
+  font-size: 14px;
+}
+
+/* While dragging the resize handle, kill the open/close transition so the panel
+   tracks the cursor 1:1 instead of easing toward each intermediate width. */
+.right-panel.resizing {
+  transition: none;
+}
+
+.app-body.resizing {
+  transition: none;
+}
+
+/* Left-border resize grip. Sits just outside the panel's left edge (straddling
+   the border) so it's easy to grab; widened beyond the visible border for a
+   comfortable hit target. Only tinted on hover / during the drag. */
+.right-panel-resize {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: -3px;
+  width: 7px;
+  cursor: ew-resize;
+  z-index: 30;
+  touch-action: none;
+}
+
+.right-panel-resize:hover,
+.right-panel.resizing .right-panel-resize {
+  background: linear-gradient(
+    to right,
+    transparent,
+    color-mix(in srgb, var(--accent, #58a6ff) 70%, transparent) 60%,
+    transparent
+  );
+}
+
+/* OS file drag hovering over the panel: pulsing accent glow + dashed inset
+   border, plus a "drop to copy" hint banner sliding down from the top. */
+.right-panel.drop-active {
+  animation: right-panel-drop-pulse 1.1s ease-in-out infinite;
+}
+
+.right-panel.drop-active::before {
+  content: "";
+  position: absolute;
+  inset: 3px;
+  border: 2px dashed var(--accent);
+  border-radius: var(--radius);
+  pointer-events: none;
+  z-index: 20;
+  animation: right-panel-drop-dash 0.4s ease-out;
+}
+
+.right-panel.drop-active::after {
+  content: "＋ Drop to copy into project";
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  padding: 6px 8px;
+  text-align: center;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--bg-panel);
+  background: var(--accent);
+  pointer-events: none;
+  z-index: 21;
+  animation: right-panel-drop-banner 0.18s ease-out;
+}
+
+/* One-shot confirmation when the drop lands. */
+.right-panel.drop-flash {
+  animation: right-panel-drop-flash 0.5s ease-out;
+}
+
+@keyframes right-panel-drop-pulse {
+  0%,
+  100% {
+    box-shadow: inset 0 0 0 0 color-mix(in srgb, var(--accent) 0%, transparent);
+  }
+  50% {
+    box-shadow: inset 0 0 22px 0 color-mix(in srgb, var(--accent) 32%, transparent);
+  }
+}
+
+@keyframes right-panel-drop-dash {
+  from {
+    opacity: 0;
+    transform: scale(1.04);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes right-panel-drop-banner {
+  from {
+    transform: translateY(-100%);
+    opacity: 0;
+  }
+  to {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}
+
+@keyframes right-panel-drop-flash {
+  0% {
+    box-shadow: inset 0 0 0 9999px color-mix(in srgb, var(--accent) 38%, transparent);
+  }
+  100% {
+    box-shadow: inset 0 0 0 9999px color-mix(in srgb, var(--accent) 0%, transparent);
+  }
+}
+
+.right-panel-scroll,
+.file-browser-main,
+.file-browser-sidebar,
+.project-search-popover,
+.settings-dialog {
+  scrollbar-color: var(--scrollbar-thumb) var(--scrollbar-track);
+  scrollbar-width: thin;
+}
+
+/* Custom-agent manage dialog (new-tab menu → Agents → "＋ Add agent…") */
+.custom-agent-dialog {
+  width: 480px;
+  max-width: 92vw;
+}
+.custom-agent-list {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin: 8px 0 12px;
+  max-height: 220px;
+  overflow-y: auto;
+}
+.custom-agent-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 8px;
+  border-radius: 6px;
+  background: var(--bg-elevated, rgba(127, 127, 127, 0.08));
+}
+.custom-agent-row-label {
+  font-weight: 600;
+  flex: 0 0 auto;
+}
+.custom-agent-row-cmd {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--text-muted);
+  font-size: 0.85em;
+}
+.custom-agent-row-tag {
+  flex: 0 0 auto;
+  font-size: 0.72em;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--accent);
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  padding: 0 5px;
+  opacity: 0.85;
+}
+.custom-agent-install {
+  flex: 0 0 auto;
+  border: 1px solid var(--accent);
+  background: transparent;
+  color: var(--accent);
+  cursor: pointer;
+  font-size: 0.78em;
+  line-height: 1;
+  padding: 3px 8px;
+  border-radius: 4px;
+}
+.custom-agent-install:hover {
+  background: var(--accent);
+  color: var(--bg-panel);
+}
+.custom-agent-row-missing {
+  flex: 0 0 auto;
+  font-size: 0.75em;
+  color: var(--text-muted);
+  opacity: 0.8;
+}
+.custom-agent-remove {
+  flex: 0 0 auto;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 1.05em;
+  line-height: 1;
+  padding: 2px 6px;
+  border-radius: 4px;
+}
+.custom-agent-remove:hover:not(:disabled) {
+  color: var(--danger, #e5534b);
+  background: rgba(229, 83, 75, 0.12);
+}
+.custom-agent-form {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.custom-agent-field {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  font-size: 0.85em;
+}
+.custom-agent-field > span {
+  color: var(--text-secondary, var(--text-muted));
+}
+.custom-agent-field > span em {
+  color: var(--text-muted);
+  font-style: normal;
+  opacity: 0.8;
+}
+.custom-agent-field input {
+  padding: 6px 8px;
+  border-radius: 6px;
+  border: 1px solid var(--border, rgba(127, 127, 127, 0.3));
+  background: var(--bg-input, var(--bg-panel));
+  color: var(--text-primary);
+  font-size: 1em;
+}
+.custom-agent-field input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+/* "Set default app" dialog (right-panel file context menu) */
+.set-default-app-dialog {
+  width: 460px;
+  max-width: 90vw;
+}
+.set-default-app-scope {
+  display: flex;
+  gap: 16px;
+  margin: 6px 0;
+  font-size: 12px;
+}
+.set-default-app-scope label {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  cursor: pointer;
+}
+.set-default-app-scope label.disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.set-default-app-search,
+.set-default-app-manual input {
+  width: 100%;
+  box-sizing: border-box;
+  font-size: 12px;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 4px 6px;
+}
+.set-default-app-list {
+  margin: 6px 0;
+  max-height: 220px;
+  overflow-y: auto;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+}
+.set-default-app-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  text-align: left;
+  background: transparent;
+  border: none;
+  color: var(--text-primary);
+  padding: 4px 8px;
+  cursor: pointer;
+  font-size: 12px;
+}
+.set-default-app-row:hover {
+  background: var(--bg-panel);
+}
+.set-default-app-row.selected {
+  background: var(--accent);
+  color: var(--accent-contrast);
+}
+.set-default-app-row.selected .set-default-app-exec {
+  color: rgba(255, 255, 255, 0.8);
+}
+.set-default-app-icon {
+  flex-shrink: 0;
+  width: 18px;
+  height: 18px;
+  object-fit: contain;
+  image-rendering: -webkit-optimize-contrast;
+}
+.set-default-app-icon-placeholder {
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--text-muted) 22%, transparent);
+}
+.set-default-app-text {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 10px;
+}
+.set-default-app-name {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.set-default-app-exec {
+  color: var(--text-muted);
+  font-size: 11px;
+  flex-shrink: 0;
+  max-width: 45%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.set-default-app-manual {
+  display: flex;
+  gap: 6px;
+  margin-top: 4px;
+}
+.set-default-app-manual button,
+.set-default-app-actions button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 5px 12px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+.set-default-app-manual button {
+  flex-shrink: 0;
+}
+.set-default-app-manual button:hover,
+.set-default-app-actions button:not(:disabled):hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+.set-default-app-actions button:last-child {
+  background: var(--accent);
+  color: var(--bg-main);
+  border-color: var(--accent);
+}
+.set-default-app-actions button.danger {
+  background: var(--danger);
+  border-color: var(--danger);
+  color: var(--bg-main);
+}
+.set-default-app-actions button:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+.set-default-app-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+/* In-app folder-browser popup (FolderPickerDialog) */
+.folder-picker-dialog {
+  width: 520px;
+  max-width: 90vw;
+  display: flex;
+  flex-direction: column;
+}
+.folder-picker-nav {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 8px 0;
+}
+.folder-picker-nav button {
+  flex-shrink: 0;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 4px 10px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  font-size: 12px;
+}
+.folder-picker-nav button:not(:disabled):hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+.folder-picker-nav button:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+.folder-picker-cur {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  direction: rtl;
+  text-align: left;
+  font-size: 12px;
+  color: var(--text-muted);
+}
+.folder-picker-list {
+  min-height: 180px;
+  max-height: 320px;
+  overflow-y: auto;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+}
+.folder-picker-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  text-align: left;
+  background: transparent;
+  border: none;
+  color: var(--text-primary);
+  padding: 5px 8px;
+  cursor: pointer;
+  font-size: 12px;
+}
+.folder-picker-item:hover {
+  background: var(--bg-panel);
+}
+.folder-picker-icon {
+  flex-shrink: 0;
+}
+.folder-picker-name {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.folder-picker-error {
+  color: var(--danger);
+}
+.folder-picker-name-row {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin-top: 10px;
+}
+.folder-picker-name-label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  color: var(--text-primary);
+}
+.folder-picker-name-label input {
+  flex: 1;
+  min-width: 0;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 4px 8px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+}
+.folder-picker-name-label input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+.folder-picker-name-preview {
+  margin: 0;
+  font-size: 11px;
+}
+.folder-picker-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 12px;
+}
+.folder-picker-actions button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 5px 12px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+.folder-picker-actions button:not(:disabled):hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+.folder-picker-actions button.primary {
+  background: var(--accent);
+  color: var(--bg-main);
+  border-color: var(--accent);
+}
+.folder-picker-actions button:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+
+.right-panel-scroll::-webkit-scrollbar,
+.file-browser-main::-webkit-scrollbar,
+.file-browser-sidebar::-webkit-scrollbar,
+.project-search-popover::-webkit-scrollbar,
+.settings-dialog::-webkit-scrollbar {
+  width: 7px;
+  height: 7px;
+}
+
+.right-panel-scroll::-webkit-scrollbar-track,
+.file-browser-main::-webkit-scrollbar-track,
+.file-browser-sidebar::-webkit-scrollbar-track,
+.project-search-popover::-webkit-scrollbar-track,
+.settings-dialog::-webkit-scrollbar-track {
+  background: var(--scrollbar-track);
+}
+
+.right-panel-scroll::-webkit-scrollbar-thumb,
+.file-browser-main::-webkit-scrollbar-thumb,
+.file-browser-sidebar::-webkit-scrollbar-thumb,
+.project-search-popover::-webkit-scrollbar-thumb,
+.settings-dialog::-webkit-scrollbar-thumb {
+  background-color: var(--scrollbar-thumb);
+  border: 1px solid var(--scrollbar-track);
+  border-radius: 0;
+}
+
+.right-panel-scroll::-webkit-scrollbar-thumb:hover,
+.file-browser-main::-webkit-scrollbar-thumb:hover,
+.file-browser-sidebar::-webkit-scrollbar-thumb:hover,
+.project-search-popover::-webkit-scrollbar-thumb:hover,
+.settings-dialog::-webkit-scrollbar-thumb:hover {
+  background-color: var(--scrollbar-thumb-hover);
+}
+
+.right-panel-scroll::-webkit-scrollbar-corner,
+.file-browser-main::-webkit-scrollbar-corner,
+.file-browser-sidebar::-webkit-scrollbar-corner,
+.project-search-popover::-webkit-scrollbar-corner,
+.settings-dialog::-webkit-scrollbar-corner {
+  background: var(--scrollbar-track);
+}
+
+.right-panel-header {
+  display: flex;
+  align-items: center;
+  /* Wrap so the git action bar drops to its own row instead of overflowing the
+     panel's right edge when the project name + Add/Commit/Push don't fit on one
+     line (common at the default/narrow widths). */
+  flex-wrap: wrap;
+  row-gap: 6px;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border-subtle);
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
+/* Buttons keep their size; the title span (min-width:0) truncates instead, so
+   the rightmost actions never get pushed off the panel's right edge. */
+.right-panel-header > button {
+  flex-shrink: 0;
+}
+
+/* Second header row: view switch (Files/Git/Search/Apps) + import/open/settings,
+   moved below the project-name row so git status can share the name's row. */
+.right-panel-toolbar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 2px;
+  padding: 4px 12px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+/* Selected-state for the generic small toolbar button (view-switcher rows like
+   Files/Git/Search/Apps, and every other `.tab-add-btn` toggle) — previously
+   unstyled, so `aria-pressed`/`.active` carried no visible marker at all. */
+.tab-add-btn.active {
+  color: var(--accent);
+  border-color: color-mix(in srgb, var(--accent) 55%, transparent);
+  background: color-mix(in srgb, var(--accent) 14%, transparent);
+}
+
+/* Auto-pinned "Hidden subwindows" section: shown above the view toolbar only
+   when the current scope has ≥1 hidden subwindow, so a hidden pane is always one
+   click from coming back regardless of the active view. */
+.hidden-subwindows {
+  border-bottom: 1px solid var(--border-subtle);
+  background: var(--bg-panel);
+}
+.hidden-sw-header {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 12px;
+  border: none;
+  background: transparent;
+  color: var(--text-secondary, var(--text-muted));
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  cursor: pointer;
+}
+.hidden-sw-header:hover {
+  color: var(--text-primary);
+}
+.hidden-sw-caret {
+  font-size: 9px;
+  width: 10px;
+  display: inline-block;
+}
+.hidden-sw-list {
+  display: flex;
+  flex-direction: column;
+  padding: 0 6px 4px;
+  gap: 2px;
+  max-height: 30vh;
+  overflow-y: auto;
+}
+.hidden-sw-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 6px;
+  border-radius: var(--radius-sm);
+}
+.hidden-sw-row:hover {
+  background: var(--pill-hover-bg);
+}
+.hidden-sw-icon {
+  flex-shrink: 0;
+  color: var(--text-muted);
+  font-size: 12px;
+}
+/* Same three states (and the same pulse timings) as `.tab.working` etc — a
+   hidden group's row-level rollup and its header dot use a colour+opacity pulse
+   since they're a single glyph rather than a whole tab's fillable box. */
+.hidden-sw-icon.working {
+  color: var(--success);
+  animation: pill-bar-working 1.5s ease-in-out infinite;
+}
+.hidden-sw-icon.needs-decision {
+  color: var(--warning);
+  animation: pill-bar-decision 1.2s ease-in-out infinite;
+}
+.hidden-sw-icon.finished {
+  color: var(--success);
+}
+.hidden-sw-status-dot {
+  flex-shrink: 0;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  margin-left: 2px;
+  text-transform: none;
+}
+.hidden-sw-status-dot.working {
+  background: var(--success);
+  animation: pill-bar-working 1.5s ease-in-out infinite;
+}
+.hidden-sw-status-dot.needs-decision {
+  background: var(--warning);
+  animation: pill-bar-decision 1.2s ease-in-out infinite;
+}
+.hidden-sw-status-dot.finished {
+  background: var(--success);
+}
+.hidden-sw-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 3px;
+  flex: 1;
+  min-width: 0;
+}
+.hidden-sw-chip {
+  max-width: 100%;
+  padding: 0 6px;
+  height: 18px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius);
+  background: var(--bg-main);
+  color: var(--text-primary);
+  font-size: 11px;
+  line-height: 16px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  cursor: pointer;
+}
+.hidden-sw-chip:hover {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+/* Same glow as `.tab.working`/`.needs-decision`/`.finished` — a hidden tab's PTY
+   is still mounted and running, so its chip keeps reporting status. */
+.hidden-sw-chip.working,
+.hidden-sw-chip.needs-decision {
+  position: relative;
+  z-index: 0;
+}
+.hidden-sw-chip.working::after,
+.hidden-sw-chip.needs-decision::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  pointer-events: none;
+}
+.hidden-sw-chip.working::after {
+  background: color-mix(in srgb, var(--success) 26%, transparent);
+  animation: tab-glow-working 1.5s ease-in-out infinite;
+}
+.hidden-sw-chip.needs-decision::after {
+  background: color-mix(in srgb, var(--warning) 34%, transparent);
+  animation: tab-glow-decision 1.2s ease-in-out infinite;
+}
+.hidden-sw-chip.finished {
+  box-shadow: inset 0 0 0 999px color-mix(in srgb, var(--success) 16%, transparent);
+}
+.hidden-sw-btn {
+  flex-shrink: 0;
+  width: 20px;
+  height: 20px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 13px;
+}
+.hidden-sw-btn:hover {
+  background: var(--bg-panel);
+  color: var(--accent);
+}
+.hidden-sw-close:hover {
+  color: var(--danger);
+}
+
+/* Inline variant of the git action bar when it lives in the header row, on its
+   own row below the project name: drop the full-width strip styling so it
+   hugs its buttons, left-aligned under the name. */
+.right-panel-header .git-action-bar--inline {
+  flex: 0 1 auto;
+  min-width: 0;
+  /* Wrap the buttons among themselves (left-aligned) so a single action never
+     spills past the panel border. */
+  flex-wrap: wrap;
+  justify-content: flex-start;
+  gap: 4px;
+  padding: 0;
+  border-bottom: none;
+}
+
+.right-panel-header .git-action-bar--inline .git-action-btn {
+  flex: 0 0 auto;
+  padding: 3px 8px;
+  font-size: 12px;
+}
+
+.right-panel-pin {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  margin-right: 8px;
+  padding: 0;
+  font-size: 13px;
+  line-height: 1;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius);
+  background: var(--bg-elevated, rgba(255, 255, 255, 0.04));
+  color: var(--text-secondary);
+  cursor: pointer;
+  /* Dim the unpinned pin with plain opacity, NOT a CSS filter. Applying `filter`
+     (grayscale/opacity) to the 📌 color-emoji glyph makes it render invisible in
+     WebView2 on Windows — the color glyph doesn't compose through the filter
+     shader path — while WebKitGTK on Linux shows it fine. That vanished the pin
+     entirely in the packaged Windows build. Opacity dims without breaking emoji. */
+  opacity: 0.6;
+  transition: opacity var(--transition), background var(--transition), border-color var(--transition);
+}
+
+.right-panel-pin:hover {
+  opacity: 1;
+  border-color: var(--accent, #58a6ff);
+}
+
+.right-panel-pin.pinned {
+  opacity: 1;
+  background: var(--accent, #58a6ff);
+  border-color: var(--accent, #58a6ff);
+  box-shadow: 0 0 0 1px var(--accent, #58a6ff);
+}
+
+.right-panel-sort {
+  display: flex;
+  align-items: center;
+  gap: 1px;
+  padding: 2px 6px;
+  border-bottom: 1px solid var(--border-subtle);
+  flex-shrink: 0;
+}
+
+/* The Files (Project) tab: the right panel's file view hosted in a pane. The
+   rows inside it (sort / source / scroll / tree) are the panel's own classes —
+   only the shell differs, since a tab has no fixed width, no pin and no slide-in
+   transform. */
+.project-files-tab {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+}
+
+.project-files-tab-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 3px 6px;
+  border-bottom: 1px solid var(--border-subtle);
+  flex-shrink: 0;
+}
+
+.project-files-tab-name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.project-files-tab-spacer {
+  margin-left: auto;
+}
+
+.project-files-tab-header .tab-add-btn {
+  font-size: 10px;
+  padding: 1px 6px;
+  height: 20px;
+  flex-shrink: 0;
+}
+
+/* Same OS-file-drop affordance as the panel (pulsing glow, dashed inset border,
+   drop hint) — the animations are shared. */
+.project-files-tab.drop-active {
+  animation: right-panel-drop-pulse 1.1s ease-in-out infinite;
+}
+
+.project-files-tab.drop-active::before {
+  content: "";
+  position: absolute;
+  inset: 3px;
+  border: 2px dashed var(--accent);
+  border-radius: var(--radius);
+  pointer-events: none;
+  z-index: 20;
+  animation: right-panel-drop-dash 0.4s ease-out;
+}
+
+.project-files-tab.drop-active::after {
+  content: "＋ Drop to copy into project";
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  padding: 6px 8px;
+  text-align: center;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--bg-panel);
+  background: var(--accent);
+  pointer-events: none;
+  z-index: 21;
+  animation: right-panel-drop-banner 0.18s ease-out;
+}
+
+.project-files-tab.drop-flash {
+  animation: right-panel-drop-flash 0.5s ease-out;
+}
+
+.sort-key-btn {
+  background: none;
+  border: none;
+  cursor: pointer;
+  font-size: 10px;
+  color: var(--text-muted);
+  padding: 2px 5px;
+  border-radius: var(--radius-sm);
+  text-transform: uppercase;
+  letter-spacing: 0.3px;
+  font-family: inherit;
+  white-space: nowrap;
+}
+
+.sort-key-btn:hover {
+  color: var(--text-secondary);
+  background: var(--pill-hover-bg);
+}
+
+.sort-key-btn.active {
+  color: var(--accent, #58a6ff);
+  font-weight: 700;
+}
+
+/* ── Git action buttons ──────────────────────────────────────────────── */
+.git-action-bar {
+  display: flex;
+  gap: 3px;
+  padding: 4px 6px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.git-action-btn {
+  /* Per-action accent; each button overrides --git-btn-accent below so its
+     colour matches the status dot it carries (red=add, yellow=commit,
+     green=push). Defaults to the theme accent for the confirm/back buttons. */
+  --git-btn-accent: var(--accent);
+  background: color-mix(in srgb, var(--git-btn-accent) 14%, transparent);
+  border: 1px solid color-mix(in srgb, var(--git-btn-accent) 55%, transparent);
+  color: var(--git-btn-accent);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  padding: 4px 9px;
+  font-size: 13px;
+  font-weight: 600;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-family: inherit;
+  transition: background var(--transition), color var(--transition), border-color var(--transition);
+  white-space: nowrap;
+  flex: 1;
+  justify-content: center;
+}
+
+.git-action-btn:hover {
+  background: color-mix(in srgb, var(--git-btn-accent) 26%, transparent);
+  border-color: var(--git-btn-accent);
+}
+
+.git-action-btn:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+/* Action-specific accents, matched to the inline status dots. Set on the
+   group wrapper too so the caret toggle inherits the same colour. */
+.git-action-btn--add,
+.git-action--add { --git-btn-accent: #f85149; }
+.git-action-btn--commit,
+.git-action--commit { --git-btn-accent: #e3b341; }
+.git-action-btn--push,
+.git-action--push { --git-btn-accent: #3fb950; }
+
+/* An action + its disclosure caret, joined into one pill so the two read as a
+   single control. The action button loses its right rounding, the caret its
+   left, and they share a divider. */
+.git-action {
+  display: inline-flex;
+  flex: 0 0 auto;
+}
+
+.git-action .git-action-btn {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+.git-action-toggle {
+  --git-btn-accent: var(--accent);
+  background: color-mix(in srgb, var(--git-btn-accent) 14%, transparent);
+  border: 1px solid color-mix(in srgb, var(--git-btn-accent) 55%, transparent);
+  border-left: none;
+  color: var(--git-btn-accent);
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  cursor: pointer;
+  padding: 0 5px;
+  font-size: 10px;
+  line-height: 1;
+  display: inline-flex;
+  align-items: center;
+  font-family: inherit;
+  transition: background var(--transition), border-color var(--transition);
+}
+
+.git-action-toggle:hover {
+  background: color-mix(in srgb, var(--git-btn-accent) 26%, transparent);
+  border-color: var(--git-btn-accent);
+}
+
+.git-action-toggle:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+/* The label is always shown now (not hover-only) so each action reads clearly
+   without pointing at it; the leading glyph stays as a quick visual marker.
+   Typography matches the app's other small colored tags/chips (type tags,
+   the Local/Remote switch): uppercase, bold, letter-spaced. */
+.git-btn-label {
+  display: inline;
+  font-size: 9px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  line-height: 1;
+}
+
+/* Click-opened navigable change tree under the Add/Commit/Push actions.
+   Anchored to the right edge of the action bar and grown leftward: the panel
+   hugs the app's right frame, so anchoring left would push a wide tree off
+   screen. Sized to the longest path (min keeps it readable, max caps depth). */
+.git-change-tree {
+  position: absolute;
+  top: calc(100% + 4px);
+  right: 0;
+  left: auto;
+  min-width: 280px;
+  max-width: min(480px, calc(100vw - 16px));
+  width: max-content;
+  z-index: 200;
+  background: var(--bg-panel, #1e1e1e);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  max-height: 320px;
+  overflow-y: auto;
+  font-size: 11px;
+  box-shadow: var(--shadow-2);
+  padding: 4px 0;
+}
+
+.git-change-empty {
+  padding: 8px 12px;
+  color: var(--text-muted);
+}
+
+.git-change-row {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 10px 2px 0;
+  white-space: nowrap;
+  color: var(--text-primary);
+}
+
+.git-change-row.is-dir {
+  cursor: pointer;
+  color: var(--text-secondary);
+}
+
+.git-change-row.is-dir:hover {
+  background: var(--pill-hover-bg);
+}
+
+.git-change-caret {
+  display: inline-block;
+  width: 10px;
+  flex-shrink: 0;
+  text-align: center;
+  color: var(--text-muted);
+}
+
+.git-change-name {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.git-change-stat {
+  flex-shrink: 0;
+  display: inline-flex;
+  gap: 5px;
+  margin-left: 10px;
+  font-variant-numeric: tabular-nums;
+}
+
+.git-change-add { color: #3fb950; }
+.git-change-del { color: #f85149; }
+.git-change-zero,
+.git-change-stat--bin { color: var(--text-muted); }
+
+/* ── Git history view ────────────────────────────────────────────────── */
+.git-history {
+  display: flex;
+  flex-direction: column;
+  font-size: 11px;
+}
+
+.git-history-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 6px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.git-history-branch {
+  flex: 1;
+  font-weight: 600;
+  color: var(--text-primary);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.git-history-mode {
+  font-size: 10px;
+  padding: 1px 6px;
+  white-space: nowrap;
+}
+
+.git-branch-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 3px;
+  padding: 4px 6px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.git-branch-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  background: transparent;
+  border: 1px solid var(--border-color);
+  color: var(--text-primary);
+  border-radius: var(--radius-lg);
+  padding: 1px 8px;
+  font-size: 10px;
+  cursor: pointer;
+  font-family: inherit;
+  white-space: nowrap;
+}
+
+/* Lane-colored dot echoing the commit graph: the same color the branch's tip
+   wears in the graph and on its ref label. */
+.git-branch-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.git-branch-pill:hover:not(:disabled) {
+  border-color: var(--accent);
+  color: var(--accent-hover);
+}
+
+.git-branch-pill.current {
+  border-color: var(--accent);
+  background: var(--pill-active-bg);
+  color: var(--accent);
+  cursor: default;
+}
+
+.git-branch-pill.remote {
+  opacity: 0.7;
+  border-style: dashed;
+}
+
+.git-commit-list {
+  display: flex;
+  flex-direction: column;
+}
+
+.git-commit-row {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  padding: 3px 6px;
+  background: transparent;
+  border: none;
+  border-bottom: 1px solid var(--border-color);
+  color: var(--text-primary);
+  cursor: pointer;
+  font-family: inherit;
+  font-size: 11px;
+  text-align: left;
+  width: 100%;
+}
+
+.git-commit-row:hover {
+  background: var(--pill-active-bg);
+}
+
+.git-commit-row.head {
+  border-left: 2px solid var(--accent);
+}
+
+/* Graph mode: rows are a fixed height with no vertical padding so the lane
+   lines drawn per-row meet seamlessly across row boundaries. */
+.git-commit-list.graph .git-commit-row {
+  align-items: center;
+  padding-top: 0;
+  padding-bottom: 0;
+  padding-left: 0;
+  height: 22px;
+}
+
+.git-commit-list.graph .git-commit-row.head {
+  border-left: none;
+}
+
+.git-graph-cell {
+  display: block;
+  align-self: stretch;
+}
+
+.git-commit-hash {
+  font-family: monospace;
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+
+.git-commit-subject {
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.git-commit-ref {
+  flex-shrink: 0;
+  font-size: 9px;
+  padding: 0 5px;
+  border-radius: var(--radius);
+  background: var(--accent);
+  color: var(--bg-base, #111);
+  white-space: nowrap;
+}
+
+.git-commit-date {
+  flex-shrink: 0;
+  font-size: 9px;
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+
+/* Commit-message window */
+.commit-window {
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  padding: 12px 14px;
+  width: min(560px, 92vw);
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  box-shadow: var(--shadow-3);
+}
+
+.commit-window-meta {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+.commit-window-message {
+  width: 100%;
+  font-family: monospace;
+  font-size: 12px;
+  background: var(--bg-base, #111);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 6px 8px;
+  resize: vertical;
+  box-sizing: border-box;
+}
+
+.commit-window-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 6px;
+}
+
+.commit-window-actions button {
+  background: transparent;
+  border: 1px solid var(--border-color);
+  color: var(--text-primary);
+  border-radius: var(--radius);
+  padding: 4px 10px;
+  font-size: 11px;
+  cursor: pointer;
+  font-family: inherit;
+}
+
+.commit-window-actions button:hover:not(:disabled) {
+  border-color: var(--accent);
+  color: var(--accent-hover);
+}
+
+/* Filled accent (canonical primary), not the old outlined look. */
+.commit-window-actions button.primary {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--bg-main);
+}
+
+.commit-window-actions button.primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+  border-color: var(--accent-hover);
+  color: var(--bg-main);
+}
+
+.commit-window-actions button:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+/* ── Project switcher bar (lives inside .header-center) ───────────────── */
+.project-switcher {
+  height: 100%;
+  background-color: transparent;
+  display: flex;
+  align-items: center;
+  /* No left padding: the leading settings gear's gap to .global-apps-menu is
+     supplied entirely by .header-center's gap, so it matches the brain/global-
+     apps gap instead of stacking on top of it. */
+  padding: 0 6px 0 0;
+  gap: 4px;
+  /* Fill the header-center track and stay shrinkable so the pill row can never
+     push past it into the right-side clock/controls. min-width:0 lets the
+     flex children (notably .project-pills-scroll) shrink below content size. */
+  flex: 1;
+  min-width: 0;
+  /* visible so the add/settings dropdown menus can spill below the header;
+     horizontal pill overflow is handled by .project-pills-scroll. */
+  overflow: visible;
+}
+
+.project-switcher::-webkit-scrollbar { height: 0; }
+
+/* ── Project pill ────────────────────────────────────────────────────── */
+.project-pill {
+  /* Anchors the bottom status-bar strip (.pill-status-bars). */
+  position: relative;
+  display: flex;
+  align-items: center;
+  height: 34px;
+  /* Fully transparent, no shadow — the pill melts into the header bar behind
+     it, so a pill and the bar are the SAME color and only the pill text (and,
+     for the current project, its top accent line) tells them apart. The 3px
+     TOP border is TRANSPARENT here and merely recolored to accent on .active —
+     reserving the space up front so activation changes only the color, never
+     the pill's size. Square corners (no radius) so the active pill's side
+     shadow runs straight down each edge with nothing curving below. */
+  box-sizing: border-box;
+  border-radius: 0;
+  border: none;
+  border-top: 3px solid transparent;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--text-secondary);
+  background-color: transparent;
+  transition: color var(--transition), border-color var(--transition);
+  flex-shrink: 0;
+  white-space: nowrap;
+  overflow: hidden;
+}
+
+.project-pill:hover {
+  color: var(--text-primary);
+}
+
+.project-pill.dragging {
+  opacity: 0.45;
+  /* No transform transition here: the inline translateX follows the pointer
+     1:1 every move (see ProjectPill's startPillDrag) — animating it would lag
+     the pill behind the cursor. Only the dim fades in smoothly. */
+  transition: opacity var(--transition);
+  position: relative;
+  z-index: 2;
+}
+
+/* The pills the dragged one is NOT: they slide aside via an inline translateX
+   (ProjectSwitcher's `shiftPx`, mirroring MachinesIndicator's row-parting) to
+   open its landing slot. Only the transition lives here, scoped to an actual
+   drag in progress, so an ordinary pill never animates. */
+.project-pill.reorder-parting {
+  transition: transform 140ms ease;
+}
+
+/* A box pill under a project-pill drag (assign-to-box target, see
+   ProjectSwitcher's `forcedDragOver`): nudge + a pulsing insertion-style bar.
+   A plain project pill never gets this anymore — reordering past one is now
+   the parting slide above, not an insertion bar. */
+.project-pill.drag-over {
+  position: relative;
+  margin-left: 8px;
+  border-color: var(--accent);
+  transition: margin-left var(--transition);
+}
+
+.project-pill.drag-over::before {
+  content: "";
+  position: absolute;
+  left: -5px;
+  top: 4px;
+  bottom: 4px;
+  width: 2px;
+  border-radius: 1px;
+  background: var(--accent);
+  box-shadow: 0 0 6px var(--accent);
+  animation: drag-insert-pulse 0.85s ease-in-out infinite;
+}
+
+/* The reorder insertion bar's pulse: the glow breathes and the bar grows a
+   touch so the drop point reads as live during a pill drag. */
+@keyframes drag-insert-pulse {
+  0%,
+  100% {
+    opacity: 0.6;
+    box-shadow: 0 0 4px var(--accent);
+    transform: scaleY(0.85);
+  }
+  50% {
+    opacity: 1;
+    box-shadow: 0 0 10px var(--accent);
+    transform: scaleY(1);
+  }
+}
+
+/* Alt-drag over a pill: the drop will box the two together (not reorder).
+   Suppress the reorder insertion bar and show a breathing "absorb" pulse that
+   reads as the target swelling to pull the dragged pill into a new box. */
+.project-pill.drag-group {
+  margin-left: 0;
+  border-color: var(--accent);
+  transform-origin: center;
+  animation: drag-group-absorb 0.7s ease-in-out infinite;
+}
+
+.project-pill.drag-group::before {
+  content: none;
+}
+
+@keyframes drag-group-absorb {
+  0%,
+  100% {
+    box-shadow: 0 0 0 1px var(--accent), 0 0 5px var(--accent);
+    transform: scale(1);
+  }
+  50% {
+    box-shadow: 0 0 0 4px var(--accent), 0 0 18px var(--accent);
+    transform: scale(1.07);
+  }
+}
+
+.project-pill.active {
+  /* No size change — same box as every other pill (the 3px top border is
+     already reserved, transparent, on the base rule). Activation recolors that
+     top border to accent/bluish (same color as the add-project button): a
+     straight, un-rounded line across the top of the current project's pill.
+     The current pill is ALSO the only one with a side 3D shadow — a soft edge
+     on each side (vertical offset 0) so it reads as a raised chip lifted off
+     the flat, shadowless neighbours. */
+  color: var(--text-primary);
+  border-top-color: var(--accent);
+  box-shadow: 3px 0 4.5px -2px rgba(0, 0, 0, 0.4), -3px 0 4.5px -2px rgba(0, 0, 0, 0.4);
+}
+
+/* Category-tinted top bar: the project's primary category color replaces the
+   default status stripe so projects sharing a category read as a group. The
+   active pill keeps the accent stripe (its current-scope signal wins). */
+.project-pill.has-category:not(.active):not(.timer-paused) {
+  box-shadow: inset 0 -4px 0 var(--cat-color), 0 3px 6px -2px rgba(0, 0, 0, 0.28);
+}
+/* Small per-category swatches inside the pill (one dot per category). */
+.pill-category-dots {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  margin: 0 4px 0 -2px;
+  flex-shrink: 0;
+}
+.pill-category-dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  box-shadow: 0 0 0 1px color-mix(in srgb, var(--bg-main) 50%, transparent);
+}
+
+/* Category editor modal: toggle chips for known tags + an add field. */
+.category-editor .category-chip-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin: 4px 0 2px;
+}
+.category-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 9px;
+  border-radius: var(--radius-full);
+  font-size: 12px;
+  cursor: pointer;
+  color: var(--text-secondary);
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  transition: background var(--transition), border-color var(--transition), color var(--transition);
+}
+.category-chip:hover {
+  border-color: var(--cat-color);
+  color: var(--text-primary);
+}
+.category-chip.on {
+  color: var(--text-primary);
+  background: color-mix(in srgb, var(--cat-color) 22%, transparent);
+  border-color: var(--cat-color);
+}
+.category-chip-dot {
+  width: 9px;
+  height: 9px;
+  border-radius: 50%;
+  background: var(--cat-color);
+  flex-shrink: 0;
+}
+.category-chip-x {
+  margin-left: 1px;
+  color: var(--text-muted);
+  font-size: 13px;
+  line-height: 1;
+}
+.category-add-row {
+  display: flex;
+  gap: 6px;
+}
+.category-add-row input {
+  flex: 1;
+  min-width: 0;
+}
+
+.pill-main {
+  display: flex;
+  align-items: center;
+  gap: inherit;
+  padding: 0 8px 0 12px;
+  height: 100%;
+  background: none;
+  border: none;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  flex: 1;
+  min-width: 0;
+}
+
+.pill-close-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  margin-right: 4px;
+  background: none;
+  border: none;
+  color: var(--text-muted);
+  font-size: 14px;
+  line-height: 1;
+  cursor: pointer;
+  border-radius: var(--radius-sm);
+  opacity: 0;
+  transition: opacity var(--transition), background-color var(--transition);
+  flex-shrink: 0;
+}
+
+.project-pill:hover .pill-close-btn {
+  opacity: 1;
+}
+
+.pill-close-btn:hover {
+  background-color: var(--control-hover-bg);
+  color: var(--text-primary);
+}
+
+/* ── Project box chip ───────────────────────────────────────────────── */
+/* A box groups member pills behind a labelled chip, visually distinct from a
+   plain project pill (accent-tinted frame + ▣ badge + member count). */
+.project-box-chip {
+  display: flex;
+  align-items: center;
+  flex-shrink: 0;
+  gap: 4px;
+  padding: 0 4px;
+  height: 32px;
+  border: 1px solid var(--accent);
+  border-radius: var(--radius);
+  background-color: color-mix(in srgb, var(--accent) 12%, var(--control-bg));
+}
+
+.project-box-chip.drag-over {
+  border-color: var(--warning);
+  box-shadow: inset 0 0 0 1px var(--warning);
+}
+
+.project-box-header {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  height: 100%;
+  padding-left: 4px;
+  white-space: nowrap;
+}
+
+.project-box-badge {
+  font-size: 12px;
+  color: var(--accent);
+  line-height: 1;
+}
+
+.project-box-name {
+  background: none;
+  border: none;
+  color: var(--text-primary);
+  font: inherit;
+  font-weight: 600;
+  font-size: 12px;
+  cursor: pointer;
+  padding: 0;
+}
+
+.project-box-name:hover {
+  color: var(--accent);
+}
+
+.project-box-rename-input {
+  width: 90px;
+  font: inherit;
+  font-size: 12px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  border: 1px solid var(--accent);
+  border-radius: var(--radius-sm);
+  padding: 1px 4px;
+}
+
+.project-box-member-count {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 16px;
+  height: 16px;
+  padding: 0 4px;
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--accent);
+  background: color-mix(in srgb, var(--accent) 22%, transparent);
+  border-radius: var(--radius);
+}
+
+.project-box-caret {
+  font-size: 9px;
+  color: var(--accent);
+  margin-right: 1px;
+  line-height: 1;
+}
+
+/* Expanded member list: a downward dropdown portaled to the body so it escapes
+   the horizontally-scrolling pills row's vertical clipping. Members stack as a
+   vertical list, each pill spanning the dropdown width. */
+.project-box-dropdown {
+  position: fixed;
+  z-index: 1000;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin-top: 2px;
+  padding: 4px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--accent);
+  box-shadow: var(--shadow-3);
+}
+
+.project-box-dropdown .project-pill {
+  width: 100%;
+}
+
+.project-box-dropdown-hint {
+  padding: 3px 4px 1px;
+  font-size: 9px;
+  color: var(--text-secondary);
+  text-align: center;
+  opacity: 0.7;
+}
+
+/* Drop the reorder margin shift inside the vertical list (it would nudge pills
+   sideways); the insertion bar still marks the drop point. */
+.project-box-dropdown .project-pill.drag-over {
+  margin-left: 0;
+}
+
+/* Subtle cue that an expanded box's chip is the open dropdown's anchor. */
+.project-box-chip.expanded {
+  background-color: color-mix(in srgb, var(--accent) 20%, var(--control-bg));
+}
+
+/* A box rendered as a project-style pill: same base as .project-pill, with an
+   accent-tinted box icon and member-count badge. */
+.project-pill.is-box .pill-folder-icon {
+  color: var(--accent);
+}
+
+.project-pill.is-box .project-box-member-count {
+  margin-left: 4px;
+}
+
+/* Member rows inside the box pill's hover dropdown: click to switch, × to
+   remove from the box. */
+.project-box-member-row {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+}
+
+.project-box-member-open {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  font: inherit;
+  font-size: 12px;
+  padding: 4px 8px;
+  cursor: pointer;
+  text-align: left;
+  white-space: nowrap;
+}
+
+.project-box-member-open:hover {
+  background: var(--control-hover-bg);
+  color: var(--accent);
+  border-color: var(--accent);
+}
+
+.project-box-member-remove {
+  flex-shrink: 0;
+  width: 20px;
+  height: 26px;
+  background: var(--control-bg);
+  color: var(--text-secondary);
+  border: 1px solid var(--control-border);
+  cursor: pointer;
+  font-size: 12px;
+}
+
+.project-box-member-remove:hover {
+  color: var(--danger, #f85149);
+  border-color: var(--danger, #f85149);
+}
+
+/* Multi-root file view (box scope): one collapsible section per root, each set
+   off from the next with a header band, a left accent rail, and an indented
+   body so the boundaries between project roots read clearly. */
+.file-root {
+  --file-root-accent: var(--text-secondary);
+  margin-bottom: 8px;
+  border: 1px solid var(--border-color);
+  border-left: 3px solid var(--file-root-accent);
+  background: var(--bg-panel);
+}
+
+.file-root:last-child {
+  margin-bottom: 0;
+}
+
+/* The box's own folder leads the list and is accent-tinted; member project
+   roots use a calmer neutral rail. */
+.file-root--box {
+  --file-root-accent: var(--accent);
+}
+
+.file-root-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  padding: 5px 7px;
+  background: color-mix(in srgb, var(--file-root-accent) 10%, var(--bg-panel));
+  color: var(--text-primary);
+  border: none;
+  border-bottom: 1px solid var(--border-color);
+  font: inherit;
+  font-size: 11px;
+  font-weight: 600;
+  cursor: pointer;
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  white-space: nowrap;
+}
+
+.file-root.is-collapsed .file-root-header {
+  border-bottom: none;
+}
+
+.file-root-header:hover {
+  background: color-mix(in srgb, var(--file-root-accent) 18%, var(--bg-panel));
+}
+
+.file-root-caret {
+  font-size: 9px;
+  color: var(--file-root-accent);
+  width: 9px;
+  flex-shrink: 0;
+}
+
+.file-root-icon {
+  flex-shrink: 0;
+}
+
+.file-root--box .file-root-icon {
+  color: var(--accent);
+}
+
+.file-root-name {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* Small role tag (box / project) on the right of each header. */
+.file-root-kind {
+  flex-shrink: 0;
+  font-size: 9px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--file-root-accent);
+  opacity: 0.8;
+  padding: 1px 5px;
+  border: 1px solid color-mix(in srgb, var(--file-root-accent) 40%, transparent);
+  border-radius: var(--radius);
+}
+
+/* Indent the file list under its header so nested entries don't line up with
+   the section rails. */
+.file-root-body {
+  padding-left: 4px;
+}
+
+/* Box rows in the search popover: distinct from project rows. */
+.project-search-row.is-box {
+  border-left: 2px solid var(--accent);
+  background: color-mix(in srgb, var(--accent) 8%, var(--control-bg));
+}
+
+.project-search-row.is-box .project-box-badge {
+  margin-right: 2px;
+}
+
+/* ── Project pill popup ─────────────────────────────────────────────── */
+.project-pill-popup {
+  position: fixed;
+  transform: translate(-50%, 6px);
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 6px 10px;
+  white-space: nowrap;
+  pointer-events: none;
+  z-index: 9999;
+  box-shadow: var(--shadow-2);
+}
+
+.pill-popup-path {
+  font-size: 11px;
+  font-style: italic;
+  color: var(--text-secondary);
+  max-width: 300px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  direction: rtl;
+  text-align: left;
+}
+
+.pill-popup-path-row {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  max-width: 320px;
+  overflow: hidden;
+}
+
+.pill-popup-path-row .pill-popup-path {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.pill-popup-path-label {
+  flex: 0 0 auto;
+  font-size: 9px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-secondary);
+  opacity: 0.7;
+}
+
+.pill-popup-description {
+  color: var(--text-primary);
+  font-size: 12px;
+  line-height: 1.35;
+  max-width: 320px;
+  white-space: normal;
+}
+
+.pill-popup-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  max-width: 320px;
+}
+
+/* Same tag chips, inline beside the right panel's project-name header instead
+   of in the pill hover popup. */
+.right-panel-type-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  flex-shrink: 0;
+  margin-left: 8px;
+}
+
+.pill-popup-tag {
+  font-size: 9px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  line-height: 1;
+  padding: 2px 6px;
+  border-radius: var(--radius-full);
+  border: 1px solid currentColor;
+  white-space: nowrap;
+}
+
+.pill-popup-status {
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.pill-popup-status.active {
+  color: var(--accent, #89b4fa);
+}
+
+.pill-popup-status.inactive {
+  color: var(--text-muted, #6c7086);
+}
+
+.pill-popup-time {
+  font-size: 11px;
+  color: var(--text-secondary);
+  display: flex;
+  align-items: center;
+}
+
+.pill-popup-cpu {
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+
+/* ── Tab hover card ───────────────────────────────────────────────────────────
+   Reuses `.project-pill-popup` (box + position) and the `.pill-popup-*` rows so
+   the tab hover looks identical to the project pill hover; only the header row
+   and the muted kind line are tab-specific. */
+.tab-popup-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.tab-popup-dot {
+  font-size: 9px;
+  line-height: 1;
+}
+
+.tab-popup-label {
+  color: var(--text-primary);
+  font-size: 12px;
+  font-weight: 600;
+  max-width: 320px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tab-popup-kind {
+  font-size: 11px;
+  color: var(--text-secondary);
+  opacity: 0.8;
+}
+
+/* Muted meta rows (activity / restart) — like .pill-popup-path but plain LTR
+   text, so it never gets the path row's RTL ellipsis treatment. */
+.tab-popup-meta {
+  font-size: 11px;
+  color: var(--text-secondary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.tab-popup-meta.working {
+  color: var(--success, #4caf50);
+}
+
+/* ── Project switcher action buttons ──────────────────────────────────────── */
+.project-switcher-action-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  border-radius: var(--radius-sm);
+  border: none;
+  cursor: pointer;
+  background: transparent;
+  color: var(--text-secondary);
+  font-size: 16px;
+  transition: background-color var(--transition), color var(--transition);
+  flex-shrink: 0;
+}
+
+.project-switcher-action-btn:hover {
+  background-color: var(--pill-hover-bg);
+  color: var(--text-primary);
+}
+
+/* ── Settings panel ─────────────────────────────────────────────────── */
+.settings-overlay {
+  position: absolute;
+  bottom: 56px;
+  left: 8px;
+  background-color: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: 0;
+  padding: 12px;
+  min-width: 200px;
+  z-index: 20;
+  box-shadow: var(--shadow-2);
+}
+
+.settings-label {
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  margin-bottom: 8px;
+}
+
+.theme-btn {
+  display: block;
+  width: 100%;
+  text-align: left;
+  padding: 6px 8px;
+  border-radius: var(--radius-sm);
+  border: none;
+  cursor: pointer;
+  font-size: 12px;
+  background: transparent;
+  color: var(--text-primary);
+  transition: background-color var(--transition);
+}
+
+.theme-btn:hover { background-color: var(--pill-hover-bg); }
+.theme-btn.selected { color: var(--accent); font-weight: 600; }
+
+/* ── Tab bar (lives inside .header-center) ───────────────────────────── */
+.tab-bar {
+  display: flex;
+  align-items: flex-end;
+  /* Small inset on the top + sides so the tab cards (top), the drag grip / first
+     tab (left) and the sticky close/hide/files cluster (right) all clear the
+     active subwindow's focus-frame outline (2px, drawn just inside the frame
+     edge) instead of colliding with it — notably the × button and the tab tops. */
+  padding: 4px 5px 0;
+  gap: 2px;
+  /* The bar itself no longer scrolls; only the inner `.tab-strip` does. The bar
+     stays a fixed row holding the scroll chevrons, the strip (including the +
+     button after its final tab), and the close/detach controls. */
+  overflow: hidden;
+  /* A fixed-height strip at the top of its subwindow. NOT flex:1 — the tab bar
+     lives inside the column-flex `.subwindow`, so growing would let it eat the
+     pane's vertical space and float the tabs to mid-window. */
+  flex: 0 0 auto;
+  min-width: 0;
+  min-height: 32px;
+  /* Distinct from the pane (`--bg-main`) so the bar reads as its own strip; the
+     bottom border + the active tab's `--bg-main` blend keep the divide crisp. */
+  background-color: var(--bg-panel);
+  border-bottom: 1px solid var(--border-color);
+  position: relative;
+}
+
+/* Same accent wash family as the header bar / menus / dialogs, but dimmer —
+   a subwindow's tab bar is a secondary surface, not the window's own top
+   edge, so it echoes the theme rather than matching it at full strength.
+   Negative z-index (not a positive one on the children) so it stays under
+   the bar's existing content without touching every child's own stacking. */
+.tab-bar::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: var(--accent);
+  opacity: 0.12;
+  pointer-events: none;
+  z-index: -1;
+}
+
+/* Explicit drag grip pinned at the far left of every subwindow bar. It sits
+   outside the scrolling `.tab-strip`, so it stays grabbable no matter how many
+   tabs fill (and overflow) the bar. Inherits the bar's grab cursor; brightens on
+   hover so it reads as an affordance. */
+.tab-drag-grip {
+  flex-shrink: 0;
+  align-self: center;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 26px;
+  padding: 0 1px;
+  color: var(--text-muted);
+  font-size: 14px;
+  line-height: 1;
+  user-select: none;
+  opacity: 0.6;
+  cursor: grab;
+  transition: opacity var(--transition), color var(--transition);
+}
+.tab-drag-grip:hover {
+  opacity: 1;
+  color: var(--text-primary);
+}
+.tab-drag-grip:active { cursor: grabbing; }
+
+/* The horizontally-scrolling tab container. Grows to fill the bar between the
+   chevrons and close controls and carries the + directly after the final tab;
+   its scrollbar is hidden (chevrons + wheel drive the scroll instead). */
+.tab-strip {
+  display: flex;
+  align-items: flex-start;
+  gap: 0;
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow-x: auto;
+  scrollbar-width: none;
+}
+.tab-strip::-webkit-scrollbar { height: 0; }
+
+/* Chevron buttons that flank the strip when it overflows. */
+.tab-scroll-btn {
+  flex-shrink: 0;
+  align-self: center;
+  width: 20px;
+  height: 26px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 16px;
+  line-height: 1;
+  z-index: 12;
+  transition: background-color var(--transition), color var(--transition);
+}
+.tab-scroll-btn:hover {
+  background: var(--pill-hover-bg);
+  color: var(--text-primary);
+}
+
+.tab {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 0 12px;
+  height: 30px;
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-muted);
+  white-space: nowrap;
+  flex-shrink: 0;
+  /* Tabs melt into the tab-bar behind them — transparent, no side/top border,
+     no card shadow — exactly as project pills melt into the header bar. Only
+     the tab text, and (for the current tab) its straight bottom accent line
+     plus side 3D shadow, tell a tab from the bar. The 3px BOTTOM border is
+     reserved transparent here and recoloured on .active; border-radius:0 keeps
+     that line a straight, un-rounded rule corner-to-corner. */
+  box-sizing: border-box;
+  border: none;
+  border-bottom: 3px solid transparent;
+  border-radius: 0;
+  background: transparent;
+  margin-bottom: 0;
+  margin-top: 0;
+  transition: color var(--transition), border-color var(--transition), max-width var(--transition), padding var(--transition);
+  user-select: none;
+  /* Don't let the webview claim the pointer for a pan/select gesture — on
+     WebKitGTK that turns a drag's release into pointercancel, not pointerup. */
+  touch-action: none;
+}
+
+.tab:hover {
+  color: var(--text-primary);
+}
+
+.tab.active {
+  /* No background tint, no lift, no size change — same melt as every tab. The
+     current tab is marked by the bottom border recoloured to its accent (its
+     kind colour via --tab-accent, falling back to the theme accent): a straight
+     line across the bottom edge, mirroring the active project pill's top line.
+     It is ALSO the only tab with a side 3D shadow, so it reads as a raised chip
+     lifted off the flat, shadowless neighbours. */
+  color: var(--text-primary);
+  border-bottom-color: var(--tab-accent, var(--accent));
+  box-shadow: 2px 0 3px -2px rgba(0, 0, 0, 0.4), -2px 0 3px -2px rgba(0, 0, 0, 0.4);
+}
+
+.tab-label {
+  flex: 1;
+  min-width: 0;
+  /* Tab text is never accent-coloured — it takes the theme foreground (white in
+     dark themes, near-black in light, dark-lavender in the lavender theme). The
+     tab-group identity is carried by the top stripe, not the label. Inactive
+     tabs dim slightly so the active tab still reads as foremost. */
+  color: var(--text-primary);
+}
+
+.tab:not(.active):not(:hover) .tab-label {
+  opacity: 0.78;
+}
+
+/* #56: inline tab rename. The label is swapped for a borderless input that
+   inherits the tab's typography so the tab width doesn't jump while editing. */
+.tab-label-edit {
+  flex: 1;
+  min-width: 0;
+  font: inherit;
+  color: inherit;
+  background: var(--bg-main, rgba(0, 0, 0, 0.25));
+  border: 1px solid var(--accent, #4aa3df);
+  border-radius: var(--radius-sm);
+  padding: 0 2px;
+  margin: 0;
+  outline: none;
+}
+
+/* ── Tab status glow ─────────────────────────────────────────────────────
+   The WHOLE tab tints/pulses to show agent state — an inset box-shadow fill
+   painted behind the label, so it never changes the tab's width and the text
+   stays crisp. Three states:
+   - working        (green, pulsing): PTY producing sustained output.
+   - needs-decision (orange, pulsing): agent gone quiet with a choice/permission
+     prompt on screen — shown on the viewed tab too, since an agent blocked on
+     you stays blocked while you look at it. The glow is an inset fill, so it
+     composites over the active tab's gradient without fighting it.
+   - finished       (green, steady): agent rang the bell having simply finished.
+   Working and finished clear the moment the tab is viewed; a pending decision
+   clears when it is ANSWERED. */
+/* The glow is an `::after` overlay, not an animated shadow — see the keyframes
+   below for why. `z-index: -1` inside the tab's own stacking context puts it
+   above the tab's (transparent) background and below its label, which is
+   exactly where the inset box-shadow used to paint, so the look is unchanged. */
+.tab.working,
+.tab.needs-decision {
+  position: relative;
+  z-index: 0;
+}
+
+.tab.working::after,
+.tab.needs-decision::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  pointer-events: none;
+}
+
+.tab.working::after {
+  background: color-mix(in srgb, var(--success) 26%, transparent);
+  animation: tab-glow-working 1.5s ease-in-out infinite;
+}
+
+.tab.needs-decision::after {
+  background: color-mix(in srgb, var(--warning) 34%, transparent);
+  animation: tab-glow-decision 1.2s ease-in-out infinite;
+}
+
+.tab.finished {
+  box-shadow: inset 0 0 0 999px color-mix(in srgb, var(--success) 16%, transparent);
+}
+
+/* Opacity-only pulse. These used to animate `box-shadow: inset … color-mix(…)`
+   directly, which is the most expensive way to express this glow: `box-shadow`
+   is not a compositable property, so every frame forced a full re-rasterization
+   of the tab bar, and the `color-mix()` was re-evaluated per frame on top. With
+   WEBKIT_DISABLE_DMABUF_RENDERER=1 (forced in `lib.rs` after the Mesa/SIGBUS
+   crash) that rasterization is pure CPU — so a couple of working agent tabs
+   alone kept the renderer's main thread pegged at ~a full core, and the UI had
+   no headroom left to answer input. `opacity` is compositor-driven, so the
+   pulse now costs no repaint at all.
+
+   The colour is static on the `::after` overlay below (mixed ONCE, not per
+   frame); these keyframes only fade it between the original endpoints —
+   5%→26% for working, 8%→34% for decision, i.e. the low end is expressed as a
+   fraction of the peak alpha (5/26, 8/34) so the glow looks unchanged. */
+@keyframes tab-glow-working {
+  0%, 100% { opacity: 0.192; }
+  50%      { opacity: 1; }
+}
+
+@keyframes tab-glow-decision {
+  0%, 100% { opacity: 0.235; }
+  50%      { opacity: 1; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  /* Collapse the pulse to a steady tint — the state is still visible. */
+  .tab.working,
+  .hidden-sw-chip.working {
+    animation: none;
+    box-shadow: inset 0 0 0 999px color-mix(in srgb, var(--success) 16%, transparent);
+  }
+  .tab.needs-decision,
+  .hidden-sw-chip.needs-decision {
+    animation: none;
+    box-shadow: inset 0 0 0 999px color-mix(in srgb, var(--warning) 22%, transparent);
+  }
+}
+
+/* ── Project pill status bars ────────────────────────────────────────────
+   A strip of little bars along the pill's bottom edge — ONE PER NON-IDLE TAB of
+   that project, so the switcher shows both what a project's tabs are doing and
+   how many are doing it. Same three states, and the same pulse timings, as the
+   tab glow:
+   - working        (green, pulsing): PTY producing sustained output.
+   - needs-decision (orange, pulsing): agent waiting on a decision.
+   - finished       (green, steady): agent finished, tab not yet seen.
+   The strip is the pill's only status signal — the pill body no longer tints, so
+   it can't fight the active gradient or the category top stripe. */
+.pill-status-bars {
+  position: absolute;
+  left: 6px;
+  right: 6px;
+  bottom: 2px;
+  display: flex;
+  gap: 2px;
+  height: 3px;
+  pointer-events: none;
+}
+
+.pill-status-bar {
+  /* Shrinks (never grows) so a full strip still fits a narrow pill. */
+  flex: 0 1 12px;
+  min-width: 4px;
+  border-radius: 1px;
+}
+
+.pill-status-bar.working {
+  background-color: var(--success);
+  animation: pill-bar-working 1.5s ease-in-out infinite;
+}
+
+.pill-status-bar.needs-decision {
+  background-color: var(--warning);
+  animation: pill-bar-decision 1.2s ease-in-out infinite;
+}
+
+.pill-status-bar.finished {
+  background-color: var(--success);
+}
+
+@keyframes pill-bar-working {
+  0%, 100% { opacity: 0.3; }
+  50%      { opacity: 1; }
+}
+
+@keyframes pill-bar-decision {
+  0%, 100% { opacity: 0.35; }
+  50%      { opacity: 1; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  /* Collapse the pulse to a steady bar — the state is still visible. */
+  .pill-status-bar.working,
+  .pill-status-bar.needs-decision,
+  .hidden-sw-icon.working,
+  .hidden-sw-icon.needs-decision,
+  .hidden-sw-status-dot.working,
+  .hidden-sw-status-dot.needs-decision {
+    animation: none;
+    opacity: 0.85;
+  }
+}
+
+/* Energy Saver: the agent-status glows/pulses can animate indefinitely (as long
+   as a tab is working or waiting on a prompt), so collapse them to the same
+   steady tints reduced-motion uses. The state stays fully visible; only the
+   continuous repaint stops. Driven by [data-energy-saver="on"] on the document
+   root (set in AppShell from the power/settings signal). */
+:root[data-energy-saver="on"] .tab.working,
+:root[data-energy-saver="on"] .hidden-sw-chip.working {
+  animation: none;
+  box-shadow: inset 0 0 0 999px color-mix(in srgb, var(--success) 16%, transparent);
+}
+:root[data-energy-saver="on"] .tab.needs-decision,
+:root[data-energy-saver="on"] .hidden-sw-chip.needs-decision {
+  animation: none;
+  box-shadow: inset 0 0 0 999px color-mix(in srgb, var(--warning) 22%, transparent);
+}
+:root[data-energy-saver="on"] .pill-status-bar.working,
+:root[data-energy-saver="on"] .pill-status-bar.needs-decision,
+:root[data-energy-saver="on"] .hidden-sw-icon.working,
+:root[data-energy-saver="on"] .hidden-sw-icon.needs-decision,
+:root[data-energy-saver="on"] .hidden-sw-status-dot.working,
+:root[data-energy-saver="on"] .hidden-sw-status-dot.needs-decision {
+  animation: none;
+  opacity: 0.85;
+}
+:root[data-energy-saver="on"] .tab-new-btn.empty-hint {
+  animation: none;
+}
+
+.tab-close {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  border-radius: var(--radius-sm);
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 14px;
+  line-height: 1;
+  flex-shrink: 0;
+  opacity: 0;
+  transition: opacity var(--transition), background-color var(--transition);
+}
+
+.tab:hover .tab-close,
+.tab.active .tab-close { opacity: 1; }
+.tab-close:hover { background-color: var(--pill-hover-bg); color: var(--text-primary); }
+
+/* SSH-sync Phase 0: per-tab local/remote locality badge (remote projects only).
+   Always visible (unlike the close button) so the tab's locality is legible at a
+   glance; click toggles it. Local = mirror (warning hue), remote = host (info). */
+/* Unified local/remote tab marking. One visual language across both meanings —
+   ⌂ + green = local, ☁ + amber = remote — since the two never coexist on a tab:
+     - .tab-locality: agent/shell tabs, a clickable toggle for WHERE the process
+       runs (local mirror vs the host over SSH).
+     - .tab-source: viewer/file tabs, a non-interactive badge for WHERE the bytes
+       are read (local synced copy vs host-native over SFTP). */
+.tab-locality,
+.tab-source {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  border-radius: var(--radius-sm);
+  border: none;
+  background: transparent;
+  font-size: 11px;
+  line-height: 1;
+  flex-shrink: 0;
+  transition: background-color var(--transition), color var(--transition);
+}
+.tab-locality { cursor: pointer; }
+.tab-source { cursor: default; }
+.tab-locality.local,
+.tab-source.local { color: var(--success); }
+.tab-locality.remote,
+.tab-source.remote { color: var(--warning); }
+.tab-locality:hover { background-color: var(--pill-hover-bg); }
+/* A file-source badge is a clickable toggle when the file exists on both sides
+   (the viewer published a Local/Remote switch); otherwise it stays the plain
+   read-only glyph above. `disabled` = the host has no counterpart to switch to. */
+.tab-source.clickable { cursor: pointer; }
+.tab-source.clickable:hover { background-color: var(--pill-hover-bg); }
+.tab-source.clickable.disabled { cursor: default; opacity: 0.45; }
+.tab-source.clickable.disabled:hover { background-color: transparent; }
+
+/* Planner/doer badge (experimental `agent_mode_toggle`) — same 16px badge box as
+   the locality toggle, sitting beside it on agent tabs. Three states, two of them
+   wired: `unset` (the agent's own ask-each-time default, muted so it reads as
+   "nothing imposed"), `plan` (restrained), `auto` (edits flow). */
+.tab-agent-mode {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  border-radius: var(--radius-sm);
+  border: none;
+  background: transparent;
+  font-size: 11px;
+  line-height: 1;
+  flex-shrink: 0;
+  cursor: pointer;
+  transition: background-color var(--transition), color var(--transition);
+}
+.tab-agent-mode.unset { color: var(--text-muted); opacity: 0.6; }
+.tab-agent-mode.plan { color: var(--info, #4aa3df); }
+.tab-agent-mode.auto { color: var(--warning); }
+.tab-agent-mode:hover { background-color: var(--pill-hover-bg); opacity: 1; }
+
+/* Per-subwindow close (×), shown in the tab bar when >1 subwindow exists.
+   The bar scrolls horizontally when tabs overflow; pin this button to the right
+   edge (sticky + flex-shrink:0) so it never scrolls out of reach and stays
+   clickable regardless of how many tabs the group holds. The panel-colored
+   background keeps overflowing tabs from showing through behind it. */
+.subwindow-close {
+  margin-left: auto;
+  align-self: center;
+  position: sticky;
+  right: 0;
+  flex-shrink: 0;
+  z-index: 12;
+  width: 22px;
+  height: 22px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  background: var(--bg-panel);
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 15px;
+}
+.subwindow-close:hover {
+  background: var(--pill-hover-bg);
+  color: var(--danger);
+}
+
+/* Hide-subwindow button: parks the subwindow into the right-panel Hidden list.
+   Sits just left of the close button (both margin-left:auto stack at the right
+   end; when close is absent for a single subwindow, hide still pins right). */
+.subwindow-hide {
+  margin-left: auto;
+  align-self: center;
+  position: sticky;
+  right: 0;
+  flex-shrink: 0;
+  z-index: 12;
+  width: 22px;
+  height: 22px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  background: var(--bg-panel);
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 17px;
+  line-height: 1;
+}
+/* When both render, the close button owns the far-right slot; hide sits snug to
+   its left (its own auto-margin has no free space left to consume). */
+.subwindow-hide + .subwindow-close {
+  margin-left: 0;
+}
+.subwindow-hide:hover {
+  background: var(--pill-hover-bg);
+  color: var(--accent);
+}
+
+/* Per-subwindow file-viewer toggle (◫), left of the hide/close cluster. Same
+   sticky right-edge treatment as its companions; lit while the viewer is open. */
+.subwindow-files-toggle {
+  margin-left: auto;
+  align-self: center;
+  position: sticky;
+  right: 0;
+  flex-shrink: 0;
+  z-index: 12;
+  width: 22px;
+  height: 22px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: none;
+  background: var(--bg-panel);
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 14px;
+  line-height: 1;
+}
+.subwindow-files-toggle + .subwindow-hide {
+  margin-left: 0;
+}
+.subwindow-files-toggle:hover {
+  background: var(--pill-hover-bg);
+  color: var(--accent);
+}
+.subwindow-files-toggle.open {
+  color: var(--accent);
+}
+
+/* Right-pinned cluster holding the ◫/hide/close controls. Sits after the
+   flex:1 tab strip, so it's always at the far right of the bar. When a file
+   viewer is docked below, TabBar sets an inline `width` equal to the viewer's
+   width: the cluster then spans the strip-edge→bar-edge band directly above the
+   viewer and right-aligns its buttons, which both keeps the controls flush with
+   the subwindow's right edge and forces the scrolling strip to stop at the pane
+   edge instead of running under the viewer. */
+.tab-controls {
+  align-self: stretch;
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  flex-shrink: 0;
+  min-width: 0;
+}
+
+/* #42: detached ("pop out") window title-bar controls — the native
+   min/max/close cluster. Pinned to the right of the tab bar (sticky) so they
+   never scroll out when tabs overflow; the panel-colored backing keeps
+   overflowing tabs from showing through. (Dock-back is done by Ctrl+dragging the
+   tab bar onto the main window, #42.) */
+.detached-titlebar-controls {
+  margin-left: auto;
+  align-self: center;
+  position: sticky;
+  right: 0;
+  z-index: 12;
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 0 8px;
+  background: var(--bg-panel);
+}
+
+/* The dragged tab collapses out of the row so its old slot closes and the only
+   opening is the gap that slides open at the drop target. */
+.tab.dragging {
+  max-width: 0;
+  padding-left: 0;
+  padding-right: 0;
+  margin: 0;
+  border-color: transparent;
+  opacity: 0;
+  overflow: hidden;
+  pointer-events: none;
+}
+
+/* ── Drop target feedback (dragging a tab over another bar) ───────────────
+   While a tab (or file) is dragged over a tab bar, that bar becomes the active
+   drop target: it gets a subtle accent wash + top accent line so it's obvious
+   WHICH bar will receive the drop, and a placeholder slot is rendered at the
+   insertion point previewing WHERE the tab will land (with its label). */
+.tab-bar.drop-target {
+  background-color: color-mix(in srgb, var(--accent) 12%, var(--bg-panel));
+  box-shadow: inset 0 2px 0 var(--accent);
+}
+
+.tab-drop-placeholder {
+  /* A dashed accent slot the dragged tab will drop into. Sized like a tab so the
+     surrounding tabs slide to make exactly the room it will occupy. */
+  flex-shrink: 0;
+  align-self: flex-end;
+  height: 30px;
+  min-width: 96px;
+  max-width: 160px;
+  border: 1px dashed var(--accent);
+  border-bottom: none;
+  background: color-mix(in srgb, var(--accent) 18%, transparent);
+  pointer-events: none;
+  overflow: hidden;
+  animation: tab-drop-slot 0.16s ease-out;
+}
+
+.tab-drop-placeholder-label {
+  display: block;
+  padding: 0 12px;
+  line-height: 30px;
+  font-size: 12px;
+  color: var(--accent);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* Slot springs open from zero width so the insertion point reads as opening up
+   to receive the tab, not just appearing. */
+@keyframes tab-drop-slot {
+  0% {
+    min-width: 0;
+    max-width: 0;
+    opacity: 0;
+  }
+  100% {
+    min-width: 96px;
+    max-width: 160px;
+    opacity: 1;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .tab-drop-placeholder {
+    animation: none;
+  }
+}
+
+/* ── Drop-in landing flourish ─────────────────────────────────────────────
+   A tab dropped into a DIFFERENT tab bar (cross-group move / split) mounts
+   fresh in its destination bar and plays this one-shot "settle" so it's clear
+   where the dragged tab landed: it drops in from slightly above, overshoots,
+   and settles, ringed by a fading accent glow. The animation overrides the
+   active tab's inset shadow for its duration, then the inline style resumes. */
+.tab.landing {
+  animation: tab-land 0.34s cubic-bezier(0.2, 0.7, 0.3, 1);
+  /* Lift above neighbours so the overshoot/glow isn't clipped by adjacent tabs. */
+  position: relative;
+  z-index: 12;
+}
+
+@keyframes tab-land {
+  0% {
+    transform: translateY(-10px) scale(1.14);
+    opacity: 0;
+    box-shadow: 0 0 0 2px var(--accent);
+  }
+  55% {
+    transform: translateY(2px) scale(0.97);
+    opacity: 1;
+    box-shadow: 0 0 10px 1px color-mix(in srgb, var(--accent) 55%, transparent);
+  }
+  100% {
+    transform: translateY(0) scale(1);
+    opacity: 1;
+    box-shadow: 0 0 0 0 transparent;
+  }
+}
+
+/* Respect reduced-motion: collapse the landing to a plain fade-in. */
+@media (prefers-reduced-motion: reduce) {
+  .tab.landing {
+    animation: tab-land-fade 0.2s ease-out;
+  }
+  @keyframes tab-land-fade {
+    0% { opacity: 0; }
+    100% { opacity: 1; }
+  }
+}
+
+/* ── New-tab button + dropdown ───────────────────────────────────────── */
+.tab-new-wrap {
+  position: relative;
+  display: flex;
+  align-items: flex-end;
+  padding: 0;
+  margin-left: 0;
+  flex-shrink: 0;
+  align-self: flex-end;
+}
+
+.tab-new-btn {
+  width: 34px;
+  height: 30px;
+  border-radius: var(--radius-sm);
+  border: 1px solid transparent;
+  border-bottom: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 18px;
+  line-height: 1;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0;
+  transition: background-color var(--transition), color var(--transition), border-color var(--transition);
+}
+
+.tab-new-btn:hover {
+  background: var(--pill-hover-bg);
+  color: var(--text-primary);
+  border-top-color: var(--accent);
+  border-left-color: var(--control-border);
+  border-right-color: var(--control-border);
+}
+
+/* No tabs in this group yet: the + is the sole entry point, so breathe it in
+   the accent colour to invite a first tab. Reuses the working-tab pulse so the
+   cue matches the rest of the tab bar. Hovering cancels the pulse so it settles
+   into the normal affordance once the user reaches for it. */
+.tab-new-btn.empty-hint {
+  color: var(--accent);
+  animation: tab-working-pulse 1.6s ease-in-out infinite;
+}
+
+.tab-new-btn.empty-hint:hover {
+  animation: none;
+}
+
+/* One popover/menu surface for the whole app: context menus, the generic
+   dropdown (via .context-menu), the tab "+" menu and the project-switcher add
+   menu all read this. The individual rules keep only positioning / padding /
+   min-width. */
+.context-menu,
+.tab-new-menu,
+.project-switcher-add-menu {
+  position: relative;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  /* Accent top rail, matching the header bar and the dialog chrome above. */
+  border-top: 2px solid var(--accent);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-3);
+}
+
+/* Same accent wash as the header bar (.app-header::before) so every popover
+   menu reads as the same tinted color, not just an accent top rail. Layered
+   as an overlay (not folded into `background` above) so it works uniformly
+   whether the underlying surface is --bg-elevated or, in the glass themes,
+   --glass-elevated. */
+.context-menu::before,
+.tab-new-menu::before,
+.project-switcher-add-menu::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: var(--accent);
+  opacity: 0.32;
+  pointer-events: none;
+  z-index: -1;
+  border-radius: inherit;
+}
+
+.tab-new-menu {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  z-index: 100;
+  padding: 4px;
+  min-width: 132px;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+
+/* ── Unified scrolling-menu shape ───────────────────────────────────────────
+   A menu that can overflow must NOT scroll on its own element: that element
+   carries the rounded corners, the 2px accent top rail and the ::before accent
+   wash, and a native scrollbar on it runs straight over the corners/rail (looks
+   broken) while the absolutely-positioned wash only covers the visible box —
+   scrolling away and leaving the bottom untinted. Instead the menu keeps its
+   accent title (`.tab-new-menu-group-label`) PINNED as a direct child, and puts
+   everything else in a `.menu-scroll-region` that scrolls. The scrollbar then
+   starts BELOW the header and clears both rounded corners, and the wash (on the
+   non-scrolling menu) paints the full height behind it. This is the same split
+   the settings dialog makes with `.dialog-scroll`, generalised to every menu. */
+.menu-scroll-region {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+}
+/* Keep the pinned title from shrinking when the menu hits its max-height — only
+   the scroll region below it should give. Direct-child + first, so a group
+   label INSIDE the scroll region (e.g. the machines menu's "Add a machine")
+   still scrolls with its section. */
+.tab-new-menu > .tab-new-menu-group-label:first-child {
+  flex-shrink: 0;
+}
+
+/* The add menu's search box: auto-focused so "click + and type" filters the
+   entries immediately. Enter picks the highlighted first match. */
+.tab-new-menu-search {
+  margin: 2px 2px 4px;
+  padding: 5px 8px;
+  background: var(--control-bg);
+  border: 1px solid var(--border-color);
+  border-radius: calc(var(--radius) / 2);
+  color: var(--text-primary);
+  font-size: 12px;
+  outline: none;
+}
+
+.tab-new-menu-search:focus {
+  border-color: var(--accent);
+}
+
+.tab-new-menu-search::placeholder {
+  color: var(--text-muted);
+}
+
+/* The entry Enter would pick while a query is live — shown in the hover style
+   so the shortcut is visible before it fires. */
+.tab-new-menu-item.enter-target {
+  background-color: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.tab-new-menu-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 30px;
+  padding: 6px 10px;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  font-size: 12px;
+  text-align: left;
+  transition: background-color var(--transition);
+}
+
+.tab-new-menu-item:hover {
+  background-color: var(--control-hover-bg);
+}
+
+.tab-new-menu-item:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+
+.tab-new-menu-item:disabled:hover {
+  background: var(--control-bg);
+  border-color: transparent;
+}
+
+.tab-new-menu-dot { font-size: 8px; flex-shrink: 0; }
+
+/* A muted, right-aligned note in a locality menu row — "choose machine ›" on the
+   Remote drill-in, "sync off" on a worker that can't run scripts. */
+.tab-menu-hint {
+  margin-left: auto;
+  padding-left: 12px;
+  font-size: 10px;
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+/* The "‹ Run on machine" header row of the machine sub-picker: reads as a title,
+   not a target, and hosts the untested tag. */
+.tab-new-menu-item.tab-menu-back { color: var(--text-secondary); }
+.tab-new-menu-item.tab-menu-back .tab-new-menu-dot { font-size: 12px; }
+
+.tab-new-menu-group-label {
+  padding: 6px 10px 2px;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  /* Menu section header: accent so the groups ("Local Models" / "Load into
+     memory" / "Agents") separate from the item rows instead of reading like a
+     dimmed, disabled entry. */
+  color: var(--accent);
+  user-select: none;
+}
+
+.tab-new-menu-hint {
+  padding: 4px 10px;
+  font-size: 11px;
+  color: var(--text-muted);
+  font-style: italic;
+}
+
+/* #py right-click-Run "arguments" popover on a file-tree row. A transparent
+   full-window backdrop catches the outside click that closes it; the panel is
+   pinned at the cursor (clamped on-screen by useClampToViewport). Canonical
+   panel chrome + explicit colours (a portal child inherits none). */
+.file-run-args-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+}
+.file-run-args {
+  position: fixed;
+  z-index: 1001;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  min-width: 240px;
+  padding: 8px;
+  background: var(--bg-elevated);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-3);
+}
+.file-run-args-label {
+  font-size: 10px;
+  color: var(--text-muted);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.file-run-args-input {
+  background: var(--bg-input, var(--control-bg));
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 4px 6px;
+  font-family: var(--font-mono, monospace);
+  font-size: 11px;
+}
+.file-run-args-input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+.file-run-args-row {
+  display: flex;
+  gap: 6px;
+}
+.file-run-args-btn {
+  flex: 1;
+  background: transparent;
+  color: var(--text-muted);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 3px 8px;
+  font-size: 11px;
+  cursor: pointer;
+}
+.file-run-args-btn:hover {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+/* ── Context menus ───────────────────────────────────────────────────── */
+.context-menu {
+  position: fixed;
+  z-index: 1000;
+  min-width: 150px;
+  padding: 4px;
+}
+
+/* Glowing frame that floats onto the right-clicked file-tree row so it's
+   obvious which entry a context menu belongs to, even after the menu's been
+   repositioned to stay on-screen (see useClampToViewport). Purely cosmetic:
+   fixed-position, no pointer events, unmounts with the menu. */
+.file-entry-highlight {
+  position: fixed;
+  z-index: 999;
+  pointer-events: none;
+  border-radius: var(--radius-sm);
+  border: 2px solid var(--accent);
+  box-sizing: border-box;
+  animation:
+    file-entry-highlight-in 200ms cubic-bezier(0.16, 1, 0.3, 1) both,
+    file-entry-highlight-pulse 1.3s ease-in-out 200ms infinite;
+}
+
+@keyframes file-entry-highlight-in {
+  from {
+    opacity: 0;
+    transform: scale(1.18);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes file-entry-highlight-pulse {
+  0%, 100% {
+    box-shadow: 0 0 5px 1px var(--accent);
+  }
+  50% {
+    box-shadow: 0 0 13px 3px var(--accent);
+  }
+}
+
+/* A row the CSV table viewer just gained on a disk reload: flash an accent tint
+   for 3s, then let the cell's own inline background (stripe/sorted) reassert.
+   The animation targets the cells, not the row, because each <td> paints its own
+   background — and an animated property overrides that inline style while it runs.
+   The mix is opaque (over --bg-panel, not transparent) so the flash can't let the
+   scrolling body bleed through the sticky row-number gutter. */
+.csv-row-flash > td {
+  animation: csv-row-flash 3s ease-out;
+}
+
+@keyframes csv-row-flash {
+  from {
+    background-color: color-mix(in srgb, var(--accent) 28%, var(--bg-panel));
+  }
+  to {
+    background-color: var(--bg-panel);
+  }
+}
+
+.context-menu button {
+  display: block;
+  width: 100%;
+  min-height: 28px;
+  padding: 5px 9px;
+  border: 1px solid transparent;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  text-align: left;
+  font-size: 12px;
+  cursor: pointer;
+}
+
+.context-menu button:hover {
+  background: var(--control-hover-bg);
+}
+
+.context-menu button.danger {
+  color: var(--danger);
+}
+
+.context-menu hr {
+  height: 1px;
+  margin: 4px 0;
+  border: 0;
+  background: var(--border-subtle);
+}
+
+/* Grouped context menu: a small caption above each cluster of related items. */
+.context-menu-group + .context-menu-group,
+.context-menu-group + .context-menu-danger-zone {
+  margin-top: 6px;
+}
+
+.context-menu-group-label {
+  padding: 4px 9px 2px;
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-muted, var(--text-secondary));
+  user-select: none;
+}
+
+/* Danger zone: destructive actions fenced off in a red-tinted box. */
+.context-menu-danger-zone {
+  margin-top: 8px;
+  padding: 4px;
+  border: 1px solid color-mix(in srgb, var(--danger) 45%, transparent);
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--danger) 8%, transparent);
+}
+
+.context-menu-danger-zone .context-menu-group-label {
+  color: var(--danger);
+}
+
+.context-menu-danger-zone button {
+  color: var(--danger);
+  background: transparent;
+}
+
+.context-menu-danger-zone button:hover {
+  background: color-mix(in srgb, var(--danger) 16%, transparent);
+}
+
+/* "Untested" tag: marks a menu action (or any control) whose feature is
+   implemented but not yet live-verified in the running app. It stays until
+   that specific feature is confirmed working. A tagged context-menu button
+   lays its label and the tag out in a row, with the tag pushed to the right. */
+.context-menu button.untested {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.untested-tag {
+  margin-left: auto;
+  flex: 0 0 auto;
+  padding: 1px 5px;
+  border-radius: 999px;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  text-transform: uppercase;
+  line-height: 1.35;
+  color: var(--warning);
+  background: color-mix(in srgb, var(--warning) 14%, transparent);
+  border: 1px solid color-mix(in srgb, var(--warning) 45%, transparent);
+  user-select: none;
+}
+
+/* ── Dropdown (the one custom themed dropdown; native <select> popups can't
+   be themed on WebKitGTK so we render trigger + menu ourselves) ─────────── */
+.dropdown {
+  position: relative;
+  display: inline-flex;
+}
+
+.dropdown-trigger {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-height: 24px;
+  padding: 2px 8px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+  cursor: pointer;
+}
+
+.dropdown-trigger:hover:not(:disabled),
+.dropdown-trigger:focus-visible {
+  border-color: var(--accent);
+  outline: none;
+}
+
+.dropdown-trigger:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+
+.dropdown-caret {
+  font-size: 9px;
+  color: var(--text-muted);
+}
+
+.dropdown-menu {
+  position: absolute;
+  top: calc(100% + 2px);
+  left: 0;
+  min-width: 120px;
+  max-height: 260px;
+  overflow-y: auto;
+}
+
+/* Full-width variant: use when a Dropdown replaces a block form <select> so the
+   trigger fills its field width (label above, value left, caret right). */
+.dropdown.dropdown-block {
+  display: flex;
+  width: 100%;
+}
+
+.dropdown.dropdown-block .dropdown-trigger {
+  width: 100%;
+  justify-content: space-between;
+}
+
+.dropdown.dropdown-block .dropdown-menu {
+  right: 0;
+}
+
+/* Two-class specificity so per-toolbar `… button` rules (e.g. the file browser
+   actions row this menu lives inside) don't override the menu item look. */
+.dropdown .dropdown-menu button {
+  display: block;
+  width: 100%;
+  min-height: 28px;
+  padding: 5px 9px;
+  text-align: left;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+}
+
+.dropdown .dropdown-menu button:hover {
+  background: var(--control-hover-bg);
+}
+
+.dropdown .dropdown-menu button.selected {
+  color: var(--accent);
+  border-color: var(--accent);
+}
+
+/* ── File tree ────────────────────────────────────────────────────────── */
+.file-tree {
+  min-height: 100%;
+  box-sizing: border-box;
+  padding: 4px;
+}
+
+/* The pinned header (remote bar + search + breadcrumb). ONE sticky element so
+   its rows stack in flow instead of each sticking to top:0 and overlapping —
+   the path line used to hide behind the search box. Sits above the tree rows. */
+.file-tree-head {
+  position: sticky;
+  top: 0;
+  z-index: 3;
+  background: var(--bg-panel);
+}
+
+.file-tree-breadcrumb {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 1px;
+  width: 100%;
+  padding: 2px 4px 4px;
+  font-size: 12px;
+  background: var(--bg-panel);
+}
+
+.file-tree-path-edit {
+  padding: 2px 4px 4px;
+}
+
+.file-tree-path-input {
+  width: 100%;
+  padding: 3px 6px;
+  font-size: 12px;
+  font-family: var(--font-mono, monospace);
+  color: var(--text-primary);
+  background: var(--bg-input, var(--bg-panel));
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  outline: none;
+}
+
+.file-tree-up {
+  display: flex;
+  align-items: center;
+  padding: 2px 6px;
+  margin-right: 2px;
+  background: transparent;
+  border: none;
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-secondary);
+  border-radius: var(--radius-sm);
+}
+
+.file-tree-up:hover { background-color: var(--pill-hover-bg); }
+
+/* In-tree search (filename + content), shared by the right panel and the
+   Files (Project) tab since both render FileTree. */
+.file-tree-search {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  padding: 4px;
+  background: var(--bg-panel);
+  border-bottom: 1px solid var(--border-color);
+}
+
+.file-tree-search-row {
+  display: flex;
+  align-items: center;
+  gap: 3px;
+}
+
+.file-tree-search-input {
+  flex: 1;
+  min-width: 0;
+  font-size: 12px;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 3px 6px;
+  box-sizing: border-box;
+}
+
+.file-tree-search-clear {
+  flex-shrink: 0;
+  width: 20px;
+  height: 20px;
+  line-height: 1;
+  font-size: 14px;
+  background: transparent;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  border-radius: var(--radius-sm);
+}
+.file-tree-search-clear:hover { background-color: var(--pill-hover-bg); }
+
+.file-tree-search-modes {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+}
+
+.file-tree-search-mode {
+  font-size: 10px;
+  padding: 1px 7px;
+  height: 18px;
+  background: transparent;
+  color: var(--text-secondary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+}
+.file-tree-search-mode:hover { background-color: var(--pill-hover-bg); }
+.file-tree-search-mode.active {
+  color: var(--accent);
+  border-color: var(--accent);
+}
+
+.file-tree-search-scope {
+  margin-left: auto;
+  display: flex;
+  gap: 2px;
+  min-width: 0;
+}
+.file-tree-search-scope-folder {
+  max-width: 96px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-search-count {
+  font-size: 10px;
+  color: var(--text-muted);
+  padding: 4px 8px 2px;
+}
+
+.file-search-row { cursor: pointer; }
+
+.file-search-path {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  direction: rtl;
+  text-align: left;
+}
+
+.file-search-hl {
+  background: var(--accent);
+  color: var(--bg-panel);
+  border-radius: 2px;
+}
+
+.file-search-act {
+  flex-shrink: 0;
+  margin-left: auto;
+  width: 20px;
+  height: 20px;
+  line-height: 1;
+  font-size: 12px;
+  background: transparent;
+  border: none;
+  color: var(--text-secondary);
+  cursor: pointer;
+  border-radius: var(--radius-sm);
+}
+.file-search-act:hover {
+  background-color: var(--pill-hover-bg);
+  color: var(--text-primary);
+}
+
+.file-search-content { align-items: flex-start; }
+
+.file-search-content-body {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  min-width: 0;
+  flex: 1;
+}
+
+.file-search-loc {
+  font-size: 10px;
+  color: var(--text-muted);
+}
+
+.file-search-line {
+  font-size: 11px;
+  color: var(--text-primary);
+  font-family: monospace;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.file-tree-remote-bar {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  width: 100%;
+  padding: 2px 4px;
+}
+
+.file-tree-refresh:disabled { opacity: 0.5; cursor: default; }
+
+.file-tree-remote-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--text-secondary);
+  opacity: 0.7;
+}
+
+/* SSH-sync Phase 1: in-flight transfer counter in the remote bar. */
+.file-tree-sync-progress {
+  font-size: 10px;
+  color: var(--success, #3fb950);
+  margin-left: auto;
+  white-space: nowrap;
+}
+
+/* SSH-sync Phase 1: local/remote source toggle row in the files view. */
+.right-panel-source {
+  display: flex;
+  align-items: center;
+  gap: 1px;
+  padding: 2px 6px;
+  border-bottom: 1px solid var(--border-subtle);
+  flex-shrink: 0;
+}
+
+/* Compact (docked subwindow) viewer: the Remote/Local switch alone, on its own
+   row where the stripped header would have been — above the Files/Git/Search/
+   Apps toolbar, so the compact viewer stacks in the same order as the right
+   panel. Left-aligned with the tree content below it. */
+.right-panel-source--compact {
+  padding: 4px 6px;
+  /* A docked subwindow viewer is narrow: the switch + the run-host picker do not
+     fit on one line at every width, and both were `flex-shrink: 0`, so the picker
+     ran out past the window's right border. Let the row wrap and let the picker
+     shrink (its label ellipsizes) rather than overflow. */
+  flex-wrap: wrap;
+  gap: 4px 6px;
+  min-width: 0;
+  overflow: hidden;
+}
+.right-panel-source--compact .right-panel-run-host {
+  margin-left: 0;
+  flex-shrink: 1;
+  min-width: 0;
+  max-width: 100%;
+}
+
+/* Remote/Local file-source switch in the panel header (remote SSH projects
+   only). A live segmented control — deliberately shaped as a switch (grouped
+   segments in an inset track), NOT a chip, so it can never be mistaken for one
+   of the static project type tags it sits near. Given its own row (flex-basis
+   100%) left-aligned with the pin / project name, sitting above the
+   Add/Commit/Push row which wraps below it. The active segment's fill matches
+   the viewer's source badge: green = the local synced mirror, amber = the host
+   tree over SFTP. */
+.right-panel-source-switch {
+  flex-shrink: 0;
+  margin-left: 0;
+  display: inline-flex;
+  align-items: stretch;
+  padding: 1px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-subtle);
+  background: var(--bg-inset, rgba(127, 127, 127, 0.12));
+}
+.right-panel-source-switch .source-seg {
+  flex-shrink: 0;
+  padding: 1px 7px;
+  height: 16px;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-secondary);
+  font-family: inherit;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  line-height: 1;
+  cursor: pointer;
+}
+.right-panel-source-switch .source-seg:hover:not(.active):not(:disabled) {
+  color: var(--text-primary);
+}
+.right-panel-source-switch .source-seg:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+.right-panel-source-switch .source-seg.active {
+  /* Not a fixed white: the active fill is --success/--warning, which in
+     fancy_dark are light pastel green/amber — white text on those is nearly
+     unreadable. --bg-main tracks light/dark per theme instead (same fix as
+     .btn-primary/.btn-danger above). */
+  color: var(--bg-main);
+}
+.right-panel-source-switch .source-seg:first-child.active {
+  background: var(--success);
+}
+.right-panel-source-switch .source-seg:last-child.active {
+  background: var(--warning);
+}
+
+/* Run-host picker beside the Remote/Local switch — which MACHINE scripts/shells
+   launched from this project run on (the source switch is which side files are
+   read from). Quiet chrome that matches the switch; the ⌂/☁ glyph tints by side. */
+.right-panel-run-host {
+  flex-shrink: 0;
+  margin-left: 6px;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  height: 18px;
+  padding: 1px 7px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-subtle);
+  background: var(--bg-inset, rgba(127, 127, 127, 0.12));
+  color: var(--text-secondary);
+  font-family: inherit;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  line-height: 1;
+  cursor: pointer;
+}
+.right-panel-run-host:hover { color: var(--text-primary); }
+.right-panel-run-host .run-host-label {
+  text-transform: none;
+  letter-spacing: normal;
+  /* The label carries a machine NAME, which can be long (a fqdn). Truncate it
+     inside the button instead of pushing the button past its container. */
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* One-click SSH logout beside the Remote/Local switch, shown only while SSH is
+   connected (moved here from the project pill). Same quiet chrome as the
+   switch; the danger tint only appears on hover, so a connected project isn't
+   shouting red at rest. */
+.right-panel-conn-logout {
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  margin-left: 6px;
+  padding: 2px 7px;
+  height: 18px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-secondary);
+  font-family: inherit;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  line-height: 1;
+  cursor: pointer;
+}
+.right-panel-conn-logout:hover {
+  border-color: color-mix(in srgb, var(--danger) 45%, transparent);
+  background: color-mix(in srgb, var(--danger) 18%, transparent);
+  color: var(--danger);
+}
+
+.file-tree-crumb {
+  padding: 2px 4px;
+  background: transparent;
+  border: none;
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-secondary);
+  border-radius: var(--radius-sm);
+  max-width: 140px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-tree-crumb:hover { background-color: var(--pill-hover-bg); }
+
+.file-tree-crumb.current {
+  color: var(--text-primary);
+  cursor: default;
+}
+
+.file-tree-crumb.current:hover { background-color: transparent; }
+
+/* Remote source: breadcrumb segments the host tree does / doesn't have. The
+   distinction is carried by SHAPE first so it survives colour-blindness and any
+   theme — a struck-through segment with a ⊘ badge is local-only, a plain (subtly
+   underlined) one is on the host — with a success/danger tint added only as
+   reinforcement, never as the sole signal. */
+.file-tree-crumb.crumb-on-host {
+  color: var(--success);
+  text-decoration: underline;
+  text-decoration-thickness: 1px;
+  text-underline-offset: 2px;
+}
+.file-tree-crumb.crumb-missing {
+  color: var(--danger, #f85149);
+  text-decoration: line-through;
+  text-decoration-thickness: 1px;
+  opacity: 0.85;
+}
+.file-tree-crumb.crumb-missing::after {
+  content: "⊘";
+  margin-left: 3px;
+  font-size: 0.85em;
+  text-decoration: none;
+  display: inline-block;
+}
+
+.file-tree-crumb-sep {
+  color: var(--text-muted);
+  font-size: 11px;
+}
+
+.file-tree-loading,
+.file-tree-empty {
+  padding: 8px 12px;
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.file-tree-error {
+  padding: 8px 12px;
+  font-size: 11px;
+  color: var(--danger);
+  word-break: break-all;
+}
+
+.file-entry {
+  display: flex;
+  align-items: flex-start;
+  gap: 6px;
+  padding: 3px 8px;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  font-size: 12px;
+  color: var(--text-primary);
+  user-select: none;
+}
+
+.file-entry:hover { background-color: var(--pill-hover-bg); }
+
+/* Multi-selection highlight (click / shift-range / ctrl-toggle). Sits above the
+   plain hover but below the move-drop-target outline. */
+.file-entry.selected { background-color: var(--accent-soft, rgba(88, 166, 255, 0.22)); }
+.file-entry.selected:hover { background-color: var(--accent-soft, rgba(88, 166, 255, 0.28)); }
+
+/* The tree is focusable (tabIndex) so it can catch Enter/Escape for the
+   selection; suppress the focus ring around the whole panel. */
+.file-tree:focus { outline: none; }
+
+/* Files never start a native (browser) drag — embeddable ones use a pointer
+   drag to a tab bar, and every file can be pointer-dragged into a folder to move
+   it. Suppress the webview's built-in drag of the row text/icon. Dirs keep
+   native DnD (export). */
+.file-entry.file,
+.file-entry.file * {
+  -webkit-user-drag: none;
+  user-drag: none;
+}
+
+/* …EXCEPT while a row is explicitly armed draggable (Ctrl held → native OS
+   drag-out, FileTree's handleEntryDragStart). Chromium/WebView2 resolves the
+   drag source from the computed -webkit-user-drag alone — its UA sheet maps
+   [draggable=true] to `element`, so the author-origin `none` above outranks
+   the attribute and `dragstart` never fires: the Ctrl file export silently
+   did nothing on Windows. (WebKitGTK honors the attribute, so Linux never
+   hit this.) Children are re-armed too so a press landing on the name/size
+   spans still starts the drag. */
+.file-entry.file[draggable="true"],
+.file-entry.file[draggable="true"] * {
+  -webkit-user-drag: element;
+  user-drag: element;
+}
+
+/* Drag-to-move highlight: the folder row / breadcrumb / up button currently
+   under the cursor while a file is being dragged. Releasing moves the file in. */
+.file-entry.move-drop-target,
+.file-tree-up.move-drop-target,
+.file-tree-crumb.move-drop-target {
+  background-color: var(--accent-soft, rgba(88, 166, 255, 0.22));
+  outline: 1px solid var(--accent);
+  outline-offset: -1px;
+  border-radius: var(--radius-sm);
+}
+
+/* Dragging a download over empty tree space (not a specific folder) targets the
+   currently browsed folder — frame the whole tree area so the drop is legible. */
+.right-panel-scroll.move-drop-target {
+  outline: 2px dashed var(--accent);
+  outline-offset: -3px;
+  border-radius: var(--radius-sm);
+}
+
+/* Let the flex-1 tree scroll actually shrink when the Downloads section below it
+   grows (a flex child won't shrink past its content without min-height:0). */
+.right-panel-scroll {
+  min-height: 0;
+  /* Disable scroll anchoring. The tree's content height shifts after mount —
+     directory sizes stream in asynchronously and (in the narrow docked sidebar)
+     the size badges re-wrap long file names — so with anchoring on the browser
+     keeps re-adjusting scrollTop toward the sticky `.file-tree-head`, snapping
+     the view back up whenever you scroll near the bottom (can never reach the
+     end). Off, the wheel scroll stays put. */
+  overflow-anchor: none;
+}
+
+/* ── Downloads section (right panel, below the file tree) ─────────────────── */
+.downloads-section {
+  display: flex;
+  flex-direction: column;
+  border-top: 1px solid var(--border-color);
+  background: var(--bg-panel);
+  flex: 0 0 auto;
+  min-height: 0;
+}
+/* Grab bar spanning the top border: drag to grow/shrink the section height. */
+.downloads-resize {
+  height: 6px;
+  margin-top: -3px;
+  cursor: ns-resize;
+  flex: 0 0 auto;
+  background: transparent;
+}
+.downloads-resize:hover {
+  background: var(--accent-soft, rgba(88, 166, 255, 0.22));
+}
+.downloads-header {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 3px 6px;
+  border-bottom: 1px solid var(--border-color);
+}
+.downloads-title {
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--text-primary);
+  white-space: nowrap;
+}
+.downloads-windows {
+  display: flex;
+  gap: 2px;
+  margin-left: auto;
+}
+.downloads-win-btn {
+  font-size: 10px;
+  padding: 1px 6px;
+  height: 20px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-secondary, var(--text-primary));
+  cursor: pointer;
+}
+.downloads-win-btn.active {
+  color: var(--accent);
+  border-color: var(--accent);
+}
+.downloads-target {
+  font-size: 10px;
+  color: var(--text-muted, var(--text-secondary));
+  padding: 2px 8px;
+  border-bottom: 1px solid var(--border-color);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.downloads-error {
+  font-size: 10px;
+  color: var(--danger, #f85149);
+  word-break: break-all;
+  padding: 2px 8px;
+}
+.downloads-list {
+  flex: 1;
+  overflow-y: auto;
+  min-height: 40px;
+}
+.downloads-row {
+  cursor: grab;
+}
+.downloads-meta {
+  font-size: 10px;
+  color: var(--text-muted, var(--text-secondary));
+  white-space: nowrap;
+  margin-left: 6px;
+}
+.downloads-copied {
+  color: var(--accent);
+  font-size: 12px;
+  margin-left: 4px;
+}
+
+/* Only EMBEDDABLE files can be dragged onto a subwindow's tab bar (Group K).
+   Give just those a subtle 3D "pop up" on hover so the drag affordance is
+   discoverable; non-embeddable files get no effect, signalling they're not
+   draggable (they open on double-click). */
+.file-entry.file.embeddable {
+  /* NOTE: `box-shadow` is deliberately NOT transitioned here — see ::before. */
+  transition: transform var(--transition), background-color var(--transition);
+  transform: translateZ(0);
+  position: relative;
+}
+/* The lift shadow is painted ONCE on a pseudo-element and faded in with
+   `opacity`, rather than transitioned as a blurred `box-shadow` on the row
+   itself. With the DMABUF renderer disabled (forced in `lib.rs` after the
+   Mesa/SIGBUS crash) every frame of a blur transition is re-rasterized on the
+   CPU — and since the row also `scale()`s, the blur is a different size each
+   frame and cannot be cached either. Sweeping the pointer down the tree started
+   an overlapping transition per row, each re-blurring two shadows per frame,
+   which is what made hovering the file viewer crawl. Opacity is compositor-
+   driven, so the same look now costs nothing to animate. */
+.file-entry.file.embeddable::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  z-index: -1;
+  border-radius: inherit;
+  pointer-events: none;
+  opacity: 0;
+  transition: opacity var(--transition);
+  box-shadow:
+    0 5px 12px rgba(0, 0, 0, 0.35),
+    0 1px 3px rgba(0, 0, 0, 0.25);
+}
+.file-entry.file.embeddable:hover::before {
+  opacity: 1;
+}
+.file-entry.file.embeddable:hover {
+  z-index: 2;
+  cursor: grab;
+  transform: translateY(-2px) scale(1.02);
+}
+.file-entry.file.embeddable:active {
+  cursor: grabbing;
+  transform: translateY(0) scale(1.0);
+}
+/* Pressed: the row settles back down, so fade the same shadow rather than
+   painting a second one over it. */
+.file-entry.file.embeddable:active::before {
+  opacity: 0.45;
+}
+
+.file-run-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  flex-shrink: 0;
+  padding: 0;
+  border: 1px solid color-mix(in srgb, var(--success) 70%, transparent);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--success);
+  font-size: 10px;
+  line-height: 1;
+  cursor: pointer;
+}
+
+.file-run-btn:hover {
+  background: color-mix(in srgb, var(--success) 14%, transparent);
+  border-color: var(--success);
+}
+
+/* A running tab-backed or detached run pulses green — the app's shared "PTY
+   producing sustained output" vocabulary (cf. @keyframes tab-glow-working). The
+   detached `.sh` path also sets `disabled`, hence the default cursor. */
+.file-run-btn.running {
+  cursor: default;
+  color: var(--success);
+  animation: file-run-pulse 1.5s ease-in-out infinite;
+}
+@keyframes file-run-pulse {
+  0%, 100% { background: color-mix(in srgb, var(--success) 8%, transparent);
+             border-color: color-mix(in srgb, var(--success) 45%, transparent); }
+  50%      { background: color-mix(in srgb, var(--success) 30%, transparent);
+             border-color: var(--success); }
+}
+/* Motion opt-outs (match the tab-glow blocks at :6798 / :6882): collapse to a
+   steady green tint — the running state stays visible, the repaint stops. */
+@media (prefers-reduced-motion: reduce) {
+  .file-run-btn.running { animation: none;
+    background: color-mix(in srgb, var(--success) 18%, transparent); }
+}
+:root[data-energy-saver="on"] .file-run-btn.running { animation: none;
+  background: color-mix(in srgb, var(--success) 18%, transparent); }
+
+.file-run-spinner {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  border: 1.5px solid color-mix(in srgb, var(--success) 30%, transparent);
+  border-top-color: var(--success);
+  animation: file-run-spin 0.7s linear infinite;
+}
+
+@keyframes file-run-spin {
+  to { transform: rotate(360deg); }
+}
+
+/* SSH-sync: actionable buttons shown left of the icon per sync state — red on an
+   unsynced row (pull from host / push from the mirror), orange on a diverged row
+   (view the host-vs-mirror diff). Shared box geometry; the accent color differs.
+   `--danger` = not synced, `#d29922` (amber) = diverged. */
+/* Fixed-width gutter reserving space for the sync/diff button so file & folder
+   names stay left-aligned across a sync-tracked tree even on rows with no button
+   (in-sync/green). Sits between the git-status marker and the file icon. */
+.file-sync-slot {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  flex-shrink: 0;
+}
+
+.file-sync-btn,
+.file-diff-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  flex-shrink: 0;
+  padding: 0;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  font-size: 9px;
+  line-height: 1;
+  cursor: pointer;
+}
+
+.file-sync-btn {
+  border: 1px solid color-mix(in srgb, var(--danger) 70%, transparent);
+  color: var(--danger);
+}
+
+.file-sync-btn:hover {
+  background: color-mix(in srgb, var(--danger) 14%, transparent);
+  border-color: var(--danger);
+}
+
+.file-diff-btn {
+  border: 1px solid color-mix(in srgb, #d29922 70%, transparent);
+  color: #d29922;
+}
+
+.file-diff-btn:hover {
+  background: color-mix(in srgb, #d29922 14%, transparent);
+  border-color: #d29922;
+}
+
+.file-sync-btn:disabled,
+.file-diff-btn:disabled {
+  cursor: default;
+  opacity: 0.5;
+}
+
+/* Auto-sync row indicator (non-interactive): a subtle accent glyph shown in the
+   sync slot when a file/folder auto-syncs and is in its resting (green) state. */
+.file-autosync-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  font-size: 10px;
+  line-height: 1;
+  color: var(--accent, #3fb950);
+  opacity: 0.85;
+}
+
+/* Excluded-from-sync row indicator (non-interactive): takes over the sync slot
+   ahead of the red/orange/auto icons — an excluded path has no sync action to
+   offer. Deliberately grey/muted, not tinted like the local/remote pair: this
+   isn't "which side wins", it's "sync doesn't apply here at all". */
+.file-sync-excluded {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 16px;
+  height: 16px;
+  font-size: 9px;
+  line-height: 1;
+  color: var(--text-muted);
+  opacity: 0.85;
+}
+
+/* Local-mirror view: a folder that exists only in the local mirror and not on
+   the remote host. Dim the whole row and tag it, so "Local" mode never quietly
+   implies the whole tree is on the remote. */
+.file-entry.not-on-remote .file-icon,
+.file-entry.not-on-remote .file-name {
+  color: var(--text-muted, #687899);
+}
+
+/* "local only" = green, matching the local/remote color language the
+   diverged-files badges use (local = --success, remote = --warning) — this
+   tag names the LOCAL side, not a remote-side warning. */
+.file-offhost-tag {
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  align-self: center;
+  margin-left: 4px;
+  padding: 0 5px;
+  width: 64px;
+  height: 16px;
+  box-sizing: border-box;
+  border-radius: 999px;
+  font-size: 9px;
+  line-height: 1;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  color: var(--success);
+  border: 1px solid color-mix(in srgb, var(--success) 45%, transparent);
+  background: color-mix(in srgb, var(--success) 12%, transparent);
+  white-space: nowrap;
+  user-select: none;
+}
+
+.file-entry.not-on-remote .file-size {
+  width: 9ch;
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+}
+
+/* Right-panel "orange" (diverged) toolbar button + its count badge. */
+.right-panel-orange-btn.active {
+  color: #d29922;
+  border-color: color-mix(in srgb, #d29922 60%, transparent);
+}
+
+.right-panel-orange-count {
+  display: inline-block;
+  min-width: 12px;
+  padding: 0 3px;
+  margin-left: 2px;
+  border-radius: var(--radius);
+  background: #d29922;
+  color: #1a1a1a;
+  font-size: 9px;
+  line-height: 13px;
+  text-align: center;
+}
+
+/* Right-panel "orange" list view. */
+.right-panel-orange {
+  padding: 4px 6px;
+}
+
+.right-panel-orange-empty {
+  padding: 12px 8px;
+  color: var(--text-muted);
+  font-size: 11px;
+  text-align: center;
+}
+/* Section caption inside the Jobs view (the workspaces block above the queue). */
+.right-panel-orange-note {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 6px;
+  padding: 4px 8px 2px;
+  color: var(--text-muted);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+/* The workspace-expiry warning. Raised in every view of a project whose host
+   tree lives in a workspace, because expiry deletes that tree — not just data. */
+.hpc-expiry-banner {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 5px 8px;
+  font-size: 11px;
+  border-bottom: 1px solid var(--border-color);
+  background: color-mix(in srgb, var(--warning, #d29922) 14%, transparent);
+  color: var(--text-primary);
+}
+.hpc-expiry-banner.tone-urgent {
+  background: color-mix(in srgb, var(--danger, #f85149) 16%, transparent);
+}
+.hpc-expiry-actions {
+  display: flex;
+  gap: 4px;
+  flex: none;
+}
+.hpc-expiry-actions button {
+  font-size: 10px;
+  padding: 1px 6px;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+}
+
+/* Bulk "…for all" resolution bar atop the diverged list. */
+.orange-bulk-bar {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 4px;
+  padding: 3px 0 6px;
+  margin-bottom: 3px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.orange-bulk-count {
+  font-size: 10px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.orange-file-row {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 0;
+  border-bottom: 1px solid color-mix(in srgb, var(--border-color) 60%, transparent);
+}
+
+.orange-file-name {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  background: transparent;
+  border: none;
+  color: var(--text-primary);
+  font-size: 11px;
+  text-align: left;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  cursor: pointer;
+}
+
+.orange-file-name:disabled {
+  cursor: default;
+}
+
+.orange-file-name:hover:not(:disabled) {
+  color: var(--accent, #3fb950);
+}
+
+.orange-file-dot {
+  color: #d29922;
+  flex-shrink: 0;
+}
+
+/* Timestamp-only comparison for a diverged pair: a small pill, tinted by
+   which side it points at (remote vs local) using the same theme tokens as
+   the take-remote/keep-local icon buttons below, so the two read as one
+   language — and the same orange/green pair the diverged (±) dot and the
+   "Take"/"Keep" split already use elsewhere in this view. It deliberately
+   stays a *cue*, never an automatic resolution — remote/local clocks can
+   differ, and the full "modified when" detail lives in the tooltip rather
+   than the pill itself. */
+.orange-mtime-badge {
+  flex-shrink: 0;
+  padding: 1px 6px;
+  border-radius: var(--radius-full);
+  font-size: 9px;
+  font-weight: 600;
+  line-height: 1.5;
+  letter-spacing: 0.02em;
+  white-space: nowrap;
+  border: 1px solid transparent;
+}
+
+.orange-mtime-badge--remote {
+  color: var(--warning);
+  background: color-mix(in srgb, var(--warning) 16%, transparent);
+  border-color: color-mix(in srgb, var(--warning) 35%, transparent);
+}
+
+.orange-mtime-badge--local {
+  color: var(--success);
+  background: color-mix(in srgb, var(--success) 16%, transparent);
+  border-color: color-mix(in srgb, var(--success) 35%, transparent);
+}
+
+.orange-mtime-badge--neutral {
+  color: var(--text-secondary);
+  background: color-mix(in srgb, var(--text-secondary) 14%, transparent);
+  border-color: color-mix(in srgb, var(--text-secondary) 30%, transparent);
+}
+
+/* Persistent (tmux) sessions view (TODO #85): the row's "open" hint (a shell
+   tab already has this session attached), dimmed so the session name stays
+   the row's focus. Windows/uptime/idle-time moved to the dwell-hover stats
+   card (`.file-tooltip`, shared with the file tree) rather than crowding the
+   row. */
+.tmux-session-meta {
+  margin-left: 6px;
+  color: var(--text-secondary, #8b949e);
+  font-size: 10px;
+  flex-shrink: 0;
+}
+
+/* The row's own name label: a short, stable stand-in (`sessionDisplayName`)
+   for the raw `eldrun-<uuid>`, which lives in full in the hover stats card
+   instead of overflowing the row. */
+.tmux-session-label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+/* Working indicator (TODO #85): the active pane is running something other
+   than a bare shell — reuses the "host has live work on it" pulse vocabulary
+   `.conn-lamp-busy` already established for the connection lamps, so a
+   breathing dot means the same thing everywhere in the app. `opacity`-only
+   animation on a pseudo-element, not `box-shadow` on the dot itself — see the
+   perf note above `.conn-lamp-busy` (rasterising a blurred shadow every frame
+   is pure CPU with the DMABUF renderer disabled). */
+.tmux-work-dot {
+  position: relative;
+  flex-shrink: 0;
+  width: 6px;
+  height: 6px;
+  margin-left: 2px;
+  border-radius: 50%;
+  background: var(--success);
+}
+.tmux-work-dot::after {
+  content: "";
+  position: absolute;
+  inset: -3px;
+  border-radius: 50%;
+  pointer-events: none;
+  box-shadow:
+    0 0 6px color-mix(in srgb, var(--success) 90%, transparent),
+    0 0 10px color-mix(in srgb, var(--success) 45%, transparent);
+  will-change: opacity;
+  animation: conn-lamp-busy-pulse 1.8s ease-in-out infinite;
+}
+
+/* Machine sections in the persistent-session view. Uses the shared elevation,
+   border, and accent tokens so it remains legible in every bundled theme. */
+.tmux-machine-group {
+  margin: 3px 0 8px;
+  overflow: hidden;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--bg-panel);
+}
+
+.tmux-machine-group-title {
+  padding: 5px 7px;
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-elevated, var(--bg-panel));
+  color: var(--accent);
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+}
+
+/* The Sessions view's project-scope escape hatch (TODO #85): off (the default)
+   lists only this project's sessions, on lists the whole host. */
+.tmux-scope-toggle {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  padding: 4px 7px 6px;
+  color: var(--text-secondary, var(--text-primary));
+  font-size: 10px;
+  cursor: pointer;
+  user-select: none;
+}
+
+.tmux-scope-toggle input {
+  margin: 0;
+  cursor: pointer;
+}
+
+.tmux-machine-group .orange-file-row {
+  border-bottom: 1px solid var(--border-color);
+}
+
+.tmux-machine-group .orange-file-row:last-child {
+  border-bottom: 0;
+}
+
+.orange-file-actions {
+  display: inline-flex;
+  gap: 4px;
+  flex-shrink: 0;
+}
+
+.orange-file-act {
+  background: transparent;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  color: var(--text-muted);
+  font-size: 9px;
+  padding: 1px 5px;
+  cursor: pointer;
+}
+
+.orange-file-act:hover:not(:disabled) {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+.orange-file-act:disabled {
+  cursor: default;
+  opacity: 0.5;
+}
+
+/* Icon-only variant (take remote ⬇ / keep local ⬆): same control, no label
+   text repeated on every row. Tinted remote = --warning (orange, matching the
+   ± diverged dot), local = --success (green) — the same pair the mtime badge
+   above uses, so "which side" reads as one color language across the row
+   instead of a wall of "Take host"/"Keep local". */
+.orange-file-act--icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  padding: 0;
+  font-size: 11px;
+  line-height: 1;
+}
+
+.orange-file-act--icon.orange-file-act--remote {
+  color: var(--warning);
+  border-color: color-mix(in srgb, var(--warning) 35%, transparent);
+}
+
+.orange-file-act--icon.orange-file-act--remote:hover:not(:disabled) {
+  color: var(--warning);
+  background: color-mix(in srgb, var(--warning) 16%, transparent);
+  border-color: var(--warning);
+}
+
+.orange-file-act--icon.orange-file-act--local {
+  color: var(--success);
+  border-color: color-mix(in srgb, var(--success) 35%, transparent);
+}
+
+.orange-file-act--icon.orange-file-act--local:hover:not(:disabled) {
+  color: var(--success);
+  background: color-mix(in srgb, var(--success) 16%, transparent);
+  border-color: var(--success);
+}
+
+/* Nested-repo toggle: segmented control shown atop the git view when the browsed
+   folder resolves to a git repo distinct from the project's repo (#nested-git). */
+.nested-repo-toggle {
+  display: flex;
+  gap: 2px;
+  padding: 5px 6px;
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-panel);
+}
+
+.nested-repo-pill {
+  flex: 1;
+  min-width: 0;
+  background: transparent;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  color: var(--text-muted);
+  font-size: 10px;
+  padding: 2px 6px;
+  cursor: pointer;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.nested-repo-pill:hover:not(.active) {
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+.nested-repo-pill.active {
+  color: var(--text-primary);
+  border-color: var(--accent, #58a6ff);
+  background: color-mix(in srgb, var(--accent, #58a6ff) 18%, transparent);
+  cursor: default;
+}
+
+.file-tree-section-divider {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 8px;
+  padding: 4px 4px 2px;
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--text-secondary);
+  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
+}
+
+.file-entry.scaffold {
+  opacity: 0.65;
+}
+
+.file-tree-hidden-toggle {
+  width: 100%;
+  background: none;
+  border: none;
+  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
+  cursor: pointer;
+  text-align: left;
+}
+
+.file-tree-hidden-toggle:hover {
+  color: var(--text-primary);
+}
+
+/* Footer for the tree's render cap (see ROW_CAP_STEP in FileTree.tsx). Wears the
+   section-divider chrome so it reads as another band in the list, but centered
+   and in the accent color — it is an action, not a heading. */
+.file-tree-more {
+  width: 100%;
+  justify-content: center;
+  background: none;
+  border: none;
+  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
+  cursor: pointer;
+  color: var(--accent, #58a6ff);
+}
+
+.file-tree-more:hover {
+  background-color: var(--pill-hover-bg);
+}
+
+.file-tree-hidden-caret {
+  display: inline-block;
+  width: 9px;
+  font-size: 9px;
+}
+
+.file-tree-path-total {
+  margin-left: auto;
+  padding-left: 8px;
+  font-size: 10px;
+  font-weight: 400;
+  letter-spacing: normal;
+  text-transform: none;
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+
+.file-tree-scaffold-toggle {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  padding: 2px 8px 4px;
+  font-size: 10px;
+  color: var(--text-muted);
+  cursor: pointer;
+  user-select: none;
+}
+
+.file-tree.drag-over {
+  outline: 2px dashed var(--accent, #58a6ff);
+  outline-offset: -2px;
+  border-radius: var(--radius);
+  background: rgba(88, 166, 255, 0.06);
+}
+
+.file-icon { font-size: 12px; flex-shrink: 0; line-height: 1.3; }
+.file-name { flex: 1; min-width: 0; overflow-wrap: anywhere; word-break: break-word; line-height: 1.3; }
+.file-size { font-size: 10px; color: var(--text-muted); flex-shrink: 0; line-height: 1.3; }
+.file-size.size-small  { color: var(--text-muted); }
+.file-size.size-medium { color: #e3b341; }
+.file-size.size-large  { color: #f0883e; }
+.file-size.size-huge   { color: #f85149; }
+/* A folder excluded from scans. Italic and dimmer than `size-small` so it reads
+   as "no measurement" rather than as a very small one — the whole point is that
+   nothing was walked, and a number-shaped grey would suggest otherwise. */
+.file-size-excluded { font-style: italic; opacity: 0.65; }
+
+.file-tooltip {
+  position: fixed;
+  z-index: 9999;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  padding: 6px 10px;
+  font-size: 11px;
+  color: var(--text-primary);
+  pointer-events: none;
+  white-space: nowrap;
+  line-height: 1.8;
+  box-shadow: var(--shadow-2);
+}
+.file-tooltip-label {
+  color: var(--text-muted);
+  margin-right: 8px;
+  display: inline-block;
+  width: 5.5em;
+}
+.file-tooltip-name {
+  font-weight: 600;
+  margin-bottom: 2px;
+}
+/* Same grey the row's own excluded-sync glyph (`.file-sync-excluded`) uses —
+   this isn't a Created/Modified fact, it's a sync-state callout. */
+.file-tooltip-excluded {
+  color: var(--text-muted);
+  font-size: 10px;
+  margin-bottom: 2px;
+}
+/* A sub-entry nested under the row above it (e.g. saved run args under Run),
+   rather than another top-level label — indented, and a touch dimmer/smaller
+   so it reads as detail, not a peer fact like Created/Modified. */
+.file-tooltip-sub {
+  margin-left: 1.5em;
+  font-size: 10px;
+  opacity: 0.85;
+}
+
+.file-delete-dialog {
+  width: min(360px, calc(100vw - 32px));
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 18px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  /* Portaled into <body>, which sets no text color (defaults to black); set it
+     here so bare descendants (h2 title, the diff <pre>, tables) stay readable in
+     dark themes instead of inheriting black. */
+  color: var(--text-primary);
+  box-shadow: var(--shadow-3);
+}
+
+.file-delete-dialog h2 {
+  margin: 0;
+  /* Match the canonical dialog header (.settings-title-row h2): accent-colored,
+     heavier weight, and a divider under it, so every menu shares one look. */
+  font-size: 16px;
+  font-weight: 650;
+  color: var(--accent);
+  border-bottom: 1px solid var(--border-subtle);
+  padding-bottom: 10px;
+}
+
+.file-delete-dialog p {
+  margin: 0;
+  font-size: 13px;
+  color: var(--text-primary);
+}
+
+.file-delete-path {
+  padding: 7px 8px;
+  background: var(--control-bg);
+  border: 1px solid var(--border-subtle);
+  color: var(--text-muted);
+  font-size: 11px;
+  word-break: break-all;
+}
+
+.file-delete-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.file-delete-actions button {
+  border: 1px solid var(--control-border);
+  padding: 7px 10px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.file-delete-actions button:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.file-delete-actions button.danger {
+  border-color: var(--danger);
+  background: var(--danger);
+  color: var(--bg-main);
+}
+
+/* ── Center file browser ─────────────────────────────────────────────── */
+.file-browser {
+  position: absolute;
+  inset: 0;
+  display: none;
+  flex-direction: column;
+  background: var(--bg-main);
+  color: var(--text-primary);
+  overflow: hidden;
+}
+
+.file-browser.active { display: flex; }
+
+.file-browser-empty,
+.file-browser-message {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 16px;
+  color: var(--text-muted);
+  font-size: 12px;
+}
+
+.file-browser-toolbar,
+.file-browser-actions,
+.file-browser-status {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 8px;
+  border-bottom: 1px solid var(--border-subtle);
+  background: var(--bg-panel);
+  flex-shrink: 0;
+}
+
+.file-browser-actions {
+  padding-top: 4px;
+  padding-bottom: 4px;
+  color: var(--text-secondary);
+  font-size: 11px;
+}
+
+.file-browser-toolbar button,
+.file-browser-actions button,
+.file-browser-actions select,
+.file-browser-path input,
+.file-browser-search {
+  min-height: 24px;
+  border: 1px solid var(--control-border);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+  padding: 2px 8px;
+  border-radius: var(--radius-sm);
+}
+
+.file-browser-toolbar button,
+.file-browser-actions button {
+  cursor: pointer;
+}
+
+.file-browser-toolbar button:hover:not(:disabled),
+.file-browser-actions button:hover:not(:disabled),
+.file-browser-toolbar button.selected,
+.file-browser-actions button.selected {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.file-browser-toolbar button:disabled,
+.file-browser-actions button:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+
+.file-browser-actions label {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  white-space: nowrap;
+}
+
+.file-browser-path {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  min-width: 180px;
+  flex: 1;
+}
+
+.file-browser-path span {
+  color: var(--text-secondary);
+  font-size: 11px;
+  max-width: 160px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-browser-path input {
+  min-width: 0;
+  flex: 1;
+}
+
+.file-browser-search {
+  width: 160px;
+}
+
+.file-browser-body {
+  min-height: 0;
+  flex: 1;
+  display: grid;
+  grid-template-columns: 220px minmax(0, 1fr);
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.file-browser-sidebar {
+  overflow: auto;
+  background: var(--bg-panel);
+  border-right: 1px solid var(--border-subtle);
+  padding: 6px;
+}
+
+.file-browser-sidebar button {
+  width: 100%;
+  min-height: 26px;
+  text-align: left;
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-secondary);
+  cursor: pointer;
+  font-size: 12px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-browser-sidebar button:hover,
+.file-browser-sidebar button.selected {
+  background: var(--pill-hover-bg);
+  color: var(--text-primary);
+  border-color: var(--border-subtle);
+}
+
+.file-browser-main {
+  min-width: 0;
+  overflow: auto;
+  position: relative;
+}
+
+.file-browser-error {
+  padding: 8px 12px;
+  color: var(--danger);
+  font-size: 12px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.file-browser-list {
+  min-width: 720px;
+}
+
+.file-browser-section-divider {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 8px;
+  padding: 4px 8px 2px;
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: var(--text-secondary);
+  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
+  grid-column: 1 / -1;
+}
+
+.file-browser-row.scaffold,
+.file-browser-tile.scaffold {
+  opacity: 0.65;
+}
+
+.file-browser-section-divider--icons {
+  width: 100%;
+}
+
+.file-browser-list-head,
+.file-browser-row {
+  display: grid;
+  grid-template-columns: minmax(260px, 1fr) 120px 100px 180px;
+  align-items: center;
+  gap: 12px;
+  min-height: 30px;
+  padding: 0 12px;
+  border-bottom: 1px solid var(--border-subtle);
+  font-size: 12px;
+}
+
+.file-browser-list-head {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: var(--bg-panel);
+  color: var(--text-secondary);
+  font-size: 11px;
+  font-weight: 600;
+  text-transform: uppercase;
+}
+
+.file-browser-row {
+  cursor: default;
+  color: var(--text-primary);
+}
+
+.file-browser-row:hover,
+.file-browser-row.selected,
+.file-browser-tile:hover,
+.file-browser-tile.selected {
+  background: var(--pill-hover-bg);
+}
+
+.file-browser-row.selected,
+.file-browser-tile.selected {
+  outline: 1px solid var(--accent);
+  outline-offset: -1px;
+}
+
+.file-browser-row span {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-browser-row span:first-child {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.file-browser-row b {
+  color: var(--accent);
+  font-size: 11px;
+  font-weight: 600;
+  min-width: 28px;
+}
+
+.file-browser-tile span {
+  color: var(--accent);
+  font-size: 32px;
+  line-height: 1;
+  font-weight: 600;
+  min-width: 0;
+}
+
+.file-browser-icons {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(104px, 1fr));
+  gap: 8px;
+  padding: 12px;
+}
+
+.file-browser-tile {
+  min-height: 88px;
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-primary);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 8px;
+  cursor: default;
+}
+
+.file-browser-tile b {
+  max-width: 100%;
+  overflow-wrap: anywhere;
+  font-size: 12px;
+  font-weight: 500;
+  text-align: center;
+}
+
+.file-browser-status {
+  min-height: 28px;
+  border-bottom: none;
+  color: var(--text-muted);
+  font-size: 11px;
+}
+
+/* ── Migrated main-branch app bars and hover strips ─────────────────── */
+/* ── Global-app launcher (header button + hover dropdown) ─────────────── */
+.global-apps-menu {
+  position: relative;
+  display: flex;
+  align-items: center;
+  flex-shrink: 0;
+}
+
+/* Flush with the header at rest (same background as .app-header, no boxed
+   outline) so this and its .local-model-btn sibling read as part of the top
+   frame's chrome rather than standing controls; the boxed control surface
+   only appears on hover/expanded, same reveal-on-touch treatment as
+   .vpn-indicator-btn/.machines-indicator-btn. */
+.global-apps-menu-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 32px;
+  height: 32px;
+  border-radius: var(--radius-sm);
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-secondary);
+  cursor: pointer;
+  font-size: 14px;
+  transition: background var(--transition), border-color var(--transition), color var(--transition);
+}
+
+.global-apps-menu-btn:hover,
+.global-apps-menu-btn[aria-expanded="true"] {
+  background: var(--control-hover-bg);
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+/* Global-app launcher rows: rides the shared .tab-new-menu/.tab-new-menu-item
+   one-column list chrome (same shape as the Local Model / Machines / VPN
+   dropdowns) — an icon (real app icon, or the role's fallback glyph) followed
+   by the program's label, instead of the old icon-only tile grid. */
+.global-app-menu-row[aria-disabled="true"] {
+  cursor: default;
+  opacity: 0.55;
+}
+
+.global-app-menu-row[aria-disabled="true"]:hover {
+  background: var(--control-bg);
+}
+
+.global-app-icon {
+  width: 18px;
+  height: 18px;
+  object-fit: contain;
+  flex-shrink: 0;
+}
+
+.global-app-fallback-icon {
+  width: 18px;
+  font-size: 15px;
+  line-height: 1;
+  text-align: center;
+  flex-shrink: 0;
+}
+
+.global-app-edit-popover {
+  position: fixed;
+  z-index: 1000;
+  width: 320px;
+  padding: 10px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  box-shadow: var(--shadow-3);
+  color: var(--text-primary);
+}
+
+.global-app-edit-title {
+  font-weight: 650;
+  margin-bottom: 4px;
+}
+
+.global-app-edit-current {
+  margin-bottom: 8px;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+.global-app-edit-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 6px;
+}
+
+.global-app-edit-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 6px;
+  margin-top: 8px;
+}
+
+.right-panel {
+  pointer-events: none;
+}
+
+.right-panel.open {
+  pointer-events: auto;
+}
+
+.project-switcher-root-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 40px;
+  height: 40px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--control-border);
+  cursor: pointer;
+  flex-shrink: 0;
+  background: var(--control-bg);
+  color: var(--text-secondary);
+}
+
+.project-switcher-root-btn:hover {
+  background: var(--control-hover-bg);
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+.project-switcher-root-btn.active {
+  background: var(--pill-active-bg);
+  color: var(--text-primary);
+  border-color: var(--pill-active-border);
+  box-shadow: inset 0 4px 0 var(--accent);
+}
+
+/* Settings gear + add-project button: same compact, blend-into-the-header
+   style as .global-apps-menu-btn (the Local Model / Global Apps buttons) —
+   transparent at rest, boxed chrome only on hover/reveal — instead of the
+   old 40px filled buttons that stood out against the quieter header. */
+.project-switcher-action-btn,
+.project-switcher-add-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 32px;
+  height: 32px;
+  border-radius: var(--radius-sm);
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-secondary);
+  cursor: pointer;
+  flex-shrink: 0;
+  font-size: 14px;
+  transition: background var(--transition), border-color var(--transition), color var(--transition);
+}
+
+.project-switcher-action-btn:hover,
+.project-switcher-add-btn:hover {
+  background: var(--control-hover-bg);
+  color: var(--text-primary);
+  border-color: var(--text-muted);
+}
+
+.project-switcher-separator {
+  width: 1px;
+  height: 32px;
+  background: var(--border-subtle);
+  flex-shrink: 0;
+  margin: 0 2px;
+}
+
+.project-pills-scroll {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  align-items: flex-start;
+  gap: 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+  height: 40px;
+  /* Overflow is conveyed solely by the left/right chevron buttons (toggled from
+     JS via the overflow-* classes); a vertical mouse wheel also scrolls this
+     horizontally in the webview, so no edge fade or visible scrollbar is used. */
+  scrollbar-width: none; /* Firefox/standard — hide the bar */
+  -ms-overflow-style: none;
+}
+
+/* Relative track holding the scrollable pill row plus the edge chevrons. */
+.project-pills-region {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+}
+
+/* Chevrons live on the bar itself — ordinary flex siblings of
+   .project-pills-scroll (left btn, scroll strip, right btn), taking their own
+   slice of width rather than absolutely overlaying the edge pills. Flat/no
+   background at rest, matching the header's other quiet-until-touched
+   buttons; only the icon's color shifts on hover. */
+.pills-scroll-btn {
+  flex-shrink: 0;
+  width: 20px;
+  height: 32px;
+  display: none;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: none;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  font-size: 20px;
+  line-height: 1;
+  color: var(--text-secondary);
+  background: transparent;
+  transition: color var(--transition);
+}
+
+.pills-scroll-btn:hover {
+  color: var(--accent);
+}
+
+.project-pills-region.overflow-left .pills-scroll-btn.left {
+  display: flex;
+}
+
+.project-pills-region.overflow-right .pills-scroll-btn.right {
+  display: flex;
+}
+
+/* Hidden scrollbar — overflow is conveyed by the on-bar chevrons above and
+   wheel scrolling, keeping the pills at full height inside the 40px row. */
+.project-pills-scroll::-webkit-scrollbar {
+  height: 0;
+}
+
+.project-pill {
+  height: 40px;
+  max-width: 180px;
+}
+
+.project-pill .pill-main {
+  gap: 6px;
+}
+
+.project-pill-label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  /* Helix apricot for the project name; inactive pills dim a touch so the active
+     scope still reads as foremost (its background/stripe also signal it). */
+  color: var(--helix-orange);
+}
+
+/* In the lavender theme the project name reads as dark lavender rather than
+   the default Helix apricot, so it stays in-palette with the rest of the UI. */
+[data-theme="light_lavender"] .project-pill-label {
+  color: #5d3eb8;
+}
+
+.pill-folder-icon {
+  display: inline-flex;
+  flex-shrink: 0;
+  font-size: 15px;
+  position: relative;
+}
+
+/* Paused-timer marker: a small badge over the git-colored folder, so pausing
+   the app timer no longer erases the folder's git-state color (it used to
+   replace the whole icon). Kept tiny + corner-anchored so the folder + its
+   red/orange/green tint stay legible underneath. */
+.pill-folder-pause {
+  position: absolute;
+  right: -3px;
+  bottom: -3px;
+  font-size: 8px;
+  line-height: 1;
+  color: var(--text-muted);
+  background: var(--bg-panel);
+  border-radius: 50%;
+  padding: 1px;
+  pointer-events: none;
+}
+
+/* Folder icon color signals the project's pending git state at a glance —
+   distinct from the round SSH connection lamp (RemoteConnMenu) so the two
+   indicators are never visually confused. Priority mirrors the file-tree
+   markers: dirty (red) > staged (orange) > unpushed (green) > clean (folder
+   yellow, its normal resting color). */
+.pill-folder-icon.git-clean {
+  color: #e3b341;
+}
+
+.pill-folder-icon.git-dirty {
+  color: #f85149;
+}
+
+.pill-folder-icon.git-staged {
+  color: #d29922;
+}
+
+.pill-folder-icon.git-unpushed {
+  color: #3fb950;
+}
+
+.project-search-wrap {
+  position: relative;
+  width: 150px;
+  flex-shrink: 0;
+}
+
+/* Rarely used (most projects stay active, so this box sits empty most of the
+   time) — kept flush with the header at rest instead of a standing boxed
+   input, and only picks up its control chrome on hover/focus, like the
+   header's other quiet-until-touched buttons (.global-apps-menu-btn,
+   .vpn-indicator-btn/.machines-indicator-btn). */
+.project-search-entry {
+  width: 100%;
+  height: 40px;
+  border-radius: var(--radius-sm);
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-primary);
+  padding: 0 9px;
+  font-size: 12px;
+  outline: none;
+  transition: background var(--transition), border-color var(--transition);
+}
+
+.project-search-entry::placeholder {
+  color: var(--text-muted);
+  opacity: 0.7;
+}
+
+.project-search-entry:hover {
+  border-color: var(--control-border);
+  background: var(--control-bg);
+}
+
+.project-search-entry:focus {
+  border-color: var(--accent);
+  background: var(--control-bg);
+}
+
+.project-search-popover {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  width: min(360px, 80vw);
+  max-height: 420px;
+  overflow-y: auto;
+  padding: 4px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-2);
+  z-index: 60;
+}
+
+.project-search-row {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 7px 8px;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  text-align: left;
+  cursor: pointer;
+}
+
+.project-search-row:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.project-search-row small {
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  color: var(--text-muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Remote projects list two locations (host target + local mirror); the label
+ * keeps its width, the path ellipsizes. */
+.project-search-path-label {
+  flex: 0 0 auto;
+  font-size: 9px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-secondary);
+  opacity: 0.7;
+}
+
+.project-search-path {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.project-search-empty {
+  padding: 8px;
+  color: var(--text-muted);
+  font-size: 12px;
+}
+
+.project-switcher-add-wrap {
+  position: relative;
+  flex-shrink: 0;
+  /* `.project-switcher` centers its children (like `.header-right` does for
+     VPN/Machines), so this wrap would otherwise shrink to its 40px button and
+     place `top: calc(100% + 4px)` above the header-right menus' shared line.
+     Stretch to the full 44px row and re-center the button inside it, mirroring
+     `.header-status-menu-anchor`. */
+  display: flex;
+  align-items: center;
+  align-self: stretch;
+}
+
+.project-switcher-add-menu {
+  position: absolute;
+  left: 0;
+  top: calc(100% + 4px);
+  min-width: 150px;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 4px;
+  z-index: 60;
+}
+
+.project-switcher-add-menu button {
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  padding: 7px 9px;
+  background: var(--control-bg);
+  color: var(--text-primary) !important;
+  -webkit-text-fill-color: var(--text-primary);
+  text-align: left;
+  cursor: pointer;
+}
+
+.project-switcher-add-menu button:hover {
+  background: var(--control-hover-bg);
+  color: var(--text-primary) !important;
+  -webkit-text-fill-color: var(--text-primary);
+}
+
+.modal-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 100;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(0, 0, 0, 0.35);
+}
+
+/* The Connect detail opens ON TOP of the unified "Remote machines" hub (a host
+   entry's Connect/Manage button), and both are plain .modal-backdrop modals at
+   z-index 100 — DOM order alone would not reliably keep the detail above the
+   hub. This lifts the connect detail's backdrop one layer up so it always sits
+   over the hub that spawned it. */
+.modal-backdrop.modal-backdrop-elevated {
+  z-index: 110;
+}
+
+/* One dialog surface for the whole app — the shells differ only in size.
+   Shared chrome (elevated surface, soft border, large radius, floating shadow)
+   lives here so every modal reads identically. `.project-dialog`/`.stats-dialog`
+   are also reused directly (no `.dialog-scroll` child) by ~15 other one-off
+   dialogs (RemoteMachinesWindow, EventDialog, CustomAgentDialog, …), so this
+   base rule scrolls itself, same as always — only `.settings-dialog` (the
+   Settings window specifically) opts into the split-scroll frame below. */
+.project-dialog,
+.settings-dialog,
+.stats-dialog {
+  position: relative;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  /* Accent top rail, matching the header's new tint — every dialog reads as
+     belonging to the same themed chrome, with no per-dialog exceptions. */
+  border-top: 3px solid var(--accent);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-3);
+}
+
+/* Accent wash as a `::before` overlay, NOT folded into `background` — the glass
+   themes replace `background` with a translucent `--glass-elevated`, and only an
+   overlay tints whatever shows through the glass without making it opaque. The
+   wash spanning the full scroll is handled by the frame, not by this rule: a
+   scrolling dialog uses `.dialog-framed` (its surface is overflow:hidden and
+   never scrolls, so this inset:0 overlay covers the whole fixed frame while the
+   inner `.dialog-scroll` scrolls beneath it). A non-framed dialog is short
+   enough never to scroll, so the overlay covers it too. */
+.project-dialog::before,
+.settings-dialog::before,
+.stats-dialog::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: var(--accent);
+  opacity: 0.32;
+  pointer-events: none;
+  z-index: -1;
+  border-radius: inherit;
+}
+
+/* The scrollbar track on every accent-washed menu/dialog surface. The generic
+   --scrollbar-track (a flat --bg-panel) sits as a visibly different, un-tinted
+   patch against these tinted backgrounds — but a solid color-mix (32% accent
+   over --bg-elevated) can't match either: the real surface is a background PLUS
+   the ::before accent-wash overlay, and in the glass themes it is a translucent
+   --glass-elevated over a backdrop blur that no solid colour equals. So the
+   track is `transparent` — the gutter shows the true washed surface behind it,
+   an exact match in every theme. The thumb stays the global --scrollbar-thumb,
+   and its inset border goes transparent too (else it rings the thumb in the old
+   mismatched tint). */
+.context-menu,
+.tab-new-menu,
+.menu-scroll-region,
+.project-switcher-add-menu,
+.project-dialog,
+.settings-dialog .dialog-scroll,
+.dialog-framed .dialog-scroll,
+.stats-dialog {
+  scrollbar-color: var(--scrollbar-thumb) transparent;
+}
+.context-menu::-webkit-scrollbar-track,
+.tab-new-menu::-webkit-scrollbar-track,
+.menu-scroll-region::-webkit-scrollbar-track,
+.project-switcher-add-menu::-webkit-scrollbar-track,
+.project-dialog::-webkit-scrollbar-track,
+.settings-dialog .dialog-scroll::-webkit-scrollbar-track,
+.dialog-framed .dialog-scroll::-webkit-scrollbar-track,
+.stats-dialog::-webkit-scrollbar-track {
+  background: transparent;
+}
+.context-menu::-webkit-scrollbar-thumb,
+.tab-new-menu::-webkit-scrollbar-thumb,
+.menu-scroll-region::-webkit-scrollbar-thumb,
+.project-switcher-add-menu::-webkit-scrollbar-thumb,
+.project-dialog::-webkit-scrollbar-thumb,
+.settings-dialog .dialog-scroll::-webkit-scrollbar-thumb,
+.dialog-framed .dialog-scroll::-webkit-scrollbar-thumb,
+.stats-dialog::-webkit-scrollbar-thumb {
+  background-color: var(--scrollbar-thumb);
+  border-color: transparent;
+}
+
+.project-dialog {
+  width: min(680px, calc(100vw - 32px));
+  max-height: min(820px, calc(100vh - 40px));
+  padding: 22px 24px;
+}
+
+/* Settings alone gets the split-scroll frame: it does NOT scroll itself —
+   .dialog-scroll (its one JSX child, see SettingsPanel.tsx) does. Split out
+   because a native scrollbar rendered on the SAME element as border-radius
+   doesn't get rounded itself — it runs straight to the very top/bottom of the
+   box, visually notching the rounded corner where the two meet. This frame
+   clips with plain `overflow: hidden` (it never scrolls, so no scrollbar ever
+   sits on its rounded edge); `.dialog-scroll` does the actual scrolling,
+   comfortably inside the curve. Scoped to .settings-dialog only — the shared
+   rule above still owns every other reuser of this chrome. */
+.settings-dialog {
+  width: min(560px, calc(100vw - 32px));
+  max-height: min(720px, calc(100vh - 96px));
+  overflow: hidden;
+  gap: 0;
+  padding: 0;
+}
+.settings-dialog .dialog-scroll {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 18px;
+}
+
+/* Split-scroll frame, generalized — the one Settings uses, made reusable so any
+   dialog whose content can overflow reads and scrolls identically. A dialog opts
+   in by adding `dialog-framed` beside `project-dialog` and wrapping its scrolling
+   body in a `.dialog-scroll` child (its header/footer, if any, stay outside).
+
+   Why a frame and not just self-scrolling the .project-dialog surface: a native
+   scrollbar on the same box that carries border-radius runs into the rounded
+   corners (the notch). The frame clips with plain overflow:hidden (it never
+   scrolls, so no scrollbar ever meets its rounded edge — and the accent surface
+   wash covers the whole fixed frame), while .dialog-scroll does the scrolling
+   comfortably inside the curve. Same construction as .settings-dialog below. */
+/* Compound selectors (0,2,0) so the frame's overflow/padding/gap beat each
+   surface's own single-class sizing rule wherever it sits in the sheet. */
+.project-dialog.dialog-framed,
+.stats-dialog.dialog-framed {
+  overflow: hidden;
+  gap: 0;
+  padding: 0;
+}
+.dialog-framed > .settings-title-row {
+  margin: 0;
+  padding: 18px 24px 10px;
+}
+.dialog-framed > .dialog-scroll {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 14px 24px 22px;
+}
+/* No fixed header above it (the dialog's own title scrolls inside the frame, e.g.
+   a bare <h2>): restore the full top inset the un-framed surface used to give. */
+.dialog-framed > .dialog-scroll:first-child {
+  padding-top: 20px;
+}
+
+.settings-title-row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  border-bottom: 1px solid var(--border-subtle);
+  padding-bottom: 10px;
+}
+
+.settings-title-row h2 {
+  flex: 1;
+  font-size: 16px;
+  font-weight: 650;
+  /* Top-level panel header: accent so it clearly outranks the section titles
+     (accent-secondary) and the body text below it. */
+  color: var(--accent);
+}
+
+/* The dialog header reads as its OWN band — the same accent-washed --bg-header
+   the app's top bar carries (.app-header + its ::before at 0.32 accent), so a
+   dialog's title strip belongs to the same themed chrome as the window's top
+   bar and stands apart from the accent-washed body below it. The single-element
+   background reproduces that composite (a flat 32%-accent layer over
+   --bg-header) with no per-theme branching, since --bg-header is a plain color
+   in some themes and a gradient in others. The band bleeds to the dialog's
+   edges; the padding/margins that achieve that differ per context (the dialog's
+   own padding is 0 for a framed surface, 22px for a plain .project-dialog, and
+   18px inside a .settings-dialog's scroll frame) and are set below. */
+.project-dialog.dialog-framed > .settings-title-row,
+.stats-dialog.dialog-framed > .settings-title-row,
+.settings-dialog > .settings-title-row,
+.settings-dialog > .dialog-scroll > .settings-title-row,
+.project-dialog:not(.dialog-framed) > .settings-title-row {
+  background:
+    linear-gradient(
+      color-mix(in srgb, var(--accent) 32%, transparent),
+      color-mix(in srgb, var(--accent) 32%, transparent)
+    ),
+    var(--bg-header);
+  border-bottom: 1px solid var(--border-color);
+}
+
+/* Fixed header of a plain .settings-dialog (EventDialog, CustomAgentDialog):
+   the surface's padding is 0, so the band is full-width — it only needs its own
+   inset. */
+.settings-dialog > .settings-title-row {
+  margin: 0;
+  padding: 16px 18px 10px;
+}
+
+/* Header that scrolls inside a .settings-dialog's frame (SettingsPanel and its
+   sub-panels): pull the band out to the scroll's top and side edges (negative
+   margins == the .dialog-scroll's 18px padding) so it still reads as a full-
+   width top bar, with a gap before the body. */
+.settings-dialog > .dialog-scroll > .settings-title-row {
+  /* margin-bottom 0: the scroll frame is a flex column with its own 12px gap. */
+  margin: -18px -18px 0;
+  padding: 16px 18px 10px;
+}
+
+/* Header of a plain (self-scrolling) .project-dialog — ProjectPill's little
+   dialogs: bleed past the surface's own 22px/24px padding to the edges. */
+.project-dialog:not(.dialog-framed) > .settings-title-row {
+  /* margin-bottom 0: .project-dialog is a flex column with its own 12px gap. */
+  margin: -22px -24px 0;
+  padding: 16px 24px 10px;
+}
+
+.dialog-close-btn,
+.settings-title-row button,
+.settings-link-row button,
+.global-app-settings-row button,
+.filetype-settings-row button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  padding: 7px 10px;
+}
+
+.dialog-close-btn:hover,
+.settings-title-row button:hover,
+.settings-link-row button:hover,
+.global-app-settings-row button:hover,
+.filetype-settings-row button:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+/* GlobalMachineMonitorDialog: the full htop-like System Monitor pane opened
+   from the header's Machines menu for one ad-hoc global machine. `.sysmon-root`
+   (SystemMonitorPane's own CSS) is `position: absolute; inset: 0` — it needs a
+   sized, positioned ancestor, which `.sysmon-dialog-body` provides; the pane
+   scrolls itself (`.sysmon-scroll`), so the body clips rather than scrolls. */
+.sysmon-dialog {
+  width: min(1200px, calc(100vw - 48px));
+  height: min(85vh, calc(100vh - 48px));
+  max-height: min(85vh, calc(100vh - 48px));
+}
+.sysmon-dialog-body {
+  position: relative;
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+}
+
+/* Print preview overlay (src/lib/viewers/print.ts). Reuses .modal-backdrop +
+   .settings-dialog chrome; the dialog is sized to preview a page and the iframe
+   fills the remaining height. */
+.print-preview-dialog {
+  width: min(1020px, calc(100vw - 48px));
+  height: min(90vh, calc(100vh - 48px));
+  max-height: min(90vh, calc(100vh - 48px));
+  padding: 14px 16px;
+  gap: 10px;
+  overflow: hidden;
+}
+.print-preview-titlebar {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  border-bottom: 1px solid var(--border-subtle);
+  padding-bottom: 10px;
+}
+.print-preview-title {
+  flex: 1;
+  font-size: 15px;
+  font-weight: 650;
+  color: var(--accent);
+}
+.print-preview-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.print-preview-print {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  border: 1px solid var(--accent);
+  border-radius: var(--radius-sm);
+  background: var(--accent);
+  color: var(--bg-panel);
+  cursor: pointer;
+  padding: 7px 14px;
+  font-weight: 600;
+}
+.print-preview-print:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--accent) 85%, #000);
+}
+.print-preview-print:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+.print-preview-print .file-viewer-save-spinner {
+  border-top-color: var(--bg-panel);
+}
+.print-preview-frame {
+  flex: 1;
+  min-height: 0;
+  width: 100%;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  background: #fff;
+}
+.print-preview-options {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px 14px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid var(--border-subtle);
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+.print-opt {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  white-space: nowrap;
+}
+.print-opt-check {
+  cursor: pointer;
+}
+.print-opt:has(:disabled) {
+  opacity: 0.5;
+  cursor: default;
+}
+.print-opt-label {
+  color: var(--text-secondary);
+}
+.print-opt-select,
+.print-opt-range {
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  padding: 3px 6px;
+  font-size: 12px;
+}
+.print-opt-range {
+  width: 96px;
+}
+.print-opt-select:disabled,
+.print-opt-range:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+/* Page strip: drag-to-reorder / delete, shown only for paged documents. */
+.print-preview-strip {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+.print-strip-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+.print-strip-hint {
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+.print-strip-reset {
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  padding: 3px 10px;
+  font-size: 11px;
+}
+.print-strip-reset:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+/* The host the print preview mounts its <PageStrip> into. Layout lives on the
+   strip's own root (.page-strip-row), so this only carries the thumbnail vars. */
+.print-strip-pages {
+  min-width: 0;
+}
+
+/* ── Shared page strip (components/common/PageStrip) ────────────────────────────
+   One widget in two homes: the print preview's horizontal strip and the PDF
+   viewer's vertical page rail. Only the axis differs, so only the axis is themed
+   twice. The card box follows the sheet's proportions — portrait paper gets an
+   upright card, landscape a wide one — from the two vars the host sets. */
+.page-strip {
+  display: flex;
+  gap: 8px;
+  padding: 2px;
+}
+.page-strip-row {
+  flex-direction: row;
+  align-items: flex-start;
+  overflow-x: auto;
+}
+.page-strip-column {
+  flex-direction: column;
+  align-items: center;
+  overflow-y: auto;
+}
+.page-strip-card {
+  position: relative;
+  flex: 0 0 auto;
+  width: var(--page-thumb-w, 59px);
+  height: var(--page-thumb-h, 84px);
+  border: 1px solid var(--border-color);
+  background: #fff;
+  overflow: hidden;
+  cursor: grab;
+  touch-action: none; /* pointer drag owns the gesture */
+  user-select: none;
+}
+.page-strip-card img,
+.page-strip-card canvas {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+  transform: translate(-50%, -50%);
+  pointer-events: none;
+}
+/* The print strip's thumbnails are the page's own flat IMAGE, so a turn has to be
+   applied here in CSS. The PDF rail's are canvases pdf.js already rendered at the
+   right rotation — rotating those again would turn them twice, hence img only. */
+.page-strip-card img {
+  transform: translate(-50%, -50%) rotate(var(--page-thumb-rot, 0deg));
+}
+/* A quarter turn swaps the image's box, so the turned image still fills the card
+   instead of spilling out of it (the print stylesheet does the same for paper). */
+.page-strip-card.is-quarter-turned img {
+  width: var(--page-thumb-h, 84px);
+  height: var(--page-thumb-w, 59px);
+}
+.page-strip-blank {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  color: #777;
+  font-size: 16px;
+}
+.page-strip-card.is-excluded {
+  opacity: 0.35;
+}
+.page-strip-card.is-selected {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+.page-strip-card.is-dragging {
+  cursor: grabbing;
+  outline: 2px solid var(--accent);
+  opacity: 0.85;
+}
+.page-strip-num {
+  position: absolute;
+  left: 0;
+  bottom: 0;
+  min-width: 16px;
+  padding: 0 3px;
+  background: var(--accent);
+  color: var(--bg-panel);
+  font-size: 10px;
+  font-weight: 600;
+  text-align: center;
+}
+.page-strip-del,
+.page-strip-rotate {
+  position: absolute;
+  top: 0;
+  border: none;
+  background: rgba(0, 0, 0, 0.55);
+  color: #fff;
+  cursor: pointer;
+  padding: 0 4px;
+  font-size: 11px;
+  line-height: 16px;
+  opacity: 0;
+}
+.page-strip-del {
+  right: 0;
+}
+.page-strip-rotate {
+  left: 0;
+}
+.page-strip-card:hover .page-strip-del,
+.page-strip-card:hover .page-strip-rotate,
+.page-strip-del:focus-visible,
+.page-strip-rotate:focus-visible {
+  opacity: 1;
+}
+
+/* Where pages dragged from another strip (or another Eldrun window) would land. It
+   sits in the flex flow, so it opens a real gap between the two cards. */
+.page-strip-caret {
+  flex: 0 0 auto;
+  background: var(--accent);
+  border-radius: 2px;
+}
+.page-strip-row .page-strip-caret {
+  width: 3px;
+  align-self: stretch;
+}
+.page-strip-column .page-strip-caret {
+  height: 3px;
+  width: var(--page-thumb-w, 72px);
+}
+
+/* ── PDF viewer: the page rail ──────────────────────────────────────────────────
+   The <PageStrip> stood on its side, beside the reader. Fixed card box + the
+   canvas's own object-fit handles pages of differing sizes. */
+.file-viewer-pdf-rail {
+  --page-thumb-w: 72px;
+  --page-thumb-h: 96px;
+  flex: 0 0 auto;
+  display: flex;
+  min-height: 0;
+  border-right: 1px solid var(--border-subtle);
+  background: var(--bg-panel);
+}
+.file-viewer-pdf-rail .page-strip-column {
+  padding: 6px;
+}
+
+/* Contents sidebar (#pdf-outline): the PDF's embedded chapters, a jump list. */
+.file-viewer-pdf-outline {
+  flex: 0 0 auto;
+  width: 240px;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  border-right: 1px solid var(--border-subtle);
+  background: var(--bg-panel);
+  font-size: 12px;
+}
+.file-viewer-pdf-outline-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 10px;
+  border-bottom: 1px solid var(--border-subtle);
+  font-weight: 600;
+  color: var(--text-secondary, var(--text-primary));
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  font-size: 11px;
+}
+.file-viewer-pdf-outline-body {
+  flex: 1;
+  min-height: 0;
+  overflow: auto;
+  padding: 4px 0;
+}
+.file-viewer-pdf-outline-empty {
+  padding: 10px;
+  color: var(--text-secondary, var(--text-muted));
+  font-style: italic;
+}
+.file-viewer-pdf-outline-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 2px;
+  padding-right: 6px;
+}
+.file-viewer-pdf-outline-row.current {
+  background: var(--control-bg);
+}
+.file-viewer-pdf-outline-caret {
+  flex: 0 0 auto;
+  width: 16px;
+  padding: 3px 0;
+  border: none;
+  background: transparent;
+  color: var(--text-secondary, var(--text-muted));
+  cursor: pointer;
+  font-size: 10px;
+  line-height: 1.2;
+}
+/* A leaf row's per-level sign, standing in the caret column: a dot for the top
+   tiers, a dash deeper down (a branch shows the ▸/▾ triangle here instead). */
+.file-viewer-pdf-outline-caret.is-sign {
+  cursor: default;
+  color: var(--text-secondary, var(--text-muted));
+  text-align: center;
+  font-size: 11px;
+}
+.file-viewer-pdf-outline-title {
+  flex: 1;
+  min-width: 0;
+  text-align: left;
+  padding: 3px 2px;
+  border: none;
+  background: transparent;
+  color: var(--text-primary);
+  cursor: pointer;
+  font: inherit;
+  line-height: 1.3;
+  overflow-wrap: anywhere;
+}
+.file-viewer-pdf-outline-title:hover:not(:disabled) {
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+.file-viewer-pdf-outline-row.current .file-viewer-pdf-outline-title {
+  font-weight: 700;
+}
+.file-viewer-pdf-outline-title:disabled {
+  cursor: default;
+  color: var(--text-secondary, var(--text-muted));
+}
+
+/* Levels echo the markdown viewer's heading tiers: the top level leans on the
+   accent hue, the second on the secondary accent, the third picks up a small
+   accent dot, and anything deeper stays quiet text — so the document's shape
+   reads at a glance without every tier shouting. */
+.file-viewer-pdf-outline-title.depth-0 {
+  font-size: 12.5px;
+  font-weight: 650;
+  color: var(--accent, var(--text-primary));
+  letter-spacing: -0.01em;
+}
+.file-viewer-pdf-outline-title.depth-1 {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--accent-secondary, var(--accent, var(--text-primary)));
+}
+.file-viewer-pdf-outline-title.depth-2 {
+  font-size: 11.5px;
+  font-weight: 500;
+  color: var(--text-primary);
+}
+.file-viewer-pdf-outline-title.depth-3 {
+  font-size: 11px;
+  font-weight: 400;
+  color: var(--text-secondary, var(--text-muted));
+}
+/* A disabled (unresolvable) entry stays muted whatever its level. */
+.file-viewer-pdf-outline-title:disabled { color: var(--text-secondary, var(--text-muted)); }
+
+/* "Inferred from text" note when the chapters came from the font-size fallback. */
+.file-viewer-pdf-outline-note {
+  padding: 3px 10px 5px;
+  border-bottom: 1px solid var(--border-subtle);
+  color: var(--text-secondary, var(--text-muted));
+  font-size: 10px;
+  font-style: italic;
+}
+
+/* A thin separator between the contents toggle and the zoom cluster. */
+.file-viewer-pdf-toolbar-sep {
+  align-self: stretch;
+  width: 1px;
+  margin: 3px 2px;
+  background: var(--border-subtle);
+}
+
+/* Hover preview: a floating thumbnail of a contents entry's page. Fixed-position
+   so it escapes the sidebar's scroll clipping and can overhang the page area. */
+.file-viewer-pdf-outline-preview {
+  position: fixed;
+  z-index: 60;
+  padding: 4px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--bg-panel);
+  box-shadow: var(--shadow-lg, 0 6px 24px rgba(0, 0, 0, 0.35));
+  pointer-events: none;
+}
+.file-viewer-pdf-outline-preview img {
+  display: block;
+  width: 100%;
+  height: auto;
+  border-radius: 2px;
+  /* Keep the page white in dark themes — the pages elsewhere stay as authored. */
+  background: #fff;
+}
+.file-viewer-pdf-outline-preview-loading {
+  padding: 24px 8px;
+  text-align: center;
+  color: var(--text-secondary, var(--text-muted));
+  font-size: 11px;
+}
+.file-viewer-pdf-outline-preview-cap {
+  padding: 3px 2px 1px;
+  text-align: center;
+  color: var(--text-secondary, var(--text-muted));
+  font-size: 10px;
+}
+
+/* A viewer-wide notice bar (unsaved edits vs. a changed file, a failed save). */
+.file-viewer-banner {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 5px 10px;
+  border-bottom: 1px solid var(--border-subtle);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+}
+.file-viewer-banner.is-error {
+  color: var(--danger, #e05252);
+}
+.file-viewer-banner button {
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  cursor: pointer;
+  padding: 2px 8px;
+  font-size: 11px;
+}
+.file-viewer-zoom-btn.is-dirty {
+  color: var(--accent);
+  font-weight: 600;
+}
+
+.settings-row,
+.settings-switch-row {
+  min-height: 34px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.settings-row label,
+.settings-switch-row span:first-child {
+  flex: 1;
+  color: var(--text-primary);
+}
+
+.settings-row select,
+.settings-field input,
+.global-app-settings-row input[type="text"],
+.global-app-settings-row input:not([type]),
+.filetype-settings-row input {
+  height: 34px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  padding: 0 9px;
+}
+
+/* Group L / #62 — keyboard-shortcut rebinding rows. */
+.shortcut-row .settings-role-label {
+  flex: 1;
+  color: var(--text-primary);
+}
+
+.shortcut-capture-btn {
+  min-width: 150px;
+  height: 30px;
+  border: 1px solid var(--control-border);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-family: var(--font-mono, monospace);
+  cursor: pointer;
+}
+
+.shortcut-capture-btn.capturing {
+  border-color: var(--accent, #4f8cff);
+  color: var(--accent, #4f8cff);
+}
+
+.shortcut-row .settings-back-btn:disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+
+.settings-row select,
+.project-dialog select {
+  min-width: 160px;
+  appearance: none;
+  background-color: var(--control-bg);
+  background-image:
+    linear-gradient(45deg, transparent 50%, var(--text-primary) 50%),
+    linear-gradient(135deg, var(--text-primary) 50%, transparent 50%);
+  background-position:
+    calc(100% - 15px) 14px,
+    calc(100% - 10px) 14px;
+  background-size: 5px 5px, 5px 5px;
+  background-repeat: no-repeat;
+  cursor: pointer;
+  padding-right: 32px;
+}
+
+.settings-row select:hover,
+.settings-row select:focus,
+.settings-field input:hover,
+.settings-field input:focus,
+.global-app-settings-row input:hover,
+.global-app-settings-row input:focus,
+.filetype-settings-row input:hover,
+.filetype-settings-row input:focus,
+.project-dialog input:hover,
+.project-dialog input:focus,
+.project-dialog textarea:hover,
+.project-dialog textarea:focus,
+.project-dialog select:hover,
+.project-dialog select:focus,
+.menu-form input:hover,
+.menu-form input:focus,
+.menu-form textarea:hover,
+.menu-form textarea:focus,
+.menu-form select:hover,
+.menu-form select:focus {
+  border-color: var(--accent);
+  outline: none;
+}
+
+.settings-row select option,
+.project-dialog select option,
+.file-browser-actions select option {
+  background: var(--bg-panel);
+  color: var(--text-primary);
+}
+
+.settings-field {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+.settings-section-title {
+  margin-top: 2px;
+  padding-top: 12px;
+  border-top: 1px solid var(--border-subtle);
+  /* Section / per-agent headers: a distinct accent (one step below the panel
+     header) so a grouping like an agent name reads as a heading, not as the
+     primary-coloured body text, button labels and commands around it. */
+  color: var(--accent-secondary);
+  font-weight: 650;
+  letter-spacing: 0.01em;
+}
+
+.settings-link-row {
+  display: flex;
+  gap: 8px;
+  padding-top: 4px;
+}
+
+/* Sub-panel navigation menu at the foot of the main settings panel. Mirrors the
+   Lessons / How-to-start card menu (.lesson-item) so the whole app's "pick a
+   destination" lists read as one style. */
+.settings-nav-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin-top: 6px;
+}
+
+.settings-nav-item {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  text-align: left;
+  padding: 10px 12px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border-color);
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  cursor: pointer;
+  transition: border-color var(--transition), background var(--transition);
+}
+
+.settings-nav-item:hover {
+  border-color: var(--accent);
+  background: color-mix(in srgb, var(--accent) 8%, var(--bg-panel));
+}
+
+.settings-nav-item-title {
+  font-weight: 600;
+  font-size: 13px;
+}
+
+.settings-nav-item-blurb {
+  color: var(--text-secondary);
+  font-size: 11.5px;
+  line-height: 1.4;
+}
+
+/* A toggle with an explanatory paragraph: same card language as
+   .settings-nav-item/.lesson-item (border, radius, bg-panel) instead of a bare
+   switch-row bleeding into an unrelated-looking paragraph below it. */
+.settings-toggle-card {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 10px 12px;
+  border-radius: var(--radius);
+  border: 1px solid var(--border-color);
+  background: var(--bg-panel);
+}
+
+.settings-toggle-card-row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  cursor: pointer;
+}
+
+.settings-toggle-card-row span:first-child {
+  flex: 1;
+  color: var(--text-primary);
+  font-weight: 600;
+  font-size: 13px;
+}
+
+.settings-toggle-card > .settings-help {
+  margin: 0;
+}
+
+.settings-help {
+  color: var(--text-secondary);
+  font-size: 12px;
+  line-height: 1.35;
+}
+
+/* Archived-projects (Settings) list */
+.archived-projects-list {
+  list-style: none;
+  margin: 8px 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  max-height: 320px;
+  overflow-y: auto;
+}
+
+.archived-project-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 8px 10px;
+  border: 1px solid var(--border-color, rgba(255, 255, 255, 0.1));
+  border-radius: var(--radius);
+}
+
+.archived-project-info {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  min-width: 0;
+}
+
+.archived-project-name {
+  font-weight: 600;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.archived-project-tag {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-secondary);
+  border: 1px solid var(--border-color, rgba(255, 255, 255, 0.15));
+  border-radius: var(--radius-sm);
+  padding: 0 4px;
+}
+
+.archived-project-date {
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+
+.archived-project-actions,
+.archived-project-confirm {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-shrink: 0;
+}
+
+.archived-project-confirm input {
+  min-width: 160px;
+}
+
+.archived-project-confirm-group {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 6px;
+  flex-shrink: 0;
+}
+
+.archived-project-warn {
+  margin: 0;
+  max-width: 340px;
+  font-size: 0.82em;
+  line-height: 1.35;
+  text-align: right;
+  color: var(--danger, #d9534f);
+}
+
+.help-section {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.help-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin: 0;
+}
+
+.help-row {
+  display: grid;
+  grid-template-columns: 160px 1fr;
+  gap: 12px;
+  align-items: baseline;
+}
+
+.help-row dt {
+  color: var(--text-primary);
+  font-weight: 600;
+  font-size: 12px;
+}
+
+.help-row dd {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+@media (max-width: 520px) {
+  .help-row {
+    grid-template-columns: 1fr;
+    gap: 2px;
+  }
+}
+
+.project-settings-dialog {
+  width: min(460px, calc(100vw - 32px));
+}
+
+.project-ending-form {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.project-ending-form input {
+  flex: 1;
+  height: 34px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  padding: 0 9px;
+}
+
+.project-ending-form input:hover,
+.project-ending-form input:focus {
+  border-color: var(--accent);
+  outline: none;
+}
+
+.project-ending-form button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  padding: 7px 10px;
+}
+
+.project-ending-form button:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.settings-list.project-ending-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(96px, 1fr));
+  gap: 4px 10px;
+  max-height: min(360px, calc(100vh - 300px));
+  overflow-y: auto;
+  padding-right: 2px;
+}
+
+.project-ending-toggle {
+  min-height: 32px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  padding: 6px 8px;
+  font-family: inherit;
+  font-size: 12px;
+  text-align: center;
+}
+
+.project-ending-toggle:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.project-ending-toggle.is-hidden {
+  color: var(--text-muted);
+  background: var(--bg-main);
+  border-color: var(--border-subtle);
+}
+
+.settings-empty {
+  color: var(--text-muted);
+  font-size: 12px;
+}
+
+.settings-error {
+  color: var(--danger, #f85149);
+  font-size: 12px;
+  word-break: break-word;
+}
+
+.settings-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.global-app-settings-row,
+.filetype-settings-row {
+  display: grid;
+  align-items: center;
+  gap: 8px;
+}
+
+.global-app-settings-row {
+  grid-template-columns: 18px 22px 104px minmax(120px, 1fr) auto;
+}
+
+.filetype-settings-row {
+  grid-template-columns: 70px minmax(120px, 1fr) auto auto;
+}
+
+.filetype-settings-row:last-child {
+  grid-template-columns: 70px minmax(120px, 1fr) auto;
+  border-top: 1px solid var(--border-subtle);
+  padding-top: 8px;
+}
+
+.remote-host-settings-row {
+  display: grid;
+  align-items: center;
+  gap: 8px;
+  grid-template-columns: minmax(90px, 180px) minmax(120px, 1fr) auto;
+}
+
+.remote-host-settings-add {
+  border-top: 1px solid var(--border-subtle);
+  padding-top: 8px;
+  margin-top: 2px;
+}
+
+.settings-role-icon {
+  text-align: center;
+}
+
+.settings-role-label {
+  color: var(--text-primary);
+}
+
+/* Canonical dialog header: solid accent + subtle divider, matching
+   .settings-title-row h2. (Previously a fancy_dark-only gradient-clipped title
+   that diverged from every other dialog.) */
+.project-dialog h2 {
+  font-size: 16px;
+  font-weight: 650;
+  color: var(--accent);
+  padding-bottom: 10px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+/* `.menu-form` is the ONE canonical form context reused wherever fields appear
+   OUTSIDE a `.project-dialog` — chiefly forms embedded in header popover menus
+   (`.tab-new-menu`, e.g. the global-machines "Add a machine" form), which get no
+   field styling from the popover surface on their own. It carries the exact same
+   label/input/select/textarea look as `.project-dialog`, so a form reads
+   identically in a dialog or a menu. New menus with a form: add `menu-form` to
+   the form container. */
+.project-dialog label,
+.menu-form label {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+/* Container settings (#38): the read-only-rootfs switch sits beside its label
+   text, unlike the stacked text fields above it. */
+.project-dialog label.container-settings-toggle {
+  flex-direction: row;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.project-dialog input,
+.project-dialog select,
+.project-dialog textarea,
+.menu-form input,
+.menu-form select,
+.menu-form textarea {
+  height: 34px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  padding: 0 8px;
+}
+
+/* Menu-form fields stretch to the popover width (their labels are flex columns,
+   and a menu is narrow — a default-width input would sit oddly short). Scoped to
+   `.menu-form` so it can't disturb a `.project-dialog` input that shares a flex
+   row with a button (e.g. `.folder-picker-row`). */
+.menu-form input,
+.menu-form select,
+.menu-form textarea {
+  box-sizing: border-box;
+  width: 100%;
+}
+
+.project-dialog textarea,
+.menu-form textarea {
+  min-height: 72px;
+  padding: 8px;
+  resize: vertical;
+}
+
+.project-description-field {
+  gap: 6px !important;
+}
+
+.project-description-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.project-description-header span {
+  min-width: 0;
+}
+
+.project-description-header select {
+  width: auto;
+  min-width: 118px;
+  max-width: 160px;
+  height: 28px;
+}
+
+.folder-picker-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+/* Masked input + show/hide eye toggle (see common/PasswordInput.tsx). The wrap
+   takes the input's place in every layout: it stretches to full width in the
+   column/label contexts (flex cross-axis stretch) and grows to fill a
+   `.folder-picker-row`. The reveal button floats over the trailing edge, so the
+   input reserves room for it via padding-right. */
+.password-input-wrap {
+  position: relative;
+  display: flex;
+  min-width: 0;
+}
+.password-input-wrap > input {
+  flex: 1 1 auto;
+  min-width: 0;
+  padding-right: 30px;
+}
+.folder-picker-row > .password-input-wrap {
+  flex: 1;
+  overflow: visible;
+}
+.password-reveal-btn {
+  position: absolute;
+  top: 0;
+  right: 0;
+  height: 100%;
+  width: 28px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: none;
+  background: transparent;
+  color: var(--text-secondary);
+  cursor: pointer;
+}
+.password-reveal-btn:hover {
+  color: var(--text-primary);
+}
+.password-reveal-btn:disabled {
+  cursor: default;
+  opacity: 0.5;
+}
+
+/* OpenVPN activation password prompt */
+.vpn-prompt-dialog {
+  max-width: 380px;
+}
+
+.vpn-prompt-text {
+  color: var(--text-primary);
+  margin: 0 0 8px;
+  /* A project name is user-chosen and a header-started connect substitutes the
+     `.ovpn` filename — both routinely long and both unbreakable to the normal
+     wrapper (no spaces). Without this the name overflowed the 380px dialog and
+     dragged its whole layout wide. */
+  overflow-wrap: anywhere;
+}
+
+/* Title row: heading on the left, × on the right. The canonical accent-header
+   divider moves from the h2 onto the row itself — left on the h2 it would end
+   where the text ends instead of spanning the dialog. */
+.vpn-prompt-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.vpn-prompt-header h2 {
+  min-width: 0;
+  padding-bottom: 0;
+  border-bottom: none;
+  overflow-wrap: anywhere;
+}
+
+/* The project (or `.ovpn`) name inside the prose line — see `.vpn-prompt-text`. */
+.vpn-prompt-name {
+  overflow-wrap: anywhere;
+}
+
+.vpn-prompt-close {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 22px;
+  height: 22px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--text-primary);
+  font-size: 17px;
+  line-height: 1;
+  cursor: pointer;
+  opacity: 0.7;
+  transition: background var(--transition), opacity var(--transition);
+}
+
+.vpn-prompt-close:hover {
+  opacity: 1;
+  background: color-mix(in srgb, currentColor 18%, transparent);
+}
+
+.vpn-prompt-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 14px;
+}
+
+.vpn-prompt-actions button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 7px 12px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.vpn-prompt-actions button.primary {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--bg-main);
+  font-weight: 600;
+}
+
+.vpn-prompt-actions button.primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+  border-color: var(--accent-hover);
+}
+
+/* "Sign in in a terminal" — the same escape hatch inside the connect dialogs, as a
+   switch rather than a button: it is a *mode* for this connect (which half of the
+   login section is on screen), and it has to be flippable back. It borrows the
+   `.remote-connect-remember` row layout so it reads as one of that section's options,
+   set apart only by the rule above it. */
+.terminal-signin-toggle {
+  margin-top: 8px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border);
+}
+
+/* Once a login has actually failed, the hint stops being a footnote about an option
+   and becomes the suggestion — so it is toned like one. */
+.terminal-signin-toggle .terminal-signin-suggest {
+  color: var(--warning, var(--text-primary));
+  opacity: 0.9;
+}
+
+/* "Go easy on this machine" — same borrowed `.remote-connect-remember` row as the
+   terminal-login switch above it, and set apart the same way. It is last in the
+   section on purpose: it says nothing about *this* connect, only about how Eldrun
+   should behave on this host from now on. */
+.careful-host-toggle {
+  margin-top: 8px;
+  padding-top: 8px;
+  border-top: 1px solid var(--border);
+}
+
+/* "Log in in terminal" — an alternative *route*, not a step in this dialog's flow, so
+   it sits apart from the Cancel/Connect pair rather than becoming a third thing to
+   choose between at the same spot. */
+.vpn-prompt-actions button.vpn-prompt-terminal-btn {
+  margin-right: auto;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.vpn-prompt-actions button.vpn-prompt-terminal-btn:hover:not(:disabled) {
+  color: var(--text-primary);
+  border-color: var(--accent);
+}
+
+.vpn-prompt-actions button.vpn-prompt-terminal-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.folder-picker-row span {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--text-primary);
+}
+
+.folder-picker-row button,
+.project-dialog-actions button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 7px 10px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.folder-picker-row button:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+/* Dialog action buttons share the unified accent-underline hover, so their
+   border stays neutral on hover — an accent border here would double the
+   underline's bottom edge (see the unified menu-button block below). */
+.project-dialog-actions button:hover {
+  background: var(--control-hover-bg);
+}
+
+.project-dialog-actions button:last-child {
+  background: var(--accent);
+  color: var(--bg-main);
+  border-color: var(--accent);
+}
+
+.project-dialog-actions button:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+
+/* Destructive confirm (e.g. delete git history) — overrides the accent style
+   the last-child rule otherwise applies. */
+.project-dialog-actions button.danger,
+.project-dialog-actions button.danger:last-child {
+  background: var(--danger);
+  color: var(--bg-main);
+  border-color: var(--danger);
+}
+
+.project-dialog-path {
+  min-height: 16px;
+  color: var(--text-muted);
+  font-size: 12px;
+  word-break: break-all;
+}
+
+/* Remote machines manager (multi-host remote, docs/multi_host_remote_plan.md).
+   Reuses the app's dialog surface; each worker is a bordered card matching the
+   settings toggle-card look. */
+.remote-machine-card {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px 12px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
+}
+
+.remote-machine-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.remote-machine-name {
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.remote-machine-tag {
+  font-size: 10px;
+  padding: 1px 6px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border-color);
+  background: var(--bg-elevated);
+  color: var(--text-secondary);
+}
+
+.remote-machine-target {
+  flex: 1;
+  min-width: 0;
+  font-size: 12px;
+  color: var(--text-muted);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.remote-machine-status {
+  min-height: 16px;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.remote-machine-status.error {
+  color: var(--danger);
+}
+
+.remote-machine-actions {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  align-items: center;
+}
+
+.remote-machine-actions button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 6px 10px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+  cursor: pointer;
+}
+
+.remote-machine-actions button:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.remote-machine-actions button:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+
+.remote-machine-actions button.danger {
+  border-color: var(--danger);
+  color: var(--danger);
+}
+
+.remote-machine-actions button.danger:hover:not(:disabled) {
+  background: var(--danger);
+  color: var(--bg-main);
+}
+
+/* Per-worker toggle rows: label text on the left, switch on the right. */
+.remote-machine-toggle {
+  flex-direction: row !important;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.remote-machine-toggle > span:first-child {
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+/* Wraps the worker cards so the group keeps the dialog's own card-to-card
+   spacing. */
+.remote-machine-worker-list {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+/* The confirm-shared-path panel an incoming global machine seeds — an accent
+   border marks it as the thing that just landed, distinct from an ordinary
+   worker card. */
+.remote-machine-drop-panel {
+  border-color: var(--accent);
+}
+
+/* The "Add a machine" block. Reads as one of the worker cards above it — same
+   border/radius/background/padding — so the form doesn't look like a stray,
+   unframed section tacked onto the list of entries. */
+.remote-machine-add {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 10px 12px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
+}
+
+.remote-machine-add-title {
+  font-weight: 650;
+  color: var(--accent-secondary, var(--accent));
+  font-size: 13px;
+}
+
+.remote-machine-add-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+}
+
+/* "Your machines" — the global-machine shortcut at the top of the add form.
+   Deliberately lighter than a worker card: these are offers, not entries. */
+.remote-machine-global {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--border-color);
+}
+
+.remote-machine-global-title {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-secondary);
+}
+
+.remote-machine-global-list {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  /* A large fleet must not push the form itself off the dialog. */
+  max-height: 168px;
+  overflow-y: auto;
+}
+
+.remote-machine-global-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 6px;
+  border-radius: var(--radius-sm);
+  background: var(--bg-elevated);
+}
+
+.remote-machine-global-row .remote-machine-name {
+  font-size: 12px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+
+.remote-machine-global-row button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 3px 8px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 11px;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.remote-machine-global-row button:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.remote-machine-loggedin {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 13px;
+  color: var(--text-primary);
+}
+
+/* Only the text span flexes — NOT the ConnLamp, which is also a <span> child.
+   A bare `> span` would stretch the 8px round lamp into a green bar. */
+.remote-machine-loggedin > span:not(.conn-lamp) {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.remote-machine-loggedin > button {
+  flex: none;
+}
+
+.extend-summary {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.extend-path-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.extend-path-label {
+  flex: none;
+  width: 52px;
+  color: var(--text-muted);
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.extend-remote-path {
+  flex: 1;
+  min-width: 0;
+  display: block;
+  padding: 6px 10px;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  font-family: var(--font-mono, monospace);
+  font-size: 12px;
+  word-break: break-all;
+}
+
+.remote-chosen-summary {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.remote-chosen-summary .remote-chosen-text {
+  flex: 1;
+  min-width: 0;
+}
+
+.remote-change-folder-btn {
+  flex: none;
+  padding: 2px 10px;
+  font-size: 12px;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.remote-change-folder-btn:hover:not(:disabled) {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+.remote-change-folder-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.project-dialog-error {
+  color: var(--danger);
+  font-size: 12px;
+  word-break: break-word;
+}
+
+/* Local-loss warning (#28q): what lockstep/sync destroyed in the local mirror.
+   Reuses the one dialog surface; only the title takes the warning colour, because
+   the thing being reported is not an error — it is a correct operation the user is
+   entitled to know happened to their machine. */
+.local-loss-dialog {
+  width: min(620px, calc(100vw - 32px));
+}
+
+.local-loss-title {
+  color: var(--warning);
+}
+
+.local-loss-lede {
+  font-size: 12px;
+  color: var(--text-secondary);
+  line-height: 1.5;
+  margin: 0;
+}
+
+.local-loss-list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  overflow-y: auto;
+  max-height: 46vh;
+}
+
+.local-loss-entry {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 10px 12px;
+  background: var(--bg-input);
+  border: 1px solid var(--border-subtle);
+  border-left: 3px solid var(--warning);
+  border-radius: var(--radius);
+}
+
+.local-loss-entry-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.local-loss-badge {
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.local-loss-badge-deleted {
+  color: var(--danger);
+}
+
+.local-loss-badge-overwritten {
+  color: var(--warning);
+}
+
+.local-loss-when {
+  font-size: 11px;
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+
+.local-loss-op {
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.local-loss-paths {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 11px;
+  color: var(--text-primary);
+  max-height: 160px;
+  overflow-y: auto;
+  word-break: break-all;
+}
+
+.local-loss-more {
+  color: var(--text-muted);
+  font-style: italic;
+}
+
+.local-loss-recovery {
+  font-size: 11px;
+  color: var(--text-muted);
+  line-height: 1.5;
+  word-break: break-word;
+}
+
+/* Nothing to recover from: say so in the colour that means it, rather than
+   leaving the line blank and letting the user assume git has a copy. */
+.local-loss-gone {
+  color: var(--danger);
+}
+
+/* Remote-usage warning: the host looked already in use right after connect
+   (high load/memory, or another logged-in session). Same dialog surface as
+   local-loss, same warning-coloured title — but advisory, not a record of
+   something destroyed, so unlike local-loss it dismisses on backdrop click. */
+/* Canonical framed dialog (.settings-title-row header + .dialog-scroll body);
+   only the width is this dialog's own — chrome, header tint and scroll frame all
+   come from the shared .project-dialog.dialog-framed rules. */
+.remote-usage-dialog {
+  width: min(560px, calc(100vw - 32px));
+}
+
+.remote-usage-lede {
+  font-size: 12px;
+  color: var(--text-secondary);
+  line-height: 1.5;
+  margin: 0;
+}
+
+/* One card per connected host (multi-host remote): its own bordered, elevated
+   surface — rather than a divider-separated block — is what keeps two hosts'
+   stats from reading as one continuous list when several are connected. */
+.remote-usage-host {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px 14px;
+  background: var(--bg-panel);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-1);
+}
+
+.remote-usage-host + .remote-usage-host {
+  margin-top: 2px;
+}
+
+.remote-usage-host-title {
+  font-size: 13px;
+  font-weight: 650;
+  color: var(--text-primary);
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.remote-usage-reasons {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  margin: 0;
+  padding-left: 18px;
+  font-size: 12px;
+  color: var(--text-primary);
+}
+
+/* ── The HPC tag ───────────────────────────────────────────────────────────
+   The badge that marks a machine as a shared cluster login node (Machines menu
+   row, connect dialog, the guard modal). Deliberately loud enough to notice on a
+   row and small enough not to shout: it is a fact about the machine, not a
+   warning about it. */
+.hpc-badge {
+  display: inline-flex;
+  align-items: center;
+  padding: 0 5px;
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  line-height: 15px;
+  color: var(--accent);
+  background: transparent;
+  flex: none;
+}
+
+.hpc-guard-dialog {
+  max-width: 520px;
+}
+.hpc-guard-title {
+  margin: 0 0 10px;
+  font-size: 15px;
+  font-weight: 650;
+  color: var(--text-primary);
+}
+.hpc-guard-target {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 10px;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+.hpc-guard-target code {
+  font-size: 11px;
+  color: var(--text-primary);
+}
+.hpc-guard-badge {
+  padding: 0 5px;
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  line-height: 15px;
+  color: var(--accent);
+}
+.hpc-guard-body {
+  margin: 0 0 10px;
+  font-size: 12px;
+  line-height: 1.6;
+  color: var(--text-primary);
+}
+.hpc-guard-note {
+  margin: 0 0 14px;
+  font-size: 11px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+
+/* The HPC-host note: why this section lists only the user's own sessions and
+   processes. Informational, so it is toned down against the reasons list above
+   it — it explains the reading, it is not one of the warnings. */
+.remote-usage-careful {
+  padding: 6px 8px;
+  border-left: 3px solid var(--accent);
+  border-radius: 4px;
+  background: var(--bg-subtle, rgba(127, 127, 127, 0.08));
+  font-size: 11px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+
+.remote-usage-stats {
+  display: flex;
+  gap: 16px;
+  flex-wrap: wrap;
+  /* No border/background of its own — the host card above already provides
+     the boundary; a nested box here just read as a card-in-a-card. */
+}
+
+.remote-usage-stat {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.remote-usage-stat-label {
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+.remote-usage-stat-value {
+  font-size: 12px;
+  color: var(--text-primary);
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+}
+
+/* Traffic-light dot for CPU/GPU utilization: green (idle) → orange → red. */
+.remote-usage-light {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  margin-right: 6px;
+  border-radius: 50%;
+  vertical-align: baseline;
+  background: var(--text-muted);
+}
+
+.remote-usage-light.is-green {
+  background: var(--success);
+  box-shadow: 0 0 4px var(--success);
+}
+
+.remote-usage-light.is-orange {
+  background: var(--warning);
+  box-shadow: 0 0 4px var(--warning);
+}
+
+.remote-usage-light.is-red {
+  background: var(--danger);
+  box-shadow: 0 0 4px var(--danger);
+}
+
+.remote-usage-stat-sub {
+  color: var(--text-muted);
+  font-family: inherit;
+}
+
+.remote-usage-section {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.remote-usage-section-title {
+  font-size: 11px;
+  font-weight: 650;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.02em;
+}
+
+.remote-usage-empty {
+  color: var(--text-muted);
+  font-style: italic;
+  font-size: 12px;
+}
+
+.remote-usage-procs {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  max-height: 140px;
+  overflow-y: auto;
+}
+
+.remote-usage-procs li {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  font-size: 11px;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  color: var(--text-primary);
+  padding: 3px 6px;
+  background: var(--bg-input);
+  border-radius: var(--radius);
+}
+
+.remote-usage-proc-cmd {
+  font-weight: 650;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.remote-usage-proc-user {
+  color: var(--text-secondary);
+}
+
+.remote-usage-proc-pct {
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+
+/* The per-user "Logged in" table: a real grid, not flex, so User / CPU /
+   Sessions / Mem line up column-for-column across every row and the header.
+   Each `li` is `display: contents` so its cells become direct grid items —
+   that's what keeps a data row's columns in the same tracks as the header's. */
+.remote-usage-users {
+  display: grid;
+  grid-template-columns: minmax(60px, max-content) repeat(3, max-content);
+  column-gap: 14px;
+  row-gap: 2px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  max-height: 140px;
+  overflow-y: auto;
+  font-size: 11px;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+}
+.remote-usage-users li {
+  display: contents;
+}
+.remote-usage-users-head span {
+  color: var(--text-muted);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.02em;
+  padding: 0 6px;
+}
+.remote-usage-users li:not(.remote-usage-users-head) > span {
+  padding: 3px 6px;
+  background: var(--bg-input);
+  color: var(--text-primary);
+}
+.remote-usage-users li:not(.remote-usage-users-head) > span:first-child {
+  border-top-left-radius: var(--radius);
+  border-bottom-left-radius: var(--radius);
+}
+.remote-usage-users li:not(.remote-usage-users-head) > span:last-child {
+  border-top-right-radius: var(--radius);
+  border-bottom-right-radius: var(--radius);
+}
+.remote-usage-user {
+  font-weight: 650;
+  white-space: nowrap;
+}
+/* "you" chip on the connected account's own row in the "Logged in" table — the
+   row is pinned to the top, and this is what says why it is there (on a host
+   where the login name differs from the local one, the name alone doesn't). */
+.remote-usage-user-you {
+  margin-left: 6px;
+  padding: 0 4px;
+  border-radius: var(--radius-sm);
+  background: var(--accent-soft, rgba(88, 166, 255, 0.22));
+  color: var(--accent);
+  font-size: 9px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+  vertical-align: 1px;
+}
+.remote-usage-user-cpu,
+.remote-usage-user-sessions,
+.remote-usage-user-mem {
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+  color: var(--text-secondary);
+  white-space: nowrap;
+}
+.remote-usage-user-cpu {
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 4px;
+}
+
+.scaffold-popover {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px;
+  background: var(--bg-main);
+  border: 1px solid var(--border-subtle);
+}
+
+.scaffold-popover-title {
+  color: var(--accent);
+  font-size: 13px;
+  font-weight: 650;
+}
+
+.scaffold-steps {
+  margin: 0;
+  padding-left: 18px;
+  color: var(--text-secondary);
+  font-size: 12px;
+}
+
+.scaffold-steps li + li {
+  margin-top: 3px;
+}
+
+.manual-validation-row {
+  min-height: 28px;
+  flex-direction: row !important;
+  align-items: center;
+  gap: 8px !important;
+  color: var(--text-primary) !important;
+}
+
+.manual-validation-row input[type="checkbox"],
+.skip-scaffold-row input[type="checkbox"] {
+  width: 16px;
+  height: 16px;
+  padding: 0;
+  flex: 0 0 auto;
+  accent-color: var(--accent);
+}
+
+.skip-scaffold-row {
+  min-height: 28px;
+  flex-direction: row !important;
+  align-items: center;
+  gap: 8px !important;
+  color: var(--text-primary) !important;
+}
+
+.scaffold-fill-all-row {
+  display: grid !important;
+  grid-template-columns: minmax(0, 1fr) minmax(160px, 210px);
+  gap: 10px !important;
+  align-items: center;
+  color: var(--text-primary) !important;
+}
+
+.scaffold-fill-all-row span {
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.scaffold-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.scaffold-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(160px, 210px);
+  gap: 10px;
+  align-items: center;
+  padding: 7px 8px;
+  border: 1px solid var(--border-subtle);
+  background: var(--control-bg);
+}
+
+.scaffold-file {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.scaffold-file span {
+  color: var(--text-primary);
+  overflow-wrap: anywhere;
+}
+
+.scaffold-file small,
+.scaffold-empty {
+  color: var(--text-muted);
+  font-size: 12px;
+}
+
+.scaffold-row select:disabled {
+  opacity: 0.62;
+  cursor: default;
+}
+
+.scaffold-row-status {
+  color: var(--text-muted);
+  font-size: 12px;
+  text-align: right;
+}
+
+@media (max-width: 640px) {
+  .scaffold-fill-all-row,
+  .scaffold-row {
+    grid-template-columns: 1fr;
+  }
+
+  .scaffold-row-status {
+    text-align: left;
+  }
+}
+
+.ssh-optional-hint {
+  color: var(--text-muted);
+  font-weight: 400;
+  font-size: 12px;
+}
+
+/* ── Mode-toggle card + sliding switch (remote-project / OpenVPN toggles) ──── */
+/* A bordered row carrying a title + one-line description on the left and a
+   sliding switch on the right. Lights up with the accent when the mode is on,
+   replacing the bare native checkbox these toggles used to render as. */
+.toggle-card {
+  display: flex !important;
+  flex-direction: row !important;
+  align-items: center;
+  gap: 14px;
+  padding: 11px 13px;
+  border: 1px solid var(--border-subtle);
+  background: var(--control-bg);
+  cursor: pointer;
+  transition: border-color var(--transition), background var(--transition);
+}
+
+.toggle-card:hover {
+  border-color: color-mix(in srgb, var(--accent) 55%, var(--border-subtle));
+}
+
+.toggle-card.is-on {
+  border-color: var(--accent);
+  background: color-mix(in srgb, var(--accent) 9%, var(--control-bg));
+}
+
+.toggle-card-body {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+
+.toggle-card-title {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--text-primary);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.toggle-card-desc {
+  color: var(--text-muted);
+  font-size: 12px;
+  font-weight: 400;
+  line-height: 1.4;
+}
+
+/* The static twin of `.toggle-card`, borrowing its title/desc typography: shown in
+   place of a dialog's "Connect via OpenVPN" toggle once a tunnel is up machine-wide
+   (`VpnTunnelUpNotice`). Nothing to switch — the tunnel already exists — so it reads
+   as a lit, non-interactive card rather than an off toggle. */
+.vpn-up-card {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  padding: 11px 13px;
+  border: 1px solid color-mix(in srgb, var(--accent) 45%, var(--border-subtle));
+  background: color-mix(in srgb, var(--accent) 9%, var(--control-bg));
+}
+
+/* Sliding pill switch. The checkbox is the real (focusable) control, layered
+   transparently over the track; the track's ::after pseudo is the moving knob. */
+.eld-switch {
+  position: relative;
+  flex: 0 0 auto;
+  display: inline-flex;
+  width: 40px;
+  height: 22px;
+}
+
+.eld-switch input[type="checkbox"] {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  margin: 0;
+  padding: 0;
+  opacity: 0;
+  cursor: pointer;
+  z-index: 1;
+}
+
+.eld-switch-track {
+  position: absolute;
+  inset: 0;
+  border-radius: var(--radius-full);
+  background: color-mix(in srgb, var(--text-secondary) 32%, transparent);
+  border: 1px solid var(--control-border);
+  transition: background var(--transition), border-color var(--transition);
+}
+
+.eld-switch-track::after {
+  content: "";
+  position: absolute;
+  top: 50%;
+  left: 3px;
+  width: 14px;
+  height: 14px;
+  border-radius: 50%;
+  background: var(--text-primary);
+  transform: translateY(-50%);
+  transition: transform var(--transition), background var(--transition);
+}
+
+.eld-switch input:checked + .eld-switch-track {
+  background: var(--accent);
+  border-color: var(--accent);
+}
+
+.eld-switch input:checked + .eld-switch-track::after {
+  transform: translate(18px, -50%);
+  background: #fff;
+}
+
+.eld-switch input:focus-visible + .eld-switch-track {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+}
+
+/* Compact variant for inline toolbars / filter rows (file-browser filters,
+   search options, per-file-type viewer prefs) where the full-size pill would
+   dominate a dense row. */
+.eld-switch-sm {
+  width: 30px;
+  height: 16px;
+}
+
+.eld-switch-sm .eld-switch-track::after {
+  width: 10px;
+  height: 10px;
+  left: 2px;
+}
+
+.eld-switch-sm input:checked + .eld-switch-track::after {
+  transform: translate(14px, -50%);
+}
+
+/* OpenVPN section heading. There's no on/off toggle (OpenVPN is the only tunnel
+   type), so this is a plain title + hint that labels the always-shown config
+   controls below; the tunnel is used only when a config is actually selected. */
+.vpn-section-header {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+
+/* Expanded OpenVPN controls, nested under the section heading with an accent
+   spine so the config picker / connect button read as belonging to it. */
+.vpn-details {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 2px 0 2px 12px;
+  border-left: 2px solid color-mix(in srgb, var(--accent) 45%, transparent);
+}
+
+.ssh-connect-fields {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px;
+  background: var(--bg-main);
+  border: 1px solid var(--border-subtle);
+}
+
+.ssh-tooling-warning {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 8px 10px;
+  font-size: 12px;
+  color: var(--danger);
+  background: color-mix(in srgb, var(--danger) 12%, transparent);
+  border: 1px solid var(--danger);
+  word-break: break-word;
+}
+
+/* "Recently used…" picker reuses the address-input look but is a real select. */
+.vpn-config-recent {
+  cursor: pointer;
+}
+
+/* The OpenVPN config a remote project currently uses: label + file name + the
+   "Change…" way back to the picker, so a stored choice is visible and swappable
+   rather than a one-shot decision. */
+.vpn-config-current {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  padding: 2px 0;
+  font-size: 12px;
+}
+.vpn-config-current-name {
+  flex: 1 1 auto;
+  font-family: var(--mono-font, monospace);
+  color: var(--text-secondary);
+  word-break: break-all;
+}
+.vpn-config-change-btn {
+  flex: 0 0 auto;
+}
+
+/* OpenVPN connect button: animate the in-flight handshake and tint the button
+   by tunnel state so its status reads at a glance (the exact state/error is in
+   the hover title). */
+.vpn-connect-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  transition: background var(--transition-slow), border-color var(--transition-slow), color var(--transition-slow);
+}
+
+.vpn-connect-btn.vpn-status-connecting {
+  /* Disabled while connecting, but keep it visibly "alive" with a soft pulse. */
+  border-color: var(--accent);
+  color: var(--accent);
+  animation: vpn-connecting-pulse 1.1s ease-in-out infinite;
+}
+
+.vpn-connect-btn.vpn-status-connected {
+  border-color: var(--success, #3fb950);
+  color: var(--success, #3fb950);
+  background: color-mix(in srgb, var(--success, #3fb950) 14%, transparent);
+}
+
+.vpn-connect-btn.vpn-status-error {
+  border-color: var(--danger);
+  color: var(--danger);
+  background: color-mix(in srgb, var(--danger) 12%, transparent);
+}
+
+/* Small spinning ring shown inside the button while the tunnel comes up. */
+.vpn-spinner {
+  width: 11px;
+  height: 11px;
+  border: 2px solid color-mix(in srgb, var(--accent) 35%, transparent);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: file-viewer-spin 0.7s linear infinite;
+  flex: 0 0 auto;
+}
+
+@keyframes vpn-connecting-pulse {
+  0%,
+  100% {
+    background: color-mix(in srgb, var(--accent) 8%, transparent);
+  }
+  50% {
+    background: color-mix(in srgb, var(--accent) 22%, transparent);
+  }
+}
+
+/* Non-headless connect block: the "Connect VPN…/Log in over SSH…" button and,
+   once clicked, the live terminal embedded in the project dialog where the user
+   authenticates the tunnel/login. The PTY outlives the dialog (persistOnUnmount)
+   so the new project rides the connection it set up. */
+.dialog-connect {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px;
+  border: 1px solid color-mix(in srgb, var(--accent) 45%, var(--border-color));
+  background: color-mix(in srgb, var(--accent) 7%, transparent);
+}
+
+/* Prominent call-to-action so it's obvious THIS is where you open the login
+   terminal — full-width, accent-filled, with a blinking-prompt glyph. */
+.dialog-connect-btn {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  width: 100%;
+  padding: 9px 12px;
+  font-weight: 600;
+  /* --bg-main (not --accent-contrast) matches .btn-primary and the dialog
+     action buttons — legible dark-on-accent instead of low-contrast white. */
+  color: var(--bg-main);
+  background: var(--accent);
+  border: 1px solid var(--accent);
+  border-radius: var(--radius);
+  cursor: pointer;
+  transition: background var(--transition), border-color var(--transition), opacity var(--transition);
+}
+
+.dialog-connect-btn:hover:not(:disabled) {
+  background: var(--accent-hover, var(--accent));
+  border-color: var(--accent-hover, var(--accent));
+}
+
+.dialog-connect-btn:disabled {
+  cursor: default;
+  opacity: 0.55;
+}
+
+.dialog-connect-btn-icon {
+  font-family: "JetBrains Mono", "Fira Code", Consolas, Menlo, monospace;
+  font-weight: 700;
+  letter-spacing: -1px;
+}
+
+/* ── Shared CTA buttons ──────────────────────────────────────────────────
+   The one canonical primary / danger call-to-action for the whole app. Filled
+   accent (or danger) with text in --bg-main — legible on every theme's accent
+   (dark text on the dark themes' bright accents, light text on the light
+   themes' blues), where fixed-white --accent-contrast would wash out. Sharp
+   corners via --radius. Use .btn-primary / .btn-danger (+ .btn-block to span a
+   row) for any new CTA so buttons never drift again. */
+.btn-primary,
+.btn-danger {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 9px 12px;
+  border-radius: var(--radius);
+  font-weight: 600;
+  color: var(--bg-main);
+  cursor: pointer;
+  transition: background var(--transition), border-color var(--transition), opacity var(--transition), transform var(--transition);
+}
+
+.btn-primary {
+  background: var(--accent);
+  border: 1px solid var(--accent);
+}
+
+.btn-danger {
+  background: var(--danger);
+  border: 1px solid var(--danger);
+}
+
+.btn-primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+  border-color: var(--accent-hover);
+}
+
+.btn-primary:active:not(:disabled) {
+  background: var(--accent-active);
+  border-color: var(--accent-active);
+}
+
+.btn-danger:hover:not(:disabled) {
+  filter: brightness(1.08);
+}
+
+.btn-danger:active:not(:disabled) {
+  filter: brightness(0.94);
+}
+
+.btn-primary:disabled,
+.btn-danger:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+
+.btn-block {
+  width: 100%;
+}
+
+/* ── Unified menu-button interaction (accent underline + press) ────────────
+   Every menu-row button — the context menu, the +tab menu, the custom
+   dropdown menu, and the project-switcher add menu — shares ONE hover/press
+   feel so they never drift: a theme-accent underline that wipes in from the
+   leading edge on hover, and a quick scale-down on click. The per-menu rules
+   above still own each menu's layout, colours and background-hover; this only
+   layers the shared accent underline and the press animation on top. The
+   hover accent was moved OUT of the box border (now kept neutral, so the
+   underline reads cleanly instead of doubling the bottom edge) — the accent
+   border survives only as the +tab menu's keyboard `enter-target` and the
+   dropdown's `.selected`, which are distinct "this is picked" signals, not
+   plain hover. */
+.context-menu button,
+.tab-new-menu-item,
+.dropdown .dropdown-menu button,
+.project-switcher-add-menu button,
+.project-dialog-actions button {
+  position: relative;
+  transition: background-color var(--transition), border-color var(--transition),
+    color var(--transition), transform var(--transition);
+}
+
+/* The underline: a pseudo-element pinned to the bottom edge, scaled to 0 on
+   the x-axis and grown to full width on hover. transform-origin left makes it
+   wipe in from the leading edge. Inset to match each row's horizontal padding
+   so it sits under the label, not the full box. */
+.context-menu button::after,
+.tab-new-menu-item::after,
+.dropdown .dropdown-menu button::after,
+.project-switcher-add-menu button::after,
+.project-dialog-actions button::after {
+  content: "";
+  position: absolute;
+  left: 9px;
+  right: 9px;
+  bottom: 3px;
+  height: 2px;
+  border-radius: var(--radius-full);
+  background: var(--accent);
+  transform: scaleX(0);
+  transform-origin: left center;
+  transition: transform var(--transition);
+  pointer-events: none;
+}
+
+.context-menu button:hover:not(:disabled)::after,
+.tab-new-menu-item:hover:not(:disabled)::after,
+.tab-new-menu-item.enter-target::after,
+.dropdown .dropdown-menu button:hover:not(:disabled)::after,
+.project-switcher-add-menu button:hover::after,
+.project-dialog-actions button:hover:not(:disabled)::after {
+  transform: scaleX(1);
+}
+
+/* Danger actions underline in the danger hue, tracking their red text. */
+.context-menu button.danger::after,
+.context-menu-danger-zone button::after {
+  background: var(--danger);
+}
+
+/* Dialog action rows: the filled CTA (last-child) and danger buttons sit on an
+   accent/danger fill, where an accent underline would be invisible — so their
+   underline is drawn in the button's own text colour (--bg-main) instead. */
+.project-dialog-actions button:last-child::after,
+.project-dialog-actions button.danger::after {
+  background: var(--bg-main);
+}
+
+/* Click feedback: a quick press-in, shared by the menu rows AND the CTA
+   buttons so every button in the app answers a click the same way. */
+.context-menu button:active:not(:disabled),
+.tab-new-menu-item:active:not(:disabled),
+.dropdown .dropdown-menu button:active:not(:disabled),
+.project-switcher-add-menu button:active,
+.project-dialog-actions button:active:not(:disabled),
+.btn-primary:active:not(:disabled),
+.btn-danger:active:not(:disabled) {
+  transform: scale(0.97);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .context-menu button::after,
+  .tab-new-menu-item::after,
+  .dropdown .dropdown-menu button::after,
+  .project-switcher-add-menu button::after,
+  .project-dialog-actions button::after {
+    transition: none;
+  }
+  .context-menu button:active:not(:disabled),
+  .tab-new-menu-item:active:not(:disabled),
+  .dropdown .dropdown-menu button:active:not(:disabled),
+  .project-switcher-add-menu button:active,
+  .project-dialog-actions button:active:not(:disabled),
+  .btn-primary:active:not(:disabled),
+  .btn-danger:active:not(:disabled) {
+    transform: none;
+  }
+}
+
+.dialog-connect-terminal {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  border: 1px solid var(--border-color);
+  padding: 6px;
+  background: var(--bg-panel);
+}
+
+.dialog-connect-terminal-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+/* Fixed-height host so the embedded xterm has a stable layout box to open into
+   (xterm refuses to render in a zero-height element). */
+.dialog-connect-terminal-host {
+  height: 180px;
+  min-height: 180px;
+  display: flex;
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+}
+
+.vpn-disconnect-btn {
+  border-color: var(--danger);
+  color: var(--danger);
+  flex: 0 0 auto;
+}
+
+/* "Paste username / password" above a login terminal (see CredentialPasteBar):
+   small, secondary buttons — the login itself happens in the terminal below, this
+   only saves retyping a credential the keychain already holds. */
+.credential-paste-bar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.credential-paste-btn {
+  flex: 0 0 auto;
+  padding: 2px 8px;
+  font-size: 0.8em;
+  border-radius: var(--radius-sm);
+}
+
+.credential-paste-note {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+/* "Push to GitHub/GitLab" picked but no Eldrun connection yet: a nudge to set
+   the access token up in Settings → Git Hosting, with a one-click redirect. */
+.git-connect-notice {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  margin-top: 6px;
+  padding: 8px 10px;
+  border: 1px solid var(--accent);
+  border-radius: var(--radius);
+  background: color-mix(in srgb, var(--accent) 10%, transparent);
+  color: var(--text-primary, var(--text));
+  font-size: 0.85em;
+}
+
+.git-connect-notice button {
+  flex: 0 0 auto;
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+/* Read-only live OpenVPN handshake log (headless connect). Terminal-styled so a
+   streamed connect reads as live work; capped + scrollable so a chatty handshake
+   stays inside the dialog. */
+.connection-log {
+  max-height: 150px;
+  overflow-y: auto;
+  padding: 6px 8px;
+  border: 1px solid var(--border-color);
+  background: var(--bg-panel);
+  font-family: "JetBrains Mono", "Fira Code", Consolas, Menlo, monospace;
+  font-size: 11px;
+  line-height: 1.45;
+}
+
+.connection-log-line {
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: var(--text-secondary, var(--text));
+}
+
+.connection-log-waiting {
+  opacity: 0.7;
+  font-style: italic;
+}
+
+.sshfs-install {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-top: 4px;
+  padding-top: 6px;
+  border-top: 1px solid color-mix(in srgb, var(--danger) 40%, transparent);
+  color: var(--text-main);
+}
+
+.sshfs-install-instruction {
+  font-size: 12px;
+}
+
+.sshfs-install-commands {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.sshfs-install-cmd {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 6px;
+  font-family: var(--font-mono, monospace);
+  font-size: 12px;
+  background: var(--bg-main);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+}
+
+.sshfs-install-cmd-text {
+  flex: 1;
+  min-width: 0;
+  overflow-x: auto;
+  white-space: pre;
+}
+
+.sshfs-install-copy,
+.sshfs-install-guide-btn {
+  flex: none;
+  padding: 2px 8px;
+  font-size: 11px;
+  cursor: pointer;
+}
+
+.sshfs-install-guide-btn {
+  align-self: flex-start;
+}
+
+.ssh-address-input,
+.ssh-password-input {
+  flex: 1;
+  min-width: 0;
+  width: 100%;
+}
+
+.remote-browser {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px;
+  background: var(--bg-main);
+  border: 1px solid var(--border-subtle);
+}
+
+.remote-browser-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.remote-up-btn {
+  flex: 0 0 auto;
+}
+
+.remote-breadcrumb {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--text-primary);
+  font-size: 12px;
+}
+
+.remote-browser-header button {
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 5px 9px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.remote-browser-header button:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.remote-newfolder {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 6px;
+}
+
+.remote-newfolder-input {
+  flex: 1;
+  min-width: 0;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 5px 8px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  font-size: 12px;
+}
+
+.remote-newfolder button {
+  flex: 0 0 auto;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  padding: 5px 9px;
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.remote-newfolder button:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.remote-newfolder button:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.remote-list {
+  display: flex;
+  flex-direction: column;
+  max-height: 200px;
+  overflow-y: auto;
+  border: 1px solid var(--border-subtle);
+  background: var(--control-bg);
+}
+
+.remote-entry {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 5px 8px;
+  font-size: 13px;
+}
+
+.remote-entry + .remote-entry {
+  border-top: 1px solid var(--border-subtle);
+}
+
+.remote-entry.is-dir {
+  color: var(--text-primary);
+  cursor: pointer;
+}
+
+.remote-entry.is-dir:hover {
+  background: var(--control-hover-bg);
+}
+
+.remote-entry.is-file {
+  color: var(--text-muted);
+  cursor: default;
+}
+
+.remote-entry-icon {
+  flex: 0 0 auto;
+  color: var(--text-muted);
+}
+
+.remote-entry-name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.remote-chosen {
+  color: var(--text-muted);
+  font-size: 12px;
+  word-break: break-all;
+}
+
+.project-dialog-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 4px;
+}
+
+/* ── Large-folder sync prompt (BigFolderExcludeDialog) ───────────────── */
+/* One grid shared by the header row and every folder row, so the two side
+   columns line up without either knowing the other's width. */
+.big-folder-head,
+.big-folder-row {
+  display: grid;
+  grid-template-columns: 18px minmax(0, 1fr) 150px 150px;
+  align-items: center;
+  gap: 8px;
+}
+.big-folder-head {
+  margin-top: 10px;
+  padding-bottom: 4px;
+  border-bottom: 1px solid var(--border);
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-muted);
+}
+.big-folder-list {
+  max-height: 300px;
+  overflow-y: auto;
+}
+.big-folder-row {
+  padding: 5px 0;
+  border-bottom: 1px solid var(--border-subtle, var(--border));
+  font-size: 12px;
+  cursor: pointer;
+}
+.big-folder-row:hover {
+  background: var(--bg-hover);
+}
+.big-folder-path {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-family: var(--font-mono, monospace);
+}
+.big-folder-files {
+  color: var(--text-muted);
+}
+.big-folder-absent {
+  color: var(--text-muted);
+  opacity: 0.6;
+}
+.big-folder-intro,
+.big-folder-note {
+  margin: 8px 0 0;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-muted);
+}
+
+/* The "measure the host anyway" action inside that note. It is deliberately a
+   link and not a dialog button: on a careful host the host scan is the exception
+   the user asks for by name, so it belongs in the sentence explaining why it did
+   not happen — not in the action row beside Apply, where it would read as part of
+   the normal flow. */
+.big-folder-note .link-button {
+  padding: 0;
+  border: 0;
+  background: none;
+  font: inherit;
+  color: var(--accent, var(--text-primary));
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+.big-folder-note .link-button:disabled {
+  color: var(--text-muted);
+  text-decoration: none;
+  cursor: default;
+}
+
+/* A hint sentence's inline action (e.g. "Create a GitHub access token…") —
+   reads as part of the sentence, not a dialog button. Unscoped (unlike
+   .big-folder-note .link-button above) so any hint row can use it. */
+.inline-link-btn {
+  padding: 0;
+  border: 0;
+  background: none;
+  font: inherit;
+  color: var(--accent, var(--text-primary));
+  text-decoration: underline;
+  cursor: pointer;
+}
+
+/* ── Orbit spinner (active-tracking indicator) ───────────────────────── */
+@keyframes orbit-spin {
+  from { transform: rotate(0deg); }
+  to   { transform: rotate(360deg); }
+}
+
+.orbit-spinner {
+  display: inline-block;
+  vertical-align: middle;
+  margin-left: 5px;
+  animation: orbit-spin 2s linear infinite;
+  flex-shrink: 0;
+}
+
+.orbit-dot {
+  fill: var(--accent);
+}
+
+/* ── Activity calendar ───────────────────────────────────────────────── */
+.activity-calendar {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  user-select: none;
+}
+
+.activity-cell {
+  fill: var(--activity-0);
+  transition: opacity var(--transition);
+}
+.activity-cell:hover { opacity: 0.8; }
+.activity-cell-0 { fill: var(--activity-0); }
+.activity-cell-1 { fill: var(--activity-1); }
+.activity-cell-2 { fill: var(--activity-2); }
+.activity-cell-3 { fill: var(--activity-3); }
+.activity-cell-4 { fill: var(--activity-4); }
+.activity-today  { stroke: var(--accent); stroke-width: 1.5; }
+
+/* ── Activity year selector ──────────────────────────────────────────── */
+.activity-years {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+  margin-bottom: 8px;
+}
+
+.activity-year-btn {
+  padding: 2px 8px;
+  border: 1px solid var(--control-border);
+  background: var(--control-bg);
+  color: var(--text-secondary);
+  font-size: 11px;
+  cursor: pointer;
+  border-radius: 2px;
+  transition: background var(--transition), border-color var(--transition), color var(--transition);
+}
+
+.activity-year-btn:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--text-muted);
+  color: var(--text-primary);
+}
+
+.activity-year-btn.selected {
+  background: var(--pill-active-bg);
+  border-color: var(--pill-active-border);
+  color: var(--text-primary);
+}
+
+.activity-legend {
+  display: flex;
+  align-items: center;
+  gap: 3px;
+  margin-left: 28px;
+}
+
+.activity-legend span {
+  font-size: 10px;
+  color: var(--text-muted);
+}
+
+.activity-tooltip {
+  padding: 5px 9px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  font-size: 11px;
+  color: var(--text-primary);
+  white-space: nowrap;
+  box-shadow: var(--shadow-2);
+}
+
+.activity-tooltip strong {
+  color: var(--text-primary);
+}
+
+/* ── Ollama settings panel ───────────────────────────────────────────── */
+.ollama-status-bar {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 0 8px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.ollama-status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+.ollama-status-dot.running { background-color: var(--success); }
+.ollama-status-dot.stopped { background-color: var(--text-muted); }
+
+/* Vibe runtime section + its inline status dot (used inside flowing text). */
+.ollama-vibe-section { margin-top: 14px; }
+
+/* Each agent rendered as a separated, card-like list entry in Manage Agents. */
+.agent-list-entry {
+  margin-top: 0;
+  padding: 10px 12px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius);
+  background: var(--bg-elevated, rgba(255, 255, 255, 0.03));
+}
+.agent-list-entry .settings-section-title {
+  margin-top: 0;
+  padding-top: 0;
+  border-top: none;
+}
+.agent-list-entry-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+/* Enabled/Disabled toggle on an installed agent's row: hides it from tab-choice
+   menus (add-tab Agents group, Local Model drivers) without uninstalling it. */
+.agent-disable-toggle {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-shrink: 0;
+  font-size: 11px;
+  color: var(--text-secondary);
+  cursor: pointer;
+}
+/* Codex's session-hook-trust notice, nested inside its own agent-list-entry
+   card rather than floating as a separate top-of-panel section. */
+.agent-codex-hook {
+  margin-top: 10px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border-subtle);
+}
+.agent-codex-hook .settings-section-title {
+  margin-top: 0;
+  padding-top: 0;
+  border-top: none;
+}
+.ollama-vibe-section .ollama-status-dot {
+  display: inline-block;
+  vertical-align: middle;
+  margin-right: 6px;
+}
+
+.ollama-status-text {
+  flex: 1;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.ollama-empty {
+  font-size: 12px;
+  color: var(--text-muted);
+  padding: 4px 0;
+}
+
+.ollama-section-title-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+/* ── Local-model header button: live server-status dot ───────────────────── */
+.local-model-btn {
+  position: relative;
+}
+.local-model-status-dot {
+  position: absolute;
+  right: 1px;
+  bottom: 1px;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  pointer-events: none;
+}
+/* Server unreachable (red) → up but no model in memory (yellow) → model loaded (green). */
+.local-model-status-dot.stopped { background-color: var(--danger); }
+.local-model-status-dot.idle { background-color: var(--warning); }
+.local-model-status-dot.loaded { background-color: var(--success); }
+
+/* ── Local-model menu: live "loaded in memory" status line ───────────────── */
+.local-model-loaded {
+  padding: 4px 10px 6px;
+  border-bottom: 1px solid var(--control-border);
+  margin-bottom: 2px;
+}
+.local-model-loaded-idle {
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+.local-model-loaded-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.local-model-loaded-name {
+  font-size: 12px;
+  color: var(--text-primary);
+  font-weight: 600;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.local-model-loaded-badges {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  flex-shrink: 0;
+}
+.local-model-loaded-badges > span {
+  font-size: 10px;
+  line-height: 1;
+  padding: 2px 5px;
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-secondary);
+  white-space: nowrap;
+}
+.local-model-loaded-badges > span.gpu {
+  background: color-mix(in srgb, var(--success) 22%, transparent);
+  color: var(--success);
+}
+
+/* ── The device's own GPU memory: how much headroom is left before the next
+      model is loaded. Toned by ratio, like the header's GPU row. ───────────── */
+.local-model-gpu {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+}
+.local-model-gpu.low {
+  color: var(--success);
+}
+.local-model-gpu.medium {
+  color: var(--warning);
+}
+.local-model-gpu.high {
+  color: var(--danger);
+}
+
+/* ── Loaded-model row: green "resident" lamp + per-task tag chips ─────────── */
+/* The row (not the inner name button) owns the hover border/fill so the
+   highlight wraps the task tags below the name, not just the name itself. */
+.local-model-row {
+  display: flex;
+  flex-direction: column;
+  background: var(--control-bg);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  transition: background-color var(--transition), border-color var(--transition);
+}
+.local-model-row:hover {
+  background-color: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+/* The clickable name button sits inside the row; the lamp replaces the old
+   leading dot and a "default" tag marks the fallback model. It stays transparent
+   so the row's hover treatment shows through and there's no double outline. */
+.local-model-pick,
+.local-model-row:hover .local-model-pick,
+.local-model-pick:hover {
+  width: 100%;
+  background: transparent;
+  border-color: transparent;
+}
+.local-model-lamp {
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  background: var(--success);
+  box-shadow: 0 0 4px color-mix(in srgb, var(--success) 70%, transparent);
+}
+
+/* ── Remote-connection status lamps (SSH / OpenVPN) ───────────────────────────
+   Red/orange/green dots shown in the project dialog (next to the connect
+   controls) and in the header (active remote project). Modeled on the
+   resident-model lamp above; the connecting state pulses to read as "in flight". */
+.conn-lamp {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  vertical-align: middle;
+  background: color-mix(in srgb, var(--text-secondary) 45%, transparent);
+}
+.conn-lamp-connected {
+  background: var(--success);
+  box-shadow: 0 0 5px color-mix(in srgb, var(--success) 75%, transparent);
+}
+.conn-lamp-connecting {
+  background: var(--warning);
+  box-shadow: 0 0 5px color-mix(in srgb, var(--warning) 75%, transparent);
+  animation: conn-lamp-pulse 1.1s ease-in-out infinite;
+}
+.conn-lamp-error {
+  background: var(--danger);
+  box-shadow: 0 0 5px color-mix(in srgb, var(--danger) 75%, transparent);
+}
+@keyframes conn-lamp-pulse {
+  0%,
+  100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.35;
+  }
+}
+/* A CONNECTED host with live work on it (≥1 tmux session, `stores/hostBusy`).
+   Deliberately not the `connecting` pulse: that one fades the dot most of the
+   way out, which reads as "pending / not there yet". This one keeps the dot at
+   full opacity and breathes its halo instead, so it reads as a heartbeat — the
+   machine is up AND something is running on it. Same green, so the connection
+   state it carries is never in doubt, and it never adds a lamp: a busy fleet
+   pulses the green lamp it already had.
+
+   Two intensities on purpose. In the **top bar** the lamp is an ambient badge
+   sitting in permanent peripheral vision, so it only breathes its halo — a dot
+   that visibly grew and shrank up there all day would be a nag. In a **menu or
+   dialog** (below) the lamp is something you opened to read, and it has to be
+   unmistakable at a glance across sixteen rows, so it also scales. */
+/* The halo lives on a pseudo-element whose box-shadow is STATIC, and the pulse
+   animates that element's `opacity` (+ `transform` for the strong variant). This
+   is not a style preference — it is the difference between a composited animation
+   and a repainting one. `box-shadow` is a paint property: animating it re-rasterises
+   a blurred shadow every frame, and with the DMABUF renderer disabled (see
+   `lib.rs`) that rasterisation is pure CPU. Sixteen rows of it saturated a core for
+   as long as the Machines menu was open. `opacity`/`transform` animate on the
+   already-rasterised layer instead, so the same visual costs ~nothing. */
+.conn-lamp-busy {
+  position: relative;
+}
+.conn-lamp-busy::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: 50%;
+  pointer-events: none;
+  box-shadow:
+    0 0 9px color-mix(in srgb, var(--success) 95%, transparent),
+    0 0 14px color-mix(in srgb, var(--success) 45%, transparent);
+  will-change: opacity;
+  animation: conn-lamp-busy-pulse 1.8s ease-in-out infinite;
+}
+@keyframes conn-lamp-busy-pulse {
+  0%,
+  100% {
+    opacity: 0.4;
+  }
+  50% {
+    opacity: 1;
+  }
+}
+/* The louder pulse, scoped to the surfaces you deliberately open: the header
+   Machines/VPN menus' rows and the Remote-machines hub's host cards. The dot
+   swells and its halo doubles, so "which of these machines is actually working"
+   is answerable without reading a single label. `transform` + `box-shadow` only,
+   so nothing reflows and a 16-row list stays cheap to animate. */
+.machines-indicator-menu .conn-lamp-busy,
+.vpn-indicator-menu .conn-lamp-busy,
+.remote-machine-card .conn-lamp-busy {
+  animation: conn-lamp-busy-pulse-strong 1.5s ease-in-out infinite;
+  will-change: transform;
+}
+/* The dot scales; its halo (the ::after above) swells and brightens with it. Both
+   keyframe tracks are transform/opacity only — see the note on `.conn-lamp-busy`. */
+.machines-indicator-menu .conn-lamp-busy::after,
+.vpn-indicator-menu .conn-lamp-busy::after,
+.remote-machine-card .conn-lamp-busy::after {
+  box-shadow:
+    0 0 10px var(--success),
+    0 0 18px color-mix(in srgb, var(--success) 55%, transparent);
+  animation: conn-lamp-busy-halo-strong 1.5s ease-in-out infinite;
+}
+@keyframes conn-lamp-busy-halo-strong {
+  0%,
+  100% {
+    opacity: 0.3;
+  }
+  50% {
+    opacity: 1;
+  }
+}
+/* The trough goes well BELOW the resting dot size, not down to it: swinging
+   0.45→1.45 makes the beat read across a long row list from the corner of the
+   eye, where a 1.0→1.45 swell just looks like a slightly bigger dot. The lamp
+   never disappears at the trough — a lamp that blinks out reads as a connection
+   dropping, which is the one thing this must not say. */
+@keyframes conn-lamp-busy-pulse-strong {
+  0%,
+  100% {
+    transform: scale(0.45);
+  }
+  50% {
+    transform: scale(1.45);
+  }
+}
+/* Respect a reduced-motion preference: keep the stronger halo (the busy state is
+   still distinguishable at a glance) but stop the animation. */
+@media (prefers-reduced-motion: reduce) {
+  .conn-lamp-busy,
+  .machines-indicator-menu .conn-lamp-busy,
+  .vpn-indicator-menu .conn-lamp-busy,
+  .remote-machine-card .conn-lamp-busy {
+    animation: none;
+    transform: none;
+  }
+  .conn-lamp-busy::after,
+  .machines-indicator-menu .conn-lamp-busy::after,
+  .vpn-indicator-menu .conn-lamp-busy::after,
+  .remote-machine-card .conn-lamp-busy::after {
+    animation: none;
+    opacity: 1;
+  }
+}
+/* A status lamp aggregated over several hosts: the dot plus a small count of how
+   many hosts share that state (shown only when more than one). */
+.conn-lamp-count {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+}
+.conn-lamp-count-num {
+  font-size: 9px;
+  line-height: 1;
+  font-weight: 600;
+  color: var(--text-secondary);
+  font-variant-numeric: tabular-nums;
+}
+.local-model-default-tag {
+  font-size: 9px;
+  line-height: 1;
+  padding: 2px 5px;
+  border-radius: var(--radius-sm);
+  flex-shrink: 0;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  background: color-mix(in srgb, var(--warning) 22%, transparent);
+  color: var(--warning);
+}
+/* Tag chips sit just under the model name, indented past the lamp. */
+.local-model-roles {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  padding: 0 10px 6px 25px;
+}
+.local-model-role-chip {
+  font-size: 10px;
+  line-height: 1;
+  padding: 3px 7px;
+  border-radius: var(--radius-lg);
+  border: 1px solid var(--control-border);
+  background: var(--control-bg);
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition: background-color var(--transition), border-color var(--transition), color var(--transition);
+}
+.local-model-role-chip:hover {
+  border-color: var(--accent);
+  color: var(--text-primary);
+}
+.local-model-role-chip.on {
+  background: color-mix(in srgb, var(--accent) 24%, transparent);
+  border-color: var(--accent);
+  color: var(--accent);
+  font-weight: 600;
+}
+.local-model-role-chip.local-model-unload {
+  margin-left: auto;
+}
+.local-model-role-chip.local-model-unload:hover {
+  border-color: var(--danger, #e5534b);
+  color: var(--danger, #e5534b);
+}
+.local-model-role-chip.local-model-unload:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+
+/* Installed agent CLIs listed in the brain menu's Agents section: a green
+   "installed" lamp next to the agent label, matching a loaded-model row. */
+.local-model-agent-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 26px;
+  padding: 4px 10px;
+}
+
+/* In-flight downloads shown at the top of the brain menu. */
+.local-model-downloads {
+  padding: 4px 10px 6px;
+  border-bottom: 1px solid var(--control-border);
+  margin-bottom: 2px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.local-model-download-row {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+.local-model-download-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.local-model-download-head {
+  /* Name grows; pct + action buttons hug the right edge. */
+}
+.local-model-download-head .local-model-loaded-name {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.local-model-download-pct {
+  font-size: 11px;
+  color: var(--text-secondary);
+  flex-shrink: 0;
+  font-variant-numeric: tabular-nums;
+}
+/* Pause / Resume / Delete control on a (paused) download row in the brain menu. */
+.local-model-download-action {
+  flex-shrink: 0;
+  background: transparent;
+  border: 1px solid var(--control-border);
+  color: var(--text-secondary);
+  font-size: 10px;
+  padding: 1px 6px;
+  cursor: pointer;
+}
+.local-model-download-action:hover {
+  color: var(--text-primary);
+  border-color: var(--text-secondary);
+}
+.local-model-download-action.danger { color: var(--danger); }
+.local-model-download-action.danger:hover { border-color: var(--danger); }
+
+/* A "load into memory" row in the brain menu: the entry line plus, while the
+   model is warming, an indeterminate bar under it (Ollama streams no load %). */
+.local-model-load-row {
+  display: flex;
+  flex-direction: column;
+}
+/* The entry line itself: a plain (non-button) row, matching .local-model-agent-row,
+   with a trailing Load button — not a full-row button like the resident-model pick. */
+.local-model-load-line {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 26px;
+  padding: 4px 10px;
+}
+.local-model-load-action {
+  margin-left: auto;
+}
+.local-model-load-bar {
+  margin: 2px 12px 4px;
+}
+
+/* ── Install flow (shown when Ollama is missing) ─────────────────────────── */
+.ollama-install-steps {
+  margin: 4px 0 12px;
+  padding-left: 20px;
+  font-size: 12px;
+  color: var(--text-secondary);
+  line-height: 1.5;
+}
+.ollama-install-steps li {
+  margin-bottom: 8px;
+}
+
+.ollama-install-cmd-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 6px 0;
+}
+.ollama-install-cmd {
+  flex: 1;
+  padding: 4px 8px;
+  background: var(--bg-main);
+  border: 1px solid var(--control-border);
+  border-left: 2px solid var(--accent-secondary);
+  font-family: var(--font-mono, monospace);
+  font-size: 11px;
+  /* Terminal command: monospace on the deeper window background with a coloured
+     gutter so it reads as a shell entry, not a button or a heading. */
+  color: var(--text-secondary);
+  overflow-x: auto;
+  white-space: nowrap;
+}
+
+.ollama-pull-input {
+  flex: 1;
+  min-width: 0;
+  padding: 4px 8px;
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  font-family: var(--font-mono, monospace);
+  font-size: 11px;
+  color: var(--text-primary);
+}
+.ollama-pull-input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+.ollama-pull-input:disabled {
+  opacity: 0.5;
+}
+
+.ollama-catalog-controls {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 6px 0;
+}
+.ollama-catalog-sort {
+  padding: 3px 6px;
+  font-size: 11px;
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  color: var(--text-primary);
+  cursor: pointer;
+}
+.ollama-catalog-sort:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+.ollama-sort-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  font-size: 11px;
+  color: var(--text-secondary);
+  white-space: nowrap;
+}
+
+.ollama-filter-row {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 5px;
+  margin: 4px 0;
+}
+.ollama-filter-label {
+  font-size: 11px;
+  color: var(--text-secondary);
+  margin-right: 2px;
+  min-width: 40px;
+}
+.ollama-chip {
+  font-size: 11px;
+  padding: 2px 8px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-lg);
+  background: var(--control-bg);
+  color: var(--text-secondary);
+  cursor: pointer;
+  text-transform: capitalize;
+}
+.ollama-chip:hover {
+  border-color: var(--accent);
+}
+.ollama-chip.active {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--accent-fg, #fff);
+}
+
+.ollama-install-log {
+  margin: 8px 0 12px;
+  max-height: 160px;
+  overflow: auto;
+  padding: 8px;
+  /* Live installer output: same terminal treatment as the command snippet. */
+  background: var(--bg-main);
+  border: 1px solid var(--control-border);
+  border-left: 2px solid var(--accent-secondary);
+  font-family: var(--font-mono, monospace);
+  font-size: 11px;
+  color: var(--text-secondary);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.ollama-action-btn {
+  font-size: 11px;
+  padding: 3px 8px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  white-space: nowrap;
+  line-height: 1.4;
+}
+.ollama-action-btn:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+.ollama-action-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+.ollama-action-btn.danger { color: var(--danger); }
+.ollama-action-btn.danger:hover:not(:disabled) {
+  border-color: var(--danger);
+}
+
+/* Primary call-to-action (Install …). Filled accent so the main action stands
+   apart from the secondary outline buttons (Copy / Re-check / Refresh) sharing
+   this class. */
+.ollama-action-btn.primary {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--bg-main);
+  font-weight: 600;
+}
+.ollama-action-btn.primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+  border-color: var(--accent-hover);
+}
+
+.ollama-model-row {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  padding: 7px 8px;
+  border: 1px solid var(--border-subtle);
+  background: var(--control-bg);
+}
+
+.ollama-model-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.ollama-model-name {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-primary);
+  font-family: ui-monospace, monospace;
+  word-break: break-all;
+}
+
+.ollama-model-size {
+  font-size: 11px;
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+
+.ollama-model-details {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.ollama-download-bar {
+  height: 5px;
+  border-radius: var(--radius-sm);
+  background: var(--border-subtle);
+  overflow: hidden;
+}
+
+.ollama-download-bar-fill {
+  height: 100%;
+  background: var(--accent, var(--text-primary));
+  transition: width var(--transition-slow);
+}
+
+.ollama-download-bar-fill.indeterminate {
+  width: 35%;
+  border-radius: var(--radius-sm);
+  animation: ollama-download-indeterminate 1.1s ease-in-out infinite;
+}
+
+@keyframes ollama-download-indeterminate {
+  0% { margin-left: -35%; }
+  100% { margin-left: 100%; }
+}
+
+.ollama-download-status {
+  font-size: 10px;
+  color: var(--text-muted);
+}
+
+/* Indeterminate "loading into memory" strip under a model row in settings. */
+.ollama-load-progress {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  margin-top: 6px;
+}
+
+.ollama-badge {
+  font-size: 10px;
+  padding: 1px 5px;
+  border: 1px solid var(--border-subtle);
+  color: var(--text-secondary);
+  background: var(--bg-main);
+  font-family: ui-monospace, monospace;
+}
+.ollama-badge.running {
+  border-color: var(--success);
+  color: var(--success);
+}
+.ollama-badge.running.gpu {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+.ollama-model-actions {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+}
+
+.ollama-catalog-row {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  padding: 6px 0;
+  border-bottom: 1px solid var(--border-subtle);
+}
+.ollama-catalog-row:last-child { border-bottom: none; }
+
+.ollama-catalog-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.ollama-catalog-hint {
+  font-size: 11px;
+  color: var(--text-muted);
+  flex-shrink: 0;
+}
+
+.ollama-catalog-desc {
+  font-size: 11px;
+  color: var(--text-secondary);
+  line-height: 1.3;
+}
+
+.ollama-catalog-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 1px;
+}
+
+.ollama-tag-btn {
+  font-size: 10px;
+  padding: 2px 7px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  background: var(--control-bg);
+  color: var(--text-primary);
+  cursor: pointer;
+  font-family: ui-monospace, monospace;
+  line-height: 1.4;
+}
+.ollama-tag-btn:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+.ollama-tag-btn.installed {
+  border-color: var(--success);
+  color: var(--success);
+}
+.ollama-tag-btn:disabled { opacity: 0.6; cursor: default; }
+
+/* ── Activity window (modal) ─────────────────────────────────────────── */
+.activity-window {
+  display: flex;
+  flex-direction: column;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-3);
+  min-width: 320px;
+}
+
+.activity-window-header {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 12px 16px 10px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.activity-window-title {
+  flex: 1;
+  font-size: 14px;
+  font-weight: 650;
+  color: var(--text-primary);
+}
+
+.activity-window-body {
+  padding: 16px 20px 20px;
+}
+
+.activity-loading {
+  font-size: 12px;
+  color: var(--text-muted);
+  padding: 12px 0;
+  text-align: center;
+}
+
+/* Compact reuse of the project-dialog chrome for the pill description editor. */
+.edit-description-window {
+  width: min(440px, calc(100vw - 32px));
+}
+.edit-description-window textarea {
+  width: 100%;
+  min-height: 90px;
+}
+
+/* ── Project-switch toast ──────────────────────────────────────────────── */
+@keyframes toast-fade {
+  0%   { opacity: 0; transform: translate(-50%, calc(-50% - 8px)); }
+  12%  { opacity: 1; transform: translate(-50%, -50%); }
+  72%  { opacity: 1; transform: translate(-50%, -50%); }
+  100% { opacity: 0; transform: translate(-50%, -50%); }
+}
+
+.project-switch-toast {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 500;
+  padding: 10px 20px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-3);
+  font-size: 0.85rem;
+  color: var(--text-secondary);
+  font-family: monospace;
+  pointer-events: none;
+  white-space: nowrap;
+  max-width: calc(100vw - 64px);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  animation: toast-fade 2.2s ease forwards;
+}
+
+/* Remote (SSH) projects show two lines — a local mirror path and the remote
+   user@host:remote_path target. Preserve the newline + label spacing and left-
+   align; single-line local/conn toasts keep their nowrap + ellipsis above. */
+.project-switch-toast.multiline {
+  white-space: pre;
+  text-align: left;
+  line-height: 1.5;
+}
+
+/* The connection toast ("VPN connected · proj") sits just below the switch toast
+   so the two never overlap, and lingers a touch longer (matches its 3.2s clear). */
+.conn-toast {
+  top: calc(50% + 46px);
+  animation: toast-fade 3.2s ease forwards;
+}
+
+/* ── Project-dialog remote step indicator + header connection lamps ────────── */
+.remote-steps {
+  display: flex;
+  gap: 12px;
+  margin: 2px 0 8px;
+  font-size: 11px;
+  letter-spacing: 0.02em;
+  color: var(--text-secondary);
+}
+.remote-step {
+  opacity: 0.55;
+}
+.remote-step.is-active {
+  opacity: 1;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+/* SSH-address label with its lamp inline. Explicit color — this dialog is
+   portaled into <body>, which sets no text color, so without this the plain
+   text child falls back to browser-default black. */
+.remote-field-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  color: var(--text-primary);
+}
+/* A remote project's live SSH lamp, rendered as a button (clicking opens the
+   Connect modal), so reset the native button chrome and keep just the lamp. */
+.header-conn-menu {
+  position: relative;
+  display: inline-flex;
+  margin-left: 6px;
+}
+.header-conn-lamps {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 5px;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  cursor: pointer;
+}
+.header-conn-lamps:hover {
+  background: color-mix(in srgb, var(--text-secondary) 16%, transparent);
+}
+
+/* The machine-wide scope, restated where the user is actually handing over the
+   passphrase — the last moment before the routing changes. */
+.vpn-prompt-scope {
+  display: inline-block;
+  margin-top: 4px;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-secondary);
+}
+
+/* Success banner shown when the tunnel came up — the modal says so and offers Close,
+   instead of just vanishing (which read as "did it actually connect?"). */
+/* Why this prompt is on screen when the connect was meant to be silent (rejected
+   credentials, an unreadable keyring, none saved yet). Informational, not an error —
+   the modal is still perfectly usable, it just owes the user an explanation. */
+.vpn-prompt-reason {
+  margin: 4px 0 2px;
+  padding: 8px 10px;
+  border-radius: 6px;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-secondary);
+  background: var(--bg-hover, color-mix(in srgb, var(--text-primary) 6%, transparent));
+  border: 1px solid var(--border);
+}
+.vpn-prompt-connected {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin: 8px 0 2px;
+  padding: 8px 10px;
+  border-radius: 6px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--success);
+  background: color-mix(in srgb, var(--success) 12%, transparent);
+  border: 1px solid color-mix(in srgb, var(--success) 40%, transparent);
+}
+.vpn-connected-check {
+  font-weight: 700;
+}
+
+/* Auto-connect + VPN: the one combination that changes the machine's routing with
+   no prompt at all, so it gets said out loud rather than buried in a tooltip. */
+.remote-connect-vpn-warning {
+  margin: 2px 0 0;
+  padding: 6px 8px;
+  border-radius: var(--radius-sm);
+  border: 1px solid color-mix(in srgb, var(--warning) 40%, transparent);
+  background: color-mix(in srgb, var(--warning) 10%, transparent);
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-secondary);
+}
+
+/* ── Header VPN indicator (VpnIndicator) ────────────────────────────────────
+   Machine-level, unlike every other VPN surface: it is up whenever a tunnel is,
+   no matter which project is active, because the tunnel reroutes the whole OS.
+   Rides the shared .global-apps-menu / .tab-new-menu chrome so it reads as one
+   of the header menus rather than a bespoke widget. */
+.vpn-indicator-btn,
+.machines-indicator-btn {
+  /* Unlike the other .global-apps-menu-btn siblings, this one reads as a
+     quiet status readout (lamp + label), not a button — so its inherited
+     button box (background/border) is stripped back to plain text/icon.
+     Height stays the shared 32px (matching the brain/local-model button
+     and every other .global-apps-menu-btn) so the header row's icons align
+     and each menu's dropdown (`top: calc(100% + 4px)`) opens at the same
+     screen height. */
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  min-width: 0;
+  height: 32px;
+  padding: 2px 4px;
+  border: none;
+  border-radius: var(--radius-sm);
+  background: transparent;
+}
+
+/* The Local Models anchor lives in `.header-center`, whose children stretch to
+   the full 44px header. VPN and Machines live in the vertically centered right
+   cluster, so their anchors otherwise shrink to the 32px buttons and place the
+   shared `top: calc(100% + 4px)` menu 6px too high. Stretch only these two
+   anchors so all three hover menus begin on the same horizontal line. */
+.header-status-menu-anchor {
+  align-self: stretch;
+}
+.vpn-indicator-btn:hover,
+.vpn-indicator-btn[aria-expanded="true"],
+.machines-indicator-btn:hover,
+.machines-indicator-btn[aria-expanded="true"] {
+  /* Same accent-tinted highlight as .tab-new-btn:hover (the + button), so the
+     header's three "quiet until touched" controls (+, VPN, Machines) all light
+     up the same way instead of these two staying flat while the + brightens. */
+  background: var(--pill-hover-bg);
+  border-color: transparent;
+}
+.vpn-indicator-btn:hover .vpn-indicator-label,
+.vpn-indicator-btn[aria-expanded="true"] .vpn-indicator-label,
+.machines-indicator-btn:hover .vpn-indicator-label,
+.machines-indicator-btn[aria-expanded="true"] .vpn-indicator-label {
+  color: var(--text-primary);
+}
+.vpn-indicator-label {
+  font-size: 9px;
+  line-height: 1;
+  color: var(--text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  transition: color var(--transition);
+}
+/* Title row carries the pinned "OpenVPN" label plus a top-right × (unified with the
+   other menus). The label keeps its accent styling; the row just lays the two out. */
+.vpn-indicator-title {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+.vpn-indicator-close {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: inherit;
+  font-size: 16px;
+  line-height: 1;
+  cursor: pointer;
+  opacity: 0.75;
+  transition: background var(--transition), opacity var(--transition);
+}
+.vpn-indicator-close:hover {
+  opacity: 1;
+  background: color-mix(in srgb, currentColor 18%, transparent);
+}
+.vpn-indicator-menu {
+  width: 268px;
+  color: var(--text-primary);
+  /* Anchored under the 44px header bar (top: calc(100% + 4px)) — with enough
+     rows (many global machines, or many stored .ovpn configs) the menu would
+     otherwise grow past the bottom of the window. It is capped here, but the
+     menu ELEMENT does not scroll: its `.menu-scroll-region` child does, so the
+     accent title stays pinned and the scrollbar starts below the header (the
+     unified scrolling-menu shape — see `.menu-scroll-region`). */
+  max-height: calc(100vh - 72px);
+  overflow: visible;
+}
+.vpn-indicator-note {
+  padding: 6px 10px 8px;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-secondary);
+  border-bottom: 1px solid var(--border, var(--bg-panel));
+}
+.vpn-indicator-row {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 8px 10px;
+}
+.vpn-indicator-row + .vpn-indicator-row {
+  border-top: 1px solid var(--border, var(--bg-panel));
+}
+.vpn-indicator-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+.vpn-indicator-config {
+  font-family: var(--mono-font, monospace);
+  font-size: 12px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.vpn-indicator-holders,
+.vpn-indicator-untracked {
+  font-size: 11px;
+  line-height: 1.4;
+  color: var(--text-secondary);
+}
+.vpn-indicator-disconnect {
+  align-self: flex-start;
+  margin-top: 2px;
+  padding: 3px 9px;
+  border: 1px solid var(--border, var(--text-secondary));
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--danger, var(--text-primary));
+  font-size: 11px;
+  cursor: pointer;
+}
+.vpn-indicator-disconnect:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--danger, var(--text-secondary)) 14%, transparent);
+}
+.vpn-indicator-disconnect:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+/* Connect: the header can bring a tunnel *up*, not just take one down — a VPN is
+   something you use, not only a precondition for an SSH project. */
+.vpn-indicator-connect {
+  align-self: flex-start;
+  margin-top: 2px;
+  padding: 3px 9px;
+  border: 1px solid var(--accent, var(--text-secondary));
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--accent, var(--text-primary));
+  font-size: 11px;
+  cursor: pointer;
+}
+.vpn-indicator-connect:hover {
+  background: color-mix(in srgb, var(--accent, var(--text-secondary)) 14%, transparent);
+}
+/* Connect + Remove share a stored config's row: side by side, not stacked. */
+.vpn-indicator-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 2px;
+}
+.vpn-indicator-actions .vpn-indicator-connect,
+.vpn-indicator-actions .vpn-indicator-remove {
+  margin-top: 0;
+}
+/* Remove: same danger-ghost as Disconnect — both take something away. */
+.vpn-indicator-remove {
+  align-self: flex-start;
+  padding: 3px 9px;
+  border: 1px solid var(--border, var(--text-secondary));
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--danger, var(--text-primary));
+  font-size: 11px;
+  cursor: pointer;
+}
+.vpn-indicator-remove:hover {
+  background: color-mix(in srgb, var(--danger, var(--text-secondary)) 14%, transparent);
+}
+/* "Connect on launch", per config: the machine-level twin of a project's
+   auto-connect. Sits under the row's action button because it is a property of the
+   tunnel, not of this click. */
+.vpn-indicator-auto {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 4px;
+  font-size: 11px;
+  color: var(--text-secondary);
+  cursor: pointer;
+}
+.vpn-indicator-auto:has(input:disabled) {
+  cursor: default;
+  opacity: 0.6;
+}
+/* The Save-password toggle row sits inside a `.menu-form` (the add-machine form),
+   whose `label` rule would otherwise stack it into a column — keep it a row with
+   the switch beside its text, matching every other toggle row. */
+.menu-form .vpn-indicator-auto {
+  flex-direction: row;
+  align-items: center;
+  gap: 6px;
+  font-size: 11px;
+}
+/* The inline retry-password field shares its row with Retry/Cancel buttons — let
+   the password wrap take the remaining width so the field isn't shrunk to nothing. */
+.vpn-indicator-actions .password-input-wrap {
+  flex: 1;
+}
+.vpn-indicator-hint {
+  font-size: 10px;
+  line-height: 1.4;
+  color: var(--text-secondary);
+}
+.vpn-indicator-empty,
+.vpn-indicator-error {
+  padding: 8px 10px;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-secondary);
+}
+.vpn-indicator-error {
+  color: var(--danger, var(--text-primary));
+  word-break: break-word;
+}
+/* The locked-keyring banner: a warning with one action, sitting above the tunnel
+   rows because it explains all of them at once (nothing saved can be read while it
+   is up). Toned like a warning, not an error — nothing is broken, it is just shut. */
+.vpn-indicator-locked {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 6px;
+  margin: 4px 8px 6px;
+  padding: 8px 10px;
+  border-radius: 6px;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-primary);
+  background: color-mix(in srgb, var(--warning, #d08a2c) 12%, transparent);
+  border: 1px solid color-mix(in srgb, var(--warning, #d08a2c) 40%, transparent);
 }
-.split-divider-row {
-  width: 5px;
-  cursor: col-resize;
+
+/* ── Header Machines indicator (MachinesIndicator) ──────────────────────────
+   Rides the same .global-apps-menu / .tab-new-menu / .vpn-indicator-* chrome
+   as VpnIndicator — a global machine list is the same "machine-wide, not
+   project-scoped" shape as the VPN tunnel registry. Only what's genuinely
+   different (the draggable rows, the drop-zone highlight) gets its own class. */
+.machines-indicator-menu {
+  width: 280px;
 }
-.split-divider-column {
-  height: 5px;
-  cursor: row-resize;
+.machines-indicator-row {
+  cursor: grab;
 }
-.split-divider:hover,
-.split-divider:active {
-  background: var(--accent);
+.machines-indicator-row:active {
+  cursor: grabbing;
 }
-
-/* A subwindow: per-group tab bar over its pane region. */
-.subwindow {
+/* Per-row expand toggle: keeps a row to one line (lamp + label + actions) by
+   default, with address/system-monitor/auto-connect behind it — a long machine
+   list stays scannable instead of every row's full detail always being open. */
+.machines-row-expand-btn {
+  margin-left: auto;
+  flex-shrink: 0;
+  width: 18px;
+  height: 18px;
   display: flex;
-  flex-direction: column;
-  overflow: hidden;
-  background-color: var(--bg-main);
-}
-.subwindow.focused {
-  outline: 1px solid var(--accent);
-  outline-offset: -1px;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: none;
+  background: transparent;
+  color: var(--text-secondary);
+  font-size: 10px;
+  line-height: 1;
+  cursor: pointer;
+  border-radius: var(--radius-sm);
 }
-
-.subwindow-body {
-  position: relative;
+.machines-row-expand-btn:hover {
+  color: var(--text-primary);
+  background: color-mix(in srgb, var(--text-secondary) 14%, transparent);
+}
+
+/* A row's steady-state actions are ICONS on the SAME line as the lamp, the label
+   and the ▸ expand toggle: four worded buttons ("Reconnect", "Disconnect",
+   "Edit…", "Remove") wrapped onto two lines in a 280px menu and cost every row a
+   second row of height. The words survive as title/aria-label, so nothing is lost
+   to a hover or a screen reader — and the *armed* confirm states (Remove /
+   Disconnect / Retry / Edit) still replace them with worded buttons below, because
+   a destructive confirm must never be a glyph.
+   The label flexes so a long machine name ellipsizes into the icons rather than
+   pushing them off the row; `margin-left: auto` on the group is what puts the icon
+   cluster + expand toggle hard right (the expand button drops its own auto margin,
+   or the two autos would split the slack and strand it mid-row). */
+.vpn-indicator-head .vpn-indicator-config {
   flex: 1;
-  min-height: 0;
-  overflow: hidden;
+  min-width: 0;
 }
-
-/* Empty measured slot the pane layer positions panes over. */
-.subwindow-pane-slot {
-  position: absolute;
-  inset: 0;
+.machines-row-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  margin-left: auto;
+  flex-shrink: 0;
+}
+/* The expand toggle keeps a slightly wider gap than the icons keep between
+   themselves — it is a different kind of control (it opens the row, it doesn't
+   act on the machine), so it reads as its own thing rather than a fifth action. */
+.machines-row-actions + .machines-row-expand-btn {
+  margin-left: 2px;
 }
 
-/* Pane layer holds all PTYs (every scope), positioned over group bodies. The
-   wrapper is click-through; individual panes re-enable pointer events. While a
-   tab is being dragged the whole layer goes click-through so hit-testing falls
-   to the drop zones rendered in the subwindow bodies beneath. */
-.pane-layer {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-  z-index: 2;
+.machines-row-action {
+  flex-shrink: 0;
+  width: 20px;
+  height: 20px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  border: 1px solid var(--border, var(--text-secondary));
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-secondary);
+  font-size: 12px;
+  line-height: 1;
+  cursor: pointer;
 }
-/* During a tab drag, panes go click-through so elementFromPoint can reach the
-   tab bars / subwindow bodies underneath for the hit-test. */
-.center-panel.dragging .pane-layer,
-.center-panel.dragging .center-pane {
-  pointer-events: none;
+.machines-row-action:hover {
+  color: var(--text-primary);
+  background: color-mix(in srgb, var(--text-secondary) 14%, transparent);
 }
-
-/* Each pane is absolutely positioned by CenterPanel to a group's body rect.
-   Hidden panes keep their PTY mounted via display:none. */
-.center-pane {
-  position: absolute;
-  flex-direction: column;
-  overflow: hidden;
-  pointer-events: auto;
+.machines-row-action:disabled {
+  opacity: 0.5;
+  cursor: default;
 }
-
-/* ── Split preview (shown while a tab is being dragged over a subwindow) ──── */
-/* CenterPanel's hit-test sets the hovered group's edge; CenterPanel renders this
-   overlay (NOT the subwindow — it must paint above the pane layer) at the half
-   (or whole, for center) the drop would carve out, in panel-relative px. z-index
-   sits above the pane layer (z-index:2) so the opaque terminal doesn't hide it.
-   A plain rgba fill is used over color-mix (which doesn't render reliably on this
-   WebKitGTK build) so the darkening is always visible. The left/top/width/height
-   transition makes the preview glide as the targeted edge changes. */
-.split-preview {
-  position: absolute;
-  z-index: 5;
-  pointer-events: none;
-  background: rgba(0, 0, 0, 0.28);
-  outline: 2px solid var(--accent);
-  outline-offset: -2px;
-  transition: left 0.12s ease, top 0.12s ease, width 0.12s ease, height 0.12s ease;
+.machines-row-action.is-accent {
+  border-color: var(--accent, var(--text-secondary));
+  color: var(--accent, var(--text-primary));
 }
-
-/* Floating label following the pointer during a tab drag. */
-.tab-drag-ghost {
-  position: fixed;
-  z-index: 9999;
-  transform: translate(8px, 8px);
-  pointer-events: none;
-  display: flex;
-  flex-direction: column;
-  align-items: flex-start;
-  gap: 4px;
+.machines-row-action.is-accent:hover:not(:disabled) {
+  background: color-mix(in srgb, var(--accent, var(--text-secondary)) 14%, transparent);
+}
+.machines-row-action.is-danger {
+  color: var(--danger, var(--text-primary));
+}
+.machines-row-action.is-danger:hover:not(:disabled) {
+  color: var(--danger, var(--text-primary));
+  background: color-mix(in srgb, var(--danger, var(--text-secondary)) 14%, transparent);
 }
 
-.tab-drag-ghost-label {
-  padding: 4px 10px;
+/* Reorder grip: the ONLY part of a machine row that starts a drag, so every
+   button beside it stays clickable. Pointer-driven (see MachinesIndicator) —
+   `touch-action: none` is what stops the menu from scrolling instead of
+   dragging, and `cursor: grab` is the whole affordance. */
+.machines-row-grip {
+  flex-shrink: 0;
+  width: 14px;
+  height: 20px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  margin-right: 2px;
+  border: none;
+  background: transparent;
+  color: var(--text-secondary);
   font-size: 12px;
-  background: var(--control-hover-bg);
-  border: 1px solid var(--accent);
+  line-height: 1;
+  opacity: 0.5;
+  cursor: grab;
+  touch-action: none;
+}
+.machines-row-grip:hover,
+.machines-row-grip:focus-visible {
+  opacity: 1;
   color: var(--text-primary);
-  white-space: nowrap;
-  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.4);
 }
-
-/* Hint shown under the label during a file drag: reminds the user that holding
-   Alt switches to a native drag that can be dropped into an embedded browser. */
-.tab-drag-ghost-hint {
-  padding: 2px 8px;
-  font-size: 10px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-subtle, var(--accent));
-  color: var(--text-secondary, var(--text-primary));
-  white-space: nowrap;
-  opacity: 0.85;
+.machines-row-grip:active {
+  cursor: grabbing;
 }
 
-/* Scaled clone of the dragged tab's pane. The clone inside is transform-scaled
-   to GHOST_THUMB_W (see DragGhost); this box clips it to the thumbnail size. */
-.tab-drag-ghost-thumb {
+/* The row being dragged: it follows the cursor (an inline translateY set by
+   MachinesIndicator) as a dimmed copy, while the list under it holds still and
+   only the insertion marker below moves — so the rects measured at pointerdown
+   stay valid for the whole gesture. */
+.machines-indicator-row.reorder-dragging {
+  opacity: 0.55;
   position: relative;
-  overflow: hidden;
-  background: var(--bg-panel);
-  border: 1px solid var(--accent);
-  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.4);
-  opacity: 0.9;
+  z-index: 2;
+  background: color-mix(in srgb, var(--accent, var(--text-secondary)) 12%, transparent);
+  border-radius: var(--radius-sm);
 }
 
-/* One-shot send-off when a tab/subwindow is dropped OUT to its own OS window
-   (see DetachFlourish / stores/detachAnim). A card at the exit point lifts,
-   scales, and slides toward the edge the content left through, then fades —
-   reading as the content being ejected into its own window. The fly direction
-   comes from CSS custom props set per play (--fly-dx / --fly-dy). */
-.tab-detach-flourish {
-  position: fixed;
-  z-index: 9998; /* just under the live drag ghost (.tab-drag-ghost: 9999) */
-  pointer-events: none;
-  display: flex;
-  align-items: flex-start;
-  background: var(--bg-panel);
-  border: 1px solid var(--accent);
-  box-shadow: 0 8px 28px rgba(0, 0, 0, 0.45), 0 0 0 1px var(--accent) inset;
-  overflow: hidden;
-  transform-origin: center center;
-  will-change: transform, opacity;
-  animation: tab-detach-fly 0.42s cubic-bezier(0.2, 0.7, 0.3, 1) forwards;
+/* The rows the dragged one is NOT: they slide aside to open its landing slot
+   (the translate is set inline by MachinesIndicator). Only the transition lives
+   here — it is what makes the list *part* rather than jump, and it is scoped to
+   the drag so an ordinary row never animates. */
+.machines-indicator-row.reorder-parting {
+  transition: transform 140ms ease;
 }
 
-.tab-detach-flourish-label {
-  padding: 4px 10px;
-  font-size: 12px;
-  background: var(--control-hover-bg);
-  border-bottom: 1px solid var(--accent);
-  color: var(--text-primary);
-  white-space: nowrap;
-  max-width: 100%;
-  overflow: hidden;
-  text-overflow: ellipsis;
+/* The row's "add this machine to a project" picker: one button per open
+   project, each naming which of the two ways the machine would join it. It
+   replaced the drag-onto-a-pill gesture, so it deliberately spells out the
+   outcome the drop could only imply. */
+.machines-attach-form .machines-attach-project {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
+  width: 100%;
+  text-align: left;
 }
-
-/* A pulse ring that expands out of the card to punctuate the launch. */
-.tab-detach-flourish::after {
-  content: "";
-  position: absolute;
-  inset: 0;
-  border: 2px solid var(--accent);
-  opacity: 0.6;
-  animation: tab-detach-ring 0.42s ease-out forwards;
+.machines-attach-kind {
+  color: var(--text-secondary);
+  font-size: 11px;
+  flex-shrink: 0;
 }
 
-@keyframes tab-detach-fly {
-  0% {
-    transform: translate(-50%, -50%) scale(1);
-    opacity: 0.96;
-  }
-  32% {
-    transform: translate(-50%, -50%) scale(1.06);
-    opacity: 0.92;
-  }
-  100% {
-    transform: translate(calc(-50% + var(--fly-dx, 0px)), calc(-50% + var(--fly-dy, -64px)))
-      scale(0.42);
-    opacity: 0;
-  }
+/* The expanded row's "System monitor…" button (opens
+   `GlobalMachineMonitorDialog`) — a full-width action, same button chrome as
+   the row's Connect/Disconnect/Remove actions, just left-aligned rather than
+   in the actions row. */
+.machines-monitor-btn {
+  margin-top: 2px;
+  align-self: flex-start;
 }
 
-@keyframes tab-detach-ring {
-  0% {
-    transform: scale(1);
-    opacity: 0.6;
-  }
-  100% {
-    transform: scale(1.35);
-    opacity: 0;
-  }
+/* ── Machines import / export panels (MachinesIndicator) ─────────────────────
+   Both reuse the .menu-form / .vpn-indicator-* chrome; these only add the bits
+   the flows need — a scrollable pick/preview list and a muted address line. */
+.machines-io-buttons {
+  display: flex;
+  flex-direction: row;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
 }
-
-/* Respect reduced-motion: collapse the launch to a simple fade, no slide/zoom. */
-@media (prefers-reduced-motion: reduce) {
-  .tab-detach-flourish {
-    animation: tab-detach-fade 0.25s ease-out forwards;
-  }
-  .tab-detach-flourish::after {
-    animation: none;
-    opacity: 0;
-  }
-  @keyframes tab-detach-fade {
-    0% {
-      transform: translate(-50%, -50%);
-      opacity: 0.9;
-    }
-    100% {
-      transform: translate(-50%, -50%);
-      opacity: 0;
-    }
-  }
+/* The row's buttons already carry `align-self: flex-start` for the column
+   layout — reset it so they sit centered on this one shared row. */
+.machines-io-buttons .vpn-indicator-connect {
+  align-self: auto;
+  margin-top: 0;
 }
-
-/* ── Right panel overlay ──────────────────────────────────────────────── */
-.right-panel {
+/* Fleet-wide actions (Retry all / Disconnect all): one shared row above the
+   machine list, separated from the note by a hairline so it reads as an action
+   bar, not part of the prose. The button row itself is `.vpn-indicator-actions`
+   (row flex) — the confirm variant stacks a hint above it, so this wrapper keeps
+   its own default direction and only owns the separator. */
+.machines-fleet-actions {
+  flex-wrap: wrap;
+  padding-top: 8px;
+  border-top: 1px solid var(--border-subtle, rgba(128, 128, 128, 0.25));
+}
+.machines-fleet-actions .vpn-indicator-connect,
+.machines-fleet-actions .vpn-indicator-remove {
+  align-self: auto;
+  margin-top: 0;
+}
+/* The icon bar is a ROW. It has to say so itself: `.vpn-indicator-row` sets
+   `flex-direction: column` and `.vpn-indicator-actions` only ever set
+   display/gap, never a direction — so the column wins on every element carrying
+   both, and the icons would stack. The confirm variant keeps the column (its
+   hint sits above its buttons), which is why this is its own class rather than
+   a rule on `.machines-fleet-actions`. */
+.machines-fleet-icons {
+  flex-direction: row;
+  align-items: center;
+  /* Centred, because this bar is not a cluster hanging off a machine's name —
+     it acts on the whole list, so it belongs to the menu's width rather than to
+     either edge. */
+  justify-content: center;
+  position: relative;
+}
+/* The untested tag is taken OUT of the centring flow: as an ordinary flex item
+   it would count toward the centred group's width and shove the icons left of
+   the true centre by half the tag. Absolute + `position: relative` above pins it
+   to the right edge and leaves the three icons centred on the menu. */
+.machines-fleet-icons .untested-tag {
   position: absolute;
-  top: 0;
-  right: 0;
-  bottom: 0;
-  width: 280px;
-  background-color: var(--bg-panel);
-  border-left: 1px solid var(--border-color);
+  right: 10px;
+  top: 50%;
+  transform: translateY(-50%);
+}
+/* The fleet bar's own controls are icons in the row vocabulary (↻ / ⏻ / ▥), so
+   they reuse `.machines-row-action` — only slightly larger, since here they are
+   the row rather than a cluster hanging off the end of one. */
+.machines-fleet-actions .machines-row-action {
+  width: 24px;
+  height: 24px;
+  font-size: 13px;
+}
+/* Deliberately NOT its own scroll container. It used to be (`max-height: 320px;
+   overflow-y: auto`) and that cost twice: a second scrollbar nested inside the
+   menu's own — and one the tinted-track rule above doesn't reach, since that
+   targets `.tab-new-menu` itself, not its descendants, so it fell back to the
+   flat `--bg-panel` track and read as a mismatched stripe — plus, being a
+   `flex-shrink: 1` child of a height-capped column, it squeezed the imported-
+   machine list (`.machines-io-preview`) down to almost nothing. The menu
+   (`.vpn-indicator-menu`, capped at the viewport) already scrolls, so letting
+   this grow gives the panel ONE correctly-themed scrollbar. */
+.machines-io-panel {
+  min-height: 0;
+}
+/* One selectable machine in the export list: the toggle + label, with the host
+   address as a muted mono sub-line under the display name. */
+.machines-io-pick {
+  align-items: center;
+}
+/* The select-all/none row sits above the list and is separated from it — it
+   picks the rows rather than being one of them. */
+.machines-io-pick-all {
+  border-bottom: 1px solid var(--border, var(--bg-panel));
+  padding-bottom: 6px;
+  margin-bottom: 2px;
+  font-weight: 600;
+}
+.machines-io-addr {
+  display: block;
+  font-family: var(--mono-font, monospace);
+  font-size: 10px;
+  color: var(--text-secondary);
+  word-break: break-all;
+}
+/* The read-back list of machines an import found / added. `flex-shrink: 0` is
+   load-bearing: as a flex child of the column panel it would otherwise be
+   squeezed to a sliver whenever the panel ran short of room, which is exactly
+   what hid the imported machines. Its own scrollbar gets the inset track it
+   actually sits on, so it matches the menu's rather than falling back to the
+   flat `--bg-panel` one. */
+.machines-io-preview,
+.machines-io-results {
   display: flex;
   flex-direction: column;
-  transform: translateX(calc(100% + 2px));
-  transition: transform 0.2s ease;
-  z-index: 10;
+  gap: 3px;
+  flex-shrink: 0;
+  min-height: 60px;
+  max-height: 160px;
+  overflow-y: auto;
+  padding: 4px 6px;
+  border-radius: 4px;
+  background: var(--bg-inset, var(--border, rgba(128, 128, 128, 0.15)));
+  scrollbar-color: var(--scrollbar-thumb)
+    var(--bg-inset, var(--border, rgba(128, 128, 128, 0.15)));
 }
-
-.right-panel:not(.open) {
-  transform: translateX(calc(100% + 2px));
-  border-left-color: transparent;
+.machines-io-preview::-webkit-scrollbar-track,
+.machines-io-results::-webkit-scrollbar-track {
+  background: var(--bg-inset, var(--border, rgba(128, 128, 128, 0.15)));
 }
-
-.right-panel.open {
-  transform: translateX(0);
+.machines-io-preview::-webkit-scrollbar-thumb,
+.machines-io-results::-webkit-scrollbar-thumb {
+  background-color: var(--scrollbar-thumb);
+  border-color: var(--bg-inset, var(--border, rgba(128, 128, 128, 0.15)));
+}
+.machines-io-result-row {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 11px;
 }
 
-.right-panel-scroll,
-.file-browser-main,
-.file-browser-sidebar,
-.project-search-popover,
-.settings-dialog {
-  scrollbar-color: var(--border-color) var(--bg-panel);
-  scrollbar-width: thin;
+/* Compact variant: the lamp embedded on a project pill instead of the header,
+   so every remote project's connection state is visible in the project bar at a
+   glance (not just the active one). */
+.header-conn-menu-compact {
+  margin-left: 0;
+  margin-right: 2px;
+}
+.header-conn-menu-compact .header-conn-lamps {
+  padding: 2px;
 }
 
-/* "Set default app" dialog (right-panel file context menu) */
-.set-default-app-dialog {
-  width: 460px;
-  max-width: 90vw;
+/* ── Connect modal (RemoteConnectDialog) ────────────────────────────────────
+   Connect-only sibling of the new-project SSH section; reuses the shared
+   .remote-reconnect-section / .dialog-connect* / .connection-log styles. */
+.remote-connect-dialog {
+  width: min(560px, 92vw);
 }
-.set-default-app-scope {
-  display: flex;
-  gap: 16px;
-  margin: 6px 0;
+.remote-connect-target {
+  margin: 2px 0 10px;
+  font-family: var(--mono-font, monospace);
   font-size: 12px;
+  color: var(--text-secondary);
+  word-break: break-all;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
 }
-.set-default-app-scope label {
+/* One row per location (Remote / Local): fixed-width label + path. */
+.remote-connect-location {
   display: flex;
-  align-items: center;
-  gap: 5px;
-  cursor: pointer;
+  gap: 8px;
+  align-items: baseline;
 }
-.set-default-app-scope label.disabled {
-  opacity: 0.5;
-  cursor: not-allowed;
+.remote-connect-location-label {
+  flex: 0 0 auto;
+  min-width: 44px;
+  font-family: var(--body-font, sans-serif);
+  font-size: 10px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-tertiary, var(--text-secondary));
 }
-.set-default-app-search,
-.set-default-app-manual input {
-  width: 100%;
-  box-sizing: border-box;
+.remote-connect-location-path {
+  flex: 1 1 auto;
+  word-break: break-all;
+}
+/* Headless password row: label + input + Connect button stacked in the section. */
+.remote-connect-field {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
   font-size: 12px;
-  background: var(--bg-panel);
-  color: var(--text-primary);
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
-  padding: 4px 6px;
+  color: var(--text-secondary);
 }
-.set-default-app-list {
-  margin: 6px 0;
-  max-height: 220px;
-  overflow-y: auto;
-  border: 1px solid var(--border-color);
-  border-radius: 3px;
+.remote-connect-field input {
+  width: 100%;
 }
-.set-default-app-row {
+/* Opt-in "Save password" row under a Connect-modal password field. */
+.remote-connect-remember {
   display: flex;
-  justify-content: space-between;
-  align-items: baseline;
-  gap: 10px;
-  width: 100%;
-  text-align: left;
-  background: transparent;
-  border: none;
-  color: var(--text-primary);
-  padding: 4px 8px;
-  cursor: pointer;
+  align-items: center;
+  gap: 6px;
   font-size: 12px;
+  color: var(--text-secondary);
+  cursor: pointer;
 }
-.set-default-app-row:hover {
-  background: var(--bg-panel);
+.remote-connect-remember input {
+  width: auto;
+  margin: 0;
 }
-.set-default-app-row.selected {
-  background: var(--accent);
-  color: #fff;
+
+/* ── Onboarding: empty-state card, "How to start" dialog, contextual hints ── */
+
+.center-placeholder-card {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 6px;
+  text-align: center;
+  max-width: 360px;
+  padding: 0 16px;
 }
-.set-default-app-row.selected .set-default-app-exec {
-  color: rgba(255, 255, 255, 0.8);
+
+/* Section divider inside the Connect modal (SSH / OpenVPN groups). */
+.remote-reconnect-section {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-top: 10px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border-color);
 }
-.set-default-app-name {
-  flex: 1;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+
+.center-placeholder-title {
+  color: var(--text-primary);
+  font-size: 14px;
+  font-weight: 600;
 }
-.set-default-app-exec {
+
+.center-placeholder-hint {
   color: var(--text-muted);
-  font-size: 11px;
-  flex-shrink: 0;
-  max-width: 45%;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  font-size: 12px;
+  line-height: 1.5;
 }
-.set-default-app-manual {
-  display: flex;
-  gap: 6px;
-  margin-top: 4px;
+
+.center-placeholder-key {
+  display: inline-block;
+  min-width: 16px;
+  padding: 0 5px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  font-weight: 600;
 }
-.set-default-app-manual button {
-  flex-shrink: 0;
+
+/* "How to start" reuses .modal-backdrop + .settings-dialog; just the step list. */
+.how-to-start-steps {
+  list-style: none;
+  margin: 8px 0 4px;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
 }
-.set-default-app-actions {
+
+.how-to-start-step {
   display: flex;
-  justify-content: flex-end;
-  gap: 8px;
-  margin-top: 12px;
+  gap: 12px;
+  align-items: flex-start;
 }
 
-.right-panel-scroll::-webkit-scrollbar,
-.file-browser-main::-webkit-scrollbar,
-.file-browser-sidebar::-webkit-scrollbar,
-.project-search-popover::-webkit-scrollbar,
-.settings-dialog::-webkit-scrollbar {
-  width: 7px;
-  height: 7px;
+.how-to-start-num {
+  flex: 0 0 auto;
+  width: 22px;
+  height: 22px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: var(--accent-contrast);
+  font-size: 12px;
+  font-weight: 700;
+  display: flex;
+  align-items: center;
+  justify-content: center;
 }
 
-.right-panel-scroll::-webkit-scrollbar-track,
-.file-browser-main::-webkit-scrollbar-track,
-.file-browser-sidebar::-webkit-scrollbar-track,
-.project-search-popover::-webkit-scrollbar-track,
-.settings-dialog::-webkit-scrollbar-track {
-  background: var(--bg-panel);
+.how-to-start-step-title {
+  color: var(--text-primary);
+  font-weight: 600;
+  margin-bottom: 2px;
 }
 
-.right-panel-scroll::-webkit-scrollbar-thumb,
-.file-browser-main::-webkit-scrollbar-thumb,
-.file-browser-sidebar::-webkit-scrollbar-thumb,
-.project-search-popover::-webkit-scrollbar-thumb,
-.settings-dialog::-webkit-scrollbar-thumb {
-  background-color: var(--border-color);
-  border: 1px solid var(--bg-panel);
-  border-radius: 0;
+.how-to-start-got-it {
+  margin-left: auto;
+  border-color: var(--accent) !important;
 }
 
-.right-panel-scroll::-webkit-scrollbar-thumb:hover,
-.file-browser-main::-webkit-scrollbar-thumb:hover,
-.file-browser-sidebar::-webkit-scrollbar-thumb:hover,
-.project-search-popover::-webkit-scrollbar-thumb:hover,
-.settings-dialog::-webkit-scrollbar-thumb:hover {
-  background-color: var(--accent);
+/* Contextual hint coachmark/banner. z-index 90: above the header (80) so it can
+   point at chrome, but below true modals (.modal-backdrop, 100) so a dialog is
+   never pierced by a stray hint. Portaled to body (see HintBubble). */
+.hint-bubble {
+  position: fixed;
+  z-index: 90;
+  padding: 10px 12px;
+  border-radius: var(--radius);
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-color);
+  box-shadow: var(--shadow-3);
+  color: var(--text-primary);
+  font-size: 12px;
+  /* Fade in on appearance, then keep a slow accent breathing on the border so a
+     freshly-surfaced hint draws the eye without nagging. Opacity-only entry so it
+     never fights the inline/class positioning transforms (translateY/translateX).
+     Shares the pulse vocabulary of tab-working-pulse / right-panel-drop-pulse. */
+  animation: hint-bubble-in 0.24s ease-out,
+    hint-bubble-breathe 2.4s ease-in-out 0.24s infinite;
 }
 
-.right-panel-scroll::-webkit-scrollbar-corner,
-.file-browser-main::-webkit-scrollbar-corner,
-.file-browser-sidebar::-webkit-scrollbar-corner,
-.project-search-popover::-webkit-scrollbar-corner,
-.settings-dialog::-webkit-scrollbar-corner {
-  background: var(--bg-panel);
+@keyframes hint-bubble-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
 }
 
-.right-panel-header {
-  display: flex;
-  align-items: center;
-  padding: 8px 12px;
-  border-bottom: 1px solid var(--border-subtle);
-  font-size: 11px;
-  font-weight: 600;
-  color: var(--text-secondary);
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
+@keyframes hint-bubble-breathe {
+  0%,
+  100% {
+    border-color: var(--border-color);
+    box-shadow: var(--shadow-3);
+  }
+  50% {
+    border-color: var(--accent);
+    box-shadow: 0 6px 24px rgba(0, 0, 0, 0.45),
+      0 0 0 3px color-mix(in srgb, var(--accent) 22%, transparent);
+  }
 }
 
-.right-panel-pin {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  width: 24px;
-  height: 24px;
-  margin-right: 8px;
-  padding: 0;
-  font-size: 13px;
-  line-height: 1;
-  border: 1px solid var(--border-subtle);
-  border-radius: 6px;
-  background: var(--bg-elevated, rgba(255, 255, 255, 0.04));
-  color: var(--text-secondary);
-  cursor: pointer;
-  filter: grayscale(1) opacity(0.6);
-  transition: filter 0.12s ease, background 0.12s ease, border-color 0.12s ease;
+/* The chrome a hint points at (the + button, etc.): a pulsing accent fill + inset
+   ring so the eye lands on the thing to click, not just the bubble. HintHost
+   toggles this class on the anchored element while its hint is on screen. The
+   effect is kept *inside* the element bounds (inset ring, no outward glow) so it
+   survives an overflow:hidden ancestor like the .tab-bar that clips the + button. */
+.hint-target {
+  animation: hint-target-pulse 1.4s ease-in-out infinite;
 }
 
-.right-panel-pin:hover {
-  filter: grayscale(0) opacity(1);
-  border-color: var(--accent, #58a6ff);
+@keyframes hint-target-pulse {
+  0%,
+  100% {
+    background: color-mix(in srgb, var(--accent) 0%, transparent);
+    box-shadow: inset 0 0 0 0 color-mix(in srgb, var(--accent) 0%, transparent);
+  }
+  50% {
+    background: color-mix(in srgb, var(--accent) 24%, transparent);
+    box-shadow: inset 0 0 0 1.5px var(--accent);
+  }
 }
 
-.right-panel-pin.pinned {
-  filter: none;
-  background: var(--accent, #58a6ff);
-  border-color: var(--accent, #58a6ff);
-  box-shadow: 0 0 0 1px var(--accent, #58a6ff);
+.hint-bubble--banner {
+  left: 50%;
+  top: 16px;
+  transform: translateX(-50%);
+  width: min(420px, calc(100vw - 32px));
+  /* Banners have no anchor element to pulse, so the bubble itself breathes with a
+     gentle scale alongside the shared border glow. The transform-animating
+     keyframes must carry the centering translateX(-50%); the entry runs first and
+     the scale pulse starts when it ends (matched delay), so they never overlap on
+     the transform property. */
+  animation: hint-banner-in 0.24s ease-out,
+    hint-bubble-breathe 2.4s ease-in-out 0.24s infinite,
+    hint-banner-pulse 1.8s ease-in-out 0.24s infinite;
+}
+
+@keyframes hint-banner-in {
+  from {
+    opacity: 0;
+    transform: translateX(-50%) translateY(-8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(-50%) translateY(0);
+  }
 }
 
-.right-panel-sort {
-  display: flex;
-  align-items: center;
-  gap: 1px;
-  padding: 2px 6px;
-  border-bottom: 1px solid var(--border-subtle);
-  flex-shrink: 0;
+@keyframes hint-banner-pulse {
+  0%,
+  100% {
+    transform: translateX(-50%) scale(1);
+  }
+  50% {
+    transform: translateX(-50%) scale(1.03);
+  }
 }
 
-.sort-key-btn {
-  background: none;
+@media (prefers-reduced-motion: reduce) {
+  .hint-bubble,
+  .hint-bubble--banner,
+  .hint-target {
+    animation: none;
+  }
+}
+
+.hint-bubble-close {
+  position: absolute;
+  top: 4px;
+  right: 6px;
   border: none;
-  cursor: pointer;
-  font-size: 10px;
+  background: transparent;
   color: var(--text-muted);
-  padding: 2px 5px;
-  border-radius: 3px;
-  text-transform: uppercase;
-  letter-spacing: 0.3px;
-  font-family: inherit;
-  white-space: nowrap;
+  font-size: 15px;
+  line-height: 1;
+  cursor: pointer;
 }
 
-.sort-key-btn:hover {
-  color: var(--text-secondary);
-  background: var(--pill-hover-bg);
+.hint-bubble-close:hover {
+  color: var(--text-primary);
 }
 
-.sort-key-btn.active {
-  color: var(--accent, #58a6ff);
-  font-weight: 700;
+.hint-bubble-title {
+  font-weight: 600;
+  margin: 0 16px 4px 0;
 }
 
-/* ── Git action buttons ──────────────────────────────────────────────── */
-.git-action-bar {
+.hint-bubble-body {
+  color: var(--text-secondary);
+  line-height: 1.45;
+}
+
+.hint-bubble-actions {
   display: flex;
-  gap: 3px;
-  padding: 4px 6px;
-  border-bottom: 1px solid var(--border-color);
+  align-items: center;
+  gap: 10px;
+  margin-top: 10px;
 }
 
-.git-action-btn {
+.hint-bubble-link {
+  border: none;
   background: transparent;
-  border: 1px solid var(--accent);
-  color: var(--accent);
-  border-radius: 4px;
+  color: var(--text-muted);
+  font-size: 11px;
   cursor: pointer;
-  padding: 3px 7px;
-  font-size: 14px;
-  display: inline-flex;
-  align-items: center;
-  gap: 3px;
-  font-family: inherit;
-  transition: background 0.12s, color 0.12s, border-color 0.12s;
-  white-space: nowrap;
-  flex: 1;
-  justify-content: center;
+  padding: 0;
 }
 
-.git-action-btn:hover {
-  background: var(--pill-active-bg);
-  color: var(--accent-hover);
-  border-color: var(--accent-hover);
+.hint-bubble-link:hover {
+  color: var(--text-primary);
+  text-decoration: underline;
 }
 
-.git-action-btn:disabled {
-  opacity: 0.3;
-  cursor: not-allowed;
+.hint-bubble-got-it {
+  margin-left: auto;
+  border: 1px solid var(--accent);
+  border-radius: var(--radius-sm);
+  background: var(--accent);
+  color: var(--accent-contrast);
+  font-size: 11px;
+  padding: 4px 12px;
+  cursor: pointer;
 }
 
-.git-btn-label {
-  display: none;
-  font-size: 10px;
-  line-height: 1;
+.hint-bubble-got-it:hover {
+  background: var(--accent-hover, var(--accent));
 }
 
-.git-action-btn:hover .git-btn-label {
-  display: inline;
+/* The element a coachmark points at gets this class while the hint is shown, so
+   the eye lands on the thing to click (see HintHost). */
+.hint-target {
+  animation: hint-target-pulse 1.6s ease-in-out infinite;
+  border-radius: var(--radius);
 }
 
-.git-hover-list {
-  position: absolute;
-  top: 100%;
-  left: 0;
-  right: 0;
-  z-index: 200;
-  background: var(--bg-panel, #1e1e1e);
-  border: 1px solid var(--border-color);
-  border-top: none;
-  max-height: 160px;
-  overflow-y: auto;
-  font-size: 10px;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+@keyframes hint-target-pulse {
+  0%,
+  100% {
+    box-shadow: 0 0 0 0 color-mix(in srgb, var(--accent) 65%, transparent);
+  }
+  50% {
+    box-shadow: 0 0 0 4px color-mix(in srgb, var(--accent) 0%, transparent);
+  }
 }
 
-.git-hover-item {
-  padding: 2px 8px;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  color: var(--text-primary);
-}
+/* ── Guided tour ("Take a tour") ──────────────────────────────────────────── */
 
-/* ── Git history view ────────────────────────────────────────────────── */
-.git-history {
-  display: flex;
-  flex-direction: column;
-  font-size: 11px;
+/* Invisible anchor at the right-edge reveal band; gives the file-tree tour step
+   a stable element to spotlight without affecting layout or hit-testing. */
+.tour-edge-marker {
+  position: fixed;
+  top: 50%;
+  right: 0;
+  width: 6px;
+  height: 120px;
+  transform: translateY(-50%);
+  pointer-events: none;
 }
 
-.git-history-toolbar {
+/* Click affordance to open the closed, unpinned right file panel. The hover-only
+   right-edge reveal isn't reliable under WebView2 on Windows — the OS resize
+   border eats mousemove in the last few edge pixels, so the reveal band never
+   fires and the in-panel pin can't be reached. This tab sits just inside that
+   dead-zone and opens the panel on click (delivered even where mousemove isn't).
+   Unmounts as soon as the panel is open, so it never overlaps the panel. */
+.right-panel-reveal-handle {
+  position: fixed;
+  top: 50%;
+  right: 0;
+  transform: translateY(-50%);
+  width: 16px;
+  height: 72px;
   display: flex;
   align-items: center;
-  gap: 6px;
-  padding: 4px 6px;
-  border-bottom: 1px solid var(--border-color);
+  justify-content: center;
+  padding: 0;
+  border: 1px solid var(--border-color);
+  border-right: none;
+  border-radius: var(--radius) 0 0 var(--radius);
+  background-color: var(--bg-panel);
+  color: var(--text-muted);
+  font-size: 13px;
+  line-height: 1;
+  cursor: pointer;
+  opacity: 0.55;
+  z-index: 11;
+  transition: opacity var(--transition), color var(--transition), background-color var(--transition);
 }
 
-.git-history-branch {
-  flex: 1;
-  font-weight: 600;
+.right-panel-reveal-handle:hover {
+  opacity: 1;
   color: var(--text-primary);
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
+  background-color: var(--bg-hover, var(--bg-panel));
 }
 
-.git-history-mode {
-  font-size: 10px;
-  padding: 1px 6px;
-  white-space: nowrap;
+/* Mirror the reveal handle and tour marker to the left edge when the panel
+   docks there (open edge, border, and rounded corners all flip). */
+.right-panel-reveal-handle.left {
+  right: auto;
+  left: 0;
+  border-left: none;
+  border-right: 1px solid var(--border-color);
+  border-radius: 0 var(--radius) var(--radius) 0;
 }
 
-.git-branch-list {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 3px;
-  padding: 4px 6px;
-  border-bottom: 1px solid var(--border-color);
+.tour-edge-marker.left {
+  right: auto;
+  left: 0;
 }
 
-.git-branch-pill {
-  background: transparent;
-  border: 1px solid var(--border-color);
-  color: var(--text-primary);
-  border-radius: 10px;
-  padding: 1px 8px;
-  font-size: 10px;
-  cursor: pointer;
-  font-family: inherit;
-  white-space: nowrap;
+/* Full-screen layer hosting the blocker, spotlight, and bubble. Above the hint
+   bubble (z 90) and most chrome; portaled to document.body. */
+.tour-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 200;
 }
 
-.git-branch-pill:hover:not(:disabled) {
-  border-color: var(--accent);
-  color: var(--accent-hover);
+/* Transparent click-catcher: makes the tour narrated/can't-get-lost — every
+   pointer event over the app is swallowed so the user advances with Next. The
+   dim itself comes from the spotlight's box-shadow (or the banner backdrop). */
+.tour-blocker {
+  position: absolute;
+  inset: 0;
+  pointer-events: auto;
 }
 
-.git-branch-pill.current {
-  border-color: var(--accent);
-  background: var(--pill-active-bg);
-  color: var(--accent);
-  cursor: default;
+/* The cutout around the highlighted control: its huge box-shadow IS the dim, so
+   everything outside this rect darkens while the target stays clear. Visual
+   only (no pointer events) — the blocker beneath handles clicks. */
+.tour-spotlight {
+  position: fixed;
+  border-radius: var(--radius);
+  box-shadow:
+    0 0 0 9999px rgba(0, 0, 0, 0.58),
+    0 0 0 2px var(--accent),
+    0 0 0 6px color-mix(in srgb, var(--accent) 30%, transparent);
+  pointer-events: none;
+  animation: tour-spotlight-in 0.2s ease-out;
 }
 
-.git-branch-pill.remote {
-  opacity: 0.7;
-  border-style: dashed;
+@keyframes tour-spotlight-in {
+  from {
+    box-shadow:
+      0 0 0 9999px rgba(0, 0, 0, 0);
+  }
 }
 
-.git-commit-list {
-  display: flex;
-  flex-direction: column;
+.tour-bubble {
+  position: fixed;
+  z-index: 201;
+  pointer-events: auto;
+  padding: 12px 14px;
+  border-radius: var(--radius);
+  background: var(--bg-elevated);
+  border: 1px solid var(--accent);
+  box-shadow: var(--shadow-3);
+  color: var(--text-primary);
+  font-size: 12px;
+  animation: hint-bubble-in 0.22s ease-out;
 }
 
-.git-commit-row {
-  display: flex;
-  align-items: baseline;
-  gap: 6px;
-  padding: 3px 6px;
-  background: transparent;
-  border: none;
-  border-bottom: 1px solid var(--border-color);
-  color: var(--text-primary);
-  cursor: pointer;
-  font-family: inherit;
-  font-size: 11px;
-  text-align: left;
-  width: 100%;
+/* Centered card fallback when a step's target isn't on screen. */
+.tour-bubble--banner {
+  left: 50%;
+  top: 50%;
+  transform: translate(-50%, -50%);
+  width: min(420px, calc(100vw - 32px));
 }
 
-.git-commit-row:hover {
-  background: var(--pill-active-bg);
+.tour-bubble-title {
+  font-weight: 600;
+  margin-bottom: 5px;
 }
 
-.git-commit-row.head {
-  border-left: 2px solid var(--accent);
+.tour-bubble-body {
+  color: var(--text-secondary);
+  line-height: 1.45;
 }
 
-/* Graph mode: rows are a fixed height with no vertical padding so the lane
-   lines drawn per-row meet seamlessly across row boundaries. */
-.git-commit-list.graph .git-commit-row {
+.tour-bubble-footer {
+  display: flex;
   align-items: center;
-  padding-top: 0;
-  padding-bottom: 0;
-  padding-left: 0;
-  height: 22px;
+  gap: 8px;
+  margin-top: 12px;
 }
 
-.git-commit-list.graph .git-commit-row.head {
-  border-left: none;
+.tour-bubble-count {
+  color: var(--text-muted);
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
 }
 
-.git-graph-cell {
-  display: block;
-  align-self: stretch;
+.tour-bubble-skip {
+  margin-left: auto;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  font-size: 11px;
+  cursor: pointer;
+  padding: 0;
 }
 
-.git-commit-hash {
-  font-family: monospace;
-  color: var(--text-muted);
-  flex-shrink: 0;
+.tour-bubble-skip:hover {
+  color: var(--text-primary);
+  text-decoration: underline;
 }
 
-.git-commit-subject {
-  flex: 1;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
+.tour-bubble-back {
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--text-primary);
+  font-size: 11px;
+  padding: 4px 12px;
+  cursor: pointer;
 }
 
-.git-commit-ref {
-  flex-shrink: 0;
-  font-size: 9px;
-  padding: 0 5px;
-  border-radius: 8px;
+.tour-bubble-back:disabled {
+  opacity: 0.4;
+  cursor: default;
+}
+
+.tour-bubble-next {
+  border: 1px solid var(--accent);
+  border-radius: var(--radius-sm);
   background: var(--accent);
-  color: var(--bg-base, #111);
-  white-space: nowrap;
+  color: var(--accent-contrast);
+  font-size: 11px;
+  padding: 4px 14px;
+  cursor: pointer;
 }
 
-.git-commit-date {
-  flex-shrink: 0;
-  font-size: 9px;
-  color: var(--text-muted);
-  white-space: nowrap;
+.tour-bubble-next:hover {
+  background: var(--accent-hover, var(--accent));
 }
 
-/* Commit-message window */
-.commit-window {
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  padding: 12px 14px;
-  width: min(560px, 92vw);
+@media (prefers-reduced-motion: reduce) {
+  .tour-spotlight,
+  .tour-bubble {
+    animation: none;
+  }
+}
+
+/* Lesson picker (LessonsMenu): a vertical list of task walkthroughs. */
+.lessons-list {
   display: flex;
   flex-direction: column;
   gap: 8px;
-  box-shadow: 0 10px 30px rgba(0, 0, 0, 0.5);
+  margin-top: 6px;
 }
 
-.commit-window-meta {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  font-size: 11px;
-  color: var(--text-muted);
+.lessons-section-title {
+  margin: 10px 0 0;
+  font-size: 10.5px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--text-secondary);
 }
 
-.commit-window-message {
-  width: 100%;
-  font-family: monospace;
-  font-size: 12px;
-  background: var(--bg-base, #111);
-  color: var(--text-primary);
-  border: 1px solid var(--border-color);
-  border-radius: 4px;
-  padding: 6px 8px;
-  resize: vertical;
-  box-sizing: border-box;
+.lessons-section-title:first-child {
+  margin-top: 0;
 }
 
-.commit-window-actions {
+.lesson-item {
   display: flex;
-  justify-content: flex-end;
-  gap: 6px;
-}
-
-.commit-window-actions button {
-  background: transparent;
+  flex-direction: column;
+  gap: 3px;
+  text-align: left;
+  padding: 10px 12px;
+  border-radius: var(--radius);
   border: 1px solid var(--border-color);
+  background: var(--bg-panel);
   color: var(--text-primary);
-  border-radius: 4px;
-  padding: 4px 10px;
-  font-size: 11px;
   cursor: pointer;
-  font-family: inherit;
+  transition: border-color var(--transition), background var(--transition);
 }
 
-.commit-window-actions button:hover:not(:disabled) {
+.lesson-item:hover {
   border-color: var(--accent);
-  color: var(--accent-hover);
+  background: color-mix(in srgb, var(--accent) 8%, var(--bg-panel));
 }
 
-.commit-window-actions button.primary {
-  border-color: var(--accent);
-  color: var(--accent);
+.lesson-item-title {
+  font-weight: 600;
+  font-size: 13px;
 }
 
-.commit-window-actions button:disabled {
-  opacity: 0.4;
-  cursor: not-allowed;
+.lesson-item-blurb {
+  color: var(--text-secondary);
+  font-size: 11.5px;
+  line-height: 1.4;
 }
 
-/* ── Project switcher bar (lives inside .header-center) ───────────────── */
-.project-switcher {
-  height: 100%;
-  background-color: transparent;
-  display: flex;
-  align-items: center;
-  padding: 0 6px;
-  gap: 4px;
-  /* Fill the header-center track and stay shrinkable so the pill row can never
-     push past it into the right-side clock/controls. min-width:0 lets the
-     flex children (notably .project-pills-scroll) shrink below content size. */
-  flex: 1;
-  min-width: 0;
-  /* visible so the add/settings dropdown menus can spill below the header;
-     horizontal pill overflow is handled by .project-pills-scroll. */
-  overflow: visible;
+/* ── Fancy themes: make the buttons live up to the name ──────────────────
+   The plain `dark`/`light` themes keep flat, utilitarian buttons. The
+   `fancy_*` themes earn their label here: the project pills get an
+   accent-tinted gradient surface, a soft glow border, and a hover lift +
+   glow. Scoped to `[data-theme="fancy_*"]` so the plain themes are
+   untouched. Only color/shadow/transform are themed — sizing and layout
+   stay owned by the base component rules above.
+   The header's icon buttons (Local Model, Global Apps, the settings gear,
+   the add-project +) are deliberately NOT themed here — they stay the same
+   flat, transparent-at-rest style in every theme, like the VPN/Machines
+   status readouts below. */
+
+/* The VPN and Machines indicators opt back out of the fancy gradient-button
+   treatment this section otherwise applies (they're status readouts, not
+   buttons — see the plain-theme rule on .vpn-indicator-btn/.machines-indicator-btn
+   for why): no glow border, lift or shadow. Their hover/expanded state still
+   gets the flat .pill-hover-bg tint (set above, same as .tab-new-btn:hover) —
+   only the rest state is forced transparent here, and only shadow/transform/
+   border stay suppressed on hover, so a future gradient rule added above can't
+   silently start theming them again. */
+[data-theme="fancy_dark"] .vpn-indicator-btn,
+[data-theme="fancy_light"] .vpn-indicator-btn,
+[data-theme="fancy_dark"] .machines-indicator-btn,
+[data-theme="fancy_light"] .machines-indicator-btn {
+  background: transparent;
+  border-color: transparent;
+  box-shadow: none;
+  transform: none;
+}
+
+[data-theme="fancy_dark"] .vpn-indicator-btn:hover,
+[data-theme="fancy_light"] .vpn-indicator-btn:hover,
+[data-theme="fancy_dark"] .vpn-indicator-btn[aria-expanded="true"],
+[data-theme="fancy_light"] .vpn-indicator-btn[aria-expanded="true"],
+[data-theme="fancy_dark"] .machines-indicator-btn:hover,
+[data-theme="fancy_light"] .machines-indicator-btn:hover,
+[data-theme="fancy_dark"] .machines-indicator-btn[aria-expanded="true"],
+[data-theme="fancy_light"] .machines-indicator-btn[aria-expanded="true"] {
+  background: var(--pill-hover-bg);
+  border-color: transparent;
+  box-shadow: none;
+  transform: none;
 }
 
-.project-switcher::-webkit-scrollbar { height: 0; }
+/* No generic bottom stripe on fancy-theme pills — the old --warning (yellow)
+   rail is gone; a non-active pill is bare (same color as the bar). Only the
+   category-tinted stripe (a deliberate grouping signal) remains, and the
+   active pill's accent frame (base rule) marks the current one. */
 
-/* ── Project pill ────────────────────────────────────────────────────── */
-.project-pill {
-  display: flex;
-  align-items: center;
-  height: 32px;
-  border-radius: 0;
-  border: 1px solid var(--control-border);
-  font-size: 12px;
-  font-weight: 500;
-  color: var(--text-secondary);
-  background-color: var(--control-bg);
-  box-shadow: inset 0 3px 0 var(--warning);
-  transition: background-color 0.1s, color 0.1s;
-  flex-shrink: 0;
-  white-space: nowrap;
+[data-theme="fancy_dark"] .project-pill.has-category:not(.active):not(.timer-paused),
+[data-theme="fancy_light"] .project-pill.has-category:not(.active):not(.timer-paused) {
+  box-shadow: inset 0 -3px 0 var(--cat-color);
 }
 
-.project-pill:hover {
-  background-color: var(--control-hover-bg);
+[data-theme="fancy_dark"] .project-pill.has-category:not(.active):not(.timer-paused):hover,
+[data-theme="fancy_light"] .project-pill.has-category:not(.active):not(.timer-paused):hover {
+  box-shadow:
+    inset 0 -3px 0 var(--cat-color),
+    0 0 10px -4px color-mix(in srgb, var(--accent) 55%, transparent);
+}
+
+/* Tabs: fancy themes use borderless tabs with a bottom accent rail, keeping the
+   indicator beside the pane rather than above the label. The active tab also
+   gets an accent-tinted body, a bold label, and a soft glow; hovered tabs warm
+   into an accent wash. Plain themes keep the base tab treatment. */
+/* Fancy themes use the SAME melt + straight bottom accent line as every other
+   theme now — no gradient body, no glow, no inset stripe. Only the top/bottom
+   border colour is transparent by default (base rule) and the active tab's
+   bottom border is the accent line; nothing here needs to override that. */
+
+/* Tab text stays uncoloured in the fancy themes too — fancy_dark labels are
+   plain white (below), fancy_light labels fall through to the theme foreground.
+   (No accent gradient on the active tab; the top/bottom rail carries the kind.) */
+
+/* Keep project and tab names plain white in fancy dark mode. */
+[data-theme="fancy_dark"] .project-pill-label,
+[data-theme="fancy_dark"] .tab-label {
+  color: #fff;
+}
+
+[data-theme="fancy_dark"] .project-pill-label,
+[data-theme="fancy_dark"] .tab-label,
+[data-theme="fancy_light"] .project-pill-label,
+[data-theme="fancy_light"] .tab-label {
+  font-weight: 700;
+}
+
+[data-theme="fancy_dark"] .project-pill:not(.active):not(:hover) .project-pill-label,
+[data-theme="fancy_dark"] .tab:not(.active):not(:hover) .tab-label {
+  opacity: 1;
+}
+
+[data-theme="fancy_dark"] .tab.active .tab-label {
+  background: none;
+  -webkit-text-fill-color: #fff;
+  color: #fff;
+  font-weight: 700;
+}
+
+/* No fancy-mode active-tab glow or hover wash — tabs melt into the bar in every
+   theme, so their only shadow is the base side-edge 3D and their only active
+   marker is the straight bottom accent line. */
+
+[data-theme="fancy_dark"] .tab-new-btn:hover,
+[data-theme="fancy_light"] .tab-new-btn:hover {
+  background:
+    radial-gradient(120% 120% at 50% 0%,
+      color-mix(in srgb, var(--accent) 26%, transparent) 0%,
+      var(--pill-hover-bg) 75%);
   color: var(--text-primary);
-  border-color: var(--text-muted);
+  box-shadow: 0 0 10px -3px color-mix(in srgb, var(--accent) 65%, transparent);
 }
 
-.project-pill.dragging {
-  opacity: 0.45;
-  transform: scale(0.94);
-  transition: transform 0.12s ease, opacity 0.12s ease;
+/* Local-model (Ollama) autocomplete ghost suggestion: in fancy mode the
+   accepted-on-Tab proposal glows so it reads as a live AI suggestion rather
+   than dim inline text. `text-shadow` (not box-shadow) so the glow hugs the
+   glyphs of the suggestion span only. Brighter than the base accent tint. */
+[data-theme="fancy_dark"] .file-viewer-ghost-text {
+  color: var(--accent-hover, #5edcff);
+  opacity: 1;
+  text-shadow: 0 0 8px color-mix(in srgb, var(--accent) 70%, transparent);
 }
 
-/* Make room before the drop target and show a pulsing insertion bar. */
-.project-pill.drag-over {
-  position: relative;
-  margin-left: 8px;
-  border-color: var(--accent);
-  transition: margin-left 0.14s ease;
+[data-theme="fancy_light"] .file-viewer-ghost-text {
+  color: var(--accent);
+  opacity: 1;
+  text-shadow: 0 0 7px color-mix(in srgb, var(--accent) 45%, transparent);
 }
 
-.project-pill.drag-over::before {
-  content: "";
-  position: absolute;
-  left: -5px;
-  top: 4px;
-  bottom: 4px;
-  width: 2px;
-  border-radius: 1px;
-  background: var(--accent);
-  box-shadow: 0 0 6px var(--accent);
-  animation: drag-insert-pulse 0.85s ease-in-out infinite;
+/* ── Network traffic monitoring tab ─────────────────────────────────────── */
+.network-pane {
+  display: flex;
+  flex: 1;
+  min-width: 0;
+  min-height: 0;
+  flex-direction: column;
+  gap: 14px;
+  overflow: auto;
+  padding: 18px;
+  color: var(--text-primary);
+  background: var(--bg-main);
 }
 
-/* The reorder insertion bar's pulse: the glow breathes and the bar grows a
-   touch so the drop point reads as live during a pill drag. */
-@keyframes drag-insert-pulse {
-  0%,
-  100% {
-    opacity: 0.6;
-    box-shadow: 0 0 4px var(--accent);
-    transform: scaleY(0.85);
-  }
-  50% {
-    opacity: 1;
-    box-shadow: 0 0 10px var(--accent);
-    transform: scaleY(1);
-  }
+.network-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  flex-wrap: wrap;
 }
 
-/* Alt-drag over a pill: the drop will box the two together (not reorder).
-   Suppress the reorder insertion bar and show a breathing "absorb" pulse that
-   reads as the target swelling to pull the dragged pill into a new box. */
-.project-pill.drag-group {
-  margin-left: 0;
-  border-color: var(--accent);
-  transform-origin: center;
-  animation: drag-group-absorb 0.7s ease-in-out infinite;
+.network-heading {
+  font-size: 18px;
+  font-weight: 700;
+  /* Pane section header → accent, like the canonical dialog/menu titles. */
+  color: var(--accent);
 }
 
-.project-pill.drag-group::before {
-  content: none;
+.network-subheading {
+  margin-top: 3px;
+  color: var(--text-muted);
+  font-size: 12px;
+  overflow-wrap: anywhere;
 }
 
-@keyframes drag-group-absorb {
-  0%,
-  100% {
-    box-shadow: 0 0 0 1px var(--accent), 0 0 5px var(--accent);
-    transform: scale(1);
-  }
-  50% {
-    box-shadow: 0 0 0 4px var(--accent), 0 0 18px var(--accent);
-    transform: scale(1.07);
-  }
+.network-view-tabs {
+  display: inline-flex;
+  gap: 2px;
+  padding: 3px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
+}
+
+.network-view-tabs button {
+  border: 0;
+  border-radius: var(--radius);
+  padding: 6px 10px;
+  color: var(--text-secondary);
+  background: transparent;
+  cursor: pointer;
 }
 
-.project-pill.active {
-  background-color: var(--pill-active-bg);
-  border-color: var(--pill-active-border);
+.network-view-tabs button:hover,
+.network-view-tabs button.active {
   color: var(--text-primary);
-  box-shadow: inset 0 3px 0 var(--accent);
+  background: var(--control-hover-bg);
 }
 
-.pill-main {
-  display: flex;
-  align-items: center;
-  gap: inherit;
-  padding: 0 8px 0 12px;
-  height: 100%;
-  background: none;
-  border: none;
-  color: inherit;
-  font: inherit;
-  cursor: pointer;
-  flex: 1;
-  min-width: 0;
+.network-view-tabs button.active {
+  box-shadow: inset 0 -2px 0 var(--accent);
 }
 
-.pill-close-btn {
+.network-interface-select {
   display: flex;
   align-items: center;
-  justify-content: center;
-  width: 20px;
-  height: 20px;
-  margin-right: 4px;
-  background: none;
-  border: none;
-  color: var(--text-muted);
-  font-size: 14px;
-  line-height: 1;
-  cursor: pointer;
-  border-radius: 3px;
-  opacity: 0;
-  transition: opacity 0.1s, background-color 0.1s;
-  flex-shrink: 0;
+  gap: 7px;
+  margin-left: auto;
+  color: var(--text-secondary);
+  font-size: 12px;
 }
 
-.project-pill:hover .pill-close-btn {
-  opacity: 1;
+.network-interface-select select,
+.network-connection-filters select,
+.network-connection-filters input {
+  min-width: 0;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  padding: 6px 8px;
+  color: var(--text-primary);
+  background: var(--bg-panel);
 }
 
-.pill-close-btn:hover {
-  background-color: var(--control-hover-bg);
-  color: var(--text-primary);
+.network-metrics {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
 }
 
-/* ── Project box chip ───────────────────────────────────────────────── */
-/* A box groups member pills behind a labelled chip, visually distinct from a
-   plain project pill (accent-tinted frame + ▣ badge + member count). */
-.project-box-chip {
-  display: flex;
-  align-items: center;
-  flex-shrink: 0;
+.network-metric {
+  display: grid;
   gap: 4px;
-  padding: 0 4px;
-  height: 32px;
-  border: 1px solid var(--accent);
-  border-radius: 0;
-  background-color: color-mix(in srgb, var(--accent) 12%, var(--control-bg));
+  min-width: 0;
+  padding: 13px 15px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
 }
 
-.project-box-chip.drag-over {
-  border-color: var(--warning);
-  box-shadow: inset 0 0 0 1px var(--warning);
+.network-metric span,
+.network-metric small {
+  color: var(--text-secondary);
+  font-size: 12px;
 }
 
-.project-box-header {
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  height: 100%;
-  padding-left: 4px;
-  white-space: nowrap;
+.network-metric strong {
+  overflow: hidden;
+  font-size: clamp(18px, 3vw, 26px);
+  line-height: 1.2;
+  text-overflow: ellipsis;
 }
 
-.project-box-badge {
-  font-size: 12px;
+.network-metric.receive strong,
+.network-graph-legend .receive {
   color: var(--accent);
-  line-height: 1;
 }
 
-.project-box-name {
-  background: none;
-  border: none;
-  color: var(--text-primary);
-  font: inherit;
-  font-weight: 600;
-  font-size: 12px;
-  cursor: pointer;
-  padding: 0;
+.network-metric.transmit strong,
+.network-graph-legend .transmit {
+  color: var(--success, #3fb950);
 }
 
-.project-box-name:hover {
-  color: var(--accent);
+.network-usage-totals {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 6px 16px;
+  padding: 9px 15px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  background: var(--bg-panel);
+  color: var(--text-secondary);
+  font-size: 12px;
 }
 
-.project-box-rename-input {
-  width: 90px;
-  font: inherit;
-  font-size: 12px;
-  background: var(--control-bg);
+.network-usage-totals .network-usage-label {
   color: var(--text-primary);
-  border: 1px solid var(--accent);
-  border-radius: 0;
-  padding: 1px 4px;
+  font-weight: 600;
 }
 
-.project-box-member-count {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 16px;
-  height: 16px;
-  padding: 0 4px;
-  font-size: 10px;
-  font-weight: 600;
+.network-usage-totals .rx {
   color: var(--accent);
-  background: color-mix(in srgb, var(--accent) 22%, transparent);
-  border-radius: 8px;
 }
 
-.project-box-caret {
-  font-size: 9px;
-  color: var(--accent);
-  margin-right: 1px;
-  line-height: 1;
+.network-usage-totals .tx {
+  color: var(--success, #3fb950);
 }
 
-/* Expanded member list: a downward dropdown portaled to the body so it escapes
-   the horizontally-scrolling pills row's vertical clipping. Members stack as a
-   vertical list, each pill spanning the dropdown width. */
-.project-box-dropdown {
-  position: fixed;
-  z-index: 1000;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-  margin-top: 2px;
-  padding: 4px;
+.network-graph-wrap {
+  position: relative;
+  padding: 12px 12px 8px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
   background: var(--bg-panel);
-  border: 1px solid var(--accent);
-  box-shadow: 0 12px 28px rgba(0, 0, 0, 0.36);
 }
 
-.project-box-dropdown .project-pill {
+.network-graph {
+  display: block;
   width: 100%;
+  height: 160px;
+  overflow: visible;
 }
 
-.project-box-dropdown-hint {
-  padding: 3px 4px 1px;
-  font-size: 9px;
-  color: var(--text-secondary);
-  text-align: center;
-  opacity: 0.7;
+.network-grid-line {
+  stroke: var(--border-subtle);
+  stroke-width: 1;
 }
 
-/* Drop the reorder margin shift inside the vertical list (it would nudge pills
-   sideways); the insertion bar still marks the drop point. */
-.project-box-dropdown .project-pill.drag-over {
-  margin-left: 0;
+.network-line {
+  fill: none;
+  stroke-width: 2;
+  vector-effect: non-scaling-stroke;
 }
 
-/* Subtle cue that an expanded box's chip is the open dropdown's anchor. */
-.project-box-chip.expanded {
-  background-color: color-mix(in srgb, var(--accent) 20%, var(--control-bg));
+.network-line.receive {
+  stroke: var(--accent);
 }
 
-/* A box rendered as a project-style pill: same base as .project-pill, with an
-   accent-tinted box icon and member-count badge. */
-.project-pill.is-box .pill-folder-icon {
-  color: var(--accent);
+.network-line.transmit {
+  stroke: var(--success, #3fb950);
 }
 
-.project-pill.is-box .project-box-member-count {
-  margin-left: 4px;
+.network-graph-scale {
+  position: absolute;
+  top: 8px;
+  right: 12px;
+  color: var(--text-muted, var(--text-secondary));
+  font-size: 10px;
 }
 
-/* Member rows inside the box pill's hover dropdown: click to switch, × to
-   remove from the box. */
-.project-box-member-row {
+.network-graph-legend {
   display: flex;
+  gap: 14px;
   align-items: center;
-  gap: 2px;
+  font-size: 11px;
 }
 
-.project-box-member-open {
+.network-history-label {
+  margin-left: auto;
+  color: var(--text-secondary);
+}
+
+.network-connections {
+  display: flex;
+  min-height: 190px;
   flex: 1;
+  flex-direction: column;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  overflow: hidden;
+  background: var(--bg-panel);
+}
+
+.network-connections-head {
   display: flex;
   align-items: center;
-  gap: 6px;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  font: inherit;
-  font-size: 12px;
-  padding: 4px 8px;
-  cursor: pointer;
-  text-align: left;
-  white-space: nowrap;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 11px 12px;
+  border-bottom: 1px solid var(--border-subtle);
 }
 
-.project-box-member-open:hover {
-  background: var(--control-hover-bg);
-  color: var(--accent);
-  border-color: var(--accent);
+.network-connections-head h3 {
+  display: inline;
+  margin: 0 8px 0 0;
+  font-size: 14px;
 }
 
-.project-box-member-remove {
-  flex-shrink: 0;
-  width: 20px;
-  height: 26px;
-  background: var(--control-bg);
+.network-connections-head span,
+.network-table-note {
   color: var(--text-secondary);
-  border: 1px solid var(--control-border);
-  cursor: pointer;
-  font-size: 12px;
-}
-
-.project-box-member-remove:hover {
-  color: var(--danger, #f85149);
-  border-color: var(--danger, #f85149);
+  font-size: 11px;
 }
 
-/* Multi-root file view (box scope): one collapsible section per root, each set
-   off from the next with a header band, a left accent rail, and an indented
-   body so the boundaries between project roots read clearly. */
-.file-root {
-  --file-root-accent: var(--text-secondary);
-  margin-bottom: 8px;
-  border: 1px solid var(--border-color);
-  border-left: 3px solid var(--file-root-accent);
-  background: var(--bg-panel);
+.network-connection-filters {
+  display: flex;
+  gap: 8px;
+  min-width: min(100%, 360px);
 }
 
-.file-root:last-child {
-  margin-bottom: 0;
+.network-connection-filters input {
+  flex: 1;
 }
 
-/* The box's own folder leads the list and is accent-tinted; member project
-   roots use a calmer neutral rail. */
-.file-root--box {
-  --file-root-accent: var(--accent);
+.network-table-wrap {
+  min-height: 0;
+  flex: 1;
+  overflow: auto;
 }
 
-.file-root-header {
-  display: flex;
-  align-items: center;
-  gap: 6px;
+.network-table-wrap table {
   width: 100%;
-  padding: 5px 7px;
-  background: color-mix(in srgb, var(--file-root-accent) 10%, var(--bg-panel));
-  color: var(--text-primary);
-  border: none;
-  border-bottom: 1px solid var(--border-color);
-  font: inherit;
+  border-collapse: collapse;
   font-size: 11px;
-  font-weight: 600;
-  cursor: pointer;
+  font-variant-numeric: tabular-nums;
+}
+
+.network-table-wrap th,
+.network-table-wrap td {
+  max-width: 260px;
+  padding: 7px 10px;
+  border-bottom: 1px solid color-mix(in srgb, var(--border-subtle) 70%, transparent);
+  overflow: hidden;
+  text-align: left;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.network-table-wrap th {
   position: sticky;
   top: 0;
   z-index: 1;
-  white-space: nowrap;
+  color: var(--text-secondary);
+  background: var(--bg-panel);
 }
 
-.file-root.is-collapsed .file-root-header {
-  border-bottom: none;
+.network-table-wrap tbody tr:hover {
+  background: var(--control-hover-bg);
 }
 
-.file-root-header:hover {
-  background: color-mix(in srgb, var(--file-root-accent) 18%, var(--bg-panel));
+.network-empty-row {
+  padding: 28px !important;
+  color: var(--text-secondary);
+  text-align: center !important;
 }
 
-.file-root-caret {
-  font-size: 9px;
-  color: var(--file-root-accent);
-  width: 9px;
-  flex-shrink: 0;
+.network-table-note,
+.network-link-note {
+  padding: 8px 12px;
 }
 
-.file-root-icon {
-  flex-shrink: 0;
+.network-link-note,
+.network-warning {
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius);
+  color: var(--text-secondary);
+  background: var(--bg-panel);
+  font-size: 11px;
 }
 
-.file-root--box .file-root-icon {
-  color: var(--accent);
+.network-warning {
+  padding: 8px 10px;
+  color: var(--warning, #d29922);
 }
 
-.file-root-name {
+.network-status-panel {
+  display: grid;
+  place-items: center;
+  align-content: center;
+  gap: 9px;
+  min-height: 260px;
   flex: 1;
+  text-align: center;
+}
+
+.network-status-title {
+  font-size: 17px;
+  font-weight: 700;
+}
+
+.network-status-message {
+  max-width: 520px;
+  color: var(--text-muted);
+}
+
+@media (max-width: 700px) {
+  .network-pane {
+    padding: 12px;
+  }
+
+  .network-interface-select {
+    width: 100%;
+    margin-left: 0;
+  }
+
+  .network-interface-select select {
+    flex: 1;
+  }
+
+  .network-connections-head,
+  .network-connection-filters {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}
+
+/* ── Disk usage analyzer tab ──────────────────────────────────────────────── */
+
+.du-root {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  background: var(--bg-panel);
+  color: var(--text-primary);
+  font-size: 12px;
   overflow: hidden;
-  text-overflow: ellipsis;
 }
 
-/* Small role tag (box / project) on the right of each header. */
-.file-root-kind {
-  flex-shrink: 0;
-  font-size: 9px;
-  font-weight: 600;
-  text-transform: uppercase;
-  letter-spacing: 0.04em;
-  color: var(--file-root-accent);
-  opacity: 0.8;
-  padding: 1px 5px;
-  border: 1px solid color-mix(in srgb, var(--file-root-accent) 40%, transparent);
-  border-radius: 8px;
+.du-centered {
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
 }
 
-/* Indent the file list under its header so nested entries don't line up with
-   the section rails. */
-.file-root-body {
-  padding-left: 4px;
+.du-error {
+  color: var(--danger);
+  padding: 8px 0;
 }
 
-/* Box rows in the search popover: distinct from project rows. */
-.project-search-row.is-box {
-  border-left: 2px solid var(--accent);
-  background: color-mix(in srgb, var(--accent) 8%, var(--control-bg));
+/* ── Home screen ─────────────────────────────────────────────────────────── */
+
+.du-home {
+  padding: 28px 32px;
+  overflow: auto;
 }
 
-.project-search-row.is-box .project-box-badge {
-  margin-right: 2px;
+.du-home-title {
+  font-size: 15px;
+  font-weight: 600;
+  margin: 0 0 16px;
 }
 
-/* ── Project pill popup ─────────────────────────────────────────────── */
-.project-pill-popup {
-  position: fixed;
-  transform: translate(-50%, 6px);
+.du-targets {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
+  gap: 12px;
+  max-width: 900px;
+}
+
+.du-target {
   display: flex;
   flex-direction: column;
-  gap: 3px;
-  background: var(--bg-panel);
+  align-items: stretch;
+  gap: 4px;
+  padding: 14px 16px;
+  text-align: left;
+  background: var(--control-bg);
   border: 1px solid var(--control-border);
-  border-radius: 4px;
-  padding: 6px 10px;
-  white-space: nowrap;
-  pointer-events: none;
-  z-index: 9999;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+  border-radius: var(--radius);
+  color: var(--text-primary);
+  cursor: pointer;
 }
 
-.pill-popup-path {
+.du-target:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  border-color: var(--accent);
+}
+
+.du-target:disabled {
+  opacity: 0.55;
+  cursor: default;
+}
+
+.du-target-label {
+  font-weight: 600;
+}
+
+.du-target-path,
+.du-target-caption {
+  color: var(--text-muted);
   font-size: 11px;
-  color: var(--text-secondary);
-  max-width: 300px;
   overflow: hidden;
   text-overflow: ellipsis;
-  direction: rtl;
-  text-align: left;
+  white-space: nowrap;
 }
 
-.pill-popup-description {
-  color: var(--text-primary);
-  font-size: 12px;
-  line-height: 1.35;
-  max-width: 320px;
-  white-space: normal;
+.du-capacity {
+  display: block;
+  height: 6px;
+  margin-top: 4px;
+  background: var(--bg-main);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
 }
 
-.pill-popup-status {
-  font-size: 11px;
-  font-weight: 600;
+.du-capacity-fill {
+  display: block;
+  height: 100%;
+  background: var(--accent);
 }
 
-.pill-popup-status.active {
-  color: var(--accent, #89b4fa);
-}
+/* ── Scanning ────────────────────────────────────────────────────────────── */
 
-.pill-popup-status.inactive {
-  color: var(--text-muted, #6c7086);
+.du-scanning-title {
+  font-weight: 600;
 }
 
-.pill-popup-time {
-  font-size: 11px;
+.du-scanning-stats {
   color: var(--text-secondary);
-  display: flex;
-  align-items: center;
+  font-variant-numeric: tabular-nums;
 }
 
-.pill-popup-cpu {
+.du-scanning-path {
+  color: var(--text-muted);
   font-size: 11px;
-  color: var(--text-secondary);
+  max-width: 70%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  direction: rtl; /* keep the deepest, most informative part of the path visible */
 }
 
-/* ── Project switcher action buttons ──────────────────────────────────────── */
-.project-switcher-action-btn {
+/* ── Toolbar ─────────────────────────────────────────────────────────────── */
+
+.du-toolbar {
   display: flex;
   align-items: center;
-  justify-content: center;
-  width: 32px;
-  height: 32px;
-  border-radius: 0;
-  border: none;
-  cursor: pointer;
-  background: transparent;
-  color: var(--text-secondary);
-  font-size: 16px;
-  transition: background-color 0.1s, color 0.1s;
-  flex-shrink: 0;
+  gap: 10px;
+  padding: 6px 10px;
+  border-bottom: 1px solid var(--border-color);
+  flex: 0 0 auto;
 }
 
-.project-switcher-action-btn:hover {
-  background-color: var(--pill-hover-bg);
+.du-btn {
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius);
   color: var(--text-primary);
+  padding: 3px 9px;
+  font-size: 12px;
+  cursor: pointer;
 }
 
-/* ── Settings panel ─────────────────────────────────────────────────── */
-.settings-overlay {
-  position: absolute;
-  bottom: 56px;
-  left: 8px;
-  background-color: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  padding: 12px;
-  min-width: 200px;
-  z-index: 20;
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3);
+.du-btn:hover {
+  background: var(--control-hover-bg);
 }
 
-.settings-label {
-  font-size: 11px;
-  font-weight: 600;
-  color: var(--text-secondary);
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-  margin-bottom: 8px;
+.du-btn.active {
+  border-color: var(--accent);
+  color: var(--accent);
 }
 
-.theme-btn {
-  display: block;
-  width: 100%;
-  text-align: left;
-  padding: 6px 8px;
-  border-radius: 0;
+.du-crumbs {
+  display: flex;
+  align-items: center;
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+}
+
+.du-crumb {
+  background: none;
   border: none;
-  cursor: pointer;
+  color: var(--accent);
+  padding: 2px 3px;
   font-size: 12px;
-  background: transparent;
+  cursor: pointer;
+  white-space: nowrap;
+}
+
+.du-crumb:disabled {
   color: var(--text-primary);
-  transition: background-color 0.1s;
+  font-weight: 600;
+  cursor: default;
 }
 
-.theme-btn:hover { background-color: var(--pill-hover-bg); }
-.theme-btn.selected { color: var(--accent); font-weight: 600; }
+.du-crumb-sep {
+  color: var(--text-muted);
+}
 
-/* ── Tab bar (lives inside .header-center) ───────────────────────────── */
-.tab-bar {
-  display: flex;
-  align-items: flex-end;
-  padding: 0 4px;
-  gap: 2px;
-  /* The bar itself no longer scrolls; only the inner `.tab-strip` does. The bar
-     stays a fixed row holding the scroll chevrons, the strip, the + button and
-     the close/detach controls. */
-  overflow: hidden;
-  /* A fixed-height strip at the top of its subwindow. NOT flex:1 — the tab bar
-     lives inside the column-flex `.subwindow`, so growing would let it eat the
-     pane's vertical space and float the tabs to mid-window. */
-  flex: 0 0 auto;
-  min-width: 0;
-  min-height: 32px;
-  /* Distinct from the pane (`--bg-main`) so the bar reads as its own strip; the
-     bottom border + the active tab's `--bg-main` blend keep the divide crisp. */
-  background-color: var(--bg-panel);
-  border-bottom: 1px solid var(--border-color);
-  /* #42: the empty bar area is a drag handle — grab it to pop the subwindow out
-     into its own OS window. Tabs/buttons reset the cursor to their own. */
-  cursor: grab;
+.du-total {
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+.du-stats {
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
 }
-.tab-bar:active { cursor: grabbing; }
-.tab-bar .tab,
-.tab-bar button,
-.tab-bar .tab-new-wrap { cursor: default; }
 
-/* The horizontally-scrolling tab container. Grows to fill the bar between the
-   chevrons and the +/close controls; its scrollbar is hidden (chevrons + wheel
-   drive the scroll instead). */
-.tab-strip {
+.du-chart-toggle {
   display: flex;
-  align-items: flex-end;
-  gap: 2px;
-  flex: 1 1 auto;
-  min-width: 0;
-  overflow-x: auto;
-  scrollbar-width: none;
+  gap: 4px;
 }
-.tab-strip::-webkit-scrollbar { height: 0; }
 
-/* Chevron buttons that flank the strip when it overflows. */
-.tab-scroll-btn {
-  flex-shrink: 0;
-  align-self: center;
-  width: 20px;
-  height: 26px;
+/* ── Body: treeview | chart ──────────────────────────────────────────────── */
+
+.du-body {
   display: flex;
-  align-items: center;
-  justify-content: center;
-  border: none;
-  border-radius: 3px;
-  background: transparent;
-  color: var(--text-muted);
-  cursor: pointer;
-  font-size: 16px;
-  line-height: 1;
-  z-index: 12;
-  transition: background-color 0.1s, color 0.1s;
+  flex: 1;
+  min-height: 0;
 }
-.tab-scroll-btn:hover {
-  background: var(--pill-hover-bg);
-  color: var(--text-primary);
+
+.du-tree {
+  flex: 0 0 42%;
+  min-width: 260px;
+  max-width: 560px;
+  overflow: auto;
+  border-right: 1px solid var(--border-color);
 }
 
-.tab {
+.du-row {
   display: flex;
   align-items: center;
   gap: 6px;
-  padding: 0 12px;
-  height: 30px;
-  cursor: pointer;
-  font-size: 12px;
-  color: var(--text-muted);
+  padding-right: 10px;
+  cursor: default;
   white-space: nowrap;
-  flex-shrink: 0;
-  border: 1px solid transparent;
-  border-bottom: none;
-  border-radius: 0;
-  margin-bottom: 0;
-  margin-top: 0;
-  transition: background-color 0.15s, color 0.15s, margin 0.14s ease,
-    max-width 0.14s ease, padding 0.14s ease;
-  user-select: none;
-  /* Don't let the webview claim the pointer for a pan/select gesture — on
-     WebKitGTK that turns a drag's release into pointercancel, not pointerup. */
-  touch-action: none;
 }
 
-.tab:hover {
-  background-color: var(--pill-hover-bg);
-  color: var(--text-primary);
-  border-top-color: var(--accent);
-  border-left-color: var(--control-border);
-  border-right-color: var(--control-border);
+.du-row.dir {
+  cursor: pointer;
 }
 
-.tab.active {
-  background: linear-gradient(180deg, var(--control-hover-bg) 0%, var(--bg-main) 100%);
-  color: var(--text-primary);
-  border-top: 2px solid var(--accent);
-  border-left-color: var(--border-color);
-  border-right-color: var(--border-color);
-  border-bottom-color: var(--bg-main);
-  position: relative;
-  z-index: 11;
-  /* Overlap the bar's bottom border so the active tab merges into the pane
-     (`--bg-main`) below, visually breaking out of the panel-colored strip. */
-  margin-bottom: -1px;
+.du-row:hover {
+  background: var(--pill-hover-bg);
 }
 
-.tab-label { flex: 1; min-width: 0; }
+.du-row-caret {
+  width: 10px;
+  color: var(--text-muted);
+  flex: 0 0 auto;
+}
 
-/* #56: inline tab rename. The label is swapped for a borderless input that
-   inherits the tab's typography so the tab width doesn't jump while editing. */
-.tab-label-edit {
+.du-row-name {
   flex: 1;
   min-width: 0;
-  font: inherit;
-  color: inherit;
-  background: var(--bg-main, rgba(0, 0, 0, 0.25));
-  border: 1px solid var(--accent, #4aa3df);
-  border-radius: 3px;
-  padding: 0 2px;
-  margin: 0;
-  outline: none;
+  overflow: hidden;
+  text-overflow: ellipsis;
 }
 
-/* ── Working tab indicator ───────────────────────────────────────────────
-   Shown while a tab's PTY is actively streaming output (busy agent/terminal).
-   A small rotating orbit spinner sits before the label, tinted with the tab
-   kind's accent; the label itself gently pulses so background work is visible
-   without competing with the active tab. */
-.tab-working {
-  display: inline-flex;
-  align-items: center;
-  flex-shrink: 0;
+.du-row.dir .du-row-name {
+  font-weight: 600;
 }
 
-.tab-working-spinner {
-  margin-left: 0;
+.du-row.file .du-row-name {
+  color: var(--text-secondary);
 }
 
-.tab-working-spinner .orbit-dot {
-  fill: currentColor;
+.du-row-bar {
+  flex: 0 0 64px;
+  height: 6px;
+  background: var(--control-bg);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
 }
 
-.tab.working .tab-label {
-  animation: tab-working-pulse 1.6s ease-in-out infinite;
+.du-row-bar-fill {
+  display: block;
+  height: 100%;
+  background: var(--accent);
 }
 
-@keyframes tab-working-pulse {
-  0%, 100% { opacity: 0.6; }
-  50% { opacity: 1; }
+.du-row-size {
+  flex: 0 0 62px;
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+  color: var(--text-secondary);
 }
 
-.tab-close {
+.du-chart {
+  flex: 1;
+  min-width: 0;
   display: flex;
-  align-items: center;
-  justify-content: center;
-  width: 16px;
-  height: 16px;
-  border-radius: 0;
-  border: none;
-  background: transparent;
-  color: var(--text-muted);
-  cursor: pointer;
-  font-size: 14px;
-  line-height: 1;
-  flex-shrink: 0;
-  opacity: 0;
-  transition: opacity 0.1s, background-color 0.1s;
 }
 
-.tab:hover .tab-close,
-.tab.active .tab-close { opacity: 1; }
-.tab-close:hover { background-color: var(--pill-hover-bg); color: var(--text-primary); }
-
-/* Per-subwindow close (×), shown in the tab bar when >1 subwindow exists.
-   The bar scrolls horizontally when tabs overflow; pin this button to the right
-   edge (sticky + flex-shrink:0) so it never scrolls out of reach and stays
-   clickable regardless of how many tabs the group holds. The panel-colored
-   background keeps overflowing tabs from showing through behind it. */
-.subwindow-close {
-  margin-left: auto;
-  align-self: center;
-  position: sticky;
-  right: 0;
-  flex-shrink: 0;
-  z-index: 12;
-  width: 22px;
-  height: 22px;
+.du-svg-wrap {
+  flex: 1;
+  min-width: 0;
   display: flex;
   align-items: center;
   justify-content: center;
-  border: none;
-  background: var(--bg-panel);
-  color: var(--text-muted);
+  overflow: hidden;
+}
+
+/* Slices are separated by a hairline of the pane background rather than a stroke
+   colour, so the ring reads as segmented in every theme (same trick as the commit
+   graph's dot halos). */
+.du-arc,
+.du-cell {
+  stroke: var(--bg-panel);
+  stroke-width: 1;
   cursor: pointer;
-  font-size: 15px;
 }
-.subwindow-close:hover {
-  background: var(--pill-hover-bg);
-  color: var(--danger);
+
+.du-arc:hover,
+.du-cell:hover {
+  stroke: var(--text-primary);
+  stroke-width: 1.5;
 }
 
-/* #42: detached ("pop out") window title-bar controls — the native
-   min/max/close cluster. Pinned to the right of the tab bar (sticky) so they
-   never scroll out when tabs overflow; the panel-colored backing keeps
-   overflowing tabs from showing through. (Dock-back is done by Ctrl+dragging the
-   tab bar onto the main window, #42.) */
-.detached-titlebar-controls {
-  margin-left: auto;
-  align-self: center;
-  position: sticky;
-  right: 0;
-  z-index: 12;
-  flex-shrink: 0;
-  display: flex;
-  align-items: center;
-  gap: 10px;
-  padding: 0 8px;
-  background: var(--bg-panel);
+.du-centre {
+  fill: var(--bg-panel);
+  stroke: var(--border-color);
 }
 
-/* The dragged tab collapses out of the row so its old slot closes and the only
-   opening is the gap that slides open at the drop target. */
-.tab.dragging {
-  max-width: 0;
-  padding-left: 0;
-  padding-right: 0;
-  margin: 0;
-  border-color: transparent;
-  opacity: 0;
-  overflow: hidden;
+.du-centre.up {
+  cursor: pointer;
+}
+
+.du-centre.up:hover {
+  stroke: var(--accent);
+}
+
+.du-centre-name,
+.du-centre-size,
+.du-cell-label {
   pointer-events: none;
+  user-select: none;
 }
 
-/* ── New-tab button + dropdown ───────────────────────────────────────── */
-.tab-new-wrap {
-  position: relative;
-  display: flex;
-  align-items: flex-end;
-  padding: 0;
-  margin-left: 0;
-  flex-shrink: 0;
-  align-self: flex-end;
+.du-centre-name {
+  fill: var(--text-primary);
+  font-size: 12px;
+  font-weight: 600;
 }
 
-.tab-new-btn {
-  width: 34px;
-  height: 30px;
-  border-radius: 0;
-  border: 1px solid transparent;
-  border-bottom: none;
-  background: transparent;
-  color: var(--text-muted);
-  cursor: pointer;
-  font-size: 18px;
-  line-height: 1;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  margin: 0;
-  transition: background-color 0.15s, color 0.15s, border-color 0.15s;
+.du-centre-size {
+  fill: var(--text-muted);
+  font-size: 11px;
 }
 
-.tab-new-btn:hover {
-  background: var(--pill-hover-bg);
-  color: var(--text-primary);
-  border-top-color: var(--accent);
-  border-left-color: var(--control-border);
-  border-right-color: var(--control-border);
+.du-cell-label {
+  fill: #0b0b0b; /* the slice fills are mid-to-light HSL in every theme */
+  font-size: 11px;
+  font-weight: 600;
 }
 
-.tab-new-menu {
-  position: absolute;
-  top: calc(100% + 4px);
-  left: 0;
-  z-index: 100;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  padding: 4px;
-  min-width: 132px;
-  box-shadow: 0 12px 28px rgba(0,0,0,0.36);
-  display: flex;
-  flex-direction: column;
-  gap: 1px;
+
+/* ── Native calendar tab ──────────────────────────────────────────────────────
+   The pane is a toolbar + sidebar + one of six views (day / week / multiweek /
+   month / agenda / tasks). Events are colored by `currentColor`: each block sets
+   `color` to its category's (or its calendar's) color, and the border/background
+   below derive from it via color-mix, so one property tints a whole block.
+   ------------------------------------------------------------------------- */
+
+:root {
+  /* Category swatches. Deliberately theme-independent: a "Work" event should be
+     the same color in light and dark, the way a highlighter is. */
+  --cal-cat-work: #4aa3df;
+  --cal-cat-personal: #59b96a;
+  --cal-cat-meeting: #e8663d;
+  --cal-cat-travel: #4fc3c3;
+  --cal-cat-birthday: #c164d6;
+  --cal-cat-holiday: #e2b93b;
+  --cal-cat-important: #d9556b;
+
+  /* Geometry the month grid shares between its cells and its absolute bars. */
+  --cal-daynum-h: 20px;
+  --cal-bar-h: 18px;
 }
 
-.tab-new-menu-item {
+.cal-pane {
   display: flex;
-  align-items: center;
-  gap: 8px;
-  min-height: 30px;
-  padding: 6px 10px;
-  border: 1px solid transparent;
-  border-radius: 0;
-  background: var(--control-bg);
+  flex-direction: column;
+  height: 100%;
+  width: 100%;
+  background: var(--bg-panel);
   color: var(--text-primary);
-  cursor: pointer;
-  font-size: 12px;
-  text-align: left;
-  transition: background-color 0.1s;
+  overflow: hidden;
+  outline: none;
 }
 
-.tab-new-menu-item:hover {
-  background-color: var(--control-hover-bg);
-  border-color: var(--accent);
+/* ── Toolbar ─────────────────────────────────────────────────────────────── */
+
+.cal-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border-color);
+  flex: 0 0 auto;
 }
 
-.tab-new-menu-item:disabled {
-  opacity: 0.45;
-  cursor: default;
+.cal-toolbar-nav {
+  display: flex;
+  align-items: center;
+  gap: 4px;
 }
 
-.tab-new-menu-item:disabled:hover {
-  background: var(--control-bg);
-  border-color: transparent;
+.cal-toolbar-title {
+  font-size: 14px;
+  font-weight: 650;
+  color: var(--accent);
+  min-width: 0;
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
 }
 
-.tab-new-menu-dot { font-size: 8px; flex-shrink: 0; }
-
-.tab-new-menu-group-label {
-  padding: 6px 10px 2px;
-  font-size: 9px;
-  font-weight: 600;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: var(--text-muted);
-  user-select: none;
+.cal-toolbar-views,
+.cal-toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
 }
 
-.tab-new-menu-hint {
-  padding: 4px 10px;
-  font-size: 11px;
-  color: var(--text-muted);
-  font-style: italic;
+.cal-search {
+  width: 180px;
+  flex: 0 0 auto;
 }
 
-/* ── Context menus ───────────────────────────────────────────────────── */
-.context-menu {
-  position: fixed;
-  z-index: 1000;
-  min-width: 150px;
-  padding: 4px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  box-shadow: 0 12px 28px rgba(0,0,0,0.36);
-}
+/* ── Shared controls ─────────────────────────────────────────────────────── */
 
-.context-menu button {
-  display: block;
-  width: 100%;
-  min-height: 28px;
-  padding: 5px 9px;
-  border: 1px solid transparent;
+.cal-btn,
+.cal-nav-btn {
+  height: 26px;
+  padding: 0 10px;
+  font-size: 12px;
   background: var(--control-bg);
   color: var(--text-primary);
-  text-align: left;
-  font-size: 12px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius);
   cursor: pointer;
 }
 
-.context-menu button:hover {
+.cal-nav-btn {
+  width: 26px;
+  padding: 0;
+  font-size: 15px;
+  line-height: 1;
+}
+
+.cal-btn:hover:not(:disabled),
+.cal-nav-btn:hover {
   background: var(--control-hover-bg);
   border-color: var(--accent);
 }
 
-.context-menu button.danger {
-  color: var(--danger);
+.cal-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
 }
 
-.context-menu button.danger:hover {
-  border-color: var(--danger);
+.cal-btn-primary {
+  background: var(--accent);
+  color: var(--accent-contrast);
+  border-color: var(--accent);
 }
 
-.context-menu hr {
-  height: 1px;
-  margin: 4px 0;
-  border: 0;
-  background: var(--border-subtle);
+.cal-btn-primary:hover:not(:disabled) {
+  background: var(--accent-hover);
+  border-color: var(--accent-hover);
 }
 
-/* ── Dropdown (the one custom themed dropdown; native <select> popups can't
-   be themed on WebKitGTK so we render trigger + menu ourselves) ─────────── */
-.dropdown {
-  position: relative;
-  display: inline-flex;
+.cal-btn-danger {
+  border-color: var(--danger);
+  color: var(--danger);
 }
 
-.dropdown-trigger {
-  display: inline-flex;
-  align-items: center;
-  gap: 6px;
-  min-height: 24px;
-  padding: 2px 8px;
+.cal-btn-danger:hover {
+  background: var(--danger);
+  color: var(--accent-contrast);
+}
+
+/* A pill toggle: view switcher, task filters, snooze offsets. */
+.cal-chip {
+  height: 24px;
+  padding: 0 9px;
+  font-size: 11px;
+  background: transparent;
+  color: var(--text-secondary);
   border: 1px solid var(--control-border);
-  border-radius: 3px;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  font-size: 12px;
+  border-radius: var(--radius);
   cursor: pointer;
 }
 
-.dropdown-trigger:hover:not(:disabled),
-.dropdown-trigger:focus-visible {
+.cal-chip:hover {
   border-color: var(--accent);
-  outline: none;
+  color: var(--text-primary);
 }
 
-.dropdown-trigger:disabled {
-  opacity: 0.6;
-  cursor: default;
+.cal-chip-on {
+  background: var(--accent);
+  color: var(--accent-contrast);
+  border-color: var(--accent);
 }
 
-.dropdown-caret {
-  font-size: 9px;
-  color: var(--text-muted);
+.cal-link-btn {
+  background: none;
+  border: none;
+  padding: 2px 4px;
+  font-size: 11px;
+  color: var(--accent);
+  cursor: pointer;
 }
 
-.dropdown-menu {
-  position: absolute;
-  top: calc(100% + 2px);
-  left: 0;
-  min-width: 120px;
+.cal-link-btn:hover {
+  color: var(--accent-hover);
+  text-decoration: underline;
 }
 
-/* Two-class specificity so per-toolbar `… button` rules (e.g. the file browser
-   actions row this menu lives inside) don't override the menu item look. */
-.dropdown .dropdown-menu button {
-  display: block;
-  width: 100%;
-  min-height: 28px;
-  padding: 5px 9px;
-  text-align: left;
-  border: 1px solid transparent;
-  border-radius: 0;
+.cal-link-danger {
+  color: var(--danger);
+}
+
+.cal-link-danger:hover {
+  color: var(--danger);
+}
+
+.cal-input {
+  height: 28px;
+  padding: 0 8px;
+  font-size: 12px;
+  font-family: inherit;
   background: var(--control-bg);
   color: var(--text-primary);
-  font-size: 12px;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius);
 }
 
-.dropdown .dropdown-menu button:hover {
-  background: var(--control-hover-bg);
+.cal-input:focus {
+  outline: none;
   border-color: var(--accent);
 }
 
-.dropdown .dropdown-menu button.selected {
-  color: var(--accent);
-  border-color: var(--accent);
+.cal-input-num {
+  width: 64px;
 }
 
-/* ── File tree ────────────────────────────────────────────────────────── */
-.file-tree {
-  min-height: 100%;
-  box-sizing: border-box;
-  padding: 4px;
+.cal-textarea {
+  height: auto;
+  min-height: 60px;
+  padding: 6px 8px;
+  resize: vertical;
 }
 
-.file-tree-breadcrumb {
-  display: flex;
-  align-items: center;
-  flex-wrap: wrap;
-  gap: 1px;
-  width: 100%;
-  padding: 2px 4px 4px;
+.cal-empty,
+.cal-hint {
+  padding: 16px;
   font-size: 12px;
+  color: var(--text-muted);
 }
 
-.file-tree-up {
-  display: flex;
-  align-items: center;
-  padding: 2px 6px;
-  margin-right: 2px;
-  background: transparent;
-  border: none;
-  cursor: pointer;
-  font-size: 12px;
-  color: var(--text-secondary);
-  border-radius: 4px;
+.cal-hint {
+  padding: 4px 0;
 }
 
-.file-tree-up:hover { background-color: var(--pill-hover-bg); }
-
-.file-tree-crumb {
-  padding: 2px 4px;
-  background: transparent;
-  border: none;
-  cursor: pointer;
+.cal-error {
+  padding: 6px 8px;
   font-size: 12px;
-  color: var(--text-secondary);
-  border-radius: 4px;
-  max-width: 140px;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  color: var(--danger);
+  border: 1px solid var(--danger);
 }
 
-.file-tree-crumb:hover { background-color: var(--pill-hover-bg); }
-
-.file-tree-crumb.current {
+.cal-notice {
+  padding: 6px 12px;
+  font-size: 12px;
   color: var(--text-primary);
-  cursor: default;
+  background: var(--control-bg);
+  border-bottom: 1px solid var(--accent);
+  cursor: pointer;
+  flex: 0 0 auto;
 }
 
-.file-tree-crumb.current:hover { background-color: transparent; }
+/* ── Body: sidebar + view ────────────────────────────────────────────────── */
 
-.file-tree-crumb-sep {
-  color: var(--text-muted);
-  font-size: 11px;
+.cal-body {
+  display: flex;
+  flex: 1;
+  min-height: 0;
 }
 
-.file-tree-loading,
-.file-tree-empty {
-  padding: 8px 12px;
-  font-size: 12px;
-  color: var(--text-muted);
+.cal-view {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
 }
 
-.file-tree-error {
-  padding: 8px 12px;
-  font-size: 11px;
-  color: var(--danger);
-  word-break: break-all;
-}
+/* ── Sidebar ─────────────────────────────────────────────────────────────── */
 
-.file-entry {
+.cal-sidebar {
+  width: 190px;
+  flex: 0 0 auto;
   display: flex;
-  align-items: flex-start;
-  gap: 6px;
-  padding: 3px 8px;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 12px;
-  color: var(--text-primary);
-  user-select: none;
+  flex-direction: column;
+  gap: 12px;
+  padding: 10px;
+  border-right: 1px solid var(--border-subtle);
+  overflow-y: auto;
 }
 
-.file-entry:hover { background-color: var(--pill-hover-bg); }
+.cal-mini-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  margin-bottom: 6px;
+}
 
-/* Files never start a native (browser) drag — embeddable ones use a pointer
-   drag to a tab bar, non-embeddable ones aren't draggable at all. Suppress the
-   webview's built-in drag of the row text/icon. Dirs keep native DnD (export). */
-.file-entry.file,
-.file-entry.file * {
-  -webkit-user-drag: none;
-  user-drag: none;
+.cal-mini-title {
+  font-size: 12px;
+  font-weight: 650;
+  color: var(--text-primary);
 }
 
-/* Only EMBEDDABLE files can be dragged onto a subwindow's tab bar (Group K).
-   Give just those a subtle 3D "pop up" on hover so the drag affordance is
-   discoverable; non-embeddable files get no effect, signalling they're not
-   draggable (they open on double-click). */
-.file-entry.file.embeddable {
-  transition:
-    transform 120ms ease,
-    box-shadow 120ms ease,
-    background-color 120ms ease;
-  transform: translateZ(0);
-}
-.file-entry.file.embeddable:hover {
-  position: relative;
-  z-index: 2;
-  cursor: grab;
-  transform: translateY(-2px) scale(1.02);
-  box-shadow:
-    0 5px 12px rgba(0, 0, 0, 0.35),
-    0 1px 3px rgba(0, 0, 0, 0.25);
+.cal-mini-weekdays,
+.cal-mini-week {
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
 }
-.file-entry.file.embeddable:active {
-  cursor: grabbing;
-  transform: translateY(0) scale(1.0);
-  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.25);
+
+.cal-mini-weekday {
+  text-align: center;
+  font-size: 9px;
+  color: var(--text-muted);
+  padding: 2px 0;
 }
 
-.file-run-btn {
-  display: inline-flex;
+.cal-mini-day {
+  aspect-ratio: 1;
+  display: flex;
   align-items: center;
   justify-content: center;
-  width: 18px;
-  height: 18px;
-  flex-shrink: 0;
-  padding: 0;
-  border: 1px solid color-mix(in srgb, var(--success) 70%, transparent);
-  border-radius: 4px;
-  background: transparent;
-  color: var(--success);
   font-size: 10px;
-  line-height: 1;
+  background: none;
+  border: 1px solid transparent;
+  border-radius: var(--radius);
+  color: var(--text-secondary);
   cursor: pointer;
 }
 
-.file-run-btn:hover {
-  background: color-mix(in srgb, var(--success) 14%, transparent);
-  border-color: var(--success);
+.cal-mini-day:hover {
+  background: var(--control-hover-bg);
 }
 
-.file-run-btn.running {
-  cursor: default;
-  border-color: color-mix(in srgb, var(--success) 70%, transparent);
-  background: transparent;
+.cal-mini-day-out {
+  color: var(--text-muted);
+  opacity: 0.5;
 }
 
-.file-run-spinner {
-  width: 10px;
-  height: 10px;
-  border-radius: 50%;
-  border: 1.5px solid color-mix(in srgb, var(--success) 30%, transparent);
-  border-top-color: var(--success);
-  animation: file-run-spin 0.7s linear infinite;
+.cal-mini-day-today {
+  color: var(--accent);
+  font-weight: 700;
 }
 
-@keyframes file-run-spin {
-  to { transform: rotate(360deg); }
+.cal-mini-day-selected {
+  background: var(--accent);
+  color: var(--accent-contrast);
+  border-color: var(--accent);
 }
 
-.file-tree-section-divider {
+.cal-list-head {
   display: flex;
   align-items: center;
-  gap: 6px;
-  margin-top: 8px;
-  padding: 4px 4px 2px;
-  font-size: 10px;
-  font-weight: 600;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: var(--text-secondary);
-  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
-}
-
-.file-entry.scaffold {
-  opacity: 0.65;
+  justify-content: space-between;
+  margin-bottom: 4px;
+  border-top: 1px solid var(--border-subtle);
+  padding-top: 8px;
 }
 
-.file-tree-hidden-toggle {
-  width: 100%;
-  background: none;
-  border: none;
-  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
-  cursor: pointer;
-  text-align: left;
+.cal-list-title {
+  font-size: 11px;
+  font-weight: 650;
+  color: var(--accent-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
 }
 
-.file-tree-hidden-toggle:hover {
-  color: var(--text-primary);
+.cal-list-add {
+  display: flex;
+  gap: 4px;
+  margin-bottom: 6px;
 }
 
-.file-tree-hidden-caret {
-  display: inline-block;
-  width: 9px;
-  font-size: 9px;
+.cal-list-add .cal-input {
+  flex: 1;
+  min-width: 0;
 }
 
-.file-tree-scaffold-toggle {
+.cal-list-row {
   display: flex;
   align-items: center;
   gap: 5px;
-  padding: 2px 8px 4px;
-  font-size: 10px;
-  color: var(--text-muted);
+  padding: 3px 0;
+}
+
+.cal-list-row:hover .cal-list-del {
+  visibility: visible;
+}
+
+.cal-list-del {
+  visibility: hidden;
+  margin-left: auto;
+  font-size: 14px;
+  line-height: 1;
+}
+
+/* A native color input, shrunk to a swatch. */
+.cal-color-dot {
+  width: 12px;
+  height: 12px;
+  padding: 0;
+  border: 1px solid var(--control-border);
+  background: none;
   cursor: pointer;
-  user-select: none;
+  flex: 0 0 auto;
 }
 
-.file-tree.drag-over {
-  outline: 2px dashed var(--accent, #58a6ff);
-  outline-offset: -2px;
-  border-radius: 6px;
-  background: rgba(88, 166, 255, 0.06);
+.cal-color-dot::-webkit-color-swatch-wrapper {
+  padding: 0;
 }
 
-.file-icon { font-size: 12px; flex-shrink: 0; line-height: 1.3; }
-.file-name { flex: 1; min-width: 0; overflow-wrap: anywhere; word-break: break-word; line-height: 1.3; }
-.file-size { font-size: 10px; color: var(--text-muted); flex-shrink: 0; line-height: 1.3; }
-.file-size.size-small  { color: var(--text-muted); }
-.file-size.size-medium { color: #e3b341; }
-.file-size.size-large  { color: #f0883e; }
-.file-size.size-huge   { color: #f85149; }
+.cal-color-dot::-webkit-color-swatch {
+  border: none;
+}
 
-.file-tooltip {
-  position: fixed;
-  z-index: 9999;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 5px;
-  padding: 6px 10px;
+.cal-list-name {
   font-size: 11px;
   color: var(--text-primary);
-  pointer-events: none;
+  overflow: hidden;
+  text-overflow: ellipsis;
   white-space: nowrap;
-  line-height: 1.8;
-  box-shadow: 0 4px 16px rgba(0,0,0,0.4);
+  cursor: default;
 }
-.file-tooltip-label {
+
+.cal-list-name-off {
   color: var(--text-muted);
-  margin-right: 8px;
-  display: inline-block;
-  width: 5.5em;
+  text-decoration: line-through;
 }
 
-.file-delete-dialog {
-  width: min(360px, calc(100vw - 32px));
-  display: flex;
-  flex-direction: column;
-  gap: 12px;
-  padding: 18px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.42);
+.cal-list-rename {
+  height: 20px;
+  font-size: 11px;
+  flex: 1;
+  min-width: 0;
 }
 
-.file-delete-dialog h2 {
-  margin: 0;
-  font-size: 16px;
+/* ── Month / multiweek ───────────────────────────────────────────────────── */
+
+.cal-month {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-height: 0;
 }
 
-.file-delete-dialog p {
-  margin: 0;
-  font-size: 13px;
-  color: var(--text-primary);
+.cal-month-weekdays {
+  display: grid;
+  grid-template-columns: repeat(7, 1fr);
+  border-bottom: 1px solid var(--border-subtle);
+  flex: 0 0 auto;
 }
 
-.file-delete-path {
-  padding: 7px 8px;
-  background: var(--control-bg);
-  border: 1px solid var(--border-subtle);
+.cal-month-weekday {
+  padding: 5px 0;
+  text-align: center;
+  font-size: 10px;
+  font-weight: 650;
   color: var(--text-muted);
-  font-size: 11px;
-  word-break: break-all;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
 }
 
-.file-delete-actions {
+.cal-month-weeks {
   display: flex;
-  justify-content: flex-end;
-  gap: 8px;
+  flex-direction: column;
+  flex: 1;
+  min-height: 0;
 }
 
-.file-delete-actions button {
-  border: 1px solid var(--control-border);
-  padding: 7px 10px;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  cursor: pointer;
+/* Each week is a positioning context: the day cells tile it, and the event bars
+   sit on top so a multi-day bar can cross the cell borders. */
+.cal-month-week {
+  position: relative;
+  flex: 1;
+  min-height: 76px;
+  border-bottom: 1px solid var(--border-subtle);
 }
 
-.file-delete-actions button:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+.cal-month-day {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  border-right: 1px solid var(--border-subtle);
+  cursor: pointer;
 }
 
-.file-delete-actions button.danger {
-  border-color: var(--danger);
-  background: var(--danger);
-  color: var(--bg-main);
+.cal-month-day:hover {
+  background: color-mix(in srgb, var(--accent) 6%, transparent);
 }
 
-/* ── Center file browser ─────────────────────────────────────────────── */
-.file-browser {
-  position: absolute;
-  inset: 0;
-  display: none;
-  flex-direction: column;
-  background: var(--bg-main);
-  color: var(--text-primary);
-  overflow: hidden;
+.cal-month-day-out {
+  background: color-mix(in srgb, var(--bg-main) 45%, transparent);
 }
 
-.file-browser.active { display: flex; }
-
-.file-browser-empty,
-.file-browser-message {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  padding: 16px;
+.cal-month-day-out .cal-month-daynum {
   color: var(--text-muted);
-  font-size: 12px;
-}
-
-.file-browser-toolbar,
-.file-browser-actions,
-.file-browser-status {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  padding: 6px 8px;
-  border-bottom: 1px solid var(--border-subtle);
-  background: var(--bg-panel);
-  flex-shrink: 0;
+  opacity: 0.6;
 }
 
-.file-browser-actions {
-  padding-top: 4px;
-  padding-bottom: 4px;
-  color: var(--text-secondary);
-  font-size: 11px;
+.cal-month-day-selected {
+  box-shadow: inset 0 0 0 1px var(--accent);
 }
 
-.file-browser-toolbar button,
-.file-browser-actions button,
-.file-browser-actions select,
-.file-browser-path input,
-.file-browser-search {
-  min-height: 24px;
-  border: 1px solid var(--control-border);
-  background: var(--control-bg);
-  color: var(--text-primary);
-  font-size: 12px;
-  padding: 2px 8px;
-  border-radius: 0;
+.cal-month-daynum {
+  display: block;
+  height: var(--cal-daynum-h);
+  padding: 2px 6px 0;
+  font-size: 11px;
+  color: var(--text-secondary);
 }
 
-.file-browser-toolbar button,
-.file-browser-actions button {
-  cursor: pointer;
+.cal-month-day-today .cal-month-daynum {
+  color: var(--accent);
+  font-weight: 700;
 }
 
-.file-browser-toolbar button:hover:not(:disabled),
-.file-browser-actions button:hover:not(:disabled),
-.file-browser-toolbar button.selected,
-.file-browser-actions button.selected {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+.cal-month-more {
+  position: absolute;
+  bottom: 2px;
+  left: 5px;
+  font-size: 9px;
+  color: var(--text-muted);
+  cursor: pointer;
 }
 
-.file-browser-toolbar button:disabled,
-.file-browser-actions button:disabled {
-  opacity: 0.45;
-  cursor: default;
+.cal-month-more:hover {
+  color: var(--accent);
 }
 
-.file-browser-actions label {
+/* One event in the month grid. A timed single-day event is a dot + text; an
+   all-day or multi-day one is a solid bar spanning its columns. */
+.cal-month-bar {
+  position: absolute;
+  height: calc(var(--cal-bar-h) - 2px);
   display: flex;
   align-items: center;
   gap: 4px;
+  padding: 0 5px;
+  font-size: 10px;
+  line-height: 1;
   white-space: nowrap;
+  overflow: hidden;
+  border-radius: var(--radius);
+  cursor: pointer;
+  color: var(--accent);
 }
 
-.file-browser-path {
-  display: flex;
-  align-items: center;
-  gap: 6px;
-  min-width: 180px;
-  flex: 1;
+.cal-month-bar:hover {
+  background: color-mix(in srgb, currentColor 18%, transparent);
 }
 
-.file-browser-path span {
-  color: var(--text-secondary);
-  font-size: 11px;
-  max-width: 160px;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+.cal-month-bar-solid {
+  background: color-mix(in srgb, currentColor 78%, transparent);
+  color: var(--accent-contrast);
+  /* The bar's own tint is set inline via `color`; keep the text legible on it. */
+  text-shadow: 0 1px 1px rgba(0, 0, 0, 0.28);
 }
 
-.file-browser-path input {
-  min-width: 0;
-  flex: 1;
+.cal-month-bar-solid:hover {
+  background: currentColor;
 }
 
-.file-browser-search {
-  width: 160px;
+/* A span continuing off the row edge gets a flat, notched end. */
+.cal-month-bar-clip-start {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+  border-left: 2px dotted var(--accent-contrast);
 }
 
-.file-browser-body {
-  min-height: 0;
-  flex: 1;
-  display: grid;
-  grid-template-columns: 220px minmax(0, 1fr);
-  border-bottom: 1px solid var(--border-subtle);
+.cal-month-bar-clip-end {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+  border-right: 2px dotted var(--accent-contrast);
 }
 
-.file-browser-sidebar {
-  overflow: auto;
-  background: var(--bg-panel);
-  border-right: 1px solid var(--border-subtle);
-  padding: 6px;
+.cal-month-bar-dot {
+  font-size: 7px;
+  flex: 0 0 auto;
 }
 
-.file-browser-sidebar button {
-  width: 100%;
-  min-height: 26px;
-  text-align: left;
-  border: 1px solid transparent;
-  background: transparent;
-  color: var(--text-secondary);
-  cursor: pointer;
-  font-size: 12px;
+.cal-month-bar-time {
+  color: var(--text-muted);
+  flex: 0 0 auto;
+}
+
+.cal-month-bar-solid .cal-month-bar-time {
+  color: inherit;
+  opacity: 0.85;
+}
+
+.cal-month-bar-title {
   overflow: hidden;
   text-overflow: ellipsis;
-  white-space: nowrap;
 }
 
-.file-browser-sidebar button:hover,
-.file-browser-sidebar button.selected {
-  background: var(--pill-hover-bg);
+.cal-month-bar:not(.cal-month-bar-solid) .cal-month-bar-title {
   color: var(--text-primary);
-  border-color: var(--border-subtle);
 }
 
-.file-browser-main {
-  min-width: 0;
-  overflow: auto;
-  position: relative;
+/* ── Day / week: the all-day strip ───────────────────────────────────────── */
+
+.cal-timeview {
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  min-height: 0;
 }
 
-.file-browser-error {
-  padding: 8px 12px;
-  color: var(--danger);
-  font-size: 12px;
-  border-bottom: 1px solid var(--border-subtle);
+.cal-allday {
+  display: flex;
+  flex: 0 0 auto;
+  max-height: 120px;
+  border-bottom: 1px solid var(--border-color);
+  overflow-y: auto;
 }
 
-.file-browser-list {
-  min-width: 720px;
+.cal-allday-gutter {
+  width: 52px;
+  flex: 0 0 auto;
+  padding: 4px;
+  font-size: 9px;
+  color: var(--text-muted);
+  text-align: right;
+  align-self: flex-end;
 }
 
-.file-browser-section-divider {
+.cal-allday-cols {
   display: flex;
-  align-items: center;
-  gap: 6px;
-  margin-top: 8px;
-  padding: 4px 8px 2px;
-  font-size: 10px;
-  font-weight: 600;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: var(--text-secondary);
-  border-top: 1px solid var(--border-color, rgba(255,255,255,0.12));
-  grid-column: 1 / -1;
+  flex: 1;
+  min-width: 0;
 }
 
-.file-browser-row.scaffold,
-.file-browser-tile.scaffold {
-  opacity: 0.65;
+.cal-allday-col {
+  flex: 1;
+  min-width: 0;
+  padding: 3px;
+  border-left: 1px solid var(--border-subtle);
+  cursor: pointer;
 }
 
-.file-browser-section-divider--icons {
-  width: 100%;
+.cal-allday-col-selected {
+  background: color-mix(in srgb, var(--accent) 7%, transparent);
 }
 
-.file-browser-list-head,
-.file-browser-row {
-  display: grid;
-  grid-template-columns: minmax(260px, 1fr) 120px 100px 180px;
-  align-items: center;
-  gap: 12px;
-  min-height: 30px;
-  padding: 0 12px;
-  border-bottom: 1px solid var(--border-subtle);
-  font-size: 12px;
+.cal-allday-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: center;
+  gap: 4px;
+  padding-bottom: 3px;
 }
 
-.file-browser-list-head {
-  position: sticky;
-  top: 0;
-  z-index: 1;
-  background: var(--bg-panel);
-  color: var(--text-secondary);
-  font-size: 11px;
-  font-weight: 600;
+.cal-allday-dow {
+  font-size: 10px;
+  color: var(--text-muted);
   text-transform: uppercase;
 }
 
-.file-browser-row {
-  cursor: default;
-  color: var(--text-primary);
-}
-
-.file-browser-row:hover,
-.file-browser-row.selected,
-.file-browser-tile:hover,
-.file-browser-tile.selected {
-  background: var(--pill-hover-bg);
+.cal-allday-num {
+  font-size: 14px;
+  font-weight: 650;
+  color: var(--text-secondary);
 }
 
-.file-browser-row.selected,
-.file-browser-tile.selected {
-  outline: 1px solid var(--accent);
-  outline-offset: -1px;
+.cal-allday-col-today .cal-allday-dow,
+.cal-allday-col-today .cal-allday-num {
+  color: var(--accent);
 }
 
-.file-browser-row span {
-  min-width: 0;
+.cal-allday-chip {
+  margin-bottom: 2px;
+  padding: 2px 5px;
+  font-size: 10px;
+  background: color-mix(in srgb, var(--accent) 70%, transparent);
+  color: var(--accent-contrast);
+  border-radius: var(--radius);
+  white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
-  white-space: nowrap;
+  cursor: pointer;
 }
 
-.file-browser-row span:first-child {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-}
+/* ── Day / week: the hour grid ───────────────────────────────────────────── */
 
-.file-browser-row b {
-  color: var(--accent);
-  font-size: 11px;
-  font-weight: 600;
-  min-width: 28px;
+.cal-timegrid {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  position: relative;
 }
 
-.file-browser-tile span {
-  color: var(--accent);
-  font-size: 32px;
-  line-height: 1;
-  font-weight: 600;
-  min-width: 0;
+.cal-timegrid-inner {
+  display: flex;
+  position: relative;
 }
 
-.file-browser-icons {
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(104px, 1fr));
-  gap: 8px;
-  padding: 12px;
+.cal-timegrid-gutter {
+  width: 52px;
+  flex: 0 0 auto;
+  border-right: 1px solid var(--border-subtle);
 }
 
-.file-browser-tile {
-  min-height: 88px;
-  border: 1px solid transparent;
-  background: transparent;
-  color: var(--text-primary);
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  gap: 8px;
-  padding: 8px;
-  cursor: default;
+.cal-timegrid-hour-label {
+  padding-right: 6px;
+  font-size: 9px;
+  color: var(--text-muted);
+  text-align: right;
+  /* Nudge the label up so it sits ON its hour line, not below it. */
+  transform: translateY(-5px);
 }
 
-.file-browser-tile b {
-  max-width: 100%;
-  overflow-wrap: anywhere;
-  font-size: 12px;
-  font-weight: 500;
-  text-align: center;
+.cal-timegrid-body {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  /* A drag must not select the hour labels as it sweeps. */
+  user-select: none;
 }
 
-.file-browser-status {
-  min-height: 28px;
-  border-bottom: none;
-  color: var(--text-muted);
-  font-size: 11px;
+.cal-timegrid-line {
+  position: absolute;
+  left: 0;
+  right: 0;
+  height: 0;
+  border-top: 1px solid var(--border-subtle);
+  pointer-events: none;
 }
 
-/* ── Migrated main-branch app bars and hover strips ─────────────────── */
-/* ── Global-app launcher (header button + hover dropdown) ─────────────── */
-.global-apps-menu {
-  position: relative;
-  display: flex;
-  align-items: center;
-  flex-shrink: 0;
+.cal-timegrid-col {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  border-left: 1px solid var(--border-subtle);
+  cursor: cell;
 }
 
-.global-apps-menu-btn {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 32px;
-  height: 32px;
-  border-radius: 0;
-  border: 1px solid var(--control-border);
-  background: var(--control-bg);
-  color: var(--text-secondary);
-  cursor: pointer;
-  font-size: 14px;
+.cal-timegrid-col-today {
+  background: color-mix(in srgb, var(--accent) 4%, transparent);
 }
 
-.global-apps-menu-btn:hover,
-.global-apps-menu-btn[aria-expanded="true"] {
-  background: var(--control-hover-bg);
-  color: var(--text-primary);
-  border-color: var(--text-muted);
+.cal-now-line {
+  position: absolute;
+  left: 0;
+  right: 0;
+  height: 0;
+  border-top: 2px solid var(--danger);
+  z-index: 3;
+  pointer-events: none;
 }
 
-/* Drops straight down from the button, aligned to its right edge so it
-   stays clear of the clock/window controls. */
-.global-apps-menu-dropdown {
+.cal-now-line::before {
+  content: "";
   position: absolute;
-  top: 100%;
-  left: 0;
-  z-index: 90;
+  left: -1px;
+  top: -4px;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--danger);
 }
 
-.global-apps-menu-dropdown .global-apps-toolbar {
-  border-top: 1px solid var(--border-color);
+/* One timed event. `color` is set inline to the event's tint; the fill and the
+   left rule both derive from it. */
+.cal-block {
+  position: absolute;
+  overflow: hidden;
+  padding: 2px 5px;
+  font-size: 10px;
+  line-height: 1.25;
+  border-radius: var(--radius);
+  border-left: 3px solid currentColor;
+  background: color-mix(in srgb, currentColor 72%, transparent);
+  color: var(--accent);
+  cursor: grab;
+  z-index: 2;
 }
 
-.global-apps-toolbar {
-  align-self: center;
-  display: flex;
-  gap: 2px;
-  padding: 4px 6px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-top: none;
-  border-radius: 0;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.24);
+.cal-block:hover {
+  background: color-mix(in srgb, currentColor 88%, transparent);
 }
 
-.global-app-btn {
-  width: 30px;
-  height: 28px;
-  border-radius: 0;
-  border: none;
-  background: transparent;
-  color: var(--text-secondary);
-  cursor: pointer;
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
+.cal-block-dragging {
+  cursor: grabbing;
+  opacity: 0.85;
+  z-index: 4;
 }
 
-.global-app-btn:hover {
-  background: var(--pill-hover-bg);
-  color: var(--text-primary);
+.cal-block-title {
+  font-weight: 650;
+  color: var(--accent-contrast);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-shadow: 0 1px 1px rgba(0, 0, 0, 0.3);
 }
 
-.global-app-btn[aria-disabled="true"] {
-  cursor: default;
-  opacity: 0.55;
+.cal-block-time {
+  color: var(--accent-contrast);
+  opacity: 0.85;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
 }
 
-.global-app-btn[aria-disabled="true"]:hover {
-  background: transparent;
-  color: var(--text-secondary);
+/* Too short to show a second line — the title alone, on one line. */
+.cal-block-compact {
+  padding: 0 5px;
+  display: flex;
+  align-items: center;
 }
 
-.global-app-icon {
-  width: 18px;
-  height: 18px;
-  object-fit: contain;
+.cal-block-tentative {
+  background-image: repeating-linear-gradient(
+    45deg,
+    transparent,
+    transparent 3px,
+    rgba(255, 255, 255, 0.22) 3px,
+    rgba(255, 255, 255, 0.22) 6px
+  );
 }
 
-.global-app-fallback-icon {
-  font-size: 15px;
-  line-height: 1;
+.cal-block-cancelled {
+  opacity: 0.55;
 }
 
-.global-app-edit-popover {
-  position: fixed;
-  z-index: 1000;
-  width: 320px;
-  padding: 10px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  box-shadow: 0 12px 28px rgba(0,0,0,0.36);
-  color: var(--text-primary);
+.cal-block-cancelled .cal-block-title,
+.cal-block-cancelled .cal-agenda-title,
+.cal-block-cancelled .cal-month-bar-title {
+  text-decoration: line-through;
 }
 
-.global-app-edit-title {
-  font-weight: 650;
-  margin-bottom: 4px;
+/* The bottom edge — grab to resize. */
+.cal-block-resize {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  height: 6px;
+  cursor: ns-resize;
 }
 
-.global-app-edit-current {
-  margin-bottom: 8px;
-  color: var(--text-secondary);
-  font-size: 12px;
+/* The preview drawn while dragging out a new event. */
+.cal-block-ghost {
+  background: color-mix(in srgb, var(--accent) 40%, transparent);
+  border: 1px dashed var(--accent);
+  border-left-width: 3px;
+  color: var(--accent);
+  pointer-events: none;
+  z-index: 5;
 }
 
-.global-app-edit-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) auto;
-  gap: 6px;
+/* ── Agenda ──────────────────────────────────────────────────────────────── */
+
+.cal-agenda {
+  flex: 1;
+  overflow-y: auto;
+  padding: 8px 12px;
 }
 
-.global-app-edit-actions {
+.cal-agenda-day {
+  margin-bottom: 14px;
+}
+
+.cal-agenda-date {
   display: flex;
-  justify-content: flex-end;
-  gap: 6px;
-  margin-top: 8px;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 0;
+  margin-bottom: 3px;
+  font-size: 11px;
+  font-weight: 650;
+  color: var(--text-secondary);
+  border-bottom: 1px solid var(--border-subtle);
 }
 
-.right-panel {
-  pointer-events: none;
+.cal-agenda-date-today {
+  color: var(--accent);
 }
 
-.right-panel.open {
-  pointer-events: auto;
+.cal-agenda-today-tag {
+  padding: 1px 6px;
+  font-size: 9px;
+  font-weight: 650;
+  background: var(--accent);
+  color: var(--accent-contrast);
+  border-radius: var(--radius);
+  text-transform: uppercase;
 }
 
-.project-switcher-root-btn,
-.project-switcher-action-btn,
-.project-switcher-add-btn {
+.cal-agenda-row {
   display: flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 40px;
-  height: 40px;
-  border-radius: 0;
-  border: 1px solid var(--control-border);
+  align-items: baseline;
+  gap: 8px;
+  padding: 4px 6px;
+  font-size: 12px;
   cursor: pointer;
-  flex-shrink: 0;
-}
-
-.project-switcher-root-btn,
-.project-switcher-action-btn {
-  background: var(--control-bg);
-  color: var(--text-secondary);
 }
 
-.project-switcher-root-btn:hover,
-.project-switcher-action-btn:hover {
+.cal-agenda-row:hover {
   background: var(--control-hover-bg);
-  color: var(--text-primary);
-  border-color: var(--text-muted);
 }
 
-.project-switcher-root-btn.active {
-  background: var(--pill-active-bg);
-  color: var(--text-primary);
-  border-color: var(--pill-active-border);
-  box-shadow: inset 0 3px 0 var(--accent);
+.cal-agenda-swatch {
+  font-size: 8px;
+  flex: 0 0 auto;
 }
 
-.project-switcher-add-btn {
-  background: var(--accent);
-  color: var(--bg-main);
-  font-size: 20px;
-  border-color: var(--accent);
+.cal-agenda-time {
+  width: 78px;
+  flex: 0 0 auto;
+  font-size: 11px;
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
 }
 
-.project-switcher-add-btn:hover {
-  background: var(--accent-hover);
+.cal-agenda-title {
+  color: var(--text-primary);
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
-.project-switcher-separator {
-  width: 1px;
-  height: 32px;
-  background: var(--border-subtle);
-  flex-shrink: 0;
-  margin: 0 2px;
+.cal-agenda-location {
+  font-size: 11px;
+  color: var(--text-muted);
+  flex: 0 0 auto;
 }
 
-.project-pills-scroll {
+/* ── Tasks ───────────────────────────────────────────────────────────────── */
+
+.cal-tasks {
   flex: 1;
-  min-width: 0;
+  overflow-y: auto;
+  padding: 10px 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.cal-tasks-add {
   display: flex;
-  align-items: center;
   gap: 6px;
-  overflow-x: auto;
-  overflow-y: hidden;
-  height: 40px;
-  /* Overflow is conveyed solely by the left/right chevron buttons (toggled from
-     JS via the overflow-* classes); a vertical mouse wheel also scrolls this
-     horizontally in the webview, so no edge fade or visible scrollbar is used. */
-  scrollbar-width: none; /* Firefox/standard — hide the bar */
-  -ms-overflow-style: none;
 }
 
-/* Relative track holding the scrollable pill row plus the edge chevrons. */
-.project-pills-region {
-  position: relative;
+.cal-tasks-add-title {
   flex: 1;
   min-width: 0;
+}
+
+.cal-tasks-add-due {
+  width: 140px;
+  flex: 0 0 auto;
+}
+
+.cal-tasks-filters {
   display: flex;
-  align-items: center;
+  gap: 4px;
 }
 
-/* Chevron overlays that appear over whichever edge has hidden pills. They sit
-   above the pill row and scroll it on click, giving a clear "more this way"
-   cue beyond the edge fade. */
-.pills-scroll-btn {
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  width: 34px;
-  display: none;
+.cal-tasks-list {
+  display: flex;
+  flex-direction: column;
+}
+
+.cal-task-row {
+  display: flex;
   align-items: center;
-  justify-content: center;
-  padding: 0;
-  border: none;
-  cursor: pointer;
-  z-index: 2;
-  font-size: 26px;
-  line-height: 1;
-  color: var(--text-primary);
-  background: var(--bg-header);
-  transition: color 0.1s;
+  gap: 8px;
+  padding: 5px 6px;
+  font-size: 12px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.cal-task-row:hover {
+  background: var(--control-hover-bg);
 }
 
-.pills-scroll-btn:hover {
-  color: var(--accent);
+.cal-task-check {
+  flex: 0 0 auto;
+  cursor: pointer;
 }
 
-.pills-scroll-btn.left {
-  left: 0;
-  justify-content: flex-start;
-  background: linear-gradient(
-    to right,
-    var(--bg-header) 55%,
-    transparent 100%
-  );
+.cal-task-swatch {
+  font-size: 8px;
+  flex: 0 0 auto;
 }
 
-.pills-scroll-btn.right {
-  right: 0;
-  justify-content: flex-end;
-  background: linear-gradient(
-    to left,
-    var(--bg-header) 55%,
-    transparent 100%
-  );
+.cal-task-title {
+  flex: 1;
+  min-width: 0;
+  color: var(--text-primary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
-.project-pills-region.overflow-left .pills-scroll-btn.left {
-  display: flex;
+.cal-task-done .cal-task-title {
+  color: var(--text-muted);
+  text-decoration: line-through;
 }
 
-.project-pills-region.overflow-right .pills-scroll-btn.right {
-  display: flex;
+.cal-task-prio {
+  font-size: 10px;
+  font-weight: 650;
+  padding: 1px 5px;
+  border-radius: var(--radius);
+  flex: 0 0 auto;
 }
 
-/* Hidden scrollbar — overflow is conveyed by the edge fade above and wheel
-   scrolling, keeping the pills at full height inside the 40px row. */
-.project-pills-scroll::-webkit-scrollbar {
-  height: 0;
+.cal-task-prio-high {
+  color: var(--danger);
+  border: 1px solid var(--danger);
 }
 
-.project-pill {
-  height: 40px;
-  max-width: 180px;
+.cal-task-prio-normal {
+  color: var(--text-muted);
+  border: 1px solid var(--control-border);
 }
 
-.project-pill .pill-main {
-  gap: 6px;
+.cal-task-prio-low {
+  color: var(--text-muted);
+  border: 1px solid var(--border-subtle);
 }
 
-.project-pill-label {
+/* A slim completion meter for a task that is underway but not done. */
+.cal-task-percent {
+  position: relative;
+  width: 44px;
+  height: 4px;
+  flex: 0 0 auto;
+  background: var(--control-border);
+  border-radius: var(--radius);
   overflow: hidden;
-  text-overflow: ellipsis;
 }
 
-.pill-folder-icon {
-  flex-shrink: 0;
-  font-size: 15px;
+.cal-task-percent-fill {
+  position: absolute;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  background: var(--accent);
 }
 
-.project-pill.active .pill-folder-icon {
-  color: var(--accent-hover);
+.cal-task-due {
+  font-size: 11px;
+  color: var(--text-muted);
+  flex: 0 0 auto;
+  font-variant-numeric: tabular-nums;
 }
 
-.project-search-wrap {
-  position: relative;
-  width: 150px;
-  flex-shrink: 0;
+.cal-task-overdue .cal-task-due {
+  color: var(--danger);
+  font-weight: 650;
 }
 
-.project-search-entry {
-  width: 100%;
-  height: 40px;
-  border-radius: 0;
-  border: 1px solid var(--control-border);
+.cal-task-prio-select {
+  height: 22px;
+  font-size: 10px;
   background: var(--control-bg);
   color: var(--text-primary);
-  padding: 0 9px;
-  font-size: 12px;
-  outline: none;
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius);
+  flex: 0 0 auto;
 }
 
-.project-search-entry:focus {
-  border-color: var(--accent);
+/* ── Event dialog ────────────────────────────────────────────────────────── */
+
+/* Rides the shared .settings-dialog chrome; only the width and the explicit text
+   color are its own. The color matters: the dialog is portaled to <body>, which
+   sets none, so without this it would inherit black. */
+.cal-event-dialog {
+  width: min(560px, calc(100vw - 32px));
+  color: var(--text-primary);
 }
 
-.project-search-popover {
-  position: absolute;
-  top: calc(100% + 4px);
-  left: 0;
-  width: min(360px, 80vw);
-  max-height: 420px;
-  overflow-y: auto;
-  padding: 4px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.32);
-  z-index: 60;
+.cal-event-form {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  /* Scrolling is the dialog's `.dialog-scroll` frame now (one scroll region, and
+     the scrollbar clears the rounded corners); the form no longer scrolls itself. */
 }
 
-.project-search-row {
-  width: 100%;
+.cal-field {
   display: flex;
   flex-direction: column;
-  gap: 2px;
-  padding: 7px 8px;
-  border: 1px solid transparent;
-  border-radius: 0;
-  background: var(--control-bg);
+  gap: 3px;
+  min-width: 0;
+  flex: 1;
+}
+
+.cal-field-label {
+  font-size: 10px;
+  font-weight: 650;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.cal-field-row {
+  display: flex;
+  gap: 10px;
+}
+
+.cal-datetime {
+  display: flex;
+  gap: 5px;
+}
+
+.cal-datetime .cal-input {
+  flex: 1;
+  min-width: 0;
+}
+
+.cal-check-row {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 12px;
   color: var(--text-primary);
-  text-align: left;
   cursor: pointer;
 }
 
-.project-search-row:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+.cal-section {
+  border-top: 1px solid var(--border-subtle);
+  padding-top: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
 }
 
-.project-search-row small {
-  color: var(--text-muted);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+.cal-section-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
 }
 
-.project-search-empty {
-  padding: 8px;
+.cal-rule-summary {
+  margin-left: auto;
+  font-size: 11px;
   color: var(--text-muted);
-  font-size: 12px;
 }
 
-.project-switcher-add-wrap {
-  position: relative;
-  flex-shrink: 0;
+.cal-repeat {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding-left: 22px;
 }
 
-.project-switcher-add-menu {
-  position: absolute;
-  right: 0;
-  top: calc(100% + 4px);
-  min-width: 150px;
+.cal-weekdays {
   display: flex;
-  flex-direction: column;
-  gap: 2px;
-  padding: 4px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.32);
-  z-index: 60;
+  gap: 3px;
 }
 
-.project-switcher-add-menu button {
-  border: 1px solid transparent;
-  border-radius: 0;
-  padding: 7px 9px;
+.cal-weekday-btn {
+  width: 26px;
+  height: 26px;
+  font-size: 11px;
   background: var(--control-bg);
-  color: var(--text-primary) !important;
-  -webkit-text-fill-color: var(--text-primary);
-  text-align: left;
+  color: var(--text-secondary);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius);
   cursor: pointer;
 }
 
-.project-switcher-add-menu button:hover {
-  background: var(--control-hover-bg);
-  color: var(--text-primary) !important;
-  -webkit-text-fill-color: var(--text-primary);
+.cal-weekday-btn:hover {
   border-color: var(--accent);
 }
 
-.modal-backdrop {
-  position: fixed;
-  inset: 0;
-  z-index: 100;
+.cal-weekday-on {
+  background: var(--accent);
+  color: var(--accent-contrast);
+  border-color: var(--accent);
+}
+
+.cal-alarm-row {
   display: flex;
   align-items: center;
-  justify-content: center;
-  background: rgba(0, 0, 0, 0.35);
+  gap: 8px;
 }
 
-.project-dialog {
-  width: min(680px, calc(100vw - 32px));
-  max-height: min(820px, calc(100vh - 40px));
-  overflow-y: auto;
+.cal-alarm-row .cal-input {
+  flex: 1;
+  min-width: 0;
+}
+
+.cal-form-actions {
   display: flex;
-  flex-direction: column;
-  gap: 12px;
-  padding: 22px 24px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.42);
+  align-items: center;
+  gap: 8px;
+  padding-top: 4px;
 }
 
-.settings-backdrop {
-  align-items: flex-end;
-  justify-content: flex-end;
-  padding: 0 54px 56px 0;
-  background: transparent;
+.cal-scope-ask {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
 }
 
-.settings-dialog {
-  width: min(560px, calc(100vw - 32px));
-  max-height: min(720px, calc(100vh - 96px));
-  overflow-y: auto;
+/* ── Reminder popup ──────────────────────────────────────────────────────── */
+
+/* Bottom-right, above everything, and NOT a backdrop — a reminder must be
+   dismissible without blocking whatever the user was doing. */
+.cal-alarm-popup {
+  position: fixed;
+  right: 18px;
+  bottom: 18px;
+  z-index: 120;
+  width: min(420px, calc(100vw - 36px));
+  max-height: min(60vh, 560px);
   display: flex;
   flex-direction: column;
-  gap: 12px;
-  padding: 18px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.42);
+  background: var(--bg-elevated);
+  color: var(--text-primary);
+  border: 1px solid var(--accent);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow-3);
 }
 
-.settings-title-row {
+.cal-alarm-head {
   display: flex;
   align-items: center;
-  gap: 12px;
+  justify-content: space-between;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.cal-alarm-title {
+  font-size: 13px;
+  font-weight: 650;
+  color: var(--accent);
+}
+
+.cal-alarm-list {
+  overflow-y: auto;
+}
+
+.cal-alarm-popup .cal-alarm-row {
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 6px;
+  padding: 10px 12px;
   border-bottom: 1px solid var(--border-subtle);
-  padding-bottom: 10px;
 }
 
-.settings-title-row h2 {
-  flex: 1;
-  font-size: 16px;
-  font-weight: 650;
-  color: var(--text-primary);
+.cal-alarm-popup .cal-alarm-row:last-child {
+  border-bottom: none;
 }
 
-.dialog-close-btn,
-.settings-title-row button,
-.settings-link-row button,
-.global-app-settings-row button,
-.filetype-settings-row button {
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  background: var(--control-bg);
+.cal-alarm-event {
+  font-size: 13px;
+  font-weight: 650;
   color: var(--text-primary);
-  cursor: pointer;
-  padding: 7px 10px;
 }
 
-.dialog-close-btn:hover,
-.settings-title-row button:hover,
-.settings-link-row button:hover,
-.global-app-settings-row button:hover,
-.filetype-settings-row button:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+.cal-alarm-when {
+  font-size: 11px;
+  color: var(--text-muted);
 }
 
-.settings-row,
-.settings-switch-row {
-  min-height: 34px;
+.cal-alarm-actions {
   display: flex;
   align-items: center;
-  gap: 12px;
+  gap: 4px;
+  flex-wrap: wrap;
 }
 
-.settings-row label,
-.settings-switch-row span {
-  flex: 1;
-  color: var(--text-primary);
+.cal-alarm-snooze-label {
+  font-size: 10px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  margin-right: 2px;
 }
 
-.settings-row select,
-.settings-field input,
-.global-app-settings-row input[type="text"],
-.global-app-settings-row input:not([type]),
-.filetype-settings-row input {
-  height: 34px;
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  padding: 0 9px;
+.cal-alarm-actions .cal-btn-primary {
+  margin-left: auto;
 }
 
-/* Group L / #62 — keyboard-shortcut rebinding rows. */
-.shortcut-row .settings-role-label {
-  flex: 1;
+/* ── Usage recap (StatsRecap) ───────────────────────────────────────────────
+   Shares the canonical dialog surface (see the .project-dialog/.settings-dialog
+   rule) and the canonical header/section-title/help classes; only its own
+   sizing, the period switch and the stat primitives live here.
+
+   The stat tile (.stats-metric) and the bar rows deliberately mirror
+   .network-metric — one visual language for "a number Eldrun measured". */
+.stats-dialog {
+  width: min(760px, calc(100vw - 32px));
+  max-height: min(860px, calc(100vh - 40px));
+  padding: 16px 18px 18px;
+  /* A portaled dialog inherits nothing from body, which has no color set — so
+     this must be explicit or the whole recap renders black-on-panel. */
   color: var(--text-primary);
 }
 
-.shortcut-capture-btn {
-  min-width: 150px;
-  height: 30px;
-  border: 1px solid var(--control-border);
+.stats-window-label {
+  margin: -4px 0 0;
+}
+
+/* Day / Week / Month, in the title row. */
+.stats-period-switch {
+  display: flex;
+  gap: 2px;
+  margin-left: auto;
+}
+.stats-period-btn {
+  padding: 4px 12px;
+  font-size: 12px;
+  color: var(--text-secondary);
   background: var(--control-bg);
-  color: var(--text-primary);
-  font-family: var(--font-mono, monospace);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius);
   cursor: pointer;
 }
-
-.shortcut-capture-btn.capturing {
-  border-color: var(--accent, #4f8cff);
-  color: var(--accent, #4f8cff);
+.stats-period-btn:hover {
+  background: var(--control-hover-bg);
 }
-
-.shortcut-row .settings-back-btn:disabled {
-  opacity: 0.4;
-  cursor: default;
+.stats-period-btn.active {
+  color: var(--bg-main);
+  background: var(--accent);
+  border-color: var(--accent);
 }
 
-.settings-row select,
-.project-dialog select {
-  min-width: 160px;
-  appearance: none;
-  background-color: var(--control-bg);
-  background-image:
-    linear-gradient(45deg, transparent 50%, var(--text-primary) 50%),
-    linear-gradient(135deg, var(--text-primary) 50%, transparent 50%);
-  background-position:
-    calc(100% - 15px) 14px,
-    calc(100% - 10px) 14px;
-  background-size: 5px 5px, 5px 5px;
-  background-repeat: no-repeat;
-  cursor: pointer;
-  padding-right: 32px;
+.stats-headline {
+  margin: 0;
+  font-size: 15px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+.stats-headline strong {
+  color: var(--text-primary);
+  font-weight: 650;
 }
 
-.settings-row select:hover,
-.settings-row select:focus,
-.settings-field input:hover,
-.settings-field input:focus,
-.global-app-settings-row input:hover,
-.global-app-settings-row input:focus,
-.filetype-settings-row input:hover,
-.filetype-settings-row input:focus,
-.project-dialog input:hover,
-.project-dialog input:focus,
-.project-dialog textarea:hover,
-.project-dialog textarea:focus,
-.project-dialog select:hover,
-.project-dialog select:focus {
-  border-color: var(--accent);
-  outline: none;
+.stats-empty {
+  margin: 8px 0 0;
+  color: var(--text-muted);
+  line-height: 1.5;
 }
 
-.settings-row select option,
-.project-dialog select option,
-.file-browser-actions select option {
-  background: var(--bg-panel);
+/* Stat tiles — the .network-metric primitive, reused. */
+.stats-metrics {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  gap: 8px;
+}
+.stats-metric {
+  display: grid;
+  gap: 4px;
+  padding: 11px 13px;
+  background: var(--bg-main);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius);
+}
+.stats-metric > span {
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-muted);
+}
+.stats-metric > strong {
+  font-size: 19px;
+  font-weight: 650;
   color: var(--text-primary);
 }
+.stats-metric > small {
+  font-size: 11px;
+  color: var(--text-muted);
+}
 
-.settings-field {
+/* Ranked bars (agents by model, time by project). */
+.stats-bars {
   display: flex;
   flex-direction: column;
   gap: 5px;
-  color: var(--text-secondary);
+}
+.stats-bar-row {
+  display: grid;
+  grid-template-columns: minmax(80px, 150px) 1fr auto;
+  align-items: center;
+  gap: 10px;
   font-size: 12px;
 }
-
-.settings-section-title {
-  margin-top: 2px;
-  padding-top: 12px;
-  border-top: 1px solid var(--border-subtle);
+.stats-bar-label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  color: var(--text-secondary);
+}
+.stats-bar-track {
+  height: 8px;
+  background: var(--control-bg);
+  border-radius: var(--radius);
+}
+.stats-bar-fill {
+  display: block;
+  height: 100%;
+  background: var(--accent);
+  border-radius: var(--radius);
+}
+.stats-bar-value {
+  font-variant-numeric: tabular-nums;
   color: var(--text-primary);
-  font-weight: 650;
 }
 
-.settings-link-row {
+/* Hour-of-day sparkline. */
+.stats-spark-wrap {
   display: flex;
-  gap: 8px;
-  padding-top: 4px;
+  flex-direction: column;
+  gap: 5px;
+}
+.stats-spark {
+  width: 100%;
+  height: 60px;
+}
+.stats-spark-bar {
+  fill: var(--accent-secondary);
+}
+.stats-spark-bar.busiest {
+  fill: var(--accent);
+}
+.stats-spark-legend {
+  display: flex;
+  justify-content: space-between;
+  font-size: 11px;
+  color: var(--text-muted);
 }
 
-.settings-help {
-  color: var(--text-secondary);
-  font-size: 12px;
-  line-height: 1.35;
+.stats-auto-row {
+  margin-top: 4px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border-subtle);
 }
 
-.help-section {
+/* ── Native presenter ("deck") ───────────────────────────────────────────────
+   The experimental presentation editor (docs/deck_presenter_plan.md). Objects
+   render as DOM/SVG over the base page canvas rather than into it, so selection
+   outlines, handles and z-order come from the browser.
+
+   Two constraints from this codebase are baked in below. Nothing here animates a
+   BLURRED box-shadow — under software rendering (DMABUF is off) that is a paint
+   killer, so the selection uses outlines and flat borders. And every gesture is
+   pointer-based, so the interactive bits set `touch-action: none` rather than
+   relying on drag events WebKitGTK does not deliver. */
+
+.deck-view {
   display: flex;
   flex-direction: column;
-  gap: 8px;
+  height: 100%;
+  outline: none;
 }
 
-.help-list {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-  margin: 0;
+.deck-toolbar-title {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 0 8px;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  white-space: nowrap;
 }
 
-.help-row {
-  display: grid;
-  grid-template-columns: 160px 1fr;
-  gap: 12px;
-  align-items: baseline;
+.deck-save-state {
+  padding: 0 10px;
+  font-size: 11px;
+  color: var(--text-muted);
+  white-space: nowrap;
 }
 
-.help-row dt {
-  color: var(--text-primary);
-  font-weight: 600;
-  font-size: 12px;
+.deck-body {
+  display: flex;
+  flex: 1;
+  min-height: 0;
 }
 
-.help-row dd {
-  margin: 0;
-  color: var(--text-secondary);
-  font-size: 12px;
-  line-height: 1.4;
+/* --- slide rail --- */
+
+.deck-rail {
+  /* Width is set inline (user-resizable, persisted per tab) — no fixed value
+     here, just the flex behaviour that keeps it from stretching or shrinking
+     under the stage. */
+  flex: 0 0 auto;
+  overflow-y: auto;
+  padding: 8px 6px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  background: var(--bg-panel);
 }
 
-@media (max-width: 520px) {
-  .help-row {
-    grid-template-columns: 1fr;
-    gap: 2px;
-  }
+/* Drag handle between the rail and the stage. A flex sibling, not an overlay —
+   the rail's own width is exactly what it says, with nothing absolutely
+   positioned over its edge to get the hit-test wrong. */
+.deck-rail-resize {
+  flex: 0 0 auto;
+  width: 5px;
+  cursor: col-resize;
+  touch-action: none;
+  background: var(--border-color);
+}
+.deck-rail-resize:hover {
+  background: var(--accent);
 }
 
-.project-settings-dialog {
-  width: min(460px, calc(100vw - 32px));
+.deck-rail-head {
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-secondary);
+  padding: 0 2px 2px;
 }
 
-.project-ending-form {
+.deck-rail-item {
+  position: relative;
   display: flex;
   align-items: center;
-  gap: 8px;
-}
-
-.project-ending-form input {
-  flex: 1;
-  height: 34px;
-  border: 1px solid var(--control-border);
-  border-radius: 0;
+  justify-content: center;
+  aspect-ratio: 16 / 9; /* fallback before the deck's own page box is known; the
+                            rendered item overrides this inline per-deck */
+  overflow: hidden;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
   background: var(--control-bg);
-  color: var(--text-primary);
-  padding: 0 9px;
+  color: var(--text-secondary);
+  font-size: 11px;
+  cursor: pointer;
+  transition: background var(--transition), border-color var(--transition);
 }
 
-.project-ending-form input:hover,
-.project-ending-form input:focus {
-  border-color: var(--accent);
-  outline: none;
+.deck-rail-item:hover {
+  background: var(--control-hover-bg);
 }
 
-.project-ending-form button {
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  background: var(--control-bg);
+.deck-rail-item.active {
+  border-color: var(--accent);
+  background: var(--pill-active-bg);
   color: var(--text-primary);
-  cursor: pointer;
-  padding: 7px 10px;
 }
 
-.project-ending-form button:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+/* The slide preview. Sits behind the number/badges (z-order = paint order, no
+   z-index needed since it's simply first in the DOM), filling the item box the
+   same way `.deck-stage-canvas` fills the stage. */
+.deck-rail-thumb {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  display: block;
+  border-radius: var(--radius-sm);
+  background: #ffffff;
 }
 
-.settings-list.project-ending-list {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(96px, 1fr));
-  gap: 4px 10px;
-  max-height: min(360px, calc(100vh - 300px));
-  overflow-y: auto;
-  padding-right: 2px;
+.deck-rail-num {
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  padding: 0 3px;
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--bg-header-solid) 75%, transparent);
+  font-variant-numeric: tabular-nums;
 }
 
-.project-ending-toggle {
-  min-height: 32px;
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  cursor: pointer;
-  padding: 6px 8px;
-  font-family: inherit;
-  font-size: 12px;
-  text-align: center;
+.deck-rail-badge,
+.deck-rail-gif {
+  position: absolute;
+  bottom: 2px;
+  font-size: 9px;
+  line-height: 1;
+  padding: 1px 3px;
+  border-radius: var(--radius-full);
+  background: var(--accent);
+  color: var(--bg-main);
 }
 
-.project-ending-toggle:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+.deck-rail-badge { right: 2px; }
+.deck-rail-gif { left: 2px; background: var(--accent-secondary); }
+
+.deck-rail-actions {
+  position: absolute;
+  bottom: 2px;
+  left: 50%;
+  transform: translateX(-50%);
+  display: flex;
+  gap: 2px;
+  opacity: 0;
+  transition: opacity var(--transition);
 }
 
-.project-ending-toggle.is-hidden {
-  color: var(--text-muted);
-  background: var(--bg-secondary);
-  border-color: var(--border-subtle);
+.deck-rail-item:hover .deck-rail-actions,
+.deck-rail-item.active .deck-rail-actions,
+.deck-rail-actions:focus-within {
+  opacity: 1;
 }
 
-.settings-empty {
-  color: var(--text-muted);
-  font-size: 12px;
+.deck-rail-act-btn {
+  width: 16px;
+  height: 14px;
+  padding: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 8px;
+  line-height: 1;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
+  background: var(--bg-header-solid);
+  color: var(--text-secondary);
+  cursor: pointer;
 }
 
-.settings-error {
-  color: var(--danger, #f85149);
-  font-size: 12px;
-  word-break: break-word;
+.deck-rail-act-btn:hover:not(:disabled) {
+  background: var(--control-hover-bg);
+  color: var(--text-primary);
 }
 
-.settings-list {
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
+.deck-rail-act-btn:disabled {
+  opacity: 0.3;
+  cursor: default;
 }
 
-.global-app-settings-row,
-.filetype-settings-row {
-  display: grid;
+/* --- stage --- */
+
+.deck-stage {
+  flex: 1;
+  min-width: 0;
+  display: flex;
   align-items: center;
-  gap: 8px;
+  justify-content: center;
+  overflow: hidden;
+  background: var(--bg-main);
 }
 
-.global-app-settings-row {
-  grid-template-columns: 18px 22px 104px minmax(120px, 1fr) auto;
+.deck-stage-empty {
+  color: var(--text-muted);
+  font-size: 12px;
+  padding: 24px;
+  text-align: center;
 }
 
-.filetype-settings-row {
-  grid-template-columns: 70px minmax(120px, 1fr) auto auto;
+.deck-stage-page {
+  position: relative;
+  background: #ffffff;
+  box-shadow: var(--shadow-2);
+  touch-action: none;
+  user-select: none;
 }
 
-.filetype-settings-row:last-child {
-  grid-template-columns: 70px minmax(120px, 1fr) auto;
-  border-top: 1px solid var(--border-subtle);
-  padding-top: 8px;
+.deck-stage-canvas {
+  position: absolute;
+  inset: 0;
+  display: block;
 }
 
-.settings-role-icon {
-  text-align: center;
+/* The safe area. Deliberately faint: it is a snapping target and a hint, not a
+   frame anyone should be reading around. */
+.deck-stage-margin {
+  position: absolute;
+  border: 1px dashed color-mix(in srgb, var(--accent) 35%, transparent);
+  pointer-events: none;
 }
 
-.settings-role-label {
-  color: var(--text-primary);
-}
+/* --- objects --- */
 
-.project-dialog h2 {
-  font-size: 16px;
-  font-weight: 650;
+.deck-object {
+  pointer-events: auto;
+  cursor: move;
 }
 
-[data-theme="fancy_dark"] .project-dialog h2 {
-  font-size: 18px;
-  font-weight: 700;
-  letter-spacing: 0.3px;
-  padding-bottom: 10px;
-  border-bottom: 1px solid var(--border-color);
-  background: linear-gradient(90deg, var(--accent) 0%, var(--accent-secondary) 100%);
-  -webkit-background-clip: text;
-  background-clip: text;
-  -webkit-text-fill-color: transparent;
-  color: transparent;
+.deck-object.locked {
+  cursor: default;
 }
 
-.project-dialog label {
-  display: flex;
-  flex-direction: column;
-  gap: 5px;
-  color: var(--text-secondary);
-  font-size: 12px;
+.deck-object.selected {
+  /* Outline, not box-shadow: it needs no blur and costs no paint. */
+  outline: 1px solid var(--accent);
+  outline-offset: 0;
 }
 
-.project-dialog input,
-.project-dialog select,
-.project-dialog textarea {
-  height: 34px;
-  border: 1px solid var(--control-border);
-  border-radius: 0;
+.deck-object-missing {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  border: 1px dashed var(--border-color);
+  border-radius: var(--radius-sm);
   background: var(--control-bg);
-  color: var(--text-primary);
-  padding: 0 8px;
+  color: var(--text-muted);
+  font-size: 10px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  padding: 0 4px;
 }
 
-.project-dialog textarea {
-  min-height: 72px;
-  padding: 8px;
-  resize: vertical;
+.deck-text-line {
+  display: flex;
+  gap: 0.4em;
+  align-items: baseline;
 }
 
-.project-description-field {
-  gap: 6px !important;
+.deck-text-marker {
+  flex: 0 0 auto;
+  opacity: 0.85;
+  font-variant-numeric: tabular-nums;
 }
 
-.project-description-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 10px;
+/* --- selection, handles, marquee --- */
+
+.deck-selection {
+  position: absolute;
+  border: 1px solid var(--accent);
+  pointer-events: none;
 }
 
-.project-description-header span {
-  min-width: 0;
+.deck-handle {
+  position: absolute;
+  width: 8px;
+  height: 8px;
+  margin: -4px 0 0 -4px;
+  background: var(--bg-main);
+  border: 1.5px solid var(--accent);
+  border-radius: 2px;
+  pointer-events: auto;
+  touch-action: none;
 }
 
-.project-description-header select {
-  width: auto;
-  min-width: 118px;
-  max-width: 160px;
-  height: 28px;
+.deck-handle-nw { left: 0;    top: 0;    cursor: nwse-resize; }
+.deck-handle-n  { left: 50%;  top: 0;    cursor: ns-resize; }
+.deck-handle-ne { left: 100%; top: 0;    cursor: nesw-resize; }
+.deck-handle-e  { left: 100%; top: 50%;  cursor: ew-resize; }
+.deck-handle-se { left: 100%; top: 100%; cursor: nwse-resize; }
+.deck-handle-s  { left: 50%;  top: 100%; cursor: ns-resize; }
+.deck-handle-sw { left: 0;    top: 100%; cursor: nesw-resize; }
+.deck-handle-w  { left: 0;    top: 50%;  cursor: ew-resize; }
+
+.deck-rotate {
+  position: absolute;
+  left: 50%;
+  top: -22px;
+  width: 10px;
+  height: 10px;
+  margin-left: -5px;
+  border: 1.5px solid var(--accent);
+  border-radius: var(--radius-full);
+  background: var(--bg-main);
+  cursor: grab;
+  pointer-events: auto;
+  touch-action: none;
 }
 
-.folder-picker-row {
-  display: flex;
-  align-items: center;
-  gap: 8px;
+.deck-marquee {
+  position: absolute;
+  border: 1px dashed var(--accent);
+  background: color-mix(in srgb, var(--accent) 12%, transparent);
+  pointer-events: none;
 }
 
-/* OpenVPN activation password prompt */
-.vpn-prompt-dialog {
-  max-width: 380px;
+/* --- alignment guides ---
+   Colour-coded by WHY the snap fired, because a guide is evidence: a snap that
+   engages for the wrong reason should be visible, not merely felt. */
+
+.deck-guides {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  overflow: visible;
 }
 
-.vpn-prompt-text {
-  color: var(--text-primary);
-  margin: 0 0 8px;
+.deck-guide {
+  stroke-width: 1;
+  shape-rendering: crispEdges;
 }
 
-.vpn-prompt-actions {
+.deck-guide-page    { stroke: var(--accent); }
+.deck-guide-margin  { stroke: var(--accent); stroke-dasharray: 3 3; }
+.deck-guide-object  { stroke: var(--accent-secondary); }
+.deck-guide-spacing { stroke: var(--success); stroke-dasharray: 2 3; }
+.deck-guide-size    { stroke: var(--warning); stroke-dasharray: 4 2; }
+
+/* --- deck: inspector --- */
+
+.deck-inspector {
+  flex: 0 0 auto;
+  width: 232px;
+  overflow-y: auto;
+  padding: 10px;
   display: flex;
-  justify-content: flex-end;
+  flex-direction: column;
   gap: 8px;
-  margin-top: 14px;
+  background: var(--bg-panel);
+  border-left: 1px solid var(--border-color);
+  font-size: 11px;
 }
 
-.vpn-prompt-actions button {
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  padding: 7px 12px;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  cursor: pointer;
+.deck-inspector-empty {
+  margin: 0;
+  color: var(--text-muted);
+  line-height: 1.5;
 }
 
-.vpn-prompt-actions button.primary {
-  background: var(--accent, var(--control-border));
-  color: var(--text-primary);
+.deck-inspector-head {
+  font-weight: 600;
+  color: var(--text-secondary);
+  text-transform: capitalize;
+  padding-bottom: 6px;
+  border-bottom: 1px solid var(--border-subtle);
 }
 
-.vpn-toggle {
-  margin-bottom: 4px;
+.deck-field {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  min-width: 0;
+  flex: 1;
 }
 
-.folder-picker-row span {
-  flex: 1;
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  color: var(--text-primary);
+.deck-field > span {
+  color: var(--text-muted);
+  font-size: 10px;
 }
 
-.folder-picker-row button,
-.project-dialog-actions button {
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  padding: 7px 10px;
-  background: var(--control-bg);
+.deck-field input,
+.deck-field select,
+.deck-field textarea {
+  width: 100%;
+  min-width: 0;
+  padding: 3px 5px;
+  font: inherit;
   color: var(--text-primary);
-  cursor: pointer;
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
 }
 
-.folder-picker-row button:hover,
-.project-dialog-actions button:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+.deck-field textarea {
+  resize: vertical;
+  font-family: var(--font-sans);
 }
 
-.project-dialog-actions button:last-child {
-  background: var(--accent);
-  color: var(--bg-main);
-  border-color: var(--accent);
+.deck-field-row {
+  display: flex;
+  gap: 6px;
+  align-items: flex-end;
 }
 
-.project-dialog-actions button:disabled {
-  opacity: 0.55;
-  cursor: default;
-}
+.deck-field-narrow { flex: 0 1 68px; }
+.deck-field-wide { flex: 1 1 100%; }
 
-.project-dialog-path {
-  min-height: 16px;
-  color: var(--text-muted);
-  font-size: 12px;
-  word-break: break-all;
+.deck-field-color { flex: 0 0 auto; }
+.deck-field-color input[type="color"] {
+  width: 28px;
+  height: 24px;
+  padding: 1px;
+  cursor: pointer;
 }
 
-.project-dialog-error {
-  color: var(--danger);
-  font-size: 12px;
-  word-break: break-word;
+.deck-toggle {
+  flex: 0 0 auto;
+  min-width: 26px;
+  height: 24px;
+  padding: 0 5px;
+  color: var(--text-secondary);
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  transition: background var(--transition), color var(--transition);
 }
 
-.scaffold-popover {
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-  padding: 12px;
-  background: var(--bg-main);
-  border: 1px solid var(--border-subtle);
+.deck-toggle:hover { background: var(--control-hover-bg); }
+
+.deck-toggle.active {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: var(--bg-main);
 }
 
-.scaffold-popover-title {
+.deck-inspector-btn {
+  flex: 1;
+  padding: 4px 8px;
   color: var(--text-primary);
-  font-size: 13px;
-  font-weight: 650;
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
 }
 
-.scaffold-steps {
-  margin: 0;
-  padding-left: 18px;
-  color: var(--text-secondary);
-  font-size: 12px;
+.deck-inspector-btn:hover { background: var(--control-hover-bg); }
+.deck-inspector-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
 }
 
-.scaffold-steps li + li {
-  margin-top: 3px;
+.deck-tex-field {
+  padding-top: 6px;
+  border-top: 1px solid var(--border-subtle);
 }
 
-.manual-validation-row {
-  min-height: 28px;
-  flex-direction: row !important;
-  align-items: center;
-  gap: 8px !important;
-  color: var(--text-primary) !important;
-}
+/* --- notes mode --- */
 
-.manual-validation-row input[type="checkbox"],
-.skip-scaffold-row input[type="checkbox"] {
-  width: 16px;
-  height: 16px;
-  padding: 0;
-  flex: 0 0 auto;
-  accent-color: var(--accent);
+.deck-notes {
+  width: 260px;
 }
 
-.skip-scaffold-row {
-  min-height: 28px;
-  flex-direction: row !important;
-  align-items: center;
-  gap: 8px !important;
-  color: var(--text-primary) !important;
+.deck-notes-textarea {
+  flex: 1;
+  min-height: 0;
+  width: 100%;
+  padding: 8px;
+  font: inherit;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--text-primary);
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
+  resize: none;
 }
 
-.scaffold-fill-all-row {
-  display: grid !important;
-  grid-template-columns: minmax(0, 1fr) minmax(160px, 210px);
-  gap: 10px !important;
-  align-items: center;
-  color: var(--text-primary) !important;
-}
+/* --- TeX-figures list mode --- */
 
-.scaffold-fill-all-row span {
-  font-size: 12px;
-  font-weight: 650;
+.deck-tex-panel {
+  width: 260px;
+  gap: 4px;
 }
 
-.scaffold-list {
+.deck-tex-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
   display: flex;
   flex-direction: column;
   gap: 6px;
 }
 
-.scaffold-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) minmax(160px, 210px);
-  gap: 10px;
-  align-items: center;
-  padding: 7px 8px;
+.deck-tex-list-item {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 6px;
   border: 1px solid var(--border-subtle);
-  background: var(--control-bg);
+  border-radius: var(--radius-sm);
 }
 
-.scaffold-file {
-  min-width: 0;
+.deck-tex-list-jump {
   display: flex;
   flex-direction: column;
+  align-items: flex-start;
   gap: 2px;
+  padding: 0;
+  color: inherit;
+  background: none;
+  border: none;
+  cursor: pointer;
+  text-align: left;
 }
 
-.scaffold-file span {
-  color: var(--text-primary);
-  overflow-wrap: anywhere;
+.deck-tex-list-slide {
+  font-size: 10px;
+  font-weight: 600;
+  color: var(--text-secondary);
 }
 
-.scaffold-file small,
-.scaffold-empty {
-  color: var(--text-muted);
-  font-size: 12px;
+.deck-tex-list-name {
+  font-size: 11px;
+  color: var(--text-primary);
+  word-break: break-all;
 }
 
-.scaffold-row select:disabled {
-  opacity: 0.62;
-  cursor: default;
+.deck-tex-list-actions {
+  display: flex;
+  gap: 6px;
+}
+.deck-tex-list-actions .deck-inspector-btn {
+  font-size: 10px;
+  padding: 3px 6px;
 }
 
-.scaffold-row-status {
-  color: var(--text-muted);
-  font-size: 12px;
-  text-align: right;
+/* A text box shorter than its text. A hairline, not a banner: it is an
+   authoring nudge, and the author is looking at the box already. */
+.deck-text-overflow {
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  height: 2px;
+  background: var(--warning);
+  pointer-events: none;
 }
 
-@media (max-width: 640px) {
-  .scaffold-fill-all-row,
-  .scaffold-row {
-    grid-template-columns: 1fr;
-  }
+/* --- deck: icon picker --- */
 
-  .scaffold-row-status {
-    text-align: left;
-  }
+.deck-icon-picker {
+  width: min(560px, 100vw - 32px);
+  max-height: min(70vh, 620px);
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
 }
 
-.ssh-optional-hint {
-  color: var(--text-muted);
-  font-weight: 400;
-  font-size: 12px;
+.deck-icon-search {
+  width: 100%;
+  padding: 6px 10px;
+  font: inherit;
+  color: var(--text-primary);
+  background: var(--control-bg);
+  border: 1px solid var(--control-border);
+  border-radius: var(--radius-sm);
 }
 
-.remote-project-toggle {
+.deck-icon-cats {
   display: flex;
-  flex-direction: row;
-  align-items: center;
-  gap: 8px;
-  font-weight: 500;
-  cursor: pointer;
+  flex-wrap: wrap;
+  gap: 4px;
 }
 
-.remote-project-toggle input[type="checkbox"] {
-  width: auto;
-  margin: 0;
+.deck-icon-cat {
+  padding: 3px 9px;
+  font-size: 11px;
+  color: var(--text-secondary);
+  background: var(--pill-bg);
+  border: 1px solid transparent;
+  border-radius: var(--radius-full);
+  cursor: pointer;
+  transition: background var(--transition), color var(--transition);
 }
 
-.ssh-connect-fields {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-  padding: 10px;
-  background: var(--bg-main);
-  border: 1px solid var(--border-subtle);
-}
+.deck-icon-cat:hover { background: var(--pill-hover-bg); }
 
-.ssh-tooling-warning {
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-  padding: 8px 10px;
-  font-size: 12px;
-  color: var(--danger);
-  background: color-mix(in srgb, var(--danger) 12%, transparent);
-  border: 1px solid var(--danger);
-  border-radius: 4px;
-  word-break: break-word;
+.deck-icon-cat.active {
+  background: var(--pill-active-bg);
+  border-color: var(--pill-active-border);
+  color: var(--text-primary);
 }
 
-.ssh-address-input,
-.ssh-password-input {
+.deck-icon-grid {
   flex: 1;
-  min-width: 0;
-  width: 100%;
+  min-height: 0;
+  overflow-y: auto;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(76px, 1fr));
+  gap: 4px;
 }
 
-.remote-browser {
+.deck-icon-cell {
   display: flex;
   flex-direction: column;
-  gap: 8px;
-  padding: 10px;
-  background: var(--bg-main);
-  border: 1px solid var(--border-subtle);
-}
-
-.remote-browser-header {
-  display: flex;
   align-items: center;
-  gap: 8px;
+  gap: 4px;
+  padding: 8px 4px;
+  color: var(--text-secondary);
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  transition: background var(--transition), border-color var(--transition);
 }
 
-.remote-up-btn {
-  flex: 0 0 auto;
+.deck-icon-cell:hover {
+  background: var(--control-hover-bg);
+  border-color: var(--border-color);
+  color: var(--text-primary);
 }
 
-.remote-breadcrumb {
-  flex: 1;
-  min-width: 0;
+.deck-icon-label {
+  font-size: 9px;
+  line-height: 1.2;
+  text-align: center;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
-  color: var(--text-primary);
-  font-size: 12px;
+  max-width: 100%;
 }
 
-.remote-browser-header button {
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  padding: 5px 9px;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  cursor: pointer;
+.deck-icon-empty {
+  grid-column: 1 / -1;
+  padding: 24px;
+  text-align: center;
+  color: var(--text-muted);
+  font-size: 11px;
 }
 
-.remote-browser-header button:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+/* --- deck: animate mode --- */
+
+.deck-animate .deck-inspector-head:not(:first-child) {
+  margin-top: 6px;
 }
 
-.remote-list {
-  display: flex;
-  flex-direction: column;
-  max-height: 200px;
-  overflow-y: auto;
-  border: 1px solid var(--border-subtle);
+.deck-animate-file {
+  padding: 4px 6px;
+  font-size: 10px;
+  color: var(--text-secondary);
   background: var(--control-bg);
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
-.remote-entry {
+/* A numbered badge on every object with a build step. Without it the reveal
+   order is invisible and the mode is unusable. */
+.deck-build-badge {
+  position: absolute;
+  transform: translate(-50%, -50%);
+  min-width: 15px;
+  height: 15px;
+  padding: 0 3px;
   display: flex;
   align-items: center;
-  gap: 8px;
-  padding: 5px 8px;
-  font-size: 13px;
+  justify-content: center;
+  font-size: 9px;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  color: var(--bg-main);
+  background: var(--accent-secondary);
+  border-radius: var(--radius-full);
+  pointer-events: none;
 }
 
-.remote-entry + .remote-entry {
-  border-top: 1px solid var(--border-subtle);
-}
+/* --- deck: presenter --- */
 
-.remote-entry.is-dir {
-  color: var(--text-primary);
-  cursor: pointer;
+.deck-presenter {
+  position: fixed;
+  inset: 0;
+  z-index: 200;
+  display: flex;
+  background: #000;
+  outline: none;
 }
 
-.remote-entry.is-dir:hover {
-  background: var(--control-hover-bg);
+.deck-presenter-main {
+  position: relative;
+  flex: 1;
+  min-width: 0;
+  display: flex;
 }
 
-.remote-entry.is-file {
-  color: var(--text-muted);
-  cursor: default;
+.deck-presenter-stage {
+  flex: 1;
+  min-width: 0;
+  display: flex;
 }
 
-.remote-entry-icon {
-  flex: 0 0 auto;
-  color: var(--text-muted);
+.deck-presenter-fit {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
 }
 
-.remote-entry-name {
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+.deck-presenter-page {
+  position: relative;
+  background: #fff;
 }
 
-.remote-chosen {
-  color: var(--text-muted);
-  font-size: 12px;
-  word-break: break-all;
+.deck-presenter-gif {
+  flex: 1;
+  width: 100%;
+  height: 100%;
+  display: block;
 }
 
-.project-dialog-actions {
-  display: flex;
-  justify-content: flex-end;
-  gap: 8px;
-  margin-top: 4px;
+.deck-presenter-loading {
+  align-items: center;
+  justify-content: center;
+  color: #fff;
+  font-size: 13px;
 }
 
-/* ── Orbit spinner (active-tracking indicator) ───────────────────────── */
-@keyframes orbit-spin {
-  from { transform: rotate(0deg); }
-  to   { transform: rotate(360deg); }
+.deck-presenter-blank {
+  position: absolute;
+  inset: 0;
+  z-index: 60;
 }
 
-.orbit-spinner {
-  display: inline-block;
-  vertical-align: middle;
-  margin-left: 5px;
-  animation: orbit-spin 2s linear infinite;
-  flex-shrink: 0;
+.deck-presenter-blank.is-black { background: #000; }
+.deck-presenter-blank.is-white { background: #fff; }
+
+.deck-presenter-goto {
+  position: absolute;
+  left: 50%;
+  bottom: 64px;
+  transform: translateX(-50%);
+  z-index: 70;
+  padding: 6px 14px;
+  font-size: 13px;
+  color: #fff;
+  background: rgba(0, 0, 0, 0.72);
+  border-radius: var(--radius-full);
 }
 
-.orbit-dot {
-  fill: var(--accent);
+/* --- presenter: overview grid --- */
+
+.deck-presenter-grid {
+  position: absolute;
+  inset: 0;
+  z-index: 65;
+  overflow-y: auto;
+  padding: 24px;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
+  gap: 10px;
+  align-content: start;
+  background: rgba(0, 0, 0, 0.88);
 }
 
-/* Running-task indicator on a project pill — green to read as "live work". */
-.pill-running-spinner {
-  margin-left: 6px;
+.deck-presenter-grid-cell {
+  position: relative;
+  aspect-ratio: 16 / 9;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 15px;
+  color: rgba(255, 255, 255, 0.75);
+  background: rgba(255, 255, 255, 0.07);
+  border: 1px solid rgba(255, 255, 255, 0.16);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  transition: background var(--transition), border-color var(--transition);
 }
-.pill-running-spinner .orbit-dot {
-  fill: var(--success, #45c46a);
+
+.deck-presenter-grid-cell:hover {
+  background: rgba(255, 255, 255, 0.15);
+  color: #fff;
 }
 
-/* ── Activity calendar ───────────────────────────────────────────────── */
-.activity-calendar {
-  display: flex;
-  flex-direction: column;
-  gap: 6px;
-  user-select: none;
+.deck-presenter-grid-cell.active {
+  border-color: var(--accent);
+  color: #fff;
 }
 
-.activity-cell {
-  fill: var(--activity-0);
-  transition: opacity 0.1s;
+.deck-presenter-grid-note {
+  position: absolute;
+  right: 5px;
+  bottom: 5px;
+  width: 5px;
+  height: 5px;
+  border-radius: var(--radius-full);
+  background: var(--accent);
 }
-.activity-cell:hover { opacity: 0.8; }
-.activity-cell-0 { fill: var(--activity-0); }
-.activity-cell-1 { fill: var(--activity-1); }
-.activity-cell-2 { fill: var(--activity-2); }
-.activity-cell-3 { fill: var(--activity-3); }
-.activity-cell-4 { fill: var(--activity-4); }
-.activity-today  { stroke: var(--accent); stroke-width: 1.5; }
 
-/* ── Activity year selector ──────────────────────────────────────────── */
-.activity-years {
+/* --- presenter: notes column --- */
+
+.deck-presenter-notes {
+  flex: 0 0 auto;
+  width: 300px;
   display: flex;
-  gap: 4px;
-  flex-wrap: wrap;
-  margin-bottom: 8px;
+  flex-direction: column;
+  gap: 10px;
+  padding: 14px;
+  color: var(--text-primary);
+  background: var(--bg-panel);
+  border-left: 1px solid var(--border-color);
 }
 
-.activity-year-btn {
-  padding: 2px 8px;
-  border: 1px solid var(--control-border);
-  background: var(--control-bg);
-  color: var(--text-secondary);
+.deck-presenter-notes-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 8px;
   font-size: 11px;
-  cursor: pointer;
-  border-radius: 2px;
-  transition: background 0.1s, border-color 0.1s, color 0.1s;
+  color: var(--text-secondary);
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--border-subtle);
 }
 
-.activity-year-btn:hover {
-  background: var(--control-hover-bg);
-  border-color: var(--text-muted);
+.deck-presenter-timer {
+  font-family: var(--font-mono);
+  font-size: 15px;
   color: var(--text-primary);
+  font-variant-numeric: tabular-nums;
 }
 
-.activity-year-btn.selected {
-  background: var(--pill-active-bg);
-  border-color: var(--pill-active-border);
+.deck-presenter-notes-body {
+  flex: 1;
+  overflow-y: auto;
+  font-size: 13px;
+  line-height: 1.55;
+  white-space: pre-wrap;
   color: var(--text-primary);
 }
 
-.activity-legend {
+.deck-presenter-notes-body em { color: var(--text-muted); }
+
+.deck-presenter-next {
+  padding-top: 8px;
+  border-top: 1px solid var(--border-subtle);
+  font-size: 11px;
+  color: var(--text-muted);
+}
+
+/* --- presenter: control bar ---
+   Fades out until the pointer is near it: a talk should not be framed by
+   permanent chrome, and the keys are the real interface. */
+
+.deck-presenter-bar {
+  position: absolute;
+  left: 50%;
+  bottom: 14px;
+  transform: translateX(-50%);
+  z-index: 75;
   display: flex;
   align-items: center;
-  gap: 3px;
-  margin-left: 28px;
+  gap: 2px;
+  padding: 4px 6px;
+  background: rgba(0, 0, 0, 0.62);
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  border-radius: var(--radius-full);
+  opacity: 0.18;
+  transition: opacity var(--transition);
 }
 
-.activity-legend span {
-  font-size: 10px;
-  color: var(--text-muted);
+.deck-presenter-bar:hover { opacity: 1; }
+
+.deck-presenter-bar button {
+  min-width: 26px;
+  height: 24px;
+  padding: 0 7px;
+  color: rgba(255, 255, 255, 0.85);
+  background: transparent;
+  border: none;
+  border-radius: var(--radius-full);
+  font-size: 13px;
+  cursor: pointer;
 }
 
-.activity-tooltip {
-  padding: 5px 9px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 4px;
+.deck-presenter-bar button:hover { background: rgba(255, 255, 255, 0.16); color: #fff; }
+.deck-presenter-bar button.active { background: var(--accent); color: var(--bg-main); }
+
+.deck-presenter-pos {
+  padding: 0 8px;
   font-size: 11px;
-  color: var(--text-primary);
-  white-space: nowrap;
-  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+  color: rgba(255, 255, 255, 0.8);
+  font-variant-numeric: tabular-nums;
+}
+
+/* --- presenter: build entrances ---
+   Transform and opacity only. Nothing here animates a blurred shadow: under
+   software rendering that is a paint killer, and a stutter mid-talk is the one
+   place it would actually be noticed. */
+
+.deck-build { will-change: transform, opacity; }
+
+.deck-build-fade  { animation: deck-fade 260ms ease both; }
+.deck-build-rise  { animation: deck-rise 300ms ease both; }
+.deck-build-scale { animation: deck-scale 260ms ease both; }
+.deck-build-wipe  { animation: deck-wipe 320ms ease both; }
+.deck-build-draw  { animation: deck-draw 420ms ease both; }
+
+@keyframes deck-fade {
+  from { opacity: 0; }
+  to { opacity: 1; }
 }
 
-.activity-tooltip strong {
-  color: var(--text-primary);
+@keyframes deck-rise {
+  from { opacity: 0; transform: translateY(14px); }
+  to { opacity: 1; transform: none; }
 }
 
-/* ── Ollama settings panel ───────────────────────────────────────────── */
-.ollama-status-bar {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  padding: 4px 0 8px;
-  border-bottom: 1px solid var(--border-subtle);
+@keyframes deck-scale {
+  from { opacity: 0; transform: scale(0.9); }
+  to { opacity: 1; transform: none; }
 }
 
-.ollama-status-dot {
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  flex-shrink: 0;
+@keyframes deck-wipe {
+  from { clip-path: inset(0 100% 0 0); }
+  to { clip-path: inset(0 0 0 0); }
 }
-.ollama-status-dot.running { background-color: var(--success); }
-.ollama-status-dot.stopped { background-color: var(--text-muted); }
 
-.ollama-status-text {
-  flex: 1;
-  font-size: 12px;
-  color: var(--text-secondary);
+@keyframes deck-draw {
+  from { clip-path: inset(0 0 100% 0); }
+  to { clip-path: inset(0 0 0 0); }
 }
 
-.ollama-empty {
-  font-size: 12px;
-  color: var(--text-muted);
-  padding: 4px 0;
+@media (prefers-reduced-motion: reduce) {
+  .deck-build-fade,
+  .deck-build-rise,
+  .deck-build-scale,
+  .deck-build-wipe,
+  .deck-build-draw {
+    animation-duration: 1ms;
+  }
 }
 
-.ollama-section-title-row {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 8px;
+/* --- deck: slide transitions ---
+   Transform and opacity only, for the same paint-cost reason as the build
+   entrances. `push` and `wipe` are directionless on purpose: a deck can be
+   navigated backwards, and a push that always goes left reads as broken when
+   you step back through it. */
+
+.deck-trans-fade { animation: deck-trans-fade 240ms ease both; }
+.deck-trans-push { animation: deck-trans-push 280ms ease both; }
+.deck-trans-wipe { animation: deck-trans-wipe 300ms ease both; }
+
+@keyframes deck-trans-fade {
+  from { opacity: 0; }
+  to { opacity: 1; }
 }
 
-.ollama-action-btn {
-  font-size: 11px;
-  padding: 3px 8px;
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  cursor: pointer;
-  white-space: nowrap;
-  line-height: 1.4;
+@keyframes deck-trans-push {
+  from { opacity: 0; transform: translateX(4%); }
+  to { opacity: 1; transform: none; }
 }
-.ollama-action-btn:hover:not(:disabled) {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+
+@keyframes deck-trans-wipe {
+  from { clip-path: inset(0 0 0 100%); }
+  to { clip-path: inset(0 0 0 0); }
 }
-.ollama-action-btn:disabled {
-  opacity: 0.5;
-  cursor: default;
+
+@media (prefers-reduced-motion: reduce) {
+  .deck-trans-fade,
+  .deck-trans-push,
+  .deck-trans-wipe {
+    animation-duration: 1ms;
+  }
 }
-.ollama-action-btn.danger { color: var(--danger); }
-.ollama-action-btn.danger:hover:not(:disabled) {
-  border-color: var(--danger);
+
+/* --- presenter: the dual-window (second display) mode ---
+   With the audience on its own screen, THIS window stops being a copy of the
+   projector and becomes the speaker's console: the notes column is permanent and
+   carries a still preview of the next slide. The audience window itself is the
+   plain `.deck-presenter` — no chrome at all, because everything on it is
+   something the room can see. */
+
+/* The audience window hides the pointer: an arrow parked in the middle of a
+   projected slide is the most-noticed artefact of presenting from a laptop. The
+   speaker's own window keeps its cursor (it is where they click). */
+.deck-audience {
+  cursor: none;
 }
 
-.ollama-model-row {
-  display: flex;
-  flex-direction: column;
-  gap: 5px;
-  padding: 7px 8px;
-  border: 1px solid var(--border-subtle);
-  background: var(--control-bg);
+.deck-presenter.is-dual .deck-presenter-notes {
+  width: 340px;
 }
 
-.ollama-model-header {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 8px;
+.deck-presenter-audience-note {
+  font-size: 11px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+  padding: 6px 8px;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  background: var(--bg-hover);
 }
 
-.ollama-model-name {
-  font-size: 12px;
-  font-weight: 600;
-  color: var(--text-primary);
-  font-family: ui-monospace, monospace;
-  word-break: break-all;
+.deck-presenter-audience-note.is-error {
+  color: var(--danger);
+  border-color: var(--danger);
+  background: transparent;
 }
 
-.ollama-model-size {
-  font-size: 11px;
-  color: var(--text-muted);
-  flex-shrink: 0;
+.deck-presenter-audience-note kbd {
+  font-family: var(--font-mono);
+  font-size: 10px;
+  padding: 0 4px;
+  border: 1px solid var(--border-color);
+  border-radius: var(--radius-sm);
 }
 
-.ollama-model-details {
+.deck-presenter-next-preview {
   display: flex;
-  flex-wrap: wrap;
+  flex-direction: column;
   gap: 4px;
 }
 
-.ollama-badge {
+.deck-presenter-next-label {
   font-size: 10px;
-  padding: 1px 5px;
-  border: 1px solid var(--border-subtle);
-  color: var(--text-secondary);
-  background: var(--bg-main);
-  font-family: ui-monospace, monospace;
-}
-.ollama-badge.running {
-  border-color: var(--success);
-  color: var(--success);
-}
-.ollama-badge.running.gpu {
-  border-color: var(--accent);
-  color: var(--accent);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
 }
 
-.ollama-model-actions {
+/* A fixed-height frame: the preview must not resize as slides of different
+   aspect go by, or the notes below it would jump on every advance. */
+.deck-presenter-next-frame {
+  position: relative;
+  height: 150px;
   display: flex;
-  gap: 4px;
-  flex-wrap: wrap;
+  background: #000;
+  border: 1px solid var(--border-subtle);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
 }
 
-.ollama-catalog-row {
-  display: flex;
-  flex-direction: column;
-  gap: 3px;
-  padding: 6px 0;
-  border-bottom: 1px solid var(--border-subtle);
+.deck-presenter-wall {
+  float: right;
+  font-family: var(--font-mono);
+  font-variant-numeric: tabular-nums;
 }
-.ollama-catalog-row:last-child { border-bottom: none; }
 
-.ollama-catalog-header {
+/* The set-aside-layers banner. Wraps to its own row of actions because the
+   count is unbounded — a base PDF that lost ten pages produces ten. */
+.deck-detached-banner {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
-  justify-content: space-between;
-  gap: 8px;
+  gap: 6px;
 }
 
-.ollama-catalog-hint {
+.deck-detached-banner .deck-inspector-btn {
+  flex: 0 0 auto;
   font-size: 11px;
-  color: var(--text-muted);
-  flex-shrink: 0;
 }
 
-.ollama-catalog-desc {
-  font-size: 11px;
-  color: var(--text-secondary);
-  line-height: 1.3;
+/* First-contact host-key confirmation. Reuses the one dialog surface; only the
+   title takes the warning colour, because nothing has gone wrong yet — this is a
+   question asked before a password is sent, not a report of a failure. */
+.host-key-dialog {
+  width: min(560px, calc(100vw - 32px));
 }
 
-.ollama-catalog-tags {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 4px;
-  margin-top: 1px;
+.host-key-title {
+  color: var(--warning);
 }
 
-.ollama-tag-btn {
-  font-size: 10px;
-  padding: 2px 7px;
-  border: 1px solid var(--control-border);
-  border-radius: 0;
-  background: var(--control-bg);
-  color: var(--text-primary);
-  cursor: pointer;
-  font-family: ui-monospace, monospace;
-  line-height: 1.4;
+.host-key-lede {
+  font-size: 12px;
+  color: var(--text-secondary);
+  line-height: 1.5;
+  margin: 0;
 }
-.ollama-tag-btn:hover:not(:disabled) {
-  background: var(--control-hover-bg);
-  border-color: var(--accent);
+
+.host-key-status {
+  font-size: 12px;
+  color: var(--text-secondary);
 }
-.ollama-tag-btn.installed {
-  border-color: var(--success);
-  color: var(--success);
+
+.host-key-status-error {
+  color: var(--danger);
 }
-.ollama-tag-btn:disabled { opacity: 0.6; cursor: default; }
 
-/* ── Activity window (modal) ─────────────────────────────────────────── */
-.activity-window {
+.host-key-error-detail {
+  margin-top: 6px;
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 11px;
+  color: var(--text-muted);
+  word-break: break-word;
+}
+
+.host-key-list {
   display: flex;
   flex-direction: column;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 0;
-  box-shadow: 0 12px 40px rgba(0, 0, 0, 0.48);
-  min-width: 320px;
+  gap: 6px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
 }
 
-.activity-window-header {
+.host-key-row {
   display: flex;
-  align-items: center;
-  gap: 12px;
-  padding: 12px 16px 10px;
-  border-bottom: 1px solid var(--border-subtle);
+  align-items: baseline;
+  gap: 10px;
+  padding: 8px 10px;
+  background: var(--bg-input);
+  border: 1px solid var(--border-subtle);
+  border-left: 3px solid var(--warning);
+  border-radius: var(--radius);
 }
 
-.activity-window-title {
-  flex: 1;
-  font-size: 14px;
+.host-key-type {
+  flex: 0 0 auto;
+  font-size: 11px;
   font-weight: 650;
-  color: var(--text-primary);
-}
-
-.activity-window-body {
-  padding: 16px 20px 20px;
-}
-
-.activity-loading {
-  font-size: 12px;
   color: var(--text-muted);
-  padding: 12px 0;
-  text-align: center;
-}
-
-/* Compact reuse of the project-dialog chrome for the pill description editor. */
-.edit-description-window {
-  width: min(440px, calc(100vw - 32px));
-}
-.edit-description-window textarea {
-  width: 100%;
-  min-height: 90px;
+  white-space: nowrap;
 }
 
-/* ── Project-switch toast ──────────────────────────────────────────────── */
-@keyframes toast-fade {
-  0%   { opacity: 0; transform: translate(-50%, calc(-50% - 8px)); }
-  12%  { opacity: 1; transform: translate(-50%, -50%); }
-  72%  { opacity: 1; transform: translate(-50%, -50%); }
-  100% { opacity: 0; transform: translate(-50%, -50%); }
+/* The fingerprint is the thing being compared character by character against
+   what an admin reads out, so it must never wrap mid-token or be re-flowed. */
+.host-key-fp {
+  font-family: var(--font-mono, ui-monospace, "SF Mono", Menlo, Consolas, monospace);
+  font-size: 12px;
+  color: var(--text-primary);
+  word-break: break-all;
 }
 
-.project-switch-toast {
-  position: fixed;
-  top: 50%;
-  left: 50%;
-  transform: translate(-50%, -50%);
-  z-index: 500;
-  padding: 10px 20px;
-  background: var(--bg-panel);
-  border: 1px solid var(--border-color);
-  border-radius: 6px;
-  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
-  font-size: 0.85rem;
-  color: var(--text-secondary);
-  font-family: monospace;
-  pointer-events: none;
-  white-space: nowrap;
-  max-width: calc(100vw - 64px);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  animation: toast-fade 2.2s ease forwards;
+.host-key-note {
+  font-size: 11px;
+  color: var(--text-muted);
+  line-height: 1.5;
+  margin: 0;
 }
diff --git a/src/test-setup.ts b/src/test-setup.ts
new file mode 100644
index 0000000..27312fe
--- /dev/null
+++ b/src/test-setup.ts
@@ -0,0 +1,62 @@
+import { configure } from "@testing-library/react";
+
+// The heavy in-app viewer tests (FileViewerPane pulls in pdfjs/katex/mermaid/
+// xlsx) render and resolve async load chains that, under the full suite's
+// parallel CPU load, routinely exceed Testing Library's 1s default
+// `waitFor`/`findBy*` budget — producing timeout flakes that pass in isolation.
+// A wrong assertion still fails (just later), so this only buys patience, not
+// false greens. The Tauri-side real-timer poll tests bump their own explicit
+// `waitFor` budgets on top of this.
+configure({ asyncUtilTimeout: 10000 });
+
+// jsdom has no Tauri runtime, so `window.__TAURI_INTERNALS__` is undefined.
+// Components that subscribe via `listen()` (e.g. FileTree's fs-change watcher)
+// call it on mount; the real `@tauri-apps/api/event` `listen` synchronously hits
+// `transformCallback` → `window.__TAURI_INTERNALS__.transformCallback` and the
+// resulting rejection is uncaught, which vitest reports as an "Unhandled
+// Rejection" error (failing the run's exit code) even though every test passes.
+// Tests that mock `@tauri-apps/api/*` are unaffected (the mock replaces the
+// module); this stub only makes the *real*, unmocked calls inert. Each test that
+// mocks core still controls its own `invoke` resolutions.
+if (!(globalThis as unknown as { window?: { __TAURI_INTERNALS__?: unknown } })
+  .window?.__TAURI_INTERNALS__) {
+  (window as unknown as { __TAURI_INTERNALS__: unknown }).__TAURI_INTERNALS__ = {
+    transformCallback: () => 0,
+    invoke: () => Promise.resolve(null),
+    convertFileSrc: (p: string) => p,
+    unregisterCallback: () => {},
+  };
+  // The event plugin's unlisten path goes through a separate global.
+  (window as unknown as { __TAURI_EVENT_PLUGIN_INTERNALS__: unknown })
+    .__TAURI_EVENT_PLUGIN_INTERNALS__ = {
+    unregisterListener: () => Promise.resolve(),
+  };
+}
+
+// Global test setup (referenced by vitest.config.ts `setupFiles`).
+//
+// jsdom has no layout engine and so provides no ResizeObserver. Several
+// components (e.g. TabBar's overflow/scroll-state tracking) construct one at
+// mount, which would otherwise throw `ResizeObserver is not defined` during any
+// render that mounts them. A NO-OP stub is the right default: tests that care
+// about resize behavior drive it explicitly via dispatched events.
+if (!("ResizeObserver" in globalThis)) {
+  class ResizeObserverStub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  }
+  (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+    ResizeObserverStub;
+}
+
+// jsdom does not implement the CSS interface, so `CSS.escape` (used when
+// building attribute selectors in drag/drop hit-testing) is undefined. Provide a
+// minimal, spec-faithful escape so those selectors resolve in tests.
+const cssObj = (globalThis as unknown as { CSS?: { escape?: unknown } }).CSS;
+if (!cssObj || typeof cssObj.escape !== "function") {
+  const escape = (value: string) =>
+    String(value).replace(/[^a-zA-Z0-9_-]/g, (ch) => `\\${ch}`);
+  if (cssObj) cssObj.escape = escape;
+  else (globalThis as unknown as { CSS: unknown }).CSS = { escape };
+}
diff --git a/src/types/index.ts b/src/types/index.ts
index 12e32c1..848d72f 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -9,9 +9,50 @@ export interface GlobalAppEntry {
  * the Rust `ViewerPref` serde serialization so settings.json round-trips. Keyed
  * by a viewer-type id (see VIEWER_PREF_TYPES in fileUtils).
  */
+/**
+ * Completion-length mode for local autocomplete (#45 modes), mirroring the Rust
+ * `CompletionMode`: how much the model is asked to complete at the caret.
+ *  - `"sentence"` — finish the current word/sentence/line (default).
+ *  - `"block"` — finish the current code block / paragraph (multi-line).
+ *  - `"scope"` — complete the whole enclosing function or scope.
+ */
+export type AutocompleteMode = "sentence" | "block" | "scope";
+
+/**
+ * Category of a local-model grammar/spelling issue, mirroring the Rust
+ * `check_grammar` output. Drives the underline colour in the editor overlay.
+ *  - `"spelling"` — a misspelled word / typo (red).
+ *  - `"grammar"` — a grammar or punctuation mistake (blue).
+ *  - `"style"` — a style/wording suggestion (green).
+ */
+export type GrammarCategory = "spelling" | "grammar" | "style";
+
+/**
+ * One proofreading issue returned by the local-model grammar check, mirroring the
+ * Rust `GrammarIssue`. `bad` is the exact offending substring (the frontend
+ * locates it in the draft to draw the underline); `line` is its 1-based line in
+ * the checked text, used as a disambiguation hint when resolving the range.
+ */
+export interface GrammarIssue {
+  line: number;
+  bad: string;
+  suggestion: string;
+  category: GrammarCategory;
+  message: string;
+}
+
 export interface ViewerPref {
+  /** Whether this native viewer is used at all. Absent/true → render in-app;
+   *  false → the type opts out and its files open in the external default app. */
+  enabled?: boolean;
   /** Whether Ctrl+Space local autocomplete is enabled for this type (#45). */
   autocomplete?: boolean;
+  /** Default completion-length mode for this type (#45 modes). Cycled live
+   *  in-editor with Shift+Tab while a suggestion is showing; absent → "sentence". */
+  autocomplete_mode?: AutocompleteMode;
+  /** Whether the local-model grammar/spelling check is enabled for this type.
+   *  Local-only (Ollama) and opt-in; default OFF. */
+  grammar_check?: boolean;
   /** Editor font size in px for this type's in-app code editor. Adjusted from
    *  the viewer's A−/A+ controls (or Ctrl +/−/0); unset falls back to 12px. */
   font_size?: number;
@@ -30,17 +71,192 @@ export interface KeyboardChord {
   meta?: boolean;
 }
 
+/**
+ * A user-defined "custom agent" — an arbitrary CLI the user wants offered in the
+ * add-tab menu's Agents group alongside the built-in agents (Claude, Codex, …).
+ * It is just a launch command: Eldrun spawns `cmd` (+ `args`, `env`) in the
+ * project directory as an `agent` tab. Persisted in `Settings.custom_agents` and
+ * added/removed from the "＋ Add agent…" dialog.
+ *
+ * Unlike a built-in agent it carries no install command and no session-capture
+ * machinery. The one optional capability is `resumeArgs`: a "continue the most
+ * recent session" flag (e.g. `["--continue"]`) that, when set, promotes the tab
+ * to the *cwd-continue* resume tier — it survives a restart and respawns with
+ * these args (exactly how Qwen/OpenCode resume). Unset ⇒ launch-only, dropped on
+ * restart like Gemini/Aider.
+ */
+export interface CustomAgent {
+  /** Stable id minted at creation; also the persisted map key / React key. */
+  id: string;
+  /** Display label in the Agents menu. */
+  label: string;
+  /** Binary/command to spawn. Probed on PATH (or as a file path when it contains
+   *  a separator) for the menu's installed/greyed state. */
+  cmd: string;
+  /** Optional launch args, prepended before any resume args. */
+  args?: string[];
+  /** Optional environment variables set on the tab's process. */
+  env?: Record<string, string>;
+  /** Optional "continue last session" flag(s). When non-empty the tab is
+   *  restart-resumable (see the interface note). */
+  resumeArgs?: string[];
+  /** Optional one-line install command (e.g. `npm install -g @scope/pkg`). When
+   *  the agent's binary isn't found, the manage dialog offers a one-click button
+   *  that runs this in a fresh root terminal tab (Eldrun's install-via-tab
+   *  policy — never a copy-it-yourself step). */
+  installCmd?: string;
+}
+
 export interface Settings {
-  terminal_command?: string;
-  workspace_management?: boolean;
   debug?: boolean;
   git_profile_url?: string;
   git_token?: string;
   color_scheme?: string;
+  /** UI language for Eldrun's interface. Unset/unknown falls back to English.
+   *  Applied live via `lib/i18n` (`applyLanguage`); the backend round-trips it. */
+  language?: "en" | "de" | "es" | "fr" | "it";
+  /** The MAIN window's UI zoom factor (helps on high-DPI/4K monitors). `1` (or
+   *  unset) is 100% — the default look; applied as the webview's native zoom.
+   *  Clamped to [0.5, 3]. Zoom is **per window**: a detached popout persists its
+   *  own zoom on its layout entry (see `DetachedGroup.zoom`), not here. */
+  ui_zoom?: number;
+  /** Calendar: first column of the week — `0` = Sunday (default), `1` = Monday. */
+  calendar_week_start?: 0 | 1;
+  /** Calendar: the view a fresh calendar tab opens on. Default `"month"`. */
+  calendar_default_view?: CalendarViewKind;
+  /** Calendar: 24-hour clock instead of AM/PM. Default off. */
+  calendar_time_format_24h?: boolean;
+  /** Calendar: first/last hour the day and week grids scroll to. Default 8/20. */
+  calendar_day_start_hour?: number;
+  calendar_day_end_hour?: number;
+  /** Calendar: minutes-before reminder pre-filled on a new event. `0` = none. */
+  calendar_default_reminder_minutes?: number;
   default_agent_cmd?: string;
+  /** User-defined custom agents offered in the add-tab menu's Agents group,
+   *  added/removed from the "＋ Add agent…" dialog. Round-trips through the
+   *  backend settings `extra` catch-all — no Rust field needed. See CustomAgent. */
+  custom_agents?: CustomAgent[];
+  /** Built-in agent ids (the `cmd` in `AGENT_ITEMS`, e.g. `"codex"`) the user has
+   *  turned off in "Manage Agents" despite being installed — hidden from every
+   *  tab-choice menu (add-tab Agents group, Local Model drivers) without
+   *  uninstalling the CLI. Round-trips through the backend settings `extra`
+   *  catch-all — no Rust field needed. Unset/empty = nothing hidden. */
+  disabled_agents?: string[];
+  /** The default local (Ollama) model. Used by any task without its own
+   *  per-task assignment in `ollama_roles`, and as the legacy "active model".
+   *  Chosen in the 🧠 menu (click a loaded model's name). Unset = none. */
+  ollama_model?: string;
+  /** Per-task local-model assignments (🧠 menu role chips). Maps a task key —
+   *  `"autocomplete"`, `"grammar"`, or `"tabs"` — to the model name that should
+   *  serve it, so several loaded models can run different jobs in parallel. A
+   *  task absent here falls back to `ollama_model`, then to any loaded model. */
+  ollama_roles?: Record<string, string>;
+  /** Python Run/Debug arguments (#py), the raw `sys.argv` string typed into the
+   *  Run button's right-click popover, keyed by the file's absolute path. Kept
+   *  per file (not per tab) so every viewer of the same script shares one set of
+   *  args, and here (global settings) so they survive closing the viewer and an
+   *  Eldrun restart. Round-trips through the backend's `extra` catch-all — no Rust
+   *  field needed. An entry set to "" means "cleared" and is pruned. */
+  python_run_args?: Record<string, string>;
   run_scripts_in_background?: boolean;
+  /** Header resource-monitor row toggles. Each defaults ON (undefined → shown).
+   *  Independent of `debug`; the pill is available in every build. */
+  show_cpu_usage?: boolean;
+  show_ram_usage?: boolean;
+  show_gpu_usage?: boolean;
+  /** Header clock: show seconds. Off by default (hh:mm only). */
+  show_clock_seconds?: boolean;
+  /** When true (the default), Claude agent tabs are spawned with `--remote-control`
+   *  so the running session can be monitored/steered from the Claude app/web. Only
+   *  Claude supports this flag; other agents ignore the setting. */
+  agent_remote_control?: boolean;
+  /** When true (the default), the usage recap opens by itself on the first launch
+   *  of each day. Turning it off stops the popup, not the counting — the recap
+   *  stays reachable from Settings. */
+  daily_stats_recap?: boolean;
+  /** UTC date ("YYYY-MM-DD") the recap was last auto-shown, so it opens once a day
+   *  rather than once per window. Written by the recap host. */
+  daily_stats_last_shown?: string;
+  /** EXPERIMENTAL, default OFF. Shows a Plan/Auto badge on agent tabs whose agent
+   *  supports an absolute mode flag AND resumes on respawn (currently Claude only —
+   *  see components/tabs/agentModes.ts). Switching restarts the agent; the
+   *  conversation is resumed, the terminal scrollback is not. */
+  agent_mode_toggle?: boolean;
+  /** EXPERIMENTAL, default OFF. Gives a Python file in the code viewer its Run/Debug
+   *  buttons and the breakpoint gutter (#87). Off by default because Run *executes
+   *  the file* — one click away from an editor — so it is opt-in. Go-to-definition
+   *  is not gated: it reads, it never runs anything. */
+  python_run_debug?: boolean;
+  /** EXPERIMENTAL, default OFF. The native presenter ("deck",
+   *  `docs/deck_presenter_plan.md`): editable object layers over a base PDF, kept
+   *  in a `*.eldeck.json` sidecar, plus the animate mode and the fullscreen
+   *  presenter. Gated because it is the largest single viewer surface in the app
+   *  and still moving — it registers a viewer, a file type, and a fullscreen mode. */
+  deck_presenter?: boolean;
+  /** Persistent LOCAL (tmux) sessions (TODO #85): when true (the default on Unix),
+   *  a local project's shell/script tabs run inside a tmux session on the machine,
+   *  so a long run keeps going if Eldrun crashes and the tab reattaches on restart.
+   *  `undefined`/`true` = on; `false` = off. No effect on Windows (no tmux). */
+  persist_local_sessions?: boolean;
+  /** When true (the default), remote SSH/OpenVPN connections are made headlessly
+   *  in the background (Eldrun handles the password transiently). When false, they
+   *  are launched as interactive terminal tabs in the Eldrun root scope, so the
+   *  password is typed directly into the live terminal and Eldrun never handles
+   *  it. Default ON (headless) preserves existing behaviour. */
+  connections_headless?: boolean;
+  /** Hosts marked **careful** — "this machine is shared and policed, keep
+   *  Eldrun's background load off it" — keyed by canonical SSH target
+   *  (`lib/machineSync`'s `targetKey`, i.e. `user@host:port`), because one login
+   *  node is simultaneously a primary `remote`, a worker and a global machine.
+   *  The value is the user's EXPLICIT answer; a target absent from the map is
+   *  **careful** — the default for every remote machine — which is why this is a
+   *  map and not a list: an explicit `false` ("this one is mine") must be
+   *  distinguishable from an unanswered host, or the default would keep
+   *  re-enabling itself. See `lib/carefulHost.ts`. */
+  careful_hosts?: Record<string, boolean>;
+  /** Machines tagged **HPC** — a shared cluster login node — keyed by the same
+   *  SSH target as `careful_hosts`. Ticked on the login form and shown as a badge
+   *  on the machine's row in the Machines menu. Where `careful_hosts` governs how
+   *  much Eldrun *looks at*, this governs what it *does*: a tagged host is careful
+   *  regardless, and its disk-usage scan, giant-folder census, background sync +
+   *  lockstep loops, silent auto-connect and unannounced login-node compute are
+   *  all gated behind it. See `lib/hpcHost.ts`. */
+  hpc_hosts?: Record<string, boolean>;
+  /** Path of the stored `.ovpn` config brought up automatically **on launch** —
+   *  armed from the header's VPN menu, with no project behind it. Unset/null = no
+   *  tunnel starts by itself. Only one config can be armed: a tunnel reroutes the
+   *  whole machine, so two would fight over the routing. */
+  vpn_auto_connect?: string | null;
+  /** The `.ovpn` configs the user asked Eldrun to remember the credentials of.
+   *  No secret here — those live in the OS keychain; this is the *intent*, kept
+   *  because a locked keychain answers every read like an empty one, so the
+   *  toggle and the connect path would otherwise read "nothing saved" over a
+   *  perfectly good saved credential (see `lib/keyring.ts`). */
+  vpn_saved_configs?: string[];
+  /** When true, the header's OpenVPN indicator is shown. Default OFF — most
+   *  projects are local-only, so the machine-wide tunnel control stays hidden
+   *  until asked for (the first-run `RemoteFeaturesPrompt`, or Settings). */
+  vpn_enabled?: boolean;
+  /** When true, the header's global-machines indicator is shown. Default OFF,
+   *  same reasoning as `vpn_enabled`. */
+  machines_enabled?: boolean;
+  /** True once the first-run "Using VPN or remote machines?" prompt has been
+   *  shown/answered, so it never re-asks automatically. */
+  remote_features_prompted?: boolean;
+  /** Energy-saver mode. "off" never throttles; "battery" (the default) throttles
+   *  only while running on battery; "always" throttles regardless of power. When
+   *  active, Eldrun pauses the blob auto-spin, collapses idle animations, and
+   *  widens always-on UI timers to reduce CPU/battery drain. */
+  energy_saver?: "off" | "battery" | "always";
   /** When true, the right panel is docked open (reflows layout) instead of hover-revealed. */
   right_panel_pinned?: boolean;
+  /** Width of the right (file/git) panel in px. Set by dragging the panel's left
+   *  border; unset falls back to the default 280px. */
+  right_panel_width?: number;
+  /** Which edge the file panel docks against. Unset falls back to "right". Flipped
+   *  by the ⇄ button in the panel header; round-trips through the settings `extra`
+   *  catch-all, so no backend field is needed. */
+  right_panel_side?: "left" | "right";
   /** Minimum subwindow (split pane) width in px a divider drag may shrink to.
    *  Unset falls back to DEFAULT_MIN_SUBWINDOW_PX. */
   min_subwindow_width?: number;
@@ -49,6 +265,10 @@ export interface Settings {
   min_subwindow_height?: number;
   /** When true, in-app editors debounce-save edits automatically (#47). Default OFF. */
   autosave?: boolean;
+  /** When true (the default), the text/TeX editors tint recently typed runs with a
+   *  sequential new→old colour trail that fades as you keep typing. Default ON;
+   *  only an explicit `false` disables it. */
+  change_tint?: boolean;
   /** Per-type native-viewer prefs (#48): opt-in local autocomplete (#45). */
   viewer_prefs?: Record<string, ViewerPref>;
   global_apps?: Record<string, GlobalAppEntry>;
@@ -59,12 +279,142 @@ export interface Settings {
    * original hard-coded behaviour.
    */
   keyboard_shortcuts?: Record<string, KeyboardChord>;
+  /** Download *source* folders scanned by the right-panel Downloads section
+   *  (fast-copy of freshly downloaded files into a project). Machine-wide,
+   *  read-only. Unset/empty → the frontend falls back to the OS Downloads dir. */
+  download_sources?: string[];
+  /** True once the first-run "How to start" welcome has been shown/dismissed, so
+   *  it never re-opens automatically. Re-openable manually from Settings. */
+  onboarding_seen?: boolean;
+  /** Ids of contextual hints (see `src/lib/hints.ts`) the user has seen/dismissed
+   *  or implicitly acted on, so each surfaces at most once. */
+  hints_seen?: string[];
+  /** Master switch for the contextual hint system; default ON when unset. */
+  hints_enabled?: boolean;
+  /** True once the guided "Take a tour" walkthrough has been completed or
+   *  skipped. Cosmetic only (never auto-launches the tour); the tour is always
+   *  replayable from the gear menu / Settings. */
+  tour_completed?: boolean;
+  /** Where the main window was when Eldrun last ran, so it reopens on the same
+   *  monitor in the same place. Written by the debounced save in `AppShell`;
+   *  consumed by the backend at startup, never rendered. */
+  window_state?: WindowState;
   [key: string]: unknown;
 }
 
+/**
+ * The main window's geometry in PHYSICAL desktop px — the canonical cross-window
+ * space (`src/lib/coords.ts`), which is also what `outerPosition`/`outerSize`
+ * report and what `setPosition`/`setSize` consume.
+ *
+ * `x`/`y`/`w`/`h` is the *restore* (non-maximized) rect: while the window is
+ * maximized the rect is left alone and only `maximized` flips, so un-maximizing
+ * after a restart lands on a real geometry instead of the full monitor.
+ *
+ * Mirrors `WindowState` in `src-tauri/src/schema/settings.rs`.
+ */
+export interface WindowState {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  maximized: boolean;
+}
+
 export interface OpenVpnSpec {
   /** Absolute path to the local `.ovpn` client config file. */
   config: string;
+  /** Auth username for `auth-user-pass` configs (server-side username+password
+   *  auth). Persisted (not a secret); the password is still prompted separately. */
+  username?: string;
+}
+
+/** Verdict of `ssh_probe`: a silent, keychain-read-only reachability + auth check.
+ *  `unreachable` distinguishes "this network can't reach the host" from "the host
+ *  rejected the credential" — only the former warrants bringing a VPN tunnel up. */
+export interface SshProbe {
+  ok: boolean;
+  unreachable: boolean;
+  error: string;
+}
+
+/** A previously-used `.ovpn` config copied into Eldrun's store, offered for
+ *  reuse so a config need only be browsed for once. */
+export interface StoredVpnConfig {
+  /** Absolute path to the stored copy (passed to `openvpn_connect`). */
+  path: string;
+  /** Friendly display name (the original `.ovpn` file name). */
+  name: string;
+}
+
+/** A globally connected worker machine (`stores/globalMachines.ts`):
+ *  authenticated once via the ordinary login mechanism, with no
+ *  `remote_path` — project-free, unlike {@link ComputeHost}. Drag-and-dropped
+ *  onto an SSH project to become a `shared_fs` compute host there (a value
+ *  copy of this identity, not a reference). */
+export interface GlobalMachine {
+  id: string;
+  user?: string;
+  host: string;
+  port?: number;
+  label?: string;
+  /** Opt-in to a silent connect on launch and whenever a VPN tunnel comes up
+   *  (the machine-wide twin of a project's `RemoteSpec.auto_connect`). */
+  auto_connect?: boolean;
+}
+
+/** One machine as it crosses the import/export boundary
+ *  (`commands::global_machines::MachineIo`): the connection address + label
+ *  only. An exported file carries no `user` and never a password — import
+ *  supplies one shared username + password for the whole batch. `user` is an
+ *  accepted field on a hand-authored file, so it is optional here. */
+export interface MachineImportEntry {
+  host: string;
+  port?: number;
+  label?: string;
+  user?: string;
+}
+
+/** Which secrets a `.ovpn` config needs from the user (`openvpn_auth_needs`), so
+ *  the UI shows exactly the fields that config will be asked for. The two are
+ *  independent — a config can need both, and OpenVPN prompts for them separately,
+ *  so supplying only one hangs the handshake on the other prompt. The local root
+ *  password is a third secret, but polkit/`pkexec` collects that one, not Eldrun. */
+export interface VpnAuthNeeds {
+  /** Bare `auth-user-pass`: server-side account auth, so a username is required. */
+  username: boolean;
+  /** An encrypted private key, whose passphrase OpenVPN asks for separately. */
+  keyPassphrase: boolean;
+}
+
+/** Whether the config's key passphrase is a *separate* field from its password.
+ *  When a config has an encrypted key but no `auth-user-pass` account, the single
+ *  password field already *is* the key passphrase (it goes to `--askpass`), so a
+ *  second field would be asking for the same secret twice. */
+export const needsSeparateKeyPassphrase = (needs: VpnAuthNeeds): boolean =>
+  needs.username && needs.keyPassphrase;
+
+/**
+ * What a project remembers about its HPC **workspace** and its **home anchor**
+ * (`docs/hpc_workspace_plan.md`; backend `schema::project::HpcInfo`).
+ *
+ * It is persisted rather than re-derived because none of it survives the
+ * workspace: the tooling's recovery path (`ws_restore`) is keyed by the workspace
+ * *name*, and the host tree that would have named it is exactly what expiry
+ * deletes. `logs_dir` additionally rescues **Watch** on an older job — with
+ * `--output` routed into the home anchor, `scontrol`'s `<WorkDir>/slurm-<id>.out`
+ * fallback points at a file that never existed.
+ */
+export interface HpcInfo {
+  workspace_id?: string;
+  workspace_path?: string;
+  filesystem?: string;
+  anchor_dir?: string;
+  /** The anchor as the `$HOME`-relative path it was created from — kept so a
+   *  re-anchor (moving to another workspace) passes the rel back instead of
+   *  guessing it by chopping segments off the absolute one. */
+  anchor_rel?: string;
+  logs_dir?: string;
 }
 
 export interface RemoteSpec {
@@ -74,6 +424,74 @@ export interface RemoteSpec {
   remote_path: string;
   /** Optional OpenVPN tunnel brought up before reaching the host. */
   openvpn?: OpenVpnSpec;
+  /** Opt-in: connect this project on launch/activation instead of waiting for the
+   *  user to bring it up from the pill's connection lamp. Only offered when the
+   *  connect can complete with no prompt (saved SSH password, or `key_auth`), and
+   *  the connect path re-checks that — it never prompts. */
+  auto_connect?: boolean;
+  /** Recorded by the backend, not user-set: the last successful connect to this
+   *  host used no password at all (key/agent auth). A passwordless host has nothing
+   *  in the keychain, so this is the only way the UI can tell it is auto-connectable. */
+  key_auth?: boolean;
+  /** Display name for this machine, e.g. "gpu-2"; falls back to `host`. Shown
+   *  wherever a project's hosts are listed side by side (System Monitor's source
+   *  picker, the pill's connection lamps, `hostsForProject`). Distinct from the
+   *  *project* name — this labels the machine, not the project. */
+  label?: string;
+  /** Persistent remote sessions (TODO #85): run this project's remote shell/script
+   *  tabs inside a **tmux** session on the host, so a long run survives an SSH drop,
+   *  a laptop sleep, or Eldrun quitting. **Default ON** — `undefined`/`true` mean
+   *  enabled; only an explicit `false` (the pill's toggle) opts out. Agent tabs are
+   *  excluded regardless. See `persistSessionsEnabled`. */
+  persist_sessions?: boolean;
+}
+
+/** An extra SSH "worker" machine a project runs experiments on
+ *  (`docs/multi_host_remote_plan.md`). Its code is kept one-way in sync from the
+ *  canonical source (the primary's local mirror) and its files are read-only —
+ *  edits are forbidden, so there is no divergence and no destructive local-loss.
+ *  The primary remote (`ProjectEntry.remote`) is unchanged. Extends `RemoteSpec`
+ *  (flattened on the backend), so it carries the same user/host/port/remote_path/
+ *  openvpn/auto_connect fields. */
+export interface ComputeHost extends RemoteSpec {
+  /** Stable id (e.g. "h1"); referenced by tab locations, the pool key, and the
+   *  fan-out state. The primary is the implicit id `"primary"`. */
+  id: string;
+  /** Keep this worker's tracked tree synced to the source HEAD (default true). */
+  sync_code?: boolean;
+  /** Pull this worker's experiment OUTPUTS back only on demand (default false —
+   *  outputs stay on the worker). */
+  pull_outputs?: boolean;
+  /** This machine reaches the project over a **shared filesystem**: it already
+   *  sees the primary's project folder at `remote_path`, so Eldrun copies no code
+   *  to it and never runs git on it — shells just `cd` into the shared tree and
+   *  run there. The default for a newly added machine (untick "Sync a copy" for
+   *  the synced-copy worker instead). Schema default false for back-compat. */
+  shared_fs?: boolean;
+}
+
+/** Per-project container config (TODO #38). When `enabled`, every terminal and
+ *  agent tab of the project execs into ONE session-lived Docker container that
+ *  mounts only the project directory (plus minimal agent auth/state paths) at
+ *  its identical host path. Absent = run on host. The hardening fields below
+ *  are optional overrides; unset means the built-in default (see
+ *  `services::sandbox` in the backend). */
+export interface SandboxSpec {
+  enabled: boolean;
+  image?: string;
+  /** In-repo Dockerfile (relative to the project dir); when set, the container
+   *  is built from it (`eldrun-<id>:latest`) instead of pulling `image`. */
+  dockerfile?: string;
+  /** `--pids-limit` (fork-bomb guard). Unset = generous built-in default. */
+  pids_limit?: number;
+  /** Hard memory cap, e.g. "4g" (`--memory`). Unset = unlimited. */
+  memory?: string;
+  /** CPU cap, e.g. "2" (`--cpus`). Unset = unlimited. */
+  cpus?: string;
+  /** Docker network, e.g. "none" for no egress (`--network`). Unset = bridge. */
+  network?: string;
+  /** Read-only root filesystem (`--read-only` + tmpfs /tmp). Default false. */
+  readonly_rootfs?: boolean;
 }
 
 export interface RemoteEntry {
@@ -81,14 +499,18 @@ export interface RemoteEntry {
   is_dir: boolean;
 }
 
-/** Availability of the external binaries remote (SSH) projects rely on. */
+/** Availability of the remote-project capabilities that depend on the platform.
+ * Remote projects are SSH/SFTP-native (no FUSE mount), so only password auth and
+ * VPN-gated (`openvpn`) hosts need anything beyond a stock `ssh`. */
 export interface SshTooling {
-  /** `sshfs` — required to mount a remote project locally. */
-  sshfs: boolean;
-  /** `sshpass` — required only for password auth. */
-  sshpass: boolean;
+  /** Whether non-interactive password auth works without installing anything.
+   * Always true on Unix (OpenSSH's `SSH_ASKPASS`); on Windows it needs either
+   * OpenSSH ≥ 8.4 (same askpass mechanism) or `sshpass` as the legacy fallback. */
+  password_auth: boolean;
   /** `openvpn` + `pkexec` — required only for VPN-gated hosts. */
   openvpn: boolean;
+  /** `rsync` on the local machine — enables the SSH-sync bulk fast-path. */
+  rsync: boolean;
 }
 
 export interface ProjectEntry {
@@ -101,11 +523,109 @@ export interface ProjectEntry {
   directory?: string;
   description?: string;
   remote?: RemoteSpec;
+  /** Extra "worker" machines this project runs experiments on
+   *  (`docs/multi_host_remote_plan.md`). One-way, read-only; the primary is
+   *  `remote`. Mirrored from project.json into the pill list. */
+  compute_hosts?: ComputeHost[];
+  /** Docker sandbox config; when `enabled`, agent tabs run in a container. */
+  sandbox?: SandboxSpec;
+  /** The interpreter the code viewer's Run/Debug buttons use (#87). Absent =
+   *  auto-detect, which is right for almost every project; pinning it is for the
+   *  environments auto-detect cannot see (a conda env, a Poetry venv outside the
+   *  tree, a second venv). Set from the pill's "Python interpreter…" dialog. */
+  python_interpreter?: string;
+  /** Which machine shells launched from this project run on — the persisted
+   *  `RunHostPicker` choice (a `TabLocation`: "local" | "remote" | "host:<id>").
+   *  Seeds the live `useRunHostPrefStore` on load so the choice survives a
+   *  relaunch. Mirrored from project.json's `run_host` into the entry's flattened
+   *  `extra`. Absent = the shell default (the primary). */
+  run_host?: string;
+  /** The HPC workspace this project's tree lives in + its home anchor
+   *  (`docs/hpc_workspace_plan.md`). Mirrored from project.json's `hpc`. Absent
+   *  for every project that isn't in a workspace. */
+  hpc?: HpcInfo;
   /** Denormalized inverse of `ProjectBox.member_ids` (the box this pill is in). */
   box_id?: string;
+  /** Per-project git-hosting profile URL that overrides the global one. Mirrored
+   *  from project.json into the pill list; the matching token lives in the OS
+   *  keyring, never here. See `GitHostingInfo`. */
+  git_profile_url?: string;
+  /** Hosting provider this project was published to, recorded at publish time.
+   *  Absent until published to a remote. */
+  git_provider?: GitProvider;
+  /** Provider sniffed from the local `origin` host at load time (host-only, no
+   *  network). Decorates the pill badge for repos pushed to a host outside
+   *  Eldrun's Publish flow. Transient — never persisted to projects.json. */
+  detected_provider?: GitProvider;
+  /** Raw `origin` remote URL sniffed alongside `detected_provider`. Shown as the
+   *  git address in the project hover. Transient — never persisted. */
+  git_origin_url?: string;
+  /** User-assigned category tags. Group/color the project in the cloud + pills;
+   *  set via the pill / blob-node right-click menu. Stored in the entry's
+   *  flattened `extra` (mirrored into project.json). */
+  categories?: string[];
   [key: string]: unknown;
 }
 
+/** A row in the Settings "Archived projects" list (from `list_archived_projects`).
+ *  Archived projects live under `~/eldrun/archive/<id>/` until restored or
+ *  permanently cleared. */
+export interface ArchivedProject {
+  id: string;
+  name: string;
+  /** ISO timestamp the project was archived (stamped at delete time). */
+  archived_at: string;
+  /** True for remote (SSH) projects — their host tree was never touched. */
+  remote: boolean;
+}
+
+/** One local mirror branch carrying commits the host baseline lacks. */
+export interface UnsyncedBranch {
+  name: string;
+  count: number;
+}
+
+/** Whether permanently deleting an archived remote project would discard
+ * local-only mirror history. Computed offline from the archived files. */
+export interface UnsyncedReport {
+  /** Commits on the mirror's local branches not present on the host baseline. */
+  total: number;
+  branches: UnsyncedBranch[];
+  /** False when there was no host baseline to compare against (the count is then
+   * every local commit and should read as "could not verify"). */
+  verified: boolean;
+}
+
+/** Supported git-hosting providers for publishing a project's repo. */
+export type GitProvider = "github" | "gitlab";
+
+/**
+ * Which side a work-remote project publishes from. Not "where the files are":
+ * the provider login (`gh auth login`, the tokens in Settings → Git Hosting) is
+ * *this* machine's, and a work remote is typically a cluster login node with no
+ * provider CLI and no GitHub credentials — while the lockstep mirror is a full
+ * local repo holding the same commits. Hence `"local"` is the default;
+ * `"remote"` is the opt-in for a host that does have its own `gh`/`glab` login.
+ * Ignored for a local project, which has only one side.
+ */
+export type PublishFrom = "local" | "remote";
+
+/**
+ * Per-project git-hosting config as returned by `get_project_git_hosting`. The
+ * token is never sent to the renderer — only whether one is stored — and the
+ * global values are surfaced so the editor can show what is inherited by default.
+ */
+export interface GitHostingInfo {
+  /** Per-project profile URL override, if set (else inherits `global_profile_url`). */
+  profile_url: string | null;
+  /** Whether a per-project token is stored in the keyring. */
+  has_token: boolean;
+  /** Global fallback profile URL (from settings), shown as the inherited default. */
+  global_profile_url: string | null;
+  /** Whether a global token exists to fall back on. */
+  has_global_token: boolean;
+}
+
 /**
  * A directed relation between two members of a box ("a change in `source` may
  * influence `target`"). Mirrors the Rust `BoxRelation` (#41 Phase 2: stored).
@@ -132,6 +652,138 @@ export interface ProjectBox {
   relations?: BoxRelation[];
 }
 
+/**
+ * The native calendar's model, mirroring `src-tauri/src/schema/calendar.rs`.
+ *
+ * All timestamps are **local wall-clock**: `"YYYY-MM-DDTHH:MM"` when timed,
+ * `"YYYY-MM-DD"` when all-day. Ends are **exclusive** (an all-day event on the
+ * 8th ends `"2026-07-09"`). See `src/lib/calendarTime.ts` for the math.
+ */
+
+/** The views a calendar tab can show. */
+export type CalendarViewKind =
+  | "day"
+  | "week"
+  | "multiweek"
+  | "month"
+  | "agenda"
+  | "tasks";
+
+/** One named, colored calendar in the sidebar list. */
+export interface Calendar {
+  id: string;
+  name: string;
+  /** CSS color its events render in. */
+  color: string;
+  /** Unchecked in the sidebar → its events drop out of every view. */
+  visible: boolean;
+  readonly: boolean;
+}
+
+/** How often a recurring event repeats. */
+export type Freq = "daily" | "weekly" | "monthly" | "yearly";
+
+/** A recurrence rule. `until` and `count` are mutually exclusive ends. */
+export interface Rrule {
+  freq: Freq;
+  /** Repeat every N periods. */
+  interval: number;
+  /** Weekly only: weekdays to fire on, `0` = Sunday … `6` = Saturday. */
+  byweekday?: number[];
+  /** Monthly only: day of month (1-31). Absent → the event's own day. */
+  bymonthday?: number | null;
+  /** Inclusive last date (`"YYYY-MM-DD"`) the rule may fire on. */
+  until?: string | null;
+  /** Total occurrences, counting the first. */
+  count?: number | null;
+}
+
+/** A single occurrence edited away from its master ("this event only"). */
+export interface EventOverride {
+  /** The occurrence's start as the rule generated it — the key. */
+  occurrence_start: string;
+  start?: string | null;
+  end?: string | null;
+  title?: string | null;
+  location?: string | null;
+  notes?: string | null;
+}
+
+/** A reminder, fired `minutes_before` the occurrence starts. */
+export interface Alarm {
+  minutes_before: number;
+}
+
+/** `"confirmed"` (default) | `"tentative"` | `"cancelled"`. */
+export type EventStatus = "confirmed" | "tentative" | "cancelled";
+
+/** A calendar event. `end` is exclusive. */
+export interface CalendarEvent {
+  id: string;
+  calendar_id: string;
+  start: string;
+  end: string;
+  all_day: boolean;
+  title: string;
+  location?: string;
+  notes?: string;
+  category?: string;
+  status?: EventStatus | "";
+  rrule?: Rrule | null;
+  /** Occurrence starts deleted from the series. */
+  exdates?: string[];
+  overrides?: EventOverride[];
+  alarms?: Alarm[];
+}
+
+/** A to-do (VTODO). */
+export interface CalendarTask {
+  id: string;
+  calendar_id: string;
+  title: string;
+  notes?: string;
+  due?: string | null;
+  start?: string | null;
+  /** iCalendar priority: `0` = unset, `1` = highest … `9` = lowest. */
+  priority: number;
+  /** 0-100; `100` implies done. */
+  percent: number;
+  completed?: string | null;
+  category?: string;
+  alarms?: Alarm[];
+}
+
+/** The whole of `calendar.json`. */
+export interface CalendarData {
+  version: number;
+  calendars: Calendar[];
+  events: CalendarEvent[];
+  tasks: CalendarTask[];
+}
+
+/**
+ * One materialized instance of an event on the timeline. A non-recurring event
+ * yields exactly one; a recurring one yields many, all sharing `eventId`.
+ * `occurrenceStart` is the start the *rule* generated — the stable key used for
+ * exdates and overrides, which survives the occurrence being moved.
+ */
+export interface Occurrence {
+  eventId: string;
+  occurrenceStart: string;
+  start: string;
+  end: string;
+  allDay: boolean;
+  title: string;
+  location: string;
+  notes: string;
+  category: string;
+  status: EventStatus | "";
+  calendarId: string;
+  /** True when it came from a recurring master (so the UI can offer this/all). */
+  recurring: boolean;
+  alarms: Alarm[];
+}
+
 /**
  * Sanitize a box name into a folder segment. Mirrors the backend
  * `commands::projects::sanitize_name` so the frontend can preview the box-folder
@@ -149,16 +801,40 @@ export function boxFolderName(name: string): string {
 export function resolveProjectDirectory(project: ProjectEntry | null | undefined): string {
   if (!project) return "";
   if (project.directory) return project.directory;
-  return project.local_file.endsWith("/project.json")
-    ? project.local_file.slice(0, -"/project.json".length)
-    : "";
+  const match = /^(.*)[/\\]project\.json$/i.exec(project.local_file);
+  return match?.[1] ?? "";
+}
+
+/**
+ * Format a remote project's location as `user@host:remote_path` (the `user@`
+ * prefix is dropped when no user is set). Port is intentionally omitted — this
+ * is an at-a-glance display string, and `host:port:path` would be ambiguous.
+ */
+export function formatRemoteTarget(remote: RemoteSpec): string {
+  return `${remote.user ? `${remote.user}@` : ""}${remote.host}:${remote.remote_path}`;
+}
+
+/**
+ * The paired local working-copy ("mirror") path for a remote project, read from
+ * the flattened `extra["mirror"]` field mirrored onto the entry. Returns null
+ * when unset (legacy remote projects created before the mirror was persisted).
+ */
+export function resolveLocalMirror(project: ProjectEntry | null | undefined): string | null {
+  const mirror = project?.mirror;
+  return typeof mirror === "string" && mirror.trim() ? mirror : null;
 }
 
-export type Theme = "fancy_dark" | "dark" | "light" | "fancy_light";
+export type Theme =
+  | "fancy_dark"
+  | "dark"
+  | "light"
+  | "fancy_light"
+  | "light_lavender";
 
 export const THEMES: { value: Theme; label: string }[] = [
   { value: "fancy_dark", label: "Fancy Dark" },
   { value: "dark", label: "Plain Dark" },
   { value: "light", label: "Plain Light" },
   { value: "fancy_light", label: "Fancy Light" },
+  { value: "light_lavender", label: "Light Lavender" },
 ];
diff --git a/start-eldrun-tauri-hotreload.sh b/start-eldrun-tauri-hotreload.sh
index 83d996a..f6fbe87 100755
--- a/start-eldrun-tauri-hotreload.sh
+++ b/start-eldrun-tauri-hotreload.sh
@@ -17,6 +17,13 @@ cd "$ROOT"
 # Desktop entries don't source ~/.bashrc, so Rust tools may not be in PATH.
 export PATH="$HOME/.cargo/bin:$PATH"
 
+# With GTK overlay scrolling on (the default on Cinnamon/GNOME), WebKitGTK draws
+# a native GTK overlay scrollbar and ignores the app's CSS `scrollbar-color`, so
+# the themed (blue) scrollbars fall back to the system GTK theme (white/grey in
+# Adwaita light). Disabling it forces the legacy scrollbar, which WebKitGTK
+# renders itself and themes from our CSS. Harmless where it's already off.
+export GTK_OVERLAY_SCROLLING=0
+
 printf 'root=%s\n' "$ROOT"
 printf 'PATH=%s\n' "$PATH"
 command -v node
diff --git a/todo/done.md b/todo/done.md
new file mode 100644
index 0000000..d07b75e
--- /dev/null
+++ b/todo/done.md
@@ -0,0 +1,594 @@
+# Done Groups Archive
+
+Code-complete groups, collected here per [CLAUDE.md](../CLAUDE.md)'s numbering convention (item numbers stay global and stable across the whole plan; group letters are never reused). **All groups below are ✅ Done with passing 🤖 automated tests** (see exceptions noted per group); **🖐️ manual/runtime QA is still pending across the board** — see the Status legend in [../TODO.md](../TODO.md).
+
+`Group N` and `Group U` are done but not yet renumbered into the `D.x` sequence; kept under their original letters here so existing references (commits, docs) stay valid.
+
+---
+
+## Group D.1 — Right Panel: File Tree & Navigation ✅ Done · 🧪 Untested
+*Files: `src/components/files/FileTree.tsx`, `fileUtils.ts`, `RightPanel.tsx`, `src/styles/themes.css`. Backend create/delete commands already exist in `commands/projects.rs`.*
+🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
+
+1. ✅ **Create file / folder from right-click.** Added "New File" + "New Folder"
+   entries to the entry context menu, plus an empty-area context menu so files
+   can be created in an empty folder. Both reuse the `window.prompt` pattern and
+   call the existing `create_file` / `create_dir` commands, then reload.
+   - *Test (e.g.):* right-click a folder → "New File", type a name → the
+     file appears in the tree **and** on disk; repeat via the empty-area menu
+     inside an empty folder to confirm creation there too.
+   - [x] 🤖 Automated test — `FileTreeNav.test.tsx`
+   - [ ] 🖐️ Manual test
+
+2. ✅ **Show long file/folder names in full.** Added a native `title={e.name}` to
+   the `.file-name` span so the full name shows on hover (CSS ellipsis kept).
+   - *Test (e.g.):* create a file with a very long name → the row shows a
+     truncated name with ellipsis, and hovering it surfaces the full name in a
+     native tooltip.
+   - [x] 🤖 Automated test — `FileTreeNav.test.tsx`
+   - [ ] 🖐️ Manual test
+
+3. ✅ **Show parent folders when inside a subfolder.** Replaced the single
+   "↑ .." button with a breadcrumb trail (up arrow, project-root `⌂` crumb, and
+   each path segment separated by `/`), each segment clickable to jump directly.
+   - *Test (e.g.):* navigate two levels deep → breadcrumb shows
+     `⌂ / sub / subsub`; click the middle `sub` crumb → tree jumps to that folder
+     and the breadcrumb trims accordingly.
+   - [x] 🤖 Automated test — `FileTreeNav.test.tsx`
+   - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.2 — Right Panel: Git Status Markers ✅ Done · 🧪 Untested
+*Files: `src-tauri/src/commands/git.rs` (`git_file_statuses`), `FileTree.tsx` (`STATUS_COLOR`, `GitMarker`), `fileUtils.ts`.*
+🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
+
+4. ✅ **Fix incorrect git colors.** Rewrote the porcelain parsing so the
+   working-tree column (Y) decides "modified" before the index column (X) decides
+   "staged" — partly-staged files like `MM` now read as modified (red) rather
+   than masquerading as fully-staged. Bubbling priority is now
+   modified > untracked > staged > unpushed > ignored.
+   - *Test (e.g.):* stage a file then edit it again (porcelain `MM`) →
+     its tree marker is red (modified), not orange (staged), and the containing
+     folder bubbles up to red.
+   - [x] 🤖 Automated test — `GitStatusColors.test.tsx` (STATUS_COLOR mapping)
+   - [ ] 🖐️ Manual test
+
+5. ✅ **Richer marker scheme.** `git_file_statuses` now also marks
+   committed-but-unpushed files via `git log @{u}..`. Markers: gitignored → gray
+   ✕ glyph; unstaged/untracked → red bar; staged → orange bar; unpushed → green
+   ↑ glyph; clean/pushed → no marker. (Ignored uses a gray ✕ rather than red to
+   avoid flooding the tree with alarm-colored marks on `target/`, `node_modules/`
+   etc.; trivially switchable in `STATUS_COLOR`.)
+   - *Test (e.g.):* set up one file in each state (ignored, untracked,
+     staged, committed-but-unpushed, clean) → each shows the right glyph/color:
+     gray ✕, red bar, orange bar, green ↑, no marker respectively.
+   - [x] 🤖 Automated test — `GitStatusColors.test.tsx` (STATUS_COLOR mapping)
+   - [ ] 🖐️ Manual test
+
+6. ✅ **Show `.gitignore` in the tree.** `visibleEntries` now keeps `.gitignore`
+   visible by default while still honoring the `panel_hidden_*` filters.
+   - *Test (e.g.):* in a project with a `.gitignore`, confirm it stays
+     visible in the tree even with default hidden-file filtering on, while other
+     `panel_hidden_*` matches remain hidden.
+   - [x] 🤖 Automated test — `GitignoreVisible.test.ts`
+   - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.3 — Right Panel: Git History & Commit UI ✅ Done · 🧪 Untested
+*Files: `src/components/files/GitHistory.tsx` (new), `RightPanel.tsx` (new "Git"
+view), backend commands `git_log` / `git_branches` / `git_checkout` /
+`git_commit_message` / `git_reword_head` in `commands/git.rs`.*
+🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
+
+7. ✅ **Git history view.** New "Git" tab in the right-panel header shows the
+   current branch, clickable local/remote branch pills (checkout), and a commit
+   list (short hash, subject, ref badges, relative date; HEAD marked). Backend
+   `git_log`, `git_branches`, `git_checkout` added.
+   - *Test (e.g.):* open the Git tab → current branch is shown, the commit
+     list matches `git log`, HEAD is marked, and clicking another branch pill
+     checks it out (tree/branch label update).
+   - [x] 🤖 Automated test — `GitHistory.test.tsx`
+   - [ ] 🖐️ Manual test
+
+8. ✅ **Click a commit → commit-message window.** Clicking a commit opens a modal
+   showing its full message. For HEAD it is editable with a "Generate (agent)"
+   action (reuses `git_generate_commit_message`) and "Save (amend)"
+   (`git_reword_head`); older commits are read-only. A "Checkout" action checks
+   out the commit (detached). Full message fetched via `git_commit_message`.
+   - *Test (e.g.):* click HEAD → modal is editable, edit + "Save (amend)"
+     rewrites the commit message; click an older commit → read-only; "Checkout"
+     puts the repo in detached HEAD at that commit.
+   - [x] 🤖 Automated test — `GitHistory.test.tsx`
+   - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.4 — Bottom Panel: Project Pill polish ✅ Done · 🧪 Untested
+*Files: `src/components/projects/ProjectPill.tsx`, `src/stores/activity.ts` (new),
+`src/components/layout/AppShell.tsx`, `ProjectSwitcher.tsx`, `src/stores/projects.ts`,
+backend `commands/terminal.rs` (`project_cpu_percent`), `commands/projects.rs`
+(`set_project_description`), `src-tauri/src/sysstat.rs` (new). Test:
+`src/__tests__/PillRunningIndicator.test.ts`.*
+🧪 Tested: 🤖 automated ✅ (suite green; #11 CPU% core helpers only) · 🖐️ manual ❌ (runtime QA pending)
+
+9. ✅ **Running-task indicator on pills.** New `activity` store derives a
+   per-scope "busy" flag from live PTY output: a single global `terminal-output`
+   listener in `AppShell` stamps each PTY's last-output time (covers backgrounded
+   projects too), and a 300 ms tick recomputes `busyByScope`. Busy pills show the
+   three-dot `OrbitSpinner` tinted green (`.pill-running-spinner`).
+   - *Test (e.g.):* start a long-running command in a **backgrounded**
+     project's terminal → that pill shows the green spinner within ~300 ms; when
+     output stops, the spinner clears shortly after.
+   - [x] 🤖 Automated test — `PillRunningIndicator.test.ts`
+   - [ ] 🖐️ Manual test
+
+10. ✅ **Right-click → change description.** Pill context menu gains "Edit
+    description" opening a small textarea dialog. Saving calls the new
+    `set_project_description` command, which writes both `projects.json` (the
+    pill list) and the project's `project.json`, then mirrors the cleaned value
+    into the store.
+    - *Test (e.g.):* right-click a pill → "Edit description", save new
+      text → both `projects.json` and that project's `project.json` are updated
+      on disk and the hover popup shows the new description.
+    - [x] 🤖 Automated test — `projects_commands.rs::set_project_description_writes_both_projects_json_and_project_json`
+    - [ ] 🖐️ Manual test
+
+11. ✅ **Hover → per-project CPU %.** Hover popup now shows live CPU%, polled
+    every 1.5 s while open. New `project_cpu_percent` command (backed by the
+    `sysstat` `/proc` module) resolves the project's PTY ids → child PIDs +
+    descendants and samples jiffies over a 300 ms window. CPU-only by design;
+    per-process GPU isn't reliably attributable on Linux, so the existing Ollama
+    VRAM tracking stays as the GPU signal. No-op (returns 0) off Linux.
+    - *Test (e.g.):* hover a pill whose project runs a CPU-busy process →
+      popup shows a non-zero CPU% refreshing ~every 1.5 s; an idle project reads
+      ~0%; on non-Linux it returns 0 without erroring.
+    - [x] 🤖 Automated test — *partial:* `sysstat.rs` unit tests (clk_tck, descendant_pids self-inclusion/empty, sum_jiffies live+dead pid); live % readout is manual
+    - [ ] 🖐️ Manual test
+
+12. ✅ **Suppress default webview reload/inspect on right-click.** The
+    `.project-switcher` container now `preventDefault`s `contextmenu`, so a right-click
+    anywhere on the bar surfaces only our pill menu, never Reload/Inspect.
+    - *Test (e.g.):* right-click empty space on the project switcher and on a
+      pill → only the custom menu appears; the default webview Reload/Inspect
+      context menu never shows.
+    - [x] 🤖 Automated test — `ProjectSwitcherContextMenu.test.tsx`
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.5 — Branding ✅ Done · 🧪 Untested
+*Files: `src/assets/logo.svg` (new), `src/components/layout/HeaderBar.tsx`, `src-tauri/icons/*`.*
+🧪 Tested: 🤖 automated — N/A (purely visual) · 🖐️ manual ❌ (icons/header not visually verified in a live build)
+
+25. ✅ **Redraw the Eldrun logo in SVG.** Recreated the logo as a clean,
+    symmetric vector (`logo.svg`): green circuit "tree of life" ring, split
+    trunk, mirrored branch traces with node terminals, and the gold spark — left
+    half authored and mirrored across the centre line. Header now imports the SVG
+    (`logo.png` removed). OS app icons (`32x32`, `128x128`, `128x128@2x`,
+    `icon.ico`, `icon.icns`) regenerated from the vector via `tauri icon`, which
+    also fixed the previously mis-sized (all 650×650) raster icons.
+    - *Test (e.g.):* launch a packaged build → the header renders the new
+      SVG logo crisply, and the OS app/taskbar icon shows at correct sizes (not a
+      stretched 650×650 blob).
+    - [ ] 🤖 Automated test — *N/A: purely visual; manual only*
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.6 — Drag & Drop Reordering ✅ Done · 🧪 Untested
+*Files: `src/stores/tabs.ts` (already has a `reorder(from, to)` action),
+`src/components/layout/CenterPanel.tsx` (tab bar — no drag handlers yet);
+`src/stores/projects.ts` (projects carry a `position` field and are sorted by
+it, but there is no reorder/persist action), `ProjectSwitcher.tsx`/`ProjectPill.tsx`,
+backend `save_projects`.*
+🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
+
+26. ✅ **Drag-and-drop tab reordering.** Tabs in `TabBar.tsx` are now `draggable`
+    with HTML5 drag handlers that call `useTabsStore.reorder(from, to)` on drop.
+    Persistence is automatic — `CenterPanel`'s debounced `saveLayout` effect runs
+    whenever `tabs` changes. Drag feedback via `.tab.dragging` / `.tab.drag-over`.
+    - *Test (e.g.):* drag a tab to a new slot → order updates with drag
+      feedback; reopen the app → the new tab order persisted (saveLayout fired).
+    - [x] 🤖 Automated test — `TabReorder.test.ts`
+    - [ ] 🖐️ Manual test
+
+27. ✅ **Drag-and-drop project ordering.** Pills in `ProjectPill.tsx` are now
+    `draggable` (source id carried in `dataTransfer`); dropping on another pill
+    calls the new `reorderProjects(fromId, toId)` action in `projects.ts`, which
+    splices the active-pill order, renumbers every project's `position` with
+    gap-spaced values (active pills first, inactive after), and persists via
+    `save_projects`. Drag feedback via `.project-pill.drag-over`.
+    - *Test (e.g.):* drag one pill onto another → pills reorder, `position`
+      values are renumbered (active first, inactive after) and written via
+      `save_projects`; restart → order survives.
+    - [x] 🤖 Automated test — `ProjectReorder.test.ts`
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.7 — Right Panel: Hidden Files Section ✅ Done · 🧪 Untested
+*Files: `src/components/files/FileTree.tsx` (the `separateScaffold` split at
+~426-480 and the "scaffold" `file-tree-section-divider`), `fileUtils.ts`
+(`visibleEntries`, `STANDARD_PROJECT_FILES`), `src/styles/themes.css`.*
+🧪 Tested: 🤖 automated ✅ (`HiddenFilesSection.test.ts` green) · 🖐️ manual ❌ (runtime QA pending)
+
+29. ✅ **Collapsible hidden-files section under scaffold.** Keep the existing
+    show/hide filtering (`showHidden` toggle + `hiddenEndings`/`hiddenPaths` in
+    `visibleEntries`) exactly as-is. **Additionally**, when a scaffold section is
+    shown, render a third grouped section **below** the scaffold divider that
+    gathers the hidden folders/files, collapsed (minimized) by default with a
+    click-to-expand header. This is an addition to the existing
+    `separateScaffold` rendering (a parallel `hidden` bucket + a collapsed
+    `<details>`-style divider), not a replacement of the binary show/hide
+    toggle — so hidden items stay discoverable without flooding the tree, and
+    the toggle still works for users who want them inline or fully hidden.
+    - *Test (e.g.):* in a project with hidden files, the scaffold view
+      shows a collapsed "hidden" section below the divider; clicking its header
+      expands it; the existing show/hide toggle still works independently.
+    - [x] 🤖 Automated test — `HiddenFilesSection.test.ts`
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.8 — Right Panel: Persist Script-Run Animation ✅ Done · 🧪 Untested
+*Files: `src/components/files/FileTree.tsx` (`runningScripts` state + the
+`script-finished` listener at ~136, `runShellScript`, `.file-run-spinner`),
+`src/components/layout/RightPanel.tsx` (renders `<FileTree>` only `{open && …}`).
+Related to the run-detached backend `run_script_detached` in `commands/apps.rs`.*
+🧪 Tested: 🤖 automated ✅ (`ScriptRunState.test.ts` green) · 🖐️ manual ❌ (runtime QA pending)
+
+34. ✅ **Keep the `.sh` run animation alive when the right panel hides.** Today
+    `FileTree` is mounted only while the panel is open (RightPanel
+    `{open && (<FileTree…>)}`), so hiding the panel unmounts the tree and drops
+    both the local `runningScripts` set and the `script-finished` subscription —
+    when reopened, a still-running script shows no spinner and a completed run is
+    never reflected. Lift the running-scripts state and the `script-finished`
+    listener out of `FileTree` into a persistent owner (a small store like
+    `activity.ts`, or an `AppShell`-level listener) so the run animation/state
+    survives panel hide/show and the button re-renders correctly on reopen.
+    - *Test (e.g.):* run a long `.sh`, hide the right panel, reopen →
+      spinner is still active; let it finish while hidden → on reopen the button
+      shows the finished (non-spinning) state.
+    - [x] 🤖 Automated test — `ScriptRunState.test.ts`
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.9 — Center Panel: Free Tab Arrangement / Grid View ✅ Done · ⛔ Superseded by D.11
+*The per-scope auto-grid (`grid`/`gridByScope`/`toggleGrid`/`setGrid` + ▦ button)
+was **removed** and replaced by the tiling split-subwindow model in Group D.11.
+`TerminalView`'s `visible`/`focused` prop split survives and is reused there.
+`GridView.test.ts` now only asserts the old grid API is gone.*
+🧪 Tested: 🤖 automated ✅ (`GridView.test.ts` green) · 🖐️ manual ❌ (runtime QA pending)
+
+35. ✅ ⛔ **Free arrangement of tabs / grid view — superseded.** The original
+    per-scope auto-grid (columns = `ceil(sqrt(n))`) is gone; tab arrangement is
+    now the directional tiling split model (Group D.11 / #36). The reusable
+    `TerminalView` `visible`/`focused` prop split and the all-scopes-mounted pane
+    approach carried over. `GridView.test.ts` was rewritten to assert the grid
+    store API no longer exists.
+    - [x] 🤖 Automated test — `GridView.test.ts` (asserts removal)
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.10 — Project Model, Import & Publishing ✅ Done · 🧪 Untested
+*Files: `src-tauri/src/commands/projects.rs` (`normalize_git_type`,
+`ImportProjectRequest.skip_scaffold`, create/import defaults + read-time
+migration), `src-tauri/src/commands/github.rs` (new `github_publish`),
+`lib.rs`/`commands/mod.rs` (registration), `ProjectSwitcher.tsx` (push-target select +
+skip-scaffold checkbox), `ProjectPill.tsx` (Publish window + menu),
+`src/stores/projects.ts` (`publishProject`), `src/types/index.ts`,
+`themes.css` (`.skip-scaffold-row`). Tests: `projects_commands.rs`
+(`import_project_skip_scaffold_…`), unit tests for `normalize_git_type` and
+`shell_quote`.*
+🧪 Tested: 🤖 automated ✅ (suite green; #22 publish = shell_quote only) · 🖐️ manual ❌ (`github_publish` runtime QA pending)
+
+20. ✅ **No-scaffold option for import.** `ImportProjectRequest` gained a
+    `skip_scaffold` flag (default false); `finish_import` now gates the
+    `scaffold_project` call (and its `git init`) on it, still writing
+    `project.json` so the project registers. The import dialog shows a "Skip
+    scaffolding (project already has its own files)" checkbox that also hides the
+    scaffold-fill guidance and suppresses the scaffold-fill agent tabs.
+    - *Test (e.g.):* import an existing repo with "Skip scaffolding"
+      checked → no `AGENTS.md`/`CLAUDE.md`/etc. added and no `git init`, but
+      `project.json` is written so it registers (cf. `import_project_skip_scaffold_…`).
+    - [x] 🤖 Automated test — `projects_commands.rs::import_project_skip_scaffold_does_not_add_missing_scaffold_files`
+    - [ ] 🖐️ Manual test
+
+21. ✅ **Rename public/private → local/remote (push-target axis).** `git_type`
+    now models the git **push** target — distinct from the SSH **work**-remote —
+    with three values: `local`, `remote-private`, `remote-public`. New projects
+    default to `local`. A `normalize_git_type` helper migrates legacy values
+    (private → remote-private, public → remote-public) on read in `get_projects`
+    / `load_project` and canonicalizes writes. The dialog's "Git push target"
+    select offers the three options.
+    - *Test (e.g.):* a legacy project with `git_type: "private"` loads as
+      `remote-private` via `get_projects`; a brand-new project defaults to
+      `local` (cf. the `normalize_git_type` unit test).
+    - [x] 🤖 Automated test — `commands/projects.rs` normalize_git_type unit tests
+    - [ ] 🖐️ Manual test
+
+22. ✅ **"Make repo public" publish flow.** New `github_publish(project_id,
+    visibility)` command shells out to `gh repo create <name> --public|--private
+    --source=. --remote=origin --push`. For SSH work-remote projects it runs over
+    `ssh` on the host where the bytes live (reusing `ssh_base_args`/`validate_arg`
+    + single-quoted remote argv). On success it records `git_type =
+    remote-<visibility>` in both `projects.json` and `project.json`. Surfaced via
+    a "Publish to GitHub…" entry in the project-pill context menu opening a
+    visibility-picker window; the store's `publishProject` mirrors the new push
+    target into state. Requires `gh` installed + authenticated. **Runtime QA
+    pending** (agents can't launch Eldrun).
+    - *Test (e.g.):* on a local project, "Publish to GitHub…" → pick
+      public → `gh repo create` runs and `git_type` flips to `remote-public` in
+      both json files; for an SSH project the command runs over `ssh` on the host.
+    - [x] 🤖 Automated test — *partial:* `commands/github.rs` shell_quote unit tests (argv escaping only; full gh/ssh publish flow is manual)
+    - [ ] 🖐️ Manual test
+
+23. ✅ **GitLab support alongside GitHub.** `commands/github.rs` renamed to
+    `commands/git_publish.rs`; `github_publish` generalized to
+    `publish_project(project_id, provider, visibility)` with a `Provider`
+    enum (`github`→`gh`, `gitlab`→`glab`). GitHub keeps `gh repo create …
+    --source=. --remote=origin --push`; GitLab runs `glab repo create …
+    --remoteName origin` then an explicit token-authenticated `git push -u origin
+    HEAD` (glab has no `--source/--push`), reusing the inline credential-helper
+    pattern (`oauth2` username, `GITLAB_TOKEN` for the CLI). Provider recorded in a
+    new `Project.git_provider` field (mirrored into `projects.json`). Publish
+    window gained a provider picker; pill label + menu, settings/hosting
+    placeholders, lessons, README and DOCUMENTATION updated. **Runtime QA pending**
+    (needs `glab` installed + authenticated; agents can't launch Eldrun).
+    - *Test (e.g.):* on a local project, Publish → GitLab → private runs `glab repo
+      create … --private --remoteName origin` then `git push`, and `git_type` flips
+      to `remote-private` with `git_provider: "gitlab"` in both json files.
+    - [x] 🤖 Automated test — `commands/git_publish.rs` provider-parse + remote-script unit tests (argv only; full glab/ssh flow is manual)
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.11 — Center Panel: Tiling Split Subwindows ✅ Done · 🧪 Untested
+*Files: `src/stores/tabs.ts` (layout-tree model: `SplitNode`/`GroupNode`,
+`splitWithTab`/`moveTab`/`reorderInGroup`/`resizeSplit`/`removeTab` collapse,
+`serializeTree`/`deserializeTree`, per-scope `layoutByScope`/`focusedGroupByScope`),
+`src/components/layout/CenterPanel.tsx` (recursive split render + measured-rect
+pane positioning + panel-wide drop tracking), `src/components/tabs/Subwindow.tsx`
+(per-group frame + L/R/T/B/center drop zones), `src/components/tabs/TabBar.tsx`
+(per-group bar, cross-group drag payload `{key, fromGroup}`),
+`src/components/layout/HeaderBar.tsx` (global tab bar removed), `src/stores/projects.ts`
+(threads `tabGroups` through project switch via shared `serializeTree`),
+`src/styles/themes.css` (`.subwindow`, `.split`/`.split-divider`, `.drop-zone`).
+Backend: `schema/project.rs` `tab_groups`, `commands/projects.rs::save_tab_layout`,
+`services/terminal_service.rs`, `schema/session.rs`, `services/project_runtime.rs`.
+Tests: `src/__tests__/SplitLayout.test.ts`.*
+🧪 Tested: 🤖 automated ✅ (`SplitLayout.test.ts` green, 85 vitest + cargo) · 🖐️ manual ❌ (runtime QA pending)
+
+36. ✅ **Tiling split subwindows (directional drag-drop splits).** Reworked the
+    center panel from one header tab bar + auto-grid into a tiling layout of
+    subwindows. Each subwindow (group) owns its tabs and renders its own tab bar;
+    dragging a tab onto another subwindow's edge (L/R/T/B) splits that direction
+    into a new subwindow, onto its center moves the tab in. Splits resize via
+    draggable dividers (`resizeSplit`, clamped, divider-pair math). The layout is
+    a per-scope tree (`layoutByScope`); flat tab payloads stay per-scope so PTYs
+    never unmount. `removeTab`/`moveTab`/`splitWithTab` collapse emptied groups
+    and lone splits and keep focus + `activeKey` on a surviving group. Persisted
+    as `tab_groups` in `project.json` alongside the flat `tab_layout`, round-trips
+    through project switch (`switch_project_runtime`); absent → single group
+    (legacy projects). **Backend rebuild/restart required** for `tab_groups`
+    persistence (per CLAUDE.md; agents can't launch Eldrun).
+    - *Test (e.g.):* drag a tab onto a subwindow's right edge → a 2-way row split
+      with the dragged tab in a new group sized 50/50; close its only tab → split
+      collapses back to one group with focus on the survivor; reload restores the
+      tree from `tab_groups`.
+    - [x] 🤖 Automated test — `SplitLayout.test.ts` (splits/collapse/move/resize/load)
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.12 — Layout fix: project switcher in the top header ✅ Done · 🧪 Untested
+*Files: `src/components/layout/HeaderBar.tsx` (`header-center`),
+`src/components/layout/ProjectSwitcher.tsx` (renamed from the old `BottomBar`),
+`src/components/layout/AppShell.tsx`, `RightPanel.tsx`, `themes.css`.*
+🧪 Tested: 🤖 automated ✅ (`ProjectSwitcherContextMenu.test.tsx` green) · 🖐️ manual ❌ (runtime QA pending)
+
+14. ✅ **Stop bottom/right panel intersection.** Resolved by moving the project
+    switcher out of the bottom overlay into the top header (`HeaderBar`
+    `header-center`); the old `BottomBar` component became `ProjectSwitcher.tsx`.
+    With no bottom bar there is nothing left to overlap the right panel, and the
+    pill menus now open downward.
+    - *Test (e.g.):* the project pills render in the top header; revealing the
+      right panel no longer collides with a bottom bar.
+    - [x] 🤖 Automated test — `ProjectSwitcherContextMenu.test.tsx`
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.13 — Right Panel: Pin / Dock Option ✅ Done · 🧪 Untested
+*Files: `src/components/layout/AppShell.tsx` (hover-reveal/auto-close timers
+`handleBodyMouseMove`/`scheduleClose`, `rightPinned` state), `RightPanel.tsx`
+(`right-panel-header` pin button), `src/stores/settings.ts`
+(`right_panel_pinned`), `src/styles/themes.css` (`.right-panel`/`.app-body`).*
+🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
+
+37. ✅ **Pin the right panel open.** A 📌 toggle in the `right-panel-header`
+    keeps the panel persistently open instead of auto-hiding on mouse-leave; when
+    pinned the hover-reveal/auto-close timers are suppressed and the panel takes
+    layout space (no overlap of the center terminal). The pinned flag persists in
+    `settings.json` (`right_panel_pinned`) and is restored on launch.
+    - *Test (e.g.):* click the pin → panel stays open after the cursor leaves;
+      center reflows (no overlap); toggle off → reverts to hover-reveal; restart →
+      pinned state restored.
+    - [x] 🤖 Automated test — covered by the right-panel suite
+    - [ ] 🖐️ Manual test
+
+---
+
+---
+
+## Group D.14 — File → Tab: In-App Viewers & Embedded Tabs (Phase 1) ✅ Done · 🧪 Untested
+*Files: drag source `src/components/files/FileTree.tsx`, drop targets
+`src/components/tabs/TabBar.tsx`/`Subwindow.tsx` + `commitFileDrop.ts`,
+`src/stores/tabs.ts` (`"embed"` tab kind, `viewer`/`embedExec`), in-app viewers
+`src/components/embed/FileViewerPane.tsx` + `EmbedPane.tsx`,
+`src/components/files/markdown.ts`, `fileUtils.ts` (`internalViewerFor`),
+backend `commands/apps.rs` (`embed_capability`, default-app resolution),
+`commands/tex.rs` (`tex_capability`/`compile_tex`). Tests:
+`FileDropAddsEmbedTab`/`FileDropEmptyFirstTab`/`FileDropSplitsSubwindow`,
+`EmbedCapabilityGate`, `InternalViewer`, `Markdown`, `embed_capability_tests.rs`.*
+🧪 Tested: 🤖 automated ✅ (suite green) · 🖐️ manual ❌ (runtime QA pending)
+
+40. ✅ **Drag a file from the right panel into a (sub)window's tab bar to open it
+    in a tab (Phase 1).** Dragging a file row onto a subwindow's tab bar opens a
+    new `"embed"` tab **named after the file**. Two backends: files with a
+    built-in viewer (`internalViewerFor` → PDF, image, markdown, or text) render
+    **in-app** via `FileViewerPane` — a zoom/pan image view, a PDF iframe, a
+    markdown Edit/Preview toggle, and an editable code editor (line-number gutter,
+    Tab/Shift+Tab indent, Ctrl+S save). Other files open in their external default
+    app via `EmbedPane`, gated on an `embed_capability` check. Only in-app
+    `viewer` embeds persist/restore across restart. TeX files additionally get a
+    compile affordance when a LaTeX engine is on `PATH` (`tex_capability` /
+    `compile_tex`). **Phase 2 (live X11-reparented frameless embedding) deferred**
+    — see `docs/group_k_plan.md`.
+    - *Test (e.g.):* drag `notes.md` onto a subwindow's tab bar → a `notes.md`
+      tab opens rendering the markdown in-app; drag a `.png` → zoomable image
+      tab; on an unsupported OS/app a non-viewer file opens externally as before.
+    - [x] 🤖 Automated test — `FileDrop*`/`InternalViewer`/`Markdown`/`EmbedCapabilityGate`
+    - [ ] 🖐️ Manual test
+
+*This is an organizational plan. Pick an item by its number and I'll produce a
+focused implementation plan + changes for just that item.*
+
+---
+
+## Group N — Native Calendar ✅ Done · 🧪 Untested
+*Files: `src-tauri/src/schema/calendar.rs`, `src-tauri/src/commands/calendar.rs`,
+`src/components/calendar/*`, `src/stores/{calendar,alarms}.ts`,
+`src/lib/{calendarTime,recurrence,ics,alarms,calendarCategories}.ts`. Brought the
+month-grid-only calendar up to Thunderbird-class features. The store is global —
+one `calendar.json`, shown by every calendar tab in every scope.*
+
+N1. **Event model v2 + migration.** `{date, time}` → `{start, end, all_day}` with
+    exclusive ends, plus location/category/status/rrule/alarms, and calendars +
+    tasks alongside. `calendar.json` became an object; the legacy bare array still
+    loads and is migrated on read (`CalendarFile`).
+    - [x] 🤖 Automated test — migration, CRUD, orphan refile (`commands/calendar.rs`)
+
+N2. **Views.** Day / week / multiweek / month / agenda / tasks, with a mini-month
+    + calendar list sidebar, a search box, and keyboard nav (←/→, T, N, 1-6).
+    Multi-day events render as spanning bars; day/week supports drag-to-create,
+    drag-to-move and edge-drag-to-resize (pointer events — HTML5 DnD is unusable
+    under WebKitGTK).
+    - [ ] 🧪 Manual — drag/resize in week view; multi-day bars in month view
+
+N3. **Recurrence.** Daily/weekly/monthly/yearly with interval, byweekday,
+    bymonthday, until/count. Editing or deleting one occurrence of a series
+    prompts "this occurrence / all occurrences" (exdates + per-occurrence
+    overrides, keyed by the rule-generated start).
+    - [x] 🤖 Automated test — `src/__tests__/Recurrence.test.ts` (39 cases)
+
+N4. **Reminders.** Fire on **both** channels: an OS notification
+    (`tauri-plugin-notification`) so it lands when Eldrun is unfocused, and an
+    in-app popup with snooze/dismiss, mounted in `AppShell` so it shows on any
+    tab. Fired alarms are keyed and persisted, so one never fires twice.
+    - [x] 🤖 Automated test — `src/__tests__/Alarms.test.ts` (fire-once, snooze)
+    - [ ] 🧪 Manual — confirm the OS notification actually appears on KDE/Wayland
+
+N5. **Multiple calendars, categories, tasks, ICS.** Named/colored/toggle-visible
+    calendars; a category→color palette; VTODO tasks (due, priority, % complete);
+    and ICS import/export through `calendar_read_ics`/`calendar_write_ics` —
+    deliberately narrow, extension- and size-guarded commands, because the general
+    `read_file_text`/`write_file_text` are confined to the current project and
+    that confinement is worth keeping.
+    - [x] 🤖 Automated test — `src/__tests__/Ics.test.ts` (round-trip, folding, guards)
+    - [ ] 🧪 Manual — import a real .ics from Thunderbird/Google and check fidelity
+
+N6. **Deferred.** Timezone support (everything is floating local time; a `TZID`
+    we do not understand is dropped rather than guessed at), CalDAV/URL
+    subscriptions, ordinal BYDAY ("2nd Monday" degrades to plain Monday), and
+    per-occurrence category/status overrides.
+
+---
+
+## Group U — Usage Stats & Daily Recap ✅ Done · 🧪 Untested
+
+A local usage-counter store (`usage_stats.json`) plus a recap dialog that opens on
+the first launch of each day and from a Settings button. Answers "you used 4 agent
+tabs today (2 Claude, 1 Codex, 1 qwen3), asked them 37 things, and
+created/modified/deleted 12/47/3 files", with Day / Week / Month windows and time
+per project. Everything is counted locally; nothing is sent anywhere.
+
+Design notes worth keeping in mind before extending it:
+
+- The store is `schema::usage_stats`, modelled on `schema::net_usage` (same
+  hour+day buckets, same prune-on-save). Its payload is an **open string-keyed
+  counter map**, so a new statistic costs one const in `metric` (mirrored in
+  `src/lib/usageMetrics.ts`) and one render line — no schema migration.
+- Time, network bytes and git are **not** counted into it. They are read from
+  `time_summary.json`, `net_usage.json` and `git log` at recap time, so they can
+  never drift from their sources.
+- Tab opens are counted in the frontend's `addTab`, **not** at `pty_spawn`: the
+  backend spawn fires again for every resumable agent tab respawned on relaunch,
+  which would report a fresh "agent tab opened" each morning.
+
+86. **Prompt counting is a keystroke heuristic.** `lib/promptCount.ts` counts a
+    submit as "Enter with content typed since the last Enter". It covers all
+    eleven agents and every local model without reading another app's data dir,
+    but an Enter inside an agent's multi-line editor buffer over-counts. If Claude
+    and Codex ever expose a supported per-session message count, prefer it for
+    those two and keep the heuristic as the fallback for the rest.
+    - [x] 🤖 Automated test — `src/__tests__/PromptCount.test.ts` (arrow keys,
+      Ctrl-C, bare Enter, paste-then-Enter, per-PTY independence).
+    - [ ] 🖐️ Manual test — send N prompts to a Claude tab, confirm the recap says N.
+
+87. **File churn is local-filesystem only.** The recursive `notify` watcher
+    (`services::usage_stats`) cannot see an SFTP tree, so a remote project is
+    counted only through its **local mirror**, and one without a mirror records
+    nothing. The recap states this rather than showing a misleading zero. Revisit
+    if a remote-side watcher (inotify over SSH) is ever worth the complexity.
+    - [x] 🤖 Automated test — `classify_fs_event` + `is_ignored` + `Debouncer`
+      cover create/modify/delete, every ignore rule, and burst collapsing.
+    - [ ] 🖐️ Manual test — create/edit/delete files, confirm the counts match; run
+      a `cargo build` and confirm `target/` churn does NOT show up.
+
+88. **One watcher at a time.** Only the *active* project's tree is watched, so
+    churn in a background project is not counted. Watching every open project
+    would mean an inotify tree per project. Reconsider if per-project file stats
+    while multitasking turn out to matter.
+    - [ ] 🖐️ Manual test — switch projects, confirm the watcher follows.
+
+89. **Buckets are UTC.** Matching `time_summary.json` and `net_usage.json`, so all
+    three line up. A late-night session lands in "tomorrow" for users well west of
+    UTC. Fixing it means a timezone-aware bucket key across all three stores.
+    - [ ] 🖐️ Manual test — confirm the recap's day matches the timer's day.
+
+90. **Only the recap reads the counters.** `usage_summary` already returns
+    per-project buckets and the hour buckets are recorded but only used for the
+    Day sparkline. Cheap follow-ups if wanted: a per-project stats view, an
+    all-time "since you started using Eldrun" panel, and streaks.
+    - [ ] Not started.
+
+---
diff --git a/todo/group-a.md b/todo/group-a.md
new file mode 100644
index 0000000..e880fec
--- /dev/null
+++ b/todo/group-a.md
@@ -0,0 +1,86 @@
+## Group A — Bottom Panel: Meta-Project Grouping (new feature)
+*Files: data model (`schema/project.rs`/`projects.rs`, `types/index.ts`), `ProjectSwitcher.tsx`, `ProjectPill.tsx`. No grouping concept exists today.*
+
+13. **Project boxes / meta-project management.** Right-click to create a named,
+    renamable box (e.g. PaperBox, CodingBox) that groups projects, with
+    drag-and-drop of pills into boxes. Requires a new grouping field in the
+    project/entry schema plus drag-drop UI and grouped rendering. Largest bottom-
+    panel item.
+    > **Phase 1 (#13) DONE (🤖 covered).** Box model (`schema/boxes.rs`
+    > `ProjectBox`/`BoxRelation`, `boxes.json`) + box CRUD commands
+    > (`commands/boxes.rs`: get/save/create/rename/delete/set_box_members) +
+    > native-DnD pill-into-box + ungrouped-drop-zone + grouped pill rendering with
+    > a distinct `.project-box-chip` (badge + member count) +
+    > `stores/boxes.ts`/`BoxChip.tsx`. `box_id` rides in `ProjectEntry.extra`;
+    > member_ids authoritative, `box_id` derived in-memory on load (no write).
+
+41. **Project box containers (merge of two or more projects).** Building on #13,
+    let a box be opened as a single *merged* workspace that spans its member
+    projects rather than just a pill grouping. Specifics:
+    - **Merged file view in the right panel.** Extend the right-panel file tree
+      (`FileTree.tsx`/`RightPanel.tsx`) to render a box as a multi-root view —
+      each member project listed as a top-level node, populated from that
+      project's **stored state** (its `project.json` tree layout / file metadata)
+      rather than re-walking only one root. Reuse the existing per-project file
+      model so each member keeps its own git markers, hidden-file sections, etc.
+    - **A box folder in the eldrun root.** Create a `~/eldrun/boxes/<box-name>/`
+      (or similar under the eldrun root) directory per box to host box-scoped
+      state and serve as the cwd for the box's terminals/agents.
+    - **Agent tabs rooted in the box, hinted to each member.** Start the box's
+      agent tabs rooted in the box folder, seeding each agent with hints/pointers
+      to every member project's local agent files (`CLAUDE.md`/`AGENTS.md`/
+      `GEMINI.md` and paths) so the agent can work across all merged projects
+      from one place.
+    - **Boxes in the project search (merge is opt-in).** Surface boxes as results
+      in the "Search inactive…" box (`ProjectSwitcher.tsx`,
+      `activateSearchResult`/`results`) alongside individual projects; picking a
+      box result opens the merged box workspace. The merge is **opt-in** — a box's
+      member projects stay independently searchable and can each be loaded on
+      their own as a normal single project, without activating the box merge.
+    - **Visual distinction box vs. single project.** Give boxes a distinct look
+      from single projects everywhere they appear — in the search results
+      (`project-search-row`), the pills (`ProjectPill.tsx`/`project-switcher`),
+      and the right-panel multi-root header — e.g. a box icon/badge, member count,
+      and/or a grouped style, so a merged box is never mistaken for a plain
+      project. Add the corresponding styles in `themes.css`.
+    - **Inter-project relations within a box.** Let a box record directed
+      relations between its members — "a change in project A may influence
+      project B" — e.g. project B depends on a Python library developed in project
+      A, so editing A's library can break/affect B. Model as relation edges in the
+      box metadata (source → dependents, with an optional kind/label like
+      "python-lib" and an optional path/package hint). Surface them so the
+      dependency is visible and actionable: show related members in the box view,
+      flag dependents when a source changes (tie into the existing git-status
+      markers so a dirty source highlights its dependents), and seed the box's
+      agent hints with the relation graph so a cross-project agent knows which
+      members a change ripples into. Auto-detection of relations (e.g. scanning
+      `pyproject.toml`/`requirements.txt`/imports for local-path deps between
+      members) is a stretch goal; manual declaration is the baseline.
+    - Schema/model: extends the #13 grouping field with box-as-workspace metadata
+      (member list, box folder path, relation edges); touches
+      `schema/project.rs`/`projects.rs`, `types/index.ts`, `ProjectSwitcher.tsx`,
+      `RightPanel.tsx`/`FileTree.tsx`, and the runtime/spawn path that sets
+      agent-tab cwd + env. Scope to be refined when picked.
+    > **Phase 2 (#41 groundwork) DONE (🤖 covered):** full box schema stored
+    > (`folder`, `relations` via `set_box_relations`), lazy
+    > `~/eldrun/boxes/<name>/` creation (`ensure_box_folder`, idempotent +
+    > name-collision-safe against reserved `folder`s and on-disk dirs), boxes in
+    > the project search (`.project-search-row.is-box`, opt-in — members stay
+    > searchable), and opt-in box activation (`openBox` → `box:<id>` scope rooted
+    > in the box folder). **Box scopes are session-only this pass** —
+    > `switch_project_runtime` does not persist/restore them.
+    > **DEFERRED (explicit follow-on, NOT this pass):** Phase 3 merged multi-root
+    > file tree (`RightPanel.tsx`/`FileTree.tsx`); Phase 4 agent-hint seeding +
+    > relation-graph surfacing (dirty-source→dependent git markers,
+    > auto-detection). Schema groundwork for both is in place.
+    - [x] 🤖 Automated test — `commands/boxes.rs` cargo tests (reconcile drops
+      unknown member_ids / recomputes box_id inverse / drop-on-delete, gap-spaced
+      position, defaults round-trip, folder-collision suffixing); `paths.rs`
+      `boxes_root`; vitest `BoxAssignment` (assign/unassign/move/delete sweep,
+      create/rename, derive-on-load no-write), `BoxRendering` (grouped vs inline,
+      orphan box_id inline, chip drop ≠ reorder, ungrouped drop), `BoxSearch`
+      (is-box row → openBox, members independently searchable). Covers Phase 1 +
+      Phase 2 groundwork; Phase 3/4 deferred.
+    - [ ] 🖐️ Manual test
+
+---
diff --git a/todo/group-c.md b/todo/group-c.md
new file mode 100644
index 0000000..334975c
--- /dev/null
+++ b/todo/group-c.md
@@ -0,0 +1,27 @@
+## Group C — Workspace Switching / Platform Stability
+*Files: `src-tauri/src/platform/x11.rs`, `wayland_kde.rs`, `null.rs`, `services/window_service.rs`, `services/project_runtime.rs`, `commands/workspace.rs`.*
+
+15. **Securely move opened files/windows to the hidden workspace on switch
+    (X11).** Fix the reported issue where files/windows opened in one project
+    aren't reliably parked on the hidden desktop when switching. Investigate the
+    move-retry logic (x11.rs ~retry 5×30ms) and window registry coverage.
+
+16. **Make X11 workspace switching rock-solid.** Broader hardening of the
+    two-desktop parking model — fix all known races/flakiness around
+    show/hide/switch. (#15 is a specific symptom of this.)
+
+17. **Preserve window z-order across switches.** Today `show_window` always
+    raises to `Above` (x11.rs:120), losing stacking order. Track per-window
+    z-order in the window registry/session and restore it on show.
+
+18. **KDE Plasma i3-style workspace mode.** Explore an i3-like tiling/workspace
+    behavior on KDE Plasma. Note: KDE Wayland per-window show/hide is currently a
+    **no-op** (`wayland_kde.rs:74-80`) and needs KWin scripting first — this is
+    research + sizable backend work.
+
+19. **Cross-platform verification: Windows, macOS, KDE Plasma.** Verify the app
+    runs and degrades gracefully where workspace backends are absent (null
+    backend) and KDE works. Mostly QA + targeted fixes. OS-specific build,
+    packaging, and native-window work is tracked separately in Group H (#30/#31).
+
+---
diff --git a/todo/group-e.md b/todo/group-e.md
new file mode 100644
index 0000000..a7e482d
--- /dev/null
+++ b/todo/group-e.md
@@ -0,0 +1,10 @@
+## Group E — Git Worktree (new feature)
+*Implemented in `src-tauri/src/commands/git.rs` + `src/components/files/GitHistory.tsx`.*
+
+23. **Git worktree support.** [DONE] Backend commands
+    `git_worktree_list`/`git_worktree_add`/`git_worktree_remove`/`git_worktree_prune`
+    (porcelain parser, registered in `lib.rs`) plus a "Worktrees" section in the
+    history view (list, create-from-branch, remove). STRETCH "open worktree as
+    project" intentionally deferred.
+
+---
diff --git a/todo/group-f.md b/todo/group-f.md
new file mode 100644
index 0000000..8181b8b
--- /dev/null
+++ b/todo/group-f.md
@@ -0,0 +1,107 @@
+## Group F — Session Restore
+*Files: `src-tauri/src/schema/active_session.rs` (defined but unused), `services/project_runtime.rs`, `terminal_service.rs`, `src/stores/tabs.ts`, `CenterPanel.tsx`.*
+
+24. **Restore/resume agent sessions.** Terminal/tab layout persistence already
+    exists (`.eldrun/sessions/terminals.json`), but app-startup restore via
+    `active_session.json` is **unused**. Wire up restoring the full prior session
+    (active project, tabs, windows) on launch. Feasibility note: resuming the
+    actual *agent* process state depends on the agent CLI's own resume support;
+    realistic scope is restoring tabs + relaunching the agent, not live state.
+    Agent-resume approach (migrated from TODO `ISSUE-RESUME`): when restoring a
+    tab, detect that tab's most recent agent session ID from the agent's own
+    session directory — Claude Code `~/.claude/projects/<encoded>/`, Codex
+    `~/.codex/sessions/`, Gemini `~/.gemini/history/`, Vibe
+    `$VIBE_HOME/logs/session/` — and pass `--resume <id>` when respawning. A
+    prior attempt was removed 2026-06-07 because detection was unreliable and
+    **each tab must track its own distinct session ID** (not the project-global
+    latest) to work with multi-agent setups; solve per-tab session tracking
+    before relying on `--resume`.
+
+39. **Per-tab agent session restore — stepwise.** Concrete, incremental path to
+    #24's hard part (per-tab session tracking), built one step at a time so each
+    step is verifiable on its own.
+    - [x] **39a — Surface a tab's launch session id (Claude).** ✅ Done. Eldrun
+      mints a UUID and launches Claude with `claude --session-id <uuid>`, stored
+      on `TabEntry.sessionId` and shown on tab hover. This **launch id** is
+      deterministic, stable, and unique per tab. *Files: `stores/tabs.ts`
+      (`sessionId`), `components/tabs/TabBar.tsx`.* Pure frontend — no rebuild.
+      **Known limitation (drove the design):** the id does **not** follow a
+      `/clear` (which rolls Claude onto a new session id). A first attempt
+      resolved the "live" id from the newest `<uuid>.jsonl` in
+      `~/.claude/projects/<encoded-cwd>/`, but that was **removed** — all Claude
+      sessions in a project (other tabs, *and the dev agent running in the same
+      cwd*) share one folder, so "newest file" cross-contaminates: two tabs
+      showed the same id and it drifted as any session wrote. Following `/clear`
+      reliably needs per-process attribution, not directory guessing → 39c.
+      - *Test (e.g.):* open two Claude tabs in one project → each hover shows a
+        distinct, stable UUID that never changes while the tab is open.
+      - [ ] 🤖 Automated test — none yet (trivial frontend tooltip; covered by
+        manual)
+      - [ ] 🖐️ Manual test
+    - [x] **39b — Persist agent tabs with their session id.** ✅ Done.
+      Resumable agent tabs (Claude with a `sessionId`) are now persisted in
+      `tab_layout` (carrying `sessionId`) and restored on relaunch; other agent
+      tabs are still dropped. *Files: `schema/project.rs` (`TabEntry.session_id`),
+      `stores/tabs.ts` (`isRestorableTab`/`saveLayout`/`loadFromLayout`),
+      `stores/projects.ts`, `components/layout/CenterPanel.tsx`.*
+    - [x] **39c — Track the live session id across `/clear`, then resume.** ✅
+      Done for Claude. The original hard part — following the *live* session id
+      after `/clear` (Claude rolls onto a fresh id with no recorded back-link to
+      the launch id) — is solved with a global Claude **`SessionStart` hook**
+      (fires on startup/resume/clear/compact) that records the live `session_id`
+      keyed by `$ELDRUN_TAB_UID`. Eldrun sets `ELDRUN_TAB_UID` to the tab's
+      stable launch id on spawn, then at (re)spawn resolves the hook-recorded
+      live id and emits `claude --resume <live-id>` (falling back to the launch
+      id, and downgrading to `--session-id` when no log exists yet). The hook is
+      installed once into `~/.claude/settings.json` and no-ops for any Claude not
+      launched by Eldrun. *Files: `services/agent_session.rs` (hook install +
+      live-id store), `terminal/mod.rs` (`resolve_claude_session`), `lib.rs`
+      (install at startup). Hook script: `~/.local/share/eldrun/hooks/`; live ids:
+      `~/.local/share/eldrun/live_sessions/`.*
+    - [x] **39d — Generalize to other agents.** Codex, Gemini and Mistral/vibe done.
+      - [x] **Codex.** ✅ Done. Codex mints its own session id (no launch-time
+        `--session-id`), but it has a Claude-style `SessionStart` hook and resumes
+        by uuid (`codex resume <id>`). Eldrun sets `ELDRUN_TAB_UID` (a per-tab key)
+        on the Codex tab, installs a `SessionStart` hook into `~/.codex/config.toml`
+        (TOML text-append, idempotent) that records the live session id under that
+        key, then at spawn resolves it and launches `codex resume <live-id>` when a
+        rollout log exists (else fresh). Covers `/clear` (Codex `source` includes
+        `clear`). *Files: `services/agent_session.rs` (`register_codex_hook`,
+        `resolve_codex_session`/`codex_session_exists`), `stores/tabs.ts`
+        (`RESUMABLE_AGENTS.codex`), `components/tabs/TabBar.tsx`.*
+        ⚠️ **The trust gate bit us:** user-level Codex hooks need a one-time
+        approval (`/hooks` in Codex), and an unapproved hook *silently* never
+        runs — so in practice this never fired at all (Codex recorded our hook
+        with `enabled = false`, and 0 of 89 `live_sessions/` records were Codex's)
+        and every Codex tab restored blank.
+      - [x] **Codex, hook-free fallback.** ✅ Done. Resume no longer depends on
+        the hook: `services/codex_bind.rs` follows Codex's own rollout logs
+        (`~/.codex/sessions/**/rollout-*.jsonl`, whose `session_meta` header
+        carries `session_id` + `cwd`), attributes a new rollout to the tab that
+        spawned in that cwd, and writes it to the same `live_sessions/<uid>` file
+        the hook would have — so the resolve path is unchanged. The hook stays
+        installed as the *precise* path (it disambiguates two Codex tabs in one
+        cwd, and rebinds on `/clear` instantly); `codex_hook_state` detects the
+        trust gate and the UI offers a one-click "open Codex on `/hooks`" fix
+        (`lib/codexHooks.ts`, `lib/hints.ts`, `SettingsSubPanels.tsx`).
+        Remaining: **remote (ssh) Codex tabs are out of scope** — their rollouts
+        live on the far host, so the binder skips them; making them work means
+        running the rollout scan over `ssh_exec`.
+      - [x] **Gemini.** ✅ Done via **continue-last**. `--session-id <uuid>` sets
+        the launch id (already passed), but `--resume` takes an index/`latest`,
+        not a uuid — so precise resume-by-uuid isn't available. Instead Eldrun
+        restores with `gemini --resume latest`, continuing the project's most-
+        recent session, exactly like Grok/Qwen. Same caveat: two Gemini tabs in
+        one project share that one latest session. *Files: `stores/tabs.ts`
+        (`RESUMABLE_AGENTS.gemini`).* Verified against `gemini --help` (`-r,
+        --resume … "latest"`). Not wired into the plan/auto mode table because
+        continue-last can't guarantee THIS tab's session on respawn (see
+        `components/tabs/agentModes.ts`).
+      - [x] **Mistral/vibe.** ✅ Done via **continue-last**. Vibe mints its own id
+        with no launch-id control, and `--resume` with no id opens an interactive
+        picker (hangs a restore) — but `-c/--continue` "Continue from the most
+        recent saved session" is the non-interactive path, so Eldrun restores with
+        `vibe --continue`. Same shared-latest caveat. *Files: `stores/tabs.ts`
+        (`RESUMABLE_AGENTS.vibe`).* Verified against `vibe --help`.
+
+---
diff --git a/todo/group-g.md b/todo/group-g.md
new file mode 100644
index 0000000..35e0416
--- /dev/null
+++ b/todo/group-g.md
@@ -0,0 +1,1189 @@
+## Group G — Remote / SSH & Containerized Projects (work axes)
+*Files: `src-tauri/src/schema/project.rs` (project model is local-only:
+`directory` is a local path, no host/remote/container fields), `services/project_runtime.rs`,
+`services/ssh_mount.rs` (mount lifecycle — the pattern for container lifecycle),
+`terminal/` (PTY cwd / exec target), `commands/projects.rs` (create/import),
+`commands/ssh.rs`, file-tree commands. These items share a theme: a **work
+axis** — *where the project's process and files live* (host, SSH remote, or
+container) — as opposed to the git **push** axis (#21/#22).*
+
+28. ✅ **SSH-based projects (remote path, remote agent).** Implemented via an
+    **sshfs mount**: a remote project's bytes live on `host:remote_path` and are
+    mounted to `~/.local/share/eldrun/mounts/<project-id>/`; the project's
+    `directory` points at that mountpoint so the file tree, terminal cwd, and git
+    keep working unchanged. New `RemoteSpec` (`user?`, `host`, `port?`,
+    `remote_path`) on the project schema + `projects.json` `extra`. New
+    `commands/ssh.rs` (`ssh_connect`, `ssh_default_dir`, `ssh_list_dir`,
+    `ensure_project_mounted`) shells out to system `ssh` in `BatchMode=yes`
+    (keys/agent/`~/.ssh/config` are the source of truth; no in-app passwords).
+    New `services/ssh_mount.rs` handles mount/unmount lifecycle (idempotent
+    mount, `/proc/mounts` check, `fusermount -u` with `umount` fallback,
+    sshfs-missing guard, unmount-all on app exit). `create_project`/
+    `import_project` accept an optional `remote` and scaffold over the mount
+    (remote import is `keep`-only). `ProjectSwitcher.tsx` add/import dialog gains an
+    SSH-address field + Connect and an in-app remote folder browser. Active
+    remote project is mounted on startup (best-effort, non-blocking) and on
+    switch. Requires `sshfs`/FUSE locally. **Runtime QA pending** (agents can't
+    launch Eldrun); password/interactive auth out of scope for v1;
+    project-removal unmount is a follow-up (no delete command exists yet — stale
+    mounts are cleaned up on next app exit). See `docs/ssh_projects_plan.md`.
+    - *Test (e.g.):* add a project via SSH address against a key-auth host
+      → folder browser lists the remote dir, the project mounts under
+      `mounts/<id>/`, terminal cwd + file tree work on the remote files, and the
+      mount is cleaned up on app exit.
+    - [x] 🤖 Automated test — `services/ssh_mount.rs` unit tests (validate_arg, mountpoint_for, sshfs_args)
+    - [ ] 🖐️ Manual test
+    - **Manual QA checklist (live, step-by-step).** Runtime test plan for
+      #28/#28b — agents can't launch Eldrun, so these are hand-checks. Each box is
+      one check; a phase is done when all its boxes are ticked.
+      - *Phase 0 — prerequisites / baseline.*
+        - [ ] Local tooling on `PATH`: `sshfs`, `fusermount` (or `umount`); for
+          password auth `sshpass`; for VPN-gated hosts `openvpn` + `pkexec`.
+        - [ ] A reachable host with working key/agent auth; ideally a second
+          host/account that requires a **password** (no key) to exercise `sshpass`.
+        - [ ] `cargo test --manifest-path src-tauri/Cargo.toml` green.
+        - [ ] `npx tsc --noEmit` green.
+      - *Phase 1 — connect (`ssh_connect`/`ssh_default_dir`).*
+        - [ ] Tick **Remote (SSH) project** → SSH address + password + Connect
+          section appears.
+        - [ ] `user@host` (key auth, blank password) → Connect succeeds.
+        - [ ] `user@host:port` with a non-default port → Connect succeeds.
+        - [ ] Bare `host` (no user, via `~/.ssh/config`) → Connect succeeds.
+        - [ ] Password-only host + correct password → Connect succeeds (`sshpass`).
+        - [ ] Wrong password → clear ssh-stderr error, no hang.
+        - [ ] Password auth with `sshpass` not installed → actionable error.
+        - [ ] Unreachable host/bad name → fails within ~10s (ConnectTimeout), UI
+          stays responsive.
+        - [ ] Editing the address/password after connect resets to disconnected.
+      - *Phase 2 — browse (`ssh_default_dir`/`ssh_list_dir`).*
+        - [ ] Browser opens at remote `$HOME`.
+        - [ ] Dirs-first, case-insensitive name sort; hidden entries shown;
+          `.`/`..` hidden.
+        - [ ] Click a dir descends; **Up** ascends; can't go above `/`.
+        - [ ] Dir names with spaces/unicode render correctly.
+        - [ ] No-permission directory → error surfaced, dialog stays usable.
+        - [ ] "Use this folder" commits the chosen remote path.
+      - *Phase 3 — create remote project.*
+        - [ ] Connect → browse → Use folder → Create → project created with a
+          generated id.
+        - [ ] Mounted under `~/.local/share/eldrun/mounts/<id>/`; `directory`
+          points at the mountpoint (check `/proc/mounts`).
+        - [ ] Scaffold files written **over the mount** only where missing.
+        - [ ] `project.json` carries `remote`; `projects.json` entry mirrors it
+          under `extra`.
+        - [ ] Create against a password-only host → confirm mount behavior /
+          error (mount path still `BatchMode=yes`; see 28c password half-state).
+      - *Phase 4 — import remote project.*
+        - [ ] Import an existing remote dir (keep-only) → mounts, persists
+          `remote`, does not relocate bytes.
+        - [ ] Scaffold-fill agent tabs are local-disk-only on remote import.
+      - *Phase 5 — mount lifecycle.*
+        - [ ] Switch away and back → mount persists / re-mount is a no-op.
+        - [ ] Restart with a remote project active → startup best-effort mount;
+          an offline host at boot does **not** block app start.
+        - [ ] Quit → `unmount_all` tears down every mount (`/proc/mounts` clean).
+        - [ ] Hard-kill leaving a stale mount → relaunch reuses it without error.
+        - [ ] Host offline mid-session → reconnect/keepalive recovers; no
+          permanent wedge.
+      - *Phase 6 — behaves like local (over the mount).*
+        - [ ] File tree lists remote files.
+        - [ ] Open/edit/save a file → change lands on the remote.
+        - [ ] Git status/history work against the mountpoint.
+        - [ ] Plain shell tab cwd/behavior as expected (see Phase 7).
+      - *Phase 7 — remote agent execution (`ssh_exec.rs`).*
+        - [ ] Claude agent tab runs **on the remote** via `ssh -tt` (verify
+          hostname/env inside the agent).
+        - [ ] Resize resizes the remote PTY; exit/kill ends the remote session.
+        - [ ] Second tab multiplexes over the ControlMaster socket; master
+          persists ~600s after the last session.
+        - [ ] Userspace CLI (`~/.local/bin`/nvm/pyenv) is found (login-shell PATH).
+        - [ ] Auto-bootstrap (probe → install → re-probe; `exit 127` + hint on
+          failure) runs live in the PTY on a remote missing the CLI.
+        - [ ] First-run `claude login` works inside the remote PTY.
+        - [ ] Local `ANTHROPIC_API_KEY`/`OPENAI_API_KEY` is **stripped** from the
+          remote env (remote's own login used).
+        - [ ] `local_only` tabs (local Ollama) are **not** wrapped — run locally.
+        - [ ] Codex/Gemini/Vibe remote tabs — note current behavior (recipes may
+          not be generalized yet).
+      - *Phase 8 — OpenVPN-gated hosts.*
+        - [ ] Project with `remote.openvpn.config` → tunnel comes up first; VPN
+          password prompted and **never persisted**.
+        - [ ] `openvpn_status` detects an already-up tunnel (no double-connect).
+        - [ ] Missing `openvpn`/`pkexec` → actionable error.
+        - [ ] Quit → `disconnect_all` brings tunnels down.
+      - *Phase 9 — security / argument injection (spot-check; mostly auto).*
+        - [ ] UI can't send a host/user/path beginning with `-` to ssh.
+        - [ ] Control chars / newline / NUL in any field rejected.
+        - [ ] Empty host (or empty user when provided) rejected.
+        - [ ] During a password connect, the password is only in the `SSHPASS`
+          env, never in argv (inspect the process list).
+      - *Phase 10 — persistence & restart.*
+        - [ ] Resumable Claude/Codex tabs in a remote project restore and resume
+          on the remote on relaunch.
+        - [ ] `project.json`/`projects.json` round-trip `remote` across restart.
+    - **28b — Remote agent execution (decided 2026-06-19: agents run ON the
+      remote).** A remote project's bytes are sshfs-mounted **only** for
+      Eldrun's own file tree / git / `list_dir`; terminal **and agent** tabs
+      instead run on the remote host via `ssh -tt`. `services/ssh_exec.rs`
+      (`wrap_pty_options`) rewrites any spawn whose cwd is under the mounts root
+      into `ssh -tt [-p port] [user@]host '<remote_command>'`, multiplexed over a
+      ControlMaster socket; `remote_subdir` maps the local mount cwd back to the
+      remote path and `remote_command` builds `cd <dir> && export … && exec
+      <cli> …`. VPN-gated hosts bring an OpenVPN tunnel up first via
+      `services/openvpn.rs` (pkexec + askpass temp file + ready-marker wait,
+      disconnect-all on exit) when `RemoteSpec.openvpn` is set. Rationale and the
+      rejected alternatives (local-CLI-over-sshfs; per-command `ssh host -- …`
+      helper) are in `docs/ssh_projects_plan.md` → *Remote execution model*. This
+      makes a **userspace** agent-CLI install on the remote load-bearing; the
+      items below close the gaps.
+      - [x] **Login-shell PATH for agent tabs.** `remote_command` now runs agent
+        tabs through `exec "${SHELL:-/bin/bash}" -lc '<quoted cli + args>'` (was a
+        bare `exec '<cli>'` under ssh's non-login shell), so a userspace
+        `~/.local/bin`/nvm/pyenv CLI is on PATH and resolves. Shell tabs keep
+        `$SHELL -l`.
+        - [x] 🤖 Automated test — `remote_command_agent_runs_under_login_shell`
+          asserts the `-lc` login-shell wrap with correct single-quoting
+      - [x] **Auto-bootstrap + detect the remote CLI.** Implemented in new
+        `services/remote_agents.rs` (recipe table keyed by agent base name:
+        probe `bin`, userspace `install`, manual hint). Rather than a separate
+        command, `bootstrap_prelude` is **folded into** `remote_command`'s
+        `$SHELL -lc` script for recognised agents: it probes
+        `command -v <bin>`, runs the userspace installer if missing
+        (claude → `npm install -g @anthropic-ai/claude-code`), re-probes, and
+        `exit 127`s with a manual hint on failure — all live in the PTY, so
+        install progress and the first-run `login` show in the terminal. Unknown
+        commands get no prelude. (Chose PTY-folded over a Tauri
+        `ensure_remote_agent` command: no event plumbing, fully unit-testable.)
+        - [x] 🤖 Automated test — `remote_agents` (`recipe_for` base-name match,
+          `bootstrap_prelude` probe/install/abort) + `ssh_exec`
+          `remote_command_agent_bootstraps_known_cli`
+      - [x] **Remote auth = the remote's own login.** Decided: the remote `claude`
+        authenticates with its own `~/.claude` credentials; the first run prompts
+        an interactive `claude login` in the PTY (works because agent tabs get a
+        real `-tt` PTY). `remote_command` now strips agent-auth env vars
+        (`AGENT_AUTH_ENV`: `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`,
+        `CLAUDE_CODE_OAUTH_TOKEN`, `OPENAI_API_KEY`, `GEMINI_API_KEY`,
+        `GOOGLE_API_KEY`) from the exported env so a local key can't clobber the
+        remote session.
+        - [x] 🤖 Automated test — `remote_command_strips_agent_auth_env` asserts
+          auth vars (and their values) are excluded while ordinary env is kept
+      - [ ] **Generalize bootstrap/detect to other agent CLIs** (Codex, Gemini,
+        Vibe): add one `AgentRecipe` row per agent to `remote_agents::RECIPES`
+        (the framework + claude recipe already ship); keep honoring the existing
+        `local_only` flag (local Ollama agents are never wrapped).
+      - [ ] 🖐️ Manual test — connect (VPN if needed) → open a remote agent tab →
+        the CLI is detected/installed, logs in on first run, and runs a pipeline
+        on the remote (remote GPU/env), with edits visible in Eldrun's file tree.
+    - **28c — Hardening & gaps (two-reviewer review, 2026-06-19).** A
+      code-correctness/security pass plus an architecture pass over #28/#28b.
+      Ordered by severity.
+      - [ ] **[Critical] Remote command injection in the browse commands.**
+        `ssh_list_dir`/`ssh_default_dir`/`ssh_connect` (`commands/ssh.rs`) hand
+        remote argv tokens to `ssh`, which space-joins them into one remote
+        `$SHELL -c` string; `validate_arg` only blocks a leading `-`/control
+        chars, so a `path` containing `;`/`$()`/backticks/spaces (e.g. a remote
+        dir name the user clicks while browsing) runs arbitrary remote code.
+        Route these through a shared `shell_quote` (lift from `ssh_exec`) and
+        send a single pre-quoted remote string; add injection tests (`;`, `$()`,
+        backtick, space, quote).
+      - [ ] **[Critical] Remote agent tabs never resume (ordering bug).**
+        `wrap_pty_options` rewrites `opts.cmd` `claude`/`codex`→`ssh`
+        (`commands/terminal.rs`) *before* `spawn_pty`'s `resolve_agent_session`
+        dispatches on `opts.cmd` (`terminal/mod.rs`), so `--resume`/`codex
+        resume` are never injected; the ELDRUN_TAB_UID + SessionStart mechanism
+        is also local-only (it reads the local `~/.claude`/live_sessions while a
+        remote agent logs on the remote). Resolve session args *before* the
+        ssh-exec rewrite and embed them in `remote_command`, and install the
+        SessionStart hook + live-id lookup on the remote — or document remote
+        agents as non-resumable for now.
+      - [ ] **[High] Serialize `mount()` per project id.** The
+        `is_mounted`→`sshfs` sequence in `ssh_mount::mount` is TOCTOU and
+        `ensure_project_mounted` runs from several call sites concurrently, so
+        two activations can stack FUSE mounts (the second shadows the first;
+        `unmount` removes only one → leak). Guard with a per-id global mutex and
+        re-verify `is_mounted` after `sshfs`.
+      - [ ] **[High] Validate exported env in `remote_command`.** Env keys are
+        interpolated raw into `export {k}=…` (`ssh_exec.rs`); a key containing
+        `=`/space/newline injects a second `&&` command. Require keys to match
+        `^[A-Za-z_][A-Za-z0-9_]*$` and reject NUL in any quoted value; test a
+        malicious key.
+      - [ ] **[High] Centralize VPN-gated activation ordering.** The backend
+        mount path (`project_runtime::ensure_remote_mounted`,
+        `ensure_project_mounted`) never calls `openvpn::connect` — only the
+        frontend does — so switching to a VPN-gated project from the backend
+        fails with an opaque ssh timeout. One entry point should do VPN-connect →
+        mount → exec and fail loudly ("VPN not connected — use Connect in the
+        dialog"), since the backend can't prompt for the password.
+      - [ ] **[High] Resolve the password-auth half-state.** `ssh_mount`/
+        `ssh_exec` hardcode `BatchMode=yes`, so a password-only host browses in
+        the dialog but then fails at mount/exec. Either thread the password via
+        `sshpass`/`SSHPASS` (as `commands/ssh.rs` already does for browse) or
+        gate remote create/import on key/agent auth and mark password hosts
+        browse-only — don't ship the silent half-state.
+      - [ ] **[High] Connection-loss / stale-handle recovery + UX.** sshfs
+        `reconnect` doesn't heal a stale FUSE handle (`is_mounted` still returns
+        true → `mount()` no-ops), and exec tabs die silently. Treat a statfs
+        failure on a mounted path as not-mounted so `mount()` remounts; add a
+        reconnect/remount action and a connection-state badge on remote project
+        pills.
+      - [ ] **[Medium] OpenVPN robustness.** (a) `wait_for_ready` only checks the
+        timeout when a new stdout line arrives, so a silent hang (stuck auth /
+        black-hole) blocks `connect` forever — read on a thread with
+        `recv_timeout`. (b) `is_connected` tracks only tunnels this process
+        started, so a tunnel surviving a crash isn't detected and `connect`
+        spawns a duplicate / `pkexec` re-prompts — reconcile via the pidfile/tun
+        device. (c) teardown via `pkexec kill` re-prompts polkit at exit, so the
+        root tunnel can survive app exit — launch once with a teardown trap or a
+        persistent privileged helper.
+      - [ ] **[Medium] Mount-detection edge cases.** Unescape `/proc/mounts`
+        octal sequences (`\040` etc.) and canonicalize before comparing in
+        `is_mounted` (refactor the field parsing into a pure, unit-tested fn) to
+        avoid stacking/leaks when the state-dir path contains spaces; treat
+        `Some(port) == 0` as "no port"; bound/short-hash the ControlPath so it
+        stays under the AF_UNIX 108-byte limit.
+      - [ ] **[Medium] Host-key (TOFU) trust UX.** Browse/mount use
+        `BatchMode=yes`, which *fails* on an unknown host key with no prompt,
+        while the exec path drops BatchMode to prompt in-terminal — but that's
+        only reached after a mount that already failed. Add an explicit
+        `ssh-keyscan`/known_hosts confirmation step in the connect flow.
+      - [ ] **[Medium] Project-delete teardown + startup GC.** When a delete
+        command lands, `unmount` + remove the mountpoint dir + `ssh -O exit` the
+        control master + `openvpn::disconnect` if unused; add startup GC of stale
+        mounts (ties into the stale-handle fix above).
+      - [ ] **[Medium] Generalization auth stories (extends the open item in
+        #28b).** Adding Codex/Gemini recipes is one `AgentRecipe` row each (npm:
+        `@openai/codex`, `@google/gemini-cli`); Vibe likely needs a
+        `manual_hint`-only entry. Each needs a documented remote-auth story, and
+        verify `local_only` is actually set end-to-end for Ollama-backed tabs.
+      - [ ] **[Low] Smaller items.** Replace `which`-based binary detection
+        (`sshfs`/`sshpass`/`openvpn`) with in-process PATH search; lazy-unmount
+        (`-z`) as a last resort at exit; feed the askpass passphrase to OpenVPN
+        via stdin/fd instead of a 0600 temp file (plaintext currently survives a
+        crash); document `parse_ls_output` symlink-vs-dir `-p` semantics.
+      - [ ] 🤖 **Test coverage to add** — injection-safety of the browse `path`;
+        malicious env keys in `remote_command`; a pure `/proc/mounts` field
+        parser (`\040`); `wait_for_ready` timeout with no output; mount
+        double-spawn; `shell_quote` round-trip incl. NUL/newline.
+      - **Refactor / future ideas.**
+        - [ ] **Factor a target-agnostic spawn-rewrite layer (only load-bearing
+          at #38f, remote Docker).** `ssh_exec::wrap_pty_options` hardcodes
+          mount-path detection, `AGENT_AUTH_ENV`, `shell_quote`, the `-lc`
+          login wrap, and the `remote_agents` bootstrap. #38's v2 shape
+          (local project containers, `services/sandbox.rs`) needs none of
+          this — `pty_spawn` keeps its plain two-way dispatch. This refactor
+          only earns its cost once #38f composes a container spawn-rewrite
+          with SSH's (`ssh … docker exec …`). Extract a trait ("PtyOptions +
+          target descriptor → rewritten argv") with SSH and
+          Docker impls so the resume fix, the recipes, and Phase-2 composition
+          (`ssh … docker exec …`) land once.
+        - [ ] **Document the split-model consistency tradeoffs.** git/`list_dir`/
+          file-tree run locally over sshfs while the agent edits on the remote:
+          slow git, weak sshfs inotify (stale tree), line-ending/identity
+          mismatches. Document the model; consider running `git` on the remote
+          via the exec wrapper; add a manual "refresh file tree" affordance.
+        - [ ] **SSH `LocalForward` per project** to reach remote dev-server ports
+          at `localhost:port`.
+        - [ ] **Remote-status panel** (mount state, control-master liveness, VPN
+          state, last error) for debuggability.
+
+38. **Widen the Docker sandbox into a full project container.** ~~Run projects
+    inside Docker containers~~ — **superseded 2026-07-13: this is now an
+    evolution of the shipped agent sandbox (`services/sandbox.rs`), not a
+    second containerization feature.** There is exactly one such feature.
+    Full plan (v2): `docs/docker_projects_plan.md`. **Implemented 2026-07-13
+    (38a–38e; 38f stays deferred; manual/live Docker QA pending — see the
+    plan's runtime checklist).** The `DockerSpec` /
+    `docker_runtime.rs` / `docker_exec.rs` / `commands/docker.rs` design
+    below (dated 2026-06-19) is **superseded** — kept struck through for
+    history, do not implement it as written:
+
+    ~~Let a project be started in a Docker container instead of (or in
+    addition to) directly on the host: the project's terminal/agent tabs run
+    via `docker exec` into a container, with the project directory
+    bind-mounted as the working dir so the file tree and git keep working.
+    Mirrors the two-mechanism split the SSH axis (#28) settled on — a
+    lifecycle service `services/docker_runtime.rs` (cf. `ssh_mount.rs`) and a
+    spawn-rewrite service `services/docker_exec.rs` (cf. `ssh_exec.rs`).~~
+
+    **v2 shape.** The existing per-tab ephemeral sandbox (`SandboxSpec`,
+    `services::sandbox`) grows into a per-project, session-lived container:
+    same toggle, same `SandboxSpec` (gains `dockerfile`), same `sandbox` key
+    in `project.json`/`projects.json` `extra` — already-toggled projects
+    upgrade in place, no migration, no new schema/`DockerSpec`. Mounts stay
+    at their **identical host path** (not `/workspace` — keeps agent session
+    resume valid), so the v1 `container_workdir` translation layer, the
+    `ContainerSource` enum, `run_args`, and `engine` (podman) are all dropped
+    for v1. `services/sandbox.rs` gains the lifecycle half itself
+    (`up`/`down`/`down_all`/`sweep_orphans`, `eldrun-<project-id>` naming +
+    `eldrun.owner`/`eldrun.spec-hash` labels, mirroring `services/remote.rs`'s
+    per-project connection lifecycle) instead of a new `docker_runtime.rs`;
+    `wrap_pty_options_docker` becomes run-once-then-exec-per-tab instead of a
+    new `docker_exec.rs`; no new `commands/docker.rs`. `pty_spawn`'s existing
+    two-way dispatch (sandbox else ssh, `commands/terminal.rs:116-136`) is
+    unchanged — no third rewriter.
+
+    - [x] **38a — Phase 0: fix the shipped sandbox** (independently
+      shippable, lands first because the lifecycle rewrite touches the same
+      lines): preflight daemon-down vs image-missing misdiagnosis; toggle
+      preserves existing `SandboxSpec` fields instead of resetting to
+      default; `--init` + `eldrun.owner`/`eldrun.project` labels on every
+      container; hide/disable the toggle in the Windows UI (backend already
+      refuses, #86).
+    - [x] **38b — Phase 1: container lifecycle.** `up`/`down`/`down_all`/
+      `sweep_orphans` in `services/sandbox.rs`; three-state machine
+      (running+fingerprint-match → no-op; stopped/mismatch → recreate;
+      missing → create) keyed on a `spec_fingerprint` label; mount/hardening
+      code reused from today's per-tab path, moved to the create step;
+      staged hook-registration copies become per-project
+      (`sandbox-stage/<project-id>/`), refreshed at each `up` (fixes today's
+      per-tab stage-dir leak).
+    - [x] **38c — Phase 2: run → exec + tab-kill contract.**
+      `wrap_pty_options_docker` resolves the container via `up()` then
+      rewrites to `docker exec`; per-tab env (incl. `host_auth_env`) moves to
+      the exec step. Docker does not kill an exec'd process when the exec
+      client dies, so tab close needs an explicit kill path (pidfile wrapper
+      + `docker exec <name> kill …` on the PtyRegistry kill, containerized
+      tabs only) — required, not optional, once tabs share one long-lived
+      container.
+    - [x] **38d — Phase 3: wiring + frontend scope widen.**
+      `project_runtime::switch` calls `up`/`down` on activate/deactivate
+      (worker thread, never main — cf. the remote sync-command freeze
+      lesson); `lib.rs` exit hook calls `down_all()`, startup calls
+      `sweep_orphans()`; `CenterPanel.tsx`'s per-tab gate widens from
+      `tab.kind === "agent"` to any non-`local_only` tab of a toggled
+      project; `ProjectPill.tsx` label becomes "Run this project in a
+      container". Flag stays in `TerminalView`'s spawn-effect deps, so
+      toggling still respawns live tabs — Gemini/Vibe lose their
+      conversation on flip, same hazard class as `tabs/agentModes.ts`.
+    - [x] **38e — Phase 4: spec sources & UX.** Auto-detect an in-repo
+      `Dockerfile`/`.devcontainer/devcontainer.json` as the container source;
+      fall back to the existing `eldrun-agent-sandbox:latest` reference
+      image; preflight's "image missing" error becomes a one-click
+      open-new-tab-paste-run build flow (house convention); minimal spec UI
+      for image/network/memory/cpus/readonly (safe now that 38a makes the
+      toggle spec-preserving).
+    - [ ] **38f — Phase 5 (deferred): compose / pre-existing-container
+      variants, persistent (non-session-scoped) containers, remote Docker
+      (container on an SSH host, composing with #28's `ssh_exec` wrapping —
+      this is where the target-agnostic spawn-rewrite refactor below
+      actually becomes load-bearing), Windows (#86).**
+    - [x] 🤖 Automated test — see `docs/docker_projects_plan.md` Tests
+      section (argv/state-machine assertions, no daemon needed): sandbox.rs
+      unit suite (name/fingerprint/up-decision/create+exec argv/stage refresh)
+      + `projects_commands.rs` toggle-preservation/legacy-spec tests
+    - [ ] 🖐️ Manual test
+
+80. **Native SFTP remote browsing (drop `ssh ls` for the folder picker).**
+    Replace the shell-out browse commands in `commands/ssh.rs`
+    (`ssh_list_dir`, `ssh_default_dir`) with an in-process **SFTP** client, so
+    the new/import dialog's remote folder picker no longer parses `ls` text and
+    no longer feeds user-controlled paths to a remote `$SHELL -c`. This is the
+    JetBrains *Deployment*-style model (in-process SFTP browse), and it
+    **supersedes** the #28c "[Critical] Remote command injection in the browse
+    commands" item — SFTP is a binary protocol, so paths are never
+    shell-interpreted and `shell_quote`/`validate_arg` are no longer load-bearing
+    for browsing. **Scope is browsing only:** the project *mount* still uses
+    sshfs (kernel FUSE is unavoidable for a local mountpoint regardless of
+    language — see the install-helper work), and remote *agent/terminal* exec
+    still uses `ssh -tt` (#28b). Nothing here changes the mount or exec paths.
+    - **Library: `openssh-sftp-client`** (rides the system `ssh` ControlMaster).
+      Chosen over `russh-sftp` (pure-Rust but reimplements auth/known_hosts) and
+      `ssh2`/libssh2 (C + openssl build dep) because it reuses the user's
+      `~/.ssh/config`/agent/keys — the "source of truth" the existing `ssh.rs`
+      already commits to — and keeps a single auth story shared with mount/exec.
+    - **Prototype steps.** ✅ **Code-complete (🤖 covered; 🖐️ live QA pending)** —
+      built over `openssh-sftp-client` driving a child `ssh -s sftp` over its
+      pipes (no `openssh` ControlMaster crate needed); the password-arg builder
+      was lifted to `services::ssh_mount::ssh_password_base_args` so browse +
+      SFTP share one validated auth path.
+      - [x] **80a — Dep + thin `services/sftp.rs` session helper.** ✅ Done.
+        `open_session(user, host, port, password)` spawns `ssh`/`sshpass -e ssh`
+        with the shared base args, splices `-s <target> sftp`, and hands the
+        child's stdin/stdout to `Sftp::new`. Keeps the `validate_arg` guard on
+        `path` as defense in depth. (Drove the design: chose raw-pipe `Sftp::new`
+        over the `openssh`-feature `from_session` so no ControlMaster crate is
+        pulled in; `ReadDir` is `!Unpin` → `Box::pin` to drive the stream.)
+      - [x] **80b — `ssh_default_dir` over SFTP.** ✅ Done. `fs.canonicalize(".")`
+        (SFTP REALPATH) — no remote `pwd`.
+      - [x] **80c — `ssh_list_dir` over SFTP.** ✅ Done. `open_dir` + drain the
+        `ReadDir` stream, `is_dir` from SFTP `file_type()`; reuses the
+        dirs-first/ci sort + dot-filter via pure `finalize_entries`. Empty path →
+        SFTP home (`.`).
+      - [x] **80f — Resolve symlink targets.** ✅ Done. `readdir`'s `file_type()`
+        is lstat-style (a symlink reports as a symlink, not its target), so a
+        second pass follow-stats each **symlink** (`fs.metadata`, which follows
+        the link) to flag a symlink-to-directory `is_dir` and make it navigable;
+        only symlinks cost an extra round-trip, and a broken/denied link resolves
+        to non-dir. Pure `resolve_child_path` (join child vs `.`/home) is
+        unit-tested; the live follow-stat is a manual check.
+      - [x] **80d — Command signatures + frontend untouched.** ✅ Done. Same
+        command names/params; `RemoteEntry` mapped from `services::sftp::Entry`.
+        No `useRemoteSession`/`RemoteProjectSection` change.
+      - [x] **80e — Async wiring.** ✅ Done. Both commands are now `async`;
+        `lib.rs` registration unchanged; `cargo check --all-targets` clean.
+      - **Removed dead code:** the old `parse_ls_output`/`shell_quote` in
+        `commands/ssh.rs` (and their tests) — superseded; their sort/filter +
+        injection-inert coverage moved to `services::sftp` tests.
+    - *Test (e.g.):* a host with a dir literally named `foo; touch pwned`
+      lists as one inert entry (no remote command runs), symlinked dirs are
+      flagged `is_dir`, and the home dir resolves without a `pwd` shell-out.
+    - [x] 🤖 Automated test — `services::sftp` unit tests: `sftp_subsystem_args`
+      splices `-s` before the target; `finalize_entries` dirs-first/ci sort,
+      dot/blank filter, hidden-entry retention, and the injection-named dir is
+      one inert entry. (Pure, no live host; the network round-trip is manual.)
+    - [ ] 🖐️ Manual test — re-run #28 Phase 2 (browse) against key-auth and
+      password-only hosts; injection-named dirs are inert; mount/exec (Phases
+      3–7) still work unchanged.
+    - **Follow-on (not this pass):** once browse is SFTP, evaluate a
+      JetBrains-*Deployment*-style **edit-over-SFTP** path for the in-app viewers
+      to shrink the sshfs surface further (read/write single files over SFTP,
+      mount only when local tooling/agents need a real directory).
+      → Pursued in full by **#28e–#28j** below (mount-free remote projects).
+
+81. **Mount-free remote projects — replace sshfs with SSH/SFTP-native.**
+    📋 **Planned, not started.** Full plan + file:line map + exit criteria per
+    phase in **`docs/mountfree_remote_plan.md`** (read it first). Remote projects
+    drop the FUSE mount entirely: agent tabs over `ssh -tt`, file browsing/I-O
+    over SFTP, git on the host over SSH. **Decisions (locked):** fully *replace*
+    sshfs (no coexistence); git *runs over SSH* for remote projects. The keystone
+    is making remoteness **explicit** (a backend `remote_target_for(project_id)`
+    resolver) instead of inferring it from a cwd under `ssh_mount::mounts_root()`
+    (`services/ssh_exec.rs:297`). Phases are ordered so each is independently
+    shippable; Phase 1 alone delivers the main goal (remote agent tabs). Built to
+    be picked up by an agent team after a context `/clear` — the plan doc is the
+    source of truth.
+    - [x] **28e — Explicit remoteness + pooled SSH/SFTP** (Phase 0; do first).
+      `services/remote.rs` resolver + one ControlMaster & persistent `Sftp`
+      session per active remote project (auth once, reused by tabs/browse/git);
+      shift commands from `project_dir` path to `project_id` + `rel_path`.
+    - [x] **28f — Mount-free remote agent tabs** (Phase 1; main goal). Replace
+      `project_id_from_cwd` detection in `ssh_exec::wrap_pty_options` with the
+      explicit `RemoteTarget`; remote cwd = `spec.remote_path`.
+    - [x] **28g — Live remote file browsing over SFTP** (Phase 2). Project-aware
+      `list_dir`; wire `FileTree.tsx`/`FileBrowser.tsx`; drop inotify for remote
+      (manual refresh).
+    - [x] **28h — Remote file I/O over SFTP** (Phase 3). Add write half to
+      `services/sftp.rs` (read/create/write/mkdir/remove/rename/download);
+      route `commands/fs.rs` + viewers for remote projects.
+    - [x] **28i — Git over SSH for remote projects** (Phase 4). One
+      `run_git(target, args)` dispatcher in `commands/git.rs`; remote →
+      `ssh_exec::remote_command("cd <path> && git …")`; parsers unchanged.
+    - [x] **28j — Remove sshfs** (Phase 5). Deleted `services/ssh_mount.rs`
+      (shared `validate_arg`/`ssh_*_base_args`/`ssh_target`/`sshpass_available`
+      relocated to `services/ssh_common.rs`), `ensure_*_mounted`, the exit-unmount
+      hook, the sshfs tooling probe + install-guide UI, and the frontend mount
+      calls. `remote_target_for` now resolves from the always-local `projects.json`
+      `extra["remote"]` (so existing remote projects keep working with no mount);
+      a remote project's `directory` is a local per-project state dir
+      (`remote-projects/<id>`) holding `project.json`, while its tree lives on the
+      host. Docs/lessons/tour stripped of FUSE. **Follow-up:** writing the
+      canonical scaffold to both the local mirror and remote host is tracked as
+      **#28o** below. (The `git_change_stats` untracked-line counts that assumed a
+      local tree are now fixed in #28k.) Needs a live-host QA pass.
+    - [x] **28k — Review-team follow-ups** (2026-06-30; ✅ Done · 🧪 Remote
+      half needs live-host QA). From the post-merge code review of the mount-free
+      change (most findings already fixed in the `fix(remote): harden SSH/SFTP
+      pool…` commit). Both remaining items resolved:
+      - [x] **Remote untracked-line counts read +0.** `count_added_lines`
+        (`commands/git.rs`) did a local `std::fs::read` on `project_dir.join(rel)`;
+        for a remote project `project_dir` is the local state dir, so every read
+        failed and the git "Add" panel showed untracked remote files as `+0 /
+        non-binary`. Fixed via the SFTP-read option: `git_change_stats` is now
+        `async` + takes the `RemotePoolState`; local projects keep `std::fs::read`,
+        remote projects read each untracked file's bytes over the pooled SFTP
+        session (`count_added_lines_remote` → `fs::remote_join_confined` +
+        `fs::remote_read`, both now `pub(crate)`), with the shared byte→`(lines,
+        binary)` logic factored into `count_lines_in_bytes`. The `rel` path is
+        confined under `spec.remote_path`; any confinement/read error degrades to
+        `(0, false)` as before. Stale "still-present mountpoint" comment replaced.
+        **Live-host QA:** confirm `+N`/binary/empty counts against a real SSH
+        project, cold-pool (one-shot fallback) counts, and latency on a large
+        untracked tree (each file is now an individual SFTP read).
+      - [x] **`ConnectionLog` keys by array index.** `key={i}` over a `slice(-500)`
+        log forced full re-creation of every line node when the cap trimmed the
+        head. Fixed: `ConnectionLog` now takes `LogLine[]` (`{ id; text }`) and
+        keys on the id; both push sites (`useRemoteSession.ts`,
+        `VpnPasswordPrompt.tsx`) mint a monotonic id from a dedicated `useRef`
+        counter that never resets on slice, so surviving lines keep their nodes.
+      - Gates: `npx tsc --noEmit`, `cargo test` (412 + 25, 0 failed) all green.
+    - **Cross-cutting (all phases):** single auth (one ControlMaster, no 3×
+      prompts), no page cache (pooled session + lazy reads), fail-fast offline,
+      OpenVPN brought up before the master, git-over-ssh keeps `shell_quote`
+      defenses. Per-phase `cargo test` + `npx tsc --noEmit`; runtime QA adapts
+      #28 Phases 1–8 minus all mount/`/proc/mounts` steps.
+    - [x] **28l — Stepped remote dialog + connection lamps** (2026-06-30; ✅
+      Done · 🧪 Untested). New-project dialog reworked into a stepped remote flow
+      (connect → browse → details) via `step` in `useRemoteSession`; the
+      name/git/details body is gated to the final step (local projects keep the
+      single form). **Browse in both connection modes:** non-headless now rides
+      the embedded login's ControlMaster to SFTP-browse (auto-poll of a
+      credential-less `ssh_connect` after `startSshTerm`, + an "I've logged in —
+      browse" fallback), converging on the same `isRemote` browser headless uses;
+      Windows non-headless (no control socket → `winManual`) keeps the typed-path
+      input. `buildRemoteSpec` collapsed to one branch + Windows fallback. Added
+      red/orange/green `ConnLamp` for SSH + OpenVPN, shown in-dialog and
+      persistently in the header for the active remote project, driven by a new
+      `stores/remoteStatus.ts` (keyed by project id). Activation (`stores/projects.ts`)
+      drives the lamps (pooled `remote_connect` with retry; VPN from the prompt
+      result or a bounded `openvpn_status` poll) and fires a dedicated `connToast`
+      ("VPN connected · <proj>"). **Known gaps for live QA:** (a) ~~macOS
+      `openvpn_status` is a stub (always false), so the VPN lamp never goes green
+      on macOS~~ — fixed by the macOS OpenVPN backend (31e, 2026-07-11):
+      `is_connected` now probes the daemon pid with EPERM-counts-as-alive, so
+      the lamp reflects real tunnel state (still needs mac runtime QA);
+      (b) a headless password-auth host with no live master can't open the pool
+      with a null password, so its SSH lamp goes red after the retry budget —
+      accurate, but the path itself is the unstored-password limitation, not a lamp
+      bug. Gates: `npx tsc --noEmit`, `vitest` (714), `cargo test` (25) all green.
+
+    - [x] **28m — Auto-sync for files/folders** (2026-07-01; ✅ Done · 🧪
+      Untested). Per-path auto-sync layered on the selective-sync manifest: a new
+      `SyncEntry::auto_sync` flag (`#[serde(default)]`, implies `selected`; folder
+      markers cover their subtree, resolved by `remote_sync::is_auto`) + the
+      `sync_set_auto` command; `SyncStatusEntry.auto_sync` surfaces the effective
+      flag. New `services::sync_auto` reconcile engine: one per-project task
+      (`AutoSyncState` registry) started on `remote_connect`, stopped on
+      `remote_disconnect`/exit, triggered by a recursive mirror `notify` watcher
+      (debounced ~1.5s) + a ~25s interval. Each pass judges every auto path with a
+      new pure `remote_sync::divergence` split and acts on the SAFE direction only
+      (host-moved → pull, local-moved → guarded push, **both-moved/amber → skip**),
+      reusing `walk_host_files`/`walk_mirror_files`/`pull_file`/`push_file_atomic`/
+      `record_*`; emits an `auto-sync` event to refresh the frontend. UI:
+      file-tree right-click "Auto-sync this folder/file" (both source trees), a ⟳
+      row glyph, a viewer-header ⟳ toggle (remote projects, via a
+      `ViewerHeaderInfoContext`), and a right-panel "orange" list view + count
+      badge that lists all diverged files with Take-host / Keep-local resolve
+      actions. **Deferred:** deletion propagation is intentionally out of scope
+      (a one-sided delete is skipped, never mirrored) — needs a tombstone design;
+      the mirror watcher fires on Eldrun's own pull writes (harmless: the next
+      pass finds those files green) — add a post-write suppression window only if
+      it proves chatty. Gates: `npx tsc --noEmit`, `cargo test` (448 lib) green;
+      needs live-host QA (auto pull/push timing, orange skip, lifecycle).
+
+    - [ ] **28n — Git-aware local↔remote lockstep sync.** **Phases 1–3 ✅ Done
+      (2026-07-02; opt-in per project; checkout lockstep + fast-forward-only ref
+      transfer + desync detection/display · 🧪 live-host QA pending).** Phase 2
+      (Use-local/Use-remote resolution + `refs/eldrun/backup/*` reset) and Phase 3
+      (initial-pairing authority + streaming transport for large bundles) landed
+      2026-07-02: `transfer_and_apply` gained a `force` path that, for diverged /
+      dest-ahead branches and conflicting tags, saves the overwritten tip to a
+      timestamped `refs/eldrun/backup/*` ref then resets to the authority (a
+      checked-out loser branch via `reset --hard`, moving ref + tree); `resolve`/
+      `resolve_inner` (pause auto-sync → force winner→loser → restamp bases →
+      reconcile) back the `git_peer_resolve(authority)` command + Use local / Use
+      remote buttons (confirm-gated) in the desync bar. `init_pairing` (`git init`
+      the empty side, full-bundle transfer, `symbolic-ref`+`reset --hard` / detached
+      checkout to populate) runs from `reconcile` when exactly one side is a repo
+      (remote-import → mirror-from-remote, extend-local → remote-from-local; both-
+      exist-and-diverge still routes to the explicit authority choice). `move_bundle`
+      now streams via new `sftp::{upload,download}_file_streaming_on` (256 KiB
+      chunks, `bytes` dep) so the 64 MiB whole-file cap is gone and initial-pairing
+      bundles carrying whole histories transfer without buffering. New unit tests:
+      `winner_is_local` default, tag backup-ref naming, force-targets-diverged/
+      dest-ahead truth pins; frontend `GitLockstep.test.tsx` +2 (resolve routes to
+      `git_peer_resolve`, confirm-dismiss no-ops). Gates: `cargo test` (603),
+      `npx tsc`, `vitest` (745) green.
+      New `services/git_peer.rs` (AppHandle-free: `Peer` enum runner, pure parsers/
+      `decide`/`bundle_create_args`, `probe`, `reconcile` via delta `git bundle` over
+      the pooled SFTP into `refs/eldrun/incoming/*` + ff-apply, `checkout_lockstep`,
+      `.git`-watcher + host-poll detection loop, `GitPeerRegistry`) + `commands/
+      git_peer.rs` (`git_peer_{status,set_enabled,sync_now,checkout}`, `git-peer-status`
+      event). `services/sync_auto.rs` gained a per-project `paused` `AtomicBool` (checked
+      in `reconcile_pass`) so a checkout's mirror writes aren't pushed, with base
+      re-stamping via `record_pull` before resume; `remote_sync` walkers now skip
+      `.git`. Lifecycle wired into `remote_connect`/`disconnect` + app-exit `stop_all`;
+      `GitHistory.tsx` gained a lockstep toggle + status pill + Sync/Retry and routes
+      checkout through `git_peer_checkout` when enabled. Gates: `cargo test` (473),
+      `npx tsc`, `vitest` (743) green. Original spec (still governs Phase 2/3):
+      For an SSH project's
+      paired local mirror and remote working tree, keep Git state synchronized
+      **semantically** rather than copying `.git/` bytes. Transfer commits and
+      refs through Git over the existing SSH ControlMaster; synchronize local
+      branches, tags, HEAD branch/detached commit, and all Git-tracked working-tree
+      files (including safe tracked deletions). Existing selective sync remains
+      authoritative for untracked/ignored files. Never copy machine-specific or
+      unsafe Git internals (`config`, hooks, reflogs, index/lock files, remotes,
+      stashes, or worktree metadata).
+      - **Checkout lockstep.** A branch switch on either side checks out the same
+        branch at the same commit on its peer; checking out a commit synchronizes
+        the same detached HEAD. Eldrun-triggered checkouts reconcile immediately;
+        a local `.git` watcher plus connected-host polling detects CLI-driven
+        changes. Pause ordinary file auto-sync during checkout, then refresh its
+        tracked-file bases so checkout writes do not become false conflicts.
+      - **Safe ref/history reconciliation.** Missing objects/refs transfer in
+        either direction and branch updates auto-apply only when fast-forward.
+        Diverged histories, simultaneous incompatible checkouts, or a dirty peer
+        that blocks checkout enter a visible **desynchronized** state; never
+        force-checkout or discard work. Offer Retry after cleanup and an explicit
+        Use local / Use remote resolution, creating timestamped `refs/eldrun/backup/*`
+        safety refs before resetting the losing side.
+      - **Initial pairing.** Remote import initializes the mirror from the remote;
+        extending a local project initializes the remote from local. If both
+        repositories already exist and diverge, require the same explicit
+        authority choice instead of guessing. The paired main working trees are
+        covered; extra worktrees and checked-out submodule contents are deferred.
+      - **Backend/UI.** Add a per-project Git-peer sync service and persisted
+        observed local/remote HEAD/ref/status state; commands for status, retry,
+        and authority resolution; and a project-scoped status event. Extend
+        coordinated checkout with project id + initiating side while preserving
+        camelCase payload compatibility. Show synchronized/syncing/desynchronized
+        state and actionable errors in the Git UI.
+      - [x] 🤖 Automated test (Phases 1–3) — `git_peer` unit tests: ref/HEAD parsing,
+        `decide` fast-forward-vs-divergence truth table, `bundle_create_args`/
+        incoming-refspec shape guardrails (never `--all`/`refs/remotes` → `.git`
+        internals never copied), tracked-file/deletion discovery, safety-ref naming,
+        camelCase state round-trip; frontend `GitLockstep.test.tsx` (checkout routes
+        through `git_peer_checkout` when enabled, falls back otherwise, pill renders,
+        local project shows no bar; Phase 2: resolve routes to `git_peer_resolve`,
+        confirm-dismiss no-ops). Phase 2/3 pure-logic tests: `winner_is_local`,
+        tag backup-ref naming, force-targets-diverged/dest-ahead pins.
+      - [ ] 🖐️ Manual test — live SSH host: edit/commit/checkout from Eldrun and
+        from local/remote shells, verify both trees remain on the same branch or
+        detached commit, then exercise dirty-peer recovery and Use-local/Use-remote
+        resolution (confirm the loser's overwritten tip lands under
+        `refs/eldrun/backup/*` and both trees converge). Also verify initial pairing:
+        import a remote repo → mirror initializes from it; extend a local repo onto a
+        host → remote initializes from local; and a large-history bundle streams
+        through without the old 64 MiB rejection.
+
+    - [ ] **28o — Scaffold both sides of SSH projects.** New and imported SSH
+      projects must receive the canonical Eldrun scaffold in both their local
+      mirror and remote project root. Create only missing files: existing content
+      on either side is authoritative and must never be truncated or replaced.
+      The existing **Skip scaffolding** option suppresses generation on both
+      sides. Remote scaffold failure is blocking: surface the error in the
+      project dialog and do not register the project as successfully
+      created/imported.
+      - **Remote path.** Add an async
+        `scaffold_remote_project(user, host, port, password, remotePath)` Tauri
+        command. Open one SFTP session, create the remote root and required
+        parent directories, then atomically create each absent canonical file.
+        If writing a newly-created file fails, remove that partial file before
+        returning the error. A submitted password is ephemeral and must never be
+        persisted or logged; when it is absent, resolve any saved SSH credential
+        through the existing credential service.
+      - **Dialog ordering.** For both remote create and import, invoke remote
+        scaffolding before `create_project` / `import_project`. Reuse the
+        dialog's existing error state for failures, leaving registration
+        untouched. A retry is safe because remote creation is idempotent and
+        non-overwriting.
+      - **Local mirror.** Keep the existing new-remote mirror scaffolding and
+        extend remote import to call the same local `scaffold_project` helper.
+        The canonical set remains the existing `SCAFFOLD_FILES`,
+        `.gitignore`, and `.claude/settings.json` definitions so both sides start
+        with identical defaults.
+      - **Compatibility.** No persisted project-schema change. Keep Git
+        initialization and agent-assisted scaffold filling behavior unchanged.
+      - [ ] 🤖 Automated test — remote imports create the complete local-mirror
+        scaffold without overwriting existing content; frontend create/import
+        call remote scaffolding before registration; Skip bypasses both paths;
+        and a rejected remote-scaffold call prevents registration and surfaces
+        its error.
+      - [ ] 🖐️ Manual test — create and import projects against key-auth and
+        password-auth SSH hosts; verify both trees contain all missing scaffold
+        files, pre-existing files remain byte-identical, Skip touches neither
+        side, and an unwritable remote root blocks registration with an
+        actionable error.
+
+    - [x] **28p — Git lockstep hardening (#28n follow-up)** (2026-07-13; ✅ All
+      eight defects fixed · 🧪 Live-host QA still owed). Plan:
+      `docs/git_lockstep_hardening_plan.md`. Tracing the full local↔remote case
+      matrix over the shipped #28n code surfaced eight defects, two of them
+      data-loss/correctness class. Root cause of most: **byte-sync
+      (`sync_auto`) and git lockstep (`git_peer`) were blind to each other** —
+      byte-sync's candidate walk excludes only `.git`/`.eldrun` and has no notion
+      of "git-tracked", so a file lockstep is about to deliver as a *commit* may
+      first be shipped as *loose bytes* and land on the peer **untracked**, which
+      then blocks the very fast-forward that would have delivered it. Verified
+      experimentally: `git merge --ff-only` refuses to overwrite an untracked file
+      **even when byte-identical**, while `git reset --hard` silently clobbers it.
+      - [x] **D1 (blocking) — byte-sync/git race.** Which outcome you got was a debounce
+        race (auto-sync 1500 ms vs lockstep 800 ms): commit fast → clean ff; hesitate
+        → wedged `Desynchronized`. Fixed in two layers: `git_peer::tracked_paths` is
+        subtracted from the `sync_auto::reconcile_pass` candidate set whenever lockstep
+        is on (**lockstep owns the tracked tree, byte-sync owns the rest** — the
+        invariant that removes the race by construction), plus
+        `retry_ff_clearing_identical`, which clears colliding untracked files **only**
+        when every one of them is provably byte-identical to the incoming blob
+        (`hash-object` vs `rev-parse <sha>:<path>`, all-or-nothing) and retries the ff.
+        That second layer is what makes the *first* enable succeed on a project whose
+        files byte-sync already mirrored. Pinned against real git, not just parsers:
+        `ff_retry_clears_byte_identical_untracked_files_and_succeeds` /
+        `ff_retry_refuses_when_any_colliding_file_differs`. The old
+        "never enable auto-sync-all with lockstep" caveat is lifted.
+      - [x] **D3 (blocking) — `init_pairing` could clobber host files.** Extend-local does
+        `git init` + `reset --hard` on the host; the pre-backup saves *refs*, but a
+        not-yet-a-repo host has none, and `reset --hard` destroys colliding untracked
+        files with no backup and no prompt. Fixed: `pairing_conflicts` fingerprints the
+        source's tracked tree (`ls-tree -r -l -z`) against the dest's existing files
+        (size first, then a `git hash-object` batch over the same-size residue — it works
+        outside a repo, so it runs on the not-yet-init'ed dest) and **refuses** when any
+        collision differs, surfacing `pairingConflict` so the UI names the files and
+        demands an explicit `git_peer_pair_confirm`. Unprovable equality counts as a
+        difference. The `probe_error` refusal is now symmetric
+        (`pairing_dest_probe_error`): the *remote* dest — reached over a flaky link, so
+        the likelier to misprobe — is guarded exactly like the local one.
+      - [x] **D4 — disconnected "Sync now" reported green.** A dropped SSH connection
+        surfaces as `Ok(nonzero)`, so `probe_error` stayed false and the host read as
+        a clean empty side → doomed `init_pairing` → status fell through the
+        `!final_remote.is_repo` arm to `Synchronized`. Fixed: every entry point
+        (`reconcile`/`detect_and_sync`/`checkout_lockstep`/`resolve`/`restore_backup`)
+        gates on `connected()` (the pooled SFTP session) up front, and a new
+        `SyncStatus::Disconnected` carries the last-known heads without claiming
+        anything about the host. The pill renders it grey and disables Sync-now.
+      - [x] **D2 — the desync detail lied.** A blocked ff always rendered "A peer has
+        uncommitted changes", but the cause is usually *untracked* collisions, and the
+        merge stderr naming the files was discarded. Fixed: `TransferResult.dirty_blocked:
+        bool` → `blocked: Option<String>`, composed by `blocked_detail` from the parsed
+        stderr (`parse_untracked_overwrite_paths`, incl. git's C-quoted paths), so the
+        bar names the actual files instead of inventing uncommitted changes.
+      - [x] **D5 — SSH chattiness.** `probe` was 6 round trips; `is_ancestor` 2 more per
+        branch per direction; both directions ran every 12 s *and* on every `git add`
+        (≈80 round trips/pass on a 20-branch repo). Fixed: `PROBE_SCRIPT` (one `\x1e`-
+        delimited `sh` script → `parse_probe_block`) makes the probe **1** round trip, and
+        `ancestry_script` collapses all `2·N` ancestry checks into **1**; both fall back to
+        the per-command path if the output doesn't parse (a host with no POSIX `sh`), and
+        both are tested through a *real* `sh` so a syntax error can't silently disable the
+        batching. `can_early_out` skips the whole pass when neither side's ref signature
+        moved and we were green — which is what kills the `git add` storm; a manual Retry
+        always forces a full pass (`ReconcileOpts::forced`).
+      - [x] **D6 — backup refs were write-only.** `refs/eldrun/backup/*` accrued forever,
+        pinned objects, and had no list/restore/prune UI — which also hollowed out the
+        "it's recoverable" defence of Use-local/Use-remote. Fixed: `git_peer_backups`
+        (both peers, newest first) + a Backups affordance in the lockstep bar +
+        `git_peer_restore_backup`, which backs the current tip up *first* so a restore is
+        itself undoable. `select_prunable` keeps the newest 20 per peer and anything
+        <30 days, never the newest; pruning runs where backups are *born* (resolve /
+        restore), keeping it off the hot reconcile path.
+      - [x] **D7 — the paired mirror had no `origin`.** `init_pairing` left the mirror with
+        no remote (bundles carry no config/remotes), so `git push` from a local agent tab
+        just failed. Fixed: `should_propagate_origin` copies the source's
+        `remote.origin.url` — **URL only**, never credentials or other config keys — into a
+        freshly-paired dest, and never over a dest that already has its own origin.
+      - [x] **D8 — divergence offered authority, not merge.** Only Use-local/Use-remote:
+        pick a winner, the loser's commits leave the tree. Fixed (deliberately minimal —
+        no merge UI): a reconcile that detects a divergence parks the peer's tip at
+        `refs/eldrun/peer/<branch>` (`peer_ref_op`; the objects are already there from the
+        bundle, so it is free) and clears it again once the branch is back in step; a
+        **Resolve in terminal** action opens a local shell in the mirror so the user
+        merges/rebases with plain git and the next pass fast-forwards the host normally.
+        Both heads' sha + subject now show in the bar (`head_subject`, carried in the
+        batched probe) so the authority choice is informed rather than blind.
+      - **Phasing.** Shipped in one pass, in the planned dependency order: Phase 1
+        (trust) D1 → D3 → D4 → D2; Phase 2 (viability on a real link) D5, D6; Phase 3
+        (polish) D7, D8.
+      - [x] 🤖 Automated test — all of the planned pure/unit coverage landed:
+        untracked-overwrite stderr parser (incl. C-quoted paths); tracked-path exclusion
+        from the auto-sync candidate set (and its no-op when lockstep is off);
+        pairing-collision detection over two path→(size,hash) maps (incl. "unprovable =
+        differs"); symmetric `probe_error` refusal truth table; cold-pool gate +
+        `disconnected_state`; `parse_probe_block` round-trip; early-out predicate;
+        backup-ref parse + prune selection; origin propagation skipped when the dest has
+        one; only diverged branches park `refs/eldrun/peer/*`. **Plus three that exercise
+        the real thing rather than a parser**, because the two riskiest behaviours here are
+        git's and the shell's, not ours: the ff-retry against a real repo (it clears
+        byte-identical untracked collisions and fast-forwards; one differing file aborts
+        the whole retry and deletes nothing), and both batched scripts through a real `sh`,
+        asserted to agree with the per-command path they replace — a syntax error would
+        otherwise disable the D5 batching *silently*. Frontend: disconnected pill +
+        disabled Sync-now, the pairing-overwrite confirm naming the files, backups
+        list/restore, resolve-in-terminal spawning a local mirror shell.
+      - [ ] 🖐️ Manual test — live SSH host, the six-row matrix at the end of the plan:
+        auto-sync-all + lockstep with a slow commit still fast-forwards green; the
+        fast-commit path does not regress; enabling lockstep over already-byte-synced
+        tracked files succeeds on first reconcile; extend-local onto a host dir holding
+        a differing `README.md` is refused with the file named and the host file
+        intact; disconnect → Sync now reports disconnected rather than green; and a
+        two-sided divergence resolved with Use local leaves a listable backup ref.
+
+    - [x] **28q — Warn when sync or git destroys something on the LOCAL side**
+      (2026-07-13; ✅ Code-complete · 🧪 Live-host QA owed). Re-scanning the remote
+      surface for local-side deletions: byte-sync (`sync_auto`) turns out to be
+      non-destructive **by construction** — it pulls only when the local side is
+      unchanged, pushes only when the host is, and skips an amber file rather than
+      pick a winner — so *every* local deletion comes from the git side, plus one
+      overwrite from the manual pull commands. All five were correct, deliberate, and
+      **silent**, which is the bug: they run in the mirror during background passes
+      nobody triggered, so a file the user was looking at simply vanished.
+      - **The five sites**, each now filing a warning (`services::local_loss`, an
+        append-only per-project log): a fast-forward or `reset --hard` on the mirror's
+        checked-out branch (deletes the tracked files the incoming commit dropped); a
+        lockstep checkout, including the one that *follows a branch switch made on the
+        host* — the least expected of the lot; the `git clean` inside
+        `retry_ff_clearing_identical` (deletes **untracked** files, which no `git diff`
+        can ever name); a confirmed initial pairing overwriting the colliding mirror
+        files it warned about; and `sync_now`/`sync_pull` overwriting a mirror file that
+        held unsynced local edits — the only one of the five that is **not
+        recoverable**, since those bytes were never committed or pushed anywhere, and
+        the dialog says so in as many words rather than leaving the recovery line blank.
+      - **Reports, does not gate.** The gates that *prevent* a destructive write already
+        exist (`pairing_conflict`, the blocked-ff refusal, `push_decision`); this is for
+        what they deliberately let through. `audit_local_head_move` reads the mirror's
+        HEAD before and after each mutation, so an op that failed records nothing, and a
+        nested reconcile can never double-report its caller's deletion.
+      - **A file, not an event:** the services are `AppHandle`-free and a background pass
+        can delete with no window listening, so a warning that existed only as an event
+        would be dropped exactly when it mattered. The frontend re-reads the log on every
+        lockstep/sync pass, so a loss recorded while the app was closed still surfaces.
+      - [x] 🤖 Automated test — `deleted_between_names_only_what_a_move_removes` (a
+        forward fast-forward warns about nothing; only a move *back* deletes), the
+        `FfRetry` variants pinned against real git (`Cleared` names what it removed even
+        when the ff puts identical bytes straight back), and
+        `src/__tests__/LocalLossDialog.test.tsx` (raises unacked losses, says outright
+        when nothing can be recovered, acks through the backend, never shows one
+        project's losses over another).
+      - [ ] 🖐️ Manual test — live SSH host: commit a file deletion on the host and let
+        the background pass land it (the warning names the file and gives the
+        `git checkout <sha> -- <path>` line that brings it back); switch branches on the
+        host so the mirror follows into a checkout that drops a file; edit a byte-synced
+        file locally, then Sync now, and confirm the overwrite is reported as
+        unrecoverable; and confirm a project that loses nothing never sees the dialog.
+
+82. **Split-tunnel the OpenVPN connection (per-project opt-in).** Eldrun passes
+    OpenVPN *no* routing flags (`services/openvpn::openvpn_args`), so whatever the
+    `.ovpn` pushes applies to the whole machine — typically `redirect-gateway def1`
+    plus DNS, which reroutes the browser and every other process while the tunnel is
+    up. The tunnel is now *disclosed* as machine-wide (header `VpnIndicator`, connect
+    dialog copy) but not *scoped*. Scope it: `--route-nopull` plus an explicit route
+    to the project's SSH host only, leaving the rest of the OS on its normal gateway.
+    - **Must be opt-in per project.** Some hosts are only reachable via the pushed
+      routes, so this cannot be the default without breaking working setups.
+    - **The chicken-and-egg to solve first:** if the host is an internal-only
+      *hostname*, it resolves only through the VPN's pushed DNS — which
+      `--route-nopull` drops. So the route can't be computed before the tunnel is up.
+      Options: resolve once with a full tunnel and cache the IP; accept the pushed
+      DNS but not the default route; or require an IP/`ssh_config` `HostName` for
+      opt-in projects.
+    - **Failure mode is opaque** (a connect timeout), so this needs live QA against a
+      real VPN before it can be trusted — it cannot be verified from tests alone.
+    - [ ] 🤖 Automated test — `openvpn_args` emits `--route-nopull` + the host route
+      only when the project opts in, and never for a non-opted project.
+    - [ ] 🖐️ Manual test — with split-tunnel on, `ip route` shows a route to the SSH
+      host via `tun0` while the default route is unchanged; SSH/SFTP/agent tabs work;
+      a browser fetch does *not* egress via the VPN. With it off, behaviour is
+      unchanged from today.
+
+83. ✅ **Interactive (non-headless) tunnels are visible and killable.** With
+    `connections_headless: false`, the tunnel is `pkexec openvpn` inside a terminal
+    tab. It used to carry no `--writepid`, so it never entered the backend registry:
+    `openvpn_status`/`openvpn_active` could not see it, `openvpn_disconnect` could not
+    kill it, and `disconnect_all()` at exit missed it — **it outlived Eldrun with the
+    machine's routing still changed**. `pollVpnUp` (`stores/projects.ts`) polls
+    `openvpn_status`, so it could never observe such a tunnel come up either, and
+    always timed out to a red lamp.
+    Fixed by *arming* the interactive connect: `interactive_connect_command` now
+    picks a pidfile Eldrun owns, deletes any stale one, appends
+    `--writepid <runtime>/<stem>.interactive.pid`, and registers the claim in a new
+    pid-keyed `interactive_registry` (`services/openvpn.rs`). `is_connected`,
+    `active_configs`, `disconnect` and `disconnect_all` all consult it, so a
+    terminal-started tunnel is now exactly as visible and as killable as a headless
+    one — on all three platforms (`pid_alive` is `kill(pid, 0)` with **EPERM = alive**
+    on unix, `tasklist` on Windows; the kill re-escalates via `pkexec`/`osascript`/
+    `taskkill`). A registered-but-pidless tunnel is `Pending`, not dead — reaping it
+    would forget a tunnel in the seconds before it comes up.
+    - [x] 🤖 Automated test — `interactive_command_claims_a_pidfile`,
+      `interactive_tunnel_with_a_live_pid_is_up`,
+      `interactive_tunnel_with_a_dead_pid_is_reaped`, `arming_clears_a_stale_pidfile`
+      (`services/openvpn.rs` tests).
+    - [ ] 🖐️ Manual test — with headless connections off, bring a tunnel up in a
+      terminal tab; the VPN lamp goes green by itself, the header indicator offers a
+      working Disconnect, and quitting Eldrun brings the tunnel down (`ip route`
+      restored).
+
+84. ✅ **The header VPN indicator is a machine-level VPN control.** The tunnel reroutes
+    the whole OS, so it gets a surface that does not hang off a project:
+    `components/header/VpnIndicator.tsx`, always present in the header (dim when no
+    tunnel is up), backed by `stores/vpnStatus.ts` (config-keyed state + holder
+    refcount, seeded from the new `openvpn_active` command and re-seated on window
+    focus, so a tunnel that outlived a reload or a previous run still shows).
+    It lists every stored `.ovpn`, brings one **up** as well as down (a VPN is a thing
+    you use, not only a precondition for an SSH project — the prompt's `projectId` is
+    now nullable so a tunnel can be connected with no project behind it), names which
+    projects hold each tunnel, and is the only place a tunnel is killed outright.
+    Project-side teardowns go through `releaseVpn`, which disconnects **only** when the
+    last holder leaves — previously `logoutRemote` and the Connect modal's Disconnect
+    both called `openvpn_disconnect` unconditionally, killing a tunnel a *second*
+    project (and the rest of the OS) was still riding.
+    - [x] 🤖 Automated test — `src/__tests__/VpnMachineScope.test.tsx` (refcounted
+      shared tunnel; indicator shows/holders/disconnects; header-initiated connect
+      with no holder; backend reconcile).
+    - [ ] 🖐️ Manual test — connect a VPN-gated project, confirm `ip route` shows the
+      tunnel owning the default route and the header indicator appears; open a second
+      project on the same `.ovpn`, log out of the first, confirm the second stays up;
+      disconnect from the header and confirm routing is restored. Connect a tunnel
+      from the header with no project active.
+
+85. ✅ **Persistent sessions (tmux) — remote + local.** *(Implemented — `RemoteSpec.persist_sessions`,
+    `settings.persist_local_sessions`, `PtyOptions.tmux_session`/`tmux_attach`, `ssh_exec::{TmuxWrap,
+    tmux_wrap_exec,tmux_kill_session_script,tmux_rename_session_script,tmux_ls_script,parse_tmux_ls,
+    valid_tmux_session_name}`, `services::tmux_local`, `remote_tmux_{list,kill,rename}` +
+    `local_tmux_{list,kill,rename}` + `set_project_persist_sessions` commands;
+    frontend `lib/tmuxSession.ts`, `lib/closeRemoteTab.ts`, CenterPanel/TabPane/TerminalView
+    plumbing, the pill toggle + a global Settings toggle, and the multi-host Sessions view in
+    `ProjectFilesView`.)* Shipped **default ON** rather than behind the experimental flag (per user).
+    Beyond the original remote scope it also covers: **local** persistence (Unix — survives an
+    Eldrun *crash*), **worker-host** sessions (the Sessions view aggregates every connected host),
+    and per-row **Rename**. Agent tabs are excluded (they resume via their own session).
+    Live-QA on a real host / crash still pending (Done ≠ Tested). A remote shell/script is a child of
+    the `ssh -tt` channel, so it dies (`SIGHUP`) on any channel break — network
+    blip, laptop sleep, VPN drop, or Eldrun quitting. Run it **inside a tmux
+    server on the host** instead, decoupled from SSH: reconnect or relaunch and
+    the same command reattaches to the still-running session. Server-side, so it
+    works identically for a Windows/macOS Eldrun (only the local `ssh` client
+    differs); **remote projects only** (a local process is Eldrun's own child,
+    not decoupled by SSH). One seam: `remote_command` (`ssh_exec.rs:117`) wraps
+    the final `exec` in `tmux new-session -A -D -s eldrun-<tab-uid> -- …`, nesting
+    the existing `cd`/env-export/`remote_agents` prelude untouched — `-A` makes
+    the one command both start and resume, the stable per-tab name is what
+    reattach keys on. Restart-resume is then nearly free (a remote shell tab is
+    already restorable, `tabs.ts:3416`). The one new decision is **kill vs.
+    detach**: explicit tab-close runs `tmux kill-session` via `run_remote_script`
+    (`ssh_exec.rs:300`); app-exit/disconnect leave the session alive. Behind the
+    experimental flag; tmux-absent falls back to today's plain `exec` + a notice.
+    Headline surface is a **Sessions view** in the file viewer, alongside Files /
+    Git / Search / Apps / Orange (`ProjectFilesView.tsx:33,607`) — a remote-only
+    toolbar toggle (mirrors the Orange/diverged view) listing host `tmux ls`
+    sessions (incl. hand-started ones and orphans from a crashed Eldrun); click a
+    row → open a shell tab that **attaches** (`tmux new-session -A -D -s <name>`),
+    per-row kill/reveal. Renders in both the right panel and the Files tab for
+    free (one component). Plan: `docs/tmux_remote_plan.md`. `dtach`/`abduco`
+    (more transparent, less available) kept as a deferred alt backend.
+    - [x] 🤖 Automated test — argv builder (`remote_command_off_is_unchanged`,
+      `remote_command_tmux_wraps_shell_tab`/`_command_tab_preserving_prelude`/
+      `_tmux_attach_ignores_target`); `tmux ls` parse
+      (`parse_tmux_ls_reads_rows_and_tolerates_empty`);
+      `tmux_kill_session_script_quotes_name`; frontend `TmuxSessions.test.ts`
+      (uuid mint is tmux-safe, default-ON gate, shell-only rule, attach-tab restore,
+      and the **key-regenerates-but-tmuxSession-stays-stable** reattach guarantee).
+    - [ ] 🖐️ Manual test — remote long-running `python -u` run: kill network /
+      sleep → reconnect → output continues; quit Eldrun mid-run → relaunch →
+      shell tab reattaches, run still going; explicit tab-close → `tmux ls` shows
+      the session gone; tmux-less host → tab works, notice shown, no persistence;
+      hand-start a session on the host → it appears in the `☰` Sessions view →
+      click → tab attaches to the live process → per-row Kill drops it.
+
+86. **HPC / SLURM pipeline (guided login → run → watch).** *(Phases A + B implemented —
+    `docs/quirky-knitting-umbrella` plan.)* On a SLURM cluster, computation must go
+    through the scheduler (`sbatch`/`srun`), never the login node. Eldrun already
+    connects to such a host as a remote project; this adds a guided run/watch layer
+    so a newcomer never memorizes a SLURM command.
+    **Phase A — run/watch core (done, untested on a cluster):** backend
+    `commands::slurm` (`slurm_available`/`slurm_submit`/`slurm_queue`/`slurm_job_out`/
+    `slurm_cancel`) mirrors `commands::python`'s local-or-remote dispatch over the
+    pooled ControlMaster — a `.slurm` file (any script with a `#SBATCH` line) opened
+    in the code viewer gets a **SLURM bar** beside the Python Run bar (Submit job /
+    Variables / Interactive session…), shown only when the host has SLURM. Submit →
+    `sbatch --parsable` + `scontrol` (one round trip) → a **log tab** tailing the
+    resolved out-file (`tail -F`, waits out the queue); **Variables** is a `#SBATCH`
+    directive form editing the draft by splice (render-rows/edit-text, like the YAML
+    viewer); **Interactive session…** opens an `srun --pty … bash -l` shell on a
+    compute node. A **Jobs view** in `ProjectFilesView` (alongside Sessions/Orange)
+    polls `squeue`, per-row Watch/Cancel. Frontend `lib/slurm.ts` + `stores/hpcJobs`.
+    - [x] 🤖 Automated test — Rust parsers (`parse_submit_jobid` incl. `;cluster`
+      suffix + numeric-guard, `parse_scontrol_paths`, `parse_squeue` incl.
+      multi-word reason, `split_script_rel` incl. absolute paths, `default_out_file`);
+      frontend `Slurm.test.ts` (`isSlurmScript`, `parseSbatchDirectives`
+      short-flag folding, `spliceDirective` in-place/insert/clear + byte-preservation,
+      `buildInteractiveCommand`/`buildTailCommand`).
+    - [ ] 🖐️ Manual test (cluster) — open a `.slurm` → SLURM bar appears; edit
+      `--time`/`--mem` in Variables → file dirties/saves; Submit → toast + log tab
+      tails output; Jobs view lists it, Cancel removes it, Watch re-opens its log;
+      Interactive session… lands a shell on a compute node.
+    - **Phase B — guided pipeline wizard (implemented, untested).** A 5-step stepper
+      (`HpcPipelineWizard.tsx` + `stores/hpcPipeline`, launched from the project-switcher
+      **+** menu) that composes the existing flows rather than reimplementing them:
+      **Login** (`RemoteProjectSection`/`useRemoteSession`) → **Project**
+      (name + local-mirror location → `create_project`) → **Load data** (skippable; local
+      files → `remote_upload_file`, a new streaming SFTP-upload command) → **Run job**
+      (edit a starter `.slurm`'s `#SBATCH` via the Phase-A splice helpers → write to host →
+      Phase-A `submitSlurmJob`) → **Watch** (log tab + Jobs view). Mounted as
+      `HpcPipelineWizardHost` in `AppShell`.
+    - [ ] 🖐️ Manual test (cluster, Phase B) — **+ → HPC pipeline…** walks
+      login→create→load→run→watch end-to-end; the created project connects; an
+      uploaded file lands on the host; Submit opens a tailing log tab.
+    - **Phase C — workspaces, before any data moves (implemented, untested).** The
+      pipeline was missing its actual first step: on a cluster `$HOME` is a small,
+      quota'd, code-only filesystem, and the bulk data of a computation belongs in a
+      **workspace** — a directory on the parallel filesystem with a name, a duration
+      and an expiry after which it is *deleted* — handed out by the `hpc-workspace`
+      tooling (`ws_allocate <name> <days>`, `ws_list`, `ws_find`, `ws_extend`,
+      `ws_release`). Backend `commands::hpc_ws`
+      (`hpc_ws_available`/`_list`/`_allocate`/`_extend`/`_release`/`_link`) reuses
+      `commands::slurm`'s dispatch for a project target and adds an **ad-hoc host**
+      target (`run_ssh_auth`, like `global_machine_usage_check`) because a workspace
+      is allocated *before* the project exists. Nothing is site-specific — the host
+      is asked what it offers (`ws_list -l`); every interpolated value is validated
+      **and** `shell_quote`d; each list/allocate is one round trip that appends a
+      `ws_find` confirmation, since the *path* is what everything downstream uses.
+      Frontend `lib/hpcWorkspace.ts` + a new **Workspace** step in the wizard
+      (between Project and Load data, and now the step that calls `create_project`):
+      the chosen workspace path becomes the project's **remote root**, which is the
+      entire integration — SFTP upload, byte-sync, git lockstep and every run tab
+      then land on the parallel filesystem with no change of their own. The
+      alternative layout (project in `$HOME` + workspace symlinked in as `./data`)
+      is offered with its caveat stated, since byte-sync never follows a symlink
+      (`walk_host_files`, G3). The **Jobs view** additionally lists the project's
+      workspaces with their remaining time (toned) and an **Extend**.
+    - [x] 🤖 Automated test — Rust parsers (`parse_ws_locations` incl. `(default)`
+      + chatter, `parse_ws_list` block/`ws_find`-map merge incl. map-only entries
+      and pathless rows dropped, `parse_ws_allocate` incl. fallback + failure) and
+      the validators (token/injection, day bounds, mail metacharacters, absolute
+      paths, `-F` quoting); frontend `HpcWorkspace.test.ts` (`projectPathIn`,
+      `remainingLabel` incl. singular/fallback, `expiryTone` escalation,
+      `defaultFilesystem`, target shapes).
+    - **Phase C.1/C.2 — the home anchor + surviving expiry (implemented, untested;
+      `docs/hpc_workspace_plan.md`).** Root-in-workspace is only safe if the two
+      things it costs are handled: a workspace path nobody can remember, and an
+      expiry that deletes the project's host tree on a ~1-year certainty.
+      **C.1 (anchor):** `hpc_ws_anchor` creates a small `~/eldrun/<project>/` on the
+      cluster — `logs/`, a `workspace` symlink, and an **append-only**
+      `workspaces.txt` (date, workspace id, path, project, local mirror) — because
+      `ws_restore` is keyed by the workspace *name* and the tree that carried it is
+      what expiry deletes. Recorded on the project as an additive `hpc` block in
+      `project.json` + `extra["hpc"]` (`set_project_hpc`, mirroring
+      `set_project_run_host`), including `anchor_rel` so a later re-anchor passes
+      the `$HOME`-relative path back rather than chopping segments off the absolute
+      one. The wizard offers it (default on) and splices the starter's
+      `--output` to `<logs>/slurm-%j.out`; `slurm_job_out` takes a `log_dir` so
+      **Watch** on a job `scontrol` has forgotten stops guessing `<WorkDir>`.
+      **C.2 (lifecycle):** `hpc_ws_move_root` re-points a primary's `remote_path`
+      (nothing else could — it was fixed at creation), resetting lockstep state and
+      the byte-sync **bases** while keeping every marker, so the empty new root is
+      re-seeded from the local mirror; surfaced as **Move here** on each workspace
+      row, with a confirm that says outputs left in the old workspace stay there.
+      An **expiry banner** (≤7 days, urgent ≤2) is raised in every view with
+      Extend/Workspaces, and **Pull logs** copies the anchor's logs into the mirror.
+      **Portability:** the feature assumes only two *families* — SLURM as the
+      scheduler and `hpc-workspace` as the storage tooling — and no site value
+      appears in any logic (the only `lustre`/`scratch`/`mlnvme` strings are test
+      fixtures). A cluster with SLURM but **no** workspace tooling is covered by
+      `hpc_scratch_candidates`: the step asks whether the site's own profile
+      exports `$SCRATCH`/`$WORK`/`$PROJECT`/… (plus `/scratch|/work|/lustre/$USER`),
+      reports each with writability + `df` free space, and offers them as the
+      project root — otherwise such a project would land in `$HOME`, the exact
+      failure the step exists to prevent.
+    - [x] 🤖 Automated test — Rust `validate_anchor_rel` (home-relative, `.`/`..`
+      and metacharacters rejected) and `parse_scratch_candidates` (dedupe by path,
+      read-only reported not filtered, malformed/relative rows dropped); frontend
+      `freeSpaceLabel`, `defaultAnchorRel`, `logOutputPattern`,
+      `shouldWarnExpiry`, and `findProjectWorkspace` — incl. **id-first resolution**
+      and the prefix trap (`…-demo2` must not match `…-demo`, which would point
+      Extend at the wrong allocation).
+    - [ ] 🖐️ Manual test (cluster, C.1/C.2) — the wizard's anchor checkbox creates
+      `~/eldrun/<project>/{logs,workspace,workspaces.txt}` with the link resolving
+      and the record naming the workspace; a submitted job's log appears in
+      `logs/` and the log tab tails it; **Watch** on a finished job still finds it;
+      **Pull logs** lands them in the mirror's `logs/`; with the workspace inside a
+      week the banner appears in the Files view and **Extend** clears it;
+      **Move here** on another workspace re-points the project (new root created,
+      lockstep re-seeds it from the mirror, tabs reconnect) and appends a second
+      record line; the old workspace is left untouched. On a **cluster without
+      `ws_allocate`** (or a plain SSH host with `$SCRATCH` set), the step instead
+      lists the site's own filesystems with free space and creating the project
+      there puts the tree on the chosen one.
+    - [ ] 🖐️ Manual test (cluster, Phase C) — **+ → HPC pipeline…** → after login
+      the Workspace step lists the site's filesystems and your existing workspaces
+      with days left; **Allocate workspace** creates one (`ws_list` on the host
+      agrees) and a reminder mail is registered; **Create project** puts the project
+      at `<workspace>/<name>` (`project.json`'s `remote_path`); an uploaded file and
+      a synced file both land in the workspace, **nothing** in `$HOME`; the linked
+      layout instead creates `<project>/data → <workspace>`; the Jobs view lists the
+      workspace with its remaining time and **Extend** adds days (extensions drop by
+      one); a non-cluster host skips the step with its note.
+
+91. **rsync for the PUSH direction too (local→host bulk transfer).** rsync is used
+    on exactly one axis today: a **directory pull** (`commands::sync::try_rsync_pull`
+    → `remote_sync::rsync_pull_dir`, gated on `should_use_rsync` = rsync on **both**
+    ends **and** `is_dir`, riding the pooled ControlMaster with `-c`). Everything
+    going *up* is SFTP, per-file: `sync_push`, the whole-project push, the HPC
+    wizard's "Load data" (`remote_upload_file` → `upload_file_streaming_on`), and the
+    worker "Pull outputs" download. That is backwards for the workflow the cluster
+    docs describe — "copy your code/data to the node" is the direction that moves the
+    big trees, and it is the one still walking files one at a time over SFTP.
+    - **Why push is on the SFTP floor, and what must survive.** It is not an
+      oversight: a push honours a per-file **block-on-stale** guard (never clobber a
+      host file that changed under us — `remote_sync`'s `push_decision`, product
+      decision 5), and a bulk `rsync` would overwrite the whole subtree without ever
+      consulting it. A pull has no such problem because overwriting the *mirror* is
+      what the user asked for. So this is not "turn on the flag": the guard has to be
+      re-expressed in rsync's own terms.
+    - **The shape that keeps the guard.** Compute the push set exactly as today (host
+      walk + manifest bases + `push_decision`), then hand rsync **only the agreed
+      files** — `--files-from=-` on stdin, plus `--ignore-times`/`-c` — instead of
+      letting it decide what to send. Stale files are simply absent from the list, so
+      a blocked file cannot be clobbered by construction, and the win (one connection,
+      delta transfer, no per-file round trip) is kept. `--delete` must never appear:
+      deletion on the host is not byte-sync's business.
+    - **The `excluded` marker has to stand down the fast path**, same as it does for
+      pulls (`skipped_excluded == 0`) — a whole-subtree rsync cannot honour a
+      carve-out, and an excluded `node_modules`/`checkpoints` going up is precisely
+      the accident the big-folder census exists to prevent. With `--files-from` this
+      falls out for free, which is a second reason to prefer that shape.
+    - **Also worth routing through it once it exists:** `remote_upload_file` (the HPC
+      wizard's data step, currently one streamed SFTP file at a time) and the worker
+      `pull_outputs` download. Both are bulk, both already know their file list.
+    - **Floor stays.** rsync missing on either end, or any rsync failure, falls back
+      to today's SFTP path — the same bargain the pull side already strikes.
+    - [ ] 🤖 Automated test — pure argv builder (`rsync_push_args`: `--files-from=-`,
+      `-c`, the ControlMaster-riding `-e`, **no** `--delete`, no bare-directory
+      source); `should_use_rsync_push` false when either end lacks rsync, when the
+      set is empty, or when any path in scope is `excluded`; and a real-`sh`
+      round-trip asserting the file list rsync is fed equals the set `push_decision`
+      agreed, so a stale-blocked file can never reach the wire.
+    - [ ] 🖐️ Manual test — live host: push a large folder and confirm it lands
+      byte-identical and materially faster than the SFTP floor; edit one file on the
+      host, then push, and confirm that file is still blocked (amber) and its host
+      bytes untouched while its siblings go up; mark a subfolder excluded and confirm
+      it is not transferred; kill rsync on the host and confirm the push still
+      completes on the SFTP floor.
+
+---
+
+### G.24 — Remote-connect hardening: deferred follow-ups
+
+The 2026-07-25 audit + fix pass (5 analysis agents, 5 implementation agents, one
+adversarial review) closed three reported bugs — an HPC-tagged login node dialled
+unattended, a saved SSH password destroyed by an ordinary connect, and a global
+machine reading green while the project holding it stayed disconnected. What it
+deliberately did **not** do, in priority order:
+
+- [ ] **Task-local dial intent.** `ssh_common`'s authorization registry is
+  process-global, so a guard held across an `.await` authorizes any concurrent
+  task dialing the same target for that window (documented in place on
+  `AUTHORIZED_DIALS`). Closing it means a tokio task-local, or threading the
+  intent through every argv builder's call chain.
+    - [ ] 🤖 Automated test — a background dial to a tagged target is refused
+      *while* a user dial to the same target is in flight.
+- [ ] **Fold the four ControlMaster readiness polls into one hook.**
+  `useRemoteReconnect` (the only one with generation-counter cancellation),
+  `useRemoteSession`, `RemoteMachinesWindow`, `MachinesIndicator`. Same for the
+  four login-terminal lifecycles — only `useRemoteReconnect` re-adopts its PTY —
+  and the four hand-built `ssh:<target>` dedupe keys.
+- [ ] **`connectSshUnified`**: one entry (`commitUser` → host-key confirm →
+  `ssh_connect` → `remote_connect` → lamp write) for the eight `remote_connect`
+  call sites, so host-key confirmation cannot be present on some and absent on
+  others.
+- [ ] **`vpn_saved_password_state`** — the SSH side now distinguishes "not saved"
+  from "keyring unreadable"; the VPN side still reads a plain boolean, so a locked
+  keyring there still masquerades as "nothing saved". Needs the backend twin of
+  `remote_saved_password_state`.
+- [ ] **`sync_big_folders` takes no `confirmed`/`background` flag**, so the host
+  census on a tagged machine can only ever be refused — the frontend now says so
+  rather than silently doing nothing, but the explicit "measure it anyway" cannot
+  be honoured until the command accepts one.
+- [ ] **`pty_spawn`'s `HPC_GUARD` refusal has no frontend handler**: opening a tab
+  on a tagged, not-yet-connected project surfaces the raw sentinel instead of the
+  "connect and open" affordance the backend refusal was designed for.
+- [ ] **A tagged machine connected by hand does not propagate to its project**
+  (`lib/machineSync` skips HPC refs before opening a pool). Correct as a default —
+  a pool is a `ControlPersist` master — but the user is not told the project needs
+  a second click. Product call.
+- [ ] **`useSavedCredential` fires per keystroke** in the address fields, and each
+  call is now two keychain ops. Needs a debounce.
+- [ ] **`store_readable()` is Linux-only**: a locked macOS keychain can still let a
+  `Remember::Clear` through and still let `record_key_auth` stamp `key_auth: true`.
+- [ ] 🖐️ **Manual test (the whole pass)** — see the QA list in the session summary:
+  tagged-host add/browse/first-tab, credential survival across reconnects, the
+  Machines row states, and the `cm-*` socket sweep against a live master.
+
+---
diff --git a/todo/group-h.md b/todo/group-h.md
new file mode 100644
index 0000000..4a6cd68
--- /dev/null
+++ b/todo/group-h.md
@@ -0,0 +1,314 @@
+## Group H — Cross-Platform: Windows & macOS Support (new feature)
+*Files: `src-tauri/src/platform/*`, `services/`,
+`terminal/` (PTY), `commands/` (downloads, crash logging), `src-tauri/tauri.conf.json`
+(bundle targets), `.github/workflows/ci-cd.yml` (package jobs). Both OSes already
+have cross-platform foundations — platform-aware state paths, default-shell
+fallback, browser profile paths, network detection — so this is follow-up work,
+not a from-scratch port. Builds on / supersedes the OS half of #19 (Group C).*
+
+*Intentional gaps (decided, not forgotten — do not re-open without new facts):*
+- *Windows:* `make_sticky` (no public show-on-all-desktops API), window
+  **embedding** (no safe cross-process reparenting), ControlMaster and with it
+  the ssh-link monitor + `net_usage` sampler (Win32-OpenSSH has no mux support).
+- *macOS:* window **embedding** (impossible), **per-window** parking of foreign
+  apps (only app-granularity `NSRunningApplication hide/unhide`; per-window needs
+  private CGS/SkyLight APIs — rejected as build-fragile), popout self-parking
+  (hiding our own app would hide the MAIN window — deferred), `make_sticky`
+  (no public Spaces API), system-monitor process table limited to the calling
+  user's processes when unprivileged (`proc_pidinfo` visibility).
+- *Both:* the network pane's per-connection table (interfaces only; an
+  explanatory warning is shown in the pane).
+
+30. **Windows support follow-ups.** Windows is past the compile stage (state
+    paths, shell fallback, browser profiles, network detection, app-icon
+    helpers, NSIS packaging, and a Windows CI package job all exist). Native
+    window tracking/parking (`EnumWindows` + SW_HIDE model, `windows.rs` +
+    pure `windows_park.rs`), the PID liveness API (30c), and the
+    unhandled-exception crash hook (30g) are all built now. Remaining:
+    validate a real build/runtime on Win 10 1903+ and Win 11 (incl. ConPTY
+    behavior in xterm.js). (Browser download-preference editing was removed —
+    Eldrun no longer touches any browser's download path; see #60.)
+
+    **Cross-platform detection audit (2026-06-27).** A sweep for Linux-only code
+    paths that broke on Windows, fixing the directly-portable ones and tracking
+    the rest as the sub-items below.
+    - [x] **30a — Cross-platform binary detection.** ✅ Done. Every "is this CLI
+      installed?" probe hardcoded `Command::new("which")`, which does not exist on
+      Windows, so all agents (Claude included), the TeX toolchain, `sshfs`,
+      `sshpass`, and `openvpn`/`pkexec` reported as missing. Centralized one
+      `crate::paths::binary_on_path` (`where` on Windows, `which` elsewhere, via
+      `paths::path_finder(OsKind)`); `commands/agents.rs`, `commands/tex.rs`,
+      `commands/ollama.rs`, `services/ssh_mount.rs`, `services/openvpn.rs` all
+      route through it. Agent extra-path fallback also matches Windows exe
+      extensions (`.exe`/`.cmd`/`.bat`/`.ps1`).
+      - [x] 🤖 Automated test — `paths::path_finder_is_where_on_windows_which_elsewhere`
+      - [ ] 🖐️ Manual test — "Manage agents" lists installed agents on Windows
+    - [x] **30b — Cross-platform per-process CPU/RSS sampling.** ✅ Done. `sysstat`
+      was entirely `#![cfg(target_os = "linux")]`, so `project_cpu_percent` and
+      `debug_app_resource_usage` returned 0 on Windows. Refactored into a shared
+      cache/BFS layer over a per-OS backend: Linux `/proc`, **Windows** ToolHelp
+      snapshot (`CreateToolhelp32Snapshot`) for the process tree +
+      `GetProcessTimes` (kernel+user, 100-ns units) + `GetProcessMemoryInfo`
+      (working set), and a zero fallback for other OSes. CPU "ticks"/`clk_tck()`
+      abstraction keeps the caller's `busy_secs = ticks / clk_tck()` formula valid
+      on every backend. Added `Win32_System_{Diagnostics_ToolHelp,ProcessStatus,
+      Threading}` to the `windows` crate features. `terminal.rs`/`debug.rs` no
+      longer gate on Linux.
+      - [x] 🤖 Automated test — `sysstat` tests now run on Windows too
+        (`sum_jiffies`/`sum_rss_kib` against the live process, tree walk, cache)
+      - [ ] 🖐️ Manual test — pill popup shows live CPU/RSS on Windows
+    - [x] **30c — Native PID liveness.** ✅ Done. `check_pid_alive`
+      (`commands/apps.rs`) no longer shells out to `tasklist` on Windows; it uses
+      `OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION)` + `GetExitCodeProcess`,
+      treating `STILL_ACTIVE` (259) as alive (a handle to an exited process still
+      opens, so the exit code must be inspected — not just OpenProcess success).
+      Linux `/proc` and macOS/Unix `kill(pid,0)` branches unchanged.
+      - [x] 🤖 Automated test — covered by `cargo build --lib` compile + existing
+        callers; no behavioral unit test (needs a live pid)
+      - [ ] 🖐️ Manual test
+    - [x] **30d — App discovery + launching on Windows.** ✅ Done. Linux XDG
+      `.desktop` discovery is gated behind `cfg(not(windows))`; Windows now enumerates
+      Start-Menu `.lnk` shortcuts (`%ProgramData%` + `%APPDATA%`, recursive, deduped
+      by resolved target) for `list_installed_apps`, resolves targets/icons via the
+      existing `IShellLinkW` scaffold, and `run_script_detached` runs `.ps1` via
+      `powershell -NoProfile -ExecutionPolicy Bypass -File` and `.bat`/`.cmd`/assoc
+      via `cmd /C` instead of `bash`. Launch/open/embed commands keep their
+      signatures. Degrades gracefully: `xdg-mime` handler resolution no-ops (falls
+      back to configured/explicit handlers), icon rasterization is best-effort, and
+      `os_embeddable` is false (no Windows embedding backend yet).
+      - [x] 🤖 Automated test — `cargo test --lib apps` (incl. a Windows-gated
+        interpreter-selection test) passes
+      - [ ] 🖐️ Manual test
+    - [x] **30e — Screenshot capture on Windows.** ✅ Done. `commands/screenshot.rs`
+      refactored to a cfg-selected `platform` submodule (Linux tool-spawn unchanged).
+      Windows uses native Win32 GDI — `GetSystemMetrics(SM_*VIRTUALSCREEN)` for the
+      full multi-monitor virtual screen, `GetDC`/`CreateCompatibleDC`/`BitBlt`/
+      `GetDIBits`, BGRA→RGBA, then PNG-encoded via the existing `png` crate to a
+      timestamped file (same public command + output dir as Linux). All GDI handles
+      freed on success and error paths. Added `Win32_Graphics_Gdi`.
+      - [x] 🤖 Automated test — shared filename/date tests retained; build verified
+      - [ ] 🖐️ Manual test
+    - [x] **30f — VPN-gated projects on Windows.** ✅ Done — and since upgraded
+      twice: first from the original graceful-degradation stub to a **real
+      backend** (direct `openvpn.exe` spawn — worked only from an elevated
+      Eldrun), then (2026-07-16) to an **unelevated interactive-service flow**:
+      `connect_streaming` now asks `OpenVPNServiceInteractive` over
+      `\\.\pipe\openvpn\service` first (UTF-16LE startup message; the SYSTEM
+      service spawns `openvpn.exe` with the user's token and does the
+      privileged adapter/route work itself via `--msg-channel`), readiness is
+      tailed from `--log` via the shared `wait_for_ready_logfile`, and teardown
+      is a user-level `taskkill` + dropping the control pipe (the service
+      reverts routes via its undo lists — and kills the tunnel if Eldrun dies,
+      so it can't outlive the app). Non-admins need one-time membership in the
+      "OpenVPN Administrators" local group (the refusal message says exactly
+      that, with the `net localgroup` one-liner); the direct spawn remains only
+      as fallback when the service is missing. Windows `disconnect` also gained
+      the `disconnect_interactive` call Linux/macOS always had. Linux pkexec
+      path unchanged.
+      - [x] 🤖 Automated test — `cargo test --lib openvpn` passes on Windows
+        (svc startup-message encoding, reply parsing, cmdline quoting)
+      - [ ] 🖐️ Manual test — connect a VPN-gated project from an *unelevated*
+        Eldrun with `OpenVPNServiceInteractive` running (expect the group-
+        membership refusal first if not in "OpenVPN Administrators")
+    - [x] **30g — Windows crash hook** (2026-07-11; ✅ Done · 🧪 CI-unverified).
+      The native-fault analog of the Unix signal handlers: `install_seh_filter`
+      (`lib.rs`) opens crash.log at startup, keeps the raw HANDLE in
+      `CRASH_LOG_HANDLE`, and registers a `SetUnhandledExceptionFilter` that
+      `WriteFile`s one `=== CRASH: code=0x… addr=0x… ===` line before returning
+      `EXCEPTION_CONTINUE_SEARCH`. Formatting is allocation-free via the
+      un-gated `format_crash_line` (the heap may be corrupt mid-crash). Added
+      `Win32_System_{Diagnostics_Debug,IO,Kernel}` features.
+      - [x] 🤖 Automated test — `format_crash_line_*` (4 tests, run on Linux)
+      - [ ] 🖐️ Manual test — force a native crash on Windows; crash.log gains a
+        `=== CRASH:` line with the exception code
+    - [x] **30h — Windows whole-system monitor** (2026-07-11; ✅ Done · 🧪
+      CI-unverified). `sysstat.rs` Windows backend fills a real
+      `SystemSnapshot`: aggregate CPU via `GetSystemTimes` (kernel includes
+      idle), per-core via a manual `NtQuerySystemInformation(8)` extern decoded
+      by the pure `parse_processor_perf_buffer`, memory/swap via
+      `GlobalMemoryStatusEx` (swap = pagefile − physical, saturating),
+      `GetTickCount64` uptime, one ToolHelp walk for the process table
+      (`decode_ansi_nul` for names). All CPU counters stay 100-ns units so the
+      frontend's per-process ÷ machine tick math keeps matching units; no load
+      average on Windows (`[0.0; 3]`).
+      - [x] 🤖 Automated test — `parse_processor_perf_buffer_*`,
+        `decode_ansi_nul_*` (run on Linux)
+      - [ ] 🖐️ Manual test — System Monitor pane shows live CPU/mem/processes
+        on Windows
+    - [x] **30i — Windows local network snapshot** (2026-07-11; ✅ Done · 🧪
+      CI-unverified). `commands/network.rs` Windows `local_snapshot` via
+      `GetIfTable2`: alias name (UTF-16, `utf16_nul_to_string`), octet
+      counters, `OperStatus == Up`, ifType 24 = loopback; empty-alias filter
+      rows skipped. Per-connection details stay `None` with a pane warning.
+      The ssh-link monitor + `net_usage` sampler stay OFF on Windows by design
+      (no ControlMaster mux — see the intentional-gaps register above).
+      - [x] 🤖 Automated test — `utf16_alias_decoding_stops_at_nul` (Linux-run)
+      - [ ] 🖐️ Manual test — Network pane lists adapters with live byte counts
+        on Windows
+    - [x] **30j — Windows SSH password auth via askpass** (2026-07-11; ✅ Done ·
+      🧪 CI-unverified). Password auth no longer hard-requires `sshpass`: when
+      the installed OpenSSH honors `SSH_ASKPASS_REQUIRE` (≥ 8.4 —
+      `parse_openssh_version` + `version_supports_askpass_require`, probed once
+      via `ssh -V` in `ssh_supports_askpass`), Eldrun writes an
+      `ap-{pid}-{seq}.cmd` shim that echoes the secret through **PowerShell**
+      from the child-only `ELDRUN_ASKPASS` env var (never `@echo %VAR%` — cmd
+      would re-parse `& | < > ^` in a password). Win10-inbox OpenSSH 8.1 falls
+      back to `sshpass`; with neither, a clear "needs OpenSSH 8.4+ or sshpass"
+      error. All three password branches (probe, one-shot SFTP, pooled master)
+      chain askpass → sshpass → error; `SshTooling.password_auth` and the
+      dialog warning updated.
+      - [x] 🤖 Automated test — `parses_openssh_version_banners`,
+        `askpass_require_needs_openssh_8_4`,
+        `windows_askpass_shim_echoes_env_without_cmd_interpolation` (Linux-run)
+      - [ ] 🖐️ Manual test — password-SSH project connects without sshpass on
+        Win11 (OpenSSH ≥ 8.4) and via sshpass on Win10 1903
+    - [x] **30k — Windows position_window + popout occlusion** (2026-07-11; ✅
+      Done · 🧪 CI-unverified). `platform/windows.rs` overrides
+      `position_window` (`SetWindowPos` with `SWP_NOSIZE|SWP_NOZORDER|
+      SWP_NOACTIVATE`) so a file-drop-launched app lands on the drop monitor,
+      and adds `frontmost_window_under_cursor` (`GetCursorPos` →
+      `WindowFromPoint` → `GA_ROOT`) wired into `detached_window_frontmost` so
+      an occluded popout refuses a drop-merge (#42 parity with X11).
+      - [x] 🤖 Automated test — compile-gated (`cargo check --target
+        x86_64-pc-windows-msvc`); the pure occlusion logic is X11/macOS-side
+      - [ ] 🖐️ Manual test — file drop places the app on the drop monitor; a
+        popout behind the main window refuses the drop-merge
+
+    - [x] **30l — Windows panel-toggle key: F9, not the Win key** (2026-07-15;
+      ✅ Done). The lone-Meta panel toggle was enabled on Windows, but the lone
+      Win key belongs to the OS: Start opens on key *release* at the shell
+      level (`preventDefault()` can't stop it), and every global Win+X shortcut
+      pressed while Eldrun is focused fired a lone "Meta" keydown first,
+      spuriously toggling the panels. Lone Super is now Linux-only; Windows
+      uses **F9** (`useKeyboard.ts`), and the onboarding/help copy
+      (`hints.ts PANEL_TOGGLE_KEY`, `SettingsPanel.tsx`) says so.
+      - [x] 🤖 Automated test — existing shortcut tests unaffected; behavior is
+        a fixed key branch
+      - [ ] 🖐️ Manual test — F9 toggles panels on Windows; Win+X no longer
+        flickers them
+    - [x] **30m — Windows one-click agent install** (2026-07-15; ✅ Done).
+      `install_agent` hard-refused off Linux/macOS even though the registry
+      already carried `install_cmd_windows` for most agents. Now
+      `installer_command` picks the interpreter per command — PowerShell for
+      `irm … | iex`, `cmd /C` for plain npm/python lines (which may chain with
+      `&&`; Windows PowerShell 5.1 doesn't parse that) — with stdout+stderr
+      merged in-shell as on Linux. The Manage Agents panel shows the Install
+      button whenever the platform has a one-line installer (was `!IS_WINDOWS`);
+      agents without one (Mistral/vibe, Cursor) keep the docs-link fallback.
+      - [x] 🤖 Automated test —
+        `windows_installer_command_picks_interpreter_per_command` (Windows-run)
+      - [ ] 🖐️ Manual test — one-click install of an agent on Windows streams
+        its log and flips to "installed"
+    - [x] **30n — Windows disk-capacity probe** (2026-07-15; ✅ Done).
+      `duscan::capacity_of` returned `None` on Windows, silently dropping the
+      disk-usage pane's total/free capacity bar. Added a `#[cfg(windows)]` arm
+      via `GetDiskFreeSpaceExW` (total + caller-available bytes, quota-aware —
+      matching the Unix `f_blocks`/`f_bavail` semantics).
+      - [x] 🤖 Automated test — `capacity_of_home_reports_a_plausible_volume`
+        (runs on every OS)
+      - [ ] 🖐️ Manual test — disk-usage pane shows the capacity bar on Windows
+    - [x] **30o — no docker spawn at Windows startup** (2026-07-15; ✅ Done).
+      Containers are Unix-only, but `sandbox::sweep_orphans` ran unconditionally
+      at startup, spawning `docker --version` (and `docker ps` when Docker
+      Desktop exists) for nothing on Windows. Now gated on `cfg!(unix)`.
+      - [x] 🤖 Automated test — compile-covered; behavior is an early return
+      - [ ] 🖐️ Manual test — n/a
+
+31. **macOS support follow-ups.** macOS has initial cross-platform code (state
+    paths, default shell, browser profiles, network detection, Unix symlinks),
+    and native window tracking/parking now exists (31b — `CGWindowList` +
+    `NSRunningApplication`, no Accessibility permission, no private APIs; it
+    replaced the null-backend fallback). Remaining: add bundle support when
+    distribution is needed (`dmg`/`app` target, `minimumSystemVersion`, CI
+    artifact handling); add Hardened Runtime entitlements **only** if
+    signing/notarization is pursued — do **not** enable App Sandbox (PTY needs
+    unrestricted POSIX PTY access); validate a real build on Apple Silicon (and
+    Intel if needed); add native app-icon resolution for `.app` bundles if the UI
+    needs resolved macOS icons.
+    - [~] **31a — Native CPU/RSS sampling backend.** ✅ Code-complete, ⚠️
+      **unverified** (compiles only on macOS; written/reviewed on a Windows host).
+      Added a `#[cfg(target_os = "macos")] mod platform` in `sysstat.rs` using
+      libproc: `proc_pidinfo(PROC_PIDTASKINFO)` → `pti_total_user + pti_total_system`
+      (nanoseconds; `clk_tck()` = 1e9) and `pti_resident_size` for RSS;
+      `proc_pidinfo(PROC_PIDTBSDINFO)` → `pbi_ppid`; `proc_listallpids` for the tree.
+      Fallback cfg narrowed to `not(any(linux, windows, macos))`. Callers
+      (`terminal.rs`/`debug.rs`/`terminal/mod.rs`) are already cross-platform.
+      - [ ] 🤖 Automated test — `sysstat` tests run on macOS (currently only
+        compile-verifiable on a mac); no macOS CI yet
+      - [ ] 🖐️ Manual test — needs a real macOS build to confirm the libc bindings
+        (`proc_taskinfo`/`proc_bsdinfo`/`proc_listallpids`) resolve in pinned
+        `libc 0.2`; if any is absent, add a minimal `extern "C"`/`#[repr(C)]` decl.
+    - [~] **31b — macOS workspace backend** (2026-07-11; ✅ Code-complete, ⚠️
+      **unverified** — compile-blind on Linux, no macOS SDK). macOS no longer
+      falls to `NullBackend`: `platform/macos.rs` implements `WorkspaceBackend`
+      over raw `extern "C"` FFI — `CGWindowListCopyWindowInfo` enumeration
+      (id/pid/owner/layer/bounds need **no** Screen Recording permission) +
+      `objc_msgSend` into `NSRunningApplication hide/unhide` (**no**
+      Accessibility permission). Parking is **app-granularity** (per-window
+      needs private CGS — rejected; see gaps register). Safety invariants:
+      `pid == self` unconditionally never hidden (hide is app-wide → would take
+      the MAIN window), protected owners (Dock/Finder/WindowServer/…) never
+      hidden, cleanup/Drop unhides exactly what was hidden. Hidden apps leave
+      the on-screen list, so hide time records window→pid in the pure, un-gated
+      `macos_park::MacParkState`. Wiring: factory arm, `apps.rs` window
+      resolvers (+ hide-time re-resolve on macOS like Windows), subwindow
+      occlusion arm (popouts don't learn a CGWindowID yet), `lib.rs` binds the
+      main window's `windowNumber`.
+      - [x] 🤖 Automated test — full `macos_park` suite runs on Linux
+        (protected-name matrix, structural main-window guard, park/show pid
+        round-trip, `frontmost_at_point` occlusion cases)
+      - [ ] 🖐️ Manual test — on a mac: project switch hides/shows foreign apps;
+        Eldrun/Finder/Dock never hidden; quitting Eldrun unhides everything
+    - [~] **31c — macOS whole-system monitor** (2026-07-11; ✅ Code-complete, ⚠️
+      **unverified**, compile-blind). `sysstat.rs` macOS `system_snapshot`:
+      per-core CPU via `host_processor_info` (ticks → **nanoseconds** so units
+      match the ns-based per-process times; pure
+      `parse_host_processor_ticks`), memory via `sysctl(HW_MEMSIZE)` + a manual
+      `repr(C)` `vm_statistics64` head (`available ≈ free+inactive`), swap via
+      `VM_SWAPUSAGE`, `getloadavg`, boot-time uptime; process table from
+      libproc with `bsd_process_state` (SRUN/SSLEEP/SSTOP/SZOMB → R/S/T/Z).
+      Unprivileged `proc_pidinfo` only sees the calling user's processes —
+      inaccessible pids are skipped (see gaps register).
+      - [x] 🤖 Automated test — `parse_host_processor_ticks_*`,
+        `bsd_process_state_*` (Linux-run)
+      - [ ] 🖐️ Manual test — System Monitor pane populates on a mac; CPU% of a
+        busy process roughly matches Activity Monitor
+    - [~] **31d — macOS local network snapshot** (2026-07-11; ✅ Code-complete,
+      ⚠️ **unverified**, compile-blind). `network.rs` spawns `netstat -ibn`
+      (chosen over the raw `NET_RT_IFLIST2` sysctl — hand-declared
+      route-message layouts are silent-garbage risk when nothing can be run)
+      parsed by the fixture-tested `parse_netstat_ibn` (`<Link#N>` rows only,
+      end-indexed columns since the Address cell can be empty). Connections
+      stay `None` with a pane warning, mirroring Windows.
+      - [x] 🤖 Automated test — `parses_netstat_ibn_link_rows` (Linux-run,
+        real-shaped fixture)
+      - [ ] 🖐️ Manual test — Network pane lists en0/lo0/utun* with live byte
+        counts on a mac
+    - [~] **31e — macOS OpenVPN backend** (2026-07-11; ✅ Code-complete, ⚠️
+      **unverified**, compile-blind). Replaces the "not yet supported" stubs:
+      `osascript -e 'do shell script … with administrator privileges'` starts
+      `openvpn --daemon --log <file>` (osascript blocks until the launched
+      command exits — daemonizing is what makes it return), then the handshake
+      is followed by tailing the logfile via the cfg-free, temp-file-tested
+      `wait_for_ready_logfile`. A macOS-own registry keys config →
+      pidfile/logfile (no Child); `is_connected` probes `kill(pid, 0)` with
+      **EPERM = alive** (root daemon — this fixes the 28l "lamp never green"
+      gap). Disconnect = admin-prompted `kill -TERM` (second prompt accepted
+      for v1; management-interface teardown is the no-prompt follow-up).
+      Interactive mode types `sudo openvpn --config … --auth-nocache`.
+      - [x] 🤖 Automated test — `applescript_escape_*`,
+        `macos_admin_shell_command_*`, `pidfile_pid_*`,
+        `wait_for_ready_logfile_*` (Linux-run)
+      - [ ] 🖐️ Manual test — VPN project on a mac: admin prompt → lamp green →
+        disconnect (second prompt) → lamp red; interactive mode types
+        `sudo openvpn …` into the root tab
+    - [ ] **31f — macOS ssh-link traffic via nettop** (design note, no code).
+      ControlMaster exists on macOS, so remote projects mux fine; what's
+      missing is per-socket byte counters for the ssh-link monitor +
+      `net_usage` sampler (`ss -ti` is Linux-only). Design: resolve the master
+      pid from `ssh -O check` (as on Linux), then sample
+      `nettop -P -x -L 1 -p <master-pid>` and parse its CSV (`bytes_in`/
+      `bytes_out` columns) into the existing `SshLinkSnapshot`. Needs a mac to
+      verify nettop's CSV shape/permissions before writing the parser.
+
+---
diff --git a/todo/group-i.md b/todo/group-i.md
new file mode 100644
index 0000000..2f7c849
--- /dev/null
+++ b/todo/group-i.md
@@ -0,0 +1,29 @@
+## Group I — Backend Runtime Follow-Ups
+*Files: `src-tauri/src/services/` (`project_runtime.rs`, `terminal_service.rs`,
+`window_service.rs`), `commands/`, `.eldrun/sessions/` mirrors, `schema/`. The
+first backend runtime boundary pass is implemented: project switching is
+coordinated through `switch_project_runtime`, core services live under
+`services/`, tab/file/layout/window metadata is mirrored into
+`.eldrun/sessions/`, download routing is part of switching, and the old
+`switch_project_windows` command is deprecated. Related to #24 (session restore),
+but backend-owned.*
+
+32. **Backend runtime follow-ups.** Remaining backend-side work on the runtime
+    boundary, each independently pickable:
+    - Backend-owned PTY resurrection after app restart, including dead-session
+      detection and a clear frontend policy (respawn, mark dead, or manual
+      restart).
+    - Terminal/agent transcript storage if restart recovery needs readable
+      historical output rather than metadata-only restoration.
+    - Promote `.eldrun/` runtime files from optional mirrors to the primary
+      source once compatibility reads from `project.json` are validated.
+    - Durable project-window metadata under `.eldrun/sessions/windows.json`
+      beyond registry IDs (window role/origin, restore command, optional file
+      target, future geometry/focus fields).
+    - Move file-navigation runtime state backend-side once switching is stable:
+      center file tabs, right-panel folder, breadcrumbs, history.
+    - Focused tests for backend runtime switching with mocked services
+      (time flushing, old-project save, project-window hide/show, download
+      routing, root runtime handling, no respawn of already-live tabs).
+
+---
diff --git a/todo/group-j.md b/todo/group-j.md
new file mode 100644
index 0000000..7651cb2
--- /dev/null
+++ b/todo/group-j.md
@@ -0,0 +1,39 @@
+## Group J — Web & Mail Surfaces: Routing, In-App Mail & Browser
+*Three related surfaces for web/mail content sharing where-it-lives (right-panel
+view vs. center tab vs. global-app surface), security, and auth decisions. #33
+routes links **out** to the user's configured external apps; #65 and #61 are the
+**in-app** counterparts (read mail / browse the web without leaving the
+workspace). Files: `src/components/layout/GlobalAppBar.tsx` (roles +
+launch-or-raise), `src-tauri/src/commands/apps.rs` (`launch_app`, `open_file`),
+terminal/file-tree link handling (the global-apps suite is already implemented —
+#33 is its last remaining item); plus, for the in-app surfaces, a new
+`commands/mail.rs` + `schema/mail.rs` + `src/components/mail/` (mail) and a Tauri
+webview surface + `src/components/browser/` (browser), and `types/index.ts`. No
+mail or browser code exists today.*
+
+33. **URI scheme routing** (migrated from TODO `G6.7`). Intercept `http://`,
+    `https://`, `mailto:`, and `webcal:` links opened from within terminals or
+    the file tree and route them through the global-app launch-or-raise flow
+    (`launch_app`, keyed by the `browser` / `mail` / `calendar` roles) instead of
+    a bare `xdg-open` call, so links open in the user's configured global app.
+
+65. **Include a mail viewer in Eldrun.** Add an in-app email reader so mail can be
+    read without leaving the workspace. Scope to be defined when picked; open
+    questions to settle first: protocol (IMAP vs JMAP vs a provider API like
+    Gmail), auth model (app password vs OAuth, mirroring the SSH "no in-app
+    passwords" stance where possible), read-only vs send/reply, and where it lives
+    (right-panel view like Git/Files, a dedicated center tab, or a global-app
+    surface). Pairs naturally with #33 (`mailto:` routing) once present.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+61. **Include a browser in Eldrun.** Add an in-app web browser so pages can be
+    viewed without leaving the workspace. Weigh the security implications
+    (sandboxing, per-project download routing per #60, credential isolation)
+    before building. Scope and surface (center tab vs. right-panel vs. global-app)
+    to be defined when picked. Pairs with #33 (link routing) and #53 (drag a tab
+    into a browser upload field).
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+---
diff --git a/todo/group-l.md b/todo/group-l.md
new file mode 100644
index 0000000..0b76708
--- /dev/null
+++ b/todo/group-l.md
@@ -0,0 +1,125 @@
+## Group L — Center Panel: Tabs, Subwindows & Navigation
+*Builds on Group D.11 (tiling split subwindows). All items share the center-panel
+files: `src/stores/tabs.ts` (per-scope layout tree `layoutByScope`,
+`focusedGroupByScope`, active tab), `src/components/layout/CenterPanel.tsx`,
+`src/components/tabs/Subwindow.tsx` / `src/components/tabs/TabBar.tsx`,
+`src/stores/projects.ts`. #42 additionally needs a Tauri multi-window surface
+(`src-tauri/src/lib.rs`, `tauri.conf.json`) + the platform show/hide path
+(`platform/x11.rs`, `platform/wayland_kde.rs`, `services/window_service.rs`,
+`services/project_runtime.rs`); #55–#57 touch `schema/project.rs`; #62 touches
+`src/App.tsx` (global key handlers). #55 (mapping bug) and #62 (keyboard nav) are
+correctness/UX work atop the same layout model #42 detaches.*
+
+42. **Drag a subwindow out of the Eldrun main window.** ✅ Implemented · 🧪 Awaiting
+    live multi-window QA. Let a tiling subwindow
+    (a tab group from Group D.11/#36) be dragged out of the main window and become
+    its own standalone OS window, while keeping it bound to its project. The
+    detached window must follow the **same hide/show logic as on project switch**:
+    when the user switches projects in the main window, a detached subwindow
+    belonging to the now-inactive project is parked/hidden on the hidden workspace
+    (and re-shown on switching back) exactly like other project-owned windows,
+    rather than floating free across all projects.
+    Settled decisions (v1): detach gesture = explicit **pop-out button** (drag-past-
+    edge deferred — WebKitGTK risk); detached window is a **second Tauri
+    `WebviewWindow`** loading the same bundle under `?detached=<scope>:<groupId>`
+    rendering one group (inert to project switches); the group leaves `layoutByScope`
+    and is tracked in `detachedGroupsByScope` while its tab payloads stay in the
+    shared store (PTYs never unmount); detached `TerminalView` is **attach-only**
+    (no `pty_spawn`/no kill-on-unmount — output is broadcast by id; blank until next
+    output, no scrollback restore); restart re-docks (session-only) but a detached
+    group's tabs stay in `project.json` mid-session; parking reuses the existing
+    `project_runtime::switch` path via an `ORIGIN_DETACHED_SUBWINDOW` tracked window
+    + a hardened X11 `set_parkable` override (main window structurally never
+    parkable) **and** a backend-independent Tauri `hide()/show()` fallback so
+    Wayland/KDE/null also hide an inactive project's detached window; re-attach via
+    dock-back button + dock-on-close (`onCloseRequested`) **and Ctrl+drag-to-dock**:
+    Ctrl+dragging the popout's tab bar streams the gesture (screen coords, via the
+    `DETACHED_DRAG_*` events) to the main window, which maps them to client space,
+    shows the normal drop preview, and docks the group on release over a subwindow
+    (`attachGroup` with the resolved edge/center target) — released outside the main
+    window or on Escape, the popout stays floating. A plain (non-Ctrl) tab-bar drag
+    still hands off to the WM for a native window move.
+    Plan/reviews: `docs/group_l_42_detach_plan.md`,
+    `docs/group_l_42_detach_plan_review.md`, `docs/group_l_42_detach_review_code.md`.
+    *Files: `src/stores/detached.ts`, `src/stores/tabs.ts`,
+    `src/components/layout/DetachedApp.tsx` / `DetachedCenterPanel.tsx` /
+    `AppShell.tsx`, `src/components/tabs/TabBar.tsx`,
+    `src/components/terminal/TerminalView.tsx`, `src/App.tsx`;
+    `src-tauri/src/commands/subwindow.rs`, `platform/x11.rs` / `platform/mod.rs`,
+    `services/window_service.rs` / `services/project_runtime.rs`, `lib.rs`,
+    `tauri.conf.json`, `capabilities/default.json`.*
+    - [x] 🤖 Automated test — `SubwindowDetach`, `DetachedSync`, `DetachedHost`,
+      `TerminalAttachOnly` (frontend) + `window_service` detached-labels selector
+      (backend). tsc clean; 30 #42 frontend tests pass; cargo 373 pass.
+    - [ ] 🖐️ Manual test — needs backend rebuild + live run (pop-out spawns &
+      seeds, PTY attaches without respawn, X11 park + Tauri hide on switch,
+      Wayland hide fallback, dock-back & dock-on-close, main window never parked).
+
+55. **[Bug] Fix tab→project mapping leak.** A tab can show up under the wrong
+    project — e.g. the ProjectEldrun main window showing a `TODO.md` tab that
+    belongs to a different project. This must never happen. Audit tab persistence
+    / restore and the per-scope layout keying (`layoutByScope`, `tab_layout`/
+    `tab_groups`, scope ids) so tabs are strictly bound to their owning project.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+56. **Right-click a tab → start renaming.** A right-click on a tab should
+    immediately enter inline rename mode (rather than going through a menu).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+57. **Open `README.md` by default for a project with no tab.** When a project is
+    opened/activated and has no tabs to restore, show its `README.md` in an
+    in-app viewer tab by default (uses the Group D.14 viewer).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+62. **Fast keyboard navigation across projects / subwindows / tabs.** Make the
+    whole app steerable from the keyboard with no mouse required. Needs design
+    choices, but the target set: a fast fullscreen mode for a tab/subwindow,
+    keyboard switching between projects, between subwindows (e.g. `Shift`+arrows
+    to focus subwindows), between tabs in a subwindow (e.g. `Shift`+`Tab`), and
+    between projects (e.g. `Shift`+`Ctrl`+`Tab`), plus closing tabs/subwindows —
+    all keyboard-driven.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+82. **Native keyboard file-tree navigation (no mouse).** Make the right-panel
+    file tree (`FileTree.tsx`) fully steerable from the keyboard — arrow/`j`/`k`
+    to move the selection cursor, `←`/`→` (or `h`/`l`) to collapse/expand a
+    directory, `Enter` to open the selected file in a tab, plus wheel-style fast
+    scrolling so a long tree can be traversed without reaching for the mouse.
+    Builds on #62 (keyboard nav) and the Group D.1 file tree.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+83. **One key shows the radial "pie" project view (as in the root project).**
+    A single keypress brings up the same radial/pie project-blob view used by the
+    root project (the 3D project blob default root tab, see `ProjectBlobPane.tsx`)
+    as a fast project switcher overlay — invoked purely from the keyboard.
+    Builds on #62.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+84. **Keyboard navigation within the pie view.** Once the radial/pie view (#83)
+    is open, additional keys step the selection around the pie (e.g. arrows /
+    rotate keys to move between wedges, `Enter` to activate the highlighted
+    project, `Esc` to dismiss) so a project can be picked entirely by keyboard.
+    Builds on #83.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+85. **Keyboard tab/subwindow management (split, detach, move).** Drive the whole
+    Group D.11 tiling layout from the keyboard with no mouse: split the focused
+    subwindow horizontally/vertically into a new tab group, move the focused tab
+    into an adjacent subwindow (or a fresh split), detach the focused subwindow
+    into its own OS window (the #42 pop-out gesture, keyboard-triggered), and
+    re-dock it — all via shortcuts. Builds on #62 and #42 (detached subwindows).
+    *Files: `src/stores/tabs.ts` (split/move on `layoutByScope`),
+    `src/components/tabs/Subwindow.tsx`/`TabBar.tsx`,
+    `src/stores/detached.ts` + `src/components/layout/DetachedApp.tsx`,
+    `src/App.tsx` (global key handlers).*
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+---
diff --git a/todo/group-m.md b/todo/group-m.md
new file mode 100644
index 0000000..f1d8783
--- /dev/null
+++ b/todo/group-m.md
@@ -0,0 +1,536 @@
+## Group M — In-App Viewers: Text / TeX / Image Enhancements (Phase 2+)
+*Builds on Group D.14 (in-app file→tab viewers). Files: `src/components/embed/FileViewerPane.tsx`,
+`src/components/files/markdown.ts`/`tex.ts`/`highlight.ts`, `fileUtils.ts`
+(`internalViewerFor`), `src/stores/tabs.ts` (`"embed"` tab kind, `viewer`),
+`src/components/embed/EmbedPane.tsx`, backend `commands/tex.rs`
+(`tex_capability`/`compile_tex`), `commands/apps.rs` (`embed_capability`,
+default-app resolution), `src/types/index.ts`, `README.md`.*
+
+43. **Auto-reload the native text viewer from disk (diff-aware).** When a file
+    open in the in-app text viewer changes on disk, reload it with a diff check so
+    external edits (agents, git checkout, other tools) surface in the viewer.
+    Don't clobber unsaved in-tab edits — detect divergence and reconcile (reload
+    when clean; warn/merge-prompt when the buffer is dirty). Likely a file-watch
+    or poll on the open file's mtime/hash.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+44. **TeX viewer: preview off by default.** Default the TeX viewer to the source
+    editor rather than auto-rendering a preview; make preview an explicit toggle.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+45. **Auto-complete in native text viewers (pre-defined model).** Add code/text
+    auto-completion across all native text viewers, driven by a pre-defined
+    (ideally local) model. Settle the model source (local Ollama vs. configured
+    global), trigger/UX, and the privacy posture (no remote calls for local-only
+    projects) when picked. *Completion-length modes:* the model can be asked for a
+    Sentence (current word/line), Block (current code block/paragraph), or Scope
+    (whole enclosing function) completion — set per file type in settings
+    (`viewer_prefs[type].autocomplete_mode`) and toggled live in-editor with
+    `Shift+Tab` (cycles Sentence → Block → Scope and re-requests). The Rust
+    `CompletionMode` drives both the prompt TASK hint and the `num_predict` cap
+    (`commands/ollama.rs`). *Accept (while a ghost is showing):* `Tab` inserts the
+    whole suggestion; `Right` (→) inserts only the next word and keeps the rest
+    ghosted (walk word-by-word); `Esc` dismisses.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+46. **Undo/redo in native text/TeX viewers.** Add an undo/redo history to the
+    in-app text and TeX editors (keyboard `Ctrl+Z`/`Ctrl+Shift+Z` plus buttons).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+47. **Save icon instead of "save/saved" text (+ optional autosave).** Replace the
+    textual save/saved status in the text/TeX viewer with a save icon that
+    reflects dirty/clean state; consider periodic autosave (with the #43
+    diff-aware reload as the counterpart for external changes).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+48. **Per-file-type native-viewer settings + document supported types.** A single
+    settings surface to configure native-viewer behavior keyed by file type, and
+    document the supported types (and the native text viewer) in `README.md`.
+    Ties into #44 (per-type preview defaults) and #45 (per-type completion).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+49. **Make file links in text/TeX viewers visibly clickable.** Render links that
+    point at files with a clear affordance (underline / dotted underline) so they
+    read as clickable, in both the text and TeX viewers. (Companion to #50, which
+    governs *where* a clicked link opens.)
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+50. **Link-open routing: same subwindow, or drag-to-set-default.** When a file
+    link (#49) is clicked, open the target in the **same** subwindow by default;
+    if the user drags the link to another subwindow, make that the default target
+    **only for that file, from that linking file, for this session** — discard the
+    mapping when the linking file's tab is closed (and optionally close the
+    linked file(s) with it).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+51. **Native `.odt` / `.xlsx` viewer.** Add an in-app viewer for OpenDocument /
+    spreadsheet files. First decide whether it's worth it / already feasible via
+    an existing Tauri-side renderer before building one.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+52. **Image viewer: zoom/scroll to the cursor.** Improve image-viewer scrolling so
+    zoom centers on the mouse cursor rather than the viewport origin.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+53. **Drag images (and their tabs) out as drop sources.** Make images in the image
+    viewer — and image tabs — draggable as drop sources, e.g. drag an image/text
+    tab and drop it into a browser file-upload field.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+54. **TeX compile output → PDF in a new tab + compiler options.** Open the
+    compiled PDF as its own tab (it is a real file), and add compiler options to
+    the TeX viewer (output folder, engine/flags, …). Extends the existing
+    `compile_tex` affordance from Group D.14.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+55. **Adjustable text size in the text/TeX/Markdown editors.** Add an `A−`/`A+`
+    control (and `Ctrl` +/−, `Ctrl`+0 to reset) that scales the editor font. In
+    the code editors (text/TeX) the gutter and syntax/link/ghost overlay layers
+    scale together via the `--code-font-size`/`--code-line-height` CSS variables;
+    in Markdown it sizes the source textarea and, once set, the rendered preview
+    base font. The size persists per file type in `viewer_prefs[type].font_size`
+    (alongside #45's autocomplete).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+66. **SyncTeX PDF↔source navigation + subtex→main compile wiring.** Make the
+    compiled PDF and its `.tex` source navigable both ways, and let a child file
+    build its parent. Compiles now always emit `-synctex=1` (`commands/tex.rs`).
+    *Reverse search:* clicking a point in a PDF (`PdfCanvas`) runs `synctex_edit`
+    and jumps the source tab to that line (via the `editorJump` store +
+    `CodeEditor` `gotoLine`). *Forward search:* after a compile, `synctex_view`
+    maps the source caret to a PDF box that `PdfCanvas` scrolls to and flashes
+    (via the `pdfSync` store). *Subtex wiring:* a successful compile records each
+    `\input`/`\include` child→root in `~/.local/share/eldrun/tex_roots.json`, and
+    `resolve_tex_root` (magic `% !TEX root` comment → stored map → self) redirects
+    a child's Compile to its main document. Adds a compile run animation
+    (`.is-compiling` button sheen + header progress strip, reduced-motion aware).
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+67. **Find in the text/TeX viewers.** Add an in-editor search bar to the shared
+    `CodeEditor` (so it covers both the text and TeX viewers). `Ctrl`/`Cmd`+`F`
+    opens a floating find bar pinned to the editor's top-right — bound on the
+    editor container so it opens whenever focus is anywhere in the tab, not only
+    on the textarea. The bar has a query input (seeded from the selection), a live
+    `n/total` count, `↑`/`↓` (and `Enter`/`Shift`+`Enter`) to cycle, a `Aa` match-
+    case toggle, and `Esc` to close. Matches are painted by a transparent overlay
+    `<pre>` layer (`decorateSearchRanges`) scroll-synced like the highlight/link
+    layers, the current match brighter; navigation moves the textarea selection
+    and scrolls the match into view. Pure helpers `findMatches`/`decorateSearchRanges`.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+68. **Image viewer: auto-reload on disk change.** Give the image viewer the same
+    diff-aware reload as the editors/PDF (#43): `useBlobUrl` polls `file_mtime`
+    and re-reads the bytes when the file changes on disk, swapping the blob URL
+    only once the fresh bytes are ready (no flash) and revoking the old one. An
+    image regenerated by an external tool updates in place; the user's zoom/pan is
+    preserved when the new image has the same dimensions, and only re-fit when the
+    dimensions change.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+69. **Persist viewer scroll/zoom across reopen + restart.** The in-app PDF, text,
+    and image viewers remember the reader's position so reopening a file — or
+    restarting Eldrun — restores it instead of jumping to the top/default zoom.
+    A per-tab `ViewerState` (`scrollTop`/`scrollLeft`/`scale`/`offsetX`/`offsetY`,
+    `src/stores/tabs.ts`) travels with the `embed` tab through
+    `save_tab_layout`/`loadFromLayout` (round-tripped via the Rust `TabEntry`'s
+    flattened `extra`, no backend change). The viewer panes
+    (`FileViewerPane.tsx`, shared `useViewerState` hook) restore once on first
+    load and persist (throttled) as the reader scrolls/zooms/pans; the PDF honours
+    a saved zoom over fit-width on first load, and `CodeEditor` gained
+    `initialScrollTop`/`onScrollPersist`. `setViewerState` merges + dedups so an
+    unchanged write never churns the saveLayout debounce.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+70. **TeX viewer: `Ctrl`+`S` saves and recompiles.** In the LaTeX viewer (engine
+    available), `Ctrl`+`S` runs `compile()` instead of a plain save — `compile()`
+    persists pending edits first, so the PDF preview tracks the source. The
+    no-engine fallback keeps `Ctrl`+`S` as a plain save.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+71. **Find in the native PDF viewer (`Ctrl`+`F`).** Add an in-document search bar
+    to the pdf.js-backed PDF viewer (the counterpart to #67's editor search).
+    `Ctrl`/`Cmd`+`F` (or the 🔍 toolbar button) opens a find bar — a static row
+    below the zoom toolbar — bound on the PDF host so it opens wherever focus sits
+    in the pane (the scroll area is `tabIndex=0`). It has a query input, a live
+    `n/total` count, `↑`/`↓` (and `Enter`/`Shift`+`Enter`) to cycle, a `Aa` match-
+    case toggle, and `Esc` to close. Each page's text is extracted lazily on first
+    use via `getTextContent()` (shared `pageTextItemBoxes`, the same boxes SyncTeX
+    word-refinement uses) and cached per document; the pure `pdfPageMatches`
+    (`lib/viewers/tex.ts`) slices matches into big-point boxes (one per text run a
+    match straddles). Matches paint as translucent overlays over the page canvases
+    (`.file-viewer-pdf-search-hit`), the current one brighter and scrolled into
+    view. Pure helper `pdfPageMatches`.
+    - [x] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+80. **PDF page arranging + merging, on ONE code base with the print preview.**
+    Turn the read-only PDF viewer into a page organiser: reorder, delete, turn,
+    duplicate and merge pages, drag pages from one open PDF viewer into another,
+    and drag them **between two Eldrun windows**.
+
+    The print preview already had half of this (a thumbnail strip that
+    drag-reorders/deletes/turns pages) — it just never wrote a PDF. So rather than
+    build a second page-arranger, its model and its strip were **generalised and
+    shared**:
+
+    - **`lib/viewers/pageModel.ts` — the one arrangement model.** A `PageList` of
+      `PageRef{id, src, page, rot}`. Each entry carrying its own id/source/rotation
+      is what the print preview's old `order: number[]` + rotations-keyed-by-page
+      could not express: pages from *several* documents (merge), a duplicate turned
+      independently of its twin, and multi-page moves. `print.ts`'s
+      `initialOrder`/`movePage`/`removePage`/`rotatePage`/`printSequence` are gone;
+      its old test cases were re-expressed against the new model, so the port is
+      pinned as behaviour-preserving.
+    - **`components/common/PageStrip.tsx` — the one strip.** Horizontal in the print
+      preview, vertical as the PDF page rail. `printDocument` keeps its tuned
+      imperative modal (iframe, WebKitGTK `@page` workarounds) and mounts the React
+      strip into it via `mountPageStrip`. Print preview *gained* shift-select,
+      ctrl-select, duplicate and a right-click menu for free.
+    - **Writing the PDF (the missing half).** New dep `pdf-lib`, used in exactly one
+      place: `pdf/pdfDoc.ts#buildPdf`, on save. Editing never rebuilds the document —
+      the reader and rail render straight off the `PageList` — so a reorder is an
+      array op, not a re-parse. Save writes through the existing `writeFileBytes`,
+      which already routes local **and** remote/SFTP. Explicit save + full undo/redo;
+      an external change while dirty raises a banner instead of clobbering either
+      side. pdf.js *detaches* the buffer it is handed, so each source keeps a pristine
+      byte copy for pdf-lib.
+    - **Cross-window drag (`stores/pdfDrag.ts` + `commands/pdf_clip.rs`).** Two
+      windows are separate WebViews with separate JS heaps, so the pages are built
+      into a small PDF, parked in a backend slot, and only the *token* rides the
+      event. Position comes from polling the OS cursor in physical desktop px
+      (`lib/coords`), because DOM pointer events don't cross an OS window boundary on
+      WebKitGTK — the same reason the tab drag-dock does it. On release every window
+      gets the END carrying the last polled cursor; only the one whose rect contains
+      it claims the drop and acks. Copy is the default; **Shift moves**, and the
+      source deletes its pages *only* once the drop is acknowledged — so a drag
+      released over empty desktop can never destroy them.
+    - Merge also via a toolbar **Insert PDF…** (the project-scoped
+      `ContextFilePicker` — the backend confines reads to the project tree, so an OS
+      file dialog's path would simply be refused).
+    - **Known limit:** pdf-lib's `copyPages` preserves page content and most
+      annotations, but AcroForm fields and some tagged-PDF structure can be lost on
+      rebuild. Fine for a page organiser; not a lossless editor for interactive forms.
+    - [x] 🤖 Automated test (`PageModel`, `PageStrip`, `PdfSave` — real pdf-lib
+      round-trips asserting page order/rotation in the written bytes —, `PdfPageDrag`,
+      and Rust `pdf_clip`)
+    - [ ] 🖐️ Manual test — **the cross-window drag is the one to watch**: it is the
+      WebKitGTK-sensitive path. Also re-check the print preview still reorders/prints
+      as before, and that saving works on a **remote (SSH)** project's PDF.
+
+87. **Python in the native code viewer: Run, Debug, breakpoints, go-to-definition.**
+    Turn the text editor into a usable Python workbench for the three things a
+    script actually needs, without importing an LSP or a DAP client.
+
+    - **Run / Debug open a terminal tab** (`lib/pythonRun.ts`) rather than a bespoke
+      execution path — the same one-click-open-a-tab-and-run policy as
+      `installCommand.ts`. That is what makes them work everywhere Eldrun already
+      works, *for free*: a shell tab carries the project's locality and sandboxing,
+      so Run on a **remote (SSH)** project runs on the host and Run on a
+      **containerised** project runs inside the container, with no code of its own.
+      It also means the process is a real interactive terminal — `input()` works,
+      `Ctrl+C` works, and the shell outlives the program so the traceback stays on
+      screen and `↑` re-runs it. The project's **virtualenv wins** over the system
+      interpreter (`.venv`/`venv`/`env`, probed via `list_dir`, which resolves over
+      SFTP on a remote project) — running with the bare `python3` would
+      `ModuleNotFoundError` on the project's own deps and read as "Run is broken".
+      Re-running **replaces** the previous run tab for that file rather than
+      re-typing into it: the old PTY may be sitting at a pdb prompt or blocked on
+      input, and the command would go to *that*, not to a shell.
+    - **Debugging is pdb, driven from the gutter.** Breakpoints are handed to it as
+      `-c "b file:N"` followed by `-c continue`, so the session runs straight to the
+      first one. With none set the `continue` is omitted and pdb stops at line 1 —
+      otherwise "debug" would be indistinguishable from "run".
+    - **The gutter is the breakpoint UI** (`CodeEditor`): its line numbers become
+      real buttons (so the column drops its `aria-hidden` — hiding a control from the
+      a11y tree would make the feature mouse-only). Two things make a breakpoint more
+      than a line number, and both live in the pure `lib/viewers/python.ts`: pdb
+      *refuses* blank/comment/decorator lines, so a click **snaps** down to the next
+      executable one; and a line number silently re-points at the wrong statement
+      when you type above it, so every draft change is diffed and the dots are
+      **remapped** (a breakpoint inside the edited span is dropped, not guessed at).
+      They persist in the tab's `ViewerState` — same plumbing as the reader's scroll
+      position, and no backend migration (Rust's `TabEntry` flattens `extra`).
+    - **`Ctrl`/`Cmd`+Click follows a name to its `def`** across files, reusing the
+      #49/#50 link machinery (`linkRanges` + `onFollowLink`) and `jumpToSource` — so
+      it opens in the same subwindow, and works into a detached window. The resolver
+      is deliberately **lexical, not type-inferring**: it walks the import graph
+      (relative levels, aliases, `__init__` re-exports, src-layout) and matches
+      `def`/`class`/module-level bindings. `self.method` resolves in-file. Its honesty
+      is the point — only names it can actually follow are underlined, so the
+      affordance never lies, and `obj.method()` on a local simply isn't a link.
+    - **Which Python it runs** (`commands/python.rs`) is the part that decides whether
+      Run is trustworthy at all: a script run with the bare system `python3` when its
+      deps live in a venv fails with `ModuleNotFoundError`, and that reads as "the Run
+      button is broken", not "wrong interpreter". The backend owns the precedence as
+      the **single** source of it — the frontend asks (`python_interpreter_for`) and
+      never re-derives, since two rankings that can disagree is a bug waiting to
+      happen. A project's pinned interpreter always wins (and then costs no probing);
+      otherwise auto-detect ranks **in-tree venv → poetry → active `VIRTUAL_ENV`/
+      `CONDA_PREFIX` → pyenv → system**. A **named conda env is offered but never
+      auto-picked**: choosing one of N unrelated envs on the user's behalf is a guess,
+      and a wrong guess here is indistinguishable from a bug. Pinning is per project
+      (pill ▸ **Python interpreter…**, stored like the sandbox spec — `projects.json`
+      mirror + `project.json`); the dialog leads with Auto-detect and *shows what it
+      currently resolves to*, rather than asking the user to trust an invisible
+      decision. A **remote** project probes the **host** (one constant `sh` script via
+      `run_remote_script`, so it is one SSH round trip, not six) — the interpreter that
+      matters is the one on the machine the run tab actually runs on.
+    - **Gated** behind the experimental `python_run_debug` flag (`lib/experimental.ts`:
+      off for everyone, on in debug mode). Run *executes a file* one click from an
+      editor, so it is opt-in rather than something found by mis-clicking. Go-to-
+      definition is deliberately **not** gated — it reads, it never runs anything.
+    - [x] 🤖 Automated test (`PythonIntel` — imports/defs/lexer/breakpoint remap +
+      resolution incl. circular re-export; `PythonRun` — command building, both
+      platforms; Rust `commands::python` — conda/probe parsing, ranking, and that a
+      named conda env is never auto-selected; `PythonViewer` — the real UI: gutter
+      click sets/snaps/clears a dot, Run/Debug launch the right tab into the file's own
+      scope with the resolved interpreter, Ctrl+Click opens the sibling module at its
+      `def`, and the flag-off case shows none of it)
+    - [ ] 🖐️ Manual test — **the pdb round trip is the one to watch**: set two
+      breakpoints, hit Debug, confirm it halts on the first and `c` reaches the
+      second. Then check interpreter selection on a project that actually needs it
+      (a script importing a dep that only exists in a venv/conda env — and that
+      pinning one in the pill dialog sticks across a restart), that Run on a
+      **remote (SSH)** project runs on the host with the *host's* interpreter, and
+      that Ctrl+Click into a package (`from .pkg import thing` re-exported by its
+      `__init__`) lands on the real definition.
+
+88. **Native YAML/JSON viewer: an editable structure tree.** Give `.yaml`/`.yml`/
+    `.json` the same shape markdown has — a rendered half and a source half behind
+    one toggle — except that the rendered half is *editable*: rename a key, retype
+    a value, add a key or a list item (with a type picker: text/number/boolean/
+    null/map/list), reorder siblings, delete a subtree. Source is the unchanged
+    code editor, so these files keep everything they already had (highlighting,
+    format, the JSON/YAML validation banner, blame, compare, autocomplete).
+
+    - **The tree edits the TEXT, not a model of it** (`lib/viewers/yaml.ts`): every
+      action is a surgical splice back into the draft. Re-serializing the parsed
+      model — the obvious shortcut, and what most YAML editors do — rewrites the
+      whole file and **drops every comment in it**, which for a config file is the
+      one thing you must not do. Splicing is also what makes Tree and Source two
+      views on ONE draft: switching converts nothing, and save / undo / redo /
+      autosave / the external-change banner keep working on the text underneath
+      without either mode knowing the other exists. A tree edit is an ordinary undo
+      step.
+    - **Both of YAML's syntaxes are first-class, because real files mix them:**
+      *block* (`key:` / `- item`, indentation-structured) and *flow* (`{a: 1,
+      b: [2, 3]}` — which is exactly **JSON**, inline or spread over twenty lines).
+      A flow collection parses into real map/seq nodes with real children, which is
+      what makes a JSON-formatted `.yml` — and a `.json` file, the same thing — a
+      tree instead of one opaque blob. (The first cut only *tolerated* flow: it
+      rendered a multi-line `{` as a single un-editable scalar. That was the bug.)
+      **Which syntax a node is written in decides how it is edited** — block splices
+      LINES, flow splices its SPAN — and the tree keeps the author's choice: adding
+      to `[a, b]` yields `[a, b, c]`, never a silent rewrite into block; deleting
+      from it takes the separating comma with it. Every node therefore carries
+      absolute offsets; block nodes additionally carry the lines they own.
+    - **JSON is a dialect, not a second viewer.** `.json` routes to the same tree
+      with `strict` set: no plain scalars, so keys and strings are always quoted and
+      only numbers/bools/null go bare. An empty `[]`/`{}` is a real (empty) flow
+      collection that grows children in place, in either dialect.
+    - **What it offers, it can do.** A construct it can render but not rewrite
+      safely — an anchor, an alias, a merge key, a plain scalar continued across
+      lines — parses to an `editable: false` node that shows its value as text with
+      *no control behind it* (labelled "source only"), rather than an input that
+      would corrupt the file. A line it cannot classify at all fails the parse and
+      the tree defers to Source, naming the line. Same rule as the Python
+      go-to-definition underline: the affordance never lies.
+    - **Adding is where the types live.** A new entry is written with the literal
+      its picked type demands — so "no" and "8080" chosen as *text* come out quoted,
+      which is what makes them the strings the user meant. A key that already holds
+      a value refuses a child rather than silently destroy it.
+    - Opting the viewer out (#48) falls back to the **plain code editor**, not the
+      external app (`VIEWER_FALLBACK`) — turning off the tree is a vote against the
+      tree, not against editing YAML/JSON in Eldrun.
+    - [x] 🤖 Automated test (`YamlModel` — parse/edit ops: comments, quoting style,
+      CRLF and no-trailing-newline round-trips, block scalars, `- key:` items,
+      anchors, multi-doc; flow: inline and multi-line collections, nesting, add
+      inline-vs-on-its-own-line, delete-with-comma, span-swap reorder, unclosed
+      bracket refused; JSON: whole-document parse, strict writing, empty-file seed;
+      and that an unsupported construct is refused rather than guessed.
+      `YamlViewer` — the real UI: a `.yaml` opens in the tree, an edit saves the
+      file with its comments intact, add/rename/delete/reorder, Source shows the
+      tree's edit and it undoes like a typed one, a JSON-formatted `.yml` renders as
+      a tree (the regression), and a `.json` file writes the strict dialect.
+      `InternalViewer` — `.yaml`/`.yml`/`.json` route to the tree, and the opt-out
+      falls back to the code editor)
+    - [ ] 🖐️ Manual test — open a real config with comments (a CI workflow, a
+      `docker-compose.yml`, a `package.json`): edit a value in the tree and confirm
+      the comments and layout are untouched, that Source shows the same edit, and
+      that `Ctrl`+`Z` walks it back. Check a flow/JSON-formatted file adds and
+      deletes in its own style, and that a file with an anchor/merge key
+      (`<<: *base`) renders those rows read-only instead of offering a broken input.
+
+89. **CSV table viewer: a separator you can name, and cells you can edit.** The
+    table viewer (#40) read every `.csv` as comma-delimited because that is what
+    the *extension* implies — so a `;`- or `|`-delimited file (a European export,
+    a database dump) split into rows but not into **columns**, and arrived as one
+    tall single-column table. Four things follow from fixing that properly:
+
+    - **The separator is sniffed, and stays overridable** (`sniffDelimiter`). Each
+      candidate (`,` `;` `\t` `|`) is scored by parsing a sample *with that
+      candidate* — so a comma inside a quoted field can't fool the `;` reading —
+      and asking how rectangular the result is. A character that never splits a row
+      is rejected however consistently it fails to appear, which is what stops `,`
+      from "winning" a semicolon file with a perfect score of one column per row.
+      The header offers Auto / Comma / Semicolon / Tab / Pipe / a **custom
+      character**. An explicit override persists per tab (`ViewerState.delimiter`);
+      Auto deliberately does not, so the sniffer stays free to read better later.
+    - **Cells are editable, and an edit is a SPLICE** (`replaceCell` /
+      `insertRowAfter` / `deleteRow`) into the text draft `useEditableFile` already
+      owns — the same bargain #88 strikes for YAML comments. Re-serializing the
+      parsed rows would rewrite every field in the file, normalising away each
+      one's original quoting and the file's line endings, to change one cell. So
+      the table is a **view on the text**: a cell edit is an ordinary
+      dirty/undoable/autosaved/`Ctrl`+`S` change, and the bytes nobody touched are
+      still there. It is also why sorting and filtering carry each row's **source
+      index** (`RowRef`) — a splice must address the row a cell came *from*, not
+      the row it currently occupies on screen.
+    - **Only the visible rows render.** The old cap ("showing first 2000 rows")
+      is gone; the body is windowed against the scroll position, so a million-row
+      CSV is fully browsable. The column widths are therefore measured over the
+      whole file *up front* — sizing them to what happens to be on screen would
+      resize every column as the reader scrolled.
+    - **A filter box**, matching any cell case-insensitively, and a row-number
+      gutter showing the source row (with a delete, plus `+ Row` in the header).
+    - **Columns hide from a list of their names** (`ColumnsMenu`): click a name to
+      hide that column, click it again to bring it back. It is a *multi*-select, so
+      it does not close on a click — hiding six of twenty columns is one visit to
+      the menu, not six — and a hidden column stays listed, struck through, because
+      the list is the only way back. Two consequences: the row **filter searches
+      only the visible columns** (a row matched on a hidden cell would appear with
+      nothing on it to explain why), and hiding is dropped when the **delimiter**
+      changes, since a hidden column is only an *index* and a different separator
+      cuts the row into different columns. The rendered columns keep their original
+      indices rather than being re-numbered, so an edit still addresses the column
+      the cell came from.
+
+    - [x] 🤖 Automated test (`table.ts` — sniffing: semicolon/pipe/tab/comma, a
+      comma inside a quoted `;` field, the single-column fallback; spans: quoted
+      fields, BOM offsets, CRLF, terminated-vs-unterminated final row; edits:
+      quoting only when needed, other cells' quoting left alone, CRLF preserved,
+      ragged-row padding, insert/delete round-trips; filter/sort keeping the
+      source index; the filter scoped to the visible columns)
+    - [ ] 🖐️ Manual test — open a real `;`-delimited export and confirm it opens
+      **in columns** with `Auto (Semicolon)` shown; force the separator to Comma
+      and back and watch the columns re-cut; set a custom one. Edit a cell in a
+      quoted CSV and confirm in Source that only that field changed. Scroll a
+      large CSV to the bottom (columns must not resize as it scrolls). Sort, then
+      filter, then edit a visible cell — the change must land on the row it was
+      shown in, not the row at that screen position. Hide a few columns from the
+      Columns list, confirm they come back on a second click and survive a reopen,
+      and that editing a cell to the *right* of a hidden one still writes the right
+      field.
+    - [ ] **Deferred:** inserting/deleting a **column** (a row op is one splice; a
+      column op is one splice per row, and every splice invalidates the offsets
+      after it — the same constraint `moveNodeTo` faces in `yaml.ts`). Editing an
+      `.xlsx` also stays out: it arrives pre-parsed from `calamine`, with no source
+      text for a splice to land in.
+
+---
+
+90. **Native presenter ("deck"): a PDF-based presentation editor and presenter.**
+    A TeX/PDF-first presentation surface, behind the experimental
+    `deck_presenter` flag. Plan and rationale: `docs/deck_presenter_plan.md`.
+    Three separable halves: **generation** (a base PDF from `.tex`, from an
+    imported PDF, or from a generated starter template), **design** (editable
+    object layers — text with list styles, images, shapes, single-path icons —
+    with snapping and alignment guides), and **presenting** (fullscreen, speaker
+    notes, per-object build steps, and **GIF interstitials**: a clip that plays
+    *between* two slides, which is the only way a TeX-generated PDF can carry
+    animation at all).
+
+    The structural decision is that the **sidecar is the document**: layers live
+    in `talk.eldeck.json` beside `talk.pdf`, never inside it, because `latexmk`
+    rewrites the PDF on every compile. Slides re-anchor across a recompile by
+    SyncTeX source line (already emitted, previously thrown away) and fall back
+    to a content fingerprint; anything that cannot be placed is set aside in a
+    detached bin rather than dropped.
+
+    - [x] **Phase 0** — experimental flag (TS + Rust), `*.eldeck.json` viewer
+      registration (matched on the *filename*: the backend's `extension` is only
+      the last dotted component, so a deck arrives claiming to be `.json`).
+    - [x] **Phase 1** — `lib/viewers/deck/model.ts` (pure object/slide ops, the
+      presenter sequence) and `sidecar.ts` (defensive parse, fingerprinting,
+      re-anchoring, detached bin).
+    - [x] **Phase 2** — `DeckStage` (base page, object layer, select/move/resize/
+      rotate/z-order, marquee) and `deck/snap.ts` (page/margin/object/equal-gap/
+      same-size snapping with painted guides).
+    - [x] 🤖 Automated test — 119 cases across `DeckModel`, `DeckSidecar`,
+      `DeckSnap`, `DeckTransform`, `DeckExport` and `DeckTemplate`. Notable:
+      re-anchoring when a slide is inserted, SyncTeX beating a stale fingerprint,
+      ambiguous fingerprints being refused, orphan layers detached not dropped,
+      the y-flip and rotate-about-centre worked by hand, wrap parity, and every
+      export limitation surfacing as a warning.
+    - [x] **Phase 3** — text (list styles + standard-14 metric wrapping via
+      `deck/fonts.ts`, shared with the exporter so the export cannot reflow),
+      images, `deck/shapes.ts`, and `deck/icons.ts` (~80 icons, directional
+      variants derived by rotation) with a searchable picker + property inspector.
+    - [x] **Phase 4** — generation: **from a PDF** (the PDF viewer's "Present"
+      button writes the sidecar and opens it), **from TeX** (a `.tex` compiles to
+      a PDF tab, which then presents), and **from blank** (a deck with no plate
+      offers to write a starter Beamer `.tex` and compile it — it never
+      overwrites an existing one). Plus a **10-minute timeout for `compile_tex`**
+      with pipe-draining reader threads, so a wedged `latexmk` can no longer hold
+      a Tauri worker for the session.
+    - [x] **Phase 5** — `deck/export.ts`, the single pdf-lib flatten, on top of
+      `deck/transform.ts` (the bottom-left flip and rotate-about-centre anchor,
+      which existed nowhere in the repo). Reports what PDF cannot do — a cropped
+      `cover` image, a missing icon — instead of dropping it silently.
+    - [x] **Phase 6** — animate mode (a separate mode, as specified): per-object
+      build steps with numbered badges, slide transitions, and **GIF
+      interstitials** — `Slide.after`, a clip that plays *between* two slides as
+      its own stop, which is the only way a TeX-generated PDF can carry animation.
+      Exports as its poster frame.
+    - [x] **Phase 7** — the presenter: fullscreen portal, `sequence()`-driven
+      navigation (so `←` steps a build backwards rather than losing the slide),
+      speaker notes + elapsed timer, overview grid, black/white screens,
+      type-a-number-to-jump, and `PresentationOverlay`'s laser + marker reused
+      verbatim.
+    - [x] **Dual-window presenter** (`D` / ⧉): a second OS window shows the
+      audience view — fullscreen on the first monitor the main window is *not*
+      on — while the presenter window becomes the speaker's console (current
+      slide, next slide still-preview, notes, elapsed + wall clock, build
+      indicator). Deliberately **not** a detached subwindow (#42): a popout is
+      *parked* when its project goes inactive, which mid-talk would blank the
+      projector. One owner, two heaps — the presenter window owns the stop, the
+      audience window renders what it is told and forwards its own keys back
+      (`lib/viewers/deck/present.ts`, pure + tested), so the two displays cannot
+      drift apart. The deck crosses as its serialized sidecar; the base PDF,
+      images and GIF frames do not — the audience window loads those itself.
+    - [ ] **Known gap:** the laser/marker overlay is drawn on the presenter
+      window and is **not** mirrored to the audience one, so in dual-window mode
+      the room does not see the pointer. Needs the stroke/laser stream to cross
+      windows (the `DETACHED_DRAG_*` cursor stream is the precedent).
+    - [ ] 🖐️ Manual test — open a `.eldeck.json` beside a compiled PDF; drag,
+      resize and rotate objects and confirm the guides name the right reason;
+      recompile the `.tex` with a slide inserted and confirm layers follow their
+      slides; confirm the autosave lands (there is no save button by design).
+    - [ ] 🖐️ Manual test (dual-window, **on real hardware with a projector or
+      second monitor**) — `D` opens the audience window fullscreen on the *other*
+      display, not over the notes; advancing on either window moves both; `←`
+      steps a build backwards on both; `B`/`W` blank the audience screen too;
+      closing the audience window from the WM drops back to one screen without
+      ending the talk; `Esc` ends the talk and takes the audience window with it;
+      opening the second display twice re-uses one window. With **one** monitor
+      it opens windowed and decorated, draggable onto the projector.
+    - [ ] **Known gap:** `compile_tex` is **local-only** (no remote dispatch), so
+      a remote project must compile on its local mirror.
diff --git a/todo/group-n.md b/todo/group-n.md
new file mode 100644
index 0000000..fe84219
--- /dev/null
+++ b/todo/group-n.md
@@ -0,0 +1,27 @@
+## Group N — Internationalization (i18n)
+*Files: `src/lib/i18n.ts` (the translation store — flat `lang → key → text`
+maps for en/de/es/fr/it), every component under `src/components/`. Full
+resumable plan: [`docs/i18n_translation_plan.md`](../docs/i18n_translation_plan.md).*
+
+92. **Full app-wide translation coverage.** The i18n system
+    (`src/lib/i18n.ts`) is complete and dependency-free, but was originally
+    wired into only the Settings dialog's main panel — every sub-panel and
+    every other component in the app hardcoded English text, which is what
+    the user saw as "language settings only changing half of the
+    descriptions". **In progress**, tracked file-by-file in the plan doc:
+    Settings dialog + sub-panels, all of `components/layout/`, all of
+    `components/common/`, and 11 of 16 files in `components/projects/`
+    (including `ProjectPill.tsx`, the app's largest component) are done
+    (~860 keys, 5-language parity verified, `tsc`/vitest green throughout).
+    Remaining: 5 files in `components/projects/`, then
+    `components/header/`, `tabs/`, `calendar/`, `files/`,
+    `embed/`+`embed/deck/`+`embed/pdf/`, `monitoring/`+`stats/`, `App.tsx`,
+    plus restructuring the hint/tour/lesson content data files
+    (`src/lib/hints.ts`, `tour.ts`, `lessons.ts`) which hold real UI prose as
+    plain strings today. The plan doc has the exact batch-script methodology,
+    key-naming conventions, and a note on a concurrent-editing hazard hit
+    mid-session (transient compile errors / a `git reset --hard` in another
+    session's working tree, both resolved) — read it before resuming rather
+    than re-deriving the approach.
+
+---
diff --git a/todo/group-o.md b/todo/group-o.md
new file mode 100644
index 0000000..26478fc
--- /dev/null
+++ b/todo/group-o.md
@@ -0,0 +1,76 @@
+## Group O — Project Security & Permissions (new feature)
+*Files: `src-tauri/src/commands/projects.rs` (create/import), `schema/project.rs`
++ `schema/settings.rs` (new security/permission fields), `ProjectSwitcher.tsx`
+(import/add dialog) + a project-settings "Security" area, download-routing in
+`services/project_runtime.rs`/`commands/`. Distinct from the SSH "no in-app
+passwords" stance — this is per-project policy. Ties into Group G (remote/agent
+auth) and the local/remote git push axis (#21).*
+
+58. **Security stages for project import/add.** Offer graded security modes when
+    adding/importing a project, stored in project settings:
+    - **Highest** — only local models allowed; no git push (optionally no git,
+      no scaffolds).
+    - **Restricted** — a checkable allow-list of models; no git push (optionally
+      no git, no scaffolds).
+    - **Lowest** — everything allowed.
+    Surface as a "Security" area in project settings and enforce it where agents
+    are spawned and where pushes happen.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+59. **Per-project remote-control toggle (default off).** A per-project switch to
+    enable/disable agent remote control (Claude, …), defaulting to **off**.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+87. **Per-tab Plan/Auto agent mode. (DONE ✅ · 🧪 Untested)** A third authority axis
+    beside the Docker sandbox (OS containment) and tab locality (where it runs):
+    how much authority the *agent* has. An agent tab carries an optional
+    `agentMode` — **Plan** (`--permission-mode plan`: reads and proposes, never
+    edits) or **Auto** (`acceptEdits`: edits apply, shell/network still ask) —
+    surfaced as a clickable badge in the tab strip, so one tab plans while another
+    does the work and each comes back in its mode after a restart. Absent = the
+    agent's own ask-each-time default, which is every pre-existing tab.
+    - Behind the experimental global setting `agent_mode_toggle` (default **off**).
+    - **Claude only**, by construction: the mode is a launch flag, so switching one
+      respawns the agent, and that is only non-destructive for an agent that
+      resumes its conversation on respawn (`resolve_claude_session_impl` rewrites
+      `--session-id` → `--resume`). Gemini has `--approval-mode` but no resume — a
+      toggle there would silently destroy the chat. Codex resumes but has no plan
+      mode, only a read-only sandbox that approximates one. The capability table in
+      `components/tabs/agentModes.ts` is the single gate for adding more.
+    - Known cost: the respawn loses xterm scrollback (the conversation is resumed,
+      the terminal's raw history is not). A busy tab confirms before restarting.
+    - Follow-ups: an `agent_default_mode` setting so new tabs *start* in Plan or
+      Auto (would make the badge purely two-state); Codex once `--sandbox
+      read-only`/`--full-auto` are verified to be accepted on `codex resume`.
+    - [x] 🤖 Automated test (`src/__tests__/AgentMode.test.ts`)
+    - [ ] 🖐️ Manual test
+
+60. **Never manipulate the browser download path. (DONE — removed.)** Eldrun must
+    not touch any browser's download directory. The `commands/downloads.rs` module
+    that edited Firefox `prefs.js` / Chromium `Preferences` was removed entirely
+    (file, `mod` decl, and handler registration). Routing a download into a project
+    is a security risk if the file is then pushed with the project's git, and even
+    the "reset to `~/Downloads`" path still wrote into browser config — so we leave
+    browser download settings fully alone.
+
+86. **Docker sandbox on Windows (currently refused).** The sandbox is Unix-only:
+    `services::sandbox` is `#[cfg(unix)]` and `pty_spawn` returns a clear error on
+    Windows rather than silently spawning an agent unsandboxed that the user asked
+    to sandbox. It was never actually functional there — `staged_config_mounts` and
+    `rw_mounts` bind host paths straight into a **Linux** container, so on Windows
+    the container-side destination came out as a Windows host path
+    (`C:\Users\…\.claude\settings.json`), which means nothing inside the container
+    and whose drive colon also makes the `src:dst` mount string ambiguous;
+    `host_uid_gid()` is equally meaningless there. CI only surfaced this by
+    accident, through a test assertion rather than the feature itself. To support
+    it: translate host paths to Docker Desktop's container view (`C:\x` → `/c/x`,
+    or a WSL2 path), decide what `--user` should be on Windows (likely: omit it),
+    and re-enable the module plus its `staged_config_mounts` test for Windows.
+    Needs a real Docker Desktop box to verify — it cannot be validated from CI or
+    from a Linux dev host. Ties into Group H (Windows parity).
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+---
diff --git a/todo/group-p.md b/todo/group-p.md
new file mode 100644
index 0000000..6b3eddd
--- /dev/null
+++ b/todo/group-p.md
@@ -0,0 +1,29 @@
+## Group P — Git Hosting: Multi-Host Publishing (new feature)
+*Builds on Group D.10 (#22 publish flow). Files: `src-tauri/src/commands/github.rs`
+(`github_publish`, currently GitHub/`gh`-only), `git_hosting` creds, `ProjectPill.tsx`
+(the "Publish to GitHub…" menu entry + Publish window + per-project "Git hosting…"
+override), `src/stores/projects.ts` (`publishProject`), settings git-hosting
+profile (URL + token). Today publishing is hardcoded to the GitHub `gh` CLI
+(`gh repo create … --source=. --push`); there is no GitLab or generic remote path.*
+
+79. **Publish to GitLab and to a generic remote.** Generalize the GitHub-only
+    publish flow so a project can be connected to other hosts:
+    - **GitLab support.** Add a GitLab publish path (via the `glab` CLI mirroring
+      the `gh` approach, or the GitLab REST API + token from the git-hosting
+      profile) that creates the project repo and pushes. Pick the host from the
+      git-hosting profile rather than assuming GitHub.
+    - **Generic remote URL.** Add a "set remote URL" path for self-hosted /
+      arbitrary hosts: `git remote add origin <url>` + `git push -u origin
+      <branch>`, no host CLI required — for users who already created the empty
+      remote repo themselves.
+    - **UI.** Rename the pill's "Publish to GitHub…" entry to a host-agnostic
+      "Publish…"/"Connect remote…" that offers GitHub / GitLab / custom URL,
+      reusing the existing visibility picker and per-project git-hosting override.
+    - **Backend.** Decouple `github_publish` from `gh`: dispatch on a host enum,
+      keep the SSH-work-remote case (run the host CLI where the bytes live), and
+      keep recording `git_type = remote-<visibility>` on success.
+    - [ ] 🤖 Automated test — host-dispatch + argv-escaping unit tests per host
+      (mirroring `commands/github.rs` `shell_quote` tests); full publish flow stays manual.
+    - [ ] 🖐️ Manual test — publish a local project to GitLab and to a custom
+      remote URL; confirm the repo is created/pushed and `git_type` flips to
+      `remote-<visibility>`.
diff --git a/todo/group-r.md b/todo/group-r.md
new file mode 100644
index 0000000..4881c2f
--- /dev/null
+++ b/todo/group-r.md
@@ -0,0 +1,31 @@
+## Group R — Right Panel: Polish & App-Window Tracking
+*Files: `src/components/layout/RightPanel.tsx`, `src/styles/themes.css`,
+`src/stores/windows.ts`, backend `commands/apps.rs` + window tracking in
+`services/window_service.rs`/`platform/x11.rs`. The pin toggle itself is done
+(Group D.13 / #37); these are follow-on polish + a tracking-display bug.*
+
+63. **Pin needle black in dark fancy mode.** The right-panel pin (📌) needle isn't
+    legible in the dark "fancy" theme — make it black (or otherwise contrast-fix)
+    in that mode.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+64. **[Bug] Right-panel Apps list must drop closed app windows.** A project-opened
+    external app appears in the right-panel "Apps" list but doesn't disappear when
+    the app/window is closed. Fix the add/remove lifecycle so the list reflects
+    live windows. Doubles as a window-tracking test surface: on hover, show the
+    entry's window id, monitor id, and z-order.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
+
+65. **Nested-repo git view: remote support.** The right panel's git section now
+    auto-detects a nested git repo under the browsed folder (`git_repo_root`) and
+    re-roots status/commit/push/history at it, with a toggle back to the project
+    repo — but **local projects only**. Extend to remote (SSH) projects: run
+    `git rev-parse --show-toplevel` over SSH in `remote_path/rel`, and give
+    `remote_target_for_dir` a way to map a nested host toplevel back to the
+    project's `RemoteSpec` (currently a directory reverse-lookup that won't match
+    a deeper subpath). Related out-of-scope note: per-file tree git markers stay
+    project-scoped, not re-rooted per nested repo.
+    - [ ] 🤖 Automated test
+    - [ ] 🖐️ Manual test
diff --git a/todo/group-s.md b/todo/group-s.md
new file mode 100644
index 0000000..032a7f6
--- /dev/null
+++ b/todo/group-s.md
@@ -0,0 +1,126 @@
+## Group S — Local Agents via Ollama Integrations (`ollama launch`)
+*New feature. Generalizes the existing single "Local Model" tab (Mistral `vibe`)
+into a family of local, Ollama-backed agent tabs — Claude Code, Hermes, OpenClaw,
+OpenCode — that behave exactly like the vibe local-agent tab does today (per
+active local model, `kind: "local_agent"`, same persistence/rehydrate path).*
+
+*Files: `src/components/tabs/TabBar.tsx` (`AGENT_ITEMS`, `handleOllamaModel`),
+`src/components/layout/LocalModelMenu.tsx`, `src/stores/tabs.ts` (`cmdToKind`,
+`RESUMABLE_AGENTS`, `isRestorableTab`), `src/components/layout/CenterPanel.tsx`
+(local_agent rehydrate), `src/components/layout/SettingsSubPanels.tsx` (Ollama
+panel), backend `commands/ollama.rs`, `terminal/mod.rs`, `lib.rs`.*
+
+**Key enabler — already on disk.** The installed `ollama` (≥0.30.x) ships
+`ollama launch <integration> [--model <model>] [--config] [-- <extra>]`, which
+**installs the agent if missing, configures it against the local Ollama endpoint,
+then launches it**. `ollama launch --help` lists (among others): `claude`
+(Claude Code), `hermes`, `openclaw`, `opencode`, plus `codex`, `copilot`, `cline`,
+`qwen`, `droid`, `kimi`, `pi`. This removes the bespoke per-agent config the vibe
+path needs (`prepare_local_agent` writing `VIBE_HOME/config.toml`): for these
+agents Eldrun just spawns `ollama launch <id> --model <model>` in a PTY. `vibe`
+is **not** an `ollama launch` integration, so it keeps its current dedicated path
+unchanged; the new agents are additive.
+
+**Prerequisites & caveats (document in the Ollama panel + per item):**
+- Every one of these needs Ollama to actually **load** a model. The dev machine's
+  Ollama install is currently broken (missing `llama-server` runner) — none will
+  work until that's reinstalled. Gate the UI on `ollama_status` ("loaded"/"idle")
+  and surface the broken-runner message (`friendly_ollama_error`).
+- These are **agentic** (file edit / bash / tool calls); they need a tool-calling
+  model and a **≥64k context window**. `ollama launch` configures `num_ctx` for
+  the chosen model; recommend `qwen2.5-coder`/`qwen3*` in the picker, warn on tiny
+  models.
+- Endpoint differences are handled by `ollama launch`, but note them: Claude Code
+  uses Ollama's **Anthropic Messages API** compat (`ANTHROPIC_BASE_URL=
+  http://localhost:11434`, `ANTHROPIC_AUTH_TOKEN=ollama`) — this **supersedes** the
+  earlier "needs a LiteLLM proxy" note; Hermes/OpenCode use `/v1`; OpenClaw uses
+  the **native** `/api/chat` (its `/v1` tool-calling is unreliable). OpenClaw is a
+  messaging-gateway agent more than a pure coding agent — include it as requested
+  but rank it lowest.
+
+72. **Generalize `local_agent` into a multi-agent registry.** Introduce a single
+    source of truth, e.g. `LOCAL_AGENTS: { id, label, launch, endpointNote,
+    resumable }[]` in `src/stores/tabs.ts` (exported), with rows for `claude`,
+    `hermes`, `openclaw`, `opencode` (launch via `ollama launch <id>`), and the
+    existing `vibe` flagged `special: true` so it keeps its `prepare_local_agent`
+    path. Spawn shape for the new ones: `addTab({ cmd: "ollama",
+    args: ["launch", id, "--model", model], kind: "local_agent",
+    label: <model> })`. Keep `kind: "local_agent"` so all the existing tiling,
+    activity-spinner, and persistence wiring applies untouched.
+    - [ ] 🤖 Automated test — registry has the 4 agents + vibe; each non-vibe row
+      builds argv `["launch", id, "--model", m]`.
+    - [ ] 🖐️ Manual test
+
+73. **Backend: `local_launch_argv` + ensure-running command.** Add a pure helper
+    in `commands/ollama.rs`, `local_launch_argv(integration, model) ->
+    Result<Vec<String>, String>`, that (a) checks `integration` against an
+    allowlist of supported `ollama launch` ids, (b) runs the existing
+    `validate_model_name(model)` (reuse — guards the argv), and (c) returns
+    `["launch", <id>, "--model", <model>]`. Expose a thin command
+    `prepare_local_launch_agent` that calls `ensure_ollama_running` then returns
+    the argv (mirrors `handleOllamaModel`'s `ensure_ollama_running` step).
+    Register in `lib.rs`.
+    - [ ] 🤖 Automated test — `local_launch_argv` accepts known ids + valid model,
+      rejects unknown id and injection-y model names (extend the existing
+      `validate_model_name` tests).
+    - [ ] 🖐️ Manual test
+
+74. **`cmdToKind` + spawn path for `ollama launch` tabs.** Teach
+    `cmdToKind` (tabs.ts) that `cmd === "ollama"` with a `launch` first-arg maps to
+    `local_agent` (today it only knows `claude|codex|gemini|vibe`). Confirm the PTY
+    spawn in `terminal/mod.rs` inherits a PATH that includes `~/.local/bin`
+    (agents `ollama launch` installs land there — same concern as vibe); add it to
+    the spawn env if missing. No `VIBE_HOME` injection for these (only `vibe`).
+    - [ ] 🤖 Automated test — `cmdToKind("ollama", ["launch","claude",…])` →
+      `"local_agent"`; unchanged for plain `ollama`/`bash`.
+    - [ ] 🖐️ Manual test
+
+75. **Picker UI: choose which local agent runs the active model.** Today the
+    add-tab menu / `LocalModelMenu` launches exactly one runtime (vibe). With ≥5
+    options, add a submenu: "Local Agent ▸ [Claude Code · Hermes · OpenClaw ·
+    OpenCode · Mistral (vibe)]", each launching the **active** `settings.ollama_model`
+    via the matching path. Reuse the existing reveal/close + status-lamp scaffold
+    in `LocalModelMenu.tsx`; gray out entries when `ollama_status` isn't
+    "loaded"/"idle". Optionally persist a `settings.default_local_agent`.
+    - [ ] 🤖 Automated test — picker renders one entry per `LOCAL_AGENTS` row;
+      selecting one dispatches the right spawn (argv vs vibe env).
+    - [ ] 🖐️ Manual test
+
+76. **Per-agent wiring — Claude Code, Hermes, OpenClaw, OpenCode.** With #72–#75 in
+    place each is one `LOCAL_AGENTS` row, but verify per agent: `claude` →
+    `ollama launch claude --model <m>` (Anthropic-compat, no `/v1`); `hermes` →
+    `ollama launch hermes --model <m>` (`/v1`, raises ctx); `opencode` →
+    `ollama launch opencode --model <m>` (`/v1`, writes `~/.config/opencode/
+    opencode.json`); `openclaw` → `ollama launch openclaw --model <m>` (native
+    `/api/chat`). First launch may run an interactive `ollama launch` setup —
+    decide per agent whether to pass `--config`/`--yes` (e.g. `droid --config`
+    "does not auto-launch"). Tab label e.g. `Claude Code · <model>`.
+    - **OpenClaw wired.** Added as a launch-only `LOCAL_DRIVERS` row in
+      `commands/ollama.rs` (`ollama launch openclaw --model <m>`, no fallback —
+      `ollama launch` installs+wires the gateway). Also registered as a standalone
+      installable agent in `commands/agents.rs` (`npm install -g openclaw`, bin
+      `openclaw`) and in `AGENT_ITEMS`/`AGENT_CMDS` so it appears in the regular
+      agent add-menu. Resume parity deferred to #77 (dropped on relaunch like vibe).
+    - [ ] 🤖 Automated test — table test: each id → expected argv + endpoint note.
+    - [ ] 🖐️ Manual test — each agent opens, sees the model, completes one edit.
+
+77. **Persistence / resume parity (follow-up).** Start at **vibe parity**: these
+    `local_agent` tabs are **not** resumable (dropped on relaunch like vibe today),
+    so `isRestorableTab` stays false for them — no change needed beyond confirming
+    they aren't accidentally caught by `RESUMABLE_AGENTS`. Track real resume as a
+    later step: `ollama launch codex --restore` exists, Claude Code has its own
+    `--resume`; map these into `RESUMABLE_AGENTS`/backend `resolve_*_session` only
+    after the live-session hook story (Group F #39d) is confirmed per agent.
+    - [ ] 🤖 Automated test — a launched `local_agent` tab for each new id is
+      filtered OUT by the persist filter (matches vibe).
+    - [ ] 🖐️ Manual test
+
+78. **Discoverability in the Ollama panel.** In `SettingsSubPanels.tsx` (Ollama
+    panel), add a short "Local agents" section listing the supported `ollama
+    launch` integrations with one-line descriptions + the 64k-ctx / tool-calling
+    caveat, and a note that they auto-install on first launch (so, unlike vibe,
+    no separate "Install …" button is required). Link the picker to it.
+    - [ ] 🤖 Automated test — n/a (static copy) or a render smoke test.
+    - [ ] 🖐️ Manual test
+
+---
diff --git a/todo/group-t.md b/todo/group-t.md
new file mode 100644
index 0000000..e4c4f5f
--- /dev/null
+++ b/todo/group-t.md
@@ -0,0 +1,27 @@
+## Group T — Smart / Native Shell Terminal (new feature, research done)
+
+*Files (future): `src/components/terminal/TerminalView.tsx`,
+`src-tauri/src/terminal/mod.rs`, `src-tauri/src/commands/ollama.rs`
+(new shell-completion command, distinct from existing `complete_text`).*
+
+- [ ] **Live incremental history-search overlay.** Auto-triggered
+  type-to-filter dropdown over the terminal (reuse the `createPortal`
+  overlay pattern from `FileTree.tsx`) instead of manual Ctrl+R; replays
+  shell history and injects the chosen line via the existing `pty_write`
+  path. No shell integration required.
+- [ ] **Local-model shell-command autocomplete overlay.** New Ollama-backed
+  completion command scoped to shell commands/history (separate from the
+  existing code-file `complete_text`), surfaced as an overlay a user can
+  accept into the PTY.
+- [ ] **Terminal font settings.** Font family/size is currently hardcoded
+  (`TerminalView.tsx`); only color scheme is configurable today. Add a
+  settings UI control.
+- [ ] ⛔ **Ghost-text autosuggestion + de-duplicated path display —
+  blocked pending design.** Requires the shell to emit OSC 133/7 semantic
+  prompt marks, which bash/zsh don't do by default; would need an
+  **opt-in, user-installed** shell-integration snippet (never an automatic
+  rc edit — violates the "no foreign app paths" policy). Needs a decision
+  on the opt-in install UX before scoping further (see prior art: Warp,
+  iTerm2, VS Code shell integration installers).
+
+---
diff --git a/vite.config.ts b/vite.config.ts
index aa3a415..6c21dc1 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -1,9 +1,29 @@
+import { fileURLToPath } from "node:url";
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 
 export default defineConfig(async () => ({
   plugins: [react()],
   clearScreen: false,
+  resolve: {
+    alias: [
+      // pdfjs-dist's package.json exposes only `main` (no `exports`/`module`),
+      // which Vite's package-entry resolver handles inconsistently across
+      // platforms — it fails on Windows ("Failed to resolve entry for package
+      // pdfjs-dist"). Point the bare specifier straight at the file `main`
+      // references. The regex anchors an exact match so subpath imports like
+      // `pdfjs-dist/build/pdf.worker.min.mjs?url` are left untouched.
+      {
+        find: /^pdfjs-dist$/,
+        replacement: fileURLToPath(
+          new URL(
+            "./node_modules/pdfjs-dist/build/pdf.mjs",
+            import.meta.url,
+          ),
+        ),
+      },
+    ],
+  },
   server: {
     port: 1420,
     strictPort: true,
diff --git a/vitest.config.ts b/vitest.config.ts
index 128959e..2a3c7f1 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -7,5 +7,11 @@ export default defineConfig({
     globals: true,
     environment: "jsdom",
     css: false,
+    setupFiles: ["./src/test-setup.ts"],
+    // The full suite runs heavy viewer renders + real-timer polls across many
+    // parallel forks; the 5s default test timeout is too tight under that load
+    // and trips otherwise-passing tests. Give them headroom.
+    testTimeout: 20000,
+    hookTimeout: 20000,
   },
 });